drivers/hid/bpf/hid_bpf_struct_ops.c

103

type_id = btf_find_by_name_kind(reg->btf, write_range->struct_name,

drivers/hid/bpf/hid_bpf_struct_ops.c

108

state = btf_type_by_id(reg->btf, type_id);

drivers/hid/bpf/hid_bpf_struct_ops.c

23

static struct btf *hid_bpf_ops_btf;

drivers/hid/bpf/hid_bpf_struct_ops.c

25

static int hid_bpf_ops_init(struct btf *btf)

drivers/hid/bpf/hid_bpf_struct_ops.c

27

hid_bpf_ops_btf = btf;

drivers/hid/bpf/hid_bpf_struct_ops.c

89

t = btf_type_by_id(reg->btf, reg->btf_id);

include/linux/bpf.h

1052

struct btf *btf;

include/linux/bpf.h

128

const struct btf *btf,

include/linux/bpf.h

1615

struct btf *btf;

include/linux/bpf.h

1622

struct btf *btf;

include/linux/bpf.h

1677

struct btf *attach_btf;

include/linux/bpf.h

1738

struct btf *btf;

include/linux/bpf.h

1991

int (*init)(struct btf *btf);

include/linux/bpf.h

2143

struct btf *btf,

include/linux/bpf.h

231

struct btf *btf;

include/linux/bpf.h

241

struct btf *btf;

include/linux/bpf.h

2621

static inline struct btf *__btf_get_by_fd(struct fd f)

include/linux/bpf.h

2923

struct btf *bpf_get_btf_vmlinux(void);

include/linux/bpf.h

3010

const struct btf *btf, u32 id, int off,

include/linux/bpf.h

3011

const struct btf *need_btf, u32 need_type_id,

include/linux/bpf.h

3015

struct btf *btf,

include/linux/bpf.h

3023

struct btf *btf, const struct btf_type *t);

include/linux/bpf.h

3024

const char *btf_find_decl_tag_value(const struct btf *btf, const struct btf_type *pt,

include/linux/bpf.h

3026

int btf_find_next_decl_tag(const struct btf *btf, const struct btf_type *pt,

include/linux/bpf.h

3045

const struct btf *btf;

include/linux/bpf.h

3053

const struct btf *reg_btf, u32 reg_id,

include/linux/bpf.h

3054

const struct btf *arg_btf, u32 arg_id);

include/linux/bpf.h

315

struct btf *btf;

include/linux/bpf.h

3951

void bpf_get_linfo_file_line(struct btf *btf, const struct bpf_line_info *linfo,

include/linux/bpf.h

45

struct btf;

include/linux/bpf.h

660

const struct btf *btf,

include/linux/bpf_local_storage.h

176

const struct btf *btf,

include/linux/bpf_verifier.h

1048

struct btf *btf, u32 btf_id)

include/linux/bpf_verifier.h

1053

return ((u64)btf_obj_id(btf) << 32) | 0x80000000 | btf_id;

include/linux/bpf_verifier.h

1295

const char *iter_type_str(const struct btf *btf, u32 btf_id);

include/linux/bpf_verifier.h

1324

struct btf *btf;

include/linux/bpf_verifier.h

1351

struct btf *arg_btf;

include/linux/bpf_verifier.h

591

struct btf *btf;

include/linux/bpf_verifier.h

62

struct btf *btf;

include/linux/bpf_verifier.h

88

struct btf *btf;

include/linux/btf.h

111

struct btf;

include/linux/btf.h

144

const char *btf_get_name(const struct btf *btf);

include/linux/btf.h

145

void btf_get(struct btf *btf);

include/linux/btf.h

146

void btf_put(struct btf *btf);

include/linux/btf.h

147

const struct btf_header *btf_header(const struct btf *btf);

include/linux/btf.h

149

struct btf *btf_get_by_fd(int fd);

include/linux/btf.h

150

int btf_get_info_by_fd(const struct btf *btf,

include/linux/btf.h

174

const struct btf_type *btf_type_id_size(const struct btf *btf,

include/linux/btf.h

195

void btf_type_seq_show(const struct btf *btf, u32 type_id, void *obj,

include/linux/btf.h

197

int btf_type_seq_show_flags(const struct btf *btf, u32 type_id, void *obj,

include/linux/btf.h

213

int btf_type_snprintf_show(const struct btf *btf, u32 type_id, void *obj,

include/linux/btf.h

217

u32 btf_obj_id(const struct btf *btf);

include/linux/btf.h

218

bool btf_is_kernel(const struct btf *btf);

include/linux/btf.h

219

bool btf_is_module(const struct btf *btf);

include/linux/btf.h

220

bool btf_is_vmlinux(const struct btf *btf);

include/linux/btf.h

221

struct module *btf_try_get_module(const struct btf *btf);

include/linux/btf.h

222

u32 btf_nr_types(const struct btf *btf);

include/linux/btf.h

223

u32 btf_named_start_id(const struct btf *btf, bool own);

include/linux/btf.h

224

struct btf *btf_base_btf(const struct btf *btf);

include/linux/btf.h

228

bool btf_member_is_reg_int(const struct btf *btf, const struct btf_type *s,

include/linux/btf.h

231

struct btf_record *btf_parse_fields(const struct btf *btf, const struct btf_type *t,

include/linux/btf.h

233

int btf_check_and_fixup_fields(const struct btf *btf, struct btf_record *rec);

include/linux/btf.h

235

s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind);

include/linux/btf.h

236

s32 bpf_find_btf_id(const char *name, u32 kind, struct btf **btf_p);

include/linux/btf.h

237

const struct btf_type *btf_type_skip_modifiers(const struct btf *btf,

include/linux/btf.h

239

const struct btf_type *btf_type_resolve_ptr(const struct btf *btf,

include/linux/btf.h

241

const struct btf_type *btf_type_resolve_func_ptr(const struct btf *btf,

include/linux/btf.h

244

btf_resolve_size(const struct btf *btf, const struct btf_type *type,

include/linux/btf.h

524

bool btf_param_match_suffix(const struct btf *btf,

include/linux/btf.h

527

int btf_ctx_arg_offset(const struct btf *btf, const struct btf_type *func_proto,

include/linux/btf.h

529

u32 btf_ctx_arg_idx(struct btf *btf, const struct btf_type *func_proto, int off);

include/linux/btf.h

536

const struct bpf_struct_ops_desc *bpf_struct_ops_find_value(struct btf *btf, u32 value_id);

include/linux/btf.h

537

const struct bpf_struct_ops_desc *bpf_struct_ops_find(struct btf *btf, u32 type_id);

include/linux/btf.h

539

static inline const struct bpf_struct_ops_desc *bpf_struct_ops_find(struct btf *btf, u32 type_id)

include/linux/btf.h

568

const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id);

include/linux/btf.h

569

void btf_set_base_btf(struct btf *btf, const struct btf *base_btf);

include/linux/btf.h

570

int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **map_ids);

include/linux/btf.h

575

const char *btf_name_by_offset(const struct btf *btf, u32 offset);

include/linux/btf.h

576

const char *btf_str_by_offset(const struct btf *btf, u32 offset);

include/linux/btf.h

577

struct btf *btf_parse_vmlinux(void);

include/linux/btf.h

578

struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog);

include/linux/btf.h

579

u32 *btf_kfunc_flags(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog);

include/linux/btf.h

580

bool btf_kfunc_is_allowed(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog);

include/linux/btf.h

581

u32 *btf_kfunc_is_modify_return(const struct btf *btf, u32 kfunc_btf_id,

include/linux/btf.h

586

s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id);

include/linux/btf.h

589

struct btf_struct_meta *btf_find_struct_meta(const struct btf *btf, u32 btf_id);

include/linux/btf.h

591

bool btf_is_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,

include/linux/btf.h

595

bool btf_types_are_same(const struct btf *btf1, u32 id1,

include/linux/btf.h

596

const struct btf *btf2, u32 id2);

include/linux/btf.h

597

int btf_check_iter_arg(struct btf *btf, const struct btf_type *func, int arg_idx);

include/linux/btf.h

599

static inline bool btf_type_is_struct_ptr(struct btf *btf, const struct btf_type *t)

include/linux/btf.h

604

t = btf_type_skip_modifiers(btf, t->type, NULL);

include/linux/btf.h

609

static inline const struct btf_type *btf_type_by_id(const struct btf *btf,

include/linux/btf.h

615

static inline void btf_set_base_btf(struct btf *btf, const struct btf *base_btf)

include/linux/btf.h

619

static inline int btf_relocate(void *log, struct btf *btf, const struct btf *base_btf,

include/linux/btf.h

636

static inline const char *btf_name_by_offset(const struct btf *btf,

include/linux/btf.h

641

static inline u32 *btf_kfunc_id_set_contains(const struct btf *btf,

include/linux/btf.h

653

static inline s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id)

include/linux/btf.h

662

static inline struct btf_struct_meta *btf_find_struct_meta(const struct btf *btf, u32 btf_id)

include/linux/btf.h

667

btf_is_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,

include/linux/btf.h

677

static inline bool btf_types_are_same(const struct btf *btf1, u32 id1,

include/linux/btf.h

678

const struct btf *btf2, u32 id2)

include/linux/btf.h

682

static inline int btf_check_iter_arg(struct btf *btf, const struct btf_type *func, int arg_idx)

include/uapi/linux/bpf.h

1755

__aligned_u64 btf;

include/uapi/linux/bpf.h

6725

__aligned_u64 btf;

io_uring/bpf-ops.c

107

io_lookup_struct_type(struct btf *btf, const char *name)

io_uring/bpf-ops.c

111

type_id = btf_find_by_name_kind(btf, name, BTF_KIND_STRUCT);

io_uring/bpf-ops.c

114

return btf_type_by_id(btf, type_id);

io_uring/bpf-ops.c

117

static int bpf_io_init(struct btf *btf)

io_uring/bpf-ops.c

121

loop_params_type = io_lookup_struct_type(btf, "iou_loop_params");

io_uring/bpf-ops.c

90

const struct btf_type *t = btf_type_by_id(reg->btf, reg->btf_id);

kernel/bpf/arena.c

306

static int arena_map_check_btf(struct bpf_map *map, const struct btf *btf,

kernel/bpf/arraymap.c

1038

btf_type_seq_show(map->btf, map->btf_value_type_id,

kernel/bpf/arraymap.c

522

btf_type_seq_show(map->btf, map->btf_value_type_id, value, m);

kernel/bpf/arraymap.c

542

btf_type_seq_show(map->btf, map->btf_value_type_id,

kernel/bpf/arraymap.c

552

const struct btf *btf,

kernel/bpf/bloom_filter.c

184

const struct btf *btf,

kernel/bpf/bpf_insn_array.c

102

const struct btf *btf,

kernel/bpf/bpf_local_storage.c

719

const struct btf *btf,

kernel/bpf/bpf_struct_ops.c

1030

static u32 count_func_ptrs(const struct btf *btf, const struct btf_type *t)

kernel/bpf/bpf_struct_ops.c

1038

if (btf_type_resolve_func_ptr(btf, member->type, NULL))

kernel/bpf/bpf_struct_ops.c

104

mt = btf_type_by_id(btf, member->type);

kernel/bpf/bpf_struct_ops.c

1051

struct btf *btf;

kernel/bpf/bpf_struct_ops.c

1056

btf = btf_get_by_fd(attr->value_type_btf_obj_fd);

kernel/bpf/bpf_struct_ops.c

1057

if (IS_ERR(btf))

kernel/bpf/bpf_struct_ops.c

1058

return ERR_CAST(btf);

kernel/bpf/bpf_struct_ops.c

1059

if (!btf_is_module(btf)) {

kernel/bpf/bpf_struct_ops.c

1060

btf_put(btf);

kernel/bpf/bpf_struct_ops.c

1064

mod = btf_try_get_module(btf);

kernel/bpf/bpf_struct_ops.c

1068

btf_put(btf);

kernel/bpf/bpf_struct_ops.c

1072

btf = bpf_get_btf_vmlinux();

kernel/bpf/bpf_struct_ops.c

1073

if (IS_ERR(btf))

kernel/bpf/bpf_struct_ops.c

1074

return ERR_CAST(btf);

kernel/bpf/bpf_struct_ops.c

1075

if (!btf)

kernel/bpf/bpf_struct_ops.c

1079

st_ops_desc = bpf_struct_ops_find_value(btf, attr->btf_vmlinux_value_type_id);

kernel/bpf/bpf_struct_ops.c

1109

st_map->funcs_cnt = count_func_ptrs(btf, t);

kernel/bpf/bpf_struct_ops.c

1121

st_map->btf = btf;

kernel/bpf/bpf_struct_ops.c

113

mt = btf_type_by_id(btf, member->type);

kernel/bpf/bpf_struct_ops.c

116

value_name, btf_name_by_offset(btf, type->name_off));

kernel/bpf/bpf_struct_ops.c

1491

info->btf_vmlinux_id = btf_obj_id(st_map->btf);

kernel/bpf/bpf_struct_ops.c

171

static int prepare_arg_info(struct btf *btf,

kernel/bpf/bpf_struct_ops.c

196

stub_func_id = btf_find_by_name_kind(btf, stub_fname, BTF_KIND_FUNC);

kernel/bpf/bpf_struct_ops.c

202

stub_func_proto = btf_type_by_id(btf, stub_func_id);

kernel/bpf/bpf_struct_ops.c

203

stub_func_proto = btf_type_by_id(btf, stub_func_proto->type);

kernel/bpf/bpf_struct_ops.c

231

is_nullable = btf_param_match_suffix(btf, &stub_args[arg_no],

kernel/bpf/bpf_struct_ops.c

233

is_refcounted = btf_param_match_suffix(btf, &stub_args[arg_no],

kernel/bpf/bpf_struct_ops.c

244

pointed_type = btf_type_resolve_ptr(btf,

kernel/bpf/bpf_struct_ops.c

254

offset = btf_ctx_arg_offset(btf, func_proto, arg_no);

kernel/bpf/bpf_struct_ops.c

269

info->btf = btf;

kernel/bpf/bpf_struct_ops.c

310

static bool is_module_member(const struct btf *btf, u32 id)

kernel/bpf/bpf_struct_ops.c

314

t = btf_type_resolve_ptr(btf, id, NULL);

kernel/bpf/bpf_struct_ops.c

321

return !strcmp(btf_name_by_offset(btf, t->name_off), "module");

kernel/bpf/bpf_struct_ops.c

332

struct btf *btf,

kernel/bpf/bpf_struct_ops.c

357

type_id = btf_find_by_name_kind(btf, st_ops->name,

kernel/bpf/bpf_struct_ops.c

361

st_ops->name, btf_get_name(btf));

kernel/bpf/bpf_struct_ops.c

364

t = btf_type_by_id(btf, type_id);

kernel/bpf/bpf_struct_ops.c

371

value_id = btf_find_by_name_kind(btf, value_name,

kernel/bpf/bpf_struct_ops.c

375

value_name, btf_get_name(btf));

kernel/bpf/bpf_struct_ops.c

378

if (!is_valid_value_type(btf, value_id, t, value_name))

kernel/bpf/bpf_struct_ops.c

389

st_ops_desc->value_type = btf_type_by_id(btf, value_id);

kernel/bpf/bpf_struct_ops.c

397

mname = btf_name_by_offset(btf, member->name_off);

kernel/bpf/bpf_struct_ops.c

412

if (!st_ops_ids[IDX_MODULE_ID] && is_module_member(btf, member->type)) {

kernel/bpf/bpf_struct_ops.c

419

func_proto = btf_type_resolve_func_ptr(btf,

kernel/bpf/bpf_struct_ops.c

43

struct btf *btf;

kernel/bpf/bpf_struct_ops.c

430

ret_type = btf_type_resolve_ptr(btf, func_proto->type, NULL);

kernel/bpf/bpf_struct_ops.c

439

if (btf_distill_func_proto(log, btf,

kernel/bpf/bpf_struct_ops.c

449

err = prepare_arg_info(btf, st_ops->name, mname,

kernel/bpf/bpf_struct_ops.c

456

if (st_ops->init(btf)) {

kernel/bpf/bpf_struct_ops.c

555

static int check_zero_holes(const struct btf *btf, const struct btf_type *t, void *data)

kernel/bpf/bpf_struct_ops.c

567

mtype = btf_type_by_id(btf, member->type);

kernel/bpf/bpf_struct_ops.c

568

mtype = btf_resolve_size(btf, mtype, &msize);

kernel/bpf/bpf_struct_ops.c

711

err = check_zero_holes(st_map->btf, st_ops_desc->value_type, value);

kernel/bpf/bpf_struct_ops.c

716

err = check_zero_holes(st_map->btf, t, uvalue->data);

kernel/bpf/bpf_struct_ops.c

744

tname = btf_name_by_offset(st_map->btf, t->name_off);

kernel/bpf/bpf_struct_ops.c

754

mname = btf_name_by_offset(st_map->btf, member->name_off);

kernel/bpf/bpf_struct_ops.c

755

ptype = btf_type_resolve_ptr(st_map->btf, member->type, NULL);

kernel/bpf/bpf_struct_ops.c

780

mtype = btf_type_by_id(st_map->btf, member->type);

kernel/bpf/bpf_struct_ops.c

781

mtype = btf_resolve_size(st_map->btf, mtype, &msize);

kernel/bpf/bpf_struct_ops.c

87

extern struct btf *btf_vmlinux;

kernel/bpf/bpf_struct_ops.c

89

static bool is_valid_value_type(struct btf *btf, s32 value_id,

kernel/bpf/bpf_struct_ops.c

962

btf_type_seq_show(st_map->btf,

kernel/bpf/bpf_struct_ops.c

97

vt = btf_type_by_id(btf, value_id);

kernel/bpf/bpf_struct_ops.c

994

if (btf_is_module(st_map->btf))

kernel/bpf/btf.c

1016

bool btf_member_is_reg_int(const struct btf *btf, const struct btf_type *s,

kernel/bpf/btf.c

1025

t = btf_type_id_size(btf, &id, NULL);

kernel/bpf/btf.c

1054

static const struct btf_type *btf_type_skip_qualifiers(const struct btf *btf,

kernel/bpf/btf.c

1057

const struct btf_type *t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

1061

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

1107

member = btf_name_by_offset(show->btf, m->name_off);

kernel/bpf/btf.c

1119

t = btf_type_by_id(show->btf, id);

kernel/bpf/btf.c

1150

name = btf_name_by_offset(show->btf,

kernel/bpf/btf.c

1177

t = btf_type_skip_qualifiers(show->btf, id);

kernel/bpf/btf.c

1184

name = btf_name_by_offset(show->btf, t->name_off);

kernel/bpf/btf.c

1374

rt = btf_resolve_size(show->btf, t, &size);

kernel/bpf/btf.c

1566

struct btf *btf = env->btf;

kernel/bpf/btf.c

1581

if (env->btf->base_btf && IS_ENABLED(CONFIG_MODULE_ALLOW_BTF_MISMATCH))

kernel/bpf/btf.c

1588

__btf_name_by_offset(btf, t->name_off),

kernel/bpf/btf.c

1616

struct btf *btf = env->btf;

kernel/bpf/btf.c

1627

if (env->btf->base_btf && IS_ENABLED(CONFIG_MODULE_ALLOW_BTF_MISMATCH))

kernel/bpf/btf.c

1643

__btf_name_by_offset(btf, member->name_off),

kernel/bpf/btf.c

1649

__btf_name_by_offset(btf, member->name_off),

kernel/bpf/btf.c

1694

const struct btf *btf = env->btf;

kernel/bpf/btf.c

1702

hdr = &btf->hdr;

kernel/bpf/btf.c

1721

struct btf *btf = env->btf;

kernel/bpf/btf.c

1723

if (btf->types_size == btf->nr_types) {

kernel/bpf/btf.c

1729

if (btf->start_id + btf->types_size == BTF_MAX_TYPE) {

kernel/bpf/btf.c

1734

expand_by = max_t(u32, btf->types_size >> 2, 16);

kernel/bpf/btf.c

1736

btf->types_size + expand_by);

kernel/bpf/btf.c

1743

if (btf->nr_types == 0) {

kernel/bpf/btf.c

1744

if (!btf->base_btf) {

kernel/bpf/btf.c

1747

btf->nr_types++;

kernel/bpf/btf.c

1750

memcpy(new_types, btf->types,

kernel/bpf/btf.c

1751

sizeof(*btf->types) * btf->nr_types);

kernel/bpf/btf.c

1754

kvfree(btf->types);

kernel/bpf/btf.c

1755

btf->types = new_types;

kernel/bpf/btf.c

1756

btf->types_size = new_size;

kernel/bpf/btf.c

1759

btf->types[btf->nr_types++] = t;

kernel/bpf/btf.c

1764

static int btf_alloc_id(struct btf *btf)

kernel/bpf/btf.c

1770

id = idr_alloc_cyclic(&btf_idr, btf, 1, INT_MAX, GFP_ATOMIC);

kernel/bpf/btf.c

1772

btf->id = id;

kernel/bpf/btf.c

1782

static void btf_free_id(struct btf *btf)

kernel/bpf/btf.c

1796

if (btf->id) {

kernel/bpf/btf.c

1797

idr_remove(&btf_idr, btf->id);

kernel/bpf/btf.c

1804

WRITE_ONCE(btf->id, 0);

kernel/bpf/btf.c

1809

static void btf_free_kfunc_set_tab(struct btf *btf)

kernel/bpf/btf.c

1811

struct btf_kfunc_set_tab *tab = btf->kfunc_set_tab;

kernel/bpf/btf.c

1819

btf->kfunc_set_tab = NULL;

kernel/bpf/btf.c

1822

static void btf_free_dtor_kfunc_tab(struct btf *btf)

kernel/bpf/btf.c

1824

struct btf_id_dtor_kfunc_tab *tab = btf->dtor_kfunc_tab;

kernel/bpf/btf.c

1829

btf->dtor_kfunc_tab = NULL;

kernel/bpf/btf.c

1843

static void btf_free_struct_meta_tab(struct btf *btf)

kernel/bpf/btf.c

1845

struct btf_struct_metas *tab = btf->struct_meta_tab;

kernel/bpf/btf.c

1848

btf->struct_meta_tab = NULL;

kernel/bpf/btf.c

1851

static void btf_free_struct_ops_tab(struct btf *btf)

kernel/bpf/btf.c

1853

struct btf_struct_ops_tab *tab = btf->struct_ops_tab;

kernel/bpf/btf.c

1863

btf->struct_ops_tab = NULL;

kernel/bpf/btf.c

1866

static void btf_free(struct btf *btf)

kernel/bpf/btf.c

1868

btf_free_struct_meta_tab(btf);

kernel/bpf/btf.c

1869

btf_free_dtor_kfunc_tab(btf);

kernel/bpf/btf.c

1870

btf_free_kfunc_set_tab(btf);

kernel/bpf/btf.c

1871

btf_free_struct_ops_tab(btf);

kernel/bpf/btf.c

1872

kvfree(btf->types);

kernel/bpf/btf.c

1873

kvfree(btf->resolved_sizes);

kernel/bpf/btf.c

1874

kvfree(btf->resolved_ids);

kernel/bpf/btf.c

1878

if (!btf_is_vmlinux(btf))

kernel/bpf/btf.c

1879

kvfree(btf->data);

kernel/bpf/btf.c

1880

kvfree(btf->base_id_map);

kernel/bpf/btf.c

1881

kfree(btf);

kernel/bpf/btf.c

1886

struct btf *btf = container_of(rcu, struct btf, rcu);

kernel/bpf/btf.c

1888

btf_free(btf);

kernel/bpf/btf.c

1891

const char *btf_get_name(const struct btf *btf)

kernel/bpf/btf.c

1893

return btf->name;

kernel/bpf/btf.c

1896

void btf_get(struct btf *btf)

kernel/bpf/btf.c

1898

refcount_inc(&btf->refcnt);

kernel/bpf/btf.c

1901

void btf_put(struct btf *btf)

kernel/bpf/btf.c

1903

if (btf && refcount_dec_and_test(&btf->refcnt)) {

kernel/bpf/btf.c

1904

btf_free_id(btf);

kernel/bpf/btf.c

1905

call_rcu(&btf->rcu, btf_free_rcu);

kernel/bpf/btf.c

1909

struct btf *btf_base_btf(const struct btf *btf)

kernel/bpf/btf.c

1911

return btf->base_btf;

kernel/bpf/btf.c

1914

const struct btf_header *btf_header(const struct btf *btf)

kernel/bpf/btf.c

1916

return &btf->hdr;

kernel/bpf/btf.c

1919

void btf_set_base_btf(struct btf *btf, const struct btf *base_btf)

kernel/bpf/btf.c

1921

btf->base_btf = (struct btf *)base_btf;

kernel/bpf/btf.c

1922

btf->start_id = btf_nr_types(base_btf);

kernel/bpf/btf.c

1923

btf->start_str_off = base_btf->hdr.str_len;

kernel/bpf/btf.c

1928

struct btf *btf = env->btf;

kernel/bpf/btf.c

1929

u32 nr_types = btf->nr_types;

kernel/bpf/btf.c

1949

btf->resolved_sizes = resolved_sizes;

kernel/bpf/btf.c

1950

btf->resolved_ids = resolved_ids;

kernel/bpf/btf.c

1997

if (type_id < env->btf->start_id)

kernel/bpf/btf.c

2000

return env->visit_states[type_id - env->btf->start_id] == RESOLVED;

kernel/bpf/btf.c

2006

const struct btf *btf = env->btf;

kernel/bpf/btf.c

2012

if (type_id < btf->start_id

kernel/bpf/btf.c

2013

|| env->visit_states[type_id - btf->start_id] != NOT_VISITED)

kernel/bpf/btf.c

2016

env->visit_states[type_id - btf->start_id] = VISITED;

kernel/bpf/btf.c

2044

struct btf *btf = env->btf;

kernel/bpf/btf.c

2046

type_id -= btf->start_id; /* adjust to local type id */

kernel/bpf/btf.c

2047

btf->resolved_sizes[type_id] = resolved_size;

kernel/bpf/btf.c

2048

btf->resolved_ids[type_id] = resolved_type_id;

kernel/bpf/btf.c

2078

__btf_resolve_size(const struct btf *btf, const struct btf_type *type,

kernel/bpf/btf.c

2109

type = btf_type_by_id(btf, type->type);

kernel/bpf/btf.c

2119

type = btf_type_by_id(btf, array->type);

kernel/bpf/btf.c

2148

btf_resolve_size(const struct btf *btf, const struct btf_type *type,

kernel/bpf/btf.c

2151

return __btf_resolve_size(btf, type, type_size, NULL, NULL, NULL, NULL);

kernel/bpf/btf.c

2154

static u32 btf_resolved_type_id(const struct btf *btf, u32 type_id)

kernel/bpf/btf.c

2156

while (type_id < btf->start_id)

kernel/bpf/btf.c

2157

btf = btf->base_btf;

kernel/bpf/btf.c

2159

return btf->resolved_ids[type_id - btf->start_id];

kernel/bpf/btf.c

2163

static const struct btf_type *btf_type_id_resolve(const struct btf *btf,

kernel/bpf/btf.c

2166

*type_id = btf_resolved_type_id(btf, *type_id);

kernel/bpf/btf.c

2167

return btf_type_by_id(btf, *type_id);

kernel/bpf/btf.c

2170

static u32 btf_resolved_type_size(const struct btf *btf, u32 type_id)

kernel/bpf/btf.c

2172

while (type_id < btf->start_id)

kernel/bpf/btf.c

2173

btf = btf->base_btf;

kernel/bpf/btf.c

2175

return btf->resolved_sizes[type_id - btf->start_id];

kernel/bpf/btf.c

2178

const struct btf_type *btf_type_id_size(const struct btf *btf,

kernel/bpf/btf.c

2185

size_type = btf_type_by_id(btf, size_type_id);

kernel/bpf/btf.c

2192

size = btf_resolved_type_size(btf, size_type_id);

kernel/bpf/btf.c

2200

size_type_id = btf_resolved_type_id(btf, size_type_id);

kernel/bpf/btf.c

2201

size_type = btf_type_by_id(btf, size_type_id);

kernel/bpf/btf.c

2207

size = btf_resolved_type_size(btf, size_type_id);

kernel/bpf/btf.c

2270

static void btf_df_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

2538

static void btf_int_bits_show(const struct btf *btf,

kernel/bpf/btf.c

2557

static void btf_int_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

2573

btf_int_bits_show(btf, t, safe_data, bits_offset, show);

kernel/bpf/btf.c

2620

btf_int_bits_show(btf, t, safe_data, bits_offset, show);

kernel/bpf/btf.c

2644

struct btf *btf = env->btf;

kernel/bpf/btf.c

2646

resolved_type = btf_type_id_size(btf, &resolved_type_id, NULL);

kernel/bpf/btf.c

2669

struct btf *btf = env->btf;

kernel/bpf/btf.c

2671

resolved_type = btf_type_id_size(btf, &resolved_type_id, NULL);

kernel/bpf/btf.c

2738

!btf_name_valid_identifier(env->btf, t->name_off)) {

kernel/bpf/btf.c

2743

value = btf_name_by_offset(env->btf, t->name_off);

kernel/bpf/btf.c

276

struct btf *base_btf;

kernel/bpf/btf.c

2766

struct btf *btf = env->btf;

kernel/bpf/btf.c

2768

next_type = btf_type_by_id(btf, next_type_id);

kernel/bpf/btf.c

2784

if (!btf_type_id_size(btf, &next_type_id, NULL)) {

kernel/bpf/btf.c

2786

next_type = btf_type_id_resolve(btf, &next_type_id);

kernel/bpf/btf.c

2808

struct btf *btf = env->btf;

kernel/bpf/btf.c

2810

next_type = btf_type_by_id(btf, next_type_id);

kernel/bpf/btf.c

2825

resolved_type = btf_type_id_resolve(btf, &resolved_type_id);

kernel/bpf/btf.c

2838

if (!btf_type_id_size(btf, &next_type_id, NULL)) {

kernel/bpf/btf.c

2854

struct btf *btf = env->btf;

kernel/bpf/btf.c

2856

next_type = btf_type_by_id(btf, next_type_id);

kernel/bpf/btf.c

2879

resolved_type = btf_type_id_resolve(btf, &resolved_type_id);

kernel/bpf/btf.c

2888

if (!btf_type_id_size(btf, &next_type_id, NULL)) {

kernel/bpf/btf.c

2890

next_type = btf_type_id_resolve(btf, &next_type_id);

kernel/bpf/btf.c

2905

static void btf_modifier_show(const struct btf *btf,

kernel/bpf/btf.c

2910

if (btf->resolved_ids)

kernel/bpf/btf.c

2911

t = btf_type_id_resolve(btf, &type_id);

kernel/bpf/btf.c

2913

t = btf_type_skip_modifiers(btf, type_id, NULL);

kernel/bpf/btf.c

2915

btf_type_ops(t)->show(btf, t, type_id, data, bits_offset, show);

kernel/bpf/btf.c

2918

static void btf_var_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

2922

t = btf_type_id_resolve(btf, &type_id);

kernel/bpf/btf.c

2924

btf_type_ops(t)->show(btf, t, type_id, data, bits_offset, show);

kernel/bpf/btf.c

2927

static void btf_ptr_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

2985

!btf_name_valid_identifier(env->btf, t->name_off)) {

kernel/bpf/btf.c

3018

struct btf *btf = env->btf;

kernel/bpf/btf.c

3027

btf_type_id_size(btf, &array_type_id, &array_size);

kernel/bpf/btf.c

3098

struct btf *btf = env->btf;

kernel/bpf/btf.c

3103

index_type = btf_type_by_id(btf, index_type_id);

kernel/bpf/btf.c

3114

index_type = btf_type_id_size(btf, &index_type_id, NULL);

kernel/bpf/btf.c

3123

elem_type = btf_type_by_id(btf, elem_type_id);

kernel/bpf/btf.c

3135

elem_type = btf_type_id_size(btf, &elem_type_id, &elem_size);

kernel/bpf/btf.c

3166

static void __btf_array_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

317

struct btf *btf;

kernel/bpf/btf.c

3177

elem_type = btf_type_skip_modifiers(btf, elem_type_id, NULL);

kernel/bpf/btf.c

3206

elem_ops->show(btf, elem_type, elem_type_id, data,

kernel/bpf/btf.c

3219

static void btf_array_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

3235

__btf_array_show(btf, t, type_id, data, bits_offset, show);

kernel/bpf/btf.c

3249

__btf_array_show(btf, t, type_id, data, bits_offset, show);

kernel/bpf/btf.c

3293

struct btf *btf = env->btf;

kernel/bpf/btf.c

3308

!btf_name_valid_identifier(env->btf, t->name_off)) {

kernel/bpf/btf.c

3317

if (!btf_name_offset_valid(btf, member->name_off)) {

kernel/bpf/btf.c

3326

!btf_name_valid_identifier(btf, member->name_off)) {

kernel/bpf/btf.c

3389

last_member_type = btf_type_by_id(env->btf,

kernel/bpf/btf.c

3405

const struct btf_type *member_type = btf_type_by_id(env->btf,

kernel/bpf/btf.c

3463

static int btf_find_struct(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

3476

static int btf_find_kptr(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

3486

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

3490

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

3495

if (btf_type_is_type_tag(btf_type_by_id(btf, t->type)))

kernel/bpf/btf.c

3497

tag_value = __btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

3513

t = btf_type_skip_modifiers(btf, t->type, &res_id);

kernel/bpf/btf.c

3524

int btf_find_next_decl_tag(const struct btf *btf, const struct btf_type *pt,

kernel/bpf/btf.c

3530

for (i = last_id + 1, n = btf_nr_types(btf); i < n; i++) {

kernel/bpf/btf.c

3531

const struct btf_type *t = btf_type_by_id(btf, i);

kernel/bpf/btf.c

3535

if (pt != btf_type_by_id(btf, t->type))

kernel/bpf/btf.c

3539

if (strncmp(__btf_name_by_offset(btf, t->name_off), tag_key, len))

kernel/bpf/btf.c

3546

const char *btf_find_decl_tag_value(const struct btf *btf, const struct btf_type *pt,

kernel/bpf/btf.c

3553

id = btf_find_next_decl_tag(btf, pt, comp_idx, tag_key,

kernel/bpf/btf.c

3554

btf_named_start_id(btf, false) - 1);

kernel/bpf/btf.c

3558

t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

3560

value = __btf_name_by_offset(btf, t->name_off) + len;

kernel/bpf/btf.c

3563

id = btf_find_next_decl_tag(btf, pt, comp_idx, tag_key, id);

kernel/bpf/btf.c

3571

btf_find_graph_root(const struct btf *btf, const struct btf_type *pt,

kernel/bpf/btf.c

3584

value_type = btf_find_decl_tag_value(btf, pt, comp_idx, "contains:");

kernel/bpf/btf.c

3594

id = btf_find_by_name_kind(btf, value_type, BTF_KIND_STRUCT);

kernel/bpf/btf.c

3608

static int btf_get_field_type(const struct btf *btf, const struct btf_type *var_type,

kernel/bpf/btf.c

3628

const char *name = __btf_name_by_offset(btf, var_type->name_off);

kernel/bpf/btf.c

3705

static int btf_find_struct_field(const struct btf *btf,

kernel/bpf/btf.c

3716

static int btf_find_nested_struct(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

3727

ret = btf_find_struct_field(btf, t, field_mask, info, info_cnt, level);

kernel/bpf/btf.c

3749

static int btf_find_field_one(const struct btf *btf,

kernel/bpf/btf.c

3769

var_type = btf_type_by_id(btf, array->type);

kernel/bpf/btf.c

3776

field_type = btf_get_field_type(btf, var_type,

kernel/bpf/btf.c

3783

ret = btf_find_nested_struct(btf, var_type, off, nelems, field_mask,

kernel/bpf/btf.c

3807

ret = btf_find_struct(btf, var_type, off, sz, field_type,

kernel/bpf/btf.c

3816

ret = btf_find_kptr(btf, var_type, off, sz,

kernel/bpf/btf.c

3823

ret = btf_find_graph_root(btf, var, var_type,

kernel/bpf/btf.c

3846

static int btf_find_struct_field(const struct btf *btf,

kernel/bpf/btf.c

3856

const struct btf_type *member_type = btf_type_by_id(btf,

kernel/bpf/btf.c

3865

ret = btf_find_field_one(btf, t, member_type, i,

kernel/bpf/btf.c

3876

static int btf_find_datasec_var(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

3885

const struct btf_type *var = btf_type_by_id(btf, vsi->type);

kernel/bpf/btf.c

3886

const struct btf_type *var_type = btf_type_by_id(btf, var->type);

kernel/bpf/btf.c

3889

ret = btf_find_field_one(btf, var, var_type, -1, off, vsi->size,

kernel/bpf/btf.c

3900

static int btf_find_field(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

3905

return btf_find_struct_field(btf, t, field_mask, info, info_cnt, 0);

kernel/bpf/btf.c

3907

return btf_find_datasec_var(btf, t, field_mask, info, info_cnt, 0);

kernel/bpf/btf.c

3912

static int btf_parse_kptr(const struct btf *btf, struct btf_field *field,

kernel/bpf/btf.c

3920

struct btf *kptr_btf;

kernel/bpf/btf.c

3927

t = btf_type_by_id(btf, info->kptr.type_id);

kernel/bpf/btf.c

3928

id = bpf_find_btf_id(__btf_name_by_offset(btf, t->name_off), BTF_INFO_KIND(t->info),

kernel/bpf/btf.c

3932

WARN_ON_ONCE(btf_is_kernel(btf));

kernel/bpf/btf.c

3939

kptr_btf = (struct btf *)btf;

kernel/bpf/btf.c

3992

field->kptr.btf = kptr_btf;

kernel/bpf/btf.c

4002

static int btf_parse_graph_root(const struct btf *btf,

kernel/bpf/btf.c

4013

t = btf_type_by_id(btf, info->graph_root.value_btf_id);

kernel/bpf/btf.c

4020

__btf_name_by_offset(btf, member->name_off)))

kernel/bpf/btf.c

4025

n = btf_type_by_id(btf, member->type);

kernel/bpf/btf.c

4028

if (strcmp(node_type_name, __btf_name_by_offset(btf, n->name_off)))

kernel/bpf/btf.c

4037

field->graph_root.btf = (struct btf *)btf;

kernel/bpf/btf.c

4046

static int btf_parse_list_head(const struct btf *btf, struct btf_field *field,

kernel/bpf/btf.c

4049

return btf_parse_graph_root(btf, field, info, "bpf_list_node",

kernel/bpf/btf.c

4053

static int btf_parse_rb_root(const struct btf *btf, struct btf_field *field,

kernel/bpf/btf.c

4056

return btf_parse_graph_root(btf, field, info, "bpf_rb_node",

kernel/bpf/btf.c

4072

struct btf_record *btf_parse_fields(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

4080

ret = btf_find_field(btf, t, field_mask, info_arr, ARRAY_SIZE(info_arr));

kernel/bpf/btf.c

4152

ret = btf_parse_kptr(btf, &rec->fields[i], &info_arr[i]);

kernel/bpf/btf.c

4157

ret = btf_parse_list_head(btf, &rec->fields[i], &info_arr[i]);

kernel/bpf/btf.c

4162

ret = btf_parse_rb_root(btf, &rec->fields[i], &info_arr[i]);

kernel/bpf/btf.c

4205

int btf_check_and_fixup_fields(const struct btf *btf, struct btf_record *rec)

kernel/bpf/btf.c

4228

if (btf_is_kernel(rec->fields[i].kptr.btf))

kernel/bpf/btf.c

423

const struct btf *btf;

kernel/bpf/btf.c

4230

t = btf_type_by_id(rec->fields[i].kptr.btf,

kernel/bpf/btf.c

4242

meta = btf_find_struct_meta(btf, btf_id);

kernel/bpf/btf.c

4293

static void __btf_struct_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

4306

const struct btf_type *member_type = btf_type_by_id(btf,

kernel/bpf/btf.c

4330

ops->show(btf, member_type, member->type,

kernel/bpf/btf.c

4340

static void btf_struct_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

4356

__btf_struct_show(btf, t, type_id, data, bits_offset, show);

kernel/bpf/btf.c

4371

__btf_struct_show(btf, t, type_id, data, bits_offset, show);

kernel/bpf/btf.c

4448

struct btf *btf = env->btf;

kernel/bpf/btf.c

4470

!btf_name_valid_identifier(env->btf, t->name_off)) {

kernel/bpf/btf.c

4478

if (!btf_name_offset_valid(btf, enums[i].name_off)) {

kernel/bpf/btf.c

4486

!btf_name_valid_identifier(btf, enums[i].name_off)) {

kernel/bpf/btf.c

4495

__btf_name_by_offset(btf, enums[i].name_off),

kernel/bpf/btf.c

4508

static void btf_enum_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

4528

__btf_name_by_offset(btf,

kernel/bpf/btf.c

4556

struct btf *btf = env->btf;

kernel/bpf/btf.c

4578

!btf_name_valid_identifier(env->btf, t->name_off)) {

kernel/bpf/btf.c

4586

if (!btf_name_offset_valid(btf, enums[i].name_off)) {

kernel/bpf/btf.c

4594

!btf_name_valid_identifier(btf, enums[i].name_off)) {

kernel/bpf/btf.c

4604

__btf_name_by_offset(btf, enums[i].name_off),

kernel/bpf/btf.c

4611

static void btf_enum64_show(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

462

void (*show)(const struct btf *btf, const struct btf_type *t,

kernel/bpf/btf.c

4631

__btf_name_by_offset(btf,

kernel/bpf/btf.c

4701

__btf_name_by_offset(env->btf,

kernel/bpf/btf.c

4705

__btf_name_by_offset(env->btf,

kernel/bpf/btf.c

4713

__btf_name_by_offset(env->btf,

kernel/bpf/btf.c

4746

!btf_name_valid_identifier(env->btf, t->name_off)) {

kernel/bpf/btf.c

4815

!btf_name_valid_identifier(env->btf, t->name_off)) {

kernel/bpf/btf.c

4881

!btf_name_valid_section(env->btf, t->name_off)) {

kernel/bpf/btf.c

4931

struct btf *btf = env->btf;

kernel/bpf/btf.c

4937

const struct btf_type *var_type = btf_type_by_id(env->btf,

kernel/bpf/btf.c

4952

if (!btf_type_id_size(btf, &type_id, &type_size)) {

kernel/bpf/btf.c

4973

static void btf_datasec_show(const struct btf *btf,

kernel/bpf/btf.c

4986

__btf_name_by_offset(btf, t->name_off));

kernel/bpf/btf.c

4988

var = btf_type_by_id(btf, vsi->type);

kernel/bpf/btf.c

4991

btf_type_ops(var)->show(btf, var, vsi->type,

kernel/bpf/btf.c

500

static int btf_start_id(const struct btf *btf)

kernel/bpf/btf.c

502

return btf->start_id + (btf->base_btf ? 0 : 1);

kernel/bpf/btf.c

5097

value = btf_name_by_offset(env->btf, t->name_off);

kernel/bpf/btf.c

5125

struct btf *btf = env->btf;

kernel/bpf/btf.c

5129

next_type = btf_type_by_id(btf, next_type_id);

kernel/bpf/btf.c

5150

next_type = btf_type_by_id(btf, next_type->type);

kernel/bpf/btf.c

5185

const struct btf *btf;

kernel/bpf/btf.c

5189

btf = env->btf;

kernel/bpf/btf.c

5197

ret_type = btf_type_by_id(btf, ret_type_id);

kernel/bpf/btf.c

5216

if (!btf_type_id_size(btf, &ret_type_id, NULL)) {

kernel/bpf/btf.c

5240

arg_type = btf_type_by_id(btf, arg_type_id);

kernel/bpf/btf.c

5252

(!btf_name_offset_valid(btf, args[i].name_off) ||

kernel/bpf/btf.c

5253

!btf_name_valid_identifier(btf, args[i].name_off))) {

kernel/bpf/btf.c

5266

if (!btf_type_id_size(btf, &arg_type_id, NULL)) {

kernel/bpf/btf.c

5280

const struct btf *btf;

kernel/bpf/btf.c

5283

btf = env->btf;

kernel/bpf/btf.c

5284

proto_type = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

5352

if (!btf_name_offset_valid(env->btf, t->name_off)) {

kernel/bpf/btf.c

5369

struct btf *btf = env->btf;

kernel/bpf/btf.c

5373

hdr = &btf->hdr;

kernel/bpf/btf.c

5374

cur = btf->nohdr_data + hdr->type_off;

kernel/bpf/btf.c

5377

env->log_type_id = btf->base_btf ? btf->start_id : 1;

kernel/bpf/btf.c

538

bool btf_is_vmlinux(const struct btf *btf)

kernel/bpf/btf.c

5398

struct btf *btf = env->btf;

kernel/bpf/btf.c

540

return btf->kernel_btf && !btf->base_btf;

kernel/bpf/btf.c

5404

return !btf_resolved_type_id(btf, type_id) &&

kernel/bpf/btf.c

5405

!btf_resolved_type_size(btf, type_id);

kernel/bpf/btf.c

5408

return btf_resolved_type_id(btf, type_id) &&

kernel/bpf/btf.c

5409

!btf_resolved_type_size(btf, type_id);

kernel/bpf/btf.c

5413

t = btf_type_id_resolve(btf, &type_id);

kernel/bpf/btf.c

5426

elem_type = btf_type_id_size(btf, &elem_type_id, &elem_size);

kernel/bpf/btf.c

5429

btf_resolved_type_size(btf, type_id));

kernel/bpf/btf.c

543

u32 btf_nr_types(const struct btf *btf)

kernel/bpf/btf.c

547

while (btf) {

kernel/bpf/btf.c

5470

struct btf *btf = env->btf;

kernel/bpf/btf.c

548

total += btf->nr_types;

kernel/bpf/btf.c

5480

for (i = btf->base_btf ? 0 : 1; i < btf->nr_types; i++) {

kernel/bpf/btf.c

5481

type_id = btf->start_id + i;

kernel/bpf/btf.c

5482

t = btf_type_by_id(btf, type_id);

kernel/bpf/btf.c

549

btf = btf->base_btf;

kernel/bpf/btf.c

5504

const struct btf_header *hdr = &env->btf->hdr;

kernel/bpf/btf.c

5513

if (!env->btf->base_btf && !hdr->type_len) {

kernel/bpf/btf.c

5528

struct btf *btf = env->btf;

kernel/bpf/btf.c

5531

hdr = &btf->hdr;

kernel/bpf/btf.c

5532

start = btf->nohdr_data + hdr->str_off;

kernel/bpf/btf.c

5536

end != btf->data + btf->data_size) {

kernel/bpf/btf.c

5541

btf->strings = start;

kernel/bpf/btf.c

5543

if (btf->base_btf && !hdr->str_len)

kernel/bpf/btf.c

5549

if (!btf->base_btf && start[0]) {

kernel/bpf/btf.c

5559

const struct btf_header *hdr = &env->btf->hdr;

kernel/bpf/btf.c

5560

struct btf *btf = env->btf;

kernel/bpf/btf.c

5572

start = btf->nohdr_data + hdr->layout_off;

kernel/bpf/btf.c

5584

if (end > btf->data + btf->data_size) {

kernel/bpf/btf.c

5588

btf->layout = start;

kernel/bpf/btf.c

559

static void btf_check_sorted(struct btf *btf)

kernel/bpf/btf.c

5614

const struct btf *btf;

kernel/bpf/btf.c

5616

btf = env->btf;

kernel/bpf/btf.c

5617

hdr = &btf->hdr;

kernel/bpf/btf.c

563

n = btf_nr_types(btf);

kernel/bpf/btf.c

564

if (btf_is_vmlinux(btf)) {

kernel/bpf/btf.c

565

for (i = btf_start_id(btf); i < n; i++) {

kernel/bpf/btf.c

566

const struct btf_type *t = btf_type_by_id(btf, i);

kernel/bpf/btf.c

5668

struct btf *btf;

kernel/bpf/btf.c

567

const char *n = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

5670

btf = env->btf;

kernel/bpf/btf.c

5671

btf_data_size = btf->data_size;

kernel/bpf/btf.c

5678

hdr = btf->data;

kernel/bpf/btf.c

5686

if (hdr_len > sizeof(btf->hdr)) {

kernel/bpf/btf.c

5687

u8 *expected_zero = btf->data + sizeof(btf->hdr);

kernel/bpf/btf.c

5688

u8 *end = btf->data + hdr_len;

kernel/bpf/btf.c

5698

hdr_copy = min_t(u32, hdr_len, sizeof(btf->hdr));

kernel/bpf/btf.c

5699

memcpy(&btf->hdr, btf->data, hdr_copy);

kernel/bpf/btf.c

570

btf->named_start_id = i;

kernel/bpf/btf.c

5701

hdr = &btf->hdr;

kernel/bpf/btf.c

5720

if (!btf->base_btf && btf_data_size == hdr->hdr_len) {

kernel/bpf/btf.c

5738

btf_parse_struct_metas(struct bpf_verifier_log *log, struct btf *btf)

kernel/bpf/btf.c

5759

id = btf_find_by_name_kind(btf, alloc_obj_fields[i], BTF_KIND_STRUCT);

kernel/bpf/btf.c

577

for (i = btf_start_id(btf) + 1; i < n; i++) {

kernel/bpf/btf.c

5773

n = btf_nr_types(btf);

kernel/bpf/btf.c

578

const struct btf_type *ta = btf_type_by_id(btf, i - 1);

kernel/bpf/btf.c

5780

t = btf_type_by_id(btf, i);

kernel/bpf/btf.c

5786

ret = btf_find_kptr(btf, t, 0, 0, &tmp, BPF_KPTR);

kernel/bpf/btf.c

579

const struct btf_type *tb = btf_type_by_id(btf, i);

kernel/bpf/btf.c

580

const char *na = btf_name_by_offset(btf, ta->name_off);

kernel/bpf/btf.c

581

const char *nb = btf_name_by_offset(btf, tb->name_off);

kernel/bpf/btf.c

5814

t = btf_type_by_id(btf, i);

kernel/bpf/btf.c

5839

record = btf_parse_fields(btf, t, BPF_SPIN_LOCK | BPF_RES_SPIN_LOCK | BPF_LIST_HEAD | BPF_LIST_NODE |

kernel/bpf/btf.c

5859

struct btf_struct_meta *btf_find_struct_meta(const struct btf *btf, u32 btf_id)

kernel/bpf/btf.c

5864

tab = btf->struct_meta_tab;

kernel/bpf/btf.c

5871

struct btf *btf, int start_id)

kernel/bpf/btf.c

5876

n = btf_nr_types(btf);

kernel/bpf/btf.c

5882

t = btf_type_by_id(btf, i);

kernel/bpf/btf.c

5908

t = btf_type_by_id(btf, cur_id);

kernel/bpf/btf.c

593

btf->named_start_id = named_start_id;

kernel/bpf/btf.c

5932

static struct btf *btf_parse(const union bpf_attr *attr, bpfptr_t uattr, u32 uattr_size)

kernel/bpf/btf.c

5934

bpfptr_t btf_data = make_bpfptr(attr->btf, uattr.is_kernel);

kernel/bpf/btf.c

5938

struct btf *btf = NULL;

kernel/bpf/btf.c

5957

btf = kzalloc_obj(*btf, GFP_KERNEL | __GFP_NOWARN);

kernel/bpf/btf.c

5958

if (!btf) {

kernel/bpf/btf.c

5962

env->btf = btf;

kernel/bpf/btf.c

5963

btf->named_start_id = 0;

kernel/bpf/btf.c

5971

btf->data = data;

kernel/bpf/btf.c

5972

btf->data_size = attr->btf_size;

kernel/bpf/btf.c

5983

btf->nohdr_data = btf->data + btf->hdr.hdr_len;

kernel/bpf/btf.c

5997

err = btf_check_type_tags(env, btf, 1);

kernel/bpf/btf.c

6001

struct_meta_tab = btf_parse_struct_metas(&env->log, btf);

kernel/bpf/btf.c

6006

btf->struct_meta_tab = struct_meta_tab;

kernel/bpf/btf.c

6012

err = btf_check_and_fixup_fields(btf, struct_meta_tab->types[i].record);

kernel/bpf/btf.c

6023

refcount_set(&btf->refcnt, 1);

kernel/bpf/btf.c

6024

return btf;

kernel/bpf/btf.c

6027

btf_free_struct_meta_tab(btf);

kernel/bpf/btf.c

6035

if (btf)

kernel/bpf/btf.c

6036

btf_free(btf);

kernel/bpf/btf.c

6042

extern struct btf *btf_vmlinux;

kernel/bpf/btf.c

607

u32 btf_named_start_id(const struct btf *btf, bool own)

kernel/bpf/btf.c

609

const struct btf *base_btf = btf;

kernel/bpf/btf.c

6115

bool btf_is_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,

kernel/bpf/btf.c

6122

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

6129

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

6132

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

6139

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

6148

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

617

static s32 btf_find_by_name_kind_bsearch(const struct btf *btf, const char *name)

kernel/bpf/btf.c

6201

static int btf_validate_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,

kernel/bpf/btf.c

6213

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

6218

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

6221

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

6229

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

623

l = btf_named_start_id(btf, true);

kernel/bpf/btf.c

6235

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

624

r = btf_nr_types(btf) - 1;

kernel/bpf/btf.c

627

t = btf_type_by_id(btf, m);

kernel/bpf/btf.c

628

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

6337

struct btf *btf,

kernel/bpf/btf.c

6342

if (!btf_is_prog_ctx_type(log, btf, t, prog_type, arg))

kernel/bpf/btf.c

6369

static struct btf *btf_parse_base(struct btf_verifier_env *env, const char *name,

kernel/bpf/btf.c

6372

struct btf *btf = NULL;

kernel/bpf/btf.c

6378

btf = kzalloc_obj(*btf, GFP_KERNEL | __GFP_NOWARN);

kernel/bpf/btf.c

6379

if (!btf) {

kernel/bpf/btf.c

638

return btf_nr_types(btf);

kernel/bpf/btf.c

6383

env->btf = btf;

kernel/bpf/btf.c

6385

btf->data = data;

kernel/bpf/btf.c

6386

btf->data_size = data_size;

kernel/bpf/btf.c

6387

btf->kernel_btf = true;

kernel/bpf/btf.c

6388

btf->named_start_id = 0;

kernel/bpf/btf.c

6389

strscpy(btf->name, name);

kernel/bpf/btf.c

6395

btf->nohdr_data = btf->data + btf->hdr.hdr_len;

kernel/bpf/btf.c

6405

err = btf_check_type_tags(env, btf, 1);

kernel/bpf/btf.c

6409

btf_check_sorted(btf);

kernel/bpf/btf.c

641

s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind)

kernel/bpf/btf.c

6410

refcount_set(&btf->refcnt, 1);

kernel/bpf/btf.c

6412

return btf;

kernel/bpf/btf.c

6415

if (btf) {

kernel/bpf/btf.c

6416

kvfree(btf->types);

kernel/bpf/btf.c

6417

kfree(btf);

kernel/bpf/btf.c

6422

struct btf *btf_parse_vmlinux(void)

kernel/bpf/btf.c

6426

struct btf *btf;

kernel/bpf/btf.c

643

const struct btf *base_btf = btf_base_btf(btf);

kernel/bpf/btf.c

6435

btf = btf_parse_base(env, "vmlinux", __start_BTF, __stop_BTF - __start_BTF);

kernel/bpf/btf.c

6436

if (IS_ERR(btf))

kernel/bpf/btf.c

6440

bpf_ctx_convert.t = btf_type_by_id(btf, bpf_ctx_convert_btf_id[0]);

kernel/bpf/btf.c

6441

err = btf_alloc_id(btf);

kernel/bpf/btf.c

6443

btf_free(btf);

kernel/bpf/btf.c

6444

btf = ERR_PTR(err);

kernel/bpf/btf.c

6448

return btf;

kernel/bpf/btf.c

6455

static __u32 btf_relocate_id(const struct btf *btf, __u32 id)

kernel/bpf/btf.c

6457

if (!btf->base_btf || !btf->base_id_map)

kernel/bpf/btf.c

6459

return btf->base_id_map[id];

kernel/bpf/btf.c

6464

static struct btf *btf_parse_module(const char *module_name, const void *data,

kernel/bpf/btf.c

6468

struct btf *btf = NULL, *vmlinux_btf, *base_btf = NULL;

kernel/bpf/btf.c

6496

btf = kzalloc_obj(*btf, GFP_KERNEL | __GFP_NOWARN);

kernel/bpf/btf.c

6497

if (!btf) {

kernel/bpf/btf.c

6501

env->btf = btf;

kernel/bpf/btf.c

6503

btf->base_btf = base_btf;

kernel/bpf/btf.c

6504

btf->start_id = base_btf->nr_types;

kernel/bpf/btf.c

6505

btf->start_str_off = base_btf->hdr.str_len;

kernel/bpf/btf.c

6506

btf->kernel_btf = true;

kernel/bpf/btf.c

6507

btf->named_start_id = 0;

kernel/bpf/btf.c

6508

strscpy(btf->name, module_name);

kernel/bpf/btf.c

6510

btf->data = kvmemdup(data, data_size, GFP_KERNEL | __GFP_NOWARN);

kernel/bpf/btf.c

6511

if (!btf->data) {

kernel/bpf/btf.c

6515

btf->data_size = data_size;

kernel/bpf/btf.c

6521

btf->nohdr_data = btf->data + btf->hdr.hdr_len;

kernel/bpf/btf.c

6531

err = btf_check_type_tags(env, btf, btf_nr_types(base_btf));

kernel/bpf/btf.c

6536

err = btf_relocate(btf, vmlinux_btf, &btf->base_id_map);

kernel/bpf/btf.c

654

total = btf_nr_types(btf);

kernel/bpf/btf.c

6544

btf_check_sorted(btf);

kernel/bpf/btf.c

6545

refcount_set(&btf->refcnt, 1);

kernel/bpf/btf.c

6546

return btf;

kernel/bpf/btf.c

655

if (btf->named_start_id > 0 && name[0]) {

kernel/bpf/btf.c

6552

if (btf) {

kernel/bpf/btf.c

6553

kvfree(btf->data);

kernel/bpf/btf.c

6554

kvfree(btf->types);

kernel/bpf/btf.c

6555

kfree(btf);

kernel/bpf/btf.c

656

id = btf_find_by_name_kind_bsearch(btf, name);

kernel/bpf/btf.c

6562

struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog)

kernel/bpf/btf.c

6567

return tgt_prog->aux->btf;

kernel/bpf/btf.c

6572

u32 btf_ctx_arg_idx(struct btf *btf, const struct btf_type *func_proto,

kernel/bpf/btf.c

658

t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

6586

t = btf_type_skip_modifiers(btf, args[i].type, NULL);

kernel/bpf/btf.c

659

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

6592

t = btf_type_skip_modifiers(btf, func_proto->type, NULL);

kernel/bpf/btf.c

6616

int btf_ctx_arg_offset(const struct btf *btf, const struct btf_type *func_proto,

kernel/bpf/btf.c

6626

t = btf_type_by_id(btf, args[i].type);

kernel/bpf/btf.c

6627

t = btf_resolve_size(btf, t, &sz);

kernel/bpf/btf.c

666

for (id = btf_start_id(btf); id < total; id++) {

kernel/bpf/btf.c

667

t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

670

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

679

s32 bpf_find_btf_id(const char *name, u32 kind, struct btf **btf_p)

kernel/bpf/btf.c

681

struct btf *btf;

kernel/bpf/btf.c

6839

struct btf *btf = bpf_prog_get_target_btf(prog);

kernel/bpf/btf.c

685

btf = bpf_get_btf_vmlinux();

kernel/bpf/btf.c

6853

arg = btf_ctx_arg_idx(btf, t, off);

kernel/bpf/btf.c

686

if (IS_ERR(btf))

kernel/bpf/btf.c

687

return PTR_ERR(btf);

kernel/bpf/btf.c

688

if (!btf)

kernel/bpf/btf.c

6895

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

6904

t = btf_type_skip_modifiers(btf, t->type, NULL);

kernel/bpf/btf.c

691

ret = btf_find_by_name_kind(btf, name, kind);

kernel/bpf/btf.c

6921

t = btf_type_by_id(btf, args[arg].type);

kernel/bpf/btf.c

6926

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

6934

__btf_name_by_offset(btf, t->name_off),

kernel/bpf/btf.c

696

btf_get(btf);

kernel/bpf/btf.c

6967

if (!btf_type_is_struct_ptr(btf, t))

kernel/bpf/btf.c

697

*btf_p = btf;

kernel/bpf/btf.c

6981

info->btf = ctx_arg_info->btf ? : btf_vmlinux;

kernel/bpf/btf.c

6992

if (btf_param_match_suffix(btf, &args[arg], "__nullable"))

kernel/bpf/btf.c

6996

struct btf *btf = prog->aux->attach_btf;

kernel/bpf/btf.c

7001

t = btf_type_by_id(btf, prog->aux->attach_btf_id);

kernel/bpf/btf.c

7004

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

7024

if (i == ARRAY_SIZE(raw_tp_null_args) && btf_is_module(btf))

kernel/bpf/btf.c

703

idr_for_each_entry(&btf_idr, btf, id) {

kernel/bpf/btf.c

7036

ret = btf_translate_to_vmlinux(log, btf, t, tgt_type, arg);

kernel/bpf/btf.c

7038

info->btf = btf_vmlinux;

kernel/bpf/btf.c

704

if (!btf_is_module(btf))

kernel/bpf/btf.c

7046

info->btf = btf;

kernel/bpf/btf.c

7048

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7051

tag_value = __btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

7061

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7071

__btf_name_by_offset(btf, t->name_off));

kernel/bpf/btf.c

709

btf_get(btf);

kernel/bpf/btf.c

7093

static int btf_struct_walk(struct bpf_verifier_log *log, const struct btf *btf,

kernel/bpf/btf.c

7106

t = btf_type_skip_modifiers(btf, t->type, NULL);

kernel/bpf/btf.c

7107

tname = __btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

711

ret = btf_find_by_name_kind(btf, name, kind);

kernel/bpf/btf.c

713

*btf_p = btf;

kernel/bpf/btf.c

7132

mtype = btf_type_skip_modifiers(btf, member->type,

kernel/bpf/btf.c

7146

t = btf_type_skip_modifiers(btf, array_elem->type,

kernel/bpf/btf.c

716

btf_put(btf);

kernel/bpf/btf.c

7208

mtype = btf_type_by_id(btf, member->type);

kernel/bpf/btf.c

7209

mname = __btf_name_by_offset(btf, member->name_off);

kernel/bpf/btf.c

7211

mtype = __btf_resolve_size(btf, mtype, &msize,

kernel/bpf/btf.c

724

const struct btf_type *btf_type_skip_modifiers(const struct btf *btf,

kernel/bpf/btf.c

727

const struct btf_type *t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

7309

t = btf_type_by_id(btf, mtype->type);

kernel/bpf/btf.c

731

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7311

tag_value = __btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

7323

stype = btf_type_skip_modifiers(btf, mtype->type, &id);

kernel/bpf/btf.c

7360

const struct btf *btf = reg->btf;

kernel/bpf/btf.c

7371

meta = btf_find_struct_meta(btf, id);

kernel/bpf/btf.c

7388

t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

7390

err = btf_struct_walk(log, btf, t, off, size, &id, &tmp_flag, field_name);

kernel/bpf/btf.c

740

const struct btf_type *btf_type_resolve_ptr(const struct btf *btf,

kernel/bpf/btf.c

7415

t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

7436

bool btf_types_are_same(const struct btf *btf1, u32 id1,

kernel/bpf/btf.c

7437

const struct btf *btf2, u32 id2)

kernel/bpf/btf.c

7447

const struct btf *btf, u32 id, int off,

kernel/bpf/btf.c

7448

const struct btf *need_btf, u32 need_type_id,

kernel/bpf/btf.c

745

t = btf_type_skip_modifiers(btf, id, NULL);

kernel/bpf/btf.c

7456

if (off == 0 && btf_types_are_same(btf, id, need_btf, need_type_id))

kernel/bpf/btf.c

7465

type = btf_type_by_id(btf, id);

kernel/bpf/btf.c

7468

err = btf_struct_walk(log, btf, type, off, 1, &id, &flag, NULL);

kernel/bpf/btf.c

7477

if (!btf_types_are_same(btf, id, need_btf, need_type_id)) {

kernel/bpf/btf.c

7485

static int __get_type_size(struct btf *btf, u32 btf_id,

kernel/bpf/btf.c

749

return btf_type_skip_modifiers(btf, t->type, res_id);

kernel/bpf/btf.c

7490

*ret_type = btf_type_by_id(btf, 0);

kernel/bpf/btf.c

7494

t = btf_type_by_id(btf, btf_id);

kernel/bpf/btf.c

7496

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

752

const struct btf_type *btf_type_resolve_func_ptr(const struct btf *btf,

kernel/bpf/btf.c

7521

struct btf *btf,

kernel/bpf/btf.c

7552

ret = __get_type_size(btf, func->type, &t);

kernel/bpf/btf.c

7569

ret = __get_type_size(btf, args[i].type, &t);

kernel/bpf/btf.c

757

ptype = btf_type_resolve_ptr(btf, id, res_id);

kernel/bpf/btf.c

7600

struct btf *btf1, const struct btf_type *t1,

kernel/bpf/btf.c

7601

struct btf *btf2, const struct btf_type *t2)

kernel/bpf/btf.c

7711

struct btf *btf2, const struct btf_type *t2)

kernel/bpf/btf.c

7713

struct btf *btf1 = prog->aux->btf;

kernel/bpf/btf.c

7733

static bool btf_is_dynptr_ptr(const struct btf *btf, const struct btf_type *t)

kernel/bpf/btf.c

7737

t = btf_type_by_id(btf, t->type); /* skip PTR */

kernel/bpf/btf.c

7740

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7745

name = btf_str_by_offset(btf, t->name_off);

kernel/bpf/btf.c

7758

const struct btf *btf;

kernel/bpf/btf.c

7769

const struct btf *btf, const struct btf_type *t)

kernel/bpf/btf.c

7773

.btf = btf,

kernel/bpf/btf.c

7781

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7784

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7792

arg_idx, btf_type_str(t), __btf_name_by_offset(btf, t->name_off),

kernel/bpf/btf.c

7798

arg_idx, btf_type_str(t), __btf_name_by_offset(btf, t->name_off),

kernel/bpf/btf.c

7803

if (btf_is_module(cc->cands[0].btf)) {

kernel/bpf/btf.c

7805

arg_idx, btf_type_str(t), __btf_name_by_offset(btf, t->name_off));

kernel/bpf/btf.c

7843

struct btf *btf = prog->aux->btf;

kernel/bpf/btf.c

7865

fn_t = btf_type_by_id(btf, btf_id);

kernel/bpf/btf.c

7874

tname = btf_name_by_offset(btf, fn_t->name_off);

kernel/bpf/btf.c

7883

t = btf_type_by_id(btf, fn_t->type);

kernel/bpf/btf.c

7898

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7900

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7916

int id = btf_named_start_id(btf, false) - 1;

kernel/bpf/btf.c

7921

while ((id = btf_find_next_decl_tag(btf, fn_t, i, "arg:", id)) > 0) {

kernel/bpf/btf.c

7922

const struct btf_type *tag_t = btf_type_by_id(btf, id);

kernel/bpf/btf.c

7923

const char *tag = __btf_name_by_offset(btf, tag_t->name_off) + 4;

kernel/bpf/btf.c

7953

t = btf_type_by_id(btf, args[i].type);

kernel/bpf/btf.c

7955

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

7959

if ((tags & ARG_TAG_CTX) || btf_is_prog_ctx_type(log, btf, t, prog_type, i)) {

kernel/bpf/btf.c

7965

btf_validate_prog_ctx_type(log, btf, t, i, prog_type,

kernel/bpf/btf.c

7971

if (btf_is_dynptr_ptr(btf, t)) {

kernel/bpf/btf.c

7987

kern_type_id = btf_get_ptr_to_btf_id(log, i, btf, t);

kernel/bpf/btf.c

7998

struct btf *vmlinux_btf;

kernel/bpf/btf.c

8006

ref_t = btf_type_skip_modifiers(btf, t->type, NULL);

kernel/bpf/btf.c

8013

kern_type_id = btf_get_ptr_to_btf_id(log, i, btf, t);

kernel/bpf/btf.c

8045

t = btf_type_skip_modifiers(btf, t->type, NULL);

kernel/bpf/btf.c

8046

ref_t = btf_resolve_size(btf, t, &mem_size);

kernel/bpf/btf.c

8049

i, btf_type_str(t), btf_name_by_offset(btf, t->name_off),

kernel/bpf/btf.c

8083

static void btf_type_show(const struct btf *btf, u32 type_id, void *obj,

kernel/bpf/btf.c

8086

const struct btf_type *t = btf_type_by_id(btf, type_id);

kernel/bpf/btf.c

8088

show->btf = btf;

kernel/bpf/btf.c

8092

btf_type_ops(t)->show(btf, t, type_id, obj, 0, show);

kernel/bpf/btf.c

8101

int btf_type_seq_show_flags(const struct btf *btf, u32 type_id,

kernel/bpf/btf.c

8110

btf_type_show(btf, type_id, obj, &sseq);

kernel/bpf/btf.c

8115

void btf_type_seq_show(const struct btf *btf, u32 type_id, void *obj,

kernel/bpf/btf.c

8118

(void) btf_type_seq_show_flags(btf, type_id, obj, m,

kernel/bpf/btf.c

8151

int btf_type_snprintf_show(const struct btf *btf, u32 type_id, void *obj,

kernel/bpf/btf.c

8162

btf_type_show(btf, type_id, obj, (struct btf_show *)&ssnprintf);

kernel/bpf/btf.c

8175

const struct btf *btf = filp->private_data;

kernel/bpf/btf.c

8177

seq_printf(m, "btf_id:\t%u\n", READ_ONCE(btf->id));

kernel/bpf/btf.c

8194

static int __btf_new_fd(struct btf *btf)

kernel/bpf/btf.c

8196

return anon_inode_getfd("btf", &btf_fops, btf, O_RDONLY | O_CLOEXEC);

kernel/bpf/btf.c

8201

struct btf *btf;

kernel/bpf/btf.c

8204

btf = btf_parse(attr, uattr, uattr_size);

kernel/bpf/btf.c

8205

if (IS_ERR(btf))

kernel/bpf/btf.c

8206

return PTR_ERR(btf);

kernel/bpf/btf.c

8208

ret = btf_alloc_id(btf);

kernel/bpf/btf.c

8210

btf_free(btf);

kernel/bpf/btf.c

8220

ret = __btf_new_fd(btf);

kernel/bpf/btf.c

8222

btf_put(btf);

kernel/bpf/btf.c

8227

struct btf *btf_get_by_fd(int fd)

kernel/bpf/btf.c

8229

struct btf *btf;

kernel/bpf/btf.c

8232

btf = __btf_get_by_fd(f);

kernel/bpf/btf.c

8233

if (!IS_ERR(btf))

kernel/bpf/btf.c

8234

refcount_inc(&btf->refcnt);

kernel/bpf/btf.c

8236

return btf;

kernel/bpf/btf.c

8239

int btf_get_info_by_fd(const struct btf *btf,

kernel/bpf/btf.c

8259

info.id = READ_ONCE(btf->id);

kernel/bpf/btf.c

8260

ubtf = u64_to_user_ptr(info.btf);

kernel/bpf/btf.c

8261

btf_copy = min_t(u32, btf->data_size, info.btf_size);

kernel/bpf/btf.c

8262

if (copy_to_user(ubtf, btf->data, btf_copy))

kernel/bpf/btf.c

8264

info.btf_size = btf->data_size;

kernel/bpf/btf.c

8266

info.kernel_btf = btf->kernel_btf;

kernel/bpf/btf.c

8273

name_len = strlen(btf->name);

kernel/bpf/btf.c

8278

if (copy_to_user(uname, btf->name, name_len + 1))

kernel/bpf/btf.c

8283

if (copy_to_user(uname, btf->name, uname_len - 1))

kernel/bpf/btf.c

8301

struct btf *btf;

kernel/bpf/btf.c

8305

btf = idr_find(&btf_idr, id);

kernel/bpf/btf.c

8306

if (!btf || !refcount_inc_not_zero(&btf->refcnt))

kernel/bpf/btf.c

8307

btf = ERR_PTR(-ENOENT);

kernel/bpf/btf.c

8310

if (IS_ERR(btf))

kernel/bpf/btf.c

8311

return PTR_ERR(btf);

kernel/bpf/btf.c

8313

fd = __btf_new_fd(btf);

kernel/bpf/btf.c

8315

btf_put(btf);

kernel/bpf/btf.c

8320

u32 btf_obj_id(const struct btf *btf)

kernel/bpf/btf.c

8322

return READ_ONCE(btf->id);

kernel/bpf/btf.c

8325

bool btf_is_kernel(const struct btf *btf)

kernel/bpf/btf.c

8327

return btf->kernel_btf;

kernel/bpf/btf.c

8330

bool btf_is_module(const struct btf *btf)

kernel/bpf/btf.c

8332

return btf->kernel_btf && strcmp(btf->name, "vmlinux") != 0;

kernel/bpf/btf.c

8343

struct btf *btf;

kernel/bpf/btf.c

8351

static void purge_cand_cache(struct btf *btf);

kernel/bpf/btf.c

8358

struct btf *btf;

kernel/bpf/btf.c

8373

btf = btf_parse_module(mod->name, mod->btf_data, mod->btf_data_size,

kernel/bpf/btf.c

8375

if (IS_ERR(btf)) {

kernel/bpf/btf.c

8379

mod->name, PTR_ERR(btf));

kernel/bpf/btf.c

8380

err = PTR_ERR(btf);

kernel/bpf/btf.c

8386

err = btf_alloc_id(btf);

kernel/bpf/btf.c

8388

btf_free(btf);

kernel/bpf/btf.c

8396

btf_mod->btf = btf;

kernel/bpf/btf.c

8408

attr->attr.name = btf->name;

kernel/bpf/btf.c

8410

attr->size = btf->data_size;

kernel/bpf/btf.c

8411

attr->private = btf->data;

kernel/bpf/btf.c

8450

btf_free_id(btf_mod->btf);

kernel/bpf/btf.c

8454

purge_cand_cache(btf_mod->btf);

kernel/bpf/btf.c

8455

btf_put(btf_mod->btf);

kernel/bpf/btf.c

8480

struct module *btf_try_get_module(const struct btf *btf)

kernel/bpf/btf.c

8488

if (btf_mod->btf != btf)

kernel/bpf/btf.c

8510

static struct btf *btf_get_module_btf(const struct module *module)

kernel/bpf/btf.c

8515

struct btf *btf = NULL;

kernel/bpf/btf.c

8518

btf = bpf_get_btf_vmlinux();

kernel/bpf/btf.c

8519

if (!IS_ERR_OR_NULL(btf))

kernel/bpf/btf.c

8520

btf_get(btf);

kernel/bpf/btf.c

8521

return btf;

kernel/bpf/btf.c

8530

btf_get(btf_mod->btf);

kernel/bpf/btf.c

8531

btf = btf_mod->btf;

kernel/bpf/btf.c

8537

return btf;

kernel/bpf/btf.c

8553

struct btf *btf = NULL;

kernel/bpf/btf.c

8563

ret = bpf_find_btf_id(name, kind, &btf);

kernel/bpf/btf.c

8564

if (ret > 0 && btf_is_module(btf)) {

kernel/bpf/btf.c

8565

btf_obj_fd = __btf_new_fd(btf);

kernel/bpf/btf.c

8567

btf_put(btf);

kernel/bpf/btf.c

8573

btf_put(btf);

kernel/bpf/btf.c

8596

int btf_check_iter_arg(struct btf *btf, const struct btf_type *func, int arg_idx)

kernel/bpf/btf.c

8607

t = btf_type_skip_modifiers(btf, arg->type, NULL);

kernel/bpf/btf.c

8610

t = btf_type_skip_modifiers(btf, t->type, &btf_id);

kernel/bpf/btf.c

8614

name = btf_name_by_offset(btf, t->name_off);

kernel/bpf/btf.c

8621

static int btf_check_iter_kfuncs(struct btf *btf, const char *func_name,

kernel/bpf/btf.c

8640

btf_id = btf_check_iter_arg(btf, func, 0);

kernel/bpf/btf.c

8647

t = btf_type_by_id(btf, btf_id);

kernel/bpf/btf.c

8654

iter_name = btf_name_by_offset(btf, t->name_off) + sizeof(ITER_PREFIX) - 1;

kernel/bpf/btf.c

8672

t = btf_type_skip_modifiers(btf, func->type, NULL);

kernel/bpf/btf.c

8679

t = btf_type_by_id(btf, func->type);

kernel/bpf/btf.c

868

static bool btf_name_offset_valid(const struct btf *btf, u32 offset)

kernel/bpf/btf.c

8687

static int btf_check_kfunc_protos(struct btf *btf, u32 func_id, u32 func_flags)

kernel/bpf/btf.c

8694

func = btf_type_by_id(btf, func_id);

kernel/bpf/btf.c

8699

func_name = btf_name_by_offset(btf, func->name_off);

kernel/bpf/btf.c

8703

func = btf_type_by_id(btf, func->type);

kernel/bpf/btf.c

8708

err = btf_check_iter_kfuncs(btf, func_name, func, func_flags);

kernel/bpf/btf.c

8718

static int btf_populate_kfunc_set(struct btf *btf, enum btf_kfunc_hook hook,

kernel/bpf/btf.c

8723

bool vmlinux_set = !btf_is_module(btf);

kernel/bpf/btf.c

873

while (offset < btf->start_str_off)

kernel/bpf/btf.c

8738

tab = btf->kfunc_set_tab;

kernel/bpf/btf.c

874

btf = btf->base_btf;

kernel/bpf/btf.c

876

offset -= btf->start_str_off;

kernel/bpf/btf.c

8761

btf->kfunc_set_tab = tab;

kernel/bpf/btf.c

877

return offset < btf->hdr.str_len;

kernel/bpf/btf.c

8813

set->pairs[i].id = btf_relocate_id(btf, set->pairs[i].id);

kernel/bpf/btf.c

8825

btf_free_kfunc_set_tab(btf);

kernel/bpf/btf.c

8829

static u32 *btf_kfunc_id_set_contains(const struct btf *btf,

kernel/bpf/btf.c

8838

if (!btf->kfunc_set_tab)

kernel/bpf/btf.c

8840

set = btf->kfunc_set_tab->sets[hook];

kernel/bpf/btf.c

8850

static bool __btf_kfunc_is_allowed(const struct btf *btf,

kernel/bpf/btf.c

8860

if (!btf->kfunc_set_tab)

kernel/bpf/btf.c

8863

hook_filter = &btf->kfunc_set_tab->hook_filters[hook];

kernel/bpf/btf.c

890

const char *btf_str_by_offset(const struct btf *btf, u32 offset)

kernel/bpf/btf.c

8919

bool btf_kfunc_is_allowed(const struct btf *btf,

kernel/bpf/btf.c

892

while (offset < btf->start_str_off)

kernel/bpf/btf.c

8927

kfunc_flags = btf_kfunc_id_set_contains(btf, BTF_KFUNC_HOOK_COMMON, kfunc_btf_id);

kernel/bpf/btf.c

8928

if (kfunc_flags && __btf_kfunc_is_allowed(btf, BTF_KFUNC_HOOK_COMMON, kfunc_btf_id, prog))

kernel/bpf/btf.c

893

btf = btf->base_btf;

kernel/bpf/btf.c

8932

kfunc_flags = btf_kfunc_id_set_contains(btf, hook, kfunc_btf_id);

kernel/bpf/btf.c

8933

if (kfunc_flags && __btf_kfunc_is_allowed(btf, hook, kfunc_btf_id, prog))

kernel/bpf/btf.c

8946

u32 *btf_kfunc_flags(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog)

kernel/bpf/btf.c

895

offset -= btf->start_str_off;

kernel/bpf/btf.c

8952

kfunc_flags = btf_kfunc_id_set_contains(btf, BTF_KFUNC_HOOK_COMMON, kfunc_btf_id);

kernel/bpf/btf.c

8957

return btf_kfunc_id_set_contains(btf, hook, kfunc_btf_id);

kernel/bpf/btf.c

896

if (offset < btf->hdr.str_len)

kernel/bpf/btf.c

8960

u32 *btf_kfunc_is_modify_return(const struct btf *btf, u32 kfunc_btf_id,

kernel/bpf/btf.c

8963

if (!__btf_kfunc_is_allowed(btf, BTF_KFUNC_HOOK_FMODRET, kfunc_btf_id, prog))

kernel/bpf/btf.c

8966

return btf_kfunc_id_set_contains(btf, BTF_KFUNC_HOOK_FMODRET, kfunc_btf_id);

kernel/bpf/btf.c

897

return &btf->strings[offset];

kernel/bpf/btf.c

8972

struct btf *btf;

kernel/bpf/btf.c

8975

btf = btf_get_module_btf(kset->owner);

kernel/bpf/btf.c

8976

if (!btf)

kernel/bpf/btf.c

8978

if (IS_ERR(btf))

kernel/bpf/btf.c

8979

return PTR_ERR(btf);

kernel/bpf/btf.c

8982

ret = btf_check_kfunc_protos(btf, btf_relocate_id(btf, kset->set->pairs[i].id),

kernel/bpf/btf.c

8988

ret = btf_populate_kfunc_set(btf, hook, kset);

kernel/bpf/btf.c

8991

btf_put(btf);

kernel/bpf/btf.c

902

static bool btf_name_valid_identifier(const struct btf *btf, u32 offset)

kernel/bpf/btf.c

9021

s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id)

kernel/bpf/btf.c

9023

struct btf_id_dtor_kfunc_tab *tab = btf->dtor_kfunc_tab;

kernel/bpf/btf.c

9038

static int btf_check_dtor_kfuncs(struct btf *btf, const struct btf_id_dtor_kfunc *dtors, u32 cnt)

kernel/bpf/btf.c

9046

dtor_btf_id = btf_relocate_id(btf, dtors[i].kfunc_btf_id);

kernel/bpf/btf.c

9048

dtor_func = btf_type_by_id(btf, dtor_btf_id);

kernel/bpf/btf.c

905

const char *src = btf_str_by_offset(btf, offset);

kernel/bpf/btf.c

9052

dtor_func_proto = btf_type_by_id(btf, dtor_func->type);

kernel/bpf/btf.c

9057

t = btf_type_by_id(btf, dtor_func_proto->type);

kernel/bpf/btf.c

9065

t = btf_type_by_id(btf, args[0].type);

kernel/bpf/btf.c

9074

t = btf_type_by_id(btf, t->type);

kernel/bpf/btf.c

9087

struct btf *btf;

kernel/bpf/btf.c

9091

btf = btf_get_module_btf(owner);

kernel/bpf/btf.c

9092

if (!btf)

kernel/bpf/btf.c

9094

if (IS_ERR(btf))

kernel/bpf/btf.c

9095

return PTR_ERR(btf);

kernel/bpf/btf.c

9104

ret = btf_check_dtor_kfuncs(btf, dtors, add_cnt);

kernel/bpf/btf.c

9108

tab = btf->dtor_kfunc_tab;

kernel/bpf/btf.c

9110

if (WARN_ON_ONCE(tab && btf_is_module(btf))) {

kernel/bpf/btf.c

9126

tab = krealloc(btf->dtor_kfunc_tab,

kernel/bpf/btf.c

9134

if (!btf->dtor_kfunc_tab)

kernel/bpf/btf.c

9136

btf->dtor_kfunc_tab = tab;

kernel/bpf/btf.c

9142

tab->dtors[i].btf_id = btf_relocate_id(btf, tab->dtors[i].btf_id);

kernel/bpf/btf.c

9143

tab->dtors[i].kfunc_btf_id = btf_relocate_id(btf, tab->dtors[i].kfunc_btf_id);

kernel/bpf/btf.c

9152

btf_free_dtor_kfunc_tab(btf);

kernel/bpf/btf.c

9153

btf_put(btf);

kernel/bpf/btf.c

9179

int bpf_core_types_are_compat(const struct btf *local_btf, __u32 local_id,

kernel/bpf/btf.c

9180

const struct btf *targ_btf, __u32 targ_id)

kernel/bpf/btf.c

9188

int bpf_core_types_match(const struct btf *local_btf, u32 local_id,

kernel/bpf/btf.c

9189

const struct btf *targ_btf, u32 targ_id)

kernel/bpf/btf.c

924

static bool btf_name_valid_section(const struct btf *btf, u32 offset)

kernel/bpf/btf.c

927

const char *src = btf_str_by_offset(btf, offset);

kernel/bpf/btf.c

9318

static void __purge_cand_cache(struct btf *btf, struct bpf_cand_cache **cache,

kernel/bpf/btf.c

9328

if (!btf) {

kernel/bpf/btf.c

9341

if (cc->cands[j].btf == btf) {

kernel/bpf/btf.c

9350

static void purge_cand_cache(struct btf *btf)

kernel/bpf/btf.c

9353

__purge_cand_cache(btf, module_cand_cache, MODULE_CAND_CACHE_SIZE);

kernel/bpf/btf.c

9359

bpf_core_add_cands(struct bpf_cand_cache *cands, const struct btf *targ_btf,

kernel/bpf/btf.c

9400

cands->cands[cands->cnt].btf = targ_btf;

kernel/bpf/btf.c

9411

const struct btf *local_btf = ctx->btf;

kernel/bpf/btf.c

9413

const struct btf *main_btf;

kernel/bpf/btf.c

9415

struct btf *mod_btf;

kernel/bpf/btf.c

944

static const char *__btf_name_by_offset(const struct btf *btf, u32 offset)

kernel/bpf/btf.c

951

name = btf_str_by_offset(btf, offset);

kernel/bpf/btf.c

9512

type = btf_type_by_id(ctx->btf, relo->type_id);

kernel/bpf/btf.c

9544

cands.cands[i].btf = cc->cands[i].btf;

kernel/bpf/btf.c

955

const char *btf_name_by_offset(const struct btf *btf, u32 offset)

kernel/bpf/btf.c

9555

err = bpf_core_calc_relo_insn((void *)ctx->log, relo, relo_idx, ctx->btf, &cands, specs,

kernel/bpf/btf.c

957

return btf_str_by_offset(btf, offset);

kernel/bpf/btf.c

9578

struct btf *btf = reg->btf;

kernel/bpf/btf.c

9586

walk_type = btf_type_by_id(btf, reg->btf_id);

kernel/bpf/btf.c

9590

tname = btf_name_by_offset(btf, walk_type->name_off);

kernel/bpf/btf.c

9596

safe_id = btf_find_by_name_kind(btf, safe_tname, BTF_INFO_KIND(walk_type->info));

kernel/bpf/btf.c

960

const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id)

kernel/bpf/btf.c

9600

safe_type = btf_type_by_id(btf, safe_id);

kernel/bpf/btf.c

9605

const char *m_name = __btf_name_by_offset(btf, member->name_off);

kernel/bpf/btf.c

9606

const struct btf_type *mtype = btf_type_by_id(btf, member->type);

kernel/bpf/btf.c

9612

btf_type_skip_modifiers(btf, mtype->type, &id);

kernel/bpf/btf.c

962

while (type_id < btf->start_id)

kernel/bpf/btf.c

9622

const struct btf *reg_btf, u32 reg_id,

kernel/bpf/btf.c

9623

const struct btf *arg_btf, u32 arg_id)

kernel/bpf/btf.c

963

btf = btf->base_btf;

kernel/bpf/btf.c

965

type_id -= btf->start_id;

kernel/bpf/btf.c

966

if (type_id >= btf->nr_types)

kernel/bpf/btf.c

9678

btf_add_struct_ops(struct btf *btf, struct bpf_struct_ops *st_ops,

kernel/bpf/btf.c

968

return btf->types[type_id];

kernel/bpf/btf.c

9684

tab = btf->struct_ops_tab;

kernel/bpf/btf.c

9690

btf->struct_ops_tab = tab;

kernel/bpf/btf.c

9705

btf->struct_ops_tab = tab;

kernel/bpf/btf.c

9708

tab->ops[btf->struct_ops_tab->cnt].st_ops = st_ops;

kernel/bpf/btf.c

9710

err = bpf_struct_ops_desc_init(&tab->ops[btf->struct_ops_tab->cnt], btf, log);

kernel/bpf/btf.c

9714

btf->struct_ops_tab->cnt++;

kernel/bpf/btf.c

9720

bpf_struct_ops_find_value(struct btf *btf, u32 value_id)

kernel/bpf/btf.c

9728

if (!btf->struct_ops_tab)

kernel/bpf/btf.c

9731

cnt = btf->struct_ops_tab->cnt;

kernel/bpf/btf.c

9732

st_ops_list = btf->struct_ops_tab->ops;

kernel/bpf/btf.c

9742

bpf_struct_ops_find(struct btf *btf, u32 type_id)

kernel/bpf/btf.c

9750

if (!btf->struct_ops_tab)

kernel/bpf/btf.c

9753

cnt = btf->struct_ops_tab->cnt;

kernel/bpf/btf.c

9754

st_ops_list = btf->struct_ops_tab->ops;

kernel/bpf/btf.c

9766

struct btf *btf;

kernel/bpf/btf.c

9769

btf = btf_get_module_btf(st_ops->owner);

kernel/bpf/btf.c

9770

if (!btf)

kernel/bpf/btf.c

9772

if (IS_ERR(btf))

kernel/bpf/btf.c

9773

return PTR_ERR(btf);

kernel/bpf/btf.c

9783

err = btf_add_struct_ops(btf, st_ops, log);

kernel/bpf/btf.c

9787

btf_put(btf);

kernel/bpf/btf.c

9794

bool btf_param_match_suffix(const struct btf *btf,

kernel/bpf/btf.c

9802

param_name = btf_name_by_offset(btf, arg->name_off);

kernel/bpf/check_btf.c

108

type = btf_type_by_id(btf, krecord[i].type_id);

kernel/bpf/check_btf.c

115

func_proto = btf_type_by_id(btf, type->type);

kernel/bpf/check_btf.c

142

const struct btf *btf;

kernel/bpf/check_btf.c

161

btf = prog->aux->btf;

kernel/bpf/check_btf.c

181

type = btf_type_by_id(btf, krecord[i].type_id);

kernel/bpf/check_btf.c

184

func_proto = btf_type_by_id(btf, type->type);

kernel/bpf/check_btf.c

186

ret_type = btf_type_skip_modifiers(btf, func_proto->type, NULL);

kernel/bpf/check_btf.c

198

env->subprog_info[i].name = btf_name_by_offset(btf, type->name_off);

kernel/bpf/check_btf.c

221

const struct btf *btf;

kernel/bpf/check_btf.c

246

btf = prog->aux->btf;

kernel/bpf/check_btf.c

299

if (!btf_name_by_offset(btf, linfo[i].line_off) ||

kernel/bpf/check_btf.c

300

!btf_name_by_offset(btf, linfo[i].file_name_off)) {

kernel/bpf/check_btf.c

348

const struct btf *btf = prog->aux->btf;

kernel/bpf/check_btf.c

351

.btf = btf,

kernel/bpf/check_btf.c

40

const struct btf *btf;

kernel/bpf/check_btf.c

414

struct btf *btf;

kernel/bpf/check_btf.c

423

btf = btf_get_by_fd(attr->prog_btf_fd);

kernel/bpf/check_btf.c

424

if (IS_ERR(btf))

kernel/bpf/check_btf.c

425

return PTR_ERR(btf);

kernel/bpf/check_btf.c

426

if (btf_is_kernel(btf)) {

kernel/bpf/check_btf.c

427

btf_put(btf);

kernel/bpf/check_btf.c

430

env->prog->aux->btf = btf;

kernel/bpf/check_btf.c

61

btf = prog->aux->btf;

kernel/bpf/core.c

2981

btf_put(btf_mod->btf);

kernel/bpf/core.c

3378

void bpf_get_linfo_file_line(struct btf *btf, const struct bpf_line_info *linfo,

kernel/bpf/core.c

3383

*filep = btf_name_by_offset(btf, linfo->file_name_off);

kernel/bpf/core.c

3389

*linep = btf_name_by_offset(btf, linfo->line_off);

kernel/bpf/core.c

3441

struct btf *btf;

kernel/bpf/core.c

3444

btf = prog->aux->btf;

kernel/bpf/core.c

3448

if (!btf || !linfo || !jited_linfo)

kernel/bpf/core.c

3469

bpf_get_linfo_file_line(btf, &linfo[idx], filep, linep, nump);

kernel/bpf/core.c

586

type = btf_type_by_id(prog->aux->btf,

kernel/bpf/core.c

588

func_name = btf_name_by_offset(prog->aux->btf, type->name_off);

kernel/bpf/fixups.c

1107

func[i]->aux->btf = prog->aux->btf;

kernel/bpf/hashtab.c

1667

btf_type_seq_show(map->btf, map->btf_key_type_id, key, m);

kernel/bpf/hashtab.c

1669

btf_type_seq_show(map->btf, map->btf_value_type_id, value, m);

kernel/bpf/hashtab.c

2544

btf_type_seq_show(map->btf, map->btf_key_type_id, key, m);

kernel/bpf/hashtab.c

2549

btf_type_seq_show(map->btf, map->btf_value_type_id,

kernel/bpf/hashtab.c

525

static int htab_map_check_btf(struct bpf_map *map, const struct btf *btf,

kernel/bpf/inode.c

594

const struct btf *btf;

kernel/bpf/inode.c

612

const struct btf *btf;

kernel/bpf/inode.c

617

btf = bpf_get_btf_vmlinux();

kernel/bpf/inode.c

618

if (IS_ERR(btf))

kernel/bpf/inode.c

619

return PTR_ERR(btf);

kernel/bpf/inode.c

620

if (!btf)

kernel/bpf/inode.c

623

info->btf = btf;

kernel/bpf/inode.c

626

id = btf_find_by_name_kind(btf, btf_enums[i].name,

kernel/bpf/inode.c

631

*btf_enums[i].type = btf_type_by_id(btf, id);

kernel/bpf/inode.c

637

static bool find_btf_enum_const(const struct btf *btf, const struct btf_type *enum_t,

kernel/bpf/inode.c

646

if (!btf || !enum_t)

kernel/bpf/inode.c

652

name = btf_name_by_offset(btf, e->name_off);

kernel/bpf/inode.c

668

const struct btf *btf,

kernel/bpf/inode.c

690

if (btf && enum_t) {

kernel/bpf/inode.c

693

name = btf_name_by_offset(btf, e->name_off);

kernel/bpf/inode.c

743

info.btf, info.cmd_t, "BPF_",

kernel/bpf/inode.c

748

info.btf, info.map_t, "BPF_MAP_TYPE_",

kernel/bpf/inode.c

753

info.btf, info.prog_t, "BPF_PROG_TYPE_",

kernel/bpf/inode.c

758

info.btf, info.attach_t, "BPF_",

kernel/bpf/inode.c

905

} else if (find_btf_enum_const(info.btf, enum_t, enum_pfx, p, &val)) {

kernel/bpf/local_storage.c

368

const struct btf *btf,

kernel/bpf/local_storage.c

396

if (!btf_member_is_reg_int(btf, key_type, m, 0, size))

kernel/bpf/local_storage.c

405

if (!btf_member_is_reg_int(btf, key_type, m, offset, size))

kernel/bpf/local_storage.c

432

btf_type_seq_show(map->btf, map->btf_key_type_id, key, m);

kernel/bpf/local_storage.c

436

btf_type_seq_show(map->btf, map->btf_value_type_id,

kernel/bpf/local_storage.c

443

btf_type_seq_show(map->btf, map->btf_value_type_id,

kernel/bpf/log.c

345

const struct btf *btf;

kernel/bpf/log.c

376

btf = env->prog->aux->btf;

kernel/bpf/log.c

377

s = ltrim(btf_name_by_offset(btf, linfo->line_off));

kernel/bpf/log.c

380

s = btf_name_by_offset(btf, linfo->file_name_off);

kernel/bpf/log.c

389

static const char *btf_type_name(const struct btf *btf, u32 id)

kernel/bpf/log.c

391

return btf_name_by_offset(btf, btf_type_by_id(btf, id)->name_off);

kernel/bpf/log.c

473

const char *iter_type_str(const struct btf *btf, u32 btf_id)

kernel/bpf/log.c

475

if (!btf || btf_id == 0)

kernel/bpf/log.c

479

return btf_type_name(btf, btf_id) + sizeof(ITER_PREFIX) - 1;

kernel/bpf/log.c

662

verbose(env, "%s", btf_type_name(reg->btf, reg->btf_id));

kernel/bpf/log.c

784

iter_type_str(reg->iter.btf, reg->iter.btf_id),

kernel/bpf/lpm_trie.c

755

const struct btf *btf,

kernel/bpf/map_in_map.c

57

if (inner_map->btf) {

kernel/bpf/map_in_map.c

58

btf_get(inner_map->btf);

kernel/bpf/map_in_map.c

59

inner_map_meta->btf = inner_map->btf;

kernel/bpf/map_in_map.c

79

btf_put(map_meta->btf);

kernel/bpf/preload/iterators/iterators.bpf.c

114

get_name(aux->btf, aux->func_info[0].type_id, aux->name),

kernel/bpf/preload/iterators/iterators.bpf.c

46

struct btf *btf;

kernel/bpf/preload/iterators/iterators.bpf.c

59

static const char *get_name(struct btf *btf, long btf_id, const char *fallback)

kernel/bpf/preload/iterators/iterators.bpf.c

65

if (!btf)

kernel/bpf/preload/iterators/iterators.bpf.c

67

str = btf->strings;

kernel/bpf/preload/iterators/iterators.bpf.c

68

types = btf->types;

kernel/bpf/preload/iterators/iterators.bpf.c

71

if (name_off >= btf->hdr.str_len)

kernel/bpf/states.c

814

if (old_reg->iter.btf != cur_reg->iter.btf ||

kernel/bpf/syscall.c

1231

const struct btf *btf,

kernel/bpf/syscall.c

1239

const struct btf *btf, u32 btf_key_id, u32 btf_value_id)

kernel/bpf/syscall.c

1247

key_type = btf_type_id_size(btf, &btf_key_id, &key_size);

kernel/bpf/syscall.c

1251

key_type = btf_type_by_id(btf, 0);

kernel/bpf/syscall.c

1256

value_type = btf_type_id_size(btf, &btf_value_id, &value_size);

kernel/bpf/syscall.c

1260

map->record = btf_parse_fields(btf, value_type,

kernel/bpf/syscall.c

1344

ret = btf_check_and_fixup_fields(btf, map->record);

kernel/bpf/syscall.c

1349

ret = map->ops->map_check_btf(map, btf, key_type, value_type);

kernel/bpf/syscall.c

1530

struct btf *btf;

kernel/bpf/syscall.c

1532

btf = btf_get_by_fd(attr->btf_fd);

kernel/bpf/syscall.c

1533

if (IS_ERR(btf)) {

kernel/bpf/syscall.c

1534

err = PTR_ERR(btf);

kernel/bpf/syscall.c

1537

if (btf_is_kernel(btf)) {

kernel/bpf/syscall.c

1538

btf_put(btf);

kernel/bpf/syscall.c

1542

map->btf = btf;

kernel/bpf/syscall.c

1545

err = map_check_btf(map, token, btf, attr->btf_key_type_id,

kernel/bpf/syscall.c

217

t = btf_type_by_id(field->kptr.btf, field->kptr.btf_id);

kernel/bpf/syscall.c

2372

btf_put(prog->aux->btf);

kernel/bpf/syscall.c

2648

struct btf *attach_btf, u32 btf_id,

kernel/bpf/syscall.c

2868

struct btf *attach_btf = NULL;

kernel/bpf/syscall.c

5017

struct btf *attach_btf = bpf_prog_get_target_btf(prog);

kernel/bpf/syscall.c

5071

if (prog->aux->btf)

kernel/bpf/syscall.c

5072

info.btf_id = btf_obj_id(prog->aux->btf);

kernel/bpf/syscall.c

5328

if (map->btf) {

kernel/bpf/syscall.c

5329

info.btf_id = btf_obj_id(map->btf);

kernel/bpf/syscall.c

5373

struct btf *btf,

kernel/bpf/syscall.c

5385

return btf_get_info_by_fd(btf, attr, uattr);

kernel/bpf/syscall.c

678

if (btf_is_kernel(rec->fields[i].kptr.btf))

kernel/bpf/syscall.c

679

btf_put(rec->fields[i].kptr.btf);

kernel/bpf/syscall.c

728

if (btf_is_kernel(fields[i].kptr.btf))

kernel/bpf/syscall.c

729

btf_get(fields[i].kptr.btf);

kernel/bpf/syscall.c

846

if (!btf_is_kernel(field->kptr.btf)) {

kernel/bpf/syscall.c

847

pointee_struct_meta = btf_find_struct_meta(field->kptr.btf,

kernel/bpf/syscall.c

884

struct btf *btf = map->btf;

kernel/bpf/syscall.c

908

btf_put(btf);

kernel/bpf/verifier.c

1036

struct btf *btf, u32 btf_id, int nr_slots)

kernel/bpf/verifier.c

10526

type = btf_type_by_id(reg->btf, reg->btf_id);

kernel/bpf/verifier.c

1056

if (st->iter.btf != btf || st->iter.btf_id != btf_id)

kernel/bpf/verifier.c

10643

regs[BPF_REG_0].btf = meta.ret_btf;

kernel/bpf/verifier.c

10650

struct btf *ret_btf;

kernel/bpf/verifier.c

10656

ret_btf = meta.kptr_field->kptr.btf;

kernel/bpf/verifier.c

10678

regs[BPF_REG_0].btf = ret_btf;

kernel/bpf/verifier.c

10825

static bool is_kfunc_arg_mem_size(const struct btf *btf,

kernel/bpf/verifier.c

10831

t = btf_type_skip_modifiers(btf, arg->type, NULL);

kernel/bpf/verifier.c

10835

return btf_param_match_suffix(btf, arg, "__sz");

kernel/bpf/verifier.c

10838

static bool is_kfunc_arg_const_mem_size(const struct btf *btf,

kernel/bpf/verifier.c

10844

t = btf_type_skip_modifiers(btf, arg->type, NULL);

kernel/bpf/verifier.c

10848

return btf_param_match_suffix(btf, arg, "__szk");

kernel/bpf/verifier.c

10851

static bool is_kfunc_arg_constant(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10853

return btf_param_match_suffix(btf, arg, "__k");

kernel/bpf/verifier.c

10856

static bool is_kfunc_arg_ignore(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10858

return btf_param_match_suffix(btf, arg, "__ign");

kernel/bpf/verifier.c

10861

static bool is_kfunc_arg_map(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10863

return btf_param_match_suffix(btf, arg, "__map");

kernel/bpf/verifier.c

10866

static bool is_kfunc_arg_alloc_obj(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10868

return btf_param_match_suffix(btf, arg, "__alloc");

kernel/bpf/verifier.c

10871

static bool is_kfunc_arg_uninit(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10873

return btf_param_match_suffix(btf, arg, "__uninit");

kernel/bpf/verifier.c

10876

static bool is_kfunc_arg_refcounted_kptr(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10878

return btf_param_match_suffix(btf, arg, "__refcounted_kptr");

kernel/bpf/verifier.c

10881

static bool is_kfunc_arg_nullable(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10883

return btf_param_match_suffix(btf, arg, "__nullable");

kernel/bpf/verifier.c

10886

static bool is_kfunc_arg_const_str(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10888

return btf_param_match_suffix(btf, arg, "__str");

kernel/bpf/verifier.c

10891

static bool is_kfunc_arg_irq_flag(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10893

return btf_param_match_suffix(btf, arg, "__irq_flag");

kernel/bpf/verifier.c

10896

static bool is_kfunc_arg_scalar_with_name(const struct btf *btf,

kernel/bpf/verifier.c

10903

param_name = btf_name_by_offset(btf, arg->name_off);

kernel/bpf/verifier.c

10940

static bool __is_kfunc_ptr_arg_type(const struct btf *btf,

kernel/bpf/verifier.c

10946

t = btf_type_skip_modifiers(btf, arg->type, NULL);

kernel/bpf/verifier.c

10951

t = btf_type_skip_modifiers(btf, t->type, &res_id);

kernel/bpf/verifier.c

10954

return btf_types_are_same(btf, res_id, btf_vmlinux, kf_arg_btf_ids[type]);

kernel/bpf/verifier.c

10957

static bool is_kfunc_arg_dynptr(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10959

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_DYNPTR_ID);

kernel/bpf/verifier.c

10962

static bool is_kfunc_arg_list_head(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10964

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_LIST_HEAD_ID);

kernel/bpf/verifier.c

10967

static bool is_kfunc_arg_list_node(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10969

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_LIST_NODE_ID);

kernel/bpf/verifier.c

10972

static bool is_kfunc_arg_rbtree_root(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10974

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_RB_ROOT_ID);

kernel/bpf/verifier.c

10977

static bool is_kfunc_arg_rbtree_node(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10979

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_RB_NODE_ID);

kernel/bpf/verifier.c

10982

static bool is_kfunc_arg_timer(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10984

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_TIMER_ID);

kernel/bpf/verifier.c

10987

static bool is_kfunc_arg_wq(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10989

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_WORKQUEUE_ID);

kernel/bpf/verifier.c

10992

static bool is_kfunc_arg_task_work(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10994

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_TASK_WORK_ID);

kernel/bpf/verifier.c

10997

static bool is_kfunc_arg_res_spin_lock(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

10999

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_RES_SPIN_LOCK_ID);

kernel/bpf/verifier.c

11012

static bool is_kfunc_arg_callback(struct bpf_verifier_env *env, const struct btf *btf,

kernel/bpf/verifier.c

11017

t = btf_type_resolve_func_ptr(btf, arg->type, NULL);

kernel/bpf/verifier.c

11024

static bool is_kfunc_arg_prog_aux(const struct btf *btf, const struct btf_param *arg)

kernel/bpf/verifier.c

11026

return __is_kfunc_ptr_arg_type(btf, arg, KF_ARG_PROG_AUX_ID);

kernel/bpf/verifier.c

11044

func = btf_type_by_id(meta->btf, meta->func_id);

kernel/bpf/verifier.c

11045

func_proto = btf_type_by_id(meta->btf, func->type);

kernel/bpf/verifier.c

11053

const struct btf *btf,

kernel/bpf/verifier.c

11066

member_type = btf_type_skip_modifiers(btf, member->type, NULL);

kernel/bpf/verifier.c

11072

if (!__btf_type_is_scalar_struct(env, btf, member_type, rec + 1))

kernel/bpf/verifier.c

11080

member_type = btf_type_skip_modifiers(btf, array->type, NULL);

kernel/bpf/verifier.c

11371

(is_kfunc_arg_mem_size(meta->btf, &args[argno + 1], &regs[regno + 1]) ||

kernel/bpf/verifier.c

11372

is_kfunc_arg_const_mem_size(meta->btf, &args[argno + 1], &regs[regno + 1])))

kernel/bpf/verifier.c

11380

if (btf_is_prog_ctx_type(&env->log, meta->btf, t, resolve_prog_type(env->prog), argno))

kernel/bpf/verifier.c

11383

if (is_kfunc_arg_nullable(meta->btf, &args[argno]) && bpf_register_is_null(reg) &&

kernel/bpf/verifier.c

11387

if (is_kfunc_arg_alloc_obj(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11390

if (is_kfunc_arg_refcounted_kptr(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11393

if (is_kfunc_arg_dynptr(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11399

if (is_kfunc_arg_list_head(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11402

if (is_kfunc_arg_list_node(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11405

if (is_kfunc_arg_rbtree_root(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11408

if (is_kfunc_arg_rbtree_node(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11411

if (is_kfunc_arg_const_str(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11414

if (is_kfunc_arg_map(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11417

if (is_kfunc_arg_wq(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11420

if (is_kfunc_arg_timer(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11423

if (is_kfunc_arg_task_work(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11426

if (is_kfunc_arg_irq_flag(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11429

if (is_kfunc_arg_res_spin_lock(meta->btf, &args[argno]))

kernel/bpf/verifier.c

11441

if (is_kfunc_arg_callback(env, meta->btf, &args[argno]))

kernel/bpf/verifier.c

11449

if (!btf_type_is_scalar(ref_t) && !__btf_type_is_scalar_struct(env, meta->btf, ref_t, 0) &&

kernel/bpf/verifier.c

11467

const struct btf *reg_btf;

kernel/bpf/verifier.c

11474

reg_btf = reg->btf;

kernel/bpf/verifier.c

11506

btf_type_ids_nocast_alias(&env->log, reg_btf, reg_ref_id, meta->btf, ref_id))

kernel/bpf/verifier.c

11514

meta->btf, ref_id, strict_type_match);

kernel/bpf/verifier.c

11691

ptr = reg->btf;

kernel/bpf/verifier.c

11868

if (meta->btf != btf_vmlinux) {

kernel/bpf/verifier.c

11936

if (meta->btf != btf_vmlinux) {

kernel/bpf/verifier.c

11961

et = btf_type_by_id(field->graph_root.btf, field->graph_root.value_btf_id);

kernel/bpf/verifier.c

11962

t = btf_type_by_id(reg->btf, reg->btf_id);

kernel/bpf/verifier.c

11963

if (!btf_struct_ids_match(&env->log, reg->btf, reg->btf_id, 0, field->graph_root.btf,

kernel/bpf/verifier.c

11970

btf_name_by_offset(field->graph_root.btf, et->name_off),

kernel/bpf/verifier.c

11971

node_off, btf_name_by_offset(reg->btf, t->name_off));

kernel/bpf/verifier.c

11974

meta->arg_btf = reg->btf;

kernel/bpf/verifier.c

11981

btf_name_by_offset(field->graph_root.btf, et->name_off));

kernel/bpf/verifier.c

12032

const struct btf *btf = meta->btf;

kernel/bpf/verifier.c

12057

if (is_kfunc_arg_prog_aux(btf, &args[i])) {

kernel/bpf/verifier.c

12068

if (is_kfunc_arg_ignore(btf, &args[i]) || is_kfunc_arg_implicit(meta, i))

kernel/bpf/verifier.c

12071

t = btf_type_skip_modifiers(btf, args[i].type, NULL);

kernel/bpf/verifier.c

12079

if (is_kfunc_arg_constant(meta->btf, &args[i])) {

kernel/bpf/verifier.c

12093

} else if (is_kfunc_arg_scalar_with_name(btf, &args[i], "rdonly_buf_size")) {

kernel/bpf/verifier.c

12096

} else if (is_kfunc_arg_scalar_with_name(btf, &args[i], "rdwr_buf_size")) {

kernel/bpf/verifier.c

12125

!is_kfunc_arg_nullable(meta->btf, &args[i])) {

kernel/bpf/verifier.c

12142

ref_t = btf_type_skip_modifiers(btf, t->type, &ref_id);

kernel/bpf/verifier.c

12143

ref_tname = btf_name_by_offset(btf, ref_t->name_off);

kernel/bpf/verifier.c

12266

if (meta->btf == btf_vmlinux) {

kernel/bpf/verifier.c

12267

meta->arg_btf = reg->btf;

kernel/bpf/verifier.c

12279

if (is_kfunc_arg_uninit(btf, &args[i]))

kernel/bpf/verifier.c

12409

ref_tname = btf_name_by_offset(btf, ref_t->name_off);

kernel/bpf/verifier.c

12427

resolve_ret = btf_resolve_size(btf, ref_t, &type_size);

kernel/bpf/verifier.c

12444

if (!bpf_register_is_null(buff_reg) || !is_kfunc_arg_nullable(meta->btf, buff_arg)) {

kernel/bpf/verifier.c

12452

if (is_kfunc_arg_const_mem_size(meta->btf, size_arg, size_reg)) {

kernel/bpf/verifier.c

12495

meta->arg_btf = reg->btf;

kernel/bpf/verifier.c

12590

meta->btf = kfunc.btf;

kernel/bpf/verifier.c

12595

if (!kfunc.flags || !btf_kfunc_is_allowed(kfunc.btf, kfunc.id, env->prog))

kernel/bpf/verifier.c

12738

const struct btf *btf;

kernel/bpf/verifier.c

12745

btf = meta.btf;

kernel/bpf/verifier.c

12751

t = btf_type_skip_modifiers(btf, args[arg].type, NULL);

kernel/bpf/verifier.c

12756

if (is_kfunc_arg_dynptr(btf, &args[arg])) {

kernel/bpf/verifier.c

12763

(btf_param_match_suffix(btf, &args[arg + 1], "__sz") ||

kernel/bpf/verifier.c

12764

btf_param_match_suffix(btf, &args[arg + 1], "__szk"))) {

kernel/bpf/verifier.c

12775

ref_t = btf_type_skip_modifiers(btf, t->type, NULL);

kernel/bpf/verifier.c

12776

if (!IS_ERR(btf_resolve_size(btf, ref_t, &type_size))) {

kernel/bpf/verifier.c

12786

if (is_kfunc_arg_uninit(btf, &args[arg]))

kernel/bpf/verifier.c

12798

const struct btf_type *ptr_type, struct btf *desc_btf)

kernel/bpf/verifier.c

12803

if (meta->btf != btf_vmlinux)

kernel/bpf/verifier.c

12808

struct btf *ret_btf;

kernel/bpf/verifier.c

12819

ret_btf = env->prog->aux->btf;

kernel/bpf/verifier.c

12878

regs[BPF_REG_0].btf = ret_btf;

kernel/bpf/verifier.c

12888

regs[BPF_REG_0].btf = meta->arg_btf;

kernel/bpf/verifier.c

12905

regs[BPF_REG_0].btf = desc_btf;

kernel/bpf/verifier.c

12916

regs[BPF_REG_0].btf = desc_btf;

kernel/bpf/verifier.c

12986

struct btf *desc_btf;

kernel/bpf/verifier.c

12997

desc_btf = meta.btf;

kernel/bpf/verifier.c

13204

if (is_kfunc_acquire(&meta) && !btf_type_is_struct_ptr(meta.btf, t)) {

kernel/bpf/verifier.c

13205

if (meta.btf != btf_vmlinux ||

kernel/bpf/verifier.c

13216

if (meta.btf == btf_vmlinux && (meta.func_id == special_kfunc_list[KF_bpf_res_spin_lock] ||

kernel/bpf/verifier.c

13292

regs[BPF_REG_0].btf = desc_btf;

kernel/bpf/verifier.c

13318

if (meta.btf == btf_vmlinux) {

kernel/bpf/verifier.c

16563

dst_reg->btf = aux->btf_var.btf;

kernel/bpf/verifier.c

16888

reg_type = reg->btf ? btf_type_by_id(reg->btf, reg->btf_id) : NULL;

kernel/bpf/verifier.c

17039

cs->is_void = btf_type_is_void(btf_type_by_id(meta.btf, meta.func_proto->type));

kernel/bpf/verifier.c

17850

static int find_btf_percpu_datasec(struct btf *btf)

kernel/bpf/verifier.c

17861

n = btf_nr_types(btf);

kernel/bpf/verifier.c

17862

for (i = btf_named_start_id(btf, true); i < n; i++) {

kernel/bpf/verifier.c

17863

t = btf_type_by_id(btf, i);

kernel/bpf/verifier.c

17867

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/verifier.c

17881

static int __add_used_btf(struct bpf_verifier_env *env, struct btf *btf)

kernel/bpf/verifier.c

17889

if (env->used_btfs[i].btf == btf)

kernel/bpf/verifier.c

17900

btf_mod->btf = btf;

kernel/bpf/verifier.c

17904

if (btf_is_module(btf)) {

kernel/bpf/verifier.c

17905

btf_mod->module = btf_try_get_module(btf);

kernel/bpf/verifier.c

17917

btf_put(btf);

kernel/bpf/verifier.c

17925

struct btf *btf)

kernel/bpf/verifier.c

17937

t = btf_type_by_id(btf, id);

kernel/bpf/verifier.c

17948

sym_name = btf_name_by_offset(btf, t->name_off);

kernel/bpf/verifier.c

17964

datasec_id = find_btf_percpu_datasec(btf);

kernel/bpf/verifier.c

17966

datasec = btf_type_by_id(btf, datasec_id);

kernel/bpf/verifier.c

17976

t = btf_type_skip_modifiers(btf, type, NULL);

kernel/bpf/verifier.c

17979

aux->btf_var.btf = btf;

kernel/bpf/verifier.c

17987

ret = btf_resolve_size(btf, t, &tsize);

kernel/bpf/verifier.c

17989

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/verifier.c

17998

aux->btf_var.btf = btf;

kernel/bpf/verifier.c

18009

struct btf *btf;

kernel/bpf/verifier.c

18015

btf = btf_get_by_fd(btf_fd);

kernel/bpf/verifier.c

18016

if (IS_ERR(btf)) {

kernel/bpf/verifier.c

18026

btf = btf_vmlinux;

kernel/bpf/verifier.c

18029

err = __check_pseudo_btf_id(env, insn, aux, btf);

kernel/bpf/verifier.c

18031

btf_put(btf);

kernel/bpf/verifier.c

18035

return __add_used_btf(env, btf);

kernel/bpf/verifier.c

1868

regs[regno].btf = ds_head->btf;

kernel/bpf/verifier.c

18768

reg->btf = bpf_get_btf_vmlinux(); /* can't fail at this point */

kernel/bpf/verifier.c

18936

struct btf *btf;

kernel/bpf/verifier.c

18948

btf = prog->aux->attach_btf;

kernel/bpf/verifier.c

18949

if (btf_is_module(btf)) {

kernel/bpf/verifier.c

18951

env->attach_btf_mod = btf_try_get_module(btf);

kernel/bpf/verifier.c

18954

btf_get_name(btf));

kernel/bpf/verifier.c

18960

st_ops_desc = bpf_struct_ops_find(btf, btf_id);

kernel/bpf/verifier.c

18977

mname = btf_name_by_offset(btf, member->name_off);

kernel/bpf/verifier.c

18978

func_proto = btf_type_resolve_func_ptr(btf, member->type,

kernel/bpf/verifier.c

19145

struct btf *btf;

kernel/bpf/verifier.c

19153

btf = tgt_prog ? tgt_prog->aux->btf : prog->aux->attach_btf;

kernel/bpf/verifier.c

19154

if (!btf) {

kernel/bpf/verifier.c

19159

t = btf_type_by_id(btf, btf_id);

kernel/bpf/verifier.c

19164

tname = btf_name_by_offset(btf, t->name_off);

kernel/bpf/verifier.c

19307

ret = btf_find_by_name_kind(btf, fname, BTF_KIND_FUNC);

kernel/bpf/verifier.c

19312

t = btf_type_by_id(btf, t->type);

kernel/bpf/verifier.c

19317

t = btf_type_by_id(btf, ret);

kernel/bpf/verifier.c

19323

t = btf_type_by_id(btf, t->type);

kernel/bpf/verifier.c

19335

t = btf_type_by_id(btf, t->type);

kernel/bpf/verifier.c

19338

ret = btf_distill_func_proto(log, btf, t, tname, &tgt_info->fmodel);

kernel/bpf/verifier.c

19363

btf_check_type_match(log, prog, btf, t))

kernel/bpf/verifier.c

19365

t = btf_type_by_id(btf, t->type);

kernel/bpf/verifier.c

19377

ret = btf_distill_func_proto(log, btf, t, tname, &tgt_info->fmodel);

kernel/bpf/verifier.c

19387

if (btf_is_module(btf)) {

kernel/bpf/verifier.c

19388

mod = btf_try_get_module(btf);

kernel/bpf/verifier.c

19415

u32 *flags = btf_kfunc_is_modify_return(btf, btf_id,

kernel/bpf/verifier.c

19444

if (btf_kfunc_is_modify_return(btf, btf_id, prog) ||

kernel/bpf/verifier.c

19619

struct btf *bpf_get_btf_vmlinux(void)

kernel/bpf/verifier.c

19638

struct btf *btf;

kernel/bpf/verifier.c

19650

btf = __btf_get_by_fd(f);

kernel/bpf/verifier.c

19651

if (!IS_ERR(btf)) {

kernel/bpf/verifier.c

19652

btf_get(btf);

kernel/bpf/verifier.c

19653

return __add_used_btf(env, btf);

kernel/bpf/verifier.c

245

struct btf *btf;

kernel/bpf/verifier.c

247

struct btf *ret_btf;

kernel/bpf/verifier.c

2521

struct btf *btf, u32 btf_id,

kernel/bpf/verifier.c

2531

regs[regno].btf = btf;

kernel/bpf/verifier.c

255

struct btf *btf;

kernel/bpf/verifier.c

262

struct btf *btf_vmlinux;

kernel/bpf/verifier.c

264

static const char *btf_type_name(const struct btf *btf, u32 id)

kernel/bpf/verifier.c

266

return btf_name_by_offset(btf, btf_type_by_id(btf, id)->name_off);

kernel/bpf/verifier.c

2693

struct btf *btf = aux->btf;

kernel/bpf/verifier.c

2704

t = btf_type_by_id(btf, main_btf_id);

kernel/bpf/verifier.c

2710

name = btf_find_decl_tag_value(btf, t, -1, "exception_callback:");

kernel/bpf/verifier.c

2721

ret = btf_find_by_name_kind(btf, name, BTF_KIND_FUNC);

kernel/bpf/verifier.c

2727

t = btf_type_by_id(btf, id);

kernel/bpf/verifier.c

2755

struct btf *btf;

kernel/bpf/verifier.c

2809

static struct btf *__find_kfunc_desc_btf(struct bpf_verifier_env *env,

kernel/bpf/verifier.c

2816

struct btf *btf;

kernel/bpf/verifier.c

2838

btf = btf_get_by_fd(btf_fd);

kernel/bpf/verifier.c

2839

if (IS_ERR(btf)) {

kernel/bpf/verifier.c

2841

return btf;

kernel/bpf/verifier.c

2844

if (!btf_is_module(btf)) {

kernel/bpf/verifier.c

2846

btf_put(btf);

kernel/bpf/verifier.c

2850

mod = btf_try_get_module(btf);

kernel/bpf/verifier.c

2852

btf_put(btf);

kernel/bpf/verifier.c

2857

b->btf = btf;

kernel/bpf/verifier.c

2867

btf = b->btf;

kernel/bpf/verifier.c

2870

return btf;

kernel/bpf/verifier.c

2880

btf_put(tab->descs[tab->nr_descs].btf);

kernel/bpf/verifier.c

2885

static struct btf *find_kfunc_desc_btf(struct bpf_verifier_env *env, s16 offset)

kernel/bpf/verifier.c

2904

struct btf *btf,

kernel/bpf/verifier.c

2918

impl_id = btf_find_by_name_kind(btf, buf, BTF_KIND_FUNC);

kernel/bpf/verifier.c

2924

func = btf_type_by_id(btf, impl_id);

kernel/bpf/verifier.c

2926

return btf_type_by_id(btf, func->type);

kernel/bpf/verifier.c

2937

struct btf *btf;

kernel/bpf/verifier.c

2944

btf = find_kfunc_desc_btf(env, offset);

kernel/bpf/verifier.c

2945

if (IS_ERR(btf)) {

kernel/bpf/verifier.c

2947

return PTR_ERR(btf);

kernel/bpf/verifier.c

2957

kfunc_flags = btf_kfunc_flags(btf, func_id, env->prog);

kernel/bpf/verifier.c

2959

func = btf_type_by_id(btf, func_id);

kernel/bpf/verifier.c

2965

func_name = btf_name_by_offset(btf, func->name_off);

kernel/bpf/verifier.c

2972

func_proto = find_kfunc_impl_proto(env, btf, func_name);

kernel/bpf/verifier.c

2974

func_proto = btf_type_by_id(btf, func->type);

kernel/bpf/verifier.c

2983

kfunc->btf = btf;

kernel/bpf/verifier.c

3073

err = btf_distill_func_proto(&env->log, kfunc.btf, kfunc.proto, kfunc.name, &func_model);

kernel/bpf/verifier.c

333

meta = btf_find_struct_meta(reg->btf, reg->btf_id);

kernel/bpf/verifier.c

350

const struct btf *btf = env->prog->aux->btf;

kernel/bpf/verifier.c

355

func = btf_type_by_id(btf, btf_id);

kernel/bpf/verifier.c

3586

struct btf *desc_btf;

kernel/bpf/verifier.c

359

func_proto = btf_type_by_id(btf, func->type);

kernel/bpf/verifier.c

363

type = btf_type_skip_modifiers(btf, func_proto->type, NULL);

kernel/bpf/verifier.c

378

return btf_type_name(env->prog->aux->btf, info->type_id);

kernel/bpf/verifier.c

4548

const char *targ_name = btf_type_name(kptr_field->kptr.btf, kptr_field->kptr.btf_id);

kernel/bpf/verifier.c

4555

if (btf_is_kernel(reg->btf)) {

kernel/bpf/verifier.c

4571

reg_name = btf_type_name(reg->btf, reg->btf_id);

kernel/bpf/verifier.c

4606

if (!btf_struct_ids_match(&env->log, reg->btf, reg->btf_id, reg->var_off.value,

kernel/bpf/verifier.c

4607

kptr_field->kptr.btf, kptr_field->kptr.btf_id,

kernel/bpf/verifier.c

4655

static bool rcu_protected_object(const struct btf *btf, u32 btf_id)

kernel/bpf/verifier.c

4657

if (!btf_is_kernel(btf))

kernel/bpf/verifier.c

4666

if (btf_is_kernel(kptr_field->kptr.btf))

kernel/bpf/verifier.c

4669

meta = btf_find_struct_meta(kptr_field->kptr.btf,

kernel/bpf/verifier.c

4680

(field->type == BPF_KPTR_REF && rcu_protected_object(kptr->btf, kptr->btf_id));

kernel/bpf/verifier.c

4693

else if (!btf_is_kernel(kptr_field->kptr.btf))

kernel/bpf/verifier.c

4712

t = btf_type_by_id(field->kptr.btf, field->kptr.btf_id);

kernel/bpf/verifier.c

4764

kptr_field->kptr.btf, kptr_field->kptr.btf_id,

kernel/bpf/verifier.c

5986

const struct btf_type *t = btf_type_by_id(reg->btf, reg->btf_id);

kernel/bpf/verifier.c

5987

const char *tname = btf_name_by_offset(reg->btf, t->name_off);

kernel/bpf/verifier.c

5999

if (!env->prog->gpl_compatible && btf_is_kernel(reg->btf)) {

kernel/bpf/verifier.c

6040

if (!btf_is_kernel(reg->btf)) {

kernel/bpf/verifier.c

6128

ret = mark_btf_ld_reg(env, regs, value_regno, ret, reg->btf, btf_id, flag);

kernel/bpf/verifier.c

6476

regs[value_regno].btf = info.btf;

kernel/bpf/verifier.c

7199

struct btf *btf = NULL;

kernel/bpf/verifier.c

7212

if (!map->btf) {

kernel/bpf/verifier.c

7219

btf = reg->btf;

kernel/bpf/verifier.c

7241

ptr = btf;

kernel/bpf/verifier.c

7274

ptr = btf;

kernel/bpf/verifier.c

7323

if (!map->btf) {

kernel/bpf/verifier.c

7395

if (!map_ptr->btf) {

kernel/bpf/verifier.c

7568

return btf_param_match_suffix(meta->btf, arg, "__iter");

kernel/bpf/verifier.c

7589

btf_id = btf_check_iter_arg(meta->btf, meta->func_proto, regno - 1);

kernel/bpf/verifier.c

7594

t = btf_type_by_id(meta->btf, btf_id);

kernel/bpf/verifier.c

7601

iter_type_str(meta->btf, btf_id), regno - 1);

kernel/bpf/verifier.c

7612

err = mark_stack_slots_iter(env, meta, reg, insn_idx, meta->btf, btf_id, nr_slots);

kernel/bpf/verifier.c

7619

err = is_iter_reg_valid_init(env, reg, meta->btf, btf_id, nr_slots);

kernel/bpf/verifier.c

7625

iter_type_str(meta->btf, btf_id), regno - 1);

kernel/bpf/verifier.c

8160

if (!btf_struct_ids_match(&env->log, reg->btf, reg->btf_id,

kernel/bpf/verifier.c

8164

regno, btf_type_name(reg->btf, reg->btf_id),

kernel/bpf/verifier.c

8658

meta->ret_btf = reg->btf;

kernel/bpf/verifier.c

9305

const struct btf *btf,

kernel/bpf/verifier.c

940

struct btf *btf, u32 btf_id, int nr_slots)

kernel/bpf/verifier.c

9409

struct btf *btf = prog->aux->btf;

kernel/bpf/verifier.c

9423

err = btf_check_func_arg_match(env, subprog, btf, regs);

kernel/bpf/verifier.c

966

st->iter.btf = btf;

kernel/bpf/verifier.c

9714

callee->regs[BPF_REG_2].btf = btf_vmlinux;

kernel/sched/ext.c

7205

t = btf_type_by_id(reg->btf, reg->btf_id);

kernel/sched/ext.c

7357

static int bpf_scx_init(struct btf *btf)

kernel/sched/ext.c

7359

task_struct_type = btf_type_by_id(btf, btf_tracing_ids[BTF_TRACING_TYPE_TASK]);

kernel/trace/bpf_trace.c

1009

const struct btf *btf;

kernel/trace/bpf_trace.c

1013

ret = bpf_btf_printf_prepare(ptr, btf_ptr_size, flags, &btf, &btf_id);

kernel/trace/bpf_trace.c

1017

return btf_type_snprintf_show(btf, btf_id, ptr->ptr, str, str_size,

kernel/trace/bpf_trace.c

514

const struct btf *btf;

kernel/trace/bpf_trace.c

518

ret = bpf_btf_printf_prepare(ptr, btf_ptr_size, flags, &btf, &btf_id);

kernel/trace/bpf_trace.c

522

return btf_type_seq_show_flags(btf, btf_id, ptr->ptr, m, flags);

kernel/trace/bpf_trace.c

87

u64 flags, const struct btf **btf,

kernel/trace/bpf_trace.c

977

u64 flags, const struct btf **btf,

kernel/trace/bpf_trace.c

988

*btf = bpf_get_btf_vmlinux();

kernel/trace/bpf_trace.c

990

if (IS_ERR_OR_NULL(*btf))

kernel/trace/bpf_trace.c

991

return IS_ERR(*btf) ? PTR_ERR(*btf) : -EINVAL;

kernel/trace/bpf_trace.c

999

t = btf_type_by_id(*btf, *btf_id);

kernel/trace/trace_btf.c

101

name = btf_name_by_offset(btf, member->name_off);

kernel/trace/trace_btf.c

113

type = btf_type_by_id(btf, tid);

kernel/trace/trace_btf.c

13

const struct btf_type *btf_find_func_proto(const char *func_name, struct btf **btf_p)

kernel/trace/trace_btf.c

70

const struct btf_member *btf_find_struct_member(struct btf *btf,

kernel/trace/trace_btf.c

94

if (btf_type_skip_modifiers(btf, member->type, &tid) &&

kernel/trace/trace_btf.h

5

struct btf **btf_p);

kernel/trace/trace_btf.h

8

const struct btf_member *btf_find_struct_member(struct btf *btf,

kernel/trace/trace_output.c

730

struct btf *btf;

kernel/trace/trace_output.c

743

t = btf_find_func_proto(name, &btf);

kernel/trace/trace_output.c

763

param_name = btf_name_by_offset(btf, param[p].name_off);

kernel/trace/trace_output.c

766

t = btf_type_skip_modifiers(btf, param[p].type, &tid);

kernel/trace/trace_output.c

790

btf_name_by_offset(btf,

kernel/trace/trace_output.c

812

btf_put(btf);

kernel/trace/trace_probe.c

1708

name = btf_name_by_offset(ctx->btf, ctx->params[idx].name_off);

kernel/trace/trace_probe.c

342

static bool btf_type_is_char_ptr(struct btf *btf, const struct btf_type *type)

kernel/trace/trace_probe.c

348

real_type = btf_type_skip_modifiers(btf, type->type, &tid);

kernel/trace/trace_probe.c

360

static bool btf_type_is_char_array(struct btf *btf, const struct btf_type *type)

kernel/trace/trace_probe.c

372

real_type = btf_type_skip_modifiers(btf, array->type, &tid);

kernel/trace/trace_probe.c

383

struct btf *btf = ctx->btf;

kernel/trace/trace_probe.c

385

if (!btf || !ctx->last_type)

kernel/trace/trace_probe.c

389

if (btf_type_is_char_array(btf, ctx->last_type))

kernel/trace/trace_probe.c

393

if (btf_type_is_char_ptr(btf, ctx->last_type)) {

kernel/trace/trace_probe.c

413

static const char *fetch_type_from_btf_type(struct btf *btf,

kernel/trace/trace_probe.c

471

struct btf *btf;

kernel/trace/trace_probe.c

474

if (ctx->btf)

kernel/trace/trace_probe.c

480

type = btf_find_func_proto(ctx->funcname, &btf);

kernel/trace/trace_probe.c

484

ctx->btf = btf;

kernel/trace/trace_probe.c

511

if (ctx->btf) {

kernel/trace/trace_probe.c

512

btf_put(ctx->btf);

kernel/trace/trace_probe.c

513

ctx->btf = NULL;

kernel/trace/trace_probe.c

568

type = btf_type_skip_modifiers(ctx->btf, type->type, &tid);

kernel/trace/trace_probe.c

583

field = btf_find_struct_member(ctx->btf, type, fieldname,

kernel/trace/trace_probe.c

605

type = btf_type_skip_modifiers(ctx->btf, field->type, &tid);

kernel/trace/trace_probe.c

675

if (!ctx->btf) {

kernel/trace/trace_probe.c

685

const char *name = btf_name_by_offset(ctx->btf, params[i].name_off);

kernel/trace/trace_probe.c

711

type = btf_type_skip_modifiers(ctx->btf, tid, &tid);

kernel/trace/trace_probe.c

730

struct btf *btf = ctx->btf;

kernel/trace/trace_probe.c

733

if (btf && ctx->last_type)

kernel/trace/trace_probe.c

734

typestr = fetch_type_from_btf_type(btf, ctx->last_type, ctx);

kernel/trace/trace_probe.c

764

ctx->btf = NULL;

kernel/trace/trace_probe.h

423

struct btf *btf; /* The BTF to be used */

net/bpf/bpf_dummy_struct_ops.c

205

static int bpf_dummy_init(struct btf *btf)

net/bpf/bpf_dummy_struct_ops.c

207

bpf_dummy_ops_btf = btf;

net/bpf/bpf_dummy_struct_ops.c

244

type_id = btf_find_by_name_kind(reg->btf, "bpf_dummy_ops_state",

net/bpf/bpf_dummy_struct_ops.c

249

t = btf_type_by_id(reg->btf, reg->btf_id);

net/bpf/bpf_dummy_struct_ops.c

25

static struct btf *bpf_dummy_ops_btf;

net/bpf/bpf_dummy_struct_ops.c

250

state = btf_type_by_id(reg->btf, type_id);

net/ipv4/bpf_tcp_ca.c

21

static int bpf_tcp_ca_init(struct btf *btf)

net/ipv4/bpf_tcp_ca.c

25

type_id = btf_find_by_name_kind(btf, "sock", BTF_KIND_STRUCT);

net/ipv4/bpf_tcp_ca.c

30

type_id = btf_find_by_name_kind(btf, "tcp_sock", BTF_KIND_STRUCT);

net/ipv4/bpf_tcp_ca.c

34

tcp_sock_type = btf_type_by_id(btf, tcp_sock_id);

net/ipv4/bpf_tcp_ca.c

36

type_id = btf_find_by_name_kind(btf, "tcp_congestion_ops", BTF_KIND_STRUCT);

net/ipv4/bpf_tcp_ca.c

39

tcp_congestion_ops_type = btf_type_by_id(btf, type_id);

net/ipv4/bpf_tcp_ca.c

68

t = btf_type_by_id(reg->btf, reg->btf_id);

net/netfilter/nf_bpf_link.c

275

struct btf *btf;

net/netfilter/nf_bpf_link.c

278

btf = bpf_get_btf_vmlinux();

net/netfilter/nf_bpf_link.c

279

if (IS_ERR_OR_NULL(btf))

net/netfilter/nf_bpf_link.c

282

type_id = btf_find_by_name_kind(btf, name, BTF_KIND_STRUCT);

net/netfilter/nf_bpf_link.c

286

info->btf = btf;

net/netfilter/nf_conntrack_bpf.c

242

ncit = btf_type_by_id(reg->btf, btf_nf_conn_ids[1]);

net/netfilter/nf_conntrack_bpf.c

243

nct = btf_type_by_id(reg->btf, btf_nf_conn_ids[0]);

net/netfilter/nf_conntrack_bpf.c

244

t = btf_type_by_id(reg->btf, reg->btf_id);

net/sched/bpf_qdisc.c

104

skbt = btf_type_by_id(reg->btf, bpf_sk_buff_ids[0]);

net/sched/bpf_qdisc.c

105

qdisct = btf_type_by_id(reg->btf, bpf_qdisc_ids[0]);

net/sched/bpf_qdisc.c

106

t = btf_type_by_id(reg->btf, reg->btf_id);

net/sched/bpf_qdisc.c

119

btf_name_by_offset(reg->btf, t->name_off), off);

net/sched/bpf_qdisc.c

126

off, size, btf_name_by_offset(reg->btf, t->name_off), end);

net/sched/bpf_qdisc.c

24

static int bpf_qdisc_init(struct btf *btf)

net/sched/bpf_qdisc.c

38

struct btf *btf = prog->aux->attach_btf;

net/sched/bpf_qdisc.c

41

arg = btf_ctx_arg_idx(btf, prog->aux->attach_func_proto, off);

net/sched/bpf_qdisc.c

45

info->btf = btf;

net/smc/smc_hs_bpf.c

70

static int smc_bpf_hs_ctrl_init(struct btf *btf) { return 0; }

tools/bpf/bpftool/btf.c

1001

struct btf *vmlinux_base = base_btf;

tools/bpf/bpftool/btf.c

1052

btf = btf__parse_split(files[0], base ?: base_btf);

tools/bpf/bpftool/btf.c

1053

if (!btf) {

tools/bpf/bpftool/btf.c

1065

btf = merge_btf_files(files, nr_files, vmlinux_base);

tools/bpf/bpftool/btf.c

1066

if (!btf) {

tools/bpf/bpftool/btf.c

108

static const char *btf_str(const struct btf *btf, __u32 off)

tools/bpf/bpftool/btf.c

112

return btf__name_by_offset(btf, off) ? : "(invalid)";

tools/bpf/bpftool/btf.c

1138

if (!btf) {

tools/bpf/bpftool/btf.c

1145

btf = btf__load_from_kernel_by_id_split(btf_id, base_btf);

tools/bpf/bpftool/btf.c

1146

if (!btf) {

tools/bpf/bpftool/btf.c

1157

if (root_type_ids[i] >= btf__type_cnt(btf)) {

tools/bpf/bpftool/btf.c

1170

err = dump_btf_c(btf, root_type_ids, root_type_cnt, sort_dump_c);

tools/bpf/bpftool/btf.c

1172

err = dump_btf_raw(btf, root_type_ids, root_type_cnt);

tools/bpf/bpftool/btf.c

1177

btf__free(btf);

tools/bpf/bpftool/btf.c

120

static int dump_btf_type(const struct btf *btf, __u32 id,

tools/bpf/bpftool/btf.c

130

jsonw_string_field(w, "name", btf_str(btf, t->name_off));

tools/bpf/bpftool/btf.c

133

btf_str(btf, t->name_off));

tools/bpf/bpftool/btf.c

194

const char *name = btf_str(btf, m->name_off);

tools/bpf/bpftool/btf.c

243

const char *name = btf_str(btf, v->name_off);

tools/bpf/bpftool/btf.c

281

const char *name = btf_str(btf, v->name_off);

tools/bpf/bpftool/btf.c

340

const char *name = btf_str(btf, p->name_off);

tools/bpf/bpftool/btf.c

394

if (v->type < btf__type_cnt(btf)) {

tools/bpf/bpftool/btf.c

395

vt = btf__type_by_id(btf, v->type);

tools/bpf/bpftool/btf.c

398

btf_str(btf, vt->name_off));

tools/bpf/bpftool/btf.c

436

static int dump_btf_raw(const struct btf *btf,

tools/bpf/bpftool/btf.c

450

t = btf__type_by_id(btf, root_type_ids[i]);

tools/bpf/bpftool/btf.c

451

dump_btf_type(btf, root_type_ids[i], t);

tools/bpf/bpftool/btf.c

454

const struct btf *base;

tools/bpf/bpftool/btf.c

455

int cnt = btf__type_cnt(btf);

tools/bpf/bpftool/btf.c

458

base = btf__base_btf(btf);

tools/bpf/bpftool/btf.c

463

t = btf__type_by_id(btf, i);

tools/bpf/bpftool/btf.c

464

dump_btf_type(btf, i, t);

tools/bpf/bpftool/btf.c

505

struct btf *btf = ctx;

tools/bpf/bpftool/btf.c

509

return strcmp(btf__str_by_offset(btf, a->name_off),

tools/bpf/bpftool/btf.c

510

btf__str_by_offset(btf, b->name_off));

tools/bpf/bpftool/btf.c

513

static int dump_btf_kfuncs(struct btf_dump *d, const struct btf *btf)

tools/bpf/bpftool/btf.c

516

__u32 cnt = btf__type_cnt(btf), i, j;

tools/bpf/bpftool/btf.c

525

const struct btf_type *t = btf__type_by_id(btf, i);

tools/bpf/bpftool/btf.c

535

ft = btf__type_by_id(btf, t->type);

tools/bpf/bpftool/btf.c

539

name = btf__name_by_offset(btf, t->name_off);

tools/bpf/bpftool/btf.c

554

qsort_r(kfuncs.elems, kfuncs.cnt, sizeof(*kfuncs.elems), cmp_kfuncs, (void *)btf);

tools/bpf/bpftool/btf.c

568

opts.field_name = btf__name_by_offset(btf, t->name_off);

tools/bpf/bpftool/btf.c

590

static int btf_type_rank(const struct btf *btf, __u32 index, bool has_name)

tools/bpf/bpftool/btf.c

592

const struct btf_type *t = btf__type_by_id(btf, index);

tools/bpf/bpftool/btf.c

613

return btf_type_rank(btf, btf_array(t)->type, has_name);

tools/bpf/bpftool/btf.c

623

return btf_type_rank(btf, t->type, has_name);

tools/bpf/bpftool/btf.c

630

static const char *btf_type_sort_name(const struct btf *btf, __u32 index, bool from_ref)

tools/bpf/bpftool/btf.c

632

const struct btf_type *t = btf__type_by_id(btf, index);

tools/bpf/bpftool/btf.c

644

return btf__name_by_offset(btf, name_off);

tools/bpf/bpftool/btf.c

647

return btf_type_sort_name(btf, btf_array(t)->type, true);

tools/bpf/bpftool/btf.c

655

return btf_type_sort_name(btf, t->type, true);

tools/bpf/bpftool/btf.c

657

return btf__name_by_offset(btf, t->name_off);

tools/bpf/bpftool/btf.c

667

static __u64 btf_name_hasher(__u64 hash, const struct btf *btf, __u32 name_off)

tools/bpf/bpftool/btf.c

672

return hasher(hash, str_hash(btf__name_by_offset(btf, name_off)));

tools/bpf/bpftool/btf.c

675

static __u64 btf_type_disambig_hash(const struct btf *btf, __u32 id, bool include_members)

tools/bpf/bpftool/btf.c

677

const struct btf_type *t = btf__type_by_id(btf, id);

tools/bpf/bpftool/btf.c

681

hash = btf_name_hasher(hash, btf, t->name_off);

tools/bpf/bpftool/btf.c

691

hash = btf_name_hasher(hash, btf, name_off);

tools/bpf/bpftool/btf.c

701

hash = btf_name_hasher(hash, btf, m->name_off);

tools/bpf/bpftool/btf.c

703

hash = hasher(hash, btf_type_disambig_hash(btf, m->type, false));

tools/bpf/bpftool/btf.c

713

hash = hasher(hash, btf_type_disambig_hash(btf, t->type, include_members));

tools/bpf/bpftool/btf.c

719

hash = hasher(hash, btf_type_disambig_hash(btf, arr->type, include_members));

tools/bpf/bpftool/btf.c

746

static struct sort_datum *sort_btf_c(const struct btf *btf)

tools/bpf/bpftool/btf.c

751

n = btf__type_cnt(btf);

tools/bpf/bpftool/btf.c

758

const struct btf_type *t = btf__type_by_id(btf, i);

tools/bpf/bpftool/btf.c

761

d->type_rank = btf_type_rank(btf, i, false);

tools/bpf/bpftool/btf.c

762

d->sort_name = btf_type_sort_name(btf, i, false);

tools/bpf/bpftool/btf.c

763

d->own_name = btf__name_by_offset(btf, t->name_off);

tools/bpf/bpftool/btf.c

764

d->disambig_hash = btf_type_disambig_hash(btf, i, true);

tools/bpf/bpftool/btf.c

772

static int dump_btf_c(const struct btf *btf,

tools/bpf/bpftool/btf.c

779

d = btf_dump__new(btf, btf_dump_printf, NULL, NULL);

tools/bpf/bpftool/btf.c

810

int cnt = btf__type_cnt(btf);

tools/bpf/bpftool/btf.c

813

datums = sort_btf_c(btf);

tools/bpf/bpftool/btf.c

822

err = dump_btf_kfuncs(d, btf);

tools/bpf/bpftool/btf.c

841

static struct btf *get_vmlinux_btf_from_sysfs(void)

tools/bpf/bpftool/btf.c

843

struct btf *base;

tools/bpf/bpftool/btf.c

882

static struct btf *merge_btf_files(const char **files, int nr_files,

tools/bpf/bpftool/btf.c

883

struct btf *vmlinux_base)

tools/bpf/bpftool/btf.c

885

struct btf *combined, *mod;

tools/bpf/bpftool/btf.c

924

struct btf *btf = NULL, *base = NULL;

tools/bpf/bpftool/btf_dumper.c

118

ptr_type_id = btf__resolve_type(d->btf, t->type);

tools/bpf/bpftool/btf_dumper.c

121

ptr_type = btf__type_by_id(d->btf, ptr_type_id);

tools/bpf/bpftool/btf_dumper.c

140

actual_type_id = btf__resolve_type(d->btf, type_id);

tools/bpf/bpftool/btf_dumper.c

175

btf__name_by_offset(d->btf,

tools/bpf/bpftool/btf_dumper.c

201

btf__name_by_offset(d->btf,

tools/bpf/bpftool/btf_dumper.c

211

static bool is_str_array(const struct btf *btf, const struct btf_array *arr,

tools/bpf/bpftool/btf_dumper.c

220

elem_type = btf__type_by_id(btf, arr->type);

tools/bpf/bpftool/btf_dumper.c

225

elem_type = btf__type_by_id(btf, elem_type->type);

tools/bpf/bpftool/btf_dumper.c

231

strcmp("char", btf__name_by_offset(btf, elem_type->name_off)))

tools/bpf/bpftool/btf_dumper.c

250

const struct btf_type *t = btf__type_by_id(d->btf, type_id);

tools/bpf/bpftool/btf_dumper.c

256

if (is_str_array(d->btf, arr, data)) {

tools/bpf/bpftool/btf_dumper.c

261

elem_size = btf__resolve_size(d->btf, arr->type);

tools/bpf/bpftool/btf_dumper.c

27

static int btf_dump_func(const struct btf *btf, char *func_sig,

tools/bpf/bpftool/btf_dumper.c

40

struct btf *prog_btf = NULL;

tools/bpf/bpftool/btf_dumper.c

47

func_sig_len = btf_dump_func(d->btf, prog_str, func_proto, NULL, 0,

tools/bpf/bpftool/btf_dumper.c

475

t = btf__type_by_id(d->btf, type_id);

tools/bpf/bpftool/btf_dumper.c

493

jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));

tools/bpf/bpftool/btf_dumper.c

516

const struct btf_type *t = btf__type_by_id(d->btf, type_id);

tools/bpf/bpftool/btf_dumper.c

520

jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

534

t = btf__type_by_id(d->btf, type_id);

tools/bpf/bpftool/btf_dumper.c

542

jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

558

const struct btf_type *t = btf__type_by_id(d->btf, type_id);

tools/bpf/bpftool/btf_dumper.c

613

pos = __btf_dumper_type_only(btf, type, func_sig, \

tools/bpf/bpftool/btf_dumper.c

619

static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,

tools/bpf/bpftool/btf_dumper.c

632

t = btf__type_by_id(btf, type_id);

tools/bpf/bpftool/btf_dumper.c

638

BTF_PRINT_ARG("%s ", btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

642

btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

646

btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

651

btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

665

btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

680

pos = btf_dump_func(btf, func_sig, t, NULL, pos, size);

tools/bpf/bpftool/btf_dumper.c

685

proto_type = btf__type_by_id(btf, t->type);

tools/bpf/bpftool/btf_dumper.c

686

pos = btf_dump_func(btf, func_sig, proto_type, t, pos, size);

tools/bpf/bpftool/btf_dumper.c

696

btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

700

btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/btf_dumper.c

710

static int btf_dump_func(const struct btf *btf, char *func_sig,

tools/bpf/bpftool/btf_dumper.c

718

BTF_PRINT_ARG("%s(", btf__name_by_offset(btf, func->name_off));

tools/bpf/bpftool/btf_dumper.c

731

btf__name_by_offset(btf, arg->name_off));

tools/bpf/bpftool/btf_dumper.c

747

void btf_dumper_type_only(const struct btf *btf, __u32 type_id, char *func_sig,

tools/bpf/bpftool/btf_dumper.c

753

if (!btf)

tools/bpf/bpftool/btf_dumper.c

756

err = __btf_dumper_type_only(btf, type_id, func_sig, 0, size);

tools/bpf/bpftool/btf_dumper.c

769

void btf_dump_linfo_plain(const struct btf *btf,

tools/bpf/bpftool/btf_dumper.c

773

const char *line = btf__name_by_offset(btf, linfo->line_off);

tools/bpf/bpftool/btf_dumper.c

783

const char *file = btf__name_by_offset(btf, linfo->file_name_off);

tools/bpf/bpftool/btf_dumper.c

801

void btf_dump_linfo_json(const struct btf *btf,

tools/bpf/bpftool/btf_dumper.c

804

const char *line = btf__name_by_offset(btf, linfo->line_off);

tools/bpf/bpftool/btf_dumper.c

810

const char *file = btf__name_by_offset(btf, linfo->file_name_off);

tools/bpf/bpftool/btf_dumper.c

874

void btf_dump_linfo_dotlabel(const struct btf *btf,

tools/bpf/bpftool/btf_dumper.c

877

const char *line = btf__name_by_offset(btf, linfo->line_off);

tools/bpf/bpftool/btf_dumper.c

884

const char *file = btf__name_by_offset(btf, linfo->file_name_off);

tools/bpf/bpftool/cgroup.c

78

static struct btf *btf_vmlinux;

tools/bpf/bpftool/common.c

421

struct btf *prog_btf = NULL;

tools/bpf/bpftool/gen.c

1015

static int walk_st_ops_shadow_vars(struct btf *btf, const char *ident,

tools/bpf/bpftool/gen.c

1028

d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);

tools/bpf/bpftool/gen.c

1034

member_type = skip_mods_and_typedefs(btf, m->type, &member_type_id);

tools/bpf/bpftool/gen.c

1035

member_name = btf__name_by_offset(btf, m->name_off);

tools/bpf/bpftool/gen.c

1056

size = btf__resolve_size(btf, member_type_id);

tools/bpf/bpftool/gen.c

1067

if (resolve_func_ptr(btf, m->type, NULL)) {

tools/bpf/bpftool/gen.c

1091

size = btf__resolve_size(btf, member_type_id);

tools/bpf/bpftool/gen.c

1105

size = btf__resolve_size(btf, map_type_id);

tools/bpf/bpftool/gen.c

1130

static int gen_st_ops_shadow_type(const char *obj_name, struct btf *btf, const char *ident,

tools/bpf/bpftool/gen.c

1141

map_type = btf__type_by_id(btf, map_type_id);

tools/bpf/bpftool/gen.c

1145

type_name = btf__name_by_offset(btf, map_type->name_off);

tools/bpf/bpftool/gen.c

1149

err = walk_st_ops_shadow_vars(btf, ident, map_type, map_type_id);

tools/bpf/bpftool/gen.c

1158

static int gen_st_ops_shadow(const char *obj_name, struct btf *btf, struct bpf_object *obj)

tools/bpf/bpftool/gen.c

1164

if (!btf)

tools/bpf/bpftool/gen.c

1180

err = gen_st_ops_shadow_type(obj_name, btf, ident, map);

tools/bpf/bpftool/gen.c

1192

static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)

tools/bpf/bpftool/gen.c

1197

if (!btf)

tools/bpf/bpftool/gen.c

1229

struct btf *btf;

tools/bpf/bpftool/gen.c

1366

btf = bpf_object__btf(obj);

tools/bpf/bpftool/gen.c

1367

err = gen_st_ops_shadow(obj_name, btf, obj);

tools/bpf/bpftool/gen.c

1417

if (btf) {

tools/bpf/bpftool/gen.c

1476

gen_st_ops_shadow_init(btf, obj);

tools/bpf/bpftool/gen.c

148

struct btf *btf,

tools/bpf/bpftool/gen.c

153

const char *sec_name = btf__name_by_offset(btf, sec->name_off);

tools/bpf/bpftool/gen.c

1642

struct btf *btf;

tools/bpf/bpftool/gen.c

167

const struct btf_type *var = btf__type_by_id(btf, sec_var->type);

tools/bpf/bpftool/gen.c

168

const char *var_name = btf__name_by_offset(btf, var->name_off);

tools/bpf/bpftool/gen.c

1719

btf = bpf_object__btf(obj);

tools/bpf/bpftool/gen.c

1720

if (!btf) {

tools/bpf/bpftool/gen.c

1749

map_type = btf__type_by_id(btf, map_type_id);

tools/bpf/bpftool/gen.c

1754

var_type = btf__type_by_id(btf, var->type);

tools/bpf/bpftool/gen.c

1791

err = gen_st_ops_shadow(obj_name, btf, obj);

tools/bpf/bpftool/gen.c

187

align = btf__align_of(btf, var->type);

tools/bpf/bpftool/gen.c

1872

map_type = btf__type_by_id(btf, map_type_id);

tools/bpf/bpftool/gen.c

1876

var_type = btf__type_by_id(btf, var->type);

tools/bpf/bpftool/gen.c

1877

var_name = btf__name_by_offset(btf, var_type->name_off);

tools/bpf/bpftool/gen.c

1909

gen_st_ops_shadow_init(btf, obj);

tools/bpf/bpftool/gen.c

2000

static int btf_save_raw(const struct btf *btf, const char *path)

tools/bpf/bpftool/gen.c

2007

data = btf__raw_data(btf, &data_sz);

tools/bpf/bpftool/gen.c

2023

struct btf *src_btf;

tools/bpf/bpftool/gen.c

2024

struct btf *marked_btf; /* btf structure used to mark used types */

tools/bpf/bpftool/gen.c

2167

struct btf *btf = info->src_btf;

tools/bpf/bpftool/gen.c

2175

btf_type = btf__type_by_id(btf, type_id);

tools/bpf/bpftool/gen.c

2185

btf_type = btf__type_by_id(btf, type_id);

tools/bpf/bpftool/gen.c

2199

btf_type = btf__type_by_id(btf, type_id);

tools/bpf/bpftool/gen.c

2207

btf_type = btf__type_by_id(btf, type_id);

tools/bpf/bpftool/gen.c

2230

struct btf *btf = info->src_btf;

tools/bpf/bpftool/gen.c

2237

btf_type = btf__type_by_id(btf, type_id);

tools/bpf/bpftool/gen.c

235

static const struct btf_type *find_type_for_map(struct btf *btf, const char *map_ident)

tools/bpf/bpftool/gen.c

2362

btfgen_find_cands(const struct btf *local_btf, const struct btf *targ_btf, __u32 local_id)

tools/bpf/bpftool/gen.c

237

int n = btf__type_cnt(btf), i;

tools/bpf/bpftool/gen.c

2371

local_cand.btf = local_btf;

tools/bpf/bpftool/gen.c

241

const struct btf_type *t = btf__type_by_id(btf, i);

tools/bpf/bpftool/gen.c

2413

struct btf *btf = NULL;

tools/bpf/bpftool/gen.c

2417

btf = btf__parse(obj_path, &btf_ext);

tools/bpf/bpftool/gen.c

2418

if (!btf) {

tools/bpf/bpftool/gen.c

2448

const char *sec_name = btf__name_by_offset(btf, sec->sec_name_off);

tools/bpf/bpftool/gen.c

2452

cands = btfgen_find_cands(btf, info->src_btf, relo->type_id);

tools/bpf/bpftool/gen.c

2464

err = bpf_core_calc_relo_insn(sec_name, relo, relo_idx, btf, cands,

tools/bpf/bpftool/gen.c

247

name = btf__str_by_offset(btf, t->name_off);

tools/bpf/bpftool/gen.c

2477

btf__free(btf);

tools/bpf/bpftool/gen.c

2491

static struct btf *btfgen_get_btf(struct btfgen_info *info)

tools/bpf/bpftool/gen.c

2493

struct btf *btf_new = NULL;

tools/bpf/bpftool/gen.c

2616

struct btf *btf_new = NULL;

tools/bpf/bpftool/gen.c

277

struct btf *btf = bpf_object__btf(obj);

tools/bpf/bpftool/gen.c

284

d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);

tools/bpf/bpftool/gen.c

293

sec = find_type_for_map(btf, map_ident);

tools/bpf/bpftool/gen.c

306

err = codegen_datasec_def(obj, btf, d, sec, obj_name);

tools/bpf/bpftool/gen.c

318

static bool btf_is_ptr_to_func_proto(const struct btf *btf,

tools/bpf/bpftool/gen.c

321

return btf_is_ptr(v) && btf_is_func_proto(btf__type_by_id(btf, v->type));

tools/bpf/bpftool/gen.c

326

struct btf *btf = bpf_object__btf(obj);

tools/bpf/bpftool/gen.c

337

d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);

tools/bpf/bpftool/gen.c

346

sec = find_type_for_map(btf, map_ident);

tools/bpf/bpftool/gen.c

350

sec_name = btf__name_by_offset(btf, sec->name_off);

tools/bpf/bpftool/gen.c

367

var = btf__type_by_id(btf, sec_var->type);

tools/bpf/bpftool/gen.c

368

var_name = btf__name_by_offset(btf, var->name_off);

tools/bpf/bpftool/gen.c

378

var = skip_mods_and_typedefs(btf, var->type, NULL);

tools/bpf/bpftool/gen.c

387

needs_typeof = btf_is_array(var) || btf_is_ptr_to_func_proto(btf, var);

tools/bpf/bpftool/gen.c

499

struct btf *btf = bpf_object__btf(obj);

tools/bpf/bpftool/gen.c

506

if (!btf)

tools/bpf/bpftool/gen.c

523

sec = find_type_for_map(btf, map_ident);

tools/bpf/bpftool/gen.c

533

const struct btf_type *var = btf__type_by_id(btf, sec_var->type);

tools/bpf/bpftool/gen.c

534

const char *var_name = btf__name_by_offset(btf, var->name_off);

tools/bpf/bpftool/gen.c

541

var_size = btf__resolve_size(btf, var->type);

tools/bpf/bpftool/gen.c

59

resolve_func_ptr(const struct btf *btf, __u32 id, __u32 *res_id)

tools/bpf/bpftool/gen.c

63

t = skip_mods_and_typedefs(btf, id, NULL);

tools/bpf/bpftool/gen.c

67

t = skip_mods_and_typedefs(btf, t->type, res_id);

tools/bpf/bpftool/jit_disasm.c

348

const struct btf *btf,

tools/bpf/bpftool/jit_disasm.c

381

btf_dump_linfo_json(btf, linfo, linum);

tools/bpf/bpftool/jit_disasm.c

386

btf_dump_linfo_plain(btf, linfo, "; ",

tools/bpf/bpftool/main.c

34

struct btf *base_btf;

tools/bpf/bpftool/main.h

122

struct btf;

tools/bpf/bpftool/main.h

192

const struct btf *btf,

tools/bpf/bpftool/main.h

201

const struct btf *btf,

tools/bpf/bpftool/main.h

223

const struct btf *btf;

tools/bpf/bpftool/main.h

238

void btf_dumper_type_only(const struct btf *btf, __u32 func_type_id,

tools/bpf/bpftool/main.h

241

void btf_dump_linfo_plain(const struct btf *btf,

tools/bpf/bpftool/main.h

244

void btf_dump_linfo_json(const struct btf *btf,

tools/bpf/bpftool/main.h

246

void btf_dump_linfo_dotlabel(const struct btf *btf,

tools/bpf/bpftool/main.h

92

extern struct btf *base_btf;

tools/bpf/bpftool/map.c

1038

struct btf *btf;

tools/bpf/bpftool/map.c

1040

if (get_map_kv_btf(info, &btf))

tools/bpf/bpftool/map.c

1044

print_entry_json(info, key, value, btf);

tools/bpf/bpftool/map.c

1045

} else if (btf) {

tools/bpf/bpftool/map.c

1052

btf__free(btf);

tools/bpf/bpftool/map.c

1053

btf = NULL;

tools/bpf/bpftool/map.c

1057

.btf = btf,

tools/bpf/bpftool/map.c

1068

btf__free(btf);

tools/bpf/bpftool/map.c

133

unsigned char *value, struct btf *btf)

tools/bpf/bpftool/map.c

145

if (btf) {

tools/bpf/bpftool/map.c

147

.btf = btf,

tools/bpf/bpftool/map.c

178

if (btf) {

tools/bpf/bpftool/map.c

180

.btf = btf,

tools/bpf/bpftool/map.c

746

struct bpf_map_info *map_info, struct btf *btf,

tools/bpf/bpftool/map.c

755

print_entry_json(map_info, key, value, btf);

tools/bpf/bpftool/map.c

756

} else if (btf) {

tools/bpf/bpftool/map.c

758

.btf = btf,

tools/bpf/bpftool/map.c

791

static struct btf *btf_vmlinux;

tools/bpf/bpftool/map.c

793

static int get_map_kv_btf(const struct bpf_map_info *info, struct btf **btf)

tools/bpf/bpftool/map.c

805

*btf = btf_vmlinux;

tools/bpf/bpftool/map.c

807

*btf = btf__load_from_kernel_by_id(info->btf_id);

tools/bpf/bpftool/map.c

808

if (!*btf) {

tools/bpf/bpftool/map.c

813

*btf = NULL;

tools/bpf/bpftool/map.c

819

static void free_map_kv_btf(struct btf *btf)

tools/bpf/bpftool/map.c

821

if (btf != btf_vmlinux)

tools/bpf/bpftool/map.c

822

btf__free(btf);

tools/bpf/bpftool/map.c

831

struct btf *btf = NULL;

tools/bpf/bpftool/map.c

845

err = get_map_kv_btf(info, &btf);

tools/bpf/bpftool/map.c

875

if (!dump_map_elem(fd, key, value, info, btf, wtr))

tools/bpf/bpftool/map.c

893

free_map_kv_btf(btf);

tools/bpf/bpftool/prog.c

2297

struct btf *btf = NULL;

tools/bpf/bpftool/prog.c

2329

btf = btf__load_from_kernel_by_id(info.btf_id);

tools/bpf/bpftool/prog.c

2330

if (!btf) {

tools/bpf/bpftool/prog.c

2335

t = btf__type_by_id(btf, func_info.type_id);

tools/bpf/bpftool/prog.c

2341

name = strdup(btf__name_by_offset(btf, t->name_off));

tools/bpf/bpftool/prog.c

2343

btf__free(btf);

tools/bpf/bpftool/prog.c

314

struct btf *btf;

tools/bpf/bpftool/prog.c

325

btf = btf__load_from_kernel_by_id(map_info.btf_id);

tools/bpf/bpftool/prog.c

326

if (!btf)

tools/bpf/bpftool/prog.c

329

t_datasec = btf__type_by_id(btf, map_info.btf_value_type_id);

tools/bpf/bpftool/prog.c

342

.btf = btf,

tools/bpf/bpftool/prog.c

348

t_var = btf__type_by_id(btf, vsi->type);

tools/bpf/bpftool/prog.c

349

name = btf__name_by_offset(btf, t_var->name_off);

tools/bpf/bpftool/prog.c

372

.btf = btf,

tools/bpf/bpftool/prog.c

377

t_var = btf__type_by_id(btf, vsi->type);

tools/bpf/bpftool/prog.c

378

name = btf__name_by_offset(btf, t_var->name_off);

tools/bpf/bpftool/prog.c

410

btf__free(btf);

tools/bpf/bpftool/prog.c

709

struct btf *btf = NULL;

tools/bpf/bpftool/prog.c

733

btf = btf__load_from_kernel_by_id(info->btf_id);

tools/bpf/bpftool/prog.c

734

if (!btf) {

tools/bpf/bpftool/prog.c

806

btf_dumper_type_only(btf, record->type_id,

tools/bpf/bpftool/prog.c

828

name, disasm_opt, btf,

tools/bpf/bpftool/prog.c

834

name, disasm_opt, btf,

tools/bpf/bpftool/prog.c

851

disasm_opt, btf, NULL, 0, 0,

tools/bpf/bpftool/prog.c

859

dd.btf = btf;

tools/bpf/bpftool/prog.c

876

btf__free(btf);

tools/bpf/bpftool/skeleton/pid_iter.bpf.c

47

return BPF_CORE_READ((struct btf *)ent, id);

tools/bpf/bpftool/struct_ops.c

21

static struct btf *btf_vmlinux;

tools/bpf/bpftool/struct_ops.c

29

static const struct btf *get_btf_vmlinux(void)

tools/bpf/bpftool/struct_ops.c

361

const struct btf *kern_btf = d->btf;

tools/bpf/bpftool/struct_ops.c

368

kern_btf = d->btf;

tools/bpf/bpftool/struct_ops.c

409

const struct btf *kern_btf;

tools/bpf/bpftool/struct_ops.c

43

const struct btf *kern_btf;

tools/bpf/bpftool/struct_ops.c

434

d.btf = kern_btf;

tools/bpf/bpftool/struct_ops.c

60

const struct btf *kern_btf;

tools/bpf/bpftool/xlated_dumper.c

230

struct btf *btf = dd->btf;

tools/bpf/bpftool/xlated_dumper.c

247

if (btf && record) {

tools/bpf/bpftool/xlated_dumper.c

249

btf_dumper_type_only(btf, record->type_id,

tools/bpf/bpftool/xlated_dumper.c

265

btf_dump_linfo_json(btf, linfo, linum);

tools/bpf/bpftool/xlated_dumper.c

315

struct btf *btf = dd->btf;

tools/bpf/bpftool/xlated_dumper.c

328

if (btf && record) {

tools/bpf/bpftool/xlated_dumper.c

330

btf_dumper_type_only(btf, record->type_id,

tools/bpf/bpftool/xlated_dumper.c

344

btf_dump_linfo_plain(btf, linfo, "; ",

tools/bpf/bpftool/xlated_dumper.c

383

struct btf *btf = dd->btf;

tools/bpf/bpftool/xlated_dumper.c

397

if (btf && record) {

tools/bpf/bpftool/xlated_dumper.c

399

btf_dumper_type_only(btf, record->type_id,

tools/bpf/bpftool/xlated_dumper.c

413

btf_dump_linfo_dotlabel(btf, linfo, linum);

tools/bpf/bpftool/xlated_dumper.h

24

struct btf *btf;

tools/bpf/resolve_btfids/main.c

1006

t = btf__type_by_id(btf, ctx->decl_tags[i]);

tools/bpf/resolve_btfids/main.c

1010

tag_name = btf__name_by_offset(btf, t->name_off);

tools/bpf/resolve_btfids/main.c

1015

t = btf__type_by_id(btf, func_id);

tools/bpf/resolve_btfids/main.c

1019

func_name = btf__name_by_offset(btf, t->name_off);

tools/bpf/resolve_btfids/main.c

1045

ctx->btf = obj->btf;

tools/bpf/resolve_btfids/main.c

1064

static bool is_kf_implicit_arg(const struct btf *btf, const struct btf_param *p)

tools/bpf/resolve_btfids/main.c

1073

t = btf_type_skip_qualifiers(btf, p->type);

tools/bpf/resolve_btfids/main.c

1077

t = btf_type_skip_qualifiers(btf, t->type);

tools/bpf/resolve_btfids/main.c

1081

name = btf__name_by_offset(btf, t->name_off);

tools/bpf/resolve_btfids/main.c

1119

struct btf *btf = ctx->btf;

tools/bpf/resolve_btfids/main.c

1123

t = (struct btf_type *)btf__type_by_id(btf, kfunc->btf_id);

tools/bpf/resolve_btfids/main.c

1132

t = (struct btf_type *)btf__type_by_id(btf, proto_id);

tools/bpf/resolve_btfids/main.c

1144

if (btf__find_by_name_kind(btf, tmp_name, BTF_KIND_FUNC) > 0) {

tools/bpf/resolve_btfids/main.c

1150

new_func_id = btf__add_func(btf, tmp_name, linkage, proto_id);

tools/bpf/resolve_btfids/main.c

1158

t = (struct btf_type *)btf__type_by_id(btf, ctx->decl_tags[i]);

tools/bpf/resolve_btfids/main.c

1162

tag_name = btf__name_by_offset(btf, t->name_off);

tools/bpf/resolve_btfids/main.c

1169

err = btf__add_decl_attr(btf, tag_name, new_func_id, idx);

tools/bpf/resolve_btfids/main.c

1171

err = btf__add_decl_tag(btf, tag_name, new_func_id, idx);

tools/bpf/resolve_btfids/main.c

1181

t = (struct btf_type *)btf__type_by_id(btf, proto_id);

tools/bpf/resolve_btfids/main.c

1182

new_proto_id = btf__add_func_proto(btf, t->type);

tools/bpf/resolve_btfids/main.c

1189

t = (struct btf_type *)btf__type_by_id(btf, proto_id);

tools/bpf/resolve_btfids/main.c

1193

if (is_kf_implicit_arg(btf, &params[i]))

tools/bpf/resolve_btfids/main.c

1195

param_name = btf__name_by_offset(btf, params[i].name_off);

tools/bpf/resolve_btfids/main.c

1196

err = btf__add_func_param(btf, param_name, params[i].type);

tools/bpf/resolve_btfids/main.c

1202

t = (struct btf_type *)btf__type_by_id(btf, proto_id);

tools/bpf/resolve_btfids/main.c

1206

t = (struct btf_type *)btf__type_by_id(btf, kfunc->btf_id);

tools/bpf/resolve_btfids/main.c

1248

struct btf *btf = (struct btf *)priv;

tools/bpf/resolve_btfids/main.c

1249

const struct btf_type *ta = btf__type_by_id(btf, *(__u32 *)a);

tools/bpf/resolve_btfids/main.c

1250

const struct btf_type *tb = btf__type_by_id(btf, *(__u32 *)b);

tools/bpf/resolve_btfids/main.c

1254

na = btf__str_by_offset(btf, ta->name_off);

tools/bpf/resolve_btfids/main.c

1255

nb = btf__str_by_offset(btf, tb->name_off);

tools/bpf/resolve_btfids/main.c

1264

static int sort_btf_by_name(struct btf *btf)

tools/bpf/resolve_btfids/main.c

127

struct btf *btf;

tools/bpf/resolve_btfids/main.c

1270

if (btf__base_btf(btf))

tools/bpf/resolve_btfids/main.c

1271

start_id = btf__type_cnt(btf__base_btf(btf));

tools/bpf/resolve_btfids/main.c

1272

nr_types = btf__type_cnt(btf) - start_id;

tools/bpf/resolve_btfids/main.c

128

struct btf *base_btf;

tools/bpf/resolve_btfids/main.c

1290

btf);

tools/bpf/resolve_btfids/main.c

1297

err = btf__permute(btf, id_map, nr_types, NULL);

tools/bpf/resolve_btfids/main.c

1309

struct btf *base_btf = obj->base_btf, *btf = obj->btf;

tools/bpf/resolve_btfids/main.c

1313

err = btf__distill_base(obj->btf, &base_btf, &btf);

tools/bpf/resolve_btfids/main.c

1320

btf__free(obj->btf);

tools/bpf/resolve_btfids/main.c

1322

obj->btf = btf;

tools/bpf/resolve_btfids/main.c

1325

err = sort_btf_by_name(obj->btf);

tools/bpf/resolve_btfids/main.c

1335

btf__free(btf);

tools/bpf/resolve_btfids/main.c

1337

obj->btf = NULL;

tools/bpf/resolve_btfids/main.c

1557

err = err ?: dump_raw_btf(obj.btf, out_path);

tools/bpf/resolve_btfids/main.c

1572

btf__free(obj.btf);

tools/bpf/resolve_btfids/main.c

165

struct btf *btf;

tools/bpf/resolve_btfids/main.c

583

struct btf *base_btf = NULL, *btf = NULL;

tools/bpf/resolve_btfids/main.c

596

btf = btf__parse_split(obj->btf_path ?: obj->path, base_btf);

tools/bpf/resolve_btfids/main.c

597

err = libbpf_get_error(btf);

tools/bpf/resolve_btfids/main.c

605

obj->btf = btf;

tools/bpf/resolve_btfids/main.c

611

btf__free(btf);

tools/bpf/resolve_btfids/main.c

613

obj->btf = NULL;

tools/bpf/resolve_btfids/main.c

623

struct btf *btf = obj->btf;

tools/bpf/resolve_btfids/main.c

628

nr_types = btf__type_cnt(btf);

tools/bpf/resolve_btfids/main.c

640

type = btf__type_by_id(btf, type_id);

tools/bpf/resolve_btfids/main.c

662

str = btf__name_by_offset(btf, type->name_off);

tools/bpf/resolve_btfids/main.c

862

static int dump_raw_btf(struct btf *btf, const char *out_path)

tools/bpf/resolve_btfids/main.c

868

raw_btf_data = btf__raw_data(btf, &raw_btf_size);

tools/bpf/resolve_btfids/main.c

881

static const struct btf_type *btf_type_skip_qualifiers(const struct btf *btf, s32 type_id)

tools/bpf/resolve_btfids/main.c

883

const struct btf_type *t = btf__type_by_id(btf, type_id);

tools/bpf/resolve_btfids/main.c

886

t = btf__type_by_id(btf, t->type);

tools/bpf/resolve_btfids/main.c

931

const u32 type_cnt = btf__type_cnt(ctx->btf);

tools/bpf/resolve_btfids/main.c

932

struct btf *btf = ctx->btf;

tools/bpf/resolve_btfids/main.c

937

t = btf__type_by_id(btf, id);

tools/bpf/resolve_btfids/main.c

995

struct btf *btf = ctx->btf;

tools/include/uapi/linux/bpf.h

1755

__aligned_u64 btf;

tools/include/uapi/linux/bpf.h

6725

__aligned_u64 btf;

tools/lib/bpf/bpf.c

1278

attr.btf = ptr_to_u64(btf_data);

tools/lib/bpf/btf.c

1004

return btf__align_of(btf, t->type);

tools/lib/bpf/btf.c

1006

return btf__align_of(btf, btf_array(t)->type);

tools/lib/bpf/btf.c

1014

align = btf__align_of(btf, m->type);

tools/lib/bpf/btf.c

1041

int btf__resolve_type(const struct btf *btf, __u32 type_id)

tools/lib/bpf/btf.c

1046

t = btf__type_by_id(btf, type_id);

tools/lib/bpf/btf.c

1051

t = btf__type_by_id(btf, type_id);

tools/lib/bpf/btf.c

1061

static void btf_check_sorted(struct btf *btf)

tools/lib/bpf/btf.c

1065

n = btf__type_cnt(btf);

tools/lib/bpf/btf.c

1066

for (i = btf->start_id + 1; i < n; i++) {

tools/lib/bpf/btf.c

1067

struct btf_type *ta = btf_type_by_id(btf, i - 1);

tools/lib/bpf/btf.c

1068

struct btf_type *tb = btf_type_by_id(btf, i);

tools/lib/bpf/btf.c

1069

const char *na = btf__str_by_offset(btf, ta->name_off);

tools/lib/bpf/btf.c

1070

const char *nb = btf__str_by_offset(btf, tb->name_off);

tools/lib/bpf/btf.c

1082

btf->named_start_id = named_start_id;

tools/lib/bpf/btf.c

1085

static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const char *name,

tools/lib/bpf/btf.c

1093

r = btf__type_cnt(btf) - 1;

tools/lib/bpf/btf.c

1096

t = btf_type_by_id(btf, m);

tools/lib/bpf/btf.c

1097

tname = btf__str_by_offset(btf, t->name_off);

tools/lib/bpf/btf.c

1107

return btf__type_cnt(btf);

tools/lib/bpf/btf.c

1110

static __s32 btf_find_by_name_kind(const struct btf *btf, int start_id,

tools/lib/bpf/btf.c

1113

__u32 nr_types = btf__type_cnt(btf);

tools/lib/bpf/btf.c

1118

if (start_id < btf->start_id) {

tools/lib/bpf/btf.c

1119

id = btf_find_by_name_kind(btf->base_btf, start_id,

tools/lib/bpf/btf.c

1123

start_id = btf->start_id;

tools/lib/bpf/btf.c

1129

if (btf->named_start_id > 0 && type_name[0]) {

tools/lib/bpf/btf.c

1130

start_id = max(start_id, btf->named_start_id);

tools/lib/bpf/btf.c

1131

id = btf_find_type_by_name_bsearch(btf, type_name, start_id);

tools/lib/bpf/btf.c

1133

t = btf__type_by_id(btf, id);

tools/lib/bpf/btf.c

1134

tname = btf__str_by_offset(btf, t->name_off);

tools/lib/bpf/btf.c

1142

t = btf_type_by_id(btf, id);

tools/lib/bpf/btf.c

1145

tname = btf__str_by_offset(btf, t->name_off);

tools/lib/bpf/btf.c

1155

__s32 btf__find_by_name(const struct btf *btf, const char *type_name)

tools/lib/bpf/btf.c

1157

return btf_find_by_name_kind(btf, 1, type_name, -1);

tools/lib/bpf/btf.c

1160

__s32 btf__find_by_name_kind_own(const struct btf *btf, const char *type_name,

tools/lib/bpf/btf.c

1163

return btf_find_by_name_kind(btf, btf->start_id, type_name, kind);

tools/lib/bpf/btf.c

1166

__s32 btf__find_by_name_kind(const struct btf *btf, const char *type_name,

tools/lib/bpf/btf.c

1169

return btf_find_by_name_kind(btf, 1, type_name, kind);

tools/lib/bpf/btf.c

1172

static bool btf_is_modifiable(const struct btf *btf)

tools/lib/bpf/btf.c

1175

return btf->modifiable;

tools/lib/bpf/btf.c

1178

static void btf_free_raw_data(struct btf *btf)

tools/lib/bpf/btf.c

1180

if (btf->raw_data_is_mmap) {

tools/lib/bpf/btf.c

1181

munmap(btf->raw_data, btf->raw_size);

tools/lib/bpf/btf.c

1182

btf->raw_data_is_mmap = false;

tools/lib/bpf/btf.c

1184

free(btf->raw_data);

tools/lib/bpf/btf.c

1186

btf->raw_data = NULL;

tools/lib/bpf/btf.c

1189

void btf__free(struct btf *btf)

tools/lib/bpf/btf.c

1191

if (IS_ERR_OR_NULL(btf))

tools/lib/bpf/btf.c

1194

if (btf->fd >= 0)

tools/lib/bpf/btf.c

1195

close(btf->fd);

tools/lib/bpf/btf.c

1197

if (btf_is_modifiable(btf)) {

tools/lib/bpf/btf.c

1204

free(btf->types_data);

tools/lib/bpf/btf.c

1205

strset__free(btf->strs_set);

tools/lib/bpf/btf.c

1206

free(btf->layout);

tools/lib/bpf/btf.c

1208

btf_free_raw_data(btf);

tools/lib/bpf/btf.c

1209

free(btf->raw_data_swapped);

tools/lib/bpf/btf.c

1210

free(btf->type_offs);

tools/lib/bpf/btf.c

1211

if (btf->owns_base)

tools/lib/bpf/btf.c

1212

btf__free(btf->base_btf);

tools/lib/bpf/btf.c

1213

free(btf);

tools/lib/bpf/btf.c

1216

static struct btf *btf_new_empty(struct btf_new_opts *opts)

tools/lib/bpf/btf.c

1219

struct btf *base_btf = OPTS_GET(opts, base_btf, NULL);

tools/lib/bpf/btf.c

1221

struct btf *btf;

tools/lib/bpf/btf.c

1223

btf = calloc(1, sizeof(*btf));

tools/lib/bpf/btf.c

1224

if (!btf)

tools/lib/bpf/btf.c

1227

btf->nr_types = 0;

tools/lib/bpf/btf.c

1228

btf->start_id = 1;

tools/lib/bpf/btf.c

1229

btf->start_str_off = 0;

tools/lib/bpf/btf.c

1230

btf->fd = -1;

tools/lib/bpf/btf.c

1231

btf->ptr_sz = sizeof(void *);

tools/lib/bpf/btf.c

1232

btf->swapped_endian = false;

tools/lib/bpf/btf.c

1233

btf->named_start_id = 0;

tools/lib/bpf/btf.c

1236

btf->base_btf = base_btf;

tools/lib/bpf/btf.c

1237

btf->start_id = btf__type_cnt(base_btf);

tools/lib/bpf/btf.c

1238

btf->start_str_off = base_btf->hdr.str_len + base_btf->start_str_off;

tools/lib/bpf/btf.c

1239

btf->swapped_endian = base_btf->swapped_endian;

tools/lib/bpf/btf.c

1243

btf->raw_size = sizeof(struct btf_header) + (base_btf ? 0 : 1);

tools/lib/bpf/btf.c

1245

btf->raw_size += sizeof(layouts);

tools/lib/bpf/btf.c

1246

btf->raw_data = calloc(1, btf->raw_size);

tools/lib/bpf/btf.c

1247

if (!btf->raw_data) {

tools/lib/bpf/btf.c

1248

free(btf);

tools/lib/bpf/btf.c

1252

hdr = btf->raw_data;

tools/lib/bpf/btf.c

1257

btf->types_data = btf->raw_data + hdr->hdr_len;

tools/lib/bpf/btf.c

1258

btf->strs_data = btf->raw_data + hdr->hdr_len;

tools/lib/bpf/btf.c

1263

btf->layout = layouts;

tools/lib/bpf/btf.c

1268

memcpy(btf->raw_data + hdr->hdr_len, layouts, sizeof(layouts));

tools/lib/bpf/btf.c

1269

btf->strs_data += sizeof(layouts);

tools/lib/bpf/btf.c

1273

memcpy(&btf->hdr, hdr, sizeof(*hdr));

tools/lib/bpf/btf.c

1275

return btf;

tools/lib/bpf/btf.c

1278

struct btf *btf__new_empty(void)

tools/lib/bpf/btf.c

1283

struct btf *btf__new_empty_split(struct btf *base_btf)

tools/lib/bpf/btf.c

1292

struct btf *btf__new_empty_opts(struct btf_new_opts *opts)

tools/lib/bpf/btf.c

1300

static struct btf *btf_new(const void *data, __u32 size, struct btf *base_btf, bool is_mmap)

tools/lib/bpf/btf.c

1302

struct btf *btf;

tools/lib/bpf/btf.c

1305

btf = calloc(1, sizeof(struct btf));

tools/lib/bpf/btf.c

1306

if (!btf)

tools/lib/bpf/btf.c

1309

btf->nr_types = 0;

tools/lib/bpf/btf.c

1310

btf->start_id = 1;

tools/lib/bpf/btf.c

1311

btf->start_str_off = 0;

tools/lib/bpf/btf.c

1312

btf->fd = -1;

tools/lib/bpf/btf.c

1313

btf->named_start_id = 0;

tools/lib/bpf/btf.c

1316

btf->base_btf = base_btf;

tools/lib/bpf/btf.c

1317

btf->start_id = btf__type_cnt(base_btf);

tools/lib/bpf/btf.c

1318

btf->start_str_off = base_btf->hdr.str_len + base_btf->start_str_off;

tools/lib/bpf/btf.c

1322

btf->raw_data = (void *)data;

tools/lib/bpf/btf.c

1323

btf->raw_data_is_mmap = true;

tools/lib/bpf/btf.c

1325

btf->raw_data = malloc(size);

tools/lib/bpf/btf.c

1326

if (!btf->raw_data) {

tools/lib/bpf/btf.c

1330

memcpy(btf->raw_data, data, size);

tools/lib/bpf/btf.c

1333

btf->raw_size = size;

tools/lib/bpf/btf.c

1335

err = btf_parse_hdr(btf);

tools/lib/bpf/btf.c

1339

btf->strs_data = btf->raw_data + btf->hdr.hdr_len + btf->hdr.str_off;

tools/lib/bpf/btf.c

1340

btf->types_data = btf->raw_data + btf->hdr.hdr_len + btf->hdr.type_off;

tools/lib/bpf/btf.c

1342

err = btf_parse_str_sec(btf);

tools/lib/bpf/btf.c

1343

err = err ?: btf_parse_layout_sec(btf);

tools/lib/bpf/btf.c

1344

err = err ?: btf_parse_type_sec(btf);

tools/lib/bpf/btf.c

1345

err = err ?: btf_sanity_check(btf);

tools/lib/bpf/btf.c

1348

btf_check_sorted(btf);

tools/lib/bpf/btf.c

1352

btf__free(btf);

tools/lib/bpf/btf.c

1356

return btf;

tools/lib/bpf/btf.c

1359

struct btf *btf__new(const void *data, __u32 size)

tools/lib/bpf/btf.c

1364

struct btf *btf__new_split(const void *data, __u32 size, struct btf *base_btf)

tools/lib/bpf/btf.c

141

struct btf *base_btf;

tools/lib/bpf/btf.c

1447

static struct btf *btf_parse_elf(const char *path, struct btf *base_btf,

tools/lib/bpf/btf.c

1451

struct btf *dist_base_btf = NULL;

tools/lib/bpf/btf.c

1452

struct btf *btf = NULL;

tools/lib/bpf/btf.c

1495

btf = btf_new(secs.btf_data->d_buf, secs.btf_data->d_size,

tools/lib/bpf/btf.c

1497

if (IS_ERR(btf)) {

tools/lib/bpf/btf.c

1498

err = PTR_ERR(btf);

tools/lib/bpf/btf.c

1502

err = btf__relocate(btf, base_btf);

tools/lib/bpf/btf.c

1510

btf->owns_base = true;

tools/lib/bpf/btf.c

1514

btf__set_pointer_size(btf, 4);

tools/lib/bpf/btf.c

1517

btf__set_pointer_size(btf, 8);

tools/lib/bpf/btf.c

1539

return btf;

tools/lib/bpf/btf.c

1544

btf__free(btf);

tools/lib/bpf/btf.c

1549

struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext)

tools/lib/bpf/btf.c

1554

struct btf *btf__parse_elf_split(const char *path, struct btf *base_btf)

tools/lib/bpf/btf.c

1559

static struct btf *btf_parse_raw(const char *path, struct btf *base_btf)

tools/lib/bpf/btf.c

1561

struct btf *btf = NULL;

tools/lib/bpf/btf.c

1613

btf = btf_new(data, sz, base_btf, false);

tools/lib/bpf/btf.c

1619

return err ? ERR_PTR(err) : btf;

tools/lib/bpf/btf.c

1622

struct btf *btf__parse_raw(const char *path)

tools/lib/bpf/btf.c

1627

struct btf *btf__parse_raw_split(const char *path, struct btf *base_btf)

tools/lib/bpf/btf.c

1632

static struct btf *btf_parse_raw_mmap(const char *path, struct btf *base_btf)

tools/lib/bpf/btf.c

1636

struct btf *btf;

tools/lib/bpf/btf.c

1656

btf = btf_new(data, st.st_size, base_btf, true);

tools/lib/bpf/btf.c

1657

if (IS_ERR(btf))

tools/lib/bpf/btf.c

1660

return btf;

tools/lib/bpf/btf.c

1663

static struct btf *btf_parse(const char *path, struct btf *base_btf, struct btf_ext **btf_ext)

tools/lib/bpf/btf.c

1665

struct btf *btf;

tools/lib/bpf/btf.c

1671

btf = btf_parse_raw(path, base_btf);

tools/lib/bpf/btf.c

1672

err = libbpf_get_error(btf);

tools/lib/bpf/btf.c

1674

return btf;

tools/lib/bpf/btf.c

1680

struct btf *btf__parse(const char *path, struct btf_ext **btf_ext)

tools/lib/bpf/btf.c

1685

struct btf *btf__parse_split(const char *path, struct btf *base_btf)

tools/lib/bpf/btf.c

1690

static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endian);

tools/lib/bpf/btf.c

1692

int btf_load_into_kernel(struct btf *btf,

tools/lib/bpf/btf.c

1702

if (btf->fd >= 0)

tools/lib/bpf/btf.c

1708

raw_data = btf_get_raw_data(btf, &raw_size, false);

tools/lib/bpf/btf.c

1713

btf->raw_size = raw_size;

tools/lib/bpf/btf.c

1714

btf->raw_data = raw_data;

tools/lib/bpf/btf.c

1748

btf->fd = bpf_btf_load(raw_data, raw_size, &opts);

tools/lib/bpf/btf.c

1749

if (btf->fd < 0) {

tools/lib/bpf/btf.c

1773

int btf__load_into_kernel(struct btf *btf)

tools/lib/bpf/btf.c

1775

return btf_load_into_kernel(btf, NULL, 0, 0, 0);

tools/lib/bpf/btf.c

1778

int btf__fd(const struct btf *btf)

tools/lib/bpf/btf.c

1780

return btf->fd;

tools/lib/bpf/btf.c

1783

void btf__set_fd(struct btf *btf, int fd)

tools/lib/bpf/btf.c

1785

btf->fd = fd;

tools/lib/bpf/btf.c

1788

static const void *btf_strs_data(const struct btf *btf)

tools/lib/bpf/btf.c

1790

return btf->strs_data ? btf->strs_data : strset__data(btf->strs_set);

tools/lib/bpf/btf.c

1793

static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endian)

tools/lib/bpf/btf.c

1795

const struct btf_header *hdr = &btf->hdr;

tools/lib/bpf/btf.c

1801

data = swap_endian ? btf->raw_data_swapped : btf->raw_data;

tools/lib/bpf/btf.c

1803

*size = btf->raw_size;

tools/lib/bpf/btf.c

1808

if (btf->layout)

tools/lib/bpf/btf.c

1821

memcpy(p, btf->types_data, hdr->type_len);

tools/lib/bpf/btf.c

1823

for (i = 0; i < btf->nr_types; i++) {

tools/lib/bpf/btf.c

1824

t = p + btf->type_offs[i];

tools/lib/bpf/btf.c

1836

if (btf->layout) {

tools/lib/bpf/btf.c

1837

memcpy(p, btf->layout, hdr->layout_len);

tools/lib/bpf/btf.c

1847

memcpy(p, btf_strs_data(btf), hdr->str_len);

tools/lib/bpf/btf.c

1856

const void *btf__raw_data(const struct btf *btf_ro, __u32 *size)

tools/lib/bpf/btf.c

1858

struct btf *btf = (struct btf *)btf_ro;

tools/lib/bpf/btf.c

1862

data = btf_get_raw_data(btf, &data_sz, btf->swapped_endian);

tools/lib/bpf/btf.c

1866

btf->raw_size = data_sz;

tools/lib/bpf/btf.c

1867

if (btf->swapped_endian)

tools/lib/bpf/btf.c

1868

btf->raw_data_swapped = data;

tools/lib/bpf/btf.c

1870

btf->raw_data = data;

tools/lib/bpf/btf.c

1876

const void *btf__get_raw_data(const struct btf *btf, __u32 *size);

tools/lib/bpf/btf.c

1878

const char *btf__str_by_offset(const struct btf *btf, __u32 offset)

tools/lib/bpf/btf.c

1880

if (offset < btf->start_str_off)

tools/lib/bpf/btf.c

1881

return btf__str_by_offset(btf->base_btf, offset);

tools/lib/bpf/btf.c

1882

else if (offset - btf->start_str_off < btf->hdr.str_len)

tools/lib/bpf/btf.c

1883

return btf_strs_data(btf) + (offset - btf->start_str_off);

tools/lib/bpf/btf.c

1888

const char *btf__name_by_offset(const struct btf *btf, __u32 offset)

tools/lib/bpf/btf.c

1890

return btf__str_by_offset(btf, offset);

tools/lib/bpf/btf.c

1893

struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf)

tools/lib/bpf/btf.c

1898

struct btf *btf;

tools/lib/bpf/btf.c

1912

btf_info.btf = ptr_to_u64(ptr);

tools/lib/bpf/btf.c

1922

btf = ERR_PTR(-ENOMEM);

tools/lib/bpf/btf.c

1929

btf_info.btf = ptr_to_u64(ptr);

tools/lib/bpf/btf.c

1936

btf = err ? ERR_PTR(-errno) : ERR_PTR(-E2BIG);

tools/lib/bpf/btf.c

1940

btf = btf_new(ptr, btf_info.btf_size, base_btf, false);

tools/lib/bpf/btf.c

1944

return btf;

tools/lib/bpf/btf.c

1947

struct btf *btf_load_from_kernel(__u32 id, struct btf *base_btf, int token_fd)

tools/lib/bpf/btf.c

1949

struct btf *btf;

tools/lib/bpf/btf.c

1962

btf = btf_get_from_fd(btf_fd, base_btf);

tools/lib/bpf/btf.c

1965

return libbpf_ptr(btf);

tools/lib/bpf/btf.c

1968

struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf)

tools/lib/bpf/btf.c

1973

struct btf *btf__load_from_kernel_by_id(__u32 id)

tools/lib/bpf/btf.c

1978

static void btf_invalidate_raw_data(struct btf *btf)

tools/lib/bpf/btf.c

1980

if (btf->raw_data)

tools/lib/bpf/btf.c

1981

btf_free_raw_data(btf);

tools/lib/bpf/btf.c

1982

if (btf->raw_data_swapped) {

tools/lib/bpf/btf.c

1983

free(btf->raw_data_swapped);

tools/lib/bpf/btf.c

1984

btf->raw_data_swapped = NULL;

tools/lib/bpf/btf.c

1986

btf->named_start_id = 0;

tools/lib/bpf/btf.c

1993

static int btf_ensure_modifiable(struct btf *btf)

tools/lib/bpf/btf.c

1999

if (btf_is_modifiable(btf)) {

tools/lib/bpf/btf.c

2001

btf_invalidate_raw_data(btf);

tools/lib/bpf/btf.c

2005

if (btf->has_hdr_extra) {

tools/lib/bpf/btf.c

2011

types = malloc(btf->hdr.type_len);

tools/lib/bpf/btf.c

2014

memcpy(types, btf->types_data, btf->hdr.type_len);

tools/lib/bpf/btf.c

2016

if (btf->hdr.layout_len) {

tools/lib/bpf/btf.c

2017

layout = malloc(btf->hdr.layout_len);

tools/lib/bpf/btf.c

2020

memcpy(layout, btf->raw_data + btf->hdr.hdr_len + btf->hdr.layout_off,

tools/lib/bpf/btf.c

2021

btf->hdr.layout_len);

tools/lib/bpf/btf.c

2025

set = strset__new(BTF_MAX_STR_OFFSET, btf->strs_data, btf->hdr.str_len);

tools/lib/bpf/btf.c

2032

btf->types_data = types;

tools/lib/bpf/btf.c

2033

btf->types_data_cap = btf->hdr.type_len;

tools/lib/bpf/btf.c

2034

btf->strs_data = NULL;

tools/lib/bpf/btf.c

2035

btf->strs_set = set;

tools/lib/bpf/btf.c

2037

btf->layout = layout;

tools/lib/bpf/btf.c

2041

if (btf->hdr.str_len == 0)

tools/lib/bpf/btf.c

2042

btf->strs_deduped = true;

tools/lib/bpf/btf.c

2043

if (!btf->base_btf && btf->hdr.str_len == 1)

tools/lib/bpf/btf.c

2044

btf->strs_deduped = true;

tools/lib/bpf/btf.c

2047

btf_invalidate_raw_data(btf);

tools/lib/bpf/btf.c

2049

btf->modifiable = true;

tools/lib/bpf/btf.c

2066

int btf__find_str(struct btf *btf, const char *s)

tools/lib/bpf/btf.c

2071

if (btf->base_btf) {

tools/lib/bpf/btf.c

2072

off = btf__find_str(btf->base_btf, s);

tools/lib/bpf/btf.c

2078

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2082

off = strset__find_str(btf->strs_set, s);

tools/lib/bpf/btf.c

2086

return btf->start_str_off + off;

tools/lib/bpf/btf.c

2094

int btf__add_str(struct btf *btf, const char *s)

tools/lib/bpf/btf.c

2099

if (btf->base_btf) {

tools/lib/bpf/btf.c

2100

off = btf__find_str(btf->base_btf, s);

tools/lib/bpf/btf.c

2105

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2109

off = strset__add_str(btf->strs_set, s);

tools/lib/bpf/btf.c

2113

btf->hdr.str_len = strset__data_size(btf->strs_set);

tools/lib/bpf/btf.c

2115

return btf->start_str_off + off;

tools/lib/bpf/btf.c

2118

static void *btf_add_type_mem(struct btf *btf, size_t add_sz)

tools/lib/bpf/btf.c

2120

return libbpf_add_mem(&btf->types_data, &btf->types_data_cap, 1,

tools/lib/bpf/btf.c

2121

btf->hdr.type_len, UINT_MAX, add_sz);

tools/lib/bpf/btf.c

2129

static void btf_hdr_update_type_len(struct btf *btf, int new_len)

tools/lib/bpf/btf.c

2131

btf->hdr.type_len = new_len;

tools/lib/bpf/btf.c

2132

if (btf->layout) {

tools/lib/bpf/btf.c

2133

btf->hdr.layout_off = btf->hdr.type_off + new_len;

tools/lib/bpf/btf.c

2134

btf->hdr.str_off = btf->hdr.layout_off + btf->hdr.layout_len;

tools/lib/bpf/btf.c

2136

btf->hdr.str_off = btf->hdr.type_off + new_len;

tools/lib/bpf/btf.c

2140

static void btf_hdr_update_str_len(struct btf *btf, int new_len)

tools/lib/bpf/btf.c

2142

btf->hdr.str_len = new_len;

tools/lib/bpf/btf.c

2145

static int btf_commit_type(struct btf *btf, int data_sz)

tools/lib/bpf/btf.c

2149

err = btf_add_type_idx_entry(btf, btf->hdr.type_len);

tools/lib/bpf/btf.c

2153

btf_hdr_update_type_len(btf, btf->hdr.type_len + data_sz);

tools/lib/bpf/btf.c

2154

btf->nr_types++;

tools/lib/bpf/btf.c

2155

return btf->start_id + btf->nr_types - 1;

tools/lib/bpf/btf.c

2159

const struct btf *src;

tools/lib/bpf/btf.c

2160

struct btf *dst;

tools/lib/bpf/btf.c

2230

int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_type *src_type)

tools/lib/bpf/btf.c

2232

struct btf_pipe p = { .src = src_btf, .dst = btf };

tools/lib/bpf/btf.c

2240

int btf__add_btf(struct btf *btf, const struct btf *src_btf)

tools/lib/bpf/btf.c

2242

struct btf_pipe p = { .src = src_btf, .dst = btf };

tools/lib/bpf/btf.c

2252

if (src_btf->base_btf && src_btf->base_btf != btf->base_btf)

tools/lib/bpf/btf.c

2258

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2265

old_strs_len = btf->hdr.str_len;

tools/lib/bpf/btf.c

2271

t = btf_add_type_mem(btf, data_sz);

tools/lib/bpf/btf.c

2276

off = btf_add_type_offs_mem(btf, cnt);

tools/lib/bpf/btf.c

2300

*off = t - btf->types_data;

tools/lib/bpf/btf.c

2328

*type_id += btf->start_id + btf->nr_types - src_start_id;

tools/lib/bpf/btf.c

2344

btf_hdr_update_type_len(btf, btf->hdr.type_len + data_sz);

tools/lib/bpf/btf.c

2345

btf->nr_types += cnt;

tools/lib/bpf/btf.c

2350

return btf->start_id + btf->nr_types - cnt;

tools/lib/bpf/btf.c

2355

memset(btf->types_data + btf->hdr.type_len, 0, data_sz);

tools/lib/bpf/btf.c

2356

if (btf->strs_data)

tools/lib/bpf/btf.c

2357

memset(btf->strs_data + old_strs_len, 0, btf->hdr.str_len - old_strs_len);

tools/lib/bpf/btf.c

2362

btf_hdr_update_str_len(btf, old_strs_len);

tools/lib/bpf/btf.c

2378

int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding)

tools/lib/bpf/btf.c

2394

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2399

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2407

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2417

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

2428

int btf__add_float(struct btf *btf, const char *name, size_t byte_sz)

tools/lib/bpf/btf.c

2443

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2448

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2452

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2460

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

2475

static int btf_add_ref_kind(struct btf *btf, int kind, const char *name, int ref_type_id, int kflag)

tools/lib/bpf/btf.c

2484

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2489

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2494

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2503

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

2513

int btf__add_ptr(struct btf *btf, int ref_type_id)

tools/lib/bpf/btf.c

2515

return btf_add_ref_kind(btf, BTF_KIND_PTR, NULL, ref_type_id, 0);

tools/lib/bpf/btf.c

2527

int btf__add_array(struct btf *btf, int index_type_id, int elem_type_id, __u32 nr_elems)

tools/lib/bpf/btf.c

253

static void *btf_add_type_offs_mem(struct btf *btf, size_t add_cnt)

tools/lib/bpf/btf.c

2537

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2542

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

255

return libbpf_add_mem((void **)&btf->type_offs, &btf->type_offs_cap, sizeof(__u32),

tools/lib/bpf/btf.c

2555

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

2559

static int btf_add_composite(struct btf *btf, int kind, const char *name, __u32 bytes_sz)

tools/lib/bpf/btf.c

256

btf->nr_types, BTF_MAX_NR_TYPES, add_cnt);

tools/lib/bpf/btf.c

2565

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2570

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2575

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2587

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

259

static int btf_add_type_idx_entry(struct btf *btf, __u32 type_off)

tools/lib/bpf/btf.c

2602

int btf__add_struct(struct btf *btf, const char *name, __u32 byte_sz)

tools/lib/bpf/btf.c

2604

return btf_add_composite(btf, BTF_KIND_STRUCT, name, byte_sz);

tools/lib/bpf/btf.c

2620

int btf__add_union(struct btf *btf, const char *name, __u32 byte_sz)

tools/lib/bpf/btf.c

2622

return btf_add_composite(btf, BTF_KIND_UNION, name, byte_sz);

tools/lib/bpf/btf.c

2625

static struct btf_type *btf_last_type(struct btf *btf)

tools/lib/bpf/btf.c

2627

return btf_type_by_id(btf, btf__type_cnt(btf) - 1);

tools/lib/bpf/btf.c

263

p = btf_add_type_offs_mem(btf, 1);

tools/lib/bpf/btf.c

2640

int btf__add_field(struct btf *btf, const char *name, int type_id,

tools/lib/bpf/btf.c

2650

if (btf->nr_types == 0)

tools/lib/bpf/btf.c

2652

t = btf_last_type(btf);

tools/lib/bpf/btf.c

2668

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2673

m = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2678

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2688

t = btf_last_type(btf);

tools/lib/bpf/btf.c

2692

btf_hdr_update_type_len(btf, btf->hdr.type_len + sz);

tools/lib/bpf/btf.c

2696

static int btf_add_enum_common(struct btf *btf, const char *name, __u32 byte_sz,

tools/lib/bpf/btf.c

2707

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2712

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2717

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2727

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

2743

int btf__add_enum(struct btf *btf, const char *name, __u32 byte_sz)

tools/lib/bpf/btf.c

2749

return btf_add_enum_common(btf, name, byte_sz, false, BTF_KIND_ENUM);

tools/lib/bpf/btf.c

2760

int btf__add_enum_value(struct btf *btf, const char *name, __s64 value)

tools/lib/bpf/btf.c

2768

if (btf->nr_types == 0)

tools/lib/bpf/btf.c

2770

t = btf_last_type(btf);

tools/lib/bpf/btf.c

2781

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

2786

v = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2790

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2798

t = btf_last_type(btf);

tools/lib/bpf/btf.c

2805

btf_hdr_update_type_len(btf, btf->hdr.type_len + sz);

tools/lib/bpf/btf.c

2823

int btf__add_enum64(struct btf *btf, const char *name, __u32 byte_sz,

tools/lib/bpf/btf.c

2826

return btf_add_enum_common(btf, name, byte_sz, is_signed,

tools/lib/bpf/btf.c

2838

int btf__add_enum64_value(struct btf *btf, const char *name, __u64 value)

tools/lib/bpf/btf.c

2846

if (btf->nr_types == 0)

tools/lib/bpf/btf.c

2848

t = btf_last_type(btf);

tools/lib/bpf/btf.c

2857

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

286

static int btf_parse_hdr(struct btf *btf)

tools/lib/bpf/btf.c

2862

v = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

2866

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

2875

t = btf_last_type(btf);

tools/lib/bpf/btf.c

2878

btf_hdr_update_type_len(btf, btf->hdr.type_len + sz);

tools/lib/bpf/btf.c

288

struct btf_header *hdr = btf->raw_data;

tools/lib/bpf/btf.c

2891

int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind)

tools/lib/bpf/btf.c

2902

id = btf_add_ref_kind(btf, BTF_KIND_FWD, name, 0, 0);

tools/lib/bpf/btf.c

2905

t = btf_type_by_id(btf, id);

tools/lib/bpf/btf.c

291

if (btf->raw_size < offsetofend(struct btf_header, str_len)) {

tools/lib/bpf/btf.c

2913

return btf__add_enum(btf, name, sizeof(int));

tools/lib/bpf/btf.c

2927

int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id)

tools/lib/bpf/btf.c

2932

return btf_add_ref_kind(btf, BTF_KIND_TYPEDEF, name, ref_type_id, 0);

tools/lib/bpf/btf.c

2942

int btf__add_volatile(struct btf *btf, int ref_type_id)

tools/lib/bpf/btf.c

2944

return btf_add_ref_kind(btf, BTF_KIND_VOLATILE, NULL, ref_type_id, 0);

tools/lib/bpf/btf.c

2954

int btf__add_const(struct btf *btf, int ref_type_id)

tools/lib/bpf/btf.c

2956

return btf_add_ref_kind(btf, BTF_KIND_CONST, NULL, ref_type_id, 0);

tools/lib/bpf/btf.c

2966

int btf__add_restrict(struct btf *btf, int ref_type_id)

tools/lib/bpf/btf.c

2968

return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id, 0);

tools/lib/bpf/btf.c

2979

int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id)

tools/lib/bpf/btf.c

2984

return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 0);

tools/lib/bpf/btf.c

299

btf->swapped_endian = true;

tools/lib/bpf/btf.c

2996

int btf__add_type_attr(struct btf *btf, const char *value, int ref_type_id)

tools/lib/bpf/btf.c

3001

return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 1);

tools/lib/bpf/btf.c

3012

int btf__add_func(struct btf *btf, const char *name,

tools/lib/bpf/btf.c

3023

id = btf_add_ref_kind(btf, BTF_KIND_FUNC, name, proto_type_id, 0);

tools/lib/bpf/btf.c

3025

struct btf_type *t = btf_type_by_id(btf, id);

tools/lib/bpf/btf.c

3044

int btf__add_func_proto(struct btf *btf, int ret_type_id)

tools/lib/bpf/btf.c

3053

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

3058

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

3069

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

3080

int btf__add_func_param(struct btf *btf, const char *name, int type_id)

tools/lib/bpf/btf.c

3091

if (btf->nr_types == 0)

tools/lib/bpf/btf.c

3093

t = btf_last_type(btf);

tools/lib/bpf/btf.c

3098

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

3103

p = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

3108

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

311

if (btf->raw_size < hdr_len) {

tools/lib/bpf/btf.c

3117

t = btf_last_type(btf);

tools/lib/bpf/btf.c

3120

btf_hdr_update_type_len(btf, btf->hdr.type_len + sz);

tools/lib/bpf/btf.c

313

hdr_len, btf->raw_size);

tools/lib/bpf/btf.c

3134

int btf__add_var(struct btf *btf, const char *name, int linkage, int type_id)

tools/lib/bpf/btf.c

3151

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

3156

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

3160

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

317

if (btf->swapped_endian)

tools/lib/bpf/btf.c

3171

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

3186

int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz)

tools/lib/bpf/btf.c

3196

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

320

memcpy(&btf->hdr, hdr, min((size_t)hdr_len, sizeof(struct btf_header)));

tools/lib/bpf/btf.c

3201

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

3205

name_off = btf__add_str(btf, name);

tools/lib/bpf/btf.c

3214

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

3227

int btf__add_datasec_var_info(struct btf *btf, int var_type_id, __u32 offset, __u32 byte_sz)

tools/lib/bpf/btf.c

3235

if (btf->nr_types == 0)

tools/lib/bpf/btf.c

3237

t = btf_last_type(btf);

tools/lib/bpf/btf.c

3245

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

3250

v = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

3259

t = btf_last_type(btf);

tools/lib/bpf/btf.c

3262

btf_hdr_update_type_len(btf, btf->hdr.type_len + sz);

tools/lib/bpf/btf.c

3266

static int btf_add_decl_tag(struct btf *btf, const char *value, int ref_type_id,

tools/lib/bpf/btf.c

3279

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

3284

t = btf_add_type_mem(btf, sz);

tools/lib/bpf/btf.c

3288

value_off = btf__add_str(btf, value);

tools/lib/bpf/btf.c

3297

return btf_commit_type(btf, sz);

tools/lib/bpf/btf.c

3310

int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,

tools/lib/bpf/btf.c

3313

return btf_add_decl_tag(btf, value, ref_type_id, component_idx, 0);

tools/lib/bpf/btf.c

332

btf->has_hdr_extra = true;

tools/lib/bpf/btf.c

3327

int btf__add_decl_attr(struct btf *btf, const char *value, int ref_type_id,

tools/lib/bpf/btf.c

3330

return btf_add_decl_tag(btf, value, ref_type_id, component_idx, 1);

tools/lib/bpf/btf.c

339

meta_left = btf->raw_size - hdr_len;

tools/lib/bpf/btf.c

340

if (meta_left < (long long)btf->hdr.str_off + btf->hdr.str_len) {

tools/lib/bpf/btf.c

341

pr_debug("Invalid BTF total size: %u\n", btf->raw_size);

tools/lib/bpf/btf.c

345

if ((long long)btf->hdr.type_off + btf->hdr.type_len > btf->hdr.str_off) {

tools/lib/bpf/btf.c

347

btf->hdr.type_off, btf->hdr.type_len, btf->hdr.str_off,

tools/lib/bpf/btf.c

348

btf->hdr.str_len);

tools/lib/bpf/btf.c

352

if (btf->hdr.type_off % 4) {

tools/lib/bpf/btf.c

357

if (btf->hdr.layout_len == 0)

tools/lib/bpf/btf.c

361

if (btf->hdr.layout_off % 4) {

tools/lib/bpf/btf.c

365

if (btf->hdr.layout_off < (long long)btf->hdr.type_off + btf->hdr.type_len) {

tools/lib/bpf/btf.c

367

btf->hdr.type_off, btf->hdr.type_len,

tools/lib/bpf/btf.c

368

btf->hdr.layout_off, btf->hdr.layout_len);

tools/lib/bpf/btf.c

371

if ((long long)btf->hdr.layout_off + btf->hdr.layout_len > btf->hdr.str_off ||

tools/lib/bpf/btf.c

372

btf->hdr.layout_off > btf->hdr.str_off) {

tools/lib/bpf/btf.c

374

btf->hdr.layout_off, btf->hdr.layout_len, btf->hdr.str_off);

tools/lib/bpf/btf.c

3742

static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts);

tools/lib/bpf/btf.c

380

static int btf_parse_str_sec(struct btf *btf)

tools/lib/bpf/btf.c

382

const char *start = btf->strs_data;

tools/lib/bpf/btf.c

383

const char *end = start + btf->hdr.str_len;

tools/lib/bpf/btf.c

385

if (btf->base_btf && btf->hdr.str_len == 0)

tools/lib/bpf/btf.c

387

if (!btf->hdr.str_len || btf->hdr.str_len - 1 > BTF_MAX_STR_OFFSET || end[-1]) {

tools/lib/bpf/btf.c

3891

int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts)

tools/lib/bpf/btf.c

3899

d = btf_dedup_new(btf, opts);

tools/lib/bpf/btf.c

3905

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

391

if (!btf->base_btf && start[0]) {

tools/lib/bpf/btf.c

3960

struct btf *btf;

tools/lib/bpf/btf.c

398

static int btf_parse_layout_sec(struct btf *btf)

tools/lib/bpf/btf.c

400

if (!btf->hdr.layout_len)

tools/lib/bpf/btf.c

403

if (btf->hdr.layout_len % sizeof(struct btf_layout) != 0) {

tools/lib/bpf/btf.c

4066

static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts)

tools/lib/bpf/btf.c

407

btf->layout = btf->raw_data + btf->hdr.hdr_len + btf->hdr.layout_off;

tools/lib/bpf/btf.c

4078

d->btf = btf;

tools/lib/bpf/btf.c

4088

type_cnt = btf__type_cnt(btf);

tools/lib/bpf/btf.c

409

if (btf->swapped_endian) {

tools/lib/bpf/btf.c

4097

struct btf_type *t = btf_type_by_id(d->btf, i);

tools/lib/bpf/btf.c

410

struct btf_layout *l, *end = btf->layout + btf->hdr.layout_len;

tools/lib/bpf/btf.c

412

for (l = btf->layout; l < end; l++)

tools/lib/bpf/btf.c

4131

for (i = 0; i < d->btf->nr_types; i++) {

tools/lib/bpf/btf.c

4133

struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i);

tools/lib/bpf/btf.c

4165

if (str_off == 0 || str_off < d->btf->start_str_off)

tools/lib/bpf/btf.c

4168

s = btf__str_by_offset(d->btf, str_off);

tools/lib/bpf/btf.c

4169

if (d->btf->base_btf) {

tools/lib/bpf/btf.c

4170

err = btf__find_str(d->btf->base_btf, s);

tools/lib/bpf/btf.c

4183

*str_off_ptr = d->btf->start_str_off + off;

tools/lib/bpf/btf.c

420

static int btf_type_size_unknown(const struct btf *btf, const struct btf_type *t)

tools/lib/bpf/btf.c

4202

if (d->btf->strs_deduped)

tools/lib/bpf/btf.c

4211

if (!d->btf->base_btf) {

tools/lib/bpf/btf.c

422

__u32 l_cnt = btf->hdr.layout_len / sizeof(struct btf_layout);

tools/lib/bpf/btf.c

4226

strset__free(d->btf->strs_set);

tools/lib/bpf/btf.c

4227

btf_hdr_update_str_len(d->btf, strset__data_size(d->strs_set));

tools/lib/bpf/btf.c

4228

d->btf->strs_set = d->strs_set;

tools/lib/bpf/btf.c

423

struct btf_layout *l = btf->layout;

tools/lib/bpf/btf.c

4230

d->btf->strs_deduped = true;

tools/lib/bpf/btf.c

429

struct btf *base_btf = btf->base_btf;

tools/lib/bpf/btf.c

454

static int btf_type_size(const struct btf *btf, const struct btf_type *t)

tools/lib/bpf/btf.c

4562

if (!d->btf->base_btf)

tools/lib/bpf/btf.c

4565

for (type_id = 1; type_id < d->btf->start_id; type_id++) {

tools/lib/bpf/btf.c

4566

t = btf_type_by_id(d->btf, type_id);

tools/lib/bpf/btf.c

4624

struct btf_type *t = btf_type_by_id(d->btf, type_id);

tools/lib/bpf/btf.c

4653

cand = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

4666

cand = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

4688

cand = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

4711

for (i = 0; i < d->btf->nr_types; i++) {

tools/lib/bpf/btf.c

4712

err = btf_dedup_prim_type(d, d->btf->start_id + i);

tools/lib/bpf/btf.c

4747

if (!btf_is_fwd(btf__type_by_id(d->btf, type_id)))

tools/lib/bpf/btf.c

4753

if (!btf_is_fwd(btf__type_by_id(d->btf, type_id)))

tools/lib/bpf/btf.c

4770

t1 = btf_type_by_id(d->btf, id1);

tools/lib/bpf/btf.c

4771

t2 = btf_type_by_id(d->btf, id2);

tools/lib/bpf/btf.c

4774

btf__name_by_offset(d->btf, t1->name_off),

tools/lib/bpf/btf.c

4775

btf__name_by_offset(d->btf, t2->name_off));

tools/lib/bpf/btf.c

4843

btf__name_by_offset(d->btf, t1->name_off),

tools/lib/bpf/btf.c

4845

btf__name_by_offset(d->btf, m1->name_off));

tools/lib/bpf/btf.c

490

return btf_type_size_unknown(btf, t);

tools/lib/bpf/btf.c

5011

cand_type = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

5012

canon_type = btf_type_by_id(d->btf, canon_id);

tools/lib/bpf/btf.c

5032

if (fwd_kind == real_kind && canon_id < d->btf->start_id)

tools/lib/bpf/btf.c

5093

btf__name_by_offset(d->btf, cand_type->name_off),

tools/lib/bpf/btf.c

5095

btf__name_by_offset(d->btf, cand_m->name_off), eq);

tools/lib/bpf/btf.c

5172

t_kind = btf_kind(btf__type_by_id(d->btf, t_id));

tools/lib/bpf/btf.c

5173

c_kind = btf_kind(btf__type_by_id(d->btf, c_id));

tools/lib/bpf/btf.c

5275

t = btf_type_by_id(d->btf, type_id);

tools/lib/bpf/btf.c

5298

cand_type = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

5326

for (i = 0; i < d->btf->nr_types; i++) {

tools/lib/bpf/btf.c

5327

err = btf_dedup_struct_type(d, d->btf->start_id + i);

tools/lib/bpf/btf.c

5372

t = btf_type_by_id(d->btf, type_id);

tools/lib/bpf/btf.c

5390

cand = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

5407

cand = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

5431

cand = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

5463

cand = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

5487

for (i = 0; i < d->btf->nr_types; i++) {

tools/lib/bpf/btf.c

5488

err = btf_dedup_ref_type(d, d->btf->start_id + i);

tools/lib/bpf/btf.c

5505

__u32 nr_types = btf__type_cnt(d->btf);

tools/lib/bpf/btf.c

5516

t = btf_type_by_id(d->btf, type_id);

tools/lib/bpf/btf.c

5539

struct btf_type *t = btf_type_by_id(d->btf, type_id);

tools/lib/bpf/btf.c

5559

cand_t = btf_type_by_id(d->btf, cand_id);

tools/lib/bpf/btf.c

5615

for (i = 0; i < d->btf->nr_types; i++) {

tools/lib/bpf/btf.c

5616

err = btf_dedup_resolve_fwd(d, names_map, d->btf->start_id + i);

tools/lib/bpf/btf.c

5640

__u32 next_type_id = d->btf->start_id;

tools/lib/bpf/btf.c

5648

for (id = 1; id < d->btf->start_id; id++)

tools/lib/bpf/btf.c

5650

for (i = 0, id = d->btf->start_id; i < d->btf->nr_types; i++, id++)

tools/lib/bpf/btf.c

5653

p = d->btf->types_data;

tools/lib/bpf/btf.c

5655

for (i = 0, id = d->btf->start_id; i < d->btf->nr_types; i++, id++) {

tools/lib/bpf/btf.c

5659

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf.c

5660

len = btf_type_size(d->btf, t);

tools/lib/bpf/btf.c

5666

d->btf->type_offs[next_type_id - d->btf->start_id] = p - d->btf->types_data;

tools/lib/bpf/btf.c

5672

d->btf->nr_types = next_type_id - d->btf->start_id;

tools/lib/bpf/btf.c

5673

d->btf->type_offs_cap = d->btf->nr_types;

tools/lib/bpf/btf.c

5674

d->btf->hdr.type_len = p - d->btf->types_data;

tools/lib/bpf/btf.c

5675

new_offs = libbpf_reallocarray(d->btf->type_offs, d->btf->type_offs_cap,

tools/lib/bpf/btf.c

5677

if (d->btf->type_offs_cap && !new_offs)

tools/lib/bpf/btf.c

5679

d->btf->type_offs = new_offs;

tools/lib/bpf/btf.c

5680

if (d->btf->layout)

tools/lib/bpf/btf.c

5681

d->btf->hdr.layout_off = d->btf->hdr.type_off + d->btf->hdr.type_len;

tools/lib/bpf/btf.c

5682

d->btf->hdr.str_off = d->btf->hdr.type_off + d->btf->hdr.type_len + d->btf->hdr.layout_len;

tools/lib/bpf/btf.c

5683

d->btf->raw_size = d->btf->hdr.hdr_len + d->btf->hdr.type_off + d->btf->hdr.type_len +

tools/lib/bpf/btf.c

5684

d->btf->hdr.layout_len + d->btf->hdr.str_len;

tools/lib/bpf/btf.c

5722

for (i = 0; i < d->btf->nr_types; i++) {

tools/lib/bpf/btf.c

5723

struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i);

tools/lib/bpf/btf.c

5757

struct btf *btf__load_vmlinux_btf(void)

tools/lib/bpf/btf.c

5772

struct btf *btf;

tools/lib/bpf/btf.c

578

static int btf_parse_type_sec(struct btf *btf)

tools/lib/bpf/btf.c

5780

btf = btf_parse_raw_mmap(sysfs_btf_path, NULL);

tools/lib/bpf/btf.c

5781

if (IS_ERR(btf))

tools/lib/bpf/btf.c

5782

btf = btf__parse(sysfs_btf_path, NULL);

tools/lib/bpf/btf.c

5784

if (!btf) {

tools/lib/bpf/btf.c

5791

return btf;

tools/lib/bpf/btf.c

580

void *next_type = btf->types_data;

tools/lib/bpf/btf.c

5802

btf = btf__parse(path, NULL);

tools/lib/bpf/btf.c

5803

err = libbpf_get_error(btf);

tools/lib/bpf/btf.c

5808

return btf;

tools/lib/bpf/btf.c

581

void *end_type = next_type + btf->hdr.type_len;

tools/lib/bpf/btf.c

5815

struct btf *libbpf_find_kernel_btf(void) __attribute__((alias("btf__load_vmlinux_btf")));

tools/lib/bpf/btf.c

5817

struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_btf)

tools/lib/bpf/btf.c

585

if (btf->swapped_endian)

tools/lib/bpf/btf.c

588

type_size = btf_type_size(btf, next_type);

tools/lib/bpf/btf.c

592

pr_warn("BTF type [%d] is malformed\n", btf->start_id + btf->nr_types);

tools/lib/bpf/btf.c

596

if (btf->swapped_endian && btf_bswap_type_rest(next_type))

tools/lib/bpf/btf.c

599

err = btf_add_type_idx_entry(btf, next_type - btf->types_data);

tools/lib/bpf/btf.c

604

btf->nr_types++;

tools/lib/bpf/btf.c

6108

int btf__distill_base(const struct btf *src_btf, struct btf **new_base_btf,

tools/lib/bpf/btf.c

6109

struct btf **new_split_btf)

tools/lib/bpf/btf.c

6111

struct btf *new_base = NULL, *new_split = NULL;

tools/lib/bpf/btf.c

6112

const struct btf *old_base;

tools/lib/bpf/btf.c

615

static int btf_validate_str(const struct btf *btf, __u32 str_off, const char *what, __u32 type_id)

tools/lib/bpf/btf.c

619

s = btf__str_by_offset(btf, str_off);

tools/lib/bpf/btf.c

6209

const struct btf_header *btf_header(const struct btf *btf)

tools/lib/bpf/btf.c

6211

return &btf->hdr;

tools/lib/bpf/btf.c

6214

void btf_set_base_btf(struct btf *btf, const struct btf *base_btf)

tools/lib/bpf/btf.c

6216

btf->base_btf = (struct btf *)base_btf;

tools/lib/bpf/btf.c

6217

btf->start_id = btf__type_cnt(base_btf);

tools/lib/bpf/btf.c

6218

btf->start_str_off = base_btf->hdr.str_len + base_btf->start_str_off;

tools/lib/bpf/btf.c

6221

int btf__relocate(struct btf *btf, const struct btf *base_btf)

tools/lib/bpf/btf.c

6223

int err = btf_relocate(btf, base_btf, NULL);

tools/lib/bpf/btf.c

6226

btf->owns_base = false;

tools/lib/bpf/btf.c

6231

struct btf *btf;

tools/lib/bpf/btf.c

6243

if (new_id < p->btf->start_id)

tools/lib/bpf/btf.c

6246

if (new_id >= btf__type_cnt(p->btf))

tools/lib/bpf/btf.c

6249

*type_id = p->id_map[new_id - p->btf->start_id + p->start_offs];

tools/lib/bpf/btf.c

6253

int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_cnt,

tools/lib/bpf/btf.c

6266

if (btf__base_btf(btf)) {

tools/lib/bpf/btf.c

6267

n = btf->nr_types;

tools/lib/bpf/btf.c

6271

n = btf__type_cnt(btf);

tools/lib/bpf/btf.c

628

static int btf_validate_id(const struct btf *btf, __u32 id, __u32 ctx_id)

tools/lib/bpf/btf.c

6285

new_types = calloc(btf->hdr.type_len, 1);

tools/lib/bpf/btf.c

6291

err = btf_ensure_modifiable(btf);

tools/lib/bpf/btf.c

6297

if (id < btf->start_id || id >= btf__type_cnt(btf)) {

tools/lib/bpf/btf.c

6301

id -= btf->start_id - start_offs;

tools/lib/bpf/btf.c

6307

order_map[id] = i + btf->start_id - start_offs;

tools/lib/bpf/btf.c

6310

p.btf = btf;

tools/lib/bpf/btf.c

632

t = btf__type_by_id(btf, id);

tools/lib/bpf/btf.c

6321

t = btf__type_by_id(btf, id);

tools/lib/bpf/btf.c

6322

type_size = btf_type_size(btf, t);

tools/lib/bpf/btf.c

6347

btf->type_offs[i] = nt - new_types;

tools/lib/bpf/btf.c

6348

nt += btf_type_size(btf, nt);

tools/lib/bpf/btf.c

6352

free(btf->types_data);

tools/lib/bpf/btf.c

6353

btf->types_data = new_types;

tools/lib/bpf/btf.c

641

static int btf_validate_type(const struct btf *btf, const struct btf_type *t, __u32 id)

tools/lib/bpf/btf.c

646

err = btf_validate_str(btf, t->name_off, "type name", id);

tools/lib/bpf/btf.c

664

err = btf_validate_id(btf, t->type, id);

tools/lib/bpf/btf.c

671

err = btf_validate_id(btf, a->type, id);

tools/lib/bpf/btf.c

672

err = err ?: btf_validate_id(btf, a->index_type, id);

tools/lib/bpf/btf.c

683

err = btf_validate_str(btf, m->name_off, "field name", id);

tools/lib/bpf/btf.c

684

err = err ?: btf_validate_id(btf, m->type, id);

tools/lib/bpf/btf.c

695

err = btf_validate_str(btf, m->name_off, "enum name", id);

tools/lib/bpf/btf.c

706

err = btf_validate_str(btf, m->name_off, "enum name", id);

tools/lib/bpf/btf.c

715

err = btf_validate_id(btf, t->type, id);

tools/lib/bpf/btf.c

718

ft = btf__type_by_id(btf, t->type);

tools/lib/bpf/btf.c

730

err = btf_validate_str(btf, m->name_off, "param name", id);

tools/lib/bpf/btf.c

731

err = err ?: btf_validate_id(btf, m->type, id);

tools/lib/bpf/btf.c

742

err = btf_validate_id(btf, m->type, id);

tools/lib/bpf/btf.c

750

if (btf_type_size_unknown(btf, t) < 0) {

tools/lib/bpf/btf.c

763

static int btf_sanity_check(const struct btf *btf)

tools/lib/bpf/btf.c

766

__u32 i, n = btf__type_cnt(btf);

tools/lib/bpf/btf.c

769

for (i = btf->start_id; i < n; i++) {

tools/lib/bpf/btf.c

770

t = btf_type_by_id(btf, i);

tools/lib/bpf/btf.c

771

err = btf_validate_type(btf, t, i);

tools/lib/bpf/btf.c

778

__u32 btf__type_cnt(const struct btf *btf)

tools/lib/bpf/btf.c

780

return btf->start_id + btf->nr_types;

tools/lib/bpf/btf.c

783

const struct btf *btf__base_btf(const struct btf *btf)

tools/lib/bpf/btf.c

785

return btf->base_btf;

tools/lib/bpf/btf.c

789

struct btf_type *btf_type_by_id(const struct btf *btf, __u32 type_id)

tools/lib/bpf/btf.c

793

if (type_id < btf->start_id)

tools/lib/bpf/btf.c

794

return btf_type_by_id(btf->base_btf, type_id);

tools/lib/bpf/btf.c

795

return btf->types_data + btf->type_offs[type_id - btf->start_id];

tools/lib/bpf/btf.c

798

const struct btf_type *btf__type_by_id(const struct btf *btf, __u32 type_id)

tools/lib/bpf/btf.c

800

if (type_id >= btf->start_id + btf->nr_types)

tools/lib/bpf/btf.c

802

return btf_type_by_id((struct btf *)btf, type_id);

tools/lib/bpf/btf.c

805

static int determine_ptr_size(const struct btf *btf)

tools/lib/bpf/btf.c

824

if (btf->base_btf && btf->base_btf->ptr_sz > 0)

tools/lib/bpf/btf.c

825

return btf->base_btf->ptr_sz;

tools/lib/bpf/btf.c

827

n = btf__type_cnt(btf);

tools/lib/bpf/btf.c

829

t = btf__type_by_id(btf, i);

tools/lib/bpf/btf.c

836

name = btf__name_by_offset(btf, t->name_off);

tools/lib/bpf/btf.c

849

static size_t btf_ptr_sz(const struct btf *btf)

tools/lib/bpf/btf.c

851

if (!btf->ptr_sz)

tools/lib/bpf/btf.c

852

((struct btf *)btf)->ptr_sz = determine_ptr_size(btf);

tools/lib/bpf/btf.c

853

return btf->ptr_sz < 0 ? sizeof(void *) : btf->ptr_sz;

tools/lib/bpf/btf.c

864

size_t btf__pointer_size(const struct btf *btf)

tools/lib/bpf/btf.c

866

if (!btf->ptr_sz)

tools/lib/bpf/btf.c

867

((struct btf *)btf)->ptr_sz = determine_ptr_size(btf);

tools/lib/bpf/btf.c

869

if (btf->ptr_sz < 0)

tools/lib/bpf/btf.c

873

return btf->ptr_sz;

tools/lib/bpf/btf.c

879

int btf__set_pointer_size(struct btf *btf, size_t ptr_sz)

tools/lib/bpf/btf.c

883

btf->ptr_sz = ptr_sz;

tools/lib/bpf/btf.c

898

enum btf_endianness btf__endianness(const struct btf *btf)

tools/lib/bpf/btf.c

901

return btf->swapped_endian ? BTF_LITTLE_ENDIAN : BTF_BIG_ENDIAN;

tools/lib/bpf/btf.c

903

return btf->swapped_endian ? BTF_BIG_ENDIAN : BTF_LITTLE_ENDIAN;

tools/lib/bpf/btf.c

906

int btf__set_endianness(struct btf *btf, enum btf_endianness endian)

tools/lib/bpf/btf.c

911

btf->swapped_endian = is_host_big_endian() != (endian == BTF_BIG_ENDIAN);

tools/lib/bpf/btf.c

912

if (!btf->swapped_endian) {

tools/lib/bpf/btf.c

913

free(btf->raw_data_swapped);

tools/lib/bpf/btf.c

914

btf->raw_data_swapped = NULL;

tools/lib/bpf/btf.c

931

__s64 btf__resolve_size(const struct btf *btf, __u32 type_id)

tools/lib/bpf/btf.c

939

t = btf__type_by_id(btf, type_id);

tools/lib/bpf/btf.c

952

size = btf_ptr_sz(btf);

tools/lib/bpf/btf.c

974

t = btf__type_by_id(btf, type_id);

tools/lib/bpf/btf.c

986

int btf__align_of(const struct btf *btf, __u32 id)

tools/lib/bpf/btf.c

988

const struct btf_type *t = btf__type_by_id(btf, id);

tools/lib/bpf/btf.c

996

return min(btf_ptr_sz(btf), (size_t)t->size);

tools/lib/bpf/btf.c

998

return btf_ptr_sz(btf);

tools/lib/bpf/btf.h

110

LIBBPF_API struct btf *btf__new_empty_split(struct btf *base_btf);

tools/lib/bpf/btf.h

114

struct btf *base_btf; /* optional base BTF */

tools/lib/bpf/btf.h

130

LIBBPF_API struct btf *btf__new_empty_opts(struct btf_new_opts *opts);

tools/lib/bpf/btf.h

154

LIBBPF_API int btf__distill_base(const struct btf *src_btf, struct btf **new_base_btf,

tools/lib/bpf/btf.h

155

struct btf **new_split_btf);

tools/lib/bpf/btf.h

157

LIBBPF_API struct btf *btf__parse(const char *path, struct btf_ext **btf_ext);

tools/lib/bpf/btf.h

158

LIBBPF_API struct btf *btf__parse_split(const char *path, struct btf *base_btf);

tools/lib/bpf/btf.h

159

LIBBPF_API struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext);

tools/lib/bpf/btf.h

160

LIBBPF_API struct btf *btf__parse_elf_split(const char *path, struct btf *base_btf);

tools/lib/bpf/btf.h

161

LIBBPF_API struct btf *btf__parse_raw(const char *path);

tools/lib/bpf/btf.h

162

LIBBPF_API struct btf *btf__parse_raw_split(const char *path, struct btf *base_btf);

tools/lib/bpf/btf.h

164

LIBBPF_API struct btf *btf__load_vmlinux_btf(void);

tools/lib/bpf/btf.h

165

LIBBPF_API struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_btf);

tools/lib/bpf/btf.h

167

LIBBPF_API struct btf *btf__load_from_kernel_by_id(__u32 id);

tools/lib/bpf/btf.h

168

LIBBPF_API struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf);

tools/lib/bpf/btf.h

170

LIBBPF_API int btf__load_into_kernel(struct btf *btf);

tools/lib/bpf/btf.h

171

LIBBPF_API __s32 btf__find_by_name(const struct btf *btf,

tools/lib/bpf/btf.h

173

LIBBPF_API __s32 btf__find_by_name_kind(const struct btf *btf,

tools/lib/bpf/btf.h

175

LIBBPF_API __u32 btf__type_cnt(const struct btf *btf);

tools/lib/bpf/btf.h

176

LIBBPF_API const struct btf *btf__base_btf(const struct btf *btf);

tools/lib/bpf/btf.h

177

LIBBPF_API const struct btf_type *btf__type_by_id(const struct btf *btf,

tools/lib/bpf/btf.h

179

LIBBPF_API size_t btf__pointer_size(const struct btf *btf);

tools/lib/bpf/btf.h

180

LIBBPF_API int btf__set_pointer_size(struct btf *btf, size_t ptr_sz);

tools/lib/bpf/btf.h

181

LIBBPF_API enum btf_endianness btf__endianness(const struct btf *btf);

tools/lib/bpf/btf.h

182

LIBBPF_API int btf__set_endianness(struct btf *btf, enum btf_endianness endian);

tools/lib/bpf/btf.h

183

LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id);

tools/lib/bpf/btf.h

184

LIBBPF_API int btf__resolve_type(const struct btf *btf, __u32 type_id);

tools/lib/bpf/btf.h

185

LIBBPF_API int btf__align_of(const struct btf *btf, __u32 id);

tools/lib/bpf/btf.h

186

LIBBPF_API int btf__fd(const struct btf *btf);

tools/lib/bpf/btf.h

187

LIBBPF_API void btf__set_fd(struct btf *btf, int fd);

tools/lib/bpf/btf.h

188

LIBBPF_API const void *btf__raw_data(const struct btf *btf, __u32 *size);

tools/lib/bpf/btf.h

189

LIBBPF_API const char *btf__name_by_offset(const struct btf *btf, __u32 offset);

tools/lib/bpf/btf.h

190

LIBBPF_API const char *btf__str_by_offset(const struct btf *btf, __u32 offset);

tools/lib/bpf/btf.h

199

LIBBPF_API int btf__find_str(struct btf *btf, const char *s);

tools/lib/bpf/btf.h

200

LIBBPF_API int btf__add_str(struct btf *btf, const char *s);

tools/lib/bpf/btf.h

201

LIBBPF_API int btf__add_type(struct btf *btf, const struct btf *src_btf,

tools/lib/bpf/btf.h

224

LIBBPF_API int btf__add_btf(struct btf *btf, const struct btf *src_btf);

tools/lib/bpf/btf.h

226

LIBBPF_API int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding);

tools/lib/bpf/btf.h

227

LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz);

tools/lib/bpf/btf.h

228

LIBBPF_API int btf__add_ptr(struct btf *btf, int ref_type_id);

tools/lib/bpf/btf.h

229

LIBBPF_API int btf__add_array(struct btf *btf,

tools/lib/bpf/btf.h

232

LIBBPF_API int btf__add_struct(struct btf *btf, const char *name, __u32 sz);

tools/lib/bpf/btf.h

233

LIBBPF_API int btf__add_union(struct btf *btf, const char *name, __u32 sz);

tools/lib/bpf/btf.h

234

LIBBPF_API int btf__add_field(struct btf *btf, const char *name, int field_type_id,

tools/lib/bpf/btf.h

238

LIBBPF_API int btf__add_enum(struct btf *btf, const char *name, __u32 bytes_sz);

tools/lib/bpf/btf.h

239

LIBBPF_API int btf__add_enum_value(struct btf *btf, const char *name, __s64 value);

tools/lib/bpf/btf.h

24

struct btf;

tools/lib/bpf/btf.h

240

LIBBPF_API int btf__add_enum64(struct btf *btf, const char *name, __u32 bytes_sz, bool is_signed);

tools/lib/bpf/btf.h

241

LIBBPF_API int btf__add_enum64_value(struct btf *btf, const char *name, __u64 value);

tools/lib/bpf/btf.h

249

LIBBPF_API int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind);

tools/lib/bpf/btf.h

250

LIBBPF_API int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id);

tools/lib/bpf/btf.h

251

LIBBPF_API int btf__add_volatile(struct btf *btf, int ref_type_id);

tools/lib/bpf/btf.h

252

LIBBPF_API int btf__add_const(struct btf *btf, int ref_type_id);

tools/lib/bpf/btf.h

253

LIBBPF_API int btf__add_restrict(struct btf *btf, int ref_type_id);

tools/lib/bpf/btf.h

254

LIBBPF_API int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id);

tools/lib/bpf/btf.h

255

LIBBPF_API int btf__add_type_attr(struct btf *btf, const char *value, int ref_type_id);

tools/lib/bpf/btf.h

258

LIBBPF_API int btf__add_func(struct btf *btf, const char *name,

tools/lib/bpf/btf.h

260

LIBBPF_API int btf__add_func_proto(struct btf *btf, int ret_type_id);

tools/lib/bpf/btf.h

261

LIBBPF_API int btf__add_func_param(struct btf *btf, const char *name, int type_id);

tools/lib/bpf/btf.h

264

LIBBPF_API int btf__add_var(struct btf *btf, const char *name, int linkage, int type_id);

tools/lib/bpf/btf.h

265

LIBBPF_API int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz);

tools/lib/bpf/btf.h

266

LIBBPF_API int btf__add_datasec_var_info(struct btf *btf, int var_type_id,

tools/lib/bpf/btf.h

270

LIBBPF_API int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,

tools/lib/bpf/btf.h

272

LIBBPF_API int btf__add_decl_attr(struct btf *btf, const char *value, int ref_type_id,

tools/lib/bpf/btf.h

285

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

tools/lib/bpf/btf.h

302

LIBBPF_API int btf__relocate(struct btf *btf, const struct btf *base_btf);

tools/lib/bpf/btf.h

343

LIBBPF_API int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_cnt,

tools/lib/bpf/btf.h

355

LIBBPF_API struct btf_dump *btf_dump__new(const struct btf *btf,

tools/lib/bpf/btf.h

39

LIBBPF_API void btf__free(struct btf *btf);

tools/lib/bpf/btf.h

55

LIBBPF_API struct btf *btf__new(const void *data, __u32 size);

tools/lib/bpf/btf.h

77

LIBBPF_API struct btf *btf__new_split(const void *data, __u32 size, struct btf *base_btf);

tools/lib/bpf/btf.h

91

LIBBPF_API struct btf *btf__new_empty(void);

tools/lib/bpf/btf_dump.c

1007

m_sz = max((__s64)0, btf__resolve_size(d->btf, m->type));

tools/lib/bpf/btf_dump.c

1300

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

134

return btf__name_by_offset(d->btf, name_off);

tools/lib/bpf/btf_dump.c

1379

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

1405

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

1449

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

149

struct btf_dump *btf_dump__new(const struct btf *btf,

tools/lib/bpf/btf_dump.c

1529

next_t = btf__type_by_id(d->btf, next_id);

tools/lib/bpf/btf_dump.c

1623

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

1668

const struct btf_type *t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

167

d->btf = btf;

tools/lib/bpf/btf_dump.c

170

d->ptr_sz = btf__pointer_size(btf) ? : sizeof(void *);

tools/lib/bpf/btf_dump.c

1867

static bool ptr_is_aligned(const struct btf *btf, __u32 type_id,

tools/lib/bpf/btf_dump.c

1870

int alignment = btf__align_of(btf, type_id);

tools/lib/bpf/btf_dump.c

1897

if (!ptr_is_aligned(d->btf, type_id, data)) {

tools/lib/bpf/btf_dump.c

197

int err, last_id = btf__type_cnt(d->btf) - 1;

tools/lib/bpf/btf_dump.c

1987

if (!ptr_is_aligned(d->btf, type_id, data)) {

tools/lib/bpf/btf_dump.c

2037

t = btf__type_by_id(d->btf, type_id);

tools/lib/bpf/btf_dump.c

2102

elem_type = skip_mods_and_typedefs(d->btf, elem_type_id, NULL);

tools/lib/bpf/btf_dump.c

2103

elem_size = btf__resolve_size(d->btf, elem_type_id);

tools/lib/bpf/btf_dump.c

2181

mtype = btf__type_by_id(d->btf, m->type);

tools/lib/bpf/btf_dump.c

2207

if (ptr_is_aligned(d->btf, id, data) && d->ptr_sz == sizeof(void *)) {

tools/lib/bpf/btf_dump.c

2229

if (!ptr_is_aligned(d->btf, id, data)) {

tools/lib/bpf/btf_dump.c

2313

var = btf__type_by_id(d->btf, vsi->type);

tools/lib/bpf/btf_dump.c

2345

size = btf__resolve_size(d->btf, id);

tools/lib/bpf/btf_dump.c

2360

t = skip_mods_and_typedefs(d->btf, id, NULL);

tools/lib/bpf/btf_dump.c

2408

t = skip_mods_and_typedefs(d->btf, id, NULL);

tools/lib/bpf/btf_dump.c

2425

elem_size = btf__resolve_size(d->btf, elem_type_id);

tools/lib/bpf/btf_dump.c

2426

elem_type = skip_mods_and_typedefs(d->btf, elem_type_id, NULL);

tools/lib/bpf/btf_dump.c

2461

mtype = btf__type_by_id(d->btf, m->type);

tools/lib/bpf/btf_dump.c

2520

t = skip_mods_and_typedefs(d->btf, id, NULL);

tools/lib/bpf/btf_dump.c

2592

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

285

if (id >= btf__type_cnt(d->btf))

tools/lib/bpf/btf_dump.c

317

int i, j, n = btf__type_cnt(d->btf);

tools/lib/bpf/btf_dump.c

322

t = btf__type_by_id(d->btf, i);

tools/lib/bpf/btf_dump.c

495

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

658

const struct btf_type *t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

699

t = btf__type_by_id(d->btf, id);

tools/lib/bpf/btf_dump.c

81

const struct btf *btf;

tools/lib/bpf/btf_dump.c

837

static bool btf_is_struct_packed(const struct btf *btf, __u32 id,

tools/lib/bpf/btf_dump.c

848

align = btf__align_of(btf, m->type);

tools/lib/bpf/btf_dump.c

978

align = btf__align_of(d->btf, id);

tools/lib/bpf/btf_dump.c

979

packed = is_struct ? btf_is_struct_packed(d->btf, id, t) : 0;

tools/lib/bpf/btf_dump.c

994

m_align = packed ? 1 : btf__align_of(d->btf, m->type);

tools/lib/bpf/btf_relocate.c

134

struct btf_type *t = btf_type_by_id(r->btf, i);

tools/lib/bpf/btf_relocate.c

150

t = btf_type_by_id(r->btf, next_id);

tools/lib/bpf/btf_relocate.c

36

struct btf;

tools/lib/bpf/btf_relocate.c

39

struct btf *btf;

tools/lib/bpf/btf_relocate.c

40

const struct btf *base_btf;

tools/lib/bpf/btf_relocate.c

41

const struct btf *dist_base_btf;

tools/lib/bpf/btf_relocate.c

414

struct btf_type *t = btf_type_by_id(r->btf, i);

tools/lib/bpf/btf_relocate.c

432

btf__str_by_offset(r->btf, off), *str_off);

tools/lib/bpf/btf_relocate.c

444

int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **id_map)

tools/lib/bpf/btf_relocate.c

446

unsigned int nr_types = btf__type_cnt(btf);

tools/lib/bpf/btf_relocate.c

453

r.dist_base_btf = btf__base_btf(btf);

tools/lib/bpf/btf_relocate.c

460

r.btf = btf;

tools/lib/bpf/btf_relocate.c

509

btf_set_base_btf(btf, base_btf);

tools/lib/bpf/btf_relocate.c

68

struct btf_type *t = btf_type_by_id(r->btf, i);

tools/lib/bpf/gen_loader.c

495

emit_rel_store(gen, attr_field(btf_load_attr, btf), btf_data);

tools/lib/bpf/libbpf.c

1015

find_member_by_name(const struct btf *btf, const struct btf_type *t,

tools/lib/bpf/libbpf.c

1022

if (!strcmp(btf__name_by_offset(btf, m->name_off), name))

tools/lib/bpf/libbpf.c

1030

__u16 kind, struct btf **res_btf,

tools/lib/bpf/libbpf.c

1034

static int find_btf_by_prefix_kind(const struct btf *btf, const char *prefix,

tools/lib/bpf/libbpf.c

10361

const struct btf *btf;

tools/lib/bpf/libbpf.c

10370

btf = obj->btf;

tools/lib/bpf/libbpf.c

10416

type = btf__type_by_id(btf, st_ops->type_id);

tools/lib/bpf/libbpf.c

10424

name = btf__name_by_offset(btf, member->name_off);

tools/lib/bpf/libbpf.c

10426

if (!resolve_func_ptr(btf, member->type, NULL)) {

tools/lib/bpf/libbpf.c

1046

struct btf *btf = NULL;

tools/lib/bpf/libbpf.c

10488

static int find_btf_by_prefix_kind(const struct btf *btf, const char *prefix,

tools/lib/bpf/libbpf.c

10502

return btf__find_by_name_kind(btf, btf_type_name, kind);

tools/lib/bpf/libbpf.c

10505

static inline int find_attach_btf_id(struct btf *btf, const char *name,

tools/lib/bpf/libbpf.c

10512

return find_btf_by_prefix_kind(btf, prefix, name, kind);

tools/lib/bpf/libbpf.c

10518

struct btf *btf;

tools/lib/bpf/libbpf.c

10521

btf = btf__load_vmlinux_btf();

tools/lib/bpf/libbpf.c

10522

err = libbpf_get_error(btf);

tools/lib/bpf/libbpf.c

10528

err = find_attach_btf_id(btf, name, attach_type);

tools/lib/bpf/libbpf.c

10532

btf__free(btf);

tools/lib/bpf/libbpf.c

10540

struct btf *btf;

tools/lib/bpf/libbpf.c

10556

btf = btf_load_from_kernel(info.btf_id, NULL, token_fd);

tools/lib/bpf/libbpf.c

10557

err = libbpf_get_error(btf);

tools/lib/bpf/libbpf.c

10562

err = btf__find_by_name_kind(btf, name, BTF_KIND_FUNC);

tools/lib/bpf/libbpf.c

10563

btf__free(btf);

tools/lib/bpf/libbpf.c

10609

ret = find_attach_btf_id(mod->btf,

tools/lib/bpf/libbpf.c

1061

kern_vtype_id = find_ksym_btf_id(obj, stname, BTF_KIND_STRUCT, &btf, mod_btf);

tools/lib/bpf/libbpf.c

1066

kern_vtype = btf__type_by_id(btf, kern_vtype_id);

tools/lib/bpf/libbpf.c

1068

kern_type_id = btf__find_by_name_kind(btf, tname, BTF_KIND_STRUCT);

tools/lib/bpf/libbpf.c

1073

kern_type = btf__type_by_id(btf, kern_type_id);

tools/lib/bpf/libbpf.c

10805

struct btf *btf;

tools/lib/bpf/libbpf.c

10814

btf = bpf_object__btf(map->obj);

tools/lib/bpf/libbpf.c

10815

if (!btf)

tools/lib/bpf/libbpf.c

10819

datasec_type = btf_type_by_id(btf, bpf_map__btf_value_type_id(map));

tools/lib/bpf/libbpf.c

10836

var_type = btf_type_by_id(btf, var->type);

tools/lib/bpf/libbpf.c

10837

array_type = skip_mods_and_typedefs(btf, var_type->type, NULL);

tools/lib/bpf/libbpf.c

10846

element_sz = btf__resolve_size(btf, array->type);

tools/lib/bpf/libbpf.c

10855

new_array_id = btf__add_array(btf, array->index_type, array->type, nr_elements);

tools/lib/bpf/libbpf.c

10862

datasec_type = btf_type_by_id(btf, map->btf_value_type_id);

tools/lib/bpf/libbpf.c

10864

var_type = btf_type_by_id(btf, var->type);

tools/lib/bpf/libbpf.c

1145

type = btf__type_by_id(obj->btf, map->st_ops->type_id);

tools/lib/bpf/libbpf.c

1171

const struct btf *btf = obj->btf;

tools/lib/bpf/libbpf.c

1173

const struct btf *kern_btf;

tools/lib/bpf/libbpf.c

1180

type = btf__type_by_id(btf, st_ops->type_id);

tools/lib/bpf/libbpf.c

1181

tname = btf__name_by_offset(btf, type->name_off);

tools/lib/bpf/libbpf.c

1189

kern_btf = mod_btf ? mod_btf->btf : obj->btf_vmlinux;

tools/lib/bpf/libbpf.c

1217

mname = btf__name_by_offset(btf, member->name_off);

tools/lib/bpf/libbpf.c

1220

msize = btf__resolve_size(btf, member->type);

tools/lib/bpf/libbpf.c

1264

mtype = skip_mods_and_typedefs(btf, member->type, &mtype_id);

tools/lib/bpf/libbpf.c

1395

const struct btf *btf;

tools/lib/bpf/libbpf.c

1402

btf = obj->btf;

tools/lib/bpf/libbpf.c

1403

datasec_id = btf__find_by_name_kind(btf, sec_name,

tools/lib/bpf/libbpf.c

1411

datasec = btf__type_by_id(btf, datasec_id);

tools/lib/bpf/libbpf.c

1414

type = btf__type_by_id(obj->btf, vsi->type);

tools/lib/bpf/libbpf.c

1415

var_name = btf__name_by_offset(obj->btf, type->name_off);

tools/lib/bpf/libbpf.c

1417

type_id = btf__resolve_type(obj->btf, vsi->type);

tools/lib/bpf/libbpf.c

1424

type = btf__type_by_id(obj->btf, type_id);

tools/lib/bpf/libbpf.c

1425

tname = btf__name_by_offset(obj->btf, type->name_off);

tools/lib/bpf/libbpf.c

14562

struct btf *btf;

tools/lib/bpf/libbpf.c

14571

btf = bpf_object__btf(s->obj);

tools/lib/bpf/libbpf.c

14572

if (!btf) {

tools/lib/bpf/libbpf.c

14594

map_type = btf__type_by_id(btf, map_type_id);

tools/lib/bpf/libbpf.c

14606

var_type = btf__type_by_id(btf, var->type);

tools/lib/bpf/libbpf.c

14607

var_name = btf__name_by_offset(btf, var_type->name_off);

tools/lib/bpf/libbpf.c

1939

t = btf__type_by_id(obj->btf, map->btf_value_type_id);

tools/lib/bpf/libbpf.c

1945

vt = btf__type_by_id(obj->btf, vsi->type);

tools/lib/bpf/libbpf.c

2399

skip_mods_and_typedefs(const struct btf *btf, __u32 id, __u32 *res_id)

tools/lib/bpf/libbpf.c

2401

const struct btf_type *t = btf__type_by_id(btf, id);

tools/lib/bpf/libbpf.c

2409

t = btf__type_by_id(btf, t->type);

tools/lib/bpf/libbpf.c

2416

resolve_func_ptr(const struct btf *btf, __u32 id, __u32 *res_id)

tools/lib/bpf/libbpf.c

2420

t = skip_mods_and_typedefs(btf, id, NULL);

tools/lib/bpf/libbpf.c

2424

t = skip_mods_and_typedefs(btf, t->type, res_id);

tools/lib/bpf/libbpf.c

2468

static bool get_map_field_int(const char *map_name, const struct btf *btf,

tools/lib/bpf/libbpf.c

2471

const struct btf_type *t = skip_mods_and_typedefs(btf, m->type, NULL);

tools/lib/bpf/libbpf.c

2472

const char *name = btf__name_by_offset(btf, m->name_off);

tools/lib/bpf/libbpf.c

2482

arr_t = btf__type_by_id(btf, t->type);

tools/lib/bpf/libbpf.c

2498

static bool get_map_field_long(const char *map_name, const struct btf *btf,

tools/lib/bpf/libbpf.c

2501

const struct btf_type *t = skip_mods_and_typedefs(btf, m->type, NULL);

tools/lib/bpf/libbpf.c

2502

const char *name = btf__name_by_offset(btf, m->name_off);

tools/lib/bpf/libbpf.c

2508

ret = get_map_field_int(map_name, btf, m, &res32);

tools/lib/bpf/libbpf.c

2573

int parse_btf_map_def(const char *map_name, struct btf *btf,

tools/lib/bpf/libbpf.c

2585

const char *name = btf__name_by_offset(btf, m->name_off);

tools/lib/bpf/libbpf.c

2592

if (!get_map_field_int(map_name, btf, m, &map_def->map_type))

tools/lib/bpf/libbpf.c

2596

if (!get_map_field_int(map_name, btf, m, &map_def->max_entries))

tools/lib/bpf/libbpf.c

2600

if (!get_map_field_int(map_name, btf, m, &map_def->map_flags))

tools/lib/bpf/libbpf.c

2604

if (!get_map_field_int(map_name, btf, m, &map_def->numa_node))

tools/lib/bpf/libbpf.c

2610

if (!get_map_field_int(map_name, btf, m, &sz))

tools/lib/bpf/libbpf.c

2622

t = btf__type_by_id(btf, m->type);

tools/lib/bpf/libbpf.c

2633

sz = btf__resolve_size(btf, t->type);

tools/lib/bpf/libbpf.c

2650

if (!get_map_field_int(map_name, btf, m, &sz))

tools/lib/bpf/libbpf.c

2662

t = btf__type_by_id(btf, m->type);

tools/lib/bpf/libbpf.c

2673

sz = btf__resolve_size(btf, t->type);

tools/lib/bpf/libbpf.c

2716

t = btf__type_by_id(btf, m->type);

tools/lib/bpf/libbpf.c

2727

t = skip_mods_and_typedefs(btf, btf_array(t)->type, NULL);

tools/lib/bpf/libbpf.c

2733

t = skip_mods_and_typedefs(btf, t->type, NULL);

tools/lib/bpf/libbpf.c

2749

err = parse_btf_map_def(inner_map_name, btf, t, strict, inner_def, NULL);

tools/lib/bpf/libbpf.c

2761

if (!get_map_field_int(map_name, btf, m, &val))

tools/lib/bpf/libbpf.c

2773

if (!get_map_field_long(map_name, btf, m, &map_extra))

tools/lib/bpf/libbpf.c

2904

var = btf__type_by_id(obj->btf, vi->type);

tools/lib/bpf/libbpf.c

2906

map_name = btf__name_by_offset(obj->btf, var->name_off);

tools/lib/bpf/libbpf.c

2927

def = skip_mods_and_typedefs(obj->btf, var->type, NULL);

tools/lib/bpf/libbpf.c

2954

err = parse_btf_map_def(map->name, obj->btf, def, strict, &map_def, &inner_def);

tools/lib/bpf/libbpf.c

3039

nr_types = btf__type_cnt(obj->btf);

tools/lib/bpf/libbpf.c

3041

t = btf__type_by_id(obj->btf, i);

tools/lib/bpf/libbpf.c

3044

name = btf__name_by_offset(obj->btf, t->name_off);

tools/lib/bpf/libbpf.c

3148

struct btf *bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *orig_btf)

tools/lib/bpf/libbpf.c

3161

struct btf *btf = NULL;

tools/lib/bpf/libbpf.c

3205

btf = btf__new(new_raw_data, sz);

tools/lib/bpf/libbpf.c

3208

btf = btf__new(raw_data, sz);

tools/lib/bpf/libbpf.c

3210

err = libbpf_get_error(btf);

tools/lib/bpf/libbpf.c

3215

btf__set_pointer_size(btf, 8);

tools/lib/bpf/libbpf.c

3217

for (i = 1; i < btf__type_cnt(btf); i++) {

tools/lib/bpf/libbpf.c

3218

t = (struct btf_type *)btf__type_by_id(btf, i);

tools/lib/bpf/libbpf.c

3237

name = (char *)btf__name_by_offset(btf, t->name_off);

tools/lib/bpf/libbpf.c

3251

vt = (void *)btf__type_by_id(btf, v->type);

tools/lib/bpf/libbpf.c

3255

starts_with_qmark(btf__name_by_offset(btf, t->name_off))) {

tools/lib/bpf/libbpf.c

3259

name = (char *)btf__name_by_offset(btf, t->name_off);

tools/lib/bpf/libbpf.c

3292

enum64_placeholder_id = btf__add_int(btf, "enum64_placeholder", 1, 0);

tools/lib/bpf/libbpf.c

3294

btf__free(btf);

tools/lib/bpf/libbpf.c

3297

t = (struct btf_type *)btf__type_by_id(btf, i);

tools/lib/bpf/libbpf.c

3310

return btf;

tools/lib/bpf/libbpf.c

3332

obj->btf = btf__new(btf_data->d_buf, btf_data->d_size);

tools/lib/bpf/libbpf.c

3333

err = libbpf_get_error(obj->btf);

tools/lib/bpf/libbpf.c

3335

obj->btf = NULL;

tools/lib/bpf/libbpf.c

3340

btf__set_pointer_size(obj->btf, 8);

tools/lib/bpf/libbpf.c

3346

if (!obj->btf) {

tools/lib/bpf/libbpf.c

3386

sec_name = btf__name_by_offset(obj->btf, sec->sec_name_off);

tools/lib/bpf/libbpf.c

3413

static int btf_fixup_datasec(struct bpf_object *obj, struct btf *btf,

tools/lib/bpf/libbpf.c

3417

const char *sec_name = btf__name_by_offset(btf, t->name_off);

tools/lib/bpf/libbpf.c

3462

t_var = btf__type_by_id(btf, vsi->type);

tools/lib/bpf/libbpf.c

3472

var_name = btf__name_by_offset(btf, t_var->name_off);

tools/lib/bpf/libbpf.c

3510

if (!obj->btf)

tools/lib/bpf/libbpf.c

3513

n = btf__type_cnt(obj->btf);

tools/lib/bpf/libbpf.c

3515

struct btf_type *t = btf_type_by_id(obj->btf, i);

tools/lib/bpf/libbpf.c

3523

err = btf_fixup_datasec(obj, obj->btf, t);

tools/lib/bpf/libbpf.c

3611

struct btf *kern_btf = obj->btf;

tools/lib/bpf/libbpf.c

3615

if (!obj->btf)

tools/lib/bpf/libbpf.c

3644

n = btf__type_cnt(obj->btf);

tools/lib/bpf/libbpf.c

3646

t = btf_type_by_id(obj->btf, j);

tools/lib/bpf/libbpf.c

3650

name = btf__str_by_offset(obj->btf, t->name_off);

tools/lib/bpf/libbpf.c

3661

kern_btf = bpf_object__sanitize_btf(obj, obj->btf);

tools/lib/bpf/libbpf.c

3685

btf__set_fd(obj->btf, btf__fd(kern_btf));

tools/lib/bpf/libbpf.c

4114

static int find_extern_btf_id(const struct btf *btf, const char *ext_name)

tools/lib/bpf/libbpf.c

4120

if (!btf)

tools/lib/bpf/libbpf.c

4123

n = btf__type_cnt(btf);

tools/lib/bpf/libbpf.c

4125

t = btf__type_by_id(btf, i);

tools/lib/bpf/libbpf.c

4130

tname = btf__name_by_offset(btf, t->name_off);

tools/lib/bpf/libbpf.c

4147

static int find_extern_sec_btf_id(struct btf *btf, int ext_btf_id) {

tools/lib/bpf/libbpf.c

4152

if (!btf)

tools/lib/bpf/libbpf.c

4155

n = btf__type_cnt(btf);

tools/lib/bpf/libbpf.c

4157

t = btf__type_by_id(btf, i);

tools/lib/bpf/libbpf.c

4172

static enum kcfg_type find_kcfg_type(const struct btf *btf, int id,

tools/lib/bpf/libbpf.c

4178

t = skip_mods_and_typedefs(btf, id, NULL);

tools/lib/bpf/libbpf.c

4179

name = btf__name_by_offset(btf, t->name_off);

tools/lib/bpf/libbpf.c

4210

if (find_kcfg_type(btf, btf_array(t)->type, NULL) != KCFG_CHAR)

tools/lib/bpf/libbpf.c

4239

static int find_int_btf_id(const struct btf *btf)

tools/lib/bpf/libbpf.c

4244

n = btf__type_cnt(btf);

tools/lib/bpf/libbpf.c

4246

t = btf__type_by_id(btf, i);

tools/lib/bpf/libbpf.c

4255

static int add_dummy_ksym_var(struct btf *btf)

tools/lib/bpf/libbpf.c

4261

if (!btf)

tools/lib/bpf/libbpf.c

4264

sec_btf_id = btf__find_by_name_kind(btf, KSYMS_SEC,

tools/lib/bpf/libbpf.c

4269

sec = btf__type_by_id(btf, sec_btf_id);

tools/lib/bpf/libbpf.c

4274

vt = btf__type_by_id(btf, vs->type);

tools/lib/bpf/libbpf.c

4283

int_btf_id = find_int_btf_id(btf);

tools/lib/bpf/libbpf.c

4284

dummy_var_btf_id = btf__add_var(btf,

tools/lib/bpf/libbpf.c

4313

dummy_var_btf_id = add_dummy_ksym_var(obj->btf);

tools/lib/bpf/libbpf.c

4340

ext->btf_id = find_extern_btf_id(obj->btf, ext_name);

tools/lib/bpf/libbpf.c

4346

t = btf__type_by_id(obj->btf, ext->btf_id);

tools/lib/bpf/libbpf.c

4347

ext->name = strdup(btf__name_by_offset(obj->btf, t->name_off));

tools/lib/bpf/libbpf.c

4361

ext->sec_btf_id = find_extern_sec_btf_id(obj->btf, ext->btf_id);

tools/lib/bpf/libbpf.c

4367

sec = (void *)btf__type_by_id(obj->btf, ext->sec_btf_id);

tools/lib/bpf/libbpf.c

4368

sec_name = btf__name_by_offset(obj->btf, sec->name_off);

tools/lib/bpf/libbpf.c

4378

ext->kcfg.sz = btf__resolve_size(obj->btf, t->type);

tools/lib/bpf/libbpf.c

4384

ext->kcfg.align = btf__align_of(obj->btf, t->type);

tools/lib/bpf/libbpf.c

4390

ext->kcfg.type = find_kcfg_type(obj->btf, t->type,

tools/lib/bpf/libbpf.c

4399

skip_mods_and_typedefs(obj->btf, t->type,

tools/lib/bpf/libbpf.c

4422

int int_btf_id = find_int_btf_id(obj->btf);

tools/lib/bpf/libbpf.c

4430

dummy_var = btf__type_by_id(obj->btf, dummy_var_btf_id);

tools/lib/bpf/libbpf.c

4445

vt = (void *)btf__type_by_id(obj->btf, vs->type);

tools/lib/bpf/libbpf.c

4446

ext_name = btf__name_by_offset(obj->btf, vt->name_off);

tools/lib/bpf/libbpf.c

4458

func_proto = btf__type_by_id(obj->btf,

tools/lib/bpf/libbpf.c

4500

t = btf__type_by_id(obj->btf, vs->type);

tools/lib/bpf/libbpf.c

4501

ext_name = btf__name_by_offset(obj->btf, t->name_off);

tools/lib/bpf/libbpf.c

4930

if (!obj->btf)

tools/lib/bpf/libbpf.c

4947

id = btf__find_by_name(obj->btf, map->real_name);

tools/lib/bpf/libbpf.c

5394

if (obj->btf && btf__fd(obj->btf) >= 0) {

tools/lib/bpf/libbpf.c

5395

create_attr.btf_fd = btf__fd(obj->btf);

tools/lib/bpf/libbpf.c

5755

const struct btf *targ_btf,

tools/lib/bpf/libbpf.c

5766

local_t = btf__type_by_id(local_cand->btf, local_cand->id);

tools/lib/bpf/libbpf.c

5767

local_name = btf__str_by_offset(local_cand->btf, local_t->name_off);

tools/lib/bpf/libbpf.c

5796

cand->btf = targ_btf;

tools/lib/bpf/libbpf.c

5809

struct btf *btf;

tools/lib/bpf/libbpf.c

5855

btf = NULL;

tools/lib/bpf/libbpf.c

5869

btf = btf_get_from_fd(fd, obj->btf_vmlinux);

tools/lib/bpf/libbpf.c

5870

err = libbpf_get_error(btf);

tools/lib/bpf/libbpf.c

5884

mod_btf->btf = btf;

tools/lib/bpf/libbpf.c

5896

btf__free(btf);

tools/lib/bpf/libbpf.c

5903

bpf_core_find_cands(struct bpf_object *obj, const struct btf *local_btf, __u32 local_type_id)

tools/lib/bpf/libbpf.c

5907

const struct btf *main_btf;

tools/lib/bpf/libbpf.c

5913

local_cand.btf = local_btf;

tools/lib/bpf/libbpf.c

5949

obj->btf_modules[i].btf,

tools/lib/bpf/libbpf.c

5982

int bpf_core_types_are_compat(const struct btf *local_btf, __u32 local_id,

tools/lib/bpf/libbpf.c

5983

const struct btf *targ_btf, __u32 targ_id)

tools/lib/bpf/libbpf.c

5988

int bpf_core_types_match(const struct btf *local_btf, __u32 local_id,

tools/lib/bpf/libbpf.c

5989

const struct btf *targ_btf, __u32 targ_id)

tools/lib/bpf/libbpf.c

6041

const struct btf *local_btf,

tools/lib/bpf/libbpf.c

6119

sec_name = btf__name_by_offset(obj->btf, sec->sec_name_off);

tools/lib/bpf/libbpf.c

6170

err = bpf_core_resolve_relo(prog, rec, i, obj->btf, cand_cache, &targ_res);

tools/lib/bpf/libbpf.c

650

struct btf *btf;

tools/lib/bpf/libbpf.c

7032

if (!obj->btf || !kernel_supports(obj, FEAT_BTF_DECL_TAG))

tools/lib/bpf/libbpf.c

7035

n = btf__type_cnt(obj->btf);

tools/lib/bpf/libbpf.c

7040

t = btf_type_by_id(obj->btf, i);

tools/lib/bpf/libbpf.c

7044

name = btf__str_by_offset(obj->btf, t->name_off);

tools/lib/bpf/libbpf.c

7048

t = btf_type_by_id(obj->btf, t->type);

tools/lib/bpf/libbpf.c

7054

if (strcmp(prog->name, btf__str_by_offset(obj->btf, t->name_off)) != 0)

tools/lib/bpf/libbpf.c

7148

static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

7156

t = skip_mods_and_typedefs(btf, arg_type_id, NULL);

tools/lib/bpf/libbpf.c

7165

t = btf__type_by_id(btf, t->type);

tools/lib/bpf/libbpf.c

7168

tname = btf__str_by_offset(btf, t->name_off) ?: "<anon>";

tools/lib/bpf/libbpf.c

7174

t = skip_mods_and_typedefs(btf, t->type, NULL);

tools/lib/bpf/libbpf.c

7181

tname = btf__str_by_offset(btf, t->name_off) ?: "<anon>";

tools/lib/bpf/libbpf.c

7219

static int clone_func_btf_info(struct btf *btf, int orig_fn_id, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7227

fn_t = btf_type_by_id(btf, orig_fn_id);

tools/lib/bpf/libbpf.c

7228

fn_proto_t = btf_type_by_id(btf, fn_t->type);

tools/lib/bpf/libbpf.c

7246

fn_proto_id = btf__add_func_proto(btf, ret_type_id);

tools/lib/bpf/libbpf.c

7254

t = btf_type_by_id(btf, orig_proto_id);

tools/lib/bpf/libbpf.c

7258

err = btf__add_func_param(btf, "", p->type);

tools/lib/bpf/libbpf.c

7262

fn_proto_t = btf_type_by_id(btf, fn_proto_id);

tools/lib/bpf/libbpf.c

7271

fn_id = btf__add_func(btf, prog->name, linkage, fn_proto_id);

tools/lib/bpf/libbpf.c

7275

fn_t = btf_type_by_id(btf, fn_id);

tools/lib/bpf/libbpf.c

728

struct btf *btf;

tools/lib/bpf/libbpf.c

7293

struct btf *btf = obj->btf;

tools/lib/bpf/libbpf.c

7333

for (i = 1, n = btf__type_cnt(btf); i < n; i++) {

tools/lib/bpf/libbpf.c

7335

t = btf__type_by_id(btf, i);

tools/lib/bpf/libbpf.c

7338

if (strcmp(btf__str_by_offset(btf, t->name_off), ctx_tag) != 0)

tools/lib/bpf/libbpf.c

734

struct btf *btf_vmlinux;

tools/lib/bpf/libbpf.c

7343

fn_t = btf_type_by_id(btf, orig_fn_id);

tools/lib/bpf/libbpf.c

7348

fn_proto_t = btf_type_by_id(btf, fn_t->type);

tools/lib/bpf/libbpf.c

7372

fn_name = btf__str_by_offset(btf, fn_t->name_off) ?: "<anon>";

tools/lib/bpf/libbpf.c

7373

if (!need_func_arg_type_fixup(btf, prog, fn_name, arg_idx, p->type, ctx_name))

tools/lib/bpf/libbpf.c

7380

fn_id = clone_func_btf_info(btf, orig_fn_id, prog);

tools/lib/bpf/libbpf.c

7396

struct_id = btf__add_struct(btf, ctx_name, 0);

tools/lib/bpf/libbpf.c

7397

ptr_id = btf__add_ptr(btf, struct_id);

tools/lib/bpf/libbpf.c

740

struct btf *btf_vmlinux_override;

tools/lib/bpf/libbpf.c

7405

tag_id = btf__add_decl_tag(btf, ctx_tag, func_rec->type_id, arg_idx);

tools/lib/bpf/libbpf.c

7412

fn_t = btf_type_by_id(btf, func_rec->type_id);

tools/lib/bpf/libbpf.c

7413

fn_proto_t = btf_type_by_id(btf, fn_t->type);

tools/lib/bpf/libbpf.c

7563

if (!obj->efile.btf_maps_sec_btf_id || !obj->btf)

tools/lib/bpf/libbpf.c

7565

sec = btf__type_by_id(obj->btf, obj->efile.btf_maps_sec_btf_id);

tools/lib/bpf/libbpf.c

7644

var = btf__type_by_id(obj->btf, vi->type);

tools/lib/bpf/libbpf.c

7645

def = skip_mods_and_typedefs(obj->btf, var->type, NULL);

tools/lib/bpf/libbpf.c

7649

mname = btf__name_by_offset(obj->btf, member->name_off);

tools/lib/bpf/libbpf.c

7886

if (obj->btf && btf__fd(obj->btf) >= 0 && kernel_supports(obj, FEAT_BTF_FUNC)) {

tools/lib/bpf/libbpf.c

7887

load_attr.prog_btf_fd = btf__fd(obj->btf);

tools/lib/bpf/libbpf.c

8094

err = bpf_core_parse_spec(prog->name, prog->obj->btf, relo, &spec);

tools/lib/bpf/libbpf.c

8237

kind = btf_is_var(btf__type_by_id(obj->btf, ext->btf_id)) ?

tools/lib/bpf/libbpf.c

8568

t = btf__type_by_id(obj->btf, ext->btf_id);

tools/lib/bpf/libbpf.c

8591

__u16 kind, struct btf **res_btf,

tools/lib/bpf/libbpf.c

8595

struct btf *btf;

tools/lib/bpf/libbpf.c

8598

btf = obj->btf_vmlinux;

tools/lib/bpf/libbpf.c

8600

id = btf__find_by_name_kind(btf, ksym_name, kind);

tools/lib/bpf/libbpf.c

8610

btf = mod_btf->btf;

tools/lib/bpf/libbpf.c

8611

id = btf__find_by_name_kind_own(btf, ksym_name, kind);

tools/lib/bpf/libbpf.c

8619

*res_btf = btf;

tools/lib/bpf/libbpf.c

8631

struct btf *btf = NULL;

tools/lib/bpf/libbpf.c

8634

id = find_ksym_btf_id(obj, ext->name, BTF_KIND_VAR, &btf, &mod_btf);

tools/lib/bpf/libbpf.c

8647

targ_var = btf__type_by_id(btf, id);

tools/lib/bpf/libbpf.c

8648

targ_var_name = btf__name_by_offset(btf, targ_var->name_off);

tools/lib/bpf/libbpf.c

8649

targ_type = skip_mods_and_typedefs(btf, targ_var->type, &targ_type_id);

tools/lib/bpf/libbpf.c

8651

err = bpf_core_types_are_compat(obj->btf, local_type_id,

tools/lib/bpf/libbpf.c

8652

btf, targ_type_id);

tools/lib/bpf/libbpf.c

8657

local_type = btf__type_by_id(obj->btf, local_type_id);

tools/lib/bpf/libbpf.c

8658

local_name = btf__name_by_offset(obj->btf, local_type->name_off);

tools/lib/bpf/libbpf.c

8659

targ_name = btf__name_by_offset(btf, targ_type->name_off);

tools/lib/bpf/libbpf.c

8683

struct btf *kern_btf = NULL;

tools/lib/bpf/libbpf.c

8701

ret = bpf_core_types_are_compat(obj->btf, local_func_proto_id,

tools/lib/bpf/libbpf.c

8766

t = btf__type_by_id(obj->btf, ext->btf_id);

tools/lib/bpf/libbpf.c

8894

type = btf__type_by_id(map->obj->btf, st_ops->type_id);

tools/lib/bpf/libbpf.c

8949

btf__free(obj->btf_modules[i].btf);

tools/lib/bpf/libbpf.c

9025

if (obj->btf)

tools/lib/bpf/libbpf.c

9026

btf__set_fd(obj->btf, -1);

tools/lib/bpf/libbpf.c

9507

btf__free(obj->btf);

tools/lib/bpf/libbpf.c

9566

struct btf *bpf_object__btf(const struct bpf_object *obj)

tools/lib/bpf/libbpf.c

9568

return obj ? obj->btf : NULL;

tools/lib/bpf/libbpf.c

9573

return obj->btf ? btf__fd(obj->btf) : -1;

tools/lib/bpf/libbpf.c

9893

if (!prog_btf_fd && obj->btf)

tools/lib/bpf/libbpf.c

9894

prog_btf_fd = btf__fd(obj->btf);

tools/lib/bpf/libbpf.h

343

struct btf;

tools/lib/bpf/libbpf.h

344

LIBBPF_API struct btf *bpf_object__btf(const struct bpf_object *obj);

tools/lib/bpf/libbpf_internal.h

244

struct btf;

tools/lib/bpf/libbpf_internal.h

247

struct btf_type *btf_type_by_id(const struct btf *btf, __u32 type_id);

tools/lib/bpf/libbpf_internal.h

249

const struct btf_type *skip_mods_and_typedefs(const struct btf *btf, __u32 id, __u32 *res_id);

tools/lib/bpf/libbpf_internal.h

250

const struct btf_header *btf_header(const struct btf *btf);

tools/lib/bpf/libbpf_internal.h

251

void btf_set_base_btf(struct btf *btf, const struct btf *base_btf);

tools/lib/bpf/libbpf_internal.h

252

int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **id_map);

tools/lib/bpf/libbpf_internal.h

294

int parse_btf_map_def(const char *map_name, struct btf *btf,

tools/lib/bpf/libbpf_internal.h

431

struct btf *bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *orig_btf);

tools/lib/bpf/libbpf_internal.h

432

int btf_load_into_kernel(struct btf *btf,

tools/lib/bpf/libbpf_internal.h

435

struct btf *btf_load_from_kernel(__u32 id, struct btf *base_btf, int token_fd);

tools/lib/bpf/libbpf_internal.h

437

struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf);

tools/lib/bpf/libbpf_internal.h

596

__s32 btf__find_by_name_kind_own(const struct btf *btf, const char *type_name,

tools/lib/bpf/libbpf_internal.h

719

const struct btf *targ_btf,

tools/lib/bpf/libbpf_legacy.h

125

struct btf;

tools/lib/bpf/libbpf_legacy.h

128

LIBBPF_API struct btf *libbpf_find_kernel_btf(void);

tools/lib/bpf/libbpf_legacy.h

133

LIBBPF_API const void *btf__get_raw_data(const struct btf *btf, __u32 *size);

tools/lib/bpf/linker.c

1065

struct btf *btf = ctx;

tools/lib/bpf/linker.c

1067

if (*type_id >= btf__type_cnt(btf))

tools/lib/bpf/linker.c

1075

struct btf *btf = ctx;

tools/lib/bpf/linker.c

1078

s = btf__str_by_offset(btf, *str_off);

tools/lib/bpf/linker.c

1091

if (!obj->btf)

tools/lib/bpf/linker.c

1094

n = btf__type_cnt(obj->btf);

tools/lib/bpf/linker.c

1099

t = btf_type_by_id(obj->btf, i);

tools/lib/bpf/linker.c

1113

if (!btf__str_by_offset(obj->btf, *str_off))

tools/lib/bpf/linker.c

1129

if (!obj->btf)

tools/lib/bpf/linker.c

1132

err = err ?: btf_ext_visit_type_ids(obj->btf_ext, check_btf_type_id, obj->btf);

tools/lib/bpf/linker.c

1133

err = err ?: btf_ext_visit_str_offs(obj->btf_ext, check_btf_str_off, obj->btf);

tools/lib/bpf/linker.c

1483

const struct btf *btf1, __u32 id1,

tools/lib/bpf/linker.c

1484

const struct btf *btf2, __u32 id2)

tools/lib/bpf/linker.c

153

struct btf *btf;

tools/lib/bpf/linker.c

1677

const struct btf *main_btf,

tools/lib/bpf/linker.c

1680

const struct btf *extra_btf,

tools/lib/bpf/linker.c

1773

t = btf__type_by_id(obj->btf, btf_id);

tools/lib/bpf/linker.c

1778

t = skip_mods_and_typedefs(obj->btf, t->type, NULL);

tools/lib/bpf/linker.c

1780

err = parse_btf_map_def(sym_name, obj->btf, t, true /*strict*/, &src_def, &src_inner_def);

tools/lib/bpf/linker.c

1787

t = btf__type_by_id(linker->btf, glob_sym->btf_id);

tools/lib/bpf/linker.c

1788

t = skip_mods_and_typedefs(linker->btf, t->type, NULL);

tools/lib/bpf/linker.c

1789

err = parse_btf_map_def(sym_name, linker->btf, t, true /*strict*/, &dst_def, &dst_inner_def);

tools/lib/bpf/linker.c

1800

return map_defs_match(sym_name, linker->btf, &dst_def, &dst_inner_def,

tools/lib/bpf/linker.c

1801

obj->btf, &src_def, &src_inner_def);

tools/lib/bpf/linker.c

1818

src_t = btf__type_by_id(obj->btf, btf_id);

tools/lib/bpf/linker.c

1830

linker->btf, glob_sym->btf_id, obj->btf, btf_id))

tools/lib/bpf/linker.c

1850

if (!obj->btf) {

tools/lib/bpf/linker.c

1855

n = btf__type_cnt(obj->btf);

tools/lib/bpf/linker.c

1857

t = btf__type_by_id(obj->btf, i);

tools/lib/bpf/linker.c

1863

name = btf__str_by_offset(obj->btf, t->name_off);

tools/lib/bpf/linker.c

1877

t = btf__type_by_id(obj->btf, vi->type);

tools/lib/bpf/linker.c

1878

name = btf__str_by_offset(obj->btf, t->name_off);

tools/lib/bpf/linker.c

1926

static int complete_extern_btf_info(struct btf *dst_btf, int dst_id,

tools/lib/bpf/linker.c

1927

struct btf *src_btf, int src_id)

tools/lib/bpf/linker.c

2013

if (!obj->btf) {

tools/lib/bpf/linker.c

2045

t = btf__type_by_id(obj->btf, btf_sec_id);

tools/lib/bpf/linker.c

2046

sec_name = btf__str_by_offset(obj->btf, t->name_off);

tools/lib/bpf/linker.c

207

btf__free(linker->btf);

tools/lib/bpf/linker.c

2139

if (complete_extern_btf_info(linker->btf, glob_sym->btf_id,

tools/lib/bpf/linker.c

2140

obj->btf, btf_id))

tools/lib/bpf/linker.c

2323

if (!obj->btf)

tools/lib/bpf/linker.c

2326

n = btf__type_cnt(obj->btf);

tools/lib/bpf/linker.c

2331

t = btf_type_by_id(obj->btf, i);

tools/lib/bpf/linker.c

2335

sec_name = btf__str_by_offset(obj->btf, t->name_off);

tools/lib/bpf/linker.c

2383

const struct btf_type *vt = btf__type_by_id(obj->btf, vi->type);

tools/lib/bpf/linker.c

2392

var_name = btf__str_by_offset(obj->btf, vt->name_off);

tools/lib/bpf/linker.c

2418

if (!obj->btf)

tools/lib/bpf/linker.c

2421

start_id = btf__type_cnt(linker->btf);

tools/lib/bpf/linker.c

2422

n = btf__type_cnt(obj->btf);

tools/lib/bpf/linker.c

2431

t = btf__type_by_id(obj->btf, i);

tools/lib/bpf/linker.c

2439

name = btf__str_by_offset(obj->btf, t->name_off);

tools/lib/bpf/linker.c

2467

id = btf__add_type(linker->btf, obj->btf, t);

tools/lib/bpf/linker.c

2483

n = btf__type_cnt(linker->btf);

tools/lib/bpf/linker.c

2485

struct btf_type *dst_t = btf_type_by_id(linker->btf, i);

tools/lib/bpf/linker.c

2519

glob_t = btf_type_by_id(linker->btf, glob_sym->btf_id);

tools/lib/bpf/linker.c

2545

t = btf__type_by_id(obj->btf, src_sec->sec_type_id);

tools/lib/bpf/linker.c

2553

t = btf_type_by_id(linker->btf, new_id);

tools/lib/bpf/linker.c

2555

name = btf__str_by_offset(linker->btf, t->name_off);

tools/lib/bpf/linker.c

2581

sz = btf__resolve_size(linker->btf, glob_sym->underlying_btf_id);

tools/lib/bpf/linker.c

2645

sec_name = btf__name_by_offset(obj->btf, ext_sec->sec_name_off);

tools/lib/bpf/linker.c

2674

sec_name = btf__name_by_offset(obj->btf, ext_sec->sec_name_off);

tools/lib/bpf/linker.c

2696

s = btf__str_by_offset(obj->btf, src_rec->file_name_off);

tools/lib/bpf/linker.c

2697

str_off = btf__add_str(linker->btf, s);

tools/lib/bpf/linker.c

2702

s = btf__str_by_offset(obj->btf, src_rec->line_off);

tools/lib/bpf/linker.c

2703

str_off = btf__add_str(linker->btf, s);

tools/lib/bpf/linker.c

2716

sec_name = btf__name_by_offset(obj->btf, ext_sec->sec_name_off);

tools/lib/bpf/linker.c

2739

s = btf__str_by_offset(obj->btf, src_rec->access_str_off);

tools/lib/bpf/linker.c

2740

str_off = btf__add_str(linker->btf, s);

tools/lib/bpf/linker.c

2864

struct btf *btf = linker->btf;

tools/lib/bpf/linker.c

2870

if (btf__type_cnt(linker->btf) == 1)

tools/lib/bpf/linker.c

2879

id = btf__add_datasec(btf, sec->sec_name, sec->sec_sz);

tools/lib/bpf/linker.c

2889

if (btf__add_datasec_var_info(btf, vi->type, vi->offset, vi->size))

tools/lib/bpf/linker.c

2901

err = btf__dedup(linker->btf, &opts);

tools/lib/bpf/linker.c

2910

btf__set_endianness(linker->btf, link_endianness);

tools/lib/bpf/linker.c

2915

raw_data = btf__raw_data(linker->btf, &raw_sz);

tools/lib/bpf/linker.c

2952

str_off = btf__add_str(linker->btf, sec_name);

tools/lib/bpf/linker.c

470

linker->btf = btf__new_empty();

tools/lib/bpf/linker.c

471

err = libbpf_get_error(linker->btf);

tools/lib/bpf/linker.c

508

btf__free(obj.btf);

tools/lib/bpf/linker.c

63

struct btf *btf;

tools/lib/bpf/linker.c

783

obj->btf = btf__new(data->d_buf, shdr->sh_size);

tools/lib/bpf/linker.c

784

err = libbpf_get_error(obj->btf);

tools/lib/bpf/relo_core.c

1192

t = btf_type_by_id(spec->btf, type_id);

tools/lib/bpf/relo_core.c

1193

s = btf__name_by_offset(spec->btf, t->name_off);

tools/lib/bpf/relo_core.c

1203

t = skip_mods_and_typedefs(spec->btf, type_id, NULL);

tools/lib/bpf/relo_core.c

1209

s = btf__name_by_offset(spec->btf, e->name_off);

tools/lib/bpf/relo_core.c

1217

s = btf__name_by_offset(spec->btf, e->name_off);

tools/lib/bpf/relo_core.c

1300

const struct btf *local_btf,

tools/lib/bpf/relo_core.c

1355

err = bpf_core_spec_match(local_spec, cands->cands[i].btf,

tools/lib/bpf/relo_core.c

1439

static bool bpf_core_names_match(const struct btf *local_btf, size_t local_name_off,

tools/lib/bpf/relo_core.c

1440

const struct btf *targ_btf, size_t targ_name_off)

tools/lib/bpf/relo_core.c

145

int __bpf_core_types_are_compat(const struct btf *local_btf, __u32 local_id,

tools/lib/bpf/relo_core.c

1457

static int bpf_core_enums_match(const struct btf *local_btf, const struct btf_type *local_t,

tools/lib/bpf/relo_core.c

1458

const struct btf *targ_btf, const struct btf_type *targ_t)

tools/lib/bpf/relo_core.c

146

const struct btf *targ_btf, __u32 targ_id, int level)

tools/lib/bpf/relo_core.c

1496

static int bpf_core_composites_match(const struct btf *local_btf, const struct btf_type *local_t,

tools/lib/bpf/relo_core.c

1497

const struct btf *targ_btf, const struct btf_type *targ_t,

tools/lib/bpf/relo_core.c

1561

int __bpf_core_types_match(const struct btf *local_btf, __u32 local_id, const struct btf *targ_btf,

tools/lib/bpf/relo_core.c

22

skip_mods_and_typedefs(const struct btf *btf, u32 id, u32 *res_id)

tools/lib/bpf/relo_core.c

24

return btf_type_skip_modifiers(btf, id, res_id);

tools/lib/bpf/relo_core.c

262

int bpf_core_parse_spec(const char *prog_name, const struct btf *btf,

tools/lib/bpf/relo_core.c

27

static const char *btf__name_by_offset(const struct btf *btf, u32 offset)

tools/lib/bpf/relo_core.c

273

spec_str = btf__name_by_offset(btf, relo->access_str_off);

tools/lib/bpf/relo_core.c

278

spec->btf = btf;

tools/lib/bpf/relo_core.c

29

return btf_name_by_offset(btf, offset);

tools/lib/bpf/relo_core.c

306

t = skip_mods_and_typedefs(btf, relo->type_id, &id);

tools/lib/bpf/relo_core.c

32

static s64 btf__resolve_size(const struct btf *btf, u32 type_id)

tools/lib/bpf/relo_core.c

323

acc->name = btf__name_by_offset(btf, name_off);

tools/lib/bpf/relo_core.c

330

sz = btf__resolve_size(btf, id);

tools/lib/bpf/relo_core.c

336

t = skip_mods_and_typedefs(btf, id, &id);

tools/lib/bpf/relo_core.c

355

name = btf__name_by_offset(btf, m->name_off);

tools/lib/bpf/relo_core.c

37

t = btf_type_by_id(btf, type_id);

tools/lib/bpf/relo_core.c

370

t = skip_mods_and_typedefs(btf, a->type, &id);

tools/lib/bpf/relo_core.c

374

flex = is_flex_arr(btf, acc - 1, a);

tools/lib/bpf/relo_core.c

38

t = btf_resolve_size(btf, t, &size);

tools/lib/bpf/relo_core.c

382

sz = btf__resolve_size(btf, id);

tools/lib/bpf/relo_core.c

413

static int bpf_core_fields_are_compat(const struct btf *local_btf,

tools/lib/bpf/relo_core.c

415

const struct btf *targ_btf,

tools/lib/bpf/relo_core.c

482

static int bpf_core_match_member(const struct btf *local_btf,

tools/lib/bpf/relo_core.c

484

const struct btf *targ_btf,

tools/lib/bpf/relo_core.c

559

const struct btf *targ_btf, __u32 targ_id,

tools/lib/bpf/relo_core.c

569

targ_spec->btf = targ_btf;

tools/lib/bpf/relo_core.c

575

return bpf_core_types_match(local_spec->btf,

tools/lib/bpf/relo_core.c

579

return bpf_core_types_are_compat(local_spec->btf,

tools/lib/bpf/relo_core.c

592

targ_type = skip_mods_and_typedefs(targ_spec->btf, targ_id, &targ_id);

tools/lib/bpf/relo_core.c

604

targ_name = btf__name_by_offset(targ_spec->btf, name_off);

tools/lib/bpf/relo_core.c

625

targ_type = skip_mods_and_typedefs(targ_spec->btf, targ_id,

tools/lib/bpf/relo_core.c

631

matched = bpf_core_match_member(local_spec->btf,

tools/lib/bpf/relo_core.c

70

static bool is_flex_arr(const struct btf *btf,

tools/lib/bpf/relo_core.c

704

t = btf_type_by_id(spec->btf, acc->type_id);

tools/lib/bpf/relo_core.c

714

t = skip_mods_and_typedefs(spec->btf, acc->type_id, &elem_id);

tools/lib/bpf/relo_core.c

716

t = skip_mods_and_typedefs(spec->btf, btf_array(t)->type, &elem_id);

tools/lib/bpf/relo_core.c

717

sz = btf__resolve_size(spec->btf, elem_id);

tools/lib/bpf/relo_core.c

723

sz = btf__resolve_size(spec->btf, acc->type_id);

tools/lib/bpf/relo_core.c

738

mt = skip_mods_and_typedefs(spec->btf, m->type, &field_type_id);

tools/lib/bpf/relo_core.c

758

sz = btf__resolve_size(spec->btf, field_type_id);

tools/lib/bpf/relo_core.c

781

t = skip_mods_and_typedefs(spec->btf, field_type_id, &elem_id);

tools/lib/bpf/relo_core.c

783

t = skip_mods_and_typedefs(spec->btf, btf_array(t)->type, &elem_id);

tools/lib/bpf/relo_core.c

784

sz = btf__resolve_size(spec->btf, elem_id);

tools/lib/bpf/relo_core.c

81

t = btf_type_by_id(btf, acc->type_id);

tools/lib/bpf/relo_core.c

850

sz = btf__resolve_size(spec->btf, spec->root_type_id);

tools/lib/bpf/relo_core.c

877

t = btf_type_by_id(spec->btf, spec->spec[0].type_id);

tools/lib/bpf/relo_core.c

930

orig_t = btf_type_by_id(local_spec->btf, res->orig_type_id);

tools/lib/bpf/relo_core.c

931

new_t = btf_type_by_id(targ_spec->btf, res->new_type_id);

tools/lib/bpf/relo_core.h

10

const struct btf *btf;

tools/lib/bpf/relo_core.h

30

const struct btf *btf;

tools/lib/bpf/relo_core.h

71

int __bpf_core_types_are_compat(const struct btf *local_btf, __u32 local_id,

tools/lib/bpf/relo_core.h

72

const struct btf *targ_btf, __u32 targ_id, int level);

tools/lib/bpf/relo_core.h

73

int bpf_core_types_are_compat(const struct btf *local_btf, __u32 local_id,

tools/lib/bpf/relo_core.h

74

const struct btf *targ_btf, __u32 targ_id);

tools/lib/bpf/relo_core.h

75

int __bpf_core_types_match(const struct btf *local_btf, __u32 local_id, const struct btf *targ_btf,

tools/lib/bpf/relo_core.h

77

int bpf_core_types_match(const struct btf *local_btf, __u32 local_id, const struct btf *targ_btf,

tools/lib/bpf/relo_core.h

84

const struct btf *local_btf,

tools/lib/bpf/relo_core.h

93

int bpf_core_parse_spec(const char *prog_name, const struct btf *btf,

tools/perf/builtin-trace.c

1000

syscall_arg_fmt__cache_btf_enum(arg->fmt, btf, type);

tools/perf/builtin-trace.c

1015

static size_t btf_enum_scnprintf(const struct btf_type *type, struct btf *btf, char *bf, size_t size, int val)

tools/perf/builtin-trace.c

1023

btf__name_by_offset(btf, be->name_off));

tools/perf/builtin-trace.c

1042

static size_t btf_struct_scnprintf(const struct btf_type *type, struct btf *btf, char *bf, size_t size, struct syscall_arg *arg)

tools/perf/builtin-trace.c

1061

btf_dump = btf_dump__new(btf, trace__btf_dump_snprintf, &ctx, &dump_opts);

tools/perf/builtin-trace.c

1083

if (trace->btf == NULL)

tools/perf/builtin-trace.c

1088

syscall_arg_fmt__cache_btf_enum(arg_fmt, trace->btf, type);

tools/perf/builtin-trace.c

1096

return btf_enum_scnprintf(arg_fmt->type, trace->btf, bf, size, val);

tools/perf/builtin-trace.c

1098

return btf_struct_scnprintf(arg_fmt->type, trace->btf, bf, size, arg);

tools/perf/builtin-trace.c

157

struct btf *btf;

tools/perf/builtin-trace.c

241

if (trace->btf != NULL)

tools/perf/builtin-trace.c

244

trace->btf = btf__load_vmlinux_btf();

tools/perf/builtin-trace.c

246

fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :

tools/perf/builtin-trace.c

3732

static int syscall_arg_fmt__cache_btf_struct(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type)

tools/perf/builtin-trace.c

3739

id = btf__find_by_name(btf, type);

tools/perf/builtin-trace.c

3743

arg_fmt->type = btf__type_by_id(btf, id);

tools/perf/builtin-trace.c

3819

if (trace->btf == NULL)

tools/perf/builtin-trace.c

3844

if (syscall_arg_fmt__cache_btf_struct(&sc->arg_fmt[i], trace->btf, name))

tools/perf/builtin-trace.c

5361

btf__free(trace->btf);

tools/perf/builtin-trace.c

5362

trace->btf = NULL;

tools/perf/builtin-trace.c

950

static void syscall_arg_fmt__cache_btf_enum(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type)

tools/perf/builtin-trace.c

960

id = btf__find_by_name(btf, type);

tools/perf/builtin-trace.c

964

arg_fmt->type = btf__type_by_id(btf, id);

tools/perf/builtin-trace.c

970

struct btf *btf = arg->trace->btf;

tools/perf/builtin-trace.c

974

const char *name = btf__name_by_offset(btf, be->name_off);

tools/perf/builtin-trace.c

990

struct btf *btf;

tools/perf/builtin-trace.c

994

btf = arg->trace->btf;

tools/perf/builtin-trace.c

995

if (btf == NULL)

tools/perf/tests/sigtrap.c

103

id = btf__find_by_name_kind(btf, "spinlock", BTF_KIND_STRUCT);

tools/perf/tests/sigtrap.c

108

member = __btf_type__find_member_by_name(btf, id, "lock");

tools/perf/tests/sigtrap.c

113

type = btf__type_by_id(btf, member->type);

tools/perf/tests/sigtrap.c

117

type_name = btf__name_by_offset(btf, type->name_off);

tools/perf/tests/sigtrap.c

61

static struct btf *btf;

tools/perf/tests/sigtrap.c

65

if (btf == NULL)

tools/perf/tests/sigtrap.c

66

btf = btf__load_vmlinux_btf();

tools/perf/tests/sigtrap.c

68

return btf != NULL;

tools/perf/tests/sigtrap.c

73

btf__free(btf);

tools/perf/tests/sigtrap.c

74

btf = NULL;

tools/perf/tests/sigtrap.c

86

id = btf__find_by_name_kind(btf, "perf_event_attr", BTF_KIND_STRUCT);

tools/perf/tests/sigtrap.c

90

return __btf_type__find_member_by_name(btf, id, "sigtrap") != NULL;

tools/perf/util/bpf-event.c

106

struct btf *btf)

tools/perf/util/bpf-event.c

112

data = btf__raw_data(btf, &data_size);

tools/perf/util/bpf-event.c

132

struct btf *btf,

tools/perf/util/bpf-event.c

146

if (btf) {

tools/perf/util/bpf-event.c

148

t = btf__type_by_id(btf, finfo->type_id);

tools/perf/util/bpf-event.c

149

short_name = btf__name_by_offset(btf, t->name_off);

tools/perf/util/bpf-event.c

176

struct btf *btf;

tools/perf/util/bpf-event.c

189

struct btf *btf;

tools/perf/util/bpf-event.c

213

btf = btf__load_from_kernel_by_id(map_info.btf_id);

tools/perf/util/bpf-event.c

214

if (!btf)

tools/perf/util/bpf-event.c

216

datasec = btf__type_by_id(btf, map_info.btf_value_type_id);

tools/perf/util/bpf-event.c

228

const struct btf_type *t_var = btf__type_by_id(btf, vsi->type);

tools/perf/util/bpf-event.c

229

const char *name = btf__name_by_offset(btf, t_var->name_off);

tools/perf/util/bpf-event.c

247

map->btf = btf;

tools/perf/util/bpf-event.c

255

btf__free(btf);

tools/perf/util/bpf-event.c

279

static void format_btf_variable(struct btf *btf, char *buf, size_t buf_size,

tools/perf/util/bpf-event.c

296

d = btf_dump__new(btf, format_btf_cb, &ctx, NULL);

tools/perf/util/bpf-event.c

297

btf_size = btf__resolve_size(btf, t->type);

tools/perf/util/bpf-event.c

313

const struct btf_type *t_var = btf__type_by_id(map->btf,

tools/perf/util/bpf-event.c

315

const char *name = btf__name_by_offset(map->btf,

tools/perf/util/bpf-event.c

329

format_btf_variable(map->btf, entry->value,

tools/perf/util/bpf-event.c

338

btf__free(map->btf);

tools/perf/util/bpf-event.c

404

map.btf, index);

tools/perf/util/bpf-event.c

542

struct btf *btf = NULL;

tools/perf/util/bpf-event.c

598

btf = btf__load_from_kernel_by_id(info->btf_id);

tools/perf/util/bpf-event.c

599

if (libbpf_get_error(btf)) {

tools/perf/util/bpf-event.c

604

perf_env__fetch_btf(env, info->btf_id, btf);

tools/perf/util/bpf-event.c

625

KSYM_NAME_LEN, info, btf, i);

tools/perf/util/bpf-event.c

690

btf__free(btf);

tools/perf/util/bpf-event.c

838

struct btf *btf = NULL;

tools/perf/util/bpf-event.c

885

btf = btf__load_from_kernel_by_id(btf_id);

tools/perf/util/bpf-event.c

886

if (!btf) {

tools/perf/util/bpf-event.c

890

perf_env__fetch_btf(env, btf_id, btf);

tools/perf/util/bpf-event.c

894

btf__free(btf);

tools/perf/util/bpf-event.c

953

struct btf *btf = NULL;

tools/perf/util/bpf-event.c

966

btf = btf__new((__u8 *)(node->data),

tools/perf/util/bpf-event.c

971

synthesize_bpf_prog_name(name, KSYM_NAME_LEN, info, btf, 0);

tools/perf/util/bpf-event.c

979

synthesize_bpf_prog_name(name, KSYM_NAME_LEN, info, btf, i);

tools/perf/util/bpf-event.c

985

btf__free(btf);

tools/perf/util/bpf_counter.c

126

struct btf *btf = NULL;

tools/perf/util/bpf_counter.c

140

btf = btf__load_from_kernel_by_id(info_linear->info.btf_id);

tools/perf/util/bpf_counter.c

141

if (libbpf_get_error(btf)) {

tools/perf/util/bpf_counter.c

147

t = btf__type_by_id(btf, func_info[0].type_id);

tools/perf/util/bpf_counter.c

153

name = strdup(btf__name_by_offset(btf, t->name_off));

tools/perf/util/bpf_counter.c

155

btf__free(btf);

tools/perf/util/bpf_lock_contention.c

120

if (!con->btf)

tools/perf/util/bpf_lock_contention.c

128

ret = btf__find_by_name_kind(con->btf, "zone", BTF_KIND_STRUCT);

tools/perf/util/bpf_lock_contention.c

134

ret = btf__resolve_size(con->btf, ret);

tools/perf/util/bpf_lock_contention.c

43

con->btf = btf__load_vmlinux_btf();

tools/perf/util/bpf_lock_contention.c

44

if (con->btf == NULL) {

tools/perf/util/bpf_lock_contention.c

49

ret = btf__find_by_name_kind(con->btf, "bpf_iter__kmem_cache", BTF_KIND_STRUCT);

tools/perf/util/bpf_lock_contention.c

852

btf__free(con->btf);

tools/perf/util/bpf_off_cpu.c

116

struct btf *btf = btf__load_vmlinux_btf();

tools/perf/util/bpf_off_cpu.c

120

if (!btf) {

tools/perf/util/bpf_off_cpu.c

125

type_id = btf__find_by_name_kind(btf, "btf_trace_sched_switch",

tools/perf/util/bpf_off_cpu.c

130

t1 = btf__type_by_id(btf, type_id);

tools/perf/util/bpf_off_cpu.c

134

t2 = btf__type_by_id(btf, t1->type);

tools/perf/util/bpf_off_cpu.c

138

t3 = btf__type_by_id(btf, t2->type);

tools/perf/util/bpf_off_cpu.c

145

btf__free(btf);

tools/perf/util/btf.c

12

const struct btf_member *__btf_type__find_member_by_name(struct btf *btf,

tools/perf/util/btf.c

15

const struct btf_type *t = btf__type_by_id(btf, type_id);

tools/perf/util/btf.c

20

const char *current_member_name = btf__name_by_offset(btf, m->name_off);

tools/perf/util/btf.h

5

struct btf;

tools/perf/util/btf.h

8

const struct btf_member *__btf_type__find_member_by_name(struct btf *btf,

tools/perf/util/libbfd.c

509

struct btf *btf = NULL;

tools/perf/util/libbfd.c

567

btf = btf__new((__u8 *)(node->data),

tools/perf/util/libbfd.c

600

if (linfo && btf) {

tools/perf/util/libbfd.c

601

srcline = btf__name_by_offset(btf, linfo->line_off);

tools/perf/util/libbfd.c

638

btf__free(btf);

tools/perf/util/lock-contention.h

152

void *btf;

tools/sched_ext/include/scx/compat.h

16

struct btf *__COMPAT_vmlinux_btf __attribute__((weak));

tools/testing/selftests/bpf/btf_helpers.c

101

fprintf(out, "[%u] %s '%s'", id, btf_kind_str(kind), btf_str(btf, t->name_off));

tools/testing/selftests/bpf/btf_helpers.c

135

btf_str(btf, m->name_off), m->type, bit_off);

tools/testing/selftests/bpf/btf_helpers.c

150

btf_str(btf, v->name_off), v->val);

tools/testing/selftests/bpf/btf_helpers.c

164

btf_str(btf, v->name_off),

tools/testing/selftests/bpf/btf_helpers.c

181

btf_str(btf, p->name_off), p->type);

tools/testing/selftests/bpf/btf_helpers.c

216

const char *btf_type_raw_dump(const struct btf *btf, int type_id)

tools/testing/selftests/bpf/btf_helpers.c

227

fprintf_btf_type_raw(buf_file, btf, type_id);

tools/testing/selftests/bpf/btf_helpers.c

234

int btf_validate_raw(struct btf *btf, int nr_types, const char *exp_types[])

tools/testing/selftests/bpf/btf_helpers.c

239

ASSERT_EQ(btf__type_cnt(btf) - 1, nr_types, "btf_nr_types");

tools/testing/selftests/bpf/btf_helpers.c

242

if (!ASSERT_STREQ(btf_type_raw_dump(btf, i), exp_types[i - 1], "raw_dump"))

tools/testing/selftests/bpf/btf_helpers.c

257

const char *btf_type_c_dump(const struct btf *btf)

tools/testing/selftests/bpf/btf_helpers.c

270

d = btf_dump__new(btf, btf_dump_printf, buf_file, NULL);

tools/testing/selftests/bpf/btf_helpers.c

276

for (i = 1; i < btf__type_cnt(btf); i++) {

tools/testing/selftests/bpf/btf_helpers.c

81

static const char *btf_str(const struct btf *btf, __u32 off)

tools/testing/selftests/bpf/btf_helpers.c

85

return btf__str_by_offset(btf, off) ?: "(invalid)";

tools/testing/selftests/bpf/btf_helpers.c

88

int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id)

tools/testing/selftests/bpf/btf_helpers.c

94

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/btf_helpers.h

10

const char *btf_type_raw_dump(const struct btf *btf, int type_id);

tools/testing/selftests/bpf/btf_helpers.h

11

int btf_validate_raw(struct btf *btf, int nr_types, const char *exp_types[]);

tools/testing/selftests/bpf/btf_helpers.h

13

#define VALIDATE_RAW_BTF(btf, raw_types...) \

tools/testing/selftests/bpf/btf_helpers.h

14

btf_validate_raw(btf, \

tools/testing/selftests/bpf/btf_helpers.h

18

const char *btf_type_c_dump(const struct btf *btf);

tools/testing/selftests/bpf/btf_helpers.h

9

int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id);

tools/testing/selftests/bpf/prog_tests/btf.c

4568

info->btf = ptr_to_u64(user_btf);

tools/testing/selftests/bpf/prog_tests/btf.c

4636

info[i].btf = ptr_to_u64(user_btf[i]);

tools/testing/selftests/bpf/prog_tests/btf.c

4778

info.btf = ptr_to_u64(user_btf);

tools/testing/selftests/bpf/prog_tests/btf.c

4839

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf.c

4847

btf = btf__parse_elf(test->file, &btf_ext);

tools/testing/selftests/bpf/prog_tests/btf.c

4848

err = libbpf_get_error(btf);

tools/testing/selftests/bpf/prog_tests/btf.c

4857

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf.c

4951

btf = btf__load_from_kernel_by_id(info.btf_id);

tools/testing/selftests/bpf/prog_tests/btf.c

4952

err = libbpf_get_error(btf);

tools/testing/selftests/bpf/prog_tests/btf.c

4962

t = btf__type_by_id(btf, finfo->type_id);

tools/testing/selftests/bpf/prog_tests/btf.c

4969

fname = btf__name_by_offset(btf, t->name_off);

tools/testing/selftests/bpf/prog_tests/btf.c

4990

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf.c

8151

struct btf *test_btf = NULL, *expect_btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

127

struct btf *btf1, *btf2;

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

225

struct btf *btf1, *btf2;

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

332

static void btf_add_dup_struct_in_cu(struct btf *btf, int start_id)

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

335

btf__set_pointer_size(btf, 8); /* enforce 64-bit arch */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

337

btf__add_int(btf, "int", 4, BTF_INT_SIGNED); /* [1] int */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

339

btf__add_struct(btf, "s", 8); /* [2] struct s { */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

340

btf__add_field(btf, "a", ID(3), 0, 0); /* struct anon a; */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

341

btf__add_field(btf, "b", ID(4), 0, 0); /* struct anon b; */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

344

btf__add_struct(btf, "(anon)", 8); /* [3] struct anon { */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

345

btf__add_field(btf, "f1", ID(1), 0, 0); /* int f1; */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

346

btf__add_field(btf, "f2", ID(1), 32, 0); /* int f2; */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

349

btf__add_struct(btf, "(anon)", 8); /* [4] struct anon { */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

350

btf__add_field(btf, "f1", ID(1), 0, 0); /* int f1; */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

351

btf__add_field(btf, "f2", ID(1), 32, 0); /* int f2; */

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

358

struct btf *btf1, *btf2 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

473

struct btf *vmlinux_btf, *btf1 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c

9

struct btf *btf1, *btf2;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

16

struct btf *btf1 = NULL, *btf2 = NULL, *btf3 = NULL, *btf4 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

300

struct btf *btf1 = NULL, *btf2 = NULL, *btf3 = NULL, *btf4 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

354

struct btf *btf1 = NULL, *btf2 = NULL, *btf3 = NULL, *btf4 = NULL, *btf5 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

408

struct btf *btf1 = NULL, *btf2 = NULL, *btf3 = NULL, *btf4 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

453

struct btf *btf1 = NULL, *btf2 = NULL, *btf3 = NULL, *btf4 = NULL, *btf5 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

503

struct btf *split_btf = NULL, *vmlinux_btf = btf__load_vmlinux_btf();

tools/testing/selftests/bpf/prog_tests/btf_distill.c

504

struct btf *split_dist = NULL, *base_dist = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

541

struct btf *base = NULL, *split = NULL, *new_base = NULL, *new_split = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

542

struct btf *new_base1 = NULL, *new_split1 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_distill.c

610

struct btf *btf1 = NULL, *btf2 = NULL, *btf3 = NULL, *btf4 = NULL, *btf5 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1009

type_id = btf__find_by_name(btf, name);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1013

secsize = btf__resolve_size(btf, type_id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1026

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1030

btf = btf__parse("xdping_kern.bpf.o", NULL);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1031

if (!ASSERT_OK_PTR(btf, "xdping_kern.bpf.o BTF not found"))

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1034

d = btf_dump__new(btf, btf_dump_snprintf, str, NULL);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1038

test_btf_datasec(btf, d, str, "license",

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1043

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1049

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1066

btf = libbpf_find_kernel_btf();

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1067

if (!ASSERT_OK_PTR(btf, "no kernel BTF found"))

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1070

d = btf_dump__new(btf, btf_dump_snprintf, str, NULL);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1076

test_btf_dump_int_data(btf, d, str);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1078

test_btf_dump_float_data(btf, d, str);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1080

test_btf_dump_char_data(btf, d, str);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1082

test_btf_dump_typedef_data(btf, d, str);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1084

test_btf_dump_enum_data(btf, d, str);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1086

test_btf_dump_struct_data(btf, d, str);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1088

test_btf_dump_var_data(btf, d, str);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

1092

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

125

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

130

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

142

btf__free(t->btf);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

150

t->btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/btf_dump.c

151

if (!ASSERT_OK_PTR(t->btf, "new_empty"))

tools/testing/selftests/bpf/prog_tests/btf_dump.c

153

t->d = btf_dump__new(t->btf, btf_dump_printf, t->dump_buf_file, NULL);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

170

for (i = 1; i < btf__type_cnt(t->btf); i++) {

tools/testing/selftests/bpf/prog_tests/btf_dump.c

184

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

190

btf = t.btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

205

id = btf__add_enum(btf, "x", 4);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

207

id = btf__add_enum(btf, "x", 4);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

209

err = btf__add_enum_value(btf, "X", 1);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

212

id = btf__add_enum(btf, NULL, 4);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

214

err = btf__add_enum_value(btf, "Y", 1);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

217

id = btf__add_int(btf, "int", 4, BTF_INT_SIGNED);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

220

id = btf__add_fwd(btf, "s", BTF_FWD_STRUCT);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

223

id = btf__add_struct(btf, "s", 4);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

225

err = btf__add_field(btf, "x", 4, 0, 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

26

static int btf_dump_all_types(const struct btf *btf, void *ctx)

tools/testing/selftests/bpf/prog_tests/btf_dump.c

261

id = btf__add_struct(btf, "s", 4);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

263

err = btf__add_field(btf, "x", 2, 0, 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

265

err = btf__add_field(btf, "y", 3, 32, 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

267

err = btf__add_field(btf, "s", 6, 64, 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

28

size_t type_cnt = btf__type_cnt(btf);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

285

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

291

btf = t.btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

302

id = btf__add_type_tag(btf, "void_tag", 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

304

id = btf__add_ptr(btf, id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

307

id = btf__add_type_attr(btf, "void_attr", 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

309

id = btf__add_ptr(btf, id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

312

id = btf__add_struct(btf, "s", 8);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

314

err = btf__add_field(btf, "p1", 2, 0, 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

316

err = btf__add_field(btf, "p2", 4, 0, 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

32

d = btf_dump__new(btf, btf_dump_printf, ctx, NULL);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

339

static int btf_dump_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

359

type_id = btf__find_by_name(btf, name);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

362

type_sz = btf__resolve_size(btf, type_id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

420

static void test_btf_dump_int_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

432

TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, int, BTF_F_COMPACT, 1234);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

433

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

435

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, 0, "(int)1234", 1234);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

438

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT, "(int)0", 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

439

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

441

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_ZERO,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

443

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

446

TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, int, BTF_F_COMPACT, -4567);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

447

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

449

TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, 0, "(int)-4567", -4567);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

451

TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, int, sizeof(int)-1, "", 1);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

458

if (btf__find_by_name(btf, "unsigned __int128") > 0) {

tools/testing/selftests/bpf/prog_tests/btf_dump.c

459

TEST_BTF_DUMP_DATA(btf, d, NULL, str, unsigned __int128, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

462

ASSERT_OK(btf_dump_data(btf, d, "unsigned __int128", NULL, 0, &i, 16, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

465

} else if (btf__find_by_name(btf, "__int128 unsigned") > 0) {

tools/testing/selftests/bpf/prog_tests/btf_dump.c

466

TEST_BTF_DUMP_DATA(btf, d, NULL, str, __int128 unsigned, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

469

ASSERT_OK(btf_dump_data(btf, d, "__int128 unsigned", NULL, 0, &i, 16, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

478

static void test_btf_dump_float_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

495

ASSERT_GT(btf__add_float(btf, "test_float", 4), 0, "add float");

tools/testing/selftests/bpf/prog_tests/btf_dump.c

496

ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t1, 4, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

498

ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t2, 4, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

500

ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t3, 4, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

503

ASSERT_GT(btf__add_float(btf, "test_double", 8), 0, "add_double");

tools/testing/selftests/bpf/prog_tests/btf_dump.c

504

ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t4, 8, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

506

ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t5, 8, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

508

ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t6, 8, str,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

51

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

511

ASSERT_GT(btf__add_float(btf, "test_long_double", 16), 0, "add long double");

tools/testing/selftests/bpf/prog_tests/btf_dump.c

512

ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t7, 16,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

515

ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t8, 16,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

518

ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t9, 16,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

523

static void test_btf_dump_char_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

527

TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, char, BTF_F_COMPACT, 100);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

528

TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

530

TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, 0, "(char)100", 100);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

532

TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

534

TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

536

TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_ZERO,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

538

TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

540

TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, 0, "(char)0", 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

542

TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, char, sizeof(char)-1, "", 100);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

545

static void test_btf_dump_typedef_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

549

TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, uint64_t, BTF_F_COMPACT, 100);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

550

TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

552

TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, 0, "(u64)1", 1);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

554

TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT, "(u64)0", 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

555

TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

557

TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_ZERO,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

559

TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

562

TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, 0, "(u64)0", 0);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

565

TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, atomic_t, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

567

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

569

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

57

btf = btf__parse_elf(test_file, NULL);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

575

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT, "(atomic_t){}",

tools/testing/selftests/bpf/prog_tests/btf_dump.c

577

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_NONAME,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

579

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

58

if (!ASSERT_OK_PTR(btf, "btf_parse_elf")) {

tools/testing/selftests/bpf/prog_tests/btf_dump.c

583

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_ZERO,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

586

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

589

TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_ZERO,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

59

err = -PTR_ERR(btf);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

596

TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, atomic_t, sizeof(atomic_t)-1,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

60

btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

600

static void test_btf_dump_enum_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

604

TEST_BTF_DUMP_DATA_C(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

606

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

608

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

612

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

615

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

618

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

622

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

625

TEST_BTF_DUMP_DATA_C(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT, 2000);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

626

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

629

TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

632

TEST_BTF_DUMP_DATA_OVER(btf, d, "enum", str, enum bpf_cmd,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

636

static void test_btf_dump_struct_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

652

TEST_BTF_DUMP_DATA_C(btf, d, "struct", str, struct btf_enum, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

654

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

658

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

664

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

668

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

673

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

676

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

680

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

684

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

688

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

697

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

70

btf__set_pointer_size(btf, 8);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

700

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

706

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

709

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

715

type_id = btf__find_by_name(btf, "file_operations");

tools/testing/selftests/bpf/prog_tests/btf_dump.c

717

type_sz = btf__resolve_size(btf, type_id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

72

CHECK(btf__pointer_size(btf) != 8, "ptr_sz", "exp %d, got %zu\n",

tools/testing/selftests/bpf/prog_tests/btf_dump.c

73

8, btf__pointer_size(btf));

tools/testing/selftests/bpf/prog_tests/btf_dump.c

732

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

735

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

739

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

749

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

753

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

758

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

761

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

765

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

777

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

780

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

793

TEST_BTF_DUMP_DATA_C(btf, d, "struct", str, struct bpf_insn, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

795

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

800

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn, 0,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

811

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

816

type_id = btf__find_by_name(btf, "fs_context");

tools/testing/selftests/bpf/prog_tests/btf_dump.c

818

type_sz = btf__resolve_size(btf, type_id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

831

TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_sock_ops, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

836

TEST_BTF_DUMP_DATA(btf, d, "union", str, union bpf_iter_link_info, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

844

type_id = btf__find_by_name(btf, "sk_buff");

tools/testing/selftests/bpf/prog_tests/btf_dump.c

846

type_sz = btf__resolve_size(btf, type_id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

861

TEST_BTF_DUMP_DATA_OVER(btf, d, "struct", str, struct bpf_sock_ops,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

865

TEST_BTF_DUMP_DATA_OVER(btf, d, "struct", str, struct bpf_sock_ops,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

871

static void test_btf_dump_var_data(struct btf *btf, struct btf_dump *d,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

875

TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_number", int, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

878

TEST_BTF_DUMP_VAR(btf, d, NULL, str, "bpf_bprintf_nest_level", int, BTF_F_COMPACT,

tools/testing/selftests/bpf/prog_tests/btf_dump.c

883

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

89

err = btf_dump_all_types(btf, f);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

898

type_sz = btf__resolve_size(ctx->btf, ctx->array_id);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

974

d = btf_dump__new(t.btf, btf_dump_snprintf, str, NULL);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

979

char_id = btf__add_int(t.btf, "char", 1, BTF_INT_CHAR);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

981

int_id = btf__add_int(t.btf, "int", 4, BTF_INT_SIGNED);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

983

array_id = btf__add_array(t.btf, int_id, char_id, 4);

tools/testing/selftests/bpf/prog_tests/btf_dump.c

986

ctx.btf = t.btf;

tools/testing/selftests/bpf/prog_tests/btf_dump.c

998

static void test_btf_datasec(struct btf *btf, struct btf_dump *d, char *str,

tools/testing/selftests/bpf/prog_tests/btf_endian.c

18

struct btf *btf = NULL, *swap_btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_endian.c

26

btf = btf__parse_elf("btf_dump_test_case_syntax.bpf.o", NULL);

tools/testing/selftests/bpf/prog_tests/btf_endian.c

27

if (!ASSERT_OK_PTR(btf, "parse_native_btf"))

tools/testing/selftests/bpf/prog_tests/btf_endian.c

30

ASSERT_EQ(btf__endianness(btf), endian, "endian");

tools/testing/selftests/bpf/prog_tests/btf_endian.c

31

btf__set_endianness(btf, swap_endian);

tools/testing/selftests/bpf/prog_tests/btf_endian.c

32

ASSERT_EQ(btf__endianness(btf), swap_endian, "endian");

tools/testing/selftests/bpf/prog_tests/btf_endian.c

35

raw_data = btf__raw_data(btf, &raw_sz);

tools/testing/selftests/bpf/prog_tests/btf_endian.c

45

ASSERT_EQ(btf__type_cnt(swap_btf), btf__type_cnt(btf), "nr_types");

tools/testing/selftests/bpf/prog_tests/btf_endian.c

71

var_id = btf__add_var(btf, "some_var", BTF_VAR_GLOBAL_ALLOCATED, 1);

tools/testing/selftests/bpf/prog_tests/btf_endian.c

77

btf__set_endianness(btf, swap_endian);

tools/testing/selftests/bpf/prog_tests/btf_endian.c

78

raw_data = btf__raw_data(btf, &raw_sz);

tools/testing/selftests/bpf/prog_tests/btf_endian.c

88

ASSERT_EQ(btf__type_cnt(swap_btf), btf__type_cnt(btf), "nr_types");

tools/testing/selftests/bpf/prog_tests/btf_endian.c

97

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

128

for (id = 1; id < btf__type_cnt(btf); id++) {

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

129

struct btf_type *t = btf_type_by_id(btf, id);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

143

const char *str = btf__str_by_offset(btf, *next_str);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

160

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

43

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

46

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

47

if (!ASSERT_OK_PTR(btf, "empty_btf"))

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

50

btf__add_int(btf, "int", 4, BTF_INT_SIGNED); /* [1] int */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

51

btf__add_int(btf, "int64", 8, BTF_INT_SIGNED); /* [2] int64 */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

52

btf__add_ptr(btf, 1); /* [3] int * */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

53

btf__add_array(btf, 1, 2, 3); /* [4] int64[3] */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

54

btf__add_struct(btf, "s1", 12); /* [5] struct s1 { */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

55

btf__add_field(btf, "f1", 3, 0, 0); /* int *f1; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

56

btf__add_field(btf, "f2", 1, 0, 0); /* int f2; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

58

btf__add_union(btf, "u1", 12); /* [6] union u1 { */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

59

btf__add_field(btf, "f1", 1, 0, 0); /* int f1; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

60

btf__add_field(btf, "f2", 5, 0, 0); /* struct s1 f2; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

62

btf__add_enum(btf, "e1", 4); /* [7] enum e1 { */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

63

btf__add_enum_value(btf, "v1", 1); /* v1 = 1; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

64

btf__add_enum_value(btf, "v2", 2); /* v2 = 2; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

67

btf__add_fwd(btf, "fw1", BTF_FWD_STRUCT); /* [8] struct fw1; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

68

btf__add_typedef(btf, "t", 1); /* [9] typedef int t; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

69

btf__add_volatile(btf, 2); /* [10] volatile int64; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

70

btf__add_const(btf, 1); /* [11] const int; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

71

btf__add_restrict(btf, 3); /* [12] restrict int *; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

72

btf__add_func_proto(btf, 1); /* [13] int (*)(int p1, int *p2); */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

73

btf__add_func_param(btf, "p1", 1);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

74

btf__add_func_param(btf, "p2", 3);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

76

btf__add_func(btf, "func", BTF_FUNC_GLOBAL, 13);/* [14] int func(int p1, int *p2); */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

77

btf__add_var(btf, "var1", BTF_VAR_STATIC, 1); /* [15] static int var1; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

78

btf__add_var(btf, "var2", BTF_VAR_STATIC, 3); /* [16] static int *var2; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

79

btf__add_float(btf, "float", 4); /* [17] float; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

80

btf__add_decl_tag(btf, "decltag", 11, -1); /* [18] decltag const int; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

81

btf__add_type_tag(btf, "typetag", 6); /* [19] typetag union u1; */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

82

btf__add_enum64(btf, "e64", 8, true); /* [20] enum { */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

83

btf__add_enum64_value(btf, "eval1", 1000); /* eval1 = 1000, */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

84

btf__add_enum64_value(btf, "eval2", 2000); /* eval2 = 2000, */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

85

btf__add_enum64_value(btf, "eval3", 3000); /* eval3 = 3000 */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

87

btf__add_datasec(btf, "datasec1", 12); /* [21] datasec datasec1 */

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

88

btf__add_datasec_var_info(btf, 15, 0, 4);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

89

btf__add_datasec_var_info(btf, 16, 4, 8);

tools/testing/selftests/bpf/prog_tests/btf_field_iter.c

92

btf,

tools/testing/selftests/bpf/prog_tests/btf_kind.c

100

unrec_id = btf__add_typedef(btf, "unrec_kind", int_id);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

108

id = btf__add_typedef(btf, "test_lookup", int_id);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

111

id2 = btf__add_typedef(btf, "test_lookup2", int_id);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

115

raw_btf = (void *)btf__raw_data(btf, &raw_size);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

14

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_kind.c

18

btf = btf__new_empty_opts(&opts);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

19

if (!ASSERT_OK_PTR(btf, "btf_new"))

tools/testing/selftests/bpf/prog_tests/btf_kind.c

217

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

22

raw_btf = btf__raw_data(btf, &raw_size);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

32

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

35

btf = btf__new_empty_opts(&opts);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

36

if (!ASSERT_OK_PTR(btf, "btf_new"))

tools/testing/selftests/bpf/prog_tests/btf_kind.c

39

raw_btf = btf__raw_data(btf, &raw_size);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

48

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

76

struct btf *btf = NULL, *new_btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_kind.c

88

btf = btf__new_empty_opts(&opts);

tools/testing/selftests/bpf/prog_tests/btf_kind.c

89

if (!ASSERT_OK_PTR(btf, "btf_new"))

tools/testing/selftests/bpf/prog_tests/btf_kind.c

92

int_id = btf__add_int(btf, "test_char", 1, BTF_INT_CHAR);

tools/testing/selftests/bpf/prog_tests/btf_module.c

12

struct btf *vmlinux_btf, *module_btf;

tools/testing/selftests/bpf/prog_tests/btf_permute.c

106

err = btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

11

btf,

tools/testing/selftests/bpf/prog_tests/btf_permute.c

110

permute_base_check(btf);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

120

err = btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

124

permute_base_check(btf);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

127

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

130

static void permute_split_check(struct btf *btf)

tools/testing/selftests/bpf/prog_tests/btf_permute.c

133

btf,

tools/testing/selftests/bpf/prog_tests/btf_permute.c

148

struct btf *split_btf = NULL, *base_btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_permute.c

26

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_permute.c

30

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/btf_permute.c

31

if (!ASSERT_OK_PTR(btf, "empty_main_btf"))

tools/testing/selftests/bpf/prog_tests/btf_permute.c

34

btf__add_int(btf, "int", 4, BTF_INT_SIGNED); /* [1] int */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

35

btf__add_ptr(btf, 1); /* [2] ptr to int */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

36

btf__add_struct(btf, "s1", 4); /* [3] struct s1 { */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

37

btf__add_field(btf, "m", 1, 0, 0); /* int m; */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

39

btf__add_struct(btf, "s2", 4); /* [4] struct s2 { */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

40

btf__add_field(btf, "m", 1, 0, 0); /* int m; */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

42

btf__add_func_proto(btf, 1); /* [5] int (*)(int *p); */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

43

btf__add_func_param(btf, "p", 2);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

44

btf__add_func(btf, "f", BTF_FUNC_STATIC, 5); /* [6] int f(int *p); */

tools/testing/selftests/bpf/prog_tests/btf_permute.c

47

btf,

tools/testing/selftests/bpf/prog_tests/btf_permute.c

65

err = btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

68

permute_base_check(btf);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

78

err = btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

8

static void permute_base_check(struct btf *btf)

tools/testing/selftests/bpf/prog_tests/btf_permute.c

82

permute_base_check(btf);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

92

err = btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids) - 1, NULL);

tools/testing/selftests/bpf/prog_tests/btf_permute.c

96

permute_base_check(btf);

tools/testing/selftests/bpf/prog_tests/btf_sanitize.c

45

struct btf *orig = NULL, *sanitized = NULL;

tools/testing/selftests/bpf/prog_tests/btf_split.c

16

static ssize_t btf_raw_write(struct btf *btf, char *file)

tools/testing/selftests/bpf/prog_tests/btf_split.c

27

data = btf__raw_data(btf, &size);

tools/testing/selftests/bpf/prog_tests/btf_split.c

52

struct btf *btf1 = NULL, *btf2 = NULL, *btf3 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_split.c

53

struct btf *btf4 = NULL, *btf5 = NULL, *btf6 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

11

static void test_btf_mmap_sysfs(const char *path, struct btf *base)

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

18

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

66

btf = btf__new_split(raw_data, btf_size, base);

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

67

if (!ASSERT_OK_PTR(btf, "parse_btf"))

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

71

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_tag.c

112

struct btf *vmlinux_btf = NULL, *module_btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_tag.c

142

struct btf *vmlinux_btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_tag.c

166

struct btf *vmlinux_btf, *module_btf;

tools/testing/selftests/bpf/prog_tests/btf_tag.c

197

struct btf *vmlinux_btf = NULL;

tools/testing/selftests/bpf/prog_tests/btf_tag.c

54

static int load_btfs(struct btf **vmlinux_btf, struct btf **module_btf,

tools/testing/selftests/bpf/prog_tests/btf_write.c

101

id = btf__add_struct(btf, "s1", 8);

tools/testing/selftests/bpf/prog_tests/btf_write.c

103

err = btf__add_field(btf, "f1", 1, 0, 0);

tools/testing/selftests/bpf/prog_tests/btf_write.c

105

err = btf__add_field(btf, "f2", 1, 32, 16);

tools/testing/selftests/bpf/prog_tests/btf_write.c

108

t = btf__type_by_id(btf, 7);

tools/testing/selftests/bpf/prog_tests/btf_write.c

109

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "s1", "struct_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

115

ASSERT_STREQ(btf__str_by_offset(btf, m->name_off), "f1", "f1_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

120

ASSERT_STREQ(btf__str_by_offset(btf, m->name_off), "f2", "f2_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

124

ASSERT_STREQ(btf_type_raw_dump(btf, 7),

tools/testing/selftests/bpf/prog_tests/btf_write.c

130

id = btf__add_union(btf, "u1", 8);

tools/testing/selftests/bpf/prog_tests/btf_write.c

134

err = btf__add_field(btf, "field", 1, 1, 0);

tools/testing/selftests/bpf/prog_tests/btf_write.c

137

err = btf__add_field(btf, "f1", 1, 0, 16);

tools/testing/selftests/bpf/prog_tests/btf_write.c

140

t = btf__type_by_id(btf, 8);

tools/testing/selftests/bpf/prog_tests/btf_write.c

141

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "u1", "union_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

147

ASSERT_STREQ(btf__str_by_offset(btf, m->name_off), "f1", "f1_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

151

ASSERT_STREQ(btf_type_raw_dump(btf, 8),

tools/testing/selftests/bpf/prog_tests/btf_write.c

156

id = btf__add_enum(btf, "e1", 4);

tools/testing/selftests/bpf/prog_tests/btf_write.c

158

err = btf__add_enum_value(btf, "v1", 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

160

err = btf__add_enum_value(btf, "v2", 2);

tools/testing/selftests/bpf/prog_tests/btf_write.c

163

t = btf__type_by_id(btf, 9);

tools/testing/selftests/bpf/prog_tests/btf_write.c

164

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "e1", "enum_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

169

ASSERT_STREQ(btf__str_by_offset(btf, v->name_off), "v1", "v1_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

17

str_off = btf__find_str(btf, "int");

tools/testing/selftests/bpf/prog_tests/btf_write.c

172

ASSERT_STREQ(btf__str_by_offset(btf, v->name_off), "v2", "v2_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

174

ASSERT_STREQ(btf_type_raw_dump(btf, 9),

tools/testing/selftests/bpf/prog_tests/btf_write.c

180

id = btf__add_fwd(btf, "struct_fwd", BTF_FWD_STRUCT);

tools/testing/selftests/bpf/prog_tests/btf_write.c

182

t = btf__type_by_id(btf, 10);

tools/testing/selftests/bpf/prog_tests/btf_write.c

183

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "struct_fwd", "fwd_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

186

ASSERT_STREQ(btf_type_raw_dump(btf, 10),

tools/testing/selftests/bpf/prog_tests/btf_write.c

189

id = btf__add_fwd(btf, "union_fwd", BTF_FWD_UNION);

tools/testing/selftests/bpf/prog_tests/btf_write.c

191

t = btf__type_by_id(btf, 11);

tools/testing/selftests/bpf/prog_tests/btf_write.c

192

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "union_fwd", "fwd_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

195

ASSERT_STREQ(btf_type_raw_dump(btf, 11),

tools/testing/selftests/bpf/prog_tests/btf_write.c

198

id = btf__add_fwd(btf, "enum_fwd", BTF_FWD_ENUM);

tools/testing/selftests/bpf/prog_tests/btf_write.c

20

str_off = btf__add_str(btf, "int");

tools/testing/selftests/bpf/prog_tests/btf_write.c

200

t = btf__type_by_id(btf, 12);

tools/testing/selftests/bpf/prog_tests/btf_write.c

201

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "enum_fwd", "fwd_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

205

ASSERT_STREQ(btf_type_raw_dump(btf, 12),

tools/testing/selftests/bpf/prog_tests/btf_write.c

209

id = btf__add_typedef(btf, "typedef1", 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

211

t = btf__type_by_id(btf, 13);

tools/testing/selftests/bpf/prog_tests/btf_write.c

212

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "typedef1", "typedef_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

215

ASSERT_STREQ(btf_type_raw_dump(btf, 13),

tools/testing/selftests/bpf/prog_tests/btf_write.c

219

id = btf__add_func(btf, "func1", BTF_FUNC_GLOBAL, 15);

tools/testing/selftests/bpf/prog_tests/btf_write.c

221

t = btf__type_by_id(btf, 14);

tools/testing/selftests/bpf/prog_tests/btf_write.c

222

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "func1", "func_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

226

ASSERT_STREQ(btf_type_raw_dump(btf, 14),

tools/testing/selftests/bpf/prog_tests/btf_write.c

229

id = btf__add_func_proto(btf, 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

23

str_off = btf__find_str(btf, "int");

tools/testing/selftests/bpf/prog_tests/btf_write.c

231

err = btf__add_func_param(btf, "p1", 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

233

err = btf__add_func_param(btf, "p2", 2);

tools/testing/selftests/bpf/prog_tests/btf_write.c

236

t = btf__type_by_id(btf, 15);

tools/testing/selftests/bpf/prog_tests/btf_write.c

241

ASSERT_STREQ(btf__str_by_offset(btf, p->name_off), "p1", "p1_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

244

ASSERT_STREQ(btf__str_by_offset(btf, p->name_off), "p2", "p2_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

246

ASSERT_STREQ(btf_type_raw_dump(btf, 15),

tools/testing/selftests/bpf/prog_tests/btf_write.c

252

id = btf__add_var(btf, "var1", BTF_VAR_GLOBAL_ALLOCATED, 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

254

t = btf__type_by_id(btf, 16);

tools/testing/selftests/bpf/prog_tests/btf_write.c

255

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "var1", "var_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

259

ASSERT_STREQ(btf_type_raw_dump(btf, 16),

tools/testing/selftests/bpf/prog_tests/btf_write.c

263

id = btf__add_datasec(btf, "datasec1", 12);

tools/testing/selftests/bpf/prog_tests/btf_write.c

265

err = btf__add_datasec_var_info(btf, 1, 4, 8);

tools/testing/selftests/bpf/prog_tests/btf_write.c

268

t = btf__type_by_id(btf, 17);

tools/testing/selftests/bpf/prog_tests/btf_write.c

269

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "datasec1", "datasec_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

27

id = btf__add_int(btf, "int", 4, BTF_INT_SIGNED);

tools/testing/selftests/bpf/prog_tests/btf_write.c

277

ASSERT_STREQ(btf_type_raw_dump(btf, 17),

tools/testing/selftests/bpf/prog_tests/btf_write.c

282

id = btf__add_decl_tag(btf, "tag1", 16, -1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

284

t = btf__type_by_id(btf, 18);

tools/testing/selftests/bpf/prog_tests/btf_write.c

285

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "tag1", "tag_value");

tools/testing/selftests/bpf/prog_tests/btf_write.c

289

ASSERT_STREQ(btf_type_raw_dump(btf, 18),

tools/testing/selftests/bpf/prog_tests/btf_write.c

292

id = btf__add_decl_tag(btf, "tag2", 14, 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

294

t = btf__type_by_id(btf, 19);

tools/testing/selftests/bpf/prog_tests/btf_write.c

295

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "tag2", "tag_value");

tools/testing/selftests/bpf/prog_tests/btf_write.c

299

ASSERT_STREQ(btf_type_raw_dump(btf, 19),

tools/testing/selftests/bpf/prog_tests/btf_write.c

30

t = btf__type_by_id(btf, 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

303

id = btf__add_type_tag(btf, "tag1", 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

305

t = btf__type_by_id(btf, 20);

tools/testing/selftests/bpf/prog_tests/btf_write.c

306

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "tag1", "tag_value");

tools/testing/selftests/bpf/prog_tests/btf_write.c

309

ASSERT_STREQ(btf_type_raw_dump(btf, 20),

tools/testing/selftests/bpf/prog_tests/btf_write.c

313

id = btf__add_enum64(btf, "e1", 8, true);

tools/testing/selftests/bpf/prog_tests/btf_write.c

315

err = btf__add_enum64_value(btf, "v1", -1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

317

err = btf__add_enum64_value(btf, "v2", 0x123456789); /* 4886718345 */

tools/testing/selftests/bpf/prog_tests/btf_write.c

319

t = btf__type_by_id(btf, 21);

tools/testing/selftests/bpf/prog_tests/btf_write.c

320

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "e1", "enum64_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

325

ASSERT_STREQ(btf__str_by_offset(btf, v64->name_off), "v1", "v1_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

329

ASSERT_STREQ(btf__str_by_offset(btf, v64->name_off), "v2", "v2_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

33

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "int", "int_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

332

ASSERT_STREQ(btf_type_raw_dump(btf, 21),

tools/testing/selftests/bpf/prog_tests/btf_write.c

337

id = btf__add_enum64(btf, "e1", 8, false);

tools/testing/selftests/bpf/prog_tests/btf_write.c

339

err = btf__add_enum64_value(btf, "v1", 0xffffffffFFFFFFFF); /* 18446744073709551615 */

tools/testing/selftests/bpf/prog_tests/btf_write.c

341

t = btf__type_by_id(btf, 22);

tools/testing/selftests/bpf/prog_tests/btf_write.c

342

ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "e1", "enum64_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

347

ASSERT_STREQ(btf__str_by_offset(btf, v64->name_off), "v1", "v1_name");

tools/testing/selftests/bpf/prog_tests/btf_write.c

350

ASSERT_STREQ(btf_type_raw_dump(btf, 22),

tools/testing/selftests/bpf/prog_tests/btf_write.c

357

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/btf_write.c

359

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/btf_write.c

360

if (!ASSERT_OK_PTR(btf, "new_empty"))

tools/testing/selftests/bpf/prog_tests/btf_write.c

363

gen_btf(btf);

tools/testing/selftests/bpf/prog_tests/btf_write.c

366

btf,

tools/testing/selftests/bpf/prog_tests/btf_write.c

38

ASSERT_STREQ(btf_type_raw_dump(btf, 1),

tools/testing/selftests/bpf/prog_tests/btf_write.c

401

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/btf_write.c

406

struct btf *btf1 = NULL, *btf2 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_write.c

42

id = btf__add_int(btf, "bad sz int", 7, 0);

tools/testing/selftests/bpf/prog_tests/btf_write.c

45

id = btf__add_int(btf, "bad enc int", 4, 123);

tools/testing/selftests/bpf/prog_tests/btf_write.c

48

id = btf__add_int(btf, NULL, 4, 0);

tools/testing/selftests/bpf/prog_tests/btf_write.c

502

struct btf *base = NULL, *split1 = NULL, *split2 = NULL;

tools/testing/selftests/bpf/prog_tests/btf_write.c

503

struct btf *combined = NULL;

tools/testing/selftests/bpf/prog_tests/btf_write.c

51

id = btf__add_int(btf, "", 4, 0);

tools/testing/selftests/bpf/prog_tests/btf_write.c

55

id = btf__add_ptr(btf, 1);

tools/testing/selftests/bpf/prog_tests/btf_write.c

57

t = btf__type_by_id(btf, 2);

tools/testing/selftests/bpf/prog_tests/btf_write.c

60

ASSERT_STREQ(btf_type_raw_dump(btf, 2),

tools/testing/selftests/bpf/prog_tests/btf_write.c

63

id = btf__add_const(btf, 5); /* points forward to restrict */

tools/testing/selftests/bpf/prog_tests/btf_write.c

65

t = btf__type_by_id(btf, 3);

tools/testing/selftests/bpf/prog_tests/btf_write.c

68

ASSERT_STREQ(btf_type_raw_dump(btf, 3),

tools/testing/selftests/bpf/prog_tests/btf_write.c

7

static void gen_btf(struct btf *btf)

tools/testing/selftests/bpf/prog_tests/btf_write.c

71

id = btf__add_volatile(btf, 3);

tools/testing/selftests/bpf/prog_tests/btf_write.c

73

t = btf__type_by_id(btf, 4);

tools/testing/selftests/bpf/prog_tests/btf_write.c

76

ASSERT_STREQ(btf_type_raw_dump(btf, 4),

tools/testing/selftests/bpf/prog_tests/btf_write.c

79

id = btf__add_restrict(btf, 4);

tools/testing/selftests/bpf/prog_tests/btf_write.c

81

t = btf__type_by_id(btf, 5);

tools/testing/selftests/bpf/prog_tests/btf_write.c

84

ASSERT_STREQ(btf_type_raw_dump(btf, 5),

tools/testing/selftests/bpf/prog_tests/btf_write.c

88

id = btf__add_array(btf, 1, 2, 10); /* int *[10] */

tools/testing/selftests/bpf/prog_tests/btf_write.c

90

t = btf__type_by_id(btf, 6);

tools/testing/selftests/bpf/prog_tests/btf_write.c

95

ASSERT_STREQ(btf_type_raw_dump(btf, 6),

tools/testing/selftests/bpf/prog_tests/btf_write.c

99

err = btf__add_field(btf, "field", 1, 0, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

101

err = btf__add_field(btf, "ptr", void_ptr_id, 0, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

102

err = err ?: btf__add_field(btf, "val2", int_id, 32, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

103

err = err ?: btf__add_field(btf, "val1", long_long_id, 64, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

104

err = err ?: btf__add_field(btf, "val3", short_id, 128, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

105

err = err ?: btf__add_field(btf, "val4", char_id, 144, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

115

raw_data = btf__raw_data(btf, &raw_sz);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

221

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

60

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/core_autosize.c

66

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/core_autosize.c

67

if (!ASSERT_OK_PTR(btf, "empty_btf"))

tools/testing/selftests/bpf/prog_tests/core_autosize.c

85

btf__set_pointer_size(btf, 4);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

87

char_id = btf__add_int(btf, "unsigned char", 1, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

89

short_id = btf__add_int(btf, "unsigned short", 2, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

92

int_id = btf__add_int(btf, "long unsigned int", 4, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

94

long_long_id = btf__add_int(btf, "unsigned long long", 8, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

96

void_ptr_id = btf__add_ptr(btf, 0);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

99

id = btf__add_struct(btf, "test_struct", 20 /* bytes */);

tools/testing/selftests/bpf/prog_tests/core_reloc.c

414

static int find_btf_type(const struct btf *btf, const char *name, __u32 kind)

tools/testing/selftests/bpf/prog_tests/core_reloc.c

418

id = btf__find_by_name_kind(btf, name, kind);

tools/testing/selftests/bpf/prog_tests/core_reloc.c

428

struct btf *local_btf = btf__parse(test->bpf_obj_file, NULL);

tools/testing/selftests/bpf/prog_tests/core_reloc.c

429

struct btf *targ_btf = btf__parse(test->btf_src_file, NULL);

tools/testing/selftests/bpf/prog_tests/core_reloc.c

499

struct btf *targ_btf;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

252

static int find_field_offset_aux(struct btf *btf, int btf_id, char *field_name, int off)

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

254

const struct btf_type *type = btf__type_by_id(btf, btf_id);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

273

const char *mname = btf__name_by_offset(btf, m->name_off);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

276

int msize = find_field_offset_aux(btf, m->type, field_name,

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

291

static int find_field_offset(struct btf *btf, char *pattern, regmatch_t *matches)

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

315

btf_id = btf__find_by_name(btf, type_str);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

321

field_offset = find_field_offset_aux(btf, btf_id, field_str, 0);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

492

static bool match_pattern(struct btf *btf, char *pattern, char *text, char *reg_map[][2])

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

563

field_offset = find_field_offset(btf, pattern, matches);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

589

field_offset = find_field_offset(btf, pattern, matches);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

642

static void match_program(struct btf *btf,

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

697

ASSERT_TRUE(match_pattern(btf, pattern, text, reg_map),

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

707

static void run_one_testcase(struct btf *btf, struct test_case *test)

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

751

match_program(btf, &pinfo, test->read, reg_map, false);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

784

match_program(btf, &pinfo, pattern, stx_reg_map, true);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

793

match_program(btf, &pinfo, pattern, st_reg_map, false);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

802

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

810

btf = btf__load_vmlinux_btf();

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

811

if (!btf) {

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

817

run_one_testcase(btf, &test_cases[i]);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

820

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

120

btf_id = btf__find_by_name_kind(btf, tgt_name + 1, BTF_KIND_FUNC);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

459

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

469

btf = btf__load_from_kernel_by_id(info.btf_id);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

470

ret = libbpf_get_error(btf);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

474

ret = btf__find_by_name_kind(btf, name, BTF_KIND_FUNC);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

475

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

69

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

87

btf = bpf_object__btf(tgt_obj);

tools/testing/selftests/bpf/prog_tests/ksyms_btf.c

158

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/ksyms_btf.c

160

btf = libbpf_find_kernel_btf();

tools/testing/selftests/bpf/prog_tests/ksyms_btf.c

161

if (!ASSERT_OK_PTR(btf, "btf_exists"))

tools/testing/selftests/bpf/prog_tests/ksyms_btf.c

164

percpu_datasec = btf__find_by_name_kind(btf, ".data..percpu",

tools/testing/selftests/bpf/prog_tests/ksyms_btf.c

166

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

14

btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

15

if (!ASSERT_OK_PTR(btf, "btf_parse"))

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

19

id = btf__find_by_name_kind(btf, "bpf_prog_type", BTF_KIND_ENUM);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

22

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

27

const char *prog_type_name = btf__str_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

44

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

49

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

54

btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

55

if (!ASSERT_OK_PTR(btf, "btf_parse"))

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

59

id = btf__find_by_name_kind(btf, "bpf_map_type", BTF_KIND_ENUM);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

62

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

67

const char *map_type_name = btf__str_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

84

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

9

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

104

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

113

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

118

btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

119

if (!ASSERT_OK_PTR(btf, "btf_parse"))

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

123

id = btf__find_by_name_kind(btf, "bpf_map_type", BTF_KIND_ENUM);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

126

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

138

map_type_name = btf__str_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

161

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

170

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

175

btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

176

if (!ASSERT_OK_PTR(btf, "btf_parse"))

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

180

id = btf__find_by_name_kind(btf, "bpf_prog_type", BTF_KIND_ENUM);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

183

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

195

prog_type_name = btf__str_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

206

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

23

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

28

btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

29

if (!ASSERT_OK_PTR(btf, "btf_parse"))

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

33

id = btf__find_by_name_kind(btf, "bpf_attach_type", BTF_KIND_ENUM);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

36

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

48

attach_type_name = btf__str_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

59

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

68

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

73

btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

74

if (!ASSERT_OK_PTR(btf, "btf_parse"))

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

78

id = btf__find_by_name_kind(btf, "bpf_link_type", BTF_KIND_ENUM);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

81

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/prog_tests/libbpf_str.c

93

link_type_name = btf__str_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/prog_tests/linked_list.c

250

static struct btf *init_btf(void)

tools/testing/selftests/bpf/prog_tests/linked_list.c

253

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/linked_list.c

255

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/linked_list.c

256

if (!ASSERT_OK_PTR(btf, "btf__new_empty"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

258

id = btf__add_int(btf, "int", 4, BTF_INT_SIGNED);

tools/testing/selftests/bpf/prog_tests/linked_list.c

261

lid = btf__add_struct(btf, "bpf_spin_lock", 4);

tools/testing/selftests/bpf/prog_tests/linked_list.c

264

hid = btf__add_struct(btf, "bpf_list_head", 16);

tools/testing/selftests/bpf/prog_tests/linked_list.c

267

nid = btf__add_struct(btf, "bpf_list_node", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

270

return btf;

tools/testing/selftests/bpf/prog_tests/linked_list.c

272

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

279

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/linked_list.c

282

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

283

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

286

bpf_rb_node_btf_id = btf__add_struct(btf, "bpf_rb_node", 32);

tools/testing/selftests/bpf/prog_tests/linked_list.c

291

bpf_refcount_btf_id = btf__add_struct(btf, "bpf_refcount", 4);

tools/testing/selftests/bpf/prog_tests/linked_list.c

296

id = btf__add_struct(btf, "bar", refcount_field ? 60 : 56);

tools/testing/selftests/bpf/prog_tests/linked_list.c

299

err = btf__add_field(btf, "a", LIST_NODE, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

302

err = btf__add_field(btf, "c", bpf_rb_node_btf_id, 192, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

306

err = btf__add_field(btf, "ref", bpf_refcount_btf_id, 448, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

311

foo_btf_id = btf__add_struct(btf, "foo", 20);

tools/testing/selftests/bpf/prog_tests/linked_list.c

314

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

317

err = btf__add_field(btf, "b", SPIN_LOCK, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

320

id = btf__add_decl_tag(btf, "contains:bar:a", foo_btf_id, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

324

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

326

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

331

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/linked_list.c

335

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

336

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

338

id = btf__add_struct(btf, "foo", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

341

err = btf__add_field(btf, "a", SPIN_LOCK, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

344

err = btf__add_field(btf, "b", SPIN_LOCK, 32, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

347

err = btf__add_field(btf, "c", LIST_HEAD, 64, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

351

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

353

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

358

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

359

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

361

id = btf__add_struct(btf, "foo", 16);

tools/testing/selftests/bpf/prog_tests/linked_list.c

364

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

367

id = btf__add_decl_tag(btf, "contains:baz:a", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

370

id = btf__add_struct(btf, "baz", 16);

tools/testing/selftests/bpf/prog_tests/linked_list.c

373

err = btf__add_field(btf, "a", LIST_NODE, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

377

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

379

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

384

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

385

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

387

id = btf__add_struct(btf, "foo", 36);

tools/testing/selftests/bpf/prog_tests/linked_list.c

390

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

393

err = btf__add_field(btf, "b", LIST_NODE, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

396

err = btf__add_field(btf, "c", SPIN_LOCK, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

399

id = btf__add_decl_tag(btf, "contains:foo:b", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

403

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

405

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

410

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

411

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

413

id = btf__add_struct(btf, "foo", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

416

err = btf__add_field(btf, "a", SPIN_LOCK, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

419

err = btf__add_field(btf, "b", LIST_HEAD, 64, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

423

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

425

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

430

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

431

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

433

id = btf__add_struct(btf, "foo", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

436

err = btf__add_field(btf, "a", SPIN_LOCK, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

439

err = btf__add_field(btf, "b", LIST_HEAD, 64, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

442

id = btf__add_decl_tag(btf, "contains:bar:bar", 5, 1);

tools/testing/selftests/bpf/prog_tests/linked_list.c

446

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

448

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

453

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

454

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

456

id = btf__add_struct(btf, "foo", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

459

err = btf__add_field(btf, "a", SPIN_LOCK, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

462

err = btf__add_field(btf, "b", LIST_HEAD, 64, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

465

id = btf__add_decl_tag(btf, "contains:foo:c", 5, 1);

tools/testing/selftests/bpf/prog_tests/linked_list.c

469

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

470

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

476

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

477

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

479

id = btf__add_struct(btf, "foo", 20);

tools/testing/selftests/bpf/prog_tests/linked_list.c

482

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

485

err = btf__add_field(btf, "b", SPIN_LOCK, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

488

id = btf__add_decl_tag(btf, "contains:bar:a", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

491

id = btf__add_struct(btf, "bar", 4);

tools/testing/selftests/bpf/prog_tests/linked_list.c

494

err = btf__add_field(btf, "a", SPIN_LOCK, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

498

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

500

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

505

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

506

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

508

id = btf__add_struct(btf, "foo", 52);

tools/testing/selftests/bpf/prog_tests/linked_list.c

511

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

514

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

517

err = btf__add_field(btf, "b", LIST_NODE, 256, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

520

err = btf__add_field(btf, "d", SPIN_LOCK, 384, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

523

id = btf__add_decl_tag(btf, "contains:foo:b", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

527

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

529

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

534

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

535

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

537

id = btf__add_struct(btf, "foo", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

540

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

543

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

546

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

549

id = btf__add_decl_tag(btf, "contains:foo:b", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

553

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

555

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

560

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

561

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

563

id = btf__add_struct(btf, "foo", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

566

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

569

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

572

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

575

id = btf__add_decl_tag(btf, "contains:bar:b", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

578

id = btf__add_struct(btf, "bar", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

581

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

584

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

587

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

590

id = btf__add_decl_tag(btf, "contains:foo:b", 7, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

594

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

596

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

601

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

602

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

604

id = btf__add_struct(btf, "foo", 28);

tools/testing/selftests/bpf/prog_tests/linked_list.c

607

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

610

err = btf__add_field(btf, "b", SPIN_LOCK, 192, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

613

id = btf__add_decl_tag(btf, "contains:bar:a", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

616

id = btf__add_struct(btf, "bar", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

619

err = btf__add_field(btf, "a", LIST_NODE, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

623

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

625

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

630

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

631

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

633

id = btf__add_struct(btf, "foo", 28);

tools/testing/selftests/bpf/prog_tests/linked_list.c

636

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

639

err = btf__add_field(btf, "b", SPIN_LOCK, 192, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

642

id = btf__add_decl_tag(btf, "contains:bar:b", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

645

id = btf__add_struct(btf, "bar", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

648

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

651

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

654

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

657

id = btf__add_decl_tag(btf, "contains:baz:a", 7, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

660

id = btf__add_struct(btf, "baz", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

663

err = btf__add_field(btf, "a", LIST_NODE, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

667

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

669

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

674

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

675

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

677

id = btf__add_struct(btf, "foo", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

680

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

683

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

686

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

689

id = btf__add_decl_tag(btf, "contains:bar:b", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

692

id = btf__add_struct(btf, "bar", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

695

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

698

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

701

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

704

id = btf__add_decl_tag(btf, "contains:baz:a", 7, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

707

id = btf__add_struct(btf, "baz", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

710

err = btf__add_field(btf, "a", LIST_NODE, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

714

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

716

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

721

btf = init_btf();

tools/testing/selftests/bpf/prog_tests/linked_list.c

722

if (!ASSERT_OK_PTR(btf, "init_btf"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

724

id = btf__add_struct(btf, "foo", 20);

tools/testing/selftests/bpf/prog_tests/linked_list.c

727

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

730

err = btf__add_field(btf, "b", SPIN_LOCK, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

733

id = btf__add_decl_tag(btf, "contains:bar:b", 5, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

736

id = btf__add_struct(btf, "bar", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

739

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

742

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

745

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

748

id = btf__add_decl_tag(btf, "contains:baz:b", 7, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

751

id = btf__add_struct(btf, "baz", 44);

tools/testing/selftests/bpf/prog_tests/linked_list.c

754

err = btf__add_field(btf, "a", LIST_HEAD, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

757

err = btf__add_field(btf, "b", LIST_NODE, 128, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

760

err = btf__add_field(btf, "c", SPIN_LOCK, 320, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

763

id = btf__add_decl_tag(btf, "contains:bam:a", 9, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

766

id = btf__add_struct(btf, "bam", 24);

tools/testing/selftests/bpf/prog_tests/linked_list.c

769

err = btf__add_field(btf, "a", LIST_NODE, 0, 0);

tools/testing/selftests/bpf/prog_tests/linked_list.c

773

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/linked_list.c

775

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/log_buf.c

206

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/log_buf.c

210

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/log_buf.c

211

if (!ASSERT_OK_PTR(btf, "empty_btf"))

tools/testing/selftests/bpf/prog_tests/log_buf.c

214

ASSERT_GT(btf__add_int(btf, "int", 4, 0), 0, "int_type");

tools/testing/selftests/bpf/prog_tests/log_buf.c

216

raw_btf_data = btf__raw_data(btf, &raw_btf_size);

tools/testing/selftests/bpf/prog_tests/log_buf.c

248

ASSERT_GT(btf__add_ptr(btf, 100), 0, "bad_ptr_type");

tools/testing/selftests/bpf/prog_tests/log_buf.c

250

raw_btf_data = btf__raw_data(btf, &raw_btf_size);

tools/testing/selftests/bpf/prog_tests/log_buf.c

267

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c

13

static struct btf *btf;

tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c

30

if (!btf)

tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c

31

btf = btf__load_vmlinux_btf();

tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c

318

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c

32

if (!ASSERT_OK(libbpf_get_error(btf), "btf_vmlinux"))

tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c

51

btf__find_by_name_kind(btf, attach_func, BTF_KIND_FUNC))

tools/testing/selftests/bpf/prog_tests/module_fentry_shadow.c

58

struct btf *vmlinux_btf = NULL, *mod_btf = NULL;

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

100

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

104

btf = btf__parse_raw("resolve_btfids.test.o.BTF");

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

105

if (CHECK(libbpf_get_error(btf), "resolve",

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

109

nr = btf__type_cnt(btf);

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

112

if (__resolve_symbol(btf, type_id))

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

116

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

66

__resolve_symbol(struct btf *btf, int type_id)

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

72

type = btf__type_by_id(btf, type_id);

tools/testing/selftests/bpf/prog_tests/resolve_btfids.c

85

str = btf__name_by_offset(btf, type->name_off);

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

468

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

476

btf = bpf_object__btf(skel->obj);

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

477

err = btf__load_into_kernel(btf);

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

482

create_attr.btf_fd = btf__fd(btf);

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

16

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

24

btf = bpf_object__btf(skel->obj);

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

25

if (!ASSERT_OK_PTR(btf, "btf"))

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

30

id = btf__find_by_name_kind(btf, tname, BTF_KIND_STRUCT);

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

38

id = btf__find_by_name_kind(btf, tname, BTF_KIND_STRUCT);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

100

fn_t = btf__type_by_id(btf, rec->type_id);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

105

proto_t = btf__type_by_id(btf, fn_t->type);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

109

name = btf__name_by_offset(btf, fn_t->name_off);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

116

check_ctx_arg_type(btf, &btf_params(proto_t)[0]);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

126

check_ctx_arg_type(btf, &btf_params(proto_t)[0]);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

128

check_ctx_arg_type(btf, &btf_params(proto_t)[2]);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

136

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

27

static void check_ctx_arg_type(const struct btf *btf, const struct btf_param *p)

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

32

t = btf__type_by_id(btf, p->type);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

36

s = btf_type_raw_dump(btf, t->type);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

48

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

51

struct btf *kern_btf = NULL;

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

88

btf = btf__load_from_kernel_by_id(info.btf_id);

tools/testing/selftests/bpf/prog_tests/test_global_funcs.c

89

if (!ASSERT_OK_PTR(btf, "obj_kern_btf"))

tools/testing/selftests/bpf/prog_tests/token.c

579

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/token.c

599

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/token.c

600

if (!ASSERT_OK_PTR(btf, "empty_btf"))

tools/testing/selftests/bpf/prog_tests/token.c

603

ASSERT_GT(btf__add_int(btf, "int", 4, 0), 0, "int_type");

tools/testing/selftests/bpf/prog_tests/token.c

605

raw_btf_data = btf__raw_data(btf, &raw_btf_size);

tools/testing/selftests/bpf/prog_tests/token.c

637

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/unpriv_bpf_disabled.c

137

struct btf *btf = NULL;

tools/testing/selftests/bpf/prog_tests/unpriv_bpf_disabled.c

188

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/unpriv_bpf_disabled.c

189

if (ASSERT_OK_PTR(btf, "empty_btf") &&

tools/testing/selftests/bpf/prog_tests/unpriv_bpf_disabled.c

190

ASSERT_GT(btf__add_int(btf, "int", 4, 0), 0, "unpriv_int_type")) {

tools/testing/selftests/bpf/prog_tests/unpriv_bpf_disabled.c

194

raw_btf_data = btf__raw_data(btf, &raw_btf_size);

tools/testing/selftests/bpf/prog_tests/unpriv_bpf_disabled.c

199

btf__free(btf);

tools/testing/selftests/bpf/prog_tests/verifier_log.c

272

struct btf *btf;

tools/testing/selftests/bpf/prog_tests/verifier_log.c

280

btf = btf__new_empty();

tools/testing/selftests/bpf/prog_tests/verifier_log.c

281

if (!ASSERT_OK_PTR(btf, "btf_new_empty"))

tools/testing/selftests/bpf/prog_tests/verifier_log.c

283

res = btf__add_int(btf, "whatever", 4, 0);

tools/testing/selftests/bpf/prog_tests/verifier_log.c

291

t = (void *)btf__type_by_id(btf, res);

tools/testing/selftests/bpf/prog_tests/verifier_log.c

297

btf_data = btf__raw_data(btf, &btf_data_sz);

tools/testing/selftests/bpf/prog_tests/verifier_log.c

433

btf__free(btf);

tools/testing/selftests/bpf/progs/bpf_mod_race.c

94

int BPF_PROG(fexit_module_get, const struct btf *btf, struct module *mod)

tools/testing/selftests/bpf/progs/syscall.c

94

btf_load_attr.btf = (long)&raw_btf;

tools/testing/selftests/bpf/test_cpp.cpp

107

struct btf *btf;

tools/testing/selftests/bpf/test_cpp.cpp

119

btf = btf__new(NULL, 0);

tools/testing/selftests/bpf/test_cpp.cpp

120

if (!libbpf_get_error(btf))

tools/testing/selftests/bpf/test_cpp.cpp

121

btf_dump__new(btf, dump_printf, nullptr, &opts);

tools/testing/selftests/bpf/test_kmods/bpf_test_no_cfi.c

13

static int dummy_init(struct btf *btf)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1333

static int bpf_testmod_ops_init(struct btf *btf)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1739

static int st_ops_init(struct btf *btf)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1741

struct btf *kfunc_btf;

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1772

static int multi_st_ops_init(struct btf *btf)

tools/testing/selftests/bpf/test_loader.c

348

static const char **collect_decl_tags(struct btf *btf, int id, int *cnt)

tools/testing/selftests/bpf/test_loader.c

355

for (i = 1; i < btf__type_cnt(btf); i++) {

tools/testing/selftests/bpf/test_loader.c

356

t = btf__type_by_id(btf, i);

tools/testing/selftests/bpf/test_loader.c

365

tags[(*cnt)++] = btf__str_by_offset(btf, t->name_off);

tools/testing/selftests/bpf/test_loader.c

421

struct btf *btf;

tools/testing/selftests/bpf/test_loader.c

429

btf = bpf_object__btf(obj);

tools/testing/selftests/bpf/test_loader.c

430

if (!btf) {

tools/testing/selftests/bpf/test_loader.c

435

func_id = btf__find_by_name_kind(btf, spec->prog_name, BTF_KIND_FUNC);

tools/testing/selftests/bpf/test_loader.c

441

tags = collect_decl_tags(btf, func_id, &nr_tags);

tools/testing/selftests/bpf/test_progs.c

1254

int get_bpf_max_tramp_links_from(struct btf *btf)

tools/testing/selftests/bpf/test_progs.c

1262

for (i = 1, type_cnt = btf__type_cnt(btf); i < type_cnt; i++) {

tools/testing/selftests/bpf/test_progs.c

1263

t = btf__type_by_id(btf, i);

tools/testing/selftests/bpf/test_progs.c

1268

name = btf__str_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/test_progs.c

1279

struct btf *vmlinux_btf;

tools/testing/selftests/bpf/test_progs.h

499

int get_bpf_max_tramp_links_from(struct btf *btf);

tools/testing/selftests/bpf/test_verifier.c

893

static struct btf *btf__load_testmod_btf(struct btf *vmlinux)

tools/testing/selftests/bpf/test_verifier.c

897

struct btf *btf = NULL;

tools/testing/selftests/bpf/test_verifier.c

941

btf = btf__load_from_kernel_by_id_split(id, vmlinux);

tools/testing/selftests/bpf/test_verifier.c

942

if (!btf) {

tools/testing/selftests/bpf/test_verifier.c

951

btf__set_fd(btf, fd);

tools/testing/selftests/bpf/test_verifier.c

956

return btf;

tools/testing/selftests/bpf/test_verifier.c

959

static struct btf *testmod_btf;

tools/testing/selftests/bpf/test_verifier.c

960

static struct btf *vmlinux_btf;

tools/testing/selftests/bpf/veristat.c

1213

struct btf *btf = bpf_object__btf(obj);

tools/testing/selftests/bpf/veristat.c

1220

t = btf__type_by_id(btf, bpf_map__btf_value_type_id(map));

tools/testing/selftests/bpf/veristat.c

1227

mt = btf__type_by_id(btf, m->type);

tools/testing/selftests/bpf/veristat.c

1278

const struct btf *btf = bpf_object__btf(obj);

tools/testing/selftests/bpf/veristat.c

1286

if (!btf)

tools/testing/selftests/bpf/veristat.c

1289

id = btf__find_by_name_kind(btf, prog_name, BTF_KIND_FUNC);

tools/testing/selftests/bpf/veristat.c

1290

t = btf__type_by_id(btf, id);

tools/testing/selftests/bpf/veristat.c

1291

t = btf__type_by_id(btf, t->type);

tools/testing/selftests/bpf/veristat.c

1296

t = btf__type_by_id(btf, btf_params(t)[0].type);

tools/testing/selftests/bpf/veristat.c

1298

t = btf__type_by_id(btf, t->type);

tools/testing/selftests/bpf/veristat.c

1301

t = btf__type_by_id(btf, t->type);

tools/testing/selftests/bpf/veristat.c

1303

t = btf__type_by_id(btf, t->type);

tools/testing/selftests/bpf/veristat.c

1307

ctx_name = btf__name_by_offset(btf, t->name_off);

tools/testing/selftests/bpf/veristat.c

1852

static int enum_value_from_name(const struct btf *btf, const struct btf_type *t,

tools/testing/selftests/bpf/veristat.c

1860

const char *cur_name = btf__name_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/veristat.c

1872

const char *cur_name = btf__name_by_offset(btf, e->name_off);

tools/testing/selftests/bpf/veristat.c

1889

static int find_enum_value(const struct btf *btf, const char *name, long long *value)

tools/testing/selftests/bpf/veristat.c

1895

cnt = btf__type_cnt(btf);

tools/testing/selftests/bpf/veristat.c

1897

t = btf__type_by_id(btf, i);

tools/testing/selftests/bpf/veristat.c

1902

if (enum_value_from_name(btf, t, name, &lvalue) == 0) {

tools/testing/selftests/bpf/veristat.c

1910

static int resolve_rvalue(struct btf *btf, const struct rvalue *rvalue, long long *result)

tools/testing/selftests/bpf/veristat.c

1919

err = find_enum_value(btf, rvalue->svalue, result);

tools/testing/selftests/bpf/veristat.c

1932

static int adjust_var_secinfo_array(struct btf *btf, int tid, struct field_access *atom,

tools/testing/selftests/bpf/veristat.c

1940

tid = btf__resolve_type(btf, tid);

tools/testing/selftests/bpf/veristat.c

1941

t = btf__type_by_id(btf, tid);

tools/testing/selftests/bpf/veristat.c

1948

err = resolve_rvalue(btf, &atom->index, &idx);

tools/testing/selftests/bpf/veristat.c

1956

sinfo->size = btf__resolve_size(btf, barr->type);

tools/testing/selftests/bpf/veristat.c

1958

sinfo->type = btf__resolve_type(btf, barr->type);

tools/testing/selftests/bpf/veristat.c

1962

static int adjust_var_secinfo_member(const struct btf *btf,

tools/testing/selftests/bpf/veristat.c

1981

tid = btf__resolve_type(btf, member->type);

tools/testing/selftests/bpf/veristat.c

1985

member_type = btf__type_by_id(btf, tid);

tools/testing/selftests/bpf/veristat.c

1988

const char *name = btf__name_by_offset(btf, member->name_off);

tools/testing/selftests/bpf/veristat.c

2004

err = adjust_var_secinfo_member(btf, member_type, off,

tools/testing/selftests/bpf/veristat.c

2014

static int adjust_var_secinfo(struct btf *btf, const struct btf_type *t,

tools/testing/selftests/bpf/veristat.c

2025

tid = btf__resolve_type(btf, t->type);

tools/testing/selftests/bpf/veristat.c

2026

base_type = btf__type_by_id(btf, tid);

tools/testing/selftests/bpf/veristat.c

2034

err = adjust_var_secinfo_array(btf, tid, atom, prev_name, sinfo);

tools/testing/selftests/bpf/veristat.c

2037

err = adjust_var_secinfo_member(btf, base_type, 0, atom->name, sinfo);

tools/testing/selftests/bpf/veristat.c

2048

base_type = btf__type_by_id(btf, sinfo->type);

tools/testing/selftests/bpf/veristat.c

2055

static int set_global_var(struct bpf_object *obj, struct btf *btf,

tools/testing/selftests/bpf/veristat.c

2064

base_type = btf__type_by_id(btf, btf__resolve_type(btf, sinfo->type));

tools/testing/selftests/bpf/veristat.c

2077

if (enum_value_from_name(btf, base_type, preset->value.svalue, &value)) {

tools/testing/selftests/bpf/veristat.c

2086

btf__name_by_offset(btf, base_type->name_off));

tools/testing/selftests/bpf/veristat.c

2100

btf__name_by_offset(btf, base_type->name_off), value,

tools/testing/selftests/bpf/veristat.c

2126

struct btf *btf;

tools/testing/selftests/bpf/veristat.c

2132

btf = bpf_object__btf(obj);

tools/testing/selftests/bpf/veristat.c

2133

if (!btf)

tools/testing/selftests/bpf/veristat.c

2136

cnt = btf__type_cnt(btf);

tools/testing/selftests/bpf/veristat.c

2138

t = btf__type_by_id(btf, i);

tools/testing/selftests/bpf/veristat.c

2144

sec_name = btf__name_by_offset(btf, t->name_off);

tools/testing/selftests/bpf/veristat.c

2151

const struct btf_type *var_type = btf__type_by_id(btf, sinfo->type);

tools/testing/selftests/bpf/veristat.c

2157

var_name = btf__name_by_offset(btf, var_type->name_off);

tools/testing/selftests/bpf/veristat.c

2171

err = adjust_var_secinfo(btf, var_type,

tools/testing/selftests/bpf/veristat.c

2176

err = set_global_var(obj, btf, map, &tmp_sinfo, presets + k);