xfs
[Top] [All Lists]

[PATCH 3/6] workqueue: use @pool instead of @gcwq or @cpu where applicab

To: linux-kernel@xxxxxxxxxxxxxxx
Subject: [PATCH 3/6] workqueue: use @pool instead of @gcwq or @cpu where applicable
From: Tejun Heo <tj@xxxxxxxxxx>
Date: Mon, 9 Jul 2012 11:41:52 -0700
Cc: torvalds@xxxxxxxxxxxxxxxxxxxx, joshhunt00@xxxxxxxxx, axboe@xxxxxxxxx, rni@xxxxxxxxxx, vgoyal@xxxxxxxxxx, vwadekar@xxxxxxxxxx, herbert@xxxxxxxxxxxxxxxxxxxx, davem@xxxxxxxxxxxxx, linux-crypto@xxxxxxxxxxxxxxx, swhiteho@xxxxxxxxxx, bpm@xxxxxxx, elder@xxxxxxxxxx, xfs@xxxxxxxxxxx, marcel@xxxxxxxxxxxx, gustavo@xxxxxxxxxxx, johan.hedberg@xxxxxxxxx, linux-bluetooth@xxxxxxxxxxxxxxx, martin.petersen@xxxxxxxxxx, Tejun Heo <tj@xxxxxxxxxx>
Dkim-signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=sender:from:to:cc:subject:date:message-id:x-mailer:in-reply-to :references; bh=8Cyqq2OUxD3DXHE8XImUCfv8eFObIopXdVycA4DF51g=; b=cTSLRZUWNVVIbFObWtgfz8ZlCIB2ATobWxlFkUpSVOu1Jpau48pVegIC5ysWuzaHIe 2SPSPMu3nJhkXTJPOx6ZukF5AkNLs2kG71kR9g8pV1XLyi2XArxhO1UQZ9IE9NnWiYIM idDyJ788+JytznMUqVp26fi39x4QCOVSnZd/laNY+CAdHMknI40QWJesm04TodpdzCtc YMaXXluLdCY/zOc0uAgxejnX9gq8I88E29oj5ExXcaSXF4j6qUxmJb1RNeKGZ6igX+OA HLh9PT1r03OQxVtfERxK96JPagN9shPfrzOIqKTPbwHRBqVvt5BtDl9ndnZspWJZoXpJ Mi/g==
In-reply-to: <1341859315-17759-1-git-send-email-tj@xxxxxxxxxx>
References: <1341859315-17759-1-git-send-email-tj@xxxxxxxxxx>
Sender: Tejun Heo <htejun@xxxxxxxxx>
Modify all functions which deal with per-pool properties to pass
around @pool instead of @gcwq or @cpu.

The changes in this patch are mechanical and don't caues any
functional difference.  This is to prepare for multiple pools per
gcwq.

Signed-off-by: Tejun Heo <tj@xxxxxxxxxx>
---
 kernel/workqueue.c |  218 ++++++++++++++++++++++++++-------------------------
 1 files changed, 111 insertions(+), 107 deletions(-)

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index bc43a0c..9f82c25 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -471,8 +471,10 @@ static struct global_cwq *get_gcwq(unsigned int cpu)
                return &unbound_global_cwq;
 }
 
-static atomic_t *get_gcwq_nr_running(unsigned int cpu)
+static atomic_t *get_pool_nr_running(struct worker_pool *pool)
 {
+       int cpu = pool->gcwq->cpu;
+
        if (cpu != WORK_CPU_UNBOUND)
                return &per_cpu(gcwq_nr_running, cpu);
        else
@@ -578,10 +580,10 @@ static struct global_cwq *get_work_gcwq(struct 
work_struct *work)
  * assume that they're being called with gcwq->lock held.
  */
 
-static bool __need_more_worker(struct global_cwq *gcwq)
+static bool __need_more_worker(struct worker_pool *pool)
 {
-       return !atomic_read(get_gcwq_nr_running(gcwq->cpu)) ||
-               gcwq->flags & GCWQ_HIGHPRI_PENDING;
+       return !atomic_read(get_pool_nr_running(pool)) ||
+               pool->gcwq->flags & GCWQ_HIGHPRI_PENDING;
 }
 
 /*
@@ -592,45 +594,46 @@ static bool __need_more_worker(struct global_cwq *gcwq)
  * function will always return %true for unbound gcwq as long as the
  * worklist isn't empty.
  */
-static bool need_more_worker(struct global_cwq *gcwq)
+static bool need_more_worker(struct worker_pool *pool)
 {
-       return !list_empty(&gcwq->pool.worklist) && __need_more_worker(gcwq);
+       return !list_empty(&pool->worklist) && __need_more_worker(pool);
 }
 
 /* Can I start working?  Called from busy but !running workers. */
-static bool may_start_working(struct global_cwq *gcwq)
+static bool may_start_working(struct worker_pool *pool)
 {
-       return gcwq->pool.nr_idle;
+       return pool->nr_idle;
 }
 
 /* Do I need to keep working?  Called from currently running workers. */
-static bool keep_working(struct global_cwq *gcwq)
+static bool keep_working(struct worker_pool *pool)
 {
-       atomic_t *nr_running = get_gcwq_nr_running(gcwq->cpu);
+       atomic_t *nr_running = get_pool_nr_running(pool);
 
-       return !list_empty(&gcwq->pool.worklist) &&
+       return !list_empty(&pool->worklist) &&
                (atomic_read(nr_running) <= 1 ||
-                gcwq->flags & GCWQ_HIGHPRI_PENDING);
+                pool->gcwq->flags & GCWQ_HIGHPRI_PENDING);
 }
 
 /* Do we need a new worker?  Called from manager. */
-static bool need_to_create_worker(struct global_cwq *gcwq)
+static bool need_to_create_worker(struct worker_pool *pool)
 {
-       return need_more_worker(gcwq) && !may_start_working(gcwq);
+       return need_more_worker(pool) && !may_start_working(pool);
 }
 
 /* Do I need to be the manager? */
-static bool need_to_manage_workers(struct global_cwq *gcwq)
+static bool need_to_manage_workers(struct worker_pool *pool)
 {
-       return need_to_create_worker(gcwq) || gcwq->flags & GCWQ_MANAGE_WORKERS;
+       return need_to_create_worker(pool) ||
+               pool->gcwq->flags & GCWQ_MANAGE_WORKERS;
 }
 
 /* Do we have too many workers and should some go away? */
-static bool too_many_workers(struct global_cwq *gcwq)
+static bool too_many_workers(struct worker_pool *pool)
 {
-       bool managing = gcwq->flags & GCWQ_MANAGING_WORKERS;
-       int nr_idle = gcwq->pool.nr_idle + managing; /* manager is considered 
idle */
-       int nr_busy = gcwq->pool.nr_workers - nr_idle;
+       bool managing = pool->gcwq->flags & GCWQ_MANAGING_WORKERS;
+       int nr_idle = pool->nr_idle + managing; /* manager is considered idle */
+       int nr_busy = pool->nr_workers - nr_idle;
 
        return nr_idle > 2 && (nr_idle - 2) * MAX_IDLE_WORKERS_RATIO >= nr_busy;
 }
@@ -640,26 +643,26 @@ static bool too_many_workers(struct global_cwq *gcwq)
  */
 
 /* Return the first worker.  Safe with preemption disabled */
-static struct worker *first_worker(struct global_cwq *gcwq)
+static struct worker *first_worker(struct worker_pool *pool)
 {
-       if (unlikely(list_empty(&gcwq->pool.idle_list)))
+       if (unlikely(list_empty(&pool->idle_list)))
                return NULL;
 
-       return list_first_entry(&gcwq->pool.idle_list, struct worker, entry);
+       return list_first_entry(&pool->idle_list, struct worker, entry);
 }
 
 /**
  * wake_up_worker - wake up an idle worker
- * @gcwq: gcwq to wake worker for
+ * @pool: worker pool to wake worker from
  *
- * Wake up the first idle worker of @gcwq.
+ * Wake up the first idle worker of @pool.
  *
  * CONTEXT:
  * spin_lock_irq(gcwq->lock).
  */
-static void wake_up_worker(struct global_cwq *gcwq)
+static void wake_up_worker(struct worker_pool *pool)
 {
-       struct worker *worker = first_worker(gcwq);
+       struct worker *worker = first_worker(pool);
 
        if (likely(worker))
                wake_up_process(worker->task);
@@ -681,7 +684,7 @@ void wq_worker_waking_up(struct task_struct *task, unsigned 
int cpu)
        struct worker *worker = kthread_data(task);
 
        if (!(worker->flags & WORKER_NOT_RUNNING))
-               atomic_inc(get_gcwq_nr_running(cpu));
+               atomic_inc(get_pool_nr_running(worker->pool));
 }
 
 /**
@@ -704,8 +707,7 @@ struct task_struct *wq_worker_sleeping(struct task_struct 
*task,
 {
        struct worker *worker = kthread_data(task), *to_wakeup = NULL;
        struct worker_pool *pool = worker->pool;
-       struct global_cwq *gcwq = pool->gcwq;
-       atomic_t *nr_running = get_gcwq_nr_running(cpu);
+       atomic_t *nr_running = get_pool_nr_running(pool);
 
        if (worker->flags & WORKER_NOT_RUNNING)
                return NULL;
@@ -725,7 +727,7 @@ struct task_struct *wq_worker_sleeping(struct task_struct 
*task,
         * without gcwq lock is safe.
         */
        if (atomic_dec_and_test(nr_running) && !list_empty(&pool->worklist))
-               to_wakeup = first_worker(gcwq);
+               to_wakeup = first_worker(pool);
        return to_wakeup ? to_wakeup->task : NULL;
 }
 
@@ -746,7 +748,6 @@ static inline void worker_set_flags(struct worker *worker, 
unsigned int flags,
                                    bool wakeup)
 {
        struct worker_pool *pool = worker->pool;
-       struct global_cwq *gcwq = pool->gcwq;
 
        WARN_ON_ONCE(worker->task != current);
 
@@ -757,12 +758,12 @@ static inline void worker_set_flags(struct worker 
*worker, unsigned int flags,
         */
        if ((flags & WORKER_NOT_RUNNING) &&
            !(worker->flags & WORKER_NOT_RUNNING)) {
-               atomic_t *nr_running = get_gcwq_nr_running(gcwq->cpu);
+               atomic_t *nr_running = get_pool_nr_running(pool);
 
                if (wakeup) {
                        if (atomic_dec_and_test(nr_running) &&
                            !list_empty(&pool->worklist))
-                               wake_up_worker(gcwq);
+                               wake_up_worker(pool);
                } else
                        atomic_dec(nr_running);
        }
@@ -782,7 +783,7 @@ static inline void worker_set_flags(struct worker *worker, 
unsigned int flags,
  */
 static inline void worker_clr_flags(struct worker *worker, unsigned int flags)
 {
-       struct global_cwq *gcwq = worker->pool->gcwq;
+       struct worker_pool *pool = worker->pool;
        unsigned int oflags = worker->flags;
 
        WARN_ON_ONCE(worker->task != current);
@@ -796,7 +797,7 @@ static inline void worker_clr_flags(struct worker *worker, 
unsigned int flags)
         */
        if ((flags & WORKER_NOT_RUNNING) && (oflags & WORKER_NOT_RUNNING))
                if (!(worker->flags & WORKER_NOT_RUNNING))
-                       atomic_inc(get_gcwq_nr_running(gcwq->cpu));
+                       atomic_inc(get_pool_nr_running(pool));
 }
 
 /**
@@ -880,15 +881,15 @@ static struct worker *find_worker_executing_work(struct 
global_cwq *gcwq,
 }
 
 /**
- * gcwq_determine_ins_pos - find insertion position
- * @gcwq: gcwq of interest
+ * pool_determine_ins_pos - find insertion position
+ * @pool: pool of interest
  * @cwq: cwq a work is being queued for
  *
- * A work for @cwq is about to be queued on @gcwq, determine insertion
+ * A work for @cwq is about to be queued on @pool, determine insertion
  * position for the work.  If @cwq is for HIGHPRI wq, the work is
  * queued at the head of the queue but in FIFO order with respect to
  * other HIGHPRI works; otherwise, at the end of the queue.  This
- * function also sets GCWQ_HIGHPRI_PENDING flag to hint @gcwq that
+ * function also sets GCWQ_HIGHPRI_PENDING flag to hint @pool that
  * there are HIGHPRI works pending.
  *
  * CONTEXT:
@@ -897,22 +898,22 @@ static struct worker *find_worker_executing_work(struct 
global_cwq *gcwq,
  * RETURNS:
  * Pointer to inserstion position.
  */
-static inline struct list_head *gcwq_determine_ins_pos(struct global_cwq *gcwq,
+static inline struct list_head *pool_determine_ins_pos(struct worker_pool 
*pool,
                                               struct cpu_workqueue_struct *cwq)
 {
        struct work_struct *twork;
 
        if (likely(!(cwq->wq->flags & WQ_HIGHPRI)))
-               return &gcwq->pool.worklist;
+               return &pool->worklist;
 
-       list_for_each_entry(twork, &gcwq->pool.worklist, entry) {
+       list_for_each_entry(twork, &pool->worklist, entry) {
                struct cpu_workqueue_struct *tcwq = get_work_cwq(twork);
 
                if (!(tcwq->wq->flags & WQ_HIGHPRI))
                        break;
        }
 
-       gcwq->flags |= GCWQ_HIGHPRI_PENDING;
+       pool->gcwq->flags |= GCWQ_HIGHPRI_PENDING;
        return &twork->entry;
 }
 
@@ -933,7 +934,7 @@ static void insert_work(struct cpu_workqueue_struct *cwq,
                        struct work_struct *work, struct list_head *head,
                        unsigned int extra_flags)
 {
-       struct global_cwq *gcwq = cwq->pool->gcwq;
+       struct worker_pool *pool = cwq->pool;
 
        /* we own @work, set data and link */
        set_work_cwq(work, cwq, extra_flags);
@@ -953,8 +954,8 @@ static void insert_work(struct cpu_workqueue_struct *cwq,
         */
        smp_mb();
 
-       if (__need_more_worker(gcwq))
-               wake_up_worker(gcwq);
+       if (__need_more_worker(pool))
+               wake_up_worker(pool);
 }
 
 /*
@@ -1056,7 +1057,7 @@ static void __queue_work(unsigned int cpu, struct 
workqueue_struct *wq,
        if (likely(cwq->nr_active < cwq->max_active)) {
                trace_workqueue_activate_work(work);
                cwq->nr_active++;
-               worklist = gcwq_determine_ins_pos(gcwq, cwq);
+               worklist = pool_determine_ins_pos(cwq->pool, cwq);
        } else {
                work_flags |= WORK_STRUCT_DELAYED;
                worklist = &cwq->delayed_works;
@@ -1221,7 +1222,7 @@ static void worker_enter_idle(struct worker *worker)
        list_add(&worker->entry, &pool->idle_list);
 
        if (likely(!(worker->flags & WORKER_ROGUE))) {
-               if (too_many_workers(gcwq) && !timer_pending(&pool->idle_timer))
+               if (too_many_workers(pool) && !timer_pending(&pool->idle_timer))
                        mod_timer(&pool->idle_timer,
                                  jiffies + IDLE_WORKER_TIMEOUT);
        } else
@@ -1234,7 +1235,7 @@ static void worker_enter_idle(struct worker *worker)
         */
        WARN_ON_ONCE(gcwq->trustee_state == TRUSTEE_DONE &&
                     pool->nr_workers == pool->nr_idle &&
-                    atomic_read(get_gcwq_nr_running(gcwq->cpu)));
+                    atomic_read(get_pool_nr_running(pool)));
 }
 
 /**
@@ -1356,10 +1357,10 @@ static struct worker *alloc_worker(void)
 
 /**
  * create_worker - create a new workqueue worker
- * @gcwq: gcwq the new worker will belong to
+ * @pool: pool the new worker will belong to
  * @bind: whether to set affinity to @cpu or not
  *
- * Create a new worker which is bound to @gcwq.  The returned worker
+ * Create a new worker which is bound to @pool.  The returned worker
  * can be started by calling start_worker() or destroyed using
  * destroy_worker().
  *
@@ -1369,10 +1370,10 @@ static struct worker *alloc_worker(void)
  * RETURNS:
  * Pointer to the newly created worker.
  */
-static struct worker *create_worker(struct global_cwq *gcwq, bool bind)
+static struct worker *create_worker(struct worker_pool *pool, bool bind)
 {
+       struct global_cwq *gcwq = pool->gcwq;
        bool on_unbound_cpu = gcwq->cpu == WORK_CPU_UNBOUND;
-       struct worker_pool *pool = &gcwq->pool;
        struct worker *worker = NULL;
        int id = -1;
 
@@ -1480,27 +1481,27 @@ static void destroy_worker(struct worker *worker)
        ida_remove(&pool->worker_ida, id);
 }
 
-static void idle_worker_timeout(unsigned long __gcwq)
+static void idle_worker_timeout(unsigned long __pool)
 {
-       struct global_cwq *gcwq = (void *)__gcwq;
+       struct worker_pool *pool = (void *)__pool;
+       struct global_cwq *gcwq = pool->gcwq;
 
        spin_lock_irq(&gcwq->lock);
 
-       if (too_many_workers(gcwq)) {
+       if (too_many_workers(pool)) {
                struct worker *worker;
                unsigned long expires;
 
                /* idle_list is kept in LIFO order, check the last one */
-               worker = list_entry(gcwq->pool.idle_list.prev, struct worker,
-                                   entry);
+               worker = list_entry(pool->idle_list.prev, struct worker, entry);
                expires = worker->last_active + IDLE_WORKER_TIMEOUT;
 
                if (time_before(jiffies, expires))
-                       mod_timer(&gcwq->pool.idle_timer, expires);
+                       mod_timer(&pool->idle_timer, expires);
                else {
                        /* it's been idle for too long, wake up manager */
                        gcwq->flags |= GCWQ_MANAGE_WORKERS;
-                       wake_up_worker(gcwq);
+                       wake_up_worker(pool);
                }
        }
 
@@ -1526,37 +1527,38 @@ static bool send_mayday(struct work_struct *work)
        return true;
 }
 
-static void gcwq_mayday_timeout(unsigned long __gcwq)
+static void gcwq_mayday_timeout(unsigned long __pool)
 {
-       struct global_cwq *gcwq = (void *)__gcwq;
+       struct worker_pool *pool = (void *)__pool;
+       struct global_cwq *gcwq = pool->gcwq;
        struct work_struct *work;
 
        spin_lock_irq(&gcwq->lock);
 
-       if (need_to_create_worker(gcwq)) {
+       if (need_to_create_worker(pool)) {
                /*
                 * We've been trying to create a new worker but
                 * haven't been successful.  We might be hitting an
                 * allocation deadlock.  Send distress signals to
                 * rescuers.
                 */
-               list_for_each_entry(work, &gcwq->pool.worklist, entry)
+               list_for_each_entry(work, &pool->worklist, entry)
                        send_mayday(work);
        }
 
        spin_unlock_irq(&gcwq->lock);
 
-       mod_timer(&gcwq->pool.mayday_timer, jiffies + MAYDAY_INTERVAL);
+       mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INTERVAL);
 }
 
 /**
  * maybe_create_worker - create a new worker if necessary
- * @gcwq: gcwq to create a new worker for
+ * @pool: pool to create a new worker for
  *
- * Create a new worker for @gcwq if necessary.  @gcwq is guaranteed to
+ * Create a new worker for @pool if necessary.  @pool is guaranteed to
  * have at least one idle worker on return from this function.  If
  * creating a new worker takes longer than MAYDAY_INTERVAL, mayday is
- * sent to all rescuers with works scheduled on @gcwq to resolve
+ * sent to all rescuers with works scheduled on @pool to resolve
  * possible allocation deadlock.
  *
  * On return, need_to_create_worker() is guaranteed to be false and
@@ -1571,52 +1573,54 @@ static void gcwq_mayday_timeout(unsigned long __gcwq)
  * false if no action was taken and gcwq->lock stayed locked, true
  * otherwise.
  */
-static bool maybe_create_worker(struct global_cwq *gcwq)
+static bool maybe_create_worker(struct worker_pool *pool)
 __releases(&gcwq->lock)
 __acquires(&gcwq->lock)
 {
-       if (!need_to_create_worker(gcwq))
+       struct global_cwq *gcwq = pool->gcwq;
+
+       if (!need_to_create_worker(pool))
                return false;
 restart:
        spin_unlock_irq(&gcwq->lock);
 
        /* if we don't make progress in MAYDAY_INITIAL_TIMEOUT, call for help */
-       mod_timer(&gcwq->pool.mayday_timer, jiffies + MAYDAY_INITIAL_TIMEOUT);
+       mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INITIAL_TIMEOUT);
 
        while (true) {
                struct worker *worker;
 
-               worker = create_worker(gcwq, true);
+               worker = create_worker(pool, true);
                if (worker) {
-                       del_timer_sync(&gcwq->pool.mayday_timer);
+                       del_timer_sync(&pool->mayday_timer);
                        spin_lock_irq(&gcwq->lock);
                        start_worker(worker);
-                       BUG_ON(need_to_create_worker(gcwq));
+                       BUG_ON(need_to_create_worker(pool));
                        return true;
                }
 
-               if (!need_to_create_worker(gcwq))
+               if (!need_to_create_worker(pool))
                        break;
 
                __set_current_state(TASK_INTERRUPTIBLE);
                schedule_timeout(CREATE_COOLDOWN);
 
-               if (!need_to_create_worker(gcwq))
+               if (!need_to_create_worker(pool))
                        break;
        }
 
-       del_timer_sync(&gcwq->pool.mayday_timer);
+       del_timer_sync(&pool->mayday_timer);
        spin_lock_irq(&gcwq->lock);
-       if (need_to_create_worker(gcwq))
+       if (need_to_create_worker(pool))
                goto restart;
        return true;
 }
 
 /**
  * maybe_destroy_worker - destroy workers which have been idle for a while
- * @gcwq: gcwq to destroy workers for
+ * @pool: pool to destroy workers for
  *
- * Destroy @gcwq workers which have been idle for longer than
+ * Destroy @pool workers which have been idle for longer than
  * IDLE_WORKER_TIMEOUT.
  *
  * LOCKING:
@@ -1627,20 +1631,19 @@ restart:
  * false if no action was taken and gcwq->lock stayed locked, true
  * otherwise.
  */
-static bool maybe_destroy_workers(struct global_cwq *gcwq)
+static bool maybe_destroy_workers(struct worker_pool *pool)
 {
        bool ret = false;
 
-       while (too_many_workers(gcwq)) {
+       while (too_many_workers(pool)) {
                struct worker *worker;
                unsigned long expires;
 
-               worker = list_entry(gcwq->pool.idle_list.prev, struct worker,
-                                   entry);
+               worker = list_entry(pool->idle_list.prev, struct worker, entry);
                expires = worker->last_active + IDLE_WORKER_TIMEOUT;
 
                if (time_before(jiffies, expires)) {
-                       mod_timer(&gcwq->pool.idle_timer, expires);
+                       mod_timer(&pool->idle_timer, expires);
                        break;
                }
 
@@ -1673,7 +1676,8 @@ static bool maybe_destroy_workers(struct global_cwq *gcwq)
  */
 static bool manage_workers(struct worker *worker)
 {
-       struct global_cwq *gcwq = worker->pool->gcwq;
+       struct worker_pool *pool = worker->pool;
+       struct global_cwq *gcwq = pool->gcwq;
        bool ret = false;
 
        if (gcwq->flags & GCWQ_MANAGING_WORKERS)
@@ -1686,8 +1690,8 @@ static bool manage_workers(struct worker *worker)
         * Destroy and then create so that may_start_working() is true
         * on return.
         */
-       ret |= maybe_destroy_workers(gcwq);
-       ret |= maybe_create_worker(gcwq);
+       ret |= maybe_destroy_workers(pool);
+       ret |= maybe_create_worker(pool);
 
        gcwq->flags &= ~GCWQ_MANAGING_WORKERS;
 
@@ -1746,7 +1750,7 @@ static void cwq_activate_first_delayed(struct 
cpu_workqueue_struct *cwq)
 {
        struct work_struct *work = list_first_entry(&cwq->delayed_works,
                                                    struct work_struct, entry);
-       struct list_head *pos = gcwq_determine_ins_pos(cwq->pool->gcwq, cwq);
+       struct list_head *pos = pool_determine_ins_pos(cwq->pool, cwq);
 
        trace_workqueue_activate_work(work);
        move_linked_works(work, pos, NULL);
@@ -1874,7 +1878,7 @@ __acquires(&gcwq->lock)
 
                if (!list_empty(&pool->worklist) &&
                    get_work_cwq(nwork)->wq->flags & WQ_HIGHPRI)
-                       wake_up_worker(gcwq);
+                       wake_up_worker(pool);
                else
                        gcwq->flags &= ~GCWQ_HIGHPRI_PENDING;
        }
@@ -1890,8 +1894,8 @@ __acquires(&gcwq->lock)
         * Unbound gcwq isn't concurrency managed and work items should be
         * executed ASAP.  Wake up another worker if necessary.
         */
-       if ((worker->flags & WORKER_UNBOUND) && need_more_worker(gcwq))
-               wake_up_worker(gcwq);
+       if ((worker->flags & WORKER_UNBOUND) && need_more_worker(pool))
+               wake_up_worker(pool);
 
        spin_unlock_irq(&gcwq->lock);
 
@@ -1983,11 +1987,11 @@ woke_up:
        worker_leave_idle(worker);
 recheck:
        /* no more worker necessary? */
-       if (!need_more_worker(gcwq))
+       if (!need_more_worker(pool))
                goto sleep;
 
        /* do we need to manage? */
-       if (unlikely(!may_start_working(gcwq)) && manage_workers(worker))
+       if (unlikely(!may_start_working(pool)) && manage_workers(worker))
                goto recheck;
 
        /*
@@ -2018,11 +2022,11 @@ recheck:
                        move_linked_works(work, &worker->scheduled, NULL);
                        process_scheduled_works(worker);
                }
-       } while (keep_working(gcwq));
+       } while (keep_working(pool));
 
        worker_set_flags(worker, WORKER_PREP, false);
 sleep:
-       if (unlikely(need_to_manage_workers(gcwq)) && manage_workers(worker))
+       if (unlikely(need_to_manage_workers(pool)) && manage_workers(worker))
                goto recheck;
 
        /*
@@ -2107,8 +2111,8 @@ repeat:
                 * regular worker; otherwise, we end up with 0 concurrency
                 * and stalling the execution.
                 */
-               if (keep_working(gcwq))
-                       wake_up_worker(gcwq);
+               if (keep_working(pool))
+                       wake_up_worker(pool);
 
                spin_unlock_irq(&gcwq->lock);
        }
@@ -3383,7 +3387,7 @@ static int __cpuinit trustee_thread(void *__gcwq)
         * keep_working() are always true as long as the worklist is
         * not empty.
         */
-       atomic_set(get_gcwq_nr_running(gcwq->cpu), 0);
+       atomic_set(get_pool_nr_running(&gcwq->pool), 0);
 
        spin_unlock_irq(&gcwq->lock);
        del_timer_sync(&gcwq->pool.idle_timer);
@@ -3424,9 +3428,9 @@ static int __cpuinit trustee_thread(void *__gcwq)
                        wake_up_process(worker->task);
                }
 
-               if (need_to_create_worker(gcwq)) {
+               if (need_to_create_worker(&gcwq->pool)) {
                        spin_unlock_irq(&gcwq->lock);
-                       worker = create_worker(gcwq, false);
+                       worker = create_worker(&gcwq->pool, false);
                        spin_lock_irq(&gcwq->lock);
                        if (worker) {
                                worker->flags |= WORKER_ROGUE;
@@ -3540,7 +3544,7 @@ static int __devinit workqueue_cpu_callback(struct 
notifier_block *nfb,
                /* fall through */
        case CPU_UP_PREPARE:
                BUG_ON(gcwq->pool.first_idle);
-               new_worker = create_worker(gcwq, false);
+               new_worker = create_worker(&gcwq->pool, false);
                if (!new_worker) {
                        if (new_trustee)
                                kthread_stop(new_trustee);
@@ -3788,7 +3792,7 @@ void thaw_workqueues(void)
                                cwq_activate_first_delayed(cwq);
                }
 
-               wake_up_worker(gcwq);
+               wake_up_worker(&gcwq->pool);
 
                spin_unlock_irq(&gcwq->lock);
        }
@@ -3822,10 +3826,10 @@ static int __init init_workqueues(void)
 
                init_timer_deferrable(&gcwq->pool.idle_timer);
                gcwq->pool.idle_timer.function = idle_worker_timeout;
-               gcwq->pool.idle_timer.data = (unsigned long)gcwq;
+               gcwq->pool.idle_timer.data = (unsigned long)&gcwq->pool;
 
                setup_timer(&gcwq->pool.mayday_timer, gcwq_mayday_timeout,
-                           (unsigned long)gcwq);
+                           (unsigned long)&gcwq->pool);
 
                ida_init(&gcwq->pool.worker_ida);
 
@@ -3840,7 +3844,7 @@ static int __init init_workqueues(void)
 
                if (cpu != WORK_CPU_UNBOUND)
                        gcwq->flags &= ~GCWQ_DISASSOCIATED;
-               worker = create_worker(gcwq, true);
+               worker = create_worker(&gcwq->pool, true);
                BUG_ON(!worker);
                spin_lock_irq(&gcwq->lock);
                start_worker(worker);
-- 
1.7.7.3

<Prev in Thread] Current Thread [Next in Thread>