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

Commit 0b36c9ee authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'work.mount3' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull more mount API conversions from Al Viro:
 "Assorted conversions of options parsing to new API.

  gfs2 is probably the most serious one here; the rest is trivial stuff.

  Other things in what used to be #work.mount are going to wait for the
  next cycle (and preferably go via git trees of the filesystems
  involved)"

* 'work.mount3' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  gfs2: Convert gfs2 to fs_context
  vfs: Convert spufs to use the new mount API
  vfs: Convert hypfs to use the new mount API
  hypfs: Fix error number left in struct pointer member
  vfs: Convert functionfs to use the new mount API
  vfs: Convert bpf to use the new mount API
parents 722e6f50 1f52aa08

arch/powerpc/platforms/cell/spufs/inode.c

+116 −91
Original line number Diff line number Diff line
@@ -10,6 +10,8 @@ 


#include <linux/file.h>

#include <linux/fs.h>

#include <linux/fs_context.h>

#include <linux/fs_parser.h>

#include <linux/fsnotify.h>

#include <linux/backing-dev.h>

#include <linux/init.h>
@@ -20,7 +22,6 @@ 
#include <linux/pagemap.h>

#include <linux/poll.h>

#include <linux/slab.h>

#include <linux/parser.h>



#include <asm/prom.h>

#include <asm/spu.h>
@@ -30,7 +31,7 @@ 
#include "spufs.h"



struct spufs_sb_info {

	int debug;

	bool debug;

};



static struct kmem_cache *spufs_inode_cache;
@@ -574,16 +575,27 @@ long spufs_create(struct path *path, struct dentry *dentry, 
}



/* File system initialization */

struct spufs_fs_context {

	kuid_t	uid;

	kgid_t	gid;

	umode_t	mode;

};



enum {

	Opt_uid, Opt_gid, Opt_mode, Opt_debug, Opt_err,

	Opt_uid, Opt_gid, Opt_mode, Opt_debug,

};



static const match_table_t spufs_tokens = {

	{ Opt_uid,   "uid=%d" },

	{ Opt_gid,   "gid=%d" },

	{ Opt_mode,  "mode=%o" },

	{ Opt_debug, "debug" },

	{ Opt_err,    NULL  },

static const struct fs_parameter_spec spufs_param_specs[] = {

	fsparam_u32	("gid",				Opt_gid),

	fsparam_u32oct	("mode",			Opt_mode),

	fsparam_u32	("uid",				Opt_uid),

	fsparam_flag	("debug",			Opt_debug),

	{}

};



static const struct fs_parameter_description spufs_fs_parameters = {

	.name		= "spufs",

	.specs		= spufs_param_specs,

};



static int spufs_show_options(struct seq_file *m, struct dentry *root)
@@ -604,47 +616,41 @@ static int spufs_show_options(struct seq_file *m, struct dentry *root) 
	return 0;

}



static int

spufs_parse_options(struct super_block *sb, char *options, struct inode *root)

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

{

	char *p;

	substring_t args[MAX_OPT_ARGS];



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

		int token, option;



		if (!*p)

			continue;



		token = match_token(p, spufs_tokens, args);

		switch (token) {

	struct spufs_fs_context *ctx = fc->fs_private;

	struct spufs_sb_info *sbi = fc->s_fs_info;

	struct fs_parse_result result;

	kuid_t uid;

	kgid_t gid;

	int opt;



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

	if (opt < 0)

		return opt;



	switch (opt) {

	case Opt_uid:

			if (match_int(&args[0], &option))

				return 0;

			root->i_uid = make_kuid(current_user_ns(), option);

			if (!uid_valid(root->i_uid))

				return 0;

		uid = make_kuid(current_user_ns(), result.uint_32);

		if (!uid_valid(uid))

			return invalf(fc, "Unknown uid");

		ctx->uid = uid;

		break;

	case Opt_gid:

			if (match_int(&args[0], &option))

				return 0;

			root->i_gid = make_kgid(current_user_ns(), option);

			if (!gid_valid(root->i_gid))

				return 0;

		gid = make_kgid(current_user_ns(), result.uint_32);

		if (!gid_valid(gid))

			return invalf(fc, "Unknown gid");

		ctx->gid = gid;

		break;

	case Opt_mode:

			if (match_octal(&args[0], &option))

				return 0;

			root->i_mode = option | S_IFDIR;

		ctx->mode = result.uint_32 & S_IALLUGO;

		break;

	case Opt_debug:

			spufs_get_sb_info(sb)->debug = 1;

		sbi->debug = true;

		break;

		default:

			return 0;

		}

	}

	return 1;



	return 0;

}



static void spufs_exit_isolated_loader(void)
@@ -678,47 +684,32 @@ spufs_init_isolated_loader(void) 
	printk(KERN_INFO "spufs: SPU isolation mode enabled\n");

}



static int

spufs_create_root(struct super_block *sb, void *data)

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

{

	struct spufs_fs_context *ctx = fc->fs_private;

	struct inode *inode;

	int ret;



	ret = -ENODEV;

	if (!spu_management_ops)

		goto out;

		return -ENODEV;



	ret = -ENOMEM;

	inode = spufs_new_inode(sb, S_IFDIR | 0775);

	inode = spufs_new_inode(sb, S_IFDIR | ctx->mode);

	if (!inode)

		goto out;

		return -ENOMEM;



	inode->i_uid = ctx->uid;

	inode->i_gid = ctx->gid;

	inode->i_op = &simple_dir_inode_operations;

	inode->i_fop = &simple_dir_operations;

	SPUFS_I(inode)->i_ctx = NULL;

	inc_nlink(inode);



	ret = -EINVAL;

	if (!spufs_parse_options(sb, data, inode))

		goto out_iput;



	ret = -ENOMEM;

	sb->s_root = d_make_root(inode);

	if (!sb->s_root)

		goto out;



		return -ENOMEM;

	return 0;

out_iput:

	iput(inode);

out:

	return ret;

}



static int

spufs_fill_super(struct super_block *sb, void *data, int silent)

{

	struct spufs_sb_info *info;

	static const struct super_operations s_ops = {

static const struct super_operations spufs_ops = {

	.alloc_inode	= spufs_alloc_inode,

	.free_inode	= spufs_free_inode,

	.statfs		= simple_statfs,
@@ -726,31 +717,65 @@ spufs_fill_super(struct super_block *sb, void *data, int silent) 
	.show_options	= spufs_show_options,

};



	info = kzalloc(sizeof(*info), GFP_KERNEL);

	if (!info)

		return -ENOMEM;



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

{

	sb->s_maxbytes = MAX_LFS_FILESIZE;

	sb->s_blocksize = PAGE_SIZE;

	sb->s_blocksize_bits = PAGE_SHIFT;

	sb->s_magic = SPUFS_MAGIC;

	sb->s_op = &s_ops;

	sb->s_fs_info = info;

	sb->s_op = &spufs_ops;



	return spufs_create_root(sb, fc);

}



	return spufs_create_root(sb, data);

static int spufs_get_tree(struct fs_context *fc)

{

	return get_tree_single(fc, spufs_fill_super);

}



static struct dentry *

spufs_mount(struct file_system_type *fstype, int flags,

		const char *name, void *data)

static void spufs_free_fc(struct fs_context *fc)

{

	kfree(fc->s_fs_info);

}



static const struct fs_context_operations spufs_context_ops = {

	.free		= spufs_free_fc,

	.parse_param	= spufs_parse_param,

	.get_tree	= spufs_get_tree,

};



static int spufs_init_fs_context(struct fs_context *fc)

{

	return mount_single(fstype, flags, data, spufs_fill_super);

	struct spufs_fs_context *ctx;

	struct spufs_sb_info *sbi;



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

	if (!ctx)

		goto nomem;



	sbi = kzalloc(sizeof(struct spufs_sb_info), GFP_KERNEL);

	if (!sbi)

		goto nomem_ctx;



	ctx->uid = current_uid();

	ctx->gid = current_gid();

	ctx->mode = 0755;



	fc->s_fs_info = sbi;

	fc->ops = &spufs_context_ops;

	return 0;



nomem_ctx:

	kfree(ctx);

nomem:

	return -ENOMEM;

}



static struct file_system_type spufs_type = {

	.owner = THIS_MODULE,

	.name = "spufs",

	.mount = spufs_mount,

	.init_fs_context = spufs_init_fs_context,

	.parameters	= &spufs_fs_parameters,

	.kill_sb = kill_litter_super,

};

MODULE_ALIAS_FS("spufs");

arch/s390/hypfs/inode.c

+75 −62
Original line number Diff line number Diff line
@@ -12,17 +12,17 @@ 
#include <linux/types.h>

#include <linux/errno.h>

#include <linux/fs.h>

#include <linux/fs_context.h>

#include <linux/fs_parser.h>

#include <linux/namei.h>

#include <linux/vfs.h>

#include <linux/slab.h>

#include <linux/pagemap.h>

#include <linux/time.h>

#include <linux/parser.h>

#include <linux/sysfs.h>

#include <linux/init.h>

#include <linux/kobject.h>

#include <linux/seq_file.h>

#include <linux/mount.h>

#include <linux/uio.h>

#include <asm/ebcdic.h>

#include "hypfs.h"
@@ -207,52 +207,44 @@ static int hypfs_release(struct inode *inode, struct file *filp) 
	return 0;

}



enum { opt_uid, opt_gid, opt_err };

enum { Opt_uid, Opt_gid, };



static const match_table_t hypfs_tokens = {

	{opt_uid, "uid=%u"},

	{opt_gid, "gid=%u"},

	{opt_err, NULL}

static const struct fs_parameter_spec hypfs_param_specs[] = {

	fsparam_u32("gid", Opt_gid),

	fsparam_u32("uid", Opt_uid),

	{}

};



static int hypfs_parse_options(char *options, struct super_block *sb)

static const struct fs_parameter_description hypfs_fs_parameters = {

	.name		= "hypfs",

	.specs		= hypfs_param_specs,

};



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

{

	char *str;

	substring_t args[MAX_OPT_ARGS];

	struct hypfs_sb_info *hypfs_info = fc->s_fs_info;

	struct fs_parse_result result;

	kuid_t uid;

	kgid_t gid;

	int opt;



	if (!options)

		return 0;

	while ((str = strsep(&options, ",")) != NULL) {

		int token, option;

		struct hypfs_sb_info *hypfs_info = sb->s_fs_info;

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

	if (opt < 0)

		return opt;



		if (!*str)

			continue;

		token = match_token(str, hypfs_tokens, args);

		switch (token) {

		case opt_uid:

			if (match_int(&args[0], &option))

				return -EINVAL;

			uid = make_kuid(current_user_ns(), option);

	switch (opt) {

	case Opt_uid:

		uid = make_kuid(current_user_ns(), result.uint_32);

		if (!uid_valid(uid))

				return -EINVAL;

			return invalf(fc, "Unknown uid");

		hypfs_info->uid = uid;

		break;

		case opt_gid:

			if (match_int(&args[0], &option))

				return -EINVAL;

			gid = make_kgid(current_user_ns(), option);

	case Opt_gid:

		gid = make_kgid(current_user_ns(), result.uint_32);

		if (!gid_valid(gid))

				return -EINVAL;

			return invalf(fc, "Unknown gid");

		hypfs_info->gid = gid;

		break;

		case opt_err:

		default:

			pr_err("%s is not a valid mount option\n", str);

			return -EINVAL;

		}

	}

	return 0;

}
@@ -266,26 +258,18 @@ static int hypfs_show_options(struct seq_file *s, struct dentry *root) 
	return 0;

}



static int hypfs_fill_super(struct super_block *sb, void *data, int silent)

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

{

	struct hypfs_sb_info *sbi = sb->s_fs_info;

	struct inode *root_inode;

	struct dentry *root_dentry;

	int rc = 0;

	struct hypfs_sb_info *sbi;

	struct dentry *root_dentry, *update_file;

	int rc;



	sbi = kzalloc(sizeof(struct hypfs_sb_info), GFP_KERNEL);

	if (!sbi)

		return -ENOMEM;

	mutex_init(&sbi->lock);

	sbi->uid = current_uid();

	sbi->gid = current_gid();

	sb->s_fs_info = sbi;

	sb->s_blocksize = PAGE_SIZE;

	sb->s_blocksize_bits = PAGE_SHIFT;

	sb->s_magic = HYPFS_MAGIC;

	sb->s_op = &hypfs_s_ops;

	if (hypfs_parse_options(data, sb))

		return -EINVAL;



	root_inode = hypfs_make_inode(sb, S_IFDIR | 0755);

	if (!root_inode)

		return -ENOMEM;
@@ -300,18 +284,46 @@ static int hypfs_fill_super(struct super_block *sb, void *data, int silent) 
		rc = hypfs_diag_create_files(root_dentry);

	if (rc)

		return rc;

	sbi->update_file = hypfs_create_update_file(root_dentry);

	if (IS_ERR(sbi->update_file))

		return PTR_ERR(sbi->update_file);

	update_file = hypfs_create_update_file(root_dentry);

	if (IS_ERR(update_file))

		return PTR_ERR(update_file);

	sbi->update_file = update_file;

	hypfs_update_update(sb);

	pr_info("Hypervisor filesystem mounted\n");

	return 0;

}



static struct dentry *hypfs_mount(struct file_system_type *fst, int flags,

			const char *devname, void *data)

static int hypfs_get_tree(struct fs_context *fc)

{

	return mount_single(fst, flags, data, hypfs_fill_super);

	return get_tree_single(fc, hypfs_fill_super);

}



static void hypfs_free_fc(struct fs_context *fc)

{

	kfree(fc->s_fs_info);

}



static const struct fs_context_operations hypfs_context_ops = {

	.free		= hypfs_free_fc,

	.parse_param	= hypfs_parse_param,

	.get_tree	= hypfs_get_tree,

};



static int hypfs_init_fs_context(struct fs_context *fc)

{

	struct hypfs_sb_info *sbi;



	sbi = kzalloc(sizeof(struct hypfs_sb_info), GFP_KERNEL);

	if (!sbi)

		return -ENOMEM;



	mutex_init(&sbi->lock);

	sbi->uid = current_uid();

	sbi->gid = current_gid();



	fc->s_fs_info = sbi;

	fc->ops = &hypfs_context_ops;

	return 0;

}



static void hypfs_kill_super(struct super_block *sb)
@@ -442,7 +454,8 @@ static const struct file_operations hypfs_file_ops = { 
static struct file_system_type hypfs_type = {

	.owner		= THIS_MODULE,

	.name		= "s390_hypfs",

	.mount		= hypfs_mount,

	.init_fs_context = hypfs_init_fs_context,

	.parameters	= &hypfs_fs_parameters,

	.kill_sb	= hypfs_kill_super

};

drivers/usb/gadget/function/f_fs.c

+120 −113
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <linux/blkdev.h>

#include <linux/pagemap.h>

#include <linux/export.h>

#include <linux/fs_parser.h>

#include <linux/hid.h>

#include <linux/mm.h>

#include <linux/module.h>
@@ -1451,9 +1452,9 @@ struct ffs_sb_fill_data { 
	struct ffs_data *ffs_data;

};



static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)

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

{

	struct ffs_sb_fill_data *data = _data;

	struct ffs_sb_fill_data *data = fc->fs_private;

	struct inode	*inode;

	struct ffs_data	*ffs = data->ffs_data;
@@ -1486,147 +1487,152 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent) 
	return 0;

}



static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)

{

	ENTER();

enum {

	Opt_no_disconnect,

	Opt_rmode,

	Opt_fmode,

	Opt_mode,

	Opt_uid,

	Opt_gid,

};



	if (!opts || !*opts)

		return 0;

static const struct fs_parameter_spec ffs_fs_param_specs[] = {

	fsparam_bool	("no_disconnect",	Opt_no_disconnect),

	fsparam_u32	("rmode",		Opt_rmode),

	fsparam_u32	("fmode",		Opt_fmode),

	fsparam_u32	("mode",		Opt_mode),

	fsparam_u32	("uid",			Opt_uid),

	fsparam_u32	("gid",			Opt_gid),

	{}

};



	for (;;) {

		unsigned long value;

		char *eq, *comma;



		/* Option limit */

		comma = strchr(opts, ',');

		if (comma)

			*comma = 0;



		/* Value limit */

		eq = strchr(opts, '=');

		if (unlikely(!eq)) {

			pr_err("'=' missing in %s\n", opts);

			return -EINVAL;

		}

		*eq = 0;

static const struct fs_parameter_description ffs_fs_fs_parameters = {

	.name		= "kAFS",

	.specs		= ffs_fs_param_specs,

};



		/* Parse value */

		if (kstrtoul(eq + 1, 0, &value)) {

			pr_err("%s: invalid value: %s\n", opts, eq + 1);

			return -EINVAL;

		}

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

{

	struct ffs_sb_fill_data *data = fc->fs_private;

	struct fs_parse_result result;

	int opt;



		/* Interpret option */

		switch (eq - opts) {

		case 13:

			if (!memcmp(opts, "no_disconnect", 13))

				data->no_disconnect = !!value;

			else

				goto invalid;

	ENTER();



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

	if (opt < 0)

		return opt;



	switch (opt) {

	case Opt_no_disconnect:

		data->no_disconnect = result.boolean;

		break;

		case 5:

			if (!memcmp(opts, "rmode", 5))

				data->root_mode  = (value & 0555) | S_IFDIR;

			else if (!memcmp(opts, "fmode", 5))

				data->perms.mode = (value & 0666) | S_IFREG;

			else

				goto invalid;

	case Opt_rmode:

		data->root_mode  = (result.uint_32 & 0555) | S_IFDIR;

		break;



		case 4:

			if (!memcmp(opts, "mode", 4)) {

				data->root_mode  = (value & 0555) | S_IFDIR;

				data->perms.mode = (value & 0666) | S_IFREG;

			} else {

				goto invalid;

			}

	case Opt_fmode:

		data->perms.mode = (result.uint_32 & 0666) | S_IFREG;

		break;

	case Opt_mode:

		data->root_mode  = (result.uint_32 & 0555) | S_IFDIR;

		data->perms.mode = (result.uint_32 & 0666) | S_IFREG;

		break;



		case 3:

			if (!memcmp(opts, "uid", 3)) {

				data->perms.uid = make_kuid(current_user_ns(), value);

				if (!uid_valid(data->perms.uid)) {

					pr_err("%s: unmapped value: %lu\n", opts, value);

					return -EINVAL;

				}

			} else if (!memcmp(opts, "gid", 3)) {

				data->perms.gid = make_kgid(current_user_ns(), value);

				if (!gid_valid(data->perms.gid)) {

					pr_err("%s: unmapped value: %lu\n", opts, value);

					return -EINVAL;

				}

			} else {

				goto invalid;

			}

	case Opt_uid:

		data->perms.uid = make_kuid(current_user_ns(), result.uint_32);

		if (!uid_valid(data->perms.uid))

			goto unmapped_value;

		break;

	case Opt_gid:

		data->perms.gid = make_kgid(current_user_ns(), result.uint_32);

		if (!gid_valid(data->perms.gid))

			goto unmapped_value;

		break;



	default:

invalid:

			pr_err("%s: invalid option\n", opts);

			return -EINVAL;

		}



		/* Next iteration */

		if (!comma)

			break;

		opts = comma + 1;

		return -ENOPARAM;

	}



	return 0;

}



/* "mount -t functionfs dev_name /dev/function" ends up here */

unmapped_value:

	return invalf(fc, "%s: unmapped value: %u", param->key, result.uint_32);

}



static struct dentry *

ffs_fs_mount(struct file_system_type *t, int flags,

	      const char *dev_name, void *opts)

{

	struct ffs_sb_fill_data data = {

		.perms = {

			.mode = S_IFREG | 0600,

			.uid = GLOBAL_ROOT_UID,

			.gid = GLOBAL_ROOT_GID,

		},

		.root_mode = S_IFDIR | 0500,

		.no_disconnect = false,

	};

	struct dentry *rv;

	int ret;

/*

 * Set up the superblock for a mount.

 */

static int ffs_fs_get_tree(struct fs_context *fc)

{

	struct ffs_sb_fill_data *ctx = fc->fs_private;

	void *ffs_dev;

	struct ffs_data	*ffs;



	ENTER();



	ret = ffs_fs_parse_opts(&data, opts);

	if (unlikely(ret < 0))

		return ERR_PTR(ret);

	if (!fc->source)

		return invalf(fc, "No source specified");



	ffs = ffs_data_new(dev_name);

	ffs = ffs_data_new(fc->source);

	if (unlikely(!ffs))

		return ERR_PTR(-ENOMEM);

	ffs->file_perms = data.perms;

	ffs->no_disconnect = data.no_disconnect;

		return -ENOMEM;

	ffs->file_perms = ctx->perms;

	ffs->no_disconnect = ctx->no_disconnect;



	ffs->dev_name = kstrdup(dev_name, GFP_KERNEL);

	ffs->dev_name = kstrdup(fc->source, GFP_KERNEL);

	if (unlikely(!ffs->dev_name)) {

		ffs_data_put(ffs);

		return ERR_PTR(-ENOMEM);

		return -ENOMEM;

	}



	ffs_dev = ffs_acquire_dev(dev_name);

	ffs_dev = ffs_acquire_dev(ffs->dev_name);

	if (IS_ERR(ffs_dev)) {

		ffs_data_put(ffs);

		return ERR_CAST(ffs_dev);

		return PTR_ERR(ffs_dev);

	}



	ffs->private_data = ffs_dev;

	data.ffs_data = ffs;

	ctx->ffs_data = ffs;

	return get_tree_nodev(fc, ffs_sb_fill);

}



static void ffs_fs_free_fc(struct fs_context *fc)

{

	struct ffs_sb_fill_data *ctx = fc->fs_private;



	if (ctx) {

		if (ctx->ffs_data) {

			ffs_release_dev(ctx->ffs_data);

			ffs_data_put(ctx->ffs_data);

		}



	rv = mount_nodev(t, flags, &data, ffs_sb_fill);

	if (IS_ERR(rv) && data.ffs_data) {

		ffs_release_dev(data.ffs_data);

		ffs_data_put(data.ffs_data);

		kfree(ctx);

	}

}

	return rv;



static const struct fs_context_operations ffs_fs_context_ops = {

	.free		= ffs_fs_free_fc,

	.parse_param	= ffs_fs_parse_param,

	.get_tree	= ffs_fs_get_tree,

};



static int ffs_fs_init_fs_context(struct fs_context *fc)

{

	struct ffs_sb_fill_data *ctx;



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

	if (!ctx)

		return -ENOMEM;



	ctx->perms.mode = S_IFREG | 0600;

	ctx->perms.uid = GLOBAL_ROOT_UID;

	ctx->perms.gid = GLOBAL_ROOT_GID;

	ctx->root_mode = S_IFDIR | 0500;

	ctx->no_disconnect = false;



	fc->fs_private = ctx;

	fc->ops = &ffs_fs_context_ops;

	return 0;

}



static void
@@ -1644,7 +1650,8 @@ ffs_fs_kill_sb(struct super_block *sb) 
static struct file_system_type ffs_fs_type = {

	.owner		= THIS_MODULE,

	.name		= "functionfs",

	.mount		= ffs_fs_mount,

	.init_fs_context = ffs_fs_init_fs_context,

	.parameters	= &ffs_fs_fs_parameters,

	.kill_sb	= ffs_fs_kill_sb,

};

MODULE_ALIAS_FS("functionfs");

fs/gfs2/incore.h

+4 −4
Original line number Diff line number Diff line
@@ -584,10 +584,10 @@ struct gfs2_args { 
	unsigned int ar_rgrplvb:1;		/* use lvbs for rgrp info */

	unsigned int ar_loccookie:1;		/* use location based readdir

						   cookies */

	int ar_commit;				/* Commit interval */

	int ar_statfs_quantum;			/* The fast statfs interval */

	int ar_quota_quantum;			/* The quota interval */

	int ar_statfs_percent;			/* The % change to force sync */

	s32 ar_commit;				/* Commit interval */

	s32 ar_statfs_quantum;			/* The fast statfs interval */

	s32 ar_quota_quantum;			/* The quota interval */

	s32 ar_statfs_percent;			/* The % change to force sync */

};



struct gfs2_tune {

fs/gfs2/ops_fstype.c

+374 −121

File changed.

Preview size limit exceeded, changes collapsed.