btrfs: rename the btrfs_calc_*_metadata_size helpers

btrfs_calc_trunc_metadata_size differs from trans_metadata_size in that
it doesn't take into account any splitting at the levels, because
truncate will never split nodes.  However truncate _and_ changing will
never split nodes, so rename btrfs_calc_trunc_metadata_size to
btrfs_calc_metadata_size.  Also btrfs_calc_trans_metadata_size is purely
for inserting items, so rename this to btrfs_calc_insert_metadata_size.
Making these clearer will help when I start using them differently in
upcoming patches.

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 55d6d1c..c912ee2 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -3015,8 +3015,8 @@ void check_system_chunk(struct btrfs_trans_handle *trans, u64 type)
        num_devs = get_profile_num_devs(fs_info, type);
 
        /* num_devs device items to update and 1 chunk item to add or remove */
-       thresh = btrfs_calc_trunc_metadata_size(fs_info, num_devs) +
-               btrfs_calc_trans_metadata_size(fs_info, 1);
+       thresh = btrfs_calc_metadata_size(fs_info, num_devs) +
+               btrfs_calc_insert_metadata_size(fs_info, 1);
 
        if (left < thresh && btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
                btrfs_info(fs_info, "left=%llu, need=%llu, flags=%llu",

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 2079374..d27b398 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2451,17 +2451,21 @@ u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset);
 
 u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes);
 
-static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,
-                                                unsigned num_items)
+/*
+ * Use this if we would be adding new items, as we could split nodes as we cow
+ * down the tree.
+ */
+static inline u64 btrfs_calc_insert_metadata_size(struct btrfs_fs_info *fs_info,
+                                                 unsigned num_items)
 {
        return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
 }
 
 /*
- * Doing a truncate won't result in new nodes or leaves, just what we need for
- * COW.
+ * Doing a truncate or a modification won't result in new nodes or leaves, just
+ * what we need for COW.
  */
-static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,
+static inline u64 btrfs_calc_metadata_size(struct btrfs_fs_info *fs_info,
                                                 unsigned num_items)
 {
        return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;

diff --git a/fs/btrfs/delalloc-space.c b/fs/btrfs/delalloc-space.c
index d2dfc20..62aa18b 100644 (file)
--- a/fs/btrfs/delalloc-space.c
+++ b/fs/btrfs/delalloc-space.c
@@ -256,12 +256,12 @@ static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info,
        lockdep_assert_held(&inode->lock);
        outstanding_extents = inode->outstanding_extents;
        if (outstanding_extents)
-               reserve_size = btrfs_calc_trans_metadata_size(fs_info,
+               reserve_size = btrfs_calc_insert_metadata_size(fs_info,
                                                outstanding_extents + 1);
        csum_leaves = btrfs_csum_bytes_to_leaves(fs_info,
                                                 inode->csum_bytes);
-       reserve_size += btrfs_calc_trans_metadata_size(fs_info,
-                                                      csum_leaves);
+       reserve_size += btrfs_calc_insert_metadata_size(fs_info,
+                                                       csum_leaves);
        /*
         * For qgroup rsv, the calculation is very simple:
         * account one nodesize for each outstanding extent
@@ -284,7 +284,7 @@ static void calc_inode_reservations(struct btrfs_fs_info *fs_info,
        u64 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, num_bytes);
 
        /* We add one for the inode update at finish ordered time */
-       *meta_reserve = btrfs_calc_trans_metadata_size(fs_info,
+       *meta_reserve = btrfs_calc_insert_metadata_size(fs_info,
                                                nr_extents + csum_leaves + 1);
        *qgroup_reserve = nr_extents * fs_info->nodesize;
 }

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 6858a05..de87ea7 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -558,7 +558,7 @@ static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans,
        src_rsv = trans->block_rsv;
        dst_rsv = &fs_info->delayed_block_rsv;
 
-       num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
+       num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
 
        /*
         * Here we migrate space rsv from transaction rsv, since have already
@@ -612,7 +612,7 @@ static int btrfs_delayed_inode_reserve_metadata(
        src_rsv = trans->block_rsv;
        dst_rsv = &fs_info->delayed_block_rsv;
 
-       num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
+       num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
 
        /*
         * btrfs_dirty_inode will update the inode under btrfs_join_transaction

diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 9a91d1e..951a60c 100644 (file)
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -79,7 +79,7 @@ int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans)
 void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr)
 {
        struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;
-       u64 num_bytes = btrfs_calc_trans_metadata_size(fs_info, nr);
+       u64 num_bytes = btrfs_calc_insert_metadata_size(fs_info, nr);
        u64 released = 0;
 
        released = __btrfs_block_rsv_release(fs_info, block_rsv, num_bytes,
@@ -105,8 +105,8 @@ void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans)
        if (!trans->delayed_ref_updates)
                return;
 
-       num_bytes = btrfs_calc_trans_metadata_size(fs_info,
-                                                  trans->delayed_ref_updates);
+       num_bytes = btrfs_calc_insert_metadata_size(fs_info,
+                                                   trans->delayed_ref_updates);
        spin_lock(&delayed_rsv->lock);
        delayed_rsv->size += num_bytes;
        delayed_rsv->full = 0;
@@ -174,7 +174,7 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
                                  enum btrfs_reserve_flush_enum flush)
 {
        struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv;
-       u64 limit = btrfs_calc_trans_metadata_size(fs_info, 1);
+       u64 limit = btrfs_calc_insert_metadata_size(fs_info, 1);
        u64 num_bytes = 0;
        int ret = -ENOSPC;
 

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index b31991f..1cb694c 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2511,7 +2511,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
                           struct btrfs_trans_handle **trans_out)
 {
        struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-       u64 min_size = btrfs_calc_trans_metadata_size(fs_info, 1);
+       u64 min_size = btrfs_calc_insert_metadata_size(fs_info, 1);
        u64 ino_size = round_up(inode->i_size, fs_info->sectorsize);
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct btrfs_trans_handle *trans = NULL;
@@ -2530,7 +2530,7 @@ int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
                ret = -ENOMEM;
                goto out;
        }
-       rsv->size = btrfs_calc_trans_metadata_size(fs_info, 1);
+       rsv->size = btrfs_calc_insert_metadata_size(fs_info, 1);
        rsv->failfast = 1;
 
        /*

diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index faaf57a..265dc75 100644 (file)
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -211,8 +211,8 @@ int btrfs_check_trunc_cache_free_space(struct btrfs_fs_info *fs_info,
        int ret;
 
        /* 1 for slack space, 1 for updating the inode */
-       needed_bytes = btrfs_calc_trunc_metadata_size(fs_info, 1) +
-               btrfs_calc_trans_metadata_size(fs_info, 1);
+       needed_bytes = btrfs_calc_insert_metadata_size(fs_info, 1) +
+               btrfs_calc_metadata_size(fs_info, 1);
 
        spin_lock(&rsv->lock);
        if (rsv->reserved < needed_bytes)

diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
index 86031cd..63cad78 100644 (file)
--- a/fs/btrfs/inode-map.c
+++ b/fs/btrfs/inode-map.c
@@ -436,7 +436,7 @@ int btrfs_save_ino_cache(struct btrfs_root *root,
         * 1 item for free space object
         * 3 items for pre-allocation
         */
-       trans->bytes_reserved = btrfs_calc_trans_metadata_size(fs_info, 10);
+       trans->bytes_reserved = btrfs_calc_insert_metadata_size(fs_info, 10);
        ret = btrfs_block_rsv_add(root, trans->block_rsv,
                                  trans->bytes_reserved,
                                  BTRFS_RESERVE_NO_FLUSH);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index c4116bc..31eacbf 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -5337,7 +5337,7 @@ static struct btrfs_trans_handle *evict_refill_and_join(struct btrfs_root *root,
        struct btrfs_fs_info *fs_info = root->fs_info;
        struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
        struct btrfs_trans_handle *trans;
-       u64 delayed_refs_extra = btrfs_calc_trans_metadata_size(fs_info, 1);
+       u64 delayed_refs_extra = btrfs_calc_insert_metadata_size(fs_info, 1);
        int ret;
 
        /*
@@ -5426,7 +5426,7 @@ void btrfs_evict_inode(struct inode *inode)
        rsv = btrfs_alloc_block_rsv(fs_info, BTRFS_BLOCK_RSV_TEMP);
        if (!rsv)
                goto no_delete;
-       rsv->size = btrfs_calc_trunc_metadata_size(fs_info, 1);
+       rsv->size = btrfs_calc_metadata_size(fs_info, 1);
        rsv->failfast = 1;
 
        btrfs_i_size_write(BTRFS_I(inode), 0);
@@ -9040,7 +9040,7 @@ static int btrfs_truncate(struct inode *inode, bool skip_writeback)
        int ret;
        struct btrfs_trans_handle *trans;
        u64 mask = fs_info->sectorsize - 1;
-       u64 min_size = btrfs_calc_trunc_metadata_size(fs_info, 1);
+       u64 min_size = btrfs_calc_metadata_size(fs_info, 1);
 
        if (!skip_writeback) {
                ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask),

diff --git a/fs/btrfs/props.c b/fs/btrfs/props.c
index e046981..1e664e0 100644 (file)
--- a/fs/btrfs/props.c
+++ b/fs/btrfs/props.c
@@ -362,7 +362,7 @@ static int inherit_props(struct btrfs_trans_handle *trans,
                 * reservations if we do add more properties in the future.
                 */
                if (need_reserve) {
-                       num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
+                       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);
                        if (ret)

diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 47733fb..3b17b64 100644 (file)
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -533,7 +533,7 @@ int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
                        return ret;
        }
 
-       num_bytes = btrfs_calc_trans_metadata_size(fs_info, items);
+       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,

diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index 5f8f655..13a4326 100644 (file)
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -412,7 +412,7 @@ static inline u64 calc_reclaim_items_nr(struct btrfs_fs_info *fs_info,
        u64 bytes;
        u64 nr;
 
-       bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
+       bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
        nr = div64_u64(to_reclaim, bytes);
        if (!nr)
                nr = 1;

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 2e3f677..f21416d 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -485,7 +485,7 @@ start_transaction(struct btrfs_root *root, unsigned int num_items,
                 * worth of delayed refs updates in this trans handle, and
                 * refill that amount for whatever is missing in the reserve.
                 */
-               num_bytes = btrfs_calc_trans_metadata_size(fs_info, num_items);
+               num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items);
                if (delayed_refs_rsv->full == 0) {
                        delayed_refs_bytes = num_bytes;
                        num_bytes <<= 1;
@@ -636,7 +636,7 @@ struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv(
        if (IS_ERR(trans))
                return trans;
 
-       num_bytes = btrfs_calc_trans_metadata_size(fs_info, num_items);
+       num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items);
        ret = btrfs_cond_migrate_bytes(fs_info, &fs_info->trans_block_rsv,
                                       num_bytes, min_factor);
        if (ret) {