ftrace: Remove global function list and call function directly

Instead of having a list of global functions that are called,
as only one global function is allow to be enabled at a time, there's
no reason to have a list.

Instead, simply have all the users of the global ops, use the global ops
directly, instead of registering their own ftrace_ops. Just switch what
function is used before enabling the function tracer.

This removes a lot of code as well as the complexity involved with it.

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

7 files changed, 125 insertions, 209 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 1fd4b9479210..8f61ef70a297 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -62,7 +62,7 @@
 #define FTRACE_HASH_DEFAULT_BITS 10
 #define FTRACE_HASH_MAX_BITS 12
 
-#define FL_GLOBAL_CONTROL_MASK (FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_CONTROL)
+#define FL_GLOBAL_CONTROL_MASK (FTRACE_OPS_FL_CONTROL)
 
 #ifdef CONFIG_DYNAMIC_FTRACE
 #define INIT_REGEX_LOCK(opsname)        \
@@ -103,7 +103,6 @@ static int ftrace_disabled __read_mostly;
 
 static DEFINE_MUTEX(ftrace_lock);
 
-static struct ftrace_ops *ftrace_global_list __read_mostly = &ftrace_list_end;
 static struct ftrace_ops *ftrace_control_list __read_mostly = &ftrace_list_end;
 static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
@@ -171,23 +170,6 @@ int ftrace_nr_registered_ops(void)
         return cnt;
 }
 
-static void
-ftrace_global_list_func(unsigned long ip, unsigned long parent_ip,
-                        struct ftrace_ops *op, struct pt_regs *regs)
-{
-        int bit;
-
-        bit = trace_test_and_set_recursion(TRACE_GLOBAL_START, TRACE_GLOBAL_MAX);
-        if (bit < 0)
-                return;
-
-        do_for_each_ftrace_op(op, ftrace_global_list) {
-                op->func(ip, parent_ip, op, regs);
-        } while_for_each_ftrace_op(op);
-
-        trace_clear_recursion(bit);
-}
-
 static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip,
                             struct ftrace_ops *op, struct pt_regs *regs)
 {
@@ -237,43 +219,6 @@ static int control_ops_alloc(struct ftrace_ops *ops)
         return 0;
 }
 
-static void update_global_ops(void)
-{
-        ftrace_func_t func = ftrace_global_list_func;
-        void *private = NULL;
-
-        /* The list has its own recursion protection. */
-        global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
-
-        /*
-         * If there's only one function registered, then call that
-         * function directly. Otherwise, we need to iterate over the
-         * registered callers.
-         */
-        if (ftrace_global_list == &ftrace_list_end ||
-            ftrace_global_list->next == &ftrace_list_end) {
-                func = ftrace_global_list->func;
-                private = ftrace_global_list->private;
-                /*
-                 * As we are calling the function directly.
-                 * If it does not have recursion protection,
-                 * the function_trace_op needs to be updated
-                 * accordingly.
-                 */
-                if (!(ftrace_global_list->flags & FTRACE_OPS_FL_RECURSION_SAFE))
-                        global_ops.flags &= ~FTRACE_OPS_FL_RECURSION_SAFE;
-        }
-
-        /* If we filter on pids, update to use the pid function */
-        if (!list_empty(&ftrace_pids)) {
-                set_ftrace_pid_function(func);
-                func = ftrace_pid_func;
-        }
-
-        global_ops.func = func;
-        global_ops.private = private;
-}
-
 static void ftrace_sync(struct work_struct *work)
 {
         /*
@@ -301,8 +246,6 @@ static void update_ftrace_function(void)
 {
         ftrace_func_t func;
 
-        update_global_ops();
-
         /*
          * If we are at the end of the list and this ops is
          * recursion safe and not dynamic and the arch supports passing ops,
@@ -314,10 +257,7 @@ static void update_ftrace_function(void)
              (ftrace_ops_list->flags & FTRACE_OPS_FL_RECURSION_SAFE) &&
              !FTRACE_FORCE_LIST_FUNC)) {
                 /* Set the ftrace_ops that the arch callback uses */
-                if (ftrace_ops_list == &global_ops)
-                        set_function_trace_op = ftrace_global_list;
-                else
-                        set_function_trace_op = ftrace_ops_list;
+                set_function_trace_op = ftrace_ops_list;
                 func = ftrace_ops_list->func;
         } else {
                 /* Just use the default ftrace_ops */
@@ -434,16 +374,9 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         if (ops->flags & FTRACE_OPS_FL_DELETED)
                 return -EINVAL;
 
-        if (FTRACE_WARN_ON(ops == &global_ops))
-                return -EINVAL;
-
         if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED))
                 return -EBUSY;
 
-        /* We don't support both control and global flags set. */
-        if ((ops->flags & FL_GLOBAL_CONTROL_MASK) == FL_GLOBAL_CONTROL_MASK)
-                return -EINVAL;
-
 #ifndef CONFIG_DYNAMIC_FTRACE_WITH_REGS
         /*
          * If the ftrace_ops specifies SAVE_REGS, then it only can be used
@@ -461,10 +394,7 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         if (!core_kernel_data((unsigned long)ops))
                 ops->flags |= FTRACE_OPS_FL_DYNAMIC;
 
-        if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
-                add_ftrace_list_ops(&ftrace_global_list, &global_ops, ops);
-                ops->flags |= FTRACE_OPS_FL_ENABLED;
-        } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
+        if (ops->flags & FTRACE_OPS_FL_CONTROL) {
                 if (control_ops_alloc(ops))
                         return -ENOMEM;
                 add_ftrace_list_ops(&ftrace_control_list, &control_ops, ops);
@@ -484,15 +414,7 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
         if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED)))
                 return -EBUSY;
 
-        if (FTRACE_WARN_ON(ops == &global_ops))
-                return -EINVAL;
-
-        if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
-                ret = remove_ftrace_list_ops(&ftrace_global_list,
-                                             &global_ops, ops);
-                if (!ret)
-                        ops->flags &= ~FTRACE_OPS_FL_ENABLED;
-        } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
+        if (ops->flags & FTRACE_OPS_FL_CONTROL) {
                 ret = remove_ftrace_list_ops(&ftrace_control_list,
                                              &control_ops, ops);
         } else
@@ -2128,15 +2050,6 @@ static int ftrace_startup(struct ftrace_ops *ops, int command)
         ftrace_start_up++;
         command |= FTRACE_UPDATE_CALLS;
 
-        /* ops marked global share the filter hashes */
-        if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
-                ops = &global_ops;
-                /* Don't update hash if global is already set */
-                if (global_start_up)
-                        hash_enable = false;
-                global_start_up++;
-        }
-
         ops->flags |= FTRACE_OPS_FL_ENABLED;
         if (hash_enable)
                 ftrace_hash_rec_enable(ops, 1);
@@ -2166,21 +2079,10 @@ static int ftrace_shutdown(struct ftrace_ops *ops, int command)
          */
         WARN_ON_ONCE(ftrace_start_up < 0);
 
-        if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
-                ops = &global_ops;
-                global_start_up--;
-                WARN_ON_ONCE(global_start_up < 0);
-                /* Don't update hash if global still has users */
-                if (global_start_up) {
-                        WARN_ON_ONCE(!ftrace_start_up);
-                        hash_disable = false;
-                }
-        }
-
         if (hash_disable)
                 ftrace_hash_rec_disable(ops, 1);
 
-        if (ops != &global_ops || !global_start_up)
+        if (!global_start_up)
                 ops->flags &= ~FTRACE_OPS_FL_ENABLED;
 
         command |= FTRACE_UPDATE_CALLS;
@@ -3524,10 +3426,6 @@ ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
         struct ftrace_hash *hash;
         int ret;
 
-        /* All global ops uses the global ops filters */
-        if (ops->flags & FTRACE_OPS_FL_GLOBAL)
-                ops = &global_ops;
-
         if (unlikely(ftrace_disabled))
                 return -ENODEV;
 
@@ -4462,6 +4360,34 @@ ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
 
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
+__init void ftrace_init_global_array_ops(struct trace_array *tr)
+{
+        tr->ops = &global_ops;
+        tr->ops->private = tr;
+}
+
+void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func)
+{
+        /* If we filter on pids, update to use the pid function */
+        if (tr->flags & TRACE_ARRAY_FL_GLOBAL) {
+                if (WARN_ON(tr->ops->func != ftrace_stub))
+                        printk("ftrace ops had %pS for function\n",
+                               tr->ops->func);
+                /* Only the top level instance does pid tracing */
+                if (!list_empty(&ftrace_pids)) {
+                        set_ftrace_pid_function(func);
+                        func = ftrace_pid_func;
+                }
+        }
+        tr->ops->func = func;
+        tr->ops->private = tr;
+}
+
+void ftrace_reset_array_ops(struct trace_array *tr)
+{
+        tr->ops->func = ftrace_stub;
+}
+
 static void
 ftrace_ops_control_func(unsigned long ip, unsigned long parent_ip,
                         struct ftrace_ops *op, struct pt_regs *regs)
@@ -4520,9 +4446,16 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
          */
         preempt_disable_notrace();
         do_for_each_ftrace_op(op, ftrace_ops_list) {
-                if (ftrace_ops_test(op, ip, regs))
+                if (ftrace_ops_test(op, ip, regs)) {
+                        if (WARN_ON(!op->func)) {
+                                function_trace_stop = 1;
+                                printk("op=%p %pS\n", op, op);
+                                goto out;
+                        }
                         op->func(ip, parent_ip, op, regs);
+                }
         } while_for_each_ftrace_op(op);
+out:
         preempt_enable_notrace();
         trace_clear_recursion(bit);
 }
@@ -5076,8 +5009,7 @@ ftrace_suspend_notifier_call(struct notifier_block *bl, unsigned long state,
 /* Just a place holder for function graph */
 static struct ftrace_ops fgraph_ops __read_mostly = {
         .func           = ftrace_stub,
-        .flags          = FTRACE_OPS_FL_STUB | FTRACE_OPS_FL_GLOBAL |
-                                FTRACE_OPS_FL_RECURSION_SAFE,
+        .flags          = FTRACE_OPS_FL_STUB | FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
 static int ftrace_graph_entry_test(struct ftrace_graph_ent *trace)
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 737b0efa1a62..fdd33aacdf05 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -6629,6 +6629,8 @@ __init static int tracer_alloc_buffers(void)
          */
         global_trace.current_trace = &nop_trace;
 
+        ftrace_init_global_array_ops(&global_trace);
+
         register_tracer(&nop_trace);
 
         /* All seems OK, enable tracing */
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 2e29d7ba5a52..df5256be64cd 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -416,13 +416,7 @@ enum {
         TRACE_FTRACE_IRQ_BIT,
         TRACE_FTRACE_SIRQ_BIT,
 
-        /* GLOBAL_BITs must be greater than FTRACE_BITs */
-        TRACE_GLOBAL_BIT,
-        TRACE_GLOBAL_NMI_BIT,
-        TRACE_GLOBAL_IRQ_BIT,
-        TRACE_GLOBAL_SIRQ_BIT,
-
-        /* INTERNAL_BITs must be greater than GLOBAL_BITs */
+        /* INTERNAL_BITs must be greater than FTRACE_BITs */
         TRACE_INTERNAL_BIT,
         TRACE_INTERNAL_NMI_BIT,
         TRACE_INTERNAL_IRQ_BIT,
@@ -449,9 +443,6 @@ enum {
 #define TRACE_FTRACE_START      TRACE_FTRACE_BIT
 #define TRACE_FTRACE_MAX        ((1 << (TRACE_FTRACE_START + TRACE_CONTEXT_BITS)) - 1)
 
-#define TRACE_GLOBAL_START      TRACE_GLOBAL_BIT
-#define TRACE_GLOBAL_MAX        ((1 << (TRACE_GLOBAL_START + TRACE_CONTEXT_BITS)) - 1)
-
 #define TRACE_LIST_START        TRACE_INTERNAL_BIT
 #define TRACE_LIST_MAX          ((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)
 
@@ -823,6 +814,9 @@ extern int ftrace_is_dead(void);
 int ftrace_create_function_files(struct trace_array *tr,
                                  struct dentry *parent);
 void ftrace_destroy_function_files(struct trace_array *tr);
+void ftrace_init_global_array_ops(struct trace_array *tr);
+void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func);
+void ftrace_reset_array_ops(struct trace_array *tr);
 #else
 static inline int ftrace_trace_task(struct task_struct *task)
 {
@@ -836,6 +830,11 @@ ftrace_create_function_files(struct trace_array *tr,
         return 0;
 }
 static inline void ftrace_destroy_function_files(struct trace_array *tr) { }
+static inline __init void
+ftrace_init_global_array_ops(struct trace_array *tr) { }
+static inline void ftrace_reset_array_ops(struct trace_array *tr) { }
+/* ftace_func_t type is not defined, use macro instead of static inline */
+#define ftrace_init_array_ops(tr, func) do { } while (0)
 #endif /* CONFIG_FUNCTION_TRACER */
 
 #if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index ffd56351b521..2d9482b8f26a 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -26,8 +26,6 @@ function_trace_call(unsigned long ip, unsigned long parent_ip,
 static void
 function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
                           struct ftrace_ops *op, struct pt_regs *pt_regs);
-static struct ftrace_ops trace_ops;
-static struct ftrace_ops trace_stack_ops;
 static struct tracer_flags func_flags;
 
 /* Our option */
@@ -83,28 +81,24 @@ void ftrace_destroy_function_files(struct trace_array *tr)
 
 static int function_trace_init(struct trace_array *tr)
 {
-        struct ftrace_ops *ops;
-
-        if (tr->flags & TRACE_ARRAY_FL_GLOBAL) {
-                /* There's only one global tr */
-                if (!trace_ops.private) {
-                        trace_ops.private = tr;
-                        trace_stack_ops.private = tr;
-                }
+        ftrace_func_t func;
 
-                if (func_flags.val & TRACE_FUNC_OPT_STACK)
-                        ops = &trace_stack_ops;
-                else
-                        ops = &trace_ops;
-                tr->ops = ops;
-        } else if (!tr->ops) {
-                /*
-                 * Instance trace_arrays get their ops allocated
-                 * at instance creation. Unless it failed
-                 * the allocation.
-                 */
+        /*
+         * Instance trace_arrays get their ops allocated
+         * at instance creation. Unless it failed
+         * the allocation.
+         */
+        if (!tr->ops)
                 return -ENOMEM;
-        }
+
+        /* Currently only the global instance can do stack tracing */
+        if (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
+            func_flags.val & TRACE_FUNC_OPT_STACK)
+                func = function_stack_trace_call;
+        else
+                func = function_trace_call;
+
+        ftrace_init_array_ops(tr, func);
 
         tr->trace_buffer.cpu = get_cpu();
         put_cpu();
@@ -118,6 +112,7 @@ static void function_trace_reset(struct trace_array *tr)
 {
         tracing_stop_function_trace(tr);
         tracing_stop_cmdline_record();
+        ftrace_reset_array_ops(tr);
 }
 
 static void function_trace_start(struct trace_array *tr)
@@ -199,18 +194,6 @@ function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
         local_irq_restore(flags);
 }
 
-static struct ftrace_ops trace_ops __read_mostly =
-{
-        .func = function_trace_call,
-        .flags = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
-};
-
-static struct ftrace_ops trace_stack_ops __read_mostly =
-{
-        .func = function_stack_trace_call,
-        .flags = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
-};
-
 static struct tracer_opt func_opts[] = {
 #ifdef CONFIG_STACKTRACE
         { TRACER_OPT(func_stack_trace, TRACE_FUNC_OPT_STACK) },
@@ -248,10 +231,10 @@ func_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
                 unregister_ftrace_function(tr->ops);
 
                 if (set) {
-                        tr->ops = &trace_stack_ops;
+                        tr->ops->func = function_stack_trace_call;
                         register_ftrace_function(tr->ops);
                 } else {
-                        tr->ops = &trace_ops;
+                        tr->ops->func = function_trace_call;
                         register_ftrace_function(tr->ops);
                 }
 
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 8ff02cbb892f..b5cb047df3e9 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -151,12 +151,6 @@ irqsoff_tracer_call(unsigned long ip, unsigned long parent_ip,
 
         atomic_dec(&data->disabled);
 }
-
-static struct ftrace_ops trace_ops __read_mostly =
-{
-        .func = irqsoff_tracer_call,
-        .flags = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
-};
 #endif /* CONFIG_FUNCTION_TRACER */
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
@@ -531,7 +525,7 @@ void trace_preempt_off(unsigned long a0, unsigned long a1)
 }
 #endif /* CONFIG_PREEMPT_TRACER */
 
-static int register_irqsoff_function(int graph, int set)
+static int register_irqsoff_function(struct trace_array *tr, int graph, int set)
 {
         int ret;
 
@@ -543,7 +537,7 @@ static int register_irqsoff_function(int graph, int set)
                 ret = register_ftrace_graph(&irqsoff_graph_return,
                                             &irqsoff_graph_entry);
         else
-                ret = register_ftrace_function(&trace_ops);
+                ret = register_ftrace_function(tr->ops);
 
         if (!ret)
                 function_enabled = true;
@@ -551,7 +545,7 @@ static int register_irqsoff_function(int graph, int set)
         return ret;
 }
 
-static void unregister_irqsoff_function(int graph)
+static void unregister_irqsoff_function(struct trace_array *tr, int graph)
 {
         if (!function_enabled)
                 return;
@@ -559,17 +553,17 @@ static void unregister_irqsoff_function(int graph)
         if (graph)
                 unregister_ftrace_graph();
         else
-                unregister_ftrace_function(&trace_ops);
+                unregister_ftrace_function(tr->ops);
 
         function_enabled = false;
 }
 
-static void irqsoff_function_set(int set)
+static void irqsoff_function_set(struct trace_array *tr, int set)
 {
         if (set)
-                register_irqsoff_function(is_graph(), 1);
+                register_irqsoff_function(tr, is_graph(), 1);
         else
-                unregister_irqsoff_function(is_graph());
+                unregister_irqsoff_function(tr, is_graph());
 }
 
 static int irqsoff_flag_changed(struct trace_array *tr, u32 mask, int set)
@@ -577,7 +571,7 @@ static int irqsoff_flag_changed(struct trace_array *tr, u32 mask, int set)
         struct tracer *tracer = tr->current_trace;
 
         if (mask & TRACE_ITER_FUNCTION)
-                irqsoff_function_set(set);
+                irqsoff_function_set(tr, set);
 
         return trace_keep_overwrite(tracer, mask, set);
 }
@@ -586,7 +580,7 @@ static int start_irqsoff_tracer(struct trace_array *tr, int graph)
 {
         int ret;
 
-        ret = register_irqsoff_function(graph, 0);
+        ret = register_irqsoff_function(tr, graph, 0);
 
         if (!ret && tracing_is_enabled())
                 tracer_enabled = 1;
@@ -600,7 +594,7 @@ static void stop_irqsoff_tracer(struct trace_array *tr, int graph)
 {
         tracer_enabled = 0;
 
-        unregister_irqsoff_function(graph);
+        unregister_irqsoff_function(tr, graph);
 }
 
 static void __irqsoff_tracer_init(struct trace_array *tr)
@@ -617,7 +611,11 @@ static void __irqsoff_tracer_init(struct trace_array *tr)
         smp_wmb();
         tracing_reset_online_cpus(&tr->trace_buffer);
 
-        if (start_irqsoff_tracer(tr, is_graph()))
+        ftrace_init_array_ops(tr, irqsoff_tracer_call);
+
+        /* Only toplevel instance supports graph tracing */
+        if (start_irqsoff_tracer(tr, (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
+                                      is_graph())))
                 printk(KERN_ERR "failed to start irqsoff tracer\n");
 }
 
@@ -630,6 +628,7 @@ static void irqsoff_tracer_reset(struct trace_array *tr)
 
         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, lat_flag);
         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, overwrite_flag);
+        ftrace_reset_array_ops(tr);
 }
 
 static void irqsoff_tracer_start(struct trace_array *tr)
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index e14da5e97a69..4dd986defa60 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -130,15 +130,9 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip,
         atomic_dec(&data->disabled);
         preempt_enable_notrace();
 }
-
-static struct ftrace_ops trace_ops __read_mostly =
-{
-        .func = wakeup_tracer_call,
-        .flags = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
-};
 #endif /* CONFIG_FUNCTION_TRACER */
 
-static int register_wakeup_function(int graph, int set)
+static int register_wakeup_function(struct trace_array *tr, int graph, int set)
 {
         int ret;
 
@@ -150,7 +144,7 @@ static int register_wakeup_function(int graph, int set)
                 ret = register_ftrace_graph(&wakeup_graph_return,
                                             &wakeup_graph_entry);
         else
-                ret = register_ftrace_function(&trace_ops);
+                ret = register_ftrace_function(tr->ops);
 
         if (!ret)
                 function_enabled = true;
@@ -158,7 +152,7 @@ static int register_wakeup_function(int graph, int set)
         return ret;
 }
 
-static void unregister_wakeup_function(int graph)
+static void unregister_wakeup_function(struct trace_array *tr, int graph)
 {
         if (!function_enabled)
                 return;
@@ -166,17 +160,17 @@ static void unregister_wakeup_function(int graph)
         if (graph)
                 unregister_ftrace_graph();
         else
-                unregister_ftrace_function(&trace_ops);
+                unregister_ftrace_function(tr->ops);
 
         function_enabled = false;
 }
 
-static void wakeup_function_set(int set)
+static void wakeup_function_set(struct trace_array *tr, int set)
 {
         if (set)
-                register_wakeup_function(is_graph(), 1);
+                register_wakeup_function(tr, is_graph(), 1);
         else
-                unregister_wakeup_function(is_graph());
+                unregister_wakeup_function(tr, is_graph());
 }
 
 static int wakeup_flag_changed(struct trace_array *tr, u32 mask, int set)
@@ -184,16 +178,16 @@ static int wakeup_flag_changed(struct trace_array *tr, u32 mask, int set)
         struct tracer *tracer = tr->current_trace;
 
         if (mask & TRACE_ITER_FUNCTION)
-                wakeup_function_set(set);
+                wakeup_function_set(tr, set);
 
         return trace_keep_overwrite(tracer, mask, set);
 }
 
-static int start_func_tracer(int graph)
+static int start_func_tracer(struct trace_array *tr, int graph)
 {
         int ret;
 
-        ret = register_wakeup_function(graph, 0);
+        ret = register_wakeup_function(tr, graph, 0);
 
         if (!ret && tracing_is_enabled())
                 tracer_enabled = 1;
@@ -203,11 +197,11 @@ static int start_func_tracer(int graph)
         return ret;
 }
 
-static void stop_func_tracer(int graph)
+static void stop_func_tracer(struct trace_array *tr, int graph)
 {
         tracer_enabled = 0;
 
-        unregister_wakeup_function(graph);
+        unregister_wakeup_function(tr, graph);
 }
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
@@ -221,12 +215,12 @@ wakeup_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
         if (!(is_graph() ^ set))
                 return 0;
 
-        stop_func_tracer(!set);
+        stop_func_tracer(tr, !set);
 
         wakeup_reset(wakeup_trace);
         tracing_max_latency = 0;
 
-        return start_func_tracer(set);
+        return start_func_tracer(tr, set);
 }
 
 static int wakeup_graph_entry(struct ftrace_graph_ent *trace)
@@ -587,7 +581,7 @@ static void start_wakeup_tracer(struct trace_array *tr)
          */
         smp_wmb();
 
-        if (start_func_tracer(is_graph()))
+        if (start_func_tracer(tr, is_graph()))
                 printk(KERN_ERR "failed to start wakeup tracer\n");
 
         return;
@@ -600,7 +594,7 @@ fail_deprobe:
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
-        stop_func_tracer(is_graph());
+        stop_func_tracer(tr, is_graph());
         unregister_trace_sched_switch(probe_wakeup_sched_switch, NULL);
         unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
         unregister_trace_sched_wakeup(probe_wakeup, NULL);
@@ -617,6 +611,7 @@ static int __wakeup_tracer_init(struct trace_array *tr)
 
         tracing_max_latency = 0;
         wakeup_trace = tr;
+        ftrace_init_array_ops(tr, wakeup_tracer_call);
         start_wakeup_tracer(tr);
         return 0;
 }
@@ -653,6 +648,7 @@ static void wakeup_tracer_reset(struct trace_array *tr)
 
         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, lat_flag);
         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, overwrite_flag);
+        ftrace_reset_array_ops(tr);
 }
 
 static void wakeup_tracer_start(struct trace_array *tr)
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index e98fca60974f..519d04affe38 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -161,11 +161,6 @@ static struct ftrace_ops test_probe3 = {
         .flags                  = FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
-static struct ftrace_ops test_global = {
-        .func           = trace_selftest_test_global_func,
-        .flags          = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
-};
-
 static void print_counts(void)
 {
         printk("(%d %d %d %d %d) ",
@@ -185,7 +180,7 @@ static void reset_counts(void)
         trace_selftest_test_dyn_cnt = 0;
 }
 
-static int trace_selftest_ops(int cnt)
+static int trace_selftest_ops(struct trace_array *tr, int cnt)
 {
         int save_ftrace_enabled = ftrace_enabled;
         struct ftrace_ops *dyn_ops;
@@ -220,7 +215,11 @@ static int trace_selftest_ops(int cnt)
         register_ftrace_function(&test_probe1);
         register_ftrace_function(&test_probe2);
         register_ftrace_function(&test_probe3);
-        register_ftrace_function(&test_global);
+        /* First time we are running with main function */
+        if (cnt > 1) {
+                ftrace_init_array_ops(tr, trace_selftest_test_global_func);
+                register_ftrace_function(tr->ops);
+        }
 
         DYN_FTRACE_TEST_NAME();
 
@@ -232,8 +231,10 @@ static int trace_selftest_ops(int cnt)
                 goto out;
         if (trace_selftest_test_probe3_cnt != 1)
                 goto out;
-        if (trace_selftest_test_global_cnt == 0)
-                goto out;
+        if (cnt > 1) {
+                if (trace_selftest_test_global_cnt == 0)
+                        goto out;
+        }
 
         DYN_FTRACE_TEST_NAME2();
 
@@ -269,8 +270,10 @@ static int trace_selftest_ops(int cnt)
                 goto out_free;
         if (trace_selftest_test_probe3_cnt != 3)
                 goto out_free;
-        if (trace_selftest_test_global_cnt == 0)
-                goto out;
+        if (cnt > 1) {
+                if (trace_selftest_test_global_cnt == 0)
+                        goto out;
+        }
         if (trace_selftest_test_dyn_cnt == 0)
                 goto out_free;
 
@@ -295,7 +298,9 @@ static int trace_selftest_ops(int cnt)
         unregister_ftrace_function(&test_probe1);
         unregister_ftrace_function(&test_probe2);
         unregister_ftrace_function(&test_probe3);
-        unregister_ftrace_function(&test_global);
+        if (cnt > 1)
+                unregister_ftrace_function(tr->ops);
+        ftrace_reset_array_ops(tr);
 
         /* Make sure everything is off */
         reset_counts();
@@ -388,7 +393,7 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         }
 
         /* Test the ops with global tracing running */
-        ret = trace_selftest_ops(1);
+        ret = trace_selftest_ops(tr, 1);
         trace->reset(tr);
 
  out:
@@ -399,7 +404,7 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
 
         /* Test the ops with global tracing off */
         if (!ret)
-                ret = trace_selftest_ops(2);
+                ret = trace_selftest_ops(tr, 2);
 
         return ret;
 }