selftests/bpf: skip verifier tests for unsupported map types

Use recently introduced bpf_probe_map_type() to skip tests in the
test_verifier if map creation (create_map) fails. It's handled
explicitly for each fixup, i.e. if bpf_create_map returns negative fd,
we probe the kernel for the appropriate map support and skip the
test is map type is not supported.

Signed-off-by: Stanislav Fomichev <sdf@google.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c
index 2a36f9f2ee8f74abad00d8fa982d8af476829440..97188dbe80bd40df901a4c2712b5fb3c6abacba8 100644 (file)
--- a/tools/testing/selftests/bpf/test_verifier.c
+++ b/tools/testing/selftests/bpf/test_verifier.c
@@ -265,6 +265,16 @@ static int probe_filter_length(const struct bpf_insn *fp)
        return len + 1;
 }
 
+static bool skip_unsupported_map(enum bpf_map_type map_type)
+{
+       if (!bpf_probe_map_type(map_type, 0)) {
+               printf("SKIP (unsupported map type %d)\n", map_type);
+               skips++;
+               return true;
+       }
+       return false;
+}
+
 static int create_map(uint32_t type, uint32_t size_key,
                      uint32_t size_value, uint32_t max_elem)
 {
@@ -272,8 +282,11 @@ static int create_map(uint32_t type, uint32_t size_key,
 
        fd = bpf_create_map(type, size_key, size_value, max_elem,
                            type == BPF_MAP_TYPE_HASH ? BPF_F_NO_PREALLOC : 0);
-       if (fd < 0)
+       if (fd < 0) {
+               if (skip_unsupported_map(type))
+                       return -1;
                printf("Failed to create hash map '%s'!\n", strerror(errno));
+       }
 
        return fd;
 }
@@ -323,6 +336,8 @@ static int create_prog_array(enum bpf_prog_type prog_type, uint32_t max_elem,
        mfd = bpf_create_map(BPF_MAP_TYPE_PROG_ARRAY, sizeof(int),
                             sizeof(int), max_elem, 0);
        if (mfd < 0) {
+               if (skip_unsupported_map(BPF_MAP_TYPE_PROG_ARRAY))
+                       return -1;
                printf("Failed to create prog array '%s'!\n", strerror(errno));
                return -1;
        }
@@ -353,15 +368,20 @@ static int create_map_in_map(void)
        inner_map_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int),
                                      sizeof(int), 1, 0);
        if (inner_map_fd < 0) {
+               if (skip_unsupported_map(BPF_MAP_TYPE_ARRAY))
+                       return -1;
                printf("Failed to create array '%s'!\n", strerror(errno));
                return inner_map_fd;
        }
 
        outer_map_fd = bpf_create_map_in_map(BPF_MAP_TYPE_ARRAY_OF_MAPS, NULL,
                                             sizeof(int), inner_map_fd, 1, 0);
-       if (outer_map_fd < 0)
+       if (outer_map_fd < 0) {
+               if (skip_unsupported_map(BPF_MAP_TYPE_ARRAY_OF_MAPS))
+                       return -1;
                printf("Failed to create array of maps '%s'!\n",
                       strerror(errno));
+       }
 
        close(inner_map_fd);
 
@@ -376,9 +396,12 @@ static int create_cgroup_storage(bool percpu)
 
        fd = bpf_create_map(type, sizeof(struct bpf_cgroup_storage_key),
                            TEST_DATA_LEN, 0, 0);
-       if (fd < 0)
+       if (fd < 0) {
+               if (skip_unsupported_map(type))
+                       return -1;
                printf("Failed to create cgroup storage '%s'!\n",
                       strerror(errno));
+       }
 
        return fd;
 }
@@ -582,6 +605,7 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
        int run_errs, run_successes;
        int map_fds[MAX_NR_MAPS];
        const char *expected_err;
+       int fixup_skips;
        __u32 pflags;
        int i, err;
 
@@ -590,7 +614,13 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
 
        if (!prog_type)
                prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
+       fixup_skips = skips;
        do_test_fixup(test, prog_type, prog, map_fds);
+       /* If there were some map skips during fixup due to missing bpf
+        * features, skip this test.
+        */
+       if (fixup_skips != skips)
+               return;
        prog_len = probe_filter_length(prog);
 
        pflags = 0;