rust: irq: add `'static` bounds to irq callbacks
Subsystems (2)
Benno Lossin
reviewerPATCH 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
@@ -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 { &*(ptras *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 { &*(ptras *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
Quoted 8 lines · Benno Lossin
These callback functions take a generic
Tthat is used in the body as the generic argument inRegistrationandThreadedRegistration. Those types requireT: '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].Signed-off-by Benno Lossin <[email protected]>
Quoted 43 lines
--- rust/kernel/irq/request.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)rust/kernel/irq/request.rs +9
-3@@ -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 { &*(ptras *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 { &*(ptras *const ThreadedRegistration <T >) };// SAFETY: The irq callback is removed before the device is unbound, so the fact that the irq base-commit:
63804fed149a6750ffd28610c5c1c98cce6bd377
Danilo Krummrich
maintainerQuoted 8 lines · Benno Lossin
These callback functions take a generic
Tthat is used in the body as the generic argument inRegistrationandThreadedRegistration. Those types requireT: '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].Signed-off-by Benno Lossin <[email protected]>
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
Benno Lossin
reviewerQuoted 11 lines · Danilo Krummrich
Quoted 8 lines · Benno Lossin
These callback functions take a generic
Tthat is used in the body as the generic argument inRegistrationandThreadedRegistration. Those types requireT: '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].Signed-off-by Benno Lossin <[email protected]>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
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
Danilo Krummrich
maintainerQuoted 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]Registrationtypes 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")
Benno Lossin
reviewerQuoted 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]Registrationtypes 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
Danilo Krummrich
maintainerQuoted 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,29e16fcd67eeis the correct fixes. But from a "good API design" perspective, we could choose the two other commits.
Makes sense, I will add
then.
Thanks,
Danilo
Alice Ryhl
maintainerQuoted 9 lines · Benno Lossin
These callback functions take a generic
Tthat is used in the body as the generic argument inRegistrationandThreadedRegistration. Those types requireT: '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].Signed-off-by Benno Lossin <[email protected]>
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
Quoted 8 lines · Benno Lossin
These callback functions take a generic
Tthat is used in the body as the generic argument inRegistrationandThreadedRegistration. Those types requireT: '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].Signed-off-by Benno Lossin <[email protected]>
As discussed, this will go through the Rust tree -- thanks Miguel!
Miguel Ojeda
AppliedQuoted 9 lines · Benno Lossin
These callback functions take a generic
Tthat is used in the body as the generic argument inRegistrationandThreadedRegistration. Those types requireT: '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].Signed-off-by Benno Lossin <[email protected]>
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>) };
| ^^^^^^^^^^^^^^^^^^^^^^
| |
| theparameter 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