selftests/bpf: Temporarily disable linked list tests

The latest clang nightly as of writing crashes with the given test case
for BPF linked lists wherever global glock, ghead, glock2 are used,
hence comment out the parts that cause the crash, and prepare this commit
so that it can be reverted when the fix has been made. More context in [0].

 [0]: https://lore.kernel.org/bpf/d56223f9-483e-fbc1-4564-44c0858a1e3e@meta.com

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

diff --git a/tools/testing/selftests/bpf/prog_tests/linked_list.c b/tools/testing/selftests/bpf/prog_tests/linked_list.c
index dd73d0a62c6ea64d98ddc753edf3bb29668147d5..6170d36fe5fc72779e7fd85f044092d9940e6912 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/linked_list.c
+++ b/tools/testing/selftests/bpf/prog_tests/linked_list.c
@@ -24,7 +24,9 @@ static struct {
        { #test "_missing_lock_pop_back", \
          "bpf_spin_lock at off=" #off " must be held for bpf_list_head" },
        TEST(kptr, 32)
+/* FIXME
        TEST(global, 16)
+*/
        TEST(map, 0)
        TEST(inner_map, 0)
 #undef TEST
@@ -32,9 +34,6 @@ static struct {
        { #test "_kptr_incorrect_lock_" #op, \
          "held lock and object are not in the same allocation\n" \
          "bpf_spin_lock at off=32 must be held for bpf_list_head" }, \
-       { #test "_global_incorrect_lock_" #op, \
-         "held lock and object are not in the same allocation\n" \
-         "bpf_spin_lock at off=16 must be held for bpf_list_head" }, \
        { #test "_map_incorrect_lock_" #op, \
          "held lock and object are not in the same allocation\n" \
          "bpf_spin_lock at off=0 must be held for bpf_list_head" }, \
@@ -45,10 +44,6 @@ static struct {
        TEST(kptr, push_back)
        TEST(kptr, pop_front)
        TEST(kptr, pop_back)
-       TEST(global, push_front)
-       TEST(global, push_back)
-       TEST(global, pop_front)
-       TEST(global, pop_back)
        TEST(map, push_front)
        TEST(map, push_back)
        TEST(map, pop_front)
@@ -58,12 +53,14 @@ static struct {
        TEST(inner_map, pop_front)
        TEST(inner_map, pop_back)
 #undef TEST
+/* FIXME
        { "map_compat_kprobe", "tracing progs cannot use bpf_list_head yet" },
        { "map_compat_kretprobe", "tracing progs cannot use bpf_list_head yet" },
        { "map_compat_tp", "tracing progs cannot use bpf_list_head yet" },
        { "map_compat_perf", "tracing progs cannot use bpf_list_head yet" },
        { "map_compat_raw_tp", "tracing progs cannot use bpf_list_head yet" },
        { "map_compat_raw_tp_w", "tracing progs cannot use bpf_list_head yet" },
+*/
        { "obj_type_id_oor", "local type ID argument must be in range [0, U32_MAX]" },
        { "obj_new_no_composite", "bpf_obj_new type ID argument must be of a struct" },
        { "obj_new_no_struct", "bpf_obj_new type ID argument must be of a struct" },
@@ -78,6 +75,7 @@ static struct {
        { "direct_write_head", "direct access to bpf_list_head is disallowed" },
        { "direct_read_node", "direct access to bpf_list_node is disallowed" },
        { "direct_write_node", "direct access to bpf_list_node is disallowed" },
+/* FIXME
        { "write_after_push_front", "only read is supported" },
        { "write_after_push_back", "only read is supported" },
        { "use_after_unlock_push_front", "invalid mem access 'scalar'" },
@@ -94,8 +92,11 @@ static struct {
        { "no_head_type", "bpf_list_head not found at offset=0" },
        { "incorrect_head_var_off1", "R1 doesn't have constant offset" },
        { "incorrect_head_var_off2", "variable ptr_ access var_off=(0x0; 0xffffffff) disallowed" },
+*/
        { "incorrect_head_off1", "bpf_list_head not found at offset=17" },
+/* FIXME
        { "incorrect_head_off2", "bpf_list_head not found at offset=1" },
+*/
        { "pop_front_off",
          "15: (bf) r1 = r6                      ; R1_w=ptr_or_null_foo(id=4,ref_obj_id=4,off=40,imm=0) "
          "R6_w=ptr_or_null_foo(id=4,ref_obj_id=4,off=40,imm=0) refs=2,4\n"
@@ -188,8 +189,10 @@ static void test_linked_list_success(int mode, bool leave_in_map)
        ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.global_list_push_pop), &opts);
        ASSERT_OK(ret, "global_list_push_pop");
        ASSERT_OK(opts.retval, "global_list_push_pop retval");
+       /* FIXME:
        if (!leave_in_map)
                clear_fields(skel->maps.data_A);
+       */
 
        if (mode == PUSH_POP)
                goto end;
@@ -210,8 +213,10 @@ ppm:
        ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.global_list_push_pop_multiple), &opts);
        ASSERT_OK(ret, "global_list_push_pop_multiple");
        ASSERT_OK(opts.retval, "global_list_push_pop_multiple retval");
+       /* FIXME:
        if (!leave_in_map)
                clear_fields(skel->maps.data_A);
+       */
 
        if (mode == PUSH_POP_MULT)
                goto end;
@@ -232,8 +237,10 @@ lil:
        ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.global_list_in_list), &opts);
        ASSERT_OK(ret, "global_list_in_list");
        ASSERT_OK(opts.retval, "global_list_in_list retval");
+       /* FIXME:
        if (!leave_in_map)
                clear_fields(skel->maps.data_A);
+       */
 end:
        linked_list__destroy(skel);
 }

diff --git a/tools/testing/selftests/bpf/progs/linked_list.c b/tools/testing/selftests/bpf/progs/linked_list.c
index 2c7b615c6d41dcf107e6172380fce3e6b50affba..a99103c86e4849c463fd4007dd487840af5f0a61 100644 (file)
--- a/tools/testing/selftests/bpf/progs/linked_list.c
+++ b/tools/testing/selftests/bpf/progs/linked_list.c
@@ -291,7 +291,10 @@ int inner_map_list_push_pop(void *ctx)
 SEC("tc")
 int global_list_push_pop(void *ctx)
 {
-       return test_list_push_pop(&glock, &ghead);
+       /* FIXME:
+        * return test_list_push_pop(&glock, &ghead);
+        */
+       return 0;
 }
 
 SEC("tc")
@@ -327,10 +330,13 @@ int global_list_push_pop_multiple(void *ctx)
 {
        int ret;
 
+       /* FIXME:
        ret = list_push_pop_multiple(&glock, &ghead, false);
        if (ret)
                return ret;
        return list_push_pop_multiple(&glock, &ghead, true);
+       */
+       return 0;
 }
 
 SEC("tc")
@@ -364,7 +370,10 @@ int inner_map_list_in_list(void *ctx)
 SEC("tc")
 int global_list_in_list(void *ctx)
 {
+       /* FIXME
        return test_list_in_list(&glock, &ghead);
+       */
+       return 0;
 }
 
 char _license[] SEC("license") = "GPL";

diff --git a/tools/testing/selftests/bpf/progs/linked_list.h b/tools/testing/selftests/bpf/progs/linked_list.h
index 8db80ed64db1b0e3aed989f557addeab586e4776..93157efc2d043df74e239dcf3d8f30a113f96696 100644 (file)
--- a/tools/testing/selftests/bpf/progs/linked_list.h
+++ b/tools/testing/selftests/bpf/progs/linked_list.h
@@ -47,10 +47,12 @@ struct {
        },
 };
 
+/* FIXME
 #define private(name) SEC(".data." #name) __hidden __attribute__((aligned(8)))
 
 private(A) struct bpf_spin_lock glock;
 private(A) struct bpf_list_head ghead __contains(foo, node);
 private(B) struct bpf_spin_lock glock2;
 
+*/
 #endif

diff --git a/tools/testing/selftests/bpf/progs/linked_list_fail.c b/tools/testing/selftests/bpf/progs/linked_list_fail.c
index 1d9017240e19745761374ae0d03594c9ac8c2d28..1b7ed1d3a9bbfa52e82d280cafd08eca2fb05420 100644 (file)
--- a/tools/testing/selftests/bpf/progs/linked_list_fail.c
+++ b/tools/testing/selftests/bpf/progs/linked_list_fail.c
@@ -59,10 +59,12 @@ CHECK(kptr, push_back, &f->head);
 CHECK(kptr, pop_front, &f->head);
 CHECK(kptr, pop_back, &f->head);
 
+/* FIXME
 CHECK(global, push_front, &ghead);
 CHECK(global, push_back, &ghead);
 CHECK(global, pop_front, &ghead);
 CHECK(global, pop_back, &ghead);
+*/
 
 CHECK(map, push_front, &v->head);
 CHECK(map, push_back, &v->head);
@@ -89,23 +91,15 @@ CHECK(inner_map, pop_back, &iv->head);
 
 #define CHECK_OP(op)                                           \
        CHECK(kptr_kptr, op, &f1->lock, &f2->head);            \
-       CHECK(kptr_global, op, &f1->lock, &ghead);             \
        CHECK(kptr_map, op, &f1->lock, &v->head);              \
        CHECK(kptr_inner_map, op, &f1->lock, &iv->head);       \
                                                                \
-       CHECK(global_global, op, &glock2, &ghead);             \
-       CHECK(global_kptr, op, &glock, &f1->head);             \
-       CHECK(global_map, op, &glock, &v->head);               \
-       CHECK(global_inner_map, op, &glock, &iv->head);        \
-                                                               \
        CHECK(map_map, op, &v->lock, &v2->head);               \
        CHECK(map_kptr, op, &v->lock, &f2->head);              \
-       CHECK(map_global, op, &v->lock, &ghead);               \
        CHECK(map_inner_map, op, &v->lock, &iv->head);         \
                                                                \
        CHECK(inner_map_inner_map, op, &iv->lock, &iv2->head); \
        CHECK(inner_map_kptr, op, &iv->lock, &f2->head);       \
-       CHECK(inner_map_global, op, &iv->lock, &ghead);        \
        CHECK(inner_map_map, op, &iv->lock, &v->head);
 
 CHECK_OP(push_front);
@@ -117,6 +111,7 @@ CHECK_OP(pop_back);
 #undef CHECK_OP
 #undef INIT
 
+/* FIXME
 SEC("?kprobe/xyz")
 int map_compat_kprobe(void *ctx)
 {
@@ -158,6 +153,7 @@ int map_compat_raw_tp_w(void *ctx)
        bpf_list_push_front(&ghead, NULL);
        return 0;
 }
+*/
 
 SEC("?tc")
 int obj_type_id_oor(void *ctx)
@@ -303,6 +299,7 @@ int direct_write_node(void *ctx)
        return 0;
 }
 
+/* FIXME
 static __always_inline
 int write_after_op(void (*push_op)(void *head, void *node))
 {
@@ -506,6 +503,7 @@ int incorrect_head_var_off2(struct __sk_buff *ctx)
 
        return 0;
 }
+*/
 
 SEC("?tc")
 int incorrect_head_off1(void *ctx)
@@ -529,6 +527,7 @@ int incorrect_head_off1(void *ctx)
        return 0;
 }
 
+/* FIXME
 SEC("?tc")
 int incorrect_head_off2(void *ctx)
 {
@@ -545,6 +544,7 @@ int incorrect_head_off2(void *ctx)
 
        return 0;
 }
+*/
 
 static __always_inline
 int pop_ptr_off(void *(*op)(void *head))