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

/* SPDX-License-Identifier: GPL-2.0 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM sock

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

#include <net/sock.h>
#include <net/ipv6.h>
#include <linux/tracepoint.h>
#include <linux/ipv6.h>
#include <linux/tcp.h>
#include <trace/events/net_probe_common.h>

#define family_names			\
		EM(AF_INET)				\
		EMe(AF_INET6)

/* The protocol traced by inet_sock_set_state */
#define inet_protocol_names		\
		EM(IPPROTO_TCP)			\
		EM(IPPROTO_SCTP)		\
		EMe(IPPROTO_MPTCP)

#define tcp_state_names			\
		EM(TCP_ESTABLISHED)		\
		EM(TCP_SYN_SENT)		\
		EM(TCP_SYN_RECV)		\
		EM(TCP_FIN_WAIT1)		\
		EM(TCP_FIN_WAIT2)		\
		EM(TCP_TIME_WAIT)		\
		EM(TCP_CLOSE)			\
		EM(TCP_CLOSE_WAIT)		\
		EM(TCP_LAST_ACK)		\
		EM(TCP_LISTEN)			\
		EM(TCP_CLOSING)			\
		EMe(TCP_NEW_SYN_RECV)

#define skmem_kind_names			\
		EM(SK_MEM_SEND)			\
		EMe(SK_MEM_RECV)

/* enums need to be exported to user space */
#undef EM
#undef EMe
#define EM(a)       TRACE_DEFINE_ENUM(a);
#define EMe(a)      TRACE_DEFINE_ENUM(a);

family_names
inet_protocol_names
tcp_state_names
skmem_kind_names

#undef EM
#undef EMe
#define EM(a)       { a, #a },
#define EMe(a)      { a, #a }

#define show_family_name(val)			\
	__print_symbolic(val, family_names)

#define show_inet_protocol_name(val)    \
	__print_symbolic(val, inet_protocol_names)

#define show_tcp_state_name(val)        \
	__print_symbolic(val, tcp_state_names)

#define show_skmem_kind_names(val)	\
	__print_symbolic(val, skmem_kind_names)

TRACE_EVENT(sock_rcvqueue_full,

	TP_PROTO(struct sock *sk, struct sk_buff *skb),

	TP_ARGS(sk, skb),

	TP_STRUCT__entry(
		__field(int, rmem_alloc)
		__field(unsigned int, truesize)
		__field(int, sk_rcvbuf)
	),

	TP_fast_assign(
		__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
		__entry->truesize   = skb->truesize;
		__entry->sk_rcvbuf  = READ_ONCE(sk->sk_rcvbuf);
	),

	TP_printk("rmem_alloc=%d truesize=%u sk_rcvbuf=%d",
		__entry->rmem_alloc, __entry->truesize, __entry->sk_rcvbuf)
);

TRACE_EVENT(sock_exceed_buf_limit,

	TP_PROTO(struct sock *sk, struct proto *prot, long allocated, int kind),

	TP_ARGS(sk, prot, allocated, kind),

	TP_STRUCT__entry(
		__array(char, name, 32)
		__array(long, sysctl_mem, 3)
		__field(long, allocated)
		__field(int, sysctl_rmem)
		__field(int, rmem_alloc)
		__field(int, sysctl_wmem)
		__field(int, wmem_alloc)
		__field(int, wmem_queued)
		__field(int, kind)
	),

	TP_fast_assign(
		strscpy(__entry->name, prot->name, 32);
		__entry->sysctl_mem[0] = READ_ONCE(prot->sysctl_mem[0]);
		__entry->sysctl_mem[1] = READ_ONCE(prot->sysctl_mem[1]);
		__entry->sysctl_mem[2] = READ_ONCE(prot->sysctl_mem[2]);
		__entry->allocated = allocated;
		__entry->sysctl_rmem = sk_get_rmem0(sk, prot);
		__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
		__entry->sysctl_wmem = sk_get_wmem0(sk, prot);
		__entry->wmem_alloc = refcount_read(&sk->sk_wmem_alloc);
		__entry->wmem_queued = READ_ONCE(sk->sk_wmem_queued);
		__entry->kind = kind;
	),

	TP_printk("proto:%s sysctl_mem=%ld,%ld,%ld allocated=%ld sysctl_rmem=%d rmem_alloc=%d sysctl_wmem=%d wmem_alloc=%d wmem_queued=%d kind=%s",
		__entry->name,
		__entry->sysctl_mem[0],
		__entry->sysctl_mem[1],
		__entry->sysctl_mem[2],
		__entry->allocated,
		__entry->sysctl_rmem,
		__entry->rmem_alloc,
		__entry->sysctl_wmem,
		__entry->wmem_alloc,
		__entry->wmem_queued,
		show_skmem_kind_names(__entry->kind)
	)
);

TRACE_EVENT(inet_sock_set_state,

	TP_PROTO(const struct sock *sk, const int oldstate, const int newstate),

	TP_ARGS(sk, oldstate, newstate),

	TP_STRUCT__entry(
		__field(const void *, skaddr)
		__field(int, oldstate)
		__field(int, newstate)
		__field(__u16, sport)
		__field(__u16, dport)
		__field(__u16, family)
		__field(__u16, protocol)
		__array(__u8, saddr, 4)
		__array(__u8, daddr, 4)
		__array(__u8, saddr_v6, 16)
		__array(__u8, daddr_v6, 16)
	),

	TP_fast_assign(
		const struct inet_sock *inet = inet_sk(sk);
		__be32 *p32;

		__entry->skaddr = sk;
		__entry->oldstate = oldstate;
		__entry->newstate = newstate;

		__entry->family = sk->sk_family;
		__entry->protocol = sk->sk_protocol;
		__entry->sport = ntohs(inet->inet_sport);
		__entry->dport = ntohs(inet->inet_dport);

		p32 = (__be32 *) __entry->saddr;
		*p32 = inet->inet_saddr;

		p32 = (__be32 *) __entry->daddr;
		*p32 =  inet->inet_daddr;

		TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
			       sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
	),

	TP_printk("family=%s protocol=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c oldstate=%s newstate=%s",
			show_family_name(__entry->family),
			show_inet_protocol_name(__entry->protocol),
			__entry->sport, __entry->dport,
			__entry->saddr, __entry->daddr,
			__entry->saddr_v6, __entry->daddr_v6,
			show_tcp_state_name(__entry->oldstate),
			show_tcp_state_name(__entry->newstate))
);

TRACE_EVENT(inet_sk_error_report,

	TP_PROTO(const struct sock *sk),

	TP_ARGS(sk),

	TP_STRUCT__entry(
		__field(int, error)
		__field(__u16, sport)
		__field(__u16, dport)
		__field(__u16, family)
		__field(__u16, protocol)
		__array(__u8, saddr, 4)
		__array(__u8, daddr, 4)
		__array(__u8, saddr_v6, 16)
		__array(__u8, daddr_v6, 16)
	),

	TP_fast_assign(
		const struct inet_sock *inet = inet_sk(sk);
		__be32 *p32;

		__entry->error = sk->sk_err;
		__entry->family = sk->sk_family;
		__entry->protocol = sk->sk_protocol;
		__entry->sport = ntohs(inet->inet_sport);
		__entry->dport = ntohs(inet->inet_dport);

		p32 = (__be32 *) __entry->saddr;
		*p32 = inet->inet_saddr;

		p32 = (__be32 *) __entry->daddr;
		*p32 =  inet->inet_daddr;

		TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
			       sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
	),

	TP_printk("family=%s protocol=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c error=%d",
		  show_family_name(__entry->family),
		  show_inet_protocol_name(__entry->protocol),
		  __entry->sport, __entry->dport,
		  __entry->saddr, __entry->daddr,
		  __entry->saddr_v6, __entry->daddr_v6,
		  __entry->error)
);

TRACE_EVENT(sk_data_ready,

	TP_PROTO(const struct sock *sk),

	TP_ARGS(sk),

	TP_STRUCT__entry(
		__field(const void *, skaddr)
		__field(__u16, family)
		__field(__u16, protocol)
		__field(unsigned long, ip)
	),

	TP_fast_assign(
		__entry->skaddr = sk;
		__entry->family = sk->sk_family;
		__entry->protocol = sk->sk_protocol;
		__entry->ip = _RET_IP_;
	),

	TP_printk("family=%u protocol=%u func=%ps",
		  __entry->family, __entry->protocol, (void *)__entry->ip)
);

/*
 * sock send/recv msg length
 */
DECLARE_EVENT_CLASS(sock_msg_length,

	TP_PROTO(struct sock *sk, int ret, int flags),

	TP_ARGS(sk, ret, flags),

	TP_STRUCT__entry(
		__field(void *, sk)
		__field(__u16, family)
		__field(__u16, protocol)
		__field(int, ret)
		__field(int, flags)
	),

	TP_fast_assign(
		__entry->sk = sk;
		__entry->family = sk->sk_family;
		__entry->protocol = sk->sk_protocol;
		__entry->ret = ret;
		__entry->flags = flags;
	),

	TP_printk("sk address = %p, family = %s protocol = %s, length = %d, error = %d, flags = 0x%x",
		  __entry->sk, show_family_name(__entry->family),
		  show_inet_protocol_name(__entry->protocol),
		  !(__entry->flags & MSG_PEEK) ?
		  (__entry->ret > 0 ? __entry->ret : 0) : 0,
		  __entry->ret < 0 ? __entry->ret : 0,
		  __entry->flags)
);

DEFINE_EVENT(sock_msg_length, sock_send_length,
	TP_PROTO(struct sock *sk, int ret, int flags),

	TP_ARGS(sk, ret, flags)
);

DEFINE_EVENT(sock_msg_length, sock_recv_length,
	TP_PROTO(struct sock *sk, int ret, int flags),

	TP_ARGS(sk, ret, flags)
);
#endif /* _TRACE_SOCK_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#undef TRACE_SYSTEM
	3	#define TRACE_SYSTEM sock
	4
	5	#if !defined(_TRACE_SOCK_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	6	#define _TRACE_SOCK_H
	7
	8	#include <net/sock.h>
	9	#include <net/ipv6.h>
	10	#include <linux/tracepoint.h>
	11	#include <linux/ipv6.h>
	12	#include <linux/tcp.h>
	13	#include <trace/events/net_probe_common.h>
	14
	15	#define family_names \
	16	EM(AF_INET) \
	17	EMe(AF_INET6)
	18
	19	/* The protocol traced by inet_sock_set_state */
	20	#define inet_protocol_names \
	21	EM(IPPROTO_TCP) \
	22	EM(IPPROTO_SCTP) \
	23	EMe(IPPROTO_MPTCP)
	24
	25	#define tcp_state_names \
	26	EM(TCP_ESTABLISHED) \
	27	EM(TCP_SYN_SENT) \
	28	EM(TCP_SYN_RECV) \
	29	EM(TCP_FIN_WAIT1) \
	30	EM(TCP_FIN_WAIT2) \
	31	EM(TCP_TIME_WAIT) \
	32	EM(TCP_CLOSE) \
	33	EM(TCP_CLOSE_WAIT) \
	34	EM(TCP_LAST_ACK) \
	35	EM(TCP_LISTEN) \
	36	EM(TCP_CLOSING) \
	37	EMe(TCP_NEW_SYN_RECV)
	38
	39	#define skmem_kind_names \
	40	EM(SK_MEM_SEND) \
	41	EMe(SK_MEM_RECV)
	42
	43	/* enums need to be exported to user space */
	44	#undef EM
	45	#undef EMe
	46	#define EM(a) TRACE_DEFINE_ENUM(a);
	47	#define EMe(a) TRACE_DEFINE_ENUM(a);
	48
	49	family_names
	50	inet_protocol_names
	51	tcp_state_names
	52	skmem_kind_names
	53
	54	#undef EM
	55	#undef EMe
	56	#define EM(a) { a, #a },
	57	#define EMe(a) { a, #a }
	58
	59	#define show_family_name(val) \
	60	__print_symbolic(val, family_names)
	61
	62	#define show_inet_protocol_name(val) \
	63	__print_symbolic(val, inet_protocol_names)
	64
	65	#define show_tcp_state_name(val) \
	66	__print_symbolic(val, tcp_state_names)
	67
	68	#define show_skmem_kind_names(val) \
	69	__print_symbolic(val, skmem_kind_names)
	70
	71	TRACE_EVENT(sock_rcvqueue_full,
	72
	73	TP_PROTO(struct sock sk, struct sk_buff skb),
	74
	75	TP_ARGS(sk, skb),
	76
	77	TP_STRUCT__entry(
	78	__field(int, rmem_alloc)
	79	__field(unsigned int, truesize)
	80	__field(int, sk_rcvbuf)
	81	),
	82
	83	TP_fast_assign(
	84	__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
	85	__entry->truesize = skb->truesize;
	86	__entry->sk_rcvbuf = READ_ONCE(sk->sk_rcvbuf);
	87	),
	88
	89	TP_printk("rmem_alloc=%d truesize=%u sk_rcvbuf=%d",
	90	__entry->rmem_alloc, __entry->truesize, __entry->sk_rcvbuf)
	91	);
	92
	93	TRACE_EVENT(sock_exceed_buf_limit,
	94
	95	TP_PROTO(struct sock sk, struct proto prot, long allocated, int kind),
	96
	97	TP_ARGS(sk, prot, allocated, kind),
	98
	99	TP_STRUCT__entry(
	100	__array(char, name, 32)
	101	__array(long, sysctl_mem, 3)
	102	__field(long, allocated)
	103	__field(int, sysctl_rmem)
	104	__field(int, rmem_alloc)
	105	__field(int, sysctl_wmem)
	106	__field(int, wmem_alloc)
	107	__field(int, wmem_queued)
	108	__field(int, kind)
	109	),
	110
	111	TP_fast_assign(
	112	strscpy(__entry->name, prot->name, 32);
	113	__entry->sysctl_mem[0] = READ_ONCE(prot->sysctl_mem[0]);
	114	__entry->sysctl_mem[1] = READ_ONCE(prot->sysctl_mem[1]);
	115	__entry->sysctl_mem[2] = READ_ONCE(prot->sysctl_mem[2]);
	116	__entry->allocated = allocated;
	117	__entry->sysctl_rmem = sk_get_rmem0(sk, prot);
	118	__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
	119	__entry->sysctl_wmem = sk_get_wmem0(sk, prot);
	120	__entry->wmem_alloc = refcount_read(&sk->sk_wmem_alloc);
	121	__entry->wmem_queued = READ_ONCE(sk->sk_wmem_queued);
	122	__entry->kind = kind;
	123	),
	124
	125	TP_printk("proto:%s sysctl_mem=%ld,%ld,%ld allocated=%ld sysctl_rmem=%d rmem_alloc=%d sysctl_wmem=%d wmem_alloc=%d wmem_queued=%d kind=%s",
	126	__entry->name,
	127	__entry->sysctl_mem[0],
	128	__entry->sysctl_mem[1],
	129	__entry->sysctl_mem[2],
	130	__entry->allocated,
	131	__entry->sysctl_rmem,
	132	__entry->rmem_alloc,
	133	__entry->sysctl_wmem,
	134	__entry->wmem_alloc,
	135	__entry->wmem_queued,
	136	show_skmem_kind_names(__entry->kind)
	137	)
	138	);
	139
	140	TRACE_EVENT(inet_sock_set_state,
	141
	142	TP_PROTO(const struct sock *sk, const int oldstate, const int newstate),
	143
	144	TP_ARGS(sk, oldstate, newstate),
	145
	146	TP_STRUCT__entry(
	147	__field(const void *, skaddr)
	148	__field(int, oldstate)
	149	__field(int, newstate)
	150	__field(__u16, sport)
	151	__field(__u16, dport)
	152	__field(__u16, family)
	153	__field(__u16, protocol)
	154	__array(__u8, saddr, 4)
	155	__array(__u8, daddr, 4)
	156	__array(__u8, saddr_v6, 16)
	157	__array(__u8, daddr_v6, 16)
	158	),
	159
	160	TP_fast_assign(
	161	const struct inet_sock *inet = inet_sk(sk);
	162	__be32 *p32;
	163
	164	__entry->skaddr = sk;
	165	__entry->oldstate = oldstate;
	166	__entry->newstate = newstate;
	167
	168	__entry->family = sk->sk_family;
	169	__entry->protocol = sk->sk_protocol;
	170	__entry->sport = ntohs(inet->inet_sport);
	171	__entry->dport = ntohs(inet->inet_dport);
	172
	173	p32 = (__be32 *) __entry->saddr;
	174	*p32 = inet->inet_saddr;
	175
	176	p32 = (__be32 *) __entry->daddr;
	177	*p32 = inet->inet_daddr;
	178
	179	TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
	180	sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
	181	),
	182
	183	TP_printk("family=%s protocol=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c oldstate=%s newstate=%s",
	184	show_family_name(__entry->family),
	185	show_inet_protocol_name(__entry->protocol),
	186	__entry->sport, __entry->dport,
	187	__entry->saddr, __entry->daddr,
	188	__entry->saddr_v6, __entry->daddr_v6,
	189	show_tcp_state_name(__entry->oldstate),
	190	show_tcp_state_name(__entry->newstate))
	191	);
	192
	193	TRACE_EVENT(inet_sk_error_report,
	194
	195	TP_PROTO(const struct sock *sk),
	196
	197	TP_ARGS(sk),
	198
	199	TP_STRUCT__entry(
	200	__field(int, error)
	201	__field(__u16, sport)
	202	__field(__u16, dport)
	203	__field(__u16, family)
	204	__field(__u16, protocol)
	205	__array(__u8, saddr, 4)
	206	__array(__u8, daddr, 4)
	207	__array(__u8, saddr_v6, 16)
	208	__array(__u8, daddr_v6, 16)
	209	),
	210
	211	TP_fast_assign(
	212	const struct inet_sock *inet = inet_sk(sk);
	213	__be32 *p32;
	214
	215	__entry->error = sk->sk_err;
	216	__entry->family = sk->sk_family;
	217	__entry->protocol = sk->sk_protocol;
	218	__entry->sport = ntohs(inet->inet_sport);
	219	__entry->dport = ntohs(inet->inet_dport);
	220
	221	p32 = (__be32 *) __entry->saddr;
	222	*p32 = inet->inet_saddr;
	223
	224	p32 = (__be32 *) __entry->daddr;
	225	*p32 = inet->inet_daddr;
	226
	227	TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
	228	sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
	229	),
	230
	231	TP_printk("family=%s protocol=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c error=%d",
	232	show_family_name(__entry->family),
	233	show_inet_protocol_name(__entry->protocol),
	234	__entry->sport, __entry->dport,
	235	__entry->saddr, __entry->daddr,
	236	__entry->saddr_v6, __entry->daddr_v6,
	237	__entry->error)
	238	);
	239
	240	TRACE_EVENT(sk_data_ready,
	241
	242	TP_PROTO(const struct sock *sk),
	243
	244	TP_ARGS(sk),
	245
	246	TP_STRUCT__entry(
	247	__field(const void *, skaddr)
	248	__field(__u16, family)
	249	__field(__u16, protocol)
	250	__field(unsigned long, ip)
	251	),
	252
	253	TP_fast_assign(
	254	__entry->skaddr = sk;
	255	__entry->family = sk->sk_family;
	256	__entry->protocol = sk->sk_protocol;
	257	__entry->ip = _RET_IP_;
	258	),
	259
	260	TP_printk("family=%u protocol=%u func=%ps",
	261	__entry->family, __entry->protocol, (void *)__entry->ip)
	262	);
	263
	264	/*
	265	* sock send/recv msg length
	266	*/
	267	DECLARE_EVENT_CLASS(sock_msg_length,
	268
	269	TP_PROTO(struct sock *sk, int ret, int flags),
	270
	271	TP_ARGS(sk, ret, flags),
	272
	273	TP_STRUCT__entry(
	274	__field(void *, sk)
	275	__field(__u16, family)
	276	__field(__u16, protocol)
	277	__field(int, ret)
	278	__field(int, flags)
	279	),
	280
	281	TP_fast_assign(
	282	__entry->sk = sk;
	283	__entry->family = sk->sk_family;
	284	__entry->protocol = sk->sk_protocol;
	285	__entry->ret = ret;
	286	__entry->flags = flags;
	287	),
	288
	289	TP_printk("sk address = %p, family = %s protocol = %s, length = %d, error = %d, flags = 0x%x",
	290	__entry->sk, show_family_name(__entry->family),
	291	show_inet_protocol_name(__entry->protocol),
	292	!(__entry->flags & MSG_PEEK) ?
	293	(__entry->ret > 0 ? __entry->ret : 0) : 0,
	294	__entry->ret < 0 ? __entry->ret : 0,
	295	__entry->flags)
	296	);
	297
	298	DEFINE_EVENT(sock_msg_length, sock_send_length,
	299	TP_PROTO(struct sock *sk, int ret, int flags),
	300
	301	TP_ARGS(sk, ret, flags)
	302	);
	303
	304	DEFINE_EVENT(sock_msg_length, sock_recv_length,
	305	TP_PROTO(struct sock *sk, int ret, int flags),
	306
	307	TP_ARGS(sk, ret, flags)
	308	);
	309	#endif /* _TRACE_SOCK_H */
	310
	311	/* This part must be outside protection */
	312	#include <trace/define_trace.h>