History

Rename superblock flags (MS_xyz -> SB_xyz)

This is a pure automated search-and-replace of the internal kernel superblock flags. The s_flags are now called SB_*, with the names and the values for the moment mirroring the MS_* flags that they're equivalent to. Note how the MS_xyz flags are the ones passed to the mount system call, while the SB_xyz flags are what we then use in sb->s_flags. The script to do this was: # places to look in; re security/*: it generally should *not* be # touched (that stuff parses mount(2) arguments directly), but # there are two places where we really deal with superblock flags. FILES="drivers/mtd drivers/staging/lustre fs ipc mm \ include/linux/fs.h include/uapi/linux/bfs_fs.h \ security/apparmor/apparmorfs.c security/apparmor/include/lib.h" # the list of MS_... constants SYMS="RDONLY NOSUID NODEV NOEXEC SYNCHRONOUS REMOUNT MANDLOCK \ DIRSYNC NOATIME NODIRATIME BIND MOVE REC VERBOSE SILENT \ POSIXACL UNBINDABLE PRIVATE SLAVE SHARED RELATIME KERNMOUNT \ I_VERSION STRICTATIME LAZYTIME SUBMOUNT NOREMOTELOCK NOSEC BORN \ ACTIVE NOUSER" SED_PROG= for i in $SYMS; do SED_PROG="$SED_PROG -e s/MS_$i/SB_$i/g"; done # we want files that contain at least one of MS_..., # with fs/namespace.c and fs/pnode.c excluded. L=$(for i in $SYMS; do git grep -w -l MS_$i $FILES; done| sort|uniq|grep -v '^fs/namespace.c'|grep -v '^fs/pnode.c') for f in $L; do sed -i $f $SED_PROG; done

Linus Torvalds committed 8 years ago

Commit 1751e8a1 parent 141cbfb111 files · +417 −417Browse files

Unified · Split

111 files
  1. drivers/mtd/mtdsuper.c +3 −3
  2. drivers/staging/lustre/lustre/llite/file.c +1 −1
  3. drivers/staging/lustre/lustre/llite/llite_lib.c +7 −7
  4. fs/9p/vfs_super.c +3 −3
  5. fs/adfs/super.c +2 −2
  6. fs/affs/amigaffs.c +1 −1
  7. fs/affs/bitmap.c +3 −3
  8. fs/affs/super.c +8 −8
  9. fs/afs/super.c +2 −2
  10. fs/befs/ChangeLog +1 −1
  11. fs/befs/linuxvfs.c +2 −2
  12. fs/btrfs/ctree.h +1 −1
  13. fs/btrfs/extent_io.c +1 −1
  14. fs/btrfs/ioctl.c +2 −2
  15. fs/btrfs/super.c +25 −25
  16. fs/btrfs/volumes.c +2 −2
  17. fs/ceph/super.c +4 −4
  18. fs/cifs/cifs_fs_sb.h +1 −1
  19. fs/cifs/cifsfs.c +6 −6
  20. fs/cifs/cifsglob.h +2 −2
  21. fs/cifs/inode.c +1 −1
  22. fs/cifs/xattr.c +4 −4
  23. fs/coda/inode.c +2 −2
  24. fs/cramfs/inode.c +2 −2
  25. fs/ecryptfs/main.c +4 −4
  26. fs/efs/super.c +2 −2
  27. fs/ext2/balloc.c +2 −2
  28. fs/ext2/ialloc.c +2 −2
  29. fs/ext2/super.c +10 −10
  30. fs/ext4/inode.c +2 −2
  31. fs/ext4/super.c +26 −26
  32. fs/f2fs/checkpoint.c +5 −5
  33. fs/f2fs/f2fs.h +1 −1
  34. fs/f2fs/gc.c +1 −1
  35. fs/f2fs/recovery.c +5 −5
  36. fs/f2fs/super.c +14 −14
  37. fs/fat/fatent.c +3 −3
  38. fs/fat/inode.c +4 −4
  39. fs/fat/misc.c +1 −1
  40. fs/fat/namei_msdos.c +1 −1
  41. fs/freevxfs/vxfs_super.c +2 −2
  42. fs/fs-writeback.c +1 −1
  43. fs/fuse/inode.c +6 −6
  44. fs/gfs2/ops_fstype.c +8 −8
  45. fs/gfs2/super.c +5 −5
  46. fs/gfs2/trans.c +1 −1
  47. fs/hfs/mdb.c +2 −2
  48. fs/hfs/super.c +8 −8
  49. fs/hfsplus/super.c +11 −11
  50. fs/hpfs/map.c +1 −1
  51. fs/hpfs/super.c +4 −4
  52. fs/inode.c +5 −5
  53. fs/isofs/inode.c +1 −1
  54. fs/jffs2/fs.c +2 −2
  55. fs/jffs2/os-linux.h +1 −1
  56. fs/jffs2/super.c +2 −2
  57. fs/jfs/super.c +5 −5
  58. fs/kernfs/mount.c +1 −1
  59. fs/libfs.c +3 −3
  60. fs/locks.c +1 −1
  61. fs/minix/inode.c +2 −2
  62. fs/ncpfs/inode.c +2 −2
  63. fs/nfs/dir.c +1 −1
  64. fs/nfs/inode.c +1 −1
  65. fs/nfs/internal.h +1 −1
  66. fs/nfs/super.c +11 −11
  67. fs/nilfs2/segment.c +1 −1
  68. fs/nilfs2/super.c +12 −12
  69. fs/nilfs2/the_nilfs.c +3 −3
  70. fs/notify/fsnotify.c +1 −1
  71. fs/nsfs.c +1 −1
  72. fs/ntfs/super.c +16 −16
  73. fs/ocfs2/file.c +1 −1
  74. fs/ocfs2/super.c +14 −14
  75. fs/ocfs2/xattr.c +1 −1
  76. fs/openpromfs/inode.c +2 −2
  77. fs/orangefs/super.c +4 −4
  78. fs/overlayfs/super.c +5 −5
  79. fs/proc/inode.c +1 −1
  80. fs/proc/root.c +1 −1
  81. fs/proc_namespace.c +4 −4
  82. fs/qnx4/inode.c +2 −2
  83. fs/qnx6/inode.c +2 −2
  84. fs/reiserfs/inode.c +1 −1
  85. fs/reiserfs/journal.c +3 −3
  86. fs/reiserfs/prints.c +2 −2
  87. fs/reiserfs/super.c +9 −9
  88. fs/reiserfs/xattr.c +5 −5
  89. fs/romfs/super.c +2 −2
  90. fs/squashfs/super.c +2 −2
  91. fs/statfs.c +3 −3
  92. fs/sysfs/mount.c +1 −1
  93. fs/sysv/inode.c +1 −1
  94. fs/sysv/super.c +1 −1
  95. fs/ubifs/file.c +1 −1
  96. fs/ubifs/io.c +1 −1
  97. fs/ubifs/super.c +10 −10
  98. fs/ubifs/ubifs.h +2 −2
  99. fs/udf/super.c +3 −3
  100. fs/ufs/balloc.c +4 −4
  101. fs/ufs/ialloc.c +5 −5
  102. fs/ufs/super.c +15 −15
  103. fs/xfs/xfs_log.c +3 −3
  104. fs/xfs/xfs_super.c +4 −4
  105. fs/xfs/xfs_super.h +1 −1
  106. include/linux/fs.h +1 −1
  107. include/uapi/linux/bfs_fs.h +1 −1
  108. ipc/mqueue.c +1 −1
  109. mm/shmem.c +5 −5
  110. security/apparmor/apparmorfs.c +1 −1
  111. security/apparmor/include/lib.h +1 −1
drivers/mtd/mtdsuper.c+3−3
@@ -79,14 +79,14 @@ static struct dentry *mount_mtd_aux(struct file_system_type *fs_type, int flags, · 78 unmodified lines
7979 pr_debug("MTDSB: New superblock for device %d (\"%s\")\n",
8080 mtd->index, mtd->name);
8181
82− ret = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
82+ ret = fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
8383 if (ret < 0) {
8484 deactivate_locked_super(sb);
8585 return ERR_PTR(ret);
8686 }
8787
8888 /* go */
89− sb->s_flags |= MS_ACTIVE;
89+ sb->s_flags |= SB_ACTIVE;
9090 return dget(sb->s_root);
9191
9292 /* new mountpoint for an already mounted superblock */
@@ -202,7 +202,7 @@ struct dentry *mount_mtd(struct file_system_type *fs_type, int flags, · 109 unmodified lines
202202 not_an_MTD_device:
203203 #endif /* CONFIG_BLOCK */
204204
205− if (!(flags & MS_SILENT))
205+ if (!(flags & SB_SILENT))
206206 printk(KERN_NOTICE
207207 "MTD: Attempt to mount non-MTD device \"%s\"\n",
208208 dev_name);
drivers/staging/lustre/lustre/llite/file.c+1−1
@@ -1016,7 +1016,7 @@ static bool file_is_noatime(const struct file *file) · 1015 unmodified lines
10161016 if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
10171017 return true;
10181018
1019− if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1019+ if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode))
10201020 return true;
10211021
10221022 return false;
drivers/staging/lustre/lustre/llite/llite_lib.c+7−7
@@ -313,11 +313,11 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt, · 312 unmodified lines
313313 }
314314
315315 if (data->ocd_connect_flags & OBD_CONNECT_ACL) {
316− sb->s_flags |= MS_POSIXACL;
316+ sb->s_flags |= SB_POSIXACL;
317317 sbi->ll_flags |= LL_SBI_ACL;
318318 } else {
319319 LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");
320− sb->s_flags &= ~MS_POSIXACL;
320+ sb->s_flags &= ~SB_POSIXACL;
321321 sbi->ll_flags &= ~LL_SBI_ACL;
322322 }
323323
@@ -660,7 +660,7 @@ void ll_kill_super(struct super_block *sb) · 336 unmodified lines
660660 struct ll_sb_info *sbi;
661661
662662 /* not init sb ?*/
663− if (!(sb->s_flags & MS_ACTIVE))
663+ if (!(sb->s_flags & SB_ACTIVE))
664664 return;
665665
666666 sbi = ll_s2sbi(sb);
@@ -2039,8 +2039,8 @@ int ll_remount_fs(struct super_block *sb, int *flags, char *data) · 1372 unmodified lines
20392039 int err;
20402040 __u32 read_only;
20412041
2042− if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) {
2043− read_only = *flags & MS_RDONLY;
2042+ if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
2043+ read_only = *flags & SB_RDONLY;
20442044 err = obd_set_info_async(NULL, sbi->ll_md_exp,
20452045 sizeof(KEY_READ_ONLY),
20462046 KEY_READ_ONLY, sizeof(read_only),
@@ -2053,9 +2053,9 @@ int ll_remount_fs(struct super_block *sb, int *flags, char *data) · 6 unmodified lines
20532053 }
20542054
20552055 if (read_only)
2056− sb->s_flags |= MS_RDONLY;
2056+ sb->s_flags |= SB_RDONLY;
20572057 else
2058− sb->s_flags &= ~MS_RDONLY;
2058+ sb->s_flags &= ~SB_RDONLY;
20592059
20602060 if (sbi->ll_flags & LL_SBI_VERBOSE)
20612061 LCONSOLE_WARN("Remounted %s %s\n", profilenm,
fs/9p/vfs_super.c+3−3
@@ -94,13 +94,13 @@ v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses, · 93 unmodified lines
9494 if (v9ses->cache)
9595 sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_SIZE;
9696
97− sb->s_flags |= MS_ACTIVE | MS_DIRSYNC | MS_NOATIME;
97+ sb->s_flags |= SB_ACTIVE | SB_DIRSYNC | SB_NOATIME;
9898 if (!v9ses->cache)
99− sb->s_flags |= MS_SYNCHRONOUS;
99+ sb->s_flags |= SB_SYNCHRONOUS;
100100
101101 #ifdef CONFIG_9P_FS_POSIX_ACL
102102 if ((v9ses->flags & V9FS_ACL_MASK) == V9FS_POSIX_ACL)
103− sb->s_flags |= MS_POSIXACL;
103+ sb->s_flags |= SB_POSIXACL;
104104 #endif
105105
106106 return 0;
fs/adfs/super.c+2−2
@@ -213,7 +213,7 @@ static int parse_options(struct super_block *sb, char *options) · 212 unmodified lines
213213 static int adfs_remount(struct super_block *sb, int *flags, char *data)
214214 {
215215 sync_filesystem(sb);
216− *flags |= MS_NODIRATIME;
216+ *flags |= SB_NODIRATIME;
217217 return parse_options(sb, data);
218218 }
219219
@@ -372,7 +372,7 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent) · 152 unmodified lines
372372 struct inode *root;
373373 int ret = -EINVAL;
374374
375− sb->s_flags |= MS_NODIRATIME;
375+ sb->s_flags |= SB_NODIRATIME;
376376
377377 asb = kzalloc(sizeof(*asb), GFP_KERNEL);
378378 if (!asb)
fs/affs/amigaffs.c+1−1
@@ -453,7 +453,7 @@ affs_error(struct super_block *sb, const char *function, const char *fmt, ...) · 452 unmodified lines
453453 pr_crit("error (device %s): %s(): %pV\n", sb->s_id, function, &vaf);
454454 if (!sb_rdonly(sb))
455455 pr_warn("Remounting filesystem read-only\n");
456− sb->s_flags |= MS_RDONLY;
456+ sb->s_flags |= SB_RDONLY;
457457 va_end(args);
458458 }
459459
fs/affs/bitmap.c+3−3
@@ -250,12 +250,12 @@ int affs_init_bitmap(struct super_block *sb, int *flags) · 249 unmodified lines
250250 int i, res = 0;
251251 struct affs_sb_info *sbi = AFFS_SB(sb);
252252
253− if (*flags & MS_RDONLY)
253+ if (*flags & SB_RDONLY)
254254 return 0;
255255
256256 if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {
257257 pr_notice("Bitmap invalid - mounting %s read only\n", sb->s_id);
258− *flags |= MS_RDONLY;
258+ *flags |= SB_RDONLY;
259259 return 0;
260260 }
261261
@@ -288,7 +288,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags) · 26 unmodified lines
288288 if (affs_checksum_block(sb, bh)) {
289289 pr_warn("Bitmap %u invalid - mounting %s read only.\n",
290290 bm->bm_key, sb->s_id);
291− *flags |= MS_RDONLY;
291+ *flags |= SB_RDONLY;
292292 goto out;
293293 }
294294 pr_debug("read bitmap block %d: %d\n", blk, bm->bm_key);
fs/affs/super.c+8−8
@@ -356,7 +356,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent) · 355 unmodified lines
356356
357357 sb->s_magic = AFFS_SUPER_MAGIC;
358358 sb->s_op = &affs_sops;
359− sb->s_flags |= MS_NODIRATIME;
359+ sb->s_flags |= SB_NODIRATIME;
360360
361361 sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
362362 if (!sbi)
@@ -466,7 +466,7 @@ got_root: · 103 unmodified lines
466466 if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
467467 || chksum == MUFS_DCOFS) && !sb_rdonly(sb)) {
468468 pr_notice("Dircache FS - mounting %s read only\n", sb->s_id);
469− sb->s_flags |= MS_RDONLY;
469+ sb->s_flags |= SB_RDONLY;
470470 }
471471 switch (chksum) {
472472 case MUFS_FS:
@@ -488,7 +488,7 @@ got_root: · 15 unmodified lines
488488 /* fall thru */
489489 case FS_OFS:
490490 affs_set_opt(sbi->s_flags, SF_OFS);
491− sb->s_flags |= MS_NOEXEC;
491+ sb->s_flags |= SB_NOEXEC;
492492 break;
493493 case MUFS_DCOFS:
494494 case MUFS_INTLOFS:
@@ -497,7 +497,7 @@ got_root: · 2 unmodified lines
497497 case FS_INTLOFS:
498498 affs_set_opt(sbi->s_flags, SF_INTL);
499499 affs_set_opt(sbi->s_flags, SF_OFS);
500− sb->s_flags |= MS_NOEXEC;
500+ sb->s_flags |= SB_NOEXEC;
501501 break;
502502 default:
503503 pr_err("Unknown filesystem on device %s: %08X\n",
@@ -513,7 +513,7 @@ got_root: · 9 unmodified lines
513513 sig, sig[3] + '0', blocksize);
514514 }
515515
516− sb->s_flags |= MS_NODEV | MS_NOSUID;
516+ sb->s_flags |= SB_NODEV | SB_NOSUID;
517517
518518 sbi->s_data_blksize = sb->s_blocksize;
519519 if (affs_test_opt(sbi->s_flags, SF_OFS))
@@ -570,7 +570,7 @@ affs_remount(struct super_block *sb, int *flags, char *data) · 50 unmodified lines
570570 pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data);
571571
572572 sync_filesystem(sb);
573− *flags |= MS_NODIRATIME;
573+ *flags |= SB_NODIRATIME;
574574
575575 memcpy(volume, sbi->s_volume, 32);
576576 if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block,
@@ -596,10 +596,10 @@ affs_remount(struct super_block *sb, int *flags, char *data) · 19 unmodified lines
596596 memcpy(sbi->s_volume, volume, 32);
597597 spin_unlock(&sbi->symlink_lock);
598598
599− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
599+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
600600 return 0;
601601
602− if (*flags & MS_RDONLY)
602+ if (*flags & SB_RDONLY)
603603 affs_free_bitmap(sb);
604604 else
605605 res = affs_init_bitmap(sb, flags);
fs/afs/super.c+2−2
@@ -496,10 +496,10 @@ static struct dentry *afs_mount(struct file_system_type *fs_type, · 495 unmodified lines
496496 if (ret < 0)
497497 goto error_sb;
498498 as = NULL;
499− sb->s_flags |= MS_ACTIVE;
499+ sb->s_flags |= SB_ACTIVE;
500500 } else {
501501 _debug("reuse");
502− ASSERTCMP(sb->s_flags, &, MS_ACTIVE);
502+ ASSERTCMP(sb->s_flags, &, SB_ACTIVE);
503503 afs_destroy_sbi(as);
504504 as = NULL;
505505 }
fs/befs/ChangeLog+1−1
@@ -365,7 +365,7 @@ Version 0.4 (2001-10-28) · 364 unmodified lines
365365 (fs/befs/super.c)
366366
367367 * Tell the kernel to only mount befs read-only.
368− By setting the MS_RDONLY flag in befs_read_super().
368+ By setting the SB_RDONLY flag in befs_read_super().
369369 Not that it was possible to write before. But now the kernel won't even try.
370370 (fs/befs/super.c)
371371
fs/befs/linuxvfs.c+2−2
@@ -841,7 +841,7 @@ befs_fill_super(struct super_block *sb, void *data, int silent) · 840 unmodified lines
841841 if (!sb_rdonly(sb)) {
842842 befs_warning(sb,
843843 "No write support. Marking filesystem read-only");
844− sb->s_flags |= MS_RDONLY;
844+ sb->s_flags |= SB_RDONLY;
845845 }
846846
847847 /*
@@ -948,7 +948,7 @@ static int · 100 unmodified lines
948948 befs_remount(struct super_block *sb, int *flags, char *data)
949949 {
950950 sync_filesystem(sb);
951− if (!(*flags & MS_RDONLY))
951+ if (!(*flags & SB_RDONLY))
952952 return -EINVAL;
953953 return 0;
954954 }
fs/btrfs/ctree.h+1−1
@@ -2957,7 +2957,7 @@ static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info) · 2956 unmodified lines
29572957 */
29582958 static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
29592959 {
2960− return fs_info->sb->s_flags & MS_RDONLY || btrfs_fs_closing(fs_info);
2960+ return fs_info->sb->s_flags & SB_RDONLY || btrfs_fs_closing(fs_info);
29612961 }
29622962
29632963 static inline void free_fs_info(struct btrfs_fs_info *fs_info)
fs/btrfs/extent_io.c+1−1
@@ -1984,7 +1984,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start, · 1983 unmodified lines
19841984 struct btrfs_bio *bbio = NULL;
19851985 int ret;
19861986
1987− ASSERT(!(fs_info->sb->s_flags & MS_RDONLY));
1987+ ASSERT(!(fs_info->sb->s_flags & SB_RDONLY));
19881988 BUG_ON(!mirror_num);
19891989
19901990 bio = btrfs_io_bio_alloc(1);
fs/btrfs/ioctl.c+2−2
@@ -1172,7 +1172,7 @@ again: · 1171 unmodified lines
11721172 if (!i_done || ret)
11731173 goto out;
11741174
1175− if (!(inode->i_sb->s_flags & MS_ACTIVE))
1175+ if (!(inode->i_sb->s_flags & SB_ACTIVE))
11761176 goto out;
11771177
11781178 /*
@@ -1333,7 +1333,7 @@ int btrfs_defrag_file(struct inode *inode, struct file *file, · 154 unmodified lines
13331333 * make sure we stop running if someone unmounts
13341334 * the FS
13351335 */
1336− if (!(inode->i_sb->s_flags & MS_ACTIVE))
1336+ if (!(inode->i_sb->s_flags & SB_ACTIVE))
13371337 break;
13381338
13391339 if (btrfs_defrag_cancelled(fs_info)) {
fs/btrfs/super.c+25−25
@@ -107,7 +107,7 @@ static void btrfs_handle_error(struct btrfs_fs_info *fs_info) · 106 unmodified lines
107107 return;
108108
109109 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
110− sb->s_flags |= MS_RDONLY;
110+ sb->s_flags |= SB_RDONLY;
111111 btrfs_info(fs_info, "forced readonly");
112112 /*
113113 * Note that a running device replace operation is not
@@ -137,7 +137,7 @@ void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function · 23 unmodified lines
137137
138138 /*
139139 * Special case: if the error is EROFS, and we're already
140− * under MS_RDONLY, then it is safe here.
140+ * under SB_RDONLY, then it is safe here.
141141 */
142142 if (errno == -EROFS && sb_rdonly(sb))
143143 return;
@@ -168,7 +168,7 @@ void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function · 24 unmodified lines
168168 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
169169
170170 /* Don't go through full error handling during mount */
171− if (sb->s_flags & MS_BORN)
171+ if (sb->s_flags & SB_BORN)
172172 btrfs_handle_error(fs_info);
173173 }
174174
@@ -625,7 +625,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options, · 450 unmodified lines
625625 break;
626626 case Opt_acl:
627627 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
628− info->sb->s_flags |= MS_POSIXACL;
628+ info->sb->s_flags |= SB_POSIXACL;
629629 break;
630630 #else
631631 btrfs_err(info, "support for ACL not compiled in!");
@@ -633,7 +633,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options, · 1 unmodified line
633633 goto out;
634634 #endif
635635 case Opt_noacl:
636− info->sb->s_flags &= ~MS_POSIXACL;
636+ info->sb->s_flags &= ~SB_POSIXACL;
637637 break;
638638 case Opt_notreelog:
639639 btrfs_set_and_info(info, NOTREELOG,
@@ -851,7 +851,7 @@ check: · 211 unmodified lines
851851 /*
852852 * Extra check for current option against current flag
853853 */
854− if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & MS_RDONLY)) {
854+ if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & SB_RDONLY)) {
855855 btrfs_err(info,
856856 "nologreplay must be used with ro mount option");
857857 ret = -EINVAL;
@@ -1147,7 +1147,7 @@ static int btrfs_fill_super(struct super_block *sb, · 289 unmodified lines
11471147 sb->s_xattr = btrfs_xattr_handlers;
11481148 sb->s_time_gran = 1;
11491149 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
1150− sb->s_flags |= MS_POSIXACL;
1150+ sb->s_flags |= SB_POSIXACL;
11511151 #endif
11521152 sb->s_flags |= SB_I_VERSION;
11531153 sb->s_iflags |= SB_I_CGROUPWB;
@@ -1180,7 +1180,7 @@ static int btrfs_fill_super(struct super_block *sb, · 26 unmodified lines
11801180 }
11811181
11821182 cleancache_init_fs(sb);
1183− sb->s_flags |= MS_ACTIVE;
1183+ sb->s_flags |= SB_ACTIVE;
11841184 return 0;
11851185
11861186 fail_close:
@@ -1277,7 +1277,7 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry) · 90 unmodified lines
12771277 seq_puts(seq, ",flushoncommit");
12781278 if (btrfs_test_opt(info, DISCARD))
12791279 seq_puts(seq, ",discard");
1280− if (!(info->sb->s_flags & MS_POSIXACL))
1280+ if (!(info->sb->s_flags & SB_POSIXACL))
12811281 seq_puts(seq, ",noacl");
12821282 if (btrfs_test_opt(info, SPACE_CACHE))
12831283 seq_puts(seq, ",space_cache");
@@ -1409,11 +1409,11 @@ static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid, · 125 unmodified lines
14091409
14101410 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name, newargs);
14111411 if (PTR_ERR_OR_ZERO(mnt) == -EBUSY) {
1412− if (flags & MS_RDONLY) {
1413− mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~MS_RDONLY,
1412+ if (flags & SB_RDONLY) {
1413+ mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~SB_RDONLY,
14141414 device_name, newargs);
14151415 } else {
1416− mnt = vfs_kern_mount(&btrfs_fs_type, flags | MS_RDONLY,
1416+ mnt = vfs_kern_mount(&btrfs_fs_type, flags | SB_RDONLY,
14171417 device_name, newargs);
14181418 if (IS_ERR(mnt)) {
14191419 root = ERR_CAST(mnt);
@@ -1565,7 +1565,7 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · 145 unmodified lines
15651565 u64 subvol_objectid = 0;
15661566 int error = 0;
15671567
1568− if (!(flags & MS_RDONLY))
1568+ if (!(flags & SB_RDONLY))
15691569 mode |= FMODE_WRITE;
15701570
15711571 error = btrfs_parse_early_options(data, mode, fs_type,
@@ -1619,13 +1619,13 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · 47 unmodified lines
16191619 if (error)
16201620 goto error_fs_info;
16211621
1622− if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
1622+ if (!(flags & SB_RDONLY) && fs_devices->rw_devices == 0) {
16231623 error = -EACCES;
16241624 goto error_close_devices;
16251625 }
16261626
16271627 bdev = fs_devices->latest_bdev;
1628− s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
1628+ s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | SB_NOSEC,
16291629 fs_info);
16301630 if (IS_ERR(s)) {
16311631 error = PTR_ERR(s);
@@ -1635,7 +1635,7 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · 3 unmodified lines
16351635 if (s->s_root) {
16361636 btrfs_close_devices(fs_devices);
16371637 free_fs_info(fs_info);
1638− if ((flags ^ s->s_flags) & MS_RDONLY)
1638+ if ((flags ^ s->s_flags) & SB_RDONLY)
16391639 error = -EBUSY;
16401640 } else {
16411641 snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
@@ -1702,11 +1702,11 @@ static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info, · 60 unmodified lines
17021702 {
17031703 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
17041704 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1705− (flags & MS_RDONLY))) {
1705+ (flags & SB_RDONLY))) {
17061706 /* wait for any defraggers to finish */
17071707 wait_event(fs_info->transaction_wait,
17081708 (atomic_read(&fs_info->defrag_running) == 0));
1709− if (flags & MS_RDONLY)
1709+ if (flags & SB_RDONLY)
17101710 sync_filesystem(fs_info->sb);
17111711 }
17121712 }
@@ -1766,10 +1766,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) · 53 unmodified lines
17661766 btrfs_resize_thread_pool(fs_info,
17671767 fs_info->thread_pool_size, old_thread_pool_size);
17681768
1769− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
1769+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
17701770 goto out;
17711771
1772− if (*flags & MS_RDONLY) {
1772+ if (*flags & SB_RDONLY) {
17731773 /*
17741774 * this also happens on 'umount -rf' or on shutdown, when
17751775 * the filesystem is busy.
@@ -1781,10 +1781,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
17811781 /* avoid complains from lockdep et al. */
17821782 up(&fs_info->uuid_tree_rescan_sem);
17831783
1784− sb->s_flags |= MS_RDONLY;
1784+ sb->s_flags |= SB_RDONLY;
17851785
17861786 /*
1787− * Setting MS_RDONLY will put the cleaner thread to
1787+ * Setting SB_RDONLY will put the cleaner thread to
17881788 * sleep at the next loop if it's already active.
17891789 * If it's already asleep, we'll leave unused block
17901790 * groups on disk until we're mounted read-write again
@@ -1856,7 +1856,7 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) · 65 unmodified lines
18561856 goto restore;
18571857 }
18581858 }
1859− sb->s_flags &= ~MS_RDONLY;
1859+ sb->s_flags &= ~SB_RDONLY;
18601860
18611861 set_bit(BTRFS_FS_OPEN, &fs_info->flags);
18621862 }
@@ -1866,9 +1866,9 @@ out: · 3 unmodified lines
18661866 return 0;
18671867
18681868 restore:
1869− /* We've hit an error - don't reset MS_RDONLY */
1869+ /* We've hit an error - don't reset SB_RDONLY */
18701870 if (sb_rdonly(sb))
1871− old_flags |= MS_RDONLY;
1871+ old_flags |= SB_RDONLY;
18721872 sb->s_flags = old_flags;
18731873 fs_info->mount_opt = old_opts;
18741874 fs_info->compress_type = old_compress_type;
fs/btrfs/volumes.c+2−2
@@ -2384,7 +2384,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path · 2383 unmodified lines
23842384 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
23852385
23862386 if (seeding_dev) {
2387− sb->s_flags &= ~MS_RDONLY;
2387+ sb->s_flags &= ~SB_RDONLY;
23882388 ret = btrfs_prepare_sprout(fs_info);
23892389 if (ret) {
23902390 btrfs_abort_transaction(trans, ret);
@@ -2497,7 +2497,7 @@ error_sysfs: · 106 unmodified lines
24972497 btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
24982498 error_trans:
24992499 if (seeding_dev)
2500− sb->s_flags |= MS_RDONLY;
2500+ sb->s_flags |= SB_RDONLY;
25012501 if (trans)
25022502 btrfs_end_transaction(trans);
25032503 rcu_string_free(device->name);
fs/ceph/super.c+4−4
@@ -331,11 +331,11 @@ static int parse_fsopt_token(char *c, void *private) · 330 unmodified lines
331331 break;
332332 #ifdef CONFIG_CEPH_FS_POSIX_ACL
333333 case Opt_acl:
334− fsopt->sb_flags |= MS_POSIXACL;
334+ fsopt->sb_flags |= SB_POSIXACL;
335335 break;
336336 #endif
337337 case Opt_noacl:
338− fsopt->sb_flags &= ~MS_POSIXACL;
338+ fsopt->sb_flags &= ~SB_POSIXACL;
339339 break;
340340 default:
341341 BUG_ON(token);
@@ -520,7 +520,7 @@ static int ceph_show_options(struct seq_file *m, struct dentry *root) · 178 unmodified lines
520520 seq_puts(m, ",nopoolperm");
521521
522522 #ifdef CONFIG_CEPH_FS_POSIX_ACL
523− if (fsopt->sb_flags & MS_POSIXACL)
523+ if (fsopt->sb_flags & SB_POSIXACL)
524524 seq_puts(m, ",acl");
525525 else
526526 seq_puts(m, ",noacl");
@@ -988,7 +988,7 @@ static struct dentry *ceph_mount(struct file_system_type *fs_type, · 461 unmodified lines
988988 dout("ceph_mount\n");
989989
990990 #ifdef CONFIG_CEPH_FS_POSIX_ACL
991− flags |= MS_POSIXACL;
991+ flags |= SB_POSIXACL;
992992 #endif
993993 err = parse_mount_options(&fsopt, &opt, flags, data, dev_name);
994994 if (err < 0) {
fs/cifs/cifs_fs_sb.h+1−1
@@ -42,7 +42,7 @@ · 41 unmodified lines
4242 #define CIFS_MOUNT_MULTIUSER 0x20000 /* multiuser mount */
4343 #define CIFS_MOUNT_STRICT_IO 0x40000 /* strict cache mode */
4444 #define CIFS_MOUNT_RWPIDFORWARD 0x80000 /* use pid forwarding for rw */
45−#define CIFS_MOUNT_POSIXACL 0x100000 /* mirror of MS_POSIXACL in mnt_cifs_flags */
45+#define CIFS_MOUNT_POSIXACL 0x100000 /* mirror of SB_POSIXACL in mnt_cifs_flags */
4646 #define CIFS_MOUNT_CIFS_BACKUPUID 0x200000 /* backup intent bit for a user */
4747 #define CIFS_MOUNT_CIFS_BACKUPGID 0x400000 /* backup intent bit for a group */
4848 #define CIFS_MOUNT_MAP_SFM_CHR 0x800000 /* SFM/MAC mapping for illegal chars */
fs/cifs/cifsfs.c+6−6
@@ -125,7 +125,7 @@ cifs_read_super(struct super_block *sb) · 124 unmodified lines
125125 tcon = cifs_sb_master_tcon(cifs_sb);
126126
127127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
128− sb->s_flags |= MS_POSIXACL;
128+ sb->s_flags |= SB_POSIXACL;
129129
130130 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
131131 sb->s_maxbytes = MAX_LFS_FILESIZE;
@@ -497,7 +497,7 @@ cifs_show_options(struct seq_file *s, struct dentry *root) · 365 unmodified lines
497497 seq_puts(s, ",cifsacl");
498498 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
499499 seq_puts(s, ",dynperm");
500− if (root->d_sb->s_flags & MS_POSIXACL)
500+ if (root->d_sb->s_flags & SB_POSIXACL)
501501 seq_puts(s, ",acl");
502502 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
503503 seq_puts(s, ",mfsymlinks");
@@ -573,7 +573,7 @@ static int cifs_show_stats(struct seq_file *s, struct dentry *root) · 69 unmodified lines
573573 static int cifs_remount(struct super_block *sb, int *flags, char *data)
574574 {
575575 sync_filesystem(sb);
576− *flags |= MS_NODIRATIME;
576+ *flags |= SB_NODIRATIME;
577577 return 0;
578578 }
579579
@@ -708,7 +708,7 @@ cifs_do_mount(struct file_system_type *fs_type, · 128 unmodified lines
708708
709709 rc = cifs_mount(cifs_sb, volume_info);
710710 if (rc) {
711− if (!(flags & MS_SILENT))
711+ if (!(flags & SB_SILENT))
712712 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
713713 rc);
714714 root = ERR_PTR(rc);
@@ -720,7 +720,7 @@ cifs_do_mount(struct file_system_type *fs_type, · 5 unmodified lines
720720 mnt_data.flags = flags;
721721
722722 /* BB should we make this contingent on mount parm? */
723− flags |= MS_NODIRATIME | MS_NOATIME;
723+ flags |= SB_NODIRATIME | SB_NOATIME;
724724
725725 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
726726 if (IS_ERR(sb)) {
@@ -739,7 +739,7 @@ cifs_do_mount(struct file_system_type *fs_type, · 12 unmodified lines
739739 goto out_super;
740740 }
741741
742− sb->s_flags |= MS_ACTIVE;
742+ sb->s_flags |= SB_ACTIVE;
743743 }
744744
745745 root = cifs_get_root(volume_info, sb);
fs/cifs/cifsglob.h+2−2
@@ -559,8 +559,8 @@ struct smb_vol { · 558 unmodified lines
559559 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
560560 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
561561
562−#define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \
563− MS_NODEV | MS_SYNCHRONOUS)
562+#define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \
563+ SB_NODEV | SB_SYNCHRONOUS)
564564
565565 struct cifs_mnt_data {
566566 struct cifs_sb_info *cifs_sb;
fs/cifs/inode.c+1−1
@@ -985,7 +985,7 @@ retry_iget5_locked: · 984 unmodified lines
985985 }
986986
987987 cifs_fattr_to_inode(inode, fattr);
988− if (sb->s_flags & MS_NOATIME)
988+ if (sb->s_flags & SB_NOATIME)
989989 inode->i_flags |= S_NOATIME | S_NOCMTIME;
990990 if (inode->i_state & I_NEW) {
991991 inode->i_ino = hash;
fs/cifs/xattr.c+4−4
@@ -117,7 +117,7 @@ static int cifs_xattr_set(const struct xattr_handler *handler, · 116 unmodified lines
117117 #ifdef CONFIG_CIFS_POSIX
118118 if (!value)
119119 goto out;
120− if (sb->s_flags & MS_POSIXACL)
120+ if (sb->s_flags & SB_POSIXACL)
121121 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
122122 value, (const int)size,
123123 ACL_TYPE_ACCESS, cifs_sb->local_nls,
@@ -129,7 +129,7 @@ static int cifs_xattr_set(const struct xattr_handler *handler, · 5 unmodified lines
129129 #ifdef CONFIG_CIFS_POSIX
130130 if (!value)
131131 goto out;
132− if (sb->s_flags & MS_POSIXACL)
132+ if (sb->s_flags & SB_POSIXACL)
133133 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
134134 value, (const int)size,
135135 ACL_TYPE_DEFAULT, cifs_sb->local_nls,
@@ -266,7 +266,7 @@ static int cifs_xattr_get(const struct xattr_handler *handler, · 130 unmodified lines
266266
267267 case XATTR_ACL_ACCESS:
268268 #ifdef CONFIG_CIFS_POSIX
269− if (sb->s_flags & MS_POSIXACL)
269+ if (sb->s_flags & SB_POSIXACL)
270270 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
271271 value, size, ACL_TYPE_ACCESS,
272272 cifs_sb->local_nls,
@@ -276,7 +276,7 @@ static int cifs_xattr_get(const struct xattr_handler *handler, · 3 unmodified lines
276276
277277 case XATTR_ACL_DEFAULT:
278278 #ifdef CONFIG_CIFS_POSIX
279− if (sb->s_flags & MS_POSIXACL)
279+ if (sb->s_flags & SB_POSIXACL)
280280 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
281281 value, size, ACL_TYPE_DEFAULT,
282282 cifs_sb->local_nls,
fs/coda/inode.c+2−2
@@ -96,7 +96,7 @@ void coda_destroy_inodecache(void) · 95 unmodified lines
9696 static int coda_remount(struct super_block *sb, int *flags, char *data)
9797 {
9898 sync_filesystem(sb);
99− *flags |= MS_NOATIME;
99+ *flags |= SB_NOATIME;
100100 return 0;
101101 }
102102
@@ -188,7 +188,7 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent) · 85 unmodified lines
188188 mutex_unlock(&vc->vc_mutex);
189189
190190 sb->s_fs_info = vc;
191− sb->s_flags |= MS_NOATIME;
191+ sb->s_flags |= SB_NOATIME;
192192 sb->s_blocksize = 4096; /* XXXXX what do we put here?? */
193193 sb->s_blocksize_bits = 12;
194194 sb->s_magic = CODA_SUPER_MAGIC;
fs/cramfs/inode.c+2−2
@@ -505,7 +505,7 @@ static void cramfs_kill_sb(struct super_block *sb) · 504 unmodified lines
505505 static int cramfs_remount(struct super_block *sb, int *flags, char *data)
506506 {
507507 sync_filesystem(sb);
508− *flags |= MS_RDONLY;
508+ *flags |= SB_RDONLY;
509509 return 0;
510510 }
511511
@@ -592,7 +592,7 @@ static int cramfs_finalize_super(struct super_block *sb, · 80 unmodified lines
592592 struct inode *root;
593593
594594 /* Set it all up.. */
595− sb->s_flags |= MS_RDONLY;
595+ sb->s_flags |= SB_RDONLY;
596596 sb->s_op = &cramfs_ops;
597597 root = get_cramfs_inode(sb, cramfs_root, 0);
598598 if (IS_ERR(root))
fs/ecryptfs/main.c+4−4
@@ -560,8 +560,8 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags · 559 unmodified lines
560560 * Set the POSIX ACL flag based on whether they're enabled in the lower
561561 * mount.
562562 */
563− s->s_flags = flags & ~MS_POSIXACL;
564− s->s_flags |= path.dentry->d_sb->s_flags & MS_POSIXACL;
563+ s->s_flags = flags & ~SB_POSIXACL;
564+ s->s_flags |= path.dentry->d_sb->s_flags & SB_POSIXACL;
565565
566566 /**
567567 * Force a read-only eCryptfs mount when:
@@ -569,7 +569,7 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags · 1 unmodified line
569569 * 2) The ecryptfs_encrypted_view mount option is specified
570570 */
571571 if (sb_rdonly(path.dentry->d_sb) || mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
572− s->s_flags |= MS_RDONLY;
572+ s->s_flags |= SB_RDONLY;
573573
574574 s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
575575 s->s_blocksize = path.dentry->d_sb->s_blocksize;
@@ -602,7 +602,7 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags · 26 unmodified lines
602602 ecryptfs_set_dentry_private(s->s_root, root_info);
603603 root_info->lower_path = path;
604604
605− s->s_flags |= MS_ACTIVE;
605+ s->s_flags |= SB_ACTIVE;
606606 return dget(s->s_root);
607607
608608 out_free:
fs/efs/super.c+2−2
@@ -116,7 +116,7 @@ static void destroy_inodecache(void) · 115 unmodified lines
116116 static int efs_remount(struct super_block *sb, int *flags, char *data)
117117 {
118118 sync_filesystem(sb);
119− *flags |= MS_RDONLY;
119+ *flags |= SB_RDONLY;
120120 return 0;
121121 }
122122
@@ -311,7 +311,7 @@ static int efs_fill_super(struct super_block *s, void *d, int silent) · 188 unmodified lines
311311 #ifdef DEBUG
312312 pr_info("forcing read-only mode\n");
313313 #endif
314− s->s_flags |= MS_RDONLY;
314+ s->s_flags |= SB_RDONLY;
315315 }
316316 s->s_op = &efs_superblock_operations;
317317 s->s_export_op = &efs_export_ops;
fs/ext2/balloc.c+2−2
@@ -548,7 +548,7 @@ do_more: · 547 unmodified lines
548548 }
549549
550550 mark_buffer_dirty(bitmap_bh);
551− if (sb->s_flags & MS_SYNCHRONOUS)
551+ if (sb->s_flags & SB_SYNCHRONOUS)
552552 sync_dirty_buffer(bitmap_bh);
553553
554554 group_adjust_blocks(sb, block_group, desc, bh2, group_freed);
@@ -1424,7 +1424,7 @@ allocated: · 869 unmodified lines
14241424 percpu_counter_sub(&sbi->s_freeblocks_counter, num);
14251425
14261426 mark_buffer_dirty(bitmap_bh);
1427− if (sb->s_flags & MS_SYNCHRONOUS)
1427+ if (sb->s_flags & SB_SYNCHRONOUS)
14281428 sync_dirty_buffer(bitmap_bh);
14291429
14301430 *errp = 0;
fs/ext2/ialloc.c+2−2
@@ -145,7 +145,7 @@ void ext2_free_inode (struct inode * inode) · 144 unmodified lines
145145 else
146146 ext2_release_inode(sb, block_group, is_directory);
147147 mark_buffer_dirty(bitmap_bh);
148− if (sb->s_flags & MS_SYNCHRONOUS)
148+ if (sb->s_flags & SB_SYNCHRONOUS)
149149 sync_dirty_buffer(bitmap_bh);
150150
151151 brelse(bitmap_bh);
@@ -517,7 +517,7 @@ repeat_in_this_group: · 365 unmodified lines
517517 goto fail;
518518 got:
519519 mark_buffer_dirty(bitmap_bh);
520− if (sb->s_flags & MS_SYNCHRONOUS)
520+ if (sb->s_flags & SB_SYNCHRONOUS)
521521 sync_dirty_buffer(bitmap_bh);
522522 brelse(bitmap_bh);
523523
fs/ext2/super.c+10−10
@@ -75,7 +75,7 @@ void ext2_error(struct super_block *sb, const char *function, · 74 unmodified lines
7575 if (test_opt(sb, ERRORS_RO)) {
7676 ext2_msg(sb, KERN_CRIT,
7777 "error: remounting filesystem read-only");
78− sb->s_flags |= MS_RDONLY;
78+ sb->s_flags |= SB_RDONLY;
7979 }
8080 }
8181
@@ -656,7 +656,7 @@ static int ext2_setup_super (struct super_block * sb, · 574 unmodified lines
656656 ext2_msg(sb, KERN_ERR,
657657 "error: revision level too high, "
658658 "forcing read-only mode");
659− res = MS_RDONLY;
659+ res = SB_RDONLY;
660660 }
661661 if (read_only)
662662 return res;
@@ -924,9 +924,9 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) · 261 unmodified lines
924924 sbi->s_resuid = opts.s_resuid;
925925 sbi->s_resgid = opts.s_resgid;
926926
927− sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
927+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
928928 ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
929− MS_POSIXACL : 0);
929+ SB_POSIXACL : 0);
930930 sb->s_iflags |= SB_I_CGROUPWB;
931931
932932 if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&
@@ -1178,7 +1178,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) · 245 unmodified lines
11781178 ext2_msg(sb, KERN_WARNING,
11791179 "warning: mounting ext3 filesystem as ext2");
11801180 if (ext2_setup_super (sb, es, sb_rdonly(sb)))
1181− sb->s_flags |= MS_RDONLY;
1181+ sb->s_flags |= SB_RDONLY;
11821182 ext2_write_super(sb);
11831183 return 0;
11841184
@@ -1341,9 +1341,9 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) · 156 unmodified lines
13411341 "dax flag with busy inodes while remounting");
13421342 new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;
13431343 }
1344− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
1344+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
13451345 goto out_set;
1346− if (*flags & MS_RDONLY) {
1346+ if (*flags & SB_RDONLY) {
13471347 if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
13481348 !(sbi->s_mount_state & EXT2_VALID_FS))
13491349 goto out_set;
@@ -1379,7 +1379,7 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) · 29 unmodified lines
13791379 */
13801380 sbi->s_mount_state = le16_to_cpu(es->s_state);
13811381 if (!ext2_setup_super (sb, es, 0))
1382− sb->s_flags &= ~MS_RDONLY;
1382+ sb->s_flags &= ~SB_RDONLY;
13831383 spin_unlock(&sbi->s_lock);
13841384
13851385 ext2_write_super(sb);
@@ -1392,8 +1392,8 @@ out_set: · 6 unmodified lines
13921392 sbi->s_mount_opt = new_opts.s_mount_opt;
13931393 sbi->s_resuid = new_opts.s_resuid;
13941394 sbi->s_resgid = new_opts.s_resgid;
1395− sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1396− ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1395+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
1396+ ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? SB_POSIXACL : 0);
13971397 spin_unlock(&sbi->s_lock);
13981398
13991399 return 0;
fs/ext4/inode.c+2−2
@@ -2742,7 +2742,7 @@ static int ext4_writepages(struct address_space *mapping, · 2741 unmodified lines
27422742 * If the filesystem has aborted, it is read-only, so return
27432743 * right away instead of dumping stack traces later on that
27442744 * will obscure the real source of the problem. We test
2745− * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2745+ * EXT4_MF_FS_ABORTED instead of sb->s_flag's SB_RDONLY because
27462746 * the latter could be true if the filesystem is mounted
27472747 * read-only, and in that case, ext4_writepages should
27482748 * *never* be called, so if that ever happens, we would want
@@ -5183,7 +5183,7 @@ static int ext4_do_update_inode(handle_t *handle, · 2434 unmodified lines
51835183
51845184 ext4_inode_csum_set(inode, raw_inode, ei);
51855185 spin_unlock(&ei->i_raw_lock);
5186− if (inode->i_sb->s_flags & MS_LAZYTIME)
5186+ if (inode->i_sb->s_flags & SB_LAZYTIME)
51875187 ext4_update_other_inodes_time(inode->i_sb, inode->i_ino,
51885188 bh->b_data);
51895189
fs/ext4/super.c+26−26
@@ -422,7 +422,7 @@ static void ext4_handle_error(struct super_block *sb) · 421 unmodified lines
422422 * before ->s_flags update
423423 */
424424 smp_wmb();
425− sb->s_flags |= MS_RDONLY;
425+ sb->s_flags |= SB_RDONLY;
426426 }
427427 if (test_opt(sb, ERRORS_PANIC)) {
428428 if (EXT4_SB(sb)->s_journal &&
@@ -635,7 +635,7 @@ void __ext4_abort(struct super_block *sb, const char *function, · 206 unmodified lines
635635 * before ->s_flags update
636636 */
637637 smp_wmb();
638− sb->s_flags |= MS_RDONLY;
638+ sb->s_flags |= SB_RDONLY;
639639 if (EXT4_SB(sb)->s_journal)
640640 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
641641 save_error_info(sb, function, line);
@@ -1682,10 +1682,10 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token, · 1040 unmodified lines
16821682 sb->s_flags |= SB_I_VERSION;
16831683 return 1;
16841684 case Opt_lazytime:
1685− sb->s_flags |= MS_LAZYTIME;
1685+ sb->s_flags |= SB_LAZYTIME;
16861686 return 1;
16871687 case Opt_nolazytime:
1688− sb->s_flags &= ~MS_LAZYTIME;
1688+ sb->s_flags &= ~SB_LAZYTIME;
16891689 return 1;
16901690 }
16911691
@@ -2116,7 +2116,7 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es, · 424 unmodified lines
21162116 if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
21172117 ext4_msg(sb, KERN_ERR, "revision level too high, "
21182118 "forcing read-only mode");
2119− res = MS_RDONLY;
2119+ res = SB_RDONLY;
21202120 }
21212121 if (read_only)
21222122 goto done;
@@ -2429,7 +2429,7 @@ static void ext4_orphan_cleanup(struct super_block *sb, · 306 unmodified lines
24292429
24302430 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
24312431 /* don't clear list on RO mount w/ errors */
2432− if (es->s_last_orphan && !(s_flags & MS_RDONLY)) {
2432+ if (es->s_last_orphan && !(s_flags & SB_RDONLY)) {
24332433 ext4_msg(sb, KERN_INFO, "Errors on filesystem, "
24342434 "clearing orphan list.\n");
24352435 es->s_last_orphan = 0;
@@ -2438,19 +2438,19 @@ static void ext4_orphan_cleanup(struct super_block *sb, · 2 unmodified lines
24382438 return;
24392439 }
24402440
2441− if (s_flags & MS_RDONLY) {
2441+ if (s_flags & SB_RDONLY) {
24422442 ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
2443− sb->s_flags &= ~MS_RDONLY;
2443+ sb->s_flags &= ~SB_RDONLY;
24442444 }
24452445 #ifdef CONFIG_QUOTA
24462446 /* Needed for iput() to work correctly and not trash data */
2447− sb->s_flags |= MS_ACTIVE;
2447+ sb->s_flags |= SB_ACTIVE;
24482448
24492449 /*
24502450 * Turn on quotas which were not enabled for read-only mounts if
24512451 * filesystem has quota feature, so that they are updated correctly.
24522452 */
2453− if (ext4_has_feature_quota(sb) && (s_flags & MS_RDONLY)) {
2453+ if (ext4_has_feature_quota(sb) && (s_flags & SB_RDONLY)) {
24542454 int ret = ext4_enable_quotas(sb);
24552455
24562456 if (!ret)
@@ -2539,7 +2539,7 @@ static void ext4_orphan_cleanup(struct super_block *sb, · 82 unmodified lines
25392539 }
25402540 }
25412541 #endif
2542− sb->s_flags = s_flags; /* Restore MS_RDONLY status */
2542+ sb->s_flags = s_flags; /* Restore SB_RDONLY status */
25432543 }
25442544
25452545 /*
@@ -2741,7 +2741,7 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly) · 195 unmodified lines
27412741
27422742 if (ext4_has_feature_readonly(sb)) {
27432743 ext4_msg(sb, KERN_INFO, "filesystem is read-only");
2744− sb->s_flags |= MS_RDONLY;
2744+ sb->s_flags |= SB_RDONLY;
27452745 return 1;
27462746 }
27472747
@@ -3623,8 +3623,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) · 875 unmodified lines
36233623 sb->s_iflags |= SB_I_CGROUPWB;
36243624 }
36253625
3626− sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
3627− (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
3626+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
3627+ (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
36283628
36293629 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
36303630 (ext4_has_compat_features(sb) ||
@@ -4199,7 +4199,7 @@ no_journal: · 568 unmodified lines
41994199 }
42004200
42014201 if (ext4_setup_super(sb, es, sb_rdonly(sb)))
4202− sb->s_flags |= MS_RDONLY;
4202+ sb->s_flags |= SB_RDONLY;
42034203
42044204 /* determine the minimum size of new large inodes, if present */
42054205 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE &&
@@ -4693,7 +4693,7 @@ static int ext4_commit_super(struct super_block *sb, int sync) · 487 unmodified lines
46934693 * the clock is set in the future, and this will cause e2fsck
46944694 * to complain and force a full file system check.
46954695 */
4696− if (!(sb->s_flags & MS_RDONLY))
4696+ if (!(sb->s_flags & SB_RDONLY))
46974697 es->s_wtime = cpu_to_le32(get_seconds());
46984698 if (sb->s_bdev->bd_part)
46994699 es->s_kbytes_written =
@@ -5047,8 +5047,8 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 347 unmodified lines
50475047 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)
50485048 ext4_abort(sb, "Abort forced by user");
50495049
5050− sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
5051− (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
5050+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
5051+ (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
50525052
50535053 es = sbi->s_es;
50545054
@@ -5057,16 +5057,16 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 2 unmodified lines
50575057 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
50585058 }
50595059
5060− if (*flags & MS_LAZYTIME)
5061− sb->s_flags |= MS_LAZYTIME;
5060+ if (*flags & SB_LAZYTIME)
5061+ sb->s_flags |= SB_LAZYTIME;
50625062
5063− if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) {
5063+ if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
50645064 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {
50655065 err = -EROFS;
50665066 goto restore_opts;
50675067 }
50685068
5069− if (*flags & MS_RDONLY) {
5069+ if (*flags & SB_RDONLY) {
50705070 err = sync_filesystem(sb);
50715071 if (err < 0)
50725072 goto restore_opts;
@@ -5078,7 +5078,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
50785078 * First of all, the unconditional stuff we have to do
50795079 * to disable replay of the journal when we next remount
50805080 */
5081− sb->s_flags |= MS_RDONLY;
5081+ sb->s_flags |= SB_RDONLY;
50825082
50835083 /*
50845084 * OK, test if we are remounting a valid rw partition
@@ -5140,7 +5140,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 55 unmodified lines
51405140 ext4_clear_journal_err(sb, es);
51415141 sbi->s_mount_state = le16_to_cpu(es->s_state);
51425142 if (!ext4_setup_super(sb, es, 0))
5143− sb->s_flags &= ~MS_RDONLY;
5143+ sb->s_flags &= ~SB_RDONLY;
51445144 if (ext4_has_feature_mmp(sb))
51455145 if (ext4_multi_mount_protect(sb,
51465146 le64_to_cpu(es->s_mmp_block))) {
@@ -5164,7 +5164,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 17 unmodified lines
51645164 }
51655165
51665166 ext4_setup_system_zone(sb);
5167− if (sbi->s_journal == NULL && !(old_sb_flags & MS_RDONLY))
5167+ if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY))
51685168 ext4_commit_super(sb, 1);
51695169
51705170 #ifdef CONFIG_QUOTA
@@ -5182,7 +5182,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 11 unmodified lines
51825182 }
51835183 #endif
51845184
5185− *flags = (*flags & ~MS_LAZYTIME) | (sb->s_flags & MS_LAZYTIME);
5185+ *flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
51865186 ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data);
51875187 kfree(orig_data);
51885188 return 0;
fs/f2fs/checkpoint.c+5−5
@@ -617,17 +617,17 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi) · 616 unmodified lines
617617 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
618618 return 0;
619619
620− if (s_flags & MS_RDONLY) {
620+ if (s_flags & SB_RDONLY) {
621621 f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");
622− sbi->sb->s_flags &= ~MS_RDONLY;
622+ sbi->sb->s_flags &= ~SB_RDONLY;
623623 }
624624
625625 #ifdef CONFIG_QUOTA
626626 /* Needed for iput() to work correctly and not trash data */
627− sbi->sb->s_flags |= MS_ACTIVE;
627+ sbi->sb->s_flags |= SB_ACTIVE;
628628
629629 /* Turn on quotas so that they are updated correctly */
630− quota_enabled = f2fs_enable_quota_files(sbi, s_flags & MS_RDONLY);
630+ quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
631631 #endif
632632
633633 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
@@ -658,7 +658,7 @@ out: · 24 unmodified lines
658658 if (quota_enabled)
659659 f2fs_quota_off_umount(sbi->sb);
660660 #endif
661− sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */
661+ sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
662662
663663 return err;
664664 }
fs/f2fs/f2fs.h+1−1
@@ -2378,7 +2378,7 @@ static inline bool f2fs_skip_inode_update(struct inode *inode, int dsync) · 2377 unmodified lines
23782378
23792379 static inline int f2fs_readonly(struct super_block *sb)
23802380 {
2381− return sb->s_flags & MS_RDONLY;
2381+ return sb->s_flags & SB_RDONLY;
23822382 }
23832383
23842384 static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
fs/f2fs/gc.c+1−1
@@ -1005,7 +1005,7 @@ int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, · 1004 unmodified lines
10051005
10061006 cpc.reason = __get_cp_reason(sbi);
10071007 gc_more:
1008− if (unlikely(!(sbi->sb->s_flags & MS_ACTIVE))) {
1008+ if (unlikely(!(sbi->sb->s_flags & SB_ACTIVE))) {
10091009 ret = -EINVAL;
10101010 goto stop;
10111011 }
fs/f2fs/recovery.c+5−5
@@ -598,16 +598,16 @@ int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only) · 597 unmodified lines
598598 int quota_enabled;
599599 #endif
600600
601− if (s_flags & MS_RDONLY) {
601+ if (s_flags & SB_RDONLY) {
602602 f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");
603− sbi->sb->s_flags &= ~MS_RDONLY;
603+ sbi->sb->s_flags &= ~SB_RDONLY;
604604 }
605605
606606 #ifdef CONFIG_QUOTA
607607 /* Needed for iput() to work correctly and not trash data */
608− sbi->sb->s_flags |= MS_ACTIVE;
608+ sbi->sb->s_flags |= SB_ACTIVE;
609609 /* Turn on quotas so that they are updated correctly */
610− quota_enabled = f2fs_enable_quota_files(sbi, s_flags & MS_RDONLY);
610+ quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
611611 #endif
612612
613613 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
@@ -671,7 +671,7 @@ out: · 57 unmodified lines
671671 if (quota_enabled)
672672 f2fs_quota_off_umount(sbi->sb);
673673 #endif
674− sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */
674+ sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
675675
676676 return ret ? ret: err;
677677 }
fs/f2fs/super.c+14−14
@@ -534,10 +534,10 @@ static int parse_options(struct super_block *sb, char *options) · 533 unmodified lines
534534 #endif
535535 break;
536536 case Opt_lazytime:
537− sb->s_flags |= MS_LAZYTIME;
537+ sb->s_flags |= SB_LAZYTIME;
538538 break;
539539 case Opt_nolazytime:
540− sb->s_flags &= ~MS_LAZYTIME;
540+ sb->s_flags &= ~SB_LAZYTIME;
541541 break;
542542 #ifdef CONFIG_QUOTA
543543 case Opt_quota:
@@ -1168,7 +1168,7 @@ static void default_options(struct f2fs_sb_info *sbi) · 624 unmodified lines
11681168 set_opt(sbi, INLINE_DENTRY);
11691169 set_opt(sbi, EXTENT_CACHE);
11701170 set_opt(sbi, NOHEAP);
1171− sbi->sb->s_flags |= MS_LAZYTIME;
1171+ sbi->sb->s_flags |= SB_LAZYTIME;
11721172 set_opt(sbi, FLUSH_MERGE);
11731173 if (f2fs_sb_mounted_blkzoned(sbi->sb)) {
11741174 set_opt_mode(sbi, F2FS_MOUNT_LFS);
@@ -1236,7 +1236,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) · 61 unmodified lines
12361236 #endif
12371237
12381238 /* recover superblocks we couldn't write due to previous RO mount */
1239− if (!(*flags & MS_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
1239+ if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
12401240 err = f2fs_commit_super(sbi, false);
12411241 f2fs_msg(sb, KERN_INFO,
12421242 "Try to recover all the superblocks, ret: %d", err);
@@ -1255,17 +1255,17 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) · 12 unmodified lines
12551255 * Previous and new state of filesystem is RO,
12561256 * so skip checking GC and FLUSH_MERGE conditions.
12571257 */
1258− if (f2fs_readonly(sb) && (*flags & MS_RDONLY))
1258+ if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
12591259 goto skip;
12601260
12611261 #ifdef CONFIG_QUOTA
1262− if (!f2fs_readonly(sb) && (*flags & MS_RDONLY)) {
1262+ if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
12631263 err = dquot_suspend(sb, -1);
12641264 if (err < 0)
12651265 goto restore_opts;
12661266 } else {
12671267 /* dquot_resume needs RW */
1268− sb->s_flags &= ~MS_RDONLY;
1268+ sb->s_flags &= ~SB_RDONLY;
12691269 if (sb_any_quota_suspended(sb)) {
12701270 dquot_resume(sb, -1);
12711271 } else if (f2fs_sb_has_quota_ino(sb)) {
@@ -1288,7 +1288,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) · 16 unmodified lines
12881288 * or if background_gc = off is passed in mount
12891289 * option. Also sync the filesystem.
12901290 */
1291− if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) {
1291+ if ((*flags & SB_RDONLY) || !test_opt(sbi, BG_GC)) {
12921292 if (sbi->gc_thread) {
12931293 stop_gc_thread(sbi);
12941294 need_restart_gc = true;
@@ -1300,7 +1300,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
13001300 need_stop_gc = true;
13011301 }
13021302
1303− if (*flags & MS_RDONLY) {
1303+ if (*flags & SB_RDONLY) {
13041304 writeback_inodes_sb(sb, WB_REASON_SYNC);
13051305 sync_inodes_sb(sb);
13061306
@@ -1314,7 +1314,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) · 7 unmodified lines
13141314 * We stop issue flush thread if FS is mounted as RO
13151315 * or if flush_merge is not passed in mount option.
13161316 */
1317− if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
1317+ if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
13181318 clear_opt(sbi, FLUSH_MERGE);
13191319 destroy_flush_cmd_control(sbi, false);
13201320 } else {
@@ -1329,8 +1329,8 @@ skip: · 8 unmodified lines
13291329 kfree(s_qf_names[i]);
13301330 #endif
13311331 /* Update the POSIXACL Flag */
1332− sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1333− (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
1332+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
1333+ (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
13341334
13351335 return 0;
13361336 restore_gc:
@@ -2472,8 +2472,8 @@ try_onemore: · 1135 unmodified lines
24722472 sb->s_export_op = &f2fs_export_ops;
24732473 sb->s_magic = F2FS_SUPER_MAGIC;
24742474 sb->s_time_gran = 1;
2475− sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2476− (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
2475+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
2476+ (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
24772477 memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
24782478
24792479 /* init f2fs-specific super block info */
fs/fat/fatent.c+3−3
@@ -392,7 +392,7 @@ static int fat_mirror_bhs(struct super_block *sb, struct buffer_head **bhs, · 391 unmodified lines
392392 memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize);
393393 set_buffer_uptodate(c_bh);
394394 mark_buffer_dirty_inode(c_bh, sbi->fat_inode);
395− if (sb->s_flags & MS_SYNCHRONOUS)
395+ if (sb->s_flags & SB_SYNCHRONOUS)
396396 err = sync_dirty_buffer(c_bh);
397397 brelse(c_bh);
398398 if (err)
@@ -597,7 +597,7 @@ int fat_free_clusters(struct inode *inode, int cluster) · 198 unmodified lines
597597 }
598598
599599 if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {
600− if (sb->s_flags & MS_SYNCHRONOUS) {
600+ if (sb->s_flags & SB_SYNCHRONOUS) {
601601 err = fat_sync_bhs(bhs, nr_bhs);
602602 if (err)
603603 goto error;
@@ -612,7 +612,7 @@ int fat_free_clusters(struct inode *inode, int cluster) · 8 unmodified lines
612612 fat_collect_bhs(bhs, &nr_bhs, &fatent);
613613 } while (cluster != FAT_ENT_EOF);
614614
615− if (sb->s_flags & MS_SYNCHRONOUS) {
615+ if (sb->s_flags & SB_SYNCHRONOUS) {
616616 err = fat_sync_bhs(bhs, nr_bhs);
617617 if (err)
618618 goto error;
fs/fat/inode.c+4−4
@@ -781,12 +781,12 @@ static int fat_remount(struct super_block *sb, int *flags, char *data) · 780 unmodified lines
781781 {
782782 int new_rdonly;
783783 struct msdos_sb_info *sbi = MSDOS_SB(sb);
784− *flags |= MS_NODIRATIME | (sbi->options.isvfat ? 0 : MS_NOATIME);
784+ *flags |= SB_NODIRATIME | (sbi->options.isvfat ? 0 : SB_NOATIME);
785785
786786 sync_filesystem(sb);
787787
788788 /* make sure we update state on remount. */
789− new_rdonly = *flags & MS_RDONLY;
789+ new_rdonly = *flags & SB_RDONLY;
790790 if (new_rdonly != sb_rdonly(sb)) {
791791 if (new_rdonly)
792792 fat_set_state(sb, 0, 0);
@@ -1352,7 +1352,7 @@ out: · 559 unmodified lines
13521352 if (opts->unicode_xlate)
13531353 opts->utf8 = 0;
13541354 if (opts->nfs == FAT_NFS_NOSTALE_RO) {
1355− sb->s_flags |= MS_RDONLY;
1355+ sb->s_flags |= SB_RDONLY;
13561356 sb->s_export_op = &fat_export_ops_nostale;
13571357 }
13581358
@@ -1608,7 +1608,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat, · 249 unmodified lines
16081608 return -ENOMEM;
16091609 sb->s_fs_info = sbi;
16101610
1611− sb->s_flags |= MS_NODIRATIME;
1611+ sb->s_flags |= SB_NODIRATIME;
16121612 sb->s_magic = MSDOS_SUPER_MAGIC;
16131613 sb->s_op = &fat_sops;
16141614 sb->s_export_op = &fat_export_ops;
fs/fat/misc.c+1−1
@@ -33,7 +33,7 @@ void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...) · 32 unmodified lines
3333 if (opts->errors == FAT_ERRORS_PANIC)
3434 panic("FAT-fs (%s): fs panic from previous error\n", sb->s_id);
3535 else if (opts->errors == FAT_ERRORS_RO && !sb_rdonly(sb)) {
36− sb->s_flags |= MS_RDONLY;
36+ sb->s_flags |= SB_RDONLY;
3737 fat_msg(sb, KERN_ERR, "Filesystem has been set read-only");
3838 }
3939 }
fs/fat/namei_msdos.c+1−1
@@ -646,7 +646,7 @@ static void setup(struct super_block *sb) · 645 unmodified lines
646646 {
647647 MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;
648648 sb->s_d_op = &msdos_dentry_operations;
649− sb->s_flags |= MS_NOATIME;
649+ sb->s_flags |= SB_NOATIME;
650650 }
651651
652652 static int msdos_fill_super(struct super_block *sb, void *data, int silent)
fs/freevxfs/vxfs_super.c+2−2
@@ -116,7 +116,7 @@ vxfs_statfs(struct dentry *dentry, struct kstatfs *bufp) · 115 unmodified lines
116116 static int vxfs_remount(struct super_block *sb, int *flags, char *data)
117117 {
118118 sync_filesystem(sb);
119− *flags |= MS_RDONLY;
119+ *flags |= SB_RDONLY;
120120 return 0;
121121 }
122122
@@ -220,7 +220,7 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent) · 97 unmodified lines
220220 int ret = -EINVAL;
221221 u32 j;
222222
223− sbp->s_flags |= MS_RDONLY;
223+ sbp->s_flags |= SB_RDONLY;
224224
225225 infp = kzalloc(sizeof(*infp), GFP_KERNEL);
226226 if (!infp) {
fs/fs-writeback.c+1−1
@@ -490,7 +490,7 @@ static void inode_switch_wbs(struct inode *inode, int new_wb_id) · 489 unmodified lines
490490
491491 /* while holding I_WB_SWITCH, no one else can update the association */
492492 spin_lock(&inode->i_lock);
493− if (!(inode->i_sb->s_flags & MS_ACTIVE) ||
493+ if (!(inode->i_sb->s_flags & SB_ACTIVE) ||
494494 inode->i_state & (I_WB_SWITCH | I_FREEING) ||
495495 inode_to_wb(inode) == isw->new_wb) {
496496 spin_unlock(&inode->i_lock);
fs/fuse/inode.c+6−6
@@ -130,7 +130,7 @@ static void fuse_evict_inode(struct inode *inode) · 129 unmodified lines
130130 {
131131 truncate_inode_pages_final(&inode->i_data);
132132 clear_inode(inode);
133− if (inode->i_sb->s_flags & MS_ACTIVE) {
133+ if (inode->i_sb->s_flags & SB_ACTIVE) {
134134 struct fuse_conn *fc = get_fuse_conn(inode);
135135 struct fuse_inode *fi = get_fuse_inode(inode);
136136 fuse_queue_forget(fc, fi->forget, fi->nodeid, fi->nlookup);
@@ -141,7 +141,7 @@ static void fuse_evict_inode(struct inode *inode) · 4 unmodified lines
141141 static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
142142 {
143143 sync_filesystem(sb);
144− if (*flags & MS_MANDLOCK)
144+ if (*flags & SB_MANDLOCK)
145145 return -EINVAL;
146146
147147 return 0;
@@ -1056,10 +1056,10 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent) · 908 unmodified lines
10561056 int is_bdev = sb->s_bdev != NULL;
10571057
10581058 err = -EINVAL;
1059− if (sb->s_flags & MS_MANDLOCK)
1059+ if (sb->s_flags & SB_MANDLOCK)
10601060 goto err;
10611061
1062− sb->s_flags &= ~(MS_NOSEC | SB_I_VERSION);
1062+ sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION);
10631063
10641064 if (!parse_fuse_opt(data, &d, is_bdev))
10651065 goto err;
@@ -1109,9 +1109,9 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent) · 43 unmodified lines
11091109 goto err_dev_free;
11101110
11111111 /* Handle umasking inside the fuse code */
1112− if (sb->s_flags & MS_POSIXACL)
1112+ if (sb->s_flags & SB_POSIXACL)
11131113 fc->dont_mask = 1;
1114− sb->s_flags |= MS_POSIXACL;
1114+ sb->s_flags |= SB_POSIXACL;
11151115
11161116 fc->default_permissions = d.default_permissions;
11171117 fc->allow_other = d.allow_other;
fs/gfs2/ops_fstype.c+8−8
@@ -1065,15 +1065,15 @@ static int fill_super(struct super_block *sb, struct gfs2_args *args, int silent · 1064 unmodified lines
10651065 sdp->sd_args = *args;
10661066
10671067 if (sdp->sd_args.ar_spectator) {
1068− sb->s_flags |= MS_RDONLY;
1068+ sb->s_flags |= SB_RDONLY;
10691069 set_bit(SDF_RORECOVERY, &sdp->sd_flags);
10701070 }
10711071 if (sdp->sd_args.ar_posix_acl)
1072− sb->s_flags |= MS_POSIXACL;
1072+ sb->s_flags |= SB_POSIXACL;
10731073 if (sdp->sd_args.ar_nobarrier)
10741074 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
10751075
1076− sb->s_flags |= MS_NOSEC;
1076+ sb->s_flags |= SB_NOSEC;
10771077 sb->s_magic = GFS2_MAGIC;
10781078 sb->s_op = &gfs2_super_ops;
10791079 sb->s_d_op = &gfs2_dops;
@@ -1257,7 +1257,7 @@ static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags, · 177 unmodified lines
12571257 struct gfs2_args args;
12581258 struct gfs2_sbd *sdp;
12591259
1260− if (!(flags & MS_RDONLY))
1260+ if (!(flags & SB_RDONLY))
12611261 mode |= FMODE_WRITE;
12621262
12631263 bdev = blkdev_get_by_path(dev_name, mode, fs_type);
@@ -1313,15 +1313,15 @@ static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags, · 49 unmodified lines
13131313
13141314 if (s->s_root) {
13151315 error = -EBUSY;
1316− if ((flags ^ s->s_flags) & MS_RDONLY)
1316+ if ((flags ^ s->s_flags) & SB_RDONLY)
13171317 goto error_super;
13181318 } else {
13191319 snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
13201320 sb_set_blocksize(s, block_size(bdev));
1321− error = fill_super(s, &args, flags & MS_SILENT ? 1 : 0);
1321+ error = fill_super(s, &args, flags & SB_SILENT ? 1 : 0);
13221322 if (error)
13231323 goto error_super;
1324− s->s_flags |= MS_ACTIVE;
1324+ s->s_flags |= SB_ACTIVE;
13251325 bdev->bd_super = s;
13261326 }
13271327
@@ -1365,7 +1365,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type, · 37 unmodified lines
13651365 pr_warn("gfs2 mount does not exist\n");
13661366 return ERR_CAST(s);
13671367 }
1368− if ((flags ^ s->s_flags) & MS_RDONLY) {
1368+ if ((flags ^ s->s_flags) & SB_RDONLY) {
13691369 deactivate_locked_super(s);
13701370 return ERR_PTR(-EBUSY);
13711371 }
fs/gfs2/super.c+5−5
@@ -1256,10 +1256,10 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data) · 1255 unmodified lines
12561256 return -EINVAL;
12571257
12581258 if (sdp->sd_args.ar_spectator)
1259− *flags |= MS_RDONLY;
1259+ *flags |= SB_RDONLY;
12601260
1261− if ((sb->s_flags ^ *flags) & MS_RDONLY) {
1262− if (*flags & MS_RDONLY)
1261+ if ((sb->s_flags ^ *flags) & SB_RDONLY) {
1262+ if (*flags & SB_RDONLY)
12631263 error = gfs2_make_fs_ro(sdp);
12641264 else
12651265 error = gfs2_make_fs_rw(sdp);
@@ -1269,9 +1269,9 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data) · 3 unmodified lines
12691269
12701270 sdp->sd_args = args;
12711271 if (sdp->sd_args.ar_posix_acl)
1272− sb->s_flags |= MS_POSIXACL;
1272+ sb->s_flags |= SB_POSIXACL;
12731273 else
1274− sb->s_flags &= ~MS_POSIXACL;
1274+ sb->s_flags &= ~SB_POSIXACL;
12751275 if (sdp->sd_args.ar_nobarrier)
12761276 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
12771277 else
fs/gfs2/trans.c+1−1
@@ -117,7 +117,7 @@ void gfs2_trans_end(struct gfs2_sbd *sdp) · 116 unmodified lines
117117 kfree(tr);
118118 up_read(&sdp->sd_log_flush_lock);
119119
120− if (sdp->sd_vfs->s_flags & MS_SYNCHRONOUS)
120+ if (sdp->sd_vfs->s_flags & SB_SYNCHRONOUS)
121121 gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
122122 if (alloced)
123123 sb_end_intwrite(sdp->sd_vfs);
fs/hfs/mdb.c+2−2
@@ -204,11 +204,11 @@ int hfs_mdb_get(struct super_block *sb) · 203 unmodified lines
204204 attrib = mdb->drAtrb;
205205 if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
206206 pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n");
207− sb->s_flags |= MS_RDONLY;
207+ sb->s_flags |= SB_RDONLY;
208208 }
209209 if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
210210 pr_warn("filesystem is marked locked, mounting read-only.\n");
211− sb->s_flags |= MS_RDONLY;
211+ sb->s_flags |= SB_RDONLY;
212212 }
213213 if (!sb_rdonly(sb)) {
214214 /* Mark the volume uncleanly unmounted in case we crash */
fs/hfs/super.c+8−8
@@ -114,18 +114,18 @@ static int hfs_statfs(struct dentry *dentry, struct kstatfs *buf) · 113 unmodified lines
114114 static int hfs_remount(struct super_block *sb, int *flags, char *data)
115115 {
116116 sync_filesystem(sb);
117− *flags |= MS_NODIRATIME;
118− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
117+ *flags |= SB_NODIRATIME;
118+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
119119 return 0;
120− if (!(*flags & MS_RDONLY)) {
120+ if (!(*flags & SB_RDONLY)) {
121121 if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
122122 pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. leaving read-only.\n");
123− sb->s_flags |= MS_RDONLY;
124− *flags |= MS_RDONLY;
123+ sb->s_flags |= SB_RDONLY;
124+ *flags |= SB_RDONLY;
125125 } else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) {
126126 pr_warn("filesystem is marked locked, leaving read-only.\n");
127− sb->s_flags |= MS_RDONLY;
128− *flags |= MS_RDONLY;
127+ sb->s_flags |= SB_RDONLY;
128+ *flags |= SB_RDONLY;
129129 }
130130 }
131131 return 0;
@@ -407,7 +407,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent) · 275 unmodified lines
407407
408408 sb->s_op = &hfs_super_operations;
409409 sb->s_xattr = hfs_xattr_handlers;
410− sb->s_flags |= MS_NODIRATIME;
410+ sb->s_flags |= SB_NODIRATIME;
411411 mutex_init(&sbi->bitmap_lock);
412412
413413 res = hfs_mdb_get(sb);
fs/hfsplus/super.c+11−11
@@ -329,9 +329,9 @@ static int hfsplus_statfs(struct dentry *dentry, struct kstatfs *buf) · 328 unmodified lines
329329 static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
330330 {
331331 sync_filesystem(sb);
332− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
332+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
333333 return 0;
334− if (!(*flags & MS_RDONLY)) {
334+ if (!(*flags & SB_RDONLY)) {
335335 struct hfsplus_vh *vhdr = HFSPLUS_SB(sb)->s_vhdr;
336336 int force = 0;
337337
@@ -340,20 +340,20 @@ static int hfsplus_remount(struct super_block *sb, int *flags, char *data) · 2 unmodified lines
340340
341341 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
342342 pr_warn("filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. leaving read-only.\n");
343− sb->s_flags |= MS_RDONLY;
344− *flags |= MS_RDONLY;
343+ sb->s_flags |= SB_RDONLY;
344+ *flags |= SB_RDONLY;
345345 } else if (force) {
346346 /* nothing */
347347 } else if (vhdr->attributes &
348348 cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
349349 pr_warn("filesystem is marked locked, leaving read-only.\n");
350− sb->s_flags |= MS_RDONLY;
351− *flags |= MS_RDONLY;
350+ sb->s_flags |= SB_RDONLY;
351+ *flags |= SB_RDONLY;
352352 } else if (vhdr->attributes &
353353 cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
354354 pr_warn("filesystem is marked journaled, leaving read-only.\n");
355− sb->s_flags |= MS_RDONLY;
356− *flags |= MS_RDONLY;
355+ sb->s_flags |= SB_RDONLY;
356+ *flags |= SB_RDONLY;
357357 }
358358 }
359359 return 0;
@@ -455,16 +455,16 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent) · 95 unmodified lines
455455
456456 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
457457 pr_warn("Filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. mounting read-only.\n");
458− sb->s_flags |= MS_RDONLY;
458+ sb->s_flags |= SB_RDONLY;
459459 } else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) {
460460 /* nothing */
461461 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
462462 pr_warn("Filesystem is marked locked, mounting read-only.\n");
463− sb->s_flags |= MS_RDONLY;
463+ sb->s_flags |= SB_RDONLY;
464464 } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) &&
465465 !sb_rdonly(sb)) {
466466 pr_warn("write access to a journaled filesystem is not supported, use the force option at your own risk, mounting read-only.\n");
467− sb->s_flags |= MS_RDONLY;
467+ sb->s_flags |= SB_RDONLY;
468468 }
469469
470470 err = -EINVAL;
fs/hpfs/map.c+1−1
@@ -288,7 +288,7 @@ struct dnode *hpfs_map_dnode(struct super_block *s, unsigned secno, · 287 unmodified lines
288288 goto bail;
289289 }
290290 if (((31 + de->namelen + de->down*4 + 3) & ~3) != le16_to_cpu(de->length)) {
291− if (((31 + de->namelen + de->down*4 + 3) & ~3) < le16_to_cpu(de->length) && s->s_flags & MS_RDONLY) goto ok;
291+ if (((31 + de->namelen + de->down*4 + 3) & ~3) < le16_to_cpu(de->length) && s->s_flags & SB_RDONLY) goto ok;
292292 hpfs_error(s, "namelen does not match dirent size in dnode %08x, dirent %03x, last %03x", secno, p, pp);
293293 goto bail;
294294 }
fs/hpfs/super.c+4−4
@@ -78,7 +78,7 @@ void hpfs_error(struct super_block *s, const char *fmt, ...) · 77 unmodified lines
7878 else {
7979 pr_cont("; remounting read-only\n");
8080 mark_dirty(s, 0);
81− s->s_flags |= MS_RDONLY;
81+ s->s_flags |= SB_RDONLY;
8282 }
8383 } else if (sb_rdonly(s))
8484 pr_cont("; going on - but anything won't be destroyed because it's read-only\n");
@@ -457,7 +457,7 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data) · 372 unmodified lines
457457
458458 sync_filesystem(s);
459459
460− *flags |= MS_NOATIME;
460+ *flags |= SB_NOATIME;
461461
462462 hpfs_lock(s);
463463 uid = sbi->sb_uid; gid = sbi->sb_gid;
@@ -488,7 +488,7 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data) · 24 unmodified lines
488488 sbi->sb_eas = eas; sbi->sb_chk = chk; sbi->sb_chkdsk = chkdsk;
489489 sbi->sb_err = errs; sbi->sb_timeshift = timeshift;
490490
491− if (!(*flags & MS_RDONLY)) mark_dirty(s, 1);
491+ if (!(*flags & SB_RDONLY)) mark_dirty(s, 1);
492492
493493 hpfs_unlock(s);
494494 return 0;
@@ -614,7 +614,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent) · 119 unmodified lines
614614 goto bail4;
615615 }
616616
617− s->s_flags |= MS_NOATIME;
617+ s->s_flags |= SB_NOATIME;
618618
619619 /* Fill superblock stuff */
620620 s->s_magic = HPFS_SUPER_MAGIC;
fs/inode.c+5−5
@@ -416,7 +416,7 @@ void inode_add_lru(struct inode *inode) · 415 unmodified lines
416416 {
417417 if (!(inode->i_state & (I_DIRTY_ALL | I_SYNC |
418418 I_FREEING | I_WILL_FREE)) &&
419− !atomic_read(&inode->i_count) && inode->i_sb->s_flags & MS_ACTIVE)
419+ !atomic_read(&inode->i_count) && inode->i_sb->s_flags & SB_ACTIVE)
420420 inode_lru_list_add(inode);
421421 }
422422
@@ -595,7 +595,7 @@ static void dispose_list(struct list_head *head) · 172 unmodified lines
595595 * @sb: superblock to operate on
596596 *
597597 * Make sure that no inodes with zero refcount are retained. This is
598− * called by superblock shutdown after having MS_ACTIVE flag removed,
598+ * called by superblock shutdown after having SB_ACTIVE flag removed,
599599 * so any inode reaching zero refcount during or after that call will
600600 * be immediately evicted.
601601 */
@@ -1492,7 +1492,7 @@ static void iput_final(struct inode *inode) · 890 unmodified lines
14921492 else
14931493 drop = generic_drop_inode(inode);
14941494
1495− if (!drop && (sb->s_flags & MS_ACTIVE)) {
1495+ if (!drop && (sb->s_flags & SB_ACTIVE)) {
14961496 inode_add_lru(inode);
14971497 spin_unlock(&inode->i_lock);
14981498 return;
@@ -1644,7 +1644,7 @@ int generic_update_time(struct inode *inode, struct timespec *time, int flags) · 145 unmodified lines
16441644 if (flags & S_MTIME)
16451645 inode->i_mtime = *time;
16461646
1647− if (!(inode->i_sb->s_flags & MS_LAZYTIME) || (flags & S_VERSION))
1647+ if (!(inode->i_sb->s_flags & SB_LAZYTIME) || (flags & S_VERSION))
16481648 iflags |= I_DIRTY_SYNC;
16491649 __mark_inode_dirty(inode, iflags);
16501650 return 0;
@@ -1691,7 +1691,7 @@ bool __atime_needs_update(const struct path *path, struct inode *inode, · 40 unmodified lines
16911691
16921692 if (IS_NOATIME(inode))
16931693 return false;
1694− if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1694+ if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode))
16951695 return false;
16961696
16971697 if (mnt->mnt_flags & MNT_NOATIME)
fs/isofs/inode.c+1−1
@@ -114,7 +114,7 @@ static void destroy_inodecache(void) · 113 unmodified lines
114114 static int isofs_remount(struct super_block *sb, int *flags, char *data)
115115 {
116116 sync_filesystem(sb);
117− if (!(*flags & MS_RDONLY))
117+ if (!(*flags & SB_RDONLY))
118118 return -EROFS;
119119 return 0;
120120 }
fs/jffs2/fs.c+2−2
@@ -409,10 +409,10 @@ int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data) · 408 unmodified lines
409409 mutex_unlock(&c->alloc_sem);
410410 }
411411
412− if (!(*flags & MS_RDONLY))
412+ if (!(*flags & SB_RDONLY))
413413 jffs2_start_garbage_collect_thread(c);
414414
415− *flags |= MS_NOATIME;
415+ *flags |= SB_NOATIME;
416416 return 0;
417417 }
418418
fs/jffs2/os-linux.h+1−1
@@ -59,7 +59,7 @@ static inline void jffs2_init_inode_info(struct jffs2_inode_info *f) · 58 unmodified lines
5959 }
6060
6161
62−#define jffs2_is_readonly(c) (OFNI_BS_2SFFJ(c)->s_flags & MS_RDONLY)
62+#define jffs2_is_readonly(c) (OFNI_BS_2SFFJ(c)->s_flags & SB_RDONLY)
6363
6464 #define SECTOR_ADDR(x) ( (((unsigned long)(x) / c->sector_size) * c->sector_size) )
6565 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
fs/jffs2/super.c+2−2
@@ -301,10 +301,10 @@ static int jffs2_fill_super(struct super_block *sb, void *data, int silent) · 300 unmodified lines
301301
302302 sb->s_op = &jffs2_super_operations;
303303 sb->s_export_op = &jffs2_export_ops;
304− sb->s_flags = sb->s_flags | MS_NOATIME;
304+ sb->s_flags = sb->s_flags | SB_NOATIME;
305305 sb->s_xattr = jffs2_xattr_handlers;
306306 #ifdef CONFIG_JFFS2_FS_POSIX_ACL
307− sb->s_flags |= MS_POSIXACL;
307+ sb->s_flags |= SB_POSIXACL;
308308 #endif
309309 ret = jffs2_do_fill_super(sb, data, silent);
310310 return ret;
fs/jfs/super.c+5−5
@@ -87,7 +87,7 @@ static void jfs_handle_error(struct super_block *sb) · 86 unmodified lines
8787 else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
8888 jfs_err("ERROR: (device %s): remounting filesystem as read-only",
8989 sb->s_id);
90− sb->s_flags |= MS_RDONLY;
90+ sb->s_flags |= SB_RDONLY;
9191 }
9292
9393 /* nothing is done for continue beyond marking the superblock dirty */
@@ -477,7 +477,7 @@ static int jfs_remount(struct super_block *sb, int *flags, char *data) · 383 unmodified lines
477477 return rc;
478478 }
479479
480− if (sb_rdonly(sb) && !(*flags & MS_RDONLY)) {
480+ if (sb_rdonly(sb) && !(*flags & SB_RDONLY)) {
481481 /*
482482 * Invalidate any previously read metadata. fsck may have
483483 * changed the on-disk data since we mounted r/o
@@ -488,12 +488,12 @@ static int jfs_remount(struct super_block *sb, int *flags, char *data) · 4 unmodified lines
488488 ret = jfs_mount_rw(sb, 1);
489489
490490 /* mark the fs r/w for quota activity */
491− sb->s_flags &= ~MS_RDONLY;
491+ sb->s_flags &= ~SB_RDONLY;
492492
493493 dquot_resume(sb, -1);
494494 return ret;
495495 }
496− if (!sb_rdonly(sb) && (*flags & MS_RDONLY)) {
496+ if (!sb_rdonly(sb) && (*flags & SB_RDONLY)) {
497497 rc = dquot_suspend(sb, -1);
498498 if (rc < 0)
499499 return rc;
@@ -545,7 +545,7 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent) · 45 unmodified lines
545545 sbi->flag = flag;
546546
547547 #ifdef CONFIG_JFS_POSIX_ACL
548− sb->s_flags |= MS_POSIXACL;
548+ sb->s_flags |= SB_POSIXACL;
549549 #endif
550550
551551 if (newLVSize) {
fs/kernfs/mount.c+1−1
@@ -335,7 +335,7 @@ struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, · 334 unmodified lines
335335 deactivate_locked_super(sb);
336336 return ERR_PTR(error);
337337 }
338− sb->s_flags |= MS_ACTIVE;
338+ sb->s_flags |= SB_ACTIVE;
339339
340340 mutex_lock(&kernfs_mutex);
341341 list_add(&info->node, &root->supers);
fs/libfs.c+3−3
@@ -246,7 +246,7 @@ struct dentry *mount_pseudo_xattr(struct file_system_type *fs_type, char *name, · 245 unmodified lines
246246 struct inode *root;
247247 struct qstr d_name = QSTR_INIT(name, strlen(name));
248248
249− s = sget_userns(fs_type, NULL, set_anon_super, MS_KERNMOUNT|MS_NOUSER,
249+ s = sget_userns(fs_type, NULL, set_anon_super, SB_KERNMOUNT|SB_NOUSER,
250250 &init_user_ns, NULL);
251251 if (IS_ERR(s))
252252 return ERR_CAST(s);
@@ -277,7 +277,7 @@ struct dentry *mount_pseudo_xattr(struct file_system_type *fs_type, char *name, · 24 unmodified lines
277277 d_instantiate(dentry, root);
278278 s->s_root = dentry;
279279 s->s_d_op = dops;
280− s->s_flags |= MS_ACTIVE;
280+ s->s_flags |= SB_ACTIVE;
281281 return dget(s->s_root);
282282
283283 Enomem:
@@ -578,7 +578,7 @@ int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *c · 294 unmodified lines
578578 spin_lock(&pin_fs_lock);
579579 if (unlikely(!*mount)) {
580580 spin_unlock(&pin_fs_lock);
581− mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, NULL);
581+ mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL);
582582 if (IS_ERR(mnt))
583583 return PTR_ERR(mnt);
584584 spin_lock(&pin_fs_lock);
fs/locks.c+1−1
@@ -141,7 +141,7 @@ · 140 unmodified lines
141141
142142 static inline bool is_remote_lock(struct file *filp)
143143 {
144− return likely(!(filp->f_path.dentry->d_sb->s_flags & MS_NOREMOTELOCK));
144+ return likely(!(filp->f_path.dentry->d_sb->s_flags & SB_NOREMOTELOCK));
145145 }
146146
147147 static bool lease_breaking(struct file_lock *fl)
fs/minix/inode.c+2−2
@@ -125,9 +125,9 @@ static int minix_remount (struct super_block * sb, int * flags, char * data) · 124 unmodified lines
125125
126126 sync_filesystem(sb);
127127 ms = sbi->s_ms;
128− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
128+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
129129 return 0;
130− if (*flags & MS_RDONLY) {
130+ if (*flags & SB_RDONLY) {
131131 if (ms->s_state & MINIX_VALID_FS ||
132132 !(sbi->s_mount_state & MINIX_VALID_FS))
133133 return 0;
fs/ncpfs/inode.c+2−2
@@ -103,7 +103,7 @@ static void destroy_inodecache(void) · 102 unmodified lines
103103 static int ncp_remount(struct super_block *sb, int *flags, char* data)
104104 {
105105 sync_filesystem(sb);
106− *flags |= MS_NODIRATIME;
106+ *flags |= SB_NODIRATIME;
107107 return 0;
108108 }
109109
@@ -547,7 +547,7 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent) · 437 unmodified lines
547547 else
548548 default_bufsize = 1024;
549549
550− sb->s_flags |= MS_NODIRATIME; /* probably even noatime */
550+ sb->s_flags |= SB_NODIRATIME; /* probably even noatime */
551551 sb->s_maxbytes = 0xFFFFFFFFU;
552552 sb->s_blocksize = 1024; /* Eh... Is this correct? */
553553 sb->s_blocksize_bits = 10;
fs/nfs/dir.c+1−1
@@ -1256,7 +1256,7 @@ static int nfs_dentry_delete(const struct dentry *dentry) · 1255 unmodified lines
12561256 /* Unhash it, so that ->d_iput() would be called */
12571257 return 1;
12581258 }
1259− if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1259+ if (!(dentry->d_sb->s_flags & SB_ACTIVE)) {
12601260 /* Unhash it, so that ancestors of killed async unlink
12611261 * files will be cleaned up during umount */
12621262 return 1;
fs/nfs/inode.c+1−1
@@ -752,7 +752,7 @@ int nfs_getattr(const struct path *path, struct kstat *stat, · 751 unmodified lines
752752 * Note that we only have to check the vfsmount flags here:
753753 * - NFS always sets S_NOATIME by so checking it would give a
754754 * bogus result
755− * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
755+ * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is
756756 * no point in checking those.
757757 */
758758 if ((path->mnt->mnt_flags & MNT_NOATIME) ||
fs/nfs/internal.h+1−1
@@ -10,7 +10,7 @@ · 9 unmodified lines
1010 #include <linux/nfs_page.h>
1111 #include <linux/wait_bit.h>
1212
13−#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
13+#define NFS_MS_MASK (SB_RDONLY|SB_NOSUID|SB_NODEV|SB_NOEXEC|SB_SYNCHRONOUS)
1414
1515 extern const struct export_operations nfs_export_ops;
1616
fs/nfs/super.c+11−11
@@ -813,9 +813,9 @@ int nfs_show_stats(struct seq_file *m, struct dentry *root) · 812 unmodified lines
813813 */
814814 seq_printf(m, "\n\topts:\t");
815815 seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");
816− seq_puts(m, root->d_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
817− seq_puts(m, root->d_sb->s_flags & MS_NOATIME ? ",noatime" : "");
818− seq_puts(m, root->d_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
816+ seq_puts(m, root->d_sb->s_flags & SB_SYNCHRONOUS ? ",sync" : "");
817+ seq_puts(m, root->d_sb->s_flags & SB_NOATIME ? ",noatime" : "");
818+ seq_puts(m, root->d_sb->s_flags & SB_NODIRATIME ? ",nodiratime" : "");
819819 nfs_show_mount_options(m, nfss, 1);
820820
821821 seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
@@ -2296,11 +2296,11 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data) · 1474 unmodified lines
22962296 /*
22972297 * noac is a special case. It implies -o sync, but that's not
22982298 * necessarily reflected in the mtab options. do_remount_sb
2299− * will clear MS_SYNCHRONOUS if -o sync wasn't specified in the
2299+ * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
23002300 * remount options, so we have to explicitly reset it.
23012301 */
23022302 if (data->flags & NFS_MOUNT_NOAC)
2303− *flags |= MS_SYNCHRONOUS;
2303+ *flags |= SB_SYNCHRONOUS;
23042304
23052305 /* compare new mount options with old ones */
23062306 error = nfs_compare_remount_data(nfss, data);
@@ -2349,7 +2349,7 @@ void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info) · 42 unmodified lines
23492349 /* The VFS shouldn't apply the umask to mode bits. We will do
23502350 * so ourselves when necessary.
23512351 */
2352− sb->s_flags |= MS_POSIXACL;
2352+ sb->s_flags |= SB_POSIXACL;
23532353 sb->s_time_gran = 1;
23542354 sb->s_export_op = &nfs_export_ops;
23552355 }
@@ -2379,7 +2379,7 @@ static void nfs_clone_super(struct super_block *sb, · 23 unmodified lines
23792379 /* The VFS shouldn't apply the umask to mode bits. We will do
23802380 * so ourselves when necessary.
23812381 */
2382− sb->s_flags |= MS_POSIXACL;
2382+ sb->s_flags |= SB_POSIXACL;
23832383 }
23842384
23852385 nfs_initialise_sb(sb);
@@ -2600,11 +2600,11 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server, · 214 unmodified lines
26002600
26012601 /* -o noac implies -o sync */
26022602 if (server->flags & NFS_MOUNT_NOAC)
2603− sb_mntdata.mntflags |= MS_SYNCHRONOUS;
2603+ sb_mntdata.mntflags |= SB_SYNCHRONOUS;
26042604
26052605 if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)
2606− if (mount_info->cloned->sb->s_flags & MS_SYNCHRONOUS)
2607− sb_mntdata.mntflags |= MS_SYNCHRONOUS;
2606+ if (mount_info->cloned->sb->s_flags & SB_SYNCHRONOUS)
2607+ sb_mntdata.mntflags |= SB_SYNCHRONOUS;
26082608
26092609 /* Get a superblock - note that we may end up sharing one that already exists */
26102610 s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata);
@@ -2641,7 +2641,7 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server, · 30 unmodified lines
26412641 if (error)
26422642 goto error_splat_root;
26432643
2644− s->s_flags |= MS_ACTIVE;
2644+ s->s_flags |= SB_ACTIVE;
26452645
26462646 out:
26472647 return mntroot;
fs/nilfs2/segment.c+1−1
@@ -1979,7 +1979,7 @@ static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci, · 1978 unmodified lines
19791979 struct the_nilfs *nilfs)
19801980 {
19811981 struct nilfs_inode_info *ii, *n;
1982− int during_mount = !(sci->sc_super->s_flags & MS_ACTIVE);
1982+ int during_mount = !(sci->sc_super->s_flags & SB_ACTIVE);
19831983 int defer_iput = false;
19841984
19851985 spin_lock(&nilfs->ns_inode_lock);
fs/nilfs2/super.c+12−12
@@ -141,7 +141,7 @@ void __nilfs_error(struct super_block *sb, const char *function, · 140 unmodified lines
141141
142142 if (nilfs_test_opt(nilfs, ERRORS_RO)) {
143143 printk(KERN_CRIT "Remounting filesystem read-only\n");
144− sb->s_flags |= MS_RDONLY;
144+ sb->s_flags |= SB_RDONLY;
145145 }
146146 }
147147
@@ -869,7 +869,7 @@ int nilfs_store_magic_and_option(struct super_block *sb, · 721 unmodified lines
869869
870870 /* FS independent flags */
871871 #ifdef NILFS_ATIME_DISABLE
872− sb->s_flags |= MS_NOATIME;
872+ sb->s_flags |= SB_NOATIME;
873873 #endif
874874
875875 nilfs_set_default_options(sb, sbp);
@@ -1133,7 +1133,7 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data) · 257 unmodified lines
11331133 err = -EINVAL;
11341134 goto restore_opts;
11351135 }
1136− sb->s_flags = (sb->s_flags & ~MS_POSIXACL);
1136+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL);
11371137
11381138 err = -EINVAL;
11391139
@@ -1143,12 +1143,12 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data) · 3 unmodified lines
11431143 goto restore_opts;
11441144 }
11451145
1146− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
1146+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
11471147 goto out;
1148− if (*flags & MS_RDONLY) {
1148+ if (*flags & SB_RDONLY) {
11491149 /* Shutting down log writer */
11501150 nilfs_detach_log_writer(sb);
1151− sb->s_flags |= MS_RDONLY;
1151+ sb->s_flags |= SB_RDONLY;
11521152
11531153 /*
11541154 * Remounting a valid RW partition RDONLY, so set
@@ -1178,7 +1178,7 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data) · 23 unmodified lines
11781178 goto restore_opts;
11791179 }
11801180
1181− sb->s_flags &= ~MS_RDONLY;
1181+ sb->s_flags &= ~SB_RDONLY;
11821182
11831183 root = NILFS_I(d_inode(sb->s_root))->i_root;
11841184 err = nilfs_attach_log_writer(sb, root);
@@ -1212,7 +1212,7 @@ static int nilfs_parse_snapshot_option(const char *option, · 27 unmodified lines
12121212 const char *msg = NULL;
12131213 int err;
12141214
1215− if (!(sd->flags & MS_RDONLY)) {
1215+ if (!(sd->flags & SB_RDONLY)) {
12161216 msg = "read-only option is not specified";
12171217 goto parse_error;
12181218 }
@@ -1286,7 +1286,7 @@ nilfs_mount(struct file_system_type *fs_type, int flags, · 67 unmodified lines
12861286 struct dentry *root_dentry;
12871287 int err, s_new = false;
12881288
1289− if (!(flags & MS_RDONLY))
1289+ if (!(flags & SB_RDONLY))
12901290 mode |= FMODE_WRITE;
12911291
12921292 sd.bdev = blkdev_get_by_path(dev_name, mode, fs_type);
@@ -1327,14 +1327,14 @@ nilfs_mount(struct file_system_type *fs_type, int flags, · 34 unmodified lines
13271327 snprintf(s->s_id, sizeof(s->s_id), "%pg", sd.bdev);
13281328 sb_set_blocksize(s, block_size(sd.bdev));
13291329
1330− err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
1330+ err = nilfs_fill_super(s, data, flags & SB_SILENT ? 1 : 0);
13311331 if (err)
13321332 goto failed_super;
13331333
1334− s->s_flags |= MS_ACTIVE;
1334+ s->s_flags |= SB_ACTIVE;
13351335 } else if (!sd.cno) {
13361336 if (nilfs_tree_is_busy(s->s_root)) {
1337− if ((flags ^ s->s_flags) & MS_RDONLY) {
1337+ if ((flags ^ s->s_flags) & SB_RDONLY) {
13381338 nilfs_msg(s, KERN_ERR,
13391339 "the device already has a %s mount.",
13401340 sb_rdonly(s) ? "read-only" : "read/write");
fs/nilfs2/the_nilfs.c+3−3
@@ -220,7 +220,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb) · 219 unmodified lines
220220
221221 if (!valid_fs) {
222222 nilfs_msg(sb, KERN_WARNING, "mounting unchecked fs");
223− if (s_flags & MS_RDONLY) {
223+ if (s_flags & SB_RDONLY) {
224224 nilfs_msg(sb, KERN_INFO,
225225 "recovery required for readonly filesystem");
226226 nilfs_msg(sb, KERN_INFO,
@@ -286,7 +286,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb) · 59 unmodified lines
286286 if (valid_fs)
287287 goto skip_recovery;
288288
289− if (s_flags & MS_RDONLY) {
289+ if (s_flags & SB_RDONLY) {
290290 __u64 features;
291291
292292 if (nilfs_test_opt(nilfs, NORECOVERY)) {
@@ -309,7 +309,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb) · 16 unmodified lines
309309 err = -EROFS;
310310 goto failed_unload;
311311 }
312− sb->s_flags &= ~MS_RDONLY;
312+ sb->s_flags &= ~SB_RDONLY;
313313 } else if (nilfs_test_opt(nilfs, NORECOVERY)) {
314314 nilfs_msg(sb, KERN_ERR,
315315 "recovery cancelled because norecovery option was specified for a read/write mount");
fs/notify/fsnotify.c+1−1
@@ -67,7 +67,7 @@ void fsnotify_unmount_inodes(struct super_block *sb) · 66 unmodified lines
6767
6868 /*
6969 * If i_count is zero, the inode cannot have any watches and
70− * doing an __iget/iput with MS_ACTIVE clear would actually
70+ * doing an __iget/iput with SB_ACTIVE clear would actually
7171 * evict all inodes with zero i_count from icache which is
7272 * unnecessarily violent and may in fact be illegal to do.
7373 */
fs/nsfs.c+1−1
@@ -255,5 +255,5 @@ void __init nsfs_init(void) · 254 unmodified lines
255255 nsfs_mnt = kern_mount(&nsfs);
256256 if (IS_ERR(nsfs_mnt))
257257 panic("can't set nsfs up\n");
258− nsfs_mnt->mnt_sb->s_flags &= ~MS_NOUSER;
258+ nsfs_mnt->mnt_sb->s_flags &= ~SB_NOUSER;
259259 }
fs/ntfs/super.c+16−16
@@ -473,7 +473,7 @@ static int ntfs_remount(struct super_block *sb, int *flags, char *opt) · 472 unmodified lines
473473
474474 #ifndef NTFS_RW
475475 /* For read-only compiled driver, enforce read-only flag. */
476− *flags |= MS_RDONLY;
476+ *flags |= SB_RDONLY;
477477 #else /* NTFS_RW */
478478 /*
479479 * For the read-write compiled driver, if we are remounting read-write,
@@ -487,7 +487,7 @@ static int ntfs_remount(struct super_block *sb, int *flags, char *opt) · 7 unmodified lines
487487 * When remounting read-only, mark the volume clean if no volume errors
488488 * have occurred.
489489 */
490− if (sb_rdonly(sb) && !(*flags & MS_RDONLY)) {
490+ if (sb_rdonly(sb) && !(*flags & SB_RDONLY)) {
491491 static const char *es = ". Cannot remount read-write.";
492492
493493 /* Remounting read-write. */
@@ -548,7 +548,7 @@ static int ntfs_remount(struct super_block *sb, int *flags, char *opt) · 54 unmodified lines
548548 NVolSetErrors(vol);
549549 return -EROFS;
550550 }
551− } else if (!sb_rdonly(sb) && (*flags & MS_RDONLY)) {
551+ } else if (!sb_rdonly(sb) && (*flags & SB_RDONLY)) {
552552 /* Remounting read-only. */
553553 if (!NVolErrors(vol)) {
554554 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
@@ -1799,7 +1799,7 @@ static bool load_system_files(ntfs_volume *vol) · 1244 unmodified lines
17991799 es3);
18001800 goto iput_mirr_err_out;
18011801 }
1802− sb->s_flags |= MS_RDONLY;
1802+ sb->s_flags |= SB_RDONLY;
18031803 ntfs_error(sb, "%s. Mounting read-only%s",
18041804 !vol->mftmirr_ino ? es1 : es2, es3);
18051805 } else
@@ -1937,7 +1937,7 @@ get_ctx_vol_failed: · 131 unmodified lines
19371937 es1, es2);
19381938 goto iput_vol_err_out;
19391939 }
1940− sb->s_flags |= MS_RDONLY;
1940+ sb->s_flags |= SB_RDONLY;
19411941 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
19421942 } else
19431943 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -1974,7 +1974,7 @@ get_ctx_vol_failed: · 30 unmodified lines
19741974 }
19751975 goto iput_logfile_err_out;
19761976 }
1977− sb->s_flags |= MS_RDONLY;
1977+ sb->s_flags |= SB_RDONLY;
19781978 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
19791979 } else
19801980 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2019,7 +2019,7 @@ get_ctx_vol_failed: · 38 unmodified lines
20192019 es1, es2);
20202020 goto iput_root_err_out;
20212021 }
2022− sb->s_flags |= MS_RDONLY;
2022+ sb->s_flags |= SB_RDONLY;
20232023 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
20242024 } else
20252025 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2042,7 +2042,7 @@ get_ctx_vol_failed: · 16 unmodified lines
20422042 goto iput_root_err_out;
20432043 }
20442044 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2045− sb->s_flags |= MS_RDONLY;
2045+ sb->s_flags |= SB_RDONLY;
20462046 /*
20472047 * Do not set NVolErrors() because ntfs_remount() might manage
20482048 * to set the dirty flag in which case all would be well.
@@ -2055,7 +2055,7 @@ get_ctx_vol_failed: · 6 unmodified lines
20552055 * If (still) a read-write mount, set the NT4 compatibility flag on
20562056 * newer NTFS version volumes.
20572057 */
2058− if (!(sb->s_flags & MS_RDONLY) && (vol->major_ver > 1) &&
2058+ if (!(sb->s_flags & SB_RDONLY) && (vol->major_ver > 1) &&
20592059 ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
20602060 static const char *es1 = "Failed to set NT4 compatibility flag";
20612061 static const char *es2 = ". Run chkdsk.";
@@ -2069,7 +2069,7 @@ get_ctx_vol_failed: · 7 unmodified lines
20692069 goto iput_root_err_out;
20702070 }
20712071 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2072− sb->s_flags |= MS_RDONLY;
2072+ sb->s_flags |= SB_RDONLY;
20732073 NVolSetErrors(vol);
20742074 }
20752075 #endif
@@ -2087,7 +2087,7 @@ get_ctx_vol_failed: · 11 unmodified lines
20872087 goto iput_root_err_out;
20882088 }
20892089 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2090− sb->s_flags |= MS_RDONLY;
2090+ sb->s_flags |= SB_RDONLY;
20912091 NVolSetErrors(vol);
20922092 }
20932093 #endif /* NTFS_RW */
@@ -2128,7 +2128,7 @@ get_ctx_vol_failed: · 34 unmodified lines
21282128 es1, es2);
21292129 goto iput_quota_err_out;
21302130 }
2131− sb->s_flags |= MS_RDONLY;
2131+ sb->s_flags |= SB_RDONLY;
21322132 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
21332133 } else
21342134 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2150,7 +2150,7 @@ get_ctx_vol_failed: · 15 unmodified lines
21502150 goto iput_quota_err_out;
21512151 }
21522152 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2153− sb->s_flags |= MS_RDONLY;
2153+ sb->s_flags |= SB_RDONLY;
21542154 NVolSetErrors(vol);
21552155 }
21562156 /*
@@ -2171,7 +2171,7 @@ get_ctx_vol_failed: · 14 unmodified lines
21712171 es1, es2);
21722172 goto iput_usnjrnl_err_out;
21732173 }
2174− sb->s_flags |= MS_RDONLY;
2174+ sb->s_flags |= SB_RDONLY;
21752175 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
21762176 } else
21772177 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2194,7 +2194,7 @@ get_ctx_vol_failed: · 16 unmodified lines
21942194 goto iput_usnjrnl_err_out;
21952195 }
21962196 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2197− sb->s_flags |= MS_RDONLY;
2197+ sb->s_flags |= SB_RDONLY;
21982198 NVolSetErrors(vol);
21992199 }
22002200 #endif /* NTFS_RW */
@@ -2728,7 +2728,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent) · 527 unmodified lines
27282728 lockdep_off();
27292729 ntfs_debug("Entering.");
27302730 #ifndef NTFS_RW
2731− sb->s_flags |= MS_RDONLY;
2731+ sb->s_flags |= SB_RDONLY;
27322732 #endif /* ! NTFS_RW */
27332733 /* Allocate a new ntfs_volume and place it in sb->s_fs_info. */
27342734 sb->s_fs_info = kmalloc(sizeof(ntfs_volume), GFP_NOFS);
fs/ocfs2/file.c+1−1
@@ -227,7 +227,7 @@ int ocfs2_should_update_atime(struct inode *inode, · 226 unmodified lines
227227 return 0;
228228
229229 if ((inode->i_flags & S_NOATIME) ||
230− ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)))
230+ ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode)))
231231 return 0;
232232
233233 /*
fs/ocfs2/super.c+14−14
@@ -675,9 +675,9 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data) · 674 unmodified lines
675675 }
676676
677677 /* We're going to/from readonly mode. */
678− if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) {
678+ if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
679679 /* Disable quota accounting before remounting RO */
680− if (*flags & MS_RDONLY) {
680+ if (*flags & SB_RDONLY) {
681681 ret = ocfs2_susp_quotas(osb, 0);
682682 if (ret < 0)
683683 goto out;
@@ -691,8 +691,8 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data) · 7 unmodified lines
691691 goto unlock_osb;
692692 }
693693
694− if (*flags & MS_RDONLY) {
695− sb->s_flags |= MS_RDONLY;
694+ if (*flags & SB_RDONLY) {
695+ sb->s_flags |= SB_RDONLY;
696696 osb->osb_flags |= OCFS2_OSB_SOFT_RO;
697697 } else {
698698 if (osb->osb_flags & OCFS2_OSB_ERROR_FS) {
@@ -709,14 +709,14 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data) · 10 unmodified lines
709709 ret = -EINVAL;
710710 goto unlock_osb;
711711 }
712− sb->s_flags &= ~MS_RDONLY;
712+ sb->s_flags &= ~SB_RDONLY;
713713 osb->osb_flags &= ~OCFS2_OSB_SOFT_RO;
714714 }
715715 trace_ocfs2_remount(sb->s_flags, osb->osb_flags, *flags);
716716 unlock_osb:
717717 spin_unlock(&osb->osb_lock);
718718 /* Enable quota accounting after remounting RW */
719− if (!ret && !(*flags & MS_RDONLY)) {
719+ if (!ret && !(*flags & SB_RDONLY)) {
720720 if (sb_any_quota_suspended(sb))
721721 ret = ocfs2_susp_quotas(osb, 1);
722722 else
@@ -724,7 +724,7 @@ unlock_osb: · 1 unmodified line
724724 if (ret < 0) {
725725 /* Return back changes... */
726726 spin_lock(&osb->osb_lock);
727− sb->s_flags |= MS_RDONLY;
727+ sb->s_flags |= SB_RDONLY;
728728 osb->osb_flags |= OCFS2_OSB_SOFT_RO;
729729 spin_unlock(&osb->osb_lock);
730730 goto out;
@@ -744,9 +744,9 @@ unlock_osb: · 13 unmodified lines
744744 if (!ocfs2_is_hard_readonly(osb))
745745 ocfs2_set_journal_params(osb);
746746
747− sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
747+ sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
748748 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ?
749− MS_POSIXACL : 0);
749+ SB_POSIXACL : 0);
750750 }
751751 out:
752752 return ret;
@@ -1057,10 +1057,10 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent) · 304 unmodified lines
10571057
10581058 sb->s_magic = OCFS2_SUPER_MAGIC;
10591059
1060− sb->s_flags = (sb->s_flags & ~(MS_POSIXACL | MS_NOSEC)) |
1061− ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1060+ sb->s_flags = (sb->s_flags & ~(SB_POSIXACL | SB_NOSEC)) |
1061+ ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? SB_POSIXACL : 0);
10621062
1063− /* Hard readonly mode only if: bdev_read_only, MS_RDONLY,
1063+ /* Hard readonly mode only if: bdev_read_only, SB_RDONLY,
10641064 * heartbeat=none */
10651065 if (bdev_read_only(sb->s_bdev)) {
10661066 if (!sb_rdonly(sb)) {
@@ -2057,7 +2057,7 @@ static int ocfs2_initialize_super(struct super_block *sb, · 990 unmodified lines
20572057 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
20582058 sb->s_xattr = ocfs2_xattr_handlers;
20592059 sb->s_time_gran = 1;
2060− sb->s_flags |= MS_NOATIME;
2060+ sb->s_flags |= SB_NOATIME;
20612061 /* this is needed to support O_LARGEFILE */
20622062 cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits);
20632063 bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits);
@@ -2568,7 +2568,7 @@ static int ocfs2_handle_error(struct super_block *sb) · 504 unmodified lines
25682568 return rv;
25692569
25702570 pr_crit("OCFS2: File system is now read-only.\n");
2571− sb->s_flags |= MS_RDONLY;
2571+ sb->s_flags |= SB_RDONLY;
25722572 ocfs2_set_ro_flag(osb, 0);
25732573 }
25742574
fs/ocfs2/xattr.c+1−1
@@ -901,7 +901,7 @@ static int ocfs2_xattr_list_entry(struct super_block *sb, · 900 unmodified lines
901901
902902 case OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS:
903903 case OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT:
904− if (!(sb->s_flags & MS_POSIXACL))
904+ if (!(sb->s_flags & SB_POSIXACL))
905905 return 0;
906906 break;
907907
fs/openpromfs/inode.c+2−2
@@ -369,7 +369,7 @@ static struct inode *openprom_iget(struct super_block *sb, ino_t ino) · 368 unmodified lines
369369 static int openprom_remount(struct super_block *sb, int *flags, char *data)
370370 {
371371 sync_filesystem(sb);
372− *flags |= MS_NOATIME;
372+ *flags |= SB_NOATIME;
373373 return 0;
374374 }
375375
@@ -386,7 +386,7 @@ static int openprom_fill_super(struct super_block *s, void *data, int silent) · 10 unmodified lines
386386 struct op_inode_info *oi;
387387 int ret;
388388
389− s->s_flags |= MS_NOATIME;
389+ s->s_flags |= SB_NOATIME;
390390 s->s_blocksize = 1024;
391391 s->s_blocksize_bits = 10;
392392 s->s_magic = OPENPROM_SUPER_MAGIC;
fs/orangefs/super.c+4−4
@@ -40,7 +40,7 @@ static int orangefs_show_options(struct seq_file *m, struct dentry *root) · 39 unmodified lines
4040 {
4141 struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(root->d_sb);
4242
43− if (root->d_sb->s_flags & MS_POSIXACL)
43+ if (root->d_sb->s_flags & SB_POSIXACL)
4444 seq_puts(m, ",acl");
4545 if (orangefs_sb->flags & ORANGEFS_OPT_INTR)
4646 seq_puts(m, ",intr");
@@ -60,7 +60,7 @@ static int parse_mount_options(struct super_block *sb, char *options, · 13 unmodified lines
6060 * Force any potential flags that might be set from the mount
6161 * to zero, ie, initialize to unset.
6262 */
63− sb->s_flags &= ~MS_POSIXACL;
63+ sb->s_flags &= ~SB_POSIXACL;
6464 orangefs_sb->flags &= ~ORANGEFS_OPT_INTR;
6565 orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK;
6666
@@ -73,7 +73,7 @@ static int parse_mount_options(struct super_block *sb, char *options, · 6 unmodified lines
7373 token = match_token(p, tokens, args);
7474 switch (token) {
7575 case Opt_acl:
76− sb->s_flags |= MS_POSIXACL;
76+ sb->s_flags |= SB_POSIXACL;
7777 break;
7878 case Opt_intr:
7979 orangefs_sb->flags |= ORANGEFS_OPT_INTR;
@@ -507,7 +507,7 @@ struct dentry *orangefs_mount(struct file_system_type *fst, · 427 unmodified lines
507507
508508 ret = orangefs_fill_sb(sb,
509509 &new_op->downcall.resp.fs_mount, data,
510− flags & MS_SILENT ? 1 : 0);
510+ flags & SB_SILENT ? 1 : 0);
511511
512512 if (ret) {
513513 d = ERR_PTR(ret);
fs/overlayfs/super.c+5−5
@@ -326,7 +326,7 @@ static int ovl_remount(struct super_block *sb, int *flags, char *data) · 325 unmodified lines
326326 {
327327 struct ovl_fs *ofs = sb->s_fs_info;
328328
329− if (!(*flags & MS_RDONLY) && ovl_force_readonly(ofs))
329+ if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs))
330330 return -EROFS;
331331
332332 return 0;
@@ -1190,7 +1190,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent) · 857 unmodified lines
11901190 goto out_err;
11911191
11921192 if (!ofs->workdir)
1193− sb->s_flags |= MS_RDONLY;
1193+ sb->s_flags |= SB_RDONLY;
11941194
11951195 sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth;
11961196 sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran;
@@ -1203,7 +1203,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent) · 6 unmodified lines
12031203
12041204 /* If the upper fs is nonexistent, we mark overlayfs r/o too */
12051205 if (!ofs->upper_mnt)
1206− sb->s_flags |= MS_RDONLY;
1206+ sb->s_flags |= SB_RDONLY;
12071207 else if (ofs->upper_mnt->mnt_sb != ofs->same_sb)
12081208 ofs->same_sb = NULL;
12091209
@@ -1213,7 +1213,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent) · 3 unmodified lines
12131213 goto out_free_oe;
12141214
12151215 if (!ofs->indexdir)
1216− sb->s_flags |= MS_RDONLY;
1216+ sb->s_flags |= SB_RDONLY;
12171217 }
12181218
12191219 /* Show index=off/on in /proc/mounts for any of the reasons above */
@@ -1227,7 +1227,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent) · 7 unmodified lines
12271227 sb->s_op = &ovl_super_operations;
12281228 sb->s_xattr = ovl_xattr_handlers;
12291229 sb->s_fs_info = ofs;
1230− sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK;
1230+ sb->s_flags |= SB_POSIXACL | SB_NOREMOTELOCK;
12311231
12321232 err = -ENOMEM;
12331233 root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));
fs/proc/inode.c+1−1
@@ -483,7 +483,7 @@ int proc_fill_super(struct super_block *s, void *data, int silent) · 482 unmodified lines
483483
484484 /* User space would break if executables or devices appear on proc */
485485 s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;
486− s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
486+ s->s_flags |= SB_NODIRATIME | SB_NOSUID | SB_NOEXEC;
487487 s->s_blocksize = 1024;
488488 s->s_blocksize_bits = 10;
489489 s->s_magic = PROC_SUPER_MAGIC;
fs/proc/root.c+1−1
@@ -91,7 +91,7 @@ static struct dentry *proc_mount(struct file_system_type *fs_type, · 90 unmodified lines
9191 {
9292 struct pid_namespace *ns;
9393
94− if (flags & MS_KERNMOUNT) {
94+ if (flags & SB_KERNMOUNT) {
9595 ns = data;
9696 data = NULL;
9797 } else {
fs/proc_namespace.c+4−4
@@ -45,10 +45,10 @@ struct proc_fs_info { · 44 unmodified lines
4545 static int show_sb_opts(struct seq_file *m, struct super_block *sb)
4646 {
4747 static const struct proc_fs_info fs_info[] = {
48− { MS_SYNCHRONOUS, ",sync" },
49− { MS_DIRSYNC, ",dirsync" },
50− { MS_MANDLOCK, ",mand" },
51− { MS_LAZYTIME, ",lazytime" },
48+ { SB_SYNCHRONOUS, ",sync" },
49+ { SB_DIRSYNC, ",dirsync" },
50+ { SB_MANDLOCK, ",mand" },
51+ { SB_LAZYTIME, ",lazytime" },
5252 { 0, NULL }
5353 };
5454 const struct proc_fs_info *fs_infop;
fs/qnx4/inode.c+2−2
@@ -47,7 +47,7 @@ static int qnx4_remount(struct super_block *sb, int *flags, char *data) · 46 unmodified lines
4747 sync_filesystem(sb);
4848 qs = qnx4_sb(sb);
4949 qs->Version = QNX4_VERSION;
50− *flags |= MS_RDONLY;
50+ *flags |= SB_RDONLY;
5151 return 0;
5252 }
5353
@@ -199,7 +199,7 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent) · 145 unmodified lines
199199
200200 s->s_op = &qnx4_sops;
201201 s->s_magic = QNX4_SUPER_MAGIC;
202− s->s_flags |= MS_RDONLY; /* Yup, read-only yet */
202+ s->s_flags |= SB_RDONLY; /* Yup, read-only yet */
203203
204204 /* Check the superblock signature. Since the qnx4 code is
205205 dangerous, we should leave as quickly as possible
fs/qnx6/inode.c+2−2
@@ -56,7 +56,7 @@ static int qnx6_show_options(struct seq_file *seq, struct dentry *root) · 55 unmodified lines
5656 static int qnx6_remount(struct super_block *sb, int *flags, char *data)
5757 {
5858 sync_filesystem(sb);
59− *flags |= MS_RDONLY;
59+ *flags |= SB_RDONLY;
6060 return 0;
6161 }
6262
@@ -427,7 +427,7 @@ mmi_success: · 364 unmodified lines
427427 }
428428 s->s_op = &qnx6_sops;
429429 s->s_magic = QNX6_SUPER_MAGIC;
430− s->s_flags |= MS_RDONLY; /* Yup, read-only yet */
430+ s->s_flags |= SB_RDONLY; /* Yup, read-only yet */
431431
432432 /* ease the later tree level calculations */
433433 sbi = QNX6_SB(s);
fs/reiserfs/inode.c+1−1
@@ -2106,7 +2106,7 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th, · 2105 unmodified lines
21062106 journal_end(th);
21072107 goto out_inserted_sd;
21082108 }
2109− } else if (inode->i_sb->s_flags & MS_POSIXACL) {
2109+ } else if (inode->i_sb->s_flags & SB_POSIXACL) {
21102110 reiserfs_warning(inode->i_sb, "jdm-13090",
21112111 "ACLs aren't enabled in the fs, "
21122112 "but vfs thinks they are!");
fs/reiserfs/journal.c+3−3
@@ -1960,7 +1960,7 @@ static int do_journal_release(struct reiserfs_transaction_handle *th, · 1959 unmodified lines
19601960 /*
19611961 * Cancel flushing of old commits. Note that neither of these works
19621962 * will be requeued because superblock is being shutdown and doesn't
1963− * have MS_ACTIVE set.
1963+ * have SB_ACTIVE set.
19641964 */
19651965 reiserfs_cancel_old_flush(sb);
19661966 /* wait for all commits to finish */
@@ -4302,7 +4302,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, int flags) · 2335 unmodified lines
43024302 * Avoid queueing work when sb is being shut down. Transaction
43034303 * will be flushed on journal shutdown.
43044304 */
4305− if (sb->s_flags & MS_ACTIVE)
4305+ if (sb->s_flags & SB_ACTIVE)
43064306 queue_delayed_work(REISERFS_SB(sb)->commit_wq,
43074307 &journal->j_work, HZ / 10);
43084308 }
@@ -4393,7 +4393,7 @@ void reiserfs_abort_journal(struct super_block *sb, int errno) · 84 unmodified lines
43934393 if (!journal->j_errno)
43944394 journal->j_errno = errno;
43954395
4396− sb->s_flags |= MS_RDONLY;
4396+ sb->s_flags |= SB_RDONLY;
43974397 set_bit(J_ABORTED, &journal->j_state);
43984398
43994399 #ifdef CONFIG_REISERFS_CHECK
fs/reiserfs/prints.c+2−2
@@ -390,7 +390,7 @@ void __reiserfs_error(struct super_block *sb, const char *id, · 389 unmodified lines
390390 return;
391391
392392 reiserfs_info(sb, "Remounting filesystem read-only\n");
393− sb->s_flags |= MS_RDONLY;
393+ sb->s_flags |= SB_RDONLY;
394394 reiserfs_abort_journal(sb, -EIO);
395395 }
396396
@@ -409,7 +409,7 @@ void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...) · 12 unmodified lines
409409 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
410410 error_buf);
411411
412− sb->s_flags |= MS_RDONLY;
412+ sb->s_flags |= SB_RDONLY;
413413 reiserfs_abort_journal(sb, errno);
414414 }
415415
fs/reiserfs/super.c+9−9
@@ -121,7 +121,7 @@ void reiserfs_schedule_old_flush(struct super_block *s) · 120 unmodified lines
121121 * Avoid scheduling flush when sb is being shut down. It can race
122122 * with journal shutdown and free still queued delayed work.
123123 */
124− if (sb_rdonly(s) || !(s->s_flags & MS_ACTIVE))
124+ if (sb_rdonly(s) || !(s->s_flags & SB_ACTIVE))
125125 return;
126126
127127 spin_lock(&sbi->old_work_lock);
@@ -252,11 +252,11 @@ static int finish_unfinished(struct super_block *s) · 124 unmodified lines
252252
253253 #ifdef CONFIG_QUOTA
254254 /* Needed for iput() to work correctly and not trash data */
255− if (s->s_flags & MS_ACTIVE) {
255+ if (s->s_flags & SB_ACTIVE) {
256256 ms_active_set = 0;
257257 } else {
258258 ms_active_set = 1;
259− s->s_flags |= MS_ACTIVE;
259+ s->s_flags |= SB_ACTIVE;
260260 }
261261 /* Turn on quotas so that they are updated correctly */
262262 for (i = 0; i < REISERFS_MAXQUOTAS; i++) {
@@ -411,7 +411,7 @@ static int finish_unfinished(struct super_block *s) · 148 unmodified lines
411411 reiserfs_write_lock(s);
412412 if (ms_active_set)
413413 /* Restore the flag back */
414− s->s_flags &= ~MS_ACTIVE;
414+ s->s_flags &= ~SB_ACTIVE;
415415 #endif
416416 pathrelse(&path);
417417 if (done)
@@ -1521,7 +1521,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) · 1103 unmodified lines
15211521 goto out_err_unlock;
15221522 }
15231523
1524− if (*mount_flags & MS_RDONLY) {
1524+ if (*mount_flags & SB_RDONLY) {
15251525 reiserfs_write_unlock(s);
15261526 reiserfs_xattr_init(s, *mount_flags);
15271527 /* remount read-only */
@@ -1567,7 +1567,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) · 39 unmodified lines
15671567 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
15681568
15691569 /* now it is safe to call journal_begin */
1570− s->s_flags &= ~MS_RDONLY;
1570+ s->s_flags &= ~SB_RDONLY;
15711571 err = journal_begin(&th, s, 10);
15721572 if (err)
15731573 goto out_err_unlock;
@@ -1575,7 +1575,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) · 1 unmodified line
15751575 /* Mount a partition which is read-only, read-write */
15761576 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
15771577 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1578− s->s_flags &= ~MS_RDONLY;
1578+ s->s_flags &= ~SB_RDONLY;
15791579 set_sb_umount_state(rs, REISERFS_ERROR_FS);
15801580 if (!old_format_only(s))
15811581 set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
@@ -1590,7 +1590,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) · 8 unmodified lines
15901590 goto out_err_unlock;
15911591
15921592 reiserfs_write_unlock(s);
1593− if (!(*mount_flags & MS_RDONLY)) {
1593+ if (!(*mount_flags & SB_RDONLY)) {
15941594 dquot_resume(s, -1);
15951595 reiserfs_write_lock(s);
15961596 finish_unfinished(s);
@@ -2055,7 +2055,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent) · 458 unmodified lines
20552055 if (bdev_read_only(s->s_bdev) && !sb_rdonly(s)) {
20562056 SWARN(silent, s, "clm-7000",
20572057 "Detected readonly device, marking FS readonly");
2058− s->s_flags |= MS_RDONLY;
2058+ s->s_flags |= SB_RDONLY;
20592059 }
20602060 args.objectid = REISERFS_ROOT_OBJECTID;
20612061 args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
fs/reiserfs/xattr.c+5−5
@@ -959,7 +959,7 @@ int reiserfs_lookup_privroot(struct super_block *s) · 958 unmodified lines
959959
960960 /*
961961 * We need to take a copy of the mount flags since things like
962− * MS_RDONLY don't get set until *after* we're called.
962+ * SB_RDONLY don't get set until *after* we're called.
963963 * mount_flags != mount_options
964964 */
965965 int reiserfs_xattr_init(struct super_block *s, int mount_flags)
@@ -971,7 +971,7 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags) · 5 unmodified lines
971971 if (err)
972972 goto error;
973973
974− if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) {
974+ if (d_really_is_negative(privroot) && !(mount_flags & SB_RDONLY)) {
975975 inode_lock(d_inode(s->s_root));
976976 err = create_privroot(REISERFS_SB(s)->priv_root);
977977 inode_unlock(d_inode(s->s_root));
@@ -999,11 +999,11 @@ error: · 21 unmodified lines
999999 clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt);
10001000 }
10011001
1002− /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */
1002+ /* The super_block SB_POSIXACL must mirror the (no)acl mount option. */
10031003 if (reiserfs_posixacl(s))
1004− s->s_flags |= MS_POSIXACL;
1004+ s->s_flags |= SB_POSIXACL;
10051005 else
1006− s->s_flags &= ~MS_POSIXACL;
1006+ s->s_flags &= ~SB_POSIXACL;
10071007
10081008 return err;
10091009 }
fs/romfs/super.c+2−2
@@ -451,7 +451,7 @@ static int romfs_statfs(struct dentry *dentry, struct kstatfs *buf) · 450 unmodified lines
451451 static int romfs_remount(struct super_block *sb, int *flags, char *data)
452452 {
453453 sync_filesystem(sb);
454− *flags |= MS_RDONLY;
454+ *flags |= SB_RDONLY;
455455 return 0;
456456 }
457457
@@ -502,7 +502,7 @@ static int romfs_fill_super(struct super_block *sb, void *data, int silent) · 44 unmodified lines
502502
503503 sb->s_maxbytes = 0xFFFFFFFF;
504504 sb->s_magic = ROMFS_MAGIC;
505− sb->s_flags |= MS_RDONLY | MS_NOATIME;
505+ sb->s_flags |= SB_RDONLY | SB_NOATIME;
506506 sb->s_op = &romfs_super_ops;
507507
508508 #ifdef CONFIG_ROMFS_ON_MTD
fs/squashfs/super.c+2−2
@@ -195,7 +195,7 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent) · 194 unmodified lines
195195 (u64) le64_to_cpu(sblk->id_table_start));
196196
197197 sb->s_maxbytes = MAX_LFS_FILESIZE;
198− sb->s_flags |= MS_RDONLY;
198+ sb->s_flags |= SB_RDONLY;
199199 sb->s_op = &squashfs_super_ops;
200200
201201 err = -ENOMEM;
@@ -373,7 +373,7 @@ static int squashfs_statfs(struct dentry *dentry, struct kstatfs *buf) · 171 unmodified lines
373373 static int squashfs_remount(struct super_block *sb, int *flags, char *data)
374374 {
375375 sync_filesystem(sb);
376− *flags |= MS_RDONLY;
376+ *flags |= SB_RDONLY;
377377 return 0;
378378 }
379379
fs/statfs.c+3−3
@@ -35,11 +35,11 @@ static int flags_by_mnt(int mnt_flags) · 34 unmodified lines
3535 static int flags_by_sb(int s_flags)
3636 {
3737 int flags = 0;
38− if (s_flags & MS_SYNCHRONOUS)
38+ if (s_flags & SB_SYNCHRONOUS)
3939 flags |= ST_SYNCHRONOUS;
40− if (s_flags & MS_MANDLOCK)
40+ if (s_flags & SB_MANDLOCK)
4141 flags |= ST_MANDLOCK;
42− if (s_flags & MS_RDONLY)
42+ if (s_flags & SB_RDONLY)
4343 flags |= ST_RDONLY;
4444 return flags;
4545 }
fs/sysfs/mount.c+1−1
@@ -30,7 +30,7 @@ static struct dentry *sysfs_mount(struct file_system_type *fs_type, · 29 unmodified lines
3030 void *ns;
3131 bool new_sb;
3232
33− if (!(flags & MS_KERNMOUNT)) {
33+ if (!(flags & SB_KERNMOUNT)) {
3434 if (!kobj_ns_current_may_mount(KOBJ_NS_TYPE_NET))
3535 return ERR_PTR(-EPERM);
3636 }
fs/sysv/inode.c+1−1
@@ -63,7 +63,7 @@ static int sysv_remount(struct super_block *sb, int *flags, char *data) · 62 unmodified lines
6363
6464 sync_filesystem(sb);
6565 if (sbi->s_forced_ro)
66− *flags |= MS_RDONLY;
66+ *flags |= SB_RDONLY;
6767 return 0;
6868 }
6969
fs/sysv/super.c+1−1
@@ -333,7 +333,7 @@ static int complete_read_super(struct super_block *sb, int silent, int size) · 332 unmodified lines
333333 /* set up enough so that it can read an inode */
334334 sb->s_op = &sysv_sops;
335335 if (sbi->s_forced_ro)
336− sb->s_flags |= MS_RDONLY;
336+ sb->s_flags |= SB_RDONLY;
337337 if (sbi->s_truncate)
338338 sb->s_d_op = &sysv_dentry_operations;
339339 root_inode = sysv_iget(sb, SYSV_ROOT_INO);
fs/ubifs/file.c+1−1
@@ -1406,7 +1406,7 @@ int ubifs_update_time(struct inode *inode, struct timespec *time, · 1405 unmodified lines
14061406 if (flags & S_MTIME)
14071407 inode->i_mtime = *time;
14081408
1409− if (!(inode->i_sb->s_flags & MS_LAZYTIME))
1409+ if (!(inode->i_sb->s_flags & SB_LAZYTIME))
14101410 iflags |= I_DIRTY_SYNC;
14111411
14121412 release = ui->dirty;
fs/ubifs/io.c+1−1
@@ -84,7 +84,7 @@ void ubifs_ro_mode(struct ubifs_info *c, int err) · 83 unmodified lines
8484 if (!c->ro_error) {
8585 c->ro_error = 1;
8686 c->no_chk_data_crc = 0;
87− c->vfs_sb->s_flags |= MS_RDONLY;
87+ c->vfs_sb->s_flags |= SB_RDONLY;
8888 ubifs_warn(c, "switched to read-only mode, error %d", err);
8989 dump_stack();
9090 }
fs/ubifs/super.c+10−10
@@ -968,7 +968,7 @@ static int parse_standard_option(const char *option) · 967 unmodified lines
968968
969969 pr_notice("UBIFS: parse %s\n", option);
970970 if (!strcmp(option, "sync"))
971− return MS_SYNCHRONOUS;
971+ return SB_SYNCHRONOUS;
972972 return 0;
973973 }
974974
@@ -1160,8 +1160,8 @@ static int mount_ubifs(struct ubifs_info *c) · 185 unmodified lines
11601160 size_t sz;
11611161
11621162 c->ro_mount = !!sb_rdonly(c->vfs_sb);
1163− /* Suppress error messages while probing if MS_SILENT is set */
1164− c->probing = !!(c->vfs_sb->s_flags & MS_SILENT);
1163+ /* Suppress error messages while probing if SB_SILENT is set */
1164+ c->probing = !!(c->vfs_sb->s_flags & SB_SILENT);
11651165
11661166 err = init_constants_early(c);
11671167 if (err)
@@ -1852,7 +1852,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) · 684 unmodified lines
18521852 return err;
18531853 }
18541854
1855− if (c->ro_mount && !(*flags & MS_RDONLY)) {
1855+ if (c->ro_mount && !(*flags & SB_RDONLY)) {
18561856 if (c->ro_error) {
18571857 ubifs_msg(c, "cannot re-mount R/W due to prior errors");
18581858 return -EROFS;
@@ -1864,7 +1864,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
18641864 err = ubifs_remount_rw(c);
18651865 if (err)
18661866 return err;
1867− } else if (!c->ro_mount && (*flags & MS_RDONLY)) {
1867+ } else if (!c->ro_mount && (*flags & SB_RDONLY)) {
18681868 if (c->ro_error) {
18691869 ubifs_msg(c, "cannot re-mount R/O due to prior errors");
18701870 return -EROFS;
@@ -2117,7 +2117,7 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags, · 246 unmodified lines
21172117 */
21182118 ubi = open_ubi(name, UBI_READONLY);
21192119 if (IS_ERR(ubi)) {
2120− if (!(flags & MS_SILENT))
2120+ if (!(flags & SB_SILENT))
21212121 pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d",
21222122 current->pid, name, (int)PTR_ERR(ubi));
21232123 return ERR_CAST(ubi);
@@ -2143,18 +2143,18 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags, · 19 unmodified lines
21432143 kfree(c);
21442144 /* A new mount point for already mounted UBIFS */
21452145 dbg_gen("this ubi volume is already mounted");
2146− if (!!(flags & MS_RDONLY) != c1->ro_mount) {
2146+ if (!!(flags & SB_RDONLY) != c1->ro_mount) {
21472147 err = -EBUSY;
21482148 goto out_deact;
21492149 }
21502150 } else {
2151− err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
2151+ err = ubifs_fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
21522152 if (err)
21532153 goto out_deact;
21542154 /* We do not support atime */
2155− sb->s_flags |= MS_ACTIVE;
2155+ sb->s_flags |= SB_ACTIVE;
21562156 #ifndef CONFIG_UBIFS_ATIME_SUPPORT
2157− sb->s_flags |= MS_NOATIME;
2157+ sb->s_flags |= SB_NOATIME;
21582158 #else
21592159 ubifs_msg(c, "full atime support is enabled.");
21602160 #endif
fs/ubifs/ubifs.h+2−2
@@ -1201,7 +1201,7 @@ struct ubifs_debug_info; · 1200 unmodified lines
12011201 * @need_recovery: %1 if the file-system needs recovery
12021202 * @replaying: %1 during journal replay
12031203 * @mounting: %1 while mounting
1204− * @probing: %1 while attempting to mount if MS_SILENT mount flag is set
1204+ * @probing: %1 while attempting to mount if SB_SILENT mount flag is set
12051205 * @remounting_rw: %1 while re-mounting from R/O mode to R/W mode
12061206 * @replay_list: temporary list used during journal replay
12071207 * @replay_buds: list of buds to replay
@@ -1850,7 +1850,7 @@ __printf(2, 3) · 642 unmodified lines
18501850 void ubifs_warn(const struct ubifs_info *c, const char *fmt, ...);
18511851 /*
18521852 * A conditional variant of 'ubifs_err()' which doesn't output anything
1853− * if probing (ie. MS_SILENT set).
1853+ * if probing (ie. SB_SILENT set).
18541854 */
18551855 #define ubifs_errc(c, fmt, ...) \
18561856 do { \
fs/udf/super.c+3−3
@@ -650,7 +650,7 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options) · 649 unmodified lines
650650 sync_filesystem(sb);
651651 if (lvidiu) {
652652 int write_rev = le16_to_cpu(lvidiu->minUDFWriteRev);
653− if (write_rev > UDF_MAX_WRITE_VERSION && !(*flags & MS_RDONLY))
653+ if (write_rev > UDF_MAX_WRITE_VERSION && !(*flags & SB_RDONLY))
654654 return -EACCES;
655655 }
656656
@@ -673,10 +673,10 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options) · 16 unmodified lines
673673 sbi->s_dmode = uopt.dmode;
674674 write_unlock(&sbi->s_cred_lock);
675675
676− if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))
676+ if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
677677 goto out_unlock;
678678
679− if (*flags & MS_RDONLY)
679+ if (*flags & SB_RDONLY)
680680 udf_close_lvid(sb);
681681 else
682682 udf_open_lvid(sb);
fs/ufs/balloc.c+4−4
@@ -115,7 +115,7 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count) · 114 unmodified lines
115115
116116 ubh_mark_buffer_dirty (USPI_UBH(uspi));
117117 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
118− if (sb->s_flags & MS_SYNCHRONOUS)
118+ if (sb->s_flags & SB_SYNCHRONOUS)
119119 ubh_sync_block(UCPI_UBH(ucpi));
120120 ufs_mark_sb_dirty(sb);
121121
@@ -205,7 +205,7 @@ do_more: · 83 unmodified lines
205205
206206 ubh_mark_buffer_dirty (USPI_UBH(uspi));
207207 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
208− if (sb->s_flags & MS_SYNCHRONOUS)
208+ if (sb->s_flags & SB_SYNCHRONOUS)
209209 ubh_sync_block(UCPI_UBH(ucpi));
210210
211211 if (overflow) {
@@ -567,7 +567,7 @@ static u64 ufs_add_fragments(struct inode *inode, u64 fragment, · 355 unmodified lines
567567
568568 ubh_mark_buffer_dirty (USPI_UBH(uspi));
569569 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
570− if (sb->s_flags & MS_SYNCHRONOUS)
570+ if (sb->s_flags & SB_SYNCHRONOUS)
571571 ubh_sync_block(UCPI_UBH(ucpi));
572572 ufs_mark_sb_dirty(sb);
573573
@@ -688,7 +688,7 @@ cg_found: · 114 unmodified lines
688688 succed:
689689 ubh_mark_buffer_dirty (USPI_UBH(uspi));
690690 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
691− if (sb->s_flags & MS_SYNCHRONOUS)
691+ if (sb->s_flags & SB_SYNCHRONOUS)
692692 ubh_sync_block(UCPI_UBH(ucpi));
693693 ufs_mark_sb_dirty(sb);
694694
fs/ufs/ialloc.c+5−5
@@ -112,7 +112,7 @@ void ufs_free_inode (struct inode * inode) · 111 unmodified lines
112112
113113 ubh_mark_buffer_dirty (USPI_UBH(uspi));
114114 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
115− if (sb->s_flags & MS_SYNCHRONOUS)
115+ if (sb->s_flags & SB_SYNCHRONOUS)
116116 ubh_sync_block(UCPI_UBH(ucpi));
117117
118118 ufs_mark_sb_dirty(sb);
@@ -146,14 +146,14 @@ static void ufs2_init_inodes_chunk(struct super_block *sb, · 27 unmodified lines
146146 set_buffer_uptodate(bh);
147147 mark_buffer_dirty(bh);
148148 unlock_buffer(bh);
149− if (sb->s_flags & MS_SYNCHRONOUS)
149+ if (sb->s_flags & SB_SYNCHRONOUS)
150150 sync_dirty_buffer(bh);
151151 brelse(bh);
152152 }
153153
154154 fs32_add(sb, &ucg->cg_u.cg_u2.cg_initediblk, uspi->s_inopb);
155155 ubh_mark_buffer_dirty(UCPI_UBH(ucpi));
156− if (sb->s_flags & MS_SYNCHRONOUS)
156+ if (sb->s_flags & SB_SYNCHRONOUS)
157157 ubh_sync_block(UCPI_UBH(ucpi));
158158
159159 UFSD("EXIT\n");
@@ -284,7 +284,7 @@ cg_found: · 124 unmodified lines
284284 }
285285 ubh_mark_buffer_dirty (USPI_UBH(uspi));
286286 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
287− if (sb->s_flags & MS_SYNCHRONOUS)
287+ if (sb->s_flags & SB_SYNCHRONOUS)
288288 ubh_sync_block(UCPI_UBH(ucpi));
289289 ufs_mark_sb_dirty(sb);
290290
@@ -330,7 +330,7 @@ cg_found: · 39 unmodified lines
330330 ufs2_inode->ui_birthnsec = cpu_to_fs32(sb, ts.tv_nsec);
331331 mark_buffer_dirty(bh);
332332 unlock_buffer(bh);
333− if (sb->s_flags & MS_SYNCHRONOUS)
333+ if (sb->s_flags & SB_SYNCHRONOUS)
334334 sync_dirty_buffer(bh);
335335 brelse(bh);
336336 }
fs/ufs/super.c+15−15
@@ -282,7 +282,7 @@ void ufs_error (struct super_block * sb, const char * function, · 281 unmodified lines
282282 usb1->fs_clean = UFS_FSBAD;
283283 ubh_mark_buffer_dirty(USPI_UBH(uspi));
284284 ufs_mark_sb_dirty(sb);
285− sb->s_flags |= MS_RDONLY;
285+ sb->s_flags |= SB_RDONLY;
286286 }
287287 va_start(args, fmt);
288288 vaf.fmt = fmt;
@@ -320,7 +320,7 @@ void ufs_panic (struct super_block * sb, const char * function, · 31 unmodified lines
320320 va_start(args, fmt);
321321 vaf.fmt = fmt;
322322 vaf.va = &args;
323− sb->s_flags |= MS_RDONLY;
323+ sb->s_flags |= SB_RDONLY;
324324 pr_crit("panic (device %s): %s: %pV\n",
325325 sb->s_id, function, &vaf);
326326 va_end(args);
@@ -905,7 +905,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 578 unmodified lines
905905 if (!sb_rdonly(sb)) {
906906 if (!silent)
907907 pr_info("ufstype=old is supported read-only\n");
908− sb->s_flags |= MS_RDONLY;
908+ sb->s_flags |= SB_RDONLY;
909909 }
910910 break;
911911
@@ -921,7 +921,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 9 unmodified lines
921921 if (!sb_rdonly(sb)) {
922922 if (!silent)
923923 pr_info("ufstype=nextstep is supported read-only\n");
924− sb->s_flags |= MS_RDONLY;
924+ sb->s_flags |= SB_RDONLY;
925925 }
926926 break;
927927
@@ -937,7 +937,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 9 unmodified lines
937937 if (!sb_rdonly(sb)) {
938938 if (!silent)
939939 pr_info("ufstype=nextstep-cd is supported read-only\n");
940− sb->s_flags |= MS_RDONLY;
940+ sb->s_flags |= SB_RDONLY;
941941 }
942942 break;
943943
@@ -953,7 +953,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 9 unmodified lines
953953 if (!sb_rdonly(sb)) {
954954 if (!silent)
955955 pr_info("ufstype=openstep is supported read-only\n");
956− sb->s_flags |= MS_RDONLY;
956+ sb->s_flags |= SB_RDONLY;
957957 }
958958 break;
959959
@@ -968,7 +968,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 8 unmodified lines
968968 if (!sb_rdonly(sb)) {
969969 if (!silent)
970970 pr_info("ufstype=hp is supported read-only\n");
971− sb->s_flags |= MS_RDONLY;
971+ sb->s_flags |= SB_RDONLY;
972972 }
973973 break;
974974 default:
@@ -1125,21 +1125,21 @@ magic_found: · 150 unmodified lines
11251125 break;
11261126 case UFS_FSACTIVE:
11271127 pr_err("%s(): fs is active\n", __func__);
1128− sb->s_flags |= MS_RDONLY;
1128+ sb->s_flags |= SB_RDONLY;
11291129 break;
11301130 case UFS_FSBAD:
11311131 pr_err("%s(): fs is bad\n", __func__);
1132− sb->s_flags |= MS_RDONLY;
1132+ sb->s_flags |= SB_RDONLY;
11331133 break;
11341134 default:
11351135 pr_err("%s(): can't grok fs_clean 0x%x\n",
11361136 __func__, usb1->fs_clean);
1137− sb->s_flags |= MS_RDONLY;
1137+ sb->s_flags |= SB_RDONLY;
11381138 break;
11391139 }
11401140 } else {
11411141 pr_err("%s(): fs needs fsck\n", __func__);
1142− sb->s_flags |= MS_RDONLY;
1142+ sb->s_flags |= SB_RDONLY;
11431143 }
11441144
11451145 /*
@@ -1328,7 +1328,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) · 182 unmodified lines
13281328 return -EINVAL;
13291329 }
13301330
1331− if ((bool)(*mount_flags & MS_RDONLY) == sb_rdonly(sb)) {
1331+ if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {
13321332 UFS_SB(sb)->s_mount_opt = new_mount_opt;
13331333 mutex_unlock(&UFS_SB(sb)->s_lock);
13341334 return 0;
@@ -1337,7 +1337,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) · 2 unmodified lines
13371337 /*
13381338 * fs was mouted as rw, remounting ro
13391339 */
1340− if (*mount_flags & MS_RDONLY) {
1340+ if (*mount_flags & SB_RDONLY) {
13411341 ufs_put_super_internal(sb);
13421342 usb1->fs_time = cpu_to_fs32(sb, get_seconds());
13431343 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
@@ -1346,7 +1346,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) · 2 unmodified lines
13461346 ufs_set_fs_state(sb, usb1, usb3,
13471347 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
13481348 ubh_mark_buffer_dirty (USPI_UBH(uspi));
1349− sb->s_flags |= MS_RDONLY;
1349+ sb->s_flags |= SB_RDONLY;
13501350 } else {
13511351 /*
13521352 * fs was mounted as ro, remounting rw
@@ -1370,7 +1370,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) · 17 unmodified lines
13701370 mutex_unlock(&UFS_SB(sb)->s_lock);
13711371 return -EPERM;
13721372 }
1373− sb->s_flags &= ~MS_RDONLY;
1373+ sb->s_flags &= ~SB_RDONLY;
13741374 #endif
13751375 }
13761376 UFS_SB(sb)->s_mount_opt = new_mount_opt;
fs/xfs/xfs_log.c+3−3
@@ -781,17 +781,17 @@ xfs_log_mount_finish( · 780 unmodified lines
781781 * something to an unlinked inode, the irele won't cause
782782 * premature truncation and freeing of the inode, which results
783783 * in log recovery failure. We have to evict the unreferenced
784− * lru inodes after clearing MS_ACTIVE because we don't
784+ * lru inodes after clearing SB_ACTIVE because we don't
785785 * otherwise clean up the lru if there's a subsequent failure in
786786 * xfs_mountfs, which leads to us leaking the inodes if nothing
787787 * else (e.g. quotacheck) references the inodes before the
788788 * mount failure occurs.
789789 */
790− mp->m_super->s_flags |= MS_ACTIVE;
790+ mp->m_super->s_flags |= SB_ACTIVE;
791791 error = xlog_recover_finish(mp->m_log);
792792 if (!error)
793793 xfs_log_work_queue(mp);
794− mp->m_super->s_flags &= ~MS_ACTIVE;
794+ mp->m_super->s_flags &= ~SB_ACTIVE;
795795 evict_inodes(mp->m_super);
796796
797797 /*
fs/xfs/xfs_super.c+4−4
@@ -212,9 +212,9 @@ xfs_parseargs( · 211 unmodified lines
212212 */
213213 if (sb_rdonly(sb))
214214 mp->m_flags |= XFS_MOUNT_RDONLY;
215− if (sb->s_flags & MS_DIRSYNC)
215+ if (sb->s_flags & SB_DIRSYNC)
216216 mp->m_flags |= XFS_MOUNT_DIRSYNC;
217− if (sb->s_flags & MS_SYNCHRONOUS)
217+ if (sb->s_flags & SB_SYNCHRONOUS)
218218 mp->m_flags |= XFS_MOUNT_WSYNC;
219219
220220 /*
@@ -1312,7 +1312,7 @@ xfs_fs_remount( · 1091 unmodified lines
13121312 }
13131313
13141314 /* ro -> rw */
1315− if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {
1315+ if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & SB_RDONLY)) {
13161316 if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
13171317 xfs_warn(mp,
13181318 "ro->rw transition prohibited on norecovery mount");
@@ -1368,7 +1368,7 @@ xfs_fs_remount( · 49 unmodified lines
13681368 }
13691369
13701370 /* rw -> ro */
1371− if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {
1371+ if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & SB_RDONLY)) {
13721372 /* Free the per-AG metadata reservation pool. */
13731373 error = xfs_fs_unreserve_ag_blocks(mp);
13741374 if (error) {
fs/xfs/xfs_super.h+1−1
@@ -30,7 +30,7 @@ extern void xfs_qm_exit(void); · 29 unmodified lines
3030
3131 #ifdef CONFIG_XFS_POSIX_ACL
3232 # define XFS_ACL_STRING "ACLs, "
33−# define set_posix_acl_flag(sb) ((sb)->s_flags |= MS_POSIXACL)
33+# define set_posix_acl_flag(sb) ((sb)->s_flags |= SB_POSIXACL)
3434 #else
3535 # define XFS_ACL_STRING
3636 # define set_posix_acl_flag(sb) do { } while (0)
include/linux/fs.h+1−1
@@ -1872,7 +1872,7 @@ struct super_operations { · 1871 unmodified lines
18721872 */
18731873 #define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
18741874
1875−static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & MS_RDONLY; }
1875+static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
18761876 #define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
18771877 #define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \
18781878 ((inode)->i_flags & S_SYNC))
include/uapi/linux/bfs_fs.h+1−1
@@ -76,7 +76,7 @@ struct bfs_super_block { · 75 unmodified lines
7676 #define BFS_FILEBLOCKS(ip) \
7777 ((ip)->i_sblock == 0 ? 0 : (le32_to_cpu((ip)->i_eblock) + 1) - le32_to_cpu((ip)->i_sblock))
7878 #define BFS_UNCLEAN(bfs_sb, sb) \
79− ((le32_to_cpu(bfs_sb->s_from) != -1) && (le32_to_cpu(bfs_sb->s_to) != -1) && !(sb->s_flags & MS_RDONLY))
79+ ((le32_to_cpu(bfs_sb->s_from) != -1) && (le32_to_cpu(bfs_sb->s_to) != -1) && !(sb->s_flags & SB_RDONLY))
8080
8181
8282 #endif /* _LINUX_BFS_FS_H */
ipc/mqueue.c+1−1
@@ -331,7 +331,7 @@ static struct dentry *mqueue_mount(struct file_system_type *fs_type, · 330 unmodified lines
331331 void *data)
332332 {
333333 struct ipc_namespace *ns;
334− if (flags & MS_KERNMOUNT) {
334+ if (flags & SB_KERNMOUNT) {
335335 ns = data;
336336 data = NULL;
337337 } else {
mm/shmem.c+5−5
@@ -3776,7 +3776,7 @@ int shmem_fill_super(struct super_block *sb, void *data, int silent) · 3775 unmodified lines
37763776 * tmpfs instance, limiting inodes to one per page of lowmem;
37773777 * but the internal instance is left unlimited.
37783778 */
3779− if (!(sb->s_flags & MS_KERNMOUNT)) {
3779+ if (!(sb->s_flags & SB_KERNMOUNT)) {
37803780 sbinfo->max_blocks = shmem_default_max_blocks();
37813781 sbinfo->max_inodes = shmem_default_max_inodes();
37823782 if (shmem_parse_options(data, sbinfo, false)) {
@@ -3784,12 +3784,12 @@ int shmem_fill_super(struct super_block *sb, void *data, int silent) · 1 unmodified line
37843784 goto failed;
37853785 }
37863786 } else {
3787− sb->s_flags |= MS_NOUSER;
3787+ sb->s_flags |= SB_NOUSER;
37883788 }
37893789 sb->s_export_op = &shmem_export_ops;
3790− sb->s_flags |= MS_NOSEC;
3790+ sb->s_flags |= SB_NOSEC;
37913791 #else
3792− sb->s_flags |= MS_NOUSER;
3792+ sb->s_flags |= SB_NOUSER;
37933793 #endif
37943794
37953795 spin_lock_init(&sbinfo->stat_lock);
@@ -3809,7 +3809,7 @@ int shmem_fill_super(struct super_block *sb, void *data, int silent) · 13 unmodified lines
38093809 sb->s_xattr = shmem_xattr_handlers;
38103810 #endif
38113811 #ifdef CONFIG_TMPFS_POSIX_ACL
3812− sb->s_flags |= MS_POSIXACL;
3812+ sb->s_flags |= SB_POSIXACL;
38133813 #endif
38143814 uuid_gen(&sb->s_uuid);
38153815
security/apparmor/apparmorfs.c+1−1
@@ -2451,7 +2451,7 @@ static int __init aa_create_aafs(void) · 2450 unmodified lines
24512451 aafs_mnt = kern_mount(&aafs_ops);
24522452 if (IS_ERR(aafs_mnt))
24532453 panic("can't set apparmorfs up\n");
2454− aafs_mnt->mnt_sb->s_flags &= ~MS_NOUSER;
2454+ aafs_mnt->mnt_sb->s_flags &= ~SB_NOUSER;
24552455
24562456 /* Populate fs tree. */
24572457 error = entry_create_dir(&aa_sfs_entry, NULL);
security/apparmor/include/lib.h+1−1
@@ -86,7 +86,7 @@ static inline unsigned int aa_dfa_null_transition(struct aa_dfa *dfa, · 85 unmodified lines
8686
8787 static inline bool path_mediated_fs(struct dentry *dentry)
8888 {
89− return !(dentry->d_sb->s_flags & MS_NOUSER);
89+ return !(dentry->d_sb->s_flags & SB_NOUSER);
9090 }
9191
9292

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t