tools/bpf: refactor test_btf pretty printing for multiple map value formats

The test_btf pretty print is refactored in order to easily
support multiple map value formats. The next patch will
add __int128 type tests which needs macro guard __SIZEOF_INT128__.
There is no functionality change with this patch.

Acked-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

diff --git a/tools/testing/selftests/bpf/test_btf.c b/tools/testing/selftests/bpf/test_btf.c
index 69f5058..02b00c9 100644 (file)
--- a/tools/testing/selftests/bpf/test_btf.c
+++ b/tools/testing/selftests/bpf/test_btf.c
@@ -18,6 +18,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <assert.h>
 #include <bpf/libbpf.h>
 #include <bpf/btf.h>
 
@@ -134,6 +135,11 @@ static struct btf_header hdr_tmpl = {
        .hdr_len = sizeof(struct btf_header),
 };
 
+/* several different mapv kinds(types) supported by pprint */
+enum pprint_mapv_kind_t {
+       PPRINT_MAPV_KIND_BASIC = 0,
+};
+
 struct btf_raw_test {
        const char *descr;
        const char *str_sec;
@@ -156,6 +162,7 @@ struct btf_raw_test {
        int type_off_delta;
        int str_off_delta;
        int str_len_delta;
+       enum pprint_mapv_kind_t mapv_kind;
 };
 
 #define BTF_STR_SEC(str) \
@@ -3880,24 +3887,69 @@ static struct btf_pprint_test_meta {
 
 };
 
+static size_t get_pprint_mapv_size(enum pprint_mapv_kind_t mapv_kind)
+{
+       if (mapv_kind == PPRINT_MAPV_KIND_BASIC)
+               return sizeof(struct pprint_mapv);
 
-static void set_pprint_mapv(struct pprint_mapv *v, uint32_t i,
+       assert(0);
+}
+
+static void set_pprint_mapv(enum pprint_mapv_kind_t mapv_kind,
+                           void *mapv, uint32_t i,
                            int num_cpus, int rounded_value_size)
 {
        int cpu;
 
-       for (cpu = 0; cpu < num_cpus; cpu++) {
-               v->ui32 = i + cpu;
-               v->si32 = -i;
-               v->unused_bits2a = 3;
-               v->bits28 = i;
-               v->unused_bits2b = 3;
-               v->ui64 = i;
-               v->aenum = i & 0x03;
-               v->ui32b = 4;
-               v->bits2c = 1;
-               v = (void *)v + rounded_value_size;
+       if (mapv_kind == PPRINT_MAPV_KIND_BASIC) {
+               struct pprint_mapv *v = mapv;
+
+               for (cpu = 0; cpu < num_cpus; cpu++) {
+                       v->ui32 = i + cpu;
+                       v->si32 = -i;
+                       v->unused_bits2a = 3;
+                       v->bits28 = i;
+                       v->unused_bits2b = 3;
+                       v->ui64 = i;
+                       v->aenum = i & 0x03;
+                       v->ui32b = 4;
+                       v->bits2c = 1;
+                       v = (void *)v + rounded_value_size;
+               }
+       }
+}
+
+ssize_t get_pprint_expected_line(enum pprint_mapv_kind_t mapv_kind,
+                                char *expected_line, ssize_t line_size,
+                                bool percpu_map, unsigned int next_key,
+                                int cpu, void *mapv)
+{
+       ssize_t nexpected_line = -1;
+
+       if (mapv_kind == PPRINT_MAPV_KIND_BASIC) {
+               struct pprint_mapv *v = mapv;
+
+               nexpected_line = snprintf(expected_line, line_size,
+                                         "%s%u: {%u,0,%d,0x%x,0x%x,0x%x,"
+                                         "{%lu|[%u,%u,%u,%u,%u,%u,%u,%u]},%s,"
+                                         "%u,0x%x}\n",
+                                         percpu_map ? "\tcpu" : "",
+                                         percpu_map ? cpu : next_key,
+                                         v->ui32, v->si32,
+                                         v->unused_bits2a,
+                                         v->bits28,
+                                         v->unused_bits2b,
+                                         v->ui64,
+                                         v->ui8a[0], v->ui8a[1],
+                                         v->ui8a[2], v->ui8a[3],
+                                         v->ui8a[4], v->ui8a[5],
+                                         v->ui8a[6], v->ui8a[7],
+                                         pprint_enum_str[v->aenum],
+                                         v->ui32b,
+                                         v->bits2c);
        }
+
+       return nexpected_line;
 }
 
 static int check_line(const char *expected_line, int nexpected_line,
@@ -3921,10 +3973,10 @@ static int check_line(const char *expected_line, int nexpected_line,
 static int do_test_pprint(int test_num)
 {
        const struct btf_raw_test *test = &pprint_test_template[test_num];
+       enum pprint_mapv_kind_t mapv_kind = test->mapv_kind;
        struct bpf_create_map_attr create_attr = {};
        bool ordered_map, lossless_map, percpu_map;
        int err, ret, num_cpus, rounded_value_size;
-       struct pprint_mapv *mapv = NULL;
        unsigned int key, nr_read_elems;
        int map_fd = -1, btf_fd = -1;
        unsigned int raw_btf_size;
@@ -3933,6 +3985,7 @@ static int do_test_pprint(int test_num)
        char pin_path[255];
        size_t line_len = 0;
        char *line = NULL;
+       void *mapv = NULL;
        uint8_t *raw_btf;
        ssize_t nread;
 
@@ -3985,7 +4038,7 @@ static int do_test_pprint(int test_num)
 
        percpu_map = test->percpu_map;
        num_cpus = percpu_map ? bpf_num_possible_cpus() : 1;
-       rounded_value_size = round_up(sizeof(struct pprint_mapv), 8);
+       rounded_value_size = round_up(get_pprint_mapv_size(mapv_kind), 8);
        mapv = calloc(num_cpus, rounded_value_size);
        if (CHECK(!mapv, "mapv allocation failure")) {
                err = -1;
@@ -3993,7 +4046,7 @@ static int do_test_pprint(int test_num)
        }
 
        for (key = 0; key < test->max_entries; key++) {
-               set_pprint_mapv(mapv, key, num_cpus, rounded_value_size);
+               set_pprint_mapv(mapv_kind, mapv, key, num_cpus, rounded_value_size);
                bpf_map_update_elem(map_fd, &key, mapv, 0);
        }
 
@@ -4017,13 +4070,13 @@ static int do_test_pprint(int test_num)
        ordered_map = test->ordered_map;
        lossless_map = test->lossless_map;
        do {
-               struct pprint_mapv *cmapv;
                ssize_t nexpected_line;
                unsigned int next_key;
+               void *cmapv;
                int cpu;
 
                next_key = ordered_map ? nr_read_elems : atoi(line);
-               set_pprint_mapv(mapv, next_key, num_cpus, rounded_value_size);
+               set_pprint_mapv(mapv_kind, mapv, next_key, num_cpus, rounded_value_size);
                cmapv = mapv;
 
                for (cpu = 0; cpu < num_cpus; cpu++) {
@@ -4056,31 +4109,16 @@ static int do_test_pprint(int test_num)
                                        break;
                        }
 
-                       nexpected_line = snprintf(expected_line, sizeof(expected_line),
-                                                 "%s%u: {%u,0,%d,0x%x,0x%x,0x%x,"
-                                                 "{%lu|[%u,%u,%u,%u,%u,%u,%u,%u]},%s,"
-                                                 "%u,0x%x}\n",
-                                                 percpu_map ? "\tcpu" : "",
-                                                 percpu_map ? cpu : next_key,
-                                                 cmapv->ui32, cmapv->si32,
-                                                 cmapv->unused_bits2a,
-                                                 cmapv->bits28,
-                                                 cmapv->unused_bits2b,
-                                                 cmapv->ui64,
-                                                 cmapv->ui8a[0], cmapv->ui8a[1],
-                                                 cmapv->ui8a[2], cmapv->ui8a[3],
-                                                 cmapv->ui8a[4], cmapv->ui8a[5],
-                                                 cmapv->ui8a[6], cmapv->ui8a[7],
-                                                 pprint_enum_str[cmapv->aenum],
-                                                 cmapv->ui32b,
-                                                 cmapv->bits2c);
-
+                       nexpected_line = get_pprint_expected_line(mapv_kind, expected_line,
+                                                                 sizeof(expected_line),
+                                                                 percpu_map, next_key,
+                                                                 cpu, cmapv);
                        err = check_line(expected_line, nexpected_line,
                                         sizeof(expected_line), line);
                        if (err == -1)
                                goto done;
 
-                       cmapv = (void *)cmapv + rounded_value_size;
+                       cmapv = cmapv + rounded_value_size;
                }
 
                if (percpu_map) {