selftests/bpf: Convert test_hashmap into test_progs test

Fold stand-alone test_hashmap test into test_progs.

Signed-off-by: Andrii Nakryiko <andriin@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200429012111.277390-4-andriin@fb.com

diff --git a/tools/testing/selftests/bpf/.gitignore b/tools/testing/selftests/bpf/.gitignore
index c30079c..16b9774 100644 (file)
--- a/tools/testing/selftests/bpf/.gitignore
+++ b/tools/testing/selftests/bpf/.gitignore
@@ -30,8 +30,6 @@ test_tcpnotify_user
 test_libbpf
 test_tcp_check_syncookie_user
 test_sysctl
-test_hashmap
-test_btf_dump
 test_current_pid_tgid_new_ns
 xdping
 test_cpp

diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile
index 887f06a..10f12a5 100644 (file)
--- a/tools/testing/selftests/bpf/Makefile
+++ b/tools/testing/selftests/bpf/Makefile
@@ -33,7 +33,7 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test
        test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \
        test_sock test_btf test_sockmap get_cgroup_id_user test_socket_cookie \
        test_cgroup_storage \
-       test_netcnt test_tcpnotify_user test_sock_fields test_sysctl test_hashmap \
+       test_netcnt test_tcpnotify_user test_sock_fields test_sysctl \
        test_progs-no_alu32 \
        test_current_pid_tgid_new_ns
 

diff --git a/tools/testing/selftests/bpf/test_hashmap.c b/tools/testing/selftests/bpf/prog_tests/hashmap.c
similarity index 53%
rename from tools/testing/selftests/bpf/test_hashmap.c
rename to tools/testing/selftests/bpf/prog_tests/hashmap.c
index c490e01..428d488 100644 (file)
--- a/tools/testing/selftests/bpf/test_hashmap.c
+++ b/tools/testing/selftests/bpf/prog_tests/hashmap.c
@@ -5,26 +5,17 @@
  *
  * Copyright (c) 2019 Facebook
  */
-#include <stdio.h>
-#include <errno.h>
-#include <linux/err.h>
+#include "test_progs.h"
 #include "bpf/hashmap.h"
 
-#define CHECK(condition, format...) ({                                 \
-       int __ret = !!(condition);                                      \
-       if (__ret) {                                                    \
-               fprintf(stderr, "%s:%d:FAIL ", __func__, __LINE__);     \
-               fprintf(stderr, format);                                \
-       }                                                               \
-       __ret;                                                          \
-})
+static int duration = 0;
 
-size_t hash_fn(const void *k, void *ctx)
+static size_t hash_fn(const void *k, void *ctx)
 {
        return (long)k;
 }
 
-bool equal_fn(const void *a, const void *b, void *ctx)
+static bool equal_fn(const void *a, const void *b, void *ctx)
 {
        return (long)a == (long)b;
 }
@@ -49,53 +40,55 @@ static inline size_t exp_cap(size_t sz)
 
 #define ELEM_CNT 62
 
-int test_hashmap_generic(void)
+static void test_hashmap_generic(void)
 {
        struct hashmap_entry *entry, *tmp;
        int err, bkt, found_cnt, i;
        long long found_msk;
        struct hashmap *map;
 
-       fprintf(stderr, "%s: ", __func__);
-
        map = hashmap__new(hash_fn, equal_fn, NULL);
-       if (CHECK(IS_ERR(map), "failed to create map: %ld\n", PTR_ERR(map)))
-               return 1;
+       if (CHECK(IS_ERR(map), "hashmap__new",
+                 "failed to create map: %ld\n", PTR_ERR(map)))
+               return;
 
        for (i = 0; i < ELEM_CNT; i++) {
                const void *oldk, *k = (const void *)(long)i;
                void *oldv, *v = (void *)(long)(1024 + i);
 
                err = hashmap__update(map, k, v, &oldk, &oldv);
-               if (CHECK(err != -ENOENT, "unexpected result: %d\n", err))
-                       return 1;
+               if (CHECK(err != -ENOENT, "hashmap__update",
+                         "unexpected result: %d\n", err))
+                       goto cleanup;
 
                if (i % 2) {
                        err = hashmap__add(map, k, v);
                } else {
                        err = hashmap__set(map, k, v, &oldk, &oldv);
-                       if (CHECK(oldk != NULL || oldv != NULL,
+                       if (CHECK(oldk != NULL || oldv != NULL, "check_kv",
                                  "unexpected k/v: %p=%p\n", oldk, oldv))
-                               return 1;
+                               goto cleanup;
                }
 
-               if (CHECK(err, "failed to add k/v %ld = %ld: %d\n",
+               if (CHECK(err, "elem_add", "failed to add k/v %ld = %ld: %d\n",
                               (long)k, (long)v, err))
-                       return 1;
+                       goto cleanup;
 
-               if (CHECK(!hashmap__find(map, k, &oldv),
+               if (CHECK(!hashmap__find(map, k, &oldv), "elem_find",
                          "failed to find key %ld\n", (long)k))
-                       return 1;
-               if (CHECK(oldv != v, "found value is wrong: %ld\n", (long)oldv))
-                       return 1;
+                       goto cleanup;
+               if (CHECK(oldv != v, "elem_val",
+                         "found value is wrong: %ld\n", (long)oldv))
+                       goto cleanup;
        }
 
-       if (CHECK(hashmap__size(map) != ELEM_CNT,
+       if (CHECK(hashmap__size(map) != ELEM_CNT, "hashmap__size",
                  "invalid map size: %zu\n", hashmap__size(map)))
-               return 1;
+               goto cleanup;
        if (CHECK(hashmap__capacity(map) != exp_cap(hashmap__size(map)),
+                 "hashmap_cap",
                  "unexpected map capacity: %zu\n", hashmap__capacity(map)))
-               return 1;
+               goto cleanup;
 
        found_msk = 0;
        hashmap__for_each_entry(map, entry, bkt) {
@@ -103,42 +96,47 @@ int test_hashmap_generic(void)
                long v = (long)entry->value;
 
                found_msk |= 1ULL << k;
-               if (CHECK(v - k != 1024, "invalid k/v pair: %ld = %ld\n", k, v))
-                       return 1;
+               if (CHECK(v - k != 1024, "check_kv",
+                         "invalid k/v pair: %ld = %ld\n", k, v))
+                       goto cleanup;
        }
-       if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1,
+       if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1, "elem_cnt",
                  "not all keys iterated: %llx\n", found_msk))
-               return 1;
+               goto cleanup;
 
        for (i = 0; i < ELEM_CNT; i++) {
                const void *oldk, *k = (const void *)(long)i;
                void *oldv, *v = (void *)(long)(256 + i);
 
                err = hashmap__add(map, k, v);
-               if (CHECK(err != -EEXIST, "unexpected add result: %d\n", err))
-                       return 1;
+               if (CHECK(err != -EEXIST, "hashmap__add",
+                         "unexpected add result: %d\n", err))
+                       goto cleanup;
 
                if (i % 2)
                        err = hashmap__update(map, k, v, &oldk, &oldv);
                else
                        err = hashmap__set(map, k, v, &oldk, &oldv);
 
-               if (CHECK(err, "failed to update k/v %ld = %ld: %d\n",
-                              (long)k, (long)v, err))
-                       return 1;
-               if (CHECK(!hashmap__find(map, k, &oldv),
+               if (CHECK(err, "elem_upd",
+                         "failed to update k/v %ld = %ld: %d\n",
+                         (long)k, (long)v, err))
+                       goto cleanup;
+               if (CHECK(!hashmap__find(map, k, &oldv), "elem_find",
                          "failed to find key %ld\n", (long)k))
-                       return 1;
-               if (CHECK(oldv != v, "found value is wrong: %ld\n", (long)oldv))
-                       return 1;
+                       goto cleanup;
+               if (CHECK(oldv != v, "elem_val",
+                         "found value is wrong: %ld\n", (long)oldv))
+                       goto cleanup;
        }
 
-       if (CHECK(hashmap__size(map) != ELEM_CNT,
+       if (CHECK(hashmap__size(map) != ELEM_CNT, "hashmap__size",
                  "invalid updated map size: %zu\n", hashmap__size(map)))
-               return 1;
+               goto cleanup;
        if (CHECK(hashmap__capacity(map) != exp_cap(hashmap__size(map)),
+                 "hashmap__capacity",
                  "unexpected map capacity: %zu\n", hashmap__capacity(map)))
-               return 1;
+               goto cleanup;
 
        found_msk = 0;
        hashmap__for_each_entry_safe(map, entry, tmp, bkt) {
@@ -146,20 +144,21 @@ int test_hashmap_generic(void)
                long v = (long)entry->value;
 
                found_msk |= 1ULL << k;
-               if (CHECK(v - k != 256,
+               if (CHECK(v - k != 256, "elem_check",
                          "invalid updated k/v pair: %ld = %ld\n", k, v))
-                       return 1;
+                       goto cleanup;
        }
-       if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1,
+       if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1, "elem_cnt",
                  "not all keys iterated after update: %llx\n", found_msk))
-               return 1;
+               goto cleanup;
 
        found_cnt = 0;
        hashmap__for_each_key_entry(map, entry, (void *)0) {
                found_cnt++;
        }
-       if (CHECK(!found_cnt, "didn't find any entries for key 0\n"))
-               return 1;
+       if (CHECK(!found_cnt, "found_cnt",
+                 "didn't find any entries for key 0\n"))
+               goto cleanup;
 
        found_msk = 0;
        found_cnt = 0;
@@ -173,30 +172,31 @@ int test_hashmap_generic(void)
                found_cnt++;
                found_msk |= 1ULL << (long)k;
 
-               if (CHECK(!hashmap__delete(map, k, &oldk, &oldv),
+               if (CHECK(!hashmap__delete(map, k, &oldk, &oldv), "elem_del",
                          "failed to delete k/v %ld = %ld\n",
                          (long)k, (long)v))
-                       return 1;
-               if (CHECK(oldk != k || oldv != v,
+                       goto cleanup;
+               if (CHECK(oldk != k || oldv != v, "check_old",
                          "invalid deleted k/v: expected %ld = %ld, got %ld = %ld\n",
                          (long)k, (long)v, (long)oldk, (long)oldv))
-                       return 1;
-               if (CHECK(hashmap__delete(map, k, &oldk, &oldv),
+                       goto cleanup;
+               if (CHECK(hashmap__delete(map, k, &oldk, &oldv), "elem_del",
                          "unexpectedly deleted k/v %ld = %ld\n",
                          (long)oldk, (long)oldv))
-                       return 1;
+                       goto cleanup;
        }
 
-       if (CHECK(!found_cnt || !found_msk,
+       if (CHECK(!found_cnt || !found_msk, "found_entries",
                  "didn't delete any key entries\n"))
-               return 1;
-       if (CHECK(hashmap__size(map) != ELEM_CNT - found_cnt,
+               goto cleanup;
+       if (CHECK(hashmap__size(map) != ELEM_CNT - found_cnt, "elem_cnt",
                  "invalid updated map size (already deleted: %d): %zu\n",
                  found_cnt, hashmap__size(map)))
-               return 1;
+               goto cleanup;
        if (CHECK(hashmap__capacity(map) != exp_cap(hashmap__size(map)),
+                 "hashmap__capacity",
                  "unexpected map capacity: %zu\n", hashmap__capacity(map)))
-               return 1;
+               goto cleanup;
 
        hashmap__for_each_entry_safe(map, entry, tmp, bkt) {
                const void *oldk, *k;
@@ -208,53 +208,56 @@ int test_hashmap_generic(void)
                found_cnt++;
                found_msk |= 1ULL << (long)k;
 
-               if (CHECK(!hashmap__delete(map, k, &oldk, &oldv),
+               if (CHECK(!hashmap__delete(map, k, &oldk, &oldv), "elem_del",
                          "failed to delete k/v %ld = %ld\n",
                          (long)k, (long)v))
-                       return 1;
-               if (CHECK(oldk != k || oldv != v,
+                       goto cleanup;
+               if (CHECK(oldk != k || oldv != v, "elem_check",
                          "invalid old k/v: expect %ld = %ld, got %ld = %ld\n",
                          (long)k, (long)v, (long)oldk, (long)oldv))
-                       return 1;
-               if (CHECK(hashmap__delete(map, k, &oldk, &oldv),
+                       goto cleanup;
+               if (CHECK(hashmap__delete(map, k, &oldk, &oldv), "elem_del",
                          "unexpectedly deleted k/v %ld = %ld\n",
                          (long)k, (long)v))
-                       return 1;
+                       goto cleanup;
        }
 
        if (CHECK(found_cnt != ELEM_CNT || found_msk != (1ULL << ELEM_CNT) - 1,
+                 "found_cnt",
                  "not all keys were deleted: found_cnt:%d, found_msk:%llx\n",
                  found_cnt, found_msk))
-               return 1;
-       if (CHECK(hashmap__size(map) != 0,
+               goto cleanup;
+       if (CHECK(hashmap__size(map) != 0, "hashmap__size",
                  "invalid updated map size (already deleted: %d): %zu\n",
                  found_cnt, hashmap__size(map)))
-               return 1;
+               goto cleanup;
 
        found_cnt = 0;
        hashmap__for_each_entry(map, entry, bkt) {
-               CHECK(false, "unexpected map entries left: %ld = %ld\n",
-                            (long)entry->key, (long)entry->value);
-               return 1;
+               CHECK(false, "elem_exists",
+                     "unexpected map entries left: %ld = %ld\n",
+                     (long)entry->key, (long)entry->value);
+               goto cleanup;
        }
 
-       hashmap__free(map);
+       hashmap__clear(map);
        hashmap__for_each_entry(map, entry, bkt) {
-               CHECK(false, "unexpected map entries left: %ld = %ld\n",
-                            (long)entry->key, (long)entry->value);
-               return 1;
+               CHECK(false, "elem_exists",
+                     "unexpected map entries left: %ld = %ld\n",
+                     (long)entry->key, (long)entry->value);
+               goto cleanup;
        }
 
-       fprintf(stderr, "OK\n");
-       return 0;
+cleanup:
+       hashmap__free(map);
 }
 
-size_t collision_hash_fn(const void *k, void *ctx)
+static size_t collision_hash_fn(const void *k, void *ctx)
 {
        return 0;
 }
 
-int test_hashmap_multimap(void)
+static void test_hashmap_multimap(void)
 {
        void *k1 = (void *)0, *k2 = (void *)1;
        struct hashmap_entry *entry;
@@ -262,121 +265,116 @@ int test_hashmap_multimap(void)
        long found_msk;
        int err, bkt;
 
-       fprintf(stderr, "%s: ", __func__);
-
        /* force collisions */
        map = hashmap__new(collision_hash_fn, equal_fn, NULL);
-       if (CHECK(IS_ERR(map), "failed to create map: %ld\n", PTR_ERR(map)))
-               return 1;
-
+       if (CHECK(IS_ERR(map), "hashmap__new",
+                 "failed to create map: %ld\n", PTR_ERR(map)))
+               return;
 
        /* set up multimap:
         * [0] -> 1, 2, 4;
         * [1] -> 8, 16, 32;
         */
        err = hashmap__append(map, k1, (void *)1);
-       if (CHECK(err, "failed to add k/v: %d\n", err))
-               return 1;
+       if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))
+               goto cleanup;
        err = hashmap__append(map, k1, (void *)2);
-       if (CHECK(err, "failed to add k/v: %d\n", err))
-               return 1;
+       if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))
+               goto cleanup;
        err = hashmap__append(map, k1, (void *)4);
-       if (CHECK(err, "failed to add k/v: %d\n", err))
-               return 1;
+       if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))
+               goto cleanup;
 
        err = hashmap__append(map, k2, (void *)8);
-       if (CHECK(err, "failed to add k/v: %d\n", err))
-               return 1;
+       if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))
+               goto cleanup;
        err = hashmap__append(map, k2, (void *)16);
-       if (CHECK(err, "failed to add k/v: %d\n", err))
-               return 1;
+       if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))
+               goto cleanup;
        err = hashmap__append(map, k2, (void *)32);
-       if (CHECK(err, "failed to add k/v: %d\n", err))
-               return 1;
+       if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))
+               goto cleanup;
 
-       if (CHECK(hashmap__size(map) != 6,
+       if (CHECK(hashmap__size(map) != 6, "hashmap_size",
                  "invalid map size: %zu\n", hashmap__size(map)))
-               return 1;
+               goto cleanup;
 
        /* verify global iteration still works and sees all values */
        found_msk = 0;
        hashmap__for_each_entry(map, entry, bkt) {
                found_msk |= (long)entry->value;
        }
-       if (CHECK(found_msk != (1 << 6) - 1,
+       if (CHECK(found_msk != (1 << 6) - 1, "found_msk",
                  "not all keys iterated: %lx\n", found_msk))
-               return 1;
+               goto cleanup;
 
        /* iterate values for key 1 */
        found_msk = 0;
        hashmap__for_each_key_entry(map, entry, k1) {
                found_msk |= (long)entry->value;
        }
-       if (CHECK(found_msk != (1 | 2 | 4),
+       if (CHECK(found_msk != (1 | 2 | 4), "found_msk",
                  "invalid k1 values: %lx\n", found_msk))
-               return 1;
+               goto cleanup;
 
        /* iterate values for key 2 */
        found_msk = 0;
        hashmap__for_each_key_entry(map, entry, k2) {
                found_msk |= (long)entry->value;
        }
-       if (CHECK(found_msk != (8 | 16 | 32),
+       if (CHECK(found_msk != (8 | 16 | 32), "found_msk",
                  "invalid k2 values: %lx\n", found_msk))
-               return 1;
+               goto cleanup;
 
-       fprintf(stderr, "OK\n");
-       return 0;
+cleanup:
+       hashmap__free(map);
 }
 
-int test_hashmap_empty()
+static void test_hashmap_empty()
 {
        struct hashmap_entry *entry;
        int bkt;
        struct hashmap *map;
        void *k = (void *)0;
 
-       fprintf(stderr, "%s: ", __func__);
-
        /* force collisions */
        map = hashmap__new(hash_fn, equal_fn, NULL);
-       if (CHECK(IS_ERR(map), "failed to create map: %ld\n", PTR_ERR(map)))
-               return 1;
+       if (CHECK(IS_ERR(map), "hashmap__new",
+                 "failed to create map: %ld\n", PTR_ERR(map)))
+               goto cleanup;
 
-       if (CHECK(hashmap__size(map) != 0,
+       if (CHECK(hashmap__size(map) != 0, "hashmap__size",
                  "invalid map size: %zu\n", hashmap__size(map)))
-               return 1;
-       if (CHECK(hashmap__capacity(map) != 0,
+               goto cleanup;
+       if (CHECK(hashmap__capacity(map) != 0, "hashmap__capacity",
                  "invalid map capacity: %zu\n", hashmap__capacity(map)))
-               return 1;
-       if (CHECK(hashmap__find(map, k, NULL), "unexpected find\n"))
-               return 1;
-       if (CHECK(hashmap__delete(map, k, NULL, NULL), "unexpected delete\n"))
-               return 1;
+               goto cleanup;
+       if (CHECK(hashmap__find(map, k, NULL), "elem_find",
+                 "unexpected find\n"))
+               goto cleanup;
+       if (CHECK(hashmap__delete(map, k, NULL, NULL), "elem_del",
+                 "unexpected delete\n"))
+               goto cleanup;
 
        hashmap__for_each_entry(map, entry, bkt) {
-               CHECK(false, "unexpected iterated entry\n");
-               return 1;
+               CHECK(false, "elem_found", "unexpected iterated entry\n");
+               goto cleanup;
        }
        hashmap__for_each_key_entry(map, entry, k) {
-               CHECK(false, "unexpected key entry\n");
-               return 1;
+               CHECK(false, "key_found", "unexpected key entry\n");
+               goto cleanup;
        }
 
-       fprintf(stderr, "OK\n");
-       return 0;
+cleanup:
+       hashmap__free(map);
 }
 
-int main(int argc, char **argv)
+void test_hashmap()
 {
-       bool failed = false;
-
-       if (test_hashmap_generic())
-               failed = true;
-       if (test_hashmap_multimap())
-               failed = true;
-       if (test_hashmap_empty())
-               failed = true;
-
-       return failed;
+       if (test__start_subtest("generic"))
+               test_hashmap_generic();
+       if (test__start_subtest("multimap"))
+               test_hashmap_multimap();
+       if (test__start_subtest("empty"))
+               test_hashmap_empty();
 }