Merge tag 'trace-4.1-tracefs' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace

Pull tracefs from Steven Rostedt:
 "This adds the new tracefs file system.

  This has been in linux-next for more than one release, as I had it
  ready for the 4.0 merge window, but a last minute thing that needed to
  go into Linux first had to be done.  That was that perf hard coded the
  file system number when reading /sys/kernel/debugfs/tracing directory
  making sure that the path had the debugfs mount # before it would
  parse the tracing file.  This broke other use cases of perf, and the
  check is removed.

  Now when mounting /sys/kernel/debug, tracefs is automatically mounted
  in /sys/kernel/debug/tracing such that old tools will still see that
  path as expected.  But now system admins can mount tracefs directly
  and not need to mount debugfs, which can expose security issues.  A
  new directory is created when tracefs is configured such that system
  admins can now mount it separately (/sys/kernel/tracing)"

* tag 'trace-4.1-tracefs' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace:
  tracing: Have mkdir and rmdir be part of tracefs
  tracefs: Add directory /sys/kernel/tracing
  tracing: Automatically mount tracefs on debugfs/tracing
  tracing: Convert the tracing facility over to use tracefs
  tracefs: Add new tracefs file system
  tracing: Create cmdline tracer options on tracing fs init
  tracing: Only create tracer options files if directory exists
  debugfs: Provide a file creation function that also takes an initial size

1 files changed, 88 insertions, 99 deletions

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 62c6506d663f..bcfa2add6dda 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -20,6 +20,7 @@
 #include <linux/notifier.h>
 #include <linux/irqflags.h>
 #include <linux/debugfs.h>
+#include <linux/tracefs.h>
 #include <linux/pagemap.h>
 #include <linux/hardirq.h>
 #include <linux/linkage.h>
@@ -31,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>
@@ -4105,9 +4107,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,11 +4189,7 @@ 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) {
-                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) {
@@ -5817,6 +5830,14 @@ static inline __init int register_snapshot_cmd(void) { return 0; }
 
 static struct dentry *tracing_get_dentry(struct trace_array *tr)
 {
+        if (WARN_ON(!tr->dir))
+                return ERR_PTR(-ENODEV);
+
+        /* Top directory uses NULL as the parent */
+        if (tr->flags & TRACE_ARRAY_FL_GLOBAL)
+                return NULL;
+
+        /* All sub buffers have a descriptor */
         return tr->dir;
 }
 
@@ -5831,10 +5852,10 @@ static struct dentry *tracing_dentry_percpu(struct trace_array *tr, int cpu)
         if (IS_ERR(d_tracer))
                 return NULL;
 
-        tr->percpu_dir = debugfs_create_dir("per_cpu", d_tracer);
+        tr->percpu_dir = tracefs_create_dir("per_cpu", d_tracer);
 
         WARN_ONCE(!tr->percpu_dir,
-                  "Could not create debugfs directory 'per_cpu/%d'\n", cpu);
+                  "Could not create tracefs directory 'per_cpu/%d'\n", cpu);
 
         return tr->percpu_dir;
 }
@@ -5851,7 +5872,7 @@ trace_create_cpu_file(const char *name, umode_t mode, struct dentry *parent,
 }
 
 static void
-tracing_init_debugfs_percpu(struct trace_array *tr, long cpu)
+tracing_init_tracefs_percpu(struct trace_array *tr, long cpu)
 {
         struct dentry *d_percpu = tracing_dentry_percpu(tr, cpu);
         struct dentry *d_cpu;
@@ -5861,9 +5882,9 @@ tracing_init_debugfs_percpu(struct trace_array *tr, long cpu)
                 return;
 
         snprintf(cpu_dir, 30, "cpu%ld", cpu);
-        d_cpu = debugfs_create_dir(cpu_dir, d_percpu);
+        d_cpu = tracefs_create_dir(cpu_dir, d_percpu);
         if (!d_cpu) {
-                pr_warning("Could not create debugfs '%s' entry\n", cpu_dir);
+                pr_warning("Could not create tracefs '%s' entry\n", cpu_dir);
                 return;
         }
 
@@ -6015,9 +6036,9 @@ struct dentry *trace_create_file(const char *name,
 {
         struct dentry *ret;
 
-        ret = debugfs_create_file(name, mode, parent, data, fops);
+        ret = tracefs_create_file(name, mode, parent, data, fops);
         if (!ret)
-                pr_warning("Could not create debugfs '%s' entry\n", name);
+                pr_warning("Could not create tracefs '%s' entry\n", name);
 
         return ret;
 }
@@ -6034,9 +6055,9 @@ static struct dentry *trace_options_init_dentry(struct trace_array *tr)
         if (IS_ERR(d_tracer))
                 return NULL;
 
-        tr->options = debugfs_create_dir("options", d_tracer);
+        tr->options = tracefs_create_dir("options", d_tracer);
         if (!tr->options) {
-                pr_warning("Could not create debugfs directory 'options'\n");
+                pr_warning("Could not create tracefs directory 'options'\n");
                 return NULL;
         }
 
@@ -6105,7 +6126,7 @@ destroy_trace_option_files(struct trace_option_dentry *topts)
                 return;
 
         for (cnt = 0; topts[cnt].opt; cnt++)
-                debugfs_remove(topts[cnt].entry);
+                tracefs_remove(topts[cnt].entry);
 
         kfree(topts);
 }
@@ -6194,7 +6215,7 @@ static const struct file_operations rb_simple_fops = {
 struct dentry *trace_instance_dir;
 
 static void
-init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer);
+init_tracer_tracefs(struct trace_array *tr, struct dentry *d_tracer);
 
 static int
 allocate_trace_buffer(struct trace_array *tr, struct trace_buffer *buf, int size)
@@ -6271,7 +6292,7 @@ static void free_trace_buffers(struct trace_array *tr)
 #endif
 }
 
-static int new_instance_create(const char *name)
+static int instance_mkdir(const char *name)
 {
         struct trace_array *tr;
         int ret;
@@ -6310,17 +6331,17 @@ static int new_instance_create(const char *name)
         if (allocate_trace_buffers(tr, trace_buf_size) < 0)
                 goto out_free_tr;
 
-        tr->dir = debugfs_create_dir(name, trace_instance_dir);
+        tr->dir = tracefs_create_dir(name, trace_instance_dir);
         if (!tr->dir)
                 goto out_free_tr;
 
         ret = event_trace_add_tracer(tr->dir, tr);
         if (ret) {
-                debugfs_remove_recursive(tr->dir);
+                tracefs_remove_recursive(tr->dir);
                 goto out_free_tr;
         }
 
-        init_tracer_debugfs(tr, tr->dir);
+        init_tracer_tracefs(tr, tr->dir);
 
         list_add(&tr->list, &ftrace_trace_arrays);
 
@@ -6341,7 +6362,7 @@ static int new_instance_create(const char *name)
 
 }
 
-static int instance_delete(const char *name)
+static int instance_rmdir(const char *name)
 {
         struct trace_array *tr;
         int found = 0;
@@ -6382,82 +6403,17 @@ static int instance_delete(const char *name)
         return ret;
 }
 
-static int instance_mkdir (struct inode *inode, struct dentry *dentry, umode_t mode)
-{
-        struct dentry *parent;
-        int ret;
-
-        /* Paranoid: Make sure the parent is the "instances" directory */
-        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_u.d_alias);
-        if (WARN_ON_ONCE(parent != trace_instance_dir))
-                return -ENOENT;
-
-        /*
-         * The inode mutex is locked, but debugfs_create_dir() will also
-         * take the mutex. As the instances directory can not be destroyed
-         * or changed in any other way, it is safe to unlock it, and
-         * let the dentry try. If two users try to make the same dir at
-         * the same time, then the new_instance_create() will determine the
-         * winner.
-         */
-        mutex_unlock(&inode->i_mutex);
-
-        ret = new_instance_create(dentry->d_iname);
-
-        mutex_lock(&inode->i_mutex);
-
-        return ret;
-}
-
-static int instance_rmdir(struct inode *inode, struct dentry *dentry)
-{
-        struct dentry *parent;
-        int ret;
-
-        /* Paranoid: Make sure the parent is the "instances" directory */
-        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_u.d_alias);
-        if (WARN_ON_ONCE(parent != trace_instance_dir))
-                return -ENOENT;
-
-        /* The caller did a dget() on dentry */
-        mutex_unlock(&dentry->d_inode->i_mutex);
-
-        /*
-         * The inode mutex is locked, but debugfs_create_dir() will also
-         * take the mutex. As the instances directory can not be destroyed
-         * or changed in any other way, it is safe to unlock it, and
-         * let the dentry try. If two users try to make the same dir at
-         * the same time, then the instance_delete() will determine the
-         * winner.
-         */
-        mutex_unlock(&inode->i_mutex);
-
-        ret = instance_delete(dentry->d_iname);
-
-        mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT);
-        mutex_lock(&dentry->d_inode->i_mutex);
-
-        return ret;
-}
-
-static const struct inode_operations instance_dir_inode_operations = {
-        .lookup         = simple_lookup,
-        .mkdir          = instance_mkdir,
-        .rmdir          = instance_rmdir,
-};
-
 static __init void create_trace_instances(struct dentry *d_tracer)
 {
-        trace_instance_dir = debugfs_create_dir("instances", d_tracer);
+        trace_instance_dir = tracefs_create_instance_dir("instances", d_tracer,
+                                                         instance_mkdir,
+                                                         instance_rmdir);
         if (WARN_ON(!trace_instance_dir))
                 return;
-
-        /* Hijack the dir inode operations, to allow mkdir */
-        trace_instance_dir->d_inode->i_op = &instance_dir_inode_operations;
 }
 
 static void
-init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer)
+init_tracer_tracefs(struct trace_array *tr, struct dentry *d_tracer)
 {
         int cpu;
 
@@ -6511,10 +6467,32 @@ init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer)
 #endif
 
         for_each_tracing_cpu(cpu)
-                tracing_init_debugfs_percpu(tr, cpu);
+                tracing_init_tracefs_percpu(tr, cpu);
 
 }
 
+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
  *
@@ -6526,23 +6504,30 @@ 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);
         }
 
-        return tr->dir;
+        return NULL;
 }
 
-static __init int tracer_init_debugfs(void)
+static __init int tracer_init_tracefs(void)
 {
         struct dentry *d_tracer;
 
@@ -6552,7 +6537,7 @@ static __init int tracer_init_debugfs(void)
         if (IS_ERR(d_tracer))
                 return 0;
 
-        init_tracer_debugfs(&global_trace, d_tracer);
+        init_tracer_tracefs(&global_trace, d_tracer);
 
         trace_create_file("tracing_thresh", 0644, d_tracer,
                         &global_trace, &tracing_thresh_fops);
@@ -6575,6 +6560,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;
 }
 
@@ -6910,5 +6899,5 @@ __init static int clear_boot_tracer(void)
         return 0;
 }
 
-fs_initcall(tracer_init_debugfs);
+fs_initcall(tracer_init_tracefs);
 late_initcall(clear_boot_tracer);