workqueue: rename manager_mutex to attach_mutex

	 * be executing on any CPU.  The pool behaves as an unbound one.

	 *

	 * Note that DISASSOCIATED should be flipped only while holding

	 * manager_mutex to avoid changing binding state while

	 * attach_mutex to avoid changing binding state while

	 * create_worker() is in progress.

	 */

	POOL_DISASSOCIATED	= 1 << 2,	/* cpu can't serve workers */

 *    cpu or grabbing pool->lock is enough for read access.  If

 *    POOL_DISASSOCIATED is set, it's identical to L.

 *

 * M: pool->manager_mutex protected.

 * A: pool->attach_mutex protected.

 *

 * PL: wq_pool_mutex protected.

 *

	/* see manage_workers() for details on the two manager mutexes */

	struct mutex		manager_arb;	/* manager arbitration */

	struct mutex		manager_mutex;	/* manager exclusion */

	struct list_head	workers;	/* M: attached workers */

	struct mutex		attach_mutex;	/* attach/detach exclusion */

	struct list_head	workers;	/* A: attached workers */

	struct completion	*detach_completion; /* all workers detached */

	struct ida		worker_ida;	/* worker IDs for task name */

 * @worker: iteration cursor

 * @pool: worker_pool to iterate workers of

 *

 * This must be called with @pool->manager_mutex.

 * This must be called with @pool->attach_mutex.

 *

 * The if/else clause exists only for the lockdep assertion and can be

 * ignored.

 */

#define for_each_pool_worker(worker, pool)				\

	list_for_each_entry((worker), &(pool)->workers, node)		\

		if (({ lockdep_assert_held(&pool->manager_mutex); false; })) { } \

		if (({ lockdep_assert_held(&pool->attach_mutex); false; })) { } \

		else

/**

{

	struct completion *detach_completion = NULL;

	mutex_lock(&pool->manager_mutex);

	mutex_lock(&pool->attach_mutex);

	list_del(&worker->node);

	if (list_empty(&pool->workers))

		detach_completion = pool->detach_completion;

	mutex_unlock(&pool->manager_mutex);

	mutex_unlock(&pool->attach_mutex);

	if (detach_completion)

		complete(detach_completion);

	/* prevent userland from meddling with cpumask of workqueue workers */

	worker->task->flags |= PF_NO_SETAFFINITY;

	mutex_lock(&pool->manager_mutex);

	mutex_lock(&pool->attach_mutex);

	/*

	 * set_cpus_allowed_ptr() will fail if the cpumask doesn't have any

	set_cpus_allowed_ptr(worker->task, pool->attrs->cpumask);

	/*

	 * The pool->manager_mutex ensures %POOL_DISASSOCIATED

	 * The pool->attach_mutex ensures %POOL_DISASSOCIATED

	 * remains stable across this function.  See the comments above the

	 * flag definition for details.

	 */

	/* successful, attach the worker to the pool */

	list_add_tail(&worker->node, &pool->workers);

	mutex_unlock(&pool->manager_mutex);

	mutex_unlock(&pool->attach_mutex);

	return worker;

		    (unsigned long)pool);

	mutex_init(&pool->manager_arb);

	mutex_init(&pool->manager_mutex);

	mutex_init(&pool->attach_mutex);

	INIT_LIST_HEAD(&pool->workers);

	ida_init(&pool->worker_ida);

	/*

	 * Become the manager and destroy all workers.  Grabbing

	 * manager_arb prevents @pool's workers from blocking on

	 * manager_mutex.

	 * attach_mutex.

	 */

	mutex_lock(&pool->manager_arb);

	WARN_ON(pool->nr_workers || pool->nr_idle);

	spin_unlock_irq(&pool->lock);

	mutex_lock(&pool->manager_mutex);

	mutex_lock(&pool->attach_mutex);

	if (!list_empty(&pool->workers))

		pool->detach_completion = &detach_completion;

	mutex_unlock(&pool->manager_mutex);

	mutex_unlock(&pool->attach_mutex);

	if (pool->detach_completion)

		wait_for_completion(pool->detach_completion);

	for_each_cpu_worker_pool(pool, cpu) {

		WARN_ON_ONCE(cpu != smp_processor_id());

		mutex_lock(&pool->manager_mutex);

		mutex_lock(&pool->attach_mutex);

		spin_lock_irq(&pool->lock);

		/*

		 * We've blocked all manager operations.  Make all workers

		 * We've blocked all attach/detach operations. Make all workers

		 * unbound and set DISASSOCIATED.  Before this, all workers

		 * except for the ones which are still executing works from

		 * before the last CPU down must be on the cpu.  After

		pool->flags |= POOL_DISASSOCIATED;

		spin_unlock_irq(&pool->lock);

		mutex_unlock(&pool->manager_mutex);

		mutex_unlock(&pool->attach_mutex);

		/*

		 * Call schedule() so that we cross rq->lock and thus can

{

	struct worker *worker;

	lockdep_assert_held(&pool->manager_mutex);

	lockdep_assert_held(&pool->attach_mutex);

	/*

	 * Restore CPU affinity of all workers.  As all idle workers should

	static cpumask_t cpumask;

	struct worker *worker;

	lockdep_assert_held(&pool->manager_mutex);

	lockdep_assert_held(&pool->attach_mutex);

	/* is @cpu allowed for @pool? */

	if (!cpumask_test_cpu(cpu, pool->attrs->cpumask))

		mutex_lock(&wq_pool_mutex);

		for_each_pool(pool, pi) {

			mutex_lock(&pool->manager_mutex);

			mutex_lock(&pool->attach_mutex);

			if (pool->cpu == cpu) {

				spin_lock_irq(&pool->lock);

				restore_unbound_workers_cpumask(pool, cpu);

			}

			mutex_unlock(&pool->manager_mutex);

			mutex_unlock(&pool->attach_mutex);

		}

		/* update NUMA affinity of unbound workqueues */

	struct task_struct	*task;		/* I: worker task */

	struct worker_pool	*pool;		/* I: the associated pool */

						/* L: for rescuers */

	struct list_head	node;		/* M: anchored at pool->workers */

						/* M: runs through worker->node */

	struct list_head	node;		/* A: anchored at pool->workers */

						/* A: runs through worker->node */

	unsigned long		last_active;	/* L: last active timestamp */

	unsigned int		flags;		/* X: flags */