int main() { lock = CreateLock("lock"); cv2 = CreateCV("cv2"); AcquireLock("lock"); SignalCV("lock","cv2"); Print("Client 3 will now destroy CV...",-1,-1,-1); DestroyCV("cv2"); for (i=0; i<9; i++) Print("\n",-1,-1,-1); ReleaseLock("lock"); AcquireLock("lock"); WaitCV("lock","cv2"); Print("Client 3: This prints as CV has been destroyed...",-1,-1,-1); ReleaseLock("lock"); Exit(0); }
void otudp_output(OTUDP *x) { // This is called by the Max clock. It's guaranteed not to be called // at notifier level, although if we're in Overdrive this will be called // at interrupt level. Atom arguments[2]; PacketBuffer b; short oldLockout; // BufferSanityCheck(x, 0, 0, 0); while (1) { oldLockout = AcquireLock(x); b = PBFIFODequeue(&(x->pendingBuffers)); ReleaseLock(x,oldLockout); if (b == 0) break; SETLONG(&arguments[0], b->n); SETLONG(&arguments[1], (long) b->buf); outlet_anything(x->o_outlet, ps_FullPacket, 2, arguments); oldLockout = AcquireLock(x); PacketBufferListPush(b, &(x->freeBuffers)); ReleaseLock(x,oldLockout); } // BufferSanityCheck(x, 0, 0, 0); }
void ReleaseProcessMemory(HANDLE hProc) { DWORD pid,addr,len; AcquireLock(); if (hProc==NtCurrentProcess()) pid=current_process_id; else { PROCESS_BASIC_INFORMATION info; NtQueryInformationProcess(hProc,ProcessBasicInformation,&info,sizeof(info),&len); pid=info.uUniqueProcessId; } pid>>=2; //NtWaitForSingleObject(thread_man_mutex,0,0); for (UINT_PTR i=0;i<count;i++) { if ((proc_record[i]&0xFFF)==pid) { addr=proc_record[i]&~0xFFF; DWORD size=0x1000; NtFreeVirtualMemory(hProc,(PVOID*)&addr,&size,MEM_RELEASE); count--; for (UINT_PTR j=i;j<count;j++) { proc_record[j]=proc_record[j+1]; } proc_record[count]=0; ReleaseLock(); //NtReleaseMutant(thread_man_mutex,0); return; } } ReleaseLock(); //NtReleaseMutant(thread_man_mutex,0); }
VOID Image(IMG img, VOID *v){ char szFilePath[260]; unsigned long index; GetLock(&lock, 1); if (process_start != 0){ ReleaseLock(&lock); return; } if (IMG_Valid(img)){ memset(szFilePath, 0, sizeof(szFilePath)); strncpy(szFilePath, IMG_Name(img).c_str(), sizeof(szFilePath)-1); index = 0; while (szFilePath[index] != 0){ szFilePath[index] = tolower(szFilePath[index]); index++; } if (strstr(szFilePath, KnobProcessToTrace.Value().c_str())){ process_start = IMG_LowAddress(img); process_end = IMG_HighAddress(img); } } ReleaseLock(&lock); }
void main() { lck = CreateLock("lock1"); cv = CreateCV("cv1"); Print("\nDistCVTest1_1: Created Lock is %d and CV is %d\n", lck, cv, -1); AcquireLock("lock1"); Print("Client 1: About to go on wait...\n", -1, -1, -1); WaitCV("lock1","cv1"); Print("Client 1: Now out of wait...\n", -1, -1, -1); for (num=0; num<10; num++) Print("\n",-1,-1,-1); Print("Client 1: About to signal Client 2\n", -1, -1, -1); SignalCV("lock1","cv1"); ReleaseLock("lock1"); AcquireLock("lock1"); ReleaseLock("lock1"); Exit(0); }
int monte_carlo_pi(unsigned int n, int procNumber) { AcquireLock(); printf("CORE %d\n", procNumber); ReleaseLock(); int in = 0, i; int x, y, d; int limit; limit = n*(procNumber + 1)/CORES; if (procNumber == CORES - 1) { //ultimo core, faz o resto limit = n; } for (i = n*procNumber/CORES; i < limit; i++) { //x = ((*randNum % 1000000)/500000.0)-1; x = (((getRandomNumber() % 1000000)/500000)-1)*10; y = (((getRandomNumber() % 1000000)/500000)-1)*10; //y = ((*randNum % 1000000)/500000.0)-1; //x = 1; //y = 2; d = ((x*x) + (y*y)); //AcquireLock(); if (d <= 10) { in+=1; } //ReleaseLock(); } AcquireLock(); printf("IN: %d\n", in); ReleaseLock(); return in; }
/* *---------------------------------------------------------------------- * * OS_Accept -- * * Accepts a new FastCGI connection. This routine knows whether * we're dealing with TCP based sockets or NT Named Pipes for IPC. * * Results: * -1 if the operation fails, otherwise this is a valid IPC fd. * * Side effects: * New IPC connection is accepted. * *---------------------------------------------------------------------- */ int OS_Accept(int listen_sock, int fail_on_intr, const char *webServerAddrs) { int socket; union { struct sockaddr_un un; struct sockaddr_in in; } sa; for (;;) { if (AcquireLock(listen_sock, fail_on_intr)) return -1; for (;;) { do { int len = sizeof(sa); socket = accept(listen_sock, (struct sockaddr *)&sa, &len); } while (socket < 0 && errno == EINTR && !fail_on_intr); if (socket < 0) { if (!is_reasonable_accept_errno(errno)) { int errnoSave = errno; ReleaseLock(listen_sock); errno = errnoSave; return (-1); } errno = 0; } else { /* socket >= 0 */ int set = 1; if (sa.in.sin_family != AF_INET) break; #ifdef TCP_NODELAY /* No replies to outgoing data, so disable Nagle */ setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *)&set, sizeof(set)); #endif /* Check that the client IP address is approved */ if (ClientAddrOK(&sa.in, webServerAddrs)) break; close(socket); } /* socket >= 0 */ } /* for(;;) */ if (ReleaseLock(listen_sock)) return (-1); if (sa.in.sin_family != AF_UNIX || is_af_unix_keeper(socket)) break; close(socket); } /* while(1) - lock */ return (socket); }
static BOOL Intercept(THREADID tid, DEBUGGING_EVENT eventType, CONTEXT *ctxt, VOID *) { if (eventType == DEBUGGING_EVENT_BREAKPOINT) { // When the child thread reaches the breakpoint in Breakpoint(), wait for the main // thread to reach the One() function. If the main thread is not there yet, squash the // breakpoint and move the PC back to the start of the Breakpoint() function. This will // delay a while and then re-trigger the breakpoint. // ADDRINT pc = PIN_GetContextReg(ctxt, REG_INST_PTR); if (pc == BreakpointLocation && !AllowBreakpoint) { PIN_SetContextReg(ctxt, REG_INST_PTR, BreakpointFunction); GetLock(&Lock, 1); std::cout << "Squashing breakpoint at 0x" << std::hex << pc << " on thread " << std::dec << tid << std::endl; ReleaseLock(&Lock); return FALSE; } GetLock(&Lock, 1); std::cout << "Stopping at breakpoint at 0x" << std::hex << pc << " on thread " << std::dec << tid << std::endl; ReleaseLock(&Lock); return TRUE; } if (eventType == DEBUGGING_EVENT_ASYNC_BREAK) { // When the child thread triggers the breakpoint, we should be at the One() function. // Change the PC to the Two() function, which is the point of this test. We want to // make sure Pin properly handles the change of PC in this case. // ADDRINT pc = PIN_GetContextReg(ctxt, REG_INST_PTR); if (pc == OneFunction) { PIN_SetContextReg(ctxt, REG_INST_PTR, TwoFunction); GetLock(&Lock, 1); std::cout << "Changing ASYNC BREAK PC to Two() on thread " << std::dec << tid << std::endl; ReleaseLock(&Lock); return TRUE; } // If the PC is not at the One() function, the child thread has probably hit some breakpoint // other than the one at Breakpoint(). (E.g. an internal breakpoint set by GDB.) Don't // change the PC in such a case. // GetLock(&Lock, 1); std::cout << "ASYNC_BREAK at 0x" << std::hex << pc << " on thread " << std::dec << tid << std::endl; ReleaseLock(&Lock); return TRUE; } GetLock(&Lock, 1); std::cout << "FAILURE: Unexpected debugging event type" << std::endl; ReleaseLock(&Lock); std::exit(1); }
LPVOID GetProcAddr(HANDLE hProc) { AcquireLock(); DWORD pid,addr,len; if (hProc==NtCurrentProcess()) pid=current_process_id; else { PROCESS_BASIC_INFORMATION info; NtQueryInformationProcess(hProc,ProcessBasicInformation,&info,sizeof(info),&len); pid=info.uUniqueProcessId; } pid>>=2; for (UINT_PTR i=0;i<count;i++) { if ((proc_record[i]&0xFFF)==pid) { addr=proc_record[i]&~0xFFF; ReleaseLock(); return (LPVOID)addr; } } len=0x1000; NtAllocateVirtualMemory(hProc,(PVOID*)(proc_record+count),0,&len, MEM_COMMIT,PAGE_EXECUTE_READWRITE); DWORD base = proc_record[count]; proc_record[count] |= pid; union { LPVOID buffer; DWORD b; }; b = base; LPVOID fun_table[3]; *(DWORD*)(normal_routine + ADDR0) += base; NtWriteVirtualMemory(hProc, buffer, normal_routine, 0x14, 0); *(DWORD*)(normal_routine + ADDR0) -= base; b += 0x14; fun_table[0] = NtTerminateThread; fun_table[1] = NtQueryVirtualMemory; fun_table[2] = MessageBoxW; NtWriteVirtualMemory(hProc, buffer, fun_table, 0xC, 0); b += 0xC; *(DWORD*)(except_routine + ADDR1) += base; *(DWORD*)(except_routine + ADDR2) += base; *(DWORD*)(except_routine + ADDR3) += base; NtWriteVirtualMemory(hProc, buffer, except_routine, 0xE0, 0); *(DWORD*)(except_routine + ADDR1) -= base; *(DWORD*)(except_routine + ADDR2) -= base; *(DWORD*)(except_routine + ADDR3) -= base; count++; ReleaseLock(); return (LPVOID)base; }
int main() { mv = CreateMV("mv1"); mv2 = CreateMV("mv2"); lck = CreateLock("lock1"); lck2 = CreateLock("lock2"); cv = CreateCV("cv1"); for (loop =0; loop<500; loop++) { AcquireLock(lck); SignalCV(lck,cv); AcquireLock(lck2); ret = GetMV(mv2); ReleaseLock(lck2); if (ret != 21)/*This will wait only if the other one isnt finished*/ WaitCV(lck,cv); mvEdit = GetMV(mv); Print("Client 2: Monitor variable was read to be %d..",mvEdit,-1,-1); mvEdit+=7; ret=SetMV(mv,mvEdit); mvEdit = GetMV(lck); Print("Client 2: Monitor variable was set to be %d..",mvEdit,-1,-1); ReleaseLock(lck); Print("Client 2: %d Iterations done..",loop,-1,-1); } AcquireLock(lck2); ret = SetMV(mv2,21); /*this monitor variable is set to 21 here to signify *one of the processes is over and the other will not *wait for it to signal it */ ReleaseLock(lck2); AcquireLock(lck); SignalCV(lck,cv); ReleaseLock(lck); }
void main() { lck = CreateLock("lock1"); cv = CreateCV("cv1"); Print("Client 2: Created Lock is %d and CV is %d\n", lck, cv, -1); AcquireLock("lock1"); Print("Client 2: About to signal Client 1\n", -1, -1, -1); SignalCV("lock1","cv1"); Print("Client 2: About to go on wait...\n", -1, -1, -1); WaitCV("lock1","cv1"); for (i=0; i<10; i++) Print("\n",-1,-1,-1); Print("Client 2: Now out of wait...\n", -1, -1, -1); ReleaseLock("lock1"); Exit(0); }
// Note that opening a file in a callback is only supported on Linux systems. // See buffer-win.cpp for how to work around this issue on Windows. // // This routine is executed every time a thread is created. VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) { GetLock(&lock, threadid+1); fprintf(out, "thread begin %d\n",threadid); fflush(out); ReleaseLock(&lock); }
void t5_t3(){ test=AcquireLock(LockIndex1); Write("3 acquired\n", sizeof("3 acquired\n"), 1); test=ReleaseLock(LockIndex1); Write("3 released\n", sizeof("3 released\n"), 1); Exit(0); }
// This routine is executed each time malloc is called. VOID BeforeMalloc( int size, THREADID threadid ) { GetLock(&lock, threadid+1); fprintf(out, "thread %d entered malloc(%d)\n", threadid, size); fflush(out); ReleaseLock(&lock); }
/*! * Print out analysis results. * This function is called when the application exits. * @param[in] code exit code of the application * @param[in] v value specified by the tool in the * PIN_AddFiniFunction function call */ VOID Fini(INT32 code, VOID *v) { GetLock(&fileLock, 1); fclose(outfile); printf("outfile closed\n"); ReleaseLock(&fileLock); }
void CheckProcessMemory() { UINT_PTR i,j,flag,addr; DWORD len; CLIENT_ID id; OBJECT_ATTRIBUTES oa={0}; HANDLE hProc; BYTE buffer[8]; AcquireLock(); id.UniqueThread=0; oa.uLength=sizeof(oa); for (i=0;i<count;i++) { id.UniqueProcess=(proc_record[i]&0xFFF)<<2; addr=proc_record[i]&~0xFFF; flag=0; if (NT_SUCCESS(NtOpenProcess(&hProc,PROCESS_VM_OPERATION|PROCESS_VM_READ,&oa,&id))) { if (NT_SUCCESS(NtReadVirtualMemory(hProc,(PVOID)addr,buffer,8,&len))) if (memcmp(buffer,normal_routine,4)==0) flag=1; NtClose(hProc); } if (flag==0) { for (j=i;j<count;j++) proc_record[j]=proc_record[j+1]; count--; i--; } } ReleaseLock(); }
//Track the first instance of our App. //return TRUE on success, else FALSE BOOL CInstanceChecker::TrackFirstInstanceRunning() { //If a previous instance is running, just return prematurely if (PreviousInstanceRunning()) return FALSE; //If this is the first instance then copy in our info into the shared memory //First create the MMF int nMMFSize = sizeof(CWindowInstance); g_sinstanceData.hInstanceData = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, nMMFSize, GetMMFFilename()); if (g_sinstanceData.hInstanceData == NULL) { TRACE(_T("Failed to create the MMF even though this is the first instance, you might want to consider overriding GetMMFFilename()\n")); return FALSE; } //Open the MMF CWindowInstance* pInstanceData = static_cast<CWindowInstance*>(MapViewOfFile(g_sinstanceData.hInstanceData, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, nMMFSize)); ASSERT(pInstanceData != NULL); //Opening the MMF should work //Lock the data prior to updating it CSingleLock dataLock(&m_instanceDataMutex, TRUE); pInstanceData->hMainWnd = GetWindowToTrack(); UnmapViewOfFile(pInstanceData); //Since this will be the last function that will be called //when this is the first instance we can release the lock ReleaseLock(); return TRUE; }
static Boolean BufferSanityCheck(OTUDP *x, int *freep, int *pendingp, int *outgoingp) { short oldLockout; int free, pending, outgoing, i; free = 100; // In case we fail to acquire lock // Mutual exclusion to prevent the lists from changing out from under me oldLockout = AcquireLock(x); free = CountPacketList(x->freeBuffers); pending = CountPacketList(x->pendingBuffers.first); outgoing = 0; ReleaseLock(x,oldLockout); if (freep != 0) *freep = free; if (pendingp != 0) *pendingp = pending; if (outgoingp != 0) *outgoingp = outgoing; if (free+pending+outgoing != x->nbufs) { error("otudp: BufferSanityCheck failed! %d free + %d pending + %d outgoing = %d", free, pending, free+pending+outgoing); return false; } else { return true; } }
int main() { lock = CreateLock("lock"); lock2 = CreateLock("lock2"); cv1 = CreateCV("cv1"); cv2=CreateCV("cv2"); AcquireLock("lock"); SignalCV("lock","cv1"); Print("Client 2 is going to wait...",-1,-1,-1); WaitCV("lock","cv2"); for (i=0; i<9; i++) Print("\n",-1,-1,-1); Print("Client 2 is now out of wait...",-1,-1,-1); ReleaseLock("lock"); Exit(0); }
// This routine is executed every time a thread is destroyed. VOID ThreadFini(THREADID threadid, const CONTEXT *ctxt, INT32 code, VOID *v) { GetLock(&lock, threadid+1); fprintf(out, "thread end %d code %d\n",threadid, code); fflush(out); ReleaseLock(&lock); }
/////////////////////////////////////////////////////////////////////////////// // HandleIoctlPowerSet // Input: pMemCard - SD memory card structure // pDevicePowerState - device power state // Output: // Return: // Notes: /////////////////////////////////////////////////////////////////////////////// VOID HandleIoctlPowerSet(PSD_MEMCARD_INFO pMemCard, PCEDEVICE_POWER_STATE pDevicePowerState) { AcquireLock(pMemCard); DEBUGMSG(SDMEM_ZONE_POWER, (TEXT("SDMemory: IOCTL_POWER_SET %d \n"),*pDevicePowerState)); if (*pDevicePowerState < pMemCard->PowerStateForIdle) { // everything above the power state for idle is treated as D0 *pDevicePowerState = D0; pMemCard->CurrentPowerState = D0; // disable low power operation pMemCard->EnableLowPower = FALSE; } else { // everything above the IDLE power state is set to IDLE *pDevicePowerState = pMemCard->PowerStateForIdle; pMemCard->CurrentPowerState = pMemCard->PowerStateForIdle; // enable low power operation pMemCard->EnableLowPower = TRUE; // wake up the idle thread to go into power idle polling SetEvent(pMemCard->hWakeUpIdleThread); } ReleaseLock(pMemCard); }
VOID Error(std::string where, THREADID tid, UINT32 r, ADDRINT expect, ADDRINT val) { GetLock(&Lock, 1); Out << "Mismatch " << where << ": tid=" << std::dec << tid << " (G" << r << ")" << ", Expect " << std::hex << expect << ", Got " << std::hex << val << std::endl; ReleaseLock(&Lock); }
// ----------------------------------------------------------------------------- // CPosLmLocalReadPartialLmOp::HandleError // // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CPosLmLocalReadPartialLmOp::HandleError( TInt& aError) { iStatusFlag = aError; ReleaseLock(); }
CHAR16 * SEnvIGetStr ( IN CHAR16 *Name, IN EFI_LIST_ENTRY *Head ) /*++ Routine Description: Arguments: Name - The variable name Head - The variable list Returns: --*/ { VARIABLE_ID *Var; CHAR16 *Value; AcquireLock (&SEnvLock); // // Walk through linked list to find corresponding Var // Value = NULL; Var = SEnvFindVar (Head, Name); if (Var != NULL) { Value = Var->u.Str; } ReleaseLock (&SEnvLock); return Value; }
bool ConnectionNoMoreUsed (Connection* connection, ConnectionOwner owner) { bool result = true; int i = 0; TakeLock(connection->closedByLock); connection->closedBy[owner] = true; Log(AIO4C_LOG_LEVEL_DEBUG, "connection %s closed by: [reader:%u,worker:%u,writer:%u,acceptor:%u,client:%u]", connection->string, connection->closedBy[AIO4C_CONNECTION_OWNER_READER], connection->closedBy[AIO4C_CONNECTION_OWNER_WORKER], connection->closedBy[AIO4C_CONNECTION_OWNER_WRITER], connection->closedBy[AIO4C_CONNECTION_OWNER_ACCEPTOR], connection->closedBy[AIO4C_CONNECTION_OWNER_CLIENT]); for (i = 0; i < AIO4C_CONNECTION_OWNER_MAX && result; i++) { result = (result && connection->closedBy[i]); } if (result) { memset(connection->closedBy, 0, AIO4C_CONNECTION_OWNER_MAX * sizeof(bool)); } ReleaseLock(connection->closedByLock); return result; }
void t2_t1() { /* checks acquire and release invalid input is handled properly.*/ indexcheck1 = AcquireLock(5000); indexcheck2 = ReleaseLock(5000); indexcheck3 = AcquireLock(-1); indexcheck4= ReleaseLock(-1); /*this function is called the last among the functions that are used for the same test. print out the result and FORK next text function*/ if(indexcheck1 == - 1 && indexcheck2 == -1 && indexcheck3 == -1 && indexcheck4 == -1) { Write("passed: acquire/releaselock validates input\n", sizeof("passed: acquire/releaselock validates input\n"), 1); }else{ Write("failed: acquire/releaselock validates input\n", sizeof("failed: acquire/releaselock validates input\n"), 1); } Exit(0); }
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) { GetLock(&lock, threadid+1); numThreads++; ReleaseLock(&lock); ASSERT(numThreads <= MaxNumThreads, "Maximum number of threads exceeded\n"); }
/* * finding total number of customer in particular queue * */ int getTotalCustCount(int debugId, mtQueue *queue) { int count; AcquireLock(queueLock[queue->queueType][queue->queueId]); count=getMv(&queue->numCust); ReleaseLock(queueLock[queue->queueType][queue->queueId]); return count ; }
/* * obtain current state of customer - * We acquire a lock before seeing it * and release lock once we are done * */ int getCustState(int debugId, int custId, int grpId) { int state; AcquireLock(custLock[grpId][custId]); state = getMv(&mtCb.custGrp[grpId].cust[custId].state); ReleaseLock(custLock[grpId][custId]); return state; }
VOID ThreadBegin(UINT32 threadid, VOID * sp, int flags, VOID *v) { GetLock(&lock, threadid+1); numThreads++; ReleaseLock(&lock); ASSERT(numThreads <= MaxNumThreads, "Maximum number of threads exceeded\n"); }