Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq: (55 commits)
  workqueue: mark init_workqueues() as early_initcall()
  workqueue: explain for_each_*cwq_cpu() iterators
  fscache: fix build on !CONFIG_SYSCTL
  slow-work: kill it
  gfs2: use workqueue instead of slow-work
  drm: use workqueue instead of slow-work
  cifs: use workqueue instead of slow-work
  fscache: drop references to slow-work
  fscache: convert operation to use workqueue instead of slow-work
  fscache: convert object to use workqueue instead of slow-work
  workqueue: fix how cpu number is stored in work->data
  workqueue: fix mayday_mask handling on UP
  workqueue: fix build problem on !CONFIG_SMP
  workqueue: fix locking in retry path of maybe_create_worker()
  async: use workqueue for worker pool
  workqueue: remove WQ_SINGLE_CPU and use WQ_UNBOUND instead
  workqueue: implement unbound workqueue
  workqueue: prepare for WQ_UNBOUND implementation
  libata: take advantage of cmwq and remove concurrency limitations
  workqueue: fix worker management invocation without pending works
  ...

Fixed up conflicts in fs/cifs/* as per Tejun. Other trivial conflicts in
include/linux/workqueue.h, kernel/trace/Kconfig and kernel/workqueue.c

11 files changed, 2963 insertions, 1924 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index ce53fb2bd1d9..c53e491e25a8 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -99,8 +99,6 @@ obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_X86_DS) += trace/
 obj-$(CONFIG_RING_BUFFER) += trace/
 obj-$(CONFIG_SMP) += sched_cpupri.o
-obj-$(CONFIG_SLOW_WORK) += slow-work.o
-obj-$(CONFIG_SLOW_WORK_DEBUG) += slow-work-debugfs.o
 obj-$(CONFIG_PERF_EVENTS) += perf_event.o
 obj-$(CONFIG_HAVE_HW_BREAKPOINT) += hw_breakpoint.o
 obj-$(CONFIG_USER_RETURN_NOTIFIER) += user-return-notifier.o
diff --git a/kernel/async.c b/kernel/async.c
index 15319d6c18fe..cd9dbb913c77 100644
--- a/kernel/async.c
+++ b/kernel/async.c
@@ -49,40 +49,33 @@ asynchronous and synchronous parts of the kernel.
 */
 
 #include <linux/async.h>
-#include <linux/bug.h>
 #include <linux/module.h>
 #include <linux/wait.h>
 #include <linux/sched.h>
-#include <linux/init.h>
-#include <linux/kthread.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
+#include <linux/workqueue.h>
 #include <asm/atomic.h>
 
 static async_cookie_t next_cookie = 1;
 
-#define MAX_THREADS     256
 #define MAX_WORK        32768
 
 static LIST_HEAD(async_pending);
 static LIST_HEAD(async_running);
 static DEFINE_SPINLOCK(async_lock);
 
-static int async_enabled = 0;
-
 struct async_entry {
-        struct list_head list;
-        async_cookie_t   cookie;
-        async_func_ptr   *func;
-        void             *data;
-        struct list_head *running;
+        struct list_head        list;
+        struct work_struct      work;
+        async_cookie_t          cookie;
+        async_func_ptr          *func;
+        void                    *data;
+        struct list_head        *running;
 };
 
 static DECLARE_WAIT_QUEUE_HEAD(async_done);
-static DECLARE_WAIT_QUEUE_HEAD(async_new);
 
 static atomic_t entry_count;
-static atomic_t thread_count;
 
 extern int initcall_debug;
 
@@ -117,27 +110,23 @@ static async_cookie_t  lowest_in_progress(struct list_head *running)
         spin_unlock_irqrestore(&async_lock, flags);
         return ret;
 }
+
 /*
  * pick the first pending entry and run it
  */
-static void run_one_entry(void)
+static void async_run_entry_fn(struct work_struct *work)
 {
+        struct async_entry *entry =
+                container_of(work, struct async_entry, work);
         unsigned long flags;
-        struct async_entry *entry;
         ktime_t calltime, delta, rettime;
 
-        /* 1) pick one task from the pending queue */
-
+        /* 1) move self to the running queue */
         spin_lock_irqsave(&async_lock, flags);
-        if (list_empty(&async_pending))
-                goto out;
-        entry = list_first_entry(&async_pending, struct async_entry, list);
-
-        /* 2) move it to the running queue */
         list_move_tail(&entry->list, entry->running);
         spin_unlock_irqrestore(&async_lock, flags);
 
-        /* 3) run it (and print duration)*/
+        /* 2) run (and print duration) */
         if (initcall_debug && system_state == SYSTEM_BOOTING) {
                 printk("calling  %lli_%pF @ %i\n", (long long)entry->cookie,
                         entry->func, task_pid_nr(current));
@@ -153,31 +142,25 @@ static void run_one_entry(void)
                         (long long)ktime_to_ns(delta) >> 10);
         }
 
-        /* 4) remove it from the running queue */
+        /* 3) remove self from the running queue */
         spin_lock_irqsave(&async_lock, flags);
         list_del(&entry->list);
 
-        /* 5) free the entry  */
+        /* 4) free the entry */
         kfree(entry);
         atomic_dec(&entry_count);
 
         spin_unlock_irqrestore(&async_lock, flags);
 
-        /* 6) wake up any waiters. */
+        /* 5) wake up any waiters */
         wake_up(&async_done);
-        return;
-
-out:
-        spin_unlock_irqrestore(&async_lock, flags);
 }
 
-
 static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct list_head *running)
 {
         struct async_entry *entry;
         unsigned long flags;
         async_cookie_t newcookie;
-        
 
         /* allow irq-off callers */
         entry = kzalloc(sizeof(struct async_entry), GFP_ATOMIC);
@@ -186,7 +169,7 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct l
          * If we're out of memory or if there's too much work
          * pending already, we execute synchronously.
          */
-        if (!async_enabled || !entry || atomic_read(&entry_count) > MAX_WORK) {
+        if (!entry || atomic_read(&entry_count) > MAX_WORK) {
                 kfree(entry);
                 spin_lock_irqsave(&async_lock, flags);
                 newcookie = next_cookie++;
@@ -196,6 +179,7 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct l
                 ptr(data, newcookie);
                 return newcookie;
         }
+        INIT_WORK(&entry->work, async_run_entry_fn);
         entry->func = ptr;
         entry->data = data;
         entry->running = running;
@@ -205,7 +189,10 @@ static async_cookie_t __async_schedule(async_fu