/************************************************************** * Private functions **************************************************************/ static void * kernelManager( void *arg) { s_kernelManager km = (s_kernelManager)arg; os_mutexLock(&km->mtx); km->active++; os_condBroadcast(&km->cv); os_mutexUnlock(&km->mtx); u_splicedKernelManager(km->spliced); return NULL; }
c_syncResult c_condBroadcast ( c_cond *cnd) { os_result result; result = os_condBroadcast(cnd); if(result != os_resultSuccess){ OS_REPORT_1(OS_ERROR, "c_condBroadcast", 0, "os_condBroadcast failed; os_result = %d.", result); assert(result == os_resultSuccess); } return result; }
static void * cAndMCommandManager( void *arg) { s_kernelManager km = (s_kernelManager)arg; os_mutexLock(&km->mtx); km->active++; os_condBroadcast(&km->cv); os_mutexUnlock(&km->mtx); u_splicedBuiltinCAndMCommandDispatcher(km->spliced); return NULL; }
void gapi_objectClearBusy ( gapi_object _this) { gapi_handle handle = gapi_handle(_this); if (gapi_handleClaim(handle) == GAPI_RETCODE_OK) { if ( handle->busy ) { handle->busy = FALSE; os_condBroadcast(&handle->cv); } gapi_handleRelease(handle); } }
/** * Sets the terminate-flag in the parallel demarshalling context and signals workers. * @param[in] pdc the parallel demarshalling context to signal * @pre dr_mutex locked */ static void pdc_terminateWorkers( DDS::ccpp_parDemContext *pdc) { if(pdc){ if(os_mutexLock(&pdc->superMtx) != os_resultSuccess) goto err_mutex_lock; if(os_mutexLock(&pdc->mtx) != os_resultSuccess) goto err_mutex_lock; pdc->terminate = 1U; os_condBroadcast(&pdc->startCnd); os_mutexUnlock(&pdc->mtx); os_mutexUnlock(&pdc->superMtx); } return; err_mutex_lock: OS_REPORT(OS_FATAL, "CCPP", 0, "Failed to claim mutex"); return; }
void _ObjectClearBusy ( _Object object) { gapi_handle handle; assert(object); assert(object->handle); handle = (gapi_handle)object->handle; assert(handle->magic == MAGIC); if ( handle->busy ) { handle->busy = FALSE; os_condBroadcast(&handle->cv); } }
static void nw_splicedaemonListener( v_serviceStateKind spliceDaemonState, c_voidp usrData) { nw_termination *terminate = (nw_termination *)usrData; switch (spliceDaemonState) { case STATE_TERMINATING: case STATE_TERMINATED: case STATE_DIED: os_mutexLock( &terminate->mtx ); terminate->terminate = TRUE; os_condBroadcast( &terminate->cv ); os_mutexUnlock( &terminate->mtx ); break; default: NW_CONFIDENCE(FALSE); break; } }
u_result u_waitsetDetach_s( const u_waitset _this, const u_observable observable) { u_waitsetEntry entry; u_domain domain; u_result result; os_result osr; assert(_this != NULL); assert(observable != NULL); osr = os_mutexLock_s(&_this->mutex); if (osr == os_resultSuccess) { domain = u_observableDomain(observable); if (domain != NULL) { entry = c_iterResolve(_this->entries, compare_domain, domain); if (entry != NULL) { /* The following detach will wakeup any blocking wait call on this entry. */ result = u_waitsetEntryDetach(entry, observable); if (result == U_RESULT_UNSUPPORTED) { _this->detachCnt++; /* removed last observable for this entry so can detach from domain. */ entry = c_iterTake(_this->entries, entry); /* use overwrite entry */ result = u_domainRemoveWaitset(domain, _this); if (c_iterLength(_this->entries) == 1) { _this->multi_mode = OS_FALSE; } else { _this->multi_mode = OS_TRUE; } while (_this->waitBusy) { os_condWait(&_this->waitCv, &_this->mutex); } _this->detachCnt--; /* Broadcast the detachCnt update. */ os_condBroadcast(&_this->waitCv); os_mutexUnlock(&_this->mutex); u_objectFree(entry); } else { os_mutexUnlock(&_this->mutex); } } else { /* Check if the condition is already deleted */ v_public ko; result = u_observableReadClaim(observable, &ko, C_MM_RESERVATION_NO_CHECK); if (result == U_RESULT_OK) { u_observableRelease(observable, C_MM_RESERVATION_NO_CHECK); result = U_RESULT_PRECONDITION_NOT_MET; OS_REPORT(OS_ERROR, "u_waitSetDetach_s", result, "Condition is not attached to Waitset"); } os_mutexUnlock(&_this->mutex); } } else { os_mutexUnlock(&_this->mutex); result = U_RESULT_INTERNAL_ERROR; OS_REPORT(OS_ERROR, "u_waitsetDetach_s", result, "Failed to connect to domain."); } } else { result = U_RESULT_INTERNAL_ERROR; OS_REPORT(OS_ERROR, "u_waitSetDetach_s", result, "Could not lock the waitset."); } return result; }
u_result u_waitsetWaitAction ( const u_waitset _this, u_waitsetAction action, void *arg, const os_duration timeout) { u_result result = U_RESULT_OK; os_result osr; c_ulong length; assert(_this != NULL); assert(action != NULL); assert(OS_DURATION_ISPOSITIVE(timeout)); osr = os_mutexLock_s(&_this->mutex); if (osr == os_resultSuccess) { if (!_this->alive) { result = U_RESULT_ALREADY_DELETED; } if (result == U_RESULT_OK) { if (!_this->waitBusy) { /* Wait for possible detach to complete. * If you don't do that, it's possible that this wait call sets * the waitBusy flag before the detach can wake up of its waitBusy * loop, meaning that the detach will block at least until the * waitset is triggered again. */ while (_this->detachCnt > 0) { os_condWait(&_this->waitCv, &_this->mutex); } _this->waitBusy = TRUE; length = c_iterLength(_this->entries); if (length == 1) { /* Single Domain Mode. */ u_waitsetEntry entry = c_iterObject(_this->entries,0); os_mutexUnlock(&_this->mutex); result = u_waitsetEntryWait(entry, action, arg, timeout); os_mutexLock(&_this->mutex); _this->waitBusy = FALSE; os_condBroadcast(&_this->waitCv); os_mutexUnlock(&_this->mutex); if ((result == U_RESULT_OK) && (_this->alive == FALSE)) { result = U_RESULT_ALREADY_DELETED; } } else { /* Multi Domain Mode (or no Domain). */ if (OS_DURATION_ISINFINITE(timeout)) { os_condWait(&_this->cv, &_this->mutex); osr = os_resultSuccess; } else { osr = os_condTimedWait(&_this->cv, &_this->mutex, timeout); } _this->waitBusy = FALSE; os_condBroadcast(&_this->waitCv); switch (osr) { case os_resultSuccess: if (_this->alive == TRUE) { result = U_RESULT_OK; } else { result = U_RESULT_ALREADY_DELETED; } break; case os_resultTimeout: result = U_RESULT_TIMEOUT; break; default: result = U_RESULT_INTERNAL_ERROR; OS_REPORT(OS_ERROR, "u_waitsetWaitAction", result, "os_condWait failed for waitset 0x" PA_ADDRFMT, (PA_ADDRCAST)_this); break; } os_mutexUnlock(&_this->mutex); } } else { os_mutexUnlock(&_this->mutex); result = U_RESULT_PRECONDITION_NOT_MET; } } else { os_mutexUnlock(&_this->mutex); } } else { result = U_RESULT_INTERNAL_ERROR; OS_REPORT(OS_ERROR, "u_waitsetWaitAction", result, "os_mutexLock failed for waitset 0x" PA_ADDRFMT, (PA_ADDRCAST)_this); } return result; }
u_result u_waitsetWaitAction2 ( const u_waitset _this, u_waitsetAction2 action, void *arg, const os_duration timeout) { u_result result = U_RESULT_OK; os_result osr; c_ulong length; struct checkArg a; a.action = action; a.arg = arg; a.count = 0; assert(_this != NULL); assert(OS_DURATION_ISPOSITIVE(timeout)); osr = os_mutexLock_s(&_this->mutex); if (osr == os_resultSuccess) { if (!_this->alive) { result = U_RESULT_ALREADY_DELETED; OS_REPORT(OS_ERROR, "u_waitsetWaitAction2", result, "Precondition not met: Waitset is already deleted"); } if (_this->waitBusy) { result = U_RESULT_PRECONDITION_NOT_MET; OS_REPORT(OS_ERROR, "u_waitsetWaitAction2", result, "Precondition not met: A Wait call is already active on this Waitset"); } if (result == U_RESULT_OK) { /* Wait for possible detach to complete. * If you don't do that, it's possible that this wait call sets * the waitBusy flag before the detach can wake up of its waitBusy * loop, meaning that the detach will block at least until the * waitset is triggered again. */ while (_this->detachCnt > 0) { os_condWait(&_this->waitCv, &_this->mutex); } length = c_iterLength(_this->entries); if (length == 1) { /* Single Domain Mode. */ u_waitsetEntry entry = c_iterObject(_this->entries,0); _this->waitBusy = TRUE; os_mutexUnlock(&_this->mutex); result = u_waitsetEntryWait2(entry, action, arg, timeout); os_mutexLock(&_this->mutex); _this->waitBusy = FALSE; if (_this->notifyDetached) { result = U_RESULT_DETACHING; _this->notifyDetached = OS_FALSE; } os_condBroadcast(&_this->waitCv); os_mutexUnlock(&_this->mutex); if ((result == U_RESULT_OK) && (_this->alive == FALSE)) { result = U_RESULT_ALREADY_DELETED; OS_REPORT(OS_ERROR, "u_waitsetWaitAction2", result, "Precondition not met: Waitset is already deleted"); } } else { /* Multi Domain Mode (or no Domain). */ a.count = 0; /* For each Domain test Conditions. */ (void)c_iterWalkUntil(_this->entries, check_entry_conditions, &a); /* Test Guard Conditions */ if ((a.count == 0) && (!action(NULL,arg))) { a.count++; } /* If No Conditions are true then wait. */ if (a.count == 0) { _this->waitBusy = TRUE; if (OS_DURATION_ISINFINITE(timeout)) { os_condWait(&_this->cv, &_this->mutex); osr = os_resultSuccess; } else { osr = os_condTimedWait(&_this->cv, &_this->mutex, timeout); } _this->waitBusy = FALSE; os_condBroadcast(&_this->waitCv); switch (osr) { case os_resultSuccess: if (_this->alive == TRUE) { if (_this->notifyDetached) { result = U_RESULT_DETACHING; _this->notifyDetached = OS_FALSE; } else { result = U_RESULT_OK; } } else { result = U_RESULT_ALREADY_DELETED; OS_REPORT(OS_ERROR, "u_waitsetWaitAction2", result, "Precondition not met: Waitset is already deleted"); } break; case os_resultTimeout: result = U_RESULT_TIMEOUT; break; default: result = U_RESULT_INTERNAL_ERROR; OS_REPORT(OS_ERROR, "u_waitsetWaitAction2", result, "os_condWait failed for waitset 0x" PA_ADDRFMT, (PA_ADDRCAST)_this); break; } } os_mutexUnlock(&_this->mutex); } } else { os_mutexUnlock(&_this->mutex); } } else { result = U_RESULT_INTERNAL_ERROR; OS_REPORT(OS_ERROR, "u_waitsetWaitAction2", result, "os_mutexLock failed for waitset 0x" PA_ADDRFMT, (PA_ADDRCAST)_this); } return result; }