Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/livep...

[sfrench/cifs-2.6.git] / fs / super.c

diff --git a/fs/super.c b/fs/super.c
index 221cfa1f4e92596101c6b2edf3febe6fc7c546b2..166c4ee0d0ed02a00591c9b00cdb69eb8759ca61 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -360,7 +360,7 @@ static int grab_super(struct super_block *s) __releases(sb_lock)
        s->s_count++;
        spin_unlock(&sb_lock);
        down_write(&s->s_umount);
-       if ((s->s_flags & MS_BORN) && atomic_inc_not_zero(&s->s_active)) {
+       if ((s->s_flags & SB_BORN) && atomic_inc_not_zero(&s->s_active)) {
                put_super(s);
                return 1;
        }
@@ -390,7 +390,7 @@ bool trylock_super(struct super_block *sb)
 {
        if (down_read_trylock(&sb->s_umount)) {
                if (!hlist_unhashed(&sb->s_instances) &&
-                   sb->s_root && (sb->s_flags & MS_BORN))
+                   sb->s_root && (sb->s_flags & SB_BORN))
                        return true;
                up_read(&sb->s_umount);
        }
@@ -419,7 +419,7 @@ void generic_shutdown_super(struct super_block *sb)
        if (sb->s_root) {
                shrink_dcache_for_umount(sb);
                sync_filesystem(sb);
-               sb->s_flags &= ~MS_ACTIVE;
+               sb->s_flags &= ~SB_ACTIVE;
 
                fsnotify_unmount_inodes(sb);
                cgroup_writeback_umount();
@@ -472,7 +472,7 @@ struct super_block *sget_userns(struct file_system_type *type,
        struct super_block *old;
        int err;
 
-       if (!(flags & (MS_KERNMOUNT|MS_SUBMOUNT)) &&
+       if (!(flags & (SB_KERNMOUNT|SB_SUBMOUNT)) &&
            !(type->fs_flags & FS_USERNS_MOUNT) &&
            !capable(CAP_SYS_ADMIN))
                return ERR_PTR(-EPERM);
@@ -502,7 +502,7 @@ retry:
        }
        if (!s) {
                spin_unlock(&sb_lock);
-               s = alloc_super(type, (flags & ~MS_SUBMOUNT), user_ns);
+               s = alloc_super(type, (flags & ~SB_SUBMOUNT), user_ns);
                if (!s)
                        return ERR_PTR(-ENOMEM);
                goto retry;
@@ -547,11 +547,11 @@ struct super_block *sget(struct file_system_type *type,
         * mount through to here so always use &init_user_ns
         * until that changes.
         */
-       if (flags & MS_SUBMOUNT)
+       if (flags & SB_SUBMOUNT)
                user_ns = &init_user_ns;
 
        /* Ensure the requestor has permissions over the target filesystem */
-       if (!(flags & (MS_KERNMOUNT|MS_SUBMOUNT)) && !ns_capable(user_ns, CAP_SYS_ADMIN))
+       if (!(flags & (SB_KERNMOUNT|SB_SUBMOUNT)) && !ns_capable(user_ns, CAP_SYS_ADMIN))
                return ERR_PTR(-EPERM);
 
        return sget_userns(type, test, set, flags, user_ns, data);
@@ -594,7 +594,7 @@ void iterate_supers(void (*f)(struct super_block *, void *), void *arg)
                spin_unlock(&sb_lock);
 
                down_read(&sb->s_umount);
-               if (sb->s_root && (sb->s_flags & MS_BORN))
+               if (sb->s_root && (sb->s_flags & SB_BORN))
                        f(sb, arg);
                up_read(&sb->s_umount);
 
@@ -628,7 +628,7 @@ void iterate_supers_type(struct file_system_type *type,
                spin_unlock(&sb_lock);
 
                down_read(&sb->s_umount);
-               if (sb->s_root && (sb->s_flags & MS_BORN))
+               if (sb->s_root && (sb->s_flags & SB_BORN))
                        f(sb, arg);
                up_read(&sb->s_umount);
 
@@ -664,7 +664,7 @@ rescan:
                        else
                                down_write(&sb->s_umount);
                        /* still alive? */
-                       if (sb->s_root && (sb->s_flags & MS_BORN))
+                       if (sb->s_root && (sb->s_flags & SB_BORN))
                                return sb;
                        if (!excl)
                                up_read(&sb->s_umount);
@@ -785,7 +785,7 @@ rescan:
                        spin_unlock(&sb_lock);
                        down_read(&sb->s_umount);
                        /* still alive? */
-                       if (sb->s_root && (sb->s_flags & MS_BORN))
+                       if (sb->s_root && (sb->s_flags & SB_BORN))
                                return sb;
                        up_read(&sb->s_umount);
                        /* nope, got unmounted */
@@ -801,13 +801,13 @@ rescan:
 /**
  *     do_remount_sb - asks filesystem to change mount options.
  *     @sb:    superblock in question
- *     @flags: numeric part of options
+ *     @sb_flags: revised superblock flags
  *     @data:  the rest of options
  *      @force: whether or not to force the change
  *
  *     Alters the mount options of a mounted file system.
  */
-int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
+int do_remount_sb(struct super_block *sb, int sb_flags, void *data, int force)
 {
        int retval;
        int remount_ro;
@@ -816,11 +816,11 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
                return -EBUSY;
 
 #ifdef CONFIG_BLOCK
-       if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
+       if (!(sb_flags & SB_RDONLY) && bdev_read_only(sb->s_bdev))
                return -EACCES;
 #endif
 
-       remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
+       remount_ro = (sb_flags & SB_RDONLY) && !sb_rdonly(sb);
 
        if (remount_ro) {
                if (!hlist_empty(&sb->s_pins)) {
@@ -831,7 +831,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
                                return 0;
                        if (sb->s_writers.frozen != SB_UNFROZEN)
                                return -EBUSY;
-                       remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
+                       remount_ro = (sb_flags & SB_RDONLY) && !sb_rdonly(sb);
                }
        }
        shrink_dcache_sb(sb);
@@ -850,7 +850,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
        }
 
        if (sb->s_op->remount_fs) {
-               retval = sb->s_op->remount_fs(sb, &flags, data);
+               retval = sb->s_op->remount_fs(sb, &sb_flags, data);
                if (retval) {
                        if (!force)
                                goto cancel_readonly;
@@ -859,7 +859,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
                             sb->s_type->name, retval);
                }
        }
-       sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
+       sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (sb_flags & MS_RMT_MASK);
        /* Needs to be ordered wrt mnt_is_readonly() */
        smp_wmb();
        sb->s_readonly_remount = 0;
@@ -892,12 +892,12 @@ static void do_emergency_remount(struct work_struct *work)
                sb->s_count++;
                spin_unlock(&sb_lock);
                down_write(&sb->s_umount);
-               if (sb->s_root && sb->s_bdev && (sb->s_flags & MS_BORN) &&
-                   !(sb->s_flags & MS_RDONLY)) {
+               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, MS_RDONLY, NULL, 1);
+                       do_remount_sb(sb, SB_RDONLY, NULL, 1);
                }
                up_write(&sb->s_umount);
                spin_lock(&sb_lock);
@@ -1023,7 +1023,7 @@ struct dentry *mount_ns(struct file_system_type *fs_type,
        /* Don't allow mounting unless the caller has CAP_SYS_ADMIN
         * over the namespace.
         */
-       if (!(flags & MS_KERNMOUNT) && !ns_capable(user_ns, CAP_SYS_ADMIN))
+       if (!(flags & SB_KERNMOUNT) && !ns_capable(user_ns, CAP_SYS_ADMIN))
                return ERR_PTR(-EPERM);
 
        sb = sget_userns(fs_type, ns_test_super, ns_set_super, flags,
@@ -1033,13 +1033,13 @@ struct dentry *mount_ns(struct file_system_type *fs_type,
 
        if (!sb->s_root) {
                int err;
-               err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
+               err = fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
                if (err) {
                        deactivate_locked_super(sb);
                        return ERR_PTR(err);
                }
 
-               sb->s_flags |= MS_ACTIVE;
+               sb->s_flags |= SB_ACTIVE;
        }
 
        return dget(sb->s_root);
@@ -1071,7 +1071,7 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
        fmode_t mode = FMODE_READ | FMODE_EXCL;
        int error = 0;
 
-       if (!(flags & MS_RDONLY))
+       if (!(flags & SB_RDONLY))
                mode |= FMODE_WRITE;
 
        bdev = blkdev_get_by_path(dev_name, mode, fs_type);
@@ -1089,14 +1089,14 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
                error = -EBUSY;
                goto error_bdev;
        }
-       s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC,
+       s = sget(fs_type, test_bdev_super, set_bdev_super, flags | SB_NOSEC,
                 bdev);
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
        if (IS_ERR(s))
                goto error_s;
 
        if (s->s_root) {
-               if ((flags ^ s->s_flags) & MS_RDONLY) {
+               if ((flags ^ s->s_flags) & SB_RDONLY) {
                        deactivate_locked_super(s);
                        error = -EBUSY;
                        goto error_bdev;
@@ -1116,13 +1116,13 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
                s->s_mode = mode;
                snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
                sb_set_blocksize(s, block_size(bdev));
-               error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
+               error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
                if (error) {
                        deactivate_locked_super(s);
                        goto error;
                }
 
-               s->s_flags |= MS_ACTIVE;
+               s->s_flags |= SB_ACTIVE;
                bdev->bd_super = s;
        }
 
@@ -1162,12 +1162,12 @@ struct dentry *mount_nodev(struct file_system_type *fs_type,
        if (IS_ERR(s))
                return ERR_CAST(s);
 
-       error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
+       error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
        if (error) {
                deactivate_locked_super(s);
                return ERR_PTR(error);
        }
-       s->s_flags |= MS_ACTIVE;
+       s->s_flags |= SB_ACTIVE;
        return dget(s->s_root);
 }
 EXPORT_SYMBOL(mount_nodev);
@@ -1188,12 +1188,12 @@ struct dentry *mount_single(struct file_system_type *fs_type,
        if (IS_ERR(s))
                return ERR_CAST(s);
        if (!s->s_root) {
-               error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
+               error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
                if (error) {
                        deactivate_locked_super(s);
                        return ERR_PTR(error);
                }
-               s->s_flags |= MS_ACTIVE;
+               s->s_flags |= SB_ACTIVE;
        } else {
                do_remount_sb(s, flags, data, 0);
        }
@@ -1227,7 +1227,7 @@ mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
        sb = root->d_sb;
        BUG_ON(!sb);
        WARN_ON(!sb->s_bdi);
-       sb->s_flags |= MS_BORN;
+       sb->s_flags |= SB_BORN;
 
        error = security_sb_kern_mount(sb, flags, secdata);
        if (error)
@@ -1434,12 +1434,12 @@ int freeze_super(struct super_block *sb)
                return -EBUSY;
        }
 
-       if (!(sb->s_flags & MS_BORN)) {
+       if (!(sb->s_flags & SB_BORN)) {
                up_write(&sb->s_umount);
                return 0;       /* sic - it's "nothing to do" */
        }
 
-       if (sb->s_flags & MS_RDONLY) {
+       if (sb_rdonly(sb)) {
                /* Nothing to do really... */
                sb->s_writers.frozen = SB_FREEZE_COMPLETE;
                up_write(&sb->s_umount);
@@ -1502,7 +1502,7 @@ int thaw_super(struct super_block *sb)
                return -EINVAL;
        }
 
-       if (sb->s_flags & MS_RDONLY) {
+       if (sb_rdonly(sb)) {
                sb->s_writers.frozen = SB_UNFROZEN;
                goto out;
        }