Struct PollCondVarBox 

pub struct PollCondVarBox { /* private fields */ }

A KBox<PollCondVar> that uses kfree_rcu.

Implementations

impl PollCondVarBox

pub fn new( name: &'static CStr, key: Pin<&'static LockClassKey>, ) -> Result<Self, AllocError>

Constructs a new boxed PollCondVar.

Methods from Deref<Target = PollCondVar>

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

Pin-projects all fields of Self.

These fields are structurally pinned:

• inner

These fields are not structurally pinned:

Methods from Deref<Target = CondVar>

pub fn project<'__pin>(self: Pin<&'__pin mut Self>) -> CondVarProjection<'__pin>

Pin-projects all fields of Self.

These fields are structurally pinned:

• wait_queue_head
• _pin

These fields are not structurally pinned:

pub fn wait<T: ?Sized, B: Backend>(&self, guard: &mut Guard<'_, T, B>)

Releases the lock and waits for a notification in uninterruptible mode.

Atomically releases the given lock (whose ownership is proven by the guard) and puts the thread to sleep, reacquiring the lock on wake up. It wakes up when notified by CondVar::notify_one or CondVar::notify_all. Note that it may also wake up spuriously.

pub fn wait_interruptible<T: ?Sized, B: Backend>( &self, guard: &mut Guard<'_, T, B>, ) -> bool

Releases the lock and waits for a notification in interruptible mode.

Similar to CondVar::wait, except that the wait is interruptible. That is, the thread may wake up due to signals. It may also wake up spuriously.

Returns whether there is a signal pending.

pub fn wait_interruptible_freezable<T: ?Sized, B: Backend>( &self, guard: &mut Guard<'_, T, B>, ) -> bool

Releases the lock and waits for a notification in interruptible and freezable mode.

The process is allowed to be frozen during this sleep. No lock should be held when calling this function, and there is a lockdep assertion for this. Freezing a task that holds a lock can trivially deadlock vs another task that needs that lock to complete before it too can hit freezable.

pub fn wait_interruptible_timeout<T: ?Sized, B: Backend>( &self, guard: &mut Guard<'_, T, B>, jiffies: Jiffies, ) -> CondVarTimeoutResult

Releases the lock and waits for a notification in interruptible mode.

Atomically releases the given lock (whose ownership is proven by the guard) and puts the thread to sleep. It wakes up when notified by CondVar::notify_one or CondVar::notify_all, or when a timeout occurs, or when the thread receives a signal.

pub fn notify_sync(&self)

Calls the kernel function to notify one thread synchronously.

This method behaves like notify_one, except that it hints to the scheduler that the current thread is about to go to sleep, so it should schedule the target thread on the same CPU.

pub fn notify_one(&self)

Wakes a single waiter up, if any.

This is not ‘sticky’ in the sense that if no thread is waiting, the notification is lost completely (as opposed to automatically waking up the next waiter).

pub fn notify_all(&self)

Wakes all waiters up, if any.

This is not ‘sticky’ in the sense that if no thread is waiting, the notification is lost completely (as opposed to automatically waking up the next waiter).

Trait Implementations

impl Deref for PollCondVarBox

type Target = PollCondVar

The resulting type after dereferencing.

fn deref(&self) -> &PollCondVar

Dereferences the value.

impl Drop for PollCondVarBox

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.