BPF List
 help / color / mirror / Atom feed
From: Ihor Solodrai <ihor.solodrai@linux.dev>
To: Alexei Starovoitov <ast@kernel.org>,
	Andrii Nakryiko <andrii@kernel.org>,
	Daniel Borkmann <daniel@iogearbox.net>,
	Eduard Zingerman <eddyz87@gmail.com>,
	Kumar Kartikeya Dwivedi <memxor@gmail.com>
Cc: Alan Maguire <alan.maguire@oracle.com>,
	Emil Tsalapatis <emil@etsalapatis.com>,
	Jiri Olsa <jolsa@kernel.org>, Song Liu <song@kernel.org>,
	Tejun Heo <tj@kernel.org>,
	Yonghong Song <yonghong.song@linux.dev>,
	bpf@vger.kernel.org, linux-kernel@vger.kernel.org,
	sched-ext@lists.linux.dev
Subject: [PATCH bpf-next v2 3/6] libbpf: Resolve kfunc variants by prototype
Date: Fri, 20 Nov 2026 17:34:00 -0700	[thread overview]
Message-ID: <20261121003403.2928928-4-ihor.solodrai@linux.dev> (raw)
In-Reply-To: <20261121003403.2928928-1-ihor.solodrai@linux.dev>

libbpf resolves a kfunc declaration by exact name, after dropping its
last ___ suffix, and only then checks the prototype. The name alone
picks the kernel function, so the kernel can't serve both prototypes of
a changed kfunc. For example, vmlinux.h declares:

  bool scx_bpf_dsq_move_to_local(u64 dsq_id);
  bool scx_bpf_dsq_move_to_local___v2(u64 dsq_id, u64 enq_flags);

libbpf resolves the second to scx_bpf_dsq_move_to_local() and rejects
its prototype. Keeping the old prototype as ___v1 and giving the new
one the unsuffixed name would break old declarations the same way.

Select a kfunc in two steps instead:

  1. Collect the functions in vmlinux and module BTFs with the same
     essential name as the declaration, as CO-RE does for types. The
     "bpf_kfunc" decl tag is ignored.

  2. Resolve the candidate with a compatible prototype. If there is
     none, a __weak kfunc stays unresolved. More than one is an error,
     even for a __weak kfunc.

The prototype check is stricter than bpf_core_types_are_compat(). It
also compares the names of structs, unions and forward declarations,
ignoring ___ suffixes. Members aren't compared. Typedefs and qualifiers
are skipped. For example:

  typedef struct foo foo_t;

  void kfunc(struct foo *arg);
  void kfunc(struct foo___local *arg);
  void kfunc(foo_t *arg);

are compatible, but not with:

  void kfunc(struct bar *arg);

So a declaration with an outdated struct name no longer resolves. For
example, commit 8740156ad33b ("bpf: Require a BPF cpumask for
bpf_cpumask_populate()") changed:

  before: int bpf_cpumask_populate(struct cpumask *, void *, size_t);
  after:  int bpf_cpumask_populate(struct bpf_cpumask *, void *, size_t);

Each declaration now resolves only on a kernel with the same prototype.
A stacked suffix, as in foo___v2___compat, no longer resolves foo___v2,
because its essential name is foo___v2. compat.bpf.h now tries foo___v2
first.

Module BTFs are now loaded for every object with kfuncs: 0.5 and 1.4 ms
for 8 and 32 small modules in a VM. Lookup cost per kfunc:

                        before (hit / miss)   after
  sorted, 23 modules    0.14 / 0.65 us        0.8 us
  unsorted (v6.18)      0.1 / 0.5 ms          0.7 ms

Signed-off-by: Ihor Solodrai <ihor.solodrai@linux.dev>
---
 tools/lib/bpf/btf.c             |  99 ++++++++++++++++++++++++++-
 tools/lib/bpf/libbpf.c          | 117 ++++++++++++++++++++++----------
 tools/lib/bpf/libbpf_internal.h |   2 +
 tools/lib/bpf/libbpf_tools.h    |   2 +
 4 files changed, 182 insertions(+), 38 deletions(-)

diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
index a4bf01403a43..71cba0b9bbfe 100644
--- a/tools/lib/bpf/btf.c
+++ b/tools/lib/bpf/btf.c
@@ -1140,7 +1140,7 @@ static void btf_check_sorted(struct btf *btf)
 }
 
 static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const char *name,
-					   __s32 start_id)
+					   size_t name_len, __s32 start_id)
 {
 	const struct btf_type *t;
 	const char *tname;
@@ -1152,7 +1152,7 @@ static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const char *na
 		m = l + (r - l) / 2;
 		t = btf_type_by_id(btf, m);
 		tname = btf__str_by_offset(btf, t->name_off);
-		if (strcmp(tname, name) >= 0) {
+		if (strncmp(tname, name, name_len) >= 0) {
 			if (l == r)
 				return r;
 			r = m;
@@ -1164,6 +1164,99 @@ static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const char *na
 	return btf__type_cnt(btf);
 }
 
+/*
+ * Set [*start, *end) to the range of own type IDs that may match the
+ * first name_len bytes of name. For unsorted BTF, include all own type IDs.
+ */
+void btf_name_prefix_range(const struct btf *btf, const char *name, size_t name_len,
+			   __u32 *start, __u32 *end)
+{
+	__u32 i, n = btf__type_cnt(btf);
+
+	if (btf->named_start_id <= 0) {
+		*start = btf->start_id;
+		*end = n;
+		return;
+	}
+	*start = btf_find_type_by_name_bsearch(btf, name, name_len, btf->named_start_id);
+	for (i = *start; i < n; i++) {
+		const struct btf_type *t = btf_type_by_id(btf, i);
+		const char *tname = btf__str_by_offset(btf, t->name_off);
+
+		if (strncmp(tname, name, name_len) != 0)
+			break;
+	}
+	*end = i;
+}
+
+static __u16 kfunc_type_kind(const struct btf_type *t)
+{
+	if (btf_is_fwd(t))
+		return btf_kflag(t) ? BTF_KIND_UNION : BTF_KIND_STRUCT;
+	if (btf_is_enum64(t))
+		return BTF_KIND_ENUM;
+	return btf_kind(t);
+}
+
+/*
+ * Return 1 if the types match, 0 if they don't, or -EINVAL if a type
+ * can't be looked up or the types nest deeper than depth.
+ */
+static int kfunc_type_match(const struct btf *a, __u32 a_id,
+			    const struct btf *b, __u32 b_id, int depth)
+{
+	const struct btf_type *at = skip_mods_and_typedefs(a, a_id, NULL);
+	const struct btf_type *bt = skip_mods_and_typedefs(b, b_id, NULL);
+	__u16 kind;
+	int i, ret;
+
+	if (!at || !bt || !depth)
+		return -EINVAL;
+
+	kind = kfunc_type_kind(at);
+	if (kind != kfunc_type_kind(bt))
+		return 0;
+
+	switch (kind) {
+	case BTF_KIND_STRUCT:
+	case BTF_KIND_UNION: {
+		const char *an = btf__name_by_offset(a, at->name_off);
+		const char *bn = btf__name_by_offset(b, bt->name_off);
+		size_t name_len = bpf_core_essential_name_len(an);
+
+		return name_len == bpf_core_essential_name_len(bn) &&
+		       strncmp(an, bn, name_len) == 0;
+	}
+	case BTF_KIND_UNKN:
+	case BTF_KIND_ENUM:
+		return 1;
+	case BTF_KIND_INT:
+		return btf_int_offset(at) == 0 && btf_int_offset(bt) == 0;
+	case BTF_KIND_PTR:
+		return kfunc_type_match(a, at->type, b, bt->type, depth - 1);
+	case BTF_KIND_ARRAY:
+		return kfunc_type_match(a, btf_array(at)->type, b, btf_array(bt)->type, depth - 1);
+	case BTF_KIND_FUNC_PROTO:
+		if (btf_vlen(at) != btf_vlen(bt))
+			return 0;
+		for (i = 0; i < btf_vlen(at); i++) {
+			ret = kfunc_type_match(a, btf_params(at)[i].type,
+					       b, btf_params(bt)[i].type, depth - 1);
+			if (ret <= 0)
+				return ret;
+		}
+		return kfunc_type_match(a, at->type, b, bt->type, depth - 1);
+	default:
+		return 0;
+	}
+}
+
+int btf_kfunc_proto_match(const struct btf *a, __u32 a_id,
+			  const struct btf *b, __u32 b_id)
+{
+	return kfunc_type_match(a, a_id, b, b_id, 32);
+}
+
 static __s32 btf_find_by_name_kind(const struct btf *btf, int start_id,
 				   const char *type_name, __s32 kind)
 {
@@ -1185,7 +1278,7 @@ static __s32 btf_find_by_name_kind(const struct btf *btf, int start_id,
 
 	if (btf->named_start_id > 0 && type_name[0]) {
 		start_id = max(start_id, btf->named_start_id);
-		id = btf_find_type_by_name_bsearch(btf, type_name, start_id);
+		id = btf_find_type_by_name_bsearch(btf, type_name, strlen(type_name), start_id);
 		for (; id < nr_types; id++) {
 			t = btf__type_by_id(btf, id);
 			tname = btf__str_by_offset(btf, t->name_off);
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 1efc0dd37b2e..9439dc2816ea 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -641,7 +641,6 @@ struct extern_desc {
 	int btf_id;
 	int sec_btf_id;
 	char *name;
-	char *essent_name;
 	bool is_set;
 	bool is_weak;
 	union {
@@ -4446,7 +4445,6 @@ static int bpf_object__collect_externs(struct bpf_object *obj)
 	struct extern_desc *ext;
 	int i, n, off, dummy_var_btf_id;
 	const char *ext_name, *sec_name;
-	size_t ext_essent_len;
 	Elf_Scn *scn;
 	Elf64_Shdr *sh;
 
@@ -4498,14 +4496,6 @@ static int bpf_object__collect_externs(struct bpf_object *obj)
 		ext->sym_idx = i;
 		ext->is_weak = ELF64_ST_BIND(sym->st_info) == STB_WEAK;
 
-		ext_essent_len = bpf_core_essential_name_len(ext->name);
-		ext->essent_name = NULL;
-		if (ext_essent_len != strlen(ext->name)) {
-			ext->essent_name = strndup(ext->name, ext_essent_len);
-			if (!ext->essent_name)
-				return -ENOMEM;
-		}
-
 		ext->sec_btf_id = find_extern_sec_btf_id(obj->btf, ext->btf_id);
 		if (ext->sec_btf_id <= 0) {
 			pr_warn("failed to find BTF for extern '%s' [%d] section: %d\n",
@@ -9513,41 +9503,99 @@ static int bpf_object__resolve_ksym_var_btf_id(struct bpf_object *obj,
 	return 0;
 }
 
+/* t is a FUNC whose essential name is the first name_len bytes of name */
+static bool btf_is_kfunc_candidate(const struct btf *btf, const struct btf_type *t,
+				   const char *name, size_t name_len)
+{
+	const char *tname;
+
+	if (!btf_is_func(t))
+		return false;
+	tname = btf__name_by_offset(btf, t->name_off);
+	if (strncmp(tname, name, name_len) != 0)
+		return false;
+	return bpf_core_essential_name_len(tname) == name_len;
+}
+
+/*
+ * Search vmlinux and module BTFs. Return:
+ *   - a BTF ID for a unique match;
+ *   - -ESRCH if the family is absent;
+ *   - -EINVAL if no candidate has a compatible prototype;
+ *   - -ENOTUNIQ if more than one candidate has a compatible prototype;
+ *   - another negative error on failure.
+ */
+static int find_kfunc_btf_id(struct bpf_object *obj, const struct extern_desc *ext,
+			     struct btf **res_btf, struct module_btf **res_mod_btf)
+{
+	size_t name_len = bpf_core_essential_name_len(ext->name);
+	int kfunc_id = 0, nr_cands = 0, err;
+	size_t i;
+
+	err = load_module_btfs(obj);
+	if (err)
+		return err;
+
+	for (i = 0; i <= obj->btf_module_cnt; i++) {
+		struct module_btf *mod = i ? &obj->btf_modules[i - 1] : NULL;
+		struct btf *btf = mod ? mod->btf : obj->btf_vmlinux;
+		__u32 id, end;
+
+		btf_name_prefix_range(btf, ext->name, name_len, &id, &end);
+		for (; id < end; id++) {
+			const struct btf_type *t = btf__type_by_id(btf, id);
+
+			if (!btf_is_kfunc_candidate(btf, t, ext->name, name_len))
+				continue;
+			nr_cands++;
+			if (btf_kfunc_proto_match(obj->btf, ext->ksym.type_id, btf, t->type) <= 0)
+				continue;
+			if (kfunc_id)
+				return -ENOTUNIQ;
+			kfunc_id = id;
+			*res_btf = btf;
+			*res_mod_btf = mod;
+		}
+	}
+	if (!nr_cands)
+		return -ESRCH;
+	if (!kfunc_id)
+		return -EINVAL;
+	return kfunc_id;
+}
+
 static int bpf_object__resolve_ksym_func_btf_id(struct bpf_object *obj,
 						struct extern_desc *ext)
 {
-	int local_func_proto_id, kfunc_proto_id, kfunc_id;
 	struct module_btf *mod_btf = NULL;
 	const struct btf_type *kern_func;
 	struct btf *kern_btf = NULL;
-	int ret;
-
-	local_func_proto_id = ext->ksym.type_id;
+	int kfunc_id, ret;
 
-	kfunc_id = find_ksym_btf_id(obj, ext->essent_name ?: ext->name, BTF_KIND_FUNC, &kern_btf,
-				    &mod_btf);
-	if (kfunc_id < 0) {
-		if (kfunc_id == -ESRCH && ext->is_weak)
+	kfunc_id = find_kfunc_btf_id(obj, ext, &kern_btf, &mod_btf);
+	if (kfunc_id == -ESRCH) {
+		if (ext->is_weak)
 			return 0;
 		pr_warn("extern (func ksym) '%s': not found in kernel or module BTFs\n",
 			ext->name);
 		return kfunc_id;
 	}
-
-	kern_func = btf__type_by_id(kern_btf, kfunc_id);
-	kfunc_proto_id = kern_func->type;
-
-	ret = bpf_core_types_are_compat(obj->btf, local_func_proto_id,
-					kern_btf, kfunc_proto_id);
-	if (ret <= 0) {
+	if (kfunc_id == -EINVAL) {
 		if (ext->is_weak)
 			return 0;
-
-		pr_warn("extern (func ksym) '%s': func_proto [%d] incompatible with %s [%d]\n",
-			ext->name, local_func_proto_id,
-			mod_btf ? mod_btf->name : "vmlinux", kfunc_proto_id);
-		return -EINVAL;
+		pr_warn("extern (func ksym) '%s': no compatible prototype in kernel or module BTFs\n",
+			ext->name);
+		return kfunc_id;
 	}
+	/* an error even for a weak kfunc: ambiguity isn't absence */
+	if (kfunc_id == -ENOTUNIQ) {
+		pr_warn("extern (func ksym) '%s': more than one compatible prototype in kernel or module BTFs\n",
+			ext->name);
+		return kfunc_id;
+	}
+	if (kfunc_id < 0)
+		return kfunc_id;
+	kern_func = btf__type_by_id(kern_btf, kfunc_id);
 
 	/* set index for module BTF fd in fd_array, if unset */
 	if (mod_btf && !mod_btf->fd_array_idx) {
@@ -9579,8 +9627,9 @@ static int bpf_object__resolve_ksym_func_btf_id(struct bpf_object *obj,
 	 * {kernel_btf_id, kernel_btf_obj_fd} -> fixup ld_imm64.
 	 */
 	ext->ksym.kernel_btf_obj_fd = mod_btf ? mod_btf->fd : 0;
-	pr_debug("extern (func ksym) '%s': resolved to %s [%d]\n",
-		 ext->name, mod_btf ? mod_btf->name : "vmlinux", kfunc_id);
+	pr_debug("extern (func ksym) '%s': resolved to %s '%s' [%d]\n",
+		 ext->name, mod_btf ? mod_btf->name : "vmlinux",
+		 btf__name_by_offset(kern_btf, kern_func->name_off), kfunc_id);
 
 	return 0;
 }
@@ -10441,10 +10490,8 @@ void bpf_object__close(struct bpf_object *obj)
 	zfree(&obj->btf_custom_path);
 	zfree(&obj->kconfig);
 
-	for (i = 0; i < obj->nr_extern; i++) {
+	for (i = 0; i < obj->nr_extern; i++)
 		zfree(&obj->externs[i].name);
-		zfree(&obj->externs[i].essent_name);
-	}
 
 	zfree(&obj->externs);
 	obj->nr_extern = 0;
diff --git a/tools/lib/bpf/libbpf_internal.h b/tools/lib/bpf/libbpf_internal.h
index 0ab15b5589d6..c3dadbfbe43d 100644
--- a/tools/lib/bpf/libbpf_internal.h
+++ b/tools/lib/bpf/libbpf_internal.h
@@ -251,6 +251,8 @@ const struct btf_type *skip_mods_and_typedefs(const struct btf *btf, __u32 id, _
 void btf_set_base_btf(struct btf *btf, const struct btf *base_btf);
 int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **id_map,
 		 __u32 **str_map);
+void btf_name_prefix_range(const struct btf *btf, const char *name, size_t name_len,
+			   __u32 *start, __u32 *end);
 bool btf_type_is_traceable_func(const struct btf *btf, const struct btf_type *t);
 
 static inline enum btf_func_linkage btf_func_linkage(const struct btf_type *t)
diff --git a/tools/lib/bpf/libbpf_tools.h b/tools/lib/bpf/libbpf_tools.h
index c590ea4312f2..6068146eabd2 100644
--- a/tools/lib/bpf/libbpf_tools.h
+++ b/tools/lib/bpf/libbpf_tools.h
@@ -12,6 +12,8 @@ struct btf_header;
 struct btf_type;
 
 const struct btf_header *btf_header(const struct btf *btf);
+int btf_kfunc_proto_match(const struct btf *a, __u32 a_id,
+			  const struct btf *b, __u32 b_id);
 
 enum btf_field_iter_kind {
 	BTF_FIELD_ITER_IDS,
-- 
2.56.1


  parent reply	other threads:[~2026-11-21  0:34 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-21  0:33 [PATCH bpf-next v2 0/6] libbpf: Support kernel-side kfunc variants Ihor Solodrai
2026-11-21  0:33 ` [PATCH bpf-next v2 1/6] libbpf: Separate interfaces shared with in-tree tools Ihor Solodrai
2026-11-21  0:33 ` [PATCH bpf-next v2 2/6] sched_ext: Prefer ___v2 kfunc names in compat.bpf.h Ihor Solodrai
2026-11-21  0:34 ` Ihor Solodrai [this message]
2026-11-21  0:34 ` [PATCH bpf-next v2 4/6] selftests/bpf: Test kfunc variant selection by prototype Ihor Solodrai
2026-11-21  0:34 ` [PATCH bpf-next v2 5/6] resolve_btfids: Reject ambiguous kfunc variants Ihor Solodrai
2026-11-21  0:34 ` [PATCH bpf-next v2 6/6] docs/bpf: Describe how to change a kfunc's prototype Ihor Solodrai
2026-11-21  0:58   ` bot+bpf-ci

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261121003403.2928928-4-ihor.solodrai@linux.dev \
    --to=ihor.solodrai@linux.dev \
    --cc=alan.maguire@oracle.com \
    --cc=andrii@kernel.org \
    --cc=ast@kernel.org \
    --cc=bpf@vger.kernel.org \
    --cc=daniel@iogearbox.net \
    --cc=eddyz87@gmail.com \
    --cc=emil@etsalapatis.com \
    --cc=jolsa@kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=memxor@gmail.com \
    --cc=sched-ext@lists.linux.dev \
    --cc=song@kernel.org \
    --cc=tj@kernel.org \
    --cc=yonghong.song@linux.dev \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox