[PATCH v2] locking/rtmutex: Annotate API and implementation

[PATCH v2] locking/rtmutex: Annotate API and implementation

[Bart Van Assche]

Add lock context annotations to the rtmutex API and implementation and
enable lock context analysis.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---

Changes compared to v1: fixed the CONFIG_PREEMPT_RT=y build.

 include/linux/rtmutex.h      | 22 +++++++++++++++-------
 kernel/locking/Makefile      |  1 +
 kernel/locking/rtmutex.c     |  5 +++++
 kernel/locking/rtmutex_api.c |  6 ++++++
 4 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/include/linux/rtmutex.h b/include/linux/rtmutex.h
index 78e7e588817c..9e1f012f89db 100644
--- a/include/linux/rtmutex.h
+++ b/include/linux/rtmutex.h
@@ -56,6 +56,8 @@ static inline struct task_struct *rt_mutex_owner(struct rt_mutex_base *lock)
 #endif
 extern void rt_mutex_base_init(struct rt_mutex_base *rtb);
 
+context_lock_struct(rt_mutex);
+
 /**
  * The rt_mutex structure
  *
@@ -108,8 +110,10 @@ do { \
 extern void __rt_mutex_init(struct rt_mutex *lock, const char *name, struct lock_class_key *key);
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
-extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass);
-extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock);
+extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
+	__acquires(lock);
+extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
+	__acquires(lock);
 #define rt_mutex_lock(lock) rt_mutex_lock_nested(lock, 0)
 #define rt_mutex_lock_nest_lock(lock, nest_lock)			\
 	do {								\
@@ -118,15 +122,19 @@ extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *
 	} while (0)
 
 #else
-extern void rt_mutex_lock(struct rt_mutex *lock);
+extern void rt_mutex_lock(struct rt_mutex *lock) __acquires(lock);
 #define rt_mutex_lock_nested(lock, subclass) rt_mutex_lock(lock)
 #define rt_mutex_lock_nest_lock(lock, nest_lock) rt_mutex_lock(lock)
 #endif
 
-extern int rt_mutex_lock_interruptible(struct rt_mutex *lock);
-extern int rt_mutex_lock_killable(struct rt_mutex *lock);
-extern int rt_mutex_trylock(struct rt_mutex *lock);
+extern int rt_mutex_lock_interruptible(struct rt_mutex *lock)
+	__cond_acquires(0, lock);
+extern int rt_mutex_lock_killable(struct rt_mutex *lock)
+	__cond_acquires(0, lock);
+extern int rt_mutex_trylock(struct rt_mutex *lock)
+	__cond_acquires(true, lock);
 
-extern void rt_mutex_unlock(struct rt_mutex *lock);
+extern void rt_mutex_unlock(struct rt_mutex *lock)
+	__releases(lock);
 
 #endif
diff --git a/kernel/locking/Makefile b/kernel/locking/Makefile
index cee1901d4cff..24dc00e12aa6 100644
--- a/kernel/locking/Makefile
+++ b/kernel/locking/Makefile
@@ -4,6 +4,7 @@
 KCOV_INSTRUMENT		:= n
 
 CONTEXT_ANALYSIS_mutex.o := y
+CONTEXT_ANALYSIS_rtmutex.o := y
 CONTEXT_ANALYSIS_rtmutex_api.o := y
 CONTEXT_ANALYSIS_ww_rt_mutex.o := y
 CONTEXT_ANALYSIS_rwsem.o := y
diff --git a/kernel/locking/rtmutex.c b/kernel/locking/rtmutex.c
index 4f386ea6c792..69759fde7d10 100644
--- a/kernel/locking/rtmutex.c
+++ b/kernel/locking/rtmutex.c
@@ -484,6 +484,7 @@ static __always_inline bool __waiter_less(struct rb_node *a, const struct rb_nod
 
 static __always_inline void
 rt_mutex_enqueue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -492,6 +493,7 @@ rt_mutex_enqueue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)
 
 static __always_inline void
 rt_mutex_dequeue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -1092,6 +1094,7 @@ static int __sched rt_mutex_adjust_prio_chain(struct task_struct *task,
 static int __sched
 try_to_take_rt_mutex(struct rt_mutex_base *lock, struct task_struct *task,
 		     struct rt_mutex_waiter *waiter)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -1319,6 +1322,7 @@ static int __sched task_blocks_on_rt_mutex(struct rt_mutex_base *lock,
  */
 static void __sched mark_wakeup_next_waiter(struct rt_wake_q_head *wqh,
 					    struct rt_mutex_base *lock)
+	__must_hold(&lock->wait_lock)
 {
 	struct rt_mutex_waiter *waiter;
 
@@ -1479,6 +1483,7 @@ static void __sched rt_mutex_slowunlock(struct rt_mutex_base *lock)
 }
 
 static __always_inline void __rt_mutex_unlock(struct rt_mutex_base *lock)
+	__no_context_analysis
 {
 	if (likely(rt_mutex_cmpxchg_release(lock, current, NULL)))
 		return;
diff --git a/kernel/locking/rtmutex_api.c b/kernel/locking/rtmutex_api.c
index 124219aea46e..23ad997ddd65 100644
--- a/kernel/locking/rtmutex_api.c
+++ b/kernel/locking/rtmutex_api.c
@@ -41,6 +41,7 @@ static __always_inline int __rt_mutex_lock_common(struct rt_mutex *lock,
 						  unsigned int state,
 						  struct lockdep_map *nest_lock,
 						  unsigned int subclass)
+	__cond_acquires(0, lock)
 {
 	int ret;
 
@@ -66,12 +67,14 @@ EXPORT_SYMBOL(rt_mutex_base_init);
  * @subclass: the lockdep subclass
  */
 void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
+	__no_context_analysis /* ignoring the return value below is fine in this case */
 {
 	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass);
 }
 EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);
 
 void __sched _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
+	__no_context_analysis /* ignoring the return value below is fine in this case */
 {
 	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, nest_lock, 0);
 }
@@ -157,6 +160,7 @@ void __sched rt_mutex_unlock(struct rt_mutex *lock)
 {
 	mutex_release(&lock->dep_map, _RET_IP_);
 	__rt_mutex_unlock(&lock->rtmutex);
+	__release(lock);
 }
 EXPORT_SYMBOL_GPL(rt_mutex_unlock);
 
@@ -182,6 +186,7 @@ int __sched __rt_mutex_futex_trylock(struct rt_mutex_base *lock)
  */
 bool __sched __rt_mutex_futex_unlock(struct rt_mutex_base *lock,
 				     struct rt_wake_q_head *wqh)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -312,6 +317,7 @@ int __sched __rt_mutex_start_proxy_lock(struct rt_mutex_base *lock,
 					struct rt_mutex_waiter *waiter,
 					struct task_struct *task,
 					struct wake_q_head *wake_q)
+	__must_hold(&lock->wait_lock)
 {
 	int ret;
 

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Sebastian Andrzej Siewior]

On 2026-05-05 04:26:44 [+0200], Bart Van Assche wrote:
> Add lock context annotations to the rtmutex API and implementation and
> enable lock context analysis.
> 
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>

Is this in addition to commit 90bb681dcdf7e ("locking/rtmutex: Add context analysis")
?

Sebastian

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Bart Van Assche]

On 5/5/26 9:01 AM, Sebastian Andrzej Siewior wrote:
> On 2026-05-05 04:26:44 [+0200], Bart Van Assche wrote:
>> Add lock context annotations to the rtmutex API and implementation and
>> enable lock context analysis.
> 
> Is this in addition to commit 90bb681dcdf7e ("locking/rtmutex: Add context analysis")
> ?

Yes. This patch add context annotations in header file
<linux/rtmutex.h>. Maybe I overlooked something but I have not yet seen
any other patch that adds context annotations in that header file.

Thanks,

Bart.

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Sebastian Andrzej Siewior]

On 2026-05-05 09:24:51 [+0200], Bart Van Assche wrote:
> On 5/5/26 9:01 AM, Sebastian Andrzej Siewior wrote:
> > On 2026-05-05 04:26:44 [+0200], Bart Van Assche wrote:
> > > Add lock context annotations to the rtmutex API and implementation and
> > > enable lock context analysis.
> > 
> > Is this in addition to commit 90bb681dcdf7e ("locking/rtmutex: Add context analysis")
> > ?
> 
> Yes. This patch add context annotations in header file
> <linux/rtmutex.h>. Maybe I overlooked something but I have not yet seen
> any other patch that adds context annotations in that header file.

I see. I don't know why CONTEXT_ANALYSIS_rtmutex was skipped. Was this
just a regular compile with newer clang or was there more to it? I do
remember clang was not complaining but then context-analysis flag was
missing…

> Thanks,
> 
> Bart.

Sebastian

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Bart Van Assche]

On 5/5/26 9:32 AM, Sebastian Andrzej Siewior wrote:
> I see. I don't know why CONTEXT_ANALYSIS_rtmutex was skipped. Was this
> just a regular compile with newer clang or was there more to it? I do
> remember clang was not complaining but then context-analysis flag was
> missing…

Hi Sebastian,

This was noticed by enabling CONFIG_WARN_CONTEXT_ANALYSIS_ALL=n. I'm not
sure why this was not noticed earlier. Maybe as the result of an
oversight?

Thanks,

Bart.

[tip: locking/core] locking/rtmutex: Annotate API and implementation

[tip-bot2 for Bart Van Assche]

The following commit has been merged into the locking/core branch of tip:

Commit-ID:     d30a456aa7ce1bab05d9b364eeacad0c9cb10cc2
Gitweb:        https://git.kernel.org/tip/d30a456aa7ce1bab05d9b364eeacad0c9cb10cc2
Author:        Bart Van Assche <bvanassche@acm.org>
AuthorDate:    Tue, 05 May 2026 04:26:44 +02:00
Committer:     Peter Zijlstra <peterz@infradead.org>
CommitterDate: Tue, 05 May 2026 12:50:49 +02:00

locking/rtmutex: Annotate API and implementation

Add lock context annotations to the rtmutex API and implementation and
enable lock context analysis.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: https://patch.msgid.link/20260505022649.870788-1-bvanassche@acm.org
---
 include/linux/rtmutex.h      | 22 +++++++++++++++-------
 kernel/locking/Makefile      |  1 +
 kernel/locking/rtmutex.c     |  5 +++++
 kernel/locking/rtmutex_api.c |  6 ++++++
 4 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/include/linux/rtmutex.h b/include/linux/rtmutex.h
index 78e7e58..9e1f012 100644
--- a/include/linux/rtmutex.h
+++ b/include/linux/rtmutex.h
@@ -56,6 +56,8 @@ static inline struct task_struct *rt_mutex_owner(struct rt_mutex_base *lock)
 #endif
 extern void rt_mutex_base_init(struct rt_mutex_base *rtb);
 
+context_lock_struct(rt_mutex);
+
 /**
  * The rt_mutex structure
  *
@@ -108,8 +110,10 @@ do { \
 extern void __rt_mutex_init(struct rt_mutex *lock, const char *name, struct lock_class_key *key);
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
-extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass);
-extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock);
+extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
+	__acquires(lock);
+extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
+	__acquires(lock);
 #define rt_mutex_lock(lock) rt_mutex_lock_nested(lock, 0)
 #define rt_mutex_lock_nest_lock(lock, nest_lock)			\
 	do {								\
@@ -118,15 +122,19 @@ extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *
 	} while (0)
 
 #else
-extern void rt_mutex_lock(struct rt_mutex *lock);
+extern void rt_mutex_lock(struct rt_mutex *lock) __acquires(lock);
 #define rt_mutex_lock_nested(lock, subclass) rt_mutex_lock(lock)
 #define rt_mutex_lock_nest_lock(lock, nest_lock) rt_mutex_lock(lock)
 #endif
 
-extern int rt_mutex_lock_interruptible(struct rt_mutex *lock);
-extern int rt_mutex_lock_killable(struct rt_mutex *lock);
-extern int rt_mutex_trylock(struct rt_mutex *lock);
+extern int rt_mutex_lock_interruptible(struct rt_mutex *lock)
+	__cond_acquires(0, lock);
+extern int rt_mutex_lock_killable(struct rt_mutex *lock)
+	__cond_acquires(0, lock);
+extern int rt_mutex_trylock(struct rt_mutex *lock)
+	__cond_acquires(true, lock);
 
-extern void rt_mutex_unlock(struct rt_mutex *lock);
+extern void rt_mutex_unlock(struct rt_mutex *lock)
+	__releases(lock);
 
 #endif
diff --git a/kernel/locking/Makefile b/kernel/locking/Makefile
index cee1901..24dc00e 100644
--- a/kernel/locking/Makefile
+++ b/kernel/locking/Makefile
@@ -4,6 +4,7 @@
 KCOV_INSTRUMENT		:= n
 
 CONTEXT_ANALYSIS_mutex.o := y
+CONTEXT_ANALYSIS_rtmutex.o := y
 CONTEXT_ANALYSIS_rtmutex_api.o := y
 CONTEXT_ANALYSIS_ww_rt_mutex.o := y
 CONTEXT_ANALYSIS_rwsem.o := y
diff --git a/kernel/locking/rtmutex.c b/kernel/locking/rtmutex.c
index 4f386ea..69759fd 100644
--- a/kernel/locking/rtmutex.c
+++ b/kernel/locking/rtmutex.c
@@ -484,6 +484,7 @@ static __always_inline bool __waiter_less(struct rb_node *a, const struct rb_nod
 
 static __always_inline void
 rt_mutex_enqueue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -492,6 +493,7 @@ rt_mutex_enqueue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)
 
 static __always_inline void
 rt_mutex_dequeue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -1092,6 +1094,7 @@ static int __sched rt_mutex_adjust_prio_chain(struct task_struct *task,
 static int __sched
 try_to_take_rt_mutex(struct rt_mutex_base *lock, struct task_struct *task,
 		     struct rt_mutex_waiter *waiter)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -1319,6 +1322,7 @@ static int __sched task_blocks_on_rt_mutex(struct rt_mutex_base *lock,
  */
 static void __sched mark_wakeup_next_waiter(struct rt_wake_q_head *wqh,
 					    struct rt_mutex_base *lock)
+	__must_hold(&lock->wait_lock)
 {
 	struct rt_mutex_waiter *waiter;
 
@@ -1479,6 +1483,7 @@ static void __sched rt_mutex_slowunlock(struct rt_mutex_base *lock)
 }
 
 static __always_inline void __rt_mutex_unlock(struct rt_mutex_base *lock)
+	__no_context_analysis
 {
 	if (likely(rt_mutex_cmpxchg_release(lock, current, NULL)))
 		return;
diff --git a/kernel/locking/rtmutex_api.c b/kernel/locking/rtmutex_api.c
index 124219a..23ad997 100644
--- a/kernel/locking/rtmutex_api.c
+++ b/kernel/locking/rtmutex_api.c
@@ -41,6 +41,7 @@ static __always_inline int __rt_mutex_lock_common(struct rt_mutex *lock,
 						  unsigned int state,
 						  struct lockdep_map *nest_lock,
 						  unsigned int subclass)
+	__cond_acquires(0, lock)
 {
 	int ret;
 
@@ -66,12 +67,14 @@ EXPORT_SYMBOL(rt_mutex_base_init);
  * @subclass: the lockdep subclass
  */
 void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
+	__no_context_analysis /* ignoring the return value below is fine in this case */
 {
 	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass);
 }
 EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);
 
 void __sched _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
+	__no_context_analysis /* ignoring the return value below is fine in this case */
 {
 	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, nest_lock, 0);
 }
@@ -157,6 +160,7 @@ void __sched rt_mutex_unlock(struct rt_mutex *lock)
 {
 	mutex_release(&lock->dep_map, _RET_IP_);
 	__rt_mutex_unlock(&lock->rtmutex);
+	__release(lock);
 }
 EXPORT_SYMBOL_GPL(rt_mutex_unlock);
 
@@ -182,6 +186,7 @@ int __sched __rt_mutex_futex_trylock(struct rt_mutex_base *lock)
  */
 bool __sched __rt_mutex_futex_unlock(struct rt_mutex_base *lock,
 				     struct rt_wake_q_head *wqh)
+	__must_hold(&lock->wait_lock)
 {
 	lockdep_assert_held(&lock->wait_lock);
 
@@ -312,6 +317,7 @@ int __sched __rt_mutex_start_proxy_lock(struct rt_mutex_base *lock,
 					struct rt_mutex_waiter *waiter,
 					struct task_struct *task,
 					struct wake_q_head *wake_q)
+	__must_hold(&lock->wait_lock)
 {
 	int ret;
 

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Sebastian Andrzej Siewior]

On 2026-05-05 09:50:11 [+0200], Bart Van Assche wrote:
> 
> On 5/5/26 9:32 AM, Sebastian Andrzej Siewior wrote:
> > I see. I don't know why CONTEXT_ANALYSIS_rtmutex was skipped. Was this
> > just a regular compile with newer clang or was there more to it? I do
> > remember clang was not complaining but then context-analysis flag was
> > missing…
> 
> Hi Sebastian,

Hi Bart,

> This was noticed by enabling CONFIG_WARN_CONTEXT_ANALYSIS_ALL=n. I'm not
> sure why this was not noticed earlier. Maybe as the result of an
> oversight?

I have here clang-22 and make with CONFIG_WARN_CONTEXT_ANALYSIS_ALL=n
and CONFIG_WARN_CONTEXT_ANALYSIS=y. I don't see any warning without your
patch during "make kernel/locking/".

The change
	CONTEXT_ANALYSIS_rtmutex.o := y

is not needed because rtmutex.o is not compiled on its own:
| $ git grep "rtmutex\.c" kernel/locking/
| kernel/locking/rtmutex_api.c:#include "rtmutex.c"
| kernel/locking/rwsem.c:#include "rtmutex.c"
| kernel/locking/spinlock_rt.c:#include "rtmutex.c"
| kernel/locking/ww_rt_mutex.c:#include "rtmutex.c"

or do I miss something here?
I tried with PREEMPT_RT enabled and disabled. Also with and without
LOCKDEP in case it makes a change.

> Thanks,
> 
> Bart.

Sebastian

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Bart Van Assche]

On 5/5/26 4:03 PM, Sebastian Andrzej Siewior wrote:
> I have here clang-22 and make with CONFIG_WARN_CONTEXT_ANALYSIS_ALL=n
> and CONFIG_WARN_CONTEXT_ANALYSIS=y. I don't see any warning without your
> patch during "make kernel/locking/".

That is expected.

> The change
> 	CONTEXT_ANALYSIS_rtmutex.o := y
> 
> is not needed because rtmutex.o is not compiled on its own:

Agreed. Do you perhaps want me to repost this patch with that line left
out?

In case it would not be clear, the goal of this patch is to let the
compiler verify whether users of the rtmutex_*() API use this API
correctly.

Thanks,

Bart.

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Sebastian Andrzej Siewior]

On 2026-05-05 04:26:44 [+0200], Bart Van Assche wrote:
> --- a/include/linux/rtmutex.h
> +++ b/include/linux/rtmutex.h
> @@ -56,6 +56,8 @@ static inline struct task_struct *rt_mutex_owner(struct rt_mutex_base *lock)
>  #endif
>  extern void rt_mutex_base_init(struct rt_mutex_base *rtb);
>  
> +context_lock_struct(rt_mutex);

What does this do? Shouldn't this define the struct?

>  /**
>   * The rt_mutex structure
>   *
> @@ -108,8 +110,10 @@ do { \
>  extern void __rt_mutex_init(struct rt_mutex *lock, const char *name, struct lock_class_key *key);
>  
>  #ifdef CONFIG_DEBUG_LOCK_ALLOC
> -extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass);
> -extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock);
> +extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
> +	__acquires(lock);
> +extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
> +	__acquires(lock);
>  #define rt_mutex_lock(lock) rt_mutex_lock_nested(lock, 0)
>  #define rt_mutex_lock_nest_lock(lock, nest_lock)			\
>  	do {								\
> @@ -118,15 +122,19 @@ extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *
>  	} while (0)
>  
>  #else
> -extern void rt_mutex_lock(struct rt_mutex *lock);
> +extern void rt_mutex_lock(struct rt_mutex *lock) __acquires(lock);

So this is "one" thing where you add annotation to the rt_mutex*() API
for external users. Then you add the wait_lock annotation. Different
scope but okay.

…
> --- a/kernel/locking/rtmutex_api.c
> +++ b/kernel/locking/rtmutex_api.c
> @@ -66,12 +67,14 @@ EXPORT_SYMBOL(rt_mutex_base_init);
>   * @subclass: the lockdep subclass
>   */
>  void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
> +	__no_context_analysis /* ignoring the return value below is fine in this case */
>  {
>  	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass);
>  }
>  EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);
>  
>  void __sched _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
> +	__no_context_analysis /* ignoring the return value below is fine in this case */
>  {
>  	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, nest_lock, 0);
>  }

*Why* is it okay? Because the void always acquire the lock and only the
conditional locking (which can be interrupted by signal/ timeout) return
an error if they failed to acquire the lock. Something like that would
be nice for the comment.

Not sure if "__no_context_analysis" is the right thing to do here.
  __acquires(lock) __no_context_analysis

might be better if just __acquires leads to trouble.

Sebastian

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Sebastian Andrzej Siewior]

On 2026-05-05 17:26:05 [+0200], Bart Van Assche wrote:
> On 5/5/26 4:03 PM, Sebastian Andrzej Siewior wrote:
> > I have here clang-22 and make with CONFIG_WARN_CONTEXT_ANALYSIS_ALL=n
> > and CONFIG_WARN_CONTEXT_ANALYSIS=y. I don't see any warning without your
> > patch during "make kernel/locking/".
> 
> That is expected.

Ah okay.

> > The change
> > 	CONTEXT_ANALYSIS_rtmutex.o := y
> > 
> > is not needed because rtmutex.o is not compiled on its own:
> 
> Agreed. Do you perhaps want me to repost this patch with that line left
> out?
> 
> In case it would not be clear, the goal of this patch is to let the
> compiler verify whether users of the rtmutex_*() API use this API
> correctly.

I somehow did not connect the dots. I just did comment on the patch
after reading this one. But yes, please remove
CONTEXT_ANALYSIS_rtmutex.o since it is not required.

> Thanks,
> 
> Bart.

Sebastian

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Bart Van Assche]

On 5/5/26 6:12 PM, Sebastian Andrzej Siewior wrote:
> On 2026-05-05 04:26:44 [+0200], Bart Van Assche wrote:
>> +context_lock_struct(rt_mutex);
> 
> What does this do? Shouldn't this define the struct?

This enables context locking support for struct rt_mutex. I placed 
context_lock_struct() on a line by itself because in my opinion that
results in a header file that is easier to read compared to
context_lock_struct(name) { ... }.

>> --- a/kernel/locking/rtmutex_api.c
>> +++ b/kernel/locking/rtmutex_api.c
>> @@ -66,12 +67,14 @@ EXPORT_SYMBOL(rt_mutex_base_init);
>>    * @subclass: the lockdep subclass
>>    */
>>   void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
>> +	__no_context_analysis /* ignoring the return value below is fine in this case */
>>   {
>>   	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass);
>>   }
>>   EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);
>>   
>>   void __sched _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
>> +	__no_context_analysis /* ignoring the return value below is fine in this case */
>>   {
>>   	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, nest_lock, 0);
>>   }
> 
> *Why* is it okay? Because the void always acquire the lock and only the
> conditional locking (which can be interrupted by signal/ timeout) return
> an error if they failed to acquire the lock.

Yes, that's correct.

> Something like that would be nice for the comment.
> 
> Not sure if "__no_context_analysis" is the right thing to do here.
>    __acquires(lock) __no_context_analysis
> 
> might be better if just __acquires leads to trouble.

There is an alternative that does not require __no_context_analysis:

void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int 
subclass)
{
         int ret = __rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, 
NULL, subclass);

         BUG_ON(ret);
}
EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);

Please let me know which style you prefer.

Thanks,

Bart.

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Sebastian Andrzej Siewior]

On 2026-05-05 22:05:51 [+0200], Bart Van Assche wrote:
> On 5/5/26 6:12 PM, Sebastian Andrzej Siewior wrote:
> > On 2026-05-05 04:26:44 [+0200], Bart Van Assche wrote:
> > > +context_lock_struct(rt_mutex);
> > 
> > What does this do? Shouldn't this define the struct?
> 
> This enables context locking support for struct rt_mutex. I placed
> context_lock_struct() on a line by itself because in my opinion that
> results in a header file that is easier to read compared to
> context_lock_struct(name) { ... }.

Hmm. This was the confusing part, because everything else such as
rwlock, rw_semaphore, mutex, … use that way.

> > > --- a/kernel/locking/rtmutex_api.c
> > > +++ b/kernel/locking/rtmutex_api.c
> > > @@ -66,12 +67,14 @@ EXPORT_SYMBOL(rt_mutex_base_init);
> > >    * @subclass: the lockdep subclass
> > >    */
> > >   void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass)
> > > +	__no_context_analysis /* ignoring the return value below is fine in this case */
> > >   {
> > >   	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass);
> > >   }
> > >   EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);
> > >   void __sched _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock)
> > > +	__no_context_analysis /* ignoring the return value below is fine in this case */
> > >   {
> > >   	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, nest_lock, 0);
> > >   }
> > 
> > *Why* is it okay? Because the void always acquire the lock and only the
> > conditional locking (which can be interrupted by signal/ timeout) return
> > an error if they failed to acquire the lock.
> 
> Yes, that's correct.

I meant this as an improved comment ;)

> > Something like that would be nice for the comment.
> > 
> > Not sure if "__no_context_analysis" is the right thing to do here.
> >    __acquires(lock) __no_context_analysis
> > 
> > might be better if just __acquires leads to trouble.
> 
> There is an alternative that does not require __no_context_analysis:
> 
> void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int
> subclass)
> {
>         int ret = __rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL,
> subclass);
> 
>         BUG_ON(ret);
> }
> EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);
> 
> Please let me know which style you prefer.

Hmm. This mostly reassembles __mutex_lock() from mutex.c which does the
same thing. Couldn't we get away doing the same thing meaning a
__cond_acquires() on those with a return value and a __acquire() in the
void case? I think it would make sense to keep those two close in terms
of annotations.

> Thanks,
> 
> Bart.

Sebastian

Re: [PATCH v2] locking/rtmutex: Annotate API and implementation

[Bart Van Assche]

On 5/6/26 9:35 AM, Sebastian Andrzej Siewior wrote:
> Hmm. This mostly reassembles __mutex_lock() from mutex.c which does the
> same thing. Couldn't we get away doing the same thing meaning a
> __cond_acquires() on those with a return value and a __acquire() in the
> void case? I think it would make sense to keep those two close in terms
> of annotations.

Please take a look at the rt_mutex_lock() changes in the diff below.

Thanks,

Bart.

diff --git a/include/linux/rtmutex.h b/include/linux/rtmutex.h
index 78e7e588817c..9e1f012f89db 100644
--- a/include/linux/rtmutex.h
+++ b/include/linux/rtmutex.h
@@ -56,6 +56,8 @@ static inline struct task_struct 
*rt_mutex_owner(struct rt_mutex_base *lock)
  #endif
  extern void rt_mutex_base_init(struct rt_mutex_base *rtb);

+context_lock_struct(rt_mutex);
+
  /**
   * The rt_mutex structure
   *
@@ -108,8 +110,10 @@ do { \
  extern void __rt_mutex_init(struct rt_mutex *lock, const char *name, 
struct lock_class_key *key);

  #ifdef CONFIG_DEBUG_LOCK_ALLOC
-extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int 
subclass);
-extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct 
lockdep_map *nest_lock);
+extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int 
subclass)
+	__acquires(lock);
+extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct 
lockdep_map *nest_lock)
+	__acquires(lock);
  #define rt_mutex_lock(lock) rt_mutex_lock_nested(lock, 0)
  #define rt_mutex_lock_nest_lock(lock, nest_lock)			\
  	do {								\
@@ -118,15 +122,19 @@ extern void _rt_mutex_lock_nest_lock(struct 
rt_mutex *lock, struct lockdep_map *
  	} while (0)

  #else
-extern void rt_mutex_lock(struct rt_mutex *lock);
+extern void rt_mutex_lock(struct rt_mutex *lock) __acquires(lock);
  #define rt_mutex_lock_nested(lock, subclass) rt_mutex_lock(lock)
  #define rt_mutex_lock_nest_lock(lock, nest_lock) rt_mutex_lock(lock)
  #endif

-extern int rt_mutex_lock_interruptible(struct rt_mutex *lock);
-extern int rt_mutex_lock_killable(struct rt_mutex *lock);
-extern int rt_mutex_trylock(struct rt_mutex *lock);
+extern int rt_mutex_lock_interruptible(struct rt_mutex *lock)
+	__cond_acquires(0, lock);
+extern int rt_mutex_lock_killable(struct rt_mutex *lock)
+	__cond_acquires(0, lock);
+extern int rt_mutex_trylock(struct rt_mutex *lock)
+	__cond_acquires(true, lock);

-extern void rt_mutex_unlock(struct rt_mutex *lock);
+extern void rt_mutex_unlock(struct rt_mutex *lock)
+	__releases(lock);

  #endif
diff --git a/kernel/locking/rtmutex.c b/kernel/locking/rtmutex.c
index 4f386ea6c792..69759fde7d10 100644
--- a/kernel/locking/rtmutex.c
+++ b/kernel/locking/rtmutex.c
@@ -484,6 +484,7 @@ static __always_inline bool __waiter_less(struct 
rb_node *a, const struct rb_nod

  static __always_inline void
  rt_mutex_enqueue(struct rt_mutex_base *lock, struct rt_mutex_waiter 
*waiter)
+	__must_hold(&lock->wait_lock)
  {
  	lockdep_assert_held(&lock->wait_lock);

@@ -492,6 +493,7 @@ rt_mutex_enqueue(struct rt_mutex_base *lock, struct 
rt_mutex_waiter *waiter)

  static __always_inline void
  rt_mutex_dequeue(struct rt_mutex_base *lock, struct rt_mutex_waiter 
*waiter)
+	__must_hold(&lock->wait_lock)
  {
  	lockdep_assert_held(&lock->wait_lock);

@@ -1092,6 +1094,7 @@ static int __sched 
rt_mutex_adjust_prio_chain(struct task_struct *task,
  static int __sched
  try_to_take_rt_mutex(struct rt_mutex_base *lock, struct task_struct *task,
  		     struct rt_mutex_waiter *waiter)
+	__must_hold(&lock->wait_lock)
  {
  	lockdep_assert_held(&lock->wait_lock);

@@ -1319,6 +1322,7 @@ static int __sched task_blocks_on_rt_mutex(struct 
rt_mutex_base *lock,
   */
  static void __sched mark_wakeup_next_waiter(struct rt_wake_q_head *wqh,
  					    struct rt_mutex_base *lock)
+	__must_hold(&lock->wait_lock)
  {
  	struct rt_mutex_waiter *waiter;

@@ -1479,6 +1483,7 @@ static void __sched rt_mutex_slowunlock(struct 
rt_mutex_base *lock)
  }

  static __always_inline void __rt_mutex_unlock(struct rt_mutex_base *lock)
+	__no_context_analysis
  {
  	if (likely(rt_mutex_cmpxchg_release(lock, current, NULL)))
  		return;
diff --git a/kernel/locking/rtmutex_api.c b/kernel/locking/rtmutex_api.c
index 124219aea46e..f9345fa22286 100644
--- a/kernel/locking/rtmutex_api.c
+++ b/kernel/locking/rtmutex_api.c
@@ -41,6 +41,7 @@ static __always_inline int 
__rt_mutex_lock_common(struct rt_mutex *lock,
  						  unsigned int state,
  						  struct lockdep_map *nest_lock,
  						  unsigned int subclass)
+	__cond_acquires(0, lock)
  {
  	int ret;

@@ -67,13 +68,19 @@ EXPORT_SYMBOL(rt_mutex_base_init);
   */
  void __sched rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int 
subclass)
  {
-	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass);
+	if (__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, subclass) 
== 0)
+		return;
+	WARN_ON_ONCE(true);
+	__acquire(lock); /* to keep the compiler happy */
  }
  EXPORT_SYMBOL_GPL(rt_mutex_lock_nested);

  void __sched _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct 
lockdep_map *nest_lock)
  {
-	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, nest_lock, 0);
+	if (__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, nest_lock, 0) == 0)
+		return;
+	WARN_ON_ONCE(true);
+	__acquire(lock); /* to keep the compiler happy */
  }
  EXPORT_SYMBOL_GPL(_rt_mutex_lock_nest_lock);

@@ -86,7 +93,10 @@ EXPORT_SYMBOL_GPL(_rt_mutex_lock_nest_lock);
   */
  void __sched rt_mutex_lock(struct rt_mutex *lock)
  {
-	__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, 0);
+	if (__rt_mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, NULL, 0) == 0)
+		return;
+	WARN_ON_ONCE(true);
+	__acquire(lock); /* to keep the compiler happy */
  }
  EXPORT_SYMBOL_GPL(rt_mutex_lock);
  #endif
@@ -157,6 +167,7 @@ void __sched rt_mutex_unlock(struct rt_mutex *lock)
  {
  	mutex_release(&lock->dep_map, _RET_IP_);
  	__rt_mutex_unlock(&lock->rtmutex);
+	__release(lock);
  }
  EXPORT_SYMBOL_GPL(rt_mutex_unlock);

@@ -182,6 +193,7 @@ int __sched __rt_mutex_futex_trylock(struct 
rt_mutex_base *lock)
   */
  bool __sched __rt_mutex_futex_unlock(struct rt_mutex_base *lock,
  				     struct rt_wake_q_head *wqh)
+	__must_hold(&lock->wait_lock)
  {
  	lockdep_assert_held(&lock->wait_lock);

@@ -312,6 +324,7 @@ int __sched __rt_mutex_start_proxy_lock(struct 
rt_mutex_base *lock,
  					struct rt_mutex_waiter *waiter,
  					struct task_struct *task,
  					struct wake_q_head *wake_q)
+	__must_hold(&lock->wait_lock)
  {
  	int ret;