The following has been changed: - introduce mutex to C serdev tty port controller - introduce a new C serdev API to fix race conditions and simplify rust code. Should also be useful on the C side. - fix race conditions - simplify rust code
Signed-off-by: Markus Probst markus.probst@posteo.de --- Changes in v6: - fix issues reported by Sashiko: - fix compile error on 3. patch - rebase onto v7.4-rc2 - use dev_WARN instead of WARN_ON (WARN intentionally kept) - Link to v5: https://patch.msgid.link/20261022-rust_serdev_probe_refactor-v5-0-a27d862a41...
Changes in v5: - fix issues reported by Sashiko: - fix access to serport->tty outside of locked mutex - only lock receive_lock in ttyport_open for set_bit - Link to v4: https://patch.msgid.link/20261016-rust_serdev_probe_refactor-v4-0-46832e0347...
Changes in v4: - fix issues reported by Sashiko: - add receive_lock to prevent deadlocks - Link to v3: https://patch.msgid.link/20260930-rust_serdev_probe_refactor-v3-0-d1b6e77135...
Changes in v3: - add mutex - Link to v2: https://patch.msgid.link/20260920-rust_serdev_probe_refactor-v2-0-43b855162f...
Changes in v2: - fix missing memory barriers in serdev apis - use `tty_buffer_restart_work` instead of `tty_flip_buffer_push` - use `tty_buffer_flush_work` instead of exclusively locking the mutex - add `#[inline]` to `PrivateData::driver_data` - remove patches for mutable references - Link to v1: https://patch.msgid.link/20260906-rust_serdev_probe_refactor-v1-0-69cdae0074...
--- Markus Probst (4): tty: serdev: Add mutex lock tty: serdev: Export functions to pause receive_buf callback calls rust: serdev: Replace `active` mutex with receive pause rust: serdev: Simplify callbacks
drivers/tty/serdev/core.c | 56 +++++++++++- drivers/tty/serdev/serdev-ttyport.c | 80 +++++++++++++++-- include/linux/serdev.h | 8 +- rust/kernel/serdev.rs | 167 ++++++++++++------------------------ 4 files changed, 186 insertions(+), 125 deletions(-) --- base-commit: fd9230005e85472b81c1c7c16afe93dd878996b1 change-id: 20260905-rust_serdev_probe_refactor-0e2b044354a7
Besides more predictable behaviour, this allows for several hardened behaviour changes:
Return -EALREADY in `serdev_device_open` if the device is already open instead of causing undefined behaviour.
Allow calling `serdev_device_close`, even if the device is already closed instead of causing a null pointer dereference.
If the device is left open by the driver after remove, close it and warn instead of leaving it in a invalid state.
Signed-off-by: Markus Probst markus.probst@posteo.de --- drivers/tty/serdev/core.c | 12 +++++++--- drivers/tty/serdev/serdev-ttyport.c | 44 +++++++++++++++++++++++++++++++------ include/linux/serdev.h | 2 +- 3 files changed, 47 insertions(+), 11 deletions(-)
diff --git a/drivers/tty/serdev/core.c b/drivers/tty/serdev/core.c index 7500efcdfc21..86d9cf8215ed 100644 --- a/drivers/tty/serdev/core.c +++ b/drivers/tty/serdev/core.c @@ -142,6 +142,13 @@ void serdev_device_remove(struct serdev_device *serdev) struct serdev_controller *ctrl = serdev->ctrl;
device_unregister(&serdev->dev); + + /* Warn if driver did not close the serial device. */ + if (ctrl->ops->close && ctrl->ops->close(ctrl)) { + dev_WARN(&ctrl->dev, "Child driver did not close the serial device"); + pm_runtime_put(&ctrl->dev); + } + ctrl->serdev = NULL; } EXPORT_SYMBOL_GPL(serdev_device_remove); @@ -181,9 +188,8 @@ void serdev_device_close(struct serdev_device *serdev) if (!ctrl || !ctrl->ops->close) return;
- pm_runtime_put(&ctrl->dev); - - ctrl->ops->close(ctrl); + if (ctrl->ops->close(ctrl)) + pm_runtime_put(&ctrl->dev); } EXPORT_SYMBOL_GPL(serdev_device_close);
diff --git a/drivers/tty/serdev/serdev-ttyport.c b/drivers/tty/serdev/serdev-ttyport.c index b6638f9f40d2..17c18d4b0cb8 100644 --- a/drivers/tty/serdev/serdev-ttyport.c +++ b/drivers/tty/serdev/serdev-ttyport.c @@ -16,6 +16,8 @@ struct serport { struct tty_driver *tty_drv; int tty_idx; unsigned long flags; + struct mutex lock; /* lock preventing modification of flags */ + struct mutex receive_lock; /* lock preventing execution of serdev_controller_receive_buf */ };
/* @@ -29,6 +31,8 @@ static size_t ttyport_receive_buf(struct tty_port *port, const u8 *cp, struct serport *serport = serdev_controller_get_drvdata(ctrl); size_t ret;
+ guard(mutex)(&serport->receive_lock); + if (!test_bit(SERPORT_ACTIVE, &serport->flags)) return 0;
@@ -99,14 +103,23 @@ static int ttyport_open(struct serdev_controller *ctrl) struct ktermios ktermios; int ret;
+ mutex_lock(&serport->lock); + + if (test_bit(SERPORT_ACTIVE, &serport->flags)) { + ret = -EALREADY; + goto err_flags_unlock; + } + tty = tty_init_dev(serport->tty_drv, serport->tty_idx); - if (IS_ERR(tty)) - return PTR_ERR(tty); + if (IS_ERR(tty)) { + ret = PTR_ERR(tty); + goto err_flags_unlock; + } serport->tty = tty;
if (!tty->ops->open || !tty->ops->close) { ret = -ENODEV; - goto err_unlock; + goto err_tty_unlock; }
ret = tty->ops->open(serport->tty, NULL); @@ -128,26 +141,38 @@ static int ttyport_open(struct serdev_controller *ctrl) ktermios.c_cflag |= CLOCAL; tty_set_termios(tty, &ktermios);
+ mutex_lock(&serport->receive_lock); set_bit(SERPORT_ACTIVE, &serport->flags); + mutex_unlock(&serport->receive_lock); + + mutex_unlock(&serport->lock);
return 0;
err_close: tty->ops->close(tty, NULL); -err_unlock: +err_tty_unlock: tty_unlock(tty); tty_release_struct(tty, serport->tty_idx); serport->tty = NULL; +err_flags_unlock: + mutex_unlock(&serport->lock);
return ret; }
-static void ttyport_close(struct serdev_controller *ctrl) +static bool ttyport_close(struct serdev_controller *ctrl) { struct serport *serport = serdev_controller_get_drvdata(ctrl); - struct tty_struct *tty = serport->tty; + struct tty_struct *tty; + + guard(mutex)(&serport->lock);
- clear_bit(SERPORT_ACTIVE, &serport->flags); + tty = serport->tty; + + scoped_guard(mutex, &serport->receive_lock) + if (!__test_and_clear_bit(SERPORT_ACTIVE, &serport->flags)) + return false;
tty_lock(tty); if (tty->ops->close) @@ -156,6 +181,8 @@ static void ttyport_close(struct serdev_controller *ctrl)
tty_release_struct(tty, serport->tty_idx); serport->tty = NULL; + + return true; }
static unsigned int ttyport_set_baudrate(struct serdev_controller *ctrl, unsigned int speed) @@ -290,6 +317,9 @@ struct device *serdev_tty_port_register(struct tty_port *port, port->client_ops = &client_ops; port->client_data = ctrl;
+ mutex_init(&serport->lock); + mutex_init(&serport->receive_lock); + ret = serdev_controller_add(ctrl); if (ret) goto err_reset_data; diff --git a/include/linux/serdev.h b/include/linux/serdev.h index b6c3d957ec15..0f4e81c0950d 100644 --- a/include/linux/serdev.h +++ b/include/linux/serdev.h @@ -81,7 +81,7 @@ struct serdev_controller_ops { ssize_t (*write_buf)(struct serdev_controller *, const u8 *, size_t); void (*write_flush)(struct serdev_controller *); int (*open)(struct serdev_controller *); - void (*close)(struct serdev_controller *); + bool (*close)(struct serdev_controller *); void (*set_flow_control)(struct serdev_controller *, bool); int (*set_parity)(struct serdev_controller *, enum serdev_parity); unsigned int (*set_baudrate)(struct serdev_controller *, unsigned int);
These functions will be used to simply the serdev rust abstraction. It also contributes to the fixing of 2 race conditions in the serdev rust abstraction.
Signed-off-by: Markus Probst markus.probst@posteo.de --- drivers/tty/serdev/core.c | 44 ++++++++++++++++++++++++++++++++++++- drivers/tty/serdev/serdev-ttyport.c | 36 ++++++++++++++++++++++++++++++ include/linux/serdev.h | 6 +++++ 3 files changed, 85 insertions(+), 1 deletion(-)
diff --git a/drivers/tty/serdev/core.c b/drivers/tty/serdev/core.c index 86d9cf8215ed..ca20304c7b20 100644 --- a/drivers/tty/serdev/core.c +++ b/drivers/tty/serdev/core.c @@ -193,6 +193,45 @@ void serdev_device_close(struct serdev_device *serdev) } EXPORT_SYMBOL_GPL(serdev_device_close);
+/** + * serdev_device_pause_rx() - pause data receive + * @serdev: serdev device + * + * Pause calls to receive_buf. + * + * Note that if a call to receive_buf is currently executed, the function will + * sleep until it has finished. + */ +void serdev_device_pause_rx(struct serdev_device *serdev) +{ + struct serdev_controller *ctrl = serdev->ctrl; + + if (!ctrl || !ctrl->ops->pause_rx) + return; + + ctrl->ops->pause_rx(ctrl); +} +EXPORT_SYMBOL_GPL(serdev_device_pause_rx); + +/** + * serdev_device_resume_rx() - resume data receive + * @serdev: serdev device + * + * Resume calls to receive_buf. + * + * This can be called even if not paused to ensure data receive is active. + */ +void serdev_device_resume_rx(struct serdev_device *serdev) +{ + struct serdev_controller *ctrl = serdev->ctrl; + + if (!ctrl || !ctrl->ops->resume_rx) + return; + + ctrl->ops->resume_rx(ctrl); +} +EXPORT_SYMBOL_GPL(serdev_device_resume_rx); + static void devm_serdev_device_close(void *serdev) { serdev_device_close(serdev); @@ -404,6 +443,7 @@ EXPORT_SYMBOL_GPL(serdev_device_break_ctl); static int serdev_drv_probe(struct device *dev) { const struct serdev_device_driver *sdrv = to_serdev_device_driver(dev->driver); + struct serdev_device *sdev = to_serdev_device(dev); int ret;
ret = dev_pm_domain_attach(dev, PD_FLAG_ATTACH_POWER_ON | @@ -411,7 +451,9 @@ static int serdev_drv_probe(struct device *dev) if (ret) return ret;
- return sdrv->probe(to_serdev_device(dev)); + serdev_device_resume_rx(sdev); + + return sdrv->probe(sdev); }
static void serdev_drv_remove(struct device *dev) diff --git a/drivers/tty/serdev/serdev-ttyport.c b/drivers/tty/serdev/serdev-ttyport.c index 17c18d4b0cb8..6e1134976996 100644 --- a/drivers/tty/serdev/serdev-ttyport.c +++ b/drivers/tty/serdev/serdev-ttyport.c @@ -7,8 +7,10 @@ #include <linux/tty.h> #include <linux/tty_driver.h> #include <linux/poll.h> +#include "../tty.h"
#define SERPORT_ACTIVE 1 +#define SERPORT_PAUSE_RX 2
struct serport { struct tty_port *port; @@ -36,6 +38,9 @@ static size_t ttyport_receive_buf(struct tty_port *port, const u8 *cp, if (!test_bit(SERPORT_ACTIVE, &serport->flags)) return 0;
+ if (test_bit(SERPORT_PAUSE_RX, &serport->flags)) + return 0; + ret = serdev_controller_receive_buf(ctrl, cp, count);
dev_WARN_ONCE(&ctrl->dev, ret > count, @@ -185,6 +190,35 @@ static bool ttyport_close(struct serdev_controller *ctrl) return true; }
+static void ttyport_pause_rx(struct serdev_controller *ctrl) +{ + struct serport *serport = serdev_controller_get_drvdata(ctrl); + + guard(mutex)(&serport->lock); + + scoped_guard(mutex, &serport->receive_lock) + set_bit(SERPORT_PAUSE_RX, &serport->flags); + + if (test_bit(SERPORT_ACTIVE, &serport->flags)) + tty_buffer_cancel_work(serport->tty->port); +} + +static void ttyport_resume_rx(struct serdev_controller *ctrl) +{ + struct serport *serport = serdev_controller_get_drvdata(ctrl); + + guard(mutex)(&serport->lock); + + if (!test_bit(SERPORT_PAUSE_RX, &serport->flags)) + return; + + scoped_guard(mutex, &serport->receive_lock) + clear_bit(SERPORT_PAUSE_RX, &serport->flags); + + if (test_bit(SERPORT_ACTIVE, &serport->flags)) + tty_buffer_restart_work(serport->tty->port); +} + static unsigned int ttyport_set_baudrate(struct serdev_controller *ctrl, unsigned int speed) { struct serport *serport = serdev_controller_get_drvdata(ctrl); @@ -289,6 +323,8 @@ static const struct serdev_controller_ops ctrl_ops = { .get_tiocm = ttyport_get_tiocm, .set_tiocm = ttyport_set_tiocm, .break_ctl = ttyport_break_ctl, + .pause_rx = ttyport_pause_rx, + .resume_rx = ttyport_resume_rx, };
struct device *serdev_tty_port_register(struct tty_port *port, diff --git a/include/linux/serdev.h b/include/linux/serdev.h index 0f4e81c0950d..02773554e759 100644 --- a/include/linux/serdev.h +++ b/include/linux/serdev.h @@ -89,6 +89,8 @@ struct serdev_controller_ops { int (*get_tiocm)(struct serdev_controller *); int (*set_tiocm)(struct serdev_controller *, unsigned int, unsigned int); int (*break_ctl)(struct serdev_controller *ctrl, unsigned int break_state); + void (*pause_rx)(struct serdev_controller *ctrl); + void (*resume_rx)(struct serdev_controller *ctrl); };
/** @@ -194,6 +196,8 @@ static inline size_t serdev_controller_receive_buf(struct serdev_controller *ctr int serdev_device_open(struct serdev_device *); void serdev_device_close(struct serdev_device *); int devm_serdev_device_open(struct device *, struct serdev_device *); +void serdev_device_pause_rx(struct serdev_device *serdev); +void serdev_device_resume_rx(struct serdev_device *serdev); unsigned int serdev_device_set_baudrate(struct serdev_device *, unsigned int); void serdev_device_set_flow_control(struct serdev_device *, bool); int serdev_device_write_buf(struct serdev_device *, const u8 *, size_t); @@ -233,6 +237,8 @@ static inline int serdev_device_open(struct serdev_device *sdev) return -ENODEV; } static inline void serdev_device_close(struct serdev_device *sdev) {} +static inline void serdev_device_pause_rx(struct serdev_device *serdev) {} +static inline void serdev_device_resume_rx(struct serdev_device *serdev) {} static inline unsigned int serdev_device_set_baudrate(struct serdev_device *sdev, unsigned int baudrate) { return 0;
There are currently 2 race conditions: - in probe if `Driver::probe` returns Err - in unbind . In those cases the driver data will be set to NULL before the serdev device was closed. If data is received while the driver data is dropped, the `receive_buf_callback` might try to access the `active` mutex on a null pointer.
Removing the need for `receive_buf_callback` to lock the `active` mutex fixes these.
Fixes: 99f59aa82341 ("rust: add basic serial device bus abstractions") Reported-by: Sashiko Bot sashiko-bot@kernel.org Closes: https://lore.kernel.org/linux-serial/20260905000836.C8FC91F00A3D@smtp.kernel... Closes: https://lore.kernel.org/linux-serial/20260903222159.70A911F000E9@smtp.kernel... Signed-off-by: Markus Probst markus.probst@posteo.de --- rust/kernel/serdev.rs | 63 ++++++++++++++------------------------------------- 1 file changed, 17 insertions(+), 46 deletions(-)
diff --git a/rust/kernel/serdev.rs b/rust/kernel/serdev.rs index 17ca504b7f8d..559d142ce557 100644 --- a/rust/kernel/serdev.rs +++ b/rust/kernel/serdev.rs @@ -13,13 +13,9 @@ to_result, VTABLE_DEFAULT_ERROR, // }, - new_mutex, of, prelude::*, - sync::{ - aref::AlwaysRefCounted, - Mutex, // - }, + sync::aref::AlwaysRefCounted, time::Jiffies, types::{ Opaque, @@ -103,40 +99,11 @@ pub struct PrivateData<'bound, T: Driver> { #[pin] driver: UnsafeCell<MaybeUninit<T::Data<'bound>>>, open: UnsafeCell<bool>, - /// Whether `receive_buf_callback` is allowed to call `Driver::receive`. - /// - /// If locked, the receive_buf_callback will be blocked on data reception. - /// This is the case while the driver is being probed or while [`PrivateData`] is being dropped. - /// This is necessary, because we need to open the serdev device before the driver has been - /// probed in order to allow it to be configured, which allows `receive_buf_callback` to be - /// called. Thus we need to block data until probe completes and the driver data becomes - /// initialized. - /// - /// If unlocked and true, the receive_buf_callback will forward the data to - /// `Driver::receive`. This is the normal state of operation. - /// - /// If unlocked and false, the receive_buf_callback will throw away the data. - /// This is only the case, if the serdev device is open and - /// - the driver returned an error in probe - /// or - /// - the driver data already has been dropped, because it was unbound. - #[pin] - active: Mutex<bool>, }
#[pinned_drop] impl<T: Driver> PinnedDrop for PrivateData<'_, T> { fn drop(self: Pin<&mut Self>) { - let mut active = self.active.lock(); - if *active { - // SAFETY: - // - We have exclusive access to `self.driver`. - // - `self.driver` is guaranteed to be initialized. - unsafe { (*self.driver.get()).assume_init_drop() }; - *active = false; - } - drop(active); - // SAFETY: We have exclusive access to `self.open`. if unsafe { *self.open.get() } { // SAFETY: `self.sdev.as_raw()` is guaranteed to be a pointer to a valid @@ -170,7 +137,6 @@ extern "C" fn probe_callback(sdev: *mut bindings::serdev_device) -> kernel::ffi: sdev: &**sdev, driver: MaybeUninit::<T::Data<'_>>::zeroed().into(), open: false.into(), - active <- new_mutex!(false), }))?; // SAFETY: We just set drvdata to `PrivateData<'_, T>`. let private_data = unsafe { sdev.as_ref().drvdata_borrow::<PrivateData<'_, T>>() }; @@ -178,11 +144,12 @@ extern "C" fn probe_callback(sdev: *mut bindings::serdev_device) -> kernel::ffi: // SAFETY: We just set drvdata to `PrivateData<'_, T>`. drop(unsafe { sdev.as_ref().drvdata_obtain::<PrivateData<'_, T>>() }); }); - let mut active = private_data.active.lock(); - // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. unsafe { bindings::serdev_device_set_client_ops(sdev.as_raw(), Self::OPS) };
+ // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. + unsafe { bindings::serdev_device_pause_rx(sdev.as_raw()) }; + // SAFETY: The serial device bus only ever calls the probe callback with a valid pointer // to a `serdev_device`. to_result(unsafe { bindings::serdev_device_open(sdev.as_raw()) })?; @@ -199,12 +166,12 @@ extern "C" fn probe_callback(sdev: *mut bindings::serdev_device) -> kernel::ffi: // - `private_data.driver` is pinned. let result = unsafe { pin_init::raw_try_init(driver.as_mut_ptr(), data) };
- *active = result.is_ok(); - - drop(active); - result.map(|()| { private_data.dismiss(); + + // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. + unsafe { bindings::serdev_device_resume_rx(sdev.as_raw()) }; + 0 }) }) @@ -231,6 +198,15 @@ extern "C" fn remove_callback(sdev: *mut bindings::serdev_device) { let data_pinned = unsafe { Pin::new_unchecked(data.assume_init_ref()) };
T::unbind(sdev, data_pinned); + + // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. + unsafe { bindings::serdev_device_pause_rx(sdev.as_raw()) }; + + // SAFETY: We have exclusive access to `private_data.driver`. + let data = unsafe { &mut *private_data.driver.get() }; + + // SAFETY: We already established that `data` is guaranteed to be initialized. + unsafe { data.assume_init_drop() }; }
extern "C" fn receive_buf_callback( @@ -248,11 +224,6 @@ extern "C" fn receive_buf_callback( // `probe_callback`, hence it's guaranteed that `Device::set_drvdata()` has been called // and stored a `Pin<KBox<PrivateData<'_, T>>>`. let private_data = unsafe { sdev.as_ref().drvdata_borrow::<PrivateData<'_, T>>() }; - let active = private_data.active.lock(); - - if !*active { - return length; - }
// SAFETY: No one has exclusive access to `private_data.driver`. let data = unsafe { &*private_data.driver.get() };
Initialize the driver's private data directly on `PrivateData`.
Introduce `OpenGuard` for resource cleanup.
Signed-off-by: Markus Probst markus.probst@posteo.de --- rust/kernel/serdev.rs | 134 ++++++++++++++++++++------------------------------ 1 file changed, 52 insertions(+), 82 deletions(-)
diff --git a/rust/kernel/serdev.rs b/rust/kernel/serdev.rs index 559d142ce557..3f9165e16776 100644 --- a/rust/kernel/serdev.rs +++ b/rust/kernel/serdev.rs @@ -17,16 +17,12 @@ prelude::*, sync::aref::AlwaysRefCounted, time::Jiffies, - types::{ - Opaque, - ScopeGuard, // - }, // + types::Opaque, // };
use core::{ - cell::UnsafeCell, marker::PhantomData, - mem::{offset_of, MaybeUninit}, + mem::offset_of, ptr::NonNull, // };
@@ -92,24 +88,36 @@ unsafe fn unregister(sdrv: &OpaqueSelf::DriverType) { } }
+struct OpenGuard<'bound> { + sdev: &'bound Devicedevice::Bound, +} + +impl Drop for OpenGuard<'_> { + fn drop(&mut self) { + // SAFETY: + // - `self.sdev.as_raw()` is guaranteed to be a pointer to a valid + // `struct serdev_device`. + // - The existence of self proves that the device is open. + unsafe { bindings::serdev_device_close(self.sdev.as_raw()) }; + } +} + #[doc(hidden)] -#[pin_data(PinnedDrop)] +#[pin_data] pub struct PrivateData<'bound, T: Driver> { - sdev: &'bound Devicedevice::Bound, #[pin] - driver: UnsafeCell<MaybeUninit<T::Data<'bound>>>, - open: UnsafeCell<bool>, + driver: T::Data<'bound>, + open: OpenGuard<'bound>, }
-#[pinned_drop] -impl<T: Driver> PinnedDrop for PrivateData<'_, T> { - fn drop(self: Pin<&mut Self>) { - // SAFETY: We have exclusive access to `self.open`. - if unsafe { *self.open.get() } { - // SAFETY: `self.sdev.as_raw()` is guaranteed to be a pointer to a valid - // `struct serdev_device`. - unsafe { bindings::serdev_device_close(self.sdev.as_raw()) }; - } +impl<'bound, T: Driver> PrivateData<'bound, T> { + #[inline] + fn driver_data(self: Pin<&Self>) -> Pin<&T::Data<'bound>> { + // SAFETY: We treat the result as pinned. + let inner = unsafe { Pin::into_inner_unchecked(self) }; + + // SAFETY: `self.driver` is pinned. + unsafe { Pin::new_unchecked(&inner.driver) } } }
@@ -134,46 +142,30 @@ extern "C" fn probe_callback(sdev: *mut bindings::serdev_device) -> kernel::ffi:
from_result(|| { sdev.as_ref().set_drvdata(try_pin_init!(PrivateData::<T> { - sdev: &**sdev, - driver: MaybeUninit::<T::Data<'_>>::zeroed().into(), - open: false.into(), + open: { + // SAFETY: + // - `sdev.as_raw()` is guaranteed to be a valid pointer to + // `serdev_device`. + // - It is safe to call before open. + unsafe { bindings::serdev_device_set_client_ops(sdev.as_raw(), Self::OPS) }; + + // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to + // `serdev_device`. + unsafe { bindings::serdev_device_pause_rx(sdev.as_raw()) }; + + // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to + // `serdev_device`. + to_result(unsafe { bindings::serdev_device_open(sdev.as_raw()) })?; + + OpenGuard { sdev } + }, + driver <- T::probe(sdev, info), }))?; - // SAFETY: We just set drvdata to `PrivateData<'_, T>`. - let private_data = unsafe { sdev.as_ref().drvdata_borrow::<PrivateData<'_, T>>() }; - let private_data = ScopeGuard::new_with_data(private_data, |_| { - // SAFETY: We just set drvdata to `PrivateData<'_, T>`. - drop(unsafe { sdev.as_ref().drvdata_obtain::<PrivateData<'_, T>>() }); - }); - // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. - unsafe { bindings::serdev_device_set_client_ops(sdev.as_raw(), Self::OPS) };
// SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. - unsafe { bindings::serdev_device_pause_rx(sdev.as_raw()) }; - - // SAFETY: The serial device bus only ever calls the probe callback with a valid pointer - // to a `serdev_device`. - to_result(unsafe { bindings::serdev_device_open(sdev.as_raw()) })?; - - // SAFETY: We have exclusive access to `private_data.open`. - unsafe { *private_data.open.get() = true }; - - let data = T::probe(sdev, info); + unsafe { bindings::serdev_device_resume_rx(sdev.as_raw()) };
- // SAFETY: We have exclusive access to `private_data.driver`. - let driver = unsafe { &mut *private_data.driver.get() }; - // SAFETY: - // - `driver.as_mut_ptr()` is a valid pointer to uninitialized data. - // - `private_data.driver` is pinned. - let result = unsafe { pin_init::raw_try_init(driver.as_mut_ptr(), data) }; - - result.map(|()| { - private_data.dismiss(); - - // SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. - unsafe { bindings::serdev_device_resume_rx(sdev.as_raw()) }; - - 0 - }) + Ok(0) }) }
@@ -189,24 +181,10 @@ extern "C" fn remove_callback(sdev: *mut bindings::serdev_device) { // and stored a `Pin<KBox<PrivateData<'_, T>>>`. let private_data = unsafe { sdev.as_ref().drvdata_borrow::<PrivateData<'_, T>>() };
- // SAFETY: No one has exclusive access to `private_data.driver`. - let data = unsafe { &*private_data.driver.get() }; - // SAFETY: - // - `private_data.driver` is pinned. - // - `remove_callback` is only ever called after a successful call to `probe_callback`, - // hence it's guaranteed that `private_data.driver` was initialized. - let data_pinned = unsafe { Pin::new_unchecked(data.assume_init_ref()) }; - - T::unbind(sdev, data_pinned); + T::unbind(sdev, private_data.driver_data());
// SAFETY: `sdev.as_raw()` is guaranteed to be a valid pointer to `serdev_device`. unsafe { bindings::serdev_device_pause_rx(sdev.as_raw()) }; - - // SAFETY: We have exclusive access to `private_data.driver`. - let data = unsafe { &mut *private_data.driver.get() }; - - // SAFETY: We already established that `data` is guaranteed to be initialized. - unsafe { data.assume_init_drop() }; }
extern "C" fn receive_buf_callback( @@ -214,6 +192,9 @@ extern "C" fn receive_buf_callback( buf: *const u8, length: usize, ) -> usize { + // SAFETY: `buf` is guaranteed to be non-null and has the size of `length`. + let buf = unsafe { core::slice::from_raw_parts(buf, length) }; + // SAFETY: The serial device bus only ever calls the receive buf callback with a valid // pointer to a `struct serdev_device`. // @@ -225,18 +206,7 @@ extern "C" fn receive_buf_callback( // and stored a `Pin<KBox<PrivateData<'_, T>>>`. let private_data = unsafe { sdev.as_ref().drvdata_borrow::<PrivateData<'_, T>>() };
- // SAFETY: No one has exclusive access to `private_data.driver`. - let data = unsafe { &*private_data.driver.get() }; - // SAFETY: - // - `private_data.driver` is pinned. - // - `receive_buf_callback` is only ever called after a successful call to `probe_callback`, - // hence it's guaranteed that `private_data.driver` was initialized. - let data_pinned = unsafe { Pin::new_unchecked(data.assume_init_ref()) }; - - // SAFETY: `buf` is guaranteed to be non-null and has the size of `length`. - let buf = unsafe { core::slice::from_raw_parts(buf, length) }; - - T::receive(sdev, data_pinned, buf) + T::receive(sdev, private_data.driver_data(), buf) } }