FxVerifierLock Class Reference

#include <fxverifierlock.hpp>

Inheritance diagram for FxVerifierLock:

Collaboration diagram for FxVerifierLock:

Public Member Functions
	~FxVerifierLock (VOID)
VOID	Lock (__out PKIRQL PreviousIrql, __in BOOLEAN AtDpc)
VOID	Unlock (__in KIRQL PreviousIrql, __in BOOLEAN AtDpc)
KIRQL	GetLockPreviousIrql (VOID)
Public Member Functions inherited from FxGlobalsStump
	FxGlobalsStump (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)
Public Member Functions inherited from FxStump
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)
VOID	operator delete (__in PVOID pointer)
PVOID	operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID	operator delete[] (__in PVOID pointer)

Static Public Member Functions
_Must_inspect_result_ static __inline NTSTATUS	CreateAndInitialize (__out FxVerifierLock **VerifierLock, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *ParentObject, __in BOOLEAN UseMutex)
_Must_inspect_result_ static __inline NTSTATUS	CreateAndInitialize (__out FxVerifierLock **VerifierLock, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *ParentObject)
static void	AllocateThreadTable (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
static void	FreeThreadTable (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
static void	DumpDetails (__in FxVerifierLock *Lock, __in MxThread curThread, __in FxVerifierLock *PerThreadList)
static pFxVerifierThreadTableEntry	GetThreadTableEntry (__in MxThread curThread, __in FxVerifierLock *pLock, __in BOOLEAN LookupOnly)
static void	ReleaseOrReplaceThreadTableEntry (__in MxThread curThread, __in FxVerifierLock *pLock)

Public Attributes
FxVerifierThreadTableEntry	m_ThreadTableEntry

Static Public Attributes
static ULONG	ThreadTableSize
static KSPIN_LOCK	ThreadTableLock
static PLIST_ENTRY	ThreadTable

Private Member Functions
	FxVerifierLock (PFX_DRIVER_GLOBALS FxDriverGlobals)
void	InitializeLockOrder (VOID)
void	FxVerifierLockDumpDetails (__in FxVerifierLock *Lock, __in PVOID curThread, __in FxVerifierLock *PerThreadList)
	FxVerifierLock (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *ParentObject)
_Must_inspect_result_ __inline NTSTATUS	Initialize ()
	FxVerifierLock (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *ParentObject, __in BOOLEAN UseMutex)

Private Attributes
USHORT	m_Type
USHORT	m_Size
MxLock	m_Lock
KIRQL	m_OldIrql
MxPagedLock	m_Mutex
FxObject *	m_ParentObject
MxThread	m_OwningThread
USHORT	m_Order
BOOLEAN	m_UseMutex
BOOLEAN	m_CallbackLock
FxVerifierLock *	m_OwnedLink

Additional Inherited Members
Protected Member Functions inherited from FxStump
	FxStump (VOID)

Detailed Description

Definition at line 259 of file fxverifierlock.hpp.

Constructor & Destructor Documentation

FxVerifierLock() [1/3]

FxVerifierLock::FxVerifierLock ( PFX_DRIVER_GLOBALS  FxDriverGlobals )

inlineprivate

Definition at line 293 of file fxverifierlock.hpp.

          :
        FxGlobalsStump(FxDriverGlobals)
    {
    }

FxVerifierLock() [2/3]

FxVerifierLock::FxVerifierLock ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in FxObject *  ParentObject  )

inlineprivate

Definition at line 317 of file fxverifierlock.hpp.

          :
        FxGlobalsStump(FxDriverGlobals)
    {
        m_Type = FX_TYPE_VERIFIERLOCK;
        m_Size = sizeof(FxVerifierLock);
 
        m_ParentObject = ParentObject;
 
        m_OwningThread = NULL;
        m_OwnedLink    = NULL;
        m_Order        = FX_LOCK_ORDER_UNKNOWN;
 
        m_ThreadTableEntry.Thread = NULL;
        m_ThreadTableEntry.PerThreadPassiveLockList = NULL;
        m_ThreadTableEntry.PerThreadDispatchLockList = NULL;
 
        m_UseMutex = FALSE;
        m_CallbackLock = FALSE;
 
        InitializeLockOrder();
    }

FxVerifierLock() [3/3]

FxVerifierLock::FxVerifierLock ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in FxObject *  ParentObject, __in BOOLEAN  UseMutex  )

inlineprivate

Definition at line 372 of file fxverifierlock.hpp.

          :
        FxGlobalsStump(FxDriverGlobals)
    {
 
        m_Type = FX_TYPE_VERIFIERLOCK;
        m_Size = sizeof(FxVerifierLock);
 
        m_ParentObject = ParentObject;
 
        m_OwningThread = NULL;
        m_OwnedLink    = NULL;
        m_Order        = FX_LOCK_ORDER_UNKNOWN;
 
        m_ThreadTableEntry.Thread = NULL;
        m_ThreadTableEntry.PerThreadPassiveLockList = NULL;
        m_ThreadTableEntry.PerThreadDispatchLockList = NULL;
 
        // Different verifier table
        m_CallbackLock = TRUE;
 
        if (UseMutex) {
            m_UseMutex = TRUE;
        }
        else {
            m_UseMutex = FALSE;
        }
 
        InitializeLockOrder();
    }

~FxVerifierLock()

FxVerifierLock::~FxVerifierLock ( VOID  )

inline

Definition at line 480 of file fxverifierlock.hpp.

    {
        if (m_OwningThread != NULL) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Lock 0x%p is being destroyed while owned by "
                                "thread 0x%p, Owning Object 0x%p",
                                this, m_OwningThread, m_ParentObject);
            FxVerifierDbgBreakPoint(GetDriverGlobals());
        }
    }

Member Function Documentation

AllocateThreadTable()

void FxVerifierLock::AllocateThreadTable ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals )

static

Definition at line 937 of file fxverifierlock.cpp.

{
    KIRQL       oldIrql;
    ULONG       newEntries;
    PLIST_ENTRY newTable;
 
    FxDriverGlobals->ThreadTableLock.Acquire(&oldIrql);
 
    if( FxDriverGlobals->ThreadTable != NULL ) {
        FxDriverGlobals->ThreadTableLock.Release(oldIrql);
        return;
    }
 
    // Table must be kept as a power of 2 for hash algorithm
    newEntries = VERIFIER_THREAD_HASHTABLE_SIZE;
 
    newTable = (PLIST_ENTRY) FxPoolAllocateWithTag(
        FxDriverGlobals,
        NonPagedPool,
        sizeof(LIST_ENTRY) * newEntries,
        FxDriverGlobals->Tag);
 
    if( newTable == NULL ) {
        FxDriverGlobals->ThreadTableLock.Release(oldIrql);
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "No Memory to allocate thread table");
        return;
    }
 
    for(ULONG index=0; index < newEntries; index++ ) {
        InitializeListHead(&newTable[index]);
    }
 
    FxDriverGlobals->ThreadTable     = newTable;
 
    FxDriverGlobals->ThreadTableLock.Release(oldIrql);
 
    return;
}

Referenced by FxVerifierLockInitialize().

CreateAndInitialize() [1/2]

_Must_inspect_result_ static __inline NTSTATUS FxVerifierLock::CreateAndInitialize ( __out FxVerifierLock **  VerifierLock, __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in FxObject *  ParentObject  )

inlinestatic

Definition at line 449 of file fxverifierlock.hpp.

    {
        NTSTATUS status;
        FxVerifierLock * verifierLock;
 
        verifierLock = new (FxDriverGlobals) FxVerifierLock(FxDriverGlobals,
                                                            ParentObject);
        if (NULL == verifierLock) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Failed to allocate verifier lock, returning %!STATUS!",
                                status);
            goto exit;
        }
 
        status = verifierLock->Initialize();
        if (!NT_SUCCESS(status)) {
            delete verifierLock;
            goto exit;
        }
 
        *VerifierLock = verifierLock;
 
    exit:
        return status;
    }

CreateAndInitialize() [2/2]

_Must_inspect_result_ static __inline NTSTATUS FxVerifierLock::CreateAndInitialize ( __out FxVerifierLock **  VerifierLock, __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in FxObject *  ParentObject, __in BOOLEAN  UseMutex  )

inlinestatic

Definition at line 412 of file fxverifierlock.hpp.

    {
        NTSTATUS status;
        FxVerifierLock * verifierLock;
 
        verifierLock = new (FxDriverGlobals) FxVerifierLock(FxDriverGlobals,
                                                            ParentObject,
                                                            UseMutex);
        if (NULL == verifierLock) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Failed to allocate verifier lock, returning %!STATUS!",
                                status);
            goto exit;
        }
 
        status = verifierLock->Initialize();
        if (!NT_SUCCESS(status)) {
            delete verifierLock;
            goto exit;
        }
 
        *VerifierLock = verifierLock;
 
    exit:
        return status;
    }

Referenced by FxNonPagedObject::FxNonPagedObject(), FxLock::Initialize(), FxCallbackMutexLock::Initialize(), and FxCallbackSpinLock::Initialize().

DumpDetails()

void FxVerifierLock::DumpDetails ( __in FxVerifierLock *  Lock, __in MxThread  curThread, __in FxVerifierLock *  PerThreadList  )

static

Definition at line 1005 of file fxverifierlock.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = Lock->GetDriverGlobals();
 
    FxVerifierLock* next;
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "Thread 0x%p Attempted to acquire lock on Object 0x%p, "
                        "ObjectType 0x%x, at Level 0x%x out of sequence.",
                        curThread,Lock->m_ParentObject,
                        Lock->m_ParentObject->GetType(),
                        Lock->m_Order);
 
    next = PerThreadList;
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "Highest Lock Currently held is level 0x%x for "
                        "Object 0x%p, ObjectType 0x%x",
                        next->m_Order,
                        next->m_ParentObject,
                        next->m_ParentObject->GetType());
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "List of Already Acquired Locks and Objects:");
 
    while( next != NULL ) {
 
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Object 0x%p, ObjectType 0x%x, LockLevel 0x%x",
                            next->m_ParentObject,
                            next->m_ParentObject->GetType(),
                            next->m_Order);
 
        next = next->m_OwnedLink;
    }
 
    FxVerifierDbgBreakPoint(FxDriverGlobals);
 
    return;
}

Referenced by Lock().

FreeThreadTable()

void FxVerifierLock::FreeThreadTable ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals )

static

Definition at line 980 of file fxverifierlock.cpp.

{
    KIRQL oldIrql;
 
    UNREFERENCED_PARAMETER(FxDriverGlobals);
 
    FxDriverGlobals->ThreadTableLock.Acquire(&oldIrql);
 
    if( FxDriverGlobals->ThreadTable == NULL ) {
        FxDriverGlobals->ThreadTableLock.Release(oldIrql);
        return;
    }
 
    FxPoolFree(FxDriverGlobals->ThreadTable);
 
    FxDriverGlobals->ThreadTable = NULL;
 
    FxDriverGlobals->ThreadTableLock.Release(oldIrql);
 
    return;
}

Referenced by FxVerifierLockDestroy().

FxVerifierLockDumpDetails()

void FxVerifierLock::FxVerifierLockDumpDetails ( __in FxVerifierLock *  Lock, __in PVOID  curThread, __in FxVerifierLock *  PerThreadList  )

private

GetLockPreviousIrql()

KIRQL FxVerifierLock::GetLockPreviousIrql

(

VOID

)

Definition at line 602 of file fxverifierlock.cpp.

{
    return m_OldIrql;
}

GetThreadTableEntry()

pFxVerifierThreadTableEntry FxVerifierLock::GetThreadTableEntry ( __in MxThread  curThread, __in FxVerifierLock *  pLock, __in BOOLEAN  LookupOnly  )

static

Definition at line 652 of file fxverifierlock.cpp.

{
    ULONG Hash, Index;
    PLIST_ENTRY head, next;
    FxVerifierLock* entry;
 
    PFX_DRIVER_GLOBALS FxDriverGlobals = pLock->GetDriverGlobals();
 
    // Verifier is off, or an early memory allocation failure
    if( FxDriverGlobals->ThreadTable == NULL ) {
        return NULL;
    }
 
    //
    // Hash the KeCurrentThread() information into an table
    // index.
    //
    // Hash takes into account that NT pool items don't use
    // the lower 4 bits (16 byte boundries)
    //
 
    Hash = (ULONG)((ULONG_PTR)curThread >> 4);
    Hash = ((Hash >> 16) & 0x0000FFFF) ^ (Hash & 0x0000FFFF);
 
    //
    // Hash table is maintained as a power of two
    //
    Index = Hash & (VERIFIER_THREAD_HASHTABLE_SIZE-1);
 
    head = &FxDriverGlobals->ThreadTable[Index];
 
    //
    // Walk the list to see if our thread has an entry
    //
    next = head->Flink;
    while( next != head ) {
        entry = CONTAINING_RECORD(next, FxVerifierLock, m_ThreadTableEntry.HashChain);
 
        if( entry->m_ThreadTableEntry.Thread == curThread ) {
 
            //DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            //                    "Returning existing Entry 0x%p for Thread 0x%p, "
            //                    "Lock 0x%p",
            //                    &entry->m_ThreadTableEntry, curThread, pLock);
 
            return &entry->m_ThreadTableEntry;
        }
 
        next = next->Flink;
    }
 
    if( LookupOnly ) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Thread 0x%p does not have an entry",curThread);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        return NULL;
    }
 
    //
    // The current ETHREAD has no locks it currently holds, so it has
    // no entry in the hash table.
    //
    // Use the supplied locks m_ThreadTableEntry to create an entry
    // for this ETHREAD and the start of a new list of held locks.
    //
    pLock->m_ThreadTableEntry.Thread = curThread;
    pLock->m_ThreadTableEntry.PerThreadPassiveLockList = NULL;
    pLock->m_ThreadTableEntry.PerThreadDispatchLockList = NULL;
 
    InsertTailList(head, &pLock->m_ThreadTableEntry.HashChain);
 
//    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
//                        "Returning new Entry 0x%p for Thread 0x%p, Lock 0x%p",
//                        &pLock->m_ThreadTableEntry, curThread, pLock);
 
    return &pLock->m_ThreadTableEntry;
}

Referenced by Lock(), and Unlock().

Initialize()

_Must_inspect_result_ __inline NTSTATUS FxVerifierLock::Initialize ( )

inlineprivate

Definition at line 345 of file fxverifierlock.hpp.

    {
        NTSTATUS status;
 
        if (m_UseMutex) {
            status = m_Mutex.Initialize();
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                    "Unable to initialize paged lock for VerifierLock 0x%p "
                                    "status %!STATUS!",
                                    this, status);
                return status;
            }
        }
 
        return STATUS_SUCCESS;
    }

Referenced by CreateAndInitialize().

InitializeLockOrder()

void FxVerifierLock::InitializeLockOrder ( VOID  )

private

Definition at line 608 of file fxverifierlock.cpp.

{
    USHORT ObjectType;
    pFxVerifierOrderMapping p;
 
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    ObjectType = m_ParentObject->GetType();
 
    if( m_CallbackLock ) {
        p = FxVerifierCallbackOrderTable;
    }
    else {
        p = FxVerifierOrderTable;
    }
 
    while( p->ObjectType != 0 ) {
 
        if( p->ObjectType == ObjectType ) {
            m_Order = p->ObjectLockOrder;
            return;
        }
 
        p++;
    }
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "Object Type 0x%x does not have a lock order "
                        "defined in fx\\inc\\FxVerifierLock.hpp",
                        ObjectType);
 
    m_Order = FX_LOCK_ORDER_UNKNOWN;
 
    return;
}

Referenced by FxVerifierLock().

Lock()

VOID FxVerifierLock::Lock	(	__out PKIRQL	PreviousIrql,
		__in BOOLEAN	AtDpc
	)

Definition at line 151 of file fxverifierlock.cpp.

{
    MxThread curThread;
    FxVerifierLock* head;
    pFxVerifierThreadTableEntry perThreadList;
    KIRQL oldIrql = PASSIVE_LEVEL;
 
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    curThread = Mx::MxGetCurrentThread();
 
    //
    // First check to see if the lock is already
    // owned.
    //
    // This check is race free since this can only be set
    // to our thread from under the spinlock, and is cleared
    // before release.
    //
 
    if( m_OwningThread == curThread ) {
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_FATAL, TRACINGDEVICE,
            "Thread 0x%p already owns lock 0x%p for object 0x%p, WDFOBJECT 0x%p",
            curThread, this, m_ParentObject, m_ParentObject->GetObjectHandle());
 
        FxVerifierBugCheck( FxDriverGlobals,
                            WDF_RECURSIVE_LOCK,
                            (ULONG_PTR) m_ParentObject->GetObjectHandle(),
                            (ULONG_PTR) this);
    }
 
    if( m_UseMutex ) {
        // Get the Mutex
        Mx::MxEnterCriticalRegion();
        m_Mutex.AcquireUnsafe();
 
        *PreviousIrql = Mx::MxGetCurrentIrql();
    }
    else if (AtDpc) {
        // Get the spinlock
        m_Lock.AcquireAtDpcLevel();
        m_OldIrql = DISPATCH_LEVEL;
 
        *PreviousIrql = m_OldIrql;
    }
    else {
        // Try to force a thread switch to catch synchronization errors
        if (Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
            LARGE_INTEGER sleepTime;
 
            sleepTime.QuadPart = 0;
            Mx::MxDelayExecutionThread(KernelMode, TRUE, &sleepTime);
        }
 
        // Get the spinlock using a local since KeAcquireSpinLock might use this
        // var as temp space while spinning and we would then corrupt it if
        // the owning thread used it in the middle of the spin.
        //
        m_Lock.Acquire(PreviousIrql);
        m_OldIrql = *PreviousIrql;
    }
 
    // Lock the verifier lists
    if (m_UseMutex) {
        FxDriverGlobals->ThreadTableLock.Acquire(&oldIrql);
    }
    else {
        FxDriverGlobals->ThreadTableLock.AcquireAtDpcLevel();
    }
 
    m_OwningThread = curThread;
 
    // Get our per thread list from the thread table
    perThreadList = FxVerifierLock::GetThreadTableEntry(curThread, this, FALSE);
    if( perThreadList == NULL ) {
 
        if (m_UseMutex) {
            FxDriverGlobals->ThreadTableLock.Release(oldIrql);
        }
        else {
            FxDriverGlobals->ThreadTableLock.ReleaseFromDpcLevel();
        }
 
        // Can't get an entry, so return
        return;
    }
 
    //
    // There are seperately sorted lists for passive and dispatch
    // level locks since dispatch level locks of a lower level can interrupt a
    // higher passive level lock, giving a false report.
    //
    if( m_UseMutex ) {
        head = perThreadList->PerThreadPassiveLockList;
    }
    else {
        head = perThreadList->PerThreadDispatchLockList;
    }
 
    if( head != NULL ) {
 
        // Validate current is > head
        if( m_Order > head->m_Order ) {
            m_OwnedLink = head;
            //perThreadList->PerThreadLockList = this;
        }
        else if( m_Order == head->m_Order ) {
 
            // Place at head if the same lock level as current head
            m_OwnedLink = head;
            //perThreadList->PerThreadLockList = this;
        }
        else {
 
            // Lock violation, m_Order < head->m_Order
            FxVerifierLock::DumpDetails(this, curThread, head);
 
            //
            // Caller is feeling lucky and resumed so place it at the head
            // to keep our lists intact
            //
            m_OwnedLink = head;
            //perThreadList->PerThreadLockList = this;
        }
    }
    else {
        this->m_OwnedLink = NULL;
        //perThreadList->PerThreadLockList = this;
    }
 
    //
    // Update to the next list head
    //
    if (m_UseMutex) {
        perThreadList->PerThreadPassiveLockList = this;
        FxDriverGlobals->ThreadTableLock.Release(oldIrql);
    }
    else {
        perThreadList->PerThreadDispatchLockList = this;
        FxDriverGlobals->ThreadTableLock.ReleaseFromDpcLevel();
    }
 
    return;
}

Referenced by FxNonPagedObject::_Acquires_lock_(), FxLock::_When_(), FxCallbackMutexLock::Lock(), and FxCallbackSpinLock::Lock().

ReleaseOrReplaceThreadTableEntry()

void FxVerifierLock::ReleaseOrReplaceThreadTableEntry ( __in MxThread  curThread, __in FxVerifierLock *  pLock  )

static

Definition at line 823 of file fxverifierlock.cpp.

{
    ULONG Hash, Index;
    PLIST_ENTRY head;
    FxVerifierLock* pNewLock = NULL;
 
    PFX_DRIVER_GLOBALS FxDriverGlobals = pLock->GetDriverGlobals();
 
    if( pLock->m_ThreadTableEntry.Thread == NULL ) {
 
        // This locks entry is not used for hash chaining
        //DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
        //                    "Entry 0x%p Not currently part of the hash chain",
        //                     pLock);
 
        return;
    }
 
    // It should be the current thread
    if( pLock->m_ThreadTableEntry.Thread != curThread ) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "OldEntry Thread 0x%p not Current! 0x%p",
                            pLock,curThread);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
    }
 
    Hash = (ULONG)((ULONG_PTR)curThread >> 4);
    Hash = ((Hash >> 16) & 0x0000FFFF) ^ (Hash & 0x0000FFFF);
 
    Index = Hash & (VERIFIER_THREAD_HASHTABLE_SIZE-1);
 
    head = &FxDriverGlobals->ThreadTable[Index];
 
    // Remove old entry
    RemoveEntryList(&pLock->m_ThreadTableEntry.HashChain);
 
    //
    // If both lock lists are NULL, we can just release the entry
    //
    if( (pLock->m_ThreadTableEntry.PerThreadPassiveLockList == NULL) &&
        (pLock->m_ThreadTableEntry.PerThreadDispatchLockList == NULL) ) {
 
        //DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
        //                    "Releasing entry  for lock 0x%p for Thread 0x%p",
        //                    pLock, curThread);
 
        // This is now an unused entry
        pLock->m_ThreadTableEntry.Thread = NULL;
        pLock->m_ThreadTableEntry.PerThreadPassiveLockList = NULL;
        pLock->m_ThreadTableEntry.PerThreadDispatchLockList = NULL;
 
        return;
    }
 
    //DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
    //                    "Replacing Lock 0x%p, for Thread 0x%p",
    //                    pLock, curThread);
    if( pLock->m_ThreadTableEntry.PerThreadPassiveLockList != NULL ) {
        pNewLock = pLock->m_ThreadTableEntry.PerThreadPassiveLockList;
    }
    else {
        pNewLock = pLock->m_ThreadTableEntry.PerThreadDispatchLockList;
    }
 
    ASSERT(pNewLock != NULL);
    ASSERT(pNewLock->m_ThreadTableEntry.Thread == NULL);
    ASSERT(pNewLock->m_ThreadTableEntry.PerThreadPassiveLockList == NULL);
    ASSERT(pNewLock->m_ThreadTableEntry.PerThreadDispatchLockList == NULL);
 
    // Copy the old lock structures table to the next one
    pNewLock->m_ThreadTableEntry.Thread = pLock->m_ThreadTableEntry.Thread;
    pNewLock->m_ThreadTableEntry.PerThreadPassiveLockList = pLock->m_ThreadTableEntry.PerThreadPassiveLockList;
    pNewLock->m_ThreadTableEntry.PerThreadDispatchLockList = pLock->m_ThreadTableEntry.PerThreadDispatchLockList;
 
    // Insert new entry at the end of thelist
    InsertTailList(head, &pNewLock->m_ThreadTableEntry.HashChain);
 
    return;
}

Referenced by Unlock().

Unlock()

void FxVerifierLock::Unlock	(	__in KIRQL	PreviousIrql,
		__in BOOLEAN	AtDpc
	)

Definition at line 302 of file fxverifierlock.cpp.

{
    MxThread curThread;
    pFxVerifierThreadTableEntry perThreadList;
    KIRQL oldIrql;
 
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    // Only from DISPATCH_LEVEL or below
    curThread = Mx::MxGetCurrentThread();
 
    if( curThread != m_OwningThread ) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Thread 0x%p Is Attempting to release a Lock 0x%p "
                            "for Object 0x%p it does not own!",
                            curThread,this,m_ParentObject);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        return;
    }
 
    // Lock the verifier lists
    FxDriverGlobals->ThreadTableLock.Acquire(&oldIrql);
 
    // Get our per thread list from the thread table
    perThreadList = FxVerifierLock::GetThreadTableEntry(m_OwningThread, this, TRUE);
    if( perThreadList == NULL ) {
 
        // Can't get our entry, so release the spinlock and return
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Unlock:  Can't get per thread entry for thread %p",
                            curThread);
 
        m_OwningThread = NULL;
 
        FxDriverGlobals->ThreadTableLock.Release(oldIrql);
 
        if (m_UseMutex) {
            m_Mutex.ReleaseUnsafe();
            Mx::MxLeaveCriticalRegion();
        }
        else if (AtDpc) {
            m_Lock.ReleaseFromDpcLevel();
        }
        else {
            m_Lock.Release(PreviousIrql);
 
            // Try to force a thread switch to catch synchronization errors
            if (Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
                LARGE_INTEGER sleepTime;
 
                sleepTime.QuadPart = 0;
                Mx::MxDelayExecutionThread(KernelMode, TRUE, &sleepTime);
            }
        }
        return;
    }
 
    if( m_UseMutex ) {
        if( perThreadList->PerThreadPassiveLockList == NULL ) {
            // Problem with verifier
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Thread has entry, but no locks recorded as "
                                "held for passive!");
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "this 0x%p, perThreadList 0x%p",
                                this, perThreadList);
            FxVerifierDbgBreakPoint(FxDriverGlobals);
 
            m_OwningThread = NULL;
 
            FxDriverGlobals->ThreadTableLock.Release(oldIrql);
 
            m_Mutex.ReleaseUnsafe();
            Mx::MxLeaveCriticalRegion();
 
            return;
        }
    }
    else {
        if( perThreadList->PerThreadDispatchLockList == NULL ) {
            // Problem with verifier
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Thread has entry, but no locks recorded as held "
                                "for dispatch!");
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "this 0x%p, perThreadList 0x%p",
                                this, perThreadList);
            FxVerifierDbgBreakPoint(FxDriverGlobals);
 
            m_OwningThread = NULL;
 
            FxDriverGlobals->ThreadTableLock.Release(oldIrql);
 
            if (AtDpc) {
                m_Lock.ReleaseFromDpcLevel();
            }
            else {
                m_Lock.Release(PreviousIrql);
 
                // Try to force a thread switch to catch synchronization errors
                if (Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
                    LARGE_INTEGER sleepTime;
 
                    sleepTime.QuadPart = 0;
                    Mx::MxDelayExecutionThread(KernelMode, TRUE, &sleepTime);
                }
            }
 
            return;
        }
    }
 
    if( m_UseMutex ) {
 
        // Common case is a nested release
        if( perThreadList->PerThreadPassiveLockList == this ) {
 
            perThreadList->PerThreadPassiveLockList = this->m_OwnedLink;
            m_OwnedLink = NULL;
 
            ReleaseOrReplaceThreadTableEntry(curThread, this);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        }
        else {
            //
            // Releasing out of order does not deadlock as
            // long as all acquires are in order, but its
            // not commmon
            //
            FxVerifierLock* next;
            FxVerifierLock* prev = NULL;
 
            // Skip the first entry checked by the above if
            prev = perThreadList->PerThreadPassiveLockList;
            next = perThreadList->PerThreadPassiveLockList->m_OwnedLink;
 
            while( next != NULL ) {
 
                if( next == this ) {
                    prev->m_OwnedLink = m_OwnedLink;
                    m_OwnedLink = NULL;
 
                    //
                    // The perThreadList entry may, or may not be the
                    // data structure in this lock. Sinse we are releasing
                    // the lock, this entry can no longer be referenced if
                    // so.
                    //
                    ReleaseOrReplaceThreadTableEntry(curThread, this);
 
//                    FxVerifierLock::ReplaceThreadTableEntry(curThread, this, perThreadList->PerThreadPassiveLockList);
 
                    break;
                }
 
                prev = next;
                next = next->m_OwnedLink;
            }
 
            if( next == NULL ) {
                // Somehow the entry is gone
                DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                    "Record entry for VerifierLock 0x%p is missing "
                                    "on list 0x%p for Thread 0x%p",
                                    this,perThreadList,m_OwningThread);
                FxVerifierDbgBreakPoint(FxDriverGlobals);
            }
        }
    }
    else {
 
        // Common case is a nested release
        if( perThreadList->PerThreadDispatchLockList == this ) {
 
            perThreadList->PerThreadDispatchLockList = this->m_OwnedLink;
            m_OwnedLink = NULL;
 
            ReleaseOrReplaceThreadTableEntry(curThread, this);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        }
        else {
            //
            // Releasing out of order does not deadlock as
            // long as all acquires are in order, but its
            // not commmon
            //
            FxVerifierLock* next;
            FxVerifierLock* prev = NULL;
 
            // Skip the first entry checked by the above if
            prev = perThreadList->PerThreadDispatchLockList;
            next = perThreadList->PerThreadDispatchLockList->m_OwnedLink;
 
            while( next != NULL ) {
 
                if( next == this ) {
                    prev->m_OwnedLink = m_OwnedLink;
                    m_OwnedLink = NULL;
 
                    //
                    // The perThreadList entry may, or may not be the
                    // data structure in this lock. Sinse we are releasing
                    // the lock, this entry can no longer be referenced if
                    // so.
                    //
                    ReleaseOrReplaceThreadTableEntry(curThread, this);
 
//                    FxVerifierLock::ReplaceThreadTableEntry(curThread, this, perThreadList->PerThreadDispatchLockList);
 
                    break;
                }
 
                prev = next;
                next = next->m_OwnedLink;
            }
 
            if( next == NULL ) {
                // Somehow the entry is gone
                DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                    "Record entry for VerifierLock 0x%p is missing "
                                    "on list 0x%p for Thread 0x%p",
                                    this,perThreadList,m_OwningThread);
                FxVerifierDbgBreakPoint(FxDriverGlobals);
            }
        }
 
    }
 
    m_OwningThread = NULL;
 
    FxDriverGlobals->ThreadTableLock.Release(oldIrql);
 
    if (m_UseMutex) {
        m_Mutex.ReleaseUnsafe();
        Mx::MxLeaveCriticalRegion();
    }
    else if (AtDpc) {
        m_Lock.ReleaseFromDpcLevel();
    }
    else {
        m_Lock.Release(PreviousIrql);
 
        // Try to force a thread switch to catch synchronization errors
        if (Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
            LARGE_INTEGER sleepTime;
 
            sleepTime.QuadPart = 0;
            Mx::MxDelayExecutionThread(KernelMode, TRUE, &sleepTime);
        }
    }
 
    return;
}

Referenced by FxNonPagedObject::_Releases_lock_(), FxNonPagedObject::_Requires_lock_held_(), FxLock::_When_(), FxCallbackMutexLock::Unlock(), and FxCallbackSpinLock::Unlock().

Member Data Documentation

m_CallbackLock

BOOLEAN FxVerifierLock::m_CallbackLock

private

Definition at line 285 of file fxverifierlock.hpp.

Referenced by FxVerifierLock(), and InitializeLockOrder().

m_Lock

MxLock FxVerifierLock::m_Lock

private

Definition at line 267 of file fxverifierlock.hpp.

Referenced by Lock(), and Unlock().

m_Mutex

MxPagedLock FxVerifierLock::m_Mutex

private

Definition at line 271 of file fxverifierlock.hpp.

Referenced by Initialize(), Lock(), and Unlock().

m_OldIrql

KIRQL FxVerifierLock::m_OldIrql

private

Definition at line 268 of file fxverifierlock.hpp.

Referenced by GetLockPreviousIrql(), and Lock().

m_Order

USHORT FxVerifierLock::m_Order

private

Definition at line 279 of file fxverifierlock.hpp.

Referenced by FxVerifierLock(), InitializeLockOrder(), and Lock().

m_OwnedLink

FxVerifierLock* FxVerifierLock::m_OwnedLink

private

Definition at line 290 of file fxverifierlock.hpp.

Referenced by FxVerifierLock(), Lock(), and Unlock().

m_OwningThread

MxThread FxVerifierLock::m_OwningThread

private

Definition at line 278 of file fxverifierlock.hpp.

Referenced by FxVerifierLock(), Lock(), Unlock(), and ~FxVerifierLock().

m_ParentObject

FxObject* FxVerifierLock::m_ParentObject

private

Definition at line 277 of file fxverifierlock.hpp.

Referenced by FxVerifierLock(), InitializeLockOrder(), Lock(), Unlock(), and ~FxVerifierLock().

m_Size

USHORT FxVerifierLock::m_Size

private

Definition at line 264 of file fxverifierlock.hpp.

Referenced by FxVerifierLock().

m_ThreadTableEntry

FxVerifierThreadTableEntry FxVerifierLock::m_ThreadTableEntry

Definition at line 513 of file fxverifierlock.hpp.

Referenced by FxVerifierLock(), GetThreadTableEntry(), and ReleaseOrReplaceThreadTableEntry().

m_Type

USHORT FxVerifierLock::m_Type

private

Definition at line 263 of file fxverifierlock.hpp.

Referenced by FxVerifierLock().

m_UseMutex

BOOLEAN FxVerifierLock::m_UseMutex

private

Definition at line 282 of file fxverifierlock.hpp.

Referenced by FxVerifierLock(), Initialize(), Lock(), and Unlock().

ThreadTable

PLIST_ENTRY FxVerifierLock::ThreadTable

static

Definition at line 522 of file fxverifierlock.hpp.

ThreadTableLock

KSPIN_LOCK FxVerifierLock::ThreadTableLock

static

Definition at line 520 of file fxverifierlock.hpp.

ThreadTableSize

ULONG FxVerifierLock::ThreadTableSize

static

Definition at line 518 of file fxverifierlock.hpp.

---

The documentation for this class was generated from the following files:

• sdk/lib/drivers/wdf/shared/inc/private/common/fxverifierlock.hpp
• sdk/lib/drivers/wdf/shared/object/fxverifierlock.cpp