?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/panfrost: Remove set but not used variable 'bo'
[linux/fpc-iii.git] / include / trace / events / sunrpc.h
blobee993575d2fad63a2e87357863512eb2febc6009
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 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 DEFINE_RPC_STATUS_EVENT(call);
67 DEFINE_RPC_STATUS_EVENT(bind);
68 DEFINE_RPC_STATUS_EVENT(connect);
69
70 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 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 DEFINE_RPC_RUNNING_EVENT(begin);
186 DEFINE_RPC_RUNNING_EVENT(run_action);
187 DEFINE_RPC_RUNNING_EVENT(complete);
188 DEFINE_RPC_RUNNING_EVENT(signalled);
189 DEFINE_RPC_RUNNING_EVENT(end);
190
191 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 DEFINE_RPC_QUEUED_EVENT(sleep);
236 DEFINE_RPC_QUEUED_EVENT(wakeup);
237
238 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 DEFINE_RPC_FAILURE(callhdr);
266 DEFINE_RPC_FAILURE(verifier);
267
268 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 DEFINE_RPC_REPLY_EVENT(prog_unavail);
310 DEFINE_RPC_REPLY_EVENT(prog_mismatch);
311 DEFINE_RPC_REPLY_EVENT(proc_unavail);
312 DEFINE_RPC_REPLY_EVENT(garbage_args);
313 DEFINE_RPC_REPLY_EVENT(unparsable);
314 DEFINE_RPC_REPLY_EVENT(mismatch);
315 DEFINE_RPC_REPLY_EVENT(stale_creds);
316 DEFINE_RPC_REPLY_EVENT(bad_creds);
317 DEFINE_RPC_REPLY_EVENT(auth_tooweak);
318
319 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 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 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 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 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 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 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
673 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
674 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
675 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
676 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
677 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
678
679 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 DEFINE_RPC_XPRT_EVENT(timer);
716 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
717 DEFINE_RPC_XPRT_EVENT(complete_rqst);
718
719 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 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 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 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 DEFINE_WRITELOCK_EVENT(reserve_xprt);
842 DEFINE_WRITELOCK_EVENT(release_xprt);
843
844 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 DEFINE_CONG_EVENT(reserve_cong);
891 DEFINE_CONG_EVENT(release_cong);
892 DEFINE_CONG_EVENT(get_cong);
893 DEFINE_CONG_EVENT(put_cong);
894
895 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 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 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 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 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 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 DEFINE_SVC_RQST_EVENT(defer);
1079 DEFINE_SVC_RQST_EVENT(drop);
1080
1081 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 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 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 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 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
1174 TP_PROTO(struct svc_xprt *xprt),
1175 TP_ARGS(xprt));
1176
1177 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 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 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 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 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 DEFINE_SVC_DEFERRED_EVENT(drop);
1293 DEFINE_SVC_DEFERRED_EVENT(revisit);
1294
1295 #endif /* _TRACE_SUNRPC_H */
1296
1297 #include <trace/define_trace.h>
Linux with added FPC-III support