Wait
status_t Wait(uint32 flags = 0, bigtime_t timeout = 0);
status_t Wait(const void* object, uint32 flags = 0,
status_t Wait(uint32 flags = 0, bigtime_t timeout = 0);
status_t Wait(mutex* lock, uint32 flags = 0, bigtime_t timeout = 0);
status_t Wait(recursive_lock* lock, uint32 flags = 0, bigtime_t timeout = 0);
bool Wait(bigtime_t timeout, bool clearActivated)
return entry.Wait(B_RELATIVE_TIMEOUT, timeout) == B_OK;
iii. Wait for FDI training pattern 1 time
vi. Wait for FDI training pattern 2 time
ix. Wait for FDI idle pattern time for link to become active
12. Wait for panel power sequencing to reach enabled steady state
sc->ec_condition_var.Wait(B_RELATIVE_TIMEOUT, 1000);
if (Wait(0, ATA_STATUS_BUSY, 0, 3 * 1000 * 1000) != B_OK) {
if (Wait(0, ATA_STATUS_BUSY, 0, 28 * 1000 * 1000) != B_OK) {
return Wait(high ? ATA_STATUS_DATA_REQUEST : 0,
return Wait(ATA_STATUS_DEVICE_READY, 0, 0, 5 * 1000 * 1000);
return Wait(0, ATA_STATUS_BUSY | ATA_STATUS_DATA_REQUEST, 0, 50 * 1000);
status_t result = fInterruptConditionEntry.Wait(B_RELATIVE_TIMEOUT,
status_t result = Wait(0, ATA_STATUS_BUSY, flags, request->Timeout());
if (Wait(ATA_STATUS_DATA_REQUEST, ATA_STATUS_BUSY,
if (fChannel->Wait(ATA_STATUS_BUSY | ATA_STATUS_DATA_REQUEST, 0,
if (fChannel->Wait(ATA_STATUS_DATA_REQUEST, ATA_STATUS_BUSY,
if (fChannel->Wait(ATA_STATUS_DATA_REQUEST, 0, ATA_CHECK_ERROR_BIT
result = fChannel->Wait(ATA_STATUS_DATA_REQUEST, ATA_STATUS_BUSY,
result = fChannel->Wait(0, ATA_STATUS_BUSY, 0, request->Timeout());
if (fChannel->Wait(ATA_STATUS_DATA_REQUEST, ATA_STATUS_BUSY,
status_t Wait(uint8 setBits, uint8 clearedBits,
status_t status = request->Wait(waitEntry);
return waitEntry->Wait(B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT, VMBUS_TIMEOUT);
status_t Wait(ConditionVariableEntry* waitEntry);
entry.Wait();
if (entry.Wait(B_RELATIVE_TIMEOUT, 1 * 1000 * 1000) == B_TIMED_OUT)
status_t result = configConditionEntry.Wait(B_CAN_INTERRUPT);
queueConditionEntry.Wait(B_CAN_INTERRUPT);
status_t status = variableEntry.Wait(&bus->readwait,
err = variableEntry.Wait(&bus->busy, B_RELATIVE_TIMEOUT,
status_t result = waiter.Wait(B_RELATIVE_TIMEOUT, 1000000);
status_t result = waiter.Wait();
status_t result = waiter.Wait(B_RELATIVE_TIMEOUT, 1000000);
result = conditionVariableEntry.Wait(B_CAN_INTERRUPT);
status = entry.Wait(B_RELATIVE_TIMEOUT, request->GetTimeout());
result = entry.Wait(B_RELATIVE_TIMEOUT, fRequest->Timeout());
status = request.Wait(0, 0);
status = request.Wait(0, 0);
entry.Wait(B_RELATIVE_TIMEOUT, min_c(5 * 1000 * 1000,
} else if (entry.Wait(B_RELATIVE_TIMEOUT, 5 * 1000 * 1000) != B_OK) {
status = request.Wait(0, 0);
status = request.Wait(0, 0);
result = entry.Wait(B_RELATIVE_TIMEOUT, 10 * 1000 * 1000);
result = conditionVariableEntry.Wait(B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT, timeout);
status = protocolRespEntry.Wait(B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT, HV_HID_TIMEOUT_US);
status = deviceInfoEntry.Wait(B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT, HV_HID_TIMEOUT_US);
conditionVariableEntry.Wait(B_RELATIVE_TIMEOUT, 0);
result = conditionVariableEntry.Wait(B_RELATIVE_TIMEOUT, timeout);
sBatteryCondition.Wait();
result = subRequest->Wait(0, 0);
return request->fEvent.Wait(B_RELATIVE_TIMEOUT, time);
lineLocker->Wait(fLock);
void Wait(mutex& lock)
waitEntry.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
request.Wait();
entry.Wait();
requestOwner.Wait(false);
error = entry.Wait(
status_t status = fRequestOwner.Wait(true);
status = fRequestOwner.Wait(true, timeout);
status_t Wait(bool interruptable, bigtime_t timeout = B_INFINITE_TIMEOUT);
status_t status = fCommandWait.Wait(&fLock,
status_t result = entry.Wait(B_ABSOLUTE_TIMEOUT | B_CAN_INTERRUPT, timeout);
status_t error = entry.Wait(B_ABSOLUTE_TIMEOUT | B_CAN_INTERRUPT,
status_t error = entry.Wait(B_ABSOLUTE_TIMEOUT | B_CAN_INTERRUPT,
status_t error = entry.Wait(B_ABSOLUTE_TIMEOUT | B_CAN_INTERRUPT,
error = entry.Wait(B_ABSOLUTE_TIMEOUT | B_CAN_INTERRUPT, timeout);
entry.Wait();
status_t Wait();
Wait();
Wait();
Wait();
void Wait();
return job->Wait(fLock);
status = condition->Wait(&mutex->u.recursive,
status = entry.Wait(flags, timeout);
waitEntry.Wait();
waitEntry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
entry.Wait();
return Wait(flags, timeout);
return entry.Wait(flags, timeout);
status_t res = entry.Wait(flags, timeout);
status_t res = entry.Wait(flags, timeout);
conditionVariableEntry.Wait();
heap.memory_added_condition.Wait(&heap.lock);
heap.memory_added_condition.Wait(&heap.lock);
entry.Wait();
entry.Wait();
status = request.Wait(0, 0);
error = waitEntry.Wait();
status_t error = entry.Wait(flags, timeout);
status_t Wait(uint32 flags = 0, bigtime_t timeout = 0);
entry.Wait(B_CAN_INTERRUPT);
entry.Wait(B_CAN_INTERRUPT);
entry.Wait();
ssize_t Wait(event_wait_info* infos, int numInfos,
status_t status = fQueueCondition.Wait(queueLocker.Get(),
fEventCondition.Wait(&fQueueLock);
ssize_t result = eventQueue->Wait(infos, numInfos, flags, timeout);
status = entry.Wait(B_CAN_INTERRUPT);
status_t status = waitEntry.Wait(B_CAN_INTERRUPT);
status = request.Wait();
status = request.Wait();
fUnregisterCondition.Wait(locker.Get());
return waiter.Wait(flags, timeout);
error = waiter.Wait(toFlags, timeout);
entry.Wait(flags, timeout);
status_t status = entry.Wait(flags, timeout);
status_t status = entry.Wait(flags, timeout);
status = entry.Wait(flags, timeout);
status_t status = entry.Wait(flags, timeout);
return queueEntry->Wait(B_CAN_INTERRUPT);
queueEntry->Wait(B_RELATIVE_TIMEOUT, 0);
result = queueEntry.Wait(B_CAN_INTERRUPT);
queueEntry->Wait(B_RELATIVE_TIMEOUT, 0);
allocationEntry->condition.Wait(&sLock);
sMaintenanceCondition.Wait(locker.Get());
resizeEntry->condition.Wait(&cache->lock);
entry.Wait();
loadingWaitEntry.Wait();
entry.Wait();
status = deadWaitEntry.Wait(B_CAN_INTERRUPT);
waitForDebuggerEntry.Wait();
conditionEntry.Wait();
waiter.waitEntry.Wait();
waiter.waitEntry.Wait();
waiter.waitEntry.Wait();
entry.Wait();
sPageDaemonCondition.Wait(kIdleScanWaitInterval, false);
waitEntry.Wait();
fPageWriterCondition.Wait(3000000, true);
enum { Accept, File, Stream, Timer, Wait, Free, Null } type;
return Wait(flags, timeout);
return entry.Wait(flags, timeout);
status = request.Wait(0, 0);
status = request.Wait(0, 0);
status = request.Wait(0, 0);
status = request.Wait(0, 0);