1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* Copyright (c) 2018 Facebook */
3 
4 #ifndef _LINUX_BTF_H
5 #define _LINUX_BTF_H 1
6 
7 #include <linux/types.h>
8 #include <linux/bpfptr.h>
9 #include <linux/bsearch.h>
10 #include <linux/btf_ids.h>
11 #include <uapi/linux/btf.h>
12 #include <uapi/linux/bpf.h>
13 
14 #define BTF_TYPE_EMIT(type) ((void)(type *)0)
15 #define BTF_TYPE_EMIT_ENUM(enum_val) ((void)enum_val)
16 
17 /* These need to be macros, as the expressions are used in assembler input */
18 #define KF_ACQUIRE	(1 << 0) /* kfunc is an acquire function */
19 #define KF_RELEASE	(1 << 1) /* kfunc is a release function */
20 #define KF_RET_NULL	(1 << 2) /* kfunc returns a pointer that may be NULL */
21 /* Trusted arguments are those which are guaranteed to be valid when passed to
22  * the kfunc. It is used to enforce that pointers obtained from either acquire
23  * kfuncs, or from the main kernel on a tracepoint or struct_ops callback
24  * invocation, remain unmodified when being passed to helpers taking trusted
25  * args.
26  *
27  * Consider, for example, the following new task tracepoint:
28  *
29  *	SEC("tp_btf/task_newtask")
30  *	int BPF_PROG(new_task_tp, struct task_struct *task, u64 clone_flags)
31  *	{
32  *		...
33  *	}
34  *
35  * And the following kfunc:
36  *
37  *	BTF_ID_FLAGS(func, bpf_task_acquire, KF_ACQUIRE | KF_TRUSTED_ARGS)
38  *
39  * All invocations to the kfunc must pass the unmodified, unwalked task:
40  *
41  *	bpf_task_acquire(task);		    // Allowed
42  *	bpf_task_acquire(task->last_wakee); // Rejected, walked task
43  *
44  * Programs may also pass referenced tasks directly to the kfunc:
45  *
46  *	struct task_struct *acquired;
47  *
48  *	acquired = bpf_task_acquire(task);	// Allowed, same as above
49  *	bpf_task_acquire(acquired);		// Allowed
50  *	bpf_task_acquire(task);			// Allowed
51  *	bpf_task_acquire(acquired->last_wakee); // Rejected, walked task
52  *
53  * Programs may _not_, however, pass a task from an arbitrary fentry/fexit, or
54  * kprobe/kretprobe to the kfunc, as BPF cannot guarantee that all of these
55  * pointers are guaranteed to be safe. For example, the following BPF program
56  * would be rejected:
57  *
58  * SEC("kretprobe/free_task")
59  * int BPF_PROG(free_task_probe, struct task_struct *tsk)
60  * {
61  *	struct task_struct *acquired;
62  *
63  *	acquired = bpf_task_acquire(acquired); // Rejected, not a trusted pointer
64  *	bpf_task_release(acquired);
65  *
66  *	return 0;
67  * }
68  */
69 #define KF_TRUSTED_ARGS (1 << 4) /* kfunc only takes trusted pointer arguments */
70 #define KF_SLEEPABLE    (1 << 5) /* kfunc may sleep */
71 #define KF_DESTRUCTIVE  (1 << 6) /* kfunc performs destructive actions */
72 #define KF_RCU          (1 << 7) /* kfunc takes either rcu or trusted pointer arguments */
73 /* only one of KF_ITER_{NEW,NEXT,DESTROY} could be specified per kfunc */
74 #define KF_ITER_NEW     (1 << 8) /* kfunc implements BPF iter constructor */
75 #define KF_ITER_NEXT    (1 << 9) /* kfunc implements BPF iter next method */
76 #define KF_ITER_DESTROY (1 << 10) /* kfunc implements BPF iter destructor */
77 
78 /*
79  * Tag marking a kernel function as a kfunc. This is meant to minimize the
80  * amount of copy-paste that kfunc authors have to include for correctness so
81  * as to avoid issues such as the compiler inlining or eliding either a static
82  * kfunc, or a global kfunc in an LTO build.
83  */
84 #define __bpf_kfunc __used noinline
85 
86 /*
87  * Return the name of the passed struct, if exists, or halt the build if for
88  * example the structure gets renamed. In this way, developers have to revisit
89  * the code using that structure name, and update it accordingly.
90  */
91 #define stringify_struct(x)			\
92 	({ BUILD_BUG_ON(sizeof(struct x) < 0);	\
93 	   __stringify(x); })
94 
95 struct btf;
96 struct btf_member;
97 struct btf_type;
98 union bpf_attr;
99 struct btf_show;
100 struct btf_id_set;
101 struct bpf_prog;
102 
103 typedef int (*btf_kfunc_filter_t)(const struct bpf_prog *prog, u32 kfunc_id);
104 
105 struct btf_kfunc_id_set {
106 	struct module *owner;
107 	struct btf_id_set8 *set;
108 	btf_kfunc_filter_t filter;
109 };
110 
111 struct btf_id_dtor_kfunc {
112 	u32 btf_id;
113 	u32 kfunc_btf_id;
114 };
115 
116 struct btf_struct_meta {
117 	u32 btf_id;
118 	struct btf_record *record;
119 };
120 
121 struct btf_struct_metas {
122 	u32 cnt;
123 	struct btf_struct_meta types[];
124 };
125 
126 extern const struct file_operations btf_fops;
127 
128 void btf_get(struct btf *btf);
129 void btf_put(struct btf *btf);
130 int btf_new_fd(const union bpf_attr *attr, bpfptr_t uattr, u32 uattr_sz);
131 struct btf *btf_get_by_fd(int fd);
132 int btf_get_info_by_fd(const struct btf *btf,
133 		       const union bpf_attr *attr,
134 		       union bpf_attr __user *uattr);
135 /* Figure out the size of a type_id.  If type_id is a modifier
136  * (e.g. const), it will be resolved to find out the type with size.
137  *
138  * For example:
139  * In describing "const void *",  type_id is "const" and "const"
140  * refers to "void *".  The return type will be "void *".
141  *
142  * If type_id is a simple "int", then return type will be "int".
143  *
144  * @btf: struct btf object
145  * @type_id: Find out the size of type_id. The type_id of the return
146  *           type is set to *type_id.
147  * @ret_size: It can be NULL.  If not NULL, the size of the return
148  *            type is set to *ret_size.
149  * Return: The btf_type (resolved to another type with size info if needed).
150  *         NULL is returned if type_id itself does not have size info
151  *         (e.g. void) or it cannot be resolved to another type that
152  *         has size info.
153  *         *type_id and *ret_size will not be changed in the
154  *         NULL return case.
155  */
156 const struct btf_type *btf_type_id_size(const struct btf *btf,
157 					u32 *type_id,
158 					u32 *ret_size);
159 
160 /*
161  * Options to control show behaviour.
162  *	- BTF_SHOW_COMPACT: no formatting around type information
163  *	- BTF_SHOW_NONAME: no struct/union member names/types
164  *	- BTF_SHOW_PTR_RAW: show raw (unobfuscated) pointer values;
165  *	  equivalent to %px.
166  *	- BTF_SHOW_ZERO: show zero-valued struct/union members; they
167  *	  are not displayed by default
168  *	- BTF_SHOW_UNSAFE: skip use of bpf_probe_read() to safely read
169  *	  data before displaying it.
170  */
171 #define BTF_SHOW_COMPACT	BTF_F_COMPACT
172 #define BTF_SHOW_NONAME		BTF_F_NONAME
173 #define BTF_SHOW_PTR_RAW	BTF_F_PTR_RAW
174 #define BTF_SHOW_ZERO		BTF_F_ZERO
175 #define BTF_SHOW_UNSAFE		(1ULL << 4)
176 
177 void btf_type_seq_show(const struct btf *btf, u32 type_id, void *obj,
178 		       struct seq_file *m);
179 int btf_type_seq_show_flags(const struct btf *btf, u32 type_id, void *obj,
180 			    struct seq_file *m, u64 flags);
181 
182 /*
183  * Copy len bytes of string representation of obj of BTF type_id into buf.
184  *
185  * @btf: struct btf object
186  * @type_id: type id of type obj points to
187  * @obj: pointer to typed data
188  * @buf: buffer to write to
189  * @len: maximum length to write to buf
190  * @flags: show options (see above)
191  *
192  * Return: length that would have been/was copied as per snprintf, or
193  *	   negative error.
194  */
195 int btf_type_snprintf_show(const struct btf *btf, u32 type_id, void *obj,
196 			   char *buf, int len, u64 flags);
197 
198 int btf_get_fd_by_id(u32 id);
199 u32 btf_obj_id(const struct btf *btf);
200 bool btf_is_kernel(const struct btf *btf);
201 bool btf_is_module(const struct btf *btf);
202 struct module *btf_try_get_module(const struct btf *btf);
203 u32 btf_nr_types(const struct btf *btf);
204 bool btf_member_is_reg_int(const struct btf *btf, const struct btf_type *s,
205 			   const struct btf_member *m,
206 			   u32 expected_offset, u32 expected_size);
207 struct btf_record *btf_parse_fields(const struct btf *btf, const struct btf_type *t,
208 				    u32 field_mask, u32 value_size);
209 int btf_check_and_fixup_fields(const struct btf *btf, struct btf_record *rec);
210 bool btf_type_is_void(const struct btf_type *t);
211 s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind);
212 s32 bpf_find_btf_id(const char *name, u32 kind, struct btf **btf_p);
213 const struct btf_type *btf_type_skip_modifiers(const struct btf *btf,
214 					       u32 id, u32 *res_id);
215 const struct btf_type *btf_type_resolve_ptr(const struct btf *btf,
216 					    u32 id, u32 *res_id);
217 const struct btf_type *btf_type_resolve_func_ptr(const struct btf *btf,
218 						 u32 id, u32 *res_id);
219 const struct btf_type *
220 btf_resolve_size(const struct btf *btf, const struct btf_type *type,
221 		 u32 *type_size);
222 const char *btf_type_str(const struct btf_type *t);
223 
224 #define for_each_member(i, struct_type, member)			\
225 	for (i = 0, member = btf_type_member(struct_type);	\
226 	     i < btf_type_vlen(struct_type);			\
227 	     i++, member++)
228 
229 #define for_each_vsi(i, datasec_type, member)			\
230 	for (i = 0, member = btf_type_var_secinfo(datasec_type);	\
231 	     i < btf_type_vlen(datasec_type);			\
232 	     i++, member++)
233 
btf_type_is_ptr(const struct btf_type * t)234 static inline bool btf_type_is_ptr(const struct btf_type *t)
235 {
236 	return BTF_INFO_KIND(t->info) == BTF_KIND_PTR;
237 }
238 
btf_type_is_int(const struct btf_type * t)239 static inline bool btf_type_is_int(const struct btf_type *t)
240 {
241 	return BTF_INFO_KIND(t->info) == BTF_KIND_INT;
242 }
243 
btf_type_is_small_int(const struct btf_type * t)244 static inline bool btf_type_is_small_int(const struct btf_type *t)
245 {
246 	return btf_type_is_int(t) && t->size <= sizeof(u64);
247 }
248 
btf_int_encoding(const struct btf_type * t)249 static inline u8 btf_int_encoding(const struct btf_type *t)
250 {
251 	return BTF_INT_ENCODING(*(u32 *)(t + 1));
252 }
253 
btf_type_is_signed_int(const struct btf_type * t)254 static inline bool btf_type_is_signed_int(const struct btf_type *t)
255 {
256 	return btf_type_is_int(t) && (btf_int_encoding(t) & BTF_INT_SIGNED);
257 }
258 
btf_type_is_enum(const struct btf_type * t)259 static inline bool btf_type_is_enum(const struct btf_type *t)
260 {
261 	return BTF_INFO_KIND(t->info) == BTF_KIND_ENUM;
262 }
263 
btf_is_any_enum(const struct btf_type * t)264 static inline bool btf_is_any_enum(const struct btf_type *t)
265 {
266 	return BTF_INFO_KIND(t->info) == BTF_KIND_ENUM ||
267 	       BTF_INFO_KIND(t->info) == BTF_KIND_ENUM64;
268 }
269 
btf_kind_core_compat(const struct btf_type * t1,const struct btf_type * t2)270 static inline bool btf_kind_core_compat(const struct btf_type *t1,
271 					const struct btf_type *t2)
272 {
273 	return BTF_INFO_KIND(t1->info) == BTF_INFO_KIND(t2->info) ||
274 	       (btf_is_any_enum(t1) && btf_is_any_enum(t2));
275 }
276 
str_is_empty(const char * s)277 static inline bool str_is_empty(const char *s)
278 {
279 	return !s || !s[0];
280 }
281 
btf_kind(const struct btf_type * t)282 static inline u16 btf_kind(const struct btf_type *t)
283 {
284 	return BTF_INFO_KIND(t->info);
285 }
286 
btf_is_enum(const struct btf_type * t)287 static inline bool btf_is_enum(const struct btf_type *t)
288 {
289 	return btf_kind(t) == BTF_KIND_ENUM;
290 }
291 
btf_is_enum64(const struct btf_type * t)292 static inline bool btf_is_enum64(const struct btf_type *t)
293 {
294 	return btf_kind(t) == BTF_KIND_ENUM64;
295 }
296 
btf_enum64_value(const struct btf_enum64 * e)297 static inline u64 btf_enum64_value(const struct btf_enum64 *e)
298 {
299 	return ((u64)e->val_hi32 << 32) | e->val_lo32;
300 }
301 
btf_is_composite(const struct btf_type * t)302 static inline bool btf_is_composite(const struct btf_type *t)
303 {
304 	u16 kind = btf_kind(t);
305 
306 	return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;
307 }
308 
btf_is_array(const struct btf_type * t)309 static inline bool btf_is_array(const struct btf_type *t)
310 {
311 	return btf_kind(t) == BTF_KIND_ARRAY;
312 }
313 
btf_is_int(const struct btf_type * t)314 static inline bool btf_is_int(const struct btf_type *t)
315 {
316 	return btf_kind(t) == BTF_KIND_INT;
317 }
318 
btf_is_ptr(const struct btf_type * t)319 static inline bool btf_is_ptr(const struct btf_type *t)
320 {
321 	return btf_kind(t) == BTF_KIND_PTR;
322 }
323 
btf_int_offset(const struct btf_type * t)324 static inline u8 btf_int_offset(const struct btf_type *t)
325 {
326 	return BTF_INT_OFFSET(*(u32 *)(t + 1));
327 }
328 
btf_type_is_scalar(const struct btf_type * t)329 static inline bool btf_type_is_scalar(const struct btf_type *t)
330 {
331 	return btf_type_is_int(t) || btf_type_is_enum(t);
332 }
333 
btf_type_is_typedef(const struct btf_type * t)334 static inline bool btf_type_is_typedef(const struct btf_type *t)
335 {
336 	return BTF_INFO_KIND(t->info) == BTF_KIND_TYPEDEF;
337 }
338 
btf_type_is_volatile(const struct btf_type * t)339 static inline bool btf_type_is_volatile(const struct btf_type *t)
340 {
341 	return BTF_INFO_KIND(t->info) == BTF_KIND_VOLATILE;
342 }
343 
btf_type_is_func(const struct btf_type * t)344 static inline bool btf_type_is_func(const struct btf_type *t)
345 {
346 	return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC;
347 }
348 
btf_type_is_func_proto(const struct btf_type * t)349 static inline bool btf_type_is_func_proto(const struct btf_type *t)
350 {
351 	return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC_PROTO;
352 }
353 
btf_type_is_var(const struct btf_type * t)354 static inline bool btf_type_is_var(const struct btf_type *t)
355 {
356 	return BTF_INFO_KIND(t->info) == BTF_KIND_VAR;
357 }
358 
btf_type_is_type_tag(const struct btf_type * t)359 static inline bool btf_type_is_type_tag(const struct btf_type *t)
360 {
361 	return BTF_INFO_KIND(t->info) == BTF_KIND_TYPE_TAG;
362 }
363 
364 /* union is only a special case of struct:
365  * all its offsetof(member) == 0
366  */
btf_type_is_struct(const struct btf_type * t)367 static inline bool btf_type_is_struct(const struct btf_type *t)
368 {
369 	u8 kind = BTF_INFO_KIND(t->info);
370 
371 	return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;
372 }
373 
__btf_type_is_struct(const struct btf_type * t)374 static inline bool __btf_type_is_struct(const struct btf_type *t)
375 {
376 	return BTF_INFO_KIND(t->info) == BTF_KIND_STRUCT;
377 }
378 
btf_type_is_array(const struct btf_type * t)379 static inline bool btf_type_is_array(const struct btf_type *t)
380 {
381 	return BTF_INFO_KIND(t->info) == BTF_KIND_ARRAY;
382 }
383 
btf_type_vlen(const struct btf_type * t)384 static inline u16 btf_type_vlen(const struct btf_type *t)
385 {
386 	return BTF_INFO_VLEN(t->info);
387 }
388 
btf_vlen(const struct btf_type * t)389 static inline u16 btf_vlen(const struct btf_type *t)
390 {
391 	return btf_type_vlen(t);
392 }
393 
btf_func_linkage(const struct btf_type * t)394 static inline u16 btf_func_linkage(const struct btf_type *t)
395 {
396 	return BTF_INFO_VLEN(t->info);
397 }
398 
btf_type_kflag(const struct btf_type * t)399 static inline bool btf_type_kflag(const struct btf_type *t)
400 {
401 	return BTF_INFO_KFLAG(t->info);
402 }
403 
__btf_member_bit_offset(const struct btf_type * struct_type,const struct btf_member * member)404 static inline u32 __btf_member_bit_offset(const struct btf_type *struct_type,
405 					  const struct btf_member *member)
406 {
407 	return btf_type_kflag(struct_type) ? BTF_MEMBER_BIT_OFFSET(member->offset)
408 					   : member->offset;
409 }
410 
__btf_member_bitfield_size(const struct btf_type * struct_type,const struct btf_member * member)411 static inline u32 __btf_member_bitfield_size(const struct btf_type *struct_type,
412 					     const struct btf_member *member)
413 {
414 	return btf_type_kflag(struct_type) ? BTF_MEMBER_BITFIELD_SIZE(member->offset)
415 					   : 0;
416 }
417 
btf_members(const struct btf_type * t)418 static inline struct btf_member *btf_members(const struct btf_type *t)
419 {
420 	return (struct btf_member *)(t + 1);
421 }
422 
btf_member_bit_offset(const struct btf_type * t,u32 member_idx)423 static inline u32 btf_member_bit_offset(const struct btf_type *t, u32 member_idx)
424 {
425 	const struct btf_member *m = btf_members(t) + member_idx;
426 
427 	return __btf_member_bit_offset(t, m);
428 }
429 
btf_member_bitfield_size(const struct btf_type * t,u32 member_idx)430 static inline u32 btf_member_bitfield_size(const struct btf_type *t, u32 member_idx)
431 {
432 	const struct btf_member *m = btf_members(t) + member_idx;
433 
434 	return __btf_member_bitfield_size(t, m);
435 }
436 
btf_type_member(const struct btf_type * t)437 static inline const struct btf_member *btf_type_member(const struct btf_type *t)
438 {
439 	return (const struct btf_member *)(t + 1);
440 }
441 
btf_array(const struct btf_type * t)442 static inline struct btf_array *btf_array(const struct btf_type *t)
443 {
444 	return (struct btf_array *)(t + 1);
445 }
446 
btf_enum(const struct btf_type * t)447 static inline struct btf_enum *btf_enum(const struct btf_type *t)
448 {
449 	return (struct btf_enum *)(t + 1);
450 }
451 
btf_enum64(const struct btf_type * t)452 static inline struct btf_enum64 *btf_enum64(const struct btf_type *t)
453 {
454 	return (struct btf_enum64 *)(t + 1);
455 }
456 
btf_type_var_secinfo(const struct btf_type * t)457 static inline const struct btf_var_secinfo *btf_type_var_secinfo(
458 		const struct btf_type *t)
459 {
460 	return (const struct btf_var_secinfo *)(t + 1);
461 }
462 
btf_params(const struct btf_type * t)463 static inline struct btf_param *btf_params(const struct btf_type *t)
464 {
465 	return (struct btf_param *)(t + 1);
466 }
467 
btf_id_cmp_func(const void * a,const void * b)468 static inline int btf_id_cmp_func(const void *a, const void *b)
469 {
470 	const int *pa = a, *pb = b;
471 
472 	return *pa - *pb;
473 }
474 
btf_id_set_contains(const struct btf_id_set * set,u32 id)475 static inline bool btf_id_set_contains(const struct btf_id_set *set, u32 id)
476 {
477 	return bsearch(&id, set->ids, set->cnt, sizeof(u32), btf_id_cmp_func) != NULL;
478 }
479 
btf_id_set8_contains(const struct btf_id_set8 * set,u32 id)480 static inline void *btf_id_set8_contains(const struct btf_id_set8 *set, u32 id)
481 {
482 	return bsearch(&id, set->pairs, set->cnt, sizeof(set->pairs[0]), btf_id_cmp_func);
483 }
484 
485 struct bpf_verifier_log;
486 
487 #ifdef CONFIG_BPF_SYSCALL
488 const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id);
489 const char *btf_name_by_offset(const struct btf *btf, u32 offset);
490 struct btf *btf_parse_vmlinux(void);
491 struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog);
492 u32 *btf_kfunc_id_set_contains(const struct btf *btf, u32 kfunc_btf_id,
493 			       const struct bpf_prog *prog);
494 u32 *btf_kfunc_is_modify_return(const struct btf *btf, u32 kfunc_btf_id,
495 				const struct bpf_prog *prog);
496 int register_btf_kfunc_id_set(enum bpf_prog_type prog_type,
497 			      const struct btf_kfunc_id_set *s);
498 int register_btf_fmodret_id_set(const struct btf_kfunc_id_set *kset);
499 s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id);
500 int register_btf_id_dtor_kfuncs(const struct btf_id_dtor_kfunc *dtors, u32 add_cnt,
501 				struct module *owner);
502 struct btf_struct_meta *btf_find_struct_meta(const struct btf *btf, u32 btf_id);
503 const struct btf_member *
504 btf_get_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,
505 		      const struct btf_type *t, enum bpf_prog_type prog_type,
506 		      int arg);
507 int get_kern_ctx_btf_id(struct bpf_verifier_log *log, enum bpf_prog_type prog_type);
508 bool btf_types_are_same(const struct btf *btf1, u32 id1,
509 			const struct btf *btf2, u32 id2);
510 #else
btf_type_by_id(const struct btf * btf,u32 type_id)511 static inline const struct btf_type *btf_type_by_id(const struct btf *btf,
512 						    u32 type_id)
513 {
514 	return NULL;
515 }
btf_name_by_offset(const struct btf * btf,u32 offset)516 static inline const char *btf_name_by_offset(const struct btf *btf,
517 					     u32 offset)
518 {
519 	return NULL;
520 }
btf_kfunc_id_set_contains(const struct btf * btf,u32 kfunc_btf_id,struct bpf_prog * prog)521 static inline u32 *btf_kfunc_id_set_contains(const struct btf *btf,
522 					     u32 kfunc_btf_id,
523 					     struct bpf_prog *prog)
524 
525 {
526 	return NULL;
527 }
register_btf_kfunc_id_set(enum bpf_prog_type prog_type,const struct btf_kfunc_id_set * s)528 static inline int register_btf_kfunc_id_set(enum bpf_prog_type prog_type,
529 					    const struct btf_kfunc_id_set *s)
530 {
531 	return 0;
532 }
btf_find_dtor_kfunc(struct btf * btf,u32 btf_id)533 static inline s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id)
534 {
535 	return -ENOENT;
536 }
register_btf_id_dtor_kfuncs(const struct btf_id_dtor_kfunc * dtors,u32 add_cnt,struct module * owner)537 static inline int register_btf_id_dtor_kfuncs(const struct btf_id_dtor_kfunc *dtors,
538 					      u32 add_cnt, struct module *owner)
539 {
540 	return 0;
541 }
btf_find_struct_meta(const struct btf * btf,u32 btf_id)542 static inline struct btf_struct_meta *btf_find_struct_meta(const struct btf *btf, u32 btf_id)
543 {
544 	return NULL;
545 }
546 static inline const struct btf_member *
btf_get_prog_ctx_type(struct bpf_verifier_log * log,const struct btf * btf,const struct btf_type * t,enum bpf_prog_type prog_type,int arg)547 btf_get_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,
548 		      const struct btf_type *t, enum bpf_prog_type prog_type,
549 		      int arg)
550 {
551 	return NULL;
552 }
get_kern_ctx_btf_id(struct bpf_verifier_log * log,enum bpf_prog_type prog_type)553 static inline int get_kern_ctx_btf_id(struct bpf_verifier_log *log,
554 				      enum bpf_prog_type prog_type) {
555 	return -EINVAL;
556 }
btf_types_are_same(const struct btf * btf1,u32 id1,const struct btf * btf2,u32 id2)557 static inline bool btf_types_are_same(const struct btf *btf1, u32 id1,
558 				      const struct btf *btf2, u32 id2)
559 {
560 	return false;
561 }
562 #endif
563 
btf_type_is_struct_ptr(struct btf * btf,const struct btf_type * t)564 static inline bool btf_type_is_struct_ptr(struct btf *btf, const struct btf_type *t)
565 {
566 	if (!btf_type_is_ptr(t))
567 		return false;
568 
569 	t = btf_type_skip_modifiers(btf, t->type, NULL);
570 
571 	return btf_type_is_struct(t);
572 }
573 
574 #endif
575