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

* 'for-2.6.39' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq:
  workqueue: fix build failure introduced by s/freezeable/freezable/
  workqueue: add system_freezeable_wq
  rds/ib: use system_wq instead of rds_ib_fmr_wq
  net/9p: replace p9_poll_task with a work
  net/9p: use system_wq instead of p9_mux_wq
  xfs: convert to alloc_workqueue()
  reiserfs: make commit_wq use the default concurrency level
  ocfs2: use system_wq instead of ocfs2_quota_wq
  ext4: convert to alloc_workqueue()
  scsi/scsi_tgt_lib: scsi_tgtd isn't used in memory reclaim path
  scsi/be2iscsi,qla2xxx: convert to alloc_workqueue()
  misc/iwmc3200top: use system_wq instead of dedicated workqueues
  i2o: use alloc_workqueue() instead of create_workqueue()
  acpi: kacpi*_wq don't need WQ_MEM_RECLAIM
  fs/aio: aio_wq isn't used in memory reclaim path
  input/tps6507x-ts: use system_wq instead of dedicated workqueue
  cpufreq: use system_wq instead of dedicated workqueues
  wireless/ipw2x00: use system_wq instead of dedicated workqueues
  arm/omap: use system_wq in mailbox
  workqueue: use WQ_MEM_RECLAIM instead of WQ_RESCUER

5 files changed, 18 insertions, 74 deletions

diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c
index 078eb162d9bf..a30471e51740 100644
--- a/net/9p/trans_fd.c
+++ b/net/9p/trans_fd.c
@@ -153,10 +153,11 @@ struct p9_conn {
         unsigned long wsched;
 };
 
+static void p9_poll_workfn(struct work_struct *work);
+
 static DEFINE_SPINLOCK(p9_poll_lock);
 static LIST_HEAD(p9_poll_pending_list);
-static struct workqueue_struct *p9_mux_wq;
-static struct task_struct *p9_poll_task;
+static DECLARE_WORK(p9_poll_work, p9_poll_workfn);
 
 static void p9_mux_poll_stop(struct p9_conn *m)
 {
@@ -384,7 +385,7 @@ static void p9_read_work(struct work_struct *work)
 
                 if (n & POLLIN) {
                         P9_DPRINTK(P9_DEBUG_TRANS, "sched read work %p\n", m);
-                        queue_work(p9_mux_wq, &m->rq);
+                        schedule_work(&m->rq);
                 } else
                         clear_bit(Rworksched, &m->wsched);
         } else
@@ -497,7 +498,7 @@ static void p9_write_work(struct work_struct *work)
 
                 if (n & POLLOUT) {
                         P9_DPRINTK(P9_DEBUG_TRANS, "sched write work %p\n", m);
-                        queue_work(p9_mux_wq, &m->wq);
+                        schedule_work(&m->wq);
                 } else
                         clear_bit(Wworksched, &m->wsched);
         } else
@@ -516,15 +517,14 @@ static int p9_pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)
                 container_of(wait, struct p9_poll_wait, wait);
         struct p9_conn *m = pwait->conn;
         unsigned long flags;
-        DECLARE_WAITQUEUE(dummy_wait, p9_poll_task);
 
         spin_lock_irqsave(&p9_poll_lock, flags);
         if (list_empty(&m->poll_pending_link))
                 list_add_tail(&m->poll_pending_link, &p9_poll_pending_list);
         spin_unlock_irqrestore(&p9_poll_lock, flags);
 
-        /* perform the default wake up operation */
-        return default_wake_function(&dummy_wait, mode, sync, key);
+        schedule_work(&p9_poll_work);
+        return 1;
 }
 
 /**
@@ -629,7 +629,7 @@ static void p9_poll_mux(struct p9_conn *m)
                 P9_DPRINTK(P9_DEBUG_TRANS, "mux %p can read\n", m);
                 if (!test_and_set_bit(Rworksched, &m->wsched)) {
                         P9_DPRINTK(P9_DEBUG_TRANS, "sched read work %p\n", m);
-                        queue_work(p9_mux_wq, &m->rq);
+                        schedule_work(&m->rq);
                 }
         }
 
@@ -639,7 +639,7 @@ static void p9_poll_mux(struct p9_conn *m)
                 if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
                     !test_and_set_bit(Wworksched, &m->wsched)) {
                         P9_DPRINTK(P9_DEBUG_TRANS, "sched write work %p\n", m);
-                        queue_work(p9_mux_wq, &m->wq);
+                        schedule_work(&m->wq);
                 }
         }
 }
@@ -677,7 +677,7 @@ static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
                 n = p9_fd_poll(m->client, NULL);
 
         if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
-                queue_work(p9_mux_wq, &m->wq);
+                schedule_work(&m->wq);
 
         return 0;
 }
@@ -1047,12 +1047,12 @@ static struct p9_trans_module p9_fd_trans = {
  *
  */
 
-static int p9_poll_proc(void *a)
+static void p9_poll_workfn(struct work_struct *work)
 {
         unsigned long flags;
 
         P9_DPRINTK(P9_DEBUG_TRANS, "start %p\n", current);
- repeat:
+
         spin_lock_irqsave(&p9_poll_lock, flags);
         while (!list_empty(&p9_poll_pending_list)) {
                 struct p9_conn *conn = list_first_entry(&p9_poll_pending_list,
@@ -1067,35 +1067,11 @@ static int p9_poll_proc(void *a)
         }
         spin_unlock_irqrestore(&p9_poll_lock, flags);
 
-        set_current_state(TASK_INTERRUPTIBLE);
-        if (list_empty(&p9_poll_pending_list)) {
-                P9_DPRINTK(P9_DEBUG_TRANS, "sleeping...\n");
-                schedule();
-        }
-        __set_current_state(TASK_RUNNING);
-
-        if (!kthread_should_stop())
-                goto repeat;
-
         P9_DPRINTK(P9_DEBUG_TRANS, "finish\n");
-        return 0;
 }
 
 int p9_trans_fd_init(void)
 {
-        p9_mux_wq = create_workqueue("v9fs");
-        if (!p9_mux_wq) {
-                printk(KERN_WARNING "v9fs: mux: creating workqueue failed\n");
-                return -ENOMEM;
-        }
-
-        p9_poll_task = kthread_run(p9_poll_proc, NULL, "v9fs-poll");
-        if (IS_ERR(p9_poll_task)) {
-                destroy_workqueue(p9_mux_wq);
-                printk(KERN_WARNING "v9fs: mux: creating poll task failed\n");
-                return PTR_ERR(p9_poll_task);
-        }
-
         v9fs_register_trans(&p9_tcp_trans);
         v9fs_register_trans(&p9_unix_trans);
         v9fs_register_trans(&p9_fd_trans);
@@ -1105,10 +1081,8 @@ int p9_trans_fd_init(void)
 
 void p9_trans_fd_exit(void)
 {
-        kthread_stop(p9_poll_task);
+        flush_work_sync(&p9_poll_work);
         v9fs_unregister_trans(&p9_tcp_trans);
         v9fs_unregister_trans(&p9_unix_trans);
         v9fs_unregister_trans(&p9_fd_trans);
-
-        destroy_workqueue(p9_mux_wq);
 }
diff --git a/net/rds/ib.c b/net/rds/ib.c
index 4123967d4d65..cce19f95c624 100644
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -364,7 +364,6 @@ void rds_ib_exit(void)
         rds_ib_sysctl_exit();
         rds_ib_recv_exit();
         rds_trans_unregister(&rds_ib_transport);
-        rds_ib_fmr_exit();
 }
 
 struct rds_transport rds_ib_transport = {
@@ -400,13 +399,9 @@ int rds_ib_init(void)
 
         INIT_LIST_HEAD(&rds_ib_devices);
 
-        ret = rds_ib_fmr_init();
-        if (ret)
-                goto out;
-
         ret = ib_register_client(&rds_ib_client);
         if (ret)
-                goto out_fmr_exit;
+                goto out;
 
         ret = rds_ib_sysctl_init();
         if (ret)
@@ -430,8 +425,6 @@ out_sysctl:
         rds_ib_sysctl_exit();
 out_ibreg:
         rds_ib_unregister_client();
-out_fmr_exit:
-        rds_ib_fmr_exit();
 out:
         return ret;
 }
diff --git a/net/rds/ib.h b/net/rds/ib.h
index e34ad032b66d..4297d92788dc 100644
--- a/net/rds/ib.h
+++ b/net/rds/ib.h
@@ -307,8 +307,6 @@ void *rds_ib_get_mr(struct scatterlist *sg, unsigned long nents,
 void rds_ib_sync_mr(void *trans_private, int dir);
 void rds_ib_free_mr(void *trans_private, int invalidate);
 void rds_ib_flush_mrs(void);
-int rds_ib_fmr_init(void);
-void rds_ib_fmr_exit(void);
 
 /* ib_recv.c */
 int rds_ib_recv_init(void);
diff --git a/net/rds/ib_rdma.c b/net/rds/ib_rdma.c
index 18a833c450c8..819c35a0d9cb 100644
--- a/net/rds/ib_rdma.c
+++ b/net/rds/ib_rdma.c
@@ -38,8 +38,6 @@
 #include "ib.h"
 #include "xlist.h"
 
-static struct workqueue_struct *rds_ib_fmr_wq;
-
 static DEFINE_PER_CPU(unsigned long, clean_list_grace);
 #define CLEAN_LIST_BUSY_BIT 0
 
@@ -307,7 +305,7 @@ static struct rds_ib_mr *rds_ib_alloc_fmr(struct rds_ib_device *rds_ibdev)
         int err = 0, iter = 0;
 
         if (atomic_read(&pool->dirty_count) >= pool->max_items / 10)
-                queue_delayed_work(rds_ib_fmr_wq, &pool->flush_worker, 10);
+                schedule_delayed_work(&pool->flush_worker, 10);
 
         while (1) {
                 ibmr = rds_ib_reuse_fmr(pool);
@@ -696,24 +694,6 @@ out_nolock:
         return ret;
 }
 
-int rds_ib_fmr_init(void)
-{
-        rds_ib_fmr_wq = create_workqueue("rds_fmr_flushd");
-        if (!rds_ib_fmr_wq)
-                return -ENOMEM;
-        return 0;
-}
-
-/*
- * By the time this is called all the IB devices should have been torn down and
- * had their pools freed.  As each pool is freed its work struct is waited on,
- * so the pool flushing work queue should be idle by the time we get here.
- */
-void rds_ib_fmr_exit(void)
-{
-        destroy_workqueue(rds_ib_fmr_wq);
-}
-
 static void rds_ib_mr_pool_flush_worker(struct work_struct *work)
 {
         struct rds_ib_mr_pool *pool = container_of(work, struct rds_ib_mr_pool, flush_worker.work);
@@ -741,7 +721,7 @@ void rds_ib_free_mr(void *trans_private, int invalidate)
         /* If we've pinned too many pages, request a flush */
         if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned ||
             atomic_read(&pool->dirty_count) >= pool->max_items / 10)
-                queue_delayed_work(rds_ib_fmr_wq, &pool->flush_worker, 10);
+                schedule_delayed_work(&pool->flush_worker, 10);
 
         if (invalidate) {
                 if (likely(!in_interrupt())) {
@@ -749,8 +729,7 @@ void rds_ib_free_mr(void *trans_private, int invalidate)
                 } else {
                         /* We get here if the user created a MR marked
                          * as use_once and invalidate at the same time. */
-                        queue_delayed_work(rds_ib_fmr_wq,
-                                           &pool->flush_worker, 10);
+                        schedule_delayed_work(&pool->flush_worker, 10);
                 }
         }
 
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index 59e599498e37..3fc8624fcd17 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -955,7 +955,7 @@ static int rpciod_start(void)
          * Create the rpciod thread and wait for it to start.
          */
         dprintk("RPC:       creating workqueue rpciod\n");
-        wq = alloc_workqueue("rpciod", WQ_RESCUER, 0);
+        wq = alloc_workqueue("rpciod", WQ_MEM_RECLAIM, 0);
         rpciod_workqueue = wq;
         return rpciod_workqueue != NULL;
 }