futex: Rename {,__}{,un}queue_me()

 * the second.

 *

 * PI futexes are typically woken before they are removed from the hash list via

 * the rt_mutex code. See unqueue_me_pi().

 * the rt_mutex code. See futex_unqueue_pi().

 */

struct futex_q {

	struct plist_node list;

};

static const struct futex_q futex_q_init = {

	/* list gets initialized in queue_me()*/

	/* list gets initialized in futex_queue()*/

	.key		= FUTEX_KEY_INIT,

	.bitset		= FUTEX_BITSET_MATCH_ANY,

	.requeue_state	= ATOMIC_INIT(Q_REQUEUE_PI_NONE),

	/*

	 * We get here with hb->lock held, and having found a

	 * futex_top_waiter(). This means that futex_lock_pi() of said futex_q

	 * has dropped the hb->lock in between queue_me() and unqueue_me_pi(),

	 * has dropped the hb->lock in between futex_queue() and futex_unqueue_pi(),

	 * which in turn means that futex_lock_pi() still has a reference on

	 * our pi_state.

	 *

	 * Increment the counter before taking the lock so that

	 * a potential waker won't miss a to-be-slept task that is

	 * waiting for the spinlock. This is safe as all queue_lock()

	 * users end up calling queue_me(). Similarly, for housekeeping,

	 * users end up calling futex_queue(). Similarly, for housekeeping,

	 * decrement the counter at queue_unlock() when some error has

	 * occurred and we don't end up adding the task to the list.

	 */

	hb_waiters_dec(hb);

}

static inline void __queue_me(struct futex_q *q, struct futex_hash_bucket *hb)

static inline void __futex_queue(struct futex_q *q, struct futex_hash_bucket *hb)

{

	int prio;

}

/**

 * queue_me() - Enqueue the futex_q on the futex_hash_bucket

 * futex_queue() - Enqueue the futex_q on the futex_hash_bucket

 * @q:	The futex_q to enqueue

 * @hb:	The destination hash bucket

 *

 * The hb->lock must be held by the caller, and is released here. A call to

 * queue_me() is typically paired with exactly one call to unqueue_me().  The

 * exceptions involve the PI related operations, which may use unqueue_me_pi()

 * futex_queue() is typically paired with exactly one call to futex_unqueue().  The

 * exceptions involve the PI related operations, which may use futex_unqueue_pi()

 * or nothing if the unqueue is done as part of the wake process and the unqueue

 * state is implicit in the state of woken task (see futex_wait_requeue_pi() for

 * an example).

 */

static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)

static inline void futex_queue(struct futex_q *q, struct futex_hash_bucket *hb)

	__releases(&hb->lock)

{

	__queue_me(q, hb);

	__futex_queue(q, hb);

	spin_unlock(&hb->lock);

}

/**

 * unqueue_me() - Remove the futex_q from its futex_hash_bucket

 * futex_unqueue() - Remove the futex_q from its futex_hash_bucket

 * @q:	The futex_q to unqueue

 *

 * The q->lock_ptr must not be held by the caller. A call to unqueue_me() must

 * be paired with exactly one earlier call to queue_me().

 * The q->lock_ptr must not be held by the caller. A call to futex_unqueue() must

 * be paired with exactly one earlier call to futex_queue().

 *

 * Return:

 *  - 1 - if the futex_q was still queued (and we removed unqueued it);

 *  - 0 - if the futex_q was already removed by the waking thread

 */

static int unqueue_me(struct futex_q *q)

static int futex_unqueue(struct futex_q *q)

{

	spinlock_t *lock_ptr;

	int ret = 0;

 * PI futexes can not be requeued and must remove themselves from the

 * hash bucket. The hash bucket lock (i.e. lock_ptr) is held.

 */

static void unqueue_me_pi(struct futex_q *q)

static void futex_unqueue_pi(struct futex_q *q)

{

	__unqueue_futex(q);

}

/**

 * futex_wait_queue_me() - queue_me() and wait for wakeup, timeout, or signal

 * futex_wait_queue_me() - futex_queue() and wait for wakeup, timeout, or signal

 * @hb:		the futex hash bucket, must be locked by the caller

 * @q:		the futex_q to queue up on

 * @timeout:	the prepared hrtimer_sleeper, or null for no timeout

	/*

	 * The task state is guaranteed to be set before another task can

	 * wake it. set_current_state() is implemented using smp_store_mb() and

	 * queue_me() calls spin_unlock() upon completion, both serializing

	 * futex_queue() calls spin_unlock() upon completion, both serializing

	 * access to the hash list and forcing another memory barrier.

	 */

	set_current_state(TASK_INTERRUPTIBLE);

	queue_me(q, hb);

	futex_queue(q, hb);

	/* Arm the timer */

	if (timeout)

	if (ret)

		goto out;

	/* queue_me and wait for wakeup, timeout, or a signal. */

	/* futex_queue and wait for wakeup, timeout, or a signal. */

	futex_wait_queue_me(hb, &q, to);

	/* If we were woken (and unqueued), we succeeded, whatever. */

	ret = 0;

	if (!unqueue_me(&q))

	if (!futex_unqueue(&q))

		goto out;

	ret = -ETIMEDOUT;

	if (to && !to->task)

	/*

	 * Only actually queue now that the atomic ops are done:

	 */

	__queue_me(&q, hb);

	__futex_queue(&q, hb);

	if (trylock) {

		ret = rt_mutex_futex_trylock(&q.pi_state->pi_mutex);

	if (res)

		ret = (res < 0) ? res : 0;

	unqueue_me_pi(&q);

	futex_unqueue_pi(&q);

	spin_unlock(q.lock_ptr);

	goto out;

		if (res)

			ret = (res < 0) ? res : 0;

		unqueue_me_pi(&q);

		futex_unqueue_pi(&q);

		spin_unlock(q.lock_ptr);

		if (ret == -EINTR) {