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

This reverts commit 0344ff81d0a7967e8a4f84f75fd40a184b9952bb.

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 8ccfff91b17fb140a46c82a18d18c8ee2b825a96..e277e4b6333529b8198caf113906346e4284aed4 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
@@ -1850,6 +1849,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 d168d6c4d70b7d461d71e7e8e89346f096a62aa9..234f266b6d2a86234238143a2fab859a29ed6cb6 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1822,11 +1822,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:
@@ -2578,6 +2579,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);
@@ -2664,7 +2666,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 a47705f8fae929875335a3ddb4e6567917ef3288..0b90c2a0d5c26f3730a595cf5eedb314d583658d 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -4061,7 +4061,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);
@@ -4072,11 +4071,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 */
@@ -4088,17 +4084,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.
@@ -4121,20 +4106,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;
                                }
@@ -4168,19 +4150,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
@@ -4197,7 +4175,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;
@@ -4205,9 +4182,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;
 }
 
@@ -10481,7 +10455,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);
@@ -10609,7 +10583,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 f8df15e8c9950aaf0cb162cecf2020550609d646..5ab5674e1a903211cf82fa2713f4d70051242f10 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -2850,7 +2850,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)
@@ -2903,10 +2903,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 */
@@ -2914,7 +2914,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)
@@ -2936,7 +2936,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;
@@ -3492,10 +3492,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;
                }
 
@@ -3509,7 +3509,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;
                }
@@ -3519,7 +3519,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;
                }
 
@@ -3537,12 +3537,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);
@@ -3567,7 +3567,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;
                }
 
@@ -3580,7 +3580,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;
                        }
@@ -3589,7 +3589,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;
@@ -3597,7 +3597,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) {
@@ -4325,16 +4325,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) {
@@ -4348,7 +4348,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;
                }
@@ -4357,7 +4357,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;
                }
@@ -4366,7 +4366,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)