From patchwork Mon Mar 25 17:53:37 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Daniel Xu X-Patchwork-Id: 13602611 Received: from out2-smtp.messagingengine.com (out2-smtp.messagingengine.com [66.111.4.26]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 94F0A5D8F8 for ; Mon, 25 Mar 2024 17:54:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=66.111.4.26 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711389257; cv=none; b=PSQwLNOtKF8AnBDMDiSuorRsTmkvXKsdJIfPNTmKmC1B4gQuBd4rj5LtnI8YvPXWsTnkoyHgj7bkaP5yh9nrx9I+d1Kpumpgi9Nfrlq/r8zGnmkIrFHtJ00yQMCtHphLVT36sHQwfHFynUnr2xvDLvXpXiOQr2vusfEcqWOl1ac= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711389257; c=relaxed/simple; bh=SO/R8KajO9YRpRjoi9S/bz1TVMtn0eWDcykRxFyKDyc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=JLMTUxw7UP8sqT2XyGaojtzCbizN2Apu+Kpw/Ic+TjoL0GdQ9zwnykq0QL7dKEhTPHEl4VFDGSLp9/Z4x5t0drYRdviLXnVOtgBbMOCbxhp5PFUx/GqA4xxPm9OTQFP/d+EFc/qNGnxyyZm5MzBZKIL8vTgqLN75DSzJp0s1e/M= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=dxuuu.xyz; spf=pass smtp.mailfrom=dxuuu.xyz; dkim=pass (2048-bit key) header.d=dxuuu.xyz header.i=@dxuuu.xyz header.b=xW5stzsj; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b=Xe6/CiHn; arc=none smtp.client-ip=66.111.4.26 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=dxuuu.xyz Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=dxuuu.xyz Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=dxuuu.xyz header.i=@dxuuu.xyz header.b="xW5stzsj"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="Xe6/CiHn" Received: from compute7.internal (compute7.nyi.internal [10.202.2.48]) by mailout.nyi.internal (Postfix) with ESMTP id 8CB035C006E; Mon, 25 Mar 2024 13:54:14 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute7.internal (MEProxy); Mon, 25 Mar 2024 13:54:14 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=dxuuu.xyz; h=cc :cc:content-transfer-encoding:content-type:date:date:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to; s=fm1; t=1711389254; x= 1711475654; bh=fzeiH2Hlf+wc9Y8HCph8MoYWAyWmYsDWAiLABgsP08I=; b=x W5stzsjHkiQIFKhKDvD1b5qq/SA0991UP3ZM5/My2cSZAHtyPYTJexcnH5cmd28M 3KNTYD1+nE1yb0d2nnqtEKpXJcr1rDJc4vjuOvRTk4CQ0JXANJixFafnmFRspxst V+mrX5vTlmjMV3/Xf/3eozt5JK1rCx+3xol9dMTEE1qWSSoGGGhuxTsKhGnP//2T NqTdk3H4uV08Vl2qjlTxz9QUVDDfbmmiReachC6kxKN1KkF6QfP7EBceGQYmfBBu s0iNdHmDTGJ/qXgGRTBdx8gUlghTTJjC1Az+f74LRsrlrRoCWcdwo8hLsRiIo7Lb pCNw6PR5DWIKMqPiQ3OYQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:date:date:feedback-id:feedback-id:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to:x-me-proxy:x-me-proxy :x-me-sender:x-me-sender:x-sasl-enc; s=fm2; t=1711389254; x= 1711475654; bh=fzeiH2Hlf+wc9Y8HCph8MoYWAyWmYsDWAiLABgsP08I=; b=X e6/CiHnrkoieG3tiTq69M8ylQjGNJV603ltAOwhztMdH6XsArIfatTHgBSYKPPAN YnPl8E0AdE+nTdkbwuku8HsX2Pfo7i30EdlyovFqtc+x/B33hJHxuNx8+7eLkjJq HWMqu4sWuSAnGmMdY8jpi5lO7KEq/TOmjcsl2WCBzGyn33I7JR36HLdulGH1lQbT Wlm02/lCnqEEbw3YqQvOENseVzuA4XJ1tYiARAmOUcwnV3f+ioQtYkovBGSQ4KPC H/EzpzzIW710g/j4nha0QkBCnyQ3pBHZAaG82qOPq9XakH/hho+4U6cXp5UXuxBg w6YuIq4OPxKLDnX12wJLg== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvledrudduuddggeehucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucgfrhhlucfvnfffucdljedtmdenucfjughrpefhvf evufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpeffrghnihgvlhcuighuuceo ugiguhesugiguhhuuhdrgiihiieqnecuggftrfgrthhtvghrnhepgfefgfegjefhudeike dvueetffelieefuedvhfehjeeljeejkefgffeghfdttdetnecuvehluhhsthgvrhfuihii vgeptdenucfrrghrrghmpehmrghilhhfrhhomhepugiguhesugiguhhuuhdrgiihii X-ME-Proxy: Feedback-ID: i6a694271:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Mon, 25 Mar 2024 13:54:13 -0400 (EDT) From: Daniel Xu To: acme@kernel.org, jolsa@kernel.org, quentin@isovalent.com, alan.maguire@oracle.com, eddyz87@gmail.com Cc: andrii.nakryiko@gmail.com, ast@kernel.org, daniel@iogearbox.net, bpf@vger.kernel.org Subject: [PATCH dwarves v6 1/3] gobuffer: Add gobuffer__sort() helper Date: Mon, 25 Mar 2024 11:53:37 -0600 Message-ID: X-Mailer: git-send-email 2.44.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Add a helper to sort the gobuffer. Trivial wrapper around qsort(). Signed-off-by: Daniel Xu Reviewed-by: Alan Maguire --- gobuffer.c | 5 +++++ gobuffer.h | 2 ++ 2 files changed, 7 insertions(+) diff --git a/gobuffer.c b/gobuffer.c index 02b2084..4655339 100644 --- a/gobuffer.c +++ b/gobuffer.c @@ -102,6 +102,11 @@ void gobuffer__copy(const struct gobuffer *gb, void *dest) } } +void gobuffer__sort(struct gobuffer *gb, unsigned int size, int (*compar)(const void *, const void *)) +{ + qsort((void *)gb->entries, gb->nr_entries, size, compar); +} + const void *gobuffer__compress(struct gobuffer *gb, unsigned int *size) { z_stream z = { diff --git a/gobuffer.h b/gobuffer.h index a12c5c8..cd218b6 100644 --- a/gobuffer.h +++ b/gobuffer.h @@ -21,6 +21,8 @@ void __gobuffer__delete(struct gobuffer *gb); void gobuffer__copy(const struct gobuffer *gb, void *dest); +void gobuffer__sort(struct gobuffer *gb, unsigned int size, int (*compar)(const void *, const void *)); + int gobuffer__add(struct gobuffer *gb, const void *s, unsigned int len); int gobuffer__allocate(struct gobuffer *gb, unsigned int len); From patchwork Mon Mar 25 17:53:38 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Daniel Xu X-Patchwork-Id: 13602612 Received: from out2-smtp.messagingengine.com (out2-smtp.messagingengine.com [66.111.4.26]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8590874424 for ; Mon, 25 Mar 2024 17:54:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=66.111.4.26 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711389258; cv=none; b=eKaVaItVNyiGe1l8YpbRXx/2ISO27TejcZlO7tNfRdLXTnjHv8LUY5g6oG2VQCQaGbxys+nfAD2wiJc9wbqnULUwe5HFgpyu800aMrW+aDbz3y6zxnqhFNzuiVIqSljA6hCqb50pJAiF8O11kjbPk1taYj8LavbEWgM3iDdz6X8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711389258; c=relaxed/simple; bh=kuBJD6/3mq7T5AY5lXYVNx9HNSsB7ggRwUYUE9TgG+c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Y4lVi84YAQGAb/NVdc+wj0wY1hXexvoGmM4mwBntBm7l3mLP0RGaUQggQhW4xPelV4D17uIiTDnSNoKbi9dNT/87AU0nLMPiwl/QXA7FLw2Ef2IcM+HsLcutgzspCSBWzlx+uC/XWS9GLAuNWd87IA1cw/S6oSjfeMqjR0vAEpk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=dxuuu.xyz; spf=pass smtp.mailfrom=dxuuu.xyz; dkim=pass (2048-bit key) header.d=dxuuu.xyz header.i=@dxuuu.xyz header.b=iHNW6gVD; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b=DTIhszNX; arc=none smtp.client-ip=66.111.4.26 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=dxuuu.xyz Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=dxuuu.xyz Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=dxuuu.xyz header.i=@dxuuu.xyz header.b="iHNW6gVD"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="DTIhszNX" Received: from compute4.internal (compute4.nyi.internal [10.202.2.44]) by mailout.nyi.internal (Postfix) with ESMTP id 946525C006D; Mon, 25 Mar 2024 13:54:15 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute4.internal (MEProxy); Mon, 25 Mar 2024 13:54:15 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=dxuuu.xyz; h=cc :cc:content-transfer-encoding:content-type:date:date:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to; s=fm1; t=1711389255; x= 1711475655; bh=J/JlfyyA9Z9LQpRrMORlAO/4ndkA28VNCpe8u83fFMk=; b=i HNW6gVDRIiN3QmwNwKgJecV/Lx3v2KIgXgAolw9UhxzJ2UMElhyXTLOHSpC/OpQU Oe9+m0HNOBGNOlMpe0yKM/et8nWt8xHnhvRS7zLbWwnHp9eSVQ3RoFEPTUWcSc5W Bu+X0BlQDTVAQj1l0ofBUBcfECtk00ggKqVkoILhiNOZGAF9jsoS89kwRR6cgczw 3bBMGc/nGLtvDuOjEwANyQXcwKKgVHYARA7FZDeL9p/ZtKZKXUG63WKTYna4+uiZ Ba5WetIBQlqpJnUhzpht7YGVT8wiMuBzFJv4LIUcLkmG+jNLWqt2VW0wWhLLyLmR SaJrQY8RLOE6+phI5JrTg== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:date:date:feedback-id:feedback-id:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to:x-me-proxy:x-me-proxy :x-me-sender:x-me-sender:x-sasl-enc; s=fm2; t=1711389255; x= 1711475655; bh=J/JlfyyA9Z9LQpRrMORlAO/4ndkA28VNCpe8u83fFMk=; b=D TIhszNX4EnBGOqahEYsnYLdZIgrl+8Qkq11JcbNon7oyuXnvt/TXEe7VFrc8xzTf Z8nNCP95KirJo0y46sUN0qJ8vffVYul0rixjSnoB0z/upwGcMRenEaztxal81J+L dhv+1AnSPeSttgn4QVsGiAqwj/Dmpd4fplZwD3037LMUTXS3qgbvsD9R8CinyDNe WMwbqiDpcMLYVWs3c+kHPEC8OUBnTnqmV9iWzOCxoLeCqCDUCJvLnf1R69vB/r+L tpP7ENSMU1f98LElAe/q1ZfUXEQmpqZbs7QBfBor3tAXN8prV2YJGodxknQrNHMo FCn1k7G9JbBp7P4bualAg== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvledrudduuddggeeiucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucgfrhhlucfvnfffucdlfeehmdenucfjughrpefhvf evufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpeffrghnihgvlhcuighuuceo ugiguhesugiguhhuuhdrgiihiieqnecuggftrfgrthhtvghrnhepgfefgfegjefhudeike dvueetffelieefuedvhfehjeeljeejkefgffeghfdttdetnecuvehluhhsthgvrhfuihii vgeptdenucfrrghrrghmpehmrghilhhfrhhomhepugiguhesugiguhhuuhdrgiihii X-ME-Proxy: Feedback-ID: i6a694271:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Mon, 25 Mar 2024 13:54:14 -0400 (EDT) From: Daniel Xu To: acme@kernel.org, jolsa@kernel.org, quentin@isovalent.com, alan.maguire@oracle.com, eddyz87@gmail.com Cc: andrii.nakryiko@gmail.com, ast@kernel.org, daniel@iogearbox.net, bpf@vger.kernel.org Subject: [PATCH dwarves v6 2/3] pahole: Add --btf_feature=decl_tag_kfuncs feature Date: Mon, 25 Mar 2024 11:53:38 -0600 Message-ID: <8a10fa4a067a382cecba722c91e6a8780ff4159c.1711389163.git.dxu@dxuuu.xyz> X-Mailer: git-send-email 2.44.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Add a feature flag to guard tagging of kfuncs. The next commit will implement the actual tagging. Reviewed-by: Alan Maguire Signed-off-by: Daniel Xu --- btf_encoder.c | 2 ++ dwarves.h | 1 + man-pages/pahole.1 | 1 + pahole.c | 1 + 4 files changed, 5 insertions(+) diff --git a/btf_encoder.c b/btf_encoder.c index e1e3529..850e36f 100644 --- a/btf_encoder.c +++ b/btf_encoder.c @@ -75,6 +75,7 @@ struct btf_encoder { verbose, force, gen_floats, + tag_kfuncs, is_rel; uint32_t array_index_id; struct { @@ -1659,6 +1660,7 @@ struct btf_encoder *btf_encoder__new(struct cu *cu, const char *detached_filenam encoder->force = conf_load->btf_encode_force; encoder->gen_floats = conf_load->btf_gen_floats; encoder->skip_encoding_vars = conf_load->skip_encoding_btf_vars; + encoder->tag_kfuncs = conf_load->btf_decl_tag_kfuncs; encoder->verbose = verbose; encoder->has_index_type = false; encoder->need_index_type = false; diff --git a/dwarves.h b/dwarves.h index 2393a6c..2a679bb 100644 --- a/dwarves.h +++ b/dwarves.h @@ -87,6 +87,7 @@ struct conf_load { bool skip_encoding_btf_vars; bool btf_gen_floats; bool btf_encode_force; + bool btf_decl_tag_kfuncs; uint8_t hashtable_bits; uint8_t max_hashtable_bits; uint16_t kabi_prefix_len; diff --git a/man-pages/pahole.1 b/man-pages/pahole.1 index 2be165d..5ea41ff 100644 --- a/man-pages/pahole.1 +++ b/man-pages/pahole.1 @@ -308,6 +308,7 @@ Encode BTF using the specified feature list, or specify 'all' for all features s in some CUs and not others, or when the same function name has inconsistent BTF descriptions in different CUs. + decl_tag_kfuncs Inject a BTF_KIND_DECL_TAG for each discovered kfunc. .fi So for example, specifying \-\-btf_encode=var,enum64 will result in a BTF encoding that (as well as encoding basic BTF information) will contain variables and enum64 values. diff --git a/pahole.c b/pahole.c index 0b9c2de..353a080 100644 --- a/pahole.c +++ b/pahole.c @@ -1281,6 +1281,7 @@ struct btf_feature { BTF_FEATURE(enum64, skip_encoding_btf_enum64, true), BTF_FEATURE(optimized_func, btf_gen_optimized, false), BTF_FEATURE(consistent_func, skip_encoding_btf_inconsistent_proto, false), + BTF_FEATURE(decl_tag_kfuncs, btf_decl_tag_kfuncs, false), }; #define BTF_MAX_FEATURE_STR 1024 From patchwork Mon Mar 25 17:53:39 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Daniel Xu X-Patchwork-Id: 13602613 Received: from out2-smtp.messagingengine.com (out2-smtp.messagingengine.com [66.111.4.26]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 809EC74E0A for ; Mon, 25 Mar 2024 17:54:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=66.111.4.26 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711389259; cv=none; b=oWcbwaNsQF3zaP/RiCNftO1tBGtsQFBkj5DyowuTNlyccPApzp/Xy4FZFqW9cbqt12bBLE7jY7TnYhVTeMXVZtuQJmU+TqB/lsjzDYNrj6dLsGP69g4F3ONrrmxl8wnNjcTcsPWMfHqbhX34wcpJqAZk7gSqQPE7WaaGp4n2zG0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711389259; c=relaxed/simple; bh=RwByOirmi6ATY77LeF3vE9WHjPKc+wseXXggJu8DOD8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Vso/5MJPllE20fYe099ZMmveuMh1YO0gLqo/SAAk9q13SnQRgoHrZYt8wBWodliMjsn51nwnrDVOCKOumsyEXW4quiv9T8fB94rAwZq21xRWdoyNFzHiY4ASqBffVo10P1ql4JP7/rhoAsI+mC58HxzgCTc2bINET7tMyBr0crU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=dxuuu.xyz; spf=pass smtp.mailfrom=dxuuu.xyz; dkim=pass (2048-bit key) header.d=dxuuu.xyz header.i=@dxuuu.xyz header.b=wCa6uceg; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b=kw44OTmQ; arc=none smtp.client-ip=66.111.4.26 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=dxuuu.xyz Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=dxuuu.xyz Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=dxuuu.xyz header.i=@dxuuu.xyz header.b="wCa6uceg"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="kw44OTmQ" Received: from compute5.internal (compute5.nyi.internal [10.202.2.45]) by mailout.nyi.internal (Postfix) with ESMTP id AA5735C0045; Mon, 25 Mar 2024 13:54:16 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute5.internal (MEProxy); Mon, 25 Mar 2024 13:54:16 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=dxuuu.xyz; h=cc :cc:content-transfer-encoding:content-type:date:date:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to; s=fm1; t=1711389256; x= 1711475656; bh=vRuNAidZqsLlrAMITucjIXWpJfz3G/Qsuca+6EhZEB4=; b=w Ca6ucegUcVEF8bQBOx8VgZSBlTR8wQJ3A7JY7GFV1QA6E8JZONZKZRZM1s896miY MBsflda9aFtJrrxD+6hWIqjFHyR1U276QRnMblhdaNK2etKAA2ga5KX5WZR3UQhl siljq9Og2xjV9AYuLDZxmHTvoRo6rKWJEDt6uYInGdri361L2HaDVloyhCdcluRU q9c3khxFqvS0koaEhqSoVp3eyxVllotFpEArWO5lQWz8Ms5FHFkIzep5xjPU9T32 8wnIrYLoIUc0VRjUrML5db++nlIGAyS3rM/Qd0BA/N7Ktql98UTcQmOOSVpYxSOW Rl5pKElBML+TGv6MMkifA== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:date:date:feedback-id:feedback-id:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to:x-me-proxy:x-me-proxy :x-me-sender:x-me-sender:x-sasl-enc; s=fm2; t=1711389256; x= 1711475656; bh=vRuNAidZqsLlrAMITucjIXWpJfz3G/Qsuca+6EhZEB4=; b=k w44OTmQpheiVNDgielfadUC7VVcFcb3/5POfkYp7c+spBVY6K4YtRSbtbEmQyLAb M8H+gZcX4i81KfluT+w1axY38bL09f32H9v8pM33Xkug/Y9D1+BKj0+f/rg2Xkfh I0rjeSoDiPbfVTs/f+boNREjcpcI+UaWqt9AjJ7o2OSETkU7AK+7wdw2DfzoPRbu 5KCutmJhX73wZw/Kf49mYJfJZcdTmFEfAnDJtJGoLXnpk192gzzeWjkIHyTVVC3A jgqp9m0AWY9axK6U2feRmyNan2z1l4DkIda5mHYGjBeSzsnx78ucZXiW6dcphFjO 3s+XIlerA0/xqzZzEEnEg== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvledrudduuddggeeiucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucgfrhhlucfvnfffucdlvdefmdenucfjughrpefhvf evufffkffojghfggfgsedtkeertdertddtnecuhfhrohhmpeffrghnihgvlhcuighuuceo ugiguhesugiguhhuuhdrgiihiieqnecuggftrfgrthhtvghrnhepgfefgfegjefhudeike dvueetffelieefuedvhfehjeeljeejkefgffeghfdttdetnecuvehluhhsthgvrhfuihii vgeptdenucfrrghrrghmpehmrghilhhfrhhomhepugiguhesugiguhhuuhdrgiihii X-ME-Proxy: Feedback-ID: i6a694271:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Mon, 25 Mar 2024 13:54:15 -0400 (EDT) From: Daniel Xu To: acme@kernel.org, jolsa@kernel.org, quentin@isovalent.com, alan.maguire@oracle.com, eddyz87@gmail.com Cc: andrii.nakryiko@gmail.com, ast@kernel.org, daniel@iogearbox.net, bpf@vger.kernel.org Subject: [PATCH dwarves v6 3/3] pahole: Inject kfunc decl tags into BTF Date: Mon, 25 Mar 2024 11:53:39 -0600 Message-ID: <82ae2ddd83a8d85ae071e650cf80005c36bb1343.1711389163.git.dxu@dxuuu.xyz> X-Mailer: git-send-email 2.44.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 This commit teaches pahole to parse symbols in .BTF_ids section in vmlinux and discover exported kfuncs. Pahole then takes the list of kfuncs and injects a BTF_KIND_DECL_TAG for each kfunc. Example of encoding: $ bpftool btf dump file .tmp_vmlinux.btf | rg "DECL_TAG 'bpf_kfunc'" | wc -l 121 $ bpftool btf dump file .tmp_vmlinux.btf | rg 56337 [56337] FUNC 'bpf_ct_change_timeout' type_id=56336 linkage=static [127861] DECL_TAG 'bpf_kfunc' type_id=56337 component_idx=-1 This enables downstream users and tools to dynamically discover which kfuncs are available on a system by parsing vmlinux or module BTF, both available in /sys/kernel/btf. This feature is enabled with --btf_features=decl_tag,decl_tag_kfuncs. Acked-by: Jiri Olsa Tested-by: Jiri Olsa Reviewed-by: Alan Maguire Tested-by: Alan Maguire Signed-off-by: Daniel Xu --- btf_encoder.c | 372 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 372 insertions(+) diff --git a/btf_encoder.c b/btf_encoder.c index 850e36f..d326404 100644 --- a/btf_encoder.c +++ b/btf_encoder.c @@ -34,6 +34,21 @@ #include #define BTF_ENCODER_MAX_PROTO 512 +#define BTF_IDS_SECTION ".BTF_ids" +#define BTF_ID_FUNC_PFX "__BTF_ID__func__" +#define BTF_ID_SET8_PFX "__BTF_ID__set8__" +#define BTF_SET8_KFUNCS (1 << 0) +#define BTF_KFUNC_TYPE_TAG "bpf_kfunc" + +/* Adapted from include/linux/btf_ids.h */ +struct btf_id_set8 { + uint32_t cnt; + uint32_t flags; + struct { + uint32_t id; + uint32_t flags; + } pairs[]; +}; /* state used to do later encoding of saved functions */ struct btf_encoder_state { @@ -75,6 +90,7 @@ struct btf_encoder { verbose, force, gen_floats, + skip_encoding_decl_tag, tag_kfuncs, is_rel; uint32_t array_index_id; @@ -94,6 +110,17 @@ struct btf_encoder { } functions; }; +struct btf_func { + const char *name; + int type_id; +}; + +/* Half open interval representing range of addresses containing kfuncs */ +struct btf_kfunc_set_range { + uint64_t start; + uint64_t end; +}; + static LIST_HEAD(encoders); static pthread_mutex_t encoders__lock = PTHREAD_MUTEX_INITIALIZER; @@ -1363,8 +1390,343 @@ out: return err; } +/* Returns if `sym` points to a kfunc set */ +static int is_sym_kfunc_set(GElf_Sym *sym, const char *name, Elf_Data *idlist, size_t idlist_addr) +{ + void *ptr = idlist->d_buf; + struct btf_id_set8 *set; + int off; + + /* kfuncs are only found in BTF_SET8's */ + if (!strstarts(name, BTF_ID_SET8_PFX)) + return false; + + off = sym->st_value - idlist_addr; + if (off >= idlist->d_size) { + fprintf(stderr, "%s: symbol '%s' out of bounds\n", __func__, name); + return false; + } + + /* Check the set8 flags to see if it was marked as kfunc */ + set = ptr + off; + return set->flags & BTF_SET8_KFUNCS; +} + +/* + * Parse BTF_ID symbol and return the func name. + * + * Returns: + * Caller-owned string containing func name if successful. + * NULL if !func or on error. + */ +static char *get_func_name(const char *sym) +{ + char *func, *end; + + /* Example input: __BTF_ID__func__vfs_close__1 + * + * The goal is to strip the prefix and suffix such that we only + * return vfs_close. + */ + + if (!strstarts(sym, BTF_ID_FUNC_PFX)) + return NULL; + + /* Strip prefix and handle malformed input such as __BTF_ID__func___ */ + func = strdup(sym + sizeof(BTF_ID_FUNC_PFX) - 1); + if (strlen(func) < 2) { + free(func); + return NULL; + } + + /* Strip suffix */ + end = strrchr(func, '_'); + if (!end || *(end - 1) != '_') { + free(func); + return NULL; + } + *(end - 1) = '\0'; + + return func; +} + +static int btf_func_cmp(const void *_a, const void *_b) +{ + const struct btf_func *a = _a; + const struct btf_func *b = _b; + + return strcmp(a->name, b->name); +} + +/* + * Collects all functions described in BTF. + * Returns non-zero on error. + */ +static int btf_encoder__collect_btf_funcs(struct btf_encoder *encoder, struct gobuffer *funcs) +{ + struct btf *btf = encoder->btf; + int nr_types, type_id; + int err = -1; + + /* First collect all the func entries into an array */ + nr_types = btf__type_cnt(btf); + for (type_id = 1; type_id < nr_types; type_id++) { + const struct btf_type *type; + struct btf_func func = {}; + const char *name; + + type = btf__type_by_id(btf, type_id); + if (!type) { + fprintf(stderr, "%s: malformed BTF, can't resolve type for ID %d\n", + __func__, type_id); + err = -EINVAL; + goto out; + } + + if (!btf_is_func(type)) + continue; + + name = btf__name_by_offset(btf, type->name_off); + if (!name) { + fprintf(stderr, "%s: malformed BTF, can't resolve name for ID %d\n", + __func__, type_id); + err = -EINVAL; + goto out; + } + + func.name = name; + func.type_id = type_id; + err = gobuffer__add(funcs, &func, sizeof(func)); + if (err < 0) + goto out; + } + + /* Now that we've collected funcs, sort them by name */ + gobuffer__sort(funcs, sizeof(struct btf_func), btf_func_cmp); + + err = 0; +out: + return err; +} + +static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, struct gobuffer *funcs, const char *kfunc) +{ + struct btf_func key = { .name = kfunc }; + struct btf *btf = encoder->btf; + struct btf_func *target; + const void *base; + unsigned int cnt; + int err = -1; + + base = gobuffer__entries(funcs); + cnt = gobuffer__nr_entries(funcs); + target = bsearch(&key, base, cnt, sizeof(key), btf_func_cmp); + if (!target) { + fprintf(stderr, "%s: failed to find kfunc '%s' in BTF\n", __func__, kfunc); + goto out; + } + + /* Note we are unconditionally adding the btf_decl_tag even + * though vmlinux may already contain btf_decl_tags for kfuncs. + * We are ok to do this b/c we will later btf__dedup() to remove + * any duplicates. + */ + err = btf__add_decl_tag(btf, BTF_KFUNC_TYPE_TAG, target->type_id, -1); + if (err < 0) { + fprintf(stderr, "%s: failed to insert kfunc decl tag for '%s': %d\n", + __func__, kfunc, err); + goto out; + } + + err = 0; +out: + return err; +} + +static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder) +{ + const char *filename = encoder->filename; + struct gobuffer btf_kfunc_ranges = {}; + struct gobuffer btf_funcs = {}; + Elf_Data *symbols = NULL; + Elf_Data *idlist = NULL; + Elf_Scn *symscn = NULL; + int symbols_shndx = -1; + size_t idlist_addr = 0; + int fd = -1, err = -1; + int idlist_shndx = -1; + size_t strtabidx = 0; + Elf_Scn *scn = NULL; + Elf *elf = NULL; + GElf_Shdr shdr; + size_t strndx; + char *secname; + int nr_syms; + int i = 0; + + fd = open(filename, O_RDONLY); + if (fd < 0) { + fprintf(stderr, "Cannot open %s\n", filename); + goto out; + } + + if (elf_version(EV_CURRENT) == EV_NONE) { + elf_error("Cannot set libelf version"); + goto out; + } + + elf = elf_begin(fd, ELF_C_READ, NULL); + if (elf == NULL) { + elf_error("Cannot update ELF file"); + goto out; + } + + /* Locate symbol table and .BTF_ids sections */ + if (elf_getshdrstrndx(elf, &strndx) < 0) + goto out; + + while ((scn = elf_nextscn(elf, scn)) != NULL) { + Elf_Data *data; + + i++; + if (!gelf_getshdr(scn, &shdr)) { + elf_error("Failed to get ELF section(%d) hdr", i); + goto out; + } + + secname = elf_strptr(elf, strndx, shdr.sh_name); + if (!secname) { + elf_error("Failed to get ELF section(%d) hdr name", i); + goto out; + } + + data = elf_getdata(scn, 0); + if (!data) { + elf_error("Failed to get ELF section(%d) data", i); + goto out; + } + + if (shdr.sh_type == SHT_SYMTAB) { + symbols_shndx = i; + symscn = scn; + symbols = data; + strtabidx = shdr.sh_link; + } else if (!strcmp(secname, BTF_IDS_SECTION)) { + idlist_shndx = i; + idlist_addr = shdr.sh_addr; + idlist = data; + } + } + + /* Cannot resolve symbol or .BTF_ids sections. Nothing to do. */ + if (symbols_shndx == -1 || idlist_shndx == -1) { + err = 0; + goto out; + } + + if (!gelf_getshdr(symscn, &shdr)) { + elf_error("Failed to get ELF symbol table header"); + goto out; + } + nr_syms = shdr.sh_size / shdr.sh_entsize; + + err = btf_encoder__collect_btf_funcs(encoder, &btf_funcs); + if (err) { + fprintf(stderr, "%s: failed to collect BTF funcs\n", __func__); + goto out; + } + + /* First collect all kfunc set ranges. + * + * Note we choose not to sort these ranges and accept a linear + * search when doing lookups. Reasoning is that the number of + * sets is ~O(100) and not worth the additional code to optimize. + */ + for (i = 0; i < nr_syms; i++) { + struct btf_kfunc_set_range range = {}; + const char *name; + GElf_Sym sym; + + if (!gelf_getsym(symbols, i, &sym)) { + elf_error("Failed to get ELF symbol(%d)", i); + goto out; + } + + if (sym.st_shndx != idlist_shndx) + continue; + + name = elf_strptr(elf, strtabidx, sym.st_name); + if (!is_sym_kfunc_set(&sym, name, idlist, idlist_addr)) + continue; + + range.start = sym.st_value; + range.end = sym.st_value + sym.st_size; + gobuffer__add(&btf_kfunc_ranges, &range, sizeof(range)); + } + + /* Now inject BTF with kfunc decl tag for detected kfuncs */ + for (i = 0; i < nr_syms; i++) { + const struct btf_kfunc_set_range *ranges; + unsigned int ranges_cnt; + char *func, *name; + GElf_Sym sym; + bool found; + int err; + int j; + + if (!gelf_getsym(symbols, i, &sym)) { + elf_error("Failed to get ELF symbol(%d)", i); + goto out; + } + + if (sym.st_shndx != idlist_shndx) + continue; + + name = elf_strptr(elf, strtabidx, sym.st_name); + func = get_func_name(name); + if (!func) + continue; + + /* Check if function belongs to a kfunc set */ + ranges = gobuffer__entries(&btf_kfunc_ranges); + ranges_cnt = gobuffer__nr_entries(&btf_kfunc_ranges); + found = false; + for (j = 0; j < ranges_cnt; j++) { + size_t addr = sym.st_value; + + if (ranges[j].start <= addr && addr < ranges[j].end) { + found = true; + break; + } + } + if (!found) { + free(func); + continue; + } + + err = btf_encoder__tag_kfunc(encoder, &btf_funcs, func); + if (err) { + fprintf(stderr, "%s: failed to tag kfunc '%s'\n", __func__, func); + free(func); + goto out; + } + free(func); + } + + err = 0; +out: + __gobuffer__delete(&btf_funcs); + __gobuffer__delete(&btf_kfunc_ranges); + if (elf) + elf_end(elf); + if (fd != -1) + close(fd); + return err; +} + int btf_encoder__encode(struct btf_encoder *encoder) { + bool should_tag_kfuncs; int err; /* for single-threaded case, saved funcs are added here */ @@ -1377,6 +1739,15 @@ int btf_encoder__encode(struct btf_encoder *encoder) if (btf__type_cnt(encoder->btf) == 1) return 0; + /* Note vmlinux may already contain btf_decl_tag's for kfuncs. So + * take care to call this before btf_dedup(). + */ + should_tag_kfuncs = encoder->tag_kfuncs && !encoder->skip_encoding_decl_tag; + if (should_tag_kfuncs && btf_encoder__tag_kfuncs(encoder)) { + fprintf(stderr, "%s: failed to tag kfuncs!\n", __func__); + return -1; + } + if (btf__dedup(encoder->btf, NULL)) { fprintf(stderr, "%s: btf__dedup failed!\n", __func__); return -1; @@ -1660,6 +2031,7 @@ struct btf_encoder *btf_encoder__new(struct cu *cu, const char *detached_filenam encoder->force = conf_load->btf_encode_force; encoder->gen_floats = conf_load->btf_gen_floats; encoder->skip_encoding_vars = conf_load->skip_encoding_btf_vars; + encoder->skip_encoding_decl_tag = conf_load->skip_encoding_btf_decl_tag; encoder->tag_kfuncs = conf_load->btf_decl_tag_kfuncs; encoder->verbose = verbose; encoder->has_index_type = false;