[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-ID: <20250317204310.7804-1-benoit@dugarreau.fr>
Date: Mon, 17 Mar 2025 21:42:51 +0100
From: Benoît du Garreau <benoit@...arreau.fr>
To: Danilo Krummrich <dakr@...nel.org>
Cc: Benoît du Garreau <benoit@...arreau.fr>,
gregkh@...uxfoundation.org,
rafael@...nel.org,
ojeda@...nel.org,
alex.gaynor@...il.com,
boqun.feng@...il.com,
gary@...yguo.net,
bjorn3_gh@...tonmail.com,
benno.lossin@...ton.me,
a.hindborg@...nel.org,
aliceryhl@...gle.com,
tmgross@...ch.edu,
airlied@...il.com,
acourbot@...dia.com,
jhubbard@...dia.com,
linux-kernel@...r.kernel.org,
rust-for-linux@...r.kernel.org
Subject: Re: [PATCH v2 3/4] rust: auxiliary: add auxiliary registration
On Thu, 13 Mar 2025 03:23:52 +0100 Danilo Krummrich <dakr@...nel.org> wrote:
> Implement the `auxiliary::Registration` type, which provides an API to
> create and register new auxiliary devices in the system.
>
> Signed-off-by: Danilo Krummrich <dakr@...nel.org>
> ---
> rust/kernel/auxiliary.rs | 80 +++++++++++++++++++++++++++++++++++++++-
> 1 file changed, 79 insertions(+), 1 deletion(-)
>
> diff --git a/rust/kernel/auxiliary.rs b/rust/kernel/auxiliary.rs
> index e453f821f7cb..fc4bb5388a9b 100644
> --- a/rust/kernel/auxiliary.rs
> +++ b/rust/kernel/auxiliary.rs
> @@ -5,7 +5,7 @@
> //! C header: [`include/linux/auxiliary_bus.h`](srctree/include/linux/auxiliary_bus.h)
>
> use crate::{
> - bindings, device,
> + bindings, container_of, device,
> device_id::RawDeviceId,
> driver,
> error::{to_result, Result},
> @@ -219,6 +219,16 @@ pub fn id(&self) -> u32 {
> // `struct auxiliary_device`.
> unsafe { (*self.as_raw()).id }
> }
> +
> + extern "C" fn release(dev: *mut bindings::device) {
> + // SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device`
> + // embedded in `struct auxiliary_device`.
> + let adev = unsafe { container_of!(dev, bindings::auxiliary_device, dev) }.cast_mut();
> +
> + // SAFETY: `adev` points to the memory that has been allocated in `Registration::new`, via
> + // `KBox::new(Opaque::<bindings::auxiliary_device>::zeroed(), GFP_KERNEL)`.
> + let _ = unsafe { KBox::<Opaque<bindings::auxiliary_device>>::from_raw(adev.cast()) };
> + }
> }
>
> impl Deref for Device<device::Core> {
> @@ -265,3 +275,71 @@ fn as_ref(&self) -> &device::Device {
> unsafe { device::Device::as_ref(dev) }
> }
> }
> +
> +/// The registration of an auxiliary device.
> +///
> +/// This type represents the registration of a [`struct auxiliary_device`]. When an instance of this
> +/// type is dropped, its respective auxiliary device will be unregistered from the system.
> +///
> +/// # Invariants
> +///
> +/// `self.0` always holds a valid pointer to an initialized and registered
> +/// [`struct auxiliary_device`].
> +pub struct Registration(NonNull<bindings::auxiliary_device>);
> +
> +impl Registration {
> + /// Create and register a new auxiliary device.
> + pub fn new(parent: &device::Device, name: &CStr, id: u32, modname: &CStr) -> Result<Self> {
> + let boxed = KBox::new(Opaque::<bindings::auxiliary_device>::zeroed(), GFP_KERNEL)?;
You can use `KBox::init(kernel::init::zeroed(), GFP_KERNEL)` here. It avoids
the need for the first patch.
> + let adev = boxed.get();
> +
> + // SAFETY: It's safe to set the fields of `struct auxiliary_device` on initialization.
> + unsafe {
> + (*adev).dev.parent = parent.as_raw();
> + (*adev).dev.release = Some(Device::release);
> + (*adev).name = name.as_char_ptr();
> + (*adev).id = id;
> + }
> +
> + // SAFETY: `adev` is guaranteed to be a valid pointer to a `struct auxiliary_device`,
> + // which has not been initialized yet.
> + unsafe { bindings::auxiliary_device_init(adev) };
> +
> + // Now that `adev` is initialized, leak the `Box`; the corresponding memory will be freed
> + // by `Device::release` when the last reference to the `struct auxiliary_device` is dropped.
> + let _ = KBox::into_raw(boxed);
> +
> + // SAFETY:
> + // - `adev` is guaranteed to be a valid pointer to a `struct auxiliary_device`, which has
> + // been initialialized,
> + // - `modname.as_char_ptr()` is a NULL terminated string.
> + let ret = unsafe { bindings::__auxiliary_device_add(adev, modname.as_char_ptr()) };
> + if ret != 0 {
> + // SAFETY: `adev` is guaranteed to be a valid pointer to a `struct auxiliary_device`,
> + // which has been initialialized.
> + unsafe { bindings::auxiliary_device_uninit(adev) };
> +
> + return Err(Error::from_errno(ret));
> + }
> +
> + // SAFETY: `adev` is guaranteed to be non-null, since the `KBox` was allocated successfully.
> + //
> + // INVARIANT: The device will remain registered until `auxiliary_device_delete()` is called,
> + // which happens in `Self::drop()`.
> + Ok(Self(unsafe { NonNull::new_unchecked(adev) }))
> + }
> +}
> +
> +impl Drop for Registration {
> + fn drop(&mut self) {
> + // SAFETY: By the type invariant of `Self`, `self.0.as_ptr()` is a valid registered
> + // `struct auxiliary_device`.
> + unsafe { bindings::auxiliary_device_delete(self.0.as_ptr()) };
> +
> + // This drops the reference we acquired through `auxiliary_device_init()`.
> + //
> + // SAFETY: By the type invariant of `Self`, `self.0.as_ptr()` is a valid registered
> + // `struct auxiliary_device`.
> + unsafe { bindings::auxiliary_device_uninit(self.0.as_ptr()) };
> + }
> +}
> --
> 2.48.1
>
>
Benoît du Garreau
Powered by blists - more mailing lists