Struct LockdepTracked 

pub struct LockdepTracked<L: RawLock, P = <L as RawLock>::DefaultPolicy, const LOCK_FLAGS: LockFlags = { lockdep::LOCK_FLAGS_NONE }> { /* private fields */ }

Wraps a RawLock and LockPolicy with optional lockdep tracking state.

Implementations

impl<L: RawLock, P, const LOCK_FLAGS: LockFlags> LockdepTracked<L, P, LOCK_FLAGS>

pub fn project<'__pin>( self: Pin<&'__pin mut Self>, ) -> LockdepTrackedProjection<'__pin, L, P, LOCK_FLAGS>

Pin-projects all fields of Self.

These fields are structurally pinned:

• lock

These fields are not structurally pinned:

• class_id
• _policy

impl<L: RawLock, P, const LOCK_FLAGS: LockFlags> LockdepTracked<L, P, LOCK_FLAGS>

pub const LOCK_FLAGS: LockFlags = LOCK_FLAGS

Flags specifying validation rules for the lock class.

impl<L: ConstRawLock, P, const LOCK_FLAGS: LockFlags> LockdepTracked<L, P, LOCK_FLAGS>

pub const INIT: Self

pub const fn const_init(_class_id: *const c_void) -> Self

Statically initializes a LockdepTracked lock in constant context.

Trait Implementations

impl<L: ConstRawLock, P: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> ConstRawLock for LockdepTracked<L, P, LOCK_FLAGS>

const INIT: Self = Self::INIT

Constant-initialized value for the lock.

impl<L: ConstRawLock, P, const LOCK_FLAGS: LockFlags> Default for LockdepTracked<L, P, LOCK_FLAGS>

fn default() -> Self

Returns the “default value” for a type.

impl<L: RawLock, P, const LOCK_FLAGS: LockFlags> Deref for LockdepTracked<L, P, LOCK_FLAGS>

type Target = L

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<L: RawLock, P: ExclusiveLockPolicy<L>, LP: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> ExclusiveLockPolicy<LockdepTracked<L, LP, LOCK_FLAGS>> for LockdepTracked<L, P, LOCK_FLAGS>

impl<L: RawLock, LP: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> ExclusiveLockPolicy<LockdepTracked<L, LP, LOCK_FLAGS>> for IrqSavePolicy

where IrqSavePolicy: ExclusiveLockPolicy<L>,

impl<L: RawLock, LP: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> ExclusiveLockPolicy<LockdepTracked<L, LP, LOCK_FLAGS>> for NoIrqSavePolicy

where NoIrqSavePolicy: ExclusiveLockPolicy<L>,

impl<L: RawLock, P, const LOCK_FLAGS: LockFlags> HasPinData for LockdepTracked<L, P, LOCK_FLAGS>

type PinData = __ThePinData<L, P, LOCK_FLAGS>

unsafe fn __pin_data() -> Self::PinData

impl<L: RawLock, P: LockPolicy<L>, LP: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> LockPolicy<LockdepTracked<L, LP, LOCK_FLAGS>> for LockdepTracked<L, P, LOCK_FLAGS>

type AcquireArgs = <P as LockPolicy<L>>::AcquireArgs

Arguments passed when acquiring the lock under this policy.

type GuardState = LockdepTrackedGuardState<<P as LockPolicy<L>>::GuardState>

State stored in the pinned guard across lock acquisition and release.

unsafe fn pre_validate( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Performs any pre-validation setup (such as disabling and saving interrupts) before lockdep validation runs.

unsafe fn pre_reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-runs pre-validation on an existing GuardState before re-acquiring the lock (e.g. in call_unlocked).

unsafe fn acquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Acquires the raw synchronization lock.

unsafe fn post_validate_acquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Acquires the raw synchronization lock after pre_validate and lockdep validation have completed.

unsafe fn reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-acquires the raw synchronization lock using existing guard state (e.g. after call_unlocked).

unsafe fn post_validate_reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-acquires the raw synchronization lock after pre_reacquire and lockdep validation have completed.

unsafe fn untrack( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Temporarily untracks the held lock in lockdep (used by call_untracked).

unsafe fn retrack( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-tracks the held lock in lockdep after untrack (used by call_untracked).

unsafe fn release( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Releases the raw synchronization lock, restoring the state.

impl<L: RawLock, LP: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> LockPolicy<LockdepTracked<L, LP, LOCK_FLAGS>> for IrqSavePolicy

where IrqSavePolicy: LockPolicy<L>,

type AcquireArgs = <IrqSavePolicy as LockPolicy<L>>::AcquireArgs

Arguments passed when acquiring the lock under this policy.

type GuardState = LockdepTrackedGuardState<<IrqSavePolicy as LockPolicy<L>>::GuardState>

State stored in the pinned guard across lock acquisition and release.

unsafe fn pre_validate( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Performs any pre-validation setup (such as disabling and saving interrupts) before lockdep validation runs.

unsafe fn pre_reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-runs pre-validation on an existing GuardState before re-acquiring the lock (e.g. in call_unlocked).

unsafe fn acquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Acquires the raw synchronization lock.

unsafe fn post_validate_acquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Acquires the raw synchronization lock after pre_validate and lockdep validation have completed.

unsafe fn reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-acquires the raw synchronization lock using existing guard state (e.g. after call_unlocked).

unsafe fn post_validate_reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-acquires the raw synchronization lock after pre_reacquire and lockdep validation have completed.

unsafe fn untrack( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Temporarily untracks the held lock in lockdep (used by call_untracked).

unsafe fn retrack( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-tracks the held lock in lockdep after untrack (used by call_untracked).

unsafe fn release( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Releases the raw synchronization lock, restoring the state.

impl<L: RawLock, LP: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> LockPolicy<LockdepTracked<L, LP, LOCK_FLAGS>> for NoIrqSavePolicy

where NoIrqSavePolicy: LockPolicy<L>,

type AcquireArgs = <NoIrqSavePolicy as LockPolicy<L>>::AcquireArgs

Arguments passed when acquiring the lock under this policy.

type GuardState = LockdepTrackedGuardState<<NoIrqSavePolicy as LockPolicy<L>>::GuardState>

State stored in the pinned guard across lock acquisition and release.

unsafe fn pre_validate( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Performs any pre-validation setup (such as disabling and saving interrupts) before lockdep validation runs.

unsafe fn pre_reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-runs pre-validation on an existing GuardState before re-acquiring the lock (e.g. in call_unlocked).

unsafe fn acquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Acquires the raw synchronization lock.

unsafe fn post_validate_acquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, args: Self::AcquireArgs, )

Acquires the raw synchronization lock after pre_validate and lockdep validation have completed.

unsafe fn reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-acquires the raw synchronization lock using existing guard state (e.g. after call_unlocked).

unsafe fn post_validate_reacquire( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-acquires the raw synchronization lock after pre_reacquire and lockdep validation have completed.

unsafe fn untrack( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Temporarily untracks the held lock in lockdep (used by call_untracked).

unsafe fn retrack( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Re-tracks the held lock in lockdep after untrack (used by call_untracked).

unsafe fn release( lock: &LockdepTracked<L, LP, LOCK_FLAGS>, state: &mut Self::GuardState, )

Releases the raw synchronization lock, restoring the state.

impl<L: RawLock, P: ExclusiveLockPolicy<L>, const LOCK_FLAGS: LockFlags> RawLock for LockdepTracked<L, P, LOCK_FLAGS>

type DefaultPolicy = LockdepTracked<L, P, LOCK_FLAGS>

Default policy that should be used when acquiring this lock.

unsafe fn init(class_id: *const c_void) -> impl PinInit<Self, Infallible>

Returns a PinInit block to initialize the raw lock in-place.

fn as_mut_ptr(&self) -> *mut c_void

Convert the raw lock reference to a standard c_void pointer for FFI.

impl<L: RawLock + Send, P, const LOCK_FLAGS: LockFlags> Send for LockdepTracked<L, P, LOCK_FLAGS>

impl<L: RawLock + Sync, P, const LOCK_FLAGS: LockFlags> Sync for LockdepTracked<L, P, LOCK_FLAGS>