[deliverable/linux.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_event,

	TP_PROTO(struct svc_rqst *rqst),

	TP_ARGS(rqst),

	TP_STRUCT__entry(
		__field(__be32, xid)
		__field(unsigned long, flags)
		__dynamic_array(unsigned char, addr, rqst->rq_addrlen)
	),

	TP_fast_assign(
		__entry->xid = rqst->rq_xid;
		__entry->flags = rqst->rq_flags;
		memcpy(__get_dynamic_array(addr),
			&rqst->rq_addr, rqst->rq_addrlen);
	),

	TP_printk("addr=%pIScp rq_xid=0x%x flags=%s",
		(struct sockaddr *)__get_dynamic_array(addr),
		be32_to_cpu(__entry->xid),
		show_rqstp_flags(__entry->flags))
);

DEFINE_EVENT(svc_rqst_event, svc_defer,
	TP_PROTO(struct svc_rqst *rqst),
	TP_ARGS(rqst));

DEFINE_EVENT(svc_rqst_event, svc_drop,
	TP_PROTO(struct svc_rqst *rqst),
	TP_ARGS(rqst));

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(int, pid)
		__field(unsigned long, flags)
		__dynamic_array(unsigned char, addr, xprt != NULL ?
			xprt->xpt_remotelen : 0)
	),

	TP_fast_assign(
		__entry->xprt = xprt;
		__entry->pid = rqst? rqst->rq_task->pid : 0;
		if (xprt) {
			memcpy(__get_dynamic_array(addr),
				&xprt->xpt_remote,
				xprt->xpt_remotelen);
			__entry->flags = xprt->xpt_flags;
		} else
			__entry->flags = 0;
	),

	TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt,
		__get_dynamic_array_len(addr) != 0 ?
			(struct sockaddr *)__get_dynamic_array(addr) : NULL,
		__entry->pid, show_svc_xprt_flags(__entry->flags))
);

DECLARE_EVENT_CLASS(svc_xprt_event,
	TP_PROTO(struct svc_xprt *xprt),

	TP_ARGS(xprt),

	TP_STRUCT__entry(
		__field(struct svc_xprt *, xprt)
		__field(unsigned long, flags)
		__dynamic_array(unsigned char, addr, xprt != NULL ?
			xprt->xpt_remotelen : 0)
	),

	TP_fast_assign(
		__entry->xprt = xprt;
		if (xprt) {
			memcpy(__get_dynamic_array(addr),
					&xprt->xpt_remote,
					xprt->xpt_remotelen);
			__entry->flags = xprt->xpt_flags;
		} else
			__entry->flags = 0;
	),

	TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt,
		__get_dynamic_array_len(addr) != 0 ?
			(struct sockaddr *)__get_dynamic_array(addr) : NULL,
		show_svc_xprt_flags(__entry->flags))
);

DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue,
	TP_PROTO(struct svc_xprt *xprt),
	TP_ARGS(xprt));

DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
	TP_PROTO(struct svc_xprt *xprt),
	TP_ARGS(xprt));

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(unsigned long, flags)
		__dynamic_array(unsigned char, addr, xprt != NULL ?
			xprt->xpt_remotelen : 0)
	),

	TP_fast_assign(
		__entry->xprt = xprt;
		__entry->len = len;
		if (xprt) {
			memcpy(__get_dynamic_array(addr),
					&xprt->xpt_remote,
					xprt->xpt_remotelen);
			__entry->flags = xprt->xpt_flags;
		} else
			__entry->flags = 0;
	),

	TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt,
		__get_dynamic_array_len(addr) != 0 ?
			(struct sockaddr *)__get_dynamic_array(addr) : NULL,
		__entry->len, show_svc_xprt_flags(__entry->flags))
);


DECLARE_EVENT_CLASS(svc_deferred_event,
	TP_PROTO(struct svc_deferred_req *dr),

	TP_ARGS(dr),

	TP_STRUCT__entry(
		__field(__be32, xid)
		__dynamic_array(unsigned char, addr, dr->addrlen)
	),

	TP_fast_assign(
		__entry->xid = *(__be32 *)(dr->args + (dr->xprt_hlen>>2));
		memcpy(__get_dynamic_array(addr), &dr->addr, dr->addrlen);
	),

	TP_printk("addr=%pIScp xid=0x%x",
		(struct sockaddr *)__get_dynamic_array(addr),
		be32_to_cpu(__entry->xid))
);

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