mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
To: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: peterz@infradead.org, tglx@kernel.org, mingo@redhat.com,
	linux-kernel@vger.kernel.org, will@kernel.org, boqun@kernel.org,
	longman@redhat.com, rostedt@goodmis.org, clrkwllms@kernel.org,
	dvhart@infradead.org, dave@stgolabs.net, andrealmeid@igalia.com,
	shuah@kernel.org, juri.lelli@redhat.com,
	linux-rt-devel@lists.linux.dev, linux-kselftest@vger.kernel.org,
	stable@vger.kernel.org
Subject: Re: [PATCH v2 1/5] locking/rtmutex: Stop spinning on the owner when the waiter is woken
Date: Wed, 18 Nov 2026 15:19:12 +0100	[thread overview]
Message-ID: <20261118141912.GnOg6YYM@linutronix.de> (raw)
In-Reply-To: <83330898-b6de-469c-ac20-7367c1eb4f0e@efficios.com>

On 2026-11-16 13:36:39 [-0500], Mathieu Desnoyers wrote:
> Hi Sebastian,
Hi,

…
> I kept the check for TASK_UNINTERRUPTIBLE on the rt_mutex side. A
> ww_mutex wound also wakes an uninterruptible waiter, and the ABBA case
> of patch 5 needs the spin to stop there.

Not sure what is related to. I don't see this in this patch.
TASK_UNINTERRUPTIBLE vs TASK_INTERRUPTIBLE would make a difference for
signals here.

…
> From: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
> Date: Fri, 6 Nov 2026 13:56:54 -0500
> Subject: [PATCH] locking/rtmutex: Stop spinning on the owner when the waiter
>  is woken
> 
> The top waiter of an rt_mutex sets its sleep state. Then it spins in
> rtmutex_spin_on_owner() as long as the owner is running. A wakeup sets
> the waiter back to TASK_RUNNING. The spin loop does not check for this.
> 
> The rtmutex_spin_on_owner() is just an optimization with the idea that
> if the owner is still running on a CPU, it will likely release it soon.
> If the owner gets preempted or schedules out on its own, the spinning
> will stop and the waiter will sleep. This came from PREEMPT_RT adaptive
> spinning for rt_spin_locks that allowed them to behave more like normal
> spin locks and speed up PREEMPT_RT performance.
> 
> The problem is that when this was implemented for futex and normal
> mutexes it did not account for timeouts or other mechanisms where
> the owner releasing the lock wasn't the only way for the spinning
> task to exit the mutex acquire. The spinning currently does not
> account for anything else but the lock being released or the owner
> sleeping.
> 
> The owner of a PI futex is a user task. It can run for a long time.
> With an owner spinning in userspace, a 1ms pthread_mutex_timedlock()
> returned up to 1.4s late in testing. The timeout signal or any signal
> to the waiter will not stop it from spinning, and the signal will be
> delayed until it exits the spin.
> 
> With PREEMPT_RT, two contexts that take two ww_mutexes in opposite
> order spin on each other. The wound that resolves this wakes up the
> younger one, but it keeps spinning. Only something else that needs one
> of the two CPUs stops them. By default, the fair server does it after
> 950ms, to run SCHED_OTHER tasks.
> 
> Luckily, when the spinning task needs to exit the mutex lock code, its
> state is set to TASK_RUNNING. By having the spin check the spinning
> task's state to see if it switches to running, it can exit the spin
> appropriately.
> 
> On a wakeup, the spin returns true. The caller then takes the wait lock
> again and checks why it was woken, with no call to the scheduler. Only
> rt_mutex_slowlock_block() asks for the check. An rtlock waiter is made
> running by the lock handoff alone, and the handoff changes the owner,
> which already ends the spin. Sebastian Andrzej Siewior suggested both.

For my taste this is overly verbose. In the spirit of "ain't nobody got
time for that" what about

   rtmutex_spin_on_owner() does not abort spinning if the task state
   returns to TASK_RUNNING. This can happen if the task receives a signal
   or timeout. It will continue to spin on the lock as long as the owner is
   on the CPU and so delaying the processing of the signal or timeout
   condition.
   
   This affects PI futex users in general and ww_mutexes users on
   PREEMPT_RT.
   
   Stop spinning when the task state changes to TASK_RUNNING. Return true
   to let the caller check condition again instead going to the scheduler.
   Skip this in rtlock_slowlock_locked() which can not be interrupted and
   always needs to acquire the lock.
 
> Fixes: 992caf7f1724 ("locking/rtmutex: Add adaptive spinwait mechanism")
> Cc: stable@vger.kernel.org
> Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

I agree with the change as-is so
Reviewed-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>

but the text here is too verbose.

> --- a/kernel/locking/rtmutex.c
> +++ b/kernel/locking/rtmutex.c
> @@ -1510,6 +1511,13 @@ static bool rtmutex_spin_on_owner(struct rt_mutex_base *lock,
>  		 * the rcu_read_lock() ensures the memory stays valid.
>  		 */
>  		barrier();
> +		/*
> +		 * Stop spinning when current is woken, for example by a
> +		 * timeout or a signal. Return true: the caller checks why,
> +		 * with no call to the scheduler.
> +		 */

		/* If became running, trylock again or abort (signal/
		 * timeout)
		 */

> +		if (check_wakeup && task_is_running(current))
> +			break;
>  		/*
>  		 * Stop spinning when:
>  		 *  - the lock owner has been scheduled out
> @@ -1890,7 +1899,12 @@ static void __sched rtlock_slowlock_locked(struct rt_mutex_base *lock,
>  			owner = NULL;
>  		raw_spin_unlock_irq_wake(&lock->wait_lock, wake_q);
> -		if (!owner || !rtmutex_spin_on_owner(lock, &waiter, owner)) {
> +		/*
> +		 * Only the lock handoff makes an rtlock waiter running,
> +		 * and it changes the owner. Any other wakeup goes to
> +		 * saved_state. So the spin need not check for a wakeup.
> +		 */

I would drop this entirely. It says below that the check is for signal/
timeout which is something we don't have here. So I don't think this is
required.

> +		if (!owner || !rtmutex_spin_on_owner(lock, &waiter, owner, false)) {
>  			lockevent_inc(rtlock_slow_sleep);
>  			schedule_rtlock();
>  		}

Sebastian

  reply	other threads:[~2026-11-18 14:19 UTC|newest]

Thread overview: 16+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-08 14:13 [PATCH v2 0/5] locking/rtmutex: priority inheritance fixes and tests Mathieu Desnoyers
2026-11-08 14:13 ` [PATCH v2 1/5] locking/rtmutex: Stop spinning on the owner when the waiter is woken Mathieu Desnoyers
2026-11-16 12:06   ` Sebastian Andrzej Siewior
2026-11-16 18:36     ` Mathieu Desnoyers
2026-11-18 14:19       ` Sebastian Andrzej Siewior [this message]
2026-11-08 14:13 ` [PATCH v2 2/5] locking/rtmutex: Initialize the ww_mutex context of a waiter Mathieu Desnoyers
2026-11-16 13:58   ` Sebastian Andrzej Siewior
2026-11-16 18:37     ` Mathieu Desnoyers
2026-11-18 14:40       ` Sebastian Andrzej Siewior
2026-11-08 14:13 ` [PATCH v2 3/5] locking/rtmutex: Clone the sort keys in rt_mutex_enqueue_pi() Mathieu Desnoyers
2026-11-16 15:11   ` Sebastian Andrzej Siewior
2026-11-16 18:35     ` Mathieu Desnoyers
2026-11-08 14:13 ` [PATCH v2 4/5] selftests/futex: Test priority inheritance on PI futexes Mathieu Desnoyers
2026-11-16 16:56   ` Sebastian Andrzej Siewior
2026-11-16 18:48     ` Mathieu Desnoyers
2026-11-08 14:13 ` [PATCH v2 5/5] locking/ww_mutex/test: Time an ABBA with both owners running Mathieu Desnoyers

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261118141912.GnOg6YYM@linutronix.de \
    --to=bigeasy@linutronix.de \
    --cc=andrealmeid@igalia.com \
    --cc=boqun@kernel.org \
    --cc=clrkwllms@kernel.org \
    --cc=dave@stgolabs.net \
    --cc=dvhart@infradead.org \
    --cc=juri.lelli@redhat.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-kselftest@vger.kernel.org \
    --cc=linux-rt-devel@lists.linux.dev \
    --cc=longman@redhat.com \
    --cc=mathieu.desnoyers@efficios.com \
    --cc=mingo@redhat.com \
    --cc=peterz@infradead.org \
    --cc=rostedt@goodmis.org \
    --cc=shuah@kernel.org \
    --cc=stable@vger.kernel.org \
    --cc=tglx@kernel.org \
    --cc=will@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®