ftrace: Synchronize setting function_trace_op with ftrace_trace_function

commit 405e1d834807e51b2ebd3dea81cb51e53fb61504 upstream.

ftrace_trace_function is a variable that holds what function will be called
directly by the assembly code (mcount). If just a single function is
registered and it handles recursion itself, then the assembly will call that
function directly without any helper function. It also passes in the
ftrace_op that was registered with the callback. The ftrace_op to send is
stored in the function_trace_op variable.

The ftrace_trace_function and function_trace_op needs to be coordinated such
that the called callback wont be called with the wrong ftrace_op, otherwise
bad things can happen if it expected a different op. Luckily, there's no
callback that doesn't use the helper functions that requires this. But
there soon will be and this needs to be fixed.

Use a set_function_trace_op to store the ftrace_op to set the
function_trace_op to when it is safe to do so (during the update function
within the breakpoint or stop machine calls). Or if dynamic ftrace is not
being used (static tracing) then we have to do a bit more synchronization
when the ftrace_trace_function is set as that takes affect immediately
(as oppose to dynamic ftrace doing it with the modification of the trampoline).

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 72 insertions, 4 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index d0c5c3f0d939..fc21312dad6d 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -85,6 +85,8 @@ int function_trace_stop __read_mostly;
 
 /* Current function tracing op */
 struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end;
+/* What to set function_trace_op to */
+static struct ftrace_ops *set_function_trace_op;
 
 /* List for set_ftrace_pid's pids. */
 LIST_HEAD(ftrace_pids);
@@ -278,6 +280,23 @@ static void update_global_ops(void)
         global_ops.func = func;
 }
 
+static void ftrace_sync(struct work_struct *work)
+{
+        /*
+         * This function is just a stub to implement a hard force
+         * of synchronize_sched(). This requires synchronizing
+         * tasks even in userspace and idle.
+         *
+         * Yes, function tracing is rude.
+         */
+}
+
+static void ftrace_sync_ipi(void *data)
+{
+        /* Probably not needed, but do it anyway */
+        smp_rmb();
+}
+
 static void update_ftrace_function(void)
 {
         ftrace_func_t func;
@@ -296,16 +315,59 @@ static void update_ftrace_function(void)
              !FTRACE_FORCE_LIST_FUNC)) {
                 /* Set the ftrace_ops that the arch callback uses */
                 if (ftrace_ops_list == &global_ops)
-                        function_trace_op = ftrace_global_list;
+                        set_function_trace_op = ftrace_global_list;
                 else
-                        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 */
-                function_trace_op = &ftrace_list_end;
+                set_function_trace_op = &ftrace_list_end;
                 func = ftrace_ops_list_func;
         }
 
+        /* If there's no change, then do nothing more here */
+        if (ftrace_trace_function == func)
+                return;
+
+        /*
+         * If we are using the list function, it doesn't care
+         * about the function_trace_ops.
+         */
+        if (func == ftrace_ops_list_func) {
+                ftrace_trace_function = func;
+                /*
+                 * Don't even bother setting function_trace_ops,
+                 * it would be racy to do so anyway.
+                 */
+                return;
+        }
+
+#ifndef CONFIG_DYNAMIC_FTRACE
+        /*
+         * For static tracing, we need to be a bit more careful.
+         * The function change takes affect immediately. Thus,
+         * we need to coorditate the setting of the function_trace_ops
+         * with the setting of the ftrace_trace_function.
+         *
+         * Set the function to the list ops, which will call the
+         * function we want, albeit indirectly, but it handles the
+         * ftrace_ops and doesn't depend on function_trace_op.
+         */
+        ftrace_trace_function = ftrace_ops_list_func;
+        /*
+         * Make sure all CPUs see this. Yes this is slow, but static
+         * tracing is slow and nasty to have enabled.
+         */
+        schedule_on_each_cpu(ftrace_sync);
+        /* Now all cpus are using the list ops. */
+        function_trace_op = set_function_trace_op;
+        /* Make sure the function_trace_op is visible on all CPUs */
+        smp_wmb();
+        /* Nasty way to force a rmb on all cpus */
+        smp_call_function(ftrace_sync_ipi, NULL, 1);
+        /* OK, we are all set to update the ftrace_trace_function now! */
+#endif /* !CONFIG_DYNAMIC_FTRACE */
+
         ftrace_trace_function = func;
 }
 
@@ -1952,8 +2014,14 @@ void ftrace_modify_all_code(int command)
         else if (command & FTRACE_DISABLE_CALLS)
                 ftrace_replace_code(0);
 
-        if (command & FTRACE_UPDATE_TRACE_FUNC)
+        if (command & FTRACE_UPDATE_TRACE_FUNC) {
+                function_trace_op = set_function_trace_op;
+                smp_wmb();
+                /* If irqs are disabled, we are in stop machine */
+                if (!irqs_disabled())
+                        smp_call_function(ftrace_sync_ipi, NULL, 1);
                 ftrace_update_ftrace_func(ftrace_trace_function);
+        }
 
         if (command & FTRACE_START_FUNC_RET)
                 ftrace_enable_ftrace_graph_caller();