Merge branch 'tip/perf/core-2' of git://git.kernel.org/pub/scm/linux/kernel/git/roste...

Pull ftrace fixlets from Steve Rostedt.

Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 49491fa7daa2d35546a6e5ba46d73103594c384e..b32ed0e385a59b40b971bd04e0e374d333992749 100644 (file)
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -2816,7 +2816,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_record_enable);
  * to the buffer after this will fail and return NULL.
  *
  * This is different than ring_buffer_record_disable() as
- * it works like an on/off switch, where as the disable() verison
+ * it works like an on/off switch, where as the disable() version
  * must be paired with a enable().
  */
 void ring_buffer_record_off(struct ring_buffer *buffer)
@@ -2839,7 +2839,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_record_off);
  * ring_buffer_record_off().
  *
  * This is different than ring_buffer_record_enable() as
- * it works like an on/off switch, where as the enable() verison
+ * it works like an on/off switch, where as the enable() version
  * must be paired with a disable().
  */
 void ring_buffer_record_on(struct ring_buffer *buffer)

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 5c38c81496ceb7d3b6b1e1aa457a2cf0c5752c52..08acf42e325b1276fe54205a3f42f656a0b6fe9d 100644 (file)
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -426,15 +426,15 @@ __setup("trace_buf_size=", set_buf_size);
 
 static int __init set_tracing_thresh(char *str)
 {
-       unsigned long threshhold;
+       unsigned long threshold;
        int ret;
 
        if (!str)
                return 0;
-       ret = strict_strtoul(str, 0, &threshhold);
+       ret = strict_strtoul(str, 0, &threshold);
        if (ret < 0)
                return 0;
-       tracing_thresh = threshhold * 1000;
+       tracing_thresh = threshold * 1000;
        return 1;
 }
 __setup("tracing_thresh=", set_tracing_thresh);

diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 431dba8b754214ee06b4d7163dc3abd91b2718b5..c154797a7ff7afa80f5d79571eae87fb609eec19 100644 (file)
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -2002,7 +2002,7 @@ static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,
 static int __ftrace_function_set_filter(int filter, char *buf, int len,
                                        struct function_filter_data *data)
 {
-       int i, re_cnt, ret;
+       int i, re_cnt, ret = -EINVAL;
        int *reset;
        char **re;
 

diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 1003a4d5eb2522053ab54770477f01581b7087ef..2c00a691a54068ec9db750f2be4053701bd5be65 100644 (file)
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -1041,6 +1041,8 @@ static int trace_wakeup_test_thread(void *data)
        set_current_state(TASK_INTERRUPTIBLE);
        schedule();
 
+       complete(x);
+
        /* we are awake, now wait to disappear */
        while (!kthread_should_stop()) {
                /*
@@ -1084,24 +1086,21 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
        /* reset the max latency */
        tracing_max_latency = 0;
 
-       /* sleep to let the RT thread sleep too */
-       msleep(100);
+       while (p->on_rq) {
+               /*
+                * Sleep to make sure the RT thread is asleep too.
+                * On virtual machines we can't rely on timings,
+                * but we want to make sure this test still works.
+                */
+               msleep(100);
+       }
 
-       /*
-        * Yes this is slightly racy. It is possible that for some
-        * strange reason that the RT thread we created, did not
-        * call schedule for 100ms after doing the completion,
-        * and we do a wakeup on a task that already is awake.
-        * But that is extremely unlikely, and the worst thing that
-        * happens in such a case, is that we disable tracing.
-        * Honestly, if this race does happen something is horrible
-        * wrong with the system.
-        */
+       init_completion(&isrt);
 
        wake_up_process(p);
 
-       /* give a little time to let the thread wake up */
-       msleep(100);
+       /* Wait for the task to wake up */
+       wait_for_completion(&isrt);
 
        /* stop the tracing. */
        tracing_stop();