class WaitQueue

Block until a wait queue is notified, ignoring existing signals

in |signal_mask|.

This function puts the current thread at the end of a wait

queue and then blocks until some other thread wakes the queue

up again.

If the deadline is zero, this function returns immediately with

ZX_ERR_TIMED_OUT. If the deadline is ZX_TIME_INFINITE, this function

waits indefinitely. Otherwise, this function returns with

ZX_ERR_TIMED_OUT when the deadline elapses.

Parameters

Returns

ZX_ERR_TIMED_OUT on timeout, else returns the return

value specified when the queue was woken by wait_queue_wake_one().

Wake up one thread sleeping on a wait queue

This function removes one thread (if any) from the head of the wait queue and

makes it executable. The new thread will be placed in the run queue.

Parameters

Returns

Whether a thread was woken

Block on a wait queue.

The returned status is whatever the caller of WaitQueue::Wake_*() specifies.

A deadline other than Deadline::infinite() will abort at the specified time

and return ZX_ERR_TIMED_OUT. A deadline in the past will immediately return.

Block on a wait queue with a zx_instant_mono_t-typed deadline.

Returns the current highest priority blocked thread on this wait queue, or

nullptr if no threads are blocked.

Wake a specific thread from a specific wait queue

TODO(johngro): Update this comment. UnblockThread does not actually remove

the thread from the wait queue, it simply finishes the unblock operation,

propagating any PI effects and dropping the PI lock chain starting from the

wait queue in the processes.

This function extracts a specific thread from a wait queue, wakes it, puts it

into a Scheduler's run queue, and does a reschedule if necessary. Callers of

this function must be sure that they are holding the locks for all of the

nodes in the PI chain, starting from the thread, before calling the function.

Static analysis can only ensure that the thread and its immediately

downstream blocking wait queue are locked.

Parameters

Returns

ZX_ERR_BAD_STATE if thread was not in any wait queue.

Wake all threads sleeping on a wait queue

This function removes all threads (if any) from the wait queue and

makes them executable. The new threads will be placed at the head of the

run queue.

Parameters

Returns

The number of threads woken

Locked versions of the wake calls. These calls are going to need to obtain

locks for each of the threads woken, which could result in needing to back

off and start the operation again. Each routine returns a

std::optional (bool or u32).

++ If the optional holds a value, then the value is the number of threads

which were woken, and the operation succeeded.

++ Otherwise, the operation failed with a Backoff error and the queue's

lock needs to be dropped before trying again.

It is assumed that forming a lock cycle should be impossible. If such a

cycle is detected (like, if the caller was holding the lock of one of the

thread's blocked in this queue at the time of the call) it will trigger a

DEBUG_ASSERT.

Either way, unlike the non-Locked versions of these routines, the wait

queue's lock is held for the duration of the operation, instead of being

release as soon as possible (during the call to SchedulerUnlock)

Whether the wait queue is currently empty.

OwnedWaitQueue needs to be able to call this on WaitQueues to

determine if they are base WaitQueues or the OwnedWaitQueue

subclass.

Tear down a wait queue

This panics if any threads were waiting on this queue, because that

would indicate a race condition for most uses of wait queues. If a

thread is currently waiting, it could have been scheduled later, in

which case it would have called Block() on an invalid wait

queue.

Dequeue the specified thread and set its blocked_status. Do not actually

schedule the thread to run.

Recompute the effective profile of a thread which is known to be blocked in

this wait queue, reordering the thread in the queue collection as needed.

This method does not deal with the consequences of profile inheritance, and

should only ever be called from one of the OwnedWaitQueue's Propagate

methods (which will deal with the consequences)