Re: [PATCH v2 2/5] locking/rtmutex: Initialize the ww_mutex context of a waiter

From: Mathieu Desnoyers

Date: Mon Nov 16 2026 - 13:37:27 EST


Hi Sebastian,

I *think* this is unrelated because the futex caller shouldn't end up
here. The __rt_mutex_slowlock() -> rt_mutex_handle_deadlock() should be
different for the futex and ww_mutex case.

The futex caller does not go through __rt_mutex_slowlock(). It gets to
the chain walk through the proxy lock:

futex_lock_pi()
rt_mutex_init_waiter(&rt_waiter)
__rt_mutex_start_proxy_lock()
task_blocks_on_rt_mutex(..., RT_MUTEX_FULL_CHAINWALK)
rt_mutex_adjust_prio_chain()

rt_mutex_adjust_prio_chain() reads waiter->ww_ctx in two places:

if (IS_ENABLED(CONFIG_PREEMPT_RT) && waiter->ww_ctx && detect_deadlock)
detect_deadlock = false;
[...]
if (IS_ENABLED(CONFIG_PREEMPT_RT) && orig_waiter && orig_waiter->ww_ctx)
ret = 0;

Both tests are under IS_ENABLED(CONFIG_PREEMPT_RT), not under
build_ww_mutex(). So the futex build of the chain walk has them too.

Is this really the case?
You have a lock chain where the ww_mutex and a regular rtmutex interact?

No ww_mutex is needed. Two PI futexes are enough. Both waiters come from
rt_mutex_init_waiter() in futex_lock_pi(), so both hold the 0x11 poison
in ww_ctx with CONFIG_DEBUG_RT_MUTEXES. The chain walk takes them for
ww_mutex waiters.

The deadlock case of futex_lock_pi_inherit (patch 4) is that ABBA. With
PREEMPT_RT and CONFIG_DEBUG_RT_MUTEXES, it fails without this patch: the
second FUTEX_LOCK_PI blocks. It passes with it.

I would argue that the full-chainwalk depends now
on a random stack value _and_ __waiter_less() might access the random
value if ww_mutex is enqueued and a regular mutex exists in the lock
chain.

Yes, those are the two effects. I reproduced the first one only. The
second one is from reading the code, which is why the changelog says
"would dereference".

You are right that the changelog is confusing. It starts with the futex
symptom, and only then says where the value is read. In the planned next
version, I would put the mechanism first, with the call path above. Does
this read better?

rt_mutex_init_waiter() does not set waiter->ww_ctx. Only
__rt_mutex_slowlock_locked() sets it. So the waiters of PI futexes
and rtlocks keep the 0x11 poison of CONFIG_DEBUG_RT_MUTEXES. Without
that option, they keep what was on the stack, unless the compiler
zeroes it.

With PREEMPT_RT, ww_mutexes are built on rtmutexes. They can create
a cycle in the lock graph legitimately, and the wound/die logic
resolves it. So rt_mutex_adjust_prio_chain() turns deadlock
detection off when it finds a waiter with a ww_ctx. It also drops
the -EDEADLK of a walk that started from such a waiter. Both tests
are under IS_ENABLED(CONFIG_PREEMPT_RT), so every build of the chain
walk has them.

FUTEX_LOCK_PI gets there with no ww_mutex in the chain:

futex_lock_pi()
rt_mutex_init_waiter()
__rt_mutex_start_proxy_lock()
task_blocks_on_rt_mutex()
rt_mutex_adjust_prio_chain()

The chain walk takes its waiters for ww_mutex waiters. With
PREEMPT_RT and CONFIG_DEBUG_RT_MUTEXES, FUTEX_LOCK_PI then reports
no deadlock. Two threads that each block on a PI futex the other
holds sleep forever. Without PREEMPT_RT, the second one gets
EDEADLK. FUTEX_LOCK_PI also blocks on a chain deeper than
max_lock_depth, instead of returning EDEADLK.

The ww_mutex build of the chain walk can also requeue such waiters.
On two of them with equal priority, __waiter_less() would
dereference the poison.

Fix this by clearing waiter->ww_ctx in rt_mutex_init_waiter().

Thanks,

Mathieu

--
Mathieu Desnoyers
EfficiOS Inc.
https://www.efficios.com