Merge branch 'linus' into timers/urgent

Get upstream changes so we can apply fixes against them

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

1 files changed, 34 insertions, 4 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 6c508ff33c62..67708f46baae 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -413,6 +413,17 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         return 0;
 }
 
+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 int __unregister_ftrace_function(struct ftrace_ops *ops)
 {
         int ret;
@@ -440,8 +451,12 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
                          * so there'll be no new users. We must ensure
                          * all current users are done before we free
                          * the control data.
+                         * Note synchronize_sched() is not enough, as we
+                         * use preempt_disable() to do RCU, but the function
+                         * tracer can be called where RCU is not active
+                         * (before user_exit()).
                          */
-                        synchronize_sched();
+                        schedule_on_each_cpu(ftrace_sync);
                         control_ops_free(ops);
                 }
         } else
@@ -456,9 +471,13 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
         /*
          * Dynamic ops may be freed, we must make sure that all
          * callers are done before leaving this function.
+         *
+         * Again, normal synchronize_sched() is not good enough.
+         * We need to do a hard force of sched synchronization.
          */
         if (ops->flags & FTRACE_OPS_FL_DYNAMIC)
-                synchronize_sched();
+                schedule_on_each_cpu(ftrace_sync);
+
 
         return 0;
 }
@@ -622,12 +641,18 @@ static int function_stat_show(struct seq_file *m, void *v)
         if (rec->counter <= 1)
                 stddev = 0;
         else {
-                stddev = rec->time_squared - rec->counter * avg * avg;
+                /*
+                 * Apply Welford's method:
+                 * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2)
+                 */
+                stddev = rec->counter * rec->time_squared -
+                         rec->time * rec->time;
+
                 /*
                  * Divide only 1000 for ns^2 -> us^2 conversion.
                  * trace_print_graph_duration will divide 1000 again.
                  */
-                do_div(stddev, (rec->counter - 1) * 1000);
+                do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
         }
 
         trace_seq_init(&s);
@@ -3512,8 +3537,12 @@ EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
 static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
 static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
 
+/* Used by function selftest to not test if filter is set */
+bool ftrace_filter_param __initdata;
+
 static int __init set_ftrace_notrace(char *str)
 {
+        ftrace_filter_param = true;
         strlcpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE);
         return 1;
 }
@@ -3521,6 +3550,7 @@ __setup("ftrace_notrace=", set_ftrace_notrace);
 
 static int __init set_ftrace_filter(char *str)
 {
+        ftrace_filter_param = true;
         strlcpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE);
         return 1;
 }