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 17TRACE_DEFINE_ENUM(SOCK_STREAM); 18TRACE_DEFINE_ENUM(SOCK_DGRAM); 19TRACE_DEFINE_ENUM(SOCK_RAW); 20TRACE_DEFINE_ENUM(SOCK_RDM); 21TRACE_DEFINE_ENUM(SOCK_SEQPACKET); 22TRACE_DEFINE_ENUM(SOCK_DCCP); 23TRACE_DEFINE_ENUM(SOCK_PACKET); 24 25#define show_socket_type(type) \ 26 __print_symbolic(type, \ 27 { SOCK_STREAM, "STREAM" }, \ 28 { SOCK_DGRAM, "DGRAM" }, \ 29 { SOCK_RAW, "RAW" }, \ 30 { SOCK_RDM, "RDM" }, \ 31 { SOCK_SEQPACKET, "SEQPACKET" }, \ 32 { SOCK_DCCP, "DCCP" }, \ 33 { SOCK_PACKET, "PACKET" }) 34 35/* This list is known to be incomplete, add new enums as needed. */ 36TRACE_DEFINE_ENUM(AF_UNSPEC); 37TRACE_DEFINE_ENUM(AF_UNIX); 38TRACE_DEFINE_ENUM(AF_LOCAL); 39TRACE_DEFINE_ENUM(AF_INET); 40TRACE_DEFINE_ENUM(AF_INET6); 41 42#define rpc_show_address_family(family) \ 43 __print_symbolic(family, \ 44 { AF_UNSPEC, "AF_UNSPEC" }, \ 45 { AF_UNIX, "AF_UNIX" }, \ 46 { AF_LOCAL, "AF_LOCAL" }, \ 47 { AF_INET, "AF_INET" }, \ 48 { AF_INET6, "AF_INET6" }) 49 50DECLARE_EVENT_CLASS(rpc_xdr_buf_class, 51 TP_PROTO( 52 const struct rpc_task *task, 53 const struct xdr_buf *xdr 54 ), 55 56 TP_ARGS(task, xdr), 57 58 TP_STRUCT__entry( 59 __field(unsigned int, task_id) 60 __field(unsigned int, client_id) 61 __field(const void *, head_base) 62 __field(size_t, head_len) 63 __field(const void *, tail_base) 64 __field(size_t, tail_len) 65 __field(unsigned int, page_len) 66 __field(unsigned int, msg_len) 67 ), 68 69 TP_fast_assign( 70 __entry->task_id = task->tk_pid; 71 __entry->client_id = task->tk_client ? 72 task->tk_client->cl_clid : -1; 73 __entry->head_base = xdr->head[0].iov_base; 74 __entry->head_len = xdr->head[0].iov_len; 75 __entry->tail_base = xdr->tail[0].iov_base; 76 __entry->tail_len = xdr->tail[0].iov_len; 77 __entry->page_len = xdr->page_len; 78 __entry->msg_len = xdr->len; 79 ), 80 81 TP_printk("task:%u@%u head=[%p,%zu] page=%u tail=[%p,%zu] len=%u", 82 __entry->task_id, __entry->client_id, 83 __entry->head_base, __entry->head_len, __entry->page_len, 84 __entry->tail_base, __entry->tail_len, __entry->msg_len 85 ) 86); 87 88#define DEFINE_RPCXDRBUF_EVENT(name) \ 89 DEFINE_EVENT(rpc_xdr_buf_class, \ 90 rpc_xdr_##name, \ 91 TP_PROTO( \ 92 const struct rpc_task *task, \ 93 const struct xdr_buf *xdr \ 94 ), \ 95 TP_ARGS(task, xdr)) 96 97DEFINE_RPCXDRBUF_EVENT(sendto); 98DEFINE_RPCXDRBUF_EVENT(recvfrom); 99DEFINE_RPCXDRBUF_EVENT(reply_pages); 100 101 102DECLARE_EVENT_CLASS(rpc_clnt_class, 103 TP_PROTO( 104 const struct rpc_clnt *clnt 105 ), 106 107 TP_ARGS(clnt), 108 109 TP_STRUCT__entry( 110 __field(unsigned int, client_id) 111 ), 112 113 TP_fast_assign( 114 __entry->client_id = clnt->cl_clid; 115 ), 116 117 TP_printk("clid=%u", __entry->client_id) 118); 119 120#define DEFINE_RPC_CLNT_EVENT(name) \ 121 DEFINE_EVENT(rpc_clnt_class, \ 122 rpc_clnt_##name, \ 123 TP_PROTO( \ 124 const struct rpc_clnt *clnt \ 125 ), \ 126 TP_ARGS(clnt)) 127 128DEFINE_RPC_CLNT_EVENT(free); 129DEFINE_RPC_CLNT_EVENT(killall); 130DEFINE_RPC_CLNT_EVENT(shutdown); 131DEFINE_RPC_CLNT_EVENT(release); 132DEFINE_RPC_CLNT_EVENT(replace_xprt); 133DEFINE_RPC_CLNT_EVENT(replace_xprt_err); 134 135TRACE_EVENT(rpc_clnt_new, 136 TP_PROTO( 137 const struct rpc_clnt *clnt, 138 const struct rpc_xprt *xprt, 139 const char *program, 140 const char *server 141 ), 142 143 TP_ARGS(clnt, xprt, program, server), 144 145 TP_STRUCT__entry( 146 __field(unsigned int, client_id) 147 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) 148 __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) 149 __string(program, program) 150 __string(server, server) 151 ), 152 153 TP_fast_assign( 154 __entry->client_id = clnt->cl_clid; 155 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); 156 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); 157 __assign_str(program, program) 158 __assign_str(server, server) 159 ), 160 161 TP_printk("client=%u peer=[%s]:%s program=%s server=%s", 162 __entry->client_id, __get_str(addr), __get_str(port), 163 __get_str(program), __get_str(server)) 164); 165 166TRACE_EVENT(rpc_clnt_new_err, 167 TP_PROTO( 168 const char *program, 169 const char *server, 170 int error 171 ), 172 173 TP_ARGS(program, server, error), 174 175 TP_STRUCT__entry( 176 __field(int, error) 177 __string(program, program) 178 __string(server, server) 179 ), 180 181 TP_fast_assign( 182 __entry->error = error; 183 __assign_str(program, program) 184 __assign_str(server, server) 185 ), 186 187 TP_printk("program=%s server=%s error=%d", 188 __get_str(program), __get_str(server), __entry->error) 189); 190 191TRACE_EVENT(rpc_clnt_clone_err, 192 TP_PROTO( 193 const struct rpc_clnt *clnt, 194 int error 195 ), 196 197 TP_ARGS(clnt, error), 198 199 TP_STRUCT__entry( 200 __field(unsigned int, client_id) 201 __field(int, error) 202 ), 203 204 TP_fast_assign( 205 __entry->client_id = clnt->cl_clid; 206 __entry->error = error; 207 ), 208 209 TP_printk("client=%u error=%d", __entry->client_id, __entry->error) 210); 211 212 213TRACE_DEFINE_ENUM(RPC_AUTH_OK); 214TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED); 215TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED); 216TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF); 217TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF); 218TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK); 219TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM); 220TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM); 221 222#define rpc_show_auth_stat(status) \ 223 __print_symbolic(status, \ 224 { RPC_AUTH_OK, "AUTH_OK" }, \ 225 { RPC_AUTH_BADCRED, "BADCRED" }, \ 226 { RPC_AUTH_REJECTEDCRED, "REJECTEDCRED" }, \ 227 { RPC_AUTH_BADVERF, "BADVERF" }, \ 228 { RPC_AUTH_REJECTEDVERF, "REJECTEDVERF" }, \ 229 { RPC_AUTH_TOOWEAK, "TOOWEAK" }, \ 230 { RPCSEC_GSS_CREDPROBLEM, "GSS_CREDPROBLEM" }, \ 231 { RPCSEC_GSS_CTXPROBLEM, "GSS_CTXPROBLEM" }) \ 232 233DECLARE_EVENT_CLASS(rpc_task_status, 234 235 TP_PROTO(const struct rpc_task *task), 236 237 TP_ARGS(task), 238 239 TP_STRUCT__entry( 240 __field(unsigned int, task_id) 241 __field(unsigned int, client_id) 242 __field(int, status) 243 ), 244 245 TP_fast_assign( 246 __entry->task_id = task->tk_pid; 247 __entry->client_id = task->tk_client->cl_clid; 248 __entry->status = task->tk_status; 249 ), 250 251 TP_printk("task:%u@%u status=%d", 252 __entry->task_id, __entry->client_id, 253 __entry->status) 254); 255#define DEFINE_RPC_STATUS_EVENT(name) \ 256 DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \ 257 TP_PROTO( \ 258 const struct rpc_task *task \ 259 ), \ 260 TP_ARGS(task)) 261 262DEFINE_RPC_STATUS_EVENT(call); 263DEFINE_RPC_STATUS_EVENT(connect); 264DEFINE_RPC_STATUS_EVENT(timeout); 265DEFINE_RPC_STATUS_EVENT(retry_refresh); 266DEFINE_RPC_STATUS_EVENT(refresh); 267 268TRACE_EVENT(rpc_request, 269 TP_PROTO(const struct rpc_task *task), 270 271 TP_ARGS(task), 272 273 TP_STRUCT__entry( 274 __field(unsigned int, task_id) 275 __field(unsigned int, client_id) 276 __field(int, version) 277 __field(bool, async) 278 __string(progname, task->tk_client->cl_program->name) 279 __string(procname, rpc_proc_name(task)) 280 ), 281 282 TP_fast_assign( 283 __entry->task_id = task->tk_pid; 284 __entry->client_id = task->tk_client->cl_clid; 285 __entry->version = task->tk_client->cl_vers; 286 __entry->async = RPC_IS_ASYNC(task); 287 __assign_str(progname, task->tk_client->cl_program->name) 288 __assign_str(procname, rpc_proc_name(task)) 289 ), 290 291 TP_printk("task:%u@%u %sv%d %s (%ssync)", 292 __entry->task_id, __entry->client_id, 293 __get_str(progname), __entry->version, 294 __get_str(procname), __entry->async ? "a": "" 295 ) 296); 297 298TRACE_DEFINE_ENUM(RPC_TASK_ASYNC); 299TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER); 300TRACE_DEFINE_ENUM(RPC_TASK_NULLCREDS); 301TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN); 302TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS); 303TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC); 304TRACE_DEFINE_ENUM(RPC_TASK_NO_ROUND_ROBIN); 305TRACE_DEFINE_ENUM(RPC_TASK_SOFT); 306TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN); 307TRACE_DEFINE_ENUM(RPC_TASK_SENT); 308TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT); 309TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT); 310TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT); 311TRACE_DEFINE_ENUM(RPC_TASK_CRED_NOREF); 312 313#define rpc_show_task_flags(flags) \ 314 __print_flags(flags, "|", \ 315 { RPC_TASK_ASYNC, "ASYNC" }, \ 316 { RPC_TASK_SWAPPER, "SWAPPER" }, \ 317 { RPC_TASK_NULLCREDS, "NULLCREDS" }, \ 318 { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \ 319 { RPC_TASK_ROOTCREDS, "ROOTCREDS" }, \ 320 { RPC_TASK_DYNAMIC, "DYNAMIC" }, \ 321 { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" }, \ 322 { RPC_TASK_SOFT, "SOFT" }, \ 323 { RPC_TASK_SOFTCONN, "SOFTCONN" }, \ 324 { RPC_TASK_SENT, "SENT" }, \ 325 { RPC_TASK_TIMEOUT, "TIMEOUT" }, \ 326 { RPC_TASK_NOCONNECT, "NOCONNECT" }, \ 327 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }, \ 328 { RPC_TASK_CRED_NOREF, "CRED_NOREF" }) 329 330TRACE_DEFINE_ENUM(RPC_TASK_RUNNING); 331TRACE_DEFINE_ENUM(RPC_TASK_QUEUED); 332TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE); 333TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT); 334TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV); 335TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT); 336TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED); 337 338#define rpc_show_runstate(flags) \ 339 __print_flags(flags, "|", \ 340 { (1UL << RPC_TASK_RUNNING), "RUNNING" }, \ 341 { (1UL << RPC_TASK_QUEUED), "QUEUED" }, \ 342 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" }, \ 343 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" }, \ 344 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" }, \ 345 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \ 346 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" }) 347 348DECLARE_EVENT_CLASS(rpc_task_running, 349 350 TP_PROTO(const struct rpc_task *task, const void *action), 351 352 TP_ARGS(task, action), 353 354 TP_STRUCT__entry( 355 __field(unsigned int, task_id) 356 __field(unsigned int, client_id) 357 __field(const void *, action) 358 __field(unsigned long, runstate) 359 __field(int, status) 360 __field(unsigned short, flags) 361 ), 362 363 TP_fast_assign( 364 __entry->client_id = task->tk_client ? 365 task->tk_client->cl_clid : -1; 366 __entry->task_id = task->tk_pid; 367 __entry->action = action; 368 __entry->runstate = task->tk_runstate; 369 __entry->status = task->tk_status; 370 __entry->flags = task->tk_flags; 371 ), 372 373 TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps", 374 __entry->task_id, __entry->client_id, 375 rpc_show_task_flags(__entry->flags), 376 rpc_show_runstate(__entry->runstate), 377 __entry->status, 378 __entry->action 379 ) 380); 381#define DEFINE_RPC_RUNNING_EVENT(name) \ 382 DEFINE_EVENT(rpc_task_running, rpc_task_##name, \ 383 TP_PROTO( \ 384 const struct rpc_task *task, \ 385 const void *action \ 386 ), \ 387 TP_ARGS(task, action)) 388 389DEFINE_RPC_RUNNING_EVENT(begin); 390DEFINE_RPC_RUNNING_EVENT(run_action); 391DEFINE_RPC_RUNNING_EVENT(sync_sleep); 392DEFINE_RPC_RUNNING_EVENT(sync_wake); 393DEFINE_RPC_RUNNING_EVENT(complete); 394DEFINE_RPC_RUNNING_EVENT(timeout); 395DEFINE_RPC_RUNNING_EVENT(signalled); 396DEFINE_RPC_RUNNING_EVENT(end); 397 398DECLARE_EVENT_CLASS(rpc_task_queued, 399 400 TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), 401 402 TP_ARGS(task, q), 403 404 TP_STRUCT__entry( 405 __field(unsigned int, task_id) 406 __field(unsigned int, client_id) 407 __field(unsigned long, timeout) 408 __field(unsigned long, runstate) 409 __field(int, status) 410 __field(unsigned short, flags) 411 __string(q_name, rpc_qname(q)) 412 ), 413 414 TP_fast_assign( 415 __entry->client_id = task->tk_client ? 416 task->tk_client->cl_clid : -1; 417 __entry->task_id = task->tk_pid; 418 __entry->timeout = rpc_task_timeout(task); 419 __entry->runstate = task->tk_runstate; 420 __entry->status = task->tk_status; 421 __entry->flags = task->tk_flags; 422 __assign_str(q_name, rpc_qname(q)); 423 ), 424 425 TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s", 426 __entry->task_id, __entry->client_id, 427 rpc_show_task_flags(__entry->flags), 428 rpc_show_runstate(__entry->runstate), 429 __entry->status, 430 __entry->timeout, 431 __get_str(q_name) 432 ) 433); 434#define DEFINE_RPC_QUEUED_EVENT(name) \ 435 DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \ 436 TP_PROTO( \ 437 const struct rpc_task *task, \ 438 const struct rpc_wait_queue *q \ 439 ), \ 440 TP_ARGS(task, q)) 441 442DEFINE_RPC_QUEUED_EVENT(sleep); 443DEFINE_RPC_QUEUED_EVENT(wakeup); 444 445DECLARE_EVENT_CLASS(rpc_failure, 446 447 TP_PROTO(const struct rpc_task *task), 448 449 TP_ARGS(task), 450 451 TP_STRUCT__entry( 452 __field(unsigned int, task_id) 453 __field(unsigned int, client_id) 454 ), 455 456 TP_fast_assign( 457 __entry->task_id = task->tk_pid; 458 __entry->client_id = task->tk_client->cl_clid; 459 ), 460 461 TP_printk("task:%u@%u", 462 __entry->task_id, __entry->client_id) 463); 464 465#define DEFINE_RPC_FAILURE(name) \ 466 DEFINE_EVENT(rpc_failure, rpc_bad_##name, \ 467 TP_PROTO( \ 468 const struct rpc_task *task \ 469 ), \ 470 TP_ARGS(task)) 471 472DEFINE_RPC_FAILURE(callhdr); 473DEFINE_RPC_FAILURE(verifier); 474 475DECLARE_EVENT_CLASS(rpc_reply_event, 476 477 TP_PROTO( 478 const struct rpc_task *task 479 ), 480 481 TP_ARGS(task), 482 483 TP_STRUCT__entry( 484 __field(unsigned int, task_id) 485 __field(unsigned int, client_id) 486 __field(u32, xid) 487 __string(progname, task->tk_client->cl_program->name) 488 __field(u32, version) 489 __string(procname, rpc_proc_name(task)) 490 __string(servername, task->tk_xprt->servername) 491 ), 492 493 TP_fast_assign( 494 __entry->task_id = task->tk_pid; 495 __entry->client_id = task->tk_client->cl_clid; 496 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid); 497 __assign_str(progname, task->tk_client->cl_program->name) 498 __entry->version = task->tk_client->cl_vers; 499 __assign_str(procname, rpc_proc_name(task)) 500 __assign_str(servername, task->tk_xprt->servername) 501 ), 502 503 TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s", 504 __entry->task_id, __entry->client_id, __get_str(servername), 505 __entry->xid, __get_str(progname), __entry->version, 506 __get_str(procname)) 507) 508 509#define DEFINE_RPC_REPLY_EVENT(name) \ 510 DEFINE_EVENT(rpc_reply_event, rpc__##name, \ 511 TP_PROTO( \ 512 const struct rpc_task *task \ 513 ), \ 514 TP_ARGS(task)) 515 516DEFINE_RPC_REPLY_EVENT(prog_unavail); 517DEFINE_RPC_REPLY_EVENT(prog_mismatch); 518DEFINE_RPC_REPLY_EVENT(proc_unavail); 519DEFINE_RPC_REPLY_EVENT(garbage_args); 520DEFINE_RPC_REPLY_EVENT(unparsable); 521DEFINE_RPC_REPLY_EVENT(mismatch); 522DEFINE_RPC_REPLY_EVENT(stale_creds); 523DEFINE_RPC_REPLY_EVENT(bad_creds); 524DEFINE_RPC_REPLY_EVENT(auth_tooweak); 525 526#define DEFINE_RPCB_ERROR_EVENT(name) \ 527 DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err, \ 528 TP_PROTO( \ 529 const struct rpc_task *task \ 530 ), \ 531 TP_ARGS(task)) 532 533DEFINE_RPCB_ERROR_EVENT(prog_unavail); 534DEFINE_RPCB_ERROR_EVENT(timeout); 535DEFINE_RPCB_ERROR_EVENT(bind_version); 536DEFINE_RPCB_ERROR_EVENT(unreachable); 537DEFINE_RPCB_ERROR_EVENT(unrecognized); 538 539TRACE_EVENT(rpc_buf_alloc, 540 TP_PROTO( 541 const struct rpc_task *task, 542 int status 543 ), 544 545 TP_ARGS(task, status), 546 547 TP_STRUCT__entry( 548 __field(unsigned int, task_id) 549 __field(unsigned int, client_id) 550 __field(size_t, callsize) 551 __field(size_t, recvsize) 552 __field(int, status) 553 ), 554 555 TP_fast_assign( 556 __entry->task_id = task->tk_pid; 557 __entry->client_id = task->tk_client->cl_clid; 558 __entry->callsize = task->tk_rqstp->rq_callsize; 559 __entry->recvsize = task->tk_rqstp->rq_rcvsize; 560 __entry->status = status; 561 ), 562 563 TP_printk("task:%u@%u callsize=%zu recvsize=%zu status=%d", 564 __entry->task_id, __entry->client_id, 565 __entry->callsize, __entry->recvsize, __entry->status 566 ) 567); 568 569TRACE_EVENT(rpc_call_rpcerror, 570 TP_PROTO( 571 const struct rpc_task *task, 572 int tk_status, 573 int rpc_status 574 ), 575 576 TP_ARGS(task, tk_status, rpc_status), 577 578 TP_STRUCT__entry( 579 __field(unsigned int, task_id) 580 __field(unsigned int, client_id) 581 __field(int, tk_status) 582 __field(int, rpc_status) 583 ), 584 585 TP_fast_assign( 586 __entry->client_id = task->tk_client->cl_clid; 587 __entry->task_id = task->tk_pid; 588 __entry->tk_status = tk_status; 589 __entry->rpc_status = rpc_status; 590 ), 591 592 TP_printk("task:%u@%u tk_status=%d rpc_status=%d", 593 __entry->task_id, __entry->client_id, 594 __entry->tk_status, __entry->rpc_status) 595); 596 597TRACE_EVENT(rpc_stats_latency, 598 599 TP_PROTO( 600 const struct rpc_task *task, 601 ktime_t backlog, 602 ktime_t rtt, 603 ktime_t execute 604 ), 605 606 TP_ARGS(task, backlog, rtt, execute), 607 608 TP_STRUCT__entry( 609 __field(unsigned int, task_id) 610 __field(unsigned int, client_id) 611 __field(u32, xid) 612 __field(int, version) 613 __string(progname, task->tk_client->cl_program->name) 614 __string(procname, rpc_proc_name(task)) 615 __field(unsigned long, backlog) 616 __field(unsigned long, rtt) 617 __field(unsigned long, execute) 618 ), 619 620 TP_fast_assign( 621 __entry->client_id = task->tk_client->cl_clid; 622 __entry->task_id = task->tk_pid; 623 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid); 624 __entry->version = task->tk_client->cl_vers; 625 __assign_str(progname, task->tk_client->cl_program->name) 626 __assign_str(procname, rpc_proc_name(task)) 627 __entry->backlog = ktime_to_us(backlog); 628 __entry->rtt = ktime_to_us(rtt); 629 __entry->execute = ktime_to_us(execute); 630 ), 631 632 TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu", 633 __entry->task_id, __entry->client_id, __entry->xid, 634 __get_str(progname), __entry->version, __get_str(procname), 635 __entry->backlog, __entry->rtt, __entry->execute) 636); 637 638TRACE_EVENT(rpc_xdr_overflow, 639 TP_PROTO( 640 const struct xdr_stream *xdr, 641 size_t requested 642 ), 643 644 TP_ARGS(xdr, requested), 645 646 TP_STRUCT__entry( 647 __field(unsigned int, task_id) 648 __field(unsigned int, client_id) 649 __field(int, version) 650 __field(size_t, requested) 651 __field(const void *, end) 652 __field(const void *, p) 653 __field(const void *, head_base) 654 __field(size_t, head_len) 655 __field(const void *, tail_base) 656 __field(size_t, tail_len) 657 __field(unsigned int, page_len) 658 __field(unsigned int, len) 659 __string(progname, xdr->rqst ? 660 xdr->rqst->rq_task->tk_client->cl_program->name : "unknown") 661 __string(procedure, xdr->rqst ? 662 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown") 663 ), 664 665 TP_fast_assign( 666 if (xdr->rqst) { 667 const struct rpc_task *task = xdr->rqst->rq_task; 668 669 __entry->task_id = task->tk_pid; 670 __entry->client_id = task->tk_client->cl_clid; 671 __assign_str(progname, 672 task->tk_client->cl_program->name) 673 __entry->version = task->tk_client->cl_vers; 674 __assign_str(procedure, task->tk_msg.rpc_proc->p_name) 675 } else { 676 __entry->task_id = 0; 677 __entry->client_id = 0; 678 __assign_str(progname, "unknown") 679 __entry->version = 0; 680 __assign_str(procedure, "unknown") 681 } 682 __entry->requested = requested; 683 __entry->end = xdr->end; 684 __entry->p = xdr->p; 685 __entry->head_base = xdr->buf->head[0].iov_base, 686 __entry->head_len = xdr->buf->head[0].iov_len, 687 __entry->page_len = xdr->buf->page_len, 688 __entry->tail_base = xdr->buf->tail[0].iov_base, 689 __entry->tail_len = xdr->buf->tail[0].iov_len, 690 __entry->len = xdr->buf->len; 691 ), 692 693 TP_printk( 694 "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n", 695 __entry->task_id, __entry->client_id, 696 __get_str(progname), __entry->version, __get_str(procedure), 697 __entry->requested, __entry->p, __entry->end, 698 __entry->head_base, __entry->head_len, 699 __entry->page_len, 700 __entry->tail_base, __entry->tail_len, 701 __entry->len 702 ) 703); 704 705TRACE_EVENT(rpc_xdr_alignment, 706 TP_PROTO( 707 const struct xdr_stream *xdr, 708 size_t offset, 709 unsigned int copied 710 ), 711 712 TP_ARGS(xdr, offset, copied), 713 714 TP_STRUCT__entry( 715 __field(unsigned int, task_id) 716 __field(unsigned int, client_id) 717 __field(int, version) 718 __field(size_t, offset) 719 __field(unsigned int, copied) 720 __field(const void *, head_base) 721 __field(size_t, head_len) 722 __field(const void *, tail_base) 723 __field(size_t, tail_len) 724 __field(unsigned int, page_len) 725 __field(unsigned int, len) 726 __string(progname, 727 xdr->rqst->rq_task->tk_client->cl_program->name) 728 __string(procedure, 729 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 730 ), 731 732 TP_fast_assign( 733 const struct rpc_task *task = xdr->rqst->rq_task; 734 735 __entry->task_id = task->tk_pid; 736 __entry->client_id = task->tk_client->cl_clid; 737 __assign_str(progname, 738 task->tk_client->cl_program->name) 739 __entry->version = task->tk_client->cl_vers; 740 __assign_str(procedure, task->tk_msg.rpc_proc->p_name) 741 742 __entry->offset = offset; 743 __entry->copied = copied; 744 __entry->head_base = xdr->buf->head[0].iov_base, 745 __entry->head_len = xdr->buf->head[0].iov_len, 746 __entry->page_len = xdr->buf->page_len, 747 __entry->tail_base = xdr->buf->tail[0].iov_base, 748 __entry->tail_len = xdr->buf->tail[0].iov_len, 749 __entry->len = xdr->buf->len; 750 ), 751 752 TP_printk( 753 "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n", 754 __entry->task_id, __entry->client_id, 755 __get_str(progname), __entry->version, __get_str(procedure), 756 __entry->offset, __entry->copied, 757 __entry->head_base, __entry->head_len, 758 __entry->page_len, 759 __entry->tail_base, __entry->tail_len, 760 __entry->len 761 ) 762); 763 764/* 765 * First define the enums in the below macros to be exported to userspace 766 * via TRACE_DEFINE_ENUM(). 767 */ 768#undef EM 769#undef EMe 770#define EM(a, b) TRACE_DEFINE_ENUM(a); 771#define EMe(a, b) TRACE_DEFINE_ENUM(a); 772 773#define RPC_SHOW_SOCKET \ 774 EM( SS_FREE, "FREE" ) \ 775 EM( SS_UNCONNECTED, "UNCONNECTED" ) \ 776 EM( SS_CONNECTING, "CONNECTING" ) \ 777 EM( SS_CONNECTED, "CONNECTED" ) \ 778 EMe( SS_DISCONNECTING, "DISCONNECTING" ) 779 780#define rpc_show_socket_state(state) \ 781 __print_symbolic(state, RPC_SHOW_SOCKET) 782 783RPC_SHOW_SOCKET 784 785#define RPC_SHOW_SOCK \ 786 EM( TCP_ESTABLISHED, "ESTABLISHED" ) \ 787 EM( TCP_SYN_SENT, "SYN_SENT" ) \ 788 EM( TCP_SYN_RECV, "SYN_RECV" ) \ 789 EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \ 790 EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \ 791 EM( TCP_TIME_WAIT, "TIME_WAIT" ) \ 792 EM( TCP_CLOSE, "CLOSE" ) \ 793 EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \ 794 EM( TCP_LAST_ACK, "LAST_ACK" ) \ 795 EM( TCP_LISTEN, "LISTEN" ) \ 796 EMe( TCP_CLOSING, "CLOSING" ) 797 798#define rpc_show_sock_state(state) \ 799 __print_symbolic(state, RPC_SHOW_SOCK) 800 801RPC_SHOW_SOCK 802 803/* 804 * Now redefine the EM() and EMe() macros to map the enums to the strings 805 * that will be printed in the output. 806 */ 807#undef EM 808#undef EMe 809#define EM(a, b) {a, b}, 810#define EMe(a, b) {a, b} 811 812DECLARE_EVENT_CLASS(xs_socket_event, 813 814 TP_PROTO( 815 struct rpc_xprt *xprt, 816 struct socket *socket 817 ), 818 819 TP_ARGS(xprt, socket), 820 821 TP_STRUCT__entry( 822 __field(unsigned int, socket_state) 823 __field(unsigned int, sock_state) 824 __field(unsigned long long, ino) 825 __string(dstaddr, 826 xprt->address_strings[RPC_DISPLAY_ADDR]) 827 __string(dstport, 828 xprt->address_strings[RPC_DISPLAY_PORT]) 829 ), 830 831 TP_fast_assign( 832 struct inode *inode = SOCK_INODE(socket); 833 __entry->socket_state = socket->state; 834 __entry->sock_state = socket->sk->sk_state; 835 __entry->ino = (unsigned long long)inode->i_ino; 836 __assign_str(dstaddr, 837 xprt->address_strings[RPC_DISPLAY_ADDR]); 838 __assign_str(dstport, 839 xprt->address_strings[RPC_DISPLAY_PORT]); 840 ), 841 842 TP_printk( 843 "socket:[%llu] dstaddr=%s/%s " 844 "state=%u (%s) sk_state=%u (%s)", 845 __entry->ino, __get_str(dstaddr), __get_str(dstport), 846 __entry->socket_state, 847 rpc_show_socket_state(__entry->socket_state), 848 __entry->sock_state, 849 rpc_show_sock_state(__entry->sock_state) 850 ) 851); 852#define DEFINE_RPC_SOCKET_EVENT(name) \ 853 DEFINE_EVENT(xs_socket_event, name, \ 854 TP_PROTO( \ 855 struct rpc_xprt *xprt, \ 856 struct socket *socket \ 857 ), \ 858 TP_ARGS(xprt, socket)) 859 860DECLARE_EVENT_CLASS(xs_socket_event_done, 861 862 TP_PROTO( 863 struct rpc_xprt *xprt, 864 struct socket *socket, 865 int error 866 ), 867 868 TP_ARGS(xprt, socket, error), 869 870 TP_STRUCT__entry( 871 __field(int, error) 872 __field(unsigned int, socket_state) 873 __field(unsigned int, sock_state) 874 __field(unsigned long long, ino) 875 __string(dstaddr, 876 xprt->address_strings[RPC_DISPLAY_ADDR]) 877 __string(dstport, 878 xprt->address_strings[RPC_DISPLAY_PORT]) 879 ), 880 881 TP_fast_assign( 882 struct inode *inode = SOCK_INODE(socket); 883 __entry->socket_state = socket->state; 884 __entry->sock_state = socket->sk->sk_state; 885 __entry->ino = (unsigned long long)inode->i_ino; 886 __entry->error = error; 887 __assign_str(dstaddr, 888 xprt->address_strings[RPC_DISPLAY_ADDR]); 889 __assign_str(dstport, 890 xprt->address_strings[RPC_DISPLAY_PORT]); 891 ), 892 893 TP_printk( 894 "error=%d socket:[%llu] dstaddr=%s/%s " 895 "state=%u (%s) sk_state=%u (%s)", 896 __entry->error, 897 __entry->ino, __get_str(dstaddr), __get_str(dstport), 898 __entry->socket_state, 899 rpc_show_socket_state(__entry->socket_state), 900 __entry->sock_state, 901 rpc_show_sock_state(__entry->sock_state) 902 ) 903); 904#define DEFINE_RPC_SOCKET_EVENT_DONE(name) \ 905 DEFINE_EVENT(xs_socket_event_done, name, \ 906 TP_PROTO( \ 907 struct rpc_xprt *xprt, \ 908 struct socket *socket, \ 909 int error \ 910 ), \ 911 TP_ARGS(xprt, socket, error)) 912 913DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); 914DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); 915DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); 916DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); 917DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); 918DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); 919 920TRACE_EVENT(rpc_socket_nospace, 921 TP_PROTO( 922 const struct rpc_rqst *rqst, 923 const struct sock_xprt *transport 924 ), 925 926 TP_ARGS(rqst, transport), 927 928 TP_STRUCT__entry( 929 __field(unsigned int, task_id) 930 __field(unsigned int, client_id) 931 __field(unsigned int, total) 932 __field(unsigned int, remaining) 933 ), 934 935 TP_fast_assign( 936 __entry->task_id = rqst->rq_task->tk_pid; 937 __entry->client_id = rqst->rq_task->tk_client->cl_clid; 938 __entry->total = rqst->rq_slen; 939 __entry->remaining = rqst->rq_slen - transport->xmit.offset; 940 ), 941 942 TP_printk("task:%u@%u total=%u remaining=%u", 943 __entry->task_id, __entry->client_id, 944 __entry->total, __entry->remaining 945 ) 946); 947 948TRACE_DEFINE_ENUM(XPRT_LOCKED); 949TRACE_DEFINE_ENUM(XPRT_CONNECTED); 950TRACE_DEFINE_ENUM(XPRT_CONNECTING); 951TRACE_DEFINE_ENUM(XPRT_CLOSE_WAIT); 952TRACE_DEFINE_ENUM(XPRT_BOUND); 953TRACE_DEFINE_ENUM(XPRT_BINDING); 954TRACE_DEFINE_ENUM(XPRT_CLOSING); 955TRACE_DEFINE_ENUM(XPRT_CONGESTED); 956TRACE_DEFINE_ENUM(XPRT_CWND_WAIT); 957TRACE_DEFINE_ENUM(XPRT_WRITE_SPACE); 958 959#define rpc_show_xprt_state(x) \ 960 __print_flags(x, "|", \ 961 { (1UL << XPRT_LOCKED), "LOCKED"}, \ 962 { (1UL << XPRT_CONNECTED), "CONNECTED"}, \ 963 { (1UL << XPRT_CONNECTING), "CONNECTING"}, \ 964 { (1UL << XPRT_CLOSE_WAIT), "CLOSE_WAIT"}, \ 965 { (1UL << XPRT_BOUND), "BOUND"}, \ 966 { (1UL << XPRT_BINDING), "BINDING"}, \ 967 { (1UL << XPRT_CLOSING), "CLOSING"}, \ 968 { (1UL << XPRT_CONGESTED), "CONGESTED"}, \ 969 { (1UL << XPRT_CWND_WAIT), "CWND_WAIT"}, \ 970 { (1UL << XPRT_WRITE_SPACE), "WRITE_SPACE"}) 971 972DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class, 973 TP_PROTO( 974 const struct rpc_xprt *xprt 975 ), 976 977 TP_ARGS(xprt), 978 979 TP_STRUCT__entry( 980 __field(unsigned long, state) 981 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) 982 __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) 983 ), 984 985 TP_fast_assign( 986 __entry->state = xprt->state; 987 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); 988 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); 989 ), 990 991 TP_printk("peer=[%s]:%s state=%s", 992 __get_str(addr), __get_str(port), 993 rpc_show_xprt_state(__entry->state)) 994); 995 996#define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \ 997 DEFINE_EVENT(rpc_xprt_lifetime_class, \ 998 xprt_##name, \ 999 TP_PROTO( \ 1000 const struct rpc_xprt *xprt \ 1001 ), \ 1002 TP_ARGS(xprt)) 1003 1004DEFINE_RPC_XPRT_LIFETIME_EVENT(create); 1005DEFINE_RPC_XPRT_LIFETIME_EVENT(connect); 1006DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto); 1007DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done); 1008DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force); 1009DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy); 1010 1011DECLARE_EVENT_CLASS(rpc_xprt_event, 1012 TP_PROTO( 1013 const struct rpc_xprt *xprt, 1014 __be32 xid, 1015 int status 1016 ), 1017 1018 TP_ARGS(xprt, xid, status), 1019 1020 TP_STRUCT__entry( 1021 __field(u32, xid) 1022 __field(int, status) 1023 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) 1024 __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) 1025 ), 1026 1027 TP_fast_assign( 1028 __entry->xid = be32_to_cpu(xid); 1029 __entry->status = status; 1030 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); 1031 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); 1032 ), 1033 1034 TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr), 1035 __get_str(port), __entry->xid, 1036 __entry->status) 1037); 1038#define DEFINE_RPC_XPRT_EVENT(name) \ 1039 DEFINE_EVENT(rpc_xprt_event, xprt_##name, \ 1040 TP_PROTO( \ 1041 const struct rpc_xprt *xprt, \ 1042 __be32 xid, \ 1043 int status \ 1044 ), \ 1045 TP_ARGS(xprt, xid, status)) 1046 1047DEFINE_RPC_XPRT_EVENT(timer); 1048DEFINE_RPC_XPRT_EVENT(lookup_rqst); 1049 1050TRACE_EVENT(xprt_transmit, 1051 TP_PROTO( 1052 const struct rpc_rqst *rqst, 1053 int status 1054 ), 1055 1056 TP_ARGS(rqst, status), 1057 1058 TP_STRUCT__entry( 1059 __field(unsigned int, task_id) 1060 __field(unsigned int, client_id) 1061 __field(u32, xid) 1062 __field(u32, seqno) 1063 __field(int, status) 1064 ), 1065 1066 TP_fast_assign( 1067 __entry->task_id = rqst->rq_task->tk_pid; 1068 __entry->client_id = rqst->rq_task->tk_client ? 1069 rqst->rq_task->tk_client->cl_clid : -1; 1070 __entry->xid = be32_to_cpu(rqst->rq_xid); 1071 __entry->seqno = rqst->rq_seqno; 1072 __entry->status = status; 1073 ), 1074 1075 TP_printk( 1076 "task:%u@%u xid=0x%08x seqno=%u status=%d", 1077 __entry->task_id, __entry->client_id, __entry->xid, 1078 __entry->seqno, __entry->status) 1079); 1080 1081TRACE_EVENT(xprt_ping, 1082 TP_PROTO(const struct rpc_xprt *xprt, int status), 1083 1084 TP_ARGS(xprt, status), 1085 1086 TP_STRUCT__entry( 1087 __field(int, status) 1088 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) 1089 __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) 1090 ), 1091 1092 TP_fast_assign( 1093 __entry->status = status; 1094 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); 1095 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); 1096 ), 1097 1098 TP_printk("peer=[%s]:%s status=%d", 1099 __get_str(addr), __get_str(port), __entry->status) 1100); 1101 1102DECLARE_EVENT_CLASS(xprt_writelock_event, 1103 TP_PROTO( 1104 const struct rpc_xprt *xprt, const struct rpc_task *task 1105 ), 1106 1107 TP_ARGS(xprt, task), 1108 1109 TP_STRUCT__entry( 1110 __field(unsigned int, task_id) 1111 __field(unsigned int, client_id) 1112 __field(unsigned int, snd_task_id) 1113 ), 1114 1115 TP_fast_assign( 1116 if (task) { 1117 __entry->task_id = task->tk_pid; 1118 __entry->client_id = task->tk_client ? 1119 task->tk_client->cl_clid : -1; 1120 } else { 1121 __entry->task_id = -1; 1122 __entry->client_id = -1; 1123 } 1124 __entry->snd_task_id = xprt->snd_task ? 1125 xprt->snd_task->tk_pid : -1; 1126 ), 1127 1128 TP_printk("task:%u@%u snd_task:%u", 1129 __entry->task_id, __entry->client_id, 1130 __entry->snd_task_id) 1131); 1132 1133#define DEFINE_WRITELOCK_EVENT(name) \ 1134 DEFINE_EVENT(xprt_writelock_event, xprt_##name, \ 1135 TP_PROTO( \ 1136 const struct rpc_xprt *xprt, \ 1137 const struct rpc_task *task \ 1138 ), \ 1139 TP_ARGS(xprt, task)) 1140 1141DEFINE_WRITELOCK_EVENT(reserve_xprt); 1142DEFINE_WRITELOCK_EVENT(release_xprt); 1143 1144DECLARE_EVENT_CLASS(xprt_cong_event, 1145 TP_PROTO( 1146 const struct rpc_xprt *xprt, const struct rpc_task *task 1147 ), 1148 1149 TP_ARGS(xprt, task), 1150 1151 TP_STRUCT__entry( 1152 __field(unsigned int, task_id) 1153 __field(unsigned int, client_id) 1154 __field(unsigned int, snd_task_id) 1155 __field(unsigned long, cong) 1156 __field(unsigned long, cwnd) 1157 __field(bool, wait) 1158 ), 1159 1160 TP_fast_assign( 1161 if (task) { 1162 __entry->task_id = task->tk_pid; 1163 __entry->client_id = task->tk_client ? 1164 task->tk_client->cl_clid : -1; 1165 } else { 1166 __entry->task_id = -1; 1167 __entry->client_id = -1; 1168 } 1169 __entry->snd_task_id = xprt->snd_task ? 1170 xprt->snd_task->tk_pid : -1; 1171 __entry->cong = xprt->cong; 1172 __entry->cwnd = xprt->cwnd; 1173 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state); 1174 ), 1175 1176 TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s", 1177 __entry->task_id, __entry->client_id, 1178 __entry->snd_task_id, __entry->cong, __entry->cwnd, 1179 __entry->wait ? " (wait)" : "") 1180); 1181 1182#define DEFINE_CONG_EVENT(name) \ 1183 DEFINE_EVENT(xprt_cong_event, xprt_##name, \ 1184 TP_PROTO( \ 1185 const struct rpc_xprt *xprt, \ 1186 const struct rpc_task *task \ 1187 ), \ 1188 TP_ARGS(xprt, task)) 1189 1190DEFINE_CONG_EVENT(reserve_cong); 1191DEFINE_CONG_EVENT(release_cong); 1192DEFINE_CONG_EVENT(get_cong); 1193DEFINE_CONG_EVENT(put_cong); 1194 1195TRACE_EVENT(xprt_reserve, 1196 TP_PROTO( 1197 const struct rpc_rqst *rqst 1198 ), 1199 1200 TP_ARGS(rqst), 1201 1202 TP_STRUCT__entry( 1203 __field(unsigned int, task_id) 1204 __field(unsigned int, client_id) 1205 __field(u32, xid) 1206 ), 1207 1208 TP_fast_assign( 1209 __entry->task_id = rqst->rq_task->tk_pid; 1210 __entry->client_id = rqst->rq_task->tk_client->cl_clid; 1211 __entry->xid = be32_to_cpu(rqst->rq_xid); 1212 ), 1213 1214 TP_printk("task:%u@%u xid=0x%08x", 1215 __entry->task_id, __entry->client_id, __entry->xid 1216 ) 1217); 1218 1219TRACE_EVENT(xs_stream_read_data, 1220 TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total), 1221 1222 TP_ARGS(xprt, err, total), 1223 1224 TP_STRUCT__entry( 1225 __field(ssize_t, err) 1226 __field(size_t, total) 1227 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] : 1228 "(null)") 1229 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] : 1230 "(null)") 1231 ), 1232 1233 TP_fast_assign( 1234 __entry->err = err; 1235 __entry->total = total; 1236 __assign_str(addr, xprt ? 1237 xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)"); 1238 __assign_str(port, xprt ? 1239 xprt->address_strings[RPC_DISPLAY_PORT] : "(null)"); 1240 ), 1241 1242 TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr), 1243 __get_str(port), __entry->err, __entry->total) 1244); 1245 1246TRACE_EVENT(xs_stream_read_request, 1247 TP_PROTO(struct sock_xprt *xs), 1248 1249 TP_ARGS(xs), 1250 1251 TP_STRUCT__entry( 1252 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]) 1253 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]) 1254 __field(u32, xid) 1255 __field(unsigned long, copied) 1256 __field(unsigned int, reclen) 1257 __field(unsigned int, offset) 1258 ), 1259 1260 TP_fast_assign( 1261 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]); 1262 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]); 1263 __entry->xid = be32_to_cpu(xs->recv.xid); 1264 __entry->copied = xs->recv.copied; 1265 __entry->reclen = xs->recv.len; 1266 __entry->offset = xs->recv.offset; 1267 ), 1268 1269 TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u", 1270 __get_str(addr), __get_str(port), __entry->xid, 1271 __entry->copied, __entry->reclen, __entry->offset) 1272); 1273 1274TRACE_EVENT(rpcb_getport, 1275 TP_PROTO( 1276 const struct rpc_clnt *clnt, 1277 const struct rpc_task *task, 1278 unsigned int bind_version 1279 ), 1280 1281 TP_ARGS(clnt, task, bind_version), 1282 1283 TP_STRUCT__entry( 1284 __field(unsigned int, task_id) 1285 __field(unsigned int, client_id) 1286 __field(unsigned int, program) 1287 __field(unsigned int, version) 1288 __field(int, protocol) 1289 __field(unsigned int, bind_version) 1290 __string(servername, task->tk_xprt->servername) 1291 ), 1292 1293 TP_fast_assign( 1294 __entry->task_id = task->tk_pid; 1295 __entry->client_id = clnt->cl_clid; 1296 __entry->program = clnt->cl_prog; 1297 __entry->version = clnt->cl_vers; 1298 __entry->protocol = task->tk_xprt->prot; 1299 __entry->bind_version = bind_version; 1300 __assign_str(servername, task->tk_xprt->servername); 1301 ), 1302 1303 TP_printk("task:%u@%u server=%s program=%u version=%u protocol=%d bind_version=%u", 1304 __entry->task_id, __entry->client_id, __get_str(servername), 1305 __entry->program, __entry->version, __entry->protocol, 1306 __entry->bind_version 1307 ) 1308); 1309 1310TRACE_EVENT(rpcb_setport, 1311 TP_PROTO( 1312 const struct rpc_task *task, 1313 int status, 1314 unsigned short port 1315 ), 1316 1317 TP_ARGS(task, status, port), 1318 1319 TP_STRUCT__entry( 1320 __field(unsigned int, task_id) 1321 __field(unsigned int, client_id) 1322 __field(int, status) 1323 __field(unsigned short, port) 1324 ), 1325 1326 TP_fast_assign( 1327 __entry->task_id = task->tk_pid; 1328 __entry->client_id = task->tk_client->cl_clid; 1329 __entry->status = status; 1330 __entry->port = port; 1331 ), 1332 1333 TP_printk("task:%u@%u status=%d port=%u", 1334 __entry->task_id, __entry->client_id, 1335 __entry->status, __entry->port 1336 ) 1337); 1338 1339TRACE_EVENT(pmap_register, 1340 TP_PROTO( 1341 u32 program, 1342 u32 version, 1343 int protocol, 1344 unsigned short port 1345 ), 1346 1347 TP_ARGS(program, version, protocol, port), 1348 1349 TP_STRUCT__entry( 1350 __field(unsigned int, program) 1351 __field(unsigned int, version) 1352 __field(int, protocol) 1353 __field(unsigned int, port) 1354 ), 1355 1356 TP_fast_assign( 1357 __entry->program = program; 1358 __entry->version = version; 1359 __entry->protocol = protocol; 1360 __entry->port = port; 1361 ), 1362 1363 TP_printk("program=%u version=%u protocol=%d port=%u", 1364 __entry->program, __entry->version, 1365 __entry->protocol, __entry->port 1366 ) 1367); 1368 1369TRACE_EVENT(rpcb_register, 1370 TP_PROTO( 1371 u32 program, 1372 u32 version, 1373 const char *addr, 1374 const char *netid 1375 ), 1376 1377 TP_ARGS(program, version, addr, netid), 1378 1379 TP_STRUCT__entry( 1380 __field(unsigned int, program) 1381 __field(unsigned int, version) 1382 __string(addr, addr) 1383 __string(netid, netid) 1384 ), 1385 1386 TP_fast_assign( 1387 __entry->program = program; 1388 __entry->version = version; 1389 __assign_str(addr, addr); 1390 __assign_str(netid, netid); 1391 ), 1392 1393 TP_printk("program=%u version=%u addr=%s netid=%s", 1394 __entry->program, __entry->version, 1395 __get_str(addr), __get_str(netid) 1396 ) 1397); 1398 1399TRACE_EVENT(rpcb_unregister, 1400 TP_PROTO( 1401 u32 program, 1402 u32 version, 1403 const char *netid 1404 ), 1405 1406 TP_ARGS(program, version, netid), 1407 1408 TP_STRUCT__entry( 1409 __field(unsigned int, program) 1410 __field(unsigned int, version) 1411 __string(netid, netid) 1412 ), 1413 1414 TP_fast_assign( 1415 __entry->program = program; 1416 __entry->version = version; 1417 __assign_str(netid, netid); 1418 ), 1419 1420 TP_printk("program=%u version=%u netid=%s", 1421 __entry->program, __entry->version, __get_str(netid) 1422 ) 1423); 1424 1425DECLARE_EVENT_CLASS(svc_xdr_buf_class, 1426 TP_PROTO( 1427 const struct svc_rqst *rqst, 1428 const struct xdr_buf *xdr 1429 ), 1430 1431 TP_ARGS(rqst, xdr), 1432 1433 TP_STRUCT__entry( 1434 __field(u32, xid) 1435 __field(const void *, head_base) 1436 __field(size_t, head_len) 1437 __field(const void *, tail_base) 1438 __field(size_t, tail_len) 1439 __field(unsigned int, page_len) 1440 __field(unsigned int, msg_len) 1441 ), 1442 1443 TP_fast_assign( 1444 __entry->xid = be32_to_cpu(rqst->rq_xid); 1445 __entry->head_base = xdr->head[0].iov_base; 1446 __entry->head_len = xdr->head[0].iov_len; 1447 __entry->tail_base = xdr->tail[0].iov_base; 1448 __entry->tail_len = xdr->tail[0].iov_len; 1449 __entry->page_len = xdr->page_len; 1450 __entry->msg_len = xdr->len; 1451 ), 1452 1453 TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u", 1454 __entry->xid, 1455 __entry->head_base, __entry->head_len, __entry->page_len, 1456 __entry->tail_base, __entry->tail_len, __entry->msg_len 1457 ) 1458); 1459 1460#define DEFINE_SVCXDRBUF_EVENT(name) \ 1461 DEFINE_EVENT(svc_xdr_buf_class, \ 1462 svc_xdr_##name, \ 1463 TP_PROTO( \ 1464 const struct svc_rqst *rqst, \ 1465 const struct xdr_buf *xdr \ 1466 ), \ 1467 TP_ARGS(rqst, xdr)) 1468 1469DEFINE_SVCXDRBUF_EVENT(recvfrom); 1470DEFINE_SVCXDRBUF_EVENT(sendto); 1471 1472/* 1473 * from include/linux/sunrpc/svc.h 1474 */ 1475#define SVC_RQST_FLAG_LIST \ 1476 svc_rqst_flag(SECURE) \ 1477 svc_rqst_flag(LOCAL) \ 1478 svc_rqst_flag(USEDEFERRAL) \ 1479 svc_rqst_flag(DROPME) \ 1480 svc_rqst_flag(SPLICE_OK) \ 1481 svc_rqst_flag(VICTIM) \ 1482 svc_rqst_flag(BUSY) \ 1483 svc_rqst_flag(DATA) \ 1484 svc_rqst_flag_end(AUTHERR) 1485 1486#undef svc_rqst_flag 1487#undef svc_rqst_flag_end 1488#define svc_rqst_flag(x) TRACE_DEFINE_ENUM(RQ_##x); 1489#define svc_rqst_flag_end(x) TRACE_DEFINE_ENUM(RQ_##x); 1490 1491SVC_RQST_FLAG_LIST 1492 1493#undef svc_rqst_flag 1494#undef svc_rqst_flag_end 1495#define svc_rqst_flag(x) { BIT(RQ_##x), #x }, 1496#define svc_rqst_flag_end(x) { BIT(RQ_##x), #x } 1497 1498#define show_rqstp_flags(flags) \ 1499 __print_flags(flags, "|", SVC_RQST_FLAG_LIST) 1500 1501TRACE_EVENT(svc_recv, 1502 TP_PROTO(struct svc_rqst *rqst, int len), 1503 1504 TP_ARGS(rqst, len), 1505 1506 TP_STRUCT__entry( 1507 __field(u32, xid) 1508 __field(int, len) 1509 __field(unsigned long, flags) 1510 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1511 ), 1512 1513 TP_fast_assign( 1514 __entry->xid = be32_to_cpu(rqst->rq_xid); 1515 __entry->len = len; 1516 __entry->flags = rqst->rq_flags; 1517 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1518 ), 1519 1520 TP_printk("addr=%s xid=0x%08x len=%d flags=%s", 1521 __get_str(addr), __entry->xid, __entry->len, 1522 show_rqstp_flags(__entry->flags)) 1523); 1524 1525TRACE_DEFINE_ENUM(SVC_GARBAGE); 1526TRACE_DEFINE_ENUM(SVC_SYSERR); 1527TRACE_DEFINE_ENUM(SVC_VALID); 1528TRACE_DEFINE_ENUM(SVC_NEGATIVE); 1529TRACE_DEFINE_ENUM(SVC_OK); 1530TRACE_DEFINE_ENUM(SVC_DROP); 1531TRACE_DEFINE_ENUM(SVC_CLOSE); 1532TRACE_DEFINE_ENUM(SVC_DENIED); 1533TRACE_DEFINE_ENUM(SVC_PENDING); 1534TRACE_DEFINE_ENUM(SVC_COMPLETE); 1535 1536#define svc_show_status(status) \ 1537 __print_symbolic(status, \ 1538 { SVC_GARBAGE, "SVC_GARBAGE" }, \ 1539 { SVC_SYSERR, "SVC_SYSERR" }, \ 1540 { SVC_VALID, "SVC_VALID" }, \ 1541 { SVC_NEGATIVE, "SVC_NEGATIVE" }, \ 1542 { SVC_OK, "SVC_OK" }, \ 1543 { SVC_DROP, "SVC_DROP" }, \ 1544 { SVC_CLOSE, "SVC_CLOSE" }, \ 1545 { SVC_DENIED, "SVC_DENIED" }, \ 1546 { SVC_PENDING, "SVC_PENDING" }, \ 1547 { SVC_COMPLETE, "SVC_COMPLETE" }) 1548 1549TRACE_EVENT(svc_authenticate, 1550 TP_PROTO(const struct svc_rqst *rqst, int auth_res, __be32 auth_stat), 1551 1552 TP_ARGS(rqst, auth_res, auth_stat), 1553 1554 TP_STRUCT__entry( 1555 __field(u32, xid) 1556 __field(unsigned long, svc_status) 1557 __field(unsigned long, auth_stat) 1558 ), 1559 1560 TP_fast_assign( 1561 __entry->xid = be32_to_cpu(rqst->rq_xid); 1562 __entry->svc_status = auth_res; 1563 __entry->auth_stat = be32_to_cpu(auth_stat); 1564 ), 1565 1566 TP_printk("xid=0x%08x auth_res=%s auth_stat=%s", 1567 __entry->xid, svc_show_status(__entry->svc_status), 1568 rpc_show_auth_stat(__entry->auth_stat)) 1569); 1570 1571TRACE_EVENT(svc_process, 1572 TP_PROTO(const struct svc_rqst *rqst, const char *name), 1573 1574 TP_ARGS(rqst, name), 1575 1576 TP_STRUCT__entry( 1577 __field(u32, xid) 1578 __field(u32, vers) 1579 __field(u32, proc) 1580 __string(service, name) 1581 __string(addr, rqst->rq_xprt ? 1582 rqst->rq_xprt->xpt_remotebuf : "(null)") 1583 ), 1584 1585 TP_fast_assign( 1586 __entry->xid = be32_to_cpu(rqst->rq_xid); 1587 __entry->vers = rqst->rq_vers; 1588 __entry->proc = rqst->rq_proc; 1589 __assign_str(service, name); 1590 __assign_str(addr, rqst->rq_xprt ? 1591 rqst->rq_xprt->xpt_remotebuf : "(null)"); 1592 ), 1593 1594 TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%u", 1595 __get_str(addr), __entry->xid, 1596 __get_str(service), __entry->vers, __entry->proc) 1597); 1598 1599DECLARE_EVENT_CLASS(svc_rqst_event, 1600 1601 TP_PROTO( 1602 const struct svc_rqst *rqst 1603 ), 1604 1605 TP_ARGS(rqst), 1606 1607 TP_STRUCT__entry( 1608 __field(u32, xid) 1609 __field(unsigned long, flags) 1610 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1611 ), 1612 1613 TP_fast_assign( 1614 __entry->xid = be32_to_cpu(rqst->rq_xid); 1615 __entry->flags = rqst->rq_flags; 1616 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1617 ), 1618 1619 TP_printk("addr=%s xid=0x%08x flags=%s", 1620 __get_str(addr), __entry->xid, 1621 show_rqstp_flags(__entry->flags)) 1622); 1623#define DEFINE_SVC_RQST_EVENT(name) \ 1624 DEFINE_EVENT(svc_rqst_event, svc_##name, \ 1625 TP_PROTO( \ 1626 const struct svc_rqst *rqst \ 1627 ), \ 1628 TP_ARGS(rqst)) 1629 1630DEFINE_SVC_RQST_EVENT(defer); 1631DEFINE_SVC_RQST_EVENT(drop); 1632 1633DECLARE_EVENT_CLASS(svc_rqst_status, 1634 1635 TP_PROTO(struct svc_rqst *rqst, int status), 1636 1637 TP_ARGS(rqst, status), 1638 1639 TP_STRUCT__entry( 1640 __field(u32, xid) 1641 __field(int, status) 1642 __field(unsigned long, flags) 1643 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1644 ), 1645 1646 TP_fast_assign( 1647 __entry->xid = be32_to_cpu(rqst->rq_xid); 1648 __entry->status = status; 1649 __entry->flags = rqst->rq_flags; 1650 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1651 ), 1652 1653 TP_printk("addr=%s xid=0x%08x status=%d flags=%s", 1654 __get_str(addr), __entry->xid, 1655 __entry->status, show_rqstp_flags(__entry->flags)) 1656); 1657 1658DEFINE_EVENT(svc_rqst_status, svc_send, 1659 TP_PROTO(struct svc_rqst *rqst, int status), 1660 TP_ARGS(rqst, status)); 1661 1662#define show_svc_xprt_flags(flags) \ 1663 __print_flags(flags, "|", \ 1664 { (1UL << XPT_BUSY), "XPT_BUSY"}, \ 1665 { (1UL << XPT_CONN), "XPT_CONN"}, \ 1666 { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \ 1667 { (1UL << XPT_DATA), "XPT_DATA"}, \ 1668 { (1UL << XPT_TEMP), "XPT_TEMP"}, \ 1669 { (1UL << XPT_DEAD), "XPT_DEAD"}, \ 1670 { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \ 1671 { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \ 1672 { (1UL << XPT_OLD), "XPT_OLD"}, \ 1673 { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \ 1674 { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \ 1675 { (1UL << XPT_LOCAL), "XPT_LOCAL"}, \ 1676 { (1UL << XPT_KILL_TEMP), "XPT_KILL_TEMP"}, \ 1677 { (1UL << XPT_CONG_CTRL), "XPT_CONG_CTRL"}) 1678 1679TRACE_EVENT(svc_xprt_create_err, 1680 TP_PROTO( 1681 const char *program, 1682 const char *protocol, 1683 struct sockaddr *sap, 1684 const struct svc_xprt *xprt 1685 ), 1686 1687 TP_ARGS(program, protocol, sap, xprt), 1688 1689 TP_STRUCT__entry( 1690 __field(long, error) 1691 __string(program, program) 1692 __string(protocol, protocol) 1693 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1694 ), 1695 1696 TP_fast_assign( 1697 __entry->error = PTR_ERR(xprt); 1698 __assign_str(program, program); 1699 __assign_str(protocol, protocol); 1700 memcpy(__entry->addr, sap, sizeof(__entry->addr)); 1701 ), 1702 1703 TP_printk("addr=%pISpc program=%s protocol=%s error=%ld", 1704 __entry->addr, __get_str(program), __get_str(protocol), 1705 __entry->error) 1706); 1707 1708TRACE_EVENT(svc_xprt_do_enqueue, 1709 TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), 1710 1711 TP_ARGS(xprt, rqst), 1712 1713 TP_STRUCT__entry( 1714 __field(int, pid) 1715 __field(unsigned long, flags) 1716 __string(addr, xprt->xpt_remotebuf) 1717 ), 1718 1719 TP_fast_assign( 1720 __entry->pid = rqst? rqst->rq_task->pid : 0; 1721 __entry->flags = xprt->xpt_flags; 1722 __assign_str(addr, xprt->xpt_remotebuf); 1723 ), 1724 1725 TP_printk("addr=%s pid=%d flags=%s", __get_str(addr), 1726 __entry->pid, show_svc_xprt_flags(__entry->flags)) 1727); 1728 1729DECLARE_EVENT_CLASS(svc_xprt_event, 1730 TP_PROTO(struct svc_xprt *xprt), 1731 1732 TP_ARGS(xprt), 1733 1734 TP_STRUCT__entry( 1735 __field(unsigned long, flags) 1736 __string(addr, xprt->xpt_remotebuf) 1737 ), 1738 1739 TP_fast_assign( 1740 __entry->flags = xprt->xpt_flags; 1741 __assign_str(addr, xprt->xpt_remotebuf); 1742 ), 1743 1744 TP_printk("addr=%s flags=%s", __get_str(addr), 1745 show_svc_xprt_flags(__entry->flags)) 1746); 1747 1748#define DEFINE_SVC_XPRT_EVENT(name) \ 1749 DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \ 1750 TP_PROTO( \ 1751 struct svc_xprt *xprt \ 1752 ), \ 1753 TP_ARGS(xprt)) 1754 1755DEFINE_SVC_XPRT_EVENT(no_write_space); 1756DEFINE_SVC_XPRT_EVENT(close); 1757DEFINE_SVC_XPRT_EVENT(detach); 1758DEFINE_SVC_XPRT_EVENT(free); 1759 1760TRACE_EVENT(svc_xprt_accept, 1761 TP_PROTO( 1762 const struct svc_xprt *xprt, 1763 const char *service 1764 ), 1765 1766 TP_ARGS(xprt, service), 1767 1768 TP_STRUCT__entry( 1769 __string(addr, xprt->xpt_remotebuf) 1770 __string(protocol, xprt->xpt_class->xcl_name) 1771 __string(service, service) 1772 ), 1773 1774 TP_fast_assign( 1775 __assign_str(addr, xprt->xpt_remotebuf); 1776 __assign_str(protocol, xprt->xpt_class->xcl_name) 1777 __assign_str(service, service); 1778 ), 1779 1780 TP_printk("addr=%s protocol=%s service=%s", 1781 __get_str(addr), __get_str(protocol), __get_str(service) 1782 ) 1783); 1784 1785TRACE_EVENT(svc_xprt_dequeue, 1786 TP_PROTO(struct svc_rqst *rqst), 1787 1788 TP_ARGS(rqst), 1789 1790 TP_STRUCT__entry( 1791 __field(unsigned long, flags) 1792 __field(unsigned long, wakeup) 1793 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1794 ), 1795 1796 TP_fast_assign( 1797 __entry->flags = rqst->rq_xprt->xpt_flags; 1798 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(), 1799 rqst->rq_qtime)); 1800 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1801 ), 1802 1803 TP_printk("addr=%s flags=%s wakeup-us=%lu", __get_str(addr), 1804 show_svc_xprt_flags(__entry->flags), __entry->wakeup) 1805); 1806 1807TRACE_EVENT(svc_wake_up, 1808 TP_PROTO(int pid), 1809 1810 TP_ARGS(pid), 1811 1812 TP_STRUCT__entry( 1813 __field(int, pid) 1814 ), 1815 1816 TP_fast_assign( 1817 __entry->pid = pid; 1818 ), 1819 1820 TP_printk("pid=%d", __entry->pid) 1821); 1822 1823TRACE_EVENT(svc_handle_xprt, 1824 TP_PROTO(struct svc_xprt *xprt, int len), 1825 1826 TP_ARGS(xprt, len), 1827 1828 TP_STRUCT__entry( 1829 __field(int, len) 1830 __field(unsigned long, flags) 1831 __string(addr, xprt->xpt_remotebuf) 1832 ), 1833 1834 TP_fast_assign( 1835 __entry->len = len; 1836 __entry->flags = xprt->xpt_flags; 1837 __assign_str(addr, xprt->xpt_remotebuf); 1838 ), 1839 1840 TP_printk("addr=%s len=%d flags=%s", __get_str(addr), 1841 __entry->len, show_svc_xprt_flags(__entry->flags)) 1842); 1843 1844TRACE_EVENT(svc_stats_latency, 1845 TP_PROTO(const struct svc_rqst *rqst), 1846 1847 TP_ARGS(rqst), 1848 1849 TP_STRUCT__entry( 1850 __field(u32, xid) 1851 __field(unsigned long, execute) 1852 __string(addr, rqst->rq_xprt->xpt_remotebuf) 1853 ), 1854 1855 TP_fast_assign( 1856 __entry->xid = be32_to_cpu(rqst->rq_xid); 1857 __entry->execute = ktime_to_us(ktime_sub(ktime_get(), 1858 rqst->rq_stime)); 1859 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1860 ), 1861 1862 TP_printk("addr=%s xid=0x%08x execute-us=%lu", 1863 __get_str(addr), __entry->xid, __entry->execute) 1864); 1865 1866DECLARE_EVENT_CLASS(svc_deferred_event, 1867 TP_PROTO( 1868 const struct svc_deferred_req *dr 1869 ), 1870 1871 TP_ARGS(dr), 1872 1873 TP_STRUCT__entry( 1874 __field(const void *, dr) 1875 __field(u32, xid) 1876 __array(__u8, addr, INET6_ADDRSTRLEN + 10) 1877 ), 1878 1879 TP_fast_assign( 1880 __entry->dr = dr; 1881 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args + 1882 (dr->xprt_hlen>>2))); 1883 snprintf(__entry->addr, sizeof(__entry->addr) - 1, 1884 "%pISpc", (struct sockaddr *)&dr->addr); 1885 ), 1886 1887 TP_printk("addr=%s dr=%p xid=0x%08x", __entry->addr, __entry->dr, 1888 __entry->xid) 1889); 1890 1891#define DEFINE_SVC_DEFERRED_EVENT(name) \ 1892 DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \ 1893 TP_PROTO( \ 1894 const struct svc_deferred_req *dr \ 1895 ), \ 1896 TP_ARGS(dr)) 1897 1898DEFINE_SVC_DEFERRED_EVENT(drop); 1899DEFINE_SVC_DEFERRED_EVENT(queue); 1900DEFINE_SVC_DEFERRED_EVENT(recv); 1901 1902TRACE_EVENT(svcsock_new_socket, 1903 TP_PROTO( 1904 const struct socket *socket 1905 ), 1906 1907 TP_ARGS(socket), 1908 1909 TP_STRUCT__entry( 1910 __field(unsigned long, type) 1911 __field(unsigned long, family) 1912 __field(bool, listener) 1913 ), 1914 1915 TP_fast_assign( 1916 __entry->type = socket->type; 1917 __entry->family = socket->sk->sk_family; 1918 __entry->listener = (socket->sk->sk_state == TCP_LISTEN); 1919 ), 1920 1921 TP_printk("type=%s family=%s%s", 1922 show_socket_type(__entry->type), 1923 rpc_show_address_family(__entry->family), 1924 __entry->listener ? " (listener)" : "" 1925 ) 1926); 1927 1928TRACE_EVENT(svcsock_marker, 1929 TP_PROTO( 1930 const struct svc_xprt *xprt, 1931 __be32 marker 1932 ), 1933 1934 TP_ARGS(xprt, marker), 1935 1936 TP_STRUCT__entry( 1937 __field(unsigned int, length) 1938 __field(bool, last) 1939 __string(addr, xprt->xpt_remotebuf) 1940 ), 1941 1942 TP_fast_assign( 1943 __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK; 1944 __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT; 1945 __assign_str(addr, xprt->xpt_remotebuf); 1946 ), 1947 1948 TP_printk("addr=%s length=%u%s", __get_str(addr), 1949 __entry->length, __entry->last ? " (last)" : "") 1950); 1951 1952DECLARE_EVENT_CLASS(svcsock_class, 1953 TP_PROTO( 1954 const struct svc_xprt *xprt, 1955 ssize_t result 1956 ), 1957 1958 TP_ARGS(xprt, result), 1959 1960 TP_STRUCT__entry( 1961 __field(ssize_t, result) 1962 __field(unsigned long, flags) 1963 __string(addr, xprt->xpt_remotebuf) 1964 ), 1965 1966 TP_fast_assign( 1967 __entry->result = result; 1968 __entry->flags = xprt->xpt_flags; 1969 __assign_str(addr, xprt->xpt_remotebuf); 1970 ), 1971 1972 TP_printk("addr=%s result=%zd flags=%s", __get_str(addr), 1973 __entry->result, show_svc_xprt_flags(__entry->flags) 1974 ) 1975); 1976 1977#define DEFINE_SVCSOCK_EVENT(name) \ 1978 DEFINE_EVENT(svcsock_class, svcsock_##name, \ 1979 TP_PROTO( \ 1980 const struct svc_xprt *xprt, \ 1981 ssize_t result \ 1982 ), \ 1983 TP_ARGS(xprt, result)) 1984 1985DEFINE_SVCSOCK_EVENT(udp_send); 1986DEFINE_SVCSOCK_EVENT(udp_recv); 1987DEFINE_SVCSOCK_EVENT(udp_recv_err); 1988DEFINE_SVCSOCK_EVENT(tcp_send); 1989DEFINE_SVCSOCK_EVENT(tcp_recv); 1990DEFINE_SVCSOCK_EVENT(tcp_recv_eagain); 1991DEFINE_SVCSOCK_EVENT(tcp_recv_err); 1992DEFINE_SVCSOCK_EVENT(data_ready); 1993DEFINE_SVCSOCK_EVENT(write_space); 1994 1995TRACE_EVENT(svcsock_tcp_recv_short, 1996 TP_PROTO( 1997 const struct svc_xprt *xprt, 1998 u32 expected, 1999 u32 received 2000 ), 2001 2002 TP_ARGS(xprt, expected, received), 2003 2004 TP_STRUCT__entry( 2005 __field(u32, expected) 2006 __field(u32, received) 2007 __field(unsigned long, flags) 2008 __string(addr, xprt->xpt_remotebuf) 2009 ), 2010 2011 TP_fast_assign( 2012 __entry->expected = expected; 2013 __entry->received = received; 2014 __entry->flags = xprt->xpt_flags; 2015 __assign_str(addr, xprt->xpt_remotebuf); 2016 ), 2017 2018 TP_printk("addr=%s flags=%s expected=%u received=%u", 2019 __get_str(addr), show_svc_xprt_flags(__entry->flags), 2020 __entry->expected, __entry->received 2021 ) 2022); 2023 2024TRACE_EVENT(svcsock_tcp_state, 2025 TP_PROTO( 2026 const struct svc_xprt *xprt, 2027 const struct socket *socket 2028 ), 2029 2030 TP_ARGS(xprt, socket), 2031 2032 TP_STRUCT__entry( 2033 __field(unsigned long, socket_state) 2034 __field(unsigned long, sock_state) 2035 __field(unsigned long, flags) 2036 __string(addr, xprt->xpt_remotebuf) 2037 ), 2038 2039 TP_fast_assign( 2040 __entry->socket_state = socket->state; 2041 __entry->sock_state = socket->sk->sk_state; 2042 __entry->flags = xprt->xpt_flags; 2043 __assign_str(addr, xprt->xpt_remotebuf); 2044 ), 2045 2046 TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr), 2047 rpc_show_socket_state(__entry->socket_state), 2048 rpc_show_sock_state(__entry->sock_state), 2049 show_svc_xprt_flags(__entry->flags) 2050 ) 2051); 2052 2053DECLARE_EVENT_CLASS(svcsock_accept_class, 2054 TP_PROTO( 2055 const struct svc_xprt *xprt, 2056 const char *service, 2057 long status 2058 ), 2059 2060 TP_ARGS(xprt, service, status), 2061 2062 TP_STRUCT__entry( 2063 __field(long, status) 2064 __string(service, service) 2065 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 2066 ), 2067 2068 TP_fast_assign( 2069 __entry->status = status; 2070 __assign_str(service, service); 2071 memcpy(__entry->addr, &xprt->xpt_local, sizeof(__entry->addr)); 2072 ), 2073 2074 TP_printk("listener=%pISpc service=%s status=%ld", 2075 __entry->addr, __get_str(service), __entry->status 2076 ) 2077); 2078 2079#define DEFINE_ACCEPT_EVENT(name) \ 2080 DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \ 2081 TP_PROTO( \ 2082 const struct svc_xprt *xprt, \ 2083 const char *service, \ 2084 long status \ 2085 ), \ 2086 TP_ARGS(xprt, service, status)) 2087 2088DEFINE_ACCEPT_EVENT(accept); 2089DEFINE_ACCEPT_EVENT(getpeername); 2090 2091DECLARE_EVENT_CLASS(cache_event, 2092 TP_PROTO( 2093 const struct cache_detail *cd, 2094 const struct cache_head *h 2095 ), 2096 2097 TP_ARGS(cd, h), 2098 2099 TP_STRUCT__entry( 2100 __field(const struct cache_head *, h) 2101 __string(name, cd->name) 2102 ), 2103 2104 TP_fast_assign( 2105 __entry->h = h; 2106 __assign_str(name, cd->name); 2107 ), 2108 2109 TP_printk("cache=%s entry=%p", __get_str(name), __entry->h) 2110); 2111#define DEFINE_CACHE_EVENT(name) \ 2112 DEFINE_EVENT(cache_event, name, \ 2113 TP_PROTO( \ 2114 const struct cache_detail *cd, \ 2115 const struct cache_head *h \ 2116 ), \ 2117 TP_ARGS(cd, h)) 2118DEFINE_CACHE_EVENT(cache_entry_expired); 2119DEFINE_CACHE_EVENT(cache_entry_upcall); 2120DEFINE_CACHE_EVENT(cache_entry_update); 2121DEFINE_CACHE_EVENT(cache_entry_make_negative); 2122DEFINE_CACHE_EVENT(cache_entry_no_listener); 2123 2124DECLARE_EVENT_CLASS(register_class, 2125 TP_PROTO( 2126 const char *program, 2127 const u32 version, 2128 const int family, 2129 const unsigned short protocol, 2130 const unsigned short port, 2131 int error 2132 ), 2133 2134 TP_ARGS(program, version, family, protocol, port, error), 2135 2136 TP_STRUCT__entry( 2137 __field(u32, version) 2138 __field(unsigned long, family) 2139 __field(unsigned short, protocol) 2140 __field(unsigned short, port) 2141 __field(int, error) 2142 __string(program, program) 2143 ), 2144 2145 TP_fast_assign( 2146 __entry->version = version; 2147 __entry->family = family; 2148 __entry->protocol = protocol; 2149 __entry->port = port; 2150 __entry->error = error; 2151 __assign_str(program, program); 2152 ), 2153 2154 TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d", 2155 __get_str(program), __entry->version, 2156 __entry->protocol == IPPROTO_UDP ? "udp" : "tcp", 2157 __entry->port, rpc_show_address_family(__entry->family), 2158 __entry->error 2159 ) 2160); 2161 2162#define DEFINE_REGISTER_EVENT(name) \ 2163 DEFINE_EVENT(register_class, svc_##name, \ 2164 TP_PROTO( \ 2165 const char *program, \ 2166 const u32 version, \ 2167 const int family, \ 2168 const unsigned short protocol, \ 2169 const unsigned short port, \ 2170 int error \ 2171 ), \ 2172 TP_ARGS(program, version, family, protocol, \ 2173 port, error)) 2174 2175DEFINE_REGISTER_EVENT(register); 2176DEFINE_REGISTER_EVENT(noregister); 2177 2178TRACE_EVENT(svc_unregister, 2179 TP_PROTO( 2180 const char *program, 2181 const u32 version, 2182 int error 2183 ), 2184 2185 TP_ARGS(program, version, error), 2186 2187 TP_STRUCT__entry( 2188 __field(u32, version) 2189 __field(int, error) 2190 __string(program, program) 2191 ), 2192 2193 TP_fast_assign( 2194 __entry->version = version; 2195 __entry->error = error; 2196 __assign_str(program, program); 2197 ), 2198 2199 TP_printk("program=%sv%u error=%d", 2200 __get_str(program), __entry->version, __entry->error 2201 ) 2202); 2203 2204#endif /* _TRACE_SUNRPC_H */ 2205 2206#include <trace/define_trace.h> 2207