Skip to contentSkip to conversation

rust: add basic serial device bus abstractions

PATCH Superseded Markus Probst 4 participants 20 messages Mar 13 – Mar 20

Subsystems (7)

v3 of 16 Superseded Latest is v16 →

lore
Share & tools
lore

Markus Probst

author maintainer
#0 lore raw

v3 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).

@Rob: Are you willing to maintain these rust abstractions yourself, as you are the expert on this subsystem, otherwise I would take care of it with a "SERIAL DEVICE BUS [RUST]" section in the MAINTAINERS file. In the second case, I assume you are going to pick those patches as-is into your tree, after they have been reviewed?

---
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 (4):
rust: devres: return reference in devres::register
serdev: add rust private data to serdev_device
rust: add basic serial device bus abstractions
samples: rust: add Rust serial device bus sample device driver

 drivers/tty/serdev/Kconfig         |   7 +
 include/linux/serdev.h             |  15 +-
 rust/bindings/bindings_helper.h    |   1 +
 rust/helpers/helpers.c             |   1 +
 rust/helpers/serdev.c              |  22 ++
 rust/kernel/cpufreq.rs             |   3 +-
 rust/kernel/devres.rs              |  15 +-
 rust/kernel/drm/driver.rs          |   3 +-
 rust/kernel/lib.rs                 |   2 +
 rust/kernel/serdev.rs              | 536 +++++++++++++++++++++++++++++++++++++
 samples/rust/Kconfig               |  11 +
 samples/rust/Makefile              |   1 +
 samples/rust/rust_driver_serdev.rs |  86 ++++++
 13 files changed, 693 insertions(+), 10 deletions(-)

---
base-commit: 1f318b96cc84d7c2ab792fcc0bfd42a7ca890681
change-id: 20251217-rust_serdev-ee5481e9085c

author maintainer
#1 lore raw

PATCH v3 1/4 rust: devres: return reference in `devres::register`

Return the reference to the initialized data in the devres::register function.

This is needed in a following commit (rust: add basic serial device bus abstractions).

---
 rust/kernel/cpufreq.rs    |  3 ++-
 rust/kernel/devres.rs     | 15 +++++++++++++--
 rust/kernel/drm/driver.rs |  3 ++-
 3 files changed, 17 insertions(+), 4 deletions(-)
rust/kernel/cpufreq.rs +2 -1
index 76faa1ac8501..8cf86bb8e0f4 100644
@@ -1051,7 +1051,8 @@ pub fn new_foreign_owned(dev: &Device<Bound>) -> Result
     where
         T: 'static,
     {
-        devres::register(dev, Self::new()?, GFP_KERNEL)
+        devres::register(dev, Self::new()?, GFP_KERNEL)?;
+        Ok(())
     }
 }
 
rust/kernel/devres.rs +13 -2
index 6afe196be42c..f882bace8601 100644
@@ -326,15 +326,26 @@ fn register_foreign<P>(dev: &Device<Bound>, data: P) -> Result
 /// }
 ///
 /// fn from_bound_context(dev: &Device<Bound>) -> Result {
-///     devres::register(dev, Registration::new(), GFP_KERNEL)
+///     devres::register(dev, Registration::new(), GFP_KERNEL)?;
+///     Ok(())
 /// }
 /// ```
-pub fn register<T, E>(dev: &Device<Bound>, data: impl PinInit<T, E>, flags: Flags) -> Result
+pub fn register<'a, T, E>(
+    dev: &'a Device<Bound>,
+    data: impl PinInit<T, E>,
+    flags: Flags,
+) -> Result<&'a T>
 where
     T: Send + 'static,
     Error: From<E>,
 {
     let data = KBox::pin_init(data, flags)?;
 
+    let data_ptr = &raw const *data;
+
     register_foreign(dev, data)
+        // SAFETY: `dev` is valid for the lifetime of 'a. As long as there is a reference to
+        // `Device<Bound>`, it is guaranteed that the device is not unbound and data has not been
+        // dropped. Thus `data_ptr` is also valid for the lifetime of 'a.
+        .map(|()| unsafe { &*data_ptr })
 }
rust/kernel/drm/driver.rs +2 -1
index e09f977b5b51..51e0c7e30cc2 100644
@@ -145,7 +145,8 @@ pub fn new_foreign_owned(
 
         let reg = Registration::<T>::new(drm, flags)?;
 
-        devres::register(dev, reg, GFP_KERNEL)
+        devres::register(dev, reg, GFP_KERNEL)?;
+        Ok(())
     }
 
     /// Returns a reference to the `Device` instance for this registration.
Signature · 1 line
2.52.0
author maintainer
#2 lore raw

PATCH v3 2/4 serdev: add rust private data to serdev_device

In reply to Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

---
 include/linux/serdev.h | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)
include/linux/serdev.h +9 -6
index 5654c58eb73c..c74c345d60ae 100644
@@ -33,12 +33,14 @@ struct serdev_device_ops {
 
 /**
  * struct serdev_device - Basic representation of an serdev device
- * @dev:	Driver model representation of the device.
- * @nr:		Device number on serdev bus.
- * @ctrl:	serdev controller managing this device.
- * @ops:	Device operations.
- * @write_comp	Completion used by serdev_device_write() internally
- * @write_lock	Lock to serialize access when writing data
+ * @dev:	       Driver model representation of the device.
+ * @nr:		       Device number on serdev bus.
+ * @ctrl:	       serdev controller managing this device.
+ * @ops:	       Device operations.
+ * @write_comp:	       Completion used by serdev_device_write() internally
+ * @write_lock:	       Lock to serialize access when writing data
+ * @rust_private_data: Private data for the rust abstraction. This should
+ *		       not be used by the C drivers.
  */
 struct serdev_device {
 	struct device dev;
@@ -47,6 +49,7 @@ struct serdev_device {
 	const struct serdev_device_ops *ops;
 	struct completion write_comp;
 	struct mutex write_lock;
+	void *rust_private_data;
 };
 
 static inline struct serdev_device *to_serdev_device(struct device *d)
Signature · 1 line
2.52.0
#3 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

thanks,

greg k-h

author maintainer
#4 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

Thanks
- Markus Probst

Quoted 4 lines

thanks,

greg k-h

#5 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

What am I missing?

Also, all of this information MUST be in the changelog text in order for us to be able to accept it. You need to say _why_ a change is needed, not just _what_ the change does, as you know.

thanks,

greg k-h

author maintainer
#6 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 24 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

Quoted 5 lines

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Quoted 4 lines

Also, all of this information MUST be in the changelog text in order for us to be able to accept it. You need to say _why_ a change is needed, not just _what_ the change does, as you know.

Will do.

Thanks
- Markus Probst

maintainer
#7 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 29 lines · Markus Probst
Quoted 28 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

Quoted 5 lines
Quoted 1 line

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Why can the function pointers be called during probe?

Alice

#8 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

In reply to Markus Probst
Quoted 29 lines · Markus Probst
Quoted 28 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

Quoted 5 lines
Quoted 1 line

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here? What specific serdev function causes this and why isn't it an issue with the C api? Can we change the C code to not require this?

thanks,

greg k-h

maintainer
#9 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 36 lines · Greg Kroah-Hartman
Quoted 29 lines · Markus Probst
Quoted 28 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

Quoted 5 lines
Quoted 1 line

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Quoted 4 lines

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here? What specific serdev function causes this and why isn't it an issue with the C api? Can we change the C code to not require this?

I think the idea is to avoid bugs as in the mhz19b driver [1].

This driver's probe() looks like this:

	serdev_device_set_client_ops(serdev, &mhz19b_ops);
	ret = devm_serdev_device_open(dev, serdev);

	// Lots of other initialization.

	serdev_device_set_drvdata(serdev, indio_dev);

But the receive_buf() callback from mhz19b_ops dereferences the driver's private data.

Now, maybe this is actually prevented to become an actual race, since some regulator is only enabled subsequently:

	devm_regulator_get_enable(dev, "vin");

But in any case in Rust it would be unsound as with this a driver could easily cause undefined behavior with safe APIs.

Maybe it is as simple as letting the abstraction call serdev_device_open() only after the driver's probe() has completed, but maybe there are reasons why that is not an option, that's a serdev question.

[1] https://elixir.bootlin.com/linux/v6.19.7/source/drivers/iio/chemical/mhz19b.c#L260

author maintainer
#10 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 60 lines · Danilo Krummrich
Quoted 36 lines · Greg Kroah-Hartman
Quoted 29 lines · Markus Probst
Quoted 28 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

Quoted 5 lines
Quoted 1 line

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Quoted 4 lines

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here? What specific serdev function causes this and why isn't it an issue with the C api? Can we change the C code to not require this?

I think the idea is to avoid bugs as in the mhz19b driver [1].

This driver's probe() looks like this:

	serdev_device_set_client_ops(serdev, &mhz19b_ops);
	ret = devm_serdev_device_open(dev, serdev);

	// Lots of other initialization.

	serdev_device_set_drvdata(serdev, indio_dev);

But the receive_buf() callback from mhz19b_ops dereferences the driver's private data.

Now, maybe this is actually prevented to become an actual race, since some regulator is only enabled subsequently:

Quoted 8 lines
	devm_regulator_get_enable(dev, "vin");

But in any case in Rust it would be unsound as with this a driver could easily cause undefined behavior with safe APIs.

Maybe it is as simple as letting the abstraction call serdev_device_open() only after the driver's probe() has completed, but maybe there are reasons why that is not an option, that's a serdev question.

If we call it after probe, calls to serdev_device_set_baudrate, serdev_device_set_flow_control, serdev_device_set_parity, serdev_device_write_buf, serdev_device_write, serdev_device_write_flush, which are exposed via the rust abstraction would result in a null pointer dereference.

Thanks
- Markus Probst

Quoted 2 lines

[1] https://elixir.bootlin.com/linux/v6.19.7/source/drivers/iio/chemical/mhz19b.c#L260

maintainer
#11 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 66 lines · Markus Probst
Quoted 65 lines · Danilo Krummrich
Quoted 36 lines · Greg Kroah-Hartman
Quoted 29 lines · Markus Probst
Quoted 28 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

Quoted 5 lines
Quoted 1 line

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Quoted 4 lines

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here? What specific serdev function causes this and why isn't it an issue with the C api? Can we change the C code to not require this?

I think the idea is to avoid bugs as in the mhz19b driver [1].

This driver's probe() looks like this:

	serdev_device_set_client_ops(serdev, &mhz19b_ops);
	ret = devm_serdev_device_open(dev, serdev);

	// Lots of other initialization.

	serdev_device_set_drvdata(serdev, indio_dev);

But the receive_buf() callback from mhz19b_ops dereferences the driver's private data.

Now, maybe this is actually prevented to become an actual race, since some regulator is only enabled subsequently:

	devm_regulator_get_enable(dev, "vin");

But in any case in Rust it would be unsound as with this a driver could easily cause undefined behavior with safe APIs.

Quoted 8 lines
Quoted 3 lines

Maybe it is as simple as letting the abstraction call serdev_device_open() only after the driver's probe() has completed, but maybe there are reasons why that is not an option, that's a serdev question.

If we call it after probe, calls to serdev_device_set_baudrate, serdev_device_set_flow_control, serdev_device_set_parity, serdev_device_write_buf, serdev_device_write, serdev_device_write_flush, which are exposed via the rust abstraction would result in a null pointer dereference.

Then maybe ensure that the driver's receive_buf() callback can only ever be called after probe() has been completed? E.g. receive_buf() could be optional and swapped out later on.

author maintainer
#12 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 76 lines · Danilo Krummrich
Quoted 66 lines · Markus Probst
Quoted 65 lines · Danilo Krummrich
Quoted 36 lines · Greg Kroah-Hartman
Quoted 29 lines · Markus Probst
Quoted 28 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

Quoted 5 lines
Quoted 1 line

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Quoted 4 lines

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here? What specific serdev function causes this and why isn't it an issue with the C api? Can we change the C code to not require this?

I think the idea is to avoid bugs as in the mhz19b driver [1].

This driver's probe() looks like this:

	serdev_device_set_client_ops(serdev, &mhz19b_ops);
	ret = devm_serdev_device_open(dev, serdev);

	// Lots of other initialization.

	serdev_device_set_drvdata(serdev, indio_dev);

But the receive_buf() callback from mhz19b_ops dereferences the driver's private data.

Now, maybe this is actually prevented to become an actual race, since some regulator is only enabled subsequently:

	devm_regulator_get_enable(dev, "vin");

But in any case in Rust it would be unsound as with this a driver could easily cause undefined behavior with safe APIs.

Quoted 8 lines
Quoted 3 lines

Maybe it is as simple as letting the abstraction call serdev_device_open() only after the driver's probe() has completed, but maybe there are reasons why that is not an option, that's a serdev question.

If we call it after probe, calls to serdev_device_set_baudrate, serdev_device_set_flow_control, serdev_device_set_parity, serdev_device_write_buf, serdev_device_write, serdev_device_write_flush, which are exposed via the rust abstraction would result in a null pointer dereference.

Quoted 3 lines

Then maybe ensure that the driver's receive_buf() callback can only ever be called after probe() has been completed? E.g. receive_buf() could be optional and swapped out later on.

I am not exactly sure what you mean by "could be optional and swapped out later on".

Also,
the function pointer cannot be changed while the device is open, as this could introduce a race condition. In addition if it was prior set to NULL and data was received, this data would be lost.

Thanks
- Markus Probst

author maintainer
#13 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

In reply to Greg Kroah-Hartman
Quoted 30 lines · Greg Kroah-Hartman
Quoted 29 lines · Markus Probst
Quoted 28 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

Quoted 9 lines
Quoted 5 lines
Quoted 1 line

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here?

In PCI or USB we don't need to provide function pointers for callbacks in advance, which will be can be called any time (even while probe).

Quoted 3 lines

What specific serdev function
causes this

drivers/tty/serdev/serdev-ttyport.c basically only wraps the serdev calls to tty calls. This isn't directly caused by a serdev function, but by the tty part.

Quoted 2 lines

why isn't it an issue with the C api?

In C you can set the drvdata inside the probe and even with it not being fully initialized.

With Rust the drvdata is only available after the probe. But there is the posibility of serdev calling the provided callback inside probe.

Quoted 2 lines

Can we change the
C code to not require this?

Serdev is very closely linked to tty.

There are 3 options:

1. Add a rust_serdev_device_open and rust_serdev_device_ready function. rust_serdev_device_open would do the same thing as serdev_device_open, but with calling tty_buffer_lock_exclusive before opening the underlying tty port. rust_serdev_device_ready would call tty_buffer_unlock_exclusive. Such functions would then need to exist for every serdev controller (currently there is only ttyport as serdev controller).

2. Rewrite parts of the tty subsystem.

Not sure what would need to be changed there yet. But this could also affect the existing tty drivers, which are a lot in comparision to serdev.

3. Keep the rust_private_data pointer in serdev_device.

This seems to be the simplest option to me.

Thanks
- Markus Probst

Quoted 4 lines

thanks,

greg k-h

#14 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 37 lines · Markus Probst
Quoted 36 lines · Greg Kroah-Hartman
Quoted 34 lines · Markus Probst
Quoted 24 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

Quoted 5 lines

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Quoted 5 lines
Quoted 3 lines

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here?

In PCI or USB we don't need to provide function pointers for callbacks in advance, which will be can be called any time (even while probe).

All class drivers are like this, once you register with them, the function pointers you provide can be called before your probe call ends. So this isn't unique as far as I can tell.

Quoted 7 lines
Quoted 3 lines

What specific serdev function
causes this

drivers/tty/serdev/serdev-ttyport.c basically only wraps the serdev calls to tty calls. This isn't directly caused by a serdev function, but by the tty part.

Quoted 8 lines
Quoted 2 lines

why isn't it an issue with the C api?

In C you can set the drvdata inside the probe and even with it not being fully initialized.

With Rust the drvdata is only available after the probe. But there is the posibility of serdev calling the provided callback inside probe.

Other classes have this same issue, so why isn't this a problem for HID and input and the like?

thanks,

greg k-h

author maintainer
#15 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 60 lines · Greg Kroah-Hartman
Quoted 37 lines · Markus Probst
Quoted 36 lines · Greg Kroah-Hartman
Quoted 34 lines · Markus Probst
Quoted 24 lines · Greg Kroah-Hartman
Quoted 8 lines · Markus Probst
Quoted 7 lines · Greg Kroah-Hartman
Quoted 3 lines · Markus Probst

Add rust private data to struct serdev_device, as it is required by the rust abstraction added in the following commit
(rust: add basic serial device bus abstractions).

why is rust "special" here? What's wrong with the existing private pointer in this structure? Why must we add another one?

Quoted 14 lines

Because in rust, the device drvdata will be set after probe has run. In serdev, once the device has been opened, it can receive data. It must be opened either inside probe or before probe, because it can only be configured (baudrate, flow control etc.) and data written to after it has been opened. Because it can receive data before drvdata has been set yet, we need to ensure it waits on data receival for the probe to be finished. Otherwise this would be a null pointer dereference. To do this, we need to store a Completion for it to wait and a bool in case the probe exits with an error. We cannot store this data in the device drvdata, because this is where the drivers drvdata goes. We also cannot create a wrapper of the drivers drvdata, because Device::drvdata::<T>() would always fail in that case. That is why we need a "rust_private_data" for this abstraction to store the Completion and bool.

Quoted 5 lines

So why is this any different from any other bus type? I don't see the "uniqueness" here that has not required this to happen for PCI or USB or anything else.

What am I missing?

In Short:
In serdev, we have to handle incoming device data (serdev calls on a function pointer we provide in advance), even in the case that the driver hasn't completed probe yet.

Quoted 5 lines
Quoted 3 lines

But how is that any different from a USB or PCI driver doing the same thing? Why is serdev so unique here?

In PCI or USB we don't need to provide function pointers for callbacks in advance, which will be can be called any time (even while probe).

All class drivers are like this, once you register with them, the function pointers you provide can be called before your probe call ends. So this isn't unique as far as I can tell.

Quoted 12 lines
Quoted 3 lines

What specific serdev function
causes this

drivers/tty/serdev/serdev-ttyport.c basically only wraps the serdev calls to tty calls. This isn't directly caused by a serdev function, but by the tty part.

Quoted 2 lines

why isn't it an issue with the C api?

In C you can set the drvdata inside the probe and even with it not being fully initialized.

Quoted 6 lines
Quoted 3 lines

With Rust the drvdata is only available after the probe. But there is the posibility of serdev calling the provided callback inside probe.

Other classes have this same issue, so why isn't this a problem for HID and input and the like?

This is unique for a bus device.

A class device has its own Data (e. g. PwmOps), i. e. it will only be registered after this Data has been initialized by the driver.

The receive_buf callback on the serdev device on the other hand must happen on the drvdata, as there is no place to store its own Data.

The drvdata is only available at the end of the probe in Rust.

Thanks
- Markus Probst

Quoted 4 lines

thanks,

greg k-h

maintainer
#16 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 9 lines · Markus Probst

This is unique for a bus device.

A class device has its own Data (e. g. PwmOps), i. e. it will only be registered after this Data has been initialized by the driver.

The receive_buf callback on the serdev device on the other hand must happen on the drvdata, as there is no place to store its own Data.

The drvdata is only available at the end of the probe in Rust.

In other words, devm_serdev_device_open() relies on the driver having its private data set before this is called, since once devm_serdev_device_open() has been called, the driver's receive_buf() callback may be called.

So, in C it is the driver's responsibility to do things in the correct order, in Rust we want to make sure the driver can't do it out of order in the first place.

I'm still not sure whether the current approach is the best option. For instance, we could also solve this with a separate callback. (Wasn't this even what you had in a previous version?)

author maintainer
#17 lore raw

Re: [PATCH v3 2/4] serdev: add rust private data to serdev_device

Quoted 18 lines · Danilo Krummrich
Quoted 9 lines · Markus Probst

This is unique for a bus device.

A class device has its own Data (e. g. PwmOps), i. e. it will only be registered after this Data has been initialized by the driver.

The receive_buf callback on the serdev device on the other hand must happen on the drvdata, as there is no place to store its own Data.

The drvdata is only available at the end of the probe in Rust.

In other words, devm_serdev_device_open() relies on the driver having its private data set before this is called, since once devm_serdev_device_open() has been called, the driver's receive_buf() callback may be called.

So, in C it is the driver's responsibility to do things in the correct order, in Rust we want to make sure the driver can't do it out of order in the first place.

Quoted 6 lines

I'm still not sure whether the current approach is the best option. For instance, we could also solve this with a separate callback.

Wasn't this even
what you had in a previous version?

Yes, but Kari pointed out that changing the ops while it is in use is unsafe [1].

Thanks
- Markus Probst

[1]
https://lore.kernel.org/rust-for-linux/CAC=eVgR2WYdDTW3kOeemyQPP-H0aAUsrzn5Gk5zCe2hQEB709w@mail.gmail.com/

author maintainer
#18 lore raw

PATCH v3 3/4 rust: add basic serial device bus abstractions

In reply to Markus Probst

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.

---
 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           | 536 ++++++++++++++++++++++++++++++++++++++++
 6 files changed, 569 insertions(+)
drivers/tty/serdev/Kconfig +7 -0
index 46ae732bfc68..e6dfe949ad01 100644
@@ -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
index 083cc44aa952..ab521ba42673 100644
@@ -80,6 +80,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
index a3c42e51f00a..9b87e9591cfd 100644
@@ -53,6 +53,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
new file mode 100644
index 000000000000..c52b78ca3fc7
@@ -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
index 3da92f18f4ee..90635f44e171 100644
@@ -140,6 +140,8 @@
 pub mod scatterlist;
 pub mod security;
 pub mod seq_file;
+#[cfg(CONFIG_RUST_SERIAL_DEV_BUS_ABSTRACTIONS)]
+pub mod serdev;
 pub mod sizes;
 pub mod slice;
 #[cfg(CONFIG_SOC_BUS)]
rust/kernel/serdev.rs new file +536 -0

536 lines not on this page · raw message

Signature · 1 line
2.52.0
author maintainer
#19 lore raw

PATCH v3 4/4 samples: rust: add Rust serial device bus sample device driver

In reply to Markus Probst

Add 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.

---
 samples/rust/Kconfig               | 11 +++++
 samples/rust/Makefile              |  1 +
 samples/rust/rust_driver_serdev.rs | 86 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 98 insertions(+)
samples/rust/Kconfig +11 -0
index c49ab9106345..a421470d2c52 100644
@@ -161,6 +161,17 @@ config SAMPLE_RUST_DRIVER_AUXILIARY
 
 	  If unsure, say N.
 
+config SAMPLE_RUST_DRIVER_SERDEV
+	tristate "Serial Device Bus Device Driver"
+	depends on SERIAL_DEV_BUS
+	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
index 6c0aaa58cccc..b986b681cde5 100644
@@ -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 +86 -0

86 lines not on this page · raw message

Signature · 1 line
2.52.0