Add a selftest to ensure that kprobe_multi programs cannot be attached using the BPF_F_SLEEPABLE flag. This test succeeds when the kernel rejects attachment of kprobe_multi when the BPF_F_SLEEPABLE flag is set.
Suggested-by: Leon Hwang <[email protected]> Signed-off-by: Varun R Mallya <[email protected]> --- .../bpf/prog_tests/kprobe_multi_test.c | 78 ++++++++++++++++++- .../bpf/progs/kprobe_multi_sleepable.c | 25 ++++++ 2 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/progs/kprobe_multi_sleepable.c diff --git a/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c b/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c index 78c974d4ea33..e4f9021a84ed 100644 --- a/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c +++ b/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c @@ -10,6 +10,7 @@ #include "kprobe_multi_session_cookie.skel.h" #include "kprobe_multi_verifier.skel.h" #include "kprobe_write_ctx.skel.h" +#include "kprobe_multi_sleepable.skel.h" #include "bpf/libbpf_internal.h" #include "bpf/hashmap.h" @@ -220,7 +221,9 @@ static void test_attach_api_syms(void) static void test_attach_api_fails(void) { LIBBPF_OPTS(bpf_kprobe_multi_opts, opts); + LIBBPF_OPTS(bpf_test_run_opts, topts); struct kprobe_multi *skel = NULL; + struct kprobe_multi_sleepable *sl_skel = NULL; struct bpf_link *link = NULL; unsigned long long addrs[2]; const char *syms[2] = { @@ -228,7 +231,7 @@ static void test_attach_api_fails(void) "bpf_fentry_test2", }; __u64 cookies[2]; - int saved_error; + int saved_error, err; addrs[0] = ksym_get_addr("bpf_fentry_test1"); addrs[1] = ksym_get_addr("bpf_fentry_test2"); @@ -351,9 +354,39 @@ static void test_attach_api_fails(void) if (!ASSERT_EQ(saved_error, -ENOENT, "fail_8_error")) goto cleanup; + /* fail_9 - sleepable kprobe multi should not attach */ + sl_skel = kprobe_multi_sleepable__open(); + if (!ASSERT_OK_PTR(sl_skel, "sleep_skel_open")) + goto cleanup; + + sl_skel->bss->user_ptr = sl_skel; + + err = bpf_program__set_flags(sl_skel->progs.handle_kprobe_multi_sleepable, + BPF_F_SLEEPABLE); + if (!ASSERT_OK(err, "sleep_skel_set_flags")) + goto cleanup; + + err = kprobe_multi_sleepable__load(sl_skel); + if (!ASSERT_OK(err, "sleep_skel_load")) + goto cleanup; + + link = bpf_program__attach_kprobe_multi_opts(sl_skel->progs.handle_kprobe_multi_sleepable, + "bpf_fentry_test1", NULL); + saved_error = -errno; + + if (!ASSERT_ERR_PTR(link, "fail_9")) + goto cleanup; + + if (!ASSERT_EQ(saved_error, -EINVAL, "fail_9_error")) + goto cleanup; + + err = bpf_prog_test_run_opts(bpf_program__fd(sl_skel->progs.fentry), &topts); + ASSERT_OK(err, "bpf_prog_test_run_opts"); + cleanup: bpf_link__destroy(link); kprobe_multi__destroy(skel); + kprobe_multi_sleepable__destroy(sl_skel); } static void test_session_skel_api(void) @@ -609,6 +642,47 @@ static void test_override(void) kprobe_multi_override__destroy(skel); } +static void test_attach_multi_sleepable(void) +{ + struct kprobe_multi_sleepable *skel; + int err; + + LIBBPF_OPTS(bpf_test_run_opts, topts); + + skel = kprobe_multi_sleepable__open(); + if (!ASSERT_OK_PTR(skel, "kprobe_multi_sleepable__open")) + return; + + skel->bss->user_ptr = skel; + + err = bpf_program__set_flags(skel->progs.handle_kprobe_multi_sleepable, + BPF_F_SLEEPABLE); + if (!ASSERT_OK(err, "bpf_program__set_flags")) + goto cleanup; + + /* Load should succeed even with BPF_F_SLEEPABLE for KPROBE types */ + err = kprobe_multi_sleepable__load(skel); + if (!ASSERT_OK(err, "kprobe_multi_sleepable__load")) + goto cleanup; + + skel->links.handle_kprobe_multi_sleepable = + bpf_program__attach_kprobe_multi_opts(skel->progs.handle_kprobe_multi_sleepable, + "bpf_fentry_test1", NULL); + + ASSERT_EQ(libbpf_get_error(skel->links.handle_kprobe_multi_sleepable), + -EINVAL, "attach_multi_sleepable_err"); + + ASSERT_ERR_PTR(skel->links.handle_kprobe_multi_sleepable, + "bpf_program__attach_kprobe_multi_opts"); + + err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.fentry), &topts); + + ASSERT_OK(err, "bpf_prog_test_run_opts"); + +cleanup: + kprobe_multi_sleepable__destroy(skel); +} + #ifdef __x86_64__ static void test_attach_write_ctx(void) { @@ -676,5 +750,7 @@ void test_kprobe_multi_test(void) test_unique_match(); if (test__start_subtest("attach_write_ctx")) test_attach_write_ctx(); + if (test__start_subtest("attach_multi_sleepable")) + test_attach_multi_sleepable(); RUN_TESTS(kprobe_multi_verifier); } diff --git a/tools/testing/selftests/bpf/progs/kprobe_multi_sleepable.c b/tools/testing/selftests/bpf/progs/kprobe_multi_sleepable.c new file mode 100644 index 000000000000..932e1d9c72e2 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/kprobe_multi_sleepable.c @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +void *user_ptr = 0; + +SEC("kprobe.multi") +int handle_kprobe_multi_sleepable(struct pt_regs *ctx) +{ + int a, err; + + err = bpf_copy_from_user(&a, sizeof(a), user_ptr); + barrier_var(a); + return err; +} + +SEC("fentry/bpf_fentry_test1") +int BPF_PROG(fentry) +{ + return 0; +} + +char _license[] SEC("license") = "GPL"; -- 2.53.0
