612 lines · c
1/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */2/* Copyright (c) 2018 Facebook */3/*! \file */4 5#ifndef __LIBBPF_BTF_H6#define __LIBBPF_BTF_H7 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 __cplusplus16extern "C" {17#endif18 19#define BTF_ELF_SEC ".BTF"20#define BTF_EXT_ELF_SEC ".BTF.ext"21#define BTF_BASE_ELF_SEC ".BTF.base"22#define MAPS_ELF_SEC ".maps"23 24struct btf;25struct btf_ext;26struct btf_type;27 28struct bpf_object;29 30enum btf_endianness {31 BTF_LITTLE_ENDIAN = 0,32 BTF_BIG_ENDIAN = 1,33};34 35/**36 * @brief **btf__free()** frees all data of a BTF object37 * @param btf BTF object to free38 */39LIBBPF_API void btf__free(struct btf *btf);40 41/**42 * @brief **btf__new()** creates a new instance of a BTF object from the raw43 * bytes of an ELF's BTF section44 * @param data raw bytes45 * @param size number of bytes passed in `data`46 * @return new BTF object instance which has to be eventually freed with47 * **btf__free()**48 *49 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract50 * error code from such a pointer `libbpf_get_error()` should be used. If51 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is52 * returned on error instead. In both cases thread-local `errno` variable is53 * always set to error code as well.54 */55LIBBPF_API struct btf *btf__new(const void *data, __u32 size);56 57/**58 * @brief **btf__new_split()** create a new instance of a BTF object from the59 * provided raw data bytes. It takes another BTF instance, **base_btf**, which60 * serves as a base BTF, which is extended by types in a newly created BTF61 * instance62 * @param data raw bytes63 * @param size length of raw bytes64 * @param base_btf the base BTF object65 * @return new BTF object instance which has to be eventually freed with66 * **btf__free()**67 *68 * If *base_btf* is NULL, `btf__new_split()` is equivalent to `btf__new()` and69 * creates non-split BTF.70 *71 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract72 * error code from such a pointer `libbpf_get_error()` should be used. If73 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is74 * returned on error instead. In both cases thread-local `errno` variable is75 * always set to error code as well.76 */77LIBBPF_API struct btf *btf__new_split(const void *data, __u32 size, struct btf *base_btf);78 79/**80 * @brief **btf__new_empty()** creates an empty BTF object. Use81 * `btf__add_*()` to populate such BTF object.82 * @return new BTF object instance which has to be eventually freed with83 * **btf__free()**84 *85 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract86 * error code from such a pointer `libbpf_get_error()` should be used. If87 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is88 * returned on error instead. In both cases thread-local `errno` variable is89 * always set to error code as well.90 */91LIBBPF_API struct btf *btf__new_empty(void);92 93/**94 * @brief **btf__new_empty_split()** creates an unpopulated BTF object from an95 * ELF BTF section except with a base BTF on top of which split BTF should be96 * based97 * @return new BTF object instance which has to be eventually freed with98 * **btf__free()**99 *100 * If *base_btf* is NULL, `btf__new_empty_split()` is equivalent to101 * `btf__new_empty()` and creates non-split BTF.102 *103 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract104 * error code from such a pointer `libbpf_get_error()` should be used. If105 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is106 * returned on error instead. In both cases thread-local `errno` variable is107 * always set to error code as well.108 */109LIBBPF_API struct btf *btf__new_empty_split(struct btf *base_btf);110 111/**112 * @brief **btf__distill_base()** creates new versions of the split BTF113 * *src_btf* and its base BTF. The new base BTF will only contain the types114 * needed to improve robustness of the split BTF to small changes in base BTF.115 * When that split BTF is loaded against a (possibly changed) base, this116 * distilled base BTF will help update references to that (possibly changed)117 * base BTF.118 *119 * Both the new split and its associated new base BTF must be freed by120 * the caller.121 *122 * If successful, 0 is returned and **new_base_btf** and **new_split_btf**123 * will point at new base/split BTF. Both the new split and its associated124 * new base BTF must be freed by the caller.125 *126 * A negative value is returned on error and the thread-local `errno` variable127 * is set to the error code as well.128 */129LIBBPF_API int btf__distill_base(const struct btf *src_btf, struct btf **new_base_btf,130 struct btf **new_split_btf);131 132LIBBPF_API struct btf *btf__parse(const char *path, struct btf_ext **btf_ext);133LIBBPF_API struct btf *btf__parse_split(const char *path, struct btf *base_btf);134LIBBPF_API struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext);135LIBBPF_API struct btf *btf__parse_elf_split(const char *path, struct btf *base_btf);136LIBBPF_API struct btf *btf__parse_raw(const char *path);137LIBBPF_API struct btf *btf__parse_raw_split(const char *path, struct btf *base_btf);138 139LIBBPF_API struct btf *btf__load_vmlinux_btf(void);140LIBBPF_API struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_btf);141 142LIBBPF_API struct btf *btf__load_from_kernel_by_id(__u32 id);143LIBBPF_API struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf);144 145LIBBPF_API int btf__load_into_kernel(struct btf *btf);146LIBBPF_API __s32 btf__find_by_name(const struct btf *btf,147 const char *type_name);148LIBBPF_API __s32 btf__find_by_name_kind(const struct btf *btf,149 const char *type_name, __u32 kind);150LIBBPF_API __u32 btf__type_cnt(const struct btf *btf);151LIBBPF_API const struct btf *btf__base_btf(const struct btf *btf);152LIBBPF_API const struct btf_type *btf__type_by_id(const struct btf *btf,153 __u32 id);154LIBBPF_API size_t btf__pointer_size(const struct btf *btf);155LIBBPF_API int btf__set_pointer_size(struct btf *btf, size_t ptr_sz);156LIBBPF_API enum btf_endianness btf__endianness(const struct btf *btf);157LIBBPF_API int btf__set_endianness(struct btf *btf, enum btf_endianness endian);158LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id);159LIBBPF_API int btf__resolve_type(const struct btf *btf, __u32 type_id);160LIBBPF_API int btf__align_of(const struct btf *btf, __u32 id);161LIBBPF_API int btf__fd(const struct btf *btf);162LIBBPF_API void btf__set_fd(struct btf *btf, int fd);163LIBBPF_API const void *btf__raw_data(const struct btf *btf, __u32 *size);164LIBBPF_API const char *btf__name_by_offset(const struct btf *btf, __u32 offset);165LIBBPF_API const char *btf__str_by_offset(const struct btf *btf, __u32 offset);166 167LIBBPF_API struct btf_ext *btf_ext__new(const __u8 *data, __u32 size);168LIBBPF_API void btf_ext__free(struct btf_ext *btf_ext);169LIBBPF_API const void *btf_ext__raw_data(const struct btf_ext *btf_ext, __u32 *size);170 171LIBBPF_API int btf__find_str(struct btf *btf, const char *s);172LIBBPF_API int btf__add_str(struct btf *btf, const char *s);173LIBBPF_API int btf__add_type(struct btf *btf, const struct btf *src_btf,174 const struct btf_type *src_type);175/**176 * @brief **btf__add_btf()** appends all the BTF types from *src_btf* into *btf*177 * @param btf BTF object which all the BTF types and strings are added to178 * @param src_btf BTF object which all BTF types and referenced strings are copied from179 * @return BTF type ID of the first appended BTF type, or negative error code180 *181 * **btf__add_btf()** can be used to simply and efficiently append the entire182 * contents of one BTF object to another one. All the BTF type data is copied183 * over, all referenced type IDs are adjusted by adding a necessary ID offset.184 * Only strings referenced from BTF types are copied over and deduplicated, so185 * if there were some unused strings in *src_btf*, those won't be copied over,186 * which is consistent with the general string deduplication semantics of BTF187 * writing APIs.188 *189 * If any error is encountered during this process, the contents of *btf* is190 * left intact, which means that **btf__add_btf()** follows the transactional191 * semantics and the operation as a whole is all-or-nothing.192 *193 * *src_btf* has to be non-split BTF, as of now copying types from split BTF194 * is not supported and will result in -ENOTSUP error code returned.195 */196LIBBPF_API int btf__add_btf(struct btf *btf, const struct btf *src_btf);197 198LIBBPF_API int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding);199LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz);200LIBBPF_API int btf__add_ptr(struct btf *btf, int ref_type_id);201LIBBPF_API int btf__add_array(struct btf *btf,202 int index_type_id, int elem_type_id, __u32 nr_elems);203/* struct/union construction APIs */204LIBBPF_API int btf__add_struct(struct btf *btf, const char *name, __u32 sz);205LIBBPF_API int btf__add_union(struct btf *btf, const char *name, __u32 sz);206LIBBPF_API int btf__add_field(struct btf *btf, const char *name, int field_type_id,207 __u32 bit_offset, __u32 bit_size);208 209/* enum construction APIs */210LIBBPF_API int btf__add_enum(struct btf *btf, const char *name, __u32 bytes_sz);211LIBBPF_API int btf__add_enum_value(struct btf *btf, const char *name, __s64 value);212LIBBPF_API int btf__add_enum64(struct btf *btf, const char *name, __u32 bytes_sz, bool is_signed);213LIBBPF_API int btf__add_enum64_value(struct btf *btf, const char *name, __u64 value);214 215enum btf_fwd_kind {216 BTF_FWD_STRUCT = 0,217 BTF_FWD_UNION = 1,218 BTF_FWD_ENUM = 2,219};220 221LIBBPF_API int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind);222LIBBPF_API int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id);223LIBBPF_API int btf__add_volatile(struct btf *btf, int ref_type_id);224LIBBPF_API int btf__add_const(struct btf *btf, int ref_type_id);225LIBBPF_API int btf__add_restrict(struct btf *btf, int ref_type_id);226LIBBPF_API int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id);227 228/* func and func_proto construction APIs */229LIBBPF_API int btf__add_func(struct btf *btf, const char *name,230 enum btf_func_linkage linkage, int proto_type_id);231LIBBPF_API int btf__add_func_proto(struct btf *btf, int ret_type_id);232LIBBPF_API int btf__add_func_param(struct btf *btf, const char *name, int type_id);233 234/* var & datasec construction APIs */235LIBBPF_API int btf__add_var(struct btf *btf, const char *name, int linkage, int type_id);236LIBBPF_API int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz);237LIBBPF_API int btf__add_datasec_var_info(struct btf *btf, int var_type_id,238 __u32 offset, __u32 byte_sz);239 240/* tag construction API */241LIBBPF_API int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,242 int component_idx);243 244struct btf_dedup_opts {245 size_t sz;246 /* optional .BTF.ext info to dedup along the main BTF info */247 struct btf_ext *btf_ext;248 /* force hash collisions (used for testing) */249 bool force_collisions;250 size_t :0;251};252#define btf_dedup_opts__last_field force_collisions253 254LIBBPF_API int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts);255 256/**257 * @brief **btf__relocate()** will check the split BTF *btf* for references258 * to base BTF kinds, and verify those references are compatible with259 * *base_btf*; if they are, *btf* is adjusted such that is re-parented to260 * *base_btf* and type ids and strings are adjusted to accommodate this.261 *262 * If successful, 0 is returned and **btf** now has **base_btf** as its263 * base.264 *265 * A negative value is returned on error and the thread-local `errno` variable266 * is set to the error code as well.267 */268LIBBPF_API int btf__relocate(struct btf *btf, const struct btf *base_btf);269 270struct btf_dump;271 272struct btf_dump_opts {273 size_t sz;274};275#define btf_dump_opts__last_field sz276 277typedef void (*btf_dump_printf_fn_t)(void *ctx, const char *fmt, va_list args);278 279LIBBPF_API struct btf_dump *btf_dump__new(const struct btf *btf,280 btf_dump_printf_fn_t printf_fn,281 void *ctx,282 const struct btf_dump_opts *opts);283 284LIBBPF_API void btf_dump__free(struct btf_dump *d);285 286LIBBPF_API int btf_dump__dump_type(struct btf_dump *d, __u32 id);287 288struct btf_dump_emit_type_decl_opts {289 /* size of this struct, for forward/backward compatibility */290 size_t sz;291 /* optional field name for type declaration, e.g.:292 * - struct my_struct <FNAME>293 * - void (*<FNAME>)(int)294 * - char (*<FNAME>)[123]295 */296 const char *field_name;297 /* extra indentation level (in number of tabs) to emit for multi-line298 * type declarations (e.g., anonymous struct); applies for lines299 * starting from the second one (first line is assumed to have300 * necessary indentation already301 */302 int indent_level;303 /* strip all the const/volatile/restrict mods */304 bool strip_mods;305 size_t :0;306};307#define btf_dump_emit_type_decl_opts__last_field strip_mods308 309LIBBPF_API int310btf_dump__emit_type_decl(struct btf_dump *d, __u32 id,311 const struct btf_dump_emit_type_decl_opts *opts);312 313 314struct btf_dump_type_data_opts {315 /* size of this struct, for forward/backward compatibility */316 size_t sz;317 const char *indent_str;318 int indent_level;319 /* below match "show" flags for bpf_show_snprintf() */320 bool compact; /* no newlines/indentation */321 bool skip_names; /* skip member/type names */322 bool emit_zeroes; /* show 0-valued fields */323 size_t :0;324};325#define btf_dump_type_data_opts__last_field emit_zeroes326 327LIBBPF_API int328btf_dump__dump_type_data(struct btf_dump *d, __u32 id,329 const void *data, size_t data_sz,330 const struct btf_dump_type_data_opts *opts);331 332/*333 * A set of helpers for easier BTF types handling.334 *335 * The inline functions below rely on constants from the kernel headers which336 * may not be available for applications including this header file. To avoid337 * compilation errors, we define all the constants here that were added after338 * the initial introduction of the BTF_KIND* constants.339 */340#ifndef BTF_KIND_FUNC341#define BTF_KIND_FUNC 12 /* Function */342#define BTF_KIND_FUNC_PROTO 13 /* Function Proto */343#endif344#ifndef BTF_KIND_VAR345#define BTF_KIND_VAR 14 /* Variable */346#define BTF_KIND_DATASEC 15 /* Section */347#endif348#ifndef BTF_KIND_FLOAT349#define BTF_KIND_FLOAT 16 /* Floating point */350#endif351/* The kernel header switched to enums, so the following were never #defined */352#define BTF_KIND_DECL_TAG 17 /* Decl Tag */353#define BTF_KIND_TYPE_TAG 18 /* Type Tag */354#define BTF_KIND_ENUM64 19 /* Enum for up-to 64bit values */355 356static inline __u16 btf_kind(const struct btf_type *t)357{358 return BTF_INFO_KIND(t->info);359}360 361static inline __u16 btf_vlen(const struct btf_type *t)362{363 return BTF_INFO_VLEN(t->info);364}365 366static inline bool btf_kflag(const struct btf_type *t)367{368 return BTF_INFO_KFLAG(t->info);369}370 371static inline bool btf_is_void(const struct btf_type *t)372{373 return btf_kind(t) == BTF_KIND_UNKN;374}375 376static inline bool btf_is_int(const struct btf_type *t)377{378 return btf_kind(t) == BTF_KIND_INT;379}380 381static inline bool btf_is_ptr(const struct btf_type *t)382{383 return btf_kind(t) == BTF_KIND_PTR;384}385 386static inline bool btf_is_array(const struct btf_type *t)387{388 return btf_kind(t) == BTF_KIND_ARRAY;389}390 391static inline bool btf_is_struct(const struct btf_type *t)392{393 return btf_kind(t) == BTF_KIND_STRUCT;394}395 396static inline bool btf_is_union(const struct btf_type *t)397{398 return btf_kind(t) == BTF_KIND_UNION;399}400 401static inline bool btf_is_composite(const struct btf_type *t)402{403 __u16 kind = btf_kind(t);404 405 return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;406}407 408static inline bool btf_is_enum(const struct btf_type *t)409{410 return btf_kind(t) == BTF_KIND_ENUM;411}412 413static inline bool btf_is_enum64(const struct btf_type *t)414{415 return btf_kind(t) == BTF_KIND_ENUM64;416}417 418static inline bool btf_is_fwd(const struct btf_type *t)419{420 return btf_kind(t) == BTF_KIND_FWD;421}422 423static inline bool btf_is_typedef(const struct btf_type *t)424{425 return btf_kind(t) == BTF_KIND_TYPEDEF;426}427 428static inline bool btf_is_volatile(const struct btf_type *t)429{430 return btf_kind(t) == BTF_KIND_VOLATILE;431}432 433static inline bool btf_is_const(const struct btf_type *t)434{435 return btf_kind(t) == BTF_KIND_CONST;436}437 438static inline bool btf_is_restrict(const struct btf_type *t)439{440 return btf_kind(t) == BTF_KIND_RESTRICT;441}442 443static inline bool btf_is_mod(const struct btf_type *t)444{445 __u16 kind = btf_kind(t);446 447 return kind == BTF_KIND_VOLATILE ||448 kind == BTF_KIND_CONST ||449 kind == BTF_KIND_RESTRICT ||450 kind == BTF_KIND_TYPE_TAG;451}452 453static inline bool btf_is_func(const struct btf_type *t)454{455 return btf_kind(t) == BTF_KIND_FUNC;456}457 458static inline bool btf_is_func_proto(const struct btf_type *t)459{460 return btf_kind(t) == BTF_KIND_FUNC_PROTO;461}462 463static inline bool btf_is_var(const struct btf_type *t)464{465 return btf_kind(t) == BTF_KIND_VAR;466}467 468static inline bool btf_is_datasec(const struct btf_type *t)469{470 return btf_kind(t) == BTF_KIND_DATASEC;471}472 473static inline bool btf_is_float(const struct btf_type *t)474{475 return btf_kind(t) == BTF_KIND_FLOAT;476}477 478static inline bool btf_is_decl_tag(const struct btf_type *t)479{480 return btf_kind(t) == BTF_KIND_DECL_TAG;481}482 483static inline bool btf_is_type_tag(const struct btf_type *t)484{485 return btf_kind(t) == BTF_KIND_TYPE_TAG;486}487 488static inline bool btf_is_any_enum(const struct btf_type *t)489{490 return btf_is_enum(t) || btf_is_enum64(t);491}492 493static inline bool btf_kind_core_compat(const struct btf_type *t1,494 const struct btf_type *t2)495{496 return btf_kind(t1) == btf_kind(t2) ||497 (btf_is_any_enum(t1) && btf_is_any_enum(t2));498}499 500static inline __u8 btf_int_encoding(const struct btf_type *t)501{502 return BTF_INT_ENCODING(*(__u32 *)(t + 1));503}504 505static inline __u8 btf_int_offset(const struct btf_type *t)506{507 return BTF_INT_OFFSET(*(__u32 *)(t + 1));508}509 510static inline __u8 btf_int_bits(const struct btf_type *t)511{512 return BTF_INT_BITS(*(__u32 *)(t + 1));513}514 515static inline struct btf_array *btf_array(const struct btf_type *t)516{517 return (struct btf_array *)(t + 1);518}519 520static inline struct btf_enum *btf_enum(const struct btf_type *t)521{522 return (struct btf_enum *)(t + 1);523}524 525struct btf_enum64;526 527static inline struct btf_enum64 *btf_enum64(const struct btf_type *t)528{529 return (struct btf_enum64 *)(t + 1);530}531 532static inline __u64 btf_enum64_value(const struct btf_enum64 *e)533{534 /* struct btf_enum64 is introduced in Linux 6.0, which is very535 * bleeding-edge. Here we are avoiding relying on struct btf_enum64536 * definition coming from kernel UAPI headers to support wider range537 * of system-wide kernel headers.538 *539 * Given this header can be also included from C++ applications, that540 * further restricts C tricks we can use (like using compatible541 * anonymous struct). So just treat struct btf_enum64 as542 * a three-element array of u32 and access second (lo32) and third543 * (hi32) elements directly.544 *545 * For reference, here is a struct btf_enum64 definition:546 *547 * const struct btf_enum64 {548 * __u32 name_off;549 * __u32 val_lo32;550 * __u32 val_hi32;551 * };552 */553 const __u32 *e64 = (const __u32 *)e;554 555 return ((__u64)e64[2] << 32) | e64[1];556}557 558static inline struct btf_member *btf_members(const struct btf_type *t)559{560 return (struct btf_member *)(t + 1);561}562 563/* Get bit offset of a member with specified index. */564static inline __u32 btf_member_bit_offset(const struct btf_type *t,565 __u32 member_idx)566{567 const struct btf_member *m = btf_members(t) + member_idx;568 bool kflag = btf_kflag(t);569 570 return kflag ? BTF_MEMBER_BIT_OFFSET(m->offset) : m->offset;571}572/*573 * Get bitfield size of a member, assuming t is BTF_KIND_STRUCT or574 * BTF_KIND_UNION. If member is not a bitfield, zero is returned.575 */576static inline __u32 btf_member_bitfield_size(const struct btf_type *t,577 __u32 member_idx)578{579 const struct btf_member *m = btf_members(t) + member_idx;580 bool kflag = btf_kflag(t);581 582 return kflag ? BTF_MEMBER_BITFIELD_SIZE(m->offset) : 0;583}584 585static inline struct btf_param *btf_params(const struct btf_type *t)586{587 return (struct btf_param *)(t + 1);588}589 590static inline struct btf_var *btf_var(const struct btf_type *t)591{592 return (struct btf_var *)(t + 1);593}594 595static inline struct btf_var_secinfo *596btf_var_secinfos(const struct btf_type *t)597{598 return (struct btf_var_secinfo *)(t + 1);599}600 601struct btf_decl_tag;602static inline struct btf_decl_tag *btf_decl_tag(const struct btf_type *t)603{604 return (struct btf_decl_tag *)(t + 1);605}606 607#ifdef __cplusplus608} /* extern "C" */609#endif610 611#endif /* __LIBBPF_BTF_H */612