selftests/bpf: Add failure test cases for spin lock pairing

First, ensure that whenever a bpf_spin_lock is present in an allocation,
the reg->id is preserved. This won't be true for global variables
however, since they have a single map value per map, hence the verifier
harcodes it to 0 (so that multiple pseudo ldimm64 insns can yield the
same lock object per map at a given offset).

Next, add test cases for all possible combinations (kptr, global, map
value, inner map value). Since we lifted restriction on locking in inner
maps, also add test cases for them. Currently, each lookup into an inner
map gets a fresh reg->id, so even if the reg->map_ptr is same, they will
be treated as separate allocations and the incorrect unlock pairing will
be rejected.

Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Link: https://lore.kernel.org/r/20221118015614.2013203-22-memxor@gmail.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/prog_tests/spin_lock.c b/tools/testing/selftests/bpf/prog_tests/spin_lock.c
index fab061e9d77c5f990290fccc4700546dcbaf710f..72282e92a78a22d66fdd340589eb4b897cf58166 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/spin_lock.c
+++ b/tools/testing/selftests/bpf/prog_tests/spin_lock.c
@@ -3,6 +3,79 @@
 #include <network_helpers.h>
 
 #include "test_spin_lock.skel.h"
+#include "test_spin_lock_fail.skel.h"
+
+static char log_buf[1024 * 1024];
+
+static struct {
+       const char *prog_name;
+       const char *err_msg;
+} spin_lock_fail_tests[] = {
+       { "lock_id_kptr_preserve",
+         "5: (bf) r1 = r0                       ; R0_w=ptr_foo(id=2,ref_obj_id=2,off=0,imm=0) "
+         "R1_w=ptr_foo(id=2,ref_obj_id=2,off=0,imm=0) refs=2\n6: (85) call bpf_this_cpu_ptr#154\n"
+         "R1 type=ptr_ expected=percpu_ptr_" },
+       { "lock_id_global_zero",
+         "; R1_w=map_value(off=0,ks=4,vs=4,imm=0)\n2: (85) call bpf_this_cpu_ptr#154\n"
+         "R1 type=map_value expected=percpu_ptr_" },
+       { "lock_id_mapval_preserve",
+         "8: (bf) r1 = r0                       ; R0_w=map_value(id=1,off=0,ks=4,vs=8,imm=0) "
+         "R1_w=map_value(id=1,off=0,ks=4,vs=8,imm=0)\n9: (85) call bpf_this_cpu_ptr#154\n"
+         "R1 type=map_value expected=percpu_ptr_" },
+       { "lock_id_innermapval_preserve",
+         "13: (bf) r1 = r0                      ; R0=map_value(id=2,off=0,ks=4,vs=8,imm=0) "
+         "R1_w=map_value(id=2,off=0,ks=4,vs=8,imm=0)\n14: (85) call bpf_this_cpu_ptr#154\n"
+         "R1 type=map_value expected=percpu_ptr_" },
+       { "lock_id_mismatch_kptr_kptr", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_kptr_global", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_kptr_mapval", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_kptr_innermapval", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_global_global", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_global_kptr", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_global_mapval", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_global_innermapval", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_mapval_mapval", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_mapval_kptr", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_mapval_global", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_mapval_innermapval", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_innermapval_innermapval1", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_innermapval_innermapval2", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_innermapval_kptr", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_innermapval_global", "bpf_spin_unlock of different lock" },
+       { "lock_id_mismatch_innermapval_mapval", "bpf_spin_unlock of different lock" },
+};
+
+static void test_spin_lock_fail_prog(const char *prog_name, const char *err_msg)
+{
+       LIBBPF_OPTS(bpf_object_open_opts, opts, .kernel_log_buf = log_buf,
+                                               .kernel_log_size = sizeof(log_buf),
+                                               .kernel_log_level = 1);
+       struct test_spin_lock_fail *skel;
+       struct bpf_program *prog;
+       int ret;
+
+       skel = test_spin_lock_fail__open_opts(&opts);
+       if (!ASSERT_OK_PTR(skel, "test_spin_lock_fail__open_opts"))
+               return;
+
+       prog = bpf_object__find_program_by_name(skel->obj, prog_name);
+       if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
+               goto end;
+
+       bpf_program__set_autoload(prog, true);
+
+       ret = test_spin_lock_fail__load(skel);
+       if (!ASSERT_ERR(ret, "test_spin_lock_fail__load must fail"))
+               goto end;
+
+       if (!ASSERT_OK_PTR(strstr(log_buf, err_msg), "expected error message")) {
+               fprintf(stderr, "Expected: %s\n", err_msg);
+               fprintf(stderr, "Verifier: %s\n", log_buf);
+       }
+
+end:
+       test_spin_lock_fail__destroy(skel);
+}
 
 static void *spin_lock_thread(void *arg)
 {
@@ -19,7 +92,7 @@ static void *spin_lock_thread(void *arg)
        pthread_exit(arg);
 }
 
-void test_spinlock(void)
+void test_spin_lock_success(void)
 {
        struct test_spin_lock *skel;
        pthread_t thread_id[4];
@@ -47,3 +120,17 @@ void test_spinlock(void)
 end:
        test_spin_lock__destroy(skel);
 }
+
+void test_spin_lock(void)
+{
+       int i;
+
+       test_spin_lock_success();
+
+       for (i = 0; i < ARRAY_SIZE(spin_lock_fail_tests); i++) {
+               if (!test__start_subtest(spin_lock_fail_tests[i].prog_name))
+                       continue;
+               test_spin_lock_fail_prog(spin_lock_fail_tests[i].prog_name,
+                                        spin_lock_fail_tests[i].err_msg);
+       }
+}

diff --git a/tools/testing/selftests/bpf/progs/test_spin_lock_fail.c b/tools/testing/selftests/bpf/progs/test_spin_lock_fail.c
new file mode 100644 (file)
index 0000000..86cd183
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/test_spin_lock_fail.c
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <vmlinux.h>
+#include <bpf/bpf_tracing.h>
+#include <bpf/bpf_helpers.h>
+#include "bpf_experimental.h"
+
+struct foo {
+       struct bpf_spin_lock lock;
+       int data;
+};
+
+struct array_map {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __type(key, int);
+       __type(value, struct foo);
+       __uint(max_entries, 1);
+} array_map SEC(".maps");
+
+struct {
+       __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
+       __uint(max_entries, 1);
+       __type(key, int);
+       __type(value, int);
+       __array(values, struct array_map);
+} map_of_maps SEC(".maps") = {
+       .values = {
+               [0] = &array_map,
+       },
+};
+
+SEC(".data.A") struct bpf_spin_lock lockA;
+SEC(".data.B") struct bpf_spin_lock lockB;
+
+SEC("?tc")
+int lock_id_kptr_preserve(void *ctx)
+{
+       struct foo *f;
+
+       f = bpf_obj_new(typeof(*f));
+       if (!f)
+               return 0;
+       bpf_this_cpu_ptr(f);
+       return 0;
+}
+
+SEC("?tc")
+int lock_id_global_zero(void *ctx)
+{
+       bpf_this_cpu_ptr(&lockA);
+       return 0;
+}
+
+SEC("?tc")
+int lock_id_mapval_preserve(void *ctx)
+{
+       struct foo *f;
+       int key = 0;
+
+       f = bpf_map_lookup_elem(&array_map, &key);
+       if (!f)
+               return 0;
+       bpf_this_cpu_ptr(f);
+       return 0;
+}
+
+SEC("?tc")
+int lock_id_innermapval_preserve(void *ctx)
+{
+       struct foo *f;
+       int key = 0;
+       void *map;
+
+       map = bpf_map_lookup_elem(&map_of_maps, &key);
+       if (!map)
+               return 0;
+       f = bpf_map_lookup_elem(map, &key);
+       if (!f)
+               return 0;
+       bpf_this_cpu_ptr(f);
+       return 0;
+}
+
+#define CHECK(test, A, B)                                      \
+       SEC("?tc")                                             \
+       int lock_id_mismatch_##test(void *ctx)                 \
+       {                                                      \
+               struct foo *f1, *f2, *v, *iv;                  \
+               int key = 0;                                   \
+               void *map;                                     \
+                                                               \
+               map = bpf_map_lookup_elem(&map_of_maps, &key); \
+               if (!map)                                      \
+                       return 0;                              \
+               iv = bpf_map_lookup_elem(map, &key);           \
+               if (!iv)                                       \
+                       return 0;                              \
+               v = bpf_map_lookup_elem(&array_map, &key);     \
+               if (!v)                                        \
+                       return 0;                              \
+               f1 = bpf_obj_new(typeof(*f1));                 \
+               if (!f1)                                       \
+                       return 0;                              \
+               f2 = bpf_obj_new(typeof(*f2));                 \
+               if (!f2) {                                     \
+                       bpf_obj_drop(f1);                      \
+                       return 0;                              \
+               }                                              \
+               bpf_spin_lock(A);                              \
+               bpf_spin_unlock(B);                            \
+               return 0;                                      \
+       }
+
+CHECK(kptr_kptr, &f1->lock, &f2->lock);
+CHECK(kptr_global, &f1->lock, &lockA);
+CHECK(kptr_mapval, &f1->lock, &v->lock);
+CHECK(kptr_innermapval, &f1->lock, &iv->lock);
+
+CHECK(global_global, &lockA, &lockB);
+CHECK(global_kptr, &lockA, &f1->lock);
+CHECK(global_mapval, &lockA, &v->lock);
+CHECK(global_innermapval, &lockA, &iv->lock);
+
+SEC("?tc")
+int lock_id_mismatch_mapval_mapval(void *ctx)
+{
+       struct foo *f1, *f2;
+       int key = 0;
+
+       f1 = bpf_map_lookup_elem(&array_map, &key);
+       if (!f1)
+               return 0;
+       f2 = bpf_map_lookup_elem(&array_map, &key);
+       if (!f2)
+               return 0;
+
+       bpf_spin_lock(&f1->lock);
+       f1->data = 42;
+       bpf_spin_unlock(&f2->lock);
+
+       return 0;
+}
+
+CHECK(mapval_kptr, &v->lock, &f1->lock);
+CHECK(mapval_global, &v->lock, &lockB);
+CHECK(mapval_innermapval, &v->lock, &iv->lock);
+
+SEC("?tc")
+int lock_id_mismatch_innermapval_innermapval1(void *ctx)
+{
+       struct foo *f1, *f2;
+       int key = 0;
+       void *map;
+
+       map = bpf_map_lookup_elem(&map_of_maps, &key);
+       if (!map)
+               return 0;
+       f1 = bpf_map_lookup_elem(map, &key);
+       if (!f1)
+               return 0;
+       f2 = bpf_map_lookup_elem(map, &key);
+       if (!f2)
+               return 0;
+
+       bpf_spin_lock(&f1->lock);
+       f1->data = 42;
+       bpf_spin_unlock(&f2->lock);
+
+       return 0;
+}
+
+SEC("?tc")
+int lock_id_mismatch_innermapval_innermapval2(void *ctx)
+{
+       struct foo *f1, *f2;
+       int key = 0;
+       void *map;
+
+       map = bpf_map_lookup_elem(&map_of_maps, &key);
+       if (!map)
+               return 0;
+       f1 = bpf_map_lookup_elem(map, &key);
+       if (!f1)
+               return 0;
+       map = bpf_map_lookup_elem(&map_of_maps, &key);
+       if (!map)
+               return 0;
+       f2 = bpf_map_lookup_elem(map, &key);
+       if (!f2)
+               return 0;
+
+       bpf_spin_lock(&f1->lock);
+       f1->data = 42;
+       bpf_spin_unlock(&f2->lock);
+
+       return 0;
+}
+
+CHECK(innermapval_kptr, &iv->lock, &f1->lock);
+CHECK(innermapval_global, &iv->lock, &lockA);
+CHECK(innermapval_mapval, &iv->lock, &v->lock);
+
+#undef CHECK
+
+char _license[] SEC("license") = "GPL";