Line data Source code
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 :
28 0 : 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(
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 :
53 0 : 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 :
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 :
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 :
94 0 : DECLARE_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 :
132 0 : DEFINE_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 :
140 0 : DEFINE_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 */
161 0 : DEFINE_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 :
169 0 : DEFINE_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 :
177 0 : TRACE_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 :
220 0 : TRACE_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 :
255 0 : TRACE_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 :
308 0 : TRACE_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 :
335 0 : TRACE_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 :
369 0 : TRACE_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>
|
