[PATCH 1/2] rust: devres: provide an accessor for the device

[PATCH 1/2] rust: devres: provide an accessor for the device

[Danilo Krummrich]

Provide an accessor for the Device a Devres instance has been created
with.

For instance, this is useful when registrations want to provide a
&Device<Bound> for a scope that is protected by Devres.

Suggested-by: Benno Lossin <lossin@kernel.org>
Signed-off-by: Danilo Krummrich <dakr@kernel.org>
---
 rust/kernel/devres.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rust/kernel/devres.rs b/rust/kernel/devres.rs
index f43de3d77d61..a8a2d24cac24 100644
--- a/rust/kernel/devres.rs
+++ b/rust/kernel/devres.rs
@@ -204,6 +204,11 @@ fn remove_action(&self) -> bool {
         } == 0)
     }
 
+    /// Return a reference of the [`Device`] this [`Devres`] instance has been created with.
+    pub fn device(&self) -> &Device {
+        &self.dev
+    }
+
     /// Obtain `&'a T`, bypassing the [`Revocable`].
     ///
     /// This method allows to directly obtain a `&'a T`, bypassing the [`Revocable`], by presenting

base-commit: 3964d07dd821efe9680e90c51c86661a98e60a0f
-- 
2.50.0

[PATCH 2/2] rust: device: implement Device::as_bound()

[Danilo Krummrich]

Provide an unsafe functions for abstractions to convert a regular
&Device to a &Device<Bound>.

This is useful for registrations that provide certain guarantees for the
scope of their callbacks, such as IRQs or certain class device
registrations (e.g. PWM, miscdevice).

Signed-off-by: Danilo Krummrich <dakr@kernel.org>
---
 rust/kernel/device.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs
index d527ceef829e..4d9b052afe92 100644
--- a/rust/kernel/device.rs
+++ b/rust/kernel/device.rs
@@ -60,6 +60,25 @@ pub unsafe fn get_device(ptr: *mut bindings::device) -> ARef<Self> {
         // SAFETY: By the safety requirements ptr is valid
         unsafe { Self::as_ref(ptr) }.into()
     }
+
+    /// Convert a [`&Device`](Device) into a [`&Device<Bound>`](Device<Bound>).
+    ///
+    /// # Safety
+    ///
+    /// The caller is responsible to ensure that the returned [`&Device<Bound>`](Device<Bound>)
+    /// only lives as long as it can be guaranteed that the [`Device`] is actually bound.
+    pub unsafe fn as_bound(&self) -> &Device<Bound> {
+        let ptr = core::ptr::from_ref(self);
+
+        // CAST: By the safety requirements the caller is responsible to guarantee that the
+        // returned reference only lives as long as the device is actually bound.
+        let ptr = ptr.cast::<Device<Bound>>();
+
+        // SAFETY:
+        // - `ptr` comes from `from_ref(self)` above, hence it's guaranteed to be valid.
+        // - Any valid `Device` pointer is also a valid pointer for `Device<Bound>`.
+        unsafe { &*ptr.cast() }
+    }
 }
 
 impl Device<CoreInternal> {
-- 
2.50.0

Re: [PATCH 2/2] rust: device: implement Device::as_bound()

[Danilo Krummrich]

On Sun Jul 13, 2025 at 8:26 PM CEST, Danilo Krummrich wrote:
> Provide an unsafe functions for abstractions to convert a regular
> &Device to a &Device<Bound>.
>
> This is useful for registrations that provide certain guarantees for the
> scope of their callbacks, such as IRQs or certain class device
> registrations (e.g. PWM, miscdevice).
>
> Signed-off-by: Danilo Krummrich <dakr@kernel.org>
> ---
>  rust/kernel/device.rs | 19 +++++++++++++++++++
>  1 file changed, 19 insertions(+)
>
> diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs
> index d527ceef829e..4d9b052afe92 100644
> --- a/rust/kernel/device.rs
> +++ b/rust/kernel/device.rs
> @@ -60,6 +60,25 @@ pub unsafe fn get_device(ptr: *mut bindings::device) -> ARef<Self> {
>          // SAFETY: By the safety requirements ptr is valid
>          unsafe { Self::as_ref(ptr) }.into()
>      }
> +
> +    /// Convert a [`&Device`](Device) into a [`&Device<Bound>`](Device<Bound>).
> +    ///
> +    /// # Safety
> +    ///
> +    /// The caller is responsible to ensure that the returned [`&Device<Bound>`](Device<Bound>)
> +    /// only lives as long as it can be guaranteed that the [`Device`] is actually bound.
> +    pub unsafe fn as_bound(&self) -> &Device<Bound> {
> +        let ptr = core::ptr::from_ref(self);
> +
> +        // CAST: By the safety requirements the caller is responsible to guarantee that the
> +        // returned reference only lives as long as the device is actually bound.
> +        let ptr = ptr.cast::<Device<Bound>>();
> +
> +        // SAFETY:
> +        // - `ptr` comes from `from_ref(self)` above, hence it's guaranteed to be valid.
> +        // - Any valid `Device` pointer is also a valid pointer for `Device<Bound>`.
> +        unsafe { &*ptr.cast() }
> +    }
>  }

diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs
index 4d9b052afe92..b6b81546a0da 100644
--- a/rust/kernel/device.rs
+++ b/rust/kernel/device.rs
@@ -72,12 +72,12 @@ pub unsafe fn as_bound(&self) -> &Device<Bound> {

         // CAST: By the safety requirements the caller is responsible to guarantee that the
         // returned reference only lives as long as the device is actually bound.
-        let ptr = ptr.cast::<Device<Bound>>();
+        let ptr = ptr.cast();

         // SAFETY:
         // - `ptr` comes from `from_ref(self)` above, hence it's guaranteed to be valid.
         // - Any valid `Device` pointer is also a valid pointer for `Device<Bound>`.
-        unsafe { &*ptr.cast() }
+        unsafe { &*ptr }
     }
 }

Re: [PATCH 2/2] rust: device: implement Device::as_bound()

[Benno Lossin]

On Sun Jul 13, 2025 at 8:26 PM CEST, Danilo Krummrich wrote:
> Provide an unsafe functions for abstractions to convert a regular
> &Device to a &Device<Bound>.
>
> This is useful for registrations that provide certain guarantees for the
> scope of their callbacks, such as IRQs or certain class device
> registrations (e.g. PWM, miscdevice).
>
> Signed-off-by: Danilo Krummrich <dakr@kernel.org>

Reviewed-by: Benno Lossin <lossin@kernel.org>

---
Cheers,
Benno

> ---
>  rust/kernel/device.rs | 19 +++++++++++++++++++
>  1 file changed, 19 insertions(+)

Re: [PATCH 1/2] rust: devres: provide an accessor for the device

[Benno Lossin]

On Sun Jul 13, 2025 at 8:26 PM CEST, Danilo Krummrich wrote:
> Provide an accessor for the Device a Devres instance has been created
> with.
>
> For instance, this is useful when registrations want to provide a
> &Device<Bound> for a scope that is protected by Devres.
>
> Suggested-by: Benno Lossin <lossin@kernel.org>
> Signed-off-by: Danilo Krummrich <dakr@kernel.org>

Reviewed-by: Benno Lossin <lossin@kernel.org>

---
Cheers,
Benno

> ---
>  rust/kernel/devres.rs | 5 +++++
>  1 file changed, 5 insertions(+)

Re: [PATCH 2/2] rust: device: implement Device::as_bound()

[Greg KH]

On Sun, Jul 13, 2025 at 08:26:54PM +0200, Danilo Krummrich wrote:
> Provide an unsafe functions for abstractions to convert a regular
> &Device to a &Device<Bound>.
> 
> This is useful for registrations that provide certain guarantees for the
> scope of their callbacks, such as IRQs or certain class device
> registrations (e.g. PWM, miscdevice).

Do we have an example where this can be used today in the tree, or is
this only for new stuff going forward that would use it?

thanks,

greg k-h

Re: [PATCH 1/2] rust: devres: provide an accessor for the device

[Greg KH]

On Sun, Jul 13, 2025 at 08:26:53PM +0200, Danilo Krummrich wrote:
> Provide an accessor for the Device a Devres instance has been created
> with.
> 
> For instance, this is useful when registrations want to provide a
> &Device<Bound> for a scope that is protected by Devres.
> 
> Suggested-by: Benno Lossin <lossin@kernel.org>
> Signed-off-by: Danilo Krummrich <dakr@kernel.org>
> ---
>  rust/kernel/devres.rs | 5 +++++
>  1 file changed, 5 insertions(+)

Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Re: [PATCH 2/2] rust: device: implement Device::as_bound()

[Danilo Krummrich]

On Mon Jul 14, 2025 at 7:30 AM CEST, Greg KH wrote:
> On Sun, Jul 13, 2025 at 08:26:54PM +0200, Danilo Krummrich wrote:
>> Provide an unsafe functions for abstractions to convert a regular
>> &Device to a &Device<Bound>.
>> 
>> This is useful for registrations that provide certain guarantees for the
>> scope of their callbacks, such as IRQs or certain class device
>> registrations (e.g. PWM, miscdevice).
>
> Do we have an example where this can be used today in the tree, or is
> this only for new stuff going forward that would use it?

There's miscdevice in tree, but to be fair, miscdevice doesn't need it without
my patch series [1] adding driver support for the existing miscdevice
abstractions; the patch in [2] out of this series would use it within
args_from_registration().

The PWM abstractions [3] need it in bound_parent_device(). The use-case is the
same as everywhere else, PWM chips never out-live driver unbind, hence they can
provide the corresponding bus device as &Device<Bound>.

The same is true for IRQ registrations [4]. free_irq() is guaranteed to be
called before driver unbind, hence we can provide a &Device<Bound> in the IRQ
callbacks.

Ultimately, we want to provide this "cookie" in any driver scope that can be
proven to be lifetime wise limited to device / driver unbind, so there'll be
much more users.

[1] https://lore.kernel.org/lkml/20250530142447.166524-1-dakr@kernel.org/
[2] https://lore.kernel.org/lkml/20250530142447.166524-7-dakr@kernel.org/
[3] https://lore.kernel.org/lkml/20250710-rust-next-pwm-working-fan-for-sending-v11-3-93824a16f9ec@samsung.com/
[4] https://lore.kernel.org/lkml/20250703-topics-tyr-request_irq-v6-3-74103bdc7c52@collabora.com/

Re: [PATCH 2/2] rust: device: implement Device::as_bound()

[Greg KH]

On Mon, Jul 14, 2025 at 11:49:44AM +0200, Danilo Krummrich wrote:
> On Mon Jul 14, 2025 at 7:30 AM CEST, Greg KH wrote:
> > On Sun, Jul 13, 2025 at 08:26:54PM +0200, Danilo Krummrich wrote:
> >> Provide an unsafe functions for abstractions to convert a regular
> >> &Device to a &Device<Bound>.
> >> 
> >> This is useful for registrations that provide certain guarantees for the
> >> scope of their callbacks, such as IRQs or certain class device
> >> registrations (e.g. PWM, miscdevice).
> >
> > Do we have an example where this can be used today in the tree, or is
> > this only for new stuff going forward that would use it?
> 
> There's miscdevice in tree, but to be fair, miscdevice doesn't need it without
> my patch series [1] adding driver support for the existing miscdevice
> abstractions; the patch in [2] out of this series would use it within
> args_from_registration().
> 
> The PWM abstractions [3] need it in bound_parent_device(). The use-case is the
> same as everywhere else, PWM chips never out-live driver unbind, hence they can
> provide the corresponding bus device as &Device<Bound>.
> 
> The same is true for IRQ registrations [4]. free_irq() is guaranteed to be
> called before driver unbind, hence we can provide a &Device<Bound> in the IRQ
> callbacks.
> 
> Ultimately, we want to provide this "cookie" in any driver scope that can be
> proven to be lifetime wise limited to device / driver unbind, so there'll be
> much more users.

Ok, so we should probably merge it now for 6.17-rc1, no objection from
me!

thanks,

greg k-h

Re: [PATCH 2/2] rust: device: implement Device::as_bound()

[Danilo Krummrich]

On 7/14/25 3:24 PM, Greg KH wrote:
> On Mon, Jul 14, 2025 at 11:49:44AM +0200, Danilo Krummrich wrote:
>> On Mon Jul 14, 2025 at 7:30 AM CEST, Greg KH wrote:
>>> On Sun, Jul 13, 2025 at 08:26:54PM +0200, Danilo Krummrich wrote:
>>>> Provide an unsafe functions for abstractions to convert a regular
>>>> &Device to a &Device<Bound>.
>>>>
>>>> This is useful for registrations that provide certain guarantees for the
>>>> scope of their callbacks, such as IRQs or certain class device
>>>> registrations (e.g. PWM, miscdevice).
>>>
>>> Do we have an example where this can be used today in the tree, or is
>>> this only for new stuff going forward that would use it?
>>
>> There's miscdevice in tree, but to be fair, miscdevice doesn't need it without
>> my patch series [1] adding driver support for the existing miscdevice
>> abstractions; the patch in [2] out of this series would use it within
>> args_from_registration().
>>
>> The PWM abstractions [3] need it in bound_parent_device(). The use-case is the
>> same as everywhere else, PWM chips never out-live driver unbind, hence they can
>> provide the corresponding bus device as &Device<Bound>.
>>
>> The same is true for IRQ registrations [4]. free_irq() is guaranteed to be
>> called before driver unbind, hence we can provide a &Device<Bound> in the IRQ
>> callbacks.
>>
>> Ultimately, we want to provide this "cookie" in any driver scope that can be
>> proven to be lifetime wise limited to device / driver unbind, so there'll be
>> much more users.
> 
> Ok, so we should probably merge it now for 6.17-rc1, no objection from
> me!

Yup, gonna pick it up soon (with the casts fixed up as noted in a previous
reply). :)

Re: [PATCH 1/2] rust: devres: provide an accessor for the device

[Danilo Krummrich]

On Sun Jul 13, 2025 at 8:26 PM CEST, Danilo Krummrich wrote:
> Provide an accessor for the Device a Devres instance has been created
> with.
>
> For instance, this is useful when registrations want to provide a
> &Device<Bound> for a scope that is protected by Devres.
>
> Suggested-by: Benno Lossin <lossin@kernel.org>
> Signed-off-by: Danilo Krummrich <dakr@kernel.org>

Applied to driver-core-testing, thanks!

Re: [PATCH 2/2] rust: device: implement Device::as_bound()

[Danilo Krummrich]

On Sun Jul 13, 2025 at 8:26 PM CEST, Danilo Krummrich wrote:
> Provide an unsafe functions for abstractions to convert a regular
> &Device to a &Device<Bound>.
>
> This is useful for registrations that provide certain guarantees for the
> scope of their callbacks, such as IRQs or certain class device
> registrations (e.g. PWM, miscdevice).
>
> Signed-off-by: Danilo Krummrich <dakr@kernel.org>

Applied to driver-core-testing, thanks!

  [ Remove unnecessary cast(). - Danilo ]