SyncObj.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: Class wraps for standard IPC sychronization objects.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/SyncObj.h>
#include <uLib/Debug.h>

#if defined(_DEBUG) && defined( HAVE_STRUCTURED_EH )
  #define SYNCOBJ_DBG_SEH 1
  static ACSTR GetCritSecExcName( DWORD xCode )
  {
      return (xCode == STATUS_NO_MEMORY) 
          ? "STATUS_NO_MEMORY" : GetExceptionName( xCode );
  }
  //#ifdef _MSC_VER
  //  #define __FUNC  __FUNCTION__
  //#else // gcc
  //  #define __FUNC  __func__
  //#endif
#else 
  #define SYNCOBJ_DBG_SEH 0
#endif

//==---------------------------------------------------------------------------

TCritSec::TCritSec()
{
    memset( &_cSec, 0, sizeof(CRITICAL_SECTION) ); // Make dbg easier
    // WinSrv2k3 & WinXP/2k: InitializeCriticalSection can raise STATUS_NO_MEMORY!
  #if SYNCOBJ_DBG_SEH
    __try { InitializeCriticalSection( &_cSec ); }
    __except_execute
    {
        ACSTR xName = GetCritSecExcName( GetExceptionCode());
        TRACE( DP_FATAL, _F("InitializeCriticalSection: %s\n"), xName );
        BREAK();
    }
  #else
    InitializeCriticalSection( &_cSec );
  #endif
}

TCritSec::TCritSec( DWORD SpinCount )
{
    memset( &_cSec, 0, sizeof(CRITICAL_SECTION) );
  #if SYNCOBJ_DBG_SEH
    __try { InitializeCriticalSectionAndSpinCount( &_cSec, SpinCount ); }
    __except_execute
    {
        ACSTR xName = GetCritSecExcName( GetExceptionCode());
        TRACE( DP_FATAL, _F("InitializeCriticalSection: %s\n"), xName );
        BREAK();
    }
  #else
    InitializeCriticalSectionAndSpinCount( &_cSec, SpinCount );
  #endif
}

TCritSec::~TCritSec()
{
    DeleteCriticalSection( &_cSec );
}

DWORD TCritSec::SetSpinCount( DWORD SpinCount )
{
    return SetCriticalSectionSpinCount( &_cSec, SpinCount );
}

#if SYNCOBJ_DBG_SEH

// [MSDN] EnterCriticalSection() can raise EXCEPTION_POSSIBLE_DEADLOCK
// if a wait operation on the critical section times out.
// Win2k/NT: In low memory situations, EnterCriticalSection can raise an exception.
// Do *not* handle these exceptions; instead, debug the application.
 
static DWORD __csectExFilter( IN PEXCEPTION_POINTERS pexPtr, CSTR Where )
{
    // Capture, but don't handle, a possible EXCEPTION_POSSIBLE_DEADLOCK or STATUS_NO_MEMORY.
    ACSTR xName = GetCritSecExcName( pexPtr->ExceptionRecord->ExceptionCode );
    // Hmm.. It's kinda impressive that we can raise other exceptions,
    // (DBG_PRINTEXCEPTION_C and EXCEPTION_BREAKPOINT), inside the exception filter,
    // that is, before the stack is unwound. I'll call that solid :)
    DPrint( DP_ERROR, _F("%s in %s. Debug Your program!\n"), xName, Where );
    BREAK(); // Break if a debugger is present, else show MsgBox.
    // Proceed to the "unhandled exception" filter in *all cases*.
    return EXCEPTION_CONTINUE_SEARCH;
}
#endif //SYNCOBJ_DBG_SEH

void TCritSec::Enter()
{
  #if SYNCOBJ_DBG_SEH
    __try { EnterCriticalSection( &_cSec ); }
    __except( __csectExFilter( GetExceptionInformation(), (CSTR)__FUNCTION__ ))
    {
        // Agh.. We said EXCEPTION_CONTINUE_SEARCH, so if we get here
        // something is *broken* in the system or in the compiler !!
        DWORD xCode = GetExceptionCode();
        ACSTR xName = GetCritSecExcName( xCode );
        DPrint( DP_ERROR, _F("SERIOUS ERROR: Broken handling of %s!\n"), xName );
        BREAK();
    }
  #else
    EnterCriticalSection( &_cSec );
  #endif
}

bool TCritSec::TryEnter()
{
    return bool_cast( TryEnterCriticalSection( &_cSec ));
}

void TCritSec::Leave()
{
    LeaveCriticalSection( &_cSec );
}

//==---------------------------------------------------------------------------

TSyncObj::TSyncObj()
: _hSync( NULL )
{}

TSyncObj::TSyncObj( const HANDLE& Src )
: _hSync( Src )
{}

TSyncObj::~TSyncObj()
{
    Close();
}

bool TSyncObj::Close()
{
    _hSync = CloseHandleEx( _hSync );
    return (_hSync == NULL);
}

static bool __CheckWaitResult( DWORD rc )
{
    bool ok = (rc == WAIT_OBJECT_0);

    // In case of WAIT_FAILED, the error has already been set.
    // If not, then store the wait result.

    if (!ok && (rc != WAIT_FAILED)) SetLastError( rc );
    return ok;
}

bool TSyncObj::Wait( DWORD msWait )
{
    bool ok = Initialized();
    if (!ok) SetLastError( ERROR_INVALID_HANDLE );
    else
    {
        DWORD rc = WaitForSingleObject( _hSync, msWait );
        ok = __CheckWaitResult( rc );
    }
    return ok;
}

bool TSyncObj::WaitEx( DWORD msWait, bool Alertable )
{
    bool ok = Initialized();
    if (!ok) SetLastError( ERROR_INVALID_HANDLE );
    else
    {
        DWORD rc = WaitForSingleObjectEx( _hSync, msWait, Alertable );
        ok = __CheckWaitResult( rc );
    }
    return ok;
}

bool TSyncObj::SignalAndWait( HANDLE hWaitFor, DWORD msWait, bool Alertable )
{
    bool ok = Initialized();
    if (!ok) SetLastError( ERROR_INVALID_HANDLE );
    else
    {
        DWORD rc = SignalObjectAndWait( _hSync, hWaitFor, msWait, Alertable );
        ok = __CheckWaitResult( rc );
    }
    return ok;
}

HANDLE TSyncObj::RegisterWait( WAITORTIMERCALLBACK Callback, PVOID Context, DWORD msWait, DWORD Flags )
{
    HANDLE hWaitObj = NULL;
    if (!Initialized()) SetLastError( ERROR_INVALID_HANDLE );
    else
    {
        RegisterWaitForSingleObject( &hWaitObj, _hSync, Callback, Context, msWait, Flags );
    }
    return hWaitObj;
}

bool TSyncObj::UnregisterWait( HANDLE hWait )
{
    return bool_cast( ::UnregisterWait( hWait ));
}

HANDLE TSyncObj::Duplicate( HANDLE TargetProc, bool Inherit, ACCESS_MASK Access, DWORD Opt )
{
    HANDLE hTrg = NULL, hProc = GetCurrentProcess();
    if (!Initialized()) SetLastError( ERROR_INVALID_HANDLE );
    else
    {
        Opt &= ~DUPLICATE_CLOSE_SOURCE; // Prevent suicide
        DuplicateHandle( hProc, _hSync, TargetProc, &hTrg, Access, Inherit, Opt );
    }
    return hTrg;
}

//==---------------------------------------------------------------------------

TEvent::TEvent( LPSECURITY_ATTRIBUTES SecAttr, bool Manual, bool Init, CSTR Name )
: TSyncObj()
{
    _hSync = CreateEvent( SecAttr, Manual, Init, Name );
}

TEvent::TEvent( DWORD Access, bool Inherit, CSTR Name )
: TSyncObj()
{
    _hSync = OpenEvent( Access, Inherit, Name );
}

TEvent::~TEvent()
{
    Set(); // Schedule any pending waiter before dying.
}

bool TEvent::Set()
{
    return bool_cast( SetEvent( _hSync ));
}

bool TEvent::Reset()
{
    return bool_cast( ResetEvent( _hSync ));
}

bool TEvent::Pulse()
{
    return bool_cast( PulseEvent( _hSync ));
}

//==---------------------------------------------------------------------------

TMutex::TMutex( LPSECURITY_ATTRIBUTES SecAttr, bool Own, CSTR Name )
: TSyncObj()
{
    _hSync = CreateMutex( SecAttr, Own, Name );
}

TMutex::TMutex( DWORD Access, bool Inherit, CSTR Name )
: TSyncObj()
{
    _hSync = OpenMutex( Access, Inherit, Name );
}

TMutex::~TMutex()
{
    Release(); // Schedule any pending waiter before dying.
}

bool TMutex::Release()
{
    return bool_cast( ReleaseMutex( _hSync ));
}

//==---------------------------------------------------------------------------

TSemaphore::TSemaphore( LPSECURITY_ATTRIBUTES SecAttr, LONG Count, LONG MaxCount, CSTR Name )
: TSyncObj()
{
    _hSync = CreateSemaphore( SecAttr, Count, MaxCount, Name ); 
}

TSemaphore::TSemaphore( DWORD Access, bool Inherit, CSTR Name )
: TSyncObj()
{
    _hSync = OpenSemaphore( Access, Inherit, Name );
}

TSemaphore::~TSemaphore()
{
    ReleaseAll(); // Schedule pending waiters before dying.
}

bool TSemaphore::Release( LONG Count, LPLONG OldCount )
{
    if (OldCount) *OldCount = 0;
    return bool_cast( ReleaseSemaphore( _hSync, Count, OldCount ));
}

LONG TSemaphore::ReleaseAll()
{
    LONG Count = 0;

    // Release to the hilt.

    if (!_hSync) SetLastError( ERROR_INVALID_HANDLE );
    else if (ReleaseSemaphore( _hSync, 1, &Count ) && (Count > 1))
        ReleaseSemaphore( _hSync, Count-1, NULL );
    return Count; // Nr released
}

LONG TSemaphore::Lock()
{
    LONG Count = 0;

    // Eat up all available to set it to unsignaled.

    if (!_hSync) SetLastError( ERROR_INVALID_HANDLE );
    else while (WaitFor( _hSync,0 )) Count++;
    return Count; // Nr consumed
}

//==---------------------------------------------------------------------------

TWaitTimer::TWaitTimer( LPSECURITY_ATTRIBUTES SecAttr, bool Manual, CSTR Name )
{
    _hSync = CreateWaitableTimer( SecAttr, Manual, Name );
}

TWaitTimer::TWaitTimer( DWORD Access, bool Inherit, CSTR Name )
{
    _hSync = OpenWaitableTimer( Access, Inherit, Name );
}

TWaitTimer::~TWaitTimer()
{
    Cancel(); // Hmm.. Not releasing waiters like the other sync objects.
}

bool TWaitTimer::Set( FILETIME Due, LONG Period, PTIMERAPCROUTINE Action, PVOID Context, bool Resume )
{
    ULARGE_INTEGER due = { Due.dwLowDateTime, Due.dwHighDateTime }; // Since FILETIME might have different alignment!
    return bool_cast( SetWaitableTimer( _hSync, (LARGE_INTEGER*)&due, Period, Action, Context, Resume ));
}


bool TWaitTimer::Set( INT64 Due, LONG Period, PTIMERAPCROUTINE Action, PVOID Context, bool Resume )
{
    LARGE_INTEGER due; 
    due.QuadPart = (Due < 0) ? Due : -Due;
    bool ok = bool_cast( SetWaitableTimer( _hSync, &due, Period, Action, Context, Resume ));
    //if (ok) WaitForSingleObject( _hSync,0 );
    return ok;
}

bool TWaitTimer::Cancel()
{
    return bool_cast( CancelWaitableTimer( _hSync ));
}

//==---------------------------------------------------------------------------
#undef SYNCOBJ_DBG_SEH
// EOF