//////////////////////////////////////////////////////////// /// Check if the user is on the list //////////////////////////////////////////////////////////// bool UserContains(struct UserData * User) { if (User != NULL) { struct UserData * Iterator; Iterator = UserList.First; MutexLock(&User->MutexData); while (Iterator != NULL) { MutexLock(&Iterator->MutexData); if (Iterator == User) { MutexUnlock(&Iterator->MutexData); MutexUnlock(&User->MutexData); return true; } MutexUnlock(&Iterator->MutexData); Iterator = Iterator->Next; } MutexUnlock(&User->MutexData); } return false; }
void* mpThread(void* _args) { char *p = NULL; char buf[1024]; char* args = _args ? strdup(_args) : 0; int n; int offset; void* data; for (;;) { if (data = plGetEntry(&playlist)) { n = mpOpen(data, args); } else { if (!loopclip) break; n = mpOpen(loopclip, 0); } free(data); if (n) break; mpState = MP_PLAYING; MutexLock(&mpConsoleMutex); while (mpCommand("get_time_pos") <= 0) msleep(500); do { offset = 0; while (offset < sizeof(buf) - 1) { n = mpRead(buf + offset, sizeof(buf) - 1 - offset); if (n <= 0) break; offset += n; buf[offset] = 0; if (p = strstr(buf, "ANS_TIME_POSITION=")) { mpPos = atoi(p + 18); break; } } // stop here when paused MutexUnlock(&mpConsoleMutex); do { msleep(500); } while (mpState == MP_PAUSED); MutexLock(&mpConsoleMutex); } while (mpCommand("get_time_pos") > 0); MutexUnlock(&mpConsoleMutex); ShellTerminate(&mpx); ShellClean(&mpx); } free(args); mpState = MP_IDLE; mpThreadHandle = 0; return 0; }
//////////////////////////////////////////////////////////// /// Remove user from the list //////////////////////////////////////////////////////////// void UserRemove(struct UserData * User) { if (UserContains(User)) { struct UserData * UserPtr; // Remove from the list MutexLock(&User->MutexData); // Update the previous node if (User->Previous == NULL) { MutexLock(&UserList.First->MutexData); UserPtr = UserList.First; UserList.First = User->Next; } else { MutexLock(&User->Previous->Next->MutexData); UserPtr = User->Previous->Next; User->Previous->Next = User->Next; } MutexUnlock(&UserPtr->MutexData); // Update the next node if (User->Next == NULL) { MutexLock(&UserList.Last->MutexData); UserPtr = UserList.Last; UserList.Last = User->Previous; } else { MutexLock(&User->Next->Previous->MutexData); UserPtr = User->Next->Previous; User->Next->Previous = User->Previous; } MutexUnlock(&UserPtr->MutexData); // Close the socket SocketClose(&User->Connection.Socket); // Unlock the mutex MutexUnlock(&User->MutexData); // Destroy the mutex MutexDestroy(&User->MutexData); // Delete it free(User); User = NULL; } }
void* HeapAllocate(MemAllocHeap* heap, size_t size) { bool thread_safe = 0 != (heap->m_Flags & HeapFlags::kThreadSafe); if (thread_safe) { MutexLock(&heap->m_Lock); } void* ptr = nullptr; #if ENABLED(USE_DLMALLOC) ptr = mspace_malloc(heap->m_MemSpace, size); #else ptr = malloc(size); #endif if (!ptr) { Croak("out of memory allocating %d bytes", (int) size); } if (thread_safe) { MutexUnlock(&heap->m_Lock); } return ptr; }
int MQTTDisconnect(MQTTClient *c) { int rc = FAILURE; Timer timer; // we might wait for incomplete incoming publishes to complete int len = 0; #if defined(MQTT_TASK) MutexLock(&c->mutex); #endif TimerInit(&timer); TimerCountdownMS(&timer, c->command_timeout_ms); len = MQTTSerialize_disconnect(c->buf, c->buf_size); if (len > 0) { rc = sendPacket(c, len, &timer); // send the disconnect packet } MQTTCloseSession(c); #if defined(MQTT_TASK) MutexUnlock(&c->mutex); #endif return rc; }
void MQTTRun(void *parm) { Timer timer; MQTTClient *c = (MQTTClient *)parm; TimerInit(&timer); while (1) { TimerCountdownMS(&timer, CONFIG_MQTT_RECV_CYCLE); /* Don't wait too long if no traffic is incoming */ #if CONFIG_MQTT_RECV_CYCLE == 0 /* The smaller cycle, the greater throughput */ esp_task_wdt_reset(); #endif #if defined(MQTT_TASK) MutexLock(&c->mutex); #endif int rc = cycle(c, &timer); if (rc == FAILURE) { ESP_LOGE(TAG, "MQTTRun cycle failed"); #if defined(MQTT_TASK) MutexUnlock(&c->mutex); #endif vTaskDelete(NULL); } #if defined(MQTT_TASK) MutexUnlock(&c->mutex); #endif } }
bool cRemote::PutMacro(eKeys Key) // returns true it opens a menu // returns false if it is a command that has no menu { const cKeyMacro *km = KeyMacros.Get(Key); if (km) { keyMacroPlugin = km->Plugin(); if(km->Command()) { dsyslog("Executing keymacros.conf-command: \"%s\"\n", km->Command()); SystemExec(km->Command()); return false; } else { cMutexLock MutexLock(&mutex); for (int i = km->NumKeys(); --i > 0; ) { if (!Put(km->Macro()[i], true)) return true; } } } else if (Key == kTT) Skins.Message(mtError, tr("Teletext not available!")); else if (Key == kPiP) Skins.Message(mtError, tr("PiP not available!")); return true; }
static THREAD_ENTRY _audioThread(void* context) { struct mPSP2AudioContext* audio = (struct mPSP2AudioContext*) context; uint32_t zeroBuffer[PSP2_SAMPLES] = {0}; void* buffer = zeroBuffer; int audioPort = sceAudioOutOpenPort(SCE_AUDIO_OUT_PORT_TYPE_MAIN, PSP2_SAMPLES, 48000, SCE_AUDIO_OUT_MODE_STEREO); while (audio->running) { MutexLock(&audio->mutex); if (buffer != zeroBuffer) { // Can only happen in successive iterations audio->samples -= PSP2_SAMPLES; ConditionWake(&audio->cond); } if (audio->samples >= PSP2_SAMPLES) { buffer = &audio->buffer[audio->readOffset]; audio->readOffset += PSP2_SAMPLES; if (audio->readOffset >= PSP2_AUDIO_BUFFER_SIZE) { audio->readOffset = 0; } // Don't mark samples as read until the next loop iteration to prevent // writing to the buffer while being read (see above) } else { buffer = zeroBuffer; } MutexUnlock(&audio->mutex); sceAudioOutOutput(audioPort, buffer); } sceAudioOutReleasePort(audioPort); return 0; }
void BuildQueueDestroy(BuildQueue* queue) { Log(kDebug, "destroying build queue"); const BuildQueueConfig* config = &queue->m_Config; MutexLock(&queue->m_Lock); queue->m_QuitSignalled = true; MutexUnlock(&queue->m_Lock); CondBroadcast(&queue->m_WorkAvailable); for (int i = 0, thread_count = config->m_ThreadCount; i < thread_count; ++i) { if (i > 0) { Log(kDebug, "joining with build thread %d", i); ThreadJoin(queue->m_Threads[i]); } ThreadStateDestroy(&queue->m_ThreadState[i]); } // Deallocate storage. MemAllocHeap* heap = queue->m_Config.m_Heap; HeapFree(heap, queue->m_ExpensiveWaitList); HeapFree(heap, queue->m_Queue); CondDestroy(&queue->m_WorkAvailable); MutexDestroy(&queue->m_Lock); // Unblock all signals on the main thread. SignalHandlerSetCondition(nullptr); SignalBlockThread(false); }
void cDvbTuner::Action(void) { cTimeMs Timer; bool LostLock = false; fe_status_t Status = (fe_status_t)0; while (Running()) { fe_status_t NewStatus; if (GetFrontendStatus(NewStatus, 10)) Status = NewStatus; cMutexLock MutexLock(&mutex); switch (tunerStatus) { case tsIdle: break; case tsSet: tunerStatus = SetFrontend() ? tsTuned : tsIdle; Timer.Set(tuneTimeout); continue; case tsTuned: if (Timer.TimedOut()) { tunerStatus = tsSet; diseqcCommands = NULL; if (time(NULL) - lastTimeoutReport > 60) { // let's not get too many of these isyslog("frontend %d timed out while tuning to channel %d, tp %d", cardIndex, channel.Number(), channel.Transponder()); lastTimeoutReport = time(NULL); } continue; } case tsLocked: if (Status & FE_REINIT) { tunerStatus = tsSet; diseqcCommands = NULL; isyslog("frontend %d was reinitialized", cardIndex); lastTimeoutReport = 0; continue; } else if (Status & FE_HAS_LOCK) { if (LostLock) { isyslog("frontend %d regained lock on channel %d, tp %d", cardIndex, channel.Number(), channel.Transponder()); LostLock = false; } tunerStatus = tsLocked; locked.Broadcast(); lastTimeoutReport = 0; } else if (tunerStatus == tsLocked) { LostLock = true; isyslog("frontend %d lost lock on channel %d, tp %d", cardIndex, channel.Number(), channel.Transponder()); tunerStatus = tsTuned; Timer.Set(lockTimeout); lastTimeoutReport = 0; continue; } } if (ciHandler) ciHandler->Process(); if (tunerStatus != tsTuned) newSet.TimedWait(mutex, 1000); } }
void* HeapReallocate(MemAllocHeap *heap, void *ptr, size_t size) { bool thread_safe = 0 != (heap->m_Flags & HeapFlags::kThreadSafe); if (thread_safe) { MutexLock(&heap->m_Lock); } void *new_ptr; #if ENABLED(USE_DLMALLOC) new_ptr = mspace_realloc(heap->m_MemSpace, ptr, size); #else new_ptr = realloc(ptr, size); #endif if (!new_ptr && size > 0) { Croak("out of memory reallocating %d bytes at %p", (int) size, ptr); } if (thread_safe) { MutexUnlock(&heap->m_Lock); } return new_ptr; }
bool cRemote::Put(eKeys Key, bool AtFront) { if (Key != kNone) { cMutexLock MutexLock(&mutex); if (in != out && (keys[out] & k_Repeat) && (Key & k_Release)) Clear(); int d = out - in; if (d <= 0) d = MaxKeys + d; if (d - 1 > 0) { if (AtFront) { if (--out < 0) out = MaxKeys - 1; keys[out] = Key; } else { keys[in] = Key; if (++in >= MaxKeys) in = 0; } keyPressed.Broadcast(); return true; } return false; } return true; // only a real key shall report an overflow! }
void UvdState::lock() { if (m_isRealtimeMode) { MutexLock(&m_lock); } }
//////////////////////////////////////////////////////////// /// Destroy all users //////////////////////////////////////////////////////////// bool UsersDestroy() { struct UserData * Iterator = UserList.First; // Remove all users while (Iterator != NULL) { struct UserData * TempUser = Iterator; Iterator = Iterator->Next; // Close the socket MutexLock(&TempUser->MutexData); SocketClose(&TempUser->Connection.Socket); MutexUnlock(&TempUser->MutexData); // Destroy the mutex MutexDestroy(&TempUser->MutexData); // Free it free(TempUser); TempUser = NULL; } return true; }
/** * Call this function when a writer task needs access to the data * protected by the given rwlock. */ UInt32 rwl_writer_start( TRWLock *rwlock ) { /* * First we check if destroy has not been called. * In a propper design this test should never fail. */ if ( rwlock->delflag ) return 0; rwlock->wcount++; /* * We will wait for all readers to finish. * A writer must have exclusive access. */ while ( rwlock->rcount ) { ThreadDelay( 10 ); } /* * Lock mutex for exclusive access and set the writer in progress * flag. */ rwlock->wflag = 1; MutexLock( rwlock->datalock ); /* * Start writing */ return 1; }
void cControl::Shutdown(void) { cMutexLock MutexLock(&mutex); cControl *c = control; // avoids recursions control = NULL; delete c; }
void cSatipSectionStatistics::AddSectionStatistic(long bytesP, long callsP) { debug16("%s (%ld, %ld)", __PRETTY_FUNCTION__, bytesP, callsP); cMutexLock MutexLock(&mutexM); filteredDataM += bytesP; numberOfCallsM += callsP; }
bool WorkerThread::Pop( TaskBase *& outTask ) { // lock this thread's task vector //boost::mutex::scoped_lock this_lock( TaskMutex_ ); MutexLock(TaskMutex_); // if the task vector is empty, return false if( Tasks_.empty() ) { MutexUnlock(TaskMutex_); return false; } // get a pointer to the last task in the vector TaskBase * t = Tasks_.back(); // if the task can slice itself into a new task (e.g. several iterations of a loop) if( t->Slice( outTask ) ) { // mark the task's completion flag as busy t->Completion_->Set( true ); MutexUnlock(TaskMutex_); return true; // return the love } // assign the outTask to the last task outTask = t; // pop the task out of the vector Tasks_.pop_back(); MutexUnlock(TaskMutex_); return true;// return the love }
void GBASyncLockAudio(struct GBASync* sync) { if (!sync) { return; } MutexLock(&sync->audioBufferMutex); }
MUTEX * avtExecutionManager::FindMutex( const MUTEX_ID id ) { if (tPool == NULL) return NULL; std::map<MUTEX_ID, MUTEX *>::iterator it; MUTEX *lock; MutexLock( &mutexMapLock ); it = mutexMap.find( id ); if( it == mutexMap.end() ) { // Not found, create it. lock = new MUTEX; MutexInit( lock ); mutexMap.insert( std::pair<MUTEX_ID, MUTEX *>(id, lock) ); } else { lock = it->second; } MutexUnlock( &mutexMapLock ); return( lock ); }
void avtExecutionManager::MutexLock( const MUTEX_ID stringID ) { if (tPool == NULL) return; MutexLock( FindMutex(stringID) ); }
void cControl::Launch(cControl *Control) { cMutexLock MutexLock(&mutex); cControl *c = control; // keeps control from pointing to uninitialized memory control = Control; delete c; }
bool GBASIOLockstepNodeUnload(struct GBASIODriver* driver) { struct GBASIOLockstepNode* node = (struct GBASIOLockstepNode*) driver; MutexLock(&node->p->mutex); --node->p->loaded; ConditionWake(&node->p->barrier); MutexUnlock(&node->p->mutex); return true; }
void Client::crash() { MutexLock lock = MutexLock( &mutex ); printf( "Client %d: crash\n", id ); crashed = true; }
int __ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) { MutexLock(&lock->base); ww_mutex_lock_acquired(lock, ctx); lock->ctx = ctx; return 0; }
void Client::report( int vms ) { printf( "Client %d: report[%d]\n", id, vms ); MutexLock lock = MutexLock( &mutex ); allocator->report( vms ); }
void KLogToScreenDisable(void) { MutexLock (&dbg_mutex); klog_to_screen = FALSE; MutexUnlock (&dbg_mutex); }
void cSatipBufferStatistics::AddBufferStatistic(long bytesP, long usedP) { debug16("%s (%ld, %ld)", __PRETTY_FUNCTION__, bytesP, usedP); cMutexLock MutexLock(&mutexM); dataBytesM += bytesP; if (usedP > usedSpaceM) usedSpaceM = usedP; }
void cRemote::Clear(void) { cMutexLock MutexLock(&mutex); in = out = 0; if (learning) { free(unknownCode); unknownCode = NULL; } }
static void _changeVideoSync(struct GBASync* sync, bool frameOn) { // Make sure the video thread can process events while the GBA thread is paused MutexLock(&sync->videoFrameMutex); if (frameOn != sync->videoFrameOn) { sync->videoFrameOn = frameOn; ConditionWake(&sync->videoFrameAvailableCond); } MutexUnlock(&sync->videoFrameMutex); }