netfs: Gather stats

Gather statistics from the netfs interface that can be exported through a
seqfile.  This is intended to be called by a later patch when viewing
/proc/fs/fscache/stats.

Signed-off-by: David Howells <dhowells@redhat.com>
Reviewed-and-tested-by: Jeff Layton <jlayton@kernel.org>
Tested-by: Dave Wysochanski <dwysocha@redhat.com>
Tested-By: Marc Dionne <marc.dionne@auristor.com>
cc: Matthew Wilcox <willy@infradead.org>
cc: linux-mm@kvack.org
cc: linux-cachefs@redhat.com
cc: linux-afs@lists.infradead.org
cc: linux-nfs@vger.kernel.org
cc: linux-cifs@vger.kernel.org
cc: ceph-devel@vger.kernel.org
cc: v9fs-developer@lists.sourceforge.net
cc: linux-fsdevel@vger.kernel.org
Link: https://lore.kernel.org/r/161118139247.1232039.10556850937548511068.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161161034669.2537118.2761232524997091480.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161340397101.1303470.17581910581108378458.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161539539959.286939.6794352576462965914.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161653797700.2770958.5801990354413178228.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161789079281.6155.17141344853277186500.stgit@warthog.procyon.org.uk/

diff --git a/fs/netfs/Kconfig b/fs/netfs/Kconfig
index 2ebf90e6ca9593e21839a1becc3d45ce7876fb1c..578112713703b92b7cbfe578bdac9c4a374ec4ed 100644 (file)
--- a/fs/netfs/Kconfig
+++ b/fs/netfs/Kconfig
@@ -6,3 +6,18 @@ config NETFS_SUPPORT
          This option enables support for network filesystems, including
          helpers for high-level buffered I/O, abstracting out read
          segmentation, local caching and transparent huge page support.
+
+config NETFS_STATS
+       bool "Gather statistical information on local caching"
+       depends on NETFS_SUPPORT && PROC_FS
+       help
+         This option causes statistical information to be gathered on local
+         caching and exported through file:
+
+               /proc/fs/fscache/stats
+
+         The gathering of statistics adds a certain amount of overhead to
+         execution as there are a quite a few stats gathered, and on a
+         multi-CPU system these may be on cachelines that keep bouncing
+         between CPUs.  On the other hand, the stats are very useful for
+         debugging purposes.  Saying 'Y' here is recommended.

diff --git a/fs/netfs/Makefile b/fs/netfs/Makefile
index 4b4eff2ba369dff491de0c8873e11b9911e56564..c15bfc966d96db7494783d374113544ca7fc7d37 100644 (file)
--- a/fs/netfs/Makefile
+++ b/fs/netfs/Makefile
@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0
 
-netfs-y := \
-       read_helper.o
+netfs-y := read_helper.o stats.o
 
 obj-$(CONFIG_NETFS_SUPPORT) := netfs.o

diff --git a/fs/netfs/internal.h b/fs/netfs/internal.h
index ee665c0e7dc80f21f31e40bd34a9e574f0d6684b..98b6f4516da1c1e4e1fc048b10c8e47d94aa3812 100644 (file)
--- a/fs/netfs/internal.h
+++ b/fs/netfs/internal.h
@@ -16,8 +16,42 @@
  */
 extern unsigned int netfs_debug;
 
+/*
+ * stats.c
+ */
+#ifdef CONFIG_NETFS_STATS
+extern atomic_t netfs_n_rh_readahead;
+extern atomic_t netfs_n_rh_readpage;
+extern atomic_t netfs_n_rh_rreq;
+extern atomic_t netfs_n_rh_sreq;
+extern atomic_t netfs_n_rh_download;
+extern atomic_t netfs_n_rh_download_done;
+extern atomic_t netfs_n_rh_download_failed;
+extern atomic_t netfs_n_rh_download_instead;
+extern atomic_t netfs_n_rh_read;
+extern atomic_t netfs_n_rh_read_done;
+extern atomic_t netfs_n_rh_read_failed;
+extern atomic_t netfs_n_rh_zero;
+extern atomic_t netfs_n_rh_short_read;
+extern atomic_t netfs_n_rh_write;
+extern atomic_t netfs_n_rh_write_done;
+extern atomic_t netfs_n_rh_write_failed;
+
+
+static inline void netfs_stat(atomic_t *stat)
+{
+       atomic_inc(stat);
+}
+
+static inline void netfs_stat_d(atomic_t *stat)
+{
+       atomic_dec(stat);
+}
+
+#else
 #define netfs_stat(x) do {} while(0)
 #define netfs_stat_d(x) do {} while(0)
+#endif
 
 /*****************************************************************************/
 /*

diff --git a/fs/netfs/read_helper.c b/fs/netfs/read_helper.c
index 799eee7f4ee6f87bbc8c548eb87a377a3d4fc006..6d6ed30f417e04a87ab26e19c53c2d8575e3978b 100644 (file)
--- a/fs/netfs/read_helper.c
+++ b/fs/netfs/read_helper.c
@@ -56,6 +56,7 @@ static struct netfs_read_request *netfs_alloc_read_request(
                refcount_set(&rreq->usage, 1);
                __set_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags);
                ops->init_rreq(rreq, file);
+               netfs_stat(&netfs_n_rh_rreq);
        }
 
        return rreq;
@@ -88,6 +89,7 @@ static void netfs_free_read_request(struct work_struct *work)
                rreq->netfs_ops->cleanup(rreq->mapping, rreq->netfs_priv);
        trace_netfs_rreq(rreq, netfs_rreq_trace_free);
        kfree(rreq);
+       netfs_stat_d(&netfs_n_rh_rreq);
 }
 
 static void netfs_put_read_request(struct netfs_read_request *rreq, bool was_async)
@@ -117,6 +119,7 @@ static struct netfs_read_subrequest *netfs_alloc_subrequest(
                refcount_set(&subreq->usage, 2);
                subreq->rreq = rreq;
                netfs_get_read_request(rreq);
+               netfs_stat(&netfs_n_rh_sreq);
        }
 
        return subreq;
@@ -134,6 +137,7 @@ static void __netfs_put_subrequest(struct netfs_read_subrequest *subreq,
 
        trace_netfs_sreq(subreq, netfs_sreq_trace_free);
        kfree(subreq);
+       netfs_stat_d(&netfs_n_rh_sreq);
        netfs_put_read_request(rreq, was_async);
 }
 
@@ -156,6 +160,7 @@ static void netfs_clear_unread(struct netfs_read_subrequest *subreq)
 static void netfs_fill_with_zeroes(struct netfs_read_request *rreq,
                                   struct netfs_read_subrequest *subreq)
 {
+       netfs_stat(&netfs_n_rh_zero);
        __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
        netfs_subreq_terminated(subreq, 0, false);
 }
@@ -179,6 +184,7 @@ static void netfs_fill_with_zeroes(struct netfs_read_request *rreq,
 static void netfs_read_from_server(struct netfs_read_request *rreq,
                                   struct netfs_read_subrequest *subreq)
 {
+       netfs_stat(&netfs_n_rh_download);
        rreq->netfs_ops->issue_op(subreq);
 }
 
@@ -288,6 +294,7 @@ static void netfs_rreq_short_read(struct netfs_read_request *rreq,
        __clear_bit(NETFS_SREQ_SHORT_READ, &subreq->flags);
        __set_bit(NETFS_SREQ_SEEK_DATA_READ, &subreq->flags);
 
+       netfs_stat(&netfs_n_rh_short_read);
        trace_netfs_sreq(subreq, netfs_sreq_trace_resubmit_short);
 
        netfs_get_read_subrequest(subreq);
@@ -319,6 +326,7 @@ static bool netfs_rreq_perform_resubmissions(struct netfs_read_request *rreq)
                                break;
                        subreq->source = NETFS_DOWNLOAD_FROM_SERVER;
                        subreq->error = 0;
+                       netfs_stat(&netfs_n_rh_download_instead);
                        trace_netfs_sreq(subreq, netfs_sreq_trace_download_instead);
                        netfs_get_read_subrequest(subreq);
                        atomic_inc(&rreq->nr_rd_ops);
@@ -414,6 +422,17 @@ void netfs_subreq_terminated(struct netfs_read_subrequest *subreq,
               subreq->debug_index, subreq->start, subreq->flags,
               transferred_or_error);
 
+       switch (subreq->source) {
+       case NETFS_READ_FROM_CACHE:
+               netfs_stat(&netfs_n_rh_read_done);
+               break;
+       case NETFS_DOWNLOAD_FROM_SERVER:
+               netfs_stat(&netfs_n_rh_download_done);
+               break;
+       default:
+               break;
+       }
+
        if (IS_ERR_VALUE(transferred_or_error)) {
                subreq->error = transferred_or_error;
                goto failed;
@@ -470,8 +489,10 @@ incomplete:
 
 failed:
        if (subreq->source == NETFS_READ_FROM_CACHE) {
+               netfs_stat(&netfs_n_rh_read_failed);
                set_bit(NETFS_RREQ_INCOMPLETE_IO, &rreq->flags);
        } else {
+               netfs_stat(&netfs_n_rh_download_failed);
                set_bit(NETFS_RREQ_FAILED, &rreq->flags);
                rreq->error = subreq->error;
        }
@@ -653,6 +674,7 @@ void netfs_readahead(struct readahead_control *ractl,
        rreq->start     = readahead_pos(ractl);
        rreq->len       = readahead_length(ractl);
 
+       netfs_stat(&netfs_n_rh_readahead);
        trace_netfs_read(rreq, readahead_pos(ractl), readahead_length(ractl),
                         netfs_read_trace_readahead);
 
@@ -722,6 +744,7 @@ int netfs_readpage(struct file *file,
        rreq->start     = page_index(page) * PAGE_SIZE;
        rreq->len       = thp_size(page);
 
+       netfs_stat(&netfs_n_rh_readpage);
        trace_netfs_read(rreq, rreq->start, rreq->len, netfs_read_trace_readpage);
 
        netfs_get_read_request(rreq);

diff --git a/fs/netfs/stats.c b/fs/netfs/stats.c
new file mode 100644 (file)
index 0000000..df6ff57
--- /dev/null
+++ b/fs/netfs/stats.c
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Netfs support statistics
+ *
+ * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#include <linux/export.h>
+#include <linux/seq_file.h>
+#include <linux/netfs.h>
+#include "internal.h"
+
+atomic_t netfs_n_rh_readahead;
+atomic_t netfs_n_rh_readpage;
+atomic_t netfs_n_rh_rreq;
+atomic_t netfs_n_rh_sreq;
+atomic_t netfs_n_rh_download;
+atomic_t netfs_n_rh_download_done;
+atomic_t netfs_n_rh_download_failed;
+atomic_t netfs_n_rh_download_instead;
+atomic_t netfs_n_rh_read;
+atomic_t netfs_n_rh_read_done;
+atomic_t netfs_n_rh_read_failed;
+atomic_t netfs_n_rh_zero;
+atomic_t netfs_n_rh_short_read;
+atomic_t netfs_n_rh_write;
+atomic_t netfs_n_rh_write_done;
+atomic_t netfs_n_rh_write_failed;
+
+void netfs_stats_show(struct seq_file *m)
+{
+       seq_printf(m, "RdHelp : RA=%u RP=%u rr=%u sr=%u\n",
+                  atomic_read(&netfs_n_rh_readahead),
+                  atomic_read(&netfs_n_rh_readpage),
+                  atomic_read(&netfs_n_rh_rreq),
+                  atomic_read(&netfs_n_rh_sreq));
+       seq_printf(m, "RdHelp : ZR=%u sh=%u\n",
+                  atomic_read(&netfs_n_rh_zero),
+                  atomic_read(&netfs_n_rh_short_read));
+       seq_printf(m, "RdHelp : DL=%u ds=%u df=%u di=%u\n",
+                  atomic_read(&netfs_n_rh_download),
+                  atomic_read(&netfs_n_rh_download_done),
+                  atomic_read(&netfs_n_rh_download_failed),
+                  atomic_read(&netfs_n_rh_download_instead));
+       seq_printf(m, "RdHelp : RD=%u rs=%u rf=%u\n",
+                  atomic_read(&netfs_n_rh_read),
+                  atomic_read(&netfs_n_rh_read_done),
+                  atomic_read(&netfs_n_rh_read_failed));
+       seq_printf(m, "RdHelp : WR=%u ws=%u wf=%u\n",
+                  atomic_read(&netfs_n_rh_write),
+                  atomic_read(&netfs_n_rh_write_done),
+                  atomic_read(&netfs_n_rh_write_failed));
+}
+EXPORT_SYMBOL(netfs_stats_show);

diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index 8e8c6a4e4ddef044a501a6301e40d82cb62c34fa..db4af80cbae3cd4eebc49cf2c4d15385bcb027c3 100644 (file)
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -166,5 +166,6 @@ extern int netfs_readpage(struct file *,
                          void *);
 
 extern void netfs_subreq_terminated(struct netfs_read_subrequest *, ssize_t, bool);
+extern void netfs_stats_show(struct seq_file *);
 
 #endif /* _LINUX_NETFS_H */