diff mbox series

[39/43] xfs: support zone gaps

Message ID 20241211085636.1380516-40-hch@lst.de (mailing list archive)
State New
Headers show
Series [01/43] xfs: constify feature checks | expand

Commit Message

Christoph Hellwig Dec. 11, 2024, 8:55 a.m. UTC 
Zoned devices can have gaps beyond the usable capacity of a zone and the
end in the LBA/daddr address space.  In other words, the hardware
equivalent to the RT groups already takes care of the power of 2
alignment for us.  In this case the sparse FSB/RTB address space maps 1:1
to the device address space.

Signed-off-by: Christoph Hellwig <hch@lst.de>
---
 fs/xfs/libxfs/xfs_format.h  |  4 +++-
 fs/xfs/libxfs/xfs_group.h   |  6 +++++-
 fs/xfs/libxfs/xfs_rtgroup.h | 13 ++++++++-----
 fs/xfs/libxfs/xfs_sb.c      |  3 +++
 fs/xfs/libxfs/xfs_zones.c   | 19 +++++++++++++++++--
 fs/xfs/xfs_mount.h          |  9 +++++++++
 6 files changed, 45 insertions(+), 9 deletions(-)

Comments

Darrick J. Wong Dec. 13, 2024, 10:55 p.m. UTC | #1 
On Wed, Dec 11, 2024 at 09:55:04AM +0100, Christoph Hellwig wrote:
> Zoned devices can have gaps beyond the usable capacity of a zone and the
> end in the LBA/daddr address space.  In other words, the hardware
> equivalent to the RT groups already takes care of the power of 2
> alignment for us.  In this case the sparse FSB/RTB address space maps 1:1
> to the device address space.

Heh, sparse lba ranges.

> Signed-off-by: Christoph Hellwig <hch@lst.de>
> ---
>  fs/xfs/libxfs/xfs_format.h  |  4 +++-
>  fs/xfs/libxfs/xfs_group.h   |  6 +++++-
>  fs/xfs/libxfs/xfs_rtgroup.h | 13 ++++++++-----
>  fs/xfs/libxfs/xfs_sb.c      |  3 +++
>  fs/xfs/libxfs/xfs_zones.c   | 19 +++++++++++++++++--
>  fs/xfs/xfs_mount.h          |  9 +++++++++
>  6 files changed, 45 insertions(+), 9 deletions(-)
> 
> diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
> index fc56de8fe696..9491a09f6aa7 100644
> --- a/fs/xfs/libxfs/xfs_format.h
> +++ b/fs/xfs/libxfs/xfs_format.h
> @@ -398,6 +398,7 @@ xfs_sb_has_ro_compat_feature(
>  #define XFS_SB_FEAT_INCOMPAT_PARENT	(1 << 7)  /* parent pointers */
>  #define XFS_SB_FEAT_INCOMPAT_METADIR	(1 << 8)  /* metadata dir tree */
>  #define XFS_SB_FEAT_INCOMPAT_ZONED	(1U << 31)/* zoned RT allocator */
> +#define XFS_SB_FEAT_INCOMPAT_ZONE_GAPS	(1U << 30)/* RTGs have LBA gaps */

These will have to be renumbered before merging.

Otherwise looks ok,
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>

--D


>  #define XFS_SB_FEAT_INCOMPAT_ALL \
>  		(XFS_SB_FEAT_INCOMPAT_FTYPE | \
> @@ -409,7 +410,8 @@ xfs_sb_has_ro_compat_feature(
>  		 XFS_SB_FEAT_INCOMPAT_EXCHRANGE | \
>  		 XFS_SB_FEAT_INCOMPAT_PARENT | \
>  		 XFS_SB_FEAT_INCOMPAT_METADIR | \
> -		 XFS_SB_FEAT_INCOMPAT_ZONED)
> +		 XFS_SB_FEAT_INCOMPAT_ZONED | \
> +		 XFS_SB_FEAT_INCOMPAT_ZONE_GAPS)
>  
>  #define XFS_SB_FEAT_INCOMPAT_UNKNOWN	~XFS_SB_FEAT_INCOMPAT_ALL
>  static inline bool
> diff --git a/fs/xfs/libxfs/xfs_group.h b/fs/xfs/libxfs/xfs_group.h
> index 430a43e1591e..996b29313bc2 100644
> --- a/fs/xfs/libxfs/xfs_group.h
> +++ b/fs/xfs/libxfs/xfs_group.h
> @@ -117,7 +117,11 @@ xfs_gbno_to_daddr(
>  	struct xfs_groups	*g = &mp->m_groups[xg->xg_type];
>  	xfs_fsblock_t		fsbno;
>  
> -	fsbno = (xfs_fsblock_t)xg->xg_gno * g->blocks + gbno;
> +	if (g->has_daddr_gaps)
> +		fsbno = xfs_gbno_to_fsb(xg, gbno);
> +	else
> +		fsbno = (xfs_fsblock_t)xg->xg_gno * g->blocks + gbno;
> +
>  	return XFS_FSB_TO_BB(mp, g->start_fsb + fsbno);
>  }
>  
> diff --git a/fs/xfs/libxfs/xfs_rtgroup.h b/fs/xfs/libxfs/xfs_rtgroup.h
> index 85d8d329d417..5b3305e09ec3 100644
> --- a/fs/xfs/libxfs/xfs_rtgroup.h
> +++ b/fs/xfs/libxfs/xfs_rtgroup.h
> @@ -245,11 +245,14 @@ xfs_rtb_to_daddr(
>  	xfs_rtblock_t		rtbno)
>  {
>  	struct xfs_groups	*g = &mp->m_groups[XG_TYPE_RTG];
> -	xfs_rgnumber_t		rgno = xfs_rtb_to_rgno(mp, rtbno);
> -	uint64_t		start_bno = (xfs_rtblock_t)rgno * g->blocks;
>  
> -	return XFS_FSB_TO_BB(mp,
> -		g->start_fsb + start_bno + (rtbno & g->blkmask));
> +	if (xfs_has_rtgroups(mp) && !g->has_daddr_gaps) {
> +		xfs_rgnumber_t	rgno = xfs_rtb_to_rgno(mp, rtbno);
> +
> +		rtbno = (xfs_rtblock_t)rgno * g->blocks + (rtbno & g->blkmask);
> +	}
> +
> +	return XFS_FSB_TO_BB(mp, g->start_fsb + rtbno);
>  }
>  
>  static inline xfs_rtblock_t
> @@ -261,7 +264,7 @@ xfs_daddr_to_rtb(
>  	xfs_rfsblock_t		bno;
>  
>  	bno = XFS_BB_TO_FSBT(mp, daddr) - g->start_fsb;
> -	if (xfs_has_rtgroups(mp)) {
> +	if (xfs_has_rtgroups(mp) && !g->has_daddr_gaps) {
>  		xfs_rgnumber_t	rgno;
>  		uint32_t	rgbno;
>  
> diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
> index ee56fc22fd06..18e4c4908f94 100644
> --- a/fs/xfs/libxfs/xfs_sb.c
> +++ b/fs/xfs/libxfs/xfs_sb.c
> @@ -1176,6 +1176,9 @@ xfs_sb_mount_rextsize(
>  		rgs->blklog = mp->m_sb.sb_rgblklog;
>  		rgs->blkmask = xfs_mask32lo(mp->m_sb.sb_rgblklog);
>  		rgs->start_fsb = mp->m_sb.sb_rtstart;
> +		if (xfs_sb_has_incompat_feature(sbp,
> +				XFS_SB_FEAT_INCOMPAT_ZONE_GAPS))
> +			rgs->has_daddr_gaps = true;
>  	} else {
>  		rgs->blocks = 0;
>  		rgs->blklog = 0;
> diff --git a/fs/xfs/libxfs/xfs_zones.c b/fs/xfs/libxfs/xfs_zones.c
> index e170d7c13533..c17111f40821 100644
> --- a/fs/xfs/libxfs/xfs_zones.c
> +++ b/fs/xfs/libxfs/xfs_zones.c
> @@ -135,6 +135,7 @@ xfs_zone_validate(
>  {
>  	struct xfs_mount	*mp = rtg_mount(rtg);
>  	struct xfs_groups	*g = &mp->m_groups[XG_TYPE_RTG];
> +	uint32_t		expected_size;
>  
>  	/*
>  	 * Check that the zone capacity matches the rtgroup size stored in the
> @@ -149,11 +150,25 @@ xfs_zone_validate(
>  		return -EIO;
>  	}
>  
> -	if (XFS_BB_TO_FSB(mp, zone->len) != 1 << g->blklog) {
> +	if (g->has_daddr_gaps) {
> +		expected_size = 1 << g->blklog;
> +	} else {
> +		if (zone->len != zone->capacity) {
> +			xfs_warn(mp,
> +"zone %u has capacity != size ((0x%llx vs 0x%llx)",
> +				rtg_rgno(rtg),
> +				XFS_BB_TO_FSB(mp, zone->len),
> +				XFS_BB_TO_FSB(mp, zone->capacity));
> +			return -EIO;
> +		}
> +		expected_size = g->blocks;
> +	}
> +
> +	if (XFS_BB_TO_FSB(mp, zone->len) != expected_size) {
>  		xfs_warn(mp,
>  "zone %u length (0x%llx) does match geometry (0x%x).",
>  			rtg_rgno(rtg), XFS_BB_TO_FSB(mp, zone->len),
> -			1 << g->blklog);
> +			expected_size);
>  	}
>  
>  	switch (zone->type) {
> diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
> index 831d9e09fe72..ec8612c8b71d 100644
> --- a/fs/xfs/xfs_mount.h
> +++ b/fs/xfs/xfs_mount.h
> @@ -97,6 +97,15 @@ struct xfs_groups {
>  	 */
>  	uint8_t			blklog;
>  
> +	/*
> +	 * Zoned devices can have gaps beyond the usable capacity of a zone and
> +	 * the end in the LBA/daddr address space.  In other words, the hardware
> +	 * equivalent to the RT groups already takes care of the power of 2
> +	 * alignment for us.  In this case the sparse FSB/RTB address space maps
> +	 * 1:1 to the device address space.
> +	 */
> +	bool			has_daddr_gaps;
> +
>  	/*
>  	 * Mask to extract the group-relative block number from a FSB.
>  	 * For a pre-rtgroups filesystem we pretend to have one very large
> -- 
> 2.45.2
> 
>
diff mbox series

Patch

diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index fc56de8fe696..9491a09f6aa7 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -398,6 +398,7 @@  xfs_sb_has_ro_compat_feature(
 #define XFS_SB_FEAT_INCOMPAT_PARENT	(1 << 7)  /* parent pointers */
 #define XFS_SB_FEAT_INCOMPAT_METADIR	(1 << 8)  /* metadata dir tree */
 #define XFS_SB_FEAT_INCOMPAT_ZONED	(1U << 31)/* zoned RT allocator */
+#define XFS_SB_FEAT_INCOMPAT_ZONE_GAPS	(1U << 30)/* RTGs have LBA gaps */
 
 #define XFS_SB_FEAT_INCOMPAT_ALL \
 		(XFS_SB_FEAT_INCOMPAT_FTYPE | \
@@ -409,7 +410,8 @@  xfs_sb_has_ro_compat_feature(
 		 XFS_SB_FEAT_INCOMPAT_EXCHRANGE | \
 		 XFS_SB_FEAT_INCOMPAT_PARENT | \
 		 XFS_SB_FEAT_INCOMPAT_METADIR | \
-		 XFS_SB_FEAT_INCOMPAT_ZONED)
+		 XFS_SB_FEAT_INCOMPAT_ZONED | \
+		 XFS_SB_FEAT_INCOMPAT_ZONE_GAPS)
 
 #define XFS_SB_FEAT_INCOMPAT_UNKNOWN	~XFS_SB_FEAT_INCOMPAT_ALL
 static inline bool
diff --git a/fs/xfs/libxfs/xfs_group.h b/fs/xfs/libxfs/xfs_group.h
index 430a43e1591e..996b29313bc2 100644
--- a/fs/xfs/libxfs/xfs_group.h
+++ b/fs/xfs/libxfs/xfs_group.h
@@ -117,7 +117,11 @@  xfs_gbno_to_daddr(
 	struct xfs_groups	*g = &mp->m_groups[xg->xg_type];
 	xfs_fsblock_t		fsbno;
 
-	fsbno = (xfs_fsblock_t)xg->xg_gno * g->blocks + gbno;
+	if (g->has_daddr_gaps)
+		fsbno = xfs_gbno_to_fsb(xg, gbno);
+	else
+		fsbno = (xfs_fsblock_t)xg->xg_gno * g->blocks + gbno;
+
 	return XFS_FSB_TO_BB(mp, g->start_fsb + fsbno);
 }
 
diff --git a/fs/xfs/libxfs/xfs_rtgroup.h b/fs/xfs/libxfs/xfs_rtgroup.h
index 85d8d329d417..5b3305e09ec3 100644
--- a/fs/xfs/libxfs/xfs_rtgroup.h
+++ b/fs/xfs/libxfs/xfs_rtgroup.h
@@ -245,11 +245,14 @@  xfs_rtb_to_daddr(
 	xfs_rtblock_t		rtbno)
 {
 	struct xfs_groups	*g = &mp->m_groups[XG_TYPE_RTG];
-	xfs_rgnumber_t		rgno = xfs_rtb_to_rgno(mp, rtbno);
-	uint64_t		start_bno = (xfs_rtblock_t)rgno * g->blocks;
 
-	return XFS_FSB_TO_BB(mp,
-		g->start_fsb + start_bno + (rtbno & g->blkmask));
+	if (xfs_has_rtgroups(mp) && !g->has_daddr_gaps) {
+		xfs_rgnumber_t	rgno = xfs_rtb_to_rgno(mp, rtbno);
+
+		rtbno = (xfs_rtblock_t)rgno * g->blocks + (rtbno & g->blkmask);
+	}
+
+	return XFS_FSB_TO_BB(mp, g->start_fsb + rtbno);
 }
 
 static inline xfs_rtblock_t
@@ -261,7 +264,7 @@  xfs_daddr_to_rtb(
 	xfs_rfsblock_t		bno;
 
 	bno = XFS_BB_TO_FSBT(mp, daddr) - g->start_fsb;
-	if (xfs_has_rtgroups(mp)) {
+	if (xfs_has_rtgroups(mp) && !g->has_daddr_gaps) {
 		xfs_rgnumber_t	rgno;
 		uint32_t	rgbno;
 
diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index ee56fc22fd06..18e4c4908f94 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -1176,6 +1176,9 @@  xfs_sb_mount_rextsize(
 		rgs->blklog = mp->m_sb.sb_rgblklog;
 		rgs->blkmask = xfs_mask32lo(mp->m_sb.sb_rgblklog);
 		rgs->start_fsb = mp->m_sb.sb_rtstart;
+		if (xfs_sb_has_incompat_feature(sbp,
+				XFS_SB_FEAT_INCOMPAT_ZONE_GAPS))
+			rgs->has_daddr_gaps = true;
 	} else {
 		rgs->blocks = 0;
 		rgs->blklog = 0;
diff --git a/fs/xfs/libxfs/xfs_zones.c b/fs/xfs/libxfs/xfs_zones.c
index e170d7c13533..c17111f40821 100644
--- a/fs/xfs/libxfs/xfs_zones.c
+++ b/fs/xfs/libxfs/xfs_zones.c
@@ -135,6 +135,7 @@  xfs_zone_validate(
 {
 	struct xfs_mount	*mp = rtg_mount(rtg);
 	struct xfs_groups	*g = &mp->m_groups[XG_TYPE_RTG];
+	uint32_t		expected_size;
 
 	/*
 	 * Check that the zone capacity matches the rtgroup size stored in the
@@ -149,11 +150,25 @@  xfs_zone_validate(
 		return -EIO;
 	}
 
-	if (XFS_BB_TO_FSB(mp, zone->len) != 1 << g->blklog) {
+	if (g->has_daddr_gaps) {
+		expected_size = 1 << g->blklog;
+	} else {
+		if (zone->len != zone->capacity) {
+			xfs_warn(mp,
+"zone %u has capacity != size ((0x%llx vs 0x%llx)",
+				rtg_rgno(rtg),
+				XFS_BB_TO_FSB(mp, zone->len),
+				XFS_BB_TO_FSB(mp, zone->capacity));
+			return -EIO;
+		}
+		expected_size = g->blocks;
+	}
+
+	if (XFS_BB_TO_FSB(mp, zone->len) != expected_size) {
 		xfs_warn(mp,
 "zone %u length (0x%llx) does match geometry (0x%x).",
 			rtg_rgno(rtg), XFS_BB_TO_FSB(mp, zone->len),
-			1 << g->blklog);
+			expected_size);
 	}
 
 	switch (zone->type) {
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 831d9e09fe72..ec8612c8b71d 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -97,6 +97,15 @@  struct xfs_groups {
 	 */
 	uint8_t			blklog;
 
+	/*
+	 * Zoned devices can have gaps beyond the usable capacity of a zone and
+	 * the end in the LBA/daddr address space.  In other words, the hardware
+	 * equivalent to the RT groups already takes care of the power of 2
+	 * alignment for us.  In this case the sparse FSB/RTB address space maps
+	 * 1:1 to the device address space.
+	 */
+	bool			has_daddr_gaps;
+
 	/*
 	 * Mask to extract the group-relative block number from a FSB.
 	 * For a pre-rtgroups filesystem we pretend to have one very large