223 lines
7.6 KiB
Diff
223 lines
7.6 KiB
Diff
From b76ffe4039e544a31a181ba1a921851b2427e497 Mon Sep 17 00:00:00 2001
|
|
From: Thomas Gleixner <tglx@linutronix.de>
|
|
Date: Fri, 10 Jun 2011 11:04:15 +0200
|
|
Subject: [PATCH 193/279] rtmutex-futex-prepare-rt.patch
|
|
|
|
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
|
|
---
|
|
kernel/futex.c | 77 ++++++++++++++++++++++++++++++++++++++---------
|
|
kernel/rtmutex.c | 31 ++++++++++++++++---
|
|
kernel/rtmutex_common.h | 2 ++
|
|
3 files changed, 91 insertions(+), 19 deletions(-)
|
|
|
|
diff --git a/kernel/futex.c b/kernel/futex.c
|
|
index 80fb1c6..cecabcf 100644
|
|
--- a/kernel/futex.c
|
|
+++ b/kernel/futex.c
|
|
@@ -1423,6 +1423,16 @@ retry_private:
|
|
requeue_pi_wake_futex(this, &key2, hb2);
|
|
drop_count++;
|
|
continue;
|
|
+ } else if (ret == -EAGAIN) {
|
|
+ /*
|
|
+ * Waiter was woken by timeout or
|
|
+ * signal and has set pi_blocked_on to
|
|
+ * PI_WAKEUP_INPROGRESS before we
|
|
+ * tried to enqueue it on the rtmutex.
|
|
+ */
|
|
+ this->pi_state = NULL;
|
|
+ free_pi_state(pi_state);
|
|
+ continue;
|
|
} else if (ret) {
|
|
/* -EDEADLK */
|
|
this->pi_state = NULL;
|
|
@@ -2267,7 +2277,7 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
|
|
struct hrtimer_sleeper timeout, *to = NULL;
|
|
struct rt_mutex_waiter rt_waiter;
|
|
struct rt_mutex *pi_mutex = NULL;
|
|
- struct futex_hash_bucket *hb;
|
|
+ struct futex_hash_bucket *hb, *hb2;
|
|
union futex_key key2 = FUTEX_KEY_INIT;
|
|
struct futex_q q = futex_q_init;
|
|
int res, ret;
|
|
@@ -2314,20 +2324,55 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
|
|
/* Queue the futex_q, drop the hb lock, wait for wakeup. */
|
|
futex_wait_queue_me(hb, &q, to);
|
|
|
|
- spin_lock(&hb->lock);
|
|
- ret = handle_early_requeue_pi_wakeup(hb, &q, &key2, to);
|
|
- spin_unlock(&hb->lock);
|
|
- if (ret)
|
|
- goto out_put_keys;
|
|
+ /*
|
|
+ * On RT we must avoid races with requeue and trying to block
|
|
+ * on two mutexes (hb->lock and uaddr2's rtmutex) by
|
|
+ * serializing access to pi_blocked_on with pi_lock.
|
|
+ */
|
|
+ raw_spin_lock_irq(¤t->pi_lock);
|
|
+ if (current->pi_blocked_on) {
|
|
+ /*
|
|
+ * We have been requeued or are in the process of
|
|
+ * being requeued.
|
|
+ */
|
|
+ raw_spin_unlock_irq(¤t->pi_lock);
|
|
+ } else {
|
|
+ /*
|
|
+ * Setting pi_blocked_on to PI_WAKEUP_INPROGRESS
|
|
+ * prevents a concurrent requeue from moving us to the
|
|
+ * uaddr2 rtmutex. After that we can safely acquire
|
|
+ * (and possibly block on) hb->lock.
|
|
+ */
|
|
+ current->pi_blocked_on = PI_WAKEUP_INPROGRESS;
|
|
+ raw_spin_unlock_irq(¤t->pi_lock);
|
|
+
|
|
+ spin_lock(&hb->lock);
|
|
+
|
|
+ /*
|
|
+ * Clean up pi_blocked_on. We might leak it otherwise
|
|
+ * when we succeeded with the hb->lock in the fast
|
|
+ * path.
|
|
+ */
|
|
+ raw_spin_lock_irq(¤t->pi_lock);
|
|
+ current->pi_blocked_on = NULL;
|
|
+ raw_spin_unlock_irq(¤t->pi_lock);
|
|
+
|
|
+ ret = handle_early_requeue_pi_wakeup(hb, &q, &key2, to);
|
|
+ spin_unlock(&hb->lock);
|
|
+ if (ret)
|
|
+ goto out_put_keys;
|
|
+ }
|
|
|
|
/*
|
|
- * In order for us to be here, we know our q.key == key2, and since
|
|
- * we took the hb->lock above, we also know that futex_requeue() has
|
|
- * completed and we no longer have to concern ourselves with a wakeup
|
|
- * race with the atomic proxy lock acquisition by the requeue code. The
|
|
- * futex_requeue dropped our key1 reference and incremented our key2
|
|
- * reference count.
|
|
+ * In order to be here, we have either been requeued, are in
|
|
+ * the process of being requeued, or requeue successfully
|
|
+ * acquired uaddr2 on our behalf. If pi_blocked_on was
|
|
+ * non-null above, we may be racing with a requeue. Do not
|
|
+ * rely on q->lock_ptr to be hb2->lock until after blocking on
|
|
+ * hb->lock or hb2->lock. The futex_requeue dropped our key1
|
|
+ * reference and incremented our key2 reference count.
|
|
*/
|
|
+ hb2 = hash_futex(&key2);
|
|
|
|
/* Check if the requeue code acquired the second futex for us. */
|
|
if (!q.rt_waiter) {
|
|
@@ -2336,9 +2381,10 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
|
|
* did a lock-steal - fix up the PI-state in that case.
|
|
*/
|
|
if (q.pi_state && (q.pi_state->owner != current)) {
|
|
- spin_lock(q.lock_ptr);
|
|
+ spin_lock(&hb2->lock);
|
|
+ BUG_ON(&hb2->lock != q.lock_ptr);
|
|
ret = fixup_pi_state_owner(uaddr2, &q, current);
|
|
- spin_unlock(q.lock_ptr);
|
|
+ spin_unlock(&hb2->lock);
|
|
}
|
|
} else {
|
|
/*
|
|
@@ -2351,7 +2397,8 @@ static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
|
|
ret = rt_mutex_finish_proxy_lock(pi_mutex, to, &rt_waiter, 1);
|
|
debug_rt_mutex_free_waiter(&rt_waiter);
|
|
|
|
- spin_lock(q.lock_ptr);
|
|
+ spin_lock(&hb2->lock);
|
|
+ BUG_ON(&hb2->lock != q.lock_ptr);
|
|
/*
|
|
* Fixup the pi_state owner and possibly acquire the lock if we
|
|
* haven't already.
|
|
diff --git a/kernel/rtmutex.c b/kernel/rtmutex.c
|
|
index 723fd3a..13b3c92 100644
|
|
--- a/kernel/rtmutex.c
|
|
+++ b/kernel/rtmutex.c
|
|
@@ -67,6 +67,11 @@ static void fixup_rt_mutex_waiters(struct rt_mutex *lock)
|
|
clear_rt_mutex_waiters(lock);
|
|
}
|
|
|
|
+static int rt_mutex_real_waiter(struct rt_mutex_waiter *waiter)
|
|
+{
|
|
+ return waiter && waiter != PI_WAKEUP_INPROGRESS;
|
|
+}
|
|
+
|
|
/*
|
|
* We can speed up the acquire/release, if the architecture
|
|
* supports cmpxchg and if there's no debugging state to be set up
|
|
@@ -196,7 +201,7 @@ static int rt_mutex_adjust_prio_chain(struct task_struct *task,
|
|
* reached or the state of the chain has changed while we
|
|
* dropped the locks.
|
|
*/
|
|
- if (!waiter)
|
|
+ if (!rt_mutex_real_waiter(waiter))
|
|
goto out_unlock_pi;
|
|
|
|
/*
|
|
@@ -399,6 +404,23 @@ static int task_blocks_on_rt_mutex(struct rt_mutex *lock,
|
|
int chain_walk = 0, res;
|
|
|
|
raw_spin_lock_irqsave(&task->pi_lock, flags);
|
|
+
|
|
+ /*
|
|
+ * In the case of futex requeue PI, this will be a proxy
|
|
+ * lock. The task will wake unaware that it is enqueueed on
|
|
+ * this lock. Avoid blocking on two locks and corrupting
|
|
+ * pi_blocked_on via the PI_WAKEUP_INPROGRESS
|
|
+ * flag. futex_wait_requeue_pi() sets this when it wakes up
|
|
+ * before requeue (due to a signal or timeout). Do not enqueue
|
|
+ * the task if PI_WAKEUP_INPROGRESS is set.
|
|
+ */
|
|
+ if (task != current && task->pi_blocked_on == PI_WAKEUP_INPROGRESS) {
|
|
+ raw_spin_unlock_irqrestore(&task->pi_lock, flags);
|
|
+ return -EAGAIN;
|
|
+ }
|
|
+
|
|
+ BUG_ON(rt_mutex_real_waiter(task->pi_blocked_on));
|
|
+
|
|
__rt_mutex_adjust_prio(task);
|
|
waiter->task = task;
|
|
waiter->lock = lock;
|
|
@@ -423,7 +445,7 @@ static int task_blocks_on_rt_mutex(struct rt_mutex *lock,
|
|
plist_add(&waiter->pi_list_entry, &owner->pi_waiters);
|
|
|
|
__rt_mutex_adjust_prio(owner);
|
|
- if (owner->pi_blocked_on)
|
|
+ if (rt_mutex_real_waiter(owner->pi_blocked_on))
|
|
chain_walk = 1;
|
|
raw_spin_unlock_irqrestore(&owner->pi_lock, flags);
|
|
}
|
|
@@ -517,7 +539,7 @@ static void remove_waiter(struct rt_mutex *lock,
|
|
}
|
|
__rt_mutex_adjust_prio(owner);
|
|
|
|
- if (owner->pi_blocked_on)
|
|
+ if (rt_mutex_real_waiter(owner->pi_blocked_on))
|
|
chain_walk = 1;
|
|
|
|
raw_spin_unlock_irqrestore(&owner->pi_lock, flags);
|
|
@@ -551,7 +573,8 @@ void rt_mutex_adjust_pi(struct task_struct *task)
|
|
raw_spin_lock_irqsave(&task->pi_lock, flags);
|
|
|
|
waiter = task->pi_blocked_on;
|
|
- if (!waiter || waiter->list_entry.prio == task->prio) {
|
|
+ if (!rt_mutex_real_waiter(waiter) ||
|
|
+ waiter->list_entry.prio == task->prio) {
|
|
raw_spin_unlock_irqrestore(&task->pi_lock, flags);
|
|
return;
|
|
}
|
|
diff --git a/kernel/rtmutex_common.h b/kernel/rtmutex_common.h
|
|
index 53a66c8..b43d832 100644
|
|
--- a/kernel/rtmutex_common.h
|
|
+++ b/kernel/rtmutex_common.h
|
|
@@ -103,6 +103,8 @@ static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock)
|
|
/*
|
|
* PI-futex support (proxy locking functions, etc.):
|
|
*/
|
|
+#define PI_WAKEUP_INPROGRESS ((struct rt_mutex_waiter *) 1)
|
|
+
|
|
extern struct task_struct *rt_mutex_next_owner(struct rt_mutex *lock);
|
|
extern void rt_mutex_init_proxy_locked(struct rt_mutex *lock,
|
|
struct task_struct *proxy_owner);
|