btrfs: change root to fs_info for btrfs_reserve_metadata_bytes

We used to need the root for btrfs_reserve_metadata_bytes to check the
orphan cleanup state, but we no longer need that, we simply need the
fs_info.  Change btrfs_reserve_metadata_bytes() to use the fs_info, and
change both btrfs_block_rsv_refill() and btrfs_block_rsv_add() to do the
same as they simply call btrfs_reserve_metadata_bytes() and then
manipulate the block_rsv that is being used.

Reviewed-by: Nikolay Borisov <nborisov@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
index 6ab8646..d56fc1b 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -3790,7 +3790,7 @@ static void reserve_chunk_space(struct btrfs_trans_handle *trans,
        }
 
        if (!ret) {
-               ret = btrfs_block_rsv_add(fs_info->chunk_root,
+               ret = btrfs_block_rsv_add(fs_info,
                                          &fs_info->chunk_block_rsv,
                                          bytes, BTRFS_RESERVE_NO_FLUSH);
                if (!ret)

diff --git a/fs/btrfs/block-rsv.c b/fs/btrfs/block-rsv.c
index 04a6226..9d162b5 100644 (file)
--- a/fs/btrfs/block-rsv.c
+++ b/fs/btrfs/block-rsv.c
@@ -208,7 +208,7 @@ void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
        kfree(rsv);
 }
 
-int btrfs_block_rsv_add(struct btrfs_root *root,
+int btrfs_block_rsv_add(struct btrfs_fs_info *fs_info,
                        struct btrfs_block_rsv *block_rsv, u64 num_bytes,
                        enum btrfs_reserve_flush_enum flush)
 {
@@ -217,7 +217,7 @@ int btrfs_block_rsv_add(struct btrfs_root *root,
        if (num_bytes == 0)
                return 0;
 
-       ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
+       ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);
        if (!ret)
                btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true);
 
@@ -241,7 +241,7 @@ int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor)
        return ret;
 }
 
-int btrfs_block_rsv_refill(struct btrfs_root *root,
+int btrfs_block_rsv_refill(struct btrfs_fs_info *fs_info,
                           struct btrfs_block_rsv *block_rsv, u64 min_reserved,
                           enum btrfs_reserve_flush_enum flush)
 {
@@ -262,7 +262,7 @@ int btrfs_block_rsv_refill(struct btrfs_root *root,
        if (!ret)
                return 0;
 
-       ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
+       ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);
        if (!ret) {
                btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);
                return 0;
@@ -523,7 +523,7 @@ again:
                                block_rsv->type, ret);
        }
 try_reserve:
-       ret = btrfs_reserve_metadata_bytes(root, block_rsv, blocksize,
+       ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, blocksize,
                                           BTRFS_RESERVE_NO_FLUSH);
        if (!ret)
                return block_rsv;

diff --git a/fs/btrfs/block-rsv.h b/fs/btrfs/block-rsv.h
index 0b6ae53..07d61c2 100644 (file)
--- a/fs/btrfs/block-rsv.h
+++ b/fs/btrfs/block-rsv.h
@@ -57,11 +57,11 @@ void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
                                   unsigned short type);
 void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
                          struct btrfs_block_rsv *rsv);
-int btrfs_block_rsv_add(struct btrfs_root *root,
+int btrfs_block_rsv_add(struct btrfs_fs_info *fs_info,
                        struct btrfs_block_rsv *block_rsv, u64 num_bytes,
                        enum btrfs_reserve_flush_enum flush);
 int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor);
-int btrfs_block_rsv_refill(struct btrfs_root *root,
+int btrfs_block_rsv_refill(struct btrfs_fs_info *fs_info,
                           struct btrfs_block_rsv *block_rsv, u64 min_reserved,
                           enum btrfs_reserve_flush_enum flush);
 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,

diff --git a/fs/btrfs/delalloc-space.c b/fs/btrfs/delalloc-space.c
index 40c4d6b..fb46a28 100644 (file)
--- a/fs/btrfs/delalloc-space.c
+++ b/fs/btrfs/delalloc-space.c
@@ -334,7 +334,7 @@ int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
        ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserve, true);
        if (ret)
                return ret;
-       ret = btrfs_reserve_metadata_bytes(root, block_rsv, meta_reserve, flush);
+       ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, meta_reserve, flush);
        if (ret) {
                btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve);
                return ret;

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index e164766..6f134f2 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -629,7 +629,7 @@ static int btrfs_delayed_inode_reserve_metadata(
                                          BTRFS_QGROUP_RSV_META_PREALLOC, true);
                if (ret < 0)
                        return ret;
-               ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes,
+               ret = btrfs_block_rsv_add(fs_info, dst_rsv, num_bytes,
                                          BTRFS_RESERVE_NO_FLUSH);
                /* NO_FLUSH could only fail with -ENOSPC */
                ASSERT(ret == 0 || ret == -ENOSPC);

diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index cca7e85..da9d208 100644 (file)
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -191,8 +191,7 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
        if (!num_bytes)
                return 0;
 
-       ret = btrfs_reserve_metadata_bytes(fs_info->extent_root, block_rsv,
-                                          num_bytes, flush);
+       ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);
        if (ret)
                return ret;
        btrfs_block_rsv_add_bytes(block_rsv, num_bytes, 0);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index b4ef478..91f7ed2 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -5539,10 +5539,10 @@ static struct btrfs_trans_handle *evict_refill_and_join(struct btrfs_root *root,
         * if we fail to make this reservation we can re-try without the
         * delayed_refs_extra so we can make some forward progress.
         */
-       ret = btrfs_block_rsv_refill(root, rsv, rsv->size + delayed_refs_extra,
+       ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra,
                                     BTRFS_RESERVE_FLUSH_EVICT);
        if (ret) {
-               ret = btrfs_block_rsv_refill(root, rsv, rsv->size,
+               ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size,
                                             BTRFS_RESERVE_FLUSH_EVICT);
                if (ret) {
                        btrfs_warn(fs_info,

diff --git a/fs/btrfs/props.c b/fs/btrfs/props.c
index a978676..1a6d2d5 100644 (file)
--- a/fs/btrfs/props.c
+++ b/fs/btrfs/props.c
@@ -377,8 +377,9 @@ static int inherit_props(struct btrfs_trans_handle *trans,
                 */
                if (need_reserve) {
                        num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
-                       ret = btrfs_block_rsv_add(root, trans->block_rsv,
-                                       num_bytes, BTRFS_RESERVE_NO_FLUSH);
+                       ret = btrfs_block_rsv_add(fs_info, trans->block_rsv,
+                                                 num_bytes,
+                                                 BTRFS_RESERVE_NO_FLUSH);
                        if (ret)
                                return ret;
                }

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index ee0a0ef..a455a1e 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1736,7 +1736,8 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
        memset(&next_key, 0, sizeof(next_key));
 
        while (1) {
-               ret = btrfs_block_rsv_refill(root, rc->block_rsv, min_reserved,
+               ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv,
+                                            min_reserved,
                                             BTRFS_RESERVE_FLUSH_LIMIT);
                if (ret)
                        goto out;
@@ -1855,7 +1856,7 @@ int prepare_to_merge(struct reloc_control *rc, int err)
 again:
        if (!err) {
                num_bytes = rc->merging_rsv_size;
-               ret = btrfs_block_rsv_add(root, rc->block_rsv, num_bytes,
+               ret = btrfs_block_rsv_add(fs_info, rc->block_rsv, num_bytes,
                                          BTRFS_RESERVE_FLUSH_ALL);
                if (ret)
                        err = ret;
@@ -2323,8 +2324,8 @@ static int reserve_metadata_space(struct btrfs_trans_handle *trans,
         * If we get an enospc just kick back -EAGAIN so we know to drop the
         * transaction and try to refill when we can flush all the things.
         */
-       ret = btrfs_block_rsv_refill(root, rc->block_rsv, num_bytes,
-                               BTRFS_RESERVE_FLUSH_LIMIT);
+       ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv, num_bytes,
+                                    BTRFS_RESERVE_FLUSH_LIMIT);
        if (ret) {
                tmp = fs_info->nodesize * RELOCATION_RESERVED_NODES;
                while (tmp <= rc->reserved_bytes)
@@ -3550,7 +3551,7 @@ int prepare_to_relocate(struct reloc_control *rc)
        rc->reserved_bytes = 0;
        rc->block_rsv->size = rc->extent_root->fs_info->nodesize *
                              RELOCATION_RESERVED_NODES;
-       ret = btrfs_block_rsv_refill(rc->extent_root,
+       ret = btrfs_block_rsv_refill(rc->extent_root->fs_info,
                                     rc->block_rsv, rc->block_rsv->size,
                                     BTRFS_RESERVE_FLUSH_ALL);
        if (ret)
@@ -3598,9 +3599,9 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc)
 
        while (1) {
                rc->reserved_bytes = 0;
-               ret = btrfs_block_rsv_refill(rc->extent_root,
-                                       rc->block_rsv, rc->block_rsv->size,
-                                       BTRFS_RESERVE_FLUSH_ALL);
+               ret = btrfs_block_rsv_refill(fs_info, rc->block_rsv,
+                                            rc->block_rsv->size,
+                                            BTRFS_RESERVE_FLUSH_ALL);
                if (ret) {
                        err = ret;
                        break;

diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 3297368..3d68d2d 100644 (file)
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -502,7 +502,7 @@ int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
        num_bytes = btrfs_calc_insert_metadata_size(fs_info, items);
        rsv->space_info = btrfs_find_space_info(fs_info,
                                            BTRFS_BLOCK_GROUP_METADATA);
-       ret = btrfs_block_rsv_add(root, rsv, num_bytes,
+       ret = btrfs_block_rsv_add(fs_info, rsv, num_bytes,
                                  BTRFS_RESERVE_FLUSH_ALL);
 
        if (ret == -ENOSPC && use_global_rsv)

diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index d277c71..dc4b4b0 100644 (file)
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -1600,12 +1600,11 @@ static int __reserve_bytes(struct btrfs_fs_info *fs_info,
  * regain reservations will be made and this will fail if there is not enough
  * space already.
  */
-int btrfs_reserve_metadata_bytes(struct btrfs_root *root,
+int btrfs_reserve_metadata_bytes(struct btrfs_fs_info *fs_info,
                                 struct btrfs_block_rsv *block_rsv,
                                 u64 orig_bytes,
                                 enum btrfs_reserve_flush_enum flush)
 {
-       struct btrfs_fs_info *fs_info = root->fs_info;
        int ret;
 
        ret = __reserve_bytes(fs_info, block_rsv->space_info, orig_bytes, flush);

diff --git a/fs/btrfs/space-info.h b/fs/btrfs/space-info.h
index cb50564..d841fed 100644 (file)
--- a/fs/btrfs/space-info.h
+++ b/fs/btrfs/space-info.h
@@ -123,7 +123,7 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
 void btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
                           struct btrfs_space_info *info, u64 bytes,
                           int dump_block_groups);
-int btrfs_reserve_metadata_bytes(struct btrfs_root *root,
+int btrfs_reserve_metadata_bytes(struct btrfs_fs_info *fs_info,
                                 struct btrfs_block_rsv *block_rsv,
                                 u64 orig_bytes,
                                 enum btrfs_reserve_flush_enum flush);

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index eb1c916..8b6a90f 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -634,7 +634,7 @@ start_transaction(struct btrfs_root *root, unsigned int num_items,
                        reloc_reserved = true;
                }
 
-               ret = btrfs_block_rsv_add(root, rsv, num_bytes, flush);
+               ret = btrfs_block_rsv_add(fs_info, rsv, num_bytes, flush);
                if (ret)
                        goto reserve_fail;
                if (delayed_refs_bytes) {
@@ -1597,7 +1597,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
        btrfs_reloc_pre_snapshot(pending, &to_reserve);
 
        if (to_reserve > 0) {
-               pending->error = btrfs_block_rsv_add(root,
+               pending->error = btrfs_block_rsv_add(fs_info,
                                                     &pending->block_rsv,
                                                     to_reserve,
                                                     BTRFS_RESERVE_NO_FLUSH);