Add prog_kfunc feature probe
Subsystems (4)
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
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
@@ -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 helpeif (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
PATCH v4 2/4 libbpf: Init fd_array when prog probe load
In reply to Tao Chenfd_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
@@ -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 helpereturn -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
PATCH v4 3/4 libbpf: Add libbpf_probe_bpf_kfunc API
In reply to Tao ChenSimilarly 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
@@ -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
@@ -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
Eduard Zingerman
maintainerRe: [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_APIint libbpf_probe_bpf_helper(enumbpf_prog_typeprog_type,tools/lib/bpf/libbpf.h +7
-1enum 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
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@@ -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; + }
[...]
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_APIint libbpf_probe_bpf_helper(enumbpf_prog_typeprog_type,
enumbpf_func_idhelper_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--- 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@@ -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 casecheck_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 thefd_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
Re: [PATCH bpf-next v4 3/4] libbpf: Add libbpf_probe_bpf_kfunc API
In reply to Eduard ZingermanQuoted 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_APIint libbpf_probe_bpf_helper(enumbpf_prog_typeprog_type,
enumbpf_func_idhelper_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
-0tools/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@@ -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 casecheck_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 thefd_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
PATCH v4 4/4 selftests/bpf: Add libbpf_probe_bpf_kfunc API selftests
In reply to Tao ChenAdd 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
@@ -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