[linux-2.6-block.git] / include / trace / events / sunrpc.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM sunrpc

#if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SUNRPC_H

#include <linux/sunrpc/sched.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/svc.h>
#include <linux/sunrpc/xprtsock.h>
#include <linux/sunrpc/svc_xprt.h>
#include <net/tcp_states.h>
#include <linux/net.h>
#include <linux/tracepoint.h>

DECLARE_EVENT_CLASS(rpc_task_status,

	TP_PROTO(struct rpc_task *task),

	TP_ARGS(task),

	TP_STRUCT__entry(
		__field(unsigned int, task_id)
		__field(unsigned int, client_id)
		__field(int, status)
	),

	TP_fast_assign(
		__entry->task_id = task->tk_pid;
		__entry->client_id = task->tk_client->cl_clid;
		__entry->status = task->tk_status;
	),

	TP_printk("task:%u@%u, status %d",
		__entry->task_id, __entry->client_id,
		__entry->status)
);

DEFINE_EVENT(rpc_task_status, rpc_call_status,
	TP_PROTO(struct rpc_task *task),

	TP_ARGS(task)
);

DEFINE_EVENT(rpc_task_status, rpc_bind_status,
	TP_PROTO(struct rpc_task *task),

	TP_ARGS(task)
);

TRACE_EVENT(rpc_connect_status,
	TP_PROTO(struct rpc_task *task, int status),

	TP_ARGS(task, status),

	TP_STRUCT__entry(
		__field(unsigned int, task_id)
		__field(unsigned int, client_id)
		__field(int, status)
	),

	TP_fast_assign(
		__entry->task_id = task->tk_pid;
		__entry->client_id = task->tk_client->cl_clid;
		__entry->status = status;
	),

	TP_printk("task:%u@%u, status %d",
		__entry->task_id, __entry->client_id,
		__entry->status)
);

DECLARE_EVENT_CLASS(rpc_task_running,

	TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),

	TP_ARGS(clnt, task, action),

	TP_STRUCT__entry(
		__field(unsigned int, task_id)
		__field(unsigned int, client_id)
		__field(const void *, action)
		__field(unsigned long, runstate)
		__field(int, status)
		__field(unsigned short, flags)
		),

	TP_fast_assign(
		__entry->client_id = clnt ? clnt->cl_clid : -1;
		__entry->task_id = task->tk_pid;
		__entry->action = action;
		__entry->runstate = task->tk_runstate;
		__entry->status = task->tk_status;
		__entry->flags = task->tk_flags;
		),

	TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
		__entry->task_id, __entry->client_id,
		__entry->flags,
		__entry->runstate,
		__entry->status,
		__entry->action
		)
);

DEFINE_EVENT(rpc_task_running, rpc_task_begin,

	TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),

	TP_ARGS(clnt, task, action)

);

DEFINE_EVENT(rpc_task_running, rpc_task_run_action,

	TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),

	TP_ARGS(clnt, task, action)

);

DEFINE_EVENT(rpc_task_running, rpc_task_complete,

	TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),

	TP_ARGS(clnt, task, action)

);

DECLARE_EVENT_CLASS(rpc_task_queued,

	TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),

	TP_ARGS(clnt, task, q),

	TP_STRUCT__entry(
		__field(unsigned int, task_id)
		__field(unsigned int, client_id)
		__field(unsigned long, timeout)
		__field(unsigned long, runstate)
		__field(int, status)
		__field(unsigned short, flags)
		__string(q_name, rpc_qname(q))
		),

	TP_fast_assign(
		__entry->client_id = clnt->cl_clid;
		__entry->task_id = task->tk_pid;
		__entry->timeout = task->tk_timeout;
		__entry->runstate = task->tk_runstate;
		__entry->status = task->tk_status;
		__entry->flags = task->tk_flags;
		__assign_str(q_name, rpc_qname(q));
		),

	TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
		__entry->task_id, __entry->client_id,
		__entry->flags,
		__entry->runstate,
		__entry->status,
		__entry->timeout,
		__get_str(q_name)
		)
);

DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,

	TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),

	TP_ARGS(clnt, task, q)

);

DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,

	TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),

	TP_ARGS(clnt, task, q)

);

/*
 * First define the enums in the below macros to be exported to userspace
 * via TRACE_DEFINE_ENUM().
 */
#undef EM
#undef EMe
#define EM(a, b)	TRACE_DEFINE_ENUM(a);
#define EMe(a, b)	TRACE_DEFINE_ENUM(a);

#define RPC_SHOW_SOCKET				\
	EM( SS_FREE, "FREE" )			\
	EM( SS_UNCONNECTED, "UNCONNECTED" )	\
	EM( SS_CONNECTING, "CONNECTING," )	\
	EM( SS_CONNECTED, "CONNECTED," )	\
	EMe(SS_DISCONNECTING, "DISCONNECTING" )

#define rpc_show_socket_state(state) \
	__print_symbolic(state, RPC_SHOW_SOCKET)

RPC_SHOW_SOCKET

#define RPC_SHOW_SOCK				\
	EM( TCP_ESTABLISHED, "ESTABLISHED" )	\
	EM( TCP_SYN_SENT, "SYN_SENT" )		\
	EM( TCP_SYN_RECV, "SYN_RECV" )		\
	EM( TCP_FIN_WAIT1, "FIN_WAIT1" )	\
	EM( TCP_FIN_WAIT2, "FIN_WAIT2" )	\
	EM( TCP_TIME_WAIT, "TIME_WAIT" )	\
	EM( TCP_CLOSE, "CLOSE" )		\
	EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )	\
	EM( TCP_LAST_ACK, "LAST_ACK" )		\
	EM( TCP_LISTEN, "LISTEN" )		\
	EMe( TCP_CLOSING, "CLOSING" )

#define rpc_show_sock_state(state) \
	__print_symbolic(state, RPC_SHOW_SOCK)

RPC_SHOW_SOCK

/*
 * Now redefine the EM() and EMe() macros to map the enums to the strings
 * that will be printed in the output.
 */
#undef EM
#undef EMe
#define EM(a, b)	{a, b},
#define EMe(a, b)	{a, b}

DECLARE_EVENT_CLASS(xs_socket_event,

		TP_PROTO(
			struct rpc_xprt *xprt,
			struct socket *socket
		),

		TP_ARGS(xprt, socket),

		TP_STRUCT__entry(
			__field(unsigned int, socket_state)
			__field(unsigned int, sock_state)
			__field(unsigned long long, ino)
			__string(dstaddr,
				xprt->address_strings[RPC_DISPLAY_ADDR])
			__string(dstport,
				xprt->address_strings[RPC_DISPLAY_PORT])
		),

		TP_fast_assign(
			struct inode *inode = SOCK_INODE(socket);
			__entry->socket_state = socket->state;
			__entry->sock_state = socket->sk->sk_state;
			__entry->ino = (unsigned long long)inode->i_ino;
			__assign_str(dstaddr,
				xprt->address_strings[RPC_DISPLAY_ADDR]);
			__assign_str(dstport,
				xprt->address_strings[RPC_DISPLAY_PORT]);
		),

		TP_printk(
			"socket:[%llu] dstaddr=%s/%s "
			"state=%u (%s) sk_state=%u (%s)",
			__entry->ino, __get_str(dstaddr), __get_str(dstport),
			__entry->socket_state,
			rpc_show_socket_state(__entry->socket_state),
			__entry->sock_state,
			rpc_show_sock_state(__entry->sock_state)
		)
);
#define DEFINE_RPC_SOCKET_EVENT(name) \
	DEFINE_EVENT(xs_socket_event, name, \
			TP_PROTO( \
				struct rpc_xprt *xprt, \
				struct socket *socket \
			), \
			TP_ARGS(xprt, socket))

DECLARE_EVENT_CLASS(xs_socket_event_done,

		TP_PROTO(
			struct rpc_xprt *xprt,
			struct socket *socket,
			int error
		),

		TP_ARGS(xprt, socket, error),

		TP_STRUCT__entry(
			__field(int, error)
			__field(unsigned int, socket_state)
			__field(unsigned int, sock_state)
			__field(unsigned long long, ino)
			__string(dstaddr,
				xprt->address_strings[RPC_DISPLAY_ADDR])
			__string(dstport,
				xprt->address_strings[RPC_DISPLAY_PORT])
		),

		TP_fast_assign(
			struct inode *inode = SOCK_INODE(socket);
			__entry->socket_state = socket->state;
			__entry->sock_state = socket->sk->sk_state;
			__entry->ino = (unsigned long long)inode->i_ino;
			__entry->error = error;
			__assign_str(dstaddr,
				xprt->address_strings[RPC_DISPLAY_ADDR]);
			__assign_str(dstport,
				xprt->address_strings[RPC_DISPLAY_PORT]);
		),

		TP_printk(
			"error=%d socket:[%llu] dstaddr=%s/%s "
			"state=%u (%s) sk_state=%u (%s)",
			__entry->error,
			__entry->ino, __get_str(dstaddr), __get_str(dstport),
			__entry->socket_state,
			rpc_show_socket_state(__entry->socket_state),
			__entry->sock_state,
			rpc_show_sock_state(__entry->sock_state)
		)
);
#define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
	DEFINE_EVENT(xs_socket_event_done, name, \
			TP_PROTO( \
				struct rpc_xprt *xprt, \
				struct socket *socket, \
				int error \
			), \
			TP_ARGS(xprt, socket, error))

DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);

DECLARE_EVENT_CLASS(rpc_xprt_event,
	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),

	TP_ARGS(xprt, xid, status),

	TP_STRUCT__entry(
		__field(__be32, xid)
		__field(int, status)
		__string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
		__string(port, xprt->address_strings[RPC_DISPLAY_PORT])
	),

	TP_fast_assign(
		__entry->xid = xid;
		__entry->status = status;
		__assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
		__assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
	),

	TP_printk("peer=[%s]:%s xid=0x%x status=%d", __get_str(addr),
			__get_str(port), be32_to_cpu(__entry->xid),
			__entry->status)
);

DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst,
	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	TP_ARGS(xprt, xid, status));

DEFINE_EVENT(rpc_xprt_event, xprt_transmit,
	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	TP_ARGS(xprt, xid, status));

DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst,
	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	TP_ARGS(xprt, xid, status));

TRACE_EVENT(xs_tcp_data_ready,
	TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total),

	TP_ARGS(xprt, err, total),

	TP_STRUCT__entry(
		__field(int, err)
		__field(unsigned int, total)
		__string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
				"(null)")
		__string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
				"(null)")
	),

	TP_fast_assign(
		__entry->err = err;
		__entry->total = total;
		__assign_str(addr, xprt ?
			xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
		__assign_str(port, xprt ?
			xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
	),

	TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr),
			__get_str(port), __entry->err, __entry->total)
);

#define rpc_show_sock_xprt_flags(flags) \
	__print_flags(flags, "|", \
		{ TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \
		{ TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \
		{ TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \
		{ TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \
		{ TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \
		{ TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \
		{ TCP_RPC_REPLY, "TCP_RPC_REPLY" })

TRACE_EVENT(xs_tcp_data_recv,
	TP_PROTO(struct sock_xprt *xs),

	TP_ARGS(xs),

	TP_STRUCT__entry(
		__string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
		__string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
		__field(__be32, xid)
		__field(unsigned long, flags)
		__field(unsigned long, copied)
		__field(unsigned int, reclen)
		__field(unsigned long, offset)
	),

	TP_fast_assign(
		__assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
		__assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
		__entry->xid = xs->tcp_xid;
		__entry->flags = xs->tcp_flags;
		__entry->copied = xs->tcp_copied;
		__entry->reclen = xs->tcp_reclen;
		__entry->offset = xs->tcp_offset;
	),

	TP_printk("peer=[%s]:%s xid=0x%x flags=%s copied=%lu reclen=%u offset=%lu",
			__get_str(addr), __get_str(port), be32_to_cpu(__entry->xid),
			rpc_show_sock_xprt_flags(__entry->flags),
			__entry->copied, __entry->reclen, __entry->offset)
);

#define show_rqstp_flags(flags)						\
	__print_flags(flags, "|",					\
		{ (1UL << RQ_SECURE),		"RQ_SECURE"},		\
		{ (1UL << RQ_LOCAL),		"RQ_LOCAL"},		\
		{ (1UL << RQ_USEDEFERRAL),	"RQ_USEDEFERRAL"},	\
		{ (1UL << RQ_DROPME),		"RQ_DROPME"},		\
		{ (1UL << RQ_SPLICE_OK),	"RQ_SPLICE_OK"},	\
		{ (1UL << RQ_VICTIM),		"RQ_VICTIM"},		\
		{ (1UL << RQ_BUSY),		"RQ_BUSY"})

TRACE_EVENT(svc_recv,
	TP_PROTO(struct svc_rqst *rqst, int status),

	TP_ARGS(rqst, status),

	TP_STRUCT__entry(
		__field(struct sockaddr *, addr)
		__field(__be32, xid)
		__field(int, status)
		__field(unsigned long, flags)
	),

	TP_fast_assign(
		__entry->addr = (struct sockaddr *)&rqst->rq_addr;
		__entry->xid = status > 0 ? rqst->rq_xid : 0;
		__entry->status = status;
		__entry->flags = rqst->rq_flags;
	),

	TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", __entry->addr,
			be32_to_cpu(__entry->xid), __entry->status,
			show_rqstp_flags(__entry->flags))
);

DECLARE_EVENT_CLASS(svc_rqst_status,

	TP_PROTO(struct svc_rqst *rqst, int status),

	TP_ARGS(rqst, status),

	TP_STRUCT__entry(
		__field(struct sockaddr *, addr)
		__field(__be32, xid)
		__field(int, dropme)
		__field(int, status)
		__field(unsigned long, flags)
	),

	TP_fast_assign(
		__entry->addr = (struct sockaddr *)&rqst->rq_addr;
		__entry->xid = rqst->rq_xid;
		__entry->status = status;
		__entry->flags = rqst->rq_flags;
	),

	TP_printk("addr=%pIScp rq_xid=0x%x status=%d flags=%s",
		__entry->addr, be32_to_cpu(__entry->xid),
		__entry->status, show_rqstp_flags(__entry->flags))
);

DEFINE_EVENT(svc_rqst_status, svc_process,
	TP_PROTO(struct svc_rqst *rqst, int status),
	TP_ARGS(rqst, status));

DEFINE_EVENT(svc_rqst_status, svc_send,
	TP_PROTO(struct svc_rqst *rqst, int status),
	TP_ARGS(rqst, status));

#define show_svc_xprt_flags(flags)					\
	__print_flags(flags, "|",					\
		{ (1UL << XPT_BUSY),		"XPT_BUSY"},		\
		{ (1UL << XPT_CONN),		"XPT_CONN"},		\
		{ (1UL << XPT_CLOSE),		"XPT_CLOSE"},		\
		{ (1UL << XPT_DATA),		"XPT_DATA"},		\
		{ (1UL << XPT_TEMP),		"XPT_TEMP"},		\
		{ (1UL << XPT_DEAD),		"XPT_DEAD"},		\
		{ (1UL << XPT_CHNGBUF),		"XPT_CHNGBUF"},		\
		{ (1UL << XPT_DEFERRED),	"XPT_DEFERRED"},	\
		{ (1UL << XPT_OLD),		"XPT_OLD"},		\
		{ (1UL << XPT_LISTENER),	"XPT_LISTENER"},	\
		{ (1UL << XPT_CACHE_AUTH),	"XPT_CACHE_AUTH"},	\
		{ (1UL << XPT_LOCAL),		"XPT_LOCAL"})

TRACE_EVENT(svc_xprt_do_enqueue,
	TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),

	TP_ARGS(xprt, rqst),

	TP_STRUCT__entry(
		__field(struct svc_xprt *, xprt)
		__field_struct(struct sockaddr_storage, ss)
		__field(int, pid)
		__field(unsigned long, flags)
	),

	TP_fast_assign(
		__entry->xprt = xprt;
		xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss));
		__entry->pid = rqst? rqst->rq_task->pid : 0;
		__entry->flags = xprt ? xprt->xpt_flags : 0;
	),

	TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt,
		(struct sockaddr *)&__entry->ss,
		__entry->pid, show_svc_xprt_flags(__entry->flags))
);

TRACE_EVENT(svc_xprt_dequeue,
	TP_PROTO(struct svc_xprt *xprt),

	TP_ARGS(xprt),

	TP_STRUCT__entry(
		__field(struct svc_xprt *, xprt)
		__field_struct(struct sockaddr_storage, ss)
		__field(unsigned long, flags)
	),

	TP_fast_assign(
		__entry->xprt = xprt,
		xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss));
		__entry->flags = xprt ? xprt->xpt_flags : 0;
	),

	TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt,
		(struct sockaddr *)&__entry->ss,
		show_svc_xprt_flags(__entry->flags))
);

TRACE_EVENT(svc_wake_up,
	TP_PROTO(int pid),

	TP_ARGS(pid),

	TP_STRUCT__entry(
		__field(int, pid)
	),

	TP_fast_assign(
		__entry->pid = pid;
	),

	TP_printk("pid=%d", __entry->pid)
);

TRACE_EVENT(svc_handle_xprt,
	TP_PROTO(struct svc_xprt *xprt, int len),

	TP_ARGS(xprt, len),

	TP_STRUCT__entry(
		__field(struct svc_xprt *, xprt)
		__field(int, len)
		__field_struct(struct sockaddr_storage, ss)
		__field(unsigned long, flags)
	),

	TP_fast_assign(
		__entry->xprt = xprt;
		xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss));
		__entry->len = len;
		__entry->flags = xprt ? xprt->xpt_flags : 0;
	),

	TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt,
		(struct sockaddr *)&__entry->ss,
		__entry->len, show_svc_xprt_flags(__entry->flags))
);
#endif /* _TRACE_SUNRPC_H */

#include <trace/define_trace.h>
Commit	Line	Data
82b0a4c3 TM	1	#undef TRACE_SYSTEM
	2	#define TRACE_SYSTEM sunrpc
	3
	4	#if !defined(_TRACE_SUNRPC_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	5	#define _TRACE_SUNRPC_H
	6
	7	#include <linux/sunrpc/sched.h>
	8	#include <linux/sunrpc/clnt.h>
860a0d9e	9	#include <linux/sunrpc/svc.h>
1a867a08	10	#include <linux/sunrpc/xprtsock.h>
83a712e0	11	#include <linux/sunrpc/svc_xprt.h>
40b5ea0c TM	12	#include <net/tcp_states.h>
40b5ea0c TM	13	#include <linux/net.h>
82b0a4c3 TM	14	#include <linux/tracepoint.h>
82b0a4c3 TM	15
5753cba1 SD	16	DECLARE_EVENT_CLASS(rpc_task_status,
	17
	18	TP_PROTO(struct rpc_task *task),
	19
	20	TP_ARGS(task),
	21
	22	TP_STRUCT__entry(
92cb6c5b TM	23	__field(unsigned int, task_id)
92cb6c5b TM	24	__field(unsigned int, client_id)
5753cba1 SD	25	__field(int, status)
	26	),
	27
	28	TP_fast_assign(
92cb6c5b TM	29	__entry->task_id = task->tk_pid;
92cb6c5b TM	30	__entry->client_id = task->tk_client->cl_clid;
5753cba1 SD	31	__entry->status = task->tk_status;
	32	),
	33
92cb6c5b TM	34	TP_printk("task:%u@%u, status %d",
	35	__entry->task_id, __entry->client_id,
	36	__entry->status)
5753cba1 SD	37	);
	38
	39	DEFINE_EVENT(rpc_task_status, rpc_call_status,
	40	TP_PROTO(struct rpc_task *task),
	41
	42	TP_ARGS(task)
	43	);
	44
	45	DEFINE_EVENT(rpc_task_status, rpc_bind_status,
	46	TP_PROTO(struct rpc_task *task),
	47
	48	TP_ARGS(task)
	49	);
	50
	51	TRACE_EVENT(rpc_connect_status,
	52	TP_PROTO(struct rpc_task *task, int status),
	53
	54	TP_ARGS(task, status),
	55
	56	TP_STRUCT__entry(
92cb6c5b TM	57	__field(unsigned int, task_id)
92cb6c5b TM	58	__field(unsigned int, client_id)
5753cba1 SD	59	__field(int, status)
	60	),
	61
	62	TP_fast_assign(
92cb6c5b TM	63	__entry->task_id = task->tk_pid;
92cb6c5b TM	64	__entry->client_id = task->tk_client->cl_clid;
5753cba1 SD	65	__entry->status = status;
	66	),
	67
92cb6c5b TM	68	TP_printk("task:%u@%u, status %d",
	69	__entry->task_id, __entry->client_id,
	70	__entry->status)
5753cba1 SD	71	);
5753cba1 SD	72
82b0a4c3 TM	73	DECLARE_EVENT_CLASS(rpc_task_running,
	74
	75	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	76
	77	TP_ARGS(clnt, task, action),
	78
	79	TP_STRUCT__entry(
92cb6c5b TM	80	__field(unsigned int, task_id)
92cb6c5b TM	81	__field(unsigned int, client_id)
82b0a4c3 TM	82	__field(const void *, action)
	83	__field(unsigned long, runstate)
	84	__field(int, status)
	85	__field(unsigned short, flags)
	86	),
	87
	88	TP_fast_assign(
2ca310fc	89	__entry->client_id = clnt ? clnt->cl_clid : -1;
92cb6c5b	90	__entry->task_id = task->tk_pid;
82b0a4c3 TM	91	__entry->action = action;
	92	__entry->runstate = task->tk_runstate;
	93	__entry->status = task->tk_status;
	94	__entry->flags = task->tk_flags;
	95	),
	96
2ca310fc	97	TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
92cb6c5b	98	__entry->task_id, __entry->client_id,
82b0a4c3 TM	99	__entry->flags,
	100	__entry->runstate,
	101	__entry->status,
	102	__entry->action
	103	)
	104	);
	105
	106	DEFINE_EVENT(rpc_task_running, rpc_task_begin,
	107
	108	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	109
	110	TP_ARGS(clnt, task, action)
	111
	112	);
	113
	114	DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
	115
	116	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	117
	118	TP_ARGS(clnt, task, action)
	119
	120	);
	121
	122	DEFINE_EVENT(rpc_task_running, rpc_task_complete,
	123
	124	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	125
	126	TP_ARGS(clnt, task, action)
	127
	128	);
	129
	130	DECLARE_EVENT_CLASS(rpc_task_queued,
	131
	132	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const struct rpc_wait_queue *q),
	133
	134	TP_ARGS(clnt, task, q),
	135
	136	TP_STRUCT__entry(
92cb6c5b TM	137	__field(unsigned int, task_id)
92cb6c5b TM	138	__field(unsigned int, client_id)
82b0a4c3 TM	139	__field(unsigned long, timeout)
	140	__field(unsigned long, runstate)
	141	__field(int, status)
	142	__field(unsigned short, flags)
85c0d24f	143	__string(q_name, rpc_qname(q))
82b0a4c3 TM	144	),
	145
	146	TP_fast_assign(
92cb6c5b TM	147	__entry->client_id = clnt->cl_clid;
92cb6c5b TM	148	__entry->task_id = task->tk_pid;
82b0a4c3 TM	149	__entry->timeout = task->tk_timeout;
	150	__entry->runstate = task->tk_runstate;
	151	__entry->status = task->tk_status;
	152	__entry->flags = task->tk_flags;
85c0d24f	153	__assign_str(q_name, rpc_qname(q));
82b0a4c3 TM	154	),
82b0a4c3 TM	155
92cb6c5b TM	156	TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
92cb6c5b TM	157	__entry->task_id, __entry->client_id,
82b0a4c3 TM	158	__entry->flags,
	159	__entry->runstate,
	160	__entry->status,
	161	__entry->timeout,
85c0d24f	162	__get_str(q_name)
82b0a4c3 TM	163	)
	164	);
	165
	166	DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
	167
	168	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const struct rpc_wait_queue *q),
	169
	170	TP_ARGS(clnt, task, q)
	171
	172	);
	173
	174	DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
	175
	176	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const struct rpc_wait_queue *q),
	177
	178	TP_ARGS(clnt, task, q)
	179
	180	);
	181
6ba16eef SRRH	182	/*
	183	* First define the enums in the below macros to be exported to userspace
	184	* via TRACE_DEFINE_ENUM().
	185	*/
	186	#undef EM
	187	#undef EMe
	188	#define EM(a, b) TRACE_DEFINE_ENUM(a);
	189	#define EMe(a, b) TRACE_DEFINE_ENUM(a);
	190
	191	#define RPC_SHOW_SOCKET \
	192	EM( SS_FREE, "FREE" ) \
	193	EM( SS_UNCONNECTED, "UNCONNECTED" ) \
	194	EM( SS_CONNECTING, "CONNECTING," ) \
	195	EM( SS_CONNECTED, "CONNECTED," ) \
	196	EMe(SS_DISCONNECTING, "DISCONNECTING" )
	197
40b5ea0c	198	#define rpc_show_socket_state(state) \
6ba16eef SRRH	199	__print_symbolic(state, RPC_SHOW_SOCKET)
	200
	201	RPC_SHOW_SOCKET
	202
	203	#define RPC_SHOW_SOCK \
	204	EM( TCP_ESTABLISHED, "ESTABLISHED" ) \
	205	EM( TCP_SYN_SENT, "SYN_SENT" ) \
	206	EM( TCP_SYN_RECV, "SYN_RECV" ) \
	207	EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \
	208	EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \
	209	EM( TCP_TIME_WAIT, "TIME_WAIT" ) \
	210	EM( TCP_CLOSE, "CLOSE" ) \
	211	EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \
	212	EM( TCP_LAST_ACK, "LAST_ACK" ) \
	213	EM( TCP_LISTEN, "LISTEN" ) \
	214	EMe( TCP_CLOSING, "CLOSING" )
40b5ea0c TM	215
40b5ea0c TM	216	#define rpc_show_sock_state(state) \
6ba16eef SRRH	217	__print_symbolic(state, RPC_SHOW_SOCK)
	218
	219	RPC_SHOW_SOCK
	220
	221	/*
	222	* Now redefine the EM() and EMe() macros to map the enums to the strings
	223	* that will be printed in the output.
	224	*/
	225	#undef EM
	226	#undef EMe
	227	#define EM(a, b) {a, b},
	228	#define EMe(a, b) {a, b}
40b5ea0c TM	229
	230	DECLARE_EVENT_CLASS(xs_socket_event,
	231
	232	TP_PROTO(
	233	struct rpc_xprt *xprt,
	234	struct socket *socket
	235	),
	236
	237	TP_ARGS(xprt, socket),
	238
	239	TP_STRUCT__entry(
	240	__field(unsigned int, socket_state)
	241	__field(unsigned int, sock_state)
	242	__field(unsigned long long, ino)
	243	__string(dstaddr,
	244	xprt->address_strings[RPC_DISPLAY_ADDR])
	245	__string(dstport,
	246	xprt->address_strings[RPC_DISPLAY_PORT])
	247	),
	248
	249	TP_fast_assign(
	250	struct inode *inode = SOCK_INODE(socket);
	251	__entry->socket_state = socket->state;
	252	__entry->sock_state = socket->sk->sk_state;
	253	__entry->ino = (unsigned long long)inode->i_ino;
	254	__assign_str(dstaddr,
	255	xprt->address_strings[RPC_DISPLAY_ADDR]);
	256	__assign_str(dstport,
	257	xprt->address_strings[RPC_DISPLAY_PORT]);
	258	),
	259
	260	TP_printk(
	261	"socket:[%llu] dstaddr=%s/%s "
	262	"state=%u (%s) sk_state=%u (%s)",
	263	__entry->ino, __get_str(dstaddr), __get_str(dstport),
	264	__entry->socket_state,
	265	rpc_show_socket_state(__entry->socket_state),
	266	__entry->sock_state,
	267	rpc_show_sock_state(__entry->sock_state)
	268	)
	269	);
	270	#define DEFINE_RPC_SOCKET_EVENT(name) \
	271	DEFINE_EVENT(xs_socket_event, name, \
	272	TP_PROTO( \
	273	struct rpc_xprt *xprt, \
	274	struct socket *socket \
	275	), \
	276	TP_ARGS(xprt, socket))
	277
	278	DECLARE_EVENT_CLASS(xs_socket_event_done,
	279
	280	TP_PROTO(
	281	struct rpc_xprt *xprt,
	282	struct socket *socket,
	283	int error
	284	),
	285
	286	TP_ARGS(xprt, socket, error),
	287
	288	TP_STRUCT__entry(
	289	__field(int, error)
	290	__field(unsigned int, socket_state)
	291	__field(unsigned int, sock_state)
	292	__field(unsigned long long, ino)
293	__string(dstaddr,
294	xprt->address_strings[RPC_DISPLAY_ADDR])
295	__string(dstport,
296	xprt->address_strings[RPC_DISPLAY_PORT])
297	),
298
299	TP_fast_assign(
300	struct inode *inode = SOCK_INODE(socket);
301	__entry->socket_state = socket->state;
302	__entry->sock_state = socket->sk->sk_state;
303	__entry->ino = (unsigned long long)inode->i_ino;
304	__entry->error = error;
305	__assign_str(dstaddr,
306	xprt->address_strings[RPC_DISPLAY_ADDR]);
307	__assign_str(dstport,
308	xprt->address_strings[RPC_DISPLAY_PORT]);
309	),
310
311	TP_printk(
312	"error=%d socket:[%llu] dstaddr=%s/%s "
313	"state=%u (%s) sk_state=%u (%s)",
314	__entry->error,
315	__entry->ino, __get_str(dstaddr), __get_str(dstport),
316	__entry->socket_state,
317	rpc_show_socket_state(__entry->socket_state),
318	__entry->sock_state,
319	rpc_show_sock_state(__entry->sock_state)
320	)
321	);
322	#define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
323	DEFINE_EVENT(xs_socket_event_done, name, \
324	TP_PROTO( \
325	struct rpc_xprt *xprt, \
326	struct socket *socket, \
327	int error \
328	), \
329	TP_ARGS(xprt, socket, error))
330
331	DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
332	DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
e8353c76	333	DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
40b5ea0c TM	334	DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
	335	DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
	336	DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
	337
3705ad64 JL	338	DECLARE_EVENT_CLASS(rpc_xprt_event,
	339	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	340
	341	TP_ARGS(xprt, xid, status),
	342
	343	TP_STRUCT__entry(
	344	__field(__be32, xid)
	345	__field(int, status)
	346	__string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
	347	__string(port, xprt->address_strings[RPC_DISPLAY_PORT])
	348	),
	349
	350	TP_fast_assign(
	351	__entry->xid = xid;
	352	__entry->status = status;
	353	__assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
	354	__assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
	355	),
	356
1a867a08	357	TP_printk("peer=[%s]:%s xid=0x%x status=%d", __get_str(addr),
3705ad64 JL	358	__get_str(port), be32_to_cpu(__entry->xid),
	359	__entry->status)
	360	);
	361
	362	DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst,
	363	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	364	TP_ARGS(xprt, xid, status));
	365
	366	DEFINE_EVENT(rpc_xprt_event, xprt_transmit,
	367	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	368	TP_ARGS(xprt, xid, status));
	369
	370	DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst,
	371	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	372	TP_ARGS(xprt, xid, status));
	373
	374	TRACE_EVENT(xs_tcp_data_ready,
	375	TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total),
	376
	377	TP_ARGS(xprt, err, total),
	378
	379	TP_STRUCT__entry(
	380	__field(int, err)
	381	__field(unsigned int, total)
	382	__string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
	383	"(null)")
	384	__string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
	385	"(null)")
	386	),
	387
	388	TP_fast_assign(
	389	__entry->err = err;
	390	__entry->total = total;
	391	__assign_str(addr, xprt ?
	392	xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
	393	__assign_str(port, xprt ?
	394	xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
	395	),
	396
	397	TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr),
	398	__get_str(port), __entry->err, __entry->total)
	399	);
	400
1a867a08 JL	401	#define rpc_show_sock_xprt_flags(flags) \
	402	__print_flags(flags, "\|", \
	403	{ TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \
	404	{ TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \
	405	{ TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \
	406	{ TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \
	407	{ TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \
	408	{ TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \
	409	{ TCP_RPC_REPLY, "TCP_RPC_REPLY" })
	410
	411	TRACE_EVENT(xs_tcp_data_recv,
	412	TP_PROTO(struct sock_xprt *xs),
	413
	414	TP_ARGS(xs),
	415
	416	TP_STRUCT__entry(
	417	__string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
	418	__string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
	419	__field(__be32, xid)
	420	__field(unsigned long, flags)
	421	__field(unsigned long, copied)
	422	__field(unsigned int, reclen)
	423	__field(unsigned long, offset)
	424	),
	425
	426	TP_fast_assign(
	427	__assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
	428	__assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
	429	__entry->xid = xs->tcp_xid;
	430	__entry->flags = xs->tcp_flags;
	431	__entry->copied = xs->tcp_copied;
	432	__entry->reclen = xs->tcp_reclen;
	433	__entry->offset = xs->tcp_offset;
	434	),
	435
	436	TP_printk("peer=[%s]:%s xid=0x%x flags=%s copied=%lu reclen=%u offset=%lu",
	437	__get_str(addr), __get_str(port), be32_to_cpu(__entry->xid),
	438	rpc_show_sock_xprt_flags(__entry->flags),
	439	__entry->copied, __entry->reclen, __entry->offset)
	440	);
	441
30660e04 JL	442	#define show_rqstp_flags(flags) \
	443	__print_flags(flags, "\|", \
	444	{ (1UL << RQ_SECURE), "RQ_SECURE"}, \
	445	{ (1UL << RQ_LOCAL), "RQ_LOCAL"}, \
78b65eb3	446	{ (1UL << RQ_USEDEFERRAL), "RQ_USEDEFERRAL"}, \
779fb0f3	447	{ (1UL << RQ_DROPME), "RQ_DROPME"}, \
81244386	448	{ (1UL << RQ_SPLICE_OK), "RQ_SPLICE_OK"}, \
b1691bc0 JL	449	{ (1UL << RQ_VICTIM), "RQ_VICTIM"}, \
b1691bc0 JL	450	{ (1UL << RQ_BUSY), "RQ_BUSY"})
4d152e2c	451
860a0d9e JL	452	TRACE_EVENT(svc_recv,
	453	TP_PROTO(struct svc_rqst *rqst, int status),
	454
	455	TP_ARGS(rqst, status),
	456
	457	TP_STRUCT__entry(
	458	__field(struct sockaddr *, addr)
	459	__field(__be32, xid)
	460	__field(int, status)
4d152e2c	461	__field(unsigned long, flags)
860a0d9e JL	462	),
	463
	464	TP_fast_assign(
	465	__entry->addr = (struct sockaddr *)&rqst->rq_addr;
	466	__entry->xid = status > 0 ? rqst->rq_xid : 0;
	467	__entry->status = status;
4d152e2c	468	__entry->flags = rqst->rq_flags;
860a0d9e JL	469	),
860a0d9e JL	470
4d152e2c JL	471	TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", __entry->addr,
	472	be32_to_cpu(__entry->xid), __entry->status,
	473	show_rqstp_flags(__entry->flags))
860a0d9e JL	474	);
	475
	476	DECLARE_EVENT_CLASS(svc_rqst_status,
	477
	478	TP_PROTO(struct svc_rqst *rqst, int status),
	479
	480	TP_ARGS(rqst, status),
	481
	482	TP_STRUCT__entry(
	483	__field(struct sockaddr *, addr)
	484	__field(__be32, xid)
	485	__field(int, dropme)
	486	__field(int, status)
4d152e2c	487	__field(unsigned long, flags)
860a0d9e JL	488	),
	489
	490	TP_fast_assign(
	491	__entry->addr = (struct sockaddr *)&rqst->rq_addr;
	492	__entry->xid = rqst->rq_xid;
860a0d9e	493	__entry->status = status;
4d152e2c	494	__entry->flags = rqst->rq_flags;
860a0d9e JL	495	),
860a0d9e JL	496
78b65eb3 JL	497	TP_printk("addr=%pIScp rq_xid=0x%x status=%d flags=%s",
78b65eb3 JL	498	__entry->addr, be32_to_cpu(__entry->xid),
4d152e2c	499	__entry->status, show_rqstp_flags(__entry->flags))
860a0d9e JL	500	);
	501
	502	DEFINE_EVENT(svc_rqst_status, svc_process,
	503	TP_PROTO(struct svc_rqst *rqst, int status),
	504	TP_ARGS(rqst, status));
	505
	506	DEFINE_EVENT(svc_rqst_status, svc_send,
	507	TP_PROTO(struct svc_rqst *rqst, int status),
	508	TP_ARGS(rqst, status));
	509
83a712e0 JL	510	#define show_svc_xprt_flags(flags) \
	511	__print_flags(flags, "\|", \
	512	{ (1UL << XPT_BUSY), "XPT_BUSY"}, \
	513	{ (1UL << XPT_CONN), "XPT_CONN"}, \
	514	{ (1UL << XPT_CLOSE), "XPT_CLOSE"}, \
	515	{ (1UL << XPT_DATA), "XPT_DATA"}, \
	516	{ (1UL << XPT_TEMP), "XPT_TEMP"}, \
	517	{ (1UL << XPT_DEAD), "XPT_DEAD"}, \
	518	{ (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \
	519	{ (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \
	520	{ (1UL << XPT_OLD), "XPT_OLD"}, \
	521	{ (1UL << XPT_LISTENER), "XPT_LISTENER"}, \
	522	{ (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \
	523	{ (1UL << XPT_LOCAL), "XPT_LOCAL"})
	524
	525	TRACE_EVENT(svc_xprt_do_enqueue,
	526	TP_PROTO(struct svc_xprt xprt, struct svc_rqst rqst),
	527
	528	TP_ARGS(xprt, rqst),
	529
	530	TP_STRUCT__entry(
	531	__field(struct svc_xprt *, xprt)
051ac384 PA	532	__field_struct(struct sockaddr_storage, ss)
	533	__field(int, pid)
	534	__field(unsigned long, flags)
83a712e0 JL	535	),
	536
	537	TP_fast_assign(
	538	__entry->xprt = xprt;
051ac384 PA	539	xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss));
	540	__entry->pid = rqst? rqst->rq_task->pid : 0;
	541	__entry->flags = xprt ? xprt->xpt_flags : 0;
83a712e0 JL	542	),
	543
	544	TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt,
051ac384 PA	545	(struct sockaddr *)&__entry->ss,
051ac384 PA	546	__entry->pid, show_svc_xprt_flags(__entry->flags))
83a712e0 JL	547	);
	548
	549	TRACE_EVENT(svc_xprt_dequeue,
	550	TP_PROTO(struct svc_xprt *xprt),
	551
	552	TP_ARGS(xprt),
	553
	554	TP_STRUCT__entry(
	555	__field(struct svc_xprt *, xprt)
	556	__field_struct(struct sockaddr_storage, ss)
	557	__field(unsigned long, flags)
	558	),
	559
	560	TP_fast_assign(
	561	__entry->xprt = xprt,
	562	xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss));
	563	__entry->flags = xprt ? xprt->xpt_flags : 0;
	564	),
	565
	566	TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt,
	567	(struct sockaddr *)&__entry->ss,
	568	show_svc_xprt_flags(__entry->flags))
	569	);
	570
	571	TRACE_EVENT(svc_wake_up,
	572	TP_PROTO(int pid),
	573
	574	TP_ARGS(pid),
	575
	576	TP_STRUCT__entry(
	577	__field(int, pid)
	578	),
	579
	580	TP_fast_assign(
	581	__entry->pid = pid;
	582	),
	583
	584	TP_printk("pid=%d", __entry->pid)
	585	);
	586
	587	TRACE_EVENT(svc_handle_xprt,
	588	TP_PROTO(struct svc_xprt *xprt, int len),
	589
	590	TP_ARGS(xprt, len),
	591
	592	TP_STRUCT__entry(
	593	__field(struct svc_xprt *, xprt)
	594	__field(int, len)
051ac384 PA	595	__field_struct(struct sockaddr_storage, ss)
051ac384 PA	596	__field(unsigned long, flags)
83a712e0 JL	597	),
	598
	599	TP_fast_assign(
	600	__entry->xprt = xprt;
051ac384	601	xprt ? memcpy(&__entry->ss, &xprt->xpt_remote, sizeof(__entry->ss)) : memset(&__entry->ss, 0, sizeof(__entry->ss));
83a712e0	602	__entry->len = len;
051ac384	603	__entry->flags = xprt ? xprt->xpt_flags : 0;
83a712e0 JL	604	),
	605
	606	TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt,
051ac384 PA	607	(struct sockaddr *)&__entry->ss,
051ac384 PA	608	__entry->len, show_svc_xprt_flags(__entry->flags))
83a712e0	609	);
82b0a4c3 TM	610	#endif /* _TRACE_SUNRPC_H */
	611
	612	#include <trace/define_trace.h>