btrfs: zoned: implement ZONE_RESET space_info reclaiming
Subsystems (2)
v2 cover btrfs: zoned: implement ZONE_RESET space_info reclaiming
There is a longstanding early ENOSPC issue on the zoned mode. When there are heavy write operations on a nearly ENOSPC file system, freeing up the space and resetting the zones often cannot catch up the write speed. That results in an early ENOSPC. For example, running the following fio script, which repeatedly over-writes 15 GB files on 20 GB file system results in a ENOSPC shown below.
Fio script:
[test]
filename=/mnt/scratch/test
readwrite=write
ioengine=libaio
direct=1
loops=10
filesize=15G
bs=128k
Result:
BTRFS info (device nvme0n1): cannot satisfy tickets, dumping space info
BTRFS info (device nvme0n1): space_info DATA has 0 free, is full
BTRFS info (device nvme0n1): space_info total=20535312384, used=16106127360, pinned=0, reserved=0, may_use=0, readonly=0 zone_unusable=4429185024
BTRFS info (device nvme0n1): failing ticket with 131072 bytes
BTRFS info (device nvme0n1): space_info DATA has 0 free, is full
BTRFS info (device nvme0n1): space_info total=20535312384, used=16106127360, pinned=0, reserved=0, may_use=0, readonly=0 zone_unusable=4429185024
BTRFS info (device nvme0n1): global_block_rsv: size 25870336 reserved 25853952
BTRFS info (device nvme0n1): trans_block_rsv: size 0 reserved 0
BTRFS info (device nvme0n1): chunk_block_rsv: size 0 reserved 0
BTRFS info (device nvme0n1): delayed_block_rsv: size 0 reserved 0
BTRFS info (device nvme0n1): delayed_refs_rsv: size 0 reserved 0
fio: io_u error on file /mnt/scratch/test: No space left on device: write offset=13287555072, buflen=131072
fio: pid=869, err=28/file:io_u.c:1962, func=io_u error, error=No space left on device
...
Run status group 0 (all jobs):
WRITE: bw=113MiB/s (118MB/s), 113MiB/s-113MiB/s (118MB/s-118MB/s), io=27.4GiB (29.4GB), run=248965-248965msec
As the result shows, fio fails only after 27GB. Instead, it should be able to write 150 GB by freeing over-written region. The space_info status shows that there is 4.1 GB zone_unusable in the DATA space. While this space will be eventually freed after a transaction commit and zone reset, the space_info dump means btrfs is too slow to reuse the zone_unusable.
There are some reasons to hit ENOSPC early and this series only addresses one of them: unusable block group is not reclaimed enough fast. This series introduces a new space_info reclaim method ZONE_RESET. That method will pick a block group in the unused list and send ZONE_RESET command to free up and reuse the zone_unusable space.
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.
Patches 1 and 2 do the preparation for the patch 3 and there are no functional change. Patch 3 introduces the new space_info reclaim method ZONE_RESET described above.
Following series will fully fix ENOSPC issue on the above fio script. One will separate space_info of regular data and relocation data. And, another will rework zone resetting of deleted block group to let it set the empty zone bit early.
Changes:
- v2:
- Use the ordinal locking style.
- Rewrite btrfs_return_free_space() to reduce indent level.
- Add some extra comment.
- v1: https://lore.kernel.org/linux-btrfs/gjr4vwt5qm7j36xnjijp5wqttpmh62trhsq5vqeotcqm6kx2pq@qovd36rh7hap/T/
Naohiro Aota (3):
btrfs: introduce btrfs_return_free_space()
btrfs: drop fs_info argument from btrfs_update_space_info_*
btrfs: zoned: reclaim unused zone by zone resetting
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 | 35 ++-------- fs/btrfs/inode.c | 2 +- fs/btrfs/space-info.c | 69 ++++++++++++++++--- fs/btrfs/space-info.h | 15 +++-- fs/btrfs/transaction.c | 3 +- fs/btrfs/zoned.c | 124 +++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 7 ++ include/trace/events/btrfs.h | 3 +- 12 files changed, 223 insertions(+), 68 deletions(-)
Signature · 1 line
2.47.0
PATCH v2 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 | 29 +++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 1 + 3 files changed, 34 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 +29 -0
@@ -2082,3 +2082,32 @@ 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); + +/* Prioritize the global reservation to receive the freed space. */ +if (global_rsv->space_info != space_info) + goto grant; + +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); + +grant: +/* 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
PATCH v2 2/3 btrfs: drop fs_info argument from btrfs_update_space_info_*
In reply to Naohiro AotaSince 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 ; } }
@@ -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;
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
PATCH v2 3/3 btrfs: zoned: reclaim unused zone by zone resetting
In reply to Naohiro AotaOn 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 | 124 +++++++++++++++++++++++++++++++++++ fs/btrfs/zoned.h | 7 ++ include/trace/events/btrfs.h | 3 +- 5 files changed, 164 insertions(+), 3 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 +124 -0
127 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 +2 -1
@@ -100,7 +100,8 @@ struct find_free_extent_ctl; EM( ALLOC_CHUNK, "ALLOC_CHUNK") \ EM( ALLOC_CHUNK_FORCE, "ALLOC_CHUNK_FORCE") \ EM( RUN_DELAYED_IPUTS, "RUN_DELAYED_IPUTS") \ -EMe (COMMIT_TRANS ,"COMMIT_TRANS" ) + EM( COMMIT_TRANS, "COMMIT_TRANS") \ +EMe (RESET_ZONES ,"RESET_ZONES" )/* * First define the enums in the above macros to be exported to userspace via
Signature · 1 line
2.47.0
Quoted 71 lines · Naohiro Aota
There is a longstanding early ENOSPC issue on the zoned mode. When there are heavy write operations on a nearly ENOSPC file system, freeing up the space and resetting the zones often cannot catch up the write speed. That results in an early ENOSPC. For example, running the following fio script, which repeatedly over-writes 15 GB files on 20 GB file system results in a ENOSPC shown below.
Fio script:
[test]
filename=/mnt/scratch/test
readwrite=write
ioengine=libaio
direct=1
loops=10
filesize=15G
bs=128kResult:
BTRFS info (device nvme0n1): cannot satisfy tickets, dumping space info
BTRFS info (device nvme0n1):space_infoDATA has 0 free, is full
BTRFS info (device nvme0n1):space_infototal=20535312384, used=16106127360, pinned=0, reserved=0, may_use=0, readonly=0 zone_unusable=4429185024
BTRFS info (device nvme0n1): failing ticket with 131072 bytes
BTRFS info (device nvme0n1):space_infoDATA has 0 free, is full
BTRFS info (device nvme0n1):space_infototal=20535312384, used=16106127360, pinned=0, reserved=0, may_use=0, readonly=0 zone_unusable=4429185024
BTRFS info (device nvme0n1):global_block_rsv: size 25870336 reserved 25853952
BTRFS info (device nvme0n1):trans_block_rsv: size 0 reserved 0
BTRFS info (device nvme0n1):chunk_block_rsv: size 0 reserved 0
BTRFS info (device nvme0n1):delayed_block_rsv: size 0 reserved 0
BTRFS info (device nvme0n1):delayed_refs_rsv: size 0 reserved 0
fio:io_uerror on file/mnt/scratch/test: No space left on device: write offset=13287555072, buflen=131072
fio: pid=869, err=28/file:io_u.c:1962, func=io_u error, error=No space left on device
...
Run status group 0 (all jobs):WRITE: bw=113MiB/s (118MB/s), 113MiB/s-113MiB/s (118MB/s-118MB/s), io=27.4GiB (29.4GB), run=248965-248965msecAs the result shows, fio fails only after 27GB. Instead, it should be able to write 150 GB by freeing over-written region. The
space_infostatus shows that there is 4.1 GBzone_unusablein the DATA space. While this space will be eventually freed after a transaction commit and zone reset, thespace_infodump means btrfs is too slow to reuse thezone_unusable.There are some reasons to hit ENOSPC early and this series only addresses one of them: unusable block group is not reclaimed enough fast. This series introduces a new
space_inforeclaim methodZONE_RESET. That method will pick a block group in the unused list and sendZONE_RESETcommand to free up and reuse thezone_unusablespace.For the first implementation, the
ZONE_RESETis only applied to a block group whose region is fullyzone_unusable. Reclaiming partialzone_unusableblock group could be implemented later.Patches 1 and 2 do the preparation for the patch 3 and there are no functional change. Patch 3 introduces the new
space_inforeclaim methodZONE_RESETdescribed above.Following series will fully fix ENOSPC issue on the above fio script. One will separate
space_infoof regular data and relocation data. And, another will rework zone resetting of deleted block group to let it set the empty zone bit early.Changes:
- v2:
- Use the ordinal locking style.
- Rewritebtrfs_return_free_space()to reduce indent level.
- Add some extra comment.
- v1: https://lore.kernel.org/linux-btrfs/gjr4vwt5qm7j36xnjijp5wqttpmh62trhsq5vqeotcqm6kx2pq@qovd36rh7hap/T/
Quoted 4 lines
Naohiro Aota (3):
btrfs: introducebtrfs_return_free_space()
btrfs: dropfs_infoargument from btrfs_update_space_info_*
btrfs: zoned: reclaim unused zone by zone resetting
The logic sounds ok to me, I've added the patches to for-next, thanks.