struct btf { /* raw BTF data in native endianness */ void *raw_data; /* raw BTF data in non-native endianness */ void *raw_data_swapped;
__u32 raw_size; /* whether target endianness differs from the native one */ bool swapped_endian;
/* * When BTF is loaded from an ELF or raw memory it is stored * in a contiguous memory block. The hdr, type_data, and, strs_data * point inside that memory region to their respective parts of BTF * representation: * * +--------------------------------+ * | Header | Types | Strings | * +--------------------------------+ * ^ ^ ^ * | | | * hdr | | * types_data-+ | * strs_data------------+ * * If BTF data is later modified, e.g., due to types added or * removed, BTF deduplication performed, etc, this contiguous * representation is broken up into three independently allocated * memory regions to be able to modify them independently. * raw_data is nulled out at that point, but can be later allocated * and cached again if user calls btf__raw_data(), at which point * raw_data will contain a contiguous copy of header, types, and * strings: * * +----------+ +---------+ +-----------+ * | Header | | Types | | Strings | * +----------+ +---------+ +-----------+ * ^ ^ ^ * | | | * hdr | | * types_data----+ | * strset__data(strs_set)-----+ * * +----------+---------+-----------+ * | Header | Types | Strings | * raw_data----->+----------+---------+-----------+
*/ struct btf_header *hdr;
void *types_data;
size_t types_data_cap; /* used size stored in hdr->type_len */
/* type ID to `struct btf_type *` lookup index * type_offs[0] corresponds to the first non-VOID type: * - for base BTF it's type [1]; * - for split BTF it's the first non-base BTF type.
*/
__u32 *type_offs;
size_t type_offs_cap; /* number of types in this BTF instance: * - doesn't include special [0] void type; * - for split BTF counts number of types added on top of base BTF.
*/
__u32 nr_types; /* if not NULL, points to the base BTF on top of which the current * split BTF is based
*/ struct btf *base_btf; /* BTF type ID of the first type in this BTF instance: * - for base BTF it's equal to 1; * - for split BTF it's equal to biggest type ID of base BTF plus 1.
*/ int start_id; /* logical string offset of this BTF instance: * - for base BTF it's equal to 0; * - for split BTF it's equal to total size of base BTF's string section size.
*/ int start_str_off;
/* only one of strs_data or strs_set can be non-NULL, depending on * whether BTF is in a modifiable state (strs_set is used) or not * (strs_data points inside raw_data)
*/ void *strs_data; /* a set of unique strings */ struct strset *strs_set; /* whether strings are already deduplicated */ bool strs_deduped;
/* whether base_btf should be freed in btf_free for this instance */ bool owns_base;
/* whether raw_data is a (read-only) mmap */ bool raw_data_is_mmap;
/* BTF object FD, if loaded into kernel */ int fd;
/* Pointer size (in bytes) for a target architecture of this BTF */ int ptr_sz;
};
/* Ensure given dynamically allocated memory region pointed to by *data* with * capacity of *cap_cnt* elements each taking *elem_sz* bytes has enough * memory to accommodate *add_cnt* new elements, assuming *cur_cnt* elements * are already used. At most *max_cnt* elements can be ever allocated. * If necessary, memory is reallocated and all existing data is copied over, * new pointer to the memory region is stored at *data, new memory region * capacity (in number of elements) is stored in *cap. * On success, memory pointer to the beginning of unused memory is returned. * On error, NULL is returned.
*/ void *libbpf_add_mem(void **data, size_t *cap_cnt, size_t elem_sz,
size_t cur_cnt, size_t max_cnt, size_t add_cnt)
{
size_t new_cnt; void *new_data;
/* requested more than the set limit */ if (cur_cnt + add_cnt > max_cnt) return NULL;
new_cnt = *cap_cnt;
new_cnt += new_cnt / 4; /* expand by 25% */ if (new_cnt < 16) /* but at least 16 elements */
new_cnt = 16; if (new_cnt > max_cnt) /* but not exceeding a set limit */
new_cnt = max_cnt; if (new_cnt < cur_cnt + add_cnt) /* also ensure we have enough memory */
new_cnt = cur_cnt + add_cnt;
new_data = libbpf_reallocarray(*data, new_cnt, elem_sz); if (!new_data) return NULL;
/* zero out newly allocated portion of memory */
memset(new_data + (*cap_cnt) * elem_sz, 0, (new_cnt - *cap_cnt) * elem_sz);
/* Ensure given dynamically allocated memory region has enough allocated space * to accommodate *need_cnt* elements of size *elem_sz* bytes each
*/ int libbpf_ensure_mem(void **data, size_t *cap_cnt, size_t elem_sz, size_t need_cnt)
{ void *p;
if (need_cnt <= *cap_cnt) return 0;
p = libbpf_add_mem(data, cap_cnt, elem_sz, *cap_cnt, SIZE_MAX, need_cnt - *cap_cnt); if (!p) return -ENOMEM;
if ((longlong)hdr->type_off + hdr->type_len > hdr->str_off) {
pr_debug("Invalid BTF data sections layout: type data at %u + %u, strings data at %u + %u\n",
hdr->type_off, hdr->type_len, hdr->str_off, hdr->str_len); return -EINVAL;
}
if (hdr->type_off % 4) {
pr_debug("BTF type section is not aligned to 4 bytes\n"); return -EINVAL;
}
switch (kind) { case BTF_KIND_UNKN: case BTF_KIND_INT: case BTF_KIND_FWD: case BTF_KIND_FLOAT: break; case BTF_KIND_PTR: case BTF_KIND_TYPEDEF: case BTF_KIND_VOLATILE: case BTF_KIND_CONST: case BTF_KIND_RESTRICT: case BTF_KIND_VAR: case BTF_KIND_DECL_TAG: case BTF_KIND_TYPE_TAG:
err = btf_validate_id(btf, t->type, id); if (err) return err; break; case BTF_KIND_ARRAY: { conststruct btf_array *a = btf_array(t);
err = btf_validate_id(btf, a->type, id);
err = err ?: btf_validate_id(btf, a->index_type, id); if (err) return err; break;
} case BTF_KIND_STRUCT: case BTF_KIND_UNION: { conststruct btf_member *m = btf_members(t);
n = btf_vlen(t); for (i = 0; i < n; i++, m++) {
err = btf_validate_str(btf, m->name_off, "field name", id);
err = err ?: btf_validate_id(btf, m->type, id); if (err) return err;
} break;
} case BTF_KIND_ENUM: { conststruct btf_enum *m = btf_enum(t);
n = btf_vlen(t); for (i = 0; i < n; i++, m++) {
err = btf_validate_str(btf, m->name_off, "enum name", id); if (err) return err;
} break;
} case BTF_KIND_ENUM64: { conststruct btf_enum64 *m = btf_enum64(t);
n = btf_vlen(t); for (i = 0; i < n; i++, m++) {
err = btf_validate_str(btf, m->name_off, "enum name", id); if (err) return err;
} break;
} case BTF_KIND_FUNC: { conststruct btf_type *ft;
err = btf_validate_id(btf, t->type, id); if (err) return err;
ft = btf__type_by_id(btf, t->type); if (btf_kind(ft) != BTF_KIND_FUNC_PROTO) {
pr_warn("btf: type [%u]: referenced type [%u] is not FUNC_PROTO\n", id, t->type); return -EINVAL;
} break;
} case BTF_KIND_FUNC_PROTO: { conststruct btf_param *m = btf_params(t);
n = btf_vlen(t); for (i = 0; i < n; i++, m++) {
err = btf_validate_str(btf, m->name_off, "param name", id);
err = err ?: btf_validate_id(btf, m->type, id); if (err) return err;
} break;
} case BTF_KIND_DATASEC: { conststruct btf_var_secinfo *m = btf_var_secinfos(t);
n = btf_vlen(t); for (i = 0; i < n; i++, m++) {
err = btf_validate_id(btf, m->type, id); if (err) return err;
} break;
} default:
pr_warn("btf: type [%u]: unrecognized kind %u\n", id, kind); return -EINVAL;
} return 0;
}
/* Validate basic sanity of BTF. It's intentionally less thorough than * kernel's validation and validates only properties of BTF that libbpf relies * on to be correct (e.g., valid type IDs, valid string offsets, etc)
*/ staticint btf_sanity_check(conststruct btf *btf)
{ conststruct btf_type *t;
__u32 i, n = btf__type_cnt(btf); int err;
for (i = btf->start_id; i < n; i++) {
t = btf_type_by_id(btf, i);
err = btf_validate_type(btf, t, i); if (err) return err;
} return 0;
}
/* Return pointer size this BTF instance assumes. The size is heuristically * determined by looking for 'long' or 'unsigned long' integer type and * recording its size in bytes. If BTF type information doesn't have any such * type, this function returns 0. In the latter case, native architecture's * pointer size is assumed, so will be either 4 or 8, depending on * architecture that libbpf was compiled for. It's possible to override * guessed value by using btf__set_pointer_size() API.
*/
size_t btf__pointer_size(conststruct btf *btf)
{ if (!btf->ptr_sz)
((struct btf *)btf)->ptr_sz = determine_ptr_size(btf);
if (btf->ptr_sz < 0) /* not enough BTF type info to guess */ return 0;
return btf->ptr_sz;
}
/* Override or set pointer size in bytes. Only values of 4 and 8 are * supported.
*/ int btf__set_pointer_size(struct btf *btf, size_t ptr_sz)
{ if (ptr_sz != 4 && ptr_sz != 8) return libbpf_err(-EINVAL);
btf->ptr_sz = ptr_sz; return 0;
}
t = btf__type_by_id(btf, type_id); for (i = 0; i < MAX_RESOLVE_DEPTH && !btf_type_is_void_or_null(t); i++) { switch (btf_kind(t)) { case BTF_KIND_INT: case BTF_KIND_STRUCT: case BTF_KIND_UNION: case BTF_KIND_ENUM: case BTF_KIND_ENUM64: case BTF_KIND_DATASEC: case BTF_KIND_FLOAT:
size = t->size; goto done; case BTF_KIND_PTR:
size = btf_ptr_sz(btf); goto done; case BTF_KIND_TYPEDEF: case BTF_KIND_VOLATILE: case BTF_KIND_CONST: case BTF_KIND_RESTRICT: case BTF_KIND_VAR: case BTF_KIND_DECL_TAG: case BTF_KIND_TYPE_TAG:
type_id = t->type; break; case BTF_KIND_ARRAY:
array = btf_array(t); if (nelems && array->nelems > UINT32_MAX / nelems) return libbpf_err(-E2BIG);
nelems *= array->nelems;
type_id = array->type; break; default: return libbpf_err(-EINVAL);
}
t = btf__type_by_id(btf, type_id);
}
done: if (size < 0) return libbpf_err(-EINVAL); if (nelems && size > UINT32_MAX / nelems) return libbpf_err(-E2BIG);
switch (kind) { case BTF_KIND_INT: case BTF_KIND_ENUM: case BTF_KIND_ENUM64: case BTF_KIND_FLOAT: return min(btf_ptr_sz(btf), (size_t)t->size); case BTF_KIND_PTR: return btf_ptr_sz(btf); case BTF_KIND_TYPEDEF: case BTF_KIND_VOLATILE: case BTF_KIND_CONST: case BTF_KIND_RESTRICT: case BTF_KIND_TYPE_TAG: return btf__align_of(btf, t->type); case BTF_KIND_ARRAY: return btf__align_of(btf, btf_array(t)->type); case BTF_KIND_STRUCT: case BTF_KIND_UNION: { conststruct btf_member *m = btf_members(t);
__u16 vlen = btf_vlen(t); int i, max_align = 1, align;
for (i = 0; i < vlen; i++, m++) {
align = btf__align_of(btf, m->type); if (align <= 0) return libbpf_err(align);
max_align = max(max_align, align);
/* if field offset isn't aligned according to field * type's alignment, then struct must be packed
*/ if (btf_member_bitfield_size(t, i) == 0 &&
(m->offset % (8 * align)) != 0) return 1;
}
/* if struct/union size isn't a multiple of its alignment, * then struct must be packed
*/ if ((t->size % max_align) != 0) return 1;
void btf__free(struct btf *btf)
{ if (IS_ERR_OR_NULL(btf)) return;
if (btf->fd >= 0)
close(btf->fd);
if (btf_is_modifiable(btf)) { /* if BTF was modified after loading, it will have a split * in-memory representation for header, types, and strings * sections, so we need to free all of them individually. It * might still have a cached contiguous raw data present, * which will be unconditionally freed below.
*/
free(btf->hdr);
free(btf->types_data);
strset__free(btf->strs_set);
}
btf_free_raw_data(btf);
free(btf->raw_data_swapped);
free(btf->type_offs); if (btf->owns_base)
btf__free(btf->base_btf);
free(btf);
}
idx++; if (gelf_getshdr(scn, &sh) != &sh) {
pr_warn("failed to get section(%d) header from %s\n",
idx, path); goto err;
}
name = elf_strptr(elf, shstrndx, sh.sh_name); if (!name) {
pr_warn("failed to get section(%d) name from %s\n",
idx, path); goto err;
}
if (strcmp(name, BTF_ELF_SEC) == 0)
field = &secs->btf_data; elseif (strcmp(name, BTF_EXT_ELF_SEC) == 0)
field = &secs->btf_ext_data; elseif (strcmp(name, BTF_BASE_ELF_SEC) == 0)
field = &secs->btf_base_data; else continue;
if (sh.sh_type != SHT_PROGBITS) {
pr_warn("unexpected section type (%d) of section(%d, %s) from %s\n",
sh.sh_type, idx, name, path); goto err;
}
data = elf_getdata(scn, 0); if (!data) {
pr_warn("failed to get section(%d, %s) data from %s\n",
idx, name, path); goto err;
}
*field = data;
}
switch (gelf_getclass(elf)) { case ELFCLASS32:
btf__set_pointer_size(btf, 4); break; case ELFCLASS64:
btf__set_pointer_size(btf, 8); break; default:
pr_warn("failed to get ELF class (bitness) for %s\n", path); break;
}
if (btf->fd >= 0) return libbpf_err(-EEXIST); if (log_sz && !log_buf) return libbpf_err(-EINVAL);
/* cache native raw data representation */
raw_data = btf_get_raw_data(btf, &raw_size, false); if (!raw_data) {
err = -ENOMEM; goto done;
}
btf->raw_size = raw_size;
btf->raw_data = raw_data;
retry_load: /* if log_level is 0, we won't provide log_buf/log_size to the kernel, * initially. Only if BTF loading fails, we bump log_level to 1 and * retry, using either auto-allocated or custom log_buf. This way * non-NULL custom log_buf provides a buffer just in case, but hopes * for successful load and no need for log_buf.
*/ if (log_level) { /* if caller didn't provide custom log_buf, we'll keep * allocating our own progressively bigger buffers for BTF * verification log
*/ if (!log_buf) {
buf_sz = max((__u32)BPF_LOG_BUF_SIZE, buf_sz * 2);
tmp = realloc(buf, buf_sz); if (!tmp) {
err = -ENOMEM; goto done;
}
buf = tmp;
buf[0] = '\0';
}
opts.token_fd = token_fd; if (token_fd)
opts.btf_flags |= BPF_F_TOKEN_FD;
btf->fd = bpf_btf_load(raw_data, raw_size, &opts); if (btf->fd < 0) { /* time to turn on verbose mode and try again */ if (log_level == 0) {
log_level = 1; goto retry_load;
} /* only retry if caller didn't provide custom log_buf, but * make sure we can never overflow buf_sz
*/ if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2) goto retry_load;
err = -errno;
pr_warn("BTF loading error: %s\n", errstr(err)); /* don't print out contents of custom log_buf */ if (!log_buf && buf[0])
pr_warn("-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n", buf);
}
data = swap_endian ? btf->raw_data_swapped : btf->raw_data; if (data) {
*size = btf->raw_size; return data;
}
data_sz = hdr->hdr_len + hdr->type_len + hdr->str_len;
data = calloc(1, data_sz); if (!data) return NULL;
p = data;
memcpy(p, hdr, hdr->hdr_len); if (swap_endian)
btf_bswap_hdr(p);
p += hdr->hdr_len;
memcpy(p, btf->types_data, hdr->type_len); if (swap_endian) { for (i = 0; i < btf->nr_types; i++) {
t = p + btf->type_offs[i]; /* btf_bswap_type_rest() relies on native t->info, so * we swap base type info after we swapped all the * additional information
*/ if (btf_bswap_type_rest(t)) goto err_out;
btf_bswap_type_base(t);
}
}
p += hdr->type_len;
memcpy(p, btf_strs_data(btf), hdr->str_len);
p += hdr->str_len;
/* we won't know btf_size until we call bpf_btf_get_info_by_fd(). so * let's start with a sane default - 4KiB here - and resize it only if * bpf_btf_get_info_by_fd() needs a bigger buffer.
*/
last_size = 4096;
ptr = malloc(last_size); if (!ptr) return ERR_PTR(-ENOMEM);
staticvoid btf_invalidate_raw_data(struct btf *btf)
{ if (btf->raw_data)
btf_free_raw_data(btf); if (btf->raw_data_swapped) {
free(btf->raw_data_swapped);
btf->raw_data_swapped = NULL;
}
}
/* Ensure BTF is ready to be modified (by splitting into a three memory * regions for header, types, and strings). Also invalidate cached * raw_data, if any.
*/ staticint btf_ensure_modifiable(struct btf *btf)
{ void *hdr, *types; struct strset *set = NULL; int err = -ENOMEM;
if (btf_is_modifiable(btf)) { /* any BTF modification invalidates raw_data */
btf_invalidate_raw_data(btf); return 0;
}
/* split raw data into three memory regions */
hdr = malloc(btf->hdr->hdr_len);
types = malloc(btf->hdr->type_len); if (!hdr || !types) goto err_out;
/* build lookup index for all strings */
set = strset__new(BTF_MAX_STR_OFFSET, btf->strs_data, btf->hdr->str_len); if (IS_ERR(set)) {
err = PTR_ERR(set); goto err_out;
}
/* only when everything was successful, update internal state */
btf->hdr = hdr;
btf->types_data = types;
btf->types_data_cap = btf->hdr->type_len;
btf->strs_data = NULL;
btf->strs_set = set; /* if BTF was created from scratch, all strings are guaranteed to be * unique and deduplicated
*/ if (btf->hdr->str_len == 0)
btf->strs_deduped = true; if (!btf->base_btf && btf->hdr->str_len == 1)
btf->strs_deduped = true;
/* Find an offset in BTF string section that corresponds to a given string *s*. * Returns: * - >0 offset into string section, if string is found; * - -ENOENT, if string is not in the string section; * - <0, on any other error.
*/ int btf__find_str(struct btf *btf, constchar *s)
{ int off;
if (btf->base_btf) {
off = btf__find_str(btf->base_btf, s); if (off != -ENOENT) return off;
}
/* BTF needs to be in a modifiable state to build string lookup index */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
off = strset__find_str(btf->strs_set, s); if (off < 0) return libbpf_err(off);
return btf->start_str_off + off;
}
/* Add a string s to the BTF string section. * Returns: * - > 0 offset into string section, on success; * - < 0, on error.
*/ int btf__add_str(struct btf *btf, constchar *s)
{ int off;
if (btf->base_btf) {
off = btf__find_str(btf->base_btf, s); if (off != -ENOENT) return off;
}
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
off = strset__add_str(btf->strs_set, s); if (off < 0) return libbpf_err(off);
/* pre-allocate enough memory for new types */
t = btf_add_type_mem(btf, data_sz); if (!t) return libbpf_err(-ENOMEM);
/* pre-allocate enough memory for type offset index for new types */
off = btf_add_type_offs_mem(btf, cnt); if (!off) return libbpf_err(-ENOMEM);
/* Map the string offsets from src_btf to the offsets from btf to improve performance */
p.str_off_map = hashmap__new(btf_dedup_identity_hash_fn, btf_dedup_equal_fn, NULL); if (IS_ERR(p.str_off_map)) return libbpf_err(-ENOMEM);
/* bulk copy types data for all types from src_btf */
memcpy(t, src_btf->types_data, data_sz);
for (i = 0; i < cnt; i++) { struct btf_field_iter it;
__u32 *type_id, *str_off;
sz = btf_type_size(t); if (sz < 0) { /* unlikely, has to be corrupted src_btf */
err = sz; goto err_out;
}
/* fill out type ID to type offset mapping for lookups by type ID */
*off = t - btf->types_data;
/* add, dedup, and remap strings referenced by this BTF type */
err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS); if (err) goto err_out; while ((str_off = btf_field_iter_next(&it))) {
err = btf_rewrite_str(&p, str_off); if (err) goto err_out;
}
/* remap all type IDs referenced from this BTF type */
err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS); if (err) goto err_out;
while ((type_id = btf_field_iter_next(&it))) { if (!*type_id) /* nothing to do for VOID references */ continue;
/* we haven't updated btf's type count yet, so * btf->start_id + btf->nr_types - 1 is the type ID offset we should * add to all newly added BTF types
*/
*type_id += btf->start_id + btf->nr_types - 1;
}
/* go to next type data and type offset index entry */
t += sz;
off++;
}
/* Up until now any of the copied type data was effectively invisible, * so if we exited early before this point due to error, BTF would be * effectively unmodified. There would be extra internal memory * pre-allocated, but it would not be available for querying. But now * that we've copied and rewritten all the data successfully, we can * update type count and various internal offsets and sizes to * "commit" the changes and made them visible to the outside world.
*/
btf->hdr->type_len += data_sz;
btf->hdr->str_off += data_sz;
btf->nr_types += cnt;
hashmap__free(p.str_off_map);
/* return type ID of the first added BTF type */ return btf->start_id + btf->nr_types - cnt;
err_out: /* zero out preallocated memory as if it was just allocated with * libbpf_add_mem()
*/
memset(btf->types_data + btf->hdr->type_len, 0, data_sz);
memset(btf->strs_data + old_strs_len, 0, btf->hdr->str_len - old_strs_len);
/* and now restore original strings section size; types data size * wasn't modified, so doesn't need restoring, see big comment above
*/
btf->hdr->str_len = old_strs_len;
hashmap__free(p.str_off_map);
return libbpf_err(err);
}
/* * Append new BTF_KIND_INT type with: * - *name* - non-empty, non-NULL type name; * - *sz* - power-of-2 (1, 2, 4, ..) size of the type, in bytes; * - encoding is a combination of BTF_INT_SIGNED, BTF_INT_CHAR, BTF_INT_BOOL. * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_int(struct btf *btf, constchar *name, size_t byte_sz, int encoding)
{ struct btf_type *t; int sz, name_off;
/* non-empty name */ if (!name || !name[0]) return libbpf_err(-EINVAL); /* byte_sz must be power of 2 */ if (!byte_sz || (byte_sz & (byte_sz - 1)) || byte_sz > 16) return libbpf_err(-EINVAL); if (encoding & ~(BTF_INT_SIGNED | BTF_INT_CHAR | BTF_INT_BOOL)) return libbpf_err(-EINVAL);
/* deconstruct BTF, if necessary, and invalidate raw_data */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type) + sizeof(int);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
/* if something goes wrong later, we might end up with an extra string, * but that shouldn't be a problem, because BTF can't be constructed * completely anyway and will most probably be just discarded
*/
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
t->name_off = name_off;
t->info = btf_type_info(BTF_KIND_INT, 0, 0);
t->size = byte_sz; /* set INT info, we don't allow setting legacy bit offset/size */
*(__u32 *)(t + 1) = (encoding << 24) | (byte_sz * 8);
return btf_commit_type(btf, sz);
}
/* * Append new BTF_KIND_FLOAT type with: * - *name* - non-empty, non-NULL type name; * - *sz* - size of the type, in bytes; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_float(struct btf *btf, constchar *name, size_t byte_sz)
{ struct btf_type *t; int sz, name_off;
/* non-empty name */ if (!name || !name[0]) return libbpf_err(-EINVAL);
/* byte_sz must be one of the explicitly allowed values */ if (byte_sz != 2 && byte_sz != 4 && byte_sz != 8 && byte_sz != 12 &&
byte_sz != 16) return libbpf_err(-EINVAL);
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
/* it's completely legal to append BTF types with type IDs pointing forward to * types that haven't been appended yet, so we only make sure that id looks * sane, we can't guarantee that ID will always be valid
*/ staticint validate_type_id(int id)
{ if (id < 0 || id > BTF_MAX_NR_TYPES) return -EINVAL; return 0;
}
/* generic append function for PTR, TYPEDEF, CONST/VOLATILE/RESTRICT */ staticint btf_add_ref_kind(struct btf *btf, int kind, constchar *name, int ref_type_id, int kflag)
{ struct btf_type *t; int sz, name_off = 0;
if (validate_type_id(ref_type_id)) return libbpf_err(-EINVAL);
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
if (name && name[0]) {
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
}
/* * Append new BTF_KIND_PTR type with: * - *ref_type_id* - referenced type ID, it might not exist yet; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_ptr(struct btf *btf, int ref_type_id)
{ return btf_add_ref_kind(btf, BTF_KIND_PTR, NULL, ref_type_id, 0);
}
/* * Append new BTF_KIND_ARRAY type with: * - *index_type_id* - type ID of the type describing array index; * - *elem_type_id* - type ID of the type describing array element; * - *nr_elems* - the size of the array; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_array(struct btf *btf, int index_type_id, int elem_type_id, __u32 nr_elems)
{ struct btf_type *t; struct btf_array *a; int sz;
if (validate_type_id(index_type_id) || validate_type_id(elem_type_id)) return libbpf_err(-EINVAL);
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type) + sizeof(struct btf_array);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
/* generic STRUCT/UNION append function */ staticint btf_add_composite(struct btf *btf, int kind, constchar *name, __u32 bytes_sz)
{ struct btf_type *t; int sz, name_off = 0;
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
if (name && name[0]) {
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
}
/* start out with vlen=0 and no kflag; this will be adjusted when * adding each member
*/
t->name_off = name_off;
t->info = btf_type_info(kind, 0, 0);
t->size = bytes_sz;
return btf_commit_type(btf, sz);
}
/* * Append new BTF_KIND_STRUCT type with: * - *name* - name of the struct, can be NULL or empty for anonymous structs; * - *byte_sz* - size of the struct, in bytes; * * Struct initially has no fields in it. Fields can be added by * btf__add_field() right after btf__add_struct() succeeds. * * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_struct(struct btf *btf, constchar *name, __u32 byte_sz)
{ return btf_add_composite(btf, BTF_KIND_STRUCT, name, byte_sz);
}
/* * Append new BTF_KIND_UNION type with: * - *name* - name of the union, can be NULL or empty for anonymous union; * - *byte_sz* - size of the union, in bytes; * * Union initially has no fields in it. Fields can be added by * btf__add_field() right after btf__add_union() succeeds. All fields * should have *bit_offset* of 0. * * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_union(struct btf *btf, constchar *name, __u32 byte_sz)
{ return btf_add_composite(btf, BTF_KIND_UNION, name, byte_sz);
}
/* * Append new field for the current STRUCT/UNION type with: * - *name* - name of the field, can be NULL or empty for anonymous field; * - *type_id* - type ID for the type describing field type; * - *bit_offset* - bit offset of the start of the field within struct/union; * - *bit_size* - bit size of a bitfield, 0 for non-bitfield fields; * Returns: * - 0, on success; * - <0, on error.
*/ int btf__add_field(struct btf *btf, constchar *name, int type_id,
__u32 bit_offset, __u32 bit_size)
{ struct btf_type *t; struct btf_member *m; bool is_bitfield; int sz, name_off = 0;
/* last type should be union/struct */ if (btf->nr_types == 0) return libbpf_err(-EINVAL);
t = btf_last_type(btf); if (!btf_is_composite(t)) return libbpf_err(-EINVAL);
if (validate_type_id(type_id)) return libbpf_err(-EINVAL); /* best-effort bit field offset/size enforcement */
is_bitfield = bit_size || (bit_offset % 8 != 0); if (is_bitfield && (bit_size == 0 || bit_size > 255 || bit_offset > 0xffffff)) return libbpf_err(-EINVAL);
/* only offset 0 is allowed for unions */ if (btf_is_union(t) && bit_offset) return libbpf_err(-EINVAL);
/* decompose and invalidate raw data */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_member);
m = btf_add_type_mem(btf, sz); if (!m) return libbpf_err(-ENOMEM);
if (name && name[0]) {
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
}
/* byte_sz must be power of 2 */ if (!byte_sz || (byte_sz & (byte_sz - 1)) || byte_sz > 8) return libbpf_err(-EINVAL);
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
if (name && name[0]) {
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
}
/* start out with vlen=0; it will be adjusted when adding enum values */
t->name_off = name_off;
t->info = btf_type_info(kind, 0, is_signed);
t->size = byte_sz;
return btf_commit_type(btf, sz);
}
/* * Append new BTF_KIND_ENUM type with: * - *name* - name of the enum, can be NULL or empty for anonymous enums; * - *byte_sz* - size of the enum, in bytes. * * Enum initially has no enum values in it (and corresponds to enum forward * declaration). Enumerator values can be added by btf__add_enum_value() * immediately after btf__add_enum() succeeds. * * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_enum(struct btf *btf, constchar *name, __u32 byte_sz)
{ /* * set the signedness to be unsigned, it will change to signed * if any later enumerator is negative.
*/ return btf_add_enum_common(btf, name, byte_sz, false, BTF_KIND_ENUM);
}
/* * Append new enum value for the current ENUM type with: * - *name* - name of the enumerator value, can't be NULL or empty; * - *value* - integer value corresponding to enum value *name*; * Returns: * - 0, on success; * - <0, on error.
*/ int btf__add_enum_value(struct btf *btf, constchar *name, __s64 value)
{ struct btf_type *t; struct btf_enum *v; int sz, name_off;
/* last type should be BTF_KIND_ENUM */ if (btf->nr_types == 0) return libbpf_err(-EINVAL);
t = btf_last_type(btf); if (!btf_is_enum(t)) return libbpf_err(-EINVAL);
/* non-empty name */ if (!name || !name[0]) return libbpf_err(-EINVAL); if (value < INT_MIN || value > UINT_MAX) return libbpf_err(-E2BIG);
/* decompose and invalidate raw data */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_enum);
v = btf_add_type_mem(btf, sz); if (!v) return libbpf_err(-ENOMEM);
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
v->name_off = name_off;
v->val = value;
/* update parent type's vlen */
t = btf_last_type(btf);
btf_type_inc_vlen(t);
/* if negative value, set signedness to signed */ if (value < 0)
t->info = btf_type_info(btf_kind(t), btf_vlen(t), true);
/* * Append new BTF_KIND_ENUM64 type with: * - *name* - name of the enum, can be NULL or empty for anonymous enums; * - *byte_sz* - size of the enum, in bytes. * - *is_signed* - whether the enum values are signed or not; * * Enum initially has no enum values in it (and corresponds to enum forward * declaration). Enumerator values can be added by btf__add_enum64_value() * immediately after btf__add_enum64() succeeds. * * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_enum64(struct btf *btf, constchar *name, __u32 byte_sz, bool is_signed)
{ return btf_add_enum_common(btf, name, byte_sz, is_signed,
BTF_KIND_ENUM64);
}
/* * Append new enum value for the current ENUM64 type with: * - *name* - name of the enumerator value, can't be NULL or empty; * - *value* - integer value corresponding to enum value *name*; * Returns: * - 0, on success; * - <0, on error.
*/ int btf__add_enum64_value(struct btf *btf, constchar *name, __u64 value)
{ struct btf_enum64 *v; struct btf_type *t; int sz, name_off;
/* last type should be BTF_KIND_ENUM64 */ if (btf->nr_types == 0) return libbpf_err(-EINVAL);
t = btf_last_type(btf); if (!btf_is_enum64(t)) return libbpf_err(-EINVAL);
/* non-empty name */ if (!name || !name[0]) return libbpf_err(-EINVAL);
/* decompose and invalidate raw data */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_enum64);
v = btf_add_type_mem(btf, sz); if (!v) return libbpf_err(-ENOMEM);
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
/* * Append new BTF_KIND_FWD type with: * - *name*, non-empty/non-NULL name; * - *fwd_kind*, kind of forward declaration, one of BTF_FWD_STRUCT, * BTF_FWD_UNION, or BTF_FWD_ENUM; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_fwd(struct btf *btf, constchar *name, enum btf_fwd_kind fwd_kind)
{ if (!name || !name[0]) return libbpf_err(-EINVAL);
switch (fwd_kind) { case BTF_FWD_STRUCT: case BTF_FWD_UNION: { struct btf_type *t; int id;
id = btf_add_ref_kind(btf, BTF_KIND_FWD, name, 0, 0); if (id <= 0) return id;
t = btf_type_by_id(btf, id);
t->info = btf_type_info(BTF_KIND_FWD, 0, fwd_kind == BTF_FWD_UNION); return id;
} case BTF_FWD_ENUM: /* enum forward in BTF currently is just an enum with no enum * values; we also assume a standard 4-byte size for it
*/ return btf__add_enum(btf, name, sizeof(int)); default: return libbpf_err(-EINVAL);
}
}
/* * Append new BTF_KING_TYPEDEF type with: * - *name*, non-empty/non-NULL name; * - *ref_type_id* - referenced type ID, it might not exist yet; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_typedef(struct btf *btf, constchar *name, int ref_type_id)
{ if (!name || !name[0]) return libbpf_err(-EINVAL);
/* * Append new BTF_KIND_VOLATILE type with: * - *ref_type_id* - referenced type ID, it might not exist yet; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_volatile(struct btf *btf, int ref_type_id)
{ return btf_add_ref_kind(btf, BTF_KIND_VOLATILE, NULL, ref_type_id, 0);
}
/* * Append new BTF_KIND_CONST type with: * - *ref_type_id* - referenced type ID, it might not exist yet; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_const(struct btf *btf, int ref_type_id)
{ return btf_add_ref_kind(btf, BTF_KIND_CONST, NULL, ref_type_id, 0);
}
/* * Append new BTF_KIND_RESTRICT type with: * - *ref_type_id* - referenced type ID, it might not exist yet; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_restrict(struct btf *btf, int ref_type_id)
{ return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id, 0);
}
/* * Append new BTF_KIND_TYPE_TAG type with: * - *value*, non-empty/non-NULL tag value; * - *ref_type_id* - referenced type ID, it might not exist yet; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_type_tag(struct btf *btf, constchar *value, int ref_type_id)
{ if (!value || !value[0]) return libbpf_err(-EINVAL);
/* * Append new BTF_KIND_TYPE_TAG type with: * - *value*, non-empty/non-NULL tag value; * - *ref_type_id* - referenced type ID, it might not exist yet; * Set info->kflag to 1, indicating this tag is an __attribute__ * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_type_attr(struct btf *btf, constchar *value, int ref_type_id)
{ if (!value || !value[0]) return libbpf_err(-EINVAL);
/* * Append new BTF_KIND_FUNC type with: * - *name*, non-empty/non-NULL name; * - *proto_type_id* - FUNC_PROTO's type ID, it might not exist yet; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_func(struct btf *btf, constchar *name, enum btf_func_linkage linkage, int proto_type_id)
{ int id;
if (!name || !name[0]) return libbpf_err(-EINVAL); if (linkage != BTF_FUNC_STATIC && linkage != BTF_FUNC_GLOBAL &&
linkage != BTF_FUNC_EXTERN) return libbpf_err(-EINVAL);
id = btf_add_ref_kind(btf, BTF_KIND_FUNC, name, proto_type_id, 0); if (id > 0) { struct btf_type *t = btf_type_by_id(btf, id);
/* * Append new BTF_KIND_FUNC_PROTO with: * - *ret_type_id* - type ID for return result of a function. * * Function prototype initially has no arguments, but they can be added by * btf__add_func_param() one by one, immediately after * btf__add_func_proto() succeeded. * * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_func_proto(struct btf *btf, int ret_type_id)
{ struct btf_type *t; int sz;
if (validate_type_id(ret_type_id)) return libbpf_err(-EINVAL);
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
/* start out with vlen=0; this will be adjusted when adding enum * values, if necessary
*/
t->name_off = 0;
t->info = btf_type_info(BTF_KIND_FUNC_PROTO, 0, 0);
t->type = ret_type_id;
return btf_commit_type(btf, sz);
}
/* * Append new function parameter for current FUNC_PROTO type with: * - *name* - parameter name, can be NULL or empty; * - *type_id* - type ID describing the type of the parameter. * Returns: * - 0, on success; * - <0, on error.
*/ int btf__add_func_param(struct btf *btf, constchar *name, int type_id)
{ struct btf_type *t; struct btf_param *p; int sz, name_off = 0;
if (validate_type_id(type_id)) return libbpf_err(-EINVAL);
/* last type should be BTF_KIND_FUNC_PROTO */ if (btf->nr_types == 0) return libbpf_err(-EINVAL);
t = btf_last_type(btf); if (!btf_is_func_proto(t)) return libbpf_err(-EINVAL);
/* decompose and invalidate raw data */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_param);
p = btf_add_type_mem(btf, sz); if (!p) return libbpf_err(-ENOMEM);
if (name && name[0]) {
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
}
p->name_off = name_off;
p->type = type_id;
/* update parent type's vlen */
t = btf_last_type(btf);
btf_type_inc_vlen(t);
/* * Append new BTF_KIND_VAR type with: * - *name* - non-empty/non-NULL name; * - *linkage* - variable linkage, one of BTF_VAR_STATIC, * BTF_VAR_GLOBAL_ALLOCATED, or BTF_VAR_GLOBAL_EXTERN; * - *type_id* - type ID of the type describing the type of the variable. * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_var(struct btf *btf, constchar *name, int linkage, int type_id)
{ struct btf_type *t; struct btf_var *v; int sz, name_off;
/* non-empty name */ if (!name || !name[0]) return libbpf_err(-EINVAL); if (linkage != BTF_VAR_STATIC && linkage != BTF_VAR_GLOBAL_ALLOCATED &&
linkage != BTF_VAR_GLOBAL_EXTERN) return libbpf_err(-EINVAL); if (validate_type_id(type_id)) return libbpf_err(-EINVAL);
/* deconstruct BTF, if necessary, and invalidate raw_data */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type) + sizeof(struct btf_var);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
/* * Append new BTF_KIND_DATASEC type with: * - *name* - non-empty/non-NULL name; * - *byte_sz* - data section size, in bytes. * * Data section is initially empty. Variables info can be added with * btf__add_datasec_var_info() calls, after btf__add_datasec() succeeds. * * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_datasec(struct btf *btf, constchar *name, __u32 byte_sz)
{ struct btf_type *t; int sz, name_off;
/* non-empty name */ if (!name || !name[0]) return libbpf_err(-EINVAL);
if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_type);
t = btf_add_type_mem(btf, sz); if (!t) return libbpf_err(-ENOMEM);
name_off = btf__add_str(btf, name); if (name_off < 0) return name_off;
/* start with vlen=0, which will be update as var_secinfos are added */
t->name_off = name_off;
t->info = btf_type_info(BTF_KIND_DATASEC, 0, 0);
t->size = byte_sz;
return btf_commit_type(btf, sz);
}
/* * Append new data section variable information entry for current DATASEC type: * - *var_type_id* - type ID, describing type of the variable; * - *offset* - variable offset within data section, in bytes; * - *byte_sz* - variable size, in bytes. * * Returns: * - 0, on success; * - <0, on error.
*/ int btf__add_datasec_var_info(struct btf *btf, int var_type_id, __u32 offset, __u32 byte_sz)
{ struct btf_type *t; struct btf_var_secinfo *v; int sz;
/* last type should be BTF_KIND_DATASEC */ if (btf->nr_types == 0) return libbpf_err(-EINVAL);
t = btf_last_type(btf); if (!btf_is_datasec(t)) return libbpf_err(-EINVAL);
if (validate_type_id(var_type_id)) return libbpf_err(-EINVAL);
/* decompose and invalidate raw data */ if (btf_ensure_modifiable(btf)) return libbpf_err(-ENOMEM);
sz = sizeof(struct btf_var_secinfo);
v = btf_add_type_mem(btf, sz); if (!v) return libbpf_err(-ENOMEM);
/* * Append new BTF_KIND_DECL_TAG type with: * - *value* - non-empty/non-NULL string; * - *ref_type_id* - referenced type ID, it might not exist yet; * - *component_idx* - -1 for tagging reference type, otherwise struct/union * member or function argument index; * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_decl_tag(struct btf *btf, constchar *value, int ref_type_id, int component_idx)
{ return btf_add_decl_tag(btf, value, ref_type_id, component_idx, 0);
}
/* * Append new BTF_KIND_DECL_TAG type with: * - *value* - non-empty/non-NULL string; * - *ref_type_id* - referenced type ID, it might not exist yet; * - *component_idx* - -1 for tagging reference type, otherwise struct/union * member or function argument index; * Set info->kflag to 1, indicating this tag is an __attribute__ * Returns: * - >0, type ID of newly added BTF type; * - <0, on error.
*/ int btf__add_decl_attr(struct btf *btf, constchar *value, int ref_type_id, int component_idx)
{ return btf_add_decl_tag(btf, value, ref_type_id, component_idx, 1);
}
/* * Parse a single info subsection of the BTF.ext info data: * - validate subsection structure and elements * - save info subsection start and sizing details in struct btf_ext * - endian-independent operation, for calling before byte-swapping
*/ staticint btf_ext_parse_sec_info(struct btf_ext *btf_ext, struct btf_ext_sec_info_param *ext_sec, bool is_native)
{ conststruct btf_ext_info_sec *sinfo; struct btf_ext_info *ext_info;
__u32 info_left, record_size;
size_t sec_cnt = 0; void *info;
if (ext_sec->len == 0) return 0;
if (ext_sec->off & 0x03) {
pr_debug(".BTF.ext %s section is not aligned to 4 bytes\n",
ext_sec->desc); return -EINVAL;
}
/* The start of the info sec (including the __u32 record_size). */
info = btf_ext->data + btf_ext->hdr->hdr_len + ext_sec->off;
info_left = ext_sec->len;
if (btf_ext->data + btf_ext->data_size < info + ext_sec->len) {
pr_debug("%s section (off:%u len:%u) is beyond the end of the ELF section .BTF.ext\n",
ext_sec->desc, ext_sec->off, ext_sec->len); return -EINVAL;
}
/* At least a record size */ if (info_left < sizeof(__u32)) {
pr_debug(".BTF.ext %s record size not found\n", ext_sec->desc); return -EINVAL;
}
/* The record size needs to meet either the minimum standard or, when * handling non-native endianness data, the exact standard so as * to allow safe byte-swapping.
*/
record_size = is_native ? *(__u32 *)info : bswap_32(*(__u32 *)info); if (record_size < ext_sec->min_rec_size ||
(!is_native && record_size != ext_sec->min_rec_size) ||
record_size & 0x03) {
pr_debug("%s section in .BTF.ext has invalid record size %u\n",
ext_sec->desc, record_size); return -EINVAL;
}
sinfo = info + sizeof(__u32);
info_left -= sizeof(__u32);
/* If no records, return failure now so .BTF.ext won't be used. */ if (!info_left) {
pr_debug("%s section in .BTF.ext has no records\n", ext_sec->desc); return -EINVAL;
}
/* Ensure known version of structs, current BTF_VERSION == 1 */ if (hdr->version != 1) {
pr_debug("Unsupported BTF.ext version:%u\n", hdr->version); return -ENOTSUP;
}
if (hdr->flags) {
pr_debug("Unsupported BTF.ext flags:%x\n", hdr->flags); return -ENOTSUP;
}
if (data_size < hdr_len) {
pr_debug("BTF.ext header not found\n"); return -EINVAL;
} elseif (data_size == hdr_len) {
pr_debug("BTF.ext has no data\n"); return -EINVAL;
}
/* Keep hdr native byte-order in memory for introspection */ if (swapped_endian)
btf_ext_bswap_hdr(btf_ext->hdr);
/* Validate info subsections and cache key metadata */
err = btf_ext_parse_info(btf_ext, !swapped_endian); if (err) return err;
/* Keep infos native byte-order in memory for introspection */ if (swapped_endian)
btf_ext_bswap_info(btf_ext, btf_ext->data);
/* * Set btf_ext->swapped_endian only after all header and info data has * been swapped, helping bswap functions determine if their data are * in native byte-order when called.
*/
btf_ext->swapped_endian = swapped_endian; return 0;
}
/* Return native data (always present) or swapped data if present */ if (!swap_endian) return btf_ext->data; elseif (btf_ext->data_swapped) return btf_ext->data_swapped;
/* Recreate missing swapped data, then cache and return */
data = calloc(1, data_sz); if (!data) return NULL;
memcpy(data, btf_ext->data, data_sz);
/* * Deduplicate BTF types and strings. * * BTF dedup algorithm takes as an input `struct btf` representing `.BTF` ELF * section with all BTF type descriptors and string data. It overwrites that * memory in-place with deduplicated types and strings without any loss of * information. If optional `struct btf_ext` representing '.BTF.ext' ELF section * is provided, all the strings referenced from .BTF.ext section are honored * and updated to point to the right offsets after deduplication. * * If function returns with error, type/string data might be garbled and should * be discarded. * * More verbose and detailed description of both problem btf_dedup is solving, * as well as solution could be found at: * https://facebookmicrosites.github.io/bpf/blog/2018/11/14/btf-enhancement.html * * Problem description and justification * ===================================== * * BTF type information is typically emitted either as a result of conversion * from DWARF to BTF or directly by compiler. In both cases, each compilation * unit contains information about a subset of all the types that are used * in an application. These subsets are frequently overlapping and contain a lot * of duplicated information when later concatenated together into a single * binary. This algorithm ensures that each unique type is represented by single * BTF type descriptor, greatly reducing resulting size of BTF data. * * Compilation unit isolation and subsequent duplication of data is not the only * problem. The same type hierarchy (e.g., struct and all the type that struct * references) in different compilation units can be represented in BTF to * various degrees of completeness (or, rather, incompleteness) due to * struct/union forward declarations. * * Let's take a look at an example, that we'll use to better understand the * problem (and solution). Suppose we have two compilation units, each using * same `struct S`, but each of them having incomplete type information about * struct's fields: * * // CU #1: * struct S; * struct A { * int a; * struct A* self; * struct S* parent; * }; * struct B; * struct S { * struct A* a_ptr; * struct B* b_ptr; * }; * * // CU #2: * struct S; * struct A; * struct B { * int b; * struct B* self; * struct S* parent; * }; * struct S { * struct A* a_ptr; * struct B* b_ptr; * }; * * In case of CU #1, BTF data will know only that `struct B` exist (but no * more), but will know the complete type information about `struct A`. While * for CU #2, it will know full type information about `struct B`, but will * only know about forward declaration of `struct A` (in BTF terms, it will * have `BTF_KIND_FWD` type descriptor with name `B`). * * This compilation unit isolation means that it's possible that there is no * single CU with complete type information describing structs `S`, `A`, and * `B`. Also, we might get tons of duplicated and redundant type information. * * Additional complication we need to keep in mind comes from the fact that * types, in general, can form graphs containing cycles, not just DAGs. * * While algorithm does deduplication, it also merges and resolves type * information (unless disabled throught `struct btf_opts`), whenever possible. * E.g., in the example above with two compilation units having partial type * information for structs `A` and `B`, the output of algorithm will emit * a single copy of each BTF type that describes structs `A`, `B`, and `S` * (as well as type information for `int` and pointers), as if they were defined * in a single compilation unit as: * * struct A { * int a; * struct A* self; * struct S* parent; * }; * struct B { * int b; * struct B* self; * struct S* parent; * }; * struct S { * struct A* a_ptr; * struct B* b_ptr; * }; * * Algorithm summary * ================= * * Algorithm completes its work in 7 separate passes: * * 1. Strings deduplication. * 2. Primitive types deduplication (int, enum, fwd). * 3. Struct/union types deduplication. * 4. Resolve unambiguous forward declarations. * 5. Reference types deduplication (pointers, typedefs, arrays, funcs, func * protos, and const/volatile/restrict modifiers). * 6. Types compaction. * 7. Types remapping. * * Algorithm determines canonical type descriptor, which is a single * representative type for each truly unique type. This canonical type is the * one that will go into final deduplicated BTF type information. For * struct/unions, it is also the type that algorithm will merge additional type * information into (while resolving FWDs), as it discovers it from data in * other CUs. Each input BTF type eventually gets either mapped to itself, if * that type is canonical, or to some other type, if that type is equivalent * and was chosen as canonical representative. This mapping is stored in * `btf_dedup->map` array. This map is also used to record STRUCT/UNION that * FWD type got resolved to. * * To facilitate fast discovery of canonical types, we also maintain canonical * index (`btf_dedup->dedup_table`), which maps type descriptor's signature hash * (i.e., hashed kind, name, size, fields, etc) into a list of canonical types * that match that signature. With sufficiently good choice of type signature * hashing function, we can limit number of canonical types for each unique type * signature to a very small number, allowing to find canonical type for any * duplicated type very quickly. * * Struct/union deduplication is the most critical part and algorithm for * deduplicating structs/unions is described in greater details in comments for * `btf_dedup_is_equiv` function.
*/ int btf__dedup(struct btf *btf, conststruct btf_dedup_opts *opts)
{ struct btf_dedup *d; int err;
if (!OPTS_VALID(opts, btf_dedup_opts)) return libbpf_err(-EINVAL);
d = btf_dedup_new(btf, opts); if (IS_ERR(d)) {
pr_debug("btf_dedup_new failed: %ld\n", PTR_ERR(d)); return libbpf_err(-EINVAL);
}
if (btf_ensure_modifiable(btf)) {
err = -ENOMEM; goto done;
}
struct btf_dedup { /* .BTF section to be deduped in-place */ struct btf *btf; /* * Optional .BTF.ext section. When provided, any strings referenced * from it will be taken into account when deduping strings
*/ struct btf_ext *btf_ext; /* * This is a map from any type's signature hash to a list of possible * canonical representative type candidates. Hash collisions are * ignored, so even types of various kinds can share same list of * candidates, which is fine because we rely on subsequent * btf_xxx_equal() checks to authoritatively verify type equality.
*/ struct hashmap *dedup_table; /* Canonical types map */
__u32 *map; /* Hypothetical mapping, used during type graph equivalence checks */
__u32 *hypot_map;
__u32 *hypot_list;
size_t hypot_cnt;
size_t hypot_cap; /* Whether hypothetical mapping, if successful, would need to adjust * already canonicalized types (due to a new forward declaration to * concrete type resolution). In such case, during split BTF dedup * candidate type would still be considered as different, because base * BTF is considered to be immutable.
*/ bool hypot_adjust_canon; /* Various option modifying behavior of algorithm */ struct btf_dedup_opts opts; /* temporary strings deduplication state */ struct strset *strs_set;
};
type_cnt = btf__type_cnt(btf);
d->map = malloc(sizeof(__u32) * type_cnt); if (!d->map) {
err = -ENOMEM; goto done;
} /* special BTF "void" type is made canonical immediately */
d->map[0] = 0; for (i = 1; i < type_cnt; i++) { struct btf_type *t = btf_type_by_id(d->btf, i);
/* VAR and DATASEC are never deduped and are self-canonical */ if (btf_is_var(t) || btf_is_datasec(t))
d->map[i] = i; else
d->map[i] = BTF_UNPROCESSED_ID;
}
d->hypot_map = malloc(sizeof(__u32) * type_cnt); if (!d->hypot_map) {
err = -ENOMEM; goto done;
} for (i = 0; i < type_cnt; i++)
d->hypot_map[i] = BTF_UNPROCESSED_ID;
done: if (err) {
btf_dedup_free(d); return ERR_PTR(err);
}
return d;
}
/* * Iterate over all possible places in .BTF and .BTF.ext that can reference * string and pass pointer to it to a provided callback `fn`.
*/ staticint btf_for_each_str_off(struct btf_dedup *d, str_off_visit_fn fn, void *ctx)
{ int i, r;
for (i = 0; i < d->btf->nr_types; i++) { struct btf_field_iter it; struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i);
__u32 *str_off;
r = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS); if (r) return r;
while ((str_off = btf_field_iter_next(&it))) {
r = fn(str_off, ctx); if (r) return r;
}
}
if (!d->btf_ext) return 0;
r = btf_ext_visit_str_offs(d->btf_ext, fn, ctx); if (r) return r;
/* * Dedup string and filter out those that are not referenced from either .BTF * or .BTF.ext (if provided) sections. * * This is done by building index of all strings in BTF's string section, * then iterating over all entities that can reference strings (e.g., type * names, struct field names, .BTF.ext line info, etc) and marking corresponding * strings as used. After that all used strings are deduped and compacted into * sequential blob of memory and new offsets are calculated. Then all the string * references are iterated again and rewritten using new offsets.
*/ staticint btf_dedup_strings(struct btf_dedup *d)
{ int err;
if (!d->btf->base_btf) { /* insert empty string; we won't be looking it up during strings * dedup, but it's good to have it for generic BTF string lookups
*/
err = strset__add_str(d->strs_set, ""); if (err < 0) goto err_out;
}
staticbool btf_compat_enum(struct btf_type *t1, struct btf_type *t2)
{ if (!btf_is_enum_fwd(t1) && !btf_is_enum_fwd(t2)) return btf_equal_enum(t1, t2); /* At this point either t1 or t2 or both are forward declarations, thus: * - skip comparing vlen because it is zero for forward declarations; * - skip comparing size to allow enum forward declarations * to be compatible with enum64 full declarations; * - skip comparing kind for the same reason.
*/ return t1->name_off == t2->name_off &&
btf_is_any_enum(t1) && btf_is_any_enum(t2);
}
/* * Calculate type signature hash of STRUCT/UNION, ignoring referenced type IDs, * as referenced type IDs equivalence is established separately during type * graph equivalence check algorithm.
*/ staticlong btf_hash_struct(struct btf_type *t)
{ conststruct btf_member *member = btf_members(t);
__u32 vlen = btf_vlen(t); long h = btf_hash_common(t); int i;
for (i = 0; i < vlen; i++) {
h = hash_combine(h, member->name_off);
h = hash_combine(h, member->offset); /* no hashing of referenced type ID, it can be unresolved yet */
member++;
} return h;
}
/* * Check structural compatibility of two STRUCTs/UNIONs, ignoring referenced * type IDs. This check is performed during type graph equivalence check and * referenced types equivalence is checked separately.
*/ staticbool btf_shallow_equal_struct(struct btf_type *t1, struct btf_type *t2)
{ conststruct btf_member *m1, *m2;
__u16 vlen; int i;
if (!btf_equal_common(t1, t2)) returnfalse;
vlen = btf_vlen(t1);
m1 = btf_members(t1);
m2 = btf_members(t2); for (i = 0; i < vlen; i++) { if (m1->name_off != m2->name_off || m1->offset != m2->offset) returnfalse;
m1++;
m2++;
} returntrue;
}
/* * Calculate type signature hash of ARRAY, including referenced type IDs, * under assumption that they were already resolved to canonical type IDs and * are not going to change.
*/ staticlong btf_hash_array(struct btf_type *t)
{ conststruct btf_array *info = btf_array(t); long h = btf_hash_common(t);
h = hash_combine(h, info->type);
h = hash_combine(h, info->index_type);
h = hash_combine(h, info->nelems); return h;
}
/* * Check exact equality of two ARRAYs, taking into account referenced * type IDs, under assumption that they were already resolved to canonical * type IDs and are not going to change. * This function is called during reference types deduplication to compare * ARRAY to potential canonical representative.
*/ staticbool btf_equal_array(struct btf_type *t1, struct btf_type *t2)
{ conststruct btf_array *info1, *info2;
/* * Check structural compatibility of two ARRAYs, ignoring referenced type * IDs. This check is performed during type graph equivalence check and * referenced types equivalence is checked separately.
*/ staticbool btf_compat_array(struct btf_type *t1, struct btf_type *t2)
{ if (!btf_equal_common(t1, t2)) returnfalse;
/* * Calculate type signature hash of FUNC_PROTO, including referenced type IDs, * under assumption that they were already resolved to canonical type IDs and * are not going to change.
*/ staticlong btf_hash_fnproto(struct btf_type *t)
{ conststruct btf_param *member = btf_params(t);
__u16 vlen = btf_vlen(t); long h = btf_hash_common(t); int i;
for (i = 0; i < vlen; i++) {
h = hash_combine(h, member->name_off);
h = hash_combine(h, member->type);
member++;
} return h;
}
/* * Check exact equality of two FUNC_PROTOs, taking into account referenced * type IDs, under assumption that they were already resolved to canonical * type IDs and are not going to change. * This function is called during reference types deduplication to compare * FUNC_PROTO to potential canonical representative.
*/ staticbool btf_equal_fnproto(struct btf_type *t1, struct btf_type *t2)
{ conststruct btf_param *m1, *m2;
__u16 vlen; int i;
if (!btf_equal_common(t1, t2)) returnfalse;
vlen = btf_vlen(t1);
m1 = btf_params(t1);
m2 = btf_params(t2); for (i = 0; i < vlen; i++) { if (m1->name_off != m2->name_off || m1->type != m2->type) returnfalse;
m1++;
m2++;
} returntrue;
}
/* * Check structural compatibility of two FUNC_PROTOs, ignoring referenced type * IDs. This check is performed during type graph equivalence check and * referenced types equivalence is checked separately.
*/ staticbool btf_compat_fnproto(struct btf_type *t1, struct btf_type *t2)
{ conststruct btf_param *m1, *m2;
__u16 vlen; int i;
/* skip return type ID */ if (t1->name_off != t2->name_off || t1->info != t2->info) returnfalse;
vlen = btf_vlen(t1);
m1 = btf_params(t1);
m2 = btf_params(t2); for (i = 0; i < vlen; i++) { if (m1->name_off != m2->name_off) returnfalse;
m1++;
m2++;
} returntrue;
}
/* Prepare split BTF for deduplication by calculating hashes of base BTF's * types and initializing the rest of the state (canonical type mapping) for * the fixed base BTF part.
*/ staticint btf_dedup_prep(struct btf_dedup *d)
{ struct btf_type *t; int type_id; long h;
if (!d->btf->base_btf) return 0;
for (type_id = 1; type_id < d->btf->start_id; type_id++) {
t = btf_type_by_id(d->btf, type_id);
/* all base BTF types are self-canonical by definition */
d->map[type_id] = type_id;
switch (btf_kind(t)) { case BTF_KIND_VAR: case BTF_KIND_DATASEC: /* VAR and DATASEC are never hash/deduplicated */ continue; case BTF_KIND_CONST: case BTF_KIND_VOLATILE: case BTF_KIND_RESTRICT: case BTF_KIND_PTR: case BTF_KIND_FWD: case BTF_KIND_TYPEDEF: case BTF_KIND_FUNC: case BTF_KIND_FLOAT: case BTF_KIND_TYPE_TAG:
h = btf_hash_common(t); break; case BTF_KIND_INT: case BTF_KIND_DECL_TAG:
h = btf_hash_int_decl_tag(t); break; case BTF_KIND_ENUM: case BTF_KIND_ENUM64:
h = btf_hash_enum(t); break; case BTF_KIND_STRUCT: case BTF_KIND_UNION:
h = btf_hash_struct(t); break; case BTF_KIND_ARRAY:
h = btf_hash_array(t); break; case BTF_KIND_FUNC_PROTO:
h = btf_hash_fnproto(t); break; default:
pr_debug("unknown kind %d for type [%d]\n", btf_kind(t), type_id); return -EINVAL;
} if (btf_dedup_table_add(d, h, type_id)) return -ENOMEM;
}
return 0;
}
/* * Deduplicate primitive types, that can't reference other types, by calculating * their type signature hash and comparing them with any possible canonical * candidate. If no canonical candidate matches, type itself is marked as * canonical and is added into `btf_dedup->dedup_table` as another candidate.
*/ staticint btf_dedup_prim_type(struct btf_dedup *d, __u32 type_id)
{ struct btf_type *t = btf_type_by_id(d->btf, type_id); struct hashmap_entry *hash_entry; struct btf_type *cand; /* if we don't find equivalent type, then we are canonical */
__u32 new_id = type_id;
__u32 cand_id; long h;
switch (btf_kind(t)) { case BTF_KIND_CONST: case BTF_KIND_VOLATILE: case BTF_KIND_RESTRICT: case BTF_KIND_PTR: case BTF_KIND_TYPEDEF: case BTF_KIND_ARRAY: case BTF_KIND_STRUCT: case BTF_KIND_UNION: case BTF_KIND_FUNC: case BTF_KIND_FUNC_PROTO: case BTF_KIND_VAR: case BTF_KIND_DATASEC: case BTF_KIND_DECL_TAG: case BTF_KIND_TYPE_TAG: return 0;
case BTF_KIND_INT:
h = btf_hash_int_decl_tag(t);
for_each_dedup_cand(d, hash_entry, h) {
cand_id = hash_entry->value;
cand = btf_type_by_id(d->btf, cand_id); if (btf_equal_int_tag(t, cand)) {
new_id = cand_id; break;
}
} break;
case BTF_KIND_ENUM: case BTF_KIND_ENUM64:
h = btf_hash_enum(t);
for_each_dedup_cand(d, hash_entry, h) {
cand_id = hash_entry->value;
cand = btf_type_by_id(d->btf, cand_id); if (btf_equal_enum(t, cand)) {
new_id = cand_id; break;
} if (btf_compat_enum(t, cand)) { if (btf_is_enum_fwd(t)) { /* resolve fwd to full enum */
new_id = cand_id; break;
} /* resolve canonical enum fwd to full enum */
d->map[cand_id] = type_id;
}
} break;
case BTF_KIND_FWD: case BTF_KIND_FLOAT:
h = btf_hash_common(t);
for_each_dedup_cand(d, hash_entry, h) {
cand_id = hash_entry->value;
cand = btf_type_by_id(d->btf, cand_id); if (btf_equal_common(t, cand)) {
new_id = cand_id; break;
}
} break;
staticint btf_dedup_prim_types(struct btf_dedup *d)
{ int i, err;
for (i = 0; i < d->btf->nr_types; i++) {
err = btf_dedup_prim_type(d, d->btf->start_id + i); if (err) return err;
} return 0;
}
/* * Check whether type is already mapped into canonical one (could be to itself).
*/ staticinlinebool is_type_mapped(struct btf_dedup *d, uint32_t type_id)
{ return d->map[type_id] <= BTF_MAX_NR_TYPES;
}
/* * Resolve type ID into its canonical type ID, if any; otherwise return original * type ID. If type is FWD and is resolved into STRUCT/UNION already, follow * STRUCT/UNION link and resolve it into canonical type ID as well.
*/ staticinline __u32 resolve_type_id(struct btf_dedup *d, __u32 type_id)
{ while (is_type_mapped(d, type_id) && d->map[type_id] != type_id)
type_id = d->map[type_id]; return type_id;
}
/* * Resolve FWD to underlying STRUCT/UNION, if any; otherwise return original * type ID.
*/ static uint32_t resolve_fwd_id(struct btf_dedup *d, uint32_t type_id)
{
__u32 orig_type_id = type_id;
if (!btf_is_fwd(btf__type_by_id(d->btf, type_id))) return type_id;
while (is_type_mapped(d, type_id) && d->map[type_id] != type_id)
type_id = d->map[type_id];
if (!btf_is_fwd(btf__type_by_id(d->btf, type_id))) return type_id;
switch (k1) { case BTF_KIND_UNKN: /* VOID */ returntrue; case BTF_KIND_INT: return btf_equal_int_tag(t1, t2); case BTF_KIND_ENUM: case BTF_KIND_ENUM64: return btf_compat_enum(t1, t2); case BTF_KIND_FWD: case BTF_KIND_FLOAT: return btf_equal_common(t1, t2); case BTF_KIND_CONST: case BTF_KIND_VOLATILE: case BTF_KIND_RESTRICT: case BTF_KIND_PTR: case BTF_KIND_TYPEDEF: case BTF_KIND_FUNC: case BTF_KIND_TYPE_TAG: if (t1->info != t2->info || t1->name_off != t2->name_off) returnfalse;
id1 = t1->type;
id2 = t2->type; goto recur; case BTF_KIND_ARRAY: { struct btf_array *a1, *a2;
p1 = btf_params(t1);
p2 = btf_params(t2); for (i = 0, n = btf_vlen(t1); i < n; i++, p1++, p2++) { if (p1->type == p2->type) continue; if (!btf_dedup_identical_types(d, p1->type, p2->type, depth - 1)) returnfalse;
} returntrue;
} default: returnfalse;
}
}
/* * Check equivalence of BTF type graph formed by candidate struct/union (we'll * call it "candidate graph" in this description for brevity) to a type graph * formed by (potential) canonical struct/union ("canonical graph" for brevity * here, though keep in mind that not all types in canonical graph are * necessarily canonical representatives themselves, some of them might be * duplicates or its uniqueness might not have been established yet). * Returns: * - >0, if type graphs are equivalent; * - 0, if not equivalent; * - <0, on error. * * Algorithm performs side-by-side DFS traversal of both type graphs and checks * equivalence of BTF types at each step. If at any point BTF types in candidate * and canonical graphs are not compatible structurally, whole graphs are * incompatible. If types are structurally equivalent (i.e., all information * except referenced type IDs is exactly the same), a mapping from `canon_id` to * a `cand_id` is recoded in hypothetical mapping (`btf_dedup->hypot_map`). * If a type references other types, then those referenced types are checked * for equivalence recursively. * * During DFS traversal, if we find that for current `canon_id` type we * already have some mapping in hypothetical map, we check for two possible * situations: * - `canon_id` is mapped to exactly the same type as `cand_id`. This will * happen when type graphs have cycles. In this case we assume those two * types are equivalent. * - `canon_id` is mapped to different type. This is contradiction in our * hypothetical mapping, because same graph in canonical graph corresponds * to two different types in candidate graph, which for equivalent type * graphs shouldn't happen. This condition terminates equivalence check * with negative result. * * If type graphs traversal exhausts types to check and find no contradiction, * then type graphs are equivalent. * * When checking types for equivalence, there is one special case: FWD types. * If FWD type resolution is allowed and one of the types (either from canonical * or candidate graph) is FWD and other is STRUCT/UNION (depending on FWD's kind * flag) and their names match, hypothetical mapping is updated to point from * FWD to STRUCT/UNION. If graphs will be determined as equivalent successfully, * this mapping will be used to record FWD -> STRUCT/UNION mapping permanently. * * Technically, this could lead to incorrect FWD to STRUCT/UNION resolution, * if there are two exactly named (or anonymous) structs/unions that are * compatible structurally, one of which has FWD field, while other is concrete * STRUCT/UNION, but according to C sources they are different structs/unions * that are referencing different types with the same name. This is extremely * unlikely to happen, but btf_dedup API allows to disable FWD resolution if * this logic is causing problems. * * Doing FWD resolution means that both candidate and/or canonical graphs can * consists of portions of the graph that come from multiple compilation units. * This is due to the fact that types within single compilation unit are always * deduplicated and FWDs are already resolved, if referenced struct/union * definition is available. So, if we had unresolved FWD and found corresponding * STRUCT/UNION, they will be from different compilation units. This * consequently means that when we "link" FWD to corresponding STRUCT/UNION, * type graph will likely have at least two different BTF types that describe * same type (e.g., most probably there will be two different BTF types for the * same 'int' primitive type) and could even have "overlapping" parts of type * graph that describe same subset of types. * * This in turn means that our assumption that each type in canonical graph * must correspond to exactly one type in candidate graph might not hold * anymore and will make it harder to detect contradictions using hypothetical * map. To handle this problem, we allow to follow FWD -> STRUCT/UNION * resolution only in canonical graph. FWDs in candidate graphs are never * resolved. To see why it's OK, let's check all possible situations w.r.t. FWDs * that can occur: * - Both types in canonical and candidate graphs are FWDs. If they are * structurally equivalent, then they can either be both resolved to the * same STRUCT/UNION or not resolved at all. In both cases they are * equivalent and there is no need to resolve FWD on candidate side. * - Both types in canonical and candidate graphs are concrete STRUCT/UNION, * so nothing to resolve as well, algorithm will check equivalence anyway. * - Type in canonical graph is FWD, while type in candidate is concrete * STRUCT/UNION. In this case candidate graph comes from single compilation * unit, so there is exactly one BTF type for each unique C type. After * resolving FWD into STRUCT/UNION, there might be more than one BTF type * in canonical graph mapping to single BTF type in candidate graph, but * because hypothetical mapping maps from canonical to candidate types, it's * alright, and we still maintain the property of having single `canon_id` * mapping to single `cand_id` (there could be two different `canon_id` * mapped to the same `cand_id`, but it's not contradictory). * - Type in canonical graph is concrete STRUCT/UNION, while type in candidate * graph is FWD. In this case we are just going to check compatibility of * STRUCT/UNION and corresponding FWD, and if they are compatible, we'll * assume that whatever STRUCT/UNION FWD resolves to must be equivalent to * a concrete STRUCT/UNION from canonical graph. If the rest of type graphs * turn out equivalent, we'll re-resolve FWD to concrete STRUCT/UNION from * canonical graph.
*/ staticint btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
__u32 canon_id)
{ struct btf_type *cand_type; struct btf_type *canon_type;
__u32 hypot_type_id;
__u16 cand_kind;
__u16 canon_kind; int i, eq;
/* if both resolve to the same canonical, they must be equivalent */ if (resolve_type_id(d, cand_id) == resolve_type_id(d, canon_id)) return 1;
canon_id = resolve_fwd_id(d, canon_id);
hypot_type_id = d->hypot_map[canon_id]; if (hypot_type_id <= BTF_MAX_NR_TYPES) { if (hypot_type_id == cand_id) return 1; /* In some cases compiler will generate different DWARF types * for *identical* array type definitions and use them for * different fields within the *same* struct. This breaks type * equivalence check, which makes an assumption that candidate * types sub-graph has a consistent and deduped-by-compiler * types within a single CU. And similar situation can happen * with struct/union sometimes, and event with pointers. * So accommodate cases like this doing a structural * comparison recursively, but avoiding being stuck in endless * loops by limiting the depth up to which we check.
*/ if (btf_dedup_identical_types(d, hypot_type_id, cand_id, 16)) return 1; return 0;
}
if (btf_dedup_hypot_map_add(d, canon_id, cand_id)) return -ENOMEM;
if (cand_kind == BTF_KIND_FWD) {
real_kind = canon_kind;
fwd_kind = btf_fwd_kind(cand_type);
} else {
real_kind = cand_kind;
fwd_kind = btf_fwd_kind(canon_type); /* we'd need to resolve base FWD to STRUCT/UNION */ if (fwd_kind == real_kind && canon_id < d->btf->start_id)
d->hypot_adjust_canon = true;
} return fwd_kind == real_kind;
}
if (cand_kind != canon_kind) return 0;
switch (cand_kind) { case BTF_KIND_INT: return btf_equal_int_tag(cand_type, canon_type);
case BTF_KIND_ENUM: case BTF_KIND_ENUM64: return btf_compat_enum(cand_type, canon_type);
case BTF_KIND_FWD: case BTF_KIND_FLOAT: return btf_equal_common(cand_type, canon_type);
case BTF_KIND_CONST: case BTF_KIND_VOLATILE: case BTF_KIND_RESTRICT: case BTF_KIND_PTR: case BTF_KIND_TYPEDEF: case BTF_KIND_FUNC: case BTF_KIND_TYPE_TAG: if (cand_type->info != canon_type->info) return 0; return btf_dedup_is_equiv(d, cand_type->type, canon_type->type);
case BTF_KIND_ARRAY: { conststruct btf_array *cand_arr, *canon_arr;
case BTF_KIND_STRUCT: case BTF_KIND_UNION: { conststruct btf_member *cand_m, *canon_m;
__u16 vlen;
if (!btf_shallow_equal_struct(cand_type, canon_type)) return 0;
vlen = btf_vlen(cand_type);
cand_m = btf_members(cand_type);
canon_m = btf_members(canon_type); for (i = 0; i < vlen; i++) {
eq = btf_dedup_is_equiv(d, cand_m->type, canon_m->type); if (eq <= 0) return eq;
cand_m++;
canon_m++;
}
return 1;
}
case BTF_KIND_FUNC_PROTO: { conststruct btf_param *cand_p, *canon_p;
__u16 vlen;
if (!btf_compat_fnproto(cand_type, canon_type)) return 0;
eq = btf_dedup_is_equiv(d, cand_type->type, canon_type->type); if (eq <= 0) return eq;
vlen = btf_vlen(cand_type);
cand_p = btf_params(cand_type);
canon_p = btf_params(canon_type); for (i = 0; i < vlen; i++) {
eq = btf_dedup_is_equiv(d, cand_p->type, canon_p->type); if (eq <= 0) return eq;
cand_p++;
canon_p++;
} return 1;
}
default: return -EINVAL;
} return 0;
}
/* * Use hypothetical mapping, produced by successful type graph equivalence * check, to augment existing struct/union canonical mapping, where possible. * * If BTF_KIND_FWD resolution is allowed, this mapping is also used to record * FWD -> STRUCT/UNION correspondence as well. FWD resolution is bidirectional: * it doesn't matter if FWD type was part of canonical graph or candidate one, * we are recording the mapping anyway. As opposed to carefulness required * for struct/union correspondence mapping (described below), for FWD resolution * it's not important, as by the time that FWD type (reference type) will be * deduplicated all structs/unions will be deduped already anyway. * * Recording STRUCT/UNION mapping is purely a performance optimization and is * not required for correctness. It needs to be done carefully to ensure that * struct/union from candidate's type graph is not mapped into corresponding * struct/union from canonical type graph that itself hasn't been resolved into * canonical representative. The only guarantee we have is that canonical * struct/union was determined as canonical and that won't change. But any * types referenced through that struct/union fields could have been not yet * resolved, so in case like that it's too early to establish any kind of * correspondence between structs/unions. * * No canonical correspondence is derived for primitive types (they are already * deduplicated completely already anyway) or reference types (they rely on * stability of struct/union canonical relationship for equivalence checks).
*/ staticvoid btf_dedup_merge_hypot_map(struct btf_dedup *d)
{
__u32 canon_type_id, targ_type_id;
__u16 t_kind, c_kind;
__u32 t_id, c_id; int i;
for (i = 0; i < d->hypot_cnt; i++) {
canon_type_id = d->hypot_list[i];
targ_type_id = d->hypot_map[canon_type_id];
t_id = resolve_type_id(d, targ_type_id);
c_id = resolve_type_id(d, canon_type_id);
t_kind = btf_kind(btf__type_by_id(d->btf, t_id));
c_kind = btf_kind(btf__type_by_id(d->btf, c_id)); /* * Resolve FWD into STRUCT/UNION. * It's ok to resolve FWD into STRUCT/UNION that's not yet * mapped to canonical representative (as opposed to * STRUCT/UNION <--> STRUCT/UNION mapping logic below), because * eventually that struct is going to be mapped and all resolved * FWDs will automatically resolve to correct canonical * representative. This will happen before ref type deduping, * which critically depends on stability of these mapping. This * stability is not a requirement for STRUCT/UNION equivalence * checks, though.
*/
/* if it's the split BTF case, we still need to point base FWD * to STRUCT/UNION in a split BTF, because FWDs from split BTF * will be resolved against base FWD. If we don't point base * canonical FWD to the resolved STRUCT/UNION, then all the * FWDs in split BTF won't be correctly resolved to a proper * STRUCT/UNION.
*/ if (t_kind != BTF_KIND_FWD && c_kind == BTF_KIND_FWD)
d->map[c_id] = t_id;
/* if graph equivalence determined that we'd need to adjust * base canonical types, then we need to only point base FWDs * to STRUCTs/UNIONs and do no more modifications. For all * other purposes the type graphs were not equivalent.
*/ if (d->hypot_adjust_canon) continue;
if ((t_kind == BTF_KIND_STRUCT || t_kind == BTF_KIND_UNION) &&
c_kind != BTF_KIND_FWD &&
is_type_mapped(d, c_id) &&
!is_type_mapped(d, t_id)) { /* * as a perf optimization, we can map struct/union * that's part of type graph we just verified for * equivalence. We can do that for struct/union that has * canonical representative only, though.
*/
d->map[t_id] = c_id;
}
}
}
/* * Deduplicate struct/union types. * * For each struct/union type its type signature hash is calculated, taking * into account type's name, size, number, order and names of fields, but * ignoring type ID's referenced from fields, because they might not be deduped * completely until after reference types deduplication phase. This type hash * is used to iterate over all potential canonical types, sharing same hash. * For each canonical candidate we check whether type graphs that they form * (through referenced types in fields and so on) are equivalent using algorithm * implemented in `btf_dedup_is_equiv`. If such equivalence is found and * BTF_KIND_FWD resolution is allowed, then hypothetical mapping * (btf_dedup->hypot_map) produced by aforementioned type graph equivalence * algorithm is used to record FWD -> STRUCT/UNION mapping. It's also used to * potentially map other structs/unions to their canonical representatives, * if such relationship hasn't yet been established. This speeds up algorithm * by eliminating some of the duplicate work. * * If no matching canonical representative was found, struct/union is marked * as canonical for itself and is added into btf_dedup->dedup_table hash map * for further look ups.
*/ staticint btf_dedup_struct_type(struct btf_dedup *d, __u32 type_id)
{ struct btf_type *cand_type, *t; struct hashmap_entry *hash_entry; /* if we don't find equivalent type, then we are canonical */
__u32 new_id = type_id;
__u16 kind; long h;
/* already deduped or is in process of deduping (loop detected) */ if (d->map[type_id] <= BTF_MAX_NR_TYPES) return 0;
t = btf_type_by_id(d->btf, type_id);
kind = btf_kind(t);
if (kind != BTF_KIND_STRUCT && kind != BTF_KIND_UNION) return 0;
h = btf_hash_struct(t);
for_each_dedup_cand(d, hash_entry, h) {
__u32 cand_id = hash_entry->value; int eq;
/* * Even though btf_dedup_is_equiv() checks for * btf_shallow_equal_struct() internally when checking two * structs (unions) for equivalence, we need to guard here * from picking matching FWD type as a dedup candidate. * This can happen due to hash collision. In such case just * relying on btf_dedup_is_equiv() would lead to potentially * creating a loop (FWD -> STRUCT and STRUCT -> FWD), because * FWD and compatible STRUCT/UNION are considered equivalent.
*/
cand_type = btf_type_by_id(d->btf, cand_id); if (!btf_shallow_equal_struct(t, cand_type)) continue;
btf_dedup_clear_hypot_map(d);
eq = btf_dedup_is_equiv(d, type_id, cand_id); if (eq < 0) return eq; if (!eq) continue;
btf_dedup_merge_hypot_map(d); if (d->hypot_adjust_canon) /* not really equivalent */ continue;
new_id = cand_id; break;
}
staticint btf_dedup_struct_types(struct btf_dedup *d)
{ int i, err;
for (i = 0; i < d->btf->nr_types; i++) {
err = btf_dedup_struct_type(d, d->btf->start_id + i); if (err) return err;
} return 0;
}
/* * Deduplicate reference type. * * Once all primitive and struct/union types got deduplicated, we can easily * deduplicate all other (reference) BTF types. This is done in two steps: * * 1. Resolve all referenced type IDs into their canonical type IDs. This * resolution can be done either immediately for primitive or struct/union types * (because they were deduped in previous two phases) or recursively for * reference types. Recursion will always terminate at either primitive or * struct/union type, at which point we can "unwind" chain of reference types * one by one. There is no danger of encountering cycles because in C type * system the only way to form type cycle is through struct/union, so any chain * of reference types, even those taking part in a type cycle, will inevitably * reach struct/union at some point. * * 2. Once all referenced type IDs are resolved into canonical ones, BTF type * becomes "stable", in the sense that no further deduplication will cause * any changes to it. With that, it's now possible to calculate type's signature * hash (this time taking into account referenced type IDs) and loop over all * potential canonical representatives. If no match was found, current type * will become canonical representative of itself and will be added into * btf_dedup->dedup_table as another possible canonical representative.
*/ staticint btf_dedup_ref_type(struct btf_dedup *d, __u32 type_id)
{ struct hashmap_entry *hash_entry;
__u32 new_id = type_id, cand_id; struct btf_type *t, *cand; /* if we don't find equivalent type, then we are representative type */ int ref_type_id; long h;
if (d->map[type_id] == BTF_IN_PROGRESS_ID) return -ELOOP; if (d->map[type_id] <= BTF_MAX_NR_TYPES) return resolve_type_id(d, type_id);
t = btf_type_by_id(d->btf, type_id);
d->map[type_id] = BTF_IN_PROGRESS_ID;
switch (btf_kind(t)) { case BTF_KIND_CONST: case BTF_KIND_VOLATILE: case BTF_KIND_RESTRICT: case BTF_KIND_PTR: case BTF_KIND_TYPEDEF: case BTF_KIND_FUNC: case BTF_KIND_TYPE_TAG:
ref_type_id = btf_dedup_ref_type(d, t->type); if (ref_type_id < 0) return ref_type_id;
t->type = ref_type_id;
staticint btf_dedup_ref_types(struct btf_dedup *d)
{ int i, err;
for (i = 0; i < d->btf->nr_types; i++) {
err = btf_dedup_ref_type(d, d->btf->start_id + i); if (err < 0) return err;
} /* we won't need d->dedup_table anymore */
hashmap__free(d->dedup_table);
d->dedup_table = NULL; return 0;
}
/* * Collect a map from type names to type ids for all canonical structs * and unions. If the same name is shared by several canonical types * use a special value 0 to indicate this fact.
*/ staticint btf_dedup_fill_unique_names_map(struct btf_dedup *d, struct hashmap *names_map)
{
__u32 nr_types = btf__type_cnt(d->btf); struct btf_type *t;
__u32 type_id;
__u16 kind; int err;
/* * Iterate over base and split module ids in order to get all * available structs in the map.
*/ for (type_id = 1; type_id < nr_types; ++type_id) {
t = btf_type_by_id(d->btf, type_id);
kind = btf_kind(t);
if (kind != BTF_KIND_STRUCT && kind != BTF_KIND_UNION) continue;
/* Skip non-canonical types */ if (type_id != d->map[type_id]) continue;
/* * Resolve unambiguous forward declarations. * * The lion's share of all FWD declarations is resolved during * `btf_dedup_struct_types` phase when different type graphs are * compared against each other. However, if in some compilation unit a * FWD declaration is not a part of a type graph compared against * another type graph that declaration's canonical type would not be * changed. Example: * * CU #1: * * struct foo; * struct foo *some_global; * * CU #2: * * struct foo { int u; }; * struct foo *another_global; * * After `btf_dedup_struct_types` the BTF looks as follows: * * [1] STRUCT 'foo' size=4 vlen=1 ... * [2] INT 'int' size=4 ... * [3] PTR '(anon)' type_id=1 * [4] FWD 'foo' fwd_kind=struct * [5] PTR '(anon)' type_id=4 * * This pass assumes that such FWD declarations should be mapped to * structs or unions with identical name in case if the name is not * ambiguous.
*/ staticint btf_dedup_resolve_fwds(struct btf_dedup *d)
{ int i, err; struct hashmap *names_map;
names_map = hashmap__new(btf_dedup_identity_hash_fn, btf_dedup_equal_fn, NULL); if (IS_ERR(names_map)) return PTR_ERR(names_map);
err = btf_dedup_fill_unique_names_map(d, names_map); if (err < 0) gotoexit;
for (i = 0; i < d->btf->nr_types; i++) {
err = btf_dedup_resolve_fwd(d, names_map, d->btf->start_id + i); if (err < 0) break;
}
exit:
hashmap__free(names_map); return err;
}
/* * Compact types. * * After we established for each type its corresponding canonical representative * type, we now can eliminate types that are not canonical and leave only * canonical ones layed out sequentially in memory by copying them over * duplicates. During compaction btf_dedup->hypot_map array is reused to store * a map from original type ID to a new compacted type ID, which will be used * during next phase to "fix up" type IDs, referenced from struct/union and * reference types.
*/ staticint btf_dedup_compact_types(struct btf_dedup *d)
{
__u32 *new_offs;
__u32 next_type_id = d->btf->start_id; conststruct btf_type *t; void *p; int i, id, len;
/* we are going to reuse hypot_map to store compaction remapping */
d->hypot_map[0] = 0; /* base BTF types are not renumbered */ for (id = 1; id < d->btf->start_id; id++)
d->hypot_map[id] = id; for (i = 0, id = d->btf->start_id; i < d->btf->nr_types; i++, id++)
d->hypot_map[id] = BTF_UNPROCESSED_ID;
p = d->btf->types_data;
for (i = 0, id = d->btf->start_id; i < d->btf->nr_types; i++, id++) { if (d->map[id] != id) continue;
t = btf__type_by_id(d->btf, id);
len = btf_type_size(t); if (len < 0) return len;
memmove(p, t, len);
d->hypot_map[id] = next_type_id;
d->btf->type_offs[next_type_id - d->btf->start_id] = p - d->btf->types_data;
p += len;
next_type_id++;
}
/* * Figure out final (deduplicated and compacted) type ID for provided original * `type_id` by first resolving it into corresponding canonical type ID and * then mapping it to a deduplicated type ID, stored in btf_dedup->hypot_map, * which is populated during compaction phase.
*/ staticint btf_dedup_remap_type_id(__u32 *type_id, void *ctx)
{ struct btf_dedup *d = ctx;
__u32 resolved_type_id, new_type_id;
/* * Remap referenced type IDs into deduped type IDs. * * After BTF types are deduplicated and compacted, their final type IDs may * differ from original ones. The map from original to a corresponding * deduped type ID is stored in btf_dedup->hypot_map and is populated during * compaction phase. During remapping phase we are rewriting all type IDs * referenced from any BTF type (e.g., struct fields, func proto args, etc) to * their final deduped type IDs.
*/ staticint btf_dedup_remap_types(struct btf_dedup *d)
{ int i, r;
for (i = 0; i < d->btf->nr_types; i++) { struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i); struct btf_field_iter it;
__u32 *type_id;
r = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS); if (r) return r;
while ((type_id = btf_field_iter_next(&it))) {
__u32 resolved_id, new_id;
r = btf_ext_visit_type_ids(d->btf_ext, btf_dedup_remap_type_id, d); if (r) return r;
return 0;
}
/* * Probe few well-known locations for vmlinux kernel image and try to load BTF * data out of it to use for target BTF.
*/ struct btf *btf__load_vmlinux_btf(void)
{ constchar *sysfs_btf_path = "/sys/kernel/btf/vmlinux"; /* fall back locations, trying to find vmlinux on disk */ constchar *locations[] = { "/boot/vmlinux-%1$s", "/lib/modules/%1$s/vmlinux-%1$s", "/lib/modules/%1$s/build/vmlinux", "/usr/lib/modules/%1$s/kernel/vmlinux", "/usr/lib/debug/boot/vmlinux-%1$s", "/usr/lib/debug/boot/vmlinux-%1$s.debug", "/usr/lib/debug/lib/modules/%1$s/vmlinux",
}; char path[PATH_MAX + 1]; struct utsname buf; struct btf *btf; int i, err;
/* is canonical sysfs location accessible? */ if (faccessat(AT_FDCWD, sysfs_btf_path, F_OK, AT_EACCESS) < 0) {
pr_warn("kernel BTF is missing at '%s', was CONFIG_DEBUG_INFO_BTF enabled?\n",
sysfs_btf_path);
} else {
btf = btf_parse_raw_mmap(sysfs_btf_path, NULL); if (IS_ERR(btf))
btf = btf__parse(sysfs_btf_path, NULL);
if (!btf) {
err = -errno;
pr_warn("failed to read kernel BTF from '%s': %s\n",
sysfs_btf_path, errstr(err)); return libbpf_err_ptr(err);
}
pr_debug("loaded kernel BTF from '%s'\n", sysfs_btf_path); return btf;
}
/* try fallback locations */
uname(&buf); for (i = 0; i < ARRAY_SIZE(locations); i++) {
snprintf(path, PATH_MAX, locations[i], buf.release);
if (faccessat(AT_FDCWD, path, R_OK, AT_EACCESS)) continue;
err = btf_field_iter_init(&it, split_t, BTF_FIELD_ITER_IDS); if (err) return err; while ((id = btf_field_iter_next(&it))) { struct btf_type *base_t;
if (!*id) continue; /* split BTF id, not needed */ if (*id >= dist->split_start_id) continue; /* already added ? */ if (dist->id_map[*id] > 0) continue;
/* only a subset of base BTF types should be referenced from * split BTF; ensure nothing unexpected is referenced.
*/
base_t = btf_type_by_id(dist->pipe.src, *id); switch (btf_kind(base_t)) { case BTF_KIND_INT: case BTF_KIND_FLOAT: case BTF_KIND_FWD: case BTF_KIND_ARRAY: case BTF_KIND_STRUCT: case BTF_KIND_UNION: case BTF_KIND_TYPEDEF: case BTF_KIND_ENUM: case BTF_KIND_ENUM64: case BTF_KIND_PTR: case BTF_KIND_CONST: case BTF_KIND_RESTRICT: case BTF_KIND_VOLATILE: case BTF_KIND_FUNC_PROTO: case BTF_KIND_TYPE_TAG:
dist->id_map[*id] = *id; break; default:
pr_warn("unexpected reference to base type[%u] of kind [%u] when creating distilled base BTF.\n",
*id, btf_kind(base_t)); return -EINVAL;
} /* If a base type is used, ensure types it refers to are * marked as used also; so for example if we find a PTR to INT * we need both the PTR and INT. * * The only exception is named struct/unions, since distilled * base BTF composite types have no members.
*/ if (btf_is_composite(base_t) && base_t->name_off) continue;
err = btf_add_distilled_type_ids(dist, *id); if (err) return err;
} return 0;
}
staticint btf_add_distilled_types(struct btf_distill *dist)
{ bool adding_to_base = dist->pipe.dst->start_id == 1; int id = btf__type_cnt(dist->pipe.dst); struct btf_type *t; int i, err = 0;
/* Add types for each of the required references to either distilled * base or split BTF, depending on type characteristics.
*/ for (i = 1; i < dist->split_start_id; i++) { constchar *name; int kind;
if (!dist->id_map[i]) continue;
t = btf_type_by_id(dist->pipe.src, i);
kind = btf_kind(t);
name = btf__name_by_offset(dist->pipe.src, t->name_off);
switch (kind) { case BTF_KIND_INT: case BTF_KIND_FLOAT: case BTF_KIND_FWD: /* Named int, float, fwd are added to base. */ if (!adding_to_base) continue;
err = btf_add_type(&dist->pipe, t); break; case BTF_KIND_STRUCT: case BTF_KIND_UNION: /* Named struct/union are added to base as 0-vlen * struct/union of same size. Anonymous struct/unions * are added to split BTF as-is.
*/ if (adding_to_base) { if (!t->name_off) continue;
err = btf_add_composite(dist->pipe.dst, kind, name, t->size);
} else { if (t->name_off) continue;
err = btf_add_type(&dist->pipe, t);
} break; case BTF_KIND_ENUM: case BTF_KIND_ENUM64: /* Named enum[64]s are added to base as a sized * enum; relocation will match with appropriately-named * and sized enum or enum64. * * Anonymous enums are added to split BTF as-is.
*/ if (adding_to_base) { if (!t->name_off) continue;
err = btf__add_enum(dist->pipe.dst, name, t->size);
} else { if (t->name_off) continue;
err = btf_add_type(&dist->pipe, t);
} break; case BTF_KIND_ARRAY: case BTF_KIND_TYPEDEF: case BTF_KIND_PTR: case BTF_KIND_CONST: case BTF_KIND_RESTRICT: case BTF_KIND_VOLATILE: case BTF_KIND_FUNC_PROTO: case BTF_KIND_TYPE_TAG: /* All other types are added to split BTF. */ if (adding_to_base) continue;
err = btf_add_type(&dist->pipe, t); break; default:
pr_warn("unexpected kind when adding base type '%s'[%u] of kind [%u] to distilled base BTF.\n",
name, i, kind); return -EINVAL;
/* Split BTF ids without a mapping will be shifted downwards since distilled * base BTF is smaller than the original base BTF. For those that have a * mapping (either to base or updated split BTF), update the id based on * that mapping.
*/ staticint btf_update_distilled_type_ids(struct btf_distill *dist, __u32 i)
{ struct btf_type *t = btf_type_by_id(dist->pipe.dst, i); struct btf_field_iter it;
__u32 *id; int err;
err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS); if (err) return err; while ((id = btf_field_iter_next(&it))) { if (dist->id_map[*id])
*id = dist->id_map[*id]; elseif (*id >= dist->split_start_id)
*id -= dist->diff_id;
} return 0;
}
/* Create updated split BTF with distilled base BTF; distilled base BTF * consists of BTF information required to clarify the types that split * BTF refers to, omitting unneeded details. Specifically it will contain * base types and memberless definitions of named structs, unions and enumerated * types. Associated reference types like pointers, arrays and anonymous * structs, unions and enumerated types will be added to split BTF. * Size is recorded for named struct/unions to help guide matching to the * target base BTF during later relocation. * * The only case where structs, unions or enumerated types are fully represented * is when they are anonymous; in such cases, the anonymous type is added to * split BTF in full. * * We return newly-created split BTF where the split BTF refers to a newly-created * distilled base BTF. Both must be freed separately by the caller.
*/ int btf__distill_base(conststruct btf *src_btf, struct btf **new_base_btf, struct btf **new_split_btf)
{ struct btf *new_base = NULL, *new_split = NULL; conststruct btf *old_base; unsignedint n = btf__type_cnt(src_btf); struct btf_distill dist = {}; struct btf_type *t; int i, err = 0;
/* src BTF must be split BTF. */
old_base = btf__base_btf(src_btf); if (!new_base_btf || !new_split_btf || !old_base) return libbpf_err(-EINVAL);
new_base = btf__new_empty(); if (!new_base) return libbpf_err(-ENOMEM);
/* Pass over src split BTF; generate the list of base BTF type ids it * references; these will constitute our distilled BTF set to be * distributed over base and split BTF as appropriate.
*/ for (i = src_btf->start_id; i < n; i++) {
err = btf_add_distilled_type_ids(&dist, i); if (err < 0) goto done;
} /* Next add types for each of the required references to base BTF and split BTF * in turn.
*/
err = btf_add_distilled_types(&dist); if (err < 0) goto done;
/* Create new split BTF with distilled base BTF as its base; the final * state is split BTF with distilled base BTF that represents enough * about its base references to allow it to be relocated with the base * BTF available.
*/
new_split = btf__new_empty_split(new_base); if (!new_split) {
err = -errno; goto done;
}
dist.pipe.dst = new_split; /* First add all split types */ for (i = src_btf->start_id; i < n; i++) {
t = btf_type_by_id(src_btf, i);
err = btf_add_type(&dist.pipe, t); if (err < 0) goto done;
} /* Now add distilled types to split BTF that are not added to base. */
err = btf_add_distilled_types(&dist); if (err < 0) goto done;
/* All split BTF ids will be shifted downwards since there are less base * BTF ids in distilled base BTF.
*/
dist.diff_id = dist.split_start_id - btf__type_cnt(new_base);
n = btf__type_cnt(new_split); /* Now update base/split BTF ids. */ for (i = 1; i < n; i++) {
err = btf_update_distilled_type_ids(&dist, i); if (err < 0) break;
}
done:
free(dist.id_map);
hashmap__free(dist.pipe.str_off_map); if (err) {
btf__free(new_split);
btf__free(new_base); return libbpf_err(err);
}
*new_base_btf = new_base;
*new_split_btf = new_split;
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
