tracing: Convert the tracing facility over to use tracefs

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.

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

8 files changed, 74 insertions, 66 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 45e5cb143d17..fcc0e7052a79 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -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
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 05e0e50539fc..6c4739bee4bb 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>
@@ -5828,6 +5829,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;
 }
 
@@ -5842,10 +5851,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;
 }
@@ -5862,7 +5871,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;
@@ -5872,9 +5881,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;
         }
 
@@ -6026,9 +6035,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;
 }
@@ -6045,9 +6054,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;
         }
 
@@ -6116,7 +6125,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);
 }
@@ -6205,7 +6214,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)
@@ -6321,17 +6330,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);
 
@@ -6404,7 +6413,7 @@ static int instance_mkdir (struct inode *inode, struct dentry *dentry, umode_t m
                 return -ENOENT;
 
         /*
-         * The inode mutex is locked, but debugfs_create_dir() will also
+         * The inode mutex is locked, but tracefs_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
@@ -6434,7 +6443,7 @@ static int instance_rmdir(struct inode *inode, struct dentry *dentry)
         mutex_unlock(&dentry->d_inode->i_mutex);
 
         /*
-         * The inode mutex is locked, but debugfs_create_dir() will also
+         * The inode mutex is locked, but tracefs_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
@@ -6459,7 +6468,7 @@ static const struct inode_operations instance_dir_inode_operations = {
 
 static __init void create_trace_instances(struct dentry *d_tracer)
 {
-        trace_instance_dir = debugfs_create_dir("instances", d_tracer);
+        trace_instance_dir = tracefs_create_dir("instances", d_tracer);
         if (WARN_ON(!trace_instance_dir))
                 return;
 
@@ -6468,7 +6477,7 @@ static __init void create_trace_instances(struct dentry *d_tracer)
 }
 
 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;
 
@@ -6522,7 +6531,7 @@ 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);
 
 }
 
@@ -6550,10 +6559,10 @@ struct dentry *tracing_init_dentry(void)
                 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;
 
@@ -6563,7 +6572,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);
@@ -6925,5 +6934,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);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index dd8205a35760..d951deddec89 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -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
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index db54dda10ccc..0d2e47370ee7 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -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");
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 2d25ad1526bb..9cfea4c6d314 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -6,7 +6,6 @@
  * is Copyright (c) Steven Rostedt <srostedt@redhat.com>
  *
  */
-#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)
 {
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index b4a00def88f5..c1c6655847c8 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -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;
 }
diff --git a/kernel/trace/trace_probe.h b/kernel/trace/trace_probe.h
index 4f815fbce16d..19aff635841a 100644
--- a/kernel/trace/trace_probe.h
+++ b/kernel/trace/trace_probe.h
@@ -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>
diff --git a/kernel/trace/trace_stat.c b/kernel/trace/trace_stat.c
index 75e19e86c954..6cf935316769 100644
--- a/kernel/trace/trace_stat.c
+++ b/kernel/trace/trace_stat.c
@@ -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)