From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pf1-f173.google.com (mail-pf1-f173.google.com [209.85.210.173]) (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 9CA1B35B139 for ; Fri, 9 Jan 2026 13:00:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.173 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963615; cv=none; b=TWk0DxH47hnQ/2wVcNYcx7W20sJWpHH0K6mFLgb9sYXLZEyjsc1flgqWfdwkg9VcqK6UlzXlyUe1lqdwIbG4YlsmVnY3V37aEs/2iTBjfvR8m3NAtUgnGxvN3S0w5liYQxSQaH/ODM9FiCJjPjPn3Yj2qqKuPU1mmoCoSHcvK0Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963615; c=relaxed/simple; bh=ksqELPO0cXKauiYwTecfnPaKtxldFgV/kANERx4D1IY=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=TaBoAfHRHM32SdkzsTrAFoSwCHs+rHr4kcFLbzX6DcykiV/27OeLac900VqH9Fc5yoxRtxkxWnjebregvGK7N48LTEUedQtXzh5ViCnx5FW3mwSVaiWg8I9FpxomiZh8mkcIlBgco2LKtKPfBG6nUh3v2smcl3BAiANM78wZGns= 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=flJTaxQd; arc=none smtp.client-ip=209.85.210.173 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="flJTaxQd" Received: by mail-pf1-f173.google.com with SMTP id d2e1a72fcca58-81ef4b87291so51874b3a.0 for ; Fri, 09 Jan 2026 05:00:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963613; x=1768568413; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=PQF9Y2EREf+dgAVABdiiMRWyZAZapN+hexHBR/LqK4M=; b=flJTaxQdrv5Lzpa2CUYap4fjKfT7miz/fibkohjp8eEiKMY6euidWA/nDpiZJ3R6DW ZCujTnQqjvY2+YdyAVPqp0+0GPc2V1oSLqIfajgwE4EVQg6AI4VE55GuBKsXgwTIZE3y 8Ihj4NM1cLuIS3rN+QvWtdswxYdwWWEyGY4F71KIKtL1sFrUg/GukxmRstF6aX+gnmjQ jP1TcWNPzNzRNmCWrRo0IuhDwb5x/+X6c+07olsh9BftaHoMVbHli02LCfaIV58FWoXA iquTczMhuuJWj2bCw9Xp+N9kBDUCI51XEaKUfSef0HtorK2zD+Skjxmu05gu2Zz1GewY 4RAA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963613; x=1768568413; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=PQF9Y2EREf+dgAVABdiiMRWyZAZapN+hexHBR/LqK4M=; b=IrxRTTgdpEZpUncx1PmBty4mqhcKEt51aTMfkDUdB3ERjBkdkq3On4UkTUIzfCWLb6 SQwuP7POUKFLtQlBpERXiB+RKIV44suB2ED7dSLobGmx9FuHhOPqrPmqcSblNUbTi4oZ 3hs6nWQ3lki4fQXq3Rm7RDlDKFQhzqAWLPMGVsZH6XtY99Up78G6PeBguUqodAp+ABGn 9GR0uPAyQs0MCLFcpDPnlc4iMc/8wDqV0ROS60UT3Galr9ZrHy6YC1/KOiPmLFKL7dWz NpAqER8PFB2icwIEiElL8c/pvD1+20xA3FE9qVFqmQLBQRaS4/pHBVJmjZCfGMYRg34U +Csw== X-Forwarded-Encrypted: i=1; AJvYcCWhB0bnedoMHYjqCvxMLnHfByvTHNkJSO3Zmv3L6fp5MJZScUEdHtgyaZyOprNsGRCCY73azCm+Ttyy9HY=@vger.kernel.org X-Gm-Message-State: AOJu0YxNqPVT6o0pzgzMvKEVjqSd/NFJC4zXHZqdGKN4kQQQTytMHHo+ 2xBtILy5W3qz7hUYopo5nwIFwRAEWG5yB/zCsQzRBEVAF8SbQv+v71m6 X-Gm-Gg: AY/fxX4Ri9Fj/LZcs6bLv/x6ZHfQtwji/1sGCX63MZ3YfJHjolvufJuY5bXzVoCAHxA tlwX9VdDLPE0HkOZ19Zgnui5dVoEZI0cAINFBsL5EAxmDieb57AdnZaDaeBFkcAVXOjm6LtnH6X 7WAZh/tdwjbnchC6uclGHBifBuOy6U02cwH3krnLN9420dgx0DhC1h+SyLSKlnmXkAcqtTRXj+2 Od21t6nNsbBm1784MDBkHVslRW4/CCWITtqN1G5tL368zkuIm5Kq5fI4Ai3G42IPWhW6qyFeW02 K8C5eK7mcda5ISypv0/8AIvn4QDrG93O8gMSbVU3L5VKMYnpuvEqPLOAhLsxmByFUW+ZcNfHLC/ 44QFT1It+mhpyXIid5iBNRosugEV8RfTTUBnDWlHvh1x5O7Kg9V08p6kFJSREmmOUIi/ukaR8Yl VBjD9Y7iUQuTJw8TpAt5jibSnr9SY= X-Google-Smtp-Source: AGHT+IF51Igam8v/LIPmHw9lFij0EDTO1sN2sr7KpHZqEplaw8HFWRTzlRk8sdAEKOZQNo95zqw+LQ== X-Received: by 2002:a05:6a20:94c9:b0:366:5bda:1e87 with SMTP id adf61e73a8af0-3898fa40b18mr9183375637.80.1767963612265; Fri, 09 Jan 2026 05:00:12 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:11 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 01/11] libbpf: Add BTF permutation support for type reordering Date: Fri, 9 Jan 2026 20:59:53 +0800 Message-Id: <20260109130003.3313716-2-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Introduce btf__permute() API to allow in-place rearrangement of BTF types. This function reorganizes BTF type order according to a provided array of type IDs, updating all type references to maintain consistency. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 133 +++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/btf.h | 42 +++++++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 176 insertions(+) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index b136572e889a..bf75f770d29a 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -5887,3 +5887,136 @@ int btf__relocate(struct btf *btf, const struct btf= *base_btf) btf->owns_base =3D false; return libbpf_err(err); } + +struct btf_permute { + struct btf *btf; + __u32 *id_map; + __u32 start_offs; +}; + +/* Callback function to remap individual type ID references */ +static int btf_permute_remap_type_id(__u32 *type_id, void *ctx) +{ + struct btf_permute *p =3D ctx; + __u32 new_id =3D *type_id; + + /* refer to the base BTF or VOID type */ + if (new_id < p->btf->start_id) + return 0; + + if (new_id >=3D btf__type_cnt(p->btf)) + return -EINVAL; + + *type_id =3D p->id_map[new_id - p->btf->start_id + p->start_offs]; + return 0; +} + +int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_cnt, + const struct btf_permute_opts *opts) +{ + struct btf_permute p; + struct btf_ext *btf_ext; + void *nt, *new_types =3D NULL; + __u32 *order_map =3D NULL; + int err =3D 0, i; + __u32 n, id, start_offs =3D 0; + + if (!OPTS_VALID(opts, btf_permute_opts)) + return libbpf_err(-EINVAL); + + if (btf__base_btf(btf)) { + n =3D btf->nr_types; + } else { + if (id_map[0] !=3D 0) + return libbpf_err(-EINVAL); + n =3D btf__type_cnt(btf); + start_offs =3D 1; + } + + if (id_map_cnt !=3D n) + return libbpf_err(-EINVAL); + + /* record the sequence of types */ + order_map =3D calloc(id_map_cnt, sizeof(*id_map)); + if (!order_map) { + err =3D -ENOMEM; + goto done; + } + + new_types =3D calloc(btf->hdr->type_len, 1); + if (!new_types) { + err =3D -ENOMEM; + goto done; + } + + if (btf_ensure_modifiable(btf)) { + err =3D -ENOMEM; + goto done; + } + + for (i =3D start_offs; i < id_map_cnt; i++) { + id =3D id_map[i]; + if (id < btf->start_id || id >=3D btf__type_cnt(btf)) { + err =3D -EINVAL; + goto done; + } + id -=3D btf->start_id - start_offs; + /* cannot be mapped to the same ID */ + if (order_map[id]) { + err =3D -EINVAL; + goto done; + } + order_map[id] =3D i + btf->start_id - start_offs; + } + + p.btf =3D btf; + p.id_map =3D id_map; + p.start_offs =3D start_offs; + nt =3D new_types; + for (i =3D start_offs; i < id_map_cnt; i++) { + struct btf_field_iter it; + const struct btf_type *t; + __u32 *type_id; + int type_size; + + id =3D order_map[i]; + t =3D btf__type_by_id(btf, id); + type_size =3D btf_type_size(t); + memcpy(nt, t, type_size); + + /* fix up referenced IDs for BTF */ + err =3D btf_field_iter_init(&it, nt, BTF_FIELD_ITER_IDS); + if (err) + goto done; + while ((type_id =3D btf_field_iter_next(&it))) { + err =3D btf_permute_remap_type_id(type_id, &p); + if (err) + goto done; + } + + nt +=3D type_size; + } + + /* fix up referenced IDs for btf_ext */ + btf_ext =3D OPTS_GET(opts, btf_ext, NULL); + if (btf_ext) { + err =3D btf_ext_visit_type_ids(btf_ext, btf_permute_remap_type_id, &p); + if (err) + goto done; + } + + for (nt =3D new_types, i =3D 0; i < id_map_cnt - start_offs; i++) { + btf->type_offs[i] =3D nt - new_types; + nt +=3D btf_type_size(nt); + } + + free(order_map); + free(btf->types_data); + btf->types_data =3D new_types; + return 0; + +done: + free(order_map); + free(new_types); + return libbpf_err(err); +} diff --git a/tools/lib/bpf/btf.h b/tools/lib/bpf/btf.h index cc01494d6210..b30008c267c0 100644 --- a/tools/lib/bpf/btf.h +++ b/tools/lib/bpf/btf.h @@ -281,6 +281,48 @@ LIBBPF_API int btf__dedup(struct btf *btf, const struc= t btf_dedup_opts *opts); */ LIBBPF_API int btf__relocate(struct btf *btf, const struct btf *base_btf); =20 +struct btf_permute_opts { + size_t sz; + /* optional .BTF.ext info along the main BTF info */ + struct btf_ext *btf_ext; + size_t :0; +}; +#define btf_permute_opts__last_field btf_ext + +/** + * @brief **btf__permute()** rearranges BTF types in-place according to a = specified ID mapping + * @param btf BTF object to permute + * @param id_map Array mapping original type IDs to new IDs + * @param id_map_cnt Number of elements in @id_map + * @param opts Optional parameters, including BTF extension data for refer= ence updates + * @return 0 on success, negative error code on failure + * + * **btf__permute()** reorders BTF types based on the provided @id_map arr= ay, + * updating all internal type references to maintain consistency. The func= tion + * operates in-place, modifying the BTF object directly. + * + * For **base BTF**: + * - @id_map must include all types from ID 0 to `btf__type_cnt(btf) - 1` + * - @id_map_cnt must be `btf__type_cnt(btf)` + * - Mapping is defined as `id_map[original_id] =3D new_id` + * - `id_map[0]` must be 0 (void type cannot be moved) + * + * For **split BTF**: + * - @id_map must include only split types (types added on top of the base= BTF) + * - @id_map_cnt must be `btf__type_cnt(btf) - btf__type_cnt(btf__base_btf= (btf))` + * - Mapping is defined as `id_map[original_id - start_id] =3D new_id` + * - `start_id` equals `btf__type_cnt(btf__base_btf(btf))` + * + * After permutation, all type references within the BTF data and optional + * BTF extension (if provided via @opts) are updated automatically. + * + * On error, returns a negative error code and sets errno: + * - `-EINVAL`: Invalid parameters or invalid ID mapping + * - `-ENOMEM`: Memory allocation failure + */ +LIBBPF_API int btf__permute(struct btf *btf, __u32 *id_map, __u32 id_map_c= nt, + const struct btf_permute_opts *opts); + struct btf_dump; =20 struct btf_dump_opts { diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map index 84fb90a016c9..d18fbcea7578 100644 --- a/tools/lib/bpf/libbpf.map +++ b/tools/lib/bpf/libbpf.map @@ -453,4 +453,5 @@ LIBBPF_1.7.0 { bpf_map__exclusive_program; bpf_prog_assoc_struct_ops; bpf_program__assoc_struct_ops; + btf__permute; } LIBBPF_1.6.0; --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 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 90FA033C53A for ; Fri, 9 Jan 2026 13:00:16 +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=1767963619; cv=none; b=t0/6bbSjD2wQg7VLqiveP4cVNiPPTR68HEyo6Kx98zopEbgtfdbMdE8hR0EZJxre5fcL+YNfxv/WdmlQv0Y5v/USMbhfrA9XWmwhP16gEf0cXZ05K6ObEROXTrWZj0Nb7koPunnhw9mOhp1tEFtH+brpG4rEjE+/EVyUBETQae8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963619; c=relaxed/simple; bh=uMiIaTuHoGp8t2XP9PDz6WtnuLCS6v4VMQ6JPWkBmY4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=sCjhegu9aWzKc5ToNzjiinradFevKln08hMcFVeM6WlPuOrFgtOQco6u6kGjYPJMZtXFV5Ht3UU3HIjV206uJWZgPIRf2wK/eoiB6YOZetvCrmIyVX2YDorG1yr41oa3ySpeH//yXpAHQJeD6ieGlmgRsmPwykjNdij5XNT39pU= 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=ecM4lOQD; 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="ecM4lOQD" Received: by mail-pl1-f172.google.com with SMTP id d9443c01a7336-2a081c163b0so30772915ad.0 for ; Fri, 09 Jan 2026 05:00:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963616; x=1768568416; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=CLf4MD/8vWtFsjd7VfVNcjK4gNe3ynQJ9Qc+27+cU9U=; b=ecM4lOQD1dlVHQAwW9Kjrizm73duzuA7G9IWNr4S24nmYrj4pDSrral0v1oYsjCea3 Mft+xWCKu6ZxjRrlYZHF3PsTCLMBTmitdvJLJrX7AbvJLJcA7riWkkibxd1C0IAqYr8d 7dwLyDcOu++iow1KadTChv/aSKRwha8sMf6ccnnkEGd8wB9jQyeEy/+3rsGdR0xnxTVc I5saWhbPRAuMaS9R9enc5brbqfcg6h5fQPh8iHAhcLTZBEmr1CwJksN6zsHDzKZM9+pv kIMcdV8OsEf+a/TjSQi/dy/Uk4qf56OG9oPcG4xmgdWhfrYXuIHUR+FC1c7kwmoUP05j Lfpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963616; x=1768568416; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=CLf4MD/8vWtFsjd7VfVNcjK4gNe3ynQJ9Qc+27+cU9U=; b=AawKfb0+g00tXX27C59JeadBvfY+nPrTaN3kxfQsZyvKMaLW1Q9m/SN6XHCvaJ02vR BXuxTG6AB1/GEViZ+nxCitmnCCFHqi+bOEPwHSnwKgCudwUKQ3hVAYSmTYi2dBMa0yLi FlVOu37klx9L/umLmXdEYKLjtfMi3+A6DUuMPq84TxINZcx8dHdNBm6ekfWHh0QFWZxP 7ZVQUiCNtQTOGdMUt+r570kYjsZUkhLb6PUMr3vlRs3OoLCHdjZhP+TRCVkEFUdko04a IQCGQ5lJLTvcgcWsmFgqIE4IJqgNyDjt91q8Tqgtr0RdYzbw1V2/Y62arSXzf2cgjWGy O60w== X-Forwarded-Encrypted: i=1; AJvYcCV2O/dJ75qyGdiQ7hcq0YIk30VnSYIzkHJdCYlb5ijXgEzFPR6tIjep7vTzuZNB4rXyZf6ibBG5kv/20eM=@vger.kernel.org X-Gm-Message-State: AOJu0YyN6pkMCDNtNeEZU94L+P2B6Ms5O50FZI5zcLnnppVNX+O0epD/ H93TR+BOr8P3Z1EGdFF5x3vIIMrxfeftObobQy4adTWBP29MEwI/Zv51 X-Gm-Gg: AY/fxX7vVMUr3cJ2qAuy2FMuKaTVa4c8Bjw5eK4/6DNloAan1Ya6R4Gh1JfZ9nC9lzH M+GU5WCP0UIVK2AjTzlk9jQRbdWtrgWRxpBO8nGjLjGRi0hZW6QFOyQz6bUf+HfS1W/wh2eAL7r zgAZw//TDwg73DRLgyXYvD7GoyoJoJmT1LC5kReN72ceQClGk1BwmG5O4cTVzwt4yYR4y6ChJF2 M3PfaF2Q40CmnEqBByuTNXsGMstMoQOhZFZJhXgA5Q3m/e+unp3XDvsfbSC2Dtn+9EMQVOuPshU +8HtIN0CeDkiAkKXAnhUy2kbC1Y812hjwl7Ggi2UYR3PswunfV4oXR6JexjqkXBsznQVkyjEmeB CU/W8p6kyMlC04UwqDFZ0YVo7mgtAroZATDdJZWOC+H9N4bSp7ZTr/du/LojDfh/AyKQyEQ8kl+ oFx7+M3n5nWWNPaEkH8wTxG7Pg7JE= X-Google-Smtp-Source: AGHT+IHUbv9WRCZStjAecPrTyLJ6XpZmmO3OJTH9Yv044JkqHu4Qb0zoqrFjdl0rbPYyVoyrUN7Tow== X-Received: by 2002:a17:903:3d0f:b0:2a0:81c1:6194 with SMTP id d9443c01a7336-2a3ee49c2a5mr99381295ad.47.1767963615302; Fri, 09 Jan 2026 05:00:15 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:14 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 02/11] selftests/bpf: Add test cases for btf__permute functionality Date: Fri, 9 Jan 2026 20:59:54 +0800 Message-Id: <20260109130003.3313716-3-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch introduces test cases for the btf__permute function to ensure it works correctly with both base BTF and split BTF scenarios. The test suite includes: - test_permute_base: Validates permutation on base BTF - test_permute_split: Tests permutation on split BTF Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- .../selftests/bpf/prog_tests/btf_permute.c | 244 ++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/btf_permute.c diff --git a/tools/testing/selftests/bpf/prog_tests/btf_permute.c b/tools/t= esting/selftests/bpf/prog_tests/btf_permute.c new file mode 100644 index 000000000000..04ade5ad77ac --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/btf_permute.c @@ -0,0 +1,244 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 Xiaomi */ + +#include +#include +#include "btf_helpers.h" + +static void permute_base_check(struct btf *btf) +{ + VALIDATE_RAW_BTF( + btf, + "[1] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D4 bits_offset=3D0", + "[2] FUNC 'f' type_id=3D6 linkage=3Dstatic", + "[3] PTR '(anon)' type_id=3D4", + "[4] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[5] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D4 bits_offset=3D0", + "[6] FUNC_PROTO '(anon)' ret_type_id=3D4 vlen=3D1\n" + "\t'p' type_id=3D3"); +} + +/* Ensure btf__permute works as expected in the base-BTF scenario */ +static void test_permute_base(void) +{ + struct btf *btf; + __u32 permute_ids[7]; + int err; + + btf =3D btf__new_empty(); + if (!ASSERT_OK_PTR(btf, "empty_main_btf")) + return; + + btf__add_int(btf, "int", 4, BTF_INT_SIGNED); /* [1] int */ + btf__add_ptr(btf, 1); /* [2] ptr to int */ + btf__add_struct(btf, "s1", 4); /* [3] struct s1 { */ + btf__add_field(btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_struct(btf, "s2", 4); /* [4] struct s2 { */ + btf__add_field(btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_func_proto(btf, 1); /* [5] int (*)(int *p); */ + btf__add_func_param(btf, "p", 2); + btf__add_func(btf, "f", BTF_FUNC_STATIC, 5); /* [6] int f(int *p); */ + + VALIDATE_RAW_BTF( + btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1", + "[3] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[4] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[5] FUNC_PROTO '(anon)' ret_type_id=3D1 vlen=3D1\n" + "\t'p' type_id=3D2", + "[6] FUNC 'f' type_id=3D5 linkage=3Dstatic"); + + permute_ids[0] =3D 0; /* [0] -> [0] */ + permute_ids[1] =3D 4; /* [1] -> [4] */ + permute_ids[2] =3D 3; /* [2] -> [3] */ + permute_ids[3] =3D 5; /* [3] -> [5] */ + permute_ids[4] =3D 1; /* [4] -> [1] */ + permute_ids[5] =3D 6; /* [5] -> [6] */ + permute_ids[6] =3D 2; /* [6] -> [2] */ + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_OK(err, "btf__permute_base")) + goto done; + permute_base_check(btf); + + /* ids[0] must be 0 for base BTF */ + permute_ids[0] =3D 4; /* [0] -> [0] */ + permute_ids[1] =3D 0; /* [1] -> [4] */ + permute_ids[2] =3D 3; /* [2] -> [3] */ + permute_ids[3] =3D 5; /* [3] -> [5] */ + permute_ids[4] =3D 1; /* [4] -> [1] */ + permute_ids[5] =3D 6; /* [5] -> [6] */ + permute_ids[6] =3D 2; /* [6] -> [2] */ + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + + /* id_map_cnt is invalid */ + permute_ids[0] =3D 0; /* [0] -> [0] */ + permute_ids[1] =3D 4; /* [1] -> [4] */ + permute_ids[2] =3D 3; /* [2] -> [3] */ + permute_ids[3] =3D 5; /* [3] -> [5] */ + permute_ids[4] =3D 1; /* [4] -> [1] */ + permute_ids[5] =3D 6; /* [5] -> [6] */ + permute_ids[6] =3D 2; /* [6] -> [2] */ + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids) - 1, NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + + /* Multiple types can not be mapped to the same ID */ + permute_ids[0] =3D 0; + permute_ids[1] =3D 4; + permute_ids[2] =3D 4; + permute_ids[3] =3D 5; + permute_ids[4] =3D 1; + permute_ids[5] =3D 6; + permute_ids[6] =3D 2; + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + + /* Type ID must be valid */ + permute_ids[0] =3D 0; + permute_ids[1] =3D 4; + permute_ids[2] =3D 3; + permute_ids[3] =3D 5; + permute_ids[4] =3D 1; + permute_ids[5] =3D 7; + permute_ids[6] =3D 2; + err =3D btf__permute(btf, permute_ids, ARRAY_SIZE(permute_ids), NULL); + if (!ASSERT_ERR(err, "btf__permute_base")) + goto done; + /* BTF is not modified */ + permute_base_check(btf); + +done: + btf__free(btf); +} + +static void permute_split_check(struct btf *btf) +{ + VALIDATE_RAW_BTF( + btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1", + "[3] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[4] FUNC 'f' type_id=3D5 linkage=3Dstatic", + "[5] FUNC_PROTO '(anon)' ret_type_id=3D1 vlen=3D1\n" + "\t'p' type_id=3D2", + "[6] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0"); +} + +/* Ensure btf__permute works as expected in the split-BTF scenario */ +static void test_permute_split(void) +{ + struct btf *split_btf =3D NULL, *base_btf =3D NULL; + __u32 permute_ids[4]; + int err, start_id; + + base_btf =3D btf__new_empty(); + if (!ASSERT_OK_PTR(base_btf, "empty_main_btf")) + return; + + btf__add_int(base_btf, "int", 4, BTF_INT_SIGNED); /* [1] int */ + btf__add_ptr(base_btf, 1); /* [2] ptr to int */ + VALIDATE_RAW_BTF( + base_btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1"); + split_btf =3D btf__new_empty_split(base_btf); + if (!ASSERT_OK_PTR(split_btf, "empty_split_btf")) + goto cleanup; + btf__add_struct(split_btf, "s1", 4); /* [3] struct s1 { */ + btf__add_field(split_btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_struct(split_btf, "s2", 4); /* [4] struct s2 { */ + btf__add_field(split_btf, "m", 1, 0, 0); /* int m; */ + /* } */ + btf__add_func_proto(split_btf, 1); /* [5] int (*)(int p); */ + btf__add_func_param(split_btf, "p", 2); + btf__add_func(split_btf, "f", BTF_FUNC_STATIC, 5); /* [6] int f(int *p); = */ + + VALIDATE_RAW_BTF( + split_btf, + "[1] INT 'int' size=3D4 bits_offset=3D0 nr_bits=3D32 encoding=3DSIGNED", + "[2] PTR '(anon)' type_id=3D1", + "[3] STRUCT 's1' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[4] STRUCT 's2' size=3D4 vlen=3D1\n" + "\t'm' type_id=3D1 bits_offset=3D0", + "[5] FUNC_PROTO '(anon)' ret_type_id=3D1 vlen=3D1\n" + "\t'p' type_id=3D2", + "[6] FUNC 'f' type_id=3D5 linkage=3Dstatic"); + + start_id =3D btf__type_cnt(base_btf); + permute_ids[3 - start_id] =3D 6; /* [3] -> [6] */ + permute_ids[4 - start_id] =3D 3; /* [4] -> [3] */ + permute_ids[5 - start_id] =3D 5; /* [5] -> [5] */ + permute_ids[6 - start_id] =3D 4; /* [6] -> [4] */ + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids), NUL= L); + if (!ASSERT_OK(err, "btf__permute_split")) + goto cleanup; + permute_split_check(split_btf); + + /* + * For split BTF, id_map_cnt must equal to the number of types + * added on top of base BTF + */ + permute_ids[3 - start_id] =3D 4; + permute_ids[4 - start_id] =3D 3; + permute_ids[5 - start_id] =3D 5; + permute_ids[6 - start_id] =3D 6; + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids) - 1,= NULL); + if (!ASSERT_ERR(err, "btf__permute_split")) + goto cleanup; + /* BTF is not modified */ + permute_split_check(split_btf); + + /* Multiple types can not be mapped to the same ID */ + permute_ids[3 - start_id] =3D 4; + permute_ids[4 - start_id] =3D 3; + permute_ids[5 - start_id] =3D 3; + permute_ids[6 - start_id] =3D 6; + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids), NUL= L); + if (!ASSERT_ERR(err, "btf__permute_split")) + goto cleanup; + /* BTF is not modified */ + permute_split_check(split_btf); + + /* Can not map to base ID */ + permute_ids[3 - start_id] =3D 4; + permute_ids[4 - start_id] =3D 2; + permute_ids[5 - start_id] =3D 5; + permute_ids[6 - start_id] =3D 6; + err =3D btf__permute(split_btf, permute_ids, ARRAY_SIZE(permute_ids), NUL= L); + if (!ASSERT_ERR(err, "btf__permute_split")) + goto cleanup; + /* BTF is not modified */ + permute_split_check(split_btf); + +cleanup: + btf__free(split_btf); + btf__free(base_btf); +} + +void test_btf_permute(void) +{ + if (test__start_subtest("permute_base")) + test_permute_base(); + if (test__start_subtest("permute_split")) + test_permute_split(); +} --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f177.google.com (mail-pl1-f177.google.com [209.85.214.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3FC0D35BDB3 for ; Fri, 9 Jan 2026 13:00:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963620; cv=none; b=bCBQXX85GLm7mSRC21ojE7yGZgDuUL/o0Wcmr1XLZ+pcMw9ljSnlCUbt2pnOPhKttBDmEMhIWwV8UFkoOA/M6/g6Cg8RUf0FohasTfkFTsid8fJwP133Heev5+NT/wsoNzsEmypm2qzBO6XuvO9gkCu72qZ23FDy1IocFLI/j4o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963620; c=relaxed/simple; bh=V2vGk2Zy5fJHvJb6bZZNfPor1jIBJ/nlZMkVKHTwBMQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=gdJ1dRMfZuCghdXowJEQ+mLWa+0m7NPetyuwFu5ow5Xat0IyDpnITzdvxQ1LEly2B3/MsFXGFvO5KAuQhlJI9gE7OFwGK42gguqXpaGTwesrgWR5dciydHCSZaGhpKm44FPUCnUDHb+jsypW9SZv/gpvNG5GQRpEQoUVvSKaWXI= 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=VsCaxs+C; arc=none smtp.client-ip=209.85.214.177 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="VsCaxs+C" Received: by mail-pl1-f177.google.com with SMTP id d9443c01a7336-2a0a33d0585so29074145ad.1 for ; Fri, 09 Jan 2026 05:00:19 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963618; x=1768568418; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Bty2Mx4T9JTfidtdE5tI1SEQacGBSMSmT3cGtlsXrrQ=; b=VsCaxs+CfVbmGdcKD/KsIsSHsIHhEbdPJ2xBz/wcAu3q9M9ZzCzedQsXkprzF+au/u bLFD/pmIPJ+ADs45oYzVMP87NmDd/n5+nAPRspAX4nLiq2TwNBaeUgMVwcLWcOSa7buo +bdhrEeqKijbV55MzgTq/y2UQaxBmL+9a1FymHZFXkbVfUTuWcovilk8bs5bMoWq0qvz CQt2pLXeFFBpJZkEUPs8eifhxF7uqTL9RXu2qhpGaWFxwSM7ndkQLR69VUSZwxR0aYVP m3C13bSNXydgNXbS2ZSkPDbvLHM75IPRAgqAmYtXSZnT9o4toHKqCRq5hxm+bpdmp//m CWZw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963618; x=1768568418; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Bty2Mx4T9JTfidtdE5tI1SEQacGBSMSmT3cGtlsXrrQ=; b=ne/4NCog2i3Xg4gdnQ+MiXRBJbUb+srqdG2PmlvqzW3hGMpd2OHjnIoceCzXeGQ05j ptVKH5KtxG9PSpnjw5KrXTOG29JYd+QoosXOcv9fj0WfgCvpg6eM5YriVkWhi3pzx/qO +RoqdGJx2HVn/y+xSEPd7vtghO6KLqKSwprS9DnAxMQHsJHSqud+9TpLXN2Mt8Vtkqxd 7i5KgDuOFXb8mxhQGXcVJKqqsqIE82TzEoXCFM72f/IJ71OxaseiUsnxFwx6l27EBXY6 jlNx403wVLensoeWS/g+CfLLaZQD0L+R6WtuYITjKfsEAJPakm9gNkb7PwQQuWOchsQZ J2ag== X-Forwarded-Encrypted: i=1; AJvYcCVAwN2eg3YLofIAyK25CIAIcU8JkrJCn9YfhnXDSGcrJqjV7bukY4UX53kIA427YcB9rzAke2aP9eBZgoI=@vger.kernel.org X-Gm-Message-State: AOJu0YwTMYh1tiGnXhlAhyCMINUEQLMTK/47KTZFRFk2E5HwC+kQ8pYh 5RFO6cl78V47g4H1157fk5RN120jehUInNNR3bwKn0Zz/rO8UW4YCAVB X-Gm-Gg: AY/fxX7f/6OFaAjdN/+Pa3haiaHQbXa9DLECcuOhrO0BXfNzdI+6zW12xIZ6WFVtgs0 SFuB1BF5a1Y86Oq0/6jR087HRFMu06EJGtn0DC6E79VzHzK3DqkS0kGFiXbC5V7KGqHEGltD0J5 tWAwJVNYYU50IvGsRdnV7tlM06Rnkdyt9EMsBoOFEJHyPp0RGIjzSxw9a1A9nCdcFmwuowGM8Ac 0JNBBqhRbKtN/NKmGyiYQ7w1IK3Pkj6UdOiHWxS9Iuvg026rI7wyY5Zkvw21jQEU6q58PrEma8a T7Goy9pQcMAmR/lAc15+H7Nat3//9dkgB7o7dcvwUR8urer9miBv30T/FeJopW35iv6CPqGg3zL 28LqO8Ztp0Wy/4L4aHYhNRZ6885DAvTQAeEDxvWlQzNmXNF9bka4BVrU3rphO2ug82REDYxIE04 4Kn//+s+FeSexqUZ/5CVXw6RKurXr70lewAl5Ghg== X-Google-Smtp-Source: AGHT+IECF92w8fh+lHt+04+liud+q7g2I2MsZIwzGHh6/4mZ0MC6VCsv+IyzdIp0hp/XC8DnU71DOA== X-Received: by 2002:a17:902:fb04:b0:2a1:325d:8219 with SMTP id d9443c01a7336-2a3ee49010amr62629655ad.38.1767963618237; Fri, 09 Jan 2026 05:00:18 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:17 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 03/11] tools/resolve_btfids: Support BTF sorting feature Date: Fri, 9 Jan 2026 20:59:55 +0800 Message-Id: <20260109130003.3313716-4-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This introduces a new BTF sorting phase that specifically sorts BTF types by name in ascending order, so that the binary search can be used to look up types. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/bpf/resolve_btfids/main.c | 64 +++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/mai= n.c index df39982f51df..343d08050116 100644 --- a/tools/bpf/resolve_btfids/main.c +++ b/tools/bpf/resolve_btfids/main.c @@ -850,6 +850,67 @@ static int dump_raw_btf(struct btf *btf, const char *o= ut_path) return 0; } =20 +/* + * Sort types by name in ascending order resulting in all + * anonymous types being placed before named types. + */ +static int cmp_type_names(const void *a, const void *b, void *priv) +{ + struct btf *btf =3D (struct btf *)priv; + const struct btf_type *ta =3D btf__type_by_id(btf, *(__u32 *)a); + const struct btf_type *tb =3D btf__type_by_id(btf, *(__u32 *)b); + const char *na, *nb; + + na =3D btf__str_by_offset(btf, ta->name_off); + nb =3D btf__str_by_offset(btf, tb->name_off); + return strcmp(na, nb); +} + +static int sort_btf_by_name(struct btf *btf) +{ + __u32 *permute_ids =3D NULL, *id_map =3D NULL; + int nr_types, i, err =3D 0; + __u32 start_id =3D 0, start_offs =3D 1, id; + + if (btf__base_btf(btf)) { + start_id =3D btf__type_cnt(btf__base_btf(btf)); + start_offs =3D 0; + } + nr_types =3D btf__type_cnt(btf) - start_id; + + permute_ids =3D calloc(nr_types, sizeof(*permute_ids)); + if (!permute_ids) { + err =3D -ENOMEM; + goto out; + } + + id_map =3D calloc(nr_types, sizeof(*id_map)); + if (!id_map) { + err =3D -ENOMEM; + goto out; + } + + for (i =3D 0, id =3D start_id; i < nr_types; i++, id++) + permute_ids[i] =3D id; + + qsort_r(permute_ids + start_offs, nr_types - start_offs, + sizeof(*permute_ids), cmp_type_names, btf); + + for (i =3D 0; i < nr_types; i++) { + id =3D permute_ids[i] - start_id; + id_map[id] =3D i + start_id; + } + + err =3D btf__permute(btf, id_map, nr_types, NULL); + if (err) + pr_err("FAILED: btf permute: %s\n", strerror(-err)); + +out: + free(permute_ids); + free(id_map); + return err; +} + static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path= , const char *suffix) { int len =3D snprintf(buf, buf_sz, "%s%s", in_path, suffix); @@ -1025,6 +1086,9 @@ int main(int argc, const char **argv) if (load_btf(&obj)) goto out; =20 + if (sort_btf_by_name(obj.btf)) + goto out; + if (elf_collect(&obj)) goto out; =20 --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f177.google.com (mail-pl1-f177.google.com [209.85.214.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 646FB35BDCD for ; Fri, 9 Jan 2026 13:00:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963623; cv=none; b=e6uvpgdfcM3z1cFl4mqGoMxPUE/ta3QKHTBvstqA+npZx94/7hrVN5zmjSHG4kmKqAPFIbWf50LBYK9adn/kJo6TcovS/P3+4TKBuLXqeL+siN5pS7WSZVpH3JCtwrZkrFwQI53YdFFREioTzmDeYBC5YG2COs5mrA7HSDSuQoQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963623; c=relaxed/simple; bh=salwZKOMcBbCVPLM3tI/7wuQ2DcFj21LFNsKb4W+7sA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=XcrvEhGmHoaQPoheFfhJMc6te4za3tivIzxsfAKPHZim5sggTSiYeZbnA7rXX5z+lcBBU4vqobLo7bn/I3ShzTtNbxKDd7qYSuBE6QCyW00iHmj+tGrU0I/1lbcixsKBxm6l03qme7hLLM+LZZ0mmPvPmBDE6AW+tkUTr1XqicI= 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=R+/zgCh3; arc=none smtp.client-ip=209.85.214.177 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="R+/zgCh3" Received: by mail-pl1-f177.google.com with SMTP id d9443c01a7336-29efd139227so31757575ad.1 for ; Fri, 09 Jan 2026 05:00:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963622; x=1768568422; 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=EerJzBZqmLkKlZXphUYi7qXcnVy2FMOdkloJx1qklEI=; b=R+/zgCh3qzw93v2PGsDPOwE4NovWoM7ZBNmnYWi74G2BWHRDBOEM2/Xv5xyY+vgyx6 utMxvs5GZzWY6dILXlcMdFN+CiIFztp7G1fvNcpusAvYmrOeCVMAGH0EkJtuxCOnnv0x cNRadA4pbgVZoOXlaaQROf8+6ghWP173yN5rRCaqOIhyJYNhBdhCb0mc/TIWXAeXC/FL dcPeX62EwrY7tt6ji3ItwnPkGoSh4t7RHpcTYErzFbjd7NvauXmfKJZLh6jwAJkzDfU6 +/OD3usd3tYMEL/GgC8PedPxDJqNuPUzte0+rwWlkzlwIDp74soxpLZMWY9/6GMQZPAP ivuQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963622; x=1768568422; 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=EerJzBZqmLkKlZXphUYi7qXcnVy2FMOdkloJx1qklEI=; b=vm/rdgrAWOGXMqyX30KpCeGwGezupaMQQD0vrJEBZooX7yY7sqntEaVdttPEQv52Du SFcqVBdknvDkjNEC3ueJ2/QPAG0Q3+3cFvh+1NQ9Lk31cYGKQA42xpHFq2tVomOThAe8 1DQoe41S4VbBBhO9lkBmVqazwXaCBuSEXIpMmHzpxity2A8KbX+oPo/Di4cerAN1ut1w 8q5k1agZgXYIJYLiGc+tRqEPn9zc+RIwxFkitRDf1AX0Q4jo8Ibo7M4Zj44ki9BQ3BLc 25JB6hffVUE/d5YTphiJvQPO1zz4QYuV4hoZaf5ND32nIbB/wEPkMAjamYUIatEamRj6 AO/Q== X-Forwarded-Encrypted: i=1; AJvYcCXQtACyYakLoVHoODzXJlGDEmRZBYhif+PvSezEsSrAia9A/NylKHEL7z2v1R2/GevaOZjCoWksxnkKpqk=@vger.kernel.org X-Gm-Message-State: AOJu0Yx2waLo/ln/ud0nFG2E7kmSF6XGysQ1bj1I5me/7/0SU/HH/2wX rwZWA646vxkgopyFwkqmDAZvRZ7nMDF3BJ2LzQ3/GbDF5734i8JtDWi/ X-Gm-Gg: AY/fxX5r7P1u4KRRkk5suOBcPoOW/MVJTdRKYRVVabbyTz8UZVxYPF/2X60nSFzLbyb tUyB6tl4Kv73EvLF+9VNiBdqh0zZMa3YqLvcydZNTk7zJKINej5bNbR/QVlMASVQUHOd7s3LRe7 WbX12y/5WE9rN5b+KyXo5aSTVrQ80/fj0fRG1KJ+rMnPmbmyq4VHP9DYQgWYXcVz4tS4B9Mlp/l AnRA+wTBIMWJ1nbFqXfR3OUjP/xVHJM9Kx9S/PmP6V6t7EgofwlvbSkldhKG7nzvu6xTJ28Sdgd SyR3NG8xls4iamTBkyYlKwiMUUkKSj1m2761rw0U47YGOI0gToMomgCYiuSJ5MSFLVV8H9xbD8H f33hRaVfRZP7X99bbaiVaAm34JZFCRnw1nIDQehjGC8RaMkqHLPlPL9W2y1/ACH8sQJamnqwN7/ +h+HNRlONYDGb3q2hdllUNBIzi+DM= X-Google-Smtp-Source: AGHT+IHP0XZhJSwwQ1Pk21yDA+jtoIk8CxB90/Dh6t68iDw/EvtSrmz3Jthw2DPZIVW703U7HsaegA== X-Received: by 2002:a17:902:e743:b0:2a1:e19:ff4 with SMTP id d9443c01a7336-2a3ee4b750amr103993545ad.29.1767963621346; Fri, 09 Jan 2026 05:00:21 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:20 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 04/11] libbpf: Optimize type lookup with binary search for sorted BTF Date: Fri, 9 Jan 2026 20:59:56 +0800 Message-Id: <20260109130003.3313716-5-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch introduces binary search optimization for BTF type lookups when the BTF instance contains sorted types. The optimization significantly improves performance when searching for types in large BTF instances with sorted types. For unsorted BTF, the implementation falls back to the original linear search. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng --- tools/lib/bpf/btf.c | 90 +++++++++++++++++++++++++++++++++------------ 1 file changed, 66 insertions(+), 24 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index bf75f770d29a..02407a022afb 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -92,6 +92,8 @@ struct btf { * - for split BTF counts number of types added on top of base BTF. */ __u32 nr_types; + /* the start IDs of named types in sorted BTF */ + int named_start_id; /* if not NULL, points to the base BTF on top of which the current * split BTF is based */ @@ -897,46 +899,83 @@ int btf__resolve_type(const struct btf *btf, __u32 ty= pe_id) return type_id; } =20 -__s32 btf__find_by_name(const struct btf *btf, const char *type_name) +static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const ch= ar *name, + __s32 start_id) { - __u32 i, nr_types =3D btf__type_cnt(btf); - - if (!strcmp(type_name, "void")) - return 0; - - for (i =3D 1; i < nr_types; i++) { - const struct btf_type *t =3D btf__type_by_id(btf, i); - const char *name =3D btf__name_by_offset(btf, t->name_off); - - if (name && !strcmp(type_name, name)) - return i; + const struct btf_type *t; + const char *tname; + __s32 l, r, m; + + l =3D start_id; + r =3D btf__type_cnt(btf) - 1; + while (l <=3D r) { + m =3D l + (r - l) / 2; + t =3D btf_type_by_id(btf, m); + tname =3D btf__str_by_offset(btf, t->name_off); + if (strcmp(tname, name) >=3D 0) { + if (l =3D=3D r) + return r; + r =3D m; + } else { + l =3D m + 1; + } } =20 - return libbpf_err(-ENOENT); + return btf__type_cnt(btf); } =20 static __s32 btf_find_by_name_kind(const struct btf *btf, int start_id, - const char *type_name, __u32 kind) + const char *type_name, __s32 kind) { - __u32 i, nr_types =3D btf__type_cnt(btf); + const struct btf_type *t; + const char *tname; + __s32 idx; + + if (start_id < btf->start_id) { + idx =3D btf_find_by_name_kind(btf->base_btf, start_id, + type_name, kind); + if (idx >=3D 0) + return idx; + start_id =3D btf->start_id; + } =20 - if (kind =3D=3D BTF_KIND_UNKN || !strcmp(type_name, "void")) + if (kind =3D=3D BTF_KIND_UNKN || strcmp(type_name, "void") =3D=3D 0) return 0; =20 - for (i =3D start_id; i < nr_types; i++) { - const struct btf_type *t =3D btf__type_by_id(btf, i); - const char *name; + if (btf->named_start_id > 0 && type_name[0]) { + start_id =3D max(start_id, btf->named_start_id); + idx =3D btf_find_type_by_name_bsearch(btf, type_name, start_id); + for (; idx < btf__type_cnt(btf); idx++) { + t =3D btf__type_by_id(btf, idx); + tname =3D btf__str_by_offset(btf, t->name_off); + if (strcmp(tname, type_name) !=3D 0) + return libbpf_err(-ENOENT); + if (kind < 0 || btf_kind(t) =3D=3D kind) + return idx; + } + } else { + __u32 i, total; =20 - if (btf_kind(t) !=3D kind) - continue; - name =3D btf__name_by_offset(btf, t->name_off); - if (name && !strcmp(type_name, name)) - return i; + total =3D btf__type_cnt(btf); + for (i =3D start_id; i < total; i++) { + t =3D btf_type_by_id(btf, i); + if (kind > 0 && btf_kind(t) !=3D kind) + continue; + tname =3D btf__str_by_offset(btf, t->name_off); + if (strcmp(tname, type_name) =3D=3D 0) + return i; + } } =20 return libbpf_err(-ENOENT); } =20 +/* the kind value of -1 indicates that kind matching should be skipped */ +__s32 btf__find_by_name(const struct btf *btf, const char *type_name) +{ + return btf_find_by_name_kind(btf, 1, type_name, -1); +} + __s32 btf__find_by_name_kind_own(const struct btf *btf, const char *type_n= ame, __u32 kind) { @@ -1006,6 +1045,7 @@ static struct btf *btf_new_empty(struct btf *base_btf) btf->fd =3D -1; btf->ptr_sz =3D sizeof(void *); btf->swapped_endian =3D false; + btf->named_start_id =3D 0; =20 if (base_btf) { btf->base_btf =3D base_btf; @@ -1057,6 +1097,7 @@ static struct btf *btf_new(const void *data, __u32 si= ze, struct btf *base_btf, b btf->start_id =3D 1; btf->start_str_off =3D 0; btf->fd =3D -1; + btf->named_start_id =3D 0; =20 if (base_btf) { btf->base_btf =3D base_btf; @@ -1715,6 +1756,7 @@ static void btf_invalidate_raw_data(struct btf *btf) free(btf->raw_data_swapped); btf->raw_data_swapped =3D NULL; } + btf->named_start_id =3D 0; } =20 /* Ensure BTF is ready to be modified (by splitting into a three memory --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f175.google.com (mail-pl1-f175.google.com [209.85.214.175]) (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 8F76535CBAA for ; Fri, 9 Jan 2026 13:00:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963626; cv=none; b=q0mg/eT0lweVqBfT1LkG9xDXQn48V0nO030ClBxFdj4tUsIr7eb/+H76LUL6QqBX+iGDrC9j5xmZdHEFD6E/sbdhOpdS0yj0VU5HaMakq/wzy5+NfdGzEYnhyn1YcnAG19XzLU0d9wB9poSGpyiUHGZ9bTk6AQBqNwKo3QDbM2g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963626; c=relaxed/simple; bh=fY4SCqw0Jj0ycW7LlAgR+ivoerZhzv0oqJ15lIreNgU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=mhKeug6oMFKl7KOdgVnophBrlgitVUxVSHoC4yi4ZxVcHRiBv4m42Owtx+g3R4SHx6HUbTxmh6+2E7BwcZoe7Rf8ahSXNECHSSUJP7GCVCwjc2yidko+Ft/26uZVf6cXCBnRQgO4FzRU9y0wXBZQuy68EzFkTwrhkb8nCKP08es= 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=ijRnA9f9; arc=none smtp.client-ip=209.85.214.175 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="ijRnA9f9" Received: by mail-pl1-f175.google.com with SMTP id d9443c01a7336-2a0bae9aca3so29661495ad.3 for ; Fri, 09 Jan 2026 05:00:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963625; x=1768568425; 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=Wivrf32mp+JOZE3ooRkX5rorWk008Ji1LAtUMbmfi0s=; b=ijRnA9f9i8BQUmREMnx5/t4J+B5kGmiKmNFHAAUt5//eYtLcThFSVjH256FmPubtUF xj67Tja8P1wgA6s5qUWG1oOl5YsSiJXDASLNNG0NR34ZKHu5fZUWmf/0479DGiyBPCRG QBflq9gGBGIpnwC1sHGq1ohmB2UftMznRJ1dX1M63gDRo6subuodHPQYNVoXVAxXJTw7 8lAdP2fSKlrq73rL2uxzAhbNcQl5c/M1LZXwHGo0gGq1+Fw7VlN3Dt8dQWpn/2vpZj60 6//yL06BB0GswdXIEemiXwlbCh221Sy8xjLMPDjzqd7k12s+FYAi5RZwpg6xEI+jkXYK Nntg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963625; x=1768568425; 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=Wivrf32mp+JOZE3ooRkX5rorWk008Ji1LAtUMbmfi0s=; b=P24/nDMG6EOCt+dozm9bR4kBMrxmzpzXFy6uttqYzc3NJ+lDZUkhL3vd/WStXc+FTo m1Y2zb37JLgVz2u46G4Uj/s6ESVL1loUMrQsyE1lqdXmGuQsCLA6mQGttgkxr3ZvLOJp RWyoS2oeX6QrD8Oa4FbwtdcfwjNJ88zvKQwAEhbSrlNaxmzIgeAi28PT/lSi50DYkv1P 1/CWbkD/eJy3m9LVgj4BhG7KNTSitw70NwgVV7a5gEwdcORxm536N8bR6RZ17SDrOpfW +qKdUKlvlwjZ0L6Itif4kj5jY2CddAjAD5310MHxmLd6F5Rpr02XzpmFLSKfq2MpCNKQ pFKg== X-Forwarded-Encrypted: i=1; AJvYcCX2osLlq6xcIXiNpZMHp43afnLqEAvc6bRCBeJ5lZjVYzvh8J2N8CyOJW4nYOwxBA2GtEP/m9hsKnmGl/Q=@vger.kernel.org X-Gm-Message-State: AOJu0YwdhoBz6H7qtuIy0o/GCHt9kla+5xn8ccitnFSluQwYyQ5HGWBc 3C0St5lk2G/KJUMQyHsTJ8z8sobexa586XXusUk5OmXbtfy5q9Lwxn2g4n1PgQkYzu0= X-Gm-Gg: AY/fxX6IelmIbNZRSMpvibaTv/4+qCgpRpPPiIXrjFysjJp5FbITTdLUbN+hrNfTD7X wrH+a8WbJ+s2KignqdGOEs+z+91F/7asEYoxjfp3i5ca80tG0UqMP8TJK/c2pGca0cjSTZ5pAUY X9LQU1cLD7CcOk+j/k5ZmTa85BYZcXaCsFPINiTUAzY29tISIS/KyVEfyjUJX0bw/84Q28dyjGe ooS1ayDplxPONELQAQhjfgzb4p9mkpAmkUvswYb9X/AIfAiabKUKfi/cZhZSSuKvrrVrBOfzqN0 JyffMteD8n3L03c0V29CgqflqJFS7TpuPfsks7ol/aZ2XCQ3SAwwEXg565cUUHIgEvVUWjiLgTZ eCMUqozGnnaO/JfD1IdNRKpvrLjNMBpWO4UOIm6m5E4C15Y4W4NftrBT7WcD/tnnfQtLeYC1PA6 QY29UD9+H+9ODtFqEmKQaUsE3GOsk= X-Google-Smtp-Source: AGHT+IFjhcrfN6VEyGHpwi6WOA2pu0tBfNL1P3vPmYQwVhUTFDIX7kF8O3o8DgZ/DuuiiTu25Bv5Bw== X-Received: by 2002:a17:903:1aab:b0:29b:e512:752e with SMTP id d9443c01a7336-2a3ee4dca3bmr100294515ad.47.1767963624328; Fri, 09 Jan 2026 05:00:24 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:23 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 05/11] libbpf: Verify BTF sorting Date: Fri, 9 Jan 2026 20:59:57 +0800 Message-Id: <20260109130003.3313716-6-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch checks whether the BTF is sorted by name in ascending order. If sorted, binary search will be used when looking up types. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 02407a022afb..9a864de59597 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -899,6 +899,30 @@ int btf__resolve_type(const struct btf *btf, __u32 typ= e_id) return type_id; } =20 +static void btf_check_sorted(struct btf *btf) +{ + __u32 i, n, named_start_id =3D 0; + + n =3D btf__type_cnt(btf); + for (i =3D btf->start_id + 1; i < n; i++) { + struct btf_type *ta =3D btf_type_by_id(btf, i - 1); + struct btf_type *tb =3D btf_type_by_id(btf, i); + const char *na =3D btf__str_by_offset(btf, ta->name_off); + const char *nb =3D btf__str_by_offset(btf, tb->name_off); + + if (strcmp(na, nb) > 0) + return; + + if (named_start_id =3D=3D 0 && na[0] !=3D '\0') + named_start_id =3D i - 1; + if (named_start_id =3D=3D 0 && nb[0] !=3D '\0') + named_start_id =3D i; + } + + if (named_start_id) + btf->named_start_id =3D named_start_id; +} + static __s32 btf_find_type_by_name_bsearch(const struct btf *btf, const ch= ar *name, __s32 start_id) { @@ -1132,6 +1156,7 @@ static struct btf *btf_new(const void *data, __u32 si= ze, struct btf *base_btf, b err =3D err ?: btf_sanity_check(btf); if (err) goto done; + btf_check_sorted(btf); =20 done: if (err) { --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f177.google.com (mail-pl1-f177.google.com [209.85.214.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 991F135CBD6 for ; Fri, 9 Jan 2026 13:00:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963631; cv=none; b=r3JvQhsdiqwGylI4fUF2Dd/ZbRU1X5BlvEyIOilxypU9Aj4TqESsUxQJleni7xH9soopetYIFnjWGuUEabDz5ExpSvlmgV5XqYD0N7Vi3DZiVka7meManHkwuffu7/Vf1wTKDkHTbZ2n4DczrQGUs991UALcHoQYY1N94b1GmRk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963631; c=relaxed/simple; bh=c745HJ4eBL9O6dcjNGxahlJgFWWLs7lhqs1RisTI0i8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=k8fqCNPfmAjLXqnDVtPcBKh6pw/u2K9nQFyMmxXqaeR5BM/1Oyp6uwLQbo+2S7hLgenexrGJZP3ybkpPj+/v8jCBIxxTnRqa03bw1RFuivUtWklcjt3ezYv6+MLwsp3Ok5BOBV/Xju9EEiPoYxacPwwifePyFqxw1FmgUPndxoc= 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=OnFgMcuA; arc=none smtp.client-ip=209.85.214.177 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="OnFgMcuA" Received: by mail-pl1-f177.google.com with SMTP id d9443c01a7336-2a0bae9aca3so29662055ad.3 for ; Fri, 09 Jan 2026 05:00:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963629; x=1768568429; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=QQrwHecK7iJFotsalH69RC9yNT/x39b0nH1K09oW1Js=; b=OnFgMcuAiDhCqKAnfRzu0ej65dFsrGOItfSUTbaRbxX9pZD+2SxqUGt1v9sYFUsUsQ BL/XEYMTEQcGhGTi9rZqQJxLC00bxUVGyGrUUFWsRjfKIZhs1VR37vG86xKiIJcpstHp Of7xxvZ+rQIRC+pfPEBUtk4EjiC07yhTEHL6MzQg+e4PuicBZ9xgtHKzdFxOk5geMgS6 r/XJfayqDZQNosJ9s6Ne1l6vhczQ+iKUUZzUVDxtfLwFznSip2zI2Ojwgw1+8EdASFoL sRcZG66J1QZujWLpSsm8tkNozmVwST3gHQ/AhioDkoe4vF2nO1nPGTaaXnOA1x8PMW/R W7pw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963629; x=1768568429; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=QQrwHecK7iJFotsalH69RC9yNT/x39b0nH1K09oW1Js=; b=F5zIjIS2kcDMwG/QeVnsm9vdT+nF8sIxeJzCvVuTeejFQX6Jl2l5WnDeLAVyEvJNfT VmolklITo7SU/9KIkQX66SSt3y+J+Vcrfq9M/2MopX+L4PPf/Vc5u1azqACLz59PCr35 lqVFCretVvthLSekIBVTH0pT7DBeZjMsEug0renT3+yA8CxgKu8m9QnXLprS5Qh2RwsO 6eUl9jlQZNpwkEzbCUEaKV45pcdOxVAymOQsWhxhKyXBYKoWNiHG5Iy/6TxdmlWl3UCf dNbQ5YHh1PkCxA230zLXBsnIFvurajegQ8TQjtQ44LW0V4kgSbhXHIq0EmJ0N5d56/lG B/4g== X-Forwarded-Encrypted: i=1; AJvYcCWHancLxIMFGsP176PSgusLUDtJWUFwVhy0YlUsl6GT/2cFQDKPP3E99nFQQXVcRu/u720X8/kObfwP7dg=@vger.kernel.org X-Gm-Message-State: AOJu0YzsAaTIrtOBnjZYWkhk0+Aq9GiIW2rr9EEdcTddKgTavO77aIxM 7tzJKbHBwLGRFFeb9NmEXQEuRB/6K+OQMMwDwZ00PaP/L0a9ZpZDoCDU X-Gm-Gg: AY/fxX6pzWrXawkIP9JD0u2c2w3boZ3QWIAMTilriJHlALi53HFsFz/ZJ5UM0iDLN6k FG0tvob8Yw+7ID36B/GpYNQOqpLxyVVztAi9p8psBPsJ2rQJ+3KzuHcYvWpz+HmUg2ham5qK12/ x7hXtl+8ZiwMuhvezIzdx0q+NxbOrlxUwOfB5oHvbygiEXalscYXET2jTgA5CyBhFef+Cc/KRBy HP8hZAGuY2Cb3dqUgcf6YXkt1YAtawGIMH4T7RFAc5MVrA1xhUY5cufMIEH1ncmN+P9y1OMPpZl BsgxV/CaF6bXpcLv+z1iKNQRDaETFCIjbkqPExOHjOYtkdGLeh9Jd5zIBe0tQ3LE6QZ5YRQr2DB lJveOh8J7QhGAQOcTo9BzRf/WjcWT09RiJcMsqyxduxNBl58XiYEs2bSxEXfDrJ0UsUd8sS63If byl66QA+ZE2CNHEYc160m52NeqL6o= X-Google-Smtp-Source: AGHT+IH8r5Jl7OK/ko7OkHT0W07SkTpKr6K3Cb2AERKmBWRtYdKBRTbXr2RD8AFzYRrwDu33anvYvQ== X-Received: by 2002:a17:902:c402:b0:2a0:97d2:a265 with SMTP id d9443c01a7336-2a3ee452277mr89382755ad.14.1767963627294; Fri, 09 Jan 2026 05:00:27 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:26 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 06/11] btf: Optimize type lookup with binary search Date: Fri, 9 Jan 2026 20:59:58 +0800 Message-Id: <20260109130003.3313716-7-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Improve btf_find_by_name_kind() performance by adding binary search support for sorted types. Falls back to linear search for compatibility. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng --- include/linux/btf.h | 1 + kernel/bpf/btf.c | 91 ++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 83 insertions(+), 9 deletions(-) diff --git a/include/linux/btf.h b/include/linux/btf.h index 691f09784933..78dc79810c7d 100644 --- a/include/linux/btf.h +++ b/include/linux/btf.h @@ -219,6 +219,7 @@ bool btf_is_module(const struct btf *btf); bool btf_is_vmlinux(const struct btf *btf); struct module *btf_try_get_module(const struct btf *btf); u32 btf_nr_types(const struct btf *btf); +u32 btf_named_start_id(const struct btf *btf, bool own); struct btf *btf_base_btf(const struct btf *btf); bool btf_type_is_i32(const struct btf_type *t); bool btf_type_is_i64(const struct btf_type *t); diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 539c9fdea41d..d1f4b984100d 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -259,6 +259,7 @@ struct btf { void *nohdr_data; struct btf_header hdr; u32 nr_types; /* includes VOID for base BTF */ + u32 named_start_id; u32 types_size; u32 data_size; refcount_t refcnt; @@ -494,6 +495,11 @@ static bool btf_type_is_modifier(const struct btf_type= *t) return false; } =20 +static int btf_start_id(const struct btf *btf) +{ + return btf->start_id + (btf->base_btf ? 0 : 1); +} + bool btf_type_is_void(const struct btf_type *t) { return t =3D=3D &btf_void; @@ -544,21 +550,85 @@ u32 btf_nr_types(const struct btf *btf) return total; } =20 +/* btf_named_start_id - Get the named starting ID for the BTF + * @btf: Pointer to the target BTF object + * @own: Flag indicating whether to query only the current BTF (true =3D c= urrent BTF only, + * false =3D recursively traverse the base BTF chain) + * + * Return value rules: + * 1. For a sorted btf, return its named_start_id + * 2. Else for a split BTF, return its start_id + * 3. Else for a base BTF, return 1 + */ +u32 btf_named_start_id(const struct btf *btf, bool own) +{ + const struct btf *base_btf =3D btf; + + while (!own && base_btf->base_btf) + base_btf =3D base_btf->base_btf; + + return base_btf->named_start_id ?: (base_btf->start_id ?: 1); +} + +static s32 btf_find_by_name_kind_bsearch(const struct btf *btf, const char= *name) +{ + const struct btf_type *t; + const char *tname; + s32 l, r, m; + + l =3D btf_named_start_id(btf, true); + r =3D btf_nr_types(btf) - 1; + while (l <=3D r) { + m =3D l + (r - l) / 2; + t =3D btf_type_by_id(btf, m); + tname =3D btf_name_by_offset(btf, t->name_off); + if (strcmp(tname, name) >=3D 0) { + if (l =3D=3D r) + return r; + r =3D m; + } else { + l =3D m + 1; + } + } + + return btf_nr_types(btf); +} + s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind) { + const struct btf *base_btf =3D btf_base_btf(btf); const struct btf_type *t; const char *tname; - u32 i, total; + s32 idx; =20 - total =3D btf_nr_types(btf); - for (i =3D 1; i < total; i++) { - t =3D btf_type_by_id(btf, i); - if (BTF_INFO_KIND(t->info) !=3D kind) - continue; + if (base_btf) { + idx =3D btf_find_by_name_kind(base_btf, name, kind); + if (idx > 0) + return idx; + } =20 - tname =3D btf_name_by_offset(btf, t->name_off); - if (!strcmp(tname, name)) - return i; + if (btf->named_start_id > 0 && name[0]) { + idx =3D btf_find_by_name_kind_bsearch(btf, name); + for (; idx < btf_nr_types(btf); idx++) { + t =3D btf_type_by_id(btf, idx); + tname =3D btf_name_by_offset(btf, t->name_off); + if (strcmp(tname, name) !=3D 0) + return -ENOENT; + if (BTF_INFO_KIND(t->info) =3D=3D kind) + return idx; + } + } else { + u32 i, total; + + total =3D btf_nr_types(btf); + for (i =3D btf_start_id(btf); i < total; i++) { + t =3D btf_type_by_id(btf, i); + if (BTF_INFO_KIND(t->info) !=3D kind) + continue; + tname =3D btf_name_by_offset(btf, t->name_off); + if (strcmp(tname, name) =3D=3D 0) + return i; + } } =20 return -ENOENT; @@ -5791,6 +5861,7 @@ static struct btf *btf_parse(const union bpf_attr *at= tr, bpfptr_t uattr, u32 uat goto errout; } env->btf =3D btf; + btf->named_start_id =3D 0; =20 data =3D kvmalloc(attr->btf_size, GFP_KERNEL | __GFP_NOWARN); if (!data) { @@ -6210,6 +6281,7 @@ static struct btf *btf_parse_base(struct btf_verifier= _env *env, const char *name btf->data =3D data; btf->data_size =3D data_size; btf->kernel_btf =3D true; + btf->named_start_id =3D 0; snprintf(btf->name, sizeof(btf->name), "%s", name); =20 err =3D btf_parse_hdr(env); @@ -6327,6 +6399,7 @@ static struct btf *btf_parse_module(const char *modul= e_name, const void *data, btf->start_id =3D base_btf->nr_types; btf->start_str_off =3D base_btf->hdr.str_len; btf->kernel_btf =3D true; + btf->named_start_id =3D 0; snprintf(btf->name, sizeof(btf->name), "%s", module_name); =20 btf->data =3D kvmemdup(data, data_size, GFP_KERNEL | __GFP_NOWARN); --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f179.google.com (mail-pl1-f179.google.com [209.85.214.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 49D7435C1B8 for ; Fri, 9 Jan 2026 13:00:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963632; cv=none; b=OC1T48HGcu2ugXQch5PJvWOzSlsUFh8otzeet/pfid8xHVgNwzJLtBTkQBe11P0Fq4rqiK1MT3x1bwrmUTOHCPbpd3NQnXobc+ChYj34JEmyyIR+FC7MWxb5pNMg3HiZc9q/EKeZ2gsou7V5yLfC6epXPPeNeTU7R/HRBEHxA3g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963632; c=relaxed/simple; bh=mYzJ+kJtBrf1ZOrVJNkEAMPCA73IwwJ3Vq1Lvdq2Ri0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=joTSfhjKWGHa19v6aMGmxyzXmFjj+AY1AWUwYtbvgnYpjHQkIRPO+P51z5wCoT6d+uJuVS86pwWiEYeE8tdcauhM8pciPBPiNYdsJ7jMJftn9+zv7Szfd82Ol6w8+Cx+F1Ud5K6h+H8zOBLb6AwIkLNk4saHVrPMBfF9JL0XQzM= 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=MZTOBZn3; arc=none smtp.client-ip=209.85.214.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="MZTOBZn3" Received: by mail-pl1-f179.google.com with SMTP id d9443c01a7336-2a0834769f0so31985155ad.2 for ; Fri, 09 Jan 2026 05:00:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963631; x=1768568431; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=TUW7LB43dCgnLiOgR7S2ttrd8S36AZDQc8SQtsp0WmA=; b=MZTOBZn39HLC/jnQgGqREw3LqW29Y6bNB+PAzbre8wyPQkFmeoYjL/sQMMd4nYuJIR IJCsyfMqYNV9GCWUCiH2PH0O6UOhZGLpfZ2gIS4Q+uP3vKAcdh/yqeIoJU4Ee4Um90br yfnYhU7lcifIvnkc0mtXeTL0uFcl2IwGS4KSLHijtML68neuiAywg2IBRQMagyVM8/yh 3e0scd3JWdAo/aOA82zVvucDmB6OG+QMMBjnbdsAjHbdMhziiatwMZCWeiACkY2lmAJw wEFOEjQDHxK81ukldOMmzG5MBSk11zUjvOMSRRoOJzsOPt8sp/8cF/whlt/geBLcDv8e VqCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963631; x=1768568431; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=TUW7LB43dCgnLiOgR7S2ttrd8S36AZDQc8SQtsp0WmA=; b=BCzwkYAAzAjLTryP+rP6B2bAKaawymD4hZfcFxE9eZ71JiPbu+EWNEkbSgM2qognWS pI4eEoW4nuK8BLOIkI1EKoj/EFPu7NVTWEXcXgoKsknZFZ6jfS7tWyr4efrggKs2DvCQ Eg61ucQmjn+MxWi8CdBcyFhR8M+QzE9emRJwyldpN/4qLCdjkFVUrJ1PqFiVPbTXJN7b gv5R3KeaWBQrK8i+YiELgr6CnTUfwWeFSVOV1y/ciepy2uuZ0HNbiyy6k4rYXWGEN99M smkZjQ1dmN+ZQgE4oqA1a2/nGvI9iEDq1HWPQ1q/1jRtDB987VstYnkAB59vTGay3U68 fuLQ== X-Forwarded-Encrypted: i=1; AJvYcCWe2v7wVkmiPvzYbqm0dXCYZsJp8CYzgGiaL6DNgL8Z8Q8ziH+e+dqiCRYUiAMtrOk/8QtvFWuuAFNgkJY=@vger.kernel.org X-Gm-Message-State: AOJu0YzJ6YkqNXaqqGwX4HqbCWgy62qazUkr3xIt5wakeBf7/xddRB/k 95kNv4Oljd03nVN5kq3+Y4qDoc5CW5MQGBa6Te6/40ws9xVSmBtD5L/J X-Gm-Gg: AY/fxX55f0x1gc1O1s9iDNVV8lneBCimF8723TGEdMRsbjPfBs4NnuqW3Ua8IVox+Ga anCNNm92VQuqjJDFIpj8EKlpiAx0idygsiM99YGstq9Nwz9YvGeFAFwFb0PIHpFR2xVGUsWEXpd Gfh5Hu5CADc9nP69WyNSYgkdOqwOTxCEf5wA9X5nT5UtXwc0nAwmsRXr+8O2CKdHT/Wz+LBSQs2 1HUzMiDpsRvDPcqk86qkNVvVPrEocueZCpTBBvgjCVxsqesMZErqHxu7pNLpjsFa+ErBAY2aHAF MamKopDwNw5qoUH1/T9PgRYqTxHjL80EWVwLTpFWHNlMwYKbVtkQBUkg97Co2zlyytN+56x8OJ8 iIGb8nlAqbX5BNKkJhP+VRrVlob0EmBuh22K1RVnkcHhKiIA3gFfjKMkhM1ANtMdeLrtR/QLZNu ikCdGz+Cp8/OouDzinGo/af63RY8g= X-Google-Smtp-Source: AGHT+IFZdcePi4FWnR5ODfZLAiRMhV1+kMAPOJFuJ1swEbYXGuIYwPL7AAx1NXjqZtbj+QKXNQIdGg== X-Received: by 2002:a17:903:38cc:b0:2a0:e5da:febf with SMTP id d9443c01a7336-2a3ee4aaa9cmr92963955ad.46.1767963630236; Fri, 09 Jan 2026 05:00:30 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:29 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 07/11] btf: Verify BTF sorting Date: Fri, 9 Jan 2026 20:59:59 +0800 Message-Id: <20260109130003.3313716-8-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng This patch checks whether the BTF is sorted by name in ascending order. If sorted, binary search will be used when looking up types. Specifically, vmlinux and kernel module BTFs are always sorted during the build phase with anonymous types placed before named types, so we only need to identify the starting ID of named types. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng --- kernel/bpf/btf.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index d1f4b984100d..12eecf59d71f 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -550,6 +550,46 @@ u32 btf_nr_types(const struct btf *btf) return total; } =20 +/* Note that vmlinux and kernel module BTFs are always sorted + * during the building phase. + */ +static void btf_check_sorted(struct btf *btf) +{ + u32 i, n, named_start_id =3D 0; + + n =3D btf_nr_types(btf); + if (btf_is_vmlinux(btf)) { + for (i =3D btf_start_id(btf); i < n; i++) { + const struct btf_type *t =3D btf_type_by_id(btf, i); + const char *n =3D btf_name_by_offset(btf, t->name_off); + + if (n[0] !=3D '\0') { + btf->named_start_id =3D i; + return; + } + } + return; + } + + for (i =3D btf_start_id(btf) + 1; i < n; i++) { + const struct btf_type *ta =3D btf_type_by_id(btf, i - 1); + const struct btf_type *tb =3D btf_type_by_id(btf, i); + const char *na =3D btf_name_by_offset(btf, ta->name_off); + const char *nb =3D btf_name_by_offset(btf, tb->name_off); + + if (strcmp(na, nb) > 0) + return; + + if (named_start_id =3D=3D 0 && na[0] !=3D '\0') + named_start_id =3D i - 1; + if (named_start_id =3D=3D 0 && nb[0] !=3D '\0') + named_start_id =3D i; + } + + if (named_start_id) + btf->named_start_id =3D named_start_id; +} + /* btf_named_start_id - Get the named starting ID for the BTF * @btf: Pointer to the target BTF object * @own: Flag indicating whether to query only the current BTF (true =3D c= urrent BTF only, @@ -6302,6 +6342,7 @@ static struct btf *btf_parse_base(struct btf_verifier= _env *env, const char *name if (err) goto errout; =20 + btf_check_sorted(btf); refcount_set(&btf->refcnt, 1); =20 return btf; @@ -6436,6 +6477,7 @@ static struct btf *btf_parse_module(const char *modul= e_name, const void *data, } =20 btf_verifier_env_free(env); + btf_check_sorted(btf); refcount_set(&btf->refcnt, 1); return btf; =20 --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f175.google.com (mail-pl1-f175.google.com [209.85.214.175]) (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 2728035E53B for ; Fri, 9 Jan 2026 13:00:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963636; cv=none; b=kxV2TCHxdNQOPnwnRX9BQJkdGYmTb7Yp9itMzCcYN0vyrfU5K1TDrzInxnHCMTkgQFQwwkdJe+StvYFqDNxczNtCw/lnh/fwUYbd3E5yYkoaitO7ctOIMUmCCBzRF7bS+lHcSFyEANBu8Ybyxv5dYpLCKQggxnuGrGGplfqvGuQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963636; c=relaxed/simple; bh=I7eY37GsTyoXAh2wI+oSWMcZ+lGsgT+0+h2fMUYmJ2s=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=gArRODnL/AN9TYNOvUVew4/+oQMbEhlFf5TKWzPhk1W0w13v1kmK3rAVB1rzB5wNSdLDeEhMe0E2Duhj/tDWk7jNGHBdg5+PCX6VdjKcX09ldhzlz6rd+gRCvelLYBvnmXNUZ1IHEFvZxloKH9qZJ0KFwxEoshR4kW9AI/ddtUc= 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=SksYxhhm; arc=none smtp.client-ip=209.85.214.175 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="SksYxhhm" Received: by mail-pl1-f175.google.com with SMTP id d9443c01a7336-2a3e76d0f64so14126895ad.1 for ; Fri, 09 Jan 2026 05:00:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963633; x=1768568433; 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=3mmxvmI6t4HDfgNI7x8o7q25F6wuDxougz7BYJ8lGNw=; b=SksYxhhmwwRk/L+yd7O3uO8/vCTdT/IHEd2MkMxAaxMCkC9VwByAdYKaCqsKMD5V3q wA5P6yv/Cg714ntI2a5x24zttVbDCcrm9Y7eLiVqGLjX1YSr7CM6FHq908htKXepEsvs C09Cdn1np8kLEQzLGHafs6Woy53hbN2KfUtCm2kTm7q0RKIa/9dw+zVB2HmbtWuuL9XY xpV2HzfVYJPdxXncS2th1cHOQb6nl8ArsmLHnHyefYwcLIta0fHLw5+YgyUuGY5QmcjL QV9kltw4rDfv+qO/DRb0M7xCoi2oUX0R5EXwtVDcR8vuoUhANVA4VriNmfVHvwbs22Qe PwoA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963633; x=1768568433; 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=3mmxvmI6t4HDfgNI7x8o7q25F6wuDxougz7BYJ8lGNw=; b=Tva05MtYnu1+FI9fCOYb95vI22SQQ1rXNQFUt7eGFpQRoS3zp3k9tOynCarp+HSk5C Kzk3EKl1uqPlIlMcvib1wlUTYmIlVlpf6DJkcIkVUzT4Nl4j+IG8YY9vrJ0x6+UwxuCu W+SGHi9F/ihq4nD2DYBbxwLddXtkHEdwyyHej7nmiqNJEznqgcQReTo31eDzto83SS9G +x7r5fKC3hOex+5gZtPGLPG95wmOSbIQxtrVwkLrPkB1Nq+o21CmjiDK1xDjk71Aakbo +mQlbXdJ1ldgmVVRXZLISHH3r/cttyq0EdW5i9d06TBeyUr60g+2KFU1dVaug0UIe2t8 n93g== X-Forwarded-Encrypted: i=1; AJvYcCUU98gcGeIhuoieiqQOtXWSFSdchvGayO8csMsHOofTRaN7XVokwNqPk+bGO82ByLK79a/AuJr6PBTWAdM=@vger.kernel.org X-Gm-Message-State: AOJu0YxoIfLWzSRRQ3ZL2RfhaowyeCbbf9FC0O/rgbwrwzKRFmwva/+M BB7vggVGKGii2N7F+rqCcUDEWgqQ1mQiVMehDcPqHppB46y0xL7H6yj2 X-Gm-Gg: AY/fxX7mFzsqAIz+FkGPfR8miDvjmFXlQ/aUzAibZvIAHMFPWJtxdA9ewSZMtmV2g5V DUeX0gc1M76IwI1tsUuf2DnCt+fUIdOkCVfQK5fyrWuX/i3V2X4LX1DOJIInHITEiv/oEzaN0lt M5gdo0Izv3bXH/cPBkP91eopAHKf6fkg54nBzKPx++w49vyvVwnsosRFPOzpUhJuf7sbTpTcq7S b0yLUly08h1LMVT8Xi8P6jk9d1NjlRd2EBnn9iAzBdKfnPgF1wxlbHz2Bq42hc964yX8ViV57jY XC5GyLuW5/82UHt5OI1VvRl8rStC42A5fmBlwSVscYihZhxX+6eZVhaR+6jgYocvLh1D9I8gdjb YlYIhGMT7XeYmGMgh5NEWNpkRqeF1QoTypS6zQFhngNPb0X7L2dXAGSnYlJcj40ZgkSQiCzKWNR VJ/Y5Qal+B4G2rPjndySoaLjKFKus= X-Google-Smtp-Source: AGHT+IFoDc8zaNyyFce5gCCCHC7gM3YATlAegS9bI1XtcQ7NPXKyJ161Oc8IFC3/EUDLdresQG1BLg== X-Received: by 2002:a17:903:350d:b0:269:7840:de24 with SMTP id d9443c01a7336-2a3e39e5b74mr113131885ad.21.1767963633180; Fri, 09 Jan 2026 05:00:33 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:32 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 08/11] bpf: Skip anonymous types in type lookup for performance Date: Fri, 9 Jan 2026 21:00:00 +0800 Message-Id: <20260109130003.3313716-9-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Currently, vmlinux and kernel module BTFs are unconditionally sorted during the build phase, with named types placed at the end. Thus, anonymous types should be skipped when starting the search. In my vmlinux BTF, the number of anonymous types is 61,747, which means the loop count can be reduced by 61,747. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- kernel/bpf/btf.c | 10 ++++++---- kernel/bpf/verifier.c | 7 +------ 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 12eecf59d71f..686dbe18a97a 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -3534,7 +3534,8 @@ const char *btf_find_decl_tag_value(const struct btf = *btf, const struct btf_type const struct btf_type *t; int len, id; =20 - id =3D btf_find_next_decl_tag(btf, pt, comp_idx, tag_key, 0); + id =3D btf_find_next_decl_tag(btf, pt, comp_idx, tag_key, + btf_named_start_id(btf, false) - 1); if (id < 0) return ERR_PTR(id); =20 @@ -7844,12 +7845,13 @@ int btf_prepare_func_args(struct bpf_verifier_env *= env, int subprog) tname); return -EINVAL; } + /* Convert BTF function arguments into verifier types. * Only PTR_TO_CTX and SCALAR are supported atm. */ for (i =3D 0; i < nargs; i++) { u32 tags =3D 0; - int id =3D 0; + int id =3D btf_named_start_id(btf, false) - 1; =20 /* 'arg:' decl_tag takes precedence over derivation of * register type from BTF type itself @@ -9331,7 +9333,7 @@ bpf_core_find_cands(struct bpf_core_ctx *ctx, u32 loc= al_type_id) } =20 /* Attempt to find target candidates in vmlinux BTF first */ - cands =3D bpf_core_add_cands(cands, main_btf, 1); + cands =3D bpf_core_add_cands(cands, main_btf, btf_named_start_id(main_btf= , true)); if (IS_ERR(cands)) return ERR_CAST(cands); =20 @@ -9363,7 +9365,7 @@ bpf_core_find_cands(struct bpf_core_ctx *ctx, u32 loc= al_type_id) */ btf_get(mod_btf); spin_unlock_bh(&btf_idr_lock); - cands =3D bpf_core_add_cands(cands, mod_btf, btf_nr_types(main_btf)); + cands =3D bpf_core_add_cands(cands, mod_btf, btf_named_start_id(mod_btf,= true)); btf_put(mod_btf); if (IS_ERR(cands)) return ERR_CAST(cands); diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 53635ea2e41b..53aa8f503775 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -20652,12 +20652,7 @@ static int find_btf_percpu_datasec(struct btf *btf) * types to look at only module's own BTF types. */ n =3D btf_nr_types(btf); - if (btf_is_module(btf)) - i =3D btf_nr_types(btf_vmlinux); - else - i =3D 1; - - for(; i < n; i++) { + for (i =3D btf_named_start_id(btf, true); i < n; i++) { t =3D btf_type_by_id(btf, i); if (BTF_INFO_KIND(t->info) !=3D BTF_KIND_DATASEC) continue; --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f178.google.com (mail-pl1-f178.google.com [209.85.214.178]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3E89535C1BD for ; Fri, 9 Jan 2026 13:00:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963638; cv=none; b=SvM6HPpznyagKW9MGxseTGi1YhFfx9BNlaXVezRNhU56Z6TjSYFGheS4ZT+sq2mYMu1e/Ao445S5WV0ChzpqNyk11zpo9ceS1bNqJBb6ab8GchauFduyhvzBufCP7UheF8nywW5xLaDMomSZk9XCa81DcncwE74EIbTJ0mAeb/c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963638; c=relaxed/simple; bh=PP4UHGdg2aJ+7TetAPvJTrpVWwYUmJgFr04BIdkvHYQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=R8FTtWRNbjY+TeOYeuV9QSg6dVkXUa5GzWMVAcFGNxW7HoB/HKuT3QWO33I2w8AC8T6o7T0tPF5EUrO2TfafUXKR6mtRR9B9pueGsthGI8uPzqOVUrLZUHT7Gz09RhRYwuXJbGJPmvowpkXF+0AfG3QSPbxRUCLuaxuostgBBtc= 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=dQza34Pt; arc=none smtp.client-ip=209.85.214.178 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="dQza34Pt" Received: by mail-pl1-f178.google.com with SMTP id d9443c01a7336-2a1022dda33so27485855ad.2 for ; Fri, 09 Jan 2026 05:00:37 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963637; x=1768568437; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ezrrIGR+HhUrN/b6TeSbq07sIHXRwZZn0egYDAnCwYw=; b=dQza34Ptgfm2HLpHyY5vPCUu9swGH0zgrOktnkOxtIc6DeNfanpblZHb784Q9tERkx KVVbgGOff2DfFMli0Pq+vkLTFToUg8HG7iVueYjnIB7s/dcsdkA4nKSF4iJDQHjuueNT PY4nC2+B5Dpd5ueZtTKCysUJAaCYtsN24Cn7jSBhIlSDzM5EVCQXvSrzcnJG5lapMMdY Gj4eBWV6PJlcpSMn6XThIRXUiq907O/uhhUfdgYIEO/S9rE/DB9/v1005TwW1plsyBs/ aaycURpzQSW7OZZf7mtoJZWjzbZyKkU3ekbULW2z/K2SBrJa0FXmygYSx4o09GWp0LmY hbeA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963637; x=1768568437; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=ezrrIGR+HhUrN/b6TeSbq07sIHXRwZZn0egYDAnCwYw=; b=Krzw8CeVVr2K2B62B9JsIHK3+6/AgEmtbO8wqE9yN3SmLGSItjkdKHXFYyoIp9j73B GuzNvGsNvNQGh8HjHbrkrI3tp+eA6+PuPe/5jJd0Y9T12O5Lha8L9aPCw60r+ZfJW2QJ f2RGdThfwTu0hedqZ7qZ0xp5zy2xM0pNl65Ub+HM7goaW/TQEsqPjJzmGuA9WJNv48e+ L3eq5jTJgyT/K5/+viL0qNlXZle18wi5SL/HKg+VcciXrAxpy4ERuExJ7C3hUsT63n8+ fknx3ZPNggvrHCwcJsko78wh3d0ucrWcmkCY0lunUshaDJXUy5PYqyRRmUrxXMqP1h+6 ZcZA== X-Forwarded-Encrypted: i=1; AJvYcCWeGzW0XE4SmTL5SG/DpY7XNJSen20pCYlxEHFMGmtYcIFUEZCb70HBu5l3GF/X1XlO2nP7voms7rJ19UM=@vger.kernel.org X-Gm-Message-State: AOJu0YyOCFi0pFXGIb9Qtj2a67I8MiiSGGYZpe8MszLSKTGUGn5adoA2 AFX682rNZZXWUoSosJMgvLViS0Y41Bn453v+BIyw74EiaDhYD2zfL3bI X-Gm-Gg: AY/fxX79dFCMd3079ZjVianlBu1mAnkligzE2AOp4U1ohDaCoYbAymVsrJDqCn9af5c p61S0jO3mIXPCDib73+ae+Gf8bHYG1nzydhkNb7VKVNfkJhDU/2xrtdXtwWfXgTk4dBR9uxOkDl wxejHvhRNwDvW7MCi1J8RCi8ejA7Nigq5flZ8/sOgH/tgFH054lsDzLBdg6H97A1lohFqhmfQha NUkzRlaic4JNVeC0MfYaCNLP2SfDYRhhMVHFLCLp/yjg54IUsWfFih4LBqxpGUF/SgYUy4Ps5iQ nazFU6NVm2yDfEPSpof/dsSCxucUgnAEZi/WHcydBchRLs68UFomOucsf6sASYnJoKYA3K5iCFd eRvaQlMNbVVmswmatSZmntSOGYLUNhCmIRQKuS/5dyTM0N1EI6elqThVdaI1q2+I0xcnORKGDDK o7Dhuimq5+nQHlVFqu0geTaGf0QWk= X-Google-Smtp-Source: AGHT+IHGtBK/QdskngOI5OKlKsTDyA39yJOP75NjonrZNih/ElHm8DB77Fgzhggt+tCVfNovhyx3wA== X-Received: by 2002:a17:902:cf06:b0:2a0:d662:7285 with SMTP id d9443c01a7336-2a3ee33e1aamr97569295ad.0.1767963636166; Fri, 09 Jan 2026 05:00:36 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00:35 -0800 (PST) From: Donglin Peng To: ast@kernel.org, andrii.nakryiko@gmail.com, eddyz87@gmail.com Cc: zhangxiaoqin@xiaomi.com, ihor.solodrai@linux.dev, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 09/11] bpf: Optimize the performance of find_bpffs_btf_enums Date: Fri, 9 Jan 2026 21:00:01 +0800 Message-Id: <20260109130003.3313716-10-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Currently, vmlinux BTF is unconditionally sorted during the build phase. The function btf_find_by_name_kind executes the binary search branch, so find_bpffs_btf_enums can be optimized by using btf_find_by_name_kind. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- kernel/bpf/inode.c | 42 +++++++++++++++++------------------------- 1 file changed, 17 insertions(+), 25 deletions(-) diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c index 9f866a010dad..005ea3a2cda7 100644 --- a/kernel/bpf/inode.c +++ b/kernel/bpf/inode.c @@ -600,10 +600,17 @@ struct bpffs_btf_enums { =20 static int find_bpffs_btf_enums(struct bpffs_btf_enums *info) { + struct { + const struct btf_type **type; + const char *name; + } btf_enums[] =3D { + {&info->cmd_t, "bpf_cmd"}, + {&info->map_t, "bpf_map_type"}, + {&info->prog_t, "bpf_prog_type"}, + {&info->attach_t, "bpf_attach_type"}, + }; const struct btf *btf; - const struct btf_type *t; - const char *name; - int i, n; + int i, id; =20 memset(info, 0, sizeof(*info)); =20 @@ -615,31 +622,16 @@ static int find_bpffs_btf_enums(struct bpffs_btf_enum= s *info) =20 info->btf =3D btf; =20 - for (i =3D 1, n =3D btf_nr_types(btf); i < n; i++) { - t =3D btf_type_by_id(btf, i); - if (!btf_type_is_enum(t)) - continue; - - name =3D btf_name_by_offset(btf, t->name_off); - if (!name) - continue; - - if (strcmp(name, "bpf_cmd") =3D=3D 0) - info->cmd_t =3D t; - else if (strcmp(name, "bpf_map_type") =3D=3D 0) - info->map_t =3D t; - else if (strcmp(name, "bpf_prog_type") =3D=3D 0) - info->prog_t =3D t; - else if (strcmp(name, "bpf_attach_type") =3D=3D 0) - info->attach_t =3D t; - else - continue; + for (i =3D 0; i < ARRAY_SIZE(btf_enums); i++) { + id =3D btf_find_by_name_kind(btf, btf_enums[i].name, + BTF_KIND_ENUM); + if (id < 0) + return -ESRCH; =20 - if (info->cmd_t && info->map_t && info->prog_t && info->attach_t) - return 0; + *btf_enums[i].type =3D btf_type_by_id(btf, id); } =20 - return -ESRCH; + return 0; } =20 static bool find_btf_enum_const(const struct btf *btf, const struct btf_ty= pe *enum_t, --=20 2.34.1 From nobody Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f194.google.com (mail-pl1-f194.google.com [209.85.214.194]) (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 3F32735CB64 for ; Fri, 9 Jan 2026 13:00:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.194 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963641; cv=none; b=PeTit1FBVJL21debv4Nlsv508oVy9PaM3KWIfWRM5eVht6YkhR1xWMJFY8zoLJpgtu/mmqozm84PUNY3n6XbVNf8gy+BSVhLsEB+8x3UMj+jvvn5CVUyzM6yMMDcYk/QIbIYq6Gd6ui9X7kyXVGTIKCfOfqwb7wSKP9/4CAhqHU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963641; c=relaxed/simple; bh=qFOiFrQ22bp9ubPDeW8ptesz6gYdsp1wUr4p9MOrwe4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=sM2ADtZ8njp5rMCJ8pFzx5ze5j2MhiQn4e0MCUbpWAVt0km1ukLleE/2V0RPTvSD/ZccvU8K99Jcyc6nDZU26P1sPZRC2Qe4NqbMjpEapvkMCrlzUmbS5L7xqw5uq/PgmsrEOssxZCbLUIsIGuEsBBxaR1Z8ZOcZ4DGraZV0rco= 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=R5+5jieY; arc=none smtp.client-ip=209.85.214.194 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="R5+5jieY" Received: by mail-pl1-f194.google.com with SMTP id d9443c01a7336-2a0d67f1877so35158885ad.2 for ; Fri, 09 Jan 2026 05:00:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963639; x=1768568439; 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=EDRdffxeTKmKE87zhNPKSisz6ECoek9qhLj1oBu4sdg=; b=R5+5jieYo/+P3mN5FwAfoVkjNxUJKdkKwq0VZUy5gVW2UVotL+tGROJ4u2LLNNTSzu /nk58E2jI0/oS+yrnLiRw2qRBD7RfRJK2u3zWf9oCufjVDayjozTGFUwjDblkfARhOAb N8iDhJS7u0KtrG05i6MSxcoqaXXQc7Tnxou5VITZrlkWX/T8sVIWmfT6DEZrH8caZb7u dzexERjjkH0m/R6iSpMuS2VCqpYU6AgmTrJYL+7VP/6jPpfFE1xm24g+M3UuzKdf921e En2qtBg3PLcVQDqb/x0aKYi2HGbCSlVlSduX+pyp4qTeqCdLgUZk+dpdpgXs2156XU3n iZuw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963639; x=1768568439; 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=EDRdffxeTKmKE87zhNPKSisz6ECoek9qhLj1oBu4sdg=; b=BRA07hQ97uvavFZKwBu8rCTIklQkW0XM3t2xa+XPk30HaIBrV3ppOiGnx8IdD+WkFa G7V1IXubll+DJHs4Yol4jBDI8chLqUvwi3/Nj4ZXADndaw6c6SVfZknjRLJ+6clIoIZG iLYtN6dopYkgOgNJ+jLwHJAvC+YTu6S56h6mtL3joMVZ9ps8/VELuLf0JqYyOSZPoqKx iTy8BcwKnJD3cakK3bl8BM3Nlg9C3vPQLdRjgAXv3ZKRL+15GX+S4+TdVQZcZ/ujOeTt 6NjCnt9wcpYnaj/5XJnIT0jvqSDR8c+pnMZKbvgeNn/98o7VWBIq5l4WKejKyFUkq4HA bM+Q== X-Forwarded-Encrypted: i=1; AJvYcCU/xm/vSgZ/yKBrwYqSdDDeTwaDZmVlgZ/raniqwEcqI7juOeUOdxvGSVUmvlT/lE1pl2IxHWjC1+A1Prc=@vger.kernel.org X-Gm-Message-State: AOJu0YwU8IZ7s1XN9yRepz2dxx20pO3mjVjPpNFtPWHuMo7o4XmNpfRe JfeFQr/h4vmgqj619segco6YF9wo5co8GOtdYzKpC2NcmFhQcJ8p6ICv X-Gm-Gg: AY/fxX5HlQgOn/ncpr151IQ8NSqzyaIB2+BwKZhNZv8fjUYBiVIS99NIalXuCgVGLtN SgZ8FRrMGCkD9QnwdWw40jWlajMTfCAFJCLIIN6h1PG31c8hdlY+jPZYp27n7Wr8Tz+A5ngyHFq eK+4AJAMYmDtqfG3bEmcm4ILWYcoP5j0NR9JTA+uhzcWQsoFnInd8OlYA0UPZ++yr4Lqu9uLrKt cInf9rvhlMqFag+DjUXzEeORFBml5CHTTY1GMVJa5KXw58hURon5vRDIOvEzzIAyHNn96zjYLih 5PWaXI+fM6syvYQu0YGHF95iLhVhFLpEr1/66rfYIH4D3JHBvdPpni5AUfBGVMhnRoZ+HXMFAlX 2ZS1nwdto97Tw6FChewXrHweh49ur7gkFiFe/lawlF3H9yYqN1opjZEbhpe68lBvBI9IyHOPrEo U7Q2hiRYIs3LdYWVaJMWP9GdA4d4Y= X-Google-Smtp-Source: AGHT+IFnznz6DyLtGA4vTT4bY5CXqP3/QuUv/y4X6750FOCEng8nQ9cRSwMuDPg3wuxcLWTEgVAF4w== X-Received: by 2002:a17:903:2448:b0:2a1:4293:beb9 with SMTP id d9443c01a7336-2a3ee4edf78mr78283995ad.58.1767963639357; Fri, 09 Jan 2026 05:00:39 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00: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, Donglin Peng , Alan Maguire , Andrii Nakryiko Subject: [PATCH bpf-next v12 10/11] libbpf: Optimize the performance of determine_ptr_size Date: Fri, 9 Jan 2026 21:00:02 +0800 Message-Id: <20260109130003.3313716-11-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Leverage the performance improvement of btf__find_by_name_kind() when BTF is sorted. For sorted BTF, the function uses binary search with O(log n) complexity instead of linear search, providing significant performance benefits, especially for large BTF like vmlinux. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman Acked-by: Andrii Nakryiko --- tools/lib/bpf/btf.c | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 9a864de59597..918d9fa6ec36 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 Sat Feb 7 06:14:11 2026 Received: from mail-pl1-f170.google.com (mail-pl1-f170.google.com [209.85.214.170]) (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 86D8B35EDCB for ; Fri, 9 Jan 2026 13:00:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963644; cv=none; b=YfJQvqi/388JhOSfnTbSsJO6soHCn5mtdGDGGt+XdydFPTxS0fCKdtFwc7NcyxGv0lPc4uyjZVk+lOzrh3FpN88yGLWMXXQMLLxb5iet4GBj111esQB/Vmce6T3cZjSCTJyJBvLVYKhXI51DW/dYwJTenOqtLu+yzOVvDgdeZJ4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767963644; c=relaxed/simple; bh=y+RkYpOAQ7uM/0ey3EZvsKbFdv6jknz7JJQBhw+sV0s=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=kayPgpH9+5/syRgC54p5hNUsFbbR6RF4j2n0+3G46IU30GrGtlIQiGRmniTaUw+V5oR1vKq99hLHiojHACLb4Ks+B3sqnybQmYMSGxOXceEYFSV/hTy3i9nH5HjK3L8KrOos0gra+BAweGz1qEXJ9MLRcsJ+UOAwsT2i8zwSTak= 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=dWUj5ZEl; arc=none smtp.client-ip=209.85.214.170 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="dWUj5ZEl" Received: by mail-pl1-f170.google.com with SMTP id d9443c01a7336-2a0d6f647e2so44719095ad.1 for ; Fri, 09 Jan 2026 05:00:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767963643; x=1768568443; 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=MO7278nlQYTAPfu3eaWy0xSK9M5O/y06GriyWS2ce/U=; b=dWUj5ZElExOKPKl7s7CV1ni/De8q/UmB/wwa/o3C53egK803aB42F9qDyDhQJ+Zdkh Vjr7ra2S8N+I11AlBPTND3Q5GX8pRP/tD0GhGGWlz0QJBglZC6IAnPBQGzuA1cUk9Zg/ W+7o6LotVXVQcfmUiPBk13OEELPvtJPmH3FpUqkG88Rc7kZMzEBeRI9kPzD2VxivJFqH OFJ6joWU9rroLOIwV7C9AytYqhWFySgc7JmoC1+MCtbzTVxv9IM6wWo2QMVLlvQdWOcr cKMWQsffzhlRwtKDqf+OY7XJF9thTe84TAcbsmU7nDNPyQTSTp6fgEQ8fZ66+r4QDRkL QcDg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767963643; x=1768568443; 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=MO7278nlQYTAPfu3eaWy0xSK9M5O/y06GriyWS2ce/U=; b=Nk5mUp9/aRq5LXlw3VjC+PqsFqYA8YW7+dcqnVyuBobaTEMcC8KtdDAYd52mkVujXn VS6JirnRtXJ1SI6teguoao1xx7Fq0hgMcTa208IHEAiYadjkEGMH1E6boFGqHVLRnDVa 2o2zqU4sjXj5H1NmR/HUTe4WcAdNf2qk+CpGCRECedkVa/DbUVCd4b9jFb4KMIGYMN4o hfd58lt0qS50wzV2OBk1nAaRpH6TXPzwpUnIcp9hZYC/2mY7OWfLiDPzZrts2vLsYWZo gzOBo5ci2DaHvuIesYaaADW2K6dDBab9Aad4Az9r/P2CEij8qiaocwpsE6Bb3IG3f0ul 0oYg== X-Forwarded-Encrypted: i=1; AJvYcCV2NSJGRzaxmshNl67+V2LnTtoVHRUIePLhfaW0kTZsjOScE6v1iRYGcmUFCergmdJnkaqV00nuC/+PPpA=@vger.kernel.org X-Gm-Message-State: AOJu0YzdDzzFV8zSXMBwZE3TRfIFBW/QGCQy0F0BV8iZa+DKnGOhpZQ2 nnHz0DxGnlzCKtLfbPx0A/AY01i/SAMvCjapT5S+EqvHbdzAVDN3OKo3 X-Gm-Gg: AY/fxX5OluRVuP5iIrSrh270wjRLtj8M0E9eyLZ3InYPMflVhrawPUK6GbfkPHfgmQh VQZG0dmgGidlZm5EE2gmMgT2G/WxAM55SeGJ+7BF6GJ5K858l1/YFNgHUO1gzBbVr+V0IdI4CY7 Fj1XcIz95G3u7HwznmICX/nwgrWK2cbMjCJARmHq2cfXPdRNIQ14tqwNmJY/Qq2BurrhidvLwyZ rc507diFxVVK4oNVtvR1Di86uGRQl+0M7nHW3CDxKslFTcDSQHG52sIEz3A/dNOTgfgl0Ss2crm DJkHt4xv59SQBnYn+hOM2UjHYQABtyp9dPZSZOrm/seyySvxShG01yb6VhaZ+Au/kgBk2RRSfPD tiRqgH4pxlNmj7ShVx+nxX9TBp5IAYQEEeSyS5s3HIEVIoJguzF0CB48/u7kAWrCPJwHYnEe65C +JLNR3py7syfMHlOGr3uc20ppGy+I= X-Google-Smtp-Source: AGHT+IG5Cqo3+38kG8ESzhWrBgdKbUFhdU0k029rjUkM6vXAH4vvVwZEbE/pXDENcUb+VYMnZzwlCQ== X-Received: by 2002:a17:903:1cd:b0:2a0:b02b:2114 with SMTP id d9443c01a7336-2a3ee413b9cmr100817785ad.11.1767963642383; Fri, 09 Jan 2026 05:00:42 -0800 (PST) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2a3e3c3a328sm104927325ad.4.2026.01.09.05.00.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 09 Jan 2026 05:00: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, Donglin Peng , Alan Maguire Subject: [PATCH bpf-next v12 11/11] btf: Refactor the code by calling str_is_empty Date: Fri, 9 Jan 2026 21:00:03 +0800 Message-Id: <20260109130003.3313716-12-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260109130003.3313716-1-dolinux.peng@gmail.com> References: <20260109130003.3313716-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Donglin Peng Calling the str_is_empty function to clarify the code and no functional changes are introduced. Cc: Eduard Zingerman Cc: Alexei Starovoitov Cc: Andrii Nakryiko Cc: Alan Maguire Cc: Ihor Solodrai Cc: Xiaoqin Zhang Signed-off-by: Donglin Peng Acked-by: Eduard Zingerman --- tools/lib/bpf/btf.c | 34 +++++++++++++++++----------------- tools/lib/bpf/libbpf.c | 4 ++-- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c index 918d9fa6ec36..66e4a57896b3 100644 --- a/tools/lib/bpf/btf.c +++ b/tools/lib/bpf/btf.c @@ -2128,7 +2128,7 @@ int btf__add_int(struct btf *btf, const char *name, s= ize_t byte_sz, int encoding int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); /* byte_sz must be power of 2 */ if (!byte_sz || (byte_sz & (byte_sz - 1)) || byte_sz > 16) @@ -2176,7 +2176,7 @@ int btf__add_float(struct btf *btf, const char *name,= size_t byte_sz) int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 /* byte_sz must be one of the explicitly allowed values */ @@ -2231,7 +2231,7 @@ static int btf_add_ref_kind(struct btf *btf, int kind= , const char *name, int ref if (!t) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2308,7 +2308,7 @@ static int btf_add_composite(struct btf *btf, int kin= d, const char *name, __u32 if (!t) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2409,7 +2409,7 @@ int btf__add_field(struct btf *btf, const char *name,= int type_id, if (!m) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2447,7 +2447,7 @@ static int btf_add_enum_common(struct btf *btf, const= char *name, __u32 byte_sz, if (!t) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2505,7 +2505,7 @@ int btf__add_enum_value(struct btf *btf, const char *= name, __s64 value) return libbpf_err(-EINVAL); =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); if (value < INT_MIN || value > UINT_MAX) return libbpf_err(-E2BIG); @@ -2582,7 +2582,7 @@ int btf__add_enum64_value(struct btf *btf, const char= *name, __u64 value) return libbpf_err(-EINVAL); =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 /* decompose and invalidate raw data */ @@ -2622,7 +2622,7 @@ int btf__add_enum64_value(struct btf *btf, const char= *name, __u64 value) */ int btf__add_fwd(struct btf *btf, const char *name, enum btf_fwd_kind fwd_= kind) { - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 switch (fwd_kind) { @@ -2658,7 +2658,7 @@ int btf__add_fwd(struct btf *btf, const char *name, e= num btf_fwd_kind fwd_kind) */ int btf__add_typedef(struct btf *btf, const char *name, int ref_type_id) { - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 return btf_add_ref_kind(btf, BTF_KIND_TYPEDEF, name, ref_type_id, 0); @@ -2710,7 +2710,7 @@ int btf__add_restrict(struct btf *btf, int ref_type_i= d) */ int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id) { - if (!value || !value[0]) + if (str_is_empty(value)) return libbpf_err(-EINVAL); =20 return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 0); @@ -2727,7 +2727,7 @@ int btf__add_type_tag(struct btf *btf, const char *va= lue, int ref_type_id) */ int btf__add_type_attr(struct btf *btf, const char *value, int ref_type_id) { - if (!value || !value[0]) + if (str_is_empty(value)) return libbpf_err(-EINVAL); =20 return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id, 1); @@ -2746,7 +2746,7 @@ int btf__add_func(struct btf *btf, const char *name, { int id; =20 - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); if (linkage !=3D BTF_FUNC_STATIC && linkage !=3D BTF_FUNC_GLOBAL && linkage !=3D BTF_FUNC_EXTERN) @@ -2832,7 +2832,7 @@ int btf__add_func_param(struct btf *btf, const char *= name, int type_id) if (!p) return libbpf_err(-ENOMEM); =20 - if (name && name[0]) { + if (!str_is_empty(name)) { name_off =3D btf__add_str(btf, name); if (name_off < 0) return name_off; @@ -2867,7 +2867,7 @@ int btf__add_var(struct btf *btf, const char *name, i= nt linkage, int type_id) int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); if (linkage !=3D BTF_VAR_STATIC && linkage !=3D BTF_VAR_GLOBAL_ALLOCATED = && linkage !=3D BTF_VAR_GLOBAL_EXTERN) @@ -2916,7 +2916,7 @@ int btf__add_datasec(struct btf *btf, const char *nam= e, __u32 byte_sz) int sz, name_off; =20 /* non-empty name */ - if (!name || !name[0]) + if (str_is_empty(name)) return libbpf_err(-EINVAL); =20 if (btf_ensure_modifiable(btf)) @@ -2993,7 +2993,7 @@ static int btf_add_decl_tag(struct btf *btf, const ch= ar *value, int ref_type_id, struct btf_type *t; int sz, value_off; =20 - if (!value || !value[0] || component_idx < -1) + if (str_is_empty(value) || component_idx < -1) return libbpf_err(-EINVAL); =20 if (validate_type_id(ref_type_id)) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 6ea81701e274..bbcfd72b07d5 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