selftests/bpf: Add a btf_dump test for type_tags

Factor out common routines handling custom BTF from
test_btf_dump_incremental. Then use them in the
test_btf_dump_type_tags.

test_btf_dump_type_tags verifies that a type tag is dumped correctly
with respect to its kflag.

Signed-off-by: Ihor Solodrai <ihor.solodrai@linux.dev>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Acked-by: Eduard Zingerman <eddyz87@gmail.com>
Link: https://lore.kernel.org/bpf/20250130201239.1429648-5-ihor.solodrai@linux.dev

diff --git a/tools/testing/selftests/bpf/prog_tests/btf_dump.c b/tools/testing/selftests/bpf/prog_tests/btf_dump.c
index b293b8501fd603f96ed5f4b1f61c393a75164d09..c0a776feec2305cbf5dc8ee4cd1baf59488d148e 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/btf_dump.c
+++ b/tools/testing/selftests/bpf/prog_tests/btf_dump.c
@@ -126,26 +126,69 @@ done:
        return err;
 }
 
-static char *dump_buf;
-static size_t dump_buf_sz;
-static FILE *dump_buf_file;
+struct test_ctx {
+       struct btf *btf;
+       struct btf_dump *d;
+       char *dump_buf;
+       size_t dump_buf_sz;
+       FILE *dump_buf_file;
+};
 
-static void test_btf_dump_incremental(void)
+static void test_ctx__free(struct test_ctx *t)
 {
-       struct btf *btf = NULL;
-       struct btf_dump *d = NULL;
-       int id, err, i;
+       fclose(t->dump_buf_file);
+       free(t->dump_buf);
+       btf_dump__free(t->d);
+       btf__free(t->btf);
+}
 
-       dump_buf_file = open_memstream(&dump_buf, &dump_buf_sz);
-       if (!ASSERT_OK_PTR(dump_buf_file, "dump_memstream"))
-               return;
-       btf = btf__new_empty();
-       if (!ASSERT_OK_PTR(btf, "new_empty"))
+static int test_ctx__init(struct test_ctx *t)
+{
+       t->dump_buf_file = open_memstream(&t->dump_buf, &t->dump_buf_sz);
+       if (!ASSERT_OK_PTR(t->dump_buf_file, "dump_memstream"))
+               return -1;
+       t->btf = btf__new_empty();
+       if (!ASSERT_OK_PTR(t->btf, "new_empty"))
                goto err_out;
-       d = btf_dump__new(btf, btf_dump_printf, dump_buf_file, NULL);
-       if (!ASSERT_OK(libbpf_get_error(d), "btf_dump__new"))
+       t->d = btf_dump__new(t->btf, btf_dump_printf, t->dump_buf_file, NULL);
+       if (!ASSERT_OK(libbpf_get_error(t->d), "btf_dump__new"))
                goto err_out;
 
+       return 0;
+
+err_out:
+       test_ctx__free(t);
+       return -1;
+}
+
+static void test_ctx__dump_and_compare(struct test_ctx *t,
+                                      const char *expected_output,
+                                      const char *message)
+{
+       int i, err;
+
+       for (i = 1; i < btf__type_cnt(t->btf); i++) {
+               err = btf_dump__dump_type(t->d, i);
+               ASSERT_OK(err, "dump_type_ok");
+       }
+
+       fflush(t->dump_buf_file);
+       t->dump_buf[t->dump_buf_sz] = 0; /* some libc implementations don't do this */
+
+       ASSERT_STREQ(t->dump_buf, expected_output, message);
+}
+
+static void test_btf_dump_incremental(void)
+{
+       struct test_ctx t = {};
+       struct btf *btf;
+       int id, err;
+
+       if (test_ctx__init(&t))
+               return;
+
+       btf = t.btf;
+
        /* First, generate BTF corresponding to the following C code:
         *
         * enum x;
@@ -182,15 +225,7 @@ static void test_btf_dump_incremental(void)
        err = btf__add_field(btf, "x", 4, 0, 0);
        ASSERT_OK(err, "field_ok");
 
-       for (i = 1; i < btf__type_cnt(btf); i++) {
-               err = btf_dump__dump_type(d, i);
-               ASSERT_OK(err, "dump_type_ok");
-       }
-
-       fflush(dump_buf_file);
-       dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */
-
-       ASSERT_STREQ(dump_buf,
+       test_ctx__dump_and_compare(&t,
 "enum x;\n"
 "\n"
 "enum x {\n"
@@ -221,7 +256,7 @@ static void test_btf_dump_incremental(void)
         * enum values don't conflict;
         *
         */
-       fseek(dump_buf_file, 0, SEEK_SET);
+       fseek(t.dump_buf_file, 0, SEEK_SET);
 
        id = btf__add_struct(btf, "s", 4);
        ASSERT_EQ(id, 7, "struct_id");
@@ -232,14 +267,7 @@ static void test_btf_dump_incremental(void)
        err = btf__add_field(btf, "s", 6, 64, 0);
        ASSERT_OK(err, "field_ok");
 
-       for (i = 1; i < btf__type_cnt(btf); i++) {
-               err = btf_dump__dump_type(d, i);
-               ASSERT_OK(err, "dump_type_ok");
-       }
-
-       fflush(dump_buf_file);
-       dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */
-       ASSERT_STREQ(dump_buf,
+       test_ctx__dump_and_compare(&t,
 "struct s___2 {\n"
 "      enum x x;\n"
 "      enum {\n"
@@ -248,11 +276,53 @@ static void test_btf_dump_incremental(void)
 "      struct s s;\n"
 "};\n\n" , "c_dump1");
 
-err_out:
-       fclose(dump_buf_file);
-       free(dump_buf);
-       btf_dump__free(d);
-       btf__free(btf);
+       test_ctx__free(&t);
+}
+
+static void test_btf_dump_type_tags(void)
+{
+       struct test_ctx t = {};
+       struct btf *btf;
+       int id, err;
+
+       if (test_ctx__init(&t))
+               return;
+
+       btf = t.btf;
+
+       /* Generate BTF corresponding to the following C code:
+        *
+        * struct s {
+        *   void __attribute__((btf_type_tag(\"void_tag\"))) *p1;
+        *   void __attribute__((void_attr)) *p2;
+        * };
+        *
+        */
+
+       id = btf__add_type_tag(btf, "void_tag", 0);
+       ASSERT_EQ(id, 1, "type_tag_id");
+       id = btf__add_ptr(btf, id);
+       ASSERT_EQ(id, 2, "void_ptr_id1");
+
+       id = btf__add_type_attr(btf, "void_attr", 0);
+       ASSERT_EQ(id, 3, "type_attr_id");
+       id = btf__add_ptr(btf, id);
+       ASSERT_EQ(id, 4, "void_ptr_id2");
+
+       id = btf__add_struct(btf, "s", 8);
+       ASSERT_EQ(id, 5, "struct_id");
+       err = btf__add_field(btf, "p1", 2, 0, 0);
+       ASSERT_OK(err, "field_ok1");
+       err = btf__add_field(btf, "p2", 4, 0, 0);
+       ASSERT_OK(err, "field_ok2");
+
+       test_ctx__dump_and_compare(&t,
+"struct s {\n"
+"      void __attribute__((btf_type_tag(\"void_tag\"))) *p1;\n"
+"      void __attribute__((void_attr)) *p2;\n"
+"};\n\n", "dump_and_compare");
+
+       test_ctx__free(&t);
 }
 
 #define STRSIZE                                4096
@@ -874,6 +944,9 @@ void test_btf_dump() {
        if (test__start_subtest("btf_dump: incremental"))
                test_btf_dump_incremental();
 
+       if (test__start_subtest("btf_dump: type_tags"))
+               test_btf_dump_type_tags();
+
        btf = libbpf_find_kernel_btf();
        if (!ASSERT_OK_PTR(btf, "no kernel BTF found"))
                return;