Lines Matching defs:btf
17 #include <linux/btf.h>
23 #include "btf.h"
35 struct btf {
101 struct btf *base_btf;
196 static void *btf_add_type_offs_mem(struct btf *btf, size_t add_cnt)
198 return libbpf_add_mem((void **)&btf->type_offs, &btf->type_offs_cap, sizeof(__u32),
199 btf->nr_types, BTF_MAX_NR_TYPES, add_cnt);
202 static int btf_add_type_idx_entry(struct btf *btf, __u32 type_off)
206 p = btf_add_type_offs_mem(btf, 1);
224 static int btf_parse_hdr(struct btf *btf)
226 struct btf_header *hdr = btf->hdr;
229 if (btf->raw_size < sizeof(struct btf_header)) {
235 btf->swapped_endian = true;
247 if (btf->raw_size < hdr->hdr_len) {
249 hdr->hdr_len, btf->raw_size);
253 meta_left = btf->raw_size - hdr->hdr_len;
255 pr_debug("Invalid BTF total size: %u\n", btf->raw_size);
273 static int btf_parse_str_sec(struct btf *btf)
275 const struct btf_header *hdr = btf->hdr;
276 const char *start = btf->strs_data;
277 const char *end = start + btf->hdr->str_len;
279 if (btf->base_btf && hdr->str_len == 0)
285 if (!btf->base_btf && start[0]) {
417 static int btf_parse_type_sec(struct btf *btf)
419 struct btf_header *hdr = btf->hdr;
420 void *next_type = btf->types_data;
425 if (btf->swapped_endian)
432 pr_warn("BTF type [%d] is malformed\n", btf->start_id + btf->nr_types);
436 if (btf->swapped_endian && btf_bswap_type_rest(next_type))
439 err = btf_add_type_idx_entry(btf, next_type - btf->types_data);
444 btf->nr_types++;
455 static int btf_validate_str(const struct btf *btf, __u32 str_off, const char *what, __u32 type_id)
459 s = btf__str_by_offset(btf, str_off);
461 pr_warn("btf: type [%u]: invalid %s (string offset %u)\n", type_id, what, str_off);
468 static int btf_validate_id(const struct btf *btf, __u32 id, __u32 ctx_id)
472 t = btf__type_by_id(btf, id);
474 pr_warn("btf: type [%u]: invalid referenced type ID %u\n", ctx_id, id);
481 static int btf_validate_type(const struct btf *btf, const struct btf_type *t, __u32 id)
486 err = btf_validate_str(btf, t->name_off, "type name", id);
504 err = btf_validate_id(btf, t->type, id);
511 err = btf_validate_id(btf, a->type, id);
512 err = err ?: btf_validate_id(btf, a->index_type, id);
523 err = btf_validate_str(btf, m->name_off, "field name", id);
524 err = err ?: btf_validate_id(btf, m->type, id);
535 err = btf_validate_str(btf, m->name_off, "enum name", id);
546 err = btf_validate_str(btf, m->name_off, "enum name", id);
555 err = btf_validate_id(btf, t->type, id);
558 ft = btf__type_by_id(btf, t->type);
560 pr_warn("btf: type [%u]: referenced type [%u] is not FUNC_PROTO\n", id, t->type);
570 err = btf_validate_str(btf, m->name_off, "param name", id);
571 err = err ?: btf_validate_id(btf, m->type, id);
582 err = btf_validate_id(btf, m->type, id);
589 pr_warn("btf: type [%u]: unrecognized kind %u\n", id, kind);
599 static int btf_sanity_check(const struct btf *btf)
602 __u32 i, n = btf__type_cnt(btf);
606 t = btf_type_by_id(btf, i);
607 err = btf_validate_type(btf, t, i);
614 __u32 btf__type_cnt(const struct btf *btf)
616 return btf->start_id + btf->nr_types;
619 const struct btf *btf__base_btf(const struct btf *btf)
621 return btf->base_btf;
625 struct btf_type *btf_type_by_id(const struct btf *btf, __u32 type_id)
629 if (type_id < btf->start_id)
630 return btf_type_by_id(btf->base_btf, type_id);
631 return btf->types_data + btf->type_offs[type_id - btf->start_id];
634 const struct btf_type *btf__type_by_id(const struct btf *btf, __u32 type_id)
636 if (type_id >= btf->start_id + btf->nr_types)
638 return btf_type_by_id((struct btf *)btf, type_id);
641 static int determine_ptr_size(const struct btf *btf)
660 if (btf->base_btf && btf->base_btf->ptr_sz > 0)
661 return btf->base_btf->ptr_sz;
663 n = btf__type_cnt(btf);
665 t = btf__type_by_id(btf, i);
672 name = btf__name_by_offset(btf, t->name_off);
685 static size_t btf_ptr_sz(const struct btf *btf)
687 if (!btf->ptr_sz)
688 ((struct btf *)btf)->ptr_sz = determine_ptr_size(btf);
689 return btf->ptr_sz < 0 ? sizeof(void *) : btf->ptr_sz;
700 size_t btf__pointer_size(const struct btf *btf)
702 if (!btf->ptr_sz)
703 ((struct btf *)btf)->ptr_sz = determine_ptr_size(btf);
705 if (btf->ptr_sz < 0)
709 return btf->ptr_sz;
715 int btf__set_pointer_size(struct btf *btf, size_t ptr_sz)
719 btf->ptr_sz = ptr_sz;
734 enum btf_endianness btf__endianness(const struct btf *btf)
737 return btf->swapped_endian ? BTF_LITTLE_ENDIAN : BTF_BIG_ENDIAN;
739 return btf->swapped_endian ? BTF_BIG_ENDIAN : BTF_LITTLE_ENDIAN;
742 int btf__set_endianness(struct btf *btf, enum btf_endianness endian)
747 btf->swapped_endian = is_host_big_endian() != (endian == BTF_BIG_ENDIAN);
748 if (!btf->swapped_endian) {
749 free(btf->raw_data_swapped);
750 btf->raw_data_swapped = NULL;
767 __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
775 t = btf__type_by_id(btf, type_id);
788 size = btf_ptr_sz(btf);
810 t = btf__type_by_id(btf, type_id);
822 int btf__align_of(const struct btf *btf, __u32 id)
824 const struct btf_type *t = btf__type_by_id(btf, id);
832 return min(btf_ptr_sz(btf), (size_t)t->size);
834 return btf_ptr_sz(btf);
840 return btf__align_of(btf, t->type);
842 return btf__align_of(btf, btf_array(t)->type);
850 align = btf__align_of(btf, m->type);
877 int btf__resolve_type(const struct btf *btf, __u32 type_id)
882 t = btf__type_by_id(btf, type_id);
887 t = btf__type_by_id(btf, type_id);
897 __s32 btf__find_by_name(const struct btf *btf, const char *type_name)
899 __u32 i, nr_types = btf__type_cnt(btf);
905 const struct btf_type *t = btf__type_by_id(btf, i);
906 const char *name = btf__name_by_offset(btf, t->name_off);
915 static __s32 btf_find_by_name_kind(const struct btf *btf, int start_id,
918 __u32 i, nr_types = btf__type_cnt(btf);
924 const struct btf_type *t = btf__type_by_id(btf, i);
929 name = btf__name_by_offset(btf, t->name_off);
937 __s32 btf__find_by_name_kind_own(const struct btf *btf, const char *type_name,
940 return btf_find_by_name_kind(btf, btf->start_id, type_name, kind);
943 __s32 btf__find_by_name_kind(const struct btf *btf, const char *type_name,
946 return btf_find_by_name_kind(btf, 1, type_name, kind);
949 static bool btf_is_modifiable(const struct btf *btf)
951 return (void *)btf->hdr != btf->raw_data;
954 void btf__free(struct btf *btf)
956 if (IS_ERR_OR_NULL(btf))
959 if (btf->fd >= 0)
960 close(btf->fd);
962 if (btf_is_modifiable(btf)) {
969 free(btf->hdr);
970 free(btf->types_data);
971 strset__free(btf->strs_set);
973 free(btf->raw_data);
974 free(btf->raw_data_swapped);
975 free(btf->type_offs);
976 free(btf);
979 static struct btf *btf_new_empty(struct btf *base_btf)
981 struct btf *btf;
983 btf = calloc(1, sizeof(*btf));
984 if (!btf)
987 btf->nr_types = 0;
988 btf->start_id = 1;
989 btf->start_str_off = 0;
990 btf->fd = -1;
991 btf->ptr_sz = sizeof(void *);
992 btf->swapped_endian = false;
995 btf->base_btf = base_btf;
996 btf->start_id = btf__type_cnt(base_btf);
997 btf->start_str_off = base_btf->hdr->str_len;
1001 btf->raw_size = sizeof(struct btf_header) + (base_btf ? 0 : 1);
1002 btf->raw_data = calloc(1, btf->raw_size);
1003 if (!btf->raw_data) {
1004 free(btf);
1008 btf->hdr = btf->raw_data;
1009 btf->hdr->hdr_len = sizeof(struct btf_header);
1010 btf->hdr->magic = BTF_MAGIC;
1011 btf->hdr->version = BTF_VERSION;
1013 btf->types_data = btf->raw_data + btf->hdr->hdr_len;
1014 btf->strs_data = btf->raw_data + btf->hdr->hdr_len;
1015 btf->hdr->str_len = base_btf ? 0 : 1; /* empty string at offset 0 */
1017 return btf;
1020 struct btf *btf__new_empty(void)
1025 struct btf *btf__new_empty_split(struct btf *base_btf)
1030 static struct btf *btf_new(const void *data, __u32 size, struct btf *base_btf)
1032 struct btf *btf;
1035 btf = calloc(1, sizeof(struct btf));
1036 if (!btf)
1039 btf->nr_types = 0;
1040 btf->start_id = 1;
1041 btf->start_str_off = 0;
1042 btf->fd = -1;
1045 btf->base_btf = base_btf;
1046 btf->start_id = btf__type_cnt(base_btf);
1047 btf->start_str_off = base_btf->hdr->str_len;
1050 btf->raw_data = malloc(size);
1051 if (!btf->raw_data) {
1055 memcpy(btf->raw_data, data, size);
1056 btf->raw_size = size;
1058 btf->hdr = btf->raw_data;
1059 err = btf_parse_hdr(btf);
1063 btf->strs_data = btf->raw_data + btf->hdr->hdr_len + btf->hdr->str_off;
1064 btf->types_data = btf->raw_data + btf->hdr->hdr_len + btf->hdr->type_off;
1066 err = btf_parse_str_sec(btf);
1067 err = err ?: btf_parse_type_sec(btf);
1068 err = err ?: btf_sanity_check(btf);
1074 btf__free(btf);
1078 return btf;
1081 struct btf *btf__new(const void *data, __u32 size)
1106 static struct btf *btf_parse_elf(const char *path, struct btf *base_btf,
1111 struct btf *btf = NULL;
1260 btf = btf_new(btf_data->d_buf, btf_data->d_size, base_btf);
1261 err = libbpf_get_error(btf);
1271 btf__set_pointer_size(btf, 4);
1274 btf__set_pointer_size(btf, 8);
1301 return btf;
1305 btf__free(btf);
1310 struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext)
1315 struct btf *btf__parse_elf_split(const char *path, struct btf *base_btf)
1320 static struct btf *btf_parse_raw(const char *path, struct btf *base_btf)
1322 struct btf *btf = NULL;
1374 btf = btf_new(data, sz, base_btf);
1380 return err ? ERR_PTR(err) : btf;
1383 struct btf *btf__parse_raw(const char *path)
1388 struct btf *btf__parse_raw_split(const char *path, struct btf *base_btf)
1393 static struct btf *btf_parse(const char *path, struct btf *base_btf, struct btf_ext **btf_ext)
1395 struct btf *btf;
1401 btf = btf_parse_raw(path, base_btf);
1402 err = libbpf_get_error(btf);
1404 return btf;
1410 struct btf *btf__parse(const char *path, struct btf_ext **btf_ext)
1415 struct btf *btf__parse_split(const char *path, struct btf *base_btf)
1420 static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endian);
1422 int btf_load_into_kernel(struct btf *btf, char *log_buf, size_t log_sz, __u32 log_level)
1430 if (btf->fd >= 0)
1436 raw_data = btf_get_raw_data(btf, &raw_size, false);
1441 btf->raw_size = raw_size;
1442 btf->raw_data = raw_data;
1472 btf->fd = bpf_btf_load(raw_data, raw_size, &opts);
1473 if (btf->fd < 0) {
1497 int btf__load_into_kernel(struct btf *btf)
1499 return btf_load_into_kernel(btf, NULL, 0, 0);
1502 int btf__fd(const struct btf *btf)
1504 return btf->fd;
1507 void btf__set_fd(struct btf *btf, int fd)
1509 btf->fd = fd;
1512 static const void *btf_strs_data(const struct btf *btf)
1514 return btf->strs_data ? btf->strs_data : strset__data(btf->strs_set);
1517 static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endian)
1519 struct btf_header *hdr = btf->hdr;
1525 data = swap_endian ? btf->raw_data_swapped : btf->raw_data;
1527 *size = btf->raw_size;
1542 memcpy(p, btf->types_data, hdr->type_len);
1544 for (i = 0; i < btf->nr_types; i++) {
1545 t = p + btf->type_offs[i];
1557 memcpy(p, btf_strs_data(btf), hdr->str_len);
1567 const void *btf__raw_data(const struct btf *btf_ro, __u32 *size)
1569 struct btf *btf = (struct btf *)btf_ro;
1573 data = btf_get_raw_data(btf, &data_sz, btf->swapped_endian);
1577 btf->raw_size = data_sz;
1578 if (btf->swapped_endian)
1579 btf->raw_data_swapped = data;
1581 btf->raw_data = data;
1587 const void *btf__get_raw_data(const struct btf *btf, __u32 *size);
1589 const char *btf__str_by_offset(const struct btf *btf, __u32 offset)
1591 if (offset < btf->start_str_off)
1592 return btf__str_by_offset(btf->base_btf, offset);
1593 else if (offset - btf->start_str_off < btf->hdr->str_len)
1594 return btf_strs_data(btf) + (offset - btf->start_str_off);
1599 const char *btf__name_by_offset(const struct btf *btf, __u32 offset)
1601 return btf__str_by_offset(btf, offset);
1604 struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf)
1609 struct btf *btf;
1623 btf_info.btf = ptr_to_u64(ptr);
1633 btf = ERR_PTR(-ENOMEM);
1640 btf_info.btf = ptr_to_u64(ptr);
1647 btf = err ? ERR_PTR(-errno) : ERR_PTR(-E2BIG);
1651 btf = btf_new(ptr, btf_info.btf_size, base_btf);
1655 return btf;
1658 struct btf *btf__load_from_kernel_by_id_split(__u32 id, struct btf *base_btf)
1660 struct btf *btf;
1667 btf = btf_get_from_fd(btf_fd, base_btf);
1670 return libbpf_ptr(btf);
1673 struct btf *btf__load_from_kernel_by_id(__u32 id)
1678 static void btf_invalidate_raw_data(struct btf *btf)
1680 if (btf->raw_data) {
1681 free(btf->raw_data);
1682 btf->raw_data = NULL;
1684 if (btf->raw_data_swapped) {
1685 free(btf->raw_data_swapped);
1686 btf->raw_data_swapped = NULL;
1694 static int btf_ensure_modifiable(struct btf *btf)
1700 if (btf_is_modifiable(btf)) {
1702 btf_invalidate_raw_data(btf);
1707 hdr = malloc(btf->hdr->hdr_len);
1708 types = malloc(btf->hdr->type_len);
1712 memcpy(hdr, btf->hdr, btf->hdr->hdr_len);
1713 memcpy(types, btf->types_data, btf->hdr->type_len);
1716 set = strset__new(BTF_MAX_STR_OFFSET, btf->strs_data, btf->hdr->str_len);
1723 btf->hdr = hdr;
1724 btf->types_data = types;
1725 btf->types_data_cap = btf->hdr->type_len;
1726 btf->strs_data = NULL;
1727 btf->strs_set = set;
1731 if (btf->hdr->str_len == 0)
1732 btf->strs_deduped = true;
1733 if (!btf->base_btf && btf->hdr->str_len == 1)
1734 btf->strs_deduped = true;
1737 btf_invalidate_raw_data(btf);
1754 int btf__find_str(struct btf *btf, const char *s)
1758 if (btf->base_btf) {
1759 off = btf__find_str(btf->base_btf, s);
1765 if (btf_ensure_modifiable(btf))
1768 off = strset__find_str(btf->strs_set, s);
1772 return btf->start_str_off + off;
1780 int btf__add_str(struct btf *btf, const char *s)
1784 if (btf->base_btf) {
1785 off = btf__find_str(btf->base_btf, s);
1790 if (btf_ensure_modifiable(btf))
1793 off = strset__add_str(btf->strs_set, s);
1797 btf->hdr->str_len = strset__data_size(btf->strs_set);
1799 return btf->start_str_off + off;
1802 static void *btf_add_type_mem(struct btf *btf, size_t add_sz)
1804 return libbpf_add_mem(&btf->types_data, &btf->types_data_cap, 1,
1805 btf->hdr->type_len, UINT_MAX, add_sz);
1813 static int btf_commit_type(struct btf *btf, int data_sz)
1817 err = btf_add_type_idx_entry(btf, btf->hdr->type_len);
1821 btf->hdr->type_len += data_sz;
1822 btf->hdr->str_off += data_sz;
1823 btf->nr_types++;
1824 return btf->start_id + btf->nr_types - 1;
1828 const struct btf *src;
1829 struct btf *dst;
1865 int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_type *src_type)
1867 struct btf_pipe p = { .src = src_btf, .dst = btf };
1876 if (btf_ensure_modifiable(btf))
1879 t = btf_add_type_mem(btf, sz);
1889 return btf_commit_type(btf, sz);
1894 struct btf *btf = ctx;
1899 /* we haven't updated btf's type count yet, so
1900 * btf->start_id + btf->nr_types - 1 is the type ID offset we should
1903 *type_id += btf->start_id + btf->nr_types - 1;
1910 int btf__add_btf(struct btf *btf, const struct btf *src_btf)
1912 struct btf_pipe p = { .src = src_btf, .dst = btf };
1922 if (btf_ensure_modifiable(btf))
1928 old_strs_len = btf->hdr->str_len;
1934 t = btf_add_type_mem(btf, data_sz);
1939 off = btf_add_type_offs_mem(btf, cnt);
1943 /* Map the string offsets from src_btf to the offsets from btf to improve performance */
1960 *off = t - btf->types_data;
1968 err = btf_type_visit_type_ids(t, btf_rewrite_type_ids, btf);
1985 btf->hdr->type_len += data_sz;
1986 btf->hdr->str_off += data_sz;
1987 btf->nr_types += cnt;
1992 return btf->start_id + btf->nr_types - cnt;
1997 memset(btf->types_data + btf->hdr->type_len, 0, data_sz);
1998 memset(btf->strs_data + old_strs_len, 0, btf->hdr->str_len - old_strs_len);
2003 btf->hdr->str_len = old_strs_len;
2019 int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding)
2034 if (btf_ensure_modifiable(btf))
2038 t = btf_add_type_mem(btf, sz);
2046 name_off = btf__add_str(btf, name);
2056 return btf_commit_type(btf, sz);
2067 int btf__add_float(struct btf *btf, const char *name, size_t byte_sz)
2081 if (btf_ensure_modifiable(btf))
2085 t = btf_add_type_mem(btf, sz);
2089 name_off = btf__add_str(btf, name);
2097 return btf_commit_type(btf, sz);
2112 static int btf_add_ref_kind(struct btf *btf, int kind, const char *name, int ref_type_id)
2120 if (btf_ensure_modifiable(btf))
2124 t = btf_add_type_mem(btf, sz);
2129 name_off = btf__add_str(btf, name);
2138 return btf_commit_type(btf, sz);
2148 int btf__add_ptr(struct btf *btf, int ref_type_id)
2150 return btf_add_ref_kind(btf, BTF_KIND_PTR, NULL, ref_type_id);
2162 int btf__add_array(struct btf *btf, int index_type_id, int elem_type_id, __u32 nr_elems)
2171 if (btf_ensure_modifiable(btf))
2175 t = btf_add_type_mem(btf, sz);
2188 return btf_commit_type(btf, sz);
2192 static int btf_add_composite(struct btf *btf, int kind, const char *name, __u32 bytes_sz)
2197 if (btf_ensure_modifiable(btf))
2201 t = btf_add_type_mem(btf, sz);
2206 name_off = btf__add_str(btf, name);
2218 return btf_commit_type(btf, sz);
2233 int btf__add_struct(struct btf *btf, const char *name, __u32 byte_sz)
2235 return btf_add_composite(btf, BTF_KIND_STRUCT, name, byte_sz);
2251 int btf__add_union(struct btf *btf, const char *name, __u32 byte_sz)
2253 return btf_add_composite(btf, BTF_KIND_UNION, name, byte_sz);
2256 static struct btf_type *btf_last_type(struct btf *btf)
2258 return btf_type_by_id(btf, btf__type_cnt(btf) - 1);
2271 int btf__add_field(struct btf *btf, const char *name, int type_id,
2280 if (btf->nr_types == 0)
2282 t = btf_last_type(btf);
2298 if (btf_ensure_modifiable(btf))
2302 m = btf_add_type_mem(btf, sz);
2307 name_off = btf__add_str(btf, name);
2317 t = btf_last_type(btf);
2321 btf->hdr->type_len += sz;
2322 btf->hdr->str_off += sz;
2326 static int btf_add_enum_common(struct btf *btf, const char *name, __u32 byte_sz,
2336 if (btf_ensure_modifiable(btf))
2340 t = btf_add_type_mem(btf, sz);
2345 name_off = btf__add_str(btf, name);
2355 return btf_commit_type(btf, sz);
2371 int btf__add_enum(struct btf *btf, const char *name, __u32 byte_sz)
2377 return btf_add_enum_common(btf, name, byte_sz, false, BTF_KIND_ENUM);
2388 int btf__add_enum_value(struct btf *btf, const char *name, __s64 value)
2395 if (btf->nr_types == 0)
2397 t = btf_last_type(btf);
2408 if (btf_ensure_modifiable(btf))
2412 v = btf_add_type_mem(btf, sz);
2416 name_off = btf__add_str(btf, name);
2424 t = btf_last_type(btf);
2431 btf->hdr->type_len += sz;
2432 btf->hdr->str_off += sz;
2450 int btf__add_enum64(struct btf *btf, const char *name, __u32 byte_sz,
2453 return btf_add_enum_common(btf, name, byte_sz, is_signed,
2465 int btf__add_enum64_value(struct btf *btf, const char *name, __u64 value)
2472 if (btf->nr_types == 0)
2474 t = btf_last_type(btf);
2483 if (btf_ensure_modifiable(btf))
2487 v = btf_add_type_mem(btf, sz);
2491 name_off = btf__add_str(btf, name);
2500 t = btf_last_type(btf);
2503 btf->hdr->type_len += sz;
2504 btf->hdr->str_off += sz;
2517 int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_kind)
2528 id = btf_add_ref_kind(btf, BTF_KIND_FWD, name, 0);
2531 t = btf_type_by_id(btf, id);
2539 return btf__add_enum(btf, name, sizeof(int));
2553 int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id)
2558 return btf_add_ref_kind(btf, BTF_KIND_TYPEDEF, name, ref_type_id);
2568 int btf__add_volatile(struct btf *btf, int ref_type_id)
2570 return btf_add_ref_kind(btf, BTF_KIND_VOLATILE, NULL, ref_type_id);
2580 int btf__add_const(struct btf *btf, int ref_type_id)
2582 return btf_add_ref_kind(btf, BTF_KIND_CONST, NULL, ref_type_id);
2592 int btf__add_restrict(struct btf *btf, int ref_type_id)
2594 return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id);
2605 int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id)
2610 return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id);
2621 int btf__add_func(struct btf *btf, const char *name,
2632 id = btf_add_ref_kind(btf, BTF_KIND_FUNC, name, proto_type_id);
2634 struct btf_type *t = btf_type_by_id(btf, id);
2653 int btf__add_func_proto(struct btf *btf, int ret_type_id)
2661 if (btf_ensure_modifiable(btf))
2665 t = btf_add_type_mem(btf, sz);
2676 return btf_commit_type(btf, sz);
2687 int btf__add_func_param(struct btf *btf, const char *name, int type_id)
2697 if (btf->nr_types == 0)
2699 t = btf_last_type(btf);
2704 if (btf_ensure_modifiable(btf))
2708 p = btf_add_type_mem(btf, sz);
2713 name_off = btf__add_str(btf, name);
2722 t = btf_last_type(btf);
2725 btf->hdr->type_len += sz;
2726 btf->hdr->str_off += sz;
2740 int btf__add_var(struct btf *btf, const char *name, int linkage, int type_id)
2756 if (btf_ensure_modifiable(btf))
2760 t = btf_add_type_mem(btf, sz);
2764 name_off = btf__add_str(btf, name);
2775 return btf_commit_type(btf, sz);
2790 int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz)
2799 if (btf_ensure_modifiable(btf))
2803 t = btf_add_type_mem(btf, sz);
2807 name_off = btf__add_str(btf, name);
2816 return btf_commit_type(btf, sz);
2829 int btf__add_datasec_var_info(struct btf *btf, int var_type_id, __u32 offset, __u32 byte_sz)
2836 if (btf->nr_types == 0)
2838 t = btf_last_type(btf);
2846 if (btf_ensure_modifiable(btf))
2850 v = btf_add_type_mem(btf, sz);
2859 t = btf_last_type(btf);
2862 btf->hdr->type_len += sz;
2863 btf->hdr->str_off += sz;
2877 int btf__add_decl_tag(struct btf *btf, const char *value, int ref_type_id,
2889 if (btf_ensure_modifiable(btf))
2893 t = btf_add_type_mem(btf, sz);
2897 value_off = btf__add_str(btf, value);
2906 return btf_commit_type(btf, sz);
3152 static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts);
3166 * BTF dedup algorithm takes as an input `struct btf` representing `.BTF` ELF
3178 * https://facebookmicrosites.github.io/bpf/blog/2018/11/14/btf-enhancement.html
3301 int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts)
3309 d = btf_dedup_new(btf, opts);
3315 if (btf_ensure_modifiable(btf)) {
3371 struct btf *btf;
3477 static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts)
3489 d->btf = btf;
3499 type_cnt = btf__type_cnt(btf);
3508 struct btf_type *t = btf_type_by_id(d->btf, i);
3542 for (i = 0; i < d->btf->nr_types; i++) {
3543 struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i);
3568 if (str_off == 0 || str_off < d->btf->start_str_off)
3571 s = btf__str_by_offset(d->btf, str_off);
3572 if (d->btf->base_btf) {
3573 err = btf__find_str(d->btf->base_btf, s);
3586 *str_off_ptr = d->btf->start_str_off + off;
3605 if (d->btf->strs_deduped)
3614 if (!d->btf->base_btf) {
3629 strset__free(d->btf->strs_set);
3630 d->btf->hdr->str_len = strset__data_size(d->strs_set);
3631 d->btf->strs_set = d->strs_set;
3633 d->btf->strs_deduped = true;
3944 if (!d->btf->base_btf)
3947 for (type_id = 1; type_id < d->btf->start_id; type_id++) {
3948 t = btf_type_by_id(d->btf, type_id);
4006 struct btf_type *t = btf_type_by_id(d->btf, type_id);
4035 cand = btf_type_by_id(d->btf, cand_id);
4048 cand = btf_type_by_id(d->btf, cand_id);
4070 cand = btf_type_by_id(d->btf, cand_id);
4093 for (i = 0; i < d->btf->nr_types; i++) {
4094 err = btf_dedup_prim_type(d, d->btf->start_id + i);
4129 if (!btf_is_fwd(btf__type_by_id(d->btf, type_id)))
4135 if (!btf_is_fwd(btf__type_by_id(d->btf, type_id)))
4152 t1 = btf_type_by_id(d->btf, id1);
4153 t2 = btf_type_by_id(d->btf, id2);
4167 t1 = btf_type_by_id(d->btf, id1);
4168 t2 = btf_type_by_id(d->btf, id2);
4325 cand_type = btf_type_by_id(d->btf, cand_id);
4326 canon_type = btf_type_by_id(d->btf, canon_id);
4346 if (fwd_kind == real_kind && canon_id < d->btf->start_id)
4478 t_kind = btf_kind(btf__type_by_id(d->btf, t_id));
4479 c_kind = btf_kind(btf__type_by_id(d->btf, c_id));
4564 t = btf_type_by_id(d->btf, type_id);
4585 cand_type = btf_type_by_id(d->btf, cand_id);
4613 for (i = 0; i < d->btf->nr_types; i++) {
4614 err = btf_dedup_struct_type(d, d->btf->start_id + i);
4659 t = btf_type_by_id(d->btf, type_id);
4678 cand = btf_type_by_id(d->btf, cand_id);
4695 cand = btf_type_by_id(d->btf, cand_id);
4719 cand = btf_type_by_id(d->btf, cand_id);
4751 cand = btf_type_by_id(d->btf, cand_id);
4775 for (i = 0; i < d->btf->nr_types; i++) {
4776 err = btf_dedup_ref_type(d, d->btf->start_id + i);
4793 __u32 nr_types = btf__type_cnt(d->btf);
4804 t = btf_type_by_id(d->btf, type_id);
4827 struct btf_type *t = btf_type_by_id(d->btf, type_id);
4847 cand_t = btf_type_by_id(d->btf, cand_id);
4903 for (i = 0; i < d->btf->nr_types; i++) {
4904 err = btf_dedup_resolve_fwd(d, names_map, d->btf->start_id + i);
4928 __u32 next_type_id = d->btf->start_id;
4936 for (id = 1; id < d->btf->start_id; id++)
4938 for (i = 0, id = d->btf->start_id; i < d->btf->nr_types; i++, id++)
4941 p = d->btf->types_data;
4943 for (i = 0, id = d->btf->start_id; i < d->btf->nr_types; i++, id++) {
4947 t = btf__type_by_id(d->btf, id);
4954 d->btf->type_offs[next_type_id - d->btf->start_id] = p - d->btf->types_data;
4959 /* shrink struct btf's internal types index and update btf_header */
4960 d->btf->nr_types = next_type_id - d->btf->start_id;
4961 d->btf->type_offs_cap = d->btf->nr_types;
4962 d->btf->hdr->type_len = p - d->btf->types_data;
4963 new_offs = libbpf_reallocarray(d->btf->type_offs, d->btf->type_offs_cap,
4965 if (d->btf->type_offs_cap && !new_offs)
4967 d->btf->type_offs = new_offs;
4968 d->btf->hdr->str_off = d->btf->hdr->type_len;
4969 d->btf->raw_size = d->btf->hdr->hdr_len + d->btf->hdr->type_len + d->btf->hdr->str_len;
5007 for (i = 0; i < d->btf->nr_types; i++) {
5008 struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i);
5029 struct btf *btf__load_vmlinux_btf(void)
5033 "/sys/kernel/btf/vmlinux",
5045 struct btf *btf;
5056 btf = btf__parse(path, NULL);
5057 err = libbpf_get_error(btf);
5062 return btf;
5069 struct btf *libbpf_find_kernel_btf(void) __attribute__((alias("btf__load_vmlinux_btf")));
5071 struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_btf)
5075 snprintf(path, sizeof(path), "/sys/kernel/btf/%s", module_name);