#include <fxglobals.h>

Collaboration diagram for _FX_DRIVER_GLOBALS:

[legend]

Public Member Functions
ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

ULONG __inline	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

BOOLEAN	IsPoolTrackingOn (VOID)

BOOLEAN	IsObjectDebugOn (VOID)

VOID	SetVerifierState (__in BOOLEAN State)

_Must_inspect_result_ BOOLEAN	IsVersionGreaterThanOrEqualTo (__in ULONG Major, __in ULONG Minor)

_Must_inspect_result_ BOOLEAN	IsCorrectVersionRegistered (_In_ PCUNICODE_STRING ServiceKeyName)

VOID	RegisterClientVersion (_In_ PCUNICODE_STRING ServiceKeyName)

_Must_inspect_result_ BOOLEAN	IsVerificationEnabled (__in ULONG Major, __in ULONG Minor, __in FxVerifierDownlevelOption DownLevel)

__inline _Must_inspect_result_ BOOLEAN	IsDownlevelVerificationEnabled ()

VOID	WaitForSignal (__in MxEvent *Event, __in PCSTR ReasonForWaiting, __in PVOID Handle, __in ULONG WarningTimeoutInSec, __in ULONG WaitSignalFlags)

_Must_inspect_result_ BOOLEAN	IsDebuggerAttached (VOID)

	DECLSPEC_ALIGN (MEMORY_ALLOCATION_ALIGNMENT) WDF_DRIVER_GLOBALS Public

Public Attributes
LIST_ENTRY	Linkage

LONG	Refcnt

MxEvent	DestroyEvent

ULONG_PTR	WdfHandleMask

LONG	WdfVerifierAllocateFailCount

ULONG	Tag

FxDriver *	Driver

FxDriverGlobalsDebugExtension *	DebugExtension

FxLibraryGlobalsType *	LibraryGlobals

PVOID	WdfLogHeader

FX_POOL	FxPoolFrameworks

BOOLEAN	FxPoolTrackingOn

MxLock	ThreadTableLock

PLIST_ENTRY	ThreadTable

PWDF_BIND_INFO	WdfBindInfo

PVOID	ImageAddress

ULONG	ImageSize

BOOLEAN	FxVerifierOn

BOOLEAN	FxVerifyDownlevel

BOOLEAN	FxVerifierDbgBreakOnError

BOOLEAN	FxVerifierDbgBreakOnDeviceStateError

BOOLEAN	FxVerifierHandle

BOOLEAN	FxVerifierIO

BOOLEAN	FxVerifierLock

BOOLEAN	FxVerifyOn

BOOLEAN	FxVerboseOn

BOOLEAN	FxRequestParentOptimizationOn

BOOLEAN	FxDsfOn

BOOLEAN	FxForceLogsInMiniDump

BOOLEAN	FxTrackDriverForMiniDumpLog

BOOLEAN	IsUserModeDriver

ULONG	RemoveLockOptionFlags

ULONG	BugCheckDriverInfoIndex

KBUGCHECK_REASON_CALLBACK_RECORD	BugCheckCallbackRecord

ULONG	FxEnhancedVerifierOptions

ULONG	FxVerifierDbgWaitForSignalTimeoutInSec

ULONG	DbgWaitForWakeInterruptIsrTimeoutInSec

CWudfDriverGlobals *	UfxDriverGlobals

PFX_TELEMETRY_CONTEXT	TelemetryContext

Detailed Description

Definition at line 165 of file fxglobals.h.

Member Function Documentation

◆ AddRef()

ULONG __inline _FX_DRIVER_GLOBALS::AddRef	(	__in_opt PVOID	Tag = `NULL`,
		__in LONG	Line = `0`,
		__in_opt PSTR	File = `NULL`
	)

inline

Definition at line 169 of file fxglobals.h.

    {
        ULONG c;
 
        UNREFERENCED_PARAMETER(Tag);
        UNREFERENCED_PARAMETER(Line);
        UNREFERENCED_PARAMETER(File);
 
        c = InterlockedIncrement(&Refcnt);
 
        //
        // Catch the transition from 0 to 1.  Since the RefCount starts off at 1,
        // we should never have to increment to get to this value.
        //
        ASSERT(c > 1);
        return c;
    }

◆ DECLSPEC_ALIGN()

_FX_DRIVER_GLOBALS::DECLSPEC_ALIGN ( MEMORY_ALLOCATION_ALIGNMENT )

◆ IsCorrectVersionRegistered()

_Must_inspect_result_ BOOLEAN FX_DRIVER_GLOBALS::IsCorrectVersionRegistered ( _In_ PCUNICODE_STRING ServiceKeyName )

Definition at line 112 of file globalskm.cpp.

{
    FxAutoRegKey hDriver, hWdf;
    DECLARE_CONST_UNICODE_STRING(parametersPath, L"Parameters\\Wdf");
    DECLARE_CONST_UNICODE_STRING(wdfMajorValue, WDF_MAJOR_VERSION_VALUE);
    DECLARE_CONST_UNICODE_STRING(wdfMinorValue, WDF_MINOR_VERSION_VALUE);
    ULONG registeredMajor = 0, registeredMinor = 0;
    NTSTATUS status;
 
    status = FxRegKey::_OpenKey(NULL,
                                ServiceKeyName,
                                &hDriver.m_Key,
                                KEY_READ
                                );
    if (!NT_SUCCESS(status)) {
        return FALSE;
    }
 
    status = FxRegKey::_OpenKey(hDriver.m_Key,
                                &parametersPath,
                                &hWdf.m_Key,
                                KEY_READ
                                );
    if (!NT_SUCCESS(status)) {
        return FALSE;
    }
 
    status = FxRegKey::_QueryULong(hWdf.m_Key,
                                   &wdfMajorValue,
                                   &registeredMajor);
 
    if (!NT_SUCCESS(status) || registeredMajor != WdfBindInfo->Version.Major) {
        return FALSE;
    }
 
    status = FxRegKey::_QueryULong(hWdf.m_Key,
                                   &wdfMinorValue,
                                   &registeredMinor);
 
    if  (!NT_SUCCESS(status) || registeredMinor != WdfBindInfo->Version.Minor){
        return FALSE;
    }
    else {
        return TRUE;
    }
}

◆ IsDebuggerAttached()

_Must_inspect_result_ BOOLEAN FX_DRIVER_GLOBALS::IsDebuggerAttached ( VOID )

Definition at line 250 of file globalskm.cpp.

{
    return (FALSE == KdRefreshDebuggerNotPresent());
}

Referenced by WaitForSignal().

◆ IsDownlevelVerificationEnabled()

__inline _Must_inspect_result_ BOOLEAN _FX_DRIVER_GLOBALS::IsDownlevelVerificationEnabled ( )

inline

Definition at line 314 of file fxglobals.h.

    {
        return FxVerifyDownlevel;
    }

Referenced by if().

◆ IsObjectDebugOn()

BOOLEAN _FX_DRIVER_GLOBALS::IsObjectDebugOn ( VOID )

inline

Definition at line 223 of file fxglobals.h.

    {
        if (FxVerifierHandle) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }

◆ IsPoolTrackingOn()

BOOLEAN _FX_DRIVER_GLOBALS::IsPoolTrackingOn ( VOID )

inline

Definition at line 215 of file fxglobals.h.

    {
        return (FxPoolTrackingOn) ? TRUE : FALSE;
    }

Referenced by FxDevice::AllocateRequestMemory(), FxLookasideList::InitObjectAlloc(), and FxPagedLookasideListFromPool::InitPagedAlloc().

◆ IsVerificationEnabled()

_Must_inspect_result_ BOOLEAN _FX_DRIVER_GLOBALS::IsVerificationEnabled	(	__in ULONG	Major,
		__in ULONG	Minor,
		__in FxVerifierDownlevelOption	DownLevel
	)

inline

Definition at line 286 of file fxglobals.h.

    {
        //
        // those verifier checks that are restricted to specific version can be
        // applied to previous version drivers if driver opts-in by setting a
        // reg key (whose value is stored in FxVerifyDownlevel)
        //
        if (FxVerifierOn &&
            (IsVersionGreaterThanOrEqualTo(Major, Minor) ||
             (DownLevel ? FxVerifyDownlevel : FALSE))) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }

Referenced by FxPkgGeneral::AcquireRemoveLockForClose(), FxDmaTransactionBase::Dispose(), FxIoTarget::GotoStartState(), FxUsbPipe::GotoStopState(), FxPowerIdleMachine::IoDecrement(), FxDmaTransactionBase::ReleaseForReuse(), FxRequest::Reuse(), and FxDmaSystemTransaction::StopTransfer().

◆ IsVersionGreaterThanOrEqualTo()

_Must_inspect_result_ BOOLEAN FX_DRIVER_GLOBALS::IsVersionGreaterThanOrEqualTo	(	__in ULONG	Major,
		__in ULONG	Minor
	)

Definition at line 92 of file globalskm.cpp.

{
    if ((WdfBindInfo->Version.Major > Major) ||
                (WdfBindInfo->Version.Major == Major &&
                  WdfBindInfo->Version.Minor >= Minor)) {
        return TRUE;
    }
    else {
        return FALSE;
    }
}

Referenced by FxFileObject::_GetFileObjectFromWdm(), FxCommonBuffer::AllocateCommonBuffer(), FxIoTargetRemote::Close(), FxPkgGeneral::ConfigureConstraints(), FxObjectAllocateContext(), FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler(), FxUsbPipe::GotoStopState(), if(), IsVerificationEnabled(), FxPkgPnp::QueryForCapabilities(), FxIoQueue::QueuePurge(), FxRequest::Reuse(), and VerifyWdfRequestForwardToParentDeviceIoQueue().

◆ RegisterClientVersion()

VOID FX_DRIVER_GLOBALS::RegisterClientVersion ( _In_ PCUNICODE_STRING ServiceKeyName )

Definition at line 162 of file globalskm.cpp.

{
    FxAutoRegKey hDriver, hParameters, hWdf;
    DECLARE_CONST_UNICODE_STRING(parametersPart, L"Parameters");
    DECLARE_CONST_UNICODE_STRING(wdfPart, L"Wdf");
    //
    //  Not defined with the macro because ZwSetValue doesn't use PCUNICODE_STRING
    //
    UNICODE_STRING wdfMajorValue;
    UNICODE_STRING wdfMinorValue;
    NTSTATUS status;
 
    RtlInitUnicodeString(&wdfMajorValue, WDF_MAJOR_VERSION_VALUE);
    RtlInitUnicodeString(&wdfMinorValue, WDF_MINOR_VERSION_VALUE);
 
    status = FxRegKey::_OpenKey(NULL,
                                ServiceKeyName,
                                &hDriver.m_Key,
                                KEY_WRITE | KEY_READ
                                );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(this, TRACE_LEVEL_VERBOSE, TRACINGDRIVER,
            "Unable to open driver's service key, status %!STATUS!", status);
        return;
    }
    //
    //  Key creation, unlike user mode, must happen one level at a time, since
    //  create will also open take both steps instead of trying open first
    //
    status = FxRegKey::_Create(hDriver.m_Key,
                               &parametersPart,
                               &hParameters.m_Key,
                               KEY_WRITE | KEY_READ
                               );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(this, TRACE_LEVEL_VERBOSE, TRACINGDRIVER,
            "Unable to write Parameters key, status %!STATUS!", status);
        return;
    }
 
    status = FxRegKey::_Create(hParameters.m_Key,
                               &wdfPart,
                               &hWdf.m_Key,
                               KEY_WRITE | KEY_READ
                               );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(this, TRACE_LEVEL_VERBOSE, TRACINGDRIVER,
            "Unable to write Parameters key, status %!STATUS!", status);
        return;
    }
 
    //
    //  Using ZwSetValueKey here to avoid having to change the implementation
    //  in FxRegKey of SetValue to a static / thiscall pair
    //
    status = ZwSetValueKey(hWdf.m_Key,
                           &wdfMajorValue,
                           0,
                           REG_DWORD,
                           &WdfBindInfo->Version.Major,
                           sizeof(WdfBindInfo->Version.Major)
                           );
 
    if  (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(this, TRACE_LEVEL_VERBOSE, TRACINGDRIVER,
            "Failed to record driver major version value, status %!STATUS!", status);
    }
 
    status = ZwSetValueKey(hWdf.m_Key,
                           &wdfMinorValue,
                           0,
                           REG_DWORD,
                           &WdfBindInfo->Version.Minor,
                           sizeof(WdfBindInfo->Version.Minor)
                           );
 
    if  (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(this, TRACE_LEVEL_VERBOSE, TRACINGDRIVER,
            "Failed to record driver version value, status %!STATUS!", status);
    }
}

◆ Release()

ULONG __inline _FX_DRIVER_GLOBALS::Release	(	__in_opt PVOID	Tag = `NULL`,
		__in LONG	Line = `0`,
		__in_opt PSTR	File = `NULL`
	)

inline

Definition at line 193 of file fxglobals.h.

    {
        ULONG c;
 
        UNREFERENCED_PARAMETER(Tag);
        UNREFERENCED_PARAMETER(Line);
        UNREFERENCED_PARAMETER(File);
 
        c = InterlockedDecrement(&Refcnt);
        ASSERT((LONG)c >= 0);
        if (c == 0) {
            DestroyEvent.Set();
        }
 
        return c;
    }

◆ SetVerifierState()

VOID _FX_DRIVER_GLOBALS::SetVerifierState ( __in BOOLEAN State )

inline

Definition at line 236 of file fxglobals.h.

    {
        //
        // Master switch
        //
        FxVerifierOn                = State;
 
        FxVerifierHandle            = State;
        FxVerifierIO                = State;
        FxVerifierLock              = State;
        FxPoolTrackingOn            = State;
 
        //
        // Following two can be overridden by the registry settings
        // WDFVERIFY matches the state of the verifier.
        //
        FxVerifyOn                  = State;
        FxVerifierDbgBreakOnError   = State;
        FxVerifierDbgBreakOnDeviceStateError = FALSE;
 
        //
        // Set the public flags for consumption by client drivers.
        //
        if (State) {
            Public.DriverFlags |= (WdfVerifyOn | WdfVerifierOn);
        }
    }

Referenced by FxAllocateDriverGlobals().

◆ WaitForSignal()

VOID FX_DRIVER_GLOBALS::WaitForSignal	(	__in MxEvent *	Event,
		__in PCSTR	ReasonForWaiting,
		__in PVOID	Handle,
		__in ULONG	WarningTimeoutInSec,
		__in ULONG	WaitSignalFlags
	)

Definition at line 1705 of file globals.cpp.

{
    LARGE_INTEGER timeOut;
    NTSTATUS status;
 
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    timeOut.QuadPart = WDF_REL_TIMEOUT_IN_SEC(((ULONGLONG)WarningTimeoutInSec));
 
    do {
        status = Event->WaitFor(Executive,
                        KernelMode,
                        FALSE, // Non alertable
                        timeOut.QuadPart ? &timeOut : NULL);
 
        if(status == STATUS_TIMEOUT) {
            DbgPrint("Thread 0x%p is %s 0x%p\n",
              Mx::MxGetCurrentThread(),
                      ReasonForWaiting,
                      Handle);
 
            if ((WaitSignalFlags & WaitSignalAlwaysBreak) ||
                ((WaitSignalFlags & WaitSignalBreakUnderVerifier) &&
                 FxVerifierDbgBreakOnError) ||
                ((WaitSignalFlags & WaitSignalBreakUnderDebugger) &&
                 IsDebuggerAttached())) {
 
                DbgBreakPoint();
            }
        } else {
            ASSERT(NT_SUCCESS(status));
            break;
        }
    } WHILE(TRUE);
}