workqueue: rename wq->flush_mutex to wq->mutex

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

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

 *

 * F: wq->flush_mutex protected.

 *

 * MG: pool->manager_mutex and pool->lock protected.  Writes require both

 *     locks.  Reads can happen under either lock.

 *

 *

 * PW: pwq_lock protected.

 *

 * FR: wq->flush_mutex and pwq_lock protected for writes.  Sched-RCU

 *     protected for reads.

 * WQ: wq->mutex protected.

 *

 * WR: wq->mutex and pwq_lock protected for writes.  Sched-RCU protected

 *     for reads.

 *

 * MD: wq_mayday_lock protected.

 */

	int			nr_active;	/* L: nr of active works */

	int			max_active;	/* L: max active works */

	struct list_head	delayed_works;	/* L: delayed works */

	struct list_head	pwqs_node;	/* FR: node on wq->pwqs */

	struct list_head	pwqs_node;	/* WR: node on wq->pwqs */

	struct list_head	mayday_node;	/* MD: node on wq->maydays */

	/*

 * Structure used to wait for workqueue flush.

 */

struct wq_flusher {

	struct list_head	list;		/* F: list of flushers */

	int			flush_color;	/* F: flush color waiting for */

	struct list_head	list;		/* WQ: list of flushers */

	int			flush_color;	/* WQ: flush color waiting for */

	struct completion	done;		/* flush completion */

};

struct workqueue_struct {

	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	pwqs;		/* WR: all pwqs of this wq */

	struct list_head	list;		/* PL: list of all workqueues */

	struct mutex		flush_mutex;	/* protects wq flushing */

	int			work_color;	/* F: current work color */

	int			flush_color;	/* F: current flush color */

	struct mutex		mutex;		/* protects this wq */

	int			work_color;	/* WQ: current work color */

	int			flush_color;	/* WQ: current flush color */

	atomic_t		nr_pwqs_to_flush; /* flush in progress */

	struct wq_flusher	*first_flusher;	/* F: first flusher */

	struct list_head	flusher_queue;	/* F: flush waiters */

	struct list_head	flusher_overflow; /* F: flush overflow list */

	struct wq_flusher	*first_flusher;	/* WQ: first flusher */

	struct list_head	flusher_queue;	/* WQ: flush waiters */

	struct list_head	flusher_overflow; /* WQ: flush overflow list */

	struct list_head	maydays;	/* MD: pwqs requesting rescue */

	struct worker		*rescuer;	/* I: rescue worker */

 * advanced to @work_color.

 *

 * CONTEXT:

 * mutex_lock(wq->flush_mutex).

 * mutex_lock(wq->mutex).

 *

 * RETURNS:

 * %true if @flush_color >= 0 and there's something to flush.  %false

	lock_map_acquire(&wq->lockdep_map);

	lock_map_release(&wq->lockdep_map);

	mutex_lock(&wq->flush_mutex);

	mutex_lock(&wq->mutex);

	/*

	 * Start-to-wait phase

		list_add_tail(&this_flusher.list, &wq->flusher_overflow);

	}

	mutex_unlock(&wq->flush_mutex);

	mutex_unlock(&wq->mutex);

	wait_for_completion(&this_flusher.done);

	if (wq->first_flusher != &this_flusher)

		return;

	mutex_lock(&wq->flush_mutex);

	mutex_lock(&wq->mutex);

	/* we might have raced, check again with mutex held */

	if (wq->first_flusher != &this_flusher)

	}

out_unlock:

	mutex_unlock(&wq->flush_mutex);

	mutex_unlock(&wq->mutex);

}

EXPORT_SYMBOL_GPL(flush_workqueue);

		return;

	/*

	 * Unlink @pwq.  Synchronization against flush_mutex isn't strictly

	 * Unlink @pwq.  Synchronization against wq->mutex isn't strictly

	 * necessary on release but do it anyway.  It's easier to verify

	 * and consistent with the linking path.

	 */

	mutex_lock(&wq->flush_mutex);

	mutex_lock(&wq->mutex);

	spin_lock_irq(&pwq_lock);

	list_del_rcu(&pwq->pwqs_node);

	spin_unlock_irq(&pwq_lock);

	mutex_unlock(&wq->flush_mutex);

	mutex_unlock(&wq->mutex);

	put_unbound_pool(pool);

	call_rcu_sched(&pwq->rcu, rcu_free_pwq);

	INIT_LIST_HEAD(&pwq->mayday_node);

	INIT_WORK(&pwq->unbound_release_work, pwq_unbound_release_workfn);

	mutex_lock(&wq->flush_mutex);

	mutex_lock(&wq->mutex);

	spin_lock_irq(&pwq_lock);

	/*

	 * Set the matching work_color.  This is synchronized with

	 * flush_mutex to avoid confusing flush_workqueue().

	 * wq->mutex to avoid confusing flush_workqueue().

	 */

	if (p_last_pwq)

		*p_last_pwq = first_pwq(wq);

	list_add_rcu(&pwq->pwqs_node, &wq->pwqs);

	spin_unlock_irq(&pwq_lock);

	mutex_unlock(&wq->flush_mutex);

	mutex_unlock(&wq->mutex);

}

/**

	/* init wq */

	wq->flags = flags;

	wq->saved_max_active = max_active;

	mutex_init(&wq->flush_mutex);

	mutex_init(&wq->mutex);

	atomic_set(&wq->nr_pwqs_to_flush, 0);

	INIT_LIST_HEAD(&wq->pwqs);

	INIT_LIST_HEAD(&wq->flusher_queue);