On 29/01/2024 01:30, Daniel Xu wrote:
> This commit teaches pahole to parse symbols in .BTF_ids section in
> vmlinux and discover exported kfuncs. Pahole then takes the list of
> kfuncs and injects a BTF_KIND_DECL_TAG for each kfunc.
>
> Example of encoding:
>
> $ bpftool btf dump file .tmp_vmlinux.btf | rg "DECL_TAG 'bpf_kfunc'" | wc -l
> 121
>
> $ bpftool btf dump file .tmp_vmlinux.btf | rg 56337
> [56337] FUNC 'bpf_ct_change_timeout' type_id=56336 linkage=static
> [127861] DECL_TAG 'bpf_kfunc' type_id=56337 component_idx=-1
>
> This enables downstream users and tools to dynamically discover which
> kfuncs are available on a system by parsing vmlinux or module BTF, both
> available in /sys/kernel/btf.
>
> Signed-off-by: Daniel Xu <dxu@xxxxxxxxx>
>
This should probably be a BTF feature supported by --btf_features; that
way we'd have a mechanism to switch it off if needed. Can you look at
adding a "tag_kfunc" or whatever name suits into the btf_features[]
array in pahole.c? Something like:
BTF_FEATURE(tag_kfunc, btf_tag_kfunc, false),
You'll also then need to add a btf_tag_kfunc boolean field to
struct conf_load, and generation of kfunc tags should then be guarded by
if (conf_load->btf_tag_kfunc)
...so that the tags are added conditionally depending on whether
the user wants them.
Then if a user specifies --btf_features=all or some subset of BTF
features including "tag_kfunc" they will get kfunc tags.
We probably should also move to using --btf_features instead of the
current combination of "--" parameters when pahole is bumped to v1.26.
> ---
> Changes from v2:
> * More reliably detect kfunc membership in set8 by tracking set addr ranges
> * Rename some variables/functions to be more clear about kfunc vs func
>
> Changes from v1:
> * Fix resource leaks
> * Fix callee -> caller typo
> * Rename btf_decl_tag from kfunc -> bpf_kfunc
> * Only grab btf_id_set funcs tagged kfunc
> * Presort btf func list
>
> btf_encoder.c | 347 ++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 347 insertions(+)rre
>
> diff --git a/btf_encoder.c b/btf_encoder.c
> index fd04008..4f742b1 100644
> --- a/btf_encoder.c
> +++ b/btf_encoder.c
> @@ -34,6 +34,11 @@
> #include <pthread.h>
>
> #define BTF_ENCODER_MAX_PROTO 512
> +#define BTF_IDS_SECTION ".BTF_ids"
> +#define BTF_ID_FUNC_PFX "__BTF_ID__func__"
> +#define BTF_ID_SET8_PFX "__BTF_ID__set8__"
> +#define BTF_SET8_KFUNCS (1 << 0)
> +#define BTF_KFUNC_TYPE_TAG "bpf_kfunc"
>
> /* state used to do later encoding of saved functions */
> struct btf_encoder_state {
> @@ -79,6 +84,7 @@ struct btf_encoder {
> gen_floats,
> is_rel;
> uint32_t array_index_id;
> + struct gobuffer btf_funcs;
> struct {
> struct var_info vars[MAX_PERCPU_VAR_CNT];
> int var_cnt;
> @@ -94,6 +100,17 @@ struct btf_encoder {
> } functions;
> };
>
> +struct btf_func {
> + const char *name;
> + int type_id;
> +};
> +
> +/* Half open interval representing range of addresses containing kfuncs */
> +struct btf_kfunc_set_range {
> + size_t start;
> + size_t end;
> +};
> +
> static LIST_HEAD(encoders);
> static pthread_mutex_t encoders__lock = PTHREAD_MUTEX_INITIALIZER;
>
> @@ -1352,6 +1369,327 @@ out:
> return err;
> }
>
> +/* Returns if `sym` points to a kfunc set */
> +static int is_sym_kfunc_set(GElf_Sym *sym, const char *name, Elf_Data *idlist, size_t idlist_addr)
> +{
> + int *ptr = idlist->d_buf;
> + int idx, flags;
> + bool is_set8;
> +
> + /* kfuncs are only found in BTF_SET8's */
> + is_set8 = !strncmp(name, BTF_ID_SET8_PFX, sizeof(BTF_ID_SET8_PFX) - 1);
> + if (!is_set8)
> + return false;
> +
> + idx = sym->st_value - idlist_addr;
> + if (idx >= idlist->d_size) {
> + fprintf(stderr, "%s: symbol '%s' out of bounds\n", __func__, name);
> + return false;
> + }
> +
> + /* Check the set8 flags to see if it was marked as kfunc */
> + idx = idx / sizeof(int);
> + flags = ptr[idx + 1];
> + return flags & BTF_SET8_KFUNCS;
> +}
> +
> +/*
> + * Parse BTF_ID symbol and return the func name.
> + *
> + * Returns:
> + * Caller-owned string containing func name if successful.
> + * NULL if !func or on error.
> + */
> +static char *get_func_name(const char *sym)
> +{
> + char *func, *end;
> +
> + if (strncmp(sym, BTF_ID_FUNC_PFX, sizeof(BTF_ID_FUNC_PFX) - 1))
> + return NULL;
> +
> + /* Strip prefix */
> + func = strdup(sym + sizeof(BTF_ID_FUNC_PFX) - 1);
> +
> + /* Strip suffix */
> + end = strrchr(func, '_');
> + if (!end || *(end - 1) != '_') {
> + free(func);
> + return NULL;
> + }
> + *(end - 1) = '\0';
> +
> + return func;
> +}
> +
> +static int btf_func_cmp(const void *_a, const void *_b)
> +{
> + const struct btf_func *a = _a;
> + const struct btf_func *b = _b;
> +
> + return strcmp(a->name, b->name);
> +}
> +
> +/*
> + * Collects all functions described in BTF.
> + * Returns non-zero on error.
> + */
> +static int btf_encoder__collect_btf_funcs(struct btf_encoder *encoder)
> +{
> + struct gobuffer *funcs = &encoder->btf_funcs;
> + struct btf *btf = encoder->btf;
> + int nr_types, type_id;
> + int err = -1;
> +
> + /* First collect all the func entries into an array */
> + nr_types = btf__type_cnt(btf);
> + for (type_id = 1; type_id < nr_types; type_id++) {
> + const struct btf_type *type;
> + struct btf_func func = {};
> + const char *name;
> +
> + type = btf__type_by_id(btf, type_id);
> + if (!type) {
> + fprintf(stderr, "%s: malformed BTF, can't resolve type for ID %d\n",
> + __func__, type_id);
> + err = -EINVAL;
> + goto out;
> + }
> +
> + if (!btf_is_func(type))
> + continue;
> +
> + name = btf__name_by_offset(btf, type->name_off);
> + if (!name) {
> + fprintf(stderr, "%s: malformed BTF, can't resolve name for ID %d\n",
> + __func__, type_id);
> + err = -EINVAL;
> + goto out;
> + }
> +
> + func.name = name;
> + func.type_id = type_id;
> + err = gobuffer__add(funcs, &func, sizeof(func));
> + if (err < 0)
> + goto out;
> + }
> +
> + /* Now that we've collected funcs, sort them by name */
> + qsort((void *)gobuffer__entries(funcs), gobuffer__nr_entries(funcs),
> + sizeof(struct btf_func), btf_func_cmp);
> +
> + err = 0;
> +out:
> + return err;
> +}
> +
> +static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, const char *kfunc)
> +{
> + struct btf_func key = { .name = kfunc };
> + struct btf *btf = encoder->btf;
> + struct btf_func *target;
> + const void *base;
> + unsigned int cnt;
> + int err = -1;
> +
> + base = gobuffer__entries(&encoder->btf_funcs);
> + cnt = gobuffer__nr_entries(&encoder->btf_funcs);
> + target = bsearch(&key, base, cnt, sizeof(key), btf_func_cmp);
> + if (!target) {
> + fprintf(stderr, "%s: failed to find kfunc '%s' in BTF\n", __func__, kfunc);
> + goto out;
> + }
> +
> + /* Note we are unconditionally adding the btf_decl_tag even
> + * though vmlinux may already contain btf_decl_tags for kfuncs.
> + * We are ok to do this b/c we will later btf__dedup() to remove
> + * any duplicates.
> + */
> + err = btf__add_decl_tag(btf, BTF_KFUNC_TYPE_TAG, target->type_id, -1);
> + if (err < 0) {
> + fprintf(stderr, "%s: failed to insert kfunc decl tag for '%s': %d\n",
> + __func__, kfunc, err);
> + goto out;
> + }
> +
> + err = 0;
> +out:
> + return err;
> +}
> +
> +static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder)
> +{
> + const char *filename = encoder->filename;
> + struct gobuffer btf_kfunc_ranges = {};
> + Elf_Scn *symscn = NULL;
> + int symbols_shndx = -1;
> + int fd = -1, err = -1;
> + int idlist_shndx = -1;
> + Elf_Scn *scn = NULL;
> + size_t idlist_addr;
> + Elf_Data *symbols;
> + Elf_Data *idlist;
> + size_t strtabidx;
> + Elf *elf = NULL;
> + GElf_Shdr shdr;
> + size_t strndx;
> + char *secname;
> + int nr_syms;
> + int i = 0;
> +
> + fd = open(filename, O_RDONLY);
> + if (fd < 0) {
> + fprintf(stderr, "Cannot open %s\n", filename);
> + goto out;
> + }
> +
> + if (elf_version(EV_CURRENT) == EV_NONE) {
> + elf_error("Cannot set libelf version");
> + goto out;
> + }
> +
> + elf = elf_begin(fd, ELF_C_READ, NULL);
> + if (elf == NULL) {
> + elf_error("Cannot update ELF file");
> + goto out;
> + }
> +
> + /* Location symbol table and .BTF_ids sections */
> + elf_getshdrstrndx(elf, &strndx);
> + while ((scn = elf_nextscn(elf, scn)) != NULL) {
> + Elf_Data *data;
> +
> + i++;
> + if (!gelf_getshdr(scn, &shdr)) {
> + elf_error("Failed to get ELF section(%d) hdr", i);
> + goto out;
> + }
> +
> + secname = elf_strptr(elf, strndx, shdr.sh_name);
> + if (!secname) {
> + elf_error("Failed to get ELF section(%d) hdr name", i);
> + goto out;
> + }
> +
> + data = elf_getdata(scn, 0);
> + if (!data) {
> + elf_error("Failed to get ELF section(%d) data", i);
> + goto out;
> + }
> +
> + if (shdr.sh_type == SHT_SYMTAB) {
> + symbols_shndx = i;
> + symscn = scn;
> + symbols = data;
> + strtabidx = shdr.sh_link;
> + } else if (!strcmp(secname, BTF_IDS_SECTION)) {
> + idlist_shndx = i;
> + idlist_addr = shdr.sh_addr;
> + idlist = data;
> + }
> + }
> +
> + /* Cannot resolve symbol or .BTF_ids sections. Nothing to do. */
> + if (symbols_shndx == -1 || idlist_shndx == -1) {
> + err = 0;
> + goto out;
> + }
> +
> + if (!gelf_getshdr(symscn, &shdr)) {
> + elf_error("Failed to get ELF symbol table header");
> + goto out;
> + }
> + nr_syms = shdr.sh_size / shdr.sh_entsize;
> +
> + err = btf_encoder__collect_btf_funcs(encoder);
> + if (err) {
> + fprintf(stderr, "%s: failed to collect BTF funcs\n", __func__);
> + goto out;
> + }
> +
> + /* First collect all kfunc set ranges.
> + *
> + * Note we choose not to sort these ranges and accept a linear
> + * search when doing lookups. Reasoning is that the number of
> + * sets is ~O(100) and not worth the additional code to optimize.
> + */
> + for (i = 0; i < nr_syms; i++) {
> + struct btf_kfunc_set_range range = {};
> + const char *name;
> + GElf_Sym sym;
> +
> + if (!gelf_getsym(symbols, i, &sym)) {
> + elf_error("Failed to get ELF symbol(%d)", i);
> + goto out;
> + }
> +
> + if (sym.st_shndx != idlist_shndx)
> + continue;
> +
> + name = elf_strptr(elf, strtabidx, sym.st_name);
> + if (!is_sym_kfunc_set(&sym, name, idlist, idlist_addr))
> + continue;
> +
> + range.start = sym.st_value;
> + range.end = sym.st_value + sym.st_size;
> + gobuffer__add(&btf_kfunc_ranges, &range, sizeof(range));
> + }
> +
> + /* Now inject BTF with kfunc decl tag for detected kfuncs */
> + for (i = 0; i < nr_syms; i++) {
> + const struct btf_kfunc_set_range *ranges;
> + unsigned int ranges_cnt;
> + char *func, *name;
> + GElf_Sym sym;
> + bool found;
> + int err;
> + int j;
> +
> + if (!gelf_getsym(symbols, i, &sym)) {
> + elf_error("Failed to get ELF symbol(%d)", i);
> + goto out;
> + }
> +
> + if (sym.st_shndx != idlist_shndx)
> + continue;
> +
> + name = elf_strptr(elf, strtabidx, sym.st_name);
> + func = get_func_name(name);
> + if (!func)
> + continue;
> +
> + /* Check if function belongs to a kfunc set */
> + ranges = gobuffer__entries(&btf_kfunc_ranges);
> + ranges_cnt = gobuffer__nr_entries(&btf_kfunc_ranges);
> + found = false;
> + for (j = 0; j < ranges_cnt; j++) {
> + size_t addr = sym.st_value;
> + if (ranges[j].start <= addr && addr < ranges[j].end) {
> + found = true;
> + break;
> + }
> + }
> + if (!found)
> + continue;
> +
> + err = btf_encoder__tag_kfunc(encoder, func);
> + if (err) {
> + fprintf(stderr, "%s: failed to tag kfunc '%s'\n", __func__, func);
> + free(func);
> + goto out;
> + }
> + free(func);
> + }
> +
> + err = 0;
> +out:
> + __gobuffer__delete(&btf_kfunc_ranges);
> + if (elf)
> + elf_end(elf);
> + if (fd != -1)
> + close(fd);
> + return err;
> +}
> +
> int btf_encoder__encode(struct btf_encoder *encoder)
> {
> int err;
> @@ -1366,6 +1704,14 @@ int btf_encoder__encode(struct btf_encoder *encoder)
> if (btf__type_cnt(encoder->btf) == 1)
> return 0;
>
> + /* Note vmlinux may already contain btf_decl_tag's for kfuncs. So
> + * take care to call this before btf_dedup().
> + */
> + if (btf_encoder__tag_kfuncs(encoder)) {
> + fprintf(stderr, "%s: failed to tag kfuncs!\n", __func__);
> + return -1;
> + }
> +
> if (btf__dedup(encoder->btf, NULL)) {
> fprintf(stderr, "%s: btf__dedup failed!\n", __func__);
> return -1;
> @@ -1712,6 +2058,7 @@ void btf_encoder__delete(struct btf_encoder *encoder)
>
> btf_encoders__delete(encoder);
> __gobuffer__delete(&encoder->percpu_secinfo);
> + __gobuffer__delete(&encoder->btf_funcs);
> zfree(&encoder->filename);
> btf__free(encoder->btf);
> encoder->btf = NULL;
