[linux-block.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

#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 /* _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
	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)
8fe45924	325	__field(bool, key_null)
a67edbf4 DB	326	__field(int, ufd)
	327	),
	328
	329	TP_fast_assign(
8fe45924 TQ	330	if (key)
	331	memcpy(__get_dynamic_array(key), key, map->key_size);
	332	__entry->key_null = !key;
a67edbf4 DB	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,
8fe45924 TQ	343	__entry->key_null ? "NULL" : __print_hex(__get_dynamic_array(key),
	344	__entry->key_len),
	345	__entry->key_trunc && !__entry->key_null ? " ..." : "",
a67edbf4 DB	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>