bpf: Fixes for kprobe multi on kernel modules
Jiri Olsa
reviewerv3 cover bpf: Fixes for kprobe multi on kernel modules
hi,
Martynas reported kprobe _multi link does not resolve symbols from kernel modules, which attach by address works.
In addition while fixing that I realized we do not take module reference if the module has kprobe_multi link on top of it and can be removed.
There's mo crash related to this, it will silently disappear from ftrace tables, while kprobe_multi link stays up with no data.
This patchset has fixes for both issues.
v3 changes:
- reorder fields in struct bpf_kprobe_multi_link [Andrii]
- added ack [Andrii]
v2 changes:
- added acks (Song)
- added comment to kallsyms_callback (Song)
- change module_callback realloc logic (Andrii)
- get rid of macros in tests (Andrii)
thanks,
jirka
---
Jiri Olsa (8):
kallsyms: Make module_kallsyms_on_each_symbol generally available
ftrace: Add support to resolve module symbols in ftrace_lookup_symbols
bpf: Rename __bpf_kprobe_multi_cookie_cmp to bpf_kprobe_multi_addrs_cmp
bpf: Take module reference on kprobe_multi link selftests/bpf: Add load_kallsyms_refresh function selftests/bpf: Add bpf_testmod_fentry_* functions selftests/bpf: Add kprobe_multi check to module attach test selftests/bpf: Add kprobe_multi kmod attach api tests
include/linux/module.h | 9 +++++++++ kernel/module/kallsyms.c | 2 -- kernel/trace/bpf_trace.c | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- kernel/trace/ftrace.c | 16 +++++++++++----- tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c | 24 ++++++++++++++++++++++++ tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ tools/testing/selftests/bpf/prog_tests/module_attach.c | 7 +++++++ tools/testing/selftests/bpf/progs/kprobe_multi.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ tools/testing/selftests/bpf/progs/test_module_attach.c | 6 ++++++ tools/testing/selftests/bpf/trace_helpers.c | 20 +++++++++++++------- tools/testing/selftests/bpf/trace_helpers.h | 2 ++ 11 files changed, 306 insertions(+), 17 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c
Jiri Olsa
reviewerPATCH v3 1/8 kallsyms: Make module_kallsyms_on_each_symbol generally available
Making module_kallsyms_on_each_symbol generally available, so it can be used outside CONFIG_LIVEPATCH option in following changes.
Rather than adding another ifdef option let's make the function generally available (when CONFIG_KALLSYMS and CONFIG_MODULES options are defined).
--- include/linux/module.h | 9 +++++++++ kernel/module/kallsyms.c | 2 -- 2 files changed, 9 insertions(+), 2 deletions(-)
include/linux/module.h +9 -0
@@ -879,8 +879,17 @@ static inline bool module_sig_ok(struct module *module) }#endif /* CONFIG_MODULE_SIG */ +#if defined(CONFIG_MODULES ) && defined(CONFIG_KALLSYMS )int module_kallsyms_on_each_symbol (int (*fn)(void *,const char *,struct module *,unsigned long ),void *data); +#else +static inline int module_kallsyms_on_each_symbol (int (*fn)(void *,const char *, +struct module *,unsigned long ), +void *data) +{ +return -EOPNOTSUPP ; +} +#endif /* CONFIG_MODULES && CONFIG_KALLSYMS */ #endif /* _LINUX_MODULE_H */
kernel/module/kallsyms.c +0 -2
@@ -494,7 +494,6 @@ unsigned long module_kallsyms_lookup_name(const char *name)return ret; } -#ifdef CONFIG_LIVEPATCH int module_kallsyms_on_each_symbol (int (*fn)(void *,const char *,struct module *,unsigned long ),void *data)
@@ -531,4 +530,3 @@ int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,mutex_unlock (&module_mutex);return ret; } -#endif /* CONFIG_LIVEPATCH */
Signature · 1 line
2.37.3
Jiri Olsa
reviewerPATCH v3 2/8 ftrace: Add support to resolve module symbols in ftrace_lookup_symbols
In reply to Jiri OlsaCurrently ftrace_lookup_symbols iterates only over core symbols, adding module_kallsyms_on_each_symbol call to check on modules symbols as well.
Also removing 'args.found == args.cnt' condition, because it's already checked in kallsyms_callback function.
Also removing 'err < 0' check, because both *kallsyms_on_each_symbol functions do not return error.
--- kernel/trace/ftrace.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-)
kernel/trace/ftrace.c +11 -5
@@ -8267,6 +8267,10 @@ struct kallsyms_data {size_t found; }; +/* This function gets called for all kernel and module symbols +* and returns 1 in case we resolved all the requested symbols, +* 0 otherwise. +*/ static int kallsyms_callback (void *data,const char *name,struct module *mod,unsigned long addr) {
@@ -8309,17 +8313,19 @@ static int kallsyms_callback(void *data, const char *name,int ftrace_lookup_symbols (const char **sorted_syms,size_t cnt,unsigned long *addrs) {struct kallsyms_data args; -int err; +int found_all;memset (addrs,0 ,sizeof (*addrs) * cnt); args.addrs = addrs; args.syms = sorted_syms; args.cnt = cnt; args.found =0 ; - err =kallsyms_on_each_symbol (kallsyms_callback, &args); -if (err <0 ) -return err; -return args.found == args.cnt ?0 : -ESRCH ; + + found_all =kallsyms_on_each_symbol (kallsyms_callback, &args); +if (found_all) +return 0 ; + found_all =module_kallsyms_on_each_symbol (kallsyms_callback, &args); +return found_all ?0 : -ESRCH ; }#ifdef CONFIG_SYSCTL
Signature · 1 line
2.37.3
Jiri Olsa
reviewerPATCH v3 3/8 bpf: Rename __bpf_kprobe_multi_cookie_cmp to bpf_kprobe_multi_addrs_cmp
In reply to Jiri OlsaRenaming __bpf_kprobe_multi_cookie_cmp to bpf_kprobe_multi_addrs_cmp, because it's more suitable to current and upcoming code.
--- kernel/trace/bpf_trace.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
kernel/trace/bpf_trace.c +3 -3
@@ -2550,7 +2550,7 @@ static void bpf_kprobe_multi_cookie_swap(void *a, void *b, int size, const voidswap (*cookie_a, *cookie_b); } -static int __bpf_kprobe_multi_cookie_cmp (const void *a,const void *b) +static int bpf_kprobe_multi_addrs_cmp (const void *a,const void *b) {const unsigned long *addr_a = a, *addr_b = b;
@@ -2561,7 +2561,7 @@ static int __bpf_kprobe_multi_cookie_cmp(const void *a, const void *b)static int bpf_kprobe_multi_cookie_cmp (const void *a,const void *b,const void *priv) { -return __bpf_kprobe_multi_cookie_cmp (a, b); +return bpf_kprobe_multi_addrs_cmp (a, b); }static u64 bpf_kprobe_multi_cookie (struct bpf_run_ctx *ctx)
@@ -2579,7 +2579,7 @@ static u64 bpf_kprobe_multi_cookie(struct bpf_run_ctx *ctx)return 0 ; entry_ip = run_ctx->entry_ip; addr =bsearch (&entry_ip, link->addrs, link->cnt,sizeof (entry_ip), - __bpf_kprobe_multi_cookie_cmp); + bpf_kprobe_multi_addrs_cmp);if (!addr)return 0 ; cookie = link->cookies + (addr - link->addrs);
Signature · 1 line
2.37.3
Jiri Olsa
reviewerPATCH v3 4/8 bpf: Take module reference on kprobe_multi link
In reply to Jiri OlsaCurrently we allow to create kprobe multi link on function from kernel module, but we don't take the module reference to ensure it's not unloaded while we are tracing it.
The multi kprobe link is based on fprobe/ftrace layer which takes different approach and releases ftrace hooks when module is unloaded even if there's tracer registered on top of it.
Adding code that gathers all the related modules for the link and takes their references before it's attached. All kernel module references are released after link is unregistered.
Note that we do it the same way already for trampoline probes (but for single address).
--- kernel/trace/bpf_trace.c | 92 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+)
kernel/trace/bpf_trace.c +92 -0
@@ -2452,6 +2452,8 @@ struct bpf_kprobe_multi_link {unsigned long *addrs;u64 *cookies;u32 cnt; +u32 mods_cnt; +struct module **mods; };struct bpf_kprobe_multi_run_ctx {
@@ -2507,6 +2509,14 @@ static int copy_user_syms(struct user_syms *us, unsigned long __user *usyms, u32return err; } +static void kprobe_multi_put_modules (struct module **mods,u32 cnt) +{ +u32 i; + +for (i =0 ; i < cnt; i++) +module_put (mods[i]); +} +static void free_user_syms (struct user_syms *us) {kvfree (us->syms);
@@ -2519,6 +2529,7 @@ static void bpf_kprobe_multi_link_release(struct bpf_link *link) kmulti_link = container_of(link, struct bpf_kprobe_multi_link, link);unregister_fprobe (&kmulti_link->fp); +kprobe_multi_put_modules (kmulti_link->mods, kmulti_link->mods_cnt); }static void bpf_kprobe_multi_link_dealloc (struct bpf_link *link)
@@ -2528,6 +2539,7 @@ static void bpf_kprobe_multi_link_dealloc(struct bpf_link *link) kmulti_link = container_of(link, struct bpf_kprobe_multi_link, link);kvfree (kmulti_link->addrs);kvfree (kmulti_link->cookies); +kfree (kmulti_link->mods);kfree (kmulti_link); }
@@ -2663,6 +2675,71 @@ static void symbols_swap_r(void *a, void *b, int size, const void *priv) } } +struct module_addr_args { +unsigned long *addrs; +u32 addrs_cnt; +struct module **mods; +int mods_cnt; +int mods_cap; +}; + +static int module_callback (void *data,const char *name, +struct module *mod,unsigned long addr) +{ +struct module_addr_args *args = data; +struct module **mods; + +/* We iterate all modules symbols and for each we: +* - search for it in provided addresses array +* - if found we check if we already have the module pointer stored +* (we iterate modules sequentially, so we can check just the last +* module pointer) +* - take module reference and store it +*/ +if (!bsearch (&addr, args->addrs, args->addrs_cnt,sizeof (addr), + bpf_kprobe_multi_addrs_cmp)) +return 0 ; + +if (args->mods && args->mods[args->mods_cnt -1 ] == mod) +return 0 ; + +if (args->mods_cnt == args->mods_cap) { + args->mods_cap =max (16 , args->mods_cap *3 /2 ); + mods =krealloc_array (args->mods, args->mods_cap,sizeof (*mods),GFP_KERNEL ); +if (!mods) +return -ENOMEM ; + args->mods = mods; + } + +if (!try_module_get (mod)) +return -EINVAL ; + + args->mods[args->mods_cnt] = mod; + args->mods_cnt++; +return 0 ; +} + +static int get_modules_for_addrs (struct module ***mods,unsigned long *addrs,u32 addrs_cnt) +{ +struct module_addr_args args = { + .addrs = addrs, + .addrs_cnt = addrs_cnt, + }; +int err; + +/* We return either err < 0 in case of error, ... */ + err =module_kallsyms_on_each_symbol (module_callback, &args); +if (err) { +kprobe_multi_put_modules (args.mods, args.mods_cnt); +kfree (args.mods); +return err; + } + +/* or number of modules found if everything is ok. */ + *mods = args.mods; +return args.mods_cnt; +} +int bpf_kprobe_multi_link_attach (const union bpf_attr *attr,struct bpf_prog *prog) {struct bpf_kprobe_multi_link *link =NULL ;
@@ -2773,10 +2850,25 @@ int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *pr bpf_kprobe_multi_cookie_cmp, bpf_kprobe_multi_cookie_swap, link); + }else { +/* +* We need to sort addrs array even if there are no cookies +* provided, to allow bsearch in get_modules_for_addrs. +*/ +sort (addrs, cnt,sizeof (*addrs), + bpf_kprobe_multi_addrs_cmp,NULL ); + } + + err =get_modules_for_addrs (&link->mods, addrs, cnt); +if (err <0 ) { +bpf_link_cleanup (&link_primer); +return err; } + link->mods_cnt = err; err =register_fprobe_ips (&link->fp, addrs, cnt);if (err) { +kprobe_multi_put_modules (link->mods, link->mods_cnt);bpf_link_cleanup (&link_primer);return err; }
Signature · 1 line
2.37.3
Jiri Olsa
reviewerPATCH v3 5/8 selftests/bpf: Add load_kallsyms_refresh function
In reply to Jiri OlsaAdding load_kallsyms_refresh function to re-read symbols from /proc/kallsyms file.
This will be needed to get proper functions addresses from bpf_testmod.ko module, which is loaded/unloaded several times during the tests run, so symbols might be already old when we need to use them.
--- tools/testing/selftests/bpf/trace_helpers.c | 20 +++++++++++++------- tools/testing/selftests/bpf/trace_helpers.h | 2 ++ 2 files changed, 15 insertions(+), 7 deletions(-)
tools/testing/selftests/bpf/trace_helpers.c +13 -7
@@ -23,7 +23,7 @@ static int ksym_cmp(const void *p1, const void *p2)return ((struct ksym *)p1)->addr - ((struct ksym *)p2)->addr; } -int load_kallsyms (void ) +int load_kallsyms_refresh (void ) {FILE *f;char func[256 ], buf[256 ];
@@ -31,12 +31,7 @@ int load_kallsyms(void)void *addr;int i =0 ; -/* -* This is called/used from multiplace places, -* load symbols just once. -*/ -if (sym_cnt) -return 0 ; + sym_cnt =0 ; f =fopen ("/proc/kallsyms" ,"r" );if (!f)
@@ -57,6 +52,17 @@ int load_kallsyms(void)return 0 ; } +int load_kallsyms (void ) +{ +/* +* This is called/used from multiplace places, +* load symbols just once. +*/ +if (sym_cnt) +return 0 ; +return load_kallsyms_refresh (); +} +struct ksym *ksym_search (long key) {int start =0 , end = sym_cnt;
tools/testing/selftests/bpf/trace_helpers.h +2 -0
@@ -10,6 +10,8 @@ struct ksym { };int load_kallsyms (void ); +int load_kallsyms_refresh (void ); +struct ksym *ksym_search (long key);long ksym_get_addr (const char *name);
Signature · 1 line
2.37.3
Jiri Olsa
reviewerPATCH v3 6/8 selftests/bpf: Add bpf_testmod_fentry_* functions
In reply to Jiri OlsaAdding 3 bpf_testmod_fentry_* functions to have a way to test kprobe multi link on kernel module. They follow bpf_fentry_test* functions prototypes/code.
Adding equivalent functions to all bpf_fentry_test* does not seems necessary at the moment, could be added later.
--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+)
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +24 -0
@@ -128,6 +128,23 @@ __weak noinline struct file *bpf_testmod_return_ptr(int arg) } } +noinline int bpf_testmod_fentry_test1(int a) +{ +return a +1 ; +} + +noinline int bpf_testmod_fentry_test2(int a, u64 b) +{ +return a + b; +} + +noinline int bpf_testmod_fentry_test3(char a, int b, u64 c) +{ +return a + b + c; +} + +int bpf_testmod_fentry_ok; + noinline ssize_t bpf_testmod_test_read(struct file *file, struct kobject *kobj, struct bin_attribute *bin_attr,
@@ -167,6 +184,13 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj,return snprintf (buf, len,"%d\n" , writable.val); } +if (bpf_testmod_fentry_test1 (1 ) !=2 || +bpf_testmod_fentry_test2 (2 ,3 ) !=5 || +bpf_testmod_fentry_test3 (4 ,5 ,6 ) !=15 ) + goto out; + + bpf_testmod_fentry_ok =1 ; +out:return -EIO ;/* always fail */ }EXPORT_SYMBOL (bpf_testmod_test_read);
Signature · 1 line
2.37.3
Jiri Olsa
reviewerPATCH v3 7/8 selftests/bpf: Add kprobe_multi check to module attach test
In reply to Jiri OlsaAdding test that makes sure the kernel module won't be removed if there's kprobe multi link defined on top of it.
--- tools/testing/selftests/bpf/prog_tests/module_attach.c | 7 +++++++ tools/testing/selftests/bpf/progs/test_module_attach.c | 6 ++++++ 2 files changed, 13 insertions(+)
tools/testing/selftests/bpf/prog_tests/module_attach.c +7 -0
@@ -103,6 +103,13 @@ void test_module_attach(void)ASSERT_ERR (delete_module ("bpf_testmod" ,0 ),"delete_module" );bpf_link__destroy (link); + link =bpf_program__attach (skel->progs.kprobe_multi); +if (!ASSERT_OK_PTR (link,"attach_kprobe_multi" )) + goto cleanup; + +ASSERT_ERR (delete_module ("bpf_testmod" ,0 ),"delete_module" ); +bpf_link__destroy (link); + cleanup:test_module_attach__destroy (skel); }
tools/testing/selftests/bpf/progs/test_module_attach.c +6 -0
@@ -110,4 +110,10 @@ int BPF_PROG(handle_fmod_ret,return 0 ;/* don't override the exit code */ } +SEC("kprobe.multi/bpf_testmod_test_read") +int BPF_PROG (kprobe_multi ) +{ +return 0 ; +} + char _license[] SEC("license") = "GPL";
Signature · 1 line
2.37.3
Jiri Olsa
reviewerPATCH v3 8/8 selftests/bpf: Add kprobe_multi kmod attach api tests
In reply to Jiri OlsaAdding kprobe_multi kmod attach api tests that attach bpf_testmod functions via bpf_program__attach_kprobe_multi_opts.
Running it as serial test, because we don't want other tests to reload bpf_testmod while it's running.
--- .../prog_tests/kprobe_multi_testmod_test.c | 89 +++++++++++++++++++ .../selftests/bpf/progs/kprobe_multi.c | 50 +++++++++++ 2 files changed, 139 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c
tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c new file +89 -0
@@ -0,0 +1,89 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <test_progs.h> +#include "kprobe_multi.skel.h" +#include "trace_helpers.h" +#include "bpf/libbpf_internal.h" + +static void kprobe_multi_testmod_check (struct kprobe_multi *skel) +{ +ASSERT_EQ (skel->bss->kprobe_testmod_test1_result,1 ,"kprobe_test1_result" ); +ASSERT_EQ (skel->bss->kprobe_testmod_test2_result,1 ,"kprobe_test2_result" ); +ASSERT_EQ (skel->bss->kprobe_testmod_test3_result,1 ,"kprobe_test3_result" ); + +ASSERT_EQ (skel->bss->kretprobe_testmod_test1_result,1 ,"kretprobe_test1_result" ); +ASSERT_EQ (skel->bss->kretprobe_testmod_test2_result,1 ,"kretprobe_test2_result" ); +ASSERT_EQ (skel->bss->kretprobe_testmod_test3_result,1 ,"kretprobe_test3_result" ); +} + +static void test_testmod_attach_api (struct bpf_kprobe_multi_opts *opts) +{ +struct kprobe_multi *skel =NULL ; + + skel =kprobe_multi__open_and_load (); +if (!ASSERT_OK_PTR (skel,"fentry_raw_skel_load" )) +return ; + + skel->bss->pid =getpid (); + + skel->links.test_kprobe_testmod =bpf_program__attach_kprobe_multi_opts ( + skel->progs.test_kprobe_testmod, +NULL , opts); +if (!skel->links.test_kprobe_testmod) + goto cleanup; + + opts->retprobe = true; + skel->links.test_kretprobe_testmod =bpf_program__attach_kprobe_multi_opts ( + skel->progs.test_kretprobe_testmod, +NULL , opts); +if (!skel->links.test_kretprobe_testmod) + goto cleanup; + +ASSERT_OK (trigger_module_test_read (1 ),"trigger_read" ); +kprobe_multi_testmod_check (skel); + +cleanup: +kprobe_multi__destroy (skel); +} + +static void test_testmod_attach_api_addrs (void ) +{ +LIBBPF_OPTS (bpf_kprobe_multi_opts, opts); +unsigned long long addrs[3 ]; + + addrs[0 ] =ksym_get_addr ("bpf_testmod_fentry_test1" ); +ASSERT_NEQ (addrs[0 ],0 ,"ksym_get_addr" ); + addrs[1 ] =ksym_get_addr ("bpf_testmod_fentry_test2" ); +ASSERT_NEQ (addrs[1 ],0 ,"ksym_get_addr" ); + addrs[2 ] =ksym_get_addr ("bpf_testmod_fentry_test3" ); +ASSERT_NEQ (addrs[2 ],0 ,"ksym_get_addr" ); + + opts.addrs = (const unsigned long *) addrs; + opts.cnt =ARRAY_SIZE (addrs); + +test_testmod_attach_api (&opts); +} + +static void test_testmod_attach_api_syms (void ) +{ +LIBBPF_OPTS (bpf_kprobe_multi_opts, opts); +const char *syms[3 ] = { +"bpf_testmod_fentry_test1" , +"bpf_testmod_fentry_test2" , +"bpf_testmod_fentry_test3" , + }; + + opts.syms = syms; + opts.cnt =ARRAY_SIZE (syms); +test_testmod_attach_api (&opts); +} + +void serial_test_kprobe_multi_testmod_test (void ) +{ +if (!ASSERT_OK (load_kallsyms_refresh (),"load_kallsyms_refresh" )) +return ; + +if (test__start_subtest ("testmod_attach_api_syms" )) +test_testmod_attach_api_syms (); +if (test__start_subtest ("testmod_attach_api_addrs" )) +test_testmod_attach_api_addrs (); +}
tools/testing/selftests/bpf/progs/kprobe_multi.c +50 -0
53 lines not on this page · raw message
Signature · 1 line
2.37.3
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 9 lines · On Tue, 25 Oct 2022 15:41:40 +0200 you wrote:
hi,
Martynas reported kprobe_multilink does not resolve symbols from kernel modules, which attach by address works.In addition while fixing that I realized we do not take module reference if the module has
kprobe_multilink on top of it and can be removed.[...]
Here is the summary with links:
- [PATCHv3,bpf-next,1/8] kallsyms: Make module_kallsyms_on_each_symbol generally available
https://git.kernel.org/bpf/bpf-next/c/73feb8d5fa3b - [PATCHv3,bpf-next,2/8] ftrace: Add support to resolve module symbols in ftrace_lookup_symbols https://git.kernel.org/bpf/bpf-next/c/3640bf8584f4 - [PATCHv3,bpf-next,3/8] bpf: Rename __bpf_kprobe_multi_cookie_cmp to bpf_kprobe_multi_addrs_cmp https://git.kernel.org/bpf/bpf-next/c/1a1b0716d36d - [PATCHv3,bpf-next,4/8] bpf: Take module reference on kprobe_multi link https://git.kernel.org/bpf/bpf-next/c/e22061b2d309 - [PATCHv3,bpf-next,5/8] selftests/bpf: Add load_kallsyms_refresh function https://git.kernel.org/bpf/bpf-next/c/10705b2b7a8e - [PATCHv3,bpf-next,6/8] selftests/bpf: Add bpf_testmod_fentry_* functions https://git.kernel.org/bpf/bpf-next/c/fee356ede980 - [PATCHv3,bpf-next,7/8] selftests/bpf: Add kprobe_multi check to module attach test https://git.kernel.org/bpf/bpf-next/c/e697d8dcebd2 - [PATCHv3,bpf-next,8/8] selftests/bpf: Add kprobe_multi kmod attach api tests https://git.kernel.org/bpf/bpf-next/c/b2440443a64f
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html