Add testcases for BPF_TRACE_SESSION.
Signed-off-by: Menglong Dong <dongml2@chinatelecom.cn>
---
.../selftests/bpf/prog_tests/fsession_test.c | 136 +++++++++++++
.../selftests/bpf/progs/fsession_test.c | 178 ++++++++++++++++++
2 files changed, 314 insertions(+)
create mode 100644 tools/testing/selftests/bpf/prog_tests/fsession_test.c
create mode 100644 tools/testing/selftests/bpf/progs/fsession_test.c
diff --git a/tools/testing/selftests/bpf/prog_tests/fsession_test.c b/tools/testing/selftests/bpf/prog_tests/fsession_test.c
new file mode 100644
index 000000000000..e2913da57b38
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/fsession_test.c
@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2025 ChinaTelecom */
+#include <test_progs.h>
+#include "fsession_test.skel.h"
+
+static void test_fsession_basic(void)
+{
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+ struct fsession_test *skel = NULL;
+ int err, prog_fd;
+
+ skel = fsession_test__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "fsession_test__open_and_load"))
+ goto cleanup;
+
+ err = fsession_test__attach(skel);
+ if (!ASSERT_OK(err, "fsession_attach"))
+ goto cleanup;
+
+ /* Trigger test function calls */
+ prog_fd = bpf_program__fd(skel->progs.test1);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ if (!ASSERT_OK(err, "test_run_opts err"))
+ return;
+ if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
+ return;
+
+ /* Verify test1: both entry and exit are called */
+ ASSERT_EQ(skel->bss->test1_entry_called, 1, "test1_entry_called");
+ ASSERT_EQ(skel->bss->test1_exit_called, 1, "test1_exit_called");
+ ASSERT_EQ(skel->bss->test1_entry_result, 1, "test1_entry_result");
+ ASSERT_EQ(skel->bss->test1_exit_result, 1, "test1_exit_result");
+
+ /* Verify test2: entry is called but exit is blocked */
+ ASSERT_EQ(skel->bss->test2_entry_called, 1, "test2_entry_called");
+ ASSERT_EQ(skel->bss->test2_exit_called, 0, "test2_exit_not_called");
+ ASSERT_EQ(skel->bss->test2_entry_result, 1, "test2_entry_result");
+ ASSERT_EQ(skel->bss->test2_exit_result, 0, "test2_exit_result");
+
+ /* Verify test3: both entry and exit are called */
+ ASSERT_EQ(skel->bss->test3_entry_called, 1, "test3_entry_called");
+ ASSERT_EQ(skel->bss->test3_exit_called, 1, "test3_exit_called");
+ ASSERT_EQ(skel->bss->test3_entry_result, 1, "test3_entry_result");
+ ASSERT_EQ(skel->bss->test3_exit_result, 1, "test3_exit_result");
+
+ /* Verify test4: both entry and exit are called */
+ ASSERT_EQ(skel->bss->test4_entry_called, 1, "test4_entry_called");
+ ASSERT_EQ(skel->bss->test4_exit_called, 1, "test4_exit_called");
+ ASSERT_EQ(skel->bss->test4_entry_result, 1, "test4_entry_result");
+ ASSERT_EQ(skel->bss->test4_exit_result, 1, "test4_exit_result");
+
+ /* Verify test5: both entry and exit are called */
+ ASSERT_EQ(skel->bss->test5_entry_called, 1, "test5_entry_called");
+ ASSERT_EQ(skel->bss->test5_exit_called, 1, "test5_exit_called");
+ ASSERT_EQ(skel->bss->test5_entry_result, 1, "test5_entry_result");
+ ASSERT_EQ(skel->bss->test5_exit_result, 1, "test5_exit_result");
+
+ /* Verify test6: entry is called but exit is blocked */
+ ASSERT_EQ(skel->bss->test6_entry_called, 1, "test6_entry_called");
+ ASSERT_EQ(skel->bss->test6_exit_called, 0, "test6_exit_not_called");
+ ASSERT_EQ(skel->bss->test6_entry_result, 1, "test6_entry_result");
+ ASSERT_EQ(skel->bss->test6_exit_result, 0, "test6_exit_result");
+
+ /* Verify test7: entry is called but exit is blocked */
+ ASSERT_EQ(skel->bss->test7_entry_called, 1, "test7_entry_called");
+ ASSERT_EQ(skel->bss->test7_exit_called, 0, "test7_exit_not_called");
+ ASSERT_EQ(skel->bss->test7_entry_result, 1, "test7_entry_result");
+ ASSERT_EQ(skel->bss->test7_exit_result, 0, "test7_exit_result");
+
+cleanup:
+ fsession_test__destroy(skel);
+}
+
+static void test_fsession_reattach(void)
+{
+ struct fsession_test *skel = NULL;
+ int err, prog_fd;
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = fsession_test__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "fsession_test__open_and_load"))
+ goto cleanup;
+
+ /* First attach */
+ err = fsession_test__attach(skel);
+ if (!ASSERT_OK(err, "fsession_first_attach"))
+ goto cleanup;
+
+ /* Trigger test function calls */
+ prog_fd = bpf_program__fd(skel->progs.test1);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ if (!ASSERT_OK(err, "test_run_opts err"))
+ return;
+ if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
+ return;
+
+ /* Verify first call */
+ ASSERT_EQ(skel->bss->test1_entry_called, 1, "test1_entry_first");
+ ASSERT_EQ(skel->bss->test1_exit_called, 1, "test1_exit_first");
+
+ /* Detach */
+ fsession_test__detach(skel);
+
+ /* Reset counters */
+ memset(skel->bss, 0, sizeof(*skel->bss));
+
+ /* Second attach */
+ err = fsession_test__attach(skel);
+ if (!ASSERT_OK(err, "fsession_second_attach"))
+ goto cleanup;
+
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ if (!ASSERT_OK(err, "test_run_opts err"))
+ return;
+ if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
+ return;
+
+ /* Verify second call */
+ ASSERT_EQ(skel->bss->test1_entry_called, 1, "test1_entry_second");
+ ASSERT_EQ(skel->bss->test1_exit_called, 1, "test1_exit_second");
+
+cleanup:
+ fsession_test__destroy(skel);
+}
+
+void test_fsession_test(void)
+{
+#if !defined(__x86_64__)
+ test__skip();
+ return;
+#endif
+ if (test__start_subtest("fsession_basic"))
+ test_fsession_basic();
+ if (test__start_subtest("fsession_reattach"))
+ test_fsession_reattach();
+}
diff --git a/tools/testing/selftests/bpf/progs/fsession_test.c b/tools/testing/selftests/bpf/progs/fsession_test.c
new file mode 100644
index 000000000000..cce2b32f7c2c
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/fsession_test.c
@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2025 ChinaTelecom */
+#include <vmlinux.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+char _license[] SEC("license") = "GPL";
+
+__u64 test1_entry_result = 0;
+__u64 test1_exit_result = 0;
+__u64 test1_entry_called = 0;
+__u64 test1_exit_called = 0;
+
+SEC("fsession/bpf_fentry_test1")
+int BPF_PROG(test1, int a)
+{
+ bool is_exit = bpf_tracing_is_exit(ctx);
+
+ if (!is_exit) {
+ /* This is entry */
+ test1_entry_called = 1;
+ test1_entry_result = a == 1;
+ return 0; /* Return 0 to allow exit to be called */
+ }
+
+ /* This is exit */
+ test1_exit_called = 1;
+ test1_exit_result = a == 1;
+ return 0;
+}
+
+__u64 test2_entry_result = 0;
+__u64 test2_exit_result = 0;
+__u64 test2_entry_called = 0;
+__u64 test2_exit_called = 0;
+
+SEC("fsession/bpf_fentry_test2")
+int BPF_PROG(test2, int a, __u64 b)
+{
+ bool is_exit = bpf_tracing_is_exit(ctx);
+
+ if (!is_exit) {
+ /* This is entry */
+ test2_entry_called = 1;
+ test2_entry_result = a == 2 && b == 3;
+ return 1; /* Return non-zero value to block exit call */
+ }
+
+ /* This is exit - should not be called due to blocking */
+ test2_exit_called = 1;
+ test2_exit_result = a == 2 && b == 3;
+ return 0;
+}
+
+__u64 test3_entry_result = 0;
+__u64 test3_exit_result = 0;
+__u64 test3_entry_called = 0;
+__u64 test3_exit_called = 0;
+
+SEC("fsession/bpf_fentry_test3")
+int BPF_PROG(test3, char a, int b, __u64 c)
+{
+ bool is_exit = bpf_tracing_is_exit(ctx);
+
+ if (!is_exit) {
+ /* This is entry */
+ test3_entry_called = 1;
+ test3_entry_result = a == 4 && b == 5 && c == 6;
+ return 0; /* Allow exit to be called */
+ }
+
+ /* This is exit */
+ test3_exit_called = 1;
+ test3_exit_result = a == 4 && b == 5 && c == 6;
+ return 0;
+}
+
+__u64 test4_entry_result = 0;
+__u64 test4_exit_result = 0;
+__u64 test4_entry_called = 0;
+__u64 test4_exit_called = 0;
+
+SEC("fsession/bpf_fentry_test4")
+int BPF_PROG(test4, void *a, char b, int c, __u64 d)
+{
+ bool is_exit = bpf_tracing_is_exit(ctx);
+
+ if (!is_exit) {
+ /* This is entry */
+ test4_entry_called = 1;
+ test4_entry_result = a == (void *)7 && b == 8 && c == 9 && d == 10;
+ return 0; /* Allow exit to be called */
+ }
+
+ /* This is exit */
+ test4_exit_called = 1;
+ test4_exit_result = a == (void *)7 && b == 8 && c == 9 && d == 10;
+ return 0;
+}
+
+__u64 test5_entry_result = 0;
+__u64 test5_exit_result = 0;
+__u64 test5_entry_called = 0;
+__u64 test5_exit_called = 0;
+
+SEC("fsession/bpf_fentry_test7")
+int BPF_PROG(test5, struct bpf_fentry_test_t *arg)
+{
+ bool is_exit = bpf_tracing_is_exit(ctx);
+
+ if (!is_exit) {
+ /* This is entry */
+ test5_entry_called = 1;
+ if (!arg)
+ test5_entry_result = 1;
+ return 0; /* Allow exit to be called */
+ }
+
+ /* This is exit */
+ test5_exit_called = 1;
+ if (!arg)
+ test5_exit_result = 1;
+ return 0;
+}
+
+__u64 test6_entry_result = 0;
+__u64 test6_exit_result = 0;
+__u64 test6_entry_called = 0;
+__u64 test6_exit_called = 0;
+
+SEC("fsession/bpf_fentry_test5")
+int BPF_PROG(test6, __u64 a, void *b, short c, int d, __u64 e)
+{
+ bool is_exit = bpf_tracing_is_exit(ctx);
+
+ if (!is_exit) {
+ /* This is entry */
+ test6_entry_called = 1;
+ test6_entry_result = a == 11 && b == (void *)12 && c == 13 && d == 14 &&
+ e == 15;
+ /* Decide whether to block exit call based on condition */
+ if (a == 11)
+ return 1; /* Block exit call */
+ return 0;
+ }
+
+ /* This is exit - should not be called due to blocking */
+ test6_exit_called = 1;
+ test6_exit_result = a == 11 && b == (void *)12 && c == 13 && d == 14 &&
+ e == 15;
+ return 0;
+}
+
+__u64 test7_entry_result = 0;
+__u64 test7_exit_result = 0;
+__u64 test7_entry_called = 0;
+__u64 test7_exit_called = 0;
+
+SEC("fsession/bpf_fentry_test6")
+int BPF_PROG(test7, __u64 a, void *b, short c, int d, void *e, __u64 f)
+{
+ bool is_exit = bpf_tracing_is_exit(ctx);
+
+ if (!is_exit) {
+ /* This is entry */
+ test7_entry_called = 1;
+ test7_entry_result = a == 16 && b == (void *)17 && c == 18 && d == 19 &&
+ e == (void *)20 && f == 21;
+ /* Return non-zero to block exit call */
+ return 1;
+ }
+
+ /* This is exit - should not be called due to blocking */
+ test7_exit_called = 1;
+ test7_exit_result = a == 16 && b == (void *)17 && c == 18 && d == 19 &&
+ e == (void *)20 && f == 21;
+ return 0;
+}
--
2.51.0On Sat, Oct 18, 2025 at 10:21:24PM +0800, Menglong Dong wrote:
SNIP
> +static void test_fsession_reattach(void)
> +{
> + struct fsession_test *skel = NULL;
> + int err, prog_fd;
> + LIBBPF_OPTS(bpf_test_run_opts, topts);
> +
> + skel = fsession_test__open_and_load();
> + if (!ASSERT_OK_PTR(skel, "fsession_test__open_and_load"))
> + goto cleanup;
> +
> + /* First attach */
> + err = fsession_test__attach(skel);
> + if (!ASSERT_OK(err, "fsession_first_attach"))
> + goto cleanup;
> +
> + /* Trigger test function calls */
> + prog_fd = bpf_program__fd(skel->progs.test1);
> + err = bpf_prog_test_run_opts(prog_fd, &topts);
> + if (!ASSERT_OK(err, "test_run_opts err"))
> + return;
goto cleanup
> + if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
> + return;
goto cleanup
> +
> + /* Verify first call */
> + ASSERT_EQ(skel->bss->test1_entry_called, 1, "test1_entry_first");
> + ASSERT_EQ(skel->bss->test1_exit_called, 1, "test1_exit_first");
> +
> + /* Detach */
> + fsession_test__detach(skel);
> +
> + /* Reset counters */
> + memset(skel->bss, 0, sizeof(*skel->bss));
> +
> + /* Second attach */
> + err = fsession_test__attach(skel);
> + if (!ASSERT_OK(err, "fsession_second_attach"))
> + goto cleanup;
> +
> + err = bpf_prog_test_run_opts(prog_fd, &topts);
> + if (!ASSERT_OK(err, "test_run_opts err"))
> + return;
goto cleanup
> + if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
> + return;
goto cleanup
> +
> + /* Verify second call */
> + ASSERT_EQ(skel->bss->test1_entry_called, 1, "test1_entry_second");
> + ASSERT_EQ(skel->bss->test1_exit_called, 1, "test1_exit_second");
> +
> +cleanup:
> + fsession_test__destroy(skel);
> +}
> +
> +void test_fsession_test(void)
> +{
> +#if !defined(__x86_64__)
> + test__skip();
> + return;
> +#endif
> + if (test__start_subtest("fsession_basic"))
> + test_fsession_basic();
> + if (test__start_subtest("fsession_reattach"))
> + test_fsession_reattach();
> +}
> diff --git a/tools/testing/selftests/bpf/progs/fsession_test.c b/tools/testing/selftests/bpf/progs/fsession_test.c
> new file mode 100644
> index 000000000000..cce2b32f7c2c
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/progs/fsession_test.c
> @@ -0,0 +1,178 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/* Copyright (c) 2025 ChinaTelecom */
> +#include <vmlinux.h>
> +#include <bpf/bpf_helpers.h>
> +#include <bpf/bpf_tracing.h>
> +
> +char _license[] SEC("license") = "GPL";
> +
> +__u64 test1_entry_result = 0;
> +__u64 test1_exit_result = 0;
> +__u64 test1_entry_called = 0;
> +__u64 test1_exit_called = 0;
> +
> +SEC("fsession/bpf_fentry_test1")
> +int BPF_PROG(test1, int a)
> +{
I guess we can access return argument directly but it makes sense only
for exit session program, or we could use bpf_get_func_ret
jirka
> + bool is_exit = bpf_tracing_is_exit(ctx);
> +
> + if (!is_exit) {
> + /* This is entry */
> + test1_entry_called = 1;
> + test1_entry_result = a == 1;
> + return 0; /* Return 0 to allow exit to be called */
> + }
> +
> + /* This is exit */
> + test1_exit_called = 1;
> + test1_exit_result = a == 1;
> + return 0;
> +}
> +
> +__u64 test2_entry_result = 0;
> +__u64 test2_exit_result = 0;
> +__u64 test2_entry_called = 0;
> +__u64 test2_exit_called = 0;
> +
SNIP
On 2025/10/20 16:19, Jiri Olsa wrote:
> On Sat, Oct 18, 2025 at 10:21:24PM +0800, Menglong Dong wrote:
>
> SNIP
>
> > +static void test_fsession_reattach(void)
> > +{
> > + struct fsession_test *skel = NULL;
> > + int err, prog_fd;
> > + LIBBPF_OPTS(bpf_test_run_opts, topts);
> > +
> > + skel = fsession_test__open_and_load();
> > + if (!ASSERT_OK_PTR(skel, "fsession_test__open_and_load"))
> > + goto cleanup;
> > +
> > + /* First attach */
> > + err = fsession_test__attach(skel);
> > + if (!ASSERT_OK(err, "fsession_first_attach"))
> > + goto cleanup;
> > +
> > + /* Trigger test function calls */
> > + prog_fd = bpf_program__fd(skel->progs.test1);
> > + err = bpf_prog_test_run_opts(prog_fd, &topts);
> > + if (!ASSERT_OK(err, "test_run_opts err"))
> > + return;
>
> goto cleanup
ACK.
>
> > + if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
> > + return;
>
> goto cleanup
ACK.
>
> > +
> > + /* Verify first call */
> > + ASSERT_EQ(skel->bss->test1_entry_called, 1, "test1_entry_first");
> > + ASSERT_EQ(skel->bss->test1_exit_called, 1, "test1_exit_first");
> > +
> > + /* Detach */
> > + fsession_test__detach(skel);
> > +
> > + /* Reset counters */
> > + memset(skel->bss, 0, sizeof(*skel->bss));
> > +
> > + /* Second attach */
> > + err = fsession_test__attach(skel);
> > + if (!ASSERT_OK(err, "fsession_second_attach"))
> > + goto cleanup;
> > +
> > + err = bpf_prog_test_run_opts(prog_fd, &topts);
> > + if (!ASSERT_OK(err, "test_run_opts err"))
> > + return;
>
> goto cleanup
ACK.
>
> > + if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
> > + return;
>
> goto cleanup
ACK.
>
> > +
> > + /* Verify second call */
> > + ASSERT_EQ(skel->bss->test1_entry_called, 1, "test1_entry_second");
> > + ASSERT_EQ(skel->bss->test1_exit_called, 1, "test1_exit_second");
> > +
> > +cleanup:
> > + fsession_test__destroy(skel);
> > +}
> > +
> > +void test_fsession_test(void)
> > +{
> > +#if !defined(__x86_64__)
> > + test__skip();
> > + return;
> > +#endif
> > + if (test__start_subtest("fsession_basic"))
> > + test_fsession_basic();
> > + if (test__start_subtest("fsession_reattach"))
> > + test_fsession_reattach();
> > +}
> > diff --git a/tools/testing/selftests/bpf/progs/fsession_test.c b/tools/testing/selftests/bpf/progs/fsession_test.c
> > new file mode 100644
> > index 000000000000..cce2b32f7c2c
> > --- /dev/null
> > +++ b/tools/testing/selftests/bpf/progs/fsession_test.c
> > @@ -0,0 +1,178 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/* Copyright (c) 2025 ChinaTelecom */
> > +#include <vmlinux.h>
> > +#include <bpf/bpf_helpers.h>
> > +#include <bpf/bpf_tracing.h>
> > +
> > +char _license[] SEC("license") = "GPL";
> > +
> > +__u64 test1_entry_result = 0;
> > +__u64 test1_exit_result = 0;
> > +__u64 test1_entry_called = 0;
> > +__u64 test1_exit_called = 0;
> > +
> > +SEC("fsession/bpf_fentry_test1")
> > +int BPF_PROG(test1, int a)
> > +{
>
> I guess we can access return argument directly but it makes sense only
> for exit session program, or we could use bpf_get_func_ret
Yeah, we can access the return value directly here or use
bpf_get_func_ret(). For fentry, it is also allow to access the return value.
It makes no sense to obtain the return value in the fentry, and
what it gets is just the previous fsession-fentry returned.
And it needs more effort in the verifier to forbid such operation.
The testcases is not complete, and I'll add more testcases in the
next version to cover more cases.
Thanks!
Menglong Dong
>
> jirka
>
>
> > + bool is_exit = bpf_tracing_is_exit(ctx);
> > +
> > + if (!is_exit) {
> > + /* This is entry */
> > + test1_entry_called = 1;
> > + test1_entry_result = a == 1;
> > + return 0; /* Return 0 to allow exit to be called */
> > + }
> > +
> > + /* This is exit */
> > + test1_exit_called = 1;
> > + test1_exit_result = a == 1;
> > + return 0;
> > +}
> > +
> > +__u64 test2_entry_result = 0;
> > +__u64 test2_exit_result = 0;
> > +__u64 test2_entry_called = 0;
> > +__u64 test2_exit_called = 0;
> > +
>
> SNIP
>
>
© 2016 - 2026 Red Hat, Inc.