/*++

    Copyright (C) Microsoft Corporation, 1990 - 1999

    Module Name:

        mutex.hxx

    Abstract:

    This file contains the system independent mutex classes.  A mutex is an
    object which is used to serialize access to a resource.  Besides
    construction and destruction, a mutex can have two operations performed on
    it: Clear and Request.  Request is a request for exclusive access to the
    mutex; the method will not complete until the calling thread has exclusive
    access to the mutex.  Clear indicates that the thread with exclusive
    access to the mutex is done.

    Three MUTEX classes exist here, each for a particular purpose:

    MUTEX - a simple wrapper around WIN32 critical sections
        - fastest
        - better MP behavior
        - optimized for each platform
        - general purpose
        - recursive Request() calls allowed
        - good debugger support, !locks, critical section timeouts, etc

    MUTEX2 - basic lock used only for context handle dispatch serialization.
        - specific purpose.
        - may not be recursivly Request()'ed.
        - allows any thread to release the lock.
        - harder to debug

    MUTEX3 - basic lock used around connection oriented bind requests
        - behavior similar to MUTEX
        - slower
        - will not timeout
        - harder to debug

    Helper classes:

    CLAIM_MUTEX - designed as a local class wrapping a MUTEX
        Usage:

        MUTEX GlobalMutex;

        foo() {
            CLAIM_MUTEX lockit(GlobalMutex);
            // GlobalMutex is now held
            if (blah)
                return;
            bleh;
            return;
            } // GlobalMutex is released when "lockit" goes out of scope.

    EVENT - simple wrapper around a WIN32 event object

    Author:

        MikeMon

    Revision History:

    mikemon       ??-??-??    The starting line.
    mikemon       12-31-90    Upgraded the comments.
    MazharM       9/1998      MUTEX2
    MarioGo       11/1/1998   MUTEX3

--*/

#ifndef __MUTEX_HXX__
#define __MUTEX_HXX__

#include "util.hxx"

#ifdef DEBUGRPC
#define INCREMENT_CRITSECT_COUNT
#endif

class MUTEX
{
    BOOL IsSuccessfullyInitialized(void)
    {
        return (CriticalSection.DebugInfo != 0);
    }
    CRITICAL_SECTION CriticalSection;

    void EnumOwnedCriticalSections();

    void CommonConstructor(
        IN OUT RPC_STATUS PAPI * RpcStatus,
        IN DWORD dwSpinCount
        );

public:

    MUTEX (
        IN OUT RPC_STATUS PAPI * RpcStatus,
        IN DWORD dwSpinCount = 0
        )
    {
        CommonConstructor(RpcStatus, dwSpinCount);
    }

    MUTEX (
        IN OUT RPC_STATUS PAPI * RpcStatus,
        IN BOOL fPreallocateSemaphore,
        IN DWORD dwSpinCount = 0
        )
    {
        CommonConstructor(RpcStatus, 
            fPreallocateSemaphore ? (dwSpinCount | PREALLOCATE_EVENT_MASK) :
            dwSpinCount);
    }

    inline ~MUTEX ()
    {
        Free();
    }

    void Free(void);

    BOOL
    TryRequest()
    {
        BOOL Result = RtlTryEnterCriticalSection(&CriticalSection);

#ifdef CHECK_MUTEX_INVERSION
        if (Result)
            {
            LogEvent(SU_MUTEX, EV_INC, this);
            }
#endif

        return Result;
    }

    void Request ()
    {
#if 0
        EnumOwnedCriticalSections();
#endif

        NTSTATUS status;

        status = RtlEnterCriticalSection(&CriticalSection);
        ASSERT(NT_SUCCESS(status));

#ifdef CHECK_MUTEX_INVERSION
        LogEvent(SU_MUTEX, EV_INC, this);
#endif

#ifdef DEBUGRPC
        if (CriticalSection.RecursionCount > 100)
            {
            DbgPrint("thread %x has recursively taken mutex %x %d times\n",
                     GetCurrentThreadId(), &CriticalSection, CriticalSection.RecursionCount);
            RpcpBreakPoint();
            }
#endif
    }

    RPC_STATUS RequestSafe (void)
    {
        RPC_STATUS RetVal = RPC_S_OK;

        RpcTryExcept
            {
            Request();
            }
        RpcExcept((RpcExceptionCode() == STATUS_INSUFFICIENT_RESOURCES) 
            ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH )
            {
            RetVal = RpcExceptionCode();
            }
        RpcEndExcept

        return RetVal;
    }

    void Clear ()
    {
#ifdef CHECK_MUTEX_INVERSION
        LogEvent(SU_MUTEX, EV_DEC, this);
#endif

        NTSTATUS status;

        VerifyOwned();

        status =  RtlLeaveCriticalSection(&CriticalSection);
        ASSERT(NT_SUCCESS(status));
    }

    inline void
    VerifyOwned()
    {
        ASSERT(CriticalSection.OwningThread == ULongToPtr(GetCurrentThreadId()));
    }

    inline BOOL OwnedByMe()
    {
        if (CriticalSection.OwningThread == ULongToPtr(GetCurrentThreadId()) &&
            CriticalSection.RecursionCount != -1)
            {
            return TRUE;
            }

        return FALSE;
    }

    inline void
    VerifyNotOwned()
    {
        ASSERT(CriticalSection.OwningThread != ULongToPtr(GetCurrentThreadId()) ||
               CriticalSection.RecursionCount == -1);
    }

    DWORD
    SetSpinCount(
        unsigned long Count
        )
    {
        return SetCriticalSectionSpinCount(&CriticalSection, Count);
    }

};

extern RTL_CRITICAL_SECTION GlobalMutex;

#ifdef NO_RECURSIVE_MUTEXES
extern unsigned int RecursionCount;
#endif // NO_RECURSIVE_MUTEXES

#ifdef DBG
extern long lGlobalMutexCount;
#endif

inline void GlobalMutexRequest(void)
/*++

Routine Description:

    Request the global mutex.

--*/
{
#ifdef DBG
    InterlockedIncrement(&lGlobalMutexCount);
#endif

    NTSTATUS Status;

    Status = RtlEnterCriticalSection(&GlobalMutex);
    ASSERT(NT_SUCCESS(Status));

#ifdef NO_RECURSIVE_MUTEXES
    ASSERT(RecursionCount == 0);
    RecursionCount += 1;
#endif // NO_RECURSIVE_MUTEXES
}

inline void GlobalMutexClear(void)
/*++

Routine Description:

    Clear the global mutex.

--*/
{
#ifdef DBG
    InterlockedDecrement(&lGlobalMutexCount);
#endif

    NTSTATUS Status;

    Status = RtlLeaveCriticalSection(&GlobalMutex);
    ASSERT(NT_SUCCESS(Status));

#ifdef NO_RECURSIVE_MUTEXES
    RecursionCount -= 1;
#endif // NO_RECURSIVE_MUTEXES
}

inline BOOL GlobalMutexTryRequest(void)
{
    BOOL Result = RtlTryEnterCriticalSection(&GlobalMutex);

    if (Result)
        {
#ifdef DBG
        InterlockedIncrement(&lGlobalMutexCount);
#endif
#ifdef NO_RECURSIVE_MUTEXES
        ASSERT(RecursionCount == 0);
        RecursionCount += 1;
#endif // NO_RECURSIVE_MUTEXES
        }

    return Result;
}

inline void GlobalMutexVerifyOwned(void)
{
    ASSERT(GlobalMutex.OwningThread == ULongToPtr(GetCurrentThreadId()));
}

inline void GlobalMutexVerifyNotOwned(void)
{
    ASSERT(GlobalMutex.OwningThread != ULongToPtr(GetCurrentThreadId()) ||
           GlobalMutex.RecursionCount == -1);
}

inline DWORD GlobalMutexSetSpinCount(unsigned long Count)
{
    return SetCriticalSectionSpinCount(&GlobalMutex, Count);
}

class EVENT
{
public:

    HANDLE EventHandle;

    EVENT (
        IN OUT RPC_STATUS PAPI * RpcStatus,
        IN int ManualReset = 1,
        IN BOOL fDelayInit = FALSE
        );

    ~EVENT ( // Destructor.
        );

    void
    Raise ( // Raise the event.
        )
    {
        BOOL status;

        if (NULL == EventHandle)
            {
            InitializeEvent();
            }

        status = SetEvent(EventHandle);
        ASSERT(status == TRUE);
    }

    void
    Lower ( // Lower the event.
        )
    {
        BOOL status;

        status = ResetEvent(EventHandle);
        ASSERT(status == TRUE);
    }

    int
    Wait ( // Wait until the event is raised.
        IN long timeout = -1
        );

    void
    Request (
        ) {Wait(-1);}

    int
    RequestWithTimeout (
        IN long timeout = -1
        ) {return(Wait(timeout));}

    void
    Clear (
        ) {Raise();}

private:

    void InitializeEvent();
};


class CLAIM_MUTEX {

private:

    MUTEX & Resource;

public:

    CLAIM_MUTEX(
        MUTEX & ClaimedResource
        )
        : Resource(ClaimedResource)
    {
        Resource.Request();
    }

    ~CLAIM_MUTEX(
        )
    {
        Resource.Clear();
    }
};

class MUTEX2
{
    EVENT mutexEvent;
    INTERLOCKED_INTEGER guard;
    DWORD OwningThread;

public:

    MUTEX2 (
        IN OUT RPC_STATUS PAPI * RpcStatus
        ) : mutexEvent(RpcStatus, FALSE, TRUE), guard(0)
    {
    OwningThread = 0;

    // Don't set *RpcStatus to RPC_S_OK
    }

    void
    Request ()
    {
    if (guard.Increment() > 1)
        {
        mutexEvent.Wait();
        }

    ASSERT(OwningThread == 0);
    OwningThread = GetCurrentThreadId();
    }

    void
    Clear ()
    {
    OwningThread = 0;

    if (guard.Decrement() > 0)
        {
        mutexEvent.Raise();
        }
    }
};

class MUTEX3
{
private:
    EVENT event;
    INTERLOCKED_INTEGER guard;
    DWORD owner;
    DWORD recursion;

public:

    MUTEX3(RPC_STATUS *RpcStatus) : event(RpcStatus, FALSE, TRUE), guard(-1)
        {
        owner = 0;
        recursion = 0;

        // Don't set *RpcStatus to RPC_S_OK
        }

    void Request();
    void Clear();
    BOOL TryRequest();
};

#endif // __MUTEX_HXX__