From: Alexei Starovoitov <alexei.starovoitov@gmail.com>
To: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Cc: bpf <bpf@vger.kernel.org>, Alexei Starovoitov <ast@kernel.org>,
Andrii Nakryiko <andrii@kernel.org>,
Daniel Borkmann <daniel@iogearbox.net>,
Martin KaFai Lau <martin.lau@kernel.org>,
Dave Marchevsky <davemarchevsky@meta.com>
Subject: Re: [PATCH bpf-next v9 22/23] selftests/bpf: Add BPF linked list API tests
Date: Thu, 17 Nov 2022 15:05:21 -0800 [thread overview]
Message-ID: <CAADnVQKHibbQUNkwvd0g3YDK8n7k6g21=_TFd1=ccRFYJWrsOA@mail.gmail.com> (raw)
In-Reply-To: <20221117225510.1676785-23-memxor@gmail.com>
On Thu, Nov 17, 2022 at 2:56 PM Kumar Kartikeya Dwivedi
<memxor@gmail.com> wrote:
>
> Include various tests covering the success and failure cases. Also, run
> the success cases at runtime to verify correctness of linked list
> manipulation routines, in addition to ensuring successful verification.
>
> Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
> ---
> tools/testing/selftests/bpf/DENYLIST.s390x | 1 +
> .../selftests/bpf/prog_tests/linked_list.c | 255 ++++++++
> .../testing/selftests/bpf/progs/linked_list.c | 370 +++++++++++
> .../testing/selftests/bpf/progs/linked_list.h | 56 ++
> .../selftests/bpf/progs/linked_list_fail.c | 581 ++++++++++++++++++
> 5 files changed, 1263 insertions(+)
> create mode 100644 tools/testing/selftests/bpf/prog_tests/linked_list.c
> create mode 100644 tools/testing/selftests/bpf/progs/linked_list.c
> create mode 100644 tools/testing/selftests/bpf/progs/linked_list.h
> create mode 100644 tools/testing/selftests/bpf/progs/linked_list_fail.c
>
> diff --git a/tools/testing/selftests/bpf/DENYLIST.s390x b/tools/testing/selftests/bpf/DENYLIST.s390x
> index be4e3d47ea3e..072243af93b0 100644
> --- a/tools/testing/selftests/bpf/DENYLIST.s390x
> +++ b/tools/testing/selftests/bpf/DENYLIST.s390x
> @@ -33,6 +33,7 @@ ksyms_module # test_ksyms_module__open_and_load unex
> ksyms_module_libbpf # JIT does not support calling kernel function (kfunc)
> ksyms_module_lskel # test_ksyms_module_lskel__open_and_load unexpected error: -9 (?)
> libbpf_get_fd_by_id_opts # failed to attach: ERROR: strerror_r(-524)=22 (trampoline)
> +linked_list # JIT does not support calling kernel function (kfunc)
probably needs it in arm64 denylist as well.
> lookup_key # JIT does not support calling kernel function (kfunc)
> lru_bug # prog 'printk': failed to auto-attach: -524
> map_kptr # failed to open_and_load program: -524 (trampoline)
> diff --git a/tools/testing/selftests/bpf/prog_tests/linked_list.c b/tools/testing/selftests/bpf/prog_tests/linked_list.c
> new file mode 100644
> index 000000000000..32ff1684a7d3
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/prog_tests/linked_list.c
> @@ -0,0 +1,255 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#include <test_progs.h>
> +#include <network_helpers.h>
> +
> +#include "linked_list.skel.h"
> +#include "linked_list_fail.skel.h"
> +
> +static char log_buf[1024 * 1024];
> +
> +static struct {
> + const char *prog_name;
> + const char *err_msg;
> +} linked_list_fail_tests[] = {
> +#define TEST(test, off) \
> + { #test "_missing_lock_push_front", \
> + "bpf_spin_lock at off=" #off " must be held for bpf_list_head" }, \
> + { #test "_missing_lock_push_back", \
> + "bpf_spin_lock at off=" #off " must be held for bpf_list_head" }, \
> + { #test "_missing_lock_pop_front", \
> + "bpf_spin_lock at off=" #off " must be held for bpf_list_head" }, \
> + { #test "_missing_lock_pop_back", \
> + "bpf_spin_lock at off=" #off " must be held for bpf_list_head" },
> + TEST(kptr, 32)
> + TEST(global, 16)
> + TEST(map, 0)
> + TEST(inner_map, 0)
> +#undef TEST
> +#define TEST(test, op) \
> + { #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" }, \
> + { #test "_inner_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" },
> + TEST(kptr, push_front)
> + 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)
> + TEST(map, pop_back)
> + TEST(inner_map, push_front)
> + TEST(inner_map, push_back)
> + TEST(inner_map, pop_front)
> + TEST(inner_map, pop_back)
> +#undef TEST
> + { "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" },
> + { "obj_drop_non_zero_off", "R1 must have zero offset when passed to release func" },
> + { "new_null_ret", "R0 invalid mem access 'ptr_or_null_'" },
> + { "obj_new_acq", "Unreleased reference id=" },
> + { "use_after_drop", "invalid mem access 'scalar'" },
> + { "ptr_walk_scalar", "type=scalar expected=percpu_ptr_" },
> + { "direct_read_lock", "direct access to bpf_spin_lock is disallowed" },
> + { "direct_write_lock", "direct access to bpf_spin_lock is disallowed" },
> + { "direct_read_head", "direct access to bpf_list_head is disallowed" },
> + { "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" },
> + { "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'" },
> + { "use_after_unlock_push_back", "invalid mem access 'scalar'" },
> + { "double_push_front", "arg#1 expected pointer to allocated object" },
> + { "double_push_back", "arg#1 expected pointer to allocated object" },
> + { "no_node_value_type", "bpf_list_node not found for allocated object\n" },
> + { "incorrect_value_type",
> + "operation on bpf_list_head expects arg#1 bpf_list_node at offset=0 in struct foo, "
> + "but arg is at offset=0 in struct bar" },
> + { "incorrect_node_var_off", "variable ptr_ access var_off=(0x0; 0xffffffff) disallowed" },
> + { "incorrect_node_off1", "bpf_list_node not found at offset=1" },
> + { "incorrect_node_off2", "arg#1 offset=40, but expected bpf_list_node at offset=0 in struct foo" },
> + { "no_head_type", "bpf_list_head not found for allocated object" },
> + { "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" },
> + { "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"
> + "16: (85) call bpf_this_cpu_ptr#154\nR1 type=ptr_or_null_ expected=percpu_ptr_" },
> + { "pop_back_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"
> + "16: (85) call bpf_this_cpu_ptr#154\nR1 type=ptr_or_null_ expected=percpu_ptr_" },
> +};
> +
> +static void test_linked_list_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 linked_list_fail *skel;
> + struct bpf_program *prog;
> + int ret;
> +
> + skel = linked_list_fail__open_opts(&opts);
> + if (!ASSERT_OK_PTR(skel, "linked_list_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 = linked_list_fail__load(skel);
> + if (!ASSERT_ERR(ret, "linked_list_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:
> + linked_list_fail__destroy(skel);
> +}
> +
> +static void clear_fields(struct bpf_map *map)
> +{
> + char buf[24];
> + int key = 0;
> +
> + memset(buf, 0xff, sizeof(buf));
> + ASSERT_OK(bpf_map__update_elem(map, &key, sizeof(key), buf, sizeof(buf), 0), "check_and_free_fields");
> +}
> +
> +enum {
> + TEST_ALL,
> + PUSH_POP,
> + PUSH_POP_MULT,
> + LIST_IN_LIST,
> +};
> +
> +static void test_linked_list_success(int mode, bool leave_in_map)
> +{
> + LIBBPF_OPTS(bpf_test_run_opts, opts,
> + .data_in = &pkt_v4,
> + .data_size_in = sizeof(pkt_v4),
> + .repeat = 1,
> + );
> + struct linked_list *skel;
> + int ret;
> +
> + skel = linked_list__open_and_load();
> + if (!ASSERT_OK_PTR(skel, "linked_list__open_and_load"))
> + return;
> +
> + if (mode == LIST_IN_LIST)
> + goto lil;
> + if (mode == PUSH_POP_MULT)
> + goto ppm;
> +
> + ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.map_list_push_pop), &opts);
> + ASSERT_OK(ret, "map_list_push_pop");
> + ASSERT_OK(opts.retval, "map_list_push_pop retval");
> + if (!leave_in_map)
> + clear_fields(skel->maps.array_map);
> +
> + ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.inner_map_list_push_pop), &opts);
> + ASSERT_OK(ret, "inner_map_list_push_pop");
> + ASSERT_OK(opts.retval, "inner_map_list_push_pop retval");
> + if (!leave_in_map)
> + clear_fields(skel->maps.inner_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");
> + if (!leave_in_map)
> + clear_fields(skel->maps.data_A);
> +
> + if (mode == PUSH_POP)
> + goto end;
> +
> +ppm:
> + ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.map_list_push_pop_multiple), &opts);
> + ASSERT_OK(ret, "map_list_push_pop_multiple");
> + ASSERT_OK(opts.retval, "map_list_push_pop_multiple retval");
> + if (!leave_in_map)
> + clear_fields(skel->maps.array_map);
> +
> + ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.inner_map_list_push_pop_multiple), &opts);
> + ASSERT_OK(ret, "inner_map_list_push_pop_multiple");
> + ASSERT_OK(opts.retval, "inner_map_list_push_pop_multiple retval");
> + if (!leave_in_map)
> + clear_fields(skel->maps.inner_map);
> +
> + 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");
> + if (!leave_in_map)
> + clear_fields(skel->maps.data_A);
> +
> + if (mode == PUSH_POP_MULT)
> + goto end;
> +
> +lil:
> + ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.map_list_in_list), &opts);
> + ASSERT_OK(ret, "map_list_in_list");
> + ASSERT_OK(opts.retval, "map_list_in_list retval");
> + if (!leave_in_map)
> + clear_fields(skel->maps.array_map);
> +
> + ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.inner_map_list_in_list), &opts);
> + ASSERT_OK(ret, "inner_map_list_in_list");
> + ASSERT_OK(opts.retval, "inner_map_list_in_list retval");
> + if (!leave_in_map)
> + clear_fields(skel->maps.inner_map);
> +
> + 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");
> + if (!leave_in_map)
> + clear_fields(skel->maps.data_A);
> +end:
> + linked_list__destroy(skel);
> +}
> +
> +void test_linked_list(void)
> +{
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(linked_list_fail_tests); i++) {
> + if (!test__start_subtest(linked_list_fail_tests[i].prog_name))
> + continue;
> + test_linked_list_fail_prog(linked_list_fail_tests[i].prog_name,
> + linked_list_fail_tests[i].err_msg);
> + }
> + test_linked_list_success(PUSH_POP, false);
> + test_linked_list_success(PUSH_POP, true);
> + test_linked_list_success(PUSH_POP_MULT, false);
> + test_linked_list_success(PUSH_POP_MULT, true);
> + test_linked_list_success(LIST_IN_LIST, false);
> + test_linked_list_success(LIST_IN_LIST, true);
> + test_linked_list_success(TEST_ALL, false);
> +}
> diff --git a/tools/testing/selftests/bpf/progs/linked_list.c b/tools/testing/selftests/bpf/progs/linked_list.c
> new file mode 100644
> index 000000000000..2c7b615c6d41
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/progs/linked_list.c
> @@ -0,0 +1,370 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#include <vmlinux.h>
> +#include <bpf/bpf_tracing.h>
> +#include <bpf/bpf_helpers.h>
> +#include <bpf/bpf_core_read.h>
> +#include "bpf_experimental.h"
> +
> +#ifndef ARRAY_SIZE
> +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
> +#endif
> +
> +#include "linked_list.h"
> +
> +static __always_inline
> +int list_push_pop(struct bpf_spin_lock *lock, struct bpf_list_head *head, bool leave_in_map)
> +{
> + struct bpf_list_node *n;
> + struct foo *f;
> +
> + f = bpf_obj_new(typeof(*f));
> + if (!f)
> + return 2;
> +
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_front(head);
> + bpf_spin_unlock(lock);
> + if (n) {
> + bpf_obj_drop(container_of(n, struct foo, node));
> + bpf_obj_drop(f);
> + return 3;
> + }
> +
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_back(head);
> + bpf_spin_unlock(lock);
> + if (n) {
> + bpf_obj_drop(container_of(n, struct foo, node));
> + bpf_obj_drop(f);
> + return 4;
> + }
> +
> +
> + bpf_spin_lock(lock);
> + f->data = 42;
> + bpf_list_push_front(head, &f->node);
> + bpf_spin_unlock(lock);
> + if (leave_in_map)
> + return 0;
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_back(head);
> + bpf_spin_unlock(lock);
> + if (!n)
> + return 5;
> + f = container_of(n, struct foo, node);
> + if (f->data != 42) {
> + bpf_obj_drop(f);
> + return 6;
> + }
> +
> + bpf_spin_lock(lock);
> + f->data = 13;
> + bpf_list_push_front(head, &f->node);
> + bpf_spin_unlock(lock);
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_front(head);
> + bpf_spin_unlock(lock);
> + if (!n)
> + return 7;
> + f = container_of(n, struct foo, node);
> + if (f->data != 13) {
> + bpf_obj_drop(f);
> + return 8;
> + }
> + bpf_obj_drop(f);
> +
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_front(head);
> + bpf_spin_unlock(lock);
> + if (n) {
> + bpf_obj_drop(container_of(n, struct foo, node));
> + return 9;
> + }
> +
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_back(head);
> + bpf_spin_unlock(lock);
> + if (n) {
> + bpf_obj_drop(container_of(n, struct foo, node));
> + return 10;
> + }
> + return 0;
> +}
> +
> +
> +static __always_inline
> +int list_push_pop_multiple(struct bpf_spin_lock *lock, struct bpf_list_head *head, bool leave_in_map)
> +{
> + struct bpf_list_node *n;
> + struct foo *f[8], *pf;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(f); i++) {
> + f[i] = bpf_obj_new(typeof(**f));
> + if (!f[i])
> + return 2;
> + f[i]->data = i;
> + bpf_spin_lock(lock);
> + bpf_list_push_front(head, &f[i]->node);
> + bpf_spin_unlock(lock);
> + }
> +
> + for (i = 0; i < ARRAY_SIZE(f); i++) {
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_front(head);
> + bpf_spin_unlock(lock);
> + if (!n)
> + return 3;
> + pf = container_of(n, struct foo, node);
> + if (pf->data != (ARRAY_SIZE(f) - i - 1)) {
> + bpf_obj_drop(pf);
> + return 4;
> + }
> + bpf_spin_lock(lock);
> + bpf_list_push_back(head, &pf->node);
> + bpf_spin_unlock(lock);
> + }
> +
> + if (leave_in_map)
> + return 0;
> +
> + for (i = 0; i < ARRAY_SIZE(f); i++) {
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_back(head);
> + bpf_spin_unlock(lock);
> + if (!n)
> + return 5;
> + pf = container_of(n, struct foo, node);
> + if (pf->data != i) {
> + bpf_obj_drop(pf);
> + return 6;
> + }
> + bpf_obj_drop(pf);
> + }
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_back(head);
> + bpf_spin_unlock(lock);
> + if (n) {
> + bpf_obj_drop(container_of(n, struct foo, node));
> + return 7;
> + }
> +
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_front(head);
> + bpf_spin_unlock(lock);
> + if (n) {
> + bpf_obj_drop(container_of(n, struct foo, node));
> + return 8;
> + }
> + return 0;
> +}
> +
> +static __always_inline
> +int list_in_list(struct bpf_spin_lock *lock, struct bpf_list_head *head, bool leave_in_map)
> +{
> + struct bpf_list_node *n;
> + struct bar *ba[8], *b;
> + struct foo *f;
> + int i;
> +
> + f = bpf_obj_new(typeof(*f));
> + if (!f)
> + return 2;
> + for (i = 0; i < ARRAY_SIZE(ba); i++) {
> + b = bpf_obj_new(typeof(*b));
> + if (!b) {
> + bpf_obj_drop(f);
> + return 3;
> + }
> + b->data = i;
> + bpf_spin_lock(&f->lock);
> + bpf_list_push_back(&f->head, &b->node);
> + bpf_spin_unlock(&f->lock);
> + }
> +
> + bpf_spin_lock(lock);
> + f->data = 42;
> + bpf_list_push_front(head, &f->node);
> + bpf_spin_unlock(lock);
> +
> + if (leave_in_map)
> + return 0;
> +
> + bpf_spin_lock(lock);
> + n = bpf_list_pop_front(head);
> + bpf_spin_unlock(lock);
> + if (!n)
> + return 4;
> + f = container_of(n, struct foo, node);
> + if (f->data != 42) {
> + bpf_obj_drop(f);
> + return 5;
> + }
> +
> + for (i = 0; i < ARRAY_SIZE(ba); i++) {
> + bpf_spin_lock(&f->lock);
> + n = bpf_list_pop_front(&f->head);
> + bpf_spin_unlock(&f->lock);
> + if (!n) {
> + bpf_obj_drop(f);
> + return 6;
> + }
> + b = container_of(n, struct bar, node);
> + if (b->data != i) {
> + bpf_obj_drop(f);
> + bpf_obj_drop(b);
> + return 7;
> + }
> + bpf_obj_drop(b);
> + }
> + bpf_spin_lock(&f->lock);
> + n = bpf_list_pop_front(&f->head);
> + bpf_spin_unlock(&f->lock);
> + if (n) {
> + bpf_obj_drop(f);
> + bpf_obj_drop(container_of(n, struct bar, node));
> + return 8;
> + }
> + bpf_obj_drop(f);
> + return 0;
> +}
> +
> +static __always_inline
> +int test_list_push_pop(struct bpf_spin_lock *lock, struct bpf_list_head *head)
> +{
> + int ret;
> +
> + ret = list_push_pop(lock, head, false);
> + if (ret)
> + return ret;
> + return list_push_pop(lock, head, true);
> +}
> +
> +static __always_inline
> +int test_list_push_pop_multiple(struct bpf_spin_lock *lock, struct bpf_list_head *head)
> +{
> + int ret;
> +
> + ret = list_push_pop_multiple(lock ,head, false);
> + if (ret)
> + return ret;
> + return list_push_pop_multiple(lock, head, true);
> +}
> +
> +static __always_inline
> +int test_list_in_list(struct bpf_spin_lock *lock, struct bpf_list_head *head)
> +{
> + int ret;
> +
> + ret = list_in_list(lock, head, false);
> + if (ret)
> + return ret;
> + return list_in_list(lock, head, true);
> +}
> +
> +SEC("tc")
> +int map_list_push_pop(void *ctx)
> +{
> + struct map_value *v;
> +
> + v = bpf_map_lookup_elem(&array_map, &(int){0});
> + if (!v)
> + return 1;
> + return test_list_push_pop(&v->lock, &v->head);
> +}
> +
> +SEC("tc")
> +int inner_map_list_push_pop(void *ctx)
> +{
> + struct map_value *v;
> + void *map;
> +
> + map = bpf_map_lookup_elem(&map_of_maps, &(int){0});
> + if (!map)
> + return 1;
> + v = bpf_map_lookup_elem(map, &(int){0});
> + if (!v)
> + return 1;
> + return test_list_push_pop(&v->lock, &v->head);
> +}
> +
> +SEC("tc")
> +int global_list_push_pop(void *ctx)
> +{
> + return test_list_push_pop(&glock, &ghead);
> +}
> +
> +SEC("tc")
> +int map_list_push_pop_multiple(void *ctx)
> +{
> + struct map_value *v;
> + int ret;
> +
> + v = bpf_map_lookup_elem(&array_map, &(int){0});
> + if (!v)
> + return 1;
> + return test_list_push_pop_multiple(&v->lock, &v->head);
> +}
> +
> +SEC("tc")
> +int inner_map_list_push_pop_multiple(void *ctx)
> +{
> + struct map_value *v;
> + void *map;
> + int ret;
> +
> + map = bpf_map_lookup_elem(&map_of_maps, &(int){0});
> + if (!map)
> + return 1;
> + v = bpf_map_lookup_elem(map, &(int){0});
> + if (!v)
> + return 1;
> + return test_list_push_pop_multiple(&v->lock, &v->head);
> +}
> +
> +SEC("tc")
> +int global_list_push_pop_multiple(void *ctx)
> +{
> + int ret;
> +
> + ret = list_push_pop_multiple(&glock, &ghead, false);
> + if (ret)
> + return ret;
> + return list_push_pop_multiple(&glock, &ghead, true);
> +}
> +
> +SEC("tc")
> +int map_list_in_list(void *ctx)
> +{
> + struct map_value *v;
> + int ret;
> +
> + v = bpf_map_lookup_elem(&array_map, &(int){0});
> + if (!v)
> + return 1;
> + return test_list_in_list(&v->lock, &v->head);
> +}
> +
> +SEC("tc")
> +int inner_map_list_in_list(void *ctx)
> +{
> + struct map_value *v;
> + void *map;
> + int ret;
> +
> + map = bpf_map_lookup_elem(&map_of_maps, &(int){0});
> + if (!map)
> + return 1;
> + v = bpf_map_lookup_elem(map, &(int){0});
> + if (!v)
> + return 1;
> + return test_list_in_list(&v->lock, &v->head);
> +}
> +
> +SEC("tc")
> +int global_list_in_list(void *ctx)
> +{
> + return test_list_in_list(&glock, &ghead);
> +}
> +
> +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
> new file mode 100644
> index 000000000000..8db80ed64db1
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/progs/linked_list.h
> @@ -0,0 +1,56 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#ifndef LINKED_LIST_H
> +#define LINKED_LIST_H
> +
> +#include <vmlinux.h>
> +#include <bpf/bpf_helpers.h>
> +#include "bpf_experimental.h"
> +
> +struct bar {
> + struct bpf_list_node node;
> + int data;
> +};
> +
> +struct foo {
> + struct bpf_list_node node;
> + struct bpf_list_head head __contains(bar, node);
> + struct bpf_spin_lock lock;
> + int data;
> + struct bpf_list_node node2;
> +};
> +
> +struct map_value {
> + struct bpf_spin_lock lock;
> + int data;
> + struct bpf_list_head head __contains(foo, node);
> +};
> +
> +struct array_map {
> + __uint(type, BPF_MAP_TYPE_ARRAY);
> + __type(key, int);
> + __type(value, struct map_value);
> + __uint(max_entries, 1);
> +};
> +
> +struct array_map array_map SEC(".maps");
> +struct array_map inner_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] = &inner_map,
> + },
> +};
> +
> +#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;
The latest llvm crashes with a bug here:
fatal error: error in backend: unable to write nop sequence of 4 bytes
Please see BPF CI.
So far I wasn't able to find a manual workaround :(
Please give it a shot too.
Or disable the test for this case for now?
next prev parent reply other threads:[~2022-11-17 23:05 UTC|newest]
Thread overview: 30+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-11-17 22:54 [PATCH bpf-next v9 00/23] Allocated objects, BPF linked lists Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 01/23] bpf: Fix early return in map_check_btf Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 02/23] bpf: Do btf_record_free outside map_free callback Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 03/23] bpf: Free inner_map_meta when btf_record_dup fails Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 04/23] bpf: Populate field_offs for inner_map_meta Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 05/23] bpf: Introduce allocated objects support Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 06/23] bpf: Recognize lock and list fields in allocated objects Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 07/23] bpf: Verify ownership relationships for user BTF types Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 08/23] bpf: Allow locking bpf_spin_lock in allocated objects Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 09/23] bpf: Allow locking bpf_spin_lock global variables Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 10/23] bpf: Allow locking bpf_spin_lock in inner map values Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 11/23] bpf: Rewrite kfunc argument handling Kumar Kartikeya Dwivedi
2022-11-17 22:54 ` [PATCH bpf-next v9 12/23] bpf: Support constant scalar arguments for kfuncs Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 13/23] bpf: Introduce bpf_obj_new Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 14/23] bpf: Introduce bpf_obj_drop Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 15/23] bpf: Permit NULL checking pointer with non-zero fixed offset Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 16/23] bpf: Introduce single ownership BPF linked list API Kumar Kartikeya Dwivedi
2022-11-18 0:12 ` Alexei Starovoitov
2022-11-17 22:55 ` [PATCH bpf-next v9 17/23] bpf: Add 'release on unlock' logic for bpf_list_push_{front,back} Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 18/23] bpf: Add comments for map BTF matching requirement for bpf_list_head Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 19/23] selftests/bpf: Add __contains macro to bpf_experimental.h Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 20/23] selftests/bpf: Update spinlock selftest Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 21/23] selftests/bpf: Add failure test cases for spin lock pairing Kumar Kartikeya Dwivedi
2022-11-17 22:55 ` [PATCH bpf-next v9 22/23] selftests/bpf: Add BPF linked list API tests Kumar Kartikeya Dwivedi
2022-11-17 23:05 ` Alexei Starovoitov [this message]
2022-11-17 23:27 ` Dave Marchevsky
2022-11-17 23:58 ` Kumar Kartikeya Dwivedi
2022-11-18 0:05 ` Alexei Starovoitov
2022-11-17 23:29 ` Yonghong Song
2022-11-17 22:55 ` [PATCH bpf-next v9 23/23] selftests/bpf: Add BTF sanity tests Kumar Kartikeya Dwivedi
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to='CAADnVQKHibbQUNkwvd0g3YDK8n7k6g21=_TFd1=ccRFYJWrsOA@mail.gmail.com' \
--to=alexei.starovoitov@gmail.com \
--cc=andrii@kernel.org \
--cc=ast@kernel.org \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=davemarchevsky@meta.com \
--cc=martin.lau@kernel.org \
--cc=memxor@gmail.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.