From nobody Sat Feb 7 13:41:03 2026 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 1D5B1289E3A; Fri, 6 Jun 2025 16:42:31 +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=1749228152; cv=none; b=YPb4VErHK13F6K+24wnhpct6exqNhxEfAejAzf68AVtmQZVV+hLaW5J+P+Evr+4VXxSLEvACLPRqEGTvzqiHStOq++X5JDP+v83084UeOw6OSpQ8CrUkBelMZ9/Y7FXohqS5rV4/EcJj0JmzAAINIAAAyPd45DTsS/23+t3lFjM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1749228152; c=relaxed/simple; bh=FSJ2NFCigh/zm/yHBe9thSEYQN2IqjgbWwmIYyf+kM8=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=k+dvSi/mCDzImfc9Cw53TK91/7lmlx6CI0TOLgusvFzSFX4zRdnCW2WkiTUivz32gYhrU4VWsA7LId7kxtT9cXt6wB946q8L1GYhEFiwNEDg042H+80W0i7QxixJTZ2WXxHd2Usc0SvPKeLhzkWD+DiIq5jZRvEdqFnGceK/2kw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id AF1B2C4CEED; Fri, 6 Jun 2025 16:42:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1uNaAb-0000000FxAQ-1sqW; Fri, 06 Jun 2025 12:43:53 -0400 Message-ID: <20250606164353.303660896@goodmis.org> User-Agent: quilt/0.68 Date: Fri, 06 Jun 2025 12:42:30 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , stable@vger.kernel.org, "Paul E. McKenney" , "Kiszka, Jan" , "Ziegler, Andreas" , "MOESSBAUER, Felix" , "Flot, Julien" Subject: [for-linus][PATCH 1/3] tracing: Fix regression of filter waiting a long time on RCU synchronization References: <20250606164229.056794577@goodmis.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 When faultable trace events were added, a trace event may no longer use normal RCU to synchronize but instead used synchronize_rcu_tasks_trace(). This synchronization takes a much longer time to synchronize. The filter logic would free the filters by calling tracepoint_synchronize_unregister() after it unhooked the filter strings and before freeing them. With this function now calling synchronize_rcu_tasks_trace() this increased the time to free a filter tremendously. On a PREEMPT_RT system, it was even more noticeable. # time trace-cmd record -p function sleep 1 [..] real 2m29.052s user 0m0.244s sys 0m20.136s As trace-cmd would clear out all the filters before recording, it could take up to 2 minutes to do a recording of "sleep 1". To find out where the issues was: ~# trace-cmd sqlhist -e -n sched_stack select start.prev_state as state, = end.next_comm as comm, TIMESTAMP_DELTA_USECS as delta, start.STACKTRACE as= stack from sched_switch as start join sched_switch as end on start.prev_pi= d =3D end.next_pid Which will produce the following commands (and -e will also execute them): echo 's:sched_stack s64 state; char comm[16]; u64 delta; unsigned long sta= ck[];' >> /sys/kernel/tracing/dynamic_events echo 'hist:keys=3Dprev_pid:__arg_18057_2=3Dprev_state,__arg_18057_4=3Dcomm= on_timestamp.usecs,__arg_18057_7=3Dcommon_stacktrace' >> /sys/kernel/tracin= g/events/sched/sched_switch/trigger echo 'hist:keys=3Dnext_pid:__state_18057_1=3D$__arg_18057_2,__comm_18057_3= =3Dnext_comm,__delta_18057_5=3Dcommon_timestamp.usecs-$__arg_18057_4,__stac= k_18057_6=3D$__arg_18057_7:onmatch(sched.sched_switch).trace(sched_stack,$_= _state_18057_1,$__comm_18057_3,$__delta_18057_5,$__stack_18057_6)' >> /sys/= kernel/tracing/events/sched/sched_switch/trigger The above creates a synthetic event that creates a stack trace when a task schedules out and records it with the time it scheduled back in. Basically the time a task is off the CPU. It also records the state of the task when it left the CPU (running, blocked, sleeping, etc). It also saves the comm of the task as "comm" (needed for the next command). ~# echo 'hist:keys=3Dstate,stack.stacktrace:vals=3Ddelta:sort=3Dstate,delta= if comm =3D=3D "trace-cmd" && state & 3' > /sys/kernel/tracing/events/syn= thetic/sched_stack/trigger The above creates a histogram with buckets per state, per stack, and the value of the total time it was off the CPU for that stack trace. It filters on tasks with "comm =3D=3D trace-cmd" and only the sleeping and blocked sta= tes (1 - sleeping, 2 - blocked). ~# trace-cmd record -p function sleep 1 ~# cat /sys/kernel/tracing/events/synthetic/sched_stack/hist | tail -18 { state: 2, stack.stacktrace __schedule+0x1545/0x3700 schedule+0xe2/0x390 schedule_timeout+0x175/0x200 wait_for_completion_state+0x294/0x440 __wait_rcu_gp+0x247/0x4f0 synchronize_rcu_tasks_generic+0x151/0x230 apply_subsystem_event_filter+0xa2b/0x1300 subsystem_filter_write+0x67/0xc0 vfs_write+0x1e2/0xeb0 ksys_write+0xff/0x1d0 do_syscall_64+0x7b/0x420 entry_SYSCALL_64_after_hwframe+0x76/0x7e } hitcount: 237 delta: 99756288 <<--------------- Delta is 99 se= conds! Totals: Hits: 525 Entries: 21 Dropped: 0 This shows that this particular trace waited for 99 seconds on synchronize_rcu_tasks() in apply_subsystem_event_filter(). In fact, there's a lot of places in the filter code that spends a lot of time waiting for synchronize_rcu_tasks_trace() in order to free the filters. Add helper functions that will use call_rcu*() variants to asynchronously free the filters. This brings the timings back to normal: # time trace-cmd record -p function sleep 1 [..] real 0m14.681s user 0m0.335s sys 0m28.616s And the histogram also shows this: ~# cat /sys/kernel/tracing/events/synthetic/sched_stack/hist | tail -21 { state: 2, stack.stacktrace __schedule+0x1545/0x3700 schedule+0xe2/0x390 schedule_timeout+0x175/0x200 wait_for_completion_state+0x294/0x440 __wait_rcu_gp+0x247/0x4f0 synchronize_rcu_normal+0x3db/0x5c0 tracing_reset_online_cpus+0x8f/0x1e0 tracing_open+0x335/0x440 do_dentry_open+0x4c6/0x17a0 vfs_open+0x82/0x360 path_openat+0x1a36/0x2990 do_filp_open+0x1c5/0x420 do_sys_openat2+0xed/0x180 __x64_sys_openat+0x108/0x1d0 do_syscall_64+0x7b/0x420 } hitcount: 2 delta: 77044 Totals: Hits: 55 Entries: 28 Dropped: 0 Where the total waiting time of synchronize_rcu_tasks_trace() is 77 milliseconds. Cc: stable@vger.kernel.org Cc: Masami Hiramatsu Cc: Mathieu Desnoyers Cc: "Paul E. McKenney" Cc: "Kiszka, Jan" Cc: "Ziegler, Andreas" Cc: "MOESSBAUER, Felix" Link: https://lore.kernel.org/20250605161701.35f7989a@gandalf.local.home Reported-by: "Flot, Julien" Tested-by: Julien Flot Fixes: a363d27cdbc2 ("tracing: Allow system call tracepoints to handle page= faults") Closes: https://lore.kernel.org/all/240017f656631c7dd4017aa93d91f41f653788e= a.camel@siemens.com/ Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 164 ++++++++++++++++++++++------- 1 file changed, 127 insertions(+), 37 deletions(-) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 2048560264bb..3ff782d6b522 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -1335,6 +1335,74 @@ static void filter_free_subsystem_preds(struct trace= _subsystem_dir *dir, } } =20 +struct filter_list { + struct list_head list; + struct event_filter *filter; +}; + +struct filter_head { + struct list_head list; + struct rcu_head rcu; +}; + + +static void free_filter_list(struct rcu_head *rhp) +{ + struct filter_head *filter_list =3D container_of(rhp, struct filter_head,= rcu); + struct filter_list *filter_item, *tmp; + + list_for_each_entry_safe(filter_item, tmp, &filter_list->list, list) { + __free_filter(filter_item->filter); + list_del(&filter_item->list); + kfree(filter_item); + } + kfree(filter_list); +} + +static void free_filter_list_tasks(struct rcu_head *rhp) +{ + call_rcu(rhp, free_filter_list); +} + +/* + * The tracepoint_synchronize_unregister() is a double rcu call. + * It calls synchronize_rcu_tasks_trace() followed by synchronize_rcu(). + * Instead of waiting for it, simply call these via the call_rcu*() + * variants. + */ +static void delay_free_filter(struct filter_head *head) +{ + call_rcu_tasks_trace(&head->rcu, free_filter_list_tasks); +} + +static void try_delay_free_filter(struct event_filter *filter) +{ + struct filter_head *head; + struct filter_list *item; + + head =3D kmalloc(sizeof(*head), GFP_KERNEL); + if (!head) + goto free_now; + + INIT_LIST_HEAD(&head->list); + + item =3D kmalloc(sizeof(*item), GFP_KERNEL); + if (!item) { + kfree(head); + goto free_now; + } + + item->filter =3D filter; + list_add_tail(&item->list, &head->list); + delay_free_filter(head); + return; + + free_now: + /* Make sure the filter is not being used */ + tracepoint_synchronize_unregister(); + __free_filter(filter); +} + static inline void __free_subsystem_filter(struct trace_event_file *file) { __free_filter(file->filter); @@ -1342,15 +1410,53 @@ static inline void __free_subsystem_filter(struct t= race_event_file *file) } =20 static void filter_free_subsystem_filters(struct trace_subsystem_dir *dir, - struct trace_array *tr) + struct trace_array *tr, + struct event_filter *filter) { struct trace_event_file *file; + struct filter_head *head; + struct filter_list *item; + + head =3D kmalloc(sizeof(*head), GFP_KERNEL); + if (!head) + goto free_now; + + INIT_LIST_HEAD(&head->list); + + item =3D kmalloc(sizeof(*item), GFP_KERNEL); + if (!item) { + kfree(head); + goto free_now; + } + + item->filter =3D filter; + list_add_tail(&item->list, &head->list); =20 list_for_each_entry(file, &tr->events, list) { if (file->system !=3D dir) continue; - __free_subsystem_filter(file); + item =3D kmalloc(sizeof(*item), GFP_KERNEL); + if (!item) + goto free_now; + item->filter =3D file->filter; + list_add_tail(&item->list, &head->list); + file->filter =3D NULL; + } + + delay_free_filter(head); + return; + free_now: + tracepoint_synchronize_unregister(); + + if (head) + free_filter_list(&head->rcu); + + list_for_each_entry(file, &tr->events, list) { + if (file->system !=3D dir || !file->filter) + continue; + __free_filter(file->filter); } + __free_filter(filter); } =20 int filter_assign_type(const char *type) @@ -2131,11 +2237,6 @@ static inline void event_clear_filter(struct trace_e= vent_file *file) RCU_INIT_POINTER(file->filter, NULL); } =20 -struct filter_list { - struct list_head list; - struct event_filter *filter; -}; - static int process_system_preds(struct trace_subsystem_dir *dir, struct trace_array *tr, struct filter_parse_error *pe, @@ -2144,11 +2245,16 @@ static int process_system_preds(struct trace_subsys= tem_dir *dir, struct trace_event_file *file; struct filter_list *filter_item; struct event_filter *filter =3D NULL; - struct filter_list *tmp; - LIST_HEAD(filter_list); + struct filter_head *filter_list; bool fail =3D true; int err; =20 + filter_list =3D kmalloc(sizeof(*filter_list), GFP_KERNEL); + if (!filter_list) + return -ENOMEM; + + INIT_LIST_HEAD(&filter_list->list); + list_for_each_entry(file, &tr->events, list) { =20 if (file->system !=3D dir) @@ -2175,7 +2281,7 @@ static int process_system_preds(struct trace_subsyste= m_dir *dir, if (!filter_item) goto fail_mem; =20 - list_add_tail(&filter_item->list, &filter_list); + list_add_tail(&filter_item->list, &filter_list->list); /* * Regardless of if this returned an error, we still * replace the filter for the call. @@ -2195,31 +2301,22 @@ static int process_system_preds(struct trace_subsys= tem_dir *dir, * Do a synchronize_rcu() and to ensure all calls are * done with them before we free them. */ - tracepoint_synchronize_unregister(); - list_for_each_entry_safe(filter_item, tmp, &filter_list, list) { - __free_filter(filter_item->filter); - list_del(&filter_item->list); - kfree(filter_item); - } + delay_free_filter(filter_list); return 0; fail: /* No call succeeded */ - list_for_each_entry_safe(filter_item, tmp, &filter_list, list) { - list_del(&filter_item->list); - kfree(filter_item); - } + free_filter_list(&filter_list->rcu); parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0); return -EINVAL; fail_mem: __free_filter(filter); + /* If any call succeeded, we still need to sync */ if (!fail) - tracepoint_synchronize_unregister(); - list_for_each_entry_safe(filter_item, tmp, &filter_list, list) { - __free_filter(filter_item->filter); - list_del(&filter_item->list); - kfree(filter_item); - } + delay_free_filter(filter_list); + else + free_filter_list(&filter_list->rcu); + return -ENOMEM; } =20 @@ -2361,9 +2458,7 @@ int apply_event_filter(struct trace_event_file *file,= char *filter_string) =20 event_clear_filter(file); =20 - /* Make sure the filter is not being used */ - tracepoint_synchronize_unregister(); - __free_filter(filter); + try_delay_free_filter(filter); =20 return 0; } @@ -2387,11 +2482,8 @@ int apply_event_filter(struct trace_event_file *file= , char *filter_string) =20 event_set_filter(file, filter); =20 - if (tmp) { - /* Make sure the call is done with the filter */ - tracepoint_synchronize_unregister(); - __free_filter(tmp); - } + if (tmp) + try_delay_free_filter(tmp); } =20 return err; @@ -2417,9 +2509,7 @@ int apply_subsystem_event_filter(struct trace_subsyst= em_dir *dir, filter =3D system->filter; system->filter =3D NULL; /* Ensure all filters are no longer used */ - tracepoint_synchronize_unregister(); - filter_free_subsystem_filters(dir, tr); - __free_filter(filter); + filter_free_subsystem_filters(dir, tr, filter); return 0; } =20 --=20 2.47.2 From nobody Sat Feb 7 13:41:03 2026 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 3557428A1C3; Fri, 6 Jun 2025 16:42:31 +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=1749228152; cv=none; b=PBYE+EuiQKoLmm5+qEmGKaV9uH3mfprvnOTcm5Kt9n9+m7Km+fZqCPmh2BwyW5il2QKA+M+kcwLfRDM2quDye7T5G3rBEN2eECdr1BRm38K1cTiD0dcbw8L7w5w98k92aLAq1XB9nUKvxF2CVDV0vZgxds933fZwwX0Ot4H8ydo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1749228152; c=relaxed/simple; bh=bup0VwhlRIh0zyMHrfXhnPPznLi8Kh/TsT1pQRvseL0=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=sI2TMz8RxenVYad/UX+2Wok7WYCktsoZdlDiw3G/Nnq3OjNGZ3TOO6+vvygwbUjfLCjGCgLTL3yd53TwfnztjRe2GQO2L84awZ18sXLcIcy44CchssPnSxE4cFNEGQHqxeF1/vG6sKX0MaQjnsZnNmHu9bdDhCYsQYIDa93DoU0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id DCEF3C4CEF6; Fri, 6 Jun 2025 16:42:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1uNaAb-0000000FxAu-2a8Y; Fri, 06 Jun 2025 12:43:53 -0400 Message-ID: <20250606164353.472136191@goodmis.org> User-Agent: quilt/0.68 Date: Fri, 06 Jun 2025 12:42:31 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , stable@vger.kernel.org, Tzvetomir Stoyanov , syzbot+05d673e83ec640f0ced9@syzkaller.appspotmail.com, Dmitry Antipov Subject: [for-linus][PATCH 2/3] ring-buffer: Fix buffer locking in ring_buffer_subbuf_order_set() References: <20250606164229.056794577@goodmis.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: Dmitry Antipov Enlarge the critical section in ring_buffer_subbuf_order_set() to ensure that error handling takes place with per-buffer mutex held, thus preventing list corruption and other concurrency-related issues. Cc: stable@vger.kernel.org Cc: Masami Hiramatsu Cc: Mathieu Desnoyers Cc: Tzvetomir Stoyanov Link: https://lore.kernel.org/20250606112242.1510605-1-dmantipov@yandex.ru Reported-by: syzbot+05d673e83ec640f0ced9@syzkaller.appspotmail.com Closes: https://syzkaller.appspot.com/bug?extid=3D05d673e83ec640f0ced9 Fixes: f9b94daa542a8 ("ring-buffer: Set new size of the ring buffer sub pag= e") Signed-off-by: Dmitry Antipov Signed-off-by: Steven Rostedt (Google) --- kernel/trace/ring_buffer.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c index e24509bd0af5..00fc38d70e86 100644 --- a/kernel/trace/ring_buffer.c +++ b/kernel/trace/ring_buffer.c @@ -6795,7 +6795,7 @@ int ring_buffer_subbuf_order_set(struct trace_buffer = *buffer, int order) old_size =3D buffer->subbuf_size; =20 /* prevent another thread from changing buffer sizes */ - mutex_lock(&buffer->mutex); + guard(mutex)(&buffer->mutex); atomic_inc(&buffer->record_disabled); =20 /* Make sure all commits have finished */ @@ -6900,7 +6900,6 @@ int ring_buffer_subbuf_order_set(struct trace_buffer = *buffer, int order) } =20 atomic_dec(&buffer->record_disabled); - mutex_unlock(&buffer->mutex); =20 return 0; =20 @@ -6909,7 +6908,6 @@ int ring_buffer_subbuf_order_set(struct trace_buffer = *buffer, int order) buffer->subbuf_size =3D old_size; =20 atomic_dec(&buffer->record_disabled); - mutex_unlock(&buffer->mutex); =20 for_each_buffer_cpu(buffer, cpu) { cpu_buffer =3D buffer->buffers[cpu]; --=20 2.47.2 From nobody Sat Feb 7 13:41:03 2026 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 4DEA728A1C8 for ; Fri, 6 Jun 2025 16:42:32 +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=1749228152; cv=none; b=YR2wr7Y1+DsoFJ384TQsjgD8L/AFuRayjKnrl6sc9x9PQYnjXANibRgtuyZXfioXdY36hjAa/XYuUhfGC+IUa01Tduf71StLOKeSnhpECO90WPkPUEmj21sW094kCOX7Kr34ZFq326Mc1enkSuTx/VusMaLdA0SR3VqF2wNoiw0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1749228152; c=relaxed/simple; bh=Zh4DYLLc6LRnPaiVi1pXn4qtE4dSZzifVgcG+mx9aQM=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=CDU4Ksh/c3QXZj1ZUecp4EvPKft1qaIbl3/ACjOHOBgMr4BEaLm+2odusMox6eyWBM3HWs0wt/LcNFfE3gCceNK9BxgEAaHNkYkpDEf9h6tNUIXQfWq/vP372D1OX/hJTUc1AvpgsGCm/uzbpbYPOqa7arXUTRzqwMsGVVMjKXs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 044B1C4CEF2; Fri, 6 Jun 2025 16:42:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1uNaAb-0000000FxBO-3Izn; Fri, 06 Jun 2025 12:43:53 -0400 Message-ID: <20250606164353.637944319@goodmis.org> User-Agent: quilt/0.68 Date: Fri, 06 Jun 2025 12:42:32 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Ingo Molnar , Kajetan Puchalski , "Rafael J. Wysocki" Subject: [for-linus][PATCH 3/3] tracing: PM: Remove unused clock events References: <20250606164229.056794577@goodmis.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 events clock_enable, clock_disable, and clock_set_rate were added back in 2010. In 2011 they were used by the arm architecture but removed in 2013. These events add around 7K of memory which was wasted for the last 12 years. Remove them. Link: https://lore.kernel.org/all/20250529130138.544ffec4@gandalf.local.hom= e/ Cc: Masami Hiramatsu Cc: Mathieu Desnoyers Cc: Peter Zijlstra Cc: Ingo Molnar Cc: Kajetan Puchalski Acked-by: Rafael J. Wysocki Link: https://lore.kernel.org/20250605162106.1a459dad@gandalf.local.home Fixes: 74704ac6ea402 ("tracing, perf: Add more power related events") Signed-off-by: Steven Rostedt (Google) --- include/trace/events/power.h | 47 ------------------------------------ 1 file changed, 47 deletions(-) diff --git a/include/trace/events/power.h b/include/trace/events/power.h index 9253e83b9bb4..6c631eec23e3 100644 --- a/include/trace/events/power.h +++ b/include/trace/events/power.h @@ -337,53 +337,6 @@ DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, TP_ARGS(name, state) ); =20 -/* - * The clock events are used for clock enable/disable and for - * clock rate change - */ -DECLARE_EVENT_CLASS(clock, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id), - - TP_STRUCT__entry( - __string( name, name ) - __field( u64, state ) - __field( u64, cpu_id ) - ), - - TP_fast_assign( - __assign_str(name); - __entry->state =3D state; - __entry->cpu_id =3D cpu_id; - ), - - TP_printk("%s state=3D%lu cpu_id=3D%lu", __get_str(name), - (unsigned long)__entry->state, (unsigned long)__entry->cpu_id) -); - -DEFINE_EVENT(clock, clock_enable, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id) -); - -DEFINE_EVENT(clock, clock_disable, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id) -); - -DEFINE_EVENT(clock, clock_set_rate, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id) -); - /* * The power domain events are used for power domains transitions */ --=20 2.47.2