1/* SPDX-License-Identifier: GPL-2.0 */
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>
11#include <linux/bpf.h>
12
13#define __XDP_ACT_MAP(FN)	\
14	FN(ABORTED)		\
15	FN(DROP)		\
16	FN(PASS)		\
17	FN(TX)			\
18	FN(REDIRECT)
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	\
25	__XDP_ACT_MAP(__XDP_ACT_SYM_FN) { -1, NULL }
26__XDP_ACT_MAP(__XDP_ACT_TP_FN)
27
28TRACE_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(
36		__field(int, prog_id)
37		__field(u32, act)
38		__field(int, ifindex)
39	),
40
41	TP_fast_assign(
42		__entry->prog_id	= xdp->aux->id;
43		__entry->act		= act;
44		__entry->ifindex	= dev->ifindex;
45	),
46
47	TP_printk("prog_id=%d action=%s ifindex=%d",
48		  __entry->prog_id,
49		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
50		  __entry->ifindex)
51);
52
53TRACE_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
82#ifndef __DEVMAP_OBJ_TYPE
83#define __DEVMAP_OBJ_TYPE
84struct _bpf_dtab_netdev {
85	struct net_device *dev;
86};
87#endif /* __DEVMAP_OBJ_TYPE */
88
89#define devmap_ifindex(tgt, map)				\
90	(((map->map_type == BPF_MAP_TYPE_DEVMAP ||	\
91		  map->map_type == BPF_MAP_TYPE_DEVMAP_HASH)) ? \
92	  ((struct _bpf_dtab_netdev *)tgt)->dev->ifindex : 0)
93
94DECLARE_EVENT_CLASS(xdp_redirect_template,
95
96	TP_PROTO(const struct net_device *dev,
97		 const struct bpf_prog *xdp,
98		 const void *tgt, int err,
99		 const struct bpf_map *map, u32 index),
100
101	TP_ARGS(dev, xdp, tgt, err, map, index),
102
103	TP_STRUCT__entry(
104		__field(int, prog_id)
105		__field(u32, act)
106		__field(int, ifindex)
107		__field(int, err)
108		__field(int, to_ifindex)
109		__field(u32, map_id)
110		__field(int, map_index)
111	),
112
113	TP_fast_assign(
114		__entry->prog_id	= xdp->aux->id;
115		__entry->act		= XDP_REDIRECT;
116		__entry->ifindex	= dev->ifindex;
117		__entry->err		= err;
118		__entry->to_ifindex	= map ? devmap_ifindex(tgt, map) :
119						index;
120		__entry->map_id		= map ? map->id : 0;
121		__entry->map_index	= map ? index : 0;
122	),
123
124	TP_printk("prog_id=%d action=%s ifindex=%d to_ifindex=%d err=%d"
125		  " map_id=%d map_index=%d",
126		  __entry->prog_id,
127		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
128		  __entry->ifindex, __entry->to_ifindex,
129		  __entry->err, __entry->map_id, __entry->map_index)
130);
131
132DEFINE_EVENT(xdp_redirect_template, xdp_redirect,
133	TP_PROTO(const struct net_device *dev,
134		 const struct bpf_prog *xdp,
135		 const void *tgt, int err,
136		 const struct bpf_map *map, u32 index),
137	TP_ARGS(dev, xdp, tgt, err, map, index)
138);
139
140DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err,
141	TP_PROTO(const struct net_device *dev,
142		 const struct bpf_prog *xdp,
143		 const void *tgt, int err,
144		 const struct bpf_map *map, u32 index),
145	TP_ARGS(dev, xdp, tgt, err, map, index)
146);
147
148#define _trace_xdp_redirect(dev, xdp, to)		\
149	 trace_xdp_redirect(dev, xdp, NULL, 0, NULL, to);
150
151#define _trace_xdp_redirect_err(dev, xdp, to, err)	\
152	 trace_xdp_redirect_err(dev, xdp, NULL, err, NULL, to);
153
154#define _trace_xdp_redirect_map(dev, xdp, to, map, index)		\
155	 trace_xdp_redirect(dev, xdp, to, 0, map, index);
156
157#define _trace_xdp_redirect_map_err(dev, xdp, to, map, index, err)	\
158	 trace_xdp_redirect_err(dev, xdp, to, err, map, index);
159
160/* not used anymore, but kept around so as not to break old programs */
161DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map,
162	TP_PROTO(const struct net_device *dev,
163		 const struct bpf_prog *xdp,
164		 const void *tgt, int err,
165		 const struct bpf_map *map, u32 index),
166	TP_ARGS(dev, xdp, tgt, err, map, index)
167);
168
169DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map_err,
170	TP_PROTO(const struct net_device *dev,
171		 const struct bpf_prog *xdp,
172		 const void *tgt, int err,
173		 const struct bpf_map *map, u32 index),
174	TP_ARGS(dev, xdp, tgt, err, map, index)
175);
176
177TRACE_EVENT(xdp_cpumap_kthread,
178
179	TP_PROTO(int map_id, unsigned int processed,  unsigned int drops,
180		 int sched, struct xdp_cpumap_stats *xdp_stats),
181
182	TP_ARGS(map_id, processed, drops, sched, xdp_stats),
183
184	TP_STRUCT__entry(
185		__field(int, map_id)
186		__field(u32, act)
187		__field(int, cpu)
188		__field(unsigned int, drops)
189		__field(unsigned int, processed)
190		__field(int, sched)
191		__field(unsigned int, xdp_pass)
192		__field(unsigned int, xdp_drop)
193		__field(unsigned int, xdp_redirect)
194	),
195
196	TP_fast_assign(
197		__entry->map_id		= map_id;
198		__entry->act		= XDP_REDIRECT;
199		__entry->cpu		= smp_processor_id();
200		__entry->drops		= drops;
201		__entry->processed	= processed;
202		__entry->sched	= sched;
203		__entry->xdp_pass	= xdp_stats->pass;
204		__entry->xdp_drop	= xdp_stats->drop;
205		__entry->xdp_redirect	= xdp_stats->redirect;
206	),
207
208	TP_printk("kthread"
209		  " cpu=%d map_id=%d action=%s"
210		  " processed=%u drops=%u"
211		  " sched=%d"
212		  " xdp_pass=%u xdp_drop=%u xdp_redirect=%u",
213		  __entry->cpu, __entry->map_id,
214		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
215		  __entry->processed, __entry->drops,
216		  __entry->sched,
217		  __entry->xdp_pass, __entry->xdp_drop, __entry->xdp_redirect)
218);
219
220TRACE_EVENT(xdp_cpumap_enqueue,
221
222	TP_PROTO(int map_id, unsigned int processed,  unsigned int drops,
223		 int to_cpu),
224
225	TP_ARGS(map_id, processed, drops, to_cpu),
226
227	TP_STRUCT__entry(
228		__field(int, map_id)
229		__field(u32, act)
230		__field(int, cpu)
231		__field(unsigned int, drops)
232		__field(unsigned int, processed)
233		__field(int, to_cpu)
234	),
235
236	TP_fast_assign(
237		__entry->map_id		= map_id;
238		__entry->act		= XDP_REDIRECT;
239		__entry->cpu		= smp_processor_id();
240		__entry->drops		= drops;
241		__entry->processed	= processed;
242		__entry->to_cpu		= to_cpu;
243	),
244
245	TP_printk("enqueue"
246		  " cpu=%d map_id=%d action=%s"
247		  " processed=%u drops=%u"
248		  " to_cpu=%d",
249		  __entry->cpu, __entry->map_id,
250		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
251		  __entry->processed, __entry->drops,
252		  __entry->to_cpu)
253);
254
255TRACE_EVENT(xdp_devmap_xmit,
256
257	TP_PROTO(const struct net_device *from_dev,
258		 const struct net_device *to_dev,
259		 int sent, int drops, int err),
260
261	TP_ARGS(from_dev, to_dev, sent, drops, err),
262
263	TP_STRUCT__entry(
264		__field(int, from_ifindex)
265		__field(u32, act)
266		__field(int, to_ifindex)
267		__field(int, drops)
268		__field(int, sent)
269		__field(int, err)
270	),
271
272	TP_fast_assign(
273		__entry->from_ifindex	= from_dev->ifindex;
274		__entry->act		= XDP_REDIRECT;
275		__entry->to_ifindex	= to_dev->ifindex;
276		__entry->drops		= drops;
277		__entry->sent		= sent;
278		__entry->err		= err;
279	),
280
281	TP_printk("ndo_xdp_xmit"
282		  " from_ifindex=%d to_ifindex=%d action=%s"
283		  " sent=%d drops=%d"
284		  " err=%d",
285		  __entry->from_ifindex, __entry->to_ifindex,
286		  __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
287		  __entry->sent, __entry->drops,
288		  __entry->err)
289);
290
291/* Expect users already include <net/xdp.h>, but not xdp_priv.h */
292#include <net/xdp_priv.h>
293
294#define __MEM_TYPE_MAP(FN)	\
295	FN(PAGE_SHARED)		\
296	FN(PAGE_ORDER0)		\
297	FN(PAGE_POOL)		\
298	FN(XSK_BUFF_POOL)
299
300#define __MEM_TYPE_TP_FN(x)	\
301	TRACE_DEFINE_ENUM(MEM_TYPE_##x);
302#define __MEM_TYPE_SYM_FN(x)	\
303	{ MEM_TYPE_##x, #x },
304#define __MEM_TYPE_SYM_TAB	\
305	__MEM_TYPE_MAP(__MEM_TYPE_SYM_FN) { -1, 0 }
306__MEM_TYPE_MAP(__MEM_TYPE_TP_FN)
307
308TRACE_EVENT(mem_disconnect,
309
310	TP_PROTO(const struct xdp_mem_allocator *xa),
311
312	TP_ARGS(xa),
313
314	TP_STRUCT__entry(
315		__field(const struct xdp_mem_allocator *,	xa)
316		__field(u32,		mem_id)
317		__field(u32,		mem_type)
318		__field(const void *,	allocator)
319	),
320
321	TP_fast_assign(
322		__entry->xa		= xa;
323		__entry->mem_id		= xa->mem.id;
324		__entry->mem_type	= xa->mem.type;
325		__entry->allocator	= xa->allocator;
326	),
327
328	TP_printk("mem_id=%d mem_type=%s allocator=%p",
329		  __entry->mem_id,
330		  __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
331		  __entry->allocator
332	)
333);
334
335TRACE_EVENT(mem_connect,
336
337	TP_PROTO(const struct xdp_mem_allocator *xa,
338		 const struct xdp_rxq_info *rxq),
339
340	TP_ARGS(xa, rxq),
341
342	TP_STRUCT__entry(
343		__field(const struct xdp_mem_allocator *,	xa)
344		__field(u32,		mem_id)
345		__field(u32,		mem_type)
346		__field(const void *,	allocator)
347		__field(const struct xdp_rxq_info *,		rxq)
348		__field(int,		ifindex)
349	),
350
351	TP_fast_assign(
352		__entry->xa		= xa;
353		__entry->mem_id		= xa->mem.id;
354		__entry->mem_type	= xa->mem.type;
355		__entry->allocator	= xa->allocator;
356		__entry->rxq		= rxq;
357		__entry->ifindex	= rxq->dev->ifindex;
358	),
359
360	TP_printk("mem_id=%d mem_type=%s allocator=%p"
361		  " ifindex=%d",
362		  __entry->mem_id,
363		  __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
364		  __entry->allocator,
365		  __entry->ifindex
366	)
367);
368
369TRACE_EVENT(mem_return_failed,
370
371	TP_PROTO(const struct xdp_mem_info *mem,
372		 const struct page *page),
373
374	TP_ARGS(mem, page),
375
376	TP_STRUCT__entry(
377		__field(const struct page *,	page)
378		__field(u32,		mem_id)
379		__field(u32,		mem_type)
380	),
381
382	TP_fast_assign(
383		__entry->page		= page;
384		__entry->mem_id		= mem->id;
385		__entry->mem_type	= mem->type;
386	),
387
388	TP_printk("mem_id=%d mem_type=%s page=%p",
389		  __entry->mem_id,
390		  __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
391		  __entry->page
392	)
393);
394
395#endif /* _TRACE_XDP_H */
396
397#include <trace/define_trace.h>
398