Re: [PATCH 3/7] xfs: rename oz_write_pointer to oz_allocated

["Darrick J. Wong" <djwong@kernel.org>]

On Wed, Jul 16, 2025 at 02:54:03PM +0200, Christoph Hellwig wrote:
> This member just tracks how much space we handed out for sequential
> write required zones.  Only for conventional space it actually is the
> pointer where thing are written at, otherwise zone append manages
> that.
> 
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> ---
>  fs/xfs/xfs_trace.h      |  8 ++++----
>  fs/xfs/xfs_zone_alloc.c | 18 +++++++++---------
>  fs/xfs/xfs_zone_gc.c    | 13 ++++++-------
>  fs/xfs/xfs_zone_info.c  |  2 +-
>  fs/xfs/xfs_zone_priv.h  | 16 ++++++++--------
>  5 files changed, 28 insertions(+), 29 deletions(-)
> 
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index 6addebd764b0..10d4fd671dcf 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -425,8 +425,8 @@ DECLARE_EVENT_CLASS(xfs_zone_alloc_class,
>  		__field(dev_t, dev)
>  		__field(xfs_rgnumber_t, rgno)
>  		__field(xfs_rgblock_t, used)
> +		__field(xfs_rgblock_t, allocated)
>  		__field(xfs_rgblock_t, written)
> -		__field(xfs_rgblock_t, write_pointer)
>  		__field(xfs_rgblock_t, rgbno)
>  		__field(xfs_extlen_t, len)
>  	),
> @@ -434,17 +434,17 @@ DECLARE_EVENT_CLASS(xfs_zone_alloc_class,
>  		__entry->dev = rtg_mount(oz->oz_rtg)->m_super->s_dev;
>  		__entry->rgno = rtg_rgno(oz->oz_rtg);
>  		__entry->used = rtg_rmap(oz->oz_rtg)->i_used_blocks;
> +		__entry->allocated = oz->oz_allocated;
>  		__entry->written = oz->oz_written;
> -		__entry->write_pointer = oz->oz_write_pointer;
>  		__entry->rgbno = rgbno;
>  		__entry->len = len;
>  	),
> -	TP_printk("dev %d:%d rgno 0x%x used 0x%x written 0x%x wp 0x%x rgbno 0x%x len 0x%x",
> +	TP_printk("dev %d:%d rgno 0x%x used 0x%x alloced 0x%x written 0x%x rgbno 0x%x len 0x%x",

Looks fine though I'd prefer this be the full word ^^^ "allocated"

With that changed,
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>

--D

>  		  MAJOR(__entry->dev), MINOR(__entry->dev),
>  		  __entry->rgno,
>  		  __entry->used,
> +		  __entry->allocated,
>  		  __entry->written,
> -		  __entry->write_pointer,
>  		  __entry->rgbno,
>  		  __entry->len)
>  );
> diff --git a/fs/xfs/xfs_zone_alloc.c b/fs/xfs/xfs_zone_alloc.c
> index 867465b5b5fe..729d80ff52c1 100644
> --- a/fs/xfs/xfs_zone_alloc.c
> +++ b/fs/xfs/xfs_zone_alloc.c
> @@ -434,7 +434,7 @@ xfs_init_open_zone(
>  	spin_lock_init(&oz->oz_alloc_lock);
>  	atomic_set(&oz->oz_ref, 1);
>  	oz->oz_rtg = rtg;
> -	oz->oz_write_pointer = write_pointer;
> +	oz->oz_allocated = write_pointer;
>  	oz->oz_written = write_pointer;
>  	oz->oz_write_hint = write_hint;
>  	oz->oz_is_gc = is_gc;
> @@ -569,7 +569,7 @@ xfs_try_use_zone(
>  	struct xfs_open_zone	*oz,
>  	bool			lowspace)
>  {
> -	if (oz->oz_write_pointer == rtg_blocks(oz->oz_rtg))
> +	if (oz->oz_allocated == rtg_blocks(oz->oz_rtg))
>  		return false;
>  	if (!lowspace && !xfs_good_hint_match(oz, file_hint))
>  		return false;
> @@ -744,25 +744,25 @@ xfs_zone_alloc_blocks(
>  {
>  	struct xfs_rtgroup	*rtg = oz->oz_rtg;
>  	struct xfs_mount	*mp = rtg_mount(rtg);
> -	xfs_rgblock_t		rgbno;
> +	xfs_rgblock_t		allocated;
>  
>  	spin_lock(&oz->oz_alloc_lock);
>  	count_fsb = min3(count_fsb, XFS_MAX_BMBT_EXTLEN,
> -		(xfs_filblks_t)rtg_blocks(rtg) - oz->oz_write_pointer);
> +		(xfs_filblks_t)rtg_blocks(rtg) - oz->oz_allocated);
>  	if (!count_fsb) {
>  		spin_unlock(&oz->oz_alloc_lock);
>  		return 0;
>  	}
> -	rgbno = oz->oz_write_pointer;
> -	oz->oz_write_pointer += count_fsb;
> +	allocated = oz->oz_allocated;
> +	oz->oz_allocated += count_fsb;
>  	spin_unlock(&oz->oz_alloc_lock);
>  
> -	trace_xfs_zone_alloc_blocks(oz, rgbno, count_fsb);
> +	trace_xfs_zone_alloc_blocks(oz, allocated, count_fsb);
>  
>  	*sector = xfs_gbno_to_daddr(&rtg->rtg_group, 0);
>  	*is_seq = bdev_zone_is_seq(mp->m_rtdev_targp->bt_bdev, *sector);
>  	if (!*is_seq)
> -		*sector += XFS_FSB_TO_BB(mp, rgbno);
> +		*sector += XFS_FSB_TO_BB(mp, allocated);
>  	return XFS_FSB_TO_B(mp, count_fsb);
>  }
>  
> @@ -983,7 +983,7 @@ xfs_zone_rgbno_is_valid(
>  	lockdep_assert_held(&rtg_rmap(rtg)->i_lock);
>  
>  	if (rtg->rtg_open_zone)
> -		return rgbno < rtg->rtg_open_zone->oz_write_pointer;
> +		return rgbno < rtg->rtg_open_zone->oz_allocated;
>  	return !xa_get_mark(&rtg_mount(rtg)->m_groups[XG_TYPE_RTG].xa,
>  			rtg_rgno(rtg), XFS_RTG_FREE);
>  }
> diff --git a/fs/xfs/xfs_zone_gc.c b/fs/xfs/xfs_zone_gc.c
> index 9c00fc5baa30..7ea9fa77b061 100644
> --- a/fs/xfs/xfs_zone_gc.c
> +++ b/fs/xfs/xfs_zone_gc.c
> @@ -533,8 +533,7 @@ xfs_zone_gc_steal_open(
>  
>  	spin_lock(&zi->zi_open_zones_lock);
>  	list_for_each_entry(oz, &zi->zi_open_zones, oz_entry) {
> -		if (!found ||
> -		    oz->oz_write_pointer < found->oz_write_pointer)
> +		if (!found || oz->oz_allocated < found->oz_allocated)
>  			found = oz;
>  	}
>  
> @@ -584,7 +583,7 @@ xfs_zone_gc_ensure_target(
>  {
>  	struct xfs_open_zone	*oz = mp->m_zone_info->zi_open_gc_zone;
>  
> -	if (!oz || oz->oz_write_pointer == rtg_blocks(oz->oz_rtg))
> +	if (!oz || oz->oz_allocated == rtg_blocks(oz->oz_rtg))
>  		return xfs_zone_gc_select_target(mp);
>  	return oz;
>  }
> @@ -605,7 +604,7 @@ xfs_zone_gc_space_available(
>  	oz = xfs_zone_gc_ensure_target(data->mp);
>  	if (!oz)
>  		return false;
> -	return oz->oz_write_pointer < rtg_blocks(oz->oz_rtg) &&
> +	return oz->oz_allocated < rtg_blocks(oz->oz_rtg) &&
>  		xfs_zone_gc_scratch_available(data);
>  }
>  
> @@ -647,7 +646,7 @@ xfs_zone_gc_alloc_blocks(
>  	 */
>  	spin_lock(&mp->m_sb_lock);
>  	*count_fsb = min(*count_fsb,
> -			rtg_blocks(oz->oz_rtg) - oz->oz_write_pointer);
> +			rtg_blocks(oz->oz_rtg) - oz->oz_allocated);
>  	*count_fsb = min3(*count_fsb,
>  			mp->m_free[XC_FREE_RTEXTENTS].res_avail,
>  			mp->m_free[XC_FREE_RTAVAILABLE].res_avail);
> @@ -661,8 +660,8 @@ xfs_zone_gc_alloc_blocks(
>  	*daddr = xfs_gbno_to_daddr(&oz->oz_rtg->rtg_group, 0);
>  	*is_seq = bdev_zone_is_seq(mp->m_rtdev_targp->bt_bdev, *daddr);
>  	if (!*is_seq)
> -		*daddr += XFS_FSB_TO_BB(mp, oz->oz_write_pointer);
> -	oz->oz_write_pointer += *count_fsb;
> +		*daddr += XFS_FSB_TO_BB(mp, oz->oz_allocated);
> +	oz->oz_allocated += *count_fsb;
>  	atomic_inc(&oz->oz_ref);
>  	return oz;
>  }
> diff --git a/fs/xfs/xfs_zone_info.c b/fs/xfs/xfs_zone_info.c
> index 733bcc2f8645..07e30c596975 100644
> --- a/fs/xfs/xfs_zone_info.c
> +++ b/fs/xfs/xfs_zone_info.c
> @@ -32,7 +32,7 @@ xfs_show_open_zone(
>  {
>  	seq_printf(m, "\t  zone %d, wp %u, written %u, used %u, hint %s\n",
>  		rtg_rgno(oz->oz_rtg),
> -		oz->oz_write_pointer, oz->oz_written,
> +		oz->oz_allocated, oz->oz_written,
>  		rtg_rmap(oz->oz_rtg)->i_used_blocks,
>  		xfs_write_hint_to_str(oz->oz_write_hint));
>  }
> diff --git a/fs/xfs/xfs_zone_priv.h b/fs/xfs/xfs_zone_priv.h
> index ab696975a993..35e6de3d25ed 100644
> --- a/fs/xfs/xfs_zone_priv.h
> +++ b/fs/xfs/xfs_zone_priv.h
> @@ -11,18 +11,18 @@ struct xfs_open_zone {
>  	atomic_t		oz_ref;
>  
>  	/*
> -	 * oz_write_pointer is the write pointer at which space is handed out
> -	 * for conventional zones, or simple the count of blocks handed out
> -	 * so far for sequential write required zones and is protected by
> -	 * oz_alloc_lock/
> +	 * oz_allocated is the amount of space already allocated out of the zone
> +	 * and is protected by oz_alloc_lock.
> +	 *
> +	 * For conventional zones it also is the offset of the next write.
>  	 */
>  	spinlock_t		oz_alloc_lock;
> -	xfs_rgblock_t		oz_write_pointer;
> +	xfs_rgblock_t		oz_allocated;
>  
>  	/*
> -	 * oz_written is the number of blocks for which we've received a
> -	 * write completion.  oz_written must always be <= oz_write_pointer
> -	 * and is protected by the ILOCK of the rmap inode.
> +	 * oz_written is the number of blocks for which we've received a write
> +	 * completion.  oz_written must always be <= oz_allocated and is
> +	 * protected by the ILOCK of the rmap inode.
>  	 */
>  	xfs_rgblock_t		oz_written;
>  
> -- 
> 2.47.2
> 
>