fxcallbackmutexlock.hpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxCallbackMutexLock.hpp
 
Abstract:
 
    This is the C++ header for the FxCallbackMutexLock
 
    This represents a container for handling locking
    when we callback into the device driver at thread
    level.
 
Author:
 
 
 
 
Revision History:
 
 
--*/
 
#ifndef _FXCALLBACKMUTEXLOCK_H_
#define _FXCALLBACKMUTEXLOCK_H_
 
extern "C" {
// #include "FxCallbackMutexLock.hpp.tmh"
}
 
class FxCallbackMutexLock : public FxCallbackLock {
 
private:
 
 
 
 
 
 
 
    MxPagedLock m_Lock;
 
public:
 
    FxCallbackMutexLock(
        PFX_DRIVER_GLOBALS FxDriverGlobals
        ) :
        FxCallbackLock(FxDriverGlobals)
    {
        m_Lock.Initialize();
    }
 
    virtual
    ~FxCallbackMutexLock()
    {
        if (m_Verifier) {
            delete m_Verifier;
        }
    }
 
    virtual
    void
    Initialize(
        FxObject* ParentObject
        )
    {
        PFX_DRIVER_GLOBALS fxDriverGlobals;
 
        m_Verifier = NULL;
        fxDriverGlobals = GetDriverGlobals();
 
        if (fxDriverGlobals->FxVerifierLock) {
 
            //
            // VerifierLock CreateAndInitialize failure is not fatal,
            // we just won't track anything
            //
            (void) FxVerifierLock::CreateAndInitialize(&m_Verifier,
                                                       fxDriverGlobals,
                                                       ParentObject,
                                                       TRUE);
        }
    }
 
    virtual
    void
    Lock(
        __out PKIRQL PreviousIrql
        )
    {
        MxThread cur = Mx::MxGetCurrentThread();
 
        if (m_OwnerThread == cur) {
            PFX_DRIVER_GLOBALS fxDriverGlobals;
 
            fxDriverGlobals = GetDriverGlobals();
            m_RecursionCount++;
 
            //
            // For now we have decided not to allow this.
            //
 
 
 
 
 
 
 
            //
            DoTraceLevelMessage(fxDriverGlobals, TRACE_LEVEL_FATAL, TRACINGDEVICE,
                                "Recursive acquire of callback lock 0x%p", this);
 
            FxVerifierBugCheck(fxDriverGlobals,
                               WDF_RECURSIVE_LOCK,
                               (ULONG_PTR)this);
        }
        else {
            if (m_Verifier != NULL) {
                m_Verifier->Lock(PreviousIrql, FALSE);
            }
            else {
                Mx::MxEnterCriticalRegion();
                m_Lock.AcquireUnsafe();
            }
            m_OwnerThread = cur;
        }
    }
 
    virtual
    void
    Unlock(
        __in KIRQL PreviousIrql
        )
    {
        CheckOwnership();
 
        if (m_RecursionCount > 0) {
            m_RecursionCount--;
        }
        else {
            m_OwnerThread = NULL;
            if (m_Verifier) {
                m_Verifier->Unlock(PreviousIrql, FALSE);
            }
            else {
                m_Lock.ReleaseUnsafe();
                Mx::MxLeaveCriticalRegion();
            }
        }
    }
 
    _Must_inspect_result_
    virtual
    BOOLEAN
    IsOwner(
        VOID
        )
    {
        MxThread cur = Mx::MxGetCurrentThread();
 
        if (m_OwnerThread == cur) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }
};
 
#endif // _FXCALLBACKMUTEXLOCK_H_