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