hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'core-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip 

* 'core-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  futex: Add memory barrier commentary to futex_wait_queue_me()
  futex: Fix wakeup race by setting TASK_INTERRUPTIBLE before queue_me()
  futex: Correct futex_q woken state commentary
  futex: Make function kernel-doc commentary consistent
  futex: Correct queue_me and unqueue_me commentary
  futex: Correct futex_wait_requeue_pi() commentary
This commit is contained in:
Linus Torvalds 2009-09-26 10:15:53 -07:00
parent 49e70dda35 9beba3c54d
commit 3b383767c4
1 changed files with 76 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
kernel/futex.c
View File

@ -89,36 +89,36 @@ struct futex_pi_state {
union futex_key key; union futex_key key;
}; };
/* /**
* We use this hashed waitqueue instead of a normal wait_queue_t, so * struct futex_q - The hashed futex queue entry, one per waiting task
* @task: the task waiting on the futex
* @lock_ptr: the hash bucket lock
* @key: the key the futex is hashed on
* @pi_state: optional priority inheritance state
* @rt_waiter: rt_waiter storage for use with requeue_pi
* @requeue_pi_key: the requeue_pi target futex key
* @bitset: bitset for the optional bitmasked wakeup
*
* We use this hashed waitqueue, instead of a normal wait_queue_t, so
* we can wake only the relevant ones (hashed queues may be shared). * we can wake only the relevant ones (hashed queues may be shared).
* *
* A futex_q has a woken state, just like tasks have TASK_RUNNING. * A futex_q has a woken state, just like tasks have TASK_RUNNING.
* It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0. * It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0.
* The order of wakup is always to make the first condition true, then * The order of wakup is always to make the first condition true, then
* wake up q->waiter, then make the second condition true. * the second.
*
* PI futexes are typically woken before they are removed from the hash list via
* the rt_mutex code. See unqueue_me_pi().
*/ */
struct futex_q { struct futex_q {
struct plist_node list; struct plist_node list;
/* Waiter reference */
struct task_struct *task; struct task_struct *task;
/* Which hash list lock to use: */
spinlock_t *lock_ptr; spinlock_t *lock_ptr;
/* Key which the futex is hashed on: */
union futex_key key; union futex_key key;
/* Optional priority inheritance state: */
struct futex_pi_state *pi_state; struct futex_pi_state *pi_state;
/* rt_waiter storage for requeue_pi: */
struct rt_mutex_waiter *rt_waiter; struct rt_mutex_waiter *rt_waiter;
/* The expected requeue pi target futex key: */
union futex_key *requeue_pi_key; union futex_key *requeue_pi_key;
/* Bitset for the optional bitmasked wakeup */
u32 bitset; u32 bitset;
}; };
@ -198,11 +198,12 @@ static void drop_futex_key_refs(union futex_key *key)
} }
/** /**
* get_futex_key - Get parameters which are the keys for a futex. * get_futex_key() - Get parameters which are the keys for a futex
* @uaddr: virtual address of the futex * @uaddr: virtual address of the futex
* @fshared: 0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED * @fshared: 0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED
* @key: address where result is stored. * @key: address where result is stored.
* @rw: mapping needs to be read/write (values: VERIFY_READ, VERIFY_WRITE) * @rw: mapping needs to be read/write (values: VERIFY_READ,
* VERIFY_WRITE)
* *
* Returns a negative error code or 0 * Returns a negative error code or 0
* The key words are stored in *key on success. * The key words are stored in *key on success.
@ -288,8 +289,8 @@ void put_futex_key(int fshared, union futex_key *key)
drop_futex_key_refs(key); drop_futex_key_refs(key);
} }
/* /**
* fault_in_user_writeable - fault in user address and verify RW access * fault_in_user_writeable() - Fault in user address and verify RW access
* @uaddr: pointer to faulting user space address * @uaddr: pointer to faulting user space address
* *
* Slow path to fixup the fault we just took in the atomic write * Slow path to fixup the fault we just took in the atomic write
@ -309,8 +310,8 @@ static int fault_in_user_writeable(u32 __user *uaddr)
/** /**
* futex_top_waiter() - Return the highest priority waiter on a futex * futex_top_waiter() - Return the highest priority waiter on a futex
* @hb: the hash bucket the futex_q's reside in * @hb: the hash bucket the futex_q's reside in
* @key: the futex key (to distinguish it from other futex futex_q's) * @key: the futex key (to distinguish it from other futex futex_q's)
* *
* Must be called with the hb lock held. * Must be called with the hb lock held.
*/ */
@ -588,7 +589,7 @@ lookup_pi_state(u32 uval, struct futex_hash_bucket *hb,
} }
/** /**
* futex_lock_pi_atomic() - atomic work required to acquire a pi aware futex * futex_lock_pi_atomic() - Atomic work required to acquire a pi aware futex
* @uaddr: the pi futex user address * @uaddr: the pi futex user address
* @hb: the pi futex hash bucket * @hb: the pi futex hash bucket
* @key: the futex key associated with uaddr and hb * @key: the futex key associated with uaddr and hb
@ -1011,9 +1012,9 @@ void requeue_futex(struct futex_q *q, struct futex_hash_bucket *hb1,
/** /**
* requeue_pi_wake_futex() - Wake a task that acquired the lock during requeue * requeue_pi_wake_futex() - Wake a task that acquired the lock during requeue
* q: the futex_q * @q: the futex_q
* key: the key of the requeue target futex * @key: the key of the requeue target futex
* hb: the hash_bucket of the requeue target futex * @hb: the hash_bucket of the requeue target futex
* *
* During futex_requeue, with requeue_pi=1, it is possible to acquire the * During futex_requeue, with requeue_pi=1, it is possible to acquire the
* target futex if it is uncontended or via a lock steal. Set the futex_q key * target futex if it is uncontended or via a lock steal. Set the futex_q key
@ -1350,6 +1351,25 @@ static inline struct futex_hash_bucket *queue_lock(struct futex_q *q)
return hb; return hb;
} }
static inline void
queue_unlock(struct futex_q *q, struct futex_hash_bucket *hb)
{
spin_unlock(&hb->lock);
drop_futex_key_refs(&q->key);
}
/**
* queue_me() - 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()
* 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 queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
{ {
int prio; int prio;
@ -1373,19 +1393,17 @@ static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
spin_unlock(&hb->lock); spin_unlock(&hb->lock);
} }
static inline void /**
queue_unlock(struct futex_q *q, struct futex_hash_bucket *hb) * unqueue_me() - Remove the futex_q from its futex_hash_bucket
{ * @q: The futex_q to unqueue
spin_unlock(&hb->lock); *
drop_futex_key_refs(&q->key); * 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().
*
/* * Returns:
* queue_me and unqueue_me must be called as a pair, each * 1 - if the futex_q was still queued (and we removed unqueued it)
* exactly once. They are called with the hashed spinlock held. * 0 - if the futex_q was already removed by the waking thread
*/ */
/* Return 1 if we were still queued (ie. 0 means we were woken) */
static int unqueue_me(struct futex_q *q) static int unqueue_me(struct futex_q *q)
{ {
spinlock_t *lock_ptr; spinlock_t *lock_ptr;
@ -1638,17 +1656,14 @@ out:
static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q, static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
struct hrtimer_sleeper *timeout) struct hrtimer_sleeper *timeout)
{ {
queue_me(q, hb);
/* /*
* There might have been scheduling since the queue_me(), as we * The task state is guaranteed to be set before another task can
* cannot hold a spinlock across the get_user() in case it * wake it. set_current_state() is implemented using set_mb() and
* faults, and we cannot just set TASK_INTERRUPTIBLE state when * queue_me() calls spin_unlock() upon completion, both serializing
* queueing ourselves into the futex hash. This code thus has to * access to the hash list and forcing another memory barrier.
* rely on the futex_wake() code removing us from hash when it
* wakes us up.
*/ */
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
queue_me(q, hb);
/* Arm the timer */ /* Arm the timer */
if (timeout) { if (timeout) {
@ -1658,8 +1673,8 @@ static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
} }
/* /*
* !plist_node_empty() is safe here without any lock. * If we have been removed from the hash list, then another task
* q.lock_ptr != 0 is not safe, because of ordering against wakeup. * has tried to wake us, and we can skip the call to schedule().
*/ */
if (likely(!plist_node_empty(&q->list))) { if (likely(!plist_node_empty(&q->list))) {
/* /*
@ -2114,12 +2129,12 @@ int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
/** /**
* futex_wait_requeue_pi() - Wait on uaddr and take uaddr2 * futex_wait_requeue_pi() - Wait on uaddr and take uaddr2
* @uaddr: the futex we initialyl wait on (non-pi) * @uaddr: the futex we initially wait on (non-pi)
* @fshared: whether the futexes are shared (1) or not (0). They must be * @fshared: whether the futexes are shared (1) or not (0). They must be
* the same type, no requeueing from private to shared, etc. * the same type, no requeueing from private to shared, etc.
* @val: the expected value of uaddr * @val: the expected value of uaddr
* @abs_time: absolute timeout * @abs_time: absolute timeout
* @bitset: 32 bit wakeup bitset set by userspace, defaults to all. * @bitset: 32 bit wakeup bitset set by userspace, defaults to all
* @clockrt: whether to use CLOCK_REALTIME (1) or CLOCK_MONOTONIC (0) * @clockrt: whether to use CLOCK_REALTIME (1) or CLOCK_MONOTONIC (0)
* @uaddr2: the pi futex we will take prior to returning to user-space * @uaddr2: the pi futex we will take prior to returning to user-space
* *
@ -2246,7 +2261,7 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, int fshared,
res = fixup_owner(uaddr2, fshared, &q, !ret); res = fixup_owner(uaddr2, fshared, &q, !ret);
/* /*
* If fixup_owner() returned an error, proprogate that. If it * If fixup_owner() returned an error, proprogate that. If it
* acquired the lock, clear our -ETIMEDOUT or -EINTR. * acquired the lock, clear -ETIMEDOUT or -EINTR.
*/ */
if (res) if (res)
ret = (res < 0) ? res : 0; ret = (res < 0) ? res : 0;
@ -2302,9 +2317,9 @@ out:
*/ */
/** /**
* sys_set_robust_list - set the robust-futex list head of a task * sys_set_robust_list() - Set the robust-futex list head of a task
* @head: pointer to the list-head * @head: pointer to the list-head
* @len: length of the list-head, as userspace expects * @len: length of the list-head, as userspace expects
*/ */
SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
size_t, len) size_t, len)
@ -2323,10 +2338,10 @@ SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
} }
/** /**
* sys_get_robust_list - get the robust-futex list head of a task * sys_get_robust_list() - Get the robust-futex list head of a task
* @pid: pid of the process [zero for current task] * @pid: pid of the process [zero for current task]
* @head_ptr: pointer to a list-head pointer, the kernel fills it in * @head_ptr: pointer to a list-head pointer, the kernel fills it in
* @len_ptr: pointer to a length field, the kernel fills in the header size * @len_ptr: pointer to a length field, the kernel fills in the header size
*/ */
SYSCALL_DEFINE3(get_robust_list, int, pid, SYSCALL_DEFINE3(get_robust_list, int, pid,
struct robust_list_head __user * __user *, head_ptr, struct robust_list_head __user * __user *, head_ptr,