[PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[Boqun Feng]

Rust native atomics are not supposed to be used in kernel due to the
mismatch of memory model, since we now have the LKMM atomics in Rust,
remove the usage of Rust native atomics in debugfs.

(help is appreciated if anyone wants to help in other subsystem)

Boqun Feng (3):
  rust: sync: atomic: Make Atomic*Ops pub(crate)
  rust: sync: atomic: Implement Debug for Atomic<Debug>
  rust: debugfs: Replace the usage of Rust native atomics

 rust/kernel/debugfs/traits.rs       | 53 +++++++++--------------------
 rust/kernel/sync/atomic.rs          | 12 ++++++-
 samples/rust/rust_debugfs.rs        | 12 +++----
 samples/rust/rust_debugfs_scoped.rs |  6 ++--
 4 files changed, 36 insertions(+), 47 deletions(-)

-- 
2.51.0

[PATCH 1/3] rust: sync: atomic: Make Atomic*Ops pub(crate)

[Boqun Feng]

In order to write code over a generate Atomic<T> we need to make
Atomic*Ops public so that functions like `.load()` and `.store()` are
available. Make these pub(crate) at the beginning so the usage in kernel
crate is supported.

Signed-off-by: Boqun Feng <boqun.feng@gmail.com>
---
 rust/kernel/sync/atomic.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rust/kernel/sync/atomic.rs b/rust/kernel/sync/atomic.rs
index 016a6bcaf080..0bc6e7b04d67 100644
--- a/rust/kernel/sync/atomic.rs
+++ b/rust/kernel/sync/atomic.rs
@@ -22,9 +22,10 @@
 
 pub use internal::AtomicImpl;
 pub use ordering::{Acquire, Full, Relaxed, Release};
+pub(crate) use internal::{AtomicArithmeticOps, AtomicBasicOps, AtomicExchangeOps};
 
 use crate::build_error;
-use internal::{AtomicArithmeticOps, AtomicBasicOps, AtomicExchangeOps, AtomicRepr};
+use internal::AtomicRepr;
 use ordering::OrderingType;
 
 /// A memory location which can be safely modified from multiple execution contexts.
-- 
2.51.0

[PATCH 2/3] rust: sync: atomic: Implement Debug for Atomic<Debug>

[Boqun Feng]

If `Atomic<T>` is `Debug` then it's a `debugfs::Writer`, therefore make
it so since 1) debugfs needs to support `Atomic<T>` and 2) it's rather
trivial to implement `Debug` for `Atomic<Debug>`.

Signed-off-by: Boqun Feng <boqun.feng@gmail.com>
---
 rust/kernel/sync/atomic.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/rust/kernel/sync/atomic.rs b/rust/kernel/sync/atomic.rs
index 0bc6e7b04d67..3afc376be42d 100644
--- a/rust/kernel/sync/atomic.rs
+++ b/rust/kernel/sync/atomic.rs
@@ -307,6 +307,15 @@ pub fn store<Ordering: ordering::ReleaseOrRelaxed>(&self, v: T, _: Ordering) {
     }
 }
 
+impl<T: AtomicType + core::fmt::Debug> core::fmt::Debug for Atomic<T>
+where
+    T::Repr: AtomicBasicOps,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(&self.load(Relaxed), f)
+    }
+}
+
 impl<T: AtomicType> Atomic<T>
 where
     T::Repr: AtomicExchangeOps,
-- 
2.51.0

[PATCH 3/3] rust: debugfs: Replace the usage of Rust native atomics

[Boqun Feng]

Rust native atomics are not allowed to use in kernel due to the mismatch
of memory model with Linux kernel memory model, hence remove the usage
of Rust native atomics in debufs.

Signed-off-by: Boqun Feng <boqun.feng@gmail.com>
---
 rust/kernel/debugfs/traits.rs       | 53 +++++++++--------------------
 samples/rust/rust_debugfs.rs        | 12 +++----
 samples/rust/rust_debugfs_scoped.rs |  6 ++--
 3 files changed, 25 insertions(+), 46 deletions(-)

diff --git a/rust/kernel/debugfs/traits.rs b/rust/kernel/debugfs/traits.rs
index ab009eb254b3..1bcfb3b3dd2f 100644
--- a/rust/kernel/debugfs/traits.rs
+++ b/rust/kernel/debugfs/traits.rs
@@ -4,14 +4,11 @@
 //! Traits for rendering or updating values exported to DebugFS.
 
 use crate::prelude::*;
+use crate::sync::atomic::{Atomic, AtomicBasicOps, AtomicType, Relaxed};
 use crate::sync::Mutex;
 use crate::uaccess::UserSliceReader;
 use core::fmt::{self, Debug, Formatter};
 use core::str::FromStr;
-use core::sync::atomic::{
-    AtomicI16, AtomicI32, AtomicI64, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU64,
-    AtomicU8, AtomicUsize, Ordering,
-};
 
 /// A trait for types that can be written into a string.
 ///
@@ -66,37 +63,21 @@ fn read_from_slice(&self, reader: &mut UserSliceReader) -> Result {
     }
 }
 
-macro_rules! impl_reader_for_atomic {
-    ($(($atomic_type:ty, $int_type:ty)),*) => {
-        $(
-            impl Reader for $atomic_type {
-                fn read_from_slice(&self, reader: &mut UserSliceReader) -> Result {
-                    let mut buf = [0u8; 21]; // Enough for a 64-bit number.
-                    if reader.len() > buf.len() {
-                        return Err(EINVAL);
-                    }
-                    let n = reader.len();
-                    reader.read_slice(&mut buf[..n])?;
+impl<T: AtomicType + FromStr> Reader for Atomic<T>
+where
+    T::Repr: AtomicBasicOps,
+{
+    fn read_from_slice(&self, reader: &mut UserSliceReader) -> Result {
+        let mut buf = [0u8; 21]; // Enough for a 64-bit number.
+        if reader.len() > buf.len() {
+            return Err(EINVAL);
+        }
+        let n = reader.len();
+        reader.read_slice(&mut buf[..n])?;
 
-                    let s = core::str::from_utf8(&buf[..n]).map_err(|_| EINVAL)?;
-                    let val = s.trim().parse::<$int_type>().map_err(|_| EINVAL)?;
-                    self.store(val, Ordering::Relaxed);
-                    Ok(())
-                }
-            }
-        )*
-    };
+        let s = core::str::from_utf8(&buf[..n]).map_err(|_| EINVAL)?;
+        let val = s.trim().parse::<T>().map_err(|_| EINVAL)?;
+        self.store(val, Relaxed);
+        Ok(())
+    }
 }
-
-impl_reader_for_atomic!(
-    (AtomicI16, i16),
-    (AtomicI32, i32),
-    (AtomicI64, i64),
-    (AtomicI8, i8),
-    (AtomicIsize, isize),
-    (AtomicU16, u16),
-    (AtomicU32, u32),
-    (AtomicU64, u64),
-    (AtomicU8, u8),
-    (AtomicUsize, usize)
-);
diff --git a/samples/rust/rust_debugfs.rs b/samples/rust/rust_debugfs.rs
index 82b61a15a34b..711faa07bece 100644
--- a/samples/rust/rust_debugfs.rs
+++ b/samples/rust/rust_debugfs.rs
@@ -32,14 +32,12 @@
 //! ```
 
 use core::str::FromStr;
-use core::sync::atomic::AtomicUsize;
-use core::sync::atomic::Ordering;
 use kernel::c_str;
 use kernel::debugfs::{Dir, File};
 use kernel::new_mutex;
 use kernel::prelude::*;
+use kernel::sync::atomic::{Atomic, Relaxed};
 use kernel::sync::Mutex;
-
 use kernel::{acpi, device::Core, of, platform, str::CString, types::ARef};
 
 kernel::module_platform_driver! {
@@ -59,7 +57,7 @@ struct RustDebugFs {
     #[pin]
     _compatible: File<CString>,
     #[pin]
-    counter: File<AtomicUsize>,
+    counter: File<Atomic<usize>>,
     #[pin]
     inner: File<Mutex<Inner>>,
 }
@@ -109,7 +107,7 @@ fn probe(
     ) -> Result<Pin<KBox<Self>>> {
         let result = KBox::try_pin_init(RustDebugFs::new(pdev), GFP_KERNEL)?;
         // We can still mutate fields through the files which are atomic or mutexed:
-        result.counter.store(91, Ordering::Relaxed);
+        result.counter.store(91, Relaxed);
         {
             let mut guard = result.inner.lock();
             guard.x = guard.y;
@@ -120,8 +118,8 @@ fn probe(
 }
 
 impl RustDebugFs {
-    fn build_counter(dir: &Dir) -> impl PinInit<File<AtomicUsize>> + '_ {
-        dir.read_write_file(c_str!("counter"), AtomicUsize::new(0))
+    fn build_counter(dir: &Dir) -> impl PinInit<File<Atomic<usize>>> + '_ {
+        dir.read_write_file(c_str!("counter"), Atomic::<usize>::new(0))
     }
 
     fn build_inner(dir: &Dir) -> impl PinInit<File<Mutex<Inner>>> + '_ {
diff --git a/samples/rust/rust_debugfs_scoped.rs b/samples/rust/rust_debugfs_scoped.rs
index b0c4e76b123e..9f0ec5f24cda 100644
--- a/samples/rust/rust_debugfs_scoped.rs
+++ b/samples/rust/rust_debugfs_scoped.rs
@@ -6,9 +6,9 @@
 //! `Scope::dir` to create a variety of files without the need to separately
 //! track them all.
 
-use core::sync::atomic::AtomicUsize;
 use kernel::debugfs::{Dir, Scope};
 use kernel::prelude::*;
+use kernel::sync::atomic::Atomic;
 use kernel::sync::Mutex;
 use kernel::{c_str, new_mutex, str::CString};
 
@@ -62,7 +62,7 @@ fn create_file_write(
     let file_name = CString::try_from_fmt(fmt!("{name_str}"))?;
     for sub in items {
         nums.push(
-            AtomicUsize::new(sub.parse().map_err(|_| EINVAL)?),
+            Atomic::<usize>::new(sub.parse().map_err(|_| EINVAL)?),
             GFP_KERNEL,
         )?;
     }
@@ -109,7 +109,7 @@ fn init(device_dir: Dir) -> impl PinInit<Self> {
 
 struct DeviceData {
     name: CString,
-    nums: KVec<AtomicUsize>,
+    nums: KVec<Atomic<usize>>,
 }
 
 fn init_control(base_dir: &Dir, dyn_dirs: Dir) -> impl PinInit<Scope<ModuleData>> + '_ {
-- 
2.51.0

Re: [PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[Peter Zijlstra]

On Tue, Oct 21, 2025 at 11:53:21PM -0400, Boqun Feng wrote:
> Rust native atomics are not supposed to be used in kernel due to the
> mismatch of memory model, since we now have the LKMM atomics in Rust,
> remove the usage of Rust native atomics in debugfs.

Doesn't rust have a language feature that allows you to blacklist them;
ensuring they are not used?

Re: [PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[Alice Ryhl]

On Wed, Oct 22, 2025 at 10:07:17AM +0200, Peter Zijlstra wrote:
> On Tue, Oct 21, 2025 at 11:53:21PM -0400, Boqun Feng wrote:
> > Rust native atomics are not supposed to be used in kernel due to the
> > mismatch of memory model, since we now have the LKMM atomics in Rust,
> > remove the usage of Rust native atomics in debugfs.
> 
> Doesn't rust have a language feature that allows you to blacklist them;
> ensuring they are not used?

I believe clippy lets you do that.

Alice

Re: [PATCH 3/3] rust: debugfs: Replace the usage of Rust native atomics

[Danilo Krummrich]

On 10/22/25 5:53 AM, Boqun Feng wrote:
> Rust native atomics are not allowed to use in kernel due to the mismatch
> of memory model with Linux kernel memory model, hence remove the usage
> of Rust native atomics in debufs.
> 
> Signed-off-by: Boqun Feng <boqun.feng@gmail.com>

Acked-by: Danilo Krummrich <dakr@kernel.org>

Re: [PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[Greg Kroah-Hartman]

On Tue, Oct 21, 2025 at 11:53:21PM -0400, Boqun Feng wrote:
> Rust native atomics are not supposed to be used in kernel due to the
> mismatch of memory model, since we now have the LKMM atomics in Rust,
> remove the usage of Rust native atomics in debugfs.
> 
> (help is appreciated if anyone wants to help in other subsystem)
> 
> Boqun Feng (3):
>   rust: sync: atomic: Make Atomic*Ops pub(crate)
>   rust: sync: atomic: Implement Debug for Atomic<Debug>
>   rust: debugfs: Replace the usage of Rust native atomics
> 
>  rust/kernel/debugfs/traits.rs       | 53 +++++++++--------------------
>  rust/kernel/sync/atomic.rs          | 12 ++++++-
>  samples/rust/rust_debugfs.rs        | 12 +++----
>  samples/rust/rust_debugfs_scoped.rs |  6 ++--
>  4 files changed, 36 insertions(+), 47 deletions(-)
> 
> -- 
> 2.51.0
> 
> 

Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Re: [PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[Boqun Feng]

On Wed, Oct 22, 2025 at 10:07:17AM +0200, Peter Zijlstra wrote:
> On Tue, Oct 21, 2025 at 11:53:21PM -0400, Boqun Feng wrote:
> > Rust native atomics are not supposed to be used in kernel due to the
> > mismatch of memory model, since we now have the LKMM atomics in Rust,
> > remove the usage of Rust native atomics in debugfs.
> 
> Doesn't rust have a language feature that allows you to blacklist them;
> ensuring they are not used?
> 

Although I don't know whether it's available today, but I believe that
can be done (in the future probably?).

However, this patchset is about cleaning up the existing usage, which
was introduced before we have LKMM atomics on the Rust side.

Regards,
Boqun

> 

Re: [PATCH 3/3] rust: debugfs: Replace the usage of Rust native atomics

[Matthew Maurer]

On Tue, Oct 21, 2025 at 8:53 PM Boqun Feng <boqun.feng@gmail.com> wrote:
>
> Rust native atomics are not allowed to use in kernel due to the mismatch
> of memory model with Linux kernel memory model, hence remove the usage
> of Rust native atomics in debufs.
>
> Signed-off-by: Boqun Feng <boqun.feng@gmail.com>

Reviewed-by: Matthew Maurer <mmaurer@google.com>

Re: [PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[David Gow]

[-- Attachment #1: Type: text/plain, Size: 566 bytes --]

On Wed, 22 Oct 2025 at 11:53, Boqun Feng <boqun.feng@gmail.com> wrote:
>
> Rust native atomics are not supposed to be used in kernel due to the
> mismatch of memory model, since we now have the LKMM atomics in Rust,
> remove the usage of Rust native atomics in debugfs.
>
> (help is appreciated if anyone wants to help in other subsystem)
>

Thanks very much, Boqun. I can confirm this fixes the build issues
(and seems to work) on 32-bit x86 (both UML, and -- with some
-Zregparm patches -- otherwise).

Tested-by: David Gow <davidgow@google.com>

Cheers,
-- David

[-- Attachment #2: S/MIME Cryptographic Signature --]
[-- Type: application/pkcs7-signature, Size: 5281 bytes --]

Re: [PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[Danilo Krummrich]

On 10/22/25 5:53 AM, Boqun Feng wrote:
> Boqun Feng (3):
>   rust: sync: atomic: Make Atomic*Ops pub(crate)
>   rust: sync: atomic: Implement Debug for Atomic<Debug>
>   rust: debugfs: Replace the usage of Rust native atomics

I ack'd patch three for you to pick it up, but I now wonder if you want me to
pick it up through the driver-core tree?

Re: [PATCH 0/3] Remove the usage of Rust native atomics in debugfs

[Boqun Feng]

On Fri, Oct 24, 2025 at 04:57:22PM +0200, Danilo Krummrich wrote:
> On 10/22/25 5:53 AM, Boqun Feng wrote:
> > Boqun Feng (3):
> >   rust: sync: atomic: Make Atomic*Ops pub(crate)
> >   rust: sync: atomic: Implement Debug for Atomic<Debug>
> >   rust: debugfs: Replace the usage of Rust native atomics
> 
> I ack'd patch three for you to pick it up, but I now wonder if you want me to

Thanks!

> pick it up through the driver-core tree?

Given there are some atomic library changes, I will send it as a PR to
tip. Thanks for the offering!

Regards,
Boqun