From nobody Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f48.google.com (mail-pj1-f48.google.com [209.85.216.48]) (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 EAAE731A815 for ; Thu, 18 Dec 2025 11:31:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057476; cv=none; b=eAAKTL5P5iXXY0eGKRISotil7DioCCcOB7CElj1VQFJoyiWEQ83i6SSEW62GOJ0HfGvMJ1ayFhb2xGdZ8uE0hlfadS08byBlHLnuv2BwMevYYADKRbLv5SzZsa4ZucesE4qKmkLID/w6OoQJGdtQ4QzdXeyBxN4PzaYCVyaiJ8E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057476; c=relaxed/simple; bh=YhgJ9w2mpWwT1l163tIuzQE2TeqsSQofdQK+jrLBJY4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=IW2GAXa/JUHMwIs7QdkCR/rnQV+xj38DMWJCqvBkpi7/jGAOSrbmYKPxKhx4Et65PJdG3ZSI8RZ8DDKI37YDyfapjkIhOm2Kc41/Rnh05B2Ftf+tKhrkBWwFxxNxXKjtn1tSIXAc2TW63LXNgWzc5rZofHNMzsUEUuyAzSvubzA= 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=DhTZH7Tc; arc=none smtp.client-ip=209.85.216.48 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="DhTZH7Tc" Received: by mail-pj1-f48.google.com with SMTP id 98e67ed59e1d1-34c363eb612so538053a91.0 for ; Thu, 18 Dec 2025 03:31:14 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057474; x=1766662274; 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=rwtrPyApu5OKLhu1m0R33rOrz3b0Od/pu+2hCHtjT5A=; b=DhTZH7TcsYXusbjuMLRU21DzRW6BfdD6IK3StTYGMgceGGzem+cwt8I6vl6JUpG4gS f8FWs19Ifhyn9bZlwTVs4DB6T20LLPyv41jC24E7HPBVtau8cY5zrRsTljwZBYpxeONf 8CRGgOmzc+KaczUdR6MT8L2DSZuAHJt7cvj26S3kaNjJAvdBPZP+gAu/tfUsZAPRpdYx MMCZkQju9ffNrAKDWszP20rZh7zuEHmbuWwaiPWQy3DGydNv60VMAZy9TRzX686J7VPr tZhKr7L1kPOJz519xp4MGatBqeG+frJLVmbgxUCsGpTYjYVO+UPt1WEELCyAxvk2DjrK pY/Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057474; x=1766662274; 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=rwtrPyApu5OKLhu1m0R33rOrz3b0Od/pu+2hCHtjT5A=; b=mX3N5sdhqO7+UwLzTL5QWUp6XtrvPA25ud0kvrriDbxq9uGIK0Sl3sOraUbzeKbT+b EpQvcjyc82KBAG0AEGNI7x2ksCDmFeH6yQIbx6uYAFOvvtRsSe9rpgUXIjsSasvBYexN If2Zn5XND5Nn0L0L/NB5F+ZcROacOiJ2GhVpSzvzD7X9s/kM7yyJme9sGBQZEzO1TvSr NqsylVoKo/hjMmWBMF7kBW9dzJFzKlWGfoVMgKiyokcl7FhhE31XL0uODCIDd9WC3Zoj L+GwGhVFUWWlfkR4QocKeEEegJ3GQHe+2FJloSfC+D5S+k6YSwwYxFTbGNd9xIr2YpH3 NJJA== X-Forwarded-Encrypted: i=1; AJvYcCWb6sOW/2Z1t7yHMLc0fGZgOjypFgIyP7vBjcMrqejpA3RhBTTqnqrZWUZrTK4oFs6xBCmAMDcPnXS0Vz4=@vger.kernel.org X-Gm-Message-State: AOJu0Yyu1NVRPbOYT326Wrm/6oSoSLVurwJDhDw4lWHucDN9u86KC0M5 gU+eiTJinOuqF2xpSwCp3BdRIv7i9kIxZ/tn1LKdEVAb8D8STn4bcJnl X-Gm-Gg: AY/fxX7WAs9YXpEvo9qViO2jdqCKtepXRla6JVbTYxt1MFsUvUWJyfAzz5x/casTOTg dQMmWTC5FgLxIGkyjADN0RvPqpkjvMzrWDYVOd+/BBfkpgKn/1UTAmImztje31U8rKG/DMLCRaz fMku1oPXa0JBzGLI7jK9DF5RG8Qh8JfzRk1KKqSyy/Z6EN6vW6N4kEl7oA92SWvof7A9iMSwJhF z7gUWbDZmkeChG0QGYLd07kVTzjcLHZqjOU2aNULyHA2NGGmWjbyFfVvvrVu9w9B54ZQa8B67/0 lePZZuRKVXPwSAFki3SNTqYScpcB/Eqeqgc2HK3zpDV3AhzeGxf2naooGo5RX8HZnHqnu4FPQHw iJvLhJar0fGeivx/tTAdekP7HsZgqUkw1IzL+KmEBSSIXYSbSx00gq6jQ862j42py8bNRd7VvSk sYYn9502jMVvPVih6sM1tMf54WWtg= X-Google-Smtp-Source: AGHT+IFVQfIxDi/VYL5j2krPuLS3c9hBg9Z2+cMwNmaB0ZeP+5lhhD1BnA4xectZ75VE1Cja4zJDGA== X-Received: by 2002:a17:90b:270a:b0:340:b912:536 with SMTP id 98e67ed59e1d1-34abd77f7cbmr16495764a91.31.1766057474127; Thu, 18 Dec 2025 03:31:14 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31: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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 01/13] libbpf: Add BTF permutation support for type reordering Date: Thu, 18 Dec 2025 19:30:39 +0800 Message-Id: <20251218113051.455293-2-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 119 +++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/btf.h | 36 ++++++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 156 insertions(+) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index b136572e889a..ab204ca403dc 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -5887,3 +5887,122 @@ 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; +}; + +/* 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_type_id =3D *type_id; + + /* refer to the base BTF or VOID type */ + if (new_type_id < p->btf->start_id) + return 0; + + if (new_type_id >=3D btf__type_cnt(p->btf)) + return -EINVAL; + + *type_id =3D p->id_map[new_type_id - p->btf->start_id]; + 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 id; + + if (!OPTS_VALID(opts, btf_permute_opts) || id_map_cnt !=3D btf->nr_types) + 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 0; 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; + /* cannot be mapped to the same ID */ + if (order_map[id]) { + err =3D -EINVAL; + goto done; + } + order_map[id] =3D i + btf->start_id; + } + + p.btf =3D btf; + p.id_map =3D id_map; + nt =3D new_types; + for (i =3D 0; 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; 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..5d560571b1b5 100644 --- a/tools/lib/bpf/btf.h +++ b/tools/lib/bpf/btf.h @@ -281,6 +281,42 @@ 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()** performs in-place BTF type rearrangement + * @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 for BTF extension updates + * @return 0 on success, negative error code on failure + * + * **btf__permute()** rearranges BTF types according to the specified ID m= apping. + * The @id_map array defines the new type ID for each original type ID. + * + * @id_map must include all types from ID `start_id` to `btf__type_cnt(btf= ) - 1`. + * @id_map_cnt should be `btf__type_cnt(btf) - start_id` + * The mapping is defined as: `id_map[original_id - start_id] =3D new_id` + * + * For base BTF, its `start_id` is fixed to 1, i.e. the VOID type can + * not be redefined or remapped and its ID is fixed to 0. + * + * For split BTF, its `start_id` can be retrieved by calling + * `btf__type_cnt(btf__base_btf(btf))`. + * + * On error, returns negative error code and sets errno: + * - `-EINVAL`: Invalid parameters or ID mapping (duplicates, out-of-ran= ge) + * - `-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 Fri Dec 19 11:45:21 2025 Received: from mail-pg1-f169.google.com (mail-pg1-f169.google.com [209.85.215.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 9734631A55B for ; Thu, 18 Dec 2025 11:31:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057480; cv=none; b=bya6jJzhmnNA122hZ3Fx41+kMzNcwdVgkg+Sx2q0JQWx27NYreyhdnVG56AzAHkrepnTgIJUnKvbrvEK9iowU9W01/MDlLnpdHs+3/PwfziHaYntZxf4OdVR9w1+HkT7tf0KHIuhEgXicJohgwcEs7nV5wosIkoPtKzaj/+ehMY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057480; c=relaxed/simple; bh=TSISUcMass7QYhAsa8W20cahOnTUG1WjN3lWzxGmgQo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=uERQ6dwyv5NsE3cOj1eKSWvm/Q555JBJZBIma7yL2K5YjGSNZQskGqzJzqHO2Q/ygfO4b3zEPSIXrflCRlB37zc10fGEtvO5bUufY5+rbTgvYkYM44hACvvzIpRNF6FoNeOHzIIcFcftY1z1kR47TFmeocaTOeOYOBDW1uREjig= 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=XDlTrljC; arc=none smtp.client-ip=209.85.215.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="XDlTrljC" Received: by mail-pg1-f169.google.com with SMTP id 41be03b00d2f7-bcfd82f55ebso662163a12.1 for ; Thu, 18 Dec 2025 03:31:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057478; x=1766662278; 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=7zGA7dmrO478eN5aCt6oXnO7sLpKz6iRVJEdrsHBhiU=; b=XDlTrljC2KRybpS8iyjHRCv6wGSQfYUQHRpJGrMrgLV9IU2e9qz+L878wfJmQFPo4a XWjBMuTzyStj0bsiozaug9zhp3ra0AkQgQt7WnuTeXYn2rODcdmGCcmKJWcb1LWuBsXl eI1HTCbRaPjyUtYIOlx2ByXNgFhG/KCB7Mbfx8hn1pj3wdwIaJBQPeSp+VaVImXRCPQV ZyIQwC5lqRujYbexhuJWoo6MTuF8ULF6Bn8JI8X6ZmcP3m2OQNABu/N4RTrUpqR4O+0u SFteRgrU33URCCYNtR81lLDgqyXBkhh3mSOYGytPQeWCXZohKx47F06IlNRJqgOUbpSd GhGw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057478; x=1766662278; 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=7zGA7dmrO478eN5aCt6oXnO7sLpKz6iRVJEdrsHBhiU=; b=TGO+usgflkCmb3KMGKxcfBa1FfejftOJPlH//jyKMO+rEKtPeoI2PnNZbbnVQmAQbu R6PR6E/NRPP9uaLtzZ74AVp17GwmzAVCdNHzBw3OxBNXjf1nc08SIV2tfdcA49Ynm4hW SrjBEMH1wht/forIa3pJ94b4QQt6ZzxWZkxBqIgmru5kxwxxCNxmVfpEUxc3V6H2+mrM M7aMwL1BW+X76YPsIDwtBNfQ11L9wkxOqP4qm+mUU+2FqhgAatCcQFdiHY1bQMzZnOWl GQfLVoVf6pcLK5MB0sHwsh+9JHrm9Rfdn2v17AJobVAXoZECHgKke2523pyyv6z1ZGAe MVNQ== X-Forwarded-Encrypted: i=1; AJvYcCXKNA9nIw4Q1Cg3ZPdq6l1xLZeV0hg3g3S+omX0gG6p4ScF7cdRdcMvqRS+gwxwsVp+v3dmYYyNWSEwGOQ=@vger.kernel.org X-Gm-Message-State: AOJu0Yz/8hGhSNWRf0TVT1Mw1h0J2MF9Muz8i+b/3TljNv9W3KAJoEXE XJCiv342/kztHOUaml9ckIDvIzyO9sJtoBWBomPdUFolq0r9MTnVpk3I X-Gm-Gg: AY/fxX4rAbqXqCV4cDu0cPRLYkHQeYS7fnfpbuvBuITpbW7rTxYF0j+QkjaGrmS4Mtu dgtHW6VMmCC9UDtqvbRGLgD+WZkv4Ou+Dw7NHJhTE25ZlOxk65AMg0fhXpnA805OXpT+SVE5SJt M14lkvJ2OTIPDCyxqeIGTrKDCPFHoAzOP0WrxZPDlhy28adGCg20+ikFQN5yJCy3b+nhVirtrgy jXwWeHaAkIwxNJpC5TW8sUIkPoSvQyksW7zoCIuExsNgqBT1LvoJuiHeeGgqUxMdevxnEOyOEJN uAMhMubFYPlBY0QXUN0EEgC0kLcTqMMy5xEVapcG5uzKXIUdsyO1d5Tj0oqtCPiKEmd0ahyFIcf DURM481mgF/nn97AxH62IdfIIC4xXD1dEv12HwxxRURpZaVprOw079wRGzi05WHTiSqrcwGSjbF prefmPkYteWUdfz+MY/jSHU8HRMRc= X-Google-Smtp-Source: AGHT+IH0xaZFB6RRfqVHaMnqhbLC+IadB2qSroslU8dsdq2c9JIfOOsh9RXbdF8CcYUxyZFIuxV9Ng== X-Received: by 2002:a17:90b:3c10:b0:32e:4716:d551 with SMTP id 98e67ed59e1d1-34e71dbce04mr2351008a91.6.1766057477752; Thu, 18 Dec 2025 03:31:17 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:16 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 02/13] selftests/bpf: Add test cases for btf__permute functionality Date: Thu, 18 Dec 2025 19:30:40 +0800 Message-Id: <20251218113051.455293-3-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- .../selftests/bpf/prog_tests/btf_permute.c | 228 ++++++++++++++++++ 1 file changed, 228 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..9aa71cdf984a --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/btf_permute.c @@ -0,0 +1,228 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 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 work as expected with base BTF */ +static void test_permute_base(void) +{ + struct btf *btf; + __u32 permute_ids[6]; + int start_id =3D 1; + 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[1 - start_id] =3D 4; /* [1] -> [4] */ + permute_ids[2 - start_id] =3D 3; /* [2] -> [3] */ + permute_ids[3 - start_id] =3D 5; /* [3] -> [5] */ + permute_ids[4 - start_id] =3D 1; /* [4] -> [1] */ + permute_ids[5 - start_id] =3D 6; /* [5] -> [6] */ + permute_ids[6 - start_id] =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); + + /* id_map_cnt is invalid */ + permute_ids[1 - start_id] =3D 4; /* [1] -> [4] */ + permute_ids[2 - start_id] =3D 3; /* [2] -> [3] */ + permute_ids[3 - start_id] =3D 5; /* [3] -> [5] */ + permute_ids[4 - start_id] =3D 1; /* [4] -> [1] */ + permute_ids[5 - start_id] =3D 6; /* [5] -> [6] */ + permute_ids[6 - start_id] =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[1 - start_id] =3D 4; + permute_ids[2 - start_id] =3D 4; + permute_ids[3 - start_id] =3D 5; + permute_ids[4 - start_id] =3D 1; + permute_ids[5 - start_id] =3D 6; + permute_ids[6 - start_id] =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[1 - start_id] =3D 4; + permute_ids[2 - start_id] =3D 3; + permute_ids[3 - start_id] =3D 5; + permute_ids[4 - start_id] =3D 1; + permute_ids[5 - start_id] =3D 7; + permute_ids[6 - start_id] =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 work as expected with split BTF */ +static void test_permute_split(void) +{ + struct btf *split_btf =3D NULL, *base_btf =3D NULL; + __u32 permute_ids[4]; + int err; + int 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, 3, 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, 4, NULL); + 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, 4, NULL); + 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 Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f45.google.com (mail-pj1-f45.google.com [209.85.216.45]) (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 0DA88303A07 for ; Thu, 18 Dec 2025 11:31:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057483; cv=none; b=U7U56TWdIz+Wl5Tmcz16tUM6Zt9uJ9wYSsToIwtx4nFYDZnpqyV/P13aBNTYo8bdjuGYS1BDHqNbptunyJsgpt0uLRicBog7nkwvMBzn298tVJMrFptrIHBTaZmovgU+1xlyqN9sX6U3yncxFeqrsBJOvUbTsyDJQVoHMYeqTpM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057483; c=relaxed/simple; bh=5djMaNHVV5H6BwOtjnSRGIWANgTzxyBijzGE08hQiWg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=lb/93+JszO6DuyJfR1GLSvIWzViE2z9geQ9LWMAW7P5nMptEsH4iVk9QvxnpieuBg/KUTst04AOTEkk7w62dqLIHfZ9BaEcZ0MNwfI2JZL+BTnonuo22pOGDMzeRpgM9VzNCPQYZtR6ewOqmgOKSAdthmhmkOoTw18RjFHKni7c= 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=KxbVXIsU; arc=none smtp.client-ip=209.85.216.45 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="KxbVXIsU" Received: by mail-pj1-f45.google.com with SMTP id 98e67ed59e1d1-34c30f0f12eso392324a91.1 for ; Thu, 18 Dec 2025 03:31:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057481; x=1766662281; 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=RJcl/jCRaGXylPBo/Z8OTR3Isxk2SlLcxWMRbR2qK0s=; b=KxbVXIsUZr7ofE6D82+Mt7YdRY8DX08jdHXzzbFX5jwF+YXjPjs+qhfbBNnrNkN4rw znBBwUq6EKJVeKuL9BRPyc8OpVg6EX64nKXLD/AuA7dy+uq/OVBLumWnKFzT/JV2xL8h tY+op4UZEsv4lIPh85qTj0aDvRbIWII64QLNAZTx4+JuTY8fKaXvqClzLtb8AgDqLTaI wi/cpT+eAvVuoixAyR1YSHlO532RHcwXQfb457z8aYmc1KbWVKenDeUgISZX4XFRRXDm h366qBZYP+C9xY8BtZK5CAZ6ikcO9bhM5jqTGr+hrnc/oid8gdQHwzxiwUJDnsX736Ej a+Kg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057481; x=1766662281; 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=RJcl/jCRaGXylPBo/Z8OTR3Isxk2SlLcxWMRbR2qK0s=; b=YtVfw+Cuu2uptnW6D6pEB67WthgAv1+alVdKzzUMYw30kuCgrUunvgXg+J+bFsPiND KOYMgftFrRtBoPK0qHx1yfK6E8tzwYukvF3PeRLbK7kiGpfFNB3nu2WGxK9+XNadl20n 03c/HGJMZSlRRmDH/C5pBwgDFTGayR9t5KhiS7fa0eLHi07A2GR8kGh6w4r2A2MWNxi/ pZEraF8YIAVKRa31nW7fSvWAPVN9HSLd5Z46vX6jvFiak+jRqb+Y1ulcw1gHmY0NDo2l ldozZuyIpA0MR6vvtf7Q79lKRrDDVUGGZ9NyQ2inSqQuWdEzm0HCuXg+obtiU3ElQHWo ZR/Q== X-Forwarded-Encrypted: i=1; AJvYcCWfxrLph/BiJ3yjIbLQoGQQMAkSIqbRPIQ7AR+HDpu7DLdDQfkPkUvq7ZFdwkIZPi0jyi39y7xqjIXzKmE=@vger.kernel.org X-Gm-Message-State: AOJu0Yz6Pz//HdVejPQh+m5xDPpT+CA4+jSDexH/HS6naTNWl2D3qdcn ozeY4PA6ejHp/tlnD6N74RlN868g0+nIm0ue+KM+EyMWD4D2nn8zyzuH X-Gm-Gg: AY/fxX5/AuYbbxj2zDi6ksBqxe9QW9GtbcW1iFblgMzppx2lrQnLxedrmL+gwKKMtgE o5aGGPxF9nX30p6WoJpFzAfBKrPQrSMtJKe/ugUzxctHPyX3hcJ1HLqY+AI4/5Wx44mwMGZf2xD tghO6hkjaybinWHfiqCLKVtOx+qiw16z/A19LSpyCFpT0akfrSq/oFKBV0VrK7vx9b4D5nPnwpY YJ86gu1xCUKCZoYr1S5xqVfZy6iWOhTvfwo+Y3EUZfnOjWWnuS4LSalYe7oBW/A6mxLqHwORGcF Sj/wMuvzbf4wznPDdHzvdZaNTNb6nANXkBFHrgNVMiXb7NL4vwrScF6GGNQ9tc6f6rrLLWlwbQ/ LNXvB23aR3ItuHpeUjxqy3zCJl5fmm/vlTOur3OFk5iW9lLC18Ea0XjiOpijOlOe1WctIA4NDxk iILIELO1XNa5yF3A8vSWSG3BKOlbE= X-Google-Smtp-Source: AGHT+IEHum/i2me2oAGVYypygRW5Lr0FdJN1whl+oC0tykabf313G6Z1GvEaaE3TTKvu/tiyDmVWLQ== X-Received: by 2002:a17:90b:2fc8:b0:340:be4d:a718 with SMTP id 98e67ed59e1d1-34abd7e76c9mr20430778a91.7.1766057481332; Thu, 18 Dec 2025 03:31:21 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31: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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 03/13] tools/resolve_btfids: Support BTF sorting feature Date: Thu, 18 Dec 2025 19:30:41 +0800 Message-Id: <20251218113051.455293-4-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- tools/bpf/resolve_btfids/main.c | 68 +++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/mai= n.c index 3e88dc862d87..659de35748ec 100644 --- a/tools/bpf/resolve_btfids/main.c +++ b/tools/bpf/resolve_btfids/main.c @@ -848,6 +848,71 @@ 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 1, id; + + if (btf__base_btf(btf)) + start_id =3D btf__type_cnt(btf__base_btf(btf)); + nr_types =3D btf__type_cnt(btf) - start_id; + if (nr_types < 2) + goto out; + + 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, nr_types, 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 int btf2btf(struct object *obj) +{ + return sort_btf_by_name(obj->btf); +} + 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); @@ -906,6 +971,9 @@ int main(int argc, const char **argv) if (load_btf(&obj)) goto out; =20 + if (btf2btf(&obj)) + goto out; + if (elf_collect(&obj)) goto out; =20 --=20 2.34.1 From nobody Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f54.google.com (mail-pj1-f54.google.com [209.85.216.54]) (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 E999831A55B for ; Thu, 18 Dec 2025 11:31:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057488; cv=none; b=WwgfC/SYnWwUd3kvQaHx5uLeVfYteYW8C/GSE/HEOBmlqx7e5aTDCcsjVjcqr2NMxwMGyXBjJzVGR/X9gwxnvpXReAtEBQviMp1eZ/9D8a7r7DK3wGCJqksU091hOCF60k8iFa5QSR6GqyZ0nTGXGf8/E+HepZWZW2Tf9csbWsI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057488; c=relaxed/simple; bh=KxIYguLp8SeaWQeT350BLkiIGq16X2SfqmN1sIZpyfc=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=b329IhsWu0T/89y9BOhGxsbKX+DJFGPml+SLAlttALDRmh2JrDPMPFMXk8d6qjZnLzGMe3O3pKhPipsVYtnzK+FfjFUMNbCDWgP6/hWC86gEv0PhQU57oco52abgyNqNRPg0tZ6wHz9WZdycXo//qhUpJG7vCYzVqc90uQWbWUs= 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=JgZQyF3f; arc=none smtp.client-ip=209.85.216.54 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="JgZQyF3f" Received: by mail-pj1-f54.google.com with SMTP id 98e67ed59e1d1-34c21417781so567722a91.3 for ; Thu, 18 Dec 2025 03:31:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057485; x=1766662285; 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=HWTU7YkYZsUgcIcDiO47eImJA4XqxyXz+O3bx1BiSAI=; b=JgZQyF3fxE4Ww+8kagYtHQzz5EnMPdE0L+pEyP+Ntyy4ahwQXUlOzZlt+m5YoreW2F ryLnsq2yOjryOE6+81HRuTwDUVypgcmiwMRhf7/s5hPjbBaAJfG9BbDfrboeO9zblo6T 0ONpx+Q2zQqzJ+Lq4q10bXa6Bq1Gyzz5SqHWu4HA/NJ/5mrTh7Yjo0XcmPs6VQ1H7L1Y MT7Ju1Ib/JWpTmqVo6nkbOOAf8DwSKXzTl//1fcY/GbNntCaITGB4M/6B4eUeqFA4rRd EUojXJ8rTQnt10bC4tX+VPk5qmr0rMqsKBfOrWjbPTfQywSW7fabdxpTKABdmR0vGmfQ 6UaQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057485; x=1766662285; 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=HWTU7YkYZsUgcIcDiO47eImJA4XqxyXz+O3bx1BiSAI=; b=MFujYAWjTxoVGOgFG7U7v28vuFtgeP+3TqytRJwOQOtr7hFRpxYGQYrEh1T0Cz58sn QN8kK3y+rS9lHzpmNTOb9ntuGUiYV0sqfLc9vi5SFcFc9YfP2u68LYAbrkbzZld3qWnS F1YSe42oIf+fu3d+gP2d8jhiGLqzzbSi/JeWLK3aYxM45pdO/OTBiQezJs1qlx8HGClw hoKQzjWcExHjD3krO9oA6byqSomVaslqFoFsfKZHOJSWtul7c7oCmdp5xy5rrqQe9hc9 BRAYIFpWPdELX6aSaxz94xrWfEMibJAAqEEGmt70FuMgHZfcGXBiiC0ZQxZ0aVi2g5rE anvw== X-Forwarded-Encrypted: i=1; AJvYcCXMaRikk0rC1D4SeQQ/THigY8wyFlVXK6k5QczSWC16LkjRpNUMpdaD5MuDOWSBsaEDopsdQD2+0vkVs1I=@vger.kernel.org X-Gm-Message-State: AOJu0YxUtYnk2pBMnB7sko3Btf0bBYsCJO+Ykngyxgs28mA/9fi3CrVn E/0MYDjH0NVGstvDQ5fvzj2/iR9eAeJpNsdX0vBiSlAyAtHCAFOe5xxO X-Gm-Gg: AY/fxX6vN8703+D/NBbRbpYI/DYzIzEu7KGKeTe4mWWLXjAcuUG1j6Nbe/th9lbvkGT z1dkvLGvvfwRapPJLsMZzbnu17zdX6EGec5VzyUHtjQOc2JPv9yJ5HC2YagfsNzRo6olTFtFwCM Pqh/XGlgaBoZ+aVE/oR7KL8keXkAIFSxcvmdaK5ZaUl8uz6SDbRdmb6jMzqBKifaFedHuBwhuxN nvwek8CdAla7IsWKcWbJDWuJJZEtZDiVaN6oN21YJddLGzey2nC8OLCSGDL8xmjrxsQfSPqHn13 UdgaAaGN1EnjfVajFicC9DY3bMHVJVfxW16uqkuk8qbJW4CbNPlNPb5DvQfEyMxulFo/CcI+5dQ C6J4EXagA+Kbo9wgWuDsgxnNYt7W2w8CAd6wJArFJgIHxJSclnDDzpCYqI4jO6NJnxkIa64bO/8 F+zq3eItIYzvsHBD8M8L4qcptb1QU= X-Google-Smtp-Source: AGHT+IG1ZcmxKj9qrvybSbwP+Nq1gJqIR5zkosJ2g86tGdi05X+iVwrfRUtxZQJU9Q4Rbw4XJYSBnA== X-Received: by 2002:a17:90b:48c4:b0:34c:a35d:de16 with SMTP id 98e67ed59e1d1-34ca35de0bamr11166928a91.11.1766057484998; Thu, 18 Dec 2025 03:31:24 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31: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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 04/13] libbpf: Optimize type lookup with binary search for sorted BTF Date: Thu, 18 Dec 2025 19:30:42 +0800 Message-Id: <20251218113051.455293-5-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 103 ++++++++++++++++++++++++++++++++++---------- 1 file changed, 80 insertions(+), 23 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index ab204ca403dc..2facb57d7e5f 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 sorted_start_id; /* if not NULL, points to the base BTF on top of which the current * split BTF is based */ @@ -897,46 +899,98 @@ 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_by_name_bsearch(const struct btf *btf, const char *n= ame, + __s32 start_id, __s32 end_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, lmost =3D -ENOENT; + int ret; + + l =3D start_id; + r =3D end_id; + 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); + ret =3D strcmp(tname, name); + if (ret < 0) { + l =3D m + 1; + } else { + if (ret =3D=3D 0) + lmost =3D m; + r =3D m - 1; + } } =20 - return libbpf_err(-ENOENT); + return lmost; } =20 static __s32 btf_find_by_name_kind(const struct btf *btf, int start_id, const char *type_name, __u32 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->sorted_start_id > 0 && type_name[0]) { + __s32 end_id =3D btf__type_cnt(btf) - 1; + + /* skip anonymous types */ + start_id =3D max(start_id, btf->sorted_start_id); + idx =3D btf_find_by_name_bsearch(btf, type_name, start_id, end_id); + if (unlikely(idx < 0)) + return libbpf_err(-ENOENT); + + if (unlikely(kind =3D=3D -1)) + return idx; + + t =3D btf_type_by_id(btf, idx); + if (likely(BTF_INFO_KIND(t->info) =3D=3D kind)) + return idx; + + for (idx++; idx <=3D end_id; 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 (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 !=3D -1 && 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 +1060,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->sorted_start_id =3D 0; =20 if (base_btf) { btf->base_btf =3D base_btf; @@ -1057,6 +1112,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->sorted_start_id =3D 0; =20 if (base_btf) { btf->base_btf =3D base_btf; @@ -1715,6 +1771,7 @@ static void btf_invalidate_raw_data(struct btf *btf) free(btf->raw_data_swapped); btf->raw_data_swapped =3D NULL; } + btf->sorted_start_id =3D 0; } =20 /* Ensure BTF is ready to be modified (by splitting into a three memory --=20 2.34.1 From nobody Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f48.google.com (mail-pj1-f48.google.com [209.85.216.48]) (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 9EAE02DEA83 for ; Thu, 18 Dec 2025 11:31:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057491; cv=none; b=pLklHOnvNaYQGgI471UIfRMHDqQC0TZPDpH06xYG7942POTS1YxOvu8Fy/D5EhlPaogU+2CqBmQYzXJiw6tqotjOrAMFq8CcuZey7W4FNoprsUKNbsgtXX8PjVgBm4l+hyw/Hqgq8eM3628TmdnLIt7oG17X+pn9pM27Hcs1Zk4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057491; c=relaxed/simple; bh=MJCWCSf7+gBpXj5+kFXAWTCAHljmZxeXXmtQQ0SlYV0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=F2z9HqRyj7E5ph2WvDw+E48SYyZ8aHgaVC48SupVlEt6tgunOmK4uFluAyFbN/+MONTYus6rkIDzvnuNh7h6U/VhJxhAZmr+h0+59EBRQmlfatBLuXX+GRS2W7Xhz0PNJ2/0lc7Qp4gvICjPf4ndlTCnhKAQobI/i2sycbEWaMY= 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=CjKWi73M; arc=none smtp.client-ip=209.85.216.48 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="CjKWi73M" Received: by mail-pj1-f48.google.com with SMTP id 98e67ed59e1d1-34b75f7a134so430805a91.0 for ; Thu, 18 Dec 2025 03:31:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057489; x=1766662289; 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=Ks0ORR4UPC8cdozXOqcEU9Y4B28RYyjPhBeqsdEUJ5I=; b=CjKWi73MyCirHZ/TZ35RsBZHeAYeuuJlAYN9ooDeK0Qd0Zsc92agPJpK8fLW0VLPII 3elBw03wbgyAkLWHaZhLP7jijXuNZce2nHlNx+YngnRRqDtgeJsovdvITJsccYMyxC0P zwlCJC8aelUf5+Om8mQGR1sH5PsFVx0a/s7NeyH0U3kpeVJGHXrrhTEMHIXFG/myK9K4 HrvZ1AHCTHPOe1sCYB9o2RZdafVAd/+mOu1zWGiBFL4aDhweK7NhIPE+Ln74/0DeycTC EHUYCBezmhu2Y7g+pMPnqtPtOJiSx+1U5GAUHajG5OVxDPMebMlRc0QC9HcXwBGRtjEM nvhQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057489; x=1766662289; 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=Ks0ORR4UPC8cdozXOqcEU9Y4B28RYyjPhBeqsdEUJ5I=; b=Vp/f3qtL31A6AxK6cba+nBT0wslN+7Cs7AcAaG0uELMT7/+75MvaIgI8Lb2vcGQzpu Y+Xmke6ab1xCjwRSvPdGzF7T9+KV32qy7rtuq+O2maKHNtBWhuvSt9yzz/U6VmyV3r/V fEb45i1Xw9XZmnnBLpzd8xQNZmpXgYBWv6C/joBli0Xd2X2t0JqOZ+6ricMbvRKyfI+E Hrbb+Rc2YSOgrqDdrnj6msmaZ2/zFgH3ZaXJXYlqVFbZVxsJG0gdytrnr5SPhbanWsOC r+GDkq5AUInSB7dv/76Yz36q81rN+mLHdlhXlAVvFnHRmvC/CysOk2KTm/fA38oHAL6g 0GgQ== X-Forwarded-Encrypted: i=1; AJvYcCU7V1BMnVCYXCwJxmltvQsf3opR7UYwuf/r3y0IsQen7TYnyxybd0zDeJJUtFrh86zAxHa74HNTEK0ni+U=@vger.kernel.org X-Gm-Message-State: AOJu0YwMMGjDhlMtX2YSxvVFn5shxGx/7le+tiN2Qcbj+MAXO9KqtNOj YM7f4EcWxFSjksXOA9RkJXPfBFmT2zOmuNxNY8XwYRa8iOYm6ET2AAB7 X-Gm-Gg: AY/fxX5qkO6twZ2ONv75+5eW+75cz2+gM7/bvB3xUliZpakZaIqn/0qRbW42EX95C9q D8zKIVpU+qy4UVVJSLS8xonvPwzhbWktvdrs7Mz8e77i64NyMZ/0sfcqnAsaEw1DyRU/HoZhJxa h1+tKET1Y4ue6O0oLGUboh5M6yNYtlBHEKjZGWmWojFcuIprDk20OtrEIVdz7ifzF3+mZtdufYQ 1l+DMWRu1smMEVFmx21lLEB5lXzEXYc9rtfFpEoawjIqGARFE9Qic66DtclHfOi/7ClTyazc2aJ upz7XeIBuPpQZnZ9ZSJci+hJl/w341vRbaGTjwTzLwxvWP7FQ0nb7GEKVchCdy9gmbaIcfhLL5Q 6R+wY92wmUbNmX3+iRpv6DJ7BViHpBAFoAxnfA9t52uADU3eX72P+DE6igxVGn4dSPeMf4qghDL JyART1NaJs8lnOD6Zo78H+p5xKvhw= X-Google-Smtp-Source: AGHT+IEySBV+KCTgdrjD3x8MpUwLOxfCP11MntDaFD4SAgq/+i2aamQwMQYKJtgPg09lbDTVxxjigw== X-Received: by 2002:a17:90b:3912:b0:343:d70e:bef0 with SMTP id 98e67ed59e1d1-34abd8488c6mr18834187a91.21.1766057488610; Thu, 18 Dec 2025 03:31:28 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:27 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 05/13] libbpf: Verify BTF Sorting Date: Thu, 18 Dec 2025 19:30:43 +0800 Message-Id: <20251218113051.455293-6-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 2facb57d7e5f..c63d46b7d74b 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -899,6 +899,46 @@ int btf__resolve_type(const struct btf *btf, __u32 typ= e_id) return type_id; } =20 +/* + * Assuming that types are sorted by name in ascending order. + */ +static int btf_compare_type_names(__u32 *a, __u32 *b, const struct btf *bt= f) +{ + struct btf_type *ta =3D btf_type_by_id(btf, *a); + struct btf_type *tb =3D btf_type_by_id(btf, *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 void btf_check_sorted(struct btf *btf) +{ + const struct btf_type *t; + __u32 i, k, n; + __u32 sorted_start_id; + + if (btf->nr_types < 2) + return; + + sorted_start_id =3D 0; + n =3D btf__type_cnt(btf); + for (i =3D btf->start_id; i < n; i++) { + k =3D i + 1; + if (k < n && btf_compare_type_names(&i, &k, btf) > 0) + return; + if (sorted_start_id =3D=3D 0) { + t =3D btf_type_by_id(btf, i); + if (t->name_off) + sorted_start_id =3D i; + } + } + + if (sorted_start_id) + btf->sorted_start_id =3D sorted_start_id; +} + static __s32 btf_find_by_name_bsearch(const struct btf *btf, const char *n= ame, __s32 start_id, __s32 end_id) { @@ -1147,6 +1187,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 Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f46.google.com (mail-pj1-f46.google.com [209.85.216.46]) (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 CE79C31AAAD for ; Thu, 18 Dec 2025 11:31:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057495; cv=none; b=mCuVkeyV+9KUJmzqF+xlxNhyiw7yUpOU6eBNeuCnnMVSIsbGvHXbDz95GaghhlTr7PSGSNxMNVbNG3hwyHEi5kudHTIqx6gdZI4tM3pKrDPYe09Qvu0eNHTJMG56S5VkqUYFGjAh0S8NDguf1AJLzBkBQXVF7gqLBgedCKyrt54= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057495; c=relaxed/simple; bh=+zqsDHnuHDnyqQtOgMwqka0OTnj+dnOtXNTtEUn01ew=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=bn2NgiNmlZScAclOci04k2SteFY+ATS0RgcxhvN4dcIbtOC5KoBMspf1Qb/VYN4aTUz/u0tKSeuQzgMGTSq/rS3XeBd6qbHVn9K8ib+K0VtyhxKlt2yoJgaQtHxErG5qCwet6/AfAS3OLrWiEO96j7Vz9cmx/SqyhonwOo1iJUo= 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=HgPeQGOV; arc=none smtp.client-ip=209.85.216.46 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="HgPeQGOV" Received: by mail-pj1-f46.google.com with SMTP id 98e67ed59e1d1-34abc7da414so492075a91.0 for ; Thu, 18 Dec 2025 03:31:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057492; x=1766662292; 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=uewsaipU9OXUmad7hbnTZa38j0aK0kfvkQvJ5cwCJxk=; b=HgPeQGOVK9jteed7DN8wI2baXQb0GnzZ43CsSJLpjQPQYLHSOyspZOgFg4DfbmPoHF II1VixcOS+9GBK0d1F3lCaZ6vcMZ1EDijLYcLvE9g0ssor4xApOzzpKWkLWbATSe5BsW 1aLh6paWQat6cZaD2ZbYa27Bf1EhL++J/YzQMNbGXJSMjMILfwDYqK3INdZktl/5KAJw iZbxxc3Muxv4mWp/3iEao5tOfGO7VPPJPflO+bBpbZvNnqHYaQGncWhFk+60Nhnn3Ncb YI1Xl712GcqmzA04e1DlvPc4v+dXz8LHgog1veXCuwIjl4oxpU9KZ6h2aVYAwbrq5KZf E3mw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057492; x=1766662292; 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=uewsaipU9OXUmad7hbnTZa38j0aK0kfvkQvJ5cwCJxk=; b=WQXaSjwqCcDtPys1AGZZvB/33mdyCa8HDzU/w2aVwNU28j0KKax6B5kMowzvoJ0Qu6 cc8joKeHtEYgvGYqaEA4xQOJ8Y/wQRYGksfhnbQPpQVI2dRVXmsqdSxfqfG6L+l2CGbr n5jMIvRScaTcFcazsN9XFeHfwJmkWY+uqGGKCtwH9dLvMg2kzCgCOqO2oDdhSFqC4+Mz FWdxnCCMLQaytAn/OyuxUXqMGESymLCxrDnzt8IhSvIdDZUk3ag+3eMQuUFNeXeTDwka b3pwQBHFSpmBs/x5U9wChyN0+ihQALS14p/GZhkdX+XMmnvxiVBbIu5TvdMOoXcEfnsa mI1w== X-Forwarded-Encrypted: i=1; AJvYcCU6WinEsxy+6ZaitzWWbfhWLG5tBDHAT2847qqnSwkaE2VlhIsMnWLmD4bVXJk7pfT0z+eAjxPOj0aKBxw=@vger.kernel.org X-Gm-Message-State: AOJu0YxAp3761HEE1yEvaooYfJBMDG8g4mqJgsiU2l36FVPtamXDcizI SuSwt8HCzHARWT2P/MDq2t6Z6g20IO8s68K3nc8+3LJTBZsWFpPaUNt/ X-Gm-Gg: AY/fxX6V3AKeT6oYVN0OmnsWnDIPXUxg/LmqopaNPDAuvbElgXYK4f93X/9Errhrcy9 AW+J/FK6ugDkSlzS2qqtjAq9J9AQBeEFDlXfYTM1NVeBq7ci/OEEf5VgJFpc/AHJcwQ3uNEAivw h+9bB9XbBWOjs2LLjFAORYtSWRAXN07TjJk/+K55YmmoK2kO8Ll+0HbnSm/n7+1Ajrr0h7N80Pk afqG2V7k09vYObrxiLUMLV37ABjzOxBOaTGurmFUerwYGGbu7mR+Sfikeg+YHEO79SNBOPS7j/5 Rurzz9WAN1ygJXq+LGdIDD57Js8Tbtl3HBqkeFL9k99ATbpWsgtdBUc3gDp4WdjYhDfB2+m2If8 dmCzn+Dbuz89yLHKCMWT/ejlhbTC+dxG6he3sw7wc6AEPHLThncecVUp76+TjOZ5RwMEVa7uhws x72gbRmVd8mSqm80foK7Cx8gJUeMQ= X-Google-Smtp-Source: AGHT+IELClayAaqS0OadqjKtH4cOtXpKc/dZ0z9qgGpxsVMemuOw5iYbdyYOvOxgDADYhzL2w3p6cA== X-Received: by 2002:a17:90b:5111:b0:34a:adf1:677d with SMTP id 98e67ed59e1d1-34abd6d88abmr17202318a91.9.1766057492127; Thu, 18 Dec 2025 03:31:32 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:31 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 06/13] btf: Optimize type lookup with binary search Date: Thu, 18 Dec 2025 19:30:44 +0800 Message-Id: <20251218113051.455293-7-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- kernel/bpf/btf.c | 85 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 76 insertions(+), 9 deletions(-) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 0de8fc8a0e0b..0394f0c8ef74 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 sorted_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,79 @@ u32 btf_nr_types(const struct btf *btf) return total; } =20 +static s32 btf_find_by_name_bsearch(const struct btf *btf, const char *nam= e, + s32 start_id, s32 end_id) +{ + const struct btf_type *t; + const char *tname; + s32 l, r, m, lmost =3D -ENOENT; + int ret; + + l =3D start_id; + r =3D end_id; + 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); + ret =3D strcmp(tname, name); + if (ret < 0) { + l =3D m + 1; + } else { + if (ret =3D=3D 0) + lmost =3D m; + r =3D m - 1; + } + } + + return lmost; +} + 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->sorted_start_id > 0 && name[0]) { + /* skip anonymous types */ + s32 start_id =3D btf->sorted_start_id; + s32 end_id =3D btf_nr_types(btf) - 1; + + idx =3D btf_find_by_name_bsearch(btf, name, start_id, end_id); + if (idx < 0) + return -ENOENT; + + t =3D btf_type_by_id(btf, idx); + if (BTF_INFO_KIND(t->info) =3D=3D kind) + return idx; + + for (idx++; idx <=3D end_id; 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 +5855,7 @@ static struct btf *btf_parse(const union bpf_attr *at= tr, bpfptr_t uattr, u32 uat goto errout; } env->btf =3D btf; + btf->sorted_start_id =3D 0; =20 data =3D kvmalloc(attr->btf_size, GFP_KERNEL | __GFP_NOWARN); if (!data) { @@ -6210,6 +6275,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->sorted_start_id =3D 0; snprintf(btf->name, sizeof(btf->name), "%s", name); =20 err =3D btf_parse_hdr(env); @@ -6327,6 +6393,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->sorted_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 Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f46.google.com (mail-pj1-f46.google.com [209.85.216.46]) (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 63048303A07 for ; Thu, 18 Dec 2025 11:31:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057498; cv=none; b=ApvQAOR12LA9tMTbvGrIMY3CyHTWtlb9DqpScSaAew3VTlOYExjZx2eMlFvW6NzDJdB02yIf7bv6/qj3PnEsbGOV+bTFwv/TZIri88UGpqHe/UCggipzR3aNlW5cPnXOjZixO/y+MjP5Da+ycUMfuY/WOBaM3ie/63qaU6AF74k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057498; c=relaxed/simple; bh=KvaJlRaiUe8MkAKXREkrMgArNu7n4FxcgCEAlQluXAg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=FNDDqY+h6iTmKHBSqHrEfDeaJGGE5Tpe05+Z3FsLYu+tRFlGBBhlX7tujDHAWEzh+PyjoHkuabYmZMD4CHcicZ4+xxZQuY1+nhbD2KYR5Gvy+RqIbZRUMKl+7bsZn0ztasow6L67IMHkydu5U4RC7WaSV8YD79u/e9yXrbGpWi4= 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=WASuQfaY; arc=none smtp.client-ip=209.85.216.46 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="WASuQfaY" Received: by mail-pj1-f46.google.com with SMTP id 98e67ed59e1d1-34ca40c1213so459512a91.0 for ; Thu, 18 Dec 2025 03:31:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057495; x=1766662295; 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=/9wcZC55VqhhbPSAYuLEBFuNZUpMeWvJuY6oSbLgmgg=; b=WASuQfaY20GsSj3jQzEUzF4td6Z9F0w2pz+IhqUr3HUOL6AYPlKtBqwEdh0MmhtnPs bkxYpWKFoYzuw5DJy7p1gYv9phTkSpr62aPzfHhC+7HlYnLoK+1lGdfPPXc+k2t92BSr 6ZQc/J+Did3outr/Bs21TSiboUp/loJqiz3WKJ1bRCm6TkUA8QzMEUzc5uUZnQR32SXw t0FlZGc6gJJSSmLyZkPq60BRN9RkD3dX5BiGyEZsNWgPlTZPKgy8pLmMByV3nmDMTrze T1eIQfT+9KG/ht+AsLMf3cV8b1Bm4w0BRcFXaIu6QKE/W1r2eakjO/zOhKQDyuG/tDLp Z+/g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057495; x=1766662295; 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=/9wcZC55VqhhbPSAYuLEBFuNZUpMeWvJuY6oSbLgmgg=; b=Q6keZ+7EOwMd/BUVTSlt9wsFwUHQ13UW0ofY0pTCdbtcf0U/AXBJKirWTOUBDbHvSQ fm7Pal8X6ZlDqo5qkRCRqPq1OrGRXWpjhzsMIkVKm0BQ8PKM+t5Kh9HDXoYS7qL5FBBU ft01l1T3iMZAbAuRJz84lwsUBpgcQNUQJj20CKKTpvB+XO4WrRXClpN1O/6xoH8WZGWB +S8ljYdjZFJ/vbIIqXAaN21ONdNv9hRwXpdfDabAq2DYe03dqEsaXU4fW9hFPx807uaH 5WBrJBZ+B9M5b539IkrexUCuxty2rABZoMnJq9mz/+NAIkwCzg0xoxnFnNPpILeCMJ7r DcPQ== X-Forwarded-Encrypted: i=1; AJvYcCXHmf4wWwxkFbe4qw7YRQNn6sK2xFvjlvPl6/oeN7pVNaMUUjCLOZ51GIE7wtj/YmkZJxR7yehaEp1Qe2Y=@vger.kernel.org X-Gm-Message-State: AOJu0Yy3lv2eNOyP76oqxmocBr/i3lyhTwFCdQ9SZZzA2xxUvw9OM2rJ hl9p2/OjTrQ0fLTnTmiz6NxRxpfo7pPPmOKq/Ape2hhwKz1Z67VQNKkc X-Gm-Gg: AY/fxX4PORs39naHssnVm3KBPaQ9znSEV83kRDbFMpwNzNmxViq88m/42AN/GFGo+Qn lDVCnKJVNoUhbIqr6JC/AZD35xbp0w7Kr5eiEUrrDci3fpUZVQbtVGMPLRR4XuVfD4I0uKbLyEz wGOVsStSeNoJ4Z4X6Elsuwlj9sWMd6EOvJNUqU2RvyIcUJ8jSFBop6wcEh1CdMwCbSatsFTzx9i ioj5hu8xAXP19AGHC44RsVm0m3lJsBvM/e23166L6QgBl2nXxFYoe7ygC1fbO2ggILsSdzhOxn6 t0kXUT/UPJR2ilfnnhTPwqHuuaNnVazwbnn8G9jkFqslVaT2QqWhfFCVtNebAK4zCW+jPG/rKI7 JJ6Y9xwAU5JfLoxj5qxXP9Hf00aMi6iIfTWZd7dTexgbfxBGeTg0V6uYKc23hlmdmezsxKZQPKm NAGrGvDYeY6KEOtNcOrLIWLgnE9Aw= X-Google-Smtp-Source: AGHT+IH6ci0tvt9FeyZRLVqlq2jq6tgQFC7Z53yosxENZOca7GsIes90pwCI3Ro/ideYOeQxsqwwwg== X-Received: by 2002:a17:90b:5109:b0:340:c4dc:4b8b with SMTP id 98e67ed59e1d1-34abe3feccbmr19217290a91.10.1766057495472; Thu, 18 Dec 2025 03:31:35 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:34 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 07/13] btf: Verify BTF Sorting Date: Thu, 18 Dec 2025 19:30:45 +0800 Message-Id: <20251218113051.455293-8-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin --- kernel/bpf/btf.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 0394f0c8ef74..a9e2345558c0 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -550,6 +550,60 @@ u32 btf_nr_types(const struct btf *btf) return total; } =20 +/* + * Assuming that types are sorted by name in ascending order. + */ +static int btf_compare_type_names(u32 *a, u32 *b, const struct btf *btf) +{ + const struct btf_type *ta =3D btf_type_by_id(btf, *a); + const struct btf_type *tb =3D btf_type_by_id(btf, *b); + const char *na, *nb; + + na =3D btf_name_by_offset(btf, ta->name_off); + nb =3D btf_name_by_offset(btf, tb->name_off); + return strcmp(na, nb); +} + +/* Note that vmlinux and kernel module BTFs are always sorted + * during the building phase. + */ +static void btf_check_sorted(struct btf *btf) +{ + const struct btf_type *t; + u32 sorted_start_id; + u32 i, n, k; + + if (btf_is_kernel(btf) && !btf_is_module(btf)) { + for (i =3D btf_start_id(btf); i < n; i++) { + t =3D btf_type_by_id(btf, i); + if (t->name_off) { + btf->sorted_start_id =3D i; + return; + } + } + } + + if (btf->nr_types < 2) + return; + + sorted_start_id =3D 0; + n =3D btf_nr_types(btf); + for (i =3D btf_start_id(btf); i < n; i++) { + k =3D i + 1; + if (k < n && btf_compare_type_names(&i, &k, btf) > 0) + return; + + if (sorted_start_id =3D=3D 0) { + t =3D btf_type_by_id(btf, i); + if (t->name_off) + sorted_start_id =3D i; + } + } + + if (sorted_start_id) + btf->sorted_start_id =3D sorted_start_id; +} + static s32 btf_find_by_name_bsearch(const struct btf *btf, const char *nam= e, s32 start_id, s32 end_id) { @@ -6296,6 +6350,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; @@ -6430,6 +6485,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 Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f45.google.com (mail-pj1-f45.google.com [209.85.216.45]) (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 7508131A55B for ; Thu, 18 Dec 2025 11:31:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057505; cv=none; b=WuJoXKhGuFosSrjv6/eMBbqJWe7PDA1eOOb9qPhNkjhM0zybsvvDJ0r1iQAfvVNbdkCpS8cvnmTsxCuxa8H1oXboE7GxVzJPIjvyszFyslysBovy5o9EdpfzVTCG57OslzGPrMJdJt0Gz9s3urXx474nDOCNTKQCxW4opzI4bWM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057505; c=relaxed/simple; bh=e4PdXHzqE2jWb1Mz7VBs2Ivn5mRVqnf4USlw0IL3LQk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=k4Oac7su6XUriXwM6V9Vd6YHkyhe4dEcPO9wPfEB+CQ4wmyZFKb051AzAxS3cJHst3jRNhC6cqoZvvDxslo/LenYd5GGZts2KPXj8LO/VIa27wwMQl99N87v6nA3lqJ8eRrerrO4WsfEH/InOz87DsMGDlz9+AFBIN2kDuJGNGc= 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=mD2iNS3L; arc=none smtp.client-ip=209.85.216.45 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="mD2iNS3L" Received: by mail-pj1-f45.google.com with SMTP id 98e67ed59e1d1-34c868b197eso589414a91.2 for ; Thu, 18 Dec 2025 03:31:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057500; x=1766662300; 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=q4ua/Mfoorz93gkg4ZzzsoaKq2Zva6tuuEtR6k0T5nY=; b=mD2iNS3L6DSfQszNGOnft+OpQeMiBf8RjgEF6yLadDyH/X/nhRQnG5y97VtqoqaH5S i1dI9eN2LkySO1T3v09QHRyoshQKBGLFuoPUKr+7wgpo/949sUj04Zb7vxlE6Q3guqm9 +9oax0k8piB7thXUoOKZK53K94tkPXTB5IRs6BPZ4hYaGVrDVX9/QvHUMtFHbmqzGJlr 4YjF8WqrgN08ocYK15LY++hPLXEUPPYMdZEtP0Y/amrADs6rdeSpVSLBozDtfBRwGvXd YIPEy+insnFpxr6r5XXGjiFkPtE68lGLYWy2z+vf2tdevxopKwutbKPOr2oy1579KcwY 5EWw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057500; x=1766662300; 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=q4ua/Mfoorz93gkg4ZzzsoaKq2Zva6tuuEtR6k0T5nY=; b=tHWGbOsBtHf+YpIA4tyGYFyGcIVphPq2HavEoQOhfosuHOexSwEx2lAIPGqAbrsEkp 09yCwKl6mBaMt9L9N4YMQML7wU0h5N/db938b2gdZqX6URxdYZ6zjSczuH8Cn1Fg+dCQ zoQVFJm4iowoXmsxP6OWQK7VyhOOI6Nfn8bQIMPfY5xtWymxTOF7Zl3HxH0R6YrZsehl 707SZabpXBDbsCpnXEubBZlkCo2gpvW5cZQ2O57QmUB0VoXdKsZGUTukeBBskbzWNXrg NBTLhUKo3q3BJTYo/eB7tqh/geoptIh6Svm1WuZ0MzgxjTY8kdxDgLee4/QvgE1JG8CY hAog== X-Forwarded-Encrypted: i=1; AJvYcCX5qLTHRkWV366IkUyBTTN1kFJDsU0Z8ibU0zbsHvj9TC/Aw9ddhLXgh64jxDSVM+ksxpfPNirqMuPo4Do=@vger.kernel.org X-Gm-Message-State: AOJu0YyIzaVMTkAM/Epq7XzOhd/su9C5BU6tP+z/wnHsf8eWWaolySTR AA0HQFa9AVoV0FczXhvZ7Cmxp9Hnvq5+N/3ccnIbyinq+IW7mtG2s67h X-Gm-Gg: AY/fxX4h6TzwWUMmPndL0yibTyN71ctbojnYoD/biSuFlsOKkFXuR6IMs5UoCTdDvg1 ioz3WZLAtuEORmYI55YDXMnw7ZNfLQm7OUROKzwNoPdF8nCseNtS0T/M+uxNuFtAs9m0Oh41Y9O oVizLPmLKaftCWwbmAtUkSonF7bsDaM9keXKQVsZggnB4utqfxf85JVNxtXaEUaH5NtZXEfJA/Y v22gyuQkk+q9Juhuk1kAAsCmzbIPUGGZF7HTHJNjSA3VoPepF4IX+lFkHk4won83COJk5TxlTUh ox9smjNssa0eYd0cETdCozFy/6K2YnS8OBQX32cTZS8UgNzU0WgwRPc6/8izpcmIT8Jhb0r9yeV t6Ob/iVJnw7oeMsC+R6wLij1479IdkpMLOanUGlFxkDaL8S6O6UWHJFMRF/e6d8TDw3LRVgp0jT YaptfJ78drMUDuvzDGQDgVCf7+gGU= X-Google-Smtp-Source: AGHT+IHwEc3GSxPWRabZgzS1RVEcFDoMz8zwnEifDJsenEmzvMA0MJNr47Yymxi+cbS6e1uISU046Q== X-Received: by 2002:a17:90b:1dc6:b0:32d:db5b:7636 with SMTP id 98e67ed59e1d1-34abd7853bcmr18909720a91.27.1766057499551; Thu, 18 Dec 2025 03:31:39 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:38 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 08/13] bpf: Skip anonymous types in type lookup for performance Date: Thu, 18 Dec 2025 19:30:46 +0800 Message-Id: <20251218113051.455293-9-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- include/linux/btf.h | 1 + kernel/bpf/btf.c | 24 ++++++++++++++++++++---- kernel/bpf/verifier.c | 7 +------ 3 files changed, 22 insertions(+), 10 deletions(-) diff --git a/include/linux/btf.h b/include/linux/btf.h index f06976ffb63f..2d28f2b22ae5 100644 --- a/include/linux/btf.h +++ b/include/linux/btf.h @@ -220,6 +220,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_sorted_start_id(const struct btf *btf); 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 a9e2345558c0..3aeb4f00cbfe 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -550,6 +550,11 @@ u32 btf_nr_types(const struct btf *btf) return total; } =20 +u32 btf_sorted_start_id(const struct btf *btf) +{ + return btf->sorted_start_id ?: (btf->start_id ?: 1); +} + /* * Assuming that types are sorted by name in ascending order. */ @@ -3540,9 +3545,14 @@ const char *btf_find_decl_tag_value(const struct btf= *btf, const struct btf_type { const char *value =3D NULL; const struct btf_type *t; + const struct btf *base_btf =3D btf; int len, id; =20 - id =3D btf_find_next_decl_tag(btf, pt, comp_idx, tag_key, 0); + while (base_btf->base_btf) + base_btf =3D base_btf->base_btf; + + id =3D btf_find_next_decl_tag(btf, pt, comp_idx, tag_key, + btf_sorted_start_id(base_btf) - 1); if (id < 0) return ERR_PTR(id); =20 @@ -7787,6 +7797,7 @@ int btf_prepare_func_args(struct bpf_verifier_env *en= v, int subprog) struct bpf_prog *prog =3D env->prog; enum bpf_prog_type prog_type =3D prog->type; struct btf *btf =3D prog->aux->btf; + struct btf *base_btf; const struct btf_param *args; const struct btf_type *t, *ref_t, *fn_t; u32 i, nargs, btf_id; @@ -7852,12 +7863,17 @@ int btf_prepare_func_args(struct bpf_verifier_env *= env, int subprog) tname); return -EINVAL; } + + base_btf =3D btf; + while (base_btf->base_btf) + base_btf =3D base_btf->base_btf; + /* 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_sorted_start_id(base_btf) - 1; =20 /* 'arg:' decl_tag takes precedence over derivation of * register type from BTF type itself @@ -9338,7 +9354,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_sorted_start_id(main_bt= f)); if (IS_ERR(cands)) return ERR_CAST(cands); =20 @@ -9370,7 +9386,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_sorted_start_id(mod_btf= )); 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 d6b8a77fbe3b..1a9da59d8589 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -20651,12 +20651,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_sorted_start_id(btf); 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 Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f52.google.com (mail-pj1-f52.google.com [209.85.216.52]) (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 EED543002D7 for ; Thu, 18 Dec 2025 11:31:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057506; cv=none; b=Mj3/t03ZisW5+uasLMDm6PkqvxiwkQZ724MiCYpfGNOXbR+p6Ghx3F1lCkpEa/BFkeH2j/dhJ/hcEH1f4CWMkbtxBRUnZWW3/8i83aKsrB+KGBCgMIBHrIV6CcAy12+pIsJ83D96fZrc4M/rIyaI73wtgciiNEg8DYafm5d1OXQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057506; c=relaxed/simple; bh=kR3XC690eMOuMmS4XzQCFJEtC3/vg9Jkc3VHJRTqe6g=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=fKiCXAzGJvERViNfxK7Z0oXMjO9yUEIXq1Sn7fcgNPmKOasrW7QYPcdeKKW/wkps19Vy3/mNlY4b2Y35EXkzq9caZz4Av/gmq6nTEvdedrZpTIArXP2ePKVtrBo61b6WgFHdlCN0i7ht07zsF3eARj50dp5028wSObVdDqtjHyI= 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=G60kUXrX; arc=none smtp.client-ip=209.85.216.52 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="G60kUXrX" Received: by mail-pj1-f52.google.com with SMTP id 98e67ed59e1d1-34a4078f669so531081a91.1 for ; Thu, 18 Dec 2025 03:31:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057504; x=1766662304; 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=4yc18LXj38KHjY/6u3XKUquuVm27qsoM7d9pTeGO7lI=; b=G60kUXrXcmVipswR7w2fdJfda5pJZTc+Clvd/KoaVc+Zj2mVtjpEtKk10T9RHvDg5p JcS0r+OyhcWz567NRcqsbRJRgvJW84ZCLcFG95pMvE6VgxtOp5TwStB10u5w50+gt2j7 h5XXmkGAZ7Losd995OQzeTKCWy6b4I70H9aMFt0jF/EQMlCCkhdvBbMojy8SEY2VJb6e YyWpOenq+2w/8KMBvMr5afWVvMefC1TFsF1J21j4LIE72Ic9vET4re35rfVF1aKXDxKH TCLg/pCFZSDDWExNCh/51t2X9mE6zfQrqx8/n+Zl8ic7AkvtvAI7r3HGKJVCVHD/5Bwe jRMw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057504; x=1766662304; 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=4yc18LXj38KHjY/6u3XKUquuVm27qsoM7d9pTeGO7lI=; b=pbT0jclzfGyj4ul+gZGafJ1zBNP9PWaIPbUgOUHOPoVV+fKCatnCvpMLQnowBHz/++ O7NhNOxT1p4dAHFxOy0K8i3c/nyz3hUz2i2n6tfkHLOqh2K1MKASRMrioN0HlFUHNCrg 6RDMX5BXqBHiODyusLgq6/3cFNJDw1wPX3+s/PgLXEQu8ry0wtbchLov6vvzuwTPwLpf pg3TThnLInfMfXbyWWcj2gvKe63l+DFEnG5Jjj03Xw4bVvIFulTeulcZQeraiM/x0tqZ sFO0ltQC9Qe79IqLVkih3JGaQHXNM4nLDoal2g0m9pGLI3UG38+0UaVkmWh/r3bU+qbN CPBg== X-Forwarded-Encrypted: i=1; AJvYcCXu2UQBjwwG3eW3qSO/Vv90OqsdGk6T1vXMX74KPhTjPsyE1GP80KJvdcE7Zmxi8r/aF2pkjx+gUECD1AE=@vger.kernel.org X-Gm-Message-State: AOJu0YyVjuww/HM+XZUMSZIPoNT4KtqjRB0Zs4y1PohPIafFK9K5Gyep CMTkNST70N8ZcXEyLtmHltCAsU35uDkLNivaCAA7bdqqolDdEouyYOx7 X-Gm-Gg: AY/fxX7atG38zw9zBrHU2Ww7cMlr5ApCK+/9slrk8xLmwwEYNAqI6nDzTXuMmAmRWUQ OEt/OB9SUX5Z+MSDvtZ4dxqh3G0mTkqiSUKA7rJl5VoNBKevARh15QsmwDfXhK/LwBJqvmoxtVP Z2eHrMwoTa63J3S/8gT2TwZQoinmpItrv1MSKLzPvF+RMW43GuxdeNE+ORcsi1u1yGiMo7ZQUyG Pfnf/UiBOAMW7Su5ILCbDcvUpjhdRWyZ2mwJwX387HmPaywx++sBP4BpuJQ74eYFhDbbr/8MOK5 PtpTVAmyMQ09VkNqlkw7CoybKCjug5Vanmj18uV+0gdsp4OANWkfPjoIwGuaFER3sRx/LF+XbJC p5HMcHXCi39M2zpOeObFgFpNaoCm8r4DwXtC6yp9lU/WhfT/ycKZa1FD7F+mQr5ryvEj3Bjnm+e Ln0zhxBR9gghrtcTEkvqcw+hkVTp4= X-Google-Smtp-Source: AGHT+IE+OfV+nTK8EffSxIOlsTNKb3YIEVrp51owobhDCMyYJ7ysroRbW6Lt6cR2ARHL8vPSGTW1CA== X-Received: by 2002:a17:90b:2749:b0:33b:a906:e40 with SMTP id 98e67ed59e1d1-34abd6cc250mr16692648a91.2.1766057504184; Thu, 18 Dec 2025 03:31:44 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:41 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 09/13] bpf: Optimize the performance of find_bpffs_btf_enums Date: Thu, 18 Dec 2025 19:30:47 +0800 Message-Id: <20251218113051.455293-10-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Eduard Zingerman --- kernel/bpf/inode.c | 42 +++++++++++++++++++----------------------- 1 file changed, 19 insertions(+), 23 deletions(-) diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c index 9f866a010dad..050fde1cf211 100644 --- a/kernel/bpf/inode.c +++ b/kernel/bpf/inode.c @@ -600,10 +600,18 @@ 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,30 +623,18 @@ 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; + 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) + goto out; =20 - 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; - - if (info->cmd_t && info->map_t && info->prog_t && info->attach_t) - return 0; + t =3D btf_type_by_id(btf, id); + *btf_enums[i].type =3D t; } =20 + return 0; +out: return -ESRCH; } =20 --=20 2.34.1 From nobody Fri Dec 19 11:45:21 2025 Received: from mail-pg1-f196.google.com (mail-pg1-f196.google.com [209.85.215.196]) (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 6B1D931A55B for ; Thu, 18 Dec 2025 11:31:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.196 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057511; cv=none; b=BNP0QhCe/JJF3KIxvbsLcIzAQ9Aw0bcxUYU9ZwVTBHcJwCyOZOo2a88IHPKaIgXC2AN5KxusWlKXwNDv4nwY9YsTR+z4Ui4A6yUdG4hjIJf2U1gUZvDbqf6Iadc+t698kvyAs0ZLt0VzB1VjNgyWP3hmr2g3jyQTcpMoQGv/O5o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057511; c=relaxed/simple; bh=DwgNPmg1syV4ccxDgDErKTfXFZCSlTEFvUEnf2vv7ew=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=TFPwALwgcDsCMgXm1vte4+4hIOTMaICIOP0I+Euk0Xtt9+CtjnGIPCAS22AUALp6X3oWQc3lRLjvCpkiEkCKz9zFG2qU3oYZCbd0hWUoGkn+0aQsSxabps9+uHYIOi1S9hWw8mY6x5AXAeRx1/bP5Kl5lsD2r8khiZp7HZqrNwQ= 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=aqmaXMaH; arc=none smtp.client-ip=209.85.215.196 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="aqmaXMaH" Received: by mail-pg1-f196.google.com with SMTP id 41be03b00d2f7-bbf2c3eccc9so696700a12.0 for ; Thu, 18 Dec 2025 03:31:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057508; x=1766662308; 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=G5jDu9JTVmvSq4bzhcZPmH/8lJ37vJ5Z3Y7dPoVKyM4=; b=aqmaXMaHSswLZKLRsOVxIsf00iQ2z4CL6vjxYey3DL6BFsmTe+ivhb6+qJTWtzYIPg FttBzmG67QgtRnfD2aqSxWybdy3up1dyoeOmcJnWmPglG8jdMlo98SHbS/QAp3wlX2ZC uxs29Ka+ioZUUk8K6mVoDCSI2r6T9Ltjy5Y/KGaQPpuTKJ+oWcy1I7xCaKKRbsrfIMnY CgNtemW8DtZ+jGv0rLfgS6QfZ/lX/mBARlXfVd7GdQSTUoJa23JZWaBL8qihQmZKa8RD pt7zQ00apuAItOe3xCDCLXEOR2TqVoCmF1IhDcLI5PqP7ppibGQeVX7ZgeWFIYifha1q Bnpg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057508; x=1766662308; 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=G5jDu9JTVmvSq4bzhcZPmH/8lJ37vJ5Z3Y7dPoVKyM4=; b=AtWwRXy1IMGiou4qTYjpZM3pm1osRRfOzDCaG4xCJeD8O0BY0+g9t3PAOCp3UY7c/y SwZBHjTwPoPr4+FPC/WAt/gycWsvWD7A5xI1XExLSUn1Vn1m+oRNaEp3M3EcFji7e2fk jm7CWCjWfCwALm+WETdNtHRP0qk4iPAYEYnk1gUgM1z+7acJmW5DHEBgX0wdMHGFbKUT lTLg+fGMpqyFrtVt4TL4U9EXoPPhlBGLHSdhjyAqwvuIuQw+1CmFx7/CpLz67dJt3rZd QBsfoaEhyZg02+Bss04BlEF24k52MeKDKRazrK0hgcaEBuXFBsXc63wqcuhMMnCCMkLL /y3Q== X-Forwarded-Encrypted: i=1; AJvYcCVGI1V7AS296w55DRrd84A2oJ/Sjoxvxa7qTk7YrSMXC3QRuywnYVdXIPW7hxVFm6c+vy0L09lRqbhQhrE=@vger.kernel.org X-Gm-Message-State: AOJu0YyoJKKbUw9ewokcMQ/HzloT0E1zSsVwpTR4Oc02cN73fvrZsaZQ hP5lX3QZcPDxVwUZ2iVpPbi34OcDWeeyMhiKkhXj/o46/w6NvquLI0xw X-Gm-Gg: AY/fxX71YGo4dxq38R4sL0p1KZpjQN3PUUwFpEdthHbSJ46YKA6mUxhzLx9vgnNjKko ShMxhjfPIIbUMkfbwfPj0sKoh29hethCE0PUBlmnOAMTW6obFxIecZ32JB3+Z/4KFZziTcX8jYu dY8fqEUICyd5W0ugpG7X7BQLhoPi97o2eeBJoGf58pW2Ft0JDSMTv33M9kk4YF9BDxSMn7mcJL+ gO1ZoCX74zSBItKA0UBIitx5S8Jm/El8FKfuzcU9BoktjkUaCgx85m0/vciWVqbNwV783P2hj9n Qq6LU6qXpdgU16JK6Wv6HT0Fc4iQApRvE9Z1H/VloBW2TxvPyaH7hF/z6qgRfyi08JuIL/5PSTo qeI548y8+IKJMPKnDpNC7fSqn1Lo4N7P/meDhsxnWrZtFAz8JmCualUN+UuoItR6VX285NSGe60 0GQ/H1LLHZl5XdJLNJsGi2Xb2myVU= X-Google-Smtp-Source: AGHT+IGih1pBcpxyYWbt8JB2iczqZCbsKJU3zx0Wg3zNFIeEbu8D+9YIAJPSqoKisqtyqihlEVUPVg== X-Received: by 2002:a17:90b:2251:b0:343:6a63:85d5 with SMTP id 98e67ed59e1d1-34e71e0f8dbmr2312918a91.16.1766057508457; Thu, 18 Dec 2025 03:31:48 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:46 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 10/13] libbpf: Optimize the performance of determine_ptr_size Date: Thu, 18 Dec 2025 19:30:48 +0800 Message-Id: <20251218113051.455293-11-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin Acked-by: Andrii Nakryiko Acked-by: Eduard Zingerman --- 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 c63d46b7d74b..b5b0898d033d 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 Fri Dec 19 11:45:21 2025 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 5FFBE31D730 for ; Thu, 18 Dec 2025 11:31:53 +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=1766057516; cv=none; b=pR3+4/C/guQBsyqB0W9JDckMkpSchvd68JL97ItL+729Q0DKB6XWapNfy61Zk3uOTdGI9wyssZBx7mkAvf6rVhsMl4Zzk8RBRJRc4Ip+34eBiIpWVoipZe3sHDDciqI1Dzb1x747cqLFtQiwvDpbbWvOx+HdKKs8EHuCKMxJ4TE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057516; c=relaxed/simple; bh=J4/QGROYYa7Djiw/eaQ3GNdqZT48kiErWfvGDV8/Tys=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Nf1nKyniuwHXxtcxwGh3vCmEyv0WXXyyxsSKW6QSOrVNljbvxrsrfLQKr3k5RgXJpHydwOJPrPq0D428eX1R3QIq+R737icwxqKfqp+Tvc069T3iFA6L+vwyk3hqTtKnLdd2DatVe4aJus1TE7/yhQK/XZw0bbFyITX8SI+hYOU= 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=em2YnYJ8; 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="em2YnYJ8" Received: by mail-pl1-f182.google.com with SMTP id d9443c01a7336-29f2676bb21so6452085ad.0 for ; Thu, 18 Dec 2025 03:31:53 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057513; x=1766662313; 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=pRe1/jA95O9SPOHNbjC7U56aVV5DEJyjPqrggmgz7zU=; b=em2YnYJ8V3pZmmGPkkl4NzltyZJll8nv55OtLzfW1m/jKEAnr1p46GfnmvJsXOiQG7 GGUSsHTGGq3uL8lDLUAmtHmiZUsQNYGKp0ljKyJpKrvUb0BdV3IcvM/IonAodzAey39h YEiArb2tTDWu0VIgKLaN4QC4WlgY7tcn9yz15b/AEQvuWt7kNSF3Z76CSedsZWRKGopt sKPtYXJQUU3KE3B/Yn8+uSf1X0xEscjR0+tTNSykFiARlgyT/bM5iz6K23z9yM7azCYB EUrePjjsRF1UG7QeLItalvSNScqpZ6uPjAJvgP/lzxm48L33jYFesqpnxZsGDpulAngR 5i2w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057513; x=1766662313; 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=pRe1/jA95O9SPOHNbjC7U56aVV5DEJyjPqrggmgz7zU=; b=ZLd5BEVt48YOTjrF9Ieergwan8gq4pfKN7nlZLy90a41ZhPgAcdA2FUECNB+bbyJgA Oxgl9k9FxBbhgnmdwMQEMvhfJUbjNAhFwYdoYXA6h1/zAnLOTxGB7Vy3vUM1ZKgwCzpc PJBbwbzfR3u0Ql+bEMGS358WVSTThEE8jB/NZQodMDVFv8jXDLtuQJhptweAptrzv2SH lRWyii1Vm0lahK49/xo4w5ORGNtQgK3xXMs+Rhle+uAmoAgQaQ03rjZA4xg0OAmhm0j7 fbIUPTTGH/LNf1cww2fxyhxB3k6/qy7xVRtzrIcq3U76pnRuF9ik6mdRzE5fsmUkb8J5 QAFA== X-Forwarded-Encrypted: i=1; AJvYcCUvP03BLpU1SOrrFsWuVangLRhJtAy8Y9n6OToOTS6nu7ag3y4xqzjUsOCpy5C7jFpXXcPwI+IWAAIvvHk=@vger.kernel.org X-Gm-Message-State: AOJu0YxypaId9rtyTC8q191n5BWWzTGmgNn/NJ04H0XaNiF46Dl0crkQ uwovbE/c5YOVtJToPr5Fwcs/McrydDcJRHtcoNr+pejAYzRUGiL4fI3l X-Gm-Gg: AY/fxX7p80cP0Rb63uC6Ct+DSiC4tTbSomGBdaPHgZOx62cCKqOge2+H9RkTTxZTHbv Q4VsO+SLGeZtPulhSu1YKi7JKQVs7MTP3zsBOF+CAXC/Y9M3lvN68poi9LNHfhluIWQ7OY3nyEv 8tW7h+/EIZbYpu8R3yoq0fuS2xoTW0jFY+S/jv+M42om3lQm8d3X2oeHF5Hd4O0XRqSg+qFsC7f xIY9qSE75ORUIPXnFVE1ljTiznzFF9qo+PNCDsHRxmaVJ2YHj1d7kEI42ghpnFjxoJlyggPdbUS VyC5wOSP+hnbZe43C4OZ6oir92WJ6KhT9AdSOEeQ/x8WIQwG4FxnP/b6qe2vBgBEkG12Pn6PwfR HreQ0/P8+TJnJOdoaYVt9yEN1f1Z+YNiE5VOofc7bya88BbJIxPco3a5bM9KzcA7oECmj18QuCT ggrFh35saJiMv2lameYf6XN1rbLLs= X-Google-Smtp-Source: AGHT+IGkvlwioTi7DAg22F7nuqKXStAbmWJyhw8eWuCQ/KK9iLrazpre9epMzNPRQ+MW4qWMbDul4g== X-Received: by 2002:a17:902:dac2:b0:2a0:be59:10cc with SMTP id d9443c01a7336-2a0be5919e2mr145918815ad.32.1766057512655; Thu, 18 Dec 2025 03:31:52 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:50 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 11/13] libbpf: Add btf_is_sorted and btf_sorted_start_id helpers to refactor the code Date: Thu, 18 Dec 2025 19:30:49 +0800 Message-Id: <20251218113051.455293-12-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin Introduce two new helper functions 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: pengdonglin --- tools/lib/bpf/btf.c | 14 ++++++++++++-- tools/lib/bpf/libbpf_internal.h | 2 ++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index b5b0898d033d..571b72bd90b5 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -626,6 +626,16 @@ const struct btf *btf__base_btf(const struct btf *btf) return btf->base_btf; } =20 +int btf_sorted_start_id(const struct btf *btf) +{ + return btf->sorted_start_id; +} + +bool btf_is_sorted(const struct btf *btf) +{ + return btf->sorted_start_id > 0; +} + /* internal helper returning non-const pointer to a type */ struct btf_type *btf_type_by_id(const struct btf *btf, __u32 type_id) { @@ -976,11 +986,11 @@ static __s32 btf_find_by_name_kind(const struct btf *= btf, int start_id, if (kind =3D=3D BTF_KIND_UNKN || strcmp(type_name, "void") =3D=3D 0) return 0; =20 - if (btf->sorted_start_id > 0 && type_name[0]) { + if (btf_is_sorted(btf) && type_name[0]) { __s32 end_id =3D btf__type_cnt(btf) - 1; =20 /* skip anonymous types */ - start_id =3D max(start_id, btf->sorted_start_id); + start_id =3D max(start_id, btf_sorted_start_id(btf)); idx =3D btf_find_by_name_bsearch(btf, type_name, start_id, end_id); if (unlikely(idx < 0)) return libbpf_err(-ENOENT); diff --git a/tools/lib/bpf/libbpf_internal.h b/tools/lib/bpf/libbpf_interna= l.h index fc59b21b51b5..95e6848396b4 100644 --- a/tools/lib/bpf/libbpf_internal.h +++ b/tools/lib/bpf/libbpf_internal.h @@ -250,6 +250,8 @@ const struct btf_type *skip_mods_and_typedefs(const str= uct btf *btf, __u32 id, _ const struct btf_header *btf_header(const struct btf *btf); void btf_set_base_btf(struct btf *btf, const struct btf *base_btf); int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **id_m= ap); +int btf_sorted_start_id(const struct btf *btf); +bool btf_is_sorted(const struct btf *btf); =20 static inline enum btf_func_linkage btf_func_linkage(const struct btf_type= *t) { --=20 2.34.1 From nobody Fri Dec 19 11:45:21 2025 Received: from mail-pj1-f48.google.com (mail-pj1-f48.google.com [209.85.216.48]) (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 464DB28D8F1 for ; Thu, 18 Dec 2025 11:31:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057520; cv=none; b=qSSQijOTe5f+etRjaqaP7nj5xLXhL5YfbnovkQXJZtjqSkFFmkSTXUUWDwJeb980MPhlaPtXeyYp7sGJU1sc0WR2YsF9btccqgSriZZL9oTHESQCNnFsxsB3IhQo6O3y/v8EfzetIDoUv9UYJjN/uwypoLLyu2hr8POCD7MA6aM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057520; c=relaxed/simple; bh=Xz/BsCSSmQa5e7pDSsHdn/GiF1mTaug38aVPZfosH/Q=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=mvZilbUVPBSeXYrHu+xNSE/Q1kUViW9NQNvvhbltxzVq+PkItd71kfi6Q7LoAU2IKsz0jAnfi/PbLjtRqwNnkur3dL8GNvFY4O1O0pijfPmvz1Fj7QASgJ+Dtw5gp3Ue6SrKvFqix7b6H+tPYDX9n/vYr52XneUczBK7j55nLxA= 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=LY/Fe4mg; arc=none smtp.client-ip=209.85.216.48 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="LY/Fe4mg" Received: by mail-pj1-f48.google.com with SMTP id 98e67ed59e1d1-34ccb7ad166so497117a91.2 for ; Thu, 18 Dec 2025 03:31:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057517; x=1766662317; 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=VNF+WOX4XvmwzIr3rrsrWRWd9nyzJm0XMyZcg2aIieE=; b=LY/Fe4mgCNoINE4wEpLj8biWs6Qx6RjgXsqLuVnpxAWSubFMW4fDirCITafLGIF1uG 750kT5YWArhhRUXyAy6XXkRP3dyO1Q5AeTf7Us+XhgtgnMby8StJqUmZZrJHZLaJceV9 HkEKUk2QWNiW1zzdvxwXqB6s5ETkPyymUJzgDMhOuyL6F/9+3SHmRpoqZli9ufMSvGPF 5IKIvxzAm9ddFRFYfri7KxYdswLbthoxbRbJlKEYRWOZk7AhGl3rZALz14CcZFkI2TpK +kIZXj9RO+mia52YP2dIK5Dn82sJk4zArTbFQTJYg+dDTKY48t6XDiCLYwzs4SFpr1ZS DG6Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057517; x=1766662317; 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=VNF+WOX4XvmwzIr3rrsrWRWd9nyzJm0XMyZcg2aIieE=; b=nCx05AvA2wkTmHQy8Z07hZ+aVqGdB+zCyBpaAyH0h4iYKjxUSKzE97xiuasx3qfYV+ fU9Zmy9PGHF0wYbJDqOwMQ6YIJ/k45uRv4N52KBI4O055/bSXr3/9qLdY2z9vNxyWNdZ unALVHkQIGJjyNyHv/ZsJuaDVLOorPWouzUHAPb4/HN8SijzVGCg60Y57hGF+YRomh2f iUzAcLmgYvegVTa4a63nx9upHS/ITQbH6LlVuokP+M4ivHikM+a0f5u80WDbZLaSivS3 2AXBYpS3ICz+6d7EXafn4du5TohED0kw+yi5dSI/eyrSeMh5JvWNNQi2pmLyd0yMcqGG jmOg== X-Forwarded-Encrypted: i=1; AJvYcCVLZ6nETi1puhqAmqcnB+PFH1f5P4esq1lTC/2sVwLzJkDzXw144OkUQrOxqLKUqxjG3I+zap5s3FNX/6Q=@vger.kernel.org X-Gm-Message-State: AOJu0YyJcNCZr3RF0Ai+6KnrGql+x3QDPo0KfDbjMJ2KQyBoUoK6mV3S NSCTA6KXNUrt7KalBkTSeHMfntWPoGSrC7mJzzyljVfL8eO+EjdPiiBl X-Gm-Gg: AY/fxX5zJ+s17MpDaUkeAhA4RDmnpx49CGmGDAHiFCZxumCxhpu5XRAKQLUYDEcjOK7 7BBGpNx3oKbCIN6bbGhfTjh4soygLxIjbhNo96Mi/vORwpgUhoTrkiT36Vzv2gdjRkuqynkwp55 vB1OVz5A7YYG2ZPoHQVJ0sckG12eSiAigMfVsJM6+Jwijz5TKiJl6ZBonxI+akexkkFszgNQrWb s0jZNko/fApIiBWLWpWI1NdNI+WvLZuNDTqqqahlTQO02GRaB0IhY/gmrOmJayzYXNVz6jXUDSH XXF5MDbmKEXfYIZaMxfFIwa4YJBIGWCjSJQ8pXbaCO4Oka+9U9+H6ZWnWHOVEKweRJlPq38Txqh EOuvsbp06FytnYUKaT1RLuRgpnSk+p/IjMWdZuII+DIEWXZWKs2YIz+TXZQ5sXjiZIfbNwd/RIh DupAaiqsoxUpszuZ3SOmV5NYF3Sbg= X-Google-Smtp-Source: AGHT+IHcDTMoUHNvfws/gUKjgPf5T3pYkIAfD1uJ/fbcBHxliu5JD6ybAq5O78KNN+/aLzQkupcwew== X-Received: by 2002:a17:90b:270a:b0:340:b912:536 with SMTP id 98e67ed59e1d1-34abd77f7cbmr16497126a91.31.1766057517399; Thu, 18 Dec 2025 03:31:57 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31: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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 12/13] btf: Add btf_is_sorted to refactor the code Date: Thu, 18 Dec 2025 19:30:50 +0800 Message-Id: <20251218113051.455293-13-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin Introduce a new helper 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: pengdonglin --- include/linux/btf.h | 1 + kernel/bpf/btf.c | 9 +++++++-- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/include/linux/btf.h b/include/linux/btf.h index 2d28f2b22ae5..947ed2abf632 100644 --- a/include/linux/btf.h +++ b/include/linux/btf.h @@ -221,6 +221,7 @@ 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_sorted_start_id(const struct btf *btf); +bool btf_is_sorted(const struct btf *btf); 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 3aeb4f00cbfe..0f20887a6f02 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -555,6 +555,11 @@ u32 btf_sorted_start_id(const struct btf *btf) return btf->sorted_start_id ?: (btf->start_id ?: 1); } =20 +bool btf_is_sorted(const struct btf *btf) +{ + return btf->sorted_start_id > 0; +} + /* * Assuming that types are sorted by name in ascending order. */ @@ -649,9 +654,9 @@ s32 btf_find_by_name_kind(const struct btf *btf, const = char *name, u8 kind) return idx; } =20 - if (btf->sorted_start_id > 0 && name[0]) { + if (btf_is_sorted(btf) && name[0]) { /* skip anonymous types */ - s32 start_id =3D btf->sorted_start_id; + s32 start_id =3D btf_sorted_start_id(btf); s32 end_id =3D btf_nr_types(btf) - 1; =20 idx =3D btf_find_by_name_bsearch(btf, name, start_id, end_id); --=20 2.34.1 From nobody Fri Dec 19 11:45:21 2025 Received: from mail-pl1-f172.google.com (mail-pl1-f172.google.com [209.85.214.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 AE23C31C56D for ; Thu, 18 Dec 2025 11:32:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057526; cv=none; b=haqrcxFEBif5hxqDGK8GRdaJwCTVSziGYx+SPP5gHYbfRYodnFDmnf9NTu9TlQ/sEM8uJ8kwX7cuDmxbSVW5Web7J0c6oMgFxZH0a9SQtBY+r4kLDXgJaPs0nqUD6KjZ095OjnsYTILn5h4kVe9PLIiCYsZbxJ6fs0JfZxBus1Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1766057526; c=relaxed/simple; bh=HHZvtaPk3U38UuT89ZBstQ1qdjSdFHcPh8SIw5XW6RI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=sYOm1K3dAW7H5v9hi86dra4hWhdl0ptC8WSGG+ByXHkMs4TmW5Z8KBdf4CxuAs1rxxhWjJvsMpJOyxL8dEXW0mqu2UmCOxcdIonmKjX9ifYO8LhFyC7vElpnhkN6rIwG8mqXU0eUck/+JCK4Kxi88wR89TQvooX2mr22O3spxXY= 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=UhZMck+7; arc=none smtp.client-ip=209.85.214.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="UhZMck+7" Received: by mail-pl1-f172.google.com with SMTP id d9443c01a7336-2a09757004cso5998835ad.3 for ; Thu, 18 Dec 2025 03:32:03 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766057522; x=1766662322; 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=6Bzf60JLofSG2DA9NsCMwzI5A7CjeGtWYOi10qBfb/Y=; b=UhZMck+7OoG3MOzvs4qmKqXffLwzMH8Tsa4EasE77Pmylaemb9GDrKBCSYY7yb3Xwh F/3rHimx4tacktL6QuOvXrB6wCLl7GzSD8IkFKjQwwEugIWlMgV2mi573sZT/GVOucxB D6wALChjrY7e0PI+HvoE0cm2ZsYdEDHqMit/exCv1t9pIbHclENhws4GUQrXcuH7AXEL kWsI39NnK8HY1mDwKPZu2F/S6vAJzq2u+fIskk0+WCoSqS6Qk5qh0q8hRlMTknKCCac7 G4R41VhVaQl0BjvUqW9vfT0pyYkWRTBqR9akUmQV19u1taLQAVG7VSiizK5aDJduTKvA YWSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766057522; x=1766662322; 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=6Bzf60JLofSG2DA9NsCMwzI5A7CjeGtWYOi10qBfb/Y=; b=k/wULTSySAjGsme6UGhNhWhZfRLhIp1YA2B7D4W4sZ6am+OtKdrlKzM/acIJtmKzse M0qZzifEsVyCbFuFOoyVAjOrCaoIcG0aQtpp6+bhWcUGWYw7ANpuiO/OPnicLGJizvEA 025OXu2V2MXUFI97INLAI/hVqE8393/eDQG/1jTm+r1calXurEFVLaivRIJrgdzMvgEu q2UU4PK01dtS/M6GIdEa4NE/A7zBvecyFZ9ImMQlEDo6ozdx2L5Ur0m0PiCMku13abh3 uPOlTbWPocOaBqBk5cpHJrE8RvyMi95niU5ISb8LkKj4LVYUs87fQCnQJlDfac+V8liu M/dQ== X-Forwarded-Encrypted: i=1; AJvYcCVcvR7hRlv0c/smW60+PvpAGlQ+uZrEUhtBTiDknkPSQ5SQsNmhCtjaz14fHq9s0F0xp+nWdvpJ4pi0W2g=@vger.kernel.org X-Gm-Message-State: AOJu0YwtVlGhCCwLsVjnb9aK2UEhIo9H0OF8URe2OZpQS7iYnDWq/TK4 fpJxASo6euFKliy0cSOMt2PHnIiAO2M3HvoZWVb34Ik+1Gbbx+HUqxfz X-Gm-Gg: AY/fxX7QCm5lob0oeHI0ERwfTlJmuTQgZe3Viube9YJ/vYNNSDORI6cHMRXQ16Yc025 bOyjkHhxz9hum5hotNOMpTAzj9wKGngrjSR7xqnzKmiqUYdVS5dlVddj9IsAIX7tRTHbfAMbhyu Yev7FlUJe9gqxrpE/+vAFKc8RXMFh8s1+EYVzBTKPI78JMlFBqZiWZ88USVX+j2+qBfHgWjUm92 iWStuQxt5oY0o1yOSyRy7s8rLUlkQEouBlE+KwEQVqjUW+++/Mnq2QKYakNdxF0xiI61AVceR3B hYFGeRFWwaboausO9V7aIjIjdR/dLMg2hSBGYCvDoRS/LKNqNv7FzUXOs4j1sgmkKvfMvGa2UAn qEze3GymMOaMjsIU4ZrUKMf0eADXmWO7BdkgRLPzdNNBPokQZi5azAoL2z+bq6Sf0mq7TaDdFMe FvKt3lkS//P8XZz3Pk4rLe7lGQ7hY= X-Google-Smtp-Source: AGHT+IGzuUSoe6qBzXdOooKd2p++fz1sAZV7aKg6xjIsW5m88zx941fiADaOW3O9M7LJ9BpuB6dUWg== X-Received: by 2002:a17:90b:4c:b0:340:c64d:38d3 with SMTP id 98e67ed59e1d1-34abd6e0220mr21353294a91.12.1766057521908; Thu, 18 Dec 2025 03:32:01 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-34e70d4f887sm2328237a91.3.2025.12.18.03.31.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 18 Dec 2025 03:31:59 -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, pengdonglin , Alan Maguire Subject: [PATCH bpf-next v10 13/13] btf: Refactor the code by calling str_is_empty Date: Thu, 18 Dec 2025 19:30:51 +0800 Message-Id: <20251218113051.455293-14-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251218113051.455293-1-dolinux.peng@gmail.com> References: <20251218113051.455293-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: pengdonglin 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: pengdonglin 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 571b72bd90b5..013b1e5d396d 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -2169,7 +2169,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) @@ -2217,7 +2217,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 */ @@ -2272,7 +2272,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; @@ -2349,7 +2349,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; @@ -2450,7 +2450,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; @@ -2488,7 +2488,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; @@ -2546,7 +2546,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); @@ -2623,7 +2623,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 */ @@ -2663,7 +2663,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) { @@ -2699,7 +2699,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); @@ -2751,7 +2751,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); @@ -2768,7 +2768,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); @@ -2787,7 +2787,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) @@ -2873,7 +2873,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; @@ -2908,7 +2908,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) @@ -2957,7 +2957,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)) @@ -3034,7 +3034,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