mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-11-03 01:59:51 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

tracing: Remove EVENT_FILE_FL_SOFT_MODE flag

Browse source 
When soft disabling of trace events was first created, it needed to have a
way to know if a file had a user that was using it with soft disabled (for
triggers that need to enable or disable events from a context that can not
really enable or disable the event, it would set SOFT_DISABLED to state it
is disabled). The flag SOFT_MODE was used to denote that an event had a
user that would enable or disable it via the SOFT_DISABLED flag.

Commit 1cf4c0732d ("tracing: Modify soft-mode only if there's no other
referrer") fixed a bug where if two users were using the SOFT_DISABLED
flag the accounting would get messed up as the SOFT_MODE flag could only
handle one user. That commit added the sm_ref counter which kept track of
how many users were using the event in "soft mode". This made the
SOFT_MODE flag redundant as it should only be set if the sm_ref counter is
non zero.

Remove the SOFT_MODE flag and just use the sm_ref counter to know the
event is in soft mode or not. This makes the code a bit simpler.

Link: https://lore.kernel.org/all/20250702111908.03759998@batman.local.home/

Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Gabriele Paoloni <gpaoloni@redhat.com>
Link: https://lore.kernel.org/20250702143657.18dd1882@batman.local.home
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>
This commit is contained in:
Steven Rostedt 2025-07-02 14:36:57 -04:00 committed by Steven Rostedt (Google)
parent c897c1e5b1
commit 07c3f391bc
2 changed files with 12 additions and 15 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

3
include/linux/trace_events.h
View file

@ -480,7 +480,6 @@ enum {
EVENT_FILE_FL_RECORDED_TGID_BIT, EVENT_FILE_FL_RECORDED_TGID_BIT,
EVENT_FILE_FL_FILTERED_BIT, EVENT_FILE_FL_FILTERED_BIT,
EVENT_FILE_FL_NO_SET_FILTER_BIT, EVENT_FILE_FL_NO_SET_FILTER_BIT,
EVENT_FILE_FL_SOFT_MODE_BIT,
EVENT_FILE_FL_SOFT_DISABLED_BIT, EVENT_FILE_FL_SOFT_DISABLED_BIT,
EVENT_FILE_FL_TRIGGER_MODE_BIT, EVENT_FILE_FL_TRIGGER_MODE_BIT,
EVENT_FILE_FL_TRIGGER_COND_BIT, EVENT_FILE_FL_TRIGGER_COND_BIT,
@ -618,7 +617,6 @@ extern int __kprobe_event_add_fields(struct dynevent_cmd *cmd, ...);
* RECORDED_TGID - The tgids should be recorded at sched_switch * RECORDED_TGID - The tgids should be recorded at sched_switch
* FILTERED - The event has a filter attached * FILTERED - The event has a filter attached
* NO_SET_FILTER - Set when filter has error and is to be ignored * NO_SET_FILTER - Set when filter has error and is to be ignored
* SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED
* SOFT_DISABLED - When set, do not trace the event (even though its * SOFT_DISABLED - When set, do not trace the event (even though its
* tracepoint may be enabled) * tracepoint may be enabled)
* TRIGGER_MODE - When set, invoke the triggers associated with the event * TRIGGER_MODE - When set, invoke the triggers associated with the event
@ -633,7 +631,6 @@ enum {
EVENT_FILE_FL_RECORDED_TGID = (1 << EVENT_FILE_FL_RECORDED_TGID_BIT), EVENT_FILE_FL_RECORDED_TGID = (1 << EVENT_FILE_FL_RECORDED_TGID_BIT),
EVENT_FILE_FL_FILTERED = (1 << EVENT_FILE_FL_FILTERED_BIT), EVENT_FILE_FL_FILTERED = (1 << EVENT_FILE_FL_FILTERED_BIT),
EVENT_FILE_FL_NO_SET_FILTER = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT), EVENT_FILE_FL_NO_SET_FILTER = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT),
EVENT_FILE_FL_SOFT_MODE = (1 << EVENT_FILE_FL_SOFT_MODE_BIT),
EVENT_FILE_FL_SOFT_DISABLED = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT), EVENT_FILE_FL_SOFT_DISABLED = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT),
EVENT_FILE_FL_TRIGGER_MODE = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT), EVENT_FILE_FL_TRIGGER_MODE = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT),
EVENT_FILE_FL_TRIGGER_COND = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT), EVENT_FILE_FL_TRIGGER_COND = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT),

24
kernel/trace/trace_events.c
View file

@ -768,6 +768,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
{ {
struct trace_event_call *call = file->event_call; struct trace_event_call *call = file->event_call;
struct trace_array *tr = file->tr; struct trace_array *tr = file->tr;
bool soft_mode = atomic_read(&file->sm_ref) != 0;
int ret = 0; int ret = 0;
int disable; int disable;
@ -782,7 +783,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
* is set we do not want the event to be enabled before we * is set we do not want the event to be enabled before we
* clear the bit. * clear the bit.
* *
* When soft_disable is not set but the SOFT_MODE flag is, * When soft_disable is not set but the soft_mode is,
* we do nothing. Do not disable the tracepoint, otherwise * we do nothing. Do not disable the tracepoint, otherwise
* "soft enable"s (clearing the SOFT_DISABLED bit) wont work. * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
*/ */
@ -790,11 +791,11 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
if (atomic_dec_return(&file->sm_ref) > 0) if (atomic_dec_return(&file->sm_ref) > 0)
break; break;
disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED; disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;
clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags); soft_mode = false;
/* Disable use of trace_buffered_event */ /* Disable use of trace_buffered_event */
trace_buffered_event_disable(); trace_buffered_event_disable();
} else } else
disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE); disable = !soft_mode;
if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) { if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {
clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags); clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
@ -812,8 +813,8 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
WARN_ON_ONCE(ret); WARN_ON_ONCE(ret);
} }
/* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */ /* If in soft mode, just set the SOFT_DISABLE_BIT, else clear it */
if (file->flags & EVENT_FILE_FL_SOFT_MODE) if (soft_mode)
set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags); set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
else else
clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags); clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
@ -823,7 +824,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
* When soft_disable is set and enable is set, we want to * When soft_disable is set and enable is set, we want to
* register the tracepoint for the event, but leave the event * register the tracepoint for the event, but leave the event
* as is. That means, if the event was already enabled, we do * as is. That means, if the event was already enabled, we do
* nothing (but set SOFT_MODE). If the event is disabled, we * nothing (but set soft_mode). If the event is disabled, we
* set SOFT_DISABLED before enabling the event tracepoint, so * set SOFT_DISABLED before enabling the event tracepoint, so
* it still seems to be disabled. * it still seems to be disabled.
*/ */
@ -832,7 +833,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
else { else {
if (atomic_inc_return(&file->sm_ref) > 1) if (atomic_inc_return(&file->sm_ref) > 1)
break; break;
set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags); soft_mode = true;
/* Enable use of trace_buffered_event */ /* Enable use of trace_buffered_event */
trace_buffered_event_enable(); trace_buffered_event_enable();
} }
@ -840,7 +841,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
if (!(file->flags & EVENT_FILE_FL_ENABLED)) { if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
bool cmd = false, tgid = false; bool cmd = false, tgid = false;
/* Keep the event disabled, when going to SOFT_MODE. */ /* Keep the event disabled, when going to soft mode. */
if (soft_disable) if (soft_disable)
set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags); set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
@ -1792,8 +1793,7 @@ event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
!(flags & EVENT_FILE_FL_SOFT_DISABLED)) !(flags & EVENT_FILE_FL_SOFT_DISABLED))
strcpy(buf, "1"); strcpy(buf, "1");
if (flags & EVENT_FILE_FL_SOFT_DISABLED || if (atomic_read(&file->sm_ref) != 0)
flags & EVENT_FILE_FL_SOFT_MODE)
strcat(buf, "*"); strcat(buf, "*");
strcat(buf, "\n"); strcat(buf, "\n");
@ -3584,7 +3584,7 @@ static int probe_remove_event_call(struct trace_event_call *call)
continue; continue;
/* /*
* We can't rely on ftrace_event_enable_disable(enable => 0) * We can't rely on ftrace_event_enable_disable(enable => 0)
* we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress * we are going to do, soft mode can suppress
* TRACE_REG_UNREGISTER. * TRACE_REG_UNREGISTER.
*/ */
if (file->flags & EVENT_FILE_FL_ENABLED) if (file->flags & EVENT_FILE_FL_ENABLED)
@ -3997,7 +3997,7 @@ static int free_probe_data(void *data)
edata->ref--; edata->ref--;
if (!edata->ref) { if (!edata->ref) {
/* Remove the SOFT_MODE flag */ /* Remove soft mode */
__ftrace_event_enable_disable(edata->file, 0, 1); __ftrace_event_enable_disable(edata->file, 0, 1);
trace_event_put_ref(edata->file->event_call); trace_event_put_ref(edata->file->event_call);
kfree(edata); kfree(edata);