lkml.org 
[lkml]   [2022]   [Jan]   [24]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.16 0574/1039] libbpf: Accommodate DWARF/compiler bug with duplicated structs
    Date
    From: Andrii Nakryiko <andrii@kernel.org>

    [ Upstream commit efdd3eb8015e7447095f02a26eaabd164cd18004 ]

    According to [0], compilers sometimes might produce duplicate DWARF
    definitions for exactly the same struct/union within the same
    compilation unit (CU). We've had similar issues with identical arrays
    and handled them with a similar workaround in 6b6e6b1d09aa ("libbpf:
    Accomodate DWARF/compiler bug with duplicated identical arrays"). Do the
    same for struct/union by ensuring that two structs/unions are exactly
    the same, down to the integer values of field referenced type IDs.

    Solving this more generically (allowing referenced types to be
    equivalent, but using different type IDs, all within a single CU)
    requires a huge complexity increase to handle many-to-many mappings
    between canonidal and candidate type graphs. Before we invest in that,
    let's see if this approach handles all the instances of this issue in
    practice. Thankfully it's pretty rare, it seems.

    [0] https://lore.kernel.org/bpf/YXr2NFlJTAhHdZqq@krava/

    Reported-by: Jiri Olsa <jolsa@kernel.org>
    Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
    Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
    Link: https://lore.kernel.org/bpf/20211117194114.347675-1-andrii@kernel.org
    Signed-off-by: Sasha Levin <sashal@kernel.org>
    ---
    tools/lib/bpf/btf.c | 45 +++++++++++++++++++++++++++++++++++++++++----
    1 file changed, 41 insertions(+), 4 deletions(-)

    diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
    index c2400804d6bac..dc86259980231 100644
    --- a/tools/lib/bpf/btf.c
    +++ b/tools/lib/bpf/btf.c
    @@ -3443,8 +3443,8 @@ static long btf_hash_struct(struct btf_type *t)
    }

    /*
    - * Check structural compatibility of two FUNC_PROTOs, ignoring referenced type
    - * IDs. This check is performed during type graph equivalence check and
    + * Check structural compatibility of two STRUCTs/UNIONs, ignoring referenced
    + * type IDs. This check is performed during type graph equivalence check and
    * referenced types equivalence is checked separately.
    */
    static bool btf_shallow_equal_struct(struct btf_type *t1, struct btf_type *t2)
    @@ -3817,6 +3817,31 @@ static int btf_dedup_identical_arrays(struct btf_dedup *d, __u32 id1, __u32 id2)
    return btf_equal_array(t1, t2);
    }

    +/* Check if given two types are identical STRUCT/UNION definitions */
    +static bool btf_dedup_identical_structs(struct btf_dedup *d, __u32 id1, __u32 id2)
    +{
    + const struct btf_member *m1, *m2;
    + struct btf_type *t1, *t2;
    + int n, i;
    +
    + t1 = btf_type_by_id(d->btf, id1);
    + t2 = btf_type_by_id(d->btf, id2);
    +
    + if (!btf_is_composite(t1) || btf_kind(t1) != btf_kind(t2))
    + return false;
    +
    + if (!btf_shallow_equal_struct(t1, t2))
    + return false;
    +
    + m1 = btf_members(t1);
    + m2 = btf_members(t2);
    + for (i = 0, n = btf_vlen(t1); i < n; i++, m1++, m2++) {
    + if (m1->type != m2->type)
    + return false;
    + }
    + return true;
    +}
    +
    /*
    * Check equivalence of BTF type graph formed by candidate struct/union (we'll
    * call it "candidate graph" in this description for brevity) to a type graph
    @@ -3928,6 +3953,8 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,

    hypot_type_id = d->hypot_map[canon_id];
    if (hypot_type_id <= BTF_MAX_NR_TYPES) {
    + if (hypot_type_id == cand_id)
    + return 1;
    /* In some cases compiler will generate different DWARF types
    * for *identical* array type definitions and use them for
    * different fields within the *same* struct. This breaks type
    @@ -3936,8 +3963,18 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
    * types within a single CU. So work around that by explicitly
    * allowing identical array types here.
    */
    - return hypot_type_id == cand_id ||
    - btf_dedup_identical_arrays(d, hypot_type_id, cand_id);
    + if (btf_dedup_identical_arrays(d, hypot_type_id, cand_id))
    + return 1;
    + /* It turns out that similar situation can happen with
    + * struct/union sometimes, sigh... Handle the case where
    + * structs/unions are exactly the same, down to the referenced
    + * type IDs. Anything more complicated (e.g., if referenced
    + * types are different, but equivalent) is *way more*
    + * complicated and requires a many-to-many equivalence mapping.
    + */
    + if (btf_dedup_identical_structs(d, hypot_type_id, cand_id))
    + return 1;
    + return 0;
    }

    if (btf_dedup_hypot_map_add(d, canon_id, cand_id))
    --
    2.34.1


    \
     
     \ /
      Last update: 2022-01-24 23:11    [W:2.279 / U:1.824 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site