Skip to contentSkip to conversation

fix handling of too many open zones at mount time v2

PATCH In review Christoph Hellwig 3 participants 6 messages Mar 31 – Apr 7 XFS filesystem

lore
Share & tools
lore
#0 lore raw

Hi all,

because there is no actual write pointer when running the zoned allocator on conventional devices or zones, we can see spurious extra open zones when the last blocks in a written zone have been invalidated. This series adds code to handle that case and remove these spurious extra zones. It also fixes up the mountinfo code for open zones to be more easy to parse, and adds a new sysfs file reporting the currently open zones, which makes it easier to use the value in tests.

A test for the open zone behavior will be added to xfstests.

Changes since v1:
- spelling and other documentation fixes
- move two patches not directly related to the fix to a different series

Diffstat:

 xfs_trace.h      |    1 
 xfs_zone_alloc.c |  129 ++++++++++++++++++++++++++++++++++++++++++++++---------
 2 files changed, 110 insertions(+), 20 deletions(-)
#1 lore raw

PATCH 1/2 xfs: refactor xfs_mount_zones

xfs_mount_zones has grown a bit too big and unorganized. Split the zone reporting loop into a separate helper, hiding the rtg variable there. Print the mount message last, and also keep the VFS writeback chunk size last instead of in the middle of the logic to calculate the free/available blocks.

---
 fs/xfs/xfs_zone_alloc.c | 54 ++++++++++++++++++++++++++---------------
 1 file changed, 34 insertions(+), 20 deletions(-)
fs/xfs/xfs_zone_alloc.c +34 -20
index 06e2cb79030e..e9f1d9d08620 100644
@@ -1230,6 +1230,29 @@ xfs_free_zone_info(
 	kfree(zi);
 }
 
+static int
+xfs_report_zones(
+	struct xfs_mount	*mp,
+	struct xfs_init_zones	*iz)
+{
+	struct xfs_rtgroup	*rtg = NULL;
+
+	while ((rtg = xfs_rtgroup_next(mp, rtg))) {
+		xfs_rgblock_t		write_pointer;
+		int			error;
+
+		error = xfs_query_write_pointer(iz, rtg, &write_pointer);
+		if (!error)
+			error = xfs_init_zone(iz, rtg, write_pointer);
+		if (error) {
+			xfs_rtgroup_rele(rtg);
+			return error;
+		}
+	}
+
+	return 0;
+}
+
 int
 xfs_mount_zones(
 	struct xfs_mount	*mp)
@@ -1238,7 +1261,6 @@ xfs_mount_zones(
 		.zone_capacity	= mp->m_groups[XG_TYPE_RTG].blocks,
 		.zone_size	= xfs_rtgroup_raw_size(mp),
 	};
-	struct xfs_rtgroup	*rtg = NULL;
 	int			error;
 
 	if (!mp->m_rtdev_targp) {
@@ -1268,9 +1290,13 @@ xfs_mount_zones(
 	if (!mp->m_zone_info)
 		return -ENOMEM;
 
-	xfs_info(mp, "%u zones of %u blocks (%u max open zones)",
-		 mp->m_sb.sb_rgcount, iz.zone_capacity, mp->m_max_open_zones);
-	trace_xfs_zones_mount(mp);
+	error = xfs_report_zones(mp, &iz);
+	if (error)
+		goto out_free_zone_info;
+
+	xfs_set_freecounter(mp, XC_FREE_RTAVAILABLE, iz.available);
+	xfs_set_freecounter(mp, XC_FREE_RTEXTENTS,
+			iz.available + iz.reclaimable);
 
 	/*
 	 * The writeback code switches between inodes regularly to provide
@@ -1296,22 +1322,6 @@ xfs_mount_zones(
 		XFS_FSB_TO_B(mp, min(iz.zone_capacity, XFS_MAX_BMBT_EXTLEN)) >>
 			PAGE_SHIFT;
 
-	while ((rtg = xfs_rtgroup_next(mp, rtg))) {
-		xfs_rgblock_t		write_pointer;
-
-		error = xfs_query_write_pointer(&iz, rtg, &write_pointer);
-		if (!error)
-			error = xfs_init_zone(&iz, rtg, write_pointer);
-		if (error) {
-			xfs_rtgroup_rele(rtg);
-			goto out_free_zone_info;
-		}
-	}
-
-	xfs_set_freecounter(mp, XC_FREE_RTAVAILABLE, iz.available);
-	xfs_set_freecounter(mp, XC_FREE_RTEXTENTS,
-			iz.available + iz.reclaimable);
-
 	/*
 	 * The user may configure GC to free up a percentage of unused blocks.
 	 * By default this is 0. GC will always trigger at the minimum level
@@ -1322,6 +1332,10 @@ xfs_mount_zones(
 	error = xfs_zone_gc_mount(mp);
 	if (error)
 		goto out_free_zone_info;
+
+	xfs_info(mp, "%u zones of %u blocks (%u max open zones)",
+		 mp->m_sb.sb_rgcount, iz.zone_capacity, mp->m_max_open_zones);
+	trace_xfs_zones_mount(mp);
 	return 0;
 
 out_free_zone_info:
Signature · 1 line
2.47.3
Reviewed-by on v1 1/2
#2 lore raw

Re: [PATCH 1/2] xfs: refactor xfs_mount_zones

Quoted 8 lines · Christoph Hellwig

xfs_mount_zones has grown a bit too big and unorganized. Split the zone reporting loop into a separate helper, hiding the rtg variable there. Print the mount message last, and also keep the VFS writeback chunk size last instead of in the middle of the logic to calculate the free/available blocks.

Signature · 2 lines
Damien Le Moal
Western Digital Research
#3 lore raw

PATCH 2/2 xfs: handle too many open zones when mounting

In reply to Christoph Hellwig

When running on conventional zones or devices, the zoned allocator does not have a real write pointer, but instead fakes it up at mount time based on the last block recorded in the rmap. This can create spurious "open" zones when the last written blocks in a conventional zone are invalidated. Add a loop to the mount code to find the conventional zone with the highest used block in the rmap tree and "finish" it until we are below the open zones limit.

While we're at it, also error out if there are too many open sequential zones, which can only happen when the user overrode the max open zones limit (or with really buggy hardware reducing the limit, but not much we can do about that).

Fixes 4e4d52075577 ("xfs: add the zoned space allocator")
---
 fs/xfs/xfs_trace.h      |  1 +
 fs/xfs/xfs_zone_alloc.c | 75 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
fs/xfs/xfs_trace.h +1 -0
index 60d1e605dfa5..c5ad26a1d7bb 100644
@@ -461,6 +461,7 @@ DEFINE_EVENT(xfs_zone_alloc_class, name,			\
 DEFINE_ZONE_ALLOC_EVENT(xfs_zone_record_blocks);
 DEFINE_ZONE_ALLOC_EVENT(xfs_zone_skip_blocks);
 DEFINE_ZONE_ALLOC_EVENT(xfs_zone_alloc_blocks);
+DEFINE_ZONE_ALLOC_EVENT(xfs_zone_spurious_open);
 
 TRACE_EVENT(xfs_zone_gc_select_victim,
 	TP_PROTO(struct xfs_rtgroup *rtg, unsigned int bucket),
fs/xfs/xfs_zone_alloc.c +75 -0

87 lines not on this page · raw message

Signature · 1 line
2.47.3
Reviewed-by on v1 2/2
#4 lore raw

Re: [PATCH 2/2] xfs: handle too many open zones when mounting

Quoted 8 lines · Christoph Hellwig

When running on conventional zones or devices, the zoned allocator does not have a real write pointer, but instead fakes it up at mount time based on the last block recorded in the rmap. This can create spurious "open" zones when the last written blocks in a conventional zone are invalidated. Add a loop to the mount code to find the conventional zone with the highest used block in the rmap tree and "finish" it until we are below the open zones limit.

Quoted 8 lines

While we're at it, also error out if there are too many open sequential zones, which can only happen when the user overrode the max open zones limit (or with really buggy hardware reducing the limit, but not much we can do about that).

Fixes 4e4d52075577 ("xfs: add the zoned space allocator")
Signature · 2 lines
Damien Le Moal
Western Digital Research
maintainer Applied
#5 lore raw
In reply to Christoph Hellwig
Quoted 9 lines · Christoph Hellwig

because there is no actual write pointer when running the zoned allocator on conventional devices or zones, we can see spurious extra open zones when the last blocks in a written zone have been invalidated. This series adds code to handle that case and remove these spurious extra zones. It also fixes up the mountinfo code for open zones to be more easy to parse, and adds a new sysfs file reporting the currently open zones, which makes it easier to use the value in tests.

[...]

Applied to for-next, thanks!

[1/2] xfs: refactor xfs_mount_zones

      commit: 02367990bdcbeabb0ffd3e8e227e5f79a04186fc
[2/2] xfs: handle too many open zones when mounting
      commit: c6584888864e36d6225a6c16d8c39fd2aa9a45d8

Best regards,

Signature · 1 line
Carlos Maiolino <[email protected]>