On Mon, 9 Mar 2026 13:52:19 -0600
Wesley Atwell <[email protected]> wrote:
> Bootconfig expands arrays into repeated param=value entries, and the
> kernel command line can repeat the same tracing parameter as well.
> Several tracing __setup() handlers still overwrite their boot buffers,
> so only the last ftrace filter, graph filter, trace option, kprobe
> event, or trace trigger entry survives boot.
Actually I expected to use it as a string instead of array.
kernel.ftrace_filter="funcA,funcB,funcC"
Because this "funcA,funcB,funcC" is the parameter for ftrace_filter
option.
And admins can choose to specify it as an array or a string by themselves.
(according to the behavior)
For parameters which supports appending values.
param=value1, value2, value3
For parameters which does NOT supports appending values.
param="value1,value2,value3"
The problem, if there is one, is that admin-guide/kernel-parameters.txt
doesn't provide any information about this behavior.
(Whether the subsequent parameters should overwrite, be appended,
or be ignored)
Maybe it is better to document it.
>
> Preserve repeated values in the format their existing parsers already
> consume: comma-delimited lists for ftrace filters and trace options,
> semicolon-delimited lists for kprobe events, and per-chunk parsing for
> trace_trigger=. The trace_trigger parser tokenizes its storage in
> place, so keep a running length and only parse the newly appended
> chunk into bootup_triggers[].
>
> Fixes: 2af15d6a44b8 ("ftrace: add kernel command line function filtering")
> Fixes: 7bcfaf54f591 ("tracing: Add trace_options kernel command line
> parameter")
> Fixes: a01fdc897fa5 ("tracing: Add trace_trigger kernel command line option")
> Fixes: 970988e19eb0 ("tracing/kprobe: Add kprobe_event= boot parameter")
And I think this is improvement to support appending subsequent parameters.
Not Fix, because this is not a bug.
> Signed-off-by: Wesley Atwell <[email protected]>
> ---
> kernel/trace/ftrace.c | 29 +++++++++++++++++++++++++----
> kernel/trace/trace.c | 23 ++++++++++++++++++++++-
> kernel/trace/trace_events.c | 23 ++++++++++++++++++++---
> kernel/trace/trace_kprobe.c | 23 ++++++++++++++++++++++-
> 4 files changed, 89 insertions(+), 9 deletions(-)
>
> diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
> index 8df69e702706..cdd46f639333 100644
> --- a/kernel/trace/ftrace.c
> +++ b/kernel/trace/ftrace.c
> @@ -6835,13 +6835,34 @@ EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
> static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
> static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
>
> +static void __init append_ftrace_boot_param(char *buf, const char *str,
> + char sep)
> +{
> + size_t len, str_len;
> +
> + if (buf[0] == '\0') {
> + strscpy(buf, str, FTRACE_FILTER_SIZE);
> + return;
> + }
> +
> + len = strlen(buf);
> + str_len = strlen(str);
> + if (!str_len)
> + return;
> + if (str_len >= FTRACE_FILTER_SIZE - len - 1)
> + return;
> +
> + buf[len] = sep;
> + strscpy(buf + len + 1, str, FTRACE_FILTER_SIZE - len - 1);
> +}
Please make a generic append function in kernel/trace/trace.h, e.g.
void trace_append_boot_param(char *buf, const char *str, char sep, size_t
ssize);
and use it instead of strscpy.
Thank you,
> +
> /* Used by function selftest to not test if filter is set */
> bool ftrace_filter_param __initdata;
>
> static int __init set_ftrace_notrace(char *str)
> {
> ftrace_filter_param = true;
> - strscpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE);
> + append_ftrace_boot_param(ftrace_notrace_buf, str, ',');
> return 1;
> }
> __setup("ftrace_notrace=", set_ftrace_notrace);
> @@ -6849,7 +6870,7 @@ __setup("ftrace_notrace=", set_ftrace_notrace);
> static int __init set_ftrace_filter(char *str)
> {
> ftrace_filter_param = true;
> - strscpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE);
> + append_ftrace_boot_param(ftrace_filter_buf, str, ',');
> return 1;
> }
> __setup("ftrace_filter=", set_ftrace_filter);
> @@ -6861,14 +6882,14 @@ static int ftrace_graph_set_hash(struct ftrace_hash
> *hash, char *buffer);
>
> static int __init set_graph_function(char *str)
> {
> - strscpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
> + append_ftrace_boot_param(ftrace_graph_buf, str, ',');
> return 1;
> }
> __setup("ftrace_graph_filter=", set_graph_function);
>
> static int __init set_graph_notrace_function(char *str)
> {
> - strscpy(ftrace_graph_notrace_buf, str, FTRACE_FILTER_SIZE);
> + append_ftrace_boot_param(ftrace_graph_notrace_buf, str, ',');
> return 1;
> }
> __setup("ftrace_graph_notrace=", set_graph_notrace_function);
> diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
> index ebd996f8710e..42d03d36ae39 100644
> --- a/kernel/trace/trace.c
> +++ b/kernel/trace/trace.c
> @@ -327,9 +327,30 @@ __setup("trace_instance=", boot_instance);
>
> static char trace_boot_options_buf[MAX_TRACER_SIZE] __initdata;
>
> +static void __init append_trace_boot_options(const char *str)
> +{
> + size_t len, str_len;
> +
> + if (trace_boot_options_buf[0] == '\0') {
> + strscpy(trace_boot_options_buf, str, MAX_TRACER_SIZE);
> + return;
> + }
> +
> + len = strlen(trace_boot_options_buf);
> + str_len = strlen(str);
> + if (!str_len)
> + return;
> + if (str_len >= MAX_TRACER_SIZE - len - 1)
> + return;
> +
> + trace_boot_options_buf[len] = ',';
> + strscpy(trace_boot_options_buf + len + 1, str,
> + MAX_TRACER_SIZE - len - 1);
> +}
> +
> static int __init set_trace_boot_options(char *str)
> {
> - strscpy(trace_boot_options_buf, str, MAX_TRACER_SIZE);
> + append_trace_boot_options(str);
> return 1;
> }
> __setup("trace_options=", set_trace_boot_options);
> diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
> index 249d1cba72c0..c3981f62e4bc 100644
> --- a/kernel/trace/trace_events.c
> +++ b/kernel/trace/trace_events.c
> @@ -3679,20 +3679,37 @@ static struct boot_triggers {
> } bootup_triggers[MAX_BOOT_TRIGGERS];
>
> static char bootup_trigger_buf[COMMAND_LINE_SIZE];
> +static int bootup_trigger_buf_len;
> static int nr_boot_triggers;
>
> static __init int setup_trace_triggers(char *str)
> {
> char *trigger;
> char *buf;
> + ssize_t copied;
> int i;
> + int start;
>
> - strscpy(bootup_trigger_buf, str, COMMAND_LINE_SIZE);
> + if (bootup_trigger_buf_len >= COMMAND_LINE_SIZE)
> + return 1;
> +
> + start = bootup_trigger_buf_len;
> + if (start && !*str)
> + return 1;
> +
> + copied = strscpy(bootup_trigger_buf + start, str,
> + COMMAND_LINE_SIZE - start);
> + if (copied < 0) {
> + if (start)
> + return 1;
> + copied = strlen(bootup_trigger_buf + start);
> + }
> + bootup_trigger_buf_len += copied + 1;
> trace_set_ring_buffer_expanded(NULL);
> disable_tracing_selftest("running event triggers");
>
> - buf = bootup_trigger_buf;
> - for (i = 0; i < MAX_BOOT_TRIGGERS; i++) {
> + buf = bootup_trigger_buf + start;
> + for (i = nr_boot_triggers; i < MAX_BOOT_TRIGGERS; i++) {
> trigger = strsep(&buf, ",");
> if (!trigger)
> break;
> diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
> index a5dbb72528e0..a63a56b55570 100644
> --- a/kernel/trace/trace_kprobe.c
> +++ b/kernel/trace/trace_kprobe.c
> @@ -29,9 +29,30 @@
> /* Kprobe early definition from command line */
> static char kprobe_boot_events_buf[COMMAND_LINE_SIZE] __initdata;
>
> +static void __init append_kprobe_boot_event(const char *str)
> +{
> + size_t len, str_len;
> +
> + if (kprobe_boot_events_buf[0] == '\0') {
> + strscpy(kprobe_boot_events_buf, str, COMMAND_LINE_SIZE);
> + return;
> + }
> +
> + len = strlen(kprobe_boot_events_buf);
> + str_len = strlen(str);
> + if (!str_len)
> + return;
> + if (str_len >= COMMAND_LINE_SIZE - len - 1)
> + return;
> +
> + kprobe_boot_events_buf[len] = ';';
> + strscpy(kprobe_boot_events_buf + len + 1, str,
> + COMMAND_LINE_SIZE - len - 1);
> +}
> +
> static int __init set_kprobe_boot_events(char *str)
> {
> - strscpy(kprobe_boot_events_buf, str, COMMAND_LINE_SIZE);
> + append_kprobe_boot_event(str);
> disable_tracing_selftest("running kprobe events");
>
> return 1;
> --
> 2.34.1
>
--
Masami Hiramatsu (Google) <[email protected]>
