Trait Backend

pub unsafe trait Backend {
    type State;
    type GuardState;

    // Required methods
    unsafe fn init(
        ptr: *mut Self::State,
        name: *const c_char,
        key: *mut lock_class_key,
    );
    unsafe fn lock(ptr: *mut Self::State) -> Self::GuardState;
    unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState>;
    unsafe fn unlock(ptr: *mut Self::State, guard_state: &Self::GuardState);

    // Provided method
    unsafe fn relock(ptr: *mut Self::State, guard_state: &mut Self::GuardState) { ... }
}

The “backend” of a lock.

It is the actual implementation of the lock, without the need to repeat patterns used in all locks.

Safety

• Implementers must ensure that only one thread/CPU may access the protected data once the lock is owned, that is, between calls to lock and unlock.
• Implementers must also ensure that relock uses the same locking method as the original lock operation.

Required Associated Types

type State

The state required by the lock.

type GuardState

The state required to be kept between lock and unlock.

Required Methods

unsafe fn init( ptr: *mut Self::State, name: *const c_char, key: *mut lock_class_key, )

Initialises the lock.

Safety

ptr must be valid for write for the duration of the call, while name and key must remain valid for read indefinitely.

unsafe fn lock(ptr: *mut Self::State) -> Self::GuardState

Acquires the lock, making the caller its owner.

Safety

Callers must ensure that Backend::init has been previously called.

unsafe fn try_lock(ptr: *mut Self::State) -> Option<Self::GuardState>

Tries to acquire the lock.

Safety

Callers must ensure that Backend::init has been previously called.

unsafe fn unlock(ptr: *mut Self::State, guard_state: &Self::GuardState)

Releases the lock, giving up its ownership.

Safety

It must only be called by the current owner of the lock.

Provided Methods

unsafe fn relock(ptr: *mut Self::State, guard_state: &mut Self::GuardState)

Reacquires the lock, making the caller its owner.

Safety

Callers must ensure that guard_state comes from a previous call to Backend::lock (or variant) that has been unlocked with Backend::unlock and will be relocked now.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Backend for MutexBackend

type State = mutex

type GuardState = ()

impl Backend for SpinLockBackend

type State = spinlock

type GuardState = ()