fxspinlock.cpp

Go to the documentation of this file.

/*++

Copyright (c) Microsoft Corporation

Module Name:

    FxSpinLock.cpp

Abstract:

    This module implements FxSpinLock

Author:



Environment:

   Both kernel and user mode

Revision History:

--*/

#include "fxsupportpch.hpp"
#include "fxspinlock.hpp"

extern "C" {
// #include "FxSpinLock.tmh"
}

FxSpinLock::FxSpinLock(
    __in PFX_DRIVER_GLOBALS FxDriverGlobals,
    __in USHORT ExtraSize
    ) :
    FxObject(FX_TYPE_SPIN_LOCK, COMPUTE_OBJECT_SIZE(sizeof(FxSpinLock), ExtraSize), FxDriverGlobals)
{
    FX_SPIN_LOCK_HISTORY* pHistory;

    m_Irql = 0;
    m_InterruptLock = FALSE;

    pHistory = GetHistory();

    if (pHistory != NULL) {
        RtlZeroMemory(pHistory, sizeof(FX_SPIN_LOCK_HISTORY));

        pHistory->CurrentHistory = &pHistory->History[0];
    }
}


__drv_raisesIRQL(DISPATCH_LEVEL)
__drv_maxIRQL(DISPATCH_LEVEL)
VOID
FxSpinLock::AcquireLock(
    __in PVOID CallersAddress
    )
{
    PFX_SPIN_LOCK_HISTORY pHistory;
    KIRQL irql;

    m_SpinLock.Acquire(&irql);

    m_Irql = irql;

    pHistory = GetHistory();

    if (pHistory != NULL) {
        PFX_SPIN_LOCK_HISTORY_ENTRY pCur;

        //
        // This assert should never fire here, but this helps track ownership
        // in the case of a release without an acquire.
        //
        ASSERT(pHistory->OwningThread == NULL);
        pHistory->OwningThread = Mx::MxGetCurrentThread();

        pCur = pHistory->CurrentHistory;

        Mx::MxQueryTickCount(&pCur->AcquiredAtTime);
        pCur->CallersAddress = CallersAddress;
    }
}

__drv_requiresIRQL(DISPATCH_LEVEL)
VOID
FxSpinLock::ReleaseLock(
    VOID
    )
{
    PFX_SPIN_LOCK_HISTORY pHistory;

    pHistory = GetHistory();

    if (pHistory != NULL) {
        LARGE_INTEGER now;
        PFX_SPIN_LOCK_HISTORY_ENTRY pCur;

        if (pHistory->OwningThread != Mx::MxGetCurrentThread()) {
            if (pHistory->OwningThread == NULL) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGERROR,
                    "WDFSPINLOCK %p being released by thread 0x%p, but was "
                    "never acquired!", GetObjectHandle(), Mx::MxGetCurrentThread());
            }
            else {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGERROR,
                    "WDFSPINLOCK 0x%p not owned by thread 0x%p, owned by thread 0x%p",
                    GetObjectHandle(), Mx::MxGetCurrentThread(),
                    pHistory->OwningThread);
            }

            FxVerifierBugCheck(GetDriverGlobals(),
                               WDF_INVALID_LOCK_OPERATION,
                               (ULONG_PTR) GetObjectHandle(),
                               0x1);
            //
            // Will not get here
            //
            return;
        }

        ASSERT(pHistory->OwningThread != NULL);

        Mx::MxQueryTickCount(&now);

        pCur = pHistory->CurrentHistory;
        pCur->LockedDuraction = now.QuadPart - pCur->AcquiredAtTime.QuadPart;

        pHistory->CurrentHistory++;
        if (pHistory->CurrentHistory >=
            pHistory->History + FX_SPIN_LOCK_NUM_HISTORY_ENTRIES) {
            pHistory->CurrentHistory = pHistory->History;
        }

        pHistory->OwningThread = NULL;
    }

    m_SpinLock.Release(m_Irql);
}