1 files changed, 48 insertions, 51 deletions

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 1f0c509b40d3..f71fb2a08950 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -33,6 +33,7 @@
 #include <linux/kallsyms.h>
 #include <linux/debug_locks.h>
 #include <linux/lockdep.h>
+#include <trace/workqueue.h>
 
 /*
  * The per-CPU workqueue (if single thread, we always use the first
@@ -48,8 +49,6 @@ struct cpu_workqueue_struct {
 
         struct workqueue_struct *wq;
         struct task_struct *thread;
-
-        int run_depth;          /* Detect run_workqueue() recursion depth */
 } ____cacheline_aligned;
 
 /*
@@ -125,9 +124,13 @@ struct cpu_workqueue_struct *get_wq_data(struct work_struct *work)
         return (void *) (atomic_long_read(&work->data) & WORK_STRUCT_WQ_DATA_MASK);
 }
 
+DEFINE_TRACE(workqueue_insertion);
+
 static void insert_work(struct cpu_workqueue_struct *cwq,
                         struct work_struct *work, struct list_head *head)
 {
+        trace_workqueue_insertion(cwq->thread, work);
+
         set_wq_data(work, cwq);
         /*
          * Ensure that we get the right work->data if we see the
@@ -259,16 +262,11 @@ int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
 }
 EXPORT_SYMBOL_GPL(queue_delayed_work_on);
 
+DEFINE_TRACE(workqueue_execution);
+
 static void run_workqueue(struct cpu_workqueue_struct *cwq)
 {
         spin_lock_irq(&cwq->lock);
-        cwq->run_depth++;
-        if (cwq->run_depth > 3) {
-                /* morton gets to eat his hat */
-                printk("%s: recursion depth exceeded: %d\n",
-                        __func__, cwq->run_depth);
-                dump_stack();
-        }
         while (!list_empty(&cwq->worklist)) {
                 struct work_struct *work = list_entry(cwq->worklist.next,
                                                 struct work_struct, entry);
@@ -284,7 +282,7 @@ static void run_workqueue(struct cpu_workqueue_struct *cwq)
                  */
                 struct lockdep_map lockdep_map = work->lockdep_map;
 #endif
-
+                trace_workqueue_execution(cwq->thread, work);
                 cwq->current_work = work;
                 list_del_init(cwq->worklist.next);
                 spin_unlock_irq(&cwq->lock);
@@ -311,7 +309,6 @@ static void run_workqueue(struct cpu_workqueue_struct *cwq)
                 spin_lock_irq(&cwq->lock);
                 cwq->current_work = NULL;
         }
-        cwq->run_depth--;
         spin_unlock_irq(&cwq->lock);
 }
 
@@ -368,29 +365,20 @@ static void insert_wq_barrier(struct cpu_workqueue_struct *cwq,
 
 static int flush_cpu_workqueue(struct cpu_workqueue_struct *cwq)
 {
-        int active;
-
-        if (cwq->thread == current) {
-                /*
-                 * Probably keventd trying to flush its own queue. So simply run
-                 * it by hand rather than deadlocking.
-                 */
-                run_workqueue(cwq);
-                active = 1;
-        } else {
-                struct wq_barrier barr;
+        int active = 0;
+        struct wq_barrier barr;
 
-                active = 0;
-                spin_lock_irq(&cwq->lock);
-                if (!list_empty(&cwq->worklist) || cwq->current_work != NULL) {
-                        insert_wq_barrier(cwq, &barr, &cwq->worklist);
-                        active = 1;
-                }
-                spin_unlock_irq(&cwq->lock);
+        WARN_ON(cwq->thread == current);
 
-                if (active)
-                        wait_for_completion(&barr.done);
+        spin_lock_irq(&cwq->lock);
+        if (!list_empty(&cwq->worklist) || cwq->current_work != NULL) {
+                insert_wq_barrier(cwq, &barr, &cwq->worklist);
+                active = 1;
         }
+        spin_unlock_irq(&cwq->lock);
+
+        if (active)
+                wait_for_completion(&barr.done);
 
         return active;
 }
@@ -416,7 +404,7 @@ void flush_workqueue(struct workqueue_struct *wq)
         might_sleep();
         lock_map_acquire(&wq->lockdep_map);
         lock_map_release(&wq->lockdep_map);
-        for_each_cpu_mask_nr(cpu, *cpu_map)
+        for_each_cpu(cpu, cpu_map)
                 flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, cpu));
 }
 EXPORT_SYMBOL_GPL(flush_workqueue);
@@ -547,7 +535,7 @@ static void wait_on_work(struct work_struct *work)
         wq = cwq->wq;
         cpu_map = wq_cpu_map(wq);
 
-        for_each_cpu_mask_nr(cpu, *cpu_map)
+        for_each_cpu(cpu, cpu_map)
                 wait_on_cpu_work(per_cpu_ptr(wq->cpu_wq, cpu), work);
 }
 
@@ -765,6 +753,8 @@ init_cpu_workqueue(struct workqueue_struct *wq, int cpu)
         return cwq;
 }
 
+DEFINE_TRACE(workqueue_creation);
+
 static int create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu)
 {
         struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
@@ -787,6 +777,8 @@ static int create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu)
                 sched_setscheduler_nocheck(p, SCHED_FIFO, &param);
         cwq->thread = p;
 
+        trace_workqueue_creation(cwq->thread, cpu);
+
         return 0;
 }
 
@@ -868,6 +860,8 @@ struct workqueue_struct *__create_workqueue_key(const char *name,
 }
 EXPORT_SYMBOL_GPL(__create_workqueue_key);
 
+DEFINE_TRACE(workqueue_destruction);
+
 static void cleanup_workqueue_thread(struct cpu_workqueue_struct *cwq)
 {
         /*
@@ -891,6 +885,7 @@ static void cleanup_workqueue_thread(struct cpu_workqueue_struct *cwq)
          * checks list_empty(), and a "normal" queue_work() can't use
          * a dead CPU.
          */
+        trace_workqueue_destruction(cwq->thread);
         kthread_stop(cwq->thread);
         cwq->thread = NULL;
 }
@@ -911,7 +906,7 @@ void destroy_workqueue(struct workqueue_struct *wq)
         list_del(&wq->list);
         spin_unlock(&workqueue_lock);
 
-        for_each_cpu_mask_nr(cpu, *cpu_map)
+        for_each_cpu(cpu, cpu_map)
                 cleanup_workqueue_thread(per_cpu_ptr(wq->cpu_wq, cpu));
         cpu_maps_update_done();
 
@@ -971,20 +966,20 @@ undo:
 }
 
 #ifdef CONFIG_SMP
-static struct workqueue_struct *work_on_cpu_wq __read_mostly;
 
 struct work_for_cpu {
-        struct work_struct work;
+        struct completion completion;
         long (*fn)(void *);
         void *arg;
         long ret;
 };
 
-static void do_work_for_cpu(struct work_struct *w)
+static int do_work_for_cpu(void *_wfc)
 {
-        struct work_for_cpu *wfc = container_of(w, struct work_for_cpu, work);
-
+        struct work_for_cpu *wfc = _wfc;
         wfc->ret = wfc->fn(wfc->arg);
+        complete(&wfc->completion);
+        return 0;
 }
 
 /**
@@ -995,17 +990,23 @@ static void do_work_for_cpu(struct work_struct *w)
  *
  * This will return the value @fn returns.
  * It is up to the caller to ensure that the cpu doesn't go offline.
+ * The caller must not hold any locks which would prevent @fn from completing.
  */
 long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
 {
-        struct work_for_cpu wfc;
-
-        INIT_WORK(&wfc.work, do_work_for_cpu);
-        wfc.fn = fn;
-        wfc.arg = arg;
-        queue_work_on(cpu, work_on_cpu_wq, &wfc.work);
-        flush_work(&wfc.work);
-
+        struct task_struct *sub_thread;
+        struct work_for_cpu wfc = {
+                .completion = COMPLETION_INITIALIZER_ONSTACK(wfc.completion),
+                .fn = fn,
+                .arg = arg,
+        };
+
+        sub_thread = kthread_create(do_work_for_cpu, &wfc, "work_for_cpu");
+        if (IS_ERR(sub_thread))
+                return PTR_ERR(sub_thread);
+        kthread_bind(sub_thread, cpu);
+        wake_up_process(sub_thread);
+        wait_for_completion(&wfc.completion);
         return wfc.ret;
 }
 EXPORT_SYMBOL_GPL(work_on_cpu);
@@ -1021,8 +1022,4 @@ void __init init_workqueues(void)
         hotcpu_notifier(workqueue_cpu_callback, 0);
         keventd_wq = create_workqueue("events");
         BUG_ON(!keventd_wq);
-#ifdef CONFIG_SMP
-        work_on_cpu_wq = create_workqueue("work_on_cpu");
-        BUG_ON(!work_on_cpu_wq);
-#endif
 }