fxglobals.h File Reference

#include "wdfglobals.h"
#include <debug.h>

Include dependency graph for fxglobals.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FxObjectDebugInfo
struct	FxDriverGlobalsDebugExtension
struct	_FX_TELEMETRY_CONTEXT
struct	_FX_DRIVER_GLOBALS
struct	FxLibraryGlobalsType
struct	_FX_OBJECT_INFO

Macros
#define	ROSWDFNOTIMPLEMENTED   (DbgPrint("(%s:%d) ReactOS KMDF: %s not implemented\n", __RELFILE__, __LINE__, __FUNCTION__))
#define	FX_INTERNAL_OBJECT_INFO_ENTRY(_obj, _type)   { #_obj, NULL, sizeof(_obj), _type, }
#define	FX_EXTERNAL_OBJECT_INFO_ENTRY(_obj, _type, _handletype)

Typedefs
typedef enum FxTrackPowerOption	FxTrackPowerOption
typedef enum FxVerifierDownlevelOption	FxVerifierDownLevelOption
typedef enum WaitSignalFlags	WaitSignalFlags
typedef struct _FX_TELEMETRY_CONTEXT	FX_TELEMETRY_CONTEXT
typedef struct _FX_TELEMETRY_CONTEXT *	PFX_TELEMETRY_CONTEXT
typedef struct _FX_DRIVER_GLOBALS	FX_DRIVER_GLOBALS
typedef struct _FX_DRIVER_GLOBALS *	PFX_DRIVER_GLOBALS
typedef struct _WDF_DRIVER_CONFIG *	PWDF_DRIVER_CONFIG
typedef NTSTATUS(*	PFN_WMI_QUERY_TRACE_INFORMATION) (__in TRACE_INFORMATION_CLASS TraceInformationClass, __out PVOID TraceInformation, __in ULONG TraceInformationLength, __out_opt PULONG RequiredLength, __in_opt PVOID Buffer)
typedef NTSTATUS(*	PFN_WMI_TRACE_MESSAGE_VA) (__in TRACEHANDLE LoggerHandle, __in ULONG MessageFlags, __in LPGUID MessageGuid, __in USHORT MessageNumber, __in va_list MessageArgList)
typedef struct _FX_OBJECT_INFO	FX_OBJECT_INFO
typedef struct _FX_OBJECT_INFO *	PFX_OBJECT_INFO

Enumerations
enum	FxObjectDebugInfoFlags { FxObjectDebugTrackReferences = 0x0001 }
enum	FxTrackPowerOption : UCHAR { FxTrackPowerNone = 0, FxTrackPowerRefs, FxTrackPowerRefsAndStack, FxTrackPowerMaxValue }
enum	FxVerifierDownlevelOption { NotOkForDownLevel = 0, OkForDownLevel = 1 }
enum	WaitSignalFlags { WaitSignalBreakUnderVerifier = 0x01, WaitSignalBreakUnderDebugger = 0x02, WaitSignalAlwaysBreak = 0x04 }
enum	FxMachineSleepStates { FxMachineS1Index = 0, FxMachineS2Index, FxMachineS3Index, FxMachineSleepStatesMax }

Functions
	__bcount (Size) PVOID FORCEINLINE FxPoolAllocate(__in PFX_DRIVER_GLOBALS Globals
__inline PFX_DRIVER_GLOBALS	GetFxDriverGlobals (__in PWDF_DRIVER_GLOBALS DriverGlobals)
VOID	LockVerifierSection (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_ PCUNICODE_STRING RegistryPath)
VOID	UnlockVerifierSection (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals)
BOOLEAN	IsWindowsVerifierOn (_In_ MdDriverObject DriverObject)
_Must_inspect_result_ NTSTATUS	FxInitialize (__inout PFX_DRIVER_GLOBALS FxDriverGlobals, __in MdDriverObject DriverObject, __in PCUNICODE_STRING RegistryPath, __in_opt PWDF_DRIVER_CONFIG DriverConfig)
VOID	FxDestroy (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
_Must_inspect_result_ NTSTATUS	FxLibraryGlobalsCommission (VOID)
VOID	FxLibraryGlobalsDecommission (VOID)
VOID	FxCheckAssumptions (VOID)
void	FxVerifierLockInitialize (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
void	FxVerifierLockDestroy (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
_Must_inspect_result_ BOOLEAN	FxVerifierGetTrackReferences (__in FxObjectDebugInfo *DebugInfo, __in WDFTYPE ObjectType)
PCSTR	FxObjectTypeToHandleName (__in WDFTYPE ObjectType)
_Must_inspect_result_ BOOLEAN	FxVerifyObjectTypeInTable (__in USHORT ObjectType)
VOID	FxFlushQueuedDpcs (VOID)
VOID	FxFreeAllocatedMdlsDebugInfo (__in FxDriverGlobalsDebugExtension *DebugExtension)
_Must_inspect_result_ __inline BOOLEAN	FxIsClassExtension (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_DRIVER_GLOBALS ExtDriverGlobals)
_Must_inspect_result_ BOOLEAN __inline	FxIsEqualGuid (__in CONST GUID *Lhs, __in CONST GUID *Rhs)
__inline size_t	FxSizeTMax (__in size_t A, __in size_t B)
__inline size_t	FxSizeTMin (__in size_t A, __in size_t B)
__inline LONG	FxInterlockedIncrementFloor (__inout LONG volatile *Target, __in LONG Floor)
__inline LONG	FxInterlockedIncrementGTZero (__inout LONG volatile *Target)
__inline ULONG	FxRandom (__inout PULONG RandomSeed)
_Must_inspect_result_ __inline BOOLEAN	FxIsPassiveLevelInterruptSupported (VOID)
__inline _Must_inspect_result_ BOOLEAN	IsOsVersionGreaterThanOrEqualTo (__in ULONG Major, __in ULONG Minor)

Variables
__in POOL_TYPE	Type
__in POOL_TYPE __in size_t	Size
__in POOL_TYPE __in size_t __in ULONG	Tag
FxLibraryGlobalsType	FxLibraryGlobals

Macro Definition Documentation

FX_EXTERNAL_OBJECT_INFO_ENTRY

#define FX_EXTERNAL_OBJECT_INFO_ENTRY	(		_obj,
			_type,
			_handletype
	)

Value:

{ #_obj,                                                    \
      (const CHAR*) (_handletype) #_handletype,                 \
      sizeof(_obj),                                             \
      _type,                                                    \
    }

Definition at line 923 of file fxglobals.h.

FX_INTERNAL_OBJECT_INFO_ENTRY

#define FX_INTERNAL_OBJECT_INFO_ENTRY	(		_obj,
			_type
	)		{ #_obj, NULL, sizeof(_obj), _type, }

Definition at line 906 of file fxglobals.h.

ROSWDFNOTIMPLEMENTED

#define ROSWDFNOTIMPLEMENTED   (DbgPrint("(%s:%d) ReactOS KMDF: %s not implemented\n", __RELFILE__, __LINE__, __FUNCTION__))

Definition at line 52 of file fxglobals.h.

Typedef Documentation

FX_DRIVER_GLOBALS

typedef struct _FX_DRIVER_GLOBALS FX_DRIVER_GLOBALS

FX_OBJECT_INFO

typedef struct _FX_OBJECT_INFO FX_OBJECT_INFO

FX_TELEMETRY_CONTEXT

typedef struct _FX_TELEMETRY_CONTEXT FX_TELEMETRY_CONTEXT

FxTrackPowerOption

typedef enum FxTrackPowerOption FxTrackPowerOption

FxVerifierDownLevelOption

typedef enum FxVerifierDownlevelOption FxVerifierDownLevelOption

PFN_WMI_QUERY_TRACE_INFORMATION

typedef NTSTATUS(* PFN_WMI_QUERY_TRACE_INFORMATION) (__in TRACE_INFORMATION_CLASS TraceInformationClass, __out PVOID TraceInformation, __in ULONG TraceInformationLength, __out_opt PULONG RequiredLength, __in_opt PVOID Buffer)

Definition at line 678 of file fxglobals.h.

PFN_WMI_TRACE_MESSAGE_VA

typedef NTSTATUS(* PFN_WMI_TRACE_MESSAGE_VA) (__in TRACEHANDLE LoggerHandle, __in ULONG MessageFlags, __in LPGUID MessageGuid, __in USHORT MessageNumber, __in va_list MessageArgList)

Definition at line 688 of file fxglobals.h.

PFX_DRIVER_GLOBALS

typedef struct _FX_DRIVER_GLOBALS * PFX_DRIVER_GLOBALS

PFX_OBJECT_INFO

typedef struct _FX_OBJECT_INFO * PFX_OBJECT_INFO

PFX_TELEMETRY_CONTEXT

typedef struct _FX_TELEMETRY_CONTEXT * PFX_TELEMETRY_CONTEXT

PWDF_DRIVER_CONFIG

typedef struct _WDF_DRIVER_CONFIG* PWDF_DRIVER_CONFIG

Definition at line 604 of file fxglobals.h.

WaitSignalFlags

typedef enum WaitSignalFlags WaitSignalFlags

Enumeration Type Documentation

FxMachineSleepStates

enum FxMachineSleepStates

Enumerator
FxMachineS1Index
FxMachineS2Index
FxMachineS3Index
FxMachineSleepStatesMax

Definition at line 696 of file fxglobals.h.

                          {
    FxMachineS1Index = 0,
    FxMachineS2Index,
    FxMachineS3Index,
    FxMachineSleepStatesMax,
};

FxObjectDebugInfoFlags

enum FxObjectDebugInfoFlags

Enumerator
FxObjectDebugTrackReferences

Definition at line 67 of file fxglobals.h.

                            {
    FxObjectDebugTrackReferences = 0x0001,
};

FxTrackPowerOption

enum FxTrackPowerOption : UCHAR

Enumerator
FxTrackPowerNone
FxTrackPowerRefs
FxTrackPowerRefsAndStack
FxTrackPowerMaxValue

Definition at line 71 of file fxglobals.h.

                                : UCHAR {
    FxTrackPowerNone = 0,
    FxTrackPowerRefs,
    FxTrackPowerRefsAndStack,
    FxTrackPowerMaxValue
} FxTrackPowerOption;

FxVerifierDownlevelOption

enum FxVerifierDownlevelOption

Enumerator
NotOkForDownLevel
OkForDownLevel

Definition at line 78 of file fxglobals.h.

                                       {
    NotOkForDownLevel = 0,
    OkForDownLevel = 1,
} FxVerifierDownLevelOption;

WaitSignalFlags

enum WaitSignalFlags

Enumerator
WaitSignalBreakUnderVerifier
WaitSignalBreakUnderDebugger
WaitSignalAlwaysBreak

Definition at line 83 of file fxglobals.h.

                             {
    WaitSignalBreakUnderVerifier      = 0x01,
    WaitSignalBreakUnderDebugger      = 0x02,
    WaitSignalAlwaysBreak             = 0x04
} WaitSignalFlags;

Function Documentation

__bcount()

__bcount

(

Size

)

FxCheckAssumptions()

VOID FxCheckAssumptions

(

VOID

)

FxDestroy()

VOID FxDestroy

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 981 of file globals.cpp.

{
    //
    // Release the last reference.
    //
    FxDriverGlobals->RELEASE((PVOID)FxDestroy);

    //
    // Wait for everyone else to be done.
    //
    Mx::MxEnterCriticalRegion();
    FxDriverGlobals->DestroyEvent.WaitFor(Executive, KernelMode, FALSE, NULL);
    Mx::MxLeaveCriticalRegion();

    //
    // Lock verifier package
    //
    FxVerifierLockDestroy(FxDriverGlobals);

    //
    // Cleanup frameworks structures
    //
    FxPoolPackageDestroy(FxDriverGlobals);

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    //
    // Deregister from the bugcheck callbacks.
    //
    FxUnregisterBugCheckCallback(FxDriverGlobals);

    //
    // Purge driver info from bugcheck data.
    //
    FxPurgeBugCheckDriverInfo(FxDriverGlobals);
#endif

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    //
    // unlock verifier image sections
    //
    if(FxDriverGlobals->FxVerifierOn){
        UnlockVerifierSection(FxDriverGlobals);
    }
#endif

    return;
}

Referenced by FxLibraryCommonUnregisterClient().

FxFlushQueuedDpcs()

VOID FxFlushQueuedDpcs

(

VOID

)

FxFreeAllocatedMdlsDebugInfo()

VOID FxFreeAllocatedMdlsDebugInfo

(

__in FxDriverGlobalsDebugExtension *

DebugExtension

)

Definition at line 20 of file globalskm.cpp.

{
    FxAllocatedMdls* pNext, *pCur;

    pNext = DebugExtension->AllocatedMdls.Next;

    //
    // MDL leaks were already checked for in FxPoolDestroy, just free all
    // the tables here.
    //
    while (pNext != NULL) {
        pCur = pNext;
        pNext = pCur->Next;

        ExFreePool(pCur);
    }
}

Referenced by FxFreeDriverGlobals().

FxInitialize()

_Must_inspect_result_ NTSTATUS FxInitialize	(	__inout PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in MdDriverObject	DriverObject,
		__in PCUNICODE_STRING	RegistryPath,
		__in_opt PWDF_DRIVER_CONFIG	DriverConfig
	)

Definition at line 848 of file globals.cpp.

{
    NTSTATUS status;
    BOOLEAN windowsVerifierOn = FALSE;

    UNREFERENCED_PARAMETER(DriverConfig);

    //
    // Check if windows driver verifier is on for this driver
    // We need this when initializing wdf verifier
    //
    windowsVerifierOn = IsWindowsVerifierOn(DriverObject);

    //
    // Get registry values first since these effect the
    // rest of initialization
    //
    FxRegistrySettingsInitialize(FxDriverGlobals,
                                 RegistryPath,
                                 windowsVerifierOn);

    //
    // Initialize IFR logging
    //
    // FxIFRStart(FxDriverGlobals, RegistryPath, DriverObject); __REACTOS__

    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDRIVER,
                        "Initialize globals for %!wZ!", RegistryPath);

    //
    // Only first one initializes the frameworks globals
    //
    status = FxPoolPackageInitialize(FxDriverGlobals);
    if (!NT_SUCCESS(status)) {
        //
        // FxPoolPackageInitialize logs a message in case of failure so
        // we don't need to log failure here.
        //
        // FxIFRStop(FxDriverGlobals); __REACTOS__
        return status;
    }

    //
    // Lock verifier package
    //
    FxVerifierLockInitialize(FxDriverGlobals);

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    //
    // Cache driver info for bugcheck callback.
    //
    FxCacheBugCheckDriverInfo(FxDriverGlobals);

    //
    // Register for bugcheck callbacks.
    //
    FxRegisterBugCheckCallback(FxDriverGlobals, DriverObject);
#endif

    if  (NULL != RegistryPath) {
        if  (FALSE == FxDriverGlobals->IsCorrectVersionRegistered(RegistryPath))
            FxDriverGlobals->RegisterClientVersion(RegistryPath);
    }

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    if(FxDriverGlobals->FxVerifierOn){
        LockVerifierSection(FxDriverGlobals, RegistryPath);
    }
#endif

    return STATUS_SUCCESS;
}

FxInterlockedIncrementFloor()

__inline LONG FxInterlockedIncrementFloor	(	__inout LONG volatile *	Target,
		__in LONG	Floor
	)

Definition at line 1007 of file fxglobals.h.

{
    LONG startVal;
    LONG currentVal;

    currentVal = *Target;

    do {
        if (currentVal <= Floor) {
            return currentVal;
        }

        startVal = currentVal;

        //
        // currentVal will be the value that used to be Target if the exchange was made
        // or its current value if the exchange was not made.
        //
        currentVal = InterlockedCompareExchange(Target, startVal+1, startVal);

        //
        // If startVal == currentVal, then no one updated Target in between the deref at the top
        // and the InterlockedCompareExchange afterward.
        //
    } while (startVal != currentVal);

    //
    // startVal is the old value of Target. Since InterlockedIncrement returns the new
    // incremented value of Target, we should do the same here.
    //
    return startVal+1;
}

Referenced by FxInterlockedIncrementGTZero().

FxInterlockedIncrementGTZero()

__inline LONG FxInterlockedIncrementGTZero

(

__inout LONG volatile *

Target

)

Definition at line 1045 of file fxglobals.h.

{
    return FxInterlockedIncrementFloor(Target, 0);
}

Referenced by FxRequestBase::Cancel(), and FxIoTarget::TimerCallback().

FxIsClassExtension()

_Must_inspect_result_ __inline BOOLEAN FxIsClassExtension	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PFX_DRIVER_GLOBALS	ExtDriverGlobals
	)

Definition at line 965 of file fxglobals.h.

{
    return (FxDriverGlobals == ExtDriverGlobals) ? FALSE : TRUE;
}

Referenced by FxValiateCx().

FxIsEqualGuid()

_Must_inspect_result_ BOOLEAN __inline FxIsEqualGuid	(	__in CONST GUID *	Lhs,
		__in CONST GUID *	Rhs
	)

Definition at line 977 of file fxglobals.h.

{
    return RtlCompareMemory(Lhs, Rhs, sizeof(GUID)) == sizeof(GUID);
}

Referenced by FxWmiIrpHandler::AddPowerPolicyProviderAndInstance(), for(), FxVerifyLogHeader(), FxPkgPnp::HandleQueryInterface(), if(), and FxDevice::IsInterfaceRegistered().

FxIsPassiveLevelInterruptSupported()

_Must_inspect_result_ __inline BOOLEAN FxIsPassiveLevelInterruptSupported

(

VOID

)

Definition at line 1081 of file fxglobals.h.

{
    //
    // Passive-level interrupt handling is supported in Win 8 and forward.
    //
    return FxLibraryGlobals.PassiveLevelInterruptSupport;
}

Referenced by FxInterrupt::AssignResources().

FxLibraryGlobalsCommission()

_Must_inspect_result_ NTSTATUS FxLibraryGlobalsCommission

(

VOID

)

Definition at line 494 of file globals.cpp.

{
    PFN_RTL_GET_VERSION pRtlGetVersion;
    NTSTATUS status;

    //
    // Global initialization for mode-agnostic primitives library
    //
    Mx::MxGlobalInit();















#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    FxLibraryGlobals.IsUserModeFramework = FALSE;
#else
    FxLibraryGlobals.IsUserModeFramework = TRUE;
#endif

    //
    // IFR is enabled by default
    //
    FxLibraryGlobals.IfrDisabled = FALSE;

    //
    // Query global WDF settings (both KMDF and UMDF).
    //
    FxLibraryGlobalsQueryRegistrySettings();

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    UNICODE_STRING funcName;

    // For DSF support.
    RtlInitUnicodeString(&funcName, L"IoConnectInterruptEx");
    FxLibraryGlobals.IoConnectInterruptEx = (PFN_IO_CONNECT_INTERRUPT_EX)
        MmGetSystemRoutineAddress(&funcName);

    RtlInitUnicodeString(&funcName, L"IoDisconnectInterruptEx");
    FxLibraryGlobals.IoDisconnectInterruptEx = (PFN_IO_DISCONNECT_INTERRUPT_EX)
        MmGetSystemRoutineAddress(&funcName);

    // 32 bit: W2k and forward.
    // 64 bit: W2k -> Windows Server 2008 (obsolete otherwise).
    RtlInitUnicodeString(&funcName, L"KeQueryActiveProcessors");
    FxLibraryGlobals.KeQueryActiveProcessors = (PFN_KE_QUERY_ACTIVE_PROCESSORS)
        MmGetSystemRoutineAddress(&funcName);

    RtlInitUnicodeString(&funcName, L"KeSetTargetProcessorDpc");
    FxLibraryGlobals.KeSetTargetProcessorDpc = (PFN_KE_SET_TARGET_PROCESSOR_DPC)
        MmGetSystemRoutineAddress(&funcName);

    // These should always be there (obsolete in 64 bit Win 7 and forward).
    ASSERT(FxLibraryGlobals.KeQueryActiveProcessors != NULL &&
           FxLibraryGlobals.KeSetTargetProcessorDpc != NULL);

    // Win 7 and forward.
    RtlInitUnicodeString(&funcName, L"KeQueryActiveGroupCount");
    if (MmGetSystemRoutineAddress(&funcName) != NULL) {
        FxLibraryGlobals.ProcessorGroupSupport = TRUE;
    }

    // Win 7 and forward.
    RtlInitUnicodeString(&funcName, L"KeSetCoalescableTimer");
    FxLibraryGlobals.KeSetCoalescableTimer = (PFN_KE_SET_COALESCABLE_TIMER)
        MmGetSystemRoutineAddress(&funcName);

    // Win 7 and forward.
    RtlInitUnicodeString(&funcName, L"IoUnregisterPlugPlayNotificationEx");
    FxLibraryGlobals.IoUnregisterPlugPlayNotificationEx = (PFN_IO_UNREGISTER_PLUGPLAY_NOTIFICATION_EX)
        MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxRegisterDevice");
    FxLibraryGlobals.PoxRegisterDevice =
      (PFN_POX_REGISTER_DEVICE) MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxStartDevicePowerManagement");
    FxLibraryGlobals.PoxStartDevicePowerManagement =
                                    (PFN_POX_START_DEVICE_POWER_MANAGEMENT)
                                        MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxUnregisterDevice");
    FxLibraryGlobals.PoxUnregisterDevice =
                                (PFN_POX_UNREGISTER_DEVICE)
                                    MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxActivateComponent");
    FxLibraryGlobals.PoxActivateComponent = (PFN_POX_ACTIVATE_COMPONENT)
                                          MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxIdleComponent");
    FxLibraryGlobals.PoxIdleComponent = (PFN_POX_IDLE_COMPONENT)
                                          MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxReportDevicePoweredOn");
    FxLibraryGlobals.PoxReportDevicePoweredOn =
      (PFN_POX_REPORT_DEVICE_POWERED_ON) MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxCompleteIdleState");
    FxLibraryGlobals.PoxCompleteIdleState =
      (PFN_POX_COMPLETE_IDLE_STATE) MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxCompleteIdleCondition");
    FxLibraryGlobals.PoxCompleteIdleCondition =
      (PFN_POX_COMPLETE_IDLE_CONDITION) MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxCompleteDevicePowerNotRequired");
    FxLibraryGlobals.PoxCompleteDevicePowerNotRequired =
      (PFN_POX_COMPLETE_DEVICE_POWER_NOT_REQUIRED) MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"PoFxSetDeviceIdleTimeout");
    FxLibraryGlobals.PoxSetDeviceIdleTimeout =
      (PFN_POX_SET_DEVICE_IDLE_TIMEOUT) MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"IoReportInterruptActive");
    FxLibraryGlobals.IoReportInterruptActive =
      (PFN_IO_REPORT_INTERRUPT_ACTIVE) MmGetSystemRoutineAddress(&funcName);

    // Win 8 and forward
    RtlInitUnicodeString(&funcName, L"IoReportInterruptInactive");
    FxLibraryGlobals.IoReportInterruptInactive =
      (PFN_IO_REPORT_INTERRUPT_INACTIVE) MmGetSystemRoutineAddress(&funcName);

    // Win 8.2 and forward
    RtlInitUnicodeString(&funcName, L"VfCheckNxPoolType");
    FxLibraryGlobals.VfCheckNxPoolType =
      (PFN_VF_CHECK_NX_POOL_TYPE) MmGetSystemRoutineAddress(&funcName);

#endif //((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))

    FxLibraryGlobals.OsVersionInfo.dwOSVersionInfoSize = sizeof(FxLibraryGlobals.OsVersionInfo);

    // User/Kernel agnostic.

    pRtlGetVersion = (PFN_RTL_GET_VERSION)
                Mx::MxGetSystemRoutineAddress(MAKE_MX_FUNC_NAME("RtlGetVersion"));

    ASSERT(pRtlGetVersion != NULL);
    pRtlGetVersion((PRTL_OSVERSIONINFOW) &FxLibraryGlobals.OsVersionInfo);
    FxLibraryGlobalsVerifyVersion();

    //
    // Initialize power management-related stuff.
    //
    RtlZeroMemory(&FxLibraryGlobals.MachineSleepStates[0],
                  sizeof(FxLibraryGlobals.MachineSleepStates));

    //
    // Insure that the FxObject is layed-up correctly.
    //
    FxVerifyObjectTableIsSorted();

    //
    // Initialize the list of FxDriverGlobals.
    // This is essentially the list of drivers on this WDF version.
    //
    InitializeListHead(&FxLibraryGlobals.FxDriverGlobalsList);
    FxLibraryGlobals.FxDriverGlobalsListLock.Initialize();

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    //
    // Register for the global (library) bugcheck callbacks.
    //
    FxInitializeBugCheckDriverInfo();
#ifdef EVENT_TRACING // __REACTOS__
    //
    // Init driver usage tracker. This tracker is used by the debug dump
    // callback routines for finding the driver's dump log file to write
    // in the minidump. Ignore any tracker's errors.
    //
    (VOID)FxLibraryGlobals.DriverTracker.Initialize();

    //
    // Initialize enhanced-verifier section handle
    //
    FxLibraryGlobals.VerifierSectionHandle = NULL;
    FxLibraryGlobals.VerifierSectionHandleRefCount = 0;

    //
    // Retrieve a pointer to the data structure that cotains trace routines
    // corresponding to WdfNotifyRoutinesClass from the SystemTraceProvider
    // that we'll use for perf tracing of WDF operations. The trace
    // routines inside the structuyre are present only when tracing is enabled
    // by some trace client (e.g. tracelog or xperf)  for WDF specific perf
    // groups. Note that no unregistration is necessary.
    //
    status = WmiQueryTraceInformation(WdfNotifyRoutinesClass,
                                      &FxLibraryGlobals.PerfTraceRoutines,
                                      sizeof(PWMI_WDF_NOTIFY_ROUTINES),
                                      NULL,
                                      NULL);

    if (!NT_SUCCESS(status)) {
        //
        // WDF trace routines are available only on win8+, so failure is
        // expected on pre-Win8 OS. Use the dummy routines on failure.
        //
        RtlZeroMemory(&FxLibraryGlobals.DummyPerfTraceRoutines,
                      sizeof(WMI_WDF_NOTIFY_ROUTINES));
        FxLibraryGlobals.DummyPerfTraceRoutines.Size =
            sizeof(WMI_WDF_NOTIFY_ROUTINES);
        FxLibraryGlobals.PerfTraceRoutines =
            &FxLibraryGlobals.DummyPerfTraceRoutines;
        status = STATUS_SUCCESS;
    }

    //
    // The Size member of WMI_WDF_NOTIFY_ROUTINES allows versioning. When
    // the WMI_WDF_NOTIFY_ROUTINES structure is revised with additional
    // members in future OS versions, the Size member will allow validating
    // the various versions, and initializeing the structure correctly.
    //
    ASSERT(FxLibraryGlobals.PerfTraceRoutines->Size >=
        sizeof(WMI_WDF_NOTIFY_ROUTINES));
#else
    status = STATUS_SUCCESS; // __REACTOS__
#endif // EVENT_TRACING
#else
    status = STATUS_SUCCESS;
#endif

    return status;
}

Referenced by FxLibraryCommonCommission().

FxLibraryGlobalsDecommission()

VOID FxLibraryGlobalsDecommission

(

VOID

)

Definition at line 742 of file globals.cpp.

{
    //
    // Assure the all driver's FxDriverGlobals have been freed.
    //
    ASSERT(IsListEmpty(&FxLibraryGlobals.FxDriverGlobalsList));

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    //
    // Cleanup for the driver usage tracker.
    //
    FxLibraryGlobals.DriverTracker.Uninitialize();

    //
    // Deregister from the global (library) bugcheck callbacks.
    //
    FxUninitializeBugCheckDriverInfo();
#endif

    FxLibraryGlobals.FxDriverGlobalsListLock.Uninitialize();

    return;
}

Referenced by FxLibraryCommonDecommission().

FxObjectTypeToHandleName()

PCSTR FxObjectTypeToHandleName

(

__in WDFTYPE

ObjectType

)

Definition at line 316 of file globals.cpp.

{
    ULONG i;

    for (i = 0; i < FxObjectsInfoCount; i++) {
        if (ObjectType == FxObjectsInfo[i].ObjectType) {
            return FxObjectsInfo[i].HandleName;
        }
        else if (ObjectType > FxObjectsInfo[i].ObjectType) {
            continue;
        }

        return NULL;
    }

    return NULL;
}

Referenced by FxObject::~FxObject().

FxRandom()

__inline ULONG FxRandom

(

__inout PULONG

RandomSeed

)

Definition at line 1054 of file fxglobals.h.

{
    *RandomSeed = *RandomSeed * 1103515245 + 12345;
    return (ULONG)(*RandomSeed / 65536) % 32768;
}

Referenced by FxPkgIo::VerifierFreeRequestToTestForwardProgess().

FxSizeTMax()

__inline size_t FxSizeTMax	(	__in size_t	A,
		__in size_t	B
	)

Definition at line 987 of file fxglobals.h.

{
    return A > B ? A : B;
}

Referenced by FxDmaEnabler::ConfigureBusMasterAdapters().

FxSizeTMin()

__inline size_t FxSizeTMin	(	__in size_t	A,
		__in size_t	B
	)

Definition at line 997 of file fxglobals.h.

{
    return A < B ? A : B;
}

Referenced by FxDmaEnabler::InitializeResources(), FxDmaScatterGatherTransaction::InitializeResources(), FxDmaScatterGatherTransaction::StageTransfer(), FxDmaPacketTransaction::StageTransfer(), and FxDmaPacketTransaction::StartTransfer().

FxVerifierGetTrackReferences()

_Must_inspect_result_ BOOLEAN FxVerifierGetTrackReferences	(	__in FxObjectDebugInfo *	DebugInfo,
		__in WDFTYPE	ObjectType
	)

Definition at line 338 of file globals.cpp.

{
    ULONG i;

    //
    // Array size of DebugInfo is the same size as FxObjectsInfo
    //
    for (i = 0; i < FxObjectsInfoCount; i++) {
        if (ObjectType == DebugInfo[i].ObjectType) {
            return FLAG_TO_BOOL(DebugInfo[i].u.DebugFlags,
                                FxObjectDebugTrackReferences);
        }
        else if (ObjectType > FxObjectsInfo[i].ObjectType) {
            continue;
        }

        return FALSE;
    }

    return FALSE;
}

Referenced by FxObject::AllocateTagTracker().

FxVerifierLockDestroy()

void FxVerifierLockDestroy

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 137 of file fxverifierlock.cpp.

{
    if( FxDriverGlobals->FxVerifierLock ) {
        FxVerifierLock::FreeThreadTable(FxDriverGlobals);

        FxDriverGlobals->ThreadTableLock.Uninitialize();
    }

    return;
}

Referenced by FxDestroy().

FxVerifierLockInitialize()

void FxVerifierLockInitialize

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 118 of file fxverifierlock.cpp.

{
    if( FxDriverGlobals->FxVerifierLock ) {

        FxDriverGlobals->ThreadTableLock.Initialize();

        FxVerifierLock::AllocateThreadTable(FxDriverGlobals);
    }

    return;
}

Referenced by FxInitialize().

FxVerifyObjectTypeInTable()

_Must_inspect_result_ BOOLEAN FxVerifyObjectTypeInTable

(

__in USHORT

ObjectType

)

Definition at line 117 of file globals.cpp.

{
    ULONG i;

    for (i = 0; i < FxObjectsInfoCount; i++) {
        if (ObjectType == FxObjectsInfo[i].ObjectType) {
            return TRUE;
        }
        else if (ObjectType > FxObjectsInfo[i].ObjectType) {
            continue;
        }

        return FALSE;
    }

    return FALSE;
}

GetFxDriverGlobals()

__inline PFX_DRIVER_GLOBALS GetFxDriverGlobals

(

__in PWDF_DRIVER_GLOBALS

DriverGlobals

)

Definition at line 597 of file fxglobals.h.

{
    return CONTAINING_RECORD( DriverGlobals, FX_DRIVER_GLOBALS, Public );
}

Referenced by __deref_opt_out_bcount(), __deref_out_range(), __drv_strictTypeMatch(), __drv_when(), __in_bcount_opt(), __in_ecount(), __in_xcount(), __out_bcount(), _Requires_lock_held_(), _Requires_lock_not_held_(), AddEventHooksWdfDeviceCreate(), AddEventHooksWdfIoQueueCreate(), FxFreeDriverGlobals(), FxLibraryCommonRegisterClient(), FxLibraryCommonUnregisterClient(), GetIoMgrObjectForWorkItemAllocation(), if(), ResumeIdleWorker(), RosInitWdf(), StopIdleWorker(), switch(), VerifyCriticalRegionExit(), VerifyIrqlExit(), VerifyWdfDeviceWdmDispatchIrp(), VfAllocateContext(), WDF_LIBRARY_REGISTER_CLIENT(), WdfCxVerifierKeBugCheck(), WdfDriverMiniportUnload(), WdfInterruptGetDevice(), WdfInterruptQueueDpcForIsr(), WdfInterruptQueueWorkItemForIsr(), WdfInterruptWdmGetInterrupt(), WdfVerifierDbgBreakPoint(), and WdfVerifierKeBugCheck().

IsOsVersionGreaterThanOrEqualTo()

__inline _Must_inspect_result_ BOOLEAN IsOsVersionGreaterThanOrEqualTo	(	__in ULONG	Major,
		__in ULONG	Minor
	)

Definition at line 1094 of file fxglobals.h.

{
    return ((FxLibraryGlobals.OsVersionInfo.dwMajorVersion > Major) ||
            ((FxLibraryGlobals.OsVersionInfo.dwMajorVersion == Major) &&
             (FxLibraryGlobals.OsVersionInfo.dwMinorVersion >= Minor)));
}

Referenced by FxDmaEnabler::Initialize().

IsWindowsVerifierOn()

BOOLEAN IsWindowsVerifierOn

(

_In_ MdDriverObject

DriverObject

)

Definition at line 953 of file globals.cpp.

{
    BOOLEAN windowsVerifierOn = FALSE;

#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    //
    // Check if windows driver verifier is on for this driver
    // We need this when initializing wdf verifier
    //
    windowsVerifierOn = MmIsDriverVerifying(DriverObject) ? TRUE: FALSE;

#else
    UNREFERENCED_PARAMETER(DriverObject);

    //
    // For user-mode we check if app verifier's verifier.dll is loaded in this
    // process (since app verifier doesn't provide any other way to detect its
    // presence).
    //
    windowsVerifierOn = (GetModuleHandleW(L"verifier.dll") == NULL ? FALSE : TRUE);
#endif

    return windowsVerifierOn;
}

Referenced by FxInitialize().

LockVerifierSection()

VOID LockVerifierSection	(	_In_ PFX_DRIVER_GLOBALS	FxDriverGlobals,
		_In_ PCUNICODE_STRING	RegistryPath
	)

Definition at line 783 of file globals.cpp.

{
    LONG count;

    //
    // This asserts  makes sure the struct is not pack(1) and the counter
    // is correctly aligned on a 32 bit boundary.
    //
    C_ASSERT((FIELD_OFFSET(FxLibraryGlobalsType, VerifierSectionHandleRefCount)
              % __alignof(LONG)) == 0);

    count = InterlockedIncrement(&FxLibraryGlobals.VerifierSectionHandleRefCount);
    ASSERT(count > 0);

    //
    // If verifier section is unlocked, lock it in.
    //
    if(FxLibraryGlobals.VerifierSectionHandle == NULL) {
        //
        //First time verifier section is being locked.
        //
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGDRIVER,
                            "First time Locking (%d) in Verifier Paged Memory "
                            "from  %!wZ! from driver globals %p",
                            count, RegistryPath, FxDriverGlobals);
        //
        // VerifierLockHandle is a function that we use to lock in all the code from it's section
        // since all the verifier code is in the same section as VerifierLockHandle.
        //
        FxLibraryGlobals.VerifierSectionHandle = MmLockPagableCodeSection((PVOID)VerifierPageLockHandle);
    }
    else {
        MmLockPagableSectionByHandle(FxLibraryGlobals.VerifierSectionHandle);
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGDRIVER,
                            "Increment Lock counter (%d) for Verifier Paged Memory "
                            "from  %!wZ! from driver globals %p",
                            count, RegistryPath, FxDriverGlobals);
    }
}

Referenced by FxInitialize(), and FxLibraryCommonRegisterClient().

UnlockVerifierSection()

VOID UnlockVerifierSection

(

_In_ PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 827 of file globals.cpp.

{
    if( FxLibraryGlobals.VerifierSectionHandle != NULL) {
        LONG count;

        count = InterlockedDecrement(&FxLibraryGlobals.VerifierSectionHandleRefCount);
        ASSERT(count >= 0);

        MmUnlockPagableImageSection(FxLibraryGlobals.VerifierSectionHandle);
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGDRIVER,
                            "Decrement UnLock counter (%d) for Verifier Paged Memory "
                            "with driver globals %p",
                            count, FxDriverGlobals);
    }
}

Referenced by FxDestroy(), and FxLibraryCommonUnregisterClient().

Variable Documentation

FxLibraryGlobals

FxLibraryGlobalsType FxLibraryGlobals

Definition at line 95 of file globals.cpp.

Referenced by FxAllocateDriverGlobals(), FxFreeDriverGlobals(), FxIsPassiveLevelInterruptSupported(), FxLibraryGlobalsCommission(), FxLibraryGlobalsDecommission(), FxLibraryGlobalsQueryRegistrySettings(), FxLibraryGlobalsVerifyVersion(), IsOsVersionGreaterThanOrEqualTo(), LockVerifierSection(), and UnlockVerifierSection().

Size

__in POOL_TYPE __in size_t Size

Initial value:

{
    
    
    
    
    return FxPoolAllocator(
        Globals,
        &Globals->FxPoolFrameworks,
        Type,
        Size,
        Globals->Tag,
        _ReturnAddress()
        )

Definition at line 557 of file fxglobals.h.

Tag

__in POOL_TYPE __in size_t __in ULONG Tag

Initial value:

{
    return FxPoolAllocator(
        Globals,
        &Globals->FxPoolFrameworks,
        Type,
        Size,
        Tag,
        Globals->FxPoolTrackingOn ? _ReturnAddress() : NULL
        )

Definition at line 581 of file fxglobals.h.

Type

__in POOL_TYPE Type

Definition at line 554 of file fxglobals.h.