include/trace/events/xdp.h

   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 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 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 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 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 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 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 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 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 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 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 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 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 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>