tracing: Add new file system tracefs
Steven Rostedt
maintainercover tracing: Add new file system tracefs
There has been complaints that tracing is tied too much to debugfs, as there are systems that would like to perform tracing, but do not mount debugfs for security reasons. That is because any subsystem may use debugfs for debugging, and these interfaces are not always tested for security.
Creating a new tracefs that the tracing directory will now be attached to allows system admins the ability to access the tracing directory without the need to mount debugfs.
Another advantage is that debugfs does not support the system calls for mkdir and rmdir. Tracing uses these system calls to create new instances for sub buffers. This was done by a hack that hijacked the dentry ops from the "instances" debugfs dentry, and replacing it with one that could work.
Instead of using this hack, tracefs can provide a proper interface to allow the tracing system to have a mkdir and rmdir feature.
To maintain backward compatibility with older tools that expect that the tracing directory is mounted with debugfs, the tracing directory is still created under debugfs and tracefs is automatically mounted there.
Finally, a new directory is created when tracefs is enabled called /sys/kernel/tracing. This will be the new location that system admins may mount tracefs if they are not using debugfs.
Steven Rostedt (Red Hat) (5):
tracefs: Add new tracefs file system
tracing: Convert the tracing facility over to use tracefs
tracing: Automatically mount tracefs on debugfs/tracing
tracing: Have mkdir and rmdir be part of tracefs
tracefs: Add directory /sys/kernel/tracing
----
fs/Makefile | 1 + fs/tracefs/Makefile | 4 + fs/tracefs/inode.c | 649 +++++++++++++++++++++++++++++++++++ include/uapi/linux/magic.h | 2 + kernel/trace/ftrace.c | 22 +- kernel/trace/trace.c | 178 +++++----- kernel/trace/trace.h | 2 +- kernel/trace/trace_events.c | 32 +- kernel/trace/trace_functions_graph.c | 7 +- kernel/trace/trace_kprobe.c | 10 +- kernel/trace/trace_probe.h | 2 +- kernel/trace/trace_stat.c | 10 +- scripts/tags.sh | 2 +- 13 files changed, 789 insertions(+), 132 deletions(-)
Steven Rostedt
maintainerRFC PATCH 1/5 tracefs: Add new tracefs file system
From: "Steven Rostedt (Red Hat)" <[email protected]>
Add a separate file system to handle the tracing directory. Currently it is part of debugfs, but that is starting to show its limits.
One thing is that in order to access the tracing infrastructure, you need to mount debugfs. As that includes debugging from all sorts of sub systems in the kernel, it is not considered advisable to mount such an all encompassing debugging system.
Having the tracing system in its own file systems gives access to the tracing sub system without needing to include all other systems.
Another problem with tracing using the debugfs system is that the instances use mkdir to create sub buffers. debugfs does not support mkdir from userspace so to implement it, special hacks were used. By controlling the file system that the tracing infrastructure uses, this can be properly done without hacks.
--- fs/Makefile | 1 + fs/tracefs/Makefile | 4 + fs/tracefs/inode.c | 561 +++++++++++++++++++++++++++++++++++++++++++++ include/uapi/linux/magic.h | 2 + 4 files changed, 568 insertions(+) create mode 100644 fs/tracefs/Makefile create mode 100644 fs/tracefs/inode.c
fs/Makefile +1 -0
@@ -118,6 +118,7 @@ obj-$(CONFIG_HOSTFS) += hostfs/ obj-$(CONFIG_HPPFS) += hppfs/ obj-$(CONFIG_CACHEFILES) += cachefiles/ obj-$(CONFIG_DEBUG_FS) += debugfs/ +obj-$(CONFIG_TRACING) += tracefs/ obj-$(CONFIG_OCFS2_FS) += ocfs2/ obj-$(CONFIG_BTRFS_FS) += btrfs/ obj-$(CONFIG_GFS2_FS) += gfs2/
fs/tracefs/Makefile new file +4 -0
@@ -0,0 +1,4 @@ +tracefs-objs := inode.o + +obj-$(CONFIG_TRACING) += tracefs.o +
fs/tracefs/inode.c new file +561 -0
561 lines not on this page · raw message
include/uapi/linux/magic.h +2 -0
@@ -58,6 +58,8 @@#define STACK_END_MAGIC 0x57AC6E9D +#define TRACEFS_MAGIC 0x74726163 +#define V9FS_MAGIC 0x01021997#define BDEVFS_MAGIC 0x62646576
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRe: [RFC][PATCH 1/5] tracefs: Add new tracefs file system
I need to learn how to use git better :-/
I forgot to git add include/linux/tracefs.h:
-- Steve
--- include/linux/tracefs.h | 41 ++++ create mode 100644 include/linux/tracefs.h
include/linux/tracefs.h new file +41 -0
@@ -0,0 +1,41 @@ +/* +* tracefs.h - a pseudo file system for activating tracing +* +* Based on debugfs by: 2004 Greg Kroah-Hartman <[email protected]> +* +* Copyright (C) 2014 Red Hat Inc, author: Steven Rostedt <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License version +* 2 as published by the Free Software Foundation. +* +* tracefs is the file system that is used by the tracing infrastructure. +* +*/ + +#ifndef _TRACEFS_H_ +#define _TRACEFS_H_ + +#include <linux/fs.h> +#include <linux/seq_file.h> + +#include <linux/types.h> + +struct file_operations ; + +#ifdef CONFIG_TRACING + +struct dentry *tracefs_create_file (const char *name,umode_t mode, +struct dentry *parent,void *data, +const struct file_operations *fops); + +struct dentry *tracefs_create_dir (const char *name,struct dentry *parent); + +void tracefs_remove (struct dentry *dentry); +void tracefs_remove_recursive (struct dentry *dentry); + +bool tracefs_initialized (void ); + +#endif /* CONFIG_TRACING */ + +#endif
Steven Rostedt
maintainerRFC PATCH 2/5 tracing: Convert the tracing facility over to use tracefs
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
debugfs was fine for the tracing facility as a quick way to get an interface. Now that tracing has matured, it should separate itself from debugfs such that it can be mounted separately without needing to mount all of debugfs with it. That is, users resist using tracing because it requires mounting debugfs. Having tracing have its own file system lets users get the features of tracing without needing to bring in the rest of the kernel's debug infrastructure.
Another reason for tracefs is that debubfs does not support mkdir. Currently, to create instances, one does a mkdir in the tracing/instance directory. This is implemented via a hack that forces debugfs to do something it is not intended on doing. By converting over to tracefs, this hack can be removed and mkdir can be properly implemented. This patch does not address this yet, but it lays the ground work for that to be done.
--- kernel/trace/ftrace.c | 22 ++++++------- kernel/trace/trace.c | 63 ++++++++++++++++++++++-------------- kernel/trace/trace.h | 2 +- kernel/trace/trace_events.c | 32 +++++++++--------- kernel/trace/trace_functions_graph.c | 7 ++-- kernel/trace/trace_kprobe.c | 10 +++--- kernel/trace/trace_probe.h | 2 +- kernel/trace/trace_stat.c | 10 +++--- scripts/tags.sh | 2 +- 9 files changed, 81 insertions(+), 69 deletions(-)
kernel/trace/ftrace.c +11 -11
@@ -18,7 +18,7 @@#include <linux/kallsyms.h> #include <linux/seq_file.h> #include <linux/suspend.h> -#include <linux/debugfs.h> +#include <linux/tracefs.h> #include <linux/hardirq.h> #include <linux/kthread.h> #include <linux/uaccess.h>
@@ -1008,7 +1008,7 @@ static struct tracer_stat function_stats __initdata = { .stat_show = function_stat_show }; -static __init void ftrace_profile_debugfs (struct dentry *d_tracer) +static __init void ftrace_profile_tracefs (struct dentry *d_tracer) {struct ftrace_profile_stat *stat;struct dentry *entry;
@@ -1044,15 +1044,15 @@ static __init void ftrace_profile_debugfs(struct dentry *d_tracer) } } - entry =debugfs_create_file ("function_profile_enabled" ,0644 , + entry =tracefs_create_file ("function_profile_enabled" ,0644 , d_tracer,NULL , &ftrace_profile_fops);if (!entry) -pr_warning ("Could not create debugfs " +pr_warning ("Could not create tracefs " "'function_profile_enabled' entry\n" ); }#else /* CONFIG_FUNCTION_PROFILER */ -static __init void ftrace_profile_debugfs (struct dentry *d_tracer) +static __init void ftrace_profile_tracefs (struct dentry *d_tracer) { }#endif /* CONFIG_FUNCTION_PROFILER */
@@ -4653,7 +4653,7 @@ void ftrace_destroy_filter_files(struct ftrace_ops *ops)mutex_unlock (&ftrace_lock); } -static __init int ftrace_init_dyn_debugfs (struct dentry *d_tracer) +static __init int ftrace_init_dyn_tracefs (struct dentry *d_tracer) { trace_create_file("available_filter_functions", 0444,
@@ -4961,7 +4961,7 @@ static int __init ftrace_nodyn_init(void) }core_initcall (ftrace_nodyn_init); -static inline int ftrace_init_dyn_debugfs (struct dentry *d_tracer) {return 0 ; } +static inline int ftrace_init_dyn_tracefs (struct dentry *d_tracer) {return 0 ; }static inline void ftrace_startup_enable (int command) { }static inline void ftrace_startup_all (int command) { }/* Keep as macros so we do not need to define the commands */
@@ -5414,7 +5414,7 @@ static const struct file_operations ftrace_pid_fops = { .release = ftrace_pid_release, }; -static __init int ftrace_init_debugfs (void ) +static __init int ftrace_init_tracefs (void ) {struct dentry *d_tracer;
@@ -5422,16 +5422,16 @@ static __init int ftrace_init_debugfs(void)if (IS_ERR (d_tracer))return 0 ; -ftrace_init_dyn_debugfs (d_tracer); +ftrace_init_dyn_tracefs (d_tracer);trace_create_file ("set_ftrace_pid" ,0644 , d_tracer,NULL , &ftrace_pid_fops); -ftrace_profile_debugfs (d_tracer); +ftrace_profile_tracefs (d_tracer);return 0 ; } -fs_initcall (ftrace_init_debugfs); +fs_initcall (ftrace_init_tracefs);/** * ftrace_kill - kill ftrace
kernel/trace/trace.c +38 -25
196 lines not on this page · raw message
kernel/trace/trace.h +1 -1
@@ -334,7 +334,7 @@ struct tracer_flags {/** -* struct tracer - a specific tracer and its callbacks to interact with debugfs +* struct tracer - a specific tracer and its callbacks to interact with tracefs * @name: the name chosen to select it on the available_tracers file * @init: called when one switches to this tracer (echo name > current_tracer) * @reset: called when one switches to another tracer
kernel/trace/trace_events.c +16 -16
@@ -13,7 +13,7 @@#include <linux/workqueue.h> #include <linux/spinlock.h> #include <linux/kthread.h> -#include <linux/debugfs.h> +#include <linux/tracefs.h> #include <linux/uaccess.h> #include <linux/module.h> #include <linux/ctype.h>
@@ -480,7 +480,7 @@ static void remove_subsystem(struct ftrace_subsystem_dir *dir)return ;if (!--dir->nr_events) { -debugfs_remove_recursive (dir->entry); +tracefs_remove_recursive (dir->entry);list_del (&dir->list);__put_system_dir (dir); }
@@ -499,7 +499,7 @@ static void remove_event_file_dir(struct ftrace_event_file *file) }spin_unlock (&dir->d_lock); -debugfs_remove_recursive (dir); +tracefs_remove_recursive (dir); }list_del (&file->list);
@@ -1526,7 +1526,7 @@ event_subsystem_dir(struct trace_array *tr, const char *name, }else __get_system (system); - dir->entry =debugfs_create_dir (name, parent); + dir->entry =tracefs_create_dir (name, parent);if (!dir->entry) {pr_warn ("Failed to create system directory %s\n" , name);__put_system (system);
@@ -1539,12 +1539,12 @@ event_subsystem_dir(struct trace_array *tr, const char *name, dir->subsystem = system; file->system = dir; - entry =debugfs_create_file ("filter" ,0644 , dir->entry, dir, + entry =tracefs_create_file ("filter" ,0644 , dir->entry, dir, &ftrace_subsystem_filter_fops);if (!entry) {kfree (system->filter); system->filter =NULL ; -pr_warn ("Could not create debugfs '%s/filter' entry\n" , name); +pr_warn ("Could not create tracefs '%s/filter' entry\n" , name); } trace_create_file("enable", 0644, dir->entry, dir,
@@ -1585,9 +1585,9 @@ event_create_dir(struct dentry *parent, struct ftrace_event_file *file) d_events = parent; name =ftrace_event_name (call); - file->dir =debugfs_create_dir (name, d_events); + file->dir =tracefs_create_dir (name, d_events);if (!file->dir) { -pr_warn ("Could not create debugfs '%s' directory\n" , name); +pr_warn ("Could not create tracefs '%s' directory\n" , name);return -1 ; }
@@ -2228,7 +2228,7 @@ static inline int register_event_cmds(void) { return 0; }/* * The top level array has already had its ftrace_event_file * descriptors created in order to allow for early events to -* be recorded. This function is called after the debugfs has been +* be recorded. This function is called after the tracefs has been * initialized, and we now have to create the files associated * to the events. */
@@ -2311,16 +2311,16 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)struct dentry *d_events;struct dentry *entry; - entry =debugfs_create_file ("set_event" ,0644 , parent, + entry =tracefs_create_file ("set_event" ,0644 , parent, tr, &ftrace_set_event_fops);if (!entry) { -pr_warn ("Could not create debugfs 'set_event' entry\n" ); +pr_warn ("Could not create tracefs 'set_event' entry\n" );return -ENOMEM ; } - d_events =debugfs_create_dir ("events" , parent); + d_events =tracefs_create_dir ("events" , parent);if (!d_events) { -pr_warn ("Could not create debugfs 'events' directory\n" ); +pr_warn ("Could not create tracefs 'events' directory\n" );return -ENOMEM ; }
@@ -2412,7 +2412,7 @@ int event_trace_del_tracer(struct trace_array *tr)down_write (&trace_event_sem);__trace_remove_event_dirs (tr); -debugfs_remove_recursive (tr->event_dir); +tracefs_remove_recursive (tr->event_dir);up_write (&trace_event_sem); tr->event_dir =NULL ;
@@ -2493,10 +2493,10 @@ static __init int event_trace_init(void)if (IS_ERR (d_tracer))return 0 ; - entry =debugfs_create_file ("available_events" ,0444 , d_tracer, + entry =tracefs_create_file ("available_events" ,0444 , d_tracer, tr, &ftrace_avail_fops);if (!entry) -pr_warn ("Could not create debugfs 'available_events' entry\n" ); +pr_warn ("Could not create tracefs 'available_events' entry\n" );if (trace_define_common_fields ())pr_warn ("tracing: Failed to allocate common fields" );
kernel/trace/trace_functions_graph.c +3 -4
@@ -6,7 +6,6 @@* is Copyright (c) Steven Rostedt <[email protected]> * */ -#include <linux/debugfs.h> #include <linux/uaccess.h> #include <linux/ftrace.h> #include <linux/slab.h>
@@ -151,7 +150,7 @@ ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,* The curr_ret_stack is initialized to -1 and get increased * in this function. So it can be less than -1 only if it was * filtered out via ftrace_graph_notrace_addr() which can be -* set from set_graph_notrace file in debugfs by user. +* set from set_graph_notrace file in tracefs by user. */ if (current->curr_ret_stack <-1 )return -EBUSY ;
@@ -1432,7 +1431,7 @@ static const struct file_operations graph_depth_fops = { .llseek = generic_file_llseek, }; -static __init int init_graph_debugfs (void ) +static __init int init_graph_tracefs (void ) {struct dentry *d_tracer;
@@ -1445,7 +1444,7 @@ static __init int init_graph_debugfs(void)return 0 ; } -fs_initcall (init_graph_debugfs); +fs_initcall (init_graph_tracefs);static __init int init_graph_trace (void ) {
kernel/trace/trace_kprobe.c +5 -5
@@ -1310,7 +1310,7 @@ static int unregister_kprobe_event(struct trace_kprobe *tk)return ret; } -/* Make a debugfs interface for controlling probe points */ +/* Make a tracefs interface for controlling probe points */ static __init int init_kprobe_trace (void ) {struct dentry *d_tracer;
@@ -1323,20 +1323,20 @@ static __init int init_kprobe_trace(void)if (IS_ERR (d_tracer))return 0 ; - entry =debugfs_create_file ("kprobe_events" ,0644 , d_tracer, + entry =tracefs_create_file ("kprobe_events" ,0644 , d_tracer,NULL , &kprobe_events_ops);/* Event list interface */ if (!entry) -pr_warning ("Could not create debugfs " +pr_warning ("Could not create tracefs " "'kprobe_events' entry\n" );/* Profile interface */ - entry =debugfs_create_file ("kprobe_profile" ,0444 , d_tracer, + entry =tracefs_create_file ("kprobe_profile" ,0444 , d_tracer,NULL , &kprobe_profile_ops);if (!entry) -pr_warning ("Could not create debugfs " +pr_warning ("Could not create tracefs " "'kprobe_profile' entry\n" );return 0 ; }
kernel/trace/trace_probe.h +1 -1
@@ -25,7 +25,7 @@#include <linux/seq_file.h> #include <linux/slab.h> #include <linux/smp.h> -#include <linux/debugfs.h> +#include <linux/tracefs.h> #include <linux/types.h> #include <linux/string.h> #include <linux/ctype.h>
kernel/trace/trace_stat.c +5 -5
@@ -12,7 +12,7 @@#include <linux/list.h> #include <linux/slab.h> #include <linux/rbtree.h> -#include <linux/debugfs.h> +#include <linux/tracefs.h> #include "trace_stat.h" #include "trace.h"
@@ -65,7 +65,7 @@ static void reset_stat_session(struct stat_session *session)static void destroy_session (struct stat_session *session) { -debugfs_remove (session->file); +tracefs_remove (session->file);__reset_stat_session (session);mutex_destroy (&session->stat_mutex);kfree (session);
@@ -279,9 +279,9 @@ static int tracing_stat_init(void)if (IS_ERR (d_tracing))return 0 ; - stat_dir =debugfs_create_dir ("trace_stat" , d_tracing); + stat_dir =tracefs_create_dir ("trace_stat" , d_tracing);if (!stat_dir) -pr_warning ("Could not create debugfs " +pr_warning ("Could not create tracefs " "'trace_stat' entry\n" );return 0 ; }
@@ -291,7 +291,7 @@ static int init_stat_file(struct stat_session *session)if (!stat_dir &&tracing_stat_init ())return -ENODEV ; - session->file =debugfs_create_file (session->ts->name,0644 , + session->file =tracefs_create_file (session->ts->name,0644 , stat_dir, session, &tracing_stat_fops);if (!session->file)
scripts/tags.sh +1 -1
@@ -228,7 +228,7 @@ exuberant() emacs() { - all_target_sources | xargs $1 -a \ + all_target_sources | xargs $1 -a --no-members \ --regex='/^\(ENTRY\|_GLOBAL\)(\([^)]*\)).*/\2/' \ --regex='/^SYSCALL_DEFINE[0-9]?(\([^,)]*\).*/sys_\1/' \ --regex='/^COMPAT_SYSCALL_DEFINE[0-9]?(\([^,)]*\).*/compat_sys_\1/' \
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRe: [RFC][PATCH 2/5] tracing: Convert the tracing facility over to use tracefs
Quoted 10 lines · On Wed, 21 Jan 2015 12:19:55 -0500 Steven Rostedt <[email protected]> wrote:
scripts/tags.sh | 2 +- 9 files changed, 81 insertions(+), 69 deletions(-)scripts/tags.sh +0
-0
scripts/tags.sh exuberant() · line 234
Quoted 8 lines
scripts/tags.sh +1
-1@@ -228,7 +228,7 @@ exuberant() emacs() { - all_target_sources | xargs $1 -a \ + all_target_sources | xargs $1 -a --no-members \ --regex='/^\(ENTRY\|_GLOBAL\)(\([^)]*\)).*/\2/' \ --regex='/^SYSCALL_DEFINE[0-9]?(\([^,)]*\).*/sys_\1/' \ --regex='/^COMPAT_SYSCALL_DEFINE[0-9]?(\([^,)]*\).*/compat_sys_\1/' \
Oops! I applied my "fix make tags" patch to do a new "make TAGS" and forgot to remove it when doing the "git commit -a -s".
Will remove this from the series.
-- Steve
Steven Rostedt
maintainerRFC PATCH 3/5 tracing: Automatically mount tracefs on debugfs/tracing
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
As tools currently rely on the tracing directory in debugfs, we can not just created a tracefs infrastructure and expect sysadmins to mount the new tracefs to have their old tools work.
Instead, the debugfs tracing directory is still created and the tracefs file system is mounted there when the debugfs filesystem is mounted.
No longer does the tracing infrastructure update the debugfs file system, but instead interacts with the tracefs file system. But now, it still appears to the user like nothing changed, except you also have the feature of mounting just the tracing system without needing all of debugfs!
Note, because debugfs_create_dir() happens to end up setting the dentry->d_op, we can not use d_set_d_op() but must manually assign the new op, that has automount set, to the dentry returned. This can be racy, but since this happens during the initcall sequence on boot up, there should be nothing that races with it.
--- kernel/trace/trace.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-)
kernel/trace/trace.c +50 -1
@@ -32,6 +32,7 @@#include <linux/splice.h> #include <linux/kdebug.h> #include <linux/string.h> +#include <linux/mount.h> #include <linux/rwsem.h> #include <linux/slab.h> #include <linux/ctype.h>
@@ -5815,10 +5816,35 @@ static __init int register_snapshot_cmd(void)static inline __init int register_snapshot_cmd (void ) {return 0 ; }#endif /* defined(CONFIG_TRACER_SNAPSHOT) && defined(CONFIG_DYNAMIC_FTRACE) */ +static struct vfsmount *trace_automount (struct path *path) +{ +struct vfsmount *mnt; +struct file_system_type *type; + +/* +* To maintain backward compatibility for tools that mount +* debugfs to get to the tracing facility, tracefs is automatically +* mounted to the debugfs/tracing directory. +*/ + type =get_fs_type ("tracefs" ); +if (!type) +return NULL ; + mnt =vfs_kern_mount (type,0 ,"tracefs" ,NULL ); +put_filesystem (type); +if (IS_ERR (mnt)) +return NULL ; +mntget (mnt); + +return mnt; +} +#define TRACE_TOP_DIR_ENTRY ((struct dentry *)1)struct dentry *tracing_init_dentry_tr (struct trace_array *tr) { +static struct dentry_operations trace_ops; +struct dentry *traced; +/* Top entry does not have a descriptor */ if (tr->dir ==TRACE_TOP_DIR_ENTRY )return NULL ;
@@ -5831,7 +5857,30 @@ struct dentry *tracing_init_dentry_tr(struct trace_array *tr)return ERR_PTR (-ENODEV );if (tr->flags &TRACE_ARRAY_FL_GLOBAL ) { - tr->dir =debugfs_create_dir ("tracing" ,NULL ); + traced =debugfs_create_dir ("tracing" ,NULL ); +if (!traced) +return ERR_PTR (-ENOMEM ); +/* copy the dentry ops and add an automount to it */ +if (traced->d_op) { +/* +* FIXME: +* Currently debugfs sets the d_op by a side-effect +* of calling simple_lookup(). Normally, we should +* never change d_op of a dentry, but as this is +* happening at boot up and shouldn't be racing with +* any other users, this should be OK. But it is still +* a hack, and needs to be properly done. +*/ + trace_ops = *traced->d_op; + trace_ops.d_automount = trace_automount; + traced->d_flags |=DCACHE_NEED_AUTOMOUNT ; + traced->d_op = &trace_ops; + }else { +/* Ideally, this is what should happen */ + trace_ops = simple_dentry_operations; + trace_ops.d_automount = trace_automount; +d_set_d_op (traced, &trace_ops); + } tr->dir =TRACE_TOP_DIR_ENTRY ;return NULL ; }
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH 4/5 tracing: Have mkdir and rmdir be part of tracefs
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The tracing "instances" directory can create sub tracing buffers with mkdir, and remove them with rmdir. As a mkdir will also create all the files and directories that control the sub buffer the locks needed to be released before doing so to avoid deadlock. This method was not very robust, and could potentially have a race somewhere due to the lock releasing within the removing of the directory. But this was needed because debugfs did not provide a mkdir or rmdir method from syscalls.
Now that tracing has been converted over to tracefs, the tracefs file system can be modified to accommodate this feature. Instead of needing to release the locks, keep them locked but add a way to flag that they are locked and do not need to be locked again.
A struct trace_dir_ops is created that holds the methods to be called for both mkdir and rmdir, as well as a pointer to let the tracefs subsystem know that the current inode's lock is already held by the calling process.
The pointer holds the current owner of the lock, and this is checked when creating new files or removing old ones, and if the pointer matches current, then the lock is not taken to avoid the deadlock.
--- fs/tracefs/inode.c | 103 +++++++++++++++++++++++++++++++++++++++++++++------ kernel/trace/trace.c | 68 ++-------------------------------- 2 files changed, 96 insertions(+), 75 deletions(-)
fs/tracefs/inode.c +92 -11
@@ -42,13 +42,62 @@ static ssize_t default_write_file(struct file *file, const char __user *buf,return count; } -const struct file_operations tracefs_file_operations = { +static const struct file_operations tracefs_file_operations = { .read = default_read_file, .write = default_write_file, .open = simple_open, .llseek = noop_llseek, }; +static int tracefs_syscall_mkdir (struct inode *inode,struct dentry *dentry,umode_t mode) +{ +struct tracefs_dir_ops *ops = inode ? inode->i_private :NULL ; +int ret; + +if (!ops) +return -EPERM ; + +/* +* The mkdir call can call the generic functions that create +* the files within the tracefs system. Do not relock the parent, +* it was locked by the caller of this function. +*/ + ops->lock_owner = current; + ret = ops->mkdir (dentry->d_iname); + ops->lock_owner =NULL ; + +return ret; +} + +static int tracefs_syscall_rmdir (struct inode *inode,struct dentry *dentry) +{ +struct tracefs_dir_ops *ops = inode->i_private; +int ret; + +if (!ops) +return -EPERM ; + +/* +* The rmdir call can call the generic functions that remove +* the files within the tracefs system. Do not relock the parent, +* it was locked by the caller of this function. +*/ + ops->lock_owner = current; +/* The caller also locked the dentry, do not lock that again either */ + dentry->d_inode->i_private = ops; + ret = ops->rmdir (dentry->d_iname); + dentry->d_inode->i_private =NULL ; + ops->lock_owner =NULL ; + +return ret; +} + +const struct inode_operations tracefs_dir_inode_operations = { + .lookup = simple_lookup, + .mkdir = tracefs_syscall_mkdir, + .rmdir = tracefs_syscall_rmdir, +}; +static struct inode *tracefs_get_inode (struct super_block *sb,umode_t mode,dev_t dev,void *data,const struct file_operations *fops)
@@ -68,7 +117,7 @@ static struct inode *tracefs_get_inode(struct super_block *sb, umode_t mode, dev inode->i_private = data;break ;case S_IFDIR : - inode->i_op = &simple_dir_inode_operations; + inode->i_op = &tracefs_dir_inode_operations; inode->i_fop = &simple_dir_operations;/* directory inodes start off with i_nlink == 2
@@ -125,6 +174,16 @@ static int tracefs_create(struct inode *dir, struct dentry *dentry, umode_t modereturn res; } +void tracefs_add_dir_ops (struct dentry *dentry,struct tracefs_dir_ops *ops) +{ +struct inode *inode = dentry->d_inode; + +if (!inode) +return ; + + inode->i_private = ops; +} +struct tracefs_mount_opts {kuid_t uid;kgid_t gid;
@@ -305,7 +364,9 @@ static struct dentry *__create_file(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops) { + struct tracefs_dir_ops *ops;struct dentry *dentry =NULL ; +struct inode *parent_inode;int error;pr_debug ("tracefs: creating file '%s'\n" ,name);
@@ -323,7 +384,12 @@ static struct dentry *__create_file(const char *name, umode_t mode,if (!parent) parent = tracefs_mount->mnt_root; -mutex_lock (&parent->d_inode->i_mutex); + parent_inode = parent->d_inode; + ops = parent_inode->i_private; + +if (!ops || ops->lock_owner != current) +mutex_lock (&parent->d_inode->i_mutex); + dentry =lookup_one_len (name, parent,strlen (name));if (!IS_ERR (dentry)) {switch (mode &S_IFMT ) {
@@ -339,7 +405,8 @@ static struct dentry *__create_file(const char *name, umode_t mode,dput (dentry); }else error =PTR_ERR (dentry); -mutex_unlock (&parent->d_inode->i_mutex); +if (!ops || ops->lock_owner != current) +mutex_unlock (&parent->d_inode->i_mutex);if (error) { dentry =NULL ;
@@ -452,7 +519,9 @@ static int __tracefs_remove(struct dentry *dentry, struct dentry *parent)*/ void tracefs_remove (struct dentry *dentry) { +struct tracefs_dir_ops *ops;struct dentry *parent; +struct inode *inode;int ret;if (IS_ERR_OR_NULL (dentry))
@@ -462,9 +531,13 @@ void tracefs_remove(struct dentry *dentry)if (!parent || !parent->d_inode)return ; -mutex_lock (&parent->d_inode->i_mutex); + inode = parent->d_inode; + ops = inode->i_private; +if (!ops || ops->lock_owner != current) +mutex_lock (&parent->d_inode->i_mutex); ret =__tracefs_remove (dentry, parent); -mutex_unlock (&parent->d_inode->i_mutex); +if (!ops || ops->lock_owner != current) +mutex_unlock (&parent->d_inode->i_mutex);if (!ret)simple_release_fs (&tracefs_mount, &tracefs_mount_count); }
@@ -479,6 +552,7 @@ void tracefs_remove(struct dentry *dentry)*/ void tracefs_remove_recursive (struct dentry *dentry) { +struct tracefs_dir_ops *ops;struct dentry *child, *parent;if (IS_ERR_OR_NULL (dentry))
@@ -490,7 +564,9 @@ void tracefs_remove_recursive(struct dentry *dentry) parent = dentry; down: -mutex_lock (&parent->d_inode->i_mutex); + ops = parent->d_inode->i_private; +if (!ops || ops->lock_owner != current) +mutex_lock (&parent->d_inode->i_mutex); loop:/* * The parent->d_subdirs is protected by the d_lock. Outside that
@@ -505,7 +581,8 @@ void tracefs_remove_recursive(struct dentry *dentry)/* perhaps simple_empty(child) makes more sense */ if (!list_empty (&child->d_subdirs)) {spin_unlock (&parent->d_lock); -mutex_unlock (&parent->d_inode->i_mutex); +if (!ops || ops->lock_owner != current) +mutex_unlock (&parent->d_inode->i_mutex); parent = child; goto down; }
@@ -526,10 +603,13 @@ void tracefs_remove_recursive(struct dentry *dentry) }spin_unlock (&parent->d_lock); -mutex_unlock (&parent->d_inode->i_mutex); +if (!ops || ops->lock_owner != current) +mutex_unlock (&parent->d_inode->i_mutex); child = parent; parent = parent->d_parent; -mutex_lock (&parent->d_inode->i_mutex); + ops = parent->d_inode->i_private; +if (!ops || ops->lock_owner != current) +mutex_lock (&parent->d_inode->i_mutex);if (child != dentry)/* go up */
@@ -537,7 +617,8 @@ void tracefs_remove_recursive(struct dentry *dentry)if (!__tracefs_remove (child, parent))simple_release_fs (&tracefs_mount, &tracefs_mount_count); -mutex_unlock (&parent->d_inode->i_mutex); +if (!ops || ops->lock_owner != current) +mutex_unlock (&parent->d_inode->i_mutex); }/**
kernel/trace/trace.c +4 -64
92 lines not on this page · raw message
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRe: [RFC][PATCH 4/5] tracing: Have mkdir and rmdir be part of tracefs
The update to the missing tracefs.h.
-- Steve
--- include/linux/tracefs.h | 8 ++++
include/linux/tracefs.h +8 -0
@@ -34,6 +34,14 @@ struct dentry *tracefs_create_dir(const char *name, struct dentry *parent);void tracefs_remove (struct dentry *dentry);void tracefs_remove_recursive (struct dentry *dentry); +struct tracefs_dir_ops { +int (*mkdir)(const char *name); +int (*rmdir)(const char *name); +struct task_struct *lock_owner; +}; + +void tracefs_add_dir_ops (struct dentry *dentry,struct tracefs_dir_ops *ops); +bool tracefs_initialized (void );#endif /* CONFIG_TRACING */
Steven Rostedt
maintainerRe: [RFC][PATCH 4/5] tracing: Have mkdir and rmdir be part of tracefs
In reply to Steven RostedtQuoted 16 lines · On Wed, 21 Jan 2015 12:19:57 -0500 Steven Rostedt <[email protected]> wrote:
From: "Steven Rostedt (Red Hat)" <[email protected]>
The tracing "instances" directory can create sub tracing buffers with mkdir, and remove them with rmdir. As a mkdir will also create all the files and directories that control the sub buffer the locks needed to be released before doing so to avoid deadlock. This method was not very robust, and could potentially have a race somewhere due to the lock releasing within the removing of the directory. But this was needed because debugfs did not provide a mkdir or rmdir method from syscalls.
Now that tracing has been converted over to tracefs, the tracefs file system can be modified to accommodate this feature. Instead of needing to release the locks, keep them locked but add a way to flag that they are locked and do not need to be locked again.
Quoted 7 lines
A struct
trace_dir_opsis created that holds the methods to be called for both mkdir and rmdir, as well as a pointer to let the tracefs subsystem know that the current inode's lock is already held by the calling process.The pointer holds the current owner of the lock, and this is checked when creating new files or removing old ones, and if the pointer matches current, then the lock is not taken to avoid the deadlock.
Grumble, my tests triggered this bug with lockdep on:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&sb->s_type->i_mutex_key#6);
lock(trace_types_lock);
lock(&sb->s_type->i_mutex_key#6); lock(trace_types_lock);
*** DEADLOCK ***
I need to take that trace_types_lock here, but it's true that that lock is held when these mutexes are taken. I'll have to spend a bit more time figuring out how to solve this :-/
-- Steve
Steven Rostedt
maintainerRFC PATCH 5/5 tracefs: Add directory /sys/kernel/tracing
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
When tracefs is configured, have the directory /sys/kernel/tracing appear just like /sys/kernel/debug appears when debugfs is configured.
This will give a consistent place for system admins to mount tracefs.
--- fs/tracefs/inode.c | 7 +++++++ 1 file changed, 7 insertions(+)
fs/tracefs/inode.c +7 -0
@@ -16,6 +16,7 @@#include <linux/module.h> #include <linux/fs.h> #include <linux/mount.h> +#include <linux/kobject.h> #include <linux/namei.h> #include <linux/tracefs.h> #include <linux/fsnotify.h>
@@ -629,10 +630,16 @@ bool tracefs_initialized(void)return tracefs_registered; } +static struct kobject *trace_kobj; +static int __init tracefs_init (void ) {int retval; + trace_kobj =kobject_create_and_add ("tracing" , kernel_kobj); +if (!trace_kobj) +return -EINVAL ; + retval =register_filesystem (&trace_fs_type);if (!retval) tracefs_registered = true;
Signature · 1 line
2.1.4
Steven Rostedt
maintainerQuoted 15 lines · On Wed, 21 Jan 2015 12:19:53 -0500 Steven Rostedt <[email protected]> wrote:
----
fs/Makefile | 1 + fs/tracefs/Makefile | 4 + fs/tracefs/inode.c | 649 +++++++++++++++++++++++++++++++++++ include/uapi/linux/magic.h | 2 + kernel/trace/ftrace.c | 22 +- kernel/trace/trace.c | 178 +++++----- kernel/trace/trace.h | 2 +- kernel/trace/trace_events.c | 32 +- kernel/trace/trace_functions_graph.c | 7 +- kernel/trace/trace_kprobe.c | 10 +- kernel/trace/trace_probe.h | 2 +- kernel/trace/trace_stat.c | 10 +-
Quoted 1 line
scripts/tags.sh | 2 +-
Ignore this file. It was added by mistake (will remove in next version).
-- Steve
Quoted 1 line
13 files changed, 789 insertions(+), 132 deletions(-)
Quoted 10 lines · Steven Rostedt
There has been complaints that tracing is tied too much to debugfs, as there are systems that would like to perform tracing, but do not mount debugfs for security reasons. That is because any subsystem may use debugfs for debugging, and these interfaces are not always tested for security.
Creating a new tracefs that the tracing directory will now be attached to allows system admins the ability to access the tracing directory without the need to mount debugfs.
Yeah!
Any chance you can use kernfs as your "basis" for this filesystem instead of having to roll all of your own functions? I'm slowly working on moving debugfs to it, and it should save a lot of code there, as well as fixing some "problems" we have in debugfs file lifetimes when things are removed from the system.
And given the number of mistakes in this submission, I'll wait for a v2 before really reading the code :)
thanks,
greg k-h
Steven Rostedt
maintainerQuoted 5 lines · On Thu, 22 Jan 2015 07:00:07 +0800 Greg Kroah-Hartman…
Any chance you can use kernfs as your "basis" for this filesystem instead of having to roll all of your own functions? I'm slowly working on moving debugfs to it, and it should save a lot of code there, as well as fixing some "problems" we have in debugfs file lifetimes when things are removed from the system.
Someone else told me about doing this too. I'll take a look at it.
Quoted 3 lines
And given the number of mistakes in this submission, I'll wait for a v2 before really reading the code :)
Well, if I switch to using kernfs, I expect we should ignore this version as well, as I would think it would make this series obsolete.
Also, if that's the case, I guess I could keep all the "tracefs" code in kernel/tracing and not place it in the fs/ directory? Kind of like what cgroups does.
-- Steve
Steven Rostedt
maintainerQuoted 3 lines · On Wed, 21 Jan 2015 20:47:25 -0500 Steven Rostedt <[email protected]> wrote:
Well, if I switch to using kernfs, I expect we should ignore this version as well, as I would think it would make this series obsolete.
Is there any documentation on kernfs? I can't find anything that makes it any easier than what I already have.
-- Steve
Quoted 8 lines · Steven Rostedt
Quoted 3 lines · On Wed, 21 Jan 2015 20:47:25 -0500 Steven Rostedt <[email protected]> wrote:
Well, if I switch to using kernfs, I expect we should ignore this version as well, as I would think it would make this series obsolete.
Is there any documentation on kernfs? I can't find anything that makes it any easier than what I already have.
Tejun would know best, he wrote it :)
What specifically are you looking for? I think there's at least two filesystems using it already, are they not good enough examples?
thanks,
greg k-h
Steven Rostedt
maintainerQuoted 1 line · On Thu, 22 Jan 2015 11:18:19 +0800 Greg Kroah-Hartman…
Tejun would know best, he wrote it :)
Oh good, as Bugs Bunny would say "where's the doc?" (or was that "what's up doc"?)
Quoted 4 lines
What specifically are you looking for? I think there's at least two filesystems using it already, are they not good enough examples?
Well, I see the two biggest users are sysfs and cgroups, where I never understood how sysfs actually works, and cgroups, the filesystem is very integrated with the usage of cgroups.
There doesn't seem to be any abi where one can relate to the vfs system.
I'd like to keep the interface like debugfs had for tracefs, because all of tracing depends on it, and it would require a full rewrite to convert it to something that doesn't have the vfs type of paradigm, in which case, tracefs would not be done for another decade.
That is, I need to create the following interface:
tracefs_create_file()
tracefs_create_dir()
tracefs_remove()
tracefs_remove_recursive()
and that's all I need for the filesystem. There doesn't seem to be any documentation on kernfs about how to implement this.
Yes, I can study the code, but I was hoping that there was some kernfs.txt that described how to create a new fs with it. It just saves time if there was a document than having to read the code and perhaps use it in a way it wasn't supposed to be used.
-- Steve
Hey, Steven.
Quoted 4 lines · Steven Rostedt
Quoted 1 line
Tejun would know best, he wrote it :)
Oh good, as Bugs Bunny would say "where's the doc?" (or was that "what's up doc"?)
I didn't write any while extracting it out of sysfs. Sorry about that. I should get to it.
Quoted 6 lines
Quoted 2 lines
What specifically are you looking for? I think there's at least two filesystems using it already, are they not good enough examples?
Well, I see the two biggest users are sysfs and cgroups, where I never understood how sysfs actually works, and cgroups, the filesystem is very integrated with the usage of cgroups.
Yes, cgroup's usage is rather complicated. I wouldn't suggest it as a good example. sysfs's usage is a bit complicated too in part because of the namespace support.
Quoted 11 lines
There doesn't seem to be any abi where one can relate to the vfs system.
I'd like to keep the interface like debugfs had for tracefs, because all of tracing depends on it, and it would require a full rewrite to convert it to something that doesn't have the vfs type of paradigm, in which case, tracefs would not be done for another decade.
That is, I need to create the following interface:
tracefs_create_file()
kernfs_create_file()
Quoted 1 line
tracefs_create_dir()
kernfs_create_dir()
Quoted 2 lines
tracefs_remove()
tracefs_remove_recursive()
kernfs_remove[_by_name]() - recursive by default
Quoted 7 lines
and that's all I need for the filesystem. There doesn't seem to be any documentation on kernfs about how to implement this.
Yes, I can study the code, but I was hoping that there was some kernfs.txt that described how to create a new fs with it. It just saves time if there was a document than having to read the code and perhaps use it in a way it wasn't supposed to be used.
Yeah yeah, I hear you. I'll write one up.
Thanks.
Signature · 1 line
tejun
Quoted 6 lines · Tejun Heo
Quoted 4 lines
Yes, I can study the code, but I was hoping that there was some kernfs.txt that described how to create a new fs with it. It just saves time if there was a document than having to read the code and perhaps use it in a way it wasn't supposed to be used.
Yeah yeah, I hear you. I'll write one up.
But all the public APIs are well documented with docbook comments, so for the time being, I'd recommend those as the starting point.
Thanks.
Signature · 1 line
tejun
Steven Rostedt
maintainerQuoted 9 lines · On Thu, 22 Jan 2015 07:32:12 -0500 Tejun Heo <[email protected]> wrote:
Quoted 3 lines
That is, I need to create the following interface:
tracefs_create_file()
kernfs_create_file()Quoted 1 line
tracefs_create_dir()
kernfs_create_dir()
The problem is that these do not return dentry. They return kernfs_node.
I see a kernfs_node_from_dentry() call but not the other way around.
Yes, the interface for tracefs is just these four functions, but then the interaction of the kernfs versions use a completely different API.
Each of the created files expects to attach their own open, read, write, and release functions. And yes, some even use the seq functions, and they use it the vfs way. I do not intend on rewriting the users of the debugfs file system. To use kernfs, it seems that I would need to do that, and I don't have the time to make such a dramatic change to the system. It will fall down on my TODO list and I probably wont get to it for another decade.
I created tracefs with 700 lines of code and two files (inode.c and tracefs.h), and for the users of tracefs, I just did s/debugfs/tracefs/. If I can't make that substitution for the users, that is a show stopper.
I don't see how I can use kernfs without it causing a lot of invasive changes to the ftrace subsystem.
-- Steve
Quoted 18 lines
Quoted 3 lines
tracefs_remove()
tracefs_remove_recursive()kernfs_remove[_by_name]() - recursive by default
Quoted 7 lines
and that's all I need for the filesystem. There doesn't seem to be any documentation on kernfs about how to implement this.
Yes, I can study the code, but I was hoping that there was some kernfs.txt that described how to create a new fs with it. It just saves time if there was a document than having to read the code and perhaps use it in a way it wasn't supposed to be used.
Yeah yeah, I hear you. I'll write one up.
Thanks.
Hey, Steven.
Quoted 1 line · Steven Rostedt
The problem is that these do not return dentry. They return
kernfs_node.
Yeap, that's what represents a file or directory in kernfs.
Quoted 1 line
I see a
kernfs_node_from_dentry()call but not the other way around.
Because dentries / inodes may or may not exist for a given kernfs node. kernfs_nodes are the backing information in a similar way to an actual filesystem.
Quoted 10 lines
Yes, the interface for tracefs is just these four functions, but then the interaction of the kernfs versions use a completely different API.
Each of the created files expects to attach their own open, read, write, and release functions. And yes, some even use the seq functions, and they use it the vfs way. I do not intend on rewriting the users of the debugfs file system. To use kernfs, it seems that I would need to do that, and I don't have the time to make such a dramatic change to the system. It will fall down on my TODO list and I probably wont get to it for another decade.
kernfs provides two sets of file operations. One is seq_file based and the other is direct read/write. In both cases, bouncing data between userland and kernel is handled by kernfs. If you already have existing read write ops implemented doing custom buffer handling and direct userland memory access, it'll take some adaptation but for a lot of cases this would consolidate duplicate code paths.
Quoted 7 lines
I created tracefs with 700 lines of code and two files (
inode.candtracefs.h), and for the users of tracefs, I just did s/debugfs/tracefs/. If I can't make that substitution for the users, that is a show stopper.I don't see how I can use kernfs without it causing a lot of invasive changes to the ftrace subsystem.
Converting an existing vfs based pseudo fs implementation over to kernfs isn't trivial. I mean, if that were trivial, why would kernfs even exist? kernfs is a layer which abstracts a large part of pseudo filesystem which provides extra features like significantly lower memory footprint with large number of nodes and revocation support in a way that its users, for the most part, hopefully, only have to worry about the content to provide to userland.
I frankly have no idea whether tracefs would be a good candidate for kernfs usage but if you're looking for a mechanical one-to-one conversion from vfs based implementation, that's not gonna work.
Thanks.
Signature · 1 line
tejun
Steven Rostedt
maintainerQuoted 6 lines · On Thu, 22 Jan 2015 09:55:47 -0500 Tejun Heo <[email protected]> wrote:
kernfs provides two sets of file operations. One is
seq_filebased and the other is direct read/write. In both cases, bouncing data between userland and kernel is handled by kernfs. If you already have existing read write ops implemented doing custom buffer handling and direct userland memory access, it'll take some adaptation but for a lot of cases this would consolidate duplicate code paths.
Does it also handle splice? That's a key part of the tracing code.
Almost every tracing file is somewhat unique. When things can be shared, they are, but there's not much generic code that can be shared.
Quoted 9 lines
Quoted 8 lines
I created tracefs with 700 lines of code and two files (
inode.candtracefs.h), and for the users of tracefs, I just did s/debugfs/tracefs/. If I can't make that substitution for the users, that is a show stopper.I don't see how I can use kernfs without it causing a lot of invasive changes to the ftrace subsystem.
Quoted 7 lines
Converting an existing vfs based pseudo fs implementation over to kernfs isn't trivial. I mean, if that were trivial, why would kernfs even exist? kernfs is a layer which abstracts a large part of pseudo filesystem which provides extra features like significantly lower memory footprint with large number of nodes and revocation support in a way that its users, for the most part, hopefully, only have to worry about the content to provide to userland.
Sounds like some of the tracing files could benefit from this. But I'm not sure kernfs has all the necessary features I need.
Quoted 4 lines
I frankly have no idea whether tracefs would be a good candidate for kernfs usage but if you're looking for a mechanical one-to-one conversion from vfs based implementation, that's not gonna work.
OK, thanks. Perhaps if tracing was still new I could have tried to go with kernfs. But as debugfs was such a simple to use interface, it let me concentrate more on the complexities of tracing itself instead of spending time coming up with a complex interface.
If a one to one conversion to vfs is not gonna work, I'm going to be interested in seeing how debugfs will be converted.
Anyway, I think I'm convinced that kernfs is not yet the way to go. I'm going to continue on with my current path.
Thanks,
-- Steve
Quoted 8 lines · Steven Rostedt
Quoted 6 lines
kernfs provides two sets of file operations. One is
seq_filebased and the other is direct read/write. In both cases, bouncing data between userland and kernel is handled by kernfs. If you already have existing read write ops implemented doing custom buffer handling and direct userland memory access, it'll take some adaptation but for a lot of cases this would consolidate duplicate code paths.Does it also handle splice? That's a key part of the tracing code.
It doesn't yet. We can add it as a part of kernfs_syscall_ops tho which exists to support these specialized bypass operations. kernfs doesn't do much with these. It just passes over the calls to the registered callbacks.
Thanks.
Signature · 1 line
tejun
Al Viro
maintainerQuoted 12 lines · Greg Kroah-Hartman
Quoted 10 lines · Steven Rostedt
There has been complaints that tracing is tied too much to debugfs, as there are systems that would like to perform tracing, but do not mount debugfs for security reasons. That is because any subsystem may use debugfs for debugging, and these interfaces are not always tested for security.
Creating a new tracefs that the tracing directory will now be attached to allows system admins the ability to access the tracing directory without the need to mount debugfs.
Quoted 7 lines
Yeah!
Any chance you can use kernfs as your "basis" for this filesystem instead of having to roll all of your own functions? I'm slowly working on moving debugfs to it, and it should save a lot of code there, as well as fixing some "problems" we have in debugfs file lifetimes when things are removed from the system.
I would recommend against that - kernfs is overburdened by their need to accomodate cgroup weirdness. IMO it's not a good model for anything, other than an anti-hard-drugs poster ("don't shoot that shit, or you might end up hallucinating _this_").
Steven Rostedt
maintainerQuoted 4 lines · On Thu, 22 Jan 2015 04:23:30 +0000 Al Viro <[email protected]> wrote:
I would recommend against that - kernfs is overburdened by their need to accomodate cgroup weirdness. IMO it's not a good model for anything, other than an anti-hard-drugs poster ("don't shoot that shit, or you might end up hallucinating _this_").
OK, I'm not the only one that thought kernfs seemed to go all over the place. I guess I now know why. It was more of a hook for cgroups. I can understand why cgroups needed it, as I found that creating files from a mkdir and removing them with rmdir causes some pain in vfs with handling of locking. As that's what I'm working on overcoming now.
But I think I solved my issues (testing it now), and hopefully by tomorrow, I'll have a V2 out.
-- Steve
Quoted 10 lines · Steven Rostedt
Quoted 4 lines · On Thu, 22 Jan 2015 04:23:30 +0000 Al Viro <[email protected]> wrote:
I would recommend against that - kernfs is overburdened by their need to accomodate cgroup weirdness. IMO it's not a good model for anything, other than an anti-hard-drugs poster ("don't shoot that shit, or you might end up hallucinating _this_").
OK, I'm not the only one that thought kernfs seemed to go all over the place. I guess I now know why. It was more of a hook for cgroups. I can
Again, not true at all.
Quoted 6 lines
understand why cgroups needed it, as I found that creating files from a mkdir and removing them with rmdir causes some pain in vfs with handling of locking. As that's what I'm working on overcoming now.
But I think I solved my issues (testing it now), and hopefully by tomorrow, I'll have a V2 out.
I'd strongly recomment just using kernfs. If you find something wrong with it, let's fix it, please.
Thanks.
Signature · 1 line
tejun
Hello, Al.
Quoted 2 lines · Al Viro
I would recommend against that - kernfs is overburdened by their need to accomodate cgroup weirdness. IMO it's not a good model for anything, other
That's not true. The two big items where sysfs is complicated are the custom revocation implementation and namespace support, both of which come from its sysfs lineage. The revocation implementation had an update to better support cgroup but the new interface is more generic than before and necessary if it wants to support self-removing files along with the said revocation support.
One complexity actually added for cgroup is in the mount path because cgroup needs to be able to create or match superblocks dynamically during mount time and that doesn't really jive well with how superblocks are managed in the vfs layer. This part is ugly and intentially left that way. This really should be cgroup specific (and we can't shed it at the moment) and shouldn't be used elsewhere. IIRC, you had some complaints about this and I wonder whether that's what shaped your opinion, but this is entirely isolated. Just use kernfs_mount() and ignore the @new_fs_created param.
Overall, kernfs is basically the actual filesystem part of sysfs. None of the fundamentals changed while separating out kernfs out of sysfs. You may not like kernfs but then wouldn't improving it a far better strategy over long haul? I really don't think we need yet another pseudo vfs based filesystem in kernel and unless tracingfs is doing something crazy kernfs should be able to serve as a common foundation.
Thanks.
Signature · 1 line
tejun