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