int LoopCommand1(ThreadData* aThreadData) { int j = 0,retval=0; struct timespec abstime; struct timeval now; gettimeofday(&now,NULL); abstime.tv_sec = now.tv_sec - 5; abstime.tv_nsec = now.tv_usec * 1000; for(int i=0; i < 1000; i += 100) { j++; if(j == 255) { j = 0; #ifdef WINDOWS printf("%dLooping Id: %d Cmd1 %d Cmd2 %d\n",i,aData->iSelf,Command1, Command2); #else { //MSG(_L("%dLooping Id: %d Cmd1 %d Cmd2 %d\n"),i,aData->iSelf,Command1, Command2); } #endif } retval = SemTimedWait(aThreadData,&abstime); retval = SemPost(aThreadData); } return retval; }
/*----------------------------------------------------------------------------- | Function : sflash_get_status | | Parameters : OUT : unsigned char * : Status of Flash Device | | Return Value : 0 - on Success, Non-zero on failure | +----------------------------------------------------------------------------*/ int sflash_get_status( unsigned char *pStat) { int iRetVal = SFLASH_SUCCESS; char temp[5]; SCP_RW_STRUCT scp_rw; // int i; /* build the command */ memset(flash_cmd, 0, 296); flash_cmd[0] = S_FLASH_STATUS_CMD; flash_cmd[1] = S_FLASH_STATUS_CMD; flash_cmd[2] = 0x00; flash_cmd[3] = 0x00; flash_cmd[4] = 0x00; // setup the SCP_RW structure scp_rw.write_ptr = flash_cmd; scp_rw.read_ptr = temp; scp_rw.count = 4; /* Use SFLASH In Use Semaphore */ SemWait(sSFlashInUseSem); if(ioctl(fd, IOCTL_SCP_RW, &scp_rw) != 0) { printf("sflash_get_status failed with RC = %x \n", iRetVal); return -1; } *pStat = scp_rw.read_ptr[1]; SemPost(sSFlashInUseSem); return 0; }
int sflash_send_cmd(unsigned char * pInput, unsigned char * pOutput, unsigned long dwLen) { SCP_RW_STRUCT scp_rw; int i; PDEBUG("sflash_send_cmd: pInput = 0x%8.8x, pOutput = 0x%8.8x, dwLen = %d\n", pInput, pOutput, dwLen); if(dwLen > SCP_BUFFER_SIZE) { printf("ERROR: sflash_send_cmd: dwLen 0x%x is larger than SCP_BUFFER_SIZE 0x%x\n",dwLen,SCP_BUFFER_SIZE); return -1; } // setup the SCP_RW structure scp_rw.write_ptr = pInput; scp_rw.read_ptr = pOutput; scp_rw.count = dwLen; /* Use SFLASH In Use Semaphore */ SemWait(sSFlashInUseSem); if(ioctl(fd, IOCTL_SCP_RW, &scp_rw) != 0) { printf("sflash_send_cmd failed.\n"); return -1; } SemPost(sSFlashInUseSem); return 0; }
error_code threadlib_signal_sem(HSEM *e) { if (!e) return SR_ERROR_INVALID_PARAM; SemPost(*e); return SR_SUCCESS; }
static void dchild6( DREC *pdr, CHILD *pc ) { int rc; // Get the lock to synchronize with parent SemPend( hDSem6, SEM_FOREVER ); SemPost( hDSem6 ); // This function returns "1" if the socket is still open, // and "0" is the socket has been closed. rc = pdr->pCb( pc->s, pdr->Argument ); // Close the socket if we need to // We do this before we get the lock so if the socket // uses LINGER, we don't hold everyone up if( rc && pc->closeSock ) fdClose( pc->s ); // Get our lock SemPend( hDSem6, SEM_FOREVER ); // Close the socket session (if open) if( pc->hTask ) fdCloseSession( pc->hTask ); // Remove our record from the DREC if( pc->pNext ) pc->pNext->pPrev = pc->pPrev; if( !pc->pPrev ) pdr->pC = pc->pNext; else pc->pPrev->pNext = pc->pNext; pdr->TasksSpawned--; // Free our record mmFree( pc ); // Kick the parent thread if( hDTask6 ) fdSelectAbort( hDTask6 ); // Release the lock SemPost( hDSem6 ); TaskExit(); }
void f(void* arg) { int n = *((int*)arg); SemWait(&s); PutInt(n); PutString("\n"); SemPost(&s); UserThreadExit(0); }
void relacher_verrou() { int error; // section critique error = SemPost(&sem); if(error != 0) { PutString("[mem.c] erreur semaphore post\n"); Exit(1); } }
/** * @b Description * @n * The function is to used cleanup a previously created V6 daemon. * * @param[in] hEntry * This is the handle to the daemon which was previously created * using Daemon6New * @sa * Daemon6New * * @retval * Not Applicable. */ void Daemon6Free( HANDLE hEntry ) { DREC *pdr = (DREC *)hEntry; CHILD *pc; // At this point we must have a semaphore if( !hDSem6 ) return; // Enter our own lock SemPend( hDSem6, SEM_FOREVER ); // Sanity check if( pdr->Type!=SOCK_STREAM && pdr->Type!=SOCK_DGRAM ) goto errorout; // Clear the record pdr->Type = 0; RequestedRecords6--; // Close the socket session of all children. This will // cause them to eventually fall out of their code and // close their sockets pc = pdr->pC; while( pc ) { if( pc->hTask ) { fdCloseSession( pc->hTask ); pc->hTask = 0; } pc = pc->pNext; } // Close the socket (this will wake anyone who's using it) if( pdr->s != INVALID_SOCKET ) { fdClose( pdr->s ); pdr->s = INVALID_SOCKET; } // If there are no more records, close the daemon task's // file descriptor session. That will cause it to error // out and remove itself if( !RequestedRecords6 ) { fdCloseSession( hDTask6 ); hDTask6 = 0; } errorout: // Exit our lock SemPost( hDSem6 ); }
int LoopCommand2(ThreadData* aThreadData) { int j = 0,retval=0; for(int i=0; i < 1000; i += 100) { j++; if(j == 255) { j = 0; #ifdef WINDOWS printf("%dLooping Id: %d Cmd1 %d Cmd2 %d\n",i,aData->iSelf,Command1, Command2); #else { //MSG(_L("%dLooping Id: %d Cmd1 %d Cmd2 %d\n"),i,aData->iSelf,Command1, Command2); } #endif } retval = SemPost(aThreadData); retval = SemWait(aThreadData); } return retval; }
int main() { PutString("\n-----------------------------------------\n"); PutString("Lancement du test testBcpThreads : \n"); PutString("Lance plusieurs threads affichant un nombre different avec semaphore pour l'acces.\n"); PutString("-----------------------------------------\n"); int i; int nb[NB_THREADS]; SemInit(&s, 1); for(i = 0 ; i < NB_THREADS ; i++) { nb[i] = i; if(UserThreadCreate(f, &nb[i]) == -1) { SemWait(&s); PutString("Echec de creation du thread : "); PutInt(i); PutString("\n"); SemPost(&s); } } PutString("thread main se termine\n"); return 0; }
TInt CTestSemtrywait::TestSem392( ) { int errsum=0, err = 0; int retval = 0; ThreadData lThreadData; sem_t lSignalSemaphore; sem_t lSuspendSemaphore; sem_t lTestSemaphore; pthread_mutex_t lTestMutex; pthread_cond_t lTestCondVar; pthread_condattr_t lCondAttr; pthread_mutexattr_t lTestMutexAttr; pthread_mutexattr_t defaultattr; pthread_mutexattr_t errorcheckattr; pthread_mutexattr_t recursiveattr; pthread_mutexattr_init(&defaultattr); pthread_mutexattr_init(&errorcheckattr); pthread_mutexattr_init(&recursiveattr); pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK); pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE); pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; pthread_cond_t l_staticcondvar = PTHREAD_COND_INITIALIZER; CommonData lCommonData; lCommonData.iStaticMutex = &l_staticmutex; lCommonData.iErrorCheckMutex = &l_errorcheckmutex; lCommonData.iRecursiveMutex = &l_recursivemutex; lCommonData.iStaticCondVar = &l_staticcondvar; retval = sem_init(&lSignalSemaphore,0,0); if(retval != 0) { return retval; } retval = sem_init(&lSuspendSemaphore,0,0); if(retval != 0) { return retval; } lThreadData.iSignalSemaphore = &lSignalSemaphore; lThreadData.iSuspendSemaphore = &lSuspendSemaphore; lThreadData.iTestSemaphore = &lTestSemaphore; lThreadData.iTestMutex = &lTestMutex; lThreadData.iTestMutexAttr = &lTestMutexAttr; lThreadData.iTestCondVar = &lTestCondVar; lThreadData.iDefaultAttr = &defaultattr; lThreadData.iErrorcheckAttr = &errorcheckattr; lThreadData.iRecursiveAttr = &recursiveattr; lThreadData.iCondAttr = &lCondAttr; for (int loop = 0; loop < EThreadMain; loop++) { g_spinFlag[loop] = true; } lThreadData.iSuspending = false; lThreadData.iSpinCounter = 0; lThreadData.iCurrentCommand = -1; lThreadData.iSelf = EThreadMain; lThreadData.iValue = 0; lThreadData.iRetValue = 0; lThreadData.ierrno = 0; lThreadData.iExpectederrno = 0; lThreadData.iTimes = 0; lThreadData.iStopped = false; lThreadData.iCommonData = &lCommonData; retval = SemInit(&lThreadData); fp=func2; retval = ThreadCreate(&lThreadData, (void*) EThread1); fp=func4; retval = ThreadCreate(&lThreadData, (void*) EThread2); retval = SemPost(&lThreadData); retval = ThreadDestroy(&lThreadData, (void*) EThread1); retval = ThreadDestroy(&lThreadData, (void*) EThread2); retval = SemDestroy(&lThreadData); StopThread(&lThreadData); err = pthread_cond_destroy(&l_staticcondvar); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_recursivemutex); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_errorcheckmutex); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_staticmutex); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&recursiveattr); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&errorcheckattr); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&defaultattr); if(err != EINVAL) { errsum += err; } err = sem_destroy(&lSignalSemaphore); if(err != EINVAL) { errsum += err; } err = sem_destroy(&lSuspendSemaphore); if(err != EINVAL) { errsum += err; } return retval+errsum; }
/** * @b Description * @n * The function creates a V6 Daemon. * * @param[in] Type * This is the type of socket being opened through the daemon. In * the case of IPv6 the following types are supported * - SOCK_STREAM * Use this for TCP Sockets. * - SOCK_DGRAM * Use this for UDP Sockets. * @param[in] LocalAddress * This is the Local Address to which the socket will be bound to. * In most cases this is typically passed as IPV6_UNSPECIFIED_ADDRESS * @param[in] LocalPort * This is the Local Port to serve (cannot be NULL) * @param[in] pCb * Call back function which is to be invoked. * @param[in] Priority * Priority of new task to create for callback function * @param[in] StackSize * Stack size of new task to create for callback function * @param[in] Argument * Argument (besides socket) to pass to callback function * @param[in] MaxSpawn * Maximum number of callback function instances (must be 1 for UDP) * * @retval * Success - Handle to the spawned Daemon. * @retval * Error - 0 */ HANDLE Daemon6New (uint Type, IP6N LocalAddress, uint LocalPort, int (*pCb)(SOCKET,UINT32), uint Priority, uint StackSize, UINT32 Argument, uint MaxSpawn ) { int i; DREC *pdr = 0; // Sanity check the arguments if( Type==SOCK_DGRAM ) MaxSpawn=1; else if( Type!=SOCK_STREAM) return(0); if( !LocalPort || !pCb || Priority<1 || Priority>15 || !StackSize || !MaxSpawn ) return(0); // We'll borrow the stack's kernel mode for a temp exclusion method llEnter(); if( !hDSem6 ) { hDSem6 = SemCreate( 1 ); bzero( drec6, sizeof(drec6) ); RequestedRecords6 = 0; } llExit(); // At this point we must have a semaphore if( !hDSem6 ) return(0); // Enter our own lock SemPend( hDSem6, SEM_FOREVER ); // Scan the list for a free slot for( i=0; i<DAEMON_MAXRECORD; i++ ) if( !drec6[i].Type && !drec6[i].TasksSpawned ) break; // Break out if no free records if(i==DAEMON_MAXRECORD) goto errorout; // Build the new record pdr = &drec6[i]; pdr->Type = Type; pdr->LocalV6Address = LocalAddress; pdr->LocalPort = LocalPort; pdr->pCb = pCb; pdr->Priority = Priority; pdr->StackSize = StackSize; pdr->Argument = Argument; pdr->MaxSpawn = MaxSpawn; pdr->s = INVALID_SOCKET; // If the Deamon task exists, ping it, otherwise create it if( hDTask6 ) fdSelectAbort( hDTask6 ); else { hDTask6 = TaskCreate(daemon6,"daemon6",OS_TASKPRINORM,OS_TASKSTKLOW,0,0,0); if( hDTask6 ) fdOpenSession(hDTask6); else { pdr->Type = 0; pdr = 0; goto errorout; } } RequestedRecords6++; errorout: // Exit our lock SemPost( hDSem6 ); return( pdr ); }
static void daemon6() { int i,closeSock; struct sockaddr_in6 sin1; SOCKET tsock; CHILD* pc; // Enter our lock SemPend( hDSem6, SEM_FOREVER ); for(;;) { // // Create any socket that needs to be created // for( i=0; i<DAEMON_MAXRECORD; i++ ) { if( drec6[i].Type && drec6[i].s == INVALID_SOCKET ) { // Create UDP or TCP as needed if( drec6[i].Type == SOCK_DGRAM ) drec6[i].s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); else drec6[i].s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); // If the socket was created, bind it if( drec6[i].s != INVALID_SOCKET ) { // Bind to the specified Server port bzero( &sin1, sizeof(struct sockaddr_in) ); sin1.sin6_family = AF_INET6; memcpy((void *)&sin1.sin6_addr,(void *)&drec6[i].LocalAddress, sizeof(struct in6_addr)); sin1.sin6_port = htons(drec6[i].LocalPort); if( bind( drec6[i].s,(struct sockaddr *)&sin1, sizeof(sin1) ) < 0 ) { fdClose( drec6[i].s ); drec6[i].s = INVALID_SOCKET; } } // If the socket is bound and TCP, start listening if( drec6[i].s != INVALID_SOCKET && drec6[i].Type != SOCK_DGRAM ) { if( listen( drec6[i].s, drec6[i].MaxSpawn ) < 0 ) { fdClose( drec6[i].s ); drec6[i].s = INVALID_SOCKET; } } } // Update the fdPoll array pollitem6[i].fd = drec6[i].s; if( drec6[i].Type && drec6[i].TasksSpawned < drec6[i].MaxSpawn ) pollitem6[i].eventsRequested = POLLIN; else pollitem6[i].eventsRequested = 0; } // Leave our lock SemPost( hDSem6 ); // Poll with a timeout of 10 second - to try and catch // synchronization error if( fdPoll( pollitem6, DAEMON_MAXRECORD, 10000 ) == SOCKET_ERROR ) break; // Enter our lock SemPend( hDSem6, SEM_FOREVER ); // // Spawn tasks for any active sockets // for( i=0; i<DAEMON_MAXRECORD; i++ ) { // If no poll results or the drec6 has been freed, skip it if( !pollitem6[i].eventsDetected || !drec6[i].Type ) continue; // If the socket is invalid, close it if( pollitem6[i].eventsDetected & POLLNVAL ) { fdClose( drec6[i].s); drec6[i].s = INVALID_SOCKET; continue; } if( pollitem6[i].eventsDetected & POLLIN ) { if( drec6[i].Type == SOCK_DGRAM ) { tsock = drec6[i].s; closeSock = 0; } else { tsock = accept( drec6[i].s, 0, 0 ); closeSock = 1; } if( tsock != INVALID_SOCKET ) { // Create a record to track this task pc = mmAlloc( sizeof(CHILD) ); if( !pc ) goto spawnComplete; // Create the task pc->hTask = TaskCreate( dchild6, "dchild6", drec6[i].Priority, drec6[i].StackSize, (UINT32)&drec6[i], (UINT32)pc, 0); if( !pc->hTask ) { mmFree( pc ); goto spawnComplete; } // Open a socket session for the child task fdOpenSession( pc->hTask ); // Fill in the rest of the child record pc->closeSock = closeSock; pc->s = tsock; // Now we won't close the socket here closeSock = 0; // Link this record onto the DREC drec6[i].TasksSpawned++; pc->pPrev = 0; pc->pNext = drec6[i].pC; drec6[i].pC = pc; if( pc->pNext ) pc->pNext->pPrev = pc; spawnComplete: // If there was an error, we may need to close the socket if( closeSock ) fdClose( tsock ); } } } } TaskExit(); }