Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #undef TRACE_SYSTEM
3 : : #define TRACE_SYSTEM sunrpc
4 : :
5 : : #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
6 : : #define _TRACE_SUNRPC_H
7 : :
8 : : #include <linux/sunrpc/sched.h>
9 : : #include <linux/sunrpc/clnt.h>
10 : : #include <linux/sunrpc/svc.h>
11 : : #include <linux/sunrpc/xprtsock.h>
12 : : #include <linux/sunrpc/svc_xprt.h>
13 : : #include <net/tcp_states.h>
14 : : #include <linux/net.h>
15 : : #include <linux/tracepoint.h>
16 : :
17 : : TRACE_DEFINE_ENUM(RPC_AUTH_OK);
18 : : TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
19 : : TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
20 : : TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
21 : : TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
22 : : TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
23 : : TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
24 : : TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
25 : :
26 : : #define rpc_show_auth_stat(status) \
27 : : __print_symbolic(status, \
28 : : { RPC_AUTH_OK, "AUTH_OK" }, \
29 : : { RPC_AUTH_BADCRED, "BADCRED" }, \
30 : : { RPC_AUTH_REJECTEDCRED, "REJECTEDCRED" }, \
31 : : { RPC_AUTH_BADVERF, "BADVERF" }, \
32 : : { RPC_AUTH_REJECTEDVERF, "REJECTEDVERF" }, \
33 : : { RPC_AUTH_TOOWEAK, "TOOWEAK" }, \
34 : : { RPCSEC_GSS_CREDPROBLEM, "GSS_CREDPROBLEM" }, \
35 : : { RPCSEC_GSS_CTXPROBLEM, "GSS_CTXPROBLEM" }) \
36 : :
37 [ # # # # : 0 : DECLARE_EVENT_CLASS(rpc_task_status,
# # ]
38 : :
39 : : TP_PROTO(const struct rpc_task *task),
40 : :
41 : : TP_ARGS(task),
42 : :
43 : : TP_STRUCT__entry(
44 : : __field(unsigned int, task_id)
45 : : __field(unsigned int, client_id)
46 : : __field(int, status)
47 : : ),
48 : :
49 : : TP_fast_assign(
50 : : __entry->task_id = task->tk_pid;
51 : : __entry->client_id = task->tk_client->cl_clid;
52 : : __entry->status = task->tk_status;
53 : : ),
54 : :
55 : : TP_printk("task:%u@%u status=%d",
56 : : __entry->task_id, __entry->client_id,
57 : : __entry->status)
58 : : );
59 : : #define DEFINE_RPC_STATUS_EVENT(name) \
60 : : DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
61 : : TP_PROTO( \
62 : : const struct rpc_task *task \
63 : : ), \
64 : : TP_ARGS(task))
65 : :
66 [ # # # # : 0 : DEFINE_RPC_STATUS_EVENT(call);
# # # # ]
67 [ # # # # : 0 : DEFINE_RPC_STATUS_EVENT(bind);
# # # # ]
68 [ # # # # : 0 : DEFINE_RPC_STATUS_EVENT(connect);
# # # # ]
69 : :
70 [ # # # # : 0 : TRACE_EVENT(rpc_request,
# # # # #
# ]
71 : : TP_PROTO(const struct rpc_task *task),
72 : :
73 : : TP_ARGS(task),
74 : :
75 : : TP_STRUCT__entry(
76 : : __field(unsigned int, task_id)
77 : : __field(unsigned int, client_id)
78 : : __field(int, version)
79 : : __field(bool, async)
80 : : __string(progname, task->tk_client->cl_program->name)
81 : : __string(procname, rpc_proc_name(task))
82 : : ),
83 : :
84 : : TP_fast_assign(
85 : : __entry->task_id = task->tk_pid;
86 : : __entry->client_id = task->tk_client->cl_clid;
87 : : __entry->version = task->tk_client->cl_vers;
88 : : __entry->async = RPC_IS_ASYNC(task);
89 : : __assign_str(progname, task->tk_client->cl_program->name)
90 : : __assign_str(procname, rpc_proc_name(task))
91 : : ),
92 : :
93 : : TP_printk("task:%u@%u %sv%d %s (%ssync)",
94 : : __entry->task_id, __entry->client_id,
95 : : __get_str(progname), __entry->version,
96 : : __get_str(procname), __entry->async ? "a": ""
97 : : )
98 : : );
99 : :
100 : : TRACE_DEFINE_ENUM(RPC_TASK_ASYNC);
101 : : TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER);
102 : : TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN);
103 : : TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS);
104 : : TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC);
105 : : TRACE_DEFINE_ENUM(RPC_TASK_SOFT);
106 : : TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN);
107 : : TRACE_DEFINE_ENUM(RPC_TASK_SENT);
108 : : TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT);
109 : : TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT);
110 : : TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT);
111 : :
112 : : #define rpc_show_task_flags(flags) \
113 : : __print_flags(flags, "|", \
114 : : { RPC_TASK_ASYNC, "ASYNC" }, \
115 : : { RPC_TASK_SWAPPER, "SWAPPER" }, \
116 : : { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \
117 : : { RPC_TASK_ROOTCREDS, "ROOTCREDS" }, \
118 : : { RPC_TASK_DYNAMIC, "DYNAMIC" }, \
119 : : { RPC_TASK_SOFT, "SOFT" }, \
120 : : { RPC_TASK_SOFTCONN, "SOFTCONN" }, \
121 : : { RPC_TASK_SENT, "SENT" }, \
122 : : { RPC_TASK_TIMEOUT, "TIMEOUT" }, \
123 : : { RPC_TASK_NOCONNECT, "NOCONNECT" }, \
124 : : { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" })
125 : :
126 : : TRACE_DEFINE_ENUM(RPC_TASK_RUNNING);
127 : : TRACE_DEFINE_ENUM(RPC_TASK_QUEUED);
128 : : TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE);
129 : : TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT);
130 : : TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV);
131 : : TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT);
132 : : TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED);
133 : :
134 : : #define rpc_show_runstate(flags) \
135 : : __print_flags(flags, "|", \
136 : : { (1UL << RPC_TASK_RUNNING), "RUNNING" }, \
137 : : { (1UL << RPC_TASK_QUEUED), "QUEUED" }, \
138 : : { (1UL << RPC_TASK_ACTIVE), "ACTIVE" }, \
139 : : { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" }, \
140 : : { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" }, \
141 : : { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \
142 : : { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
143 : :
144 [ # # # # : 0 : DECLARE_EVENT_CLASS(rpc_task_running,
# # # # ]
145 : :
146 : : TP_PROTO(const struct rpc_task *task, const void *action),
147 : :
148 : : TP_ARGS(task, action),
149 : :
150 : : TP_STRUCT__entry(
151 : : __field(unsigned int, task_id)
152 : : __field(unsigned int, client_id)
153 : : __field(const void *, action)
154 : : __field(unsigned long, runstate)
155 : : __field(int, status)
156 : : __field(unsigned short, flags)
157 : : ),
158 : :
159 : : TP_fast_assign(
160 : : __entry->client_id = task->tk_client ?
161 : : task->tk_client->cl_clid : -1;
162 : : __entry->task_id = task->tk_pid;
163 : : __entry->action = action;
164 : : __entry->runstate = task->tk_runstate;
165 : : __entry->status = task->tk_status;
166 : : __entry->flags = task->tk_flags;
167 : : ),
168 : :
169 : : TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps",
170 : : __entry->task_id, __entry->client_id,
171 : : rpc_show_task_flags(__entry->flags),
172 : : rpc_show_runstate(__entry->runstate),
173 : : __entry->status,
174 : : __entry->action
175 : : )
176 : : );
177 : : #define DEFINE_RPC_RUNNING_EVENT(name) \
178 : : DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
179 : : TP_PROTO( \
180 : : const struct rpc_task *task, \
181 : : const void *action \
182 : : ), \
183 : : TP_ARGS(task, action))
184 : :
185 [ # # # # : 0 : DEFINE_RPC_RUNNING_EVENT(begin);
# # # # ]
186 [ # # # # : 0 : DEFINE_RPC_RUNNING_EVENT(run_action);
# # # # ]
187 [ # # # # : 0 : DEFINE_RPC_RUNNING_EVENT(complete);
# # # # ]
188 [ # # # # : 0 : DEFINE_RPC_RUNNING_EVENT(signalled);
# # # # ]
189 [ # # # # : 0 : DEFINE_RPC_RUNNING_EVENT(end);
# # # # ]
190 : :
191 [ # # # # : 0 : DECLARE_EVENT_CLASS(rpc_task_queued,
# # # # #
# # # #
# ]
192 : :
193 : : TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
194 : :
195 : : TP_ARGS(task, q),
196 : :
197 : : TP_STRUCT__entry(
198 : : __field(unsigned int, task_id)
199 : : __field(unsigned int, client_id)
200 : : __field(unsigned long, timeout)
201 : : __field(unsigned long, runstate)
202 : : __field(int, status)
203 : : __field(unsigned short, flags)
204 : : __string(q_name, rpc_qname(q))
205 : : ),
206 : :
207 : : TP_fast_assign(
208 : : __entry->client_id = task->tk_client ?
209 : : task->tk_client->cl_clid : -1;
210 : : __entry->task_id = task->tk_pid;
211 : : __entry->timeout = rpc_task_timeout(task);
212 : : __entry->runstate = task->tk_runstate;
213 : : __entry->status = task->tk_status;
214 : : __entry->flags = task->tk_flags;
215 : : __assign_str(q_name, rpc_qname(q));
216 : : ),
217 : :
218 : : TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
219 : : __entry->task_id, __entry->client_id,
220 : : rpc_show_task_flags(__entry->flags),
221 : : rpc_show_runstate(__entry->runstate),
222 : : __entry->status,
223 : : __entry->timeout,
224 : : __get_str(q_name)
225 : : )
226 : : );
227 : : #define DEFINE_RPC_QUEUED_EVENT(name) \
228 : : DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
229 : : TP_PROTO( \
230 : : const struct rpc_task *task, \
231 : : const struct rpc_wait_queue *q \
232 : : ), \
233 : : TP_ARGS(task, q))
234 : :
235 [ # # # # : 0 : DEFINE_RPC_QUEUED_EVENT(sleep);
# # # # ]
236 [ # # # # : 0 : DEFINE_RPC_QUEUED_EVENT(wakeup);
# # # # ]
237 : :
238 [ # # # # : 0 : DECLARE_EVENT_CLASS(rpc_failure,
# # ]
239 : :
240 : : TP_PROTO(const struct rpc_task *task),
241 : :
242 : : TP_ARGS(task),
243 : :
244 : : TP_STRUCT__entry(
245 : : __field(unsigned int, task_id)
246 : : __field(unsigned int, client_id)
247 : : ),
248 : :
249 : : TP_fast_assign(
250 : : __entry->task_id = task->tk_pid;
251 : : __entry->client_id = task->tk_client->cl_clid;
252 : : ),
253 : :
254 : : TP_printk("task:%u@%u",
255 : : __entry->task_id, __entry->client_id)
256 : : );
257 : :
258 : : #define DEFINE_RPC_FAILURE(name) \
259 : : DEFINE_EVENT(rpc_failure, rpc_bad_##name, \
260 : : TP_PROTO( \
261 : : const struct rpc_task *task \
262 : : ), \
263 : : TP_ARGS(task))
264 : :
265 [ # # # # : 0 : DEFINE_RPC_FAILURE(callhdr);
# # # # ]
266 [ # # # # : 0 : DEFINE_RPC_FAILURE(verifier);
# # # # ]
267 : :
268 [ # # # # : 0 : DECLARE_EVENT_CLASS(rpc_reply_event,
# # # # #
# # # ]
269 : :
270 : : TP_PROTO(
271 : : const struct rpc_task *task
272 : : ),
273 : :
274 : : TP_ARGS(task),
275 : :
276 : : TP_STRUCT__entry(
277 : : __field(unsigned int, task_id)
278 : : __field(unsigned int, client_id)
279 : : __field(u32, xid)
280 : : __string(progname, task->tk_client->cl_program->name)
281 : : __field(u32, version)
282 : : __string(procname, rpc_proc_name(task))
283 : : __string(servername, task->tk_xprt->servername)
284 : : ),
285 : :
286 : : TP_fast_assign(
287 : : __entry->task_id = task->tk_pid;
288 : : __entry->client_id = task->tk_client->cl_clid;
289 : : __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
290 : : __assign_str(progname, task->tk_client->cl_program->name)
291 : : __entry->version = task->tk_client->cl_vers;
292 : : __assign_str(procname, rpc_proc_name(task))
293 : : __assign_str(servername, task->tk_xprt->servername)
294 : : ),
295 : :
296 : : TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
297 : : __entry->task_id, __entry->client_id, __get_str(servername),
298 : : __entry->xid, __get_str(progname), __entry->version,
299 : : __get_str(procname))
300 : : )
301 : :
302 : : #define DEFINE_RPC_REPLY_EVENT(name) \
303 : : DEFINE_EVENT(rpc_reply_event, rpc__##name, \
304 : : TP_PROTO( \
305 : : const struct rpc_task *task \
306 : : ), \
307 : : TP_ARGS(task))
308 : :
309 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(prog_unavail);
# # # # ]
310 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(prog_mismatch);
# # # # ]
311 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(proc_unavail);
# # # # ]
312 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(garbage_args);
# # # # ]
313 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(unparsable);
# # # # ]
314 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(mismatch);
# # # # ]
315 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(stale_creds);
# # # # ]
316 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(bad_creds);
# # # # ]
317 [ # # # # : 0 : DEFINE_RPC_REPLY_EVENT(auth_tooweak);
# # # # ]
318 : :
319 [ # # # # : 0 : TRACE_EVENT(rpc_stats_latency,
# # # # #
# ]
320 : :
321 : : TP_PROTO(
322 : : const struct rpc_task *task,
323 : : ktime_t backlog,
324 : : ktime_t rtt,
325 : : ktime_t execute
326 : : ),
327 : :
328 : : TP_ARGS(task, backlog, rtt, execute),
329 : :
330 : : TP_STRUCT__entry(
331 : : __field(unsigned int, task_id)
332 : : __field(unsigned int, client_id)
333 : : __field(u32, xid)
334 : : __field(int, version)
335 : : __string(progname, task->tk_client->cl_program->name)
336 : : __string(procname, rpc_proc_name(task))
337 : : __field(unsigned long, backlog)
338 : : __field(unsigned long, rtt)
339 : : __field(unsigned long, execute)
340 : : ),
341 : :
342 : : TP_fast_assign(
343 : : __entry->client_id = task->tk_client->cl_clid;
344 : : __entry->task_id = task->tk_pid;
345 : : __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
346 : : __entry->version = task->tk_client->cl_vers;
347 : : __assign_str(progname, task->tk_client->cl_program->name)
348 : : __assign_str(procname, rpc_proc_name(task))
349 : : __entry->backlog = ktime_to_us(backlog);
350 : : __entry->rtt = ktime_to_us(rtt);
351 : : __entry->execute = ktime_to_us(execute);
352 : : ),
353 : :
354 : : TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
355 : : __entry->task_id, __entry->client_id, __entry->xid,
356 : : __get_str(progname), __entry->version, __get_str(procname),
357 : : __entry->backlog, __entry->rtt, __entry->execute)
358 : : );
359 : :
360 [ # # # # : 0 : TRACE_EVENT(rpc_xdr_overflow,
# # # # #
# # # ]
361 : : TP_PROTO(
362 : : const struct xdr_stream *xdr,
363 : : size_t requested
364 : : ),
365 : :
366 : : TP_ARGS(xdr, requested),
367 : :
368 : : TP_STRUCT__entry(
369 : : __field(unsigned int, task_id)
370 : : __field(unsigned int, client_id)
371 : : __field(int, version)
372 : : __field(size_t, requested)
373 : : __field(const void *, end)
374 : : __field(const void *, p)
375 : : __field(const void *, head_base)
376 : : __field(size_t, head_len)
377 : : __field(const void *, tail_base)
378 : : __field(size_t, tail_len)
379 : : __field(unsigned int, page_len)
380 : : __field(unsigned int, len)
381 : : __string(progname,
382 : : xdr->rqst->rq_task->tk_client->cl_program->name)
383 : : __string(procedure,
384 : : xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
385 : : ),
386 : :
387 : : TP_fast_assign(
388 : : if (xdr->rqst) {
389 : : const struct rpc_task *task = xdr->rqst->rq_task;
390 : :
391 : : __entry->task_id = task->tk_pid;
392 : : __entry->client_id = task->tk_client->cl_clid;
393 : : __assign_str(progname,
394 : : task->tk_client->cl_program->name)
395 : : __entry->version = task->tk_client->cl_vers;
396 : : __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
397 : : } else {
398 : : __entry->task_id = 0;
399 : : __entry->client_id = 0;
400 : : __assign_str(progname, "unknown")
401 : : __entry->version = 0;
402 : : __assign_str(procedure, "unknown")
403 : : }
404 : : __entry->requested = requested;
405 : : __entry->end = xdr->end;
406 : : __entry->p = xdr->p;
407 : : __entry->head_base = xdr->buf->head[0].iov_base,
408 : : __entry->head_len = xdr->buf->head[0].iov_len,
409 : : __entry->page_len = xdr->buf->page_len,
410 : : __entry->tail_base = xdr->buf->tail[0].iov_base,
411 : : __entry->tail_len = xdr->buf->tail[0].iov_len,
412 : : __entry->len = xdr->buf->len;
413 : : ),
414 : :
415 : : TP_printk(
416 : : "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
417 : : __entry->task_id, __entry->client_id,
418 : : __get_str(progname), __entry->version, __get_str(procedure),
419 : : __entry->requested, __entry->p, __entry->end,
420 : : __entry->head_base, __entry->head_len,
421 : : __entry->page_len,
422 : : __entry->tail_base, __entry->tail_len,
423 : : __entry->len
424 : : )
425 : : );
426 : :
427 [ # # # # : 0 : TRACE_EVENT(rpc_xdr_alignment,
# # # # #
# ]
428 : : TP_PROTO(
429 : : const struct xdr_stream *xdr,
430 : : size_t offset,
431 : : unsigned int copied
432 : : ),
433 : :
434 : : TP_ARGS(xdr, offset, copied),
435 : :
436 : : TP_STRUCT__entry(
437 : : __field(unsigned int, task_id)
438 : : __field(unsigned int, client_id)
439 : : __field(int, version)
440 : : __field(size_t, offset)
441 : : __field(unsigned int, copied)
442 : : __field(const void *, head_base)
443 : : __field(size_t, head_len)
444 : : __field(const void *, tail_base)
445 : : __field(size_t, tail_len)
446 : : __field(unsigned int, page_len)
447 : : __field(unsigned int, len)
448 : : __string(progname,
449 : : xdr->rqst->rq_task->tk_client->cl_program->name)
450 : : __string(procedure,
451 : : xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
452 : : ),
453 : :
454 : : TP_fast_assign(
455 : : const struct rpc_task *task = xdr->rqst->rq_task;
456 : :
457 : : __entry->task_id = task->tk_pid;
458 : : __entry->client_id = task->tk_client->cl_clid;
459 : : __assign_str(progname,
460 : : task->tk_client->cl_program->name)
461 : : __entry->version = task->tk_client->cl_vers;
462 : : __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
463 : :
464 : : __entry->offset = offset;
465 : : __entry->copied = copied;
466 : : __entry->head_base = xdr->buf->head[0].iov_base,
467 : : __entry->head_len = xdr->buf->head[0].iov_len,
468 : : __entry->page_len = xdr->buf->page_len,
469 : : __entry->tail_base = xdr->buf->tail[0].iov_base,
470 : : __entry->tail_len = xdr->buf->tail[0].iov_len,
471 : : __entry->len = xdr->buf->len;
472 : : ),
473 : :
474 : : TP_printk(
475 : : "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
476 : : __entry->task_id, __entry->client_id,
477 : : __get_str(progname), __entry->version, __get_str(procedure),
478 : : __entry->offset, __entry->copied,
479 : : __entry->head_base, __entry->head_len,
480 : : __entry->page_len,
481 : : __entry->tail_base, __entry->tail_len,
482 : : __entry->len
483 : : )
484 : : );
485 : :
486 [ # # # # : 0 : TRACE_EVENT(rpc_reply_pages,
# # # # ]
487 : : TP_PROTO(
488 : : const struct rpc_rqst *req
489 : : ),
490 : :
491 : : TP_ARGS(req),
492 : :
493 : : TP_STRUCT__entry(
494 : : __field(unsigned int, task_id)
495 : : __field(unsigned int, client_id)
496 : : __field(const void *, head_base)
497 : : __field(size_t, head_len)
498 : : __field(const void *, tail_base)
499 : : __field(size_t, tail_len)
500 : : __field(unsigned int, page_len)
501 : : ),
502 : :
503 : : TP_fast_assign(
504 : : __entry->task_id = req->rq_task->tk_pid;
505 : : __entry->client_id = req->rq_task->tk_client->cl_clid;
506 : :
507 : : __entry->head_base = req->rq_rcv_buf.head[0].iov_base;
508 : : __entry->head_len = req->rq_rcv_buf.head[0].iov_len;
509 : : __entry->page_len = req->rq_rcv_buf.page_len;
510 : : __entry->tail_base = req->rq_rcv_buf.tail[0].iov_base;
511 : : __entry->tail_len = req->rq_rcv_buf.tail[0].iov_len;
512 : : ),
513 : :
514 : : TP_printk(
515 : : "task:%u@%u xdr=[%p,%zu]/%u/[%p,%zu]\n",
516 : : __entry->task_id, __entry->client_id,
517 : : __entry->head_base, __entry->head_len,
518 : : __entry->page_len,
519 : : __entry->tail_base, __entry->tail_len
520 : : )
521 : : );
522 : :
523 : : /*
524 : : * First define the enums in the below macros to be exported to userspace
525 : : * via TRACE_DEFINE_ENUM().
526 : : */
527 : : #undef EM
528 : : #undef EMe
529 : : #define EM(a, b) TRACE_DEFINE_ENUM(a);
530 : : #define EMe(a, b) TRACE_DEFINE_ENUM(a);
531 : :
532 : : #define RPC_SHOW_SOCKET \
533 : : EM( SS_FREE, "FREE" ) \
534 : : EM( SS_UNCONNECTED, "UNCONNECTED" ) \
535 : : EM( SS_CONNECTING, "CONNECTING," ) \
536 : : EM( SS_CONNECTED, "CONNECTED," ) \
537 : : EMe(SS_DISCONNECTING, "DISCONNECTING" )
538 : :
539 : : #define rpc_show_socket_state(state) \
540 : : __print_symbolic(state, RPC_SHOW_SOCKET)
541 : :
542 : : RPC_SHOW_SOCKET
543 : :
544 : : #define RPC_SHOW_SOCK \
545 : : EM( TCP_ESTABLISHED, "ESTABLISHED" ) \
546 : : EM( TCP_SYN_SENT, "SYN_SENT" ) \
547 : : EM( TCP_SYN_RECV, "SYN_RECV" ) \
548 : : EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \
549 : : EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \
550 : : EM( TCP_TIME_WAIT, "TIME_WAIT" ) \
551 : : EM( TCP_CLOSE, "CLOSE" ) \
552 : : EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \
553 : : EM( TCP_LAST_ACK, "LAST_ACK" ) \
554 : : EM( TCP_LISTEN, "LISTEN" ) \
555 : : EMe( TCP_CLOSING, "CLOSING" )
556 : :
557 : : #define rpc_show_sock_state(state) \
558 : : __print_symbolic(state, RPC_SHOW_SOCK)
559 : :
560 : : RPC_SHOW_SOCK
561 : :
562 : : /*
563 : : * Now redefine the EM() and EMe() macros to map the enums to the strings
564 : : * that will be printed in the output.
565 : : */
566 : : #undef EM
567 : : #undef EMe
568 : : #define EM(a, b) {a, b},
569 : : #define EMe(a, b) {a, b}
570 : :
571 [ # # # # : 0 : DECLARE_EVENT_CLASS(xs_socket_event,
# # # # #
# ]
572 : :
573 : : TP_PROTO(
574 : : struct rpc_xprt *xprt,
575 : : struct socket *socket
576 : : ),
577 : :
578 : : TP_ARGS(xprt, socket),
579 : :
580 : : TP_STRUCT__entry(
581 : : __field(unsigned int, socket_state)
582 : : __field(unsigned int, sock_state)
583 : : __field(unsigned long long, ino)
584 : : __string(dstaddr,
585 : : xprt->address_strings[RPC_DISPLAY_ADDR])
586 : : __string(dstport,
587 : : xprt->address_strings[RPC_DISPLAY_PORT])
588 : : ),
589 : :
590 : : TP_fast_assign(
591 : : struct inode *inode = SOCK_INODE(socket);
592 : : __entry->socket_state = socket->state;
593 : : __entry->sock_state = socket->sk->sk_state;
594 : : __entry->ino = (unsigned long long)inode->i_ino;
595 : : __assign_str(dstaddr,
596 : : xprt->address_strings[RPC_DISPLAY_ADDR]);
597 : : __assign_str(dstport,
598 : : xprt->address_strings[RPC_DISPLAY_PORT]);
599 : : ),
600 : :
601 : : TP_printk(
602 : : "socket:[%llu] dstaddr=%s/%s "
603 : : "state=%u (%s) sk_state=%u (%s)",
604 : : __entry->ino, __get_str(dstaddr), __get_str(dstport),
605 : : __entry->socket_state,
606 : : rpc_show_socket_state(__entry->socket_state),
607 : : __entry->sock_state,
608 : : rpc_show_sock_state(__entry->sock_state)
609 : : )
610 : : );
611 : : #define DEFINE_RPC_SOCKET_EVENT(name) \
612 : : DEFINE_EVENT(xs_socket_event, name, \
613 : : TP_PROTO( \
614 : : struct rpc_xprt *xprt, \
615 : : struct socket *socket \
616 : : ), \
617 : : TP_ARGS(xprt, socket))
618 : :
619 [ # # # # : 0 : DECLARE_EVENT_CLASS(xs_socket_event_done,
# # # # #
# ]
620 : :
621 : : TP_PROTO(
622 : : struct rpc_xprt *xprt,
623 : : struct socket *socket,
624 : : int error
625 : : ),
626 : :
627 : : TP_ARGS(xprt, socket, error),
628 : :
629 : : TP_STRUCT__entry(
630 : : __field(int, error)
631 : : __field(unsigned int, socket_state)
632 : : __field(unsigned int, sock_state)
633 : : __field(unsigned long long, ino)
634 : : __string(dstaddr,
635 : : xprt->address_strings[RPC_DISPLAY_ADDR])
636 : : __string(dstport,
637 : : xprt->address_strings[RPC_DISPLAY_PORT])
638 : : ),
639 : :
640 : : TP_fast_assign(
641 : : struct inode *inode = SOCK_INODE(socket);
642 : : __entry->socket_state = socket->state;
643 : : __entry->sock_state = socket->sk->sk_state;
644 : : __entry->ino = (unsigned long long)inode->i_ino;
645 : : __entry->error = error;
646 : : __assign_str(dstaddr,
647 : : xprt->address_strings[RPC_DISPLAY_ADDR]);
648 : : __assign_str(dstport,
649 : : xprt->address_strings[RPC_DISPLAY_PORT]);
650 : : ),
651 : :
652 : : TP_printk(
653 : : "error=%d socket:[%llu] dstaddr=%s/%s "
654 : : "state=%u (%s) sk_state=%u (%s)",
655 : : __entry->error,
656 : : __entry->ino, __get_str(dstaddr), __get_str(dstport),
657 : : __entry->socket_state,
658 : : rpc_show_socket_state(__entry->socket_state),
659 : : __entry->sock_state,
660 : : rpc_show_sock_state(__entry->sock_state)
661 : : )
662 : : );
663 : : #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
664 : : DEFINE_EVENT(xs_socket_event_done, name, \
665 : : TP_PROTO( \
666 : : struct rpc_xprt *xprt, \
667 : : struct socket *socket, \
668 : : int error \
669 : : ), \
670 : : TP_ARGS(xprt, socket, error))
671 : :
672 [ # # # # : 0 : DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
# # # # ]
673 [ # # # # : 0 : DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
# # # # ]
674 [ # # # # : 0 : DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
# # # # ]
675 : : DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
676 [ # # # # : 0 : DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
# # # # ]
677 [ # # # # : 0 : DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
# # # # ]
678 : :
679 [ # # # # : 0 : DECLARE_EVENT_CLASS(rpc_xprt_event,
# # # # #
# ]
680 : : TP_PROTO(
681 : : const struct rpc_xprt *xprt,
682 : : __be32 xid,
683 : : int status
684 : : ),
685 : :
686 : : TP_ARGS(xprt, xid, status),
687 : :
688 : : TP_STRUCT__entry(
689 : : __field(u32, xid)
690 : : __field(int, status)
691 : : __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
692 : : __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
693 : : ),
694 : :
695 : : TP_fast_assign(
696 : : __entry->xid = be32_to_cpu(xid);
697 : : __entry->status = status;
698 : : __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
699 : : __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
700 : : ),
701 : :
702 : : TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
703 : : __get_str(port), __entry->xid,
704 : : __entry->status)
705 : : );
706 : : #define DEFINE_RPC_XPRT_EVENT(name) \
707 : : DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
708 : : TP_PROTO( \
709 : : const struct rpc_xprt *xprt, \
710 : : __be32 xid, \
711 : : int status \
712 : : ), \
713 : : TP_ARGS(xprt, xid, status))
714 : :
715 [ # # # # : 0 : DEFINE_RPC_XPRT_EVENT(timer);
# # # # ]
716 [ # # # # : 0 : DEFINE_RPC_XPRT_EVENT(lookup_rqst);
# # # # ]
717 [ # # # # : 0 : DEFINE_RPC_XPRT_EVENT(complete_rqst);
# # # # ]
718 : :
719 [ # # # # : 0 : TRACE_EVENT(xprt_transmit,
# # # # ]
720 : : TP_PROTO(
721 : : const struct rpc_rqst *rqst,
722 : : int status
723 : : ),
724 : :
725 : : TP_ARGS(rqst, status),
726 : :
727 : : TP_STRUCT__entry(
728 : : __field(unsigned int, task_id)
729 : : __field(unsigned int, client_id)
730 : : __field(u32, xid)
731 : : __field(u32, seqno)
732 : : __field(int, status)
733 : : ),
734 : :
735 : : TP_fast_assign(
736 : : __entry->task_id = rqst->rq_task->tk_pid;
737 : : __entry->client_id = rqst->rq_task->tk_client ?
738 : : rqst->rq_task->tk_client->cl_clid : -1;
739 : : __entry->xid = be32_to_cpu(rqst->rq_xid);
740 : : __entry->seqno = rqst->rq_seqno;
741 : : __entry->status = status;
742 : : ),
743 : :
744 : : TP_printk(
745 : : "task:%u@%u xid=0x%08x seqno=%u status=%d",
746 : : __entry->task_id, __entry->client_id, __entry->xid,
747 : : __entry->seqno, __entry->status)
748 : : );
749 : :
750 [ # # # # : 0 : TRACE_EVENT(xprt_enq_xmit,
# # # # ]
751 : : TP_PROTO(
752 : : const struct rpc_task *task,
753 : : int stage
754 : : ),
755 : :
756 : : TP_ARGS(task, stage),
757 : :
758 : : TP_STRUCT__entry(
759 : : __field(unsigned int, task_id)
760 : : __field(unsigned int, client_id)
761 : : __field(u32, xid)
762 : : __field(u32, seqno)
763 : : __field(int, stage)
764 : : ),
765 : :
766 : : TP_fast_assign(
767 : : __entry->task_id = task->tk_pid;
768 : : __entry->client_id = task->tk_client ?
769 : : task->tk_client->cl_clid : -1;
770 : : __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
771 : : __entry->seqno = task->tk_rqstp->rq_seqno;
772 : : __entry->stage = stage;
773 : : ),
774 : :
775 : : TP_printk(
776 : : "task:%u@%u xid=0x%08x seqno=%u stage=%d",
777 : : __entry->task_id, __entry->client_id, __entry->xid,
778 : : __entry->seqno, __entry->stage)
779 : : );
780 : :
781 [ # # # # : 0 : TRACE_EVENT(xprt_ping,
# # # # #
# ]
782 : : TP_PROTO(const struct rpc_xprt *xprt, int status),
783 : :
784 : : TP_ARGS(xprt, status),
785 : :
786 : : TP_STRUCT__entry(
787 : : __field(int, status)
788 : : __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
789 : : __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
790 : : ),
791 : :
792 : : TP_fast_assign(
793 : : __entry->status = status;
794 : : __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
795 : : __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
796 : : ),
797 : :
798 : : TP_printk("peer=[%s]:%s status=%d",
799 : : __get_str(addr), __get_str(port), __entry->status)
800 : : );
801 : :
802 [ # # # # : 0 : DECLARE_EVENT_CLASS(xprt_writelock_event,
# # # # #
# # # ]
803 : : TP_PROTO(
804 : : const struct rpc_xprt *xprt, const struct rpc_task *task
805 : : ),
806 : :
807 : : TP_ARGS(xprt, task),
808 : :
809 : : TP_STRUCT__entry(
810 : : __field(unsigned int, task_id)
811 : : __field(unsigned int, client_id)
812 : : __field(unsigned int, snd_task_id)
813 : : ),
814 : :
815 : : TP_fast_assign(
816 : : if (task) {
817 : : __entry->task_id = task->tk_pid;
818 : : __entry->client_id = task->tk_client ?
819 : : task->tk_client->cl_clid : -1;
820 : : } else {
821 : : __entry->task_id = -1;
822 : : __entry->client_id = -1;
823 : : }
824 : : __entry->snd_task_id = xprt->snd_task ?
825 : : xprt->snd_task->tk_pid : -1;
826 : : ),
827 : :
828 : : TP_printk("task:%u@%u snd_task:%u",
829 : : __entry->task_id, __entry->client_id,
830 : : __entry->snd_task_id)
831 : : );
832 : :
833 : : #define DEFINE_WRITELOCK_EVENT(name) \
834 : : DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
835 : : TP_PROTO( \
836 : : const struct rpc_xprt *xprt, \
837 : : const struct rpc_task *task \
838 : : ), \
839 : : TP_ARGS(xprt, task))
840 : :
841 [ # # # # : 0 : DEFINE_WRITELOCK_EVENT(reserve_xprt);
# # # # ]
842 [ # # # # : 0 : DEFINE_WRITELOCK_EVENT(release_xprt);
# # # # ]
843 : :
844 [ # # # # : 0 : DECLARE_EVENT_CLASS(xprt_cong_event,
# # # # #
# # # ]
845 : : TP_PROTO(
846 : : const struct rpc_xprt *xprt, const struct rpc_task *task
847 : : ),
848 : :
849 : : TP_ARGS(xprt, task),
850 : :
851 : : TP_STRUCT__entry(
852 : : __field(unsigned int, task_id)
853 : : __field(unsigned int, client_id)
854 : : __field(unsigned int, snd_task_id)
855 : : __field(unsigned long, cong)
856 : : __field(unsigned long, cwnd)
857 : : __field(bool, wait)
858 : : ),
859 : :
860 : : TP_fast_assign(
861 : : if (task) {
862 : : __entry->task_id = task->tk_pid;
863 : : __entry->client_id = task->tk_client ?
864 : : task->tk_client->cl_clid : -1;
865 : : } else {
866 : : __entry->task_id = -1;
867 : : __entry->client_id = -1;
868 : : }
869 : : __entry->snd_task_id = xprt->snd_task ?
870 : : xprt->snd_task->tk_pid : -1;
871 : : __entry->cong = xprt->cong;
872 : : __entry->cwnd = xprt->cwnd;
873 : : __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
874 : : ),
875 : :
876 : : TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s",
877 : : __entry->task_id, __entry->client_id,
878 : : __entry->snd_task_id, __entry->cong, __entry->cwnd,
879 : : __entry->wait ? " (wait)" : "")
880 : : );
881 : :
882 : : #define DEFINE_CONG_EVENT(name) \
883 : : DEFINE_EVENT(xprt_cong_event, xprt_##name, \
884 : : TP_PROTO( \
885 : : const struct rpc_xprt *xprt, \
886 : : const struct rpc_task *task \
887 : : ), \
888 : : TP_ARGS(xprt, task))
889 : :
890 [ # # # # : 0 : DEFINE_CONG_EVENT(reserve_cong);
# # # # ]
891 [ # # # # : 0 : DEFINE_CONG_EVENT(release_cong);
# # # # ]
892 [ # # # # : 0 : DEFINE_CONG_EVENT(get_cong);
# # # # ]
893 [ # # # # : 0 : DEFINE_CONG_EVENT(put_cong);
# # # # ]
894 : :
895 [ # # # # : 0 : TRACE_EVENT(xs_stream_read_data,
# # # # #
# # # # #
# # # # ]
896 : : TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
897 : :
898 : : TP_ARGS(xprt, err, total),
899 : :
900 : : TP_STRUCT__entry(
901 : : __field(ssize_t, err)
902 : : __field(size_t, total)
903 : : __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
904 : : "(null)")
905 : : __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
906 : : "(null)")
907 : : ),
908 : :
909 : : TP_fast_assign(
910 : : __entry->err = err;
911 : : __entry->total = total;
912 : : __assign_str(addr, xprt ?
913 : : xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
914 : : __assign_str(port, xprt ?
915 : : xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
916 : : ),
917 : :
918 : : TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
919 : : __get_str(port), __entry->err, __entry->total)
920 : : );
921 : :
922 [ # # # # : 0 : TRACE_EVENT(xs_stream_read_request,
# # # # #
# ]
923 : : TP_PROTO(struct sock_xprt *xs),
924 : :
925 : : TP_ARGS(xs),
926 : :
927 : : TP_STRUCT__entry(
928 : : __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
929 : : __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
930 : : __field(u32, xid)
931 : : __field(unsigned long, copied)
932 : : __field(unsigned int, reclen)
933 : : __field(unsigned int, offset)
934 : : ),
935 : :
936 : : TP_fast_assign(
937 : : __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
938 : : __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
939 : : __entry->xid = be32_to_cpu(xs->recv.xid);
940 : : __entry->copied = xs->recv.copied;
941 : : __entry->reclen = xs->recv.len;
942 : : __entry->offset = xs->recv.offset;
943 : : ),
944 : :
945 : : TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
946 : : __get_str(addr), __get_str(port), __entry->xid,
947 : : __entry->copied, __entry->reclen, __entry->offset)
948 : : );
949 : :
950 : : #define show_rqstp_flags(flags) \
951 : : __print_flags(flags, "|", \
952 : : { (1UL << RQ_SECURE), "RQ_SECURE"}, \
953 : : { (1UL << RQ_LOCAL), "RQ_LOCAL"}, \
954 : : { (1UL << RQ_USEDEFERRAL), "RQ_USEDEFERRAL"}, \
955 : : { (1UL << RQ_DROPME), "RQ_DROPME"}, \
956 : : { (1UL << RQ_SPLICE_OK), "RQ_SPLICE_OK"}, \
957 : : { (1UL << RQ_VICTIM), "RQ_VICTIM"}, \
958 : : { (1UL << RQ_BUSY), "RQ_BUSY"})
959 : :
960 [ # # # # : 0 : TRACE_EVENT(svc_recv,
# # # # #
# ]
961 : : TP_PROTO(struct svc_rqst *rqst, int len),
962 : :
963 : : TP_ARGS(rqst, len),
964 : :
965 : : TP_STRUCT__entry(
966 : : __field(u32, xid)
967 : : __field(int, len)
968 : : __field(unsigned long, flags)
969 : : __string(addr, rqst->rq_xprt->xpt_remotebuf)
970 : : ),
971 : :
972 : : TP_fast_assign(
973 : : __entry->xid = be32_to_cpu(rqst->rq_xid);
974 : : __entry->len = len;
975 : : __entry->flags = rqst->rq_flags;
976 : : __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
977 : : ),
978 : :
979 : : TP_printk("addr=%s xid=0x%08x len=%d flags=%s",
980 : : __get_str(addr), __entry->xid, __entry->len,
981 : : show_rqstp_flags(__entry->flags))
982 : : );
983 : :
984 : : #define svc_show_status(status) \
985 : : __print_symbolic(status, \
986 : : { SVC_GARBAGE, "SVC_GARBAGE" }, \
987 : : { SVC_SYSERR, "SVC_SYSERR" }, \
988 : : { SVC_VALID, "SVC_VALID" }, \
989 : : { SVC_NEGATIVE, "SVC_NEGATIVE" }, \
990 : : { SVC_OK, "SVC_OK" }, \
991 : : { SVC_DROP, "SVC_DROP" }, \
992 : : { SVC_CLOSE, "SVC_CLOSE" }, \
993 : : { SVC_DENIED, "SVC_DENIED" }, \
994 : : { SVC_PENDING, "SVC_PENDING" }, \
995 : : { SVC_COMPLETE, "SVC_COMPLETE" })
996 : :
997 [ # # # # : 0 : TRACE_EVENT(svc_authenticate,
# # # # ]
998 : : TP_PROTO(const struct svc_rqst *rqst, int auth_res, __be32 auth_stat),
999 : :
1000 : : TP_ARGS(rqst, auth_res, auth_stat),
1001 : :
1002 : : TP_STRUCT__entry(
1003 : : __field(u32, xid)
1004 : : __field(unsigned long, svc_status)
1005 : : __field(unsigned long, auth_stat)
1006 : : ),
1007 : :
1008 : : TP_fast_assign(
1009 : : __entry->xid = be32_to_cpu(rqst->rq_xid);
1010 : : __entry->svc_status = auth_res;
1011 : : __entry->auth_stat = be32_to_cpu(auth_stat);
1012 : : ),
1013 : :
1014 : : TP_printk("xid=0x%08x auth_res=%s auth_stat=%s",
1015 : : __entry->xid, svc_show_status(__entry->svc_status),
1016 : : rpc_show_auth_stat(__entry->auth_stat))
1017 : : );
1018 : :
1019 [ # # # # : 0 : TRACE_EVENT(svc_process,
# # # # #
# # # #
# ]
1020 : : TP_PROTO(const struct svc_rqst *rqst, const char *name),
1021 : :
1022 : : TP_ARGS(rqst, name),
1023 : :
1024 : : TP_STRUCT__entry(
1025 : : __field(u32, xid)
1026 : : __field(u32, vers)
1027 : : __field(u32, proc)
1028 : : __string(service, name)
1029 : : __string(addr, rqst->rq_xprt ?
1030 : : rqst->rq_xprt->xpt_remotebuf : "(null)")
1031 : : ),
1032 : :
1033 : : TP_fast_assign(
1034 : : __entry->xid = be32_to_cpu(rqst->rq_xid);
1035 : : __entry->vers = rqst->rq_vers;
1036 : : __entry->proc = rqst->rq_proc;
1037 : : __assign_str(service, name);
1038 : : __assign_str(addr, rqst->rq_xprt ?
1039 : : rqst->rq_xprt->xpt_remotebuf : "(null)");
1040 : : ),
1041 : :
1042 : : TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%u",
1043 : : __get_str(addr), __entry->xid,
1044 : : __get_str(service), __entry->vers, __entry->proc)
1045 : : );
1046 : :
1047 [ # # # # : 0 : DECLARE_EVENT_CLASS(svc_rqst_event,
# # # # #
# ]
1048 : :
1049 : : TP_PROTO(
1050 : : const struct svc_rqst *rqst
1051 : : ),
1052 : :
1053 : : TP_ARGS(rqst),
1054 : :
1055 : : TP_STRUCT__entry(
1056 : : __field(u32, xid)
1057 : : __field(unsigned long, flags)
1058 : : __string(addr, rqst->rq_xprt->xpt_remotebuf)
1059 : : ),
1060 : :
1061 : : TP_fast_assign(
1062 : : __entry->xid = be32_to_cpu(rqst->rq_xid);
1063 : : __entry->flags = rqst->rq_flags;
1064 : : __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1065 : : ),
1066 : :
1067 : : TP_printk("addr=%s xid=0x%08x flags=%s",
1068 : : __get_str(addr), __entry->xid,
1069 : : show_rqstp_flags(__entry->flags))
1070 : : );
1071 : : #define DEFINE_SVC_RQST_EVENT(name) \
1072 : : DEFINE_EVENT(svc_rqst_event, svc_##name, \
1073 : : TP_PROTO( \
1074 : : const struct svc_rqst *rqst \
1075 : : ), \
1076 : : TP_ARGS(rqst))
1077 : :
1078 [ # # # # : 0 : DEFINE_SVC_RQST_EVENT(defer);
# # # # ]
1079 [ # # # # : 0 : DEFINE_SVC_RQST_EVENT(drop);
# # # # ]
1080 : :
1081 [ # # # # : 0 : DECLARE_EVENT_CLASS(svc_rqst_status,
# # # # #
# ]
1082 : :
1083 : : TP_PROTO(struct svc_rqst *rqst, int status),
1084 : :
1085 : : TP_ARGS(rqst, status),
1086 : :
1087 : : TP_STRUCT__entry(
1088 : : __field(u32, xid)
1089 : : __field(int, status)
1090 : : __field(unsigned long, flags)
1091 : : __string(addr, rqst->rq_xprt->xpt_remotebuf)
1092 : : ),
1093 : :
1094 : : TP_fast_assign(
1095 : : __entry->xid = be32_to_cpu(rqst->rq_xid);
1096 : : __entry->status = status;
1097 : : __entry->flags = rqst->rq_flags;
1098 : : __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1099 : : ),
1100 : :
1101 : : TP_printk("addr=%s xid=0x%08x status=%d flags=%s",
1102 : : __get_str(addr), __entry->xid,
1103 : : __entry->status, show_rqstp_flags(__entry->flags))
1104 : : );
1105 : :
1106 [ # # # # : 0 : DEFINE_EVENT(svc_rqst_status, svc_send,
# # # # ]
1107 : : TP_PROTO(struct svc_rqst *rqst, int status),
1108 : : TP_ARGS(rqst, status));
1109 : :
1110 : : #define show_svc_xprt_flags(flags) \
1111 : : __print_flags(flags, "|", \
1112 : : { (1UL << XPT_BUSY), "XPT_BUSY"}, \
1113 : : { (1UL << XPT_CONN), "XPT_CONN"}, \
1114 : : { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \
1115 : : { (1UL << XPT_DATA), "XPT_DATA"}, \
1116 : : { (1UL << XPT_TEMP), "XPT_TEMP"}, \
1117 : : { (1UL << XPT_DEAD), "XPT_DEAD"}, \
1118 : : { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \
1119 : : { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \
1120 : : { (1UL << XPT_OLD), "XPT_OLD"}, \
1121 : : { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \
1122 : : { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \
1123 : : { (1UL << XPT_LOCAL), "XPT_LOCAL"}, \
1124 : : { (1UL << XPT_KILL_TEMP), "XPT_KILL_TEMP"}, \
1125 : : { (1UL << XPT_CONG_CTRL), "XPT_CONG_CTRL"})
1126 : :
1127 [ # # # # : 0 : TRACE_EVENT(svc_xprt_do_enqueue,
# # # # #
# # # ]
1128 : : TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
1129 : :
1130 : : TP_ARGS(xprt, rqst),
1131 : :
1132 : : TP_STRUCT__entry(
1133 : : __field(struct svc_xprt *, xprt)
1134 : : __field(int, pid)
1135 : : __field(unsigned long, flags)
1136 : : __string(addr, xprt->xpt_remotebuf)
1137 : : ),
1138 : :
1139 : : TP_fast_assign(
1140 : : __entry->xprt = xprt;
1141 : : __entry->pid = rqst? rqst->rq_task->pid : 0;
1142 : : __entry->flags = xprt->xpt_flags;
1143 : : __assign_str(addr, xprt->xpt_remotebuf);
1144 : : ),
1145 : :
1146 : : TP_printk("xprt=%p addr=%s pid=%d flags=%s",
1147 : : __entry->xprt, __get_str(addr),
1148 : : __entry->pid, show_svc_xprt_flags(__entry->flags))
1149 : : );
1150 : :
1151 [ # # # # : 0 : DECLARE_EVENT_CLASS(svc_xprt_event,
# # # # #
# ]
1152 : : TP_PROTO(struct svc_xprt *xprt),
1153 : :
1154 : : TP_ARGS(xprt),
1155 : :
1156 : : TP_STRUCT__entry(
1157 : : __field(struct svc_xprt *, xprt)
1158 : : __field(unsigned long, flags)
1159 : : __string(addr, xprt->xpt_remotebuf)
1160 : : ),
1161 : :
1162 : : TP_fast_assign(
1163 : : __entry->xprt = xprt;
1164 : : __entry->flags = xprt->xpt_flags;
1165 : : __assign_str(addr, xprt->xpt_remotebuf);
1166 : : ),
1167 : :
1168 : : TP_printk("xprt=%p addr=%s flags=%s",
1169 : : __entry->xprt, __get_str(addr),
1170 : : show_svc_xprt_flags(__entry->flags))
1171 : : );
1172 : :
1173 [ # # # # : 0 : DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
# # # # ]
1174 : : TP_PROTO(struct svc_xprt *xprt),
1175 : : TP_ARGS(xprt));
1176 : :
1177 [ # # # # : 0 : TRACE_EVENT(svc_xprt_dequeue,
# # # # #
# ]
1178 : : TP_PROTO(struct svc_rqst *rqst),
1179 : :
1180 : : TP_ARGS(rqst),
1181 : :
1182 : : TP_STRUCT__entry(
1183 : : __field(struct svc_xprt *, xprt)
1184 : : __field(unsigned long, flags)
1185 : : __field(unsigned long, wakeup)
1186 : : __string(addr, rqst->rq_xprt->xpt_remotebuf)
1187 : : ),
1188 : :
1189 : : TP_fast_assign(
1190 : : __entry->xprt = rqst->rq_xprt;
1191 : : __entry->flags = rqst->rq_xprt->xpt_flags;
1192 : : __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1193 : : rqst->rq_qtime));
1194 : : __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1195 : : ),
1196 : :
1197 : : TP_printk("xprt=%p addr=%s flags=%s wakeup-us=%lu",
1198 : : __entry->xprt, __get_str(addr),
1199 : : show_svc_xprt_flags(__entry->flags),
1200 : : __entry->wakeup)
1201 : : );
1202 : :
1203 [ # # # # : 0 : TRACE_EVENT(svc_wake_up,
# # # # ]
1204 : : TP_PROTO(int pid),
1205 : :
1206 : : TP_ARGS(pid),
1207 : :
1208 : : TP_STRUCT__entry(
1209 : : __field(int, pid)
1210 : : ),
1211 : :
1212 : : TP_fast_assign(
1213 : : __entry->pid = pid;
1214 : : ),
1215 : :
1216 : : TP_printk("pid=%d", __entry->pid)
1217 : : );
1218 : :
1219 [ # # # # : 0 : TRACE_EVENT(svc_handle_xprt,
# # # # #
# ]
1220 : : TP_PROTO(struct svc_xprt *xprt, int len),
1221 : :
1222 : : TP_ARGS(xprt, len),
1223 : :
1224 : : TP_STRUCT__entry(
1225 : : __field(struct svc_xprt *, xprt)
1226 : : __field(int, len)
1227 : : __field(unsigned long, flags)
1228 : : __string(addr, xprt->xpt_remotebuf)
1229 : : ),
1230 : :
1231 : : TP_fast_assign(
1232 : : __entry->xprt = xprt;
1233 : : __entry->len = len;
1234 : : __entry->flags = xprt->xpt_flags;
1235 : : __assign_str(addr, xprt->xpt_remotebuf);
1236 : : ),
1237 : :
1238 : : TP_printk("xprt=%p addr=%s len=%d flags=%s",
1239 : : __entry->xprt, __get_str(addr),
1240 : : __entry->len, show_svc_xprt_flags(__entry->flags))
1241 : : );
1242 : :
1243 [ # # # # : 0 : TRACE_EVENT(svc_stats_latency,
# # # # #
# ]
1244 : : TP_PROTO(const struct svc_rqst *rqst),
1245 : :
1246 : : TP_ARGS(rqst),
1247 : :
1248 : : TP_STRUCT__entry(
1249 : : __field(u32, xid)
1250 : : __field(unsigned long, execute)
1251 : : __string(addr, rqst->rq_xprt->xpt_remotebuf)
1252 : : ),
1253 : :
1254 : : TP_fast_assign(
1255 : : __entry->xid = be32_to_cpu(rqst->rq_xid);
1256 : : __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1257 : : rqst->rq_stime));
1258 : : __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1259 : : ),
1260 : :
1261 : : TP_printk("addr=%s xid=0x%08x execute-us=%lu",
1262 : : __get_str(addr), __entry->xid, __entry->execute)
1263 : : );
1264 : :
1265 [ # # # # : 0 : DECLARE_EVENT_CLASS(svc_deferred_event,
# # # # #
# ]
1266 : : TP_PROTO(
1267 : : const struct svc_deferred_req *dr
1268 : : ),
1269 : :
1270 : : TP_ARGS(dr),
1271 : :
1272 : : TP_STRUCT__entry(
1273 : : __field(u32, xid)
1274 : : __string(addr, dr->xprt->xpt_remotebuf)
1275 : : ),
1276 : :
1277 : : TP_fast_assign(
1278 : : __entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
1279 : : (dr->xprt_hlen>>2)));
1280 : : __assign_str(addr, dr->xprt->xpt_remotebuf);
1281 : : ),
1282 : :
1283 : : TP_printk("addr=%s xid=0x%08x", __get_str(addr), __entry->xid)
1284 : : );
1285 : : #define DEFINE_SVC_DEFERRED_EVENT(name) \
1286 : : DEFINE_EVENT(svc_deferred_event, svc_##name##_deferred, \
1287 : : TP_PROTO( \
1288 : : const struct svc_deferred_req *dr \
1289 : : ), \
1290 : : TP_ARGS(dr))
1291 : :
1292 [ # # # # : 0 : DEFINE_SVC_DEFERRED_EVENT(drop);
# # # # ]
1293 [ # # # # : 0 : DEFINE_SVC_DEFERRED_EVENT(revisit);
# # # # ]
1294 : :
1295 : : #endif /* _TRACE_SUNRPC_H */
1296 : :
1297 : : #include <trace/define_trace.h>
|
