read-only remount fixes
cover read-only remount fixes
Al,
Here's the series redone to address your comments. Please apply.
Thanks,
Miklos
PATCH 1/4 vfs: ignore error on forced remount
From: Miklos Szeredi <[email protected]>
On emergency remount we want to force MS_RDONLY on the super block even if ->remount_fs() failed for some reason.
--- fs/super.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/super.c +2 -1
@@ -579,7 +579,8 @@ int do_remount_sb(struct super_block *sbif (sb->s_op->remount_fs) { retval = sb->s_op->remount_fs (sb, &flags, data); -if (retval) +/* If forced remount, go ahead despite any errors */ +if (retval && !force)return retval; } sb->s_flags = (sb->s_flags & ~MS_RMT_MASK ) | (flags &MS_RMT_MASK );
PATCH 2/4 vfs: keep list of mounts for each superblock
In reply to Miklos SzerediFrom: Miklos Szeredi <[email protected]>
Keep track of vfsmounts belonging to a superblock. List is protected by vfsmount_lock.
--- fs/namespace.c | 5 +++++ fs/super.c | 7 +++++++ include/linux/fs.h | 1 + include/linux/mount.h | 1 + 4 files changed, 14 insertions(+)
include/linux/fs.h +1 -0
@@ -1348,6 +1348,7 @@ struct super_block {#else struct list_head s_files;#endif +struct list_head s_mounts;/* list of mounts */ /* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */ struct list_head s_dentry_lru;/* unused dentry lru */ int s_nr_dentry_unused;/* # of dentry on lru */
include/linux/mount.h +1 -0
@@ -54,6 +54,7 @@ struct vfsmount {struct super_block *mnt_sb;/* pointer to superblock */ struct list_head mnt_mounts;/* list of children, anchored here */ struct list_head mnt_child;/* and going through their mnt_child */ +struct list_head mnt_instance;/* mount instance on sb->s_mounts */ int mnt_flags;/* 4 bytes hole on 64bits arches without fsnotify */ #ifdef CONFIG_FSNOTIFY
fs/namespace.c +5 -0
@@ -622,6 +622,10 @@ static struct vfsmount *clone_mnt(structif (!list_empty (&old->mnt_expire))list_add (&mnt->mnt_expire, &old->mnt_expire); } + +br_write_lock (vfsmount_lock); +list_add_tail (&mnt->mnt_instance, &mnt->mnt_sb->s_mounts); +br_write_unlock (vfsmount_lock); }return mnt;
@@ -661,6 +665,7 @@ void mntput_no_expire(struct vfsmount *mreturn ; }if (likely (!mnt->mnt_pinned)) { +list_del (&mnt->mnt_instance);br_write_unlock (vfsmount_lock);__mntput (mnt);return ;
fs/super.c +7 -0
@@ -74,6 +74,7 @@ static struct super_block *alloc_super(sINIT_HLIST_HEAD (&s->s_anon);INIT_LIST_HEAD (&s->s_inodes);INIT_LIST_HEAD (&s->s_dentry_lru); +INIT_LIST_HEAD (&s->s_mounts);init_rwsem (&s->s_umount);mutex_init (&s->s_lock);lockdep_set_class (&s->s_umount, &type->s_umount_key);
@@ -127,6 +128,7 @@ static inline void destroy_super(structfree_percpu (s->s_files);#endif security_sb_free (s); +WARN_ON (!list_empty (&s->s_mounts));kfree (s->s_subtype);kfree (s->s_options);kfree (s);
@@ -968,6 +970,11 @@ vfs_kern_mount(struct file_system_type * mnt->mnt_parent = mnt;up_write (&mnt->mnt_sb->s_umount);free_secdata (secdata); + +br_write_lock (vfsmount_lock); +list_add_tail (&mnt->mnt_instance, &mnt->mnt_sb->s_mounts); +br_write_unlock (vfsmount_lock); +return mnt; out_sb:dput (mnt->mnt_root);
PATCH 3/4 vfs: protect remounting superblock read-only
In reply to Miklos SzerediFrom: Miklos Szeredi <[email protected]>
Currently remouting superblock read-only is racy in a major way.
With the per mount read-only infrastructure it is now possible to prevent most races, which this patch attempts.
Before starting the remount read-only, iterate through all mounts belonging to the superblock and if none of them have any pending writes, set sb->s_readonly_remount. This indicates that remount is in progress and no further write requests are allowed. If the remount succeeds set MS_RDONLY and reset s_readonly_remount.
If the remounting is unsuccessful just reset s_readonly_remount. This can result in transient EROFS errors, despite the fact the remount failed. Unfortunately hodling off writes is difficult as remount itself may touch the filesystem (e.g. through load_nls()) which would deadlock.
Small races still remain because delayed writes due to nlink going to zero but inode still having a reference are not dealt with by this patch.
--- fs/internal.h | 1 + fs/namespace.c | 40 +++++++++++++++++++++++++++++++++++++++- fs/super.c | 22 ++++++++++++++++++---- include/linux/fs.h | 3 +++ 4 files changed, 61 insertions(+), 5 deletions(-)
fs/internal.h +1 -0
@@ -69,6 +69,7 @@ extern void mnt_set_mountpoint(struct vfextern void release_mounts (struct list_head *);extern void umount_tree (struct vfsmount *,int ,struct list_head *);extern struct vfsmount *copy_tree (struct vfsmount *,struct dentry *,int ); +extern int sb_prepare_remount_readonly (struct super_block *);extern void __init mnt_init (void );
fs/namespace.c +39 -1
@@ -251,6 +251,15 @@ static unsigned int count_mnt_writers(st#endif } +static int mnt_is_readonly (struct vfsmount *mnt) +{ +if (mnt->mnt_sb->s_readonly_remount) +return 1 ; +/* Order wrt setting s_flags/s_readonly_remount in do_remount() */ +smp_rmb (); +return __mnt_is_readonly (mnt); +} +/* * Most r/o checks on a fs are for operations that take * discrete amounts of time, like a write() or unlink().
@@ -289,7 +298,7 @@ int mnt_want_write(struct vfsmount *mnt)* MNT_WRITE_HOLD is cleared. */ smp_rmb (); -if (__mnt_is_readonly (mnt)) { +if (mnt_is_readonly (mnt)) {dec_mnt_writers (mnt); ret = -EROFS ; goto out;
@@ -406,6 +415,35 @@ static void __mnt_unmake_readonly(structbr_write_unlock (vfsmount_lock); } +int sb_prepare_remount_readonly (struct super_block *sb) +{ +struct vfsmount *mnt; +int err =0 ; + +br_write_lock (vfsmount_lock); +list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { +if (!(mnt->mnt_flags &MNT_READONLY )) { + mnt->mnt_flags |=MNT_WRITE_HOLD ; +smp_mb (); +if (count_mnt_writers (mnt) >0 ) { + err = -EBUSY ; +break ; + } + } + } +if (!err) { + sb->s_readonly_remount =1 ; +smp_wmb (); + } +list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { +if (mnt->mnt_flags &MNT_WRITE_HOLD ) + mnt->mnt_flags &= ~MNT_WRITE_HOLD ; + } +br_write_unlock (vfsmount_lock); + +return err; +} +void simple_set_mnt (struct vfsmount *mnt,struct super_block *sb) { mnt->mnt_sb = sb;
fs/super.c +18 -4
@@ -573,19 +573,29 @@ int do_remount_sb(struct super_block *sb/* If we are remounting RDONLY and current sb is read/write, make sure there are no rw files opened */ if (remount_ro) { -if (force) +if (force) {mark_files_ro (sb); -else if (!fs_may_remount_ro (sb)) -return -EBUSY ; + }else { + retval =sb_prepare_remount_readonly (sb); +if (retval) +return retval; + + retval = -EBUSY ; +if (!fs_may_remount_ro (sb)) + goto cancel_readonly; + } }if (sb->s_op->remount_fs) { retval = sb->s_op->remount_fs (sb, &flags, data);/* If forced remount, go ahead despite any errors */ if (retval && !force) -return retval; + goto cancel_readonly; } sb->s_flags = (sb->s_flags & ~MS_RMT_MASK ) | (flags &MS_RMT_MASK ); +/* Needs to be ordered wrt mnt_is_readonly() */ +smp_wmb (); + sb->s_readonly_remount =0 ;/* * Some filesystems modify their metadata via some other path than the
@@ -598,6 +608,10 @@ int do_remount_sb(struct super_block *sbif (remount_ro && sb->s_bdev)invalidate_bdev (sb->s_bdev);return 0 ; + +cancel_readonly: + sb->s_readonly_remount =0 ; +return retval; }static void do_emergency_remount (struct work_struct *work)
include/linux/fs.h +3 -0
@@ -1388,6 +1388,9 @@ struct super_block {* generic_show_options() */ char __rcu *s_options; + +/* Being remounted read-only */ +int s_readonly_remount; };extern struct timespec current_fs_time (struct super_block *sb);
PATCH 4/4 vfs: fs_may_remount_ro: turn unnecessary check into a WARN_ON
In reply to Miklos SzerediFrom: Miklos Szeredi <[email protected]>
Now a successful sb_prepare_remount_readonly() should ensure that no writable files remain for this superblock. So turn this check into a WARN_ON.
--- fs/file_table.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
fs/file_table.c +5 -2
@@ -437,8 +437,11 @@ int fs_may_remount_ro(struct super_blockif (inode->i_nlink ==0 ) goto too_bad; -/* Writeable file? */ -if (S_ISREG (inode->i_mode) && (file->f_mode &FMODE_WRITE )) +/* +* Writable file? +* Should be caught by sb_prepare_remount_readonly(). +*/ +if (WARN_ON (S_ISREG (inode->i_mode) && (file->f_mode &FMODE_WRITE ))) goto too_bad; } while_file_list_for_each_entry;lg_global_unlock (files_lglock);