Skip to contentSkip to conversation

btrfs: introduce btrfs_return_free_space()

PATCH Superseded Naohiro Aota 3 participants 9 messages Nov 11, 2024 – Nov 14, 2024 1 message not in the archive

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

#1 lore raw

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
index 412e318e4a22..ce7c963dd0a6 100644
@@ -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
index 255e85f78313..bcdf0fdfa2d3 100644
@@ -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
index efbecc0c5258..4c9e8aabee51 100644
@@ -295,5 +295,6 @@ void btrfs_set_periodic_reclaim_ready(struct btrfs_space_info *space_info, bool
 bool 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
Reviewed-by on v1 1/3
#2 lore raw
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.

#3 lore raw

PATCH 2/3 btrfs: drop fs_info argument from btrfs_update_space_info_*

In reply to a message not in the archive

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.

---
 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
index 4427c1b835e8..5be029734cfa 100644
@@ -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
index a07b9594dc70..3f3608299c0b 100644
@@ -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
index 7aa8a395d838..88e900e5a43d 100644
@@ -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
index 4d2ad5b66928..3e2b1121c4ff 100644
@@ -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
index ce7c963dd0a6..9bbaa2b943e9 100644
@@ -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
index 22b8e2764619..38716ffbca45 100644
@@ -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
index bcdf0fdfa2d3..b94cd43d9495 100644
@@ -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
index 4c9e8aabee51..69071afc0d47 100644
@@ -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
index dc0b837efd5d..15312013f2a3 100644
@@ -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
#5 lore raw

PATCH 3/3 btrfs: zoned: reclaim unused zone by zone resetting

In reply to a message not in the archive

On 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
index b94cd43d9495..8a0a347652f1 100644
@@ -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
index 69071afc0d47..a96efdb5e681 100644
@@ -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
index 7612e6572605..9672bf4c3335 100644
@@ -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
index 4df93ca9b7a8..aeaf079ff994 100644
@@ -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
#6 lore raw

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;
+}
#7 lore raw

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.

#8 lore raw

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.

#9 lore raw

Re: [PATCH 3/3] btrfs: zoned: reclaim unused zone by zone resetting

In reply to Johannes Thumshirn
Quoted 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;
+}