Struct LockClassKey 

pub struct LockClassKey { /* private fields */ }

Represents a lockdep class.

Wraps the kernel’s struct lock_class_key.

Implementations

impl LockClassKey

pub fn project<'__this>(self: Pin<&'__this mut Self>) -> __Projection<'__this>

Pin-projects all fields of Self.

These fields are structurally pinned:

• inner

These fields are not structurally pinned:

pub fn with_project<'__this, R>( self: Pin<&'__this mut Self>, f: impl FnOnce(__ProjectionLt<'__this>) -> R, ) -> R

Pin-projects all fields of Self with proper lifetime.

These fields are structurally pinned:

• inner

These fields are not structurally pinned:

pub fn with_project_ref<'__this, R>( self: Pin<&'__this Self>, f: impl FnOnce(__ProjectionRef<'__this>) -> R, ) -> R

Pin-projects all fields of Self from a shared reference with proper lifetime.

These fields are structurally pinned:

• inner

These fields are not structurally pinned:

impl LockClassKey

pub const unsafe fn new_static() -> Self

Initializes a statically allocated lock class key.

This is usually used indirectly through the static_lock_class! macro. See its documentation for more information.

Safety

• Before using the returned value, it must be pinned in a static memory location.
• The destructor must never run on the returned LockClassKey.

pub fn new_dynamic() -> impl PinInit<Self>

Initializes a dynamically allocated lock class key.

In the common case of using a statically allocated lock class key, the static_lock_class! macro should be used instead.

Examples

use kernel::alloc::KBox;
use kernel::types::ForeignOwnable;
use kernel::sync::{LockClassKey, SpinLock};
use pin_init::stack_pin_init;

let key = KBox::pin_init(LockClassKey::new_dynamic(), GFP_KERNEL)?;
let key_ptr = key.into_foreign();

{
    stack_pin_init!(let num: SpinLock<u32> = SpinLock::new(
        0,
        c"my_spinlock",
        // SAFETY: `key_ptr` is returned by the above `into_foreign()`, whose
        // `from_foreign()` has not yet been called.
        unsafe { <Pin<KBox<LockClassKey>> as ForeignOwnable>::borrow(key_ptr) }
    ));
}

// SAFETY: We dropped `num`, the only use of the key, so the result of the previous
// `borrow` has also been dropped. Thus, it's safe to use from_foreign.
unsafe { drop(<Pin<KBox<LockClassKey>> as ForeignOwnable>::from_foreign(key_ptr)) };

pub fn as_ptr(&self) -> *mut lock_class_key

Returns a raw pointer to the inner C struct.

It is up to the caller to use the raw pointer correctly.

Trait Implementations

impl Drop for LockClassKey

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl HasPinData for LockClassKey

type PinData = __ThePinData

fn __pin_data(_: InitData<Self>) -> Self::PinData

impl PinnedDrop for LockClassKey

fn drop(self: Pin<&mut Self>, _: OnlyCallFromDrop)

Executes the pinned destructor of this type.

impl Send for LockClassKey

impl Sync for LockClassKey