archive/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2025-08-15 14:11:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

rust: auxiliary: use generic device drvdata accessors

Browse source 
Take advantage of the generic drvdata accessors of the generic Device
type.

While at it, use from_result() instead of match.

Link: https://lore.kernel.org/r/20250621195118.124245-6-dakr@kernel.org
Signed-off-by: Danilo Krummrich <dakr@kernel.org>
This commit is contained in:
Danilo Krummrich 2025-06-21 21:43:31 +02:00
parent 4231712c8e
commit c46f60246f
2 changed files with 15 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

10
rust/helpers/auxiliary.c
View file

@ -2,16 +2,6 @@
#include <linux/auxiliary_bus.h>
void rust_helper_auxiliary_set_drvdata(struct auxiliary_device *adev, void *data)
{
auxiliary_set_drvdata(adev, data);
}
void *rust_helper_auxiliary_get_drvdata(struct auxiliary_device *adev)
{
return auxiliary_get_drvdata(adev);
}
void rust_helper_auxiliary_device_uninit(struct auxiliary_device *adev)
{
return auxiliary_device_uninit(adev);

35
rust/kernel/auxiliary.rs
View file

@ -8,9 +8,9 @@ use crate::{
bindings, container_of, device,
device_id::RawDeviceId,
driver,
error::{to_result, Result},
error::{from_result, to_result, Result},
prelude::*,
types::{ForeignOwnable, Opaque},
types::Opaque,
ThisModule,
};
use core::{
@ -60,37 +60,32 @@ impl<T: Driver + 'static> Adapter<T> {
// `struct auxiliary_device`.
//
// INVARIANT: `adev` is valid for the duration of `probe_callback()`.
let adev = unsafe { &*adev.cast::<Device<device::Core>>() };
let adev = unsafe { &*adev.cast::<Device<device::CoreInternal>>() };
// SAFETY: `DeviceId` is a `#[repr(transparent)`] wrapper of `struct auxiliary_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(adev, info) {
Ok(data) => {
// Let the `struct auxiliary_device` own a reference of the driver's private data.
// SAFETY: By the type invariant `adev.as_raw` returns a valid pointer to a
// `struct auxiliary_device`.
unsafe {
bindings::auxiliary_set_drvdata(adev.as_raw(), data.into_foreign().cast())
};
}
Err(err) => return Error::to_errno(err),
}
from_result(|| {
let data = T::probe(adev, info)?;
0
adev.as_ref().set_drvdata(data);
Ok(0)
})
}
extern "C" fn remove_callback(adev: *mut bindings::auxiliary_device) {
// SAFETY: The auxiliary bus only ever calls the remove callback with a valid pointer to a
// SAFETY: The auxiliary bus only ever calls the probe callback with a valid pointer to a
// `struct auxiliary_device`.
let ptr = unsafe { bindings::auxiliary_get_drvdata(adev) };
//
// INVARIANT: `adev` is valid for the duration of `probe_callback()`.
let adev = unsafe { &*adev.cast::<Device<device::CoreInternal>>() };
// SAFETY: `remove_callback` is only ever called after a successful call to
// `probe_callback`, hence it's guaranteed that `ptr` points to a valid and initialized
// `KBox<T>` pointer created through `KBox::into_foreign`.
drop(unsafe { KBox::<T>::from_foreign(ptr.cast()) });
// `probe_callback`, hence it's guaranteed that `Device::set_drvdata()` has been called
// and stored a `Pin<KBox<T>>`.
drop(unsafe { adev.as_ref().drvdata_obtain::<Pin<KBox<T>>>() });
}
}