Merge branch 'work.mount2' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs (bc7d9aee) · Commits · 戴 / test

drivers/base/devtmpfs.c

+29 −9

Original line number	Diff line number	Diff line
		@@ -56,20 +56,32 @@ static int __init mount_param(char *str)
		}
		__setup("devtmpfs.mount=", mount_param);

		static struct dentry dev_mount(struct file_system_type fs_type, int flags,
		static struct vfsmount *mnt;

		static struct dentry public_dev_mount(struct file_system_type fs_type, int flags,
		const char dev_name, void data)
		{
		struct super_block *s = mnt->mnt_sb;
		atomic_inc(&s->s_active);
		down_write(&s->s_umount);
		return dget(s->s_root);
		}

		static struct file_system_type internal_fs_type = {
		.name = "devtmpfs",
		#ifdef CONFIG_TMPFS
		return mount_single(fs_type, flags, data, shmem_fill_super);
		.init_fs_context = shmem_init_fs_context,
		.parameters = &shmem_fs_parameters,
		#else
		return mount_single(fs_type, flags, data, ramfs_fill_super);
		.init_fs_context = ramfs_init_fs_context,
		.parameters = &ramfs_fs_parameters,
		#endif
		}
		.kill_sb = kill_litter_super,
		};

		static struct file_system_type dev_fs_type = {
		.name = "devtmpfs",
		.mount = dev_mount,
		.kill_sb = kill_litter_super,
		.mount = public_dev_mount,
		};

		#ifdef CONFIG_BLOCK
		@@ -378,12 +390,11 @@ static int handle(const char *name, umode_t mode, kuid_t uid, kgid_t gid,

		static int devtmpfsd(void *p)
		{
		char options[] = "mode=0755";
		int *err = p;
		*err = ksys_unshare(CLONE_NEWNS);
		if (*err)
		goto out;
		*err = ksys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options);
		*err = ksys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, NULL);
		if (*err)
		goto out;
		ksys_chdir("/.."); /* will traverse into overmounted root */
		@@ -420,7 +431,16 @@ out:
		*/
		int __init devtmpfs_init(void)
		{
		int err = register_filesystem(&dev_fs_type);
		char opts[] = "mode=0755";
		int err;

		mnt = vfs_kern_mount(&internal_fs_type, 0, "devtmpfs", opts);
		if (IS_ERR(mnt)) {
		printk(KERN_ERR "devtmpfs: unable to create devtmpfs %ld\n",
		PTR_ERR(mnt));
		return PTR_ERR(mnt);
		}
		err = register_filesystem(&dev_fs_type);
		if (err) {
		printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
		"type %i\n", err);

drivers/mtd/mtdsuper.c

+0 −189

Original line number	Diff line number	Diff line
		@@ -193,195 +193,6 @@ int get_tree_mtd(struct fs_context *fc,
		}
		EXPORT_SYMBOL_GPL(get_tree_mtd);

		/*
		* compare superblocks to see if they're equivalent
		* - they are if the underlying MTD device is the same
		*/
		static int get_sb_mtd_compare(struct super_block sb, void _mtd)
		{
		struct mtd_info *mtd = _mtd;

		if (sb->s_mtd == mtd) {
		pr_debug("MTDSB: Match on device %d (\"%s\")\n",
		mtd->index, mtd->name);
		return 1;
		}

		pr_debug("MTDSB: No match, device %d (\"%s\"), device %d (\"%s\")\n",
		sb->s_mtd->index, sb->s_mtd->name, mtd->index, mtd->name);
		return 0;
		}

		/*
		* mark the superblock by the MTD device it is using
		* - set the device number to be the correct MTD block device for pesuperstence
		* of NFS exports
		*/
		static int get_sb_mtd_set(struct super_block sb, void _mtd)
		{
		struct mtd_info *mtd = _mtd;

		sb->s_mtd = mtd;
		sb->s_dev = MKDEV(MTD_BLOCK_MAJOR, mtd->index);
		sb->s_bdi = bdi_get(mtd_bdi);

		return 0;
		}

		/*
		* get a superblock on an MTD-backed filesystem
		*/
		static struct dentry mount_mtd_aux(struct file_system_type fs_type, int flags,
		const char dev_name, void data,
		struct mtd_info *mtd,
		int (fill_super)(struct super_block , void *, int))
		{
		struct super_block *sb;
		int ret;

		sb = sget(fs_type, get_sb_mtd_compare, get_sb_mtd_set, flags, mtd);
		if (IS_ERR(sb))
		goto out_error;

		if (sb->s_root)
		goto already_mounted;

		/* fresh new superblock */
		pr_debug("MTDSB: New superblock for device %d (\"%s\")\n",
		mtd->index, mtd->name);

		ret = fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
		if (ret < 0) {
		deactivate_locked_super(sb);
		return ERR_PTR(ret);
		}

		/* go */
		sb->s_flags \|= SB_ACTIVE;
		return dget(sb->s_root);

		/* new mountpoint for an already mounted superblock */
		already_mounted:
		pr_debug("MTDSB: Device %d (\"%s\") is already mounted\n",
		mtd->index, mtd->name);
		put_mtd_device(mtd);
		return dget(sb->s_root);

		out_error:
		put_mtd_device(mtd);
		return ERR_CAST(sb);
		}

		/*
		* get a superblock on an MTD-backed filesystem by MTD device number
		*/
		static struct dentry mount_mtd_nr(struct file_system_type fs_type, int flags,
		const char dev_name, void data, int mtdnr,
		int (fill_super)(struct super_block , void *, int))
		{
		struct mtd_info *mtd;

		mtd = get_mtd_device(NULL, mtdnr);
		if (IS_ERR(mtd)) {
		pr_debug("MTDSB: Device #%u doesn't appear to exist\n", mtdnr);
		return ERR_CAST(mtd);
		}

		return mount_mtd_aux(fs_type, flags, dev_name, data, mtd, fill_super);
		}

		/*
		* set up an MTD-based superblock
		*/
		struct dentry mount_mtd(struct file_system_type fs_type, int flags,
		const char dev_name, void data,
		int (fill_super)(struct super_block , void *, int))
		{
		#ifdef CONFIG_BLOCK
		struct block_device *bdev;
		int ret, major;
		#endif
		int mtdnr;

		if (!dev_name)
		return ERR_PTR(-EINVAL);

		pr_debug("MTDSB: dev_name \"%s\"\n", dev_name);

		/* the preferred way of mounting in future; especially when
		* CONFIG_BLOCK=n - we specify the underlying MTD device by number or
		* by name, so that we don't require block device support to be present
		* in the kernel. */
		if (dev_name[0] == 'm' && dev_name[1] == 't' && dev_name[2] == 'd') {
		if (dev_name[3] == ':') {
		struct mtd_info *mtd;

		/* mount by MTD device name */
		pr_debug("MTDSB: mtd:%%s, name \"%s\"\n",
		dev_name + 4);

		mtd = get_mtd_device_nm(dev_name + 4);
		if (!IS_ERR(mtd))
		return mount_mtd_aux(
		fs_type, flags,
		dev_name, data, mtd,
		fill_super);

		printk(KERN_NOTICE "MTD:"
		" MTD device with name \"%s\" not found.\n",
		dev_name + 4);

		} else if (isdigit(dev_name[3])) {
		/* mount by MTD device number name */
		char *endptr;

		mtdnr = simple_strtoul(dev_name + 3, &endptr, 0);
		if (!*endptr) {
		/* It was a valid number */
		pr_debug("MTDSB: mtd%%d, mtdnr %d\n",
		mtdnr);
		return mount_mtd_nr(fs_type, flags,
		dev_name, data,
		mtdnr, fill_super);
		}
		}
		}

		#ifdef CONFIG_BLOCK
		/* try the old way - the hack where we allowed users to mount
		* /dev/mtdblock$(n) but didn't actually _use_ the blockdev
		*/
		bdev = lookup_bdev(dev_name);
		if (IS_ERR(bdev)) {
		ret = PTR_ERR(bdev);
		pr_debug("MTDSB: lookup_bdev() returned %d\n", ret);
		return ERR_PTR(ret);
		}
		pr_debug("MTDSB: lookup_bdev() returned 0\n");

		ret = -EINVAL;

		major = MAJOR(bdev->bd_dev);
		mtdnr = MINOR(bdev->bd_dev);
		bdput(bdev);

		if (major != MTD_BLOCK_MAJOR)
		goto not_an_MTD_device;

		return mount_mtd_nr(fs_type, flags, dev_name, data, mtdnr, fill_super);

		not_an_MTD_device:
		#endif /* CONFIG_BLOCK */

		if (!(flags & SB_SILENT))
		printk(KERN_NOTICE
		"MTD: Attempt to mount non-MTD device \"%s\"\n",
		dev_name);
		return ERR_PTR(-EINVAL);
		}

		EXPORT_SYMBOL_GPL(mount_mtd);

		/*
		* destroy an MTD-based superblock
		*/

fs/cramfs/inode.c

+39 −30

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#include <linux/blkdev.h>
		#include <linux/mtd/mtd.h>
		#include <linux/mtd/super.h>
		#include <linux/fs_context.h>
		#include <linux/slab.h>
		#include <linux/vfs.h>
		#include <linux/mutex.h>
		@@ -506,18 +507,19 @@ static void cramfs_kill_sb(struct super_block *sb)
		kfree(sbi);
		}

		static int cramfs_remount(struct super_block sb, int flags, char *data)
		static int cramfs_reconfigure(struct fs_context *fc)
		{
		sync_filesystem(sb);
		*flags \|= SB_RDONLY;
		sync_filesystem(fc->root->d_sb);
		fc->sb_flags \|= SB_RDONLY;
		return 0;
		}

		static int cramfs_read_super(struct super_block *sb,
		struct cramfs_super *super, int silent)
		static int cramfs_read_super(struct super_block sb, struct fs_context fc,
		struct cramfs_super *super)
		{
		struct cramfs_sb_info *sbi = CRAMFS_SB(sb);
		unsigned long root_offset;
		bool silent = fc->sb_flags & SB_SILENT;

		/* We don't know the real size yet */
		sbi->size = PAGE_SIZE;
		@@ -532,7 +534,7 @@ static int cramfs_read_super(struct super_block *sb,
		/* check for wrong endianness */
		if (super->magic == CRAMFS_MAGIC_WEND) {
		if (!silent)
		pr_err("wrong endianness\n");
		errorf(fc, "cramfs: wrong endianness");
		return -EINVAL;
		}

		@@ -544,22 +546,22 @@ static int cramfs_read_super(struct super_block *sb,
		mutex_unlock(&read_mutex);
		if (super->magic != CRAMFS_MAGIC) {
		if (super->magic == CRAMFS_MAGIC_WEND && !silent)
		pr_err("wrong endianness\n");
		errorf(fc, "cramfs: wrong endianness");
		else if (!silent)
		pr_err("wrong magic\n");
		errorf(fc, "cramfs: wrong magic");
		return -EINVAL;
		}
		}

		/* get feature flags first */
		if (super->flags & ~CRAMFS_SUPPORTED_FLAGS) {
		pr_err("unsupported filesystem features\n");
		errorf(fc, "cramfs: unsupported filesystem features");
		return -EINVAL;
		}

		/* Check that the root inode is in a sane state */
		if (!S_ISDIR(super->root.mode)) {
		pr_err("root is not a directory\n");
		errorf(fc, "cramfs: root is not a directory");
		return -EINVAL;
		}
		/* correct strange, hard-coded permissions of mkcramfs */
		@@ -578,12 +580,12 @@ static int cramfs_read_super(struct super_block *sb,
		sbi->magic = super->magic;
		sbi->flags = super->flags;
		if (root_offset == 0)
		pr_info("empty filesystem");
		infof(fc, "cramfs: empty filesystem");
		else if (!(super->flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
		((root_offset != sizeof(struct cramfs_super)) &&
		(root_offset != 512 + sizeof(struct cramfs_super))))
		{
		pr_err("bad root offset %lu\n", root_offset);
		errorf(fc, "cramfs: bad root offset %lu", root_offset);
		return -EINVAL;
		}

		@@ -609,8 +611,7 @@ static int cramfs_finalize_super(struct super_block *sb,
		return 0;
		}

		static int cramfs_blkdev_fill_super(struct super_block sb, void data,
		int silent)
		static int cramfs_blkdev_fill_super(struct super_block sb, struct fs_context fc)
		{
		struct cramfs_sb_info *sbi;
		struct cramfs_super super;
		@@ -625,14 +626,13 @@ static int cramfs_blkdev_fill_super(struct super_block sb, void data,
		for (i = 0; i < READ_BUFFERS; i++)
		buffer_blocknr[i] = -1;

		err = cramfs_read_super(sb, &super, silent);
		err = cramfs_read_super(sb, fc, &super);
		if (err)
		return err;
		return cramfs_finalize_super(sb, &super.root);
		}

		static int cramfs_mtd_fill_super(struct super_block sb, void data,
		int silent)
		static int cramfs_mtd_fill_super(struct super_block sb, struct fs_context fc)
		{
		struct cramfs_sb_info *sbi;
		struct cramfs_super super;
		@@ -654,7 +654,7 @@ static int cramfs_mtd_fill_super(struct super_block sb, void data,

		pr_info("checking physical address %pap for linear cramfs image\n",
		&sbi->linear_phys_addr);
		err = cramfs_read_super(sb, &super, silent);
		err = cramfs_read_super(sb, fc, &super);
		if (err)
		return err;

		@@ -949,32 +949,41 @@ static const struct inode_operations cramfs_dir_inode_operations = {
		};

		static const struct super_operations cramfs_ops = {
		.remount_fs = cramfs_remount,
		.statfs = cramfs_statfs,
		};

		static struct dentry cramfs_mount(struct file_system_type fs_type, int flags,
		const char dev_name, void data)
		static int cramfs_get_tree(struct fs_context *fc)
		{
		struct dentry *ret = ERR_PTR(-ENOPROTOOPT);
		int ret = -ENOPROTOOPT;

		if (IS_ENABLED(CONFIG_CRAMFS_MTD)) {
		ret = mount_mtd(fs_type, flags, dev_name, data,
		cramfs_mtd_fill_super);
		if (!IS_ERR(ret))
		ret = get_tree_mtd(fc, cramfs_mtd_fill_super);
		if (ret < 0)
		return ret;
		}
		if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) {
		ret = mount_bdev(fs_type, flags, dev_name, data,
		cramfs_blkdev_fill_super);
		}
		if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV))
		ret = get_tree_bdev(fc, cramfs_blkdev_fill_super);
		return ret;
		}

		static const struct fs_context_operations cramfs_context_ops = {
		.get_tree = cramfs_get_tree,
		.reconfigure = cramfs_reconfigure,
		};

		/*
		* Set up the filesystem mount context.
		*/
		static int cramfs_init_fs_context(struct fs_context *fc)
		{
		fc->ops = &cramfs_context_ops;
		return 0;
		}

		static struct file_system_type cramfs_fs_type = {
		.owner = THIS_MODULE,
		.name = "cramfs",
		.mount = cramfs_mount,
		.init_fs_context = cramfs_init_fs_context,
		.kill_sb = cramfs_kill_sb,
		.fs_flags = FS_REQUIRES_DEV,
		};

fs/fs_parser.c

+16 −2

Original line number	Diff line number	Diff line
		@@ -204,9 +204,23 @@ int fs_parse(struct fs_context *fc,
		goto okay;

		case fs_param_is_fd: {
		if (param->type != fs_value_is_file)
		switch (param->type) {
		case fs_value_is_string:
		if (!result->has_value)
		goto bad_value;
		goto okay;

		ret = kstrtouint(param->string, 0, &result->uint_32);
		break;
		case fs_value_is_file:
		result->uint_32 = param->dirfd;
		ret = 0;
		default:
		goto bad_value;
		}

		if (result->uint_32 > INT_MAX)
		goto bad_value;
		goto maybe_okay;
		}

		case fs_param_is_blockdev:

fs/jffs2/fs.c

+11 −10

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		#include <linux/sched.h>
		#include <linux/cred.h>
		#include <linux/fs.h>
		#include <linux/fs_context.h>
		#include <linux/list.h>
		#include <linux/mtd/mtd.h>
		#include <linux/pagemap.h>
		@@ -391,7 +392,7 @@ void jffs2_dirty_inode(struct inode *inode, int flags)
		jffs2_do_setattr(inode, &iattr);
		}

		int jffs2_do_remount_fs(struct super_block sb, int flags, char *data)
		int jffs2_do_remount_fs(struct super_block sb, struct fs_context fc)
		{
		struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);

		@@ -409,10 +410,10 @@ int jffs2_do_remount_fs(struct super_block sb, int flags, char *data)
		mutex_unlock(&c->alloc_sem);
		}

		if (!(*flags & SB_RDONLY))
		if (!(fc->sb_flags & SB_RDONLY))
		jffs2_start_garbage_collect_thread(c);

		*flags \|= SB_NOATIME;
		fc->sb_flags \|= SB_NOATIME;
		return 0;
		}

		@@ -509,7 +510,7 @@ static int calculate_inocache_hashsize(uint32_t flash_size)
		return hashsize;
		}

		int jffs2_do_fill_super(struct super_block sb, void data, int silent)
		int jffs2_do_fill_super(struct super_block sb, struct fs_context fc)
		{
		struct jffs2_sb_info *c;
		struct inode *root_i;
		@@ -524,11 +525,11 @@ int jffs2_do_fill_super(struct super_block sb, void data, int silent)

		#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
		if (c->mtd->type == MTD_NANDFLASH) {
		pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
		errorf(fc, "Cannot operate on NAND flash unless jffs2 NAND support is compiled in");
		return -EINVAL;
		}
		if (c->mtd->type == MTD_DATAFLASH) {
		pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
		errorf(fc, "Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in");
		return -EINVAL;
		}
		#endif
		@@ -542,12 +543,12 @@ int jffs2_do_fill_super(struct super_block sb, void data, int silent)
		*/
		if ((c->sector_size * blocks) != c->flash_size) {
		c->flash_size = c->sector_size * blocks;
		pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
		infof(fc, "Flash size not aligned to erasesize, reducing to %dKiB",
		c->flash_size / 1024);
		}

		if (c->flash_size < 5*c->sector_size) {
		pr_err("Too few erase blocks (%d)\n",
		errorf(fc, "Too few erase blocks (%d)",
		c->flash_size / c->sector_size);
		return -EINVAL;
		}

Admin message