From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f178.google.com (mail-pf1-f178.google.com [209.85.210.178]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B357E1FF5E3 for ; Thu, 8 Jan 2026 03:16:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842218; cv=none; b=FlgUsj7ZYrDV8l/cGp7t8Ii4220aI9z6mFbRHkRrw0OogWyanFdAtBCjKXmwUTEiBhVI1dxoZWoQwBOR2sekERpoKmqPZH5mtm7pEbl73AVY55cHV75OFV4drbUo1Ep4PEErj9iHveIyuRUAY2bAygsYpi2FJtThW2R+pnfkY7o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842218; c=relaxed/simple; bh=ksqELPO0cXKauiYwTecfnPaKtxldFgV/kANERx4D1IY=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Asn8NhQQ6TYU0T/TQCDNDKFpzM6at0EKUd5RriLnpTROsljZJEKTcvLf0oLTRVpmcYeyTZfBJNy/RJVTTgRdAeRq9lvf3c2veFJMWv6uU8e3KaahbVl0j6iqnUGAAXOC95n9619rP+VsIIOOszLoOIui78021/YjvHVDF2nuVMA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=KGBBOouk; arc=none smtp.client-ip=209.85.210.178 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="KGBBOouk" Received: by mail-pf1-f178.google.com with SMTP id d2e1a72fcca58-7ba55660769so1637793b3a.1 for ; Wed, 07 Jan 2026 19:16:56 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842216; x=1768447016; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=PQF9Y2EREf+dgAVABdiiMRWyZAZapN+hexHBR/LqK4M=; b=KGBBOoukJlESMM5DeiT9zqoi9PHV8qR8FU9VSHoScQVtsdqoLxMyBjn8uPLU5r1Z8+ 89uhIf2gKHJSoVkQJLeLYrVZhQnDhKGDXyWfNagRXyg2g6On6g8Nlqj2Xndf8HE+C27P Sqewzf7eGsqCrTWIP8WgU5ZMaOieh2PdoJFywof1xbxxAo+t6ZIYUZUerijqF99vaEBO IkUJf9Pr48iNSYYUKkWVc9Sgrn8trHjw2ZsCz2dRlq2gDIEmx4Y5TuKa2uRgosF+q0I3 Oc0lt7VrMUaXzhc30rw/LAHvzn+5XEnaQO4tas1bdlCI8AADXT4pqv1vuruo7669OL3B 9hEg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842216; x=1768447016; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=PQF9Y2EREf+dgAVABdiiMRWyZAZapN+hexHBR/LqK4M=; b=LSKD8vA6WoIeXuW9ROVnxLm0RfVVpO/QLNmUq3m5lVNK3xU/V6Brl+TFd34fMMeZwu QwhIHkR5FYs5z/inpoXYIsWnCC31gjt24BLmPaFHNV1RY0swjAZMoTw9n/NyWm4pJGuY i+C0CKKhaLDjGDt9D7Cp2N4PFWqW9aCCYQm0RjE5TO9KH9HBifsQ3TfEOHDrystPpfTQ F7jQVCnFGixajeYDRomje8tOoOTtT6/haWqZ4aORL3W6JVb+rMOFau/Uwnc1YqgwykyP 7GoHAMB4aok3EhvTOJcKjILSaqxhNaeR/wpzRpIu8Losp2SR0+N8rGCqaM/BbTI/0vNX dhnA== X-Forwarded-Encrypted: i=1; AJvYcCWuP9g5bq3cc0qywAdF9qTasQJuPKV2iRpHxIgcQdgqLgA5wmh2tmizltbarAM0jAQ3tz7hW1e5YqAA/GU=@vger.kernel.org X-Gm-Message-State: AOJu0YwprMsYe4V1VCOUTB0pNdNOfuYLOTzzecFZi4TkdUE5ledZGrAk qgXbm0nWiVWWlUluzobUu9VKRwqkXW+O9dwkKOAi70PMRnJUA4t6F7Dx X-Gm-Gg: AY/fxX5F8QXB9Nbc7yb8LtlYQ3zaA2hWgwKjcG+6gPjO3gvSoQoolKBOYtbAntSDUSZ ms0Ifex5B5Sf2E5IprL8fGzzG49q2Tx95BIpcUcFWqvxUxSq/rpXB7i4NRXsKfw67eM4EdiA618 IexgLfffJhGkHa/bIbWqlar6TKjsM2ADUwjBFQh+OUuUyGl8lZEfOeCDg0SGX7+MP2uJpowuDHY 1uCQEcd7lN0KdZFXmA1JNMsdm78KYvcW6c/3pYNo/Q9h80JQ4suGCT/Gjw4pJELEmxJnfCS87cl hz2+oGWi5E14b/D2w7uuhnIdZI/IDdvxDutgiPwiv2Zj0ZvwMr/0plJH4Yw2fpPU0zcxFfm3sCB Ka8zXn8X23fsL86yllZkMftXX2UFlUXISrS3+EMvytFpPOmCL7EvYX9InDIqYsQLNRGyZdd1hYN g4AzKRcUVcN232AlZOGymEXea0Qqs= X-Google-Smtp-Source: AGHT+IHxJx1chwNx2IMHnP6vHObc0mE/s4CGIeE8/R0IOP6ROUhqtKdhAwZnrXNr1L4jq8gp1O7kbw== X-Received: by 2002:a05:6a00:3019:b0:819:6dbc:caf6 with SMTP id d2e1a72fcca58-81b7f101badmr3643122b3a.44.1767842215894; Wed, 07 Jan 2026 19:16:55 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.16.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:16:55 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 01/11] libbpf: Add BTF permutation support for type reordering Date: Thu, 8 Jan 2026 11:16:35 +0800 Message-Id: <20260108031645.1350069-2-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Introduce btf__permute() API to allow in-place rearrangement of BTF types. This function reorganizes BTF type order according to a provided array of type IDs, updating all type references to maintain consistency. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 133 +++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/btf.h | 42 +++++++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 176 insertions(+) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index b136572e889a..bf75f770d29a 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -5887,3 +5887,136 @@ int btf__relocate(struct btf *btf, const struct btf= *base_btf) btf->owns_base =3D false; return libbpf_err(err); } + +struct btf_permute { + struct btf *btf; + __u32 *id_map; + __u32 start_offs; +}; + +/* Callback function to remap individual type ID references */ +static int btf_permute_remap_type_id(__u32 *type_id, void *ctx) +{ + struct btf_permute *p =3D ctx; + __u32 new_id =3D *type_id; + + /* refer to the base BTF or VOID type */ + if (new_id < p->btf->start_id) + return 0; + + if (new_id >=3D btf__type_cnt(p->btf)) + return -EINVAL; + + *type_id =3D p->id_map[new_id - p->btf->start_id + p->start_offs]; + return 0; +} + +int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_cnt, + const struct btf_permute_opts *opts) +{ + struct btf_permute p; + struct btf_ext *btf_ext; + void *nt, *new_types =3D NULL; + __u32 *order_map =3D NULL; + int err =3D 0, i; + __u32 n, id, start_offs =3D 0; + + if (!OPTS_VALID(opts, btf_permute_opts)) + return libbpf_err(-EINVAL); + + if (btf__base_btf(btf)) { + n =3D btf->nr_types; + } else { + if (id_map[0] !=3D 0) + return libbpf_err(-EINVAL); + n =3D btf__type_cnt(btf); + start_offs =3D 1; + } + + if (id_map_cnt !=3D n) + return libbpf_err(-EINVAL); + + /* record the sequence of types */ + order_map =3D calloc(id_map_cnt, sizeof(*id_map)); + if (!order_map) { + err =3D -ENOMEM; + goto done; + } + + new_types =3D calloc(btf->hdr->type_len, 1); + if (!new_types) { + err =3D -ENOMEM; + goto done; + } + + if (btf_ensure_modifiable(btf)) { + err =3D -ENOMEM; + goto done; + } + + for (i =3D start_offs; i < id_map_cnt; i++) { + id =3D id_map[i]; + if (id < btf->start_id || id >=3D btf__type_cnt(btf)) { + err =3D -EINVAL; + goto done; + } + id -=3D btf->start_id - start_offs; + /* cannot be mapped to the same ID */ + if (order_map[id]) { + err =3D -EINVAL; + goto done; + } + order_map[id] =3D i + btf->start_id - start_offs; + } + + p.btf =3D btf; + p.id_map =3D id_map; + p.start_offs =3D start_offs; + nt =3D new_types; + for (i =3D start_offs; i < id_map_cnt; i++) { + struct btf_field_iter it; + const struct btf_type *t; + __u32 *type_id; + int type_size; + + id =3D order_map[i]; + t =3D btf__type_by_id(btf, id); + type_size =3D btf_type_size(t); + memcpy(nt, t, type_size); + + /* fix up referenced IDs for BTF */ + err =3D btf_field_iter_init(&it, nt, BTF_FIELD_ITER_IDS); + if (err) + goto done; + while ((type_id =3D btf_field_iter_next(&it))) { + err =3D btf_permute_remap_type_id(type_id, &p); + if (err) + goto done; + } + + nt +=3D type_size; + } + + /* fix up referenced IDs for btf_ext */ + btf_ext =3D OPTS_GET(opts, btf_ext, NULL); + if (btf_ext) { + err =3D btf_ext_visit_type_ids(btf_ext, btf_permute_remap_type_id, &p); + if (err) + goto done; + } + + for (nt =3D new_types, i =3D 0; i < id_map_cnt - start_offs; i++) { + btf->type_offs[i] =3D nt - new_types; + nt +=3D btf_type_size(nt); + } + + free(order_map); + free(btf->types_data); + btf->types_data =3D new_types; + return 0; + +done: + free(order_map); + free(new_types); + return libbpf_err(err); +} diff --git a/tools/lib/bpf/btf.h b/tools/lib/bpf/btf.h index cc01494d6210..b30008c267c0 100644 --- a/tools/lib/bpf/btf.h +++ b/tools/lib/bpf/btf.h @@ -281,6 +281,48 @@ LIBBPF_API int btf__dedup(struct btf *btf, const struc= t btf_dedup_opts *opts); */ LIBBPF_API int btf__relocate(struct btf *btf, const struct btf *base_btf); =20 +struct btf_permute_opts { + size_t sz; + /* optional .BTF.ext info along the main BTF info */ + struct btf_ext *btf_ext; + size_t :0; +}; +#define btf_permute_opts__last_field btf_ext + +/** + * @brief **btf__permute()** rearranges BTF types in-place according to a = specified ID mapping + * @param btf BTF object to permute + * @param id_map Array mapping original type IDs to new IDs + * @param id_map_cnt Number of elements in @id_map + * @param opts Optional parameters, including BTF extension data for refer= ence updates + * @return 0 on success, negative error code on failure + * + * **btf__permute()** reorders BTF types based on the provided @id_map arr= ay, + * updating all internal type references to maintain consistency. The func= tion + * operates in-place, modifying the BTF object directly. + * + * For **base BTF**: + * - @id_map must include all types from ID 0 to `btf__type_cnt(btf) - 1` + * - @id_map_cnt must be `btf__type_cnt(btf)` + * - Mapping is defined as `id_map[original_id] =3D new_id` + * - `id_map[0]` must be 0 (void type cannot be moved) + * + * For **split BTF**: + * - @id_map must include only split types (types added on top of the base= BTF) + * - @id_map_cnt must be `btf__type_cnt(btf) - btf__type_cnt(btf__base_btf= (btf))` + * - Mapping is defined as `id_map[original_id - start_id] =3D new_id` + * - `start_id` equals `btf__type_cnt(btf__base_btf(btf))` + * + * After permutation, all type references within the BTF data and optional + * BTF extension (if provided via @opts) are updated automatically. + * + * On error, returns a negative error code and sets errno: + * - `-EINVAL`: Invalid parameters or invalid ID mapping + * - `-ENOMEM`: Memory allocation failure + */ +LIBBPF_API int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_c= nt, + const struct btf_permute_opts *opts); + struct btf_dump; =20 struct btf_dump_opts { diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 84fb90a016c9..d18fbcea7578 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -453,4 +453,5 @@ LIBBPF_1.7.0 { bpf_map__exclusive_program; bpf_prog_assoc_struct_ops; bpf_program__assoc_struct_ops; + btf__permute; } LIBBPF_1.6.0; --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f182.google.com (mail-pf1-f182.google.com [209.85.210.182]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6EBC12773F9 for ; Thu, 8 Jan 2026 03:16:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842221; cv=none; b=bmmx8AoTX+XDbBw7m9k3s2/f9lPQ6epJfzJFrS9EblKBhmsFR5h1omOHYf5o+/jBACpLYHI6BCYSdOnw7IkXfC4pTan5K00bjgwmDEX/cBFX0jKByXex3G80gE2UJX531rsrpa5OWeoBz/BpKKhz4cuH/FswtPBJurjZqd4KxwQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842221; c=relaxed/simple; bh=uMiIaTuHoGp8t2XP9PDz6WtnuLCS6v4VMQ6JPWkBmY4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=JZE598S9U9U5Ylk12bEvMijqe8Uf1ccc4ZRC7usqQY8ptzQQ/rTx/uoPQp7I3UQOcB7eljuEMos9VBr+4lP3NgkOOGt7yFE8T//fTBOkfaKcWA9YC2Gb1ZSURNd395zNYOgOVlb/zmxGgEnGRtBACorckMii/wT86bYIaZpH3ZI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=dl/dIZc5; arc=none smtp.client-ip=209.85.210.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="dl/dIZc5" Received: by mail-pf1-f182.google.com with SMTP id d2e1a72fcca58-7d26a7e5639so2040863b3a.1 for ; Wed, 07 Jan 2026 19:16:59 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842219; x=1768447019; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=CLf4MD/8vWtFsjd7VfVNcjK4gNe3ynQJ9Qc+27+cU9U=; b=dl/dIZc5Tl0wIybKUA2TAvfnOauIbMNQtotjfjX8EsqII9ATf7+r718d/4BgSKNL7u O1zBRH9R9yC2TXY9X5eMXnrlkgrWHPpk8h6z/5TP0KCJx87qcOK8h6DzLjOUH/X7onYn e0C/s6ayxF9BcZOHvMS4ZQLDGFoZc5bpQMFdLVw67Nxi/QhziplUVQFO05Zxa+NSiv82 IT8lFN+bdF+YKRo7KQ7RlbvAT/k1y2Y/KAZqX+tpGaRPqzPb/F7FJ37kcdXmh41JrALZ 9CCn9q44PSDioY+zoSsMEah0BGGQfotoAGyqmbuI/+M4r1+epIYBxGu6XUjiXz4GNE1L dSqA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842219; x=1768447019; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=CLf4MD/8vWtFsjd7VfVNcjK4gNe3ynQJ9Qc+27+cU9U=; b=wk++PJOlvgMQcVD4z4chJjwS5HGIhfkxcA06wtejNcCjmEuT5/22JzjqlW8qll5JcA fpXUMDg/G9BZJpxQjZp+EQrQ7vKmNrlBge484GPg7PTtgXf+ErSrQJmRud8bugpGZQT0 Db3cNlruv0eV/+HjI00p/Shn5QSdD7XNohZ3kPZiJFKYtszV8xFZkp5c0sh7ePct6ej7 //mcEUs2d1VDiMD1wPn746lY5dL1GnNmqFc5O/E3PxLo3j4WgEuwF3aaEnDArO29VwQA TdJnN/fQa1oQBlo4SRnInUmT8RVmfsU+LrBMVVlror7SiRzIXA1+0ykLeGkgSp1Hl7cC L61g== X-Forwarded-Encrypted: i=1; AJvYcCU8bCwsPlspJdk6tqvrajRj9IX7/1ZhQshdxied9nyV1AtGk1AJ6D5KO3Un0h/tLyTLF7YKZ+nJVR5Egb8=@vger.kernel.org X-Gm-Message-State: AOJu0YzWhPnBg5hVhh0hQFEtELC9PLoDpaVYfIXfUY8faaX9ni95b7GQ qUsUtLH56Dnx8C7cO/HBE2x5+Wfbxz37dW0+Ty+WKfuhjkit6oSvKJqE X-Gm-Gg: AY/fxX7glGSbiFlGJ2rSDjVjjnnu2gAtjk3dARS8wAA5H5HauhbL8me3H3Ywp2KrT2/ v/kqFMw3Tl5ZPsiWVsUJAtRXLsXLxLWWkufmj6QG9mL5S0p+xPOVrO4otrvwYxcB8t9b7qG1njf 0+qZUzHpoZ1jtput9GlM9RsaE7ywo2nI8GBzo+0vT/7KdNOP1sAYk7rg2HneKQUcohqkMWNxMT8 OHX2XUquW1t6mV8jWMd47mIvpoyJYdPz6Ic6SIlBTV0gDdbipult8exur2n4vV5bKpI6itXPVv/ ahQI6H41f9HbiXgAtsw72+78xKvYdn+7OGeEee1Fc/mFcdWPWErAJewPR2mpZ+KsCy3snFqj2Oq cZQYySiSCBL/siCqCefrYFykDTo8iLmpjGTAqf58l0D+SYtvwkOKbD3Ql7ZrYWOzEhx8fDC5eAm 4tbac/vbkEC0wU4w5HoBPrdk3Xj6c= X-Google-Smtp-Source: AGHT+IFTsBBICmI7w9NUcitepK09zPoWAnQzyjPhrantNXnM2/HoGRyjqD5yGPRnMXOZspGz9cpBMA== X-Received: by 2002:a05:6a00:23d4:b0:81b:be1d:bd51 with SMTP id d2e1a72fcca58-81bbe1dbdf9mr3181660b3a.60.1767842218725; Wed, 07 Jan 2026 19:16:58 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.16.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:16:58 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 02/11] selftests/bpf: Add test cases for btf__permute functionality Date: Thu, 8 Jan 2026 11:16:36 +0800 Message-Id: <20260108031645.1350069-3-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch introduces test cases for the btf__permute function to ensure it works correctly with both base BTF and split BTF scenarios. The test suite includes: - test_permute_base: Validates permutation on base BTF - test_permute_split: Tests permutation on split BTF Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- .../selftests/bpf/prog_tests/btf_permute.c | 244 ++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/btf_permute.c diff --git a/tools/testing/selftests/bpf/prog_tests/btf_permute.c b/tools/t= esting/selftests/bpf/prog_tests/btf_permute.c new file mode 100644 index 000000000000..04ade5ad77ac --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/btf_permute.c @@ -0,0 +1,244 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 Xiaomi */ + +#include +#include +#include "btf_helpers.h" + +static void permute_base_check(struct btf *btf) +{ + VALIDATE_RAW_BTF( + btf, + "[1] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D4 bits_offset=3D0", + "[2] FUNC 'f' type_id=3D6 linkage=3Dstatic", + "[3] PTR '(anon)' type_id=3D4", + "[4] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[5] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D4 bits_offset=3D0", + "[6] FUNC_PROTO '(anon)' ret_type_id=3D4 vlen=3D1\n" + "\t'p' type_id=3D3"); +} + +/* Ensure btf__permute works as expected in the base-BTF scenario */ +static void test_permute_base(void) +{ + struct btf *btf; + __u32 permute_ids[7]; + int err; + + btf =3D btf__new_empty(); + if (!ASSERT_OK_PTR(btf, "empty_main_btf")) + return; + + btf__add_int(btf, "int", 4, BTF_INT_SIGNED); /* [1] int */ + btf__add_ptr(btf, 1); /* [2] ptr to int */ + btf__add_struct(btf, "s1", 4); /* [3] struct s1 { */ + btf__add_field(btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_struct(btf, "s2", 4); /* [4] struct s2 { */ + btf__add_field(btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_func_proto(btf, 1); /* [5] int (*)(int *p); */ + btf__add_func_param(btf, "p", 2); + btf__add_func(btf, "f", BTF_FUNC_STATIC, 5); /* [6] int f(int *p); */ + + VALIDATE_RAW_BTF( + btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1", + "[3] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[4] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[5] FUNC_PROTO '(anon)' ret_type_id=3D1 vlen=3D1\n" + "\t'p' type_id=3D2", + "[6] FUNC 'f' type_id=3D5 linkage=3Dstatic"); + + permute_ids[0] =3D 0; /* [0] -> [0] */ + permute_ids[1] =3D 4; /* [1] -> [4] */ + permute_ids[2] =3D 3; /* [2] -> [3] */ + permute_ids[3] =3D 5; /* [3] -> [5] */ + permute_ids[4] =3D 1; /* [4] -> [1] */ + permute_ids[5] =3D 6; /* [5] -> [6] */ + permute_ids[6] =3D 2; /* [6] -> [2] */ + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_OK(err, "btf__permute_base")) + goto done; + permute_base_check(btf); + + /* ids[0] must be 0 for base BTF */ + permute_ids[0] =3D 4; /* [0] -> [0] */ + permute_ids[1] =3D 0; /* [1] -> [4] */ + permute_ids[2] =3D 3; /* [2] -> [3] */ + permute_ids[3] =3D 5; /* [3] -> [5] */ + permute_ids[4] =3D 1; /* [4] -> [1] */ + permute_ids[5] =3D 6; /* [5] -> [6] */ + permute_ids[6] =3D 2; /* [6] -> [2] */ + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + + /* id_map_cnt is invalid */ + permute_ids[0] =3D 0; /* [0] -> [0] */ + permute_ids[1] =3D 4; /* [1] -> [4] */ + permute_ids[2] =3D 3; /* [2] -> [3] */ + permute_ids[3] =3D 5; /* [3] -> [5] */ + permute_ids[4] =3D 1; /* [4] -> [1] */ + permute_ids[5] =3D 6; /* [5] -> [6] */ + permute_ids[6] =3D 2; /* [6] -> [2] */ + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids) - 1, NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + + /* Multiple types can not be mapped to the same ID */ + permute_ids[0] =3D 0; + permute_ids[1] =3D 4; + permute_ids[2] =3D 4; + permute_ids[3] =3D 5; + permute_ids[4] =3D 1; + permute_ids[5] =3D 6; + permute_ids[6] =3D 2; + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + + /* Type ID must be valid */ + permute_ids[0] =3D 0; + permute_ids[1] =3D 4; + permute_ids[2] =3D 3; + permute_ids[3] =3D 5; + permute_ids[4] =3D 1; + permute_ids[5] =3D 7; + permute_ids[6] =3D 2; + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + +done: + btf__free(btf); +} + +static void permute_split_check(struct btf *btf) +{ + VALIDATE_RAW_BTF( + btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1", + "[3] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[4] FUNC 'f' type_id=3D5 linkage=3Dstatic", + "[5] FUNC_PROTO '(anon)' ret_type_id=3D1 vlen=3D1\n" + "\t'p' type_id=3D2", + "[6] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0"); +} + +/* Ensure btf__permute works as expected in the split-BTF scenario */ +static void test_permute_split(void) +{ + struct btf *split_btf =3D NULL, *base_btf =3D NULL; + __u32 permute_ids[4]; + int err, start_id; + + base_btf =3D btf__new_empty(); + if (!ASSERT_OK_PTR(base_btf, "empty_main_btf")) + return; + + btf__add_int(base_btf, "int", 4, BTF_INT_SIGNED); /* [1] int */ + btf__add_ptr(base_btf, 1); /* [2] ptr to int */ + VALIDATE_RAW_BTF( + base_btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1"); + split_btf =3D btf__new_empty_split(base_btf); + if (!ASSERT_OK_PTR(split_btf, "empty_split_btf")) + goto cleanup; + btf__add_struct(split_btf, "s1", 4); /* [3] struct s1 { */ + btf__add_field(split_btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_struct(split_btf, "s2", 4); /* [4] struct s2 { */ + btf__add_field(split_btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_func_proto(split_btf, 1); /* [5] int (*)(int p); */ + btf__add_func_param(split_btf, "p", 2); + btf__add_func(split_btf, "f", BTF_FUNC_STATIC, 5); /* [6] int f(int *p); = */ + + VALIDATE_RAW_BTF( + split_btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1", + "[3] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[4] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[5] FUNC_PROTO '(anon)' ret_type_id=3D1 vlen=3D1\n" + "\t'p' type_id=3D2", + "[6] FUNC 'f' type_id=3D5 linkage=3Dstatic"); + + start_id =3D btf__type_cnt(base_btf); + permute_ids[3 - start_id] =3D 6; /* [3] -> [6] */ + permute_ids[4 - start_id] =3D 3; /* [4] -> [3] */ + permute_ids[5 - start_id] =3D 5; /* [5] -> [5] */ + permute_ids[6 - start_id] =3D 4; /* [6] -> [4] */ + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids), NUL= L); + if (!ASSERT_OK(err, "btf__permute_split")) + goto cleanup; + permute_split_check(split_btf); + + /* + * For split BTF, id_map_cnt must equal to the number of types + * added on top of base BTF + */ + permute_ids[3 - start_id] =3D 4; + permute_ids[4 - start_id] =3D 3; + permute_ids[5 - start_id] =3D 5; + permute_ids[6 - start_id] =3D 6; + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids) - 1,= NULL); + if (!ASSERT_ERR(err, "btf__permute_split")) + goto cleanup; + /* BTF is not modified */ + permute_split_check(split_btf); + + /* Multiple types can not be mapped to the same ID */ + permute_ids[3 - start_id] =3D 4; + permute_ids[4 - start_id] =3D 3; + permute_ids[5 - start_id] =3D 3; + permute_ids[6 - start_id] =3D 6; + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids), NUL= L); + if (!ASSERT_ERR(err, "btf__permute_split")) + goto cleanup; + /* BTF is not modified */ + permute_split_check(split_btf); + + /* Can not map to base ID */ + permute_ids[3 - start_id] =3D 4; + permute_ids[4 - start_id] =3D 2; + permute_ids[5 - start_id] =3D 5; + permute_ids[6 - start_id] =3D 6; + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids), NUL= L); + if (!ASSERT_ERR(err, "btf__permute_split")) + goto cleanup; + /* BTF is not modified */ + permute_split_check(split_btf); + +cleanup: + btf__free(split_btf); + btf__free(base_btf); +} + +void test_btf_permute(void) +{ + if (test__start_subtest("permute_base")) + test_permute_base(); + if (test__start_subtest("permute_split")) + test_permute_split(); +} --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f177.google.com (mail-pf1-f177.google.com [209.85.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3A8D8285072 for ; Thu, 8 Jan 2026 03:17:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842224; cv=none; b=C0G7/32fjkAYVx/bBtFA3XLFILEq6bNDlGR3kr7124OUbuUj/i784qTx58MMdviv3pBwsIdyWXEBJMF49sFP5wsQ7FlZ70OtlveEvaoH1d+vmVGASuWPoyH+oIhNrbU/2c3ytKJD4SIrFy94KY6wIW8tkYVsMZj7XOQo1FF4/XM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842224; c=relaxed/simple; bh=V2vGk2Zy5fJHvJb6bZZNfPor1jIBJ/nlZMkVKHTwBMQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=AtdFNcrMtfctVNiQUg0dMF2xUr+JkozHex5ffkjdehIqLB3gdFO43G1h0Usn4QR8XPyR71LgG0YNAg/aTUuqQfJoNM56/ct1swALtjnIkqhsWTOSgAel38xTCgyPZS/UdpLb9r/TPSXWWT+voYAhc08m8vg7IAbzlBfSoDQGQ2s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=hBJ/HBOO; arc=none smtp.client-ip=209.85.210.177 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="hBJ/HBOO" Received: by mail-pf1-f177.google.com with SMTP id d2e1a72fcca58-7aab061e7cbso3007133b3a.1 for ; Wed, 07 Jan 2026 19:17:02 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842221; x=1768447021; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Bty2Mx4T9JTfidtdE5tI1SEQacGBSMSmT3cGtlsXrrQ=; b=hBJ/HBOOqNmmDb60WJtTA3CBMUoSqXFl8m0u7RHYAUSyczcDRXN8mMmdu1PeymdAOT UQ09oYEwBwBXED8N6TIgDPyFSTSa72rDE7YV9aYFzibI4tFlhJJpkPfcpZkinzscZuyc LT+0zRmewT7mqdpnogKV9ejwAQ6nBOqyw+P0a3Qsb17BRfyGBsxgMLGqonz3zcWtWNVz kUNsZQTs6LtL5hScszsmkg1W3d505Q3lgJNvEMPXiRxlFKzp0gt6vOE8OmMk2j1sP/n2 dGosZdFTHvslwOCy1Lf79yHUko39ioX/PGoig/bndqrdMY4jZ7eRgnInGDNWn2AJjuuV 8y8Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842221; x=1768447021; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Bty2Mx4T9JTfidtdE5tI1SEQacGBSMSmT3cGtlsXrrQ=; b=QhhXF6LDKGNZk3Bslh8WeCWk+JU4egrkeSdnqaI44LdPhJtGo6EZoMD+TW84xsKKLg 07caS4Kz5peBDwQCyz73/cPnZRa/cYpI6sXAYYdDPZWbrTMp/H+wPOk6ITnZw50Tkivq RJYiRhizZQCdfQw8gN3hJhVmv6TRC7wxspbAIUjNWCPYt/iYKafRDYjQdeRh9SnRBbky 6dEbac/lPI7V3MVoiehi/a3una1t7808MYn72A/rmXjWq2ZX2yIXEhnDYF2JpwB7/ews r30kEXiFjofnnT0SGl20u/eTgBGp2k3YngP47IA4Jt06hk1VKYX0ZHpySrj+luAdxnw2 +JEg== X-Forwarded-Encrypted: i=1; AJvYcCUYjbB/ANR4loVAc6TJN08jL9b4lOF4s46JfBllIcrYXlQzFV4x6sISCH5fXdd3Nf5RZJAgfw/kW+dzwUY=@vger.kernel.org X-Gm-Message-State: AOJu0YwnOGgq9wX446xrr2IAs2Myo2xvFXTxYFWUc/34uEInqB9w1TEB NESQpsSZdZgQm2DJFAUcC/VdTx8i+ii2FRALacqSTK9ScSrPQIziVlbf X-Gm-Gg: AY/fxX7mdN/y2lRTgQCbelznYhWYh9b4hz6IUk07Z5EjDOV5Co1CC+OxPh6jdjg1xe5 WHaQ3cmSrOEKc7CNJb9WpV+8sDX3lWAZ0QBDFddZJGDQtxRBEoh/sZdx8/C5TXNDlzAhTO3Javm OL5AebtKp1Y+kd7StY12G4gF1ztIOoOnbZVMUCMlWzL+InXTdDqmx+QYmaKtQ5hYLwwImuXwIxl Rmu5HscasHUVaU3gn/2/8Vf9q5mfqiveLrhz0HWe9Tl/eJ3HcEnXHZPTUEaT2WREu6HuBIrDA34 6UtA3P5ljLSJhoKtMdDwNcoBJFzTI6ounYLGylrV26T1F+SHTrkt15LJEDv0kJnm5Y0WrH688RM 37/40zGXt4ua96tSWN1pDqupf4VbHQyXlP9g7ezGjXNdOY3hcYM6svlpNNjiSVmxdLwQKccDNlX A0fVSFqYRAg4GfGzHl8oJQh4pg68E= X-Google-Smtp-Source: AGHT+IHMEKVP3mhXgUpos/Q5KytBuzrqYEqaOFBA7IWN01A7RqP3IhiAjx4qP/6grxzJEKNhfrReQQ== X-Received: by 2002:a05:6a00:3288:b0:7e8:4433:8fac with SMTP id d2e1a72fcca58-81b7fdc379bmr3840681b3a.52.1767842221498; Wed, 07 Jan 2026 19:17:01 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.16.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:01 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 03/11] tools/resolve_btfids: Support BTF sorting feature Date: Thu, 8 Jan 2026 11:16:37 +0800 Message-Id: <20260108031645.1350069-4-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This introduces a new BTF sorting phase that specifically sorts BTF types by name in ascending order, so that the binary search can be used to look up types. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/bpf/resolve_btfids/main.c | 64 +++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/mai= n.c index df39982f51df..343d08050116 100644 --- a/tools/bpf/resolve_btfids/main.c +++ b/tools/bpf/resolve_btfids/main.c @@ -850,6 +850,67 @@ static int dump_raw_btf(struct btf *btf, const char *o= ut_path) return 0; } =20 +/* + * Sort types by name in ascending order resulting in all + * anonymous types being placed before named types. + */ +static int cmp_type_names(const void *a, const void *b, void *priv) +{ + struct btf *btf =3D (struct btf *)priv; + const struct btf_type *ta =3D btf__type_by_id(btf, *(__u32 *)a); + const struct btf_type *tb =3D btf__type_by_id(btf, *(__u32 *)b); + const char *na, *nb; + + na =3D btf__str_by_offset(btf, ta->name_off); + nb =3D btf__str_by_offset(btf, tb->name_off); + return strcmp(na, nb); +} + +static int sort_btf_by_name(struct btf *btf) +{ + __u32 *permute_ids =3D NULL, *id_map =3D NULL; + int nr_types, i, err =3D 0; + __u32 start_id =3D 0, start_offs =3D 1, id; + + if (btf__base_btf(btf)) { + start_id =3D btf__type_cnt(btf__base_btf(btf)); + start_offs =3D 0; + } + nr_types =3D btf__type_cnt(btf) - start_id; + + permute_ids =3D calloc(nr_types, sizeof(*permute_ids)); + if (!permute_ids) { + err =3D -ENOMEM; + goto out; + } + + id_map =3D calloc(nr_types, sizeof(*id_map)); + if (!id_map) { + err =3D -ENOMEM; + goto out; + } + + for (i =3D 0, id =3D start_id; i < nr_types; i++, id++) + permute_ids[i] =3D id; + + qsort_r(permute_ids + start_offs, nr_types - start_offs, + sizeof(*permute_ids), cmp_type_names, btf); + + for (i =3D 0; i < nr_types; i++) { + id =3D permute_ids[i] - start_id; + id_map[id] =3D i + start_id; + } + + err =3D btf__permute(btf, id_map, nr_types, NULL); + if (err) + pr_err("FAILED: btf permute: %s\n", strerror(-err)); + +out: + free(permute_ids); + free(id_map); + return err; +} + static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path= , const char *suffix) { int len =3D snprintf(buf, buf_sz, "%s%s", in_path, suffix); @@ -1025,6 +1086,9 @@ int main(int argc, const char **argv) if (load_btf(&obj)) goto out; =20 + if (sort_btf_by_name(obj.btf)) + goto out; + if (elf_collect(&obj)) goto out; =20 --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f177.google.com (mail-pf1-f177.google.com [209.85.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0B3A628726D for ; Thu, 8 Jan 2026 03:17:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842226; cv=none; b=gGJB1BmCmTkynemEfG3Ou4Z9gVD9uS+41QDHUYS3EDuZFc+j0nOlW2tIjATaeTYA6hctadJOkQdf194+4lKSahguhdvU9rrb7lCuPrxeaePzuyAqm4segTKwQtFy/Z3YTURiKNSZl6zmY5lGfFZIpeYvyIqpG8gHoEL70fJHlE8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842226; c=relaxed/simple; bh=ZOq8fJcGVS/fCpvZMwV/P+/0vrcfuhuBwBc7kMUvfWk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=c94+l7+Vw08UhbRIotluQPWU4R+YvGS3gGnAnprvteLbgLDu/7ATBSaE8Ijl43rLwTpkM42KB0w7YteOBeeXyv6XX2pmsRjiDwguCMCQ49VweA3uDiBuWMk/ouVCCyA+aak3Xt+f1uQsdeVPiJLGuujN7o0rSsoC8v8PZb5lf68= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Lw/12P0x; arc=none smtp.client-ip=209.85.210.177 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Lw/12P0x" Received: by mail-pf1-f177.google.com with SMTP id d2e1a72fcca58-803474aaa8bso826658b3a.0 for ; Wed, 07 Jan 2026 19:17:04 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842224; x=1768447024; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=s8++2dvjEi+Fcakj7nAgD/5PeeKaHx/ulT/qgv8H064=; b=Lw/12P0xtRGABs9Y4UcApVxlTn+szjObplaqbaP7nv4jZGXX54i+VEGI55nSn2u71/ vsnLhdlb9E2OcpEMg3rBGV19iUSyllXdHwc5WH8EFxRVKYyJpqi6dl9Aj1Tze5jfqB0+ SuqTsOkUNFFWG2OrCCHFgE+sc+Px0Ts8fJPkvWDX6PUg+zmnggaKM4eqwPDsk8useEIo uAlgF8VRKlk5GgTjXS/UIJfe0LI5PFDbMNvLzyBzIONNJRI1DLEFrc3raYKiE7yeFLWY CXq1R8YvBnaZFDYJz4YuZJEJRdHtPw/KphpX1w7Fje25MefWNij0dOSknRWvtAslw4Dy oNeA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842224; x=1768447024; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=s8++2dvjEi+Fcakj7nAgD/5PeeKaHx/ulT/qgv8H064=; b=UA51sM09LY0MUGcPg2Bo20YsVHCV+ypyj2yXwVU6d+Z+lNd+0+dFEYael9FbSzbMg2 c9pQovChzLLiQoz2u/J2W/xu/1PkU7rzdIJb5h/vFLH2jw1HUqoAiTbnCQqCx9PPrY8c SdHvokQrBPgNpTbkRKDynYJfcpTeH2K6GL2F7V5Cv0Pk4BexeE8JJPOa7fLcuwaYbLUq Kd7jOfoZR6SfQ1x78IVu7+Qby6NEX2z16rlk+CqI5tDZ5JqDJudC+doxpUQl5K+/agpq 0C9kfJ0TwRShyG4Gk96AKdvdvRDI0EXuYluRSwBSesQigrVDOo+qgeSgK3gbNTc0vziM gLdg== X-Forwarded-Encrypted: i=1; AJvYcCVVRR4HbXlSU/Kc8UZ8T6dQ0RCwDke3MHnSg9OjXGeMiXvpPacegLk22Fxc36kGnjnPM2lTWAo0SJ8V7js=@vger.kernel.org X-Gm-Message-State: AOJu0Yz2VjnTqTCInM3R8bdGXB6rNjLE5TS4NCQYy3BBJJRVRJRSHUIW +l88BvVErwrHveWPKr4L9uDQb4RSKUmQN/66V3YugZ0wYKYThN4grCS1 X-Gm-Gg: AY/fxX6XomK5495JJicuxyCac2Q5VlkstOY+JFeocX67VNIDfp8NAfoQUx/KGW51nHp aDg1z1f1tt6JkrAFqMNkMzQCrjsdjovAw+M2KPSVkuskCj7wPOEAF1TR9QHtIDI+XYTlyPOAG/Q VoIiIU35UizEm2FbFXfpjSfTtArUIEHLJoEZsLQSy5MmEOAJBi3gcDmpozFOmIdDUt4LddVfO0m oxvPqur2eC78uavDRh1dY6V1Pv+0jEjkwrZFL2erJEjN5Z+viZ75WtV4DJMa2oFyYoAUHRwLIfJ 7LpzPlnKogdSnVS2rUt7fWSPVQ/gIKeapp6cOAnhlRRj9W9oppneznj3HC77IF9PEewThzI/a6y 1Er/wQ1Reor/m267FOWHn4rnWxDGgsMUXoIz0amSXOJ5YisAJVPeGg81Xrv7s/xVumm7P80Z3G6 xcWzbkxTRC9mR8OwPeWuSqiBth9L2aaWxPcWDXMg== X-Google-Smtp-Source: AGHT+IFGwdUyqDwaYlBr4lLMYhoJJzPw06Sbar1py7DjIxEkSI4qkacyGr98gxp0p7UuMGdseTWxoA== X-Received: by 2002:a05:6a00:408c:b0:7a9:f465:f29 with SMTP id d2e1a72fcca58-81b7684e6a1mr4560405b3a.10.1767842224292; Wed, 07 Jan 2026 19:17:04 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:03 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 04/11] libbpf: Optimize type lookup with binary search for sorted BTF Date: Thu, 8 Jan 2026 11:16:38 +0800 Message-Id: <20260108031645.1350069-5-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch introduces binary search optimization for BTF type lookups when the BTF instance contains sorted types. The optimization significantly improves performance when searching for types in large BTF instances with sorted types. For unsorted BTF, the implementation falls back to the original linear search. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng --- tools/lib/bpf/btf.c | 90 +++++++++++++++++++++++++++++++++------------ 1 file changed, 66 insertions(+), 24 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index bf75f770d29a..60ff8eafea83 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -92,6 +92,8 @@ struct btf { * - for split BTF counts number of types added on top of base BTF. */ __u32 nr_types; + /* the start IDs of named types in sorted BTF */ + int named_start_id; /* if not NULL, points to the base BTF on top of which the current * split BTF is based */ @@ -897,46 +899,83 @@ int btf__resolve_type(const struct btf *btf, __u32 ty= pe_id) return type_id; } =20 -__s32 btf__find_by_name(const struct btf *btf, const char *type_name) +static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const ch= ar *name, + __s32 start_id) { - __u32 i, nr_types =3D btf__type_cnt(btf); - - if (!strcmp(type_name, "void")) - return 0; - - for (i =3D 1; i < nr_types; i++) { - const struct btf_type *t =3D btf__type_by_id(btf, i); - const char *name =3D btf__name_by_offset(btf, t->name_off); - - if (name && !strcmp(type_name, name)) - return i; + const struct btf_type *t; + const char *tname; + __s32 l, r, m; + + l =3D start_id; + r =3D btf__type_cnt(btf) - 1; + while (l <=3D r) { + m =3D l + (r - l) / 2; + t =3D btf_type_by_id(btf, m); + tname =3D btf__str_by_offset(btf, t->name_off); + if (strcmp(tname, name) >=3D 0) { + if (l =3D=3D r) + return r; + r =3D m; + } else { + l =3D m + 1; + } } =20 - return libbpf_err(-ENOENT); + return btf__type_cnt(btf); } =20 static __s32 btf_find_by_name_kind(const struct btf *btf, int start_id, - const char *type_name, __u32 kind) + const char *type_name, __s32 kind) { - __u32 i, nr_types =3D btf__type_cnt(btf); + const struct btf_type *t; + const char *tname; + __s32 idx; + + if (start_id < btf->start_id) { + idx =3D btf_find_by_name_kind(btf->base_btf, start_id, + type_name, kind); + if (idx >=3D 0) + return idx; + start_id =3D btf->start_id; + } =20 - if (kind =3D=3D BTF_KIND_UNKN || !strcmp(type_name, "void")) + if (kind =3D=3D BTF_KIND_UNKN || strcmp(type_name, "void") =3D=3D 0) return 0; =20 - for (i =3D start_id; i < nr_types; i++) { - const struct btf_type *t =3D btf__type_by_id(btf, i); - const char *name; + if (btf->named_start_id > 0 && type_name[0]) { + start_id =3D max(start_id, btf->named_start_id); + idx =3D btf_find_type_by_name_bsearch(btf, type_name, start_id); + for (; idx < btf__type_cnt(btf); idx++) { + t =3D btf__type_by_id(btf, idx); + tname =3D btf__str_by_offset(btf, t->name_off); + if (strcmp(tname, type_name) !=3D 0) + return libbpf_err(-ENOENT); + if (kind < 0 || btf_kind(t) =3D=3D kind) + return idx; + } + } else { + __u32 i, total; =20 - if (btf_kind(t) !=3D kind) - continue; - name =3D btf__name_by_offset(btf, t->name_off); - if (name && !strcmp(type_name, name)) - return i; + total =3D btf__type_cnt(btf); + for (i =3D start_id; i < total; i++) { + t =3D btf_type_by_id(btf, i); + if (kind > 0 && btf_kind(t) !=3D kind) + continue; + tname =3D btf__str_by_offset(btf, t->name_off); + if (strcmp(tname, type_name) =3D=3D 0) + return i; + } } =20 return libbpf_err(-ENOENT); } =20 +/* the kind value of -1 indicates that kind matching should be skipped */ +__s32 btf__find_by_name(const struct btf *btf, const char *type_name) +{ + return btf_find_by_name_kind(btf, btf->start_id, type_name, -1); +} + __s32 btf__find_by_name_kind_own(const struct btf *btf, const char *type_n= ame, __u32 kind) { @@ -1006,6 +1045,7 @@ static struct btf *btf_new_empty(struct btf *base_btf) btf->fd =3D -1; btf->ptr_sz =3D sizeof(void *); btf->swapped_endian =3D false; + btf->named_start_id =3D 0; =20 if (base_btf) { btf->base_btf =3D base_btf; @@ -1057,6 +1097,7 @@ static struct btf *btf_new(const void *data, __u32 si= ze, struct btf *base_btf, b btf->start_id =3D 1; btf->start_str_off =3D 0; btf->fd =3D -1; + btf->named_start_id =3D 0; =20 if (base_btf) { btf->base_btf =3D base_btf; @@ -1715,6 +1756,7 @@ static void btf_invalidate_raw_data(struct btf *btf) free(btf->raw_data_swapped); btf->raw_data_swapped =3D NULL; } + btf->named_start_id =3D 0; } =20 /* Ensure BTF is ready to be modified (by splitting into a three memory --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f169.google.com (mail-pf1-f169.google.com [209.85.210.169]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E19DC288C3D for ; Thu, 8 Jan 2026 03:17:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842229; cv=none; b=c0gsnPxV0W2bGNNd6rXaMNWaCcxcPko1J5s+8a48QgwY/NEmZXj3tBSttKxCUxN8TkMn1eyiEd1/oaC4jqjjuANv9nnXpPgwKA1RPWkUpcqxsku3pW2dwcsFEG1WxwVRCsuTHWa88aRHcBbRqCYk8tvQ6x1l7rQsTZS7lzZHFw4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842229; c=relaxed/simple; bh=u1yosoqwlcymFoxHJmfX2OwDeaTdtE3Iyo0L6QN7j0w=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=nYF6J4Si6Nq6x4TEb5Igetoyb9Zy+d40gXIb1/XKjTTmKe+59NzC2WVbSPvx+fWoQMK9AzlTfhnASF6aKP7AmN33MEt7pImXWBW/AKW91d8bt39t06obTIUpH0i3/xeXa/xcOvwkHlIbe56QAFpcYysH5NDgDIzPqAfhsRh+VYg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=AnfeAN+G; arc=none smtp.client-ip=209.85.210.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="AnfeAN+G" Received: by mail-pf1-f169.google.com with SMTP id d2e1a72fcca58-803474aaa8bso826673b3a.0 for ; Wed, 07 Jan 2026 19:17:07 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842227; x=1768447027; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=4kABC1LLrrQty1VIIHsvBVH3NPqN0utmzldvVjxZi68=; b=AnfeAN+GH1SRHmcTuYE6zQB+jgkXYVl2jWltXt/rMI38y4RwIb2NXDiVuFAo8B2iTe af4EIiB59l9d3R5dRRNhg47t+CBUuzmHfw/7pCCdn2u4PFWS4CMpTrYISCv5xkFyfWDl EJsnlUgkDml9pFEXo8rG3YyO9f+muV/Oh3kbJOS8q9G4iHRxWZFoMfY2CBN+QByk9nOJ /fM0pshL8SbZL1w308WSstb3gANVfEmxi3Yf4aEtMW3epPAwswsoh9fhhLRZEBtzQdY/ 3osTzigNu/WCbK8kisUlwwPPL4Xx2GbNSLH+aLu4z0GMkPrzfyrOoSpsA5GAc5NVq+g6 Kjdg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842227; x=1768447027; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=4kABC1LLrrQty1VIIHsvBVH3NPqN0utmzldvVjxZi68=; b=TuAgfZIVnVNZeICbAF7Ahjo3I4uxZMUp9+/6Z4jN3FOaX37YEuP2pi8hUAjRz1Prtk Q2eD0RFtlp3RWkHfUuGFJpQCdIXGwWaqqgtmFHyRWLssupZjSe1Rn5iWx+WI9Mz6JIDE Q+rc/ZSszQwM67YQmwX/lxn0fjRwJLmYCEri+CvvzuBQyuUJuJ0UXQxhRh+feIB2CS15 LOyk8h+zGN+LFQk8CaU8vrUhCefZEqPHlp7DDWX64ZQ+VyL9nUBKa0679irQ1Yw6y/PB KWobQ7ibEgBZf84QFQVHWhnMjuDhKl3ulAwJWQO+na/ae5Pf/8jGLFwwS11GH45bsQpq MdEA== X-Forwarded-Encrypted: i=1; AJvYcCUN+WwZFBkNitzz5s8GesUhiKDcC4SNLdz2SINW1HkmCcLgFHapJRWp8oINJmUYNSDea+a7/hvovx5HghA=@vger.kernel.org X-Gm-Message-State: AOJu0YxFtkzdgExPGelRFM3ld7d3rR+dfN7TnbuwuJSIcPCblfLWWEz2 sXk0qdpTjhuyhZ6Xlp4q8GHKyDkQWLn3iaj07nX/wDZHmQC2BWjyBAUI X-Gm-Gg: AY/fxX60Vw5Xxan/OM0I9ss8aC8TG3I1SDi0gt104GPstBo5KcUKylSb+Lki9S5Fcuh 3OW+8EqbmShWXINoTJZvO5nTUbU8V6ZaF7t9ot0ZwuQTpoBkYfcR+b2MBGsr6Tr+r+IY+B/b8QL eQr3+/RA4H+SUPqZfmVdEzaY/sOu+VPjPcq0uNxFakXTwLc/rnW2O9vCUHxbE4sNKje4TdHCi0s 391IuOaPfCaqycq51fjz/9tY9t2QUnz9vXRGhS8XbX9m8+t1ZL6Tw/8uawzdbMDLfHanVvVfdwm CqSG0uK+uFGgD30vw8Mmn01sZnamXRq1hEWQqJTntGSmb7ESeyjvZar1aD/VUKb7TQrzlvODXAb 19m7T4ov/BwhU95TNZ2GsSKI1+1wt2ZSEB/Gu8dkCnobwqLFljPlnmvXXVG45oYlTpXnfOdj93d FSDX91M67Gz/3ylLrzLREeuxzfuvg= X-Google-Smtp-Source: AGHT+IF5IP72Yw76UNPbKp3qcFOeQ6aRxn9rPrvIV8gootHoOjozaO2uZWqC24LWOtukGHVXMP68rw== X-Received: by 2002:a05:6a00:2b5b:b0:81c:5bca:8104 with SMTP id d2e1a72fcca58-81c5bca823fmr1632563b3a.24.1767842227105; Wed, 07 Jan 2026 19:17:07 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:06 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 05/11] libbpf: Verify BTF sorting Date: Thu, 8 Jan 2026 11:16:39 +0800 Message-Id: <20260108031645.1350069-6-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch checks whether the BTF is sorted by name in ascending order. If sorted, binary search will be used when looking up types. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 60ff8eafea83..277df0077df6 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -899,6 +899,30 @@ int btf__resolve_type(const struct btf *btf, __u32 typ= e_id) return type_id; } =20 +static void btf_check_sorted(struct btf *btf) +{ + __u32 i, n, named_start_id =3D 0; + + n =3D btf__type_cnt(btf); + for (i =3D btf->start_id + 1; i < n; i++) { + struct btf_type *ta =3D btf_type_by_id(btf, i - 1); + struct btf_type *tb =3D btf_type_by_id(btf, i); + const char *na =3D btf__str_by_offset(btf, ta->name_off); + const char *nb =3D btf__str_by_offset(btf, tb->name_off); + + if (strcmp(na, nb) > 0) + return; + + if (named_start_id =3D=3D 0 && na[0] !=3D '\0') + named_start_id =3D i - 1; + if (named_start_id =3D=3D 0 && nb[0] !=3D '\0') + named_start_id =3D i; + } + + if (named_start_id) + btf->named_start_id =3D named_start_id; +} + static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const ch= ar *name, __s32 start_id) { @@ -1132,6 +1156,7 @@ static struct btf *btf_new(const void *data, __u32 si= ze, struct btf *base_btf, b err =3D err ?: btf_sanity_check(btf); if (err) goto done; + btf_check_sorted(btf); =20 done: if (err) { --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f179.google.com (mail-pf1-f179.google.com [209.85.210.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9FC7228726D for ; Thu, 8 Jan 2026 03:17:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842232; cv=none; b=FRvjhpHvCi81VdnxPeCha+H9LJZi+NfDzPjqmewno+jlkkNynnSbentBN80ugTxfQY0sJjP1Ni/t790ZaqQ2XhkMkKF980HlxrNweLb596sQCtm7xO0rFnYszPxYF3GYuv0eLG6QMYilyRyUwhkWTVJdj/Xa610Eyr/o789OqGw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842232; c=relaxed/simple; bh=c745HJ4eBL9O6dcjNGxahlJgFWWLs7lhqs1RisTI0i8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=cFsJ/7G+kb5WDKLyFmQCy7hXl08NH0kNQN3VF5lIFF1sTHlTBLzU6BZOC7tnSJjTfl55vQEsxS6kr+vXosc9VIg7npNYETqd9BAJIA5uVctWVBZZjk+XMwAC+ICY2wxOd4vuI59WOsdg3EJvmDwEujH1GipBD92IdnzeGXXX88E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=XIWJglGa; arc=none smtp.client-ip=209.85.210.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="XIWJglGa" Received: by mail-pf1-f179.google.com with SMTP id d2e1a72fcca58-7b80fed1505so2018000b3a.3 for ; Wed, 07 Jan 2026 19:17:10 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842230; x=1768447030; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=QQrwHecK7iJFotsalH69RC9yNT/x39b0nH1K09oW1Js=; b=XIWJglGaS33yu28VmoRDhibmZorvC5zlVvIRKkfDSZuXHOD0i3H+x2vzqhCY5YXTPp J55tPNsz6C9T4Km1s/FTOYKbgNYBfUKip19fRS0Q4SZOnXP3CAdfpt3wpw8+mB3kNthL qwrfn1jp9Bw+vi0anMXkVjpEfD+CsHFnjCM9jCiVYmN0PjyYuutPqWWxFYFDbVhqrKCo 0AZD4O1dBDREJmz4fIiaRiUCSjihOPBdgpvqbP4Qv9WR6dz+JU27YsPtaz1Sb0tIROd0 oQYYUSAcBNXN1Cu/MCgwfwb/HShdId0nTB3zySYn3wM1Kuz4gpQkGVu9zARvuJXj3KoJ XELQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842230; x=1768447030; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=QQrwHecK7iJFotsalH69RC9yNT/x39b0nH1K09oW1Js=; b=iI4BQ33M2XBCj8n4d2PDbIvsPGpwBdpwHeT9u9sLk7MwlNOVGqzBAggfNUSDL164kh UFaSFqJzJrQj6GA2BVtUm1NolQmgWuq9kbt4bz7bWOCqYskbcha1boHPDPnIzKocr8hw MIHcaB4A+peGRHJppJiDRj6ni1Pt7URwJrurLluiw1PBzyivm3vcJvrb7Zt1qRijXGqa GLuIBkOlWgH5/cAc1BQgm3NoVrFbvECybcd8UiIo+QwnYrTYYhsFbEwVauz05gYqlLQf dDnp3UkY7eulW9fBWfWJ5BKE+bl2wuds+lP9wRTOh5l4XCfTOig1Zn4yNk6WRpvOpNEU GTSw== X-Forwarded-Encrypted: i=1; AJvYcCWXleHVIHmVibwjKf5pgA934tNUdYyYIUp4gJnp69cVXNi1yfv7gVgDade5NWIGPGllpwmGi+0TUZfoBJA=@vger.kernel.org X-Gm-Message-State: AOJu0YzKvQj72AboCI6Hmm6t9Qkt2u6PmidEatRHk0Usk7RBeUfglkkf sKjqIblBnfZkK6YLBTzKI6kiCgpYZS4EiTi/lC1qABPo712nXAaG0KBV X-Gm-Gg: AY/fxX5KgoElPS1bgQ6doXR9Htyag4uf8S3ZnRYlqSLeEqiFAULGfxEXwEvcgjoc7rG hNW8QhiJxfEAdi7L3QA/d5Et6WEzzavOZjCnPHjb2tS9QxsoHn2Ev+a2s1ePThArjsJD25F+qps ftAukVnxLP8JvSOBpBNrAKxHTe0VraDZEm9CRv6vmjjXBM2x3r92dq0edRHlcU/sKbt/YksXWUd F3N/eB/a3hAbbWGEbsTVxANww5CBiDDkLI5VFjL4J1tTgbHUqfXIPiTixwxXxkQjryawc3UH2Ni H+vatzkzEAAaabR10Tx3dWTxwMgmVARKNRwJe3FAvpfLTzHlVwc7FL+SiWmnS0wH6qN35PJgZ91 33SDEpc2jpK2k44bPkIYbh649V9a2U5xl49ADA+uEBdl8eA+vZdw9qoR6EftorEtShk77N2IWUf 6AAhf+JS09jTorEcYbSzHC38bnKrg= X-Google-Smtp-Source: AGHT+IG6VmaJGUutpIyeyvJlJbHM3t8zY9VuCBzH5ppbJhqIHdZT2QK6JoML3+Lr+VD5o+fEXKe/zQ== X-Received: by 2002:a05:6a00:340a:b0:7f6:e75d:8efa with SMTP id d2e1a72fcca58-81b7de58e2bmr4118281b3a.17.1767842229910; Wed, 07 Jan 2026 19:17:09 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:09 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 06/11] btf: Optimize type lookup with binary search Date: Thu, 8 Jan 2026 11:16:40 +0800 Message-Id: <20260108031645.1350069-7-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Improve btf_find_by_name_kind() performance by adding binary search support for sorted types. Falls back to linear search for compatibility. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng --- include/linux/btf.h | 1 + kernel/bpf/btf.c | 91 ++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 83 insertions(+), 9 deletions(-) diff --git a/include/linux/btf.h b/include/linux/btf.h index 691f09784933..78dc79810c7d 100644 --- a/include/linux/btf.h +++ b/include/linux/btf.h @@ -219,6 +219,7 @@ bool btf_is_module(const struct btf *btf); bool btf_is_vmlinux(const struct btf *btf); struct module *btf_try_get_module(const struct btf *btf); u32 btf_nr_types(const struct btf *btf); +u32 btf_named_start_id(const struct btf *btf, bool own); struct btf *btf_base_btf(const struct btf *btf); bool btf_type_is_i32(const struct btf_type *t); bool btf_type_is_i64(const struct btf_type *t); diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 539c9fdea41d..d1f4b984100d 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -259,6 +259,7 @@ struct btf { void *nohdr_data; struct btf_header hdr; u32 nr_types; /* includes VOID for base BTF */ + u32 named_start_id; u32 types_size; u32 data_size; refcount_t refcnt; @@ -494,6 +495,11 @@ static bool btf_type_is_modifier(const struct btf_type= *t) return false; } =20 +static int btf_start_id(const struct btf *btf) +{ + return btf->start_id + (btf->base_btf ? 0 : 1); +} + bool btf_type_is_void(const struct btf_type *t) { return t =3D=3D &btf_void; @@ -544,21 +550,85 @@ u32 btf_nr_types(const struct btf *btf) return total; } =20 +/* btf_named_start_id - Get the named starting ID for the BTF + * @btf: Pointer to the target BTF object + * @own: Flag indicating whether to query only the current BTF (true =3D c= urrent BTF only, + * false =3D recursively traverse the base BTF chain) + * + * Return value rules: + * 1. For a sorted btf, return its named_start_id + * 2. Else for a split BTF, return its start_id + * 3. Else for a base BTF, return 1 + */ +u32 btf_named_start_id(const struct btf *btf, bool own) +{ + const struct btf *base_btf =3D btf; + + while (!own && base_btf->base_btf) + base_btf =3D base_btf->base_btf; + + return base_btf->named_start_id ?: (base_btf->start_id ?: 1); +} + +static s32 btf_find_by_name_kind_bsearch(const struct btf *btf, const char= *name) +{ + const struct btf_type *t; + const char *tname; + s32 l, r, m; + + l =3D btf_named_start_id(btf, true); + r =3D btf_nr_types(btf) - 1; + while (l <=3D r) { + m =3D l + (r - l) / 2; + t =3D btf_type_by_id(btf, m); + tname =3D btf_name_by_offset(btf, t->name_off); + if (strcmp(tname, name) >=3D 0) { + if (l =3D=3D r) + return r; + r =3D m; + } else { + l =3D m + 1; + } + } + + return btf_nr_types(btf); +} + s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind) { + const struct btf *base_btf =3D btf_base_btf(btf); const struct btf_type *t; const char *tname; - u32 i, total; + s32 idx; =20 - total =3D btf_nr_types(btf); - for (i =3D 1; i < total; i++) { - t =3D btf_type_by_id(btf, i); - if (BTF_INFO_KIND(t->info) !=3D kind) - continue; + if (base_btf) { + idx =3D btf_find_by_name_kind(base_btf, name, kind); + if (idx > 0) + return idx; + } =20 - tname =3D btf_name_by_offset(btf, t->name_off); - if (!strcmp(tname, name)) - return i; + if (btf->named_start_id > 0 && name[0]) { + idx =3D btf_find_by_name_kind_bsearch(btf, name); + for (; idx < btf_nr_types(btf); idx++) { + t =3D btf_type_by_id(btf, idx); + tname =3D btf_name_by_offset(btf, t->name_off); + if (strcmp(tname, name) !=3D 0) + return -ENOENT; + if (BTF_INFO_KIND(t->info) =3D=3D kind) + return idx; + } + } else { + u32 i, total; + + total =3D btf_nr_types(btf); + for (i =3D btf_start_id(btf); i < total; i++) { + t =3D btf_type_by_id(btf, i); + if (BTF_INFO_KIND(t->info) !=3D kind) + continue; + tname =3D btf_name_by_offset(btf, t->name_off); + if (strcmp(tname, name) =3D=3D 0) + return i; + } } =20 return -ENOENT; @@ -5791,6 +5861,7 @@ static struct btf *btf_parse(const union bpf_attr *at= tr, bpfptr_t uattr, u32 uat goto errout; } env->btf =3D btf; + btf->named_start_id =3D 0; =20 data =3D kvmalloc(attr->btf_size, GFP_KERNEL | __GFP_NOWARN); if (!data) { @@ -6210,6 +6281,7 @@ static struct btf *btf_parse_base(struct btf_verifier= _env *env, const char *name btf->data =3D data; btf->data_size =3D data_size; btf->kernel_btf =3D true; + btf->named_start_id =3D 0; snprintf(btf->name, sizeof(btf->name), "%s", name); =20 err =3D btf_parse_hdr(env); @@ -6327,6 +6399,7 @@ static struct btf *btf_parse_module(const char *modul= e_name, const void *data, btf->start_id =3D base_btf->nr_types; btf->start_str_off =3D base_btf->hdr.str_len; btf->kernel_btf =3D true; + btf->named_start_id =3D 0; snprintf(btf->name, sizeof(btf->name), "%s", module_name); =20 btf->data =3D kvmemdup(data, data_size, GFP_KERNEL | __GFP_NOWARN); --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f172.google.com (mail-pf1-f172.google.com [209.85.210.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6515828C87C for ; Thu, 8 Jan 2026 03:17:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842234; cv=none; b=qwCF2ZYJsSq5u7oSgFJzjidhcyZ6MNTh7ta14imr/+2tDaOmEPM8U81cjyUUi4CzdGtSA9QJl5XK0PWwBOVD7wB6pzaHrMsa7ckuIxEtJXs9z5b59MO8pduRyhTShqKXeXWFjHiUw3nIaN1AUZ+m2ubeecTrjUmCAmPUZp6rt7U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842234; c=relaxed/simple; bh=mYzJ+kJtBrf1ZOrVJNkEAMPCA73IwwJ3Vq1Lvdq2Ri0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=XOPFn5WsdIKqPpZ7xEBPAtnDG9gOWQAwX7hj6pq0WEmNTVkFlWst4LkCou4lx6iIbDgLDTe74nYNNEHgG/4h4vzKkmVdxAmbjAs19u5m3/hjdFaIEzavGhPWs2NajKFATyMQ7bwDvzOdkr2ng6oscCm/co6l2UkbY2IMSWIDvyw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=k/noFRlq; arc=none smtp.client-ip=209.85.210.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="k/noFRlq" Received: by mail-pf1-f172.google.com with SMTP id d2e1a72fcca58-7aab061e7cbso3007224b3a.1 for ; Wed, 07 Jan 2026 19:17:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842233; x=1768447033; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=TUW7LB43dCgnLiOgR7S2ttrd8S36AZDQc8SQtsp0WmA=; b=k/noFRlqdM9BAgEccQmcUH6hvF33pgwCGHHMDp8+BHKmm2RqBN9XWZLujecfBdSkul sj+bM4EY1679wI0UyWECBJncXZZxDhqhFSqIg6zl4P3I0nRIZq3QaCTDeICtC6aXnXYw BaBYvTWlPQjmPFesNGSbUlQe9NgNrepwyJAqDlQBagnEhVYhnVnwF011TJBOixh0j0+D Zqa4SvylIT4PNH9VGBdkJ0KJ0D6+CirG7DvsoMcmpBpgKR1Q5AmKkH9drjAFQ7GaHnXO rVt84aZJaMyTEzEyjA0aPcChQR9epgT3ZV9CkCPRbnqMgN2k9mksog9jFVO/vCnjfac1 NUeg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842233; x=1768447033; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=TUW7LB43dCgnLiOgR7S2ttrd8S36AZDQc8SQtsp0WmA=; b=l58g+WLedT8x6yoX56qoYYMxBJBY2eLBHJ/Qm3ibKyJnWw7aGFJ40f9kqFCBd9zNvn A6wxZ1ikUCYhhbbj8zWnjDTIBDvi6T+61aXGu6Zj3P/IETDUdywmx7bRmNtktHX759cs q5mvHF2TgZ9U+LbBbHZ9woBMXRtoC4ALknCodSkIzxN8w8QYGqd2uEm9XBdLkcQCWI2A XCxDO3agwytVu0wUFj4KU7GFxH6tF3BDYrQxRZWASXLD33n/YGErkG1PNj1T6JIgEcyO fIOi4InIY4F+m0gyDTtBdom+yp3/ZMq/F8ZH+fR/tKComxicBiXy4lOwyKXDPqhGf/1u I98Q== X-Forwarded-Encrypted: i=1; AJvYcCVns5oUbypckwOrfZfPuoGbo5cWUQ8xCXvKxgLuRFvAlgkNQjJ6UWWTrpNMXVEAkKuB/0o6uIXjJnmFa1c=@vger.kernel.org X-Gm-Message-State: AOJu0YwWBhEITJJhEQTNercgF9clI7MKo8eZy+tmQY+GhVzuyhISG7Pi 2fj01doocNtoShyPyDDSnOHgrU1Caqo07AyHfjahCJNg77T0yM9BpgB05HGw/U1Xwfo= X-Gm-Gg: AY/fxX7jtWuV5/GbrewkGnJ2x7chqOx00rg0lzJBKk4WcajH9ZH689wn1rGaofooyWV P3XDmAELu/uPNg0OOU6mWdKdcOGWwyjSe+HoZNtUtBNEJprKugV5/Qazn/2RHbVxqSKG0ByR81Q Ktq0fytryC5qySOwmKxEBnE2nE3mWxmVl7HcxKb3JL1dAnDtik+q7VlzlWV2/SEqL04MQENXOsp ipNdtsmfzucsqr7cJDZZfPIEQs0V0eHV6pmp7JfXov671GCtIWV5FtCkeF9a7LmME8/ZSmHI3bL UU0TF/hQHOHBXAagG6/RBpyYMDbVSJ66xGzg29o0jdYvzXvvvOJQF0oaKzP1JzH2AvM9tHijstL nELVeLNAAC3aqj/U5TpLxLYamg5YgLHrsIt4L4pCYHgZMsE8ySCKM9TA2fYw4FTVuIPWUFRKrU0 fv8S5PxdFHtgYXFYEnRQ33J69BOB8= X-Google-Smtp-Source: AGHT+IHfnHd8Vmh9kg9OSxh8nSRnoLg5H121xuAGpZndMHXgdQZUDlZaIEVkSuU9Y3qrDpaUIElQPA== X-Received: by 2002:a05:6a00:2a08:b0:7e8:4433:8fb9 with SMTP id d2e1a72fcca58-81b801cc15emr3408043b3a.65.1767842232722; Wed, 07 Jan 2026 19:17:12 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:12 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 07/11] btf: Verify BTF sorting Date: Thu, 8 Jan 2026 11:16:41 +0800 Message-Id: <20260108031645.1350069-8-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch checks whether the BTF is sorted by name in ascending order. If sorted, binary search will be used when looking up types. Specifically, vmlinux and kernel module BTFs are always sorted during the build phase with anonymous types placed before named types, so we only need to identify the starting ID of named types. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng --- kernel/bpf/btf.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index d1f4b984100d..12eecf59d71f 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -550,6 +550,46 @@ u32 btf_nr_types(const struct btf *btf) return total; } =20 +/* Note that vmlinux and kernel module BTFs are always sorted + * during the building phase. + */ +static void btf_check_sorted(struct btf *btf) +{ + u32 i, n, named_start_id =3D 0; + + n =3D btf_nr_types(btf); + if (btf_is_vmlinux(btf)) { + for (i =3D btf_start_id(btf); i < n; i++) { + const struct btf_type *t =3D btf_type_by_id(btf, i); + const char *n =3D btf_name_by_offset(btf, t->name_off); + + if (n[0] !=3D '\0') { + btf->named_start_id =3D i; + return; + } + } + return; + } + + for (i =3D btf_start_id(btf) + 1; i < n; i++) { + const struct btf_type *ta =3D btf_type_by_id(btf, i - 1); + const struct btf_type *tb =3D btf_type_by_id(btf, i); + const char *na =3D btf_name_by_offset(btf, ta->name_off); + const char *nb =3D btf_name_by_offset(btf, tb->name_off); + + if (strcmp(na, nb) > 0) + return; + + if (named_start_id =3D=3D 0 && na[0] !=3D '\0') + named_start_id =3D i - 1; + if (named_start_id =3D=3D 0 && nb[0] !=3D '\0') + named_start_id =3D i; + } + + if (named_start_id) + btf->named_start_id =3D named_start_id; +} + /* btf_named_start_id - Get the named starting ID for the BTF * @btf: Pointer to the target BTF object * @own: Flag indicating whether to query only the current BTF (true =3D c= urrent BTF only, @@ -6302,6 +6342,7 @@ static struct btf *btf_parse_base(struct btf_verifier= _env *env, const char *name if (err) goto errout; =20 + btf_check_sorted(btf); refcount_set(&btf->refcnt, 1); =20 return btf; @@ -6436,6 +6477,7 @@ static struct btf *btf_parse_module(const char *modul= e_name, const void *data, } =20 btf_verifier_env_free(env); + btf_check_sorted(btf); refcount_set(&btf->refcnt, 1); return btf; =20 --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f169.google.com (mail-pf1-f169.google.com [209.85.210.169]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 38ECC2874E3 for ; Thu, 8 Jan 2026 03:17:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842237; cv=none; b=DvEOr6TFd2n+13l+EUxDMYilVLBTuNgZKRsjQobuOPV99CYvOQ/6r1a2Xyp271EKhN5KHERQFfGUb1AYUKONQZZIuWIgIhKVogy3ofJ1ADd5igb/FfiqS06yUrDmEv6qcADHi0XkzAmCGbSQz0ZIyM+88v9jZUxtx8mlRch8YT0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842237; c=relaxed/simple; bh=8smopcu78QnMs/YqVehnE5QN5ynjfgqRwGz8JYBm7fk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=WzgZudctpLPBInVRmVPNCRGk8RnE6H30GG3UWHPTGke3wXMgOglHHeZ5LazYXV14KOwEDkfc5vSL0Ck7wwxz8/GBBD1+NEbqNejj5MTIWKpT7ZqIkOzSLMG90LcyDEbftI3iucRg/vPS3ncuhCFVGJIp94w8YXL03uY1beAFhS4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=C8z7S2Qu; arc=none smtp.client-ip=209.85.210.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="C8z7S2Qu" Received: by mail-pf1-f169.google.com with SMTP id d2e1a72fcca58-7e1651ae0d5so1815068b3a.1 for ; Wed, 07 Jan 2026 19:17:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842235; x=1768447035; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Bv4kvnWYDSS1VS7MLzlNTRoM1YeZxUX9gh+m3TBBfX8=; b=C8z7S2QuqlKPXvUgQJuUPqHE4kx9vmqY1qW/G288hLTMmdq5Fx3OAEVd5KUMrAm3tQ IOIXaSStX2rxaTdE6U+GunU87xgryKMUNpGYVJZi8AMxJsmGXMIwtfCvJOeaisz1DpD5 QuIb4W4DYSy82qwJPxgDJDZ1+imFT1SSt1wMseXzrtDVvvFygVzDBnTDdTse/LDRSgyi wNJGanYFjdkryWrZ1C6Ujd/efANBHdpFBjzRo4ylf39638Trz9F7ock66ZB5q5h0Bvqh 9vGlvkxCSsVCMf5uIEJZJzisqviqFrKVqdP2GXaZPf1zSIJ7tyQidjDpyKya2h5XJGAS RYcg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842235; x=1768447035; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Bv4kvnWYDSS1VS7MLzlNTRoM1YeZxUX9gh+m3TBBfX8=; b=JxQibO9F59zoio67hYVi1lltOFlyD2BzDBVJQqEGO7YTxmmQGY+Ax9bwQN7NU6cbyI ihF8a5L5/+1ci8pZwA80Wll8FwRqcoQZe6uRV2mURG2qYMWgYb6XV6MpDXBGQBOu/f6l hujMnraH5WsL2qtjCIdURqCxKQ801gsxseW7Ru1LCWa27YupMoafEzCatUAV+Q0nnDau f6NW20/vyEnQ/KrM0wfgurRXKDdr+lEJKlafhJrwbW9kRuxbY2/0khm5FH9rrp82Xizi Bth3JOq/IZ6PFdwHQq4pKeRnBR8qlEnVjBOH0eA2GJyI8MwtzlyJPy0z3azYEPJ+irEU kPMw== X-Forwarded-Encrypted: i=1; AJvYcCWli+mAJnvLxHVyogmkMbbYsmMMfzaWFr9pfwweP6BX6RufVhON13byARhfcMgFVn8rG/0rOChro4lhSHw=@vger.kernel.org X-Gm-Message-State: AOJu0Yw51YPdhiL8mDrtxUkifnkyHDi6VOHLg4sDqlq6aoGafXHHThbn ct2rybPsA1QKLbvViXfZCm7mivzt8uIPOEbTgG3xJEvbtwxGMnxD0NIf X-Gm-Gg: AY/fxX5DGKAjhH3MnIC7mCIwfgCy50sG/0Dlp/2KJgVHaCEl7FLKhisdedtI1thALvb Y6m3MX3Fvvo2y9uBIUtSwfogvBwkh4pPUti3ChTjs/nVOaAdMLzfb9w/UHrxVSHwy0+3eyeo6t5 iRsvcQweehYRSMqk/gV01IMsmxrlj+iqmaoNlQZwmovB23H+dLEywTFowrty49E0w6kjYvHbCZz 4Lzrzd7Ukox1gyMaUrHQhXyszS1n5M80dME5OeVg/X+AYapwIxu7B9DmqZFbWQjC+y1szSAlhKz XOD3N3qGsf7uwgIJt3GvozpvJw9szE9B+QO+myvfyKFLVeKhI1VK/L6J1qL1y3Vn92CmquMfYjj cW2rh0KC0lKhgACthcsDcV9WsFw0ylcKf7wnv2fzgZLLEdGlUijM1ta+8SfkQvflqW5BhuIWDrc +WqWVOHc+YB22CFa6UiNkv4hQaEt8= X-Google-Smtp-Source: AGHT+IG2kVTh4tMqTzJLgEcx1fBS0i8ONWGZ1nAHkGySVtfYuQa6+ivUGQpjGgc7PQMd59Rq0Vri8w== X-Received: by 2002:a05:6a00:1c83:b0:7e8:4587:e8cb with SMTP id d2e1a72fcca58-81b811a0929mr4193329b3a.62.1767842235546; Wed, 07 Jan 2026 19:17:15 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:15 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 08/11] bpf: Skip anonymous types in type lookup for performance Date: Thu, 8 Jan 2026 11:16:42 +0800 Message-Id: <20260108031645.1350069-9-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Currently, vmlinux and kernel module BTFs are unconditionally sorted during the build phase, with named types placed at the end. Thus, anonymous types should be skipped when starting the search. In my vmlinux BTF, the number of anonymous types is 61,747, which means the loop count can be reduced by 61,747. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- kernel/bpf/btf.c | 10 ++++++---- kernel/bpf/verifier.c | 7 +------ 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 12eecf59d71f..686dbe18a97a 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -3534,7 +3534,8 @@ const char *btf_find_decl_tag_value(const struct btf = *btf, const struct btf_type const struct btf_type *t; int len, id; =20 - id =3D btf_find_next_decl_tag(btf, pt, comp_idx, tag_key, 0); + id =3D btf_find_next_decl_tag(btf, pt, comp_idx, tag_key, + btf_named_start_id(btf, false) - 1); if (id < 0) return ERR_PTR(id); =20 @@ -7844,12 +7845,13 @@ int btf_prepare_func_args(struct bpf_verifier_env *= env, int subprog) tname); return -EINVAL; } + /* Convert BTF function arguments into verifier types. * Only PTR_TO_CTX and SCALAR are supported atm. */ for (i =3D 0; i < nargs; i++) { u32 tags =3D 0; - int id =3D 0; + int id =3D btf_named_start_id(btf, false) - 1; =20 /* 'arg:' decl_tag takes precedence over derivation of * register type from BTF type itself @@ -9331,7 +9333,7 @@ bpf_core_find_cands(struct bpf_core_ctx *ctx, u32 loc= al_type_id) } =20 /* Attempt to find target candidates in vmlinux BTF first */ - cands =3D bpf_core_add_cands(cands, main_btf, 1); + cands =3D bpf_core_add_cands(cands, main_btf, btf_named_start_id(main_btf= , true)); if (IS_ERR(cands)) return ERR_CAST(cands); =20 @@ -9363,7 +9365,7 @@ bpf_core_find_cands(struct bpf_core_ctx *ctx, u32 loc= al_type_id) */ btf_get(mod_btf); spin_unlock_bh(&btf_idr_lock); - cands =3D bpf_core_add_cands(cands, mod_btf, btf_nr_types(main_btf)); + cands =3D bpf_core_add_cands(cands, mod_btf, btf_named_start_id(mod_btf,= true)); btf_put(mod_btf); if (IS_ERR(cands)) return ERR_CAST(cands); diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 9394b0de2ef0..05fa2e9181f5 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -20642,12 +20642,7 @@ static int find_btf_percpu_datasec(struct btf *btf) * types to look at only module's own BTF types. */ n =3D btf_nr_types(btf); - if (btf_is_module(btf)) - i =3D btf_nr_types(btf_vmlinux); - else - i =3D 1; - - for(; i < n; i++) { + for (i =3D btf_named_start_id(btf, true); i < n; i++) { t =3D btf_type_by_id(btf, i); if (BTF_INFO_KIND(t->info) !=3D BTF_KIND_DATASEC) continue; --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f179.google.com (mail-pf1-f179.google.com [209.85.210.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 118E929B781 for ; Thu, 8 Jan 2026 03:17:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842240; cv=none; b=Ax2BfnzryLa2JLrwCg3qbu1W4sO/Mu8TO/T4imeobR6mpKO4JbLkoyiLtn1X7vrQ1EgxXSmKfmCWYv130tzUb1QdHqMNGxPRMtdniaQNdR2yFTNKwkp5fjoRvl5QVlQuvbRII8EtMJ1HL1jqb6gJZBE+m8s/ub+aDPgBB9BBP4Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842240; c=relaxed/simple; bh=PP4UHGdg2aJ+7TetAPvJTrpVWwYUmJgFr04BIdkvHYQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=cXa7noi4Av4Sdca5If4K/DsyU0VgsFF2v34alxfHu5LQGIFHtpex87x+86CvX8U2Xrm2IqsBp8a0XBAUDyYW1E9CzIBzI/LS8uhSObej0Funk48hdADrVwwmWQQbym3ijvwrukUGHFH1l0d4UbCNaCBjN1OUkMChcgF8rz4We6I= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=KfoNNMsO; arc=none smtp.client-ip=209.85.210.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="KfoNNMsO" Received: by mail-pf1-f179.google.com with SMTP id d2e1a72fcca58-7ba55660769so1637923b3a.1 for ; Wed, 07 Jan 2026 19:17:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842238; x=1768447038; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ezrrIGR+HhUrN/b6TeSbq07sIHXRwZZn0egYDAnCwYw=; b=KfoNNMsOjUVXb8eTTTYd0BPk/4HMV6Fvo3SrstX2GXiq+FEpZu+KrG+ZpZm6Vdn1jR NR8S8P1wznI/0LhVXR4MIC959jczqr/FKO+r5b64+rumGZfMIeejUJIqYwJMYqe6nvwe TSueHq32sdVYE4F46LihYLJGwDiedODxyEYOfvyuFXPcwkw+1olAWjYhX05OYOjlaefd CE4AXOsByi2JLdgHUl14A9x9MOPLOQS/F2YNT4J45LemFANCPcsRkWcQU7mDhrN6e/u3 nMXvpXOJwwAOzFDbvt6P1JQj0ByIhNZnGAFy+QI7mC60k3hhOJHA0eA5x4papnN4y2D1 cmhw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842238; x=1768447038; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=ezrrIGR+HhUrN/b6TeSbq07sIHXRwZZn0egYDAnCwYw=; b=DdnDNIqUeL7vb5NblwhOh40jPqt7jBUpptufNXVqgbOAk3LghZ+bff0q6AXMByOTQv ycCin5bvgqcQE8ZyRTRfrAp4G+E6hdN/8/TXNsHbp1ua8ocMdPUlgGTbE/JOpPXq28k3 v1WuP0L1iqMa8ysAUPLNWLNPBQxTT+s7hfWeFirqNlnkY/eccTiOr1PodYkFW6hpJHUo 184Zv3txf0S9Qd+/Itaz3+lsfWDIZG6/+PCSdvwmVaN7CSDDIEvqffhiE0c3ydphyuIN 0Hdpv72VgC0uSCK+9n1Nc58oovfVTYA7Ut2nrWy/uH7pbNTt4xBuEc/VjTfSnGNY9bP0 T+IA== X-Forwarded-Encrypted: i=1; AJvYcCUFN6ZwBJvE/0126DRW973+8ywdUPtFUpUZaAxWlWNUu950/mEiMpvy3QmY7TFCqUtx8MlvfYQnq+v8od0=@vger.kernel.org X-Gm-Message-State: AOJu0YygiUkXZX85BUChM0n6DzXFuHUMC9e20BOjJ6Y3Xc4dZpKx21WZ ZiRKxfSN66WHr6wmrgPYPEN71IMsbSSUmpBYBUKGx+38oO5VpmiuXaZz X-Gm-Gg: AY/fxX5TbUP9pO52THIiaTrYDyiXgEmVvfMqt8tkphSCJ6aRSO5q07/JEtmk6qIIzcf 8X2YDzZ6P9mc5okATAc2YCRySOqjEOVhLEW9zgvXrkUSC12AGAe68E+LgQYptU97yfSi+IimLNm FvuqHlw+yHVkwNvgqfpw66gBXURhxddXCiGSysbWmyOXcs8+9SdUW92HMG+lmdoxjV+mX91tmKl gF4U6yFBgqEuaFIphD74fSlhoWZ2TQHB1s9qUCT3sXI2WiN/y4QDsBhbKcBzdfRpdP306dpzl86 ZPFFqbkvddn8uzyK9j/58JyHBb+LDCprIZywIP6hMdqxNszBwK3kukhseNettOxYAeaCYcSpJi/ /Q9IFzMY5eS9ZtMtU3LbLIq+bU2by7M7qxNCSji35hIVmptC+9Hck0DLgOOsI/83eXnmA5wk3Lt NCCyV0c/YRxmO41PrSiyTcNUeT83s= X-Google-Smtp-Source: AGHT+IGY0XC7Bq8fqaZyOgdzCEy410IYyQ5e1LkQWO+noXZVG+1d+kqt88x9yfkXPmR+LBtS4d3txQ== X-Received: by 2002:a05:6a00:27a3:b0:77f:4c3e:c19d with SMTP id d2e1a72fcca58-81b7d262421mr4602120b3a.12.1767842238330; Wed, 07 Jan 2026 19:17:18 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:17 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 09/11] bpf: Optimize the performance of find_bpffs_btf_enums Date: Thu, 8 Jan 2026 11:16:43 +0800 Message-Id: <20260108031645.1350069-10-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Currently, vmlinux BTF is unconditionally sorted during the build phase. The function btf_find_by_name_kind executes the binary search branch, so find_bpffs_btf_enums can be optimized by using btf_find_by_name_kind. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- kernel/bpf/inode.c | 42 +++++++++++++++++------------------------- 1 file changed, 17 insertions(+), 25 deletions(-) diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c index 9f866a010dad..005ea3a2cda7 100644 --- a/kernel/bpf/inode.c +++ b/kernel/bpf/inode.c @@ -600,10 +600,17 @@ struct bpffs_btf_enums { =20 static int find_bpffs_btf_enums(struct bpffs_btf_enums *info) { + struct { + const struct btf_type **type; + const char *name; + } btf_enums[] =3D { + {&info->cmd_t, "bpf_cmd"}, + {&info->map_t, "bpf_map_type"}, + {&info->prog_t, "bpf_prog_type"}, + {&info->attach_t, "bpf_attach_type"}, + }; const struct btf *btf; - const struct btf_type *t; - const char *name; - int i, n; + int i, id; =20 memset(info, 0, sizeof(*info)); =20 @@ -615,31 +622,16 @@ static int find_bpffs_btf_enums(struct bpffs_btf_enum= s *info) =20 info->btf =3D btf; =20 - for (i =3D 1, n =3D btf_nr_types(btf); i < n; i++) { - t =3D btf_type_by_id(btf, i); - if (!btf_type_is_enum(t)) - continue; - - name =3D btf_name_by_offset(btf, t->name_off); - if (!name) - continue; - - if (strcmp(name, "bpf_cmd") =3D=3D 0) - info->cmd_t =3D t; - else if (strcmp(name, "bpf_map_type") =3D=3D 0) - info->map_t =3D t; - else if (strcmp(name, "bpf_prog_type") =3D=3D 0) - info->prog_t =3D t; - else if (strcmp(name, "bpf_attach_type") =3D=3D 0) - info->attach_t =3D t; - else - continue; + for (i =3D 0; i < ARRAY_SIZE(btf_enums); i++) { + id =3D btf_find_by_name_kind(btf, btf_enums[i].name, + BTF_KIND_ENUM); + if (id < 0) + return -ESRCH; =20 - if (info->cmd_t && info->map_t && info->prog_t && info->attach_t) - return 0; + *btf_enums[i].type =3D btf_type_by_id(btf, id); } =20 - return -ESRCH; + return 0; } =20 static bool find_btf_enum_const(const struct btf *btf, const struct btf_ty= pe *enum_t, --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pf1-f193.google.com (mail-pf1-f193.google.com [209.85.210.193]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 48774286D70 for ; Thu, 8 Jan 2026 03:17:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.193 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842243; cv=none; b=GNgGZWSWjhBzyFKq/ra/h3vLwC1LaR6VFGi1snNiPC5Ny5j/QM2p2O0B72nRNRrXklBjzqORonrm5TP2sBenRdMG2wZnVsNcGKS64ctrqeGwuEqc2q5YxuHQPZ8GxrQAlTWBe/pUN+BAl9BdYAjRmlUsNk4WnnNeRFZ2UEKUSnE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842243; c=relaxed/simple; bh=k/SsHZ5DiNBKCwpIZ6HyT/U/YK/VAISbL5KNMEGIsjA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Owm36p3HUGnjA2JPzC35aOmuOyWcIv14zza+Xz+U0JPMj33xaPNTJTAnH39i0ZgLT6s7G38SRjQ4pgJtfNiJM1AD7zKaQdx4eIUITa5pJ6VpE3UsBFmMuyzmNi0FemHiFBkghAt7D46sbM0dzxHpvxQQY/7qjNM3fPDgFx2J3AM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=b+FlhBeU; arc=none smtp.client-ip=209.85.210.193 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="b+FlhBeU" Received: by mail-pf1-f193.google.com with SMTP id d2e1a72fcca58-7f0da2dfeaeso2389222b3a.1 for ; Wed, 07 Jan 2026 19:17:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842241; x=1768447041; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ppA0C32r+tZo1J9bYSHe7omsyAFm3sfGap53g1ih6tk=; b=b+FlhBeU98dF8LDu2Yuc9JsHL4tJjq+ppZoCYorYprgrL8SgHV67QMKDNd+TAvVL8W nmmMpGr9+w871ztSfWdBfJnjs1Hcr4vuRB2NfgW8FvhYUeCW/yqX1teWisxZD4oy3WPe s9NOi/SigXV3vS/xlhmx7ASIR45lEVGtEK0a8VKZMYRvJXfBKCKHY37sUF0UL4b81Hih 8A0uO7BzGgb2u913Y/yZ3VAq6OoEHXv9FORLMyK2Y3Y2W0dcigKwoDbOYh5ZGU//9Bm4 T8LYnq7wxyimzoGxPO2DQGPJe5CZLGIlvZtw+qH8Q93lf6/9VeIMa9tsPGbE4nygjvz8 O/9Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842241; x=1768447041; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=ppA0C32r+tZo1J9bYSHe7omsyAFm3sfGap53g1ih6tk=; b=G+nRKCbTUqMb+yHVcKcFDRM7ihJOz2wMTekDzwkU5Zdb1BiuLY+fhg9D5kVhMGkpgn tN1yoZ9pr6p0Olw7MVbvLHWOo2j2wLLBGQc8hE0pCtnaF9krOehwDEG73ok183QilZmO e+T8ggwQl9n1rOLQVmft9ZFZfrDJTWz5YEMjYx2MRY69GBESksBbp7B6L0rBCGa10hzv 1WnU9m+4VMZDFJmROYAfOF1z1M3uW4iIkpUIxxhPy3ci1EzEwFG3S732tf6wT3R77bnj A9keWaMCz3ZL3YanTbq1Fdq8OczN6SK6zIS8Oz5x1MmIZhtgB3M49ZzQPmnwsWbM6ydp t9cA== X-Forwarded-Encrypted: i=1; AJvYcCU/sNoTiJB6DN6Osa3VyvajVy1SlZPzcrDeb8XuvlsgdpqaZWWyoa+YQqBLqRro/fJH3mKfpJMVdhFggfQ=@vger.kernel.org X-Gm-Message-State: AOJu0YysSpKRAOYuFeMXz9UrIB7uOhloAVYtTsw7Mq1Y0VyVMogPxZE2 W/tS9cuhEcknohwIto3msVkxUHVO9sfdHm2tycSFzXRLLztDjfbfY+sB X-Gm-Gg: AY/fxX4HBVCYc3A7lzUJP2Xw9adFz+t0UhrxqYGoSQTKfep4VUqw6p+iFhg6/CUY3vT lFFJqSKnWUfLfxxMWDP6qIpRhnNV7GgRsE2q++CaaDE80iOGPEpWgEzBcqmUsUG1CIjZzMwrPs2 6+C5eDZCwDcuIDoWXt0QYjCFfNwASTTmGVD2/kOYkjl6FTj3jtW4FE6qYV9CtZgkA0VXGMnz+hF VvCEXoq0x0Zs8WYEUARCuWLlbQhwCb/GkLY1hUL5hUmks2lIN8a94uy/Vxl23kDp1AFdnlsi/HB p4o8Kiuptp7KDl03OH/nERf/n6Rnc2/mo2Zf8VR+6x6w02YmJOuuRxIMcAl31O8k6XE2Tjdx2vJ 5Qr+riTIycHtWj4X6G4njJrjhmQpsMEzIcgsYBHB3cctei9OHf7BoTnbcY0y+owNVdMeO1K9mpX RTav0EDIbxdkinp2RljmlUgskUhtE= X-Google-Smtp-Source: AGHT+IFST5MI6yDneKKwxRZqXrRJHnWyFrSyRG8+UfqIpoNr8TF9Bt7R6vZlLpFwpqTGnOdCk3i6vg== X-Received: by 2002:a05:6a00:90a6:b0:7ef:3f4e:9176 with SMTP id d2e1a72fcca58-81b7f9d1932mr3793392b3a.49.1767842241503; Wed, 07 Jan 2026 19:17:21 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:20 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire , Andrii Nakryiko Subject: [PATCH bpf-next v11 10/11] libbpf: Optimize the performance of determine_ptr_size Date: Thu, 8 Jan 2026 11:16:44 +0800 Message-Id: <20260108031645.1350069-11-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Leverage the performance improvement of btf__find_by_name_kind() when BTF is sorted. For sorted BTF, the function uses binary search with O(log n) complexity instead of linear search, providing significant performance benefits, especially for large BTF like vmlinux. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman Acked-by: Andrii Nakryiko --- tools/lib/bpf/btf.c | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 277df0077df6..9e8911755a79 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -659,29 +659,21 @@ static int determine_ptr_size(const struct btf *btf) "int long unsigned", }; const struct btf_type *t; - const char *name; - int i, j, n; + int i, id; =20 if (btf->base_btf && btf->base_btf->ptr_sz > 0) return btf->base_btf->ptr_sz; =20 - n =3D btf__type_cnt(btf); - for (i =3D 1; i < n; i++) { - t =3D btf__type_by_id(btf, i); - if (!btf_is_int(t)) + for (i =3D 0; i < ARRAY_SIZE(long_aliases); i++) { + id =3D btf__find_by_name_kind(btf, long_aliases[i], BTF_KIND_INT); + if (id < 0) continue; =20 + t =3D btf__type_by_id(btf, id); if (t->size !=3D 4 && t->size !=3D 8) continue; =20 - name =3D btf__name_by_offset(btf, t->name_off); - if (!name) - continue; - - for (j =3D 0; j < ARRAY_SIZE(long_aliases); j++) { - if (strcmp(name, long_aliases[j]) =3D=3D 0) - return t->size; - } + return t->size; } =20 return -1; --=20 2.34.1 From nobody Sun Feb 8 08:27:49 2026 Received: from mail-pl1-f182.google.com (mail-pl1-f182.google.com [209.85.214.182]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2E79D285C80 for ; Thu, 8 Jan 2026 03:17:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842246; cv=none; b=qeot4MufhlVcEwLd/J0m+ELeALRWwu57rItDrFNzpoy3ZfUuoveJaTMOhRGwqU7b7qBBqLb6HDcjBuJxDvIV0QQ3LPbb8m6gfabI1yUIHPNeMLzN6hXanynAy+DFUsxaPFQVWXHgUWXuYm20OO7/moTw7B2iLcmoA//mX/lpwKU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767842246; c=relaxed/simple; bh=HSH2cDhcqa8hihNqzM0cmWjWRa6J9Mh9nklD8GnTVc8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=k7dZWxzO2N8vqO6sCqG/1KiQFlENXsMmKz/ljCEa3wH2wf2g1qygAFaWV/zM8WkLJ8h2PNiXsqVIQCHvLiHv7kjR4zMDKFSgK6+h9ky2pYAa7RJlqUqQTJ1S29qOAXti8v6lRQjg5Jat04LQS7YRXIzjy20pVXSnjFZV43kS2rE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=lhFRc36Y; arc=none smtp.client-ip=209.85.214.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="lhFRc36Y" Received: by mail-pl1-f182.google.com with SMTP id d9443c01a7336-2a099233e8dso21193165ad.3 for ; Wed, 07 Jan 2026 19:17:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767842244; x=1768447044; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=CdiOPkebuRw2iRYJsvN/KjHUwH4DMOaF+wqFYzZkeeI=; b=lhFRc36YaOEhMJZpF06mTmuwayWrtFDDX6byf3UYkjBw3lEqrhU/BH7gRrSsJxe3qS 9AtTQWmXzV3EivzR8cvzQQ5iNXvScIuNOb56+r7UGWs7vq2578gvvkGZaFdV6rmRQP7J Id0xV3BO0+NBpOv/MNlGYGGmSqZwfnfkJWf5sq+uAPXnOAWJ/As0hkP8XalEyn/oue8e m5NXmK7CUum4P0aPxYUVVePEKLlam7hpLyLcT2tRiF160bTBF2Kzz1GBoeU74yHwlZTI ETSgzxZwertf1PW9+Dq7LdpdsxTKTzFJuqFLHhlLykYrE4CUQx9W98WUdfUaXumpCb3y O0Jg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767842244; x=1768447044; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=CdiOPkebuRw2iRYJsvN/KjHUwH4DMOaF+wqFYzZkeeI=; b=JwDr/VJ4NclQXpJlQrsjZdQ5gTkUs0T9tpd/kvqVkSFddofb4uY7vTwzZYQTc8S5Xw LwDZPeNz/3ZXHOvD3XWerSFlLrIb81u3WfenXqE4kND8+Avyl7bokTUwBv0WgN/EZsZJ VvChmBe7x1tNR3/8e7iaSbYF0IIf9FJ8ELslV8RBEbh9705mnAM10+5HHofXoDQByrLJ brQ/Jq7AbcIr/Dv7gZXDj+71dG13jTakwpFuqBJ7GfUIyvWiMupXLUP8q+CuwiYqUNjD AciyexypPrN25awnO9bILq9taICYD6PPPLS/YUk3J48p0/KBe8JzcUVwkSpA8EC3Ey3H FH6g== X-Forwarded-Encrypted: i=1; AJvYcCWpjgaysS/M2Rr7ezqAs2FDiWN2wOPYbH9pVoOLJ7CdE9RISc0PXSJiKRLKh7k5gHAAzMKVJjy0SJrSJAk=@vger.kernel.org X-Gm-Message-State: AOJu0YxUoVvGtTZQfIcRLAEBJgPeI/0ivK9PQ/49Lfw+E3sQuzJbm/j9 dw7vmLgTTSy5nSH7132IQdHQk153q+/YNNvIrSyZFcim4skcKeGZqKQJ X-Gm-Gg: AY/fxX6WPeh9bIsaZ1GuBA9od+AKJYZEWdQxZmwGSuv+sYVDhwi+c8+ipY4aHIgoALS XTfBAIqJkrZ/v9tjYm7Fc8xs7fJoCgXJBoiUkVMfrd60iAllDRKq5AJKs9lvn1V73WyPkKPR9H1 PvBGtq+PIemDwK+xOWgYfqlkPqKkC06XjTo7pG0doVroDm+L8ZEsrOpg6QyDnS3U3sVrW4Mgl3m 2JnhsWN3VnJsIBOL1Zir+1pTJLjXZmCoFBtO8v/ORAzBpYsjuB+e8wbXMXWsA+1d4U/9YlFnonJ vjibE5UcaEKBGFeNn/3B0CLvnzgEosaF6DljnDikyRs6VscaWAXjrFIe71YSvwd4fe5Pz4G5sZ5 eoNaqUQZ5COh4qb2AGGR07hiyTOFWVExhed7Ay6CswMLgiI2OwTrJahWKVtaHGsphfL/2G+SZti RvHCDnGIlFIVzPteqUXpeknI3DTd8= X-Google-Smtp-Source: AGHT+IFHwpnuvrFOHyCGVuhHu+rmSokA2SwaPRlM6b2SPtuMKwHghdpOZ5xiMR48M1E38yqC4qytXw== X-Received: by 2002:a17:903:228a:b0:2a0:9a07:f8be with SMTP id d9443c01a7336-2a3ee436040mr42072775ad.22.1767842244426; Wed, 07 Jan 2026 19:17:24 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-819c5de655bsm6134860b3a.60.2026.01.07.19.17.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 07 Jan 2026 19:17:23 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v11 11/11] btf: Refactor the code by calling str_is_empty Date: Thu, 8 Jan 2026 11:16:45 +0800 Message-Id: <20260108031645.1350069-12-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260108031645.1350069-1-dolinux.peng@gmail.com> References: <20260108031645.1350069-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Calling the str_is_empty function to clarify the code and no functional changes are introduced. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 34 +++++++++++++++++----------------- tools/lib/bpf/libbpf.c | 4 ++-- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 9e8911755a79..a10019338ca4 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -2128,7 +2128,7 @@ int btf__add_int(struct btf *btf, const char *name, s= ize_t byte_sz, int encoding int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); /* byte_sz must be power of 2 */ if (!byte_sz || (byte_sz & (byte_sz - 1)) || byte_sz > 16) @@ -2176,7 +2176,7 @@ int btf__add_float(struct btf *btf, const char *name,= size_t byte_sz) int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 /* byte_sz must be one of the explicitly allowed values */ @@ -2231,7 +2231,7 @@ static int btf_add_ref_kind(struct btf *btf, int kind= , const char *name, int ref if (!t) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2308,7 +2308,7 @@ static int btf_add_composite(struct btf *btf, int kin= d, const char *name, __u32 if (!t) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2409,7 +2409,7 @@ int btf__add_field(struct btf *btf, const char *name,= int type_id, if (!m) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2447,7 +2447,7 @@ static int btf_add_enum_common(struct btf *btf, const= char *name, __u32 byte_sz, if (!t) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2505,7 +2505,7 @@ int btf__add_enum_value(struct btf *btf, const char *= name, __s64 value) return libbpf_err(-EINVAL); =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); if (value < INT_MIN || value > UINT_MAX) return libbpf_err(-E2BIG); @@ -2582,7 +2582,7 @@ int btf__add_enum64_value(struct btf *btf, const char= *name, __u64 value) return libbpf_err(-EINVAL); =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 /* decompose and invalidate raw data */ @@ -2622,7 +2622,7 @@ int btf__add_enum64_value(struct btf *btf, const char= *name, __u64 value) */ int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_= kind) { - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 switch (fwd_kind) { @@ -2658,7 +2658,7 @@ int btf__add_fwd(struct btf *btf, const char *name, e= num btf_fwd_kind fwd_kind) */ int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id) { - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 return btf_add_ref_kind(btf, BTF_KIND_TYPEDEF, name, ref_type_id, 0); @@ -2710,7 +2710,7 @@ int btf__add_restrict(struct btf *btf, int ref_type_i= d) */ int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id) { - if (!value || !value[0]) + if (str_is_empty(value)) return libbpf_err(-EINVAL); =20 return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 0); @@ -2727,7 +2727,7 @@ int btf__add_type_tag(struct btf *btf, const char *va= lue, int ref_type_id) */ int btf__add_type_attr(struct btf *btf, const char *value, int ref_type_id) { - if (!value || !value[0]) + if (str_is_empty(value)) return libbpf_err(-EINVAL); =20 return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 1); @@ -2746,7 +2746,7 @@ int btf__add_func(struct btf *btf, const char *name, { int id; =20 - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); if (linkage !=3D BTF_FUNC_STATIC && linkage !=3D BTF_FUNC_GLOBAL && linkage !=3D BTF_FUNC_EXTERN) @@ -2832,7 +2832,7 @@ int btf__add_func_param(struct btf *btf, const char *= name, int type_id) if (!p) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2867,7 +2867,7 @@ int btf__add_var(struct btf *btf, const char *name, i= nt linkage, int type_id) int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); if (linkage !=3D BTF_VAR_STATIC && linkage !=3D BTF_VAR_GLOBAL_ALLOCATED = && linkage !=3D BTF_VAR_GLOBAL_EXTERN) @@ -2916,7 +2916,7 @@ int btf__add_datasec(struct btf *btf, const char *nam= e, __u32 byte_sz) int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 if (btf_ensure_modifiable(btf)) @@ -2993,7 +2993,7 @@ static int btf_add_decl_tag(struct btf *btf, const ch= ar *value, int ref_type_id, struct btf_type *t; int sz, value_off; =20 - if (!value || !value[0] || component_idx < -1) + if (str_is_empty(value) || component_idx < -1) return libbpf_err(-EINVAL); =20 if (validate_type_id(ref_type_id)) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 1a52d818a76c..96c6db972855 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -2904,7 +2904,7 @@ static int bpf_object__init_user_btf_map(struct bpf_o= bject *obj, var_extra =3D btf_var(var); map_name =3D btf__name_by_offset(obj->btf, var->name_off); =20 - if (map_name =3D=3D NULL || map_name[0] =3D=3D '\0') { + if (str_is_empty(map_name)) { pr_warn("map #%d: empty name.\n", var_idx); return -EINVAL; } @@ -4281,7 +4281,7 @@ static int bpf_object__collect_externs(struct bpf_obj= ect *obj) if (!sym_is_extern(sym)) continue; ext_name =3D elf_sym_str(obj, sym->st_name); - if (!ext_name || !ext_name[0]) + if (str_is_empty(ext_name)) continue; =20 ext =3D obj->externs; --=20 2.34.1