| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20251008181027.662616-4-markus.probst@posteo.de>
Date: Wed, 08 Oct 2025 18:10:47 +0000
From: Markus Probst <markus.probst@...teo.de>
To: Lee Jones <lee@...nel.org>,
Pavel Machek <pavel@...nel.org>,
Danilo Krummrich <dakr@...nel.org>,
Miguel Ojeda <ojeda@...nel.org>,
Alex Gaynor <alex.gaynor@...il.com>,
Igor Korotin <igor.korotin.linux@...il.com>
Cc: Markus Probst <markus.probst@...teo.de>,
Lorenzo Stoakes <lorenzo.stoakes@...cle.com>,
Vlastimil Babka <vbabka@...e.cz>,
"Liam R. Howlett" <Liam.Howlett@...cle.com>,
Uladzislau Rezki <urezki@...il.com>,
Boqun Feng <boqun.feng@...il.com>,
Gary Guo <gary@...yguo.net>,
bjorn3_gh@...tonmail.com,
Benno Lossin <lossin@...nel.org>,
Andreas Hindborg <a.hindborg@...nel.org>,
Alice Ryhl <aliceryhl@...gle.com>,
Trevor Gross <tmgross@...ch.edu>,
Daniel Almeida <daniel.almeida@...labora.com>,
linux-leds@...r.kernel.org,
rust-for-linux@...r.kernel.org,
linux-kernel@...r.kernel.org
Subject: [PATCH 3/4] rust: leds: add basic led classdev abstractions
Implement the core abstractions needed for led class devices, including:
* `led::LedHandler` - the trait for handling leds, including
`brightness_set`
* `led::LedInitData` - data set for the led class device
* `led::LedClassDev` - a safe wrapper arround `led_classdev`
Signed-off-by: Markus Probst <markus.probst@...teo.de>
---
rust/kernel/led.rs | 299 +++++++++++++++++++++++++++++++++++++++++++++
rust/kernel/lib.rs | 1 +
2 files changed, 300 insertions(+)
create mode 100644 rust/kernel/led.rs
diff --git a/rust/kernel/led.rs b/rust/kernel/led.rs
new file mode 100644
index 000000000000..14f09a2c8c3b
--- /dev/null
+++ b/rust/kernel/led.rs
@@ -0,0 +1,299 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Abstractions for the leds driver model.
+//!
+//! C header: [`include/linux/leds.h`](srctree/include/linux/leds.h)
+
+use core::pin::Pin;
+
+use pin_init::{pin_data, pinned_drop, PinInit};
+
+use crate::{
+ alloc::KBox,
+ container_of,
+ device::{property::FwNode, Device},
+ error::{code::EINVAL, from_result, to_result, Error, Result},
+ prelude::GFP_KERNEL,
+ str::{CStr, CString},
+ try_pin_init,
+ types::{ARef, Opaque},
+};
+
+/// The led class device representation.
+///
+/// This structure represents the Rust abstraction for a C `struct led_classdev`.
+#[pin_data(PinnedDrop)]
+pub struct LedClassDev {
+ default_trigger: Option<CString>,
+ parent: Option<ARef<Device>>,
+ handler: KBox<dyn LedHandlerImpl>,
+ #[pin]
+ classdev: Opaque<bindings::led_classdev>,
+}
+
+/// The led init data representation.
+///
+/// This structure represents the Rust abstraction for a C `struct led_init_data`.
+#[derive(Default)]
+pub struct LedInitData<'a> {
+ fwnode: Option<&'a FwNode>,
+ default_label: Option<&'a CStr>,
+ devicename: Option<&'a CStr>,
+ devname_mandatory: bool,
+}
+
+impl LedInitData<'static> {
+ /// Creates a new [`LedInitData`]
+ pub fn new() -> Self {
+ Self::default()
+ }
+}
+
+impl<'a> LedInitData<'a> {
+ /// Sets the firmware node
+ pub fn fwnode<'b, 'c>(self, fwnode: &'b FwNode) -> LedInitData<'c>
+ where
+ 'a: 'c,
+ 'b: 'c,
+ {
+ LedInitData {
+ fwnode: Some(fwnode),
+ ..self
+ }
+ }
+
+ /// Sets a default label
+ pub fn default_label<'b, 'c>(self, label: &'b CStr) -> LedInitData<'c>
+ where
+ 'a: 'c,
+ 'b: 'c,
+ {
+ LedInitData {
+ default_label: Some(label),
+ ..self
+ }
+ }
+
+ /// Sets the device name
+ pub fn devicename<'b, 'c>(self, devicename: &'b CStr) -> LedInitData<'c>
+ where
+ 'a: 'c,
+ 'b: 'c,
+ {
+ LedInitData {
+ devicename: Some(devicename),
+ ..self
+ }
+ }
+
+ /// Sets if a device name is mandatory
+ pub fn devicename_mandatory(self, mandatory: bool) -> Self {
+ Self {
+ devname_mandatory: mandatory,
+
+ ..self
+ }
+ }
+}
+
+/// The led handler trait.
+///
+/// # Examples
+///
+///```
+/// # use kernel::{c_str, led, alloc::KBox, error::{Result, code::ENOSYS}};
+/// # use core::pin::Pin;
+///
+/// struct MyHandler;
+///
+///
+/// impl led::LedHandler for MyHandler {
+/// const BLOCKING = false;
+/// const MAX_BRIGHTNESS = 255;
+///
+/// fn brightness_set(&self, _brightness: u32) -> Result<()> {
+/// // Set the brightness for the led here
+/// Ok(())
+/// }
+/// }
+///
+/// fn register_my_led() -> Result<Pin<KBox<led::LedClassDev>>> {
+/// let handler = MyHandler;
+/// KBox::pin_init(led::LedClassDev::new(
+/// None,
+/// None,
+/// led::LedInitData::new()
+/// .default_label(c_str!("my_led")),
+/// handler,
+/// ))
+/// }
+///```
+/// Led drivers must implement this trait in order to register and handle a [`LedClassDev`].
+pub trait LedHandler {
+ /// If set true, [`LedHandler::brightness_set`] and [`LedHandler::blink_set`] must not sleep
+ /// and perform the operation immediately.
+ const BLOCKING: bool;
+ /// Set this to true, if [`LedHandler::blink_set`] is implemented.
+ const BLINK: bool = false;
+ /// The max brightness level
+ const MAX_BRIGHTNESS: u32;
+
+ /// Sets the brightness level
+ ///
+ /// See also [`LedHandler::BLOCKING`]
+ fn brightness_set(&self, brightness: u32) -> Result<()>;
+
+ /// Activates hardware accelerated blinking.
+ ///
+ /// delays are in milliseconds. If both are zero, a sensible default should be chosen.
+ /// The caller should adjust the timings in that case and if it can't match the values
+ /// specified exactly. Setting the brightness to 0 will disable the hardware accelerated
+ /// blinking.
+ ///
+ /// See also [`LedHandler::BLOCKING`]
+ fn blink_set(&self, _delay_on: &mut usize, _delay_off: &mut usize) -> Result<()> {
+ Err(EINVAL)
+ }
+}
+
+trait LedHandlerImpl {
+ fn brightness_set(&self, brightness: u32) -> Result<()>;
+ fn blink_set(&self, delay_on: &mut usize, delay_off: &mut usize) -> Result<()>;
+}
+
+impl<T: LedHandler> LedHandlerImpl for T {
+ fn brightness_set(&self, brightness: u32) -> Result<()> {
+ T::brightness_set(self, brightness)
+ }
+
+ fn blink_set(&self, delay_on: &mut usize, delay_off: &mut usize) -> Result<()> {
+ T::blink_set(self, delay_on, delay_off)
+ }
+}
+
+// SAFETY: A `LedClassDev` can be unregistered from any thread.
+unsafe impl Send for LedClassDev {}
+
+// SAFETY: `LedClassDev` can be shared among threads because all methods of `LedClassDev`
+// are thread safe.
+unsafe impl Sync for LedClassDev {}
+
+impl LedClassDev {
+ /// Registers a new led classdev.
+ ///
+ /// The [`LedClassDev`] will be unregistered and drop.
+ pub fn new<'a, T: LedHandler + 'static>(
+ parent: Option<&Device>,
+ default_trigger: Option<CString>,
+ init_data: LedInitData<'a>,
+ handler: T,
+ ) -> impl PinInit<Self, Error> + use<'a, T> {
+ let parent_ptr = parent.map_or(core::ptr::null_mut(), Device::as_raw);
+ let parent = parent.map(ARef::from);
+ try_pin_init!(Self {
+ default_trigger,
+ parent,
+ handler <- {
+ let handler: KBox<dyn LedHandlerImpl> = KBox::<T>::new(handler, GFP_KERNEL)?;
+ Ok::<_, Error>(handler)
+ },
+ classdev <- Opaque::try_ffi_init(|ptr: *mut bindings::led_classdev| {
+ // SAFETY: `try_ffi_init` guarantees that `ptr` is valid for write.
+ unsafe { ptr.write(bindings::led_classdev {
+ max_brightness: T::MAX_BRIGHTNESS,
+ brightness_set: T::BLOCKING.then_some(
+ brightness_set as unsafe extern "C" fn(*mut bindings::led_classdev, u32)
+ ),
+ brightness_set_blocking: (!T::BLOCKING).then_some(
+ brightness_set_blocking
+ as unsafe extern "C" fn(*mut bindings::led_classdev,u32) -> i32
+ ),
+ blink_set: T::BLINK.then_some(
+ blink_set
+ as unsafe extern "C" fn(*mut bindings::led_classdev, *mut usize,
+ *mut usize) -> i32
+ ),
+ .. bindings::led_classdev::default()
+ }) };
+
+ let mut init_data = bindings::led_init_data {
+ fwnode: init_data.fwnode.map_or(core::ptr::null_mut(), FwNode::as_raw),
+ default_label: init_data.default_label
+ .map_or(core::ptr::null(), CStr::as_char_ptr),
+ devicename: init_data.devicename.map_or(core::ptr::null(), CStr::as_char_ptr),
+ devname_mandatory: init_data.devname_mandatory,
+ };
+ // SAFETY:
+ // - `parent_ptr` is guaranteed to be a pointer to a valid `device`
+ // or a null pointer.
+ // - `ptr` is guaranteed to be a pointer to an initialized `led_classdev`.
+ to_result(unsafe {
+ bindings::led_classdev_register_ext(parent_ptr, ptr, &mut init_data)
+ })
+ }),
+ })
+ }
+}
+
+extern "C" fn brightness_set(led_cdev: *mut bindings::led_classdev, brightness: u32) {
+ // SAFETY: `led_cdev` is a valid pointer to a `led_classdev` stored inside a `LedClassDev`.
+ let classdev = unsafe {
+ &*container_of!(
+ led_cdev.cast::<Opaque<bindings::led_classdev>>(),
+ LedClassDev,
+ classdev
+ )
+ };
+ let _ = classdev.handler.brightness_set(brightness);
+}
+
+extern "C" fn brightness_set_blocking(
+ led_cdev: *mut bindings::led_classdev,
+ brightness: u32,
+) -> i32 {
+ // SAFETY: `led_cdev` is a valid pointer to a `led_classdev` stored inside a `LedClassDev`.
+ let classdev = unsafe {
+ &*container_of!(
+ led_cdev.cast::<Opaque<bindings::led_classdev>>(),
+ LedClassDev,
+ classdev
+ )
+ };
+ from_result(|| {
+ classdev.handler.brightness_set(brightness)?;
+ Ok(0)
+ })
+}
+
+extern "C" fn blink_set(
+ led_cdev: *mut bindings::led_classdev,
+ delay_on: *mut usize,
+ delay_off: *mut usize,
+) -> i32 {
+ // SAFETY: `led_cdev` is a valid pointer to a `led_classdev` stored inside a `LedClassDev`.
+ let classdev = unsafe {
+ &*container_of!(
+ led_cdev.cast::<Opaque<bindings::led_classdev>>(),
+ LedClassDev,
+ classdev
+ )
+ };
+ from_result(|| {
+ classdev.handler.blink_set(
+ // SAFETY: `delay_on` is guaranteed to be a valid pointer to usize
+ unsafe { &mut *delay_on },
+ // SAFETY: `delay_on` is guaranteed to be a valid pointer to usize
+ unsafe { &mut *delay_off },
+ )?;
+ Ok(0)
+ })
+}
+
+#[pinned_drop]
+impl PinnedDrop for LedClassDev {
+ fn drop(self: Pin<&mut Self>) {
+ // SAFETY: The existence of `self` guarantees that `self.classdev` has previously been
+ // successfully registered with `led_classdev_register_ext`
+ unsafe { bindings::led_classdev_unregister(self.classdev.get()) };
+ }
+}
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index e5247f584ad2..f42c60da21ae 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -97,6 +97,7 @@
pub mod jump_label;
#[cfg(CONFIG_KUNIT)]
pub mod kunit;
+pub mod led;
pub mod list;
pub mod miscdevice;
pub mod mm;
--
2.49.1
Powered by blists - more mailing lists