void Task_P2() { Mutex_Lock(mut1); Task_Sleep(20); Mutex_Lock(mut2); Task_Sleep(10); Mutex_Unlock(mut2); Mutex_Unlock(mut1); for(;;); }
static int MksckBindGeneric(struct sock *sk, Mksck_Address addr) { int err; Mksck *mksck; struct MksckPage *mksckPage; if (sk->sk_protinfo != NULL) return -EISCONN; if (addr.vmId == MKSCK_VMID_UNDEF) { mksckPage = MksckPage_GetFromTgidIncRefc(); } else { pr_err("MksckBind: host bind called on vmid 0x%X\n", addr.vmId); mksckPage = MksckPage_GetFromVmIdIncRefc(addr.vmId); } if (mksckPage == NULL) { pr_err("MksckBind: no mksckPage for vm 0x%X\n", addr.vmId); return -ENETUNREACH; } addr.vmId = mksckPage->vmId; err = Mutex_Lock(&mksckPage->mutex, MutexModeEX); if (err < 0) goto outDec; addr.port = MksckPage_GetFreePort(mksckPage, addr.port); if (addr.port == MKSCK_PORT_UNDEF) { err = -EINVAL; goto outUnlockDec; } mksck = MksckPage_AllocSocket(mksckPage, addr); if (mksck == NULL) { err = -EMFILE; goto outUnlockDec; } Mutex_Unlock(&mksckPage->mutex, MutexModeEX); sk->sk_protinfo = mksck; PRINTK("MksckBind: socket bound to %08X\n", mksck->addr.addr); return 0; outUnlockDec: Mutex_Unlock(&mksckPage->mutex, MutexModeEX); outDec: MksckPage_DecRefc(mksckPage); return err; }
void Task_P1() { Mutex_Lock(mut1); Mutex_Lock(mut1); Task_Sleep(5); Mutex_Unlock(mut1); Mutex_Unlock(mut1); Task_Sleep(5); for(;;){ } }
//#pragma CODE_SECTION(ITaskQ_Write,".textDDR") VOID ITaskQ_Write(ITaskQ *pThis, VOID *pVal) { Mutex_Lock(&pThis->oLock); FIFO_Put(&pThis->oQ, pVal); Signal_Post(&pThis->oWrite); Mutex_Unlock(&pThis->oLock); }
void* listenerThreadFunc(void* data) { char filepath[1000], uuidStr[36], filetype[40], line[1100]; struct FileDefinition * f; uuid_t uuid; char c; while (true) { memset(filepath, '\0', 1000); memset(uuidStr, '\0', 36); memset(filetype, '\0', 40); memset(line, '\0', 1100); if (fgets(line, 1100, stdin) != NULL) { sscanf(line, "--uuid=%s --type=%s --file=%s\n", uuidStr, filetype, filepath); //printf("GOT: line=%s PARSED TO: --uuid=%s --type=%s --file=%s\n", line, uuidStr, filetype, filepath); } if ( strlen(filepath) > 0 ) { if (strcmp(uuidStr, "none") != 0) uuid_parse(uuidStr, uuid); else if (strcmp(filetype, "none") != 0) UUID_Get_UUID(filetype, UUID_TYPE_DATA_TYPE, uuid); else uuid_parse("0", uuid); f = createFileDefinition(filepath, uuid); Mutex_Lock(mutex); pushFileList(f); Mutex_Unlock(mutex); } else { usleep(500000); } } return NULL; }
/** * @brief Unlock the mutex and prepare to sleep on a kernel polling table * given as anonymous parameters for poll_wait * @param mutex as passed to Mutex_Lock() * @param mode as passed to Mutex_Lock() * @param cvi which condition variable to sleep on * @param filp which file to poll_wait upon * @param wait which poll_table to poll_wait upon */ void Mutex_UnlPoll(Mutex *mutex, MutexMode mode, uint32 cvi, void *filp, void *wait) { ASSERT(cvi < MUTEX_CVAR_MAX); /* poll_wait is done with mutex locked to prevent any wake that comes * and defer them just after we unlock the mutex but before kernel * polling tables are used. Note that the kernel is probably avoiding * an exclusive wait in that case and also increments the usage for * the file given in filp. */ poll_wait(filp, (wait_queue_head_t *)mutex->cvarWaitQs[cvi], wait); /* * Tell anyone who might try to wake us that they need to actually call * WAKEUP***(). This is done in putting ourselves in a "noisy" mode * since there is no guaranty that we would really sleep, or if we * would be wakening the sleeping thread with that socket or condition. * This is done using a POLL_IN_PROGRESS_FLAG, but unfortunately it * has to be a per-cvi flag, in case we would poll independently on * different cvi. */ DMB(); ATOMIC_ORO(mutex->waiters, (POLL_IN_PROGRESS_FLAG << cvi)); /* * Release the mutex, someone can wake us up now. * They will see mutex->waiters non-zero so will actually do the wake. */ Mutex_Unlock(mutex, mode); }
/* * Destroy a filesystem buffer cache. * None of the buffers in the cache must be in use. * The cache must not be used after this function returns! */ int Destroy_FS_Buffer_Cache(struct FS_Buffer_Cache *cache) { int rc; struct FS_Buffer *buf; Mutex_Lock(&cache->lock); /* Flush all contents back to disk. */ rc = Sync_Cache(cache); /* Free all of the buffers. */ buf = Get_Front_Of_FS_Buffer_List(&cache->bufferList); while (buf != 0) { struct FS_Buffer *next = Get_Next_In_FS_Buffer_List(buf); Free_Buffer(buf); buf = next; } Clear_FS_Buffer_List(&cache->bufferList); Mutex_Unlock(&cache->lock); /* Free the cache object itself. */ Free(cache); return rc; }
void Task_P3(int parameter) { Mutex_Lock(mut); Task_Suspend(pid); Mutex_Unlock(mut); for(;;); }
/* * Register a filesystem. * This should only be called from Main(), before * any processes are started. * Params: * fsName - name of the filesystem type, e.g. "pfat", "gosfs" * fsOps - the Filesystem_Ops for the filesystem * Returns true if successful, false if not. */ bool Register_Filesystem(const char *fsName, struct Filesystem_Ops *fsOps) { struct Filesystem *fs; KASSERT(fsName != 0); KASSERT(fsOps != 0); KASSERT(fsOps->Mount != 0); Debug("Registering %s filesystem type\n", fsName); /* Allocate Filesystem struct */ fs = (struct Filesystem*) Malloc(sizeof(*fs)); if (fs == 0) return false; /* Copy filesystem name and vtable. */ fs->ops = fsOps; strncpy(fs->fsName, fsName, VFS_MAX_FS_NAME_LEN); fs->fsName[VFS_MAX_FS_NAME_LEN] = '\0'; /* Add the filesystem to the list */ Mutex_Lock(&s_vfsLock); Add_To_Back_Of_Filesystem_List(&s_filesystemList, fs); Mutex_Unlock(&s_vfsLock); return true; }
void Task_P1() { Task_Sleep(30); Mutex_Lock(mut1); Mutex_Unlock(mut1); for(;;); }
void Task_P3(int parameter) { Mutex_Lock(mut); Event_Wait(evt); Mutex_Unlock(mut); for(;;); }
int P(int sid) { struct Semaphore* sema = (&s_semaphoreList)->head; struct Mutex* mutex; struct Condition* cond; //find sem by sid while (sema != 0) { if (sema->sid == sid) { mutex = &(sema->mutex); // important cond = &(sema->cond); Enable_Interrupts(); Mutex_Lock(mutex); while(sema->count <= 0) { Cond_Wait(cond, mutex); //Print("WAKE UP!"); } sema->count--; Mutex_Unlock(mutex); Disable_Interrupts(); return 0; } sema = Get_Next_In_Semaphore_List(sema); } return -1; }
int V(int sid) { struct Semaphore* sema = (&s_semaphoreList)->head; struct Mutex* mutex; struct Condition* cond; //find sem by sid while (sema != 0) { if (sema->sid == sid) { mutex = &(sema->mutex); cond = &(sema->cond); Enable_Interrupts(); Mutex_Lock(mutex); sema->count = sema->count + 1; //Print("wait queue : %d", cond->waitQueue); Cond_Broadcast(cond); Mutex_Unlock(mutex); Disable_Interrupts(); return 0; } sema = Get_Next_In_Semaphore_List(sema); } return -1; }
TEST(MutexTest,RecursiveLockFails) { Mutex *m = Mutex_Alloc(); ASSERT_NE(m,(void*)NULL); Mutex_Lock(m); ASSERT_DEATH(Mutex_Lock(m),"Detected an attempt to recursively acquire a mutex.*"); Mutex_Unlock(m); Mutex_Free(m); }
// return NULL data if data is not available VOID *ITaskQ_ReadNoBlock( ITaskQ *pThis ) { VOID *pVal; Mutex_Lock(&pThis->oLock); pVal = FIFO_Get(&pThis->oQ); Mutex_Unlock(&pThis->oLock); return pVal; }
/** * @brief Unlock the mutex and sleep. Also does a data barrier before * unlocking so any modifications made before the lock gets released * will be completed before the lock is released. * @param mutex as passed to Mutex_Lock() * @param mode as passed to Mutex_Lock() * @param cvi which condition variable to sleep on * @param test sleep only if null or pointed atomic value mismatches mask * @param mask bitfield to check test against before sleeping * @param file the file of the caller code * @param line the line number of the caller code * @return rc = 0: successfully waited<br> * < 0: error waiting */ int Mutex_UnlSleepTestLine(Mutex *mutex, MutexMode mode, uint32 cvi, AtmUInt32 *test, uint32 mask, const char *file, int line) { DEFINE_WAIT(waiter); MutexCheckSleep(file, line); ASSERT(cvi < MUTEX_CVAR_MAX); /* * Tell anyone who might try to wake us that they need to actually call * WAKEUP***(). */ ATOMIC_ADDV(mutex->waiters, 1); /* * Be sure to catch any wake that comes along just after we unlock the * mutex but before we call schedule(). */ prepare_to_wait_exclusive((wait_queue_head_t *)mutex->cvarWaitQs[cvi], &waiter, TASK_INTERRUPTIBLE); /* * Release the mutex, someone can wake us up now. * They will see mutex->waiters non-zero so will actually do the wake. */ Mutex_Unlock(mutex, mode); /* * Wait to be woken or interrupted. */ if (test == NULL || (ATOMIC_GETO(*test) & mask) == 0) schedule(); finish_wait((wait_queue_head_t *)mutex->cvarWaitQs[cvi], &waiter); /* * Done waiting, don't need a wake any more. */ ATOMIC_SUBV(mutex->waiters, 1); /* * If interrupted, return error status. */ if (signal_pending(current)) return -ERESTARTSYS; /* * Wait completed, return success status. */ return 0; }
/* * Synchronize contents of cache with the disk * by writing out all dirty buffers. */ int Sync_FS_Buffer_Cache(struct FS_Buffer_Cache *cache) { int rc; Mutex_Lock(&cache->lock); rc = Sync_Cache(cache); Mutex_Unlock(&cache->lock); return rc; }
/** * @brief Unlock the semaphore and wake sleeping threads. Also does a data * barrier before unlocking so any modifications made before the lock * gets released will be completed before the lock is released. * @param mutex as passed to Mutex_Lock() * @param mode as passed to Mutex_Lock() * @param cvi which condition variable to signal * @param all false: wake a single thread<br> * true: wake all threads */ void Mutex_UnlWake(Mutex *mutex, MutexMode mode, uint32 cvi, _Bool all) { Mutex_Unlock(mutex, mode); Mutex_CondSig(mutex, cvi, all); }
/* PROGRAM: Philosopher A program that simulates a philosopher participating in a dining philosophers' symposium. Each philosopher will join the symposium, alternating between thinking, going hungry and eating a bite, for a number of bites. After he has eaten the last bite, he leaves. */ int Philosopher(int argl, void* args) { int i,j; int bites; /* Number of bites (mpoykies) */ assert(argl == sizeof(int[2])); i = ((int*)args)[0]; bites = ((int*)args)[1]; Mutex_Lock(&mx); /* Philosopher arrives in thinking state */ state[i] = THINKING; print_state(" %d has arrived\n",i); Mutex_Unlock(&mx); for(j=0; j<bites; j++) { think(i); /* THINK */ Mutex_Lock(&mx); /* GO HUNGRY */ state[i] = HUNGRY; trytoeat(i); /* This may not succeed */ while(state[i]==HUNGRY) { print_state(" %d waits hungry\n",i); Cond_Wait(&mx, &(hungry[i])); /* If hungry we sleep. trytoeat(i) will wake us. */ } assert(state[i]==EATING); Mutex_Unlock(&mx); eat(i); /* EAT */ Mutex_Lock(&mx); state[i] = THINKING; /* We are done eating, think again */ print_state(" %d is thinking\n",i); trytoeat(LEFT(i)); /* Check if our left and right can eat NOW. */ trytoeat(RIGHT(i)); Mutex_Unlock(&mx); } Mutex_Lock(&mx); state[i] = NOTHERE; /* We are done (eaten all the bites) */ print_state(" %d is leaving\n",i); Mutex_Unlock(&mx); return i; }
/* * Get a buffer for given filesystem block. */ int Get_FS_Buffer(struct FS_Buffer_Cache *cache, ulong_t fsBlockNum, struct FS_Buffer **pBuf) { int rc; Mutex_Lock(&cache->lock); rc = Get_Buffer(cache, fsBlockNum, pBuf); Mutex_Unlock(&cache->lock); return rc; }
/* * Explicitly synchronize given buffer with its on-disk storage, * without releasing the buffer. */ int Sync_FS_Buffer(struct FS_Buffer_Cache *cache, struct FS_Buffer *buf) { int rc; KASSERT(buf->flags & FS_BUFFER_INUSE); Mutex_Lock(&cache->lock); rc = Sync_Buffer(cache, buf); Mutex_Unlock(&cache->lock); return rc; }
/** ********************************************************************************* * \fn static void RSema_Test(void); * ********************************************************************************* */ static void RSema_Test(void) { Timer_Start(&tmrRSemaToggle,0); SleepMs(100); Timer_Start(&tmrRSemaToggle,4000); Con_Printf_P("Trying to lock rsema\n"); Mutex_Lock(&testRSema); Con_Printf_P("Success, Unlocking rsema\n"); Mutex_Unlock(&testRSema); }
void output_report(TestSuite *suite) { pthread_once(&global_mutxt_once, global_mutex_init); Mutex_Lock(&mutex); if (suite->outfile) { if (suite->generatexmlreport){ TestSuite_PrintXmlFooter (suite, suite->outfile); suite->generatexmlreport = false; } } Mutex_Unlock(&mutex); }
/* * client_init handles multiple threaded connects. It creates * a listener object if either the dual test or tradeoff were * specified. It also creates settings structures for all the * threads and arranges them so they can be managed and started * via the one settings structure that was passed in. */ void client_init( thread_Settings *clients ) { thread_Settings *itr = NULL; thread_Settings *list = NULL; thread_Settings *next = NULL; // Set the first thread to report Settings (except cli side Reverse) setReport( clients ); if (clients->mMode == kTest_Reverse && !isOnServer(clients)) { unsetReport( clients ); } itr = clients; // See if we need to start a listener as well Settings_GenerateListenerSettings( clients, &list ); // Create a multiple report header to handle reporting the // sum of multiple client threads Mutex_Lock( &groupCond ); groupID--; clients->multihdr = InitMulti( clients, groupID ); Mutex_Unlock( &groupCond ); #ifdef HAVE_THREAD if ( list != NULL && !isNAT(list)) { // We have threads and we need to start a listener so // have it ran before the client is launched (unless behind NAT) itr->runNow = list; itr = list; } #endif // For each of the needed threads create a copy of the // provided settings, unsetting the report flag and add // to the list of threads to start for (int i = 1; i < clients->mThreads; i++) { Settings_Copy( clients, &next ); unsetReport( next ); itr->runNow = next; itr = next; } #ifndef HAVE_THREAD if ( list != NULL ) { // We don't have threads and we need to start a listener so // have it ran after the client is finished itr->runNext = list; } #else if ( list != NULL && isNAT(list) ) { // We have threads and we need to start a listener so // have it ran after the client is launched (when behind NAT) itr->runNext = list; } #endif }
void* inc(void *a) { counter *c=(counter*)a; int v; Mutex_Lock(c->lock); v=c->n; v++; pause_random_10ms(NULL); pause_random_10ms(NULL); c->n = v; Mutex_Unlock(c->lock); return 0; }
static void RSemaTestEvProc(void *evData) { static uint8_t toggle = false; toggle = !toggle; Con_Printf_P("RSemaTestTimer %08lx %d\n",Thread_Current(),toggle); if(toggle == true) { Mutex_Lock(&testRSema); } else { Mutex_Unlock(&testRSema); } }
VOID *ITaskQ_Read( ITaskQ *pThis ) { VOID *pVal; Mutex_Lock(&pThis->oLock); pVal = FIFO_Get(&pThis->oQ); while( pVal == NULL ) { Mutex_Unlock(&pThis->oLock); Signal_Pend(pThis->pRead); Mutex_Lock(&pThis->oLock); pVal = FIFO_Get(&pThis->oQ); } Mutex_Unlock(&pThis->oLock); return pVal; }
void Mksck_DecRefc(Mksck *mksck) { uint32 oldRefc; DMB(); do { while ((oldRefc = ATOMIC_GETO(mksck->refCount)) == 1) { MksckPage *mksckPage = Mksck_ToSharedPage(mksck); while (Mutex_Lock(&mksckPage->mutex, MutexModeEX) < 0) ; if (ATOMIC_SETIF(mksck->refCount, 0, 1)) { #if 0 KNOWN_BUG(MVP-1349); PRINTK("Mksck_DecRefc: %08X " \ "shutDown %u, foundEmpty %u, " \ "foundFull %u, blocked %u\n", mksck->addr.addr, mksck->shutDown, mksck->foundEmpty, mksck->foundFull, ATOMIC_GETO(mksck->mutex.blocked)); #endif ASSERT(mksck->peer == 0); Mutex_Unlock(&mksckPage->mutex, MutexModeEX); MksckPage_DecRefc(mksckPage); return; } Mutex_Unlock(&mksckPage->mutex, MutexModeEX); } ASSERT(oldRefc != 0); } while (!ATOMIC_SETIF(mksck->refCount, oldRefc - 1, oldRefc)); }
void Task_P3(){ PORTB = 0x40; _delay_ms(10); PORTB = 0x00; Mutex_Lock(mut); Event_Wait(evt); PORTB = 0x40; _delay_ms(10); PORTB = 0x00; Mutex_Unlock(mut); for(;;); }
/* * Look up given filesystem type. * Params: * fstype - name of the filesystem type * Returns: the Filesystem object for the filesystem, or null * if no such filesystem exists. */ static struct Filesystem *Lookup_Filesystem(const char *fstype) { struct Filesystem *fs; Mutex_Lock(&s_vfsLock); fs = Get_Front_Of_Filesystem_List(&s_filesystemList); while (fs != 0) { if (strcmp(fs->fsName, fstype) == 0) break; fs = Get_Next_In_Filesystem_List(fs); } Mutex_Unlock(&s_vfsLock); return fs; }