locking/rtmutex: Make sure we wake anything on the wake_q when we release the lock...

Bert reported seeing occasional boot hangs when running with
PREEPT_RT and bisected it down to commit 894d1b3db41c
("locking/mutex: Remove wakeups from under mutex::wait_lock").

It looks like I missed a few spots where we drop the wait_lock and
potentially call into schedule without waking up the tasks on the
wake_q structure. Since the tasks being woken are ww_mutex tasks
they need to be able to run to release the mutex and unblock the
task that currently is planning to wake them. Thus we can deadlock.

So make sure we wake the wake_q tasks when we unlock the wait_lock.

Closes: https://lore.kernel.org/lkml/[email protected]
Fixes: 894d1b3db41c ("locking/mutex: Remove wakeups from under mutex::wait_lock")
Reported-by: Bert Karwatzki <[email protected]>
Signed-off-by: John Stultz <[email protected]>
Signed-off-by: Peter Zijlstra (Intel) <[email protected]>
Link: https://lkml.kernel.org/r/[email protected]

diff --git a/kernel/locking/rtmutex.c b/kernel/locking/rtmutex.c
index e858de203eb6fa6e274cf1317624a70f0fe538e2..697a56d3d949b9e5d9d17979f511bcb335895623 100644 (file)
--- a/kernel/locking/rtmutex.c
+++ b/kernel/locking/rtmutex.c
@@ -1292,7 +1292,13 @@ static int __sched task_blocks_on_rt_mutex(struct rt_mutex_base *lock,
         */
        get_task_struct(owner);
 
+       preempt_disable();
        raw_spin_unlock_irq(&lock->wait_lock);
+       /* wake up any tasks on the wake_q before calling rt_mutex_adjust_prio_chain */
+       wake_up_q(wake_q);
+       wake_q_init(wake_q);
+       preempt_enable();
+
 
        res = rt_mutex_adjust_prio_chain(owner, chwalk, lock,
                                         next_lock, waiter, task);
@@ -1596,6 +1602,7 @@ static void __sched remove_waiter(struct rt_mutex_base *lock,
  *                      or TASK_UNINTERRUPTIBLE)
  * @timeout:            the pre-initialized and started timer, or NULL for none
  * @waiter:             the pre-initialized rt_mutex_waiter
+ * @wake_q:             wake_q of tasks to wake when we drop the lock->wait_lock
  *
  * Must be called with lock->wait_lock held and interrupts disabled
  */
@@ -1603,7 +1610,8 @@ static int __sched rt_mutex_slowlock_block(struct rt_mutex_base *lock,
                                           struct ww_acquire_ctx *ww_ctx,
                                           unsigned int state,
                                           struct hrtimer_sleeper *timeout,
-                                          struct rt_mutex_waiter *waiter)
+                                          struct rt_mutex_waiter *waiter,
+                                          struct wake_q_head *wake_q)
        __releases(&lock->wait_lock) __acquires(&lock->wait_lock)
 {
        struct rt_mutex *rtm = container_of(lock, struct rt_mutex, rtmutex);
@@ -1634,7 +1642,13 @@ static int __sched rt_mutex_slowlock_block(struct rt_mutex_base *lock,
                        owner = rt_mutex_owner(lock);
                else
                        owner = NULL;
+               preempt_disable();
                raw_spin_unlock_irq(&lock->wait_lock);
+               if (wake_q) {
+                       wake_up_q(wake_q);
+                       wake_q_init(wake_q);
+               }
+               preempt_enable();
 
                if (!owner || !rtmutex_spin_on_owner(lock, waiter, owner))
                        rt_mutex_schedule();
@@ -1708,7 +1722,7 @@ static int __sched __rt_mutex_slowlock(struct rt_mutex_base *lock,
 
        ret = task_blocks_on_rt_mutex(lock, waiter, current, ww_ctx, chwalk, wake_q);
        if (likely(!ret))
-               ret = rt_mutex_slowlock_block(lock, ww_ctx, state, NULL, waiter);
+               ret = rt_mutex_slowlock_block(lock, ww_ctx, state, NULL, waiter, wake_q);
 
        if (likely(!ret)) {
                /* acquired the lock */

diff --git a/kernel/locking/rtmutex_api.c b/kernel/locking/rtmutex_api.c
index 33ea31d6a7b3b67d74c204b4c6adfcf1d0d9fb26..191e4720e546627aed0d7ec715673b1b8753b130 100644 (file)
--- a/kernel/locking/rtmutex_api.c
+++ b/kernel/locking/rtmutex_api.c
@@ -383,7 +383,7 @@ int __sched rt_mutex_wait_proxy_lock(struct rt_mutex_base *lock,
        raw_spin_lock_irq(&lock->wait_lock);
        /* sleep on the mutex */
        set_current_state(TASK_INTERRUPTIBLE);
-       ret = rt_mutex_slowlock_block(lock, NULL, TASK_INTERRUPTIBLE, to, waiter);
+       ret = rt_mutex_slowlock_block(lock, NULL, TASK_INTERRUPTIBLE, to, waiter, NULL);
        /*
         * try_to_take_rt_mutex() sets the waiter bit unconditionally. We might
         * have to fix that up.