[mirror_ubuntu-bionic-kernel.git] / include / trace / events / bpf.h

/* SPDX-License-Identifier: GPL-2.0 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM bpf

#if !defined(_TRACE_BPF_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_BPF_H

/* These are only used within the BPF_SYSCALL code */
#ifdef CONFIG_BPF_SYSCALL

#include <linux/filter.h>
#include <linux/bpf.h>
#include <linux/fs.h>
#include <linux/tracepoint.h>

#define __PROG_TYPE_MAP(FN)	\
	FN(SOCKET_FILTER)	\
	FN(KPROBE)		\
	FN(SCHED_CLS)		\
	FN(SCHED_ACT)		\
	FN(TRACEPOINT)		\
	FN(XDP)			\
	FN(PERF_EVENT)		\
	FN(CGROUP_SKB)		\
	FN(CGROUP_SOCK)		\
	FN(LWT_IN)		\
	FN(LWT_OUT)		\
	FN(LWT_XMIT)

#define __MAP_TYPE_MAP(FN)	\
	FN(HASH)		\
	FN(ARRAY)		\
	FN(PROG_ARRAY)		\
	FN(PERF_EVENT_ARRAY)	\
	FN(PERCPU_HASH)		\
	FN(PERCPU_ARRAY)	\
	FN(STACK_TRACE)		\
	FN(CGROUP_ARRAY)	\
	FN(LRU_HASH)		\
	FN(LRU_PERCPU_HASH)	\
	FN(LPM_TRIE)

#define __PROG_TYPE_TP_FN(x)	\
	TRACE_DEFINE_ENUM(BPF_PROG_TYPE_##x);
#define __PROG_TYPE_SYM_FN(x)	\
	{ BPF_PROG_TYPE_##x, #x },
#define __PROG_TYPE_SYM_TAB	\
	__PROG_TYPE_MAP(__PROG_TYPE_SYM_FN) { -1, 0 }
__PROG_TYPE_MAP(__PROG_TYPE_TP_FN)

#define __MAP_TYPE_TP_FN(x)	\
	TRACE_DEFINE_ENUM(BPF_MAP_TYPE_##x);
#define __MAP_TYPE_SYM_FN(x)	\
	{ BPF_MAP_TYPE_##x, #x },
#define __MAP_TYPE_SYM_TAB	\
	__MAP_TYPE_MAP(__MAP_TYPE_SYM_FN) { -1, 0 }
__MAP_TYPE_MAP(__MAP_TYPE_TP_FN)

DECLARE_EVENT_CLASS(bpf_prog_event,

	TP_PROTO(const struct bpf_prog *prg),

	TP_ARGS(prg),

	TP_STRUCT__entry(
		__array(u8, prog_tag, 8)
		__field(u32, type)
	),

	TP_fast_assign(
		BUILD_BUG_ON(sizeof(__entry->prog_tag) != sizeof(prg->tag));
		memcpy(__entry->prog_tag, prg->tag, sizeof(prg->tag));
		__entry->type = prg->type;
	),

	TP_printk("prog=%s type=%s",
		  __print_hex_str(__entry->prog_tag, 8),
		  __print_symbolic(__entry->type, __PROG_TYPE_SYM_TAB))
);

DEFINE_EVENT(bpf_prog_event, bpf_prog_get_type,

	TP_PROTO(const struct bpf_prog *prg),

	TP_ARGS(prg)
);

DEFINE_EVENT(bpf_prog_event, bpf_prog_put_rcu,

	TP_PROTO(const struct bpf_prog *prg),

	TP_ARGS(prg)
);

TRACE_EVENT(bpf_prog_load,

	TP_PROTO(const struct bpf_prog *prg, int ufd),

	TP_ARGS(prg, ufd),

	TP_STRUCT__entry(
		__array(u8, prog_tag, 8)
		__field(u32, type)
		__field(int, ufd)
	),

	TP_fast_assign(
		BUILD_BUG_ON(sizeof(__entry->prog_tag) != sizeof(prg->tag));
		memcpy(__entry->prog_tag, prg->tag, sizeof(prg->tag));
		__entry->type = prg->type;
		__entry->ufd  = ufd;
	),

	TP_printk("prog=%s type=%s ufd=%d",
		  __print_hex_str(__entry->prog_tag, 8),
		  __print_symbolic(__entry->type, __PROG_TYPE_SYM_TAB),
		  __entry->ufd)
);

TRACE_EVENT(bpf_map_create,

	TP_PROTO(const struct bpf_map *map, int ufd),

	TP_ARGS(map, ufd),

	TP_STRUCT__entry(
		__field(u32, type)
		__field(u32, size_key)
		__field(u32, size_value)
		__field(u32, max_entries)
		__field(u32, flags)
		__field(int, ufd)
	),

	TP_fast_assign(
		__entry->type        = map->map_type;
		__entry->size_key    = map->key_size;
		__entry->size_value  = map->value_size;
		__entry->max_entries = map->max_entries;
		__entry->flags       = map->map_flags;
		__entry->ufd         = ufd;
	),

	TP_printk("map type=%s ufd=%d key=%u val=%u max=%u flags=%x",
		  __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
		  __entry->ufd, __entry->size_key, __entry->size_value,
		  __entry->max_entries, __entry->flags)
);

DECLARE_EVENT_CLASS(bpf_obj_prog,

	TP_PROTO(const struct bpf_prog *prg, int ufd,
		 const struct filename *pname),

	TP_ARGS(prg, ufd, pname),

	TP_STRUCT__entry(
		__array(u8, prog_tag, 8)
		__field(int, ufd)
		__string(path, pname->name)
	),

	TP_fast_assign(
		BUILD_BUG_ON(sizeof(__entry->prog_tag) != sizeof(prg->tag));
		memcpy(__entry->prog_tag, prg->tag, sizeof(prg->tag));
		__assign_str(path, pname->name);
		__entry->ufd = ufd;
	),

	TP_printk("prog=%s path=%s ufd=%d",
		  __print_hex_str(__entry->prog_tag, 8),
		  __get_str(path), __entry->ufd)
);

DEFINE_EVENT(bpf_obj_prog, bpf_obj_pin_prog,

	TP_PROTO(const struct bpf_prog *prg, int ufd,
		 const struct filename *pname),

	TP_ARGS(prg, ufd, pname)
);

DEFINE_EVENT(bpf_obj_prog, bpf_obj_get_prog,

	TP_PROTO(const struct bpf_prog *prg, int ufd,
		 const struct filename *pname),

	TP_ARGS(prg, ufd, pname)
);

DECLARE_EVENT_CLASS(bpf_obj_map,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const struct filename *pname),

	TP_ARGS(map, ufd, pname),

	TP_STRUCT__entry(
		__field(u32, type)
		__field(int, ufd)
		__string(path, pname->name)
	),

	TP_fast_assign(
		__assign_str(path, pname->name);
		__entry->type = map->map_type;
		__entry->ufd  = ufd;
	),

	TP_printk("map type=%s ufd=%d path=%s",
		  __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
		  __entry->ufd, __get_str(path))
);

DEFINE_EVENT(bpf_obj_map, bpf_obj_pin_map,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const struct filename *pname),

	TP_ARGS(map, ufd, pname)
);

DEFINE_EVENT(bpf_obj_map, bpf_obj_get_map,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const struct filename *pname),

	TP_ARGS(map, ufd, pname)
);

DECLARE_EVENT_CLASS(bpf_map_keyval,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const void *key, const void *val),

	TP_ARGS(map, ufd, key, val),

	TP_STRUCT__entry(
		__field(u32, type)
		__field(u32, key_len)
		__dynamic_array(u8, key, map->key_size)
		__field(bool, key_trunc)
		__field(u32, val_len)
		__dynamic_array(u8, val, map->value_size)
		__field(bool, val_trunc)
		__field(int, ufd)
	),

	TP_fast_assign(
		memcpy(__get_dynamic_array(key), key, map->key_size);
		memcpy(__get_dynamic_array(val), val, map->value_size);
		__entry->type      = map->map_type;
		__entry->key_len   = min(map->key_size, 16U);
		__entry->key_trunc = map->key_size != __entry->key_len;
		__entry->val_len   = min(map->value_size, 16U);
		__entry->val_trunc = map->value_size != __entry->val_len;
		__entry->ufd       = ufd;
	),

	TP_printk("map type=%s ufd=%d key=[%s%s] val=[%s%s]",
		  __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
		  __entry->ufd,
		  __print_hex(__get_dynamic_array(key), __entry->key_len),
		  __entry->key_trunc ? " ..." : "",
		  __print_hex(__get_dynamic_array(val), __entry->val_len),
		  __entry->val_trunc ? " ..." : "")
);

DEFINE_EVENT(bpf_map_keyval, bpf_map_lookup_elem,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const void *key, const void *val),

	TP_ARGS(map, ufd, key, val)
);

DEFINE_EVENT(bpf_map_keyval, bpf_map_update_elem,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const void *key, const void *val),

	TP_ARGS(map, ufd, key, val)
);

TRACE_EVENT(bpf_map_delete_elem,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const void *key),

	TP_ARGS(map, ufd, key),

	TP_STRUCT__entry(
		__field(u32, type)
		__field(u32, key_len)
		__dynamic_array(u8, key, map->key_size)
		__field(bool, key_trunc)
		__field(int, ufd)
	),

	TP_fast_assign(
		memcpy(__get_dynamic_array(key), key, map->key_size);
		__entry->type      = map->map_type;
		__entry->key_len   = min(map->key_size, 16U);
		__entry->key_trunc = map->key_size != __entry->key_len;
		__entry->ufd       = ufd;
	),

	TP_printk("map type=%s ufd=%d key=[%s%s]",
		  __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
		  __entry->ufd,
		  __print_hex(__get_dynamic_array(key), __entry->key_len),
		  __entry->key_trunc ? " ..." : "")
);

TRACE_EVENT(bpf_map_next_key,

	TP_PROTO(const struct bpf_map *map, int ufd,
		 const void *key, const void *key_next),

	TP_ARGS(map, ufd, key, key_next),

	TP_STRUCT__entry(
		__field(u32, type)
		__field(u32, key_len)
		__dynamic_array(u8, key, map->key_size)
		__dynamic_array(u8, nxt, map->key_size)
		__field(bool, key_trunc)
		__field(bool, key_null)
		__field(int, ufd)
	),

	TP_fast_assign(
		if (key)
			memcpy(__get_dynamic_array(key), key, map->key_size);
		__entry->key_null = !key;
		memcpy(__get_dynamic_array(nxt), key_next, map->key_size);
		__entry->type      = map->map_type;
		__entry->key_len   = min(map->key_size, 16U);
		__entry->key_trunc = map->key_size != __entry->key_len;
		__entry->ufd       = ufd;
	),

	TP_printk("map type=%s ufd=%d key=[%s%s] next=[%s%s]",
		  __print_symbolic(__entry->type, __MAP_TYPE_SYM_TAB),
		  __entry->ufd,
		  __entry->key_null ? "NULL" : __print_hex(__get_dynamic_array(key),
							   __entry->key_len),
		  __entry->key_trunc && !__entry->key_null ? " ..." : "",
		  __print_hex(__get_dynamic_array(nxt), __entry->key_len),
		  __entry->key_trunc ? " ..." : "")
);
#endif /* CONFIG_BPF_SYSCALL */
#endif /* _TRACE_BPF_H */

#include <trace/define_trace.h>
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
a67edbf4 DB	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
9185a610 SRV	8	/* These are only used within the BPF_SYSCALL code */
	9	#ifdef CONFIG_BPF_SYSCALL
	10
a67edbf4 DB	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)
8fe45924	328	__field(bool, key_null)
a67edbf4 DB	329	__field(int, ufd)
	330	),
	331
	332	TP_fast_assign(
8fe45924 TQ	333	if (key)
	334	memcpy(__get_dynamic_array(key), key, map->key_size);
	335	__entry->key_null = !key;
a67edbf4 DB	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,
8fe45924 TQ	346	__entry->key_null ? "NULL" : __print_hex(__get_dynamic_array(key),
	347	__entry->key_len),
	348	__entry->key_trunc && !__entry->key_null ? " ..." : "",
a67edbf4 DB	349	__print_hex(__get_dynamic_array(nxt), __entry->key_len),
	350	__entry->key_trunc ? " ..." : "")
	351	);
9185a610	352	#endif /* CONFIG_BPF_SYSCALL */
a67edbf4 DB	353	#endif /* _TRACE_BPF_H */
	354
	355	#include <trace/define_trace.h>