btf.h 20 KB
Newer Older
1
/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
2
/* Copyright (c) 2018 Facebook */
3
/*! \file */
4

5 6
#ifndef __LIBBPF_BTF_H
#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 14
#include "libbpf_common.h"

15 16 17 18
#ifdef __cplusplus
extern "C" {
#endif

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 29
struct bpf_object;

30 31 32 33 34
enum btf_endianness {
	BTF_LITTLE_ENDIAN = 0,
	BTF_BIG_ENDIAN = 1,
};

35 36 37 38
/**
 * @brief **btf__free()** frees all data of a BTF object
 * @param btf BTF object to free
 */
39
LIBBPF_API void btf__free(struct btf *btf);
40

41 42 43 44 45 46 47 48 49 50 51 52 53 54
/**
 * @brief **btf__new()** creates a new instance of a BTF object from the raw
 * bytes of an ELF's BTF section
 * @param data raw bytes
 * @param size number of bytes passed in `data`
 * @return new BTF object instance which has to be eventually freed with
 * **btf__free()**
 *
 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
 * error code from such a pointer `libbpf_get_error()` should be used. If
 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
 * returned on error instead. In both cases thread-local `errno` variable is
 * always set to error code as well.
 */
55
LIBBPF_API struct btf *btf__new(const void *data, __u32 size);
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

/**
 * @brief **btf__new_split()** create a new instance of a BTF object from the
 * provided raw data bytes. It takes another BTF instance, **base_btf**, which
 * serves as a base BTF, which is extended by types in a newly created BTF
 * instance
 * @param data raw bytes
 * @param size length of raw bytes
 * @param base_btf the base BTF object
 * @return new BTF object instance which has to be eventually freed with
 * **btf__free()**
 *
 * If *base_btf* is NULL, `btf__new_split()` is equivalent to `btf__new()` and
 * creates non-split BTF.
 *
 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
 * error code from such a pointer `libbpf_get_error()` should be used. If
 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
 * returned on error instead. In both cases thread-local `errno` variable is
 * always set to error code as well.
 */
77
LIBBPF_API struct btf *btf__new_split(const void *data, __u32 size, struct btf *base_btf);
78 79 80 81 82 83 84 85 86 87 88 89 90

/**
 * @brief **btf__new_empty()** creates an empty BTF object.  Use
 * `btf__add_*()` to populate such BTF object.
 * @return new BTF object instance which has to be eventually freed with
 * **btf__free()**
 *
 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
 * error code from such a pointer `libbpf_get_error()` should be used. If
 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
 * returned on error instead. In both cases thread-local `errno` variable is
 * always set to error code as well.
 */
91
LIBBPF_API struct btf *btf__new_empty(void);
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

/**
 * @brief **btf__new_empty_split()** creates an unpopulated BTF object from an
 * ELF BTF section except with a base BTF on top of which split BTF should be
 * based
 * @return new BTF object instance which has to be eventually freed with
 * **btf__free()**
 *
 * If *base_btf* is NULL, `btf__new_empty_split()` is equivalent to
 * `btf__new_empty()` and creates non-split BTF.
 *
 * On error, error-code-encoded-as-pointer is returned, not a NULL. To extract
 * error code from such a pointer `libbpf_get_error()` should be used. If
 * `libbpf_set_strict_mode(LIBBPF_STRICT_CLEAN_PTRS)` is enabled, NULL is
 * returned on error instead. In both cases thread-local `errno` variable is
 * always set to error code as well.
 */
109 110
LIBBPF_API struct btf *btf__new_empty_split(struct btf *base_btf);

111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/**
 * @brief **btf__distill_base()** creates new versions of the split BTF
 * *src_btf* and its base BTF. The new base BTF will only contain the types
 * needed to improve robustness of the split BTF to small changes in base BTF.
 * When that split BTF is loaded against a (possibly changed) base, this
 * distilled base BTF will help update references to that (possibly changed)
 * base BTF.
 *
 * Both the new split and its associated new base BTF must be freed by
 * the caller.
 *
 * If successful, 0 is returned and **new_base_btf** and **new_split_btf**
 * will point at new base/split BTF. Both the new split and its associated
 * new base BTF must be freed by the caller.
 *
 * A negative value is returned on error and the thread-local `errno` variable
 * is set to the error code as well.
 */
LIBBPF_API int btf__distill_base(const struct btf *src_btf, struct btf **new_base_btf,
				 struct btf **new_split_btf);

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 138
LIBBPF_API struct btf *btf__parse_raw_split(const char *path, struct btf *base_btf);

139 140 141
LIBBPF_API struct btf *btf__load_vmlinux_btf(void);
LIBBPF_API struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_btf);

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 147
LIBBPF_API __s32 btf__find_by_name(const struct btf *btf,
				   const char *type_name);
148 149
LIBBPF_API __s32 btf__find_by_name_kind(const struct btf *btf,
					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 153
LIBBPF_API const struct btf_type *btf__type_by_id(const struct btf *btf,
						  __u32 id);
154 155
LIBBPF_API size_t btf__pointer_size(const struct btf *btf);
LIBBPF_API int btf__set_pointer_size(struct btf *btf, size_t ptr_sz);
156 157
LIBBPF_API enum btf_endianness btf__endianness(const struct btf *btf);
LIBBPF_API int btf__set_endianness(struct btf *btf, enum btf_endianness endian);
158 159
LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id);
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

171 172
LIBBPF_API int btf__find_str(struct btf *btf, const char *s);
LIBBPF_API int btf__add_str(struct btf *btf, const char *s);
173 174
LIBBPF_API int btf__add_type(struct btf *btf, const struct btf *src_btf,
			     const struct btf_type *src_type);
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
/**
 * @brief **btf__add_btf()** appends all the BTF types from *src_btf* into *btf*
 * @param btf BTF object which all the BTF types and strings are added to
 * @param src_btf BTF object which all BTF types and referenced strings are copied from
 * @return BTF type ID of the first appended BTF type, or negative error code
 *
 * **btf__add_btf()** can be used to simply and efficiently append the entire
 * contents of one BTF object to another one. All the BTF type data is copied
 * over, all referenced type IDs are adjusted by adding a necessary ID offset.
 * Only strings referenced from BTF types are copied over and deduplicated, so
 * if there were some unused strings in *src_btf*, those won't be copied over,
 * which is consistent with the general string deduplication semantics of BTF
 * writing APIs.
 *
 * If any error is encountered during this process, the contents of *btf* is
 * left intact, which means that **btf__add_btf()** follows the transactional
 * semantics and the operation as a whole is all-or-nothing.
 *
 * *src_btf* has to be non-split BTF, as of now copying types from split BTF
 * is not supported and will result in -ENOTSUP error code returned.
 */
LIBBPF_API int btf__add_btf(struct btf *btf, const struct btf *src_btf);
197

198
LIBBPF_API int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding);
199
LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz);
200 201 202 203 204 205 206 207 208 209 210 211
LIBBPF_API int btf__add_ptr(struct btf *btf, int ref_type_id);
LIBBPF_API int btf__add_array(struct btf *btf,
			      int index_type_id, int elem_type_id, __u32 nr_elems);
/* struct/union construction APIs */
LIBBPF_API int btf__add_struct(struct btf *btf, const char *name, __u32 sz);
LIBBPF_API int btf__add_union(struct btf *btf, const char *name, __u32 sz);
LIBBPF_API int btf__add_field(struct btf *btf, const char *name, int field_type_id,
			      __u32 bit_offset, __u32 bit_size);

/* enum construction APIs */
LIBBPF_API int btf__add_enum(struct btf *btf, const char *name, __u32 bytes_sz);
LIBBPF_API int btf__add_enum_value(struct btf *btf, const char *name, __s64 value);
212 213
LIBBPF_API int btf__add_enum64(struct btf *btf, const char *name, __u32 bytes_sz, bool is_signed);
LIBBPF_API int btf__add_enum64_value(struct btf *btf, const char *name, __u64 value);
214 215 216 217 218 219 220 221 222 223 224 225

enum btf_fwd_kind {
	BTF_FWD_STRUCT = 0,
	BTF_FWD_UNION = 1,
	BTF_FWD_ENUM = 2,
};

LIBBPF_API int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind);
LIBBPF_API int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id);
LIBBPF_API int btf__add_volatile(struct btf *btf, int ref_type_id);
LIBBPF_API int btf__add_const(struct btf *btf, int ref_type_id);
LIBBPF_API int btf__add_restrict(struct btf *btf, int ref_type_id);
226
LIBBPF_API int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id);
227 228 229 230 231 232 233 234 235 236 237 238 239

/* func and func_proto construction APIs */
LIBBPF_API int btf__add_func(struct btf *btf, const char *name,
			     enum btf_func_linkage linkage, int proto_type_id);
LIBBPF_API int btf__add_func_proto(struct btf *btf, int ret_type_id);
LIBBPF_API int btf__add_func_param(struct btf *btf, const char *name, int type_id);

/* var & datasec construction APIs */
LIBBPF_API int btf__add_var(struct btf *btf, const char *name, int linkage, int type_id);
LIBBPF_API int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz);
LIBBPF_API int btf__add_datasec_var_info(struct btf *btf, int var_type_id,
					 __u32 offset, __u32 byte_sz);

240
/* tag construction API */
241
LIBBPF_API int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,
242 243
			    int component_idx);

244
struct btf_dedup_opts {
245 246 247 248 249 250
	size_t sz;
	/* optional .BTF.ext info to dedup along the main BTF info */
	struct btf_ext *btf_ext;
	/* force hash collisions (used for testing) */
	bool force_collisions;
	size_t :0;
251
};
252
#define btf_dedup_opts__last_field force_collisions
253

254 255
LIBBPF_API int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts);

Alan Maguire's avatar
Alan Maguire committed
256 257 258 259 260 261 262 263 264 265 266 267 268 269
/**
 * @brief **btf__relocate()** will check the split BTF *btf* for references
 * to base BTF kinds, and verify those references are compatible with
 * *base_btf*; if they are, *btf* is adjusted such that is re-parented to
 * *base_btf* and type ids and strings are adjusted to accommodate this.
 *
 * If successful, 0 is returned and **btf** now has **base_btf** as its
 * base.
 *
 * A negative value is returned on error and the thread-local `errno` variable
 * is set to the error code as well.
 */
LIBBPF_API int btf__relocate(struct btf *btf, const struct btf *base_btf);

270 271 272
struct btf_dump;

struct btf_dump_opts {
273
	size_t sz;
274
};
275
#define btf_dump_opts__last_field sz
276 277 278 279

typedef void (*btf_dump_printf_fn_t)(void *ctx, const char *fmt, va_list args);

LIBBPF_API struct btf_dump *btf_dump__new(const struct btf *btf,
280 281 282 283
					  btf_dump_printf_fn_t printf_fn,
					  void *ctx,
					  const struct btf_dump_opts *opts);

284 285 286 287
LIBBPF_API void btf_dump__free(struct btf_dump *d);

LIBBPF_API int btf_dump__dump_type(struct btf_dump *d, __u32 id);

288
struct btf_dump_emit_type_decl_opts {
289
	/* size of this struct, for forward/backward compatibility */
290 291 292 293 294 295 296 297 298 299 300 301 302
	size_t sz;
	/* optional field name for type declaration, e.g.:
	 * - struct my_struct <FNAME>
	 * - void (*<FNAME>)(int)
	 * - char (*<FNAME>)[123]
	 */
	const char *field_name;
	/* extra indentation level (in number of tabs) to emit for multi-line
	 * type declarations (e.g., anonymous struct); applies for lines
	 * starting from the second one (first line is assumed to have
	 * necessary indentation already
	 */
	int indent_level;
303 304
	/* strip all the const/volatile/restrict mods */
	bool strip_mods;
305
	size_t :0;
306
};
307
#define btf_dump_emit_type_decl_opts__last_field strip_mods
308 309 310 311 312

LIBBPF_API int
btf_dump__emit_type_decl(struct btf_dump *d, __u32 id,
			 const struct btf_dump_emit_type_decl_opts *opts);

313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331

struct btf_dump_type_data_opts {
	/* size of this struct, for forward/backward compatibility */
	size_t sz;
	const char *indent_str;
	int indent_level;
	/* below match "show" flags for bpf_show_snprintf() */
	bool compact;		/* no newlines/indentation */
	bool skip_names;	/* skip member/type names */
	bool emit_zeroes;	/* show 0-valued fields */
	size_t :0;
};
#define btf_dump_type_data_opts__last_field emit_zeroes

LIBBPF_API int
btf_dump__dump_type_data(struct btf_dump *d, __u32 id,
			 const void *data, size_t data_sz,
			 const struct btf_dump_type_data_opts *opts);

332
/*
333 334 335 336 337 338
 * A set of helpers for easier BTF types handling.
 *
 * The inline functions below rely on constants from the kernel headers which
 * may not be available for applications including this header file. To avoid
 * compilation errors, we define all the constants here that were added after
 * the initial introduction of the BTF_KIND* constants.
339
 */
340 341 342 343 344 345 346 347 348 349 350
#ifndef BTF_KIND_FUNC
#define BTF_KIND_FUNC		12	/* Function	*/
#define BTF_KIND_FUNC_PROTO	13	/* Function Proto	*/
#endif
#ifndef BTF_KIND_VAR
#define BTF_KIND_VAR		14	/* Variable	*/
#define BTF_KIND_DATASEC	15	/* Section	*/
#endif
#ifndef BTF_KIND_FLOAT
#define BTF_KIND_FLOAT		16	/* Floating point	*/
#endif
351
/* The kernel header switched to enums, so the following were never #defined */
352 353
#define BTF_KIND_DECL_TAG	17	/* Decl Tag */
#define BTF_KIND_TYPE_TAG	18	/* Type Tag */
354
#define BTF_KIND_ENUM64		19	/* Enum for up-to 64bit values */
355

356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
static inline __u16 btf_kind(const struct btf_type *t)
{
	return BTF_INFO_KIND(t->info);
}

static inline __u16 btf_vlen(const struct btf_type *t)
{
	return BTF_INFO_VLEN(t->info);
}

static inline bool btf_kflag(const struct btf_type *t)
{
	return BTF_INFO_KFLAG(t->info);
}

371 372 373 374 375
static inline bool btf_is_void(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_UNKN;
}

376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
static inline bool btf_is_int(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_INT;
}

static inline bool btf_is_ptr(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_PTR;
}

static inline bool btf_is_array(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_ARRAY;
}

static inline bool btf_is_struct(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_STRUCT;
}

static inline bool btf_is_union(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_UNION;
}

static inline bool btf_is_composite(const struct btf_type *t)
{
	__u16 kind = btf_kind(t);

	return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;
}

static inline bool btf_is_enum(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_ENUM;
}

413 414 415 416 417
static inline bool btf_is_enum64(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_ENUM64;
}

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
static inline bool btf_is_fwd(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_FWD;
}

static inline bool btf_is_typedef(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_TYPEDEF;
}

static inline bool btf_is_volatile(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_VOLATILE;
}

static inline bool btf_is_const(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_CONST;
}

static inline bool btf_is_restrict(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_RESTRICT;
}

static inline bool btf_is_mod(const struct btf_type *t)
{
	__u16 kind = btf_kind(t);

	return kind == BTF_KIND_VOLATILE ||
	       kind == BTF_KIND_CONST ||
449 450
	       kind == BTF_KIND_RESTRICT ||
	       kind == BTF_KIND_TYPE_TAG;
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
}

static inline bool btf_is_func(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_FUNC;
}

static inline bool btf_is_func_proto(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_FUNC_PROTO;
}

static inline bool btf_is_var(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_VAR;
}

static inline bool btf_is_datasec(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_DATASEC;
}

473 474 475 476 477
static inline bool btf_is_float(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_FLOAT;
}

478
static inline bool btf_is_decl_tag(const struct btf_type *t)
479
{
480
	return btf_kind(t) == BTF_KIND_DECL_TAG;
481 482
}

483 484 485 486 487
static inline bool btf_is_type_tag(const struct btf_type *t)
{
	return btf_kind(t) == BTF_KIND_TYPE_TAG;
}

488 489 490 491 492
static inline bool btf_is_any_enum(const struct btf_type *t)
{
	return btf_is_enum(t) || btf_is_enum64(t);
}

493 494 495 496 497 498 499
static inline bool btf_kind_core_compat(const struct btf_type *t1,
					const struct btf_type *t2)
{
	return btf_kind(t1) == btf_kind(t2) ||
	       (btf_is_any_enum(t1) && btf_is_any_enum(t2));
}

500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
static inline __u8 btf_int_encoding(const struct btf_type *t)
{
	return BTF_INT_ENCODING(*(__u32 *)(t + 1));
}

static inline __u8 btf_int_offset(const struct btf_type *t)
{
	return BTF_INT_OFFSET(*(__u32 *)(t + 1));
}

static inline __u8 btf_int_bits(const struct btf_type *t)
{
	return BTF_INT_BITS(*(__u32 *)(t + 1));
}

static inline struct btf_array *btf_array(const struct btf_type *t)
{
	return (struct btf_array *)(t + 1);
}

static inline struct btf_enum *btf_enum(const struct btf_type *t)
{
	return (struct btf_enum *)(t + 1);
}

525 526
struct btf_enum64;

527 528 529 530 531
static inline struct btf_enum64 *btf_enum64(const struct btf_type *t)
{
	return (struct btf_enum64 *)(t + 1);
}

532 533
static inline __u64 btf_enum64_value(const struct btf_enum64 *e)
{
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
	/* struct btf_enum64 is introduced in Linux 6.0, which is very
	 * bleeding-edge. Here we are avoiding relying on struct btf_enum64
	 * definition coming from kernel UAPI headers to support wider range
	 * of system-wide kernel headers.
	 *
	 * Given this header can be also included from C++ applications, that
	 * further restricts C tricks we can use (like using compatible
	 * anonymous struct). So just treat struct btf_enum64 as
	 * a three-element array of u32 and access second (lo32) and third
	 * (hi32) elements directly.
	 *
	 * For reference, here is a struct btf_enum64 definition:
	 *
	 * const struct btf_enum64 {
	 *	__u32	name_off;
	 *	__u32	val_lo32;
	 *	__u32	val_hi32;
	 * };
	 */
	const __u32 *e64 = (const __u32 *)e;

	return ((__u64)e64[2] << 32) | e64[1];
556 557
}

558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
static inline struct btf_member *btf_members(const struct btf_type *t)
{
	return (struct btf_member *)(t + 1);
}

/* Get bit offset of a member with specified index. */
static inline __u32 btf_member_bit_offset(const struct btf_type *t,
					  __u32 member_idx)
{
	const struct btf_member *m = btf_members(t) + member_idx;
	bool kflag = btf_kflag(t);

	return kflag ? BTF_MEMBER_BIT_OFFSET(m->offset) : m->offset;
}
/*
 * Get bitfield size of a member, assuming t is BTF_KIND_STRUCT or
 * BTF_KIND_UNION. If member is not a bitfield, zero is returned.
 */
static inline __u32 btf_member_bitfield_size(const struct btf_type *t,
					     __u32 member_idx)
{
	const struct btf_member *m = btf_members(t) + member_idx;
	bool kflag = btf_kflag(t);

	return kflag ? BTF_MEMBER_BITFIELD_SIZE(m->offset) : 0;
}

static inline struct btf_param *btf_params(const struct btf_type *t)
{
	return (struct btf_param *)(t + 1);
}

static inline struct btf_var *btf_var(const struct btf_type *t)
{
	return (struct btf_var *)(t + 1);
}

static inline struct btf_var_secinfo *
btf_var_secinfos(const struct btf_type *t)
{
	return (struct btf_var_secinfo *)(t + 1);
}

601 602
struct btf_decl_tag;
static 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 608 609 610
#ifdef __cplusplus
} /* extern "C" */
#endif

611
#endif /* __LIBBPF_BTF_H */