Re: [PATCH 2/5] rust: sync: add const constructor for raw_spinlock_t

[Carlos Llamas]

On Tue, Jun 23, 2026 at 03:38:05PM +0000, Alice Ryhl wrote:
> The abstractions for pr_*_ratelimited! need to construct a global
> `struct ratelimit_state`, which contains a `raw_spinlock_t` field. Thus,
> add a const constructor for the `raw_spinlock_t` type.
> 
> The SPINLOCK_OWNER_INIT constant isn't mirrored via a const helper
> because bindgen generates a 'static mut' instead of a constant from the
> pointer constant.,
> 
> The __ARCH_SPIN_LOCK_UNLOCKED constant cannot be translated by bindgen
> because it's a define for a struct without type annotations, so it's
> explicitly declared in Rust.
> 
> Signed-off-by: Alice Ryhl <aliceryhl@xxxxxxxxxx>
> ---
>  include/linux/spinlock_types_raw.h |  4 ++++
>  rust/bindings/lib.rs               | 24 ++++++++++++++++++++++++
>  rust/kernel/sync/lock/spinlock.rs  | 29 +++++++++++++++++++++++++++++
>  rust/kernel/sync/lockdep.rs        | 22 ++++++++++++++++++++++
>  4 files changed, 79 insertions(+)
> 
> diff --git a/include/linux/spinlock_types_raw.h b/include/linux/spinlock_types_raw.h
> index e5644ab2161f..942c229c90bb 100644
> --- a/include/linux/spinlock_types_raw.h
> +++ b/include/linux/spinlock_types_raw.h
> @@ -11,6 +11,10 @@
>  
>  #include <linux/lockdep_types.h>
>  
> +/*
> + * Keep in sync with rust/kernel/sync/lock/spinlock.rs
> + */
> +
>  context_lock_struct(raw_spinlock) {
>  	arch_spinlock_t raw_lock;
>  #ifdef CONFIG_DEBUG_SPINLOCK
> diff --git a/rust/bindings/lib.rs b/rust/bindings/lib.rs
> index 854e7c471434..adde41e41edc 100644
> --- a/rust/bindings/lib.rs
> +++ b/rust/bindings/lib.rs
> @@ -77,3 +77,27 @@ mod bindings_helper {
>          None
>      }
>  };
> +
> +// Explicitly list architectures where this logic is checked correct.
> +#[cfg(any(
> +    CONFIG_ARM,
> +    CONFIG_ARM64,
> +    CONFIG_LOONGARCH,
> +    CONFIG_PPC,
> +    CONFIG_RISCV,
> +    CONFIG_S390,
> +    CONFIG_X86,
> +))]

I guess this is done explicitly because we can't test if
__ARCH_SPIN_LOCK_UNLOCKED is defined by the arch?

> +pub const __ARCH_SPIN_LOCK_UNLOCKED: arch_spinlock_t = {
> +    // SAFETY: The `arch_spinlock_t` type can be zeroed.
> +    #[allow(unused_mut)]
> +    let mut lock: arch_spinlock_t = unsafe { core::mem::zeroed() };
> +
> +    #[cfg(not(CONFIG_SMP))]
> +    #[cfg(CONFIG_DEBUG_SPINLOCK)]
> +    {
> +        lock.slock = 1;
> +    }
> +
> +    lock
> +};
> diff --git a/rust/kernel/sync/lock/spinlock.rs b/rust/kernel/sync/lock/spinlock.rs
> index ef76fa07ca3a..8babfb79098f 100644
> --- a/rust/kernel/sync/lock/spinlock.rs
> +++ b/rust/kernel/sync/lock/spinlock.rs
> @@ -4,6 +4,8 @@
>  //!
>  //! This module allows Rust code to use the kernel's `spinlock_t`.
>  
> +use kernel::prelude::*;
> +
>  /// Creates a [`SpinLock`] initialiser with the given name and a newly-created lock class.
>  ///
>  /// It uses the name if one is given, otherwise it generates one based on the file name and line
> @@ -144,3 +146,30 @@ unsafe fn assert_is_held(ptr: *mut Self::State) {
>          unsafe { bindings::spin_assert_is_held(ptr) }
>      }
>  }
> +
> +/// Helper for creating a raw unlocked `bindings::raw_spinlock_t`.
> +///
> +/// For use in statics containing raw spinlocks.
> +pub const fn raw_spin_lock_unlocked(name: &'static CStr) -> bindings::raw_spinlock_t {
> +    // Silence unused variable warnings.
> +    #[cfg(not(CONFIG_DEBUG_LOCK_ALLOC))]
> +    let _ = name;
> +
> +    bindings::raw_spinlock_t {
> +        raw_lock: bindings::__ARCH_SPIN_LOCK_UNLOCKED,
> +
> +        #[cfg(CONFIG_DEBUG_SPINLOCK)]
> +        magic: bindings::SPINLOCK_MAGIC,
> +        #[cfg(CONFIG_DEBUG_SPINLOCK)]
> +        owner_cpu: u32::MAX,
> +        #[cfg(CONFIG_DEBUG_SPINLOCK)]
> +        owner: usize::MAX as *mut c_void,
> +
> +        #[cfg(CONFIG_DEBUG_LOCK_ALLOC)]
> +        dep_map: kernel::sync::lockdep::raw_lockdep_map(
> +            name,
> +            kernel::sync::lockdep::LD_WAIT_SPIN,
> +            kernel::sync::lockdep::LD_WAIT_INV,
> +        ),
> +    }
> +}

This seems identical to the __RAW_SPIN_LOCK_UNLOCKED equivalent.

> diff --git a/rust/kernel/sync/lockdep.rs b/rust/kernel/sync/lockdep.rs
> index 784821cc2a39..c0f8b196c084 100644
> --- a/rust/kernel/sync/lockdep.rs
> +++ b/rust/kernel/sync/lockdep.rs
> @@ -137,3 +137,25 @@ macro_rules! optional_name {
>          $crate::c_str!($name)
>      };
>  }
> +
> +/// Not checked, catch all.
> +pub const LD_WAIT_INV: u8 = bindings::lockdep_wait_type_LD_WAIT_INV as u8;
> +/// Spin loops, `raw_spinlock_t` etc
> +pub const LD_WAIT_SPIN: u8 = bindings::lockdep_wait_type_LD_WAIT_SPIN as u8;
> +
> +/// Helper for declaring a raw `struct lockdep_map` for locks in statics.
> +///
> +/// It's up to the caller to use the returned `struct lockdep_map` correctly.
> +#[cfg(CONFIG_LOCKDEP)]
> +pub const fn raw_lockdep_map(
> +    name: &'static CStr,
> +    wait_type_inner: u8,
> +    wait_type_outer: u8,
> +) -> bindings::lockdep_map {
> +    // SAFETY: All zeros is valid for this type.
> +    let mut map: bindings::lockdep_map = unsafe { core::mem::zeroed() };
> +    map.name = kernel::str::as_char_ptr_in_const_context(name);
> +    map.wait_type_inner = wait_type_inner;
> +    map.wait_type_outer = wait_type_outer;
> +    map
> +}
> 
> -- 
> 2.55.0.rc0.799.gd6f94ed593-goog
> 

Looks good to me,

Reviewed-by: Carlos Llamas <cmllamas@xxxxxxxxxx>