Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5566CC43217 for ; Mon, 6 Dec 2021 14:06:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S245350AbhLFOKI (ORCPT ); Mon, 6 Dec 2021 09:10:08 -0500 Received: from dfw.source.kernel.org ([139.178.84.217]:59854 "EHLO dfw.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S245431AbhLFOJe (ORCPT ); Mon, 6 Dec 2021 09:09:34 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id B950D612CD; Mon, 6 Dec 2021 14:06:04 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2883EC341C2; Mon, 6 Dec 2021 14:06:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1638799564; bh=jWTM6a6MT7izwc0Ln8HhTdcxBCCeX2/pmKMJ47ESLq8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bLunXsyCj3qPo++/hwdYgon1rzqUpmD9zhI0wYYazACP83+2zpMsgTlWyufb3vyj3 +U6Wfr7oMXiyVLgsd8OL3yHlF7qjOQ5uoYTvyPcQlkyoqCbrcAYyli5xbxVNSTrtrj JB5i96/nlaqapspKUkPpTukZeNUCPgvCQeuTG7yleSMRGu/gLaTLZKt1CEpEccg/yj SwxLtAiXKrUd9KDgTIM2vsWj2PW6ilYGg8Q/RZJcikPffMmWKMc2a9al9PkazCYkkP yC4qHm0+o/4C6F+z/TqyTO/5/zzTXO+2/kVdza71unQsONKMnJ0lwf0avDc+DKmONG zDSFk1Q/8Qcsw== From: Miguel Ojeda To: Linus Torvalds , Greg Kroah-Hartman Cc: rust-for-linux@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho Subject: [PATCH 13/19] scripts: decode_stacktrace: demangle Rust symbols Date: Mon, 6 Dec 2021 15:03:07 +0100 Message-Id: <20211206140313.5653-14-ojeda@kernel.org> In-Reply-To: <20211206140313.5653-1-ojeda@kernel.org> References: <20211206140313.5653-1-ojeda@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Recent versions of both Binutils (`c++filt`) and LLVM (`llvm-cxxfilt`) provide Rust v0 mangling support. Co-developed-by: Alex Gaynor Signed-off-by: Alex Gaynor Co-developed-by: Wedson Almeida Filho Signed-off-by: Wedson Almeida Filho Signed-off-by: Miguel Ojeda --- I would like to use this patch for discussing the demangling topic. The following discusses the different approaches we could take. # Leave demangling to userspace This is the easiest and less invasive approach, the one implemented by this patch. The `decode_stacktrace.sh` script is already needed to map the offsets to the source code. Therefore, we could also take the chance to demangle the symbols here. With this approach, we do not need to introduce any change in the `vsprintf` machinery and we minimize the risk of breaking user tools. Note that, if we take this approach, it is likely we want to ask for a minimum version of either of the tools (since there may be users of the script that do not have recent enough toolchains). # Demangling in kernelspace on-the-fly That is, at backtrace print time, we demangle the Rust symbols. The size of the code that would be needed is fairly small; around 5 KiB using the "official" library (written in Rust), e.g.: text data bss dec hex filename 7799976 1689820 2129920 11619716 b14d84 vmlinux 7801111 1693916 2129920 11624947 b161f3 vmlinux + demangling We can remove a few bits from the official library, e.g. punycode support that we do not need (all our identifiers will be ASCII), but it does not make a substantial difference. The official library performs the demangling without requiring allocations. However, of course, it will increased our stack usage and complexity, specially considering a stack dump may be requested in not ideal conditions. Furthermore, this approach (and the ones below) likely require adding a new `%p` specifier (or a new modifier to existing ones) if we do not want to affect non-backtrace uses of the `B`/`S` ones. Also, it is unclear whether we should write the demangled versions in an extra, different line or replace the real symbol -- we could be breaking user tools relying on parsing backtraces (e.g. our own `decode_stacktrace.sh`). For instance, they could be relying on having real symbols there, or may break due to e.g. spaces. # Demangling at compile-time This implies having kallsyms demangle all the Rust symbols. The size of this data is around the same order of magnitude of the non-demangled ones. However, this is notably more than the demangling code (see previous point), e.g. 120 KiB (uncompressed) in a small kernel. This approach also brings the same concerns regarding modifying the backtrace printing (see previous point). # Demangling at compile-time and substituting symbols by hashes One variation of the previous alternative is avoiding the mangled names inside the kernel, by hashing them. This would avoid having to support "big symbols" and would also reduce the size of the kallsyms tables, while still allowing to link modules. However, if we do not have the real symbols around, then we do not have the possibility of providing both the mangled and demangled versions in the backtrace, which brings us back to the issues related to breaking userspace tools. There are also other places other than backtraces using "real" symbols that users may be relying on, such as `/proc/*/stack`. scripts/decode_stacktrace.sh | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/scripts/decode_stacktrace.sh b/scripts/decode_stacktrace.sh index 5fbad61fe490..f3c7b506d440 100755 --- a/scripts/decode_stacktrace.sh +++ b/scripts/decode_stacktrace.sh @@ -8,6 +8,14 @@ usage() { echo " $0 -r | [|auto] []" } +# Try to find a Rust demangler +if type llvm-cxxfilt >/dev/null 2>&1 ; then + cppfilt=llvm-cxxfilt +elif type c++filt >/dev/null 2>&1 ; then + cppfilt=c++filt + cppfilt_opts=-i +fi + if [[ $1 == "-r" ]] ; then vmlinux="" basepath="auto" @@ -169,6 +177,12 @@ parse_symbol() { # In the case of inlines, move everything to same line code=${code//$'\n'/' '} + # Demangle if the name looks like a Rust symbol and if + # we got a Rust demangler + if [[ $name =~ ^_R && $cppfilt != "" ]] ; then + name=$("$cppfilt" "$cppfilt_opts" "$name") + fi + # Replace old address with pretty line numbers symbol="$segment$name ($code)" } -- 2.34.0