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

Pull mount flag updates from Al Viro:
 "Another chunk of fmount preparations from dhowells; only trivial
  conflicts for that part. It separates MS_... bits (very grotty
  mount(2) ABI) from the struct super_block ->s_flags (kernel-internal,
  only a small subset of MS_... stuff).

  This does *not* convert the filesystems to new constants; only the
  infrastructure is done here. The next step in that series is where the
  conflicts would be; that's the conversion of filesystems. It's purely
  mechanical and it's better done after the merge, so if you could run
  something like

	list=$(for i in MS_RDONLY MS_NOSUID MS_NODEV MS_NOEXEC MS_SYNCHRONOUS MS_MANDLOCK MS_DIRSYNC MS_NOATIME MS_NODIRATIME MS_SILENT MS_POSIXACL MS_KERNMOUNT MS_I_VERSION MS_LAZYTIME; do git grep -l $i fs drivers/staging/lustre drivers/mtd ipc mm include/linux; done|sort|uniq|grep -v '^fs/namespace.c$')

	sed -i -e 's/\<MS_RDONLY\>/SB_RDONLY/g' \
	        -e 's/\<MS_NOSUID\>/SB_NOSUID/g' \
	        -e 's/\<MS_NODEV\>/SB_NODEV/g' \
	        -e 's/\<MS_NOEXEC\>/SB_NOEXEC/g' \
	        -e 's/\<MS_SYNCHRONOUS\>/SB_SYNCHRONOUS/g' \
	        -e 's/\<MS_MANDLOCK\>/SB_MANDLOCK/g' \
	        -e 's/\<MS_DIRSYNC\>/SB_DIRSYNC/g' \
	        -e 's/\<MS_NOATIME\>/SB_NOATIME/g' \
	        -e 's/\<MS_NODIRATIME\>/SB_NODIRATIME/g' \
	        -e 's/\<MS_SILENT\>/SB_SILENT/g' \
	        -e 's/\<MS_POSIXACL\>/SB_POSIXACL/g' \
	        -e 's/\<MS_KERNMOUNT\>/SB_KERNMOUNT/g' \
	        -e 's/\<MS_I_VERSION\>/SB_I_VERSION/g' \
	        -e 's/\<MS_LAZYTIME\>/SB_LAZYTIME/g' \
	        $list

  and commit it with something along the lines of 'convert filesystems
  away from use of MS_... constants' as commit message, it would save a
  quite a bit of headache next cycle"

* 'work.mount' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  VFS: Differentiate mount flags (MS_*) from internal superblock flags
  VFS: Convert sb->s_flags & MS_RDONLY to sb_rdonly(sb)
  vfs: Add sb_rdonly(sb) to query the MS_RDONLY flag on s_flags

1 files changed, 34 insertions, 28 deletions

diff --git a/fs/namespace.c b/fs/namespace.c
index df0f7521979a..e48ad0192d81 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -275,7 +275,7 @@ int __mnt_is_readonly(struct vfsmount *mnt)
 {
         if (mnt->mnt_flags & MNT_READONLY)
                 return 1;
-        if (mnt->mnt_sb->s_flags & MS_RDONLY)
+        if (sb_rdonly(mnt->mnt_sb))
                 return 1;
         return 0;
 }
@@ -1029,7 +1029,7 @@ vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void
         if (!mnt)
                 return ERR_PTR(-ENOMEM);
 
-        if (flags & MS_KERNMOUNT)
+        if (flags & SB_KERNMOUNT)
                 mnt->mnt.mnt_flags = MNT_INTERNAL;
 
         root = mount_fs(type, flags, name, data);
@@ -1061,7 +1061,7 @@ vfs_submount(const struct dentry *mountpoint, struct file_system_type *type,
         if (mountpoint->d_sb->s_user_ns != &init_user_ns)
                 return ERR_PTR(-EPERM);
 
-        return vfs_kern_mount(type, MS_SUBMOUNT, name, data);
+        return vfs_kern_mount(type, SB_SUBMOUNT, name, data);
 }
 EXPORT_SYMBOL_GPL(vfs_submount);
 
@@ -1592,8 +1592,8 @@ static int do_umount(struct mount *mnt, int flags)
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
                 down_write(&sb->s_umount);
-                if (!(sb->s_flags & MS_RDONLY))
-                        retval = do_remount_sb(sb, MS_RDONLY, NULL, 0);
+                if (!sb_rdonly(sb))
+                        retval = do_remount_sb(sb, SB_RDONLY, NULL, 0);
                 up_write(&sb->s_umount);
                 return retval;
         }
@@ -2117,7 +2117,7 @@ static void unlock_mount(struct mountpoint *where)
 
 static int graft_tree(struct mount *mnt, struct mount *p, struct mountpoint *mp)
 {
-        if (mnt->mnt.mnt_sb->s_flags & MS_NOUSER)
+        if (mnt->mnt.mnt_sb->s_flags & SB_NOUSER)
                 return -EINVAL;
 
         if (d_is_dir(mp->m_dentry) !=
@@ -2131,9 +2131,9 @@ static int graft_tree(struct mount *mnt, struct mount *p, struct mountpoint *mp)
  * Sanity check the flags to change_mnt_propagation.
  */
 
-static int flags_to_propagation_type(int flags)
+static int flags_to_propagation_type(int ms_flags)
 {
-        int type = flags & ~(MS_REC | MS_SILENT);
+        int type = ms_flags & ~(MS_REC | MS_SILENT);
 
         /* Fail if any non-propagation flags are set */
         if (type & ~(MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
@@ -2147,18 +2147,18 @@ static int flags_to_propagation_type(int flags)
 /*
  * recursively change the type of the mountpoint.
  */
-static int do_change_type(struct path *path, int flag)
+static int do_change_type(struct path *path, int ms_flags)
 {
         struct mount *m;
         struct mount *mnt = real_mount(path->mnt);
-        int recurse = flag & MS_REC;
+        int recurse = ms_flags & MS_REC;
         int type;
         int err = 0;
 
         if (path->dentry != path->mnt->mnt_root)
                 return -EINVAL;
 
-        type = flags_to_propagation_type(flag);
+        type = flags_to_propagation_type(ms_flags);
         if (!type)
                 return -EINVAL;
 
@@ -2280,8 +2280,8 @@ static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
  * If you've mounted a non-root directory somewhere and want to do remount
  * on it - tough luck.
  */
-static int do_remount(struct path *path, int flags, int mnt_flags,
-                      void *data)
+static int do_remount(struct path *path, int ms_flags, int sb_flags,
+                      int mnt_flags, void *data)
 {
         int err;
         struct super_block *sb = path->mnt->mnt_sb;
@@ -2325,12 +2325,12 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
                 return err;
 
         down_write(&sb->s_umount);
-        if (flags & MS_BIND)
-                err = change_mount_flags(path->mnt, flags);
+        if (ms_flags & MS_BIND)
+                err = change_mount_flags(path->mnt, ms_flags);
         else if (!capable(CAP_SYS_ADMIN))
                 err = -EPERM;
         else
-                err = do_remount_sb(sb, flags, data, 0);
+                err = do_remount_sb(sb, sb_flags, data, 0);
         if (!err) {
                 lock_mount_hash();
                 mnt_flags |= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK;
@@ -2495,7 +2495,7 @@ static bool mount_too_revealing(struct vfsmount *mnt, int *new_mnt_flags);
  * create a new mount for userspace and request it to be added into the
  * namespace's tree
  */
-static int do_new_mount(struct path *path, const char *fstype, int flags,
+static int do_new_mount(struct path *path, const char *fstype, int sb_flags,
                         int mnt_flags, const char *name, void *data)
 {
         struct file_system_type *type;
@@ -2509,7 +2509,7 @@ static int do_new_mount(struct path *path, const char *fstype, int flags,
         if (!type)
                 return -ENODEV;
 
-        mnt = vfs_kern_mount(type, flags, name, data);
+        mnt = vfs_kern_mount(type, sb_flags, name, data);
         if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
             !mnt->mnt_sb->s_subtype)
                 mnt = fs_set_subtype(mnt, fstype);
@@ -2764,8 +2764,8 @@ long do_mount(const char *dev_name, const char __user *dir_name,
                 const char *type_page, unsigned long flags, void *data_page)
 {
         struct path path;
+        unsigned int mnt_flags = 0, sb_flags;
         int retval = 0;
-        int mnt_flags = 0;
 
         /* Discard magic */
         if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
@@ -2775,6 +2775,9 @@ long do_mount(const char *dev_name, const char __user *dir_name,
         if (data_page)
                 ((char *)data_page)[PAGE_SIZE - 1] = 0;
 
+        if (flags & MS_NOUSER)
+                return -EINVAL;
+
         /* ... and get the mountpoint */
         retval = user_path(dir_name, &path);
         if (retval)
@@ -2784,7 +2787,7 @@ long do_mount(const char *dev_name, const char __user *dir_name,
                                    type_page, flags, data_page);
         if (!retval && !may_mount())
                 retval = -EPERM;
-        if (!retval && (flags & MS_MANDLOCK) && !may_mandlock())
+        if (!retval && (flags & SB_MANDLOCK) && !may_mandlock())
                 retval = -EPERM;
         if (retval)
                 goto dput_out;
@@ -2806,7 +2809,7 @@ long do_mount(const char *dev_name, const char __user *dir_name,
                 mnt_flags |= MNT_NODIRATIME;
         if (flags & MS_STRICTATIME)
                 mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
-        if (flags & MS_RDONLY)
+        if (flags & SB_RDONLY)
                 mnt_flags |= MNT_READONLY;
 
         /* The default atime for remount is preservation */
@@ -2817,12 +2820,15 @@ long do_mount(const char *dev_name, const char __user *dir_name,
                 mnt_flags |= path.mnt->mnt_flags & MNT_ATIME_MASK;
         }
 
-        flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |
-                   MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |
-                   MS_STRICTATIME | MS_NOREMOTELOCK | MS_SUBMOUNT);
+        sb_flags = flags & (SB_RDONLY |
+                            SB_SYNCHRONOUS |
+                            SB_MANDLOCK |
+                            SB_DIRSYNC |
+                            SB_SILENT |
+                            SB_POSIXACL);
 
         if (flags & MS_REMOUNT)
-                retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,
+                retval = do_remount(&path, flags, sb_flags, mnt_flags,
                                     data_page);
         else if (flags & MS_BIND)
                 retval = do_loopback(&path, dev_name, flags & MS_REC);
@@ -2831,7 +2837,7 @@ long do_mount(const char *dev_name, const char __user *dir_name,
         else if (flags & MS_MOVE)
                 retval = do_move_mount(&path, dev_name);
         else
-                retval = do_new_mount(&path, type_page, flags, mnt_flags,
+                retval = do_new_mount(&path, type_page, sb_flags, mnt_flags,
                                       dev_name, data_page);
 dput_out:
         path_put(&path);
@@ -3281,7 +3287,7 @@ void put_mnt_ns(struct mnt_namespace *ns)
 struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
 {
         struct vfsmount *mnt;
-        mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
+        mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, data);
         if (!IS_ERR(mnt)) {
                 /*
                  * it is a longterm mount, don't release mnt until
@@ -3358,7 +3364,7 @@ static bool mnt_already_visible(struct mnt_namespace *ns, struct vfsmount *new,
                 mnt_flags = mnt->mnt.mnt_flags;
 
                 /* Don't miss readonly hidden in the superblock flags */
-                if (mnt->mnt.mnt_sb->s_flags & MS_RDONLY)
+                if (sb_rdonly(mnt->mnt.mnt_sb))
                         mnt_flags |= MNT_LOCK_READONLY;
 
                 /* Verify the mount flags are equal to or more permissive