Commit | Line | Data |
---|---|---|
82b0a4c3 TM |
1 | #undef TRACE_SYSTEM |
2 | #define TRACE_SYSTEM sunrpc | |
3 | ||
4 | #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ) | |
5 | #define _TRACE_SUNRPC_H | |
6 | ||
7 | #include <linux/sunrpc/sched.h> | |
8 | #include <linux/sunrpc/clnt.h> | |
860a0d9e | 9 | #include <linux/sunrpc/svc.h> |
1a867a08 | 10 | #include <linux/sunrpc/xprtsock.h> |
83a712e0 | 11 | #include <linux/sunrpc/svc_xprt.h> |
40b5ea0c TM |
12 | #include <net/tcp_states.h> |
13 | #include <linux/net.h> | |
82b0a4c3 TM |
14 | #include <linux/tracepoint.h> |
15 | ||
5753cba1 SD |
16 | DECLARE_EVENT_CLASS(rpc_task_status, |
17 | ||
18 | TP_PROTO(struct rpc_task *task), | |
19 | ||
20 | TP_ARGS(task), | |
21 | ||
22 | TP_STRUCT__entry( | |
92cb6c5b TM |
23 | __field(unsigned int, task_id) |
24 | __field(unsigned int, client_id) | |
5753cba1 SD |
25 | __field(int, status) |
26 | ), | |
27 | ||
28 | TP_fast_assign( | |
92cb6c5b TM |
29 | __entry->task_id = task->tk_pid; |
30 | __entry->client_id = task->tk_client->cl_clid; | |
5753cba1 SD |
31 | __entry->status = task->tk_status; |
32 | ), | |
33 | ||
92cb6c5b TM |
34 | TP_printk("task:%u@%u, status %d", |
35 | __entry->task_id, __entry->client_id, | |
36 | __entry->status) | |
5753cba1 SD |
37 | ); |
38 | ||
39 | DEFINE_EVENT(rpc_task_status, rpc_call_status, | |
40 | TP_PROTO(struct rpc_task *task), | |
41 | ||
42 | TP_ARGS(task) | |
43 | ); | |
44 | ||
45 | DEFINE_EVENT(rpc_task_status, rpc_bind_status, | |
46 | TP_PROTO(struct rpc_task *task), | |
47 | ||
48 | TP_ARGS(task) | |
49 | ); | |
50 | ||
51 | TRACE_EVENT(rpc_connect_status, | |
52 | TP_PROTO(struct rpc_task *task, int status), | |
53 | ||
54 | TP_ARGS(task, status), | |
55 | ||
56 | TP_STRUCT__entry( | |
92cb6c5b TM |
57 | __field(unsigned int, task_id) |
58 | __field(unsigned int, client_id) | |
5753cba1 SD |
59 | __field(int, status) |
60 | ), | |
61 | ||
62 | TP_fast_assign( | |
92cb6c5b TM |
63 | __entry->task_id = task->tk_pid; |
64 | __entry->client_id = task->tk_client->cl_clid; | |
5753cba1 SD |
65 | __entry->status = status; |
66 | ), | |
67 | ||
92cb6c5b TM |
68 | TP_printk("task:%u@%u, status %d", |
69 | __entry->task_id, __entry->client_id, | |
70 | __entry->status) | |
5753cba1 SD |
71 | ); |
72 | ||
82b0a4c3 TM |
73 | DECLARE_EVENT_CLASS(rpc_task_running, |
74 | ||
75 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
76 | ||
77 | TP_ARGS(clnt, task, action), | |
78 | ||
79 | TP_STRUCT__entry( | |
92cb6c5b TM |
80 | __field(unsigned int, task_id) |
81 | __field(unsigned int, client_id) | |
82b0a4c3 TM |
82 | __field(const void *, action) |
83 | __field(unsigned long, runstate) | |
84 | __field(int, status) | |
85 | __field(unsigned short, flags) | |
86 | ), | |
87 | ||
88 | TP_fast_assign( | |
2ca310fc | 89 | __entry->client_id = clnt ? clnt->cl_clid : -1; |
92cb6c5b | 90 | __entry->task_id = task->tk_pid; |
82b0a4c3 TM |
91 | __entry->action = action; |
92 | __entry->runstate = task->tk_runstate; | |
93 | __entry->status = task->tk_status; | |
94 | __entry->flags = task->tk_flags; | |
95 | ), | |
96 | ||
2ca310fc | 97 | TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf", |
92cb6c5b | 98 | __entry->task_id, __entry->client_id, |
82b0a4c3 TM |
99 | __entry->flags, |
100 | __entry->runstate, | |
101 | __entry->status, | |
102 | __entry->action | |
103 | ) | |
104 | ); | |
105 | ||
106 | DEFINE_EVENT(rpc_task_running, rpc_task_begin, | |
107 | ||
108 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
109 | ||
110 | TP_ARGS(clnt, task, action) | |
111 | ||
112 | ); | |
113 | ||
114 | DEFINE_EVENT(rpc_task_running, rpc_task_run_action, | |
115 | ||
116 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
117 | ||
118 | TP_ARGS(clnt, task, action) | |
119 | ||
120 | ); | |
121 | ||
122 | DEFINE_EVENT(rpc_task_running, rpc_task_complete, | |
123 | ||
124 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), | |
125 | ||
126 | TP_ARGS(clnt, task, action) | |
127 | ||
128 | ); | |
129 | ||
130 | DECLARE_EVENT_CLASS(rpc_task_queued, | |
131 | ||
132 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), | |
133 | ||
134 | TP_ARGS(clnt, task, q), | |
135 | ||
136 | TP_STRUCT__entry( | |
92cb6c5b TM |
137 | __field(unsigned int, task_id) |
138 | __field(unsigned int, client_id) | |
82b0a4c3 TM |
139 | __field(unsigned long, timeout) |
140 | __field(unsigned long, runstate) | |
141 | __field(int, status) | |
142 | __field(unsigned short, flags) | |
85c0d24f | 143 | __string(q_name, rpc_qname(q)) |
82b0a4c3 TM |
144 | ), |
145 | ||
146 | TP_fast_assign( | |
92cb6c5b TM |
147 | __entry->client_id = clnt->cl_clid; |
148 | __entry->task_id = task->tk_pid; | |
82b0a4c3 TM |
149 | __entry->timeout = task->tk_timeout; |
150 | __entry->runstate = task->tk_runstate; | |
151 | __entry->status = task->tk_status; | |
152 | __entry->flags = task->tk_flags; | |
85c0d24f | 153 | __assign_str(q_name, rpc_qname(q)); |
82b0a4c3 TM |
154 | ), |
155 | ||
92cb6c5b TM |
156 | TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s", |
157 | __entry->task_id, __entry->client_id, | |
82b0a4c3 TM |
158 | __entry->flags, |
159 | __entry->runstate, | |
160 | __entry->status, | |
161 | __entry->timeout, | |
85c0d24f | 162 | __get_str(q_name) |
82b0a4c3 TM |
163 | ) |
164 | ); | |
165 | ||
166 | DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, | |
167 | ||
168 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), | |
169 | ||
170 | TP_ARGS(clnt, task, q) | |
171 | ||
172 | ); | |
173 | ||
174 | DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, | |
175 | ||
176 | TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), | |
177 | ||
178 | TP_ARGS(clnt, task, q) | |
179 | ||
180 | ); | |
181 | ||
6ba16eef SRRH |
182 | /* |
183 | * First define the enums in the below macros to be exported to userspace | |
184 | * via TRACE_DEFINE_ENUM(). | |
185 | */ | |
186 | #undef EM | |
187 | #undef EMe | |
188 | #define EM(a, b) TRACE_DEFINE_ENUM(a); | |
189 | #define EMe(a, b) TRACE_DEFINE_ENUM(a); | |
190 | ||
191 | #define RPC_SHOW_SOCKET \ | |
192 | EM( SS_FREE, "FREE" ) \ | |
193 | EM( SS_UNCONNECTED, "UNCONNECTED" ) \ | |
194 | EM( SS_CONNECTING, "CONNECTING," ) \ | |
195 | EM( SS_CONNECTED, "CONNECTED," ) \ | |
196 | EMe(SS_DISCONNECTING, "DISCONNECTING" ) | |
197 | ||
40b5ea0c | 198 | #define rpc_show_socket_state(state) \ |
6ba16eef SRRH |
199 | __print_symbolic(state, RPC_SHOW_SOCKET) |
200 | ||
201 | RPC_SHOW_SOCKET | |
202 | ||
203 | #define RPC_SHOW_SOCK \ | |
204 | EM( TCP_ESTABLISHED, "ESTABLISHED" ) \ | |
205 | EM( TCP_SYN_SENT, "SYN_SENT" ) \ | |
206 | EM( TCP_SYN_RECV, "SYN_RECV" ) \ | |
207 | EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \ | |
208 | EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \ | |
209 | EM( TCP_TIME_WAIT, "TIME_WAIT" ) \ | |
210 | EM( TCP_CLOSE, "CLOSE" ) \ | |
211 | EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \ | |
212 | EM( TCP_LAST_ACK, "LAST_ACK" ) \ | |
213 | EM( TCP_LISTEN, "LISTEN" ) \ | |
214 | EMe( TCP_CLOSING, "CLOSING" ) | |
40b5ea0c TM |
215 | |
216 | #define rpc_show_sock_state(state) \ | |
6ba16eef SRRH |
217 | __print_symbolic(state, RPC_SHOW_SOCK) |
218 | ||
219 | RPC_SHOW_SOCK | |
220 | ||
221 | /* | |
222 | * Now redefine the EM() and EMe() macros to map the enums to the strings | |
223 | * that will be printed in the output. | |
224 | */ | |
225 | #undef EM | |
226 | #undef EMe | |
227 | #define EM(a, b) {a, b}, | |
228 | #define EMe(a, b) {a, b} | |
40b5ea0c TM |
229 | |
230 | DECLARE_EVENT_CLASS(xs_socket_event, | |
231 | ||
232 | TP_PROTO( | |
233 | struct rpc_xprt *xprt, | |
234 | struct socket *socket | |
235 | ), | |
236 | ||
237 | TP_ARGS(xprt, socket), | |
238 | ||
239 | TP_STRUCT__entry( | |
240 | __field(unsigned int, socket_state) | |
241 | __field(unsigned int, sock_state) | |
242 | __field(unsigned long long, ino) | |
243 | __string(dstaddr, | |
244 | xprt->address_strings[RPC_DISPLAY_ADDR]) | |
245 | __string(dstport, | |
246 | xprt->address_strings[RPC_DISPLAY_PORT]) | |
247 | ), | |
248 | ||
249 | TP_fast_assign( | |
250 | struct inode *inode = SOCK_INODE(socket); | |
251 | __entry->socket_state = socket->state; | |
252 | __entry->sock_state = socket->sk->sk_state; | |
253 | __entry->ino = (unsigned long long)inode->i_ino; | |
254 | __assign_str(dstaddr, | |
255 | xprt->address_strings[RPC_DISPLAY_ADDR]); | |
256 | __assign_str(dstport, | |
257 | xprt->address_strings[RPC_DISPLAY_PORT]); | |
258 | ), | |
259 | ||
260 | TP_printk( | |
261 | "socket:[%llu] dstaddr=%s/%s " | |
262 | "state=%u (%s) sk_state=%u (%s)", | |
263 | __entry->ino, __get_str(dstaddr), __get_str(dstport), | |
264 | __entry->socket_state, | |
265 | rpc_show_socket_state(__entry->socket_state), | |
266 | __entry->sock_state, | |
267 | rpc_show_sock_state(__entry->sock_state) | |
268 | ) | |
269 | ); | |
270 | #define DEFINE_RPC_SOCKET_EVENT(name) \ | |
271 | DEFINE_EVENT(xs_socket_event, name, \ | |
272 | TP_PROTO( \ | |
273 | struct rpc_xprt *xprt, \ | |
274 | struct socket *socket \ | |
275 | ), \ | |
276 | TP_ARGS(xprt, socket)) | |
277 | ||
278 | DECLARE_EVENT_CLASS(xs_socket_event_done, | |
279 | ||
280 | TP_PROTO( | |
281 | struct rpc_xprt *xprt, | |
282 | struct socket *socket, | |
283 | int error | |
284 | ), | |
285 | ||
286 | TP_ARGS(xprt, socket, error), | |
287 | ||
288 | TP_STRUCT__entry( | |
289 | __field(int, error) | |
290 | __field(unsigned int, socket_state) | |
291 | __field(unsigned int, sock_state) | |
292 | __field(unsigned long long, ino) | |
293 | __string(dstaddr, | |
294 | xprt->address_strings[RPC_DISPLAY_ADDR]) | |
295 | __string(dstport, | |
296 | xprt->address_strings[RPC_DISPLAY_PORT]) | |
297 | ), | |
298 | ||
299 | TP_fast_assign( | |
300 | struct inode *inode = SOCK_INODE(socket); | |
301 | __entry->socket_state = socket->state; | |
302 | __entry->sock_state = socket->sk->sk_state; | |
303 | __entry->ino = (unsigned long long)inode->i_ino; | |
304 | __entry->error = error; | |
305 | __assign_str(dstaddr, | |
306 | xprt->address_strings[RPC_DISPLAY_ADDR]); | |
307 | __assign_str(dstport, | |
308 | xprt->address_strings[RPC_DISPLAY_PORT]); | |
309 | ), | |
310 | ||
311 | TP_printk( | |
312 | "error=%d socket:[%llu] dstaddr=%s/%s " | |
313 | "state=%u (%s) sk_state=%u (%s)", | |
314 | __entry->error, | |
315 | __entry->ino, __get_str(dstaddr), __get_str(dstport), | |
316 | __entry->socket_state, | |
317 | rpc_show_socket_state(__entry->socket_state), | |
318 | __entry->sock_state, | |
319 | rpc_show_sock_state(__entry->sock_state) | |
320 | ) | |
321 | ); | |
322 | #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \ | |
323 | DEFINE_EVENT(xs_socket_event_done, name, \ | |
324 | TP_PROTO( \ | |
325 | struct rpc_xprt *xprt, \ | |
326 | struct socket *socket, \ | |
327 | int error \ | |
328 | ), \ | |
329 | TP_ARGS(xprt, socket, error)) | |
330 | ||
331 | DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); | |
332 | DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); | |
e8353c76 | 333 | DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); |
40b5ea0c TM |
334 | DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); |
335 | DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); | |
336 | DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); | |
337 | ||
3705ad64 JL |
338 | DECLARE_EVENT_CLASS(rpc_xprt_event, |
339 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
340 | ||
341 | TP_ARGS(xprt, xid, status), | |
342 | ||
343 | TP_STRUCT__entry( | |
344 | __field(__be32, xid) | |
345 | __field(int, status) | |
346 | __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) | |
347 | __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) | |
348 | ), | |
349 | ||
350 | TP_fast_assign( | |
351 | __entry->xid = xid; | |
352 | __entry->status = status; | |
353 | __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); | |
354 | __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); | |
355 | ), | |
356 | ||
1a867a08 | 357 | TP_printk("peer=[%s]:%s xid=0x%x status=%d", __get_str(addr), |
3705ad64 JL |
358 | __get_str(port), be32_to_cpu(__entry->xid), |
359 | __entry->status) | |
360 | ); | |
361 | ||
362 | DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, | |
363 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
364 | TP_ARGS(xprt, xid, status)); | |
365 | ||
366 | DEFINE_EVENT(rpc_xprt_event, xprt_transmit, | |
367 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
368 | TP_ARGS(xprt, xid, status)); | |
369 | ||
370 | DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, | |
371 | TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), | |
372 | TP_ARGS(xprt, xid, status)); | |
373 | ||
374 | TRACE_EVENT(xs_tcp_data_ready, | |
375 | TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), | |
376 | ||
377 | TP_ARGS(xprt, err, total), | |
378 | ||
379 | TP_STRUCT__entry( | |
380 | __field(int, err) | |
381 | __field(unsigned int, total) | |
382 | __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] : | |
383 | "(null)") | |
384 | __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] : | |
385 | "(null)") | |
386 | ), | |
387 | ||
388 | TP_fast_assign( | |
389 | __entry->err = err; | |
390 | __entry->total = total; | |
391 | __assign_str(addr, xprt ? | |
392 | xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)"); | |
393 | __assign_str(port, xprt ? | |
394 | xprt->address_strings[RPC_DISPLAY_PORT] : "(null)"); | |
395 | ), | |
396 | ||
397 | TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr), | |
398 | __get_str(port), __entry->err, __entry->total) | |
399 | ); | |
400 | ||
1a867a08 JL |
401 | #define rpc_show_sock_xprt_flags(flags) \ |
402 | __print_flags(flags, "|", \ | |
403 | { TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \ | |
404 | { TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \ | |
405 | { TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \ | |
406 | { TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \ | |
407 | { TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \ | |
408 | { TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \ | |
409 | { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) | |
410 | ||
411 | TRACE_EVENT(xs_tcp_data_recv, | |
412 | TP_PROTO(struct sock_xprt *xs), | |
413 | ||
414 | TP_ARGS(xs), | |
415 | ||
416 | TP_STRUCT__entry( | |
417 | __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]) | |
418 | __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]) | |
419 | __field(__be32, xid) | |
420 | __field(unsigned long, flags) | |
421 | __field(unsigned long, copied) | |
422 | __field(unsigned int, reclen) | |
423 | __field(unsigned long, offset) | |
424 | ), | |
425 | ||
426 | TP_fast_assign( | |
427 | __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]); | |
428 | __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]); | |
429 | __entry->xid = xs->tcp_xid; | |
430 | __entry->flags = xs->tcp_flags; | |
431 | __entry->copied = xs->tcp_copied; | |
432 | __entry->reclen = xs->tcp_reclen; | |
433 | __entry->offset = xs->tcp_offset; | |
434 | ), | |
435 | ||
436 | TP_printk("peer=[%s]:%s xid=0x%x flags=%s copied=%lu reclen=%u offset=%lu", | |
437 | __get_str(addr), __get_str(port), be32_to_cpu(__entry->xid), | |
438 | rpc_show_sock_xprt_flags(__entry->flags), | |
439 | __entry->copied, __entry->reclen, __entry->offset) | |
440 | ); | |
441 | ||
30660e04 JL |
442 | #define show_rqstp_flags(flags) \ |
443 | __print_flags(flags, "|", \ | |
444 | { (1UL << RQ_SECURE), "RQ_SECURE"}, \ | |
445 | { (1UL << RQ_LOCAL), "RQ_LOCAL"}, \ | |
78b65eb3 | 446 | { (1UL << RQ_USEDEFERRAL), "RQ_USEDEFERRAL"}, \ |
779fb0f3 | 447 | { (1UL << RQ_DROPME), "RQ_DROPME"}, \ |
81244386 | 448 | { (1UL << RQ_SPLICE_OK), "RQ_SPLICE_OK"}, \ |
b1691bc0 JL |
449 | { (1UL << RQ_VICTIM), "RQ_VICTIM"}, \ |
450 | { (1UL << RQ_BUSY), "RQ_BUSY"}) | |
4d152e2c | 451 | |
860a0d9e JL |
452 | TRACE_EVENT(svc_recv, |
453 | TP_PROTO(struct svc_rqst *rqst, int status), | |
454 | ||
455 | TP_ARGS(rqst, status), | |
456 | ||
457 | TP_STRUCT__entry( | |
458 | __field(struct sockaddr *, addr) | |
459 | __field(__be32, xid) | |
460 | __field(int, status) | |
4d152e2c | 461 | __field(unsigned long, flags) |
860a0d9e JL |
462 | ), |
463 | ||
464 | TP_fast_assign( | |
465 | __entry->addr = (struct sockaddr *)&rqst->rq_addr; | |
466 | __entry->xid = status > 0 ? rqst->rq_xid : 0; | |
467 | __entry->status = status; | |
4d152e2c | 468 | __entry->flags = rqst->rq_flags; |
860a0d9e JL |
469 | ), |
470 | ||
4d152e2c JL |
471 | TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", __entry->addr, |
472 | be32_to_cpu(__entry->xid), __entry->status, | |
473 | show_rqstp_flags(__entry->flags)) | |
860a0d9e JL |
474 | ); |
475 | ||
476 | DECLARE_EVENT_CLASS(svc_rqst_status, | |
477 | ||
478 | TP_PROTO(struct svc_rqst *rqst, int status), | |
479 | ||
480 | TP_ARGS(rqst, status), | |
481 | ||
482 | TP_STRUCT__entry( | |
483 | __field(struct sockaddr *, addr) | |
484 | __field(__be32, xid) | |
485 | __field(int, dropme) | |
486 | __field(int, status) | |
4d152e2c | 487 | __field(unsigned long, flags) |
860a0d9e JL |
488 | ), |
489 | ||
490 | TP_fast_assign( | |
491 | __entry->addr = (struct sockaddr *)&rqst->rq_addr; | |
492 | __entry->xid = rqst->rq_xid; | |
860a0d9e | 493 | __entry->status = status; |
4d152e2c | 494 | __entry->flags = rqst->rq_flags; |
860a0d9e JL |
495 | ), |
496 | ||
78b65eb3 JL |
497 | TP_printk("addr=%pIScp rq_xid=0x%x status=%d flags=%s", |
498 | __entry->addr, be32_to_cpu(__entry->xid), | |
4d152e2c | 499 | __entry->status, show_rqstp_flags(__entry->flags)) |
860a0d9e JL |
500 | ); |
501 | ||
502 | DEFINE_EVENT(svc_rqst_status, svc_process, | |
503 | TP_PROTO(struct svc_rqst *rqst, int status), | |
504 | TP_ARGS(rqst, status)); | |
505 | ||
506 | DEFINE_EVENT(svc_rqst_status, svc_send, | |
507 | TP_PROTO(struct svc_rqst *rqst, int status), | |
508 | TP_ARGS(rqst, status)); | |
509 | ||
83a712e0 JL |
510 | #define show_svc_xprt_flags(flags) \ |
511 | __print_flags(flags, "|", \ | |
512 | { (1UL << XPT_BUSY), "XPT_BUSY"}, \ | |
513 | { (1UL << XPT_CONN), "XPT_CONN"}, \ | |
514 | { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \ | |
515 | { (1UL << XPT_DATA), "XPT_DATA"}, \ | |
516 | { (1UL << XPT_TEMP), "XPT_TEMP"}, \ | |
517 | { (1UL << XPT_DEAD), "XPT_DEAD"}, \ | |
518 | { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \ | |
519 | { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \ | |
520 | { (1UL << XPT_OLD), "XPT_OLD"}, \ | |
521 | { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \ | |
522 | { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \ | |
523 | { (1UL << XPT_LOCAL), "XPT_LOCAL"}) | |
524 | ||
525 | TRACE_EVENT(svc_xprt_do_enqueue, | |
526 | TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), | |
527 | ||
528 | TP_ARGS(xprt, rqst), | |
529 | ||
530 | TP_STRUCT__entry( | |
531 | __field(struct svc_xprt *, xprt) | |
051ac384 PA |
532 | __field_struct(struct sockaddr_storage, ss) |
533 | __field(int, pid) | |
534 | __field(unsigned long, flags) | |
83a712e0 JL |
535 | ), |
536 | ||
537 | TP_fast_assign( | |
538 | __entry->xprt = xprt; | |
051ac384 PA |
539 | xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss)); |
540 | __entry->pid = rqst? rqst->rq_task->pid : 0; | |
541 | __entry->flags = xprt ? xprt->xpt_flags : 0; | |
83a712e0 JL |
542 | ), |
543 | ||
544 | TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt, | |
051ac384 PA |
545 | (struct sockaddr *)&__entry->ss, |
546 | __entry->pid, show_svc_xprt_flags(__entry->flags)) | |
83a712e0 JL |
547 | ); |
548 | ||
549 | TRACE_EVENT(svc_xprt_dequeue, | |
550 | TP_PROTO(struct svc_xprt *xprt), | |
551 | ||
552 | TP_ARGS(xprt), | |
553 | ||
554 | TP_STRUCT__entry( | |
555 | __field(struct svc_xprt *, xprt) | |
556 | __field_struct(struct sockaddr_storage, ss) | |
557 | __field(unsigned long, flags) | |
558 | ), | |
559 | ||
560 | TP_fast_assign( | |
561 | __entry->xprt = xprt, | |
562 | xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss)); | |
563 | __entry->flags = xprt ? xprt->xpt_flags : 0; | |
564 | ), | |
565 | ||
566 | TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt, | |
567 | (struct sockaddr *)&__entry->ss, | |
568 | show_svc_xprt_flags(__entry->flags)) | |
569 | ); | |
570 | ||
571 | TRACE_EVENT(svc_wake_up, | |
572 | TP_PROTO(int pid), | |
573 | ||
574 | TP_ARGS(pid), | |
575 | ||
576 | TP_STRUCT__entry( | |
577 | __field(int, pid) | |
578 | ), | |
579 | ||
580 | TP_fast_assign( | |
581 | __entry->pid = pid; | |
582 | ), | |
583 | ||
584 | TP_printk("pid=%d", __entry->pid) | |
585 | ); | |
586 | ||
587 | TRACE_EVENT(svc_handle_xprt, | |
588 | TP_PROTO(struct svc_xprt *xprt, int len), | |
589 | ||
590 | TP_ARGS(xprt, len), | |
591 | ||
592 | TP_STRUCT__entry( | |
593 | __field(struct svc_xprt *, xprt) | |
594 | __field(int, len) | |
051ac384 PA |
595 | __field_struct(struct sockaddr_storage, ss) |
596 | __field(unsigned long, flags) | |
83a712e0 JL |
597 | ), |
598 | ||
599 | TP_fast_assign( | |
600 | __entry->xprt = xprt; | |
051ac384 | 601 | xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss)); |
83a712e0 | 602 | __entry->len = len; |
051ac384 | 603 | __entry->flags = xprt ? xprt->xpt_flags : 0; |
83a712e0 JL |
604 | ), |
605 | ||
606 | TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt, | |
051ac384 PA |
607 | (struct sockaddr *)&__entry->ss, |
608 | __entry->len, show_svc_xprt_flags(__entry->flags)) | |
83a712e0 | 609 | ); |
82b0a4c3 TM |
610 | #endif /* _TRACE_SUNRPC_H */ |
611 | ||
612 | #include <trace/define_trace.h> |