fs: Provide helpers for manipulating sb->s_readonly_remount
Jan Kara
reviewerPATCH v3 1/1 fs: Provide helpers for manipulating sb->s_readonly_remount
Provide helpers to set and clear sb->s_readonly_remount including appropriate memory barriers. Also use this opportunity to document what the barriers pair with and why they are needed.
--- fs/internal.h | 41 +++++++++++++++++++++++++++++++++++++++++ fs/namespace.c | 25 ++++++++++++++++--------- fs/super.c | 17 ++++++----------- include/linux/fs.h | 2 +- 4 files changed, 64 insertions(+), 21 deletions(-)
fs/internal.h +41 -0
@@ -120,6 +120,47 @@ void put_super(struct super_block *sb);extern bool mount_capable (struct fs_context *);int sb_init_dio_done_wq (struct super_block *sb); +/* +* Prepare superblock for changing its read-only state (i.e., either remount +* read-write superblock read-only or vice versa). After this function returns +* mnt_is_readonly() will return true for any mount of the superblock if its +* caller is able to observe any changes done by the remount. This holds until +* sb_end_ro_state_change() is called. +*/ +static inline void sb_start_ro_state_change (struct super_block *sb) +{ +WRITE_ONCE (sb->s_readonly_remount,1 ); +/* +* For RO->RW transition, the barrier pairs with the barrier in +* mnt_is_readonly() making sure if mnt_is_readonly() sees SB_RDONLY +* cleared, it will see s_readonly_remount set. +* For RW->RO transition, the barrier pairs with the barrier in +* __mnt_want_write() before the mnt_is_readonly() check. The barrier +* makes sure if __mnt_want_write() sees MNT_WRITE_HOLD already +* cleared, it will see s_readonly_remount set. +*/ +smp_wmb (); +} + +/* +* Ends section changing read-only state of the superblock. After this function +* returns if mnt_is_readonly() returns false, the caller will be able to +* observe all the changes remount did to the superblock. +*/ +static inline void sb_end_ro_state_change (struct super_block *sb) +{ +/* +* This barrier provides release semantics that pairs with +* the smp_rmb() acquire semantics in mnt_is_readonly(). +* This barrier pair ensure that when mnt_is_readonly() sees +* 0 for sb->s_readonly_remount, it will also see all the +* preceding flag changes that were made during the RO state +* change. +*/ +smp_wmb (); +WRITE_ONCE (sb->s_readonly_remount,0 ); +} +/* * open.c */
fs/namespace.c +16 -9
@@ -309,9 +309,16 @@ static unsigned int mnt_get_writers(struct mount *mnt)static int mnt_is_readonly (struct vfsmount *mnt) { -if (mnt->mnt_sb->s_readonly_remount) +if (READ_ONCE (mnt->mnt_sb->s_readonly_remount))return 1 ; -/* Order wrt setting s_flags/s_readonly_remount in do_remount() */ +/* +* The barrier pairs with the barrier in sb_start_ro_state_change() +* making sure if we don't see s_readonly_remount set yet, we also will +* not see any superblock / mount flag changes done by remount. +* It also pairs with the barrier in sb_end_ro_state_change() +* assuring that if we see s_readonly_remount already cleared, we will +* see the values of superblock / mount flags updated by remount. +*/ smp_rmb ();return __mnt_is_readonly (mnt); }
@@ -364,9 +371,11 @@ int __mnt_want_write(struct vfsmount *m) } }/* -* After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will -* be set to match its requirements. So we must not load that until -* MNT_WRITE_HOLD is cleared. +* The barrier pairs with the barrier sb_start_ro_state_change() making +* sure that if we see MNT_WRITE_HOLD cleared, we will also see +* s_readonly_remount set (or even SB_RDONLY / MNT_READONLY flags) in +* mnt_is_readonly() and bail in case we are racing with remount +* read-only. */ smp_rmb ();if (mnt_is_readonly (m)) {
@@ -588,10 +597,8 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err &&atomic_long_read (&sb->s_remove_count)) err = -EBUSY ; -if (!err) { - sb->s_readonly_remount =1 ; -smp_wmb (); - } +if (!err) +sb_start_ro_state_change (sb);list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) {if (mnt->mnt.mnt_flags &MNT_WRITE_HOLD ) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ;
fs/super.c +6 -11
@@ -944,8 +944,7 @@ int reconfigure_super(struct fs_context *fc)*/ if (remount_ro) {if (force) { - sb->s_readonly_remount =1 ; -smp_wmb (); +sb_start_ro_state_change (sb); }else { retval =sb_prepare_remount_readonly (sb);if (retval)
@@ -953,12 +952,10 @@ int reconfigure_super(struct fs_context *fc) } }else if (remount_rw) {/* -* We set s_readonly_remount here to protect filesystem's -* reconfigure code from writes from userspace until -* reconfigure finishes. +* Protect filesystem's reconfigure code from writes from +* userspace until reconfigure finishes. */ - sb->s_readonly_remount =1 ; -smp_wmb (); +sb_start_ro_state_change (sb); }if (fc->ops->reconfigure) {
@@ -974,9 +971,7 @@ int reconfigure_super(struct fs_context *fc)WRITE_ONCE (sb->s_flags, ((sb->s_flags & ~fc->sb_flags_mask) | (fc->sb_flags & fc->sb_flags_mask))); -/* Needs to be ordered wrt mnt_is_readonly() */ -smp_wmb (); - sb->s_readonly_remount =0 ; +sb_end_ro_state_change (sb);/* * Some filesystems modify their metadata via some other path than the
@@ -991,7 +986,7 @@ int reconfigure_super(struct fs_context *fc)return 0 ; cancel_readonly: - sb->s_readonly_remount =0 ; +sb_end_ro_state_change (sb);return retval; }
include/linux/fs.h +1 -1
@@ -1242,7 +1242,7 @@ struct super_block {*/ atomic_long_t s_fsnotify_connectors; -/* Being remounted read-only */ +/* Read-only state of the superblock is being changed */ int s_readonly_remount;/* per-sb errseq_t for reporting writeback errors via syncfs */
Signature · 1 line
2.35.3
Quoted 5 lines · Jan Kara
Provide helpers to set and clear
sb->s_readonly_remountincluding appropriate memory barriers. Also use this opportunity to document what the barriers pair with and why they are needed.
Thanks for the updated comments.
---
Applied to the vfs.misc branch of the vfs/vfs.git tree. Patches in the vfs.misc branch should appear in linux-next soon.
Please report any outstanding bugs that were missed during review in a new review to the original patch series allowing us to drop it.
It's encouraged to provide Acked-bys and Reviewed-bys even though the patch has now been applied. If possible patch trailers will be updated.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git branch: vfs.misc
[1/1] fs: Provide helpers for manipulating sb->s_readonly_remount
https://git.kernel.org/vfs/vfs/c/67a91f780e98
Quoted 4 lines · Jan Kara
Provide helpers to set and clear
sb->s_readonly_remountincluding appropriate memory barriers. Also use this opportunity to document what the barriers pair with and why they are needed.
Quoted 8 lines
Suggested-by Dave Chinner <[email protected]>Signed-off-by Jan Kara <[email protected]>--- fs/internal.h | 41 +++++++++++++++++++++++++++++++++++++++++ fs/namespace.c | 25 ++++++++++++++++--------- fs/super.c | 17 ++++++----------- include/linux/fs.h | 2 +- 4 files changed, 64 insertions(+), 21 deletions(-)
Looks good.
Signature · 2 lines
Dave Chinner [email protected]