2519 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2#undef TRACE_SYSTEM3#define TRACE_SYSTEM sunrpc4 5#if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)6#define _TRACE_SUNRPC_H7 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#include <trace/misc/sunrpc.h>18 19TRACE_DEFINE_ENUM(SOCK_STREAM);20TRACE_DEFINE_ENUM(SOCK_DGRAM);21TRACE_DEFINE_ENUM(SOCK_RAW);22TRACE_DEFINE_ENUM(SOCK_RDM);23TRACE_DEFINE_ENUM(SOCK_SEQPACKET);24TRACE_DEFINE_ENUM(SOCK_DCCP);25TRACE_DEFINE_ENUM(SOCK_PACKET);26 27#define show_socket_type(type) \28 __print_symbolic(type, \29 { SOCK_STREAM, "STREAM" }, \30 { SOCK_DGRAM, "DGRAM" }, \31 { SOCK_RAW, "RAW" }, \32 { SOCK_RDM, "RDM" }, \33 { SOCK_SEQPACKET, "SEQPACKET" }, \34 { SOCK_DCCP, "DCCP" }, \35 { SOCK_PACKET, "PACKET" })36 37/* This list is known to be incomplete, add new enums as needed. */38TRACE_DEFINE_ENUM(AF_UNSPEC);39TRACE_DEFINE_ENUM(AF_UNIX);40TRACE_DEFINE_ENUM(AF_LOCAL);41TRACE_DEFINE_ENUM(AF_INET);42TRACE_DEFINE_ENUM(AF_INET6);43 44#define rpc_show_address_family(family) \45 __print_symbolic(family, \46 { AF_UNSPEC, "AF_UNSPEC" }, \47 { AF_UNIX, "AF_UNIX" }, \48 { AF_LOCAL, "AF_LOCAL" }, \49 { AF_INET, "AF_INET" }, \50 { AF_INET6, "AF_INET6" })51 52DECLARE_EVENT_CLASS(rpc_xdr_buf_class,53 TP_PROTO(54 const struct rpc_task *task,55 const struct xdr_buf *xdr56 ),57 58 TP_ARGS(task, xdr),59 60 TP_STRUCT__entry(61 __field(unsigned int, task_id)62 __field(unsigned int, client_id)63 __field(const void *, head_base)64 __field(size_t, head_len)65 __field(const void *, tail_base)66 __field(size_t, tail_len)67 __field(unsigned int, page_base)68 __field(unsigned int, page_len)69 __field(unsigned int, msg_len)70 ),71 72 TP_fast_assign(73 __entry->task_id = task->tk_pid;74 __entry->client_id = task->tk_client ?75 task->tk_client->cl_clid : -1;76 __entry->head_base = xdr->head[0].iov_base;77 __entry->head_len = xdr->head[0].iov_len;78 __entry->tail_base = xdr->tail[0].iov_base;79 __entry->tail_len = xdr->tail[0].iov_len;80 __entry->page_base = xdr->page_base;81 __entry->page_len = xdr->page_len;82 __entry->msg_len = xdr->len;83 ),84 85 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER86 " head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",87 __entry->task_id, __entry->client_id,88 __entry->head_base, __entry->head_len,89 __entry->page_len, __entry->page_base,90 __entry->tail_base, __entry->tail_len,91 __entry->msg_len92 )93);94 95#define DEFINE_RPCXDRBUF_EVENT(name) \96 DEFINE_EVENT(rpc_xdr_buf_class, \97 rpc_xdr_##name, \98 TP_PROTO( \99 const struct rpc_task *task, \100 const struct xdr_buf *xdr \101 ), \102 TP_ARGS(task, xdr))103 104DEFINE_RPCXDRBUF_EVENT(sendto);105DEFINE_RPCXDRBUF_EVENT(recvfrom);106DEFINE_RPCXDRBUF_EVENT(reply_pages);107 108 109DECLARE_EVENT_CLASS(rpc_clnt_class,110 TP_PROTO(111 const struct rpc_clnt *clnt112 ),113 114 TP_ARGS(clnt),115 116 TP_STRUCT__entry(117 __field(unsigned int, client_id)118 ),119 120 TP_fast_assign(121 __entry->client_id = clnt->cl_clid;122 ),123 124 TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER, __entry->client_id)125);126 127#define DEFINE_RPC_CLNT_EVENT(name) \128 DEFINE_EVENT(rpc_clnt_class, \129 rpc_clnt_##name, \130 TP_PROTO( \131 const struct rpc_clnt *clnt \132 ), \133 TP_ARGS(clnt))134 135DEFINE_RPC_CLNT_EVENT(free);136DEFINE_RPC_CLNT_EVENT(killall);137DEFINE_RPC_CLNT_EVENT(shutdown);138DEFINE_RPC_CLNT_EVENT(release);139DEFINE_RPC_CLNT_EVENT(replace_xprt);140DEFINE_RPC_CLNT_EVENT(replace_xprt_err);141 142TRACE_DEFINE_ENUM(RPC_XPRTSEC_NONE);143TRACE_DEFINE_ENUM(RPC_XPRTSEC_TLS_X509);144 145#define rpc_show_xprtsec_policy(policy) \146 __print_symbolic(policy, \147 { RPC_XPRTSEC_NONE, "none" }, \148 { RPC_XPRTSEC_TLS_ANON, "tls-anon" }, \149 { RPC_XPRTSEC_TLS_X509, "tls-x509" })150 151#define rpc_show_create_flags(flags) \152 __print_flags(flags, "|", \153 { RPC_CLNT_CREATE_HARDRTRY, "HARDRTRY" }, \154 { RPC_CLNT_CREATE_AUTOBIND, "AUTOBIND" }, \155 { RPC_CLNT_CREATE_NONPRIVPORT, "NONPRIVPORT" }, \156 { RPC_CLNT_CREATE_NOPING, "NOPING" }, \157 { RPC_CLNT_CREATE_DISCRTRY, "DISCRTRY" }, \158 { RPC_CLNT_CREATE_QUIET, "QUIET" }, \159 { RPC_CLNT_CREATE_INFINITE_SLOTS, \160 "INFINITE_SLOTS" }, \161 { RPC_CLNT_CREATE_NO_IDLE_TIMEOUT, \162 "NO_IDLE_TIMEOUT" }, \163 { RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT, \164 "NO_RETRANS_TIMEOUT" }, \165 { RPC_CLNT_CREATE_SOFTERR, "SOFTERR" }, \166 { RPC_CLNT_CREATE_REUSEPORT, "REUSEPORT" })167 168TRACE_EVENT(rpc_clnt_new,169 TP_PROTO(170 const struct rpc_clnt *clnt,171 const struct rpc_xprt *xprt,172 const struct rpc_create_args *args173 ),174 175 TP_ARGS(clnt, xprt, args),176 177 TP_STRUCT__entry(178 __field(unsigned int, client_id)179 __field(unsigned long, xprtsec)180 __field(unsigned long, flags)181 __string(program, clnt->cl_program->name)182 __string(server, xprt->servername)183 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])184 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])185 ),186 187 TP_fast_assign(188 __entry->client_id = clnt->cl_clid;189 __entry->xprtsec = args->xprtsec.policy;190 __entry->flags = args->flags;191 __assign_str(program);192 __assign_str(server);193 __assign_str(addr);194 __assign_str(port);195 ),196 197 TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER " peer=[%s]:%s"198 " program=%s server=%s xprtsec=%s flags=%s",199 __entry->client_id, __get_str(addr), __get_str(port),200 __get_str(program), __get_str(server),201 rpc_show_xprtsec_policy(__entry->xprtsec),202 rpc_show_create_flags(__entry->flags)203 )204);205 206TRACE_EVENT(rpc_clnt_new_err,207 TP_PROTO(208 const char *program,209 const char *server,210 int error211 ),212 213 TP_ARGS(program, server, error),214 215 TP_STRUCT__entry(216 __field(int, error)217 __string(program, program)218 __string(server, server)219 ),220 221 TP_fast_assign(222 __entry->error = error;223 __assign_str(program);224 __assign_str(server);225 ),226 227 TP_printk("program=%s server=%s error=%d",228 __get_str(program), __get_str(server), __entry->error)229);230 231TRACE_EVENT(rpc_clnt_clone_err,232 TP_PROTO(233 const struct rpc_clnt *clnt,234 int error235 ),236 237 TP_ARGS(clnt, error),238 239 TP_STRUCT__entry(240 __field(unsigned int, client_id)241 __field(int, error)242 ),243 244 TP_fast_assign(245 __entry->client_id = clnt->cl_clid;246 __entry->error = error;247 ),248 249 TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER " error=%d",250 __entry->client_id, __entry->error)251);252 253 254TRACE_DEFINE_ENUM(RPC_AUTH_OK);255TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);256TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);257TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);258TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);259TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);260TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);261TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);262 263#define rpc_show_auth_stat(status) \264 __print_symbolic(status, \265 { RPC_AUTH_OK, "AUTH_OK" }, \266 { RPC_AUTH_BADCRED, "BADCRED" }, \267 { RPC_AUTH_REJECTEDCRED, "REJECTEDCRED" }, \268 { RPC_AUTH_BADVERF, "BADVERF" }, \269 { RPC_AUTH_REJECTEDVERF, "REJECTEDVERF" }, \270 { RPC_AUTH_TOOWEAK, "TOOWEAK" }, \271 { RPCSEC_GSS_CREDPROBLEM, "GSS_CREDPROBLEM" }, \272 { RPCSEC_GSS_CTXPROBLEM, "GSS_CTXPROBLEM" }) \273 274DECLARE_EVENT_CLASS(rpc_task_status,275 276 TP_PROTO(const struct rpc_task *task),277 278 TP_ARGS(task),279 280 TP_STRUCT__entry(281 __field(unsigned int, task_id)282 __field(unsigned int, client_id)283 __field(int, status)284 ),285 286 TP_fast_assign(287 __entry->task_id = task->tk_pid;288 __entry->client_id = task->tk_client->cl_clid;289 __entry->status = task->tk_status;290 ),291 292 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d",293 __entry->task_id, __entry->client_id,294 __entry->status)295);296#define DEFINE_RPC_STATUS_EVENT(name) \297 DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \298 TP_PROTO( \299 const struct rpc_task *task \300 ), \301 TP_ARGS(task))302 303DEFINE_RPC_STATUS_EVENT(call);304DEFINE_RPC_STATUS_EVENT(connect);305DEFINE_RPC_STATUS_EVENT(timeout);306DEFINE_RPC_STATUS_EVENT(retry_refresh);307DEFINE_RPC_STATUS_EVENT(refresh);308 309TRACE_EVENT(rpc_request,310 TP_PROTO(const struct rpc_task *task),311 312 TP_ARGS(task),313 314 TP_STRUCT__entry(315 __field(unsigned int, task_id)316 __field(unsigned int, client_id)317 __field(int, version)318 __field(bool, async)319 __string(progname, task->tk_client->cl_program->name)320 __string(procname, rpc_proc_name(task))321 ),322 323 TP_fast_assign(324 __entry->task_id = task->tk_pid;325 __entry->client_id = task->tk_client->cl_clid;326 __entry->version = task->tk_client->cl_vers;327 __entry->async = RPC_IS_ASYNC(task);328 __assign_str(progname);329 __assign_str(procname);330 ),331 332 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " %sv%d %s (%ssync)",333 __entry->task_id, __entry->client_id,334 __get_str(progname), __entry->version,335 __get_str(procname), __entry->async ? "a": ""336 )337);338 339#define rpc_show_task_flags(flags) \340 __print_flags(flags, "|", \341 { RPC_TASK_ASYNC, "ASYNC" }, \342 { RPC_TASK_SWAPPER, "SWAPPER" }, \343 { RPC_TASK_MOVEABLE, "MOVEABLE" }, \344 { RPC_TASK_NULLCREDS, "NULLCREDS" }, \345 { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \346 { RPC_TASK_DYNAMIC, "DYNAMIC" }, \347 { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" }, \348 { RPC_TASK_SOFT, "SOFT" }, \349 { RPC_TASK_SOFTCONN, "SOFTCONN" }, \350 { RPC_TASK_SENT, "SENT" }, \351 { RPC_TASK_TIMEOUT, "TIMEOUT" }, \352 { RPC_TASK_NOCONNECT, "NOCONNECT" }, \353 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }, \354 { RPC_TASK_CRED_NOREF, "CRED_NOREF" })355 356#define rpc_show_runstate(flags) \357 __print_flags(flags, "|", \358 { (1UL << RPC_TASK_RUNNING), "RUNNING" }, \359 { (1UL << RPC_TASK_QUEUED), "QUEUED" }, \360 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" }, \361 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" }, \362 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" }, \363 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \364 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })365 366DECLARE_EVENT_CLASS(rpc_task_running,367 368 TP_PROTO(const struct rpc_task *task, const void *action),369 370 TP_ARGS(task, action),371 372 TP_STRUCT__entry(373 __field(unsigned int, task_id)374 __field(unsigned int, client_id)375 __field(const void *, action)376 __field(unsigned long, runstate)377 __field(int, status)378 __field(unsigned short, flags)379 ),380 381 TP_fast_assign(382 __entry->client_id = task->tk_client ?383 task->tk_client->cl_clid : -1;384 __entry->task_id = task->tk_pid;385 __entry->action = action;386 __entry->runstate = task->tk_runstate;387 __entry->status = task->tk_status;388 __entry->flags = task->tk_flags;389 ),390 391 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER392 " flags=%s runstate=%s status=%d action=%ps",393 __entry->task_id, __entry->client_id,394 rpc_show_task_flags(__entry->flags),395 rpc_show_runstate(__entry->runstate),396 __entry->status,397 __entry->action398 )399);400#define DEFINE_RPC_RUNNING_EVENT(name) \401 DEFINE_EVENT(rpc_task_running, rpc_task_##name, \402 TP_PROTO( \403 const struct rpc_task *task, \404 const void *action \405 ), \406 TP_ARGS(task, action))407 408DEFINE_RPC_RUNNING_EVENT(begin);409DEFINE_RPC_RUNNING_EVENT(run_action);410DEFINE_RPC_RUNNING_EVENT(sync_sleep);411DEFINE_RPC_RUNNING_EVENT(sync_wake);412DEFINE_RPC_RUNNING_EVENT(complete);413DEFINE_RPC_RUNNING_EVENT(timeout);414DEFINE_RPC_RUNNING_EVENT(signalled);415DEFINE_RPC_RUNNING_EVENT(end);416DEFINE_RPC_RUNNING_EVENT(call_done);417 418DECLARE_EVENT_CLASS(rpc_task_queued,419 420 TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),421 422 TP_ARGS(task, q),423 424 TP_STRUCT__entry(425 __field(unsigned int, task_id)426 __field(unsigned int, client_id)427 __field(unsigned long, timeout)428 __field(unsigned long, runstate)429 __field(int, status)430 __field(unsigned short, flags)431 __string(q_name, rpc_qname(q))432 ),433 434 TP_fast_assign(435 __entry->client_id = task->tk_client ?436 task->tk_client->cl_clid : -1;437 __entry->task_id = task->tk_pid;438 __entry->timeout = rpc_task_timeout(task);439 __entry->runstate = task->tk_runstate;440 __entry->status = task->tk_status;441 __entry->flags = task->tk_flags;442 __assign_str(q_name);443 ),444 445 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER446 " flags=%s runstate=%s status=%d timeout=%lu queue=%s",447 __entry->task_id, __entry->client_id,448 rpc_show_task_flags(__entry->flags),449 rpc_show_runstate(__entry->runstate),450 __entry->status,451 __entry->timeout,452 __get_str(q_name)453 )454);455#define DEFINE_RPC_QUEUED_EVENT(name) \456 DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \457 TP_PROTO( \458 const struct rpc_task *task, \459 const struct rpc_wait_queue *q \460 ), \461 TP_ARGS(task, q))462 463DEFINE_RPC_QUEUED_EVENT(sleep);464DEFINE_RPC_QUEUED_EVENT(wakeup);465 466DECLARE_EVENT_CLASS(rpc_failure,467 468 TP_PROTO(const struct rpc_task *task),469 470 TP_ARGS(task),471 472 TP_STRUCT__entry(473 __field(unsigned int, task_id)474 __field(unsigned int, client_id)475 ),476 477 TP_fast_assign(478 __entry->task_id = task->tk_pid;479 __entry->client_id = task->tk_client->cl_clid;480 ),481 482 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER,483 __entry->task_id, __entry->client_id)484);485 486#define DEFINE_RPC_FAILURE(name) \487 DEFINE_EVENT(rpc_failure, rpc_bad_##name, \488 TP_PROTO( \489 const struct rpc_task *task \490 ), \491 TP_ARGS(task))492 493DEFINE_RPC_FAILURE(callhdr);494DEFINE_RPC_FAILURE(verifier);495 496DECLARE_EVENT_CLASS(rpc_reply_event,497 498 TP_PROTO(499 const struct rpc_task *task500 ),501 502 TP_ARGS(task),503 504 TP_STRUCT__entry(505 __field(unsigned int, task_id)506 __field(unsigned int, client_id)507 __field(u32, xid)508 __string(progname, task->tk_client->cl_program->name)509 __field(u32, version)510 __string(procname, rpc_proc_name(task))511 __string(servername, task->tk_xprt->servername)512 ),513 514 TP_fast_assign(515 __entry->task_id = task->tk_pid;516 __entry->client_id = task->tk_client->cl_clid;517 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);518 __assign_str(progname);519 __entry->version = task->tk_client->cl_vers;520 __assign_str(procname);521 __assign_str(servername);522 ),523 524 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER525 " server=%s xid=0x%08x %sv%d %s",526 __entry->task_id, __entry->client_id, __get_str(servername),527 __entry->xid, __get_str(progname), __entry->version,528 __get_str(procname))529)530 531#define DEFINE_RPC_REPLY_EVENT(name) \532 DEFINE_EVENT(rpc_reply_event, rpc__##name, \533 TP_PROTO( \534 const struct rpc_task *task \535 ), \536 TP_ARGS(task))537 538DEFINE_RPC_REPLY_EVENT(prog_unavail);539DEFINE_RPC_REPLY_EVENT(prog_mismatch);540DEFINE_RPC_REPLY_EVENT(proc_unavail);541DEFINE_RPC_REPLY_EVENT(garbage_args);542DEFINE_RPC_REPLY_EVENT(unparsable);543DEFINE_RPC_REPLY_EVENT(mismatch);544DEFINE_RPC_REPLY_EVENT(stale_creds);545DEFINE_RPC_REPLY_EVENT(bad_creds);546DEFINE_RPC_REPLY_EVENT(auth_tooweak);547 548#define DEFINE_RPCB_ERROR_EVENT(name) \549 DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err, \550 TP_PROTO( \551 const struct rpc_task *task \552 ), \553 TP_ARGS(task))554 555DEFINE_RPCB_ERROR_EVENT(prog_unavail);556DEFINE_RPCB_ERROR_EVENT(timeout);557DEFINE_RPCB_ERROR_EVENT(bind_version);558DEFINE_RPCB_ERROR_EVENT(unreachable);559DEFINE_RPCB_ERROR_EVENT(unrecognized);560 561TRACE_EVENT(rpc_buf_alloc,562 TP_PROTO(563 const struct rpc_task *task,564 int status565 ),566 567 TP_ARGS(task, status),568 569 TP_STRUCT__entry(570 __field(unsigned int, task_id)571 __field(unsigned int, client_id)572 __field(size_t, callsize)573 __field(size_t, recvsize)574 __field(int, status)575 ),576 577 TP_fast_assign(578 __entry->task_id = task->tk_pid;579 __entry->client_id = task->tk_client->cl_clid;580 __entry->callsize = task->tk_rqstp->rq_callsize;581 __entry->recvsize = task->tk_rqstp->rq_rcvsize;582 __entry->status = status;583 ),584 585 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER586 " callsize=%zu recvsize=%zu status=%d",587 __entry->task_id, __entry->client_id,588 __entry->callsize, __entry->recvsize, __entry->status589 )590);591 592TRACE_EVENT(rpc_call_rpcerror,593 TP_PROTO(594 const struct rpc_task *task,595 int tk_status,596 int rpc_status597 ),598 599 TP_ARGS(task, tk_status, rpc_status),600 601 TP_STRUCT__entry(602 __field(unsigned int, task_id)603 __field(unsigned int, client_id)604 __field(int, tk_status)605 __field(int, rpc_status)606 ),607 608 TP_fast_assign(609 __entry->client_id = task->tk_client->cl_clid;610 __entry->task_id = task->tk_pid;611 __entry->tk_status = tk_status;612 __entry->rpc_status = rpc_status;613 ),614 615 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER616 " tk_status=%d rpc_status=%d",617 __entry->task_id, __entry->client_id,618 __entry->tk_status, __entry->rpc_status)619);620 621TRACE_EVENT(rpc_stats_latency,622 623 TP_PROTO(624 const struct rpc_task *task,625 ktime_t backlog,626 ktime_t rtt,627 ktime_t execute628 ),629 630 TP_ARGS(task, backlog, rtt, execute),631 632 TP_STRUCT__entry(633 __field(unsigned int, task_id)634 __field(unsigned int, client_id)635 __field(u32, xid)636 __field(int, version)637 __string(progname, task->tk_client->cl_program->name)638 __string(procname, rpc_proc_name(task))639 __field(unsigned long, backlog)640 __field(unsigned long, rtt)641 __field(unsigned long, execute)642 __field(u32, xprt_id)643 ),644 645 TP_fast_assign(646 __entry->client_id = task->tk_client->cl_clid;647 __entry->task_id = task->tk_pid;648 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);649 __entry->version = task->tk_client->cl_vers;650 __assign_str(progname);651 __assign_str(procname);652 __entry->backlog = ktime_to_us(backlog);653 __entry->rtt = ktime_to_us(rtt);654 __entry->execute = ktime_to_us(execute);655 __entry->xprt_id = task->tk_xprt->id;656 ),657 658 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER659 " xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu"660 " xprt_id=%d",661 __entry->task_id, __entry->client_id, __entry->xid,662 __get_str(progname), __entry->version, __get_str(procname),663 __entry->backlog, __entry->rtt, __entry->execute,664 __entry->xprt_id)665);666 667TRACE_EVENT(rpc_xdr_overflow,668 TP_PROTO(669 const struct xdr_stream *xdr,670 size_t requested671 ),672 673 TP_ARGS(xdr, requested),674 675 TP_STRUCT__entry(676 __field(unsigned int, task_id)677 __field(unsigned int, client_id)678 __field(int, version)679 __field(size_t, requested)680 __field(const void *, end)681 __field(const void *, p)682 __field(const void *, head_base)683 __field(size_t, head_len)684 __field(const void *, tail_base)685 __field(size_t, tail_len)686 __field(unsigned int, page_len)687 __field(unsigned int, len)688 __string(progname, xdr->rqst ?689 xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")690 __string(procedure, xdr->rqst ?691 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")692 ),693 694 TP_fast_assign(695 if (xdr->rqst) {696 const struct rpc_task *task = xdr->rqst->rq_task;697 698 __entry->task_id = task->tk_pid;699 __entry->client_id = task->tk_client->cl_clid;700 __assign_str(progname);701 __entry->version = task->tk_client->cl_vers;702 __assign_str(procedure);703 } else {704 __entry->task_id = -1;705 __entry->client_id = -1;706 __assign_str(progname);707 __entry->version = 0;708 __assign_str(procedure);709 }710 __entry->requested = requested;711 __entry->end = xdr->end;712 __entry->p = xdr->p;713 __entry->head_base = xdr->buf->head[0].iov_base,714 __entry->head_len = xdr->buf->head[0].iov_len,715 __entry->page_len = xdr->buf->page_len,716 __entry->tail_base = xdr->buf->tail[0].iov_base,717 __entry->tail_len = xdr->buf->tail[0].iov_len,718 __entry->len = xdr->buf->len;719 ),720 721 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER722 " %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",723 __entry->task_id, __entry->client_id,724 __get_str(progname), __entry->version, __get_str(procedure),725 __entry->requested, __entry->p, __entry->end,726 __entry->head_base, __entry->head_len,727 __entry->page_len,728 __entry->tail_base, __entry->tail_len,729 __entry->len730 )731);732 733TRACE_EVENT(rpc_xdr_alignment,734 TP_PROTO(735 const struct xdr_stream *xdr,736 size_t offset,737 unsigned int copied738 ),739 740 TP_ARGS(xdr, offset, copied),741 742 TP_STRUCT__entry(743 __field(unsigned int, task_id)744 __field(unsigned int, client_id)745 __field(int, version)746 __field(size_t, offset)747 __field(unsigned int, copied)748 __field(const void *, head_base)749 __field(size_t, head_len)750 __field(const void *, tail_base)751 __field(size_t, tail_len)752 __field(unsigned int, page_len)753 __field(unsigned int, len)754 __string(progname,755 xdr->rqst->rq_task->tk_client->cl_program->name)756 __string(procedure,757 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)758 ),759 760 TP_fast_assign(761 const struct rpc_task *task = xdr->rqst->rq_task;762 763 __entry->task_id = task->tk_pid;764 __entry->client_id = task->tk_client->cl_clid;765 __assign_str(progname);766 __entry->version = task->tk_client->cl_vers;767 __assign_str(procedure);768 769 __entry->offset = offset;770 __entry->copied = copied;771 __entry->head_base = xdr->buf->head[0].iov_base,772 __entry->head_len = xdr->buf->head[0].iov_len,773 __entry->page_len = xdr->buf->page_len,774 __entry->tail_base = xdr->buf->tail[0].iov_base,775 __entry->tail_len = xdr->buf->tail[0].iov_len,776 __entry->len = xdr->buf->len;777 ),778 779 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER780 " %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",781 __entry->task_id, __entry->client_id,782 __get_str(progname), __entry->version, __get_str(procedure),783 __entry->offset, __entry->copied,784 __entry->head_base, __entry->head_len,785 __entry->page_len,786 __entry->tail_base, __entry->tail_len,787 __entry->len788 )789);790 791/*792 * First define the enums in the below macros to be exported to userspace793 * via TRACE_DEFINE_ENUM().794 */795#undef EM796#undef EMe797#define EM(a, b) TRACE_DEFINE_ENUM(a);798#define EMe(a, b) TRACE_DEFINE_ENUM(a);799 800#define RPC_SHOW_SOCKET \801 EM( SS_FREE, "FREE" ) \802 EM( SS_UNCONNECTED, "UNCONNECTED" ) \803 EM( SS_CONNECTING, "CONNECTING" ) \804 EM( SS_CONNECTED, "CONNECTED" ) \805 EMe( SS_DISCONNECTING, "DISCONNECTING" )806 807#define rpc_show_socket_state(state) \808 __print_symbolic(state, RPC_SHOW_SOCKET)809 810RPC_SHOW_SOCKET811 812#define RPC_SHOW_SOCK \813 EM( TCP_ESTABLISHED, "ESTABLISHED" ) \814 EM( TCP_SYN_SENT, "SYN_SENT" ) \815 EM( TCP_SYN_RECV, "SYN_RECV" ) \816 EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \817 EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \818 EM( TCP_TIME_WAIT, "TIME_WAIT" ) \819 EM( TCP_CLOSE, "CLOSE" ) \820 EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \821 EM( TCP_LAST_ACK, "LAST_ACK" ) \822 EM( TCP_LISTEN, "LISTEN" ) \823 EMe( TCP_CLOSING, "CLOSING" )824 825#define rpc_show_sock_state(state) \826 __print_symbolic(state, RPC_SHOW_SOCK)827 828RPC_SHOW_SOCK829 830 831#include <trace/events/net_probe_common.h>832 833/*834 * Now redefine the EM() and EMe() macros to map the enums to the strings835 * that will be printed in the output.836 */837#undef EM838#undef EMe839#define EM(a, b) {a, b},840#define EMe(a, b) {a, b}841 842DECLARE_EVENT_CLASS(xs_socket_event,843 844 TP_PROTO(845 struct rpc_xprt *xprt,846 struct socket *socket847 ),848 849 TP_ARGS(xprt, socket),850 851 TP_STRUCT__entry(852 __field(unsigned int, socket_state)853 __field(unsigned int, sock_state)854 __field(unsigned long long, ino)855 __array(__u8, saddr, sizeof(struct sockaddr_in6))856 __array(__u8, daddr, sizeof(struct sockaddr_in6))857 ),858 859 TP_fast_assign(860 struct inode *inode = SOCK_INODE(socket);861 const struct sock *sk = socket->sk;862 const struct inet_sock *inet = inet_sk(sk);863 864 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));865 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));866 867 TP_STORE_ADDR_PORTS(__entry, inet, sk);868 869 __entry->socket_state = socket->state;870 __entry->sock_state = socket->sk->sk_state;871 __entry->ino = (unsigned long long)inode->i_ino;872 873 ),874 875 TP_printk(876 "socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "877 "state=%u (%s) sk_state=%u (%s)",878 __entry->ino,879 __entry->saddr,880 __entry->daddr,881 __entry->socket_state,882 rpc_show_socket_state(__entry->socket_state),883 __entry->sock_state,884 rpc_show_sock_state(__entry->sock_state)885 )886);887#define DEFINE_RPC_SOCKET_EVENT(name) \888 DEFINE_EVENT(xs_socket_event, name, \889 TP_PROTO( \890 struct rpc_xprt *xprt, \891 struct socket *socket \892 ), \893 TP_ARGS(xprt, socket))894 895DECLARE_EVENT_CLASS(xs_socket_event_done,896 897 TP_PROTO(898 struct rpc_xprt *xprt,899 struct socket *socket,900 int error901 ),902 903 TP_ARGS(xprt, socket, error),904 905 TP_STRUCT__entry(906 __field(int, error)907 __field(unsigned int, socket_state)908 __field(unsigned int, sock_state)909 __field(unsigned long long, ino)910 __array(__u8, saddr, sizeof(struct sockaddr_in6))911 __array(__u8, daddr, sizeof(struct sockaddr_in6))912 ),913 914 TP_fast_assign(915 struct inode *inode = SOCK_INODE(socket);916 const struct sock *sk = socket->sk;917 const struct inet_sock *inet = inet_sk(sk);918 919 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));920 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));921 922 TP_STORE_ADDR_PORTS(__entry, inet, sk);923 924 __entry->socket_state = socket->state;925 __entry->sock_state = socket->sk->sk_state;926 __entry->ino = (unsigned long long)inode->i_ino;927 __entry->error = error;928 ),929 930 TP_printk(931 "error=%d socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "932 "state=%u (%s) sk_state=%u (%s)",933 __entry->error,934 __entry->ino,935 __entry->saddr,936 __entry->daddr,937 __entry->socket_state,938 rpc_show_socket_state(__entry->socket_state),939 __entry->sock_state,940 rpc_show_sock_state(__entry->sock_state)941 )942);943#define DEFINE_RPC_SOCKET_EVENT_DONE(name) \944 DEFINE_EVENT(xs_socket_event_done, name, \945 TP_PROTO( \946 struct rpc_xprt *xprt, \947 struct socket *socket, \948 int error \949 ), \950 TP_ARGS(xprt, socket, error))951 952DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);953DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);954DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);955DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);956DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);957DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);958 959TRACE_EVENT(rpc_socket_nospace,960 TP_PROTO(961 const struct rpc_rqst *rqst,962 const struct sock_xprt *transport963 ),964 965 TP_ARGS(rqst, transport),966 967 TP_STRUCT__entry(968 __field(unsigned int, task_id)969 __field(unsigned int, client_id)970 __field(unsigned int, total)971 __field(unsigned int, remaining)972 ),973 974 TP_fast_assign(975 __entry->task_id = rqst->rq_task->tk_pid;976 __entry->client_id = rqst->rq_task->tk_client->cl_clid;977 __entry->total = rqst->rq_slen;978 __entry->remaining = rqst->rq_slen - transport->xmit.offset;979 ),980 981 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER982 " total=%u remaining=%u",983 __entry->task_id, __entry->client_id,984 __entry->total, __entry->remaining985 )986);987 988#define rpc_show_xprt_state(x) \989 __print_flags(x, "|", \990 { BIT(XPRT_LOCKED), "LOCKED" }, \991 { BIT(XPRT_CONNECTED), "CONNECTED" }, \992 { BIT(XPRT_CONNECTING), "CONNECTING" }, \993 { BIT(XPRT_CLOSE_WAIT), "CLOSE_WAIT" }, \994 { BIT(XPRT_BOUND), "BOUND" }, \995 { BIT(XPRT_BINDING), "BINDING" }, \996 { BIT(XPRT_CLOSING), "CLOSING" }, \997 { BIT(XPRT_OFFLINE), "OFFLINE" }, \998 { BIT(XPRT_REMOVE), "REMOVE" }, \999 { BIT(XPRT_CONGESTED), "CONGESTED" }, \1000 { BIT(XPRT_CWND_WAIT), "CWND_WAIT" }, \1001 { BIT(XPRT_WRITE_SPACE), "WRITE_SPACE" }, \1002 { BIT(XPRT_SND_IS_COOKIE), "SND_IS_COOKIE" })1003 1004DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,1005 TP_PROTO(1006 const struct rpc_xprt *xprt1007 ),1008 1009 TP_ARGS(xprt),1010 1011 TP_STRUCT__entry(1012 __field(unsigned long, state)1013 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])1014 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])1015 ),1016 1017 TP_fast_assign(1018 __entry->state = xprt->state;1019 __assign_str(addr);1020 __assign_str(port);1021 ),1022 1023 TP_printk("peer=[%s]:%s state=%s",1024 __get_str(addr), __get_str(port),1025 rpc_show_xprt_state(__entry->state))1026);1027 1028#define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \1029 DEFINE_EVENT(rpc_xprt_lifetime_class, \1030 xprt_##name, \1031 TP_PROTO( \1032 const struct rpc_xprt *xprt \1033 ), \1034 TP_ARGS(xprt))1035 1036DEFINE_RPC_XPRT_LIFETIME_EVENT(create);1037DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);1038DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);1039DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);1040DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);1041DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);1042 1043DECLARE_EVENT_CLASS(rpc_xprt_event,1044 TP_PROTO(1045 const struct rpc_xprt *xprt,1046 __be32 xid,1047 int status1048 ),1049 1050 TP_ARGS(xprt, xid, status),1051 1052 TP_STRUCT__entry(1053 __field(u32, xid)1054 __field(int, status)1055 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])1056 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])1057 ),1058 1059 TP_fast_assign(1060 __entry->xid = be32_to_cpu(xid);1061 __entry->status = status;1062 __assign_str(addr);1063 __assign_str(port);1064 ),1065 1066 TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),1067 __get_str(port), __entry->xid,1068 __entry->status)1069);1070#define DEFINE_RPC_XPRT_EVENT(name) \1071 DEFINE_EVENT(rpc_xprt_event, xprt_##name, \1072 TP_PROTO( \1073 const struct rpc_xprt *xprt, \1074 __be32 xid, \1075 int status \1076 ), \1077 TP_ARGS(xprt, xid, status))1078 1079DEFINE_RPC_XPRT_EVENT(timer);1080DEFINE_RPC_XPRT_EVENT(lookup_rqst);1081 1082TRACE_EVENT(xprt_transmit,1083 TP_PROTO(1084 const struct rpc_rqst *rqst,1085 int status1086 ),1087 1088 TP_ARGS(rqst, status),1089 1090 TP_STRUCT__entry(1091 __field(unsigned int, task_id)1092 __field(unsigned int, client_id)1093 __field(u32, xid)1094 __field(u32, seqno)1095 __field(int, status)1096 ),1097 1098 TP_fast_assign(1099 __entry->task_id = rqst->rq_task->tk_pid;1100 __entry->client_id = rqst->rq_task->tk_client ?1101 rqst->rq_task->tk_client->cl_clid : -1;1102 __entry->xid = be32_to_cpu(rqst->rq_xid);1103 __entry->seqno = rqst->rq_seqno;1104 __entry->status = status;1105 ),1106 1107 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER1108 " xid=0x%08x seqno=%u status=%d",1109 __entry->task_id, __entry->client_id, __entry->xid,1110 __entry->seqno, __entry->status)1111);1112 1113TRACE_EVENT(xprt_retransmit,1114 TP_PROTO(1115 const struct rpc_rqst *rqst1116 ),1117 1118 TP_ARGS(rqst),1119 1120 TP_STRUCT__entry(1121 __field(unsigned int, task_id)1122 __field(unsigned int, client_id)1123 __field(u32, xid)1124 __field(int, ntrans)1125 __field(int, version)1126 __field(unsigned long, timeout)1127 __string(progname,1128 rqst->rq_task->tk_client->cl_program->name)1129 __string(procname, rpc_proc_name(rqst->rq_task))1130 ),1131 1132 TP_fast_assign(1133 struct rpc_task *task = rqst->rq_task;1134 1135 __entry->task_id = task->tk_pid;1136 __entry->client_id = task->tk_client ?1137 task->tk_client->cl_clid : -1;1138 __entry->xid = be32_to_cpu(rqst->rq_xid);1139 __entry->ntrans = rqst->rq_ntrans;1140 __entry->timeout = task->tk_timeout;1141 __assign_str(progname);1142 __entry->version = task->tk_client->cl_vers;1143 __assign_str(procname);1144 ),1145 1146 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER1147 " xid=0x%08x %sv%d %s ntrans=%d timeout=%lu",1148 __entry->task_id, __entry->client_id, __entry->xid,1149 __get_str(progname), __entry->version, __get_str(procname),1150 __entry->ntrans, __entry->timeout1151 )1152);1153 1154TRACE_EVENT(xprt_ping,1155 TP_PROTO(const struct rpc_xprt *xprt, int status),1156 1157 TP_ARGS(xprt, status),1158 1159 TP_STRUCT__entry(1160 __field(int, status)1161 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])1162 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])1163 ),1164 1165 TP_fast_assign(1166 __entry->status = status;1167 __assign_str(addr);1168 __assign_str(port);1169 ),1170 1171 TP_printk("peer=[%s]:%s status=%d",1172 __get_str(addr), __get_str(port), __entry->status)1173);1174 1175DECLARE_EVENT_CLASS(xprt_writelock_event,1176 TP_PROTO(1177 const struct rpc_xprt *xprt, const struct rpc_task *task1178 ),1179 1180 TP_ARGS(xprt, task),1181 1182 TP_STRUCT__entry(1183 __field(unsigned int, task_id)1184 __field(unsigned int, client_id)1185 __field(unsigned int, snd_task_id)1186 ),1187 1188 TP_fast_assign(1189 if (task) {1190 __entry->task_id = task->tk_pid;1191 __entry->client_id = task->tk_client ?1192 task->tk_client->cl_clid : -1;1193 } else {1194 __entry->task_id = -1;1195 __entry->client_id = -1;1196 }1197 if (xprt->snd_task &&1198 !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))1199 __entry->snd_task_id = xprt->snd_task->tk_pid;1200 else1201 __entry->snd_task_id = -1;1202 ),1203 1204 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER1205 " snd_task:" SUNRPC_TRACE_PID_SPECIFIER,1206 __entry->task_id, __entry->client_id,1207 __entry->snd_task_id)1208);1209 1210#define DEFINE_WRITELOCK_EVENT(name) \1211 DEFINE_EVENT(xprt_writelock_event, xprt_##name, \1212 TP_PROTO( \1213 const struct rpc_xprt *xprt, \1214 const struct rpc_task *task \1215 ), \1216 TP_ARGS(xprt, task))1217 1218DEFINE_WRITELOCK_EVENT(reserve_xprt);1219DEFINE_WRITELOCK_EVENT(release_xprt);1220 1221DECLARE_EVENT_CLASS(xprt_cong_event,1222 TP_PROTO(1223 const struct rpc_xprt *xprt, const struct rpc_task *task1224 ),1225 1226 TP_ARGS(xprt, task),1227 1228 TP_STRUCT__entry(1229 __field(unsigned int, task_id)1230 __field(unsigned int, client_id)1231 __field(unsigned int, snd_task_id)1232 __field(unsigned long, cong)1233 __field(unsigned long, cwnd)1234 __field(bool, wait)1235 ),1236 1237 TP_fast_assign(1238 if (task) {1239 __entry->task_id = task->tk_pid;1240 __entry->client_id = task->tk_client ?1241 task->tk_client->cl_clid : -1;1242 } else {1243 __entry->task_id = -1;1244 __entry->client_id = -1;1245 }1246 if (xprt->snd_task &&1247 !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))1248 __entry->snd_task_id = xprt->snd_task->tk_pid;1249 else1250 __entry->snd_task_id = -1;1251 1252 __entry->cong = xprt->cong;1253 __entry->cwnd = xprt->cwnd;1254 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);1255 ),1256 1257 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER1258 " snd_task:" SUNRPC_TRACE_PID_SPECIFIER1259 " cong=%lu cwnd=%lu%s",1260 __entry->task_id, __entry->client_id,1261 __entry->snd_task_id, __entry->cong, __entry->cwnd,1262 __entry->wait ? " (wait)" : "")1263);1264 1265#define DEFINE_CONG_EVENT(name) \1266 DEFINE_EVENT(xprt_cong_event, xprt_##name, \1267 TP_PROTO( \1268 const struct rpc_xprt *xprt, \1269 const struct rpc_task *task \1270 ), \1271 TP_ARGS(xprt, task))1272 1273DEFINE_CONG_EVENT(reserve_cong);1274DEFINE_CONG_EVENT(release_cong);1275DEFINE_CONG_EVENT(get_cong);1276DEFINE_CONG_EVENT(put_cong);1277 1278TRACE_EVENT(xprt_reserve,1279 TP_PROTO(1280 const struct rpc_rqst *rqst1281 ),1282 1283 TP_ARGS(rqst),1284 1285 TP_STRUCT__entry(1286 __field(unsigned int, task_id)1287 __field(unsigned int, client_id)1288 __field(u32, xid)1289 ),1290 1291 TP_fast_assign(1292 __entry->task_id = rqst->rq_task->tk_pid;1293 __entry->client_id = rqst->rq_task->tk_client->cl_clid;1294 __entry->xid = be32_to_cpu(rqst->rq_xid);1295 ),1296 1297 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x",1298 __entry->task_id, __entry->client_id, __entry->xid1299 )1300);1301 1302TRACE_EVENT(xs_data_ready,1303 TP_PROTO(1304 const struct rpc_xprt *xprt1305 ),1306 1307 TP_ARGS(xprt),1308 1309 TP_STRUCT__entry(1310 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])1311 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])1312 ),1313 1314 TP_fast_assign(1315 __assign_str(addr);1316 __assign_str(port);1317 ),1318 1319 TP_printk("peer=[%s]:%s", __get_str(addr), __get_str(port))1320);1321 1322TRACE_EVENT(xs_stream_read_data,1323 TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),1324 1325 TP_ARGS(xprt, err, total),1326 1327 TP_STRUCT__entry(1328 __field(ssize_t, err)1329 __field(size_t, total)1330 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :1331 EVENT_NULL_STR)1332 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :1333 EVENT_NULL_STR)1334 ),1335 1336 TP_fast_assign(1337 __entry->err = err;1338 __entry->total = total;1339 __assign_str(addr);1340 __assign_str(port);1341 ),1342 1343 TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),1344 __get_str(port), __entry->err, __entry->total)1345);1346 1347TRACE_EVENT(xs_stream_read_request,1348 TP_PROTO(struct sock_xprt *xs),1349 1350 TP_ARGS(xs),1351 1352 TP_STRUCT__entry(1353 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])1354 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])1355 __field(u32, xid)1356 __field(unsigned long, copied)1357 __field(unsigned int, reclen)1358 __field(unsigned int, offset)1359 ),1360 1361 TP_fast_assign(1362 __assign_str(addr);1363 __assign_str(port);1364 __entry->xid = be32_to_cpu(xs->recv.xid);1365 __entry->copied = xs->recv.copied;1366 __entry->reclen = xs->recv.len;1367 __entry->offset = xs->recv.offset;1368 ),1369 1370 TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",1371 __get_str(addr), __get_str(port), __entry->xid,1372 __entry->copied, __entry->reclen, __entry->offset)1373);1374 1375TRACE_EVENT(rpcb_getport,1376 TP_PROTO(1377 const struct rpc_clnt *clnt,1378 const struct rpc_task *task,1379 unsigned int bind_version1380 ),1381 1382 TP_ARGS(clnt, task, bind_version),1383 1384 TP_STRUCT__entry(1385 __field(unsigned int, task_id)1386 __field(unsigned int, client_id)1387 __field(unsigned int, program)1388 __field(unsigned int, version)1389 __field(int, protocol)1390 __field(unsigned int, bind_version)1391 __string(servername, task->tk_xprt->servername)1392 ),1393 1394 TP_fast_assign(1395 __entry->task_id = task->tk_pid;1396 __entry->client_id = clnt->cl_clid;1397 __entry->program = clnt->cl_prog;1398 __entry->version = clnt->cl_vers;1399 __entry->protocol = task->tk_xprt->prot;1400 __entry->bind_version = bind_version;1401 __assign_str(servername);1402 ),1403 1404 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER1405 " server=%s program=%u version=%u protocol=%d bind_version=%u",1406 __entry->task_id, __entry->client_id, __get_str(servername),1407 __entry->program, __entry->version, __entry->protocol,1408 __entry->bind_version1409 )1410);1411 1412TRACE_EVENT(rpcb_setport,1413 TP_PROTO(1414 const struct rpc_task *task,1415 int status,1416 unsigned short port1417 ),1418 1419 TP_ARGS(task, status, port),1420 1421 TP_STRUCT__entry(1422 __field(unsigned int, task_id)1423 __field(unsigned int, client_id)1424 __field(int, status)1425 __field(unsigned short, port)1426 ),1427 1428 TP_fast_assign(1429 __entry->task_id = task->tk_pid;1430 __entry->client_id = task->tk_client->cl_clid;1431 __entry->status = status;1432 __entry->port = port;1433 ),1434 1435 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d port=%u",1436 __entry->task_id, __entry->client_id,1437 __entry->status, __entry->port1438 )1439);1440 1441TRACE_EVENT(pmap_register,1442 TP_PROTO(1443 u32 program,1444 u32 version,1445 int protocol,1446 unsigned short port1447 ),1448 1449 TP_ARGS(program, version, protocol, port),1450 1451 TP_STRUCT__entry(1452 __field(unsigned int, program)1453 __field(unsigned int, version)1454 __field(int, protocol)1455 __field(unsigned int, port)1456 ),1457 1458 TP_fast_assign(1459 __entry->program = program;1460 __entry->version = version;1461 __entry->protocol = protocol;1462 __entry->port = port;1463 ),1464 1465 TP_printk("program=%u version=%u protocol=%d port=%u",1466 __entry->program, __entry->version,1467 __entry->protocol, __entry->port1468 )1469);1470 1471TRACE_EVENT(rpcb_register,1472 TP_PROTO(1473 u32 program,1474 u32 version,1475 const char *addr,1476 const char *netid1477 ),1478 1479 TP_ARGS(program, version, addr, netid),1480 1481 TP_STRUCT__entry(1482 __field(unsigned int, program)1483 __field(unsigned int, version)1484 __string(addr, addr)1485 __string(netid, netid)1486 ),1487 1488 TP_fast_assign(1489 __entry->program = program;1490 __entry->version = version;1491 __assign_str(addr);1492 __assign_str(netid);1493 ),1494 1495 TP_printk("program=%u version=%u addr=%s netid=%s",1496 __entry->program, __entry->version,1497 __get_str(addr), __get_str(netid)1498 )1499);1500 1501TRACE_EVENT(rpcb_unregister,1502 TP_PROTO(1503 u32 program,1504 u32 version,1505 const char *netid1506 ),1507 1508 TP_ARGS(program, version, netid),1509 1510 TP_STRUCT__entry(1511 __field(unsigned int, program)1512 __field(unsigned int, version)1513 __string(netid, netid)1514 ),1515 1516 TP_fast_assign(1517 __entry->program = program;1518 __entry->version = version;1519 __assign_str(netid);1520 ),1521 1522 TP_printk("program=%u version=%u netid=%s",1523 __entry->program, __entry->version, __get_str(netid)1524 )1525);1526 1527/**1528 ** RPC-over-TLS tracepoints1529 **/1530 1531DECLARE_EVENT_CLASS(rpc_tls_class,1532 TP_PROTO(1533 const struct rpc_clnt *clnt,1534 const struct rpc_xprt *xprt1535 ),1536 1537 TP_ARGS(clnt, xprt),1538 1539 TP_STRUCT__entry(1540 __field(unsigned long, requested_policy)1541 __field(u32, version)1542 __string(servername, xprt->servername)1543 __string(progname, clnt->cl_program->name)1544 ),1545 1546 TP_fast_assign(1547 __entry->requested_policy = clnt->cl_xprtsec.policy;1548 __entry->version = clnt->cl_vers;1549 __assign_str(servername);1550 __assign_str(progname);1551 ),1552 1553 TP_printk("server=%s %sv%u requested_policy=%s",1554 __get_str(servername), __get_str(progname), __entry->version,1555 rpc_show_xprtsec_policy(__entry->requested_policy)1556 )1557);1558 1559#define DEFINE_RPC_TLS_EVENT(name) \1560 DEFINE_EVENT(rpc_tls_class, rpc_tls_##name, \1561 TP_PROTO( \1562 const struct rpc_clnt *clnt, \1563 const struct rpc_xprt *xprt \1564 ), \1565 TP_ARGS(clnt, xprt))1566 1567DEFINE_RPC_TLS_EVENT(unavailable);1568DEFINE_RPC_TLS_EVENT(not_started);1569 1570 1571/* Record an xdr_buf containing a fully-formed RPC message */1572DECLARE_EVENT_CLASS(svc_xdr_msg_class,1573 TP_PROTO(1574 const struct xdr_buf *xdr1575 ),1576 1577 TP_ARGS(xdr),1578 1579 TP_STRUCT__entry(1580 __field(u32, xid)1581 __field(const void *, head_base)1582 __field(size_t, head_len)1583 __field(const void *, tail_base)1584 __field(size_t, tail_len)1585 __field(unsigned int, page_len)1586 __field(unsigned int, msg_len)1587 ),1588 1589 TP_fast_assign(1590 __be32 *p = (__be32 *)xdr->head[0].iov_base;1591 1592 __entry->xid = be32_to_cpu(*p);1593 __entry->head_base = p;1594 __entry->head_len = xdr->head[0].iov_len;1595 __entry->tail_base = xdr->tail[0].iov_base;1596 __entry->tail_len = xdr->tail[0].iov_len;1597 __entry->page_len = xdr->page_len;1598 __entry->msg_len = xdr->len;1599 ),1600 1601 TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",1602 __entry->xid,1603 __entry->head_base, __entry->head_len, __entry->page_len,1604 __entry->tail_base, __entry->tail_len, __entry->msg_len1605 )1606);1607 1608#define DEFINE_SVCXDRMSG_EVENT(name) \1609 DEFINE_EVENT(svc_xdr_msg_class, \1610 svc_xdr_##name, \1611 TP_PROTO( \1612 const struct xdr_buf *xdr \1613 ), \1614 TP_ARGS(xdr))1615 1616DEFINE_SVCXDRMSG_EVENT(recvfrom);1617 1618/* Record an xdr_buf containing arbitrary data, tagged with an XID */1619DECLARE_EVENT_CLASS(svc_xdr_buf_class,1620 TP_PROTO(1621 __be32 xid,1622 const struct xdr_buf *xdr1623 ),1624 1625 TP_ARGS(xid, xdr),1626 1627 TP_STRUCT__entry(1628 __field(u32, xid)1629 __field(const void *, head_base)1630 __field(size_t, head_len)1631 __field(const void *, tail_base)1632 __field(size_t, tail_len)1633 __field(unsigned int, page_base)1634 __field(unsigned int, page_len)1635 __field(unsigned int, msg_len)1636 ),1637 1638 TP_fast_assign(1639 __entry->xid = be32_to_cpu(xid);1640 __entry->head_base = xdr->head[0].iov_base;1641 __entry->head_len = xdr->head[0].iov_len;1642 __entry->tail_base = xdr->tail[0].iov_base;1643 __entry->tail_len = xdr->tail[0].iov_len;1644 __entry->page_base = xdr->page_base;1645 __entry->page_len = xdr->page_len;1646 __entry->msg_len = xdr->len;1647 ),1648 1649 TP_printk("xid=0x%08x head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",1650 __entry->xid,1651 __entry->head_base, __entry->head_len,1652 __entry->page_len, __entry->page_base,1653 __entry->tail_base, __entry->tail_len,1654 __entry->msg_len1655 )1656);1657 1658#define DEFINE_SVCXDRBUF_EVENT(name) \1659 DEFINE_EVENT(svc_xdr_buf_class, \1660 svc_xdr_##name, \1661 TP_PROTO( \1662 __be32 xid, \1663 const struct xdr_buf *xdr \1664 ), \1665 TP_ARGS(xid, xdr))1666 1667DEFINE_SVCXDRBUF_EVENT(sendto);1668 1669/*1670 * from include/linux/sunrpc/svc.h1671 */1672#define SVC_RQST_FLAG_LIST \1673 svc_rqst_flag(SECURE) \1674 svc_rqst_flag(LOCAL) \1675 svc_rqst_flag(USEDEFERRAL) \1676 svc_rqst_flag(DROPME) \1677 svc_rqst_flag(VICTIM) \1678 svc_rqst_flag_end(DATA)1679 1680#undef svc_rqst_flag1681#undef svc_rqst_flag_end1682#define svc_rqst_flag(x) TRACE_DEFINE_ENUM(RQ_##x);1683#define svc_rqst_flag_end(x) TRACE_DEFINE_ENUM(RQ_##x);1684 1685SVC_RQST_FLAG_LIST1686 1687#undef svc_rqst_flag1688#undef svc_rqst_flag_end1689#define svc_rqst_flag(x) { BIT(RQ_##x), #x },1690#define svc_rqst_flag_end(x) { BIT(RQ_##x), #x }1691 1692#define show_rqstp_flags(flags) \1693 __print_flags(flags, "|", SVC_RQST_FLAG_LIST)1694 1695TRACE_DEFINE_ENUM(SVC_GARBAGE);1696TRACE_DEFINE_ENUM(SVC_SYSERR);1697TRACE_DEFINE_ENUM(SVC_VALID);1698TRACE_DEFINE_ENUM(SVC_NEGATIVE);1699TRACE_DEFINE_ENUM(SVC_OK);1700TRACE_DEFINE_ENUM(SVC_DROP);1701TRACE_DEFINE_ENUM(SVC_CLOSE);1702TRACE_DEFINE_ENUM(SVC_DENIED);1703TRACE_DEFINE_ENUM(SVC_PENDING);1704TRACE_DEFINE_ENUM(SVC_COMPLETE);1705 1706#define show_svc_auth_status(status) \1707 __print_symbolic(status, \1708 { SVC_GARBAGE, "SVC_GARBAGE" }, \1709 { SVC_SYSERR, "SVC_SYSERR" }, \1710 { SVC_VALID, "SVC_VALID" }, \1711 { SVC_NEGATIVE, "SVC_NEGATIVE" }, \1712 { SVC_OK, "SVC_OK" }, \1713 { SVC_DROP, "SVC_DROP" }, \1714 { SVC_CLOSE, "SVC_CLOSE" }, \1715 { SVC_DENIED, "SVC_DENIED" }, \1716 { SVC_PENDING, "SVC_PENDING" }, \1717 { SVC_COMPLETE, "SVC_COMPLETE" })1718 1719#define SVC_RQST_ENDPOINT_FIELDS(r) \1720 __sockaddr(server, (r)->rq_xprt->xpt_locallen) \1721 __sockaddr(client, (r)->rq_xprt->xpt_remotelen) \1722 __field(unsigned int, netns_ino) \1723 __field(u32, xid)1724 1725#define SVC_RQST_ENDPOINT_ASSIGNMENTS(r) \1726 do { \1727 struct svc_xprt *xprt = (r)->rq_xprt; \1728 __assign_sockaddr(server, &xprt->xpt_local, \1729 xprt->xpt_locallen); \1730 __assign_sockaddr(client, &xprt->xpt_remote, \1731 xprt->xpt_remotelen); \1732 __entry->netns_ino = xprt->xpt_net->ns.inum; \1733 __entry->xid = be32_to_cpu((r)->rq_xid); \1734 } while (0)1735 1736#define SVC_RQST_ENDPOINT_FORMAT \1737 "xid=0x%08x server=%pISpc client=%pISpc"1738 1739#define SVC_RQST_ENDPOINT_VARARGS \1740 __entry->xid, __get_sockaddr(server), __get_sockaddr(client)1741 1742TRACE_EVENT_CONDITION(svc_authenticate,1743 TP_PROTO(1744 const struct svc_rqst *rqst,1745 enum svc_auth_status auth_res1746 ),1747 1748 TP_ARGS(rqst, auth_res),1749 1750 TP_CONDITION(auth_res != SVC_OK && auth_res != SVC_COMPLETE),1751 1752 TP_STRUCT__entry(1753 SVC_RQST_ENDPOINT_FIELDS(rqst)1754 1755 __field(unsigned long, svc_status)1756 __field(unsigned long, auth_stat)1757 ),1758 1759 TP_fast_assign(1760 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);1761 1762 __entry->svc_status = auth_res;1763 __entry->auth_stat = be32_to_cpu(rqst->rq_auth_stat);1764 ),1765 1766 TP_printk(SVC_RQST_ENDPOINT_FORMAT1767 " auth_res=%s auth_stat=%s",1768 SVC_RQST_ENDPOINT_VARARGS,1769 show_svc_auth_status(__entry->svc_status),1770 rpc_show_auth_stat(__entry->auth_stat))1771);1772 1773TRACE_EVENT(svc_process,1774 TP_PROTO(const struct svc_rqst *rqst, const char *name),1775 1776 TP_ARGS(rqst, name),1777 1778 TP_STRUCT__entry(1779 __field(u32, xid)1780 __field(u32, vers)1781 __field(u32, proc)1782 __string(service, name)1783 __string(procedure, svc_proc_name(rqst))1784 __string(addr, rqst->rq_xprt ?1785 rqst->rq_xprt->xpt_remotebuf : EVENT_NULL_STR)1786 ),1787 1788 TP_fast_assign(1789 __entry->xid = be32_to_cpu(rqst->rq_xid);1790 __entry->vers = rqst->rq_vers;1791 __entry->proc = rqst->rq_proc;1792 __assign_str(service);1793 __assign_str(procedure);1794 __assign_str(addr);1795 ),1796 1797 TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%s",1798 __get_str(addr), __entry->xid,1799 __get_str(service), __entry->vers,1800 __get_str(procedure)1801 )1802);1803 1804DECLARE_EVENT_CLASS(svc_rqst_event,1805 TP_PROTO(1806 const struct svc_rqst *rqst1807 ),1808 1809 TP_ARGS(rqst),1810 1811 TP_STRUCT__entry(1812 SVC_RQST_ENDPOINT_FIELDS(rqst)1813 1814 __field(unsigned long, flags)1815 ),1816 1817 TP_fast_assign(1818 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);1819 1820 __entry->flags = rqst->rq_flags;1821 ),1822 1823 TP_printk(SVC_RQST_ENDPOINT_FORMAT " flags=%s",1824 SVC_RQST_ENDPOINT_VARARGS,1825 show_rqstp_flags(__entry->flags))1826);1827#define DEFINE_SVC_RQST_EVENT(name) \1828 DEFINE_EVENT(svc_rqst_event, svc_##name, \1829 TP_PROTO( \1830 const struct svc_rqst *rqst \1831 ), \1832 TP_ARGS(rqst))1833 1834DEFINE_SVC_RQST_EVENT(defer);1835DEFINE_SVC_RQST_EVENT(drop);1836 1837DECLARE_EVENT_CLASS(svc_rqst_status,1838 TP_PROTO(1839 const struct svc_rqst *rqst,1840 int status1841 ),1842 1843 TP_ARGS(rqst, status),1844 1845 TP_STRUCT__entry(1846 SVC_RQST_ENDPOINT_FIELDS(rqst)1847 1848 __field(int, status)1849 __field(unsigned long, flags)1850 ),1851 1852 TP_fast_assign(1853 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);1854 1855 __entry->status = status;1856 __entry->flags = rqst->rq_flags;1857 ),1858 1859 TP_printk(SVC_RQST_ENDPOINT_FORMAT " status=%d flags=%s",1860 SVC_RQST_ENDPOINT_VARARGS,1861 __entry->status, show_rqstp_flags(__entry->flags))1862);1863 1864DEFINE_EVENT(svc_rqst_status, svc_send,1865 TP_PROTO(const struct svc_rqst *rqst, int status),1866 TP_ARGS(rqst, status));1867 1868TRACE_EVENT(svc_replace_page_err,1869 TP_PROTO(const struct svc_rqst *rqst),1870 1871 TP_ARGS(rqst),1872 TP_STRUCT__entry(1873 SVC_RQST_ENDPOINT_FIELDS(rqst)1874 1875 __field(const void *, begin)1876 __field(const void *, respages)1877 __field(const void *, nextpage)1878 ),1879 1880 TP_fast_assign(1881 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);1882 1883 __entry->begin = rqst->rq_pages;1884 __entry->respages = rqst->rq_respages;1885 __entry->nextpage = rqst->rq_next_page;1886 ),1887 1888 TP_printk(SVC_RQST_ENDPOINT_FORMAT " begin=%p respages=%p nextpage=%p",1889 SVC_RQST_ENDPOINT_VARARGS,1890 __entry->begin, __entry->respages, __entry->nextpage)1891);1892 1893TRACE_EVENT(svc_stats_latency,1894 TP_PROTO(1895 const struct svc_rqst *rqst1896 ),1897 1898 TP_ARGS(rqst),1899 1900 TP_STRUCT__entry(1901 SVC_RQST_ENDPOINT_FIELDS(rqst)1902 1903 __field(unsigned long, execute)1904 __string(procedure, svc_proc_name(rqst))1905 ),1906 1907 TP_fast_assign(1908 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);1909 1910 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),1911 rqst->rq_stime));1912 __assign_str(procedure);1913 ),1914 1915 TP_printk(SVC_RQST_ENDPOINT_FORMAT " proc=%s execute-us=%lu",1916 SVC_RQST_ENDPOINT_VARARGS,1917 __get_str(procedure), __entry->execute)1918);1919 1920/*1921 * from include/linux/sunrpc/svc_xprt.h1922 */1923#define SVC_XPRT_FLAG_LIST \1924 svc_xprt_flag(BUSY) \1925 svc_xprt_flag(CONN) \1926 svc_xprt_flag(CLOSE) \1927 svc_xprt_flag(DATA) \1928 svc_xprt_flag(TEMP) \1929 svc_xprt_flag(DEAD) \1930 svc_xprt_flag(CHNGBUF) \1931 svc_xprt_flag(DEFERRED) \1932 svc_xprt_flag(OLD) \1933 svc_xprt_flag(LISTENER) \1934 svc_xprt_flag(CACHE_AUTH) \1935 svc_xprt_flag(LOCAL) \1936 svc_xprt_flag(KILL_TEMP) \1937 svc_xprt_flag(CONG_CTRL) \1938 svc_xprt_flag(HANDSHAKE) \1939 svc_xprt_flag(TLS_SESSION) \1940 svc_xprt_flag_end(PEER_AUTH)1941 1942#undef svc_xprt_flag1943#undef svc_xprt_flag_end1944#define svc_xprt_flag(x) TRACE_DEFINE_ENUM(XPT_##x);1945#define svc_xprt_flag_end(x) TRACE_DEFINE_ENUM(XPT_##x);1946 1947SVC_XPRT_FLAG_LIST1948 1949#undef svc_xprt_flag1950#undef svc_xprt_flag_end1951#define svc_xprt_flag(x) { BIT(XPT_##x), #x },1952#define svc_xprt_flag_end(x) { BIT(XPT_##x), #x }1953 1954#define show_svc_xprt_flags(flags) \1955 __print_flags(flags, "|", SVC_XPRT_FLAG_LIST)1956 1957TRACE_EVENT(svc_xprt_create_err,1958 TP_PROTO(1959 const char *program,1960 const char *protocol,1961 struct sockaddr *sap,1962 size_t salen,1963 const struct svc_xprt *xprt1964 ),1965 1966 TP_ARGS(program, protocol, sap, salen, xprt),1967 1968 TP_STRUCT__entry(1969 __field(long, error)1970 __string(program, program)1971 __string(protocol, protocol)1972 __sockaddr(addr, salen)1973 ),1974 1975 TP_fast_assign(1976 __entry->error = PTR_ERR(xprt);1977 __assign_str(program);1978 __assign_str(protocol);1979 __assign_sockaddr(addr, sap, salen);1980 ),1981 1982 TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",1983 __get_sockaddr(addr), __get_str(program), __get_str(protocol),1984 __entry->error)1985);1986 1987#define SVC_XPRT_ENDPOINT_FIELDS(x) \1988 __sockaddr(server, (x)->xpt_locallen) \1989 __sockaddr(client, (x)->xpt_remotelen) \1990 __field(unsigned long, flags) \1991 __field(unsigned int, netns_ino)1992 1993#define SVC_XPRT_ENDPOINT_ASSIGNMENTS(x) \1994 do { \1995 __assign_sockaddr(server, &(x)->xpt_local, \1996 (x)->xpt_locallen); \1997 __assign_sockaddr(client, &(x)->xpt_remote, \1998 (x)->xpt_remotelen); \1999 __entry->flags = (x)->xpt_flags; \2000 __entry->netns_ino = (x)->xpt_net->ns.inum; \2001 } while (0)2002 2003#define SVC_XPRT_ENDPOINT_FORMAT \2004 "server=%pISpc client=%pISpc flags=%s"2005 2006#define SVC_XPRT_ENDPOINT_VARARGS \2007 __get_sockaddr(server), __get_sockaddr(client), \2008 show_svc_xprt_flags(__entry->flags)2009 2010TRACE_EVENT(svc_xprt_enqueue,2011 TP_PROTO(2012 const struct svc_xprt *xprt,2013 unsigned long flags2014 ),2015 2016 TP_ARGS(xprt, flags),2017 2018 TP_STRUCT__entry(2019 SVC_XPRT_ENDPOINT_FIELDS(xprt)2020 ),2021 2022 TP_fast_assign(2023 __assign_sockaddr(server, &xprt->xpt_local,2024 xprt->xpt_locallen);2025 __assign_sockaddr(client, &xprt->xpt_remote,2026 xprt->xpt_remotelen);2027 __entry->flags = flags;2028 __entry->netns_ino = xprt->xpt_net->ns.inum;2029 ),2030 2031 TP_printk(SVC_XPRT_ENDPOINT_FORMAT, SVC_XPRT_ENDPOINT_VARARGS)2032);2033 2034TRACE_EVENT(svc_xprt_dequeue,2035 TP_PROTO(2036 const struct svc_rqst *rqst2037 ),2038 2039 TP_ARGS(rqst),2040 2041 TP_STRUCT__entry(2042 SVC_XPRT_ENDPOINT_FIELDS(rqst->rq_xprt)2043 2044 __field(unsigned long, wakeup)2045 ),2046 2047 TP_fast_assign(2048 SVC_XPRT_ENDPOINT_ASSIGNMENTS(rqst->rq_xprt);2049 2050 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),2051 rqst->rq_qtime));2052 ),2053 2054 TP_printk(SVC_XPRT_ENDPOINT_FORMAT " wakeup-us=%lu",2055 SVC_XPRT_ENDPOINT_VARARGS, __entry->wakeup)2056);2057 2058DECLARE_EVENT_CLASS(svc_xprt_event,2059 TP_PROTO(2060 const struct svc_xprt *xprt2061 ),2062 2063 TP_ARGS(xprt),2064 2065 TP_STRUCT__entry(2066 SVC_XPRT_ENDPOINT_FIELDS(xprt)2067 ),2068 2069 TP_fast_assign(2070 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);2071 ),2072 2073 TP_printk(SVC_XPRT_ENDPOINT_FORMAT, SVC_XPRT_ENDPOINT_VARARGS)2074);2075 2076#define DEFINE_SVC_XPRT_EVENT(name) \2077 DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \2078 TP_PROTO( \2079 const struct svc_xprt *xprt \2080 ), \2081 TP_ARGS(xprt))2082 2083DEFINE_SVC_XPRT_EVENT(no_write_space);2084DEFINE_SVC_XPRT_EVENT(close);2085DEFINE_SVC_XPRT_EVENT(detach);2086DEFINE_SVC_XPRT_EVENT(free);2087 2088#define DEFINE_SVC_TLS_EVENT(name) \2089 DEFINE_EVENT(svc_xprt_event, svc_tls_##name, \2090 TP_PROTO(const struct svc_xprt *xprt), \2091 TP_ARGS(xprt))2092 2093DEFINE_SVC_TLS_EVENT(start);2094DEFINE_SVC_TLS_EVENT(upcall);2095DEFINE_SVC_TLS_EVENT(unavailable);2096DEFINE_SVC_TLS_EVENT(not_started);2097DEFINE_SVC_TLS_EVENT(timed_out);2098 2099TRACE_EVENT(svc_xprt_accept,2100 TP_PROTO(2101 const struct svc_xprt *xprt,2102 const char *service2103 ),2104 2105 TP_ARGS(xprt, service),2106 2107 TP_STRUCT__entry(2108 SVC_XPRT_ENDPOINT_FIELDS(xprt)2109 2110 __string(protocol, xprt->xpt_class->xcl_name)2111 __string(service, service)2112 ),2113 2114 TP_fast_assign(2115 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);2116 2117 __assign_str(protocol);2118 __assign_str(service);2119 ),2120 2121 TP_printk(SVC_XPRT_ENDPOINT_FORMAT " protocol=%s service=%s",2122 SVC_XPRT_ENDPOINT_VARARGS,2123 __get_str(protocol), __get_str(service)2124 )2125);2126 2127TRACE_EVENT(svc_wake_up,2128 TP_PROTO(int pid),2129 2130 TP_ARGS(pid),2131 2132 TP_STRUCT__entry(2133 __field(int, pid)2134 ),2135 2136 TP_fast_assign(2137 __entry->pid = pid;2138 ),2139 2140 TP_printk("pid=%d", __entry->pid)2141);2142 2143TRACE_EVENT(svc_alloc_arg_err,2144 TP_PROTO(2145 unsigned int requested,2146 unsigned int allocated2147 ),2148 2149 TP_ARGS(requested, allocated),2150 2151 TP_STRUCT__entry(2152 __field(unsigned int, requested)2153 __field(unsigned int, allocated)2154 ),2155 2156 TP_fast_assign(2157 __entry->requested = requested;2158 __entry->allocated = allocated;2159 ),2160 2161 TP_printk("requested=%u allocated=%u",2162 __entry->requested, __entry->allocated)2163);2164 2165DECLARE_EVENT_CLASS(svc_deferred_event,2166 TP_PROTO(2167 const struct svc_deferred_req *dr2168 ),2169 2170 TP_ARGS(dr),2171 2172 TP_STRUCT__entry(2173 __field(const void *, dr)2174 __field(u32, xid)2175 __sockaddr(addr, dr->addrlen)2176 ),2177 2178 TP_fast_assign(2179 __entry->dr = dr;2180 __entry->xid = be32_to_cpu(*(__be32 *)dr->args);2181 __assign_sockaddr(addr, &dr->addr, dr->addrlen);2182 ),2183 2184 TP_printk("addr=%pISpc dr=%p xid=0x%08x", __get_sockaddr(addr),2185 __entry->dr, __entry->xid)2186);2187 2188#define DEFINE_SVC_DEFERRED_EVENT(name) \2189 DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \2190 TP_PROTO( \2191 const struct svc_deferred_req *dr \2192 ), \2193 TP_ARGS(dr))2194 2195DEFINE_SVC_DEFERRED_EVENT(drop);2196DEFINE_SVC_DEFERRED_EVENT(queue);2197DEFINE_SVC_DEFERRED_EVENT(recv);2198 2199DECLARE_EVENT_CLASS(svcsock_lifetime_class,2200 TP_PROTO(2201 const void *svsk,2202 const struct socket *socket2203 ),2204 TP_ARGS(svsk, socket),2205 TP_STRUCT__entry(2206 __field(unsigned int, netns_ino)2207 __field(const void *, svsk)2208 __field(const void *, sk)2209 __field(unsigned long, type)2210 __field(unsigned long, family)2211 __field(unsigned long, state)2212 ),2213 TP_fast_assign(2214 struct sock *sk = socket->sk;2215 2216 __entry->netns_ino = sock_net(sk)->ns.inum;2217 __entry->svsk = svsk;2218 __entry->sk = sk;2219 __entry->type = socket->type;2220 __entry->family = sk->sk_family;2221 __entry->state = sk->sk_state;2222 ),2223 TP_printk("svsk=%p type=%s family=%s%s",2224 __entry->svsk, show_socket_type(__entry->type),2225 rpc_show_address_family(__entry->family),2226 __entry->state == TCP_LISTEN ? " (listener)" : ""2227 )2228);2229#define DEFINE_SVCSOCK_LIFETIME_EVENT(name) \2230 DEFINE_EVENT(svcsock_lifetime_class, name, \2231 TP_PROTO( \2232 const void *svsk, \2233 const struct socket *socket \2234 ), \2235 TP_ARGS(svsk, socket))2236 2237DEFINE_SVCSOCK_LIFETIME_EVENT(svcsock_new);2238DEFINE_SVCSOCK_LIFETIME_EVENT(svcsock_free);2239 2240TRACE_EVENT(svcsock_marker,2241 TP_PROTO(2242 const struct svc_xprt *xprt,2243 __be32 marker2244 ),2245 2246 TP_ARGS(xprt, marker),2247 2248 TP_STRUCT__entry(2249 __field(unsigned int, length)2250 __field(bool, last)2251 __string(addr, xprt->xpt_remotebuf)2252 ),2253 2254 TP_fast_assign(2255 __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;2256 __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;2257 __assign_str(addr);2258 ),2259 2260 TP_printk("addr=%s length=%u%s", __get_str(addr),2261 __entry->length, __entry->last ? " (last)" : "")2262);2263 2264DECLARE_EVENT_CLASS(svcsock_class,2265 TP_PROTO(2266 const struct svc_xprt *xprt,2267 ssize_t result2268 ),2269 2270 TP_ARGS(xprt, result),2271 2272 TP_STRUCT__entry(2273 __field(ssize_t, result)2274 __field(unsigned long, flags)2275 __string(addr, xprt->xpt_remotebuf)2276 ),2277 2278 TP_fast_assign(2279 __entry->result = result;2280 __entry->flags = xprt->xpt_flags;2281 __assign_str(addr);2282 ),2283 2284 TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),2285 __entry->result, show_svc_xprt_flags(__entry->flags)2286 )2287);2288 2289#define DEFINE_SVCSOCK_EVENT(name) \2290 DEFINE_EVENT(svcsock_class, svcsock_##name, \2291 TP_PROTO( \2292 const struct svc_xprt *xprt, \2293 ssize_t result \2294 ), \2295 TP_ARGS(xprt, result))2296 2297DEFINE_SVCSOCK_EVENT(udp_send);2298DEFINE_SVCSOCK_EVENT(udp_recv);2299DEFINE_SVCSOCK_EVENT(udp_recv_err);2300DEFINE_SVCSOCK_EVENT(tcp_send);2301DEFINE_SVCSOCK_EVENT(tcp_recv);2302DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);2303DEFINE_SVCSOCK_EVENT(tcp_recv_err);2304DEFINE_SVCSOCK_EVENT(data_ready);2305DEFINE_SVCSOCK_EVENT(write_space);2306 2307TRACE_EVENT(svcsock_tcp_recv_short,2308 TP_PROTO(2309 const struct svc_xprt *xprt,2310 u32 expected,2311 u32 received2312 ),2313 2314 TP_ARGS(xprt, expected, received),2315 2316 TP_STRUCT__entry(2317 __field(u32, expected)2318 __field(u32, received)2319 __field(unsigned long, flags)2320 __string(addr, xprt->xpt_remotebuf)2321 ),2322 2323 TP_fast_assign(2324 __entry->expected = expected;2325 __entry->received = received;2326 __entry->flags = xprt->xpt_flags;2327 __assign_str(addr);2328 ),2329 2330 TP_printk("addr=%s flags=%s expected=%u received=%u",2331 __get_str(addr), show_svc_xprt_flags(__entry->flags),2332 __entry->expected, __entry->received2333 )2334);2335 2336TRACE_EVENT(svcsock_tcp_state,2337 TP_PROTO(2338 const struct svc_xprt *xprt,2339 const struct socket *socket2340 ),2341 2342 TP_ARGS(xprt, socket),2343 2344 TP_STRUCT__entry(2345 __field(unsigned long, socket_state)2346 __field(unsigned long, sock_state)2347 __field(unsigned long, flags)2348 __string(addr, xprt->xpt_remotebuf)2349 ),2350 2351 TP_fast_assign(2352 __entry->socket_state = socket->state;2353 __entry->sock_state = socket->sk->sk_state;2354 __entry->flags = xprt->xpt_flags;2355 __assign_str(addr);2356 ),2357 2358 TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),2359 rpc_show_socket_state(__entry->socket_state),2360 rpc_show_sock_state(__entry->sock_state),2361 show_svc_xprt_flags(__entry->flags)2362 )2363);2364 2365DECLARE_EVENT_CLASS(svcsock_accept_class,2366 TP_PROTO(2367 const struct svc_xprt *xprt,2368 const char *service,2369 long status2370 ),2371 2372 TP_ARGS(xprt, service, status),2373 2374 TP_STRUCT__entry(2375 __field(long, status)2376 __string(service, service)2377 __field(unsigned int, netns_ino)2378 ),2379 2380 TP_fast_assign(2381 __entry->status = status;2382 __assign_str(service);2383 __entry->netns_ino = xprt->xpt_net->ns.inum;2384 ),2385 2386 TP_printk("addr=listener service=%s status=%ld",2387 __get_str(service), __entry->status2388 )2389);2390 2391#define DEFINE_ACCEPT_EVENT(name) \2392 DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \2393 TP_PROTO( \2394 const struct svc_xprt *xprt, \2395 const char *service, \2396 long status \2397 ), \2398 TP_ARGS(xprt, service, status))2399 2400DEFINE_ACCEPT_EVENT(accept);2401DEFINE_ACCEPT_EVENT(getpeername);2402 2403DECLARE_EVENT_CLASS(cache_event,2404 TP_PROTO(2405 const struct cache_detail *cd,2406 const struct cache_head *h2407 ),2408 2409 TP_ARGS(cd, h),2410 2411 TP_STRUCT__entry(2412 __field(const struct cache_head *, h)2413 __string(name, cd->name)2414 ),2415 2416 TP_fast_assign(2417 __entry->h = h;2418 __assign_str(name);2419 ),2420 2421 TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)2422);2423#define DEFINE_CACHE_EVENT(name) \2424 DEFINE_EVENT(cache_event, name, \2425 TP_PROTO( \2426 const struct cache_detail *cd, \2427 const struct cache_head *h \2428 ), \2429 TP_ARGS(cd, h))2430DEFINE_CACHE_EVENT(cache_entry_expired);2431DEFINE_CACHE_EVENT(cache_entry_upcall);2432DEFINE_CACHE_EVENT(cache_entry_update);2433DEFINE_CACHE_EVENT(cache_entry_make_negative);2434DEFINE_CACHE_EVENT(cache_entry_no_listener);2435 2436DECLARE_EVENT_CLASS(register_class,2437 TP_PROTO(2438 const char *program,2439 const u32 version,2440 const int family,2441 const unsigned short protocol,2442 const unsigned short port,2443 int error2444 ),2445 2446 TP_ARGS(program, version, family, protocol, port, error),2447 2448 TP_STRUCT__entry(2449 __field(u32, version)2450 __field(unsigned long, family)2451 __field(unsigned short, protocol)2452 __field(unsigned short, port)2453 __field(int, error)2454 __string(program, program)2455 ),2456 2457 TP_fast_assign(2458 __entry->version = version;2459 __entry->family = family;2460 __entry->protocol = protocol;2461 __entry->port = port;2462 __entry->error = error;2463 __assign_str(program);2464 ),2465 2466 TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",2467 __get_str(program), __entry->version,2468 __entry->protocol == IPPROTO_UDP ? "udp" : "tcp",2469 __entry->port, rpc_show_address_family(__entry->family),2470 __entry->error2471 )2472);2473 2474#define DEFINE_REGISTER_EVENT(name) \2475 DEFINE_EVENT(register_class, svc_##name, \2476 TP_PROTO( \2477 const char *program, \2478 const u32 version, \2479 const int family, \2480 const unsigned short protocol, \2481 const unsigned short port, \2482 int error \2483 ), \2484 TP_ARGS(program, version, family, protocol, \2485 port, error))2486 2487DEFINE_REGISTER_EVENT(register);2488DEFINE_REGISTER_EVENT(noregister);2489 2490TRACE_EVENT(svc_unregister,2491 TP_PROTO(2492 const char *program,2493 const u32 version,2494 int error2495 ),2496 2497 TP_ARGS(program, version, error),2498 2499 TP_STRUCT__entry(2500 __field(u32, version)2501 __field(int, error)2502 __string(program, program)2503 ),2504 2505 TP_fast_assign(2506 __entry->version = version;2507 __entry->error = error;2508 __assign_str(program);2509 ),2510 2511 TP_printk("program=%sv%u error=%d",2512 __get_str(program), __entry->version, __entry->error2513 )2514);2515 2516#endif /* _TRACE_SUNRPC_H */2517 2518#include <trace/define_trace.h>2519