libbpf: Use layout to compute an unknown kind size

This allows BTF parsing to proceed even if we do not know the
kind.  Fall back to base BTF layout if layout information is
not in split BTF.

Signed-off-by: Alan Maguire <alan.maguire@oracle.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/bpf/20260326145444.2076244-4-alan.maguire@oracle.com

diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
index 2c6c524175c07513bc334e5b4207c8c59e7225cd..291691171ca7a5645ae683bf1971014a392535b5 100644 (file)
--- a/tools/lib/bpf/btf.c
+++ b/tools/lib/bpf/btf.c
@@ -386,7 +386,42 @@ static int btf_parse_layout_sec(struct btf *btf)
        return 0;
 }
 
-static int btf_type_size(const struct btf_type *t)
+/* for unknown kinds, consult kind layout. */
+static int btf_type_size_unknown(const struct btf *btf, const struct btf_type *t)
+{
+       __u32 l_cnt = btf->hdr.layout_len / sizeof(struct btf_layout);
+       struct btf_layout *l = btf->layout;
+       __u16 vlen = btf_vlen(t);
+       __u32 kind = btf_kind(t);
+
+       /* Fall back to base BTF if needed as they share layout information */
+       if (!l) {
+               struct btf *base_btf = btf->base_btf;
+
+               if (base_btf) {
+                       l = base_btf->layout;
+                       l_cnt = base_btf->hdr.layout_len / sizeof(struct btf_layout);
+               }
+       }
+       if (!l || kind >= l_cnt) {
+               pr_debug("Unsupported BTF_KIND: %u\n", btf_kind(t));
+               return -EINVAL;
+       }
+       if (l[kind].info_sz % 4) {
+               pr_debug("Unsupported info_sz %u for kind %u\n",
+                         l[kind].info_sz, kind);
+               return -EINVAL;
+       }
+       if (l[kind].elem_sz % 4) {
+               pr_debug("Unsupported elem_sz %u for kind %u\n",
+                        l[kind].elem_sz, kind);
+               return -EINVAL;
+       }
+
+       return sizeof(struct btf_type) + l[kind].info_sz + vlen * l[kind].elem_sz;
+}
+
+static int btf_type_size(const struct btf *btf, const struct btf_type *t)
 {
        const int base_size = sizeof(struct btf_type);
        __u16 vlen = btf_vlen(t);
@@ -422,8 +457,7 @@ static int btf_type_size(const struct btf_type *t)
        case BTF_KIND_DECL_TAG:
                return base_size + sizeof(struct btf_decl_tag);
        default:
-               pr_debug("Unsupported BTF_KIND:%u\n", btf_kind(t));
-               return -EINVAL;
+               return btf_type_size_unknown(btf, t);
        }
 }
 
@@ -521,7 +555,7 @@ static int btf_parse_type_sec(struct btf *btf)
                if (btf->swapped_endian)
                        btf_bswap_type_base(next_type);
 
-               type_size = btf_type_size(next_type);
+               type_size = btf_type_size(btf, next_type);
                if (type_size < 0)
                        return type_size;
                if (next_type + type_size > end_type) {
@@ -2102,7 +2136,7 @@ static int btf_add_type(struct btf_pipe *p, const struct btf_type *src_type)
        __u32 *str_off;
        int sz, err;
 
-       sz = btf_type_size(src_type);
+       sz = btf_type_size(p->src, src_type);
        if (sz < 0)
                return libbpf_err(sz);
 
@@ -2192,7 +2226,7 @@ int btf__add_btf(struct btf *btf, const struct btf *src_btf)
                struct btf_field_iter it;
                __u32 *type_id, *str_off;
 
-               sz = btf_type_size(t);
+               sz = btf_type_size(src_btf, t);
                if (sz < 0) {
                        /* unlikely, has to be corrupted src_btf */
                        err = sz;
@@ -5560,7 +5594,7 @@ static int btf_dedup_compact_types(struct btf_dedup *d)
                        continue;
 
                t = btf__type_by_id(d->btf, id);
-               len = btf_type_size(t);
+               len = btf_type_size(d->btf, t);
                if (len < 0)
                        return len;
 
@@ -6222,7 +6256,7 @@ int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_cnt,
 
                id = order_map[i];
                t = btf__type_by_id(btf, id);
-               type_size = btf_type_size(t);
+               type_size = btf_type_size(btf, t);
                memcpy(nt, t, type_size);
 
                /* fix up referenced IDs for BTF */
@@ -6248,7 +6282,7 @@ int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_cnt,
 
        for (nt = new_types, i = 0; i < id_map_cnt - start_offs; i++) {
                btf->type_offs[i] = nt - new_types;
-               nt += btf_type_size(nt);
+               nt += btf_type_size(btf, nt);
        }
 
        free(order_map);