Skip to contentSkip to conversation

rust: irq: add `'static` bounds to irq callbacks

PATCH Applied Benno Lossin 5 participants 10 messages Feb 14 – Feb 19

Subsystems (2)
lore
Share & tools
lore

Benno Lossin

author reviewer
#0 lore raw

PATCH 1/1 rust: irq: add `'static` bounds to irq callbacks

These callback functions take a generic T that is used in the body as the generic argument in Registration and ThreadedRegistration. Those types require T: 'static, but due to a compiler bug this requirement isn't propagated to the function. Thus add the bound. This was caught in the upstream Rust CI [1].

---
 rust/kernel/irq/request.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
rust/kernel/irq/request.rs +9 -3
index b150563fdef8..2ceeaeb0543a 100644
@@ -261,7 +261,10 @@ pub fn synchronize(&self, dev: &Device<Bound>) -> Result {
 /// # Safety
 ///
 /// This function should be only used as the callback in `request_irq`.
-unsafe extern "C" fn handle_irq_callback<T: Handler>(_irq: i32, ptr: *mut c_void) -> c_uint {
+unsafe extern "C" fn handle_irq_callback<T: Handler + 'static>(
+    _irq: i32,
+    ptr: *mut c_void,
+) -> c_uint {
     // SAFETY: `ptr` is a pointer to `Registration<T>` set in `Registration::new`
     let registration = unsafe { &*(ptr as *const Registration<T>) };
     // SAFETY: The irq callback is removed before the device is unbound, so the fact that the irq
@@ -480,7 +483,7 @@ pub fn synchronize(&self, dev: &Device<Bound>) -> Result {
 /// # Safety
 ///
 /// This function should be only used as the callback in `request_threaded_irq`.
-unsafe extern "C" fn handle_threaded_irq_callback<T: ThreadedHandler>(
+unsafe extern "C" fn handle_threaded_irq_callback<T: ThreadedHandler + 'static>(
     _irq: i32,
     ptr: *mut c_void,
 ) -> c_uint {
@@ -496,7 +499,10 @@ pub fn synchronize(&self, dev: &Device<Bound>) -> Result {
 /// # Safety
 ///
 /// This function should be only used as the callback in `request_threaded_irq`.
-unsafe extern "C" fn thread_fn_callback<T: ThreadedHandler>(_irq: i32, ptr: *mut c_void) -> c_uint {
+unsafe extern "C" fn thread_fn_callback<T: ThreadedHandler + 'static>(
+    _irq: i32,
+    ptr: *mut c_void,
+) -> c_uint {
     // SAFETY: `ptr` is a pointer to `ThreadedRegistration<T>` set in `ThreadedRegistration::new`
     let registration = unsafe { &*(ptr as *const ThreadedRegistration<T>) };
     // SAFETY: The irq callback is removed before the device is unbound, so the fact that the irq

base-commit: 63804fed149a6750ffd28610c5c1c98cce6bd377

Signature · 1 line
2.52.0
reviewer Reviewed-by on v1 1/1
#1 lore raw
Quoted 8 lines · Benno Lossin

These callback functions take a generic T that is used in the body as the generic argument in Registration and ThreadedRegistration. Those types require T: 'static, but due to a compiler bug this requirement isn't propagated to the function. Thus add the bound. This was caught in the upstream Rust CI [1].

Quoted 43 lines
---
 rust/kernel/irq/request.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
rust/kernel/irq/request.rs +9 -3
index b150563fdef8..2ceeaeb0543a 100644
@@ -261,7 +261,10 @@ pub fn synchronize(&self, dev: &Device<Bound>) -> Result {
 /// # Safety
 ///
 /// This function should be only used as the callback in `request_irq`.
-unsafe extern "C" fn handle_irq_callback<T: Handler>(_irq: i32, ptr: *mut c_void) -> c_uint {
+unsafe extern "C" fn handle_irq_callback<T: Handler + 'static>(
+    _irq: i32,
+    ptr: *mut c_void,
+) -> c_uint {
     // SAFETY: `ptr` is a pointer to `Registration<T>` set in `Registration::new`
     let registration = unsafe { &*(ptr as *const Registration<T>) };
     // SAFETY: The irq callback is removed before the device is unbound, so the fact that the irq
@@ -480,7 +483,7 @@ pub fn synchronize(&self, dev: &Device<Bound>) -> Result {
 /// # Safety
 ///
 /// This function should be only used as the callback in `request_threaded_irq`.
-unsafe extern "C" fn handle_threaded_irq_callback<T: ThreadedHandler>(
+unsafe extern "C" fn handle_threaded_irq_callback<T: ThreadedHandler + 'static>(
     _irq: i32,
     ptr: *mut c_void,
 ) -> c_uint {
@@ -496,7 +499,10 @@ pub fn synchronize(&self, dev: &Device<Bound>) -> Result {
 /// # Safety
 ///
 /// This function should be only used as the callback in `request_threaded_irq`.
-unsafe extern "C" fn thread_fn_callback<T: ThreadedHandler>(_irq: i32, ptr: *mut c_void) -> c_uint {
+unsafe extern "C" fn thread_fn_callback<T: ThreadedHandler + 'static>(
+    _irq: i32,
+    ptr: *mut c_void,
+) -> c_uint {
     // SAFETY: `ptr` is a pointer to `ThreadedRegistration<T>` set in `ThreadedRegistration::new`
     let registration = unsafe { &*(ptr as *const ThreadedRegistration<T>) };
     // SAFETY: The irq callback is removed before the device is unbound, so the fact that the irq

base-commit: 63804fed149a6750ffd28610c5c1c98cce6bd377

maintainer
#2 lore raw
In reply to Benno Lossin
Quoted 8 lines · Benno Lossin

These callback functions take a generic T that is used in the body as the generic argument in Registration and ThreadedRegistration. Those types require T: 'static, but due to a compiler bug this requirement isn't propagated to the function. Thus add the bound. This was caught in the upstream Rust CI [1].

IIUC, the current code will not compile with a fixed compiler, right?

If this is correct, this needs to be backported; I can add the Fixes: tag and
Cc: stable when I apply the patch.

- Danilo

author reviewer
#3 lore raw
Quoted 11 lines · Danilo Krummrich
Quoted 8 lines · Benno Lossin

These callback functions take a generic T that is used in the body as the generic argument in Registration and ThreadedRegistration. Those types require T: 'static, but due to a compiler bug this requirement isn't propagated to the function. Thus add the bound. This was caught in the upstream Rust CI [1].

IIUC, the current code will not compile with a fixed compiler, right?

Correct.

Quoted 2 lines

If this is correct, this needs to be backported; I can add the Fixes: tag and
Cc: stable when I apply the patch.

Oh yeah I forgot about that, good catch. I think it should be

Fixes 29e16fcd67ee ("rust: irq: add &Device<Bound> argument to irq callbacks")

Since that introduces the usage of the [Threaded]Registration types in the function bodies.

It can also be backported further, but then it needs to be split into threaded and non-threaded variants:

- 135d40523244 ("rust: irq: add support for threaded IRQs and handlers")
- 0851d34a8cc3 ("rust: irq: add support for non-threaded IRQs and handlers")

Cheers,
Benno

maintainer
#4 lore raw
Quoted 9 lines · Benno Lossin

Oh yeah I forgot about that, good catch. I think it should be

Fixes 29e16fcd67ee ("rust: irq: add &Device<Bound> argument to irq callbacks")

Since that introduces the usage of the [Threaded]Registration types in the function bodies.

It can also be backported further, but then it needs to be split into threaded and non-threaded variants:

All commits were introduced in v6.18, so technically there is no "backported further".

But IIUC, with a fixed compiler, it also would not compile without commit 29e16fcd67ee ("rust: irq: add &Device<Bound> argument to irq callbacks"), correct? I.e. the two commits below are the correct Fixes: tags.

Quoted 2 lines

- 135d40523244 ("rust: irq: add support for threaded IRQs and handlers")
- 0851d34a8cc3 ("rust: irq: add support for non-threaded IRQs and handlers")

author reviewer
#5 lore raw
Quoted 11 lines · Danilo Krummrich
Quoted 9 lines · Benno Lossin

Oh yeah I forgot about that, good catch. I think it should be

Fixes 29e16fcd67ee ("rust: irq: add &Device<Bound> argument to irq callbacks")

Since that introduces the usage of the [Threaded]Registration types in the function bodies.

It can also be backported further, but then it needs to be split into threaded and non-threaded variants:

Quoted 9 lines

All commits were introduced in v6.18, so technically there is no "backported further".

But IIUC, with a fixed compiler, it also would not compile without commit 29e16fcd67ee ("rust: irq: add &Device<Bound> argument to irq callbacks"), correct? I.e. the two commits below are the correct Fixes: tags.

Quoted 2 lines

- 135d40523244 ("rust: irq: add support for threaded IRQs and handlers")
- 0851d34a8cc3 ("rust: irq: add support for non-threaded IRQs and handlers")

With a fixed compiler these two would also still compile. It's just that the callbacks will only ever be called with T: 'static, since that is a bound on [Threaded]Registration, which stores these functions in the C side. So from a purely no-compile-error perspective, 29e16fcd67ee is the correct fixes. But from a "good API design" perspective, we could choose the two other commits.

But since all commits are in v6.18, it doesn't matter all that much.

Cheers,
Benno

maintainer
#6 lore raw
Quoted 6 lines · Benno Lossin

With a fixed compiler these two would also still compile. It's just that the callbacks will only ever be called with T: 'static, since that is a bound on [Threaded]Registration, which stores these functions in the C side. So from a purely no-compile-error perspective, 29e16fcd67ee is the correct fixes. But from a "good API design" perspective, we could choose the two other commits.

Makes sense, I will add

Fixes 29e16fcd67ee ("rust: irq: add &Device<Bound> argument to irq callbacks")

then.

Thanks,
Danilo

maintainer
#7 lore raw
In reply to Benno Lossin
Quoted 9 lines · Benno Lossin

These callback functions take a generic T that is used in the body as the generic argument in Registration and ThreadedRegistration. Those types require T: 'static, but due to a compiler bug this requirement isn't propagated to the function. Thus add the bound. This was caught in the upstream Rust CI [1].

Would it not be a cleaner fix to just add 'static as a super-trait to the traits directly?

trait Handler: Send + Sync + 'static {}

Alice

maintainer Acked-by on v1 1/1
#8 lore raw
In reply to Benno Lossin
Quoted 8 lines · Benno Lossin

These callback functions take a generic T that is used in the body as the generic argument in Registration and ThreadedRegistration. Those types require T: 'static, but due to a compiler bug this requirement isn't propagated to the function. Thus add the bound. This was caught in the upstream Rust CI [1].

As discussed, this will go through the Rust tree -- thanks Miguel!

Applied
#9 lore raw
In reply to Benno Lossin
Quoted 9 lines · Benno Lossin

These callback functions take a generic T that is used in the body as the generic argument in Registration and ThreadedRegistration. Those types require T: 'static, but due to a compiler bug this requirement isn't propagated to the function. Thus add the bound. This was caught in the upstream Rust CI [1].

Applied to rust-fixes -- thanks everyone!

Daniel: I added your Reviewed-by from the other patch (and linked to that patch separately too) -- I hope that is OK.

[ The three errors looked similar and will start appearing with Rust
1.95.0 (expected 2026-04-16). The first one was:

error[E0310]: the parameter type T may not live long enough
Error: --> rust/kernel/irq/request.rs:266:43
|
266 | let registration = unsafe { &*(ptr as *const

Registration<T>) };
              |                                           ^^^^^^^^^^^^^^^^^^^^^^
              |                                           |
              |                                           the

parameter type T must be valid for the static lifetime...
| ...so that
the type T will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound
|
264 | unsafe extern "C" fn handle_irq_callback<T: Handler +
'static>(_irq: i32, ptr: *mut c_void) -> c_uint {
| +++++++++

- Miguel ]

Cheers,
Miguel