From patchwork Fri Jun 16 17:17:19 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283060 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id ADD2A182D2 for ; Fri, 16 Jun 2023 17:17:59 +0000 (UTC) Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C29071FF7 for ; Fri, 16 Jun 2023 10:17:57 -0700 (PDT) Received: from pps.filterd (m0333520.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCi2X3005979; Fri, 16 Jun 2023 17:17:38 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=gXV5mOEkgNVFNwO4SSJG0IW4iXAaUZWuyK18GOOJbM4=; b=csNyrDBx5OOsTxLwCykBGl/uXVr9DpbY6bw9Oxt1KhvcEX2VcqLU7XhxjFvZVxn7rOcx jjgFojIApBYzd6XnUYTU/kTSfE1UhCBIpiGQwlvGyYXMUty2g0VZN3MsDoRvjx0QFfNo c5GgavNDnBQmwX9PK1D2e98eTnLcoPIylOIZ/1Wb1O3LhNPFoUn3SAJRM+lgB7MGAP0o 5opCry+3frDDRPgDW1gr2ktOPRWaT/ZdFPqpCYJ528p2plewv8/2w+XfyH+uUlS7zi1o UssAFulGIris9wwva1b/uLsuWXRAuZUGMXgklu1uO+q5HOCKQybhlJaksxPQPS6XpNNX YQ== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4h7dcrde-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:38 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GFwAxw012512; Fri, 16 Jun 2023 17:17:37 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmerta0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:37 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPY007608; Fri, 16 Jun 2023 17:17:36 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-2; Fri, 16 Jun 2023 17:17:36 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 1/9] btf: add kind layout encoding, crcs to UAPI Date: Fri, 16 Jun 2023 18:17:19 +0100 Message-Id: <20230616171728.530116-2-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160155 X-Proofpoint-ORIG-GUID: k6DaUIEWl8L1fnGIVLkzlmRr0jo6xok8 X-Proofpoint-GUID: k6DaUIEWl8L1fnGIVLkzlmRr0jo6xok8 X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net BTF kind layouts provide information to parse BTF kinds. By separating parsing BTF from using all the information it provides, we allow BTF to encode new features even if they cannot be used. This is helpful in particular for cases where newer tools for BTF generation run on an older kernel; BTF kinds may be present that the kernel cannot yet use, but at least it can parse the BTF provided. Meanwhile userspace tools with newer libbpf may be able to use the newer information. The intent is to support encoding of kind layouts optionally so that tools like pahole can add this information. So for each kind we record - kind-related flags - length of singular element following struct btf_type - length of each of the btf_vlen() elements following In addition we make space in the BTF header for CRC32s computed over the BTF along with a CRC for the base BTF; this allows split BTF to identify a mismatch explicitly. The ideas here were discussed at [1], [2]; hence Suggested-by: Andrii Nakryiko Signed-off-by: Alan Maguire [1] https://lore.kernel.org/bpf/CAEf4BzYjWHRdNNw4B=eOXOs_ONrDwrgX4bn=Nuc1g8JPFC34MA@mail.gmail.com/ [2] https://lore.kernel.org/bpf/20230531201936.1992188-1-alan.maguire@oracle.com/ --- include/uapi/linux/btf.h | 24 ++++++++++++++++++++++++ tools/include/uapi/linux/btf.h | 24 ++++++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/include/uapi/linux/btf.h b/include/uapi/linux/btf.h index ec1798b6d3ff..cea9125ed953 100644 --- a/include/uapi/linux/btf.h +++ b/include/uapi/linux/btf.h @@ -8,6 +8,22 @@ #define BTF_MAGIC 0xeB9F #define BTF_VERSION 1 +/* is this information required? If so it cannot be sanitized safely. */ +#define BTF_KIND_LAYOUT_OPTIONAL (1 << 0) + +/* kind layout section consists of a struct btf_kind_layout for each known + * kind at BTF encoding time. + */ +struct btf_kind_layout { + __u16 flags; /* see BTF_KIND_LAYOUT_* values above */ + __u8 info_sz; /* size of singular element after btf_type */ + __u8 elem_sz; /* size of each of btf_vlen(t) elements */ +}; + +/* for CRCs for BTF, base BTF to be considered usable, flags must be set. */ +#define BTF_FLAG_CRC_SET (1 << 0) +#define BTF_FLAG_BASE_CRC_SET (1 << 1) + struct btf_header { __u16 magic; __u8 version; @@ -19,8 +35,16 @@ struct btf_header { __u32 type_len; /* length of type section */ __u32 str_off; /* offset of string section */ __u32 str_len; /* length of string section */ + __u32 kind_layout_off;/* offset of kind layout section */ + __u32 kind_layout_len;/* length of kind layout section */ + + __u32 crc; /* crc of BTF; used if flags set BTF_FLAG_CRC_VALID */ + __u32 base_crc; /* crc of base BTF; used if flags set BTF_FLAG_BASE_CRC_VALID */ }; +/* required minimum BTF header length */ +#define BTF_HEADER_MIN_LEN (sizeof(struct btf_header) - 16) + /* Max # of type identifier */ #define BTF_MAX_TYPE 0x000fffff /* Max offset into the string section */ diff --git a/tools/include/uapi/linux/btf.h b/tools/include/uapi/linux/btf.h index ec1798b6d3ff..cea9125ed953 100644 --- a/tools/include/uapi/linux/btf.h +++ b/tools/include/uapi/linux/btf.h @@ -8,6 +8,22 @@ #define BTF_MAGIC 0xeB9F #define BTF_VERSION 1 +/* is this information required? If so it cannot be sanitized safely. */ +#define BTF_KIND_LAYOUT_OPTIONAL (1 << 0) + +/* kind layout section consists of a struct btf_kind_layout for each known + * kind at BTF encoding time. + */ +struct btf_kind_layout { + __u16 flags; /* see BTF_KIND_LAYOUT_* values above */ + __u8 info_sz; /* size of singular element after btf_type */ + __u8 elem_sz; /* size of each of btf_vlen(t) elements */ +}; + +/* for CRCs for BTF, base BTF to be considered usable, flags must be set. */ +#define BTF_FLAG_CRC_SET (1 << 0) +#define BTF_FLAG_BASE_CRC_SET (1 << 1) + struct btf_header { __u16 magic; __u8 version; @@ -19,8 +35,16 @@ struct btf_header { __u32 type_len; /* length of type section */ __u32 str_off; /* offset of string section */ __u32 str_len; /* length of string section */ + __u32 kind_layout_off;/* offset of kind layout section */ + __u32 kind_layout_len;/* length of kind layout section */ + + __u32 crc; /* crc of BTF; used if flags set BTF_FLAG_CRC_VALID */ + __u32 base_crc; /* crc of base BTF; used if flags set BTF_FLAG_BASE_CRC_VALID */ }; +/* required minimum BTF header length */ +#define BTF_HEADER_MIN_LEN (sizeof(struct btf_header) - 16) + /* Max # of type identifier */ #define BTF_MAX_TYPE 0x000fffff /* Max offset into the string section */ From patchwork Fri Jun 16 17:17:20 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283061 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 32DF9182D2 for ; Fri, 16 Jun 2023 17:18:02 +0000 (UTC) Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A783D1FEC for ; Fri, 16 Jun 2023 10:18:00 -0700 (PDT) Received: from pps.filterd (m0246630.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCiGtg021275; Fri, 16 Jun 2023 17:17:42 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=8o5FpErrqAPmxFvELGV2s51KoU61sURgJsrB6tf06AY=; b=dPw+LxJgdxTIgvt6roT6eUoBxzWceGkLw3w8wnukLcInHbqVJta7Zp4N8sf2TDijpq1S Ziv2du6xYo27YsXY9InL3A2xlIwSeNp7VMiKPUeGpdkR412j2zHLZIYl4Ggyx81F9DqT ceheoLTEJwNB3ngA9q8w46ILWZamB6aUv5aNznlQL6Ztr8JJHIviyAADDNMISXNKgGmP SRYmMn/1WS7SNFl+aIpMsc+9eNJYuX8RJnD43IuK0pqshbiFP9jSr7HoRJdS2Qi+vw4r MwEwLdkAW2G5Ieqq/6rSEdD+YOgteMfPKfDndFRynxwB7NLKIgxue8NZNcziQG5BWMmA Dg== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4fkdvh29-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:42 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GG5E71012376; Fri, 16 Jun 2023 17:17:41 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmertd1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:41 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPa007608; Fri, 16 Jun 2023 17:17:40 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-3; Fri, 16 Jun 2023 17:17:40 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 2/9] libbpf: support handling of kind layout section in BTF Date: Fri, 16 Jun 2023 18:17:20 +0100 Message-Id: <20230616171728.530116-3-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160155 X-Proofpoint-ORIG-GUID: 0ne5SpTCf5b7OfKIU4UzGE_-dWOnjFLr X-Proofpoint-GUID: 0ne5SpTCf5b7OfKIU4UzGE_-dWOnjFLr X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net support reading in kind layout fixing endian issues on reading; also support writing kind layout section to raw BTF object. There is not yet an API to populate the kind layout with meaningful information. Signed-off-by: Alan Maguire --- tools/lib/bpf/btf.c | 132 +++++++++++++++++++++++++++++++++----------- 1 file changed, 99 insertions(+), 33 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 8484b563b53d..f9f919fdc728 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -39,40 +39,44 @@ struct btf { /* * When BTF is loaded from an ELF or raw memory it is stored - * in a contiguous memory block. The hdr, type_data, and, strs_data - * point inside that memory region to their respective parts of BTF - * representation: + * in a contiguous memory block. The hdr, type_data, strs_data, + * and optional kind layout point inside that memory region to their + * respective parts of BTF representation: * - * +--------------------------------+ - * | Header | Types | Strings | - * +--------------------------------+ - * ^ ^ ^ - * | | | - * hdr | | - * types_data-+ | - * strs_data------------+ + * +--------------------------------+-------------+ + * | Header | Types | Strings | Kind Layout | + * +--------------------------------+-------------+ + * ^ ^ ^ ^ + * | | | | + * hdr | | | + * types_data-+ | | + * strs_data------------+ | + * kind_layout----------------------+ + * + * kind_layout is optional. * * If BTF data is later modified, e.g., due to types added or * removed, BTF deduplication performed, etc, this contiguous - * representation is broken up into three independently allocated - * memory regions to be able to modify them independently. + * representation is broken up into three or four independently + * allocated memory regions to be able to modify them independently. * raw_data is nulled out at that point, but can be later allocated * and cached again if user calls btf__raw_data(), at which point - * raw_data will contain a contiguous copy of header, types, and - * strings: + * raw_data will contain a contiguous copy of header, types, strings + * and (again optionally) kind layout: * - * +----------+ +---------+ +-----------+ - * | Header | | Types | | Strings | - * +----------+ +---------+ +-----------+ - * ^ ^ ^ - * | | | - * hdr | | - * types_data----+ | - * strset__data(strs_set)-----+ + * +----------+ +---------+ +-----------+ +-------------+ + * | Header | | Types | | Strings | | Kind layout | + * +----------+ +---------+ +-----------+ +-------------+ + * ^ ^ ^ ^ + * | | | | + * hdr | | | + * types_data----+ | | + * strset__data(strs_set)-----+ | + * kind_layout-------------------------------+ * - * +----------+---------+-----------+ - * | Header | Types | Strings | - * raw_data----->+----------+---------+-----------+ + * +----------+---------+-----------+-------------+ + * | Header | Types | Strings | Kind Layout | + * raw_data----->+----------+---------+-----------+-------------+ */ struct btf_header *hdr; @@ -116,6 +120,8 @@ struct btf { /* whether strings are already deduplicated */ bool strs_deduped; + struct btf_kind_layout *kind_layout; + /* BTF object FD, if loaded into kernel */ int fd; @@ -215,6 +221,13 @@ static void btf_bswap_hdr(struct btf_header *h) h->type_len = bswap_32(h->type_len); h->str_off = bswap_32(h->str_off); h->str_len = bswap_32(h->str_len); + if (h->hdr_len >= sizeof(struct btf_header)) { + h->kind_layout_off = bswap_32(h->kind_layout_off); + h->kind_layout_len = bswap_32(h->kind_layout_len); + h->crc = bswap_32(h->crc); + h->base_crc = bswap_32(h->base_crc); + } + } static int btf_parse_hdr(struct btf *btf) @@ -222,14 +235,17 @@ static int btf_parse_hdr(struct btf *btf) struct btf_header *hdr = btf->hdr; __u32 meta_left; - if (btf->raw_size < sizeof(struct btf_header)) { + if (btf->raw_size < BTF_HEADER_MIN_LEN) { pr_debug("BTF header not found\n"); return -EINVAL; } if (hdr->magic == bswap_16(BTF_MAGIC)) { + int swapped_len = bswap_32(hdr->hdr_len); + btf->swapped_endian = true; - if (bswap_32(hdr->hdr_len) != sizeof(struct btf_header)) { + if (swapped_len != sizeof(struct btf_header) && + swapped_len != BTF_HEADER_MIN_LEN) { pr_warn("Can't load BTF with non-native endianness due to unsupported header length %u\n", bswap_32(hdr->hdr_len)); return -ENOTSUP; @@ -285,6 +301,32 @@ static int btf_parse_str_sec(struct btf *btf) return 0; } +static void btf_bswap_kind_layout_sec(struct btf_kind_layout *k, int len) +{ + struct btf_kind_layout *end = (void *)k + len; + + while (k < end) { + k->flags = bswap_16(k->flags); + k++; + } +} + +static int btf_parse_kind_layout_sec(struct btf *btf) +{ + const struct btf_header *hdr = btf->hdr; + + if (hdr->hdr_len < sizeof(struct btf_header) || + !hdr->kind_layout_off || !hdr->kind_layout_len) + return 0; + if (hdr->kind_layout_len < sizeof(struct btf_kind_layout)) { + pr_debug("Invalid BTF kind layout section\n"); + return -EINVAL; + } + btf->kind_layout = btf->raw_data + btf->hdr->hdr_len + btf->hdr->kind_layout_off; + + return 0; +} + static int btf_type_size(const struct btf_type *t) { const int base_size = sizeof(struct btf_type); @@ -901,6 +943,7 @@ static struct btf *btf_new(const void *data, __u32 size, struct btf *base_btf) btf->types_data = btf->raw_data + btf->hdr->hdr_len + btf->hdr->type_off; err = btf_parse_str_sec(btf); + err = err ?: btf_parse_kind_layout_sec(btf); err = err ?: btf_parse_type_sec(btf); if (err) goto done; @@ -1267,6 +1310,11 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi } data_sz = hdr->hdr_len + hdr->type_len + hdr->str_len; + if (btf->kind_layout) { + data_sz = roundup(data_sz, 4); + data_sz += hdr->kind_layout_len; + hdr->kind_layout_off = roundup(hdr->type_len + hdr->str_len, 4); + } data = calloc(1, data_sz); if (!data) return NULL; @@ -1293,8 +1341,15 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi p += hdr->type_len; memcpy(p, btf_strs_data(btf), hdr->str_len); - p += hdr->str_len; + /* round up to 4 byte alignment to match offset above */ + p = data + hdr->hdr_len + roundup(hdr->type_len + hdr->str_len, 4); + if (btf->kind_layout) { + memcpy(p, btf->kind_layout, hdr->kind_layout_len); + if (swap_endian) + btf_bswap_kind_layout_sec(p, hdr->kind_layout_len); + p += hdr->kind_layout_len; + } *size = data_sz; return data; err_out: @@ -1425,13 +1480,13 @@ static void btf_invalidate_raw_data(struct btf *btf) } } -/* Ensure BTF is ready to be modified (by splitting into a three memory - * regions for header, types, and strings). Also invalidate cached - * raw_data, if any. +/* Ensure BTF is ready to be modified (by splitting into a three or four memory + * regions for header, types, strings and optional kind layout). Also invalidate + * cached raw_data, if any. */ static int btf_ensure_modifiable(struct btf *btf) { - void *hdr, *types; + void *hdr, *types, *kind_layout = NULL; struct strset *set = NULL; int err = -ENOMEM; @@ -1446,9 +1501,17 @@ static int btf_ensure_modifiable(struct btf *btf) types = malloc(btf->hdr->type_len); if (!hdr || !types) goto err_out; + if (btf->hdr->hdr_len >= sizeof(struct btf_header) && + btf->hdr->kind_layout_off && btf->hdr->kind_layout_len) { + kind_layout = calloc(1, btf->hdr->kind_layout_len); + if (!kind_layout) + goto err_out; + } memcpy(hdr, btf->hdr, btf->hdr->hdr_len); memcpy(types, btf->types_data, btf->hdr->type_len); + if (kind_layout) + memcpy(kind_layout, btf->kind_layout, btf->hdr->kind_layout_len); /* build lookup index for all strings */ set = strset__new(BTF_MAX_STR_OFFSET, btf->strs_data, btf->hdr->str_len); @@ -1463,6 +1526,8 @@ static int btf_ensure_modifiable(struct btf *btf) btf->types_data_cap = btf->hdr->type_len; btf->strs_data = NULL; btf->strs_set = set; + btf->kind_layout = kind_layout; + /* if BTF was created from scratch, all strings are guaranteed to be * unique and deduplicated */ @@ -1480,6 +1545,7 @@ static int btf_ensure_modifiable(struct btf *btf) strset__free(set); free(hdr); free(types); + free(kind_layout); return err; } From patchwork Fri Jun 16 17:17:21 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283065 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 43874182D2 for ; Fri, 16 Jun 2023 17:18:34 +0000 (UTC) Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 07AC51FEC for ; Fri, 16 Jun 2023 10:18:32 -0700 (PDT) Received: from pps.filterd (m0246630.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCiGth021275; Fri, 16 Jun 2023 17:17:46 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=+sFnDpKr9bGvBb+o4zRiyYu59InAb8JKsYp0LdoPxK0=; b=Czohpo1bnvGHdAQ+cjMEYq0SeBUDfFT5VVl+TjUhUsRIsNE+gVxvQDFD4eV/+4FuYWtb 8ZjPAV2UgPiuvI1+cgZ1NViEBE/KPHzMsWeLaRfFj0TSO+U5H+qOK4WAhqL/nmqvP4ux Pixo1VPcXJ5pON14pFwqws2EOqGhjBri7n6JFmk6/38HFyf3nd7HwmR0C07TnLMa6kcP iwaEOg1G7aeVeS3uS4M7eDvYXpHaLxKnKQnJoPAvk8VX1OhsgA1+p/Zj16dvdDhELIOP 6GIygFfahdtGIJJmgX0FBiUsCxNNRGi9e7DvkShKrJ+4LxpTKzjRy49k4wsDEOlArRBd Nw== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4fkdvh2f-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:46 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GHEMmb012467; Fri, 16 Jun 2023 17:17:45 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmertfq-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:45 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPc007608; Fri, 16 Jun 2023 17:17:44 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-4; Fri, 16 Jun 2023 17:17:44 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 3/9] libbpf: use kind layout to compute an unknown kind size Date: Fri, 16 Jun 2023 18:17:21 +0100 Message-Id: <20230616171728.530116-4-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=941 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160155 X-Proofpoint-ORIG-GUID: d0kc1et2f70Sp0qtvA3C9LvNhD0TxPw2 X-Proofpoint-GUID: d0kc1et2f70Sp0qtvA3C9LvNhD0TxPw2 X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net This allows BTF parsing to proceed even if we do not know the kind. Signed-off-by: Alan Maguire --- tools/lib/bpf/btf.c | 41 ++++++++++++++++++++++++++++++++++------- 1 file changed, 34 insertions(+), 7 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index f9f919fdc728..457997c2a43c 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -327,7 +327,35 @@ static int btf_parse_kind_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) +{ + int size = sizeof(struct btf_type); + struct btf_kind_layout *k = NULL; + __u16 vlen = btf_vlen(t); + __u8 kind = btf_kind(t); + + if (btf->kind_layout) + k = &btf->kind_layout[kind]; + + if (!k || (void *)k > ((void *)btf->kind_layout + btf->hdr->kind_layout_len)) { + pr_debug("Unsupported BTF_KIND: %u\n", btf_kind(t)); + return -EINVAL; + } + + if (!(k->flags & BTF_KIND_LAYOUT_OPTIONAL)) { + /* a required kind, and we do not know about it.. */ + pr_debug("unknown but required kind: %u\n", kind); + return -EINVAL; + } + + size += k->info_sz; + size += vlen * k->elem_sz; + + return size; +} + +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); @@ -363,8 +391,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); } } @@ -463,7 +490,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) { @@ -1672,7 +1699,7 @@ int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_t struct btf_type *t; int sz, err; - sz = btf_type_size(src_type); + sz = btf_type_size(src_btf, src_type); if (sz < 0) return libbpf_err(sz); @@ -1753,7 +1780,7 @@ int btf__add_btf(struct btf *btf, const struct btf *src_btf) memcpy(t, src_btf->types_data, data_sz); for (i = 0; i < cnt; i++) { - sz = btf_type_size(t); + sz = btf_type_size(src_btf, t); if (sz < 0) { /* unlikely, has to be corrupted src_btf */ err = sz; @@ -4749,7 +4776,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; From patchwork Fri Jun 16 17:17:22 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283062 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6032A182D2 for ; Fri, 16 Jun 2023 17:18:10 +0000 (UTC) Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CE8C11FEC for ; Fri, 16 Jun 2023 10:18:08 -0700 (PDT) Received: from pps.filterd (m0246632.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCi7Qe013287; Fri, 16 Jun 2023 17:17:50 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=Ki+diWlKsrEXoVNdw2E0EQX2xGQsCkX2W+f0dDWPay4=; b=xs1PrtN2vWA8RhGi/zDCq7rg16ApMPFAKskkjOpn8l1bgVAi8HsDrF2i6CpS/7D8cOnx Nbqul3tZvx2xTxZlGMDtwZNIl2yPgSSYSKU/aLGD9ls9JrOkDTjWAmMZnWLIzYvay7tq eMsEfotFSktYjHxuPt39+4yOGKMJtHnEL9AqNu9Pw2hdq7gA7TUusEcsaKkQhfoZBiAm wSIe5eJVikmktCUjLnkuQNPNFbcAAVQ5fhiBj7+R+ogk2tSYqAZauMzd8YUwBHSINBtc df8uULU2w9got3Q0xqWLSvtrcfVLjDUiKAN98soKOGNTNpDuYmHBQwdnefMIQlPDIWzL 2A== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4gsu4k48-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:49 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GFk2RM012432; Fri, 16 Jun 2023 17:17:49 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmerthf-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:49 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPe007608; Fri, 16 Jun 2023 17:17:48 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-5; Fri, 16 Jun 2023 17:17:48 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 4/9] btf: support kernel parsing of BTF with kind layout Date: Fri, 16 Jun 2023 18:17:22 +0100 Message-Id: <20230616171728.530116-5-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160155 X-Proofpoint-GUID: 8J4i8kZlZqUw_iaaDpI6dnKrMfd8gLFL X-Proofpoint-ORIG-GUID: 8J4i8kZlZqUw_iaaDpI6dnKrMfd8gLFL X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net Use kind layout to parse BTF with unknown kinds that have a kind layout representation. Validate kind layout if present, and use it to parse BTF with unrecognized kinds. Reject BTF that contains a type of a kind that is not optional. Signed-off-by: Alan Maguire --- kernel/bpf/btf.c | 102 +++++++++++++++++++++++++++++++++++++---------- 1 file changed, 82 insertions(+), 20 deletions(-) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index bd2cac057928..ffe3926ea051 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -257,6 +257,7 @@ struct btf { struct btf_kfunc_set_tab *kfunc_set_tab; struct btf_id_dtor_kfunc_tab *dtor_kfunc_tab; struct btf_struct_metas *struct_meta_tab; + struct btf_kind_layout *kind_layout; /* split BTF support */ struct btf *base_btf; @@ -4965,22 +4966,41 @@ static s32 btf_check_meta(struct btf_verifier_env *env, return -EINVAL; } - if (BTF_INFO_KIND(t->info) > BTF_KIND_MAX || - BTF_INFO_KIND(t->info) == BTF_KIND_UNKN) { - btf_verifier_log(env, "[%u] Invalid kind:%u", - env->log_type_id, BTF_INFO_KIND(t->info)); - return -EINVAL; - } - if (!btf_name_offset_valid(env->btf, t->name_off)) { btf_verifier_log(env, "[%u] Invalid name_offset:%u", env->log_type_id, t->name_off); return -EINVAL; } - var_meta_size = btf_type_ops(t)->check_meta(env, t, meta_left); - if (var_meta_size < 0) - return var_meta_size; + if (BTF_INFO_KIND(t->info) == BTF_KIND_UNKN) { + btf_verifier_log(env, "[%u] Invalid kind:%u", + env->log_type_id, BTF_INFO_KIND(t->info)); + return -EINVAL; + } + + if (BTF_INFO_KIND(t->info) > BTF_KIND_MAX && env->btf->kind_layout && + (BTF_INFO_KIND(t->info) * sizeof(struct btf_kind_layout)) < + env->btf->hdr.kind_layout_len) { + struct btf_kind_layout *k = &env->btf->kind_layout[BTF_INFO_KIND(t->info)]; + + if (!(k->flags & BTF_KIND_LAYOUT_OPTIONAL)) { + btf_verifier_log(env, "[%u] unknown but required kind %u", + env->log_type_id, + BTF_INFO_KIND(t->info)); + return -EINVAL; + } + var_meta_size = sizeof(struct btf_type); + var_meta_size += k->info_sz + (btf_type_vlen(t) * k->elem_sz); + } else { + if (BTF_INFO_KIND(t->info) > BTF_KIND_MAX) { + btf_verifier_log(env, "[%u] Invalid kind:%u", + env->log_type_id, BTF_INFO_KIND(t->info)); + return -EINVAL; + } + var_meta_size = btf_type_ops(t)->check_meta(env, t, meta_left); + if (var_meta_size < 0) + return var_meta_size; + } meta_left -= var_meta_size; @@ -5155,7 +5175,8 @@ static int btf_parse_str_sec(struct btf_verifier_env *env) start = btf->nohdr_data + hdr->str_off; end = start + hdr->str_len; - if (end != btf->data + btf->data_size) { + if (hdr->hdr_len < sizeof(struct btf_header) && + end != btf->data + btf->data_size) { btf_verifier_log(env, "String section is not at the end"); return -EINVAL; } @@ -5176,9 +5197,41 @@ static int btf_parse_str_sec(struct btf_verifier_env *env) return 0; } +static int btf_parse_kind_layout_sec(struct btf_verifier_env *env) +{ + const struct btf_header *hdr = &env->btf->hdr; + struct btf *btf = env->btf; + void *start, *end; + + if (hdr->hdr_len < sizeof(struct btf_header) || + hdr->kind_layout_len == 0) + return 0; + + /* Kind layout section must align to 4 bytes */ + if (hdr->kind_layout_off & (sizeof(u32) - 1)) { + btf_verifier_log(env, "Unaligned kind_layout_off"); + return -EINVAL; + } + start = btf->nohdr_data + hdr->kind_layout_off; + end = start + hdr->kind_layout_len; + + if (hdr->kind_layout_len < sizeof(struct btf_kind_layout)) { + btf_verifier_log(env, "Kind layout section is too small"); + return -EINVAL; + } + if (end != btf->data + btf->data_size) { + btf_verifier_log(env, "Kind layout section is not at the end"); + return -EINVAL; + } + btf->kind_layout = start; + + return 0; +} + static const size_t btf_sec_info_offset[] = { offsetof(struct btf_header, type_off), offsetof(struct btf_header, str_off), + offsetof(struct btf_header, kind_layout_off), }; static int btf_sec_info_cmp(const void *a, const void *b) @@ -5193,32 +5246,37 @@ static int btf_check_sec_info(struct btf_verifier_env *env, u32 btf_data_size) { struct btf_sec_info secs[ARRAY_SIZE(btf_sec_info_offset)]; - u32 total, expected_total, i; + u32 nr_secs = ARRAY_SIZE(btf_sec_info_offset); + u32 total, expected_total, gap, i; const struct btf_header *hdr; const struct btf *btf; btf = env->btf; hdr = &btf->hdr; + if (hdr->hdr_len < sizeof(struct btf_header)) + nr_secs--; + /* Populate the secs from hdr */ - for (i = 0; i < ARRAY_SIZE(btf_sec_info_offset); i++) + for (i = 0; i < nr_secs; i++) secs[i] = *(struct btf_sec_info *)((void *)hdr + btf_sec_info_offset[i]); - sort(secs, ARRAY_SIZE(btf_sec_info_offset), + sort(secs, nr_secs, sizeof(struct btf_sec_info), btf_sec_info_cmp, NULL); /* Check for gaps and overlap among sections */ total = 0; expected_total = btf_data_size - hdr->hdr_len; - for (i = 0; i < ARRAY_SIZE(btf_sec_info_offset); i++) { + for (i = 0; i < nr_secs; i++) { if (expected_total < secs[i].off) { btf_verifier_log(env, "Invalid section offset"); return -EINVAL; } - if (total < secs[i].off) { - /* gap */ - btf_verifier_log(env, "Unsupported section found"); + gap = secs[i].off - total; + if (gap >= 4) { + /* gap larger than alignment gap */ + btf_verifier_log(env, "Unsupported section gap found"); return -EINVAL; } if (total > secs[i].off) { @@ -5230,7 +5288,7 @@ static int btf_check_sec_info(struct btf_verifier_env *env, "Total section length too long"); return -EINVAL; } - total += secs[i].len; + total += secs[i].len + gap; } /* There is data other than hdr and known sections */ @@ -5293,7 +5351,7 @@ static int btf_parse_hdr(struct btf_verifier_env *env) return -ENOTSUPP; } - if (hdr->flags) { + if (hdr->flags & ~(BTF_FLAG_CRC_SET | BTF_FLAG_BASE_CRC_SET)) { btf_verifier_log(env, "Unsupported flags"); return -ENOTSUPP; } @@ -5530,6 +5588,10 @@ static struct btf *btf_parse(const union bpf_attr *attr, bpfptr_t uattr, u32 uat if (err) goto errout; + err = btf_parse_kind_layout_sec(env); + if (err) + goto errout; + err = btf_parse_type_sec(env); if (err) goto errout; From patchwork Fri Jun 16 17:17:23 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283063 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 45FF4182D2 for ; Fri, 16 Jun 2023 17:18:11 +0000 (UTC) Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C2ECD2101 for ; Fri, 16 Jun 2023 10:18:09 -0700 (PDT) Received: from pps.filterd (m0246630.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCiGRU021258; Fri, 16 Jun 2023 17:17:54 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=0B1WLVueqMmL5VnGFWPjVKWMIrhp7XBKLFvLvwTpnV0=; b=uFdZNDNjc47kajHbR9okAxWhhgSQ4XdEFN5tU3FPKl9zt8LzfCHTyQme3ZtHJX6o9Ygf fVVwVCX8ZvXgbY4iX7YMRLLq4tFqqedED5fICvFq72ajinhaXb8vbB3iRDF4+n2ttbZj e6dLPwFWctJ3InuG2G9aK0sDUNtHJhZmCnB8rGFCALKSWOrvE47YS8ukmL9JltvsR/WQ 48qR5lE5LjYx0XGz9WP6md8bYO9TmG+w90JqHYIaDfqhGnskEQRtwFpL2KHfX1EynuNS JTW0ex6aRH9Gw2YZrEoLbd2YhbElQdjqvICsVU08SoZb22S7hOMpk1b1L7DffDNkVUqW nA== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4fkdvh2s-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:53 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GG5E78012376; Fri, 16 Jun 2023 17:17:53 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmertke-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:53 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPg007608; Fri, 16 Jun 2023 17:17:52 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-6; Fri, 16 Jun 2023 17:17:52 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 5/9] libbpf: add kind layout encoding, crc support Date: Fri, 16 Jun 2023 18:17:23 +0100 Message-Id: <20230616171728.530116-6-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160155 X-Proofpoint-ORIG-GUID: 9rxdssEDAvSuZQlx-rfkM8A_OerkTltt X-Proofpoint-GUID: 9rxdssEDAvSuZQlx-rfkM8A_OerkTltt X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net Support encoding of BTF kind layout data and crcs via btf__new_empty_opts(). Current supported opts are base_btf, add_kind_layout and add_crc. Signed-off-by: Alan Maguire --- tools/lib/bpf/btf.c | 99 ++++++++++++++++++++++++++++++++++++++-- tools/lib/bpf/btf.h | 11 +++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 108 insertions(+), 3 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 457997c2a43c..060a93809f64 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -16,6 +16,7 @@ #include #include #include +#include #include "btf.h" #include "bpf.h" #include "libbpf.h" @@ -882,8 +883,58 @@ void btf__free(struct btf *btf) free(btf); } -static struct btf *btf_new_empty(struct btf *base_btf) +static void btf_add_kind_layout(struct btf *btf, __u8 kind, + __u16 flags, __u8 info_sz, __u8 elem_sz) { + struct btf_kind_layout *k = &btf->kind_layout[kind]; + + k->flags = flags; + k->info_sz = info_sz; + k->elem_sz = elem_sz; + btf->hdr->kind_layout_len += sizeof(*k); +} + +static int btf_ensure_modifiable(struct btf *btf); + +static int btf_add_kind_layouts(struct btf *btf, struct btf_new_opts *opts) +{ + if (btf_ensure_modifiable(btf)) + return libbpf_err(-ENOMEM); + + btf->kind_layout = calloc(NR_BTF_KINDS, sizeof(struct btf_kind_layout)); + + if (!btf->kind_layout) + return -ENOMEM; + + /* all supported kinds should describe their layout here. */ + btf_add_kind_layout(btf, BTF_KIND_UNKN, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_INT, 0, sizeof(__u32), 0); + btf_add_kind_layout(btf, BTF_KIND_PTR, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_ARRAY, 0, sizeof(struct btf_array), 0); + btf_add_kind_layout(btf, BTF_KIND_STRUCT, 0, 0, sizeof(struct btf_member)); + btf_add_kind_layout(btf, BTF_KIND_UNION, 0, 0, sizeof(struct btf_member)); + btf_add_kind_layout(btf, BTF_KIND_ENUM, 0, 0, sizeof(struct btf_enum)); + btf_add_kind_layout(btf, BTF_KIND_FWD, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_TYPEDEF, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_VOLATILE, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_CONST, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_RESTRICT, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_FUNC, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_FUNC_PROTO, 0, 0, sizeof(struct btf_param)); + btf_add_kind_layout(btf, BTF_KIND_VAR, 0, sizeof(struct btf_var), 0); + btf_add_kind_layout(btf, BTF_KIND_DATASEC, 0, 0, sizeof(struct btf_var_secinfo)); + btf_add_kind_layout(btf, BTF_KIND_FLOAT, 0, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_DECL_TAG, BTF_KIND_LAYOUT_OPTIONAL, + sizeof(struct btf_decl_tag), 0); + btf_add_kind_layout(btf, BTF_KIND_TYPE_TAG, BTF_KIND_LAYOUT_OPTIONAL, 0, 0); + btf_add_kind_layout(btf, BTF_KIND_ENUM64, 0, 0, sizeof(struct btf_enum64)); + + return 0; +} + +static struct btf *btf_new_empty(struct btf_new_opts *opts) +{ + struct btf *base_btf = OPTS_GET(opts, base_btf, NULL); struct btf *btf; btf = calloc(1, sizeof(*btf)); @@ -920,17 +971,53 @@ static struct btf *btf_new_empty(struct btf *base_btf) btf->strs_data = btf->raw_data + btf->hdr->hdr_len; btf->hdr->str_len = base_btf ? 0 : 1; /* empty string at offset 0 */ + if (opts->add_kind_layout) { + int err = btf_add_kind_layouts(btf, opts); + + if (err) { + free(btf->raw_data); + free(btf); + return ERR_PTR(err); + } + } + if (opts->add_crc) { + if (btf->base_btf) { + struct btf_header *base_hdr = btf->base_btf->hdr; + + if (base_hdr->hdr_len >= sizeof(struct btf_header) && + base_hdr->flags & BTF_FLAG_CRC_SET) { + btf->hdr->base_crc = base_hdr->crc; + btf->hdr->flags |= BTF_FLAG_BASE_CRC_SET; + } + } + btf->hdr->flags |= BTF_FLAG_CRC_SET; + } + return btf; } struct btf *btf__new_empty(void) { - return libbpf_ptr(btf_new_empty(NULL)); + LIBBPF_OPTS(btf_new_opts, opts); + + return libbpf_ptr(btf_new_empty(&opts)); } struct btf *btf__new_empty_split(struct btf *base_btf) { - return libbpf_ptr(btf_new_empty(base_btf)); + LIBBPF_OPTS(btf_new_opts, opts); + + opts.base_btf = base_btf; + + return libbpf_ptr(btf_new_empty(&opts)); +} + +struct btf *btf__new_empty_opts(struct btf_new_opts *opts) +{ + if (!OPTS_VALID(opts, btf_new_opts)) + return libbpf_err_ptr(-EINVAL); + + return libbpf_ptr(btf_new_empty(opts)); } static struct btf *btf_new(const void *data, __u32 size, struct btf *base_btf) @@ -1377,6 +1464,12 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi btf_bswap_kind_layout_sec(p, hdr->kind_layout_len); p += hdr->kind_layout_len; } + if (hdr->flags & BTF_FLAG_CRC_SET) { + struct btf_header *h = data; + + h->crc = crc32(0L, (const Bytef *)&data, sizeof(data)); + } + *size = data_sz; return data; err_out: diff --git a/tools/lib/bpf/btf.h b/tools/lib/bpf/btf.h index 8e6880d91c84..d25bd5c19eec 100644 --- a/tools/lib/bpf/btf.h +++ b/tools/lib/bpf/btf.h @@ -107,6 +107,17 @@ LIBBPF_API struct btf *btf__new_empty(void); */ LIBBPF_API struct btf *btf__new_empty_split(struct btf *base_btf); +struct btf_new_opts { + size_t sz; + struct btf *base_btf; /* optional base BTF */ + bool add_kind_layout; /* add BTF kind layout information */ + bool add_crc; /* add CRC information */ + size_t:0; +}; +#define btf_new_opts__last_field add_crc + +LIBBPF_API struct btf *btf__new_empty_opts(struct btf_new_opts *opts); + LIBBPF_API struct btf *btf__parse(const char *path, struct btf_ext **btf_ext); LIBBPF_API struct btf *btf__parse_split(const char *path, struct btf *base_btf); LIBBPF_API struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext); diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 7521a2fb7626..edd8be4b21d0 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -395,4 +395,5 @@ LIBBPF_1.2.0 { LIBBPF_1.3.0 { global: bpf_obj_pin_opts; + btf__new_empty_opts; } LIBBPF_1.2.0; From patchwork Fri Jun 16 17:17:24 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283064 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 961B6182D2 for ; Fri, 16 Jun 2023 17:18:17 +0000 (UTC) Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8332D1FEC for ; Fri, 16 Jun 2023 10:18:16 -0700 (PDT) Received: from pps.filterd (m0333520.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCi1eU005887; Fri, 16 Jun 2023 17:17:57 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=Wwkv+Kqw8/OXmGox5SyQllBP7KSjnv468H1H8hjs4Nk=; b=Sq0MHAXceKKzfj62HzajaQuVavjcv5rN0EOpZW8YGyXnIcfg7ZPFsgdhEuyS9tFoDPN/ a6q60l7ooBSpBPrVokmX08uL2o2S135ET5fHL2QX4MD6pEhpJuMlgLdyQBxemOKaj2T0 w88ToJFgaW08cNilKWc8w72nkDunHW2Nj9v2E8SzgtASAqF3Mnlnha9uYW7V3hXZeccg c/TjX5Wx8zrdyThTmwqjek5uXC954uctI3yWnr/64spPqxOcsL8q201EYtLwq0ieX1hv uN+1uIrBwoWN/3gfMKPHl+GRAPv3WDvMbArSeUCnEv8WvGdJG5AL2zM4LQefCna8Y0I6 PA== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4h7dcrec-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:57 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GG0HDu012477; Fri, 16 Jun 2023 17:17:57 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmertmp-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:17:57 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPi007608; Fri, 16 Jun 2023 17:17:56 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-7; Fri, 16 Jun 2023 17:17:56 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 6/9] btf: generate BTF kind layout for vmlinux/module BTF Date: Fri, 16 Jun 2023 18:17:24 +0100 Message-Id: <20230616171728.530116-7-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160155 X-Proofpoint-ORIG-GUID: 04TV9H26Cw_cR8mYPXPGzJ4duISDgeoc X-Proofpoint-GUID: 04TV9H26Cw_cR8mYPXPGzJ4duISDgeoc X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net Generate BTF kind layout information, crcs for kernel and module BTF if support is available in pahole. Signed-off-by: Alan Maguire --- scripts/pahole-flags.sh | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/scripts/pahole-flags.sh b/scripts/pahole-flags.sh index 728d55190d97..cb304e0a4434 100755 --- a/scripts/pahole-flags.sh +++ b/scripts/pahole-flags.sh @@ -25,6 +25,13 @@ if [ "${pahole_ver}" -ge "124" ]; then fi if [ "${pahole_ver}" -ge "125" ]; then extra_paholeopt="${extra_paholeopt} --skip_encoding_btf_inconsistent_proto --btf_gen_optimized" + pahole_help="$(${PAHOLE} --help)" + if [[ "$pahole_help" =~ "btf_gen_kind_layout" ]]; then + extra_paholeopt="${extra_paholeopt} --btf_gen_kind_layout" + fi + if [[ "$pahole_help" =~ "btf_gen_crc" ]]; then + extra_paholeopt="${extra_paholeopt} --btf_gen_crc" + fi fi echo ${extra_paholeopt} From patchwork Fri Jun 16 17:17:25 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283066 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 243AB182D2 for ; Fri, 16 Jun 2023 17:18:48 +0000 (UTC) Received: from mx0b-00069f02.pphosted.com (mx0b-00069f02.pphosted.com [205.220.177.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5B4832120 for ; Fri, 16 Jun 2023 10:18:45 -0700 (PDT) Received: from pps.filterd (m0246630.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCiFl5021230; Fri, 16 Jun 2023 17:18:27 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=qjao6FoOxureuae5cH9nbW7rHVD6WCZX1yIkGCUg2sE=; b=rlH66+0A3LfH8DJalDTKx2vxDdaE1zeWYG1mvwoOas1nfgQuC6Hv44x3GBfiig7eX1kb XiJ7dBz0z8KeoyoaL+bmwuIi1CfG3Fs8vhCSstIU4hXWd01FHAR67I1rJqmUo1i8lSTU nMwIEa4J4Vmky03T9vRYnR2oKcJ743tWxoSM4QPWroL8gXKsYWRIiiZxFi8PYzC5R9f1 qukTPqYfKDVwJlmPZeUj/+rBHH0NZDYFgIwG4Ytq88R299vN7ZnGy0tbjDEfMnXXiAP8 HEnw0qX6JMkfpIzYctMaSyu1gma7em51842xC3PEibiMGPywhEgXJu90ZXGBO6jAxY6Q WQ== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4fkdvh3m-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:18:26 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GG5oiV012461; Fri, 16 Jun 2023 17:18:26 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmeru08-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:18:26 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPk007608; Fri, 16 Jun 2023 17:18:24 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-8; Fri, 16 Jun 2023 17:18:23 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 7/9] bpftool: add BTF dump "format meta" to dump header/metadata Date: Fri, 16 Jun 2023 18:17:25 +0100 Message-Id: <20230616171728.530116-8-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160156 X-Proofpoint-ORIG-GUID: l1VQHaOp73nCgO7AwaTaIZUY9s1xpoqe X-Proofpoint-GUID: l1VQHaOp73nCgO7AwaTaIZUY9s1xpoqe X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net Provide a way to dump BTF metadata info via bpftool; this consists of BTF size, header fields and kind layout info (if available); for example $ bpftool btf dump file vmlinux format meta size 4966513 magic 0xeb9f version 1 flags 0x0 hdr_len 24 type_len 2929900 type_off 0 str_len 2036589 str_off 2929900 ...or for vmlinux with kind layout, crc: $ bpftool btf dump file vmlinux format meta size 5034496 magic 0xeb9f version 1 flags 0x1 hdr_len 40 type_len 2973628 type_off 0 str_len 2060745 str_off 2973628 kind_layout_len 80 kind_layout_off 5034376 crc 0xb6a5171f base_crc 0x0 kind 0 flags 0x0 info_sz 0 elem_sz 0 kind 1 flags 0x0 info_sz 4 elem_sz 0 kind 2 flags 0x0 info_sz 0 elem_sz 0 kind 3 flags 0x0 info_sz 12 elem_sz 0 kind 4 flags 0x0 info_sz 0 elem_sz 12 ... JSON output is also supported: $ bpftool -j btf dump file vmlinux format meta {"size":4904369,{"header":"magic":60319,"version":1,"flags":0,"hdr_len":24,"type_len":2893508,"type_off":0,"str_len":2010837,"str_off":2893508}} Signed-off-by: Alan Maguire --- tools/bpf/bpftool/bash-completion/bpftool | 2 +- tools/bpf/bpftool/btf.c | 93 ++++++++++++++++++++++- 2 files changed, 92 insertions(+), 3 deletions(-) diff --git a/tools/bpf/bpftool/bash-completion/bpftool b/tools/bpf/bpftool/bash-completion/bpftool index 085bf18f3659..4c186d4efb35 100644 --- a/tools/bpf/bpftool/bash-completion/bpftool +++ b/tools/bpf/bpftool/bash-completion/bpftool @@ -937,7 +937,7 @@ _bpftool() return 0 ;; format) - COMPREPLY=( $( compgen -W "c raw" -- "$cur" ) ) + COMPREPLY=( $( compgen -W "c raw meta" -- "$cur" ) ) ;; *) # emit extra options diff --git a/tools/bpf/bpftool/btf.c b/tools/bpf/bpftool/btf.c index 91fcb75babe3..56f40adcc161 100644 --- a/tools/bpf/bpftool/btf.c +++ b/tools/bpf/bpftool/btf.c @@ -504,6 +504,90 @@ static int dump_btf_c(const struct btf *btf, return err; } +static int dump_btf_meta(const struct btf *btf) +{ + const struct btf_header *hdr; + const struct btf_kind_layout *k; + const void *data; + __u32 data_sz; + __u8 i, nr_kinds; + + data = btf__raw_data(btf, &data_sz); + if (!data) + return -ENOMEM; + hdr = data; + if (json_output) { + jsonw_start_object(json_wtr); /* btf metadata object */ + jsonw_uint_field(json_wtr, "size", data_sz); + jsonw_start_object(json_wtr); + jsonw_name(json_wtr, "header"); + jsonw_uint_field(json_wtr, "magic", hdr->magic); + jsonw_uint_field(json_wtr, "version", hdr->version); + jsonw_uint_field(json_wtr, "flags", hdr->flags); + jsonw_uint_field(json_wtr, "hdr_len", hdr->hdr_len); + jsonw_uint_field(json_wtr, "type_len", hdr->type_len); + jsonw_uint_field(json_wtr, "type_off", hdr->type_off); + jsonw_uint_field(json_wtr, "str_len", hdr->str_len); + jsonw_uint_field(json_wtr, "str_off", hdr->str_off); + } else { + printf("size %-10d\n", data_sz); + printf("magic 0x%-10x\nversion %-10d\nflags 0x%-10x\nhdr_len %-10d\n", + hdr->magic, hdr->version, hdr->flags, hdr->hdr_len); + printf("type_len %-10d\ntype_off %-10d\n", hdr->type_len, hdr->type_off); + printf("str_len %-10d\nstr_off %-10d\n", hdr->str_len, hdr->str_off); + } + + if (hdr->hdr_len < sizeof(struct btf_header) || + hdr->kind_layout_len == 0 || hdr->kind_layout_len == 0) { + if (json_output) { + jsonw_end_object(json_wtr); /* header object */ + jsonw_end_object(json_wtr); /* metadata object */ + } + return 0; + } + + if (json_output) { + jsonw_uint_field(json_wtr, "kind_layout_len", hdr->kind_layout_len); + jsonw_uint_field(json_wtr, "kind_layout_offset", hdr->kind_layout_off); + jsonw_uint_field(json_wtr, "crc", hdr->crc); + jsonw_uint_field(json_wtr, "base_crc", hdr->base_crc); + jsonw_end_object(json_wtr); /* end header object */ + + jsonw_start_object(json_wtr); + jsonw_name(json_wtr, "kind_layouts"); + jsonw_start_array(json_wtr); + } else { + printf("kind_layout_len %-10d\nkind_layout_off %-10d\n", + hdr->kind_layout_len, hdr->kind_layout_off); + printf("crc 0x%-10x\nbase_crc 0x%-10x\n", + hdr->crc, hdr->base_crc); + } + + k = (void *)hdr + hdr->hdr_len + hdr->kind_layout_off; + nr_kinds = hdr->kind_layout_len / sizeof(*k); + for (i = 0; i < nr_kinds; i++) { + if (json_output) { + jsonw_start_object(json_wtr); + jsonw_name(json_wtr, "kind_layout"); + jsonw_uint_field(json_wtr, "kind", i); + jsonw_uint_field(json_wtr, "flags", k[i].flags); + jsonw_uint_field(json_wtr, "info_sz", k[i].info_sz); + jsonw_uint_field(json_wtr, "elem_sz", k[i].elem_sz); + jsonw_end_object(json_wtr); + } else { + printf("kind %-4d flags 0x%-4x info_sz %-4d elem_sz %-4d\n", + i, k[i].flags, k[i].info_sz, k[i].elem_sz); + } + } + if (json_output) { + jsonw_end_array(json_wtr); + jsonw_end_object(json_wtr); /* end kind layout */ + jsonw_end_object(json_wtr); /* end metadata object */ + } + + return 0; +} + static const char sysfs_vmlinux[] = "/sys/kernel/btf/vmlinux"; static struct btf *get_vmlinux_btf_from_sysfs(void) @@ -553,6 +637,7 @@ static int do_dump(int argc, char **argv) __u32 root_type_ids[2]; int root_type_cnt = 0; bool dump_c = false; + bool dump_meta = false; __u32 btf_id = -1; const char *src; int fd = -1; @@ -654,10 +739,12 @@ static int do_dump(int argc, char **argv) } if (strcmp(*argv, "c") == 0) { dump_c = true; + } else if (is_prefix(*argv, "meta")) { + dump_meta = true; } else if (strcmp(*argv, "raw") == 0) { dump_c = false; } else { - p_err("unrecognized format specifier: '%s', possible values: raw, c", + p_err("unrecognized format specifier: '%s', possible values: raw, c, meta", *argv); err = -EINVAL; goto done; @@ -692,6 +779,8 @@ static int do_dump(int argc, char **argv) goto done; } err = dump_btf_c(btf, root_type_ids, root_type_cnt); + } else if (dump_meta) { + err = dump_btf_meta(btf); } else { err = dump_btf_raw(btf, root_type_ids, root_type_cnt); } @@ -1063,7 +1152,7 @@ static int do_help(int argc, char **argv) " %1$s %2$s help\n" "\n" " BTF_SRC := { id BTF_ID | prog PROG | map MAP [{key | value | kv | all}] | file FILE }\n" - " FORMAT := { raw | c }\n" + " FORMAT := { raw | c | meta }\n" " " HELP_SPEC_MAP "\n" " " HELP_SPEC_PROGRAM "\n" " " HELP_SPEC_OPTIONS " |\n" From patchwork Fri Jun 16 17:17:26 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283067 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0CABB182D2 for ; Fri, 16 Jun 2023 17:18:55 +0000 (UTC) Received: from mx0a-00069f02.pphosted.com (mx0a-00069f02.pphosted.com [205.220.165.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C39F02120 for ; Fri, 16 Jun 2023 10:18:50 -0700 (PDT) Received: from pps.filterd (m0333521.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCibTe031344; Fri, 16 Jun 2023 17:18:32 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=zhSlSETetKKQxX9p3chPTaRsMmHMN3IzAHygE3xIDmk=; b=Tf7pPsIoqiLyS6ctb2wG9q2Fd4tDNr+4chlKQVNz0ZsU7ZGb3Q6u8fxG9O5mwww4bhTz NtIYGPsSPJ1QBkul1rtjrJhMWi3QsXLh1FjJpITsWeik6rP/fuV+8HUMk/Q19spPo77x KkHUll50eclp4orDhAeiZsLz1iCJ/uJzPzph8C6waV48R/H5969ZQwZS59+wHKHPNf1U pgPgTVI5Z0rnnGL82c1RYCxGZVpK1XiwtyltMcsemDoFsAf6yjqm2HI2emEfPGsLjXzH GGwOSoUzR0BsjhA74NVtZriowRlVEhwLIoO1xRhxhSkXAUGxG6O5Y64zI5qme2vXzExA /w== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4g3bvtjh-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:18:31 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GG4D6S012388; Fri, 16 Jun 2023 17:18:30 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmeru2q-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:18:30 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPm007608; Fri, 16 Jun 2023 17:18:29 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-9; Fri, 16 Jun 2023 17:18:29 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 8/9] bpftool: update doc to describe bpftool btf dump .. format meta Date: Fri, 16 Jun 2023 18:17:26 +0100 Message-Id: <20230616171728.530116-9-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160156 X-Proofpoint-ORIG-GUID: c6NeSo5U4JIf4i5uOrfM6tVD4tJu97w9 X-Proofpoint-GUID: c6NeSo5U4JIf4i5uOrfM6tVD4tJu97w9 X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net ...and provide an example of output. Signed-off-by: Alan Maguire --- tools/bpf/bpftool/Documentation/bpftool-btf.rst | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/tools/bpf/bpftool/Documentation/bpftool-btf.rst b/tools/bpf/bpftool/Documentation/bpftool-btf.rst index 342716f74ec4..6dd779dddbde 100644 --- a/tools/bpf/bpftool/Documentation/bpftool-btf.rst +++ b/tools/bpf/bpftool/Documentation/bpftool-btf.rst @@ -28,7 +28,7 @@ BTF COMMANDS | **bpftool** **btf help** | | *BTF_SRC* := { **id** *BTF_ID* | **prog** *PROG* | **map** *MAP* [{**key** | **value** | **kv** | **all**}] | **file** *FILE* } -| *FORMAT* := { **raw** | **c** } +| *FORMAT* := { **raw** | **c** | **meta** } | *MAP* := { **id** *MAP_ID* | **pinned** *FILE* } | *PROG* := { **id** *PROG_ID* | **pinned** *FILE* | **tag** *PROG_TAG* } @@ -67,8 +67,8 @@ DESCRIPTION typically produced by clang or pahole. **format** option can be used to override default (raw) - output format. Raw (**raw**) or C-syntax (**c**) output - formats are supported. + output format. Raw (**raw**), C-syntax (**c**) and + BTF metadata (**meta**) formats are supported. **bpftool btf help** Print short help message. @@ -266,3 +266,13 @@ All the standard ways to specify map or program are supported: [104859] FUNC 'smbalert_work' type_id=9695 linkage=static [104860] FUNC 'smbus_alert' type_id=71367 linkage=static [104861] FUNC 'smbus_do_alert' type_id=84827 linkage=static + + + **# bpftool btf dump file vmlinux format meta** + + :: + size 4904369 + magic 0xeb9f version 1 flags 0x0 hdr_len 24 + type len 2893508 off 0 + str len 2010837 off 2893508 + From patchwork Fri Jun 16 17:17:27 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alan Maguire X-Patchwork-Id: 13283068 X-Patchwork-Delegate: bpf@iogearbox.net Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 66BFE182D2 for ; Fri, 16 Jun 2023 17:18:57 +0000 (UTC) Received: from mx0a-00069f02.pphosted.com (mx0a-00069f02.pphosted.com [205.220.165.32]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BB4C0211D for ; Fri, 16 Jun 2023 10:18:55 -0700 (PDT) Received: from pps.filterd (m0246617.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35GCicep024827; Fri, 16 Jun 2023 17:18:36 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2023-03-30; bh=akngSeQCi7eQC9h7sjFDdQY3aUwi/ypDFyrgrnj0b8M=; b=ZA56iM3Q5oTHXvyiV5mAKMxgUjcCMMGIq3wzkmIrPYBcKDr4lkmdrG1mbD5pf7/e3itU or3lH+Rtby2DCcmXEftXA4KwhqsKhnRrkUSj/zfwG7GzqoiV2FZSWuDUwBnolGnKBqy0 lhlTRSqQMfFRRsN5dG28o/7G0BbNt6+Kp01ii/lPi6ZwaZn9nP50KyRCwNAgDSyoJayC y2IDG+go400T4MY0TvatYp9oPnmGsTm1jNrJ+NfnWd/xrhiYEujaDnHWBH9kotKVAj6Z PCcRhOfxzRUa0mbVuATNbBWItFxlsmsWACbjfOUgidZyrcA4hCTac/yIPDUtZs+hv7fr Tg== Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.appoci.oracle.com [130.35.100.223]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 3r4hquvr3q-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:18:35 +0000 Received: from pps.filterd (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (8.17.1.19/8.17.1.19) with ESMTP id 35GGvW4p012400; Fri, 16 Jun 2023 17:18:34 GMT Received: from pps.reinject (localhost [127.0.0.1]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTPS id 3r4fmeru4b-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 16 Jun 2023 17:18:34 +0000 Received: from iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35GHGqPo007608; Fri, 16 Jun 2023 17:18:33 GMT Received: from bpf.uk.oracle.com (dhcp-10-175-209-206.vpn.oracle.com [10.175.209.206]) by iadpaimrmta01.imrmtpd1.prodappiadaev1.oraclevcn.com (PPS) with ESMTP id 3r4fmert3d-10; Fri, 16 Jun 2023 17:18:33 +0000 From: Alan Maguire To: acme@kernel.org, ast@kernel.org, andrii@kernel.org, daniel@iogearbox.net, quentin@isovalent.com, jolsa@kernel.org Cc: martin.lau@linux.dev, song@kernel.org, yhs@fb.com, john.fastabend@gmail.com, kpsingh@kernel.org, sdf@google.com, haoluo@google.com, mykolal@fb.com, bpf@vger.kernel.org, Alan Maguire Subject: [PATCH v2 bpf-next 9/9] selftests/bpf: test kind encoding/decoding Date: Fri, 16 Jun 2023 18:17:27 +0100 Message-Id: <20230616171728.530116-10-alan.maguire@oracle.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20230616171728.530116-1-alan.maguire@oracle.com> References: <20230616171728.530116-1-alan.maguire@oracle.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-16_11,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 adultscore=0 bulkscore=0 spamscore=0 suspectscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306160156 X-Proofpoint-ORIG-GUID: VFZHzMBx9dksu6-urX5Xjriy1Y9R86sE X-Proofpoint-GUID: VFZHzMBx9dksu6-urX5Xjriy1Y9R86sE X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net X-Patchwork-Delegate: bpf@iogearbox.net verify btf__new_empty_opts() adds kind layouts for all kinds supported, and after adding kind-related types for an unknown kind, ensure that parsing uses this info when that kind is encountered rather than giving up. Also verify that presence of a required kind will fail parsing. Signed-off-by: Alan Maguire --- .../selftests/bpf/prog_tests/btf_kind.c | 187 ++++++++++++++++++ 1 file changed, 187 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/btf_kind.c diff --git a/tools/testing/selftests/bpf/prog_tests/btf_kind.c b/tools/testing/selftests/bpf/prog_tests/btf_kind.c new file mode 100644 index 000000000000..ff37126b6bc0 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/btf_kind.c @@ -0,0 +1,187 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2023, Oracle and/or its affiliates. */ + +#include +#include +#include + +/* verify kind encoding exists for each kind */ +void test_btf_kind_encoding(struct btf *btf) +{ + const struct btf_header *hdr; + const void *raw_btf; + __u32 raw_size; + + raw_btf = btf__raw_data(btf, &raw_size); + if (!ASSERT_OK_PTR(raw_btf, "btf__raw_data")) + return; + + hdr = raw_btf; + + ASSERT_GT(hdr->kind_layout_off, hdr->str_off, "kind layout off"); + ASSERT_EQ(hdr->kind_layout_len, sizeof(struct btf_kind_layout) * NR_BTF_KINDS, + "kind_layout_len"); +} + +static void write_raw_btf(const char *btf_path, void *raw_btf, size_t raw_size) +{ + int fd = open(btf_path, O_WRONLY | O_CREAT); + + write(fd, raw_btf, raw_size); + close(fd); +} + +/* fabricate an unrecognized kind at BTF_KIND_MAX + 1, and after adding + * the appropriate struct/typedefs to the BTF such that it recognizes + * this kind, ensure that parsing of BTF containing the unrecognized kind + * can succeed. + */ +void test_btf_kind_decoding(struct btf *btf) +{ + __s32 int_id, unrec_id, id, id2; + struct btf_type *t; + char btf_path[64]; + const void *raw_btf; + void *new_raw_btf; + struct btf *new_btf; + struct btf_header *hdr; + struct btf_kind_layout *k; + __u32 raw_size; + + int_id = btf__add_int(btf, "test_char", 1, BTF_INT_CHAR); + if (!ASSERT_GT(int_id, 0, "add_int_id")) + return; + + /* now create our type with unrecognized kind by adding a typedef kind + * we will overwrite it with our unrecognized kind value. + */ + unrec_id = btf__add_typedef(btf, "unrec_kind", int_id); + if (!ASSERT_GT(unrec_id, 0, "add_unrec_id")) + return; + + /* add an id after it that we will look up to verify we can parse + * beyond unrecognized kinds. + */ + id = btf__add_typedef(btf, "test_lookup", int_id); + if (!ASSERT_GT(id, 0, "add_test_lookup_id")) + return; + id2 = btf__add_typedef(btf, "test_lookup2", int_id); + if (!ASSERT_GT(id2, 0, "add_test_lookup_id2")) + return; + + raw_btf = (void *)btf__raw_data(btf, &raw_size); + if (!ASSERT_OK_PTR(raw_btf, "btf__raw_data")) + return; + + new_raw_btf = calloc(1, raw_size + sizeof(*k)); + memcpy(new_raw_btf, raw_btf, raw_size); + + /* add new layout description */ + hdr = new_raw_btf; + hdr->kind_layout_len += sizeof(*k); + k = new_raw_btf + hdr->hdr_len + hdr->kind_layout_off; + k[NR_BTF_KINDS].flags = BTF_KIND_LAYOUT_OPTIONAL; + k[NR_BTF_KINDS].info_sz = 0; + k[NR_BTF_KINDS].elem_sz = 0; + + /* now modify our typedef added above to be an unrecognized kind. */ + t = (void *)hdr + hdr->hdr_len + hdr->type_off + sizeof(struct btf_type) + + sizeof(__u32); + t->info = (NR_BTF_KINDS << 24); + + /* now write our BTF to a raw file, ready for parsing. */ + snprintf(btf_path, sizeof(btf_path), "/tmp/btf_kind.%d", getpid()); + + write_raw_btf(btf_path, new_raw_btf, raw_size + sizeof(*k)); + + /* verify parsing succeeds, and that we can read type info past + * the unrecognized kind. + */ + new_btf = btf__parse_raw(btf_path); + if (ASSERT_OK_PTR(new_btf, "btf__parse_raw")) { + ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup", + BTF_KIND_TYPEDEF), id, + "verify_id_lookup"); + ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup2", + BTF_KIND_TYPEDEF), id2, + "verify_id2_lookup"); + + /* verify the kernel can handle unrecognized kinds. */ + ASSERT_EQ(btf__load_into_kernel(new_btf), 0, "btf_load_into_kernel"); + } + btf__free(new_btf); + + /* next, change info_sz to equal sizeof(struct btf_type); this means the + * "test_lookup" kind will be reinterpreted as a singular info element + * following the unrecognized kind. + */ + k[NR_BTF_KINDS].info_sz = sizeof(struct btf_type); + write_raw_btf(btf_path, new_raw_btf, raw_size + sizeof(*k)); + + new_btf = btf__parse_raw(btf_path); + if (ASSERT_OK_PTR(new_btf, "btf__parse_raw")) { + ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup", + BTF_KIND_TYPEDEF), -ENOENT, + "verify_id_not_found"); + /* id of "test_lookup2" will be id2 -1 as we have removed one type */ + ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup2", + BTF_KIND_TYPEDEF), id2 - 1, + "verify_id_lookup2"); + + /* verify the kernel can handle unrecognized kinds. */ + ASSERT_EQ(btf__load_into_kernel(new_btf), 0, "btf_load_into_kernel"); + } + btf__free(new_btf); + + /* next, change elem_sz to equal sizeof(struct btf_type)/2 and set + * vlen associated with unrecognized type to 2; this allows us to verify + * vlen-specified BTF can still be parsed. + */ + k[NR_BTF_KINDS].info_sz = 0; + k[NR_BTF_KINDS].elem_sz = sizeof(struct btf_type)/2; + t->info |= 2; + write_raw_btf(btf_path, new_raw_btf, raw_size + sizeof(*k)); + + new_btf = btf__parse_raw(btf_path); + if (ASSERT_OK_PTR(new_btf, "btf__parse_raw")) { + ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup", + BTF_KIND_TYPEDEF), -ENOENT, + "verify_id_not_found"); + /* id of "test_lookup2" will be id2 -1 as we have removed one type */ + ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup2", + BTF_KIND_TYPEDEF), id2 - 1, + "verify_id_lookup2"); + + /* verify the kernel can handle unrecognized kinds. */ + ASSERT_EQ(btf__load_into_kernel(new_btf), 0, "btf_load_into_kernel"); + } + btf__free(new_btf); + + /* next, change kind to required (no optional flag) and ensure parsing fails. */ + k[NR_BTF_KINDS].flags = 0; + write_raw_btf(btf_path, new_raw_btf, raw_size + sizeof(*k)); + + new_btf = btf__parse_raw(btf_path); + ASSERT_ERR_PTR(new_btf, "btf__parse_raw_required"); + + free(new_raw_btf); + unlink(btf_path); +} + +void test_btf_kind(void) +{ + LIBBPF_OPTS(btf_new_opts, opts); + + opts.add_kind_layout = true; + + struct btf *btf = btf__new_empty_opts(&opts); + + if (!ASSERT_OK_PTR(btf, "btf_new")) + return; + + if (test__start_subtest("btf_kind_encoding")) + test_btf_kind_encoding(btf); + if (test__start_subtest("btf_kind_decoding")) + test_btf_kind_decoding(btf); + btf__free(btf); +}