Merge tag 'trace-3.18-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt...
authorLinus Torvalds <torvalds@linux-foundation.org>
Sun, 12 Oct 2014 11:28:55 +0000 (07:28 -0400)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sun, 12 Oct 2014 11:28:55 +0000 (07:28 -0400)
Pull tracing fixes from Steven Rostedt:
 "Seems that Peter Zijlstra added a new check that is making old code
  scream nasty warnings:

    WARNING: CPU: 0 PID: 91 at kernel/sched/core.c:7253 __might_sleep+0x9a/0x378()
    do not call blocking ops when !TASK_RUNNING; state=1 set at [<ffffffff8d79b511>] event_test_thread+0x48/0x93
    Call Trace:
      __might_sleep+0x9a/0x378
      down_read+0x26/0x98
      exit_signals+0x27/0x1c2
      do_exit+0x193/0x10bd
      kthread+0x156/0x156
      ret_from_fork+0x7a/0xb0

  These are triggered by some self tests that run at start up when
  configure in.  Although the code is technically correct, they are a
  little sloppy and not very robust.  They work now because it runs at
  boot up and the tests do not call anything that might trigger a
  spurious wake up.  But that doesn't mean those tests wont change in
  the future.

  It's best to clean them now to make sure the tests used to test the
  internal workings of the system don't cause breakage themselves.

  This also quiets the warnings made by the new checks"

* tag 'trace-3.18-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace:
  tracing: Clean up scheduling in trace_wakeup_test_thread()
  tracing: Robustify wait loop

kernel/trace/trace_events.c
kernel/trace/trace_selftest.c

index ef06ce7e9cf8d1d9b6ea78240f69c5d44ff426dc..0cc51edde3a899bf464fecbccb98e5eb35d71d42 100644 (file)
@@ -2513,8 +2513,11 @@ static __init int event_test_thread(void *unused)
        kfree(test_malloc);
 
        set_current_state(TASK_INTERRUPTIBLE);
-       while (!kthread_should_stop())
+       while (!kthread_should_stop()) {
                schedule();
+               set_current_state(TASK_INTERRUPTIBLE);
+       }
+       __set_current_state(TASK_RUNNING);
 
        return 0;
 }
index 61a6acd6025d9ec9f32cbea4f11b74500744001f..b0f86ea77881ecf3c6fbb626f298df3d25c57a48 100644 (file)
@@ -1029,6 +1029,12 @@ trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
 #endif
 
 #ifdef CONFIG_SCHED_TRACER
+
+struct wakeup_test_data {
+       struct completion       is_ready;
+       int                     go;
+};
+
 static int trace_wakeup_test_thread(void *data)
 {
        /* Make this a -deadline thread */
@@ -1038,51 +1044,56 @@ static int trace_wakeup_test_thread(void *data)
                .sched_deadline = 10000000ULL,
                .sched_period = 10000000ULL
        };
-       struct completion *x = data;
+       struct wakeup_test_data *x = data;
 
        sched_setattr(current, &attr);
 
        /* Make it know we have a new prio */
-       complete(x);
+       complete(&x->is_ready);
 
        /* now go to sleep and let the test wake us up */
        set_current_state(TASK_INTERRUPTIBLE);
-       schedule();
+       while (!x->go) {
+               schedule();
+               set_current_state(TASK_INTERRUPTIBLE);
+       }
 
-       complete(x);
+       complete(&x->is_ready);
+
+       set_current_state(TASK_INTERRUPTIBLE);
 
        /* we are awake, now wait to disappear */
        while (!kthread_should_stop()) {
-               /*
-                * This will likely be the system top priority
-                * task, do short sleeps to let others run.
-                */
-               msleep(100);
+               schedule();
+               set_current_state(TASK_INTERRUPTIBLE);
        }
 
+       __set_current_state(TASK_RUNNING);
+
        return 0;
 }
-
 int
 trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
 {
        unsigned long save_max = tr->max_latency;
        struct task_struct *p;
-       struct completion is_ready;
+       struct wakeup_test_data data;
        unsigned long count;
        int ret;
 
-       init_completion(&is_ready);
+       memset(&data, 0, sizeof(data));
+
+       init_completion(&data.is_ready);
 
        /* create a -deadline thread */
-       p = kthread_run(trace_wakeup_test_thread, &is_ready, "ftrace-test");
+       p = kthread_run(trace_wakeup_test_thread, &data, "ftrace-test");
        if (IS_ERR(p)) {
                printk(KERN_CONT "Failed to create ftrace wakeup test thread ");
                return -1;
        }
 
        /* make sure the thread is running at -deadline policy */
-       wait_for_completion(&is_ready);
+       wait_for_completion(&data.is_ready);
 
        /* start the tracing */
        ret = tracer_init(trace, tr);
@@ -1103,18 +1114,20 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
                msleep(100);
        }
 
-       init_completion(&is_ready);
+       init_completion(&data.is_ready);
+
+       data.go = 1;
+       /* memory barrier is in the wake_up_process() */
 
        wake_up_process(p);
 
        /* Wait for the task to wake up */
-       wait_for_completion(&is_ready);
+       wait_for_completion(&data.is_ready);
 
        /* stop the tracing. */
        tracing_stop();
        /* check both trace buffers */
        ret = trace_test_buffer(&tr->trace_buffer, NULL);
-       printk("ret = %d\n", ret);
        if (!ret)
                ret = trace_test_buffer(&tr->max_buffer, &count);