xfs: export zone stats in /proc/*/mountstats

Add the per-zone life time hint and the used block distribution
for fully written zones, grouping reclaimable zones in fixed-percentage
buckets spanning 0..9%, 10..19% and full zones as 100% used as well as a
few statistics about the zone allocator and open and reclaimable zones
in /proc/*/mountstats.

This gives good insight into data fragmentation and data placement
success rate.

Signed-off-by: Hans Holmberg <hans.holmberg@wdc.com>
Co-developed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index e38838409271691e34e80a45d6dc202e869739fe..5bf501cf827172f836f718faafc1695ec8ecb979 100644 (file)
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -140,6 +140,7 @@ xfs-$(CONFIG_XFS_QUOTA)             += xfs_dquot.o \
 xfs-$(CONFIG_XFS_RT)           += xfs_rtalloc.o \
                                   xfs_zone_alloc.o \
                                   xfs_zone_gc.o \
+                                  xfs_zone_info.o \
                                   xfs_zone_space_resv.o
 
 xfs-$(CONFIG_XFS_POSIX_ACL)    += xfs_acl.o

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 47468623fdc6db00a2ab7f6667cf25805832ba7a..df384c4de192815b174affbbac7c8080adc3b50b 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1243,6 +1243,10 @@ xfs_fs_show_stats(
        struct seq_file         *m,
        struct dentry           *root)
 {
+       struct xfs_mount        *mp = XFS_M(root->d_sb);
+
+       if (xfs_has_zoned(mp) && IS_ENABLED(CONFIG_XFS_RT))
+               xfs_zoned_show_stats(m, mp);
        return 0;
 }
 

diff --git a/fs/xfs/xfs_zone_alloc.h b/fs/xfs/xfs_zone_alloc.h
index 44fa1594f73e02fcf5aa3b43fff46c2682fc88c9..94ab32826c83ba2c5c5f4fe09fec1d35dced29e8 100644 (file)
--- a/fs/xfs/xfs_zone_alloc.h
+++ b/fs/xfs/xfs_zone_alloc.h
@@ -34,6 +34,7 @@ void xfs_mark_rtg_boundary(struct iomap_ioend *ioend);
 
 uint64_t xfs_zoned_default_resblks(struct xfs_mount *mp,
                enum xfs_free_counter ctr);
+void xfs_zoned_show_stats(struct seq_file *m, struct xfs_mount *mp);
 
 #ifdef CONFIG_XFS_RT
 int xfs_mount_zones(struct xfs_mount *mp);

diff --git a/fs/xfs/xfs_zone_info.c b/fs/xfs/xfs_zone_info.c
new file mode 100644 (file)
index 0000000..689c9ac
--- /dev/null
+++ b/fs/xfs/xfs_zone_info.c
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2023-2024 Christoph Hellwig.
+ * Copyright (c) 2024, Western Digital Corporation or its affiliates.
+ */
+#include "xfs.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_mount.h"
+#include "xfs_inode.h"
+#include "xfs_rtgroup.h"
+#include "xfs_zone_alloc.h"
+#include "xfs_zone_priv.h"
+
+static const char xfs_write_hint_shorthand[6][16] = {
+       "NOT_SET", "NONE", "SHORT", "MEDIUM", "LONG", "EXTREME"};
+
+static inline const char *
+xfs_write_hint_to_str(
+       uint8_t                 write_hint)
+{
+       if (write_hint > WRITE_LIFE_EXTREME)
+               return "UNKNOWN";
+       return xfs_write_hint_shorthand[write_hint];
+}
+
+static void
+xfs_show_open_zone(
+       struct seq_file         *m,
+       struct xfs_open_zone    *oz)
+{
+       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,
+               rtg_rmap(oz->oz_rtg)->i_used_blocks,
+               xfs_write_hint_to_str(oz->oz_write_hint));
+}
+
+#define XFS_USED_BUCKETS       10
+#define XFS_USED_BUCKET_PCT    (100 / XFS_USED_BUCKETS)
+
+static unsigned int
+xfs_zone_to_bucket(
+       struct xfs_rtgroup      *rtg)
+{
+       return div_u64(rtg_rmap(rtg)->i_used_blocks * XFS_USED_BUCKETS,
+                       rtg->rtg_extents);
+}
+
+static void
+xfs_show_full_zone_used_distribution(
+       struct seq_file         *m,
+       struct xfs_mount        *mp)
+{
+       struct xfs_zone_info    *zi = mp->m_zone_info;
+       XA_STATE                (xas, &mp->m_groups[XG_TYPE_RTG].xa, 0);
+       unsigned int            buckets[XFS_USED_BUCKETS] = {0};
+       unsigned int            reclaimable = 0, full, i;
+       struct xfs_rtgroup      *rtg;
+
+       lockdep_assert_held(&zi->zi_zone_list_lock);
+
+       rcu_read_lock();
+       xas_for_each_marked(&xas, rtg, ULONG_MAX, XFS_RTG_RECLAIMABLE) {
+               buckets[xfs_zone_to_bucket(rtg)]++;
+               reclaimable++;
+       }
+       rcu_read_unlock();
+
+       for (i = 0; i < XFS_USED_BUCKETS; i++)
+               seq_printf(m, "\t  %2u..%2u%%: %u\n", i * XFS_USED_BUCKET_PCT,
+                               (i + 1) * XFS_USED_BUCKET_PCT - 1, buckets[i]);
+
+       full = mp->m_sb.sb_rgcount;
+       if (zi->zi_open_gc_zone)
+               full--;
+       full -= zi->zi_nr_open_zones;
+       full -= atomic_read(&zi->zi_nr_free_zones);
+       full -= reclaimable;
+
+       seq_printf(m, "\t     100%%: %u\n", full);
+}
+
+void
+xfs_zoned_show_stats(
+       struct seq_file         *m,
+       struct xfs_mount        *mp)
+{
+       struct xfs_zone_info    *zi = mp->m_zone_info;
+       struct xfs_open_zone    *oz;
+
+       seq_puts(m, "\n");
+
+       seq_printf(m, "\tuser free blocks: %lld\n",
+               xfs_sum_freecounter(mp, XC_FREE_RTEXTENTS));
+       seq_printf(m, "\treserved free blocks: %lld\n",
+               mp->m_resblks[XC_FREE_RTEXTENTS].avail);
+       seq_printf(m, "\tuser available blocks: %lld\n",
+               xfs_sum_freecounter(mp, XC_FREE_RTAVAILABLE));
+       seq_printf(m, "\treserved available blocks: %lld\n",
+               mp->m_resblks[XC_FREE_RTAVAILABLE].avail);
+       seq_printf(m, "\treservations required: %d\n",
+               !list_empty_careful(&zi->zi_reclaim_reservations));
+       seq_printf(m, "\tGC required: %d\n",
+               xfs_zoned_need_gc(mp));
+
+       spin_lock(&zi->zi_zone_list_lock);
+       seq_printf(m, "\tfree zones: %d\n", atomic_read(&zi->zi_nr_free_zones));
+       seq_puts(m, "\topen zones:\n");
+       list_for_each_entry(oz, &zi->zi_open_zones, oz_entry)
+               xfs_show_open_zone(m, oz);
+       if (zi->zi_open_gc_zone) {
+               seq_puts(m, "\topen gc zone:\n");
+               xfs_show_open_zone(m, zi->zi_open_gc_zone);
+       }
+       seq_puts(m, "\tused blocks distribution (fully written zones):\n");
+       xfs_show_full_zone_used_distribution(m, mp);
+       spin_unlock(&zi->zi_zone_list_lock);
+}