selftests/bpf: Add union argument tests using fexit programs

Add test coverage for union argument support using fexit programs:

* 8B union argument - verify that the verifier accepts it and that fexit
  programs can trace such functions.
* 16B union argument - verify that the verifier accepts it and that
  fexit programs can access the argument, which is passed using two
  registers.

Signed-off-by: Leon Hwang <leon.hwang@linux.dev>
Link: https://lore.kernel.org/r/20250919044110.23729-3-leon.hwang@linux.dev
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/prog_tests/tracing_struct.c b/tools/testing/selftests/bpf/prog_tests/tracing_struct.c
index 19e68d4b353278bf8e2917e62f62c89d14d7fe80..6f8c0bfb041559bb6d2ad5e6d8c6c3cfb310448d 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/tracing_struct.c
+++ b/tools/testing/selftests/bpf/prog_tests/tracing_struct.c
@@ -112,10 +112,39 @@ destroy_skel:
        tracing_struct_many_args__destroy(skel);
 }
 
+static void test_union_args(void)
+{
+       struct tracing_struct *skel;
+       int err;
+
+       skel = tracing_struct__open_and_load();
+       if (!ASSERT_OK_PTR(skel, "tracing_struct__open_and_load"))
+               return;
+
+       err = tracing_struct__attach(skel);
+       if (!ASSERT_OK(err, "tracing_struct__attach"))
+               goto out;
+
+       ASSERT_OK(trigger_module_test_read(256), "trigger_read");
+
+       ASSERT_EQ(skel->bss->ut1_a_a, 1, "ut1:a.arg.a");
+       ASSERT_EQ(skel->bss->ut1_b, 4, "ut1:b");
+       ASSERT_EQ(skel->bss->ut1_c, 5, "ut1:c");
+
+       ASSERT_EQ(skel->bss->ut2_a, 6, "ut2:a");
+       ASSERT_EQ(skel->bss->ut2_b_a, 2, "ut2:b.arg.a");
+       ASSERT_EQ(skel->bss->ut2_b_b, 3, "ut2:b.arg.b");
+
+out:
+       tracing_struct__destroy(skel);
+}
+
 void test_tracing_struct(void)
 {
        if (test__start_subtest("struct_args"))
                test_struct_args();
        if (test__start_subtest("struct_many_args"))
                test_struct_many_args();
+       if (test__start_subtest("union_args"))
+               test_union_args();
 }

diff --git a/tools/testing/selftests/bpf/progs/tracing_struct.c b/tools/testing/selftests/bpf/progs/tracing_struct.c
index c435a3a8328ab1580c63967a7f0ab779aa7ca4d4..d460732e20239540b18d64af2e6af715a3ef421a 100644 (file)
--- a/tools/testing/selftests/bpf/progs/tracing_struct.c
+++ b/tools/testing/selftests/bpf/progs/tracing_struct.c
@@ -18,6 +18,18 @@ struct bpf_testmod_struct_arg_3 {
        int b[];
 };
 
+union bpf_testmod_union_arg_1 {
+       char a;
+       short b;
+       struct bpf_testmod_struct_arg_1 arg;
+};
+
+union bpf_testmod_union_arg_2 {
+       int a;
+       long b;
+       struct bpf_testmod_struct_arg_2 arg;
+};
+
 long t1_a_a, t1_a_b, t1_b, t1_c, t1_ret, t1_nregs;
 __u64 t1_reg0, t1_reg1, t1_reg2, t1_reg3;
 long t2_a, t2_b_a, t2_b_b, t2_c, t2_ret;
@@ -26,6 +38,9 @@ long t4_a_a, t4_b, t4_c, t4_d, t4_e_a, t4_e_b, t4_ret;
 long t5_ret;
 int t6;
 
+long ut1_a_a, ut1_b, ut1_c;
+long ut2_a, ut2_b_a, ut2_b_b;
+
 SEC("fentry/bpf_testmod_test_struct_arg_1")
 int BPF_PROG2(test_struct_arg_1, struct bpf_testmod_struct_arg_2, a, int, b, int, c)
 {
@@ -130,4 +145,22 @@ int BPF_PROG2(test_struct_arg_11, struct bpf_testmod_struct_arg_3 *, a)
        return 0;
 }
 
+SEC("fexit/bpf_testmod_test_union_arg_1")
+int BPF_PROG2(test_union_arg_1, union bpf_testmod_union_arg_1, a, int, b, int, c)
+{
+       ut1_a_a = a.arg.a;
+       ut1_b = b;
+       ut1_c = c;
+       return 0;
+}
+
+SEC("fexit/bpf_testmod_test_union_arg_2")
+int BPF_PROG2(test_union_arg_2, int, a, union bpf_testmod_union_arg_2, b)
+{
+       ut2_a = a;
+       ut2_b_a = b.arg.a;
+       ut2_b_b = b.arg.b;
+       return 0;
+}
+
 char _license[] SEC("license") = "GPL";

diff --git a/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c b/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
index d6ce51df9ed4a22d08a74a9cf9b121217ecddd9d..6df6475f5dbc2ceff69d2775b585449522820475 100644 (file)
--- a/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
+++ b/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
@@ -62,6 +62,18 @@ struct bpf_testmod_struct_arg_5 {
        long d;
 };
 
+union bpf_testmod_union_arg_1 {
+       char a;
+       short b;
+       struct bpf_testmod_struct_arg_1 arg;
+};
+
+union bpf_testmod_union_arg_2 {
+       int a;
+       long b;
+       struct bpf_testmod_struct_arg_2 arg;
+};
+
 __bpf_hook_start();
 
 noinline int
@@ -128,6 +140,20 @@ bpf_testmod_test_struct_arg_9(u64 a, void *b, short c, int d, void *e, char f,
        return bpf_testmod_test_struct_arg_result;
 }
 
+noinline int
+bpf_testmod_test_union_arg_1(union bpf_testmod_union_arg_1 a, int b, int c)
+{
+       bpf_testmod_test_struct_arg_result = a.arg.a + b + c;
+       return bpf_testmod_test_struct_arg_result;
+}
+
+noinline int
+bpf_testmod_test_union_arg_2(int a, union bpf_testmod_union_arg_2 b)
+{
+       bpf_testmod_test_struct_arg_result = a + b.arg.a + b.arg.b;
+       return bpf_testmod_test_struct_arg_result;
+}
+
 noinline int
 bpf_testmod_test_arg_ptr_to_struct(struct bpf_testmod_struct_arg_1 *a) {
        bpf_testmod_test_struct_arg_result = a->a;
@@ -408,6 +434,8 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj,
        struct bpf_testmod_struct_arg_3 *struct_arg3;
        struct bpf_testmod_struct_arg_4 struct_arg4 = {21, 22};
        struct bpf_testmod_struct_arg_5 struct_arg5 = {23, 24, 25, 26};
+       union bpf_testmod_union_arg_1 union_arg1 = { .arg = {1} };
+       union bpf_testmod_union_arg_2 union_arg2 = { .arg = {2, 3} };
        int i = 1;
 
        while (bpf_testmod_return_ptr(i))
@@ -425,6 +453,9 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj,
        (void)bpf_testmod_test_struct_arg_9(16, (void *)17, 18, 19, (void *)20,
                                            21, 22, struct_arg5, 27);
 
+       (void)bpf_testmod_test_union_arg_1(union_arg1, 4, 5);
+       (void)bpf_testmod_test_union_arg_2(6, union_arg2);
+
        (void)bpf_testmod_test_arg_ptr_to_struct(&struct_arg1_2);
 
        (void)trace_bpf_testmod_test_raw_tp_null_tp(NULL);