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
79 pr_debug("MTDSB: New superblock for device %d (\"%s\")\n",79 pr_debug("MTDSB: New superblock for device %d (\"%s\")\n",
80 mtd->index, mtd->name);80 mtd->index, mtd->name);
81 81
82 ret = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);82 ret = fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
83 if (ret < 0) {83 if (ret < 0) {
84 deactivate_locked_super(sb);84 deactivate_locked_super(sb);
85 return ERR_PTR(ret);85 return ERR_PTR(ret);
86 }86 }
87 87
88 /* go */88 /* go */
89 sb->s_flags |= MS_ACTIVE;89 sb->s_flags |= SB_ACTIVE;
90 return dget(sb->s_root);90 return dget(sb->s_root);
91 91
92 /* new mountpoint for an already mounted superblock */92 /* 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
202not_an_MTD_device:202not_an_MTD_device:
203#endif /* CONFIG_BLOCK */203#endif /* CONFIG_BLOCK */
204 204
205 if (!(flags & MS_SILENT))205 if (!(flags & SB_SILENT))
206 printk(KERN_NOTICE206 printk(KERN_NOTICE
207 "MTD: Attempt to mount non-MTD device \"%s\"\n",207 "MTD: Attempt to mount non-MTD device \"%s\"\n",
208 dev_name);208 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
1016 if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))1016 if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1017 return true;1017 return true;
1018 1018
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))
1020 return true;1020 return true;
1021 1021
1022 return false;1022 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
313 }313 }
314 314
315 if (data->ocd_connect_flags & OBD_CONNECT_ACL) {315 if (data->ocd_connect_flags & OBD_CONNECT_ACL) {
316 sb->s_flags |= MS_POSIXACL;316 sb->s_flags |= SB_POSIXACL;
317 sbi->ll_flags |= LL_SBI_ACL;317 sbi->ll_flags |= LL_SBI_ACL;
318 } else {318 } else {
319 LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");319 LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");
320 sb->s_flags &= ~MS_POSIXACL;320 sb->s_flags &= ~SB_POSIXACL;
321 sbi->ll_flags &= ~LL_SBI_ACL;321 sbi->ll_flags &= ~LL_SBI_ACL;
322 }322 }
323 323
@@ -660,7 +660,7 @@ void ll_kill_super(struct super_block *sb) · 336 unmodified lines
660 struct ll_sb_info *sbi;660 struct ll_sb_info *sbi;
661 661
662 /* not init sb ?*/662 /* not init sb ?*/
663 if (!(sb->s_flags & MS_ACTIVE))663 if (!(sb->s_flags & SB_ACTIVE))
664 return;664 return;
665 665
666 sbi = ll_s2sbi(sb);666 sbi = ll_s2sbi(sb);
@@ -2039,8 +2039,8 @@ int ll_remount_fs(struct super_block *sb, int *flags, char *data) · 1372 unmodified lines
2039 int err;2039 int err;
2040 __u32 read_only;2040 __u32 read_only;
2041 2041
2042 if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) {2042 if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
2043 read_only = *flags & MS_RDONLY;2043 read_only = *flags & SB_RDONLY;
2044 err = obd_set_info_async(NULL, sbi->ll_md_exp,2044 err = obd_set_info_async(NULL, sbi->ll_md_exp,
2045 sizeof(KEY_READ_ONLY),2045 sizeof(KEY_READ_ONLY),
2046 KEY_READ_ONLY, sizeof(read_only),2046 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
2053 }2053 }
2054 2054
2055 if (read_only)2055 if (read_only)
2056 sb->s_flags |= MS_RDONLY;2056 sb->s_flags |= SB_RDONLY;
2057 else2057 else
2058 sb->s_flags &= ~MS_RDONLY;2058 sb->s_flags &= ~SB_RDONLY;
2059 2059
2060 if (sbi->ll_flags & LL_SBI_VERBOSE)2060 if (sbi->ll_flags & LL_SBI_VERBOSE)
2061 LCONSOLE_WARN("Remounted %s %s\n", profilenm,2061 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
94 if (v9ses->cache)94 if (v9ses->cache)
95 sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_SIZE;95 sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_SIZE;
96 96
97 sb->s_flags |= MS_ACTIVE | MS_DIRSYNC | MS_NOATIME;97 sb->s_flags |= SB_ACTIVE | SB_DIRSYNC | SB_NOATIME;
98 if (!v9ses->cache)98 if (!v9ses->cache)
99 sb->s_flags |= MS_SYNCHRONOUS;99 sb->s_flags |= SB_SYNCHRONOUS;
100 100
101#ifdef CONFIG_9P_FS_POSIX_ACL101#ifdef CONFIG_9P_FS_POSIX_ACL
102 if ((v9ses->flags & V9FS_ACL_MASK) == V9FS_POSIX_ACL)102 if ((v9ses->flags & V9FS_ACL_MASK) == V9FS_POSIX_ACL)
103 sb->s_flags |= MS_POSIXACL;103 sb->s_flags |= SB_POSIXACL;
104#endif104#endif
105 105
106 return 0;106 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
213static int adfs_remount(struct super_block *sb, int *flags, char *data)213static int adfs_remount(struct super_block *sb, int *flags, char *data)
214{214{
215 sync_filesystem(sb);215 sync_filesystem(sb);
216 *flags |= MS_NODIRATIME;216 *flags |= SB_NODIRATIME;
217 return parse_options(sb, data);217 return parse_options(sb, data);
218}218}
219 219
@@ -372,7 +372,7 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent) · 152 unmodified lines
372 struct inode *root;372 struct inode *root;
373 int ret = -EINVAL;373 int ret = -EINVAL;
374 374
375 sb->s_flags |= MS_NODIRATIME;375 sb->s_flags |= SB_NODIRATIME;
376 376
377 asb = kzalloc(sizeof(*asb), GFP_KERNEL);377 asb = kzalloc(sizeof(*asb), GFP_KERNEL);
378 if (!asb)378 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
453 pr_crit("error (device %s): %s(): %pV\n", sb->s_id, function, &vaf);453 pr_crit("error (device %s): %s(): %pV\n", sb->s_id, function, &vaf);
454 if (!sb_rdonly(sb))454 if (!sb_rdonly(sb))
455 pr_warn("Remounting filesystem read-only\n");455 pr_warn("Remounting filesystem read-only\n");
456 sb->s_flags |= MS_RDONLY;456 sb->s_flags |= SB_RDONLY;
457 va_end(args);457 va_end(args);
458}458}
459 459
fs/affs/bitmap.c+3−3
@@ -250,12 +250,12 @@ int affs_init_bitmap(struct super_block *sb, int *flags) · 249 unmodified lines
250 int i, res = 0;250 int i, res = 0;
251 struct affs_sb_info *sbi = AFFS_SB(sb);251 struct affs_sb_info *sbi = AFFS_SB(sb);
252 252
253 if (*flags & MS_RDONLY)253 if (*flags & SB_RDONLY)
254 return 0;254 return 0;
255 255
256 if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {256 if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {
257 pr_notice("Bitmap invalid - mounting %s read only\n", sb->s_id);257 pr_notice("Bitmap invalid - mounting %s read only\n", sb->s_id);
258 *flags |= MS_RDONLY;258 *flags |= SB_RDONLY;
259 return 0;259 return 0;
260 }260 }
261 261
@@ -288,7 +288,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags) · 26 unmodified lines
288 if (affs_checksum_block(sb, bh)) {288 if (affs_checksum_block(sb, bh)) {
289 pr_warn("Bitmap %u invalid - mounting %s read only.\n",289 pr_warn("Bitmap %u invalid - mounting %s read only.\n",
290 bm->bm_key, sb->s_id);290 bm->bm_key, sb->s_id);
291 *flags |= MS_RDONLY;291 *flags |= SB_RDONLY;
292 goto out;292 goto out;
293 }293 }
294 pr_debug("read bitmap block %d: %d\n", blk, bm->bm_key);294 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
356 356
357 sb->s_magic = AFFS_SUPER_MAGIC;357 sb->s_magic = AFFS_SUPER_MAGIC;
358 sb->s_op = &affs_sops;358 sb->s_op = &affs_sops;
359 sb->s_flags |= MS_NODIRATIME;359 sb->s_flags |= SB_NODIRATIME;
360 360
361 sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);361 sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
362 if (!sbi)362 if (!sbi)
@@ -466,7 +466,7 @@ got_root: · 103 unmodified lines
466 if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS466 if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
467 || chksum == MUFS_DCOFS) && !sb_rdonly(sb)) {467 || chksum == MUFS_DCOFS) && !sb_rdonly(sb)) {
468 pr_notice("Dircache FS - mounting %s read only\n", sb->s_id);468 pr_notice("Dircache FS - mounting %s read only\n", sb->s_id);
469 sb->s_flags |= MS_RDONLY;469 sb->s_flags |= SB_RDONLY;
470 }470 }
471 switch (chksum) {471 switch (chksum) {
472 case MUFS_FS:472 case MUFS_FS:
@@ -488,7 +488,7 @@ got_root: · 15 unmodified lines
488 /* fall thru */488 /* fall thru */
489 case FS_OFS:489 case FS_OFS:
490 affs_set_opt(sbi->s_flags, SF_OFS);490 affs_set_opt(sbi->s_flags, SF_OFS);
491 sb->s_flags |= MS_NOEXEC;491 sb->s_flags |= SB_NOEXEC;
492 break;492 break;
493 case MUFS_DCOFS:493 case MUFS_DCOFS:
494 case MUFS_INTLOFS:494 case MUFS_INTLOFS:
@@ -497,7 +497,7 @@ got_root: · 2 unmodified lines
497 case FS_INTLOFS:497 case FS_INTLOFS:
498 affs_set_opt(sbi->s_flags, SF_INTL);498 affs_set_opt(sbi->s_flags, SF_INTL);
499 affs_set_opt(sbi->s_flags, SF_OFS);499 affs_set_opt(sbi->s_flags, SF_OFS);
500 sb->s_flags |= MS_NOEXEC;500 sb->s_flags |= SB_NOEXEC;
501 break;501 break;
502 default:502 default:
503 pr_err("Unknown filesystem on device %s: %08X\n",503 pr_err("Unknown filesystem on device %s: %08X\n",
@@ -513,7 +513,7 @@ got_root: · 9 unmodified lines
513 sig, sig[3] + '0', blocksize);513 sig, sig[3] + '0', blocksize);
514 }514 }
515 515
516 sb->s_flags |= MS_NODEV | MS_NOSUID;516 sb->s_flags |= SB_NODEV | SB_NOSUID;
517 517
518 sbi->s_data_blksize = sb->s_blocksize;518 sbi->s_data_blksize = sb->s_blocksize;
519 if (affs_test_opt(sbi->s_flags, SF_OFS))519 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
570 pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data);570 pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data);
571 571
572 sync_filesystem(sb);572 sync_filesystem(sb);
573 *flags |= MS_NODIRATIME;573 *flags |= SB_NODIRATIME;
574 574
575 memcpy(volume, sbi->s_volume, 32);575 memcpy(volume, sbi->s_volume, 32);
576 if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block,576 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
596 memcpy(sbi->s_volume, volume, 32);596 memcpy(sbi->s_volume, volume, 32);
597 spin_unlock(&sbi->symlink_lock);597 spin_unlock(&sbi->symlink_lock);
598 598
599 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))599 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
600 return 0;600 return 0;
601 601
602 if (*flags & MS_RDONLY)602 if (*flags & SB_RDONLY)
603 affs_free_bitmap(sb);603 affs_free_bitmap(sb);
604 else604 else
605 res = affs_init_bitmap(sb, flags);605 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
496 if (ret < 0)496 if (ret < 0)
497 goto error_sb;497 goto error_sb;
498 as = NULL;498 as = NULL;
499 sb->s_flags |= MS_ACTIVE;499 sb->s_flags |= SB_ACTIVE;
500 } else {500 } else {
501 _debug("reuse");501 _debug("reuse");
502 ASSERTCMP(sb->s_flags, &, MS_ACTIVE);502 ASSERTCMP(sb->s_flags, &, SB_ACTIVE);
503 afs_destroy_sbi(as);503 afs_destroy_sbi(as);
504 as = NULL;504 as = NULL;
505 }505 }
fs/befs/ChangeLog+1−1
@@ -365,7 +365,7 @@ Version 0.4 (2001-10-28) · 364 unmodified lines
365 (fs/befs/super.c)365 (fs/befs/super.c)
366 366
367* Tell the kernel to only mount befs read-only. 367* 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().
369 Not that it was possible to write before. But now the kernel won't even try.369 Not that it was possible to write before. But now the kernel won't even try.
370 (fs/befs/super.c)370 (fs/befs/super.c)
371 371
fs/befs/linuxvfs.c+2−2
@@ -841,7 +841,7 @@ befs_fill_super(struct super_block *sb, void *data, int silent) · 840 unmodified lines
841 if (!sb_rdonly(sb)) {841 if (!sb_rdonly(sb)) {
842 befs_warning(sb,842 befs_warning(sb,
843 "No write support. Marking filesystem read-only");843 "No write support. Marking filesystem read-only");
844 sb->s_flags |= MS_RDONLY;844 sb->s_flags |= SB_RDONLY;
845 }845 }
846 846
847 /*847 /*
@@ -948,7 +948,7 @@ static int · 100 unmodified lines
948befs_remount(struct super_block *sb, int *flags, char *data)948befs_remount(struct super_block *sb, int *flags, char *data)
949{949{
950 sync_filesystem(sb);950 sync_filesystem(sb);
951 if (!(*flags & MS_RDONLY))951 if (!(*flags & SB_RDONLY))
952 return -EINVAL;952 return -EINVAL;
953 return 0;953 return 0;
954}954}
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
2957 */2957 */
2958static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)2958static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
2959{2959{
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);
2961}2961}
2962 2962
2963static inline void free_fs_info(struct btrfs_fs_info *fs_info)2963static 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
1984 struct btrfs_bio *bbio = NULL;1984 struct btrfs_bio *bbio = NULL;
1985 int ret;1985 int ret;
1986 1986
1987 ASSERT(!(fs_info->sb->s_flags & MS_RDONLY));1987 ASSERT(!(fs_info->sb->s_flags & SB_RDONLY));
1988 BUG_ON(!mirror_num);1988 BUG_ON(!mirror_num);
1989 1989
1990 bio = btrfs_io_bio_alloc(1);1990 bio = btrfs_io_bio_alloc(1);
fs/btrfs/ioctl.c+2−2
@@ -1172,7 +1172,7 @@ again: · 1171 unmodified lines
1172 if (!i_done || ret)1172 if (!i_done || ret)
1173 goto out;1173 goto out;
1174 1174
1175 if (!(inode->i_sb->s_flags & MS_ACTIVE))1175 if (!(inode->i_sb->s_flags & SB_ACTIVE))
1176 goto out;1176 goto out;
1177 1177
1178 /*1178 /*
@@ -1333,7 +1333,7 @@ int btrfs_defrag_file(struct inode *inode, struct file *file, · 154 unmodified lines
1333 * make sure we stop running if someone unmounts1333 * make sure we stop running if someone unmounts
1334 * the FS1334 * the FS
1335 */1335 */
1336 if (!(inode->i_sb->s_flags & MS_ACTIVE))1336 if (!(inode->i_sb->s_flags & SB_ACTIVE))
1337 break;1337 break;
1338 1338
1339 if (btrfs_defrag_cancelled(fs_info)) {1339 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
107 return;107 return;
108 108
109 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {109 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
110 sb->s_flags |= MS_RDONLY;110 sb->s_flags |= SB_RDONLY;
111 btrfs_info(fs_info, "forced readonly");111 btrfs_info(fs_info, "forced readonly");
112 /*112 /*
113 * Note that a running device replace operation is not113 * 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
137 137
138 /*138 /*
139 * Special case: if the error is EROFS, and we're already139 * 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.
141 */141 */
142 if (errno == -EROFS && sb_rdonly(sb))142 if (errno == -EROFS && sb_rdonly(sb))
143 return;143 return;
@@ -168,7 +168,7 @@ void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function · 24 unmodified lines
168 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);168 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
169 169
170 /* Don't go through full error handling during mount */170 /* Don't go through full error handling during mount */
171 if (sb->s_flags & MS_BORN)171 if (sb->s_flags & SB_BORN)
172 btrfs_handle_error(fs_info);172 btrfs_handle_error(fs_info);
173}173}
174 174
@@ -625,7 +625,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options, · 450 unmodified lines
625 break;625 break;
626 case Opt_acl:626 case Opt_acl:
627#ifdef CONFIG_BTRFS_FS_POSIX_ACL627#ifdef CONFIG_BTRFS_FS_POSIX_ACL
628 info->sb->s_flags |= MS_POSIXACL;628 info->sb->s_flags |= SB_POSIXACL;
629 break;629 break;
630#else630#else
631 btrfs_err(info, "support for ACL not compiled in!");631 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
633 goto out;633 goto out;
634#endif634#endif
635 case Opt_noacl:635 case Opt_noacl:
636 info->sb->s_flags &= ~MS_POSIXACL;636 info->sb->s_flags &= ~SB_POSIXACL;
637 break;637 break;
638 case Opt_notreelog:638 case Opt_notreelog:
639 btrfs_set_and_info(info, NOTREELOG,639 btrfs_set_and_info(info, NOTREELOG,
@@ -851,7 +851,7 @@ check: · 211 unmodified lines
851 /*851 /*
852 * Extra check for current option against current flag852 * Extra check for current option against current flag
853 */853 */
854 if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & MS_RDONLY)) {854 if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & SB_RDONLY)) {
855 btrfs_err(info,855 btrfs_err(info,
856 "nologreplay must be used with ro mount option");856 "nologreplay must be used with ro mount option");
857 ret = -EINVAL;857 ret = -EINVAL;
@@ -1147,7 +1147,7 @@ static int btrfs_fill_super(struct super_block *sb, · 289 unmodified lines
1147 sb->s_xattr = btrfs_xattr_handlers;1147 sb->s_xattr = btrfs_xattr_handlers;
1148 sb->s_time_gran = 1;1148 sb->s_time_gran = 1;
1149#ifdef CONFIG_BTRFS_FS_POSIX_ACL1149#ifdef CONFIG_BTRFS_FS_POSIX_ACL
1150 sb->s_flags |= MS_POSIXACL;1150 sb->s_flags |= SB_POSIXACL;
1151#endif1151#endif
1152 sb->s_flags |= SB_I_VERSION;1152 sb->s_flags |= SB_I_VERSION;
1153 sb->s_iflags |= SB_I_CGROUPWB;1153 sb->s_iflags |= SB_I_CGROUPWB;
@@ -1180,7 +1180,7 @@ static int btrfs_fill_super(struct super_block *sb, · 26 unmodified lines
1180 }1180 }
1181 1181
1182 cleancache_init_fs(sb);1182 cleancache_init_fs(sb);
1183 sb->s_flags |= MS_ACTIVE;1183 sb->s_flags |= SB_ACTIVE;
1184 return 0;1184 return 0;
1185 1185
1186fail_close:1186fail_close:
@@ -1277,7 +1277,7 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry) · 90 unmodified lines
1277 seq_puts(seq, ",flushoncommit");1277 seq_puts(seq, ",flushoncommit");
1278 if (btrfs_test_opt(info, DISCARD))1278 if (btrfs_test_opt(info, DISCARD))
1279 seq_puts(seq, ",discard");1279 seq_puts(seq, ",discard");
1280 if (!(info->sb->s_flags & MS_POSIXACL))1280 if (!(info->sb->s_flags & SB_POSIXACL))
1281 seq_puts(seq, ",noacl");1281 seq_puts(seq, ",noacl");
1282 if (btrfs_test_opt(info, SPACE_CACHE))1282 if (btrfs_test_opt(info, SPACE_CACHE))
1283 seq_puts(seq, ",space_cache");1283 seq_puts(seq, ",space_cache");
@@ -1409,11 +1409,11 @@ static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid, · 125 unmodified lines
1409 1409
1410 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name, newargs);1410 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name, newargs);
1411 if (PTR_ERR_OR_ZERO(mnt) == -EBUSY) {1411 if (PTR_ERR_OR_ZERO(mnt) == -EBUSY) {
1412 if (flags & MS_RDONLY) {1412 if (flags & SB_RDONLY) {
1413 mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~MS_RDONLY,1413 mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~SB_RDONLY,
1414 device_name, newargs);1414 device_name, newargs);
1415 } else {1415 } else {
1416 mnt = vfs_kern_mount(&btrfs_fs_type, flags | MS_RDONLY,1416 mnt = vfs_kern_mount(&btrfs_fs_type, flags | SB_RDONLY,
1417 device_name, newargs);1417 device_name, newargs);
1418 if (IS_ERR(mnt)) {1418 if (IS_ERR(mnt)) {
1419 root = ERR_CAST(mnt);1419 root = ERR_CAST(mnt);
@@ -1565,7 +1565,7 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · 145 unmodified lines
1565 u64 subvol_objectid = 0;1565 u64 subvol_objectid = 0;
1566 int error = 0;1566 int error = 0;
1567 1567
1568 if (!(flags & MS_RDONLY))1568 if (!(flags & SB_RDONLY))
1569 mode |= FMODE_WRITE;1569 mode |= FMODE_WRITE;
1570 1570
1571 error = btrfs_parse_early_options(data, mode, fs_type,1571 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
1619 if (error)1619 if (error)
1620 goto error_fs_info;1620 goto error_fs_info;
1621 1621
1622 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {1622 if (!(flags & SB_RDONLY) && fs_devices->rw_devices == 0) {
1623 error = -EACCES;1623 error = -EACCES;
1624 goto error_close_devices;1624 goto error_close_devices;
1625 }1625 }
1626 1626
1627 bdev = fs_devices->latest_bdev;1627 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,
1629 fs_info);1629 fs_info);
1630 if (IS_ERR(s)) {1630 if (IS_ERR(s)) {
1631 error = PTR_ERR(s);1631 error = PTR_ERR(s);
@@ -1635,7 +1635,7 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · 3 unmodified lines
1635 if (s->s_root) {1635 if (s->s_root) {
1636 btrfs_close_devices(fs_devices);1636 btrfs_close_devices(fs_devices);
1637 free_fs_info(fs_info);1637 free_fs_info(fs_info);
1638 if ((flags ^ s->s_flags) & MS_RDONLY)1638 if ((flags ^ s->s_flags) & SB_RDONLY)
1639 error = -EBUSY;1639 error = -EBUSY;
1640 } else {1640 } else {
1641 snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);1641 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
1702{1702{
1703 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&1703 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1704 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||1704 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1705 (flags & MS_RDONLY))) {1705 (flags & SB_RDONLY))) {
1706 /* wait for any defraggers to finish */1706 /* wait for any defraggers to finish */
1707 wait_event(fs_info->transaction_wait,1707 wait_event(fs_info->transaction_wait,
1708 (atomic_read(&fs_info->defrag_running) == 0));1708 (atomic_read(&fs_info->defrag_running) == 0));
1709 if (flags & MS_RDONLY)1709 if (flags & SB_RDONLY)
1710 sync_filesystem(fs_info->sb);1710 sync_filesystem(fs_info->sb);
1711 }1711 }
1712}1712}
@@ -1766,10 +1766,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) · 53 unmodified lines
1766 btrfs_resize_thread_pool(fs_info,1766 btrfs_resize_thread_pool(fs_info,
1767 fs_info->thread_pool_size, old_thread_pool_size);1767 fs_info->thread_pool_size, old_thread_pool_size);
1768 1768
1769 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))1769 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
1770 goto out;1770 goto out;
1771 1771
1772 if (*flags & MS_RDONLY) {1772 if (*flags & SB_RDONLY) {
1773 /*1773 /*
1774 * this also happens on 'umount -rf' or on shutdown, when1774 * this also happens on 'umount -rf' or on shutdown, when
1775 * the filesystem is busy.1775 * the filesystem is busy.
@@ -1781,10 +1781,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
1781 /* avoid complains from lockdep et al. */1781 /* avoid complains from lockdep et al. */
1782 up(&fs_info->uuid_tree_rescan_sem);1782 up(&fs_info->uuid_tree_rescan_sem);
1783 1783
1784 sb->s_flags |= MS_RDONLY;1784 sb->s_flags |= SB_RDONLY;
1785 1785
1786 /*1786 /*
1787 * Setting MS_RDONLY will put the cleaner thread to1787 * Setting SB_RDONLY will put the cleaner thread to
1788 * sleep at the next loop if it's already active.1788 * sleep at the next loop if it's already active.
1789 * If it's already asleep, we'll leave unused block1789 * If it's already asleep, we'll leave unused block
1790 * groups on disk until we're mounted read-write again1790 * 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
1856 goto restore;1856 goto restore;
1857 }1857 }
1858 }1858 }
1859 sb->s_flags &= ~MS_RDONLY;1859 sb->s_flags &= ~SB_RDONLY;
1860 1860
1861 set_bit(BTRFS_FS_OPEN, &fs_info->flags);1861 set_bit(BTRFS_FS_OPEN, &fs_info->flags);
1862 }1862 }
@@ -1866,9 +1866,9 @@ out: · 3 unmodified lines
1866 return 0;1866 return 0;
1867 1867
1868restore:1868restore:
1869 /* We've hit an error - don't reset MS_RDONLY */1869 /* We've hit an error - don't reset SB_RDONLY */
1870 if (sb_rdonly(sb))1870 if (sb_rdonly(sb))
1871 old_flags |= MS_RDONLY;1871 old_flags |= SB_RDONLY;
1872 sb->s_flags = old_flags;1872 sb->s_flags = old_flags;
1873 fs_info->mount_opt = old_opts;1873 fs_info->mount_opt = old_opts;
1874 fs_info->compress_type = old_compress_type;1874 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
2384 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);2384 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
2385 2385
2386 if (seeding_dev) {2386 if (seeding_dev) {
2387 sb->s_flags &= ~MS_RDONLY;2387 sb->s_flags &= ~SB_RDONLY;
2388 ret = btrfs_prepare_sprout(fs_info);2388 ret = btrfs_prepare_sprout(fs_info);
2389 if (ret) {2389 if (ret) {
2390 btrfs_abort_transaction(trans, ret);2390 btrfs_abort_transaction(trans, ret);
@@ -2497,7 +2497,7 @@ error_sysfs: · 106 unmodified lines
2497 btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);2497 btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
2498error_trans:2498error_trans:
2499 if (seeding_dev)2499 if (seeding_dev)
2500 sb->s_flags |= MS_RDONLY;2500 sb->s_flags |= SB_RDONLY;
2501 if (trans)2501 if (trans)
2502 btrfs_end_transaction(trans);2502 btrfs_end_transaction(trans);
2503 rcu_string_free(device->name);2503 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
331 break;331 break;
332#ifdef CONFIG_CEPH_FS_POSIX_ACL332#ifdef CONFIG_CEPH_FS_POSIX_ACL
333 case Opt_acl:333 case Opt_acl:
334 fsopt->sb_flags |= MS_POSIXACL;334 fsopt->sb_flags |= SB_POSIXACL;
335 break;335 break;
336#endif336#endif
337 case Opt_noacl:337 case Opt_noacl:
338 fsopt->sb_flags &= ~MS_POSIXACL;338 fsopt->sb_flags &= ~SB_POSIXACL;
339 break;339 break;
340 default:340 default:
341 BUG_ON(token);341 BUG_ON(token);
@@ -520,7 +520,7 @@ static int ceph_show_options(struct seq_file *m, struct dentry *root) · 178 unmodified lines
520 seq_puts(m, ",nopoolperm");520 seq_puts(m, ",nopoolperm");
521 521
522#ifdef CONFIG_CEPH_FS_POSIX_ACL522#ifdef CONFIG_CEPH_FS_POSIX_ACL
523 if (fsopt->sb_flags & MS_POSIXACL)523 if (fsopt->sb_flags & SB_POSIXACL)
524 seq_puts(m, ",acl");524 seq_puts(m, ",acl");
525 else525 else
526 seq_puts(m, ",noacl");526 seq_puts(m, ",noacl");
@@ -988,7 +988,7 @@ static struct dentry *ceph_mount(struct file_system_type *fs_type, · 461 unmodified lines
988 dout("ceph_mount\n");988 dout("ceph_mount\n");
989 989
990#ifdef CONFIG_CEPH_FS_POSIX_ACL990#ifdef CONFIG_CEPH_FS_POSIX_ACL
991 flags |= MS_POSIXACL;991 flags |= SB_POSIXACL;
992#endif992#endif
993 err = parse_mount_options(&fsopt, &opt, flags, data, dev_name);993 err = parse_mount_options(&fsopt, &opt, flags, data, dev_name);
994 if (err < 0) {994 if (err < 0) {
fs/cifs/cifs_fs_sb.h+1−1
@@ -42,7 +42,7 @@ · 41 unmodified lines
42#define CIFS_MOUNT_MULTIUSER 0x20000 /* multiuser mount */42#define CIFS_MOUNT_MULTIUSER 0x20000 /* multiuser mount */
43#define CIFS_MOUNT_STRICT_IO 0x40000 /* strict cache mode */43#define CIFS_MOUNT_STRICT_IO 0x40000 /* strict cache mode */
44#define CIFS_MOUNT_RWPIDFORWARD 0x80000 /* use pid forwarding for rw */44#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 */
46#define CIFS_MOUNT_CIFS_BACKUPUID 0x200000 /* backup intent bit for a user */46#define CIFS_MOUNT_CIFS_BACKUPUID 0x200000 /* backup intent bit for a user */
47#define CIFS_MOUNT_CIFS_BACKUPGID 0x400000 /* backup intent bit for a group */47#define CIFS_MOUNT_CIFS_BACKUPGID 0x400000 /* backup intent bit for a group */
48#define CIFS_MOUNT_MAP_SFM_CHR 0x800000 /* SFM/MAC mapping for illegal chars */48#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
125 tcon = cifs_sb_master_tcon(cifs_sb);125 tcon = cifs_sb_master_tcon(cifs_sb);
126 126
127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
128 sb->s_flags |= MS_POSIXACL;128 sb->s_flags |= SB_POSIXACL;
129 129
130 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)130 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
131 sb->s_maxbytes = MAX_LFS_FILESIZE;131 sb->s_maxbytes = MAX_LFS_FILESIZE;
@@ -497,7 +497,7 @@ cifs_show_options(struct seq_file *s, struct dentry *root) · 365 unmodified lines
497 seq_puts(s, ",cifsacl");497 seq_puts(s, ",cifsacl");
498 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)498 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
499 seq_puts(s, ",dynperm");499 seq_puts(s, ",dynperm");
500 if (root->d_sb->s_flags & MS_POSIXACL)500 if (root->d_sb->s_flags & SB_POSIXACL)
501 seq_puts(s, ",acl");501 seq_puts(s, ",acl");
502 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)502 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
503 seq_puts(s, ",mfsymlinks");503 seq_puts(s, ",mfsymlinks");
@@ -573,7 +573,7 @@ static int cifs_show_stats(struct seq_file *s, struct dentry *root) · 69 unmodified lines
573static int cifs_remount(struct super_block *sb, int *flags, char *data)573static int cifs_remount(struct super_block *sb, int *flags, char *data)
574{574{
575 sync_filesystem(sb);575 sync_filesystem(sb);
576 *flags |= MS_NODIRATIME;576 *flags |= SB_NODIRATIME;
577 return 0;577 return 0;
578}578}
579 579
@@ -708,7 +708,7 @@ cifs_do_mount(struct file_system_type *fs_type, · 128 unmodified lines
708 708
709 rc = cifs_mount(cifs_sb, volume_info);709 rc = cifs_mount(cifs_sb, volume_info);
710 if (rc) {710 if (rc) {
711 if (!(flags & MS_SILENT))711 if (!(flags & SB_SILENT))
712 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",712 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
713 rc);713 rc);
714 root = ERR_PTR(rc);714 root = ERR_PTR(rc);
@@ -720,7 +720,7 @@ cifs_do_mount(struct file_system_type *fs_type, · 5 unmodified lines
720 mnt_data.flags = flags;720 mnt_data.flags = flags;
721 721
722 /* BB should we make this contingent on mount parm? */722 /* BB should we make this contingent on mount parm? */
723 flags |= MS_NODIRATIME | MS_NOATIME;723 flags |= SB_NODIRATIME | SB_NOATIME;
724 724
725 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);725 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
726 if (IS_ERR(sb)) {726 if (IS_ERR(sb)) {
@@ -739,7 +739,7 @@ cifs_do_mount(struct file_system_type *fs_type, · 12 unmodified lines
739 goto out_super;739 goto out_super;
740 }740 }
741 741
742 sb->s_flags |= MS_ACTIVE;742 sb->s_flags |= SB_ACTIVE;
743 }743 }
744 744
745 root = cifs_get_root(volume_info, sb);745 root = cifs_get_root(volume_info, sb);
fs/cifs/cifsglob.h+2−2
@@ -559,8 +559,8 @@ struct smb_vol { · 558 unmodified lines
559 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \559 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
560 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)560 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
561 561
562#define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \562#define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \
563 MS_NODEV | MS_SYNCHRONOUS)563 SB_NODEV | SB_SYNCHRONOUS)
564 564
565struct cifs_mnt_data {565struct cifs_mnt_data {
566 struct cifs_sb_info *cifs_sb;566 struct cifs_sb_info *cifs_sb;
fs/cifs/inode.c+1−1
@@ -985,7 +985,7 @@ retry_iget5_locked: · 984 unmodified lines
985 }985 }
986 986
987 cifs_fattr_to_inode(inode, fattr);987 cifs_fattr_to_inode(inode, fattr);
988 if (sb->s_flags & MS_NOATIME)988 if (sb->s_flags & SB_NOATIME)
989 inode->i_flags |= S_NOATIME | S_NOCMTIME;989 inode->i_flags |= S_NOATIME | S_NOCMTIME;
990 if (inode->i_state & I_NEW) {990 if (inode->i_state & I_NEW) {
991 inode->i_ino = hash;991 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
117#ifdef CONFIG_CIFS_POSIX117#ifdef CONFIG_CIFS_POSIX
118 if (!value)118 if (!value)
119 goto out;119 goto out;
120 if (sb->s_flags & MS_POSIXACL)120 if (sb->s_flags & SB_POSIXACL)
121 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,121 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
122 value, (const int)size,122 value, (const int)size,
123 ACL_TYPE_ACCESS, cifs_sb->local_nls,123 ACL_TYPE_ACCESS, cifs_sb->local_nls,
@@ -129,7 +129,7 @@ static int cifs_xattr_set(const struct xattr_handler *handler, · 5 unmodified lines
129#ifdef CONFIG_CIFS_POSIX129#ifdef CONFIG_CIFS_POSIX
130 if (!value)130 if (!value)
131 goto out;131 goto out;
132 if (sb->s_flags & MS_POSIXACL)132 if (sb->s_flags & SB_POSIXACL)
133 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,133 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
134 value, (const int)size,134 value, (const int)size,
135 ACL_TYPE_DEFAULT, cifs_sb->local_nls,135 ACL_TYPE_DEFAULT, cifs_sb->local_nls,
@@ -266,7 +266,7 @@ static int cifs_xattr_get(const struct xattr_handler *handler, · 130 unmodified lines
266 266
267 case XATTR_ACL_ACCESS:267 case XATTR_ACL_ACCESS:
268#ifdef CONFIG_CIFS_POSIX268#ifdef CONFIG_CIFS_POSIX
269 if (sb->s_flags & MS_POSIXACL)269 if (sb->s_flags & SB_POSIXACL)
270 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,270 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
271 value, size, ACL_TYPE_ACCESS,271 value, size, ACL_TYPE_ACCESS,
272 cifs_sb->local_nls,272 cifs_sb->local_nls,
@@ -276,7 +276,7 @@ static int cifs_xattr_get(const struct xattr_handler *handler, · 3 unmodified lines
276 276
277 case XATTR_ACL_DEFAULT:277 case XATTR_ACL_DEFAULT:
278#ifdef CONFIG_CIFS_POSIX278#ifdef CONFIG_CIFS_POSIX
279 if (sb->s_flags & MS_POSIXACL)279 if (sb->s_flags & SB_POSIXACL)
280 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,280 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
281 value, size, ACL_TYPE_DEFAULT,281 value, size, ACL_TYPE_DEFAULT,
282 cifs_sb->local_nls,282 cifs_sb->local_nls,
fs/coda/inode.c+2−2
@@ -96,7 +96,7 @@ void coda_destroy_inodecache(void) · 95 unmodified lines
96static int coda_remount(struct super_block *sb, int *flags, char *data)96static int coda_remount(struct super_block *sb, int *flags, char *data)
97{97{
98 sync_filesystem(sb);98 sync_filesystem(sb);
99 *flags |= MS_NOATIME;99 *flags |= SB_NOATIME;
100 return 0;100 return 0;
101}101}
102 102
@@ -188,7 +188,7 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent) · 85 unmodified lines
188 mutex_unlock(&vc->vc_mutex);188 mutex_unlock(&vc->vc_mutex);
189 189
190 sb->s_fs_info = vc;190 sb->s_fs_info = vc;
191 sb->s_flags |= MS_NOATIME;191 sb->s_flags |= SB_NOATIME;
192 sb->s_blocksize = 4096; /* XXXXX what do we put here?? */192 sb->s_blocksize = 4096; /* XXXXX what do we put here?? */
193 sb->s_blocksize_bits = 12;193 sb->s_blocksize_bits = 12;
194 sb->s_magic = CODA_SUPER_MAGIC;194 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
505static int cramfs_remount(struct super_block *sb, int *flags, char *data)505static int cramfs_remount(struct super_block *sb, int *flags, char *data)
506{506{
507 sync_filesystem(sb);507 sync_filesystem(sb);
508 *flags |= MS_RDONLY;508 *flags |= SB_RDONLY;
509 return 0;509 return 0;
510}510}
511 511
@@ -592,7 +592,7 @@ static int cramfs_finalize_super(struct super_block *sb, · 80 unmodified lines
592 struct inode *root;592 struct inode *root;
593 593
594 /* Set it all up.. */594 /* Set it all up.. */
595 sb->s_flags |= MS_RDONLY;595 sb->s_flags |= SB_RDONLY;
596 sb->s_op = &cramfs_ops;596 sb->s_op = &cramfs_ops;
597 root = get_cramfs_inode(sb, cramfs_root, 0);597 root = get_cramfs_inode(sb, cramfs_root, 0);
598 if (IS_ERR(root))598 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
560 * Set the POSIX ACL flag based on whether they're enabled in the lower560 * Set the POSIX ACL flag based on whether they're enabled in the lower
561 * mount.561 * mount.
562 */562 */
563 s->s_flags = flags & ~MS_POSIXACL;563 s->s_flags = flags & ~SB_POSIXACL;
564 s->s_flags |= path.dentry->d_sb->s_flags & MS_POSIXACL;564 s->s_flags |= path.dentry->d_sb->s_flags & SB_POSIXACL;
565 565
566 /**566 /**
567 * Force a read-only eCryptfs mount when:567 * 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
569 * 2) The ecryptfs_encrypted_view mount option is specified569 * 2) The ecryptfs_encrypted_view mount option is specified
570 */570 */
571 if (sb_rdonly(path.dentry->d_sb) || mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)571 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;
573 573
574 s->s_maxbytes = path.dentry->d_sb->s_maxbytes;574 s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
575 s->s_blocksize = path.dentry->d_sb->s_blocksize;575 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
602 ecryptfs_set_dentry_private(s->s_root, root_info);602 ecryptfs_set_dentry_private(s->s_root, root_info);
603 root_info->lower_path = path;603 root_info->lower_path = path;
604 604
605 s->s_flags |= MS_ACTIVE;605 s->s_flags |= SB_ACTIVE;
606 return dget(s->s_root);606 return dget(s->s_root);
607 607
608out_free:608out_free:
fs/efs/super.c+2−2
@@ -116,7 +116,7 @@ static void destroy_inodecache(void) · 115 unmodified lines
116static int efs_remount(struct super_block *sb, int *flags, char *data)116static int efs_remount(struct super_block *sb, int *flags, char *data)
117{117{
118 sync_filesystem(sb);118 sync_filesystem(sb);
119 *flags |= MS_RDONLY;119 *flags |= SB_RDONLY;
120 return 0;120 return 0;
121}121}
122 122
@@ -311,7 +311,7 @@ static int efs_fill_super(struct super_block *s, void *d, int silent) · 188 unmodified lines
311#ifdef DEBUG311#ifdef DEBUG
312 pr_info("forcing read-only mode\n");312 pr_info("forcing read-only mode\n");
313#endif313#endif
314 s->s_flags |= MS_RDONLY;314 s->s_flags |= SB_RDONLY;
315 }315 }
316 s->s_op = &efs_superblock_operations;316 s->s_op = &efs_superblock_operations;
317 s->s_export_op = &efs_export_ops;317 s->s_export_op = &efs_export_ops;
fs/ext2/balloc.c+2−2
@@ -548,7 +548,7 @@ do_more: · 547 unmodified lines
548 }548 }
549 549
550 mark_buffer_dirty(bitmap_bh);550 mark_buffer_dirty(bitmap_bh);
551 if (sb->s_flags & MS_SYNCHRONOUS)551 if (sb->s_flags & SB_SYNCHRONOUS)
552 sync_dirty_buffer(bitmap_bh);552 sync_dirty_buffer(bitmap_bh);
553 553
554 group_adjust_blocks(sb, block_group, desc, bh2, group_freed);554 group_adjust_blocks(sb, block_group, desc, bh2, group_freed);
@@ -1424,7 +1424,7 @@ allocated: · 869 unmodified lines
1424 percpu_counter_sub(&sbi->s_freeblocks_counter, num);1424 percpu_counter_sub(&sbi->s_freeblocks_counter, num);
1425 1425
1426 mark_buffer_dirty(bitmap_bh);1426 mark_buffer_dirty(bitmap_bh);
1427 if (sb->s_flags & MS_SYNCHRONOUS)1427 if (sb->s_flags & SB_SYNCHRONOUS)
1428 sync_dirty_buffer(bitmap_bh);1428 sync_dirty_buffer(bitmap_bh);
1429 1429
1430 *errp = 0;1430 *errp = 0;
fs/ext2/ialloc.c+2−2
@@ -145,7 +145,7 @@ void ext2_free_inode (struct inode * inode) · 144 unmodified lines
145 else145 else
146 ext2_release_inode(sb, block_group, is_directory);146 ext2_release_inode(sb, block_group, is_directory);
147 mark_buffer_dirty(bitmap_bh);147 mark_buffer_dirty(bitmap_bh);
148 if (sb->s_flags & MS_SYNCHRONOUS)148 if (sb->s_flags & SB_SYNCHRONOUS)
149 sync_dirty_buffer(bitmap_bh);149 sync_dirty_buffer(bitmap_bh);
150 150
151 brelse(bitmap_bh);151 brelse(bitmap_bh);
@@ -517,7 +517,7 @@ repeat_in_this_group: · 365 unmodified lines
517 goto fail;517 goto fail;
518got:518got:
519 mark_buffer_dirty(bitmap_bh);519 mark_buffer_dirty(bitmap_bh);
520 if (sb->s_flags & MS_SYNCHRONOUS)520 if (sb->s_flags & SB_SYNCHRONOUS)
521 sync_dirty_buffer(bitmap_bh);521 sync_dirty_buffer(bitmap_bh);
522 brelse(bitmap_bh);522 brelse(bitmap_bh);
523 523
fs/ext2/super.c+10−10
@@ -75,7 +75,7 @@ void ext2_error(struct super_block *sb, const char *function, · 74 unmodified lines
75 if (test_opt(sb, ERRORS_RO)) {75 if (test_opt(sb, ERRORS_RO)) {
76 ext2_msg(sb, KERN_CRIT,76 ext2_msg(sb, KERN_CRIT,
77 "error: remounting filesystem read-only");77 "error: remounting filesystem read-only");
78 sb->s_flags |= MS_RDONLY;78 sb->s_flags |= SB_RDONLY;
79 }79 }
80}80}
81 81
@@ -656,7 +656,7 @@ static int ext2_setup_super (struct super_block * sb, · 574 unmodified lines
656 ext2_msg(sb, KERN_ERR,656 ext2_msg(sb, KERN_ERR,
657 "error: revision level too high, "657 "error: revision level too high, "
658 "forcing read-only mode");658 "forcing read-only mode");
659 res = MS_RDONLY;659 res = SB_RDONLY;
660 }660 }
661 if (read_only)661 if (read_only)
662 return res;662 return res;
@@ -924,9 +924,9 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) · 261 unmodified lines
924 sbi->s_resuid = opts.s_resuid;924 sbi->s_resuid = opts.s_resuid;
925 sbi->s_resgid = opts.s_resgid;925 sbi->s_resgid = opts.s_resgid;
926 926
927 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |927 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
928 ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?928 ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
929 MS_POSIXACL : 0);929 SB_POSIXACL : 0);
930 sb->s_iflags |= SB_I_CGROUPWB;930 sb->s_iflags |= SB_I_CGROUPWB;
931 931
932 if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&932 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
1178 ext2_msg(sb, KERN_WARNING,1178 ext2_msg(sb, KERN_WARNING,
1179 "warning: mounting ext3 filesystem as ext2");1179 "warning: mounting ext3 filesystem as ext2");
1180 if (ext2_setup_super (sb, es, sb_rdonly(sb)))1180 if (ext2_setup_super (sb, es, sb_rdonly(sb)))
1181 sb->s_flags |= MS_RDONLY;1181 sb->s_flags |= SB_RDONLY;
1182 ext2_write_super(sb);1182 ext2_write_super(sb);
1183 return 0;1183 return 0;
1184 1184
@@ -1341,9 +1341,9 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) · 156 unmodified lines
1341 "dax flag with busy inodes while remounting");1341 "dax flag with busy inodes while remounting");
1342 new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;1342 new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;
1343 }1343 }
1344 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))1344 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
1345 goto out_set;1345 goto out_set;
1346 if (*flags & MS_RDONLY) {1346 if (*flags & SB_RDONLY) {
1347 if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||1347 if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
1348 !(sbi->s_mount_state & EXT2_VALID_FS))1348 !(sbi->s_mount_state & EXT2_VALID_FS))
1349 goto out_set;1349 goto out_set;
@@ -1379,7 +1379,7 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) · 29 unmodified lines
1379 */1379 */
1380 sbi->s_mount_state = le16_to_cpu(es->s_state);1380 sbi->s_mount_state = le16_to_cpu(es->s_state);
1381 if (!ext2_setup_super (sb, es, 0))1381 if (!ext2_setup_super (sb, es, 0))
1382 sb->s_flags &= ~MS_RDONLY;1382 sb->s_flags &= ~SB_RDONLY;
1383 spin_unlock(&sbi->s_lock);1383 spin_unlock(&sbi->s_lock);
1384 1384
1385 ext2_write_super(sb);1385 ext2_write_super(sb);
@@ -1392,8 +1392,8 @@ out_set: · 6 unmodified lines
1392 sbi->s_mount_opt = new_opts.s_mount_opt;1392 sbi->s_mount_opt = new_opts.s_mount_opt;
1393 sbi->s_resuid = new_opts.s_resuid;1393 sbi->s_resuid = new_opts.s_resuid;
1394 sbi->s_resgid = new_opts.s_resgid;1394 sbi->s_resgid = new_opts.s_resgid;
1395 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |1395 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
1396 ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);1396 ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? SB_POSIXACL : 0);
1397 spin_unlock(&sbi->s_lock);1397 spin_unlock(&sbi->s_lock);
1398 1398
1399 return 0;1399 return 0;
fs/ext4/inode.c+2−2
@@ -2742,7 +2742,7 @@ static int ext4_writepages(struct address_space *mapping, · 2741 unmodified lines
2742 * If the filesystem has aborted, it is read-only, so return2742 * If the filesystem has aborted, it is read-only, so return
2743 * right away instead of dumping stack traces later on that2743 * right away instead of dumping stack traces later on that
2744 * will obscure the real source of the problem. We test2744 * will obscure the real source of the problem. We test
2745 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because2745 * EXT4_MF_FS_ABORTED instead of sb->s_flag's SB_RDONLY because
2746 * the latter could be true if the filesystem is mounted2746 * the latter could be true if the filesystem is mounted
2747 * read-only, and in that case, ext4_writepages should2747 * read-only, and in that case, ext4_writepages should
2748 * *never* be called, so if that ever happens, we would want2748 * *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
5183 5183
5184 ext4_inode_csum_set(inode, raw_inode, ei);5184 ext4_inode_csum_set(inode, raw_inode, ei);
5185 spin_unlock(&ei->i_raw_lock);5185 spin_unlock(&ei->i_raw_lock);
5186 if (inode->i_sb->s_flags & MS_LAZYTIME)5186 if (inode->i_sb->s_flags & SB_LAZYTIME)
5187 ext4_update_other_inodes_time(inode->i_sb, inode->i_ino,5187 ext4_update_other_inodes_time(inode->i_sb, inode->i_ino,
5188 bh->b_data);5188 bh->b_data);
5189 5189
fs/ext4/super.c+26−26
@@ -422,7 +422,7 @@ static void ext4_handle_error(struct super_block *sb) · 421 unmodified lines
422 * before ->s_flags update422 * before ->s_flags update
423 */423 */
424 smp_wmb();424 smp_wmb();
425 sb->s_flags |= MS_RDONLY;425 sb->s_flags |= SB_RDONLY;
426 }426 }
427 if (test_opt(sb, ERRORS_PANIC)) {427 if (test_opt(sb, ERRORS_PANIC)) {
428 if (EXT4_SB(sb)->s_journal &&428 if (EXT4_SB(sb)->s_journal &&
@@ -635,7 +635,7 @@ void __ext4_abort(struct super_block *sb, const char *function, · 206 unmodified lines
635 * before ->s_flags update635 * before ->s_flags update
636 */636 */
637 smp_wmb();637 smp_wmb();
638 sb->s_flags |= MS_RDONLY;638 sb->s_flags |= SB_RDONLY;
639 if (EXT4_SB(sb)->s_journal)639 if (EXT4_SB(sb)->s_journal)
640 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);640 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
641 save_error_info(sb, function, line);641 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
1682 sb->s_flags |= SB_I_VERSION;1682 sb->s_flags |= SB_I_VERSION;
1683 return 1;1683 return 1;
1684 case Opt_lazytime:1684 case Opt_lazytime:
1685 sb->s_flags |= MS_LAZYTIME;1685 sb->s_flags |= SB_LAZYTIME;
1686 return 1;1686 return 1;
1687 case Opt_nolazytime:1687 case Opt_nolazytime:
1688 sb->s_flags &= ~MS_LAZYTIME;1688 sb->s_flags &= ~SB_LAZYTIME;
1689 return 1;1689 return 1;
1690 }1690 }
1691 1691
@@ -2116,7 +2116,7 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es, · 424 unmodified lines
2116 if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {2116 if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
2117 ext4_msg(sb, KERN_ERR, "revision level too high, "2117 ext4_msg(sb, KERN_ERR, "revision level too high, "
2118 "forcing read-only mode");2118 "forcing read-only mode");
2119 res = MS_RDONLY;2119 res = SB_RDONLY;
2120 }2120 }
2121 if (read_only)2121 if (read_only)
2122 goto done;2122 goto done;
@@ -2429,7 +2429,7 @@ static void ext4_orphan_cleanup(struct super_block *sb, · 306 unmodified lines
2429 2429
2430 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {2430 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
2431 /* don't clear list on RO mount w/ errors */2431 /* 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)) {
2433 ext4_msg(sb, KERN_INFO, "Errors on filesystem, "2433 ext4_msg(sb, KERN_INFO, "Errors on filesystem, "
2434 "clearing orphan list.\n");2434 "clearing orphan list.\n");
2435 es->s_last_orphan = 0;2435 es->s_last_orphan = 0;
@@ -2438,19 +2438,19 @@ static void ext4_orphan_cleanup(struct super_block *sb, · 2 unmodified lines
2438 return;2438 return;
2439 }2439 }
2440 2440
2441 if (s_flags & MS_RDONLY) {2441 if (s_flags & SB_RDONLY) {
2442 ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");2442 ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
2443 sb->s_flags &= ~MS_RDONLY;2443 sb->s_flags &= ~SB_RDONLY;
2444 }2444 }
2445#ifdef CONFIG_QUOTA2445#ifdef CONFIG_QUOTA
2446 /* Needed for iput() to work correctly and not trash data */2446 /* Needed for iput() to work correctly and not trash data */
2447 sb->s_flags |= MS_ACTIVE;2447 sb->s_flags |= SB_ACTIVE;
2448 2448
2449 /*2449 /*
2450 * Turn on quotas which were not enabled for read-only mounts if2450 * Turn on quotas which were not enabled for read-only mounts if
2451 * filesystem has quota feature, so that they are updated correctly.2451 * filesystem has quota feature, so that they are updated correctly.
2452 */2452 */
2453 if (ext4_has_feature_quota(sb) && (s_flags & MS_RDONLY)) {2453 if (ext4_has_feature_quota(sb) && (s_flags & SB_RDONLY)) {
2454 int ret = ext4_enable_quotas(sb);2454 int ret = ext4_enable_quotas(sb);
2455 2455
2456 if (!ret)2456 if (!ret)
@@ -2539,7 +2539,7 @@ static void ext4_orphan_cleanup(struct super_block *sb, · 82 unmodified lines
2539 }2539 }
2540 }2540 }
2541#endif2541#endif
2542 sb->s_flags = s_flags; /* Restore MS_RDONLY status */2542 sb->s_flags = s_flags; /* Restore SB_RDONLY status */
2543}2543}
2544 2544
2545/*2545/*
@@ -2741,7 +2741,7 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly) · 195 unmodified lines
2741 2741
2742 if (ext4_has_feature_readonly(sb)) {2742 if (ext4_has_feature_readonly(sb)) {
2743 ext4_msg(sb, KERN_INFO, "filesystem is read-only");2743 ext4_msg(sb, KERN_INFO, "filesystem is read-only");
2744 sb->s_flags |= MS_RDONLY;2744 sb->s_flags |= SB_RDONLY;
2745 return 1;2745 return 1;
2746 }2746 }
2747 2747
@@ -3623,8 +3623,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) · 875 unmodified lines
3623 sb->s_iflags |= SB_I_CGROUPWB;3623 sb->s_iflags |= SB_I_CGROUPWB;
3624 }3624 }
3625 3625
3626 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |3626 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
3627 (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);3627 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
3628 3628
3629 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&3629 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
3630 (ext4_has_compat_features(sb) ||3630 (ext4_has_compat_features(sb) ||
@@ -4199,7 +4199,7 @@ no_journal: · 568 unmodified lines
4199 }4199 }
4200 4200
4201 if (ext4_setup_super(sb, es, sb_rdonly(sb)))4201 if (ext4_setup_super(sb, es, sb_rdonly(sb)))
4202 sb->s_flags |= MS_RDONLY;4202 sb->s_flags |= SB_RDONLY;
4203 4203
4204 /* determine the minimum size of new large inodes, if present */4204 /* determine the minimum size of new large inodes, if present */
4205 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE &&4205 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
4693 * the clock is set in the future, and this will cause e2fsck4693 * the clock is set in the future, and this will cause e2fsck
4694 * to complain and force a full file system check.4694 * to complain and force a full file system check.
4695 */4695 */
4696 if (!(sb->s_flags & MS_RDONLY))4696 if (!(sb->s_flags & SB_RDONLY))
4697 es->s_wtime = cpu_to_le32(get_seconds());4697 es->s_wtime = cpu_to_le32(get_seconds());
4698 if (sb->s_bdev->bd_part)4698 if (sb->s_bdev->bd_part)
4699 es->s_kbytes_written =4699 es->s_kbytes_written =
@@ -5047,8 +5047,8 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 347 unmodified lines
5047 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)5047 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)
5048 ext4_abort(sb, "Abort forced by user");5048 ext4_abort(sb, "Abort forced by user");
5049 5049
5050 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |5050 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
5051 (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);5051 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
5052 5052
5053 es = sbi->s_es;5053 es = sbi->s_es;
5054 5054
@@ -5057,16 +5057,16 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 2 unmodified lines
5057 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);5057 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
5058 }5058 }
5059 5059
5060 if (*flags & MS_LAZYTIME)5060 if (*flags & SB_LAZYTIME)
5061 sb->s_flags |= MS_LAZYTIME;5061 sb->s_flags |= SB_LAZYTIME;
5062 5062
5063 if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) {5063 if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
5064 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {5064 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {
5065 err = -EROFS;5065 err = -EROFS;
5066 goto restore_opts;5066 goto restore_opts;
5067 }5067 }
5068 5068
5069 if (*flags & MS_RDONLY) {5069 if (*flags & SB_RDONLY) {
5070 err = sync_filesystem(sb);5070 err = sync_filesystem(sb);
5071 if (err < 0)5071 if (err < 0)
5072 goto restore_opts;5072 goto restore_opts;
@@ -5078,7 +5078,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
5078 * First of all, the unconditional stuff we have to do5078 * First of all, the unconditional stuff we have to do
5079 * to disable replay of the journal when we next remount5079 * to disable replay of the journal when we next remount
5080 */5080 */
5081 sb->s_flags |= MS_RDONLY;5081 sb->s_flags |= SB_RDONLY;
5082 5082
5083 /*5083 /*
5084 * OK, test if we are remounting a valid rw partition5084 * 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
5140 ext4_clear_journal_err(sb, es);5140 ext4_clear_journal_err(sb, es);
5141 sbi->s_mount_state = le16_to_cpu(es->s_state);5141 sbi->s_mount_state = le16_to_cpu(es->s_state);
5142 if (!ext4_setup_super(sb, es, 0))5142 if (!ext4_setup_super(sb, es, 0))
5143 sb->s_flags &= ~MS_RDONLY;5143 sb->s_flags &= ~SB_RDONLY;
5144 if (ext4_has_feature_mmp(sb))5144 if (ext4_has_feature_mmp(sb))
5145 if (ext4_multi_mount_protect(sb,5145 if (ext4_multi_mount_protect(sb,
5146 le64_to_cpu(es->s_mmp_block))) {5146 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
5164 }5164 }
5165 5165
5166 ext4_setup_system_zone(sb);5166 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))
5168 ext4_commit_super(sb, 1);5168 ext4_commit_super(sb, 1);
5169 5169
5170#ifdef CONFIG_QUOTA5170#ifdef CONFIG_QUOTA
@@ -5182,7 +5182,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) · 11 unmodified lines
5182 }5182 }
5183#endif5183#endif
5184 5184
5185 *flags = (*flags & ~MS_LAZYTIME) | (sb->s_flags & MS_LAZYTIME);5185 *flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
5186 ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data);5186 ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data);
5187 kfree(orig_data);5187 kfree(orig_data);
5188 return 0;5188 return 0;
fs/f2fs/checkpoint.c+5−5
@@ -617,17 +617,17 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi) · 616 unmodified lines
617 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))617 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
618 return 0;618 return 0;
619 619
620 if (s_flags & MS_RDONLY) {620 if (s_flags & SB_RDONLY) {
621 f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");621 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;
623 }623 }
624 624
625#ifdef CONFIG_QUOTA625#ifdef CONFIG_QUOTA
626 /* Needed for iput() to work correctly and not trash data */626 /* Needed for iput() to work correctly and not trash data */
627 sbi->sb->s_flags |= MS_ACTIVE;627 sbi->sb->s_flags |= SB_ACTIVE;
628 628
629 /* Turn on quotas so that they are updated correctly */629 /* 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);
631#endif631#endif
632 632
633 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);633 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
@@ -658,7 +658,7 @@ out: · 24 unmodified lines
658 if (quota_enabled)658 if (quota_enabled)
659 f2fs_quota_off_umount(sbi->sb);659 f2fs_quota_off_umount(sbi->sb);
660#endif660#endif
661 sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */661 sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
662 662
663 return err;663 return err;
664}664}
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
2378 2378
2379static inline int f2fs_readonly(struct super_block *sb)2379static inline int f2fs_readonly(struct super_block *sb)
2380{2380{
2381 return sb->s_flags & MS_RDONLY;2381 return sb->s_flags & SB_RDONLY;
2382}2382}
2383 2383
2384static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)2384static 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
1005 1005
1006 cpc.reason = __get_cp_reason(sbi);1006 cpc.reason = __get_cp_reason(sbi);
1007gc_more:1007gc_more:
1008 if (unlikely(!(sbi->sb->s_flags & MS_ACTIVE))) {1008 if (unlikely(!(sbi->sb->s_flags & SB_ACTIVE))) {
1009 ret = -EINVAL;1009 ret = -EINVAL;
1010 goto stop;1010 goto stop;
1011 }1011 }
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
598 int quota_enabled;598 int quota_enabled;
599#endif599#endif
600 600
601 if (s_flags & MS_RDONLY) {601 if (s_flags & SB_RDONLY) {
602 f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");602 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;
604 }604 }
605 605
606#ifdef CONFIG_QUOTA606#ifdef CONFIG_QUOTA
607 /* Needed for iput() to work correctly and not trash data */607 /* Needed for iput() to work correctly and not trash data */
608 sbi->sb->s_flags |= MS_ACTIVE;608 sbi->sb->s_flags |= SB_ACTIVE;
609 /* Turn on quotas so that they are updated correctly */609 /* 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);
611#endif611#endif
612 612
613 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",613 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
@@ -671,7 +671,7 @@ out: · 57 unmodified lines
671 if (quota_enabled)671 if (quota_enabled)
672 f2fs_quota_off_umount(sbi->sb);672 f2fs_quota_off_umount(sbi->sb);
673#endif673#endif
674 sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */674 sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
675 675
676 return ret ? ret: err;676 return ret ? ret: err;
677}677}
fs/f2fs/super.c+14−14
@@ -534,10 +534,10 @@ static int parse_options(struct super_block *sb, char *options) · 533 unmodified lines
534#endif534#endif
535 break;535 break;
536 case Opt_lazytime:536 case Opt_lazytime:
537 sb->s_flags |= MS_LAZYTIME;537 sb->s_flags |= SB_LAZYTIME;
538 break;538 break;
539 case Opt_nolazytime:539 case Opt_nolazytime:
540 sb->s_flags &= ~MS_LAZYTIME;540 sb->s_flags &= ~SB_LAZYTIME;
541 break;541 break;
542#ifdef CONFIG_QUOTA542#ifdef CONFIG_QUOTA
543 case Opt_quota:543 case Opt_quota:
@@ -1168,7 +1168,7 @@ static void default_options(struct f2fs_sb_info *sbi) · 624 unmodified lines
1168 set_opt(sbi, INLINE_DENTRY);1168 set_opt(sbi, INLINE_DENTRY);
1169 set_opt(sbi, EXTENT_CACHE);1169 set_opt(sbi, EXTENT_CACHE);
1170 set_opt(sbi, NOHEAP);1170 set_opt(sbi, NOHEAP);
1171 sbi->sb->s_flags |= MS_LAZYTIME;1171 sbi->sb->s_flags |= SB_LAZYTIME;
1172 set_opt(sbi, FLUSH_MERGE);1172 set_opt(sbi, FLUSH_MERGE);
1173 if (f2fs_sb_mounted_blkzoned(sbi->sb)) {1173 if (f2fs_sb_mounted_blkzoned(sbi->sb)) {
1174 set_opt_mode(sbi, F2FS_MOUNT_LFS);1174 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
1236#endif1236#endif
1237 1237
1238 /* recover superblocks we couldn't write due to previous RO mount */1238 /* 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)) {
1240 err = f2fs_commit_super(sbi, false);1240 err = f2fs_commit_super(sbi, false);
1241 f2fs_msg(sb, KERN_INFO,1241 f2fs_msg(sb, KERN_INFO,
1242 "Try to recover all the superblocks, ret: %d", err);1242 "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
1255 * Previous and new state of filesystem is RO,1255 * Previous and new state of filesystem is RO,
1256 * so skip checking GC and FLUSH_MERGE conditions.1256 * so skip checking GC and FLUSH_MERGE conditions.
1257 */1257 */
1258 if (f2fs_readonly(sb) && (*flags & MS_RDONLY))1258 if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
1259 goto skip;1259 goto skip;
1260 1260
1261#ifdef CONFIG_QUOTA1261#ifdef CONFIG_QUOTA
1262 if (!f2fs_readonly(sb) && (*flags & MS_RDONLY)) {1262 if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
1263 err = dquot_suspend(sb, -1);1263 err = dquot_suspend(sb, -1);
1264 if (err < 0)1264 if (err < 0)
1265 goto restore_opts;1265 goto restore_opts;
1266 } else {1266 } else {
1267 /* dquot_resume needs RW */1267 /* dquot_resume needs RW */
1268 sb->s_flags &= ~MS_RDONLY;1268 sb->s_flags &= ~SB_RDONLY;
1269 if (sb_any_quota_suspended(sb)) {1269 if (sb_any_quota_suspended(sb)) {
1270 dquot_resume(sb, -1);1270 dquot_resume(sb, -1);
1271 } else if (f2fs_sb_has_quota_ino(sb)) {1271 } 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
1288 * or if background_gc = off is passed in mount1288 * or if background_gc = off is passed in mount
1289 * option. Also sync the filesystem.1289 * option. Also sync the filesystem.
1290 */1290 */
1291 if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) {1291 if ((*flags & SB_RDONLY) || !test_opt(sbi, BG_GC)) {
1292 if (sbi->gc_thread) {1292 if (sbi->gc_thread) {
1293 stop_gc_thread(sbi);1293 stop_gc_thread(sbi);
1294 need_restart_gc = true;1294 need_restart_gc = true;
@@ -1300,7 +1300,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
1300 need_stop_gc = true;1300 need_stop_gc = true;
1301 }1301 }
1302 1302
1303 if (*flags & MS_RDONLY) {1303 if (*flags & SB_RDONLY) {
1304 writeback_inodes_sb(sb, WB_REASON_SYNC);1304 writeback_inodes_sb(sb, WB_REASON_SYNC);
1305 sync_inodes_sb(sb);1305 sync_inodes_sb(sb);
1306 1306
@@ -1314,7 +1314,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data) · 7 unmodified lines
1314 * We stop issue flush thread if FS is mounted as RO1314 * We stop issue flush thread if FS is mounted as RO
1315 * or if flush_merge is not passed in mount option.1315 * or if flush_merge is not passed in mount option.
1316 */1316 */
1317 if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {1317 if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
1318 clear_opt(sbi, FLUSH_MERGE);1318 clear_opt(sbi, FLUSH_MERGE);
1319 destroy_flush_cmd_control(sbi, false);1319 destroy_flush_cmd_control(sbi, false);
1320 } else {1320 } else {
@@ -1329,8 +1329,8 @@ skip: · 8 unmodified lines
1329 kfree(s_qf_names[i]);1329 kfree(s_qf_names[i]);
1330#endif1330#endif
1331 /* Update the POSIXACL Flag */1331 /* Update the POSIXACL Flag */
1332 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |1332 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
1333 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);1333 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
1334 1334
1335 return 0;1335 return 0;
1336restore_gc:1336restore_gc:
@@ -2472,8 +2472,8 @@ try_onemore: · 1135 unmodified lines
2472 sb->s_export_op = &f2fs_export_ops;2472 sb->s_export_op = &f2fs_export_ops;
2473 sb->s_magic = F2FS_SUPER_MAGIC;2473 sb->s_magic = F2FS_SUPER_MAGIC;
2474 sb->s_time_gran = 1;2474 sb->s_time_gran = 1;
2475 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |2475 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
2476 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);2476 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
2477 memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));2477 memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
2478 2478
2479 /* init f2fs-specific super block info */2479 /* 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
392 memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize);392 memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize);
393 set_buffer_uptodate(c_bh);393 set_buffer_uptodate(c_bh);
394 mark_buffer_dirty_inode(c_bh, sbi->fat_inode);394 mark_buffer_dirty_inode(c_bh, sbi->fat_inode);
395 if (sb->s_flags & MS_SYNCHRONOUS)395 if (sb->s_flags & SB_SYNCHRONOUS)
396 err = sync_dirty_buffer(c_bh);396 err = sync_dirty_buffer(c_bh);
397 brelse(c_bh);397 brelse(c_bh);
398 if (err)398 if (err)
@@ -597,7 +597,7 @@ int fat_free_clusters(struct inode *inode, int cluster) · 198 unmodified lines
597 }597 }
598 598
599 if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {599 if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {
600 if (sb->s_flags & MS_SYNCHRONOUS) {600 if (sb->s_flags & SB_SYNCHRONOUS) {
601 err = fat_sync_bhs(bhs, nr_bhs);601 err = fat_sync_bhs(bhs, nr_bhs);
602 if (err)602 if (err)
603 goto error;603 goto error;
@@ -612,7 +612,7 @@ int fat_free_clusters(struct inode *inode, int cluster) · 8 unmodified lines
612 fat_collect_bhs(bhs, &nr_bhs, &fatent);612 fat_collect_bhs(bhs, &nr_bhs, &fatent);
613 } while (cluster != FAT_ENT_EOF);613 } while (cluster != FAT_ENT_EOF);
614 614
615 if (sb->s_flags & MS_SYNCHRONOUS) {615 if (sb->s_flags & SB_SYNCHRONOUS) {
616 err = fat_sync_bhs(bhs, nr_bhs);616 err = fat_sync_bhs(bhs, nr_bhs);
617 if (err)617 if (err)
618 goto error;618 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
781{781{
782 int new_rdonly;782 int new_rdonly;
783 struct msdos_sb_info *sbi = MSDOS_SB(sb);783 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);
785 785
786 sync_filesystem(sb);786 sync_filesystem(sb);
787 787
788 /* make sure we update state on remount. */788 /* make sure we update state on remount. */
789 new_rdonly = *flags & MS_RDONLY;789 new_rdonly = *flags & SB_RDONLY;
790 if (new_rdonly != sb_rdonly(sb)) {790 if (new_rdonly != sb_rdonly(sb)) {
791 if (new_rdonly)791 if (new_rdonly)
792 fat_set_state(sb, 0, 0);792 fat_set_state(sb, 0, 0);
@@ -1352,7 +1352,7 @@ out: · 559 unmodified lines
1352 if (opts->unicode_xlate)1352 if (opts->unicode_xlate)
1353 opts->utf8 = 0;1353 opts->utf8 = 0;
1354 if (opts->nfs == FAT_NFS_NOSTALE_RO) {1354 if (opts->nfs == FAT_NFS_NOSTALE_RO) {
1355 sb->s_flags |= MS_RDONLY;1355 sb->s_flags |= SB_RDONLY;
1356 sb->s_export_op = &fat_export_ops_nostale;1356 sb->s_export_op = &fat_export_ops_nostale;
1357 }1357 }
1358 1358
@@ -1608,7 +1608,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat, · 249 unmodified lines
1608 return -ENOMEM;1608 return -ENOMEM;
1609 sb->s_fs_info = sbi;1609 sb->s_fs_info = sbi;
1610 1610
1611 sb->s_flags |= MS_NODIRATIME;1611 sb->s_flags |= SB_NODIRATIME;
1612 sb->s_magic = MSDOS_SUPER_MAGIC;1612 sb->s_magic = MSDOS_SUPER_MAGIC;
1613 sb->s_op = &fat_sops;1613 sb->s_op = &fat_sops;
1614 sb->s_export_op = &fat_export_ops;1614 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
33 if (opts->errors == FAT_ERRORS_PANIC)33 if (opts->errors == FAT_ERRORS_PANIC)
34 panic("FAT-fs (%s): fs panic from previous error\n", sb->s_id);34 panic("FAT-fs (%s): fs panic from previous error\n", sb->s_id);
35 else if (opts->errors == FAT_ERRORS_RO && !sb_rdonly(sb)) {35 else if (opts->errors == FAT_ERRORS_RO && !sb_rdonly(sb)) {
36 sb->s_flags |= MS_RDONLY;36 sb->s_flags |= SB_RDONLY;
37 fat_msg(sb, KERN_ERR, "Filesystem has been set read-only");37 fat_msg(sb, KERN_ERR, "Filesystem has been set read-only");
38 }38 }
39}39}
fs/fat/namei_msdos.c+1−1
@@ -646,7 +646,7 @@ static void setup(struct super_block *sb) · 645 unmodified lines
646{646{
647 MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;647 MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;
648 sb->s_d_op = &msdos_dentry_operations;648 sb->s_d_op = &msdos_dentry_operations;
649 sb->s_flags |= MS_NOATIME;649 sb->s_flags |= SB_NOATIME;
650}650}
651 651
652static int msdos_fill_super(struct super_block *sb, void *data, int silent)652static 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
116static int vxfs_remount(struct super_block *sb, int *flags, char *data)116static int vxfs_remount(struct super_block *sb, int *flags, char *data)
117{117{
118 sync_filesystem(sb);118 sync_filesystem(sb);
119 *flags |= MS_RDONLY;119 *flags |= SB_RDONLY;
120 return 0;120 return 0;
121}121}
122 122
@@ -220,7 +220,7 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent) · 97 unmodified lines
220 int ret = -EINVAL;220 int ret = -EINVAL;
221 u32 j;221 u32 j;
222 222
223 sbp->s_flags |= MS_RDONLY;223 sbp->s_flags |= SB_RDONLY;
224 224
225 infp = kzalloc(sizeof(*infp), GFP_KERNEL);225 infp = kzalloc(sizeof(*infp), GFP_KERNEL);
226 if (!infp) {226 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
490 490
491 /* while holding I_WB_SWITCH, no one else can update the association */491 /* while holding I_WB_SWITCH, no one else can update the association */
492 spin_lock(&inode->i_lock);492 spin_lock(&inode->i_lock);
493 if (!(inode->i_sb->s_flags & MS_ACTIVE) ||493 if (!(inode->i_sb->s_flags & SB_ACTIVE) ||
494 inode->i_state & (I_WB_SWITCH | I_FREEING) ||494 inode->i_state & (I_WB_SWITCH | I_FREEING) ||
495 inode_to_wb(inode) == isw->new_wb) {495 inode_to_wb(inode) == isw->new_wb) {
496 spin_unlock(&inode->i_lock);496 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
130{130{
131 truncate_inode_pages_final(&inode->i_data);131 truncate_inode_pages_final(&inode->i_data);
132 clear_inode(inode);132 clear_inode(inode);
133 if (inode->i_sb->s_flags & MS_ACTIVE) {133 if (inode->i_sb->s_flags & SB_ACTIVE) {
134 struct fuse_conn *fc = get_fuse_conn(inode);134 struct fuse_conn *fc = get_fuse_conn(inode);
135 struct fuse_inode *fi = get_fuse_inode(inode);135 struct fuse_inode *fi = get_fuse_inode(inode);
136 fuse_queue_forget(fc, fi->forget, fi->nodeid, fi->nlookup);136 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
141static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)141static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
142{142{
143 sync_filesystem(sb);143 sync_filesystem(sb);
144 if (*flags & MS_MANDLOCK)144 if (*flags & SB_MANDLOCK)
145 return -EINVAL;145 return -EINVAL;
146 146
147 return 0;147 return 0;
@@ -1056,10 +1056,10 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent) · 908 unmodified lines
1056 int is_bdev = sb->s_bdev != NULL;1056 int is_bdev = sb->s_bdev != NULL;
1057 1057
1058 err = -EINVAL;1058 err = -EINVAL;
1059 if (sb->s_flags & MS_MANDLOCK)1059 if (sb->s_flags & SB_MANDLOCK)
1060 goto err;1060 goto err;
1061 1061
1062 sb->s_flags &= ~(MS_NOSEC | SB_I_VERSION);1062 sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION);
1063 1063
1064 if (!parse_fuse_opt(data, &d, is_bdev))1064 if (!parse_fuse_opt(data, &d, is_bdev))
1065 goto err;1065 goto err;
@@ -1109,9 +1109,9 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent) · 43 unmodified lines
1109 goto err_dev_free;1109 goto err_dev_free;
1110 1110
1111 /* Handle umasking inside the fuse code */1111 /* Handle umasking inside the fuse code */
1112 if (sb->s_flags & MS_POSIXACL)1112 if (sb->s_flags & SB_POSIXACL)
1113 fc->dont_mask = 1;1113 fc->dont_mask = 1;
1114 sb->s_flags |= MS_POSIXACL;1114 sb->s_flags |= SB_POSIXACL;
1115 1115
1116 fc->default_permissions = d.default_permissions;1116 fc->default_permissions = d.default_permissions;
1117 fc->allow_other = d.allow_other;1117 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
1065 sdp->sd_args = *args;1065 sdp->sd_args = *args;
1066 1066
1067 if (sdp->sd_args.ar_spectator) {1067 if (sdp->sd_args.ar_spectator) {
1068 sb->s_flags |= MS_RDONLY;1068 sb->s_flags |= SB_RDONLY;
1069 set_bit(SDF_RORECOVERY, &sdp->sd_flags);1069 set_bit(SDF_RORECOVERY, &sdp->sd_flags);
1070 }1070 }
1071 if (sdp->sd_args.ar_posix_acl)1071 if (sdp->sd_args.ar_posix_acl)
1072 sb->s_flags |= MS_POSIXACL;1072 sb->s_flags |= SB_POSIXACL;
1073 if (sdp->sd_args.ar_nobarrier)1073 if (sdp->sd_args.ar_nobarrier)
1074 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);1074 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1075 1075
1076 sb->s_flags |= MS_NOSEC;1076 sb->s_flags |= SB_NOSEC;
1077 sb->s_magic = GFS2_MAGIC;1077 sb->s_magic = GFS2_MAGIC;
1078 sb->s_op = &gfs2_super_ops;1078 sb->s_op = &gfs2_super_ops;
1079 sb->s_d_op = &gfs2_dops;1079 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
1257 struct gfs2_args args;1257 struct gfs2_args args;
1258 struct gfs2_sbd *sdp;1258 struct gfs2_sbd *sdp;
1259 1259
1260 if (!(flags & MS_RDONLY))1260 if (!(flags & SB_RDONLY))
1261 mode |= FMODE_WRITE;1261 mode |= FMODE_WRITE;
1262 1262
1263 bdev = blkdev_get_by_path(dev_name, mode, fs_type);1263 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
1313 1313
1314 if (s->s_root) {1314 if (s->s_root) {
1315 error = -EBUSY;1315 error = -EBUSY;
1316 if ((flags ^ s->s_flags) & MS_RDONLY)1316 if ((flags ^ s->s_flags) & SB_RDONLY)
1317 goto error_super;1317 goto error_super;
1318 } else {1318 } else {
1319 snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);1319 snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
1320 sb_set_blocksize(s, block_size(bdev));1320 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);
1322 if (error)1322 if (error)
1323 goto error_super;1323 goto error_super;
1324 s->s_flags |= MS_ACTIVE;1324 s->s_flags |= SB_ACTIVE;
1325 bdev->bd_super = s;1325 bdev->bd_super = s;
1326 }1326 }
1327 1327
@@ -1365,7 +1365,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type, · 37 unmodified lines
1365 pr_warn("gfs2 mount does not exist\n");1365 pr_warn("gfs2 mount does not exist\n");
1366 return ERR_CAST(s);1366 return ERR_CAST(s);
1367 }1367 }
1368 if ((flags ^ s->s_flags) & MS_RDONLY) {1368 if ((flags ^ s->s_flags) & SB_RDONLY) {
1369 deactivate_locked_super(s);1369 deactivate_locked_super(s);
1370 return ERR_PTR(-EBUSY);1370 return ERR_PTR(-EBUSY);
1371 }1371 }
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
1256 return -EINVAL;1256 return -EINVAL;
1257 1257
1258 if (sdp->sd_args.ar_spectator)1258 if (sdp->sd_args.ar_spectator)
1259 *flags |= MS_RDONLY;1259 *flags |= SB_RDONLY;
1260 1260
1261 if ((sb->s_flags ^ *flags) & MS_RDONLY) {1261 if ((sb->s_flags ^ *flags) & SB_RDONLY) {
1262 if (*flags & MS_RDONLY)1262 if (*flags & SB_RDONLY)
1263 error = gfs2_make_fs_ro(sdp);1263 error = gfs2_make_fs_ro(sdp);
1264 else1264 else
1265 error = gfs2_make_fs_rw(sdp);1265 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
1269 1269
1270 sdp->sd_args = args;1270 sdp->sd_args = args;
1271 if (sdp->sd_args.ar_posix_acl)1271 if (sdp->sd_args.ar_posix_acl)
1272 sb->s_flags |= MS_POSIXACL;1272 sb->s_flags |= SB_POSIXACL;
1273 else1273 else
1274 sb->s_flags &= ~MS_POSIXACL;1274 sb->s_flags &= ~SB_POSIXACL;
1275 if (sdp->sd_args.ar_nobarrier)1275 if (sdp->sd_args.ar_nobarrier)
1276 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);1276 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1277 else1277 else
fs/gfs2/trans.c+1−1
@@ -117,7 +117,7 @@ void gfs2_trans_end(struct gfs2_sbd *sdp) · 116 unmodified lines
117 kfree(tr);117 kfree(tr);
118 up_read(&sdp->sd_log_flush_lock);118 up_read(&sdp->sd_log_flush_lock);
119 119
120 if (sdp->sd_vfs->s_flags & MS_SYNCHRONOUS)120 if (sdp->sd_vfs->s_flags & SB_SYNCHRONOUS)
121 gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);121 gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
122 if (alloced)122 if (alloced)
123 sb_end_intwrite(sdp->sd_vfs);123 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
204 attrib = mdb->drAtrb;204 attrib = mdb->drAtrb;
205 if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {205 if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
206 pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n");206 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;
208 }208 }
209 if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {209 if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
210 pr_warn("filesystem is marked locked, mounting read-only.\n");210 pr_warn("filesystem is marked locked, mounting read-only.\n");
211 sb->s_flags |= MS_RDONLY;211 sb->s_flags |= SB_RDONLY;
212 }212 }
213 if (!sb_rdonly(sb)) {213 if (!sb_rdonly(sb)) {
214 /* Mark the volume uncleanly unmounted in case we crash */214 /* 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
114static int hfs_remount(struct super_block *sb, int *flags, char *data)114static int hfs_remount(struct super_block *sb, int *flags, char *data)
115{115{
116 sync_filesystem(sb);116 sync_filesystem(sb);
117 *flags |= MS_NODIRATIME;117 *flags |= SB_NODIRATIME;
118 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))118 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
119 return 0;119 return 0;
120 if (!(*flags & MS_RDONLY)) {120 if (!(*flags & SB_RDONLY)) {
121 if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {121 if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
122 pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. leaving read-only.\n");122 pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. leaving read-only.\n");
123 sb->s_flags |= MS_RDONLY;123 sb->s_flags |= SB_RDONLY;
124 *flags |= MS_RDONLY;124 *flags |= SB_RDONLY;
125 } else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) {125 } else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) {
126 pr_warn("filesystem is marked locked, leaving read-only.\n");126 pr_warn("filesystem is marked locked, leaving read-only.\n");
127 sb->s_flags |= MS_RDONLY;127 sb->s_flags |= SB_RDONLY;
128 *flags |= MS_RDONLY;128 *flags |= SB_RDONLY;
129 }129 }
130 }130 }
131 return 0;131 return 0;
@@ -407,7 +407,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent) · 275 unmodified lines
407 407
408 sb->s_op = &hfs_super_operations;408 sb->s_op = &hfs_super_operations;
409 sb->s_xattr = hfs_xattr_handlers;409 sb->s_xattr = hfs_xattr_handlers;
410 sb->s_flags |= MS_NODIRATIME;410 sb->s_flags |= SB_NODIRATIME;
411 mutex_init(&sbi->bitmap_lock);411 mutex_init(&sbi->bitmap_lock);
412 412
413 res = hfs_mdb_get(sb);413 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
329static int hfsplus_remount(struct super_block *sb, int *flags, char *data)329static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
330{330{
331 sync_filesystem(sb);331 sync_filesystem(sb);
332 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))332 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
333 return 0;333 return 0;
334 if (!(*flags & MS_RDONLY)) {334 if (!(*flags & SB_RDONLY)) {
335 struct hfsplus_vh *vhdr = HFSPLUS_SB(sb)->s_vhdr;335 struct hfsplus_vh *vhdr = HFSPLUS_SB(sb)->s_vhdr;
336 int force = 0;336 int force = 0;
337 337
@@ -340,20 +340,20 @@ static int hfsplus_remount(struct super_block *sb, int *flags, char *data) · 2 unmodified lines
340 340
341 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {341 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
342 pr_warn("filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. leaving read-only.\n");342 pr_warn("filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. leaving read-only.\n");
343 sb->s_flags |= MS_RDONLY;343 sb->s_flags |= SB_RDONLY;
344 *flags |= MS_RDONLY;344 *flags |= SB_RDONLY;
345 } else if (force) {345 } else if (force) {
346 /* nothing */346 /* nothing */
347 } else if (vhdr->attributes &347 } else if (vhdr->attributes &
348 cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {348 cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
349 pr_warn("filesystem is marked locked, leaving read-only.\n");349 pr_warn("filesystem is marked locked, leaving read-only.\n");
350 sb->s_flags |= MS_RDONLY;350 sb->s_flags |= SB_RDONLY;
351 *flags |= MS_RDONLY;351 *flags |= SB_RDONLY;
352 } else if (vhdr->attributes &352 } else if (vhdr->attributes &
353 cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {353 cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
354 pr_warn("filesystem is marked journaled, leaving read-only.\n");354 pr_warn("filesystem is marked journaled, leaving read-only.\n");
355 sb->s_flags |= MS_RDONLY;355 sb->s_flags |= SB_RDONLY;
356 *flags |= MS_RDONLY;356 *flags |= SB_RDONLY;
357 }357 }
358 }358 }
359 return 0;359 return 0;
@@ -455,16 +455,16 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent) · 95 unmodified lines
455 455
456 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {456 if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
457 pr_warn("Filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. mounting read-only.\n");457 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;
459 } else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) {459 } else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) {
460 /* nothing */460 /* nothing */
461 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {461 } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
462 pr_warn("Filesystem is marked locked, mounting read-only.\n");462 pr_warn("Filesystem is marked locked, mounting read-only.\n");
463 sb->s_flags |= MS_RDONLY;463 sb->s_flags |= SB_RDONLY;
464 } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) &&464 } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) &&
465 !sb_rdonly(sb)) {465 !sb_rdonly(sb)) {
466 pr_warn("write access to a journaled filesystem is not supported, use the force option at your own risk, mounting read-only.\n");466 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;
468 }468 }
469 469
470 err = -EINVAL;470 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
288 goto bail;288 goto bail;
289 }289 }
290 if (((31 + de->namelen + de->down*4 + 3) & ~3) != le16_to_cpu(de->length)) {290 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;
292 hpfs_error(s, "namelen does not match dirent size in dnode %08x, dirent %03x, last %03x", secno, p, pp);292 hpfs_error(s, "namelen does not match dirent size in dnode %08x, dirent %03x, last %03x", secno, p, pp);
293 goto bail;293 goto bail;
294 }294 }
fs/hpfs/super.c+4−4
@@ -78,7 +78,7 @@ void hpfs_error(struct super_block *s, const char *fmt, ...) · 77 unmodified lines
78 else {78 else {
79 pr_cont("; remounting read-only\n");79 pr_cont("; remounting read-only\n");
80 mark_dirty(s, 0);80 mark_dirty(s, 0);
81 s->s_flags |= MS_RDONLY;81 s->s_flags |= SB_RDONLY;
82 }82 }
83 } else if (sb_rdonly(s))83 } else if (sb_rdonly(s))
84 pr_cont("; going on - but anything won't be destroyed because it's read-only\n");84 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
457 457
458 sync_filesystem(s);458 sync_filesystem(s);
459 459
460 *flags |= MS_NOATIME;460 *flags |= SB_NOATIME;
461 461
462 hpfs_lock(s);462 hpfs_lock(s);
463 uid = sbi->sb_uid; gid = sbi->sb_gid;463 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
488 sbi->sb_eas = eas; sbi->sb_chk = chk; sbi->sb_chkdsk = chkdsk;488 sbi->sb_eas = eas; sbi->sb_chk = chk; sbi->sb_chkdsk = chkdsk;
489 sbi->sb_err = errs; sbi->sb_timeshift = timeshift;489 sbi->sb_err = errs; sbi->sb_timeshift = timeshift;
490 490
491 if (!(*flags & MS_RDONLY)) mark_dirty(s, 1);491 if (!(*flags & SB_RDONLY)) mark_dirty(s, 1);
492 492
493 hpfs_unlock(s);493 hpfs_unlock(s);
494 return 0;494 return 0;
@@ -614,7 +614,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent) · 119 unmodified lines
614 goto bail4;614 goto bail4;
615 }615 }
616 616
617 s->s_flags |= MS_NOATIME;617 s->s_flags |= SB_NOATIME;
618 618
619 /* Fill superblock stuff */619 /* Fill superblock stuff */
620 s->s_magic = HPFS_SUPER_MAGIC;620 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
416{416{
417 if (!(inode->i_state & (I_DIRTY_ALL | I_SYNC |417 if (!(inode->i_state & (I_DIRTY_ALL | I_SYNC |
418 I_FREEING | I_WILL_FREE)) &&418 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)
420 inode_lru_list_add(inode);420 inode_lru_list_add(inode);
421}421}
422 422
@@ -595,7 +595,7 @@ static void dispose_list(struct list_head *head) · 172 unmodified lines
595 * @sb: superblock to operate on595 * @sb: superblock to operate on
596 *596 *
597 * Make sure that no inodes with zero refcount are retained. This is597 * 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,
599 * so any inode reaching zero refcount during or after that call will599 * so any inode reaching zero refcount during or after that call will
600 * be immediately evicted.600 * be immediately evicted.
601 */601 */
@@ -1492,7 +1492,7 @@ static void iput_final(struct inode *inode) · 890 unmodified lines
1492 else1492 else
1493 drop = generic_drop_inode(inode);1493 drop = generic_drop_inode(inode);
1494 1494
1495 if (!drop && (sb->s_flags & MS_ACTIVE)) {1495 if (!drop && (sb->s_flags & SB_ACTIVE)) {
1496 inode_add_lru(inode);1496 inode_add_lru(inode);
1497 spin_unlock(&inode->i_lock);1497 spin_unlock(&inode->i_lock);
1498 return;1498 return;
@@ -1644,7 +1644,7 @@ int generic_update_time(struct inode *inode, struct timespec *time, int flags) · 145 unmodified lines
1644 if (flags & S_MTIME)1644 if (flags & S_MTIME)
1645 inode->i_mtime = *time;1645 inode->i_mtime = *time;
1646 1646
1647 if (!(inode->i_sb->s_flags & MS_LAZYTIME) || (flags & S_VERSION))1647 if (!(inode->i_sb->s_flags & SB_LAZYTIME) || (flags & S_VERSION))
1648 iflags |= I_DIRTY_SYNC;1648 iflags |= I_DIRTY_SYNC;
1649 __mark_inode_dirty(inode, iflags);1649 __mark_inode_dirty(inode, iflags);
1650 return 0;1650 return 0;
@@ -1691,7 +1691,7 @@ bool __atime_needs_update(const struct path *path, struct inode *inode, · 40 unmodified lines
1691 1691
1692 if (IS_NOATIME(inode))1692 if (IS_NOATIME(inode))
1693 return false;1693 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))
1695 return false;1695 return false;
1696 1696
1697 if (mnt->mnt_flags & MNT_NOATIME)1697 if (mnt->mnt_flags & MNT_NOATIME)
fs/isofs/inode.c+1−1
@@ -114,7 +114,7 @@ static void destroy_inodecache(void) · 113 unmodified lines
114static int isofs_remount(struct super_block *sb, int *flags, char *data)114static int isofs_remount(struct super_block *sb, int *flags, char *data)
115{115{
116 sync_filesystem(sb);116 sync_filesystem(sb);
117 if (!(*flags & MS_RDONLY))117 if (!(*flags & SB_RDONLY))
118 return -EROFS;118 return -EROFS;
119 return 0;119 return 0;
120}120}
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
409 mutex_unlock(&c->alloc_sem);409 mutex_unlock(&c->alloc_sem);
410 }410 }
411 411
412 if (!(*flags & MS_RDONLY))412 if (!(*flags & SB_RDONLY))
413 jffs2_start_garbage_collect_thread(c);413 jffs2_start_garbage_collect_thread(c);
414 414
415 *flags |= MS_NOATIME;415 *flags |= SB_NOATIME;
416 return 0;416 return 0;
417}417}
418 418
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
59}59}
60 60
61 61
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)
63 63
64#define SECTOR_ADDR(x) ( (((unsigned long)(x) / c->sector_size) * c->sector_size) )64#define SECTOR_ADDR(x) ( (((unsigned long)(x) / c->sector_size) * c->sector_size) )
65#ifndef CONFIG_JFFS2_FS_WRITEBUFFER65#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
301 301
302 sb->s_op = &jffs2_super_operations;302 sb->s_op = &jffs2_super_operations;
303 sb->s_export_op = &jffs2_export_ops;303 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;
305 sb->s_xattr = jffs2_xattr_handlers;305 sb->s_xattr = jffs2_xattr_handlers;
306#ifdef CONFIG_JFFS2_FS_POSIX_ACL306#ifdef CONFIG_JFFS2_FS_POSIX_ACL
307 sb->s_flags |= MS_POSIXACL;307 sb->s_flags |= SB_POSIXACL;
308#endif308#endif
309 ret = jffs2_do_fill_super(sb, data, silent);309 ret = jffs2_do_fill_super(sb, data, silent);
310 return ret;310 return ret;
fs/jfs/super.c+5−5
@@ -87,7 +87,7 @@ static void jfs_handle_error(struct super_block *sb) · 86 unmodified lines
87 else if (sbi->flag & JFS_ERR_REMOUNT_RO) {87 else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
88 jfs_err("ERROR: (device %s): remounting filesystem as read-only",88 jfs_err("ERROR: (device %s): remounting filesystem as read-only",
89 sb->s_id);89 sb->s_id);
90 sb->s_flags |= MS_RDONLY;90 sb->s_flags |= SB_RDONLY;
91 }91 }
92 92
93 /* nothing is done for continue beyond marking the superblock dirty */93 /* 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
477 return rc;477 return rc;
478 }478 }
479 479
480 if (sb_rdonly(sb) && !(*flags & MS_RDONLY)) {480 if (sb_rdonly(sb) && !(*flags & SB_RDONLY)) {
481 /*481 /*
482 * Invalidate any previously read metadata. fsck may have482 * Invalidate any previously read metadata. fsck may have
483 * changed the on-disk data since we mounted r/o483 * 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
488 ret = jfs_mount_rw(sb, 1);488 ret = jfs_mount_rw(sb, 1);
489 489
490 /* mark the fs r/w for quota activity */490 /* mark the fs r/w for quota activity */
491 sb->s_flags &= ~MS_RDONLY;491 sb->s_flags &= ~SB_RDONLY;
492 492
493 dquot_resume(sb, -1);493 dquot_resume(sb, -1);
494 return ret;494 return ret;
495 }495 }
496 if (!sb_rdonly(sb) && (*flags & MS_RDONLY)) {496 if (!sb_rdonly(sb) && (*flags & SB_RDONLY)) {
497 rc = dquot_suspend(sb, -1);497 rc = dquot_suspend(sb, -1);
498 if (rc < 0)498 if (rc < 0)
499 return rc;499 return rc;
@@ -545,7 +545,7 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent) · 45 unmodified lines
545 sbi->flag = flag;545 sbi->flag = flag;
546 546
547#ifdef CONFIG_JFS_POSIX_ACL547#ifdef CONFIG_JFS_POSIX_ACL
548 sb->s_flags |= MS_POSIXACL;548 sb->s_flags |= SB_POSIXACL;
549#endif549#endif
550 550
551 if (newLVSize) {551 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
335 deactivate_locked_super(sb);335 deactivate_locked_super(sb);
336 return ERR_PTR(error);336 return ERR_PTR(error);
337 }337 }
338 sb->s_flags |= MS_ACTIVE;338 sb->s_flags |= SB_ACTIVE;
339 339
340 mutex_lock(&kernfs_mutex);340 mutex_lock(&kernfs_mutex);
341 list_add(&info->node, &root->supers);341 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
246 struct inode *root;246 struct inode *root;
247 struct qstr d_name = QSTR_INIT(name, strlen(name));247 struct qstr d_name = QSTR_INIT(name, strlen(name));
248 248
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,
250 &init_user_ns, NULL);250 &init_user_ns, NULL);
251 if (IS_ERR(s))251 if (IS_ERR(s))
252 return ERR_CAST(s);252 return ERR_CAST(s);
@@ -277,7 +277,7 @@ struct dentry *mount_pseudo_xattr(struct file_system_type *fs_type, char *name, · 24 unmodified lines
277 d_instantiate(dentry, root);277 d_instantiate(dentry, root);
278 s->s_root = dentry;278 s->s_root = dentry;
279 s->s_d_op = dops;279 s->s_d_op = dops;
280 s->s_flags |= MS_ACTIVE;280 s->s_flags |= SB_ACTIVE;
281 return dget(s->s_root);281 return dget(s->s_root);
282 282
283Enomem:283Enomem:
@@ -578,7 +578,7 @@ int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *c · 294 unmodified lines
578 spin_lock(&pin_fs_lock);578 spin_lock(&pin_fs_lock);
579 if (unlikely(!*mount)) {579 if (unlikely(!*mount)) {
580 spin_unlock(&pin_fs_lock);580 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);
582 if (IS_ERR(mnt))582 if (IS_ERR(mnt))
583 return PTR_ERR(mnt);583 return PTR_ERR(mnt);
584 spin_lock(&pin_fs_lock);584 spin_lock(&pin_fs_lock);
fs/locks.c+1−1
@@ -141,7 +141,7 @@ · 140 unmodified lines
141 141
142static inline bool is_remote_lock(struct file *filp)142static inline bool is_remote_lock(struct file *filp)
143{143{
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));
145}145}
146 146
147static bool lease_breaking(struct file_lock *fl)147static 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
125 125
126 sync_filesystem(sb);126 sync_filesystem(sb);
127 ms = sbi->s_ms;127 ms = sbi->s_ms;
128 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))128 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
129 return 0;129 return 0;
130 if (*flags & MS_RDONLY) {130 if (*flags & SB_RDONLY) {
131 if (ms->s_state & MINIX_VALID_FS ||131 if (ms->s_state & MINIX_VALID_FS ||
132 !(sbi->s_mount_state & MINIX_VALID_FS))132 !(sbi->s_mount_state & MINIX_VALID_FS))
133 return 0;133 return 0;
fs/ncpfs/inode.c+2−2
@@ -103,7 +103,7 @@ static void destroy_inodecache(void) · 102 unmodified lines
103static int ncp_remount(struct super_block *sb, int *flags, char* data)103static int ncp_remount(struct super_block *sb, int *flags, char* data)
104{104{
105 sync_filesystem(sb);105 sync_filesystem(sb);
106 *flags |= MS_NODIRATIME;106 *flags |= SB_NODIRATIME;
107 return 0;107 return 0;
108}108}
109 109
@@ -547,7 +547,7 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent) · 437 unmodified lines
547 else547 else
548 default_bufsize = 1024;548 default_bufsize = 1024;
549 549
550 sb->s_flags |= MS_NODIRATIME; /* probably even noatime */550 sb->s_flags |= SB_NODIRATIME; /* probably even noatime */
551 sb->s_maxbytes = 0xFFFFFFFFU;551 sb->s_maxbytes = 0xFFFFFFFFU;
552 sb->s_blocksize = 1024; /* Eh... Is this correct? */552 sb->s_blocksize = 1024; /* Eh... Is this correct? */
553 sb->s_blocksize_bits = 10;553 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
1256 /* Unhash it, so that ->d_iput() would be called */1256 /* Unhash it, so that ->d_iput() would be called */
1257 return 1;1257 return 1;
1258 }1258 }
1259 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {1259 if (!(dentry->d_sb->s_flags & SB_ACTIVE)) {
1260 /* Unhash it, so that ancestors of killed async unlink1260 /* Unhash it, so that ancestors of killed async unlink
1261 * files will be cleaned up during umount */1261 * files will be cleaned up during umount */
1262 return 1;1262 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
752 * Note that we only have to check the vfsmount flags here:752 * Note that we only have to check the vfsmount flags here:
753 * - NFS always sets S_NOATIME by so checking it would give a753 * - NFS always sets S_NOATIME by so checking it would give a
754 * bogus result754 * bogus result
755 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is755 * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is
756 * no point in checking those.756 * no point in checking those.
757 */757 */
758 if ((path->mnt->mnt_flags & MNT_NOATIME) ||758 if ((path->mnt->mnt_flags & MNT_NOATIME) ||
fs/nfs/internal.h+1−1
@@ -10,7 +10,7 @@ · 9 unmodified lines
10#include <linux/nfs_page.h>10#include <linux/nfs_page.h>
11#include <linux/wait_bit.h>11#include <linux/wait_bit.h>
12 12
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)
14 14
15extern const struct export_operations nfs_export_ops;15extern const struct export_operations nfs_export_ops;
16 16
fs/nfs/super.c+11−11
@@ -813,9 +813,9 @@ int nfs_show_stats(struct seq_file *m, struct dentry *root) · 812 unmodified lines
813 */813 */
814 seq_printf(m, "\n\topts:\t");814 seq_printf(m, "\n\topts:\t");
815 seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");815 seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");
816 seq_puts(m, root->d_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");816 seq_puts(m, root->d_sb->s_flags & SB_SYNCHRONOUS ? ",sync" : "");
817 seq_puts(m, root->d_sb->s_flags & MS_NOATIME ? ",noatime" : "");817 seq_puts(m, root->d_sb->s_flags & SB_NOATIME ? ",noatime" : "");
818 seq_puts(m, root->d_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");818 seq_puts(m, root->d_sb->s_flags & SB_NODIRATIME ? ",nodiratime" : "");
819 nfs_show_mount_options(m, nfss, 1);819 nfs_show_mount_options(m, nfss, 1);
820 820
821 seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);821 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
2296 /*2296 /*
2297 * noac is a special case. It implies -o sync, but that's not2297 * noac is a special case. It implies -o sync, but that's not
2298 * necessarily reflected in the mtab options. do_remount_sb2298 * necessarily reflected in the mtab options. do_remount_sb
2299 * will clear MS_SYNCHRONOUS if -o sync wasn't specified in the2299 * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
2300 * remount options, so we have to explicitly reset it.2300 * remount options, so we have to explicitly reset it.
2301 */2301 */
2302 if (data->flags & NFS_MOUNT_NOAC)2302 if (data->flags & NFS_MOUNT_NOAC)
2303 *flags |= MS_SYNCHRONOUS;2303 *flags |= SB_SYNCHRONOUS;
2304 2304
2305 /* compare new mount options with old ones */2305 /* compare new mount options with old ones */
2306 error = nfs_compare_remount_data(nfss, data);2306 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
2349 /* The VFS shouldn't apply the umask to mode bits. We will do2349 /* The VFS shouldn't apply the umask to mode bits. We will do
2350 * so ourselves when necessary.2350 * so ourselves when necessary.
2351 */2351 */
2352 sb->s_flags |= MS_POSIXACL;2352 sb->s_flags |= SB_POSIXACL;
2353 sb->s_time_gran = 1;2353 sb->s_time_gran = 1;
2354 sb->s_export_op = &nfs_export_ops;2354 sb->s_export_op = &nfs_export_ops;
2355 }2355 }
@@ -2379,7 +2379,7 @@ static void nfs_clone_super(struct super_block *sb, · 23 unmodified lines
2379 /* The VFS shouldn't apply the umask to mode bits. We will do2379 /* The VFS shouldn't apply the umask to mode bits. We will do
2380 * so ourselves when necessary.2380 * so ourselves when necessary.
2381 */2381 */
2382 sb->s_flags |= MS_POSIXACL;2382 sb->s_flags |= SB_POSIXACL;
2383 }2383 }
2384 2384
2385 nfs_initialise_sb(sb);2385 nfs_initialise_sb(sb);
@@ -2600,11 +2600,11 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server, · 214 unmodified lines
2600 2600
2601 /* -o noac implies -o sync */2601 /* -o noac implies -o sync */
2602 if (server->flags & NFS_MOUNT_NOAC)2602 if (server->flags & NFS_MOUNT_NOAC)
2603 sb_mntdata.mntflags |= MS_SYNCHRONOUS;2603 sb_mntdata.mntflags |= SB_SYNCHRONOUS;
2604 2604
2605 if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)2605 if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)
2606 if (mount_info->cloned->sb->s_flags & MS_SYNCHRONOUS)2606 if (mount_info->cloned->sb->s_flags & SB_SYNCHRONOUS)
2607 sb_mntdata.mntflags |= MS_SYNCHRONOUS;2607 sb_mntdata.mntflags |= SB_SYNCHRONOUS;
2608 2608
2609 /* Get a superblock - note that we may end up sharing one that already exists */2609 /* Get a superblock - note that we may end up sharing one that already exists */
2610 s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata);2610 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
2641 if (error)2641 if (error)
2642 goto error_splat_root;2642 goto error_splat_root;
2643 2643
2644 s->s_flags |= MS_ACTIVE;2644 s->s_flags |= SB_ACTIVE;
2645 2645
2646out:2646out:
2647 return mntroot;2647 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
1979 struct the_nilfs *nilfs)1979 struct the_nilfs *nilfs)
1980{1980{
1981 struct nilfs_inode_info *ii, *n;1981 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);
1983 int defer_iput = false;1983 int defer_iput = false;
1984 1984
1985 spin_lock(&nilfs->ns_inode_lock);1985 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
141 141
142 if (nilfs_test_opt(nilfs, ERRORS_RO)) {142 if (nilfs_test_opt(nilfs, ERRORS_RO)) {
143 printk(KERN_CRIT "Remounting filesystem read-only\n");143 printk(KERN_CRIT "Remounting filesystem read-only\n");
144 sb->s_flags |= MS_RDONLY;144 sb->s_flags |= SB_RDONLY;
145 }145 }
146 }146 }
147 147
@@ -869,7 +869,7 @@ int nilfs_store_magic_and_option(struct super_block *sb, · 721 unmodified lines
869 869
870 /* FS independent flags */870 /* FS independent flags */
871#ifdef NILFS_ATIME_DISABLE871#ifdef NILFS_ATIME_DISABLE
872 sb->s_flags |= MS_NOATIME;872 sb->s_flags |= SB_NOATIME;
873#endif873#endif
874 874
875 nilfs_set_default_options(sb, sbp);875 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
1133 err = -EINVAL;1133 err = -EINVAL;
1134 goto restore_opts;1134 goto restore_opts;
1135 }1135 }
1136 sb->s_flags = (sb->s_flags & ~MS_POSIXACL);1136 sb->s_flags = (sb->s_flags & ~SB_POSIXACL);
1137 1137
1138 err = -EINVAL;1138 err = -EINVAL;
1139 1139
@@ -1143,12 +1143,12 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data) · 3 unmodified lines
1143 goto restore_opts;1143 goto restore_opts;
1144 }1144 }
1145 1145
1146 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))1146 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
1147 goto out;1147 goto out;
1148 if (*flags & MS_RDONLY) {1148 if (*flags & SB_RDONLY) {
1149 /* Shutting down log writer */1149 /* Shutting down log writer */
1150 nilfs_detach_log_writer(sb);1150 nilfs_detach_log_writer(sb);
1151 sb->s_flags |= MS_RDONLY;1151 sb->s_flags |= SB_RDONLY;
1152 1152
1153 /*1153 /*
1154 * Remounting a valid RW partition RDONLY, so set1154 * 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
1178 goto restore_opts;1178 goto restore_opts;
1179 }1179 }
1180 1180
1181 sb->s_flags &= ~MS_RDONLY;1181 sb->s_flags &= ~SB_RDONLY;
1182 1182
1183 root = NILFS_I(d_inode(sb->s_root))->i_root;1183 root = NILFS_I(d_inode(sb->s_root))->i_root;
1184 err = nilfs_attach_log_writer(sb, root);1184 err = nilfs_attach_log_writer(sb, root);
@@ -1212,7 +1212,7 @@ static int nilfs_parse_snapshot_option(const char *option, · 27 unmodified lines
1212 const char *msg = NULL;1212 const char *msg = NULL;
1213 int err;1213 int err;
1214 1214
1215 if (!(sd->flags & MS_RDONLY)) {1215 if (!(sd->flags & SB_RDONLY)) {
1216 msg = "read-only option is not specified";1216 msg = "read-only option is not specified";
1217 goto parse_error;1217 goto parse_error;
1218 }1218 }
@@ -1286,7 +1286,7 @@ nilfs_mount(struct file_system_type *fs_type, int flags, · 67 unmodified lines
1286 struct dentry *root_dentry;1286 struct dentry *root_dentry;
1287 int err, s_new = false;1287 int err, s_new = false;
1288 1288
1289 if (!(flags & MS_RDONLY))1289 if (!(flags & SB_RDONLY))
1290 mode |= FMODE_WRITE;1290 mode |= FMODE_WRITE;
1291 1291
1292 sd.bdev = blkdev_get_by_path(dev_name, mode, fs_type);1292 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
1327 snprintf(s->s_id, sizeof(s->s_id), "%pg", sd.bdev);1327 snprintf(s->s_id, sizeof(s->s_id), "%pg", sd.bdev);
1328 sb_set_blocksize(s, block_size(sd.bdev));1328 sb_set_blocksize(s, block_size(sd.bdev));
1329 1329
1330 err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0);1330 err = nilfs_fill_super(s, data, flags & SB_SILENT ? 1 : 0);
1331 if (err)1331 if (err)
1332 goto failed_super;1332 goto failed_super;
1333 1333
1334 s->s_flags |= MS_ACTIVE;1334 s->s_flags |= SB_ACTIVE;
1335 } else if (!sd.cno) {1335 } else if (!sd.cno) {
1336 if (nilfs_tree_is_busy(s->s_root)) {1336 if (nilfs_tree_is_busy(s->s_root)) {
1337 if ((flags ^ s->s_flags) & MS_RDONLY) {1337 if ((flags ^ s->s_flags) & SB_RDONLY) {
1338 nilfs_msg(s, KERN_ERR,1338 nilfs_msg(s, KERN_ERR,
1339 "the device already has a %s mount.",1339 "the device already has a %s mount.",
1340 sb_rdonly(s) ? "read-only" : "read/write");1340 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
220 220
221 if (!valid_fs) {221 if (!valid_fs) {
222 nilfs_msg(sb, KERN_WARNING, "mounting unchecked fs");222 nilfs_msg(sb, KERN_WARNING, "mounting unchecked fs");
223 if (s_flags & MS_RDONLY) {223 if (s_flags & SB_RDONLY) {
224 nilfs_msg(sb, KERN_INFO,224 nilfs_msg(sb, KERN_INFO,
225 "recovery required for readonly filesystem");225 "recovery required for readonly filesystem");
226 nilfs_msg(sb, KERN_INFO,226 nilfs_msg(sb, KERN_INFO,
@@ -286,7 +286,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb) · 59 unmodified lines
286 if (valid_fs)286 if (valid_fs)
287 goto skip_recovery;287 goto skip_recovery;
288 288
289 if (s_flags & MS_RDONLY) {289 if (s_flags & SB_RDONLY) {
290 __u64 features;290 __u64 features;
291 291
292 if (nilfs_test_opt(nilfs, NORECOVERY)) {292 if (nilfs_test_opt(nilfs, NORECOVERY)) {
@@ -309,7 +309,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb) · 16 unmodified lines
309 err = -EROFS;309 err = -EROFS;
310 goto failed_unload;310 goto failed_unload;
311 }311 }
312 sb->s_flags &= ~MS_RDONLY;312 sb->s_flags &= ~SB_RDONLY;
313 } else if (nilfs_test_opt(nilfs, NORECOVERY)) {313 } else if (nilfs_test_opt(nilfs, NORECOVERY)) {
314 nilfs_msg(sb, KERN_ERR,314 nilfs_msg(sb, KERN_ERR,
315 "recovery cancelled because norecovery option was specified for a read/write mount");315 "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
67 67
68 /*68 /*
69 * If i_count is zero, the inode cannot have any watches and69 * If i_count is zero, the inode cannot have any watches and
70 * doing an __iget/iput with MS_ACTIVE clear would actually70 * doing an __iget/iput with SB_ACTIVE clear would actually
71 * evict all inodes with zero i_count from icache which is71 * evict all inodes with zero i_count from icache which is
72 * unnecessarily violent and may in fact be illegal to do.72 * unnecessarily violent and may in fact be illegal to do.
73 */73 */
fs/nsfs.c+1−1
@@ -255,5 +255,5 @@ void __init nsfs_init(void) · 254 unmodified lines
255 nsfs_mnt = kern_mount(&nsfs);255 nsfs_mnt = kern_mount(&nsfs);
256 if (IS_ERR(nsfs_mnt))256 if (IS_ERR(nsfs_mnt))
257 panic("can't set nsfs up\n");257 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;
259}259}
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
473 473
474#ifndef NTFS_RW474#ifndef NTFS_RW
475 /* For read-only compiled driver, enforce read-only flag. */475 /* For read-only compiled driver, enforce read-only flag. */
476 *flags |= MS_RDONLY;476 *flags |= SB_RDONLY;
477#else /* NTFS_RW */477#else /* NTFS_RW */
478 /*478 /*
479 * For the read-write compiled driver, if we are remounting read-write,479 * 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
487 * When remounting read-only, mark the volume clean if no volume errors487 * When remounting read-only, mark the volume clean if no volume errors
488 * have occurred.488 * have occurred.
489 */489 */
490 if (sb_rdonly(sb) && !(*flags & MS_RDONLY)) {490 if (sb_rdonly(sb) && !(*flags & SB_RDONLY)) {
491 static const char *es = ". Cannot remount read-write.";491 static const char *es = ". Cannot remount read-write.";
492 492
493 /* Remounting read-write. */493 /* Remounting read-write. */
@@ -548,7 +548,7 @@ static int ntfs_remount(struct super_block *sb, int *flags, char *opt) · 54 unmodified lines
548 NVolSetErrors(vol);548 NVolSetErrors(vol);
549 return -EROFS;549 return -EROFS;
550 }550 }
551 } else if (!sb_rdonly(sb) && (*flags & MS_RDONLY)) {551 } else if (!sb_rdonly(sb) && (*flags & SB_RDONLY)) {
552 /* Remounting read-only. */552 /* Remounting read-only. */
553 if (!NVolErrors(vol)) {553 if (!NVolErrors(vol)) {
554 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))554 if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
@@ -1799,7 +1799,7 @@ static bool load_system_files(ntfs_volume *vol) · 1244 unmodified lines
1799 es3);1799 es3);
1800 goto iput_mirr_err_out;1800 goto iput_mirr_err_out;
1801 }1801 }
1802 sb->s_flags |= MS_RDONLY;1802 sb->s_flags |= SB_RDONLY;
1803 ntfs_error(sb, "%s. Mounting read-only%s",1803 ntfs_error(sb, "%s. Mounting read-only%s",
1804 !vol->mftmirr_ino ? es1 : es2, es3);1804 !vol->mftmirr_ino ? es1 : es2, es3);
1805 } else1805 } else
@@ -1937,7 +1937,7 @@ get_ctx_vol_failed: · 131 unmodified lines
1937 es1, es2);1937 es1, es2);
1938 goto iput_vol_err_out;1938 goto iput_vol_err_out;
1939 }1939 }
1940 sb->s_flags |= MS_RDONLY;1940 sb->s_flags |= SB_RDONLY;
1941 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);1941 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
1942 } else1942 } else
1943 ntfs_warning(sb, "%s. Will not be able to remount "1943 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -1974,7 +1974,7 @@ get_ctx_vol_failed: · 30 unmodified lines
1974 }1974 }
1975 goto iput_logfile_err_out;1975 goto iput_logfile_err_out;
1976 }1976 }
1977 sb->s_flags |= MS_RDONLY;1977 sb->s_flags |= SB_RDONLY;
1978 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);1978 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
1979 } else1979 } else
1980 ntfs_warning(sb, "%s. Will not be able to remount "1980 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2019,7 +2019,7 @@ get_ctx_vol_failed: · 38 unmodified lines
2019 es1, es2);2019 es1, es2);
2020 goto iput_root_err_out;2020 goto iput_root_err_out;
2021 }2021 }
2022 sb->s_flags |= MS_RDONLY;2022 sb->s_flags |= SB_RDONLY;
2023 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2023 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2024 } else2024 } else
2025 ntfs_warning(sb, "%s. Will not be able to remount "2025 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2042,7 +2042,7 @@ get_ctx_vol_failed: · 16 unmodified lines
2042 goto iput_root_err_out;2042 goto iput_root_err_out;
2043 }2043 }
2044 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2044 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2045 sb->s_flags |= MS_RDONLY;2045 sb->s_flags |= SB_RDONLY;
2046 /*2046 /*
2047 * Do not set NVolErrors() because ntfs_remount() might manage2047 * Do not set NVolErrors() because ntfs_remount() might manage
2048 * to set the dirty flag in which case all would be well.2048 * to set the dirty flag in which case all would be well.
@@ -2055,7 +2055,7 @@ get_ctx_vol_failed: · 6 unmodified lines
2055 * If (still) a read-write mount, set the NT4 compatibility flag on2055 * If (still) a read-write mount, set the NT4 compatibility flag on
2056 * newer NTFS version volumes.2056 * newer NTFS version volumes.
2057 */2057 */
2058 if (!(sb->s_flags & MS_RDONLY) && (vol->major_ver > 1) &&2058 if (!(sb->s_flags & SB_RDONLY) && (vol->major_ver > 1) &&
2059 ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {2059 ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
2060 static const char *es1 = "Failed to set NT4 compatibility flag";2060 static const char *es1 = "Failed to set NT4 compatibility flag";
2061 static const char *es2 = ". Run chkdsk.";2061 static const char *es2 = ". Run chkdsk.";
@@ -2069,7 +2069,7 @@ get_ctx_vol_failed: · 7 unmodified lines
2069 goto iput_root_err_out;2069 goto iput_root_err_out;
2070 }2070 }
2071 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2071 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2072 sb->s_flags |= MS_RDONLY;2072 sb->s_flags |= SB_RDONLY;
2073 NVolSetErrors(vol);2073 NVolSetErrors(vol);
2074 }2074 }
2075#endif2075#endif
@@ -2087,7 +2087,7 @@ get_ctx_vol_failed: · 11 unmodified lines
2087 goto iput_root_err_out;2087 goto iput_root_err_out;
2088 }2088 }
2089 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2089 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2090 sb->s_flags |= MS_RDONLY;2090 sb->s_flags |= SB_RDONLY;
2091 NVolSetErrors(vol);2091 NVolSetErrors(vol);
2092 }2092 }
2093#endif /* NTFS_RW */2093#endif /* NTFS_RW */
@@ -2128,7 +2128,7 @@ get_ctx_vol_failed: · 34 unmodified lines
2128 es1, es2);2128 es1, es2);
2129 goto iput_quota_err_out;2129 goto iput_quota_err_out;
2130 }2130 }
2131 sb->s_flags |= MS_RDONLY;2131 sb->s_flags |= SB_RDONLY;
2132 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2132 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2133 } else2133 } else
2134 ntfs_warning(sb, "%s. Will not be able to remount "2134 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2150,7 +2150,7 @@ get_ctx_vol_failed: · 15 unmodified lines
2150 goto iput_quota_err_out;2150 goto iput_quota_err_out;
2151 }2151 }
2152 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2152 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2153 sb->s_flags |= MS_RDONLY;2153 sb->s_flags |= SB_RDONLY;
2154 NVolSetErrors(vol);2154 NVolSetErrors(vol);
2155 }2155 }
2156 /*2156 /*
@@ -2171,7 +2171,7 @@ get_ctx_vol_failed: · 14 unmodified lines
2171 es1, es2);2171 es1, es2);
2172 goto iput_usnjrnl_err_out;2172 goto iput_usnjrnl_err_out;
2173 }2173 }
2174 sb->s_flags |= MS_RDONLY;2174 sb->s_flags |= SB_RDONLY;
2175 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2175 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2176 } else2176 } else
2177 ntfs_warning(sb, "%s. Will not be able to remount "2177 ntfs_warning(sb, "%s. Will not be able to remount "
@@ -2194,7 +2194,7 @@ get_ctx_vol_failed: · 16 unmodified lines
2194 goto iput_usnjrnl_err_out;2194 goto iput_usnjrnl_err_out;
2195 }2195 }
2196 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);2196 ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2197 sb->s_flags |= MS_RDONLY;2197 sb->s_flags |= SB_RDONLY;
2198 NVolSetErrors(vol);2198 NVolSetErrors(vol);
2199 }2199 }
2200#endif /* NTFS_RW */2200#endif /* NTFS_RW */
@@ -2728,7 +2728,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent) · 527 unmodified lines
2728 lockdep_off();2728 lockdep_off();
2729 ntfs_debug("Entering.");2729 ntfs_debug("Entering.");
2730#ifndef NTFS_RW2730#ifndef NTFS_RW
2731 sb->s_flags |= MS_RDONLY;2731 sb->s_flags |= SB_RDONLY;
2732#endif /* ! NTFS_RW */2732#endif /* ! NTFS_RW */
2733 /* Allocate a new ntfs_volume and place it in sb->s_fs_info. */2733 /* Allocate a new ntfs_volume and place it in sb->s_fs_info. */
2734 sb->s_fs_info = kmalloc(sizeof(ntfs_volume), GFP_NOFS);2734 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
227 return 0;227 return 0;
228 228
229 if ((inode->i_flags & S_NOATIME) ||229 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)))
231 return 0;231 return 0;
232 232
233 /*233 /*
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
675 }675 }
676 676
677 /* We're going to/from readonly mode. */677 /* 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)) {
679 /* Disable quota accounting before remounting RO */679 /* Disable quota accounting before remounting RO */
680 if (*flags & MS_RDONLY) {680 if (*flags & SB_RDONLY) {
681 ret = ocfs2_susp_quotas(osb, 0);681 ret = ocfs2_susp_quotas(osb, 0);
682 if (ret < 0)682 if (ret < 0)
683 goto out;683 goto out;
@@ -691,8 +691,8 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data) · 7 unmodified lines
691 goto unlock_osb;691 goto unlock_osb;
692 }692 }
693 693
694 if (*flags & MS_RDONLY) {694 if (*flags & SB_RDONLY) {
695 sb->s_flags |= MS_RDONLY;695 sb->s_flags |= SB_RDONLY;
696 osb->osb_flags |= OCFS2_OSB_SOFT_RO;696 osb->osb_flags |= OCFS2_OSB_SOFT_RO;
697 } else {697 } else {
698 if (osb->osb_flags & OCFS2_OSB_ERROR_FS) {698 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
709 ret = -EINVAL;709 ret = -EINVAL;
710 goto unlock_osb;710 goto unlock_osb;
711 }711 }
712 sb->s_flags &= ~MS_RDONLY;712 sb->s_flags &= ~SB_RDONLY;
713 osb->osb_flags &= ~OCFS2_OSB_SOFT_RO;713 osb->osb_flags &= ~OCFS2_OSB_SOFT_RO;
714 }714 }
715 trace_ocfs2_remount(sb->s_flags, osb->osb_flags, *flags);715 trace_ocfs2_remount(sb->s_flags, osb->osb_flags, *flags);
716unlock_osb:716unlock_osb:
717 spin_unlock(&osb->osb_lock);717 spin_unlock(&osb->osb_lock);
718 /* Enable quota accounting after remounting RW */718 /* Enable quota accounting after remounting RW */
719 if (!ret && !(*flags & MS_RDONLY)) {719 if (!ret && !(*flags & SB_RDONLY)) {
720 if (sb_any_quota_suspended(sb))720 if (sb_any_quota_suspended(sb))
721 ret = ocfs2_susp_quotas(osb, 1);721 ret = ocfs2_susp_quotas(osb, 1);
722 else722 else
@@ -724,7 +724,7 @@ unlock_osb: · 1 unmodified line
724 if (ret < 0) {724 if (ret < 0) {
725 /* Return back changes... */725 /* Return back changes... */
726 spin_lock(&osb->osb_lock);726 spin_lock(&osb->osb_lock);
727 sb->s_flags |= MS_RDONLY;727 sb->s_flags |= SB_RDONLY;
728 osb->osb_flags |= OCFS2_OSB_SOFT_RO;728 osb->osb_flags |= OCFS2_OSB_SOFT_RO;
729 spin_unlock(&osb->osb_lock);729 spin_unlock(&osb->osb_lock);
730 goto out;730 goto out;
@@ -744,9 +744,9 @@ unlock_osb: · 13 unmodified lines
744 if (!ocfs2_is_hard_readonly(osb))744 if (!ocfs2_is_hard_readonly(osb))
745 ocfs2_set_journal_params(osb);745 ocfs2_set_journal_params(osb);
746 746
747 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |747 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
748 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ?748 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ?
749 MS_POSIXACL : 0);749 SB_POSIXACL : 0);
750 }750 }
751out:751out:
752 return ret;752 return ret;
@@ -1057,10 +1057,10 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent) · 304 unmodified lines
1057 1057
1058 sb->s_magic = OCFS2_SUPER_MAGIC;1058 sb->s_magic = OCFS2_SUPER_MAGIC;
1059 1059
1060 sb->s_flags = (sb->s_flags & ~(MS_POSIXACL | MS_NOSEC)) |1060 sb->s_flags = (sb->s_flags & ~(SB_POSIXACL | SB_NOSEC)) |
1061 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);1061 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? SB_POSIXACL : 0);
1062 1062
1063 /* Hard readonly mode only if: bdev_read_only, MS_RDONLY,1063 /* Hard readonly mode only if: bdev_read_only, SB_RDONLY,
1064 * heartbeat=none */1064 * heartbeat=none */
1065 if (bdev_read_only(sb->s_bdev)) {1065 if (bdev_read_only(sb->s_bdev)) {
1066 if (!sb_rdonly(sb)) {1066 if (!sb_rdonly(sb)) {
@@ -2057,7 +2057,7 @@ static int ocfs2_initialize_super(struct super_block *sb, · 990 unmodified lines
2057 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;2057 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
2058 sb->s_xattr = ocfs2_xattr_handlers;2058 sb->s_xattr = ocfs2_xattr_handlers;
2059 sb->s_time_gran = 1;2059 sb->s_time_gran = 1;
2060 sb->s_flags |= MS_NOATIME;2060 sb->s_flags |= SB_NOATIME;
2061 /* this is needed to support O_LARGEFILE */2061 /* this is needed to support O_LARGEFILE */
2062 cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits);2062 cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits);
2063 bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits);2063 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
2568 return rv;2568 return rv;
2569 2569
2570 pr_crit("OCFS2: File system is now read-only.\n");2570 pr_crit("OCFS2: File system is now read-only.\n");
2571 sb->s_flags |= MS_RDONLY;2571 sb->s_flags |= SB_RDONLY;
2572 ocfs2_set_ro_flag(osb, 0);2572 ocfs2_set_ro_flag(osb, 0);
2573 }2573 }
2574 2574
fs/ocfs2/xattr.c+1−1
@@ -901,7 +901,7 @@ static int ocfs2_xattr_list_entry(struct super_block *sb, · 900 unmodified lines
901 901
902 case OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS:902 case OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS:
903 case OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT:903 case OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT:
904 if (!(sb->s_flags & MS_POSIXACL))904 if (!(sb->s_flags & SB_POSIXACL))
905 return 0;905 return 0;
906 break;906 break;
907 907
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
369static int openprom_remount(struct super_block *sb, int *flags, char *data)369static int openprom_remount(struct super_block *sb, int *flags, char *data)
370{370{
371 sync_filesystem(sb);371 sync_filesystem(sb);
372 *flags |= MS_NOATIME;372 *flags |= SB_NOATIME;
373 return 0;373 return 0;
374}374}
375 375
@@ -386,7 +386,7 @@ static int openprom_fill_super(struct super_block *s, void *data, int silent) · 10 unmodified lines
386 struct op_inode_info *oi;386 struct op_inode_info *oi;
387 int ret;387 int ret;
388 388
389 s->s_flags |= MS_NOATIME;389 s->s_flags |= SB_NOATIME;
390 s->s_blocksize = 1024;390 s->s_blocksize = 1024;
391 s->s_blocksize_bits = 10;391 s->s_blocksize_bits = 10;
392 s->s_magic = OPENPROM_SUPER_MAGIC;392 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
40{40{
41 struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(root->d_sb);41 struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(root->d_sb);
42 42
43 if (root->d_sb->s_flags & MS_POSIXACL)43 if (root->d_sb->s_flags & SB_POSIXACL)
44 seq_puts(m, ",acl");44 seq_puts(m, ",acl");
45 if (orangefs_sb->flags & ORANGEFS_OPT_INTR)45 if (orangefs_sb->flags & ORANGEFS_OPT_INTR)
46 seq_puts(m, ",intr");46 seq_puts(m, ",intr");
@@ -60,7 +60,7 @@ static int parse_mount_options(struct super_block *sb, char *options, · 13 unmodified lines
60 * Force any potential flags that might be set from the mount60 * Force any potential flags that might be set from the mount
61 * to zero, ie, initialize to unset.61 * to zero, ie, initialize to unset.
62 */62 */
63 sb->s_flags &= ~MS_POSIXACL;63 sb->s_flags &= ~SB_POSIXACL;
64 orangefs_sb->flags &= ~ORANGEFS_OPT_INTR;64 orangefs_sb->flags &= ~ORANGEFS_OPT_INTR;
65 orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK;65 orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK;
66 66
@@ -73,7 +73,7 @@ static int parse_mount_options(struct super_block *sb, char *options, · 6 unmodified lines
73 token = match_token(p, tokens, args);73 token = match_token(p, tokens, args);
74 switch (token) {74 switch (token) {
75 case Opt_acl:75 case Opt_acl:
76 sb->s_flags |= MS_POSIXACL;76 sb->s_flags |= SB_POSIXACL;
77 break;77 break;
78 case Opt_intr:78 case Opt_intr:
79 orangefs_sb->flags |= ORANGEFS_OPT_INTR;79 orangefs_sb->flags |= ORANGEFS_OPT_INTR;
@@ -507,7 +507,7 @@ struct dentry *orangefs_mount(struct file_system_type *fst, · 427 unmodified lines
507 507
508 ret = orangefs_fill_sb(sb,508 ret = orangefs_fill_sb(sb,
509 &new_op->downcall.resp.fs_mount, data,509 &new_op->downcall.resp.fs_mount, data,
510 flags & MS_SILENT ? 1 : 0);510 flags & SB_SILENT ? 1 : 0);
511 511
512 if (ret) {512 if (ret) {
513 d = ERR_PTR(ret);513 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
326{326{
327 struct ovl_fs *ofs = sb->s_fs_info;327 struct ovl_fs *ofs = sb->s_fs_info;
328 328
329 if (!(*flags & MS_RDONLY) && ovl_force_readonly(ofs))329 if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs))
330 return -EROFS;330 return -EROFS;
331 331
332 return 0;332 return 0;
@@ -1190,7 +1190,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent) · 857 unmodified lines
1190 goto out_err;1190 goto out_err;
1191 1191
1192 if (!ofs->workdir)1192 if (!ofs->workdir)
1193 sb->s_flags |= MS_RDONLY;1193 sb->s_flags |= SB_RDONLY;
1194 1194
1195 sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth;1195 sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth;
1196 sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran;1196 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
1203 1203
1204 /* If the upper fs is nonexistent, we mark overlayfs r/o too */1204 /* If the upper fs is nonexistent, we mark overlayfs r/o too */
1205 if (!ofs->upper_mnt)1205 if (!ofs->upper_mnt)
1206 sb->s_flags |= MS_RDONLY;1206 sb->s_flags |= SB_RDONLY;
1207 else if (ofs->upper_mnt->mnt_sb != ofs->same_sb)1207 else if (ofs->upper_mnt->mnt_sb != ofs->same_sb)
1208 ofs->same_sb = NULL;1208 ofs->same_sb = NULL;
1209 1209
@@ -1213,7 +1213,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent) · 3 unmodified lines
1213 goto out_free_oe;1213 goto out_free_oe;
1214 1214
1215 if (!ofs->indexdir)1215 if (!ofs->indexdir)
1216 sb->s_flags |= MS_RDONLY;1216 sb->s_flags |= SB_RDONLY;
1217 }1217 }
1218 1218
1219 /* Show index=off/on in /proc/mounts for any of the reasons above */1219 /* 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
1227 sb->s_op = &ovl_super_operations;1227 sb->s_op = &ovl_super_operations;
1228 sb->s_xattr = ovl_xattr_handlers;1228 sb->s_xattr = ovl_xattr_handlers;
1229 sb->s_fs_info = ofs;1229 sb->s_fs_info = ofs;
1230 sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK;1230 sb->s_flags |= SB_POSIXACL | SB_NOREMOTELOCK;
1231 1231
1232 err = -ENOMEM;1232 err = -ENOMEM;
1233 root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));1233 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
483 483
484 /* User space would break if executables or devices appear on proc */484 /* User space would break if executables or devices appear on proc */
485 s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;485 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;
487 s->s_blocksize = 1024;487 s->s_blocksize = 1024;
488 s->s_blocksize_bits = 10;488 s->s_blocksize_bits = 10;
489 s->s_magic = PROC_SUPER_MAGIC;489 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
91{91{
92 struct pid_namespace *ns;92 struct pid_namespace *ns;
93 93
94 if (flags & MS_KERNMOUNT) {94 if (flags & SB_KERNMOUNT) {
95 ns = data;95 ns = data;
96 data = NULL;96 data = NULL;
97 } else {97 } else {
fs/proc_namespace.c+4−4
@@ -45,10 +45,10 @@ struct proc_fs_info { · 44 unmodified lines
45static int show_sb_opts(struct seq_file *m, struct super_block *sb)45static int show_sb_opts(struct seq_file *m, struct super_block *sb)
46{46{
47 static const struct proc_fs_info fs_info[] = {47 static const struct proc_fs_info fs_info[] = {
48 { MS_SYNCHRONOUS, ",sync" },48 { SB_SYNCHRONOUS, ",sync" },
49 { MS_DIRSYNC, ",dirsync" },49 { SB_DIRSYNC, ",dirsync" },
50 { MS_MANDLOCK, ",mand" },50 { SB_MANDLOCK, ",mand" },
51 { MS_LAZYTIME, ",lazytime" },51 { SB_LAZYTIME, ",lazytime" },
52 { 0, NULL }52 { 0, NULL }
53 };53 };
54 const struct proc_fs_info *fs_infop;54 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
47 sync_filesystem(sb);47 sync_filesystem(sb);
48 qs = qnx4_sb(sb);48 qs = qnx4_sb(sb);
49 qs->Version = QNX4_VERSION;49 qs->Version = QNX4_VERSION;
50 *flags |= MS_RDONLY;50 *flags |= SB_RDONLY;
51 return 0;51 return 0;
52}52}
53 53
@@ -199,7 +199,7 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent) · 145 unmodified lines
199 199
200 s->s_op = &qnx4_sops;200 s->s_op = &qnx4_sops;
201 s->s_magic = QNX4_SUPER_MAGIC;201 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 */
203 203
204 /* Check the superblock signature. Since the qnx4 code is204 /* Check the superblock signature. Since the qnx4 code is
205 dangerous, we should leave as quickly as possible205 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
56static int qnx6_remount(struct super_block *sb, int *flags, char *data)56static int qnx6_remount(struct super_block *sb, int *flags, char *data)
57{57{
58 sync_filesystem(sb);58 sync_filesystem(sb);
59 *flags |= MS_RDONLY;59 *flags |= SB_RDONLY;
60 return 0;60 return 0;
61}61}
62 62
@@ -427,7 +427,7 @@ mmi_success: · 364 unmodified lines
427 }427 }
428 s->s_op = &qnx6_sops;428 s->s_op = &qnx6_sops;
429 s->s_magic = QNX6_SUPER_MAGIC;429 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 */
431 431
432 /* ease the later tree level calculations */432 /* ease the later tree level calculations */
433 sbi = QNX6_SB(s);433 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
2106 journal_end(th);2106 journal_end(th);
2107 goto out_inserted_sd;2107 goto out_inserted_sd;
2108 }2108 }
2109 } else if (inode->i_sb->s_flags & MS_POSIXACL) {2109 } else if (inode->i_sb->s_flags & SB_POSIXACL) {
2110 reiserfs_warning(inode->i_sb, "jdm-13090",2110 reiserfs_warning(inode->i_sb, "jdm-13090",
2111 "ACLs aren't enabled in the fs, "2111 "ACLs aren't enabled in the fs, "
2112 "but vfs thinks they are!");2112 "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
1960 /*1960 /*
1961 * Cancel flushing of old commits. Note that neither of these works1961 * Cancel flushing of old commits. Note that neither of these works
1962 * will be requeued because superblock is being shutdown and doesn't1962 * will be requeued because superblock is being shutdown and doesn't
1963 * have MS_ACTIVE set.1963 * have SB_ACTIVE set.
1964 */1964 */
1965 reiserfs_cancel_old_flush(sb);1965 reiserfs_cancel_old_flush(sb);
1966 /* wait for all commits to finish */1966 /* 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
4302 * Avoid queueing work when sb is being shut down. Transaction4302 * Avoid queueing work when sb is being shut down. Transaction
4303 * will be flushed on journal shutdown.4303 * will be flushed on journal shutdown.
4304 */4304 */
4305 if (sb->s_flags & MS_ACTIVE)4305 if (sb->s_flags & SB_ACTIVE)
4306 queue_delayed_work(REISERFS_SB(sb)->commit_wq,4306 queue_delayed_work(REISERFS_SB(sb)->commit_wq,
4307 &journal->j_work, HZ / 10);4307 &journal->j_work, HZ / 10);
4308 }4308 }
@@ -4393,7 +4393,7 @@ void reiserfs_abort_journal(struct super_block *sb, int errno) · 84 unmodified lines
4393 if (!journal->j_errno)4393 if (!journal->j_errno)
4394 journal->j_errno = errno;4394 journal->j_errno = errno;
4395 4395
4396 sb->s_flags |= MS_RDONLY;4396 sb->s_flags |= SB_RDONLY;
4397 set_bit(J_ABORTED, &journal->j_state);4397 set_bit(J_ABORTED, &journal->j_state);
4398 4398
4399#ifdef CONFIG_REISERFS_CHECK4399#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
390 return;390 return;
391 391
392 reiserfs_info(sb, "Remounting filesystem read-only\n");392 reiserfs_info(sb, "Remounting filesystem read-only\n");
393 sb->s_flags |= MS_RDONLY;393 sb->s_flags |= SB_RDONLY;
394 reiserfs_abort_journal(sb, -EIO);394 reiserfs_abort_journal(sb, -EIO);
395}395}
396 396
@@ -409,7 +409,7 @@ void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...) · 12 unmodified lines
409 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,409 printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
410 error_buf);410 error_buf);
411 411
412 sb->s_flags |= MS_RDONLY;412 sb->s_flags |= SB_RDONLY;
413 reiserfs_abort_journal(sb, errno);413 reiserfs_abort_journal(sb, errno);
414}414}
415 415
fs/reiserfs/super.c+9−9
@@ -121,7 +121,7 @@ void reiserfs_schedule_old_flush(struct super_block *s) · 120 unmodified lines
121 * Avoid scheduling flush when sb is being shut down. It can race121 * Avoid scheduling flush when sb is being shut down. It can race
122 * with journal shutdown and free still queued delayed work.122 * with journal shutdown and free still queued delayed work.
123 */123 */
124 if (sb_rdonly(s) || !(s->s_flags & MS_ACTIVE))124 if (sb_rdonly(s) || !(s->s_flags & SB_ACTIVE))
125 return;125 return;
126 126
127 spin_lock(&sbi->old_work_lock);127 spin_lock(&sbi->old_work_lock);
@@ -252,11 +252,11 @@ static int finish_unfinished(struct super_block *s) · 124 unmodified lines
252 252
253#ifdef CONFIG_QUOTA253#ifdef CONFIG_QUOTA
254 /* Needed for iput() to work correctly and not trash data */254 /* Needed for iput() to work correctly and not trash data */
255 if (s->s_flags & MS_ACTIVE) {255 if (s->s_flags & SB_ACTIVE) {
256 ms_active_set = 0;256 ms_active_set = 0;
257 } else {257 } else {
258 ms_active_set = 1;258 ms_active_set = 1;
259 s->s_flags |= MS_ACTIVE;259 s->s_flags |= SB_ACTIVE;
260 }260 }
261 /* Turn on quotas so that they are updated correctly */261 /* Turn on quotas so that they are updated correctly */
262 for (i = 0; i < REISERFS_MAXQUOTAS; i++) {262 for (i = 0; i < REISERFS_MAXQUOTAS; i++) {
@@ -411,7 +411,7 @@ static int finish_unfinished(struct super_block *s) · 148 unmodified lines
411 reiserfs_write_lock(s);411 reiserfs_write_lock(s);
412 if (ms_active_set)412 if (ms_active_set)
413 /* Restore the flag back */413 /* Restore the flag back */
414 s->s_flags &= ~MS_ACTIVE;414 s->s_flags &= ~SB_ACTIVE;
415#endif415#endif
416 pathrelse(&path);416 pathrelse(&path);
417 if (done)417 if (done)
@@ -1521,7 +1521,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) · 1103 unmodified lines
1521 goto out_err_unlock;1521 goto out_err_unlock;
1522 }1522 }
1523 1523
1524 if (*mount_flags & MS_RDONLY) {1524 if (*mount_flags & SB_RDONLY) {
1525 reiserfs_write_unlock(s);1525 reiserfs_write_unlock(s);
1526 reiserfs_xattr_init(s, *mount_flags);1526 reiserfs_xattr_init(s, *mount_flags);
1527 /* remount read-only */1527 /* remount read-only */
@@ -1567,7 +1567,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) · 39 unmodified lines
1567 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);1567 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1568 1568
1569 /* now it is safe to call journal_begin */1569 /* now it is safe to call journal_begin */
1570 s->s_flags &= ~MS_RDONLY;1570 s->s_flags &= ~SB_RDONLY;
1571 err = journal_begin(&th, s, 10);1571 err = journal_begin(&th, s, 10);
1572 if (err)1572 if (err)
1573 goto out_err_unlock;1573 goto out_err_unlock;
@@ -1575,7 +1575,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) · 1 unmodified line
1575 /* Mount a partition which is read-only, read-write */1575 /* Mount a partition which is read-only, read-write */
1576 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);1576 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1577 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);1577 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1578 s->s_flags &= ~MS_RDONLY;1578 s->s_flags &= ~SB_RDONLY;
1579 set_sb_umount_state(rs, REISERFS_ERROR_FS);1579 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1580 if (!old_format_only(s))1580 if (!old_format_only(s))
1581 set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);1581 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
1590 goto out_err_unlock;1590 goto out_err_unlock;
1591 1591
1592 reiserfs_write_unlock(s);1592 reiserfs_write_unlock(s);
1593 if (!(*mount_flags & MS_RDONLY)) {1593 if (!(*mount_flags & SB_RDONLY)) {
1594 dquot_resume(s, -1);1594 dquot_resume(s, -1);
1595 reiserfs_write_lock(s);1595 reiserfs_write_lock(s);
1596 finish_unfinished(s);1596 finish_unfinished(s);
@@ -2055,7 +2055,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent) · 458 unmodified lines
2055 if (bdev_read_only(s->s_bdev) && !sb_rdonly(s)) {2055 if (bdev_read_only(s->s_bdev) && !sb_rdonly(s)) {
2056 SWARN(silent, s, "clm-7000",2056 SWARN(silent, s, "clm-7000",
2057 "Detected readonly device, marking FS readonly");2057 "Detected readonly device, marking FS readonly");
2058 s->s_flags |= MS_RDONLY;2058 s->s_flags |= SB_RDONLY;
2059 }2059 }
2060 args.objectid = REISERFS_ROOT_OBJECTID;2060 args.objectid = REISERFS_ROOT_OBJECTID;
2061 args.dirid = REISERFS_ROOT_PARENT_OBJECTID;2061 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
959 959
960/*960/*
961 * We need to take a copy of the mount flags since things like961 * 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.
963 * mount_flags != mount_options963 * mount_flags != mount_options
964 */964 */
965int reiserfs_xattr_init(struct super_block *s, int mount_flags)965int 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
971 if (err)971 if (err)
972 goto error;972 goto error;
973 973
974 if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) {974 if (d_really_is_negative(privroot) && !(mount_flags & SB_RDONLY)) {
975 inode_lock(d_inode(s->s_root));975 inode_lock(d_inode(s->s_root));
976 err = create_privroot(REISERFS_SB(s)->priv_root);976 err = create_privroot(REISERFS_SB(s)->priv_root);
977 inode_unlock(d_inode(s->s_root));977 inode_unlock(d_inode(s->s_root));
@@ -999,11 +999,11 @@ error: · 21 unmodified lines
999 clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt);999 clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt);
1000 }1000 }
1001 1001
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. */
1003 if (reiserfs_posixacl(s))1003 if (reiserfs_posixacl(s))
1004 s->s_flags |= MS_POSIXACL;1004 s->s_flags |= SB_POSIXACL;
1005 else1005 else
1006 s->s_flags &= ~MS_POSIXACL;1006 s->s_flags &= ~SB_POSIXACL;
1007 1007
1008 return err;1008 return err;
1009}1009}
fs/romfs/super.c+2−2
@@ -451,7 +451,7 @@ static int romfs_statfs(struct dentry *dentry, struct kstatfs *buf) · 450 unmodified lines
451static int romfs_remount(struct super_block *sb, int *flags, char *data)451static int romfs_remount(struct super_block *sb, int *flags, char *data)
452{452{
453 sync_filesystem(sb);453 sync_filesystem(sb);
454 *flags |= MS_RDONLY;454 *flags |= SB_RDONLY;
455 return 0;455 return 0;
456}456}
457 457
@@ -502,7 +502,7 @@ static int romfs_fill_super(struct super_block *sb, void *data, int silent) · 44 unmodified lines
502 502
503 sb->s_maxbytes = 0xFFFFFFFF;503 sb->s_maxbytes = 0xFFFFFFFF;
504 sb->s_magic = ROMFS_MAGIC;504 sb->s_magic = ROMFS_MAGIC;
505 sb->s_flags |= MS_RDONLY | MS_NOATIME;505 sb->s_flags |= SB_RDONLY | SB_NOATIME;
506 sb->s_op = &romfs_super_ops;506 sb->s_op = &romfs_super_ops;
507 507
508#ifdef CONFIG_ROMFS_ON_MTD508#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
195 (u64) le64_to_cpu(sblk->id_table_start));195 (u64) le64_to_cpu(sblk->id_table_start));
196 196
197 sb->s_maxbytes = MAX_LFS_FILESIZE;197 sb->s_maxbytes = MAX_LFS_FILESIZE;
198 sb->s_flags |= MS_RDONLY;198 sb->s_flags |= SB_RDONLY;
199 sb->s_op = &squashfs_super_ops;199 sb->s_op = &squashfs_super_ops;
200 200
201 err = -ENOMEM;201 err = -ENOMEM;
@@ -373,7 +373,7 @@ static int squashfs_statfs(struct dentry *dentry, struct kstatfs *buf) · 171 unmodified lines
373static int squashfs_remount(struct super_block *sb, int *flags, char *data)373static int squashfs_remount(struct super_block *sb, int *flags, char *data)
374{374{
375 sync_filesystem(sb);375 sync_filesystem(sb);
376 *flags |= MS_RDONLY;376 *flags |= SB_RDONLY;
377 return 0;377 return 0;
378}378}
379 379
fs/statfs.c+3−3
@@ -35,11 +35,11 @@ static int flags_by_mnt(int mnt_flags) · 34 unmodified lines
35static int flags_by_sb(int s_flags)35static int flags_by_sb(int s_flags)
36{36{
37 int flags = 0;37 int flags = 0;
38 if (s_flags & MS_SYNCHRONOUS)38 if (s_flags & SB_SYNCHRONOUS)
39 flags |= ST_SYNCHRONOUS;39 flags |= ST_SYNCHRONOUS;
40 if (s_flags & MS_MANDLOCK)40 if (s_flags & SB_MANDLOCK)
41 flags |= ST_MANDLOCK;41 flags |= ST_MANDLOCK;
42 if (s_flags & MS_RDONLY)42 if (s_flags & SB_RDONLY)
43 flags |= ST_RDONLY;43 flags |= ST_RDONLY;
44 return flags;44 return flags;
45}45}
fs/sysfs/mount.c+1−1
@@ -30,7 +30,7 @@ static struct dentry *sysfs_mount(struct file_system_type *fs_type, · 29 unmodified lines
30 void *ns;30 void *ns;
31 bool new_sb;31 bool new_sb;
32 32
33 if (!(flags & MS_KERNMOUNT)) {33 if (!(flags & SB_KERNMOUNT)) {
34 if (!kobj_ns_current_may_mount(KOBJ_NS_TYPE_NET))34 if (!kobj_ns_current_may_mount(KOBJ_NS_TYPE_NET))
35 return ERR_PTR(-EPERM);35 return ERR_PTR(-EPERM);
36 }36 }
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
63 63
64 sync_filesystem(sb);64 sync_filesystem(sb);
65 if (sbi->s_forced_ro)65 if (sbi->s_forced_ro)
66 *flags |= MS_RDONLY;66 *flags |= SB_RDONLY;
67 return 0;67 return 0;
68}68}
69 69
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
333 /* set up enough so that it can read an inode */333 /* set up enough so that it can read an inode */
334 sb->s_op = &sysv_sops;334 sb->s_op = &sysv_sops;
335 if (sbi->s_forced_ro)335 if (sbi->s_forced_ro)
336 sb->s_flags |= MS_RDONLY;336 sb->s_flags |= SB_RDONLY;
337 if (sbi->s_truncate)337 if (sbi->s_truncate)
338 sb->s_d_op = &sysv_dentry_operations;338 sb->s_d_op = &sysv_dentry_operations;
339 root_inode = sysv_iget(sb, SYSV_ROOT_INO);339 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
1406 if (flags & S_MTIME)1406 if (flags & S_MTIME)
1407 inode->i_mtime = *time;1407 inode->i_mtime = *time;
1408 1408
1409 if (!(inode->i_sb->s_flags & MS_LAZYTIME))1409 if (!(inode->i_sb->s_flags & SB_LAZYTIME))
1410 iflags |= I_DIRTY_SYNC;1410 iflags |= I_DIRTY_SYNC;
1411 1411
1412 release = ui->dirty;1412 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
84 if (!c->ro_error) {84 if (!c->ro_error) {
85 c->ro_error = 1;85 c->ro_error = 1;
86 c->no_chk_data_crc = 0;86 c->no_chk_data_crc = 0;
87 c->vfs_sb->s_flags |= MS_RDONLY;87 c->vfs_sb->s_flags |= SB_RDONLY;
88 ubifs_warn(c, "switched to read-only mode, error %d", err);88 ubifs_warn(c, "switched to read-only mode, error %d", err);
89 dump_stack();89 dump_stack();
90 }90 }
fs/ubifs/super.c+10−10
@@ -968,7 +968,7 @@ static int parse_standard_option(const char *option) · 967 unmodified lines
968 968
969 pr_notice("UBIFS: parse %s\n", option);969 pr_notice("UBIFS: parse %s\n", option);
970 if (!strcmp(option, "sync"))970 if (!strcmp(option, "sync"))
971 return MS_SYNCHRONOUS;971 return SB_SYNCHRONOUS;
972 return 0;972 return 0;
973}973}
974 974
@@ -1160,8 +1160,8 @@ static int mount_ubifs(struct ubifs_info *c) · 185 unmodified lines
1160 size_t sz;1160 size_t sz;
1161 1161
1162 c->ro_mount = !!sb_rdonly(c->vfs_sb);1162 c->ro_mount = !!sb_rdonly(c->vfs_sb);
1163 /* Suppress error messages while probing if MS_SILENT is set */1163 /* Suppress error messages while probing if SB_SILENT is set */
1164 c->probing = !!(c->vfs_sb->s_flags & MS_SILENT);1164 c->probing = !!(c->vfs_sb->s_flags & SB_SILENT);
1165 1165
1166 err = init_constants_early(c);1166 err = init_constants_early(c);
1167 if (err)1167 if (err)
@@ -1852,7 +1852,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) · 684 unmodified lines
1852 return err;1852 return err;
1853 }1853 }
1854 1854
1855 if (c->ro_mount && !(*flags & MS_RDONLY)) {1855 if (c->ro_mount && !(*flags & SB_RDONLY)) {
1856 if (c->ro_error) {1856 if (c->ro_error) {
1857 ubifs_msg(c, "cannot re-mount R/W due to prior errors");1857 ubifs_msg(c, "cannot re-mount R/W due to prior errors");
1858 return -EROFS;1858 return -EROFS;
@@ -1864,7 +1864,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) · 5 unmodified lines
1864 err = ubifs_remount_rw(c);1864 err = ubifs_remount_rw(c);
1865 if (err)1865 if (err)
1866 return err;1866 return err;
1867 } else if (!c->ro_mount && (*flags & MS_RDONLY)) {1867 } else if (!c->ro_mount && (*flags & SB_RDONLY)) {
1868 if (c->ro_error) {1868 if (c->ro_error) {
1869 ubifs_msg(c, "cannot re-mount R/O due to prior errors");1869 ubifs_msg(c, "cannot re-mount R/O due to prior errors");
1870 return -EROFS;1870 return -EROFS;
@@ -2117,7 +2117,7 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags, · 246 unmodified lines
2117 */2117 */
2118 ubi = open_ubi(name, UBI_READONLY);2118 ubi = open_ubi(name, UBI_READONLY);
2119 if (IS_ERR(ubi)) {2119 if (IS_ERR(ubi)) {
2120 if (!(flags & MS_SILENT))2120 if (!(flags & SB_SILENT))
2121 pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d",2121 pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d",
2122 current->pid, name, (int)PTR_ERR(ubi));2122 current->pid, name, (int)PTR_ERR(ubi));
2123 return ERR_CAST(ubi);2123 return ERR_CAST(ubi);
@@ -2143,18 +2143,18 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags, · 19 unmodified lines
2143 kfree(c);2143 kfree(c);
2144 /* A new mount point for already mounted UBIFS */2144 /* A new mount point for already mounted UBIFS */
2145 dbg_gen("this ubi volume is already mounted");2145 dbg_gen("this ubi volume is already mounted");
2146 if (!!(flags & MS_RDONLY) != c1->ro_mount) {2146 if (!!(flags & SB_RDONLY) != c1->ro_mount) {
2147 err = -EBUSY;2147 err = -EBUSY;
2148 goto out_deact;2148 goto out_deact;
2149 }2149 }
2150 } else {2150 } 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);
2152 if (err)2152 if (err)
2153 goto out_deact;2153 goto out_deact;
2154 /* We do not support atime */2154 /* We do not support atime */
2155 sb->s_flags |= MS_ACTIVE;2155 sb->s_flags |= SB_ACTIVE;
2156#ifndef CONFIG_UBIFS_ATIME_SUPPORT2156#ifndef CONFIG_UBIFS_ATIME_SUPPORT
2157 sb->s_flags |= MS_NOATIME;2157 sb->s_flags |= SB_NOATIME;
2158#else2158#else
2159 ubifs_msg(c, "full atime support is enabled.");2159 ubifs_msg(c, "full atime support is enabled.");
2160#endif2160#endif
fs/ubifs/ubifs.h+2−2
@@ -1201,7 +1201,7 @@ struct ubifs_debug_info; · 1200 unmodified lines
1201 * @need_recovery: %1 if the file-system needs recovery1201 * @need_recovery: %1 if the file-system needs recovery
1202 * @replaying: %1 during journal replay1202 * @replaying: %1 during journal replay
1203 * @mounting: %1 while mounting1203 * @mounting: %1 while mounting
1204 * @probing: %1 while attempting to mount if MS_SILENT mount flag is set1204 * @probing: %1 while attempting to mount if SB_SILENT mount flag is set
1205 * @remounting_rw: %1 while re-mounting from R/O mode to R/W mode1205 * @remounting_rw: %1 while re-mounting from R/O mode to R/W mode
1206 * @replay_list: temporary list used during journal replay1206 * @replay_list: temporary list used during journal replay
1207 * @replay_buds: list of buds to replay1207 * @replay_buds: list of buds to replay
@@ -1850,7 +1850,7 @@ __printf(2, 3) · 642 unmodified lines
1850void ubifs_warn(const struct ubifs_info *c, const char *fmt, ...);1850void ubifs_warn(const struct ubifs_info *c, const char *fmt, ...);
1851/*1851/*
1852 * A conditional variant of 'ubifs_err()' which doesn't output anything1852 * 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).
1854 */1854 */
1855#define ubifs_errc(c, fmt, ...) \1855#define ubifs_errc(c, fmt, ...) \
1856do { \1856do { \
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
650 sync_filesystem(sb);650 sync_filesystem(sb);
651 if (lvidiu) {651 if (lvidiu) {
652 int write_rev = le16_to_cpu(lvidiu->minUDFWriteRev);652 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))
654 return -EACCES;654 return -EACCES;
655 }655 }
656 656
@@ -673,10 +673,10 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options) · 16 unmodified lines
673 sbi->s_dmode = uopt.dmode;673 sbi->s_dmode = uopt.dmode;
674 write_unlock(&sbi->s_cred_lock);674 write_unlock(&sbi->s_cred_lock);
675 675
676 if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))676 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
677 goto out_unlock;677 goto out_unlock;
678 678
679 if (*flags & MS_RDONLY)679 if (*flags & SB_RDONLY)
680 udf_close_lvid(sb);680 udf_close_lvid(sb);
681 else681 else
682 udf_open_lvid(sb);682 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
115 115
116 ubh_mark_buffer_dirty (USPI_UBH(uspi));116 ubh_mark_buffer_dirty (USPI_UBH(uspi));
117 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));117 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
118 if (sb->s_flags & MS_SYNCHRONOUS)118 if (sb->s_flags & SB_SYNCHRONOUS)
119 ubh_sync_block(UCPI_UBH(ucpi));119 ubh_sync_block(UCPI_UBH(ucpi));
120 ufs_mark_sb_dirty(sb);120 ufs_mark_sb_dirty(sb);
121 121
@@ -205,7 +205,7 @@ do_more: · 83 unmodified lines
205 205
206 ubh_mark_buffer_dirty (USPI_UBH(uspi));206 ubh_mark_buffer_dirty (USPI_UBH(uspi));
207 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));207 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
208 if (sb->s_flags & MS_SYNCHRONOUS)208 if (sb->s_flags & SB_SYNCHRONOUS)
209 ubh_sync_block(UCPI_UBH(ucpi));209 ubh_sync_block(UCPI_UBH(ucpi));
210 210
211 if (overflow) {211 if (overflow) {
@@ -567,7 +567,7 @@ static u64 ufs_add_fragments(struct inode *inode, u64 fragment, · 355 unmodified lines
567 567
568 ubh_mark_buffer_dirty (USPI_UBH(uspi));568 ubh_mark_buffer_dirty (USPI_UBH(uspi));
569 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));569 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
570 if (sb->s_flags & MS_SYNCHRONOUS)570 if (sb->s_flags & SB_SYNCHRONOUS)
571 ubh_sync_block(UCPI_UBH(ucpi));571 ubh_sync_block(UCPI_UBH(ucpi));
572 ufs_mark_sb_dirty(sb);572 ufs_mark_sb_dirty(sb);
573 573
@@ -688,7 +688,7 @@ cg_found: · 114 unmodified lines
688succed:688succed:
689 ubh_mark_buffer_dirty (USPI_UBH(uspi));689 ubh_mark_buffer_dirty (USPI_UBH(uspi));
690 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));690 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
691 if (sb->s_flags & MS_SYNCHRONOUS)691 if (sb->s_flags & SB_SYNCHRONOUS)
692 ubh_sync_block(UCPI_UBH(ucpi));692 ubh_sync_block(UCPI_UBH(ucpi));
693 ufs_mark_sb_dirty(sb);693 ufs_mark_sb_dirty(sb);
694 694
fs/ufs/ialloc.c+5−5
@@ -112,7 +112,7 @@ void ufs_free_inode (struct inode * inode) · 111 unmodified lines
112 112
113 ubh_mark_buffer_dirty (USPI_UBH(uspi));113 ubh_mark_buffer_dirty (USPI_UBH(uspi));
114 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));114 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
115 if (sb->s_flags & MS_SYNCHRONOUS)115 if (sb->s_flags & SB_SYNCHRONOUS)
116 ubh_sync_block(UCPI_UBH(ucpi));116 ubh_sync_block(UCPI_UBH(ucpi));
117 117
118 ufs_mark_sb_dirty(sb);118 ufs_mark_sb_dirty(sb);
@@ -146,14 +146,14 @@ static void ufs2_init_inodes_chunk(struct super_block *sb, · 27 unmodified lines
146 set_buffer_uptodate(bh);146 set_buffer_uptodate(bh);
147 mark_buffer_dirty(bh);147 mark_buffer_dirty(bh);
148 unlock_buffer(bh);148 unlock_buffer(bh);
149 if (sb->s_flags & MS_SYNCHRONOUS)149 if (sb->s_flags & SB_SYNCHRONOUS)
150 sync_dirty_buffer(bh);150 sync_dirty_buffer(bh);
151 brelse(bh);151 brelse(bh);
152 }152 }
153 153
154 fs32_add(sb, &ucg->cg_u.cg_u2.cg_initediblk, uspi->s_inopb);154 fs32_add(sb, &ucg->cg_u.cg_u2.cg_initediblk, uspi->s_inopb);
155 ubh_mark_buffer_dirty(UCPI_UBH(ucpi));155 ubh_mark_buffer_dirty(UCPI_UBH(ucpi));
156 if (sb->s_flags & MS_SYNCHRONOUS)156 if (sb->s_flags & SB_SYNCHRONOUS)
157 ubh_sync_block(UCPI_UBH(ucpi));157 ubh_sync_block(UCPI_UBH(ucpi));
158 158
159 UFSD("EXIT\n");159 UFSD("EXIT\n");
@@ -284,7 +284,7 @@ cg_found: · 124 unmodified lines
284 }284 }
285 ubh_mark_buffer_dirty (USPI_UBH(uspi));285 ubh_mark_buffer_dirty (USPI_UBH(uspi));
286 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));286 ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
287 if (sb->s_flags & MS_SYNCHRONOUS)287 if (sb->s_flags & SB_SYNCHRONOUS)
288 ubh_sync_block(UCPI_UBH(ucpi));288 ubh_sync_block(UCPI_UBH(ucpi));
289 ufs_mark_sb_dirty(sb);289 ufs_mark_sb_dirty(sb);
290 290
@@ -330,7 +330,7 @@ cg_found: · 39 unmodified lines
330 ufs2_inode->ui_birthnsec = cpu_to_fs32(sb, ts.tv_nsec);330 ufs2_inode->ui_birthnsec = cpu_to_fs32(sb, ts.tv_nsec);
331 mark_buffer_dirty(bh);331 mark_buffer_dirty(bh);
332 unlock_buffer(bh);332 unlock_buffer(bh);
333 if (sb->s_flags & MS_SYNCHRONOUS)333 if (sb->s_flags & SB_SYNCHRONOUS)
334 sync_dirty_buffer(bh);334 sync_dirty_buffer(bh);
335 brelse(bh);335 brelse(bh);
336 }336 }
fs/ufs/super.c+15−15
@@ -282,7 +282,7 @@ void ufs_error (struct super_block * sb, const char * function, · 281 unmodified lines
282 usb1->fs_clean = UFS_FSBAD;282 usb1->fs_clean = UFS_FSBAD;
283 ubh_mark_buffer_dirty(USPI_UBH(uspi));283 ubh_mark_buffer_dirty(USPI_UBH(uspi));
284 ufs_mark_sb_dirty(sb);284 ufs_mark_sb_dirty(sb);
285 sb->s_flags |= MS_RDONLY;285 sb->s_flags |= SB_RDONLY;
286 }286 }
287 va_start(args, fmt);287 va_start(args, fmt);
288 vaf.fmt = fmt;288 vaf.fmt = fmt;
@@ -320,7 +320,7 @@ void ufs_panic (struct super_block * sb, const char * function, · 31 unmodified lines
320 va_start(args, fmt);320 va_start(args, fmt);
321 vaf.fmt = fmt;321 vaf.fmt = fmt;
322 vaf.va = &args;322 vaf.va = &args;
323 sb->s_flags |= MS_RDONLY;323 sb->s_flags |= SB_RDONLY;
324 pr_crit("panic (device %s): %s: %pV\n",324 pr_crit("panic (device %s): %s: %pV\n",
325 sb->s_id, function, &vaf);325 sb->s_id, function, &vaf);
326 va_end(args);326 va_end(args);
@@ -905,7 +905,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 578 unmodified lines
905 if (!sb_rdonly(sb)) {905 if (!sb_rdonly(sb)) {
906 if (!silent)906 if (!silent)
907 pr_info("ufstype=old is supported read-only\n");907 pr_info("ufstype=old is supported read-only\n");
908 sb->s_flags |= MS_RDONLY;908 sb->s_flags |= SB_RDONLY;
909 }909 }
910 break;910 break;
911 911
@@ -921,7 +921,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 9 unmodified lines
921 if (!sb_rdonly(sb)) {921 if (!sb_rdonly(sb)) {
922 if (!silent)922 if (!silent)
923 pr_info("ufstype=nextstep is supported read-only\n");923 pr_info("ufstype=nextstep is supported read-only\n");
924 sb->s_flags |= MS_RDONLY;924 sb->s_flags |= SB_RDONLY;
925 }925 }
926 break;926 break;
927 927
@@ -937,7 +937,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 9 unmodified lines
937 if (!sb_rdonly(sb)) {937 if (!sb_rdonly(sb)) {
938 if (!silent)938 if (!silent)
939 pr_info("ufstype=nextstep-cd is supported read-only\n");939 pr_info("ufstype=nextstep-cd is supported read-only\n");
940 sb->s_flags |= MS_RDONLY;940 sb->s_flags |= SB_RDONLY;
941 }941 }
942 break;942 break;
943 943
@@ -953,7 +953,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 9 unmodified lines
953 if (!sb_rdonly(sb)) {953 if (!sb_rdonly(sb)) {
954 if (!silent)954 if (!silent)
955 pr_info("ufstype=openstep is supported read-only\n");955 pr_info("ufstype=openstep is supported read-only\n");
956 sb->s_flags |= MS_RDONLY;956 sb->s_flags |= SB_RDONLY;
957 }957 }
958 break;958 break;
959 959
@@ -968,7 +968,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) · 8 unmodified lines
968 if (!sb_rdonly(sb)) {968 if (!sb_rdonly(sb)) {
969 if (!silent)969 if (!silent)
970 pr_info("ufstype=hp is supported read-only\n");970 pr_info("ufstype=hp is supported read-only\n");
971 sb->s_flags |= MS_RDONLY;971 sb->s_flags |= SB_RDONLY;
972 }972 }
973 break;973 break;
974 default:974 default:
@@ -1125,21 +1125,21 @@ magic_found: · 150 unmodified lines
1125 break;1125 break;
1126 case UFS_FSACTIVE:1126 case UFS_FSACTIVE:
1127 pr_err("%s(): fs is active\n", __func__);1127 pr_err("%s(): fs is active\n", __func__);
1128 sb->s_flags |= MS_RDONLY;1128 sb->s_flags |= SB_RDONLY;
1129 break;1129 break;
1130 case UFS_FSBAD:1130 case UFS_FSBAD:
1131 pr_err("%s(): fs is bad\n", __func__);1131 pr_err("%s(): fs is bad\n", __func__);
1132 sb->s_flags |= MS_RDONLY;1132 sb->s_flags |= SB_RDONLY;
1133 break;1133 break;
1134 default:1134 default:
1135 pr_err("%s(): can't grok fs_clean 0x%x\n",1135 pr_err("%s(): can't grok fs_clean 0x%x\n",
1136 __func__, usb1->fs_clean);1136 __func__, usb1->fs_clean);
1137 sb->s_flags |= MS_RDONLY;1137 sb->s_flags |= SB_RDONLY;
1138 break;1138 break;
1139 }1139 }
1140 } else {1140 } else {
1141 pr_err("%s(): fs needs fsck\n", __func__);1141 pr_err("%s(): fs needs fsck\n", __func__);
1142 sb->s_flags |= MS_RDONLY;1142 sb->s_flags |= SB_RDONLY;
1143 }1143 }
1144 1144
1145 /*1145 /*
@@ -1328,7 +1328,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) · 182 unmodified lines
1328 return -EINVAL;1328 return -EINVAL;
1329 }1329 }
1330 1330
1331 if ((bool)(*mount_flags & MS_RDONLY) == sb_rdonly(sb)) {1331 if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {
1332 UFS_SB(sb)->s_mount_opt = new_mount_opt;1332 UFS_SB(sb)->s_mount_opt = new_mount_opt;
1333 mutex_unlock(&UFS_SB(sb)->s_lock);1333 mutex_unlock(&UFS_SB(sb)->s_lock);
1334 return 0;1334 return 0;
@@ -1337,7 +1337,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) · 2 unmodified lines
1337 /*1337 /*
1338 * fs was mouted as rw, remounting ro1338 * fs was mouted as rw, remounting ro
1339 */1339 */
1340 if (*mount_flags & MS_RDONLY) {1340 if (*mount_flags & SB_RDONLY) {
1341 ufs_put_super_internal(sb);1341 ufs_put_super_internal(sb);
1342 usb1->fs_time = cpu_to_fs32(sb, get_seconds());1342 usb1->fs_time = cpu_to_fs32(sb, get_seconds());
1343 if ((flags & UFS_ST_MASK) == UFS_ST_SUN1343 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
1346 ufs_set_fs_state(sb, usb1, usb3,1346 ufs_set_fs_state(sb, usb1, usb3,
1347 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));1347 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
1348 ubh_mark_buffer_dirty (USPI_UBH(uspi));1348 ubh_mark_buffer_dirty (USPI_UBH(uspi));
1349 sb->s_flags |= MS_RDONLY;1349 sb->s_flags |= SB_RDONLY;
1350 } else {1350 } else {
1351 /*1351 /*
1352 * fs was mounted as ro, remounting rw1352 * 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
1370 mutex_unlock(&UFS_SB(sb)->s_lock);1370 mutex_unlock(&UFS_SB(sb)->s_lock);
1371 return -EPERM;1371 return -EPERM;
1372 }1372 }
1373 sb->s_flags &= ~MS_RDONLY;1373 sb->s_flags &= ~SB_RDONLY;
1374#endif1374#endif
1375 }1375 }
1376 UFS_SB(sb)->s_mount_opt = new_mount_opt;1376 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
781 * something to an unlinked inode, the irele won't cause781 * something to an unlinked inode, the irele won't cause
782 * premature truncation and freeing of the inode, which results782 * premature truncation and freeing of the inode, which results
783 * in log recovery failure. We have to evict the unreferenced783 * in log recovery failure. We have to evict the unreferenced
784 * lru inodes after clearing MS_ACTIVE because we don't784 * lru inodes after clearing SB_ACTIVE because we don't
785 * otherwise clean up the lru if there's a subsequent failure in785 * otherwise clean up the lru if there's a subsequent failure in
786 * xfs_mountfs, which leads to us leaking the inodes if nothing786 * xfs_mountfs, which leads to us leaking the inodes if nothing
787 * else (e.g. quotacheck) references the inodes before the787 * else (e.g. quotacheck) references the inodes before the
788 * mount failure occurs.788 * mount failure occurs.
789 */789 */
790 mp->m_super->s_flags |= MS_ACTIVE;790 mp->m_super->s_flags |= SB_ACTIVE;
791 error = xlog_recover_finish(mp->m_log);791 error = xlog_recover_finish(mp->m_log);
792 if (!error)792 if (!error)
793 xfs_log_work_queue(mp);793 xfs_log_work_queue(mp);
794 mp->m_super->s_flags &= ~MS_ACTIVE;794 mp->m_super->s_flags &= ~SB_ACTIVE;
795 evict_inodes(mp->m_super);795 evict_inodes(mp->m_super);
796 796
797 /*797 /*
fs/xfs/xfs_super.c+4−4
@@ -212,9 +212,9 @@ xfs_parseargs( · 211 unmodified lines
212 */212 */
213 if (sb_rdonly(sb))213 if (sb_rdonly(sb))
214 mp->m_flags |= XFS_MOUNT_RDONLY;214 mp->m_flags |= XFS_MOUNT_RDONLY;
215 if (sb->s_flags & MS_DIRSYNC)215 if (sb->s_flags & SB_DIRSYNC)
216 mp->m_flags |= XFS_MOUNT_DIRSYNC;216 mp->m_flags |= XFS_MOUNT_DIRSYNC;
217 if (sb->s_flags & MS_SYNCHRONOUS)217 if (sb->s_flags & SB_SYNCHRONOUS)
218 mp->m_flags |= XFS_MOUNT_WSYNC;218 mp->m_flags |= XFS_MOUNT_WSYNC;
219 219
220 /*220 /*
@@ -1312,7 +1312,7 @@ xfs_fs_remount( · 1091 unmodified lines
1312 }1312 }
1313 1313
1314 /* ro -> rw */1314 /* ro -> rw */
1315 if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {1315 if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & SB_RDONLY)) {
1316 if (mp->m_flags & XFS_MOUNT_NORECOVERY) {1316 if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
1317 xfs_warn(mp,1317 xfs_warn(mp,
1318 "ro->rw transition prohibited on norecovery mount");1318 "ro->rw transition prohibited on norecovery mount");
@@ -1368,7 +1368,7 @@ xfs_fs_remount( · 49 unmodified lines
1368 }1368 }
1369 1369
1370 /* rw -> ro */1370 /* rw -> ro */
1371 if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {1371 if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & SB_RDONLY)) {
1372 /* Free the per-AG metadata reservation pool. */1372 /* Free the per-AG metadata reservation pool. */
1373 error = xfs_fs_unreserve_ag_blocks(mp);1373 error = xfs_fs_unreserve_ag_blocks(mp);
1374 if (error) {1374 if (error) {
fs/xfs/xfs_super.h+1−1
@@ -30,7 +30,7 @@ extern void xfs_qm_exit(void); · 29 unmodified lines
30 30
31#ifdef CONFIG_XFS_POSIX_ACL31#ifdef CONFIG_XFS_POSIX_ACL
32# define XFS_ACL_STRING "ACLs, "32# 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)
34#else34#else
35# define XFS_ACL_STRING35# define XFS_ACL_STRING
36# define set_posix_acl_flag(sb) do { } while (0)36# 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
1872 */1872 */
1873#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))1873#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
1874 1874
1875static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & MS_RDONLY; }1875static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
1876#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)1876#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
1877#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \1877#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \
1878 ((inode)->i_flags & S_SYNC))1878 ((inode)->i_flags & S_SYNC))
include/uapi/linux/bfs_fs.h+1−1
@@ -76,7 +76,7 @@ struct bfs_super_block { · 75 unmodified lines
76#define BFS_FILEBLOCKS(ip) \76#define BFS_FILEBLOCKS(ip) \
77 ((ip)->i_sblock == 0 ? 0 : (le32_to_cpu((ip)->i_eblock) + 1) - le32_to_cpu((ip)->i_sblock))77 ((ip)->i_sblock == 0 ? 0 : (le32_to_cpu((ip)->i_eblock) + 1) - le32_to_cpu((ip)->i_sblock))
78#define BFS_UNCLEAN(bfs_sb, sb) \78#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))
80 80
81 81
82#endif /* _LINUX_BFS_FS_H */82#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
331 void *data)331 void *data)
332{332{
333 struct ipc_namespace *ns;333 struct ipc_namespace *ns;
334 if (flags & MS_KERNMOUNT) {334 if (flags & SB_KERNMOUNT) {
335 ns = data;335 ns = data;
336 data = NULL;336 data = NULL;
337 } else {337 } 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
3776 * tmpfs instance, limiting inodes to one per page of lowmem;3776 * tmpfs instance, limiting inodes to one per page of lowmem;
3777 * but the internal instance is left unlimited.3777 * but the internal instance is left unlimited.
3778 */3778 */
3779 if (!(sb->s_flags & MS_KERNMOUNT)) {3779 if (!(sb->s_flags & SB_KERNMOUNT)) {
3780 sbinfo->max_blocks = shmem_default_max_blocks();3780 sbinfo->max_blocks = shmem_default_max_blocks();
3781 sbinfo->max_inodes = shmem_default_max_inodes();3781 sbinfo->max_inodes = shmem_default_max_inodes();
3782 if (shmem_parse_options(data, sbinfo, false)) {3782 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
3784 goto failed;3784 goto failed;
3785 }3785 }
3786 } else {3786 } else {
3787 sb->s_flags |= MS_NOUSER;3787 sb->s_flags |= SB_NOUSER;
3788 }3788 }
3789 sb->s_export_op = &shmem_export_ops;3789 sb->s_export_op = &shmem_export_ops;
3790 sb->s_flags |= MS_NOSEC;3790 sb->s_flags |= SB_NOSEC;
3791#else3791#else
3792 sb->s_flags |= MS_NOUSER;3792 sb->s_flags |= SB_NOUSER;
3793#endif3793#endif
3794 3794
3795 spin_lock_init(&sbinfo->stat_lock);3795 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
3809 sb->s_xattr = shmem_xattr_handlers;3809 sb->s_xattr = shmem_xattr_handlers;
3810#endif3810#endif
3811#ifdef CONFIG_TMPFS_POSIX_ACL3811#ifdef CONFIG_TMPFS_POSIX_ACL
3812 sb->s_flags |= MS_POSIXACL;3812 sb->s_flags |= SB_POSIXACL;
3813#endif3813#endif
3814 uuid_gen(&sb->s_uuid);3814 uuid_gen(&sb->s_uuid);
3815 3815
security/apparmor/apparmorfs.c+1−1
@@ -2451,7 +2451,7 @@ static int __init aa_create_aafs(void) · 2450 unmodified lines
2451 aafs_mnt = kern_mount(&aafs_ops);2451 aafs_mnt = kern_mount(&aafs_ops);
2452 if (IS_ERR(aafs_mnt))2452 if (IS_ERR(aafs_mnt))
2453 panic("can't set apparmorfs up\n");2453 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;
2455 2455
2456 /* Populate fs tree. */2456 /* Populate fs tree. */
2457 error = entry_create_dir(&aa_sfs_entry, NULL);2457 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
86 86
87static inline bool path_mediated_fs(struct dentry *dentry)87static inline bool path_mediated_fs(struct dentry *dentry)
88{88{
89 return !(dentry->d_sb->s_flags & MS_NOUSER);89 return !(dentry->d_sb->s_flags & SB_NOUSER);
90}90}
91 91
92 92

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