include/trace/events/bpf.h at v4.16-rc4

tjh.dev / kernel
fork
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork
kernel / include / trace / events / bpf.h
at v4.16-rc4 355 lines 8.4 kB view raw
wrap content
  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
 59DECLARE_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
 81DEFINE_EVENT(bpf_prog_event, bpf_prog_get_type,
 82
 83	TP_PROTO(const struct bpf_prog *prg),
 84
 85	TP_ARGS(prg)
 86);
 87
 88DEFINE_EVENT(bpf_prog_event, bpf_prog_put_rcu,
 89
 90	TP_PROTO(const struct bpf_prog *prg),
 91
 92	TP_ARGS(prg)
 93);
 94
 95TRACE_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
120TRACE_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
150DECLARE_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
175DEFINE_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
183DEFINE_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
191DECLARE_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
215DEFINE_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
223DEFINE_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
231DECLARE_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
269DEFINE_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
277DEFINE_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
285TRACE_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
315TRACE_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>
Configure Feed

Configure Feed
