From patchwork Tue Oct 5 06:47:01 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrii Nakryiko X-Patchwork-Id: 12535683 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 24E2CC433FE for ; Tue, 5 Oct 2021 06:47:16 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0B2536137F for ; Tue, 5 Oct 2021 06:47:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230526AbhJEGtF (ORCPT ); Tue, 5 Oct 2021 02:49:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48960 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232619AbhJEGtE (ORCPT ); Tue, 5 Oct 2021 02:49:04 -0400 Received: from mail-pj1-x102b.google.com (mail-pj1-x102b.google.com [IPv6:2607:f8b0:4864:20::102b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F09B4C061749 for ; Mon, 4 Oct 2021 23:47:14 -0700 (PDT) Received: by mail-pj1-x102b.google.com with SMTP id np13so3333550pjb.4 for ; Mon, 04 Oct 2021 23:47:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=AvxYNIqvsOqWdEkot3UDXOIaup9xp6wRn3YsQFGWSec=; b=f92cr/nF9D1gS2LX+v3WiX+gO2ctmINkaHTaR1ittzLkm177hDx0rsnv4HqPbM3Bwq q0gGYkyoUSmwOm3Uigu8ptr+uO+SgdN0aDjqC5WDb/v0ufTCJjoNl/9sAkk7iWDR+sQL U11kdUZD8/sw7xuDXlmK01cIfdEvfXSef/caxQzgysJ3fqnT4U3DfD/pEQ1GQRsX8Fkp /EYuzCySaR/ukmVgOdPx6AK3v8HnzowIkwyDh1qxLTQiVHZCJK9Oodm1ntaYoLUCjUTo KEYwsAjbpeji06CzttHdYeCjL5ai1j2EWldRh4Cqu/8cDQINirv8p8i6WRpZxDmKEsT5 pzCw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=AvxYNIqvsOqWdEkot3UDXOIaup9xp6wRn3YsQFGWSec=; b=IKIuxmJBuuVI29bpobv4UcxRJC41h/rgzXCZtwh0Ed8BGmhmOYzJWHehGBAMW5yP/I OoLqzRnBLDISNFGR/mdo9OrizsSDfxzckv+QlwN3289inAmzrIiYOY0wJfOv4i7x3KyG GPP+JuTkNhpCYu89Kp2swWuWqCYzMVmZ/UTBiU/TNFcgU0/VUY5NgN+faD5/CCsrOB8K HGF7pt/yEWvaRNU6k+nx3tPVYJ9w2Br7mw+BRLsB0MO17ehux8uJzNJtqC6xf1m45z0R 1GlqPriekiDcNowS2I4oVo6TR3206QwCjfB4Gg5NVB7rrLOsZPxTF9tN1+nZ22zbzGhm xX7w== X-Gm-Message-State: AOAM533Onbbzq7V1Wt/veADXq3JBKKVEbOWaTY/hHPRLK3E5XzlVl1c9 nY8O4MDte2yUDbnd1bhaME9vQDJqRZBBLg== X-Google-Smtp-Source: ABdhPJxoIhhf0yToIayBFz7Do5UF3WlzQ6ilNVYF0xLl10A832M1UjZsFpv7hp+ZMLg0/YkiV1v4Mg== X-Received: by 2002:a17:90b:3805:: with SMTP id mq5mr1805808pjb.143.1633416434328; Mon, 04 Oct 2021 23:47:14 -0700 (PDT) Received: from andriin-mbp.thefacebook.com ([2620:10d:c090:400::5:381e]) by smtp.gmail.com with ESMTPSA id z9sm921539pji.42.2021.10.04.23.47.13 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 04 Oct 2021 23:47:14 -0700 (PDT) From: andrii.nakryiko@gmail.com X-Google-Original-From: andrii@kernel.org To: bpf@vger.kernel.org, ast@kernel.org, daniel@iogearbox.net Cc: andrii@kernel.org, kernel-team@fb.com, Arnaldo Carvalho de Melo Subject: [PATCH bpf-next 1/3] libbpf: add API that copies all BTF types from one BTF object to another Date: Mon, 4 Oct 2021 23:47:01 -0700 Message-Id: <20211005064703.60785-2-andrii@kernel.org> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211005064703.60785-1-andrii@kernel.org> References: <20211005064703.60785-1-andrii@kernel.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net From: Andrii Nakryiko Add a bulk copying api, btf__add_btf(), that speeds up and simplifies appending entire contents of one BTF object to another one, taking care of copying BTF type data, adjusting resulting BTF type IDs according to their new locations in the destination BTF object, as well as copying and deduplicating all the referenced strings and updating all the string offsets in new BTF types as appropriate. This API is intended to be used from tools that are generating and otherwise manipulating BTFs generically, such as pahole. In pahole's case, this API is useful for speeding up parallelized BTF encoding, as it allows pahole to offload all the intricacies of BTF type copying to libbpf and handle the parallelization aspects of the process. Cc: Arnaldo Carvalho de Melo Signed-off-by: Andrii Nakryiko Acked-by: Song Liu --- tools/lib/bpf/btf.c | 114 ++++++++++++++++++++++++++++++++++++++- tools/lib/bpf/btf.h | 22 ++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 135 insertions(+), 2 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 6ad63e4d418a..5faa94273d56 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -189,12 +189,17 @@ int libbpf_ensure_mem(void **data, size_t *cap_cnt, size_t elem_sz, size_t need_ return 0; } +static void *btf_add_type_offs_mem(struct btf *btf, size_t add_cnt) +{ + return libbpf_add_mem((void **)&btf->type_offs, &btf->type_offs_cap, sizeof(__u32), + btf->nr_types, BTF_MAX_NR_TYPES, add_cnt); +} + static int btf_add_type_idx_entry(struct btf *btf, __u32 type_off) { __u32 *p; - p = libbpf_add_mem((void **)&btf->type_offs, &btf->type_offs_cap, sizeof(__u32), - btf->nr_types, BTF_MAX_NR_TYPES, 1); + p = btf_add_type_offs_mem(btf, 1); if (!p) return -ENOMEM; @@ -1691,6 +1696,111 @@ int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_t return btf_commit_type(btf, sz); } +static int btf_rewrite_type_ids(__u32 *type_id, void *ctx) +{ + struct btf *btf = ctx; + + if (!*type_id) /* nothing to do for VOID references */ + return 0; + + /* we haven't updated btf's type count yet, so + * btf->start_id + btf->nr_types - 1 is the type ID offset we should + * add to all newly added BTF types + */ + *type_id += btf->start_id + btf->nr_types - 1; + return 0; +} + +int btf__add_btf(struct btf *btf, const struct btf *src_btf) +{ + struct btf_pipe p = { .src = src_btf, .dst = btf }; + int data_sz, sz, cnt, i, err, old_strs_len; + __u32 *off; + void *t; + + /* appending split BTF isn't supported yet */ + if (src_btf->base_btf) + return libbpf_err(-ENOTSUP); + + /* deconstruct BTF, if necessary, and invalidate raw_data */ + if (btf_ensure_modifiable(btf)) + return libbpf_err(-ENOMEM); + + /* remember original strings section size if we have to roll back + * partial strings section changes + */ + old_strs_len = btf->hdr->str_len; + + data_sz = src_btf->hdr->type_len; + cnt = btf__get_nr_types(src_btf); + + /* pre-allocate enough memory for new types */ + t = btf_add_type_mem(btf, data_sz); + if (!t) + return libbpf_err(-ENOMEM); + + /* pre-allocate enough memory for type offset index for new types */ + off = btf_add_type_offs_mem(btf, cnt); + if (!off) + return libbpf_err(-ENOMEM); + + /* bulk copy types data for all types from src_btf */ + memcpy(t, src_btf->types_data, data_sz); + + for (i = 0; i < cnt; i++) { + sz = btf_type_size(t); + if (sz < 0) { + /* unlikely, has to be corrupted src_btf */ + err = sz; + goto err_out; + } + + /* fill out type ID to type offset mapping for lookups by type ID */ + *off = t - btf->types_data; + + /* add, dedup, and remap strings referenced by this BTF type */ + err = btf_type_visit_str_offs(t, btf_rewrite_str, &p); + if (err) + goto err_out; + + /* remap all type IDs referenced from this BTF type */ + err = btf_type_visit_type_ids(t, btf_rewrite_type_ids, btf); + if (err) + goto err_out; + + /* go to next type data and type offset index entry */ + t += sz; + off++; + } + + /* Up until now any of the copied type data was effectively invisible, + * so if we exited early before this point due to error, BTF would be + * effectively unmodified. There would be extra internal memory + * pre-allocated, but it would not be available for querying. But now + * that we've copied and rewritten all the data successfully, we can + * update type count and various internal offsets and sizes to + * "commit" the changes and made them visible to the outside world. + */ + btf->hdr->type_len += data_sz; + btf->hdr->str_off += data_sz; + btf->nr_types += cnt; + + /* return type ID of the first added BTF type */ + return btf->start_id + btf->nr_types - cnt; +err_out: + /* zero out preallocated memory as if it was just allocated with + * libbpf_add_mem() + */ + memset(btf->types_data + btf->hdr->type_len, 0, data_sz); + memset(btf->strs_data + old_strs_len, 0, btf->hdr->str_len - old_strs_len); + + /* and now restore original strings section size; types data size + * wasn't modified, so doesn't need restoring, see big comment above */ + btf->hdr->str_len = old_strs_len; + + return libbpf_err(err); +} + /* * Append new BTF_KIND_INT type with: * - *name* - non-empty, non-NULL type name; diff --git a/tools/lib/bpf/btf.h b/tools/lib/bpf/btf.h index 2cfe31327920..823e7067d34e 100644 --- a/tools/lib/bpf/btf.h +++ b/tools/lib/bpf/btf.h @@ -173,6 +173,28 @@ LIBBPF_API int btf__find_str(struct btf *btf, const char *s); LIBBPF_API int btf__add_str(struct btf *btf, const char *s); LIBBPF_API int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_type *src_type); +/** + * @brief **btf__add_btf()** appends all the BTF types from *src_btf* into *btf* + * @param btf BTF object which all the BTF types and strings are added to + * @param src_btf BTF object which all BTF types and referenced strings are copied from + * @return BTF type ID of the first appended BTF type, or negative error code + * + * **btf__add_btf()** can be used to simply and efficiently append the entire + * contents of one BTF object to another one. All the BTF type data is copied + * over, all referenced type IDs are adjusted by adding a necessary ID offset. + * Only strings referenced from BTF types are copied over and deduplicated, so + * if there were some unused strings in *src_btf*, those won't be copied over, + * which is consistent with the general string deduplication semantics of BTF + * writing APIs. + * + * If any error is encountered during this process, the contents of *btf* is + * left intact, which means that **btf__add_btf()** follows the transactional + * semantics and the operation as a whole is all-or-nothing. + * + * *src_btf* has to be non-split BTF, as of now copying types from split BTF + * is not supported and will result in -OPNOTSUP error code returned. + */ +LIBBPF_API int btf__add_btf(struct btf *btf, const struct btf *src_btf); LIBBPF_API int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding); LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz); diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 9e649cf9e771..f6b0db1e8c8b 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -389,5 +389,6 @@ LIBBPF_0.5.0 { LIBBPF_0.6.0 { global: + btf__add_btf; btf__add_tag; } LIBBPF_0.5.0; From patchwork Tue Oct 5 06:47:02 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrii Nakryiko X-Patchwork-Id: 12535685 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id CEE5DC433F5 for ; Tue, 5 Oct 2021 06:47:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B17706137F for ; Tue, 5 Oct 2021 06:47:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232471AbhJEGtI (ORCPT ); Tue, 5 Oct 2021 02:49:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48974 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232596AbhJEGtI (ORCPT ); Tue, 5 Oct 2021 02:49:08 -0400 Received: from mail-pf1-x42e.google.com (mail-pf1-x42e.google.com [IPv6:2607:f8b0:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9F7C1C061745 for ; Mon, 4 Oct 2021 23:47:18 -0700 (PDT) Received: by mail-pf1-x42e.google.com with SMTP id h1so5862021pfv.12 for ; Mon, 04 Oct 2021 23:47:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ViaagKYBiQzdmafvF50+XcDXMX1X48FTWoaZfW884NI=; b=mWl7MTjw+7C6OjebmjBHwS87aLPcpbP+qukZpmD+kXciWlBG+oyH+j2fzWHmALjBdU 1P6eUOaHhNhTaRyiJfi6Jh0+zJ5mSmyDMFykPVu++1HI2NPxYnH+u6OC4FlfhihV1VKD HjW1VxaXhCdv3Lqzrh+tgAPDMDj8LVg9Ktj39gR70pyPegr8Pw2M8LKDQe9m6zhXDQ01 c9YRy7yym6HHMSuOI9z0vdQouLJjYlRwwXUiW9Q6hZMrrsLBeLpWoLuxhNJDXYYN21pM uRjL8Y1T1rGIJWdFAbh7fUnK9yk/ur9QihbQ3UFSR+V3BqrBiE0+o7c4Qc0igx/0BCwk u9Qg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ViaagKYBiQzdmafvF50+XcDXMX1X48FTWoaZfW884NI=; b=jOhe6N02Bjsza1zDMjaOuObV5NkXfFk3mktf9vgO0LGUvdvd4AbkQJhO7GU5+nVO5x JFjwGoN6PdXkWd3iYvY5C02XHwzkYZrYfG6/R0LIlqOti7TkOMDRf0YTgvMu7SQWuELX KkYBpM/RFDqvXjhkHH9X7oe9/zYadeYx5U85UWjgb0ABGRbHtqNJmotmIJxf4D5ZcM8d XtPTJ8CRI6yejT1RHM8S1sIOVAf8HiEIExyiRvxQOeEkanysTHr7LjO0pf7H91WxgyPh QoRC68z5el4xCe1BSQMQyowITQtYAckAi4uAPRpm8i7gybgnpJht78IVqNM6RnvrYL+X ZQdQ== X-Gm-Message-State: AOAM5320VIeRyqBDv+TitI6gIkFhCVzfBh7JIBRVUUgzPmifS/m+aHq5 TUNVO/8T7lGPdGGLA3VHwQgXZtJL6K7cRA== X-Google-Smtp-Source: ABdhPJxBktPjUOWV3orreyso6p26Bn5uw0FdryOPtxmXuYyxxtGkDS4lSbV0ccEyKmkRATPYuCL/6w== X-Received: by 2002:a62:e210:0:b0:44b:ae4c:8c01 with SMTP id a16-20020a62e210000000b0044bae4c8c01mr28822145pfi.45.1633416438045; Mon, 04 Oct 2021 23:47:18 -0700 (PDT) Received: from andriin-mbp.thefacebook.com ([2620:10d:c090:400::5:381e]) by smtp.gmail.com with ESMTPSA id u5sm915135pjn.48.2021.10.04.23.47.17 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 04 Oct 2021 23:47:17 -0700 (PDT) From: andrii.nakryiko@gmail.com X-Google-Original-From: andrii@kernel.org To: bpf@vger.kernel.org, ast@kernel.org, daniel@iogearbox.net Cc: andrii@kernel.org, kernel-team@fb.com, Arnaldo Carvalho de Melo Subject: [PATCH bpf-next 2/3] selftests/bpf: refactor btf_write selftest to reuse BTF generation logic Date: Mon, 4 Oct 2021 23:47:02 -0700 Message-Id: <20211005064703.60785-3-andrii@kernel.org> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211005064703.60785-1-andrii@kernel.org> References: <20211005064703.60785-1-andrii@kernel.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net From: Andrii Nakryiko Next patch will need to reuse BTF generation logic, which tests every supported BTF kind, for testing btf__add_btf() APIs. So restructure existing selftests and make it as a single subtest that uses bulk VALIDATE_RAW_BTF() macro for raw BTF dump checking. Signed-off-by: Andrii Nakryiko Acked-by: Song Liu --- .../selftests/bpf/prog_tests/btf_write.c | 55 +++++++++++++++++-- 1 file changed, 49 insertions(+), 6 deletions(-) diff --git a/tools/testing/selftests/bpf/prog_tests/btf_write.c b/tools/testing/selftests/bpf/prog_tests/btf_write.c index 76548eecce2c..aa4505618252 100644 --- a/tools/testing/selftests/bpf/prog_tests/btf_write.c +++ b/tools/testing/selftests/bpf/prog_tests/btf_write.c @@ -4,19 +4,15 @@ #include #include "btf_helpers.h" -void test_btf_write() { +static void gen_btf(struct btf *btf) +{ const struct btf_var_secinfo *vi; const struct btf_type *t; const struct btf_member *m; const struct btf_enum *v; const struct btf_param *p; - struct btf *btf; int id, err, str_off; - btf = btf__new_empty(); - if (!ASSERT_OK_PTR(btf, "new_empty")) - return; - str_off = btf__find_str(btf, "int"); ASSERT_EQ(str_off, -ENOENT, "int_str_missing_off"); @@ -301,6 +297,53 @@ void test_btf_write() { ASSERT_EQ(btf_tag(t)->component_idx, 1, "tag_component_idx"); ASSERT_STREQ(btf_type_raw_dump(btf, 19), "[19] TAG 'tag2' type_id=14 component_idx=1", "raw_dump"); +} + +static void test_btf_add() +{ + struct btf *btf; + + btf = btf__new_empty(); + if (!ASSERT_OK_PTR(btf, "new_empty")) + return; + + gen_btf(btf); + + VALIDATE_RAW_BTF( + btf, + "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED", + "[2] PTR '(anon)' type_id=1", + "[3] CONST '(anon)' type_id=5", + "[4] VOLATILE '(anon)' type_id=3", + "[5] RESTRICT '(anon)' type_id=4", + "[6] ARRAY '(anon)' type_id=2 index_type_id=1 nr_elems=10", + "[7] STRUCT 's1' size=8 vlen=2\n" + "\t'f1' type_id=1 bits_offset=0\n" + "\t'f2' type_id=1 bits_offset=32 bitfield_size=16", + "[8] UNION 'u1' size=8 vlen=1\n" + "\t'f1' type_id=1 bits_offset=0 bitfield_size=16", + "[9] ENUM 'e1' size=4 vlen=2\n" + "\t'v1' val=1\n" + "\t'v2' val=2", + "[10] FWD 'struct_fwd' fwd_kind=struct", + "[11] FWD 'union_fwd' fwd_kind=union", + "[12] ENUM 'enum_fwd' size=4 vlen=0", + "[13] TYPEDEF 'typedef1' type_id=1", + "[14] FUNC 'func1' type_id=15 linkage=global", + "[15] FUNC_PROTO '(anon)' ret_type_id=1 vlen=2\n" + "\t'p1' type_id=1\n" + "\t'p2' type_id=2", + "[16] VAR 'var1' type_id=1, linkage=global-alloc", + "[17] DATASEC 'datasec1' size=12 vlen=1\n" + "\ttype_id=1 offset=4 size=8", + "[18] TAG 'tag1' type_id=16 component_idx=-1", + "[19] TAG 'tag2' type_id=14 component_idx=1"); btf__free(btf); } + +void test_btf_write() +{ + if (test__start_subtest("btf_add")) + test_btf_add(); +} From patchwork Tue Oct 5 06:47:03 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrii Nakryiko X-Patchwork-Id: 12535687 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BAEF6C433F5 for ; Tue, 5 Oct 2021 06:47:23 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A1A9261184 for ; Tue, 5 Oct 2021 06:47:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232619AbhJEGtM (ORCPT ); Tue, 5 Oct 2021 02:49:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48992 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232591AbhJEGtM (ORCPT ); Tue, 5 Oct 2021 02:49:12 -0400 Received: from mail-pl1-x632.google.com (mail-pl1-x632.google.com [IPv6:2607:f8b0:4864:20::632]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 78ADAC061745 for ; Mon, 4 Oct 2021 23:47:22 -0700 (PDT) Received: by mail-pl1-x632.google.com with SMTP id j15so1627277plh.7 for ; Mon, 04 Oct 2021 23:47:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=oTRi7CdXsxRuWtD22xkp24bvf7B38TEOIke8y7xV1hw=; b=djOvcoxDP1BABArGLpzwQrfevdRRSZyc4aLqjm6ale2vuMSPo4jb95K6wODpPpXHbC O+N9MAKBjPuIDoxwBjE/LholedLNnRYGr3wPoM2RsG+VQelYW/EJTSwELSQuGhs7LswB VauQzRR+N5piJpnX0NEluVffWLfmg4205xmzAOznKQuddz7G6CCEG5o8mCzxWaxu+ET8 8yCOn8QmNDT9/MyrILuZuNHSOHR4IieLFAmuUDet1r5ds8xp2VqDEtcKq9acnZT29+DJ 2zU9VsTVDZTJnB7ve635iaLDhVpnXu0V3UptDIGiVs9esatUihDAd/uSpnnncBbnzkVn NjsQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=oTRi7CdXsxRuWtD22xkp24bvf7B38TEOIke8y7xV1hw=; b=UE23PWcz7tB5ZDxZRhQqoa8rFPfx4gd76FJgAate0sJxMq/9U1YBAyP0s1JL47YBIV yHa0t2fI7CHyu8a1SubWL/7arsbMtvMiVGCDWvF4Ii/zzMuNB2OiurXoiD0hXHOee0YW n8yATnph4L68K73ZLLmj2LuuLK9Ggba643VaYQJwGxaW9OrXKn/ybTVT0YU8wVzYYI6H qj9bY8Lz9QUSkgobl9qug0dk+XM4UM+gM0U8Gj5QCh8vrtSt2a6EdKd6PzNhOy9U/l2n 9tB5xSdAG62MRLAztx+9zz9f4n4ODzLp2bxC3tJ267lt6UP4rFfccVzlZsSQnPnwtUuC XUQQ== X-Gm-Message-State: AOAM530Ir1Wjm/IEkKokWXGcvK69w4C1LpFcgBY2EFYN793m7deQ21jc nY4eN8FVPL+O6JTOhzBtxYo+DUZO3B0Qtg== X-Google-Smtp-Source: ABdhPJwm2qDmK2pxbYhOHIq/NjEPi91Tzhi+K7VlPVLT7t10QnWdnAgUN6uKjf5VM5gIUFm/pAsC5Q== X-Received: by 2002:a17:90b:3b8b:: with SMTP id pc11mr1867120pjb.180.1633416441859; Mon, 04 Oct 2021 23:47:21 -0700 (PDT) Received: from andriin-mbp.thefacebook.com ([2620:10d:c090:400::5:381e]) by smtp.gmail.com with ESMTPSA id s22sm7266248pfg.137.2021.10.04.23.47.21 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 04 Oct 2021 23:47:21 -0700 (PDT) From: andrii.nakryiko@gmail.com X-Google-Original-From: andrii@kernel.org To: bpf@vger.kernel.org, ast@kernel.org, daniel@iogearbox.net Cc: andrii@kernel.org, kernel-team@fb.com, Arnaldo Carvalho de Melo Subject: [PATCH bpf-next 3/3] selftests/bpf: test new btf__add_btf() API Date: Mon, 4 Oct 2021 23:47:03 -0700 Message-Id: <20211005064703.60785-4-andrii@kernel.org> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20211005064703.60785-1-andrii@kernel.org> References: <20211005064703.60785-1-andrii@kernel.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org X-Patchwork-Delegate: bpf@iogearbox.net From: Andrii Nakryiko Add a test that validates that btf__add_btf() API is correctly copying all the types from the source BTF into destination BTF object and adjusts type IDs and string offsets properly. Signed-off-by: Andrii Nakryiko --- .../selftests/bpf/prog_tests/btf_write.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/tools/testing/selftests/bpf/prog_tests/btf_write.c b/tools/testing/selftests/bpf/prog_tests/btf_write.c index aa4505618252..75fd280f75b2 100644 --- a/tools/testing/selftests/bpf/prog_tests/btf_write.c +++ b/tools/testing/selftests/bpf/prog_tests/btf_write.c @@ -342,8 +342,94 @@ static void test_btf_add() btf__free(btf); } +static void test_btf_add_btf() +{ + struct btf *btf1 = NULL, *btf2 = NULL; + int id; + + btf1 = btf__new_empty(); + if (!ASSERT_OK_PTR(btf1, "btf1")) + return; + + btf2 = btf__new_empty(); + if (!ASSERT_OK_PTR(btf2, "btf2")) + return; + + gen_btf(btf1); + gen_btf(btf2); + + id = btf__add_btf(btf1, btf2); + if (!ASSERT_EQ(id, 20, "id")) + goto cleanup; + + VALIDATE_RAW_BTF( + btf1, + "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED", + "[2] PTR '(anon)' type_id=1", + "[3] CONST '(anon)' type_id=5", + "[4] VOLATILE '(anon)' type_id=3", + "[5] RESTRICT '(anon)' type_id=4", + "[6] ARRAY '(anon)' type_id=2 index_type_id=1 nr_elems=10", + "[7] STRUCT 's1' size=8 vlen=2\n" + "\t'f1' type_id=1 bits_offset=0\n" + "\t'f2' type_id=1 bits_offset=32 bitfield_size=16", + "[8] UNION 'u1' size=8 vlen=1\n" + "\t'f1' type_id=1 bits_offset=0 bitfield_size=16", + "[9] ENUM 'e1' size=4 vlen=2\n" + "\t'v1' val=1\n" + "\t'v2' val=2", + "[10] FWD 'struct_fwd' fwd_kind=struct", + "[11] FWD 'union_fwd' fwd_kind=union", + "[12] ENUM 'enum_fwd' size=4 vlen=0", + "[13] TYPEDEF 'typedef1' type_id=1", + "[14] FUNC 'func1' type_id=15 linkage=global", + "[15] FUNC_PROTO '(anon)' ret_type_id=1 vlen=2\n" + "\t'p1' type_id=1\n" + "\t'p2' type_id=2", + "[16] VAR 'var1' type_id=1, linkage=global-alloc", + "[17] DATASEC 'datasec1' size=12 vlen=1\n" + "\ttype_id=1 offset=4 size=8", + "[18] TAG 'tag1' type_id=16 component_idx=-1", + "[19] TAG 'tag2' type_id=14 component_idx=1", + + /* types appended from the second BTF */ + "[20] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED", + "[21] PTR '(anon)' type_id=20", + "[22] CONST '(anon)' type_id=24", + "[23] VOLATILE '(anon)' type_id=22", + "[24] RESTRICT '(anon)' type_id=23", + "[25] ARRAY '(anon)' type_id=21 index_type_id=20 nr_elems=10", + "[26] STRUCT 's1' size=8 vlen=2\n" + "\t'f1' type_id=20 bits_offset=0\n" + "\t'f2' type_id=20 bits_offset=32 bitfield_size=16", + "[27] UNION 'u1' size=8 vlen=1\n" + "\t'f1' type_id=20 bits_offset=0 bitfield_size=16", + "[28] ENUM 'e1' size=4 vlen=2\n" + "\t'v1' val=1\n" + "\t'v2' val=2", + "[29] FWD 'struct_fwd' fwd_kind=struct", + "[30] FWD 'union_fwd' fwd_kind=union", + "[31] ENUM 'enum_fwd' size=4 vlen=0", + "[32] TYPEDEF 'typedef1' type_id=20", + "[33] FUNC 'func1' type_id=34 linkage=global", + "[34] FUNC_PROTO '(anon)' ret_type_id=20 vlen=2\n" + "\t'p1' type_id=20\n" + "\t'p2' type_id=21", + "[35] VAR 'var1' type_id=20, linkage=global-alloc", + "[36] DATASEC 'datasec1' size=12 vlen=1\n" + "\ttype_id=20 offset=4 size=8", + "[37] TAG 'tag1' type_id=35 component_idx=-1", + "[38] TAG 'tag2' type_id=33 component_idx=1"); + +cleanup: + btf__free(btf1); + btf__free(btf2); +} + void test_btf_write() { if (test__start_subtest("btf_add")) test_btf_add(); + if (test__start_subtest("btf_add_btf")) + test_btf_add_btf(); }