tools/lib/bpf/btf.h

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