Implement TryFrom<&Device> for bus specific devices
Subsystems (4)
Danilo Krummrich
maintainerv3 cover Implement TryFrom<&Device> for bus specific devices
This series provides a mechanism to safely convert a struct device into its corresponding bus specific device instance, if any.
In C a generic struct device is typically converted to a specific bus device with container_of(). This requires the caller to know whether the generic struct device is indeed embedded within the expected bus specific device type.
In Rust we can do the same thing by implementing the TryFrom trait, e.g.
impl TryFrom<&Device> for pci::Device
This is a safe operation, since we can check whether dev->bus equals the the expected struct bus_type.
A branch containing the patches can be found in [1].
This is needed for the auxiliary bus abstractions and connecting nova-core with nova-drm. [2]
[1] https://web.git.kernel.org/pub/scm/linux/kernel/git/dakr/linux.git/log/?h=rust/device
[2] https://gitlab.freedesktop.org/drm/nova/-/tree/staging/nova-drm
Changes in v3:
- drop patch to add Device::parent(), will make it crate private and part of the auxbus series
- safety comment: clarify that a device' bus type is guaranteed to be set correctly by the corresponding C code
Changes in v2:
- s/unsafe { *self.as_raw() }.parent/unsafe { (*self.as_raw()).parent }/
- expand safety comment on Device::bus_type_raw()
Danilo Krummrich (3):
rust: device: implement bus_type_raw()
rust: pci: impl TryFrom<&Device> for &pci::Device
rust: platform: impl TryFrom<&Device> for &platform::Device
rust/kernel/device.rs | 9 +++++++++ rust/kernel/pci.rs | 22 ++++++++++++++++++++-- rust/kernel/platform.rs | 22 ++++++++++++++++++++-- 3 files changed, 49 insertions(+), 4 deletions(-)
base-commit: 51d0de7596a458096756c895cfed6bc4a7ecac10
Signature · 1 line
2.48.1
Danilo Krummrich
maintainerPATCH v3 1/3 rust: device: implement bus_type_raw()
Implement bus_type_raw(), which returns a raw pointer to the device' struct bus_type.
This is useful for bus devices, to implement the following trait.
impl TryFrom<&Device> for &pci::Device
With this a caller can try to get the bus specific device from a generic device in a safe way. try_from() will only succeed if the generic device' bus type pointer matches the pointer of the bus' type.
--- rust/kernel/device.rs | 10 ++++++++++ 1 file changed, 10 insertions(+)
rust/kernel/device.rs +10 -0
@@ -65,6 +65,16 @@ pub(crate) fn as_raw(&self) -> *mut bindings::device { self.0 .get () } +/// Returns a raw pointer to the device' bus type. +#[expect(unused)] +pub (crate )fn bus_type_raw (&self) -> *const bindings::bus_type { +// SAFETY: +// - By the type invariants, `self.as_raw()` is a valid pointer to a `struct device`. +// - `dev->bus` is a pointer to a `const struct bus_type`, which is only ever set at device +// creation. +unsafe { (*self.as_raw ()).bus } + } +/// Convert a raw C `struct device` pointer to a `&'a Device`. /// /// # Safety
Signature · 1 line
2.48.1
Danilo Krummrich
maintainerPATCH v3 2/3 rust: pci: impl TryFrom<&Device> for &pci::Device
In reply to Danilo KrummrichImplement TryFrom<&device::Device> for &Device.
This allows us to get a &pci::Device from a generic &Device in a safe way; the conversion fails if the device' bus type does not match with the PCI bus type.
--- rust/kernel/device.rs | 1 - rust/kernel/pci.rs | 22 ++++++++++++++++++++-- 2 files changed, 20 insertions(+), 3 deletions(-)
rust/kernel/device.rs +0 -1
@@ -66,7 +66,6 @@ pub(crate) fn as_raw(&self) -> *mut bindings::device { }/// Returns a raw pointer to the device' bus type. -#[expect(unused)] pub (crate )fn bus_type_raw (&self) -> *const bindings::bus_type {// SAFETY: // - By the type invariants, `self.as_raw()` is a valid pointer to a `struct device`.
rust/kernel/pci.rs +20 -2
@@ -6,7 +6,7 @@use crate ::{ alloc::flags::*, - bindings, device, + bindings, container_of, device, device_id::RawDeviceId , devres::Devres , driver,
@@ -20,7 +20,7 @@use core::{ marker::PhantomData , ops::Deref , - ptr::{addr_of_mut,NonNull }, + ptr::{addr_of, addr_of_mut,NonNull }, };use kernel::prelude::*;
@@ -466,6 +466,24 @@ fn as_ref(&self) -> &device::Device { } } +impl TryFrom <&device::Device >for &Device { +type Error = kernel::error::Error ; + +fn try_from (dev: &device::Device ) ->Result <Self ,Self ::Error > { +if dev.bus_type_raw () !=addr_of! (bindings::pci_bus_type) { +return Err (EINVAL ); + } + +// SAFETY: We've just verified that the bus type of `dev` equals `bindings::pci_bus_type`, +// hence `dev` must be embedded in a valid `struct pci_dev` as guaranteed by the +// corresponding C code. +let pdev =unsafe {container_of! (dev.as_raw (), bindings::pci_dev, dev) }; + +// SAFETY: `pdev` is a valid pointer to a `struct pci_dev`. +Ok (unsafe { &*pdev.cast () }) + } +} +// SAFETY: A `Device` is always reference-counted and can be released from any thread. unsafe impl Send for Device {}
Signature · 1 line
2.48.1
Danilo Krummrich
maintainerPATCH v3 3/3 rust: platform: impl TryFrom<&Device> for &platform::Device
In reply to Danilo KrummrichImplement TryFrom<&device::Device> for &Device.
This allows us to get a &platform::Device from a generic &Device in a safe way; the conversion fails if the device' bus type does not match with the platform bus type.
--- rust/kernel/platform.rs | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-)
rust/kernel/platform.rs +20 -2
@@ -5,7 +5,7 @@//! C header: [`include/linux/platform_device.h`](srctree/include/linux/platform_device.h) use crate ::{ - bindings, device, driver, + bindings, container_of, device, driver, error::{to_result,Result }, of, prelude::*,
@@ -17,7 +17,7 @@use core::{ marker::PhantomData , ops::Deref , - ptr::{addr_of_mut,NonNull }, + ptr::{addr_of, addr_of_mut,NonNull }, };/// An adapter for the registration of platform drivers.
@@ -234,6 +234,24 @@ fn as_ref(&self) -> &device::Device { } } +impl TryFrom <&device::Device >for &Device { +type Error = kernel::error::Error ; + +fn try_from (dev: &device::Device ) ->Result <Self ,Self ::Error > { +if dev.bus_type_raw () !=addr_of! (bindings::platform_bus_type) { +return Err (EINVAL ); + } + +// SAFETY: We've just verified that the bus type of `dev` equals +// `bindings::platform_bus_type`, hence `dev` must be embedded in a valid +// `struct platform_device` as guaranteed by the corresponding C code. +let pdev =unsafe {container_of! (dev.as_raw (), bindings::platform_device, dev) }; + +// SAFETY: `pdev` is a valid pointer to a `struct platform_device`. +Ok (unsafe { &*pdev.cast () }) + } +} +// SAFETY: A `Device` is always reference-counted and can be released from any thread. unsafe impl Send for Device {}
Signature · 1 line
2.48.1