Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-12-29 09:16:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

workqueue: rename wq_mutex to wq_pool_mutex

Browse Source 
wq->flush_mutex will be renamed to wq->mutex and cover all fields
specific to each workqueue and eventually replace pwq_lock, which will
make locking simpler and easier to understand.

Rename wq_mutex to wq_pool_mutex to avoid confusion with wq->mutex.
After the scheduled changes, wq_pool_mutex won't be protecting
anything specific to each workqueue instance anyway.

This patch is pure rename.

tj: s/wqs_mutex/wq_pool_mutex/.  Rewrote description.

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Lai Jiangshan <laijs@cn.fujitsu.com>
This commit is contained in:
Lai Jiangshan 2013-03-25 16:57:17 -07:00 committed by Tejun Heo
parent 519e3c1163
commit 68e13a67dd
1 changed files with 55 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
kernel/workqueue.c
View File

@ -123,9 +123,9 @@ enum {
* MG: pool->manager_mutex and pool->lock protected. Writes require both
* locks. Reads can happen under either lock.
*
* WQ: wq_mutex protected.
* PL: wq_pool_mutex protected.
*
* WR: wq_mutex protected for writes. Sched-RCU protected for reads.
* PR: wq_pool_mutex protected for writes. Sched-RCU protected for reads.
*
* PW: pwq_lock protected.
*
@ -163,8 +163,8 @@ struct worker_pool {
struct idr worker_idr; /* MG: worker IDs and iteration */
struct workqueue_attrs *attrs; /* I: worker attributes */
struct hlist_node hash_node; /* WQ: unbound_pool_hash node */
int refcnt; /* WQ: refcnt for unbound pools */
struct hlist_node hash_node; /* PL: unbound_pool_hash node */
int refcnt; /* PL: refcnt for unbound pools */
/*
* The current concurrency level. As it's likely to be accessed
@ -226,10 +226,10 @@ struct wq_device;
* the appropriate worker_pool through its pool_workqueues.
*/
struct workqueue_struct {
unsigned int flags; /* WQ: WQ_* flags */
unsigned int flags; /* PL: WQ_* flags */
struct pool_workqueue __percpu *cpu_pwqs; /* I: per-cpu pwq's */
struct list_head pwqs; /* FR: all pwqs of this wq */
struct list_head list; /* WQ: list of all workqueues */
struct list_head list; /* PL: list of all workqueues */
struct mutex flush_mutex; /* protects wq flushing */
int work_color; /* F: current work color */
@ -242,7 +242,7 @@ struct workqueue_struct {
struct list_head maydays; /* MD: pwqs requesting rescue */
struct worker *rescuer; /* I: rescue worker */
int nr_drainers; /* WQ: drain in progress */
int nr_drainers; /* PL: drain in progress */
int saved_max_active; /* PW: saved pwq max_active */
#ifdef CONFIG_SYSFS
@ -256,20 +256,20 @@ struct workqueue_struct {
static struct kmem_cache *pwq_cache;
static DEFINE_MUTEX(wq_mutex); /* protects workqueues and pools */
static DEFINE_MUTEX(wq_pool_mutex); /* protects pools and workqueues list */
static DEFINE_SPINLOCK(pwq_lock); /* protects pool_workqueues */
static DEFINE_SPINLOCK(wq_mayday_lock); /* protects wq->maydays list */
static LIST_HEAD(workqueues); /* WQ: list of all workqueues */
static bool workqueue_freezing; /* WQ: have wqs started freezing? */
static LIST_HEAD(workqueues); /* PL: list of all workqueues */
static bool workqueue_freezing; /* PL: have wqs started freezing? */
/* the per-cpu worker pools */
static DEFINE_PER_CPU_SHARED_ALIGNED(struct worker_pool [NR_STD_WORKER_POOLS],
cpu_worker_pools);
static DEFINE_IDR(worker_pool_idr); /* WR: idr of all pools */
static DEFINE_IDR(worker_pool_idr); /* PR: idr of all pools */
/* WQ: hash of all unbound pools keyed by pool->attrs */
/* PL: hash of all unbound pools keyed by pool->attrs */
static DEFINE_HASHTABLE(unbound_pool_hash, UNBOUND_POOL_HASH_ORDER);
/* I: attributes used when instantiating standard unbound pools on demand */
@ -293,10 +293,10 @@ static void copy_workqueue_attrs(struct workqueue_attrs *to,
#define CREATE_TRACE_POINTS
#include <trace/events/workqueue.h>
#define assert_rcu_or_wq_mutex() \
#define assert_rcu_or_pool_mutex() \
rcu_lockdep_assert(rcu_read_lock_sched_held() || \
lockdep_is_held(&wq_mutex), \
"sched RCU or wq_mutex should be held")
lockdep_is_held(&wq_pool_mutex), \
"sched RCU or wq_pool_mutex should be held")
#define assert_rcu_or_pwq_lock() \
rcu_lockdep_assert(rcu_read_lock_sched_held() || \
@ -323,16 +323,16 @@ static void copy_workqueue_attrs(struct workqueue_attrs *to,
* @pool: iteration cursor
* @pi: integer used for iteration
*
* This must be called either with wq_mutex held or sched RCU read locked.
* If the pool needs to be used beyond the locking in effect, the caller is
* responsible for guaranteeing that the pool stays online.
* This must be called either with wq_pool_mutex held or sched RCU read
* locked. If the pool needs to be used beyond the locking in effect, the
* caller is responsible for guaranteeing that the pool stays online.
*
* The if/else clause exists only for the lockdep assertion and can be
* ignored.
*/
#define for_each_pool(pool, pi) \
idr_for_each_entry(&worker_pool_idr, pool, pi) \
if (({ assert_rcu_or_wq_mutex(); false; })) { } \
if (({ assert_rcu_or_pool_mutex(); false; })) { } \
else
/**
@ -489,7 +489,7 @@ static int worker_pool_assign_id(struct worker_pool *pool)
{
int ret;
lockdep_assert_held(&wq_mutex);
lockdep_assert_held(&wq_pool_mutex);
do {
if (!idr_pre_get(&worker_pool_idr, GFP_KERNEL))
@ -607,9 +607,9 @@ static struct pool_workqueue *get_work_pwq(struct work_struct *work)
*
* Return the worker_pool @work was last associated with. %NULL if none.
*
* Pools are created and destroyed under wq_mutex, and allows read access
* under sched-RCU read lock. As such, this function should be called
* under wq_mutex or with preemption disabled.
* Pools are created and destroyed under wq_pool_mutex, and allows read
* access under sched-RCU read lock. As such, this function should be
* called under wq_pool_mutex or with preemption disabled.
*
* All fields of the returned pool are accessible as long as the above
* mentioned locking is in effect. If the returned pool needs to be used
@ -621,7 +621,7 @@ static struct worker_pool *get_work_pool(struct work_struct *work)
unsigned long data = atomic_long_read(&work->data);
int pool_id;
assert_rcu_or_wq_mutex();
assert_rcu_or_pool_mutex();
if (data & WORK_STRUCT_PWQ)
return ((struct pool_workqueue *)
@ -2684,10 +2684,10 @@ void drain_workqueue(struct workqueue_struct *wq)
* hotter than drain_workqueue() and already looks at @wq->flags.
* Use __WQ_DRAINING so that queue doesn't have to check nr_drainers.
*/
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
if (!wq->nr_drainers++)
wq->flags |= __WQ_DRAINING;
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
reflush:
flush_workqueue(wq);
@ -2714,10 +2714,10 @@ void drain_workqueue(struct workqueue_struct *wq)
local_irq_enable();
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
if (!--wq->nr_drainers)
wq->flags &= ~__WQ_DRAINING;
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
}
EXPORT_SYMBOL_GPL(drain_workqueue);
@ -3430,16 +3430,16 @@ static void put_unbound_pool(struct worker_pool *pool)
{
struct worker *worker;
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
if (--pool->refcnt) {
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
return;
}
/* sanity checks */
if (WARN_ON(!(pool->flags & POOL_DISASSOCIATED)) ||
WARN_ON(!list_empty(&pool->worklist))) {
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
return;
}
@ -3448,7 +3448,7 @@ static void put_unbound_pool(struct worker_pool *pool)
idr_remove(&worker_pool_idr, pool->id);
hash_del(&pool->hash_node);
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
/*
* Become the manager and destroy all workers. Grabbing
@ -3489,7 +3489,7 @@ static struct worker_pool *get_unbound_pool(const struct workqueue_attrs *attrs)
u32 hash = wqattrs_hash(attrs);
struct worker_pool *pool;
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
/* do we already have a matching pool? */
hash_for_each_possible(unbound_pool_hash, pool, hash_node, hash) {
@ -3520,10 +3520,10 @@ static struct worker_pool *get_unbound_pool(const struct workqueue_attrs *attrs)
/* install */
hash_add(unbound_pool_hash, &pool->hash_node, hash);
out_unlock:
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
return pool;
fail:
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
if (pool)
put_unbound_pool(pool);
return NULL;
@ -3803,10 +3803,11 @@ struct workqueue_struct *__alloc_workqueue_key(const char *fmt,
goto err_destroy;
/*
* wq_mutex protects global freeze state and workqueues list. Grab
* it, adjust max_active and add the new @wq to workqueues list.
* wq_pool_mutex protects global freeze state and workqueues list.
* Grab it, adjust max_active and add the new @wq to workqueues
* list.
*/
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
spin_lock_irq(&pwq_lock);
for_each_pwq(pwq, wq)
@ -3815,7 +3816,7 @@ struct workqueue_struct *__alloc_workqueue_key(const char *fmt,
list_add(&wq->list, &workqueues);
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
return wq;
@ -3866,9 +3867,9 @@ void destroy_workqueue(struct workqueue_struct *wq)
* wq list is used to freeze wq, remove from list after
* flushing is complete in case freeze races us.
*/
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
list_del_init(&wq->list);
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
workqueue_sysfs_unregister(wq);
@ -4198,7 +4199,7 @@ static int __cpuinit workqueue_cpu_up_callback(struct notifier_block *nfb,
case CPU_DOWN_FAILED:
case CPU_ONLINE:
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
for_each_pool(pool, pi) {
mutex_lock(&pool->manager_mutex);
@ -4216,7 +4217,7 @@ static int __cpuinit workqueue_cpu_up_callback(struct notifier_block *nfb,
mutex_unlock(&pool->manager_mutex);
}
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
break;
}
return NOTIFY_OK;
@ -4292,7 +4293,7 @@ EXPORT_SYMBOL_GPL(work_on_cpu);
* pool->worklist.
*
* CONTEXT:
* Grabs and releases wq_mutex, pwq_lock and pool->lock's.
* Grabs and releases wq_pool_mutex, pwq_lock and pool->lock's.
*/
void freeze_workqueues_begin(void)
{
@ -4301,7 +4302,7 @@ void freeze_workqueues_begin(void)
struct pool_workqueue *pwq;
int pi;
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
WARN_ON_ONCE(workqueue_freezing);
workqueue_freezing = true;
@ -4322,7 +4323,7 @@ void freeze_workqueues_begin(void)
}
spin_unlock_irq(&pwq_lock);
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
}
/**
@ -4332,7 +4333,7 @@ void freeze_workqueues_begin(void)
* between freeze_workqueues_begin() and thaw_workqueues().
*
* CONTEXT:
* Grabs and releases wq_mutex.
* Grabs and releases wq_pool_mutex.
*
* RETURNS:
* %true if some freezable workqueues are still busy. %false if freezing
@ -4344,7 +4345,7 @@ bool freeze_workqueues_busy(void)
struct workqueue_struct *wq;
struct pool_workqueue *pwq;
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
WARN_ON_ONCE(!workqueue_freezing);
@ -4367,7 +4368,7 @@ bool freeze_workqueues_busy(void)
rcu_read_unlock_sched();
}
out_unlock:
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
return busy;
}
@ -4378,7 +4379,7 @@ bool freeze_workqueues_busy(void)
* frozen works are transferred to their respective pool worklists.
*
* CONTEXT:
* Grabs and releases wq_mutex, pwq_lock and pool->lock's.
* Grabs and releases wq_pool_mutex, pwq_lock and pool->lock's.
*/
void thaw_workqueues(void)
{
@ -4387,7 +4388,7 @@ void thaw_workqueues(void)
struct worker_pool *pool;
int pi;
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
if (!workqueue_freezing)
goto out_unlock;
@ -4410,7 +4411,7 @@ void thaw_workqueues(void)
workqueue_freezing = false;
out_unlock:
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
}
#endif /* CONFIG_FREEZER */
@ -4442,9 +4443,9 @@ static int __init init_workqueues(void)
pool->attrs->nice = std_nice[i++];
/* alloc pool ID */
mutex_lock(&wq_mutex);
mutex_lock(&wq_pool_mutex);
BUG_ON(worker_pool_assign_id(pool));
mutex_unlock(&wq_mutex);
mutex_unlock(&wq_pool_mutex);
}
}