[PATCH bpf-next v2 5/6] resolve_btfids: Reject ambiguous kfunc variants

From: Ihor Solodrai

Date: Fri Nov 20 2026 - 19:34:48 EST


libbpf fails to load a program if a kfunc declaration matches more
than one kfunc variant. For example, libbpf doesn't distinguish
integer widths, so a declaration of either of these matches both:

int bpf_foo(u32 flags);
int bpf_foo___v1(u64 flags);

Check the kfuncs registered in vmlinux or a module at build time, so
that such a pair fails the build instead. Group them by essential name
and compare prototypes with libbpf's matcher. Skip unregistered
functions, which libbpf also considers, so that code unrelated to
kfuncs can't fail the build. Variants split across modules or vmlinux
are also caught only by libbpf.

Signed-off-by: Ihor Solodrai <ihor.solodrai@xxxxxxxxx>
Acked-by: Eduard Zingerman <eddyz87@xxxxxxxxx>
---
tools/bpf/resolve_btfids/main.c | 69 +++++++++++++++++++++++++++++++++
1 file changed, 69 insertions(+)

diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/main.c
index 0e193c3c73aa..e21ac6843873 100644
--- a/tools/bpf/resolve_btfids/main.c
+++ b/tools/bpf/resolve_btfids/main.c
@@ -94,6 +94,7 @@
#include <bpf/btf.h>
#include <bpf/libbpf.h>
#include <bpf/libbpf_tools.h>
+#include <bpf/relo_core.h>
#include "btf_colors.h"
#include "fmodret.h"
#include <subcmd/parse-options.h>
@@ -1918,6 +1919,70 @@ static int sort_btf_by_name(struct btf *btf)
return err;
}

+struct kfunc_variant {
+ const char *name;
+ size_t essent_len;
+ u32 id;
+};
+
+static int cmp_kfunc_variants(const void *lhs, const void *rhs)
+{
+ const struct kfunc_variant *a = lhs, *b = rhs;
+ int ret = strncmp(a->name, b->name, min(a->essent_len, b->essent_len));
+
+ return ret ?: (a->essent_len > b->essent_len) - (a->essent_len < b->essent_len);
+}
+
+/* libbpf rejects a declaration that matches more than one kfunc variant */
+static int check_kfunc_variants(const struct btf *btf)
+{
+ const struct btf *base = btf__base_btf(btf);
+ struct kfunc_variant *kfuncs = NULL;
+ u32 cnt = 0, cap = 0;
+ int err = 0;
+
+ for (u32 id = base ? btf__type_cnt(base) : 1; id < btf__type_cnt(btf); id++) {
+ const struct btf_type *t = btf__type_by_id(btf, id);
+ const char *name;
+
+ if (!btf_is_decl_tag(t) || btf_decl_tag(t)->component_idx != -1)
+ continue;
+ if (strcmp(btf__name_by_offset(btf, t->name_off), DECL_TAG_KFUNC) != 0)
+ continue;
+
+ err = ensure_mem(&kfuncs, &cap, cnt + 1);
+ if (err)
+ goto out;
+ name = btf__name_by_offset(btf, btf__type_by_id(btf, t->type)->name_off);
+ kfuncs[cnt++] = (struct kfunc_variant){
+ .name = name,
+ .essent_len = bpf_core_essential_name_len(name),
+ .id = t->type,
+ };
+ }
+ qsort(kfuncs, cnt, sizeof(*kfuncs), cmp_kfunc_variants);
+
+ for (u32 i = 0; i < cnt; i++) {
+ const struct btf_type *a = btf__type_by_id(btf, kfuncs[i].id);
+
+ for (u32 j = i + 1; j < cnt; j++) {
+ const struct btf_type *b;
+
+ if (cmp_kfunc_variants(&kfuncs[i], &kfuncs[j]) != 0)
+ break;
+ b = btf__type_by_id(btf, kfuncs[j].id);
+ if (btf_kfunc_proto_match(btf, a->type, btf, b->type) <= 0)
+ continue;
+ pr_err("ERROR: resolve_btfids: kfuncs %s and %s have matching prototypes\n",
+ kfuncs[i].name, kfuncs[j].name);
+ err = -EINVAL;
+ }
+ }
+out:
+ free(kfuncs);
+ return err;
+}
+
static int finalize_btf(struct object *obj)
{
struct btf *base_btf = obj->base_btf, *btf = obj->btf;
@@ -1929,6 +1994,10 @@ static int finalize_btf(struct object *obj)
return err;
}

+ err = check_kfunc_variants(obj->btf);
+ if (err)
+ return err;
+
if (obj->base_btf && obj->distill_base) {
err = btf__distill_base(obj->btf, &base_btf, &btf);
if (err) {
--
2.56.1