From nobody Tue Feb 10 15:44:58 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 C79F433C534; Tue, 10 Feb 2026 08:43:38 +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=1770713018; cv=none; b=kfpagvDhoyBVi7csjjxbWGIgLZi1np3bjC2oqJdloeTkGMeQdhBA2WXVpZJIEL97ozsTWfsa1s1GbXtLjfdvrg0WkpDgP6pcvDpOaISf2eTHZAyS5PJm0uA3eur++najXjDyH/LDuwQBOJnb89o1j7MMfq9C/osk7ot+jfyIXos= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770713018; c=relaxed/simple; bh=sPfczV+iQh/5YeCLjihJxq4iEgnUbU7vuVeJkK5BiRU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=Jjp/QDL/McaKheYDhkJrZVPtpKaijLTQnmDXdb9PPr/mDSS5jViKFFtN4LyPUMNstJWQlOk7wlFUaN73bMJvoMcu0hMzqu2tx6HbtHfAgtbS7fGDYyrE6wiXqzDXln0bRGf0jX8aQSTeH/DqJYMzw/Yumh4pRHkoGNdOP/rDkt4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=dchPzW8t; 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="dchPzW8t" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A41B7C19424; Tue, 10 Feb 2026 08:43:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770713018; bh=sPfczV+iQh/5YeCLjihJxq4iEgnUbU7vuVeJkK5BiRU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=dchPzW8tt8rU3Gmko/LqV/ekJNo8TKBj94/zIrRP+bq/fK9UVnuT2Ss4PN/+FJ6uu NvKhvo15okbhLDcGbYdRp9/p/FzWUR+iSCTRb8ElMB1gHPXo0U+zTC05IZlwPRLAun pbA1ME9+284ClW0sXQYCTxg1kECIhuXAcZMUaddwO1hoPIoaFgsVMFqDcEYjoL0HQu w/Nu97YGMmJDWyAvj52Y4x3btfh4kxZOeXbzKy04m5QIZojQzcequhZnJoQL3/PAb1 CXEPoHT/02q41yl8e8olwsaw7iepC96NGkbI8VbOf/JX3Eb2auoxfSDkLtufGcmdG+ Pub8d2wad+Tpw== 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 v8 1/6] tracing: Fix to set write permission to per-cpu buffer_size_kb Date: Tue, 10 Feb 2026 17:43:36 +0900 Message-ID: <177071301597.2293046.11683339475076917920.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.53.0.239.g8d8fc8a987-goog In-Reply-To: <177071300558.2293046.12057922262682243630.stgit@mhiramat.tok.corp.google.com> References: <177071300558.2293046.12057922262682243630.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 per-cpu buffer_size_kb file is writable for changing per-cpu ring buffer size, the file should have the write access permission. Fixes: 21ccc9cd7211 ("tracing: Disable "other" permission bits in the trace= fs files") Signed-off-by: Masami Hiramatsu (Google) --- Changes in v8: Newly added. --- kernel/trace/trace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index 845b8a165daf..fd470675809b 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -8613,7 +8613,7 @@ tracing_init_tracefs_percpu(struct trace_array *tr, l= ong cpu) trace_create_cpu_file("stats", TRACE_MODE_READ, d_cpu, tr, cpu, &tracing_stats_fops); =20 - trace_create_cpu_file("buffer_size_kb", TRACE_MODE_READ, d_cpu, + trace_create_cpu_file("buffer_size_kb", TRACE_MODE_WRITE, d_cpu, tr, cpu, &tracing_entries_fops); =20 if (tr->range_addr_start) From nobody Tue Feb 10 15:44:58 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 AD87D33D516; Tue, 10 Feb 2026 08:43:46 +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=1770713026; cv=none; b=l97z3TdQ5jA/a90tUJr4MJegmMiEEzaCA3ewSro3ljKC4bw5lgjeMct4IrMnFCvf9p9ln1bCZg3d9SacuP9WfxiVirkg4E1FtLPPh3EWja392wTdOgcRppvMb1YSHKhEMDaoOeuJ45bZ8BgKIJx9+MMiprt7khQasgmCqm6Kdmk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770713026; c=relaxed/simple; bh=cCxCDeUbb8VZHuaRklOxBbrjGG/HQRFWUQIw/Qe0nCY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=eGPXRiTgYtMwZp990OqDIlJVXBol0Wfqz6BCBSUpGBPkzs0xYb6eDIzCCGBHhjFwuRbEVKqKGHLbulknfEgxijuP3OS7JL6tE5zrAt6BSLrS9idlWSI6690iIULdHNVjjiUFJQ2x0RnBpfjwQpd2aJRIDxJJNs3EGI0/CLd83KY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=m3mCnQOl; 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="m3mCnQOl" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 50A2EC116C6; Tue, 10 Feb 2026 08:43:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770713026; bh=cCxCDeUbb8VZHuaRklOxBbrjGG/HQRFWUQIw/Qe0nCY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=m3mCnQOlaFrPPjCBbVIYCfh46HGGEpQJCEGmFhPnqMLFo+yYP2tPEJw9HVvSWvUZP Gcz731o0avsAElEP1Q0nNim0l3cx3RD1+TAYS3E6H+JXcyTCxhjs0+s6tvEQndYm9j G5VAvwkNKW/ELT+xN44kinxDCiUXNqzzy7rTx2Q1vIJLGc5zPWd/28InIHP+YduYgx jRs/seZmE5RVtEohjfYgoh5spyVzyibEZeg0ruK7u4fjBK9KV4qVGuN1WiZSsISd3g j4xSu9/2iePHl61H3TRFIhYBewW0kuFVZOCkcBvvDZ1XoOyiXRBPWHeUUqk7MD85Ai C3YtohPwL3eNw== 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 v8 2/6] tracing: Reset last_boot_info if ring buffer is reset Date: Tue, 10 Feb 2026 17:43:43 +0900 Message-ID: <177071302364.2293046.17895165659153977720.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.53.0.239.g8d8fc8a987-goog In-Reply-To: <177071300558.2293046.12057922262682243630.stgit@mhiramat.tok.corp.google.com> References: <177071300558.2293046.12057922262682243630.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) --- Changes in v7: - Remove unneeded update_last_data_if_empty() call from tracing_snapshot_write() because snapshot is disabled on persistent instances. --- kernel/trace/trace.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index fd470675809b..e884d32b7895 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -4127,6 +4127,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; @@ -4151,6 +4153,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) { @@ -5215,6 +5219,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 @@ -7028,6 +7033,7 @@ int tracing_set_clock(struct trace_array *tr, const c= har *clockstr) ring_buffer_set_clock(tr->snapshot_buffer.buffer, trace_clocks[i].func); tracing_reset_online_cpus(&tr->snapshot_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; From nobody Tue Feb 10 15:44:58 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 078C233D6C0; Tue, 10 Feb 2026 08:43:53 +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=1770713034; cv=none; b=azHwM1l1LXh4J6/8TTEAUV5Ky1K6is0jnMusZFKsNPXlfQbhfA4/CKnZ7prl6/Ww/Rh/y3TDigA6HPh4Xf8wvrSPesGGXrqgnag2JZ+CeFvR99r+lITCJTUPrTzWJ6g9CDUpOty9qwKSuZSC92AQEJL7IA+XXSmzS6wLsMpIpB0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770713034; c=relaxed/simple; bh=o+JbqEddB46Pca6G/AQxYO2jKXbhvqyLXGy3aKB0n4g=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=IpckjGSGRMdgQEzacFQs3zH+Ud2OaseRG5xmfuHrYSJAdf9mXqxuGlgqC+PPTtd26tPrNBraNHInRayONcKJFobuWbsX688nlQAOmVvZHuz9/HB62Sgn/zftQeNsx7Eu1t7hd1wPPC0uULoAVFq+nWzqFiZQHnFBsn9Jfc/OZIs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=tXWJ1stI; 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="tXWJ1stI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 06924C19423; Tue, 10 Feb 2026 08:43:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770713033; bh=o+JbqEddB46Pca6G/AQxYO2jKXbhvqyLXGy3aKB0n4g=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=tXWJ1stImWP4mZclA8/IdvFWoGXXQjxxsR2xaHvOkvzhRmk4JY/XmFi8VT18/rhGb 2nW1aiOT6hhPR93a9I9tEYUNnu98vZJxDRUjqQDagbIh34u7rVu8h5i/+PrmSBZNnt QJNhydTRBycIQ8HXXahVA8eXGTY9zmwnFJG9C4LxIApymjJ41ZH00+v8p9gH7D/tgy vgRUiRySjkNk5eIfJNl/ythxBNSUtco3xFObsF+/sGiGctFkfOjbE9Z4qAxYk2koxO +54N9bOX7cTxX72R9o7LaBDF+aimO39nmI11BbMUDRPABEQFYOIxuYO2POqMy1ENbJ +8MQMK9sbRp7A== 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 v8 3/6] tracefs: Check file permission even if user has CAP_DAC_OVERRIDE Date: Tue, 10 Feb 2026 17:43:51 +0900 Message-ID: <177071303130.2293046.2400906233143699263.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.53.0.239.g8d8fc8a987-goog In-Reply-To: <177071300558.2293046.12057922262682243630.stgit@mhiramat.tok.corp.google.com> References: <177071300558.2293046.12057922262682243630.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) Strictly checking the file read/write permission even if the owner has CAP_DAC_OVERRIDE on tracefs as same as sysfs. Tracefs is a pseudo filesystem, just like sysfs, so any file that the system defines as unwritable should actually be unwritable by anyone. Signed-off-by: Masami Hiramatsu (Google) --- fs/tracefs/event_inode.c | 2 ++ fs/tracefs/inode.c | 36 +++++++++++++++++++++++++++++++++--- fs/tracefs/internal.h | 3 +++ 3 files changed, 38 insertions(+), 3 deletions(-) diff --git a/fs/tracefs/event_inode.c b/fs/tracefs/event_inode.c index 61cbdafa2411..65e8be761e79 100644 --- a/fs/tracefs/event_inode.c +++ b/fs/tracefs/event_inode.c @@ -233,10 +233,12 @@ static int eventfs_set_attr(struct mnt_idmap *idmap, = struct dentry *dentry, static const struct inode_operations eventfs_dir_inode_operations =3D { .lookup =3D eventfs_root_lookup, .setattr =3D eventfs_set_attr, + .permission =3D tracefs_permission, }; =20 static const struct inode_operations eventfs_file_inode_operations =3D { .setattr =3D eventfs_set_attr, + .permission =3D tracefs_permission, }; =20 static const struct file_operations eventfs_file_operations =3D { diff --git a/fs/tracefs/inode.c b/fs/tracefs/inode.c index d9d8932a7b9c..eb1ddc0cc13a 100644 --- a/fs/tracefs/inode.c +++ b/fs/tracefs/inode.c @@ -212,10 +212,40 @@ static void set_tracefs_inode_owner(struct inode *ino= de) inode->i_gid =3D gid; } =20 -static int tracefs_permission(struct mnt_idmap *idmap, - struct inode *inode, int mask) +int tracefs_permission(struct mnt_idmap *idmap, + struct inode *inode, int mask) { - set_tracefs_inode_owner(inode); + struct tracefs_inode *ti =3D get_tracefs(inode); + const struct file_operations *fops; + + if (!(ti->flags & TRACEFS_EVENT_INODE)) + set_tracefs_inode_owner(inode); + + /* + * Like sysfs, file permission checks are performed even for superuser + * with CAP_DAC_OVERRIDE. See the KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK + * definition in linux/kernfs.h. + */ + if (mask & MAY_OPEN) { + fops =3D inode->i_fop; + + if (mask & MAY_WRITE) { + if (!(inode->i_mode & 0222)) + return -EACCES; + if (!fops || (!fops->write && !fops->write_iter && + !fops->mmap)) + return -EACCES; + } + + if (mask & MAY_READ) { + if (!(inode->i_mode & 0444)) + return -EACCES; + if (!fops || (!fops->read && !fops->read_iter && + !fops->mmap && !fops->splice_read)) + return -EACCES; + } + } + return generic_permission(idmap, inode, mask); } =20 diff --git a/fs/tracefs/internal.h b/fs/tracefs/internal.h index d83c2a25f288..1e49ba445ba3 100644 --- a/fs/tracefs/internal.h +++ b/fs/tracefs/internal.h @@ -76,4 +76,7 @@ struct inode *tracefs_get_inode(struct super_block *sb); void eventfs_remount(struct tracefs_inode *ti, bool update_uid, bool updat= e_gid); void eventfs_d_release(struct dentry *dentry); =20 +int tracefs_permission(struct mnt_idmap *idmap, + struct inode *inode, int mask); + #endif /* _TRACEFS_INTERNAL_H */ From nobody Tue Feb 10 15:44:58 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 925A533D6C9; Tue, 10 Feb 2026 08:44:01 +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=1770713041; cv=none; b=Ty1OcFL7pmAstkOKaNzKEgyddKXaq7PZ6tJLzgP2p+rd6FkZstxEZhyGLf/9ZlGIU9mntroKMpwIO0KJqAYkmdiPhusd64s1To0PbzaT+GGVAsomKOIePSspKdrvw1xDsnYDNL8sHvbLbOI5ydBXnkv7SLAToufI6ddwPhGWDzw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770713041; c=relaxed/simple; bh=wNgiHg5axgZ2+rd2T9vx91pMOIdrYKscjSNjVp3IBRI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=du6BFxwe269lblROrFLfUtrAhT6gGF5Py3t8mP6FavBCqvF1WC/QZnFioCvAWBHk5ZRfR8jwGZJuzLeMI1Bh0aOjVokXct6zNorWrO81ikAh9YgnJaysZvDRh4mazCqLuDelt7XgJH1LZdMFGgwbHFrexkxqorNHjl30UeQBFAM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=iZWYj2W8; 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="iZWYj2W8" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B576AC116C6; Tue, 10 Feb 2026 08:44:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770713041; bh=wNgiHg5axgZ2+rd2T9vx91pMOIdrYKscjSNjVp3IBRI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=iZWYj2W89prb+L6gQwFFZBoUH1PhfGBkNJ4f1tJIGd/gOyFkohMBBtD0VAa9wDfcI 6uWS1ERgMPx2KVksFeRYslTHZJQk3gyrD+wqu1OcCdmJYVSE9tDU8hNY0FKT3lpvza mdxfx8EamwWi6OOY5Bo4OzCLA2SUQYnQhtnQ2xwj39HTkBhFcGRnDDuYffQVHp47YZ SdOQ/I2gFpJvUPbTJwi3QblL/Q47eufEpoq5i7O5DV4sOJ93uB8vGUPf1fFTvRcZs7 XvGbbZb5yXhaE6KAtqFrKGA3MFZ4Pb3MHGJSY8MPvsDBu4yIrIZiXNn4PPkiBG+a02 L4y9SXkwbGTnw== 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 v8 4/6] tracing: Make the backup instance non-reusable Date: Tue, 10 Feb 2026 17:43:59 +0900 Message-ID: <177071303899.2293046.16073340162755628007.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.53.0.239.g8d8fc8a987-goog In-Reply-To: <177071300558.2293046.12057922262682243630.stgit@mhiramat.tok.corp.google.com> References: <177071300558.2293046.12057922262682243630.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 v8: - Remove read-only checks in read() operation. Changes in v7: - Return -EACCES instead of -EPERM. Changes in v6: - Remove tracing_on file from readonly instances. - Remove unused writable_mode from tracing_init_tracefs_percpu(). - Cleanup init_tracer_tracefs() and create_event_toplevel_files(). - Remove TRACE_MODE_WRITE_MASK. - Add TRACE_ARRAY_FL_RDONLY. 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 | 71 +++++++++++++++++++++++----------------- kernel/trace/trace.h | 7 ++++ kernel/trace/trace_boot.c | 5 ++- kernel/trace/trace_events.c | 76 +++++++++++++++++++++++++--------------= ---- 4 files changed, 94 insertions(+), 65 deletions(-) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index e884d32b7895..566d1e824360 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -9836,17 +9836,22 @@ static __init void create_trace_instances(struct de= ntry *d_tracer) static void init_tracer_tracefs(struct trace_array *tr, struct dentry *d_tracer) { + umode_t writable_mode =3D TRACE_MODE_WRITE; int cpu; =20 + if (trace_array_is_readonly(tr)) + 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 @@ -9856,12 +9861,36 @@ init_tracer_tracefs(struct trace_array *tr, struct = 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("trace_clock", writable_mode, d_tracer, tr, + &trace_clock_fops); + + trace_create_file("timestamp_mode", TRACE_MODE_READ, d_tracer, tr, + &trace_time_stamp_mode_fops); + + tr->buffer_percent =3D 50; + + trace_create_file("buffer_subbuf_size_kb", writable_mode, d_tracer, + tr, &buffer_subbuf_size_fops); + + create_trace_options_dir(tr); + + if (tr->range_addr_start) + trace_create_file("last_boot_info", TRACE_MODE_READ, d_tracer, + tr, &last_boot_fops); + + for_each_tracing_cpu(cpu) + tracing_init_tracefs_percpu(tr, cpu); + + /* Read-only instance has above files only. */ + if (trace_array_is_readonly(tr)) + return; + trace_create_file("free_buffer", 0200, d_tracer, tr, &tracing_free_buffer_fops); =20 @@ -9873,49 +9902,29 @@ init_tracer_tracefs(struct trace_array *tr, struct = dentry *d_tracer) 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_clock_fops); - - trace_create_file("tracing_on", TRACE_MODE_WRITE, d_tracer, - tr, &rb_simple_fops); - - trace_create_file("timestamp_mode", TRACE_MODE_READ, d_tracer, tr, - &trace_time_stamp_mode_fops); - - tr->buffer_percent =3D 50; - 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, - tr, &buffer_subbuf_size_fops); + tr, &buffer_percent_fops); =20 trace_create_file("syscall_user_buf_size", TRACE_MODE_WRITE, d_tracer, - tr, &tracing_syscall_buf_fops); + tr, &tracing_syscall_buf_fops); =20 - create_trace_options_dir(tr); + trace_create_file("tracing_on", TRACE_MODE_WRITE, d_tracer, + tr, &rb_simple_fops); =20 trace_create_maxlat_file(tr, d_tracer); =20 if (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 { + if (!tr->range_addr_start) 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); =20 - for_each_tracing_cpu(cpu) - tracing_init_tracefs_percpu(tr, cpu); - ftrace_init_tracefs(tr, d_tracer); } =20 @@ -10742,7 +10751,7 @@ __init static void enable_instances(void) * Backup buffers can be freed but need vfree(). */ if (backup) - tr->flags |=3D TRACE_ARRAY_FL_VMALLOC; + tr->flags |=3D TRACE_ARRAY_FL_VMALLOC | TRACE_ARRAY_FL_RDONLY; =20 if (start || backup) { tr->flags |=3D TRACE_ARRAY_FL_BOOT | TRACE_ARRAY_FL_LAST_BOOT; diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 649fdd20fc91..393be92768f1 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -459,6 +459,7 @@ enum { TRACE_ARRAY_FL_MOD_INIT =3D BIT(3), TRACE_ARRAY_FL_MEMMAP =3D BIT(4), TRACE_ARRAY_FL_VMALLOC =3D BIT(5), + TRACE_ARRAY_FL_RDONLY =3D BIT(6), }; =20 #ifdef CONFIG_MODULES @@ -488,6 +489,12 @@ extern unsigned long trace_adjust_address(struct trace= _array *tr, unsigned long =20 extern struct trace_array *printk_trace; =20 +static inline bool trace_array_is_readonly(struct trace_array *tr) +{ + /* backup instance is read only. */ + return tr->flags & TRACE_ARRAY_FL_RDONLY; +} + /* * The global tracer (top) should be the first trace array added, * but we check the flag anyway. 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 61fe01dce7a6..b493cbdf0ea0 100644 --- a/kernel/trace/trace_events.c +++ b/kernel/trace/trace_events.c @@ -1396,6 +1396,9 @@ static int __ftrace_set_clr_event(struct trace_array = *tr, const char *match, { int ret; =20 + if (trace_array_is_readonly(tr)) + return -EACCES; + mutex_lock(&event_mutex); ret =3D __ftrace_set_clr_event_nolock(tr, match, sub, event, set, mod); mutex_unlock(&event_mutex); @@ -2968,8 +2971,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); @@ -3134,28 +3137,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", @@ -3188,7 +3193,10 @@ 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= ); @@ -4527,31 +4535,44 @@ 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); + /* There are not as crucial, just warn if they are not created */ + 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); + trace_create_file("set_event_pid", TRACE_MODE_WRITE, parent, + tr, &ftrace_set_event_pid_fops); + + trace_create_file("set_event_notrace_pid", + TRACE_MODE_WRITE, parent, tr, + &ftrace_set_event_notrace_pid_fops); + 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); @@ -4560,15 +4581,6 @@ create_event_toplevel_files(struct dentry *parent, s= truct trace_array *tr) return -ENOMEM; } =20 - /* There are not as crucial, just warn if they are not created */ - - trace_create_file("set_event_pid", TRACE_MODE_WRITE, parent, - tr, &ftrace_set_event_pid_fops); - - 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 Tue Feb 10 15:44:58 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 8FE6733D6D4; Tue, 10 Feb 2026 08:44:09 +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=1770713049; cv=none; b=l4BamhJBv3ub0r8bI1sDZqQKbxz8fmM5T4OfjoqOKGGDmBRlVJquEgjHV8kdYdHU6/n+yQXHP4Y3KqHrK9Z9/msBpvahsOwqltBW8KFF+NpUMPdph46VHdXXIwqMf3qDnHIi4WcGUZMKmh6XW97DMWHJ6T74x7qSXmlhNKo6WKQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770713049; c=relaxed/simple; bh=dmL/SN0o8o4iYGF7T+Lwxd9F8Mqog2atTJFmtAWWWvo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=qe+lf4Fs9HbTBMfPvrIx/YLvAhD6aBvcLtMXGCoTuht7kwO62yxldX81Mh803C9U1k7RH83OcPt2AS/lMU9E7SCt5UXW/YLRMbUKh8bETWXFrfo+DR2hM9ZgIz6KJUSz2onaTwbsCYBKpW8TOksiZ4VvB9dZ438eVgs/MUPZ9aw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=kr2y4gCQ; 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="kr2y4gCQ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6B4CAC116C6; Tue, 10 Feb 2026 08:44:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770713049; bh=dmL/SN0o8o4iYGF7T+Lwxd9F8Mqog2atTJFmtAWWWvo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=kr2y4gCQ1WoY0WvLXRrC3TF/e8eB5WExn28xy2HEQ8HLkKchWbD96xscINazv5K72 vmUlBoD28upSrMkT3hvezwOsf9SjzEuujjUrORjOzD3vW5GcnrZ53hVzAi8ZrxNLdX 46H+R0+eVlvMEu8PJlJ/gz+MvymOr2dOAvpZLqUqRhKXfybPysmwuhQweE8HuO+zCN IbuUQ3RmJcpWYpRm4A39JIvpzPieOlDzo3+EHIbAn6uDMysQJswFMXU2+phT1XSMk4 l3j62KOEaD417toeM4jAw72KhBnDTI5vr2r07gj4lfCnWOHnbEo5T7akIaa/X3YWgu wA7CetjIhPavQ== 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 v8 5/6] tracing: Remove the backup instance automatically after read Date: Tue, 10 Feb 2026 17:44:06 +0900 Message-ID: <177071304674.2293046.14437823490848309611.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.53.0.239.g8d8fc8a987-goog In-Reply-To: <177071300558.2293046.12057922262682243630.stgit@mhiramat.tok.corp.google.com> References: <177071300558.2293046.12057922262682243630.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 v6: - Fix typo in comment. - Only when there is a readonly trace array, initialize autoremove_wq. - Fix to exit loop in trace_array_get() if tr is found in the list. Changes in v4: - Update description. --- kernel/trace/trace.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++= +++- kernel/trace/trace.h | 6 +++++ 2 files changed, 66 insertions(+), 1 deletion(-) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index 566d1e824360..c746cb4c6e38 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -578,6 +578,51 @@ 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 about the result. + */ + __remove_instance(tr); +} + +static struct workqueue_struct *autoremove_wq; + +static void trace_array_kick_autoremove(struct trace_array *tr) +{ + if (autoremove_wq && !work_pending(&tr->autoremove_work)) + queue_work(autoremove_wq, &tr->autoremove_work); +} + +static void trace_array_cancel_autoremove(struct trace_array *tr) +{ + if (autoremove_wq && work_pending(&tr->autoremove_work)) + cancel_work(&tr->autoremove_work); +} + +static void trace_array_init_autoremove(struct trace_array *tr) +{ + INIT_WORK(&tr->autoremove_work, trace_array_autoremove); + + /* Only readonly trace_array can kick the autoremove. */ + if (!trace_array_is_readonly(tr) || autoremove_wq) + return; + + autoremove_wq =3D alloc_workqueue("tr_autoremove_wq", + WQ_UNBOUND | WQ_HIGHPRI, 0); + if (!autoremove_wq) + pr_warn("Unable to allocate tr_autoremove_wq. autoremove disabled.\n"); +} + LIST_HEAD(ftrace_trace_arrays); =20 int trace_array_get(struct trace_array *this_tr) @@ -587,7 +632,8 @@ int trace_array_get(struct trace_array *this_tr) guard(mutex)(&trace_types_lock); list_for_each_entry(tr, &ftrace_trace_arrays, list) { if (tr =3D=3D this_tr) { - tr->ref++; + if (!tr->free_on_close) + tr->ref++; return 0; } } @@ -599,6 +645,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 /** @@ -5463,6 +5515,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; @@ -9596,6 +9652,8 @@ trace_array_create_systems(const char *name, const ch= ar *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); @@ -9744,6 +9802,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 393be92768f1..48b94759ba1c 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -450,6 +450,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 Tue Feb 10 15:44:58 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 385252DCC08; Tue, 10 Feb 2026 08:44:16 +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=1770713057; cv=none; b=H2B7WGt+5u9QnyCA78JUV6Hf9U8hhq8uU5qpev/pLcPUZq6ujVz7Lbt/hFaRHCKKa+rkY1sFB9bA0QW5H6QXolF8suNEyA05RBWgFqqiO462zxMxRIaSVbJ/valHkdqm1yMLx2r9Dn0r0sqUNANz3fnT5sICKnJWTI8fRZ7fe30= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770713057; c=relaxed/simple; bh=S5HUOKOwvhSR3nZmMfKa96wdR+Qt2kEIy+bpCsLdFdo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=illPF2al4QvTqceU+69n7O+kuD6AkjcOKVo7AwlMdegHYQWN9TirU59X5rM9x2mpBbvvr6f5Vb/KYoh2sO8G6gzc52yF2NkUXyDCZJ4PmrdEcWdjMsvZhu+tyH0d+YnbR/YGxijToTfxsMJyaESneT+h5oCXysslnahrZRrTBaY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=iLsX7Ahp; 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="iLsX7Ahp" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 194F2C116C6; Tue, 10 Feb 2026 08:44:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770713056; bh=S5HUOKOwvhSR3nZmMfKa96wdR+Qt2kEIy+bpCsLdFdo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=iLsX7AhpJndJgeaK8VFX34vK6SUep9cV422qvD6auL/9ZoYwHl4ofXhqRsKoKtY8X 4oqEaZrjspd2IJyWMvLLV8UxE8W23ldpgxldPvG9vU5CTBV/CmZpL7QjeU6tzdhDHH FyN5XhUWkeFCq79VM3R0nyyJDzoe+PWmsjui1Jnf5uybY4vA/MMVLBJrRoM9CToCL2 OXd3wzh8K5/nIra0adefymBGvkDRVusCpHknhE/FFjbZ/L1oSpCiYo+JBlK2Xml5KL Ggsa1FRqBkRobGHTlJZw3nP129qH+ZvKjRMUs+Vl76y5e7xd7RYqbsk4XSfy5lZGQQ 8hf2ORD0bv1fA== 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 v8 6/6] tracing/Documentation: Add a section about backup instance Date: Tue, 10 Feb 2026 17:44:14 +0900 Message-ID: <177071305440.2293046.5538536293035707901.stgit@mhiramat.tok.corp.google.com> X-Mailer: git-send-email 2.53.0.239.g8d8fc8a987-goog In-Reply-To: <177071300558.2293046.12057922262682243630.stgit@mhiramat.tok.corp.google.com> References: <177071300558.2293046.12057922262682243630.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) --- Changes in v6: - Fix typos. --- 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..15857951b506 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 + +On boot up, the previous data in the "boot_map" is copied to the "backup" +instance, and the "sched:*" and "irq:*" events for the current boot are tr= aced +in the "boot_map". Thus the user can read the previous boot data from the = "backup" +instance without stopping the 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 the "trace_pip= e" +or the "trace_pipe_raw" files. \ No newline at end of file