1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #undef TRACE_SYSTEM 3 #define TRACE_SYSTEM sunrpc 4 5 #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ) 6 #define _TRACE_SUNRPC_H 7 8 #include <linux/sunrpc/sched.h> 9 #include <linux/sunrpc/clnt.h> 10 #include <linux/sunrpc/svc.h> 11 #include <linux/sunrpc/xprtsock.h> 12 #include <linux/sunrpc/svc_xprt.h> 13 #include <net/tcp_states.h> 14 #include <linux/net.h> 15 #include <linux/tracepoint.h> 16 17 TRACE_DEFINE_ENUM(RPC_AUTH_OK); 18 TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED); 19 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED); 20 TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF); 21 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF); 22 TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK); 23 TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM); 24 TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM); 25 26 #define rpc_show_auth_stat(status) \ 27 __print_symbolic(status, \ 28 { RPC_AUTH_OK, "AUTH_OK" }, \ 29 { RPC_AUTH_BADCRED, "BADCRED" }, \ 30 { RPC_AUTH_REJECTEDCRED, "REJECTEDCRED" }, \ 31 { RPC_AUTH_BADVERF, "BADVERF" }, \ 32 { RPC_AUTH_REJECTEDVERF, "REJECTEDVERF" }, \ 33 { RPC_AUTH_TOOWEAK, "TOOWEAK" }, \ 34 { RPCSEC_GSS_CREDPROBLEM, "GSS_CREDPROBLEM" }, \ 35 { RPCSEC_GSS_CTXPROBLEM, "GSS_CTXPROBLEM" }) \ 36 37 DECLARE_EVENT_CLASS(rpc_task_status, 38 39 TP_PROTO(const struct rpc_task *task), 40 41 TP_ARGS(task), 42 43 TP_STRUCT__entry( 44 __field(unsigned int, task_id) 45 __field(unsigned int, client_id) 46 __field(int, status) 47 ), 48 49 TP_fast_assign( 50 __entry->task_id = task->tk_pid; 51 __entry->client_id = task->tk_client->cl_clid; 52 __entry->status = task->tk_status; 53 ), 54 55 TP_printk("task:%u@%u status=%d", 56 __entry->task_id, __entry->client_id, 57 __entry->status) 58 ); 59 #define DEFINE_RPC_STATUS_EVENT(name) \ 60 DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \ 61 TP_PROTO( \ 62 const struct rpc_task *task \ 63 ), \ 64 TP_ARGS(task)) 65 66 DEFINE_RPC_STATUS_EVENT(call); 67 DEFINE_RPC_STATUS_EVENT(bind); 68 DEFINE_RPC_STATUS_EVENT(connect); 69 70 TRACE_EVENT(rpc_request, 71 TP_PROTO(const struct rpc_task *task), 72 73 TP_ARGS(task), 74 75 TP_STRUCT__entry( 76 __field(unsigned int, task_id) 77 __field(unsigned int, client_id) 78 __field(int, version) 79 __field(bool, async) 80 __string(progname, task->tk_client->cl_program->name) 81 __string(procname, rpc_proc_name(task)) 82 ), 83 84 TP_fast_assign( 85 __entry->task_id = task->tk_pid; 86 __entry->client_id = task->tk_client->cl_clid; 87 __entry->version = task->tk_client->cl_vers; 88 __entry->async = RPC_IS_ASYNC(task); 89 __assign_str(progname, task->tk_client->cl_program->name) 90 __assign_str(procname, rpc_proc_name(task)) 91 ), 92 93 TP_printk("task:%u@%u %sv%d %s (%ssync)", 94 __entry->task_id, __entry->client_id, 95 __get_str(progname), __entry->version, 96 __get_str(procname), __entry->async ? "a": "" 97 ) 98 ); 99 100 TRACE_DEFINE_ENUM(RPC_TASK_ASYNC); 101 TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER); 102 TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN); 103 TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS); 104 TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC); 105 TRACE_DEFINE_ENUM(RPC_TASK_SOFT); 106 TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN); 107 TRACE_DEFINE_ENUM(RPC_TASK_SENT); 108 TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT); 109 TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT); 110 TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT); 111 112 #define rpc_show_task_flags(flags) \ 113 __print_flags(flags, "|", \ 114 { RPC_TASK_ASYNC, "ASYNC" }, \ 115 { RPC_TASK_SWAPPER, "SWAPPER" }, \ 116 { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \ 117 { RPC_TASK_ROOTCREDS, "ROOTCREDS" }, \ 118 { RPC_TASK_DYNAMIC, "DYNAMIC" }, \ 119 { RPC_TASK_SOFT, "SOFT" }, \ 120 { RPC_TASK_SOFTCONN, "SOFTCONN" }, \ 121 { RPC_TASK_SENT, "SENT" }, \ 122 { RPC_TASK_TIMEOUT, "TIMEOUT" }, \ 123 { RPC_TASK_NOCONNECT, "NOCONNECT" }, \ 124 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }) 125 126 TRACE_DEFINE_ENUM(RPC_TASK_RUNNING); 127 TRACE_DEFINE_ENUM(RPC_TASK_QUEUED); 128 TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE); 129 TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT); 130 TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV); 131 TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT); 132 TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED); 133 134 #define rpc_show_runstate(flags) \ 135 __print_flags(flags, "|", \ 136 { (1UL << RPC_TASK_RUNNING), "RUNNING" }, \ 137 { (1UL << RPC_TASK_QUEUED), "QUEUED" }, \ 138 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" }, \ 139 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" }, \ 140 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" }, \ 141 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \ 142 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" }) 143 144 DECLARE_EVENT_CLASS(rpc_task_running, 145 146 TP_PROTO(const struct rpc_task *task, const void *action), 147 148 TP_ARGS(task, action), 149 150 TP_STRUCT__entry( 151 __field(unsigned int, task_id) 152 __field(unsigned int, client_id) 153 __field(const void *, action) 154 __field(unsigned long, runstate) 155 __field(int, status) 156 __field(unsigned short, flags) 157 ), 158 159 TP_fast_assign( 160 __entry->client_id = task->tk_client ? 161 task->tk_client->cl_clid : -1; 162 __entry->task_id = task->tk_pid; 163 __entry->action = action; 164 __entry->runstate = task->tk_runstate; 165 __entry->status = task->tk_status; 166 __entry->flags = task->tk_flags; 167 ), 168 169 TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps", 170 __entry->task_id, __entry->client_id, 171 rpc_show_task_flags(__entry->flags), 172 rpc_show_runstate(__entry->runstate), 173 __entry->status, 174 __entry->action 175 ) 176 ); 177 #define DEFINE_RPC_RUNNING_EVENT(name) \ 178 DEFINE_EVENT(rpc_task_running, rpc_task_##name, \ 179 TP_PROTO( \ 180 const struct rpc_task *task, \ 181 const void *action \ 182 ), \ 183 TP_ARGS(task, action)) 184 185 DEFINE_RPC_RUNNING_EVENT(begin); 186 DEFINE_RPC_RUNNING_EVENT(run_action); 187 DEFINE_RPC_RUNNING_EVENT(complete); 188 DEFINE_RPC_RUNNING_EVENT(end); 189 190 DECLARE_EVENT_CLASS(rpc_task_queued, 191 192 TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), 193 194 TP_ARGS(task, q), 195 196 TP_STRUCT__entry( 197 __field(unsigned int, task_id) 198 __field(unsigned int, client_id) 199 __field(unsigned long, timeout) 200 __field(unsigned long, runstate) 201 __field(int, status) 202 __field(unsigned short, flags) 203 __string(q_name, rpc_qname(q)) 204 ), 205 206 TP_fast_assign( 207 __entry->client_id = task->tk_client ? 208 task->tk_client->cl_clid : -1; 209 __entry->task_id = task->tk_pid; 210 __entry->timeout = rpc_task_timeout(task); 211 __entry->runstate = task->tk_runstate; 212 __entry->status = task->tk_status; 213 __entry->flags = task->tk_flags; 214 __assign_str(q_name, rpc_qname(q)); 215 ), 216 217 TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s", 218 __entry->task_id, __entry->client_id, 219 rpc_show_task_flags(__entry->flags), 220 rpc_show_runstate(__entry->runstate), 221 __entry->status, 222 __entry->timeout, 223 __get_str(q_name) 224 ) 225 ); 226 #define DEFINE_RPC_QUEUED_EVENT(name) \ 227 DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \ 228 TP_PROTO( \ 229 const struct rpc_task *task, \ 230 const struct rpc_wait_queue *q \ 231 ), \ 232 TP_ARGS(task, q)) 233 234 DEFINE_RPC_QUEUED_EVENT(sleep); 235 DEFINE_RPC_QUEUED_EVENT(wakeup); 236 237 DECLARE_EVENT_CLASS(rpc_failure, 238 239 TP_PROTO(const struct rpc_task *task), 240 241 TP_ARGS(task), 242 243 TP_STRUCT__entry( 244 __field(unsigned int, task_id) 245 __field(unsigned int, client_id) 246 ), 247 248 TP_fast_assign( 249 __entry->task_id = task->tk_pid; 250 __entry->client_id = task->tk_client->cl_clid; 251 ), 252 253 TP_printk("task:%u@%u", 254 __entry->task_id, __entry->client_id) 255 ); 256 257 #define DEFINE_RPC_FAILURE(name) \ 258 DEFINE_EVENT(rpc_failure, rpc_bad_##name, \ 259 TP_PROTO( \ 260 const struct rpc_task *task \ 261 ), \ 262 TP_ARGS(task)) 263 264 DEFINE_RPC_FAILURE(callhdr); 265 DEFINE_RPC_FAILURE(verifier); 266 267 DECLARE_EVENT_CLASS(rpc_reply_event, 268 269 TP_PROTO( 270 const struct rpc_task *task 271 ), 272 273 TP_ARGS(task), 274 275 TP_STRUCT__entry( 276 __field(unsigned int, task_id) 277 __field(unsigned int, client_id) 278 __field(u32, xid) 279 __string(progname, task->tk_client->cl_program->name) 280 __field(u32, version) 281 __string(procname, rpc_proc_name(task)) 282 __string(servername, task->tk_xprt->servername) 283 ), 284 285 TP_fast_assign( 286 __entry->task_id = task->tk_pid; 287 __entry->client_id = task->tk_client->cl_clid; 288 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid); 289 __assign_str(progname, task->tk_client->cl_program->name) 290 __entry->version = task->tk_client->cl_vers; 291 __assign_str(procname, rpc_proc_name(task)) 292 __assign_str(servername, task->tk_xprt->servername) 293 ), 294 295 TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s", 296 __entry->task_id, __entry->client_id, __get_str(servername), 297 __entry->xid, __get_str(progname), __entry->version, 298 __get_str(procname)) 299 ) 300 301 #define DEFINE_RPC_REPLY_EVENT(name) \ 302 DEFINE_EVENT(rpc_reply_event, rpc__##name, \ 303 TP_PROTO( \ 304 const struct rpc_task *task \ 305 ), \ 306 TP_ARGS(task)) 307 308 DEFINE_RPC_REPLY_EVENT(prog_unavail); 309 DEFINE_RPC_REPLY_EVENT(prog_mismatch); 310 DEFINE_RPC_REPLY_EVENT(proc_unavail); 311 DEFINE_RPC_REPLY_EVENT(garbage_args); 312 DEFINE_RPC_REPLY_EVENT(unparsable); 313 DEFINE_RPC_REPLY_EVENT(mismatch); 314 DEFINE_RPC_REPLY_EVENT(stale_creds); 315 DEFINE_RPC_REPLY_EVENT(bad_creds); 316 DEFINE_RPC_REPLY_EVENT(auth_tooweak); 317 318 TRACE_EVENT(rpc_stats_latency, 319 320 TP_PROTO( 321 const struct rpc_task *task, 322 ktime_t backlog, 323 ktime_t rtt, 324 ktime_t execute 325 ), 326 327 TP_ARGS(task, backlog, rtt, execute), 328 329 TP_STRUCT__entry( 330 __field(unsigned int, task_id) 331 __field(unsigned int, client_id) 332 __field(u32, xid) 333 __field(int, version) 334 __string(progname, task->tk_client->cl_program->name) 335 __string(procname, rpc_proc_name(task)) 336 __field(unsigned long, backlog) 337 __field(unsigned long, rtt) 338 __field(unsigned long, execute) 339 ), 340 341 TP_fast_assign( 342 __entry->client_id = task->tk_client->cl_clid; 343 __entry->task_id = task->tk_pid; 344 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid); 345 __entry->version = task->tk_client->cl_vers; 346 __assign_str(progname, task->tk_client->cl_program->name) 347 __assign_str(procname, rpc_proc_name(task)) 348 __entry->backlog = ktime_to_us(backlog); 349 __entry->rtt = ktime_to_us(rtt); 350 __entry->execute = ktime_to_us(execute); 351 ), 352 353 TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu", 354 __entry->task_id, __entry->client_id, __entry->xid, 355 __get_str(progname), __entry->version, __get_str(procname), 356 __entry->backlog, __entry->rtt, __entry->execute) 357 ); 358 359 TRACE_EVENT(rpc_xdr_overflow, 360 TP_PROTO( 361 const struct xdr_stream *xdr, 362 size_t requested 363 ), 364 365 TP_ARGS(xdr, requested), 366 367 TP_STRUCT__entry( 368 __field(unsigned int, task_id) 369 __field(unsigned int, client_id) 370 __field(int, version) 371 __field(size_t, requested) 372 __field(const void *, end) 373 __field(const void *, p) 374 __field(const void *, head_base) 375 __field(size_t, head_len) 376 __field(const void *, tail_base) 377 __field(size_t, tail_len) 378 __field(unsigned int, page_len) 379 __field(unsigned int, len) 380 __string(progname, 381 xdr->rqst->rq_task->tk_client->cl_program->name) 382 __string(procedure, 383 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 384 ), 385 386 TP_fast_assign( 387 if (xdr->rqst) { 388 const struct rpc_task *task = xdr->rqst->rq_task; 389 390 __entry->task_id = task->tk_pid; 391 __entry->client_id = task->tk_client->cl_clid; 392 __assign_str(progname, 393 task->tk_client->cl_program->name) 394 __entry->version = task->tk_client->cl_vers; 395 __assign_str(procedure, task->tk_msg.rpc_proc->p_name) 396 } else { 397 __entry->task_id = 0; 398 __entry->client_id = 0; 399 __assign_str(progname, "unknown") 400 __entry->version = 0; 401 __assign_str(procedure, "unknown") 402 } 403 __entry->requested = requested; 404 __entry->end = xdr->end; 405 __entry->p = xdr->p; 406 __entry->head_base = xdr->buf->head[0].iov_base, 407 __entry->head_len = xdr->buf->head[0].iov_len, 408 __entry->page_len = xdr->buf->page_len, 409 __entry->tail_base = xdr->buf->tail[0].iov_base, 410 __entry->tail_len = xdr->buf->tail[0].iov_len, 411 __entry->len = xdr->buf->len; 412 ), 413 414 TP_printk( 415 "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n", 416 __entry->task_id, __entry->client_id, 417 __get_str(progname), __entry->version, __get_str(procedure), 418 __entry->requested, __entry->p, __entry->end, 419 __entry->head_base, __entry->head_len, 420 __entry->page_len, 421 __entry->tail_base, __entry->tail_len, 422 __entry->len 423 ) 424 ); 425 426 TRACE_EVENT(rpc_xdr_alignment, 427 TP_PROTO( 428 const struct xdr_stream *xdr, 429 size_t offset, 430 unsigned int copied 431 ), 432 433 TP_ARGS(xdr, offset, copied), 434 435 TP_STRUCT__entry( 436 __field(unsigned int, task_id) 437 __field(unsigned int, client_id) 438 __field(int, version) 439 __field(size_t, offset) 440 __field(unsigned int, copied) 441 __field(const void *, head_base) 442 __field(size_t, head_len) 443 __field(const void *, tail_base) 444 __field(size_t, tail_len) 445 __field(unsigned int, page_len) 446 __field(unsigned int, len) 447 __string(progname, 448 xdr->rqst->rq_task->tk_client->cl_program->name) 449 __string(procedure, 450 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 451 ), 452 453 TP_fast_assign( 454 const struct rpc_task *task = xdr->rqst->rq_task; 455 456 __entry->task_id = task->tk_pid; 457 __entry->client_id = task->tk_client->cl_clid; 458 __assign_str(progname, 459 task->tk_client->cl_program->name) 460 __entry->version = task->tk_client->cl_vers; 461 __assign_str(procedure, task->tk_msg.rpc_proc->p_name) 462 463 __entry->offset = offset; 464 __entry->copied = copied; 465 __entry->head_base = xdr->buf->head[0].iov_base, 466 __entry->head_len = xdr->buf->head[0].iov_len, 467 __entry->page_len = xdr->buf->page_len, 468 __entry->tail_base = xdr->buf->tail[0].iov_base, 469 __entry->tail_len = xdr->buf->tail[0].iov_len, 470 __entry->len = xdr->buf->len; 471 ), 472 473 TP_printk( 474 "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n", 475 __entry->task_id, __entry->client_id, 476 __get_str(progname), __entry->version, __get_str(procedure), 477 __entry->offset, __entry->copied, 478 __entry->head_base, __entry->head_len, 479 __entry->page_len, 480 __entry->tail_base, __entry->tail_len, 481 __entry->len 482 ) 483 ); 484 485 TRACE_EVENT(rpc_reply_pages, 486 TP_PROTO( 487 const struct rpc_rqst *req 488 ), 489 490 TP_ARGS(req), 491 492 TP_STRUCT__entry( 493 __field(unsigned int, task_id) 494 __field(unsigned int, client_id) 495 __field(const void *, head_base) 496 __field(size_t, head_len) 497 __field(const void *, tail_base) 498 __field(size_t, tail_len) 499 __field(unsigned int, page_len) 500 ), 501 502 TP_fast_assign( 503 __entry->task_id = req->rq_task->tk_pid; 504 __entry->client_id = req->rq_task->tk_client->cl_clid; 505 506 __entry->head_base = req->rq_rcv_buf.head[0].iov_base; 507 __entry->head_len = req->rq_rcv_buf.head[0].iov_len; 508 __entry->page_len = req->rq_rcv_buf.page_len; 509 __entry->tail_base = req->rq_rcv_buf.tail[0].iov_base; 510 __entry->tail_len = req->rq_rcv_buf.tail[0].iov_len; 511 ), 512 513 TP_printk( 514 "task:%u@%u xdr=[%p,%zu]/%u/[%p,%zu]\n", 515 __entry->task_id, __entry->client_id, 516 __entry->head_base, __entry->head_len, 517 __entry->page_len, 518 __entry->tail_base, __entry->tail_len 519 ) 520 ); 521 522 /* 523 * First define the enums in the below macros to be exported to userspace 524 * via TRACE_DEFINE_ENUM(). 525 */ 526 #undef EM 527 #undef EMe 528 #define EM(a, b) TRACE_DEFINE_ENUM(a); 529 #define EMe(a, b) TRACE_DEFINE_ENUM(a); 530 531 #define RPC_SHOW_SOCKET \ 532 EM( SS_FREE, "FREE" ) \ 533 EM( SS_UNCONNECTED, "UNCONNECTED" ) \ 534 EM( SS_CONNECTING, "CONNECTING," ) \ 535 EM( SS_CONNECTED, "CONNECTED," ) \ 536 EMe(SS_DISCONNECTING, "DISCONNECTING" ) 537 538 #define rpc_show_socket_state(state) \ 539 __print_symbolic(state, RPC_SHOW_SOCKET) 540 541 RPC_SHOW_SOCKET 542 543 #define RPC_SHOW_SOCK \ 544 EM( TCP_ESTABLISHED, "ESTABLISHED" ) \ 545 EM( TCP_SYN_SENT, "SYN_SENT" ) \ 546 EM( TCP_SYN_RECV, "SYN_RECV" ) \ 547 EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \ 548 EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \ 549 EM( TCP_TIME_WAIT, "TIME_WAIT" ) \ 550 EM( TCP_CLOSE, "CLOSE" ) \ 551 EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \ 552 EM( TCP_LAST_ACK, "LAST_ACK" ) \ 553 EM( TCP_LISTEN, "LISTEN" ) \ 554 EMe( TCP_CLOSING, "CLOSING" ) 555 556 #define rpc_show_sock_state(state) \ 557 __print_symbolic(state, RPC_SHOW_SOCK) 558 559 RPC_SHOW_SOCK 560 561 /* 562 * Now redefine the EM() and EMe() macros to map the enums to the strings 563 * that will be printed in the output. 564 */ 565 #undef EM 566 #undef EMe 567 #define EM(a, b) {a, b}, 568 #define EMe(a, b) {a, b} 569 570 DECLARE_EVENT_CLASS(xs_socket_event, 571 572 TP_PROTO( 573 struct rpc_xprt *xprt, 574 struct socket *socket 575 ), 576 577 TP_ARGS(xprt, socket), 578 579 TP_STRUCT__entry( 580 __field(unsigned int, socket_state) 581 __field(unsigned int, sock_state) 582 __field(unsigned long long, ino) 583 __string(dstaddr, 584 xprt->address_strings[RPC_DISPLAY_ADDR]) 585 __string(dstport, 586 xprt->address_strings[RPC_DISPLAY_PORT]) 587 ), 588 589 TP_fast_assign( 590 struct inode *inode = SOCK_INODE(socket); 591 __entry->socket_state = socket->state; 592 __entry->sock_state = socket->sk->sk_state; 593 __entry->ino = (unsigned long long)inode->i_ino; 594 __assign_str(dstaddr, 595 xprt->address_strings[RPC_DISPLAY_ADDR]); 596 __assign_str(dstport, 597 xprt->address_strings[RPC_DISPLAY_PORT]); 598 ), 599 600 TP_printk( 601 "socket:[%llu] dstaddr=%s/%s " 602 "state=%u (%s) sk_state=%u (%s)", 603 __entry->ino, __get_str(dstaddr), __get_str(dstport), 604 __entry->socket_state, 605 rpc_show_socket_state(__entry->socket_state), 606 __entry->sock_state, 607 rpc_show_sock_state(__entry->sock_state) 608 ) 609 ); 610 #define DEFINE_RPC_SOCKET_EVENT(name) \ 611 DEFINE_EVENT(xs_socket_event, name, \ 612 TP_PROTO( \ 613 struct rpc_xprt *xprt, \ 614 struct socket *socket \ 615 ), \ 616 TP_ARGS(xprt, socket)) 617 618 DECLARE_EVENT_CLASS(xs_socket_event_done, 619 620 TP_PROTO( 621 struct rpc_xprt *xprt, 622 struct socket *socket, 623 int error 624 ), 625 626 TP_ARGS(xprt, socket, error), 627 628 TP_STRUCT__entry( 629 __field(int, error) 630 __field(unsigned int, socket_state) 631 __field(unsigned int, sock_state) 632 __field(unsigned long long, ino) 633 __string(dstaddr, 634 xprt->address_strings[RPC_DISPLAY_ADDR]) 635 __string(dstport, 636 xprt->address_strings[RPC_DISPLAY_PORT]) 637 ), 638 639 TP_fast_assign( 640 struct inode *inode = SOCK_INODE(socket); 641 __entry->socket_state = socket->state; 642 __entry->sock_state = socket->sk->sk_state; 643 __entry->ino = (unsigned long long)inode->i_ino; 644 __entry->error = error; 645 __assign_str(dstaddr, 646 xprt->address_strings[RPC_DISPLAY_ADDR]); 647 __assign_str(dstport, 648 xprt->address_strings[RPC_DISPLAY_PORT]); 649 ), 650 651 TP_printk( 652 "error=%d socket:[%llu] dstaddr=%s/%s " 653 "state=%u (%s) sk_state=%u (%s)", 654 __entry->error, 655 __entry->ino, __get_str(dstaddr), __get_str(dstport), 656 __entry->socket_state, 657 rpc_show_socket_state(__entry->socket_state), 658 __entry->sock_state, 659 rpc_show_sock_state(__entry->sock_state) 660 ) 661 ); 662 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \ 663 DEFINE_EVENT(xs_socket_event_done, name, \ 664 TP_PROTO( \ 665 struct rpc_xprt *xprt, \ 666 struct socket *socket, \ 667 int error \ 668 ), \ 669 TP_ARGS(xprt, socket, error)) 670 671 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); 672 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); 673 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); 674 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); 675 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); 676 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); 677 678 DECLARE_EVENT_CLASS(rpc_xprt_event, 679 TP_PROTO( 680 const struct rpc_xprt *xprt, 681 __be32 xid, 682 int status 683 ), 684 685 TP_ARGS(xprt, xid, status), 686 687 TP_STRUCT__entry( 688 __field(u32, xid) 689 __field(int, status) 690 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) 691 __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) 692 ), 693 694 TP_fast_assign( 695 __entry->xid = be32_to_cpu(xid); 696 __entry->status = status; 697 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); 698 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); 699 ), 700 701 TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr), 702 __get_str(port), __entry->xid, 703 __entry->status) 704 ); 705 #define DEFINE_RPC_XPRT_EVENT(name) \ 706 DEFINE_EVENT(rpc_xprt_event, xprt_##name, \ 707 TP_PROTO( \ 708 const struct rpc_xprt *xprt, \ 709 __be32 xid, \ 710 int status \ 711 ), \ 712 TP_ARGS(xprt, xid, status)) 713 714 DEFINE_RPC_XPRT_EVENT(timer); 715 DEFINE_RPC_XPRT_EVENT(lookup_rqst); 716 DEFINE_RPC_XPRT_EVENT(complete_rqst); 717 718 TRACE_EVENT(xprt_transmit, 719 TP_PROTO( 720 const struct rpc_rqst *rqst, 721 int status 722 ), 723 724 TP_ARGS(rqst, status), 725 726 TP_STRUCT__entry( 727 __field(unsigned int, task_id) 728 __field(unsigned int, client_id) 729 __field(u32, xid) 730 __field(u32, seqno) 731 __field(int, status) 732 ), 733 734 TP_fast_assign( 735 __entry->task_id = rqst->rq_task->tk_pid; 736 __entry->client_id = rqst->rq_task->tk_client ? 737 rqst->rq_task->tk_client->cl_clid : -1; 738 __entry->xid = be32_to_cpu(rqst->rq_xid); 739 __entry->seqno = rqst->rq_seqno; 740 __entry->status = status; 741 ), 742 743 TP_printk( 744 "task:%u@%u xid=0x%08x seqno=%u status=%d", 745 __entry->task_id, __entry->client_id, __entry->xid, 746 __entry->seqno, __entry->status) 747 ); 748 749 TRACE_EVENT(xprt_enq_xmit, 750 TP_PROTO( 751 const struct rpc_task *task, 752 int stage 753 ), 754 755 TP_ARGS(task, stage), 756 757 TP_STRUCT__entry( 758 __field(unsigned int, task_id) 759 __field(unsigned int, client_id) 760 __field(u32, xid) 761 __field(u32, seqno) 762 __field(int, stage) 763 ), 764 765 TP_fast_assign( 766 __entry->task_id = task->tk_pid; 767 __entry->client_id = task->tk_client ? 768 task->tk_client->cl_clid : -1; 769 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid); 770 __entry->seqno = task->tk_rqstp->rq_seqno; 771 __entry->stage = stage; 772 ), 773 774 TP_printk( 775 "task:%u@%u xid=0x%08x seqno=%u stage=%d", 776 __entry->task_id, __entry->client_id, __entry->xid, 777 __entry->seqno, __entry->stage) 778 ); 779 780 TRACE_EVENT(xprt_ping, 781 TP_PROTO(const struct rpc_xprt *xprt, int status), 782 783 TP_ARGS(xprt, status), 784 785 TP_STRUCT__entry( 786 __field(int, status) 787 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) 788 __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) 789 ), 790 791 TP_fast_assign( 792 __entry->status = status; 793 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); 794 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); 795 ), 796 797 TP_printk("peer=[%s]:%s status=%d", 798 __get_str(addr), __get_str(port), __entry->status) 799 ); 800 801 DECLARE_EVENT_CLASS(xprt_writelock_event, 802 TP_PROTO( 803 const struct rpc_xprt *xprt, const struct rpc_task *task 804 ), 805 806 TP_ARGS(xprt, task), 807 808 TP_STRUCT__entry( 809 __field(unsigned int, task_id) 810 __field(unsigned int, client_id) 811 __field(unsigned int, snd_task_id) 812 ), 813 814 TP_fast_assign( 815 if (task) { 816 __entry->task_id = task->tk_pid; 817 __entry->client_id = task->tk_client ? 818 task->tk_client->cl_clid : -1; 819 } else { 820 __entry->task_id = -1; 821 __entry->client_id = -1; 822 } 823 __entry->snd_task_id = xprt->snd_task ? 824 xprt->snd_task->tk_pid : -1; 825 ), 826 827 TP_printk("task:%u@%u snd_task:%u", 828 __entry->task_id, __entry->client_id, 829 __entry->snd_task_id) 830 ); 831 832 #define DEFINE_WRITELOCK_EVENT(name) \ 833 DEFINE_EVENT(xprt_writelock_event, xprt_##name, \ 834 TP_PROTO( \ 835 const struct rpc_xprt *xprt, \ 836 const struct rpc_task *task \ 837 ), \ 838 TP_ARGS(xprt, task)) 839 840 DEFINE_WRITELOCK_EVENT(reserve_xprt); 841 DEFINE_WRITELOCK_EVENT(release_xprt); 842 843 DECLARE_EVENT_CLASS(xprt_cong_event, 844 TP_PROTO( 845 const struct rpc_xprt *xprt, const struct rpc_task *task 846 ), 847 848 TP_ARGS(xprt, task), 849 850 TP_STRUCT__entry( 851 __field(unsigned int, task_id) 852 __field(unsigned int, client_id) 853 __field(unsigned int, snd_task_id) 854 __field(unsigned long, cong) 855 __field(unsigned long, cwnd) 856 __field(bool, wait) 857 ), 858 859 TP_fast_assign( 860 if (task) { 861 __entry->task_id = task->tk_pid; 862 __entry->client_id = task->tk_client ? 863 task->tk_client->cl_clid : -1; 864 } else { 865 __entry->task_id = -1; 866 __entry->client_id = -1; 867 } 868 __entry->snd_task_id = xprt->snd_task ? 869 xprt->snd_task->tk_pid : -1; 870 __entry->cong = xprt->cong; 871 __entry->cwnd = xprt->cwnd; 872 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state); 873 ), 874 875 TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s", 876 __entry->task_id, __entry->client_id, 877 __entry->snd_task_id, __entry->cong, __entry->cwnd, 878 __entry->wait ? " (wait)" : "") 879 ); 880 881 #define DEFINE_CONG_EVENT(name) \ 882 DEFINE_EVENT(xprt_cong_event, xprt_##name, \ 883 TP_PROTO( \ 884 const struct rpc_xprt *xprt, \ 885 const struct rpc_task *task \ 886 ), \ 887 TP_ARGS(xprt, task)) 888 889 DEFINE_CONG_EVENT(reserve_cong); 890 DEFINE_CONG_EVENT(release_cong); 891 DEFINE_CONG_EVENT(get_cong); 892 DEFINE_CONG_EVENT(put_cong); 893 894 TRACE_EVENT(xs_stream_read_data, 895 TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total), 896 897 TP_ARGS(xprt, err, total), 898 899 TP_STRUCT__entry( 900 __field(ssize_t, err) 901 __field(size_t, total) 902 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] : 903 "(null)") 904 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] : 905 "(null)") 906 ), 907 908 TP_fast_assign( 909 __entry->err = err; 910 __entry->total = total; 911 __assign_str(addr, xprt ? 912 xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)"); 913 __assign_str(port, xprt ? 914 xprt->address_strings[RPC_DISPLAY_PORT] : "(null)"); 915 ), 916 917 TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr), 918 __get_str(port), __entry->err, __entry->total) 919 ); 920 921 TRACE_EVENT(xs_stream_read_request, 922 TP_PROTO(struct sock_xprt *xs), 923 924 TP_ARGS(xs), 925 926 TP_STRUCT__entry( 927 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]) 928 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]) 929 __field(u32, xid) 930 __field(unsigned long, copied) 931 __field(unsigned int, reclen) 932 __field(unsigned int, offset) 933 ), 934 935 TP_fast_assign( 936 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]); 937 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]); 938 __entry->xid = be32_to_cpu(xs->recv.xid); 939 __entry->copied = xs->recv.copied; 940 __entry->reclen = xs->recv.len; 941 __entry->offset = xs->recv.offset; 942 ), 943 944 TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u", 945 __get_str(addr), __get_str(port), __entry->xid, 946 __entry->copied, __entry->reclen, __entry->offset) 947 ); 948 949 #define show_rqstp_flags(flags) \ 950 __print_flags(flags, "|", \ 951 { (1UL << RQ_SECURE), "RQ_SECURE"}, \ 952 { (1UL << RQ_LOCAL), "RQ_LOCAL"}, \ 953 { (1UL << RQ_USEDEFERRAL), "RQ_USEDEFERRAL"}, \ 954 { (1UL << RQ_DROPME), "RQ_DROPME"}, \ 955 { (1UL << RQ_SPLICE_OK), "RQ_SPLICE_OK"}, \ 956 { (1UL << RQ_VICTIM), "RQ_VICTIM"}, \ 957 { (1UL << RQ_BUSY), "RQ_BUSY"}) 958 959 TRACE_EVENT(svc_recv, 960 TP_PROTO(struct svc_rqst *rqst, int len), 961 962 TP_ARGS(rqst, len), 963 964 TP_STRUCT__entry( 965 __field(u32, xid) 966 __field(int, len) 967 __field(unsigned long, flags) 968 __string(addr, rqst->rq_xprt->xpt_remotebuf) 969 ), 970 971 TP_fast_assign( 972 __entry->xid = be32_to_cpu(rqst->rq_xid); 973 __entry->len = len; 974 __entry->flags = rqst->rq_flags; 975 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 976 ), 977 978 TP_printk("addr=%s xid=0x%08x len=%d flags=%s", 979 __get_str(addr), __entry->xid, __entry->len, 980 show_rqstp_flags(__entry->flags)) 981 ); 982 983 #define svc_show_status(status) \ 984 __print_symbolic(status, \ 985 { SVC_GARBAGE, "SVC_GARBAGE" }, \ 986 { SVC_SYSERR, "SVC_SYSERR" }, \ 987 { SVC_VALID, "SVC_VALID" }, \ 988 { SVC_NEGATIVE, "SVC_NEGATIVE" }, \ 989 { SVC_OK, "SVC_OK" }, \ 990 { SVC_DROP, "SVC_DROP" }, \ 991 { SVC_CLOSE, "SVC_CLOSE" }, \ 992 { SVC_DENIED, "SVC_DENIED" }, \ 993 { SVC_PENDING, "SVC_PENDING" }, \ 994 { SVC_COMPLETE, "SVC_COMPLETE" }) 995 996 TRACE_EVENT(svc_authenticate, 997 TP_PROTO(const struct svc_rqst *rqst, int auth_res, __be32 auth_stat), 998 999 TP_ARGS(rqst, auth_res, auth_stat), 1000 1001 TP_STRUCT__entry( 1002 __field(u32, xid) 1003 __field(unsigned long, svc_status) 1004 __field(unsigned long, auth_stat) 1005 ), 1006 1007 TP_fast_assign( 1008 __entry->xid = be32_to_cpu(rqst->rq_xid); 1009 __entry->svc_status = auth_res; 1010 __entry->auth_stat = be32_to_cpu(auth_stat); 1011 ), 1012 1013 TP_printk("xid=0x%08x auth_res=%s auth_stat=%s", 1014 __entry->xid, svc_show_status(__entry->svc_status), 1015 rpc_show_auth_stat(__entry->auth_stat)) 1016 ); 1017 1018 TRACE_EVENT(svc_process, 1019 TP_PROTO(const struct svc_rqst *rqst, const char *name), 1020 1021 TP_ARGS(rqst, name), 1022 1023 TP_STRUCT__entry( 1024 __field(u32, xid) 1025 __field(u32, vers) 1026 __field(u32, proc) 1027 __string(service, name) 1028 __string(addr, rqst->rq_xprt ? 1029 rqst->rq_xprt->xpt_remotebuf : "(null)") 1030 ), 1031 1032 TP_fast_assign( 1033 __entry->xid = be32_to_cpu(rqst->rq_xid); 1034 __entry->vers = rqst->rq_vers; 1035 __entry->proc = rqst->rq_proc; 1036 __assign_str(service, name); 1037 __assign_str(addr, rqst->rq_xprt ? 1038 rqst->rq_xprt->xpt_remotebuf : "(null)"); 1039 ), 1040 1041 TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%u", 1042 __get_str(addr), __entry->xid, 1043 __get_str(service), __entry->vers, __entry->proc) 1044 ); 1045 1046 DECLARE_EVENT_CLASS(svc_rqst_event, 1047 1048 TP_PROTO( 1049 const struct svc_rqst *rqst 1050 ), 1051 1052 TP_ARGS(rqst), 1053 1054 TP_STRUCT__entry( 1055 __field(u32, xid) 1056 __field(unsigned long, flags) 1057 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1058 ), 1059 1060 TP_fast_assign( 1061 __entry->xid = be32_to_cpu(rqst->rq_xid); 1062 __entry->flags = rqst->rq_flags; 1063 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1064 ), 1065 1066 TP_printk("addr=%s xid=0x%08x flags=%s", 1067 __get_str(addr), __entry->xid, 1068 show_rqstp_flags(__entry->flags)) 1069 ); 1070 #define DEFINE_SVC_RQST_EVENT(name) \ 1071 DEFINE_EVENT(svc_rqst_event, svc_##name, \ 1072 TP_PROTO( \ 1073 const struct svc_rqst *rqst \ 1074 ), \ 1075 TP_ARGS(rqst)) 1076 1077 DEFINE_SVC_RQST_EVENT(defer); 1078 DEFINE_SVC_RQST_EVENT(drop); 1079 1080 DECLARE_EVENT_CLASS(svc_rqst_status, 1081 1082 TP_PROTO(struct svc_rqst *rqst, int status), 1083 1084 TP_ARGS(rqst, status), 1085 1086 TP_STRUCT__entry( 1087 __field(u32, xid) 1088 __field(int, status) 1089 __field(unsigned long, flags) 1090 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1091 ), 1092 1093 TP_fast_assign( 1094 __entry->xid = be32_to_cpu(rqst->rq_xid); 1095 __entry->status = status; 1096 __entry->flags = rqst->rq_flags; 1097 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1098 ), 1099 1100 TP_printk("addr=%s xid=0x%08x status=%d flags=%s", 1101 __get_str(addr), __entry->xid, 1102 __entry->status, show_rqstp_flags(__entry->flags)) 1103 ); 1104 1105 DEFINE_EVENT(svc_rqst_status, svc_send, 1106 TP_PROTO(struct svc_rqst *rqst, int status), 1107 TP_ARGS(rqst, status)); 1108 1109 #define show_svc_xprt_flags(flags) \ 1110 __print_flags(flags, "|", \ 1111 { (1UL << XPT_BUSY), "XPT_BUSY"}, \ 1112 { (1UL << XPT_CONN), "XPT_CONN"}, \ 1113 { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \ 1114 { (1UL << XPT_DATA), "XPT_DATA"}, \ 1115 { (1UL << XPT_TEMP), "XPT_TEMP"}, \ 1116 { (1UL << XPT_DEAD), "XPT_DEAD"}, \ 1117 { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \ 1118 { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \ 1119 { (1UL << XPT_OLD), "XPT_OLD"}, \ 1120 { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \ 1121 { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \ 1122 { (1UL << XPT_LOCAL), "XPT_LOCAL"}, \ 1123 { (1UL << XPT_KILL_TEMP), "XPT_KILL_TEMP"}, \ 1124 { (1UL << XPT_CONG_CTRL), "XPT_CONG_CTRL"}) 1125 1126 TRACE_EVENT(svc_xprt_do_enqueue, 1127 TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), 1128 1129 TP_ARGS(xprt, rqst), 1130 1131 TP_STRUCT__entry( 1132 __field(struct svc_xprt *, xprt) 1133 __field(int, pid) 1134 __field(unsigned long, flags) 1135 __string(addr, xprt->xpt_remotebuf) 1136 ), 1137 1138 TP_fast_assign( 1139 __entry->xprt = xprt; 1140 __entry->pid = rqst? rqst->rq_task->pid : 0; 1141 __entry->flags = xprt->xpt_flags; 1142 __assign_str(addr, xprt->xpt_remotebuf); 1143 ), 1144 1145 TP_printk("xprt=%p addr=%s pid=%d flags=%s", 1146 __entry->xprt, __get_str(addr), 1147 __entry->pid, show_svc_xprt_flags(__entry->flags)) 1148 ); 1149 1150 DECLARE_EVENT_CLASS(svc_xprt_event, 1151 TP_PROTO(struct svc_xprt *xprt), 1152 1153 TP_ARGS(xprt), 1154 1155 TP_STRUCT__entry( 1156 __field(struct svc_xprt *, xprt) 1157 __field(unsigned long, flags) 1158 __string(addr, xprt->xpt_remotebuf) 1159 ), 1160 1161 TP_fast_assign( 1162 __entry->xprt = xprt; 1163 __entry->flags = xprt->xpt_flags; 1164 __assign_str(addr, xprt->xpt_remotebuf); 1165 ), 1166 1167 TP_printk("xprt=%p addr=%s flags=%s", 1168 __entry->xprt, __get_str(addr), 1169 show_svc_xprt_flags(__entry->flags)) 1170 ); 1171 1172 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, 1173 TP_PROTO(struct svc_xprt *xprt), 1174 TP_ARGS(xprt)); 1175 1176 TRACE_EVENT(svc_xprt_dequeue, 1177 TP_PROTO(struct svc_rqst *rqst), 1178 1179 TP_ARGS(rqst), 1180 1181 TP_STRUCT__entry( 1182 __field(struct svc_xprt *, xprt) 1183 __field(unsigned long, flags) 1184 __field(unsigned long, wakeup) 1185 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1186 ), 1187 1188 TP_fast_assign( 1189 __entry->xprt = rqst->rq_xprt; 1190 __entry->flags = rqst->rq_xprt->xpt_flags; 1191 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(), 1192 rqst->rq_qtime)); 1193 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1194 ), 1195 1196 TP_printk("xprt=%p addr=%s flags=%s wakeup-us=%lu", 1197 __entry->xprt, __get_str(addr), 1198 show_svc_xprt_flags(__entry->flags), 1199 __entry->wakeup) 1200 ); 1201 1202 TRACE_EVENT(svc_wake_up, 1203 TP_PROTO(int pid), 1204 1205 TP_ARGS(pid), 1206 1207 TP_STRUCT__entry( 1208 __field(int, pid) 1209 ), 1210 1211 TP_fast_assign( 1212 __entry->pid = pid; 1213 ), 1214 1215 TP_printk("pid=%d", __entry->pid) 1216 ); 1217 1218 TRACE_EVENT(svc_handle_xprt, 1219 TP_PROTO(struct svc_xprt *xprt, int len), 1220 1221 TP_ARGS(xprt, len), 1222 1223 TP_STRUCT__entry( 1224 __field(struct svc_xprt *, xprt) 1225 __field(int, len) 1226 __field(unsigned long, flags) 1227 __string(addr, xprt->xpt_remotebuf) 1228 ), 1229 1230 TP_fast_assign( 1231 __entry->xprt = xprt; 1232 __entry->len = len; 1233 __entry->flags = xprt->xpt_flags; 1234 __assign_str(addr, xprt->xpt_remotebuf); 1235 ), 1236 1237 TP_printk("xprt=%p addr=%s len=%d flags=%s", 1238 __entry->xprt, __get_str(addr), 1239 __entry->len, show_svc_xprt_flags(__entry->flags)) 1240 ); 1241 1242 TRACE_EVENT(svc_stats_latency, 1243 TP_PROTO(const struct svc_rqst *rqst), 1244 1245 TP_ARGS(rqst), 1246 1247 TP_STRUCT__entry( 1248 __field(u32, xid) 1249 __field(unsigned long, execute) 1250 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1251 ), 1252 1253 TP_fast_assign( 1254 __entry->xid = be32_to_cpu(rqst->rq_xid); 1255 __entry->execute = ktime_to_us(ktime_sub(ktime_get(), 1256 rqst->rq_stime)); 1257 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1258 ), 1259 1260 TP_printk("addr=%s xid=0x%08x execute-us=%lu", 1261 __get_str(addr), __entry->xid, __entry->execute) 1262 ); 1263 1264 DECLARE_EVENT_CLASS(svc_deferred_event, 1265 TP_PROTO( 1266 const struct svc_deferred_req *dr 1267 ), 1268 1269 TP_ARGS(dr), 1270 1271 TP_STRUCT__entry( 1272 __field(u32, xid) 1273 __string(addr, dr->xprt->xpt_remotebuf) 1274 ), 1275 1276 TP_fast_assign( 1277 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args + 1278 (dr->xprt_hlen>>2))); 1279 __assign_str(addr, dr->xprt->xpt_remotebuf); 1280 ), 1281 1282 TP_printk("addr=%s xid=0x%08x", __get_str(addr), __entry->xid) 1283 ); 1284 #define DEFINE_SVC_DEFERRED_EVENT(name) \ 1285 DEFINE_EVENT(svc_deferred_event, svc_##name##_deferred, \ 1286 TP_PROTO( \ 1287 const struct svc_deferred_req *dr \ 1288 ), \ 1289 TP_ARGS(dr)) 1290 1291 DEFINE_SVC_DEFERRED_EVENT(drop); 1292 DEFINE_SVC_DEFERRED_EVENT(revisit); 1293 1294 #endif /* _TRACE_SUNRPC_H */ 1295 1296 #include <trace/define_trace.h> 1297