Skip to contentSkip to conversation

Add prog_kfunc feature probe

PATCH Superseded Tao Chen 2 participants 8 messages Feb 6, 2025 – Feb 9, 2025

Subsystems (4)

v4 of 7 Superseded Latest is v7 →

lore
Share & tools
lore

Tao Chen

author
#0 lore raw

v4 cover Add prog_kfunc feature probe

More and more kfunc functions are being added to the kernel. Different prog types have different restrictions when using kfunc. Therefore, prog_kfunc probe is added to check whether it is supported, and the use of this api will be added to bpftool later.

Change list:
- v3 -> v4:
- add fd_array init for kfunc in mod btf
- add test case for kfunc in mod btf
- refactor common part as prog load type check for

    libbpf_probe_bpf_{helper,kfunc}

- v3
https://lore.kernel.org/bpf/[email protected]

- v2 -> v3:
- rename parameter off with btf_fd
- extract the common part for libbpf_probe_bpf_{helper,kfunc}
- v2
https://lore.kernel.org/bpf/[email protected]

- v1 -> v2:
- check unsupported prog type like probe_bpf_helper
- add off parameter for module btf
- check verifier info when kfunc id invalid
- v1
https://lore.kernel.org/bpf/[email protected]

Tao Chen (4):
libbpf: Extract prog load type check from libbpf_probe_bpf_helper
libbpf: Init fd_array when prog probe load
libbpf: Add libbpf_probe_bpf_kfunc API
selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests

 tools/lib/bpf/libbpf.h                        |  18 ++-
 tools/lib/bpf/libbpf.map                      |   1 +
 tools/lib/bpf/libbpf_probes.c                 |  91 ++++++++++++--
 .../selftests/bpf/prog_tests/libbpf_probes.c  | 118 ++++++++++++++++++
 4 files changed, 214 insertions(+), 14 deletions(-)
Signature · 1 line
2.43.0
author
#1 lore raw

PATCH v4 1/4 libbpf: Extract prog load type check from libbpf_probe_bpf_helper

Extract prog load type check part from libbpf_probe_bpf_helper suggested by Andrii, which will be used in both libbpf_probe_bpf_{helper, kfunc}.

---
 tools/lib/bpf/libbpf_probes.c | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)
tools/lib/bpf/libbpf_probes.c +18 -11
index 9dfbe7750f56..aeb4fd97d801 100644
@@ -413,6 +413,23 @@ int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void *opts)
 	return libbpf_err(ret);
 }
 
+static bool can_probe_prog_type(enum bpf_prog_type prog_type)
+{
+	/* we can't successfully load all prog types to check for BPF helper
+	 * and kfunc support.
+	 */
+	switch (prog_type) {
+	case BPF_PROG_TYPE_TRACING:
+	case BPF_PROG_TYPE_EXT:
+	case BPF_PROG_TYPE_LSM:
+	case BPF_PROG_TYPE_STRUCT_OPS:
+		return false;
+	default:
+		break;
+	}
+	return true;
+}
+
 int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helper_id,
 			    const void *opts)
 {
@@ -427,18 +444,8 @@ int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helpe
 	if (opts)
 		return libbpf_err(-EINVAL);
 
-	/* we can't successfully load all prog types to check for BPF helper
-	 * support, so bail out with -EOPNOTSUPP error
-	 */
-	switch (prog_type) {
-	case BPF_PROG_TYPE_TRACING:
-	case BPF_PROG_TYPE_EXT:
-	case BPF_PROG_TYPE_LSM:
-	case BPF_PROG_TYPE_STRUCT_OPS:
+	if (!can_probe_prog_type(prog_type))
 		return -EOPNOTSUPP;
-	default:
-		break;
-	}
 
 	buf[0] = '\0';
 	ret = probe_prog_load(prog_type, insns, insn_cnt, buf, sizeof(buf));
Signature · 1 line
2.43.0
author
#2 lore raw

PATCH v4 2/4 libbpf: Init fd_array when prog probe load

In reply to Tao Chen

fd_array used to store module btf fd, which will
be used for kfunc probe in module btf.

---
 tools/lib/bpf/libbpf_probes.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)
tools/lib/bpf/libbpf_probes.c +5 -2
index aeb4fd97d801..e142130cb83c 100644
@@ -102,12 +102,15 @@ __u32 get_kernel_version(void)
 
 static int probe_prog_load(enum bpf_prog_type prog_type,
 			   const struct bpf_insn *insns, size_t insns_cnt,
+			   int *fd_array, size_t fd_array_cnt,
 			   char *log_buf, size_t log_buf_sz)
 {
 	LIBBPF_OPTS(bpf_prog_load_opts, opts,
 		.log_buf = log_buf,
 		.log_size = log_buf_sz,
 		.log_level = log_buf ? 1 : 0,
+		.fd_array = fd_array,
+		.fd_array_cnt = fd_array_cnt,
 	);
 	int fd, err, exp_err = 0;
 	const char *exp_msg = NULL;
@@ -214,7 +217,7 @@ int libbpf_probe_bpf_prog_type(enum bpf_prog_type prog_type, const void *opts)
 	if (opts)
 		return libbpf_err(-EINVAL);
 
-	ret = probe_prog_load(prog_type, insns, insn_cnt, NULL, 0);
+	ret = probe_prog_load(prog_type, insns, insn_cnt, NULL, 0, NULL, 0);
 	return libbpf_err(ret);
 }
 
@@ -448,7 +451,7 @@ int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helpe
 		return -EOPNOTSUPP;
 
 	buf[0] = '\0';
-	ret = probe_prog_load(prog_type, insns, insn_cnt, buf, sizeof(buf));
+	ret = probe_prog_load(prog_type, insns, insn_cnt, NULL, 0, buf, sizeof(buf));
 	if (ret < 0)
 		return libbpf_err(ret);
 
Signature · 1 line
2.43.0
author
#3 lore raw

PATCH v4 3/4 libbpf: Add libbpf_probe_bpf_kfunc API

In reply to Tao Chen

Similarly to libbpf_probe_bpf_helper, the libbpf_probe_bpf_kfunc used to test the availability of the different eBPF kfuncs on the current system.

---
 tools/lib/bpf/libbpf.h        | 18 +++++++++++-
 tools/lib/bpf/libbpf.map      |  1 +
 tools/lib/bpf/libbpf_probes.c | 55 +++++++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+), 1 deletion(-)
tools/lib/bpf/libbpf.h +17 -1
index 3020ee45303a..596b27f58c58 100644
@@ -1680,7 +1680,23 @@ LIBBPF_API int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void
  */
 LIBBPF_API int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type,
 				       enum bpf_func_id helper_id, const void *opts);
-
+/**
+ * @brief **libbpf_probe_bpf_kfunc()** detects if host kernel supports the
+ * use of a given BPF kfunc from specified BPF program type.
+ * @param prog_type BPF program type used to check the support of BPF kfunc
+ * @param kfunc_id The btf ID of BPF kfunc to check support for
+ * @param btf_fd The module BTF FD, if kfunc is defined in kernel module,
+ * btf_fd is used to point to module's BTF, 0 means kfunc defined in vmlinux.
+ * @param opts reserved for future extensibility, should be NULL
+ * @return 1, if given combination of program type and kfunc is supported; 0,
+ * if the combination is not supported; negative error code if feature
+ * detection for provided input arguments failed or can't be performed
+ *
+ * Make sure the process has required set of CAP_* permissions (or runs as
+ * root) when performing feature checking.
+ */
+LIBBPF_API int libbpf_probe_bpf_kfunc(enum bpf_prog_type prog_type,
+				      int kfunc_id, int btf_fd, const void *opts);
 /**
  * @brief **libbpf_num_possible_cpus()** is a helper function to get the
  * number of possible CPUs that the host kernel supports and expects.
tools/lib/bpf/libbpf.map +1 -0
index a8b2936a1646..e93fae101efd 100644
@@ -436,4 +436,5 @@ LIBBPF_1.6.0 {
 		bpf_linker__add_buf;
 		bpf_linker__add_fd;
 		bpf_linker__new_fd;
+		libbpf_probe_bpf_kfunc;
 } LIBBPF_1.5.0;
tools/lib/bpf/libbpf_probes.c +55 -0

61 lines not on this page · raw message

Signature · 1 line
2.43.0
maintainer
#4 lore raw

Re: [PATCH bpf-next v4 3/4] libbpf: Add libbpf_probe_bpf_kfunc API

On Thu, 2025-02-06 at 13:15 +0800, Tao Chen wrote:

[...]

tools/lib/bpf/libbpf.h LIBBPF_API int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void · line 1689

Quoted 10 lines

LIBBPF_API int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type,

tools/lib/bpf/libbpf.h +7 -1
 				       enum bpf_func_id helper_id, const void *opts);
-
+/**
+ * @brief **libbpf_probe_bpf_kfunc()** detects if host kernel supports the
+ * use of a given BPF kfunc from specified BPF program type.
+ * @param prog_type BPF program type used to check the support of BPF kfunc
+ * @param kfunc_id The btf ID of BPF kfunc to check support for
+ * @param btf_fd The module BTF FD, if kfunc is defined in kernel module,
+ * btf_fd is used to point to module's BTF, 0 means kfunc defined in vmlinux.

Regarding '0' as special value:
in general FD is considered invalid only if it's negative, 0 is a valid FD. Andrii, I remember there was a lengthy discussion about FD==0 and BPF, but I don't remember the conclusion.

Quoted 18 lines

+ * @param opts reserved for future extensibility, should be NULL
+ * @return 1, if given combination of program type and kfunc is supported; 0,
+ * if the combination is not supported; negative error code if feature
+ * detection for provided input arguments failed or can't be performed
+ *
+ * Make sure the process has required set of CAP_* permissions (or runs as
+ * root) when performing feature checking.
+ */

tools/lib/bpf/libbpf.h +2 -0
+LIBBPF_API int libbpf_probe_bpf_kfunc(enum bpf_prog_type prog_type,
+				      int kfunc_id, int btf_fd, const void *opts);
 /**
  * @brief **libbpf_num_possible_cpus()** is a helper function to get the
  * number of possible CPUs that the host kernel supports and expects.
tools/lib/bpf/libbpf.map +0 -0
index a8b2936a1646..e93fae101efd 100644

tools/lib/bpf/libbpf.map LIBBPF_1.6.0 { · line 439

Quoted 4 lines
tools/lib/bpf/libbpf.map +1 -0
@@ -436,4 +436,5 @@ LIBBPF_1.6.0 {
 		bpf_linker__add_buf;
 		bpf_linker__add_fd;
 		bpf_linker__new_fd;
+		libbpf_probe_bpf_kfunc;

This is now in conflict with bpf-next.

Quoted 21 lines
tools/lib/bpf/libbpf.map +0 -0
 } LIBBPF_1.5.0;
tools/lib/bpf/libbpf_probes.c +12 -0
index e142130cb83c..c7f2b2dfbcf1 100644
@@ -433,6 +433,61 @@ static bool can_probe_prog_type(enum bpf_prog_type prog_type)
 	return true;
 }
 
+int libbpf_probe_bpf_kfunc(enum bpf_prog_type prog_type, int kfunc_id, int btf_fd,
+			   const void *opts)
+{
+	struct bpf_insn insns[] = {
+		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, btf_fd, kfunc_id),
+		BPF_EXIT_INSN(),
+	};
+	const size_t insn_cnt = ARRAY_SIZE(insns);
+	char buf[4096];
+	int *fd_array = NULL;
+	size_t fd_array_cnt = 0, fd_array_cap = fd_array_cnt;
+	int ret;

tools/lib/bpf/libbpf_probes.c static bool can_probe_prog_type(enum bpf_prog_type prog_type) · line 457

Quoted 10 lines
tools/lib/bpf/libbpf_probes.c +10 -0
+
+	if (opts)
+		return libbpf_err(-EINVAL);
+
+	if (!can_probe_prog_type(prog_type))
+		return -EOPNOTSUPP;
+
+	if (btf_fd) {
+		ret = libbpf_ensure_mem((void **)&fd_array, &fd_array_cap,
+					sizeof(int), fd_array_cnt + btf_fd);

Please take a look at the tools/testing/selftests/bpf/prog_tests/fd_array.c, e.g. test case check_fd_array_cnt__fd_array_ok(). The offset field of the call instruction does not have to be an fd (as it only has 16 bits), instead it's an offset inside the fd_array.
Here it would be sufficient to allocate a small array on stack.

Quoted 8 lines
tools/lib/bpf/libbpf_probes.c +8 -0
+		if (ret)
+			return ret;
+
+		/* In kernel, obtain the btf fd by means of the offset of
+		 * the fd_array, and the offset is the btf fd.
+		 */
+		fd_array[btf_fd] = btf_fd;
+	}

[...]

author
#5 lore raw

Re: [PATCH bpf-next v4 3/4] libbpf: Add libbpf_probe_bpf_kfunc API

Quoted 36 lines · Eduard Zingerman

On Thu, 2025-02-06 at 13:15 +0800, Tao Chen wrote:

[...]

tools/lib/bpf/libbpf.h LIBBPF_API int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void · line 1689

Quoted 10 lines

LIBBPF_API int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type,
enum bpf_func_id helper_id, const void *opts);

tools/lib/bpf/libbpf.h +7 -1
-
+/**
+ * @brief **libbpf_probe_bpf_kfunc()** detects if host kernel supports the
+ * use of a given BPF kfunc from specified BPF program type.
+ * @param prog_type BPF program type used to check the support of BPF kfunc
+ * @param kfunc_id The btf ID of BPF kfunc to check support for
+ * @param btf_fd The module BTF FD, if kfunc is defined in kernel module,
+ * btf_fd is used to point to module's BTF, 0 means kfunc defined in vmlinux.

Regarding '0' as special value:
in general FD is considered invalid only if it's negative, 0 is a valid FD. Andrii, I remember there was a lengthy discussion about FD==0 and BPF, but I don't remember the conclusion.

Quoted 16 lines

+ * @param opts reserved for future extensibility, should be NULL
+ * @return 1, if given combination of program type and kfunc is supported; 0,
+ * if the combination is not supported; negative error code if feature
+ * detection for provided input arguments failed or can't be performed
+ *
+ * Make sure the process has required set of CAP_* permissions (or runs as
+ * root) when performing feature checking.
+ */

tools/lib/bpf/libbpf.h +2 -0
+LIBBPF_API int libbpf_probe_bpf_kfunc(enum bpf_prog_type prog_type,
+				      int kfunc_id, int btf_fd, const void *opts);
  /**
   * @brief **libbpf_num_possible_cpus()** is a helper function to get the
   * number of possible CPUs that the host kernel supports and expects.
tools/lib/bpf/libbpf.map +0 -1
index a8b2936a1646..e93fae101efd 100644
--- a/tools/lib/bpf/libbpf.map
Quoted 9 lines

tools/lib/bpf/libbpf.map LIBBPF_1.6.0 { · line 439

Quoted 6 lines

+++ b/tools/lib/bpf/libbpf.map

tools/lib/bpf/libbpf.map +1 -0
@@ -436,4 +436,5 @@ LIBBPF_1.6.0 {
  		bpf_linker__add_buf;
  		bpf_linker__add_fd;
  		bpf_linker__new_fd;
+		libbpf_probe_bpf_kfunc;

This is now in conflict with bpf-next.

My bad, i will rebase the repo.

Quoted 29 lines
Quoted 29 lines
tools/lib/bpf/libbpf.map +0 -0
  } LIBBPF_1.5.0;
tools/lib/bpf/libbpf_probes.c +20 -0
index e142130cb83c..c7f2b2dfbcf1 100644
@@ -433,6 +433,61 @@ static bool can_probe_prog_type(enum bpf_prog_type prog_type)
  	return true;
  }
 
+int libbpf_probe_bpf_kfunc(enum bpf_prog_type prog_type, int kfunc_id, int btf_fd,
+			   const void *opts)
+{
+	struct bpf_insn insns[] = {
+		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, btf_fd, kfunc_id),
+		BPF_EXIT_INSN(),
+	};
+	const size_t insn_cnt = ARRAY_SIZE(insns);
+	char buf[4096];
+	int *fd_array = NULL;
+	size_t fd_array_cnt = 0, fd_array_cap = fd_array_cnt;
+	int ret;
+
+	if (opts)
+		return libbpf_err(-EINVAL);
+
+	if (!can_probe_prog_type(prog_type))
+		return -EOPNOTSUPP;
+
+	if (btf_fd) {
Quoted 9 lines

tools/lib/bpf/libbpf_probes.c static bool can_probe_prog_type(enum bpf_prog_type prog_type) · line 457

Quoted 2 lines
tools/lib/bpf/libbpf_probes.c +2 -0
+		ret = libbpf_ensure_mem((void **)&fd_array, &fd_array_cap,
+					sizeof(int), fd_array_cnt + btf_fd);

Please take a look at the tools/testing/selftests/bpf/prog_tests/fd_array.c, e.g. test case check_fd_array_cnt__fd_array_ok(). The offset field of the call instruction does not have to be an fd (as it only has 16 bits), instead it's an offset inside the fd_array.
Here it would be sufficient to allocate a small array on stack.

Good idea,thanks for your guidance,I'll make the modifications in the next version.

Quoted 11 lines
Quoted 8 lines
tools/lib/bpf/libbpf_probes.c +8 -0
+		if (ret)
+			return ret;
+
+		/* In kernel, obtain the btf fd by means of the offset of
+		 * the fd_array, and the offset is the btf fd.
+		 */
+		fd_array[btf_fd] = btf_fd;
+	}

[...]

Signature · 2 lines
Best Regards
Dylane Chen
author
#6 lore raw

Re: [PATCH bpf-next v4 3/4] libbpf: Add libbpf_probe_bpf_kfunc API

In reply to Eduard Zingerman
Quoted 4 lines · Eduard Zingerman

On Thu, 2025-02-06 at 13:15 +0800, Tao Chen wrote:

[...]

Quoted 16 lines

tools/lib/bpf/libbpf.h LIBBPF_API int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void · line 1689

Quoted 10 lines

LIBBPF_API int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type,
enum bpf_func_id helper_id, const void *opts);

tools/lib/bpf/libbpf.h +7 -1
-
+/**
+ * @brief **libbpf_probe_bpf_kfunc()** detects if host kernel supports the
+ * use of a given BPF kfunc from specified BPF program type.
+ * @param prog_type BPF program type used to check the support of BPF kfunc
+ * @param kfunc_id The btf ID of BPF kfunc to check support for
+ * @param btf_fd The module BTF FD, if kfunc is defined in kernel module,
+ * btf_fd is used to point to module's BTF, 0 means kfunc defined in vmlinux.

Regarding '0' as special value:
in general FD is considered invalid only if it's negative, 0 is a valid FD. Andrii, I remember there was a lengthy discussion about FD==0 and BPF, but I don't remember the conclusion.

Hi Eduard,
As you said, so what about "-1 means kfunc defined in vmlinux", -1 just used to distinguish whether it is vmlinux,then processing in libbpf_probe_bpf_kfunc like:

offset = 0;
// vmlinux btf offset default is 0
insn.off = offset;

if (btf_fd >= 0) {
	offset = 1;
	insn.off = offset;
	fd_array[offset] = btf_fd;
}

What do you think?

Quoted 74 lines
Quoted 18 lines

+ * @param opts reserved for future extensibility, should be NULL
+ * @return 1, if given combination of program type and kfunc is supported; 0,
+ * if the combination is not supported; negative error code if feature
+ * detection for provided input arguments failed or can't be performed
+ *
+ * Make sure the process has required set of CAP_* permissions (or runs as
+ * root) when performing feature checking.
+ */

tools/lib/bpf/libbpf.h +2 -0
+LIBBPF_API int libbpf_probe_bpf_kfunc(enum bpf_prog_type prog_type,
+				      int kfunc_id, int btf_fd, const void *opts);
  /**
   * @brief **libbpf_num_possible_cpus()** is a helper function to get the
   * number of possible CPUs that the host kernel supports and expects.
tools/lib/bpf/libbpf.map +0 -0
index a8b2936a1646..e93fae101efd 100644

tools/lib/bpf/libbpf.map LIBBPF_1.6.0 { · line 439

Quoted 4 lines
tools/lib/bpf/libbpf.map +1 -0
@@ -436,4 +436,5 @@ LIBBPF_1.6.0 {
  		bpf_linker__add_buf;
  		bpf_linker__add_fd;
  		bpf_linker__new_fd;
+		libbpf_probe_bpf_kfunc;

This is now in conflict with bpf-next.

Quoted 21 lines
tools/lib/bpf/libbpf.map +0 -0
  } LIBBPF_1.5.0;
tools/lib/bpf/libbpf_probes.c +12 -0
index e142130cb83c..c7f2b2dfbcf1 100644
@@ -433,6 +433,61 @@ static bool can_probe_prog_type(enum bpf_prog_type prog_type)
  	return true;
  }
 
+int libbpf_probe_bpf_kfunc(enum bpf_prog_type prog_type, int kfunc_id, int btf_fd,
+			   const void *opts)
+{
+	struct bpf_insn insns[] = {
+		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, btf_fd, kfunc_id),
+		BPF_EXIT_INSN(),
+	};
+	const size_t insn_cnt = ARRAY_SIZE(insns);
+	char buf[4096];
+	int *fd_array = NULL;
+	size_t fd_array_cnt = 0, fd_array_cap = fd_array_cnt;
+	int ret;

tools/lib/bpf/libbpf_probes.c static bool can_probe_prog_type(enum bpf_prog_type prog_type) · line 457

Quoted 10 lines
tools/lib/bpf/libbpf_probes.c +10 -0
+
+	if (opts)
+		return libbpf_err(-EINVAL);
+
+	if (!can_probe_prog_type(prog_type))
+		return -EOPNOTSUPP;
+
+	if (btf_fd) {
+		ret = libbpf_ensure_mem((void **)&fd_array, &fd_array_cap,
+					sizeof(int), fd_array_cnt + btf_fd);

Please take a look at the tools/testing/selftests/bpf/prog_tests/fd_array.c, e.g. test case check_fd_array_cnt__fd_array_ok(). The offset field of the call instruction does not have to be an fd (as it only has 16 bits), instead it's an offset inside the fd_array.
Here it would be sufficient to allocate a small array on stack.

Quoted 8 lines
tools/lib/bpf/libbpf_probes.c +8 -0
+		if (ret)
+			return ret;
+
+		/* In kernel, obtain the btf fd by means of the offset of
+		 * the fd_array, and the offset is the btf fd.
+		 */
+		fd_array[btf_fd] = btf_fd;
+	}

[...]

Signature · 2 lines
Best Regards
Dylane Chen
author
#7 lore raw

PATCH v4 4/4 selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests

In reply to Tao Chen

Add selftests for prog_kfunc feature probing.

./test_progs -t libbpf_probe_kfuncs
#153 libbpf_probe_kfuncs:OK
Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED

---
 .../selftests/bpf/prog_tests/libbpf_probes.c  | 118 ++++++++++++++++++
 1 file changed, 118 insertions(+)
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c +118 -0
index 4ed46ed58a7b..8f249ca7d5d7 100644
@@ -126,3 +126,121 @@ void test_libbpf_probe_helpers(void)
 		ASSERT_EQ(res, d->supported, buf);
 	}
 }
+
+static int module_btf_fd(char *module)
+{
+	int fd, err;
+	__u32 id = 0, len;
+	struct bpf_btf_info info;
+	char name[64];
+
+	while (true) {
+		err = bpf_btf_get_next_id(id, &id);
+		if (err && (errno == ENOENT || errno == EPERM))
+			return 0;
+		if (err) {
+			err = -errno;
+			return err;
+		}
+		fd = bpf_btf_get_fd_by_id(id);
+		if (fd < 0) {
+			if (errno == ENOENT)
+				continue;
+			err = -errno;
+			return err;
+		}
+		len = sizeof(info);
+		memset(&info, 0, sizeof(info));
+		info.name = ptr_to_u64(name);
+		info.name_len = sizeof(name);
+		err = bpf_btf_get_info_by_fd(fd, &info, &len);
+		if (err) {
+			err = -errno;
+			goto err_out;
+		}
+		/* find target module btf */
+		if (!strcmp(name, module))
+			break;
+
+		close(fd);
+	}
+
+	return fd;
+err_out:
+	close(fd);
+	return err;
+}
+
+void test_libbpf_probe_kfuncs(void)
+{
+	int ret, kfunc_id, fd;
+	char *kfunc = "bpf_cpumask_create";
+	struct btf *vmlinux_btf = NULL;
+	struct btf *module_btf = NULL;
+
+	vmlinux_btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
+	if (!ASSERT_OK_PTR(vmlinux_btf, "btf_parse"))
+		return;
+
+	kfunc_id = btf__find_by_name_kind(vmlinux_btf, kfunc, BTF_KIND_FUNC);
+	if (!ASSERT_GT(kfunc_id, 0, kfunc))
+		goto cleanup;
+
+	/* prog BPF_PROG_TYPE_SYSCALL supports kfunc bpf_cpumask_create */
+	ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_SYSCALL, kfunc_id, 0, NULL);
+	if (!ASSERT_EQ(ret, 1, "kfunc in vmlinux support"))
+		goto cleanup;
+
+	/* prog BPF_PROG_TYPE_KPROBE does not support kfunc bpf_cpumask_create */
+	ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_KPROBE, kfunc_id, 0, NULL);
+	if (!ASSERT_EQ(ret, 0, "kfunc in vmlinux not suuport"))
+		goto cleanup;
+
+	ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_KPROBE, -1, 0, NULL);
+	if (!ASSERT_EQ(ret, 0, "invalid kfunc id:-1"))
+		goto cleanup;
+
+	ret = libbpf_probe_bpf_kfunc(100000, kfunc_id, 0, NULL);
+	if (!ASSERT_ERR(ret, "invalid prog type:100000"))
+		goto cleanup;
+
+	if (!env.has_testmod)
+		goto cleanup;
+
+	module_btf = btf__load_module_btf("bpf_testmod", vmlinux_btf);
+	if (!ASSERT_OK_PTR(module_btf, "load module BTF"))
+		goto cleanup;
+
+	kfunc_id = btf__find_by_name(module_btf, "bpf_kfunc_call_test1");
+	if (!ASSERT_GT(kfunc_id, 0, "func not found"))
+		goto cleanup;
+
+	fd = module_btf_fd("bpf_testmod");
+	if (!ASSERT_GT(fd, 0, "module btf fd"))
+		goto cleanup;
+
+	/* prog BPF_PROG_TYPE_SYSCALL supports kfunc bpf_kfunc_call_test1 in bpf_testmod */
+	ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_SYSCALL, kfunc_id, fd, NULL);
+	if (!ASSERT_EQ(ret, 1, "kfunc in module btf support"))
+		goto cleanup_fd;
+
+	/* prog BPF_PROG_TYPE_KPROBE does not support kfunc bpf_kfunc_call_test1
+	 * in bpf_testmod
+	 */
+	ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_KPROBE, kfunc_id, fd, NULL);
+	if (!ASSERT_EQ(ret, 0, "kfunc in module btf not support"))
+		goto cleanup_fd;
+
+	ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_SYSCALL, -1, fd, NULL);
+	if (!ASSERT_EQ(ret, 0, "invalid kfunc id in module btf"))
+		goto cleanup_fd;
+
+	ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_SYSCALL, kfunc_id, 100, NULL);
+	ASSERT_EQ(ret, 0, "invalid btf fd in module btf");
+
+cleanup_fd:
+	close(fd);
+cleanup:
+	btf__free(vmlinux_btf);
+	btf__free(module_btf);
+}
Signature · 1 line
2.43.0