Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM xdp
0004 
0005 #if !defined(_TRACE_XDP_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_XDP_H
0007 
0008 #include <linux/netdevice.h>
0009 #include <linux/filter.h>
0010 #include <linux/tracepoint.h>
0011 #include <linux/bpf.h>
0012 
0013 #define __XDP_ACT_MAP(FN)   \
0014     FN(ABORTED)     \
0015     FN(DROP)        \
0016     FN(PASS)        \
0017     FN(TX)          \
0018     FN(REDIRECT)
0019 
0020 #define __XDP_ACT_TP_FN(x)  \
0021     TRACE_DEFINE_ENUM(XDP_##x);
0022 #define __XDP_ACT_SYM_FN(x) \
0023     { XDP_##x, #x },
0024 #define __XDP_ACT_SYM_TAB   \
0025     __XDP_ACT_MAP(__XDP_ACT_SYM_FN) { -1, NULL }
0026 __XDP_ACT_MAP(__XDP_ACT_TP_FN)
0027 
0028 TRACE_EVENT(xdp_exception,
0029 
0030     TP_PROTO(const struct net_device *dev,
0031          const struct bpf_prog *xdp, u32 act),
0032 
0033     TP_ARGS(dev, xdp, act),
0034 
0035     TP_STRUCT__entry(
0036         __field(int, prog_id)
0037         __field(u32, act)
0038         __field(int, ifindex)
0039     ),
0040 
0041     TP_fast_assign(
0042         __entry->prog_id    = xdp->aux->id;
0043         __entry->act        = act;
0044         __entry->ifindex    = dev->ifindex;
0045     ),
0046 
0047     TP_printk("prog_id=%d action=%s ifindex=%d",
0048           __entry->prog_id,
0049           __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
0050           __entry->ifindex)
0051 );
0052 
0053 TRACE_EVENT(xdp_bulk_tx,
0054 
0055     TP_PROTO(const struct net_device *dev,
0056          int sent, int drops, int err),
0057 
0058     TP_ARGS(dev, sent, drops, err),
0059 
0060     TP_STRUCT__entry(
0061         __field(int, ifindex)
0062         __field(u32, act)
0063         __field(int, drops)
0064         __field(int, sent)
0065         __field(int, err)
0066     ),
0067 
0068     TP_fast_assign(
0069         __entry->ifindex    = dev->ifindex;
0070         __entry->act        = XDP_TX;
0071         __entry->drops      = drops;
0072         __entry->sent       = sent;
0073         __entry->err        = err;
0074     ),
0075 
0076     TP_printk("ifindex=%d action=%s sent=%d drops=%d err=%d",
0077           __entry->ifindex,
0078           __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
0079           __entry->sent, __entry->drops, __entry->err)
0080 );
0081 
0082 #ifndef __DEVMAP_OBJ_TYPE
0083 #define __DEVMAP_OBJ_TYPE
0084 struct _bpf_dtab_netdev {
0085     struct net_device *dev;
0086 };
0087 #endif /* __DEVMAP_OBJ_TYPE */
0088 
0089 DECLARE_EVENT_CLASS(xdp_redirect_template,
0090 
0091     TP_PROTO(const struct net_device *dev,
0092          const struct bpf_prog *xdp,
0093          const void *tgt, int err,
0094          enum bpf_map_type map_type,
0095          u32 map_id, u32 index),
0096 
0097     TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index),
0098 
0099     TP_STRUCT__entry(
0100         __field(int, prog_id)
0101         __field(u32, act)
0102         __field(int, ifindex)
0103         __field(int, err)
0104         __field(int, to_ifindex)
0105         __field(u32, map_id)
0106         __field(int, map_index)
0107     ),
0108 
0109     TP_fast_assign(
0110         u32 ifindex = 0, map_index = index;
0111 
0112         if (map_type == BPF_MAP_TYPE_DEVMAP || map_type == BPF_MAP_TYPE_DEVMAP_HASH) {
0113             /* Just leave to_ifindex to 0 if do broadcast redirect,
0114              * as tgt will be NULL.
0115              */
0116             if (tgt)
0117                 ifindex = ((struct _bpf_dtab_netdev *)tgt)->dev->ifindex;
0118         } else if (map_type == BPF_MAP_TYPE_UNSPEC && map_id == INT_MAX) {
0119             ifindex = index;
0120             map_index = 0;
0121         }
0122 
0123         __entry->prog_id    = xdp->aux->id;
0124         __entry->act        = XDP_REDIRECT;
0125         __entry->ifindex    = dev->ifindex;
0126         __entry->err        = err;
0127         __entry->to_ifindex = ifindex;
0128         __entry->map_id     = map_id;
0129         __entry->map_index  = map_index;
0130     ),
0131 
0132     TP_printk("prog_id=%d action=%s ifindex=%d to_ifindex=%d err=%d"
0133           " map_id=%d map_index=%d",
0134           __entry->prog_id,
0135           __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
0136           __entry->ifindex, __entry->to_ifindex,
0137           __entry->err, __entry->map_id, __entry->map_index)
0138 );
0139 
0140 DEFINE_EVENT(xdp_redirect_template, xdp_redirect,
0141     TP_PROTO(const struct net_device *dev,
0142          const struct bpf_prog *xdp,
0143          const void *tgt, int err,
0144          enum bpf_map_type map_type,
0145          u32 map_id, u32 index),
0146     TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
0147 );
0148 
0149 DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err,
0150     TP_PROTO(const struct net_device *dev,
0151          const struct bpf_prog *xdp,
0152          const void *tgt, int err,
0153          enum bpf_map_type map_type,
0154          u32 map_id, u32 index),
0155     TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
0156 );
0157 
0158 #define _trace_xdp_redirect(dev, xdp, to)                       \
0159      trace_xdp_redirect(dev, xdp, NULL, 0, BPF_MAP_TYPE_UNSPEC, INT_MAX, to)
0160 
0161 #define _trace_xdp_redirect_err(dev, xdp, to, err)                  \
0162      trace_xdp_redirect_err(dev, xdp, NULL, err, BPF_MAP_TYPE_UNSPEC, INT_MAX, to)
0163 
0164 #define _trace_xdp_redirect_map(dev, xdp, to, map_type, map_id, index) \
0165      trace_xdp_redirect(dev, xdp, to, 0, map_type, map_id, index)
0166 
0167 #define _trace_xdp_redirect_map_err(dev, xdp, to, map_type, map_id, index, err) \
0168      trace_xdp_redirect_err(dev, xdp, to, err, map_type, map_id, index)
0169 
0170 /* not used anymore, but kept around so as not to break old programs */
0171 DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map,
0172     TP_PROTO(const struct net_device *dev,
0173          const struct bpf_prog *xdp,
0174          const void *tgt, int err,
0175          enum bpf_map_type map_type,
0176          u32 map_id, u32 index),
0177     TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
0178 );
0179 
0180 DEFINE_EVENT(xdp_redirect_template, xdp_redirect_map_err,
0181     TP_PROTO(const struct net_device *dev,
0182          const struct bpf_prog *xdp,
0183          const void *tgt, int err,
0184          enum bpf_map_type map_type,
0185          u32 map_id, u32 index),
0186     TP_ARGS(dev, xdp, tgt, err, map_type, map_id, index)
0187 );
0188 
0189 TRACE_EVENT(xdp_cpumap_kthread,
0190 
0191     TP_PROTO(int map_id, unsigned int processed,  unsigned int drops,
0192          int sched, struct xdp_cpumap_stats *xdp_stats),
0193 
0194     TP_ARGS(map_id, processed, drops, sched, xdp_stats),
0195 
0196     TP_STRUCT__entry(
0197         __field(int, map_id)
0198         __field(u32, act)
0199         __field(int, cpu)
0200         __field(unsigned int, drops)
0201         __field(unsigned int, processed)
0202         __field(int, sched)
0203         __field(unsigned int, xdp_pass)
0204         __field(unsigned int, xdp_drop)
0205         __field(unsigned int, xdp_redirect)
0206     ),
0207 
0208     TP_fast_assign(
0209         __entry->map_id     = map_id;
0210         __entry->act        = XDP_REDIRECT;
0211         __entry->cpu        = smp_processor_id();
0212         __entry->drops      = drops;
0213         __entry->processed  = processed;
0214         __entry->sched  = sched;
0215         __entry->xdp_pass   = xdp_stats->pass;
0216         __entry->xdp_drop   = xdp_stats->drop;
0217         __entry->xdp_redirect   = xdp_stats->redirect;
0218     ),
0219 
0220     TP_printk("kthread"
0221           " cpu=%d map_id=%d action=%s"
0222           " processed=%u drops=%u"
0223           " sched=%d"
0224           " xdp_pass=%u xdp_drop=%u xdp_redirect=%u",
0225           __entry->cpu, __entry->map_id,
0226           __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
0227           __entry->processed, __entry->drops,
0228           __entry->sched,
0229           __entry->xdp_pass, __entry->xdp_drop, __entry->xdp_redirect)
0230 );
0231 
0232 TRACE_EVENT(xdp_cpumap_enqueue,
0233 
0234     TP_PROTO(int map_id, unsigned int processed,  unsigned int drops,
0235          int to_cpu),
0236 
0237     TP_ARGS(map_id, processed, drops, to_cpu),
0238 
0239     TP_STRUCT__entry(
0240         __field(int, map_id)
0241         __field(u32, act)
0242         __field(int, cpu)
0243         __field(unsigned int, drops)
0244         __field(unsigned int, processed)
0245         __field(int, to_cpu)
0246     ),
0247 
0248     TP_fast_assign(
0249         __entry->map_id     = map_id;
0250         __entry->act        = XDP_REDIRECT;
0251         __entry->cpu        = smp_processor_id();
0252         __entry->drops      = drops;
0253         __entry->processed  = processed;
0254         __entry->to_cpu     = to_cpu;
0255     ),
0256 
0257     TP_printk("enqueue"
0258           " cpu=%d map_id=%d action=%s"
0259           " processed=%u drops=%u"
0260           " to_cpu=%d",
0261           __entry->cpu, __entry->map_id,
0262           __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
0263           __entry->processed, __entry->drops,
0264           __entry->to_cpu)
0265 );
0266 
0267 TRACE_EVENT(xdp_devmap_xmit,
0268 
0269     TP_PROTO(const struct net_device *from_dev,
0270          const struct net_device *to_dev,
0271          int sent, int drops, int err),
0272 
0273     TP_ARGS(from_dev, to_dev, sent, drops, err),
0274 
0275     TP_STRUCT__entry(
0276         __field(int, from_ifindex)
0277         __field(u32, act)
0278         __field(int, to_ifindex)
0279         __field(int, drops)
0280         __field(int, sent)
0281         __field(int, err)
0282     ),
0283 
0284     TP_fast_assign(
0285         __entry->from_ifindex   = from_dev->ifindex;
0286         __entry->act        = XDP_REDIRECT;
0287         __entry->to_ifindex = to_dev->ifindex;
0288         __entry->drops      = drops;
0289         __entry->sent       = sent;
0290         __entry->err        = err;
0291     ),
0292 
0293     TP_printk("ndo_xdp_xmit"
0294           " from_ifindex=%d to_ifindex=%d action=%s"
0295           " sent=%d drops=%d"
0296           " err=%d",
0297           __entry->from_ifindex, __entry->to_ifindex,
0298           __print_symbolic(__entry->act, __XDP_ACT_SYM_TAB),
0299           __entry->sent, __entry->drops,
0300           __entry->err)
0301 );
0302 
0303 /* Expect users already include <net/xdp.h>, but not xdp_priv.h */
0304 #include <net/xdp_priv.h>
0305 
0306 #define __MEM_TYPE_MAP(FN)  \
0307     FN(PAGE_SHARED)     \
0308     FN(PAGE_ORDER0)     \
0309     FN(PAGE_POOL)       \
0310     FN(XSK_BUFF_POOL)
0311 
0312 #define __MEM_TYPE_TP_FN(x) \
0313     TRACE_DEFINE_ENUM(MEM_TYPE_##x);
0314 #define __MEM_TYPE_SYM_FN(x)    \
0315     { MEM_TYPE_##x, #x },
0316 #define __MEM_TYPE_SYM_TAB  \
0317     __MEM_TYPE_MAP(__MEM_TYPE_SYM_FN) { -1, 0 }
0318 __MEM_TYPE_MAP(__MEM_TYPE_TP_FN)
0319 
0320 TRACE_EVENT(mem_disconnect,
0321 
0322     TP_PROTO(const struct xdp_mem_allocator *xa),
0323 
0324     TP_ARGS(xa),
0325 
0326     TP_STRUCT__entry(
0327         __field(const struct xdp_mem_allocator *,   xa)
0328         __field(u32,        mem_id)
0329         __field(u32,        mem_type)
0330         __field(const void *,   allocator)
0331     ),
0332 
0333     TP_fast_assign(
0334         __entry->xa     = xa;
0335         __entry->mem_id     = xa->mem.id;
0336         __entry->mem_type   = xa->mem.type;
0337         __entry->allocator  = xa->allocator;
0338     ),
0339 
0340     TP_printk("mem_id=%d mem_type=%s allocator=%p",
0341           __entry->mem_id,
0342           __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
0343           __entry->allocator
0344     )
0345 );
0346 
0347 TRACE_EVENT(mem_connect,
0348 
0349     TP_PROTO(const struct xdp_mem_allocator *xa,
0350          const struct xdp_rxq_info *rxq),
0351 
0352     TP_ARGS(xa, rxq),
0353 
0354     TP_STRUCT__entry(
0355         __field(const struct xdp_mem_allocator *,   xa)
0356         __field(u32,        mem_id)
0357         __field(u32,        mem_type)
0358         __field(const void *,   allocator)
0359         __field(const struct xdp_rxq_info *,        rxq)
0360         __field(int,        ifindex)
0361     ),
0362 
0363     TP_fast_assign(
0364         __entry->xa     = xa;
0365         __entry->mem_id     = xa->mem.id;
0366         __entry->mem_type   = xa->mem.type;
0367         __entry->allocator  = xa->allocator;
0368         __entry->rxq        = rxq;
0369         __entry->ifindex    = rxq->dev->ifindex;
0370     ),
0371 
0372     TP_printk("mem_id=%d mem_type=%s allocator=%p"
0373           " ifindex=%d",
0374           __entry->mem_id,
0375           __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
0376           __entry->allocator,
0377           __entry->ifindex
0378     )
0379 );
0380 
0381 TRACE_EVENT(mem_return_failed,
0382 
0383     TP_PROTO(const struct xdp_mem_info *mem,
0384          const struct page *page),
0385 
0386     TP_ARGS(mem, page),
0387 
0388     TP_STRUCT__entry(
0389         __field(const struct page *,    page)
0390         __field(u32,        mem_id)
0391         __field(u32,        mem_type)
0392     ),
0393 
0394     TP_fast_assign(
0395         __entry->page       = page;
0396         __entry->mem_id     = mem->id;
0397         __entry->mem_type   = mem->type;
0398     ),
0399 
0400     TP_printk("mem_id=%d mem_type=%s page=%p",
0401           __entry->mem_id,
0402           __print_symbolic(__entry->mem_type, __MEM_TYPE_SYM_TAB),
0403           __entry->page
0404     )
0405 );
0406 
0407 #endif /* _TRACE_XDP_H */
0408 
0409 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!