Merge tag 'trace-v4.4' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace

Pull tracking updates from Steven Rostedt:
 "Most of the changes are clean ups and small fixes.  Some of them have
  stable tags to them.  I searched through my INBOX just as the merge
  window opened and found lots of patches to pull.  I ran them through
  all my tests and they were in linux-next for a few days.

  Features added this release:
  ----------------------------

   - Module globbing.  You can now filter function tracing to several
     modules.  # echo '*:mod:*snd*' > set_ftrace_filter (Dmitry Safonov)

   - Tracer specific options are now visible even when the tracer is not
     active.  It was rather annoying that you can only see and modify
     tracer options after enabling the tracer.  Now they are in the
     options/ directory even when the tracer is not active.  Although
     they are still only visible when the tracer is active in the
     trace_options file.

   - Trace options are now per instance (although some of the tracer
     specific options are global)

   - New tracefs file: set_event_pid.  If any pid is added to this file,
     then all events in the instance will filter out events that are not
     part of this pid.  sched_switch and sched_wakeup events handle next
     and the wakee pids"

* tag 'trace-v4.4' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (68 commits)
  tracefs: Fix refcount imbalance in start_creating()
  tracing: Put back comma for empty fields in boot string parsing
  tracing: Apply tracer specific options from kernel command line.
  tracing: Add some documentation about set_event_pid
  ring_buffer: Remove unneeded smp_wmb() before wakeup of reader benchmark
  tracing: Allow dumping traces without tracking trace started cpus
  ring_buffer: Fix more races when terminating the producer in the benchmark
  ring_buffer: Do no not complete benchmark reader too early
  tracing: Remove redundant TP_ARGS redefining
  tracing: Rename max_stack_lock to stack_trace_max_lock
  tracing: Allow arch-specific stack tracer
  recordmcount: arm64: Replace the ignored mcount call into nop
  recordmcount: Fix endianness handling bug for nop_mcount
  tracepoints: Fix documentation of RCU lockdep checks
  tracing: ftrace_event_is_function() can return boolean
  tracing: is_legal_op() can return boolean
  ring-buffer: rb_event_is_commit() can return boolean
  ring-buffer: rb_per_cpu_empty() can return boolean
  ring_buffer: ring_buffer_empty{cpu}() can return boolean
  ring-buffer: rb_is_reader_page() can return boolean
  ...

1 files changed, 44 insertions, 35 deletions

diff --git a/kernel/trace/ring_buffer_benchmark.c b/kernel/trace/ring_buffer_benchmark.c
index a1503a027ee2..6df9a83e20d7 100644
--- a/kernel/trace/ring_buffer_benchmark.c
+++ b/kernel/trace/ring_buffer_benchmark.c
@@ -24,8 +24,8 @@ struct rb_page {
 static int wakeup_interval = 100;
 
 static int reader_finish;
-static struct completion read_start;
-static struct completion read_done;
+static DECLARE_COMPLETION(read_start);
+static DECLARE_COMPLETION(read_done);
 
 static struct ring_buffer *buffer;
 static struct task_struct *producer;
@@ -60,12 +60,12 @@ MODULE_PARM_DESC(consumer_fifo, "fifo prio for consumer");
 
 static int read_events;
 
-static int kill_test;
+static int test_error;
 
-#define KILL_TEST()                             \
+#define TEST_ERROR()                            \
         do {                                    \
-                if (!kill_test) {               \
-                        kill_test = 1;          \
+                if (!test_error) {              \
+                        test_error = 1;         \
                         WARN_ON(1);             \
                 }                               \
         } while (0)
@@ -75,6 +75,11 @@ enum event_status {
         EVENT_DROPPED,
 };
 
+static bool break_test(void)
+{
+        return test_error || kthread_should_stop();
+}
+
 static enum event_status read_event(int cpu)
 {
         struct ring_buffer_event *event;
@@ -87,7 +92,7 @@ static enum event_status read_event(int cpu)
 
         entry = ring_buffer_event_data(event);
         if (*entry != cpu) {
-                KILL_TEST();
+                TEST_ERROR();
                 return EVENT_DROPPED;
         }
 
@@ -115,10 +120,10 @@ static enum event_status read_page(int cpu)
                 rpage = bpage;
                 /* The commit may have missed event flags set, clear them */
                 commit = local_read(&rpage->commit) & 0xfffff;
-                for (i = 0; i < commit && !kill_test; i += inc) {
+                for (i = 0; i < commit && !test_error ; i += inc) {
 
                         if (i >= (PAGE_SIZE - offsetof(struct rb_page, data))) {
-                                KILL_TEST();
+                                TEST_ERROR();
                                 break;
                         }
 
@@ -128,7 +133,7 @@ static enum event_status read_page(int cpu)
                         case RINGBUF_TYPE_PADDING:
                                 /* failed writes may be discarded events */
                                 if (!event->time_delta)
-                                        KILL_TEST();
+                                        TEST_ERROR();
                                 inc = event->array[0] + 4;
                                 break;
                         case RINGBUF_TYPE_TIME_EXTEND:
@@ -137,12 +142,12 @@ static enum event_status read_page(int cpu)
                         case 0:
                                 entry = ring_buffer_event_data(event);
                                 if (*entry != cpu) {
-                                        KILL_TEST();
+                                        TEST_ERROR();
                                         break;
                                 }
                                 read++;
                                 if (!event->array[0]) {
-                                        KILL_TEST();
+                                        TEST_ERROR();
                                         break;
                                 }
                                 inc = event->array[0] + 4;
@@ -150,17 +155,17 @@ static enum event_status read_page(int cpu)
                         default:
                                 entry = ring_buffer_event_data(event);
                                 if (*entry != cpu) {
-                                        KILL_TEST();
+                                        TEST_ERROR();
                                         break;
                                 }
                                 read++;
                                 inc = ((event->type_len + 1) * 4);
                         }
-                        if (kill_test)
+                        if (test_error)
                                 break;
 
                         if (inc <= 0) {
-                                KILL_TEST();
+                                TEST_ERROR();
                                 break;
                         }
                 }
@@ -178,10 +183,14 @@ static void ring_buffer_consumer(void)
         read_events ^= 1;
 
         read = 0;
-        while (!reader_finish && !kill_test) {
-                int found;
+        /*
+         * Continue running until the producer specifically asks to stop
+         * and is ready for the completion.
+         */
+        while (!READ_ONCE(reader_finish)) {
+                int found = 1;
 
-                do {
+                while (found && !test_error) {
                         int cpu;
 
                         found = 0;
@@ -193,19 +202,25 @@ static void ring_buffer_consumer(void)
                                 else
                                         stat = read_page(cpu);
 
-                                if (kill_test)
+                                if (test_error)
                                         break;
+
                                 if (stat == EVENT_FOUND)
                                         found = 1;
+
                         }
-                } while (found && !kill_test);
+                }
 
+                /* Wait till the producer wakes us up when there is more data
+                 * available or when the producer wants us to finish reading.
+                 */
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (reader_finish)
                         break;
 
                 schedule();
         }
+        __set_current_state(TASK_RUNNING);
         reader_finish = 0;
         complete(&read_done);
 }
@@ -263,10 +278,7 @@ static void ring_buffer_producer(void)
                 if (cnt % wakeup_interval)
                         cond_resched();
 #endif
-                if (kthread_should_stop())
-                        kill_test = 1;
-
-        } while (ktime_before(end_time, timeout) && !kill_test);
+        } while (ktime_before(end_time, timeout) && !break_test());
         trace_printk("End ring buffer hammer\n");
 
         if (consumer) {
@@ -276,8 +288,6 @@ static void ring_buffer_producer(void)
                 /* the completions must be visible before the finish var */
                 smp_wmb();
                 reader_finish = 1;
-                /* finish var visible before waking up the consumer */
-                smp_wmb();
                 wake_up_process(consumer);
                 wait_for_completion(&read_done);
         }
@@ -287,7 +297,7 @@ static void ring_buffer_producer(void)
         entries = ring_buffer_entries(buffer);
         overruns = ring_buffer_overruns(buffer);
 
-        if (kill_test && !kthread_should_stop())
+        if (test_error)
                 trace_printk("ERROR!\n");
 
         if (!disable_reader) {
@@ -368,15 +378,14 @@ static void wait_to_die(void)
 
 static int ring_buffer_consumer_thread(void *arg)
 {
-        while (!kthread_should_stop() && !kill_test) {
+        while (!break_test()) {
                 complete(&read_start);
 
                 ring_buffer_consumer();
 
                 set_current_state(TASK_INTERRUPTIBLE);
-                if (kthread_should_stop() || kill_test)
+                if (break_test())
                         break;
-
                 schedule();
         }
         __set_current_state(TASK_RUNNING);
@@ -389,27 +398,27 @@ static int ring_buffer_consumer_thread(void *arg)
 
 static int ring_buffer_producer_thread(void *arg)
 {
-        init_completion(&read_start);
-
-        while (!kthread_should_stop() && !kill_test) {
+        while (!break_test()) {
                 ring_buffer_reset(buffer);
 
                 if (consumer) {
-                        smp_wmb();
                         wake_up_process(consumer);
                         wait_for_completion(&read_start);
                 }
 
                 ring_buffer_producer();
-                if (kill_test)
+                if (break_test())
                         goto out_kill;
 
                 trace_printk("Sleeping for 10 secs\n");
                 set_current_state(TASK_INTERRUPTIBLE);
+                if (break_test())
+                        goto out_kill;
                 schedule_timeout(HZ * SLEEP_TIME);
         }
 
 out_kill:
+        __set_current_state(TASK_RUNNING);
         if (!kthread_should_stop())
                 wait_to_die();