]>
Commit | Line | Data |
---|---|---|
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 | DECLARE_EVENT_CLASS(rpc_task_status, | |
18 | ||
19 | TP_PROTO(struct rpc_task *task), | |
20 | ||
21 | TP_ARGS(task), | |
22 | ||
23 | TP_STRUCT__entry( | |
24 | __field(unsigned int, task_id) | |
25 | __field(unsigned int, client_id) | |
26 | __field(int, status) | |
27 | ), | |
28 | ||
29 | TP_fast_assign( | |
30 | __entry->task_id = task->tk_pid; | |
31 | __entry->client_id = task->tk_client->cl_clid; | |
32 | __entry->status = task->tk_status; | |
33 | ), | |
34 | ||
35 | TP_printk("task:%u@%u, status %d", | |
36 | __entry->task_id, __entry->client_id, | |
37 | __entry->status) | |
38 | ); | |
39 | ||
40 | DEFINE_EVENT(rpc_task_status, rpc_call_status, | |
41 | TP_PROTO(struct rpc_task *task), | |
42 | ||
43 | TP_ARGS(task) | |
44 | ); | |
45 | ||
46 | DEFINE_EVENT(rpc_task_status, rpc_bind_status, | |
47 | TP_PROTO(struct rpc_task *task), | |
48 | ||
49 | TP_ARGS(task) | |
50 | ); | |
51 | ||
52 | TRACE_EVENT(rpc_connect_status, | |
53 | TP_PROTO(struct rpc_task *task, int status), | |
54 | ||
55 | TP_ARGS(task, status), | |
56 | ||
57 | TP_STRUCT__entry( | |
58 | __field(unsigned int, task_id) | |
59 | __field(unsigned int, client_id) | |
60 | __field(int, status) | |
61 | ), | |
62 | ||
63 | TP_fast_assign( | |
64 | __entry->task_id = task->tk_pid; | |
65 | __entry->client_id = task->tk_client->cl_clid; | |
66 | __entry->status = status; | |
67 | ), | |
68 | ||
69 | TP_printk("task:%u@%u, status %d", | |
70 | __entry->task_id, __entry->client_id, | |
71 | __entry->status) | |
72 | ); | |
73 | ||
74 | TRACE_EVENT(rpc_request, | |
75 | TP_PROTO(const struct rpc_task *task), | |
76 | ||
77 | TP_ARGS(task), | |
78 | ||
79 | TP_STRUCT__entry( | |
80 | __field(unsigned int, task_id) | |
81 | __field(unsigned int, client_id) | |
82 | __field(int, version) | |
83 | __field(bool, async) | |
84 | __string(progname, task->tk_client->cl_program->name) | |
85 | __string(procname, rpc_proc_name(task)) | |
86 | ), | |
87 | ||
88 | TP_fast_assign( | |
89 | __entry->task_id = task->tk_pid; | |
90 | __entry->client_id = task->tk_client->cl_clid; | |
91 | __entry->version = task->tk_client->cl_vers; | |
92 | __entry->async = RPC_IS_ASYNC(task); | |
93 | __assign_str(progname, task->tk_client->cl_program->name) | |
94 | __assign_str(procname, rpc_proc_name(task)) | |
95 | ), | |
96 | ||
97 | TP_printk("task:%u@%u %sv%d %s (%ssync)", | |
98 | __entry->task_id, __entry->client_id, | |
99 | __get_str(progname), __entry->version, | |
100 | __get_str(procname), __entry->async ? "a": "" | |
101 | ) | |
102 | ); | |
103 | ||
104 | DECLARE_EVENT_CLASS(rpc_task_running, | |
105 | ||
106 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
107 | ||
108 | TP_ARGS(clnt, task, action), | |
109 | ||
110 | TP_STRUCT__entry( | |
111 | __field(unsigned int, task_id) | |
112 | __field(unsigned int, client_id) | |
113 | __field(const void *, action) | |
114 | __field(unsigned long, runstate) | |
115 | __field(int, status) | |
116 | __field(unsigned short, flags) | |
117 | ), | |
118 | ||
119 | TP_fast_assign( | |
120 | __entry->client_id = clnt ? clnt->cl_clid : -1; | |
121 | __entry->task_id = task->tk_pid; | |
122 | __entry->action = action; | |
123 | __entry->runstate = task->tk_runstate; | |
124 | __entry->status = task->tk_status; | |
125 | __entry->flags = task->tk_flags; | |
126 | ), | |
127 | ||
128 | TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf", | |
129 | __entry->task_id, __entry->client_id, | |
130 | __entry->flags, | |
131 | __entry->runstate, | |
132 | __entry->status, | |
133 | __entry->action | |
134 | ) | |
135 | ); | |
136 | ||
137 | DEFINE_EVENT(rpc_task_running, rpc_task_begin, | |
138 | ||
139 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
140 | ||
141 | TP_ARGS(clnt, task, action) | |
142 | ||
143 | ); | |
144 | ||
145 | DEFINE_EVENT(rpc_task_running, rpc_task_run_action, | |
146 | ||
147 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
148 | ||
149 | TP_ARGS(clnt, task, action) | |
150 | ||
151 | ); | |
152 | ||
153 | DEFINE_EVENT(rpc_task_running, rpc_task_complete, | |
154 | ||
155 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
156 | ||
157 | TP_ARGS(clnt, task, action) | |
158 | ||
159 | ); | |
160 | ||
161 | DECLARE_EVENT_CLASS(rpc_task_queued, | |
162 | ||
163 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), | |
164 | ||
165 | TP_ARGS(clnt, task, q), | |
166 | ||
167 | TP_STRUCT__entry( | |
168 | __field(unsigned int, task_id) | |
169 | __field(unsigned int, client_id) | |
170 | __field(unsigned long, timeout) | |
171 | __field(unsigned long, runstate) | |
172 | __field(int, status) | |
173 | __field(unsigned short, flags) | |
174 | __string(q_name, rpc_qname(q)) | |
175 | ), | |
176 | ||
177 | TP_fast_assign( | |
178 | __entry->client_id = clnt->cl_clid; | |
179 | __entry->task_id = task->tk_pid; | |
180 | __entry->timeout = task->tk_timeout; | |
181 | __entry->runstate = task->tk_runstate; | |
182 | __entry->status = task->tk_status; | |
183 | __entry->flags = task->tk_flags; | |
184 | __assign_str(q_name, rpc_qname(q)); | |
185 | ), | |
186 | ||
187 | TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s", | |
188 | __entry->task_id, __entry->client_id, | |
189 | __entry->flags, | |
190 | __entry->runstate, | |
191 | __entry->status, | |
192 | __entry->timeout, | |
193 | __get_str(q_name) | |
194 | ) | |
195 | ); | |
196 | ||
197 | DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, | |
198 | ||
199 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), | |
200 | ||
201 | TP_ARGS(clnt, task, q) | |
202 | ||
203 | ); | |
204 | ||
205 | DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, | |
206 | ||
207 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), | |
208 | ||
209 | TP_ARGS(clnt, task, q) | |
210 | ||
211 | ); | |
212 | ||
213 | /* | |
214 | * First define the enums in the below macros to be exported to userspace | |
215 | * via TRACE_DEFINE_ENUM(). | |
216 | */ | |
217 | #undef EM | |
218 | #undef EMe | |
219 | #define EM(a, b) TRACE_DEFINE_ENUM(a); | |
220 | #define EMe(a, b) TRACE_DEFINE_ENUM(a); | |
221 | ||
222 | #define RPC_SHOW_SOCKET \ | |
223 | EM( SS_FREE, "FREE" ) \ | |
224 | EM( SS_UNCONNECTED, "UNCONNECTED" ) \ | |
225 | EM( SS_CONNECTING, "CONNECTING," ) \ | |
226 | EM( SS_CONNECTED, "CONNECTED," ) \ | |
227 | EMe(SS_DISCONNECTING, "DISCONNECTING" ) | |
228 | ||
229 | #define rpc_show_socket_state(state) \ | |
230 | __print_symbolic(state, RPC_SHOW_SOCKET) | |
231 | ||
232 | RPC_SHOW_SOCKET | |
233 | ||
234 | #define RPC_SHOW_SOCK \ | |
235 | EM( TCP_ESTABLISHED, "ESTABLISHED" ) \ | |
236 | EM( TCP_SYN_SENT, "SYN_SENT" ) \ | |
237 | EM( TCP_SYN_RECV, "SYN_RECV" ) \ | |
238 | EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \ | |
239 | EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \ | |
240 | EM( TCP_TIME_WAIT, "TIME_WAIT" ) \ | |
241 | EM( TCP_CLOSE, "CLOSE" ) \ | |
242 | EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \ | |
243 | EM( TCP_LAST_ACK, "LAST_ACK" ) \ | |
244 | EM( TCP_LISTEN, "LISTEN" ) \ | |
245 | EMe( TCP_CLOSING, "CLOSING" ) | |
246 | ||
247 | #define rpc_show_sock_state(state) \ | |
248 | __print_symbolic(state, RPC_SHOW_SOCK) | |
249 | ||
250 | RPC_SHOW_SOCK | |
251 | ||
252 | /* | |
253 | * Now redefine the EM() and EMe() macros to map the enums to the strings | |
254 | * that will be printed in the output. | |
255 | */ | |
256 | #undef EM | |
257 | #undef EMe | |
258 | #define EM(a, b) {a, b}, | |
259 | #define EMe(a, b) {a, b} | |
260 | ||
261 | DECLARE_EVENT_CLASS(xs_socket_event, | |
262 | ||
263 | TP_PROTO( | |
264 | struct rpc_xprt *xprt, | |
265 | struct socket *socket | |
266 | ), | |
267 | ||
268 | TP_ARGS(xprt, socket), | |
269 | ||
270 | TP_STRUCT__entry( | |
271 | __field(unsigned int, socket_state) | |
272 | __field(unsigned int, sock_state) | |
273 | __field(unsigned long long, ino) | |
274 | __string(dstaddr, | |
275 | xprt->address_strings[RPC_DISPLAY_ADDR]) | |
276 | __string(dstport, | |
277 | xprt->address_strings[RPC_DISPLAY_PORT]) | |
278 | ), | |
279 | ||
280 | TP_fast_assign( | |
281 | struct inode *inode = SOCK_INODE(socket); | |
282 | __entry->socket_state = socket->state; | |
283 | __entry->sock_state = socket->sk->sk_state; | |
284 | __entry->ino = (unsigned long long)inode->i_ino; | |
285 | __assign_str(dstaddr, | |
286 | xprt->address_strings[RPC_DISPLAY_ADDR]); | |
287 | __assign_str(dstport, | |
288 | xprt->address_strings[RPC_DISPLAY_PORT]); | |
289 | ), | |
290 | ||
291 | TP_printk( | |
292 | "socket:[%llu] dstaddr=%s/%s " | |
293 | "state=%u (%s) sk_state=%u (%s)", | |
294 | __entry->ino, __get_str(dstaddr), __get_str(dstport), | |
295 | __entry->socket_state, | |
296 | rpc_show_socket_state(__entry->socket_state), | |
297 | __entry->sock_state, | |
298 | rpc_show_sock_state(__entry->sock_state) | |
299 | ) | |
300 | ); | |
301 | #define DEFINE_RPC_SOCKET_EVENT(name) \ | |
302 | DEFINE_EVENT(xs_socket_event, name, \ | |
303 | TP_PROTO( \ | |
304 | struct rpc_xprt *xprt, \ | |
305 | struct socket *socket \ | |
306 | ), \ | |
307 | TP_ARGS(xprt, socket)) | |
308 | ||
309 | DECLARE_EVENT_CLASS(xs_socket_event_done, | |
310 | ||
311 | TP_PROTO( | |
312 | struct rpc_xprt *xprt, | |
313 | struct socket *socket, | |
314 | int error | |
315 | ), | |
316 | ||
317 | TP_ARGS(xprt, socket, error), | |
318 | ||
319 | TP_STRUCT__entry( | |
320 | __field(int, error) | |
321 | __field(unsigned int, socket_state) | |
322 | __field(unsigned int, sock_state) | |
323 | __field(unsigned long long, ino) | |
324 | __string(dstaddr, | |
325 | xprt->address_strings[RPC_DISPLAY_ADDR]) | |
326 | __string(dstport, | |
327 | xprt->address_strings[RPC_DISPLAY_PORT]) | |
328 | ), | |
329 | ||
330 | TP_fast_assign( | |
331 | struct inode *inode = SOCK_INODE(socket); | |
332 | __entry->socket_state = socket->state; | |
333 | __entry->sock_state = socket->sk->sk_state; | |
334 | __entry->ino = (unsigned long long)inode->i_ino; | |
335 | __entry->error = error; | |
336 | __assign_str(dstaddr, | |
337 | xprt->address_strings[RPC_DISPLAY_ADDR]); | |
338 | __assign_str(dstport, | |
339 | xprt->address_strings[RPC_DISPLAY_PORT]); | |
340 | ), | |
341 | ||
342 | TP_printk( | |
343 | "error=%d socket:[%llu] dstaddr=%s/%s " | |
344 | "state=%u (%s) sk_state=%u (%s)", | |
345 | __entry->error, | |
346 | __entry->ino, __get_str(dstaddr), __get_str(dstport), | |
347 | __entry->socket_state, | |
348 | rpc_show_socket_state(__entry->socket_state), | |
349 | __entry->sock_state, | |
350 | rpc_show_sock_state(__entry->sock_state) | |
351 | ) | |
352 | ); | |
353 | #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \ | |
354 | DEFINE_EVENT(xs_socket_event_done, name, \ | |
355 | TP_PROTO( \ | |
356 | struct rpc_xprt *xprt, \ | |
357 | struct socket *socket, \ | |
358 | int error \ | |
359 | ), \ | |
360 | TP_ARGS(xprt, socket, error)) | |
361 | ||
362 | DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); | |
363 | DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); | |
364 | DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); | |
365 | DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); | |
366 | DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); | |
367 | DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); | |
368 | ||
369 | DECLARE_EVENT_CLASS(rpc_xprt_event, | |
370 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
371 | ||
372 | TP_ARGS(xprt, xid, status), | |
373 | ||
374 | TP_STRUCT__entry( | |
375 | __field(u32, xid) | |
376 | __field(int, status) | |
377 | __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) | |
378 | __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) | |
379 | ), | |
380 | ||
381 | TP_fast_assign( | |
382 | __entry->xid = be32_to_cpu(xid); | |
383 | __entry->status = status; | |
384 | __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); | |
385 | __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); | |
386 | ), | |
387 | ||
388 | TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr), | |
389 | __get_str(port), __entry->xid, | |
390 | __entry->status) | |
391 | ); | |
392 | ||
393 | DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, | |
394 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
395 | TP_ARGS(xprt, xid, status)); | |
396 | ||
397 | DEFINE_EVENT(rpc_xprt_event, xprt_transmit, | |
398 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
399 | TP_ARGS(xprt, xid, status)); | |
400 | ||
401 | DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, | |
402 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
403 | TP_ARGS(xprt, xid, status)); | |
404 | ||
405 | TRACE_EVENT(xs_tcp_data_ready, | |
406 | TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), | |
407 | ||
408 | TP_ARGS(xprt, err, total), | |
409 | ||
410 | TP_STRUCT__entry( | |
411 | __field(int, err) | |
412 | __field(unsigned int, total) | |
413 | __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] : | |
414 | "(null)") | |
415 | __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] : | |
416 | "(null)") | |
417 | ), | |
418 | ||
419 | TP_fast_assign( | |
420 | __entry->err = err; | |
421 | __entry->total = total; | |
422 | __assign_str(addr, xprt ? | |
423 | xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)"); | |
424 | __assign_str(port, xprt ? | |
425 | xprt->address_strings[RPC_DISPLAY_PORT] : "(null)"); | |
426 | ), | |
427 | ||
428 | TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr), | |
429 | __get_str(port), __entry->err, __entry->total) | |
430 | ); | |
431 | ||
432 | #define rpc_show_sock_xprt_flags(flags) \ | |
433 | __print_flags(flags, "|", \ | |
434 | { TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \ | |
435 | { TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \ | |
436 | { TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \ | |
437 | { TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \ | |
438 | { TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \ | |
439 | { TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \ | |
440 | { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) | |
441 | ||
442 | TRACE_EVENT(xs_tcp_data_recv, | |
443 | TP_PROTO(struct sock_xprt *xs), | |
444 | ||
445 | TP_ARGS(xs), | |
446 | ||
447 | TP_STRUCT__entry( | |
448 | __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]) | |
449 | __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]) | |
450 | __field(u32, xid) | |
451 | __field(unsigned long, flags) | |
452 | __field(unsigned long, copied) | |
453 | __field(unsigned int, reclen) | |
454 | __field(unsigned long, offset) | |
455 | ), | |
456 | ||
457 | TP_fast_assign( | |
458 | __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]); | |
459 | __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]); | |
460 | __entry->xid = be32_to_cpu(xs->tcp_xid); | |
461 | __entry->flags = xs->tcp_flags; | |
462 | __entry->copied = xs->tcp_copied; | |
463 | __entry->reclen = xs->tcp_reclen; | |
464 | __entry->offset = xs->tcp_offset; | |
465 | ), | |
466 | ||
467 | TP_printk("peer=[%s]:%s xid=0x%08x flags=%s copied=%lu reclen=%u offset=%lu", | |
468 | __get_str(addr), __get_str(port), __entry->xid, | |
469 | rpc_show_sock_xprt_flags(__entry->flags), | |
470 | __entry->copied, __entry->reclen, __entry->offset) | |
471 | ); | |
472 | ||
473 | #define show_rqstp_flags(flags) \ | |
474 | __print_flags(flags, "|", \ | |
475 | { (1UL << RQ_SECURE), "RQ_SECURE"}, \ | |
476 | { (1UL << RQ_LOCAL), "RQ_LOCAL"}, \ | |
477 | { (1UL << RQ_USEDEFERRAL), "RQ_USEDEFERRAL"}, \ | |
478 | { (1UL << RQ_DROPME), "RQ_DROPME"}, \ | |
479 | { (1UL << RQ_SPLICE_OK), "RQ_SPLICE_OK"}, \ | |
480 | { (1UL << RQ_VICTIM), "RQ_VICTIM"}, \ | |
481 | { (1UL << RQ_BUSY), "RQ_BUSY"}) | |
482 | ||
483 | TRACE_EVENT(svc_recv, | |
484 | TP_PROTO(struct svc_rqst *rqst, int status), | |
485 | ||
486 | TP_ARGS(rqst, status), | |
487 | ||
488 | TP_STRUCT__entry( | |
489 | __field(u32, xid) | |
490 | __field(int, status) | |
491 | __field(unsigned long, flags) | |
492 | __dynamic_array(unsigned char, addr, rqst->rq_addrlen) | |
493 | ), | |
494 | ||
495 | TP_fast_assign( | |
496 | __entry->xid = status > 0 ? be32_to_cpu(rqst->rq_xid) : 0; | |
497 | __entry->status = status; | |
498 | __entry->flags = rqst->rq_flags; | |
499 | memcpy(__get_dynamic_array(addr), | |
500 | &rqst->rq_addr, rqst->rq_addrlen); | |
501 | ), | |
502 | ||
503 | TP_printk("addr=%pIScp xid=0x%08x status=%d flags=%s", | |
504 | (struct sockaddr *)__get_dynamic_array(addr), | |
505 | __entry->xid, __entry->status, | |
506 | show_rqstp_flags(__entry->flags)) | |
507 | ); | |
508 | ||
509 | DECLARE_EVENT_CLASS(svc_rqst_event, | |
510 | ||
511 | TP_PROTO(struct svc_rqst *rqst), | |
512 | ||
513 | TP_ARGS(rqst), | |
514 | ||
515 | TP_STRUCT__entry( | |
516 | __field(u32, xid) | |
517 | __field(unsigned long, flags) | |
518 | __dynamic_array(unsigned char, addr, rqst->rq_addrlen) | |
519 | ), | |
520 | ||
521 | TP_fast_assign( | |
522 | __entry->xid = be32_to_cpu(rqst->rq_xid); | |
523 | __entry->flags = rqst->rq_flags; | |
524 | memcpy(__get_dynamic_array(addr), | |
525 | &rqst->rq_addr, rqst->rq_addrlen); | |
526 | ), | |
527 | ||
528 | TP_printk("addr=%pIScp rq_xid=0x%08x flags=%s", | |
529 | (struct sockaddr *)__get_dynamic_array(addr), | |
530 | __entry->xid, | |
531 | show_rqstp_flags(__entry->flags)) | |
532 | ); | |
533 | ||
534 | DEFINE_EVENT(svc_rqst_event, svc_defer, | |
535 | TP_PROTO(struct svc_rqst *rqst), | |
536 | TP_ARGS(rqst)); | |
537 | ||
538 | DEFINE_EVENT(svc_rqst_event, svc_drop, | |
539 | TP_PROTO(struct svc_rqst *rqst), | |
540 | TP_ARGS(rqst)); | |
541 | ||
542 | DECLARE_EVENT_CLASS(svc_rqst_status, | |
543 | ||
544 | TP_PROTO(struct svc_rqst *rqst, int status), | |
545 | ||
546 | TP_ARGS(rqst, status), | |
547 | ||
548 | TP_STRUCT__entry( | |
549 | __field(u32, xid) | |
550 | __field(int, status) | |
551 | __field(unsigned long, flags) | |
552 | __dynamic_array(unsigned char, addr, rqst->rq_addrlen) | |
553 | ), | |
554 | ||
555 | TP_fast_assign( | |
556 | __entry->xid = be32_to_cpu(rqst->rq_xid); | |
557 | __entry->status = status; | |
558 | __entry->flags = rqst->rq_flags; | |
559 | memcpy(__get_dynamic_array(addr), | |
560 | &rqst->rq_addr, rqst->rq_addrlen); | |
561 | ), | |
562 | ||
563 | TP_printk("addr=%pIScp rq_xid=0x%08x status=%d flags=%s", | |
564 | (struct sockaddr *)__get_dynamic_array(addr), | |
565 | __entry->xid, | |
566 | __entry->status, show_rqstp_flags(__entry->flags)) | |
567 | ); | |
568 | ||
569 | DEFINE_EVENT(svc_rqst_status, svc_process, | |
570 | TP_PROTO(struct svc_rqst *rqst, int status), | |
571 | TP_ARGS(rqst, status)); | |
572 | ||
573 | DEFINE_EVENT(svc_rqst_status, svc_send, | |
574 | TP_PROTO(struct svc_rqst *rqst, int status), | |
575 | TP_ARGS(rqst, status)); | |
576 | ||
577 | #define show_svc_xprt_flags(flags) \ | |
578 | __print_flags(flags, "|", \ | |
579 | { (1UL << XPT_BUSY), "XPT_BUSY"}, \ | |
580 | { (1UL << XPT_CONN), "XPT_CONN"}, \ | |
581 | { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \ | |
582 | { (1UL << XPT_DATA), "XPT_DATA"}, \ | |
583 | { (1UL << XPT_TEMP), "XPT_TEMP"}, \ | |
584 | { (1UL << XPT_DEAD), "XPT_DEAD"}, \ | |
585 | { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \ | |
586 | { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \ | |
587 | { (1UL << XPT_OLD), "XPT_OLD"}, \ | |
588 | { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \ | |
589 | { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \ | |
590 | { (1UL << XPT_LOCAL), "XPT_LOCAL"}) | |
591 | ||
592 | TRACE_EVENT(svc_xprt_do_enqueue, | |
593 | TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), | |
594 | ||
595 | TP_ARGS(xprt, rqst), | |
596 | ||
597 | TP_STRUCT__entry( | |
598 | __field(struct svc_xprt *, xprt) | |
599 | __field(int, pid) | |
600 | __field(unsigned long, flags) | |
601 | __dynamic_array(unsigned char, addr, xprt != NULL ? | |
602 | xprt->xpt_remotelen : 0) | |
603 | ), | |
604 | ||
605 | TP_fast_assign( | |
606 | __entry->xprt = xprt; | |
607 | __entry->pid = rqst? rqst->rq_task->pid : 0; | |
608 | if (xprt) { | |
609 | memcpy(__get_dynamic_array(addr), | |
610 | &xprt->xpt_remote, | |
611 | xprt->xpt_remotelen); | |
612 | __entry->flags = xprt->xpt_flags; | |
613 | } else | |
614 | __entry->flags = 0; | |
615 | ), | |
616 | ||
617 | TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt, | |
618 | __get_dynamic_array_len(addr) != 0 ? | |
619 | (struct sockaddr *)__get_dynamic_array(addr) : NULL, | |
620 | __entry->pid, show_svc_xprt_flags(__entry->flags)) | |
621 | ); | |
622 | ||
623 | DECLARE_EVENT_CLASS(svc_xprt_event, | |
624 | TP_PROTO(struct svc_xprt *xprt), | |
625 | ||
626 | TP_ARGS(xprt), | |
627 | ||
628 | TP_STRUCT__entry( | |
629 | __field(struct svc_xprt *, xprt) | |
630 | __field(unsigned long, flags) | |
631 | __dynamic_array(unsigned char, addr, xprt != NULL ? | |
632 | xprt->xpt_remotelen : 0) | |
633 | ), | |
634 | ||
635 | TP_fast_assign( | |
636 | __entry->xprt = xprt; | |
637 | if (xprt) { | |
638 | memcpy(__get_dynamic_array(addr), | |
639 | &xprt->xpt_remote, | |
640 | xprt->xpt_remotelen); | |
641 | __entry->flags = xprt->xpt_flags; | |
642 | } else | |
643 | __entry->flags = 0; | |
644 | ), | |
645 | ||
646 | TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt, | |
647 | __get_dynamic_array_len(addr) != 0 ? | |
648 | (struct sockaddr *)__get_dynamic_array(addr) : NULL, | |
649 | show_svc_xprt_flags(__entry->flags)) | |
650 | ); | |
651 | ||
652 | DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, | |
653 | TP_PROTO(struct svc_xprt *xprt), | |
654 | TP_ARGS(xprt)); | |
655 | ||
656 | DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, | |
657 | TP_PROTO(struct svc_xprt *xprt), | |
658 | TP_ARGS(xprt)); | |
659 | ||
660 | TRACE_EVENT(svc_wake_up, | |
661 | TP_PROTO(int pid), | |
662 | ||
663 | TP_ARGS(pid), | |
664 | ||
665 | TP_STRUCT__entry( | |
666 | __field(int, pid) | |
667 | ), | |
668 | ||
669 | TP_fast_assign( | |
670 | __entry->pid = pid; | |
671 | ), | |
672 | ||
673 | TP_printk("pid=%d", __entry->pid) | |
674 | ); | |
675 | ||
676 | TRACE_EVENT(svc_handle_xprt, | |
677 | TP_PROTO(struct svc_xprt *xprt, int len), | |
678 | ||
679 | TP_ARGS(xprt, len), | |
680 | ||
681 | TP_STRUCT__entry( | |
682 | __field(struct svc_xprt *, xprt) | |
683 | __field(int, len) | |
684 | __field(unsigned long, flags) | |
685 | __dynamic_array(unsigned char, addr, xprt != NULL ? | |
686 | xprt->xpt_remotelen : 0) | |
687 | ), | |
688 | ||
689 | TP_fast_assign( | |
690 | __entry->xprt = xprt; | |
691 | __entry->len = len; | |
692 | if (xprt) { | |
693 | memcpy(__get_dynamic_array(addr), | |
694 | &xprt->xpt_remote, | |
695 | xprt->xpt_remotelen); | |
696 | __entry->flags = xprt->xpt_flags; | |
697 | } else | |
698 | __entry->flags = 0; | |
699 | ), | |
700 | ||
701 | TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt, | |
702 | __get_dynamic_array_len(addr) != 0 ? | |
703 | (struct sockaddr *)__get_dynamic_array(addr) : NULL, | |
704 | __entry->len, show_svc_xprt_flags(__entry->flags)) | |
705 | ); | |
706 | ||
707 | ||
708 | DECLARE_EVENT_CLASS(svc_deferred_event, | |
709 | TP_PROTO(struct svc_deferred_req *dr), | |
710 | ||
711 | TP_ARGS(dr), | |
712 | ||
713 | TP_STRUCT__entry( | |
714 | __field(u32, xid) | |
715 | __dynamic_array(unsigned char, addr, dr->addrlen) | |
716 | ), | |
717 | ||
718 | TP_fast_assign( | |
719 | __entry->xid = be32_to_cpu(*(__be32 *)(dr->args + | |
720 | (dr->xprt_hlen>>2))); | |
721 | memcpy(__get_dynamic_array(addr), &dr->addr, dr->addrlen); | |
722 | ), | |
723 | ||
724 | TP_printk("addr=%pIScp xid=0x%08x", | |
725 | (struct sockaddr *)__get_dynamic_array(addr), | |
726 | __entry->xid) | |
727 | ); | |
728 | ||
729 | DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, | |
730 | TP_PROTO(struct svc_deferred_req *dr), | |
731 | TP_ARGS(dr)); | |
732 | DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, | |
733 | TP_PROTO(struct svc_deferred_req *dr), | |
734 | TP_ARGS(dr)); | |
735 | #endif /* _TRACE_SUNRPC_H */ | |
736 | ||
737 | #include <trace/define_trace.h> |