btrfs: drop fs_info argument from btrfs_update_space_info_*()

Since commit e1e577aafe41 ("btrfs: store fs_info in space_info"), we have
the fs_info in a space_info. So, we can drop fs_info argument from
btrfs_update_space_info_*. There is no behavior change.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Naohiro Aota <naohiro.aota@wdc.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 4427c1b835e8b24670d8244c2c40e9f84c8a56e5..5be029734cfa2cdc576b44281667a72a5f107d40 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -1223,7 +1223,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
        block_group->space_info->total_bytes -= block_group->length;
        block_group->space_info->bytes_readonly -=
                (block_group->length - block_group->zone_unusable);
-       btrfs_space_info_update_bytes_zone_unusable(fs_info, block_group->space_info,
+       btrfs_space_info_update_bytes_zone_unusable(block_group->space_info,
                                                    -block_group->zone_unusable);
        block_group->space_info->disk_total -= block_group->length * factor;
 
@@ -1396,8 +1396,7 @@ static int inc_block_group_ro(struct btrfs_block_group *cache, int force)
                if (btrfs_is_zoned(cache->fs_info)) {
                        /* Migrate zone_unusable bytes to readonly */
                        sinfo->bytes_readonly += cache->zone_unusable;
-                       btrfs_space_info_update_bytes_zone_unusable(cache->fs_info, sinfo,
-                                                                   -cache->zone_unusable);
+                       btrfs_space_info_update_bytes_zone_unusable(sinfo, -cache->zone_unusable);
                        cache->zone_unusable = 0;
                }
                cache->ro++;
@@ -1645,8 +1644,7 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
                spin_lock(&space_info->lock);
                spin_lock(&block_group->lock);
 
-               btrfs_space_info_update_bytes_pinned(fs_info, space_info,
-                                                    -block_group->pinned);
+               btrfs_space_info_update_bytes_pinned(space_info, -block_group->pinned);
                space_info->bytes_readonly += block_group->pinned;
                block_group->pinned = 0;
 
@@ -3060,8 +3058,7 @@ void btrfs_dec_block_group_ro(struct btrfs_block_group *cache)
                                (cache->alloc_offset - cache->used - cache->pinned -
                                 cache->reserved) +
                                (cache->length - cache->zone_capacity);
-                       btrfs_space_info_update_bytes_zone_unusable(cache->fs_info, sinfo,
-                                                                   cache->zone_unusable);
+                       btrfs_space_info_update_bytes_zone_unusable(sinfo, cache->zone_unusable);
                        sinfo->bytes_readonly -= cache->zone_unusable;
                }
                num_bytes = cache->length - cache->reserved -
@@ -3699,7 +3696,7 @@ int btrfs_update_block_group(struct btrfs_trans_handle *trans,
                old_val -= num_bytes;
                cache->used = old_val;
                cache->pinned += num_bytes;
-               btrfs_space_info_update_bytes_pinned(info, space_info, num_bytes);
+               btrfs_space_info_update_bytes_pinned(space_info, num_bytes);
                space_info->bytes_used -= num_bytes;
                space_info->disk_used -= num_bytes * factor;
                if (READ_ONCE(space_info->periodic_reclaim))
@@ -3781,8 +3778,7 @@ int btrfs_add_reserved_bytes(struct btrfs_block_group *cache,
        space_info->bytes_reserved += num_bytes;
        trace_btrfs_space_reservation(cache->fs_info, "space_info",
                                      space_info->flags, num_bytes, 1);
-       btrfs_space_info_update_bytes_may_use(cache->fs_info,
-                                             space_info, -ram_bytes);
+       btrfs_space_info_update_bytes_may_use(space_info, -ram_bytes);
        if (delalloc)
                cache->delalloc_bytes += num_bytes;
 

diff --git a/fs/btrfs/block-rsv.c b/fs/btrfs/block-rsv.c
index a07b9594dc706783cb078ae5138b87341aaf8b31..3f3608299c0b7efbf7581f3a7f066fa2baa1240d 100644 (file)
--- a/fs/btrfs/block-rsv.c
+++ b/fs/btrfs/block-rsv.c
@@ -150,9 +150,7 @@ static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
                        spin_unlock(&dest->lock);
                }
                if (num_bytes)
-                       btrfs_space_info_free_bytes_may_use(fs_info,
-                                                           space_info,
-                                                           num_bytes);
+                       btrfs_space_info_free_bytes_may_use(space_info, num_bytes);
        }
        if (qgroup_to_release_ret)
                *qgroup_to_release_ret = qgroup_to_release;
@@ -383,13 +381,11 @@ void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info)
 
        if (block_rsv->reserved < block_rsv->size) {
                num_bytes = block_rsv->size - block_rsv->reserved;
-               btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
-                                                     num_bytes);
+               btrfs_space_info_update_bytes_may_use(sinfo, num_bytes);
                block_rsv->reserved = block_rsv->size;
        } else if (block_rsv->reserved > block_rsv->size) {
                num_bytes = block_rsv->reserved - block_rsv->size;
-               btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
-                                                     -num_bytes);
+               btrfs_space_info_update_bytes_may_use(sinfo, -num_bytes);
                block_rsv->reserved = block_rsv->size;
                btrfs_try_granting_tickets(fs_info, sinfo);
        }

diff --git a/fs/btrfs/delalloc-space.c b/fs/btrfs/delalloc-space.c
index 7aa8a395d838c1e228cd00cd3801685b7d84eb56..88e900e5a43d436654432fafa4fdb92f65737c0b 100644 (file)
--- a/fs/btrfs/delalloc-space.c
+++ b/fs/btrfs/delalloc-space.c
@@ -176,7 +176,7 @@ void btrfs_free_reserved_data_space_noquota(struct btrfs_fs_info *fs_info,
        ASSERT(IS_ALIGNED(len, fs_info->sectorsize));
 
        data_sinfo = fs_info->data_sinfo;
-       btrfs_space_info_free_bytes_may_use(fs_info, data_sinfo, len);
+       btrfs_space_info_free_bytes_may_use(data_sinfo, len);
 }
 
 /*

diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index 44cfe7fd85bd6793316f8c6d30a9b5662aa2fe79..30f7079fa28eac73f0522d81feb9641d88875813 100644 (file)
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -257,7 +257,7 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
        spin_unlock(&block_rsv->lock);
 
        if (to_free > 0)
-               btrfs_space_info_free_bytes_may_use(fs_info, space_info, to_free);
+               btrfs_space_info_free_bytes_may_use(space_info, to_free);
 
        if (refilled_bytes > 0)
                trace_btrfs_space_reservation(fs_info, "delayed_refs_rsv", 0,
@@ -1311,8 +1311,7 @@ void btrfs_destroy_delayed_refs(struct btrfs_transaction *trans)
                                spin_lock(&bg->space_info->lock);
                                spin_lock(&bg->lock);
                                bg->pinned += head->num_bytes;
-                               btrfs_space_info_update_bytes_pinned(fs_info,
-                                                                    bg->space_info,
+                               btrfs_space_info_update_bytes_pinned(bg->space_info,
                                                                     head->num_bytes);
                                bg->reserved -= head->num_bytes;
                                bg->space_info->bytes_reserved -= head->num_bytes;

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 64a199d93d64e144f2ae4ab810fdad145eb9fefc..2f9126528a0170f4d3202436499e814469093c0d 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2547,13 +2547,10 @@ static int pin_down_extent(struct btrfs_trans_handle *trans,
                           struct btrfs_block_group *cache,
                           u64 bytenr, u64 num_bytes, int reserved)
 {
-       struct btrfs_fs_info *fs_info = cache->fs_info;
-
        spin_lock(&cache->space_info->lock);
        spin_lock(&cache->lock);
        cache->pinned += num_bytes;
-       btrfs_space_info_update_bytes_pinned(fs_info, cache->space_info,
-                                            num_bytes);
+       btrfs_space_info_update_bytes_pinned(cache->space_info, num_bytes);
        if (reserved) {
                cache->reserved -= num_bytes;
                cache->space_info->bytes_reserved -= num_bytes;
@@ -2754,15 +2751,14 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info,
                spin_lock(&space_info->lock);
                spin_lock(&cache->lock);
                cache->pinned -= len;
-               btrfs_space_info_update_bytes_pinned(fs_info, space_info, -len);
+               btrfs_space_info_update_bytes_pinned(space_info, -len);
                space_info->max_extent_size = 0;
                if (cache->ro) {
                        space_info->bytes_readonly += len;
                        readonly = true;
                } else if (btrfs_is_zoned(fs_info)) {
                        /* Need reset before reusing in a zoned block group */
-                       btrfs_space_info_update_bytes_zone_unusable(fs_info, space_info,
-                                                                   len);
+                       btrfs_space_info_update_bytes_zone_unusable(space_info, len);
                        readonly = true;
                }
                spin_unlock(&cache->lock);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 27b2fe7f735d5b3f200ce1051ada764dda4fdc01..283199d11642eb59c16f63dfde89fbdb7cdf1d98 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1809,7 +1809,7 @@ static int fallback_to_cow(struct btrfs_inode *inode,
                        bytes = range_bytes;
 
                spin_lock(&sinfo->lock);
-               btrfs_space_info_update_bytes_may_use(fs_info, sinfo, bytes);
+               btrfs_space_info_update_bytes_may_use(sinfo, bytes);
                spin_unlock(&sinfo->lock);
 
                if (count > 0)

diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index 8b6340c59bf2d7af4d22dafe9794c044cc37af1b..3ae97c974d950a8fce85d3b38fd33985e2119d13 100644 (file)
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -316,7 +316,7 @@ void btrfs_add_bg_to_space_info(struct btrfs_fs_info *info,
        found->bytes_used += block_group->used;
        found->disk_used += block_group->used * factor;
        found->bytes_readonly += block_group->bytes_super;
-       btrfs_space_info_update_bytes_zone_unusable(info, found, block_group->zone_unusable);
+       btrfs_space_info_update_bytes_zone_unusable(found, block_group->zone_unusable);
        if (block_group->length > 0)
                found->full = 0;
        btrfs_try_granting_tickets(info, found);
@@ -489,9 +489,7 @@ again:
                if ((used + ticket->bytes <= space_info->total_bytes) ||
                    btrfs_can_overcommit(fs_info, space_info, ticket->bytes,
                                         flush)) {
-                       btrfs_space_info_update_bytes_may_use(fs_info,
-                                                             space_info,
-                                                             ticket->bytes);
+                       btrfs_space_info_update_bytes_may_use(space_info, ticket->bytes);
                        remove_ticket(space_info, ticket);
                        ticket->bytes = 0;
                        space_info->tickets_id++;
@@ -1690,8 +1688,7 @@ static int __reserve_bytes(struct btrfs_fs_info *fs_info,
        if (!pending_tickets &&
            ((used + orig_bytes <= space_info->total_bytes) ||
             btrfs_can_overcommit(fs_info, space_info, orig_bytes, flush))) {
-               btrfs_space_info_update_bytes_may_use(fs_info, space_info,
-                                                     orig_bytes);
+               btrfs_space_info_update_bytes_may_use(space_info, orig_bytes);
                ret = 0;
        }
 
@@ -1703,8 +1700,7 @@ static int __reserve_bytes(struct btrfs_fs_info *fs_info,
        if (ret && unlikely(flush == BTRFS_RESERVE_FLUSH_EMERGENCY)) {
                used = btrfs_space_info_used(space_info, false);
                if (used + orig_bytes <= space_info->total_bytes) {
-                       btrfs_space_info_update_bytes_may_use(fs_info, space_info,
-                                                             orig_bytes);
+                       btrfs_space_info_update_bytes_may_use(space_info, orig_bytes);
                        ret = 0;
                }
        }
@@ -2099,7 +2095,7 @@ void btrfs_return_free_space(struct btrfs_space_info *space_info, u64 len)
                u64 to_add = min(len, global_rsv->size - global_rsv->reserved);
 
                global_rsv->reserved += to_add;
-               btrfs_space_info_update_bytes_may_use(fs_info, space_info, to_add);
+               btrfs_space_info_update_bytes_may_use(space_info, to_add);
                if (global_rsv->reserved >= global_rsv->size)
                        global_rsv->full = 1;
                len -= to_add;

diff --git a/fs/btrfs/space-info.h b/fs/btrfs/space-info.h
index 4c9e8aabee513d6e24501f3429a8313b35d70b59..69071afc0d47d5e48f33cc983b9444218227ce10 100644 (file)
--- a/fs/btrfs/space-info.h
+++ b/fs/btrfs/space-info.h
@@ -229,10 +229,10 @@ static inline bool btrfs_mixed_space_info(const struct btrfs_space_info *space_i
  */
 #define DECLARE_SPACE_INFO_UPDATE(name, trace_name)                    \
 static inline void                                                     \
-btrfs_space_info_update_##name(struct btrfs_fs_info *fs_info,          \
-                              struct btrfs_space_info *sinfo,          \
+btrfs_space_info_update_##name(struct btrfs_space_info *sinfo,         \
                               s64 bytes)                               \
 {                                                                      \
+       struct btrfs_fs_info *fs_info = sinfo->fs_info;                 \
        const u64 abs_bytes = (bytes < 0) ? -bytes : bytes;             \
        lockdep_assert_held(&sinfo->lock);                              \
        trace_update_##name(fs_info, sinfo, sinfo->name, bytes);        \
@@ -275,13 +275,12 @@ int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,
                         enum btrfs_reserve_flush_enum flush);
 
 static inline void btrfs_space_info_free_bytes_may_use(
-                               struct btrfs_fs_info *fs_info,
                                struct btrfs_space_info *space_info,
                                u64 num_bytes)
 {
        spin_lock(&space_info->lock);
-       btrfs_space_info_update_bytes_may_use(fs_info, space_info, -num_bytes);
-       btrfs_try_granting_tickets(fs_info, space_info);
+       btrfs_space_info_update_bytes_may_use(space_info, -num_bytes);
+       btrfs_try_granting_tickets(space_info->fs_info, space_info);
        spin_unlock(&space_info->lock);
 }
 int btrfs_reserve_data_bytes(struct btrfs_fs_info *fs_info, u64 bytes,

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index dc0b837efd5dfb3dcba8e270e0069b667db25a41..15312013f2a34d1d68c1778282e94b84de730374 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -795,8 +795,7 @@ alloc_fail:
        if (num_bytes)
                btrfs_block_rsv_release(fs_info, trans_rsv, num_bytes, NULL);
        if (delayed_refs_bytes)
-               btrfs_space_info_free_bytes_may_use(fs_info, trans_rsv->space_info,
-                                                   delayed_refs_bytes);
+               btrfs_space_info_free_bytes_may_use(trans_rsv->space_info, delayed_refs_bytes);
 reserve_fail:
        btrfs_qgroup_free_meta_prealloc(root, qgroup_reserved);
        return ERR_PTR(ret);