xref: /reactos/sdk/lib/drivers/wdf/shared/inc/private/common/fxglobals.h (revision 1f377076)

/*++

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