tracing: Add new file system tracefs
Steven Rostedt
maintainerPATCH v2 4/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>
@@ -547,10 +548,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
maintainerv2 cover 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.
Changes from v1:
o Fixed all the posting problems (included files that were missing and removed changes that were not suppose to be there).
o Changed the mkdir/rmdir logic. Instead of trying to keep the inode mutexes locked, which caused locking issues with other locks that were taken, the locks are still released. But this time, they are released by the tracefs system which has a bit more control. As the mkdir/rmdir methods for the tracing facility only need the new name of the instance, the tracefs mkdir/rmdir copies the name from the dentry, releases the locks, and passes in the copy to the tracing methods.
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
tracefs: Add directory /sys/kernel/tracing
tracing: Have mkdir and rmdir be part of tracefs
----
fs/Makefile | 1 + fs/tracefs/Makefile | 4 + fs/tracefs/inode.c | 658 +++++++++++++++++++++++++++++++++++ include/linux/tracefs.h | 48 +++ include/uapi/linux/magic.h | 2 + kernel/trace/ftrace.c | 22 +- kernel/trace/trace.c | 176 +++++----- 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 +- 13 files changed, 844 insertions(+), 130 deletions(-)
Steven Rostedt
maintainerPATCH v2 2/5 tracing: Convert the tracing facility over to use tracefs
From: "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 | 61 ++++++++++++++++++++++-------------- 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 +++--- 8 files changed, 79 insertions(+), 67 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 +37 -24
188 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)
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH v2 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
maintainerPATCH v2 5/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 inode mutexes need to be released before this is done, to avoid deadlocks. It is better to let the tracing system unlock the inode mutexes before calling the functions that create the files within the new directory (or deletes the files from the one being destroyed).
Now that tracing has been converted over to tracefs, the tracefs file system can be modified to accommodate this feature. It still releases the locks, but the filesystem itself can take care of the ugly business and let the user just do what it needs.
The tracing system now attaches a descriptor to the directory dentry that can have userspace create or remove sub directories. If this descriptor does not exist for a dentry, then that dentry can not be used to create other directories. This descriptor holds a mkdir and rmdir method that only takes a character string as an argument.
The tracefs file system will first make a copy of the dentry name before releasing the locks. Then it will pass the copied name to the methods. It is up to the tracing system that supplied the methods to handle races with duplicate names and such as all the inode mutexes would be released when the functions are called.
--- fs/tracefs/inode.c | 93 ++++++++++++++++++++++++++++++++++++++++++++++++- include/linux/tracefs.h | 7 ++++ kernel/trace/trace.c | 68 +++--------------------------------- 3 files changed, 103 insertions(+), 65 deletions(-)
fs/tracefs/inode.c +92 -1
@@ -50,6 +50,87 @@ static const struct file_operations tracefs_file_operations = { .llseek = noop_llseek, }; +static char *get_dname (struct dentry *dentry) +{ +const char *dname; +char *name; +int len = dentry->d_name.len; + + dname = dentry->d_name.name; + name =kmalloc (len +1 ,GFP_KERNEL ); +if (!name) +return NULL ; +memcpy (name, dname, len); + name[len] =0 ; +return name; +} + +static int tracefs_syscall_mkdir (struct inode *inode,struct dentry *dentry,umode_t mode) +{ +const struct tracefs_dir_ops *ops = inode ? inode->i_private :NULL ; +char *name; +int ret; + +if (!ops) +return -EPERM ; + + name =get_dname (dentry); +if (!name) +return -ENOMEM ; + +/* +* The mkdir call can call the generic functions that create +* the files within the tracefs system. It is up to the individual +* mkdir routine to handle races. +*/ +mutex_unlock (&inode->i_mutex); + ret = ops->mkdir (name); +mutex_lock (&inode->i_mutex); + +kfree (name); + +return ret; +} + +static int tracefs_syscall_rmdir (struct inode *inode,struct dentry *dentry) +{ +const struct tracefs_dir_ops *ops = inode->i_private; +char *name; +int ret; + +if (!ops) +return -EPERM ; + + name =get_dname (dentry); +if (!name) +return -ENOMEM ; + +/* +* The rmdir call can call the generic functions that create +* the files within the tracefs system. It is up to the individual +* rmdir routine to handle races. +* This time we need to unlock not only the parent (inode) but +* also the directory that is being deleted. +*/ +mutex_unlock (&inode->i_mutex); +mutex_unlock (&dentry->d_inode->i_mutex); + + ret = ops->rmdir (name); + +mutex_lock_nested (&inode->i_mutex,I_MUTEX_PARENT ); +mutex_lock (&dentry->d_inode->i_mutex); + +kfree (name); + +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)
@@ -69,7 +150,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 +206,16 @@ static int tracefs_create(struct inode *dir, struct dentry *dentry, umode_t modereturn res; } +void tracefs_add_dir_ops (struct dentry *dentry,const struct tracefs_dir_ops *ops) +{ +struct inode *inode = dentry->d_inode; + +if (!inode) +return ; + + inode->i_private = (void *)ops; +} +struct tracefs_mount_opts {kuid_t uid;kgid_t gid;
include/linux/tracefs.h +7 -0
@@ -34,6 +34,13 @@ 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); +}; + +void tracefs_add_dir_ops (struct dentry *dentry,const struct tracefs_dir_ops *ops); +bool tracefs_initialized (void );#endif /* CONFIG_TRACING */
kernel/trace/trace.c +4 -64
92 lines not on this page · raw message
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH v2 1/5 tracefs: Add new tracefs file system
In reply to Steven RostedtFrom: "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 | 560 +++++++++++++++++++++++++++++++++++++++++++++ include/linux/tracefs.h | 41 ++++ include/uapi/linux/magic.h | 2 + 5 files changed, 608 insertions(+) create mode 100644 fs/tracefs/Makefile create mode 100644 fs/tracefs/inode.c create mode 100644 include/linux/tracefs.h
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 +560 -0
560 lines not on this page · raw message
include/linux/tracefs.h new file +41 -0
41 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
Re: [PATCH 3/5 v2] tracing: Automatically mount tracefs on debugfs/tracing
In reply to Steven RostedtQuoted 92 lines · Steven Rostedt
From: "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 thedentry->d_op, we can not used_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.Cc Al Viro <[email protected]>Signed-off-by Steven Rostedt <[email protected]>--- kernel/trace/trace.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-)kernel/trace/trace.c +39
-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.
kernel/trace/trace.c struct dentry *tracing_init_dentry_tr(struct trace_array *tr) · line 5882
Quoted 10 lines
kernel/trace/trace.c +10
-0+*/ + 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);
How will this else block run if debugfs is setting d_op in the debugfs_create_dir() call?
What really do you want to do here, just automount a filesystem on debugfs? If so, can't we just add a new debugfs call to do that?
thanks,
greg k-h
Re: [PATCH 4/5 v2] tracefs: Add directory /sys/kernel/tracing
In reply to Steven RostedtQuoted 44 lines · Steven Rostedt
From: "Steven Rostedt (Red Hat)" <[email protected]>
When tracefs is configured, have the directory
/sys/kernel/tracingappear just like/sys/kernel/debugappears when debugfs is configured.This will give a consistent place for system admins to mount tracefs.
Signed-off-by Steven Rostedt <[email protected]>--- 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> @@ -547,10 +548,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
maintainerRe: [PATCH 3/5 v2] tracing: Automatically mount tracefs on debugfs/tracing
In reply to Greg Kroah-HartmanQuoted 19 lines · On Sat, 24 Jan 2015 11:00:41 +0800 Greg Kroah-Hartman…
Quoted 19 lines
kernel/trace/trace.c +4
-0+if (traced->d_op) { +/* +* FIXME: +* Currently debugfs sets the d_op by a side-effect
(quoted diff) +1
-0+ * of calling simple_lookup(). Normally,we should
(quoted diff) +1
-0+ * never change d_op of a dentry, but asthis is
(quoted diff) +1
-0+ * happening at boot up and shouldn't beracing with
(quoted diff) +1
-0+ * any other users, this should be OK. Butit is still
kernel/trace/trace.c +6
-0+* 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;
Quoted 8 lines
kernel/trace/trace.c struct dentry *tracing_init_dentry_tr(struct trace_array *tr) · line 5882
Quoted 5 lines
kernel/trace/trace.c +5
-0+ }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);How will this else block run if debugfs is setting
d_opin thedebugfs_create_dir()call?
It wont; I put the else block there to show what we would like to do. And would hopefully work if debugfs ever changed.
Quoted 3 lines
What really do you want to do here, just automount a filesystem on debugfs? If so, can't we just add a new debugfs call to do that?
We could add a call to debugfs to do that. Would you prefer that? From talking with Al, it sounds to me that changing d_ops on the fly is very racy. Adding a call in debugfs sounds like it would be open for other users to do the same and do so while the system is running. Would that be wise?
Doing the automount here is guaranteed not to happen after system boot up, or when there might be users of debugfs while the ops changes.
-- Steve
-- Steve
Re: [PATCH 3/5 v2] tracing: Automatically mount tracefs on debugfs/tracing
Quoted 36 lines · Steven Rostedt
Quoted 19 lines · On Sat, 24 Jan 2015 11:00:41 +0800 Greg Kroah-Hartman…
Quoted 19 lines
kernel/trace/trace.c +4
-0+if (traced->d_op) { +/* +* FIXME: +* Currently debugfs sets the d_op by a side-effect
(quoted diff) +1
-0+ * of calling simple_lookup(). Normally,we should
(quoted diff) +1
-0+ * never change d_op of a dentry, but asthis is
(quoted diff) +1
-0+ * happening at boot up and shouldn't beracing with
(quoted diff) +1
-0+ * any other users, this should be OK. Butit is still
kernel/trace/trace.c +6
-0+* 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;Quoted 8 lines
kernel/trace/trace.c struct dentry *tracing_init_dentry_tr(struct trace_array *tr) · line 5882
Quoted 5 lines
kernel/trace/trace.c +5
-0+ }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);How will this else block run if debugfs is setting
d_opin thedebugfs_create_dir()call?It wont; I put the else block there to show what we would like to do. And would hopefully work if debugfs ever changed.
Quoted 1 line
Quoted 8 lines
Quoted 2 lines
What really do you want to do here, just automount a filesystem on debugfs? If so, can't we just add a new debugfs call to do that?
We could add a call to debugfs to do that. Would you prefer that? From talking with Al, it sounds to me that changing
d_opson the fly is very racy. Adding a call in debugfs sounds like it would be open for other users to do the same and do so while the system is running. Would that be wise?
If we could do it in a non-racy way, that would be good, otherwise I don't see us being able to even take this patch :(
thanks,
greg k-h
Steven Rostedt
maintainerRe: [PATCH 3/5 v2] tracing: Automatically mount tracefs on debugfs/tracing
Quoted 2 lines · On Sun, 25 Jan 2015 21:22:07 +0800 Greg Kroah-Hartman…
If we could do it in a non-racy way, that would be good, otherwise I don't see us being able to even take this patch :(
Is it still racy even if it's only done at boot up? This path only gets hit the first time it is called. "if (tr->flags &TRACE_ARRAY_FL_GLOBAL)" is the top level tracing directory ("tracing") and is only called during boot up (fs_initcall) and never hit again. I could even make this called directly by that code so we could label it "__init" to make sure that it is to be never hit. Or is this racy even when done by fs_initcall?
Waiting for Al to comment on this, because, I can't add this feature until debugfs/tracing still containing the tracing information, otherwise it will break all the tools that interact with the tracing infrastructure, and we all know how happy Linus feels about such changes.
-- Steve
Al Viro
maintainerRe: [PATCH 3/5 v2] tracing: Automatically mount tracefs on debugfs/tracing
Quoted 15 lines · Steven Rostedt
Quoted 2 lines · On Sun, 25 Jan 2015 21:22:07 +0800 Greg Kroah-Hartman…
If we could do it in a non-racy way, that would be good, otherwise I don't see us being able to even take this patch :(
Is it still racy even if it's only done at boot up? This path only gets hit the first time it is called. "if (
tr->flags&TRACE_ARRAY_FL_GLOBAL)" is the top level tracing directory ("tracing") and is only called during boot up (fs_initcall) and never hit again. I could even make this called directly by that code so we could label it "__init" to make sure that it is to be never hit. Or is this racy even when done byfs_initcall?
Quoted 5 lines
Waiting for Al to comment on this, because, I can't add this feature until debugfs/tracing still containing the tracing information, otherwise it will break all the tools that interact with the tracing infrastructure, and we all know how happy Linus feels about such changes.
Actually, I'm almost done massaging that sucker into adding debugfs_create_automount(). The only remaining question is what arguments do we put it; for now I'm giving it dentry_operations + data (to go into inode->i_private), but it might be better to give it a pointer just to d_automount() callback + data for it...
Al Viro
maintainerRe: [PATCH 3/5 v2] tracing: Automatically mount tracefs on debugfs/tracing
Quoted 22 lines · Al Viro
Quoted 15 lines · Steven Rostedt
Quoted 2 lines · On Sun, 25 Jan 2015 21:22:07 +0800 Greg Kroah-Hartman…
If we could do it in a non-racy way, that would be good, otherwise I don't see us being able to even take this patch :(
Is it still racy even if it's only done at boot up? This path only gets hit the first time it is called. "if (
tr->flags&TRACE_ARRAY_FL_GLOBAL)" is the top level tracing directory ("tracing") and is only called during boot up (fs_initcall) and never hit again. I could even make this called directly by that code so we could label it "__init" to make sure that it is to be never hit. Or is this racy even when done byfs_initcall?Quoted 5 lines
Waiting for Al to comment on this, because, I can't add this feature until debugfs/tracing still containing the tracing information, otherwise it will break all the tools that interact with the tracing infrastructure, and we all know how happy Linus feels about such changes.
Quoted 5 lines
Actually, I'm almost done massaging that sucker into adding
debugfs_create_automount(). The only remaining question is what arguments do we put it; for now I'm giving itdentry_operations+ data (to go intoinode->i_private), but it might be better to give it a pointer just tod_automount()callback + data for it...
Turns out that it is better that way (and less prone to abuse). See vfs.git#debugfs_automount; some massage on top of 3.19-rc5, the payoff is in the last commit.
For your code it's a matter of replacing struct path *path with void *unused in trace_automount() and just calling
debugfs_create_automount("tracing", NULL, trace_automount, NULL);to create the sucker. That's it - no games with ->d_op, etc.
Al Viro
maintainerRe: [PATCH 3/5 v2] tracing: Automatically mount tracefs on debugfs/tracing
Quoted 8 lines · Al Viro
Turns out that it is better that way (and less prone to abuse). See vfs.git#debugfs_automount; some massage on top of 3.19-rc5, the payoff is in the last commit.
For your code it's a matter of replacing struct path *path with void *unused in
trace_automount()and just callingdebugfs_create_automount("tracing", NULL, trace_automount, NULL);to create the sucker. That's it - no games with ->d_op, etc.
... and the total is plus 8 lines. Would be negative, if not for the kerneldoc comment in there...