[mirror_ubuntu-jammy-kernel.git] / include / trace / events / xdp.h

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

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

#include <linux/netdevice.h>
#include <linux/filter.h>
#include <linux/tracepoint.h>
#include <linux/bpf.h>

#define __XDP_ACT_MAP(FN)	\
	FN(ABORTED)		\
	FN(DROP)		\
	FN(PASS)		\
	FN(TX)			\
	FN(REDIRECT)

#define __XDP_ACT_TP_FN(x)	\
	TRACE_DEFINE_ENUM(XDP_##x);
#define __XDP_ACT_SYM_FN(x)	\
	{ XDP_##x, #x },
#define __XDP_ACT_SYM_TAB	\
	__XDP_ACT_MAP(__XDP_ACT_SYM_FN) { -1, NULL }
__XDP_ACT_MAP(__XDP_ACT_TP_FN)

TRACE_EVENT(xdp_exception,

	TP_PROTO(const struct net_device *dev,
		 const struct bpf_prog *xdp, u32 act),

	TP_ARGS(dev, xdp, act),

	TP_STRUCT__entry(
		__field(int, prog_id)
		__field(u32, act)
		__field(int, ifindex)
	),

	TP_fast_assign(
		__entry->prog_id	= xdp->aux->id;
		__entry->act		= act;
		__entry->ifindex	= dev->ifindex;
	),

	TP_printk("prog_id=%d action=%s ifindex=%d",
		  __entry->prog_id,
		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
		  __entry->ifindex)
);

TRACE_EVENT(xdp_bulk_tx,

	TP_PROTO(const struct net_device *dev,
		 int sent, int drops, int err),

	TP_ARGS(dev, sent, drops, err),

	TP_STRUCT__entry(
		__field(int, ifindex)
		__field(u32, act)
		__field(int, drops)
		__field(int, sent)
		__field(int, err)
	),

	TP_fast_assign(
		__entry->ifindex	= dev->ifindex;
		__entry->act		= XDP_TX;
		__entry->drops		= drops;
		__entry->sent		= sent;
		__entry->err		= err;
	),

	TP_printk("ifindex=%d action=%s sent=%d drops=%d err=%d",
		  __entry->ifindex,
		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
		  __entry->sent, __entry->drops, __entry->err)
);

#ifndef __DEVMAP_OBJ_TYPE
#define __DEVMAP_OBJ_TYPE
struct _bpf_dtab_netdev {
	struct net_device *dev;
};
#endif /* __DEVMAP_OBJ_TYPE */

DECLARE_EVENT_CLASS(xdp_redirect_template,

	TP_PROTO(const struct net_device *dev,
		 const struct bpf_prog *xdp,
		 const void *tgt, int err,
		 enum bpf_map_type map_type,
		 u32 map_id, u32 index),

	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index),

	TP_STRUCT__entry(
		__field(int, prog_id)
		__field(u32, act)
		__field(int, ifindex)
		__field(int, err)
		__field(int, to_ifindex)
		__field(u32, map_id)
		__field(int, map_index)
	),

	TP_fast_assign(
		u32 ifindex = 0, map_index = index;

		if (map_type == BPF_MAP_TYPE_DEVMAP || map_type == BPF_MAP_TYPE_DEVMAP_HASH) {
			/* Just leave to_ifindex to 0 if do broadcast redirect,
			 * as tgt will be NULL.
			 */
			if (tgt)
				ifindex = ((struct _bpf_dtab_netdev *)tgt)->dev->ifindex;
		} else if (map_type == BPF_MAP_TYPE_UNSPEC && map_id == INT_MAX) {
			ifindex = index;
			map_index = 0;
		}

		__entry->prog_id	= xdp->aux->id;
		__entry->act		= XDP_REDIRECT;
		__entry->ifindex	= dev->ifindex;
		__entry->err		= err;
		__entry->to_ifindex	= ifindex;
		__entry->map_id		= map_id;
		__entry->map_index	= map_index;
	),

	TP_printk("prog_id=%d action=%s ifindex=%d to_ifindex=%d err=%d"
		  " map_id=%d map_index=%d",
		  __entry->prog_id,
		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
		  __entry->ifindex, __entry->to_ifindex,
		  __entry->err, __entry->map_id, __entry->map_index)
);

DEFINE_EVENT(xdp_redirect_template, xdp_redirect,
	TP_PROTO(const struct net_device *dev,
		 const struct bpf_prog *xdp,
		 const void *tgt, int err,
		 enum bpf_map_type map_type,
		 u32 map_id, u32 index),
	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
);

DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err,
	TP_PROTO(const struct net_device *dev,
		 const struct bpf_prog *xdp,
		 const void *tgt, int err,
		 enum bpf_map_type map_type,
		 u32 map_id, u32 index),
	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
);

#define _trace_xdp_redirect(dev, xdp, to)						\
	 trace_xdp_redirect(dev, xdp, NULL, 0, BPF_MAP_TYPE_UNSPEC, INT_MAX, to)

#define _trace_xdp_redirect_err(dev, xdp, to, err)					\
	 trace_xdp_redirect_err(dev, xdp, NULL, err, BPF_MAP_TYPE_UNSPEC, INT_MAX, to)

#define _trace_xdp_redirect_map(dev, xdp, to, map_type, map_id, index) \
	 trace_xdp_redirect(dev, xdp, to, 0, map_type, map_id, index)

#define _trace_xdp_redirect_map_err(dev, xdp, to, map_type, map_id, index, err) \
	 trace_xdp_redirect_err(dev, xdp, to, err, map_type, map_id, index)

/* not used anymore, but kept around so as not to break old programs */
DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map,
	TP_PROTO(const struct net_device *dev,
		 const struct bpf_prog *xdp,
		 const void *tgt, int err,
		 enum bpf_map_type map_type,
		 u32 map_id, u32 index),
	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
);

DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map_err,
	TP_PROTO(const struct net_device *dev,
		 const struct bpf_prog *xdp,
		 const void *tgt, int err,
		 enum bpf_map_type map_type,
		 u32 map_id, u32 index),
	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
);

TRACE_EVENT(xdp_cpumap_kthread,

	TP_PROTO(int map_id, unsigned int processed,  unsigned int drops,
		 int sched, struct xdp_cpumap_stats *xdp_stats),

	TP_ARGS(map_id, processed, drops, sched, xdp_stats),

	TP_STRUCT__entry(
		__field(int, map_id)
		__field(u32, act)
		__field(int, cpu)
		__field(unsigned int, drops)
		__field(unsigned int, processed)
		__field(int, sched)
		__field(unsigned int, xdp_pass)
		__field(unsigned int, xdp_drop)
		__field(unsigned int, xdp_redirect)
	),

	TP_fast_assign(
		__entry->map_id		= map_id;
		__entry->act		= XDP_REDIRECT;
		__entry->cpu		= smp_processor_id();
		__entry->drops		= drops;
		__entry->processed	= processed;
		__entry->sched	= sched;
		__entry->xdp_pass	= xdp_stats->pass;
		__entry->xdp_drop	= xdp_stats->drop;
		__entry->xdp_redirect	= xdp_stats->redirect;
	),

	TP_printk("kthread"
		  " cpu=%d map_id=%d action=%s"
		  " processed=%u drops=%u"
		  " sched=%d"
		  " xdp_pass=%u xdp_drop=%u xdp_redirect=%u",
		  __entry->cpu, __entry->map_id,
		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
		  __entry->processed, __entry->drops,
		  __entry->sched,
		  __entry->xdp_pass, __entry->xdp_drop, __entry->xdp_redirect)
);

TRACE_EVENT(xdp_cpumap_enqueue,

	TP_PROTO(int map_id, unsigned int processed,  unsigned int drops,
		 int to_cpu),

	TP_ARGS(map_id, processed, drops, to_cpu),

	TP_STRUCT__entry(
		__field(int, map_id)
		__field(u32, act)
		__field(int, cpu)
		__field(unsigned int, drops)
		__field(unsigned int, processed)
		__field(int, to_cpu)
	),

	TP_fast_assign(
		__entry->map_id		= map_id;
		__entry->act		= XDP_REDIRECT;
		__entry->cpu		= smp_processor_id();
		__entry->drops		= drops;
		__entry->processed	= processed;
		__entry->to_cpu		= to_cpu;
	),

	TP_printk("enqueue"
		  " cpu=%d map_id=%d action=%s"
		  " processed=%u drops=%u"
		  " to_cpu=%d",
		  __entry->cpu, __entry->map_id,
		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
		  __entry->processed, __entry->drops,
		  __entry->to_cpu)
);

TRACE_EVENT(xdp_devmap_xmit,

	TP_PROTO(const struct net_device *from_dev,
		 const struct net_device *to_dev,
		 int sent, int drops, int err),

	TP_ARGS(from_dev, to_dev, sent, drops, err),

	TP_STRUCT__entry(
		__field(int, from_ifindex)
		__field(u32, act)
		__field(int, to_ifindex)
		__field(int, drops)
		__field(int, sent)
		__field(int, err)
	),

	TP_fast_assign(
		__entry->from_ifindex	= from_dev->ifindex;
		__entry->act		= XDP_REDIRECT;
		__entry->to_ifindex	= to_dev->ifindex;
		__entry->drops		= drops;
		__entry->sent		= sent;
		__entry->err		= err;
	),

	TP_printk("ndo_xdp_xmit"
		  " from_ifindex=%d to_ifindex=%d action=%s"
		  " sent=%d drops=%d"
		  " err=%d",
		  __entry->from_ifindex, __entry->to_ifindex,
		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
		  __entry->sent, __entry->drops,
		  __entry->err)
);

/* Expect users already include <net/xdp.h>, but not xdp_priv.h */
#include <net/xdp_priv.h>

#define __MEM_TYPE_MAP(FN)	\
	FN(PAGE_SHARED)		\
	FN(PAGE_ORDER0)		\
	FN(PAGE_POOL)		\
	FN(XSK_BUFF_POOL)

#define __MEM_TYPE_TP_FN(x)	\
	TRACE_DEFINE_ENUM(MEM_TYPE_##x);
#define __MEM_TYPE_SYM_FN(x)	\
	{ MEM_TYPE_##x, #x },
#define __MEM_TYPE_SYM_TAB	\
	__MEM_TYPE_MAP(__MEM_TYPE_SYM_FN) { -1, 0 }
__MEM_TYPE_MAP(__MEM_TYPE_TP_FN)

TRACE_EVENT(mem_disconnect,

	TP_PROTO(const struct xdp_mem_allocator *xa),

	TP_ARGS(xa),

	TP_STRUCT__entry(
		__field(const struct xdp_mem_allocator *,	xa)
		__field(u32,		mem_id)
		__field(u32,		mem_type)
		__field(const void *,	allocator)
	),

	TP_fast_assign(
		__entry->xa		= xa;
		__entry->mem_id		= xa->mem.id;
		__entry->mem_type	= xa->mem.type;
		__entry->allocator	= xa->allocator;
	),

	TP_printk("mem_id=%d mem_type=%s allocator=%p",
		  __entry->mem_id,
		  __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
		  __entry->allocator
	)
);

TRACE_EVENT(mem_connect,

	TP_PROTO(const struct xdp_mem_allocator *xa,
		 const struct xdp_rxq_info *rxq),

	TP_ARGS(xa, rxq),

	TP_STRUCT__entry(
		__field(const struct xdp_mem_allocator *,	xa)
		__field(u32,		mem_id)
		__field(u32,		mem_type)
		__field(const void *,	allocator)
		__field(const struct xdp_rxq_info *,		rxq)
		__field(int,		ifindex)
	),

	TP_fast_assign(
		__entry->xa		= xa;
		__entry->mem_id		= xa->mem.id;
		__entry->mem_type	= xa->mem.type;
		__entry->allocator	= xa->allocator;
		__entry->rxq		= rxq;
		__entry->ifindex	= rxq->dev->ifindex;
	),

	TP_printk("mem_id=%d mem_type=%s allocator=%p"
		  " ifindex=%d",
		  __entry->mem_id,
		  __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
		  __entry->allocator,
		  __entry->ifindex
	)
);

TRACE_EVENT(mem_return_failed,

	TP_PROTO(const struct xdp_mem_info *mem,
		 const struct page *page),

	TP_ARGS(mem, page),

	TP_STRUCT__entry(
		__field(const struct page *,	page)
		__field(u32,		mem_id)
		__field(u32,		mem_type)
	),

	TP_fast_assign(
		__entry->page		= page;
		__entry->mem_id		= mem->id;
		__entry->mem_type	= mem->type;
	),

	TP_printk("mem_id=%d mem_type=%s page=%p",
		  __entry->mem_id,
		  __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
		  __entry->page
	)
);

#endif /* _TRACE_XDP_H */

#include <trace/define_trace.h>
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
a67edbf4 DB	2	#undef TRACE_SYSTEM
	3	#define TRACE_SYSTEM xdp
	4
	5	#if !defined(_TRACE_XDP_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	6	#define _TRACE_XDP_H
	7
	8	#include <linux/netdevice.h>
	9	#include <linux/filter.h>
	10	#include <linux/tracepoint.h>
23721a75	11	#include <linux/bpf.h>
a67edbf4 DB	12
	13	#define __XDP_ACT_MAP(FN) \
	14	FN(ABORTED) \
	15	FN(DROP) \
	16	FN(PASS) \
5acaee0a JF	17	FN(TX) \
5acaee0a JF	18	FN(REDIRECT)
a67edbf4 DB	19
	20	#define __XDP_ACT_TP_FN(x) \
	21	TRACE_DEFINE_ENUM(XDP_##x);
	22	#define __XDP_ACT_SYM_FN(x) \
	23	{ XDP_##x, #x },
	24	#define __XDP_ACT_SYM_TAB \
5e5b03d1	25	__XDP_ACT_MAP(__XDP_ACT_SYM_FN) { -1, NULL }
a67edbf4 DB	26	__XDP_ACT_MAP(__XDP_ACT_TP_FN)
	27
	28	TRACE_EVENT(xdp_exception,
	29
	30	TP_PROTO(const struct net_device *dev,
	31	const struct bpf_prog *xdp, u32 act),
	32
	33	TP_ARGS(dev, xdp, act),
	34
	35	TP_STRUCT__entry(
b06337df	36	__field(int, prog_id)
a67edbf4	37	__field(u32, act)
315ec399	38	__field(int, ifindex)
a67edbf4 DB	39	),
	40
	41	TP_fast_assign(
b06337df	42	__entry->prog_id = xdp->aux->id;
315ec399 JDB	43	__entry->act = act;
315ec399 JDB	44	__entry->ifindex = dev->ifindex;
a67edbf4 DB	45	),
a67edbf4 DB	46
b06337df JDB	47	TP_printk("prog_id=%d action=%s ifindex=%d",
b06337df JDB	48	__entry->prog_id,
315ec399 JDB	49	__print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
315ec399 JDB	50	__entry->ifindex)
a67edbf4 DB	51	);
a67edbf4 DB	52
e7d47989 TM	53	TRACE_EVENT(xdp_bulk_tx,
	54
	55	TP_PROTO(const struct net_device *dev,
	56	int sent, int drops, int err),
	57
	58	TP_ARGS(dev, sent, drops, err),
	59
	60	TP_STRUCT__entry(
	61	__field(int, ifindex)
	62	__field(u32, act)
	63	__field(int, drops)
	64	__field(int, sent)
	65	__field(int, err)
	66	),
	67
	68	TP_fast_assign(
	69	__entry->ifindex = dev->ifindex;
	70	__entry->act = XDP_TX;
	71	__entry->drops = drops;
	72	__entry->sent = sent;
	73	__entry->err = err;
	74	),
	75
	76	TP_printk("ifindex=%d action=%s sent=%d drops=%d err=%d",
	77	__entry->ifindex,
	78	__print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
	79	__entry->sent, __entry->drops, __entry->err)
	80	);
	81
1d233886 THJ	82	#ifndef __DEVMAP_OBJ_TYPE
	83	#define __DEVMAP_OBJ_TYPE
	84	struct _bpf_dtab_netdev {
	85	struct net_device *dev;
	86	};
	87	#endif /* __DEVMAP_OBJ_TYPE */
	88
8d3b778f	89	DECLARE_EVENT_CLASS(xdp_redirect_template,
5acaee0a	90
a8735855	91	TP_PROTO(const struct net_device *dev,
c31e5a48	92	const struct bpf_prog *xdp,
1d233886	93	const void *tgt, int err,
ee75aef2 BT	94	enum bpf_map_type map_type,
ee75aef2 BT	95	u32 map_id, u32 index),
5acaee0a	96
ee75aef2	97	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index),
5acaee0a JF	98
5acaee0a JF	99	TP_STRUCT__entry(
b06337df	100	__field(int, prog_id)
5acaee0a	101	__field(u32, act)
a8735855	102	__field(int, ifindex)
4c03bdd7	103	__field(int, err)
8d3b778f JDB	104	__field(int, to_ifindex)
	105	__field(u32, map_id)
	106	__field(int, map_index)
5acaee0a JF	107	),
	108
	109	TP_fast_assign(
ee75aef2 BT	110	u32 ifindex = 0, map_index = index;
	111
	112	if (map_type == BPF_MAP_TYPE_DEVMAP \|\| map_type == BPF_MAP_TYPE_DEVMAP_HASH) {
e624d4ed HL	113	/* Just leave to_ifindex to 0 if do broadcast redirect,
	114	* as tgt will be NULL.
	115	*/
	116	if (tgt)
	117	ifindex = ((struct _bpf_dtab_netdev *)tgt)->dev->ifindex;
ee75aef2 BT	118	} else if (map_type == BPF_MAP_TYPE_UNSPEC && map_id == INT_MAX) {
	119	ifindex = index;
	120	map_index = 0;
	121	}
	122
b06337df	123	__entry->prog_id = xdp->aux->id;
c31e5a48	124	__entry->act = XDP_REDIRECT;
a8735855	125	__entry->ifindex = dev->ifindex;
a8735855	126	__entry->err = err;
ee75aef2 BT	127	__entry->to_ifindex = ifindex;
	128	__entry->map_id = map_id;
	129	__entry->map_index = map_index;
5acaee0a JF	130	),
5acaee0a JF	131
1d233886 THJ	132	TP_printk("prog_id=%d action=%s ifindex=%d to_ifindex=%d err=%d"
1d233886 THJ	133	" map_id=%d map_index=%d",
b06337df	134	__entry->prog_id,
4c03bdd7	135	__print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
8d3b778f	136	__entry->ifindex, __entry->to_ifindex,
1d233886	137	__entry->err, __entry->map_id, __entry->map_index)
5acaee0a	138	);
8d3b778f JDB	139
	140	DEFINE_EVENT(xdp_redirect_template, xdp_redirect,
	141	TP_PROTO(const struct net_device *dev,
	142	const struct bpf_prog *xdp,
1d233886	143	const void *tgt, int err,
ee75aef2 BT	144	enum bpf_map_type map_type,
	145	u32 map_id, u32 index),
	146	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
8d3b778f JDB	147	);
8d3b778f JDB	148
f5836ca5 JDB	149	DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err,
	150	TP_PROTO(const struct net_device *dev,
	151	const struct bpf_prog *xdp,
1d233886	152	const void *tgt, int err,
ee75aef2 BT	153	enum bpf_map_type map_type,
	154	u32 map_id, u32 index),
	155	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
f5836ca5 JDB	156	);
f5836ca5 JDB	157
ee75aef2 BT	158	#define _trace_xdp_redirect(dev, xdp, to) \
ee75aef2 BT	159	trace_xdp_redirect(dev, xdp, NULL, 0, BPF_MAP_TYPE_UNSPEC, INT_MAX, to)
f5836ca5	160
ee75aef2 BT	161	#define _trace_xdp_redirect_err(dev, xdp, to, err) \
ee75aef2 BT	162	trace_xdp_redirect_err(dev, xdp, NULL, err, BPF_MAP_TYPE_UNSPEC, INT_MAX, to)
1d233886	163
ee75aef2 BT	164	#define _trace_xdp_redirect_map(dev, xdp, to, map_type, map_id, index) \
ee75aef2 BT	165	trace_xdp_redirect(dev, xdp, to, 0, map_type, map_id, index)
1d233886	166
ee75aef2 BT	167	#define _trace_xdp_redirect_map_err(dev, xdp, to, map_type, map_id, index, err) \
ee75aef2 BT	168	trace_xdp_redirect_err(dev, xdp, to, err, map_type, map_id, index)
f5836ca5	169
1d233886 THJ	170	/* not used anymore, but kept around so as not to break old programs */
1d233886 THJ	171	DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map,
59a30896 JDB	172	TP_PROTO(const struct net_device *dev,
59a30896 JDB	173	const struct bpf_prog *xdp,
1d233886	174	const void *tgt, int err,
ee75aef2 BT	175	enum bpf_map_type map_type,
	176	u32 map_id, u32 index),
	177	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
59a30896 JDB	178	);
59a30896 JDB	179
1d233886	180	DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map_err,
59a30896 JDB	181	TP_PROTO(const struct net_device *dev,
59a30896 JDB	182	const struct bpf_prog *xdp,
1d233886	183	const void *tgt, int err,
ee75aef2 BT	184	enum bpf_map_type map_type,
	185	u32 map_id, u32 index),
	186	TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
59a30896 JDB	187	);
59a30896 JDB	188
f9419f7b JDB	189	TRACE_EVENT(xdp_cpumap_kthread,
	190
	191	TP_PROTO(int map_id, unsigned int processed, unsigned int drops,
92164774	192	int sched, struct xdp_cpumap_stats *xdp_stats),
f9419f7b	193
92164774	194	TP_ARGS(map_id, processed, drops, sched, xdp_stats),
f9419f7b JDB	195
	196	TP_STRUCT__entry(
	197	__field(int, map_id)
	198	__field(u32, act)
	199	__field(int, cpu)
	200	__field(unsigned int, drops)
	201	__field(unsigned int, processed)
	202	__field(int, sched)
92164774 LB	203	__field(unsigned int, xdp_pass)
92164774 LB	204	__field(unsigned int, xdp_drop)
28b1520e	205	__field(unsigned int, xdp_redirect)
f9419f7b JDB	206	),
	207
	208	TP_fast_assign(
	209	__entry->map_id = map_id;
	210	__entry->act = XDP_REDIRECT;
	211	__entry->cpu = smp_processor_id();
	212	__entry->drops = drops;
	213	__entry->processed = processed;
	214	__entry->sched = sched;
92164774 LB	215	__entry->xdp_pass = xdp_stats->pass;
92164774 LB	216	__entry->xdp_drop = xdp_stats->drop;
28b1520e	217	__entry->xdp_redirect = xdp_stats->redirect;
f9419f7b JDB	218	),
	219
	220	TP_printk("kthread"
	221	" cpu=%d map_id=%d action=%s"
	222	" processed=%u drops=%u"
92164774	223	" sched=%d"
28b1520e	224	" xdp_pass=%u xdp_drop=%u xdp_redirect=%u",
f9419f7b JDB	225	__entry->cpu, __entry->map_id,
	226	__print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
	227	__entry->processed, __entry->drops,
92164774	228	__entry->sched,
28b1520e	229	__entry->xdp_pass, __entry->xdp_drop, __entry->xdp_redirect)
f9419f7b JDB	230	);
	231
	232	TRACE_EVENT(xdp_cpumap_enqueue,
	233
	234	TP_PROTO(int map_id, unsigned int processed, unsigned int drops,
	235	int to_cpu),
	236
	237	TP_ARGS(map_id, processed, drops, to_cpu),
	238
	239	TP_STRUCT__entry(
	240	__field(int, map_id)
	241	__field(u32, act)
	242	__field(int, cpu)
	243	__field(unsigned int, drops)
	244	__field(unsigned int, processed)
	245	__field(int, to_cpu)
	246	),
	247
	248	TP_fast_assign(
	249	__entry->map_id = map_id;
	250	__entry->act = XDP_REDIRECT;
	251	__entry->cpu = smp_processor_id();
	252	__entry->drops = drops;
	253	__entry->processed = processed;
	254	__entry->to_cpu = to_cpu;
	255	),
	256
	257	TP_printk("enqueue"
	258	" cpu=%d map_id=%d action=%s"
	259	" processed=%u drops=%u"
	260	" to_cpu=%d",
	261	__entry->cpu, __entry->map_id,
	262	__print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
	263	__entry->processed, __entry->drops,
	264	__entry->to_cpu)
	265	);
	266
38edddb8 JDB	267	TRACE_EVENT(xdp_devmap_xmit,
38edddb8 JDB	268
58aa94f9 JDB	269	TP_PROTO(const struct net_device *from_dev,
	270	const struct net_device *to_dev,
	271	int sent, int drops, int err),
38edddb8	272
58aa94f9	273	TP_ARGS(from_dev, to_dev, sent, drops, err),
38edddb8 JDB	274
38edddb8 JDB	275	TP_STRUCT__entry(
58aa94f9	276	__field(int, from_ifindex)
38edddb8	277	__field(u32, act)
58aa94f9	278	__field(int, to_ifindex)
38edddb8 JDB	279	__field(int, drops)
38edddb8 JDB	280	__field(int, sent)
e74de52e	281	__field(int, err)
38edddb8 JDB	282	),
	283
	284	TP_fast_assign(
58aa94f9	285	__entry->from_ifindex = from_dev->ifindex;
38edddb8	286	__entry->act = XDP_REDIRECT;
58aa94f9	287	__entry->to_ifindex = to_dev->ifindex;
38edddb8 JDB	288	__entry->drops = drops;
38edddb8 JDB	289	__entry->sent = sent;
e74de52e	290	__entry->err = err;
38edddb8 JDB	291	),
	292
	293	TP_printk("ndo_xdp_xmit"
58aa94f9	294	" from_ifindex=%d to_ifindex=%d action=%s"
38edddb8	295	" sent=%d drops=%d"
58aa94f9 JDB	296	" err=%d",
58aa94f9 JDB	297	__entry->from_ifindex, __entry->to_ifindex,
38edddb8 JDB	298	__print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
38edddb8 JDB	299	__entry->sent, __entry->drops,
58aa94f9	300	__entry->err)
38edddb8 JDB	301	);
38edddb8 JDB	302
f033b688 JDB	303	/* Expect users already include <net/xdp.h>, but not xdp_priv.h */
	304	#include <net/xdp_priv.h>
	305
	306	#define __MEM_TYPE_MAP(FN) \
	307	FN(PAGE_SHARED) \
	308	FN(PAGE_ORDER0) \
	309	FN(PAGE_POOL) \
2b43470a	310	FN(XSK_BUFF_POOL)
f033b688 JDB	311
	312	#define __MEM_TYPE_TP_FN(x) \
	313	TRACE_DEFINE_ENUM(MEM_TYPE_##x);
	314	#define __MEM_TYPE_SYM_FN(x) \
	315	{ MEM_TYPE_##x, #x },
	316	#define __MEM_TYPE_SYM_TAB \
	317	__MEM_TYPE_MAP(__MEM_TYPE_SYM_FN) { -1, 0 }
	318	__MEM_TYPE_MAP(__MEM_TYPE_TP_FN)
	319
	320	TRACE_EVENT(mem_disconnect,
	321
c3f812ce	322	TP_PROTO(const struct xdp_mem_allocator *xa),
f033b688	323
c3f812ce	324	TP_ARGS(xa),
f033b688 JDB	325
	326	TP_STRUCT__entry(
	327	__field(const struct xdp_mem_allocator *, xa)
	328	__field(u32, mem_id)
	329	__field(u32, mem_type)
	330	__field(const void *, allocator)
f033b688 JDB	331	),
	332
	333	TP_fast_assign(
	334	__entry->xa = xa;
	335	__entry->mem_id = xa->mem.id;
	336	__entry->mem_type = xa->mem.type;
	337	__entry->allocator = xa->allocator;
f033b688 JDB	338	),
f033b688 JDB	339
c3f812ce	340	TP_printk("mem_id=%d mem_type=%s allocator=%p",
f033b688 JDB	341	__entry->mem_id,
f033b688 JDB	342	__print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
c3f812ce	343	__entry->allocator
f033b688 JDB	344	)
	345	);
	346
	347	TRACE_EVENT(mem_connect,
	348
	349	TP_PROTO(const struct xdp_mem_allocator *xa,
	350	const struct xdp_rxq_info *rxq),
	351
	352	TP_ARGS(xa, rxq),
	353
	354	TP_STRUCT__entry(
	355	__field(const struct xdp_mem_allocator *, xa)
	356	__field(u32, mem_id)
	357	__field(u32, mem_type)
	358	__field(const void *, allocator)
	359	__field(const struct xdp_rxq_info *, rxq)
	360	__field(int, ifindex)
	361	),
	362
	363	TP_fast_assign(
	364	__entry->xa = xa;
	365	__entry->mem_id = xa->mem.id;
	366	__entry->mem_type = xa->mem.type;
	367	__entry->allocator = xa->allocator;
	368	__entry->rxq = rxq;
	369	__entry->ifindex = rxq->dev->ifindex;
	370	),
	371
	372	TP_printk("mem_id=%d mem_type=%s allocator=%p"
	373	" ifindex=%d",
	374	__entry->mem_id,
	375	__print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
	376	__entry->allocator,
	377	__entry->ifindex
	378	)
	379	);
	380
	381	TRACE_EVENT(mem_return_failed,
	382
	383	TP_PROTO(const struct xdp_mem_info *mem,
	384	const struct page *page),
	385
	386	TP_ARGS(mem, page),
	387
	388	TP_STRUCT__entry(
	389	__field(const struct page *, page)
	390	__field(u32, mem_id)
	391	__field(u32, mem_type)
	392	),
	393
	394	TP_fast_assign(
	395	__entry->page = page;
	396	__entry->mem_id = mem->id;
	397	__entry->mem_type = mem->type;
	398	),
	399
	400	TP_printk("mem_id=%d mem_type=%s page=%p",
	401	__entry->mem_id,
	402	__print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
	403	__entry->page
	404	)
	405	);
	406
a67edbf4 DB	407	#endif /* _TRACE_XDP_H */
	408
	409	#include <trace/define_trace.h>