Skip to contentSkip to conversation

rust: leds: add led classdev abstractions

PATCH Superseded Markus Probst 2 participants 7 messages Jul 16

Subsystems (3)

v23 of 28 Superseded Latest is v28 →

lore
Share & tools
lore
#0 lore raw

v23 cover rust: leds: add led classdev abstractions

This patch series has previously been contained in
https://lore.kernel.org/rust-for-linux/[email protected]/T/#t
which added a rust written led driver for a microcontroller via i2c.

As the reading and writing to the i2c client via the register! macro has not been implemented yet [1], the patch series will only contain the additional abstractions required.

This series depends on [1].

[1] https://lore.kernel.org/rust-for-linux/[email protected]/

The following changes were made:
* add basic led classdev abstractions to register and unregister leds

* add basic led classdev abstractions to register and unregister multicolor leds

Changes since v22:
* readded CStrExt import, because it is imported with as _ in prelude. A # CONFIG_RUST is not set sneaked into my .config while development, so the compile error was unnoticed.

Changes since v21:
* use 'init for lifetime that is only alive during initialization
* remove unnecessary CStrExt import

Changes since v20:
* resolve Sashiko regressions:
* fix typo
* fix fwnode refcount decremented too early

Changes since v19:
* rebase on v7.2-rc1:
* Add max_intensity to MultiColorSubLed
* use safer KBox::pin_slice instead of KVec
(len might not equal capacity)
* explicitly call FwNode::dec_ref instead of dropping a reconstructed ARef<FwNode>.
* remove direct access to intensity and brightness fields, which may get mutated concurrently by the C side
* fix safety comments pointing to functions from previous revisions

Changes since v18:
* add inlines
* fix invalid documentation
* improve led color duplicate checking

Changes since v17:
* use lifetimes instead of Devres

Changes since v16:
* use for loops for duplicate checking

Changes since v15:
* fix issues reported by Sashiko bot:
* fix returning error not possible on brightness_get callback

Changes since v14:
* fix issues reported by Sashiko bot:
* add missing inlines
* add missing Sync trait bound
* fix vertical import layout for public export of private types
* fix potential memory leak, if a multicolor led device with over u32::MAX subleds is registered
* remove default_trigger option
* fix missing CAST doc

Changes since v13:
* rebased onto v7.1-rc1

Changes since v12:
* add led::DeviceBuilder::name() and `DeviceBuilderState'
* add led::Color::as_c_str

Changes since v11:
* use led::DeviceBuilder instead of led::InitData
* use static_assert instead of const { assert!(...) }
* restructured patches to avoid moving led::Device from rust/kernel/led.rs to rust/kernel/led/normal.rs in the 2. patch

Changes since v10:
* allow in-place initialization of LedOps
* run rustfmt for code inside try_pin_init!

Changes since v9:
* add missing periods in documentation
* duplicate led::Device and led::Adapter instead of using a complex trait
* fix imports not using prelude
* adapt to CStr change
* documented led::Color::Multi and led::Color::Rgb

Changes since v8:
* accept Option<ARef<Fwnode>> in led::InitData::fwnode()
* make functions in MultiColorSubLed const
* drop the "rust: Add trait to convert a device reference to a bus device reference" patch, as it has been picked into driver-core

Changes since v7:
* adjusted import style
* added classdev parameter to callback functions in LedOps
* implement led::Color
* extend led::InitData with
- initial_brightness
- default_trigger
- default_color
* split generic and normal led classdev abstractions up (see patch 3/4)
* add multicolor led class device abstractions (see patch 4/4)
* added MAINTAINERS entry

Changes since v6:
* fixed typos
* improved documentation

Changes since v5:
* rename IntoBusDevice trait into AsBusDevice
* fix documentation about LedOps::BLOCKING
* removed dependency on i2c bindings
* added AsBusDevice implementation for platform::Device
* removed device::Device fallback implementation
* document that AsBusDevice must not be used by drivers and is intended for bus and class device abstractions only.

Changes since v4:
* add abstraction to convert a device reference to a bus device reference
* require the bus device as parent device and provide it in class device callbacks
* remove Pin<Vec<_>> abstraction (as not relevant for the led abstractions)
* fixed formatting in led::Device::new
* fixed LedOps::BLOCKING did the inverse effect

Changes since v3:
* fixed kunit tests failing because of example in documentation

Changes since v2:
* return Devres on led::Device creation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* rename led::Handler to led::LedOps
* add optional brightness_get function to led::LedOps
* use #[vtable] instead of const BLINK: bool
* use Opaque::cast_from instead of casting a pointer
* improve documentation
* improve support for older rust versions
* use &Device<Bound> for parent

Changes since v1:
* fixed typos noticed by Onur Özkan

---
Markus Probst (3):
rust: leds: add basic led classdev abstractions
rust: leds: add Mode trait
rust: leds: add multicolor classdev abstractions

 MAINTAINERS                     |   8 +
 rust/bindings/bindings_helper.h |   1 +
 rust/kernel/led.rs              | 339 +++++++++++++++++++++++++++++
 rust/kernel/led/multicolor.rs   | 460 ++++++++++++++++++++++++++++++++++++++++
 rust/kernel/led/normal.rs       | 238 +++++++++++++++++++++
 rust/kernel/lib.rs              |   1 +
 6 files changed, 1047 insertions(+)

---
base-commit: 1137d8b5df06137fb49513cc923b3b24d94cb809
change-id: 20251114-rust_leds-a959f7c2f7f9

#1 lore raw

PATCH v23 1/3 rust: leds: add basic led classdev abstractions

Implement the core abstractions needed for led class devices, including:

* led::LedOps - the trait for handling leds, including brightness_set, brightness_get and blink_set

* led::DeviceBuilder - the builder for the led class device

* led::Device - a safe wrapper around led_classdev

---
 MAINTAINERS               |   8 ++
 rust/kernel/led.rs        | 288 ++++++++++++++++++++++++++++++++++++++++++++++
 rust/kernel/led/normal.rs | 230 ++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs        |   1 +
 4 files changed, 527 insertions(+)
MAINTAINERS +8 -0
index 806bd2d80d15..70989c4c693c 100644
@@ -14662,6 +14662,14 @@ F:	drivers/leds/
 F:	include/dt-bindings/leds/
 F:	include/linux/leds.h
 
+LED SUBSYSTEM [RUST]
+M:	Markus Probst <[email protected]>
+L:	[email protected]
+L:	[email protected]
+S:	Maintained
+F:	rust/kernel/led.rs
+F:	rust/kernel/led/
+
 LEGO MINDSTORMS EV3
 R:	David Lechner <[email protected]>
 S:	Maintained
rust/kernel/led.rs new file +288 -0

288 lines not on this page · raw message

rust/kernel/led/normal.rs new file +230 -0

230 lines not on this page · raw message

rust/kernel/lib.rs +1 -0
index 9512af7156df..09e4cc7a14db 100644
@@ -90,6 +90,7 @@
 pub mod jump_label;
 #[cfg(CONFIG_KUNIT)]
 pub mod kunit;
+pub mod led;
 pub mod list;
 pub mod maple_tree;
 pub mod miscdevice;
Signature · 1 line
2.54.0
#2 lore raw

Re: [PATCH v23 1/3] rust: leds: add basic led classdev abstractions

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [High] Incorrect lifecycle management of the `FwNode` reference count in `Device::drop` leads to…

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] Incorrect lifecycle management of the FwNode reference count in Device::drop leads to reference count underflow and Use-After-Free.
- [Medium] Lifetime erasure in DeviceBuilder::build allows a short-lived CStr to be used for the LED device name, resulting in a dangling pointer.
- [Low] Commit message format and naming convention violation for the LED subsystem.
--

--- Patch [1]: [PATCH v23 1/3] rust: leds: add basic led classdev abstractions --- commit e26d9a00db56264a527df58257bc8e40409dcdca
Author: Markus Probst <[email protected]>

rust: leds: add basic led classdev abstractions

Implement the core abstractions needed for led class devices, including LedOps, DeviceBuilder, and Device.

Quoted 1 line

rust: leds: add basic led classdev abstractions

[Severity: Low]
This isn't a bug, but the commit message violates the mandated subsystem format. Should it be capitalized after the subsystem prefix and ordered as "leds: rust: Add basic led classdev abstractions"?

Quoted 5 lines
rust/kernel/led/normal.rs new file +0 -0
new file mode 100644
index 0000000000000..816db7c576894

[ ... ]

Quoted 4 lines
rust/kernel/led/normal.rs new file +0 -0
@@ -33,26 +33,26 @@ impl<'init, S: DeviceBuilderState> DeviceBuilder<'init, S> {
                 unsafe {
                     ptr.write(bindings::led_classdev {
                         brightness_set: (!T::BLOCKING)

rust/kernel/led/normal.rs impl<'init, S: DeviceBuilderState> DeviceBuilder<'init, S> { · line 45

Quoted 10 lines
rust/kernel/led/normal.rs new file +0 -0
                             .then_some(Adapter::<T>::brightness_set_callback),
                         brightness_set_blocking: T::BLOCKING
                             .then_some(Adapter::<T>::brightness_set_blocking_callback),
                         brightness_get: T::HAS_BRIGHTNESS_GET
                             .then_some(Adapter::<T>::brightness_get_callback),
                         blink_set: T::HAS_BLINK_SET.then_some(Adapter::<T>::blink_set_callback),
                         max_brightness: T::MAX_BRIGHTNESS,
                         brightness: self.initial_brightness,
                         color: self.color as u32,
                         name: self.name.map_or(core::ptr::null(), CStrExt::as_char_ptr),

[Severity: Medium]
Does this code introduce a dangling pointer by erasing the lifetime of the name field?

The short-lived 'init lifetime on CStr is converted to a raw pointer and permanently stored in the led_classdev structure. The returned Device<'bound, T> entirely erases the 'init lifetime constraint.

This permits safe Rust code to pass a temporary CString, build the device, and drop the CString while the Device remains registered, leaving a dangling pointer in led_classdev.name.

Quoted 3 lines
rust/kernel/led/normal.rs new file +0 -0
                         ..bindings::led_classdev::default()
                     })
                 };

[ ... ]

Quoted 4 lines
rust/kernel/led/normal.rs new file +0 -0
@@ -211,20 +211,20 @@ impl<T: LedOps> Adapter<T> {
 #[pinned_drop]
 impl<'bound, T: LedOps + 'bound> PinnedDrop for Device<'bound, T> {
     fn drop(self: Pin<&mut Self>) {

rust/kernel/led/normal.rs impl<T: LedOps> Adapter<T> { · line 223

Quoted 10 lines
rust/kernel/led/normal.rs new file +0 -0
         let raw = self.classdev.get();
         // SAFETY: The existence of `self` guarantees that `self.classdev.get()` is a pointer to a
         // valid `led_classdev`.
         let dev: &device::Device = unsafe { device::Device::from_raw((*raw).dev) };
 
         let _fwnode = dev
             .fwnode()
             // SAFETY: the reference count of `fwnode` has previously been
             // incremented in `led::DeviceBuilder::build`.
             .map(|fwnode| unsafe { ARef::from_raw(NonNull::from(fwnode)) });

[Severity: High]
Does this lifecycle management of the FwNode reference count lead to an underflow and use-after-free?

If an LED device is built without explicitly providing a firmware node, self.fwnode is None. The device is then registered, and the kernel driver core invokes platform notifiers which can dynamically discover and bind a firmware node to the device.

Later, when the Rust Device is dropped, it unconditionally fetches the node via dev.fwnode(), converts it to an ARef, and drops it. Because Rust never incremented the refcount for this dynamically attached node, dropping the ARef performs an unbalanced decrement.

Would it be safer for the Device struct to explicitly store its own Option<ARef<FwNode>> instead of blindly trusting dev.fwnode()?

Quoted 6 lines
rust/kernel/led/normal.rs new file +0 -0
         // SAFETY: The existence of `self` guarantees that `self.classdev` has previously been
         // successfully registered with `led_classdev_register_ext`.
         unsafe { bindings::led_classdev_unregister(raw) };
     }
 }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#3 lore raw

PATCH v23 2/3 rust: leds: add Mode trait

In reply to Markus Probst

Add the led::Mode trait to allow for other types of led class devices in led::LedOps.

---
 rust/kernel/led.rs        | 27 +++++++++++++++++++++++----
 rust/kernel/led/normal.rs | 22 +++++++++++++++-------
 2 files changed, 38 insertions(+), 11 deletions(-)
rust/kernel/led.rs +23 -4
index 596975e103b8..5d7e6d08ad2a 100644
@@ -32,7 +32,10 @@
 
 mod normal;
 
-pub use normal::Device;
+pub use normal::{
+    Device,
+    Normal, //
+};
 
 /// The name of the led is determined by the driver.
 pub enum Named {}
@@ -161,6 +164,7 @@ pub fn name(self, name: &'init CStr) -> Self {
 /// #[vtable]
 /// impl led::LedOps for MyLedOps {
 ///     type Bus = platform::Device<device::Bound>;
+///     type Mode = led::Normal;
 ///     const BLOCKING: bool = false;
 ///     const MAX_BRIGHTNESS: u32 = 255;
 ///
@@ -182,6 +186,11 @@ pub trait LedOps: Send + Sync + Sized {
     #[allow(private_bounds)]
     type Bus: AsBusDevice<Bound>;
 
+    /// The led mode to use.
+    ///
+    /// See [`Mode`].
+    type Mode: Mode;
+
     /// If set true, [`LedOps::brightness_set`] and [`LedOps::blink_set`] must perform the
     /// operation immediately. If set false, they must not sleep.
     const BLOCKING: bool;
@@ -194,7 +203,7 @@ pub trait LedOps: Send + Sync + Sized {
     fn brightness_set<'bound>(
         &self,
         dev: &'bound Self::Bus,
-        classdev: &Device<'bound, Self>,
+        classdev: &<Self::Mode as Mode>::Device<'bound, Self>,
         brightness: u32,
     ) -> Result<()>;
 
@@ -202,7 +211,7 @@ fn brightness_set<'bound>(
     fn brightness_get<'bound>(
         &self,
         dev: &'bound Self::Bus,
-        classdev: &Device<'bound, Self>,
+        classdev: &<Self::Mode as Mode>::Device<'bound, Self>,
     ) -> Result<u32> {
         let _ = (dev, classdev);
         build_error!(VTABLE_DEFAULT_ERROR)
@@ -219,7 +228,7 @@ fn brightness_get<'bound>(
     fn blink_set<'bound>(
         &self,
         dev: &'bound Self::Bus,
-        classdev: &Device<'bound, Self>,
+        classdev: &<Self::Mode as Mode>::Device<'bound, Self>,
         delay_on: &mut usize,
         delay_off: &mut usize,
     ) -> Result<()> {
@@ -283,6 +292,16 @@ fn try_from(value: u32) -> core::result::Result<Self, Self::Error> {
     }
 }
 
+/// The led mode.
+///
+/// Each led mode has its own led class device type with different capabilities.
+///
+/// See [`Normal`].
+pub trait Mode: private::Sealed {
+    /// The class device for the led mode.
+    type Device<'bound, T: LedOps<Mode = Self> + 'bound>;
+}
+
 mod private {
     pub trait Sealed {}
 }
rust/kernel/led/normal.rs +15 -7
index 816db7c57689..25190486a62d 100644
@@ -6,11 +6,19 @@
 
 use super::*;
 
+/// The led mode for the `struct led_classdev`. Leds with this mode can only have a fixed color.
+pub enum Normal {}
+
+impl Mode for Normal {
+    type Device<'bound, T: LedOps<Mode = Self> + 'bound> = Device<'bound, T>;
+}
+impl private::Sealed for Normal {}
+
 /// The led class device representation.
 ///
 /// This structure represents the Rust abstraction for a led class device.
 #[pin_data(PinnedDrop)]
-pub struct Device<'bound, T: LedOps + 'bound> {
+pub struct Device<'bound, T: LedOps<Mode = Normal> + 'bound> {
     #[pin]
     ops: T,
     #[pin]
@@ -20,7 +28,7 @@ pub struct Device<'bound, T: LedOps + 'bound> {
 
 impl<'init, S: DeviceBuilderState> DeviceBuilder<'init, S> {
     /// Registers a new [`Device`].
-    pub fn build<'bound: 'init, T: LedOps + 'bound>(
+    pub fn build<'bound: 'init, T: LedOps<Mode = Normal> + 'bound>(
         self,
         parent: &'bound T::Bus,
         ops: impl PinInit<T, Error> + 'init,
@@ -87,7 +95,7 @@ pub fn build<'bound: 'init, T: LedOps + 'bound>(
     }
 }
 
-impl<'bound, T: LedOps + 'bound> Device<'bound, T> {
+impl<'bound, T: LedOps<Mode = Normal> + 'bound> Device<'bound, T> {
     /// # Safety
     /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a
     /// `led::Device`.
@@ -107,17 +115,17 @@ fn parent(&self) -> &'bound device::Device<Bound> {
 }
 
 // SAFETY: A `led::Device` can be unregistered from any thread.
-unsafe impl<'bound, T: LedOps + 'bound + Send> Send for Device<'bound, T> {}
+unsafe impl<'bound, T: LedOps<Mode = Normal> + 'bound + Send> Send for Device<'bound, T> {}
 
 // SAFETY: `led::Device` can be shared among threads because all methods of `led::Device`
 // are thread safe.
-unsafe impl<'bound, T: LedOps + 'bound + Sync> Sync for Device<'bound, T> {}
+unsafe impl<'bound, T: LedOps<Mode = Normal> + 'bound + Sync> Sync for Device<'bound, T> {}
 
 struct Adapter<T: LedOps> {
     _p: PhantomData<T>,
 }
 
-impl<T: LedOps> Adapter<T> {
+impl<T: LedOps<Mode = Normal>> Adapter<T> {
     /// # Safety
     /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a
     /// `led::Device`.
@@ -210,7 +218,7 @@ impl<T: LedOps> Adapter<T> {
 }
 
 #[pinned_drop]
-impl<'bound, T: LedOps + 'bound> PinnedDrop for Device<'bound, T> {
+impl<'bound, T: LedOps<Mode = Normal> + 'bound> PinnedDrop for Device<'bound, T> {
     fn drop(self: Pin<&mut Self>) {
         let raw = self.classdev.get();
         // SAFETY: The existence of `self` guarantees that `self.classdev.get()` is a pointer to a
Signature · 1 line
2.54.0
#4 lore raw

Re: [PATCH v23 2/3] rust: leds: add Mode trait

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] The commit message description is not capitalized. --

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The commit message description is not capitalized.
--

--- Patch [2]: [PATCH v23 2/3] rust: leds: add Mode trait --- commit 82637721450ea77b83de47ea809b8962d9011425
Author: Markus Probst <[email protected]>

rust: leds: add Mode trait

This commit introduces the led::Mode trait to allow different types of LED class devices to be used within led::LedOps.

Quoted 1 line

rust: leds: add Mode trait

[Severity: Low]
This isn't a bug, but the commit message description is not capitalized. According to the LED subsystem guidelines, the description following the subsystem prefix must always be capitalized. Could the subject be updated to "rust: leds: Add Mode trait" to match standard naming conventions?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
#5 lore raw

PATCH v23 3/3 rust: leds: add multicolor classdev abstractions

In reply to Markus Probst

Implement the abstractions needed for multicolor led class devices, including:

* led::MultiColor - the led mode implementation

* MultiColorSubLed - a safe wrapper arround mc_subled

* led::MultiColorDevice - a safe wrapper around led_classdev_mc

* led::DeviceBuilder::build_multicolor - a function to register a new multicolor led class device

---
 rust/bindings/bindings_helper.h |   1 +
 rust/kernel/led.rs              |  34 ++-
 rust/kernel/led/multicolor.rs   | 460 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 494 insertions(+), 1 deletion(-)
rust/bindings/bindings_helper.h +1 -0
index 1124785e210b..821f539e597e 100644
@@ -68,6 +68,7 @@
 #include <linux/iosys-map.h>
 #include <linux/jiffies.h>
 #include <linux/jump_label.h>
+#include <linux/led-class-multicolor.h>
 #include <linux/mdio.h>
 #include <linux/mm.h>
 #include <linux/miscdevice.h>
rust/kernel/led.rs +33 -1
index 5d7e6d08ad2a..3aa7cdde78f4 100644
@@ -30,8 +30,16 @@
     types::Opaque, //
 };
 
+#[cfg(CONFIG_LEDS_CLASS_MULTICOLOR)]
+mod multicolor;
 mod normal;
 
+#[cfg(CONFIG_LEDS_CLASS_MULTICOLOR)]
+pub use multicolor::{
+    MultiColor,
+    MultiColorDevice,
+    MultiColorSubLed, //
+};
 pub use normal::{
     Device,
     Normal, //
@@ -255,7 +263,24 @@ pub enum Color {
     Violet = bindings::LED_COLOR_ID_VIOLET,
     Yellow = bindings::LED_COLOR_ID_YELLOW,
     Ir = bindings::LED_COLOR_ID_IR,
+    #[cfg_attr(
+        CONFIG_LEDS_CLASS_MULTICOLOR,
+        doc = "Use this color for a [`MultiColor`] led."
+    )]
+    #[cfg_attr(
+        not(CONFIG_LEDS_CLASS_MULTICOLOR),
+        doc = "Use this color for a `MultiColor` led."
+    )]
+    /// If the led supports RGB, use [`Color::Rgb`] instead.
     Multi = bindings::LED_COLOR_ID_MULTI,
+    #[cfg_attr(
+        CONFIG_LEDS_CLASS_MULTICOLOR,
+        doc = "Use this color for a [`MultiColor`] led with rgb support."
+    )]
+    #[cfg_attr(
+        not(CONFIG_LEDS_CLASS_MULTICOLOR),
+        doc = "Use this color for a `MultiColor` led with rgb support."
+    )]
     Rgb = bindings::LED_COLOR_ID_RGB,
     Purple = bindings::LED_COLOR_ID_PURPLE,
     Orange = bindings::LED_COLOR_ID_ORANGE,
@@ -296,7 +321,14 @@ fn try_from(value: u32) -> core::result::Result<Self, Self::Error> {
 ///
 /// Each led mode has its own led class device type with different capabilities.
 ///
-/// See [`Normal`].
+#[cfg_attr(
+    CONFIG_LEDS_CLASS_MULTICOLOR,
+    doc = "See [`Normal`] and [`MultiColor`]."
+)]
+#[cfg_attr(
+    not(CONFIG_LEDS_CLASS_MULTICOLOR),
+    doc = "See [`Normal`] and `MultiColor`."
+)]
 pub trait Mode: private::Sealed {
     /// The class device for the led mode.
     type Device<'bound, T: LedOps<Mode = Self> + 'bound>;
rust/kernel/led/multicolor.rs new file +460 -0

460 lines not on this page · raw message

Signature · 1 line
2.54.0
#6 lore raw

Re: [PATCH v23 3/3] rust: leds: add multicolor classdev abstractions

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] Safe methods `brightness()` and `intensity()` in `MultiColorSubLed` perform non-synchronized plain…

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] Safe methods brightness() and intensity() in MultiColorSubLed perform non-synchronized plain reads of an UnsafeCell, causing Undefined Behavior due to data races with concurrent C subsystem modifications.
- [High] Fragile fwnode reference management in DeviceBuilder::build_multicolor and MultiColorDevice::drop causes ARef<FwNode> leaks or invalid refcount decrements.
--

--- Patch [3]: [PATCH v23 3/3] rust: leds: add multicolor classdev abstractions --- commit 6c4e554be24453ed9f19eef4d69cdcd8cacfc0d1
Author: Markus Probst <[email protected]>

rust: leds: add multicolor classdev abstractions

Implement the abstractions needed for multicolor led class devices, including MultiColor, MultiColorSubLed, MultiColorDevice, and DeviceBuilder::build_multicolor to register new class devices.

Quoted 5 lines
rust/kernel/led/multicolor.rs new file +0 -0
new file mode 100644
index 0000000000000..82fe96fd5273b

[ ... ]

rust/kernel/led/multicolor.rs line 142

Quoted 8 lines
rust/kernel/led/multicolor.rs new file +8 -0
+    /// The intensity of the sub led.
+    #[inline]
+    pub const fn intensity(&self) -> u32 {
+        // SAFETY:
+        // - self.intensity.get() is a valid pointer to u32.
+        // - We don't have exclusive or immutable access to self.intensity,
+        //   but the alignment should prevent "load tearing".
+        unsafe { *self.intensity.get() }

[Severity: High]
Does this unsynchronized plain load introduce a data race? If a driver calls this safe method from an interrupt handler or background thread while the C subsystem concurrently updates the value via sysfs (which holds a C mutex the Rust side does not take), could this trigger undefined behavior?

rust/kernel/led/multicolor.rs line 152

Quoted 10 lines
rust/kernel/led/multicolor.rs new file +10 -0
+    }
+
+    /// The brightness of the sub led.
+    #[inline]
+    pub const fn brightness(&self) -> u32 {
+        // SAFETY:
+        // - self.brightness.get() is a valid pointer to u32.
+        // - We don't have exclusive or immutable access to self.brightness,
+        //   but the alignment should prevent "load tearing".
+        unsafe { *self.brightness.get() }

[Severity: High]
Similarly, could reading brightness() here cause undefined behavior due to concurrent sysfs modifications?

[ ... ]

Quoted 9 lines
rust/kernel/led/multicolor.rs new file +9 -0
+                // SAFETY:
+                // - parent.as_ref().as_raw() is guaranteed to be a pointer to a valid
+                //    device.
+                // - ptr is guaranteed to be a pointer to an initialized led_classdev_mc.
+                to_result(unsafe {
+                    bindings::led_classdev_multicolor_register_ext(
+                        parent.as_ref().as_raw(),
+                        ptr,
+                        if self.name.is_none() {

rust/kernel/led/multicolor.rs line 258

Quoted 10 lines
rust/kernel/led/multicolor.rs new file +10 -0
+                            &raw mut init_data
+                        } else {
+                            core::ptr::null_mut()
+                        },
+                    )
+                })?;
+
+                subled_guard.dismiss();
+
+                core::mem::forget(self.fwnode); // keep the reference count incremented

[Severity: High]
Does this unconditionally leak the fwnode reference when self.name is set?

If self.name is Some, the C registration function is passed a NULL pointer for init_data, meaning the device fwnode is never set. By calling forget() unconditionally here, the reference count is incremented but the fwnode is not stored in the C device, which might permanently leak the reference.

[ ... ]

rust/kernel/led/multicolor.rs line 438

Quoted 13 lines
rust/kernel/led/multicolor.rs new file +13 -0
+#[pinned_drop]
+impl<'bound, T: LedOps<Mode = MultiColor> + 'bound> PinnedDrop for MultiColorDevice<'bound, T> {
+    fn drop(self: Pin<&mut Self>) {
+        let raw = self.classdev.get();
+        // SAFETY: The existence of self guarantees that self.classdev.get() is a pointer to a
+        // valid led_classdev_mc.
+        let dev: &device::Device = unsafe { device::Device::from_raw((*raw).led_cdev.dev) };
+
+        let _fwnode = dev
+            .fwnode()
+            // SAFETY: the reference count of fwnode has previously been
+            // incremented in led::DeviceBuilder::build_multicolor.
+            .map(|fwnode| unsafe { ARef::from_raw(NonNull::from(fwnode)) });

[Severity: High]
Can this cause a use-after-free or double-free on an unrelated fwnode?

If self.fwnode was None during builder initialization, but the C subsystem later assigns an unrelated fwnode to the device, it seems this code would incorrectly wrap it in an ARef and decrement its refcount.

Alternatively, if dev.fwnode() returns None because init_data was NULL earlier, the previously forgotten fwnode refcount is never decremented, leaking it. It appears this same pattern may also affect normal device builders.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3