ext4: prevent parallel resizers by atomic bit ops

Before this patch, parallel resizers are allowed and protected by a
mutex lock, actually, there is no need to support parallel resizer, so
this patch prevents parallel resizers by atmoic bit ops, like
lock_page() and unlock_page() do.

To do this, the patch removed the mutex lock s_resize_lock from struct
ext4_sb_info and added a unsigned long field named s_resize_flags
which inidicates if there is a resizer.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 62cee2b6fe799a42bb7ca16dc1aeb73dc0e02e70..bb0f7760c7c8b6c6c26aaaa609c80ca7adf4abf9 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1127,7 +1127,8 @@ struct ext4_sb_info {
        struct journal_s *s_journal;
        struct list_head s_orphan;
        struct mutex s_orphan_lock;
-       struct mutex s_resize_lock;
+       unsigned long s_resize_flags;           /* Flags indicating if there
+                                                  is a resizer */
        unsigned long s_commit_interval;
        u32 s_max_batch_time;
        u32 s_min_batch_time;
@@ -2269,6 +2270,10 @@ static inline void set_bitmap_uptodate(struct buffer_head *bh)
 extern wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
 extern struct mutex ext4__aio_mutex[EXT4_WQ_HASH_SZ];
 
+#define EXT4_RESIZING  0
+extern int ext4_resize_begin(struct super_block *sb);
+extern void ext4_resize_end(struct super_block *sb);
+
 #endif /* __KERNEL__ */
 
 #endif /* _EXT4_H */

diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 808c554e773fdc2658c4708f1697edabab665acc..f18bfe37aff845cedd3dd3acf6c9d0e2225926ae 100644 (file)
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -202,8 +202,9 @@ setversion_out:
                struct super_block *sb = inode->i_sb;
                int err, err2=0;
 
-               if (!capable(CAP_SYS_RESOURCE))
-                       return -EPERM;
+               err = ext4_resize_begin(sb);
+               if (err)
+                       return err;
 
                if (get_user(n_blocks_count, (__u32 __user *)arg))
                        return -EFAULT;
@@ -221,6 +222,7 @@ setversion_out:
                if (err == 0)
                        err = err2;
                mnt_drop_write(filp->f_path.mnt);
+               ext4_resize_end(sb);
 
                return err;
        }
@@ -271,8 +273,9 @@ mext_out:
                struct super_block *sb = inode->i_sb;
                int err, err2=0;
 
-               if (!capable(CAP_SYS_RESOURCE))
-                       return -EPERM;
+               err = ext4_resize_begin(sb);
+               if (err)
+                       return err;
 
                if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
                                sizeof(input)))
@@ -291,6 +294,7 @@ mext_out:
                if (err == 0)
                        err = err2;
                mnt_drop_write(filp->f_path.mnt);
+               ext4_resize_end(sb);
 
                return err;
        }

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 80bbc9c60c247659047b805c9a74155bf2baeb14..0213f631271ff4ce8814cba83d0dfee418a7b1fc 100644 (file)
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -16,6 +16,25 @@
 
 #include "ext4_jbd2.h"
 
+int ext4_resize_begin(struct super_block *sb)
+{
+       int ret = 0;
+
+       if (!capable(CAP_SYS_RESOURCE))
+               return -EPERM;
+
+       if (test_and_set_bit_lock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags))
+               ret = -EBUSY;
+
+       return ret;
+}
+
+void ext4_resize_end(struct super_block *sb)
+{
+       clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags);
+       smp_mb__after_clear_bit();
+}
+
 #define outside(b, first, last)        ((b) < (first) || (b) >= (last))
 #define inside(b, first, last) ((b) >= (first) && (b) < (last))
 
@@ -181,11 +200,7 @@ static int setup_new_group_blocks(struct super_block *sb,
        if (IS_ERR(handle))
                return PTR_ERR(handle);
 
-       mutex_lock(&sbi->s_resize_lock);
-       if (input->group != sbi->s_groups_count) {
-               err = -EBUSY;
-               goto exit_journal;
-       }
+       BUG_ON(input->group != sbi->s_groups_count);
 
        if (IS_ERR(bh = bclean(handle, sb, input->block_bitmap))) {
                err = PTR_ERR(bh);
@@ -285,7 +300,6 @@ exit_bh:
        brelse(bh);
 
 exit_journal:
-       mutex_unlock(&sbi->s_resize_lock);
        if ((err2 = ext4_journal_stop(handle)) && !err)
                err = err2;
 
@@ -799,13 +813,6 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
                goto exit_put;
        }
 
-       mutex_lock(&sbi->s_resize_lock);
-       if (input->group != sbi->s_groups_count) {
-               ext4_warning(sb, "multiple resizers run on filesystem!");
-               err = -EBUSY;
-               goto exit_journal;
-       }
-
        if ((err = ext4_journal_get_write_access(handle, sbi->s_sbh)))
                goto exit_journal;
 
@@ -829,7 +836,6 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
         /*
          * OK, now we've set up the new group.  Time to make it active.
          *
-         * We do not lock all allocations via s_resize_lock
          * so we have to be safe wrt. concurrent accesses the group
          * data.  So we need to be careful to set all of the relevant
          * group descriptor data etc. *before* we enable the group.
@@ -886,13 +892,9 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
         *
         * The precise rules we use are:
         *
-        * * Writers of s_groups_count *must* hold s_resize_lock
-        * AND
         * * Writers must perform a smp_wmb() after updating all dependent
         *   data and before modifying the groups count
         *
-        * * Readers must hold s_resize_lock over the access
-        * OR
         * * Readers must perform an smp_rmb() after reading the groups count
         *   and before reading any dependent data.
         *
@@ -937,7 +939,6 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
        ext4_handle_dirty_super(handle, sb);
 
 exit_journal:
-       mutex_unlock(&sbi->s_resize_lock);
        if ((err2 = ext4_journal_stop(handle)) && !err)
                err = err2;
        if (!err) {
@@ -972,9 +973,6 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
        int err;
        ext4_group_t group;
 
-       /* We don't need to worry about locking wrt other resizers just
-        * yet: we're going to revalidate es->s_blocks_count after
-        * taking the s_resize_lock below. */
        o_blocks_count = ext4_blocks_count(es);
 
        if (test_opt(sb, DEBUG))
@@ -995,7 +993,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 
        if (n_blocks_count < o_blocks_count) {
                ext4_warning(sb, "can't shrink FS - resize aborted");
-               return -EBUSY;
+               return -EINVAL;
        }
 
        /* Handle the remaining blocks in the last group only. */
@@ -1038,24 +1036,13 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
                goto exit_put;
        }
 
-       mutex_lock(&EXT4_SB(sb)->s_resize_lock);
-       if (o_blocks_count != ext4_blocks_count(es)) {
-               ext4_warning(sb, "multiple resizers run on filesystem!");
-               mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
-               ext4_journal_stop(handle);
-               err = -EBUSY;
-               goto exit_put;
-       }
-
        if ((err = ext4_journal_get_write_access(handle,
                                                 EXT4_SB(sb)->s_sbh))) {
                ext4_warning(sb, "error %d on journal write access", err);
-               mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
                ext4_journal_stop(handle);
                goto exit_put;
        }
        ext4_blocks_count_set(es, o_blocks_count + add);
-       mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
        ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
                   o_blocks_count + add);
        /* We add the blocks to the bitmap and set the group need init bit */

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 143d763729b40ea0c3d287dfd574e03963702fde..cfe9f39c4ba2e16ca14962a832187ec42554eb8a 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -3500,7 +3500,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 
        INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
        mutex_init(&sbi->s_orphan_lock);
-       mutex_init(&sbi->s_resize_lock);
+       sbi->s_resize_flags = 0;
 
        sb->s_root = NULL;