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(__be32, xid) 459 __field(int, status) 460 __field(unsigned long, flags) 461 __dynamic_array(unsigned char, addr, rqst->rq_addrlen) 462 ), 463 464 TP_fast_assign( 465 __entry->xid = status > 0 ? rqst->rq_xid : 0; 466 __entry->status = status; 467 __entry->flags = rqst->rq_flags; 468 memcpy(__get_dynamic_array(addr), 469 &rqst->rq_addr, rqst->rq_addrlen); 470 ), 471 472 TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", 473 (struct sockaddr *)__get_dynamic_array(addr), 474 be32_to_cpu(__entry->xid), __entry->status, 475 show_rqstp_flags(__entry->flags)) 476 ); 477 478 DECLARE_EVENT_CLASS(svc_rqst_event, 479 480 TP_PROTO(struct svc_rqst *rqst), 481 482 TP_ARGS(rqst), 483 484 TP_STRUCT__entry( 485 __field(__be32, xid) 486 __field(unsigned long, flags) 487 __dynamic_array(unsigned char, addr, rqst->rq_addrlen) 488 ), 489 490 TP_fast_assign( 491 __entry->xid = rqst->rq_xid; 492 __entry->flags = rqst->rq_flags; 493 memcpy(__get_dynamic_array(addr), 494 &rqst->rq_addr, rqst->rq_addrlen); 495 ), 496 497 TP_printk("addr=%pIScp rq_xid=0x%x flags=%s", 498 (struct sockaddr *)__get_dynamic_array(addr), 499 be32_to_cpu(__entry->xid), 500 show_rqstp_flags(__entry->flags)) 501 ); 502 503 DEFINE_EVENT(svc_rqst_event, svc_defer, 504 TP_PROTO(struct svc_rqst *rqst), 505 TP_ARGS(rqst)); 506 507 DEFINE_EVENT(svc_rqst_event, svc_drop, 508 TP_PROTO(struct svc_rqst *rqst), 509 TP_ARGS(rqst)); 510 511 DECLARE_EVENT_CLASS(svc_rqst_status, 512 513 TP_PROTO(struct svc_rqst *rqst, int status), 514 515 TP_ARGS(rqst, status), 516 517 TP_STRUCT__entry( 518 __field(__be32, xid) 519 __field(int, status) 520 __field(unsigned long, flags) 521 __dynamic_array(unsigned char, addr, rqst->rq_addrlen) 522 ), 523 524 TP_fast_assign( 525 __entry->xid = rqst->rq_xid; 526 __entry->status = status; 527 __entry->flags = rqst->rq_flags; 528 memcpy(__get_dynamic_array(addr), 529 &rqst->rq_addr, rqst->rq_addrlen); 530 ), 531 532 TP_printk("addr=%pIScp rq_xid=0x%x status=%d flags=%s", 533 (struct sockaddr *)__get_dynamic_array(addr), 534 be32_to_cpu(__entry->xid), 535 __entry->status, show_rqstp_flags(__entry->flags)) 536 ); 537 538 DEFINE_EVENT(svc_rqst_status, svc_process, 539 TP_PROTO(struct svc_rqst *rqst, int status), 540 TP_ARGS(rqst, status)); 541 542 DEFINE_EVENT(svc_rqst_status, svc_send, 543 TP_PROTO(struct svc_rqst *rqst, int status), 544 TP_ARGS(rqst, status)); 545 546 #define show_svc_xprt_flags(flags) \ 547 __print_flags(flags, "|", \ 548 { (1UL << XPT_BUSY), "XPT_BUSY"}, \ 549 { (1UL << XPT_CONN), "XPT_CONN"}, \ 550 { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \ 551 { (1UL << XPT_DATA), "XPT_DATA"}, \ 552 { (1UL << XPT_TEMP), "XPT_TEMP"}, \ 553 { (1UL << XPT_DEAD), "XPT_DEAD"}, \ 554 { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \ 555 { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \ 556 { (1UL << XPT_OLD), "XPT_OLD"}, \ 557 { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \ 558 { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \ 559 { (1UL << XPT_LOCAL), "XPT_LOCAL"}) 560 561 TRACE_EVENT(svc_xprt_do_enqueue, 562 TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), 563 564 TP_ARGS(xprt, rqst), 565 566 TP_STRUCT__entry( 567 __field(struct svc_xprt *, xprt) 568 __field(int, pid) 569 __field(unsigned long, flags) 570 __dynamic_array(unsigned char, addr, xprt != NULL ? 571 xprt->xpt_remotelen : 0) 572 ), 573 574 TP_fast_assign( 575 __entry->xprt = xprt; 576 __entry->pid = rqst? rqst->rq_task->pid : 0; 577 if (xprt) { 578 memcpy(__get_dynamic_array(addr), 579 &xprt->xpt_remote, 580 xprt->xpt_remotelen); 581 __entry->flags = xprt->xpt_flags; 582 } else 583 __entry->flags = 0; 584 ), 585 586 TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt, 587 __get_dynamic_array_len(addr) != 0 ? 588 (struct sockaddr *)__get_dynamic_array(addr) : NULL, 589 __entry->pid, show_svc_xprt_flags(__entry->flags)) 590 ); 591 592 DECLARE_EVENT_CLASS(svc_xprt_event, 593 TP_PROTO(struct svc_xprt *xprt), 594 595 TP_ARGS(xprt), 596 597 TP_STRUCT__entry( 598 __field(struct svc_xprt *, xprt) 599 __field(unsigned long, flags) 600 __dynamic_array(unsigned char, addr, xprt != NULL ? 601 xprt->xpt_remotelen : 0) 602 ), 603 604 TP_fast_assign( 605 __entry->xprt = xprt; 606 if (xprt) { 607 memcpy(__get_dynamic_array(addr), 608 &xprt->xpt_remote, 609 xprt->xpt_remotelen); 610 __entry->flags = xprt->xpt_flags; 611 } else 612 __entry->flags = 0; 613 ), 614 615 TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt, 616 __get_dynamic_array_len(addr) != 0 ? 617 (struct sockaddr *)__get_dynamic_array(addr) : NULL, 618 show_svc_xprt_flags(__entry->flags)) 619 ); 620 621 DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, 622 TP_PROTO(struct svc_xprt *xprt), 623 TP_ARGS(xprt)); 624 625 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, 626 TP_PROTO(struct svc_xprt *xprt), 627 TP_ARGS(xprt)); 628 629 TRACE_EVENT(svc_wake_up, 630 TP_PROTO(int pid), 631 632 TP_ARGS(pid), 633 634 TP_STRUCT__entry( 635 __field(int, pid) 636 ), 637 638 TP_fast_assign( 639 __entry->pid = pid; 640 ), 641 642 TP_printk("pid=%d", __entry->pid) 643 ); 644 645 TRACE_EVENT(svc_handle_xprt, 646 TP_PROTO(struct svc_xprt *xprt, int len), 647 648 TP_ARGS(xprt, len), 649 650 TP_STRUCT__entry( 651 __field(struct svc_xprt *, xprt) 652 __field(int, len) 653 __field(unsigned long, flags) 654 __dynamic_array(unsigned char, addr, xprt != NULL ? 655 xprt->xpt_remotelen : 0) 656 ), 657 658 TP_fast_assign( 659 __entry->xprt = xprt; 660 __entry->len = len; 661 if (xprt) { 662 memcpy(__get_dynamic_array(addr), 663 &xprt->xpt_remote, 664 xprt->xpt_remotelen); 665 __entry->flags = xprt->xpt_flags; 666 } else 667 __entry->flags = 0; 668 ), 669 670 TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt, 671 __get_dynamic_array_len(addr) != 0 ? 672 (struct sockaddr *)__get_dynamic_array(addr) : NULL, 673 __entry->len, show_svc_xprt_flags(__entry->flags)) 674 ); 675 676 677 DECLARE_EVENT_CLASS(svc_deferred_event, 678 TP_PROTO(struct svc_deferred_req *dr), 679 680 TP_ARGS(dr), 681 682 TP_STRUCT__entry( 683 __field(__be32, xid) 684 __dynamic_array(unsigned char, addr, dr->addrlen) 685 ), 686 687 TP_fast_assign( 688 __entry->xid = *(__be32 *)(dr->args + (dr->xprt_hlen>>2)); 689 memcpy(__get_dynamic_array(addr), &dr->addr, dr->addrlen); 690 ), 691 692 TP_printk("addr=%pIScp xid=0x%x", 693 (struct sockaddr *)__get_dynamic_array(addr), 694 be32_to_cpu(__entry->xid)) 695 ); 696 697 DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, 698 TP_PROTO(struct svc_deferred_req *dr), 699 TP_ARGS(dr)); 700 DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, 701 TP_PROTO(struct svc_deferred_req *dr), 702 TP_ARGS(dr)); 703 #endif /* _TRACE_SUNRPC_H */ 704 705 #include <trace/define_trace.h> 706