[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 <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)

);

#define rpc_show_socket_state(state) \
	__print_symbolic(state, \
		{ SS_FREE, "FREE" }, \
		{ SS_UNCONNECTED, "UNCONNECTED" }, \
		{ SS_CONNECTING, "CONNECTING," }, \
		{ SS_CONNECTED, "CONNECTED," }, \
		{ SS_DISCONNECTING, "DISCONNECTING" })

#define rpc_show_sock_state(state) \
	__print_symbolic(state, \
		{ TCP_ESTABLISHED, "ESTABLISHED" }, \
		{ TCP_SYN_SENT, "SYN_SENT" }, \
		{ TCP_SYN_RECV, "SYN_RECV" }, \
		{ TCP_FIN_WAIT1, "FIN_WAIT1" }, \
		{ TCP_FIN_WAIT2, "FIN_WAIT2" }, \
		{ TCP_TIME_WAIT, "TIME_WAIT" }, \
		{ TCP_CLOSE, "CLOSE" }, \
		{ TCP_CLOSE_WAIT, "CLOSE_WAIT" }, \
		{ TCP_LAST_ACK, "LAST_ACK" }, \
		{ TCP_LISTEN, "LISTEN" }, \
		{ TCP_CLOSING, "CLOSING" })

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"})

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->dropme = (int)rqst->rq_dropme;
		__entry->status = status;
		__entry->flags = rqst->rq_flags;
	),

	TP_printk("addr=%pIScp rq_xid=0x%x dropme=%d status=%d flags=%s",
		__entry->addr, be32_to_cpu(__entry->xid), __entry->dropme,
		__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));

#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>
40b5ea0c TM	11	#include <net/tcp_states.h>
40b5ea0c TM	12	#include <linux/net.h>
82b0a4c3 TM	13	#include <linux/tracepoint.h>
82b0a4c3 TM	14
5753cba1 SD	15	DECLARE_EVENT_CLASS(rpc_task_status,
	16
	17	TP_PROTO(struct rpc_task *task),
	18
	19	TP_ARGS(task),
	20
	21	TP_STRUCT__entry(
92cb6c5b TM	22	__field(unsigned int, task_id)
92cb6c5b TM	23	__field(unsigned int, client_id)
5753cba1 SD	24	__field(int, status)
	25	),
	26
	27	TP_fast_assign(
92cb6c5b TM	28	__entry->task_id = task->tk_pid;
92cb6c5b TM	29	__entry->client_id = task->tk_client->cl_clid;
5753cba1 SD	30	__entry->status = task->tk_status;
	31	),
	32
92cb6c5b TM	33	TP_printk("task:%u@%u, status %d",
	34	__entry->task_id, __entry->client_id,
	35	__entry->status)
5753cba1 SD	36	);
	37
	38	DEFINE_EVENT(rpc_task_status, rpc_call_status,
	39	TP_PROTO(struct rpc_task *task),
	40
	41	TP_ARGS(task)
	42	);
	43
	44	DEFINE_EVENT(rpc_task_status, rpc_bind_status,
	45	TP_PROTO(struct rpc_task *task),
	46
	47	TP_ARGS(task)
	48	);
	49
	50	TRACE_EVENT(rpc_connect_status,
	51	TP_PROTO(struct rpc_task *task, int status),
	52
	53	TP_ARGS(task, status),
	54
	55	TP_STRUCT__entry(
92cb6c5b TM	56	__field(unsigned int, task_id)
92cb6c5b TM	57	__field(unsigned int, client_id)
5753cba1 SD	58	__field(int, status)
	59	),
	60
	61	TP_fast_assign(
92cb6c5b TM	62	__entry->task_id = task->tk_pid;
92cb6c5b TM	63	__entry->client_id = task->tk_client->cl_clid;
5753cba1 SD	64	__entry->status = status;
	65	),
	66
92cb6c5b TM	67	TP_printk("task:%u@%u, status %d",
	68	__entry->task_id, __entry->client_id,
	69	__entry->status)
5753cba1 SD	70	);
5753cba1 SD	71
82b0a4c3 TM	72	DECLARE_EVENT_CLASS(rpc_task_running,
	73
	74	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	75
	76	TP_ARGS(clnt, task, action),
	77
	78	TP_STRUCT__entry(
92cb6c5b TM	79	__field(unsigned int, task_id)
92cb6c5b TM	80	__field(unsigned int, client_id)
82b0a4c3 TM	81	__field(const void *, action)
	82	__field(unsigned long, runstate)
	83	__field(int, status)
	84	__field(unsigned short, flags)
	85	),
	86
	87	TP_fast_assign(
2ca310fc	88	__entry->client_id = clnt ? clnt->cl_clid : -1;
92cb6c5b	89	__entry->task_id = task->tk_pid;
82b0a4c3 TM	90	__entry->action = action;
	91	__entry->runstate = task->tk_runstate;
	92	__entry->status = task->tk_status;
	93	__entry->flags = task->tk_flags;
	94	),
	95
2ca310fc	96	TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
92cb6c5b	97	__entry->task_id, __entry->client_id,
82b0a4c3 TM	98	__entry->flags,
	99	__entry->runstate,
	100	__entry->status,
	101	__entry->action
	102	)
	103	);
	104
	105	DEFINE_EVENT(rpc_task_running, rpc_task_begin,
	106
	107	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	108
	109	TP_ARGS(clnt, task, action)
	110
	111	);
	112
	113	DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
	114
	115	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	116
	117	TP_ARGS(clnt, task, action)
	118
	119	);
	120
	121	DEFINE_EVENT(rpc_task_running, rpc_task_complete,
	122
	123	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const void *action),
	124
	125	TP_ARGS(clnt, task, action)
	126
	127	);
	128
	129	DECLARE_EVENT_CLASS(rpc_task_queued,
	130
	131	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const struct rpc_wait_queue *q),
	132
	133	TP_ARGS(clnt, task, q),
	134
	135	TP_STRUCT__entry(
92cb6c5b TM	136	__field(unsigned int, task_id)
92cb6c5b TM	137	__field(unsigned int, client_id)
82b0a4c3 TM	138	__field(unsigned long, timeout)
	139	__field(unsigned long, runstate)
	140	__field(int, status)
	141	__field(unsigned short, flags)
85c0d24f	142	__string(q_name, rpc_qname(q))
82b0a4c3 TM	143	),
	144
	145	TP_fast_assign(
92cb6c5b TM	146	__entry->client_id = clnt->cl_clid;
92cb6c5b TM	147	__entry->task_id = task->tk_pid;
82b0a4c3 TM	148	__entry->timeout = task->tk_timeout;
	149	__entry->runstate = task->tk_runstate;
	150	__entry->status = task->tk_status;
	151	__entry->flags = task->tk_flags;
85c0d24f	152	__assign_str(q_name, rpc_qname(q));
82b0a4c3 TM	153	),
82b0a4c3 TM	154
92cb6c5b TM	155	TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
92cb6c5b TM	156	__entry->task_id, __entry->client_id,
82b0a4c3 TM	157	__entry->flags,
	158	__entry->runstate,
	159	__entry->status,
	160	__entry->timeout,
85c0d24f	161	__get_str(q_name)
82b0a4c3 TM	162	)
	163	);
	164
	165	DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
	166
	167	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const struct rpc_wait_queue *q),
	168
	169	TP_ARGS(clnt, task, q)
	170
	171	);
	172
	173	DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
	174
	175	TP_PROTO(const struct rpc_clnt clnt, const struct rpc_task task, const struct rpc_wait_queue *q),
	176
	177	TP_ARGS(clnt, task, q)
	178
	179	);
	180
40b5ea0c TM	181	#define rpc_show_socket_state(state) \
	182	__print_symbolic(state, \
	183	{ SS_FREE, "FREE" }, \
	184	{ SS_UNCONNECTED, "UNCONNECTED" }, \
	185	{ SS_CONNECTING, "CONNECTING," }, \
	186	{ SS_CONNECTED, "CONNECTED," }, \
	187	{ SS_DISCONNECTING, "DISCONNECTING" })
	188
	189	#define rpc_show_sock_state(state) \
	190	__print_symbolic(state, \
	191	{ TCP_ESTABLISHED, "ESTABLISHED" }, \
	192	{ TCP_SYN_SENT, "SYN_SENT" }, \
	193	{ TCP_SYN_RECV, "SYN_RECV" }, \
	194	{ TCP_FIN_WAIT1, "FIN_WAIT1" }, \
	195	{ TCP_FIN_WAIT2, "FIN_WAIT2" }, \
	196	{ TCP_TIME_WAIT, "TIME_WAIT" }, \
	197	{ TCP_CLOSE, "CLOSE" }, \
	198	{ TCP_CLOSE_WAIT, "CLOSE_WAIT" }, \
	199	{ TCP_LAST_ACK, "LAST_ACK" }, \
	200	{ TCP_LISTEN, "LISTEN" }, \
	201	{ TCP_CLOSING, "CLOSING" })
	202
	203	DECLARE_EVENT_CLASS(xs_socket_event,
	204
	205	TP_PROTO(
	206	struct rpc_xprt *xprt,
	207	struct socket *socket
	208	),
	209
	210	TP_ARGS(xprt, socket),
	211
	212	TP_STRUCT__entry(
	213	__field(unsigned int, socket_state)
	214	__field(unsigned int, sock_state)
	215	__field(unsigned long long, ino)
	216	__string(dstaddr,
	217	xprt->address_strings[RPC_DISPLAY_ADDR])
	218	__string(dstport,
	219	xprt->address_strings[RPC_DISPLAY_PORT])
	220	),
	221
	222	TP_fast_assign(
	223	struct inode *inode = SOCK_INODE(socket);
	224	__entry->socket_state = socket->state;
	225	__entry->sock_state = socket->sk->sk_state;
	226	__entry->ino = (unsigned long long)inode->i_ino;
	227	__assign_str(dstaddr,
	228	xprt->address_strings[RPC_DISPLAY_ADDR]);
	229	__assign_str(dstport,
	230	xprt->address_strings[RPC_DISPLAY_PORT]);
	231	),
	232
	233	TP_printk(
	234	"socket:[%llu] dstaddr=%s/%s "
	235	"state=%u (%s) sk_state=%u (%s)",
	236	__entry->ino, __get_str(dstaddr), __get_str(dstport),
	237	__entry->socket_state,
	238	rpc_show_socket_state(__entry->socket_state),
	239	__entry->sock_state,
	240	rpc_show_sock_state(__entry->sock_state)
	241	)
	242	);
	243	#define DEFINE_RPC_SOCKET_EVENT(name) \
	244	DEFINE_EVENT(xs_socket_event, name, \
245	TP_PROTO( \
246	struct rpc_xprt *xprt, \
247	struct socket *socket \
248	), \
249	TP_ARGS(xprt, socket))
250
251	DECLARE_EVENT_CLASS(xs_socket_event_done,
252
253	TP_PROTO(
254	struct rpc_xprt *xprt,
255	struct socket *socket,
256	int error
257	),
258
259	TP_ARGS(xprt, socket, error),
260
261	TP_STRUCT__entry(
262	__field(int, error)
263	__field(unsigned int, socket_state)
264	__field(unsigned int, sock_state)
265	__field(unsigned long long, ino)
266	__string(dstaddr,
267	xprt->address_strings[RPC_DISPLAY_ADDR])
268	__string(dstport,
269	xprt->address_strings[RPC_DISPLAY_PORT])
270	),
271
272	TP_fast_assign(
273	struct inode *inode = SOCK_INODE(socket);
274	__entry->socket_state = socket->state;
275	__entry->sock_state = socket->sk->sk_state;
276	__entry->ino = (unsigned long long)inode->i_ino;
277	__entry->error = error;
278	__assign_str(dstaddr,
279	xprt->address_strings[RPC_DISPLAY_ADDR]);
280	__assign_str(dstport,
281	xprt->address_strings[RPC_DISPLAY_PORT]);
282	),
283
284	TP_printk(
285	"error=%d socket:[%llu] dstaddr=%s/%s "
286	"state=%u (%s) sk_state=%u (%s)",
287	__entry->error,
288	__entry->ino, __get_str(dstaddr), __get_str(dstport),
289	__entry->socket_state,
290	rpc_show_socket_state(__entry->socket_state),
291	__entry->sock_state,
292	rpc_show_sock_state(__entry->sock_state)
293	)
294	);
295	#define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
296	DEFINE_EVENT(xs_socket_event_done, name, \
297	TP_PROTO( \
298	struct rpc_xprt *xprt, \
299	struct socket *socket, \
300	int error \
301	), \
302	TP_ARGS(xprt, socket, error))
303
304	DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
305	DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
e8353c76	306	DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
40b5ea0c TM	307	DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
	308	DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
	309	DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
	310
3705ad64 JL	311	DECLARE_EVENT_CLASS(rpc_xprt_event,
	312	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	313
	314	TP_ARGS(xprt, xid, status),
	315
	316	TP_STRUCT__entry(
	317	__field(__be32, xid)
	318	__field(int, status)
	319	__string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
	320	__string(port, xprt->address_strings[RPC_DISPLAY_PORT])
	321	),
	322
	323	TP_fast_assign(
	324	__entry->xid = xid;
	325	__entry->status = status;
	326	__assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
	327	__assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
	328	),
	329
1a867a08	330	TP_printk("peer=[%s]:%s xid=0x%x status=%d", __get_str(addr),
3705ad64 JL	331	__get_str(port), be32_to_cpu(__entry->xid),
	332	__entry->status)
	333	);
	334
	335	DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst,
	336	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	337	TP_ARGS(xprt, xid, status));
	338
	339	DEFINE_EVENT(rpc_xprt_event, xprt_transmit,
	340	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	341	TP_ARGS(xprt, xid, status));
	342
	343	DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst,
	344	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
	345	TP_ARGS(xprt, xid, status));
	346
	347	TRACE_EVENT(xs_tcp_data_ready,
	348	TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total),
	349
	350	TP_ARGS(xprt, err, total),
	351
	352	TP_STRUCT__entry(
	353	__field(int, err)
	354	__field(unsigned int, total)
	355	__string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
	356	"(null)")
	357	__string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
	358	"(null)")
	359	),
	360
	361	TP_fast_assign(
	362	__entry->err = err;
	363	__entry->total = total;
	364	__assign_str(addr, xprt ?
	365	xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
	366	__assign_str(port, xprt ?
	367	xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
	368	),
	369
	370	TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr),
	371	__get_str(port), __entry->err, __entry->total)
	372	);
	373
1a867a08 JL	374	#define rpc_show_sock_xprt_flags(flags) \
	375	__print_flags(flags, "\|", \
	376	{ TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \
	377	{ TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \
	378	{ TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \
	379	{ TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \
	380	{ TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \
	381	{ TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \
	382	{ TCP_RPC_REPLY, "TCP_RPC_REPLY" })
	383
	384	TRACE_EVENT(xs_tcp_data_recv,
	385	TP_PROTO(struct sock_xprt *xs),
	386
	387	TP_ARGS(xs),
	388
	389	TP_STRUCT__entry(
	390	__string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
	391	__string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
	392	__field(__be32, xid)
	393	__field(unsigned long, flags)
	394	__field(unsigned long, copied)
	395	__field(unsigned int, reclen)
	396	__field(unsigned long, offset)
	397	),
	398
	399	TP_fast_assign(
	400	__assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
	401	__assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
	402	__entry->xid = xs->tcp_xid;
	403	__entry->flags = xs->tcp_flags;
	404	__entry->copied = xs->tcp_copied;
	405	__entry->reclen = xs->tcp_reclen;
	406	__entry->offset = xs->tcp_offset;
	407	),
	408
	409	TP_printk("peer=[%s]:%s xid=0x%x flags=%s copied=%lu reclen=%u offset=%lu",
	410	__get_str(addr), __get_str(port), be32_to_cpu(__entry->xid),
	411	rpc_show_sock_xprt_flags(__entry->flags),
	412	__entry->copied, __entry->reclen, __entry->offset)
	413	);
	414
4d152e2c JL	415	#define show_rqstp_flags(flags) \
4d152e2c JL	416	__print_flags(flags, "\|", \
7501cc2b JL	417	{ (1UL << RQ_SECURE), "RQ_SECURE"}, \
7501cc2b JL	418	{ (1UL << RQ_LOCAL), "RQ_LOCAL"})
4d152e2c	419
860a0d9e JL	420	TRACE_EVENT(svc_recv,
	421	TP_PROTO(struct svc_rqst *rqst, int status),
	422
	423	TP_ARGS(rqst, status),
	424
	425	TP_STRUCT__entry(
	426	__field(struct sockaddr *, addr)
	427	__field(__be32, xid)
	428	__field(int, status)
4d152e2c	429	__field(unsigned long, flags)
860a0d9e JL	430	),
	431
	432	TP_fast_assign(
	433	__entry->addr = (struct sockaddr *)&rqst->rq_addr;
	434	__entry->xid = status > 0 ? rqst->rq_xid : 0;
	435	__entry->status = status;
4d152e2c	436	__entry->flags = rqst->rq_flags;
860a0d9e JL	437	),
860a0d9e JL	438
4d152e2c JL	439	TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", __entry->addr,
	440	be32_to_cpu(__entry->xid), __entry->status,
	441	show_rqstp_flags(__entry->flags))
860a0d9e JL	442	);
	443
	444	DECLARE_EVENT_CLASS(svc_rqst_status,
	445
	446	TP_PROTO(struct svc_rqst *rqst, int status),
	447
	448	TP_ARGS(rqst, status),
	449
	450	TP_STRUCT__entry(
	451	__field(struct sockaddr *, addr)
	452	__field(__be32, xid)
	453	__field(int, dropme)
	454	__field(int, status)
4d152e2c	455	__field(unsigned long, flags)
860a0d9e JL	456	),
	457
	458	TP_fast_assign(
	459	__entry->addr = (struct sockaddr *)&rqst->rq_addr;
	460	__entry->xid = rqst->rq_xid;
	461	__entry->dropme = (int)rqst->rq_dropme;
	462	__entry->status = status;
4d152e2c	463	__entry->flags = rqst->rq_flags;
860a0d9e JL	464	),
860a0d9e JL	465
4d152e2c	466	TP_printk("addr=%pIScp rq_xid=0x%x dropme=%d status=%d flags=%s",
860a0d9e	467	__entry->addr, be32_to_cpu(__entry->xid), __entry->dropme,
4d152e2c	468	__entry->status, show_rqstp_flags(__entry->flags))
860a0d9e JL	469	);
	470
	471	DEFINE_EVENT(svc_rqst_status, svc_process,
	472	TP_PROTO(struct svc_rqst *rqst, int status),
	473	TP_ARGS(rqst, status));
	474
	475	DEFINE_EVENT(svc_rqst_status, svc_send,
	476	TP_PROTO(struct svc_rqst *rqst, int status),
	477	TP_ARGS(rqst, status));
	478
82b0a4c3 TM	479	#endif /* _TRACE_SUNRPC_H */
	480
	481	#include <trace/define_trace.h>