wait
const struct flock* lock, bool wait);
u_int wait, waitscale;
status_t Scan(bool wait = true,
extern pid_t wait(int *_status);
int GetChar(bool wait);
int GetChar(bool wait);
int GetChar(bool wait);
virtual int GetChar(bool wait) = 0;
int GetChar(bool wait);
virtual int GetChar(bool wait);
return atomic_get(&thread->wait.status) == 1;
thread->wait.flags = flags;
thread->wait.type = type;
thread->wait.object = object;
atomic_set(&thread->wait.status, 1);
if (atomic_test_and_set(&thread->wait.status, status, 1) != 1)
if ((thread->wait.flags & B_CAN_INTERRUPT) != 0
|| (kill && (thread->wait.flags & B_KILL_CAN_INTERRUPT) != 0)) {
} wait;
virtual void wait( bool doWait );
c. Configure and enable PCH DPLL, wait for PCH DPLL warmup (Can be done anytime before enabling
VMBus::_SendRequest(VMBusRequest* request, ConditionVariableEntry* waitEntry, bool wait)
if (request->GetResponseType() != VMBUS_MSGTYPE_INVALID && waitEntry != NULL && wait)
bool wait = true);
HyperVSCSI::_SendRequest(HyperVSCSIRequest* request, bool wait)
if (wait)
if (wait) {
status_t _SendRequest(HyperVSCSIRequest* request, bool wait);
u_int wait;
wait = 100;
if ((--wait) == 0) {
__func__, wait);
rt2860_mcu_cmd(struct rt2860_softc *sc, uint8_t cmd, uint16_t arg, int wait)
cid = wait ? cmd : RT2860_TOKEN_NO_INTR;
if (!wait)
Delegation::DoGiveUp(bool truncate, bool wait)
if (!fAttribute && !truncate && wait)
status_t DoGiveUp(bool truncate, bool wait = true);
Inode::Sync(bool force, bool wait)
if (wait == true) {
if (wait == true)
bool wait)
linfo->fType = sGetLockType(lock->l_type, wait);
result = NFS4Inode::AcquireLock(cookie, linfo, wait);
const struct flock* lock, bool wait);
status_t Sync(bool force = false, bool wait = true);
sGetLockType(short type, bool wait) {
case F_RDLCK: return wait ? READW_LT : READ_LT;
case F_WRLCK: return wait ? WRITEW_LT : WRITE_LT;
NFS4Inode::AcquireLock(OpenFileCookie* cookie, LockInfo* lockInfo, bool wait)
if (reply.NFS4Error() != NFS4ERR_DENIED || wait) {
bool wait);
const struct flock* lock, bool wait)
return inode->AcquireLock(cookie, lock, wait);
for (int wait = 0; wait < 100; wait++) {
for (int wait = 0; wait < 100; wait++) {
for (int wait = 0; wait < 100; wait++) {
for (int wait = 0; wait < 100; wait++) {
status_t stop(bool wait=true) {
if(wait) {
AbstractModelLoader::Abort(bool wait)
if (wait)
virtual void Abort(bool wait);
wait(&status);
(void)wait((int *)0); /* Wait for the shell to complete */
(void) wait(&status);
struct timeval now, wait;
wait.tv_sec = tp->tv_sec + waittime;
wait.tv_usec = tp->tv_usec;
tvsub(&wait, &now);
if (wait.tv_sec < 0) {
wait.tv_sec = 0;
wait.tv_usec = 1;
error = select(sock + 1, fdsp, NULL, NULL, &wait);
struct timeval wait;
wait.tv_sec = waittime; wait.tv_usec = 0;
if (select(sock+1, fdsp, (fd_set *)0, (fd_set *)0, &wait) > 0)
if ((entry->timing.wait != 0) || (entry->timing.ready != 0) ||
if (entry->timing.wait != 0) {
print_time(entry->timing.wait, entry->timing.waitscale);
BNetworkDevice::Scan(bool wait, bool forceRescan)
if (wait)
if (!wait || status != B_OK) {
#define VNET_PCPUSTAT_ALLOC(name, wait) \
sizeof(VNET(name)) / sizeof(counter_u64_t), (wait))
counter_u64_alloc(int wait)
return (counter_u64_t)_kernel_malloc(sizeof(uint64_t), wait | M_ZERO);
struct mbuf * m_copym(struct mbuf *m, int off0, int len, int wait);
m_copym(struct mbuf *m, int off0, int len, int wait)
MBUF_CHECKSLEEP(wait);
n = m_gethdr(wait, m->m_type);
n = m_get(wait, m->m_type);
if (!m_dup_pkthdr(n, m, wait))
m_split(struct mbuf *m0, int len0, int wait)
MBUF_CHECKSLEEP(wait);
n = m_gethdr(wait, m0->m_type);
n = m_gethdr(wait, m0->m_type);
n->m_next = m_split(m, len, wait);
n = m_get(wait, m->m_type);
m_dup1(struct mbuf *m, int off, int len, int wait)
n = m_getcl(wait, m->m_type, M_PKTHDR);
n = m_getcl(wait, m->m_type, 0);
n = m_gethdr(wait, m->m_type);
n = m_get(wait, m->m_type);
if (copyhdr && !m_dup_pkthdr(n, m, wait)) {
m_tag_alloc(uint32_t cookie, int type, int len, int wait)
MBUF_CHECKSLEEP(wait);
t = malloc(len + sizeof(struct m_tag), M_PACKET_TAGS, wait);
int error = 0, wait = 0, ic_used;
wait = 1;
wait = 1;
if (wait) {
m = m_get(wait, m0->m_type);
if (m_dup_pkthdr(m, m0, wait) != 0)
MCLGETL(m, wait, len);
m_dup_pkt(struct mbuf *m0, unsigned int adj, int wait)
serial_getc(bool wait)
return gUART->GetChar(wait);
extern int serial_getc(bool wait);
ArchUARTPL011::GetChar(bool wait)
if (wait) {
ArchUARTlinflex::GetChar(bool wait)
if (wait) {
if (wait) {
ArchUARTSamsung::GetChar(bool wait)
while (wait && ((In32(UFSTAT) & UFSTAT_RXCNT) == 0))
DebugUART8250::GetChar(bool wait)
if (wait) {
ArchUARTSifive::GetChar(bool wait)
} while (!wait || data.isEmpty);
if (thread->wait.type != THREAD_BLOCK_TYPE_CONDITION_VARIABLE)
_WaitObjectUsed((addr_t)oldThread->wait.object, oldThread->wait.type);
event->previous_thread_wait_object_type = oldThread->wait.type;
event->previous_thread_wait_object = (addr_t)oldThread->wait.object;
struct file_descriptor* descriptor, struct flock* flock, bool wait)
vnode, flock, wait ? "yes" : "no"));
if (!wait) {
if (thread->wait.type != THREAD_BLOCK_TYPE_CONDITION_VARIABLE) {
ConditionVariable* variable = (ConditionVariable*)thread->wait.object;
fPreviousWaitObjectType(previous->wait.type)
fPreviousWaitObject = previous->wait.object;
&& thread->wait.type == THREAD_BLOCK_TYPE_SEMAPHORE) {
return (sem_id)(addr_t)thread->wait.object;
switch (thread->wait.type) {
sem_id sem = (sem_id)(addr_t)thread->wait.object;
switch (thread->wait.type) {
sem_id sem = (sem_id)(addr_t)thread->wait.object;
switch (thread->wait.type) {
sem_id sem = (sem_id)(addr_t)thread->wait.object;
(ConditionVariable*)thread->wait.object, name, sizeof(name));
kprintf("cvar:%*s %p ", 4, name, thread->wait.object);
kprintf("cvar %p ", thread->wait.object);
kprintf("mutex %p ", thread->wait.object);
kprintf("rwlock %p ", thread->wait.object);
kprintf("other %p ", thread->wait.object);
kprintf("??? %p ", thread->wait.object);
switch (thread->wait.type) {
sem_id sem = (sem_id)(addr_t)thread->wait.object;
kprintf("condition variable %p\n", thread->wait.object);
kprintf("mutex %p\n", thread->wait.object);
kprintf("rwlock %p\n", thread->wait.object);
kprintf("other (%s)\n", (char*)thread->wait.object);
kprintf("other (%p)\n", thread->wait.object);
kprintf("unknown (%p)\n", thread->wait.object);
if (thread->wait.status == 1) {
if (thread_is_interrupted(thread, thread->wait.flags)) {
thread->wait.status = B_INTERRUPTED;
return thread->wait.status;
if (thread->wait.status != 1)
return thread->wait.status;
thread->wait.unblock_timer.user_data = thread;
add_timer(&thread->wait.unblock_timer, &thread_block_timeout, timeout,
if (useTimer && thread->wait.unblock_timer.user_data != NULL)
cancel_timer(&thread->wait.unblock_timer);
if (thread->wait.status > 0
&& thread->wait.type == THREAD_BLOCK_TYPE_USER) {
struct { evWait *this; } wait;
goto wait;
goto wait;
goto wait;
goto wait;
goto wait;
wait:
it now, or wait until the next underflow?
LaunchContext::TerminateApp(team_id team, bool wait)
if (wait)
void TerminateApp(team_id team, bool wait = true);
void wait();
while ((pid = wait(&status)) != -1 && pid != child)
wait(&status);
while (wait(&status) != child);
pid_t pid = wait(&childStatus);
pid = wait(&childStatus);
pid = wait(&childStatus);
pid_t result = wait(&status);
wait( doWait );