1/*
2 * linux/net/sunrpc/stats.c
3 *
4 * procfs-based user access to generic RPC statistics. The stats files
5 * reside in /proc/net/rpc.
6 *
7 * The read routines assume that the buffer passed in is just big enough.
8 * If you implement an RPC service that has its own stats routine which
9 * appends the generic RPC stats, make sure you don't exceed the PAGE_SIZE
10 * limit.
11 *
12 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
13 */
14
15#include <linux/module.h>
16#include <linux/slab.h>
17
18#include <linux/init.h>
19#include <linux/kernel.h>
20#include <linux/proc_fs.h>
21#include <linux/seq_file.h>
22#include <linux/sunrpc/clnt.h>
23#include <linux/sunrpc/svcsock.h>
24#include <linux/sunrpc/metrics.h>
25#include <linux/rcupdate.h>
26
27#include "netns.h"
28
29#define RPCDBG_FACILITY	RPCDBG_MISC
30
31/*
32 * Get RPC client stats
33 */
34static int rpc_proc_show(struct seq_file *seq, void *v) {
35	const struct rpc_stat	*statp = seq->private;
36	const struct rpc_program *prog = statp->program;
37	unsigned int i, j;
38
39	seq_printf(seq,
40		"net %u %u %u %u\n",
41			statp->netcnt,
42			statp->netudpcnt,
43			statp->nettcpcnt,
44			statp->nettcpconn);
45	seq_printf(seq,
46		"rpc %u %u %u\n",
47			statp->rpccnt,
48			statp->rpcretrans,
49			statp->rpcauthrefresh);
50
51	for (i = 0; i < prog->nrvers; i++) {
52		const struct rpc_version *vers = prog->version[i];
53		if (!vers)
54			continue;
55		seq_printf(seq, "proc%u %u",
56					vers->number, vers->nrprocs);
57		for (j = 0; j < vers->nrprocs; j++)
58			seq_printf(seq, " %u",
59					vers->procs[j].p_count);
60		seq_putc(seq, '\n');
61	}
62	return 0;
63}
64
65static int rpc_proc_open(struct inode *inode, struct file *file)
66{
67	return single_open(file, rpc_proc_show, PDE_DATA(inode));
68}
69
70static const struct file_operations rpc_proc_fops = {
71	.owner = THIS_MODULE,
72	.open = rpc_proc_open,
73	.read  = seq_read,
74	.llseek = seq_lseek,
75	.release = single_release,
76};
77
78/*
79 * Get RPC server stats
80 */
81void svc_seq_show(struct seq_file *seq, const struct svc_stat *statp) {
82	const struct svc_program *prog = statp->program;
83	const struct svc_procedure *proc;
84	const struct svc_version *vers;
85	unsigned int i, j;
86
87	seq_printf(seq,
88		"net %u %u %u %u\n",
89			statp->netcnt,
90			statp->netudpcnt,
91			statp->nettcpcnt,
92			statp->nettcpconn);
93	seq_printf(seq,
94		"rpc %u %u %u %u %u\n",
95			statp->rpccnt,
96			statp->rpcbadfmt+statp->rpcbadauth+statp->rpcbadclnt,
97			statp->rpcbadfmt,
98			statp->rpcbadauth,
99			statp->rpcbadclnt);
100
101	for (i = 0; i < prog->pg_nvers; i++) {
102		if (!(vers = prog->pg_vers[i]) || !(proc = vers->vs_proc))
103			continue;
104		seq_printf(seq, "proc%d %u", i, vers->vs_nproc);
105		for (j = 0; j < vers->vs_nproc; j++, proc++)
106			seq_printf(seq, " %u", proc->pc_count);
107		seq_putc(seq, '\n');
108	}
109}
110EXPORT_SYMBOL_GPL(svc_seq_show);
111
112/**
113 * rpc_alloc_iostats - allocate an rpc_iostats structure
114 * @clnt: RPC program, version, and xprt
115 *
116 */
117struct rpc_iostats *rpc_alloc_iostats(struct rpc_clnt *clnt)
118{
119	struct rpc_iostats *stats;
120	int i;
121
122	stats = kcalloc(clnt->cl_maxproc, sizeof(*stats), GFP_KERNEL);
123	if (stats) {
124		for (i = 0; i < clnt->cl_maxproc; i++)
125			spin_lock_init(&stats[i].om_lock);
126	}
127	return stats;
128}
129EXPORT_SYMBOL_GPL(rpc_alloc_iostats);
130
131/**
132 * rpc_free_iostats - release an rpc_iostats structure
133 * @stats: doomed rpc_iostats structure
134 *
135 */
136void rpc_free_iostats(struct rpc_iostats *stats)
137{
138	kfree(stats);
139}
140EXPORT_SYMBOL_GPL(rpc_free_iostats);
141
142/**
143 * rpc_count_iostats_metrics - tally up per-task stats
144 * @task: completed rpc_task
145 * @op_metrics: stat structure for OP that will accumulate stats from @task
146 */
147void rpc_count_iostats_metrics(const struct rpc_task *task,
148			       struct rpc_iostats *op_metrics)
149{
150	struct rpc_rqst *req = task->tk_rqstp;
151	ktime_t delta, now;
152
153	if (!op_metrics || !req)
154		return;
155
156	now = ktime_get();
157	spin_lock(&op_metrics->om_lock);
158
159	op_metrics->om_ops++;
160	op_metrics->om_ntrans += req->rq_ntrans;
161	op_metrics->om_timeouts += task->tk_timeouts;
162
163	op_metrics->om_bytes_sent += req->rq_xmit_bytes_sent;
164	op_metrics->om_bytes_recv += req->rq_reply_bytes_recvd;
165
166	delta = ktime_sub(req->rq_xtime, task->tk_start);
167	op_metrics->om_queue = ktime_add(op_metrics->om_queue, delta);
168
169	op_metrics->om_rtt = ktime_add(op_metrics->om_rtt, req->rq_rtt);
170
171	delta = ktime_sub(now, task->tk_start);
172	op_metrics->om_execute = ktime_add(op_metrics->om_execute, delta);
173
174	spin_unlock(&op_metrics->om_lock);
175}
176EXPORT_SYMBOL_GPL(rpc_count_iostats_metrics);
177
178/**
179 * rpc_count_iostats - tally up per-task stats
180 * @task: completed rpc_task
181 * @stats: array of stat structures
182 *
183 * Uses the statidx from @task
184 */
185void rpc_count_iostats(const struct rpc_task *task, struct rpc_iostats *stats)
186{
187	rpc_count_iostats_metrics(task,
188				  &stats[task->tk_msg.rpc_proc->p_statidx]);
189}
190EXPORT_SYMBOL_GPL(rpc_count_iostats);
191
192static void _print_name(struct seq_file *seq, unsigned int op,
193			struct rpc_procinfo *procs)
194{
195	if (procs[op].p_name)
196		seq_printf(seq, "\t%12s: ", procs[op].p_name);
197	else if (op == 0)
198		seq_printf(seq, "\t        NULL: ");
199	else
200		seq_printf(seq, "\t%12u: ", op);
201}
202
203void rpc_print_iostats(struct seq_file *seq, struct rpc_clnt *clnt)
204{
205	struct rpc_iostats *stats = clnt->cl_metrics;
206	struct rpc_xprt *xprt;
207	unsigned int op, maxproc = clnt->cl_maxproc;
208
209	if (!stats)
210		return;
211
212	seq_printf(seq, "\tRPC iostats version: %s  ", RPC_IOSTATS_VERS);
213	seq_printf(seq, "p/v: %u/%u (%s)\n",
214			clnt->cl_prog, clnt->cl_vers, clnt->cl_program->name);
215
216	rcu_read_lock();
217	xprt = rcu_dereference(clnt->cl_xprt);
218	if (xprt)
219		xprt->ops->print_stats(xprt, seq);
220	rcu_read_unlock();
221
222	seq_printf(seq, "\tper-op statistics\n");
223	for (op = 0; op < maxproc; op++) {
224		struct rpc_iostats *metrics = &stats[op];
225		_print_name(seq, op, clnt->cl_procinfo);
226		seq_printf(seq, "%lu %lu %lu %Lu %Lu %Lu %Lu %Lu\n",
227				metrics->om_ops,
228				metrics->om_ntrans,
229				metrics->om_timeouts,
230				metrics->om_bytes_sent,
231				metrics->om_bytes_recv,
232				ktime_to_ms(metrics->om_queue),
233				ktime_to_ms(metrics->om_rtt),
234				ktime_to_ms(metrics->om_execute));
235	}
236}
237EXPORT_SYMBOL_GPL(rpc_print_iostats);
238
239/*
240 * Register/unregister RPC proc files
241 */
242static inline struct proc_dir_entry *
243do_register(struct net *net, const char *name, void *data,
244	    const struct file_operations *fops)
245{
246	struct sunrpc_net *sn;
247
248	dprintk("RPC:       registering /proc/net/rpc/%s\n", name);
249	sn = net_generic(net, sunrpc_net_id);
250	return proc_create_data(name, 0, sn->proc_net_rpc, fops, data);
251}
252
253struct proc_dir_entry *
254rpc_proc_register(struct net *net, struct rpc_stat *statp)
255{
256	return do_register(net, statp->program->name, statp, &rpc_proc_fops);
257}
258EXPORT_SYMBOL_GPL(rpc_proc_register);
259
260void
261rpc_proc_unregister(struct net *net, const char *name)
262{
263	struct sunrpc_net *sn;
264
265	sn = net_generic(net, sunrpc_net_id);
266	remove_proc_entry(name, sn->proc_net_rpc);
267}
268EXPORT_SYMBOL_GPL(rpc_proc_unregister);
269
270struct proc_dir_entry *
271svc_proc_register(struct net *net, struct svc_stat *statp, const struct file_operations *fops)
272{
273	return do_register(net, statp->program->pg_name, statp, fops);
274}
275EXPORT_SYMBOL_GPL(svc_proc_register);
276
277void
278svc_proc_unregister(struct net *net, const char *name)
279{
280	struct sunrpc_net *sn;
281
282	sn = net_generic(net, sunrpc_net_id);
283	remove_proc_entry(name, sn->proc_net_rpc);
284}
285EXPORT_SYMBOL_GPL(svc_proc_unregister);
286
287int rpc_proc_init(struct net *net)
288{
289	struct sunrpc_net *sn;
290
291	dprintk("RPC:       registering /proc/net/rpc\n");
292	sn = net_generic(net, sunrpc_net_id);
293	sn->proc_net_rpc = proc_mkdir("rpc", net->proc_net);
294	if (sn->proc_net_rpc == NULL)
295		return -ENOMEM;
296
297	return 0;
298}
299
300void rpc_proc_exit(struct net *net)
301{
302	dprintk("RPC:       unregistering /proc/net/rpc\n");
303	remove_proc_entry("rpc", net->proc_net);
304}
305
306