Struct Lock 

pub struct Lock<T: ?Sized, B: Backend> { /* private fields */ }

A mutual exclusion primitive.

Exposes one of the kernel locking primitives. Which one is exposed depends on the lock Backend specified as the generic parameter B.

Implementations

impl<T: ?Sized> Lock<T, SpinLockIrqBackend>

pub fn lock_with<'a>( &'a self, context: &'a LocalInterruptDisabled, ) -> SpinLockGuard<'a, T>

Acquires the lock without modifying local interrupt state.

This function should be used in place of the more expensive Lock::lock() function when possible for SpinLockIrq locks.

pub fn try_lock_with<'a>( &'a self, context: &'a LocalInterruptDisabled, ) -> Option<SpinLockGuard<'a, T>>

Tries to acquire the lock without modifying local interrupt state.

This function should be used in place of the more expensive Lock::try_lock() function when possible for SpinLockIrq locks.

Returns a guard that can be used to access the data protected by the lock if successful.

impl<T: ?Sized, B: Backend> Lock<T, B>

pub fn project<'__pin>( self: Pin<&'__pin mut Self>, ) -> LockProjection<'__pin, T, B>

Pin-projects all fields of Self.

These fields are structurally pinned:

• state
• _pin
• data

These fields are not structurally pinned:

impl<T, B: Backend> Lock<T, B>

pub fn new( t: impl PinInit<T>, name: &'static CStr, key: Pin<&'static LockClassKey>, ) -> impl PinInit<Self>

Constructs a new lock initialiser.

impl<B: Backend> Lock<(), B>

pub unsafe fn from_raw<'a>(ptr: *mut B::State) -> &'a Self

Constructs a Lock from a raw pointer.

This can be useful for interacting with a lock which was initialised outside of Rust.

Safety

The caller promises that ptr points to a valid initialised instance of State during the whole lifetime of 'a.

impl<T: ?Sized, B: Backend> Lock<T, B>

pub fn lock(&self) -> Guard<'_, T, B>

Acquires the lock and gives the caller access to the data protected by it.

pub fn try_lock(&self) -> Option<Guard<'_, T, B>>

Tries to acquire the lock.

Returns a guard that can be used to access the data protected by the lock if successful.

Trait Implementations

impl<T: ?Sized, B: Backend> HasPinData for Lock<T, B>

type PinData = __ThePinData<T, B>

unsafe fn __pin_data() -> Self::PinData

impl<T: ?Sized + Send, B: Backend> Send for Lock<T, B>

impl<T: ?Sized + Send, B: Backend> Sync for Lock<T, B>