1 files changed, 33 insertions, 38 deletions

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 4026d1871407..faf7622246da 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -841,43 +841,32 @@ static void wake_up_worker(struct worker_pool *pool)
 }
 
 /**
- * wq_worker_waking_up - a worker is waking up
+ * wq_worker_running - a worker is running again
  * @task: task waking up
- * @cpu: CPU @task is waking up to
  *
- * This function is called during try_to_wake_up() when a worker is
- * being awoken.
- *
- * CONTEXT:
- * spin_lock_irq(rq->lock)
+ * This function is called when a worker returns from schedule()
  */
-void wq_worker_waking_up(struct task_struct *task, int cpu)
+void wq_worker_running(struct task_struct *task)
 {
         struct worker *worker = kthread_data(task);
 
-        if (!(worker->flags & WORKER_NOT_RUNNING)) {
-                WARN_ON_ONCE(worker->pool->cpu != cpu);
+        if (!worker->sleeping)
+                return;
+        if (!(worker->flags & WORKER_NOT_RUNNING))
                 atomic_inc(&worker->pool->nr_running);
-        }
+        worker->sleeping = 0;
 }
 
 /**
  * wq_worker_sleeping - a worker is going to sleep
  * @task: task going to sleep
  *
- * This function is called during schedule() when a busy worker is
- * going to sleep.  Worker on the same cpu can be woken up by
- * returning pointer to its task.
- *
- * CONTEXT:
- * spin_lock_irq(rq->lock)
- *
- * Return:
- * Worker task on @cpu to wake up, %NULL if none.
+ * This function is called from schedule() when a busy worker is
+ * going to sleep.
  */
-struct task_struct *wq_worker_sleeping(struct task_struct *task)
+void wq_worker_sleeping(struct task_struct *task)
 {
-        struct worker *worker = kthread_data(task), *to_wakeup = NULL;
+        struct worker *next, *worker = kthread_data(task);
         struct worker_pool *pool;
 
         /*
@@ -886,13 +875,15 @@ struct task_struct *wq_worker_sleeping(struct task_struct *task)
          * checking NOT_RUNNING.
          */
         if (worker->flags & WORKER_NOT_RUNNING)
-                return NULL;
+                return;
 
         pool = worker->pool;
 
-        /* this can only happen on the local cpu */
-        if (WARN_ON_ONCE(pool->cpu != raw_smp_processor_id()))
-                return NULL;
+        if (WARN_ON_ONCE(worker->sleeping))
+                return;
+
+        worker->sleeping = 1;
+        spin_lock_irq(&pool->lock);
 
         /*
          * The counterpart of the following dec_and_test, implied mb,
@@ -906,9 +897,12 @@ struct task_struct *wq_worker_sleeping(struct task_struct *task)
          * lock is safe.
          */
         if (atomic_dec_and_test(&pool->nr_running) &&
-            !list_empty(&pool->worklist))
-                to_wakeup = first_idle_worker(pool);
-        return to_wakeup ? to_wakeup->task : NULL;
+            !list_empty(&pool->worklist)) {
+                next = first_idle_worker(pool);
+                if (next)
+                        wake_up_process(next->task);
+        }
+        spin_unlock_irq(&pool->lock);
 }
 
 /**
@@ -2277,7 +2271,7 @@ __acquires(&pool->lock)
 
         if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
                 pr_err("BUG: workqueue leaked lock or atomic: %s/0x%08x/%d\n"
-                       "     last function: %pf\n",
+                       "     last function: %ps\n",
                        current->comm, preempt_count(), task_pid_nr(current),
                        worker->current_func);
                 debug_show_held_locks(current);
@@ -2596,11 +2590,11 @@ static void check_flush_dependency(struct workqueue_struct *target_wq,
         worker = current_wq_worker();
 
         WARN_ONCE(current->flags & PF_MEMALLOC,
-                  "workqueue: PF_MEMALLOC task %d(%s) is flushing !WQ_MEM_RECLAIM %s:%pf",
+                  "workqueue: PF_MEMALLOC task %d(%s) is flushing !WQ_MEM_RECLAIM %s:%ps",
                   current->pid, current->comm, target_wq->name, target_func);
         WARN_ONCE(worker && ((worker->current_pwq->wq->flags &
                               (WQ_MEM_RECLAIM | __WQ_LEGACY)) == WQ_MEM_RECLAIM),
-                  "workqueue: WQ_MEM_RECLAIM %s:%pf is flushing !WQ_MEM_RECLAIM %s:%pf",
+                  "workqueue: WQ_MEM_RECLAIM %s:%ps is flushing !WQ_MEM_RECLAIM %s:%ps",
                   worker->current_pwq->wq->name, worker->current_func,
                   target_wq->name, target_func);
 }
@@ -4266,7 +4260,7 @@ struct workqueue_struct *alloc_workqueue(const char *fmt,
         INIT_LIST_HEAD(&wq->list);
 
         if (alloc_and_link_pwqs(wq) < 0)
-                goto err_free_wq;
+                goto err_unreg_lockdep;
 
         if (wq_online && init_rescuer(wq) < 0)
                 goto err_destroy;
@@ -4292,9 +4286,10 @@ struct workqueue_struct *alloc_workqueue(const char *fmt,
 
         return wq;
 
-err_free_wq:
+err_unreg_lockdep:
         wq_unregister_lockdep(wq);
         wq_free_lockdep(wq);
+err_free_wq:
         free_workqueue_attrs(wq->unbound_attrs);
         kfree(wq);
         return NULL;
@@ -4586,7 +4581,7 @@ void print_worker_info(const char *log_lvl, struct task_struct *task)
         probe_kernel_read(desc, worker->desc, sizeof(desc) - 1);
 
         if (fn || name[0] || desc[0]) {
-                printk("%sWorkqueue: %s %pf", log_lvl, name, fn);
+                printk("%sWorkqueue: %s %ps", log_lvl, name, fn);
                 if (strcmp(name, desc))
                         pr_cont(" (%s)", desc);
                 pr_cont("\n");
@@ -4611,7 +4606,7 @@ static void pr_cont_work(bool comma, struct work_struct *work)
                 pr_cont("%s BAR(%d)", comma ? "," : "",
                         task_pid_nr(barr->task));
         } else {
-                pr_cont("%s %pf", comma ? "," : "", work->func);
+                pr_cont("%s %ps", comma ? "," : "", work->func);
         }
 }
 
@@ -4643,7 +4638,7 @@ static void show_pwq(struct pool_workqueue *pwq)
                         if (worker->current_pwq != pwq)
                                 continue;
 
-                        pr_cont("%s %d%s:%pf", comma ? "," : "",
+                        pr_cont("%s %d%s:%ps", comma ? "," : "",
                                 task_pid_nr(worker->task),
                                 worker == pwq->wq->rescuer ? "(RESCUER)" : "",
                                 worker->current_func);
@@ -4928,7 +4923,7 @@ static void rebind_workers(struct worker_pool *pool)
                  *
                  * WRITE_ONCE() is necessary because @worker->flags may be
                  * tested without holding any lock in
-                 * wq_worker_waking_up().  Without it, NOT_RUNNING test may
+                 * wq_worker_running().  Without it, NOT_RUNNING test may
                  * fail incorrectly leading to premature concurrency
                  * management operations.
                  */