2 * linux/net/sunrpc/stats.c
4 * procfs-based user access to generic RPC statistics. The stats files
5 * reside in /proc/net/rpc.
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
12 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
15 #include <linux/module.h>
16 #include <linux/slab.h>
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>
28 #define RPCDBG_FACILITY RPCDBG_MISC
31 * Get RPC client stats
33 static int rpc_proc_show(struct seq_file
*seq
, void *v
) {
34 const struct rpc_stat
*statp
= seq
->private;
35 const struct rpc_program
*prog
= statp
->program
;
48 statp
->rpcauthrefresh
);
50 for (i
= 0; i
< prog
->nrvers
; i
++) {
51 const struct rpc_version
*vers
= prog
->version
[i
];
54 seq_printf(seq
, "proc%u %u",
55 vers
->number
, vers
->nrprocs
);
56 for (j
= 0; j
< vers
->nrprocs
; j
++)
57 seq_printf(seq
, " %u",
58 vers
->procs
[j
].p_count
);
64 static int rpc_proc_open(struct inode
*inode
, struct file
*file
)
66 return single_open(file
, rpc_proc_show
, PDE(inode
)->data
);
69 static const struct file_operations rpc_proc_fops
= {
71 .open
= rpc_proc_open
,
74 .release
= single_release
,
78 * Get RPC server stats
80 void svc_seq_show(struct seq_file
*seq
, const struct svc_stat
*statp
) {
81 const struct svc_program
*prog
= statp
->program
;
82 const struct svc_procedure
*proc
;
83 const struct svc_version
*vers
;
93 "rpc %u %u %u %u %u\n",
95 statp
->rpcbadfmt
+statp
->rpcbadauth
+statp
->rpcbadclnt
,
100 for (i
= 0; i
< prog
->pg_nvers
; i
++) {
101 if (!(vers
= prog
->pg_vers
[i
]) || !(proc
= vers
->vs_proc
))
103 seq_printf(seq
, "proc%d %u", i
, vers
->vs_nproc
);
104 for (j
= 0; j
< vers
->vs_nproc
; j
++, proc
++)
105 seq_printf(seq
, " %u", proc
->pc_count
);
109 EXPORT_SYMBOL_GPL(svc_seq_show
);
112 * rpc_alloc_iostats - allocate an rpc_iostats structure
113 * @clnt: RPC program, version, and xprt
116 struct rpc_iostats
*rpc_alloc_iostats(struct rpc_clnt
*clnt
)
118 struct rpc_iostats
*new;
119 new = kcalloc(clnt
->cl_maxproc
, sizeof(struct rpc_iostats
), GFP_KERNEL
);
122 EXPORT_SYMBOL_GPL(rpc_alloc_iostats
);
125 * rpc_free_iostats - release an rpc_iostats structure
126 * @stats: doomed rpc_iostats structure
129 void rpc_free_iostats(struct rpc_iostats
*stats
)
133 EXPORT_SYMBOL_GPL(rpc_free_iostats
);
136 * rpc_count_iostats - tally up per-task stats
137 * @task: completed rpc_task
139 * Relies on the caller for serialization.
141 void rpc_count_iostats(struct rpc_task
*task
)
143 struct rpc_rqst
*req
= task
->tk_rqstp
;
144 struct rpc_iostats
*stats
;
145 struct rpc_iostats
*op_metrics
;
148 if (!task
->tk_client
|| !task
->tk_client
->cl_metrics
|| !req
)
151 stats
= task
->tk_client
->cl_metrics
;
152 op_metrics
= &stats
[task
->tk_msg
.rpc_proc
->p_statidx
];
154 op_metrics
->om_ops
++;
155 op_metrics
->om_ntrans
+= req
->rq_ntrans
;
156 op_metrics
->om_timeouts
+= task
->tk_timeouts
;
158 op_metrics
->om_bytes_sent
+= req
->rq_xmit_bytes_sent
;
159 op_metrics
->om_bytes_recv
+= req
->rq_reply_bytes_recvd
;
161 delta
= ktime_sub(req
->rq_xtime
, task
->tk_start
);
162 op_metrics
->om_queue
= ktime_add(op_metrics
->om_queue
, delta
);
164 op_metrics
->om_rtt
= ktime_add(op_metrics
->om_rtt
, req
->rq_rtt
);
166 delta
= ktime_sub(ktime_get(), task
->tk_start
);
167 op_metrics
->om_execute
= ktime_add(op_metrics
->om_execute
, delta
);
170 static void _print_name(struct seq_file
*seq
, unsigned int op
,
171 struct rpc_procinfo
*procs
)
173 if (procs
[op
].p_name
)
174 seq_printf(seq
, "\t%12s: ", procs
[op
].p_name
);
176 seq_printf(seq
, "\t NULL: ");
178 seq_printf(seq
, "\t%12u: ", op
);
181 void rpc_print_iostats(struct seq_file
*seq
, struct rpc_clnt
*clnt
)
183 struct rpc_iostats
*stats
= clnt
->cl_metrics
;
184 struct rpc_xprt
*xprt
= clnt
->cl_xprt
;
185 unsigned int op
, maxproc
= clnt
->cl_maxproc
;
190 seq_printf(seq
, "\tRPC iostats version: %s ", RPC_IOSTATS_VERS
);
191 seq_printf(seq
, "p/v: %u/%u (%s)\n",
192 clnt
->cl_prog
, clnt
->cl_vers
, clnt
->cl_protname
);
195 xprt
->ops
->print_stats(xprt
, seq
);
197 seq_printf(seq
, "\tper-op statistics\n");
198 for (op
= 0; op
< maxproc
; op
++) {
199 struct rpc_iostats
*metrics
= &stats
[op
];
200 _print_name(seq
, op
, clnt
->cl_procinfo
);
201 seq_printf(seq
, "%lu %lu %lu %Lu %Lu %Lu %Lu %Lu\n",
204 metrics
->om_timeouts
,
205 metrics
->om_bytes_sent
,
206 metrics
->om_bytes_recv
,
207 ktime_to_ms(metrics
->om_queue
),
208 ktime_to_ms(metrics
->om_rtt
),
209 ktime_to_ms(metrics
->om_execute
));
212 EXPORT_SYMBOL_GPL(rpc_print_iostats
);
215 * Register/unregister RPC proc files
217 static inline struct proc_dir_entry
*
218 do_register(const char *name
, void *data
, const struct file_operations
*fops
)
220 struct sunrpc_net
*sn
;
222 dprintk("RPC: registering /proc/net/rpc/%s\n", name
);
223 sn
= net_generic(&init_net
, sunrpc_net_id
);
224 return proc_create_data(name
, 0, sn
->proc_net_rpc
, fops
, data
);
227 struct proc_dir_entry
*
228 rpc_proc_register(struct rpc_stat
*statp
)
230 return do_register(statp
->program
->name
, statp
, &rpc_proc_fops
);
232 EXPORT_SYMBOL_GPL(rpc_proc_register
);
235 rpc_proc_unregister(const char *name
)
237 struct sunrpc_net
*sn
;
239 sn
= net_generic(&init_net
, sunrpc_net_id
);
240 remove_proc_entry(name
, sn
->proc_net_rpc
);
242 EXPORT_SYMBOL_GPL(rpc_proc_unregister
);
244 struct proc_dir_entry
*
245 svc_proc_register(struct svc_stat
*statp
, const struct file_operations
*fops
)
247 return do_register(statp
->program
->pg_name
, statp
, fops
);
249 EXPORT_SYMBOL_GPL(svc_proc_register
);
252 svc_proc_unregister(const char *name
)
254 struct sunrpc_net
*sn
;
256 sn
= net_generic(&init_net
, sunrpc_net_id
);
257 remove_proc_entry(name
, sn
->proc_net_rpc
);
259 EXPORT_SYMBOL_GPL(svc_proc_unregister
);
261 int rpc_proc_init(struct net
*net
)
263 struct sunrpc_net
*sn
;
265 dprintk("RPC: registering /proc/net/rpc\n");
266 sn
= net_generic(net
, sunrpc_net_id
);
267 sn
->proc_net_rpc
= proc_mkdir("rpc", net
->proc_net
);
268 if (sn
->proc_net_rpc
== NULL
)
274 void rpc_proc_exit(struct net
*net
)
276 dprintk("RPC: unregistering /proc/net/rpc\n");
277 remove_proc_entry("rpc", net
->proc_net
);