tracing: Add new filesystem tracefs
Steven Rostedt
maintainercover tracing: Add new filesystem tracefs
Al,
I know that you do not like the releasing of the parent i_mutex lock. But it is no different than what we do today, except that we move the release out of the tracing code and into the tracefs code.
This still gives us the separate tracefs filesystem that will let users mount it without needing to mount debugfs, so I want to get this into 3.20.
These are the patches that I plan on submitting, and will soon be adding to my linux-next branch, to be included in linux-next.
-- Steve
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
ftrace/tracefs
Head SHA1: eae473581cf93dad94ca833aa961c033c6a43924
Steven Rostedt (Red Hat) (7):
tracing: Only create tracer options files if directory exists
tracing: Create cmdline tracer options on tracing fs init
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 | 650 +++++++++++++++++++++++++++++++++++ include/linux/tracefs.h | 45 +++ include/uapi/linux/magic.h | 2 + kernel/trace/ftrace.c | 22 +- kernel/trace/trace.c | 187 +++++----- 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, 832 insertions(+), 142 deletions(-)
Steven Rostedt
maintainerPATCH 1/7 tracing: Only create tracer options files if directory exists
From: "Steven Rostedt (Red Hat)" <[email protected]>
Do not bother creating tracer options if no tracing directory exists. If a tracer is enabled via the command line, and is started before the tracing directory is created, then it wont have its tracer specific options created.
--- kernel/trace/trace.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
kernel/trace/trace.c +5 -2
@@ -4172,8 +4172,11 @@ static int tracing_set_tracer(struct trace_array *tr, const char *buf) free_snapshot(tr); }#endif -/* Currently, only the top instance has options */ -if (tr->flags &TRACE_ARRAY_FL_GLOBAL ) { +/* +* Only enable if the directory has been created already. +* Currently, only the top instance has options +*/ +if (tr->dir && tr->flags &TRACE_ARRAY_FL_GLOBAL ) {destroy_trace_option_files (topts); topts =create_trace_option_files (tr, t); }
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH 2/7 tracing: Create cmdline tracer options on tracing fs init
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The options for cmdline tracers are not created if the debugfs system is not ready yet. If tracing has started before debugfs is up, then the option files for the tracer are not created. Create them when creating the tracing directory if the current tracer requires option files.
--- kernel/trace/trace.c | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-)
kernel/trace/trace.c +21 -9
@@ -4105,9 +4105,24 @@ static void tracing_set_nop(struct trace_array *tr) tr->current_trace = &nop_trace; } -static int tracing_set_tracer (struct trace_array *tr,const char *buf) +static void update_tracer_options (struct trace_array *tr,struct tracer *t) {static struct trace_option_dentry *topts; + +/* Only enable if the directory has been created already. */ +if (!tr->dir) +return ; + +/* Currently, only the top instance has options */ +if (!(tr->flags &TRACE_ARRAY_FL_GLOBAL )) +return ; + +destroy_trace_option_files (topts); + topts =create_trace_option_files (tr, t); +} + +static int tracing_set_tracer (struct trace_array *tr,const char *buf) +{struct tracer *t;#ifdef CONFIG_TRACER_MAX_TRACE bool had_max_tr;
@@ -4172,14 +4187,7 @@ static int tracing_set_tracer(struct trace_array *tr, const char *buf)free_snapshot (tr); }#endif -/* -* Only enable if the directory has been created already. -* Currently, only the top instance has options -*/ -if (tr->dir && tr->flags &TRACE_ARRAY_FL_GLOBAL ) { -destroy_trace_option_files (topts); - topts =create_trace_option_files (tr, t); - } +update_tracer_options (tr, t);#ifdef CONFIG_TRACER_MAX_TRACE if (t->use_max_tr && !had_max_tr) {
@@ -6578,6 +6586,10 @@ static __init int tracer_init_debugfs(void)create_trace_options_dir (&global_trace); +/* If the tracer was started via cmdline, create options for it here */ +if (global_trace.current_trace != &nop_trace) +update_tracer_options (&global_trace, global_trace.current_trace); +return 0 ; }
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH 3/7 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 | 522 +++++++++++++++++++++++++++++++++++++++++++++ include/linux/tracefs.h | 41 ++++ include/uapi/linux/magic.h | 2 + 5 files changed, 570 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 +522 -0
522 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: [for-next][PATCH 3/7] tracefs: Add new tracefs file system
Hi Steve,
Quoted 21 lines · Steven Rostedt
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.
Signed-off-by Steven Rostedt <[email protected]>---
[SNIP]
Quoted 17 lines
+/**
+ *tracefs_create_file- create a file in the tracefs filesystem
+ * @name: a pointer to a string containing the name of the file to create.
+ * @mode: the permission that the file should have.
+ * @parent: a pointer to the parent dentry for this file. This should be a
+ * directory dentry if set. If this parameter is NULL, then the
+ * file will be created in the root of the tracefs filesystem.
+ * @data: a pointer to something that the caller will want to get to later
+ * on. The inode.i_private pointer will point to this value on
+ * theopen()call.
+ * @fops: a pointer to a structfile_operationsthat should be used for
+ * this file.
+ *
+ * This is the basic "create a file" function for tracefs. It allows for a
+ * wide range of flexibility in creating a file, or a directory (if you want
+ * to create a directory, thetracefs_create_dir()function is
+ * recommended to be used instead.)
Quoted 8 lines
+ *
+ * This function will return a pointer to a dentry if it succeeds. This
+ * pointer must be passed to thetracefs_remove()function when the file is
+ * to be removed (no automatic cleanup happens if your module is unloaded,
+ * you are responsible here.) If an error occurs, %NULL will be returned.
+ *
+ * If tracefs is not enabled in the kernel, the value -%ENODEV will be
+ * returned.
I cannot find where it returns -ENODEV. AFAICS we cannot call tracefs functions if tracing was not enabled.
Quoted 34 lines
+ */
fs/tracefs/inode.c new file +33
-0+struct dentry *tracefs_create_file (const char *name,umode_t mode, +struct dentry *parent,void *data, +const struct file_operations *fops) +{ +struct dentry *dentry; +struct inode *inode; + +if (!(mode &S_IFMT )) + mode |=S_IFREG ; +BUG_ON (!S_ISREG (mode)); + dentry =start_creating (name, parent); + +if (IS_ERR (dentry)) +return NULL ; + + inode =tracefs_get_inode (dentry->d_sb); +if (unlikely (!inode)) +return failed_creating (dentry); + + inode->i_mode = mode; + inode->i_fop = fops ? fops : &tracefs_file_operations; + inode->i_private = data; +d_instantiate (dentry, inode); +fsnotify_create (dentry->d_parent->d_inode, dentry); +return end_creating (dentry); +} + +/** +* tracefs_create_dir - create a directory in the tracefs filesystem +* @name: a pointer to a string containing the name of the directory to +* create. +* @parent: a pointer to the parent dentry for this file. This should be a +* directory dentry if set. If this parameter is NULL, then the
fs/tracefs/inode.c line 351
Quoted 10 lines
fs/tracefs/inode.c new file +10
-0+* directory will be created in the root of the tracefs filesystem. +* +* This function creates a directory in tracefs with the given name. +* +* This function will return a pointer to a dentry if it succeeds. This +* pointer must be passed to the tracefs_remove() function when the file is +* to be removed. If an error occurs, %NULL will be returned. +* +* If tracing is not enabled in the kernel, the value -%ENODEV will be +* returned.
Ditto.
Thanks,
Namhyung
Quoted 24 lines
+ */
fs/tracefs/inode.c new file +23
-0+struct dentry *tracefs_create_dir (const char *name,struct dentry *parent) +{ +struct dentry *dentry =start_creating (name, parent); +struct inode *inode; + +if (IS_ERR (dentry)) +return NULL ; + + inode =tracefs_get_inode (dentry->d_sb); +if (unlikely (!inode)) +return failed_creating (dentry); + + inode->i_mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ; + inode->i_op = &simple_dir_inode_operations; + inode->i_fop = &simple_dir_operations; + +/* directory inodes start off with i_nlink == 2 (for "." entry) */ +inc_nlink (inode); +d_instantiate (dentry, inode); +inc_nlink (dentry->d_parent->d_inode); +fsnotify_mkdir (dentry->d_parent->d_inode, dentry); +return end_creating (dentry); +}
Steven Rostedt
maintainerRe: [for-next][PATCH 3/7] tracefs: Add new tracefs file system
Quoted 52 lines · On Mon, 9 Feb 2015 14:56:19 +0900 Namhyung Kim <[email protected]> wrote:
Hi Steve,
Quoted 21 lines · Steven Rostedt
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.
Signed-off-by Steven Rostedt <[email protected]>---
[SNIP]
Quoted 17 lines
+/**
+ *tracefs_create_file- create a file in the tracefs filesystem
+ * @name: a pointer to a string containing the name of the file to create.
+ * @mode: the permission that the file should have.
+ * @parent: a pointer to the parent dentry for this file. This should be a
+ * directory dentry if set. If this parameter is NULL, then the
+ * file will be created in the root of the tracefs filesystem.
+ * @data: a pointer to something that the caller will want to get to later
+ * on. The inode.i_private pointer will point to this value on
+ * theopen()call.
+ * @fops: a pointer to a structfile_operationsthat should be used for
+ * this file.
+ *
+ * This is the basic "create a file" function for tracefs. It allows for a
+ * wide range of flexibility in creating a file, or a directory (if you want
+ * to create a directory, thetracefs_create_dir()function is
+ * recommended to be used instead.)Quoted 8 lines
+ *
+ * This function will return a pointer to a dentry if it succeeds. This
+ * pointer must be passed to thetracefs_remove()function when the file is
+ * to be removed (no automatic cleanup happens if your module is unloaded,
+ * you are responsible here.) If an error occurs, %NULL will be returned.
+ *
+ * If tracefs is not enabled in the kernel, the value -%ENODEV will be
+ * returned.
Quoted 2 lines
I cannot find where it returns
-ENODEV. AFAICS we cannot call tracefs functions if tracing was not enabled.
Ah, originally I had it like debugfs, where these functions were stubs that would return ENODEV when TRACING was not configured. But then, I decided that nothing should be calling these functions when tracing is not configured.
I'll nuke that comment.
Quoted 40 lines
Quoted 40 lines
+ */
fs/tracefs/inode.c new file +37
-0+struct dentry *tracefs_create_file (const char *name,umode_t mode, +struct dentry *parent,void *data, +const struct file_operations *fops) +{ +struct dentry *dentry; +struct inode *inode; + +if (!(mode &S_IFMT )) + mode |=S_IFREG ; +BUG_ON (!S_ISREG (mode)); + dentry =start_creating (name, parent); + +if (IS_ERR (dentry)) +return NULL ; + + inode =tracefs_get_inode (dentry->d_sb); +if (unlikely (!inode)) +return failed_creating (dentry); + + inode->i_mode = mode; + inode->i_fop = fops ? fops : &tracefs_file_operations; + inode->i_private = data; +d_instantiate (dentry, inode); +fsnotify_create (dentry->d_parent->d_inode, dentry); +return end_creating (dentry); +} + +/** +* tracefs_create_dir - create a directory in the tracefs filesystem +* @name: a pointer to a string containing the name of the directory to +* create. +* @parent: a pointer to the parent dentry for this file. This should be a +* directory dentry if set. If this parameter is NULL, then the +* directory will be created in the root of the tracefs filesystem. +* +* This function creates a directory in tracefs with the given name. +*
Quoted 8 lines
Quoted 6 lines
+ * This function will return a pointer to a dentry if it succeeds. This
+ * pointer must be passed to thetracefs_remove()function when the file is
+ * to be removed. If an error occurs, %NULL will be returned.
+ *
+ * If tracing is not enabled in the kernel, the value -%ENODEV will be
+ * returned.Ditto.
And that one too.
Thanks,
-- Steve
Steven Rostedt
maintainerPATCH 4/7 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 | 55 +++++++++++++++++++++--------------- 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, 74 insertions(+), 66 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 */
@@ -4690,7 +4690,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,
@@ -4998,7 +4998,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 */
@@ -5451,7 +5451,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;
@@ -5459,16 +5459,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 +32 -23
176 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 ;
@@ -2534,10 +2534,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 5/7 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!
--- kernel/trace/trace.c | 36 +++++++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-)
kernel/trace/trace.c +33 -3
@@ -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>
@@ -6535,6 +6536,28 @@ init_tracer_tracefs(struct trace_array *tr, struct dentry *d_tracer) } +static struct vfsmount *trace_automount (void *ingore) +{ +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; +} +/** * tracing_init_dentry - initialize top level trace array *
@@ -6546,14 +6569,21 @@ struct dentry *tracing_init_dentry(void) {struct trace_array *tr = &global_trace; +/* The top level trace array uses NULL as parent */ if (tr->dir) -return tr->dir; +return NULL ;if (WARN_ON (!debugfs_initialized ()))return ERR_PTR (-ENODEV ); - tr->dir =debugfs_create_dir ("tracing" ,NULL ); - +/* +* As there may still be users that expect the tracing +* files to exist in debugfs/tracing, we must automount +* the tracefs file system there, so older tools still +* work with the newer kerenl. +*/ + tr->dir =debugfs_create_automount ("tracing" ,NULL , + trace_automount,NULL );if (!tr->dir) {pr_warn_once ("Could not create debugfs directory 'tracing'\n" );return ERR_PTR (-ENOMEM );
Signature · 1 line
2.1.4
Re: [for-next][PATCH 5/7] tracing: Automatically mount tracefs on debugfs/tracing
Quoted 6 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.
Quoted 7 lines
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!
One question. Is it possible to have both of the old /sys/kernel/debug/tracing and new /sys/kernel/tracing directories?
Quoted 57 lines
Cc Al Viro <[email protected]>Signed-off-by Steven Rostedt <[email protected]>--- kernel/trace/trace.c | 36 +++++++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-)kernel/trace/trace.c +25
-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> @@ -6535,6 +6536,28 @@ init_tracer_tracefs(struct trace_array *tr, struct dentry *d_tracer) } +static struct vfsmount *trace_automount (void *ingore) +{ +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; +} +/** * tracing_init_dentry - initialize top level trace array * @@ -6546,14 +6569,21 @@ struct dentry *tracing_init_dentry(void) {struct trace_array *tr = &global_trace; +/* The top level trace array uses NULL as parent */ if (tr->dir) -return tr->dir; +return NULL ;
kernel/trace/trace.c struct dentry *tracing_init_dentry(void) · line 6583
Quoted 10 lines
kernel/trace/trace.c +5
-2if (WARN_ON (!debugfs_initialized ()))return ERR_PTR (-ENODEV ); - tr->dir =debugfs_create_dir ("tracing" ,NULL ); - +/* +* As there may still be users that expect the tracing +* files to exist in debugfs/tracing, we must automount +* the tracefs file system there, so older tools still +* work with the newer kerenl.
s/kerenl/kernel/
Thanks,
Namhyung
Quoted 15 lines
kernel/trace/trace.c +3
-0+*/ + tr->dir =debugfs_create_automount ("tracing" ,NULL , + trace_automount,NULL );if (!tr->dir) {pr_warn_once ("Could not create debugfs directory 'tracing'\n" );return ERR_PTR (-ENOMEM );Signature · 8 lines
2.1.4 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
Steven Rostedt
maintainerRe: [for-next][PATCH 5/7] tracing: Automatically mount tracefs on debugfs/tracing
Quoted 10 lines · On Mon, 9 Feb 2015 15:00:02 +0900 Namhyung Kim <[email protected]> wrote:
Quoted 9 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.
Quoted 7 lines
Quoted 4 lines
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!
One question. Is it possible to have both of the old
/sys/kernel/debug/tracingand new/sys/kernel/tracingdirectories?
Yes. In fact it's required. Because we must stay backward compatible with older tools, we can not get rid of the debug/tracing directory.
Quoted 7 lines
kernel/trace/trace.c struct dentry *tracing_init_dentry(void) · line 6583
Quoted 5 lines
kernel/trace/trace.c +5
-0+/* +* As there may still be users that expect the tracing +* files to exist in debugfs/tracing, we must automount +* the tracefs file system there, so older tools still +* work with the newer kerenl. s/kerenl/kernel/
Thanks, will fix.
-- Steve
Steven Rostedt
maintainerPATCH 6/7 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>
@@ -509,10 +510,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
maintainerPATCH 7/7 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 | 151 +++++++++++++++++++++++++++++++++++++++++++----- include/linux/tracefs.h | 4 ++ kernel/trace/trace.c | 75 ++---------------------- 3 files changed, 145 insertions(+), 85 deletions(-)
fs/tracefs/inode.c +136 -15
@@ -50,6 +50,84 @@ static const struct file_operations tracefs_file_operations = { .llseek = noop_llseek, }; +static struct tracefs_dir_ops { +int (*mkdir)(const char *name); +int (*rmdir)(const char *name); +} tracefs_ops; + +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) +{ +char *name; +int ret; + + 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 = tracefs_ops.mkdir (name); +mutex_lock (&inode->i_mutex); + +kfree (name); + +return ret; +} + +static int tracefs_syscall_rmdir (struct inode *inode,struct dentry *dentry) +{ +char *name; +int ret; + + 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 = tracefs_ops.rmdir (name); + +mutex_lock_nested (&inode->i_mutex,I_MUTEX_PARENT ); +mutex_lock (&dentry->d_inode->i_mutex); + +kfree (name); + +return ret; +} + +static 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) {struct inode *inode =new_inode (sb);
@@ -334,6 +412,31 @@ struct dentry *tracefs_create_file(const char *name, umode_t mode,return end_creating (dentry); } +static struct dentry *__create_dir (const char *name,struct dentry *parent, +const struct inode_operations *ops) +{ +struct dentry *dentry =start_creating (name, parent); +struct inode *inode; + +if (IS_ERR (dentry)) +return NULL ; + + inode =tracefs_get_inode (dentry->d_sb); +if (unlikely (!inode)) +return failed_creating (dentry); + + inode->i_mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ; + inode->i_op = ops; + inode->i_fop = &simple_dir_operations; + +/* directory inodes start off with i_nlink == 2 (for "." entry) */ +inc_nlink (inode); +d_instantiate (dentry, inode); +inc_nlink (dentry->d_parent->d_inode); +fsnotify_mkdir (dentry->d_parent->d_inode, dentry); +return end_creating (dentry); +} +/** * tracefs_create_dir - create a directory in the tracefs filesystem * @name: a pointer to a string containing the name of the directory to
@@ -353,26 +456,44 @@ struct dentry *tracefs_create_file(const char *name, umode_t mode,*/ struct dentry *tracefs_create_dir (const char *name,struct dentry *parent) { -struct dentry *dentry =start_creating (name, parent); -struct inode *inode; +return __create_dir (name, parent, &simple_dir_inode_operations); +} -if (IS_ERR (dentry)) +/** +* tracefs_create_instance_dir - create the tracing instances directory +* @name: The name of the instances directory to create +* @parent: The parent directory that the instances directory will exist +* @mkdir: The function to call when a mkdir is performed. +* @rmdir: The function to call when a rmdir is performed. +* +* Only one instances directory is allowed. +* +* The instances directory is special as it allows for mkdir and rmdir to +* to be done by userspace. When a mkdir or rmdir is performed, the inode +* locks are released and the methhods passed in (@mkdir and @rmdir) are +* called without locks and with the name of the directory being created +* within the instances directory. +* +* Returns the dentry of the instances directory. +*/ +struct dentry *tracefs_create_instance_dir (const char *name,struct dentry *parent, +int (*mkdir)(const char *name), +int (*rmdir)(const char *name)) +{ +struct dentry *dentry; + +/* Only allow one instance of the instances directory. */ +if (WARN_ON (tracefs_ops.mkdir || tracefs_ops.rmdir))return NULL ; - inode =tracefs_get_inode (dentry->d_sb); -if (unlikely (!inode)) -return failed_creating (dentry); + dentry =__create_dir (name, parent, &tracefs_dir_inode_operations); +if (!dentry) +return NULL ; - inode->i_mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ; - inode->i_op = &simple_dir_inode_operations; - inode->i_fop = &simple_dir_operations; + tracefs_ops.mkdir = mkdir; + tracefs_ops.rmdir = rmdir; -/* directory inodes start off with i_nlink == 2 (for "." entry) */ -inc_nlink (inode); -d_instantiate (dentry, inode); -inc_nlink (dentry->d_parent->d_inode); -fsnotify_mkdir (dentry->d_parent->d_inode, dentry); -return end_creating (dentry); +return dentry; }static inline int tracefs_positive (struct dentry *dentry)
include/linux/tracefs.h +4 -0
@@ -34,6 +34,10 @@ 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 dentry *tracefs_create_instance_dir (const char *name,struct dentry *parent, +int (*mkdir)(const char *name), +int (*rmdir)(const char *name)); +bool tracefs_initialized (void );#endif /* CONFIG_TRACING */
kernel/trace/trace.c +5 -70
97 lines not on this page · raw message
Signature · 1 line
2.1.4
Re: [for-next][PATCH 7/7] tracing: Have mkdir and rmdir be part of tracefs
fs/tracefs/inode.c static const struct file_operations tracefs_file_operations = { · line 83
Quoted 11 lines · Steven Rostedt
fs/tracefs/inode.c +11
-0+static int tracefs_syscall_mkdir (struct inode *inode,struct dentry *dentry,umode_t mode) +{ +char *name; +int ret; + + name =get_dname (dentry); +if (!name) +return -ENOMEM ; + +/* +* The mkdir call can call the generic functions that create
The mkdir can call ... ?
Quoted 13 lines
fs/tracefs/inode.c +13
-0+* the files within the tracefs system. It is up to the individual +* mkdir routine to handle races. +*/ +mutex_unlock (&inode->i_mutex); + ret = tracefs_ops.mkdir (name); +mutex_lock (&inode->i_mutex); + +kfree (name); + +return ret; +} + +static int tracefs_syscall_rmdir (struct inode *inode,struct dentry *dentry)
fs/tracefs/inode.c static const struct file_operations tracefs_file_operations = { · line 106
Quoted 10 lines
fs/tracefs/inode.c +10
-0+{ +char *name; +int ret; + + name =get_dname (dentry); +if (!name) +return -ENOMEM ; + +/* +* The rmdir call can call the generic functions that create
Ditto.
Quoted 18 lines
fs/tracefs/inode.c +18
-0+* 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 = tracefs_ops.rmdir (name); + +mutex_lock_nested (&inode->i_mutex,I_MUTEX_PARENT ); +mutex_lock (&dentry->d_inode->i_mutex); + +kfree (name); + +return ret; +} +
[SNIP]
Quoted 4 lines
+/**
+ *tracefs_create_instance_dir- create the tracing instances directory
+ * @name: The name of the instances directory to create
+ * @parent: The parent directory that the instances directory will exist
Quoted 8 lines
+ * @mkdir: The function to call when a mkdir is performed.
+ * @rmdir: The function to call when a rmdir is performed.
+ *
+ * Only one instances directory is allowed.
+ *
+ * The instances directory is special as it allows for mkdir and rmdir to
+ * to be done by userspace. When a mkdir or rmdir is performed, the inode
+ * locks are released and the methhods passed in (@mkdir and @rmdir) are
s/methhods/methods/
Thanks,
Namhyung
Quoted 36 lines
+ * called without locks and with the name of the directory being created
+ * within the instances directory.
+ *
+ * Returns the dentry of the instances directory.
+ */fs/tracefs/inode.c +14
-12+struct dentry *tracefs_create_instance_dir (const char *name,struct dentry *parent, +int (*mkdir)(const char *name), +int (*rmdir)(const char *name)) +{ +struct dentry *dentry; + +/* Only allow one instance of the instances directory. */ +if (WARN_ON (tracefs_ops.mkdir || tracefs_ops.rmdir))return NULL ; - inode =tracefs_get_inode (dentry->d_sb); -if (unlikely (!inode)) -return failed_creating (dentry); + dentry =__create_dir (name, parent, &tracefs_dir_inode_operations); +if (!dentry) +return NULL ; - inode->i_mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ; - inode->i_op = &simple_dir_inode_operations; - inode->i_fop = &simple_dir_operations; + tracefs_ops.mkdir = mkdir; + tracefs_ops.rmdir = rmdir; -/* directory inodes start off with i_nlink == 2 (for "." entry) */ -inc_nlink (inode); -d_instantiate (dentry, inode); -inc_nlink (dentry->d_parent->d_inode); -fsnotify_mkdir (dentry->d_parent->d_inode, dentry); -return end_creating (dentry); +return dentry; }
Steven Rostedt
maintainerRe: [for-next][PATCH 7/7] tracing: Have mkdir and rmdir be part of tracefs
Quoted 14 lines · On Mon, 9 Feb 2015 15:07:22 +0900 Namhyung Kim <[email protected]> wrote:
fs/tracefs/inode.c static const struct file_operations tracefs_file_operations = { · line 83
Quoted 11 lines · Steven Rostedt
fs/tracefs/inode.c +11
-0+static int tracefs_syscall_mkdir (struct inode *inode,struct dentry *dentry,umode_t mode) +{ +char *name; +int ret; + + name =get_dname (dentry); +if (!name) +return -ENOMEM ; + +/* +* The mkdir call can call the generic functions that create The mkdir can call ... ?
Actually, that wasn't a typo. "mkdir call" is the subject.
Quoted 19 lines
Quoted 19 lines
fs/tracefs/inode.c +17
-0+* the files within the tracefs system. It is up to the individual +* mkdir routine to handle races. +*/ +mutex_unlock (&inode->i_mutex); + ret = tracefs_ops.mkdir (name); +mutex_lock (&inode->i_mutex); + +kfree (name); + +return ret; +} + +static int tracefs_syscall_rmdir (struct inode *inode,struct dentry *dentry) +{ +char *name; +int ret; +
Quoted 9 lines
fs/tracefs/inode.c static const struct file_operations tracefs_file_operations = { · line 106
Quoted 6 lines
fs/tracefs/inode.c +6
-0+ name =get_dname (dentry); +if (!name) +return -ENOMEM ; + +/* +* The rmdir call can call the generic functions that create Ditto.
"rmdir call" is also the subject.
Quoted 34 lines
Quoted 19 lines
fs/tracefs/inode.c +18
-0+* 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 = tracefs_ops.rmdir (name); + +mutex_lock_nested (&inode->i_mutex,I_MUTEX_PARENT ); +mutex_lock (&dentry->d_inode->i_mutex); + +kfree (name); + +return ret; +} +[SNIP]
Quoted 4 lines
+/**
+ *tracefs_create_instance_dir- create the tracing instances directory
+ * @name: The name of the instances directory to create
+ * @parent: The parent directory that the instances directory will existQuoted 8 lines
+ * @mkdir: The function to call when a mkdir is performed.
+ * @rmdir: The function to call when a rmdir is performed.
+ *
+ * Only one instances directory is allowed.
+ *
+ * The instances directory is special as it allows for mkdir and rmdir to
+ * to be done by userspace. When a mkdir or rmdir is performed, the inode
+ * locks are released and the methhods passed in (@mkdir and @rmdir) are
Quoted 1 line
s/methhods/methods/
I must have been on meth ;-)
Thanks.
-- Steve