From nobody Fri Sep 25 05:29:22 2026 Received: from mail-pz2-f42.google.com (mail-pz2-f42.google.com [74.125.228.42]) (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 3069B41C71 for ; Wed, 16 Sep 2026 13:32:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.228.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565552; cv=none; b=ZsysQRUg6AC98IM8BE+Gor3XTjJCVKMvsuchpOxcGn1lHVuk2XfHaEDeF9dRRCKUvtQluNp0KoR42ByrHiVy/OZ63ixwlWlW2q4KzspSNFEyScjnkrvC6HaAVdw/faAXsY0Agl+ZRmAhGEK5RqI17Qw9jRBZU5frg0MNkuLubWI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565552; c=relaxed/simple; bh=KsuApQ6jGsBL9H1Lg6ZPp17XC38wi5V1uyun2b7groU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=FnAcR65m/yzLetHbAu6VDulPxSJma0FsYpFUZW0h6WycAt+JNMAV7J07siCYzdFoS1nI9m2l6mqSBDHvNYiSVeT/uISY4Ip2GsRiW+m5RL36KPgxHEU34VkUXQyDsnKmKZH7HK4kPFJWd41pkDbGTxW0JuEY+CqE3N1+SfCywHs= 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=HMT+C6Dt; arc=none smtp.client-ip=74.125.228.42 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="HMT+C6Dt" Received: by mail-pz2-f42.google.com with SMTP id 41be03b00d2f7-cc4cdc0d663so500532a12.3 for ; Wed, 16 Sep 2026 06:32:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789565546; x=1790170346; 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:content-type; bh=iCcn2LkYFEOrgsqYd3Ql/075Xn3VWWErqZWMbblb648=; b=HMT+C6DtikFWg1GGY1QsMdA+B10uV8lOn+gpsA6i8QT34RMF2oo7xu17OHGsLDk/tL O2VltJQydWXfBf08nxVgPd8lo+0flMQkmcbxUl0GMXYlbC+3r+qwErQ5We5QRCOjRy2o kp/qJej+WXTq8wLunaZjpGQfZqF237DSiFyZuuzEdo3JpjU3gAWfWC7P7hCuysFwXPQX mbJLIhp3kEMh1BQhZIKn2UXt1kFfVw+dgK4Oggd3bk4JsakoahxC/JdmQgYayitQjEst TnLYMITgUUfeM2gZ/gPn0oe2Umw8kQjCR9LCm51zXanhQTHh21hpPxq9uX9P7w9WwiuY MpYQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789565546; x=1790170346; 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:content-type; bh=iCcn2LkYFEOrgsqYd3Ql/075Xn3VWWErqZWMbblb648=; b=X32S3bhmTMk+vOv90Z2m1WbyrnlgB2BE/hG+g4g4iz35icZkeQVQC2/YGzf1PxJGGL p4JEMesg61K87eb21bIWd9ibfbp1M48QJcFLvPY9G/JtLXPwb9P0WsYbN+nJkNotr4Pp LouCUy+n6ZnvD1xt1HrMCmGN0fLDpDbwdK2TdAR1OPcpyW7c5heBNb809XSRFGTMGkw5 v8bfEHPOFfupnMsP85iDlj2u8khS4O6sA9dym3GUkRu8UQo3AswV+BKDoF0rGMZfWDXc G4uerECM86YGSXG8hmg0/ZtqnR4uTs+1S33xl4OHOnfGiccarJFzksg3ZcCaAHQfD8y+ 7I8A== X-Forwarded-Encrypted: i=1; AKwUvBx3MUNNq9yaHAIWu8nFWYYOg/pFkSsUlk09AIf2HJlz/rU+Rw9KMZdhycwtXspS7tA3o1nnzQdeiPYZytg=@vger.kernel.org X-Gm-Message-State: AFuF++mw8G90NpwOdljDMiSa0WdSahM1k60ZRlj4lVxV8U5ChhTqlwTL YGVHCN4wh+I1b712zyiizvlgHp5WV9GRe+ev0DgjhLyQQc5dQ6v7fEaH X-Gm-Gg: AYBFou3aEEdl57giLZrnIa2UJrqMgCcPiQiOPwohHOwoUq/MC/UN7IDz9H8mVc6UCxm AsbEnvL+fkXnX17DjIm9M13CYWUq5kliWbXence7VNcfXJNmUho5FiKUiSID/D38qSWy65TerJx +T6VgWzh3f7PHpE1Oj4cj/OG9A7rWC3lOPG4j5ORVJDz3/R3F58G+xYZr9P/mYHHk2yL478hWoX I3jO/ZNHnRTQkToGp4yorzY9RklFVX3u2EwxRH/mDmKQ+dyEDH9D8jOMykY/zuRWdkTlflEv6By 7YGR91A2ktQyFu7QrdGcxvCwUAox4tBDd5QvgOigheDopClkrSeu0wUra1wDpzll5ueN0X5H9qd m2wVUdpddT0QUezEoFi0eYoo0E7AqRh/odcBsl1rzhllAORuZ1OOeJdkrV5syPIEI/Kh6HW05Hh GklqurFt3wpNkNcJPkL6LU+m0vP2HCTDtGhknOHEVJuQqtbeISKfO/dY9Dx7+D9t7xt7YR36igo ua5gsDchrtYwVw= X-Received: by 2002:a05:6a20:430a:b0:3da:6bdd:2308 with SMTP id adf61e73a8af0-3dd5f5d673emr6093359637.18.1789565546497; Wed, 16 Sep 2026 06:32:26 -0700 (PDT) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-cc50ab960edsm1651702a12.20.2026.09.16.06.32.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Sep 2026 06:32:25 -0700 (PDT) From: Donglin Peng To: rostedt@goodmis.org Cc: mhiramat@kernel.org, dolinux.peng@gmai.com, linux-trace-kernel@vger.kernel.org, linux-kernel@vger.kernel.org, pengdonglin Subject: [PATCH v6 1/4] tracing: Avoid BTF lookup in atomic context Date: Wed, 16 Sep 2026 21:32:15 +0800 Message-Id: <20260916133218.1282590-2-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260916133218.1282590-1-dolinux.peng@gmail.com> References: <20260916133218.1282590-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: pengdonglin The function graph trace formatter can be called from ftrace_dump_one() with interrupts disabled. When ftrace_dump_on_oops is enabled, the trace panic notifier can reach ftrace_dump() from the panic path, including the nmi_panic() path used by the hard lockup detector. btf_find_func_proto() calls bpf_find_btf_id(), which may initialize vmlinux BTF under a mutex. Skip the BTF lookup when running in an atomic context or with interrupts disabled, and fall back to the existing return value formatting. Fixes: ebeed8d4a555 ("tracing/probes: Move finding func-proto API and getti= ng func-param API to trace_btf") Signed-off-by: pengdonglin --- kernel/trace/trace_btf.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/kernel/trace/trace_btf.c b/kernel/trace/trace_btf.c index 00172f301f25..ae562192b619 100644 --- a/kernel/trace/trace_btf.c +++ b/kernel/trace/trace_btf.c @@ -15,6 +15,9 @@ const struct btf_type *btf_find_func_proto(const char *fu= nc_name, struct btf **b const struct btf_type *t; s32 id; =20 + if (unlikely(in_atomic() || irqs_disabled())) + return NULL; + id =3D bpf_find_btf_id(func_name, BTF_KIND_FUNC, btf_p); if (id < 0) return NULL; --=20 2.34.1 From nobody Fri Sep 25 05:29:22 2026 Received: from mail-pz2-f43.google.com (mail-pz2-f43.google.com [74.125.228.43]) (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 EBF262C031E for ; Wed, 16 Sep 2026 13:32:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.228.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565555; cv=none; b=VBGkDW/IZW5k2cRqD8Pw1IkGvryuwOayiMPjsSoQOvS0gO69PYZDvrM0jM3dssIB+azKnRgxp67HXkJkK1+Z2dBr+bDGJfLZRS7W8TXAPJnaN8PIC1+IBe0+9QnXDwNhZ2mF4nJg87tjP9fGwWRTUz610Va/6dgiEUDEqwBtbJ4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565555; c=relaxed/simple; bh=AHNud1t7y9KEUQSEI2EhiS2yWwmw7mgpPZeVDwHxHTA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=giHqXl/Rjgeua8mopX21qhjUHelU3j0+xo+8QTJUs9ckyPggvZRJyA7MzhlrfJOqlfz8O0touU6tUv6taPOUJeA5kGE997HYlcmq0MOiDM8Hpi/YA4yaRQ6jjmBSbBqRMev1oAXphv7BlslI918xwpuqwLrIv1tG8R66NifF/gQ= 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=H9QQNGon; arc=none smtp.client-ip=74.125.228.43 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="H9QQNGon" Received: by mail-pz2-f43.google.com with SMTP id d2e1a72fcca58-85469f204f6so552654b3a.2 for ; Wed, 16 Sep 2026 06:32:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789565550; x=1790170350; 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:content-type; bh=5qaZ1xpqL3arxXt8GeaT81uXAMbXLcleRKXKUHrmFgQ=; b=H9QQNGon27x3+mTcjd1PY03/6NNr2ax5gnJRT7AvoHrmjHob6oE7mJdK4T4a5Qv0jk IqRbMDBAVHczTQdgXxPC6HRclZf3uCHVl9Gr4yCGk2+5Eh5iDtSUzEvXm3Eo400bm2UE ZBW/hOQmGzLZ8+a9feQ6e7yfm3CjQTrn5CBZAqI60OhIXSkQavzuGCANV6TKDUcXAdxC 3g3GzNvwiF/Kx1H6Gg50vlOFKNdA5FpZfsql4hrTpzilU3lTEYDz8hM94rJ5toO/AwL2 pGjx7vj/wVzo0fjRyxiTKtXkXcUIg1uwg/0oO/6d4PrEeHD+doGQeZjcTNRvNDCB8Uqh Bo1g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789565550; x=1790170350; 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:content-type; bh=5qaZ1xpqL3arxXt8GeaT81uXAMbXLcleRKXKUHrmFgQ=; b=GBnKUN69FwEnMklrJP/DsoYttZDXSuvxpl4qt/OjtWHFI3OyfIIR2VYTE7JVtvZQOS zLOB1b+6Xf3WV8MsZkionLb8HesF3aosgUf+3h/ePAnsHlEJYxafNFslcxnhZeFogaJB gQGZVyRL4W4/g1nsUiCdVWfoV2wVzojl+tH6qn+JDi2lQ1/KEGfLvbT6BDFhWTy2TbNb gAuuSNtoFe/TTGMgafl5DhEXNbBYjQWSMI9ve3Dvi427VODBqeRZaFFzfo/T7oy/skv5 W0ya0//G+mzSYOAD11eieSdo051I3RMj4EvbjqNzT5vftNBnBd/D1TfX/G6gecFNmCkH kSbA== X-Forwarded-Encrypted: i=1; AKwUvBwZiBMbw0X6TC3vM4N5pm+tl74Pilq0LobEZ9sYHXxaL1WAAWdPTT+dVS7uKPr5eJT1fjSQ55fddK1x/OQ=@vger.kernel.org X-Gm-Message-State: AFuF++nVaVYbTLpS284mi1KjvqqlU9pSx/LMHcRZ4ayuCnygIAAyyzip 17bZN1tqcbPpMOYU63sDKko8mZoMfVAfOZxnBdIiZkKXFfj3T1w0mINL X-Gm-Gg: AYBFou30uwlNXrrNCmWrMYmlb8aYejXBOgsENMS10R07egNC0HynsgxccC+KkZoQrpk 0MQzoltcW4vjO1pLjXre72pDHyCFKTfoIrenl4F9q+GINWvpKqcknEEcs8UR1ALErHUzbcjPGBA Nrlw1/27OEPDFuvGr/vOwSqqW2ovLvBALvJEs20EHYEFxrRM78/IqKP1IeJT9MZE9iwlx6OsSH6 qXPr8tJH6IYPLGEGKn0NjMXP0haFUjwHnxMuObKXRZW8c5xb0iv7LjZOkYxRaXE/jjbm8zL6VAh GD9satyitxrR6JAXBO49xPJWMH7UeZWnvydJg5TEKOrA1THLREMkdssa8tq+GHOSyRWMabtoxiQ Ml+5O9RSORMAK8WgOXabDlPwz9UmgyHkRkdjGvtp5DS9iqSmdc6QPNJIT+XtPtRzujiuXNFgycj aqBr1pEUziz/NjBluogYgdMkD1lxwXNmxXuE27zo9goXQLkcqjSIVWYifFk+iE9P8NLEUoPWGDe RF8exNdDuV/ggUXjkxGJezjJg== X-Received: by 2002:a05:6a21:a382:b0:3da:b089:dbaa with SMTP id adf61e73a8af0-3dd5f40b327mr7277725637.6.1789565549895; Wed, 16 Sep 2026 06:32:29 -0700 (PDT) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-cc50ab960edsm1651702a12.20.2026.09.16.06.32.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Sep 2026 06:32:28 -0700 (PDT) From: Donglin Peng To: rostedt@goodmis.org Cc: mhiramat@kernel.org, dolinux.peng@gmai.com, linux-trace-kernel@vger.kernel.org, linux-kernel@vger.kernel.org, pengdonglin , Xiaoqin Zhang Subject: [PATCH v6 2/4] ftrace: Build trace_btf.c when CONFIG_DEBUG_INFO_BTF is enabled Date: Wed, 16 Sep 2026 21:32:16 +0800 Message-Id: <20260916133218.1282590-3-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260916133218.1282590-1-dolinux.peng@gmail.com> References: <20260916133218.1282590-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: pengdonglin The trace_btf.c file provides BTF helper functions used by the ftrace subsystem. Make the compilation of trace_btf.c solely depend on CONFIG_DEBUG_INFO_BTF, allowing features like funcgraph-retval to also utilize these helpers. Additionally, the redundant dependency on CONFIG_PROBE_EVENTS_BTF_ARGS is removed, as CONFIG_DEBUG_INFO_BTF already depends on CONFIG_BPF_SYSCALL. Cc: Steven Rostedt (Google) Cc: Masami Hiramatsu Cc: Xiaoqin Zhang Acked-by: Masami Hiramatsu (Google) Signed-off-by: pengdonglin --- kernel/trace/Kconfig | 2 +- kernel/trace/Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig index 0ab5916575a9..d8faeb659cfc 100644 --- a/kernel/trace/Kconfig +++ b/kernel/trace/Kconfig @@ -770,7 +770,7 @@ config FPROBE_EVENTS config PROBE_EVENTS_BTF_ARGS depends on HAVE_FUNCTION_ARG_ACCESS_API depends on FPROBE_EVENTS || KPROBE_EVENTS - depends on DEBUG_INFO_BTF && BPF_SYSCALL + depends on DEBUG_INFO_BTF bool "Support BTF function arguments for probe events" default y help diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile index f934ff586bd4..28b08f31e7e5 100644 --- a/kernel/trace/Makefile +++ b/kernel/trace/Makefile @@ -119,7 +119,7 @@ obj-$(CONFIG_KGDB_KDB) +=3D trace_kdb.o endif obj-$(CONFIG_DYNAMIC_EVENTS) +=3D trace_dynevent.o obj-$(CONFIG_PROBE_EVENTS) +=3D trace_probe.o -obj-$(CONFIG_PROBE_EVENTS_BTF_ARGS) +=3D trace_btf.o +obj-$(CONFIG_DEBUG_INFO_BTF) +=3D trace_btf.o obj-$(CONFIG_UPROBE_EVENTS) +=3D trace_uprobe.o obj-$(CONFIG_BOOTTIME_TRACING) +=3D trace_boot.o obj-$(CONFIG_FTRACE_RECORD_RECURSION) +=3D trace_recursion_record.o --=20 2.34.1 From nobody Fri Sep 25 05:29:22 2026 Received: from mail-pz2-f12.google.com (mail-pz2-f12.google.com [74.125.228.12]) (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 1E83F4FC8FB for ; Wed, 16 Sep 2026 13:32:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.228.12 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565559; cv=none; b=ujKnHMTciqvnHjVC9cGqDJTQ3c6AnFG/PUqpYExKDAD/ybDXKvgV3ZS6VEM38EqB++dea0XU3a+gpMnvjPHygiCDb0mRsikp6VRlLowp0Q+jhvNFm3dxjcuWpioNwH9Tn2nPl6Y3qnUENrYwgi8Rcj3vIqUVh3SVkMbtGMiqoYU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565559; c=relaxed/simple; bh=6UxjLPsS8HHSsfySyBekkbdAS89qWegB5Z/pfhVXzaY=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=urrZgSW3FTu8tA8QiJ8WRGBeQPRoXR3yCAly3Pj5eRuIfAVFYND6Qbp0J2xtJk8Fd9ZbnhovzNQQj+TV6niXbHA5R0v7q68J+Z/Mo9A8VqVStSMLo9T8d6+Gmyf5xBXnT3WoaQRdVAovilKbosEv/+mPuZxkHvb4J6gV3P09vw0= 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=dbMgV5lu; arc=none smtp.client-ip=74.125.228.12 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="dbMgV5lu" Received: by mail-pz2-f12.google.com with SMTP id 41be03b00d2f7-cc1cea34ef3so880578a12.0 for ; Wed, 16 Sep 2026 06:32:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789565553; x=1790170353; 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:content-type; bh=Yg2C5mt4scE/xmOQfp5Li2GDZmfVPDiocqzH0MD1Seo=; b=dbMgV5luhiNHlM+mccynRdhqGOBUTAyfkPQpN72FkSUB7Xi11ZWlXN3imd8NymJYZB /dVDmyp2Coztl/CBBVDJWbmYlKcU3LDMOlHE4u6vQmBzTu++QK2m3LvJkynHBqzFAYZF JtVmVui4/7LatkS7kHvjEfbz3oDytMIa7tME/lBM35A8zXhqAu4tQc99i1KJiyODC+gV k2q8OrPsGNxNv4xL4dAgjnGaareJzSI7vLWJBwDsmrD2OGmLFnbD0tZ6E8l4axAkDZXx KKc5Fa/QWr3ZbT3IAl30hVakytAo1b/ALyE6OI8GEWixFZ0d2wwrfnDegYAm4jhl3PTr 9xoQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789565553; x=1790170353; 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:content-type; bh=Yg2C5mt4scE/xmOQfp5Li2GDZmfVPDiocqzH0MD1Seo=; b=xAywCG3U+K7lonSORbh4fF67lhWHHwdwY10xvIOQ2qQzJfSgSIM5xr7LNtlvl5ifH1 jD/FAC8EHH6s3iNjT1Iq5GgrIv6QbLmJ1U2hfG1tci6nhgu6y2gDrt7o2SuEu9AQZvBJ Jr5JCgDosCDErI/tyaGSL3Z2VxSJMqqyx9eRobaU/1VwD2oWktE2+6ECpGWQkQ8uKdje qQqCIxeIDNJSGQ03YgEBk1X1hNIjzqtbOx1xRth38TpuJeKaiBmPAUbiyK2kLN2lCp8G 9cx48EQh8Yv4Z21YJsaM5aoZCj9ey1h/Vo9JjfLz77himLvGuZ9c5pBfZE7ucYIDJ/Ge dAIA== X-Forwarded-Encrypted: i=1; AKwUvBxfTvkTf+R//6hSPu5DZmEH+KgqHXYIOSybsu04h6uYrOaRqH2OpU230uDoOsNYEYLefqgyFCMBcJnkC0k=@vger.kernel.org X-Gm-Message-State: AFuF++k1GmxLkOQBOPxUyWD7F3at+k708RwRHBO1D/z2A17IAkggmop9 a3sVvFLmf0ghh/j7LaJDGrz6A8KuznhiFDRL+lzW6LB5OYwckUeXH0dp X-Gm-Gg: AYBFou2YXe4zj7ksx27aVaAOjfzwwtp+aYJnEHhE0oy7Op54+j+BoGcfujgpNxiEtS2 UD7s4k9TSPG00ZsbWM9c2kes1aH96H9huMz65jzViRwXDi7wZLsTwNWLSl4d81tzj7Ad63IBA7b xoJ86j2N6TCakYIBnGaXLgvY4N4JdcjkHXJZ8+IO9jRc8WqfIgFpKoLUG35SRdnpK/xU7VvIc+R u/OqQM1xeERMVp4wxeNM9w/aItGtsBuTzJUjT0eVQG2qPAs3fJf2qfyL/I3Ov+7mcVTUK/LODyZ mMq7MrgDJqR1uJ+YQqEvN6NKyFNMyOhm4IrUrwNB4cgNlakAYlGdpBq+9GvsA/ZYhxSEWRB00u8 Qn9b3qAqT5XK9AikQUVvcDcsZz6ZtAp+d5uMNm1ujdRv15JdJJAcl8RKyjfawfC6rcTHofchVkl MRryCWE7O8AMw61smcyHpDSkAgLP5gla5OPGGfYaoTQnGLWA5soMj8J1BGqu0oSLOjEnnqqo1vM 3796B2Rtj6fkGdzenBccWSO1Q== X-Received: by 2002:a05:6a21:7107:b0:3c3:b57b:6285 with SMTP id adf61e73a8af0-3dd5f735116mr6731242637.13.1789565552667; Wed, 16 Sep 2026 06:32:32 -0700 (PDT) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-cc50ab960edsm1651702a12.20.2026.09.16.06.32.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Sep 2026 06:32:32 -0700 (PDT) From: Donglin Peng To: rostedt@goodmis.org Cc: mhiramat@kernel.org, dolinux.peng@gmai.com, linux-trace-kernel@vger.kernel.org, linux-kernel@vger.kernel.org, pengdonglin , Xiaoqin Zhang Subject: [PATCH v6 3/4] fgraph: Enhance funcgraph-retval with BTF-based type-aware output Date: Wed, 16 Sep 2026 21:32:17 +0800 Message-Id: <20260916133218.1282590-4-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260916133218.1282590-1-dolinux.peng@gmail.com> References: <20260916133218.1282590-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: pengdonglin The current funcgraph-retval implementation suffers from two accuracy issues: 1. Void-returning functions still print a return value, creating misleading noise in the trace output. 2. For functions returning narrower types (e.g., char, short), the displayed value can be incorrect because high bits of the register may contain undefined data. This patch addresses both problems by leveraging BTF to obtain the exact return type of each traced kernel function. The key changes are: 1. Void function filtering: Functions with void return type no longer display any return value in the trace output, eliminating unnecessary clutter. 2. Type-aware value formatting: The return value is now properly truncated to match the actual width of the return type before being displayed. Additionally, the value is formatted according to its type for better human readability. Here is an output comparison: Before: # perf ftrace -G vfs_read --graph-opts retval ... 1) | touch_atime() { 1) | atime_needs_update() { 1) 0.069 us | make_vfsuid(); /* ret=3D0x0 */ 1) 0.067 us | make_vfsgid(); /* ret=3D0x0 */ 1) | current_time() { 1) 0.197 us | ktime_get_coarse_real_ts64_mg(); /* ret=3D0x187= f886aec3ed6f5 */ 1) 0.352 us | } /* current_time ret=3D0x69380753 */ 1) 0.792 us | } /* atime_needs_update ret=3D0x0 */ 1) 0.937 us | } /* touch_atime ret=3D0x0 */ After: # perf ftrace -G vfs_read --graph-opts retval ... 2) | touch_atime() { 2) | atime_needs_update() { 2) 0.070 us | make_vfsuid(); /* ret=3D0x0 */ 2) 0.070 us | make_vfsgid(); /* ret=3D0x0 */ 2) | current_time() { 2) 0.162 us | ktime_get_coarse_real_ts64_mg(); 2) 0.312 us | } /* current_time ret=3D0x69380649(trunc) */ 2) 0.753 us | } /* atime_needs_update ret=3Dfalse */ 2) 0.899 us | } /* touch_atime */ Cc: Steven Rostedt (Google) Cc: Masami Hiramatsu Cc: Xiaoqin Zhang Signed-off-by: pengdonglin --- kernel/trace/trace_btf.c | 83 ++++++++++++++++++++++++++++ kernel/trace/trace_btf.h | 18 ++++++ kernel/trace/trace_functions_graph.c | 56 ++++++++++++++----- 3 files changed, 144 insertions(+), 13 deletions(-) diff --git a/kernel/trace/trace_btf.c b/kernel/trace/trace_btf.c index ae562192b619..bcf65fec7bb1 100644 --- a/kernel/trace/trace_btf.c +++ b/kernel/trace/trace_btf.c @@ -2,6 +2,7 @@ #include #include #include +#include =20 #include "trace_btf.h" =20 @@ -123,3 +124,85 @@ const struct btf_member *btf_find_struct_member(struct= btf *btf, return member; } =20 +void btf_trim_retval(unsigned long func, unsigned long *retval, bool *prin= t_retval, + int *fmt, bool hex) +{ + const struct btf_type *t; + char name[KSYM_NAME_LEN]; + struct btf *btf; + u32 v, msb; + bool signed_type; + int kind; + + if (lookup_symbol_name(func, name)) + return; + + t =3D btf_find_func_proto(name, &btf); + if (IS_ERR_OR_NULL(t)) + return; + + t =3D btf_type_skip_modifiers(btf, t->type, NULL); + kind =3D t ? BTF_INFO_KIND(t->info) : BTF_KIND_UNKN; + switch (kind) { + case BTF_KIND_UNKN: + *print_retval =3D false; + break; + case BTF_KIND_STRUCT: + case BTF_KIND_UNION: + case BTF_KIND_ENUM: + case BTF_KIND_ENUM64: + if (kind =3D=3D BTF_KIND_STRUCT || kind =3D=3D BTF_KIND_UNION) { + *fmt =3D RETVAL_FMT_HEX; + signed_type =3D false; + } else { + *fmt =3D RETVAL_FMT_DEC; + signed_type =3D btf_type_kflag(t); + if (!signed_type) + *fmt |=3D RETVAL_FMT_UNSIGNED; + } + + if (t->size > sizeof(unsigned long)) { + *fmt |=3D RETVAL_FMT_TRUNC; + msb =3D BITS_PER_LONG - 1; + } else { + msb =3D min_t(u32, BITS_PER_BYTE * t->size - 1, + BITS_PER_LONG - 1); + *retval &=3D GENMASK(msb, 0); + } + if (signed_type && t->size && !hex) + *retval =3D sign_extend64(*retval, msb); + break; + case BTF_KIND_INT: + v =3D *(u32 *)(t + 1); + signed_type =3D false; + if (BTF_INT_ENCODING(v) =3D=3D BTF_INT_BOOL) { + *fmt =3D RETVAL_FMT_BOOL; + msb =3D 0; + } else { + signed_type =3D BTF_INT_ENCODING(v) & BTF_INT_SIGNED; + if (signed_type) + *fmt =3D RETVAL_FMT_DEC; + else + *fmt =3D RETVAL_FMT_HEX; + + if (t->size > sizeof(unsigned long)) { + *fmt |=3D RETVAL_FMT_TRUNC; + msb =3D BITS_PER_LONG - 1; + } else { + msb =3D min_t(u32, BTF_INT_BITS(v) - 1, + BITS_PER_LONG - 1); + } + } + *retval &=3D GENMASK(msb, 0); + if (signed_type && !hex) + *retval =3D sign_extend64(*retval, msb); + break; + default: + *fmt =3D RETVAL_FMT_HEX; + break; + } + + if (*print_retval) + *fmt |=3D RETVAL_FMT_BTF; + btf_put(btf); +} diff --git a/kernel/trace/trace_btf.h b/kernel/trace/trace_btf.h index 4bc44bc261e6..0286c89e1cf9 100644 --- a/kernel/trace/trace_btf.h +++ b/kernel/trace/trace_btf.h @@ -1,6 +1,15 @@ /* SPDX-License-Identifier: GPL-2.0 */ #include =20 +enum { + RETVAL_FMT_HEX =3D BIT(0), + RETVAL_FMT_DEC =3D BIT(1), + RETVAL_FMT_BOOL =3D BIT(2), + RETVAL_FMT_TRUNC =3D BIT(3), + RETVAL_FMT_BTF =3D BIT(4), + RETVAL_FMT_UNSIGNED =3D BIT(5), +}; + const struct btf_type *btf_find_func_proto(const char *func_name, struct btf **btf_p); const struct btf_param *btf_get_func_param(const struct btf_type *func_pro= to, @@ -9,3 +18,12 @@ const struct btf_member *btf_find_struct_member(struct bt= f *btf, const struct btf_type *type, const char *member_name, u32 *anon_offset); +#ifdef CONFIG_DEBUG_INFO_BTF +void btf_trim_retval(unsigned long func, unsigned long *retval, bool *prin= t_retval, + int *fmt, bool hex); +#else +static inline void btf_trim_retval(unsigned long func, unsigned long *retv= al, + bool *print_retval, int *fmt, bool hex) +{ +} +#endif diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_func= tions_graph.c index ff7cb1a76b95..8645a33f0388 100644 --- a/kernel/trace/trace_functions_graph.c +++ b/kernel/trace/trace_functions_graph.c @@ -15,6 +15,7 @@ =20 #include "trace.h" #include "trace_output.h" +#include "trace_btf.h" =20 /* When set, irq functions might be ignored */ static int ftrace_graph_skip_irqs; @@ -875,9 +876,10 @@ static void print_graph_retval(struct trace_seq *s, st= ruct ftrace_graph_ent_entr { unsigned long err_code =3D 0; unsigned long retval =3D 0; + bool hex_format; bool print_retaddr =3D false; bool print_retval =3D false; - bool hex_format =3D !!(opt_flags & TRACE_GRAPH_PRINT_RETVAL_HEX); + int retval_fmt =3D 0; =20 #ifdef CONFIG_FUNCTION_GRAPH_RETVAL retval =3D graph_ret->retval; @@ -888,17 +890,38 @@ static void print_graph_retval(struct trace_seq *s, s= truct ftrace_graph_ent_entr print_retaddr =3D !!(opt_flags & TRACE_GRAPH_PRINT_RETADDR); #endif =20 - if (print_retval && retval && !hex_format) { - /* Check if the return value matches the negative format */ - if (IS_ENABLED(CONFIG_64BIT) && (retval & BIT(31)) && - (((u64)retval) >> 32) =3D=3D 0) { - err_code =3D sign_extend64(retval, 31); - } else { - err_code =3D retval; + if (print_retval) { + int fmt =3D RETVAL_FMT_HEX; + + hex_format =3D !!(opt_flags & TRACE_GRAPH_PRINT_RETVAL_HEX); + btf_trim_retval((unsigned long)func, &retval, &print_retval, &fmt, + hex_format); + if (print_retval) { + if (hex_format) + retval_fmt =3D RETVAL_FMT_HEX; + + if (retval && retval_fmt !=3D RETVAL_FMT_HEX && + !(fmt & RETVAL_FMT_BTF)) { + /* Check if the return value matches the negative format */ + if (IS_ENABLED(CONFIG_64BIT) && (retval & BIT(31)) && + (((u64)retval) >> 32) =3D=3D 0) { + err_code =3D sign_extend64(retval, 31); + } else { + err_code =3D retval; + } + + if (!IS_ERR_VALUE(err_code)) + err_code =3D 0; + } + + if (retval_fmt =3D=3D RETVAL_FMT_HEX) { + retval_fmt |=3D (fmt & RETVAL_FMT_TRUNC); + } else { + if (err_code && fmt & RETVAL_FMT_HEX) + fmt =3D (fmt & ~RETVAL_FMT_HEX) | RETVAL_FMT_DEC; + retval_fmt =3D fmt; + } } - - if (!IS_ERR_VALUE(err_code)) - err_code =3D 0; } =20 if (entry) { @@ -925,10 +948,17 @@ static void print_graph_retval(struct trace_seq *s, s= truct ftrace_graph_ent_entr trace_flags, false); =20 if (print_retval) { - if (hex_format || (err_code =3D=3D 0)) + if (retval_fmt & RETVAL_FMT_HEX) trace_seq_printf(s, " ret=3D0x%lx", retval); + else if (retval_fmt & RETVAL_FMT_BOOL) + trace_seq_printf(s, " ret=3D%s", retval ? "true" : "false"); + else if (retval_fmt & RETVAL_FMT_UNSIGNED) + trace_seq_printf(s, " ret=3D%lu", retval); else - trace_seq_printf(s, " ret=3D%ld", err_code); + trace_seq_printf(s, " ret=3D%ld", err_code ?: retval); + + if (retval_fmt & RETVAL_FMT_TRUNC) + trace_seq_printf(s, "(trunc)"); } =20 if (!entry || print_retval || print_retaddr) --=20 2.34.1 From nobody Fri Sep 25 05:29:22 2026 Received: from mail-pz2-f12.google.com (mail-pz2-f12.google.com [74.125.228.12]) (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 1080D40B11B for ; Wed, 16 Sep 2026 13:32:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.228.12 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565564; cv=none; b=MHBJi2VzpSOnC16MXdGSNL+lVMOJq/+SXUg/hTjS6HJD0tOlu1aSBJuIma417iR1yeX5vEnFbYFoXHGLltq5zyGZ2CNkGIN2kK7YoDoPU1HBUg/IxHzJ+ixTfk6B2oqndHlrpYpwhf8Zi1DN9AwBWgf+9zFf3Mn/QbHCEc43bV8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789565564; c=relaxed/simple; bh=ntRH15t4Lvt22zdvEstGdhxFnzUJuuJOBEZqDNUl1wo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=CAslV9HbPS0P7MctH/6GNS1qbuB8Om+gYrT5GWxpNMxTL/0OZr4Tfb+h6CVbwxzcEOOuJyC70Bo8HeZAEAFYlO8iXlL2e6/GdIiWt7yBD0aE72YTjh+TBaMvFZGqb5oWE3J5D3wXi6hj+bBHaOXbAn4BhM1wuvrOeAGyIS4RJVA= 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=ArIcPp5X; arc=none smtp.client-ip=74.125.228.12 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="ArIcPp5X" Received: by mail-pz2-f12.google.com with SMTP id 41be03b00d2f7-cc4ae616175so581105a12.1 for ; Wed, 16 Sep 2026 06:32:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789565555; x=1790170355; 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:content-type; bh=4l3Wyd9thJNNsaD9/92h5owhyhVWLhgVC84mljLruBo=; b=ArIcPp5X+cwASztbnIMjMGVsyQ5QnX4xs5JSbQyeDgarT/CkoSIMahGssF1Oo1pPCf EI/HTcvm1jaSWzeBNmY9RwrfeD1eKoKW36ezTzBW9AbsRuoJt9DMymrdixPvjDxxtOFy zbURPAcF/GweGLdkKJOkc4WSK08oRwd7BlaXjxYJapMXLQQq9BzIGAFB2GnBYzXpBAlF KTzA1VUB3k1G1lMNnK65zL6N/OM0GDdEFIxLtZR+EGdHMAzLfinrIwLGAM1Kg7HQ33g2 N9xFZpyWg63BnwKKcrH5nYkmbjXp2XfNiD76fn0cIXCj/9XrW/RsrDDHdvWFb2F3h8rc y+vA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789565555; x=1790170355; 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:content-type; bh=4l3Wyd9thJNNsaD9/92h5owhyhVWLhgVC84mljLruBo=; b=dwhKeRsWKN6shWboSDzChKJcmtKOiMhfZOMojW9CrOHwTgPWjmWosFpLu0tbLVtN4g s68bgNDNtDLkogpqHbv19gKzppnzvpWm1LtnmJ7JuWDiNQcFqhvBRH6922aysoNe2/Rx EclYhN4j1hCKZEfo4bpGfFrGhuFgM4f45x7rTnveMCnLJiCdBqY5YUuNwfqpp/yHPnKg otWoyj8IIFdLCDlK7IYFYwZEgBPEW0trWD5+uhnslrgvE5iEQ5/MCZh/ZFT/WP4VzawN RIqQQ0dK6TLHYbLvLhF0eYqrcbDHTWeVhub6o2Fwg3dsuqVj2Vt7s4aGmldhD84Zh/Uv L4pg== X-Forwarded-Encrypted: i=1; AKwUvBxqRg8Vd9LgjbAUzn2Z2SQhpApwaMp+w+FwhlSWLQUTaqW8QMLg7BPlmvaOhyFVS114NEg0BNznLYLhwME=@vger.kernel.org X-Gm-Message-State: AFuF++k5kn+ReSbwpyVWvHDr/UUFosKDGfGO/58bkSO/JL6YtKyq5Ap8 30F5io7/nVa5LCYLa91YZglSMOufRpXQXNK30NyXnKzH4lTAcDIOiqjZ X-Gm-Gg: AYBFou0eqBpCkiZL62m3Mpz6ZUg/xtkhPbaRLEcCoCbMZ9eoVnFUVgXq+C+TqiJsmSC xHO3ZmaAtP8SDILb45dXDBQpGz/IpLqCTH5J63vaXFYytky94jl52lcXxbNJXgATtGKQF7t/BJ0 ISS/gyLg4tfmAPUYQ7/7wu3KNZbbuxkXhTcSvTaramw20U1uh479w7PaCrxevh7hw2NACq+POA8 vTKVzwdDEMcRAq6fEE80y+o2ewlqgF0dNpcUjYfvAWdzF0316qWYhsfbaDNUCeoAfHcwBTA8oCH AGQFDl4UL2tgPYyQqgtFcm/1noLnfq495ic2tg9YAPUVd2pq1SOsjM2/HNn4nhYxMQRTSrnF1eX Oxv/0zeMhA9OZx7TGMg7htaiyYkyk7fvJf+gOmf8Ndb3Gldaksa6s8JoI/tGcF2QZcxwFwUmwQv f3zoLP19ph3r91KHQBSn//S0e1rFKyZ6Kowtgs8pc+4Dtn82ksYXn/ymlIsrcI+r/lo8MKOqIH8 WqmhuWCbUE6ZbXIr8Cu01XRiA== X-Received: by 2002:a05:6a21:4d0c:b0:3d3:b00a:6f03 with SMTP id adf61e73a8af0-3dd5f7dac4dmr7049928637.28.1789565555369; Wed, 16 Sep 2026 06:32:35 -0700 (PDT) Received: from pengdl-pc.mioffice.cn ([43.224.245.249]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-cc50ab960edsm1651702a12.20.2026.09.16.06.32.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Sep 2026 06:32:34 -0700 (PDT) From: Donglin Peng To: rostedt@goodmis.org Cc: mhiramat@kernel.org, dolinux.peng@gmai.com, linux-trace-kernel@vger.kernel.org, linux-kernel@vger.kernel.org, pengdonglin , Xiaoqin Zhang Subject: [PATCH v6 4/4] tracing: Update funcgraph-retval documentation Date: Wed, 16 Sep 2026 21:32:18 +0800 Message-Id: <20260916133218.1282590-5-dolinux.peng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260916133218.1282590-1-dolinux.peng@gmail.com> References: <20260916133218.1282590-1-dolinux.peng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: pengdonglin The existing documentation for funcgraph-retval is outdated and partially incorrect, as it describes limitations that have now been resolved. Recent changes (e.g., using BTF to obtain function return types) have addressed key issues: 1. Return values are now printed only for non-void functions. 2. Values are trimmed to the correct width of the return type, avoiding garbage data from high bits. Cc: Steven Rostedt (Google) Cc: Masami Hiramatsu Cc: Xiaoqin Zhang Signed-off-by: pengdonglin --- Documentation/trace/ftrace.rst | 96 ++++++++++++++++++++-------------- 1 file changed, 58 insertions(+), 38 deletions(-) diff --git a/Documentation/trace/ftrace.rst b/Documentation/trace/ftrace.rst index 7261f25f8b4b..9423722848c6 100644 --- a/Documentation/trace/ftrace.rst +++ b/Documentation/trace/ftrace.rst @@ -1483,6 +1483,10 @@ Options for function_graph tracer: printed in hexadecimal format. By default, this option is off. =20 + funcgraph-retaddr + When set, the return address will always be printed. + By default, this option is off. + sleep-time When running function graph tracer, to include the time a task schedules out in its function. @@ -2829,7 +2833,7 @@ It is default disabled. 0) 2.861 us | } /* putname() */ =20 The return value of each traced function can be displayed after -an equal sign "=3D". When encountering system call failures, it +an equal sign "ret=3D". When encountering system call failures, it can be very helpful to quickly locate the function that first returns an error code. =20 @@ -2839,16 +2843,16 @@ returns an error code. Example with funcgraph-retval:: =20 1) | cgroup_migrate() { - 1) 0.651 us | cgroup_migrate_add_task(); /* =3D 0xffff93fcfd= 346c00 */ + 1) 0.651 us | cgroup_migrate_add_task(); /* ret=3D0xffff93fc= fd346c00 */ 1) | cgroup_migrate_execute() { 1) | cpu_cgroup_can_attach() { 1) | cgroup_taskset_first() { - 1) 0.732 us | cgroup_taskset_next(); /* =3D 0xffff93fc= 8fb20000 */ - 1) 1.232 us | } /* cgroup_taskset_first =3D 0xffff93fc8f= b20000 */ - 1) 0.380 us | sched_rt_can_attach(); /* =3D 0x0 */ - 1) 2.335 us | } /* cpu_cgroup_can_attach =3D -22 */ - 1) 4.369 us | } /* cgroup_migrate_execute =3D -22 */ - 1) 7.143 us | } /* cgroup_migrate =3D -22 */ + 1) 0.732 us | cgroup_taskset_next(); /* ret=3D0xffff93= fc8fb20000 */ + 1) 1.232 us | } /* cgroup_taskset_first ret=3D0xffff93fc= 8fb20000 */ + 1) 0.380 us | sched_rt_can_attach(); /* ret=3D0x0 */ + 1) 2.335 us | } /* cpu_cgroup_can_attach ret=3D-22 */ + 1) 4.369 us | } /* cgroup_migrate_execute ret=3D-22 */ + 1) 7.143 us | } /* cgroup_migrate ret=3D-22 */ =20 The above example shows that the function cpu_cgroup_can_attach returned the error code -22 firstly, then we can read the code @@ -2859,43 +2863,55 @@ be displayed in a smart way. Specifically, if it is= an error code, it will be printed in signed decimal format, otherwise it will printed in hexadecimal format. =20 +When CONFIG_DEBUG_INFO_BTF is enabled, the smart format also takes the +declared return type into account. Signed integer and signed enum return +values are printed in signed decimal format, unsigned enum return values +are printed in unsigned decimal format, and unsigned integer, pointer, and +aggregate return values are printed in hexadecimal format. Boolean return +values are printed as ``true`` or ``false``. If the BTF type is unavailabl= e, +the legacy error-code detection is used. + - smart: echo nofuncgraph-retval-hex > trace_options - hexadecimal: echo funcgraph-retval-hex > trace_options =20 Example with funcgraph-retval-hex:: =20 1) | cgroup_migrate() { - 1) 0.651 us | cgroup_migrate_add_task(); /* =3D 0xffff93fc= fd346c00 */ + 1) 0.651 us | cgroup_migrate_add_task(); /* ret=3D0xffff93= fcfd346c00 */ 1) | cgroup_migrate_execute() { 1) | cpu_cgroup_can_attach() { 1) | cgroup_taskset_first() { - 1) 0.732 us | cgroup_taskset_next(); /* =3D 0xffff93= fc8fb20000 */ - 1) 1.232 us | } /* cgroup_taskset_first =3D 0xffff93fc= 8fb20000 */ - 1) 0.380 us | sched_rt_can_attach(); /* =3D 0x0 */ - 1) 2.335 us | } /* cpu_cgroup_can_attach =3D 0xffffffea = */ - 1) 4.369 us | } /* cgroup_migrate_execute =3D 0xffffffea */ - 1) 7.143 us | } /* cgroup_migrate =3D 0xffffffea */ - -At present, there are some limitations when using the funcgraph-retval -option, and these limitations will be eliminated in the future: - -- Even if the function return type is void, a return value will still - be printed, and you can just ignore it. - -- Even if return values are stored in multiple registers, only the - value contained in the first register will be recorded and printed. - To illustrate, in the x86 architecture, eax and edx are used to store - a 64-bit return value, with the lower 32 bits saved in eax and the - upper 32 bits saved in edx. However, only the value stored in eax - will be recorded and printed. - -- In certain procedure call standards, such as arm64's AAPCS64, when a - type is smaller than a GPR, it is the responsibility of the consumer - to perform the narrowing, and the upper bits may contain UNKNOWN values. - Therefore, it is advisable to check the code for such cases. For instanc= e, - when using a u8 in a 64-bit GPR, bits [63:8] may contain arbitrary value= s, - especially when larger types are truncated, whether explicitly or implic= itly. - Here are some specific cases to illustrate this point: + 1) 0.732 us | cgroup_taskset_next(); /* ret=3D0xffff= 93fc8fb20000 */ + 1) 1.232 us | } /* cgroup_taskset_first ret=3D0xffff93= fc8fb20000 */ + 1) 0.380 us | sched_rt_can_attach(); /* ret=3D0x0 */ + 1) 2.335 us | } /* cpu_cgroup_can_attach ret=3D0xffffffe= a */ + 1) 4.369 us | } /* cgroup_migrate_execute ret=3D0xffffffea= */ + 1) 7.143 us | } /* cgroup_migrate ret=3D0xffffffea */ + +Note that there are some limitations when using the funcgraph-retval +option: + +- If CONFIG_DEBUG_INFO_BTF is disabled (n), a return value is printed even= for + functions with a void return type. When CONFIG_DEBUG_INFO_BTF is enabled= (y), + the return value is printed only for non-void functions. + +- If a return value occupies multiple registers, only the value in the fir= st + register is recorded and printed. For example, on the x86 architecture, a + 64-bit return value is stored across eax (lower 32 bits) and edx (upper = 32 bits), + but only the contents of eax are captured. If CONFIG_DEBUG_INFO_BTF is e= nabled, + the suffix "(trunc)" is appended to the printed value to indicate that t= he + output may be truncated because high-order register contents are omitted. + +- Under certain procedure-call standards (e.g., arm64's AAPCS64), when the= return + type is smaller than a general-purpose register (GPR), the caller is res= ponsible + for narrowing the value; the upper bits of the register may contain unde= fined data. + For instance, when a u8 is returned in 64-bit GPR, bits [63:8] can hold = arbitrary + values, especially when larger types are truncated (explicitly or implic= itly). It + is therefore advisable to inspect the code in such cases. If CONFIG_DEBU= G_INFO_BTF + is enabled (y), the return value is automatically trimmed to the width o= f the return + type. + + The following examples illustrate the behavior: =20 **Case One**: =20 @@ -2914,7 +2930,9 @@ option, and these limitations will be eliminated in t= he future: RET =20 If you pass 0x123456789abcdef to this function and want to narrow it, - it may be recorded as 0x123456789abcdef instead of 0xef. + it may be recorded as 0x123456789abcdef instead of 0xef. When + CONFIG_DEBUG_INFO_BTF is enabled, the value will be correctly truncated + to 0xef based on the size constraints of the u8 type. =20 **Case Two**: =20 @@ -2939,7 +2957,9 @@ option, and these limitations will be eliminated in t= he future: RET =20 When passing 0x2_0000_0000 to it, the return value may be recorded as - 0x2_0000_0000 instead of 0. + 0x2_0000_0000 instead of 0. When CONFIG_DEBUG_INFO_BTF is enabled, the + value will be correctly truncated to 0 based on the size constraints of + the int type. =20 You can put some comments on specific functions by using trace_printk() For example, if you want to put a comment inside --=20 2.34.1