* [PATCH bpf-next v8 1/4] libbpf: Extract prog load type check from libbpf_probe_bpf_helper
2025-02-21 16:33 [PATCH bpf-next v8 0/4] Add prog_kfunc feature probe Tao Chen
@ 2025-02-21 16:33 ` Tao Chen
2025-02-21 16:33 ` [PATCH bpf-next v8 2/4] libbpf: Init fd_array when prog probe load Tao Chen
` (2 subsequent siblings)
3 siblings, 0 replies; 7+ messages in thread
From: Tao Chen @ 2025-02-21 16:33 UTC (permalink / raw)
To: ast, daniel, andrii, eddyz87, haoluo, jolsa, qmo
Cc: bpf, linux-kernel, chen.dylane, Tao Chen, Tao Chen
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}.
Cc: Tao Chen <dylane.chen@didiglobal.com>
Reviewed-by: Jiri Olsa <jolsa@kernel.org>
Reviewed-by: Eduard Zingerman <eddyz87@gmail.com>
Signed-off-by: Tao Chen <chen.dylane@linux.dev>
---
tools/lib/bpf/libbpf_probes.c | 31 +++++++++++++++++++------------
1 file changed, 19 insertions(+), 12 deletions(-)
diff --git a/tools/lib/bpf/libbpf_probes.c b/tools/lib/bpf/libbpf_probes.c
index 9dfbe7750f56..a48a557314f6 100644
--- a/tools/lib/bpf/libbpf_probes.c
+++ b/tools/lib/bpf/libbpf_probes.c
@@ -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:
- return -EOPNOTSUPP;
- default:
- break;
- }
+ if (!can_probe_prog_type(prog_type))
+ return libbpf_err(-EOPNOTSUPP);
buf[0] = '\0';
ret = probe_prog_load(prog_type, insns, insn_cnt, buf, sizeof(buf));
--
2.43.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH bpf-next v8 2/4] libbpf: Init fd_array when prog probe load
2025-02-21 16:33 [PATCH bpf-next v8 0/4] Add prog_kfunc feature probe Tao Chen
2025-02-21 16:33 ` [PATCH bpf-next v8 1/4] libbpf: Extract prog load type check from libbpf_probe_bpf_helper Tao Chen
@ 2025-02-21 16:33 ` Tao Chen
2025-02-21 16:33 ` [PATCH bpf-next v8 3/4] libbpf: Add libbpf_probe_bpf_kfunc API Tao Chen
2025-02-21 16:33 ` [PATCH bpf-next v8 4/4] selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests Tao Chen
3 siblings, 0 replies; 7+ messages in thread
From: Tao Chen @ 2025-02-21 16:33 UTC (permalink / raw)
To: ast, daniel, andrii, eddyz87, haoluo, jolsa, qmo
Cc: bpf, linux-kernel, chen.dylane, Tao Chen, Tao Chen
fd_array used to store module btf fd, which will
be used for kfunc probe in module btf.
Cc: Tao Chen <dylane.chen@didiglobal.com>
Reviewed-by: Jiri Olsa <jolsa@kernel.org>
Reviewed-by: Eduard Zingerman <eddyz87@gmail.com>
Signed-off-by: Tao Chen <chen.dylane@linux.dev>
---
tools/lib/bpf/libbpf_probes.c | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/tools/lib/bpf/libbpf_probes.c b/tools/lib/bpf/libbpf_probes.c
index a48a557314f6..de2b1205b436 100644
--- a/tools/lib/bpf/libbpf_probes.c
+++ b/tools/lib/bpf/libbpf_probes.c
@@ -102,12 +102,13 @@ __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,
- char *log_buf, size_t log_buf_sz)
+ int *fd_array, 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,
);
int fd, err, exp_err = 0;
const char *exp_msg = NULL;
@@ -214,7 +215,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, NULL, 0);
return libbpf_err(ret);
}
@@ -448,7 +449,7 @@ int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helpe
return libbpf_err(-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, buf, sizeof(buf));
if (ret < 0)
return libbpf_err(ret);
--
2.43.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH bpf-next v8 3/4] libbpf: Add libbpf_probe_bpf_kfunc API
2025-02-21 16:33 [PATCH bpf-next v8 0/4] Add prog_kfunc feature probe Tao Chen
2025-02-21 16:33 ` [PATCH bpf-next v8 1/4] libbpf: Extract prog load type check from libbpf_probe_bpf_helper Tao Chen
2025-02-21 16:33 ` [PATCH bpf-next v8 2/4] libbpf: Init fd_array when prog probe load Tao Chen
@ 2025-02-21 16:33 ` Tao Chen
2025-02-21 16:33 ` [PATCH bpf-next v8 4/4] selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests Tao Chen
3 siblings, 0 replies; 7+ messages in thread
From: Tao Chen @ 2025-02-21 16:33 UTC (permalink / raw)
To: ast, daniel, andrii, eddyz87, haoluo, jolsa, qmo
Cc: bpf, linux-kernel, chen.dylane, Tao Chen, 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.
Cc: Tao Chen <dylane.chen@didiglobal.com>
Reviewed-by: Jiri Olsa <jolsa@kernel.org>
Reviewed-by: Eduard Zingerman <eddyz87@gmail.com>
Signed-off-by: Tao Chen <chen.dylane@linux.dev>
---
tools/lib/bpf/libbpf.h | 19 ++++++++++++-
tools/lib/bpf/libbpf.map | 1 +
tools/lib/bpf/libbpf_probes.c | 51 +++++++++++++++++++++++++++++++++++
3 files changed, 70 insertions(+), 1 deletion(-)
diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index 3020ee45303a..c79b4475b956 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -1680,7 +1680,24 @@ 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, which is >= 0, and < 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.
diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map
index b5a838de6f47..3bbfe13aeb6a 100644
--- a/tools/lib/bpf/libbpf.map
+++ b/tools/lib/bpf/libbpf.map
@@ -438,4 +438,5 @@ LIBBPF_1.6.0 {
bpf_linker__new_fd;
btf__add_decl_attr;
btf__add_type_attr;
+ libbpf_probe_bpf_kfunc;
} LIBBPF_1.5.0;
diff --git a/tools/lib/bpf/libbpf_probes.c b/tools/lib/bpf/libbpf_probes.c
index de2b1205b436..8efebc18a215 100644
--- a/tools/lib/bpf/libbpf_probes.c
+++ b/tools/lib/bpf/libbpf_probes.c
@@ -431,6 +431,57 @@ 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, 1, kfunc_id),
+ BPF_EXIT_INSN(),
+ };
+ const size_t insn_cnt = ARRAY_SIZE(insns);
+ char buf[4096];
+ int fd_array[2] = {-1};
+ int ret;
+
+ if (opts)
+ return libbpf_err(-EINVAL);
+
+ if (!can_probe_prog_type(prog_type))
+ return libbpf_err(-EOPNOTSUPP);
+
+ if (btf_fd >= 0)
+ fd_array[1] = btf_fd;
+ else
+ /* insn.off = 0, means vmlinux btf */
+ insns[0].off = 0;
+
+ buf[0] = '\0';
+ ret = probe_prog_load(prog_type, insns, insn_cnt, btf_fd >= 0 ? fd_array : NULL,
+ buf, sizeof(buf));
+ if (ret < 0)
+ return libbpf_err(ret);
+
+ if (ret > 0)
+ return 1; /* assume supported */
+
+ /* If BPF verifier recognizes BPF kfunc but it's not supported for
+ * given BPF program type, it will emit "calling kernel function
+ * <name> is not allowed". If the kfunc id is invalid,
+ * it will emit "kernel btf_id <id> is not a function". If BTF fd
+ * invalid in module BTF, it will emit "invalid module BTF fd specified" or
+ * "negative offset disallowed for kernel module function call". If
+ * kfunc prog not dev buound, it will emit "metadata kfuncs require
+ * device-bound program".
+ */
+ if (strstr(buf, "not allowed") || strstr(buf, "not a function") ||
+ strstr(buf, "invalid module BTF fd") ||
+ strstr(buf, "negative offset disallowed") ||
+ strstr(buf, "device-bound program"))
+ return 0;
+
+ return 1;
+}
+
int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helper_id,
const void *opts)
{
--
2.43.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH bpf-next v8 4/4] selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests
2025-02-21 16:33 [PATCH bpf-next v8 0/4] Add prog_kfunc feature probe Tao Chen
` (2 preceding siblings ...)
2025-02-21 16:33 ` [PATCH bpf-next v8 3/4] libbpf: Add libbpf_probe_bpf_kfunc API Tao Chen
@ 2025-02-21 16:33 ` Tao Chen
2025-02-21 18:19 ` Eduard Zingerman
3 siblings, 1 reply; 7+ messages in thread
From: Tao Chen @ 2025-02-21 16:33 UTC (permalink / raw)
To: ast, daniel, andrii, eddyz87, haoluo, jolsa, qmo
Cc: bpf, linux-kernel, chen.dylane, Tao Chen, Tao Chen
Add selftests for prog_kfunc feature probing. Thanks for
Eduard providing the libbpf_probe_func_many test case.
./test_progs -t libbpf_probe_kfuncs
#153 libbpf_probe_kfuncs:OK
Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED
./test_progs -t libbpf_probe_kfuncs_many
#154 libbpf_probe_kfuncs_many:OK
Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED
Cc: Tao Chen <dylane.chen@didiglobal.com>
Reviewed-by: Jiri Olsa <jolsa@kernel.org>
Co-developed-by: Eduard Zingerman <eddyz87@gmail.com>
Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>
Signed-off-by: Tao Chen <chen.dylane@linux.dev>
---
.../selftests/bpf/prog_tests/libbpf_probes.c | 173 ++++++++++++++++++
1 file changed, 173 insertions(+)
diff --git a/tools/testing/selftests/bpf/prog_tests/libbpf_probes.c b/tools/testing/selftests/bpf/prog_tests/libbpf_probes.c
index 4ed46ed58a7b..db408fd67add 100644
--- a/tools/testing/selftests/bpf/prog_tests/libbpf_probes.c
+++ b/tools/testing/selftests/bpf/prog_tests/libbpf_probes.c
@@ -126,3 +126,176 @@ 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)
+ return -1;
+
+ fd = bpf_btf_get_fd_by_id(id);
+ if (fd < 0) {
+ if (errno == ENOENT)
+ continue;
+ return -1;
+ }
+ 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) {
+ close(fd);
+ return -1;
+ }
+ /* find target module BTF */
+ if (!strcmp(name, module))
+ break;
+
+ close(fd);
+ }
+
+ return fd;
+}
+
+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, -1, 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, -1, NULL);
+ if (!ASSERT_EQ(ret, 0, "kfunc in vmlinux not suuport"))
+ goto cleanup;
+
+ ret = libbpf_probe_bpf_kfunc(BPF_PROG_TYPE_KPROBE, -1, -1, NULL);
+ if (!ASSERT_EQ(ret, 0, "invalid kfunc id:-1"))
+ goto cleanup;
+
+ ret = libbpf_probe_bpf_kfunc(100000, kfunc_id, -1, 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_GE(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);
+}
+
+static const struct {
+ const char *name;
+ int code;
+} program_types[] = {
+#define _T(n) { #n, BPF_PROG_TYPE_##n }
+ _T(KPROBE),
+ _T(XDP),
+ _T(SYSCALL),
+ _T(SCHED_CLS),
+ _T(SCHED_ACT),
+ _T(SK_SKB),
+ _T(SOCKET_FILTER),
+ _T(CGROUP_SKB),
+ _T(LWT_OUT),
+ _T(LWT_IN),
+ _T(LWT_XMIT),
+ _T(LWT_SEG6LOCAL),
+ _T(NETFILTER),
+ _T(CGROUP_SOCK_ADDR),
+ _T(SCHED_ACT)
+#undef _T
+};
+
+void test_libbpf_probe_kfuncs_many(void)
+{
+ int i, kfunc_id, ret, id;
+ const struct btf_type *t;
+ struct btf *btf = NULL;
+ const char *kfunc;
+ const char *tag;
+
+ btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
+ if (!ASSERT_OK_PTR(btf, "btf_parse"))
+ return;
+ for (id = 0; id < btf__type_cnt(btf); ++id) {
+ t = btf__type_by_id(btf, id);
+ if (!t)
+ continue;
+ if (!btf_is_decl_tag(t))
+ continue;
+ tag = btf__name_by_offset(btf, t->name_off);
+ if (strcmp(tag, "bpf_kfunc") != 0)
+ continue;
+ kfunc_id = t->type;
+ t = btf__type_by_id(btf, kfunc_id);
+ if (!btf_is_func(t))
+ continue;
+ kfunc = btf__name_by_offset(btf, t->name_off);
+ for (i = 0; i < ARRAY_SIZE(program_types); ++i) {
+ ret = libbpf_probe_bpf_kfunc(program_types[i].code,
+ kfunc_id, -1, NULL);
+ if (ret < 0) {
+ ASSERT_FAIL("kfunc:%s use prog type:%d",
+ kfunc, program_types[i].code);
+ goto cleanup;
+ }
+ }
+ }
+cleanup:
+ btf__free(btf);
+}
--
2.43.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* Re: [PATCH bpf-next v8 4/4] selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests
2025-02-21 16:33 ` [PATCH bpf-next v8 4/4] selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests Tao Chen
@ 2025-02-21 18:19 ` Eduard Zingerman
2025-02-22 3:00 ` Tao Chen
0 siblings, 1 reply; 7+ messages in thread
From: Eduard Zingerman @ 2025-02-21 18:19 UTC (permalink / raw)
To: Tao Chen, ast, daniel, andrii, haoluo, jolsa, qmo
Cc: bpf, linux-kernel, chen.dylane, Tao Chen
On Sat, 2025-02-22 at 00:33 +0800, Tao Chen wrote:
[...]
> +static const struct {
> + const char *name;
> + int code;
> +} program_types[] = {
> +#define _T(n) { #n, BPF_PROG_TYPE_##n }
> + _T(KPROBE),
> + _T(XDP),
> + _T(SYSCALL),
> + _T(SCHED_CLS),
> + _T(SCHED_ACT),
> + _T(SK_SKB),
> + _T(SOCKET_FILTER),
> + _T(CGROUP_SKB),
> + _T(LWT_OUT),
> + _T(LWT_IN),
> + _T(LWT_XMIT),
> + _T(LWT_SEG6LOCAL),
> + _T(NETFILTER),
> + _T(CGROUP_SOCK_ADDR),
> + _T(SCHED_ACT)
> +#undef _T
> +};
> +
> +void test_libbpf_probe_kfuncs_many(void)
> +{
Hi Tao,
Sorry, probably some miscommunication from my side.
I did not mean this test for inclusion, it was meant as a one time
manual inspection of libbpf_probe_bpf_kfunc results.
Just as a sanity check before series is merged.
As an automated test it does not provide much meaningful signal.
> + int i, kfunc_id, ret, id;
> + const struct btf_type *t;
> + struct btf *btf = NULL;
> + const char *kfunc;
> + const char *tag;
> +
> + btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
> + if (!ASSERT_OK_PTR(btf, "btf_parse"))
> + return;
> + for (id = 0; id < btf__type_cnt(btf); ++id) {
> + t = btf__type_by_id(btf, id);
> + if (!t)
> + continue;
> + if (!btf_is_decl_tag(t))
> + continue;
> + tag = btf__name_by_offset(btf, t->name_off);
> + if (strcmp(tag, "bpf_kfunc") != 0)
> + continue;
> + kfunc_id = t->type;
> + t = btf__type_by_id(btf, kfunc_id);
> + if (!btf_is_func(t))
> + continue;
> + kfunc = btf__name_by_offset(btf, t->name_off);
> + for (i = 0; i < ARRAY_SIZE(program_types); ++i) {
> + ret = libbpf_probe_bpf_kfunc(program_types[i].code,
> + kfunc_id, -1, NULL);
> + if (ret < 0) {
> + ASSERT_FAIL("kfunc:%s use prog type:%d",
> + kfunc, program_types[i].code);
> + goto cleanup;
> + }
> + }
> + }
> +cleanup:
> + btf__free(btf);
> +}
^ permalink raw reply [flat|nested] 7+ messages in thread* Re: [PATCH bpf-next v8 4/4] selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests
2025-02-21 18:19 ` Eduard Zingerman
@ 2025-02-22 3:00 ` Tao Chen
0 siblings, 0 replies; 7+ messages in thread
From: Tao Chen @ 2025-02-22 3:00 UTC (permalink / raw)
To: Eduard Zingerman, ast, daniel, andrii, haoluo, jolsa, qmo
Cc: bpf, linux-kernel, chen.dylane, Tao Chen
在 2025/2/22 02:19, Eduard Zingerman 写道:
> On Sat, 2025-02-22 at 00:33 +0800, Tao Chen wrote:
>
> [...]
>
>> +static const struct {
>> + const char *name;
>> + int code;
>> +} program_types[] = {
>> +#define _T(n) { #n, BPF_PROG_TYPE_##n }
>> + _T(KPROBE),
>> + _T(XDP),
>> + _T(SYSCALL),
>> + _T(SCHED_CLS),
>> + _T(SCHED_ACT),
>> + _T(SK_SKB),
>> + _T(SOCKET_FILTER),
>> + _T(CGROUP_SKB),
>> + _T(LWT_OUT),
>> + _T(LWT_IN),
>> + _T(LWT_XMIT),
>> + _T(LWT_SEG6LOCAL),
>> + _T(NETFILTER),
>> + _T(CGROUP_SOCK_ADDR),
>> + _T(SCHED_ACT)
>> +#undef _T
>> +};
>> +
>> +void test_libbpf_probe_kfuncs_many(void)
>> +{
>
> Hi Tao,
>
> Sorry, probably some miscommunication from my side.
> I did not mean this test for inclusion, it was meant as a one time
> manual inspection of libbpf_probe_bpf_kfunc results.
> Just as a sanity check before series is merged.
> As an automated test it does not provide much meaningful signal.
>
Ok, i will resend v8 without this case, and check all the prog types
later with your program. Thanks.
>> + int i, kfunc_id, ret, id;
>> + const struct btf_type *t;
>> + struct btf *btf = NULL;
>> + const char *kfunc;
>> + const char *tag;
>> +
>> + btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
>> + if (!ASSERT_OK_PTR(btf, "btf_parse"))
>> + return;
>> + for (id = 0; id < btf__type_cnt(btf); ++id) {
>> + t = btf__type_by_id(btf, id);
>> + if (!t)
>> + continue;
>> + if (!btf_is_decl_tag(t))
>> + continue;
>> + tag = btf__name_by_offset(btf, t->name_off);
>> + if (strcmp(tag, "bpf_kfunc") != 0)
>> + continue;
>> + kfunc_id = t->type;
>> + t = btf__type_by_id(btf, kfunc_id);
>> + if (!btf_is_func(t))
>> + continue;
>> + kfunc = btf__name_by_offset(btf, t->name_off);
>> + for (i = 0; i < ARRAY_SIZE(program_types); ++i) {
>> + ret = libbpf_probe_bpf_kfunc(program_types[i].code,
>> + kfunc_id, -1, NULL);
>> + if (ret < 0) {
>> + ASSERT_FAIL("kfunc:%s use prog type:%d",
>> + kfunc, program_types[i].code);
>> + goto cleanup;
>> + }
>> + }
>> + }
>> +cleanup:
>> + btf__free(btf);
>> +}
>
>
--
Best Regards
Tao Chen
^ permalink raw reply [flat|nested] 7+ messages in thread