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@xxxxxx>
> ---
> 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@xxxxxxxxxx>
--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
>
>
