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

6 files changed, 30 insertions, 33 deletions

diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
index dd106b1d5d89..5b342ac67d2e 100644
--- a/fs/ext4/ext4_jbd2.c
+++ b/fs/ext4/ext4_jbd2.c
@@ -47,7 +47,7 @@ static int ext4_journal_check_start(struct super_block *sb)
         if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
                 return -EIO;
 
-        if (sb->s_flags & MS_RDONLY)
+        if (sb_rdonly(sb))
                 return -EROFS;
         WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE);
         journal = EXT4_SB(sb)->s_journal;
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 57dcaea762c3..da9c6948ad25 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -371,7 +371,7 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                 return -EIO;
 
         if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
-                     !(sb->s_flags & MS_RDONLY))) {
+                     !sb_rdonly(sb))) {
                 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
                 /*
                  * Sample where the filesystem has been mounted and
diff --git a/fs/ext4/fsync.c b/fs/ext4/fsync.c
index aae2c3971cef..f9230580a84b 100644
--- a/fs/ext4/fsync.c
+++ b/fs/ext4/fsync.c
@@ -107,7 +107,7 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 
         trace_ext4_sync_file_enter(file, datasync);
 
-        if (inode->i_sb->s_flags & MS_RDONLY) {
+        if (sb_rdonly(inode->i_sb)) {
                 /* Make sure that we read updated s_mount_flags value */
                 smp_rmb();
                 if (EXT4_SB(inode->i_sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 71e93a23cec3..ee823022aa34 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -1382,7 +1382,7 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
         int num, ret = 0, used_blks = 0;
 
         /* This should not happen, but just to be sure check this */
-        if (sb->s_flags & MS_RDONLY) {
+        if (sb_rdonly(sb)) {
                 ret = 1;
                 goto out;
         }
diff --git a/fs/ext4/mmp.c b/fs/ext4/mmp.c
index 77cdce1f17ce..84c54f15f1dd 100644
--- a/fs/ext4/mmp.c
+++ b/fs/ext4/mmp.c
@@ -185,7 +185,7 @@ static int kmmpd(void *data)
                         goto exit_thread;
                 }
 
-                if (sb->s_flags & MS_RDONLY) {
+                if (sb_rdonly(sb)) {
                         ext4_warning(sb, "kmmpd being stopped since filesystem "
                                      "has been remounted as readonly.");
                         goto exit_thread;
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 71b9a667e1bc..b104096fce9e 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -405,7 +405,7 @@ static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn)
 
 static void ext4_handle_error(struct super_block *sb)
 {
-        if (sb->s_flags & MS_RDONLY)
+        if (sb_rdonly(sb))
                 return;
 
         if (!test_opt(sb, ERRORS_CONT)) {
@@ -587,8 +587,7 @@ void __ext4_std_error(struct super_block *sb, const char *function,
         /* Special case: if the error is EROFS, and we're not already
          * inside a transaction, then there's really no point in logging
          * an error. */
-        if (errno == -EROFS && journal_current_handle() == NULL &&
-            (sb->s_flags & MS_RDONLY))
+        if (errno == -EROFS && journal_current_handle() == NULL && sb_rdonly(sb))
                 return;
 
         if (ext4_error_ratelimit(sb)) {
@@ -628,7 +627,7 @@ void __ext4_abort(struct super_block *sb, const char *function,
                sb->s_id, function, line, &vaf);
         va_end(args);
 
-        if ((sb->s_flags & MS_RDONLY) == 0) {
+        if (sb_rdonly(sb) == 0) {
                 ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
                 EXT4_SB(sb)->s_mount_flags |= EXT4_MF_FS_ABORTED;
                 /*
@@ -889,11 +888,11 @@ static void ext4_put_super(struct super_block *sb)
         ext4_mb_release(sb);
         ext4_ext_release(sb);
 
-        if (!(sb->s_flags & MS_RDONLY) && !aborted) {
+        if (!sb_rdonly(sb) && !aborted) {
                 ext4_clear_feature_journal_needs_recovery(sb);
                 es->s_state = cpu_to_le16(sbi->s_mount_state);
         }
-        if (!(sb->s_flags & MS_RDONLY))
+        if (!sb_rdonly(sb))
                 ext4_commit_super(sb, 1);
 
         for (i = 0; i < sbi->s_gdb_count; i++)
@@ -2100,7 +2099,7 @@ int ext4_seq_options_show(struct seq_file *seq, void *offset)
         struct super_block *sb = seq->private;
         int rc;
 
-        seq_puts(seq, (sb->s_flags & MS_RDONLY) ? "ro" : "rw");
+        seq_puts(seq, sb_rdonly(sb) ? "ro" : "rw");
         rc = _ext4_show_options(seq, sb, 1);
         seq_puts(seq, "\n");
         return rc;
@@ -2368,7 +2367,7 @@ static int ext4_check_descriptors(struct super_block *sb,
                                  "Checksum for group %u failed (%u!=%u)",
                                  i, le16_to_cpu(ext4_group_desc_csum(sb, i,
                                      gdp)), le16_to_cpu(gdp->bg_checksum));
-                        if (!(sb->s_flags & MS_RDONLY)) {
+                        if (!sb_rdonly(sb)) {
                                 ext4_unlock_group(sb, i);
                                 return 0;
                         }
@@ -3136,8 +3135,7 @@ int ext4_register_li_request(struct super_block *sb,
                 goto out;
         }
 
-        if (first_not_zeroed == ngroups ||
-            (sb->s_flags & MS_RDONLY) ||
+        if (first_not_zeroed == ngroups || sb_rdonly(sb) ||
             !test_opt(sb, INIT_INODE_TABLE))
                 goto out;
 
@@ -3683,7 +3681,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
          * previously didn't change the revision level when setting the flags,
          * so there is a chance incompat flags are set on a rev 0 filesystem.
          */
-        if (!ext4_feature_set_ok(sb, (sb->s_flags & MS_RDONLY)))
+        if (!ext4_feature_set_ok(sb, (sb_rdonly(sb))))
                 goto failed_mount;
 
         blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
@@ -3812,12 +3810,12 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                         sbi->s_hash_unsigned = 3;
                 else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
 #ifdef __CHAR_UNSIGNED__
-                        if (!(sb->s_flags & MS_RDONLY))
+                        if (!sb_rdonly(sb))
                                 es->s_flags |=
                                         cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
                         sbi->s_hash_unsigned = 3;
 #else
-                        if (!(sb->s_flags & MS_RDONLY))
+                        if (!sb_rdonly(sb))
                                 es->s_flags |=
                                         cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
 #endif
@@ -4017,7 +4015,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         needs_recovery = (es->s_last_orphan != 0 ||
                           ext4_has_feature_journal_needs_recovery(sb));
 
-        if (ext4_has_feature_mmp(sb) && !(sb->s_flags & MS_RDONLY))
+        if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb))
                 if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
                         goto failed_mount3a;
 
@@ -4029,7 +4027,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                 err = ext4_load_journal(sb, es, journal_devnum);
                 if (err)
                         goto failed_mount3a;
-        } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) &&
+        } else if (test_opt(sb, NOLOAD) && !sb_rdonly(sb) &&
                    ext4_has_feature_journal_needs_recovery(sb)) {
                 ext4_msg(sb, KERN_ERR, "required journal recovery "
                        "suppressed and not mounted read-only");
@@ -4143,7 +4141,7 @@ no_journal:
                 goto failed_mount_wq;
         }
 
-        if (DUMMY_ENCRYPTION_ENABLED(sbi) && !(sb->s_flags & MS_RDONLY) &&
+        if (DUMMY_ENCRYPTION_ENABLED(sbi) && !sb_rdonly(sb) &&
             !ext4_has_feature_encrypt(sb)) {
                 ext4_set_feature_encrypt(sb);
                 ext4_commit_super(sb, 1);
@@ -4197,7 +4195,7 @@ no_journal:
                 goto failed_mount4;
         }
 
-        if (ext4_setup_super(sb, es, sb->s_flags & MS_RDONLY))
+        if (ext4_setup_super(sb, es, sb_rdonly(sb)))
                 sb->s_flags |= MS_RDONLY;
 
         /* determine the minimum size of new large inodes, if present */
@@ -4285,7 +4283,7 @@ no_journal:
 
 #ifdef CONFIG_QUOTA
         /* Enable quota usage during mount. */
-        if (ext4_has_feature_quota(sb) && !(sb->s_flags & MS_RDONLY)) {
+        if (ext4_has_feature_quota(sb) && !sb_rdonly(sb)) {
                 err = ext4_enable_quotas(sb);
                 if (err)
                         goto failed_mount8;
@@ -4609,7 +4607,7 @@ static int ext4_load_journal(struct super_block *sb,
          * can get read-write access to the device.
          */
         if (ext4_has_feature_journal_needs_recovery(sb)) {
-                if (sb->s_flags & MS_RDONLY) {
+                if (sb_rdonly(sb)) {
                         ext4_msg(sb, KERN_INFO, "INFO: recovery "
                                         "required on readonly filesystem");
                         if (really_read_only) {
@@ -4764,8 +4762,7 @@ static void ext4_mark_recovery_complete(struct super_block *sb,
         if (jbd2_journal_flush(journal) < 0)
                 goto out;
 
-        if (ext4_has_feature_journal_needs_recovery(sb) &&
-            sb->s_flags & MS_RDONLY) {
+        if (ext4_has_feature_journal_needs_recovery(sb) && sb_rdonly(sb)) {
                 ext4_clear_feature_journal_needs_recovery(sb);
                 ext4_commit_super(sb, 1);
         }
@@ -4821,7 +4818,7 @@ int ext4_force_commit(struct super_block *sb)
 {
         journal_t *journal;
 
-        if (sb->s_flags & MS_RDONLY)
+        if (sb_rdonly(sb))
                 return 0;
 
         journal = EXT4_SB(sb)->s_journal;
@@ -4886,7 +4883,7 @@ static int ext4_freeze(struct super_block *sb)
         int error = 0;
         journal_t *journal;
 
-        if (sb->s_flags & MS_RDONLY)
+        if (sb_rdonly(sb))
                 return 0;
 
         journal = EXT4_SB(sb)->s_journal;
@@ -4921,7 +4918,7 @@ out:
  */
 static int ext4_unfreeze(struct super_block *sb)
 {
-        if ((sb->s_flags & MS_RDONLY) || ext4_forced_shutdown(EXT4_SB(sb)))
+        if (sb_rdonly(sb) || ext4_forced_shutdown(EXT4_SB(sb)))
                 return 0;
 
         if (EXT4_SB(sb)->s_journal) {
@@ -5059,7 +5056,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
         if (*flags & MS_LAZYTIME)
                 sb->s_flags |= MS_LAZYTIME;
 
-        if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) {
+        if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) {
                 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {
                         err = -EROFS;
                         goto restore_opts;
@@ -5154,7 +5151,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
          * Reinitialize lazy itable initialization thread based on
          * current settings
          */
-        if ((sb->s_flags & MS_RDONLY) || !test_opt(sb, INIT_INODE_TABLE))
+        if (sb_rdonly(sb) || !test_opt(sb, INIT_INODE_TABLE))
                 ext4_unregister_li_request(sb);
         else {
                 ext4_group_t first_not_zeroed;
@@ -5731,7 +5728,7 @@ static inline int ext2_feature_set_ok(struct super_block *sb)
 {
         if (ext4_has_unknown_ext2_incompat_features(sb))
                 return 0;
-        if (sb->s_flags & MS_RDONLY)
+        if (sb_rdonly(sb))
                 return 1;
         if (ext4_has_unknown_ext2_ro_compat_features(sb))
                 return 0;
@@ -5762,7 +5759,7 @@ static inline int ext3_feature_set_ok(struct super_block *sb)
                 return 0;
         if (!ext4_has_feature_journal(sb))
                 return 0;
-        if (sb->s_flags & MS_RDONLY)
+        if (sb_rdonly(sb))
                 return 1;
         if (ext4_has_unknown_ext3_ro_compat_features(sb))
                 return 0;