selftests/bpf: Test outer map update operations in syscall program

Syscall program is running with rcu_read_lock_trace being held, so if
bpf_map_update_elem() or bpf_map_delete_elem() invokes
synchronize_rcu_tasks_trace() when operating on an outer map, there will
be dead-lock, so add a test to guarantee that it is dead-lock free.

Signed-off-by: Hou Tao <houtao1@huawei.com>
Link: https://lore.kernel.org/r/20231204140425.1480317-8-houtao@huaweicloud.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/prog_tests/syscall.c b/tools/testing/selftests/bpf/prog_tests/syscall.c
index f4d40001155a9203b8b628f759a97830efd7746c..0be8301c0ffd25c0b690302608a88dac0641caa9 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/syscall.c
+++ b/tools/testing/selftests/bpf/prog_tests/syscall.c
@@ -12,7 +12,7 @@ struct args {
        int btf_fd;
 };
 
-void test_syscall(void)
+static void test_syscall_load_prog(void)
 {
        static char verifier_log[8192];
        struct args ctx = {
@@ -32,7 +32,7 @@ void test_syscall(void)
        if (!ASSERT_OK_PTR(skel, "skel_load"))
                goto cleanup;
 
-       prog_fd = bpf_program__fd(skel->progs.bpf_prog);
+       prog_fd = bpf_program__fd(skel->progs.load_prog);
        err = bpf_prog_test_run_opts(prog_fd, &tattr);
        ASSERT_EQ(err, 0, "err");
        ASSERT_EQ(tattr.retval, 1, "retval");
@@ -53,3 +53,29 @@ cleanup:
        if (ctx.btf_fd > 0)
                close(ctx.btf_fd);
 }
+
+static void test_syscall_update_outer_map(void)
+{
+       LIBBPF_OPTS(bpf_test_run_opts, opts);
+       struct syscall *skel;
+       int err, prog_fd;
+
+       skel = syscall__open_and_load();
+       if (!ASSERT_OK_PTR(skel, "skel_load"))
+               goto cleanup;
+
+       prog_fd = bpf_program__fd(skel->progs.update_outer_map);
+       err = bpf_prog_test_run_opts(prog_fd, &opts);
+       ASSERT_EQ(err, 0, "err");
+       ASSERT_EQ(opts.retval, 1, "retval");
+cleanup:
+       syscall__destroy(skel);
+}
+
+void test_syscall(void)
+{
+       if (test__start_subtest("load_prog"))
+               test_syscall_load_prog();
+       if (test__start_subtest("update_outer_map"))
+               test_syscall_update_outer_map();
+}

diff --git a/tools/testing/selftests/bpf/progs/syscall.c b/tools/testing/selftests/bpf/progs/syscall.c
index e550f728962d402c29a6f26312be271cd84c62bb..3d3cafdebe72b06729ecef39cc710d7b88f86efe 100644 (file)
--- a/tools/testing/selftests/bpf/progs/syscall.c
+++ b/tools/testing/selftests/bpf/progs/syscall.c
@@ -6,9 +6,15 @@
 #include <bpf/bpf_tracing.h>
 #include <../../../tools/include/linux/filter.h>
 #include <linux/btf.h>
+#include <string.h>
+#include <errno.h>
 
 char _license[] SEC("license") = "GPL";
 
+struct bpf_map {
+       int id;
+}  __attribute__((preserve_access_index));
+
 struct args {
        __u64 log_buf;
        __u32 log_size;
@@ -27,6 +33,37 @@ struct args {
        BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), sz), \
        BTF_INT_ENC(encoding, bits_offset, bits)
 
+struct {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __type(key, int);
+       __type(value, union bpf_attr);
+       __uint(max_entries, 1);
+} bpf_attr_array SEC(".maps");
+
+struct inner_map_type {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(key_size, 4);
+       __uint(value_size, 4);
+       __uint(max_entries, 1);
+} inner_map SEC(".maps");
+
+struct {
+       __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
+       __type(key, int);
+       __type(value, int);
+       __uint(max_entries, 1);
+       __array(values, struct inner_map_type);
+} outer_array_map SEC(".maps") = {
+       .values = {
+               [0] = &inner_map,
+       },
+};
+
+static inline __u64 ptr_to_u64(const void *ptr)
+{
+       return (__u64) (unsigned long) ptr;
+}
+
 static int btf_load(void)
 {
        struct btf_blob {
@@ -58,7 +95,7 @@ static int btf_load(void)
 }
 
 SEC("syscall")
-int bpf_prog(struct args *ctx)
+int load_prog(struct args *ctx)
 {
        static char license[] = "GPL";
        static struct bpf_insn insns[] = {
@@ -94,8 +131,8 @@ int bpf_prog(struct args *ctx)
        map_create_attr.max_entries = ctx->max_entries;
        map_create_attr.btf_fd = ret;
 
-       prog_load_attr.license = (long) license;
-       prog_load_attr.insns = (long) insns;
+       prog_load_attr.license = ptr_to_u64(license);
+       prog_load_attr.insns = ptr_to_u64(insns);
        prog_load_attr.log_buf = ctx->log_buf;
        prog_load_attr.log_size = ctx->log_size;
        prog_load_attr.log_level = 1;
@@ -107,8 +144,8 @@ int bpf_prog(struct args *ctx)
        insns[3].imm = ret;
 
        map_update_attr.map_fd = ret;
-       map_update_attr.key = (long) &key;
-       map_update_attr.value = (long) &value;
+       map_update_attr.key = ptr_to_u64(&key);
+       map_update_attr.value = ptr_to_u64(&value);
        ret = bpf_sys_bpf(BPF_MAP_UPDATE_ELEM, &map_update_attr, sizeof(map_update_attr));
        if (ret < 0)
                return ret;
@@ -119,3 +156,52 @@ int bpf_prog(struct args *ctx)
        ctx->prog_fd = ret;
        return 1;
 }
+
+SEC("syscall")
+int update_outer_map(void *ctx)
+{
+       int zero = 0, ret = 0, outer_fd = -1, inner_fd = -1, err;
+       const int attr_sz = sizeof(union bpf_attr);
+       union bpf_attr *attr;
+
+       attr = bpf_map_lookup_elem((struct bpf_map *)&bpf_attr_array, &zero);
+       if (!attr)
+               goto out;
+
+       memset(attr, 0, attr_sz);
+       attr->map_id = ((struct bpf_map *)&outer_array_map)->id;
+       outer_fd = bpf_sys_bpf(BPF_MAP_GET_FD_BY_ID, attr, attr_sz);
+       if (outer_fd < 0)
+               goto out;
+
+       memset(attr, 0, attr_sz);
+       attr->map_type = BPF_MAP_TYPE_ARRAY;
+       attr->key_size = 4;
+       attr->value_size = 4;
+       attr->max_entries = 1;
+       inner_fd = bpf_sys_bpf(BPF_MAP_CREATE, attr, attr_sz);
+       if (inner_fd < 0)
+               goto out;
+
+       memset(attr, 0, attr_sz);
+       attr->map_fd = outer_fd;
+       attr->key = ptr_to_u64(&zero);
+       attr->value = ptr_to_u64(&inner_fd);
+       err = bpf_sys_bpf(BPF_MAP_UPDATE_ELEM, attr, attr_sz);
+       if (err)
+               goto out;
+
+       memset(attr, 0, attr_sz);
+       attr->map_fd = outer_fd;
+       attr->key = ptr_to_u64(&zero);
+       err = bpf_sys_bpf(BPF_MAP_DELETE_ELEM, attr, attr_sz);
+       if (err)
+               goto out;
+       ret = 1;
+out:
+       if (inner_fd >= 0)
+               bpf_sys_close(inner_fd);
+       if (outer_fd >= 0)
+               bpf_sys_close(outer_fd);
+       return ret;
+}