mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

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

Requested-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Linus Torvalds 2017-11-27 13:05:09 -08:00
parent 141cbfba1d
commit 1751e8a6cb
111 changed files with 417 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/mtd/mtdsuper.c
View File

@ -79,14 +79,14 @@ static struct dentry *mount_mtd_aux(struct file_system_type *fs_type, int flags,
pr_debug("MTDSB: New superblock for device %d (\"%s\")\n", pr_debug("MTDSB: New superblock for device %d (\"%s\")\n",
mtd->index, mtd->name); mtd->index, mtd->name);
ret = fill_super(sb, data, flags & MS_SILENT ? 1 : 0); ret = fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
if (ret < 0) { if (ret < 0) {
deactivate_locked_super(sb); deactivate_locked_super(sb);
return ERR_PTR(ret); return ERR_PTR(ret);
} }
/* go */ /* go */
sb->s_flags |= MS_ACTIVE; sb->s_flags |= SB_ACTIVE;
return dget(sb->s_root); return dget(sb->s_root);
/* new mountpoint for an already mounted superblock */ /* new mountpoint for an already mounted superblock */
@ -202,7 +202,7 @@ struct dentry *mount_mtd(struct file_system_type *fs_type, int flags,
not_an_MTD_device: not_an_MTD_device:
#endif /* CONFIG_BLOCK */ #endif /* CONFIG_BLOCK */
if (!(flags & MS_SILENT)) if (!(flags & SB_SILENT))
printk(KERN_NOTICE printk(KERN_NOTICE
"MTD: Attempt to mount non-MTD device \"%s\"\n", "MTD: Attempt to mount non-MTD device \"%s\"\n",
dev_name); dev_name);

2
drivers/staging/lustre/lustre/llite/file.c
View File

@ -1016,7 +1016,7 @@ static bool file_is_noatime(const struct file *file)
if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)) if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
return true; return true;
if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)) if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode))
return true; return true;
return false; return false;

14
drivers/staging/lustre/lustre/llite/llite_lib.c
View File

@ -313,11 +313,11 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt,
} }
if (data->ocd_connect_flags & OBD_CONNECT_ACL) { if (data->ocd_connect_flags & OBD_CONNECT_ACL) {
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
sbi->ll_flags |= LL_SBI_ACL; sbi->ll_flags |= LL_SBI_ACL;
} else { } else {
LCONSOLE_INFO("client wants to enable acl, but mdt not!\n"); LCONSOLE_INFO("client wants to enable acl, but mdt not!\n");
sb->s_flags &= ~MS_POSIXACL; sb->s_flags &= ~SB_POSIXACL;
sbi->ll_flags &= ~LL_SBI_ACL; sbi->ll_flags &= ~LL_SBI_ACL;
} }
@ -660,7 +660,7 @@ void ll_kill_super(struct super_block *sb)
struct ll_sb_info *sbi; struct ll_sb_info *sbi;
/* not init sb ?*/ /* not init sb ?*/
if (!(sb->s_flags & MS_ACTIVE)) if (!(sb->s_flags & SB_ACTIVE))
return; return;
sbi = ll_s2sbi(sb); sbi = ll_s2sbi(sb);
@ -2039,8 +2039,8 @@ int ll_remount_fs(struct super_block *sb, int *flags, char *data)
int err; int err;
__u32 read_only; __u32 read_only;
if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) { if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
read_only = *flags & MS_RDONLY; read_only = *flags & SB_RDONLY;
err = obd_set_info_async(NULL, sbi->ll_md_exp, err = obd_set_info_async(NULL, sbi->ll_md_exp,
sizeof(KEY_READ_ONLY), sizeof(KEY_READ_ONLY),
KEY_READ_ONLY, sizeof(read_only), KEY_READ_ONLY, sizeof(read_only),
@ -2053,9 +2053,9 @@ int ll_remount_fs(struct super_block *sb, int *flags, char *data)
} }
if (read_only) if (read_only)
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
else else
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
if (sbi->ll_flags & LL_SBI_VERBOSE) if (sbi->ll_flags & LL_SBI_VERBOSE)
LCONSOLE_WARN("Remounted %s %s\n", profilenm, LCONSOLE_WARN("Remounted %s %s\n", profilenm,

6
fs/9p/vfs_super.c
View File

@ -94,13 +94,13 @@ v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses,
if (v9ses->cache) if (v9ses->cache)
sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_SIZE; sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_SIZE;
sb->s_flags |= MS_ACTIVE | MS_DIRSYNC | MS_NOATIME; sb->s_flags |= SB_ACTIVE | SB_DIRSYNC | SB_NOATIME;
if (!v9ses->cache) if (!v9ses->cache)
sb->s_flags |= MS_SYNCHRONOUS; sb->s_flags |= SB_SYNCHRONOUS;
#ifdef CONFIG_9P_FS_POSIX_ACL #ifdef CONFIG_9P_FS_POSIX_ACL
if ((v9ses->flags & V9FS_ACL_MASK) == V9FS_POSIX_ACL) if ((v9ses->flags & V9FS_ACL_MASK) == V9FS_POSIX_ACL)
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
#endif #endif
return 0; return 0;

4
fs/adfs/super.c
View File

@ -213,7 +213,7 @@ static int parse_options(struct super_block *sb, char *options)
static int adfs_remount(struct super_block *sb, int *flags, char *data) static int adfs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_NODIRATIME; *flags |= SB_NODIRATIME;
return parse_options(sb, data); return parse_options(sb, data);
} }
@ -372,7 +372,7 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
struct inode *root; struct inode *root;
int ret = -EINVAL; int ret = -EINVAL;
sb->s_flags |= MS_NODIRATIME; sb->s_flags |= SB_NODIRATIME;
asb = kzalloc(sizeof(*asb), GFP_KERNEL); asb = kzalloc(sizeof(*asb), GFP_KERNEL);
if (!asb) if (!asb)

2
fs/affs/amigaffs.c
View File

@ -453,7 +453,7 @@ affs_error(struct super_block *sb, const char *function, const char *fmt, ...)
pr_crit("error (device %s): %s(): %pV\n", sb->s_id, function, &vaf); pr_crit("error (device %s): %s(): %pV\n", sb->s_id, function, &vaf);
if (!sb_rdonly(sb)) if (!sb_rdonly(sb))
pr_warn("Remounting filesystem read-only\n"); pr_warn("Remounting filesystem read-only\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
va_end(args); va_end(args);
} }

6
fs/affs/bitmap.c
View File

@ -250,12 +250,12 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
int i, res = 0; int i, res = 0;
struct affs_sb_info *sbi = AFFS_SB(sb); struct affs_sb_info *sbi = AFFS_SB(sb);
if (*flags & MS_RDONLY) if (*flags & SB_RDONLY)
return 0; return 0;
if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) { if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {
pr_notice("Bitmap invalid - mounting %s read only\n", sb->s_id); pr_notice("Bitmap invalid - mounting %s read only\n", sb->s_id);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }
@ -288,7 +288,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
if (affs_checksum_block(sb, bh)) { if (affs_checksum_block(sb, bh)) {
pr_warn("Bitmap %u invalid - mounting %s read only.\n", pr_warn("Bitmap %u invalid - mounting %s read only.\n",
bm->bm_key, sb->s_id); bm->bm_key, sb->s_id);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
goto out; goto out;
} }
pr_debug("read bitmap block %d: %d\n", blk, bm->bm_key); pr_debug("read bitmap block %d: %d\n", blk, bm->bm_key);

16
fs/affs/super.c
View File

@ -356,7 +356,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
sb->s_magic = AFFS_SUPER_MAGIC; sb->s_magic = AFFS_SUPER_MAGIC;
sb->s_op = &affs_sops; sb->s_op = &affs_sops;
sb->s_flags |= MS_NODIRATIME; sb->s_flags |= SB_NODIRATIME;
sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL); sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
if (!sbi) if (!sbi)
@ -466,7 +466,7 @@ got_root:
if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
|| chksum == MUFS_DCOFS) && !sb_rdonly(sb)) { || chksum == MUFS_DCOFS) && !sb_rdonly(sb)) {
pr_notice("Dircache FS - mounting %s read only\n", sb->s_id); pr_notice("Dircache FS - mounting %s read only\n", sb->s_id);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
switch (chksum) { switch (chksum) {
case MUFS_FS: case MUFS_FS:
@ -488,7 +488,7 @@ got_root:
/* fall thru */ /* fall thru */
case FS_OFS: case FS_OFS:
affs_set_opt(sbi->s_flags, SF_OFS); affs_set_opt(sbi->s_flags, SF_OFS);
sb->s_flags |= MS_NOEXEC; sb->s_flags |= SB_NOEXEC;
break; break;
case MUFS_DCOFS: case MUFS_DCOFS:
case MUFS_INTLOFS: case MUFS_INTLOFS:
@ -497,7 +497,7 @@ got_root:
case FS_INTLOFS: case FS_INTLOFS:
affs_set_opt(sbi->s_flags, SF_INTL); affs_set_opt(sbi->s_flags, SF_INTL);
affs_set_opt(sbi->s_flags, SF_OFS); affs_set_opt(sbi->s_flags, SF_OFS);
sb->s_flags |= MS_NOEXEC; sb->s_flags |= SB_NOEXEC;
break; break;
default: default:
pr_err("Unknown filesystem on device %s: %08X\n", pr_err("Unknown filesystem on device %s: %08X\n",
@ -513,7 +513,7 @@ got_root:
sig, sig[3] + '0', blocksize); sig, sig[3] + '0', blocksize);
} }
sb->s_flags |= MS_NODEV | MS_NOSUID; sb->s_flags |= SB_NODEV | SB_NOSUID;
sbi->s_data_blksize = sb->s_blocksize; sbi->s_data_blksize = sb->s_blocksize;
if (affs_test_opt(sbi->s_flags, SF_OFS)) if (affs_test_opt(sbi->s_flags, SF_OFS))
@ -570,7 +570,7 @@ affs_remount(struct super_block *sb, int *flags, char *data)
pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data); pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data);
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_NODIRATIME; *flags |= SB_NODIRATIME;
memcpy(volume, sbi->s_volume, 32); memcpy(volume, sbi->s_volume, 32);
if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block, if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block,
@ -596,10 +596,10 @@ affs_remount(struct super_block *sb, int *flags, char *data)
memcpy(sbi->s_volume, volume, 32); memcpy(sbi->s_volume, volume, 32);
spin_unlock(&sbi->symlink_lock); spin_unlock(&sbi->symlink_lock);
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
return 0; return 0;
if (*flags & MS_RDONLY) if (*flags & SB_RDONLY)
affs_free_bitmap(sb); affs_free_bitmap(sb);
else else
res = affs_init_bitmap(sb, flags); res = affs_init_bitmap(sb, flags);

4
fs/afs/super.c
View File

@ -496,10 +496,10 @@ static struct dentry *afs_mount(struct file_system_type *fs_type,
if (ret < 0) if (ret < 0)
goto error_sb; goto error_sb;
as = NULL; as = NULL;
sb->s_flags |= MS_ACTIVE; sb->s_flags |= SB_ACTIVE;
} else { } else {
_debug("reuse"); _debug("reuse");
ASSERTCMP(sb->s_flags, &, MS_ACTIVE); ASSERTCMP(sb->s_flags, &, SB_ACTIVE);
afs_destroy_sbi(as); afs_destroy_sbi(as);
as = NULL; as = NULL;
} }

2
fs/befs/ChangeLog
View File

@ -365,7 +365,7 @@ Version 0.4 (2001-10-28)
(fs/befs/super.c) (fs/befs/super.c)
* Tell the kernel to only mount befs read-only. * Tell the kernel to only mount befs read-only.
By setting the MS_RDONLY flag in befs_read_super(). By setting the SB_RDONLY flag in befs_read_super().
Not that it was possible to write before. But now the kernel won't even try. Not that it was possible to write before. But now the kernel won't even try.
(fs/befs/super.c) (fs/befs/super.c)

4
fs/befs/linuxvfs.c
View File

@ -841,7 +841,7 @@ befs_fill_super(struct super_block *sb, void *data, int silent)
if (!sb_rdonly(sb)) { if (!sb_rdonly(sb)) {
befs_warning(sb, befs_warning(sb,
"No write support. Marking filesystem read-only"); "No write support. Marking filesystem read-only");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
/* /*
@ -948,7 +948,7 @@ static int
befs_remount(struct super_block *sb, int *flags, char *data) befs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
if (!(*flags & MS_RDONLY)) if (!(*flags & SB_RDONLY))
return -EINVAL; return -EINVAL;
return 0; return 0;
} }

2
fs/btrfs/ctree.h
View File

@ -2957,7 +2957,7 @@ static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
*/ */
static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info) static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
{ {
return fs_info->sb->s_flags & MS_RDONLY || btrfs_fs_closing(fs_info); return fs_info->sb->s_flags & SB_RDONLY || btrfs_fs_closing(fs_info);
} }
static inline void free_fs_info(struct btrfs_fs_info *fs_info) static inline void free_fs_info(struct btrfs_fs_info *fs_info)

2
fs/btrfs/extent_io.c
View File

@ -1984,7 +1984,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start,
struct btrfs_bio *bbio = NULL; struct btrfs_bio *bbio = NULL;
int ret; int ret;
ASSERT(!(fs_info->sb->s_flags & MS_RDONLY)); ASSERT(!(fs_info->sb->s_flags & SB_RDONLY));
BUG_ON(!mirror_num); BUG_ON(!mirror_num);
bio = btrfs_io_bio_alloc(1); bio = btrfs_io_bio_alloc(1);

4
fs/btrfs/ioctl.c
View File

@ -1172,7 +1172,7 @@ again:
if (!i_done || ret) if (!i_done || ret)
goto out; goto out;
if (!(inode->i_sb->s_flags & MS_ACTIVE)) if (!(inode->i_sb->s_flags & SB_ACTIVE))
goto out; goto out;
/* /*
@ -1333,7 +1333,7 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
* make sure we stop running if someone unmounts * make sure we stop running if someone unmounts
* the FS * the FS
*/ */
if (!(inode->i_sb->s_flags & MS_ACTIVE)) if (!(inode->i_sb->s_flags & SB_ACTIVE))
break; break;
if (btrfs_defrag_cancelled(fs_info)) { if (btrfs_defrag_cancelled(fs_info)) {

50
fs/btrfs/super.c
View File

@ -107,7 +107,7 @@ static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
return; return;
if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
btrfs_info(fs_info, "forced readonly"); btrfs_info(fs_info, "forced readonly");
/* /*
* Note that a running device replace operation is not * 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
/* /*
* Special case: if the error is EROFS, and we're already * Special case: if the error is EROFS, and we're already
* under MS_RDONLY, then it is safe here. * under SB_RDONLY, then it is safe here.
*/ */
if (errno == -EROFS && sb_rdonly(sb)) if (errno == -EROFS && sb_rdonly(sb))
return; return;
@ -168,7 +168,7 @@ void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function
set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state); set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
/* Don't go through full error handling during mount */ /* Don't go through full error handling during mount */
if (sb->s_flags & MS_BORN) if (sb->s_flags & SB_BORN)
btrfs_handle_error(fs_info); btrfs_handle_error(fs_info);
} }
@ -625,7 +625,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
break; break;
case Opt_acl: case Opt_acl:
#ifdef CONFIG_BTRFS_FS_POSIX_ACL #ifdef CONFIG_BTRFS_FS_POSIX_ACL
info->sb->s_flags |= MS_POSIXACL; info->sb->s_flags |= SB_POSIXACL;
break; break;
#else #else
btrfs_err(info, "support for ACL not compiled in!"); btrfs_err(info, "support for ACL not compiled in!");
@ -633,7 +633,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
goto out; goto out;
#endif #endif
case Opt_noacl: case Opt_noacl:
info->sb->s_flags &= ~MS_POSIXACL; info->sb->s_flags &= ~SB_POSIXACL;
break; break;
case Opt_notreelog: case Opt_notreelog:
btrfs_set_and_info(info, NOTREELOG, btrfs_set_and_info(info, NOTREELOG,
@ -851,7 +851,7 @@ check:
/* /*
* Extra check for current option against current flag * Extra check for current option against current flag
*/ */
if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & MS_RDONLY)) { if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & SB_RDONLY)) {
btrfs_err(info, btrfs_err(info,
"nologreplay must be used with ro mount option"); "nologreplay must be used with ro mount option");
ret = -EINVAL; ret = -EINVAL;
@ -1147,7 +1147,7 @@ static int btrfs_fill_super(struct super_block *sb,
sb->s_xattr = btrfs_xattr_handlers; sb->s_xattr = btrfs_xattr_handlers;
sb->s_time_gran = 1; sb->s_time_gran = 1;
#ifdef CONFIG_BTRFS_FS_POSIX_ACL #ifdef CONFIG_BTRFS_FS_POSIX_ACL
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
#endif #endif
sb->s_flags |= SB_I_VERSION; sb->s_flags |= SB_I_VERSION;
sb->s_iflags |= SB_I_CGROUPWB; sb->s_iflags |= SB_I_CGROUPWB;
@ -1180,7 +1180,7 @@ static int btrfs_fill_super(struct super_block *sb,
} }
cleancache_init_fs(sb); cleancache_init_fs(sb);
sb->s_flags |= MS_ACTIVE; sb->s_flags |= SB_ACTIVE;
return 0; return 0;
fail_close: fail_close:
@ -1277,7 +1277,7 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
seq_puts(seq, ",flushoncommit"); seq_puts(seq, ",flushoncommit");
if (btrfs_test_opt(info, DISCARD)) if (btrfs_test_opt(info, DISCARD))
seq_puts(seq, ",discard"); seq_puts(seq, ",discard");
if (!(info->sb->s_flags & MS_POSIXACL)) if (!(info->sb->s_flags & SB_POSIXACL))
seq_puts(seq, ",noacl"); seq_puts(seq, ",noacl");
if (btrfs_test_opt(info, SPACE_CACHE)) if (btrfs_test_opt(info, SPACE_CACHE))
seq_puts(seq, ",space_cache"); seq_puts(seq, ",space_cache");
@ -1409,11 +1409,11 @@ static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid,
mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name, newargs); mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name, newargs);
if (PTR_ERR_OR_ZERO(mnt) == -EBUSY) { if (PTR_ERR_OR_ZERO(mnt) == -EBUSY) {
if (flags & MS_RDONLY) { if (flags & SB_RDONLY) {
mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~MS_RDONLY, mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~SB_RDONLY,
device_name, newargs); device_name, newargs);
} else { } else {
mnt = vfs_kern_mount(&btrfs_fs_type, flags | MS_RDONLY, mnt = vfs_kern_mount(&btrfs_fs_type, flags | SB_RDONLY,
device_name, newargs); device_name, newargs);
if (IS_ERR(mnt)) { if (IS_ERR(mnt)) {
root = ERR_CAST(mnt); root = ERR_CAST(mnt);
@ -1565,7 +1565,7 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
u64 subvol_objectid = 0; u64 subvol_objectid = 0;
int error = 0; int error = 0;
if (!(flags & MS_RDONLY)) if (!(flags & SB_RDONLY))
mode |= FMODE_WRITE; mode |= FMODE_WRITE;
error = btrfs_parse_early_options(data, mode, fs_type, 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,
if (error) if (error)
goto error_fs_info; goto error_fs_info;
if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) { if (!(flags & SB_RDONLY) && fs_devices->rw_devices == 0) {
error = -EACCES; error = -EACCES;
goto error_close_devices; goto error_close_devices;
} }
bdev = fs_devices->latest_bdev; bdev = fs_devices->latest_bdev;
s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC, s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | SB_NOSEC,
fs_info); fs_info);
if (IS_ERR(s)) { if (IS_ERR(s)) {
error = PTR_ERR(s); error = PTR_ERR(s);
@ -1635,7 +1635,7 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
if (s->s_root) { if (s->s_root) {
btrfs_close_devices(fs_devices); btrfs_close_devices(fs_devices);
free_fs_info(fs_info); free_fs_info(fs_info);
if ((flags ^ s->s_flags) & MS_RDONLY) if ((flags ^ s->s_flags) & SB_RDONLY)
error = -EBUSY; error = -EBUSY;
} else { } else {
snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev); 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,
{ {
if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) && if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
(!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
(flags & MS_RDONLY))) { (flags & SB_RDONLY))) {
/* wait for any defraggers to finish */ /* wait for any defraggers to finish */
wait_event(fs_info->transaction_wait, wait_event(fs_info->transaction_wait,
(atomic_read(&fs_info->defrag_running) == 0)); (atomic_read(&fs_info->defrag_running) == 0));
if (flags & MS_RDONLY) if (flags & SB_RDONLY)
sync_filesystem(fs_info->sb); sync_filesystem(fs_info->sb);
} }
} }
@ -1766,10 +1766,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
btrfs_resize_thread_pool(fs_info, btrfs_resize_thread_pool(fs_info,
fs_info->thread_pool_size, old_thread_pool_size); fs_info->thread_pool_size, old_thread_pool_size);
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
goto out; goto out;
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
/* /*
* this also happens on 'umount -rf' or on shutdown, when * this also happens on 'umount -rf' or on shutdown, when
* the filesystem is busy. * the filesystem is busy.
@ -1781,10 +1781,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
/* avoid complains from lockdep et al. */ /* avoid complains from lockdep et al. */
up(&fs_info->uuid_tree_rescan_sem); up(&fs_info->uuid_tree_rescan_sem);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
/* /*
* Setting MS_RDONLY will put the cleaner thread to * Setting SB_RDONLY will put the cleaner thread to
* sleep at the next loop if it's already active. * sleep at the next loop if it's already active.
* If it's already asleep, we'll leave unused block * If it's already asleep, we'll leave unused block
* groups on disk until we're mounted read-write again * 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)
goto restore; goto restore;
} }
} }
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
set_bit(BTRFS_FS_OPEN, &fs_info->flags); set_bit(BTRFS_FS_OPEN, &fs_info->flags);
} }
@ -1866,9 +1866,9 @@ out:
return 0; return 0;
restore: restore:
/* We've hit an error - don't reset MS_RDONLY */ /* We've hit an error - don't reset SB_RDONLY */
if (sb_rdonly(sb)) if (sb_rdonly(sb))
old_flags |= MS_RDONLY; old_flags |= SB_RDONLY;
sb->s_flags = old_flags; sb->s_flags = old_flags;
fs_info->mount_opt = old_opts; fs_info->mount_opt = old_opts;
fs_info->compress_type = old_compress_type; fs_info->compress_type = old_compress_type;

4
fs/btrfs/volumes.c
View File

@ -2384,7 +2384,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
if (seeding_dev) { if (seeding_dev) {
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
ret = btrfs_prepare_sprout(fs_info); ret = btrfs_prepare_sprout(fs_info);
if (ret) { if (ret) {
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
@ -2497,7 +2497,7 @@ error_sysfs:
btrfs_sysfs_rm_device_link(fs_info->fs_devices, device); btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
error_trans: error_trans:
if (seeding_dev) if (seeding_dev)
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
if (trans) if (trans)
btrfs_end_transaction(trans); btrfs_end_transaction(trans);
rcu_string_free(device->name); rcu_string_free(device->name);

8
fs/ceph/super.c
View File

@ -331,11 +331,11 @@ static int parse_fsopt_token(char *c, void *private)
break; break;
#ifdef CONFIG_CEPH_FS_POSIX_ACL #ifdef CONFIG_CEPH_FS_POSIX_ACL
case Opt_acl: case Opt_acl:
fsopt->sb_flags |= MS_POSIXACL; fsopt->sb_flags |= SB_POSIXACL;
break; break;
#endif #endif
case Opt_noacl: case Opt_noacl:
fsopt->sb_flags &= ~MS_POSIXACL; fsopt->sb_flags &= ~SB_POSIXACL;
break; break;
default: default:
BUG_ON(token); BUG_ON(token);
@ -520,7 +520,7 @@ static int ceph_show_options(struct seq_file *m, struct dentry *root)
seq_puts(m, ",nopoolperm"); seq_puts(m, ",nopoolperm");
#ifdef CONFIG_CEPH_FS_POSIX_ACL #ifdef CONFIG_CEPH_FS_POSIX_ACL
if (fsopt->sb_flags & MS_POSIXACL) if (fsopt->sb_flags & SB_POSIXACL)
seq_puts(m, ",acl"); seq_puts(m, ",acl");
else else
seq_puts(m, ",noacl"); seq_puts(m, ",noacl");
@ -988,7 +988,7 @@ static struct dentry *ceph_mount(struct file_system_type *fs_type,
dout("ceph_mount\n"); dout("ceph_mount\n");
#ifdef CONFIG_CEPH_FS_POSIX_ACL #ifdef CONFIG_CEPH_FS_POSIX_ACL
flags |= MS_POSIXACL; flags |= SB_POSIXACL;
#endif #endif
err = parse_mount_options(&fsopt, &opt, flags, data, dev_name); err = parse_mount_options(&fsopt, &opt, flags, data, dev_name);
if (err < 0) { if (err < 0) {

2
fs/cifs/cifs_fs_sb.h
View File

@ -42,7 +42,7 @@
#define CIFS_MOUNT_MULTIUSER 0x20000 /* multiuser mount */ #define CIFS_MOUNT_MULTIUSER 0x20000 /* multiuser mount */
#define CIFS_MOUNT_STRICT_IO 0x40000 /* strict cache mode */ #define CIFS_MOUNT_STRICT_IO 0x40000 /* strict cache mode */
#define CIFS_MOUNT_RWPIDFORWARD 0x80000 /* use pid forwarding for rw */ #define CIFS_MOUNT_RWPIDFORWARD 0x80000 /* use pid forwarding for rw */
#define CIFS_MOUNT_POSIXACL 0x100000 /* mirror of MS_POSIXACL in mnt_cifs_flags */ #define CIFS_MOUNT_POSIXACL 0x100000 /* mirror of SB_POSIXACL in mnt_cifs_flags */
#define CIFS_MOUNT_CIFS_BACKUPUID 0x200000 /* backup intent bit for a user */ #define CIFS_MOUNT_CIFS_BACKUPUID 0x200000 /* backup intent bit for a user */
#define CIFS_MOUNT_CIFS_BACKUPGID 0x400000 /* backup intent bit for a group */ #define CIFS_MOUNT_CIFS_BACKUPGID 0x400000 /* backup intent bit for a group */
#define CIFS_MOUNT_MAP_SFM_CHR 0x800000 /* SFM/MAC mapping for illegal chars */ #define CIFS_MOUNT_MAP_SFM_CHR 0x800000 /* SFM/MAC mapping for illegal chars */

12
fs/cifs/cifsfs.c
View File

@ -125,7 +125,7 @@ cifs_read_super(struct super_block *sb)
tcon = cifs_sb_master_tcon(cifs_sb); tcon = cifs_sb_master_tcon(cifs_sb);
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL) if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files) if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_maxbytes = MAX_LFS_FILESIZE;
@ -497,7 +497,7 @@ cifs_show_options(struct seq_file *s, struct dentry *root)
seq_puts(s, ",cifsacl"); seq_puts(s, ",cifsacl");
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
seq_puts(s, ",dynperm"); seq_puts(s, ",dynperm");
if (root->d_sb->s_flags & MS_POSIXACL) if (root->d_sb->s_flags & SB_POSIXACL)
seq_puts(s, ",acl"); seq_puts(s, ",acl");
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
seq_puts(s, ",mfsymlinks"); seq_puts(s, ",mfsymlinks");
@ -573,7 +573,7 @@ static int cifs_show_stats(struct seq_file *s, struct dentry *root)
static int cifs_remount(struct super_block *sb, int *flags, char *data) static int cifs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_NODIRATIME; *flags |= SB_NODIRATIME;
return 0; return 0;
} }
@ -708,7 +708,7 @@ cifs_do_mount(struct file_system_type *fs_type,
rc = cifs_mount(cifs_sb, volume_info); rc = cifs_mount(cifs_sb, volume_info);
if (rc) { if (rc) {
if (!(flags & MS_SILENT)) if (!(flags & SB_SILENT))
cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n", cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
rc); rc);
root = ERR_PTR(rc); root = ERR_PTR(rc);
@ -720,7 +720,7 @@ cifs_do_mount(struct file_system_type *fs_type,
mnt_data.flags = flags; mnt_data.flags = flags;
/* BB should we make this contingent on mount parm? */ /* BB should we make this contingent on mount parm? */
flags |= MS_NODIRATIME | MS_NOATIME; flags |= SB_NODIRATIME | SB_NOATIME;
sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data); sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
if (IS_ERR(sb)) { if (IS_ERR(sb)) {
@ -739,7 +739,7 @@ cifs_do_mount(struct file_system_type *fs_type,
goto out_super; goto out_super;
} }
sb->s_flags |= MS_ACTIVE; sb->s_flags |= SB_ACTIVE;
} }
root = cifs_get_root(volume_info, sb); root = cifs_get_root(volume_info, sb);

4
fs/cifs/cifsglob.h
View File

@ -559,8 +559,8 @@ struct smb_vol {
CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \ CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID) CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
#define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \ #define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \
MS_NODEV | MS_SYNCHRONOUS) SB_NODEV | SB_SYNCHRONOUS)
struct cifs_mnt_data { struct cifs_mnt_data {
struct cifs_sb_info *cifs_sb; struct cifs_sb_info *cifs_sb;

2
fs/cifs/inode.c
View File

@ -985,7 +985,7 @@ retry_iget5_locked:
} }
cifs_fattr_to_inode(inode, fattr); cifs_fattr_to_inode(inode, fattr);
if (sb->s_flags & MS_NOATIME) if (sb->s_flags & SB_NOATIME)
inode->i_flags |= S_NOATIME | S_NOCMTIME; inode->i_flags |= S_NOATIME | S_NOCMTIME;
if (inode->i_state & I_NEW) { if (inode->i_state & I_NEW) {
inode->i_ino = hash; inode->i_ino = hash;

8
fs/cifs/xattr.c
View File

@ -117,7 +117,7 @@ static int cifs_xattr_set(const struct xattr_handler *handler,
#ifdef CONFIG_CIFS_POSIX #ifdef CONFIG_CIFS_POSIX
if (!value) if (!value)
goto out; goto out;
if (sb->s_flags & MS_POSIXACL) if (sb->s_flags & SB_POSIXACL)
rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
value, (const int)size, value, (const int)size,
ACL_TYPE_ACCESS, cifs_sb->local_nls, ACL_TYPE_ACCESS, cifs_sb->local_nls,
@ -129,7 +129,7 @@ static int cifs_xattr_set(const struct xattr_handler *handler,
#ifdef CONFIG_CIFS_POSIX #ifdef CONFIG_CIFS_POSIX
if (!value) if (!value)
goto out; goto out;
if (sb->s_flags & MS_POSIXACL) if (sb->s_flags & SB_POSIXACL)
rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
value, (const int)size, value, (const int)size,
ACL_TYPE_DEFAULT, cifs_sb->local_nls, ACL_TYPE_DEFAULT, cifs_sb->local_nls,
@ -266,7 +266,7 @@ static int cifs_xattr_get(const struct xattr_handler *handler,
case XATTR_ACL_ACCESS: case XATTR_ACL_ACCESS:
#ifdef CONFIG_CIFS_POSIX #ifdef CONFIG_CIFS_POSIX
if (sb->s_flags & MS_POSIXACL) if (sb->s_flags & SB_POSIXACL)
rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
value, size, ACL_TYPE_ACCESS, value, size, ACL_TYPE_ACCESS,
cifs_sb->local_nls, cifs_sb->local_nls,
@ -276,7 +276,7 @@ static int cifs_xattr_get(const struct xattr_handler *handler,
case XATTR_ACL_DEFAULT: case XATTR_ACL_DEFAULT:
#ifdef CONFIG_CIFS_POSIX #ifdef CONFIG_CIFS_POSIX
if (sb->s_flags & MS_POSIXACL) if (sb->s_flags & SB_POSIXACL)
rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
value, size, ACL_TYPE_DEFAULT, value, size, ACL_TYPE_DEFAULT,
cifs_sb->local_nls, cifs_sb->local_nls,

4
fs/coda/inode.c
View File

@ -96,7 +96,7 @@ void coda_destroy_inodecache(void)
static int coda_remount(struct super_block *sb, int *flags, char *data) static int coda_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_NOATIME; *flags |= SB_NOATIME;
return 0; return 0;
} }
@ -188,7 +188,7 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
mutex_unlock(&vc->vc_mutex); mutex_unlock(&vc->vc_mutex);
sb->s_fs_info = vc; sb->s_fs_info = vc;
sb->s_flags |= MS_NOATIME; sb->s_flags |= SB_NOATIME;
sb->s_blocksize = 4096; /* XXXXX what do we put here?? */ sb->s_blocksize = 4096; /* XXXXX what do we put here?? */
sb->s_blocksize_bits = 12; sb->s_blocksize_bits = 12;
sb->s_magic = CODA_SUPER_MAGIC; sb->s_magic = CODA_SUPER_MAGIC;

4
fs/cramfs/inode.c
View File

@ -505,7 +505,7 @@ static void cramfs_kill_sb(struct super_block *sb)
static int cramfs_remount(struct super_block *sb, int *flags, char *data) static int cramfs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }
@ -592,7 +592,7 @@ static int cramfs_finalize_super(struct super_block *sb,
struct inode *root; struct inode *root;
/* Set it all up.. */ /* Set it all up.. */
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
sb->s_op = &cramfs_ops; sb->s_op = &cramfs_ops;
root = get_cramfs_inode(sb, cramfs_root, 0); root = get_cramfs_inode(sb, cramfs_root, 0);
if (IS_ERR(root)) if (IS_ERR(root))

8
fs/ecryptfs/main.c
View File

@ -560,8 +560,8 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
* Set the POSIX ACL flag based on whether they're enabled in the lower * Set the POSIX ACL flag based on whether they're enabled in the lower
* mount. * mount.
*/ */
s->s_flags = flags & ~MS_POSIXACL; s->s_flags = flags & ~SB_POSIXACL;
s->s_flags |= path.dentry->d_sb->s_flags & MS_POSIXACL; s->s_flags |= path.dentry->d_sb->s_flags & SB_POSIXACL;
/** /**
* Force a read-only eCryptfs mount when: * Force a read-only eCryptfs mount when:
@ -569,7 +569,7 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
* 2) The ecryptfs_encrypted_view mount option is specified * 2) The ecryptfs_encrypted_view mount option is specified
*/ */
if (sb_rdonly(path.dentry->d_sb) || mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED) if (sb_rdonly(path.dentry->d_sb) || mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
s->s_flags |= MS_RDONLY; s->s_flags |= SB_RDONLY;
s->s_maxbytes = path.dentry->d_sb->s_maxbytes; s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
s->s_blocksize = path.dentry->d_sb->s_blocksize; 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
ecryptfs_set_dentry_private(s->s_root, root_info); ecryptfs_set_dentry_private(s->s_root, root_info);
root_info->lower_path = path; root_info->lower_path = path;
s->s_flags |= MS_ACTIVE; s->s_flags |= SB_ACTIVE;
return dget(s->s_root); return dget(s->s_root);
out_free: out_free:

4
fs/efs/super.c
View File

@ -116,7 +116,7 @@ static void destroy_inodecache(void)
static int efs_remount(struct super_block *sb, int *flags, char *data) static int efs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }
@ -311,7 +311,7 @@ static int efs_fill_super(struct super_block *s, void *d, int silent)
#ifdef DEBUG #ifdef DEBUG
pr_info("forcing read-only mode\n"); pr_info("forcing read-only mode\n");
#endif #endif
s->s_flags |= MS_RDONLY; s->s_flags |= SB_RDONLY;
} }
s->s_op = &efs_superblock_operations; s->s_op = &efs_superblock_operations;
s->s_export_op = &efs_export_ops; s->s_export_op = &efs_export_ops;

4
fs/ext2/balloc.c
View File

@ -548,7 +548,7 @@ do_more:
} }
mark_buffer_dirty(bitmap_bh); mark_buffer_dirty(bitmap_bh);
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
sync_dirty_buffer(bitmap_bh); sync_dirty_buffer(bitmap_bh);
group_adjust_blocks(sb, block_group, desc, bh2, group_freed); group_adjust_blocks(sb, block_group, desc, bh2, group_freed);
@ -1424,7 +1424,7 @@ allocated:
percpu_counter_sub(&sbi->s_freeblocks_counter, num); percpu_counter_sub(&sbi->s_freeblocks_counter, num);
mark_buffer_dirty(bitmap_bh); mark_buffer_dirty(bitmap_bh);
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
sync_dirty_buffer(bitmap_bh); sync_dirty_buffer(bitmap_bh);
*errp = 0; *errp = 0;

4
fs/ext2/ialloc.c
View File

@ -145,7 +145,7 @@ void ext2_free_inode (struct inode * inode)
else else
ext2_release_inode(sb, block_group, is_directory); ext2_release_inode(sb, block_group, is_directory);
mark_buffer_dirty(bitmap_bh); mark_buffer_dirty(bitmap_bh);
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
sync_dirty_buffer(bitmap_bh); sync_dirty_buffer(bitmap_bh);
brelse(bitmap_bh); brelse(bitmap_bh);
@ -517,7 +517,7 @@ repeat_in_this_group:
goto fail; goto fail;
got: got:
mark_buffer_dirty(bitmap_bh); mark_buffer_dirty(bitmap_bh);
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
sync_dirty_buffer(bitmap_bh); sync_dirty_buffer(bitmap_bh);
brelse(bitmap_bh); brelse(bitmap_bh);

20
fs/ext2/super.c
View File

@ -75,7 +75,7 @@ void ext2_error(struct super_block *sb, const char *function,
if (test_opt(sb, ERRORS_RO)) { if (test_opt(sb, ERRORS_RO)) {
ext2_msg(sb, KERN_CRIT, ext2_msg(sb, KERN_CRIT,
"error: remounting filesystem read-only"); "error: remounting filesystem read-only");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
} }
@ -656,7 +656,7 @@ static int ext2_setup_super (struct super_block * sb,
ext2_msg(sb, KERN_ERR, ext2_msg(sb, KERN_ERR,
"error: revision level too high, " "error: revision level too high, "
"forcing read-only mode"); "forcing read-only mode");
res = MS_RDONLY; res = SB_RDONLY;
} }
if (read_only) if (read_only)
return res; return res;
@ -924,9 +924,9 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
sbi->s_resuid = opts.s_resuid; sbi->s_resuid = opts.s_resuid;
sbi->s_resgid = opts.s_resgid; sbi->s_resgid = opts.s_resgid;
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
MS_POSIXACL : 0); SB_POSIXACL : 0);
sb->s_iflags |= SB_I_CGROUPWB; sb->s_iflags |= SB_I_CGROUPWB;
if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV && 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)
ext2_msg(sb, KERN_WARNING, ext2_msg(sb, KERN_WARNING,
"warning: mounting ext3 filesystem as ext2"); "warning: mounting ext3 filesystem as ext2");
if (ext2_setup_super (sb, es, sb_rdonly(sb))) if (ext2_setup_super (sb, es, sb_rdonly(sb)))
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ext2_write_super(sb); ext2_write_super(sb);
return 0; return 0;
@ -1341,9 +1341,9 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data)
"dax flag with busy inodes while remounting"); "dax flag with busy inodes while remounting");
new_opts.s_mount_opt ^= EXT2_MOUNT_DAX; new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;
} }
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
goto out_set; goto out_set;
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
if (le16_to_cpu(es->s_state) & EXT2_VALID_FS || if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
!(sbi->s_mount_state & EXT2_VALID_FS)) !(sbi->s_mount_state & EXT2_VALID_FS))
goto out_set; goto out_set;
@ -1379,7 +1379,7 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data)
*/ */
sbi->s_mount_state = le16_to_cpu(es->s_state); sbi->s_mount_state = le16_to_cpu(es->s_state);
if (!ext2_setup_super (sb, es, 0)) if (!ext2_setup_super (sb, es, 0))
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
spin_unlock(&sbi->s_lock); spin_unlock(&sbi->s_lock);
ext2_write_super(sb); ext2_write_super(sb);
@ -1392,8 +1392,8 @@ out_set:
sbi->s_mount_opt = new_opts.s_mount_opt; sbi->s_mount_opt = new_opts.s_mount_opt;
sbi->s_resuid = new_opts.s_resuid; sbi->s_resuid = new_opts.s_resuid;
sbi->s_resgid = new_opts.s_resgid; sbi->s_resgid = new_opts.s_resgid;
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0); ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? SB_POSIXACL : 0);
spin_unlock(&sbi->s_lock); spin_unlock(&sbi->s_lock);
return 0; return 0;

4
fs/ext4/inode.c
View File

@ -2742,7 +2742,7 @@ static int ext4_writepages(struct address_space *mapping,
* If the filesystem has aborted, it is read-only, so return * If the filesystem has aborted, it is read-only, so return
* right away instead of dumping stack traces later on that * right away instead of dumping stack traces later on that
* will obscure the real source of the problem. We test * will obscure the real source of the problem. We test
* EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because * EXT4_MF_FS_ABORTED instead of sb->s_flag's SB_RDONLY because
* the latter could be true if the filesystem is mounted * the latter could be true if the filesystem is mounted
* read-only, and in that case, ext4_writepages should * read-only, and in that case, ext4_writepages should
* *never* be called, so if that ever happens, we would want * *never* be called, so if that ever happens, we would want
@ -5183,7 +5183,7 @@ static int ext4_do_update_inode(handle_t *handle,
ext4_inode_csum_set(inode, raw_inode, ei); ext4_inode_csum_set(inode, raw_inode, ei);
spin_unlock(&ei->i_raw_lock); spin_unlock(&ei->i_raw_lock);
if (inode->i_sb->s_flags & MS_LAZYTIME) if (inode->i_sb->s_flags & SB_LAZYTIME)
ext4_update_other_inodes_time(inode->i_sb, inode->i_ino, ext4_update_other_inodes_time(inode->i_sb, inode->i_ino,
bh->b_data); bh->b_data);

52
fs/ext4/super.c
View File

@ -422,7 +422,7 @@ static void ext4_handle_error(struct super_block *sb)
* before ->s_flags update * before ->s_flags update
*/ */
smp_wmb(); smp_wmb();
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
if (test_opt(sb, ERRORS_PANIC)) { if (test_opt(sb, ERRORS_PANIC)) {
if (EXT4_SB(sb)->s_journal && if (EXT4_SB(sb)->s_journal &&
@ -635,7 +635,7 @@ void __ext4_abort(struct super_block *sb, const char *function,
* before ->s_flags update * before ->s_flags update
*/ */
smp_wmb(); smp_wmb();
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
if (EXT4_SB(sb)->s_journal) if (EXT4_SB(sb)->s_journal)
jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO); jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
save_error_info(sb, function, line); save_error_info(sb, function, line);
@ -1682,10 +1682,10 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
sb->s_flags |= SB_I_VERSION; sb->s_flags |= SB_I_VERSION;
return 1; return 1;
case Opt_lazytime: case Opt_lazytime:
sb->s_flags |= MS_LAZYTIME; sb->s_flags |= SB_LAZYTIME;
return 1; return 1;
case Opt_nolazytime: case Opt_nolazytime:
sb->s_flags &= ~MS_LAZYTIME; sb->s_flags &= ~SB_LAZYTIME;
return 1; return 1;
} }
@ -2116,7 +2116,7 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) { if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
ext4_msg(sb, KERN_ERR, "revision level too high, " ext4_msg(sb, KERN_ERR, "revision level too high, "
"forcing read-only mode"); "forcing read-only mode");
res = MS_RDONLY; res = SB_RDONLY;
} }
if (read_only) if (read_only)
goto done; goto done;
@ -2429,7 +2429,7 @@ static void ext4_orphan_cleanup(struct super_block *sb,
if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) { if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
/* don't clear list on RO mount w/ errors */ /* don't clear list on RO mount w/ errors */
if (es->s_last_orphan && !(s_flags & MS_RDONLY)) { if (es->s_last_orphan && !(s_flags & SB_RDONLY)) {
ext4_msg(sb, KERN_INFO, "Errors on filesystem, " ext4_msg(sb, KERN_INFO, "Errors on filesystem, "
"clearing orphan list.\n"); "clearing orphan list.\n");
es->s_last_orphan = 0; es->s_last_orphan = 0;
@ -2438,19 +2438,19 @@ static void ext4_orphan_cleanup(struct super_block *sb,
return; return;
} }
if (s_flags & MS_RDONLY) { if (s_flags & SB_RDONLY) {
ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs"); ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
} }
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
/* Needed for iput() to work correctly and not trash data */ /* Needed for iput() to work correctly and not trash data */
sb->s_flags |= MS_ACTIVE; sb->s_flags |= SB_ACTIVE;
/* /*
* Turn on quotas which were not enabled for read-only mounts if * Turn on quotas which were not enabled for read-only mounts if
* filesystem has quota feature, so that they are updated correctly. * filesystem has quota feature, so that they are updated correctly.
*/ */
if (ext4_has_feature_quota(sb) && (s_flags & MS_RDONLY)) { if (ext4_has_feature_quota(sb) && (s_flags & SB_RDONLY)) {
int ret = ext4_enable_quotas(sb); int ret = ext4_enable_quotas(sb);
if (!ret) if (!ret)
@ -2539,7 +2539,7 @@ static void ext4_orphan_cleanup(struct super_block *sb,
} }
} }
#endif #endif
sb->s_flags = s_flags; /* Restore MS_RDONLY status */ sb->s_flags = s_flags; /* Restore SB_RDONLY status */
} }
/* /*
@ -2741,7 +2741,7 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly)
if (ext4_has_feature_readonly(sb)) { if (ext4_has_feature_readonly(sb)) {
ext4_msg(sb, KERN_INFO, "filesystem is read-only"); ext4_msg(sb, KERN_INFO, "filesystem is read-only");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
return 1; return 1;
} }
@ -3623,8 +3623,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
sb->s_iflags |= SB_I_CGROUPWB; sb->s_iflags |= SB_I_CGROUPWB;
} }
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
(test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0); (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV && if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
(ext4_has_compat_features(sb) || (ext4_has_compat_features(sb) ||
@ -4199,7 +4199,7 @@ no_journal:
} }
if (ext4_setup_super(sb, es, sb_rdonly(sb))) if (ext4_setup_super(sb, es, sb_rdonly(sb)))
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
/* determine the minimum size of new large inodes, if present */ /* determine the minimum size of new large inodes, if present */
if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE && 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)
* the clock is set in the future, and this will cause e2fsck * the clock is set in the future, and this will cause e2fsck
* to complain and force a full file system check. * to complain and force a full file system check.
*/ */
if (!(sb->s_flags & MS_RDONLY)) if (!(sb->s_flags & SB_RDONLY))
es->s_wtime = cpu_to_le32(get_seconds()); es->s_wtime = cpu_to_le32(get_seconds());
if (sb->s_bdev->bd_part) if (sb->s_bdev->bd_part)
es->s_kbytes_written = es->s_kbytes_written =
@ -5047,8 +5047,8 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)
ext4_abort(sb, "Abort forced by user"); ext4_abort(sb, "Abort forced by user");
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
(test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0); (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
es = sbi->s_es; es = sbi->s_es;
@ -5057,16 +5057,16 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
set_task_ioprio(sbi->s_journal->j_task, journal_ioprio); set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
} }
if (*flags & MS_LAZYTIME) if (*flags & SB_LAZYTIME)
sb->s_flags |= MS_LAZYTIME; sb->s_flags |= SB_LAZYTIME;
if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) { if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) { if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {
err = -EROFS; err = -EROFS;
goto restore_opts; goto restore_opts;
} }
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
err = sync_filesystem(sb); err = sync_filesystem(sb);
if (err < 0) if (err < 0)
goto restore_opts; goto restore_opts;
@ -5078,7 +5078,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
* First of all, the unconditional stuff we have to do * First of all, the unconditional stuff we have to do
* to disable replay of the journal when we next remount * to disable replay of the journal when we next remount
*/ */
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
/* /*
* OK, test if we are remounting a valid rw partition * 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)
ext4_clear_journal_err(sb, es); ext4_clear_journal_err(sb, es);
sbi->s_mount_state = le16_to_cpu(es->s_state); sbi->s_mount_state = le16_to_cpu(es->s_state);
if (!ext4_setup_super(sb, es, 0)) if (!ext4_setup_super(sb, es, 0))
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
if (ext4_has_feature_mmp(sb)) if (ext4_has_feature_mmp(sb))
if (ext4_multi_mount_protect(sb, if (ext4_multi_mount_protect(sb,
le64_to_cpu(es->s_mmp_block))) { le64_to_cpu(es->s_mmp_block))) {
@ -5164,7 +5164,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
} }
ext4_setup_system_zone(sb); ext4_setup_system_zone(sb);
if (sbi->s_journal == NULL && !(old_sb_flags & MS_RDONLY)) if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY))
ext4_commit_super(sb, 1); ext4_commit_super(sb, 1);
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
@ -5182,7 +5182,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
} }
#endif #endif
*flags = (*flags & ~MS_LAZYTIME) | (sb->s_flags & MS_LAZYTIME); *flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data); ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data);
kfree(orig_data); kfree(orig_data);
return 0; return 0;

10
fs/f2fs/checkpoint.c
View File

@ -617,17 +617,17 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi)
if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG)) if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
return 0; return 0;
if (s_flags & MS_RDONLY) { if (s_flags & SB_RDONLY) {
f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs"); f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");
sbi->sb->s_flags &= ~MS_RDONLY; sbi->sb->s_flags &= ~SB_RDONLY;
} }
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
/* Needed for iput() to work correctly and not trash data */ /* Needed for iput() to work correctly and not trash data */
sbi->sb->s_flags |= MS_ACTIVE; sbi->sb->s_flags |= SB_ACTIVE;
/* Turn on quotas so that they are updated correctly */ /* Turn on quotas so that they are updated correctly */
quota_enabled = f2fs_enable_quota_files(sbi, s_flags & MS_RDONLY); quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
#endif #endif
start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi); start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
@ -658,7 +658,7 @@ out:
if (quota_enabled) if (quota_enabled)
f2fs_quota_off_umount(sbi->sb); f2fs_quota_off_umount(sbi->sb);
#endif #endif
sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */ sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
return err; return err;
} }

2
fs/f2fs/f2fs.h
View File

@ -2378,7 +2378,7 @@ static inline bool f2fs_skip_inode_update(struct inode *inode, int dsync)
static inline int f2fs_readonly(struct super_block *sb) static inline int f2fs_readonly(struct super_block *sb)
{ {
return sb->s_flags & MS_RDONLY; return sb->s_flags & SB_RDONLY;
} }
static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi) static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)

2
fs/f2fs/gc.c
View File

@ -1005,7 +1005,7 @@ int f2fs_gc(struct f2fs_sb_info *sbi, bool sync,
cpc.reason = __get_cp_reason(sbi); cpc.reason = __get_cp_reason(sbi);
gc_more: gc_more:
if (unlikely(!(sbi->sb->s_flags & MS_ACTIVE))) { if (unlikely(!(sbi->sb->s_flags & SB_ACTIVE))) {
ret = -EINVAL; ret = -EINVAL;
goto stop; goto stop;
} }

10
fs/f2fs/recovery.c
View File

@ -598,16 +598,16 @@ int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
int quota_enabled; int quota_enabled;
#endif #endif
if (s_flags & MS_RDONLY) { if (s_flags & SB_RDONLY) {
f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs"); f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");
sbi->sb->s_flags &= ~MS_RDONLY; sbi->sb->s_flags &= ~SB_RDONLY;
} }
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
/* Needed for iput() to work correctly and not trash data */ /* Needed for iput() to work correctly and not trash data */
sbi->sb->s_flags |= MS_ACTIVE; sbi->sb->s_flags |= SB_ACTIVE;
/* Turn on quotas so that they are updated correctly */ /* Turn on quotas so that they are updated correctly */
quota_enabled = f2fs_enable_quota_files(sbi, s_flags & MS_RDONLY); quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
#endif #endif
fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry", fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
@ -671,7 +671,7 @@ out:
if (quota_enabled) if (quota_enabled)
f2fs_quota_off_umount(sbi->sb); f2fs_quota_off_umount(sbi->sb);
#endif #endif
sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */ sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
return ret ? ret: err; return ret ? ret: err;
} }

28
fs/f2fs/super.c
View File

@ -534,10 +534,10 @@ static int parse_options(struct super_block *sb, char *options)
#endif #endif
break; break;
case Opt_lazytime: case Opt_lazytime:
sb->s_flags |= MS_LAZYTIME; sb->s_flags |= SB_LAZYTIME;
break; break;
case Opt_nolazytime: case Opt_nolazytime:
sb->s_flags &= ~MS_LAZYTIME; sb->s_flags &= ~SB_LAZYTIME;
break; break;
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
case Opt_quota: case Opt_quota:
@ -1168,7 +1168,7 @@ static void default_options(struct f2fs_sb_info *sbi)
set_opt(sbi, INLINE_DENTRY); set_opt(sbi, INLINE_DENTRY);
set_opt(sbi, EXTENT_CACHE); set_opt(sbi, EXTENT_CACHE);
set_opt(sbi, NOHEAP); set_opt(sbi, NOHEAP);
sbi->sb->s_flags |= MS_LAZYTIME; sbi->sb->s_flags |= SB_LAZYTIME;
set_opt(sbi, FLUSH_MERGE); set_opt(sbi, FLUSH_MERGE);
if (f2fs_sb_mounted_blkzoned(sbi->sb)) { if (f2fs_sb_mounted_blkzoned(sbi->sb)) {
set_opt_mode(sbi, F2FS_MOUNT_LFS); set_opt_mode(sbi, F2FS_MOUNT_LFS);
@ -1236,7 +1236,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
#endif #endif
/* recover superblocks we couldn't write due to previous RO mount */ /* recover superblocks we couldn't write due to previous RO mount */
if (!(*flags & MS_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) { if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
err = f2fs_commit_super(sbi, false); err = f2fs_commit_super(sbi, false);
f2fs_msg(sb, KERN_INFO, f2fs_msg(sb, KERN_INFO,
"Try to recover all the superblocks, ret: %d", err); "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)
* Previous and new state of filesystem is RO, * Previous and new state of filesystem is RO,
* so skip checking GC and FLUSH_MERGE conditions. * so skip checking GC and FLUSH_MERGE conditions.
*/ */
if (f2fs_readonly(sb) && (*flags & MS_RDONLY)) if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
goto skip; goto skip;
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
if (!f2fs_readonly(sb) && (*flags & MS_RDONLY)) { if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
err = dquot_suspend(sb, -1); err = dquot_suspend(sb, -1);
if (err < 0) if (err < 0)
goto restore_opts; goto restore_opts;
} else { } else {
/* dquot_resume needs RW */ /* dquot_resume needs RW */
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
if (sb_any_quota_suspended(sb)) { if (sb_any_quota_suspended(sb)) {
dquot_resume(sb, -1); dquot_resume(sb, -1);
} else if (f2fs_sb_has_quota_ino(sb)) { } else if (f2fs_sb_has_quota_ino(sb)) {
@ -1288,7 +1288,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
* or if background_gc = off is passed in mount * or if background_gc = off is passed in mount
* option. Also sync the filesystem. * option. Also sync the filesystem.
*/ */
if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) { if ((*flags & SB_RDONLY) || !test_opt(sbi, BG_GC)) {
if (sbi->gc_thread) { if (sbi->gc_thread) {
stop_gc_thread(sbi); stop_gc_thread(sbi);
need_restart_gc = true; need_restart_gc = true;
@ -1300,7 +1300,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
need_stop_gc = true; need_stop_gc = true;
} }
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
writeback_inodes_sb(sb, WB_REASON_SYNC); writeback_inodes_sb(sb, WB_REASON_SYNC);
sync_inodes_sb(sb); sync_inodes_sb(sb);
@ -1314,7 +1314,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
* We stop issue flush thread if FS is mounted as RO * We stop issue flush thread if FS is mounted as RO
* or if flush_merge is not passed in mount option. * or if flush_merge is not passed in mount option.
*/ */
if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) { if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
clear_opt(sbi, FLUSH_MERGE); clear_opt(sbi, FLUSH_MERGE);
destroy_flush_cmd_control(sbi, false); destroy_flush_cmd_control(sbi, false);
} else { } else {
@ -1329,8 +1329,8 @@ skip:
kfree(s_qf_names[i]); kfree(s_qf_names[i]);
#endif #endif
/* Update the POSIXACL Flag */ /* Update the POSIXACL Flag */
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
return 0; return 0;
restore_gc: restore_gc:
@ -2472,8 +2472,8 @@ try_onemore:
sb->s_export_op = &f2fs_export_ops; sb->s_export_op = &f2fs_export_ops;
sb->s_magic = F2FS_SUPER_MAGIC; sb->s_magic = F2FS_SUPER_MAGIC;
sb->s_time_gran = 1; sb->s_time_gran = 1;
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid)); memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
/* init f2fs-specific super block info */ /* init f2fs-specific super block info */

6
fs/fat/fatent.c
View File

@ -392,7 +392,7 @@ static int fat_mirror_bhs(struct super_block *sb, struct buffer_head **bhs,
memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize); memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize);
set_buffer_uptodate(c_bh); set_buffer_uptodate(c_bh);
mark_buffer_dirty_inode(c_bh, sbi->fat_inode); mark_buffer_dirty_inode(c_bh, sbi->fat_inode);
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
err = sync_dirty_buffer(c_bh); err = sync_dirty_buffer(c_bh);
brelse(c_bh); brelse(c_bh);
if (err) if (err)
@ -597,7 +597,7 @@ int fat_free_clusters(struct inode *inode, int cluster)
} }
if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) { if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {
if (sb->s_flags & MS_SYNCHRONOUS) { if (sb->s_flags & SB_SYNCHRONOUS) {
err = fat_sync_bhs(bhs, nr_bhs); err = fat_sync_bhs(bhs, nr_bhs);
if (err) if (err)
goto error; goto error;
@ -612,7 +612,7 @@ int fat_free_clusters(struct inode *inode, int cluster)
fat_collect_bhs(bhs, &nr_bhs, &fatent); fat_collect_bhs(bhs, &nr_bhs, &fatent);
} while (cluster != FAT_ENT_EOF); } while (cluster != FAT_ENT_EOF);
if (sb->s_flags & MS_SYNCHRONOUS) { if (sb->s_flags & SB_SYNCHRONOUS) {
err = fat_sync_bhs(bhs, nr_bhs); err = fat_sync_bhs(bhs, nr_bhs);
if (err) if (err)
goto error; goto error;

8
fs/fat/inode.c
View File

@ -781,12 +781,12 @@ static int fat_remount(struct super_block *sb, int *flags, char *data)
{ {
int new_rdonly; int new_rdonly;
struct msdos_sb_info *sbi = MSDOS_SB(sb); struct msdos_sb_info *sbi = MSDOS_SB(sb);
*flags |= MS_NODIRATIME | (sbi->options.isvfat ? 0 : MS_NOATIME); *flags |= SB_NODIRATIME | (sbi->options.isvfat ? 0 : SB_NOATIME);
sync_filesystem(sb); sync_filesystem(sb);
/* make sure we update state on remount. */ /* make sure we update state on remount. */
new_rdonly = *flags & MS_RDONLY; new_rdonly = *flags & SB_RDONLY;
if (new_rdonly != sb_rdonly(sb)) { if (new_rdonly != sb_rdonly(sb)) {
if (new_rdonly) if (new_rdonly)
fat_set_state(sb, 0, 0); fat_set_state(sb, 0, 0);
@ -1352,7 +1352,7 @@ out:
if (opts->unicode_xlate) if (opts->unicode_xlate)
opts->utf8 = 0; opts->utf8 = 0;
if (opts->nfs == FAT_NFS_NOSTALE_RO) { if (opts->nfs == FAT_NFS_NOSTALE_RO) {
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
sb->s_export_op = &fat_export_ops_nostale; sb->s_export_op = &fat_export_ops_nostale;
} }
@ -1608,7 +1608,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
return -ENOMEM; return -ENOMEM;
sb->s_fs_info = sbi; sb->s_fs_info = sbi;
sb->s_flags |= MS_NODIRATIME; sb->s_flags |= SB_NODIRATIME;
sb->s_magic = MSDOS_SUPER_MAGIC; sb->s_magic = MSDOS_SUPER_MAGIC;
sb->s_op = &fat_sops; sb->s_op = &fat_sops;
sb->s_export_op = &fat_export_ops; sb->s_export_op = &fat_export_ops;

2
fs/fat/misc.c
View File

@ -33,7 +33,7 @@ void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...)
if (opts->errors == FAT_ERRORS_PANIC) if (opts->errors == FAT_ERRORS_PANIC)
panic("FAT-fs (%s): fs panic from previous error\n", sb->s_id); panic("FAT-fs (%s): fs panic from previous error\n", sb->s_id);
else if (opts->errors == FAT_ERRORS_RO && !sb_rdonly(sb)) { else if (opts->errors == FAT_ERRORS_RO && !sb_rdonly(sb)) {
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
fat_msg(sb, KERN_ERR, "Filesystem has been set read-only"); fat_msg(sb, KERN_ERR, "Filesystem has been set read-only");
} }
} }

2
fs/fat/namei_msdos.c
View File

@ -646,7 +646,7 @@ static void setup(struct super_block *sb)
{ {
MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations; MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;
sb->s_d_op = &msdos_dentry_operations; sb->s_d_op = &msdos_dentry_operations;
sb->s_flags |= MS_NOATIME; sb->s_flags |= SB_NOATIME;
} }
static int msdos_fill_super(struct super_block *sb, void *data, int silent) static int msdos_fill_super(struct super_block *sb, void *data, int silent)

4
fs/freevxfs/vxfs_super.c
View File

@ -116,7 +116,7 @@ vxfs_statfs(struct dentry *dentry, struct kstatfs *bufp)
static int vxfs_remount(struct super_block *sb, int *flags, char *data) static int vxfs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }
@ -220,7 +220,7 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
int ret = -EINVAL; int ret = -EINVAL;
u32 j; u32 j;
sbp->s_flags |= MS_RDONLY; sbp->s_flags |= SB_RDONLY;
infp = kzalloc(sizeof(*infp), GFP_KERNEL); infp = kzalloc(sizeof(*infp), GFP_KERNEL);
if (!infp) { if (!infp) {

2
fs/fs-writeback.c
View File

@ -490,7 +490,7 @@ static void inode_switch_wbs(struct inode *inode, int new_wb_id)
/* while holding I_WB_SWITCH, no one else can update the association */ /* while holding I_WB_SWITCH, no one else can update the association */
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (!(inode->i_sb->s_flags & MS_ACTIVE) || if (!(inode->i_sb->s_flags & SB_ACTIVE) ||
inode->i_state & (I_WB_SWITCH | I_FREEING) || inode->i_state & (I_WB_SWITCH | I_FREEING) ||
inode_to_wb(inode) == isw->new_wb) { inode_to_wb(inode) == isw->new_wb) {
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);

12
fs/fuse/inode.c
View File

@ -130,7 +130,7 @@ static void fuse_evict_inode(struct inode *inode)
{ {
truncate_inode_pages_final(&inode->i_data); truncate_inode_pages_final(&inode->i_data);
clear_inode(inode); clear_inode(inode);
if (inode->i_sb->s_flags & MS_ACTIVE) { if (inode->i_sb->s_flags & SB_ACTIVE) {
struct fuse_conn *fc = get_fuse_conn(inode); struct fuse_conn *fc = get_fuse_conn(inode);
struct fuse_inode *fi = get_fuse_inode(inode); struct fuse_inode *fi = get_fuse_inode(inode);
fuse_queue_forget(fc, fi->forget, fi->nodeid, fi->nlookup); fuse_queue_forget(fc, fi->forget, fi->nodeid, fi->nlookup);
@ -141,7 +141,7 @@ static void fuse_evict_inode(struct inode *inode)
static int fuse_remount_fs(struct super_block *sb, int *flags, char *data) static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
if (*flags & MS_MANDLOCK) if (*flags & SB_MANDLOCK)
return -EINVAL; return -EINVAL;
return 0; return 0;
@ -1056,10 +1056,10 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
int is_bdev = sb->s_bdev != NULL; int is_bdev = sb->s_bdev != NULL;
err = -EINVAL; err = -EINVAL;
if (sb->s_flags & MS_MANDLOCK) if (sb->s_flags & SB_MANDLOCK)
goto err; goto err;
sb->s_flags &= ~(MS_NOSEC | SB_I_VERSION); sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION);
if (!parse_fuse_opt(data, &d, is_bdev)) if (!parse_fuse_opt(data, &d, is_bdev))
goto err; goto err;
@ -1109,9 +1109,9 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
goto err_dev_free; goto err_dev_free;
/* Handle umasking inside the fuse code */ /* Handle umasking inside the fuse code */
if (sb->s_flags & MS_POSIXACL) if (sb->s_flags & SB_POSIXACL)
fc->dont_mask = 1; fc->dont_mask = 1;
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
fc->default_permissions = d.default_permissions; fc->default_permissions = d.default_permissions;
fc->allow_other = d.allow_other; fc->allow_other = d.allow_other;

16
fs/gfs2/ops_fstype.c
View File

@ -1065,15 +1065,15 @@ static int fill_super(struct super_block *sb, struct gfs2_args *args, int silent
sdp->sd_args = *args; sdp->sd_args = *args;
if (sdp->sd_args.ar_spectator) { if (sdp->sd_args.ar_spectator) {
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
set_bit(SDF_RORECOVERY, &sdp->sd_flags); set_bit(SDF_RORECOVERY, &sdp->sd_flags);
} }
if (sdp->sd_args.ar_posix_acl) if (sdp->sd_args.ar_posix_acl)
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
if (sdp->sd_args.ar_nobarrier) if (sdp->sd_args.ar_nobarrier)
set_bit(SDF_NOBARRIERS, &sdp->sd_flags); set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
sb->s_flags |= MS_NOSEC; sb->s_flags |= SB_NOSEC;
sb->s_magic = GFS2_MAGIC; sb->s_magic = GFS2_MAGIC;
sb->s_op = &gfs2_super_ops; sb->s_op = &gfs2_super_ops;
sb->s_d_op = &gfs2_dops; sb->s_d_op = &gfs2_dops;
@ -1257,7 +1257,7 @@ static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
struct gfs2_args args; struct gfs2_args args;
struct gfs2_sbd *sdp; struct gfs2_sbd *sdp;
if (!(flags & MS_RDONLY)) if (!(flags & SB_RDONLY))
mode |= FMODE_WRITE; mode |= FMODE_WRITE;
bdev = blkdev_get_by_path(dev_name, mode, fs_type); 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,
if (s->s_root) { if (s->s_root) {
error = -EBUSY; error = -EBUSY;
if ((flags ^ s->s_flags) & MS_RDONLY) if ((flags ^ s->s_flags) & SB_RDONLY)
goto error_super; goto error_super;
} else { } else {
snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev); snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
sb_set_blocksize(s, block_size(bdev)); sb_set_blocksize(s, block_size(bdev));
error = fill_super(s, &args, flags & MS_SILENT ? 1 : 0); error = fill_super(s, &args, flags & SB_SILENT ? 1 : 0);
if (error) if (error)
goto error_super; goto error_super;
s->s_flags |= MS_ACTIVE; s->s_flags |= SB_ACTIVE;
bdev->bd_super = s; bdev->bd_super = s;
} }
@ -1365,7 +1365,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
pr_warn("gfs2 mount does not exist\n"); pr_warn("gfs2 mount does not exist\n");
return ERR_CAST(s); return ERR_CAST(s);
} }
if ((flags ^ s->s_flags) & MS_RDONLY) { if ((flags ^ s->s_flags) & SB_RDONLY) {
deactivate_locked_super(s); deactivate_locked_super(s);
return ERR_PTR(-EBUSY); return ERR_PTR(-EBUSY);
} }

10
fs/gfs2/super.c
View File

@ -1256,10 +1256,10 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
return -EINVAL; return -EINVAL;
if (sdp->sd_args.ar_spectator) if (sdp->sd_args.ar_spectator)
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
if ((sb->s_flags ^ *flags) & MS_RDONLY) { if ((sb->s_flags ^ *flags) & SB_RDONLY) {
if (*flags & MS_RDONLY) if (*flags & SB_RDONLY)
error = gfs2_make_fs_ro(sdp); error = gfs2_make_fs_ro(sdp);
else else
error = gfs2_make_fs_rw(sdp); error = gfs2_make_fs_rw(sdp);
@ -1269,9 +1269,9 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
sdp->sd_args = args; sdp->sd_args = args;
if (sdp->sd_args.ar_posix_acl) if (sdp->sd_args.ar_posix_acl)
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
else else
sb->s_flags &= ~MS_POSIXACL; sb->s_flags &= ~SB_POSIXACL;
if (sdp->sd_args.ar_nobarrier) if (sdp->sd_args.ar_nobarrier)
set_bit(SDF_NOBARRIERS, &sdp->sd_flags); set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
else else

2
fs/gfs2/trans.c
View File

@ -117,7 +117,7 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)
kfree(tr); kfree(tr);
up_read(&sdp->sd_log_flush_lock); up_read(&sdp->sd_log_flush_lock);
if (sdp->sd_vfs->s_flags & MS_SYNCHRONOUS) if (sdp->sd_vfs->s_flags & SB_SYNCHRONOUS)
gfs2_log_flush(sdp, NULL, NORMAL_FLUSH); gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
if (alloced) if (alloced)
sb_end_intwrite(sdp->sd_vfs); sb_end_intwrite(sdp->sd_vfs);

4
fs/hfs/mdb.c
View File

@ -204,11 +204,11 @@ int hfs_mdb_get(struct super_block *sb)
attrib = mdb->drAtrb; attrib = mdb->drAtrb;
if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) { if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n"); pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) { if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
pr_warn("filesystem is marked locked, mounting read-only.\n"); pr_warn("filesystem is marked locked, mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
if (!sb_rdonly(sb)) { if (!sb_rdonly(sb)) {
/* Mark the volume uncleanly unmounted in case we crash */ /* Mark the volume uncleanly unmounted in case we crash */

16
fs/hfs/super.c
View File

@ -114,18 +114,18 @@ static int hfs_statfs(struct dentry *dentry, struct kstatfs *buf)
static int hfs_remount(struct super_block *sb, int *flags, char *data) static int hfs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_NODIRATIME; *flags |= SB_NODIRATIME;
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
return 0; return 0;
if (!(*flags & MS_RDONLY)) { if (!(*flags & SB_RDONLY)) {
if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) { if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. leaving read-only.\n"); pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
} else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) { } else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) {
pr_warn("filesystem is marked locked, leaving read-only.\n"); pr_warn("filesystem is marked locked, leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
} }
} }
return 0; return 0;
@ -407,7 +407,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
sb->s_op = &hfs_super_operations; sb->s_op = &hfs_super_operations;
sb->s_xattr = hfs_xattr_handlers; sb->s_xattr = hfs_xattr_handlers;
sb->s_flags |= MS_NODIRATIME; sb->s_flags |= SB_NODIRATIME;
mutex_init(&sbi->bitmap_lock); mutex_init(&sbi->bitmap_lock);
res = hfs_mdb_get(sb); res = hfs_mdb_get(sb);

22
fs/hfsplus/super.c
View File

@ -329,9 +329,9 @@ static int hfsplus_statfs(struct dentry *dentry, struct kstatfs *buf)
static int hfsplus_remount(struct super_block *sb, int *flags, char *data) static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
return 0; return 0;
if (!(*flags & MS_RDONLY)) { if (!(*flags & SB_RDONLY)) {
struct hfsplus_vh *vhdr = HFSPLUS_SB(sb)->s_vhdr; struct hfsplus_vh *vhdr = HFSPLUS_SB(sb)->s_vhdr;
int force = 0; int force = 0;
@ -340,20 +340,20 @@ static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
pr_warn("filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. leaving read-only.\n"); pr_warn("filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
} else if (force) { } else if (force) {
/* nothing */ /* nothing */
} else if (vhdr->attributes & } else if (vhdr->attributes &
cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
pr_warn("filesystem is marked locked, leaving read-only.\n"); pr_warn("filesystem is marked locked, leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
} else if (vhdr->attributes & } else if (vhdr->attributes &
cpu_to_be32(HFSPLUS_VOL_JOURNALED)) { cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
pr_warn("filesystem is marked journaled, leaving read-only.\n"); pr_warn("filesystem is marked journaled, leaving read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
} }
} }
return 0; return 0;
@ -455,16 +455,16 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) { if (!(vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_UNMNT))) {
pr_warn("Filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. mounting read-only.\n"); pr_warn("Filesystem was not cleanly unmounted, running fsck.hfsplus is recommended. mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) { } else if (test_and_clear_bit(HFSPLUS_SB_FORCE, &sbi->flags)) {
/* nothing */ /* nothing */
} else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) { } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
pr_warn("Filesystem is marked locked, mounting read-only.\n"); pr_warn("Filesystem is marked locked, mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) && } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) &&
!sb_rdonly(sb)) { !sb_rdonly(sb)) {
pr_warn("write access to a journaled filesystem is not supported, use the force option at your own risk, mounting read-only.\n"); pr_warn("write access to a journaled filesystem is not supported, use the force option at your own risk, mounting read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
err = -EINVAL; err = -EINVAL;

2
fs/hpfs/map.c
View File

@ -288,7 +288,7 @@ struct dnode *hpfs_map_dnode(struct super_block *s, unsigned secno,
goto bail; goto bail;
} }
if (((31 + de->namelen + de->down*4 + 3) & ~3) != le16_to_cpu(de->length)) { if (((31 + de->namelen + de->down*4 + 3) & ~3) != le16_to_cpu(de->length)) {
if (((31 + de->namelen + de->down*4 + 3) & ~3) < le16_to_cpu(de->length) && s->s_flags & MS_RDONLY) goto ok; if (((31 + de->namelen + de->down*4 + 3) & ~3) < le16_to_cpu(de->length) && s->s_flags & SB_RDONLY) goto ok;
hpfs_error(s, "namelen does not match dirent size in dnode %08x, dirent %03x, last %03x", secno, p, pp); hpfs_error(s, "namelen does not match dirent size in dnode %08x, dirent %03x, last %03x", secno, p, pp);
goto bail; goto bail;
} }

8
fs/hpfs/super.c
View File

@ -78,7 +78,7 @@ void hpfs_error(struct super_block *s, const char *fmt, ...)
else { else {
pr_cont("; remounting read-only\n"); pr_cont("; remounting read-only\n");
mark_dirty(s, 0); mark_dirty(s, 0);
s->s_flags |= MS_RDONLY; s->s_flags |= SB_RDONLY;
} }
} else if (sb_rdonly(s)) } else if (sb_rdonly(s))
pr_cont("; going on - but anything won't be destroyed because it's read-only\n"); 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)
sync_filesystem(s); sync_filesystem(s);
*flags |= MS_NOATIME; *flags |= SB_NOATIME;
hpfs_lock(s); hpfs_lock(s);
uid = sbi->sb_uid; gid = sbi->sb_gid; 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)
sbi->sb_eas = eas; sbi->sb_chk = chk; sbi->sb_chkdsk = chkdsk; sbi->sb_eas = eas; sbi->sb_chk = chk; sbi->sb_chkdsk = chkdsk;
sbi->sb_err = errs; sbi->sb_timeshift = timeshift; sbi->sb_err = errs; sbi->sb_timeshift = timeshift;
if (!(*flags & MS_RDONLY)) mark_dirty(s, 1); if (!(*flags & SB_RDONLY)) mark_dirty(s, 1);
hpfs_unlock(s); hpfs_unlock(s);
return 0; return 0;
@ -614,7 +614,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
goto bail4; goto bail4;
} }
s->s_flags |= MS_NOATIME; s->s_flags |= SB_NOATIME;
/* Fill superblock stuff */ /* Fill superblock stuff */
s->s_magic = HPFS_SUPER_MAGIC; s->s_magic = HPFS_SUPER_MAGIC;

10
fs/inode.c
View File

@ -416,7 +416,7 @@ void inode_add_lru(struct inode *inode)
{ {
if (!(inode->i_state & (I_DIRTY_ALL | I_SYNC | if (!(inode->i_state & (I_DIRTY_ALL | I_SYNC |
I_FREEING | I_WILL_FREE)) && I_FREEING | I_WILL_FREE)) &&
!atomic_read(&inode->i_count) && inode->i_sb->s_flags & MS_ACTIVE) !atomic_read(&inode->i_count) && inode->i_sb->s_flags & SB_ACTIVE)
inode_lru_list_add(inode); inode_lru_list_add(inode);
} }
@ -595,7 +595,7 @@ static void dispose_list(struct list_head *head)
* @sb: superblock to operate on * @sb: superblock to operate on
* *
* Make sure that no inodes with zero refcount are retained. This is * Make sure that no inodes with zero refcount are retained. This is
* called by superblock shutdown after having MS_ACTIVE flag removed, * called by superblock shutdown after having SB_ACTIVE flag removed,
* so any inode reaching zero refcount during or after that call will * so any inode reaching zero refcount during or after that call will
* be immediately evicted. * be immediately evicted.
*/ */
@ -1492,7 +1492,7 @@ static void iput_final(struct inode *inode)
else else
drop = generic_drop_inode(inode); drop = generic_drop_inode(inode);
if (!drop && (sb->s_flags & MS_ACTIVE)) { if (!drop && (sb->s_flags & SB_ACTIVE)) {
inode_add_lru(inode); inode_add_lru(inode);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
return; return;
@ -1644,7 +1644,7 @@ int generic_update_time(struct inode *inode, struct timespec *time, int flags)
if (flags & S_MTIME) if (flags & S_MTIME)
inode->i_mtime = *time; inode->i_mtime = *time;
if (!(inode->i_sb->s_flags & MS_LAZYTIME) || (flags & S_VERSION)) if (!(inode->i_sb->s_flags & SB_LAZYTIME) || (flags & S_VERSION))
iflags |= I_DIRTY_SYNC; iflags |= I_DIRTY_SYNC;
__mark_inode_dirty(inode, iflags); __mark_inode_dirty(inode, iflags);
return 0; return 0;
@ -1691,7 +1691,7 @@ bool __atime_needs_update(const struct path *path, struct inode *inode,
if (IS_NOATIME(inode)) if (IS_NOATIME(inode))
return false; return false;
if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)) if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode))
return false; return false;
if (mnt->mnt_flags & MNT_NOATIME) if (mnt->mnt_flags & MNT_NOATIME)

2
fs/isofs/inode.c
View File

@ -114,7 +114,7 @@ static void destroy_inodecache(void)
static int isofs_remount(struct super_block *sb, int *flags, char *data) static int isofs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
if (!(*flags & MS_RDONLY)) if (!(*flags & SB_RDONLY))
return -EROFS; return -EROFS;
return 0; return 0;
} }

4
fs/jffs2/fs.c
View File

@ -409,10 +409,10 @@ int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
mutex_unlock(&c->alloc_sem); mutex_unlock(&c->alloc_sem);
} }
if (!(*flags & MS_RDONLY)) if (!(*flags & SB_RDONLY))
jffs2_start_garbage_collect_thread(c); jffs2_start_garbage_collect_thread(c);
*flags |= MS_NOATIME; *flags |= SB_NOATIME;
return 0; return 0;
} }

2
fs/jffs2/os-linux.h
View File

@ -59,7 +59,7 @@ static inline void jffs2_init_inode_info(struct jffs2_inode_info *f)
} }
#define jffs2_is_readonly(c) (OFNI_BS_2SFFJ(c)->s_flags & MS_RDONLY) #define jffs2_is_readonly(c) (OFNI_BS_2SFFJ(c)->s_flags & SB_RDONLY)
#define SECTOR_ADDR(x) ( (((unsigned long)(x) / c->sector_size) * c->sector_size) ) #define SECTOR_ADDR(x) ( (((unsigned long)(x) / c->sector_size) * c->sector_size) )
#ifndef CONFIG_JFFS2_FS_WRITEBUFFER #ifndef CONFIG_JFFS2_FS_WRITEBUFFER

4
fs/jffs2/super.c
View File

@ -301,10 +301,10 @@ static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
sb->s_op = &jffs2_super_operations; sb->s_op = &jffs2_super_operations;
sb->s_export_op = &jffs2_export_ops; sb->s_export_op = &jffs2_export_ops;
sb->s_flags = sb->s_flags | MS_NOATIME; sb->s_flags = sb->s_flags | SB_NOATIME;
sb->s_xattr = jffs2_xattr_handlers; sb->s_xattr = jffs2_xattr_handlers;
#ifdef CONFIG_JFFS2_FS_POSIX_ACL #ifdef CONFIG_JFFS2_FS_POSIX_ACL
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
#endif #endif
ret = jffs2_do_fill_super(sb, data, silent); ret = jffs2_do_fill_super(sb, data, silent);
return ret; return ret;

10
fs/jfs/super.c
View File

@ -87,7 +87,7 @@ static void jfs_handle_error(struct super_block *sb)
else if (sbi->flag & JFS_ERR_REMOUNT_RO) { else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
jfs_err("ERROR: (device %s): remounting filesystem as read-only", jfs_err("ERROR: (device %s): remounting filesystem as read-only",
sb->s_id); sb->s_id);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
/* nothing is done for continue beyond marking the superblock dirty */ /* 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)
return rc; return rc;
} }
if (sb_rdonly(sb) && !(*flags & MS_RDONLY)) { if (sb_rdonly(sb) && !(*flags & SB_RDONLY)) {
/* /*
* Invalidate any previously read metadata. fsck may have * Invalidate any previously read metadata. fsck may have
* changed the on-disk data since we mounted r/o * 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)
ret = jfs_mount_rw(sb, 1); ret = jfs_mount_rw(sb, 1);
/* mark the fs r/w for quota activity */ /* mark the fs r/w for quota activity */
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
dquot_resume(sb, -1); dquot_resume(sb, -1);
return ret; return ret;
} }
if (!sb_rdonly(sb) && (*flags & MS_RDONLY)) { if (!sb_rdonly(sb) && (*flags & SB_RDONLY)) {
rc = dquot_suspend(sb, -1); rc = dquot_suspend(sb, -1);
if (rc < 0) if (rc < 0)
return rc; return rc;
@ -545,7 +545,7 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
sbi->flag = flag; sbi->flag = flag;
#ifdef CONFIG_JFS_POSIX_ACL #ifdef CONFIG_JFS_POSIX_ACL
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
#endif #endif
if (newLVSize) { if (newLVSize) {

2
fs/kernfs/mount.c
View File

@ -335,7 +335,7 @@ struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
deactivate_locked_super(sb); deactivate_locked_super(sb);
return ERR_PTR(error); return ERR_PTR(error);
} }
sb->s_flags |= MS_ACTIVE; sb->s_flags |= SB_ACTIVE;
mutex_lock(&kernfs_mutex); mutex_lock(&kernfs_mutex);
list_add(&info->node, &root->supers); list_add(&info->node, &root->supers);

6
fs/libfs.c
View File

@ -246,7 +246,7 @@ struct dentry *mount_pseudo_xattr(struct file_system_type *fs_type, char *name,
struct inode *root; struct inode *root;
struct qstr d_name = QSTR_INIT(name, strlen(name)); struct qstr d_name = QSTR_INIT(name, strlen(name));
s = sget_userns(fs_type, NULL, set_anon_super, MS_KERNMOUNT|MS_NOUSER, s = sget_userns(fs_type, NULL, set_anon_super, SB_KERNMOUNT|SB_NOUSER,
&init_user_ns, NULL); &init_user_ns, NULL);
if (IS_ERR(s)) if (IS_ERR(s))
return ERR_CAST(s); return ERR_CAST(s);
@ -277,7 +277,7 @@ struct dentry *mount_pseudo_xattr(struct file_system_type *fs_type, char *name,
d_instantiate(dentry, root); d_instantiate(dentry, root);
s->s_root = dentry; s->s_root = dentry;
s->s_d_op = dops; s->s_d_op = dops;
s->s_flags |= MS_ACTIVE; s->s_flags |= SB_ACTIVE;
return dget(s->s_root); return dget(s->s_root);
Enomem: Enomem:
@ -578,7 +578,7 @@ int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *c
spin_lock(&pin_fs_lock); spin_lock(&pin_fs_lock);
if (unlikely(!*mount)) { if (unlikely(!*mount)) {
spin_unlock(&pin_fs_lock); spin_unlock(&pin_fs_lock);
mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, NULL); mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL);
if (IS_ERR(mnt)) if (IS_ERR(mnt))
return PTR_ERR(mnt); return PTR_ERR(mnt);
spin_lock(&pin_fs_lock); spin_lock(&pin_fs_lock);

2
fs/locks.c
View File

@ -141,7 +141,7 @@
static inline bool is_remote_lock(struct file *filp) static inline bool is_remote_lock(struct file *filp)
{ {
return likely(!(filp->f_path.dentry->d_sb->s_flags & MS_NOREMOTELOCK)); return likely(!(filp->f_path.dentry->d_sb->s_flags & SB_NOREMOTELOCK));
} }
static bool lease_breaking(struct file_lock *fl) static bool lease_breaking(struct file_lock *fl)

4
fs/minix/inode.c
View File

@ -125,9 +125,9 @@ static int minix_remount (struct super_block * sb, int * flags, char * data)
sync_filesystem(sb); sync_filesystem(sb);
ms = sbi->s_ms; ms = sbi->s_ms;
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
return 0; return 0;
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
if (ms->s_state & MINIX_VALID_FS || if (ms->s_state & MINIX_VALID_FS ||
!(sbi->s_mount_state & MINIX_VALID_FS)) !(sbi->s_mount_state & MINIX_VALID_FS))
return 0; return 0;

4
fs/ncpfs/inode.c
View File

@ -103,7 +103,7 @@ static void destroy_inodecache(void)
static int ncp_remount(struct super_block *sb, int *flags, char* data) static int ncp_remount(struct super_block *sb, int *flags, char* data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_NODIRATIME; *flags |= SB_NODIRATIME;
return 0; return 0;
} }
@ -547,7 +547,7 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
else else
default_bufsize = 1024; default_bufsize = 1024;
sb->s_flags |= MS_NODIRATIME; /* probably even noatime */ sb->s_flags |= SB_NODIRATIME; /* probably even noatime */
sb->s_maxbytes = 0xFFFFFFFFU; sb->s_maxbytes = 0xFFFFFFFFU;
sb->s_blocksize = 1024; /* Eh... Is this correct? */ sb->s_blocksize = 1024; /* Eh... Is this correct? */
sb->s_blocksize_bits = 10; sb->s_blocksize_bits = 10;

2
fs/nfs/dir.c
View File

@ -1256,7 +1256,7 @@ static int nfs_dentry_delete(const struct dentry *dentry)
/* Unhash it, so that ->d_iput() would be called */ /* Unhash it, so that ->d_iput() would be called */
return 1; return 1;
} }
if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { if (!(dentry->d_sb->s_flags & SB_ACTIVE)) {
/* Unhash it, so that ancestors of killed async unlink /* Unhash it, so that ancestors of killed async unlink
* files will be cleaned up during umount */ * files will be cleaned up during umount */
return 1; return 1;

2
fs/nfs/inode.c
View File

@ -752,7 +752,7 @@ int nfs_getattr(const struct path *path, struct kstat *stat,
* Note that we only have to check the vfsmount flags here: * Note that we only have to check the vfsmount flags here:
* - NFS always sets S_NOATIME by so checking it would give a * - NFS always sets S_NOATIME by so checking it would give a
* bogus result * bogus result
* - NFS never sets MS_NOATIME or MS_NODIRATIME so there is * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is
* no point in checking those. * no point in checking those.
*/ */
if ((path->mnt->mnt_flags & MNT_NOATIME) || if ((path->mnt->mnt_flags & MNT_NOATIME) ||

2
fs/nfs/internal.h
View File

@ -10,7 +10,7 @@
#include <linux/nfs_page.h> #include <linux/nfs_page.h>
#include <linux/wait_bit.h> #include <linux/wait_bit.h>
#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS) #define NFS_MS_MASK (SB_RDONLY|SB_NOSUID|SB_NODEV|SB_NOEXEC|SB_SYNCHRONOUS)
extern const struct export_operations nfs_export_ops; extern const struct export_operations nfs_export_ops;

22
fs/nfs/super.c
View File

@ -813,9 +813,9 @@ int nfs_show_stats(struct seq_file *m, struct dentry *root)
*/ */
seq_printf(m, "\n\topts:\t"); seq_printf(m, "\n\topts:\t");
seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw"); seq_puts(m, sb_rdonly(root->d_sb) ? "ro" : "rw");
seq_puts(m, root->d_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : ""); seq_puts(m, root->d_sb->s_flags & SB_SYNCHRONOUS ? ",sync" : "");
seq_puts(m, root->d_sb->s_flags & MS_NOATIME ? ",noatime" : ""); seq_puts(m, root->d_sb->s_flags & SB_NOATIME ? ",noatime" : "");
seq_puts(m, root->d_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : ""); seq_puts(m, root->d_sb->s_flags & SB_NODIRATIME ? ",nodiratime" : "");
nfs_show_mount_options(m, nfss, 1); nfs_show_mount_options(m, nfss, 1);
seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ); 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)
/* /*
* noac is a special case. It implies -o sync, but that's not * noac is a special case. It implies -o sync, but that's not
* necessarily reflected in the mtab options. do_remount_sb * necessarily reflected in the mtab options. do_remount_sb
* will clear MS_SYNCHRONOUS if -o sync wasn't specified in the * will clear SB_SYNCHRONOUS if -o sync wasn't specified in the
* remount options, so we have to explicitly reset it. * remount options, so we have to explicitly reset it.
*/ */
if (data->flags & NFS_MOUNT_NOAC) if (data->flags & NFS_MOUNT_NOAC)
*flags |= MS_SYNCHRONOUS; *flags |= SB_SYNCHRONOUS;
/* compare new mount options with old ones */ /* compare new mount options with old ones */
error = nfs_compare_remount_data(nfss, data); 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)
/* The VFS shouldn't apply the umask to mode bits. We will do /* The VFS shouldn't apply the umask to mode bits. We will do
* so ourselves when necessary. * so ourselves when necessary.
*/ */
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
sb->s_time_gran = 1; sb->s_time_gran = 1;
sb->s_export_op = &nfs_export_ops; sb->s_export_op = &nfs_export_ops;
} }
@ -2379,7 +2379,7 @@ static void nfs_clone_super(struct super_block *sb,
/* The VFS shouldn't apply the umask to mode bits. We will do /* The VFS shouldn't apply the umask to mode bits. We will do
* so ourselves when necessary. * so ourselves when necessary.
*/ */
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
} }
nfs_initialise_sb(sb); nfs_initialise_sb(sb);
@ -2600,11 +2600,11 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
/* -o noac implies -o sync */ /* -o noac implies -o sync */
if (server->flags & NFS_MOUNT_NOAC) if (server->flags & NFS_MOUNT_NOAC)
sb_mntdata.mntflags |= MS_SYNCHRONOUS; sb_mntdata.mntflags |= SB_SYNCHRONOUS;
if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL) if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)
if (mount_info->cloned->sb->s_flags & MS_SYNCHRONOUS) if (mount_info->cloned->sb->s_flags & SB_SYNCHRONOUS)
sb_mntdata.mntflags |= MS_SYNCHRONOUS; sb_mntdata.mntflags |= SB_SYNCHRONOUS;
/* Get a superblock - note that we may end up sharing one that already exists */ /* Get a superblock - note that we may end up sharing one that already exists */
s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata); 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,
if (error) if (error)
goto error_splat_root; goto error_splat_root;
s->s_flags |= MS_ACTIVE; s->s_flags |= SB_ACTIVE;
out: out:
return mntroot; return mntroot;

2
fs/nilfs2/segment.c
View File

@ -1979,7 +1979,7 @@ static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci,
struct the_nilfs *nilfs) struct the_nilfs *nilfs)
{ {
struct nilfs_inode_info *ii, *n; struct nilfs_inode_info *ii, *n;
int during_mount = !(sci->sc_super->s_flags & MS_ACTIVE); int during_mount = !(sci->sc_super->s_flags & SB_ACTIVE);
int defer_iput = false; int defer_iput = false;
spin_lock(&nilfs->ns_inode_lock); spin_lock(&nilfs->ns_inode_lock);

24
fs/nilfs2/super.c
View File

@ -141,7 +141,7 @@ void __nilfs_error(struct super_block *sb, const char *function,
if (nilfs_test_opt(nilfs, ERRORS_RO)) { if (nilfs_test_opt(nilfs, ERRORS_RO)) {
printk(KERN_CRIT "Remounting filesystem read-only\n"); printk(KERN_CRIT "Remounting filesystem read-only\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
} }
@ -869,7 +869,7 @@ int nilfs_store_magic_and_option(struct super_block *sb,
/* FS independent flags */ /* FS independent flags */
#ifdef NILFS_ATIME_DISABLE #ifdef NILFS_ATIME_DISABLE
sb->s_flags |= MS_NOATIME; sb->s_flags |= SB_NOATIME;
#endif #endif
nilfs_set_default_options(sb, sbp); nilfs_set_default_options(sb, sbp);
@ -1133,7 +1133,7 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data)
err = -EINVAL; err = -EINVAL;
goto restore_opts; goto restore_opts;
} }
sb->s_flags = (sb->s_flags & ~MS_POSIXACL); sb->s_flags = (sb->s_flags & ~SB_POSIXACL);
err = -EINVAL; err = -EINVAL;
@ -1143,12 +1143,12 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data)
goto restore_opts; goto restore_opts;
} }
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
goto out; goto out;
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
/* Shutting down log writer */ /* Shutting down log writer */
nilfs_detach_log_writer(sb); nilfs_detach_log_writer(sb);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
/* /*
* Remounting a valid RW partition RDONLY, so set * Remounting a valid RW partition RDONLY, so set
@ -1178,7 +1178,7 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data)
goto restore_opts; goto restore_opts;
} }
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
root = NILFS_I(d_inode(sb->s_root))->i_root; root = NILFS_I(d_inode(sb->s_root))->i_root;
err = nilfs_attach_log_writer(sb, root); err = nilfs_attach_log_writer(sb, root);
@ -1212,7 +1212,7 @@ static int nilfs_parse_snapshot_option(const char *option,
const char *msg = NULL; const char *msg = NULL;
int err; int err;
if (!(sd->flags & MS_RDONLY)) { if (!(sd->flags & SB_RDONLY)) {
msg = "read-only option is not specified"; msg = "read-only option is not specified";
goto parse_error; goto parse_error;
} }
@ -1286,7 +1286,7 @@ nilfs_mount(struct file_system_type *fs_type, int flags,
struct dentry *root_dentry; struct dentry *root_dentry;
int err, s_new = false; int err, s_new = false;
if (!(flags & MS_RDONLY)) if (!(flags & SB_RDONLY))
mode |= FMODE_WRITE; mode |= FMODE_WRITE;
sd.bdev = blkdev_get_by_path(dev_name, mode, fs_type); 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,
snprintf(s->s_id, sizeof(s->s_id), "%pg", sd.bdev); snprintf(s->s_id, sizeof(s->s_id), "%pg", sd.bdev);
sb_set_blocksize(s, block_size(sd.bdev)); sb_set_blocksize(s, block_size(sd.bdev));
err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0); err = nilfs_fill_super(s, data, flags & SB_SILENT ? 1 : 0);
if (err) if (err)
goto failed_super; goto failed_super;
s->s_flags |= MS_ACTIVE; s->s_flags |= SB_ACTIVE;
} else if (!sd.cno) { } else if (!sd.cno) {
if (nilfs_tree_is_busy(s->s_root)) { if (nilfs_tree_is_busy(s->s_root)) {
if ((flags ^ s->s_flags) & MS_RDONLY) { if ((flags ^ s->s_flags) & SB_RDONLY) {
nilfs_msg(s, KERN_ERR, nilfs_msg(s, KERN_ERR,
"the device already has a %s mount.", "the device already has a %s mount.",
sb_rdonly(s) ? "read-only" : "read/write"); sb_rdonly(s) ? "read-only" : "read/write");

6
fs/nilfs2/the_nilfs.c
View File

@ -220,7 +220,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb)
if (!valid_fs) { if (!valid_fs) {
nilfs_msg(sb, KERN_WARNING, "mounting unchecked fs"); nilfs_msg(sb, KERN_WARNING, "mounting unchecked fs");
if (s_flags & MS_RDONLY) { if (s_flags & SB_RDONLY) {
nilfs_msg(sb, KERN_INFO, nilfs_msg(sb, KERN_INFO,
"recovery required for readonly filesystem"); "recovery required for readonly filesystem");
nilfs_msg(sb, KERN_INFO, nilfs_msg(sb, KERN_INFO,
@ -286,7 +286,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb)
if (valid_fs) if (valid_fs)
goto skip_recovery; goto skip_recovery;
if (s_flags & MS_RDONLY) { if (s_flags & SB_RDONLY) {
__u64 features; __u64 features;
if (nilfs_test_opt(nilfs, NORECOVERY)) { if (nilfs_test_opt(nilfs, NORECOVERY)) {
@ -309,7 +309,7 @@ int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb)
err = -EROFS; err = -EROFS;
goto failed_unload; goto failed_unload;
} }
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
} else if (nilfs_test_opt(nilfs, NORECOVERY)) { } else if (nilfs_test_opt(nilfs, NORECOVERY)) {
nilfs_msg(sb, KERN_ERR, nilfs_msg(sb, KERN_ERR,
"recovery cancelled because norecovery option was specified for a read/write mount"); "recovery cancelled because norecovery option was specified for a read/write mount");

2
fs/notify/fsnotify.c
View File

@ -67,7 +67,7 @@ void fsnotify_unmount_inodes(struct super_block *sb)
/* /*
* If i_count is zero, the inode cannot have any watches and * If i_count is zero, the inode cannot have any watches and
* doing an __iget/iput with MS_ACTIVE clear would actually * doing an __iget/iput with SB_ACTIVE clear would actually
* evict all inodes with zero i_count from icache which is * evict all inodes with zero i_count from icache which is
* unnecessarily violent and may in fact be illegal to do. * unnecessarily violent and may in fact be illegal to do.
*/ */

2
fs/nsfs.c
View File

@ -255,5 +255,5 @@ void __init nsfs_init(void)
nsfs_mnt = kern_mount(&nsfs); nsfs_mnt = kern_mount(&nsfs);
if (IS_ERR(nsfs_mnt)) if (IS_ERR(nsfs_mnt))
panic("can't set nsfs up\n"); panic("can't set nsfs up\n");
nsfs_mnt->mnt_sb->s_flags &= ~MS_NOUSER; nsfs_mnt->mnt_sb->s_flags &= ~SB_NOUSER;
} }

32
fs/ntfs/super.c
View File

@ -473,7 +473,7 @@ static int ntfs_remount(struct super_block *sb, int *flags, char *opt)
#ifndef NTFS_RW #ifndef NTFS_RW
/* For read-only compiled driver, enforce read-only flag. */ /* For read-only compiled driver, enforce read-only flag. */
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
#else /* NTFS_RW */ #else /* NTFS_RW */
/* /*
* For the read-write compiled driver, if we are remounting read-write, * 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)
* When remounting read-only, mark the volume clean if no volume errors * When remounting read-only, mark the volume clean if no volume errors
* have occurred. * have occurred.
*/ */
if (sb_rdonly(sb) && !(*flags & MS_RDONLY)) { if (sb_rdonly(sb) && !(*flags & SB_RDONLY)) {
static const char *es = ". Cannot remount read-write."; static const char *es = ". Cannot remount read-write.";
/* Remounting read-write. */ /* Remounting read-write. */
@ -548,7 +548,7 @@ static int ntfs_remount(struct super_block *sb, int *flags, char *opt)
NVolSetErrors(vol); NVolSetErrors(vol);
return -EROFS; return -EROFS;
} }
} else if (!sb_rdonly(sb) && (*flags & MS_RDONLY)) { } else if (!sb_rdonly(sb) && (*flags & SB_RDONLY)) {
/* Remounting read-only. */ /* Remounting read-only. */
if (!NVolErrors(vol)) { if (!NVolErrors(vol)) {
if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY)) if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
@ -1799,7 +1799,7 @@ static bool load_system_files(ntfs_volume *vol)
es3); es3);
goto iput_mirr_err_out; goto iput_mirr_err_out;
} }
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ntfs_error(sb, "%s. Mounting read-only%s", ntfs_error(sb, "%s. Mounting read-only%s",
!vol->mftmirr_ino ? es1 : es2, es3); !vol->mftmirr_ino ? es1 : es2, es3);
} else } else
@ -1937,7 +1937,7 @@ get_ctx_vol_failed:
es1, es2); es1, es2);
goto iput_vol_err_out; goto iput_vol_err_out;
} }
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
} else } else
ntfs_warning(sb, "%s. Will not be able to remount " ntfs_warning(sb, "%s. Will not be able to remount "
@ -1974,7 +1974,7 @@ get_ctx_vol_failed:
} }
goto iput_logfile_err_out; goto iput_logfile_err_out;
} }
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
} else } else
ntfs_warning(sb, "%s. Will not be able to remount " ntfs_warning(sb, "%s. Will not be able to remount "
@ -2019,7 +2019,7 @@ get_ctx_vol_failed:
es1, es2); es1, es2);
goto iput_root_err_out; goto iput_root_err_out;
} }
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
} else } else
ntfs_warning(sb, "%s. Will not be able to remount " ntfs_warning(sb, "%s. Will not be able to remount "
@ -2042,7 +2042,7 @@ get_ctx_vol_failed:
goto iput_root_err_out; goto iput_root_err_out;
} }
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
/* /*
* Do not set NVolErrors() because ntfs_remount() might manage * Do not set NVolErrors() because ntfs_remount() might manage
* to set the dirty flag in which case all would be well. * to set the dirty flag in which case all would be well.
@ -2055,7 +2055,7 @@ get_ctx_vol_failed:
* If (still) a read-write mount, set the NT4 compatibility flag on * If (still) a read-write mount, set the NT4 compatibility flag on
* newer NTFS version volumes. * newer NTFS version volumes.
*/ */
if (!(sb->s_flags & MS_RDONLY) && (vol->major_ver > 1) && if (!(sb->s_flags & SB_RDONLY) && (vol->major_ver > 1) &&
ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) { ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
static const char *es1 = "Failed to set NT4 compatibility flag"; static const char *es1 = "Failed to set NT4 compatibility flag";
static const char *es2 = ". Run chkdsk."; static const char *es2 = ". Run chkdsk.";
@ -2069,7 +2069,7 @@ get_ctx_vol_failed:
goto iput_root_err_out; goto iput_root_err_out;
} }
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
NVolSetErrors(vol); NVolSetErrors(vol);
} }
#endif #endif
@ -2087,7 +2087,7 @@ get_ctx_vol_failed:
goto iput_root_err_out; goto iput_root_err_out;
} }
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
NVolSetErrors(vol); NVolSetErrors(vol);
} }
#endif /* NTFS_RW */ #endif /* NTFS_RW */
@ -2128,7 +2128,7 @@ get_ctx_vol_failed:
es1, es2); es1, es2);
goto iput_quota_err_out; goto iput_quota_err_out;
} }
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
} else } else
ntfs_warning(sb, "%s. Will not be able to remount " ntfs_warning(sb, "%s. Will not be able to remount "
@ -2150,7 +2150,7 @@ get_ctx_vol_failed:
goto iput_quota_err_out; goto iput_quota_err_out;
} }
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
NVolSetErrors(vol); NVolSetErrors(vol);
} }
/* /*
@ -2171,7 +2171,7 @@ get_ctx_vol_failed:
es1, es2); es1, es2);
goto iput_usnjrnl_err_out; goto iput_usnjrnl_err_out;
} }
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
} else } else
ntfs_warning(sb, "%s. Will not be able to remount " ntfs_warning(sb, "%s. Will not be able to remount "
@ -2194,7 +2194,7 @@ get_ctx_vol_failed:
goto iput_usnjrnl_err_out; goto iput_usnjrnl_err_out;
} }
ntfs_error(sb, "%s. Mounting read-only%s", es1, es2); ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
NVolSetErrors(vol); NVolSetErrors(vol);
} }
#endif /* NTFS_RW */ #endif /* NTFS_RW */
@ -2728,7 +2728,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
lockdep_off(); lockdep_off();
ntfs_debug("Entering."); ntfs_debug("Entering.");
#ifndef NTFS_RW #ifndef NTFS_RW
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
#endif /* ! NTFS_RW */ #endif /* ! NTFS_RW */
/* Allocate a new ntfs_volume and place it in sb->s_fs_info. */ /* Allocate a new ntfs_volume and place it in sb->s_fs_info. */
sb->s_fs_info = kmalloc(sizeof(ntfs_volume), GFP_NOFS); sb->s_fs_info = kmalloc(sizeof(ntfs_volume), GFP_NOFS);

2
fs/ocfs2/file.c
View File

@ -227,7 +227,7 @@ int ocfs2_should_update_atime(struct inode *inode,
return 0; return 0;
if ((inode->i_flags & S_NOATIME) || if ((inode->i_flags & S_NOATIME) ||
((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))) ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode)))
return 0; return 0;
/* /*

28
fs/ocfs2/super.c
View File

@ -675,9 +675,9 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
} }
/* We're going to/from readonly mode. */ /* We're going to/from readonly mode. */
if ((bool)(*flags & MS_RDONLY) != sb_rdonly(sb)) { if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
/* Disable quota accounting before remounting RO */ /* Disable quota accounting before remounting RO */
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
ret = ocfs2_susp_quotas(osb, 0); ret = ocfs2_susp_quotas(osb, 0);
if (ret < 0) if (ret < 0)
goto out; goto out;
@ -691,8 +691,8 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
goto unlock_osb; goto unlock_osb;
} }
if (*flags & MS_RDONLY) { if (*flags & SB_RDONLY) {
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
osb->osb_flags |= OCFS2_OSB_SOFT_RO; osb->osb_flags |= OCFS2_OSB_SOFT_RO;
} else { } else {
if (osb->osb_flags & OCFS2_OSB_ERROR_FS) { if (osb->osb_flags & OCFS2_OSB_ERROR_FS) {
@ -709,14 +709,14 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
ret = -EINVAL; ret = -EINVAL;
goto unlock_osb; goto unlock_osb;
} }
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~SB_RDONLY;
osb->osb_flags &= ~OCFS2_OSB_SOFT_RO; osb->osb_flags &= ~OCFS2_OSB_SOFT_RO;
} }
trace_ocfs2_remount(sb->s_flags, osb->osb_flags, *flags); trace_ocfs2_remount(sb->s_flags, osb->osb_flags, *flags);
unlock_osb: unlock_osb:
spin_unlock(&osb->osb_lock); spin_unlock(&osb->osb_lock);
/* Enable quota accounting after remounting RW */ /* Enable quota accounting after remounting RW */
if (!ret && !(*flags & MS_RDONLY)) { if (!ret && !(*flags & SB_RDONLY)) {
if (sb_any_quota_suspended(sb)) if (sb_any_quota_suspended(sb))
ret = ocfs2_susp_quotas(osb, 1); ret = ocfs2_susp_quotas(osb, 1);
else else
@ -724,7 +724,7 @@ unlock_osb:
if (ret < 0) { if (ret < 0) {
/* Return back changes... */ /* Return back changes... */
spin_lock(&osb->osb_lock); spin_lock(&osb->osb_lock);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
osb->osb_flags |= OCFS2_OSB_SOFT_RO; osb->osb_flags |= OCFS2_OSB_SOFT_RO;
spin_unlock(&osb->osb_lock); spin_unlock(&osb->osb_lock);
goto out; goto out;
@ -744,9 +744,9 @@ unlock_osb:
if (!ocfs2_is_hard_readonly(osb)) if (!ocfs2_is_hard_readonly(osb))
ocfs2_set_journal_params(osb); ocfs2_set_journal_params(osb);
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ?
MS_POSIXACL : 0); SB_POSIXACL : 0);
} }
out: out:
return ret; return ret;
@ -1057,10 +1057,10 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
sb->s_magic = OCFS2_SUPER_MAGIC; sb->s_magic = OCFS2_SUPER_MAGIC;
sb->s_flags = (sb->s_flags & ~(MS_POSIXACL | MS_NOSEC)) | sb->s_flags = (sb->s_flags & ~(SB_POSIXACL | SB_NOSEC)) |
((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0); ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? SB_POSIXACL : 0);
/* Hard readonly mode only if: bdev_read_only, MS_RDONLY, /* Hard readonly mode only if: bdev_read_only, SB_RDONLY,
* heartbeat=none */ * heartbeat=none */
if (bdev_read_only(sb->s_bdev)) { if (bdev_read_only(sb->s_bdev)) {
if (!sb_rdonly(sb)) { if (!sb_rdonly(sb)) {
@ -2057,7 +2057,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP; sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
sb->s_xattr = ocfs2_xattr_handlers; sb->s_xattr = ocfs2_xattr_handlers;
sb->s_time_gran = 1; sb->s_time_gran = 1;
sb->s_flags |= MS_NOATIME; sb->s_flags |= SB_NOATIME;
/* this is needed to support O_LARGEFILE */ /* this is needed to support O_LARGEFILE */
cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits); cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits);
bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits); bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits);
@ -2568,7 +2568,7 @@ static int ocfs2_handle_error(struct super_block *sb)
return rv; return rv;
pr_crit("OCFS2: File system is now read-only.\n"); pr_crit("OCFS2: File system is now read-only.\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
ocfs2_set_ro_flag(osb, 0); ocfs2_set_ro_flag(osb, 0);
} }

2
fs/ocfs2/xattr.c
View File

@ -901,7 +901,7 @@ static int ocfs2_xattr_list_entry(struct super_block *sb,
case OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS: case OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS:
case OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT: case OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT:
if (!(sb->s_flags & MS_POSIXACL)) if (!(sb->s_flags & SB_POSIXACL))
return 0; return 0;
break; break;

4
fs/openpromfs/inode.c
View File

@ -369,7 +369,7 @@ static struct inode *openprom_iget(struct super_block *sb, ino_t ino)
static int openprom_remount(struct super_block *sb, int *flags, char *data) static int openprom_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_NOATIME; *flags |= SB_NOATIME;
return 0; return 0;
} }
@ -386,7 +386,7 @@ static int openprom_fill_super(struct super_block *s, void *data, int silent)
struct op_inode_info *oi; struct op_inode_info *oi;
int ret; int ret;
s->s_flags |= MS_NOATIME; s->s_flags |= SB_NOATIME;
s->s_blocksize = 1024; s->s_blocksize = 1024;
s->s_blocksize_bits = 10; s->s_blocksize_bits = 10;
s->s_magic = OPENPROM_SUPER_MAGIC; s->s_magic = OPENPROM_SUPER_MAGIC;

8
fs/orangefs/super.c
View File

@ -40,7 +40,7 @@ static int orangefs_show_options(struct seq_file *m, struct dentry *root)
{ {
struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(root->d_sb); struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(root->d_sb);
if (root->d_sb->s_flags & MS_POSIXACL) if (root->d_sb->s_flags & SB_POSIXACL)
seq_puts(m, ",acl"); seq_puts(m, ",acl");
if (orangefs_sb->flags & ORANGEFS_OPT_INTR) if (orangefs_sb->flags & ORANGEFS_OPT_INTR)
seq_puts(m, ",intr"); seq_puts(m, ",intr");
@ -60,7 +60,7 @@ static int parse_mount_options(struct super_block *sb, char *options,
* Force any potential flags that might be set from the mount * Force any potential flags that might be set from the mount
* to zero, ie, initialize to unset. * to zero, ie, initialize to unset.
*/ */
sb->s_flags &= ~MS_POSIXACL; sb->s_flags &= ~SB_POSIXACL;
orangefs_sb->flags &= ~ORANGEFS_OPT_INTR; orangefs_sb->flags &= ~ORANGEFS_OPT_INTR;
orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK; orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK;
@ -73,7 +73,7 @@ static int parse_mount_options(struct super_block *sb, char *options,
token = match_token(p, tokens, args); token = match_token(p, tokens, args);
switch (token) { switch (token) {
case Opt_acl: case Opt_acl:
sb->s_flags |= MS_POSIXACL; sb->s_flags |= SB_POSIXACL;
break; break;
case Opt_intr: case Opt_intr:
orangefs_sb->flags |= ORANGEFS_OPT_INTR; orangefs_sb->flags |= ORANGEFS_OPT_INTR;
@ -507,7 +507,7 @@ struct dentry *orangefs_mount(struct file_system_type *fst,
ret = orangefs_fill_sb(sb, ret = orangefs_fill_sb(sb,
&new_op->downcall.resp.fs_mount, data, &new_op->downcall.resp.fs_mount, data,
flags & MS_SILENT ? 1 : 0); flags & SB_SILENT ? 1 : 0);
if (ret) { if (ret) {
d = ERR_PTR(ret); d = ERR_PTR(ret);

10
fs/overlayfs/super.c
View File

@ -326,7 +326,7 @@ static int ovl_remount(struct super_block *sb, int *flags, char *data)
{ {
struct ovl_fs *ofs = sb->s_fs_info; struct ovl_fs *ofs = sb->s_fs_info;
if (!(*flags & MS_RDONLY) && ovl_force_readonly(ofs)) if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs))
return -EROFS; return -EROFS;
return 0; return 0;
@ -1190,7 +1190,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
goto out_err; goto out_err;
if (!ofs->workdir) if (!ofs->workdir)
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth; sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth;
sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran; 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)
/* If the upper fs is nonexistent, we mark overlayfs r/o too */ /* If the upper fs is nonexistent, we mark overlayfs r/o too */
if (!ofs->upper_mnt) if (!ofs->upper_mnt)
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
else if (ofs->upper_mnt->mnt_sb != ofs->same_sb) else if (ofs->upper_mnt->mnt_sb != ofs->same_sb)
ofs->same_sb = NULL; ofs->same_sb = NULL;
@ -1213,7 +1213,7 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
goto out_free_oe; goto out_free_oe;
if (!ofs->indexdir) if (!ofs->indexdir)
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
} }
/* Show index=off/on in /proc/mounts for any of the reasons above */ /* 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)
sb->s_op = &ovl_super_operations; sb->s_op = &ovl_super_operations;
sb->s_xattr = ovl_xattr_handlers; sb->s_xattr = ovl_xattr_handlers;
sb->s_fs_info = ofs; sb->s_fs_info = ofs;
sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK; sb->s_flags |= SB_POSIXACL | SB_NOREMOTELOCK;
err = -ENOMEM; err = -ENOMEM;
root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0)); root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));

2
fs/proc/inode.c
View File

@ -483,7 +483,7 @@ int proc_fill_super(struct super_block *s, void *data, int silent)
/* User space would break if executables or devices appear on proc */ /* User space would break if executables or devices appear on proc */
s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV; s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;
s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC; s->s_flags |= SB_NODIRATIME | SB_NOSUID | SB_NOEXEC;
s->s_blocksize = 1024; s->s_blocksize = 1024;
s->s_blocksize_bits = 10; s->s_blocksize_bits = 10;
s->s_magic = PROC_SUPER_MAGIC; s->s_magic = PROC_SUPER_MAGIC;

2
fs/proc/root.c
View File

@ -91,7 +91,7 @@ static struct dentry *proc_mount(struct file_system_type *fs_type,
{ {
struct pid_namespace *ns; struct pid_namespace *ns;
if (flags & MS_KERNMOUNT) { if (flags & SB_KERNMOUNT) {
ns = data; ns = data;
data = NULL; data = NULL;
} else { } else {

8
fs/proc_namespace.c
View File

@ -45,10 +45,10 @@ struct proc_fs_info {
static int show_sb_opts(struct seq_file *m, struct super_block *sb) static int show_sb_opts(struct seq_file *m, struct super_block *sb)
{ {
static const struct proc_fs_info fs_info[] = { static const struct proc_fs_info fs_info[] = {
{ MS_SYNCHRONOUS, ",sync" }, { SB_SYNCHRONOUS, ",sync" },
{ MS_DIRSYNC, ",dirsync" }, { SB_DIRSYNC, ",dirsync" },
{ MS_MANDLOCK, ",mand" }, { SB_MANDLOCK, ",mand" },
{ MS_LAZYTIME, ",lazytime" }, { SB_LAZYTIME, ",lazytime" },
{ 0, NULL } { 0, NULL }
}; };
const struct proc_fs_info *fs_infop; const struct proc_fs_info *fs_infop;

4
fs/qnx4/inode.c
View File

@ -47,7 +47,7 @@ static int qnx4_remount(struct super_block *sb, int *flags, char *data)
sync_filesystem(sb); sync_filesystem(sb);
qs = qnx4_sb(sb); qs = qnx4_sb(sb);
qs->Version = QNX4_VERSION; qs->Version = QNX4_VERSION;
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }
@ -199,7 +199,7 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
s->s_op = &qnx4_sops; s->s_op = &qnx4_sops;
s->s_magic = QNX4_SUPER_MAGIC; s->s_magic = QNX4_SUPER_MAGIC;
s->s_flags |= MS_RDONLY; /* Yup, read-only yet */ s->s_flags |= SB_RDONLY; /* Yup, read-only yet */
/* Check the superblock signature. Since the qnx4 code is /* Check the superblock signature. Since the qnx4 code is
dangerous, we should leave as quickly as possible dangerous, we should leave as quickly as possible

4
fs/qnx6/inode.c
View File

@ -56,7 +56,7 @@ static int qnx6_show_options(struct seq_file *seq, struct dentry *root)
static int qnx6_remount(struct super_block *sb, int *flags, char *data) static int qnx6_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }
@ -427,7 +427,7 @@ mmi_success:
} }
s->s_op = &qnx6_sops; s->s_op = &qnx6_sops;
s->s_magic = QNX6_SUPER_MAGIC; s->s_magic = QNX6_SUPER_MAGIC;
s->s_flags |= MS_RDONLY; /* Yup, read-only yet */ s->s_flags |= SB_RDONLY; /* Yup, read-only yet */
/* ease the later tree level calculations */ /* ease the later tree level calculations */
sbi = QNX6_SB(s); sbi = QNX6_SB(s);

2
fs/reiserfs/inode.c
View File

@ -2106,7 +2106,7 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
journal_end(th); journal_end(th);
goto out_inserted_sd; goto out_inserted_sd;
} }
} else if (inode->i_sb->s_flags & MS_POSIXACL) { } else if (inode->i_sb->s_flags & SB_POSIXACL) {
reiserfs_warning(inode->i_sb, "jdm-13090", reiserfs_warning(inode->i_sb, "jdm-13090",
"ACLs aren't enabled in the fs, " "ACLs aren't enabled in the fs, "
"but vfs thinks they are!"); "but vfs thinks they are!");

6
fs/reiserfs/journal.c
View File

@ -1960,7 +1960,7 @@ static int do_journal_release(struct reiserfs_transaction_handle *th,
/* /*
* Cancel flushing of old commits. Note that neither of these works * Cancel flushing of old commits. Note that neither of these works
* will be requeued because superblock is being shutdown and doesn't * will be requeued because superblock is being shutdown and doesn't
* have MS_ACTIVE set. * have SB_ACTIVE set.
*/ */
reiserfs_cancel_old_flush(sb); reiserfs_cancel_old_flush(sb);
/* wait for all commits to finish */ /* wait for all commits to finish */
@ -4302,7 +4302,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, int flags)
* Avoid queueing work when sb is being shut down. Transaction * Avoid queueing work when sb is being shut down. Transaction
* will be flushed on journal shutdown. * will be flushed on journal shutdown.
*/ */
if (sb->s_flags & MS_ACTIVE) if (sb->s_flags & SB_ACTIVE)
queue_delayed_work(REISERFS_SB(sb)->commit_wq, queue_delayed_work(REISERFS_SB(sb)->commit_wq,
&journal->j_work, HZ / 10); &journal->j_work, HZ / 10);
} }
@ -4393,7 +4393,7 @@ void reiserfs_abort_journal(struct super_block *sb, int errno)
if (!journal->j_errno) if (!journal->j_errno)
journal->j_errno = errno; journal->j_errno = errno;
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
set_bit(J_ABORTED, &journal->j_state); set_bit(J_ABORTED, &journal->j_state);
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK

4
fs/reiserfs/prints.c
View File

@ -390,7 +390,7 @@ void __reiserfs_error(struct super_block *sb, const char *id,
return; return;
reiserfs_info(sb, "Remounting filesystem read-only\n"); reiserfs_info(sb, "Remounting filesystem read-only\n");
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
reiserfs_abort_journal(sb, -EIO); reiserfs_abort_journal(sb, -EIO);
} }
@ -409,7 +409,7 @@ void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id, printk(KERN_CRIT "REISERFS abort (device %s): %s\n", sb->s_id,
error_buf); error_buf);
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
reiserfs_abort_journal(sb, errno); reiserfs_abort_journal(sb, errno);
} }

18
fs/reiserfs/super.c
View File

@ -121,7 +121,7 @@ void reiserfs_schedule_old_flush(struct super_block *s)
* Avoid scheduling flush when sb is being shut down. It can race * Avoid scheduling flush when sb is being shut down. It can race
* with journal shutdown and free still queued delayed work. * with journal shutdown and free still queued delayed work.
*/ */
if (sb_rdonly(s) || !(s->s_flags & MS_ACTIVE)) if (sb_rdonly(s) || !(s->s_flags & SB_ACTIVE))
return; return;
spin_lock(&sbi->old_work_lock); spin_lock(&sbi->old_work_lock);
@ -252,11 +252,11 @@ static int finish_unfinished(struct super_block *s)
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
/* Needed for iput() to work correctly and not trash data */ /* Needed for iput() to work correctly and not trash data */
if (s->s_flags & MS_ACTIVE) { if (s->s_flags & SB_ACTIVE) {
ms_active_set = 0; ms_active_set = 0;
} else { } else {
ms_active_set = 1; ms_active_set = 1;
s->s_flags |= MS_ACTIVE; s->s_flags |= SB_ACTIVE;
} }
/* Turn on quotas so that they are updated correctly */ /* Turn on quotas so that they are updated correctly */
for (i = 0; i < REISERFS_MAXQUOTAS; i++) { for (i = 0; i < REISERFS_MAXQUOTAS; i++) {
@ -411,7 +411,7 @@ static int finish_unfinished(struct super_block *s)
reiserfs_write_lock(s); reiserfs_write_lock(s);
if (ms_active_set) if (ms_active_set)
/* Restore the flag back */ /* Restore the flag back */
s->s_flags &= ~MS_ACTIVE; s->s_flags &= ~SB_ACTIVE;
#endif #endif
pathrelse(&path); pathrelse(&path);
if (done) if (done)
@ -1521,7 +1521,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
goto out_err_unlock; goto out_err_unlock;
} }
if (*mount_flags & MS_RDONLY) { if (*mount_flags & SB_RDONLY) {
reiserfs_write_unlock(s); reiserfs_write_unlock(s);
reiserfs_xattr_init(s, *mount_flags); reiserfs_xattr_init(s, *mount_flags);
/* remount read-only */ /* remount read-only */
@ -1567,7 +1567,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
REISERFS_SB(s)->s_mount_state = sb_umount_state(rs); REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
/* now it is safe to call journal_begin */ /* now it is safe to call journal_begin */
s->s_flags &= ~MS_RDONLY; s->s_flags &= ~SB_RDONLY;
err = journal_begin(&th, s, 10); err = journal_begin(&th, s, 10);
if (err) if (err)
goto out_err_unlock; goto out_err_unlock;
@ -1575,7 +1575,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
/* Mount a partition which is read-only, read-write */ /* Mount a partition which is read-only, read-write */
reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1); reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
REISERFS_SB(s)->s_mount_state = sb_umount_state(rs); REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
s->s_flags &= ~MS_RDONLY; s->s_flags &= ~SB_RDONLY;
set_sb_umount_state(rs, REISERFS_ERROR_FS); set_sb_umount_state(rs, REISERFS_ERROR_FS);
if (!old_format_only(s)) if (!old_format_only(s))
set_sb_mnt_count(rs, sb_mnt_count(rs) + 1); 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)
goto out_err_unlock; goto out_err_unlock;
reiserfs_write_unlock(s); reiserfs_write_unlock(s);
if (!(*mount_flags & MS_RDONLY)) { if (!(*mount_flags & SB_RDONLY)) {
dquot_resume(s, -1); dquot_resume(s, -1);
reiserfs_write_lock(s); reiserfs_write_lock(s);
finish_unfinished(s); finish_unfinished(s);
@ -2055,7 +2055,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
if (bdev_read_only(s->s_bdev) && !sb_rdonly(s)) { if (bdev_read_only(s->s_bdev) && !sb_rdonly(s)) {
SWARN(silent, s, "clm-7000", SWARN(silent, s, "clm-7000",
"Detected readonly device, marking FS readonly"); "Detected readonly device, marking FS readonly");
s->s_flags |= MS_RDONLY; s->s_flags |= SB_RDONLY;
} }
args.objectid = REISERFS_ROOT_OBJECTID; args.objectid = REISERFS_ROOT_OBJECTID;
args.dirid = REISERFS_ROOT_PARENT_OBJECTID; args.dirid = REISERFS_ROOT_PARENT_OBJECTID;

10
fs/reiserfs/xattr.c
View File

@ -959,7 +959,7 @@ int reiserfs_lookup_privroot(struct super_block *s)
/* /*
* We need to take a copy of the mount flags since things like * We need to take a copy of the mount flags since things like
* MS_RDONLY don't get set until *after* we're called. * SB_RDONLY don't get set until *after* we're called.
* mount_flags != mount_options * mount_flags != mount_options
*/ */
int reiserfs_xattr_init(struct super_block *s, int mount_flags) int reiserfs_xattr_init(struct super_block *s, int mount_flags)
@ -971,7 +971,7 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
if (err) if (err)
goto error; goto error;
if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) { if (d_really_is_negative(privroot) && !(mount_flags & SB_RDONLY)) {
inode_lock(d_inode(s->s_root)); inode_lock(d_inode(s->s_root));
err = create_privroot(REISERFS_SB(s)->priv_root); err = create_privroot(REISERFS_SB(s)->priv_root);
inode_unlock(d_inode(s->s_root)); inode_unlock(d_inode(s->s_root));
@ -999,11 +999,11 @@ error:
clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt); clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt);
} }
/* The super_block MS_POSIXACL must mirror the (no)acl mount option. */ /* The super_block SB_POSIXACL must mirror the (no)acl mount option. */
if (reiserfs_posixacl(s)) if (reiserfs_posixacl(s))
s->s_flags |= MS_POSIXACL; s->s_flags |= SB_POSIXACL;
else else
s->s_flags &= ~MS_POSIXACL; s->s_flags &= ~SB_POSIXACL;
return err; return err;
} }

4
fs/romfs/super.c
View File

@ -451,7 +451,7 @@ static int romfs_statfs(struct dentry *dentry, struct kstatfs *buf)
static int romfs_remount(struct super_block *sb, int *flags, char *data) static int romfs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }
@ -502,7 +502,7 @@ static int romfs_fill_super(struct super_block *sb, void *data, int silent)
sb->s_maxbytes = 0xFFFFFFFF; sb->s_maxbytes = 0xFFFFFFFF;
sb->s_magic = ROMFS_MAGIC; sb->s_magic = ROMFS_MAGIC;
sb->s_flags |= MS_RDONLY | MS_NOATIME; sb->s_flags |= SB_RDONLY | SB_NOATIME;
sb->s_op = &romfs_super_ops; sb->s_op = &romfs_super_ops;
#ifdef CONFIG_ROMFS_ON_MTD #ifdef CONFIG_ROMFS_ON_MTD

4
fs/squashfs/super.c
View File

@ -195,7 +195,7 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
(u64) le64_to_cpu(sblk->id_table_start)); (u64) le64_to_cpu(sblk->id_table_start));
sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_maxbytes = MAX_LFS_FILESIZE;
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
sb->s_op = &squashfs_super_ops; sb->s_op = &squashfs_super_ops;
err = -ENOMEM; err = -ENOMEM;
@ -373,7 +373,7 @@ static int squashfs_statfs(struct dentry *dentry, struct kstatfs *buf)
static int squashfs_remount(struct super_block *sb, int *flags, char *data) static int squashfs_remount(struct super_block *sb, int *flags, char *data)
{ {
sync_filesystem(sb); sync_filesystem(sb);
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }

6
fs/statfs.c
View File

@ -35,11 +35,11 @@ static int flags_by_mnt(int mnt_flags)
static int flags_by_sb(int s_flags) static int flags_by_sb(int s_flags)
{ {
int flags = 0; int flags = 0;
if (s_flags & MS_SYNCHRONOUS) if (s_flags & SB_SYNCHRONOUS)
flags |= ST_SYNCHRONOUS; flags |= ST_SYNCHRONOUS;
if (s_flags & MS_MANDLOCK) if (s_flags & SB_MANDLOCK)
flags |= ST_MANDLOCK; flags |= ST_MANDLOCK;
if (s_flags & MS_RDONLY) if (s_flags & SB_RDONLY)
flags |= ST_RDONLY; flags |= ST_RDONLY;
return flags; return flags;
} }

2
fs/sysfs/mount.c
View File

@ -30,7 +30,7 @@ static struct dentry *sysfs_mount(struct file_system_type *fs_type,
void *ns; void *ns;
bool new_sb; bool new_sb;
if (!(flags & MS_KERNMOUNT)) { if (!(flags & SB_KERNMOUNT)) {
if (!kobj_ns_current_may_mount(KOBJ_NS_TYPE_NET)) if (!kobj_ns_current_may_mount(KOBJ_NS_TYPE_NET))
return ERR_PTR(-EPERM); return ERR_PTR(-EPERM);
} }

2
fs/sysv/inode.c
View File

@ -63,7 +63,7 @@ static int sysv_remount(struct super_block *sb, int *flags, char *data)
sync_filesystem(sb); sync_filesystem(sb);
if (sbi->s_forced_ro) if (sbi->s_forced_ro)
*flags |= MS_RDONLY; *flags |= SB_RDONLY;
return 0; return 0;
} }

2
fs/sysv/super.c
View File

@ -333,7 +333,7 @@ static int complete_read_super(struct super_block *sb, int silent, int size)
/* set up enough so that it can read an inode */ /* set up enough so that it can read an inode */
sb->s_op = &sysv_sops; sb->s_op = &sysv_sops;
if (sbi->s_forced_ro) if (sbi->s_forced_ro)
sb->s_flags |= MS_RDONLY; sb->s_flags |= SB_RDONLY;
if (sbi->s_truncate) if (sbi->s_truncate)
sb->s_d_op = &sysv_dentry_operations; sb->s_d_op = &sysv_dentry_operations;
root_inode = sysv_iget(sb, SYSV_ROOT_INO); root_inode = sysv_iget(sb, SYSV_ROOT_INO);

2
fs/ubifs/file.c
View File

@ -1406,7 +1406,7 @@ int ubifs_update_time(struct inode *inode, struct timespec *time,
if (flags & S_MTIME) if (flags & S_MTIME)
inode->i_mtime = *time; inode->i_mtime = *time;
if (!(inode->i_sb->s_flags & MS_LAZYTIME)) if (!(inode->i_sb->s_flags & SB_LAZYTIME))
iflags |= I_DIRTY_SYNC; iflags |= I_DIRTY_SYNC;
release = ui->dirty; release = ui->dirty;

2
fs/ubifs/io.c
View File

@ -84,7 +84,7 @@ void ubifs_ro_mode(struct ubifs_info *c, int err)
if (!c->ro_error) { if (!c->ro_error) {
c->ro_error = 1; c->ro_error = 1;
c->no_chk_data_crc = 0; c->no_chk_data_crc = 0;
c->vfs_sb->s_flags |= MS_RDONLY; c->vfs_sb->s_flags |= SB_RDONLY;
ubifs_warn(c, "switched to read-only mode, error %d", err); ubifs_warn(c, "switched to read-only mode, error %d", err);
dump_stack(); dump_stack();
} }

20
fs/ubifs/super.c
View File

@ -968,7 +968,7 @@ static int parse_standard_option(const char *option)
pr_notice("UBIFS: parse %s\n", option); pr_notice("UBIFS: parse %s\n", option);
if (!strcmp(option, "sync")) if (!strcmp(option, "sync"))
return MS_SYNCHRONOUS; return SB_SYNCHRONOUS;
return 0; return 0;
} }
@ -1160,8 +1160,8 @@ static int mount_ubifs(struct ubifs_info *c)
size_t sz; size_t sz;
c->ro_mount = !!sb_rdonly(c->vfs_sb); c->ro_mount = !!sb_rdonly(c->vfs_sb);
/* Suppress error messages while probing if MS_SILENT is set */ /* Suppress error messages while probing if SB_SILENT is set */
c->probing = !!(c->vfs_sb->s_flags & MS_SILENT); c->probing = !!(c->vfs_sb->s_flags & SB_SILENT);
err = init_constants_early(c); err = init_constants_early(c);
if (err) if (err)
@ -1852,7 +1852,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data)
return err; return err;
} }
if (c->ro_mount && !(*flags & MS_RDONLY)) { if (c->ro_mount && !(*flags & SB_RDONLY)) {
if (c->ro_error) { if (c->ro_error) {
ubifs_msg(c, "cannot re-mount R/W due to prior errors"); ubifs_msg(c, "cannot re-mount R/W due to prior errors");
return -EROFS; return -EROFS;
@ -1864,7 +1864,7 @@ static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data)
err = ubifs_remount_rw(c); err = ubifs_remount_rw(c);
if (err) if (err)
return err; return err;
} else if (!c->ro_mount && (*flags & MS_RDONLY)) { } else if (!c->ro_mount && (*flags & SB_RDONLY)) {
if (c->ro_error) { if (c->ro_error) {
ubifs_msg(c, "cannot re-mount R/O due to prior errors"); ubifs_msg(c, "cannot re-mount R/O due to prior errors");
return -EROFS; return -EROFS;
@ -2117,7 +2117,7 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
*/ */
ubi = open_ubi(name, UBI_READONLY); ubi = open_ubi(name, UBI_READONLY);
if (IS_ERR(ubi)) { if (IS_ERR(ubi)) {
if (!(flags & MS_SILENT)) if (!(flags & SB_SILENT))
pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d", pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d",
current->pid, name, (int)PTR_ERR(ubi)); current->pid, name, (int)PTR_ERR(ubi));
return ERR_CAST(ubi); return ERR_CAST(ubi);
@ -2143,18 +2143,18 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
kfree(c); kfree(c);
/* A new mount point for already mounted UBIFS */ /* A new mount point for already mounted UBIFS */
dbg_gen("this ubi volume is already mounted"); dbg_gen("this ubi volume is already mounted");
if (!!(flags & MS_RDONLY) != c1->ro_mount) { if (!!(flags & SB_RDONLY) != c1->ro_mount) {
err = -EBUSY; err = -EBUSY;
goto out_deact; goto out_deact;
} }
} else { } else {
err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0); err = ubifs_fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
if (err) if (err)
goto out_deact; goto out_deact;
/* We do not support atime */ /* We do not support atime */
sb->s_flags |= MS_ACTIVE; sb->s_flags |= SB_ACTIVE;
#ifndef CONFIG_UBIFS_ATIME_SUPPORT #ifndef CONFIG_UBIFS_ATIME_SUPPORT
sb->s_flags |= MS_NOATIME; sb->s_flags |= SB_NOATIME;
#else #else
ubifs_msg(c, "full atime support is enabled."); ubifs_msg(c, "full atime support is enabled.");
#endif #endif

4
fs/ubifs/ubifs.h
View File

@ -1201,7 +1201,7 @@ struct ubifs_debug_info;
* @need_recovery: %1 if the file-system needs recovery * @need_recovery: %1 if the file-system needs recovery
* @replaying: %1 during journal replay * @replaying: %1 during journal replay
* @mounting: %1 while mounting * @mounting: %1 while mounting
* @probing: %1 while attempting to mount if MS_SILENT mount flag is set * @probing: %1 while attempting to mount if SB_SILENT mount flag is set
* @remounting_rw: %1 while re-mounting from R/O mode to R/W mode * @remounting_rw: %1 while re-mounting from R/O mode to R/W mode
* @replay_list: temporary list used during journal replay * @replay_list: temporary list used during journal replay
* @replay_buds: list of buds to replay * @replay_buds: list of buds to replay
@ -1850,7 +1850,7 @@ __printf(2, 3)
void ubifs_warn(const struct ubifs_info *c, const char *fmt, ...); void ubifs_warn(const struct ubifs_info *c, const char *fmt, ...);
/* /*
* A conditional variant of 'ubifs_err()' which doesn't output anything * A conditional variant of 'ubifs_err()' which doesn't output anything
* if probing (ie. MS_SILENT set). * if probing (ie. SB_SILENT set).
*/ */
#define ubifs_errc(c, fmt, ...) \ #define ubifs_errc(c, fmt, ...) \
do { \ do { \

6
fs/udf/super.c
View File

@ -650,7 +650,7 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
sync_filesystem(sb); sync_filesystem(sb);
if (lvidiu) { if (lvidiu) {
int write_rev = le16_to_cpu(lvidiu->minUDFWriteRev); int write_rev = le16_to_cpu(lvidiu->minUDFWriteRev);
if (write_rev > UDF_MAX_WRITE_VERSION && !(*flags & MS_RDONLY)) if (write_rev > UDF_MAX_WRITE_VERSION && !(*flags & SB_RDONLY))
return -EACCES; return -EACCES;
} }
@ -673,10 +673,10 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
sbi->s_dmode = uopt.dmode; sbi->s_dmode = uopt.dmode;
write_unlock(&sbi->s_cred_lock); write_unlock(&sbi->s_cred_lock);
if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
goto out_unlock; goto out_unlock;
if (*flags & MS_RDONLY) if (*flags & SB_RDONLY)
udf_close_lvid(sb); udf_close_lvid(sb);
else else
udf_open_lvid(sb); udf_open_lvid(sb);

8
fs/ufs/balloc.c
View File

@ -115,7 +115,7 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
ubh_mark_buffer_dirty (USPI_UBH(uspi)); ubh_mark_buffer_dirty (USPI_UBH(uspi));
ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
ubh_sync_block(UCPI_UBH(ucpi)); ubh_sync_block(UCPI_UBH(ucpi));
ufs_mark_sb_dirty(sb); ufs_mark_sb_dirty(sb);
@ -205,7 +205,7 @@ do_more:
ubh_mark_buffer_dirty (USPI_UBH(uspi)); ubh_mark_buffer_dirty (USPI_UBH(uspi));
ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
ubh_sync_block(UCPI_UBH(ucpi)); ubh_sync_block(UCPI_UBH(ucpi));
if (overflow) { if (overflow) {
@ -567,7 +567,7 @@ static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
ubh_mark_buffer_dirty (USPI_UBH(uspi)); ubh_mark_buffer_dirty (USPI_UBH(uspi));
ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
ubh_sync_block(UCPI_UBH(ucpi)); ubh_sync_block(UCPI_UBH(ucpi));
ufs_mark_sb_dirty(sb); ufs_mark_sb_dirty(sb);
@ -688,7 +688,7 @@ cg_found:
succed: succed:
ubh_mark_buffer_dirty (USPI_UBH(uspi)); ubh_mark_buffer_dirty (USPI_UBH(uspi));
ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
if (sb->s_flags & MS_SYNCHRONOUS) if (sb->s_flags & SB_SYNCHRONOUS)
ubh_sync_block(UCPI_UBH(ucpi)); ubh_sync_block(UCPI_UBH(ucpi));
ufs_mark_sb_dirty(sb); ufs_mark_sb_dirty(sb);

Some files were not shown because too many files have changed in this diff Show More