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<'__pin>( self: Pin<&'__pin mut Self>, ) -> LockClassKeyProjection<'__pin>

Pin-projects all fields of Self.

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.

impl HasPinData for LockClassKey

type PinData = __ThePinData

unsafe fn __pin_data() -> 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