Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

workqueue: implement and use pwq_adjust_max_active()

Browse source 
Rename pwq_set_max_active() to pwq_adjust_max_active() and move
pool_workqueue->max_active synchronization and max_active
determination logic into it.

The new function should be called with workqueue_lock held for stable
workqueue->saved_max_active, determines the current max_active value
the target pool_workqueue should be using from @wq->saved_max_active
and the state of the associated pool, and applies it with proper
synchronization.

The current two users - workqueue_set_max_active() and
thaw_workqueues() - are updated accordingly.  In addition, the manual
freezing handling in __alloc_workqueue_key() and
freeze_workqueues_begin() are replaced with calls to
pwq_adjust_max_active().

This centralizes max_active handling so that it's less error-prone.

Signed-off-by: Tejun Heo <tj@kernel.org>
This commit is contained in:
Tejun Heo 2013-03-13 16:51:35 -07:00
parent 0fbd95aa8a
commit 699ce097ef
1 changed files with 38 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

83
kernel/workqueue.c
View file

@ -3726,23 +3726,38 @@ static void pwq_unbound_release_workfn(struct work_struct *work)
} }
/** /**
* pwq_set_max_active - adjust max_active of a pwq * pwq_adjust_max_active - update a pwq's max_active to the current setting
* @pwq: target pool_workqueue * @pwq: target pool_workqueue
* @max_active: new max_active value.
* *
* Set @pwq->max_active to @max_active and activate delayed works if * If @pwq isn't freezing, set @pwq->max_active to the associated
* increased. * workqueue's saved_max_active and activate delayed work items
* * accordingly. If @pwq is freezing, clear @pwq->max_active to zero.
* CONTEXT:
* spin_lock_irq(pool->lock).
*/ */
static void pwq_set_max_active(struct pool_workqueue *pwq, int max_active) static void pwq_adjust_max_active(struct pool_workqueue *pwq)
{ {
pwq->max_active = max_active; struct workqueue_struct *wq = pwq->wq;
bool freezable = wq->flags & WQ_FREEZABLE;
while (!list_empty(&pwq->delayed_works) && /* for @wq->saved_max_active */
pwq->nr_active < pwq->max_active) lockdep_assert_held(&workqueue_lock);
pwq_activate_first_delayed(pwq);
/* fast exit for non-freezable wqs */
if (!freezable && pwq->max_active == wq->saved_max_active)
return;
spin_lock(&pwq->pool->lock);
if (!freezable || !(pwq->pool->flags & POOL_FREEZING)) {
pwq->max_active = wq->saved_max_active;
while (!list_empty(&pwq->delayed_works) &&
pwq->nr_active < pwq->max_active)
pwq_activate_first_delayed(pwq);
} else {
pwq->max_active = 0;
}
spin_unlock(&pwq->pool->lock);
} }
static void init_and_link_pwq(struct pool_workqueue *pwq, static void init_and_link_pwq(struct pool_workqueue *pwq,
@ -3932,15 +3947,14 @@ struct workqueue_struct *__alloc_workqueue_key(const char *fmt,
goto err_destroy; goto err_destroy;
/* /*
* workqueue_lock protects global freeze state and workqueues * workqueue_lock protects global freeze state and workqueues list.
* list. Grab it, set max_active accordingly and add the new * Grab it, adjust max_active and add the new workqueue to
* workqueue to workqueues list. * workqueues list.
*/ */
spin_lock_irq(&workqueue_lock); spin_lock_irq(&workqueue_lock);
if (workqueue_freezing && wq->flags & WQ_FREEZABLE) for_each_pwq(pwq, wq)
for_each_pwq(pwq, wq) pwq_adjust_max_active(pwq);
pwq->max_active = 0;
list_add(&wq->list, &workqueues); list_add(&wq->list, &workqueues);
@ -4055,17 +4069,8 @@ void workqueue_set_max_active(struct workqueue_struct *wq, int max_active)
wq->saved_max_active = max_active; wq->saved_max_active = max_active;
for_each_pwq(pwq, wq) { for_each_pwq(pwq, wq)
struct worker_pool *pool = pwq->pool; pwq_adjust_max_active(pwq);
spin_lock(&pool->lock);
if (!(wq->flags & WQ_FREEZABLE) ||
!(pool->flags & POOL_FREEZING))
pwq_set_max_active(pwq, max_active);
spin_unlock(&pool->lock);
}
spin_unlock_irq(&workqueue_lock); spin_unlock_irq(&workqueue_lock);
} }
@ -4358,14 +4363,8 @@ void freeze_workqueues_begin(void)
/* suppress further executions by setting max_active to zero */ /* suppress further executions by setting max_active to zero */
list_for_each_entry(wq, &workqueues, list) { list_for_each_entry(wq, &workqueues, list) {
if (!(wq->flags & WQ_FREEZABLE)) for_each_pwq(pwq, wq)
continue; pwq_adjust_max_active(pwq);
for_each_pwq(pwq, wq) {
spin_lock(&pwq->pool->lock);
pwq->max_active = 0;
spin_unlock(&pwq->pool->lock);
}
} }
spin_unlock_irq(&workqueue_lock); spin_unlock_irq(&workqueue_lock);
@ -4445,14 +4444,8 @@ void thaw_workqueues(void)
/* restore max_active and repopulate worklist */ /* restore max_active and repopulate worklist */
list_for_each_entry(wq, &workqueues, list) { list_for_each_entry(wq, &workqueues, list) {
if (!(wq->flags & WQ_FREEZABLE)) for_each_pwq(pwq, wq)
continue; pwq_adjust_max_active(pwq);
for_each_pwq(pwq, wq) {
spin_lock(&pwq->pool->lock);
pwq_set_max_active(pwq, wq->saved_max_active);
spin_unlock(&pwq->pool->lock);
}
} }
/* kick workers */ /* kick workers */