Struct Waiter 

pub struct Waiter { /* private fields */ }

A type that can put a thread to sleep waiting for a condition.

Implementations

impl Waiter

pub fn new() -> Self

Create a new waiter.

pub fn new_ignoring_signals() -> Self

Create a new waiter that doesn’t wake up when a signal is received.

pub fn freeze<L>(&self, locked: &mut Locked<L>, current_task: &CurrentTask)

where L: LockEqualOrBefore<FileOpsCore>,

Freeze the task until the waiter is woken up.

No signal, e.g. EINTR (interrupt), should be received.

pub fn wait<L>( &self, locked: &mut Locked<L>, current_task: &CurrentTask, ) -> Result<(), Errno>

where L: LockEqualOrBefore<FileOpsCore>,

Wait until the waiter is woken up.

If the wait is interrupted (see Waiter::interrupt), this function returns EINTR.

pub fn wait_until<L>( &self, locked: &mut Locked<L>, current_task: &CurrentTask, deadline: MonotonicInstant, ) -> Result<(), Errno>

where L: LockEqualOrBefore<FileOpsCore>,

Wait until the given deadline has passed or the waiter is woken up.

If the wait deadline is nonzero and is interrupted (see Waiter::interrupt), this function returns EINTR. Callers must take special care not to lose any accumulated data or local state when EINTR is received as this is a normal and recoverable situation.

Using a 0 deadline (no waiting, useful for draining pending events) will not wait and is guaranteed not to issue EINTR.

It the timeout elapses with no events, this function returns ETIMEDOUT.

Processes at most one event. If the caller is interested in draining the events, it should repeatedly call this function with a 0 deadline until it reports ETIMEDOUT. (This case is why a 0 deadline must not return EINTR, as previous calls to wait_until() may have accumulated state that would be lost when returning EINTR to userspace.)

It is up to the caller (the “waiter”) to make sure that it synchronizes with any object that triggers an event (the “notifier”). This Waiter does not provide any synchronization itself. Note that synchronization between the “waiter” the “notifier” may be provided by the EventHandler used to handle an event iff the waiter observes the side-effects of the handler (e.g. reading the ready list modified by EventHandler::Enqueue or [EventHandler::EnqueueOnce]).

pub fn wake_immediately(&self, events: FdEvents, handler: EventHandler)

pub fn wake_on_zircon_signals( &self, handle: &dyn AsHandleRef, zx_signals: Signals, handler: SignalHandler, ) -> Result<PortWaitCanceler, Status>

Establish an asynchronous wait for the signals on the given Zircon handle (not to be confused with POSIX signals), optionally running a FnOnce.

Returns a PortWaitCanceler that can be used to cancel the wait.

pub fn fake_wait(&self) -> WaitCanceler

Return a WaitCanceler representing a wait that will never complete. Useful for stub implementations that should block forever even though a real implementation would wake up eventually.

pub fn notify(&self)

pub fn interrupt(&self)

Interrupt the waiter to deliver a signal. The wait operation will return EINTR, and a typical caller should then unwind to the syscall dispatch loop to let the signal be processed. See wait_until() for more details.

Ignored if the waiter was created with new_ignoring_signals().

Trait Implementations

impl Clone for Waiter

fn clone(&self) -> Waiter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Waiter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Waiter

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Waiter

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<Waiter> for WaiterRef

fn eq(&self, other: &Waiter) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Waiter

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.