fxcallbackspinlock.hpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxCallbackSpinLock.hpp
 
Abstract:
 
    This is the C++ header for the FxCallbackSpinLock
 
    This is the spinlock based driver callback lock
 
 
Author:
 
 
 
 
Revision History:
 
 
--*/
 
#ifndef _FXCALLBACKSPINLOCK_H_
#define _FXCALLBACKSPINLOCK_H_
 
extern "C" {
 
#if defined(EVENT_TRACING)
#include "FxCallbackSpinLock.hpp.tmh"
#endif
 
}
 
class FxCallbackSpinLock : public FxCallbackLock {
 
private:
    MxLock m_Lock;
 
public:
 
    FxCallbackSpinLock(
        PFX_DRIVER_GLOBALS FxDriverGlobals
        ) :
        FxCallbackLock(FxDriverGlobals)
    {
    }
 
    virtual
    ~FxCallbackSpinLock(
        VOID
        )
    {
        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,
                                                       FALSE);
 
        }
    }
 
    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);
            return;
        }
        else {
            if (m_Verifier != NULL) {
                m_Verifier->Lock(PreviousIrql, FALSE);
            }
            else {
                m_Lock.Acquire(PreviousIrql);
            }
 
            m_OwnerThread = cur;
            return;
        }
    }
 
    virtual
    void
    Unlock(
        __in KIRQL PreviousIrql
        )
    {
        CheckOwnership();
 
        if (m_RecursionCount > 0) {
            m_RecursionCount--;
        }
        else {
            m_OwnerThread = NULL;
            if (m_Verifier != NULL) {
                m_Verifier->Unlock(PreviousIrql, FALSE);
            }
            else {
                m_Lock.Release(PreviousIrql);
            }
        }
    }
 
    _Must_inspect_result_
    inline
    virtual
    BOOLEAN
    IsOwner(
        VOID
        )
    {
        MxThread cur = Mx::MxGetCurrentThread();
 
        if (m_OwnerThread == cur) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }
};
 
#endif // _FXCALLBACKSPINLOCK_H_