netfs: Add retry stat counters

Add stat counters to count the number of request and subrequest retries and
display them in /proc/fs/netfs/stats.

Signed-off-by: David Howells <dhowells@redhat.com>
Link: https://lore.kernel.org/r/20250212222402.3618494-3-dhowells@redhat.com
cc: Jeff Layton <jlayton@kernel.org>
cc: netfs@lists.linux.dev
cc: linux-fsdevel@vger.kernel.org
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/netfs/internal.h b/fs/netfs/internal.h
index eb76f98c894bb046ff110b4e09dbdfb6a6faa6ba..1c4f953c3d683b73694a48f36316d0b03e928b3f 100644 (file)
--- a/fs/netfs/internal.h
+++ b/fs/netfs/internal.h
@@ -135,6 +135,8 @@ extern atomic_t netfs_n_rh_write_begin;
 extern atomic_t netfs_n_rh_write_done;
 extern atomic_t netfs_n_rh_write_failed;
 extern atomic_t netfs_n_rh_write_zskip;
+extern atomic_t netfs_n_rh_retry_read_req;
+extern atomic_t netfs_n_rh_retry_read_subreq;
 extern atomic_t netfs_n_wh_buffered_write;
 extern atomic_t netfs_n_wh_writethrough;
 extern atomic_t netfs_n_wh_dio_write;
@@ -147,6 +149,8 @@ extern atomic_t netfs_n_wh_upload_failed;
 extern atomic_t netfs_n_wh_write;
 extern atomic_t netfs_n_wh_write_done;
 extern atomic_t netfs_n_wh_write_failed;
+extern atomic_t netfs_n_wh_retry_write_req;
+extern atomic_t netfs_n_wh_retry_write_subreq;
 extern atomic_t netfs_n_wb_lock_skip;
 extern atomic_t netfs_n_wb_lock_wait;
 extern atomic_t netfs_n_folioq;

diff --git a/fs/netfs/read_retry.c b/fs/netfs/read_retry.c
index 8316c4533a51d7b1e30de9830f2cf2ad175a461d..0f294b26e08c9624b4832c61ee4cf47f3373b90b 100644 (file)
--- a/fs/netfs/read_retry.c
+++ b/fs/netfs/read_retry.c
@@ -14,6 +14,7 @@ static void netfs_reissue_read(struct netfs_io_request *rreq,
 {
        __clear_bit(NETFS_SREQ_MADE_PROGRESS, &subreq->flags);
        __set_bit(NETFS_SREQ_IN_PROGRESS, &subreq->flags);
+       netfs_stat(&netfs_n_rh_retry_read_subreq);
        subreq->rreq->netfs_ops->issue_read(subreq);
 }
 
@@ -260,6 +261,8 @@ void netfs_retry_reads(struct netfs_io_request *rreq)
        struct netfs_io_stream *stream = &rreq->io_streams[0];
        DEFINE_WAIT(myself);
 
+       netfs_stat(&netfs_n_rh_retry_read_req);
+
        set_bit(NETFS_RREQ_RETRYING, &rreq->flags);
 
        /* Wait for all outstanding I/O to quiesce before performing retries as

diff --git a/fs/netfs/stats.c b/fs/netfs/stats.c
index f1af344266cc6aa58c5fcf7ff0f6ffe8b751f4ff..ab6b916addc4432ea9cbe7aa98140cbf0d91f20e 100644 (file)
--- a/fs/netfs/stats.c
+++ b/fs/netfs/stats.c
@@ -29,6 +29,8 @@ atomic_t netfs_n_rh_write_begin;
 atomic_t netfs_n_rh_write_done;
 atomic_t netfs_n_rh_write_failed;
 atomic_t netfs_n_rh_write_zskip;
+atomic_t netfs_n_rh_retry_read_req;
+atomic_t netfs_n_rh_retry_read_subreq;
 atomic_t netfs_n_wh_buffered_write;
 atomic_t netfs_n_wh_writethrough;
 atomic_t netfs_n_wh_dio_write;
@@ -41,6 +43,8 @@ atomic_t netfs_n_wh_upload_failed;
 atomic_t netfs_n_wh_write;
 atomic_t netfs_n_wh_write_done;
 atomic_t netfs_n_wh_write_failed;
+atomic_t netfs_n_wh_retry_write_req;
+atomic_t netfs_n_wh_retry_write_subreq;
 atomic_t netfs_n_wb_lock_skip;
 atomic_t netfs_n_wb_lock_wait;
 atomic_t netfs_n_folioq;
@@ -81,6 +85,11 @@ int netfs_stats_show(struct seq_file *m, void *v)
                   atomic_read(&netfs_n_wh_write),
                   atomic_read(&netfs_n_wh_write_done),
                   atomic_read(&netfs_n_wh_write_failed));
+       seq_printf(m, "Retries: rq=%u rs=%u wq=%u ws=%u\n",
+                  atomic_read(&netfs_n_rh_retry_read_req),
+                  atomic_read(&netfs_n_rh_retry_read_subreq),
+                  atomic_read(&netfs_n_wh_retry_write_req),
+                  atomic_read(&netfs_n_wh_retry_write_subreq));
        seq_printf(m, "Objs   : rr=%u sr=%u foq=%u wsc=%u\n",
                   atomic_read(&netfs_n_rh_rreq),
                   atomic_read(&netfs_n_rh_sreq),

diff --git a/fs/netfs/write_issue.c b/fs/netfs/write_issue.c
index 69727411683ef3491aa4e438d36da23b17b4e258..77279fc5b5a7cbb96828526f01b2986b0f118af8 100644 (file)
--- a/fs/netfs/write_issue.c
+++ b/fs/netfs/write_issue.c
@@ -253,6 +253,7 @@ void netfs_reissue_write(struct netfs_io_stream *stream,
        subreq->retry_count++;
        __clear_bit(NETFS_SREQ_MADE_PROGRESS, &subreq->flags);
        __set_bit(NETFS_SREQ_IN_PROGRESS, &subreq->flags);
+       netfs_stat(&netfs_n_wh_retry_write_subreq);
        netfs_do_issue_write(stream, subreq);
 }
 

diff --git a/fs/netfs/write_retry.c b/fs/netfs/write_retry.c
index c841a851dd73ba7bdc6642cd2416904b2d3dbe07..545d33079a77d0d5a242ec0e1a694dfac8e7eceb 100644 (file)
--- a/fs/netfs/write_retry.c
+++ b/fs/netfs/write_retry.c
@@ -203,6 +203,8 @@ void netfs_retry_writes(struct netfs_io_request *wreq)
        struct netfs_io_stream *stream;
        int s;
 
+       netfs_stat(&netfs_n_wh_retry_write_req);
+
        /* Wait for all outstanding I/O to quiesce before performing retries as
         * we may need to renegotiate the I/O sizes.
         */