include/trace/events/bpf.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM bpf
   4
   5 #if !defined(_TRACE_BPF_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_BPF_H
   7
   8 /* These are only used within the BPF_SYSCALL code */
   9 #ifdef CONFIG_BPF_SYSCALL
  10
  11 #include <linux/filter.h>
  12 #include <linux/bpf.h>
  13 #include <linux/fs.h>
  14 #include <linux/tracepoint.h>
  15
  16 #define __PROG_TYPE_MAP(FN)     \
  17         FN(SOCKET_FILTER)       \
  18         FN(KPROBE)              \
  19         FN(SCHED_CLS)           \
  20         FN(SCHED_ACT)           \
  21         FN(TRACEPOINT)          \
  22         FN(XDP)                 \
  23         FN(PERF_EVENT)          \
  24         FN(CGROUP_SKB)          \
  25         FN(CGROUP_SOCK)         \
  26         FN(LWT_IN)              \
  27         FN(LWT_OUT)             \
  28         FN(LWT_XMIT)
  29
  30 #define __MAP_TYPE_MAP(FN)      \
  31         FN(HASH)                \
  32         FN(ARRAY)               \
  33         FN(PROG_ARRAY)          \
  34         FN(PERF_EVENT_ARRAY)    \
  35         FN(PERCPU_HASH)         \
  36         FN(PERCPU_ARRAY)        \
  37         FN(STACK_TRACE)         \
  38         FN(CGROUP_ARRAY)        \
  39         FN(LRU_HASH)            \
  40         FN(LRU_PERCPU_HASH)     \
  41         FN(LPM_TRIE)
  42
  43 #define __PROG_TYPE_TP_FN(x)    \
  44         TRACE_DEFINE_ENUM(BPF_PROG_TYPE_##x);
  45 #define __PROG_TYPE_SYM_FN(x)   \
  46         { BPF_PROG_TYPE_##x, #x },
  47 #define __PROG_TYPE_SYM_TAB     \
  48         __PROG_TYPE_MAP(__PROG_TYPE_SYM_FN) { -1, 0 }
  49 __PROG_TYPE_MAP(__PROG_TYPE_TP_FN)
  50
  51 #define __MAP_TYPE_TP_FN(x)     \
  52         TRACE_DEFINE_ENUM(BPF_MAP_TYPE_##x);
  53 #define __MAP_TYPE_SYM_FN(x)    \
  54         { BPF_MAP_TYPE_##x, #x },
  55 #define __MAP_TYPE_SYM_TAB      \
  56         __MAP_TYPE_MAP(__MAP_TYPE_SYM_FN) { -1, 0 }
  57 __MAP_TYPE_MAP(__MAP_TYPE_TP_FN)
  58
  59 DECLARE_EVENT_CLASS(bpf_prog_event,
  60
  61         TP_PROTO(const struct bpf_prog *prg),
  62
  63         TP_ARGS(prg),
  64
  65         TP_STRUCT__entry(
  66                 __array(u8, prog_tag, 8)
  67                 __field(u32, type)
  68         ),
  69
  70         TP_fast_assign(
  71                 BUILD_BUG_ON(sizeof(__entry->prog_tag) != sizeof(prg->tag));
  72                 memcpy(__entry->prog_tag, prg->tag, sizeof(prg->tag));
  73                 __entry->type = prg->type;
  74         ),
  75
  76         TP_printk("prog=%s type=%s",
  77                   __print_hex_str(__entry->prog_tag, 8),
  78                   __print_symbolic(__entry->type, __PROG_TYPE_SYM_TAB))
  79 );
  80
  81 DEFINE_EVENT(bpf_prog_event, bpf_prog_get_type,
  82
  83         TP_PROTO(const struct bpf_prog *prg),
  84
  85         TP_ARGS(prg)
  86 );
  87
  88 DEFINE_EVENT(bpf_prog_event, bpf_prog_put_rcu,
  89
  90         TP_PROTO(const struct bpf_prog *prg),
  91
  92         TP_ARGS(prg)
  93 );
  94
  95 TRACE_EVENT(bpf_prog_load,
  96
  97         TP_PROTO(const struct bpf_prog *prg, int ufd),
  98
  99         TP_ARGS(prg, ufd),
 100
 101         TP_STRUCT__entry(
 102                 __array(u8, prog_tag, 8)
 103                 __field(u32, type)
 104                 __field(int, ufd)
 105         ),
 106
 107         TP_fast_assign(
 108                 BUILD_BUG_ON(sizeof(__entry->prog_tag) != sizeof(prg->tag));
 109                 memcpy(__entry->prog_tag, prg->tag, sizeof(prg->tag));
 110                 __entry->type = prg->type;
 111                 __entry->ufd  = ufd;
 112         ),
 113
 114         TP_printk("prog=%s type=%s ufd=%d",
 115                   __print_hex_str(__entry->prog_tag, 8),
 116                   __print_symbolic(__entry->type, __PROG_TYPE_SYM_TAB),
 117                   __entry->ufd)
 118 );
 119
 120 TRACE_EVENT(bpf_map_create,
 121
 122         TP_PROTO(const struct bpf_map *map, int ufd),
 123
 124         TP_ARGS(map, ufd),
 125
 126         TP_STRUCT__entry(
 127                 __field(u32, type)
 128                 __field(u32, size_key)
 129                 __field(u32, size_value)
 130                 __field(u32, max_entries)
 131                 __field(u32, flags)
 132                 __field(int, ufd)
 133         ),
 134
 135         TP_fast_assign(
 136                 __entry->type        = map->map_type;
 137                 __entry->size_key    = map->key_size;
 138                 __entry->size_value  = map->value_size;
 139                 __entry->max_entries = map->max_entries;
 140                 __entry->flags       = map->map_flags;
 141                 __entry->ufd         = ufd;
 142         ),
 143
 144         TP_printk("map type=%s ufd=%d key=%u val=%u max=%u flags=%x",
 145                   __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
 146                   __entry->ufd, __entry->size_key, __entry->size_value,
 147                   __entry->max_entries, __entry->flags)
 148 );
 149
 150 DECLARE_EVENT_CLASS(bpf_obj_prog,
 151
 152         TP_PROTO(const struct bpf_prog *prg, int ufd,
 153                  const struct filename *pname),
 154
 155         TP_ARGS(prg, ufd, pname),
 156
 157         TP_STRUCT__entry(
 158                 __array(u8, prog_tag, 8)
 159                 __field(int, ufd)
 160                 __string(path, pname->name)
 161         ),
 162
 163         TP_fast_assign(
 164                 BUILD_BUG_ON(sizeof(__entry->prog_tag) != sizeof(prg->tag));
 165                 memcpy(__entry->prog_tag, prg->tag, sizeof(prg->tag));
 166                 __assign_str(path, pname->name);
 167                 __entry->ufd = ufd;
 168         ),
 169
 170         TP_printk("prog=%s path=%s ufd=%d",
 171                   __print_hex_str(__entry->prog_tag, 8),
 172                   __get_str(path), __entry->ufd)
 173 );
 174
 175 DEFINE_EVENT(bpf_obj_prog, bpf_obj_pin_prog,
 176
 177         TP_PROTO(const struct bpf_prog *prg, int ufd,
 178                  const struct filename *pname),
 179
 180         TP_ARGS(prg, ufd, pname)
 181 );
 182
 183 DEFINE_EVENT(bpf_obj_prog, bpf_obj_get_prog,
 184
 185         TP_PROTO(const struct bpf_prog *prg, int ufd,
 186                  const struct filename *pname),
 187
 188         TP_ARGS(prg, ufd, pname)
 189 );
 190
 191 DECLARE_EVENT_CLASS(bpf_obj_map,
 192
 193         TP_PROTO(const struct bpf_map *map, int ufd,
 194                  const struct filename *pname),
 195
 196         TP_ARGS(map, ufd, pname),
 197
 198         TP_STRUCT__entry(
 199                 __field(u32, type)
 200                 __field(int, ufd)
 201                 __string(path, pname->name)
 202         ),
 203
 204         TP_fast_assign(
 205                 __assign_str(path, pname->name);
 206                 __entry->type = map->map_type;
 207                 __entry->ufd  = ufd;
 208         ),
 209
 210         TP_printk("map type=%s ufd=%d path=%s",
 211                   __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
 212                   __entry->ufd, __get_str(path))
 213 );
 214
 215 DEFINE_EVENT(bpf_obj_map, bpf_obj_pin_map,
 216
 217         TP_PROTO(const struct bpf_map *map, int ufd,
 218                  const struct filename *pname),
 219
 220         TP_ARGS(map, ufd, pname)
 221 );
 222
 223 DEFINE_EVENT(bpf_obj_map, bpf_obj_get_map,
 224
 225         TP_PROTO(const struct bpf_map *map, int ufd,
 226                  const struct filename *pname),
 227
 228         TP_ARGS(map, ufd, pname)
 229 );
 230
 231 DECLARE_EVENT_CLASS(bpf_map_keyval,
 232
 233         TP_PROTO(const struct bpf_map *map, int ufd,
 234                  const void *key, const void *val),
 235
 236         TP_ARGS(map, ufd, key, val),
 237
 238         TP_STRUCT__entry(
 239                 __field(u32, type)
 240                 __field(u32, key_len)
 241                 __dynamic_array(u8, key, map->key_size)
 242                 __field(bool, key_trunc)
 243                 __field(u32, val_len)
 244                 __dynamic_array(u8, val, map->value_size)
 245                 __field(bool, val_trunc)
 246                 __field(int, ufd)
 247         ),
 248
 249         TP_fast_assign(
 250                 memcpy(__get_dynamic_array(key), key, map->key_size);
 251                 memcpy(__get_dynamic_array(val), val, map->value_size);
 252                 __entry->type      = map->map_type;
 253                 __entry->key_len   = min(map->key_size, 16U);
 254                 __entry->key_trunc = map->key_size != __entry->key_len;
 255                 __entry->val_len   = min(map->value_size, 16U);
 256                 __entry->val_trunc = map->value_size != __entry->val_len;
 257                 __entry->ufd       = ufd;
 258         ),
 259
 260         TP_printk("map type=%s ufd=%d key=[%s%s] val=[%s%s]",
 261                   __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
 262                   __entry->ufd,
 263                   __print_hex(__get_dynamic_array(key), __entry->key_len),
 264                   __entry->key_trunc ? " ..." : "",
 265                   __print_hex(__get_dynamic_array(val), __entry->val_len),
 266                   __entry->val_trunc ? " ..." : "")
 267 );
 268
 269 DEFINE_EVENT(bpf_map_keyval, bpf_map_lookup_elem,
 270
 271         TP_PROTO(const struct bpf_map *map, int ufd,
 272                  const void *key, const void *val),
 273
 274         TP_ARGS(map, ufd, key, val)
 275 );
 276
 277 DEFINE_EVENT(bpf_map_keyval, bpf_map_update_elem,
 278
 279         TP_PROTO(const struct bpf_map *map, int ufd,
 280                  const void *key, const void *val),
 281
 282         TP_ARGS(map, ufd, key, val)
 283 );
 284
 285 TRACE_EVENT(bpf_map_delete_elem,
 286
 287         TP_PROTO(const struct bpf_map *map, int ufd,
 288                  const void *key),
 289
 290         TP_ARGS(map, ufd, key),
 291
 292         TP_STRUCT__entry(
 293                 __field(u32, type)
 294                 __field(u32, key_len)
 295                 __dynamic_array(u8, key, map->key_size)
 296                 __field(bool, key_trunc)
 297                 __field(int, ufd)
 298         ),
 299
 300         TP_fast_assign(
 301                 memcpy(__get_dynamic_array(key), key, map->key_size);
 302                 __entry->type      = map->map_type;
 303                 __entry->key_len   = min(map->key_size, 16U);
 304                 __entry->key_trunc = map->key_size != __entry->key_len;
 305                 __entry->ufd       = ufd;
 306         ),
 307
 308         TP_printk("map type=%s ufd=%d key=[%s%s]",
 309                   __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
 310                   __entry->ufd,
 311                   __print_hex(__get_dynamic_array(key), __entry->key_len),
 312                   __entry->key_trunc ? " ..." : "")
 313 );
 314
 315 TRACE_EVENT(bpf_map_next_key,
 316
 317         TP_PROTO(const struct bpf_map *map, int ufd,
 318                  const void *key, const void *key_next),
 319
 320         TP_ARGS(map, ufd, key, key_next),
 321
 322         TP_STRUCT__entry(
 323                 __field(u32, type)
 324                 __field(u32, key_len)
 325                 __dynamic_array(u8, key, map->key_size)
 326                 __dynamic_array(u8, nxt, map->key_size)
 327                 __field(bool, key_trunc)
 328                 __field(bool, key_null)
 329                 __field(int, ufd)
 330         ),
 331
 332         TP_fast_assign(
 333                 if (key)
 334                         memcpy(__get_dynamic_array(key), key, map->key_size);
 335                 __entry->key_null = !key;
 336                 memcpy(__get_dynamic_array(nxt), key_next, map->key_size);
 337                 __entry->type      = map->map_type;
 338                 __entry->key_len   = min(map->key_size, 16U);
 339                 __entry->key_trunc = map->key_size != __entry->key_len;
 340                 __entry->ufd       = ufd;
 341         ),
 342
 343         TP_printk("map type=%s ufd=%d key=[%s%s] next=[%s%s]",
 344                   __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
 345                   __entry->ufd,
 346                   __entry->key_null ? "NULL" : __print_hex(__get_dynamic_array(key),
 347                                                            __entry->key_len),
 348                   __entry->key_trunc && !__entry->key_null ? " ..." : "",
 349                   __print_hex(__get_dynamic_array(nxt), __entry->key_len),
 350                   __entry->key_trunc ? " ..." : "")
 351 );
 352 #endif /* CONFIG_BPF_SYSCALL */
 353 #endif /* _TRACE_BPF_H */
 354
 355 #include <trace/define_trace.h>