rust: rros: change some 'CONFIG_RROS' to 'CONFIG_RROS_SPINLOCK'

Author: Caspian443

rust/kernel/sync/lock.rs

@@ -77,7 +77,7 @@ pub unsafe trait Backend {
 ///
 /// Exposes one of the kernel locking primitives. Which one is exposed depends on the lock
 /// [`Backend`] specified as the generic parameter `B`.
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 #[pin_data]
 pub struct Lock<T: ?Sized, B: Backend> {
     /// The kernel lock object.
@@ -95,15 +95,15 @@ pub struct Lock<T: ?Sized, B: Backend> {
 }
 
 // SAFETY: `Lock` can be transferred across thread boundaries iff the data it protects can.
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 unsafe impl<T: ?Sized + Send, B: Backend> Send for Lock<T, B> {}
 
 // SAFETY: `Lock` serialises the interior mutability it provides, so it is `Sync` as long as the
 // data it protects is `Send`.
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 unsafe impl<T: ?Sized + Send, B: Backend> Sync for Lock<T, B> {}
 
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 impl<T, B: Backend> Lock<T, B> {
     /// Constructs a new lock initialiser.
     #[allow(clippy::new_ret_no_self)]
@@ -120,7 +120,7 @@ impl<T, B: Backend> Lock<T, B> {
     }
 }
 
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 impl<T: ?Sized, B: Backend> Lock<T, B> {
     /// Acquires the lock and gives the caller access to the data protected by it.
     pub fn lock(&self) -> Guard<'_, T, B> {
@@ -137,7 +137,7 @@ impl<T: ?Sized, B: Backend> Lock<T, B> {
 /// Allows mutual exclusion primitives that implement the [`Backend`] trait to automatically unlock
 /// when a guard goes out of scope. It also provides a safe and convenient way to access the data
 /// protected by the lock.
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 #[must_use = "the lock unlocks immediately when the guard is unused"]
 pub struct Guard<'a, T: ?Sized, B: Backend> {
     pub(crate) lock: &'a Lock<T, B>,
@@ -146,10 +146,10 @@ pub struct Guard<'a, T: ?Sized, B: Backend> {
 }
 
 // SAFETY: `Guard` is sync when the data protected by the lock is also sync.
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 unsafe impl<T: Sync + ?Sized, B: Backend> Sync for Guard<'_, T, B> {}
 
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 impl<T: ?Sized, B: Backend> Guard<'_, T, B> {
     pub(crate) fn do_unlocked(&mut self, cb: impl FnOnce()) {
         // SAFETY: The caller owns the lock, so it is safe to unlock it.
@@ -163,7 +163,7 @@ impl<T: ?Sized, B: Backend> Guard<'_, T, B> {
     }
 }
 
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 impl<T: ?Sized, B: Backend> core::ops::Deref for Guard<'_, T, B> {
     type Target = T;
 
@@ -173,23 +173,23 @@ impl<T: ?Sized, B: Backend> core::ops::Deref for Guard<'_, T, B> {
     }
 }
 
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 impl<T: ?Sized, B: Backend> core::ops::DerefMut for Guard<'_, T, B> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         // SAFETY: The caller owns the lock, so it is safe to deref the protected data.
         unsafe { &mut *self.lock.data.get() }
     }
 }
 
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 impl<T: ?Sized, B: Backend> Drop for Guard<'_, T, B> {
     fn drop(&mut self) {
         // SAFETY: The caller owns the lock, so it is safe to unlock it.
         unsafe { B::unlock(self.lock.state.get(), &self.state) };
     }
 }
 
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 impl<'a, T: ?Sized, B: Backend> Guard<'a, T, B> {
     /// Constructs a new immutable lock guard.
     ///
@@ -247,7 +247,7 @@ pub trait NeedsLockClass {
 }
 
 /// Reschedules the caller's task if needed.
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 pub fn cond_resched() -> bool {
     // SAFETY: No arguments, reschedules `current` if needed.
     unsafe { rust_helper_cond_resched() != 0 }

rust/kernel/sync/lock/spinlock.rs

@@ -23,7 +23,7 @@ use crate::str::CStr;
 ///
 /// It uses the name if one is given, otherwise it generates one based on the file name and line
 /// number.
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 #[macro_export]
 macro_rules! new_spinlock {
     ($inner:expr $(, $name:literal)? $(,)?) => {
@@ -97,7 +97,7 @@ macro_rules! new_spinlock {
 /// ```
 ///
 /// [`spinlock_t`]: ../../../../include/linux/spinlock.h
-#[cfg(not(CONFIG_RROS))]
+#[cfg(not(CONFIG_RROS_SPINLOCK))]
 pub type SpinLock<T> = super::Lock<T, SpinLockBackend>;
 
 /// A kernel `spinlock_t` lock backend.
@@ -176,7 +176,7 @@ macro_rules! spinlock_init {
 /// handlers (in which case it is ok for interrupts to be enabled).
 ///
 /// [`spinlock_t`]: ../../../include/linux/spinlock.h
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 pub struct SpinLock<T: ?Sized> {
     spin_lock: Opaque<bindings::spinlock>,
 
@@ -188,15 +188,15 @@ pub struct SpinLock<T: ?Sized> {
 }
 
 // SAFETY: `SpinLock` can be transferred across thread boundaries iff the data it protects can.
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 unsafe impl<T: ?Sized + Send> Send for SpinLock<T> {}
 
 // SAFETY: `SpinLock` serialises the interior mutability it provides, so it is `Sync` as long as the
 // data it protects is `Send`.
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 unsafe impl<T: ?Sized + Send> Sync for SpinLock<T> {}
 
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 impl<T> SpinLock<T> {
     /// Constructs a new spinlock.
     ///
@@ -212,7 +212,7 @@ impl<T> SpinLock<T> {
     }
 }
 
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 impl<T: ?Sized> SpinLock<T> {
     /// Locks the spinlock and gives the caller access to the data protected by it. Only one thread
     /// at a time is allowed to access the protected data.
@@ -277,15 +277,15 @@ impl<T: ?Sized> SpinLock<T> {
     }
 }
 
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 impl<T: ?Sized> NeedsLockClass for SpinLock<T> {
     unsafe fn init(self: Pin<&mut Self>, name: &'static CStr, key: *mut bindings::lock_class_key) {
         // SAFETY: The caller guarantees that `name` and `key` are initialised. So the pointers are valid.
         unsafe { rust_helper_spin_lock_init(self.spin_lock.get(), name.as_char_ptr(), key) };
     }
 }
 
-#[cfg(CONFIG_RROS)]
+#[cfg(CONFIG_RROS_SPINLOCK)]
 impl<T: ?Sized> Lock for SpinLock<T> {
     type Inner = T;