/* * Win32 process and thread synchronisation * * Copyright 1997 Alexandre Julliard */ #include #include #include #include #include #include "k32obj.h" #include "heap.h" #include "process.h" #include "thread.h" #include "winerror.h" #include "debug.h" /*********************************************************************** * SYNC_BuildWaitStruct */ static BOOL32 SYNC_BuildWaitStruct( DWORD count, const HANDLE32 *handles, BOOL32 wait_all, WAIT_STRUCT *wait ) { DWORD i; K32OBJ **ptr; wait->count = count; wait->signaled = WAIT_FAILED; wait->wait_all = wait_all; SYSTEM_LOCK(); for (i = 0, ptr = wait->objs; i < count; i++, ptr++) { if (!(*ptr = HANDLE_GetObjPtr( PROCESS_Current(), handles[i], K32OBJ_UNKNOWN, SYNCHRONIZE ))) break; if (!K32OBJ_OPS( *ptr )->signaled) { /* This object type cannot be waited upon */ K32OBJ_DecCount( *ptr ); break; } } if (i != count) { /* There was an error */ while (i--) K32OBJ_DecCount( wait->objs[i] ); } SYSTEM_UNLOCK(); return (i == count); } /*********************************************************************** * SYNC_FreeWaitStruct */ static void SYNC_FreeWaitStruct( WAIT_STRUCT *wait ) { DWORD i; K32OBJ **ptr; SYSTEM_LOCK(); for (i = 0, ptr = wait->objs; i < wait->count; i++, ptr++) K32OBJ_DecCount( *ptr ); SYSTEM_UNLOCK(); } /*********************************************************************** * SYNC_CheckCondition */ static BOOL32 SYNC_CheckCondition( WAIT_STRUCT *wait, DWORD thread_id ) { DWORD i; K32OBJ **ptr; SYSTEM_LOCK(); if (wait->wait_all) { for (i = 0, ptr = wait->objs; i < wait->count; i++, ptr++) { if (!K32OBJ_OPS( *ptr )->signaled( *ptr, thread_id )) { SYSTEM_UNLOCK(); return FALSE; } } /* Wait satisfied: tell it to all objects */ wait->signaled = WAIT_OBJECT_0; for (i = 0, ptr = wait->objs; i < wait->count; i++, ptr++) if (K32OBJ_OPS( *ptr )->satisfied( *ptr, thread_id )) wait->signaled = WAIT_ABANDONED_0; SYSTEM_UNLOCK(); return TRUE; } else { for (i = 0, ptr = wait->objs; i < wait->count; i++, ptr++) { if (K32OBJ_OPS( *ptr )->signaled( *ptr, thread_id )) { /* Wait satisfied: tell it to the object */ wait->signaled = WAIT_OBJECT_0 + i; if (K32OBJ_OPS( *ptr )->satisfied( *ptr, thread_id )) wait->signaled = WAIT_ABANDONED_0 + i; SYSTEM_UNLOCK(); return TRUE; } } SYSTEM_UNLOCK(); return FALSE; } } /*********************************************************************** * SYNC_WaitForCondition */ void SYNC_WaitForCondition( WAIT_STRUCT *wait, DWORD timeout ) { DWORD i, thread_id = GetCurrentThreadId(); LONG count; K32OBJ **ptr; sigset_t set; SYSTEM_LOCK(); if (SYNC_CheckCondition( wait, thread_id )) goto done; /* Condition already satisfied */ if (!timeout) { /* No need to wait */ wait->signaled = WAIT_TIMEOUT; goto done; } /* Add ourselves to the waiting list of all objects */ for (i = 0, ptr = wait->objs; i < wait->count; i++, ptr++) K32OBJ_OPS( *ptr )->add_wait( *ptr, thread_id ); /* Release the system lock completely */ count = SYSTEM_LOCK_COUNT(); for (i = count; i > 0; i--) SYSTEM_UNLOCK(); /* Now wait for it */ TRACE(win32, "starting wait (%p %04x)\n", THREAD_Current(), THREAD_Current()->teb_sel ); sigprocmask( SIG_SETMASK, NULL, &set ); sigdelset( &set, SIGUSR1 ); sigdelset( &set, SIGALRM ); if (timeout != INFINITE32) { while (wait->signaled == WAIT_FAILED) { struct itimerval timer; DWORD start_ticks, elapsed; timer.it_interval.tv_sec = timer.it_interval.tv_usec = 0; timer.it_value.tv_sec = timeout / 1000; timer.it_value.tv_usec = (timeout % 1000) * 1000; start_ticks = GetTickCount(); setitimer( ITIMER_REAL, &timer, NULL ); sigsuspend( &set ); if (wait->signaled != WAIT_FAILED) break; /* Recompute the timer value */ elapsed = GetTickCount() - start_ticks; if (elapsed >= timeout) wait->signaled = WAIT_TIMEOUT; else timeout -= elapsed; } } else { while (wait->signaled == WAIT_FAILED) { sigsuspend( &set ); } } /* Grab the system lock again */ while (count--) SYSTEM_LOCK(); TRACE(win32, "wait finished (%p %04x)\n", THREAD_Current(), THREAD_Current()->teb_sel ); /* Remove ourselves from the lists */ for (i = 0, ptr = wait->objs; i < wait->count; i++, ptr++) K32OBJ_OPS( *ptr )->remove_wait( *ptr, thread_id ); done: SYSTEM_UNLOCK(); } /*********************************************************************** * SYNC_DummySigHandler * * Dummy signal handler */ static void SYNC_DummySigHandler(void) { } /*********************************************************************** * SYNC_SetupSignals * * Setup signal handlers for a new thread. * FIXME: should merge with SIGNAL_Init. */ void SYNC_SetupSignals(void) { sigset_t set; SIGNAL_SetHandler( SIGUSR1, SYNC_DummySigHandler, 0 ); /* FIXME: conflicts with system timers */ SIGNAL_SetHandler( SIGALRM, SYNC_DummySigHandler, 0 ); sigemptyset( &set ); /* Make sure these are blocked by default */ sigaddset( &set, SIGUSR1 ); sigaddset( &set, SIGALRM ); sigprocmask( SIG_BLOCK , &set, NULL); } /*********************************************************************** * SYNC_WakeUp */ void SYNC_WakeUp( THREAD_QUEUE *wait_queue, DWORD max ) { THREAD_ENTRY *entry; if (!max) max = INFINITE32; SYSTEM_LOCK(); if (!*wait_queue) { SYSTEM_UNLOCK(); return; } entry = (*wait_queue)->next; for (;;) { THDB *thdb = entry->thread; if (SYNC_CheckCondition( &thdb->wait_struct, THDB_TO_THREAD_ID(thdb) )) { TRACE(win32, "waking up %04x\n", thdb->teb_sel ); kill( thdb->unix_pid, SIGUSR1 ); if (!--max) break; } if (entry == *wait_queue) break; entry = entry->next; } SYSTEM_UNLOCK(); } /*********************************************************************** * WaitForSingleObject (KERNEL32.723) */ DWORD WINAPI WaitForSingleObject( HANDLE32 handle, DWORD timeout ) { return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, FALSE ); } /*********************************************************************** * WaitForSingleObjectEx (KERNEL32.724) */ DWORD WINAPI WaitForSingleObjectEx( HANDLE32 handle, DWORD timeout, BOOL32 alertable ) { return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, alertable ); } /*********************************************************************** * WaitForMultipleObjects (KERNEL32.721) */ DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE32 *handles, BOOL32 wait_all, DWORD timeout ) { return WaitForMultipleObjectsEx(count, handles, wait_all, timeout, FALSE); } /*********************************************************************** * WaitForMultipleObjectsEx (KERNEL32.722) */ DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE32 *handles, BOOL32 wait_all, DWORD timeout, BOOL32 alertable ) { WAIT_STRUCT *wait = &THREAD_Current()->wait_struct; if (count > MAXIMUM_WAIT_OBJECTS) { SetLastError( ERROR_INVALID_PARAMETER ); return WAIT_FAILED; } if (alertable) fprintf( stderr, "WaitForMultipleObjectEx: alertable not implemented\n" ); SYSTEM_LOCK(); if (!SYNC_BuildWaitStruct( count, handles, wait_all, wait )) wait->signaled = WAIT_FAILED; else { /* Now wait for it */ SYNC_WaitForCondition( wait, timeout ); SYNC_FreeWaitStruct( wait ); } SYSTEM_UNLOCK(); return wait->signaled; }