convert do_remount_sb() to fs_context

Replace do_remount_sb() with a function, reconfigure_super(), that's
fs_context aware.  The fs_context is expected to be parameterised already
and have ->root pointing to the superblock to be reconfigured.

A legacy wrapper is provided that is intended to be called from the
fs_context ops when those appear, but for now is called directly from
reconfigure_super().  This wrapper invokes the ->remount_fs() superblock op
for the moment.  It is intended that the remount_fs() op will be phased
out.

The fs_context->purpose is set to FS_CONTEXT_FOR_RECONFIGURE to indicate
that the context is being used for reconfiguration.

do_umount_root() is provided to consolidate remount-to-R/O for umount and
emergency remount by creating a context and invoking reconfiguration.

do_remount(), do_umount() and do_emergency_remount_callback() are switched
to use the new process.

[AV -- fold UMOUNT and EMERGENCY_REMOUNT in; fixes the
umount / bug, gets rid of pointless complexity]
[AV -- set ->net_ns in all cases; nfs remount will need that]
[AV -- shift security_sb_remount() call into reconfigure_super(); the callers
that didn't do security_sb_remount() have NULL fc->security anyway, so it's
a no-op for them]

Signed-off-by: David Howells <dhowells@redhat.com>
Co-developed-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/fs_context.c b/fs/fs_context.c
index 857cd46a687b786b57ee3a025fe198f4a4929fe8..5e2c3aba1dd8301eee0222246208bd65f9b47604 100644 (file)
--- a/fs/fs_context.c
+++ b/fs/fs_context.c
@@ -69,6 +69,13 @@ static struct fs_context *alloc_fs_context(struct file_system_type *fs_type,
        case FS_CONTEXT_FOR_MOUNT:
                fc->user_ns = get_user_ns(fc->cred->user_ns);
                break;
+       case FS_CONTEXT_FOR_RECONFIGURE:
+               /* We don't pin any namespaces as the superblock's
+                * subscriptions cannot be changed at this point.
+                */
+               atomic_inc(&reference->d_sb->s_active);
+               fc->root = dget(reference);
+               break;
        }
 
        ret = legacy_init_fs_context(fc);
@@ -90,6 +97,15 @@ struct fs_context *fs_context_for_mount(struct file_system_type *fs_type,
 }
 EXPORT_SYMBOL(fs_context_for_mount);
 
+struct fs_context *fs_context_for_reconfigure(struct dentry *dentry,
+                                       unsigned int sb_flags,
+                                       unsigned int sb_flags_mask)
+{
+       return alloc_fs_context(dentry->d_sb->s_type, dentry, sb_flags,
+                               sb_flags_mask, FS_CONTEXT_FOR_RECONFIGURE);
+}
+EXPORT_SYMBOL(fs_context_for_reconfigure);
+
 void fc_drop_locked(struct fs_context *fc)
 {
        struct super_block *sb = fc->root->d_sb;
@@ -99,6 +115,7 @@ void fc_drop_locked(struct fs_context *fc)
 }
 
 static void legacy_fs_context_free(struct fs_context *fc);
+
 /**
  * put_fs_context - Dispose of a superblock configuration context.
  * @fc: The context to dispose of.
@@ -118,8 +135,7 @@ void put_fs_context(struct fs_context *fc)
                legacy_fs_context_free(fc);
 
        security_free_mnt_opts(&fc->security);
-       if (fc->net_ns)
-               put_net(fc->net_ns);
+       put_net(fc->net_ns);
        put_user_ns(fc->user_ns);
        put_cred(fc->cred);
        kfree(fc->subtype);
@@ -172,6 +188,21 @@ int legacy_get_tree(struct fs_context *fc)
        return 0;
 }
 
+/*
+ * Handle remount.
+ */
+int legacy_reconfigure(struct fs_context *fc)
+{
+       struct legacy_fs_context *ctx = fc->fs_private;
+       struct super_block *sb = fc->root->d_sb;
+
+       if (!sb->s_op->remount_fs)
+               return 0;
+
+       return sb->s_op->remount_fs(sb, &fc->sb_flags,
+                                   ctx ? ctx->legacy_data : NULL);
+}
+
 /*
  * Initialise a legacy context for a filesystem that doesn't support
  * fs_context.

diff --git a/fs/internal.h b/fs/internal.h
index 6af26d897034b9834b7d6bf94d41ceeb27b78a4e..016a5b8dd305d21feecc0e9329685742ce303c1d 100644 (file)
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -56,6 +56,7 @@ extern void __init chrdev_init(void);
  * fs_context.c
  */
 extern int legacy_get_tree(struct fs_context *fc);
+extern int legacy_reconfigure(struct fs_context *fc);
 extern int parse_monolithic_mount_data(struct fs_context *, void *);
 extern void fc_drop_locked(struct fs_context *);
 
@@ -107,7 +108,7 @@ extern struct file *alloc_empty_file_noaccount(int, const struct cred *);
 /*
  * super.c
  */
-extern int do_remount_sb(struct super_block *, int, void *, int);
+extern int reconfigure_super(struct fs_context *);
 extern bool trylock_super(struct super_block *sb);
 extern struct super_block *user_get_super(dev_t);
 

diff --git a/fs/namespace.c b/fs/namespace.c
index 750500c6c33d19add8ae7429285bf398a97a3162..931228d8518a1c5e77c318fc6bac44da5edcd4ce 100644 (file)
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1489,6 +1489,29 @@ static void umount_tree(struct mount *mnt, enum umount_tree_flags how)
 
 static void shrink_submounts(struct mount *mnt);
 
+static int do_umount_root(struct super_block *sb)
+{
+       int ret = 0;
+
+       down_write(&sb->s_umount);
+       if (!sb_rdonly(sb)) {
+               struct fs_context *fc;
+
+               fc = fs_context_for_reconfigure(sb->s_root, SB_RDONLY,
+                                               SB_RDONLY);
+               if (IS_ERR(fc)) {
+                       ret = PTR_ERR(fc);
+               } else {
+                       ret = parse_monolithic_mount_data(fc, NULL);
+                       if (!ret)
+                               ret = reconfigure_super(fc);
+                       put_fs_context(fc);
+               }
+       }
+       up_write(&sb->s_umount);
+       return ret;
+}
+
 static int do_umount(struct mount *mnt, int flags)
 {
        struct super_block *sb = mnt->mnt.mnt_sb;
@@ -1554,11 +1577,7 @@ static int do_umount(struct mount *mnt, int flags)
                 */
                if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN))
                        return -EPERM;
-               down_write(&sb->s_umount);
-               if (!sb_rdonly(sb))
-                       retval = do_remount_sb(sb, SB_RDONLY, NULL, 0);
-               up_write(&sb->s_umount);
-               return retval;
+               return do_umount_root(sb);
        }
 
        namespace_lock();
@@ -2367,7 +2386,7 @@ static int do_remount(struct path *path, int ms_flags, int sb_flags,
        int err;
        struct super_block *sb = path->mnt->mnt_sb;
        struct mount *mnt = real_mount(path->mnt);
-       void *sec_opts = NULL;
+       struct fs_context *fc;
 
        if (!check_mnt(mnt))
                return -EINVAL;
@@ -2378,24 +2397,22 @@ static int do_remount(struct path *path, int ms_flags, int sb_flags,
        if (!can_change_locked_flags(mnt, mnt_flags))
                return -EPERM;
 
-       if (data && !(sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)) {
-               err = security_sb_eat_lsm_opts(data, &sec_opts);
-               if (err)
-                       return err;
-       }
-       err = security_sb_remount(sb, sec_opts);
-       security_free_mnt_opts(&sec_opts);
-       if (err)
-               return err;
+       fc = fs_context_for_reconfigure(path->dentry, sb_flags, MS_RMT_MASK);
+       if (IS_ERR(fc))
+               return PTR_ERR(fc);
 
-       down_write(&sb->s_umount);
-       err = -EPERM;
-       if (ns_capable(sb->s_user_ns, CAP_SYS_ADMIN)) {
-               err = do_remount_sb(sb, sb_flags, data, 0);
-               if (!err)
-                       set_mount_attributes(mnt, mnt_flags);
+       err = parse_monolithic_mount_data(fc, data);
+       if (!err) {
+               down_write(&sb->s_umount);
+               err = -EPERM;
+               if (ns_capable(sb->s_user_ns, CAP_SYS_ADMIN)) {
+                       err = reconfigure_super(fc);
+                       if (!err)
+                               set_mount_attributes(mnt, mnt_flags);
+               }
+               up_write(&sb->s_umount);
        }
-       up_write(&sb->s_umount);
+       put_fs_context(fc);
        return err;
 }
 

diff --git a/fs/super.c b/fs/super.c
index 11e2a6cb3bafa408a126bcb99f977a03d4a4a784..50553233dd15938982d8c11b46cb3523ea4e2cff 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -836,28 +836,35 @@ rescan:
 }
 
 /**
- *     do_remount_sb - asks filesystem to change mount options.
- *     @sb:    superblock in question
- *     @sb_flags: revised superblock flags
- *     @data:  the rest of options
- *      @force: whether or not to force the change
+ * reconfigure_super - asks filesystem to change superblock parameters
+ * @fc: The superblock and configuration
  *
- *     Alters the mount options of a mounted file system.
+ * Alters the configuration parameters of a live superblock.
  */
-int do_remount_sb(struct super_block *sb, int sb_flags, void *data, int force)
+int reconfigure_super(struct fs_context *fc)
 {
+       struct super_block *sb = fc->root->d_sb;
        int retval;
-       int remount_ro;
+       bool remount_ro = false;
+       bool force = fc->sb_flags & SB_FORCE;
 
+       if (fc->sb_flags_mask & ~MS_RMT_MASK)
+               return -EINVAL;
        if (sb->s_writers.frozen != SB_UNFROZEN)
                return -EBUSY;
 
+       retval = security_sb_remount(sb, fc->security);
+       if (retval)
+               return retval;
+
+       if (fc->sb_flags_mask & SB_RDONLY) {
 #ifdef CONFIG_BLOCK
-       if (!(sb_flags & SB_RDONLY) && bdev_read_only(sb->s_bdev))
-               return -EACCES;
+               if (!(fc->sb_flags & SB_RDONLY) && bdev_read_only(sb->s_bdev))
+                       return -EACCES;
 #endif
 
-       remount_ro = (sb_flags & SB_RDONLY) && !sb_rdonly(sb);
+               remount_ro = (fc->sb_flags & SB_RDONLY) && !sb_rdonly(sb);
+       }
 
        if (remount_ro) {
                if (!hlist_empty(&sb->s_pins)) {
@@ -868,13 +875,14 @@ int do_remount_sb(struct super_block *sb, int sb_flags, void *data, int force)
                                return 0;
                        if (sb->s_writers.frozen != SB_UNFROZEN)
                                return -EBUSY;
-                       remount_ro = (sb_flags & SB_RDONLY) && !sb_rdonly(sb);
+                       remount_ro = !sb_rdonly(sb);
                }
        }
        shrink_dcache_sb(sb);
 
-       /* If we are remounting RDONLY and current sb is read/write,
-          make sure there are no rw files opened */
+       /* If we are reconfiguring to RDONLY and current sb is read/write,
+        * make sure there are no files open for writing.
+        */
        if (remount_ro) {
                if (force) {
                        sb->s_readonly_remount = 1;
@@ -886,17 +894,17 @@ int do_remount_sb(struct super_block *sb, int sb_flags, void *data, int force)
                }
        }
 
-       if (sb->s_op->remount_fs) {
-               retval = sb->s_op->remount_fs(sb, &sb_flags, data);
-               if (retval) {
-                       if (!force)
-                               goto cancel_readonly;
-                       /* If forced remount, go ahead despite any errors */
-                       WARN(1, "forced remount of a %s fs returned %i\n",
-                            sb->s_type->name, retval);
-               }
+       retval = legacy_reconfigure(fc);
+       if (retval) {
+               if (!force)
+                       goto cancel_readonly;
+               /* If forced remount, go ahead despite any errors */
+               WARN(1, "forced remount of a %s fs returned %i\n",
+                    sb->s_type->name, retval);
        }
-       sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (sb_flags & MS_RMT_MASK);
+
+       WRITE_ONCE(sb->s_flags, ((sb->s_flags & ~fc->sb_flags_mask) |
+                                (fc->sb_flags & fc->sb_flags_mask)));
        /* Needs to be ordered wrt mnt_is_readonly() */
        smp_wmb();
        sb->s_readonly_remount = 0;
@@ -923,10 +931,15 @@ static void do_emergency_remount_callback(struct super_block *sb)
        down_write(&sb->s_umount);
        if (sb->s_root && sb->s_bdev && (sb->s_flags & SB_BORN) &&
            !sb_rdonly(sb)) {
-               /*
-                * What lock protects sb->s_flags??
-                */
-               do_remount_sb(sb, SB_RDONLY, NULL, 1);
+               struct fs_context *fc;
+
+               fc = fs_context_for_reconfigure(sb->s_root,
+                                       SB_RDONLY | SB_FORCE, SB_RDONLY);
+               if (!IS_ERR(fc)) {
+                       if (parse_monolithic_mount_data(fc, NULL) == 0)
+                               (void)reconfigure_super(fc);
+                       put_fs_context(fc);
+               }
        }
        up_write(&sb->s_umount);
 }
@@ -1213,6 +1226,31 @@ struct dentry *mount_nodev(struct file_system_type *fs_type,
 }
 EXPORT_SYMBOL(mount_nodev);
 
+static int reconfigure_single(struct super_block *s,
+                             int flags, void *data)
+{
+       struct fs_context *fc;
+       int ret;
+
+       /* The caller really need to be passing fc down into mount_single(),
+        * then a chunk of this can be removed.  [Bollocks -- AV]
+        * Better yet, reconfiguration shouldn't happen, but rather the second
+        * mount should be rejected if the parameters are not compatible.
+        */
+       fc = fs_context_for_reconfigure(s->s_root, flags, MS_RMT_MASK);
+       if (IS_ERR(fc))
+               return PTR_ERR(fc);
+
+       ret = parse_monolithic_mount_data(fc, data);
+       if (ret < 0)
+               goto out;
+
+       ret = reconfigure_super(fc);
+out:
+       put_fs_context(fc);
+       return ret;
+}
+
 static int compare_single(struct super_block *s, void *p)
 {
        return 1;
@@ -1230,13 +1268,14 @@ struct dentry *mount_single(struct file_system_type *fs_type,
                return ERR_CAST(s);
        if (!s->s_root) {
                error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
-               if (error) {
-                       deactivate_locked_super(s);
-                       return ERR_PTR(error);
-               }
-               s->s_flags |= SB_ACTIVE;
+               if (!error)
+                       s->s_flags |= SB_ACTIVE;
        } else {
-               do_remount_sb(s, flags, data, 0);
+               error = reconfigure_single(s, flags, data);
+       }
+       if (unlikely(error)) {
+               deactivate_locked_super(s);
+               return ERR_PTR(error);
        }
        return dget(s->s_root);
 }

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 36fff12ab8904f9eaec8b1f8164eb0eaddf3c37f..c65d02c5c51240d3a176e547c47c8d5924b50f9f 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1337,6 +1337,7 @@ extern int send_sigurg(struct fown_struct *fown);
 
 /* These sb flags are internal to the kernel */
 #define SB_SUBMOUNT     (1<<26)
+#define SB_FORCE       (1<<27)
 #define SB_NOSEC       (1<<28)
 #define SB_BORN                (1<<29)
 #define SB_ACTIVE      (1<<30)

diff --git a/include/linux/fs_context.h b/include/linux/fs_context.h
index 9805514444c969d84e6bf4d8fc15e7be61adf3c5..98772f882a3e76cad517af5bc173469e2f43b14f 100644 (file)
--- a/include/linux/fs_context.h
+++ b/include/linux/fs_context.h
@@ -25,6 +25,7 @@ struct user_namespace;
 
 enum fs_context_purpose {
        FS_CONTEXT_FOR_MOUNT,           /* New superblock for explicit mount */
+       FS_CONTEXT_FOR_RECONFIGURE,     /* Superblock reconfiguration (remount) */
 };
 
 /*
@@ -57,6 +58,9 @@ struct fs_context {
  */
 extern struct fs_context *fs_context_for_mount(struct file_system_type *fs_type,
                                                unsigned int sb_flags);
+extern struct fs_context *fs_context_for_reconfigure(struct dentry *dentry,
+                                               unsigned int sb_flags,
+                                               unsigned int sb_flags_mask);
 
 extern int vfs_get_tree(struct fs_context *fc);
 extern void put_fs_context(struct fs_context *fc);