1 /* SPDX-License-Identifier: GPL-2.0 */ 1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* Copyright (c) 2018 Facebook */ 2 /* Copyright (c) 2018 Facebook */
3 3
4 #ifndef _LINUX_BTF_H 4 #ifndef _LINUX_BTF_H
5 #define _LINUX_BTF_H 1 5 #define _LINUX_BTF_H 1
6 6
7 #include <linux/types.h> 7 #include <linux/types.h>
8 #include <linux/bpfptr.h> 8 #include <linux/bpfptr.h>
9 #include <linux/bsearch.h> <<
10 #include <linux/btf_ids.h> <<
11 #include <uapi/linux/btf.h> 9 #include <uapi/linux/btf.h>
12 #include <uapi/linux/bpf.h> 10 #include <uapi/linux/bpf.h>
13 11
14 #define BTF_TYPE_EMIT(type) ((void)(type *)0) 12 #define BTF_TYPE_EMIT(type) ((void)(type *)0)
15 #define BTF_TYPE_EMIT_ENUM(enum_val) ((void)en 13 #define BTF_TYPE_EMIT_ENUM(enum_val) ((void)enum_val)
16 14
17 /* These need to be macros, as the expressions 15 /* These need to be macros, as the expressions are used in assembler input */
18 #define KF_ACQUIRE (1 << 0) /* kfunc is a 16 #define KF_ACQUIRE (1 << 0) /* kfunc is an acquire function */
19 #define KF_RELEASE (1 << 1) /* kfunc is a 17 #define KF_RELEASE (1 << 1) /* kfunc is a release function */
20 #define KF_RET_NULL (1 << 2) /* kfunc retu 18 #define KF_RET_NULL (1 << 2) /* kfunc returns a pointer that may be NULL */
21 /* Trusted arguments are those which are guara !! 19 #define KF_KPTR_GET (1 << 3) /* kfunc returns reference to a kptr */
22 * the kfunc. It is used to enforce that point !! 20 /* Trusted arguments are those which are meant to be referenced arguments with
23 * kfuncs, or from the main kernel on a tracep !! 21 * unchanged offset. It is used to enforce that pointers obtained from acquire
24 * invocation, remain unmodified when being pa !! 22 * kfuncs remain unmodified when being passed to helpers taking trusted args.
25 * args. !! 23 *
26 * !! 24 * Consider
27 * Consider, for example, the following new ta !! 25 * struct foo {
28 * !! 26 * int data;
29 * SEC("tp_btf/task_newtask") !! 27 * struct foo *next;
30 * int BPF_PROG(new_task_tp, struct task_ !! 28 * };
31 * { !! 29 *
32 * ... !! 30 * struct bar {
33 * } !! 31 * int data;
34 * !! 32 * struct foo f;
35 * And the following kfunc: !! 33 * };
36 * !! 34 *
37 * BTF_ID_FLAGS(func, bpf_task_acquire, K !! 35 * struct foo *f = alloc_foo(); // Acquire kfunc
38 * !! 36 * struct bar *b = alloc_bar(); // Acquire kfunc
39 * All invocations to the kfunc must pass the !! 37 *
40 * !! 38 * If a kfunc set_foo_data() wants to operate only on the allocated object, it
41 * bpf_task_acquire(task); // !! 39 * will set the KF_TRUSTED_ARGS flag, which will prevent unsafe usage like:
42 * bpf_task_acquire(task->last_wakee); // !! 40 *
43 * !! 41 * set_foo_data(f, 42); // Allowed
44 * Programs may also pass referenced tasks dir !! 42 * set_foo_data(f->next, 42); // Rejected, non-referenced pointer
45 * !! 43 * set_foo_data(&f->next, 42);// Rejected, referenced, but wrong type
46 * struct task_struct *acquired; !! 44 * set_foo_data(&b->f, 42); // Rejected, referenced, but bad offset
47 * !! 45 *
48 * acquired = bpf_task_acquire(task); !! 46 * In the final case, usually for the purposes of type matching, it is deduced
49 * bpf_task_acquire(acquired); !! 47 * by looking at the type of the member at the offset, but due to the
50 * bpf_task_acquire(task); !! 48 * requirement of trusted argument, this deduction will be strict and not done
51 * bpf_task_acquire(acquired->last_wakee) !! 49 * for this case.
52 * <<
53 * Programs may _not_, however, pass a task fr <<
54 * kprobe/kretprobe to the kfunc, as BPF canno <<
55 * pointers are guaranteed to be safe. For exa <<
56 * would be rejected: <<
57 * <<
58 * SEC("kretprobe/free_task") <<
59 * int BPF_PROG(free_task_probe, struct task_s <<
60 * { <<
61 * struct task_struct *acquired; <<
62 * <<
63 * acquired = bpf_task_acquire(acquired); <<
64 * bpf_task_release(acquired); <<
65 * <<
66 * return 0; <<
67 * } <<
68 */ 50 */
69 #define KF_TRUSTED_ARGS (1 << 4) /* kfunc only 51 #define KF_TRUSTED_ARGS (1 << 4) /* kfunc only takes trusted pointer arguments */
70 #define KF_SLEEPABLE (1 << 5) /* kfunc may 52 #define KF_SLEEPABLE (1 << 5) /* kfunc may sleep */
71 #define KF_DESTRUCTIVE (1 << 6) /* kfunc perf 53 #define KF_DESTRUCTIVE (1 << 6) /* kfunc performs destructive actions */
72 #define KF_RCU (1 << 7) /* kfunc take <<
73 /* only one of KF_ITER_{NEW,NEXT,DESTROY} coul <<
74 #define KF_ITER_NEW (1 << 8) /* kfunc impl <<
75 #define KF_ITER_NEXT (1 << 9) /* kfunc impl <<
76 #define KF_ITER_DESTROY (1 << 10) /* kfunc imp <<
77 #define KF_RCU_PROTECTED (1 << 11) /* kfunc sh <<
78 <<
79 /* <<
80 * Tag marking a kernel function as a kfunc. T <<
81 * amount of copy-paste that kfunc authors hav <<
82 * as to avoid issues such as the compiler inl <<
83 * kfunc, or a global kfunc in an LTO build. <<
84 */ <<
85 #define __bpf_kfunc __used __retain noinline <<
86 <<
87 #define __bpf_kfunc_start_defs() <<
88 __diag_push(); <<
89 __diag_ignore_all("-Wmissing-declarati <<
90 "Global kfuncs as th <<
91 __diag_ignore_all("-Wmissing-prototype <<
92 "Global kfuncs as th <<
93 <<
94 #define __bpf_kfunc_end_defs() __diag_pop() <<
95 #define __bpf_hook_start() __bpf_kfunc_start_d <<
96 #define __bpf_hook_end() __bpf_kfunc_end_defs( <<
97 54
98 /* 55 /*
99 * Return the name of the passed struct, if ex 56 * Return the name of the passed struct, if exists, or halt the build if for
100 * example the structure gets renamed. In this 57 * example the structure gets renamed. In this way, developers have to revisit
101 * the code using that structure name, and upd 58 * the code using that structure name, and update it accordingly.
102 */ 59 */
103 #define stringify_struct(x) 60 #define stringify_struct(x) \
104 ({ BUILD_BUG_ON(sizeof(struct x) < 0); 61 ({ BUILD_BUG_ON(sizeof(struct x) < 0); \
105 __stringify(x); }) 62 __stringify(x); })
106 63
107 struct btf; 64 struct btf;
108 struct btf_member; 65 struct btf_member;
109 struct btf_type; 66 struct btf_type;
110 union bpf_attr; 67 union bpf_attr;
111 struct btf_show; 68 struct btf_show;
112 struct btf_id_set; 69 struct btf_id_set;
113 struct bpf_prog; <<
114 <<
115 typedef int (*btf_kfunc_filter_t)(const struct <<
116 70
117 struct btf_kfunc_id_set { 71 struct btf_kfunc_id_set {
118 struct module *owner; 72 struct module *owner;
119 struct btf_id_set8 *set; 73 struct btf_id_set8 *set;
120 btf_kfunc_filter_t filter; <<
121 }; 74 };
122 75
123 struct btf_id_dtor_kfunc { 76 struct btf_id_dtor_kfunc {
124 u32 btf_id; 77 u32 btf_id;
125 u32 kfunc_btf_id; 78 u32 kfunc_btf_id;
126 }; 79 };
127 80
128 struct btf_struct_meta { !! 81 typedef void (*btf_dtor_kfunc_t)(void *);
129 u32 btf_id; <<
130 struct btf_record *record; <<
131 }; <<
132 <<
133 struct btf_struct_metas { <<
134 u32 cnt; <<
135 struct btf_struct_meta types[]; <<
136 }; <<
137 82
138 extern const struct file_operations btf_fops; 83 extern const struct file_operations btf_fops;
139 84
140 const char *btf_get_name(const struct btf *btf <<
141 void btf_get(struct btf *btf); 85 void btf_get(struct btf *btf);
142 void btf_put(struct btf *btf); 86 void btf_put(struct btf *btf);
143 const struct btf_header *btf_header(const stru !! 87 int btf_new_fd(const union bpf_attr *attr, bpfptr_t uattr);
144 int btf_new_fd(const union bpf_attr *attr, bpf <<
145 struct btf *btf_get_by_fd(int fd); 88 struct btf *btf_get_by_fd(int fd);
146 int btf_get_info_by_fd(const struct btf *btf, 89 int btf_get_info_by_fd(const struct btf *btf,
147 const union bpf_attr *a 90 const union bpf_attr *attr,
148 union bpf_attr __user * 91 union bpf_attr __user *uattr);
149 /* Figure out the size of a type_id. If type_ 92 /* Figure out the size of a type_id. If type_id is a modifier
150 * (e.g. const), it will be resolved to find o 93 * (e.g. const), it will be resolved to find out the type with size.
151 * 94 *
152 * For example: 95 * For example:
153 * In describing "const void *", type_id is " 96 * In describing "const void *", type_id is "const" and "const"
154 * refers to "void *". The return type will b 97 * refers to "void *". The return type will be "void *".
155 * 98 *
156 * If type_id is a simple "int", then return t 99 * If type_id is a simple "int", then return type will be "int".
157 * 100 *
158 * @btf: struct btf object 101 * @btf: struct btf object
159 * @type_id: Find out the size of type_id. The 102 * @type_id: Find out the size of type_id. The type_id of the return
160 * type is set to *type_id. 103 * type is set to *type_id.
161 * @ret_size: It can be NULL. If not NULL, th 104 * @ret_size: It can be NULL. If not NULL, the size of the return
162 * type is set to *ret_size. 105 * type is set to *ret_size.
163 * Return: The btf_type (resolved to another t 106 * Return: The btf_type (resolved to another type with size info if needed).
164 * NULL is returned if type_id itself 107 * NULL is returned if type_id itself does not have size info
165 * (e.g. void) or it cannot be resolve 108 * (e.g. void) or it cannot be resolved to another type that
166 * has size info. 109 * has size info.
167 * *type_id and *ret_size will not be 110 * *type_id and *ret_size will not be changed in the
168 * NULL return case. 111 * NULL return case.
169 */ 112 */
170 const struct btf_type *btf_type_id_size(const 113 const struct btf_type *btf_type_id_size(const struct btf *btf,
171 u32 *t 114 u32 *type_id,
172 u32 *r 115 u32 *ret_size);
173 116
174 /* 117 /*
175 * Options to control show behaviour. 118 * Options to control show behaviour.
176 * - BTF_SHOW_COMPACT: no formatting arou 119 * - BTF_SHOW_COMPACT: no formatting around type information
177 * - BTF_SHOW_NONAME: no struct/union mem 120 * - BTF_SHOW_NONAME: no struct/union member names/types
178 * - BTF_SHOW_PTR_RAW: show raw (unobfusc 121 * - BTF_SHOW_PTR_RAW: show raw (unobfuscated) pointer values;
179 * equivalent to %px. 122 * equivalent to %px.
180 * - BTF_SHOW_ZERO: show zero-valued stru 123 * - BTF_SHOW_ZERO: show zero-valued struct/union members; they
181 * are not displayed by default 124 * are not displayed by default
182 * - BTF_SHOW_UNSAFE: skip use of bpf_pro 125 * - BTF_SHOW_UNSAFE: skip use of bpf_probe_read() to safely read
183 * data before displaying it. 126 * data before displaying it.
184 */ 127 */
185 #define BTF_SHOW_COMPACT BTF_F_COMPACT 128 #define BTF_SHOW_COMPACT BTF_F_COMPACT
186 #define BTF_SHOW_NONAME BTF_F_NONAME 129 #define BTF_SHOW_NONAME BTF_F_NONAME
187 #define BTF_SHOW_PTR_RAW BTF_F_PTR_RAW 130 #define BTF_SHOW_PTR_RAW BTF_F_PTR_RAW
188 #define BTF_SHOW_ZERO BTF_F_ZERO 131 #define BTF_SHOW_ZERO BTF_F_ZERO
189 #define BTF_SHOW_UNSAFE (1ULL << 4) 132 #define BTF_SHOW_UNSAFE (1ULL << 4)
190 133
191 void btf_type_seq_show(const struct btf *btf, 134 void btf_type_seq_show(const struct btf *btf, u32 type_id, void *obj,
192 struct seq_file *m); 135 struct seq_file *m);
193 int btf_type_seq_show_flags(const struct btf * 136 int btf_type_seq_show_flags(const struct btf *btf, u32 type_id, void *obj,
194 struct seq_file *m 137 struct seq_file *m, u64 flags);
195 138
196 /* 139 /*
197 * Copy len bytes of string representation of 140 * Copy len bytes of string representation of obj of BTF type_id into buf.
198 * 141 *
199 * @btf: struct btf object 142 * @btf: struct btf object
200 * @type_id: type id of type obj points to 143 * @type_id: type id of type obj points to
201 * @obj: pointer to typed data 144 * @obj: pointer to typed data
202 * @buf: buffer to write to 145 * @buf: buffer to write to
203 * @len: maximum length to write to buf 146 * @len: maximum length to write to buf
204 * @flags: show options (see above) 147 * @flags: show options (see above)
205 * 148 *
206 * Return: length that would have been/was cop 149 * Return: length that would have been/was copied as per snprintf, or
207 * negative error. 150 * negative error.
208 */ 151 */
209 int btf_type_snprintf_show(const struct btf *b 152 int btf_type_snprintf_show(const struct btf *btf, u32 type_id, void *obj,
210 char *buf, int len, 153 char *buf, int len, u64 flags);
211 154
212 int btf_get_fd_by_id(u32 id); 155 int btf_get_fd_by_id(u32 id);
213 u32 btf_obj_id(const struct btf *btf); 156 u32 btf_obj_id(const struct btf *btf);
214 bool btf_is_kernel(const struct btf *btf); 157 bool btf_is_kernel(const struct btf *btf);
215 bool btf_is_module(const struct btf *btf); 158 bool btf_is_module(const struct btf *btf);
216 bool btf_is_vmlinux(const struct btf *btf); <<
217 struct module *btf_try_get_module(const struct 159 struct module *btf_try_get_module(const struct btf *btf);
218 u32 btf_nr_types(const struct btf *btf); 160 u32 btf_nr_types(const struct btf *btf);
219 struct btf *btf_base_btf(const struct btf *btf <<
220 bool btf_member_is_reg_int(const struct btf *b 161 bool btf_member_is_reg_int(const struct btf *btf, const struct btf_type *s,
221 const struct btf_me 162 const struct btf_member *m,
222 u32 expected_offset 163 u32 expected_offset, u32 expected_size);
223 struct btf_record *btf_parse_fields(const stru !! 164 int btf_find_spin_lock(const struct btf *btf, const struct btf_type *t);
224 u32 field_ !! 165 int btf_find_timer(const struct btf *btf, const struct btf_type *t);
225 int btf_check_and_fixup_fields(const struct bt !! 166 struct bpf_map_value_off *btf_parse_kptrs(const struct btf *btf,
>> 167 const struct btf_type *t);
226 bool btf_type_is_void(const struct btf_type *t 168 bool btf_type_is_void(const struct btf_type *t);
227 s32 btf_find_by_name_kind(const struct btf *bt 169 s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind);
228 s32 bpf_find_btf_id(const char *name, u32 kind <<
229 const struct btf_type *btf_type_skip_modifiers 170 const struct btf_type *btf_type_skip_modifiers(const struct btf *btf,
230 171 u32 id, u32 *res_id);
231 const struct btf_type *btf_type_resolve_ptr(co 172 const struct btf_type *btf_type_resolve_ptr(const struct btf *btf,
232 u3 173 u32 id, u32 *res_id);
233 const struct btf_type *btf_type_resolve_func_p 174 const struct btf_type *btf_type_resolve_func_ptr(const struct btf *btf,
234 175 u32 id, u32 *res_id);
235 const struct btf_type * 176 const struct btf_type *
236 btf_resolve_size(const struct btf *btf, const 177 btf_resolve_size(const struct btf *btf, const struct btf_type *type,
237 u32 *type_size); 178 u32 *type_size);
238 const char *btf_type_str(const struct btf_type 179 const char *btf_type_str(const struct btf_type *t);
239 180
240 #define for_each_member(i, struct_type, member 181 #define for_each_member(i, struct_type, member) \
241 for (i = 0, member = btf_type_member(s 182 for (i = 0, member = btf_type_member(struct_type); \
242 i < btf_type_vlen(struct_type); 183 i < btf_type_vlen(struct_type); \
243 i++, member++) 184 i++, member++)
244 185
245 #define for_each_vsi(i, datasec_type, member) 186 #define for_each_vsi(i, datasec_type, member) \
246 for (i = 0, member = btf_type_var_seci 187 for (i = 0, member = btf_type_var_secinfo(datasec_type); \
247 i < btf_type_vlen(datasec_type); 188 i < btf_type_vlen(datasec_type); \
248 i++, member++) 189 i++, member++)
249 190
250 static inline bool btf_type_is_ptr(const struc 191 static inline bool btf_type_is_ptr(const struct btf_type *t)
251 { 192 {
252 return BTF_INFO_KIND(t->info) == BTF_K 193 return BTF_INFO_KIND(t->info) == BTF_KIND_PTR;
253 } 194 }
254 195
255 static inline bool btf_type_is_int(const struc 196 static inline bool btf_type_is_int(const struct btf_type *t)
256 { 197 {
257 return BTF_INFO_KIND(t->info) == BTF_K 198 return BTF_INFO_KIND(t->info) == BTF_KIND_INT;
258 } 199 }
259 200
260 static inline bool btf_type_is_small_int(const 201 static inline bool btf_type_is_small_int(const struct btf_type *t)
261 { 202 {
262 return btf_type_is_int(t) && t->size < 203 return btf_type_is_int(t) && t->size <= sizeof(u64);
263 } 204 }
264 205
265 static inline u8 btf_int_encoding(const struct <<
266 { <<
267 return BTF_INT_ENCODING(*(u32 *)(t + 1 <<
268 } <<
269 <<
270 static inline bool btf_type_is_signed_int(cons <<
271 { <<
272 return btf_type_is_int(t) && (btf_int_ <<
273 } <<
274 <<
275 static inline bool btf_type_is_enum(const stru 206 static inline bool btf_type_is_enum(const struct btf_type *t)
276 { 207 {
277 return BTF_INFO_KIND(t->info) == BTF_K 208 return BTF_INFO_KIND(t->info) == BTF_KIND_ENUM;
278 } 209 }
279 210
280 static inline bool btf_is_any_enum(const struc 211 static inline bool btf_is_any_enum(const struct btf_type *t)
281 { 212 {
282 return BTF_INFO_KIND(t->info) == BTF_K 213 return BTF_INFO_KIND(t->info) == BTF_KIND_ENUM ||
283 BTF_INFO_KIND(t->info) == BTF_K 214 BTF_INFO_KIND(t->info) == BTF_KIND_ENUM64;
284 } 215 }
285 216
286 static inline bool btf_kind_core_compat(const 217 static inline bool btf_kind_core_compat(const struct btf_type *t1,
287 const 218 const struct btf_type *t2)
288 { 219 {
289 return BTF_INFO_KIND(t1->info) == BTF_ 220 return BTF_INFO_KIND(t1->info) == BTF_INFO_KIND(t2->info) ||
290 (btf_is_any_enum(t1) && btf_is_ 221 (btf_is_any_enum(t1) && btf_is_any_enum(t2));
291 } 222 }
292 223
293 static inline bool str_is_empty(const char *s) 224 static inline bool str_is_empty(const char *s)
294 { 225 {
295 return !s || !s[0]; 226 return !s || !s[0];
296 } 227 }
297 228
298 static inline u16 btf_kind(const struct btf_ty 229 static inline u16 btf_kind(const struct btf_type *t)
299 { 230 {
300 return BTF_INFO_KIND(t->info); 231 return BTF_INFO_KIND(t->info);
301 } 232 }
302 233
303 static inline bool btf_is_enum(const struct bt 234 static inline bool btf_is_enum(const struct btf_type *t)
304 { 235 {
305 return btf_kind(t) == BTF_KIND_ENUM; 236 return btf_kind(t) == BTF_KIND_ENUM;
306 } 237 }
307 238
308 static inline bool btf_is_enum64(const struct 239 static inline bool btf_is_enum64(const struct btf_type *t)
309 { 240 {
310 return btf_kind(t) == BTF_KIND_ENUM64; 241 return btf_kind(t) == BTF_KIND_ENUM64;
311 } 242 }
312 243
313 static inline u64 btf_enum64_value(const struc 244 static inline u64 btf_enum64_value(const struct btf_enum64 *e)
314 { 245 {
315 return ((u64)e->val_hi32 << 32) | e->v 246 return ((u64)e->val_hi32 << 32) | e->val_lo32;
316 } 247 }
317 248
318 static inline bool btf_is_composite(const stru 249 static inline bool btf_is_composite(const struct btf_type *t)
319 { 250 {
320 u16 kind = btf_kind(t); 251 u16 kind = btf_kind(t);
321 252
322 return kind == BTF_KIND_STRUCT || kind 253 return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;
323 } 254 }
324 255
325 static inline bool btf_is_array(const struct b 256 static inline bool btf_is_array(const struct btf_type *t)
326 { 257 {
327 return btf_kind(t) == BTF_KIND_ARRAY; 258 return btf_kind(t) == BTF_KIND_ARRAY;
328 } 259 }
329 260
330 static inline bool btf_is_int(const struct btf 261 static inline bool btf_is_int(const struct btf_type *t)
331 { 262 {
332 return btf_kind(t) == BTF_KIND_INT; 263 return btf_kind(t) == BTF_KIND_INT;
333 } 264 }
334 265
335 static inline bool btf_is_ptr(const struct btf 266 static inline bool btf_is_ptr(const struct btf_type *t)
336 { 267 {
337 return btf_kind(t) == BTF_KIND_PTR; 268 return btf_kind(t) == BTF_KIND_PTR;
338 } 269 }
339 270
340 static inline u8 btf_int_offset(const struct b 271 static inline u8 btf_int_offset(const struct btf_type *t)
341 { 272 {
342 return BTF_INT_OFFSET(*(u32 *)(t + 1)) 273 return BTF_INT_OFFSET(*(u32 *)(t + 1));
343 } 274 }
344 275
345 static inline __u8 btf_int_bits(const struct b !! 276 static inline u8 btf_int_encoding(const struct btf_type *t)
346 { 277 {
347 return BTF_INT_BITS(*(__u32 *)(t + 1)) !! 278 return BTF_INT_ENCODING(*(u32 *)(t + 1));
348 } 279 }
349 280
350 static inline bool btf_type_is_scalar(const st 281 static inline bool btf_type_is_scalar(const struct btf_type *t)
351 { 282 {
352 return btf_type_is_int(t) || btf_type_ 283 return btf_type_is_int(t) || btf_type_is_enum(t);
353 } 284 }
354 285
355 static inline bool btf_type_is_typedef(const s 286 static inline bool btf_type_is_typedef(const struct btf_type *t)
356 { 287 {
357 return BTF_INFO_KIND(t->info) == BTF_K 288 return BTF_INFO_KIND(t->info) == BTF_KIND_TYPEDEF;
358 } 289 }
359 290
360 static inline bool btf_type_is_volatile(const <<
361 { <<
362 return BTF_INFO_KIND(t->info) == BTF_K <<
363 } <<
364 <<
365 static inline bool btf_type_is_func(const stru 291 static inline bool btf_type_is_func(const struct btf_type *t)
366 { 292 {
367 return BTF_INFO_KIND(t->info) == BTF_K 293 return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC;
368 } 294 }
369 295
370 static inline bool btf_type_is_func_proto(cons 296 static inline bool btf_type_is_func_proto(const struct btf_type *t)
371 { 297 {
372 return BTF_INFO_KIND(t->info) == BTF_K 298 return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC_PROTO;
373 } 299 }
374 300
375 static inline bool btf_type_is_var(const struc 301 static inline bool btf_type_is_var(const struct btf_type *t)
376 { 302 {
377 return BTF_INFO_KIND(t->info) == BTF_K 303 return BTF_INFO_KIND(t->info) == BTF_KIND_VAR;
378 } 304 }
379 305
380 static inline bool btf_type_is_type_tag(const 306 static inline bool btf_type_is_type_tag(const struct btf_type *t)
381 { 307 {
382 return BTF_INFO_KIND(t->info) == BTF_K 308 return BTF_INFO_KIND(t->info) == BTF_KIND_TYPE_TAG;
383 } 309 }
384 310
385 /* union is only a special case of struct: 311 /* union is only a special case of struct:
386 * all its offsetof(member) == 0 312 * all its offsetof(member) == 0
387 */ 313 */
388 static inline bool btf_type_is_struct(const st 314 static inline bool btf_type_is_struct(const struct btf_type *t)
389 { 315 {
390 u8 kind = BTF_INFO_KIND(t->info); 316 u8 kind = BTF_INFO_KIND(t->info);
391 317
392 return kind == BTF_KIND_STRUCT || kind 318 return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;
393 } 319 }
394 320
395 static inline bool __btf_type_is_struct(const <<
396 { <<
397 return BTF_INFO_KIND(t->info) == BTF_K <<
398 } <<
399 <<
400 static inline bool btf_type_is_array(const str <<
401 { <<
402 return BTF_INFO_KIND(t->info) == BTF_K <<
403 } <<
404 <<
405 static inline u16 btf_type_vlen(const struct b 321 static inline u16 btf_type_vlen(const struct btf_type *t)
406 { 322 {
407 return BTF_INFO_VLEN(t->info); 323 return BTF_INFO_VLEN(t->info);
408 } 324 }
409 325
410 static inline u16 btf_vlen(const struct btf_ty 326 static inline u16 btf_vlen(const struct btf_type *t)
411 { 327 {
412 return btf_type_vlen(t); 328 return btf_type_vlen(t);
413 } 329 }
414 330
415 static inline u16 btf_func_linkage(const struc 331 static inline u16 btf_func_linkage(const struct btf_type *t)
416 { 332 {
417 return BTF_INFO_VLEN(t->info); 333 return BTF_INFO_VLEN(t->info);
418 } 334 }
419 335
420 static inline bool btf_type_kflag(const struct 336 static inline bool btf_type_kflag(const struct btf_type *t)
421 { 337 {
422 return BTF_INFO_KFLAG(t->info); 338 return BTF_INFO_KFLAG(t->info);
423 } 339 }
424 340
425 static inline u32 __btf_member_bit_offset(cons 341 static inline u32 __btf_member_bit_offset(const struct btf_type *struct_type,
426 cons 342 const struct btf_member *member)
427 { 343 {
428 return btf_type_kflag(struct_type) ? B 344 return btf_type_kflag(struct_type) ? BTF_MEMBER_BIT_OFFSET(member->offset)
429 : m 345 : member->offset;
430 } 346 }
431 347
432 static inline u32 __btf_member_bitfield_size(c 348 static inline u32 __btf_member_bitfield_size(const struct btf_type *struct_type,
433 c 349 const struct btf_member *member)
434 { 350 {
435 return btf_type_kflag(struct_type) ? B 351 return btf_type_kflag(struct_type) ? BTF_MEMBER_BITFIELD_SIZE(member->offset)
436 : 0 352 : 0;
437 } 353 }
438 354
439 static inline struct btf_member *btf_members(c 355 static inline struct btf_member *btf_members(const struct btf_type *t)
440 { 356 {
441 return (struct btf_member *)(t + 1); 357 return (struct btf_member *)(t + 1);
442 } 358 }
443 359
444 static inline u32 btf_member_bit_offset(const 360 static inline u32 btf_member_bit_offset(const struct btf_type *t, u32 member_idx)
445 { 361 {
446 const struct btf_member *m = btf_membe 362 const struct btf_member *m = btf_members(t) + member_idx;
447 363
448 return __btf_member_bit_offset(t, m); 364 return __btf_member_bit_offset(t, m);
449 } 365 }
450 366
451 static inline u32 btf_member_bitfield_size(con 367 static inline u32 btf_member_bitfield_size(const struct btf_type *t, u32 member_idx)
452 { 368 {
453 const struct btf_member *m = btf_membe 369 const struct btf_member *m = btf_members(t) + member_idx;
454 370
455 return __btf_member_bitfield_size(t, m 371 return __btf_member_bitfield_size(t, m);
456 } 372 }
457 373
458 static inline const struct btf_member *btf_typ 374 static inline const struct btf_member *btf_type_member(const struct btf_type *t)
459 { 375 {
460 return (const struct btf_member *)(t + 376 return (const struct btf_member *)(t + 1);
461 } 377 }
462 378
463 static inline struct btf_array *btf_array(cons 379 static inline struct btf_array *btf_array(const struct btf_type *t)
464 { 380 {
465 return (struct btf_array *)(t + 1); 381 return (struct btf_array *)(t + 1);
466 } 382 }
467 383
468 static inline struct btf_enum *btf_enum(const 384 static inline struct btf_enum *btf_enum(const struct btf_type *t)
469 { 385 {
470 return (struct btf_enum *)(t + 1); 386 return (struct btf_enum *)(t + 1);
471 } 387 }
472 388
473 static inline struct btf_enum64 *btf_enum64(co 389 static inline struct btf_enum64 *btf_enum64(const struct btf_type *t)
474 { 390 {
475 return (struct btf_enum64 *)(t + 1); 391 return (struct btf_enum64 *)(t + 1);
476 } 392 }
477 393
478 static inline const struct btf_var_secinfo *bt 394 static inline const struct btf_var_secinfo *btf_type_var_secinfo(
479 const struct btf_type *t) 395 const struct btf_type *t)
480 { 396 {
481 return (const struct btf_var_secinfo * 397 return (const struct btf_var_secinfo *)(t + 1);
482 } 398 }
483 399
484 static inline struct btf_param *btf_params(con 400 static inline struct btf_param *btf_params(const struct btf_type *t)
485 { 401 {
486 return (struct btf_param *)(t + 1); 402 return (struct btf_param *)(t + 1);
487 } 403 }
488 404
489 static inline struct btf_decl_tag *btf_decl_ta <<
490 { <<
491 return (struct btf_decl_tag *)(t + 1); <<
492 } <<
493 <<
494 static inline int btf_id_cmp_func(const void * <<
495 { <<
496 const int *pa = a, *pb = b; <<
497 <<
498 return *pa - *pb; <<
499 } <<
500 <<
501 static inline bool btf_id_set_contains(const s <<
502 { <<
503 return bsearch(&id, set->ids, set->cnt <<
504 } <<
505 <<
506 static inline void *btf_id_set8_contains(const <<
507 { <<
508 return bsearch(&id, set->pairs, set->c <<
509 } <<
510 <<
511 bool btf_param_match_suffix(const struct btf * <<
512 const struct btf_p <<
513 const char *suffix <<
514 int btf_ctx_arg_offset(const struct btf *btf, <<
515 u32 arg_no); <<
516 <<
517 struct bpf_verifier_log; <<
518 <<
519 #if defined(CONFIG_BPF_JIT) && defined(CONFIG_ <<
520 struct bpf_struct_ops; <<
521 int __register_bpf_struct_ops(struct bpf_struc <<
522 const struct bpf_struct_ops_desc *bpf_struct_o <<
523 const struct bpf_struct_ops_desc *bpf_struct_o <<
524 #else <<
525 static inline const struct bpf_struct_ops_desc <<
526 { <<
527 return NULL; <<
528 } <<
529 #endif <<
530 <<
531 enum btf_field_iter_kind { <<
532 BTF_FIELD_ITER_IDS, <<
533 BTF_FIELD_ITER_STRS, <<
534 }; <<
535 <<
536 struct btf_field_desc { <<
537 /* once-per-type offsets */ <<
538 int t_off_cnt, t_offs[2]; <<
539 /* member struct size, or zero, if no <<
540 int m_sz; <<
541 /* repeated per-member offsets */ <<
542 int m_off_cnt, m_offs[1]; <<
543 }; <<
544 <<
545 struct btf_field_iter { <<
546 struct btf_field_desc desc; <<
547 void *p; <<
548 int m_idx; <<
549 int off_idx; <<
550 int vlen; <<
551 }; <<
552 <<
553 #ifdef CONFIG_BPF_SYSCALL 405 #ifdef CONFIG_BPF_SYSCALL
554 const struct btf_type *btf_type_by_id(const st !! 406 struct bpf_prog;
555 void btf_set_base_btf(struct btf *btf, const s <<
556 int btf_relocate(struct btf *btf, const struct <<
557 int btf_field_iter_init(struct btf_field_iter <<
558 enum btf_field_iter_ki <<
559 __u32 *btf_field_iter_next(struct btf_field_it <<
560 407
>> 408 const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id);
561 const char *btf_name_by_offset(const struct bt 409 const char *btf_name_by_offset(const struct btf *btf, u32 offset);
562 const char *btf_str_by_offset(const struct btf <<
563 struct btf *btf_parse_vmlinux(void); 410 struct btf *btf_parse_vmlinux(void);
564 struct btf *bpf_prog_get_target_btf(const stru 411 struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog);
565 u32 *btf_kfunc_id_set_contains(const struct bt !! 412 u32 *btf_kfunc_id_set_contains(const struct btf *btf,
566 const struct bp !! 413 enum bpf_prog_type prog_type,
567 u32 *btf_kfunc_is_modify_return(const struct b !! 414 u32 kfunc_btf_id);
568 const struct b <<
569 int register_btf_kfunc_id_set(enum bpf_prog_ty 415 int register_btf_kfunc_id_set(enum bpf_prog_type prog_type,
570 const struct btf 416 const struct btf_kfunc_id_set *s);
571 int register_btf_fmodret_id_set(const struct b <<
572 s32 btf_find_dtor_kfunc(struct btf *btf, u32 b 417 s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id);
573 int register_btf_id_dtor_kfuncs(const struct b 418 int register_btf_id_dtor_kfuncs(const struct btf_id_dtor_kfunc *dtors, u32 add_cnt,
574 struct module 419 struct module *owner);
575 struct btf_struct_meta *btf_find_struct_meta(c <<
576 bool btf_is_projection_of(const char *pname, c <<
577 bool btf_is_prog_ctx_type(struct bpf_verifier_ <<
578 const struct btf_ty <<
579 int arg); <<
580 int get_kern_ctx_btf_id(struct bpf_verifier_lo <<
581 bool btf_types_are_same(const struct btf *btf1 <<
582 const struct btf *btf2 <<
583 int btf_check_iter_arg(struct btf *btf, const <<
584 #else 420 #else
585 static inline const struct btf_type *btf_type_ 421 static inline const struct btf_type *btf_type_by_id(const struct btf *btf,
586 422 u32 type_id)
587 { 423 {
588 return NULL; 424 return NULL;
589 } 425 }
590 <<
591 static inline void btf_set_base_btf(struct btf <<
592 { <<
593 } <<
594 <<
595 static inline int btf_relocate(void *log, stru <<
596 __u32 **map_ids <<
597 { <<
598 return -EOPNOTSUPP; <<
599 } <<
600 <<
601 static inline int btf_field_iter_init(struct b <<
602 enum btf <<
603 { <<
604 return -EOPNOTSUPP; <<
605 } <<
606 <<
607 static inline __u32 *btf_field_iter_next(struc <<
608 { <<
609 return NULL; <<
610 } <<
611 <<
612 static inline const char *btf_name_by_offset(c 426 static inline const char *btf_name_by_offset(const struct btf *btf,
613 u 427 u32 offset)
614 { 428 {
615 return NULL; 429 return NULL;
616 } 430 }
617 static inline u32 *btf_kfunc_id_set_contains(c 431 static inline u32 *btf_kfunc_id_set_contains(const struct btf *btf,
618 u !! 432 enum bpf_prog_type prog_type,
619 s !! 433 u32 kfunc_btf_id)
620 <<
621 { 434 {
622 return NULL; 435 return NULL;
623 } 436 }
624 static inline int register_btf_kfunc_id_set(en 437 static inline int register_btf_kfunc_id_set(enum bpf_prog_type prog_type,
625 co 438 const struct btf_kfunc_id_set *s)
626 { 439 {
627 return 0; 440 return 0;
628 } 441 }
629 static inline s32 btf_find_dtor_kfunc(struct b 442 static inline s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id)
630 { 443 {
631 return -ENOENT; 444 return -ENOENT;
632 } 445 }
633 static inline int register_btf_id_dtor_kfuncs( 446 static inline int register_btf_id_dtor_kfuncs(const struct btf_id_dtor_kfunc *dtors,
634 447 u32 add_cnt, struct module *owner)
635 { 448 {
636 return 0; 449 return 0;
637 } <<
638 static inline struct btf_struct_meta *btf_find <<
639 { <<
640 return NULL; <<
641 } <<
642 static inline bool <<
643 btf_is_prog_ctx_type(struct bpf_verifier_log * <<
644 const struct btf_type *t, <<
645 int arg) <<
646 { <<
647 return false; <<
648 } <<
649 static inline int get_kern_ctx_btf_id(struct b <<
650 enum bpf <<
651 return -EINVAL; <<
652 } <<
653 static inline bool btf_types_are_same(const st <<
654 const st <<
655 { <<
656 return false; <<
657 } <<
658 static inline int btf_check_iter_arg(struct bt <<
659 { <<
660 return -EOPNOTSUPP; <<
661 } 450 }
662 #endif 451 #endif
663 452
664 static inline bool btf_type_is_struct_ptr(stru 453 static inline bool btf_type_is_struct_ptr(struct btf *btf, const struct btf_type *t)
665 { 454 {
666 if (!btf_type_is_ptr(t)) 455 if (!btf_type_is_ptr(t))
667 return false; 456 return false;
668 457
669 t = btf_type_skip_modifiers(btf, t->ty 458 t = btf_type_skip_modifiers(btf, t->type, NULL);
670 459
671 return btf_type_is_struct(t); 460 return btf_type_is_struct(t);
672 } 461 }
673 462
674 #endif 463 #endif
675 464
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.