Re: [PATCH v2 2/4] relayfs: introduce dump of relayfs statistics function

On Fri, May 16, 2025 at 2:19 AM Jens Axboe [off-list ref] wrote:

On 5/15/25 12:16 AM, Jason Xing wrote:

quoted

From: Jason Xing <kernelxing@tencent.com>

In this version, only support dumping the counter for buffer full and
implement the framework of how it works.

Users can pass certain flag to fetch what field/statistics they expect
to know. Each time it only returns one result. So do not pass multiple
flags.

Reviewed-by: Yushan Zhou <redacted>
Signed-off-by: Jason Xing <kernelxing@tencent.com>
---
v2
1. refactor relay_dump() and make it only return a pure size_t result
of the value that users specifies.
2. revise the commit log.
---
 include/linux/relay.h |  7 +++++++
 kernel/relay.c        | 31 +++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/include/linux/relay.h b/include/linux/relay.h
index ce7a1b396872..3fb285716e34 100644
--- a/include/linux/relay.h
+++ b/include/linux/relay.h

@@ -31,6 +31,12 @@
 /*
  * Relay buffer statistics dump
  */
+enum {
+     RELAY_DUMP_BUF_FULL = (1 << 0),
+
+     RELAY_DUMP_LAST = RELAY_DUMP_BUF_FULL,
+};
+
 struct rchan_buf_stats
 {
      unsigned int full_count;        /* counter for buffer full */

@@ -167,6 +173,7 @@ struct rchan *relay_open(const char *base_filename,
                       void *private_data);
 extern void relay_close(struct rchan *chan);
 extern void relay_flush(struct rchan *chan);
+extern size_t relay_dump(struct rchan *chan, int flags);
 extern void relay_subbufs_consumed(struct rchan *chan,
                                 unsigned int cpu,
                                 size_t consumed);

diff --git a/kernel/relay.c b/kernel/relay.c
index eb3f630f3896..f47fc750e559 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c

@@ -701,6 +701,37 @@ void relay_flush(struct rchan *chan)
 }
 EXPORT_SYMBOL_GPL(relay_flush);

+/**
+ *   relay_dump - dump channel buffer statistics
+ *   @chan: the channel
+ *   @flags: select particular information to dump
+ *
+ *   Returns the count of certain field that caller specifies.
+ */
+size_t relay_dump(struct rchan *chan, int flags)
+{
+     unsigned int i, count = 0;
+     struct rchan_buf *rbuf;
+
+     if (!chan || flags > RELAY_DUMP_LAST)
+             return 0;
+
+     if (chan->is_global) {
+             rbuf = *per_cpu_ptr(chan->buf, 0);
+             if (flags & RELAY_DUMP_BUF_FULL)
+                     count = rbuf->stats.full_count;
+     } else {
+             for_each_online_cpu(i) {
+                     if ((rbuf = *per_cpu_ptr(chan->buf, i)))
+                             if (flags & RELAY_DUMP_BUF_FULL)
+                                     count += rbuf->stats.full_count;

Kernel tends to avoid the rolled-into-one assignment and check, it's
easy to misread. This:

        rbuf = *per_cpu_ptr(chan->buf, i);
        if (rbuf && flags & RELAY_DUMP_BUF_FULL)
                count += rbuf->stats.full_count;

reads much easier. IMHO.

Agreed. Thanks. I will rewrite this part in V3 :)

Thanks,
Jason

--
Jens Axboe