Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 13fcc683 authored by David Howells's avatar David Howells Committed by Al Viro
Browse files

afs: Add fs_context support 



Add fs_context support to the AFS filesystem, converting the parameter
parsing to store options there.

This will form the basis for namespace propagation over mountpoints within
the AFS model, thereby allowing AFS to be used in containers more easily.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent 06a2ae56

fs/afs/internal.h

+4 −4
Original line number Diff line number Diff line
@@ -36,15 +36,15 @@ 
struct pagevec;

struct afs_call;



struct afs_mount_params {

struct afs_fs_context {

	bool			rwpath;		/* T if the parent should be considered R/W */

	bool			force;		/* T to force cell type */

	bool			autocell;	/* T if set auto mount operation */

	bool			dyn_root;	/* T if dynamic root */

	bool			no_cell;	/* T if the source is "none" (for dynroot) */

	afs_voltype_t		type;		/* type of volume requested */

	int			volnamesz;	/* size of volume name */

	unsigned int		volnamesz;	/* size of volume name */

	const char		*volname;	/* name of volume to mount */

	struct net		*net_ns;	/* Network namespace in effect */

	struct afs_net		*net;		/* the AFS net namespace stuff */

	struct afs_cell		*cell;		/* cell in which to find volume */

	struct afs_volume	*volume;	/* volume record */
@@ -1274,7 +1274,7 @@ static inline struct afs_volume *__afs_get_volume(struct afs_volume *volume) 
	return volume;

}



extern struct afs_volume *afs_create_volume(struct afs_mount_params *);

extern struct afs_volume *afs_create_volume(struct afs_fs_context *);

extern void afs_activate_volume(struct afs_volume *);

extern void afs_deactivate_volume(struct afs_volume *);

extern void afs_put_volume(struct afs_cell *, struct afs_volume *);

fs/afs/mntpt.c

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <linux/mount.h>

#include <linux/namei.h>

#include <linux/gfp.h>

#include <linux/fs_context.h>

#include "internal.h"

fs/afs/super.c

+252 −208
Original line number Diff line number Diff line 
/* AFS superblock handling

 *

 * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved.

 * Copyright (c) 2002, 2007, 2018 Red Hat, Inc. All rights reserved.

 *

 * This software may be freely redistributed under the terms of the

 * GNU General Public License.
@@ -21,7 +21,7 @@ 
#include <linux/slab.h>

#include <linux/fs.h>

#include <linux/pagemap.h>

#include <linux/parser.h>

#include <linux/fs_parser.h>

#include <linux/statfs.h>

#include <linux/sched.h>

#include <linux/nsproxy.h>
@@ -30,19 +30,20 @@ 
#include "internal.h"



static void afs_i_init_once(void *foo);

static struct dentry *afs_mount(struct file_system_type *fs_type,

		      int flags, const char *dev_name, void *data);

static void afs_kill_super(struct super_block *sb);

static struct inode *afs_alloc_inode(struct super_block *sb);

static void afs_destroy_inode(struct inode *inode);

static int afs_statfs(struct dentry *dentry, struct kstatfs *buf);

static int afs_show_devname(struct seq_file *m, struct dentry *root);

static int afs_show_options(struct seq_file *m, struct dentry *root);

static int afs_init_fs_context(struct fs_context *fc);

static const struct fs_parameter_description afs_fs_parameters;



struct file_system_type afs_fs_type = {

	.owner			= THIS_MODULE,

	.name			= "afs",

	.mount		= afs_mount,

	.init_fs_context	= afs_init_fs_context,

	.parameters		= &afs_fs_parameters,

	.kill_sb		= afs_kill_super,

	.fs_flags		= 0,

};
@@ -63,22 +64,28 @@ static const struct super_operations afs_super_ops = { 
static struct kmem_cache *afs_inode_cachep;

static atomic_t afs_count_active_inodes;



enum {

	afs_no_opt,

	afs_opt_cell,

	afs_opt_dyn,

	afs_opt_rwpath,

	afs_opt_vol,

	afs_opt_autocell,

enum afs_param {

	Opt_autocell,

	Opt_cell,

	Opt_dyn,

	Opt_rwpath,

	Opt_source,

	Opt_vol,

};



static const match_table_t afs_options_list = {

	{ afs_opt_cell,		"cell=%s"	},

	{ afs_opt_dyn,		"dyn"		},

	{ afs_opt_rwpath,	"rwpath"	},

	{ afs_opt_vol,		"vol=%s"	},

	{ afs_opt_autocell,	"autocell"	},

	{ afs_no_opt,		NULL		},

static const struct fs_parameter_spec afs_param_specs[] = {

	fsparam_flag  ("autocell",	Opt_autocell),

	fsparam_string("cell",		Opt_cell),

	fsparam_flag  ("dyn",		Opt_dyn),

	fsparam_flag  ("rwpath",	Opt_rwpath),

	fsparam_string("source",	Opt_source),

	fsparam_string("vol",		Opt_vol),

	{}

};



static const struct fs_parameter_description afs_fs_parameters = {

	.name		= "kAFS",

	.specs		= afs_param_specs,

};



/*
@@ -190,71 +197,10 @@ static int afs_show_options(struct seq_file *m, struct dentry *root) 
}



/*

 * parse the mount options

 * - this function has been shamelessly adapted from the ext3 fs which

 *   shamelessly adapted it from the msdos fs

 */

static int afs_parse_options(struct afs_mount_params *params,

			     char *options, const char **devname)

{

	struct afs_cell *cell;

	substring_t args[MAX_OPT_ARGS];

	char *p;

	int token;



	_enter("%s", options);



	options[PAGE_SIZE - 1] = 0;



	while ((p = strsep(&options, ","))) {

		if (!*p)

			continue;



		token = match_token(p, afs_options_list, args);

		switch (token) {

		case afs_opt_cell:

			rcu_read_lock();

			cell = afs_lookup_cell_rcu(params->net,

						   args[0].from,

						   args[0].to - args[0].from);

			rcu_read_unlock();

			if (IS_ERR(cell))

				return PTR_ERR(cell);

			afs_put_cell(params->net, params->cell);

			params->cell = cell;

			break;



		case afs_opt_rwpath:

			params->rwpath = true;

			break;



		case afs_opt_vol:

			*devname = args[0].from;

			break;



		case afs_opt_autocell:

			params->autocell = true;

			break;



		case afs_opt_dyn:

			params->dyn_root = true;

			break;



		default:

			printk(KERN_ERR "kAFS:"

			       " Unknown or invalid mount option: '%s'\n", p);

			return -EINVAL;

		}

	}



	_leave(" = 0");

	return 0;

}



/*

 * parse a device name to get cell name, volume name, volume type and R/W

 * selector

 * - this can be one of the following:

 * Parse the source name to get cell name, volume name, volume type and R/W

 * selector.

 *

 * This can be one of the following:

 *	"%[cell:]volume[.]"		R/W volume

 *	"#[cell:]volume[.]"		R/O or R/W volume (rwpath=0),

 *					 or R/W (rwpath=1) volume
@@ -263,11 +209,11 @@ static int afs_parse_options(struct afs_mount_params *params, 
 *	"%[cell:]volume.backup"		Backup volume

 *	"#[cell:]volume.backup"		Backup volume

 */

static int afs_parse_device_name(struct afs_mount_params *params,

				 const char *name)

static int afs_parse_source(struct fs_context *fc, struct fs_parameter *param)

{

	struct afs_fs_context *ctx = fc->fs_private;

	struct afs_cell *cell;

	const char *cellname, *suffix;

	const char *cellname, *suffix, *name = param->string;

	int cellnamesz;



	_enter(",%s", name);
@@ -278,69 +224,174 @@ static int afs_parse_device_name(struct afs_mount_params *params, 
	}



	if ((name[0] != '%' && name[0] != '#') || !name[1]) {

		/* To use dynroot, we don't want to have to provide a source */

		if (strcmp(name, "none") == 0) {

			ctx->no_cell = true;

			return 0;

		}

		printk(KERN_ERR "kAFS: unparsable volume name\n");

		return -EINVAL;

	}



	/* determine the type of volume we're looking for */

	params->type = AFSVL_ROVOL;

	params->force = false;

	if (params->rwpath || name[0] == '%') {

		params->type = AFSVL_RWVOL;

		params->force = true;

	ctx->type = AFSVL_ROVOL;

	ctx->force = false;

	if (ctx->rwpath || name[0] == '%') {

		ctx->type = AFSVL_RWVOL;

		ctx->force = true;

	}

	name++;



	/* split the cell name out if there is one */

	params->volname = strchr(name, ':');

	if (params->volname) {

	ctx->volname = strchr(name, ':');

	if (ctx->volname) {

		cellname = name;

		cellnamesz = params->volname - name;

		params->volname++;

		cellnamesz = ctx->volname - name;

		ctx->volname++;

	} else {

		params->volname = name;

		ctx->volname = name;

		cellname = NULL;

		cellnamesz = 0;

	}



	/* the volume type is further affected by a possible suffix */

	suffix = strrchr(params->volname, '.');

	suffix = strrchr(ctx->volname, '.');

	if (suffix) {

		if (strcmp(suffix, ".readonly") == 0) {

			params->type = AFSVL_ROVOL;

			params->force = true;

			ctx->type = AFSVL_ROVOL;

			ctx->force = true;

		} else if (strcmp(suffix, ".backup") == 0) {

			params->type = AFSVL_BACKVOL;

			params->force = true;

			ctx->type = AFSVL_BACKVOL;

			ctx->force = true;

		} else if (suffix[1] == 0) {

		} else {

			suffix = NULL;

		}

	}



	params->volnamesz = suffix ?

		suffix - params->volname : strlen(params->volname);

	ctx->volnamesz = suffix ?

		suffix - ctx->volname : strlen(ctx->volname);



	_debug("cell %*.*s [%p]",

	       cellnamesz, cellnamesz, cellname ?: "", params->cell);

	       cellnamesz, cellnamesz, cellname ?: "", ctx->cell);



	/* lookup the cell record */

	if (cellname || !params->cell) {

		cell = afs_lookup_cell(params->net, cellname, cellnamesz,

	if (cellname) {

		cell = afs_lookup_cell(ctx->net, cellname, cellnamesz,

				       NULL, false);

		if (IS_ERR(cell)) {

			printk(KERN_ERR "kAFS: unable to lookup cell '%*.*s'\n",

			pr_err("kAFS: unable to lookup cell '%*.*s'\n",

			       cellnamesz, cellnamesz, cellname ?: "");

			return PTR_ERR(cell);

		}

		afs_put_cell(params->net, params->cell);

		params->cell = cell;

		afs_put_cell(ctx->net, ctx->cell);

		ctx->cell = cell;

	}



	_debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s",

	       params->cell->name, params->cell,

	       params->volnamesz, params->volnamesz, params->volname,

	       suffix ?: "-", params->type, params->force ? " FORCE" : "");

	       ctx->cell->name, ctx->cell,

	       ctx->volnamesz, ctx->volnamesz, ctx->volname,

	       suffix ?: "-", ctx->type, ctx->force ? " FORCE" : "");



	fc->source = param->string;

	param->string = NULL;

	return 0;

}



/*

 * Parse a single mount parameter.

 */

static int afs_parse_param(struct fs_context *fc, struct fs_parameter *param)

{

	struct fs_parse_result result;

	struct afs_fs_context *ctx = fc->fs_private;

	struct afs_cell *cell;

	int opt;



	opt = fs_parse(fc, &afs_fs_parameters, param, &result);

	if (opt < 0)

		return opt;



	switch (opt) {

	case Opt_cell:

		if (param->size <= 0)

			return -EINVAL;

		if (param->size > AFS_MAXCELLNAME)

			return -ENAMETOOLONG;



		rcu_read_lock();

		cell = afs_lookup_cell_rcu(ctx->net, param->string, param->size);

		rcu_read_unlock();

		if (IS_ERR(cell))

			return PTR_ERR(cell);

		afs_put_cell(ctx->net, ctx->cell);

		ctx->cell = cell;

		break;



	case Opt_source:

		return afs_parse_source(fc, param);



	case Opt_autocell:

		ctx->autocell = true;

		break;



	case Opt_dyn:

		ctx->dyn_root = true;

		break;



	case Opt_rwpath:

		ctx->rwpath = true;

		break;



	case Opt_vol:

		return invalf(fc, "'vol' param is obsolete");



	default:

		return -EINVAL;

	}



	_leave(" = 0");

	return 0;

}



/*

 * Validate the options, get the cell key and look up the volume.

 */

static int afs_validate_fc(struct fs_context *fc)

{

	struct afs_fs_context *ctx = fc->fs_private;

	struct afs_volume *volume;

	struct key *key;



	if (!ctx->dyn_root) {

		if (ctx->no_cell) {

			pr_warn("kAFS: Can only specify source 'none' with -o dyn\n");

			return -EINVAL;

		}



		if (!ctx->cell) {

			pr_warn("kAFS: No cell specified\n");

			return -EDESTADDRREQ;

		}



		/* We try to do the mount securely. */

		key = afs_request_key(ctx->cell);

		if (IS_ERR(key))

			return PTR_ERR(key);



		ctx->key = key;



		if (ctx->volume) {

			afs_put_volume(ctx->cell, ctx->volume);

			ctx->volume = NULL;

		}



		volume = afs_create_volume(ctx);

		if (IS_ERR(volume))

			return PTR_ERR(volume);



		ctx->volume = volume;

	}



	return 0;

}
@@ -348,39 +399,34 @@ static int afs_parse_device_name(struct afs_mount_params *params, 
/*

 * check a superblock to see if it's the one we're looking for

 */

static int afs_test_super(struct super_block *sb, void *data)

static int afs_test_super(struct super_block *sb, struct fs_context *fc)

{

	struct afs_super_info *as1 = data;

	struct afs_fs_context *ctx = fc->fs_private;

	struct afs_super_info *as = AFS_FS_S(sb);



	return (as->net_ns == as1->net_ns &&

	return (as->net_ns == fc->net_ns &&

		as->volume &&

		as->volume->vid == as1->volume->vid &&

		as->volume->vid == ctx->volume->vid &&

		!as->dyn_root);

}



static int afs_dynroot_test_super(struct super_block *sb, void *data)

static int afs_dynroot_test_super(struct super_block *sb, struct fs_context *fc)

{

	struct afs_super_info *as1 = data;

	struct afs_super_info *as = AFS_FS_S(sb);



	return (as->net_ns == as1->net_ns &&

	return (as->net_ns == fc->net_ns &&

		as->dyn_root);

}



static int afs_set_super(struct super_block *sb, void *data)

static int afs_set_super(struct super_block *sb, struct fs_context *fc)

{

	struct afs_super_info *as = data;



	sb->s_fs_info = as;

	return set_anon_super(sb, NULL);

}



/*

 * fill in the superblock

 */

static int afs_fill_super(struct super_block *sb,

			  struct afs_mount_params *params)

static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)

{

	struct afs_super_info *as = AFS_FS_S(sb);

	struct afs_fid fid;
@@ -412,13 +458,13 @@ static int afs_fill_super(struct super_block *sb, 
		fid.vnode	= 1;

		fid.vnode_hi	= 0;

		fid.unique	= 1;

		inode = afs_iget(sb, params->key, &fid, NULL, NULL, NULL);

		inode = afs_iget(sb, ctx->key, &fid, NULL, NULL, NULL);

	}



	if (IS_ERR(inode))

		return PTR_ERR(inode);



	if (params->autocell || params->dyn_root)

	if (ctx->autocell || as->dyn_root)

		set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);



	ret = -ENOMEM;
@@ -443,17 +489,20 @@ static int afs_fill_super(struct super_block *sb, 
	return ret;

}



static struct afs_super_info *afs_alloc_sbi(struct afs_mount_params *params)

static struct afs_super_info *afs_alloc_sbi(struct fs_context *fc)

{

	struct afs_fs_context *ctx = fc->fs_private;

	struct afs_super_info *as;



	as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);

	if (as) {

		as->net_ns = get_net(params->net_ns);

		if (params->dyn_root)

		as->net_ns = get_net(fc->net_ns);

		if (ctx->dyn_root) {

			as->dyn_root = true;

		else

			as->cell = afs_get_cell(params->cell);

		} else {

			as->cell = afs_get_cell(ctx->cell);

			as->volume = __afs_get_volume(ctx->volume);

		}

	}

	return as;

}
@@ -488,111 +537,106 @@ static void afs_kill_super(struct super_block *sb) 
}



/*

 * get an AFS superblock

 * Get an AFS superblock and root directory.

 */

static struct dentry *afs_mount(struct file_system_type *fs_type,

				int flags, const char *dev_name, void *options)

static int afs_get_tree(struct fs_context *fc)

{

	struct afs_mount_params params;

	struct afs_fs_context *ctx = fc->fs_private;

	struct super_block *sb;

	struct afs_volume *candidate;

	struct key *key;

	struct afs_super_info *as;

	int ret;



	_enter(",,%s,%p", dev_name, options);



	memset(&params, 0, sizeof(params));



	ret = -EINVAL;

	if (current->nsproxy->net_ns != &init_net)

		goto error;

	params.net_ns = current->nsproxy->net_ns;

	params.net = afs_net(params.net_ns);

	

	/* parse the options and device name */

	if (options) {

		ret = afs_parse_options(&params, options, &dev_name);

		if (ret < 0)

			goto error;

	}



	if (!params.dyn_root) {

		ret = afs_parse_device_name(&params, dev_name);

		if (ret < 0)

	ret = afs_validate_fc(fc);

	if (ret)

		goto error;



		/* try and do the mount securely */

		key = afs_request_key(params.cell);

		if (IS_ERR(key)) {

			_leave(" = %ld [key]", PTR_ERR(key));

			ret = PTR_ERR(key);

			goto error;

		}

		params.key = key;

	}

	_enter("");



	/* allocate a superblock info record */

	ret = -ENOMEM;

	as = afs_alloc_sbi(&params);

	as = afs_alloc_sbi(fc);

	if (!as)

		goto error_key;



	if (!params.dyn_root) {

		/* Assume we're going to need a volume record; at the very

		 * least we can use it to update the volume record if we have

		 * one already.  This checks that the volume exists within the

		 * cell.

		 */

		candidate = afs_create_volume(&params);

		if (IS_ERR(candidate)) {

			ret = PTR_ERR(candidate);

			goto error_as;

		}



		as->volume = candidate;

	}

		goto error;

	fc->s_fs_info = as;



	/* allocate a deviceless superblock */

	sb = sget(fs_type,

	sb = sget_fc(fc,

		     as->dyn_root ? afs_dynroot_test_super : afs_test_super,

		  afs_set_super, flags, as);

		     afs_set_super);

	if (IS_ERR(sb)) {

		ret = PTR_ERR(sb);

		goto error_as;

		goto error;

	}



	if (!sb->s_root) {

		/* initial superblock/root creation */

		_debug("create");

		ret = afs_fill_super(sb, &params);

		ret = afs_fill_super(sb, ctx);

		if (ret < 0)

			goto error_sb;

		as = NULL;

		sb->s_flags |= SB_ACTIVE;

	} else {

		_debug("reuse");

		ASSERTCMP(sb->s_flags, &, SB_ACTIVE);

		afs_destroy_sbi(as);

		as = NULL;

	}



	afs_put_cell(params.net, params.cell);

	key_put(params.key);

	fc->root = dget(sb->s_root);

	_leave(" = 0 [%p]", sb);

	return dget(sb->s_root);

	return 0;



error_sb:

	deactivate_locked_super(sb);

	goto error_key;

error_as:

	afs_destroy_sbi(as);

error_key:

	key_put(params.key);

error:

	afs_put_cell(params.net, params.cell);

	_leave(" = %d", ret);

	return ERR_PTR(ret);

	return ret;

}



static void afs_free_fc(struct fs_context *fc)

{

	struct afs_fs_context *ctx = fc->fs_private;



	afs_destroy_sbi(fc->s_fs_info);

	afs_put_volume(ctx->cell, ctx->volume);

	afs_put_cell(ctx->net, ctx->cell);

	key_put(ctx->key);

	kfree(ctx);

}



static const struct fs_context_operations afs_context_ops = {

	.free		= afs_free_fc,

	.parse_param	= afs_parse_param,

	.get_tree	= afs_get_tree,

};



/*

 * Set up the filesystem mount context.

 */

static int afs_init_fs_context(struct fs_context *fc)

{

	struct afs_fs_context *ctx;

	struct afs_cell *cell;



	if (current->nsproxy->net_ns != &init_net)

		return -EINVAL;



	ctx = kzalloc(sizeof(struct afs_fs_context), GFP_KERNEL);

	if (!ctx)

		return -ENOMEM;



	ctx->type = AFSVL_ROVOL;

	ctx->net = afs_net(fc->net_ns);



	/* Default to the workstation cell. */

	rcu_read_lock();

	cell = afs_lookup_cell_rcu(ctx->net, NULL, 0);

	rcu_read_unlock();

	if (IS_ERR(cell))

		cell = NULL;

	ctx->cell = cell;



	fc->fs_private = ctx;

	fc->ops = &afs_context_ops;

	return 0;

}



/*

fs/afs/volume.c

+2 −2
Original line number Diff line number Diff line
@@ -21,7 +21,7 @@ static const char *const afs_voltypes[] = { "R/W", "R/O", "BAK" }; 
/*

 * Allocate a volume record and load it up from a vldb record.

 */

static struct afs_volume *afs_alloc_volume(struct afs_mount_params *params,

static struct afs_volume *afs_alloc_volume(struct afs_fs_context *params,

					   struct afs_vldb_entry *vldb,

					   unsigned long type_mask)

{
@@ -113,7 +113,7 @@ static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell, 
 * - Rule 3: If parent volume is R/W, then only mount R/W volume unless

 *           explicitly told otherwise

 */

struct afs_volume *afs_create_volume(struct afs_mount_params *params)

struct afs_volume *afs_create_volume(struct afs_fs_context *params)

{

	struct afs_vldb_entry *vldb;

	struct afs_volume *volume;