* directory. It is called via fs_initcall() by any of the boot up code
  * and expects to return the dentry of the top level tracing directory.
  */
-struct dentry *tracing_init_dentry(void)
+int tracing_init_dentry(void)
 {
        struct trace_array *tr = &global_trace;
 
        if (security_locked_down(LOCKDOWN_TRACEFS)) {
                pr_warn("Tracing disabled due to lockdown\n");
-               return ERR_PTR(-EPERM);
+               return -EPERM;
        }
 
        /* The top level trace array uses  NULL as parent */
        if (tr->dir)
-               return NULL;
+               return 0;
 
        if (WARN_ON(!tracefs_initialized()))
-               return ERR_PTR(-ENODEV);
+               return -ENODEV;
 
        /*
         * As there may still be users that expect the tracing
        tr->dir = debugfs_create_automount("tracing", NULL,
                                           trace_automount, NULL);
 
-       return NULL;
+       return 0;
 }
 
 extern struct trace_eval_map *__start_ftrace_eval_maps[];
 
 static __init int tracer_init_tracefs(void)
 {
-       struct dentry *d_tracer;
+       int ret;
 
        trace_access_lock_init();
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return 0;
 
        event_trace_init();
 
-       init_tracer_tracefs(&global_trace, d_tracer);
-       ftrace_init_tracefs_toplevel(&global_trace, d_tracer);
+       init_tracer_tracefs(&global_trace, NULL);
+       ftrace_init_tracefs_toplevel(&global_trace, NULL);
 
-       trace_create_file("tracing_thresh", 0644, d_tracer,
+       trace_create_file("tracing_thresh", 0644, NULL,
                        &global_trace, &tracing_thresh_fops);
 
-       trace_create_file("README", 0444, d_tracer,
+       trace_create_file("README", 0444, NULL,
                        NULL, &tracing_readme_fops);
 
-       trace_create_file("saved_cmdlines", 0444, d_tracer,
+       trace_create_file("saved_cmdlines", 0444, NULL,
                        NULL, &tracing_saved_cmdlines_fops);
 
-       trace_create_file("saved_cmdlines_size", 0644, d_tracer,
+       trace_create_file("saved_cmdlines_size", 0644, NULL,
                          NULL, &tracing_saved_cmdlines_size_fops);
 
-       trace_create_file("saved_tgids", 0444, d_tracer,
+       trace_create_file("saved_tgids", 0444, NULL,
                        NULL, &tracing_saved_tgids_fops);
 
        trace_eval_init();
 
-       trace_create_eval_file(d_tracer);
+       trace_create_eval_file(NULL);
 
 #ifdef CONFIG_MODULES
        register_module_notifier(&trace_module_nb);
 #endif
 
 #ifdef CONFIG_DYNAMIC_FTRACE
-       trace_create_file("dyn_ftrace_total_info", 0444, d_tracer,
+       trace_create_file("dyn_ftrace_total_info", 0444, NULL,
                        NULL, &tracing_dyn_info_fops);
 #endif
 
-       create_trace_instances(d_tracer);
+       create_trace_instances(NULL);
 
        update_tracer_options(&global_trace);
 
 
                                 void *data,
                                 const struct file_operations *fops);
 
-struct dentry *tracing_init_dentry(void);
+int tracing_init_dentry(void);
 
 struct ring_buffer_event;
 
 
 /* Make a tracefs interface for controlling dynamic events */
 static __init int init_dynamic_event(void)
 {
-       struct dentry *d_tracer;
        struct dentry *entry;
+       int ret;
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return 0;
 
-       entry = tracefs_create_file("dynamic_events", 0644, d_tracer,
+       entry = tracefs_create_file("dynamic_events", 0644, NULL,
                                    NULL, &dynamic_events_ops);
 
        /* Event list interface */
 
 static __init int trace_events_synth_init(void)
 {
        struct dentry *entry = NULL;
-       struct dentry *d_tracer;
        int err = 0;
 
        err = dyn_event_register(&synth_event_ops);
                return err;
        }
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer)) {
-               err = PTR_ERR(d_tracer);
+       err = tracing_init_dentry();
+       if (err)
                goto err;
-       }
 
-       entry = tracefs_create_file("synthetic_events", 0644, d_tracer,
+       entry = tracefs_create_file("synthetic_events", 0644, NULL,
                                    NULL, &synth_events_fops);
        if (!entry) {
                err = -ENODEV;
 
 
 static __init int init_graph_tracefs(void)
 {
-       struct dentry *d_tracer;
+       int ret;
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return 0;
 
-       trace_create_file("max_graph_depth", 0644, d_tracer,
+       trace_create_file("max_graph_depth", 0644, NULL,
                          NULL, &graph_depth_fops);
 
        return 0;
 
  */
 static int init_tracefs(void)
 {
-       struct dentry *d_tracer;
+       int ret;
        struct dentry *top_dir;
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return -ENOMEM;
 
-       top_dir = tracefs_create_dir("hwlat_detector", d_tracer);
+       top_dir = tracefs_create_dir("hwlat_detector", NULL);
        if (!top_dir)
                return -ENOMEM;
 
 
 /* Make a tracefs interface for controlling probe points */
 static __init int init_kprobe_trace(void)
 {
-       struct dentry *d_tracer;
+       int ret;
        struct dentry *entry;
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return 0;
 
-       entry = tracefs_create_file("kprobe_events", 0644, d_tracer,
+       entry = tracefs_create_file("kprobe_events", 0644, NULL,
                                    NULL, &kprobe_events_ops);
 
        /* Event list interface */
                pr_warn("Could not create tracefs 'kprobe_events' entry\n");
 
        /* Profile interface */
-       entry = tracefs_create_file("kprobe_profile", 0444, d_tracer,
+       entry = tracefs_create_file("kprobe_profile", 0444, NULL,
                                    NULL, &kprobe_profile_ops);
 
        if (!entry)
 
 
 static __init int init_trace_printk_function_export(void)
 {
-       struct dentry *d_tracer;
+       int ret;
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return 0;
 
-       trace_create_file("printk_formats", 0444, d_tracer,
+       trace_create_file("printk_formats", 0444, NULL,
                                    NULL, &ftrace_formats_fops);
 
        return 0;
 
 
 static __init int stack_trace_init(void)
 {
-       struct dentry *d_tracer;
+       int ret;
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return 0;
 
-       trace_create_file("stack_max_size", 0644, d_tracer,
+       trace_create_file("stack_max_size", 0644, NULL,
                        &stack_trace_max_size, &stack_max_size_fops);
 
-       trace_create_file("stack_trace", 0444, d_tracer,
+       trace_create_file("stack_trace", 0444, NULL,
                        NULL, &stack_trace_fops);
 
 #ifdef CONFIG_DYNAMIC_FTRACE
-       trace_create_file("stack_trace_filter", 0644, d_tracer,
+       trace_create_file("stack_trace_filter", 0644, NULL,
                          &trace_ops, &stack_trace_filter_fops);
 #endif
 
 
 
 static int tracing_stat_init(void)
 {
-       struct dentry *d_tracing;
+       int ret;
 
-       d_tracing = tracing_init_dentry();
-       if (IS_ERR(d_tracing))
+       ret = tracing_init_dentry();
+       if (ret)
                return -ENODEV;
 
-       stat_dir = tracefs_create_dir("trace_stat", d_tracing);
+       stat_dir = tracefs_create_dir("trace_stat", NULL);
        if (!stat_dir) {
                pr_warn("Could not create tracefs 'trace_stat' entry\n");
                return -ENOMEM;
 
 /* Make a trace interface for controling probe points */
 static __init int init_uprobe_trace(void)
 {
-       struct dentry *d_tracer;
        int ret;
 
        ret = dyn_event_register(&trace_uprobe_ops);
        if (ret)
                return ret;
 
-       d_tracer = tracing_init_dentry();
-       if (IS_ERR(d_tracer))
+       ret = tracing_init_dentry();
+       if (ret)
                return 0;
 
-       trace_create_file("uprobe_events", 0644, d_tracer,
+       trace_create_file("uprobe_events", 0644, NULL,
                                    NULL, &uprobe_events_ops);
        /* Profile interface */
-       trace_create_file("uprobe_profile", 0444, d_tracer,
+       trace_create_file("uprobe_profile", 0444, NULL,
                                    NULL, &uprobe_profile_ops);
        return 0;
 }