btrfs: introduce btrfs_return_free_space()
Subsystems (2)
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 1/3 btrfs: introduce btrfs_return_free_space()
This commit factors out a part of unpin_extent_range() into a function for the next commit. Also, move the "len" variable into the loop to clarify we don't need to carry it beyond an iteration.
--- fs/btrfs/extent-tree.c | 25 ++++--------------------- fs/btrfs/space-info.c | 24 ++++++++++++++++++++++++ fs/btrfs/space-info.h | 1 + 3 files changed, 29 insertions(+), 21 deletions(-)
fs/btrfs/extent-tree.c +4 -21
@@ -2724,15 +2724,15 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info, {struct btrfs_block_group *cache =NULL ;struct btrfs_space_info *space_info; -struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;struct btrfs_free_cluster *cluster =NULL ; -u64 len;u64 total_unpinned =0 ;u64 empty_cluster =0 ;bool readonly;int ret =0 ;while (start <= end) { +u64 len; + readonly = false;if (!cache || start >= cache->start + cache->length) {
@@ -2790,25 +2790,8 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info, readonly = true; }spin_unlock (&cache->lock); -if (!readonly && return_free_space && - global_rsv->space_info == space_info) { -spin_lock (&global_rsv->lock); -if (!global_rsv->full) { -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); -if (global_rsv->reserved >= global_rsv->size) - global_rsv->full =1 ; - len -= to_add; - } -spin_unlock (&global_rsv->lock); - } -/* Add to any tickets we may have */ -if (!readonly && return_free_space && len) -btrfs_try_granting_tickets (fs_info, space_info); +if (!readonly && return_free_space) +btrfs_return_free_space (space_info, len);spin_unlock (&space_info->lock); }
fs/btrfs/space-info.c +24 -0
@@ -2082,3 +2082,27 @@ void btrfs_reclaim_sweep(const struct btrfs_fs_info *fs_info)do_reclaim_sweep (space_info, raid); } } + +void btrfs_return_free_space (struct btrfs_space_info *space_info,u64 len) +{ +struct btrfs_fs_info *fs_info = space_info->fs_info; +struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; + +lockdep_assert_held (&space_info->lock); + +if (global_rsv->space_info == space_info) { +guard (spinlock)(&global_rsv->lock); +if (!global_rsv->full) { +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); +if (global_rsv->reserved >= global_rsv->size) + global_rsv->full =1 ; + len -= to_add; + } + } +/* Add to any tickets we may have */ +if (len) +btrfs_try_granting_tickets (fs_info, space_info); +}
fs/btrfs/space-info.h +1 -0
@@ -295,5 +295,6 @@ void btrfs_set_periodic_reclaim_ready(struct btrfs_space_info *space_info, boolbool btrfs_should_periodic_reclaim (struct btrfs_space_info *space_info);int btrfs_calc_reclaim_threshold (const struct btrfs_space_info *space_info);void btrfs_reclaim_sweep (const struct btrfs_fs_info *fs_info); +void btrfs_return_free_space (struct btrfs_space_info *space_info,u64 len);#endif /* BTRFS_SPACE_INFO_H */
Signature · 1 line
2.47.0
Quoted 13 lines · Naohiro Aota
fs/btrfs/space-info.c +13
-0+void btrfs_return_free_space (struct btrfs_space_info *space_info,u64 len) +{ +struct btrfs_fs_info *fs_info = space_info->fs_info; +struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; + +lockdep_assert_held (&space_info->lock); + +if (global_rsv->space_info == space_info) { +guard (spinlock)(&global_rsv->lock); +if (!global_rsv->full) { +u64 to_add =min (len, global_rsv->size - global_rsv->reserved); + + global_rsv->reserved += to_add;
fs/btrfs/space-info.c void btrfs_reclaim_sweep(const struct btrfs_fs_info *fs_info) · line 2108
Quoted 10 lines
fs/btrfs/space-info.c +10
-0+btrfs_space_info_update_bytes_may_use (fs_info, space_info, to_add); +if (global_rsv->reserved >= global_rsv->size) + global_rsv->full =1 ; + len -= to_add; + } + } +/* Add to any tickets we may have */ +if (len) +btrfs_try_granting_tickets (fs_info, space_info); +}
Stylistic nitpick here,
If you reverse the 1st if condition we can save one level of indentation and therefore not go over 80 chars:
if (global_rsv->space_info != space_info)
goto out;
guard(spinlock)(&global_rsv->lock);
if (!global_rsv->full) {
/* ... */
}
out:
if (len)
btrfs_try_granting_tickets(fs_info, space_info);Possibly even the 'if (!global_rsv->full)' can have a reserved polarity.
Another thing is the use of the guard() macro. I find it a bit hard to see, what is actually guarded by it (the block inside 'if (global_rsv->space_info == space_info) {'), so not sure if it really improves anything here, but I'd prefer to leave that up to David to decide.
Code wise I think the change is legitim, so
once the indentation is reduced.
PATCH 2/3 btrfs: drop fs_info argument from btrfs_update_space_info_*
In reply to a message not in the archiveSince 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.
--- fs/btrfs/block-group.c | 16 ++++++---------- fs/btrfs/block-rsv.c | 10 +++------- fs/btrfs/delalloc-space.c | 2 +- fs/btrfs/delayed-ref.c | 5 ++--- fs/btrfs/extent-tree.c | 10 +++------- fs/btrfs/inode.c | 2 +- fs/btrfs/space-info.c | 14 +++++--------- fs/btrfs/space-info.h | 9 ++++----- fs/btrfs/transaction.c | 3 +-- 9 files changed, 26 insertions(+), 45 deletions(-)
fs/btrfs/block-group.c +6 -10
@@ -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;
fs/btrfs/block-rsv.c +3 -7
@@ -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); }
fs/btrfs/delalloc-space.c +1 -1
@@ -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); }/*
fs/btrfs/delayed-ref.c +2 -3
@@ -254,7 +254,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,
@@ -1281,8 +1281,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;
fs/btrfs/extent-tree.c +3 -7
@@ -2571,13 +2571,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;
@@ -2778,15 +2775,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);
fs/btrfs/inode.c +1 -1
@@ -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 )
fs/btrfs/space-info.c +5 -9
@@ -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 @@ void btrfs_try_granting_tickets(struct btrfs_fs_info *fs_info,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 ; } }
@@ -2096,7 +2092,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;
fs/btrfs/space-info.h +4 -5
@@ -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,
fs/btrfs/transaction.c +1 -2
@@ -795,8 +795,7 @@ start_transaction(struct btrfs_root *root, unsigned int num_items,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);
Signature · 1 line
2.47.0
Re: [PATCH 2/3] btrfs: drop fs_info argument from btrfs_update_space_info_*
Looks good,
PATCH 3/3 btrfs: zoned: reclaim unused zone by zone resetting
In reply to a message not in the archiveOn the zoned mode, once used and freed region is still not reusable after the freeing. The underlying zone needs to be reset before reusing. Btrfs resets a zone when it removes a block group, and then new block group is allocated on the zones to reuse the zones. But, it is sometime too late to catch up with a write side.
This commit introduces a new space-info reclaim method ZONE_RESET. That will pick a block group from the unused list and reset its zone to reuse the zone_unusable space. It is faster than removing the block group and re-creating a new block group on the same zones.
For the first implementation, the ZONE_RESET is only applied to a block group whose region is fully zone_unusable. Reclaiming partial zone_unusable block group could be implemented later.
--- fs/btrfs/space-info.c | 28 +++++++++- fs/btrfs/space-info.h | 5 ++ fs/btrfs/zoned.c | 104 +++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 7 +++ include/trace/events/btrfs.h | 1 + 5 files changed, 143 insertions(+), 2 deletions(-)
fs/btrfs/space-info.c +26 -2
@@ -14,6 +14,7 @@#include "fs.h" #include "accessors.h" #include "extent-tree.h" +#include "zoned.h" /* * HOW DOES SPACE RESERVATION WORK
@@ -127,6 +128,14 @@* churn a lot and we can avoid making some extent tree modifications if we * are able to delay for as long as possible. * +* RESET_ZONES +* This state works only for the zoned mode. On the zoned mode, we cannot +* reuse once allocated then freed region until we reset the zone, due to +* the sequential write zone requirement. The RESET_ZONES state resets the +* zones of an unused block group and let btrfs reuse the space. The reusing +* is faster than removing the block group and allocating another block +* group on the zones. +* * ALLOC_CHUNK * We will skip this the first time through space reservation, because of * overcommit and we don't want to have a lot of useless metadata space when
@@ -832,6 +841,9 @@ static void flush_space(struct btrfs_fs_info *fs_info,*/ ret =btrfs_commit_current_transaction (root);break ; +case RESET_ZONES : + ret =btrfs_reset_unused_block_groups (space_info, num_bytes); +break ;default : ret = -ENOSPC ;break ;
@@ -1084,9 +1096,14 @@ static void btrfs_async_reclaim_metadata_space(struct work_struct *work)enum btrfs_flush_state flush_state;int commit_cycles =0 ;u64 last_tickets_id; +enum btrfs_flush_state final_state; fs_info = container_of(work, struct btrfs_fs_info, async_reclaim_work); space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); +if (btrfs_is_zoned (fs_info)) + final_state =RESET_ZONES ; +else + final_state =COMMIT_TRANS ;spin_lock (&space_info->lock); to_reclaim =btrfs_calc_reclaim_metadata_size (fs_info, space_info);
@@ -1139,7 +1156,7 @@ static void btrfs_async_reclaim_metadata_space(struct work_struct *work)if (flush_state ==ALLOC_CHUNK_FORCE && !commit_cycles) flush_state++; -if (flush_state >COMMIT_TRANS ) { +if (flush_state > final_state) { commit_cycles++;if (commit_cycles >2 ) {if (maybe_fail_all_tickets (fs_info, space_info)) {
@@ -1153,7 +1170,7 @@ static void btrfs_async_reclaim_metadata_space(struct work_struct *work) } }spin_unlock (&space_info->lock); - }while (flush_state <=COMMIT_TRANS ); + }while (flush_state <= final_state); }/*
@@ -1284,6 +1301,10 @@ static void btrfs_preempt_reclaim_metadata_space(struct work_struct *work)* This is where we reclaim all of the pinned space generated by running the * iputs * +* RESET_ZONES +* This state works only for the zoned mode. We scan the unused block +* group list and reset the zones and reuse the block group. +* * ALLOC_CHUNK_FORCE * For data we start with alloc chunk force, however we could have been full * before, and then the transaction commit could have freed new block groups,
@@ -1293,6 +1314,7 @@ static const enum btrfs_flush_state data_flush_states[] = {FLUSH_DELALLOC_FULL ,RUN_DELAYED_IPUTS ,COMMIT_TRANS , +RESET_ZONES , ALLOC_CHUNK_FORCE, };
@@ -1384,6 +1406,7 @@ void btrfs_init_async_reclaim_work(struct btrfs_fs_info *fs_info)static const enum btrfs_flush_state priority_flush_states[] = {FLUSH_DELAYED_ITEMS_NR ,FLUSH_DELAYED_ITEMS , +RESET_ZONES ,ALLOC_CHUNK , };
@@ -1397,6 +1420,7 @@ static const enum btrfs_flush_state evict_flush_states[] = {FLUSH_DELALLOC_FULL ,ALLOC_CHUNK ,COMMIT_TRANS , + RESET_ZONES, }; static void priority_reclaim_metadata_space(struct btrfs_fs_info *fs_info,
fs/btrfs/space-info.h +5 -0
@@ -79,6 +79,10 @@ enum btrfs_reserve_flush_enum { BTRFS_RESERVE_FLUSH_EMERGENCY, }; +/* +* Please be aware that the order of enum values will be the order of the reclaim +* process in btrfs_async_reclaim_metadata_space(). +*/ enum btrfs_flush_state {FLUSH_DELAYED_ITEMS_NR =1 ,FLUSH_DELAYED_ITEMS =2 ,
@@ -91,6 +95,7 @@ enum btrfs_flush_state {ALLOC_CHUNK_FORCE =9 ,RUN_DELAYED_IPUTS =10 ,COMMIT_TRANS =11 , + RESET_ZONES = 12, }; struct btrfs_space_info {
fs/btrfs/zoned.c +104 -0
107 lines not on this page · raw message
fs/btrfs/zoned.h +7 -0
@@ -96,6 +96,7 @@ int btrfs_zone_finish_one_bg(struct btrfs_fs_info *fs_info);int btrfs_zoned_activate_one_bg (struct btrfs_fs_info *fs_info,struct btrfs_space_info *space_info,bool do_finish);void btrfs_check_active_zone_reservation (struct btrfs_fs_info *fs_info); +int btrfs_reset_unused_block_groups (struct btrfs_space_info *space_info,u64 num_bytes);#else /* CONFIG_BLK_DEV_ZONED */ static inline int btrfs_get_dev_zone_info_all_devices (struct btrfs_fs_info *fs_info)
@@ -265,6 +266,12 @@ static inline int btrfs_zoned_activate_one_bg(struct btrfs_fs_info *fs_info,static inline void btrfs_check_active_zone_reservation (struct btrfs_fs_info *fs_info) { } +static inline int btrfs_reset_unused_block_groups (struct btrfs_space_info *space_info, +u64 num_bytes) +{ +return 0 ; +} +#endif static inline bool btrfs_dev_is_sequential (struct btrfs_device *device,u64 pos)
include/trace/events/btrfs.h +1 -0
@@ -97,6 +97,7 @@ struct find_free_extent_ctl; EM( FLUSH_DELALLOC_FULL, "FLUSH_DELALLOC_FULL") \ EM( FLUSH_DELAYED_REFS_NR, "FLUSH_DELAYED_REFS_NR") \ EM( FLUSH_DELAYED_REFS, "FLUSH_DELAYED_REFS") \ + EM( RESET_ZONES, "RESET_ZONES") \ EM( ALLOC_CHUNK, "ALLOC_CHUNK") \ EM( ALLOC_CHUNK_FORCE, "ALLOC_CHUNK_FORCE") \EM (RUN_DELAYED_IPUTS ,"RUN_DELAYED_IPUTS" ) \
Signature · 1 line
2.47.0
Re: [PATCH 3/3] btrfs: zoned: reclaim unused zone by zone resetting
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2657
Quoted 7 lines · Naohiro Aota
fs/btrfs/zoned.c +7
-0+ +/* +* Reset the zones of unused block groups to free up @space_info->bytes_zone_unusable. +* +* @space_info: the space to work on +* @num_bytes: targeting reclaim bytes +*/
Maybe add a comment what's the difference between this and btrfs_delete_unused_bgs()?
Quoted 1 line
+int
btrfs_reset_unused_block_groups(struct btrfs_space_info *space_info, u64 num_bytes)
Maybe call it btrfs_space_info_reset_unused_zones()?
Quoted 11 lines
fs/btrfs/zoned.c +11
-0+{ +struct btrfs_fs_info *fs_info = space_info->fs_info; + +if (!btrfs_is_zoned (fs_info)) +return 0 ; + +while (num_bytes >0 ) { +struct btrfs_chunk_map *map; +struct btrfs_block_group *bg =NULL ; +bool found = false; +u64 reclaimed =0 ;
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2679
Quoted 10 lines
fs/btrfs/zoned.c +10
-0+ +/* +* Here, we choose a fully zone_unusable block group. It's +* technically possible to reset a partly zone_unusable block +* group, which still has some free space left. However, +* handling that needs to cope with the allocation side, which +* makes the logic more complex. So, let's handle the easy case +* for now. +*/ + scoped_guard(spinlock, &fs_info->unused_bgs_lock) {
Again, not a fan of the scoped_guard() macro...
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2685
Quoted 6 lines
fs/btrfs/zoned.c +6
-0+list_for_each_entry (bg, &fs_info->unused_bgs, bg_list) { +if ((bg->flags &BTRFS_BLOCK_GROUP_TYPE_MASK ) != space_info->flags) +continue ; + +if (!spin_trylock (&bg->lock)) +continue ;
especially as normal spin_lock() calls are mixed in.
Quoted 48 lines
fs/btrfs/zoned.c +48
-0+if (btrfs_is_block_group_used (bg) || + bg->zone_unusable < bg->length) { +spin_unlock (&bg->lock); +continue ; + } +spin_unlock (&bg->lock); + found = true; +break ; + } +if (!found) +return 0 ; + +list_del_init (&bg->bg_list); +btrfs_put_block_group (bg); + } + +/* +* Since the block group is fully zone_unusable and we cannot +* allocate anymore from this block group, we don't need to set +* this block group read-only. +*/ + + scoped_guard(rwsem_read, &fs_info->dev_replace.rwsem) { +const sector_t zone_size_sectors = fs_info->zone_size >>SECTOR_SHIFT ; + + map = bg->physical_map; +for (int i =0 ; i < map->num_stripes; i++) { +struct btrfs_io_stripe *stripe = &map->stripes[i]; +unsigned int nofs_flags; +int ret; + + nofs_flags =memalloc_nofs_save (); + ret =blkdev_zone_mgmt (stripe->dev->bdev,REQ_OP_ZONE_RESET , + stripe->physical >>SECTOR_SHIFT , + zone_size_sectors); +memalloc_nofs_restore (nofs_flags); + +if (ret) +return ret; + } + } + + scoped_guard(spinlock, &space_info->lock) { + scoped_guard(spinlock, &bg->lock) { +ASSERT (!btrfs_is_block_group_used (bg)); +if (bg->ro) +continue ; +
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2743
Quoted 10 lines
fs/btrfs/zoned.c +10
-0+ reclaimed = bg->alloc_offset; + bg->zone_unusable = bg->length - bg->zone_capacity; + bg->alloc_offset =0 ; +/* +* This holds because we currently reset fully +* used then freed BG. +*/ +ASSERT (reclaimed == bg->zone_capacity); + bg->free_space_ctl->free_space += reclaimed; + space_info->bytes_zone_unusable -= reclaimed;
btrfs_space_info_update_bytes_zone_unusable(space_info, -reclaimed);
Which perfectly fits once we get rid of the two scoped_guard() macros.
Quoted 11 lines
fs/btrfs/zoned.c +11
-0+ } +btrfs_return_free_space (space_info, reclaimed); + } + +if (num_bytes <= reclaimed) +break ; + num_bytes -= reclaimed; + } + +return 0 ; +}
Re: [PATCH 3/3] btrfs: zoned: reclaim unused zone by zone resetting
Quoted 11 lines · Johannes Thumshirn
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2679
Quoted 9 lines
fs/btrfs/zoned.c +9
-0+/* +* Here, we choose a fully zone_unusable block group. It's +* technically possible to reset a partly zone_unusable block +* group, which still has some free space left. However, +* handling that needs to cope with the allocation side, which +* makes the logic more complex. So, let's handle the easy case +* for now. +*/ + scoped_guard(spinlock, &fs_info->unused_bgs_lock) {Again, not a fan of the
scoped_guard()macro...
Yeah, we may use the scoped locking for something in the future but so far it would be quite confusing to mix explicit locking with scoped for current data structures. Subjectively speaking I don't want to use that at all.
Re: [PATCH 3/3] btrfs: zoned: reclaim unused zone by zone resetting
Quoted 13 lines · David Sterba
Quoted 11 lines · Johannes Thumshirn
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2679
Quoted 9 lines
fs/btrfs/zoned.c +9
-0+/* +* Here, we choose a fully zone_unusable block group. It's +* technically possible to reset a partly zone_unusable block +* group, which still has some free space left. However, +* handling that needs to cope with the allocation side, which +* makes the logic more complex. So, let's handle the easy case +* for now. +*/ + scoped_guard(spinlock, &fs_info->unused_bgs_lock) {Again, not a fan of the
scoped_guard()macro...
Quoted 4 lines
Yeah, we may use the scoped locking for something in the future but so far it would be quite confusing to mix explicit locking with scoped for current data structures. Subjectively speaking I don't want to use that at all.
As I wrote in another reply, mixing happens due to usage of "continue" in the outside loop. Well, I'll rewrite this with the ordinal locking style.
Re: [PATCH 3/3] btrfs: zoned: reclaim unused zone by zone resetting
In reply to Johannes ThumshirnQuoted 11 lines · Johannes Thumshirn
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2657
Quoted 7 lines · Naohiro Aota
fs/btrfs/zoned.c +7
-0+ +/* +* Reset the zones of unused block groups to free up @space_info->bytes_zone_unusable. +* +* @space_info: the space to work on +* @num_bytes: targeting reclaim bytes +*/ Maybe add a comment what's the difference between this and
btrfs_delete_unused_bgs()?
OK. This function allow reusing the block group space without removing them. So, it is like freeing region on the non-zoned mode. It is faster that btrfs_delete_unused_bgs() which just remove a block group and need re-allocation if we want to reuse the zone region.
Quoted 4 lines
Quoted 2 lines
+int
btrfs_reset_unused_block_groups(struct btrfs_space_info *space_info, u64 num_bytes)Maybe call it
btrfs_space_info_reset_unused_zones()?
Hmm, currently, we only call this function from the space_info reclaim context. But, like btrfs_run_delayed_refs() or btrfs_commit_current_transaction(), we may be able to use this function from other other contexts (e.g., extent allocation may want this?). So, I'm not sure sticking with "space_info" is a good option.
Quoted 25 lines
Quoted 12 lines
fs/btrfs/zoned.c +11
-0+{ +struct btrfs_fs_info *fs_info = space_info->fs_info; + +if (!btrfs_is_zoned (fs_info)) +return 0 ; + +while (num_bytes >0 ) { +struct btrfs_chunk_map *map; +struct btrfs_block_group *bg =NULL ; +bool found = false; +u64 reclaimed =0 ;fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2679
Quoted 10 lines
fs/btrfs/zoned.c +10
-0+ +/* +* Here, we choose a fully zone_unusable block group. It's +* technically possible to reset a partly zone_unusable block +* group, which still has some free space left. However, +* handling that needs to cope with the allocation side, which +* makes the logic more complex. So, let's handle the easy case +* for now. +*/ + scoped_guard(spinlock, &fs_info->unused_bgs_lock) {Again, not a fan of the
scoped_guard()macro...
Quoted 8 lines
fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2685
Quoted 6 lines
fs/btrfs/zoned.c +6
-0+list_for_each_entry (bg, &fs_info->unused_bgs, bg_list) { +if ((bg->flags &BTRFS_BLOCK_GROUP_TYPE_MASK ) != space_info->flags) +continue ; + +if (!spin_trylock (&bg->lock)) +continue ;especially as normal
spin_lock()calls are mixed in.
Yeah, this is nasty... there is scoped_cond_guard() variant which can use spin_trylock. But, since it uses "for (...)" internally, using it will break "continue" below. So, I avoided using that here.
Quoted 77 lines
Quoted 49 lines
fs/btrfs/zoned.c +48
-0+if (btrfs_is_block_group_used (bg) || + bg->zone_unusable < bg->length) { +spin_unlock (&bg->lock); +continue ; + } +spin_unlock (&bg->lock); + found = true; +break ; + } +if (!found) +return 0 ; + +list_del_init (&bg->bg_list); +btrfs_put_block_group (bg); + } + +/* +* Since the block group is fully zone_unusable and we cannot +* allocate anymore from this block group, we don't need to set +* this block group read-only. +*/ + + scoped_guard(rwsem_read, &fs_info->dev_replace.rwsem) { +const sector_t zone_size_sectors = fs_info->zone_size >>SECTOR_SHIFT ; + + map = bg->physical_map; +for (int i =0 ; i < map->num_stripes; i++) { +struct btrfs_io_stripe *stripe = &map->stripes[i]; +unsigned int nofs_flags; +int ret; + + nofs_flags =memalloc_nofs_save (); + ret =blkdev_zone_mgmt (stripe->dev->bdev,REQ_OP_ZONE_RESET , + stripe->physical >>SECTOR_SHIFT , + zone_size_sectors); +memalloc_nofs_restore (nofs_flags); + +if (ret) +return ret; + } + } + + scoped_guard(spinlock, &space_info->lock) { + scoped_guard(spinlock, &bg->lock) { +ASSERT (!btrfs_is_block_group_used (bg)); +if (bg->ro) +continue ; +fs/btrfs/zoned.c void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info) · line 2743
Quoted 10 lines
fs/btrfs/zoned.c +10
-0+ reclaimed = bg->alloc_offset; + bg->zone_unusable = bg->length - bg->zone_capacity; + bg->alloc_offset =0 ; +/* +* This holds because we currently reset fully +* used then freed BG. +*/ +ASSERT (reclaimed == bg->zone_capacity); + bg->free_space_ctl->free_space += reclaimed; + space_info->bytes_zone_unusable -= reclaimed;btrfs_space_info_update_bytes_zone_unusable(space_info, -reclaimed);Which perfectly fits once we get rid of the two
scoped_guard()macros.Quoted 11 lines
fs/btrfs/zoned.c +11
-0+ } +btrfs_return_free_space (space_info, reclaimed); + } + +if (num_bytes <= reclaimed) +break ; + num_bytes -= reclaimed; + } + +return 0 ; +}