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();