From nobody Thu Jun 11 05:14:01 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C314A3AEF58; Tue, 9 Jun 2026 16:16:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021763; cv=none; b=TgG5mz7MJ4cjYXmVObSlmoDHh+Y0xfoPNp2o8mFq+/hnaDKk/JqezwfurYOE00VB+nWQXR6dXOUJAcwAG+VdIOFGJNuD4DY6ETskW0CYeJeHI8KN4d6+ku2P25s2LAGMrdv6C8RWk091Apz/WLsIqLssv7dt9n0o/mNvcaVmapw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021763; c=relaxed/simple; bh=gPdb5PUAM0BrK0h035CNZn7Y2sMbtCb/Yg/pqJKIr1Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=iE65QgbSkAD/BZvDBryRPMW43grJJkgJZoS+l8YJSlO2rRW2BZGluJDOia0vpAwe1ZrJD/CnPszuPcbvziNK9+vjaYV8M6qZt7vHFp3b0e4cKnw4h0x/SeKX+ItuBbxWD03eU6jr2jfNZ1SqbrzN9vRj12OIO7zVr1RyTiJqaj4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CoKaWt4r; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="CoKaWt4r" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 818061F00893; Tue, 9 Jun 2026 16:16:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781021762; bh=fytm80oB2xd9RMPARuKQ+D3B+SOn9ysuLpBxELajWi0=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=CoKaWt4rGvfKOrEdz3Hp2SHQwJNZuaijQd4CDS5t+fREvv6fbHK3k+p47LVJgu4yF iUrHO3Ga2S8yDZmMZEGBTKhADr2B9tPcrhXy9jTp4YAjOA2sO0oHNlxAYX3ovncxm+ KH3hr6oSDCYIvHJPpBDSgWnFvK/7vIs9MxJVWuTAaGW3OH7OAtnwaHWZ1kl3M3ovfX ZQXAGAu6WlNNhV+d1kcbsk9IXAO2k3tgcQbBv2pEBMGwRJROZIFQjDZCeAiTPMtIEY A0OBpVlXq0q3gTSO5NC01FD6Q+Y00Ob7ISyaK3I1+EkiNiO7LH7O5oNtSM+3yu3i7g dFsprYgKy7S6Q== From: Jeff Layton Date: Tue, 09 Jun 2026 12:15:54 -0400 Subject: [PATCH v3 1/4] sunrpc: add per-netns per-procedure call counts to svc_stat Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260609-exportd-netlink-v3-1-aa5508a5bb1d@kernel.org> References: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> In-Reply-To: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey Cc: Trond Myklebust , Anna Schumaker , Steve Dickson , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=5361; i=jlayton@kernel.org; h=from:subject:message-id; bh=gPdb5PUAM0BrK0h035CNZn7Y2sMbtCb/Yg/pqJKIr1Q=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqKDw/RNF5b3LqP8YrkHkUAZBGifnnjm5l3vMp0 EGTQ+7Hh9qJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCaig8PwAKCRAADmhBGVaC FUyMD/4kx0KsnzRKg0Pm7CBb/heJ01VAVWLiVUyOslgcESOuDDF3VrR6k9GFTkEYVPy+UVi5YaY sYxQDu4r+Ls2h62Pebv+N3ZVK3N1A3tNQOpkNz3tkzTgOb+r1EN+BhKhMwgFw70FHj49RjA8Nej lukgbzZnWqE5gyjHyLYF3XDcR7akpQKg2XGraiDV4nKkR5g2ddbQsAEVh/s+1ysFu6jJzJ8F22n nIAuIAC9yQHDXG81NhG1RDyU9vGbH/DNKpcYiKNN3/W5+KIf71HWvBwb6icCW19q+qgb8uJZUjE kUeALlKOlJOmRUoj/+cjHs+aBPrpkAHJUnbyeWM+7VskWbH9l9Fmm/D0XF48AqCQwfapSqFQ6ir 9g2y3587PmjFBMHuOhYbuqhASlJfsToV/GWAw0WCYfcQTR/nuGYUR7GZA0y7EevoYeLuc0ly3Y/ BSqV0nmhvAanBUksfppEr+hn0PZIBabkY1DKPVHRys63/7I1iDjxLDEbvgq7JFsJZqGtAccVyyr rsxJoqmBvctP4bGZrG5/8vjRBBtzKAS8KNdQ3JUWFc9gvJkcU+KOqkN4KXUrFHCAaV6opPpqN+U sNHzyg9SSPVbkyR4LndO/ju2d6odevPMPUHa87ix7bu5UQlVs1Eu3LeGcvmybh093jHZM03DTC+ N1sIVjmH7iWAGTw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 The existing per-procedure call counts live in global svc_version->vs_count[] arrays which are not network-namespace-aware. Add per-netns equivalents in struct svc_stat so the upcoming netlink stats interface can return namespace-scoped statistics. Add a vs_count pointer array to struct svc_stat, along with svc_stat_alloc_counts() and svc_stat_free_counts() helpers to manage per-version percpu call count arrays. Increment the per-net counter alongside the global one in svc_generic_init_request(). Call the alloc/free helpers from nfsd_net_init() and nfsd_net_exit(). Assisted-by: Claude:claude-opus-4-6 Signed-off-by: Jeff Layton --- fs/nfsd/nfsctl.c | 8 ++++++- include/linux/sunrpc/stats.h | 6 +++++ net/sunrpc/stats.c | 54 ++++++++++++++++++++++++++++++++++++++++= ++++ net/sunrpc/svc.c | 8 +++++++ 4 files changed, 75 insertions(+), 1 deletion(-) diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index c06d25c06f06..7b802d335501 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -2436,9 +2436,12 @@ static __net_init int nfsd_net_init(struct net *net) =20 memset(&nn->nfsd_svcstats, 0, sizeof(nn->nfsd_svcstats)); nn->nfsd_svcstats.program =3D &nfsd_programs[0]; + retval =3D svc_stat_alloc_counts(&nn->nfsd_svcstats); + if (retval) + goto out_proc_error; if (!nfsd_proc_stat_init(net)) { retval =3D -ENOMEM; - goto out_proc_error; + goto out_svcstats_error; } =20 for (i =3D 0; i < sizeof(nn->nfsd_versions); i++) @@ -2456,6 +2459,8 @@ static __net_init int nfsd_net_init(struct net *net) #endif return 0; =20 +out_svcstats_error: + svc_stat_free_counts(&nn->nfsd_svcstats); out_proc_error: percpu_counter_destroy_many(nn->counter, NFSD_STATS_COUNTERS_NUM); out_repcache_error: @@ -2496,6 +2501,7 @@ static __net_exit void nfsd_net_exit(struct net *net) kfree_sensitive(nn->fh_key); nfsd_net_cb_shutdown(nn); nfsd_proc_stat_shutdown(net); + svc_stat_free_counts(&nn->nfsd_svcstats); percpu_counter_destroy_many(nn->counter, NFSD_STATS_COUNTERS_NUM); nfsd_idmap_shutdown(net); nfsd_export_shutdown(net); diff --git a/include/linux/sunrpc/stats.h b/include/linux/sunrpc/stats.h index 3ce1550d1beb..087ade905e29 100644 --- a/include/linux/sunrpc/stats.h +++ b/include/linux/sunrpc/stats.h @@ -37,9 +37,15 @@ struct svc_stat { rpcbadfmt, rpcbadauth, rpcbadclnt; + + /* Per-version per-procedure call counts (per-cpu, per-netns) */ + unsigned long __percpu **vs_count; }; =20 struct net; +int svc_stat_alloc_counts(struct svc_stat *statp); +void svc_stat_free_counts(struct svc_stat *statp); + #ifdef CONFIG_PROC_FS int rpc_proc_init(struct net *); void rpc_proc_exit(struct net *); diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c index 7093e18ac26c..5bcecd2919b1 100644 --- a/net/sunrpc/stats.c +++ b/net/sunrpc/stats.c @@ -116,6 +116,60 @@ void svc_seq_show(struct seq_file *seq, const struct s= vc_stat *statp) } EXPORT_SYMBOL_GPL(svc_seq_show); =20 +/** + * svc_stat_alloc_counts - allocate per-netns per-version call count arrays + * @statp: svc_stat whose vs_count arrays should be allocated + * + * statp->program must be set before calling this. + * + * Returns zero on success, or a negative errno otherwise. + */ +int svc_stat_alloc_counts(struct svc_stat *statp) +{ + struct svc_program *prog =3D statp->program; + unsigned int i; + + statp->vs_count =3D kcalloc(prog->pg_nvers, + sizeof(unsigned long __percpu *), + GFP_KERNEL); + if (!statp->vs_count) + return -ENOMEM; + + for (i =3D 0; i < prog->pg_nvers; i++) { + if (!prog->pg_vers[i]) + continue; + statp->vs_count[i] =3D __alloc_percpu(prog->pg_vers[i]->vs_nproc * + sizeof(unsigned long), + sizeof(unsigned long)); + if (!statp->vs_count[i]) + goto err; + } + return 0; +err: + svc_stat_free_counts(statp); + return -ENOMEM; +} +EXPORT_SYMBOL_GPL(svc_stat_alloc_counts); + +/** + * svc_stat_free_counts - free per-netns per-version call count arrays + * @statp: svc_stat whose vs_count arrays should be freed + */ +void svc_stat_free_counts(struct svc_stat *statp) +{ + struct svc_program *prog =3D statp->program; + unsigned int i; + + if (!statp->vs_count) + return; + + for (i =3D 0; i < prog->pg_nvers; i++) + free_percpu(statp->vs_count[i]); + kfree(statp->vs_count); + statp->vs_count =3D NULL; +} +EXPORT_SYMBOL_GPL(svc_stat_free_counts); + /** * rpc_alloc_iostats - allocate an rpc_iostats structure * @clnt: RPC program, version, and xprt diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c index 009373737ea9..200b57e633dd 100644 --- a/net/sunrpc/svc.c +++ b/net/sunrpc/svc.c @@ -1408,6 +1408,14 @@ svc_generic_init_request(struct svc_rqst *rqstp, /* Bump per-procedure stats counter */ this_cpu_inc(versp->vs_count[rqstp->rq_proc]); =20 + /* Bump per-net per-procedure stats counter */ + if (rqstp->rq_server->sv_stats && + rqstp->rq_server->sv_stats->program =3D=3D progp && + rqstp->rq_server->sv_stats->vs_count && + rqstp->rq_server->sv_stats->vs_count[rqstp->rq_vers]) + this_cpu_inc(rqstp->rq_server->sv_stats->vs_count + [rqstp->rq_vers][rqstp->rq_proc]); + ret->dispatch =3D versp->vs_dispatch; return rpc_success; err_bad_vers: --=20 2.54.0 From nobody Thu Jun 11 05:14:01 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BA6053AFCFE; Tue, 9 Jun 2026 16:16:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021764; cv=none; b=lljlrjPWzI+P9XOsURg3sDCSIhMgk22Ct7AIv0Nwc2/mKnkg2KIykBzMOF2ScK5BT2WcWaTvHLfTJAaIwlpvBx1Gv7IC7gFUqAeFNm1LIKg7ul/2XuzNVpAdHSjyJ9XYiKGZTRDuD+bTNa8f8aB45+0smx6UbJbV3TyomvyBxTU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021764; c=relaxed/simple; bh=0DyK6gpsbXEKdN+zvODLIFmNbG9l/JlTuIMh+Vp/ZCY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=q95e89BUKKU0uUCeWVn1mdtegdJgddwOpaiOWs0bg2Kjt2afHmC+PoD3QIZJGYA2Md05XRkbsDH/E9dik1YdfFpMOV6pvo74sc2P92lG8d3+p1N+aMiFlaHfBgvCJsTgzVOvwuiYYFyvV6aSPK7kYCtCYmbXcl7RkXnRwikbNMk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Vryh6vZV; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Vryh6vZV" Received: by smtp.kernel.org (Postfix) with ESMTPSA id AEFC91F00898; Tue, 9 Jun 2026 16:16:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781021763; bh=7GUrlKj+2ZTyBVhmXbHZ9ccQ+KlfhqvBRavl7nGi83A=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=Vryh6vZVsKmtPWGRxZCb+u8uN398fKPn8BeyU113+fipGstuQvck+vhYz1XAP9nM7 RpALzBBu//5yG1KV/EZBRfVeajqoOB1O1H4SKRRNm60VXwiReUBYGVZX5dkqMNoHFy uPEOj6gsZe0afnZlcRojC0+YWPThDpjXDfO4s9QvdZjlgd7RRJvNIAtpQErbhvdx/C XR/T1cSIqEqZPV9FzS0FU2brxIgo7IwWJheJ9ox7GFxgephI7KyY3MDsA781MJwrrR WBdOpQ5dECAjx3n2vHAQVbRdrp/YyI0jdOHfXGS0InD4mitu1LvvtAVLzY/q1+JWW1 YZrVOe0xik9dQ== From: Jeff Layton Date: Tue, 09 Jun 2026 12:15:55 -0400 Subject: [PATCH v3 2/4] sunrpc: use per-net counts in svc_seq_show() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260609-exportd-netlink-v3-2-aa5508a5bb1d@kernel.org> References: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> In-Reply-To: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey Cc: Trond Myklebust , Anna Schumaker , Steve Dickson , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=1043; i=jlayton@kernel.org; h=from:subject:message-id; bh=0DyK6gpsbXEKdN+zvODLIFmNbG9l/JlTuIMh+Vp/ZCY=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqKDw/TZxo+xPVoj/fG58mKcAEfXoVfS4VGzjQR 4A2hPGN2u6JAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCaig8PwAKCRAADmhBGVaC FfZWD/4uh7uGaZkWd8YhQ5QVWgH71guErFduJc29ECSNXNcpBQtQZL5d8YrfzjdZ0wfUq43W8h1 B77pGEn4ekjxjLsd4F1bRnbK//2CXSHDh5Th/1pcSwYRULbc9JNe+Y/iqBWMr0sxzoaoI/eGbkA Hw3oxjSg23U5dqByrO72PyswjbJAm+2rUrtB+Uo0U5IRpo8kLcGGD6zDJY2pWOWt5eWyFiR/O0W Eqf/fARqe3JiB2rZ6xlnlNEadKViywhvAOjjQwEaHmdXgE9qLtWNRKVvInqvGgVxCikkuVIt501 1Y/gPVxI3lMhwbXY1wEVDcl2LuNiCZqJ9+y+eufn52En+ZAwvEcOrFgzPO+7MKytQCpKgzw1/XP DMmYZrugxS6hT+O/5hEHmiizcyfuwTwUuhaRiuX370CjVdZAnOUH758V8MzXUjmtU9m3jKINW4O dxfK/7jFmSdZddkmu3m7pb9EHkGBPjMV4DQu58jfQFqvycKwjmalLRSWYBY2GUSTynEPvw74DZ4 G7HAGjo1F1jsJO0EbRDIDUXrQFCPIU//HCM6ucu01npmOhbd3cpxMsenj9qv9ZT4eZCZAr51YyI a7HvlmxU+kUqo01RuWPKRZsce67b6fE23e0JBmQvrYzoIpFl77oQOj2PmN0U5rXK7Voy+69QRZ+ w4TPrKBArCdUXXw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Update svc_seq_show() to read from the per-netns statp->vs_count[] arrays instead of the global svc_version->vs_count[]. The only caller is nfsd, which always allocates vs_count via svc_stat_alloc_counts() in nfsd_net_init(), so the per-netns arrays are always available. This makes /proc/net/rpc/nfsd report per-network-namespace procedure call counts. Assisted-by: Claude:claude-opus-4-6 Signed-off-by: Jeff Layton --- net/sunrpc/stats.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c index 5bcecd2919b1..fc2db251dfa0 100644 --- a/net/sunrpc/stats.c +++ b/net/sunrpc/stats.c @@ -108,7 +108,7 @@ void svc_seq_show(struct seq_file *seq, const struct sv= c_stat *statp) for (j =3D 0; j < vers->vs_nproc; j++) { count =3D 0; for_each_possible_cpu(k) - count +=3D per_cpu(vers->vs_count[j], k); + count +=3D per_cpu(statp->vs_count[i][j], k); seq_printf(seq, " %lu", count); } seq_putc(seq, '\n'); --=20 2.54.0 From nobody Thu Jun 11 05:14:01 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E530F1E9B3D; Tue, 9 Jun 2026 16:16:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021766; cv=none; b=APp4SEfHSvVSyG4HGLRH4E/rZ3ZK9fquru+PgJbHVZD/A/Ndptid8SegLGABJhniCcGvYzpifemFOvESeqE8O50n0PD1KBJhEW/YzzSRcwZ698Cap/GUTyyekeqnAoXH5E+7GxMBLiRykEf7/dlNydjNICnF40Bkl25cS0dCYg4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021766; c=relaxed/simple; bh=y2zkUS94UNsBE45o87S6jI9UVFaTAR2JPkR6IJwE6fE=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=nmwTxWQLzaeywyJq8/KzKVUqOcabwQ3rs5pZUIDG7xNFqBAhBxp+YNadDOCfDcr7xK1bTDnnX/ihp8bmRhri1kh7TdEauD1jMVRVN5vPCc5NeWI3A8FE6huzkGs7E63zN2dRd2RiAQOSrxwhqiIa/jmJ+GtisQjAaHl78hdXUXQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=FheCmUDI; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="FheCmUDI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id DBB9F1F0089C; Tue, 9 Jun 2026 16:16:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781021764; bh=fSMGCfXV0TcUjhTaUw1rEnpTb/AWw4pKxCmTahpo+uk=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=FheCmUDIvn2tzTVoY+JPKnkJbHmmHCcyPUnKZeimV/jj2Uek8FHW/Rs+K0janWA/n RdU2xnofLoAJ8sx9i7r8DkYpiQDgghJxa292W1asDRe6hUHwYJdXt3r824DGJke0sV No0pSmIJrXwVMKg/V1zbdnFm2l2bK78nrzjndlFQpzjiTi1ZbMqcenJwgrwAKHrQYG 4ItLhZsAwtbSLLwl5m+H2bmMxzPFGcfgNsRpCsWa70i9Z9YWKNnF3Qs9nyk3KPxLp5 c5vxcB2PGqFgQm2aNtG4F09RvuqtRAawqTnIGcpH/L9Y30PaUpD/qAbg372CbNMGCm n+EAb4pXNuxNg== From: Jeff Layton Date: Tue, 09 Jun 2026 12:15:56 -0400 Subject: [PATCH v3 3/4] nfsd: implement server-stats-get netlink handler Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260609-exportd-netlink-v3-3-aa5508a5bb1d@kernel.org> References: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> In-Reply-To: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey Cc: Trond Myklebust , Anna Schumaker , Steve Dickson , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=13119; i=jlayton@kernel.org; h=from:subject:message-id; bh=y2zkUS94UNsBE45o87S6jI9UVFaTAR2JPkR6IJwE6fE=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqKDw/LCqQ9tOXMkmR7JqrSDmj9Pi4XCX8X/vGP uKtWsF5BNuJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCaig8PwAKCRAADmhBGVaC Fa71EAC/wRN+RjDTPod2EHac+D6wZYRXcXN0+imqKTTJDhH3rsURZ1hO/dAJxKgVRz7mdShgiEo Ot1i780WPUUk/ePXGRMQ81BXGhYJiunUgResMIQReWjUMFJaK6pF/gWM4AaT2lOxGKgNVtIXtRk 2EoNTDD6Pul7O33HNxApWT+KiG4T7Zr8q3Q7Sld1sRYCuLZRL6IjxpfuOhORN+nijgdAX/3ThUz XHGZ2IL/LUY4SEHZonBtQrzLHRHBJqPcl7qD/ce5tKULUTWXCpksxBsmYrPjZZMTjSuDc0st7uO UaVfa4QxE97F1SD1/yLTdBFcJRXMb3TJAVzjO/HZMesh4s26D66IrYBGLfFpgOtOZ80p2puTEFT vVnqY9y79oTtJmFwqp6wXjKgXM1gKCUWwBRAhiVe80+EFtRFdibiTvAAOzq0LWOZaq1wO/loOPi 2GKMSnTo1uJQu7jLI0KJGWqcKjjxyu7+OPoi2e21v5f4zILZRMA++Ep4zRP0yXnidXdWOkZ31PJ N2cyOIkeCeHAPtP66mwlW7GaynHCBzsAKBYxtr2Wc0QRbFOJt/NIs+0i7Hyn/DCAqvtnheyK6B7 uqbfJ4MaPyaHqTRXF3Np0A/ZyqXj1Od5wDi4MWoVxkggDxtasQG9Sx5F0UhIiZNbghmeFTsK9aT x23ojrBwJW/kaSA== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Implement nfsd_nl_server_stats_get_dumpit() which exposes the NFS server statistics currently available via /proc/net/rpc/nfsd through the nfsd generic netlink family. The handler uses a dump operation to stream statistics across multiple netlink messages: - First message: all scalar stats (reply cache, filehandle, IO, network, RPC) plus per-version procedure counts (proc2/3/4-ops) using per-netns vs_count arrays. - Subsequent messages: NFSv4 per-operation counts (proc4ops-ops), one entry per message, using cb->args[0] to track the current operation index across dump calls. This allows nfsstat to retrieve server statistics via netlink with a procfs fallback for older kernels. Assisted-by: Claude:claude-opus-4-6 Signed-off-by: Jeff Layton --- Documentation/netlink/specs/nfsd.yaml | 105 +++++++++++++++++ fs/nfsd/netlink.c | 5 + fs/nfsd/netlink.h | 2 + fs/nfsd/nfsctl.c | 213 ++++++++++++++++++++++++++++++= ++++ include/uapi/linux/nfsd_netlink.h | 35 ++++++ 5 files changed, 360 insertions(+) diff --git a/Documentation/netlink/specs/nfsd.yaml b/Documentation/netlink/= specs/nfsd.yaml index 8f36fadd68f7..2a89d355ee7b 100644 --- a/Documentation/netlink/specs/nfsd.yaml +++ b/Documentation/netlink/specs/nfsd.yaml @@ -330,6 +330,86 @@ attribute-sets: of which client holds the state. Intended for use after all clients have been unexported from a given path, enabling the underlying filesystem to be unmounted. + - + name: server-proc-entry + attributes: + - + name: op + type: u32 + - + name: count + type: u64 + - + name: pad + type: pad + - + name: server-stats + attributes: + - + name: rc-hits + type: u64 + - + name: rc-misses + type: u64 + - + name: rc-nocache + type: u64 + - + name: pad + type: pad + - + name: fh-stale + type: u64 + - + name: io-read + type: u64 + - + name: io-write + type: u64 + - + name: netcnt + type: u32 + - + name: netudpcnt + type: u32 + - + name: nettcpcnt + type: u32 + - + name: nettcpconn + type: u32 + - + name: rpccnt + type: u32 + - + name: rpcbadfmt + type: u32 + - + name: rpcbadauth + type: u32 + - + name: rpcbadclnt + type: u32 + - + name: proc2-ops + type: nest + nested-attributes: server-proc-entry + multi-attr: true + - + name: proc3-ops + type: nest + nested-attributes: server-proc-entry + multi-attr: true + - + name: proc4-ops + type: nest + nested-attributes: server-proc-entry + multi-attr: true + - + name: proc4ops-ops + type: nest + nested-attributes: server-proc-entry + multi-attr: true =20 operations: list: @@ -516,6 +596,31 @@ operations: request: attributes: - path + - + name: server-stats-get + doc: dump NFS server statistics + attribute-set: server-stats + dump: + reply: + attributes: + - rc-hits + - rc-misses + - rc-nocache + - fh-stale + - io-read + - io-write + - netcnt + - netudpcnt + - nettcpcnt + - nettcpconn + - rpccnt + - rpcbadfmt + - rpcbadauth + - rpcbadclnt + - proc2-ops + - proc3-ops + - proc4-ops + - proc4ops-ops =20 mcast-groups: list: diff --git a/fs/nfsd/netlink.c b/fs/nfsd/netlink.c index fbee3676d253..eba8b353f412 100644 --- a/fs/nfsd/netlink.c +++ b/fs/nfsd/netlink.c @@ -225,6 +225,11 @@ static const struct genl_split_ops nfsd_nl_ops[] =3D { .maxattr =3D NFSD_A_UNLOCK_EXPORT_PATH, .flags =3D GENL_ADMIN_PERM | GENL_CMD_CAP_DO, }, + { + .cmd =3D NFSD_CMD_SERVER_STATS_GET, + .dumpit =3D nfsd_nl_server_stats_get_dumpit, + .flags =3D GENL_CMD_CAP_DUMP, + }, }; =20 static const struct genl_multicast_group nfsd_nl_mcgrps[] =3D { diff --git a/fs/nfsd/netlink.h b/fs/nfsd/netlink.h index af41aa0d4a65..027e2953db26 100644 --- a/fs/nfsd/netlink.h +++ b/fs/nfsd/netlink.h @@ -42,6 +42,8 @@ int nfsd_nl_cache_flush_doit(struct sk_buff *skb, struct = genl_info *info); int nfsd_nl_unlock_ip_doit(struct sk_buff *skb, struct genl_info *info); int nfsd_nl_unlock_filesystem_doit(struct sk_buff *skb, struct genl_info *= info); int nfsd_nl_unlock_export_doit(struct sk_buff *skb, struct genl_info *info= ); +int nfsd_nl_server_stats_get_dumpit(struct sk_buff *skb, + struct netlink_callback *cb); =20 enum { NFSD_NLGRP_NONE, diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index 7b802d335501..d60f2a0f07f0 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -2252,6 +2252,219 @@ int nfsd_nl_cache_flush_doit(struct sk_buff *skb, s= truct genl_info *info) return 0; } =20 +static int nfsd_nl_fill_proc_ops(struct sk_buff *skb, int attr, + unsigned long __percpu *counts, + unsigned int nproc) +{ + struct nlattr *nest; + unsigned int j; + int k; + + for (j =3D 0; j < nproc; j++) { + unsigned long count =3D 0; + + for_each_possible_cpu(k) + count +=3D per_cpu(counts[j], k); + + nest =3D nla_nest_start(skb, attr); + if (!nest) + return -EMSGSIZE; + if (nla_put_u32(skb, NFSD_A_SERVER_PROC_ENTRY_OP, j) || + nla_put_u64_64bit(skb, NFSD_A_SERVER_PROC_ENTRY_COUNT, + count, NFSD_A_SERVER_PROC_ENTRY_PAD)) { + nla_nest_cancel(skb, nest); + return -EMSGSIZE; + } + nla_nest_end(skb, nest); + } + + return 0; +} + +/** + * nfsd_nl_server_stats_get_dumpit - dump NFS server statistics + * @skb: reply buffer + * @cb: netlink metadata and command arguments + * + * cb->args[0] tracks the current NFSv4 operation index for proc4ops. + * A value of 0 means we haven't started yet. We emit all scalar stats + * and per-version procedure counts in the first message, then emit + * proc4ops entries filling as many as will fit per message. + * + * Returns the size of the reply or a negative errno. + */ +int nfsd_nl_server_stats_get_dumpit(struct sk_buff *skb, + struct netlink_callback *cb) +{ + struct net *net =3D sock_net(skb->sk); + struct nfsd_net *nn =3D net_generic(net, nfsd_net_id); + struct svc_stat *statp =3D &nn->nfsd_svcstats; + struct svc_program *prog =3D statp->program; + int start =3D cb->args[0]; + void *hdr; + int ret; + + /* + * cb->args[0] =3D=3D 0: first call, emit scalar stats + procN counts + * cb->args[0] > 0: emit proc4ops entries starting from args[0] - 1 + * cb->args[0] < 0: done + */ + if (start < 0) + return 0; + + if (start =3D=3D 0) { + hdr =3D genlmsg_put(skb, NETLINK_CB(cb->skb).portid, + cb->nlh->nlmsg_seq, &nfsd_nl_family, + NLM_F_MULTI, NFSD_CMD_SERVER_STATS_GET); + if (!hdr) + return -ENOBUFS; + + /* Reply cache stats */ + { + u64 hits, misses, nocache; + + hits =3D percpu_counter_sum_positive(&nn->counter[NFSD_STATS_RC_HITS]); + misses =3D percpu_counter_sum_positive(&nn->counter[NFSD_STATS_RC_MISSE= S]); + nocache =3D percpu_counter_sum_positive(&nn->counter[NFSD_STATS_RC_NOCA= CHE]); + ret =3D nla_put_u64_64bit(skb, NFSD_A_SERVER_STATS_RC_HITS, + hits, NFSD_A_SERVER_STATS_PAD) || + nla_put_u64_64bit(skb, NFSD_A_SERVER_STATS_RC_MISSES, + misses, NFSD_A_SERVER_STATS_PAD) || + nla_put_u64_64bit(skb, NFSD_A_SERVER_STATS_RC_NOCACHE, + nocache, NFSD_A_SERVER_STATS_PAD); + } + if (ret) + goto err_cancel; + + /* Filehandle stats */ + ret =3D nla_put_u64_64bit(skb, NFSD_A_SERVER_STATS_FH_STALE, + percpu_counter_sum_positive(&nn->counter[NFSD_STATS_FH_STALE]), + NFSD_A_SERVER_STATS_PAD); + if (ret) + goto err_cancel; + + /* IO stats */ + { + u64 rd, wr; + + rd =3D percpu_counter_sum_positive(&nn->counter[NFSD_STATS_IO_READ]); + wr =3D percpu_counter_sum_positive(&nn->counter[NFSD_STATS_IO_WRITE]); + ret =3D nla_put_u64_64bit(skb, NFSD_A_SERVER_STATS_IO_READ, + rd, NFSD_A_SERVER_STATS_PAD) || + nla_put_u64_64bit(skb, NFSD_A_SERVER_STATS_IO_WRITE, + wr, NFSD_A_SERVER_STATS_PAD); + } + if (ret) + goto err_cancel; + + /* Network stats */ + ret =3D nla_put_u32(skb, NFSD_A_SERVER_STATS_NETCNT, + statp->netcnt) || + nla_put_u32(skb, NFSD_A_SERVER_STATS_NETUDPCNT, + statp->netudpcnt) || + nla_put_u32(skb, NFSD_A_SERVER_STATS_NETTCPCNT, + statp->nettcpcnt) || + nla_put_u32(skb, NFSD_A_SERVER_STATS_NETTCPCONN, + statp->nettcpconn); + if (ret) + goto err_cancel; + + /* RPC stats */ + ret =3D nla_put_u32(skb, NFSD_A_SERVER_STATS_RPCCNT, + statp->rpccnt) || + nla_put_u32(skb, NFSD_A_SERVER_STATS_RPCBADFMT, + statp->rpcbadfmt) || + nla_put_u32(skb, NFSD_A_SERVER_STATS_RPCBADAUTH, + statp->rpcbadauth) || + nla_put_u32(skb, NFSD_A_SERVER_STATS_RPCBADCLNT, + statp->rpcbadclnt); + if (ret) + goto err_cancel; + + /* Per-version procedure counts */ + if (statp->vs_count) { + static const int proc_attrs[] =3D { + [2] =3D NFSD_A_SERVER_STATS_PROC2_OPS, + [3] =3D NFSD_A_SERVER_STATS_PROC3_OPS, + [4] =3D NFSD_A_SERVER_STATS_PROC4_OPS, + }; + unsigned int i; + + for (i =3D 0; i < prog->pg_nvers && + i < ARRAY_SIZE(proc_attrs); i++) { + if (!prog->pg_vers[i] || + !statp->vs_count[i]) + continue; + if (!proc_attrs[i]) + continue; + ret =3D nfsd_nl_fill_proc_ops(skb, + proc_attrs[i], + statp->vs_count[i], + prog->pg_vers[i]->vs_nproc); + if (ret) + goto err_cancel; + } + } + + genlmsg_end(skb, hdr); + cb->args[0] =3D 1; + } + +#ifdef CONFIG_NFSD_V4 + /* NFSv4 individual operation counts */ + { + int i =3D (start > 0) ? start - 1 : 0; + + for (; i <=3D LAST_NFS4_OP; i++) { + struct percpu_counter *ctr; + struct nlattr *nest; + u64 cnt; + + ctr =3D &nn->counter[NFSD_STATS_NFS4_OP(i)]; + cnt =3D percpu_counter_sum_positive(ctr); + + hdr =3D genlmsg_put(skb, NETLINK_CB(cb->skb).portid, + cb->nlh->nlmsg_seq, + &nfsd_nl_family, NLM_F_MULTI, + NFSD_CMD_SERVER_STATS_GET); + if (!hdr) { + cb->args[0] =3D i + 1; + goto out; + } + + nest =3D nla_nest_start(skb, + NFSD_A_SERVER_STATS_PROC4OPS_OPS); + if (!nest) { + genlmsg_cancel(skb, hdr); + cb->args[0] =3D i + 1; + goto out; + } + if (nla_put_u32(skb, NFSD_A_SERVER_PROC_ENTRY_OP, + i) || + nla_put_u64_64bit(skb, + NFSD_A_SERVER_PROC_ENTRY_COUNT, + cnt, + NFSD_A_SERVER_PROC_ENTRY_PAD)) { + nla_nest_cancel(skb, nest); + genlmsg_cancel(skb, hdr); + cb->args[0] =3D i + 1; + goto out; + } + nla_nest_end(skb, nest); + genlmsg_end(skb, hdr); + } + } +#endif + + cb->args[0] =3D -1; +out: + return skb->len; + +err_cancel: + genlmsg_cancel(skb, hdr); + return ret; +} + int nfsd_cache_notify(struct cache_detail *cd, struct cache_head *h, u32 c= ache_type) { struct genlmsghdr *hdr; diff --git a/include/uapi/linux/nfsd_netlink.h b/include/uapi/linux/nfsd_ne= tlink.h index f5b75d5caba9..3d076d173b1d 100644 --- a/include/uapi/linux/nfsd_netlink.h +++ b/include/uapi/linux/nfsd_netlink.h @@ -225,6 +225,40 @@ enum { NFSD_A_UNLOCK_EXPORT_MAX =3D (__NFSD_A_UNLOCK_EXPORT_MAX - 1) }; =20 +enum { + NFSD_A_SERVER_PROC_ENTRY_OP =3D 1, + NFSD_A_SERVER_PROC_ENTRY_COUNT, + NFSD_A_SERVER_PROC_ENTRY_PAD, + + __NFSD_A_SERVER_PROC_ENTRY_MAX, + NFSD_A_SERVER_PROC_ENTRY_MAX =3D (__NFSD_A_SERVER_PROC_ENTRY_MAX - 1) +}; + +enum { + NFSD_A_SERVER_STATS_RC_HITS =3D 1, + NFSD_A_SERVER_STATS_RC_MISSES, + NFSD_A_SERVER_STATS_RC_NOCACHE, + NFSD_A_SERVER_STATS_PAD, + NFSD_A_SERVER_STATS_FH_STALE, + NFSD_A_SERVER_STATS_IO_READ, + NFSD_A_SERVER_STATS_IO_WRITE, + NFSD_A_SERVER_STATS_NETCNT, + NFSD_A_SERVER_STATS_NETUDPCNT, + NFSD_A_SERVER_STATS_NETTCPCNT, + NFSD_A_SERVER_STATS_NETTCPCONN, + NFSD_A_SERVER_STATS_RPCCNT, + NFSD_A_SERVER_STATS_RPCBADFMT, + NFSD_A_SERVER_STATS_RPCBADAUTH, + NFSD_A_SERVER_STATS_RPCBADCLNT, + NFSD_A_SERVER_STATS_PROC2_OPS, + NFSD_A_SERVER_STATS_PROC3_OPS, + NFSD_A_SERVER_STATS_PROC4_OPS, + NFSD_A_SERVER_STATS_PROC4OPS_OPS, + + __NFSD_A_SERVER_STATS_MAX, + NFSD_A_SERVER_STATS_MAX =3D (__NFSD_A_SERVER_STATS_MAX - 1) +}; + enum { NFSD_CMD_RPC_STATUS_GET =3D 1, NFSD_CMD_THREADS_SET, @@ -244,6 +278,7 @@ enum { NFSD_CMD_UNLOCK_IP, NFSD_CMD_UNLOCK_FILESYSTEM, NFSD_CMD_UNLOCK_EXPORT, + NFSD_CMD_SERVER_STATS_GET, =20 __NFSD_CMD_MAX, NFSD_CMD_MAX =3D (__NFSD_CMD_MAX - 1) --=20 2.54.0 From nobody Thu Jun 11 05:14:01 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5E6A63AE6F8; Tue, 9 Jun 2026 16:16:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021767; cv=none; b=VAnGWs9NxBBlaG6Uwt42C1ErX69MqTJPF8CTLUEYdORv70+Foy00ZTziihEHo1wzUhVZ77aMQ83HHUMowuNAjatj8WBmHz8dnM6K9/96aLeCx//mzKO7FtNQb4pl4ftDS1ApXQlapS4xyxz4JaHROnF3jHSnWgZGIsKFW4XidxI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781021767; c=relaxed/simple; bh=kXiHY93vA6zkSsMC+yOT6/a94LEpKb0VCYdPFzVa6+o=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=PFfZ9u+nXd+nx9fkeEzGde5+O2Mvgh4pM3A/bU/hYQlEMu0GQCG1nyiJDyz5W5pGfHjv7YxxQbB12t91AgH6fM9WJsqxMl3bkVjHeu1hbPMOng8VX6X/wfoiqTjoVkGOcX5JRUvkUhRvGGqJTmd/tmO7WSu0QsuoGEPHvGc8his= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=k/mOTqMi; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="k/mOTqMi" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 14BBD1F00898; Tue, 9 Jun 2026 16:16:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781021766; bh=E7aa3zmJtAIXv0aXZe5AhKnYwW2BQgjkdD7bYX4VrQA=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=k/mOTqMiwU1FFklSKhCtMuI9kxdzk8OXNRCL/r+IqKI+DXsnBMQo2dbymyWpCXohx XerG+crzxNN58wmiIPRswL4NFcC8pDXDmieCuNxcq7J7j1IG7IKZTlbK/zzvpk133g OtVbDdnz9X6HD/h/isNThFKJ19mq3yS5oJL+jgHwHEJ7XSWVcNIieI99zWncTRwjAp Mp0iJi7QDEoau82zY4QK4l9yF0bB0z/dLeCTQHl0Nhi9THklhU2nmK3jaXMVgZVcoH fQ3jDRpir9kdsEztdJzcVHJE16xdb8gg6sHjlmRvtNAEhcrLPhxrKHlPcJvMs8g0r4 Xbr4BgFh7OSmQ== From: Jeff Layton Date: Tue, 09 Jun 2026 12:15:57 -0400 Subject: [PATCH v3 4/4] sunrpc: remove unused svc_version vs_count field Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260609-exportd-netlink-v3-4-aa5508a5bb1d@kernel.org> References: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> In-Reply-To: <20260609-exportd-netlink-v3-0-aa5508a5bb1d@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey Cc: Trond Myklebust , Anna Schumaker , Steve Dickson , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=8485; i=jlayton@kernel.org; h=from:subject:message-id; bh=kXiHY93vA6zkSsMC+yOT6/a94LEpKb0VCYdPFzVa6+o=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqKDw/H4Tm6q5uQKm6Rc+ZBGnbmHOfd0bJea3el MaWisvpszKJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCaig8PwAKCRAADmhBGVaC FdfCD/4hhXYR7V4FvbyEOFbrHAopks20uHEvSta12PO934OzQNqtnAsHOKWs5a7JOky0DhQKYJp EIfGB5SagD0CL28A2BX2g81UBCLrWcyu79q//FzPEOnpwYTwnR3psywvh86UOvMOflLnb0Qgaw+ kC2W5JGO+wWHE0Fxl3C2y+H+UvgGZ0Jy9/qtwnGyfLtgBHC26obr5yinNyzVmB5cdZoO9qYJerl Ost/LI463DoMk8I3q5qHR7goqBIIjVZwzmtXEMvkdxv/uc/ul//UCNsnbAyjiWI3vvdpijlHtmu x1H+Bl4/7GAgWJoKOF+70NysMNDlJJyMmKY9bx8AoudYrH0yFrtLkPAsSgjnuaYGtEBI47V3vbR xHVokPHHlPlcrFg0aGRRRD03D5o3djk5DYmGgNjPvLIMC5tVaReCMpwrYSC9DBWWqBJkQiEwSoJ e/iNyIg1f1eYxleHgAkmsvgqUZv0Gv40QXrHuXsFhiQotoUY1iPc1nCaDs7i2lEPi3VqjiT7rwP e0+rYHlz77xfzAhEoC4IJastwfG8P01p6s4st+wbW2l0NPXVQlwB9hQZHv8p3nYTQlNcHvwQs9e tWz2kWxeopo51l+Ky3DyMNZBd2IPqN1JI8M/5tWh4csnry6aHmIo70ZFokQA6MhmqnhrecXzxim e+8+ROH6BS5K1JA== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Now that svc_seq_show() and the nfsd netlink stats handler both use the per-netns svc_stat vs_count arrays, the global per-version vs_count percpu counters are no longer read by anything. Remove the vs_count field from struct svc_version and all the associated DEFINE_PER_CPU_ALIGNED arrays and initializers across nfsd, lockd, and the NFS client callback service. Assisted-by: Claude:claude-opus-4-6 Signed-off-by: Jeff Layton --- fs/lockd/svc4proc.c | 4 ---- fs/lockd/svcproc.c | 7 ------- fs/nfs/callback_xdr.c | 6 ------ fs/nfsd/localio.c | 3 --- fs/nfsd/nfs2acl.c | 3 --- fs/nfsd/nfs3acl.c | 3 --- fs/nfsd/nfs3proc.c | 3 --- fs/nfsd/nfs4proc.c | 3 --- fs/nfsd/nfsproc.c | 3 --- include/linux/sunrpc/svc.h | 1 - net/sunrpc/svc.c | 3 --- 11 files changed, 39 deletions(-) diff --git a/fs/lockd/svc4proc.c b/fs/lockd/svc4proc.c index 78e675470c4b..8910ee9c2c24 100644 --- a/fs/lockd/svc4proc.c +++ b/fs/lockd/svc4proc.c @@ -1420,14 +1420,10 @@ union nlm4svc_xdrstore { struct nlm4_shareres_wrapper shareres; }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nlm4svc_call_counters[ARRAY_SIZE(nlm4svc_procedures)]); - const struct svc_version nlmsvc_version4 =3D { .vs_vers =3D 4, .vs_nproc =3D ARRAY_SIZE(nlm4svc_procedures), .vs_proc =3D nlm4svc_procedures, - .vs_count =3D nlm4svc_call_counters, .vs_dispatch =3D nlmsvc_dispatch, .vs_xdrsize =3D sizeof(union nlm4svc_xdrstore), }; diff --git a/fs/lockd/svcproc.c b/fs/lockd/svcproc.c index 4836887f11ef..8f81d95fc5ff 100644 --- a/fs/lockd/svcproc.c +++ b/fs/lockd/svcproc.c @@ -1433,25 +1433,18 @@ union nlmsvc_xdrstore { * NLMv1 defines only procedures 1 - 15. Linux lockd also implements * procedures 0 (NULL) and 16 (SM_NOTIFY). */ -static DEFINE_PER_CPU_ALIGNED(unsigned long, nlm1svc_call_counters[17]); - const struct svc_version nlmsvc_version1 =3D { .vs_vers =3D 1, .vs_nproc =3D 17, .vs_proc =3D nlmsvc_procedures, - .vs_count =3D nlm1svc_call_counters, .vs_dispatch =3D nlmsvc_dispatch, .vs_xdrsize =3D sizeof(union nlmsvc_xdrstore), }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nlm3svc_call_counters[ARRAY_SIZE(nlmsvc_procedures)]); - const struct svc_version nlmsvc_version3 =3D { .vs_vers =3D 3, .vs_nproc =3D ARRAY_SIZE(nlmsvc_procedures), .vs_proc =3D nlmsvc_procedures, - .vs_count =3D nlm3svc_call_counters, .vs_dispatch =3D nlmsvc_dispatch, .vs_xdrsize =3D sizeof(union nlmsvc_xdrstore), }; diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c index 4382baddc9ee..eec6040556c9 100644 --- a/fs/nfs/callback_xdr.c +++ b/fs/nfs/callback_xdr.c @@ -1090,26 +1090,20 @@ static const struct svc_procedure nfs4_callback_pro= cedures1[] =3D { } }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nfs4_callback_count1[ARRAY_SIZE(nfs4_callback_procedures1)]); const struct svc_version nfs4_callback_version1 =3D { .vs_vers =3D 1, .vs_nproc =3D ARRAY_SIZE(nfs4_callback_procedures1), .vs_proc =3D nfs4_callback_procedures1, - .vs_count =3D nfs4_callback_count1, .vs_xdrsize =3D NFS4_CALLBACK_XDRSIZE, .vs_dispatch =3D nfs_callback_dispatch, .vs_hidden =3D true, .vs_need_cong_ctrl =3D true, }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nfs4_callback_count4[ARRAY_SIZE(nfs4_callback_procedures1)]); const struct svc_version nfs4_callback_version4 =3D { .vs_vers =3D 4, .vs_nproc =3D ARRAY_SIZE(nfs4_callback_procedures1), .vs_proc =3D nfs4_callback_procedures1, - .vs_count =3D nfs4_callback_count4, .vs_xdrsize =3D NFS4_CALLBACK_XDRSIZE, .vs_dispatch =3D nfs_callback_dispatch, .vs_hidden =3D true, diff --git a/fs/nfsd/localio.c b/fs/nfsd/localio.c index c3eb0557b3e1..c458c01e9478 100644 --- a/fs/nfsd/localio.c +++ b/fs/nfsd/localio.c @@ -210,14 +210,11 @@ static const struct svc_procedure localio_procedures1= [] =3D { }; =20 #define LOCALIO_NR_PROCEDURES ARRAY_SIZE(localio_procedures1) -static DEFINE_PER_CPU_ALIGNED(unsigned long, - localio_count[LOCALIO_NR_PROCEDURES]); const struct svc_version localio_version1 =3D { .vs_vers =3D 1, .vs_nproc =3D LOCALIO_NR_PROCEDURES, .vs_proc =3D localio_procedures1, .vs_dispatch =3D nfsd_dispatch, - .vs_count =3D localio_count, .vs_xdrsize =3D XDR_QUADLEN(UUID_SIZE), .vs_hidden =3D true, }; diff --git a/fs/nfsd/nfs2acl.c b/fs/nfsd/nfs2acl.c index 827f90194c43..0fd6d9def3b4 100644 --- a/fs/nfsd/nfs2acl.c +++ b/fs/nfsd/nfs2acl.c @@ -389,13 +389,10 @@ static const struct svc_procedure nfsd_acl_procedures= 2[5] =3D { }, }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)]); const struct svc_version nfsd_acl_version2 =3D { .vs_vers =3D 2, .vs_nproc =3D ARRAY_SIZE(nfsd_acl_procedures2), .vs_proc =3D nfsd_acl_procedures2, - .vs_count =3D nfsd_acl_count2, .vs_dispatch =3D nfsd_dispatch, .vs_xdrsize =3D NFS3_SVC_XDRSIZE, }; diff --git a/fs/nfsd/nfs3acl.c b/fs/nfsd/nfs3acl.c index a87f9d7f32be..6b6b289db636 100644 --- a/fs/nfsd/nfs3acl.c +++ b/fs/nfsd/nfs3acl.c @@ -278,13 +278,10 @@ static const struct svc_procedure nfsd_acl_procedures= 3[3] =3D { }, }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nfsd_acl_count3[ARRAY_SIZE(nfsd_acl_procedures3)]); const struct svc_version nfsd_acl_version3 =3D { .vs_vers =3D 3, .vs_nproc =3D ARRAY_SIZE(nfsd_acl_procedures3), .vs_proc =3D nfsd_acl_procedures3, - .vs_count =3D nfsd_acl_count3, .vs_dispatch =3D nfsd_dispatch, .vs_xdrsize =3D NFS3_SVC_XDRSIZE, }; diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c index aeda7a802bdf..2d5ab2178702 100644 --- a/fs/nfsd/nfs3proc.c +++ b/fs/nfsd/nfs3proc.c @@ -1068,13 +1068,10 @@ static const struct svc_procedure nfsd_procedures3[= 22] =3D { }, }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nfsd_count3[ARRAY_SIZE(nfsd_procedures3)]); const struct svc_version nfsd_version3 =3D { .vs_vers =3D 3, .vs_nproc =3D ARRAY_SIZE(nfsd_procedures3), .vs_proc =3D nfsd_procedures3, .vs_dispatch =3D nfsd_dispatch, - .vs_count =3D nfsd_count3, .vs_xdrsize =3D NFS3_SVC_XDRSIZE, }; diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c index 0c37d7c6d28c..3e9819fa6cee 100644 --- a/fs/nfsd/nfs4proc.c +++ b/fs/nfsd/nfs4proc.c @@ -4129,13 +4129,10 @@ static const struct svc_procedure nfsd_procedures4[= 2] =3D { }, }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nfsd_count4[ARRAY_SIZE(nfsd_procedures4)]); const struct svc_version nfsd_version4 =3D { .vs_vers =3D 4, .vs_nproc =3D ARRAY_SIZE(nfsd_procedures4), .vs_proc =3D nfsd_procedures4, - .vs_count =3D nfsd_count4, .vs_dispatch =3D nfsd_dispatch, .vs_xdrsize =3D NFS4_SVC_XDRSIZE, .vs_rpcb_optnl =3D true, diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c index 8873033d1e82..9efd261fae45 100644 --- a/fs/nfsd/nfsproc.c +++ b/fs/nfsd/nfsproc.c @@ -838,13 +838,10 @@ static const struct svc_procedure nfsd_procedures2[18= ] =3D { }, }; =20 -static DEFINE_PER_CPU_ALIGNED(unsigned long, - nfsd_count2[ARRAY_SIZE(nfsd_procedures2)]); const struct svc_version nfsd_version2 =3D { .vs_vers =3D 2, .vs_nproc =3D ARRAY_SIZE(nfsd_procedures2), .vs_proc =3D nfsd_procedures2, - .vs_count =3D nfsd_count2, .vs_dispatch =3D nfsd_dispatch, .vs_xdrsize =3D NFS2_SVC_XDRSIZE, }; diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h index 4be6204f6630..db9ee1d3a50b 100644 --- a/include/linux/sunrpc/svc.h +++ b/include/linux/sunrpc/svc.h @@ -408,7 +408,6 @@ struct svc_version { u32 vs_vers; /* version number */ u32 vs_nproc; /* number of procedures */ const struct svc_procedure *vs_proc; /* per-procedure info */ - unsigned long __percpu *vs_count; /* call counts */ u32 vs_xdrsize; /* xdrsize needed for this version */ =20 /* Don't register with rpcbind */ diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c index 200b57e633dd..61e1c56c3657 100644 --- a/net/sunrpc/svc.c +++ b/net/sunrpc/svc.c @@ -1405,9 +1405,6 @@ svc_generic_init_request(struct svc_rqst *rqstp, memset(rqstp->rq_argp, 0, procp->pc_argzero); memset(rqstp->rq_resp, 0, procp->pc_ressize); =20 - /* Bump per-procedure stats counter */ - this_cpu_inc(versp->vs_count[rqstp->rq_proc]); - /* Bump per-net per-procedure stats counter */ if (rqstp->rq_server->sv_stats && rqstp->rq_server->sv_stats->program =3D=3D progp && --=20 2.54.0