fxglobals.h

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxGlobals.h
 
Abstract:
 
    This module contains globals definitions for the frameworks.
 
Author:
 
 
 
 
Environment:
 
    Both kernel and user mode
 
Revision History:
 
        Made it mode agnostic
        Moved km specific portions to FxGlobalsKm.h
 
 
 
 
 
 
 
 
 
        New failure paths:
            AllocatedTagTrackersLock initialization -
                If this fails we free debug extensions structure and not use it
            ThreadTableLock initialization -
                If this fails we turn off lock verification
            FxDriverGlobalsListLock initialization -
                If this fails we fail FxLibraryGlobalsCommission
 
--*/
 
#ifndef _FXGLOBALS_H
#define _FXGLOBALS_H
 
#include "wdfglobals.h"
#include <debug.h>
 
// REACTOS
#define ROSWDFNOTIMPLEMENTED (DbgPrint("(%s:%d) ReactOS KMDF: %s not implemented\n", __RELFILE__, __LINE__, __FUNCTION__))
// REACTOS
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct FxLibraryGlobalsType;
 
class CWudfDriverGlobals; //UMDF driver globals
 
//
// NOTE: any time you add a value to this enum, you must add a field to the
// union in FxObjectDebugInfo.
//
enum FxObjectDebugInfoFlags {
    FxObjectDebugTrackReferences = 0x0001,
};
 
typedef enum FxTrackPowerOption : UCHAR {
    FxTrackPowerNone = 0,
    FxTrackPowerRefs,
    FxTrackPowerRefsAndStack,
    FxTrackPowerMaxValue
} FxTrackPowerOption;
 
typedef enum FxVerifierDownlevelOption {
    NotOkForDownLevel = 0,
    OkForDownLevel = 1,
} FxVerifierDownLevelOption;
 
typedef enum WaitSignalFlags {
    WaitSignalBreakUnderVerifier      = 0x01,
    WaitSignalBreakUnderDebugger      = 0x02,
    WaitSignalAlwaysBreak             = 0x04
} WaitSignalFlags;
 
 
struct FxObjectDebugInfo {
    //
    // FX_OBJECT_TYPES enum value
    //
    USHORT ObjectType;
 
    union {
        //
        // Combo of values from FxObjectDebugInfoFlags
        //
        USHORT DebugFlags;
 
        //
        // Break out of DebugFlags as individual fields.  This is used by the
        // debugger extension to reference the values w/out knowing the actual
        // enum values.
        //
        struct {
            USHORT TrackReferences : 1;
        } Bits;
    } u;
};
 
struct FxDriverGlobalsDebugExtension {
    //
    // Debug information per object.  List is sorted by
    // FxObjectDebugInfo::ObjectType, length is the same as FxObjectsInfo.
    //
    FxObjectDebugInfo* ObjectDebugInfo;
 
    //
    // Track allocated Mdls only in kernel mode version
    //
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    FxAllocatedMdls AllocatedMdls;
 
    KSPIN_LOCK AllocatedMdlsLock;
#endif
 
    //
    // List of all allocated tag trackers for this driver.  This is used to keep
    // track of orphaned objects due to leaked reference counts in the debugger
    // extension.
    //
    LIST_ENTRY AllocatedTagTrackersListHead;
 
    //
    // Synchronizes access to AllocatedTagTrackersListHead
    //
    MxLock AllocatedTagTrackersLock;
 
    //
    // Whether we track power references for WDFDEVICE objects
    // and optionally capture stack frames.
    //
    FxTrackPowerOption TrackPower;
};
 
//
// A telemetry context that is allocated if the telemetry provider is enabled.
//
typedef struct _FX_TELEMETRY_CONTEXT{
    //
    // A GUID representing the driver session
    //
    GUID DriverSessionGUID;
 
    //
    // A general purpose bitmap that can be used
    // by various telemetry events that may want to
    // fire once per driver session.
    //
    volatile LONG DoOnceFlagsBitmap;
}  FX_TELEMETRY_CONTEXT, *PFX_TELEMETRY_CONTEXT;
 
typedef struct _FX_DRIVER_GLOBALS {
public:
    ULONG
    __inline
    AddRef(
        __in_opt   PVOID Tag = NULL,
        __in       LONG Line = 0,
        __in_opt   PSTR File = NULL
        )
    {
        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;
    }
 
    ULONG
    __inline
    Release(
        __in_opt    PVOID Tag = NULL,
        __in        LONG Line = 0,
        __in_opt    PSTR File = NULL
        )
    {
        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;
    }
 
    BOOLEAN
    IsPoolTrackingOn(
        VOID
        )
    {
        return (FxPoolTrackingOn) ? TRUE : FALSE;
    }
 
    BOOLEAN
    IsObjectDebugOn(
        VOID
        )
    {
        if (FxVerifierHandle) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }
 
    VOID
    SetVerifierState(
        __in BOOLEAN State
        )
    {
        //
        // 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);
        }
    }
 
    _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
        )
    {
        //
        // 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;
        }
    }
 
    //
    // To be used in code path where it is already determined that the driver
    // is down-level, otherwise use IsVerificationEnabled.
    //
    __inline
    _Must_inspect_result_
    BOOLEAN
    IsDownlevelVerificationEnabled(
        )
    {
        return FxVerifyDownlevel;
    }
 
    VOID
    WaitForSignal(
        __in MxEvent* Event,
        __in PCSTR ReasonForWaiting,
        __in PVOID Handle,
        __in ULONG WarningTimeoutInSec,
        __in ULONG WaitSignalFlags
        );
 
    _Must_inspect_result_
    BOOLEAN
    IsDebuggerAttached(
        VOID
        );
 
public:
    //
    // Link list of driver FxDriverGlobals on this WDF Version.
    //
    LIST_ENTRY Linkage;
 
    //
    // Reference count is operated on with interlocked operations
    //
    LONG Refcnt;
 
    //
    // This event is signaled when globals can be freed. Unload thread waits
    // on this event to make sure driver's threads are done and driver unload
    // can proceed.
    //
    MxEvent DestroyEvent;
 
    //
    // Mask to XOR all outgoing handles against
    //
    ULONG_PTR WdfHandleMask;
 
    //
    // If verifier is on, this is the count of allocations
    // to fail at
    //
    LONG    WdfVerifierAllocateFailCount;
 
    //
    // Tag to be used for allocations on behalf of the driver writer.  This is
    // based off of the service name (which might be different than the binary
    // name).
    //
    ULONG Tag;
 
    //
    // Backpointer to Fx driver object
    //
    FxDriver* Driver;
 
    FxDriverGlobalsDebugExtension* DebugExtension;
 
    FxLibraryGlobalsType* LibraryGlobals;
 
    //
    // WDF internal In-Flight Recorder (IFR) log
    //
    PVOID  WdfLogHeader;
 
    //
    // The driver's memory pool header
    //
    FX_POOL FxPoolFrameworks;
 
    //
    // Framworks Pool Tracking
    //
    BOOLEAN FxPoolTrackingOn;
 
    //
    // FxVerifierLock per driver state
    //
    MxLock ThreadTableLock;
 
    PLIST_ENTRY ThreadTable;
 
    //
    // Embedded pointer to driver's WDF_BIND_INFO structure (in stub)
    //
    PWDF_BIND_INFO WdfBindInfo;
 
    //
    // The base address of the image.
    //
    PVOID ImageAddress;
 
    //
    // The size of the image.
    //
    ULONG ImageSize;
 
    //
    // Top level verifier flag.
    //
    BOOLEAN FxVerifierOn;
 
    //
    // Apply latest-version-restricted verifier checks to downlevel drivers.
    // Drivers set this value in registry.
    //
    BOOLEAN FxVerifyDownlevel;
 
    //
    // Breakpoint on errors.
    //
    BOOLEAN FxVerifierDbgBreakOnError;
 
    //
    // Breakpoint on device state errors.
    //
    BOOLEAN FxVerifierDbgBreakOnDeviceStateError;
 
    //
    // Handle verifier.
    //
    BOOLEAN FxVerifierHandle;
 
    //
    // I/O verifier.
    //
    BOOLEAN FxVerifierIO;
 
    //
    // Lock verifier.
    //
    BOOLEAN FxVerifierLock;
 
    //
    // Not a verifier option.  Rather, controls whether WDFVERIFY macros are
    // live.
    //
    BOOLEAN FxVerifyOn;
 
    //
    // Capture IFR Verbose messages.
    //
    BOOLEAN FxVerboseOn;
 
    //
    // Parent queue presented requests (to device).
    //
    BOOLEAN FxRequestParentOptimizationOn;
 
    //
    // Enable/Disable support for device simulation framework (DSF).
    //
    BOOLEAN FxDsfOn;
 
    //
    // Force copy of IFR data to mini-dump when a bugcheck happens.
    //
    BOOLEAN FxForceLogsInMiniDump;
 
    //
    // TRUE to enable run-time driver tracking. The dump callback logic
    // uses this info for finding the right log to write in the minidump.
    //
    BOOLEAN FxTrackDriverForMiniDumpLog;
 
    //
    // TRUE if compiled for user-mode
    //
    BOOLEAN IsUserModeDriver;
 
    //
    // Remove lock options, these are also specified through
    // WdfDeviceInitSetRemoveLockOptions.
    //
    ULONG RemoveLockOptionFlags;
 
    //
    // Bug check callback data for kernel mode only
 
 
 
    //
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    //
    // 0-based index into the BugCheckDriverInfo holding this driver info.
    //
    ULONG BugCheckDriverInfoIndex;
 
    //
    // Bug check callback record for processing bugchecks.
    //
    KBUGCHECK_REASON_CALLBACK_RECORD BugCheckCallbackRecord;
 
#endif
 
    //
    // Enhanced Verifier Options.
    //
    ULONG FxEnhancedVerifierOptions;
 
    //
    // If FxVerifierDbgBreakOnError is true, WaitForSignal interrupts the
    // execution of the system after waiting for the specified number
    // of seconds. Developer will have an opportunity to validate the state
    // of the driver when breakpoint is hit. Developer can continue to wait
    // by entering 'g' in the debugger.
    //
    ULONG FxVerifierDbgWaitForSignalTimeoutInSec;
 
    //
    // Timeout used by the wake interrupt ISR in WaitForSignal to catch
    // scenarios where the interrupt ISR is blocked because the device stack
    // is taking too long to power up
    //
    ULONG DbgWaitForWakeInterruptIsrTimeoutInSec;
 
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    CWudfDriverGlobals * UfxDriverGlobals;
#endif
 
    PFX_TELEMETRY_CONTEXT TelemetryContext;
 
    //
    // The public version of WDF_DRIVER_GLOBALS
    //
    DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) WDF_DRIVER_GLOBALS  Public;
 
} FX_DRIVER_GLOBALS, *PFX_DRIVER_GLOBALS;
 
__bcount(Size)
PVOID
FORCEINLINE
FxPoolAllocate(
    __in PFX_DRIVER_GLOBALS Globals,
    __in POOL_TYPE Type,
    __in size_t Size
    )
{
    //
    // Always pass in the return address, regardless of the value of
    // Globals->WdfPoolTrackingOn.
    //
    return FxPoolAllocator(
        Globals,
        &Globals->FxPoolFrameworks,
        Type,
        Size,
        Globals->Tag,
        _ReturnAddress()
        );
}
 
__bcount(Size)
PVOID
FORCEINLINE
FxPoolAllocateWithTag(
    __in PFX_DRIVER_GLOBALS Globals,
    __in POOL_TYPE Type,
    __in size_t Size,
    __in ULONG Tag
    )
{
    return FxPoolAllocator(
        Globals,
        &Globals->FxPoolFrameworks,
        Type,
        Size,
        Tag,
        Globals->FxPoolTrackingOn ? _ReturnAddress() : NULL
        );
}
 
//
// Get FxDriverGlobals from api's DriverGlobals
//
__inline
PFX_DRIVER_GLOBALS
GetFxDriverGlobals(
    __in PWDF_DRIVER_GLOBALS DriverGlobals
    )
{
    return CONTAINING_RECORD( DriverGlobals, FX_DRIVER_GLOBALS, Public );
}
 
typedef struct _WDF_DRIVER_CONFIG *PWDF_DRIVER_CONFIG;
 
#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
VOID
LockVerifierSection(
    _In_ PFX_DRIVER_GLOBALS FxDriverGlobals,
    _In_ PCUNICODE_STRING RegistryPath
    );
 
VOID
UnlockVerifierSection(
    _In_ PFX_DRIVER_GLOBALS FxDriverGlobals
    );
#endif
 
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 //optional in user mode
    );
 
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
    );
 
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
    );
 
enum FxMachineSleepStates {
    FxMachineS1Index = 0,
    FxMachineS2Index,
    FxMachineS3Index,
    FxMachineSleepStatesMax,
};
 
//
// Private Globals for the entire DLL
 
//
struct FxLibraryGlobalsType {
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
 
    //
    // The driver object for the library.
 
 
 
 
 
    //
    PDRIVER_OBJECT DriverObject;
 
    //
    // As long as this device object is around, the library cannot be unloaded.
    // This prevents the following scenario from unloading the service
    // 1  wdfldr.sys loads the library
    // 2  user tries to run "net stop <service>" while there are outstanding clients
    //    through wdfldr
    //
    PDEVICE_OBJECT LibraryDeviceObject;
 
    PFN_IO_CONNECT_INTERRUPT_EX IoConnectInterruptEx;
 
    PFN_IO_DISCONNECT_INTERRUPT_EX IoDisconnectInterruptEx;
 
    PFN_KE_QUERY_ACTIVE_PROCESSORS KeQueryActiveProcessors;
 
    PFN_KE_SET_TARGET_PROCESSOR_DPC KeSetTargetProcessorDpc;
 
    PFN_KE_SET_COALESCABLE_TIMER KeSetCoalescableTimer;
 
    PFN_IO_UNREGISTER_PLUGPLAY_NOTIFICATION_EX IoUnregisterPlugPlayNotificationEx;
 
    PFN_POX_REGISTER_DEVICE PoxRegisterDevice;
 
    PFN_POX_START_DEVICE_POWER_MANAGEMENT PoxStartDevicePowerManagement;
 
    PFN_POX_UNREGISTER_DEVICE PoxUnregisterDevice;
 
    PFN_POX_ACTIVATE_COMPONENT PoxActivateComponent;
 
    PFN_POX_IDLE_COMPONENT PoxIdleComponent;
 
    PFN_POX_REPORT_DEVICE_POWERED_ON PoxReportDevicePoweredOn;
 
    PFN_POX_COMPLETE_IDLE_STATE PoxCompleteIdleState;
 
    PFN_POX_COMPLETE_IDLE_CONDITION PoxCompleteIdleCondition;
 
    PFN_POX_COMPLETE_DEVICE_POWER_NOT_REQUIRED PoxCompleteDevicePowerNotRequired;
 
    PFN_POX_SET_DEVICE_IDLE_TIMEOUT PoxSetDeviceIdleTimeout;
 
    PFN_IO_REPORT_INTERRUPT_ACTIVE IoReportInterruptActive;
 
    PFN_IO_REPORT_INTERRUPT_INACTIVE IoReportInterruptInactive;
 
    PFN_VF_CHECK_NX_POOL_TYPE VfCheckNxPoolType;
 
#endif
 
    RTL_OSVERSIONINFOEXW OsVersionInfo;
 
    MxLockNoDynam FxDriverGlobalsListLock;
 
    LIST_ENTRY   FxDriverGlobalsList;
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    //
    // Index to first free entry in BugCheckDriverInfo array.
    //
    ULONG BugCheckDriverInfoIndex;
 
    //
    // # of entries in BugCheckDriverInfo array.
    //
    ULONG BugCheckDriverInfoCount;
 
    //
    // Array of info about loaded driver. The library bugcheck callback
    // writes this data into the minidump.
    //
    PFX_DUMP_DRIVER_INFO_ENTRY   BugCheckDriverInfo;
 
    //
    // Library bug-check callback record for processing bugchecks.
    //
    KBUGCHECK_REASON_CALLBACK_RECORD  BugCheckCallbackRecord;
 
    BOOLEAN ProcessorGroupSupport;
 
#endif
    //
    // WPP tracing.
    //
    BOOLEAN InternalTracingInitialized;
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    //
    // The following field is used by the debug dump callback routine for
    // finding which driver's dump log file to write in the minidump if an
    // exact match is not found.
    //
    FX_DRIVER_TRACKER_CACHE_AWARE DriverTracker;
 
    //
    // Best driver match for the mini-dump log.
    //
    PFX_DRIVER_GLOBALS BestDriverForDumpLog;
#endif
 
    BOOLEAN PassiveLevelInterruptSupport;
 
    //
    // TRUE if compiled for user-mode
    //
    BOOLEAN IsUserModeFramework;
 
    //
 
 
 
 
 
 
    //
 
    BOOLEAN MachineSleepStates[FxMachineSleepStatesMax];
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    //
    // used for locking/unlocking Enhanced-verifier image section
    //
    PVOID VerifierSectionHandle;
 
    //
    // This keeps track of the # of times we pinned the paged memory down.
    // This is only used to aid debugging.
    //
    volatile LONG VerifierSectionHandleRefCount;
 
    //
    // Routines provided by the kernel SystemTraceProvider for perf
    // tracing of WDF operations. The size member of this structure
    // allows versioning across multiple OS versions.
    //
    //PWMI_WDF_NOTIFY_ROUTINES PerfTraceRoutines; __REACTOS__
    PVOID PerfTraceRoutines;
 
    //
    //  PerfTraceRoutines points here if the SystemTraceProvider failed
    //  to provide trace routines.
    //
    //WMI_WDF_NOTIFY_ROUTINES DummyPerfTraceRoutines; __REACTOS__
    PVOID DummyPerfTraceRoutines;
 
#endif
 
    //
    // Registry setting to disable IFR on low-memory systems.
    //
    BOOLEAN IfrDisabled;
};
 
extern FxLibraryGlobalsType FxLibraryGlobals;
 
 
typedef struct _FX_OBJECT_INFO {
    //
    // The name of the object, ie "FxObject"
    //
    const CHAR* Name;
 
    //
    // The name of the external WDF handle that represents the object, ie
    // WDFDEVICE.  If the object does not have an external handle, this field
    // may be NULL.
    //
    const CHAR* HandleName;
 
    //
    // The minimum size of the object, ie sizeof(FxObject).  There are objects
    // which allocate more than their sizeof() length.
    //
    USHORT Size;
 
    //
    // FX_OBJECT_TYPES value
    //
    USHORT ObjectType;
 
} FX_OBJECT_INFO, *PFX_OBJECT_INFO;
 
//
// Define to declare an internal entry.  An internal entry has no external WDF
// handle.
//
#define FX_INTERNAL_OBJECT_INFO_ENTRY(_obj, _type)  \
    { #_obj, NULL, sizeof(_obj), _type, }
 
//
// Define to declare an external entry.  An external entry has an external WDF
// handle.
//
// By casting #_handletype to a (_handletype), we make sure that _handletype is
// actually a valid WDF handle name.  The cast forces the parameter to be
// evaluated as true handle type vs a string (ie the # preprocesor operator).
// For instance, this would catch the following error:
//
//    FX_EXTERNAL_OBJECT_INFO_ENTRY(FxDevice, FX_TYPE_DEVICE, WDFDEVICES),
//
// because the statement would evaluate to (const CHAR*) (WDFDEVICES) "WDFDEVICES"
// and WDFDEVICES is not a valid type (WDFDEVICE is though).
//
#define FX_EXTERNAL_OBJECT_INFO_ENTRY(_obj, _type, _handletype) \
    { #_obj,                                                    \
      (const CHAR*) (_handletype) #_handletype,                 \
      sizeof(_obj),                                             \
      _type,                                                    \
    }
 
_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
    )
{
    return (FxDriverGlobals == ExtDriverGlobals) ? FALSE : TRUE;
}
 
 
_Must_inspect_result_
BOOLEAN
__inline
FxIsEqualGuid(
    __in CONST GUID* Lhs,
    __in CONST GUID* Rhs
    )
{
    return RtlCompareMemory(Lhs, Rhs, sizeof(GUID)) == sizeof(GUID);
}
 
__inline
size_t
FxSizeTMax(
    __in size_t A,
    __in size_t B
    )
{
    return A > B ? A : B;
}
 
__inline
size_t
FxSizeTMin(
    __in size_t A,
    __in size_t B
    )
{
    return A < B ? A : B;
}
 
__inline
LONG
FxInterlockedIncrementFloor(
    __inout LONG  volatile *Target,
    __in LONG Floor
    )
{
    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;
}
 
__inline
LONG
FxInterlockedIncrementGTZero(
    __inout LONG  volatile *Target
    )
{
    return FxInterlockedIncrementFloor(Target, 0);
}
 
__inline
ULONG
FxRandom(
    __inout PULONG RandomSeed
    )
/*++
 
Routine Description:
 
    Simple threadsafe random number generator to use at DISPATCH_LEVEL
    (in kernel mode) because the system provided function RtlRandomEx
    can be called at only passive-level.
 
    This function requires the user to provide a variable used to seed
    the generator, and it must be valid and initialized to some number.
 
Return Value:
 
   ULONG
 
--*/
{
    *RandomSeed = *RandomSeed * 1103515245 + 12345;
    return (ULONG)(*RandomSeed / 65536) % 32768;
}
 
_Must_inspect_result_
__inline
BOOLEAN
FxIsPassiveLevelInterruptSupported(
    VOID
    )
{
    //
    // Passive-level interrupt handling is supported in Win 8 and forward.
    //
    return FxLibraryGlobals.PassiveLevelInterruptSupport;
}
 
__inline
_Must_inspect_result_
BOOLEAN
IsOsVersionGreaterThanOrEqualTo(
    __in ULONG Major,
    __in ULONG Minor
    )
{
    return ((FxLibraryGlobals.OsVersionInfo.dwMajorVersion > Major) ||
            ((FxLibraryGlobals.OsVersionInfo.dwMajorVersion == Major) &&
             (FxLibraryGlobals.OsVersionInfo.dwMinorVersion >= Minor)));
}
 
#ifdef __cplusplus
}
#endif
#endif // _FXGLOBALS_H