pub type SpinLock<T> = Lock<T, SpinLockBackend>;Expand description
A spinlock.
Exposes the kernel’s spinlock_t. When multiple CPUs attempt to lock the same spinlock, only
one at a time is allowed to progress, the others will block (spinning) until the spinlock is
unlocked, at which point another CPU will be allowed to make progress.
Instances of SpinLock need a lock class and to be pinned. The recommended way to create such
instances is with the pin_init and new_spinlock macros.
Examples
The following example shows how to declare, allocate and initialise a struct (Example) that
contains an inner struct (Inner) that is protected by a spinlock.
use kernel::{init::InPlaceInit, init::PinInit, new_spinlock, pin_init, sync::SpinLock};
struct Inner {
a: u32,
b: u32,
}
#[pin_data]
struct Example {
c: u32,
#[pin]
d: SpinLock<Inner>,
}
impl Example {
fn new() -> impl PinInit<Self> {
pin_init!(Self {
c: 10,
d <- new_spinlock!(Inner { a: 20, b: 30 }),
})
}
}
// Allocate a boxed `Example`.
let e = Box::pin_init(Example::new())?;
assert_eq!(e.c, 10);
assert_eq!(e.d.lock().a, 20);
assert_eq!(e.d.lock().b, 30);The following example shows how to use interior mutability to modify the contents of a struct protected by a spinlock despite only having a shared reference:
use kernel::sync::SpinLock;
struct Example {
a: u32,
b: u32,
}
fn example(m: &SpinLock<Example>) {
let mut guard = m.lock();
guard.a += 10;
guard.b += 20;
}Aliased Type§
struct SpinLock<T> { /* private fields */ }