~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/trace/events/sunrpc.h

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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>
  9 #include <linux/sunrpc/svc.h>
 10 #include <linux/sunrpc/xprtsock.h>
 11 #include <linux/sunrpc/svc_xprt.h>
 12 #include <net/tcp_states.h>
 13 #include <linux/net.h>
 14 #include <linux/tracepoint.h>
 15 
 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(
 23                 __field(unsigned int, task_id)
 24                 __field(unsigned int, client_id)
 25                 __field(int, status)
 26         ),
 27 
 28         TP_fast_assign(
 29                 __entry->task_id = task->tk_pid;
 30                 __entry->client_id = task->tk_client->cl_clid;
 31                 __entry->status = task->tk_status;
 32         ),
 33 
 34         TP_printk("task:%u@%u, status %d",
 35                 __entry->task_id, __entry->client_id,
 36                 __entry->status)
 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(
 57                 __field(unsigned int, task_id)
 58                 __field(unsigned int, client_id)
 59                 __field(int, status)
 60         ),
 61 
 62         TP_fast_assign(
 63                 __entry->task_id = task->tk_pid;
 64                 __entry->client_id = task->tk_client->cl_clid;
 65                 __entry->status = status;
 66         ),
 67 
 68         TP_printk("task:%u@%u, status %d",
 69                 __entry->task_id, __entry->client_id,
 70                 __entry->status)
 71 );
 72 
 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(
 80                 __field(unsigned int, task_id)
 81                 __field(unsigned int, client_id)
 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(
 89                 __entry->client_id = clnt ? clnt->cl_clid : -1;
 90                 __entry->task_id = task->tk_pid;
 91                 __entry->action = action;
 92                 __entry->runstate = task->tk_runstate;
 93                 __entry->status = task->tk_status;
 94                 __entry->flags = task->tk_flags;
 95                 ),
 96 
 97         TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
 98                 __entry->task_id, __entry->client_id,
 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(
137                 __field(unsigned int, task_id)
138                 __field(unsigned int, client_id)
139                 __field(unsigned long, timeout)
140                 __field(unsigned long, runstate)
141                 __field(int, status)
142                 __field(unsigned short, flags)
143                 __string(q_name, rpc_qname(q))
144                 ),
145 
146         TP_fast_assign(
147                 __entry->client_id = clnt->cl_clid;
148                 __entry->task_id = task->tk_pid;
149                 __entry->timeout = task->tk_timeout;
150                 __entry->runstate = task->tk_runstate;
151                 __entry->status = task->tk_status;
152                 __entry->flags = task->tk_flags;
153                 __assign_str(q_name, rpc_qname(q));
154                 ),
155 
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,
158                 __entry->flags,
159                 __entry->runstate,
160                 __entry->status,
161                 __entry->timeout,
162                 __get_str(q_name)
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 
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 
198 #define rpc_show_socket_state(state) \
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" )
215 
216 #define rpc_show_sock_state(state) \
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}
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);
333 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
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 
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 
357         TP_printk("peer=[%s]:%s xid=0x%x status=%d", __get_str(addr),
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 
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 
442 #define show_rqstp_flags(flags)                                         \
443         __print_flags(flags, "|",                                       \
444                 { (1UL << RQ_SECURE),           "RQ_SECURE"},           \
445                 { (1UL << RQ_LOCAL),            "RQ_LOCAL"},            \
446                 { (1UL << RQ_USEDEFERRAL),      "RQ_USEDEFERRAL"},      \
447                 { (1UL << RQ_DROPME),           "RQ_DROPME"},           \
448                 { (1UL << RQ_SPLICE_OK),        "RQ_SPLICE_OK"},        \
449                 { (1UL << RQ_VICTIM),           "RQ_VICTIM"},           \
450                 { (1UL << RQ_BUSY),             "RQ_BUSY"})
451 
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)
461                 __field(unsigned long, flags)
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;
468                 __entry->flags = rqst->rq_flags;
469         ),
470 
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))
474 );
475 
476 DECLARE_EVENT_CLASS(svc_rqst_event,
477 
478         TP_PROTO(struct svc_rqst *rqst),
479 
480         TP_ARGS(rqst),
481 
482         TP_STRUCT__entry(
483                 __field(__be32, xid)
484                 __field(unsigned long, flags)
485                 __dynamic_array(unsigned char, addr, rqst->rq_addrlen)
486         ),
487 
488         TP_fast_assign(
489                 __entry->xid = rqst->rq_xid;
490                 __entry->flags = rqst->rq_flags;
491                 memcpy(__get_dynamic_array(addr),
492                         &rqst->rq_addr, rqst->rq_addrlen);
493         ),
494 
495         TP_printk("addr=%pIScp rq_xid=0x%x flags=%s",
496                 (struct sockaddr *)__get_dynamic_array(addr),
497                 be32_to_cpu(__entry->xid),
498                 show_rqstp_flags(__entry->flags))
499 );
500 
501 DEFINE_EVENT(svc_rqst_event, svc_defer,
502         TP_PROTO(struct svc_rqst *rqst),
503         TP_ARGS(rqst));
504 
505 DEFINE_EVENT(svc_rqst_event, svc_drop,
506         TP_PROTO(struct svc_rqst *rqst),
507         TP_ARGS(rqst));
508 
509 DECLARE_EVENT_CLASS(svc_rqst_status,
510 
511         TP_PROTO(struct svc_rqst *rqst, int status),
512 
513         TP_ARGS(rqst, status),
514 
515         TP_STRUCT__entry(
516                 __field(struct sockaddr *, addr)
517                 __field(__be32, xid)
518                 __field(int, dropme)
519                 __field(int, status)
520                 __field(unsigned long, flags)
521         ),
522 
523         TP_fast_assign(
524                 __entry->addr = (struct sockaddr *)&rqst->rq_addr;
525                 __entry->xid = rqst->rq_xid;
526                 __entry->status = status;
527                 __entry->flags = rqst->rq_flags;
528         ),
529 
530         TP_printk("addr=%pIScp rq_xid=0x%x status=%d flags=%s",
531                 __entry->addr, be32_to_cpu(__entry->xid),
532                 __entry->status, show_rqstp_flags(__entry->flags))
533 );
534 
535 DEFINE_EVENT(svc_rqst_status, svc_process,
536         TP_PROTO(struct svc_rqst *rqst, int status),
537         TP_ARGS(rqst, status));
538 
539 DEFINE_EVENT(svc_rqst_status, svc_send,
540         TP_PROTO(struct svc_rqst *rqst, int status),
541         TP_ARGS(rqst, status));
542 
543 #define show_svc_xprt_flags(flags)                                      \
544         __print_flags(flags, "|",                                       \
545                 { (1UL << XPT_BUSY),            "XPT_BUSY"},            \
546                 { (1UL << XPT_CONN),            "XPT_CONN"},            \
547                 { (1UL << XPT_CLOSE),           "XPT_CLOSE"},           \
548                 { (1UL << XPT_DATA),            "XPT_DATA"},            \
549                 { (1UL << XPT_TEMP),            "XPT_TEMP"},            \
550                 { (1UL << XPT_DEAD),            "XPT_DEAD"},            \
551                 { (1UL << XPT_CHNGBUF),         "XPT_CHNGBUF"},         \
552                 { (1UL << XPT_DEFERRED),        "XPT_DEFERRED"},        \
553                 { (1UL << XPT_OLD),             "XPT_OLD"},             \
554                 { (1UL << XPT_LISTENER),        "XPT_LISTENER"},        \
555                 { (1UL << XPT_CACHE_AUTH),      "XPT_CACHE_AUTH"},      \
556                 { (1UL << XPT_LOCAL),           "XPT_LOCAL"})
557 
558 TRACE_EVENT(svc_xprt_do_enqueue,
559         TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
560 
561         TP_ARGS(xprt, rqst),
562 
563         TP_STRUCT__entry(
564                 __field(struct svc_xprt *, xprt)
565                 __field(int, pid)
566                 __field(unsigned long, flags)
567                 __dynamic_array(unsigned char, addr, xprt != NULL ?
568                         xprt->xpt_remotelen : 0)
569         ),
570 
571         TP_fast_assign(
572                 __entry->xprt = xprt;
573                 __entry->pid = rqst? rqst->rq_task->pid : 0;
574                 if (xprt) {
575                         memcpy(__get_dynamic_array(addr),
576                                 &xprt->xpt_remote,
577                                 xprt->xpt_remotelen);
578                         __entry->flags = xprt->xpt_flags;
579                 } else
580                         __entry->flags = 0;
581         ),
582 
583         TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt,
584                 __get_dynamic_array_len(addr) != 0 ?
585                         (struct sockaddr *)__get_dynamic_array(addr) : NULL,
586                 __entry->pid, show_svc_xprt_flags(__entry->flags))
587 );
588 
589 DECLARE_EVENT_CLASS(svc_xprt_event,
590         TP_PROTO(struct svc_xprt *xprt),
591 
592         TP_ARGS(xprt),
593 
594         TP_STRUCT__entry(
595                 __field(struct svc_xprt *, xprt)
596                 __field(unsigned long, flags)
597                 __dynamic_array(unsigned char, addr, xprt != NULL ?
598                         xprt->xpt_remotelen : 0)
599         ),
600 
601         TP_fast_assign(
602                 __entry->xprt = xprt;
603                 if (xprt) {
604                         memcpy(__get_dynamic_array(addr),
605                                         &xprt->xpt_remote,
606                                         xprt->xpt_remotelen);
607                         __entry->flags = xprt->xpt_flags;
608                 } else
609                         __entry->flags = 0;
610         ),
611 
612         TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt,
613                 __get_dynamic_array_len(addr) != 0 ?
614                         (struct sockaddr *)__get_dynamic_array(addr) : NULL,
615                 show_svc_xprt_flags(__entry->flags))
616 );
617 
618 DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue,
619         TP_PROTO(struct svc_xprt *xprt),
620         TP_ARGS(xprt));
621 
622 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
623         TP_PROTO(struct svc_xprt *xprt),
624         TP_ARGS(xprt));
625 
626 TRACE_EVENT(svc_wake_up,
627         TP_PROTO(int pid),
628 
629         TP_ARGS(pid),
630 
631         TP_STRUCT__entry(
632                 __field(int, pid)
633         ),
634 
635         TP_fast_assign(
636                 __entry->pid = pid;
637         ),
638 
639         TP_printk("pid=%d", __entry->pid)
640 );
641 
642 TRACE_EVENT(svc_handle_xprt,
643         TP_PROTO(struct svc_xprt *xprt, int len),
644 
645         TP_ARGS(xprt, len),
646 
647         TP_STRUCT__entry(
648                 __field(struct svc_xprt *, xprt)
649                 __field(int, len)
650                 __field(unsigned long, flags)
651                 __dynamic_array(unsigned char, addr, xprt != NULL ?
652                         xprt->xpt_remotelen : 0)
653         ),
654 
655         TP_fast_assign(
656                 __entry->xprt = xprt;
657                 __entry->len = len;
658                 if (xprt) {
659                         memcpy(__get_dynamic_array(addr),
660                                         &xprt->xpt_remote,
661                                         xprt->xpt_remotelen);
662                         __entry->flags = xprt->xpt_flags;
663                 } else
664                         __entry->flags = 0;
665         ),
666 
667         TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt,
668                 __get_dynamic_array_len(addr) != 0 ?
669                         (struct sockaddr *)__get_dynamic_array(addr) : NULL,
670                 __entry->len, show_svc_xprt_flags(__entry->flags))
671 );
672 
673 
674 DECLARE_EVENT_CLASS(svc_deferred_event,
675         TP_PROTO(struct svc_deferred_req *dr),
676 
677         TP_ARGS(dr),
678 
679         TP_STRUCT__entry(
680                 __field(__be32, xid)
681                 __dynamic_array(unsigned char, addr, dr->addrlen)
682         ),
683 
684         TP_fast_assign(
685                 __entry->xid = *(__be32 *)(dr->args + (dr->xprt_hlen>>2));
686                 memcpy(__get_dynamic_array(addr), &dr->addr, dr->addrlen);
687         ),
688 
689         TP_printk("addr=%pIScp xid=0x%x",
690                 (struct sockaddr *)__get_dynamic_array(addr),
691                 be32_to_cpu(__entry->xid))
692 );
693 
694 DEFINE_EVENT(svc_deferred_event, svc_drop_deferred,
695         TP_PROTO(struct svc_deferred_req *dr),
696         TP_ARGS(dr));
697 DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred,
698         TP_PROTO(struct svc_deferred_req *dr),
699         TP_ARGS(dr));
700 #endif /* _TRACE_SUNRPC_H */
701 
702 #include <trace/define_trace.h>
703 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp