Revert "btrfs: should block unused block groups deletion work when allocating data...

This reverts commit 7ba61c9b42a920f86d7b7e8c023da676c4e0b439.

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 89f86d02a9d8c362f3f107ecc53b29acbf2ba694..9105406b752ae5402211037e425295c43d79aa5b 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1572,7 +1572,6 @@ struct btrfs_fs_info {
        struct mutex cleaner_mutex;
        struct mutex chunk_mutex;
        struct mutex volume_mutex;
-       struct rw_semaphore bg_delete_sem;
 
        /*
         * this is taken to make sure we don't set block groups ro after
@@ -1849,6 +1848,7 @@ struct btrfs_fs_info {
        spinlock_t unused_bgs_lock;
        struct list_head unused_bgs;
        struct mutex unused_bg_unpin_mutex;
+       struct mutex delete_unused_bgs_mutex;
 
        /* For btrfs to record security options */
        struct security_mnt_opts security_opts;

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index b43f9bd8cb27c4eb84de7b5615d9889dec25aa9a..0796a9f3b9f9279306d325fe35f7f6d94ba27848 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1855,11 +1855,12 @@ static int cleaner_kthread(void *arg)
                btrfs_run_defrag_inodes(root->fs_info);
 
                /*
-                * Acquires fs_info->bg_delete_sem to avoid racing with
-                * relocation (btrfs_relocate_chunk) and relocation acquires
-                * fs_info->cleaner_mutex (btrfs_relocate_block_group) after
-                * acquiring fs_info->bg_delete_sem. So we can't hold, nor need
-                * to, fs_info->cleaner_mutex when deleting unused block groups.
+                * Acquires fs_info->delete_unused_bgs_mutex to avoid racing
+                * with relocation (btrfs_relocate_chunk) and relocation
+                * acquires fs_info->cleaner_mutex (btrfs_relocate_block_group)
+                * after acquiring fs_info->delete_unused_bgs_mutex. So we
+                * can't hold, nor need to, fs_info->cleaner_mutex when deleting
+                * unused block groups.
                 */
                btrfs_delete_unused_bgs(root->fs_info);
 sleep:
@@ -2610,6 +2611,7 @@ int open_ctree(struct super_block *sb,
        spin_lock_init(&fs_info->unused_bgs_lock);
        rwlock_init(&fs_info->tree_mod_log_lock);
        mutex_init(&fs_info->unused_bg_unpin_mutex);
+       mutex_init(&fs_info->delete_unused_bgs_mutex);
        mutex_init(&fs_info->reloc_mutex);
        mutex_init(&fs_info->delalloc_root_mutex);
        mutex_init(&fs_info->cleaner_delayed_iput_mutex);
@@ -2696,7 +2698,6 @@ int open_ctree(struct super_block *sb,
        init_rwsem(&fs_info->commit_root_sem);
        init_rwsem(&fs_info->cleanup_work_sem);
        init_rwsem(&fs_info->subvol_sem);
-       init_rwsem(&fs_info->bg_delete_sem);
        sema_init(&fs_info->uuid_tree_rescan_sem, 1);
 
        btrfs_init_dev_replace_locks(fs_info);

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 87358682ee8416250b11e88706993fe02238cf18..ec1902eee33643e01aeabb6efe71bd7c2a950469 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -4070,7 +4070,6 @@ int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes)
        int ret = 0;
        int need_commit = 2;
        int have_pinned_space;
-       int have_bg_delete_sem = 0;
 
        /* make sure bytes are sectorsize aligned */
        bytes = ALIGN(bytes, root->sectorsize);
@@ -4081,11 +4080,8 @@ int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes)
        }
 
        data_sinfo = fs_info->data_sinfo;
-       if (!data_sinfo) {
-               down_read(&root->fs_info->bg_delete_sem);
-               have_bg_delete_sem = 1;
+       if (!data_sinfo)
                goto alloc;
-       }
 
 again:
        /* make sure we have enough space to handle the data first */
@@ -4097,17 +4093,6 @@ again:
        if (used + bytes > data_sinfo->total_bytes) {
                struct btrfs_trans_handle *trans;
 
-               /*
-                * We may need to allocate new chunk, so we should block
-                * btrfs_delete_unused_bgs()
-                */
-               if (!have_bg_delete_sem) {
-                       spin_unlock(&data_sinfo->lock);
-                       down_read(&root->fs_info->bg_delete_sem);
-                       have_bg_delete_sem = 1;
-                       goto again;
-               }
-
                /*
                 * if we don't have enough free bytes in this space then we need
                 * to alloc a new chunk.
@@ -4130,20 +4115,17 @@ alloc:
                         * the fs.
                         */
                        trans = btrfs_join_transaction(root);
-                       if (IS_ERR(trans)) {
-                               up_read(&root->fs_info->bg_delete_sem);
+                       if (IS_ERR(trans))
                                return PTR_ERR(trans);
-                       }
 
                        ret = do_chunk_alloc(trans, root->fs_info->extent_root,
                                             alloc_target,
                                             CHUNK_ALLOC_NO_FORCE);
                        btrfs_end_transaction(trans, root);
                        if (ret < 0) {
-                               if (ret != -ENOSPC) {
-                                       up_read(&root->fs_info->bg_delete_sem);
+                               if (ret != -ENOSPC)
                                        return ret;
-                               } else {
+                               else {
                                        have_pinned_space = 1;
                                        goto commit_trans;
                                }
@@ -4177,19 +4159,15 @@ commit_trans:
                        }
 
                        trans = btrfs_join_transaction(root);
-                       if (IS_ERR(trans)) {
-                               up_read(&root->fs_info->bg_delete_sem);
+                       if (IS_ERR(trans))
                                return PTR_ERR(trans);
-                       }
                        if (have_pinned_space >= 0 ||
                            test_bit(BTRFS_TRANS_HAVE_FREE_BGS,
                                     &trans->transaction->flags) ||
                            need_commit > 0) {
                                ret = btrfs_commit_transaction(trans, root);
-                               if (ret) {
-                                       up_read(&root->fs_info->bg_delete_sem);
+                               if (ret)
                                        return ret;
-                               }
                                /*
                                 * The cleaner kthread might still be doing iput
                                 * operations. Wait for it to finish so that
@@ -4206,7 +4184,6 @@ commit_trans:
                trace_btrfs_space_reservation(root->fs_info,
                                              "space_info:enospc",
                                              data_sinfo->flags, bytes, 1);
-               up_read(&root->fs_info->bg_delete_sem);
                return -ENOSPC;
        }
        data_sinfo->bytes_may_use += bytes;
@@ -4214,9 +4191,6 @@ commit_trans:
                                      data_sinfo->flags, bytes, 1);
        spin_unlock(&data_sinfo->lock);
 
-       if (have_bg_delete_sem)
-               up_read(&root->fs_info->bg_delete_sem);
-
        return ret;
 }
 
@@ -10535,7 +10509,7 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
                }
                spin_unlock(&fs_info->unused_bgs_lock);
 
-               down_write(&root->fs_info->bg_delete_sem);
+               mutex_lock(&fs_info->delete_unused_bgs_mutex);
 
                /* Don't want to race with allocators so take the groups_sem */
                down_write(&space_info->groups_sem);
@@ -10663,7 +10637,7 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
 end_trans:
                btrfs_end_transaction(trans, root);
 next:
-               up_write(&root->fs_info->bg_delete_sem);
+               mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                btrfs_put_block_group(block_group);
                spin_lock(&fs_info->unused_bgs_lock);
        }

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 30db340e746568b845a66c3b262d66ab4c56a0dd..b65735e6803eaf5eb6317b34a3f62ab7ccce8df6 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -2847,7 +2847,7 @@ static int btrfs_relocate_chunk(struct btrfs_root *root, u64 chunk_offset)
         * we release the path used to search the chunk/dev tree and before
         * the current task acquires this mutex and calls us.
         */
-       ASSERT(rwsem_is_locked(&root->fs_info->bg_delete_sem));
+       ASSERT(mutex_is_locked(&root->fs_info->delete_unused_bgs_mutex));
 
        ret = btrfs_can_relocate(extent_root, chunk_offset);
        if (ret)
@@ -2900,10 +2900,10 @@ again:
        key.type = BTRFS_CHUNK_ITEM_KEY;
 
        while (1) {
-               down_read(&root->fs_info->bg_delete_sem);
+               mutex_lock(&root->fs_info->delete_unused_bgs_mutex);
                ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
                if (ret < 0) {
-                       up_read(&root->fs_info->bg_delete_sem);
+                       mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
                        goto error;
                }
                BUG_ON(ret == 0); /* Corruption */
@@ -2911,7 +2911,7 @@ again:
                ret = btrfs_previous_item(chunk_root, path, key.objectid,
                                          key.type);
                if (ret)
-                       up_read(&root->fs_info->bg_delete_sem);
+                       mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
                if (ret < 0)
                        goto error;
                if (ret > 0)
@@ -2933,7 +2933,7 @@ again:
                        else
                                BUG_ON(ret);
                }
-               up_read(&root->fs_info->bg_delete_sem);
+               mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
 
                if (found_key.offset == 0)
                        break;
@@ -3489,10 +3489,10 @@ again:
                        goto error;
                }
 
-               down_read(&fs_info->bg_delete_sem);
+               mutex_lock(&fs_info->delete_unused_bgs_mutex);
                ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
                if (ret < 0) {
-                       up_read(&fs_info->bg_delete_sem);
+                       mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                        goto error;
                }
 
@@ -3506,7 +3506,7 @@ again:
                ret = btrfs_previous_item(chunk_root, path, 0,
                                          BTRFS_CHUNK_ITEM_KEY);
                if (ret) {
-                       up_read(&fs_info->bg_delete_sem);
+                       mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                        ret = 0;
                        break;
                }
@@ -3516,7 +3516,7 @@ again:
                btrfs_item_key_to_cpu(leaf, &found_key, slot);
 
                if (found_key.objectid != key.objectid) {
-                       up_read(&fs_info->bg_delete_sem);
+                       mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                        break;
                }
 
@@ -3534,12 +3534,12 @@ again:
 
                btrfs_release_path(path);
                if (!ret) {
-                       up_read(&fs_info->bg_delete_sem);
+                       mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                        goto loop;
                }
 
                if (counting) {
-                       up_read(&fs_info->bg_delete_sem);
+                       mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                        spin_lock(&fs_info->balance_lock);
                        bctl->stat.expected++;
                        spin_unlock(&fs_info->balance_lock);
@@ -3564,7 +3564,7 @@ again:
                                        count_meta < bctl->meta.limit_min)
                                || ((chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) &&
                                        count_sys < bctl->sys.limit_min)) {
-                       up_read(&fs_info->bg_delete_sem);
+                       mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                        goto loop;
                }
 
@@ -3577,7 +3577,7 @@ again:
                    !chunk_reserved && !bytes_used) {
                        trans = btrfs_start_transaction(chunk_root, 0);
                        if (IS_ERR(trans)) {
-                               up_read(&fs_info->bg_delete_sem);
+                               mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                                ret = PTR_ERR(trans);
                                goto error;
                        }
@@ -3586,7 +3586,7 @@ again:
                                                      BTRFS_BLOCK_GROUP_DATA);
                        btrfs_end_transaction(trans, chunk_root);
                        if (ret < 0) {
-                               up_read(&fs_info->bg_delete_sem);
+                               mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                                goto error;
                        }
                        chunk_reserved = 1;
@@ -3594,7 +3594,7 @@ again:
 
                ret = btrfs_relocate_chunk(chunk_root,
                                           found_key.offset);
-               up_read(&fs_info->bg_delete_sem);
+               mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                if (ret && ret != -ENOSPC)
                        goto error;
                if (ret == -ENOSPC) {
@@ -4320,16 +4320,16 @@ again:
        key.type = BTRFS_DEV_EXTENT_KEY;
 
        do {
-               down_read(&root->fs_info->bg_delete_sem);
+               mutex_lock(&root->fs_info->delete_unused_bgs_mutex);
                ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                if (ret < 0) {
-                       up_read(&root->fs_info->bg_delete_sem);
+                       mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
                        goto done;
                }
 
                ret = btrfs_previous_item(root, path, 0, key.type);
                if (ret)
-                       up_read(&root->fs_info->bg_delete_sem);
+                       mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
                if (ret < 0)
                        goto done;
                if (ret) {
@@ -4343,7 +4343,7 @@ again:
                btrfs_item_key_to_cpu(l, &key, path->slots[0]);
 
                if (key.objectid != device->devid) {
-                       up_read(&root->fs_info->bg_delete_sem);
+                       mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
                        btrfs_release_path(path);
                        break;
                }
@@ -4352,7 +4352,7 @@ again:
                length = btrfs_dev_extent_length(l, dev_extent);
 
                if (key.offset + length <= new_size) {
-                       up_read(&root->fs_info->bg_delete_sem);
+                       mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
                        btrfs_release_path(path);
                        break;
                }
@@ -4361,7 +4361,7 @@ again:
                btrfs_release_path(path);
 
                ret = btrfs_relocate_chunk(root, chunk_offset);
-               up_read(&root->fs_info->bg_delete_sem);
+               mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
                if (ret && ret != -ENOSPC)
                        goto done;
                if (ret == -ENOSPC)