Improve soundness of bus device abstractions
Subsystems (7)
Danilo Krummrich
maintainerv2 cover Improve soundness of bus device abstractions
Currently, when sharing references of bus devices (e.g. ARef<pci::Device>), we do not have a way to restrict which functions of a bus device can be called.
Consequently, it is possible to call all bus device functions concurrently from any context. This includes functions, which access fields of the (bus) device, which are not protected against concurrent access.
This is improved by applying an execution context to the bus device in form of a generic type.
For instance, the PCI device reference that is passed to probe() has the type pci::Device<Core>, which implements all functions that are only allowed to be called from bus callbacks.
The implementation for the default context (pci::Device) contains all functions that are safe to call from any context concurrently.
The context types can be extended as required, e.g. to limit availability of certain (bus) device functions to probe().
A branch containing the patches can be found in [1].
[1] https://web.git.kernel.org/pub/scm/linux/kernel/git/dakr/linux.git/log/?h=rust/device
Changes in v2:
- make DeviceContext trait sealed
- impl From<&pci::Device<device::Core>> for ARef<pci::Device>
- impl From<&platform::Device<device::Core>> for ARef<platform::Device>
- rebase onto v6.14-rc6
- apply RBs
Danilo Krummrich (4):
rust: pci: use to_result() in enable_device_mem()
rust: device: implement device context marker
rust: pci: fix unrestricted &mut pci::Device
rust: platform: fix unrestricted &mut platform::Device
rust/kernel/device.rs | 26 +++++ rust/kernel/pci.rs | 137 +++++++++++++++++---------- rust/kernel/platform.rs | 95 +++++++++++++------ samples/rust/rust_driver_pci.rs | 8 +- samples/rust/rust_driver_platform.rs | 11 ++- 5 files changed, 187 insertions(+), 90 deletions(-)
base-commit: 80e54e84911a923c40d7bee33a34c1b4be148d7a
Signature · 1 line
2.48.1
Danilo Krummrich
maintainerPATCH v2 1/4 rust: pci: use to_result() in enable_device_mem()
Simplify enable_device_mem() by using to_result() to handle the return value of the corresponding FFI call.
--- rust/kernel/pci.rs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-)
rust/kernel/pci.rs +1 -6
@@ -382,12 +382,7 @@ pub fn device_id(&self) -> u16 {/// Enable memory resources for this device. pub fn enable_device_mem (&self) ->Result {// SAFETY: `self.as_raw` is guaranteed to be a pointer to a valid `struct pci_dev`. -let ret =unsafe { bindings::pci_enable_device_mem (self.as_raw ()) }; -if ret !=0 { -Err (Error ::from_errno (ret)) - }else { -Ok (()) - } +to_result (unsafe { bindings::pci_enable_device_mem (self.as_raw ()) }) }/// Enable bus-mastering for this device.
Signature · 1 line
2.48.1
Danilo Krummrich
maintainerPATCH v2 2/4 rust: device: implement device context marker
In reply to Danilo KrummrichSome bus device functions should only be called from bus callbacks, such as probe(), remove(), resume(), suspend(), etc.
To ensure this add device context marker structs, that can be used as generics for bus device implementations.
--- rust/kernel/device.rs | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
rust/kernel/device.rs +26 -0
@@ -209,6 +209,32 @@ unsafe impl Send for Device {}// synchronization in `struct device`. unsafe impl Sync for Device {} +/// Marker trait for the context of a bus specific device. +/// +/// Some functions of a bus specific device should only be called from a certain context, i.e. bus +/// callbacks, such as `probe()`. +/// +/// This is the marker trait for structures representing the context of a bus specific device. +pub trait DeviceContext : private::Sealed {} + +/// The [`Normal`] context is the context of a bus specific device when it is not an argument of +/// any bus callback. +pub struct Normal ; + +/// The [`Core`] context is the context of a bus specific device when it is supplied as argument of +/// any of the bus callbacks, such as `probe()`. +pub struct Core ; + +mod private { +pub trait Sealed {} + +impl Sealed for super ::Core {} +impl Sealed for super ::Normal {} +} + +impl DeviceContext for Core {} +impl DeviceContext for Normal {} +#[doc(hidden)] #[macro_export] macro_rules! dev_printk {
Signature · 1 line
2.48.1
Re: [PATCH v2 2/4] rust: device: implement device context marker
Quoted 8 lines · Danilo Krummrich
Some bus device functions should only be called from bus callbacks, such as
probe(),remove(),resume(),suspend(), etc.To ensure this add device context marker structs, that can be used as generics for bus device implementations.
Reviewed-by Benno Lossin <[email protected]>Suggested-by Benno Lossin <[email protected]>
Try chronological order for the tags? It was suggested first and then reviewed.
Regards,
Boqun
Quoted 45 lines
Signed-off-by Danilo Krummrich <[email protected]>--- rust/kernel/device.rs | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)rust/kernel/device.rs +26
-0@@ -209,6 +209,32 @@ unsafe impl Send for Device {}// synchronization in `struct device`. unsafe impl Sync for Device {} +/// Marker trait for the context of a bus specific device. +/// +/// Some functions of a bus specific device should only be called from a certain context, i.e. bus +/// callbacks, such as `probe()`. +/// +/// This is the marker trait for structures representing the context of a bus specific device. +pub trait DeviceContext : private::Sealed {} + +/// The [`Normal`] context is the context of a bus specific device when it is not an argument of +/// any bus callback. +pub struct Normal ; + +/// The [`Core`] context is the context of a bus specific device when it is supplied as argument of +/// any of the bus callbacks, such as `probe()`. +pub struct Core ; + +mod private { +pub trait Sealed {} + +impl Sealed for super ::Core {} +impl Sealed for super ::Normal {} +} + +impl DeviceContext for Core {} +impl DeviceContext for Normal {} +#[doc(hidden)] #[macro_export] macro_rules! dev_printk {Signature · 1 line
2.48.1
Danilo Krummrich
maintainerRe: [PATCH v2 2/4] rust: device: implement device context marker
Quoted 4 lines · Boqun Feng
Quoted 3 lines · Danilo Krummrich
Some bus device functions should only be called from bus callbacks, such as
probe(),remove(),resume(),suspend(), etc.
Quoted 8 lines
Quoted 5 lines
To ensure this add device context marker structs, that can be used as generics for bus device implementations.
Reviewed-by Benno Lossin <[email protected]>Suggested-by Benno Lossin <[email protected]>Try chronological order for the tags? It was suggested first and then reviewed.
Is that a thing? When I apply patches I usully keep ACKs, RBs and SOBs together at the bottom.
Re: [PATCH v2 2/4] rust: device: implement device context marker
Quoted 3 lines · Danilo Krummrich
Is that a thing? When I apply patches I usully keep ACKs, RBs and SOBs together at the bottom.
It depends on the maintainers/subsystem. Some do chronological, some do groups (even to the point of having a defined order). Chronological loses less information but "looks worse". Some consider RBs should go on top, others below.
I think most people respect the SoB boundary though, when applying a patch from someone else, and that is likely the most important part.
Cheers,
Miguel
Re: [PATCH v2 2/4] rust: device: implement device context marker
In reply to Danilo KrummrichQuoted 8 lines · Danilo Krummrich
Quoted 7 lines · Boqun Feng
Quoted 6 lines · Danilo Krummrich
Some bus device functions should only be called from bus callbacks, such as
probe(),remove(),resume(),suspend(), etc.To ensure this add device context marker structs, that can be used as generics for bus device implementations.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Reviewed-by Benno Lossin <[email protected]>Suggested-by Benno Lossin <[email protected]>Try chronological order for the tags? It was suggested first and then reviewed.
Is that a thing? When I apply patches I usully keep ACKs, RBs and SOBs together at the bottom.
I don't think it's a hard requirement, but it makes logical sense to order the tags except your own SoB based on chronological order when re-submitting a new version IMO. It's in the same spirit of putting SoBs in chronological when multiple people handle the patches.
But it's your choice, I just feel it's a bit odd in the current order ;-)
Regards,
Boqun
Danilo Krummrich
maintainerPATCH v2 3/4 rust: pci: fix unrestricted &mut pci::Device
In reply to Danilo KrummrichAs by now, pci::Device is implemented as:
#[derive(Clone)] pub struct Device(ARef<device::Device>);
This may be convenient, but has the implication that drivers can call device methods that require a mutable reference concurrently at any point of time.
Instead define pci::Device as
pub struct Device<Ctx: DeviceContext = Normal>( Opaque<bindings::pci_dev>, PhantomData<Ctx>, );
and manually implement the AlwaysRefCounted trait.
With this we can implement methods that should only be called from bus callbacks (such as probe()) for pci::Device<Core>. Consequently, we make this type accessible in bus callbacks only.
Arbitrary references taken by the driver are still of type ARef<pci::Device> and hence don't provide access to methods that are reserved for bus callbacks.
--- rust/kernel/pci.rs | 132 ++++++++++++++++++++------------ samples/rust/rust_driver_pci.rs | 8 +- 2 files changed, 89 insertions(+), 51 deletions(-)
rust/kernel/pci.rs +85 -47
@@ -6,7 +6,7 @@use crate ::{ alloc::flags::*, - bindings, container_of, device, + bindings, device, device_id::RawDeviceId , devres::Devres , driver,
@@ -17,7 +17,11 @@ types::{ARef, ForeignOwnable, Opaque}, ThisModule, }; -use core::{ops::Deref , ptr::addr_of_mut}; +use core::{ + marker::PhantomData , + ops::Deref , + ptr::{addr_of_mut,NonNull }, +};use kernel::prelude::*;/// An adapter for the registration of PCI drivers.
@@ -60,17 +64,16 @@ extern "C" fn probe_callback( ) -> kernel::ffi::c_int {// SAFETY: The PCI bus only ever calls the probe callback with a valid pointer to a // `struct pci_dev`. -let dev =unsafe { device::Device ::get_device (addr_of_mut! ((*pdev).dev)) }; -// SAFETY: `dev` is guaranteed to be embedded in a valid `struct pci_dev` by the call -// above. -let mut pdev =unsafe {Device ::from_dev (dev) }; +// +// INVARIANT: `pdev` is valid for the duration of `probe_callback()`. +let pdev =unsafe { &*pdev.cast ::<Device <device::Core >>() };// SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct pci_device_id` and // does not add additional invariants, so it's safe to transmute. let id =unsafe { &*id.cast ::<DeviceId >() };let info =T ::ID_TABLE .info (id.index ()); -match T ::probe (&mut pdev, info) { +match T ::probe (pdev, info) {Ok (data) => {// Let the `struct pci_dev` own a reference of the driver's private data. // SAFETY: By the type invariant `pdev.as_raw` returns a valid pointer to a
@@ -192,7 +195,7 @@ macro_rules! pci_device_table {/// # Example /// ///``` -/// # use kernel::{bindings, pci}; +/// # use kernel::{bindings, device::Core, pci}; /// /// struct MyDriver; ///
@@ -210,7 +213,7 @@ macro_rules! pci_device_table {/// const ID_TABLE: pci::IdTable<Self::IdInfo> = &PCI_TABLE; /// /// fn probe( -/// _pdev: &mut pci::Device, +/// _pdev: &pci::Device<Core>, /// _id_info: &Self::IdInfo, /// ) -> Result<Pin<KBox<Self>>> { /// Err(ENODEV)
@@ -234,20 +237,23 @@ pub trait Driver {/// /// Called when a new platform device is added or discovered. /// Implementers should attempt to initialize the device here. -fn probe (dev: &mut Device , id_info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>>; +fn probe (dev: &Device <device::Core >, id_info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>>; }/// The PCI device representation. /// -/// A PCI device is based on an always reference counted `device:Device` instance. Cloning a PCI -/// device, hence, also increments the base device' reference count. +/// This structure represents the Rust abstraction for a C `struct pci_dev`. The implementation +/// abstracts the usage of an already existing C `struct pci_dev` within Rust code that we get +/// passed from the C side. /// /// # Invariants /// -/// `Device` hold a valid reference of `ARef<device::Device>` whose underlying `struct device` is a -/// member of a `struct pci_dev`. -#[derive( Clone )] -pub struct Device (ARef <device::Device >); +/// A [`Device`] instance represents a valid `struct device` created by the C portion of the kernel. +#[repr(transparent)] +pub struct Device <Ctx : device::DeviceContext = device::Normal >( +Opaque <bindings::pci_dev >, +PhantomData <Ctx >, +);/// A PCI BAR to perform I/O-Operations on. ///
@@ -256,13 +262,13 @@ pub trait Driver {/// `Bar` always holds an `IoRaw` inststance that holds a valid pointer to the start of the I/O /// memory mapped PCI bar and its size. pub struct Bar <const SIZE :usize =0 > { - pdev:Device , + pdev:ARef <Device >, io:IoRaw <SIZE >, num:i32 , }impl <const SIZE :usize >Bar <SIZE > { -fn new (pdev:Device , num:u32 , name: &CStr ) ->Result <Self > { +fn new (pdev: &Device , num:u32 , name: &CStr ) ->Result <Self > {let len = pdev.resource_len (num)?;if len ==0 {return Err (ENOMEM );
@@ -300,12 +306,16 @@ fn new(pdev: Device, num: u32, name: &CStr) -> Result<Self> {// `pdev` is valid by the invariants of `Device`. // `ioptr` is guaranteed to be the start of a valid I/O mapped memory region. // `num` is checked for validity by a previous call to `Device::resource_len`. -unsafe {Self ::do_release (&pdev, ioptr, num) }; +unsafe {Self ::do_release (pdev, ioptr, num) };return Err (err); } }; -Ok (Bar { pdev, io, num }) +Ok (Bar { + pdev: pdev.into (), + io, + num, + }) }/// # Safety
@@ -351,20 +361,8 @@ fn deref(&self) -> &Self::Target { }impl Device { -/// Create a PCI Device instance from an existing `device::Device`. -/// -/// # Safety -/// -/// `dev` must be an `ARef<device::Device>` whose underlying `bindings::device` is a member of -/// a `bindings::pci_dev`. -pub unsafe fn from_dev (dev:ARef <device::Device >) ->Self { -Self (dev) - } -fn as_raw (&self) -> *mut bindings::pci_dev { -// SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` -// embedded in `struct pci_dev`. -unsafe {container_of! (self.0 .as_raw (), bindings::pci_dev, dev)as _ } + self.0 .get () }/// Returns the PCI vendor ID.
@@ -379,18 +377,6 @@ pub fn device_id(&self) -> u16 {unsafe { (*self.as_raw ()).device } } -/// Enable memory resources for this device. -pub fn enable_device_mem (&self) ->Result { -// SAFETY: `self.as_raw` is guaranteed to be a pointer to a valid `struct pci_dev`. -to_result (unsafe { bindings::pci_enable_device_mem (self.as_raw ()) }) - } - -/// Enable bus-mastering for this device. -pub fn set_master (&self) { -// SAFETY: `self.as_raw` is guaranteed to be a pointer to a valid `struct pci_dev`. -unsafe { bindings::pci_set_master (self.as_raw ()) }; - } -/// Returns the size of the given PCI bar resource. pub fn resource_len (&self, bar:u32 ) ->Result <bindings::resource_size_t > {if !Bar ::index_is_valid (bar) {
@@ -410,7 +396,7 @@ pub fn iomap_region_sized<const SIZE: usize>( bar: u32, name: &CStr, ) -> Result<Devres<Bar<SIZE>>> { -let bar =Bar ::<SIZE >::new (self.clone (), bar, name)?; +let bar =Bar ::<SIZE >::new (self, bar, name)?;let devres =Devres ::new (self.as_ref (), bar,GFP_KERNEL )?;Ok (devres)
@@ -422,8 +408,60 @@ pub fn iomap_region(&self, bar: u32, name: &CStr) -> Result<Devres<Bar>> { } } +impl Device <device::Core > { +/// Enable memory resources for this device. +pub fn enable_device_mem (&self) ->Result { +// SAFETY: `self.as_raw` is guaranteed to be a pointer to a valid `struct pci_dev`. +to_result (unsafe { bindings::pci_enable_device_mem (self.as_raw ()) }) + } + +/// Enable bus-mastering for this device. +pub fn set_master (&self) { +// SAFETY: `self.as_raw` is guaranteed to be a pointer to a valid `struct pci_dev`. +unsafe { bindings::pci_set_master (self.as_raw ()) }; + } +} + +impl Deref for Device <device::Core > { +type Target =Device ; + +fn deref (&self) -> &Self ::Target { +let ptr: *const Self = self; + +// CAST: `Device<Ctx>` is a transparent wrapper of `Opaque<bindings::pci_dev>`. +let ptr = ptr.cast ::<Device >(); + +// SAFETY: `ptr` was derived from `&self`. +unsafe { &*ptr } + } +} + +impl From <&Device <device::Core >>for ARef <Device > { +fn from (dev: &Device <device::Core >) ->Self { + (&**dev).into () + } +} + +// SAFETY: Instances of `Device` are always reference-counted. +unsafe impl crate ::types::AlwaysRefCounted for Device { +fn inc_ref (&self) { +// SAFETY: The existence of a shared reference guarantees that the refcount is non-zero. +unsafe { bindings::pci_dev_get (self.as_raw ()) }; + } + +unsafe fn dec_ref (obj:NonNull <Self >) { +// SAFETY: The safety requirements guarantee that the refcount is non-zero. +unsafe { bindings::pci_dev_put (obj.cast ().as_ptr ()) } + } +} +impl AsRef <device::Device >for Device {fn as_ref (&self) -> &device::Device { - &self.0 +// SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid +// `struct pci_dev`. +let dev =unsafe {addr_of_mut! ((*self.as_raw ()).dev) }; + +// SAFETY: `dev` points to a valid `struct device`. +unsafe { device::Device ::as_ref (dev) } } }
samples/rust/rust_driver_pci.rs +4 -4
@@ -4,7 +4,7 @@//! //! To make this driver probe, QEMU must be run with `-device pci-testdev`. -use kernel::{bindings, c_str, devres::Devres , pci, prelude::*}; +use kernel::{bindings, c_str, device::Core , devres::Devres , pci, prelude::*, types::ARef };struct Regs ;
@@ -26,7 +26,7 @@ impl TestIndex { }struct SampleDriver { - pdev: pci::Device , + pdev:ARef <pci::Device >, bar:Devres <Bar0 >, }
@@ -62,7 +62,7 @@ impl pci::Driver for SampleDriver {const ID_TABLE : pci::IdTable <Self ::IdInfo > = &PCI_TABLE ; -fn probe (pdev: &mut pci::Device , info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>> { +fn probe (pdev: &pci::Device <Core >, info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>> {dev_dbg! ( pdev.as_ref (),"Probe Rust PCI driver sample (PCI ID: 0x{:x}, 0x{:x}).\n" ,
@@ -77,7 +77,7 @@ fn probe(pdev: &mut pci::Device, info: &Self::IdInfo) -> Result<Pin<KBox<Self>>>let drvdata =KBox ::new (Self { - pdev: pdev.clone (), + pdev: pdev.into (), bar, }, GFP_KERNEL,
Signature · 1 line
2.48.1
Danilo Krummrich
maintainerPATCH v2 4/4 rust: platform: fix unrestricted &mut platform::Device
In reply to Danilo KrummrichAs by now, platform::Device is implemented as:
#[derive(Clone)] pub struct Device(ARef<device::Device>);
This may be convenient, but has the implication that drivers can call device methods that require a mutable reference concurrently at any point of time.
Instead define platform::Device as
pub struct Device<Ctx: DeviceContext = Normal>( Opaque<bindings::platform_dev>, PhantomData<Ctx>, );
and manually implement the AlwaysRefCounted trait.
With this we can implement methods that should only be called from bus callbacks (such as probe()) for platform::Device<Core>. Consequently, we make this type accessible in bus callbacks only.
Arbitrary references taken by the driver are still of type ARef<platform::Device> and hence don't provide access to methods that are reserved for bus callbacks.
--- rust/kernel/platform.rs | 95 +++++++++++++++++++--------- samples/rust/rust_driver_platform.rs | 11 ++-- 2 files changed, 72 insertions(+), 34 deletions(-)
rust/kernel/platform.rs +65 -30
@@ -5,7 +5,7 @@//! C header: [`include/linux/platform_device.h`](srctree/include/linux/platform_device.h) use crate ::{ - bindings, container_of, device, driver, + bindings, device, driver, error::{to_result,Result }, of, prelude::*,
@@ -14,7 +14,11 @@ ThisModule, }; -use core::ptr::addr_of_mut; +use core::{ + marker::PhantomData , + ops::Deref , + ptr::{addr_of_mut,NonNull }, +};/// An adapter for the registration of platform drivers. pub struct Adapter <T :Driver >(T );
@@ -54,14 +58,14 @@ unsafe fn unregister(pdrv: &Opaque<Self::RegType>) {impl <T :Driver + 'static>Adapter <T > {extern "C" fn probe_callback (pdev: *mut bindings::platform_device ) -> kernel::ffi::c_int { -// SAFETY: The platform bus only ever calls the probe callback with a valid `pdev`. -let dev =unsafe { device::Device ::get_device (addr_of_mut! ((*pdev).dev)) }; -// SAFETY: `dev` is guaranteed to be embedded in a valid `struct platform_device` by the -// call above. -let mut pdev =unsafe {Device ::from_dev (dev) }; +// SAFETY: The platform bus only ever calls the probe callback with a valid pointer to a +// `struct platform_device`. +// +// INVARIANT: `pdev` is valid for the duration of `probe_callback()`. +let pdev =unsafe { &*pdev.cast ::<Device <device::Core >>() };let info = <Self as driver::Adapter >::id_info (pdev.as_ref ()); -match T ::probe (&mut pdev, info) { +match T ::probe (pdev, info) {Ok (data) => {// Let the `struct platform_device` own a reference of the driver's private data. // SAFETY: By the type invariant `pdev.as_raw` returns a valid pointer to a
@@ -120,7 +124,7 @@ macro_rules! module_platform_driver {/// # Example /// ///``` -/// # use kernel::{bindings, c_str, of, platform}; +/// # use kernel::{bindings, c_str, device::Core, of, platform}; /// /// struct MyDriver; ///
@@ -138,7 +142,7 @@ macro_rules! module_platform_driver {/// const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE); /// /// fn probe( -/// _pdev: &mut platform::Device, +/// _pdev: &platform::Device<Core>, /// _id_info: Option<&Self::IdInfo>, /// ) -> Result<Pin<KBox<Self>>> { /// Err(ENODEV)
@@ -160,41 +164,72 @@ pub trait Driver {/// /// Called when a new platform device is added or discovered. /// Implementers should attempt to initialize the device here. -fn probe (dev: &mut Device , id_info:Option <&Self ::IdInfo >) ->Result <Pin <KBox <Self >>>; +fn probe (dev: &Device <device::Core >, id_info:Option <&Self ::IdInfo >) + ->Result <Pin <KBox <Self >>>; }/// The platform device representation. /// -/// A platform device is based on an always reference counted `device:Device` instance. Cloning a -/// platform device, hence, also increments the base device' reference count. +/// This structure represents the Rust abstraction for a C `struct platform_device`. The +/// implementation abstracts the usage of an already existing C `struct platform_device` within Rust +/// code that we get passed from the C side. /// /// # Invariants /// -/// `Device` holds a valid reference of `ARef<device::Device>` whose underlying `struct device` is a -/// member of a `struct platform_device`. -#[derive( Clone )] -pub struct Device (ARef <device::Device >); +/// A [`Device`] instance represents a valid `struct platform_device` created by the C portion of +/// the kernel. +#[repr(transparent)] +pub struct Device <Ctx : device::DeviceContext = device::Normal >( +Opaque <bindings::platform_device >, +PhantomData <Ctx >, +);impl Device { -/// Convert a raw kernel device into a `Device` -/// -/// # Safety -/// -/// `dev` must be an `Aref<device::Device>` whose underlying `bindings::device` is a member of a -/// `bindings::platform_device`. -unsafe fn from_dev (dev:ARef <device::Device >) ->Self { -Self (dev) +fn as_raw (&self) -> *mut bindings::platform_device { + self.0 .get () } +} -fn as_raw (&self) -> *mut bindings::platform_device { -// SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` -// embedded in `struct platform_device`. -unsafe {container_of! (self.0 .as_raw (), bindings::platform_device, dev) }.cast_mut () +impl Deref for Device <device::Core > { +type Target =Device ; + +fn deref (&self) -> &Self ::Target { +let ptr: *const Self = self; + +// CAST: `Device<Ctx>` is a transparent wrapper of `Opaque<bindings::platform_device>`. +let ptr = ptr.cast ::<Device >(); + +// SAFETY: `ptr` was derived from `&self`. +unsafe { &*ptr } + } +} + +impl From <&Device <device::Core >>for ARef <Device > { +fn from (dev: &Device <device::Core >) ->Self { + (&**dev).into () + } +} + +// SAFETY: Instances of `Device` are always reference-counted. +unsafe impl crate ::types::AlwaysRefCounted for Device { +fn inc_ref (&self) { +// SAFETY: The existence of a shared reference guarantees that the refcount is non-zero. +unsafe { bindings::get_device (self.as_ref ().as_raw ()) }; + } + +unsafe fn dec_ref (obj:NonNull <Self >) { +// SAFETY: The safety requirements guarantee that the refcount is non-zero. +unsafe { bindings::platform_device_put (obj.cast ().as_ptr ()) } } }impl AsRef <device::Device >for Device {fn as_ref (&self) -> &device::Device { - &self.0 +// SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid +// `struct platform_device`. +let dev =unsafe {addr_of_mut! ((*self.as_raw ()).dev) }; + +// SAFETY: `dev` points to a valid `struct device`. +unsafe { device::Device ::as_ref (dev) } } }
samples/rust/rust_driver_platform.rs +7 -4
@@ -2,10 +2,10 @@//! Rust Platform driver sample. -use kernel::{c_str, of, platform, prelude::*}; +use kernel::{c_str, device::Core , of, platform, prelude::*, types::ARef };struct SampleDriver { - pdev: platform::Device , + pdev:ARef <platform::Device >, }struct Info (u32 );
@@ -21,14 +21,17 @@ impl platform::Driver for SampleDriver {type IdInfo =Info ;const OF_ID_TABLE :Option <of::IdTable <Self ::IdInfo >> =Some (&OF_TABLE ); -fn probe (pdev: &mut platform::Device , info:Option <&Self ::IdInfo >) ->Result <Pin <KBox <Self >>> { +fn probe ( + pdev: &platform::Device <Core >, + info:Option <&Self ::IdInfo >, + ) ->Result <Pin <KBox <Self >>> {dev_dbg! (pdev.as_ref (),"Probe Rust Platform driver sample.\n" );if let Some (info) = info {dev_info! (pdev.as_ref (),"Probed with info: '{}'.\n" , info.0 ); } -let drvdata =KBox ::new (Self { pdev: pdev.clone () },GFP_KERNEL )?; +let drvdata =KBox ::new (Self { pdev: pdev.into () },GFP_KERNEL )?;Ok (drvdata.into ()) }
Signature · 1 line
2.48.1
Quoted 17 lines · Danilo Krummrich
Currently, when sharing references of bus devices (e.g. ARef<pci::Device>), we do not have a way to restrict which functions of a bus device can be called.
Consequently, it is possible to call all bus device functions concurrently from any context. This includes functions, which access fields of the (bus) device, which are not protected against concurrent access.
This is improved by applying an execution context to the bus device in form of a generic type.
For instance, the PCI device reference that is passed to
probe()has the type pci::Device<Core>, which implements all functions that are only allowed to be called from bus callbacks.The implementation for the default context (
pci::Device) contains all functions that are safe to call from any context concurrently.
Quoted 7 lines
The context types can be extended as required, e.g. to limit availability of certain (bus) device functions to
probe().A branch containing the patches can be found in [1].
[1] https://web.git.kernel.org/pub/scm/linux/kernel/git/dakr/linux.git/log/?h=rust/device
Again,
Regards,
Boqun
Quoted 25 lines
Changes in v2:
- makeDeviceContexttrait sealed
- impl From<&pci::Device<device::Core>> for ARef<pci::Device>
- impl From<&platform::Device<device::Core>> for ARef<platform::Device>
- rebase onto v6.14-rc6
- apply RBsDanilo Krummrich (4):
rust: pci: useto_result()inenable_device_mem()
rust: device: implement device context marker
rust: pci: fix unrestricted &mutpci::Device
rust: platform: fix unrestricted &mutplatform::Devicerust/kernel/device.rs | 26 +++++ rust/kernel/pci.rs | 137 +++++++++++++++++---------- rust/kernel/platform.rs | 95 +++++++++++++------ samples/rust/rust_driver_pci.rs | 8 +- samples/rust/rust_driver_platform.rs | 11 ++- 5 files changed, 187 insertions(+), 90 deletions(-)base-commit:
80e54e84911a923c40d7bee33a34c1b4be148d7aSignature · 1 line
2.48.1
Danilo Krummrich
maintainerQuoted 21 lines · Boqun Feng
Quoted 20 lines · Danilo Krummrich
Currently, when sharing references of bus devices (e.g. ARef<pci::Device>), we do not have a way to restrict which functions of a bus device can be called.
Consequently, it is possible to call all bus device functions concurrently from any context. This includes functions, which access fields of the (bus) device, which are not protected against concurrent access.
This is improved by applying an execution context to the bus device in form of a generic type.
For instance, the PCI device reference that is passed to
probe()has the type pci::Device<Core>, which implements all functions that are only allowed to be called from bus callbacks.The implementation for the default context (
pci::Device) contains all functions that are safe to call from any context concurrently.The context types can be extended as required, e.g. to limit availability of certain (bus) device functions to
probe().
Quoted 8 lines
Quoted 4 lines
A branch containing the patches can be found in [1].
[1] https://web.git.kernel.org/pub/scm/linux/kernel/git/dakr/linux.git/log/?h=rust/device
Again,
Acked-by Boqun Feng <[email protected]>
Sorry, I forgot to add your ACKs. Thanks for providing it again!
Greg KH
maintainerQuoted 37 lines · Danilo Krummrich
Currently, when sharing references of bus devices (e.g. ARef<pci::Device>), we do not have a way to restrict which functions of a bus device can be called.
Consequently, it is possible to call all bus device functions concurrently from any context. This includes functions, which access fields of the (bus) device, which are not protected against concurrent access.
This is improved by applying an execution context to the bus device in form of a generic type.
For instance, the PCI device reference that is passed to
probe()has the type pci::Device<Core>, which implements all functions that are only allowed to be called from bus callbacks.The implementation for the default context (
pci::Device) contains all functions that are safe to call from any context concurrently.The context types can be extended as required, e.g. to limit availability of certain (bus) device functions to
probe().A branch containing the patches can be found in [1].
[1] https://web.git.kernel.org/pub/scm/linux/kernel/git/dakr/linux.git/log/?h=rust/device
Changes in v2:
- makeDeviceContexttrait sealed
- impl From<&pci::Device<device::Core>> for ARef<pci::Device>
- impl From<&platform::Device<device::Core>> for ARef<platform::Device>
- rebase onto v6.14-rc6
- apply RBsDanilo Krummrich (4):
rust: pci: useto_result()inenable_device_mem()
rust: device: implement device context marker
rust: pci: fix unrestricted &mutpci::Device
rust: platform: fix unrestricted &mutplatform::Device
Quoted 6 lines
rust/kernel/device.rs | 26 +++++ rust/kernel/pci.rs | 137 +++++++++++++++++---------- rust/kernel/platform.rs | 95 +++++++++++++------ samples/rust/rust_driver_pci.rs | 8 +- samples/rust/rust_driver_platform.rs | 11 ++- 5 files changed, 187 insertions(+), 90 deletions(-)
Thanks for doing this work, looks good to me. Mind if I suck it into the driver-core tree now? Or do you want it to go through a different tree?
thanks,
greg k-h
Danilo Krummrich
maintainerQuoted 45 lines · Greg KH
Quoted 37 lines · Danilo Krummrich
Currently, when sharing references of bus devices (e.g. ARef<pci::Device>), we do not have a way to restrict which functions of a bus device can be called.
Consequently, it is possible to call all bus device functions concurrently from any context. This includes functions, which access fields of the (bus) device, which are not protected against concurrent access.
This is improved by applying an execution context to the bus device in form of a generic type.
For instance, the PCI device reference that is passed to
probe()has the type pci::Device<Core>, which implements all functions that are only allowed to be called from bus callbacks.The implementation for the default context (
pci::Device) contains all functions that are safe to call from any context concurrently.The context types can be extended as required, e.g. to limit availability of certain (bus) device functions to
probe().A branch containing the patches can be found in [1].
[1] https://web.git.kernel.org/pub/scm/linux/kernel/git/dakr/linux.git/log/?h=rust/device
Changes in v2:
- makeDeviceContexttrait sealed
- impl From<&pci::Device<device::Core>> for ARef<pci::Device>
- impl From<&platform::Device<device::Core>> for ARef<platform::Device>
- rebase onto v6.14-rc6
- apply RBsDanilo Krummrich (4):
rust: pci: useto_result()inenable_device_mem()
rust: device: implement device context marker
rust: pci: fix unrestricted &mutpci::Device
rust: platform: fix unrestricted &mutplatform::DeviceQuoted 6 lines
rust/kernel/device.rs | 26 +++++ rust/kernel/pci.rs | 137 +++++++++++++++++---------- rust/kernel/platform.rs | 95 +++++++++++++------ samples/rust/rust_driver_pci.rs | 8 +- samples/rust/rust_driver_platform.rs | 11 ++- 5 files changed, 187 insertions(+), 90 deletions(-)
Quoted 3 lines
Thanks for doing this work, looks good to me. Mind if I suck it into the driver-core tree now? Or do you want it to go through a different tree?
This series has a conflict with nova-core, it will require the following fixup in -next and Linus' tree when he pulls things.
drivers/gpu/nova-core/driver.rs +2 -2
@@ -1,6 +1,6 @@// SPDX-License-Identifier: GPL-2.0 -use kernel::{bindings, c_str, pci, prelude::*}; +use kernel::{bindings, c_str, device::Core , pci, prelude::*};use crate ::gpu::Gpu ;
@@ -27,7 +27,7 @@ impl pci::Driver for NovaCore {type IdInfo = ();const ID_TABLE : pci::IdTable <Self ::IdInfo > = &PCI_TABLE ; -fn probe (pdev: &mut pci::Device , _info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>> { +fn probe (pdev: &pci::Device <Core >, _info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>> {dev_dbg! (pdev.as_ref (),"Probe Nova Core GPU driver.\n" ); pdev.enable_device_mem ()?;
Greg KH
maintainerQuoted 67 lines · Danilo Krummrich
Quoted 45 lines · Greg KH
Quoted 37 lines · Danilo Krummrich
Currently, when sharing references of bus devices (e.g. ARef<pci::Device>), we do not have a way to restrict which functions of a bus device can be called.
Consequently, it is possible to call all bus device functions concurrently from any context. This includes functions, which access fields of the (bus) device, which are not protected against concurrent access.
This is improved by applying an execution context to the bus device in form of a generic type.
For instance, the PCI device reference that is passed to
probe()has the type pci::Device<Core>, which implements all functions that are only allowed to be called from bus callbacks.The implementation for the default context (
pci::Device) contains all functions that are safe to call from any context concurrently.The context types can be extended as required, e.g. to limit availability of certain (bus) device functions to
probe().A branch containing the patches can be found in [1].
[1] https://web.git.kernel.org/pub/scm/linux/kernel/git/dakr/linux.git/log/?h=rust/device
Changes in v2:
- makeDeviceContexttrait sealed
- impl From<&pci::Device<device::Core>> for ARef<pci::Device>
- impl From<&platform::Device<device::Core>> for ARef<platform::Device>
- rebase onto v6.14-rc6
- apply RBsDanilo Krummrich (4):
rust: pci: useto_result()inenable_device_mem()
rust: device: implement device context marker
rust: pci: fix unrestricted &mutpci::Device
rust: platform: fix unrestricted &mutplatform::DeviceQuoted 6 lines
rust/kernel/device.rs | 26 +++++ rust/kernel/pci.rs | 137 +++++++++++++++++---------- rust/kernel/platform.rs | 95 +++++++++++++------ samples/rust/rust_driver_pci.rs | 8 +- samples/rust/rust_driver_platform.rs | 11 ++- 5 files changed, 187 insertions(+), 90 deletions(-)Quoted 3 lines
Thanks for doing this work, looks good to me. Mind if I suck it into the driver-core tree now? Or do you want it to go through a different tree?
This series has a conflict with nova-core, it will require the following fixup in -next and Linus' tree when he pulls things.
drivers/gpu/nova-core/driver.rs +1
-1@@ -1,6 +1,6 @@// SPDX-License-Identifier: GPL-2.0 -use kernel::{bindings, c_str, pci, prelude::*}; +use kernel::{bindings, c_str, device::Core , pci, prelude::*};use crate ::gpu::Gpu ;
drivers/gpu/nova-core/driver.rs impl pci::Driver for NovaCore { · line 33
Quoted 8 lines
drivers/gpu/nova-core/driver.rs +1
-1@@ -27,7 +27,7 @@ impl pci::Driver for NovaCore {type IdInfo = ();const ID_TABLE : pci::IdTable <Self ::IdInfo > = &PCI_TABLE ; -fn probe (pdev: &mut pci::Device , _info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>> { +fn probe (pdev: &pci::Device <Core >, _info: &Self ::IdInfo ) ->Result <Pin <KBox <Self >>> {dev_dbg! (pdev.as_ref (),"Probe Nova Core GPU driver.\n" ); pdev.enable_device_mem ()?;
Ok, shouldn't be that hard of a merge issue, thanks for the diff as linux-next should soon hit this as well.
greg k-h