int GUI::OpenPipe(char *Command, EModel *notify) { int i; for (i = 0; i < MAX_PIPES; i++) { if (Pipes[i].used == 0) { Pipes[i].reading = 1; Pipes[i].stopped = 1; Pipes[i].id = i; Pipes[i].bufused = 0; Pipes[i].bufpos = 0; Pipes[i].buflen = PIPE_BUFLEN; Pipes[i].Command = strdup(Command); Pipes[i].notify = notify; Pipes[i].DoTerm = 0; if ((Pipes[i].buffer = (char *)malloc(PIPE_BUFLEN)) == 0) { free(Pipes[i].Command); return -1; } if (0 != DosCreateMutexSem(0, &Pipes[i].Access, 0, 0)) { free(Pipes[i].Command); free(Pipes[i].buffer); return -1; } if (0 != DosCreateEventSem(0, &Pipes[i].ResumeRead, 0, 0)) { free(Pipes[i].Command); free(Pipes[i].buffer); DosCloseMutexSem(Pipes[i].Access); return -1; } if (0 != DosCreateEventSem(0, &Pipes[i].NewData, 0, 0)) { free(Pipes[i].Command); free(Pipes[i].buffer); DosCloseEventSem(Pipes[i].ResumeRead); DosCloseMutexSem(Pipes[i].Access); return -1; } #if defined(__WATCOMC__) || defined(__MT__) || defined(__MULTI__) Pipes[i].tid = _beginthread(PipeThread, FAKE_BEGINTHREAD_NULL 16384, &Pipes[i]); #else // if defined(__WATCOMC__) || defined(__MT__) || defined(__MULTI__) DosCreateThread(Pipes[i].tid, (PFNTHREAD)PipeThread, &Pipes[i], 0, /* immediate */ 16384); #endif // if defined(__WATCOMC__) || defined(__MT__) || defined(__MULTI__) Pipes[i].used = 1; // fprintf(stderr, "Pipe Open: %d\n", i); return i; } } return -1; }
static int RequestCom(void) { USHORT res; HMTX sem=0; printf("Sending message to AM4PM to release COM port\n"); res=SendExtQMsg(EQ_RELCOM, NULL, 0); if (res) return res; res=DosOpenMutexSem(szSemCom, &sem); if (res) { printf("Error %u opening semaphore\n", res); return 3; } res=DosRequestMutexSem(sem, 120000l); if (res) { DosCloseMutexSem(sem); if (res==ERROR_TIMEOUT) { printf("Timeout waiting for AM4PM to release COM port\n"); return 4; } printf("Error %u waiting for semaphore\n", res); return 3; } DosReleaseMutexSem(sem); DosCloseMutexSem(sem); return 0; }
int CloseMarkerList(PMARKERLIST pList) { if (DosCloseMutexSem(pList->hmtxAccess)) return 1; else return 0; }
/* ** This routine deallocates a previously allocated mutex. ** SQLite is careful to deallocate every mutex that it allocates. */ void sqlite3_mutex_free(sqlite3_mutex *p){ assert( p ); assert( p->nRef==0 ); assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); DosCloseMutexSem( p->mutex ); sqlite3_free( p ); }
//--------------------------------------------------------------------- // LibMain // // This gets called at DLL initialization and termination. //--------------------------------------------------------------------- unsigned _System LibMain(unsigned hmod, unsigned termination) { int i; if (termination) { // Cleanup! if (bRunning) SSModule_StopSaving(); // Free NLS text, if it wouldn't be (safety net) for (i=0; i<SSMODULE_NLSTEXT_MAX+1; i++) { if (apchNLSText[i]) { free(apchNLSText[i]); apchNLSText[i] = NULL; } } // Free semaphore DosCloseMutexSem(hmtxUseNLSTextArray); hmtxUseNLSTextArray = NULLHANDLE; } else { // Startup! hmodOurDLLHandle = (HMODULE) hmod; bRunning = FALSE; // Initialize NLS text array for (i=0; i<SSMODULE_NLSTEXT_MAX+1; i++) apchNLSText[i] = NULL; // Create semaphore to protect it DosCreateMutexSem(NULL, &hmtxUseNLSTextArray, 0, FALSE); } return 1; }
/* ** This routine deallocates a previously allocated mutex. ** SQLite is careful to deallocate every mutex that it allocates. */ static void os2MutexFree(sqlite3_mutex *p){ if( p==0 ) return; assert( p->nRef==0 ); assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); DosCloseMutexSem( p->mutex ); sqlite3_free( p ); }
static cairo_status_t _cairo_os2_surface_finish (void *abstract_surface) { cairo_os2_surface_t *local_os2_surface; local_os2_surface = (cairo_os2_surface_t *) abstract_surface; if ((!local_os2_surface) || (local_os2_surface->base.backend != &cairo_os2_surface_backend)) { /* Invalid parameter (wrong surface)! */ return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); } DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT); /* Destroy old image surface */ cairo_surface_destroy ((cairo_surface_t *) (local_os2_surface->image_surface)); /* Destroy old pixel buffer */ _buffer_free (local_os2_surface->pixels); DosCloseMutexSem (local_os2_surface->hmtx_use_private_fields); DosCloseEventSem (local_os2_surface->hev_pixel_array_came_back); /* The memory itself will be free'd by the cairo_surface_destroy () * who called us. */ return CAIRO_STATUS_SUCCESS; }
int GetClipText(ClipData *cd) { int rc; ULONG PostCount; char *mem; rc = DosOpenMutexSem(SEM_PREFIX "CLIPSYN", &hmtxSyn); if (rc != 0) return -1; rc = DosOpenEventSem(SEM_PREFIX "CLIPGET", &hevGet); if (rc != 0) return -1; /* rc = DosOpenEventSem(SEM_PREFIX "CLIPPUT", &hevPut);*/ /* if (rc != 0) return -1;*/ rc = DosOpenEventSem(SEM_PREFIX "CLIPEND", &hevEnd); if (rc != 0) return -1; DosRequestMutexSem(hmtxSyn, SEM_INDEFINITE_WAIT); DosResetEventSem(hevEnd, &PostCount); DosPostEventSem(hevGet); DosWaitEventSem(hevEnd, SEM_INDEFINITE_WAIT); if (0 == DosGetNamedSharedMem((void **)&mem, MEM_PREFIX "CLIPDATA", PAG_READ | PAG_WRITE)) { cd->fLen = *(ULONG*)mem; cd->fChar = strdup(mem + 4); DosFreeMem(mem); } else { cd->fLen = 0; cd->fChar = 0; } DosPostEventSem(hevGet); DosReleaseMutexSem(hmtxSyn); /* DosCloseEventSem(hevPut);*/ DosCloseEventSem(hevGet); DosCloseEventSem(hevEnd); DosCloseMutexSem(hmtxSyn); return 0; }
omni_condition::~omni_condition(void) { DosCloseMutexSem( crit ); DB( if (waiting_head != NULL) { cerr << "omni_condition::~omni_condition: list of waiting threads " << "is not empty\n"; } ) }
void Uninitialize_ChannelSetList() { if (ChannelSetListProtector_Sem==-1) return; EraseChannelSetList(); DosCloseMutexSem(ChannelSetListProtector_Sem); ChannelSetListProtector_Sem = -1; }
void fly_terminate (void) { int rc; WinPostMsg (hwndFrame, WM_QUIT, 0, 0); rc = DosCloseMutexSem (mtx_Queue); debug_tools ("rc = %d after DosCloseMutexSem1\n", rc); rc = DosCloseMutexSem (mtx_Video); debug_tools ("%d menu item changes\n", item_status_change); _tfree (tiled1); _tfree (us1_16); _tfree (us2_16); fl_opt.initialized = FALSE; }
void Uninitialize_PluginList() { if (PluginListProtector_Sem==-1) return; UninitializeAllPlugins(HWND_DESKTOP); ErasePluginList(); DosCloseMutexSem(PluginListProtector_Sem); PluginListProtector_Sem = -1; }
/* Free the semaphore */ DECLSPEC void SDLCALL SDL_DestroySemaphore(SDL_sem *sem) { if ( sem ) { if ( sem->id ) { DosCloseEventSem(sem->changed); DosCloseMutexSem(sem->id); sem->id = 0; } SDL_free(sem); } }
int DLLCALL pthread_mutex_destroy(pthread_mutex_t* mutex) { #if defined(PTHREAD_MUTEX_AS_WIN32_MUTEX) return (CloseHandle(*mutex) ? 0 : GetLastError()); #elif defined(_WIN32) /* Win32 Critical Section */ DeleteCriticalSection(mutex); return 0; /* No error */ #elif defined(__OS2__) return DosCloseMutexSem(*mutex); #endif }
/* Free the mutex */ DECLSPEC void SDLCALL SDL_DestroyMutex(SDL_mutex *mutex) { if ( mutex ) { if ( mutex->hmtxID ) { DosCloseMutexSem(mutex->hmtxID); mutex->hmtxID = 0; } SDL_free(mutex); } }
/* ** This routine deallocates a previously allocated mutex. ** SQLite is careful to deallocate every mutex that it allocates. */ static void os2MutexFree(sqlite3_mutex *p){ #ifdef SQLITE_DEBUG TID tid; PID pid; ULONG ulCount; DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount); assert( ulCount==0 ); assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); #endif DosCloseMutexSem( p->mutex ); sqlite3_free( p ); }
void enter_sync() { if (Mutex == NULL) { // first call => initialize mutex HMTX newmtx; DosCreateMutexSem(NULL, &newmtx, 0, FALSE); if (InterlockedCxc((volatile unsigned*)&Mutex, 0, (unsigned)newmtx) != 0) // compare exchange failed => destroy mutex DosCloseMutexSem(newmtx); } DosRequestMutexSem(Mutex, SEM_INDEFINITE_WAIT); }
/* Strange! If video_init fails this is called without calling DosOpen before! */ void joystick_close(void) { APIRET rc; DosRequestMutexSem(hmtxJoystick, SEM_INDEFINITE_WAIT); rc=DosClose(SWhGame); DosCloseMutexSem(hmtxJoystick); if (!rc) return; log_error(joylog, "DosClose 'GAME$' (rc=%i)", rc); }
void __FiniFThreadProcessing( void ) { //=============================================== #if defined( __OS2__ ) DosCloseMutexSem( __fio_sem ); #elif defined( __NETWARE__ ) CloseLocalSemaphore( __fio_sem ); #elif defined( __NT__ ) CloseHandle( __fio_sem ); #elif defined( __LINUX__ ) // TODO: semaphore support for Linux! #endif }
RTDECL(int) RTSemMutexDestroy(RTSEMMUTEX hMutexSem) { if (hMutexSem == NIL_RTSEMMUTEX) return VINF_SUCCESS; /* * Close semaphore handle. */ int rc = DosCloseMutexSem(SEM2HND(hMutexSem)); if (!rc) return VINF_SUCCESS; AssertMsgFailed(("Destroy hMutexSem %p failed, rc=%d\n", hMutexSem, rc)); return RTErrConvertFromOS2(rc); }
static apr_status_t thread_cond_cleanup(void *data) { apr_thread_cond_t *cv = data; if (cv->semaphore) { DosCloseEventSem(cv->semaphore); } if (cv->mutex) { DosCloseMutexSem(cv->mutex); } return APR_SUCCESS; }
VOID gropDone() { debug( "Enter" ); if ( lInitTime == 0 ) return; lInitTime--; if ( lInitTime == 0 ) { debug( "%u GROP objects left.", lnkseqGetCount( &lsGropList ) ); _gropAllToDesktop(); DosCloseMutexSem( hmtxGropList ); hmtxGropList = NULLHANDLE; debugDone(); } }
APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex) { ULONG rc; if (mutex->hMutex == 0) return APR_SUCCESS; while (DosReleaseMutexSem(mutex->hMutex) == 0); rc = DosCloseMutexSem(mutex->hMutex); if (!rc) { mutex->hMutex = 0; return APR_SUCCESS; } return APR_FROM_OS_ERROR(rc); }
/****************************************************************\ * Routine to really stop semaphore example. * *--------------------------------------------------------------* * * * Name: StopSemaphore( PVOID pvArg ) * * * * Purpose: Waits for threads to complete, * * Sends message to message thread to indicate this * * has occurred, and exits. * * * * Usage: Exec'd from BeginStop when user selects Stop from * * Semaphore menu. * * * * Method: Turns off Auto mode, if present by posting auto * * semaphore. Then stop event is posted. Waits * * for threads to die. * * Returns: * * * \****************************************************************/ VOID StopSemaphore( PVOID pvArg ) { ULONG rc,usCount, i; PULONG pfAutoMode = (PULONG)pvArg; if (*pfAutoMode) { rc = DosWaitThread(&tidAutoThread,0L); if (rc && (rc != ERROR_INVALID_THREADID)) { SemError("DosWaitThread",rc); } *pfAutoMode = FALSE; } /* Wait for usConsumer threads to die. Order of death not important. */ for (usCount = 0; usCount < usConsumerThreadsCreated; usCount++) { rc = DosWaitThread(&thrConsumers[usCount].tid,0L); /* rc is ERROR_INVALID_THREADID the thread is already dead.*\ \* This is OK and not a error. */ if (rc && (rc != ERROR_INVALID_THREADID)) { SemError("DosWaitThread",rc); } } /* Threads dead so we don't need semaphores any more. */ DosCloseEventSem(hevStopAuto); DosCloseEventSem(hevStop); DosCloseMutexSem(hmtxOwnResource); for (i = 0; i < MAXRESOURCES; i++) { DosCloseEventSem(aSquares[i].hev); } DosCloseMuxWaitSem (hmuxResource); WinPostMsg (hwndMain, WM_COMMAND, (MPARAM)IDM_STOPFINISHED, (MPARAM)NULL); DosExit (EXIT_THREAD, 0); return; }
_WCRTLINK void __CloseSemaphore( semaphore_object *obj ) { #if defined( __RUNTIME_CHECKS__ ) && defined( _M_IX86 ) // 0 is ok // 1 is ok // JBS I don't think so. I would mean a critical section is active. // JBS For every lock, there should be an unlock. // if( obj->count >= 2 ) { // __fatal_runtime_error( "Semaphore locked too many times", 1 ); // } if( obj->count >= 1 ) { __fatal_runtime_error( "Semaphore not unlocked", 1 ); } #endif #if !defined( __NT__ ) #if defined( _M_I86 ) if( obj->count > 0 ) { DosSemClear( &obj->semaphore ); } #else if( obj->initialized != 0 ) { #if defined( __NETWARE__ ) obj->semaphore = 0; #elif defined( __QNX__ ) __qsem_destroy( &obj->semaphore ); #elif defined( __LINUX__ ) // TODO: Close the semaphore for Linux! #elif defined( __RDOS__ ) RdosDeleteSection( obj->semaphore ); obj->semaphore = 0; #elif defined( __RDOSDEV__ ) #else DosCloseMutexSem( obj->semaphore ); #endif } #endif obj->initialized = 0; obj->owner = 0; obj->count = 0; #endif }
extern "C" APIRET APIENTRY InitSrvConn(char *remotemachineName, ULONG *obj) { int rc; /* First let's look for FreePM.ini and read it if any */ FPM_config.Read("fpm.ini"); if (remotemachineName) { strcpy(FPM_config.ExternMachineName, remotemachineName); ExternMachine = &FPM_config.ExternMachineName[0]; } else { /* test for FreePM's semaphore at local machine */ HMTX FREEPM_hmtx = NULLHANDLE; /* Mutex semaphore handle */ rc = DosOpenMutexSem(FREEPM_MUTEX_NAME, /* Semaphore name */ &FREEPM_hmtx); /* Handle returned */ DosCloseMutexSem(FREEPM_hmtx); if (rc) /* FreePM server is not running at local machine, let's look for FreePM.ini */ ExternMachine = &FPM_config.ExternMachineName[0]; else ExternMachine = NULL; } /* init connection to FreePM server */ rc = InitServerConnection(ExternMachine, obj); if (rc && ExternMachine) { ExecuteFreePMServer(); DosSleep(1000); rc = InitServerConnection(NULL, obj); } return rc; }
void EditBoxCollection::Done() { StoreHistory(); shutdown = 1; lock(); RemoveAll(); // MouClose(MouHandle); npFED.Close(); DosCloseMutexSem(hMtx); DosSleep(1); DosSleep(1); DosSleep(1); delete ppTmr; delete ppMou; delete ppPip; vio_shutdown(); }
int GUI::ClosePipe(int id) { if ((id < 0) || (id > MAX_PIPES)) return -1; if (Pipes[id].used == 0) return -1; if (Pipes[id].reading == 1) { Pipes[id].DoTerm = 1; DosPostEventSem(Pipes[id].ResumeRead); DosWaitThread(&Pipes[id].tid, DCWW_WAIT); } free(Pipes[id].buffer); free(Pipes[id].Command); DosCloseEventSem(Pipes[id].NewData); DosCloseEventSem(Pipes[id].ResumeRead); DosCloseMutexSem(Pipes[id].Access); // fprintf(stderr, "Pipe Close: %d\n", id); Pipes[id].used = 0; // ConContinue(); return Pipes[id].RetCode; }
int PutClipText(ClipData *cd) { int rc; ULONG PostCount; char *mem; rc = DosOpenMutexSem(SEM_PREFIX "CLIPSYN", &hmtxSyn); if (rc != 0) return -1; /* rc = DosOpenEventSem(SEM_PREFIX "CLIPGET", &hevGet);*/ /* if (rc != 0) return -1;*/ rc = DosOpenEventSem(SEM_PREFIX "CLIPPUT", &hevPut); if (rc != 0) return -1; rc = DosOpenEventSem(SEM_PREFIX "CLIPEND", &hevEnd); if (rc != 0) return -1; DosRequestMutexSem(hmtxSyn, SEM_INDEFINITE_WAIT); DosResetEventSem(hevEnd, &PostCount); if (0 == DosAllocSharedMem((void **)&mem, MEM_PREFIX "CLIPDATA", cd->fLen + 5, PAG_COMMIT | PAG_READ | PAG_WRITE)) { ULONG L = cd->fLen; memcpy((void *)mem, (void *)&L, 4); strcpy(mem + 4, cd->fChar); } DosPostEventSem(hevPut); DosWaitEventSem(hevEnd, SEM_INDEFINITE_WAIT); DosPostEventSem(hevPut); DosReleaseMutexSem(hmtxSyn); DosCloseEventSem(hevPut); /* DosCloseEventSem(hevGet); */ DosCloseEventSem(hevEnd); DosCloseMutexSem(hmtxSyn); if (mem) DosFreeMem(mem); return 0; }
void TThreads::suspend() { shutDownFlag=1; TID localTID=mouseThreadID; if (localTID != 0xFFFF) DosWaitThread(&localTID,DCWW_WAIT); // cerr << " MouseThread has ended\n"; ULONG count; assert(! DosQueryEventSem(TThreads::hevKeyboard2,&count)); if (!count) assert(! DosPostEventSem(TThreads::hevKeyboard2)); // Make sure the thread is running. localTID=keyboardThreadID; DosWaitThread(&localTID,DCWW_WAIT); // cerr << " KeyboardThread has ended\n"; assert(!DosCloseMutexSem(hmtxMouse1)); assert(!DosCloseEventSem(hevKeyboard2)); assert(!DosCloseEventSem(hevKeyboard1)); assert(!DosCloseEventSem(hevMouse2)); assert(!DosCloseEventSem(hevMouse1)); assert(!DosCloseMuxWaitSem(hmuxMaster)); if (tiled->mouseHandle != 0xFFFF) MouClose(tiled->mouseHandle); // This doesn't work, the mouseThread uses the handle. assert(! DosFreeMem(tiled)); // Better not, dito }