1 files changed, 24 insertions, 13 deletions

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index ec7e4f62aaff..4048e92aa04f 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -290,11 +290,11 @@ static void run_workqueue(struct cpu_workqueue_struct *cwq)
 
                 BUG_ON(get_wq_data(work) != cwq);
                 work_clear_pending(work);
-                lock_acquire(&cwq->wq->lockdep_map, 0, 0, 0, 2, _THIS_IP_);
-                lock_acquire(&lockdep_map, 0, 0, 0, 2, _THIS_IP_);
+                lock_map_acquire(&cwq->wq->lockdep_map);
+                lock_map_acquire(&lockdep_map);
                 f(work);
-                lock_release(&lockdep_map, 1, _THIS_IP_);
-                lock_release(&cwq->wq->lockdep_map, 1, _THIS_IP_);
+                lock_map_release(&lockdep_map);
+                lock_map_release(&cwq->wq->lockdep_map);
 
                 if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
                         printk(KERN_ERR "BUG: workqueue leaked lock or atomic: "
@@ -413,8 +413,8 @@ void flush_workqueue(struct workqueue_struct *wq)
         int cpu;
 
         might_sleep();
-        lock_acquire(&wq->lockdep_map, 0, 0, 0, 2, _THIS_IP_);
-        lock_release(&wq->lockdep_map, 1, _THIS_IP_);
+        lock_map_acquire(&wq->lockdep_map);
+        lock_map_release(&wq->lockdep_map);
         for_each_cpu_mask_nr(cpu, *cpu_map)
                 flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, cpu));
 }
@@ -441,8 +441,8 @@ int flush_work(struct work_struct *work)
         if (!cwq)
                 return 0;
 
-        lock_acquire(&cwq->wq->lockdep_map, 0, 0, 0, 2, _THIS_IP_);
-        lock_release(&cwq->wq->lockdep_map, 1, _THIS_IP_);
+        lock_map_acquire(&cwq->wq->lockdep_map);
+        lock_map_release(&cwq->wq->lockdep_map);
 
         prev = NULL;
         spin_lock_irq(&cwq->lock);
@@ -536,8 +536,8 @@ static void wait_on_work(struct work_struct *work)
 
         might_sleep();
 
-        lock_acquire(&work->lockdep_map, 0, 0, 0, 2, _THIS_IP_);
-        lock_release(&work->lockdep_map, 1, _THIS_IP_);
+        lock_map_acquire(&work->lockdep_map);
+        lock_map_release(&work->lockdep_map);
 
         cwq = get_wq_data(work);
         if (!cwq)
@@ -830,10 +830,21 @@ struct workqueue_struct *__create_workqueue_key(const char *name,
                 start_workqueue_thread(cwq, -1);
         } else {
                 cpu_maps_update_begin();
+                /*
+                 * We must place this wq on list even if the code below fails.
+                 * cpu_down(cpu) can remove cpu from cpu_populated_map before
+                 * destroy_workqueue() takes the lock, in that case we leak
+                 * cwq[cpu]->thread.
+                 */
                 spin_lock(&workqueue_lock);
                 list_add(&wq->list, &workqueues);
                 spin_unlock(&workqueue_lock);
-
+                /*
+                 * We must initialize cwqs for each possible cpu even if we
+                 * are going to call destroy_workqueue() finally. Otherwise
+                 * cpu_up() can hit the uninitialized cwq once we drop the
+                 * lock.
+                 */
                 for_each_possible_cpu(cpu) {
                         cwq = init_cpu_workqueue(wq, cpu);
                         if (err || !cpu_online(cpu))
@@ -861,8 +872,8 @@ static void cleanup_workqueue_thread(struct cpu_workqueue_struct *cwq)
         if (cwq->thread == NULL)
                 return;
 
-        lock_acquire(&cwq->wq->lockdep_map, 0, 0, 0, 2, _THIS_IP_);
-        lock_release(&cwq->wq->lockdep_map, 1, _THIS_IP_);
+        lock_map_acquire(&cwq->wq->lockdep_map);
+        lock_map_release(&cwq->wq->lockdep_map);
 
         flush_cpu_workqueue(cwq);
         /*