rust: add basic serial device bus abstractions
Subsystems (4)
Markus Probst
maintainerv16 cover rust: add basic serial device bus abstractions
This patch series adds the serdev device bus rust abstraction into the kernel.
This abstraction will be used by a driver, which targets the MCU devices in Synology devices.
Kari Argillander also messaged me, stating that he wants to write a watchdog driver with this abstraction (needing initial device data).
This series depends on [1].
[1] https://lore.kernel.org/rust-for-linux/[email protected]/
---
Changes in v16:
- use Jiffies instead of impl Into<Jiffies>, until Jiffies is a newtype
- Link to v15: https://patch.msgid.link/[email protected]
Changes in v15:
- fix documentation typo
- add documentation for PrivateData::active
- adding missing #[inline] attributes
- replace serdev::Timeout with the use of impl Into<Jiffies>
- This replaces https://lore.kernel.org/rust-for-linux/[email protected]/
- Link to v14: https://patch.msgid.link/[email protected]
Changes in v14:
- fix issues reported by Sashiko:
- fix missing Sync
- fix write buffers allowed with data.len() > i32::MAX
- fix sample driver possibly stalling on full tx buffer
- Link to v13: https://patch.msgid.link/[email protected]
Changes in v13:
- Added Acked-by trailer from Rob. Consider this a RESEND.
- Link to v12: https://patch.msgid.link/[email protected]
Changes in v12:
- fix CoreInternal instead of BoundInternal
- Link to v11: https://patch.msgid.link/[email protected]
Changes in v11:
- redo changes from v9 with the following fixes:
- fix memory leak on probe failure
- fix possible access of dropped drvdata from receive_buf
- Link to v10: https://patch.msgid.link/[email protected]
Changes in v10:
- revert everything from v9, except BoundInternal
- use mutex to ensure receive_buf won't be called on a dropped drvdata.
- Link to v9: https://patch.msgid.link/[email protected]
Changes in v9:
- make use of BoundInternal
- use PrivateData wrapper and drop rust_private_data field
- use non-devm version of serdev_device_open
- Link to v8: https://patch.msgid.link/[email protected]
Changes in v8:
- adapted to driver-lifetime v5 patch series
- add MAINTAINERS file patch
- Link to v7: https://patch.msgid.link/[email protected]
Changes in v7:
- adapted to driver-lifetime patch series
- Link to v6: https://patch.msgid.link/[email protected]
Changes in v6:
- rebased onto v7.1-rc1
- Link to v5: https://patch.msgid.link/[email protected]
Changes in v5:
- fix typo in documentation
- Link to v4: https://lore.kernel.org/r/[email protected]
Changes in v4:
- fixed not selecting rust serdev abstraction in sample
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- fix vertical import style
- add Kconfig entry for the rust abstraction
- fix documentation in include/linux/serdev.h
- rename private_data to rust_private_data
- fix complete_all <-> wait_for_completion typo
- move drvdata_borrow call after the completion
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- fix documentation in serdev::Driver::write and serdev::Driver::write_all
- remove use of dev_info in probe from the sample
- remove properties_parse from the sample
- add optional baudrate property to the sample
- remove 1. patch
- remove TryFrom<&device::Device<Ctx>> for &serdev::Device<Ctx> implementation
- fix import style
- add patch to return reference in devres::register to fix safety
issue
- add patch to add private data to serdev_device, to fix Device.drvdata() from failing
- simplify abstraction by removing ability to receive the initial transmission. It may be added later in a separate patch series if needed.
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Markus Probst (3):
rust: add basic serial device bus abstractions
samples: rust: add Rust serial device bus sample device driver
MAINTAINERS: serdev: Add self for serdev
MAINTAINERS | 5 +- drivers/tty/serdev/Kconfig | 7 + rust/bindings/bindings_helper.h | 1 + rust/helpers/helpers.c | 1 + rust/helpers/serdev.c | 22 ++ rust/kernel/lib.rs | 2 + rust/kernel/serdev.rs | 605 +++++++++++++++++++++++++++++++++++++ samples/rust/Kconfig | 11 + samples/rust/Makefile | 1 + samples/rust/rust_driver_serdev.rs | 90 ++++++ 10 files changed, 744 insertions(+), 1 deletion(-)
---
base-commit: 4e63c0582e2aef7284a2cc7c62215f245003e775
change-id: 20251217-rust_serdev-ee5481e9085c
Markus Probst
maintainerPATCH v16 1/3 rust: add basic serial device bus abstractions
Implement the basic serial device bus abstractions required to write a serial device bus device driver with or without the need for initial device data. This includes the following data structures:
The serdev::Driver trait represents the interface to the driver.
The serdev::Device abstraction represents a struct serdev_device.
In order to provide the Serdev specific parts to a generic driver::Registration the driver::RegistrationOps trait is implemented by serdev::Adapter.
--- MAINTAINERS | 2 + drivers/tty/serdev/Kconfig | 7 + rust/bindings/bindings_helper.h | 1 + rust/helpers/helpers.c | 1 + rust/helpers/serdev.c | 22 ++ rust/kernel/lib.rs | 2 + rust/kernel/serdev.rs | 605 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 640 insertions(+)
MAINTAINERS +2 -0
@@ -24568,6 +24568,8 @@ S: Maintained F: Documentation/devicetree/bindings/serial/serial.yaml F: drivers/tty/serdev/ F: include/linux/serdev.h +F: rust/helpers/serdev.c +F: rust/kernel/serdev.rs SERIAL IR RECEIVER M: Sean Young <[email protected]>
drivers/tty/serdev/Kconfig +7 -0
@@ -9,6 +9,13 @@ menuconfig SERIAL_DEV_BUS Note that you typically also want to enable TTY port controller support. +config RUST_SERIAL_DEV_BUS_ABSTRACTIONS + bool "Rust Serial device bus abstractions" + depends on RUST + select SERIAL_DEV_BUS + help + This enables the Rust abstraction for the serial device bus API. + if SERIAL_DEV_BUS config SERIAL_DEV_CTRL_TTYPORT
rust/bindings/bindings_helper.h +1 -0
@@ -85,6 +85,7 @@#include <linux/regulator/consumer.h> #include <linux/sched.h> #include <linux/security.h> +#include <linux/serdev.h> #include <linux/slab.h> #include <linux/sys_soc.h> #include <linux/task_work.h>
rust/helpers/helpers.c +1 -0
@@ -87,6 +87,7 @@#include "regulator.c" #include "scatterlist.c" #include "security.c" +#include "serdev.c" #include "signal.c" #include "slab.c" #include "spinlock.c"
rust/helpers/serdev.c new file +22 -0
@@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/serdev.h> + +__rust_helper +void rust_helper_serdev_device_driver_unregister(struct serdev_device_driver *sdrv) +{ +serdev_device_driver_unregister (sdrv); +} + +__rust_helper +void rust_helper_serdev_device_put(struct serdev_device *serdev) +{ +serdev_device_put (serdev); +} + +__rust_helper +void rust_helper_serdev_device_set_client_ops(struct serdev_device *serdev, +const struct serdev_device_ops *ops) +{ +serdev_device_set_client_ops (serdev, ops); +}
rust/kernel/lib.rs +2 -0
@@ -119,6 +119,8 @@pub mod scatterlist;pub mod security;pub mod seq_file; +#[cfg( CONFIG_RUST_SERIAL_DEV_BUS_ABSTRACTIONS )] +pub mod serdev;pub mod sizes;#[cfg( CONFIG_SOC_BUS )] pub mod soc;
rust/kernel/serdev.rs new file +605 -0
605 lines not on this page · raw message
Signature · 1 line
2.54.0
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 6 potential issue(s) to consider: - [High] Structural deadlock in `probe_callback` prevents synchronous bidirectional I/O during driver…
Thank you for your contribution! Sashiko AI review found 6 potential issue(s) to consider:
- [High] Structural deadlock in probe_callback prevents synchronous bidirectional I/O during driver initialization.
- [High] Race condition between drvdata unlinking and serdev_device_close leads to Null Pointer Dereference in receive_buf_callback.
- [High] Device communication methods are restricted to Device<Bound>, breaking probe initialization.
- [High] core::slice::from_raw_parts is called with a potentially NULL pointer when length is 0.
- [Medium] Incomplete Send and Sync implementations restrict ARef<Device<Ctx>> cross-thread usage.
- [Low] Using select on a visible menuconfig symbol forces its value and violates Kconfig guidelines.
--
--- Patch [1]: [PATCH v16 1/3] rust: add basic serial device bus abstractions --- commit d5709e842e68663c0c3e7182a96d6618f31e84b5
Author: Markus Probst <[email protected]>
rust: add basic serial device bus abstractions
This commit implements the basic Rust abstractions for the serial device bus. It introduces the Driver trait and Device representation to allow writing serdev device drivers in Rust.
drivers/tty/serdev/Kconfig menuconfig SERIAL_DEV_BUS · line 15
Quoted 10 lines
drivers/tty/serdev/Kconfig +4
-0@@ -9,6 +9,13 @@ menuconfig SERIAL_DEV_BUS Note that you typically also want to enable TTY port controller support. +config RUST_SERIAL_DEV_BUS_ABSTRACTIONS + bool "Rust Serial device bus abstractions" + depends on RUST + select SERIAL_DEV_BUS
[Severity: Low]
Is it intended to use select on a user-visible menuconfig symbol?
SERIAL_DEV_BUS is a user-visible tristate. Using select here forcefully coerces SERIAL_DEV_BUS to y when the abstraction is enabled, which prevents building the serdev subsystem as a module. Kconfig guidelines generally recommend using depends on for visible symbols instead of select.
[ ... ]
Quoted 3 lines
rust/kernel/serdev.rs new file +0
-0@@ -0,0 +1,605 @@
[ ... ]
rust/kernel/serdev.rs line 352
Quoted 12 lines
rust/kernel/serdev.rs new file +12
-0+/// #[vtable] +/// impl serdev::Driver for MyDriver { +/// type IdInfo = (); +/// type Data<'bound> = Self; +/// const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE); +/// const ACPI_ID_TABLE: Option<acpi::IdTable<Self::IdInfo>> = Some(&ACPI_TABLE); +/// +/// fn probe<'bound>( +/// sdev: &'bound serdev::Device<Core<'_>>, +/// _id_info: Option<&'bound Self::IdInfo>, +/// ) -> impl PinInit<Self::Data<'bound>, Error> + 'bound { +/// sdev.set_baudrate(115200);
[Severity: High]
Will this documentation example compile?
The Driver probe callback provides a Device parameter with the Core context, but serial communication methods like set_baudrate are exclusively implemented on Device with the Bound context.
Because the types differ, calling set_baudrate on the Core device during probe will result in a compilation error.
Furthermore, PrivateData expects the device reference to have the Bound context, but probe_callback casts it to CoreInternal, which causes an internal type mismatch during the PrivateData initialization.
[ ... ]
Quoted 1 line
+ extern "C" fn
probe_callback(sdev: *mut bindings::serdev_device)->kernel::ffi::c_int{
[ ... ]
rust/kernel/serdev.rs line 179
Quoted 6 lines
rust/kernel/serdev.rs new file +6
-0+// 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 >>() }); + });
[Severity: High]
Does this error cleanup path introduce a race condition leading to a null pointer dereference?
If an error occurs in Adapter::probe_callback, the ScopeGuard runs and calls drvdata_obtain, which unlinks the driver data from the device by setting dev->driver_data to NULL.
However, the device remains open until PrivateData::drop subsequently calls serdev_device_close. If serial data arrives in this window, receive_buf_callback executes:
rust/kernel/serdev.rs:Adapter::receive_buf_callback() {
...
let private_data = unsafe { sdev.as_ref().drvdata_borrow::<PrivateData<'_, T>>() };
let active = private_data.active.lock();
...
}The callback will blindly read the now-NULL dev->driver_data and create a Rust reference to NULL. When private_data.active.lock() is called, the kernel will crash with a null pointer dereference.
The device should probably be closed synchronously before unlinking the driver data.
rust/kernel/serdev.rs line 192
Quoted 13 lines
rust/kernel/serdev.rs new file +13
-0+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: 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);
[Severity: High]
Can this sequence cause a deadlock during driver initialization?
In Adapter::probe_callback, the private_data.active mutex is locked and held across the entire execution of T::probe. If a driver attempts synchronous bidirectional I/O (like writing a query command and waiting for a response) during probe, the system might deadlock.
When the hardware responds, the RX workqueue thread triggers Adapter::receive_buf_callback, which unconditionally attempts to lock the exact same private_data.active mutex before forwarding data. Because the mutex is held by the sleeping probe thread, receive_buf_callback blocks indefinitely, stalling the RX workqueue, and T::probe will wait forever for a response.
[ ... ]
Quoted 5 lines
rust/kernel/serdev.rs new file +5
-0+extern "C" fn receive_buf_callback ( + sdev: *mut bindings::serdev_device , + buf: *const u8 , + length:usize , + ) ->usize {
[ ... ]
rust/kernel/serdev.rs line 265
Quoted 10 lines
rust/kernel/serdev.rs new file +10
-0+// 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) };
[Severity: High]
Can core::slice::from_raw_parts be called with a null pointer here?
The C serdev core and underlying TTY layer might signal empty events or flushes by passing a NULL buffer with a length of 0. In Rust, calling core::slice::from_raw_parts with a NULL pointer is immediate undefined behavior, regardless of whether the length is zero, because the standard library requires the pointer to be non-NULL and aligned.
Could a check like if buf.is_null() or if length == 0 be added before creating the slice?
[ ... ]
rust/kernel/serdev.rs line 605
Quoted 10 lines
rust/kernel/serdev.rs new file +10
-0+// SAFETY: A `Device` is always reference-counted and can be released from any thread. +unsafe impl Send for Device {} + +// SAFETY: `Device` can be shared among threads because all methods of `Device` +// (i.e. `Device<Normal>) are thread safe. +unsafe impl Sync for Device {} + +// SAFETY: Same as `Device<Normal>` -- the underlying `struct serdev_device` is the same; +// `Bound` is a zero-sized type-state marker that does not affect thread safety. +unsafe impl Sync for Device <device::Bound > {}
[Severity: Medium]
Does the Device type with the Bound context need a Send implementation?
The trait implementations unsafe impl Send for Device {} and unsafe impl Sync for Device {} implicitly apply only to Device with the Normal context due to the default generic parameter.
While unsafe impl Sync for Device with Bound context was explicitly added, Send is missing. This means a Device with the Bound context is not Send, so it cannot be moved across thread boundaries, stored in standard thread-safe driver state, or safely passed to workqueues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Markus Probst
maintainerPATCH v16 2/3 samples: rust: add Rust serial device bus sample device driver
In reply to Markus ProbstAdd a sample Rust serial device bus device driver illustrating the usage of the serial device bus abstractions.
This drivers probes through either a match of device / driver name or a match within the OF ID table.
--- MAINTAINERS | 1 + samples/rust/Kconfig | 11 +++++ samples/rust/Makefile | 1 + samples/rust/rust_driver_serdev.rs | 90 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 103 insertions(+)
MAINTAINERS +1 -0
@@ -24570,6 +24570,7 @@ F: drivers/tty/serdev/ F: include/linux/serdev.h F: rust/helpers/serdev.c F: rust/kernel/serdev.rs +F: samples/rust/rust_driver_serdev.rs SERIAL IR RECEIVER M: Sean Young <[email protected]>
samples/rust/Kconfig +11 -0
@@ -161,6 +161,17 @@ config SAMPLE_RUST_DRIVER_AUXILIARY If unsure, say N. +config SAMPLE_RUST_DRIVER_SERDEV + tristate "Serial Device Bus Device Driver" + select RUST_SERIAL_DEV_BUS_ABSTRACTIONS + help + This option builds the Rust serial device bus driver sample. + + To compile this as a module, choose M here: + the module will be called rust_driver_serdev. + + If unsure, say N. + config SAMPLE_RUST_SOC tristate "SoC Driver" select SOC_BUS
samples/rust/Makefile +1 -0
@@ -14,6 +14,7 @@ obj-$(CONFIG_SAMPLE_RUST_DRIVER_PLATFORM) += rust_driver_platform.o obj-$(CONFIG_SAMPLE_RUST_DRIVER_USB) += rust_driver_usb.o obj-$(CONFIG_SAMPLE_RUST_DRIVER_FAUX) += rust_driver_faux.o obj-$(CONFIG_SAMPLE_RUST_DRIVER_AUXILIARY) += rust_driver_auxiliary.o +obj-$(CONFIG_SAMPLE_RUST_DRIVER_SERDEV) += rust_driver_serdev.o obj-$(CONFIG_SAMPLE_RUST_CONFIGFS) += rust_configfs.o obj-$(CONFIG_SAMPLE_RUST_SOC) += rust_soc.o
samples/rust/rust_driver_serdev.rs new file +90 -0
90 lines not on this page · raw message
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v16 2/3] samples: rust: add Rust serial device bus sample device driver
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] Race condition causing Use-After-Free and NULL pointer dereference in `receive_buf_callback`…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] Race condition causing Use-After-Free and NULL pointer dereference in receive_buf_callback during device unbind or probe failure.
- [Medium] Missing write_wakeup hook in serdev abstraction causes driver stalls on transmit buffer full.
--
--- Patch [2]: [PATCH v16 2/3] samples: rust: add Rust serial device bus sample device driver --- commit 55560927fe62016a13f3a51d6f3e3f813e10db57
Author: Markus Probst <[email protected]>
samples: rust: add Rust serial device bus sample device driver
Add a sample Rust serial device bus device driver illustrating the usage of the serial device bus abstractions.
Quoted 5 lines
samples/rust/rust_driver_serdev.rs new file +0
-0
[ ... ]
samples/rust/rust_driver_serdev.rs line 71
Quoted 6 lines
samples/rust/rust_driver_serdev.rs new file +6
-0+fn receive <'bound>( + sdev: &'bound serdev::Device <Bound >, + _this:Pin <&Self >, + data: &[u8 ], + ) ->usize { + sdev.write (data).unwrap_or_default ()as usize
[Severity: Medium]
Will this driver stall on a full transmit buffer?
If the transmit buffer fills up, sdev.write() returns a short count, which the driver propagates back to the TTY core.
The TTY core responds by pausing further receive operations until space becomes available.
Since the Rust serdev abstraction hardcodes write_wakeup to bindings::serdev_device_write_wakeup (which only wakes up synchronous writes via write_all):
rust/kernel/serdev.rs:Adapter::OPS {
...
write_wakeup: Some(bindings::serdev_device_write_wakeup),
...
}the driver cannot hook write_wakeup to be notified when transmit space becomes available.
As a result, the driver never resumes the TTY receive path, causing a permanent stall until a new byte physically arrives to re-trigger the receive workqueue.
samples/rust/rust_driver_serdev.rs line 82
Quoted 11 lines
samples/rust/rust_driver_serdev.rs new file +11
-0+ } +} + +impl Drop for SampleDriver { +fn drop (&mut self) { +dev_dbg! ( + self.sdev.as_ref (), +"Remove Rust Serial device bus device driver sample.\n" + ); + } +}
[Severity: High]
Does the serdev abstraction have a use-after-free or NULL pointer dereference race condition during device unbind or probe failure?
During device unbind, the driver core invokes post_unbind_callback, which calls drvdata_obtain to take ownership of the driver data, setting drvdata to NULL:
rust/kernel/device.rs:drvdata_obtain() {
...
unsafe { bindings::dev_set_drvdata(self.as_raw(), core::ptr::null_mut()) };
...
}It then drops PrivateData, which closes the device:
rust/kernel/serdev.rs:PinnedDrop for PrivateData {
...
unsafe { bindings::serdev_device_close(self.sdev.as_raw()) };
...
}Because the device is closed only at the end of the drop routine, the TTY port remains active while drvdata is NULL and while PrivateData is being freed.
If data arrives on the UART during this window, the TTY layer concurrently invokes receive_buf_callback, which borrows drvdata:
rust/kernel/serdev.rs:receive_buf_callback() {
...
let private_data = unsafe { sdev.as_ref().drvdata_borrow::<PrivateData<'_, T>>() };
...
}rust/kernel/device.rs:drvdata_borrow() {
...
unsafe { Pin::<KBox<T>>::borrow(ptr.cast()) }
...
}This will either dereference the NULL drvdata pointer, or if it already read the pointer before drvdata_obtain, it will access PrivateData after it has been freed when attempting to lock active.
The same race exists in the probe error path where ScopeGuard drops PrivateData before the device is closed.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Markus Probst
maintainerPATCH v16 3/3 MAINTAINERS: serdev: Add self for serdev
In reply to Markus ProbstRob mentioned he needs to find someone else to maintain serdev.
--- MAINTAINERS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
MAINTAINERS +1 -1
@@ -24562,7 +24562,7 @@ F: drivers/iio/chemical/sps30_i2c.c F: drivers/iio/chemical/sps30_serial.c SERIAL DEVICE BUS -M: Rob Herring <[email protected]> +M: Markus Probst <[email protected]> L: [email protected] S: Maintained F: Documentation/devicetree/bindings/serial/serial.yaml
Signature · 1 line
2.54.0
Quoted 1 line · Markus Probst
[PATCH v16 0/3] rust: add basic serial device bus abstractions
Applied, thanks!
Branch: driver-core-testing
Tree: git://git.kernel.org/pub/scm/linux/kernel/git/driver-core/driver-core.git
[1/3] rust: add basic serial device bus abstractions
commit: 99f59aa82341
[2/3] samples: rust: add Rust serial device bus sample device driver
commit: 4b2c9156d312
[3/3] MAINTAINERS: serdev: Add self for serdev
commit: 6b71fef6f05cThe patches will appear in the next linux-next integration (typically within 24 hours on weekdays).
The patches are in the driver-core-testing branch and will be promoted to driver-core-next after validation.
Danilo Krummrich
maintainerQuoted 15 lines · Danilo Krummrich
Quoted 1 line · Markus Probst
[PATCH v16 0/3] rust: add basic serial device bus abstractions
Applied, thanks!
Branch: driver-core-testing
Tree:git://git.kernel.org/pub/scm/linux/kernel/git/driver-core/driver-core.git[1/3] rust: add basic serial device bus abstractions
commit: 99f59aa82341 [2/3] samples: rust: add Rust serial device bus sample device driver commit: 4b2c9156d312 [3/3] MAINTAINERS: serdev: Add self for serdev commit: 6b71fef6f05c
Quoted 5 lines
The patches will appear in the next linux-next integration (typically within 24 hours on weekdays).
The patches are in the driver-core-testing branch and will be promoted to driver-core-next after validation.
Greg, since I've dropped it from the queue a few days ago I've now picked it back up.
Thanks,
Danilo
Greg Kroah-Hartman
maintainerQuoted 16 lines · Danilo Krummrich
Quoted 15 lines · Danilo Krummrich
Quoted 1 line · Markus Probst
[PATCH v16 0/3] rust: add basic serial device bus abstractions
Applied, thanks!
Branch: driver-core-testing
Tree:git://git.kernel.org/pub/scm/linux/kernel/git/driver-core/driver-core.git[1/3] rust: add basic serial device bus abstractions
commit: 99f59aa82341 [2/3] samples: rust: add Rust serial device bus sample device driver commit: 4b2c9156d312 [3/3] MAINTAINERS: serdev: Add self for serdev commit: 6b71fef6f05c
Quoted 8 lines
Quoted 5 lines
The patches will appear in the next linux-next integration (typically within 24 hours on weekdays).
The patches are in the driver-core-testing branch and will be promoted to driver-core-next after validation.
Greg, since I've dropped it from the queue a few days ago I've now picked it back up.
That's great, thanks!