mirror of
https://github.com/reactos/reactos.git
synced 2025-03-10 10:14:44 +00:00
1f377076d7
Not all files are included, but these are necessary to compile cdrom driver. So far it can only be statically linked with drivers, a proper implementation requires wdfldr helper driver
1108 lines
24 KiB
C++
1108 lines
24 KiB
C++
/*++
|
|
|
|
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
|
|
|