From nobody Mon Feb 9 08:36:24 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 808FF125B2; Wed, 28 Jan 2026 00:09:51 +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=1769558991; cv=none; b=gFKwqYtIGCqwnFyqJULLYBLL38eD1fHyRHPSqkmof4rvQl6pm/zimaAtEBcRSHBNIo81sXZGr9imzLAEfYENFeVoSoPUOqW6vojT+fRmoSTYpF3Q7RlB/68O+/Ef7fg6KZ5RxcijZOaCluuRaYlAoUxaC5PLi9vF0+0XH8WAH4U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769558991; c=relaxed/simple; bh=YQL7l01WmvmK7If7bIbiNydjrUoMH+8UyFa2Eop9bCU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=Q3TX6XOcu+ke6MomqZBM3lt1BcdCBPPhzSqLf3lEPh2ElqFfhWtWh71lg0zM2brB1oeM/x+iqcaAWQyeXNlmerVQNWtVPYhT3786y22WcGg2znJbH/OvKvvMFFxKdoskymdjz1T+PCGdgAmTDMDed/YhkQft70SHf2786rQQhqU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=tin/Aphc; 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="tin/Aphc" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 60C2FC116C6; Wed, 28 Jan 2026 00:09:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1769558991; bh=YQL7l01WmvmK7If7bIbiNydjrUoMH+8UyFa2Eop9bCU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=tin/AphcIAZJu10ZgsmeMDWfmjiHW6uDdOiPv7qgSiFkNRWzUI+CFUNxNo/5mceh2 PINIw1mcmOFS5TigHz/l/plSxEWtHtMtgl+Ek6/9XV9NV6dKWO0DtU4kY0upZZJlwZ xmGAWJC8kl0bhyYKs8JhS0EjCUCgeYgCSfUgFTR5CAe5G8snhZXI5dA/oIokvUk8u7 ePwmlzsFMj/5u8e2rd8TnWFcyJtNVNJdHA52+tc6XVWF5nuTFq5nDNzy8uVxeTUHZk 1hMSvO+JiUuswIqYKZkYLCA6qhE2OR8me5XLtL75X/lCcKGnKjTkpNmgS4W74WJsjr sFy3OfXFKbcBA== From: "Masami Hiramatsu (Google)" To: Steven Rostedt Cc: Masami Hiramatsu , Mathieu Desnoyers , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH v5 1/4] tracing: Reset last_boot_info if ring buffer is reset Date: Wed, 28 Jan 2026 09:09:48 +0900 Message-ID: <176955898871.2786091.11770303255491867688.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.52.0.457.g6b5491de43-goog In-Reply-To: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> References: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> User-Agent: StGit/0.19 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Masami Hiramatsu (Google) Commit 32dc0042528d ("tracing: Reset last-boot buffers when reading out all cpu buffers") resets the last_boot_info when user read out all data via trace_pipe* files. But it is not reset when user resets the buffer from other files. (e.g. write `trace` file) Reset it when the corresponding ring buffer is reset too. Fixes: 32dc0042528d ("tracing: Reset last-boot buffers when reading out all= cpu buffers") Signed-off-by: Masami Hiramatsu (Google) --- kernel/trace/trace.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index 396d59202438..5c3e4a554143 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -4891,6 +4891,8 @@ static int tracing_single_release_tr(struct inode *in= ode, struct file *file) return single_release(inode, file); } =20 +static bool update_last_data_if_empty(struct trace_array *tr); + static int tracing_open(struct inode *inode, struct file *file) { struct trace_array *tr =3D inode->i_private; @@ -4915,6 +4917,8 @@ static int tracing_open(struct inode *inode, struct f= ile *file) tracing_reset_online_cpus(trace_buf); else tracing_reset_cpu(trace_buf, cpu); + + update_last_data_if_empty(tr); } =20 if (file->f_mode & FMODE_READ) { @@ -5981,6 +5985,7 @@ tracing_set_trace_read(struct file *filp, char __user= *ubuf, int tracer_init(struct tracer *t, struct trace_array *tr) { tracing_reset_online_cpus(&tr->array_buffer); + update_last_data_if_empty(tr); return t->init(tr); } =20 @@ -7799,6 +7804,7 @@ int tracing_set_clock(struct trace_array *tr, const c= har *clockstr) ring_buffer_set_clock(tr->max_buffer.buffer, trace_clocks[i].func); tracing_reset_online_cpus(&tr->max_buffer); #endif + update_last_data_if_empty(tr); =20 if (tr->scratch && !(tr->flags & TRACE_ARRAY_FL_LAST_BOOT)) { struct trace_scratch *tscratch =3D tr->scratch; @@ -8036,6 +8042,7 @@ tracing_snapshot_write(struct file *filp, const char = __user *ubuf, size_t cnt, tracing_reset_online_cpus(&tr->max_buffer); else tracing_reset_cpu(&tr->max_buffer, iter->cpu_file); + update_last_data_if_empty(tr); } break; } From nobody Mon Feb 9 08:36:24 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 381DF54763; Wed, 28 Jan 2026 00:09:58 +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=1769558999; cv=none; b=f6I/TNNFQr0lK2Phuo5/lMEAE6Jxy5Bk5eJB+5jk1K+QOXUKSOM7CFm6IU0WUsKMqgnVEL4DRvuPyHr60+pI9dUZVKYH6HvgjAjzvKkDVPvlzWLySqrjSosHKwPHiiiscZYE6+rBdsQ1esHbqcegFLeK2E/l6Ekz2F9ly6PdVLk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769558999; c=relaxed/simple; bh=q07aM63YjTfMX+ey1OkBRNKBZwL5uaUoaVu+H3zb1no=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=gdkHEGOISJyMX70gyplmXtJIjRnM2BhQhxd0YDMlZWOJr66Bj29VeB76UK2sm/gbvcQmZ59MLmuNoufJfaJoGivRVbJZnockHJyzlSmgGsrCy+ksqzB95jpfecTfN3pEHh6fEBRURinfgUfOkVwu3eZaC96cGsXzbev/f73dVec= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=MXnwiFZp; 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="MXnwiFZp" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1A471C116C6; Wed, 28 Jan 2026 00:09:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1769558998; bh=q07aM63YjTfMX+ey1OkBRNKBZwL5uaUoaVu+H3zb1no=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=MXnwiFZpufWK1xccKdnQ0Oh9umNLAZzqxTsP6pDIM9ZXvfhG1Qjqs4+DYe5ve8zOZ JZzVH0pidjr365fSEa9yUcgEgAYoFn3OZKe9mkNSJBMwR5RiJNjwIx89WZ0pbL5xhY 7vIm4L4EfLx6BSPZp1J27F6lTBwXaVTFLyY3riBXPQ08w9PmdNpWTRuOePao7qRsTV PpUxGhB/QUsx4ZO7zP5p43vpmNnOUFh5MAqL28I15gNPqDSrtQ7raI9ezHD2X79Ov0 tUblBVsS+jiLGmbP2XswDyxGzZE2aqqwtsO6TuP0ICXqQ4wDVePX1QYK659aAzKZgK OXC6/Ely4x/iA== From: "Masami Hiramatsu (Google)" To: Steven Rostedt Cc: Masami Hiramatsu , Mathieu Desnoyers , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH v5 2/4] tracing: Make the backup instance non-reusable Date: Wed, 28 Jan 2026 09:09:56 +0900 Message-ID: <176955899639.2786091.8716448298561300937.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.52.0.457.g6b5491de43-goog In-Reply-To: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> References: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> User-Agent: StGit/0.19 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Masami Hiramatsu (Google) Since there is no reason to reuse the backup instance, make it readonly (but erasable). Note that only backup instances are readonly, because other trace instances will be empty unless it is writable. Only backup instances have copy entries from the original. With this change, most of the trace control files are removed from the backup instance, including eventfs enable/filter etc. # find /sys/kernel/tracing/instances/backup/events/ | wc -l 4093 # find /sys/kernel/tracing/instances/boot_map/events/ | wc -l 9573 Signed-off-by: Masami Hiramatsu (Google) --- Changes in v5: - Rebased on the latest for-next (and hide show_event_filters/triggers if the instance is readonly. Changes in v4: - Make trace data erasable. (not reusable) Changes in v3: - Resuse the beginning part of event_entries for readonly files. - Remove readonly file_operations and checking readonly flag in each write operation. Changes in v2: - Use readonly file_operations to prohibit writing instead of checking flags in write() callbacks. - Remove writable files from eventfs. --- kernel/trace/trace.c | 93 ++++++++++++++++++++++++++++++---------= ---- kernel/trace/trace.h | 8 +++- kernel/trace/trace_boot.c | 5 +- kernel/trace/trace_events.c | 80 ++++++++++++++++++++++++------------- 4 files changed, 126 insertions(+), 60 deletions(-) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index 5c3e4a554143..d39f6509c12a 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -5052,6 +5052,11 @@ static ssize_t tracing_write_stub(struct file *filp, const char __user *ubuf, size_t count, loff_t *ppos) { + struct trace_array *tr =3D file_inode(filp)->i_private; + + if (trace_array_is_readonly(tr)) + return -EPERM; + return count; } =20 @@ -5152,6 +5157,9 @@ tracing_cpumask_write(struct file *filp, const char _= _user *ubuf, cpumask_var_t tracing_cpumask_new; int err; =20 + if (trace_array_is_readonly(tr)) + return -EPERM; + if (count =3D=3D 0 || count > KMALLOC_MAX_SIZE) return -EINVAL; =20 @@ -6436,6 +6444,9 @@ tracing_set_trace_write(struct file *filp, const char= __user *ubuf, size_t ret; int err; =20 + if (trace_array_is_readonly(tr)) + return -EPERM; + ret =3D cnt; =20 if (cnt > MAX_TRACER_SIZE) @@ -7070,6 +7081,9 @@ tracing_entries_write(struct file *filp, const char _= _user *ubuf, unsigned long val; int ret; =20 + if (trace_array_is_readonly(tr)) + return -EPERM; + ret =3D kstrtoul_from_user(ubuf, cnt, 10, &val); if (ret) return ret; @@ -7824,6 +7838,9 @@ static ssize_t tracing_clock_write(struct file *filp,= const char __user *ubuf, const char *clockstr; int ret; =20 + if (trace_array_is_readonly(tr)) + return -EPERM; + if (cnt >=3D sizeof(buf)) return -EINVAL; =20 @@ -9388,12 +9405,16 @@ static void tracing_init_tracefs_percpu(struct trace_array *tr, long cpu) { struct dentry *d_percpu =3D tracing_dentry_percpu(tr, cpu); + umode_t writable_mode =3D TRACE_MODE_WRITE; struct dentry *d_cpu; char cpu_dir[30]; /* 30 characters should be more than enough */ =20 if (!d_percpu) return; =20 + if (trace_array_is_readonly(tr)) + writable_mode =3D TRACE_MODE_READ; + snprintf(cpu_dir, 30, "cpu%ld", cpu); d_cpu =3D tracefs_create_dir(cpu_dir, d_percpu); if (!d_cpu) { @@ -9616,7 +9637,6 @@ struct dentry *trace_create_file(const char *name, return ret; } =20 - static struct dentry *trace_options_init_dentry(struct trace_array *tr) { struct dentry *d_tracer; @@ -9846,6 +9866,9 @@ rb_simple_write(struct file *filp, const char __user = *ubuf, unsigned long val; int ret; =20 + if (trace_array_is_readonly(tr)) + return -EPERM; + ret =3D kstrtoul_from_user(ubuf, cnt, 10, &val); if (ret) return ret; @@ -9952,6 +9975,9 @@ buffer_subbuf_size_write(struct file *filp, const cha= r __user *ubuf, int pages; int ret; =20 + if (trace_array_is_readonly(tr)) + return -EPERM; + ret =3D kstrtoul_from_user(ubuf, cnt, 10, &val); if (ret) return ret; @@ -10632,17 +10658,23 @@ static __init void create_trace_instances(struct = dentry *d_tracer) static void init_tracer_tracefs(struct trace_array *tr, struct dentry *d_tracer) { + umode_t writable_mode =3D TRACE_MODE_WRITE; + bool readonly =3D trace_array_is_readonly(tr); int cpu; =20 + if (readonly) + writable_mode =3D TRACE_MODE_READ; + trace_create_file("available_tracers", TRACE_MODE_READ, d_tracer, - tr, &show_traces_fops); + tr, &show_traces_fops); =20 - trace_create_file("current_tracer", TRACE_MODE_WRITE, d_tracer, - tr, &set_tracer_fops); + trace_create_file("current_tracer", writable_mode, d_tracer, + tr, &set_tracer_fops); =20 - trace_create_file("tracing_cpumask", TRACE_MODE_WRITE, d_tracer, + trace_create_file("tracing_cpumask", writable_mode, d_tracer, tr, &tracing_cpumask_fops); =20 + /* Options are used for changing print-format even for readonly instance.= */ trace_create_file("trace_options", TRACE_MODE_WRITE, d_tracer, tr, &tracing_iter_fops); =20 @@ -10652,27 +10684,35 @@ init_tracer_tracefs(struct trace_array *tr, struc= t dentry *d_tracer) trace_create_file("trace_pipe", TRACE_MODE_READ, d_tracer, tr, &tracing_pipe_fops); =20 - trace_create_file("buffer_size_kb", TRACE_MODE_WRITE, d_tracer, + trace_create_file("buffer_size_kb", writable_mode, d_tracer, tr, &tracing_entries_fops); =20 trace_create_file("buffer_total_size_kb", TRACE_MODE_READ, d_tracer, tr, &tracing_total_entries_fops); =20 - trace_create_file("free_buffer", 0200, d_tracer, - tr, &tracing_free_buffer_fops); + if (!readonly) { + trace_create_file("free_buffer", 0200, d_tracer, + tr, &tracing_free_buffer_fops); =20 - trace_create_file("trace_marker", 0220, d_tracer, - tr, &tracing_mark_fops); + trace_create_file("trace_marker", 0220, d_tracer, + tr, &tracing_mark_fops); =20 - tr->trace_marker_file =3D __find_event_file(tr, "ftrace", "print"); + tr->trace_marker_file =3D __find_event_file(tr, "ftrace", "print"); =20 - trace_create_file("trace_marker_raw", 0220, d_tracer, - tr, &tracing_mark_raw_fops); + trace_create_file("trace_marker_raw", 0220, d_tracer, + tr, &tracing_mark_raw_fops); =20 - trace_create_file("trace_clock", TRACE_MODE_WRITE, d_tracer, tr, + trace_create_file("buffer_percent", TRACE_MODE_WRITE, d_tracer, + tr, &buffer_percent_fops); + + trace_create_file("syscall_user_buf_size", TRACE_MODE_WRITE, d_tracer, + tr, &tracing_syscall_buf_fops); + } + + trace_create_file("trace_clock", writable_mode, d_tracer, tr, &trace_clock_fops); =20 - trace_create_file("tracing_on", TRACE_MODE_WRITE, d_tracer, + trace_create_file("tracing_on", writable_mode, d_tracer, tr, &rb_simple_fops); =20 trace_create_file("timestamp_mode", TRACE_MODE_READ, d_tracer, tr, @@ -10680,41 +10720,38 @@ init_tracer_tracefs(struct trace_array *tr, struc= t dentry *d_tracer) =20 tr->buffer_percent =3D 50; =20 - trace_create_file("buffer_percent", TRACE_MODE_WRITE, d_tracer, - tr, &buffer_percent_fops); - - trace_create_file("buffer_subbuf_size_kb", TRACE_MODE_WRITE, d_tracer, + trace_create_file("buffer_subbuf_size_kb", writable_mode, d_tracer, tr, &buffer_subbuf_size_fops); =20 - trace_create_file("syscall_user_buf_size", TRACE_MODE_WRITE, d_tracer, - tr, &tracing_syscall_buf_fops); - create_trace_options_dir(tr); =20 #ifdef CONFIG_TRACER_MAX_TRACE - trace_create_maxlat_file(tr, d_tracer); + if (!readonly) + trace_create_maxlat_file(tr, d_tracer); #endif =20 - if (ftrace_create_function_files(tr, d_tracer)) + if (!readonly && ftrace_create_function_files(tr, d_tracer)) MEM_FAIL(1, "Could not allocate function filter files"); =20 if (tr->range_addr_start) { trace_create_file("last_boot_info", TRACE_MODE_READ, d_tracer, tr, &last_boot_fops); #ifdef CONFIG_TRACER_SNAPSHOT - } else { + } else if (!readonly) { trace_create_file("snapshot", TRACE_MODE_WRITE, d_tracer, tr, &snapshot_fops); #endif } =20 - trace_create_file("error_log", TRACE_MODE_WRITE, d_tracer, - tr, &tracing_err_log_fops); + if (!readonly) + trace_create_file("error_log", TRACE_MODE_WRITE, d_tracer, + tr, &tracing_err_log_fops); =20 for_each_tracing_cpu(cpu) tracing_init_tracefs_percpu(tr, cpu); =20 - ftrace_init_tracefs(tr, d_tracer); + if (!readonly) + ftrace_init_tracefs(tr, d_tracer); } =20 #ifdef CONFIG_TRACEFS_AUTOMOUNT_DEPRECATED diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 69e7defba6c6..0adc644084bf 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -33,6 +33,7 @@ =20 #define TRACE_MODE_WRITE 0640 #define TRACE_MODE_READ 0440 +#define TRACE_MODE_WRITE_MASK (TRACE_MODE_WRITE & ~TRACE_MODE_READ) =20 enum trace_type { __TRACE_FIRST_TYPE =3D 0, @@ -483,6 +484,12 @@ extern bool trace_clock_in_ns(struct trace_array *tr); =20 extern unsigned long trace_adjust_address(struct trace_array *tr, unsigned= long addr); =20 +static inline bool trace_array_is_readonly(struct trace_array *tr) +{ + /* backup instance is read only. */ + return tr->flags & TRACE_ARRAY_FL_VMALLOC; +} + /* * The global tracer (top) should be the first trace array added, * but we check the flag anyway. @@ -681,7 +688,6 @@ struct dentry *trace_create_file(const char *name, void *data, const struct file_operations *fops); =20 - /** * tracer_tracing_is_on_cpu - show real state of ring buffer enabled on fo= r a cpu * @tr : the trace array to know if ring buffer is enabled diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c index dbe29b4c6a7a..2ca2541c8a58 100644 --- a/kernel/trace/trace_boot.c +++ b/kernel/trace/trace_boot.c @@ -61,7 +61,8 @@ trace_boot_set_instance_options(struct trace_array *tr, s= truct xbc_node *node) v =3D memparse(p, NULL); if (v < PAGE_SIZE) pr_err("Buffer size is too small: %s\n", p); - if (tracing_resize_ring_buffer(tr, v, RING_BUFFER_ALL_CPUS) < 0) + if (trace_array_is_readonly(tr) || + tracing_resize_ring_buffer(tr, v, RING_BUFFER_ALL_CPUS) < 0) pr_err("Failed to resize trace buffer to %s\n", p); } =20 @@ -597,7 +598,7 @@ trace_boot_enable_tracer(struct trace_array *tr, struct= xbc_node *node) =20 p =3D xbc_node_find_value(node, "tracer", NULL); if (p && *p !=3D '\0') { - if (tracing_set_tracer(tr, p) < 0) + if (trace_array_is_readonly(tr) || tracing_set_tracer(tr, p) < 0) pr_err("Failed to set given tracer: %s\n", p); } =20 diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c index 4972e1a2b5f3..2e0db93be557 100644 --- a/kernel/trace/trace_events.c +++ b/kernel/trace/trace_events.c @@ -1380,6 +1380,9 @@ static int __ftrace_set_clr_event(struct trace_array = *tr, const char *match, { int ret; =20 + if (trace_array_is_readonly(tr)) + return -EPERM; + mutex_lock(&event_mutex); ret =3D __ftrace_set_clr_event_nolock(tr, match, sub, event, set, mod); mutex_unlock(&event_mutex); @@ -2952,8 +2955,8 @@ event_subsystem_dir(struct trace_array *tr, const cha= r *name, } else __get_system(system); =20 - /* ftrace only has directories no files */ - if (strcmp(name, "ftrace") =3D=3D 0) + /* ftrace only has directories no files, readonly instance too. */ + if (strcmp(name, "ftrace") =3D=3D 0 || trace_array_is_readonly(tr)) nr_entries =3D 0; else nr_entries =3D ARRAY_SIZE(system_entries); @@ -3118,28 +3121,30 @@ event_create_dir(struct eventfs_inode *parent, stru= ct trace_event_file *file) int ret; static struct eventfs_entry event_entries[] =3D { { - .name =3D "enable", + .name =3D "format", .callback =3D event_callback, - .release =3D event_release, }, +#ifdef CONFIG_PERF_EVENTS { - .name =3D "filter", + .name =3D "id", .callback =3D event_callback, }, +#endif +#define NR_RO_EVENT_ENTRIES (1 + IS_ENABLED(CONFIG_PERF_EVENTS)) +/* Readonly files must be above this line and counted by NR_RO_EVENT_ENTRI= ES. */ { - .name =3D "trigger", + .name =3D "enable", .callback =3D event_callback, + .release =3D event_release, }, { - .name =3D "format", + .name =3D "filter", .callback =3D event_callback, }, -#ifdef CONFIG_PERF_EVENTS { - .name =3D "id", + .name =3D "trigger", .callback =3D event_callback, }, -#endif #ifdef CONFIG_HIST_TRIGGERS { .name =3D "hist", @@ -3172,9 +3177,13 @@ event_create_dir(struct eventfs_inode *parent, struc= t trace_event_file *file) if (!e_events) return -ENOMEM; =20 - nr_entries =3D ARRAY_SIZE(event_entries); + if (trace_array_is_readonly(tr)) + nr_entries =3D NR_RO_EVENT_ENTRIES; + else + nr_entries =3D ARRAY_SIZE(event_entries); =20 name =3D trace_event_name(call); + ei =3D eventfs_create_dir(name, e_events, event_entries, nr_entries, file= ); if (IS_ERR(ei)) { pr_warn("Could not create tracefs '%s' directory\n", name); @@ -4511,31 +4520,37 @@ create_event_toplevel_files(struct dentry *parent, = struct trace_array *tr) int nr_entries; static struct eventfs_entry events_entries[] =3D { { - .name =3D "enable", + .name =3D "header_page", .callback =3D events_callback, }, { - .name =3D "header_page", + .name =3D "header_event", .callback =3D events_callback, }, +#define NR_RO_TOP_ENTRIES 2 +/* Readonly files must be above this line and counted by NR_RO_TOP_ENTRIES= . */ { - .name =3D "header_event", + .name =3D "enable", .callback =3D events_callback, }, }; =20 - entry =3D trace_create_file("set_event", TRACE_MODE_WRITE, parent, - tr, &ftrace_set_event_fops); - if (!entry) - return -ENOMEM; + if (!trace_array_is_readonly(tr)) { + entry =3D trace_create_file("set_event", TRACE_MODE_WRITE, parent, + tr, &ftrace_set_event_fops); + if (!entry) + return -ENOMEM; =20 - trace_create_file("show_event_filters", TRACE_MODE_READ, parent, tr, - &ftrace_show_event_filters_fops); + trace_create_file("show_event_filters", TRACE_MODE_READ, parent, tr, + &ftrace_show_event_filters_fops); =20 - trace_create_file("show_event_triggers", TRACE_MODE_READ, parent, tr, - &ftrace_show_event_triggers_fops); + trace_create_file("show_event_triggers", TRACE_MODE_READ, parent, tr, + &ftrace_show_event_triggers_fops); =20 - nr_entries =3D ARRAY_SIZE(events_entries); + nr_entries =3D ARRAY_SIZE(events_entries); + } else { + nr_entries =3D NR_RO_TOP_ENTRIES; + } =20 e_events =3D eventfs_create_events_dir("events", parent, events_entries, nr_entries, tr); @@ -4544,15 +4559,22 @@ create_event_toplevel_files(struct dentry *parent, = struct trace_array *tr) return -ENOMEM; } =20 - /* There are not as crucial, just warn if they are not created */ + if (!trace_array_is_readonly(tr)) { + + entry =3D trace_create_file("set_event", TRACE_MODE_WRITE, parent, + tr, &ftrace_set_event_fops); + if (!entry) + return -ENOMEM; =20 - trace_create_file("set_event_pid", TRACE_MODE_WRITE, parent, - tr, &ftrace_set_event_pid_fops); + /* There are not as crucial, just warn if they are not created */ =20 - trace_create_file("set_event_notrace_pid", - TRACE_MODE_WRITE, parent, tr, - &ftrace_set_event_notrace_pid_fops); + trace_create_file("set_event_pid", TRACE_MODE_WRITE, parent, + tr, &ftrace_set_event_pid_fops); =20 + trace_create_file("set_event_notrace_pid", + TRACE_MODE_WRITE, parent, tr, + &ftrace_set_event_notrace_pid_fops); + } tr->event_dir =3D e_events; =20 return 0; From nobody Mon Feb 9 08:36:24 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 E058C2A1CF; Wed, 28 Jan 2026 00:10:06 +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=1769559007; cv=none; b=gzONkfnuiQN/riU79BYNsQpKgvr19d+DOBS1czcj2T4q6F8IzOWxvAVyPoYYqdo9arOSDiPYmiFk+n6vTY9k9pRJcBlZvG2vNBFTEaluLRQr5NIhb0VVoIMGuXiQOu+QzHZqo9w6SjTFHYbF+N2okY8KICxbJxChiiAjqTR3bnY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769559007; c=relaxed/simple; bh=iPwQ2a5g9OEaU5Rr9tijgRDDChhJH0iR0vO9BuhN2/4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=JsHj6ROzCjKznJRyaqsKBwudnZs1XrOg3xRqaSKRTHO0lAWjIRxNYHgNBjFTBvk+jCrrXy+nwnHxlwr3IvnIFogVJloytU3T7ciHMtTGQUY3QQuVf9S5DbgjpjVQwNfMdaclFwASp6QbOjCSUzfqiCEKogEjYnNXRFl/2KmsWNc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=oUxg7xv9; 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="oUxg7xv9" Received: by smtp.kernel.org (Postfix) with ESMTPSA id BB683C116C6; Wed, 28 Jan 2026 00:10:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1769559006; bh=iPwQ2a5g9OEaU5Rr9tijgRDDChhJH0iR0vO9BuhN2/4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=oUxg7xv9qYHaMay73MCEv0d96biOaJbqBkT3p067EqrljmrHrzbkaJqPlYSwhp/V3 U8ClmjbzcT6auCM2AO7/mWfm42obe9lSPsBcPswsusQ6pibRMA47nZX1AaEmzv5TIX /vxEnkoabfFKBKgflkU8Wm9Tvbn9kR7ieXj3J/Q2uKwKFthsfAg5W6oS+YfWK5qGWm JSkr7T9ALUutkMJoTgD5ZVU0xCh+Lgnc1pewwxt+ecvnM7OYCqZhtkfCjMRYNwRgYf XgWFL5EUHfcBSxaaZAbRenAah5JGB5/1Qk/o5d5Vt9dIlK+f1KFYskcVTPnlx0xAHi lu0zlZdRll1Qw== From: "Masami Hiramatsu (Google)" To: Steven Rostedt Cc: Masami Hiramatsu , Mathieu Desnoyers , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH v5 3/4] tracing: Remove the backup instance automatically after read Date: Wed, 28 Jan 2026 09:10:04 +0900 Message-ID: <176955900407.2786091.16663650848612163366.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.52.0.457.g6b5491de43-goog In-Reply-To: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> References: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> User-Agent: StGit/0.19 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Masami Hiramatsu (Google) Since the backup instance is readonly, after reading all data via pipe, no data is left on the instance. Thus it can be removed safely after closing all files. This also removes it if user resets the ring buffer manually via 'trace' file. Signed-off-by: Masami Hiramatsu (Google) --- Changes in v4: - Update description. --- kernel/trace/trace.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++= +++- kernel/trace/trace.h | 6 +++++ 2 files changed, 69 insertions(+), 1 deletion(-) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index d39f6509c12a..7d615a74f915 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -590,6 +590,55 @@ void trace_set_ring_buffer_expanded(struct trace_array= *tr) tr->ring_buffer_expanded =3D true; } =20 +static int __remove_instance(struct trace_array *tr); + +static void trace_array_autoremove(struct work_struct *work) +{ + struct trace_array *tr =3D container_of(work, struct trace_array, autorem= ove_work); + + guard(mutex)(&event_mutex); + guard(mutex)(&trace_types_lock); + + /* + * This can be fail if someone gets @tr before starting this + * function, but in that case, this will be kicked again when + * putting it. So we don't care the result. + */ + __remove_instance(tr); +} + +static struct workqueue_struct *autoremove_wq; + +static void trace_array_init_autoremove(struct trace_array *tr) +{ + INIT_WORK(&tr->autoremove_work, trace_array_autoremove); +} + +static void trace_array_kick_autoremove(struct trace_array *tr) +{ + if (!work_pending(&tr->autoremove_work) && autoremove_wq) + queue_work(autoremove_wq, &tr->autoremove_work); +} + +static void trace_array_cancel_autoremove(struct trace_array *tr) +{ + if (work_pending(&tr->autoremove_work)) + cancel_work(&tr->autoremove_work); +} + +__init static int trace_array_init_autoremove_wq(void) +{ + autoremove_wq =3D alloc_workqueue("tr_autoremove_wq", + WQ_UNBOUND | WQ_HIGHPRI, 0); + if (!autoremove_wq) { + pr_err("Unable to allocate tr_autoremove_wq\n"); + return -ENOMEM; + } + return 0; +} + +late_initcall_sync(trace_array_init_autoremove_wq); + LIST_HEAD(ftrace_trace_arrays); =20 int trace_array_get(struct trace_array *this_tr) @@ -598,7 +647,7 @@ int trace_array_get(struct trace_array *this_tr) =20 guard(mutex)(&trace_types_lock); list_for_each_entry(tr, &ftrace_trace_arrays, list) { - if (tr =3D=3D this_tr) { + if (tr =3D=3D this_tr && !tr->free_on_close) { tr->ref++; return 0; } @@ -611,6 +660,12 @@ static void __trace_array_put(struct trace_array *this= _tr) { WARN_ON(!this_tr->ref); this_tr->ref--; + /* + * When free_on_close is set, prepare removing the array + * when the last reference is released. + */ + if (this_tr->ref =3D=3D 1 && this_tr->free_on_close) + trace_array_kick_autoremove(this_tr); } =20 /** @@ -6237,6 +6292,10 @@ static void update_last_data(struct trace_array *tr) /* Only if the buffer has previous boot data clear and update it. */ tr->flags &=3D ~TRACE_ARRAY_FL_LAST_BOOT; =20 + /* If this is a backup instance, mark it for autoremove. */ + if (tr->flags & TRACE_ARRAY_FL_VMALLOC) + tr->free_on_close =3D true; + /* Reset the module list and reload them */ if (tr->scratch) { struct trace_scratch *tscratch =3D tr->scratch; @@ -10418,6 +10477,8 @@ trace_array_create_systems(const char *name, const = char *systems, if (ftrace_allocate_ftrace_ops(tr) < 0) goto out_free_tr; =20 + trace_array_init_autoremove(tr); + ftrace_init_trace_array(tr); =20 init_trace_flags_index(tr); @@ -10566,6 +10627,7 @@ static int __remove_instance(struct trace_array *tr) if (update_marker_trace(tr, 0)) synchronize_rcu(); =20 + trace_array_cancel_autoremove(tr); tracing_set_nop(tr); clear_ftrace_function_probes(tr); event_trace_del_tracer(tr); diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 0adc644084bf..d9d45dd3c0f3 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -447,6 +447,12 @@ struct trace_array { * we do not waste memory on systems that are not using tracing. */ bool ring_buffer_expanded; + /* + * If the ring buffer is a read only backup instance, it will be + * removed after dumping all data via pipe, because no readable data. + */ + bool free_on_close; + struct work_struct autoremove_work; }; =20 enum { From nobody Mon Feb 9 08:36:24 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 794572E40B; Wed, 28 Jan 2026 00:10:14 +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=1769559014; cv=none; b=ljQTn+0fso9l5HQ+mnARtZSMsk0O9Sw65l52+kR5eXDa3eS1E+dBhnoJW6I/gWc4UXZNmL9PM5YCcYO0GXFok8NFOOjjs4pdwApP/mk/SPBV6CiQK7Al/vxR/22/HJXPrILn8twy39NdPVI1VYcQUF8qNZZtoRx/+b6Q+cfVZoE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769559014; c=relaxed/simple; bh=ZaW5oZCDs9KNm6pL3BS/uCrrK5EMecxzSSpu9ruwHzs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=AX82mp21btvDoM1LZdq3tJSz7qJQWWl0dk4PiBPEJrIuskVY2LNRKljeks99J6cDKWz/jPiLpPJTl+JX/1rtibkuulbqG1mxeFha0IIqBDnvGH7/3VbewHbT7v7t8uVm9t2QD5Dep6Spz6BfpG6NIor1+Nw9gD0Qm6Xhf0XFvn4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=GWXwpzuv; 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="GWXwpzuv" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6F84DC4AF09; Wed, 28 Jan 2026 00:10:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1769559014; bh=ZaW5oZCDs9KNm6pL3BS/uCrrK5EMecxzSSpu9ruwHzs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GWXwpzuvY+UbJkoYESl89TsjLv1MsB+hTj1GIkjud7oIfB4TEFM2gu9GO8XPeYmXe TLCEVPXuhnWnqcCCBX7mQ+Z6S/pEL9lB1BJeZCd6BvOK+lZxXcdto5krhRgTza1ggj axczqAJzyhTysncXNYYCsw4TElnt3+Vg9Z+GRbmhvipRxI51d6gWW2rHHy5eGEAjZy MVJ+dQtoqoW5CU3wiC9GUoRxN5dTMHxnz6OrtW7bp8AyNafcbLML3fw8CPinCQcnOm 6g5yzVZA7kVwpwwcaMY9evYcuiM1Wq6PQhz5E6fZEkrJHD7kHAMSEzWbXEOWmGdy2R YOOkQhZZSKH6A== From: "Masami Hiramatsu (Google)" To: Steven Rostedt Cc: Masami Hiramatsu , Mathieu Desnoyers , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH v5 4/4] tracing/Documentation: Add a section about backup instance Date: Wed, 28 Jan 2026 09:10:11 +0900 Message-ID: <176955901173.2786091.7719483008240216705.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.52.0.457.g6b5491de43-goog In-Reply-To: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> References: <176955897718.2786091.11948759407196200082.stgit@mhiramat.tok.corp.google.com> User-Agent: StGit/0.19 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Masami Hiramatsu (Google) Add a section about backup instance to the debugging.rst. Signed-off-by: Masami Hiramatsu (Google) --- Documentation/trace/debugging.rst | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/Documentation/trace/debugging.rst b/Documentation/trace/debugg= ing.rst index 4d88c346fc38..73e2154bcf98 100644 --- a/Documentation/trace/debugging.rst +++ b/Documentation/trace/debugging.rst @@ -159,3 +159,22 @@ If setting it from the kernel command line, it is reco= mmended to also disable tracing with the "traceoff" flag, and enable tracing after boot up. Otherwise the trace from the most recent boot will be mixed with the trace from the previous boot, and may make it confusing to read. + +Using a backup instance for keeping previous boot data +------------------------------------------------------ + +It is also possible to record trace data at system boot time by specifying +events with the persistent ring buffer, but in this case the data before t= he +reboot will be lost before it can be read. This problem can be solved by a +backup instance. From the kernel command line:: + + reserve_mem=3D12M:4096:trace trace_instance=3Dboot_map@trace,sched,irq t= race_instance=3Dbackup=3Dboot_map + +When the boot up, the previous data in the`boot_map` is copied to "backup" +instance, and the "sched:*" and "irq:*" events for current boot are traced= on +"boot_map". Thus user can read the previous boot data from the "backup" in= stance +without stopping trace. + +Note that this "backup" instance is readonly, and will be removed automati= cally +if you clear the trace data or read out all trace data from "trace_pipe" or +"trace_pipe_raw" files. \ No newline at end of file