selftests/bpf: Tests for btf_dedup_resolve_fwds

Tests to verify the following behavior of `btf_dedup_resolve_fwds`:
- remapping for struct forward declarations;
- remapping for union forward declarations;
- no remapping if forward declaration kind does not match similarly
  named struct or union declaration;
- no remapping if forward declaration name is ambiguous;
- base ids are considered for fwd resolution in split btf scenario.

Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Reviewed-by: Alan Maguire <alan.maguire@oracle.com>
Link: https://lore.kernel.org/bpf/20221109142611.879983-4-eddyz87@gmail.com

diff --git a/tools/testing/selftests/bpf/prog_tests/btf.c b/tools/testing/selftests/bpf/prog_tests/btf.c
index c3e1cea..95a2b80 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/btf.c
+++ b/tools/testing/selftests/bpf/prog_tests/btf.c
@@ -7690,6 +7690,182 @@ static struct btf_dedup_test dedup_tests[] = {
                BTF_STR_SEC("\0e1\0e1_val\0td"),
        },
 },
+{
+       .descr = "dedup: standalone fwd declaration struct",
+       /*
+        * Verify that CU1:foo and CU2:foo would be unified and that
+        * typedef/ptr would be updated to point to CU1:foo.
+        *
+        * // CU 1:
+        * struct foo { int x; };
+        *
+        * // CU 2:
+        * struct foo;
+        * typedef struct foo *foo_ptr;
+        */
+       .input = {
+               .raw_types = {
+                       /* CU 1 */
+                       BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       /* CU 2 */
+                       BTF_FWD_ENC(NAME_NTH(1), 0),                   /* [3] */
+                       BTF_PTR_ENC(3),                                /* [4] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0foo_ptr"),
+       },
+       .expect = {
+               .raw_types = {
+                       BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       BTF_PTR_ENC(1),                                /* [3] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(3), 3),               /* [4] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0foo_ptr"),
+       },
+},
+{
+       .descr = "dedup: standalone fwd declaration union",
+       /*
+        * Verify that CU1:foo and CU2:foo would be unified and that
+        * typedef/ptr would be updated to point to CU1:foo.
+        * Same as "dedup: standalone fwd declaration struct" but for unions.
+        *
+        * // CU 1:
+        * union foo { int x; };
+        *
+        * // CU 2:
+        * union foo;
+        * typedef union foo *foo_ptr;
+        */
+       .input = {
+               .raw_types = {
+                       /* CU 1 */
+                       BTF_UNION_ENC(NAME_NTH(1), 1, 4),              /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       /* CU 2 */
+                       BTF_FWD_ENC(NAME_TBD, 1),                      /* [3] */
+                       BTF_PTR_ENC(3),                                /* [4] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0foo_ptr"),
+       },
+       .expect = {
+               .raw_types = {
+                       BTF_UNION_ENC(NAME_NTH(1), 1, 4),              /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       BTF_PTR_ENC(1),                                /* [3] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(3), 3),               /* [4] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0foo_ptr"),
+       },
+},
+{
+       .descr = "dedup: standalone fwd declaration wrong kind",
+       /*
+        * Negative test for btf_dedup_resolve_fwds:
+        * - CU1:foo is a struct, C2:foo is a union, thus CU2:foo is not deduped;
+        * - typedef/ptr should remain unchanged as well.
+        *
+        * // CU 1:
+        * struct foo { int x; };
+        *
+        * // CU 2:
+        * union foo;
+        * typedef union foo *foo_ptr;
+        */
+       .input = {
+               .raw_types = {
+                       /* CU 1 */
+                       BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       /* CU 2 */
+                       BTF_FWD_ENC(NAME_NTH(3), 1),                   /* [3] */
+                       BTF_PTR_ENC(3),                                /* [4] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0foo_ptr"),
+       },
+       .expect = {
+               .raw_types = {
+                       /* CU 1 */
+                       BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       /* CU 2 */
+                       BTF_FWD_ENC(NAME_NTH(3), 1),                   /* [3] */
+                       BTF_PTR_ENC(3),                                /* [4] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(3), 4),               /* [5] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0foo_ptr"),
+       },
+},
+{
+       .descr = "dedup: standalone fwd declaration name conflict",
+       /*
+        * Negative test for btf_dedup_resolve_fwds:
+        * - two candidates for CU2:foo dedup, thus it is unchanged;
+        * - typedef/ptr should remain unchanged as well.
+        *
+        * // CU 1:
+        * struct foo { int x; };
+        *
+        * // CU 2:
+        * struct foo;
+        * typedef struct foo *foo_ptr;
+        *
+        * // CU 3:
+        * struct foo { int x; int y; };
+        */
+       .input = {
+               .raw_types = {
+                       /* CU 1 */
+                       BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       /* CU 2 */
+                       BTF_FWD_ENC(NAME_NTH(1), 0),                   /* [3] */
+                       BTF_PTR_ENC(3),                                /* [4] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(4), 4),               /* [5] */
+                       /* CU 3 */
+                       BTF_STRUCT_ENC(NAME_NTH(1), 2, 8),             /* [6] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_MEMBER_ENC(NAME_NTH(3), 2, 0),
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0y\0foo_ptr"),
+       },
+       .expect = {
+               .raw_types = {
+                       /* CU 1 */
+                       BTF_STRUCT_ENC(NAME_NTH(1), 1, 4),             /* [1] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
+                       /* CU 2 */
+                       BTF_FWD_ENC(NAME_NTH(1), 0),                   /* [3] */
+                       BTF_PTR_ENC(3),                                /* [4] */
+                       BTF_TYPEDEF_ENC(NAME_NTH(4), 4),               /* [5] */
+                       /* CU 3 */
+                       BTF_STRUCT_ENC(NAME_NTH(1), 2, 8),             /* [6] */
+                       BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
+                       BTF_MEMBER_ENC(NAME_NTH(3), 2, 0),
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0foo\0x\0y\0foo_ptr"),
+       },
+},
 };
 
 static int btf_type_size(const struct btf_type *t)

diff --git a/tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c b/tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c
index 90aac43..d9024c7 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c
+++ b/tools/testing/selftests/bpf/prog_tests/btf_dedup_split.c
@@ -143,6 +143,10 @@ static void test_split_fwd_resolve() {
        btf__add_struct(btf1, "s2", 4);                 /* [5] struct s2 { */
        btf__add_field(btf1, "f1", 1, 0, 0);            /*      int f1; */
                                                        /* } */
+       /* keep this not a part of type the graph to test btf_dedup_resolve_fwds */
+       btf__add_struct(btf1, "s3", 4);                 /* [6] struct s3 { */
+       btf__add_field(btf1, "f1", 1, 0, 0);            /*      int f1; */
+                                                       /* } */
 
        VALIDATE_RAW_BTF(
                btf1,
@@ -153,20 +157,24 @@ static void test_split_fwd_resolve() {
                "\t'f1' type_id=2 bits_offset=0\n"
                "\t'f2' type_id=3 bits_offset=64",
                "[5] STRUCT 's2' size=4 vlen=1\n"
+               "\t'f1' type_id=1 bits_offset=0",
+               "[6] STRUCT 's3' size=4 vlen=1\n"
                "\t'f1' type_id=1 bits_offset=0");
 
        btf2 = btf__new_empty_split(btf1);
        if (!ASSERT_OK_PTR(btf2, "empty_split_btf"))
                goto cleanup;
 
-       btf__add_int(btf2, "int", 4, BTF_INT_SIGNED);   /* [6] int */
-       btf__add_ptr(btf2, 10);                         /* [7] ptr to struct s1 */
-       btf__add_fwd(btf2, "s2", BTF_FWD_STRUCT);       /* [8] fwd for struct s2 */
-       btf__add_ptr(btf2, 8);                          /* [9] ptr to fwd struct s2 */
-       btf__add_struct(btf2, "s1", 16);                /* [10] struct s1 { */
-       btf__add_field(btf2, "f1", 7, 0, 0);            /*      struct s1 *f1; */
-       btf__add_field(btf2, "f2", 9, 64, 0);           /*      struct s2 *f2; */
+       btf__add_int(btf2, "int", 4, BTF_INT_SIGNED);   /* [7] int */
+       btf__add_ptr(btf2, 11);                         /* [8] ptr to struct s1 */
+       btf__add_fwd(btf2, "s2", BTF_FWD_STRUCT);       /* [9] fwd for struct s2 */
+       btf__add_ptr(btf2, 9);                          /* [10] ptr to fwd struct s2 */
+       btf__add_struct(btf2, "s1", 16);                /* [11] struct s1 { */
+       btf__add_field(btf2, "f1", 8, 0, 0);            /*      struct s1 *f1; */
+       btf__add_field(btf2, "f2", 10, 64, 0);          /*      struct s2 *f2; */
                                                        /* } */
+       btf__add_fwd(btf2, "s3", BTF_FWD_STRUCT);       /* [12] fwd for struct s3 */
+       btf__add_ptr(btf2, 12);                         /* [13] ptr to struct s1 */
 
        VALIDATE_RAW_BTF(
                btf2,
@@ -178,13 +186,17 @@ static void test_split_fwd_resolve() {
                "\t'f2' type_id=3 bits_offset=64",
                "[5] STRUCT 's2' size=4 vlen=1\n"
                "\t'f1' type_id=1 bits_offset=0",
-               "[6] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
-               "[7] PTR '(anon)' type_id=10",
-               "[8] FWD 's2' fwd_kind=struct",
-               "[9] PTR '(anon)' type_id=8",
-               "[10] STRUCT 's1' size=16 vlen=2\n"
-               "\t'f1' type_id=7 bits_offset=0\n"
-               "\t'f2' type_id=9 bits_offset=64");
+               "[6] STRUCT 's3' size=4 vlen=1\n"
+               "\t'f1' type_id=1 bits_offset=0",
+               "[7] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
+               "[8] PTR '(anon)' type_id=11",
+               "[9] FWD 's2' fwd_kind=struct",
+               "[10] PTR '(anon)' type_id=9",
+               "[11] STRUCT 's1' size=16 vlen=2\n"
+               "\t'f1' type_id=8 bits_offset=0\n"
+               "\t'f2' type_id=10 bits_offset=64",
+               "[12] FWD 's3' fwd_kind=struct",
+               "[13] PTR '(anon)' type_id=12");
 
        err = btf__dedup(btf2, NULL);
        if (!ASSERT_OK(err, "btf_dedup"))
@@ -199,7 +211,10 @@ static void test_split_fwd_resolve() {
                "\t'f1' type_id=2 bits_offset=0\n"
                "\t'f2' type_id=3 bits_offset=64",
                "[5] STRUCT 's2' size=4 vlen=1\n"
-               "\t'f1' type_id=1 bits_offset=0");
+               "\t'f1' type_id=1 bits_offset=0",
+               "[6] STRUCT 's3' size=4 vlen=1\n"
+               "\t'f1' type_id=1 bits_offset=0",
+               "[7] PTR '(anon)' type_id=6");
 
 cleanup:
        btf__free(btf2);