tracefs: Add read-only eventfs filesystem at /sys/kernel/events
Steven Rostedt
maintainerPATCH v4 1/1 tracefs: Add read-only eventfs filesystem at /sys/kernel/events
From: Anubhav Shelat <[email protected]>
Introduce a new read-only pseudo-filesystem "eventfs" mounted at /sys/kernel/events that exposes trace event format and id files (mode 0444) to unprivileged users. This allows tools like perf to discover event formats without requiring access to the full tracefs/debugfs mount.
The eventfs file system reuses the existing eventfs_inode lazy-lookup infrastructure. A new set of super_operations (eventfs_ro_super_operations) shares the tracefs inode allocator so that eventfs_get_inode() and get_tracefs() work on the RO superblock. The superblock is manually initialized to ensure the root inode is allocated with tracefs_alloc_inode, allowing the root to serve directly as the events directory without another events subdirectory.
Each qualifying event gets a subsystem directory containing format and id files. The top-level events directory also exposes header_page and header_event. Similar to tracefs, a change will need to be made in systemd to mount this filesystem automatically.
[
Steven Rostedt rewrote to use the lookup functions to determine read only files to show. The struct eventfs_entry now has a "readonly" field and if it is set, it will be displayed in the read only file system. The original code [1] duplicated the eventfs_inodes for every event and subsystem. The new approach uses the existing eventfs_inodes (without requiring more memory to store them) and uses the eventfs_entry arrays to show which files are allowed to be read readonly or not.
[1] https://patch.msgid.link/[email protected]
]
---
Changes since v3: https://patch.msgid.link/[email protected]
- Fixed kernel doc name for eventfs_create_events_ro_copy() (Masami Hiramatsu)
- Removed duplicate initialization of ei in that function. (Masami Hiramatsu)
- Added include of linux/magic.h as it failed to build on some architectures. (kernel test robot)
fs/tracefs/event_inode.c | 192 ++++++++++++++++++++++++++++++++++-- fs/tracefs/inode.c | 21 +++- fs/tracefs/internal.h | 6 ++ include/linux/tracefs.h | 3 + include/uapi/linux/magic.h | 1 + kernel/trace/trace_events.c | 13 +++ 6 files changed, 225 insertions(+), 11 deletions(-)
fs/tracefs/event_inode.c +184 -8
@@ -16,14 +16,87 @@*/ #include <linux/fsnotify.h> #include <linux/fs.h> +#include <linux/fs_context.h> #include <linux/namei.h> #include <linux/workqueue.h> #include <linux/security.h> #include <linux/tracefs.h> +#include <linux/magic.h> #include <linux/kref.h> #include <linux/delay.h> #include "internal.h" +static struct vfsmount *eventfs_ro_mount; +static int eventfs_ro_mount_count; + +static int eventfs_ro_fill_super (struct super_block *sb,struct fs_context *fc) +{ +struct inode *inode; +struct dentry *root; + + sb->s_blocksize =PAGE_SIZE ; + sb->s_blocksize_bits =PAGE_SHIFT ; + sb->s_magic =EVENTFS_SUPER_MAGIC ; + sb->s_op = &eventfs_ro_super_operations; + sb->s_time_gran =1 ; + sb->s_flags |=SB_RDONLY ; + + inode =new_inode (sb); +if (!inode) +return -ENOMEM ; + + inode->i_ino =1 ; + inode->i_mode =S_IFDIR |0555 ; +simple_inode_init_ts (inode); + inode->i_op = &simple_dir_inode_operations; + inode->i_fop = &simple_dir_operations; +set_nlink (inode,2 ); + +set_default_d_op (sb, &tracefs_dentry_operations); + + root =d_make_root (inode); +if (!root) +return -ENOMEM ; + + sb->s_root = root; + +return 0 ; +} + +static int eventfs_ro_get_tree (struct fs_context *fc) +{ +return get_tree_single (fc, eventfs_ro_fill_super); +} + +static const struct fs_context_operations eventfs_ro_context_ops = { + .get_tree = eventfs_ro_get_tree, +}; + +static int eventfs_ro_init_fs_context (struct fs_context *fc) +{ + fc->ops = &eventfs_ro_context_ops; +return 0 ; +} + +struct file_system_type eventfs_ro_fs_type = { + .owner =THIS_MODULE , + .name ="eventfs" , + .init_fs_context = eventfs_ro_init_fs_context, + .kill_sb = kill_anon_super, +}; + +struct dentry *eventfs_ro_get_root (void ) +{ +int error; + + error =simple_pin_fs (&eventfs_ro_fs_type, &eventfs_ro_mount, + &eventfs_ro_mount_count); +if (error) +return ERR_PTR (error); + +return dget (eventfs_ro_mount->mnt_root); +} +/* * eventfs_mutex protects the eventfs_inode (ei) dentry. Any access * to the ei->dentry must be done under this mutex and after checking
@@ -169,7 +242,11 @@ static inline struct eventfs_inode *get_ei(struct eventfs_inode *ei)static struct dentry *eventfs_root_lookup (struct inode *dir,struct dentry *dentry,unsigned int flags); +static struct dentry *eventfs_root_lookup_ro (struct inode *dir, +struct dentry *dentry, +unsigned int flags);static int eventfs_iterate (struct file *file,struct dir_context *ctx); +static int eventfs_ro_iterate (struct file *file,struct dir_context *ctx);static void update_attr (struct eventfs_attr *attr,struct iattr *iattr) {
@@ -247,6 +324,10 @@ static const struct inode_operations eventfs_dir_inode_operations = { .setattr = eventfs_set_attr, }; +static const struct inode_operations eventfs_ro_dir_inode_operations = { + .lookup = eventfs_root_lookup_ro, +}; +static const struct inode_operations eventfs_file_inode_operations = { .setattr = eventfs_set_attr, };
@@ -257,6 +338,12 @@ static const struct file_operations eventfs_file_operations = { .llseek = generic_file_llseek, }; +static const struct file_operations eventfs_ro_file_operations = { + .read = generic_read_dir, + .iterate_shared = eventfs_ro_iterate, + .llseek = generic_file_llseek, +}; +static void eventfs_set_attrs (struct eventfs_inode *ei,bool update_uid,kuid_t uid,bool update_gid,kgid_t gid,int level) {
@@ -420,7 +507,7 @@ static struct dentry *lookup_file(struct eventfs_inode *parent_ei,* a eventfs_inode. */ static struct dentry *lookup_dir_entry (struct dentry *dentry, -struct eventfs_inode *pei,struct eventfs_inode *ei) +struct eventfs_inode *pei,struct eventfs_inode *ei,bool ro) {struct inode *inode;umode_t mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ;
@@ -429,8 +516,13 @@ static struct dentry *lookup_dir_entry(struct dentry *dentry,if (unlikely (!inode))return ERR_PTR (-ENOMEM ); - inode->i_op = &eventfs_dir_inode_operations; - inode->i_fop = &eventfs_file_operations; +if (ro) { + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + }else { + inode->i_op = &eventfs_dir_inode_operations; + inode->i_fop = &eventfs_file_operations; + }/* All directories will have the same inode number */ inode->i_ino =eventfs_dir_ino (ei);
@@ -534,9 +626,10 @@ lookup_file_dentry(struct dentry *dentry,* list, if @dentry found go ahead and create the file/dir */ -static struct dentry *eventfs_root_lookup (struct inode *dir, -struct dentry *dentry, -unsigned int flags) +static struct dentry *__eventfs_root_lookup (struct inode *dir, +struct dentry *dentry, +unsigned int flags, +bool ro) {struct eventfs_inode *ei_child;struct tracefs_inode *ti;
@@ -559,7 +652,7 @@ static struct dentry *eventfs_root_lookup(struct inode *dir,/* A child is freed and removed from the list at the same time */ if (WARN_ON_ONCE (ei_child->is_freed))return NULL ; -return lookup_dir_entry (dentry, ei, ei_child); +return lookup_dir_entry (dentry, ei, ei_child, ro); }for (int i =0 ; i < ei->nr_entries; i++) {
@@ -571,20 +664,44 @@ static struct dentry *eventfs_root_lookup(struct inode *dir,if (strcmp (name, entry->name) !=0 )continue ; +if (ro && !entry->read_only) +return NULL ; + data = ei->data;if (entry->callback (name, &mode, &data, &fops) <=0 )return NULL ; +/* +* Read-only files gets all users read access, +* but also should make sure this is not writable. +*/ +if (ro) + mode |= (mode & ~0222 ) |0444 ; +return lookup_file_dentry (dentry, ei, i, mode, data, fops); }return NULL ; } +static struct dentry *eventfs_root_lookup (struct inode *dir, +struct dentry *dentry, +unsigned int flags) +{ +return __eventfs_root_lookup (dir, dentry, flags, false); +} + +static struct dentry *eventfs_root_lookup_ro (struct inode *dir, +struct dentry *dentry, +unsigned int flags) +{ +return __eventfs_root_lookup (dir, dentry, flags, true); +} +/* * Walk the children of a eventfs_inode to fill in getdents(). */ -static int eventfs_iterate (struct file *file,struct dir_context *ctx) +static int __eventfs_iterate (struct file *file,struct dir_context *ctx,bool ro) {const struct file_operations *fops;struct inode *f_inode =file_inode (file);
@@ -630,6 +747,9 @@ static int eventfs_iterate(struct file *file, struct dir_context *ctx) entry = &ei->entries[i]; name = entry->name; +if (ro && !entry->read_only) +continue ; +/* If ei->is_freed then just bail here, nothing more to do */ scoped_guard(mutex, &eventfs_mutex) {if (ei->is_freed)
@@ -688,6 +808,16 @@ static int eventfs_iterate(struct file *file, struct dir_context *ctx)return 1 ; } +static int eventfs_iterate (struct file *file,struct dir_context *ctx) +{ +return __eventfs_iterate (file, ctx, false); +} + +static int eventfs_ro_iterate (struct file *file,struct dir_context *ctx) +{ +return __eventfs_iterate (file, ctx, true); +} +/** * eventfs_create_dir - Create the eventfs_inode for this directory * @name: The name of the directory to create.
@@ -845,6 +975,52 @@ struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentryreturn ERR_PTR (-ENOMEM ); } +/** +* eventfs_create_events_ro_copy - create a read-only events directory +* @name: The name of the top level directory to create. +* @entries: A list of entries that represent the files under this directory +* @size: The number of @entries +* @data: The default data to pass to the files (an entry may override it). +* +* This function configures the eventfs filesystem root as a read-only +* trace event directory using the existing eventfs_inode lazy-lookup +* infrastructure. +* +* See eventfs_create_dir() for use of @entries. +*/ +int eventfs_create_events_ro_copy (const char *name,struct eventfs_inode *ei) +{ +static struct dentry *dentry; +struct tracefs_inode *ti; +struct inode *inode; + +/* Can only be called once. */ +if (dentry) +return -EBUSY ; + +/* Reference acquired but never freed */ + dentry =eventfs_ro_get_root (); +if (IS_ERR (dentry)) +return PTR_ERR (dentry); + + inode =d_inode (dentry); + +INIT_LIST_HEAD (&ei->children); +INIT_LIST_HEAD (&ei->list); + + ti =get_tracefs (inode); + ti->flags |=TRACEFS_EVENT_INODE ; + ti->private = ei; + + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + +/* This is never freed */ + dentry->d_fsdata =get_ei (ei); + +return 0 ; +} +/** * eventfs_remove_rec - remove eventfs dir or file from list * @ei: eventfs_inode to be removed.
fs/tracefs/inode.c +18 -3
@@ -423,6 +423,14 @@ static const struct super_operations tracefs_super_operations = { .show_options = tracefs_show_options, }; +const struct super_operations eventfs_ro_super_operations = { + .alloc_inode = tracefs_alloc_inode, + .free_inode = tracefs_free_inode, + .destroy_inode = tracefs_destroy_inode, + .drop_inode = tracefs_drop_inode, + .statfs = simple_statfs, +}; +/* * It would be cleaner if eventfs had its own dentry ops. *
@@ -455,7 +463,7 @@ static int tracefs_d_delete(const struct dentry *dentry)return dentry->d_fsdata ==NULL ; } -static const struct dentry_operations tracefs_dentry_operations = { +const struct dentry_operations tracefs_dentry_operations = { .d_revalidate = tracefs_d_revalidate, .d_release = tracefs_d_release, .d_delete = tracefs_d_delete,
@@ -801,8 +809,15 @@ static int __init tracefs_init(void)return -EINVAL ; retval =register_filesystem (&trace_fs_type); -if (!retval) - tracefs_registered = true; +if (retval) +return retval; + tracefs_registered = true; + + retval =sysfs_create_mount_point (kernel_kobj,"events" ); +if (retval) +return retval; + + retval =register_filesystem (&eventfs_ro_fs_type);return retval; }
fs/tracefs/internal.h +6 -0
@@ -2,6 +2,10 @@#ifndef _TRACEFS_INTERNAL_H#define _TRACEFS_INTERNAL_H +extern const struct dentry_operations tracefs_dentry_operations; +extern const struct super_operations eventfs_ro_super_operations; +extern struct file_system_type eventfs_ro_fs_type; +enum {TRACEFS_EVENT_INODE =BIT (1 ), TRACEFS_GID_PERM_SET = BIT(2),
@@ -73,6 +77,8 @@ struct dentry *tracefs_end_creating(struct dentry *dentry);struct dentry *tracefs_failed_creating (struct dentry *dentry);struct inode *tracefs_get_inode (struct super_block *sb); +struct dentry *eventfs_ro_get_root (void ); +void eventfs_remount (struct tracefs_inode *ti,bool update_uid,bool update_gid);void eventfs_d_release (struct dentry *dentry);
include/linux/tracefs.h +3 -0
@@ -75,6 +75,7 @@ struct eventfs_entry {const char *name;eventfs_callback callback;eventfs_release release; +bool read_only; };struct eventfs_inode ;
@@ -87,6 +88,8 @@ struct eventfs_inode *eventfs_create_dir(const char *name, struct eventfs_inodeconst struct eventfs_entry *entries, int size, void *data); +int eventfs_create_events_ro_copy (const char *name,struct eventfs_inode *ei); +void eventfs_remove_events_dir (struct eventfs_inode *ei);void eventfs_remove_dir (struct eventfs_inode *ei);
include/uapi/linux/magic.h +1 -0
@@ -76,6 +76,7 @@#define STACK_END_MAGIC 0x57AC6E9D#define TRACEFS_MAGIC 0x74726163 +#define EVENTFS_SUPER_MAGIC 0x65766673#define V9FS_MAGIC 0x01021997
kernel/trace/trace_events.c +13 -0
@@ -3298,17 +3298,20 @@ event_create_dir(struct eventfs_inode *parent, struct trace_event_file *file) { .name = "format", .callback = event_callback, + .read_only = true, }, #ifdef CONFIG_PERF_EVENTS { .name = "id", .callback = event_callback, + .read_only = true, }, #endif #ifdef CONFIG_BPF_EVENTS { .name = "btf_ids", .callback = event_callback, + .read_only = true, }, #endif #define NR_RO_EVENT_ENTRIES (1 + IS_ENABLED(CONFIG_PERF_EVENTS) + \
@@ -4722,6 +4725,7 @@ static int events_callback(const char *name, umode_t *mode, void **data,static int create_event_toplevel_files (struct dentry *parent,struct trace_array *tr) { +static bool event_dir_ro_created;struct eventfs_inode *e_events;struct dentry *entry;int nr_entries;
@@ -4729,10 +4733,12 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) { .name = "header_page", .callback = events_callback, + .read_only = true, }, { .name = "header_event", .callback = events_callback, + .read_only = true, }, #define NR_RO_TOP_ENTRIES 2 /* Readonly files must be above this line and counted by NR_RO_TOP_ENTRIES. */
@@ -4775,6 +4781,13 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) tr->event_dir = e_events; +if (!event_dir_ro_created && (tr->flags &TRACE_ARRAY_FL_GLOBAL )) { +int ret; + + ret =eventfs_create_events_ro_copy ("events" , e_events); +if (!ret) + event_dir_ro_created = true; + }return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 6 potential issue(s) to consider: - [High] tracefs: NULL dereference in eventfs_create_events_ro_copy() on lockdown - [Medium] tracefs…
Thank you for your contribution! Sashiko AI review found 6 potential issue(s) to consider:
- [High] tracefs: NULL dereference in eventfs_create_events_ro_copy() on lockdown
- [Medium] tracefs: bitwise OR-assignment in __eventfs_root_lookup() keeps write bits
- [Medium] tracefs: shared eventfs_attr and tracefs_inodes leak tracefs permissions
- [Medium] tracefs: missing reconfigure op on eventfs allows clearing SB_RDONLY
- [Medium] tracefs: unlocked list re-init in eventfs_create_events_ro_copy()
- [Low] tracefs: kernel-doc mismatches in eventfs_create_events_ro_copy() --
commit c35b9718567e39dd0e81499c75ebb85b51e94ca3
Author: Anubhav Shelat <[email protected]>
tracefs: Add read-only eventfs filesystem at /sys/kernel/events
This commit introduces a read-only eventfs pseudo-filesystem mounted at /sys/kernel/events to expose trace event format, id, and header files to unprivileged users by reusing the existing eventfs_inode infrastructure.
Quoted 5 lines
fs/tracefs/event_inode.c +0
-0@@ -16,14 +16,87 @@
[ ... ]
fs/tracefs/event_inode.c line 73
Quoted 8 lines
fs/tracefs/event_inode.c +8
-0+static int eventfs_ro_get_tree (struct fs_context *fc) +{ +return get_tree_single (fc, eventfs_ro_fill_super); +} + +static const struct fs_context_operations eventfs_ro_context_ops = { + .get_tree = eventfs_ro_get_tree, +};
[Severity: Medium]
Can a remount clear SB_RDONLY on the eventfs superblock?
eventfs_ro_fill_super() sets sb->s_flags |= SB_RDONLY, but eventfs_ro_context_ops does not define a .reconfigure callback. In reconfigure_super(), when fc->ops->reconfigure is NULL, VFS updates sb->s_flags directly from fc->sb_flags and fc->sb_flags_mask, so running mount -o remount,rw /sys/kernel/events will clear SB_RDONLY.
Because lookup_file() assigns eventfs_file_inode_operations (with .setattr = eventfs_set_attr) to regular files in eventfs, clearing SB_RDONLY allows chmod/chown on /sys/kernel/events files to mutate the shared ei->entry_attrs used by tracefs. Should eventfs_ro_context_ops provide a .reconfigure callback that rejects clearing SB_RDONLY (or should read-only file inodes omit .setattr)?
[ ... ]
Quoted 12 lines
fs/tracefs/event_inode.c +1
-1@@ -412,7 +499,7 @@ static struct dentry *lookup_file(struct eventfs_inode *parent_ei,* a eventfs_inode. */ static struct dentry *lookup_dir_entry (struct dentry *dentry, -struct eventfs_inode *pei,struct eventfs_inode *ei) +struct eventfs_inode *pei,struct eventfs_inode *ei,bool ro) {struct inode *inode;umode_t mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ;@@ -421,8 +508,13 @@ static struct dentry *lookup_dir_entry(struct dentry *dentry,if (unlikely (!inode))return ERR_PTR (-ENOMEM );
fs/tracefs/event_inode.c static struct dentry *lookup_dir_entry(struct dentry *dentry, · line 517
Quoted 10 lines
fs/tracefs/event_inode.c +7
-2- inode->i_op = &eventfs_dir_inode_operations; - inode->i_fop = &eventfs_file_operations; +if (ro) { + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + }else { + inode->i_op = &eventfs_dir_inode_operations; + inode->i_fop = &eventfs_file_operations; + }
[Severity: Low]
This isn't a bug, but lookup_dir_entry() gained the @ro argument without a matching entry in its kernel-doc comment above.
[ ... ]
Quoted 7 lines
fs/tracefs/event_inode.c +3
-0@@ -563,20 +656,44 @@ static struct dentry *eventfs_root_lookup(struct inode *dir,if (strcmp (name, entry->name) !=0 )continue ; +if (ro && !entry->read_only) +return NULL ; +
fs/tracefs/event_inode.c static struct dentry *eventfs_root_lookup(struct inode *dir, · line 671
Quoted 10 lines
fs/tracefs/event_inode.c +6
-0data = ei->data;if (entry->callback (name, &mode, &data, &fops) <=0 )return NULL ; +/* +* Read-only files gets all users read access, +* but also should make sure this is not writable. +*/ +if (ro) + mode |= (mode & ~0222 ) |0444 ;
[Severity: Medium]
Should this use = instead of |= when updating mode?
Because |= ORs the right-hand side with the original value of mode, mode | (mode & ~0222) | 0444 simplifies to mode | 0444, leaving any write permission bits returned by entry->callback() intact.
fs/tracefs/event_inode.c static struct dentry *eventfs_root_lookup(struct inode *dir, · line 673
Quoted 2 lines
fs/tracefs/event_inode.c +1
-0+return lookup_file_dentry (dentry, ei, i, mode, data, fops);
[Severity: Medium]
Will permission or ownership changes in tracefs leak into the read-only eventfs mount through shared eventfs_attr and tracefs_inodes state?
In __eventfs_root_lookup(), both lookup_dir_entry() and lookup_file_dentry() pass the shared &ei->attr and &ei->entry_attrs[idx] into eventfs_get_inode() -> update_inode_attr() even when ro is true:
fs/tracefs/event_inode.c:update_inode_attr() {
...
if (attr && attr->mode & EVENTFS_SAVE_MODE)
inode->i_mode = attr->mode & EVENTFS_MODE_MASK;
else
inode->i_mode = mode;
if (attr && attr->mode & EVENTFS_SAVE_UID)
inode->i_uid = attr->uid;
else
inode->i_uid = rei->ei.attr.uid;
...
}If an administrator runs chmod or chown on files or directories under /sys/kernel/tracing/events, or mounts tracefs with uid=/gid= options, update_inode_attr() will override the 0444 file mode (and directory permissions/ownership) in /sys/kernel/events with the saved tracefs attributes, potentially revoking unprivileged read access or re-enabling write bits. In addition, lookup_dir_entry() passes S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO (0755) instead of 0555 when ro is true.
Similarly, because eventfs_ro_super_operations uses tracefs_alloc_inode, eventfs inodes are added to the global tracefs_inodes list. When tracefs is remounted with uid= or gid=, tracefs_apply_options() walks tracefs_inodes without checking ti->vfs_inode.i_sb == sb and overwrites i_uid and i_gid on live eventfs inodes as well:
fs/tracefs/inode.c:tracefs_apply_options() {
...
list_for_each_entry_rcu(ti, &tracefs_inodes, list) {
if (update_uid) {
ti->flags &= ~TRACEFS_UID_PERM_SET;
ti->vfs_inode.i_uid = fsi->uid;
}
...
}Should ro lookups ignore ei->attr / ei->entry_attrs (or should eventfs_get_inode() bypass saved tracefs attributes when on the read-only superblock), and should tracefs_apply_options() filter by superblock?
[ ... ]
Quoted 8 lines
fs/tracefs/event_inode.c +4
-0@@ -837,6 +967,52 @@ struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentryreturn ERR_PTR (-ENOMEM ); } +/** +* eventfs_create_events_ro_copy - create a read-only events directory +* @name: The name of the top level directory to create. +* @entries: A list of entries that represent the files under this directory
fs/tracefs/event_inode.c struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentry · line 983
Quoted 10 lines
fs/tracefs/event_inode.c +10
-0+* @size: The number of @entries +* @data: The default data to pass to the files (an entry may override it). +* +* This function configures the eventfs filesystem root as a read-only +* trace event directory using the existing eventfs_inode lazy-lookup +* infrastructure. +* +* See eventfs_create_dir() for use of @entries. +*/ +int eventfs_create_events_ro_copy (const char *name,struct eventfs_inode *ei)
[Severity: Low]
This isn't a bug, but the kernel-doc comment for eventfs_create_events_ro_copy() still lists @entries, @size, and @data from eventfs_create_events_dir() instead of @ei, and the @name parameter is unused in the function body.
Quoted 21 lines
fs/tracefs/event_inode.c +21
-0+{ +static struct dentry *dentry; +struct tracefs_inode *ti; +struct inode *inode; + +/* Can only be called once. */ +if (dentry) +return -EBUSY ; + +/* Reference acquired but never freed */ + dentry =eventfs_ro_get_root (); +if (IS_ERR (dentry)) +return PTR_ERR (dentry); + + inode =d_inode (dentry); + +INIT_LIST_HEAD (&ei->children); +INIT_LIST_HEAD (&ei->list); + + ti =get_tracefs (inode); + ti->flags |=TRACEFS_EVENT_INODE ;
fs/tracefs/event_inode.c struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentry · line 1022
Quoted 10 lines
fs/tracefs/event_inode.c +10
-0+ ti->private = ei; + + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + +/* This is never freed */ + dentry->d_fsdata =get_ei (ei); + +return 0 ; +}
[Severity: Medium]
Is it safe to re-initialize ei->children and ei->list here?
In create_event_toplevel_files(), e_events has already been allocated and initialized by eventfs_create_events_dir() -> alloc_root_ei() -> init_ei(), and published via tracefs_end_creating(). Calling INIT_LIST_HEAD(&ei->children) and INIT_LIST_HEAD(&ei->list) again without holding eventfs_mutex risks resetting an already-live list.
Also, should dentry->d_fsdata and ti->private be set before setting ti->flags |= TRACEFS_EVENT_INODE and switching inode->i_op to eventfs_ro_dir_inode_operations, and should dentry be reset to NULL (or only assigned after checking IS_ERR) if eventfs_ro_get_root() fails so static dentry does not hold an ERR_PTR?
[ ... ]
include/linux/tracefs.h struct eventfs_entry { · line 79
Quoted 10 lines
include/linux/tracefs.h +1
-0@@ -75,6 +75,7 @@ struct eventfs_entry {const char *name;eventfs_callback callback;eventfs_release release; +bool read_only; };
[Severity: Low]
This isn't a bug, but struct eventfs_entry has a kernel-doc comment just above this definition where @read_only (and @release) are not documented.
[ ... ]
Quoted 4 lines
kernel/trace/trace_events.c +0
-0
[ ... ]
kernel/trace/trace_events.c create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) · line 4792
Quoted 13 lines
kernel/trace/trace_events.c +7
-0@@ -4775,6 +4781,13 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) tr->event_dir = e_events; +if (!event_dir_ro_created && (tr->flags &TRACE_ARRAY_FL_GLOBAL )) { +int ret; + + ret =eventfs_create_events_ro_copy ("events" , e_events); +if (!ret) + event_dir_ro_created = true; + }return 0 ; }
[Severity: High]
What happens here when the kernel is booted with lockdown=confidentiality (LOCKDOWN_TRACEFS)?
In eventfs_create_events_dir():
fs/tracefs/event_inode.c:eventfs_create_events_dir() {
...
if (security_locked_down(LOCKDOWN_TRACEFS))
return NULL;
...
}When LOCKDOWN_TRACEFS is active, eventfs_create_events_dir() returns NULL rather than an ERR_PTR. In create_event_toplevel_files(), IS_ERR(e_events) evaluates to false for NULL, so e_events = NULL is passed to eventfs_create_events_ro_copy("events", e_events), which dereferences ei without a NULL check and crashes the kernel during boot.
Should create_event_toplevel_files() or eventfs_create_events_ro_copy() check for !e_events (and security_locked_down(LOCKDOWN_TRACEFS)) before dereferencing ei?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Steven Rostedt
maintainerQuoted 19 lines · On Mon, 02 Nov 2026 20:44:51 +0000 [email protected] wrote:
fs/tracefs/event_inode.c line 73
Quoted 9 lines
fs/tracefs/event_inode.c +8
-0+static int eventfs_ro_get_tree (struct fs_context *fc) +{ +return get_tree_single (fc, eventfs_ro_fill_super); +} + +static const struct fs_context_operations eventfs_ro_context_ops = { + .get_tree = eventfs_ro_get_tree, +};[Severity: Medium]
Can a remount clearSB_RDONLYon the eventfs superblock?
eventfs_ro_fill_super()setssb->s_flags|=SB_RDONLY, buteventfs_ro_context_opsdoes not define a .reconfigure callback. Inreconfigure_super(), whenfc->ops->reconfigureis NULL, VFS updatessb->s_flagsdirectly fromfc->sb_flagsandfc->sb_flags_mask, so running mount -o remount,rw/sys/kernel/eventswill clearSB_RDONLY.
Quoted 6 lines
Because
lookup_file()assignseventfs_file_inode_operations(with .setattr =eventfs_set_attr) to regular files in eventfs, clearingSB_RDONLYallows chmod/chown on/sys/kernel/eventsfiles to mutate the sharedei->entry_attrsused by tracefs. Shouldeventfs_ro_context_opsprovide a .reconfigure callback that rejects clearingSB_RDONLY(or should read-only file inodes omit .setattr)?
Ha! I wanted to handle this but wasn't sure how. Thank you Sashiko for telling me about the .reconfigure() method that lets me prevent the SB_RDONLY from being changed.
Quoted 16 lines
[ ... ]
Quoted 13 lines
fs/tracefs/event_inode.c +1
-1@@ -412,7 +499,7 @@ static struct dentry *lookup_file(struct eventfs_inode *parent_ei,* a eventfs_inode. */ static struct dentry *lookup_dir_entry (struct dentry *dentry, -struct eventfs_inode *pei,struct eventfs_inode *ei) +struct eventfs_inode *pei,struct eventfs_inode *ei,bool ro) {struct inode *inode;umode_t mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ;@@ -421,8 +508,13 @@ static struct dentry *lookup_dir_entry(struct dentry *dentry,if (unlikely (!inode))return ERR_PTR (-ENOMEM );
Quoted 13 lines
fs/tracefs/event_inode.c static struct dentry *lookup_dir_entry(struct dentry *dentry, · line 525
Quoted 9 lines
fs/tracefs/event_inode.c +7
-2- inode->i_op = &eventfs_dir_inode_operations; - inode->i_fop = &eventfs_file_operations; +if (ro) { + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + }else { + inode->i_op = &eventfs_dir_inode_operations; + inode->i_fop = &eventfs_file_operations; + }[Severity: Low]
This isn't a bug, butlookup_dir_entry()gained the @ro argument without a matching entry in its kernel-doc comment above.
Oops, I'll fix that in v5.
Quoted 14 lines
[ ... ]
Quoted 11 lines
fs/tracefs/event_inode.c +3
-0@@ -563,20 +656,44 @@ static struct dentry *eventfs_root_lookup(struct inode *dir,if (strcmp (name, entry->name) !=0 )continue ; +if (ro && !entry->read_only) +return NULL ; + data = ei->data;if (entry->callback (name, &mode, &data, &fops) <=0 )return NULL ;
Quoted 9 lines
fs/tracefs/event_inode.c static struct dentry *eventfs_root_lookup(struct inode *dir, · line 679
Quoted 6 lines
fs/tracefs/event_inode.c +6
-0+/* +* Read-only files gets all users read access, +* but also should make sure this is not writable. +*/ +if (ro) + mode |= (mode & ~0222 ) |0444 ;[Severity: Medium]
Should this use = instead of |= when updating mode?
Oops! Duh. Yeah that was a cut-and-paste bug.
Quoted 54 lines
Because |= ORs the right-hand side with the original value of mode, mode | (mode & ~0222) | 0444 simplifies to mode | 0444, leaving any write permission bits returned by
entry->callback()intact.Review static struct dentry *eventfs_root_lookup(struct inode *dir, · line 673
Quoted 2 lines
(quoted diff) +1
-0+ return lookup_file_dentry(dentry, ei, i, mode, data, fops);[Severity: Medium]
Will permission or ownership changes in tracefs leak into the read-only eventfs mount through sharedeventfs_attrandtracefs_inodesstate?In
__eventfs_root_lookup(), bothlookup_dir_entry()andlookup_file_dentry()pass the shared&ei->attrand &ei->entry_attrs[idx] intoeventfs_get_inode()->update_inode_attr()even when ro is true:fs/tracefs/event_inode.c:update_inode_attr() { ... if (attr && attr->mode & EVENTFS_SAVE_MODE) inode->i_mode = attr->mode & EVENTFS_MODE_MASK; else inode->i_mode = mode; if (attr && attr->mode & EVENTFS_SAVE_UID) inode->i_uid = attr->uid; else inode->i_uid = rei->ei.attr.uid; ... }If an administrator runs chmod or chown on files or directories under
/sys/kernel/tracing/events, or mounts tracefs with uid=/gid= options,update_inode_attr()will override the 0444 file mode (and directory permissions/ownership) in/sys/kernel/eventswith the saved tracefs attributes, potentially revoking unprivileged read access or re-enabling write bits. In addition,lookup_dir_entry()passesS_IFDIR|S_IRWXU|S_IRUGO|S_IXUGO(0755) instead of 0555 when ro is true.Similarly, because
eventfs_ro_super_operationsusestracefs_alloc_inode, eventfs inodes are added to the globaltracefs_inodeslist. When tracefs is remounted with uid= or gid=,tracefs_apply_options()walkstracefs_inodeswithout checkingti->vfs_inode.i_sb== sb and overwritesi_uidandi_gidon live eventfs inodes as well:fs/tracefs/inode.c:tracefs_apply_options() { ... list_for_each_entry_rcu(ti, &tracefs_inodes, list) { if (update_uid) { ti->flags &= ~TRACEFS_UID_PERM_SET; ti->vfs_inode.i_uid = fsi->uid; } ... }
Quoted 3 lines
Should ro lookups ignore
ei->attr/ei->entry_attrs(or shouldeventfs_get_inode()bypass saved tracefs attributes when on the read-only superblock), and shouldtracefs_apply_options()filter by superblock?
I probably should do that to be more robust. Currently all the files that are marked as read only do not even have a write method, so they can never be written to. The important thing is only these read-only files are exposed in eventfs. But for correctness, modifications to permissions should be prevented.
Quoted 19 lines
[ ... ]
Quoted 16 lines
fs/tracefs/event_inode.c +12
-0@@ -837,6 +967,52 @@ struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentryreturn ERR_PTR (-ENOMEM ); } +/** +* eventfs_create_events_ro_copy - create a read-only events directory +* @name: The name of the top level directory to create. +* @entries: A list of entries that represent the files under this directory +* @size: The number of @entries +* @data: The default data to pass to the files (an entry may override it). +* +* This function configures the eventfs filesystem root as a read-only +* trace event directory using the existing eventfs_inode lazy-lookup +* infrastructure. +* +* See eventfs_create_dir() for use of @entries.
Quoted 8 lines
fs/tracefs/event_inode.c struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentry · line 991
Quoted 2 lines
fs/tracefs/event_inode.c +2
-0+*/ +int eventfs_create_events_ro_copy (const char *name,struct eventfs_inode *ei)[Severity: Low]
This isn't a bug, but the kernel-doc comment foreventfs_create_events_ro_copy()still lists @entries, @size, and @data fromeventfs_create_events_dir()instead of @ei, and the @name parameter is unused in the function body.
Will fix.
Quoted 36 lines
Quoted 22 lines
fs/tracefs/event_inode.c +21
-0+{ +static struct dentry *dentry; +struct tracefs_inode *ti; +struct inode *inode; + +/* Can only be called once. */ +if (dentry) +return -EBUSY ; + +/* Reference acquired but never freed */ + dentry =eventfs_ro_get_root (); +if (IS_ERR (dentry)) +return PTR_ERR (dentry); + + inode =d_inode (dentry); + +INIT_LIST_HEAD (&ei->children); +INIT_LIST_HEAD (&ei->list); + + ti =get_tracefs (inode); + ti->flags |=TRACEFS_EVENT_INODE ;fs/tracefs/event_inode.c struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentry · line 1022
Quoted 10 lines
fs/tracefs/event_inode.c +10
-0+ ti->private = ei; + + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + +/* This is never freed */ + dentry->d_fsdata =get_ei (ei); + +return 0 ; +}[Severity: Medium]
Is it safe to re-initializeei->childrenandei->listhere?
Quoted 5 lines
In
create_event_toplevel_files(),e_eventshas already been allocated and initialized byeventfs_create_events_dir()->alloc_root_ei()->init_ei(), and published viatracefs_end_creating(). CallingINIT_LIST_HEAD(&ei->children)andINIT_LIST_HEAD(&ei->list)again without holdingeventfs_mutexrisks resetting an already-live list.
Hmm, I thought I fixed that. It's one of the things that Masami mentioned. Hmm, did I not commit the changes?
Quoted 9 lines
Also, should
dentry->d_fsdataandti->privatebe set before settingti->flags|=TRACEFS_EVENT_INODEand switchinginode->i_optoeventfs_ro_dir_inode_operations, and should dentry be reset to NULL (or only assigned after checkingIS_ERR) ifeventfs_ro_get_root()fails so static dentry does not hold anERR_PTR?[ ... ]
Quoted 14 lines
include/linux/tracefs.h struct eventfs_entry { · line 79
Quoted 10 lines
include/linux/tracefs.h +1
-0@@ -75,6 +75,7 @@ struct eventfs_entry {const char *name;eventfs_callback callback;eventfs_release release; +bool read_only; };[Severity: Low]
This isn't a bug, but structeventfs_entryhas a kernel-doc comment just above this definition where @read_only (and @release) are not documented.
Will fix.
Quoted 43 lines
[ ... ]
Quoted 4 lines
kernel/trace/trace_events.c +0
-0[ ... ]
kernel/trace/trace_events.c create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) · line 4792
Quoted 13 lines
kernel/trace/trace_events.c +7
-0@@ -4775,6 +4781,13 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) tr->event_dir = e_events; +if (!event_dir_ro_created && (tr->flags &TRACE_ARRAY_FL_GLOBAL )) { +int ret; + + ret =eventfs_create_events_ro_copy ("events" , e_events); +if (!ret) + event_dir_ro_created = true; + }return 0 ; }[Severity: High]
What happens here when the kernel is booted with lockdown=confidentiality (LOCKDOWN_TRACEFS)?In
eventfs_create_events_dir():fs/tracefs/event_inode.c:eventfs_create_events_dir() { ... if (security_locked_down(LOCKDOWN_TRACEFS)) return NULL; ... }When
LOCKDOWN_TRACEFSis active,eventfs_create_events_dir()returns NULL rather than anERR_PTR. Increate_event_toplevel_files(),IS_ERR(e_events)evaluates to false for NULL, soe_events= NULL is passed toeventfs_create_events_ro_copy("events", e_events), which dereferences ei without a NULL check and crashes the kernel during boot.
Quoted 4 lines
Should
create_event_toplevel_files()oreventfs_create_events_ro_copy()check for !e_events (andsecurity_locked_down(LOCKDOWN_TRACEFS)) before dereferencing ei?
Oops, will fix.
Thanks,
-- Steve
Masami Hiramatsu (Google)
maintainerQuoted 30 lines · Steven Rostedt
From: Anubhav Shelat <[email protected]>
Introduce a new read-only pseudo-filesystem "eventfs" mounted at
/sys/kernel/eventsthat exposes trace event format and id files (mode 0444) to unprivileged users. This allows tools like perf to discover event formats without requiring access to the full tracefs/debugfs mount.The eventfs file system reuses the existing
eventfs_inodelazy-lookup infrastructure. A new set ofsuper_operations(eventfs_ro_super_operations) shares the tracefs inode allocator so thateventfs_get_inode()andget_tracefs()work on the RO superblock. The superblock is manually initialized to ensure the root inode is allocated withtracefs_alloc_inode, allowing the root to serve directly as the events directory without another events subdirectory.Each qualifying event gets a subsystem directory containing format and id files. The top-level events directory also exposes
header_pageandheader_event. Similar to tracefs, a change will need to be made in systemd to mount this filesystem automatically.[
Steven Rostedt rewrote to use the lookup functions to determine read only files to show. The structeventfs_entrynow has a "readonly" field and if it is set, it will be displayed in the read only file system. The original code [1] duplicated theeventfs_inodesfor every event and subsystem. The new approach uses the existingeventfs_inodes(without requiring more memory to store them) and uses theeventfs_entryarrays to show which files are allowed to be read readonly or not.
Quoted 2 lines
Thanks for the work! As we talked offline, I think we can use this for the backup instance (an instance copied from another instance at boot) because that backup instance is also read only. See trace_array_is_readonly() and TRACE_ARRAY_FL_RDONLY[1].
Quoted 2 lines
Assisted-by CLAUDE:claude-opus-4 Apogee
BTW, this tag seems removed by commit 1e035297ffda ("docs: remove Assisted-by references")
Thanks,
Quoted 489 lines
Signed-off-by Anubhav Shelat <[email protected]>Signed-off-by Steven Rostedt <[email protected]>---
Changes since v3: https://patch.msgid.link/[email protected]- Fixed kernel doc name for
eventfs_create_events_ro_copy()(Masami Hiramatsu)- Removed duplicate initialization of ei in that function. (Masami Hiramatsu)
- Added include of
linux/magic.has it failed to build on some architectures. (kernel test robot)fs/tracefs/event_inode.c | 192 ++++++++++++++++++++++++++++++++++-- fs/tracefs/inode.c | 21 +++- fs/tracefs/internal.h | 6 ++ include/linux/tracefs.h | 3 + include/uapi/linux/magic.h | 1 + kernel/trace/trace_events.c | 13 +++ 6 files changed, 225 insertions(+), 11 deletions(-)fs/tracefs/event_inode.c +184
-8@@ -16,14 +16,87 @@*/ #include <linux/fsnotify.h> #include <linux/fs.h> +#include <linux/fs_context.h> #include <linux/namei.h> #include <linux/workqueue.h> #include <linux/security.h> #include <linux/tracefs.h> +#include <linux/magic.h> #include <linux/kref.h> #include <linux/delay.h> #include "internal.h" +static struct vfsmount *eventfs_ro_mount; +static int eventfs_ro_mount_count; + +static int eventfs_ro_fill_super (struct super_block *sb,struct fs_context *fc) +{ +struct inode *inode; +struct dentry *root; + + sb->s_blocksize =PAGE_SIZE ; + sb->s_blocksize_bits =PAGE_SHIFT ; + sb->s_magic =EVENTFS_SUPER_MAGIC ; + sb->s_op = &eventfs_ro_super_operations; + sb->s_time_gran =1 ; + sb->s_flags |=SB_RDONLY ; + + inode =new_inode (sb); +if (!inode) +return -ENOMEM ; + + inode->i_ino =1 ; + inode->i_mode =S_IFDIR |0555 ; +simple_inode_init_ts (inode); + inode->i_op = &simple_dir_inode_operations; + inode->i_fop = &simple_dir_operations; +set_nlink (inode,2 ); + +set_default_d_op (sb, &tracefs_dentry_operations); + + root =d_make_root (inode); +if (!root) +return -ENOMEM ; + + sb->s_root = root; + +return 0 ; +} + +static int eventfs_ro_get_tree (struct fs_context *fc) +{ +return get_tree_single (fc, eventfs_ro_fill_super); +} + +static const struct fs_context_operations eventfs_ro_context_ops = { + .get_tree = eventfs_ro_get_tree, +}; + +static int eventfs_ro_init_fs_context (struct fs_context *fc) +{ + fc->ops = &eventfs_ro_context_ops; +return 0 ; +} + +struct file_system_type eventfs_ro_fs_type = { + .owner =THIS_MODULE , + .name ="eventfs" , + .init_fs_context = eventfs_ro_init_fs_context, + .kill_sb = kill_anon_super, +}; + +struct dentry *eventfs_ro_get_root (void ) +{ +int error; + + error =simple_pin_fs (&eventfs_ro_fs_type, &eventfs_ro_mount, + &eventfs_ro_mount_count); +if (error) +return ERR_PTR (error); + +return dget (eventfs_ro_mount->mnt_root); +} +/* * eventfs_mutex protects the eventfs_inode (ei) dentry. Any access * to the ei->dentry must be done under this mutex and after checking @@ -169,7 +242,11 @@ static inline struct eventfs_inode *get_ei(struct eventfs_inode *ei)static struct dentry *eventfs_root_lookup (struct inode *dir,struct dentry *dentry,unsigned int flags); +static struct dentry *eventfs_root_lookup_ro (struct inode *dir, +struct dentry *dentry, +unsigned int flags);static int eventfs_iterate (struct file *file,struct dir_context *ctx); +static int eventfs_ro_iterate (struct file *file,struct dir_context *ctx);static void update_attr (struct eventfs_attr *attr,struct iattr *iattr) {@@ -247,6 +324,10 @@ static const struct inode_operations eventfs_dir_inode_operations = { .setattr = eventfs_set_attr, }; +static const struct inode_operations eventfs_ro_dir_inode_operations = { + .lookup = eventfs_root_lookup_ro, +}; +static const struct inode_operations eventfs_file_inode_operations = { .setattr = eventfs_set_attr, };@@ -257,6 +338,12 @@ static const struct file_operations eventfs_file_operations = { .llseek = generic_file_llseek, }; +static const struct file_operations eventfs_ro_file_operations = { + .read = generic_read_dir, + .iterate_shared = eventfs_ro_iterate, + .llseek = generic_file_llseek, +}; +static void eventfs_set_attrs (struct eventfs_inode *ei,bool update_uid,kuid_t uid,bool update_gid,kgid_t gid,int level) {@@ -420,7 +507,7 @@ static struct dentry *lookup_file(struct eventfs_inode *parent_ei,* a eventfs_inode. */ static struct dentry *lookup_dir_entry (struct dentry *dentry, -struct eventfs_inode *pei,struct eventfs_inode *ei) +struct eventfs_inode *pei,struct eventfs_inode *ei,bool ro) {struct inode *inode;umode_t mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ;@@ -429,8 +516,13 @@ static struct dentry *lookup_dir_entry(struct dentry *dentry,if (unlikely (!inode))return ERR_PTR (-ENOMEM ); - inode->i_op = &eventfs_dir_inode_operations; - inode->i_fop = &eventfs_file_operations; +if (ro) { + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + }else { + inode->i_op = &eventfs_dir_inode_operations; + inode->i_fop = &eventfs_file_operations; + }/* All directories will have the same inode number */ inode->i_ino =eventfs_dir_ino (ei);@@ -534,9 +626,10 @@ lookup_file_dentry(struct dentry *dentry,* list, if @dentry found go ahead and create the file/dir */ -static struct dentry *eventfs_root_lookup (struct inode *dir, -struct dentry *dentry, -unsigned int flags) +static struct dentry *__eventfs_root_lookup (struct inode *dir, +struct dentry *dentry, +unsigned int flags, +bool ro) {struct eventfs_inode *ei_child;struct tracefs_inode *ti;@@ -559,7 +652,7 @@ static struct dentry *eventfs_root_lookup(struct inode *dir,/* A child is freed and removed from the list at the same time */ if (WARN_ON_ONCE (ei_child->is_freed))return NULL ; -return lookup_dir_entry (dentry, ei, ei_child); +return lookup_dir_entry (dentry, ei, ei_child, ro); }for (int i =0 ; i < ei->nr_entries; i++) {@@ -571,20 +664,44 @@ static struct dentry *eventfs_root_lookup(struct inode *dir,if (strcmp (name, entry->name) !=0 )continue ; +if (ro && !entry->read_only) +return NULL ; + data = ei->data;if (entry->callback (name, &mode, &data, &fops) <=0 )return NULL ; +/* +* Read-only files gets all users read access, +* but also should make sure this is not writable. +*/ +if (ro) + mode |= (mode & ~0222 ) |0444 ; +return lookup_file_dentry (dentry, ei, i, mode, data, fops); }return NULL ; } +static struct dentry *eventfs_root_lookup (struct inode *dir, +struct dentry *dentry, +unsigned int flags) +{ +return __eventfs_root_lookup (dir, dentry, flags, false); +} + +static struct dentry *eventfs_root_lookup_ro (struct inode *dir, +struct dentry *dentry, +unsigned int flags) +{ +return __eventfs_root_lookup (dir, dentry, flags, true); +} +/* * Walk the children of a eventfs_inode to fill in getdents(). */ -static int eventfs_iterate (struct file *file,struct dir_context *ctx) +static int __eventfs_iterate (struct file *file,struct dir_context *ctx,bool ro) {const struct file_operations *fops;struct inode *f_inode =file_inode (file);@@ -630,6 +747,9 @@ static int eventfs_iterate(struct file *file, struct dir_context *ctx) entry = &ei->entries[i]; name = entry->name; +if (ro && !entry->read_only) +continue ; +/* If ei->is_freed then just bail here, nothing more to do */ scoped_guard(mutex, &eventfs_mutex) {if (ei->is_freed)@@ -688,6 +808,16 @@ static int eventfs_iterate(struct file *file, struct dir_context *ctx)return 1 ; } +static int eventfs_iterate (struct file *file,struct dir_context *ctx) +{ +return __eventfs_iterate (file, ctx, false); +} + +static int eventfs_ro_iterate (struct file *file,struct dir_context *ctx) +{ +return __eventfs_iterate (file, ctx, true); +} +/** * eventfs_create_dir - Create the eventfs_inode for this directory * @name: The name of the directory to create. @@ -845,6 +975,52 @@ struct eventfs_inode *eventfs_create_events_dir(const char *name, struct dentryreturn ERR_PTR (-ENOMEM ); } +/** +* eventfs_create_events_ro_copy - create a read-only events directory +* @name: The name of the top level directory to create. +* @entries: A list of entries that represent the files under this directory +* @size: The number of @entries +* @data: The default data to pass to the files (an entry may override it). +* +* This function configures the eventfs filesystem root as a read-only +* trace event directory using the existing eventfs_inode lazy-lookup +* infrastructure. +* +* See eventfs_create_dir() for use of @entries. +*/ +int eventfs_create_events_ro_copy (const char *name,struct eventfs_inode *ei) +{ +static struct dentry *dentry; +struct tracefs_inode *ti; +struct inode *inode; + +/* Can only be called once. */ +if (dentry) +return -EBUSY ; + +/* Reference acquired but never freed */ + dentry =eventfs_ro_get_root (); +if (IS_ERR (dentry)) +return PTR_ERR (dentry); + + inode =d_inode (dentry); + +INIT_LIST_HEAD (&ei->children); +INIT_LIST_HEAD (&ei->list); + + ti =get_tracefs (inode); + ti->flags |=TRACEFS_EVENT_INODE ; + ti->private = ei; + + inode->i_op = &eventfs_ro_dir_inode_operations; + inode->i_fop = &eventfs_ro_file_operations; + +/* This is never freed */ + dentry->d_fsdata =get_ei (ei); + +return 0 ; +} +/** * eventfs_remove_rec - remove eventfs dir or file from list * @ei: eventfs_inode to be removed. fs/tracefs/inode.c +18
-3@@ -423,6 +423,14 @@ static const struct super_operations tracefs_super_operations = { .show_options = tracefs_show_options, }; +const struct super_operations eventfs_ro_super_operations = { + .alloc_inode = tracefs_alloc_inode, + .free_inode = tracefs_free_inode, + .destroy_inode = tracefs_destroy_inode, + .drop_inode = tracefs_drop_inode, + .statfs = simple_statfs, +}; +/* * It would be cleaner if eventfs had its own dentry ops. * @@ -455,7 +463,7 @@ static int tracefs_d_delete(const struct dentry *dentry)return dentry->d_fsdata ==NULL ; } -static const struct dentry_operations tracefs_dentry_operations = { +const struct dentry_operations tracefs_dentry_operations = { .d_revalidate = tracefs_d_revalidate, .d_release = tracefs_d_release, .d_delete = tracefs_d_delete,@@ -801,8 +809,15 @@ static int __init tracefs_init(void)return -EINVAL ; retval =register_filesystem (&trace_fs_type); -if (!retval) - tracefs_registered = true; +if (retval) +return retval; + tracefs_registered = true; + + retval =sysfs_create_mount_point (kernel_kobj,"events" ); +if (retval) +return retval; + + retval =register_filesystem (&eventfs_ro_fs_type);return retval; }fs/tracefs/internal.h +6
-0@@ -2,6 +2,10 @@#ifndef _TRACEFS_INTERNAL_H#define _TRACEFS_INTERNAL_H +extern const struct dentry_operations tracefs_dentry_operations; +extern const struct super_operations eventfs_ro_super_operations; +extern struct file_system_type eventfs_ro_fs_type; +enum {TRACEFS_EVENT_INODE =BIT (1 ), TRACEFS_GID_PERM_SET = BIT(2),@@ -73,6 +77,8 @@ struct dentry *tracefs_end_creating(struct dentry *dentry);struct dentry *tracefs_failed_creating (struct dentry *dentry);struct inode *tracefs_get_inode (struct super_block *sb); +struct dentry *eventfs_ro_get_root (void ); +void eventfs_remount (struct tracefs_inode *ti,bool update_uid,bool update_gid);void eventfs_d_release (struct dentry *dentry);include/linux/tracefs.h +3
-0@@ -75,6 +75,7 @@ struct eventfs_entry {const char *name;eventfs_callback callback;eventfs_release release; +bool read_only; };struct eventfs_inode ;@@ -87,6 +88,8 @@ struct eventfs_inode *eventfs_create_dir(const char *name, struct eventfs_inodeconst struct eventfs_entry *entries, int size, void *data); +int eventfs_create_events_ro_copy (const char *name,struct eventfs_inode *ei); +void eventfs_remove_events_dir (struct eventfs_inode *ei);void eventfs_remove_dir (struct eventfs_inode *ei);include/uapi/linux/magic.h +1
-0@@ -76,6 +76,7 @@#define STACK_END_MAGIC 0x57AC6E9D#define TRACEFS_MAGIC 0x74726163 +#define EVENTFS_SUPER_MAGIC 0x65766673#define V9FS_MAGIC 0x01021997kernel/trace/trace_events.c +13
-0@@ -3298,17 +3298,20 @@ event_create_dir(struct eventfs_inode *parent, struct trace_event_file *file) { .name = "format", .callback = event_callback, + .read_only = true, }, #ifdef CONFIG_PERF_EVENTS { .name = "id", .callback = event_callback, + .read_only = true, }, #endif #ifdef CONFIG_BPF_EVENTS { .name = "btf_ids", .callback = event_callback, + .read_only = true, }, #endif #define NR_RO_EVENT_ENTRIES (1 + IS_ENABLED(CONFIG_PERF_EVENTS) + \@@ -4722,6 +4725,7 @@ static int events_callback(const char *name, umode_t *mode, void **data,static int create_event_toplevel_files (struct dentry *parent,struct trace_array *tr) { +static bool event_dir_ro_created;struct eventfs_inode *e_events;struct dentry *entry;int nr_entries;@@ -4729,10 +4733,12 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) { .name = "header_page", .callback = events_callback, + .read_only = true, }, { .name = "header_event", .callback = events_callback, + .read_only = true, }, #define NR_RO_TOP_ENTRIES 2 /* Readonly files must be above this line and counted by NR_RO_TOP_ENTRIES. */@@ -4775,6 +4781,13 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) tr->event_dir = e_events; +if (!event_dir_ro_created && (tr->flags &TRACE_ARRAY_FL_GLOBAL )) { +int ret; + + ret =eventfs_create_events_ro_copy ("events" , e_events); +if (!ret) + event_dir_ro_created = true; + }return 0 ; }Signature · 1 line
2.53.0
Signature · 1 line
Masami Hiramatsu (Google) <[email protected]>
Steven Rostedt
maintainerOn Tue, 03 Nov 2026 11:18:03 +0900
"Masami Hiramatsu (Google)" <[email protected]> wrote:
\
Quoted 4 lines
Thanks for the work! As we talked offline, I think we can use this for the backup instance (an instance copied from another instance at boot) because that backup instance is also read only. See
trace_array_is_readonly()and TRACE_ARRAY_FL_RDONLY[1].
Will do.
Quoted 8 lines
Quoted 2 lines
Assisted-by CLAUDE:claude-opus-4 ApogeeBTW, this tag seems removed by commit
1e035297ffda("docs: remove Assisted-by references")
As I was one of the first people to advocate for that tag, and I wasn't invited to the Maintainers Summit to argue against the removal of that tag, I will not remove any assisted by tags.
It may not be required anymore, but hell, I'll keep them for commits I'm responsible for. I still find them useful.
-- Steve