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

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

afs: Use fs_context to pass parameters over automount 



Alter the AFS automounting code to create and modify an fs_context struct
when parameterising a new mount triggered by an AFS mountpoint rather than
constructing device name and option strings.

Also remove the cell=, vol= and rwpath options as they are then redundant.
The reason they existed is because the 'device name' may be derived
literally from a mountpoint object in the filesystem, so default cell and
parent-type information needed to be passed in by some other method from
the automount routines.  The vol= option didn't end up being used.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
cc: Eric W. Biederman <ebiederm@redhat.com>
Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent 13fcc683

fs/afs/internal.h

+0 −1
Original line number Diff line number Diff line
@@ -37,7 +37,6 @@ struct pagevec; 
struct afs_call;



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 */

fs/afs/mntpt.c

+77 −71
Original line number Diff line number Diff line
@@ -48,6 +48,8 @@ static DECLARE_DELAYED_WORK(afs_mntpt_expiry_timer, afs_mntpt_expiry_timed_out); 


static unsigned long afs_mntpt_expiry_timeout = 10 * 60;



static const char afs_root_volume[] = "root.cell";



/*

 * no valid lookup procedure on this sort of dir

 */
@@ -69,108 +71,112 @@ static int afs_mntpt_open(struct inode *inode, struct file *file) 
}



/*

 * create a vfsmount to be automounted

 * Set the parameters for the proposed superblock.

 */

static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)

static int afs_mntpt_set_params(struct fs_context *fc, struct dentry *mntpt)

{

	struct afs_super_info *as;

	struct vfsmount *mnt;

	struct afs_vnode *vnode;

	struct page *page;

	char *devname, *options;

	bool rwpath = false;

	struct afs_fs_context *ctx = fc->fs_private;

	struct afs_super_info *src_as = AFS_FS_S(mntpt->d_sb);

	struct afs_vnode *vnode = AFS_FS_I(d_inode(mntpt));

	struct afs_cell *cell;

	const char *p;

	int ret;



	_enter("{%pd}", mntpt);



	BUG_ON(!d_inode(mntpt));



	ret = -ENOMEM;

	devname = (char *) get_zeroed_page(GFP_KERNEL);

	if (!devname)

		goto error_no_devname;



	options = (char *) get_zeroed_page(GFP_KERNEL);

	if (!options)

		goto error_no_options;

	if (fc->net_ns != src_as->net_ns) {

		put_net(fc->net_ns);

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

	}



	vnode = AFS_FS_I(d_inode(mntpt));

	if (src_as->volume && src_as->volume->type == AFSVL_RWVOL) {

		ctx->type = AFSVL_RWVOL;

		ctx->force = true;

	}

	if (ctx->cell) {

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

		ctx->cell = NULL;

	}

	if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) {

		/* if the directory is a pseudo directory, use the d_name */

		static const char afs_root_cell[] = ":root.cell.";

		unsigned size = mntpt->d_name.len;



		ret = -ENOENT;

		if (size < 2 || size > AFS_MAXCELLNAME)

			goto error_no_page;

		if (size < 2)

			return -ENOENT;



		p = mntpt->d_name.name;

		if (mntpt->d_name.name[0] == '.') {

			devname[0] = '%';

			memcpy(devname + 1, mntpt->d_name.name + 1, size - 1);

			memcpy(devname + size, afs_root_cell,

			       sizeof(afs_root_cell));

			rwpath = true;

		} else {

			devname[0] = '#';

			memcpy(devname + 1, mntpt->d_name.name, size);

			memcpy(devname + size + 1, afs_root_cell,

			       sizeof(afs_root_cell));

			size--;

			p++;

			ctx->type = AFSVL_RWVOL;

			ctx->force = true;

		}

		if (size > AFS_MAXCELLNAME)

			return -ENAMETOOLONG;



		cell = afs_lookup_cell(ctx->net, p, size, NULL, false);

		if (IS_ERR(cell)) {

			pr_err("kAFS: unable to lookup cell '%pd'\n", mntpt);

			return PTR_ERR(cell);

		}

		ctx->cell = cell;



		ctx->volname = afs_root_volume;

		ctx->volnamesz = sizeof(afs_root_volume) - 1;

	} else {

		/* read the contents of the AFS special symlink */

		struct page *page;

		loff_t size = i_size_read(d_inode(mntpt));

		char *buf;



		ret = -EINVAL;

		if (src_as->cell)

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



		if (size > PAGE_SIZE - 1)

			goto error_no_page;

			return -EINVAL;



		page = read_mapping_page(d_inode(mntpt)->i_mapping, 0, NULL);

		if (IS_ERR(page)) {

			ret = PTR_ERR(page);

			goto error_no_page;

		}

		if (IS_ERR(page))

			return PTR_ERR(page);



		if (PageError(page)) {

			ret = afs_bad(AFS_FS_I(d_inode(mntpt)), afs_file_error_mntpt);

			goto error;

			put_page(page);

			return ret;

		}



		buf = kmap_atomic(page);

		memcpy(devname, buf, size);

		kunmap_atomic(buf);

		buf = kmap(page);

		ret = vfs_parse_fs_string(fc, "source", buf, size);

		kunmap(page);

		put_page(page);

		page = NULL;

		if (ret < 0)

			return ret;

	}



	/* work out what options we want */

	as = AFS_FS_S(mntpt->d_sb);

	if (as->cell) {

		memcpy(options, "cell=", 5);

		strcpy(options + 5, as->cell->name);

		if ((as->volume && as->volume->type == AFSVL_RWVOL) || rwpath)

			strcat(options, ",rwpath");

	return 0;

}



	/* try and do the mount */

	_debug("--- attempting mount %s -o %s ---", devname, options);

	mnt = vfs_submount(mntpt, &afs_fs_type, devname, options);

	_debug("--- mount result %p ---", mnt);

/*

 * create a vfsmount to be automounted

 */

static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)

{

	struct fs_context *fc;

	struct vfsmount *mnt;

	int ret;



	BUG_ON(!d_inode(mntpt));



	fc = fs_context_for_submount(&afs_fs_type, mntpt);

	if (IS_ERR(fc))

		return ERR_CAST(fc);



	free_page((unsigned long) devname);

	free_page((unsigned long) options);

	_leave(" = %p", mnt);

	return mnt;

	ret = afs_mntpt_set_params(fc, mntpt);

	if (!ret)

		mnt = fc_mount(fc);

	else

		mnt = ERR_PTR(ret);



error:

	put_page(page);

error_no_page:

	free_page((unsigned long) options);

error_no_options:

	free_page((unsigned long) devname);

error_no_devname:

	_leave(" = %d", ret);

	return ERR_PTR(ret);

	put_fs_context(fc);

	return mnt;

}



/*

fs/afs/super.c

+3 −37
Original line number Diff line number Diff line
@@ -66,20 +66,14 @@ static atomic_t afs_count_active_inodes; 


enum afs_param {

	Opt_autocell,

	Opt_cell,

	Opt_dyn,

	Opt_rwpath,

	Opt_source,

	Opt_vol,

};



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),

	{}

};
@@ -202,8 +196,8 @@ static int afs_show_options(struct seq_file *m, struct dentry *root) 
 *

 * 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

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

 *					 or R/W (R/W parent) volume

 *	"%[cell:]volume.readonly"	R/O volume

 *	"#[cell:]volume.readonly"	R/O volume

 *	"%[cell:]volume.backup"		Backup volume
@@ -234,9 +228,7 @@ static int afs_parse_source(struct fs_context *fc, struct fs_parameter *param) 
	}



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

	ctx->type = AFSVL_ROVOL;

	ctx->force = false;

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

	if (name[0] == '%') {

		ctx->type = AFSVL_RWVOL;

		ctx->force = true;

	}
@@ -305,7 +297,6 @@ 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);
@@ -313,21 +304,6 @@ static int afs_parse_param(struct fs_context *fc, struct fs_parameter *param) 
		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);
@@ -339,13 +315,6 @@ static int afs_parse_param(struct fs_context *fc, struct fs_parameter *param) 
		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;

	}
@@ -616,9 +585,6 @@ 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;