Lines Matching refs:hb
318 * @hb: the hash bucket the futex_q's reside in
321 * Must be called with the hb lock held.
323 static struct futex_q *futex_top_waiter(struct futex_hash_bucket *hb,
328 plist_for_each_entry(this, &hb->chain, list) {
452 struct futex_hash_bucket *hb;
468 hb = hash_futex(&key);
471 spin_lock(&hb->lock);
479 spin_unlock(&hb->lock);
491 spin_unlock(&hb->lock);
499 lookup_pi_state(u32 uval, struct futex_hash_bucket *hb,
508 head = &hb->chain;
607 * @hb: the pi futex hash bucket
608 * @key: the futex key associated with uaddr and hb
620 * The hb->lock and futex_key refs shall be held by the caller.
622 static int futex_lock_pi_atomic(u32 __user *uaddr, struct futex_hash_bucket *hb,
699 ret = lookup_pi_state(uval, hb, key, ps);
874 struct futex_hash_bucket *hb;
887 hb = hash_futex(&key);
888 spin_lock(&hb->lock);
889 head = &hb->chain;
908 spin_unlock(&hb->lock);
1006 * requeue_futex() - Requeue a futex_q from one hb to another
1037 * @hb: the hash_bucket of the requeue target futex
1042 * futex, but remove it from the hb and NULL the rt_waiter so it can detect
1043 * atomic lock acquisition. Set the q->lock_ptr to the requeue target hb->lock
1045 * with both q->lock_ptr and hb->lock held.
1049 struct futex_hash_bucket *hb)
1060 q->lock_ptr = &hb->lock;
1062 q->list.plist.spinlock = &hb->lock;
1364 struct futex_hash_bucket *hb;
1366 hb = hash_futex(&q->key);
1367 q->lock_ptr = &hb->lock;
1369 spin_lock(&hb->lock);
1370 return hb;
1374 queue_unlock(struct futex_q *q, struct futex_hash_bucket *hb)
1376 spin_unlock(&hb->lock);
1382 * @hb: The destination hash bucket
1384 * The hb->lock must be held by the caller, and is released here. A call to
1391 static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
1407 q->list.plist.spinlock = &hb->lock;
1409 plist_add(&q->list, &hb->chain);
1411 spin_unlock(&hb->lock);
1602 * acquire the lock. Must be called with the hb lock held.
1668 * @hb: the futex hash bucket, must be locked by the caller
1672 static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
1682 queue_me(q, hb);
1713 * @hb: storage for hash_bucket pointer to be returned to caller
1717 * Return with the hb lock held and a q.key reference on success, and unlocked
1721 * 0 - uaddr contains val and hb has been locked
1722 * <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlcoked
1725 struct futex_q *q, struct futex_hash_bucket **hb)
1754 *hb = queue_lock(q);
1759 queue_unlock(q, *hb);
1773 queue_unlock(q, *hb);
1788 struct futex_hash_bucket *hb;
1812 * Prepare to wait on uaddr. On success, holds hb lock and increments
1815 ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
1820 futex_wait_queue_me(hb, &q, to);
1895 struct futex_hash_bucket *hb;
1920 hb = queue_lock(&q);
1922 ret = futex_lock_pi_atomic(uaddr, hb, &q.key, &q.pi_state, current, 0);
1936 queue_unlock(&q, hb);
1948 queue_me(&q, hb);
1988 queue_unlock(&q, hb);
1998 queue_unlock(&q, hb);
2018 struct futex_hash_bucket *hb;
2038 hb = hash_futex(&key);
2039 spin_lock(&hb->lock);
2063 head = &hb->chain;
2088 spin_unlock(&hb->lock);
2095 spin_unlock(&hb->lock);
2107 * @hb: the hash_bucket futex_q was original enqueued on
2115 * called with the hb lock held.
2122 int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
2129 * With the hb lock held, we avoid races while we process the wakeup.
2130 * We only need to hold hb (and not hb2) to ensure atomicity as the
2131 * wakeup code can't change q.key from uaddr to uaddr2 if we hold hb.
2136 WARN_ON(q->lock_ptr && (&hb->lock != q->lock_ptr));
2201 struct futex_hash_bucket *hb;
2239 ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
2243 /* Queue the futex_q, drop the hb lock, wait for wakeup. */
2244 futex_wait_queue_me(hb, &q, to);
2246 spin_lock(&hb->lock);
2247 ret = handle_early_requeue_pi_wakeup(hb, &q, &key2, to);
2248 spin_unlock(&hb->lock);
2254 * we took the hb->lock above, we also know that futex_requeue() has