1 | /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ |
2 | /* Copyright (c) 2018 Facebook */ |
3 | /*! \file */ |
4 | |
5 | #ifndef __LIBBPF_BTF_H |
6 | #define __LIBBPF_BTF_H |
7 | |
8 | #include <stdarg.h> |
9 | #include <stdbool.h> |
10 | #include <linux/btf.h> |
11 | #include <linux/types.h> |
12 | |
13 | #include "libbpf_common.h" |
14 | |
15 | #ifdef __cplusplus |
16 | extern "C" { |
17 | #endif |
18 | |
19 | #define BTF_ELF_SEC ".BTF" |
20 | #define BTF_EXT_ELF_SEC ".BTF.ext" |
21 | #define MAPS_ELF_SEC ".maps" |
22 | |
23 | struct btf; |
24 | struct btf_ext; |
25 | struct btf_type; |
26 | |
27 | struct bpf_object; |
28 | |
29 | enum btf_endianness { |
30 | BTF_LITTLE_ENDIAN = 0, |
31 | BTF_BIG_ENDIAN = 1, |
32 | }; |
33 | |
34 | /** |
35 | * @brief **btf__free()** frees all data of a BTF object |
36 | * @param btf BTF object to free |
37 | */ |
38 | LIBBPF_API void btf__free(struct btf *btf); |
39 | |
40 | /** |
41 | * @brief **btf__new()** creates a new instance of a BTF object from the raw |
42 | * bytes of an ELF's BTF section |
43 | * @param data raw bytes |
44 | * @param size number of bytes passed in `data` |
45 | * @return new BTF object instance which has to be eventually freed with |
46 | * **btf__free()** |
47 | * |
48 | * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract |
49 | * error code from such a pointer `libbpf_get_error()` should be used. If |
50 | * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is |
51 | * returned on error instead. In both cases thread-local `errno` variable is |
52 | * always set to error code as well. |
53 | */ |
54 | LIBBPF_API struct btf *btf__new(const void *data, __u32 size); |
55 | |
56 | /** |
57 | * @brief **btf__new_split()** create a new instance of a BTF object from the |
58 | * provided raw data bytes. It takes another BTF instance, **base_btf**, which |
59 | * serves as a base BTF, which is extended by types in a newly created BTF |
60 | * instance |
61 | * @param data raw bytes |
62 | * @param size length of raw bytes |
63 | * @param base_btf the base BTF object |
64 | * @return new BTF object instance which has to be eventually freed with |
65 | * **btf__free()** |
66 | * |
67 | * If *base_btf* is NULL, `btf__new_split()` is equivalent to `btf__new()` and |
68 | * creates non-split BTF. |
69 | * |
70 | * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract |
71 | * error code from such a pointer `libbpf_get_error()` should be used. If |
72 | * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is |
73 | * returned on error instead. In both cases thread-local `errno` variable is |
74 | * always set to error code as well. |
75 | */ |
76 | LIBBPF_API struct btf *btf__new_split(const void *data, __u32 size, struct btf *base_btf); |
77 | |
78 | /** |
79 | * @brief **btf__new_empty()** creates an empty BTF object. Use |
80 | * `btf__add_*()` to populate such BTF object. |
81 | * @return new BTF object instance which has to be eventually freed with |
82 | * **btf__free()** |
83 | * |
84 | * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract |
85 | * error code from such a pointer `libbpf_get_error()` should be used. If |
86 | * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is |
87 | * returned on error instead. In both cases thread-local `errno` variable is |
88 | * always set to error code as well. |
89 | */ |
90 | LIBBPF_API struct btf *btf__new_empty(void); |
91 | |
92 | /** |
93 | * @brief **btf__new_empty_split()** creates an unpopulated BTF object from an |
94 | * ELF BTF section except with a base BTF on top of which split BTF should be |
95 | * based |
96 | * @return new BTF object instance which has to be eventually freed with |
97 | * **btf__free()** |
98 | * |
99 | * If *base_btf* is NULL, `btf__new_empty_split()` is equivalent to |
100 | * `btf__new_empty()` and creates non-split BTF. |
101 | * |
102 | * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract |
103 | * error code from such a pointer `libbpf_get_error()` should be used. If |
104 | * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is |
105 | * returned on error instead. In both cases thread-local `errno` variable is |
106 | * always set to error code as well. |
107 | */ |
108 | LIBBPF_API struct btf *btf__new_empty_split(struct btf *base_btf); |
109 | |
110 | LIBBPF_API struct btf *btf__parse(const char *path, struct btf_ext **btf_ext); |
111 | LIBBPF_API struct btf *btf__parse_split(const char *path, struct btf *base_btf); |
112 | LIBBPF_API struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext); |
113 | LIBBPF_API struct btf *btf__parse_elf_split(const char *path, struct btf *base_btf); |
114 | LIBBPF_API struct btf *btf__parse_raw(const char *path); |
115 | LIBBPF_API struct btf *btf__parse_raw_split(const char *path, struct btf *base_btf); |
116 | |
117 | LIBBPF_API struct btf *btf__load_vmlinux_btf(void); |
118 | LIBBPF_API struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_btf); |
119 | |
120 | LIBBPF_API struct btf *btf__load_from_kernel_by_id(__u32 id); |
121 | LIBBPF_API struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf); |
122 | |
123 | LIBBPF_API int btf__load_into_kernel(struct btf *btf); |
124 | LIBBPF_API __s32 btf__find_by_name(const struct btf *btf, |
125 | const char *type_name); |
126 | LIBBPF_API __s32 btf__find_by_name_kind(const struct btf *btf, |
127 | const char *type_name, __u32 kind); |
128 | LIBBPF_API __u32 btf__type_cnt(const struct btf *btf); |
129 | LIBBPF_API const struct btf *btf__base_btf(const struct btf *btf); |
130 | LIBBPF_API const struct btf_type *btf__type_by_id(const struct btf *btf, |
131 | __u32 id); |
132 | LIBBPF_API size_t btf__pointer_size(const struct btf *btf); |
133 | LIBBPF_API int btf__set_pointer_size(struct btf *btf, size_t ptr_sz); |
134 | LIBBPF_API enum btf_endianness btf__endianness(const struct btf *btf); |
135 | LIBBPF_API int btf__set_endianness(struct btf *btf, enum btf_endianness endian); |
136 | LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id); |
137 | LIBBPF_API int btf__resolve_type(const struct btf *btf, __u32 type_id); |
138 | LIBBPF_API int btf__align_of(const struct btf *btf, __u32 id); |
139 | LIBBPF_API int btf__fd(const struct btf *btf); |
140 | LIBBPF_API void btf__set_fd(struct btf *btf, int fd); |
141 | LIBBPF_API const void *btf__raw_data(const struct btf *btf, __u32 *size); |
142 | LIBBPF_API const char *btf__name_by_offset(const struct btf *btf, __u32 offset); |
143 | LIBBPF_API const char *btf__str_by_offset(const struct btf *btf, __u32 offset); |
144 | |
145 | LIBBPF_API struct btf_ext *btf_ext__new(const __u8 *data, __u32 size); |
146 | LIBBPF_API void btf_ext__free(struct btf_ext *btf_ext); |
147 | LIBBPF_API const void *btf_ext__raw_data(const struct btf_ext *btf_ext, __u32 *size); |
148 | |
149 | LIBBPF_API int btf__find_str(struct btf *btf, const char *s); |
150 | LIBBPF_API int btf__add_str(struct btf *btf, const char *s); |
151 | LIBBPF_API int btf__add_type(struct btf *btf, const struct btf *src_btf, |
152 | const struct btf_type *src_type); |
153 | /** |
154 | * @brief **btf__add_btf()** appends all the BTF types from *src_btf* into *btf* |
155 | * @param btf BTF object which all the BTF types and strings are added to |
156 | * @param src_btf BTF object which all BTF types and referenced strings are copied from |
157 | * @return BTF type ID of the first appended BTF type, or negative error code |
158 | * |
159 | * **btf__add_btf()** can be used to simply and efficiently append the entire |
160 | * contents of one BTF object to another one. All the BTF type data is copied |
161 | * over, all referenced type IDs are adjusted by adding a necessary ID offset. |
162 | * Only strings referenced from BTF types are copied over and deduplicated, so |
163 | * if there were some unused strings in *src_btf*, those won't be copied over, |
164 | * which is consistent with the general string deduplication semantics of BTF |
165 | * writing APIs. |
166 | * |
167 | * If any error is encountered during this process, the contents of *btf* is |
168 | * left intact, which means that **btf__add_btf()** follows the transactional |
169 | * semantics and the operation as a whole is all-or-nothing. |
170 | * |
171 | * *src_btf* has to be non-split BTF, as of now copying types from split BTF |
172 | * is not supported and will result in -ENOTSUP error code returned. |
173 | */ |
174 | LIBBPF_API int btf__add_btf(struct btf *btf, const struct btf *src_btf); |
175 | |
176 | LIBBPF_API int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding); |
177 | LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz); |
178 | LIBBPF_API int btf__add_ptr(struct btf *btf, int ref_type_id); |
179 | LIBBPF_API int btf__add_array(struct btf *btf, |
180 | int index_type_id, int elem_type_id, __u32 nr_elems); |
181 | /* struct/union construction APIs */ |
182 | LIBBPF_API int btf__add_struct(struct btf *btf, const char *name, __u32 sz); |
183 | LIBBPF_API int btf__add_union(struct btf *btf, const char *name, __u32 sz); |
184 | LIBBPF_API int btf__add_field(struct btf *btf, const char *name, int field_type_id, |
185 | __u32 bit_offset, __u32 bit_size); |
186 | |
187 | /* enum construction APIs */ |
188 | LIBBPF_API int btf__add_enum(struct btf *btf, const char *name, __u32 bytes_sz); |
189 | LIBBPF_API int btf__add_enum_value(struct btf *btf, const char *name, __s64 value); |
190 | LIBBPF_API int btf__add_enum64(struct btf *btf, const char *name, __u32 bytes_sz, bool is_signed); |
191 | LIBBPF_API int btf__add_enum64_value(struct btf *btf, const char *name, __u64 value); |
192 | |
193 | enum btf_fwd_kind { |
194 | BTF_FWD_STRUCT = 0, |
195 | BTF_FWD_UNION = 1, |
196 | BTF_FWD_ENUM = 2, |
197 | }; |
198 | |
199 | LIBBPF_API int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind); |
200 | LIBBPF_API int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id); |
201 | LIBBPF_API int btf__add_volatile(struct btf *btf, int ref_type_id); |
202 | LIBBPF_API int btf__add_const(struct btf *btf, int ref_type_id); |
203 | LIBBPF_API int btf__add_restrict(struct btf *btf, int ref_type_id); |
204 | LIBBPF_API int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id); |
205 | |
206 | /* func and func_proto construction APIs */ |
207 | LIBBPF_API int btf__add_func(struct btf *btf, const char *name, |
208 | enum btf_func_linkage linkage, int proto_type_id); |
209 | LIBBPF_API int btf__add_func_proto(struct btf *btf, int ret_type_id); |
210 | LIBBPF_API int btf__add_func_param(struct btf *btf, const char *name, int type_id); |
211 | |
212 | /* var & datasec construction APIs */ |
213 | LIBBPF_API int btf__add_var(struct btf *btf, const char *name, int linkage, int type_id); |
214 | LIBBPF_API int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz); |
215 | LIBBPF_API int btf__add_datasec_var_info(struct btf *btf, int var_type_id, |
216 | __u32 offset, __u32 byte_sz); |
217 | |
218 | /* tag construction API */ |
219 | LIBBPF_API int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id, |
220 | int component_idx); |
221 | |
222 | struct btf_dedup_opts { |
223 | size_t sz; |
224 | /* optional .BTF.ext info to dedup along the main BTF info */ |
225 | struct btf_ext *btf_ext; |
226 | /* force hash collisions (used for testing) */ |
227 | bool force_collisions; |
228 | size_t :0; |
229 | }; |
230 | #define btf_dedup_opts__last_field force_collisions |
231 | |
232 | LIBBPF_API int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts); |
233 | |
234 | struct btf_dump; |
235 | |
236 | struct btf_dump_opts { |
237 | size_t sz; |
238 | }; |
239 | #define btf_dump_opts__last_field sz |
240 | |
241 | typedef void (*btf_dump_printf_fn_t)(void *ctx, const char *fmt, va_list args); |
242 | |
243 | LIBBPF_API struct btf_dump *btf_dump__new(const struct btf *btf, |
244 | btf_dump_printf_fn_t printf_fn, |
245 | void *ctx, |
246 | const struct btf_dump_opts *opts); |
247 | |
248 | LIBBPF_API void btf_dump__free(struct btf_dump *d); |
249 | |
250 | LIBBPF_API int btf_dump__dump_type(struct btf_dump *d, __u32 id); |
251 | |
252 | struct btf_dump_emit_type_decl_opts { |
253 | /* size of this struct, for forward/backward compatiblity */ |
254 | size_t sz; |
255 | /* optional field name for type declaration, e.g.: |
256 | * - struct my_struct <FNAME> |
257 | * - void (*<FNAME>)(int) |
258 | * - char (*<FNAME>)[123] |
259 | */ |
260 | const char *field_name; |
261 | /* extra indentation level (in number of tabs) to emit for multi-line |
262 | * type declarations (e.g., anonymous struct); applies for lines |
263 | * starting from the second one (first line is assumed to have |
264 | * necessary indentation already |
265 | */ |
266 | int indent_level; |
267 | /* strip all the const/volatile/restrict mods */ |
268 | bool strip_mods; |
269 | size_t :0; |
270 | }; |
271 | #define btf_dump_emit_type_decl_opts__last_field strip_mods |
272 | |
273 | LIBBPF_API int |
274 | btf_dump__emit_type_decl(struct btf_dump *d, __u32 id, |
275 | const struct btf_dump_emit_type_decl_opts *opts); |
276 | |
277 | |
278 | struct btf_dump_type_data_opts { |
279 | /* size of this struct, for forward/backward compatibility */ |
280 | size_t sz; |
281 | const char *indent_str; |
282 | int indent_level; |
283 | /* below match "show" flags for bpf_show_snprintf() */ |
284 | bool compact; /* no newlines/indentation */ |
285 | bool skip_names; /* skip member/type names */ |
286 | bool emit_zeroes; /* show 0-valued fields */ |
287 | size_t :0; |
288 | }; |
289 | #define btf_dump_type_data_opts__last_field emit_zeroes |
290 | |
291 | LIBBPF_API int |
292 | btf_dump__dump_type_data(struct btf_dump *d, __u32 id, |
293 | const void *data, size_t data_sz, |
294 | const struct btf_dump_type_data_opts *opts); |
295 | |
296 | /* |
297 | * A set of helpers for easier BTF types handling. |
298 | * |
299 | * The inline functions below rely on constants from the kernel headers which |
300 | * may not be available for applications including this header file. To avoid |
301 | * compilation errors, we define all the constants here that were added after |
302 | * the initial introduction of the BTF_KIND* constants. |
303 | */ |
304 | #ifndef BTF_KIND_FUNC |
305 | #define BTF_KIND_FUNC 12 /* Function */ |
306 | #define BTF_KIND_FUNC_PROTO 13 /* Function Proto */ |
307 | #endif |
308 | #ifndef BTF_KIND_VAR |
309 | #define BTF_KIND_VAR 14 /* Variable */ |
310 | #define BTF_KIND_DATASEC 15 /* Section */ |
311 | #endif |
312 | #ifndef BTF_KIND_FLOAT |
313 | #define BTF_KIND_FLOAT 16 /* Floating point */ |
314 | #endif |
315 | /* The kernel header switched to enums, so the following were never #defined */ |
316 | #define BTF_KIND_DECL_TAG 17 /* Decl Tag */ |
317 | #define BTF_KIND_TYPE_TAG 18 /* Type Tag */ |
318 | #define BTF_KIND_ENUM64 19 /* Enum for up-to 64bit values */ |
319 | |
320 | static inline __u16 btf_kind(const struct btf_type *t) |
321 | { |
322 | return BTF_INFO_KIND(t->info); |
323 | } |
324 | |
325 | static inline __u16 btf_vlen(const struct btf_type *t) |
326 | { |
327 | return BTF_INFO_VLEN(t->info); |
328 | } |
329 | |
330 | static inline bool btf_kflag(const struct btf_type *t) |
331 | { |
332 | return BTF_INFO_KFLAG(t->info); |
333 | } |
334 | |
335 | static inline bool btf_is_void(const struct btf_type *t) |
336 | { |
337 | return btf_kind(t) == BTF_KIND_UNKN; |
338 | } |
339 | |
340 | static inline bool btf_is_int(const struct btf_type *t) |
341 | { |
342 | return btf_kind(t) == BTF_KIND_INT; |
343 | } |
344 | |
345 | static inline bool btf_is_ptr(const struct btf_type *t) |
346 | { |
347 | return btf_kind(t) == BTF_KIND_PTR; |
348 | } |
349 | |
350 | static inline bool btf_is_array(const struct btf_type *t) |
351 | { |
352 | return btf_kind(t) == BTF_KIND_ARRAY; |
353 | } |
354 | |
355 | static inline bool btf_is_struct(const struct btf_type *t) |
356 | { |
357 | return btf_kind(t) == BTF_KIND_STRUCT; |
358 | } |
359 | |
360 | static inline bool btf_is_union(const struct btf_type *t) |
361 | { |
362 | return btf_kind(t) == BTF_KIND_UNION; |
363 | } |
364 | |
365 | static inline bool btf_is_composite(const struct btf_type *t) |
366 | { |
367 | __u16 kind = btf_kind(t); |
368 | |
369 | return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION; |
370 | } |
371 | |
372 | static inline bool btf_is_enum(const struct btf_type *t) |
373 | { |
374 | return btf_kind(t) == BTF_KIND_ENUM; |
375 | } |
376 | |
377 | static inline bool btf_is_enum64(const struct btf_type *t) |
378 | { |
379 | return btf_kind(t) == BTF_KIND_ENUM64; |
380 | } |
381 | |
382 | static inline bool btf_is_fwd(const struct btf_type *t) |
383 | { |
384 | return btf_kind(t) == BTF_KIND_FWD; |
385 | } |
386 | |
387 | static inline bool btf_is_typedef(const struct btf_type *t) |
388 | { |
389 | return btf_kind(t) == BTF_KIND_TYPEDEF; |
390 | } |
391 | |
392 | static inline bool btf_is_volatile(const struct btf_type *t) |
393 | { |
394 | return btf_kind(t) == BTF_KIND_VOLATILE; |
395 | } |
396 | |
397 | static inline bool btf_is_const(const struct btf_type *t) |
398 | { |
399 | return btf_kind(t) == BTF_KIND_CONST; |
400 | } |
401 | |
402 | static inline bool btf_is_restrict(const struct btf_type *t) |
403 | { |
404 | return btf_kind(t) == BTF_KIND_RESTRICT; |
405 | } |
406 | |
407 | static inline bool btf_is_mod(const struct btf_type *t) |
408 | { |
409 | __u16 kind = btf_kind(t); |
410 | |
411 | return kind == BTF_KIND_VOLATILE || |
412 | kind == BTF_KIND_CONST || |
413 | kind == BTF_KIND_RESTRICT || |
414 | kind == BTF_KIND_TYPE_TAG; |
415 | } |
416 | |
417 | static inline bool btf_is_func(const struct btf_type *t) |
418 | { |
419 | return btf_kind(t) == BTF_KIND_FUNC; |
420 | } |
421 | |
422 | static inline bool btf_is_func_proto(const struct btf_type *t) |
423 | { |
424 | return btf_kind(t) == BTF_KIND_FUNC_PROTO; |
425 | } |
426 | |
427 | static inline bool btf_is_var(const struct btf_type *t) |
428 | { |
429 | return btf_kind(t) == BTF_KIND_VAR; |
430 | } |
431 | |
432 | static inline bool btf_is_datasec(const struct btf_type *t) |
433 | { |
434 | return btf_kind(t) == BTF_KIND_DATASEC; |
435 | } |
436 | |
437 | static inline bool btf_is_float(const struct btf_type *t) |
438 | { |
439 | return btf_kind(t) == BTF_KIND_FLOAT; |
440 | } |
441 | |
442 | static inline bool btf_is_decl_tag(const struct btf_type *t) |
443 | { |
444 | return btf_kind(t) == BTF_KIND_DECL_TAG; |
445 | } |
446 | |
447 | static inline bool btf_is_type_tag(const struct btf_type *t) |
448 | { |
449 | return btf_kind(t) == BTF_KIND_TYPE_TAG; |
450 | } |
451 | |
452 | static inline bool btf_is_any_enum(const struct btf_type *t) |
453 | { |
454 | return btf_is_enum(t) || btf_is_enum64(t); |
455 | } |
456 | |
457 | static inline bool btf_kind_core_compat(const struct btf_type *t1, |
458 | const struct btf_type *t2) |
459 | { |
460 | return btf_kind(t1) == btf_kind(t2) || |
461 | (btf_is_any_enum(t1) && btf_is_any_enum(t2)); |
462 | } |
463 | |
464 | static inline __u8 btf_int_encoding(const struct btf_type *t) |
465 | { |
466 | return BTF_INT_ENCODING(*(__u32 *)(t + 1)); |
467 | } |
468 | |
469 | static inline __u8 btf_int_offset(const struct btf_type *t) |
470 | { |
471 | return BTF_INT_OFFSET(*(__u32 *)(t + 1)); |
472 | } |
473 | |
474 | static inline __u8 btf_int_bits(const struct btf_type *t) |
475 | { |
476 | return BTF_INT_BITS(*(__u32 *)(t + 1)); |
477 | } |
478 | |
479 | static inline struct btf_array *btf_array(const struct btf_type *t) |
480 | { |
481 | return (struct btf_array *)(t + 1); |
482 | } |
483 | |
484 | static inline struct btf_enum *btf_enum(const struct btf_type *t) |
485 | { |
486 | return (struct btf_enum *)(t + 1); |
487 | } |
488 | |
489 | struct btf_enum64; |
490 | |
491 | static inline struct btf_enum64 *btf_enum64(const struct btf_type *t) |
492 | { |
493 | return (struct btf_enum64 *)(t + 1); |
494 | } |
495 | |
496 | static inline __u64 btf_enum64_value(const struct btf_enum64 *e) |
497 | { |
498 | /* struct btf_enum64 is introduced in Linux 6.0, which is very |
499 | * bleeding-edge. Here we are avoiding relying on struct btf_enum64 |
500 | * definition coming from kernel UAPI headers to support wider range |
501 | * of system-wide kernel headers. |
502 | * |
503 | * Given this header can be also included from C++ applications, that |
504 | * further restricts C tricks we can use (like using compatible |
505 | * anonymous struct). So just treat struct btf_enum64 as |
506 | * a three-element array of u32 and access second (lo32) and third |
507 | * (hi32) elements directly. |
508 | * |
509 | * For reference, here is a struct btf_enum64 definition: |
510 | * |
511 | * const struct btf_enum64 { |
512 | * __u32 name_off; |
513 | * __u32 val_lo32; |
514 | * __u32 val_hi32; |
515 | * }; |
516 | */ |
517 | const __u32 *e64 = (const __u32 *)e; |
518 | |
519 | return ((__u64)e64[2] << 32) | e64[1]; |
520 | } |
521 | |
522 | static inline struct btf_member *btf_members(const struct btf_type *t) |
523 | { |
524 | return (struct btf_member *)(t + 1); |
525 | } |
526 | |
527 | /* Get bit offset of a member with specified index. */ |
528 | static inline __u32 btf_member_bit_offset(const struct btf_type *t, |
529 | __u32 member_idx) |
530 | { |
531 | const struct btf_member *m = btf_members(t) + member_idx; |
532 | bool kflag = btf_kflag(t); |
533 | |
534 | return kflag ? BTF_MEMBER_BIT_OFFSET(m->offset) : m->offset; |
535 | } |
536 | /* |
537 | * Get bitfield size of a member, assuming t is BTF_KIND_STRUCT or |
538 | * BTF_KIND_UNION. If member is not a bitfield, zero is returned. |
539 | */ |
540 | static inline __u32 btf_member_bitfield_size(const struct btf_type *t, |
541 | __u32 member_idx) |
542 | { |
543 | const struct btf_member *m = btf_members(t) + member_idx; |
544 | bool kflag = btf_kflag(t); |
545 | |
546 | return kflag ? BTF_MEMBER_BITFIELD_SIZE(m->offset) : 0; |
547 | } |
548 | |
549 | static inline struct btf_param *btf_params(const struct btf_type *t) |
550 | { |
551 | return (struct btf_param *)(t + 1); |
552 | } |
553 | |
554 | static inline struct btf_var *btf_var(const struct btf_type *t) |
555 | { |
556 | return (struct btf_var *)(t + 1); |
557 | } |
558 | |
559 | static inline struct btf_var_secinfo * |
560 | btf_var_secinfos(const struct btf_type *t) |
561 | { |
562 | return (struct btf_var_secinfo *)(t + 1); |
563 | } |
564 | |
565 | struct btf_decl_tag; |
566 | static inline struct btf_decl_tag *btf_decl_tag(const struct btf_type *t) |
567 | { |
568 | return (struct btf_decl_tag *)(t + 1); |
569 | } |
570 | |
571 | #ifdef __cplusplus |
572 | } /* extern "C" */ |
573 | #endif |
574 | |
575 | #endif /* __LIBBPF_BTF_H */ |
576 | |