From nobody Mon Oct 6 10:13:25 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 BBA4625B30E; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; cv=none; b=j80rML4WyqWmj6EU4RT/7Mgo8xX8k+1o5W+dAZ2tovBr2OFuwvrEUXprUWwgT0BcY5fScnCl+WKCNhFpypWMiXdmSc8t9YGRSjChiKnf2GivK+OacDolQIGD/LT941Xl7RjCKjVp5mwSNaUJMD6f0rVP5iNXmnKpEFh3lZazq68= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; c=relaxed/simple; bh=WuIWbTlGkfFONXaPtLn7obdDdrTWBX+oweEF8BZa9hI=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=X5Fe3Qp5rsIBAzA6YgMrW3T2Q3BLMaclw4MQV/HQxrFfaW/XO7ZuUFeKeiv2AmF4lBjJYDIYkOuuBovq3ZfRQci5U/aDkpdjUpZ1MasMGkP0VzZ5hSfPNLRNRGOJBJh+siUE38eIPkhpb4YZBeBJehnYUbI4xck8TLDXF5nWA60= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=NyiTzfT7; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="NyiTzfT7" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2BF98C4AF0C; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753197685; bh=WuIWbTlGkfFONXaPtLn7obdDdrTWBX+oweEF8BZa9hI=; h=Date:From:To:Cc:Subject:References:From; b=NyiTzfT7u7XGS5U8kRPLmbC8kY5lewdpdrYAHGsQ/P7w3u/Yk/4sRk9iLMqALP6fW ZzzoqXloHMqEwO16hGmNZThEGRgVM415kKqjJcW9BTGU9y+DWyVVdiMXmkdccU8xI6 plTJHfKynBkvlbH3pd/+TEPpJrvCOCY5FOXJs+gaLlCyTndoMY0rSNnIncE/HViRlu iRFxyBlSAcmlXopNxD1bbO5OBrILXDIaYZPWHIWHWvhQLnlC4EH/K+41sJSUwcHjQL 6VNAKRKhGanupTDbrETsQs2IoeRxorTcG+bYZoKavgmk0AhLyqX0bBmOEhKx5T9dRg g4qBFJSYLpQ2Q== Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1ueEoX-0000000AYyO-3Pim; Tue, 22 Jul 2025 11:21:57 -0400 Message-ID: <20250722152157.664260747@kernel.org> User-Agent: quilt/0.68 Date: Tue, 22 Jul 2025 11:20:54 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, llvm@lists.linux.dev Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Arnd Bergmann , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Nick Desaulniers , Catalin Marinas , Linus Torvalds Subject: [PATCH v3 1/5] tracepoints: Add verifier that makes sure all defined tracepoints are used References: <20250722152053.343028095@kernel.org> 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: Steven Rostedt If a tracepoint is defined via DECLARE_TRACE() or TRACE_EVENT() but never called (via the trace_() function), its metadata is still around in memory and not discarded. When created via TRACE_EVENT() the situation is worse because the TRACE_EVENT() creates metadata that can be around 5k per trace event. Having unused trace events causes several thousand of wasted bytes. Add a verifier that injects a pointer to the tracepoint structure in the functions that are used and added to a section called __tracepoint_check. Then on boot up, iterate over this section and for every tracepoint descriptor that is pointed to, update its ".funcs" field to (void *)1, as the .funcs field is only set when a tracepoint is registered. At this time, no tracepoints should be registered. Then iterate all tracepoints and if any tracepoints doesn't have its .funcs field set to (void*)1, trigger a warning, and list all tracepoints that are not found. Enabling this currently with a given config produces: Tracepoint x86_fpu_before_restore unused Tracepoint x86_fpu_after_restore unused Tracepoint x86_fpu_init_state unused Tracepoint pelt_hw_tp unused Tracepoint pelt_irq_tp unused Tracepoint ipi_raise unused Tracepoint ipi_entry unused Tracepoint ipi_exit unused Tracepoint irq_matrix_alloc_reserved unused Tracepoint psci_domain_idle_enter unused Tracepoint psci_domain_idle_exit unused Tracepoint powernv_throttle unused Tracepoint clock_enable unused Tracepoint clock_disable unused Tracepoint clock_set_rate unused Tracepoint power_domain_target unused Tracepoint xdp_bulk_tx unused Tracepoint xdp_redirect_map unused Tracepoint xdp_redirect_map_err unused Tracepoint mem_return_failed unused Tracepoint vma_mas_szero unused Tracepoint vma_store unused Tracepoint hugepage_set_pmd unused Tracepoint hugepage_set_pud unused Tracepoint hugepage_update_pmd unused Tracepoint hugepage_update_pud unused Tracepoint dax_pmd_insert_mapping unused Tracepoint dax_insert_mapping unused Tracepoint block_rq_remap unused Tracepoint xhci_dbc_handle_event unused Tracepoint xhci_dbc_handle_transfer unused Tracepoint xhci_dbc_gadget_ep_queue unused Tracepoint xhci_dbc_alloc_request unused Tracepoint xhci_dbc_free_request unused Tracepoint xhci_dbc_queue_request unused Tracepoint xhci_dbc_giveback_request unused Tracepoint tcp_ao_wrong_maclen unused Tracepoint tcp_ao_mismatch unused Tracepoint tcp_ao_key_not_found unused Tracepoint tcp_ao_rnext_request unused Tracepoint tcp_ao_synack_no_key unused Tracepoint tcp_ao_snd_sne_update unused Tracepoint tcp_ao_rcv_sne_update unused Some of the above is totally unused but others are not used due to their "trace_" functions being inside configs, in which case, the defined tracepoints should also be inside those same configs. Others are architecture specific but defined in generic code, where they should either be moved to the architecture or be surrounded by #ifdef for the architectures they are for. Note, currently this only handles tracepoints that are builtin. This can easily be extended to verify tracepoints used by modules, but it requires a slightly different approach as it needs updates to the module code. Link: https://lore.kernel.org/all/20250528114549.4d8a5e03@gandalf.local.hom= e/ Signed-off-by: Steven Rostedt (Google) --- include/asm-generic/vmlinux.lds.h | 1 + include/linux/tracepoint.h | 10 ++++++++++ kernel/trace/Kconfig | 19 +++++++++++++++++++ kernel/tracepoint.c | 26 ++++++++++++++++++++++++++ 4 files changed, 56 insertions(+) diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinu= x.lds.h index fa5f19b8d53a..600d8b51e315 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -708,6 +708,7 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPELL= ER_CLANG) MCOUNT_REC() \ *(.init.rodata .init.rodata.*) \ FTRACE_EVENTS() \ + BOUNDED_SECTION_BY(__tracepoint_check, ___tracepoint_check) \ TRACE_SYSCALLS() \ KPROBE_BLACKLIST() \ ERROR_INJECT_WHITELIST() \ diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h index 826ce3f8e1f8..2b96c7e94c52 100644 --- a/include/linux/tracepoint.h +++ b/include/linux/tracepoint.h @@ -221,6 +221,14 @@ static inline struct tracepoint *tracepoint_ptr_deref(= tracepoint_ptr_t *p) __do_trace_##name(args); \ } =20 +#ifdef CONFIG_TRACEPOINT_VERIFY_USED +# define TRACEPOINT_CHECK(name) \ + static void __used __section("__tracepoint_check") *__trace_check =3D \ + &__tracepoint_##name; +#else +# define TRACEPOINT_CHECK(name) +#endif + /* * Make sure the alignment of the structure in the __tracepoints section w= ill * not add unwanted padding between the beginning of the section and the @@ -270,6 +278,7 @@ static inline struct tracepoint *tracepoint_ptr_deref(t= racepoint_ptr_t *p) __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), PARAMS(data_pro= to)) \ static inline void __do_trace_##name(proto) \ { \ + TRACEPOINT_CHECK(name) \ if (cond) { \ guard(preempt_notrace)(); \ __DO_TRACE_CALL(name, TP_ARGS(args)); \ @@ -289,6 +298,7 @@ static inline struct tracepoint *tracepoint_ptr_deref(t= racepoint_ptr_t *p) __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), PARAMS(data_pro= to)) \ static inline void __do_trace_##name(proto) \ { \ + TRACEPOINT_CHECK(name) \ guard(rcu_tasks_trace)(); \ __DO_TRACE_CALL(name, TP_ARGS(args)); \ } \ diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig index a3f35c7d83b6..e676b802b721 100644 --- a/kernel/trace/Kconfig +++ b/kernel/trace/Kconfig @@ -1044,6 +1044,25 @@ config GCOV_PROFILE_FTRACE Note that on a kernel compiled with this config, ftrace will run significantly slower. =20 +config TRACEPOINT_VERIFY_USED + bool + help + This option creates a section when tracepoints are used + that hold a pointer to the tracepoint that is used. + This can be used to test if a defined tracepoint is + used or not. + +config TRACEPOINT_WARN_ON_UNUSED + bool "Warn if any tracepoint is defined but not used" + depends on TRACEPOINTS + select TRACEPOINT_VERIFY_USED + help + This option checks if every builtin defined tracepoint is + used in the code. If a tracepoint is defined but not used, + it will waste memory as its metadata is still created. + A warning will be triggered if a tracepoint is found and + not used at bootup. + config FTRACE_SELFTEST bool =20 diff --git a/kernel/tracepoint.c b/kernel/tracepoint.c index 62719d2941c9..7701a6fed310 100644 --- a/kernel/tracepoint.c +++ b/kernel/tracepoint.c @@ -677,10 +677,36 @@ static struct notifier_block tracepoint_module_nb =3D= { .priority =3D 0, }; =20 +#ifdef CONFIG_TRACEPOINT_WARN_ON_UNUSED +extern void * __start___tracepoint_check[]; +extern void * __stop___tracepoint_check[]; + +#define VERIFIED_TRACEPOINT ((void *)1) + +static void check_tracepoint(struct tracepoint *tp, void *priv) +{ + if (WARN_ONCE(tp->funcs !=3D VERIFIED_TRACEPOINT, "Unused tracepoints fou= nd")) + pr_warn("Tracepoint %s unused\n", tp->name); + + tp->funcs =3D NULL; +} +#endif + static __init int init_tracepoints(void) { int ret; =20 +#ifdef CONFIG_TRACEPOINT_WARN_ON_UNUSED + for (void **ptr =3D __start___tracepoint_check; + ptr < __stop___tracepoint_check; ptr++) { + struct tracepoint *tp =3D *ptr; + + tp->funcs =3D VERIFIED_TRACEPOINT; + } + + for_each_kernel_tracepoint(check_tracepoint, NULL); +#endif + ret =3D register_module_notifier(&tracepoint_module_nb); if (ret) pr_warn("Failed to register tracepoint module enter notifier\n"); --=20 2.47.2 From nobody Mon Oct 6 10:13:25 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 C0A69263F54; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; cv=none; b=sgxS/PoBsnef1FhMg/sZVPE6pp4XzXjkb1fBaMt3huYuTuBWzQIsBzXrfE45qZ2S/1plV9KZj6GGm2R5N0H4v5b6iEz/O0UvSr7XdLVZ3YzBLjchDrmWk8MC1ql72Blyj3Gm/ULB1DVCaIBjhnwTg3o5asqYhVGjgf/AJtqOoFU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; c=relaxed/simple; bh=lMArP3/0P1egQIWQhDgZmdaOZFB+rB/I87vjb1AhjnQ=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=lL+33GwfKrvoBF4ceN6c4AoLejo5CBn9xrcNmLYl/PP1s6jjJHtz9aWU1kP9W9FYvwVtP6PHpzzv5HnIkSF2rfWQZEPNfIawxSNmjSFGIci/bt0LmwJ6YICcfgLoSYHf/I2y7zk/A3m7zfI4n9RRnq4f1i0g1uXEoZr5r7KV+lE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=SCJtdXfS; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="SCJtdXfS" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 472ACC4CEF8; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753197685; bh=lMArP3/0P1egQIWQhDgZmdaOZFB+rB/I87vjb1AhjnQ=; h=Date:From:To:Cc:Subject:References:From; b=SCJtdXfS54tMYuHhCZzxYIzxEUAiKeeTQYCjiVvVNUcQez2TwKrGeCxTh3SPMaorO WEIIjBRNBVUTffvKGql0BIqoiYNIclgoR24JwrSXy1gq8aG6/xtbGHJ99I/FNkrIMa aBiVwLdZBje6t/EiopYXFP3Hhm9Y5Y90aic0dkAwgtuyXiO1crcZuj9Fs8bzolvwET WrZW5PGFyGcNnzlh6P45JNtIZMSq5zBNe+I4MUf2Aglk3fBGTCw0Lp8kao8SbE4Zet ORJv8AyOjX8Olwh2PlSRq6oSzsuIwq0yqM22WdIAwIveV5K2UocIW4rlM/o178q2BS ft+SXNFbokAzQ== Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1ueEoX-0000000AYyt-482c; Tue, 22 Jul 2025 11:21:57 -0400 Message-ID: <20250722152157.839415861@kernel.org> User-Agent: quilt/0.68 Date: Tue, 22 Jul 2025 11:20:55 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, llvm@lists.linux.dev Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Arnd Bergmann , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Nick Desaulniers , Catalin Marinas , Linus Torvalds Subject: [PATCH v3 2/5] tracing: sorttable: Add a tracepoint verification check at build time References: <20250722152053.343028095@kernel.org> 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: Steven Rostedt Update the sorttable code to check the tracepoint_check and tracepoint_ptr sections to see what trace events have been created but not used. Trace events can take up approximately 5K of memory each regardless if they are called or not. List the tracepoints that are not used at build time. Note, this currently only handles tracepoints that are builtin and not in modules. Signed-off-by: Steven Rostedt (Google) --- Changes since v2: https://lore.kernel.org/20250613000328.791312828@goodmis.= org - Make default n for now. As there are still tracepoints in the kernel that can be defined but not used, its best to not warn about them until they are fixed. kernel/trace/Kconfig | 11 ++ scripts/Makefile | 4 + scripts/sorttable.c | 268 +++++++++++++++++++++++++++++++++++++++---- 3 files changed, 260 insertions(+), 23 deletions(-) diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig index e676b802b721..bf964983d9e2 100644 --- a/kernel/trace/Kconfig +++ b/kernel/trace/Kconfig @@ -1063,6 +1063,17 @@ config TRACEPOINT_WARN_ON_UNUSED A warning will be triggered if a tracepoint is found and not used at bootup. =20 +config TRACEPOINT_WARN_ON_UNUSED_BUILD + bool "Warn on build if a tracepoint is defined but not used" + depends on TRACEPOINTS + select TRACEPOINT_VERIFY_USED + help + This option checks if every builtin defined tracepoint is + used in the code. If a tracepoint is defined but not used, + it will waste memory as its metadata is still created. + This will cause a warning at build time if the architecture + supports it. + config FTRACE_SELFTEST bool =20 diff --git a/scripts/Makefile b/scripts/Makefile index 46f860529df5..f81947ec9486 100644 --- a/scripts/Makefile +++ b/scripts/Makefile @@ -42,6 +42,10 @@ HOSTCFLAGS_sorttable.o +=3D -I$(srctree)/tools/arch/$(SR= CARCH)/include HOSTCFLAGS_sorttable.o +=3D -DUNWINDER_ORC_ENABLED endif =20 +ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS +HOSTCFLAGS_sorttable.o +=3D -DPREL32_RELOCATIONS +endif + ifdef CONFIG_BUILDTIME_MCOUNT_SORT HOSTCFLAGS_sorttable.o +=3D -DMCOUNT_SORT_ENABLED endif diff --git a/scripts/sorttable.c b/scripts/sorttable.c index deed676bfe38..ddcbec22ca96 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -92,6 +92,12 @@ static void (*w)(uint32_t, uint32_t *); static void (*w8)(uint64_t, uint64_t *); typedef void (*table_sort_t)(char *, int); =20 +static Elf_Shdr *init_data_sec; +static Elf_Shdr *ro_data_sec; +static Elf_Shdr *data_data_sec; + +static void *file_map_end; + static struct elf_funcs { int (*compare_extable)(const void *a, const void *b); uint64_t (*ehdr_shoff)(Elf_Ehdr *ehdr); @@ -550,8 +556,6 @@ static void *sort_orctable(void *arg) } #endif =20 -#ifdef MCOUNT_SORT_ENABLED - static int compare_values_64(const void *a, const void *b) { uint64_t av =3D *(uint64_t *)a; @@ -574,6 +578,22 @@ static int compare_values_32(const void *a, const void= *b) =20 static int (*compare_values)(const void *a, const void *b); =20 +static int fill_addrs(void *ptr, uint64_t size, void *addrs) +{ + void *end =3D ptr + size; + int count =3D 0; + + for (; ptr < end; ptr +=3D long_size, addrs +=3D long_size, count++) { + if (long_size =3D=3D 4) + *(uint32_t *)ptr =3D r(addrs); + else + *(uint64_t *)ptr =3D r8(addrs); + } + return count; +} + +#ifdef MCOUNT_SORT_ENABLED + /* Only used for sorting mcount table */ static void rela_write_addend(Elf_Rela *rela, uint64_t val) { @@ -684,7 +704,6 @@ static char m_err[ERRSTR_MAXSZ]; =20 struct elf_mcount_loc { Elf_Ehdr *ehdr; - Elf_Shdr *init_data_sec; uint64_t start_mcount_loc; uint64_t stop_mcount_loc; }; @@ -785,20 +804,6 @@ static void replace_relocs(void *ptr, uint64_t size, E= lf_Ehdr *ehdr, uint64_t st } } =20 -static int fill_addrs(void *ptr, uint64_t size, void *addrs) -{ - void *end =3D ptr + size; - int count =3D 0; - - for (; ptr < end; ptr +=3D long_size, addrs +=3D long_size, count++) { - if (long_size =3D=3D 4) - *(uint32_t *)ptr =3D r(addrs); - else - *(uint64_t *)ptr =3D r8(addrs); - } - return count; -} - static void replace_addrs(void *ptr, uint64_t size, void *addrs) { void *end =3D ptr + size; @@ -815,8 +820,8 @@ static void replace_addrs(void *ptr, uint64_t size, voi= d *addrs) static void *sort_mcount_loc(void *arg) { struct elf_mcount_loc *emloc =3D (struct elf_mcount_loc *)arg; - uint64_t offset =3D emloc->start_mcount_loc - shdr_addr(emloc->init_data_= sec) - + shdr_offset(emloc->init_data_sec); + uint64_t offset =3D emloc->start_mcount_loc - shdr_addr(init_data_sec) + + shdr_offset(init_data_sec); uint64_t size =3D emloc->stop_mcount_loc - emloc->start_mcount_loc; unsigned char *start_loc =3D (void *)emloc->ehdr + offset; Elf_Ehdr *ehdr =3D emloc->ehdr; @@ -920,6 +925,211 @@ static void get_mcount_loc(struct elf_mcount_loc *eml= oc, Elf_Shdr *symtab_sec, static inline int parse_symbols(const char *fname) { return 0; } #endif =20 +struct elf_tracepoint { + Elf_Ehdr *ehdr; + uint64_t start_tracepoint_check; + uint64_t stop_tracepoint_check; + uint64_t start_tracepoint; + uint64_t stop_tracepoint; + uint64_t *array; + int count; +}; + +static void make_trace_array(struct elf_tracepoint *etrace) +{ + uint64_t offset =3D etrace->start_tracepoint_check - shdr_addr(init_data_= sec) + + shdr_offset(init_data_sec); + uint64_t size =3D etrace->stop_tracepoint_check - etrace->start_tracepoin= t_check; + Elf_Ehdr *ehdr =3D etrace->ehdr; + void *start =3D (void *)ehdr + offset; + int count =3D 0; + void *vals; + + etrace->array =3D NULL; + + /* If CONFIG_TRACEPOINT_VERIFY_USED is not set, there's nothing to do */ + if (!size) + return; + + vals =3D malloc(long_size * size); + if (!vals) { + fprintf(stderr, "Failed to allocate tracepoint check array"); + return; + } + + count =3D fill_addrs(vals, size, start); + + compare_values =3D long_size =3D=3D 4 ? compare_values_32 : compare_value= s_64; + qsort(vals, count, long_size, compare_values); + + etrace->array =3D vals; + etrace->count =3D count; +} + +static int cmp_addr_64(const void *K, const void *A) +{ + uint64_t key =3D *(const uint64_t *)K; + const uint64_t *a =3D A; + + if (key < *a) + return -1; + return key > *a; +} + +static int cmp_addr_32(const void *K, const void *A) +{ + uint32_t key =3D *(const uint32_t *)K; + const uint32_t *a =3D A; + + if (key < *a) + return -1; + return key > *a; +} + +static int find_event(void *array, size_t size, uint64_t key) +{ + uint32_t val_32; + uint64_t val_64; + void *val; + int (*cmp_func)(const void *A, const void *B); + + if (long_size =3D=3D 4) { + val_32 =3D key; + val =3D &val_32; + cmp_func =3D cmp_addr_32; + } else { + val_64 =3D key; + val =3D &val_64; + cmp_func =3D cmp_addr_64; + } + return bsearch(val, array, size, long_size, cmp_func) !=3D NULL; +} + +static int failed_event(struct elf_tracepoint *etrace, uint64_t addr) +{ + uint64_t sec_addr =3D shdr_addr(data_data_sec); + uint64_t sec_offset =3D shdr_offset(data_data_sec); + uint64_t offset =3D addr - sec_addr + sec_offset; + Elf_Ehdr *ehdr =3D etrace->ehdr; + void *name_ptr =3D (void *)ehdr + offset; + char *name; + + if (name_ptr > file_map_end) + goto bad_addr; + + if (long_size =3D=3D 4) + addr =3D r(name_ptr); + else + addr =3D r8(name_ptr); + + sec_addr =3D shdr_addr(ro_data_sec); + sec_offset =3D shdr_offset(ro_data_sec); + offset =3D addr - sec_addr + sec_offset; + name =3D (char *)ehdr + offset; + if ((void *)name > file_map_end) + goto bad_addr; + + fprintf(stderr, "warning: tracepoint '%s' is unused.\n", name); + return 0; +bad_addr: + fprintf(stderr, "warning: Failed to verify unused trace events.\n"); + return -1; +} + +static void check_tracepoints(struct elf_tracepoint *etrace) +{ + uint64_t sec_addr =3D shdr_addr(ro_data_sec); + uint64_t sec_offset =3D shdr_offset(ro_data_sec); + uint64_t offset =3D etrace->start_tracepoint - sec_addr + sec_offset; + uint64_t size =3D etrace->stop_tracepoint - etrace->start_tracepoint; + Elf_Ehdr *ehdr =3D etrace->ehdr; + void *start =3D (void *)ehdr + offset; + void *end =3D start + size; + void *addrs; + int inc =3D long_size; + + if (!etrace->array) + return; + + if (!size) + return; + +#ifdef PREL32_RELOCATIONS + inc =3D 4; +#endif + + sec_offset =3D sec_offset + (uint64_t)ehdr; + for (addrs =3D start; addrs < end; addrs +=3D inc) { + uint64_t val; + +#ifdef PREL32_RELOCATIONS + val =3D r(addrs); + val +=3D sec_addr + ((uint64_t)addrs - sec_offset); +#else + val =3D long_size =3D=3D 4 ? r(addrs) : r8(addrs); +#endif + if (!find_event(etrace->array, etrace->count, val)) { + if (failed_event(etrace, val)) + return; + } + } + free(etrace->array); +} + +static void *tracepoint_check(struct elf_tracepoint *etrace, Elf_Shdr *sym= tab_sec, + const char *strtab) +{ + Elf_Sym *sym, *end_sym; + int symentsize =3D shdr_entsize(symtab_sec); + int found =3D 0; + + sym =3D (void *)etrace->ehdr + shdr_offset(symtab_sec); + end_sym =3D (void *)sym + shdr_size(symtab_sec); + + while (sym < end_sym) { + if (!strcmp(strtab + sym_name(sym), "__start___tracepoint_check")) { + etrace->start_tracepoint_check =3D sym_value(sym); + if (++found =3D=3D 4) + break; + } else if (!strcmp(strtab + sym_name(sym), "__stop___tracepoint_check"))= { + etrace->stop_tracepoint_check =3D sym_value(sym); + if (++found =3D=3D 4) + break; + } else if (!strcmp(strtab + sym_name(sym), "__start___tracepoints_ptrs")= ) { + etrace->start_tracepoint =3D sym_value(sym); + if (++found =3D=3D 4) + break; + } else if (!strcmp(strtab + sym_name(sym), "__stop___tracepoints_ptrs"))= { + etrace->stop_tracepoint =3D sym_value(sym); + if (++found =3D=3D 4) + break; + } + sym =3D (void *)sym + symentsize; + } + + if (!etrace->start_tracepoint_check) { + fprintf(stderr, "warning: get start_tracepoint_check error!\n"); + return NULL; + } + if (!etrace->stop_tracepoint_check) { + fprintf(stderr, "warning: get stop_tracepoint_check error!\n"); + return NULL; + } + if (!etrace->start_tracepoint) { + fprintf(stderr, "warning: get start_tracepoint error!\n"); + return NULL; + } + if (!etrace->stop_tracepoint) { + fprintf(stderr, "warning: get start_tracepoint error!\n"); + return NULL; + } + + make_trace_array(etrace); + check_tracepoints(etrace); + + return NULL; +} + static int do_sort(Elf_Ehdr *ehdr, char const *const fname, table_sort_t custom_sort) @@ -948,6 +1158,7 @@ static int do_sort(Elf_Ehdr *ehdr, int i; unsigned int shnum; unsigned int shstrndx; + struct elf_tracepoint tstruct =3D {0}; #ifdef MCOUNT_SORT_ENABLED struct elf_mcount_loc mstruct =3D {0}; #endif @@ -985,11 +1196,17 @@ static int do_sort(Elf_Ehdr *ehdr, symtab_shndx =3D (Elf32_Word *)((const char *)ehdr + shdr_offset(shdr)); =20 -#ifdef MCOUNT_SORT_ENABLED /* locate the .init.data section in vmlinux */ if (!strcmp(secstrings + idx, ".init.data")) - mstruct.init_data_sec =3D shdr; -#endif + init_data_sec =3D shdr; + + /* locate the .ro.data section in vmlinux */ + if (!strcmp(secstrings + idx, ".rodata")) + ro_data_sec =3D shdr; + + /* locate the .data section in vmlinux */ + if (!strcmp(secstrings + idx, ".data")) + data_data_sec =3D shdr; =20 #ifdef UNWINDER_ORC_ENABLED /* locate the ORC unwind tables */ @@ -1055,7 +1272,7 @@ static int do_sort(Elf_Ehdr *ehdr, mstruct.ehdr =3D ehdr; get_mcount_loc(&mstruct, symtab_sec, strtab); =20 - if (!mstruct.init_data_sec || !mstruct.start_mcount_loc || !mstruct.stop_= mcount_loc) { + if (!init_data_sec || !mstruct.start_mcount_loc || !mstruct.stop_mcount_l= oc) { fprintf(stderr, "incomplete mcount's sort in file: %s\n", fname); @@ -1071,6 +1288,9 @@ static int do_sort(Elf_Ehdr *ehdr, } #endif =20 + tstruct.ehdr =3D ehdr; + tracepoint_check(&tstruct, symtab_sec, strtab); + if (custom_sort) { custom_sort(extab_image, shdr_size(extab_sec)); } else { @@ -1404,6 +1624,8 @@ int main(int argc, char *argv[]) continue; } =20 + file_map_end =3D addr + size; + if (do_file(argv[i], addr)) ++n_error; =20 --=20 2.47.2 From nobody Mon Oct 6 10:13:25 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 C0B65263F5D; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; cv=none; b=b/jWUfw0GmO3Tf0HR3e+5fQkHrKEfWObNnEfYIphoD3wiByV1Tzhirgb616lft6rdEycfwyjR2OM4/rR0QfQ1OCVIS/Qi9QwMWyzS6LR9WJo9KNYOFpgMkDTuaPBS/9M+i3wT3OvkSgzvm+tpRlx2gWKnfoX9qfTiu0QdZUweqI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; c=relaxed/simple; bh=4GTdnC8JJoqpNwB/W+g1szxDcReQDCIveoymk3DB28I=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=RzSORi4UNcOHsA2GwZxhlSxIwxhjjSGNa8hJ6dE0MgmkpD6qqlIUi4p1wkUKYfxPyeYf8q1LO/0S/l/zPEraVVzzokBJxWrP2CiU81P1m9Rwgu4SYmdxCdvjQ/W8g2gbHREZl3ImGwCo2lmOt0TOLBzInYDk+iDhSRRQhFA9+v8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=H5xGa3rw; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="H5xGa3rw" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 71773C4AF0D; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753197685; bh=4GTdnC8JJoqpNwB/W+g1szxDcReQDCIveoymk3DB28I=; h=Date:From:To:Cc:Subject:References:From; b=H5xGa3rw2V8OfnlNBd6llex8zcHBsV7+jH4G7lrhTbBjvUm2Co0KTwdsdo2Vy0u5E +5gleYJff1MnwXul8zr1RtOeN4s94810s7m35WoG+Ducbl4w9H5OBiZI4ZNTnCI+wJ yaq7C4wdkpO7zatofuw0vuSi1uS/b3NRuG71d0PKjn2ryFkdEGMPgeCwUTzpHIuvFS CC5Fm69fCUwnwjfBfDbBVb55NGIhh71oBcc6AZLIqlKSJ56IBhGGSumUaNd6i6RiPy uqTjX0s6e9kn5CHiWSZzGWDIXL0/DnkqICG5YQMl+XzbpW6MAILk0UHGJ/2GePIELT nNY6Y5FywlJXA== Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1ueEoY-0000000AYzN-0c49; Tue, 22 Jul 2025 11:21:58 -0400 Message-ID: <20250722152158.003968940@kernel.org> User-Agent: quilt/0.68 Date: Tue, 22 Jul 2025 11:20:56 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, llvm@lists.linux.dev Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Arnd Bergmann , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Nick Desaulniers , Catalin Marinas , Linus Torvalds Subject: [PATCH v3 3/5] tracing: sorttable: Find unused tracepoints for arm64 that uses reloc for address References: <20250722152053.343028095@kernel.org> 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: Steven Rostedt The addresses in the ARM64 ELF file is stored in the RELA sections similar to the mcount location table. Add support to find the addresses from the RELA section to use to get the actual addresses for checking the tracepoints and the checking variables to show if all tracepoints are used. Signed-off-by: Steven Rostedt (Google) --- scripts/sorttable.c | 186 ++++++++++++++++++++++++++++---------------- 1 file changed, 118 insertions(+), 68 deletions(-) diff --git a/scripts/sorttable.c b/scripts/sorttable.c index ddcbec22ca96..edca5b06d8ce 100644 --- a/scripts/sorttable.c +++ b/scripts/sorttable.c @@ -578,6 +578,106 @@ static int compare_values_32(const void *a, const voi= d *b) =20 static int (*compare_values)(const void *a, const void *b); =20 +static char m_err[ERRSTR_MAXSZ]; +static long rela_type; +static bool sort_reloc; +static int reloc_shnum; + +/* Fill the array with the content of the relocs */ +static int fill_relocs(void *ptr, uint64_t size, Elf_Ehdr *ehdr, uint64_t = start_loc) +{ + Elf_Shdr *shdr_start; + Elf_Rela *rel; + unsigned int shnum; + unsigned int count =3D 0; + int shentsize; + void *array_end =3D ptr + size; + + shdr_start =3D (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr)); + shentsize =3D ehdr_shentsize(ehdr); + + shnum =3D ehdr_shnum(ehdr); + if (shnum =3D=3D SHN_UNDEF) + shnum =3D shdr_size(shdr_start); + + for (int i =3D 0; i < shnum; i++) { + Elf_Shdr *shdr =3D get_index(shdr_start, shentsize, i); + void *end; + + if (shdr_type(shdr) !=3D SHT_RELA) + continue; + + reloc_shnum =3D i; + + rel =3D (void *)ehdr + shdr_offset(shdr); + end =3D (void *)rel + shdr_size(shdr); + + for (; (void *)rel < end; rel =3D (void *)rel + shdr_entsize(shdr)) { + uint64_t offset =3D rela_offset(rel); + + if (offset >=3D start_loc && offset < start_loc + size) { + if (ptr + long_size > array_end) { + snprintf(m_err, ERRSTR_MAXSZ, + "Too many relocations"); + return -1; + } + + /* Make sure this has the correct type */ + if (rela_info(rel) !=3D rela_type) { + snprintf(m_err, ERRSTR_MAXSZ, + "rela has type %lx but expected %lx\n", + (long)rela_info(rel), rela_type); + return -1; + } + + if (long_size =3D=3D 4) + *(uint32_t *)ptr =3D rela_addend(rel); + else + *(uint64_t *)ptr =3D rela_addend(rel); + ptr +=3D long_size; + count++; + } + } + } + return count; +} + +static uint64_t get_addr_reloc(Elf_Ehdr *ehdr, uint64_t addr) +{ + Elf_Shdr *shdr_start; + Elf_Shdr *shdr; + Elf_Rela *rel; + unsigned int shnum; + int shentsize; + void *end; + + shdr_start =3D (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr)); + shentsize =3D ehdr_shentsize(ehdr); + + shnum =3D ehdr_shnum(ehdr); + if (shnum =3D=3D SHN_UNDEF) + shnum =3D shdr_size(shdr_start); + + shdr =3D get_index(shdr_start, shentsize, reloc_shnum); + if (shdr_type(shdr) !=3D SHT_RELA) + return 0; + + rel =3D (void *)ehdr + shdr_offset(shdr); + end =3D (void *)rel + shdr_size(shdr); + + for (; (void *)rel < end; rel =3D (void *)rel + shdr_entsize(shdr)) { + uint64_t offset =3D rela_offset(rel); + + if (offset =3D=3D addr) { + if (long_size =3D=3D 4) + return rela_addend(rel); + else + return rela_addend(rel); + } + } + return 0; +} + static int fill_addrs(void *ptr, uint64_t size, void *addrs) { void *end =3D ptr + size; @@ -696,11 +796,6 @@ static int parse_symbols(const char *fname) } =20 static pthread_t mcount_sort_thread; -static bool sort_reloc; - -static long rela_type; - -static char m_err[ERRSTR_MAXSZ]; =20 struct elf_mcount_loc { Elf_Ehdr *ehdr; @@ -708,63 +803,6 @@ struct elf_mcount_loc { uint64_t stop_mcount_loc; }; =20 -/* Fill the array with the content of the relocs */ -static int fill_relocs(void *ptr, uint64_t size, Elf_Ehdr *ehdr, uint64_t = start_loc) -{ - Elf_Shdr *shdr_start; - Elf_Rela *rel; - unsigned int shnum; - unsigned int count =3D 0; - int shentsize; - void *array_end =3D ptr + size; - - shdr_start =3D (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr)); - shentsize =3D ehdr_shentsize(ehdr); - - shnum =3D ehdr_shnum(ehdr); - if (shnum =3D=3D SHN_UNDEF) - shnum =3D shdr_size(shdr_start); - - for (int i =3D 0; i < shnum; i++) { - Elf_Shdr *shdr =3D get_index(shdr_start, shentsize, i); - void *end; - - if (shdr_type(shdr) !=3D SHT_RELA) - continue; - - rel =3D (void *)ehdr + shdr_offset(shdr); - end =3D (void *)rel + shdr_size(shdr); - - for (; (void *)rel < end; rel =3D (void *)rel + shdr_entsize(shdr)) { - uint64_t offset =3D rela_offset(rel); - - if (offset >=3D start_loc && offset < start_loc + size) { - if (ptr + long_size > array_end) { - snprintf(m_err, ERRSTR_MAXSZ, - "Too many relocations"); - return -1; - } - - /* Make sure this has the correct type */ - if (rela_info(rel) !=3D rela_type) { - snprintf(m_err, ERRSTR_MAXSZ, - "rela has type %lx but expected %lx\n", - (long)rela_info(rel), rela_type); - return -1; - } - - if (long_size =3D=3D 4) - *(uint32_t *)ptr =3D rela_addend(rel); - else - *(uint64_t *)ptr =3D rela_addend(rel); - ptr +=3D long_size; - count++; - } - } - } - return count; -} - /* Put the sorted vals back into the relocation elements */ static void replace_relocs(void *ptr, uint64_t size, Elf_Ehdr *ehdr, uint6= 4_t start_loc) { @@ -957,7 +995,15 @@ static void make_trace_array(struct elf_tracepoint *et= race) return; } =20 - count =3D fill_addrs(vals, size, start); + if (sort_reloc) { + count =3D fill_relocs(vals, size, ehdr, etrace->start_tracepoint_check); + /* gcc may use relocs to save the addresses, but clang does not. */ + if (!count) { + count =3D fill_addrs(vals, size, start); + sort_reloc =3D 0; + } + } else + count =3D fill_addrs(vals, size, start); =20 compare_values =3D long_size =3D=3D 4 ? compare_values_32 : compare_value= s_64; qsort(vals, count, long_size, compare_values); @@ -1017,10 +1063,14 @@ static int failed_event(struct elf_tracepoint *etra= ce, uint64_t addr) if (name_ptr > file_map_end) goto bad_addr; =20 - if (long_size =3D=3D 4) - addr =3D r(name_ptr); - else - addr =3D r8(name_ptr); + if (sort_reloc) { + addr =3D get_addr_reloc(ehdr, addr); + } else { + if (long_size =3D=3D 4) + addr =3D r(name_ptr); + else + addr =3D r8(name_ptr); + } =20 sec_addr =3D shdr_addr(ro_data_sec); sec_offset =3D shdr_offset(ro_data_sec); @@ -1473,9 +1523,9 @@ static int do_file(char const *const fname, void *add= r) =20 switch (r2(&ehdr->e32.e_machine)) { case EM_AARCH64: -#ifdef MCOUNT_SORT_ENABLED sort_reloc =3D true; rela_type =3D 0x403; +#ifdef MCOUNT_SORT_ENABLED /* arm64 uses patchable function entry placing before function */ before_func =3D 8; #endif --=20 2.47.2 From nobody Mon Oct 6 10:13:25 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 C0AE4263F5B; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; cv=none; b=jowcn+bnY1DyFzqFYKHh5fbKvUVNIO0WgvIAHEgY0fyphT/3aKlbtK1OBUOFjBmz4unpl8muqurwhIum6VI9n9rnp832fvhGNm59ABXorszQeyHG4b6IYymz10IaHlSlnmNnex6lC+MqJXNBxabrDRv0M/v5zPHvTzSSbLw954E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; c=relaxed/simple; bh=8DgMDOVyi1UQysuCYqsGqAUmquXWykBR0aOhtrr7Gzk=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=fTOubSAMz0DG9tUR4BJruvDyHxk6Vbii47Ej6VLjkRKQ8VCIg/X0NbFrlrf51b/D27M/XS1t2ZUB0yHE63lIGOK6bMS4W9u0CJahQH4vLd/AF7+v62gZuzBRvmQ3UZ4g3OCfakzPnuBH00VwikauRDnCfzLMT6xMP1i7cvrWnWA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=cMVqPpwD; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="cMVqPpwD" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7F107C4CEF7; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753197685; bh=8DgMDOVyi1UQysuCYqsGqAUmquXWykBR0aOhtrr7Gzk=; h=Date:From:To:Cc:Subject:References:From; b=cMVqPpwD6CUxA//YsB4wWzvJgiE5LHObwoguRyA2Z519cVFA274MUKPeOb8SoC3iZ 6op5BLpPw5pvzyxWVtLY4+1Y2ptlVR/XJ3sQ9rHQo4oxQqjfgPn3CNp0dkCHet1pMH s9wcFh3u3rbosRkeqBT1bOLkT+GsLc0aDLqS1TJE6hRqpDFmeEha8+wXmso70pOdN5 UbNnvDv/rLn0s1EsaSxUkOKlLKbTp5dBDWrBfH5614bUAz7rpH4YnUbF4OBf5hwFWZ oqgJIl7obLfIdzcW8UPHKbpIW0HlC6WQBPbngjq+gp0jnGZ7oEiaLznJSVX+wPHFyq 85uzNC/Ghzy7Q== Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1ueEoY-0000000AYzr-1Ji9; Tue, 22 Jul 2025 11:21:58 -0400 Message-ID: <20250722152158.166727806@kernel.org> User-Agent: quilt/0.68 Date: Tue, 22 Jul 2025 11:20:57 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, llvm@lists.linux.dev Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Arnd Bergmann , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Nick Desaulniers , Catalin Marinas , Linus Torvalds Subject: [PATCH v3 4/5] tracepoint: Do not warn for unused event that is exported References: <20250722152053.343028095@kernel.org> 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: Steven Rostedt There are a few generic events that may only be used by modules. They are defined and then set with EXPORT_TRACEPOINT*(). Mark events that are exported as being used, even though they still waste memory in the kernel proper. Signed-off-by: Steven Rostedt (Google) --- include/linux/tracepoint.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h index 2b96c7e94c52..8026a0659580 100644 --- a/include/linux/tracepoint.h +++ b/include/linux/tracepoint.h @@ -223,7 +223,8 @@ static inline struct tracepoint *tracepoint_ptr_deref(t= racepoint_ptr_t *p) =20 #ifdef CONFIG_TRACEPOINT_VERIFY_USED # define TRACEPOINT_CHECK(name) \ - static void __used __section("__tracepoint_check") *__trace_check =3D \ + static void __used __section("__tracepoint_check") * \ + __trace_check_##name =3D \ &__tracepoint_##name; #else # define TRACEPOINT_CHECK(name) @@ -381,10 +382,12 @@ static inline struct tracepoint *tracepoint_ptr_deref= (tracepoint_ptr_t *p) __DEFINE_TRACE_EXT(_name, NULL, PARAMS(_proto), PARAMS(_args)); =20 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name) \ + TRACEPOINT_CHECK(name) \ EXPORT_SYMBOL_GPL(__tracepoint_##name); \ EXPORT_SYMBOL_GPL(__traceiter_##name); \ EXPORT_STATIC_CALL_GPL(tp_func_##name) #define EXPORT_TRACEPOINT_SYMBOL(name) \ + TRACEPOINT_CHECK(name) \ EXPORT_SYMBOL(__tracepoint_##name); \ EXPORT_SYMBOL(__traceiter_##name); \ EXPORT_STATIC_CALL(tp_func_##name) --=20 2.47.2 From nobody Mon Oct 6 10:13:25 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 D0308263F5E; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; cv=none; b=lc6pn405ny9Gt8/1DORZ4elU15bKXwkyXBzMOsIo0jZGBNt42Xc8lyrPLJLqgog/2f81uYpoz90CBduAnJpRGceTT4TKzvLRZ6nQprlhwaXq73ymIM9Y0g1vxj8YhJHsZ3eS3RqvZGyfqYR7NewwHpGzIDLDXfTAkCYFWlMrW7s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753197685; c=relaxed/simple; bh=7tiMCctQO1e8SNLVYP6Hz/phXEyg6eSp49kHjXlum+M=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=rWn885unra0NfXPwiFZZPjVgwLqncbvZqZRtCInJVnck1C0xGoMrfN/V8lJUGr830LeeEvem28w9XuR/6ysu8mV+AuEYGaU6HyUWwPRDwIFThaE1Sj6qz/WTYEdseB5saLnt1CD66CqncC2YptFOQ4v9U4/hvoqdQwSDUbe1Z8Y= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Lekq/KFJ; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Lekq/KFJ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A80CDC4CEFC; Tue, 22 Jul 2025 15:21:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753197685; bh=7tiMCctQO1e8SNLVYP6Hz/phXEyg6eSp49kHjXlum+M=; h=Date:From:To:Cc:Subject:References:From; b=Lekq/KFJcx0oQOLyvIWI9Kf0SywVd+BeAPxzeCHRBrgiz/CjQiJviluIBh44JOMJj dR5H48HbWclBKpemHhlqUaSi3K0Qx2hxCV7DD8E0Vao9+HwOuDr6429JH3/B/bMW1F f+1JAHjKGwNtRKExxH4sJQr8voE/0d8/B1N8bUcouo5equeAscFOqw39RI7uLJItyZ P5Wf2WmvsVAFqWxpvE3OAg5fC96eqfL6NmeSp4muAM5fSyw5GYtNaoWF0lnnbHzDTv 4FZHHSsaoQ9bEVp9n44K8oYL8HWwXHbg50f8V2W0ir+8DaSskzK8nCDwzvr+JeiVUb RGAZ8cxjPZaug== Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1ueEoY-0000000AZ0M-21Cr; Tue, 22 Jul 2025 11:21:58 -0400 Message-ID: <20250722152158.334327422@kernel.org> User-Agent: quilt/0.68 Date: Tue, 22 Jul 2025 11:20:58 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, llvm@lists.linux.dev Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Arnd Bergmann , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Nick Desaulniers , Catalin Marinas , Linus Torvalds Subject: [PATCH v3 5/5] tracing: Call trace_ftrace_test_filter() for the event References: <20250722152053.343028095@kernel.org> 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: Steven Rostedt The trace event filter bootup self test tests a bunch of filter logic against the ftrace_test_filter event, but does not actually call the event. Work is being done to cause a warning if an event is defined but not used. To quiet the warning call the trace event under an if statement where it is disabled so it doesn't get optimized out. Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 3885aadc434d..e4581e10782b 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -2900,6 +2900,10 @@ static __init int ftrace_test_event_filter(void) if (i =3D=3D DATA_CNT) printk(KERN_CONT "OK\n"); =20 + /* Need to call ftrace_test_filter to prevent a warning */ + if (!trace_ftrace_test_filter_enabled()) + trace_ftrace_test_filter(1, 2, 3, 4, 5, 6, 7, 8); + return 0; } =20 --=20 2.47.2