selftests/bpf: BPF test_prog selftests for bpf_loop inlining

Two new test BPF programs for test_prog selftests checking bpf_loop
behavior. Both are corner cases for bpf_loop inlinig transformation:
 - check that bpf_loop behaves correctly when callback function is not
   a compile time constant
 - check that local function variables are not affected by allocating
   additional stack storage for registers spilled by loop inlining

Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>
Acked-by: Song Liu <songliubraving@fb.com>
Link: https://lore.kernel.org/r/20220620235344.569325-6-eddyz87@gmail.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_loop.c b/tools/testing/selftests/bpf/prog_tests/bpf_loop.c
index 380d7a2..4cd8a25 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/bpf_loop.c
+++ b/tools/testing/selftests/bpf/prog_tests/bpf_loop.c
@@ -120,6 +120,64 @@ static void check_nested_calls(struct bpf_loop *skel)
        bpf_link__destroy(link);
 }
 
+static void check_non_constant_callback(struct bpf_loop *skel)
+{
+       struct bpf_link *link =
+               bpf_program__attach(skel->progs.prog_non_constant_callback);
+
+       if (!ASSERT_OK_PTR(link, "link"))
+               return;
+
+       skel->bss->callback_selector = 0x0F;
+       usleep(1);
+       ASSERT_EQ(skel->bss->g_output, 0x0F, "g_output #1");
+
+       skel->bss->callback_selector = 0xF0;
+       usleep(1);
+       ASSERT_EQ(skel->bss->g_output, 0xF0, "g_output #2");
+
+       bpf_link__destroy(link);
+}
+
+static void check_stack(struct bpf_loop *skel)
+{
+       struct bpf_link *link = bpf_program__attach(skel->progs.stack_check);
+       const int max_key = 12;
+       int key;
+       int map_fd;
+
+       if (!ASSERT_OK_PTR(link, "link"))
+               return;
+
+       map_fd = bpf_map__fd(skel->maps.map1);
+
+       if (!ASSERT_GE(map_fd, 0, "bpf_map__fd"))
+               goto out;
+
+       for (key = 1; key <= max_key; ++key) {
+               int val = key;
+               int err = bpf_map_update_elem(map_fd, &key, &val, BPF_NOEXIST);
+
+               if (!ASSERT_OK(err, "bpf_map_update_elem"))
+                       goto out;
+       }
+
+       usleep(1);
+
+       for (key = 1; key <= max_key; ++key) {
+               int val;
+               int err = bpf_map_lookup_elem(map_fd, &key, &val);
+
+               if (!ASSERT_OK(err, "bpf_map_lookup_elem"))
+                       goto out;
+               if (!ASSERT_EQ(val, key + 1, "bad value in the map"))
+                       goto out;
+       }
+
+out:
+       bpf_link__destroy(link);
+}
+
 void test_bpf_loop(void)
 {
        struct bpf_loop *skel;
@@ -140,6 +198,10 @@ void test_bpf_loop(void)
                check_invalid_flags(skel);
        if (test__start_subtest("check_nested_calls"))
                check_nested_calls(skel);
+       if (test__start_subtest("check_non_constant_callback"))
+               check_non_constant_callback(skel);
+       if (test__start_subtest("check_stack"))
+               check_stack(skel);
 
        bpf_loop__destroy(skel);
 }

diff --git a/tools/testing/selftests/bpf/progs/bpf_loop.c b/tools/testing/selftests/bpf/progs/bpf_loop.c
index e085652..de1fc82 100644 (file)
--- a/tools/testing/selftests/bpf/progs/bpf_loop.c
+++ b/tools/testing/selftests/bpf/progs/bpf_loop.c
@@ -11,11 +11,19 @@ struct callback_ctx {
        int output;
 };
 
+struct {
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, 32);
+       __type(key, int);
+       __type(value, int);
+} map1 SEC(".maps");
+
 /* These should be set by the user program */
 u32 nested_callback_nr_loops;
 u32 stop_index = -1;
 u32 nr_loops;
 int pid;
+int callback_selector;
 
 /* Making these global variables so that the userspace program
  * can verify the output through the skeleton
@@ -111,3 +119,109 @@ int prog_nested_calls(void *ctx)
 
        return 0;
 }
+
+static int callback_set_f0(int i, void *ctx)
+{
+       g_output = 0xF0;
+       return 0;
+}
+
+static int callback_set_0f(int i, void *ctx)
+{
+       g_output = 0x0F;
+       return 0;
+}
+
+/*
+ * non-constant callback is a corner case for bpf_loop inline logic
+ */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+int prog_non_constant_callback(void *ctx)
+{
+       struct callback_ctx data = {};
+
+       if (bpf_get_current_pid_tgid() >> 32 != pid)
+               return 0;
+
+       int (*callback)(int i, void *ctx);
+
+       g_output = 0;
+
+       if (callback_selector == 0x0F)
+               callback = callback_set_0f;
+       else
+               callback = callback_set_f0;
+
+       bpf_loop(1, callback, NULL, 0);
+
+       return 0;
+}
+
+static int stack_check_inner_callback(void *ctx)
+{
+       return 0;
+}
+
+static int map1_lookup_elem(int key)
+{
+       int *val = bpf_map_lookup_elem(&map1, &key);
+
+       return val ? *val : -1;
+}
+
+static void map1_update_elem(int key, int val)
+{
+       bpf_map_update_elem(&map1, &key, &val, BPF_ANY);
+}
+
+static int stack_check_outer_callback(void *ctx)
+{
+       int a = map1_lookup_elem(1);
+       int b = map1_lookup_elem(2);
+       int c = map1_lookup_elem(3);
+       int d = map1_lookup_elem(4);
+       int e = map1_lookup_elem(5);
+       int f = map1_lookup_elem(6);
+
+       bpf_loop(1, stack_check_inner_callback, NULL, 0);
+
+       map1_update_elem(1, a + 1);
+       map1_update_elem(2, b + 1);
+       map1_update_elem(3, c + 1);
+       map1_update_elem(4, d + 1);
+       map1_update_elem(5, e + 1);
+       map1_update_elem(6, f + 1);
+
+       return 0;
+}
+
+/* Some of the local variables in stack_check and
+ * stack_check_outer_callback would be allocated on stack by
+ * compiler. This test should verify that stack content for these
+ * variables is preserved between calls to bpf_loop (might be an issue
+ * if loop inlining allocates stack slots incorrectly).
+ */
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+int stack_check(void *ctx)
+{
+       if (bpf_get_current_pid_tgid() >> 32 != pid)
+               return 0;
+
+       int a = map1_lookup_elem(7);
+       int b = map1_lookup_elem(8);
+       int c = map1_lookup_elem(9);
+       int d = map1_lookup_elem(10);
+       int e = map1_lookup_elem(11);
+       int f = map1_lookup_elem(12);
+
+       bpf_loop(1, stack_check_outer_callback, NULL, 0);
+
+       map1_update_elem(7,  a + 1);
+       map1_update_elem(8, b + 1);
+       map1_update_elem(9, c + 1);
+       map1_update_elem(10, d + 1);
+       map1_update_elem(11, e + 1);
+       map1_update_elem(12, f + 1);
+
+       return 0;
+}