[PATCH 8/8] rust: samples: Add debugfs sample

Matthew Maurer
2025-04-29T23:16:10Z

Provides an example of using the Rust DebugFS bindings.

Signed-off-by: Matthew Maurer <mmaurer@google.com>
---
MAINTAINERS | 1 +
samples/rust/Kconfig | 11 ++++
samples/rust/Makefile | 1 +
samples/rust/rust_debugfs.rs | 120 +++++++++++++++++++++++++++++++++++++++++++
4 files changed, 133 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index a3b835e427b083a4ddd690d9e7739851f0af47ae..426bcdac025134e20911de8e2cf5c9efb0591814 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -7278,6 +7278,7 @@ F: rust/kernel/devres.rs
F: rust/kernel/driver.rs
F: rust/kernel/faux.rs
F: rust/kernel/platform.rs
+F: samples/rust/rust_debugfs.rs
F: samples/rust/rust_driver_platform.rs
F: samples/rust/rust_driver_faux.rs

diff --git a/samples/rust/Kconfig b/samples/rust/Kconfig
index 43cb72d72631bb2d6e06185e1d88778edff6ee13..6c42ed73f842cda26256039e6917bb443738d3f1 100644
--- a/samples/rust/Kconfig
+++ b/samples/rust/Kconfig
@@ -51,6 +51,17 @@ config SAMPLE_RUST_DMA

If unsure, say N.

+config SAMPLE_RUST_DEBUGFS
+ tristate "DebugFS Test Driver"
+ depends on DEBUG_FS
+ help
+ This option builds the Rust DebugFS Test driver sample.
+
+ To compile this as a module, choose M here:
+ the module will be called rust_debugfs.
+
+ If unsure, say N.
+
config SAMPLE_RUST_DRIVER_PCI
tristate "PCI Driver"
depends on PCI
diff --git a/samples/rust/Makefile b/samples/rust/Makefile
index 6a466afd2a21eba84a3b7b2be29f25dce44e9053..b1fc4677ed53fcf7d0f5a3dbf322f65851bc1784 100644
--- a/samples/rust/Makefile
+++ b/samples/rust/Makefile
@@ -4,6 +4,7 @@ ccflags-y += -I$(src) # needed for trace events
obj-$(CONFIG_SAMPLE_RUST_MINIMAL) += rust_minimal.o
obj-$(CONFIG_SAMPLE_RUST_MISC_DEVICE) += rust_misc_device.o
obj-$(CONFIG_SAMPLE_RUST_PRINT) += rust_print.o
+obj-$(CONFIG_SAMPLE_RUST_DEBUGFS) += rust_debugfs.o
obj-$(CONFIG_SAMPLE_RUST_DMA) += rust_dma.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_PCI) += rust_driver_pci.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_PLATFORM) += rust_driver_platform.o
diff --git a/samples/rust/rust_debugfs.rs b/samples/rust/rust_debugfs.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3fd25848f2d096b03fa70679103bd725d0e42fcf
--- /dev/null
+++ b/samples/rust/rust_debugfs.rs
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-2.0
+
+// Copyright (C) 2025 Google LLC.
+
+//! Sample DebugFS exporting module
+
+use core::fmt;
+use core::fmt::{Display, Formatter};
+use core::sync::atomic::{AtomicU32, Ordering};
+use kernel::c_str;
+use kernel::debugfs::{Builder, Dir, Values};
+use kernel::debugfs_fmt_file;
+use kernel::new_mutex;
+use kernel::prelude::*;
+use kernel::sync::{Arc, Mutex};
+
+module! {
+ type: RustDebugFs,
+ name: "rust_debugfs",
+ authors: ["Matthew Maurer"],
+ description: "Rust DebugFS usage sample",
+ license: "GPL",
+}
+
+struct RustDebugFs {
+ _debugfs: Pin<KBox<Values<Backing>>>,
+}
+
+struct Composite {
+ major: u32,
+ minor: u32,
+}
+
+impl Display for Composite {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ write!(f, "{}.{}", self.major, self.minor)
+ }
+}
+
+struct Record {
+ name: &'static CStr,
+ size: usize,
+ stride: usize,
+}
+
+struct Backing {
+ simple: u32,
+ composite: Composite,
+ custom: u32,
+ many: KVec<Record>,
+ atomic: AtomicU32,
+ locked: Arc<Mutex<u32>>,
+}
+
+impl Backing {
+ fn new() -> Result<Self> {
+ let mut many = KVec::new();
+ many.push(
+ Record {
+ name: c_str!("foo"),
+ size: 1,
+ stride: 2,
+ },
+ GFP_KERNEL,
+ )?;
+ many.push(
+ Record {
+ name: c_str!("bar"),
+ size: 3,
+ stride: 4,
+ },
+ GFP_KERNEL,
+ )?;
+ Ok(Self {
+ simple: 10,
+ composite: Composite { major: 1, minor: 2 },
+ custom: 37,
+ many,
+ atomic: AtomicU32::new(7),
+ locked: Arc::pin_init(new_mutex!(0), GFP_KERNEL)?,
+ })
+ }
+ fn build<'a>(&'a self, builder: Builder<'a>) -> Result<()> {
+ builder.display_file(c_str!("simple"), &self.simple)?;
+ builder.display_file(c_str!("composite"), &self.composite)?;
+ debugfs_fmt_file!(
+ builder,
+ c_str!("custom"),
+ &self.custom,
+ "Foo! {:#010x} Bar!\n"
+ )?;
+ for record in self.many.iter() {
+ let dir = builder.dir(record.name)?;
+ dir.display_file(c_str!("size"), &record.size)?;
+ dir.display_file(c_str!("stride"), &record.stride)?;
+ }
+ builder.fmt_file(c_str!("atomic"), &self.atomic, &|atomic, f| {
+ write!(f, "{}\n", atomic.load(Ordering::Relaxed))
+ })?;
+ builder.fmt_file(c_str!("locked"), &self.locked, &|locked, f| {
+ write!(f, "{}\n", *locked.lock())
+ })?;
+ Ok(())
+ }
+}
+
+impl kernel::Module for RustDebugFs {
+ fn init(_this: &'static ThisModule) -> Result<Self> {
+ let dir = Dir::new(c_str!("sample_debugfs"), None)?;
+ let backing = Backing::new()?;
+ let locked = backing.locked.clone();
+ let debugfs = KBox::pin_init(Values::attach(backing, dir), GFP_KERNEL)?;
+ debugfs.as_ref().build(Backing::build)?;
+ // These mutations could occur at any time in the future, and would remain visible through
+ // debugfs.
+ debugfs.as_ref().atomic.store(8, Ordering::Relaxed);
+ *locked.lock() = 42;
+ Ok(Self { _debugfs: debugfs })
+ }
+}

--
2.49.0.901.g37484f566f-goog