350 lines
9.8 KiB
C
350 lines
9.8 KiB
C
/*
|
|
* Win32 critical sections
|
|
*
|
|
* Copyright 1998 Alexandre Julliard
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include "winerror.h"
|
|
#include "winbase.h"
|
|
#include "ntddk.h"
|
|
#include "heap.h"
|
|
#include "debugtools.h"
|
|
#include "thread.h"
|
|
|
|
DEFAULT_DEBUG_CHANNEL(win32);
|
|
DECLARE_DEBUG_CHANNEL(relay);
|
|
|
|
/***********************************************************************
|
|
* get_semaphore
|
|
*/
|
|
static inline HANDLE get_semaphore( CRITICAL_SECTION *crit )
|
|
{
|
|
HANDLE ret = crit->LockSemaphore;
|
|
if (!ret)
|
|
{
|
|
HANDLE sem = CreateSemaphoreA( NULL, 0, 1, NULL );
|
|
if (!(ret = (HANDLE)InterlockedCompareExchange( (PVOID *)&crit->LockSemaphore,
|
|
(PVOID)sem, 0 )))
|
|
ret = sem;
|
|
else
|
|
CloseHandle(sem); /* somebody beat us to it */
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* InitializeCriticalSection (KERNEL32.472) (NTDLL.406)
|
|
*/
|
|
void WINAPI InitializeCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
crit->LockCount = -1;
|
|
crit->RecursionCount = 0;
|
|
crit->OwningThread = 0;
|
|
crit->LockSemaphore = 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DeleteCriticalSection (KERNEL32.185) (NTDLL.327)
|
|
*/
|
|
void WINAPI DeleteCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
if (crit->RecursionCount && crit->OwningThread != GetCurrentThreadId())
|
|
ERR("Deleting owned critical section (%p)\n", crit );
|
|
|
|
crit->LockCount = -1;
|
|
crit->RecursionCount = 0;
|
|
crit->OwningThread = 0;
|
|
if (crit->LockSemaphore) CloseHandle( crit->LockSemaphore );
|
|
crit->LockSemaphore = 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* RtlpWaitForCriticalSection (NTDLL.@)
|
|
*/
|
|
void WINAPI RtlpWaitForCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
for (;;)
|
|
{
|
|
EXCEPTION_RECORD rec;
|
|
HANDLE sem = get_semaphore( crit );
|
|
|
|
DWORD res = WaitForSingleObject( sem, 5000L );
|
|
if ( res == WAIT_TIMEOUT )
|
|
{
|
|
ERR("Critical section %p wait timed out, retrying (60 sec)\n", crit );
|
|
res = WaitForSingleObject( sem, 60000L );
|
|
if ( res == WAIT_TIMEOUT && TRACE_ON(relay) )
|
|
{
|
|
ERR("Critical section %p wait timed out, retrying (5 min)\n", crit );
|
|
res = WaitForSingleObject( sem, 300000L );
|
|
}
|
|
}
|
|
if (res == STATUS_WAIT_0) break;
|
|
|
|
rec.ExceptionCode = EXCEPTION_CRITICAL_SECTION_WAIT;
|
|
rec.ExceptionFlags = 0;
|
|
rec.ExceptionRecord = NULL;
|
|
rec.ExceptionAddress = RtlRaiseException; /* sic */
|
|
rec.NumberParameters = 1;
|
|
rec.ExceptionInformation[0] = (DWORD)crit;
|
|
RtlRaiseException( &rec );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* RtlpUnWaitCriticalSection (NTDLL.@)
|
|
*/
|
|
void WINAPI RtlpUnWaitCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
HANDLE sem = get_semaphore( crit );
|
|
ReleaseSemaphore( sem, 1, NULL );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* EnterCriticalSection (KERNEL32.195) (NTDLL.344)
|
|
*/
|
|
void WINAPI EnterCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
if (InterlockedIncrement( &crit->LockCount ))
|
|
{
|
|
if (crit->OwningThread == GetCurrentThreadId())
|
|
{
|
|
crit->RecursionCount++;
|
|
return;
|
|
}
|
|
|
|
/* Now wait for it */
|
|
RtlpWaitForCriticalSection( crit );
|
|
}
|
|
crit->OwningThread = GetCurrentThreadId();
|
|
crit->RecursionCount = 1;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* TryEnterCriticalSection (KERNEL32.898) (NTDLL.969)
|
|
*/
|
|
BOOL WINAPI TryEnterCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
BOOL ret = FALSE;
|
|
if (InterlockedCompareExchange( (PVOID *)&crit->LockCount,
|
|
(PVOID)0L, (PVOID)-1L ) == (PVOID)-1L)
|
|
{
|
|
crit->OwningThread = GetCurrentThreadId();
|
|
crit->RecursionCount = 1;
|
|
ret = TRUE;
|
|
}
|
|
else if (crit->OwningThread == GetCurrentThreadId())
|
|
{
|
|
InterlockedIncrement( &crit->LockCount );
|
|
crit->RecursionCount++;
|
|
ret = TRUE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* LeaveCriticalSection (KERNEL32.494) (NTDLL.426)
|
|
*/
|
|
void WINAPI LeaveCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
if (crit->OwningThread != GetCurrentThreadId()) return;
|
|
|
|
if (--crit->RecursionCount)
|
|
{
|
|
InterlockedDecrement( &crit->LockCount );
|
|
return;
|
|
}
|
|
crit->OwningThread = 0;
|
|
if (InterlockedDecrement( &crit->LockCount ) >= 0)
|
|
{
|
|
/* Someone is waiting */
|
|
RtlpUnWaitCriticalSection( crit );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MakeCriticalSectionGlobal (KERNEL32.515)
|
|
*/
|
|
void WINAPI MakeCriticalSectionGlobal( CRITICAL_SECTION *crit )
|
|
{
|
|
crit->LockSemaphore = ConvertToGlobalHandle( get_semaphore( crit ) );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* ReinitializeCriticalSection (KERNEL32.581)
|
|
*/
|
|
void WINAPI ReinitializeCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
if ( !crit->LockSemaphore )
|
|
InitializeCriticalSection( crit );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* UninitializeCriticalSection (KERNEL32.703)
|
|
*/
|
|
void WINAPI UninitializeCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
DeleteCriticalSection( crit );
|
|
}
|
|
|
|
#ifdef __i386__
|
|
|
|
/***********************************************************************
|
|
* InterlockCompareExchange (KERNEL32.@)
|
|
*/
|
|
PVOID WINAPI InterlockedCompareExchange( PVOID *dest, PVOID xchg, PVOID compare );
|
|
__ASM_GLOBAL_FUNC(InterlockedCompareExchange,
|
|
"movl 12(%esp),%eax\n\t"
|
|
"movl 8(%esp),%ecx\n\t"
|
|
"movl 4(%esp),%edx\n\t"
|
|
"lock; cmpxchgl %ecx,(%edx)\n\t"
|
|
"ret $12");
|
|
|
|
/***********************************************************************
|
|
* InterlockedExchange (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedExchange( PLONG dest, LONG val );
|
|
__ASM_GLOBAL_FUNC(InterlockedExchange,
|
|
"movl 8(%esp),%eax\n\t"
|
|
"movl 4(%esp),%edx\n\t"
|
|
"lock; xchgl %eax,(%edx)\n\t"
|
|
"ret $8");
|
|
|
|
/***********************************************************************
|
|
* InterlockedExchangeAdd (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr );
|
|
__ASM_GLOBAL_FUNC(InterlockedExchangeAdd,
|
|
"movl 8(%esp),%eax\n\t"
|
|
"movl 4(%esp),%edx\n\t"
|
|
"lock; xaddl %eax,(%edx)\n\t"
|
|
"ret $8");
|
|
|
|
/***********************************************************************
|
|
* InterlockedIncrement (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedIncrement( PLONG dest );
|
|
__ASM_GLOBAL_FUNC(InterlockedIncrement,
|
|
"movl 4(%esp),%edx\n\t"
|
|
"movl $1,%eax\n\t"
|
|
"lock; xaddl %eax,(%edx)\n\t"
|
|
"incl %eax\n\t"
|
|
"ret $4");
|
|
|
|
/***********************************************************************
|
|
* InterlockDecrement (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedDecrement( PLONG dest );
|
|
__ASM_GLOBAL_FUNC(InterlockedDecrement,
|
|
"movl 4(%esp),%edx\n\t"
|
|
"movl $-1,%eax\n\t"
|
|
"lock; xaddl %eax,(%edx)\n\t"
|
|
"decl %eax\n\t"
|
|
"ret $4");
|
|
|
|
#elif defined(__sparc__) && defined(__sun__)
|
|
|
|
/*
|
|
* As the earlier Sparc processors lack necessary atomic instructions,
|
|
* I'm simply falling back to the library-provided _lwp_mutex routines
|
|
* to ensure mutual exclusion in a way appropriate for the current
|
|
* architecture.
|
|
*
|
|
* FIXME: If we have the compare-and-swap instruction (Sparc v9 and above)
|
|
* we could use this to speed up the Interlocked operations ...
|
|
*/
|
|
|
|
#include <synch.h>
|
|
static lwp_mutex_t interlocked_mutex = DEFAULTMUTEX;
|
|
|
|
/***********************************************************************
|
|
* InterlockedCompareExchange (KERNEL32.@)
|
|
*/
|
|
PVOID WINAPI InterlockedCompareExchange( PVOID *dest, PVOID xchg, PVOID compare )
|
|
{
|
|
_lwp_mutex_lock( &interlocked_mutex );
|
|
|
|
if ( *dest == compare )
|
|
*dest = xchg;
|
|
else
|
|
compare = *dest;
|
|
|
|
_lwp_mutex_unlock( &interlocked_mutex );
|
|
return compare;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* InterlockedExchange (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedExchange( PLONG dest, LONG val )
|
|
{
|
|
LONG retv;
|
|
_lwp_mutex_lock( &interlocked_mutex );
|
|
|
|
retv = *dest;
|
|
*dest = val;
|
|
|
|
_lwp_mutex_unlock( &interlocked_mutex );
|
|
return retv;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* InterlockedExchangeAdd (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr )
|
|
{
|
|
LONG retv;
|
|
_lwp_mutex_lock( &interlocked_mutex );
|
|
|
|
retv = *dest;
|
|
*dest += incr;
|
|
|
|
_lwp_mutex_unlock( &interlocked_mutex );
|
|
return retv;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* InterlockedIncrement (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedIncrement( PLONG dest )
|
|
{
|
|
LONG retv;
|
|
_lwp_mutex_lock( &interlocked_mutex );
|
|
|
|
retv = ++*dest;
|
|
|
|
_lwp_mutex_unlock( &interlocked_mutex );
|
|
return retv;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* InterlockedDecrement (KERNEL32.@)
|
|
*/
|
|
LONG WINAPI InterlockedDecrement( PLONG dest )
|
|
{
|
|
LONG retv;
|
|
_lwp_mutex_lock( &interlocked_mutex );
|
|
|
|
retv = --*dest;
|
|
|
|
_lwp_mutex_unlock( &interlocked_mutex );
|
|
return retv;
|
|
}
|
|
|
|
#else
|
|
#error You must implement the Interlocked* functions for your CPU
|
|
#endif
|