/*++ BUILD Version: 0162 // Increment this if a change has global effects Copyright (c) Microsoft Corporation. All rights reserved. Module Name: wdm.h Abstract: This module defines the WDM types, constants, and functions that are exposed to device drivers. Revision History: --*/ #ifndef _WDMDDK_ #define _WDMDDK_ #ifndef _NTDDK_ #define _WDM_INCLUDED_ #define _DDK_DRIVER_ // // Use 9x compat Interlocked functions by default when including wdm.h // #define NO_INTERLOCKED_INTRINSICS #endif #define _NTDDK_ #define _STRSAFE_USE_SECURE_CRT 0 #ifndef RC_INVOKED #if _MSC_VER < 1300 #error Compiler version not supported by Windows DDK #endif #endif // RC_INVOKED #define NT_INCLUDED #define _CTYPE_DISABLE_MACROS #if _MSC_VER >= 1200 #pragma warning(push) #endif #pragma warning(disable:4115) // named type definition in parentheses #pragma warning(disable:4201) // nameless struct/union #pragma warning(disable:4214) // bit field types other than int #pragma warning(disable:4365) // signed/unsigned mismatch #pragma warning(disable:4668) // #if not_defined treated as #if 0 #pragma warning(disable:4820) // padding added #include #include #include #include #include #include _Analysis_mode_(_Analysis_internal_kernel_driver_) _Analysis_mode_(_Analysis_local_leak_checks_) __drv_Mode_impl(WDM_INCLUDED) #ifdef __cplusplus extern "C" { #endif // // Define types that are not exported. // typedef struct _ACCESS_STATE *PACCESS_STATE; typedef struct _CALLBACK_OBJECT *PCALLBACK_OBJECT; #if defined(_NTHAL_INCLUDED_) typedef struct _KPROCESS *PEPROCESS; typedef struct _ETHREAD *PETHREAD; #elif defined(_NTIFS_INCLUDED_) typedef struct _KPROCESS *PEPROCESS; typedef struct _KTHREAD *PETHREAD; #else typedef struct _EPROCESS *PEPROCESS; typedef struct _ETHREAD *PETHREAD; #endif typedef struct _IO_TIMER *PIO_TIMER; typedef struct _KINTERRUPT *PKINTERRUPT; typedef struct _KTHREAD *PKTHREAD, *PRKTHREAD; typedef struct _KPROCESS *PKPROCESS, *PRKPROCESS; typedef struct _OBJECT_TYPE *POBJECT_TYPE; typedef struct _SECURITY_QUALITY_OF_SERVICE *PSECURITY_QUALITY_OF_SERVICE; // // Declare empty structure definitions so that they may be referenced by // routines before they are defined // typedef struct _CONTEXT *PCONTEXT; typedef struct _IO_STACK_LOCATION *PIO_STACK_LOCATION; typedef struct _VPB *PVPB; typedef struct _FILE_GET_QUOTA_INFORMATION *PFILE_GET_QUOTA_INFORMATION; #if defined(_M_AMD64) ULONG64 __readgsqword ( _In_ ULONG Offset ); #pragma intrinsic(__readgsqword) __forceinline PKTHREAD KeGetCurrentThread ( VOID ) { return (struct _KTHREAD *)__readgsqword(0x188); } #endif // defined(_M_AMD64) #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_ARM64) NTSYSAPI PKTHREAD NTAPI KeGetCurrentThread( VOID ); #endif // defined(_M_IX86) || defined(_M_ARM) || defined(_M_ARM64) // // Define base address for kernel and user space // #ifndef _WIN64 #define KADDRESS_BASE 0 #define UADDRESS_BASE 0 #endif // !_WIN64 #include #ifndef FAR #define FAR #endif #define PsGetCurrentProcess IoGetCurrentProcess #if (NTDDI_VERSION >= NTDDI_VISTA) #if defined(_X86_) || defined(_AMD64_) extern NTSYSAPI volatile CCHAR KeNumberProcessors; #else extern NTSYSAPI CCHAR KeNumberProcessors; #endif #elif (NTDDI_VERSION >= NTDDI_WINXP) extern NTSYSAPI CCHAR KeNumberProcessors; #else extern PCCHAR KeNumberProcessors; #endif #if defined(_X86_) // // Interrupt Request Level definitions // #define PASSIVE_LEVEL 0 // Passive release level #define LOW_LEVEL 0 // Lowest interrupt level #define APC_LEVEL 1 // APC interrupt level #define DISPATCH_LEVEL 2 // Dispatcher level #define CMCI_LEVEL 5 // CMCI handler level #define PROFILE_LEVEL 27 // timer used for profiling. #define CLOCK1_LEVEL 28 // Interval clock 1 level - Not used on x86 #define CLOCK2_LEVEL 28 // Interval clock 2 level #define IPI_LEVEL 29 // Interprocessor interrupt level #define POWER_LEVEL 30 // Power failure level #define HIGH_LEVEL 31 // Highest interrupt level #define CLOCK_LEVEL (CLOCK2_LEVEL) #endif #if defined(_AMD64_) // // Interrupt Request Level definitions // #define PASSIVE_LEVEL 0 // Passive release level #define LOW_LEVEL 0 // Lowest interrupt level #define APC_LEVEL 1 // APC interrupt level #define DISPATCH_LEVEL 2 // Dispatcher level #define CMCI_LEVEL 5 // CMCI handler level #define CLOCK_LEVEL 13 // Interval clock level #define IPI_LEVEL 14 // Interprocessor interrupt level #define DRS_LEVEL 14 // Deferred Recovery Service level #define POWER_LEVEL 14 // Power failure level #define PROFILE_LEVEL 15 // timer used for profiling. #define HIGH_LEVEL 15 // Highest interrupt level #endif #if defined(_ARM_) // // Interrupt Request Level definitions // #define PASSIVE_LEVEL 0 // Passive release level #define LOW_LEVEL 0 // Lowest interrupt level #define APC_LEVEL 1 // APC interrupt level #define DISPATCH_LEVEL 2 // Dispatcher level #define CLOCK_LEVEL 13 // Interval clock level #define IPI_LEVEL 14 // Interprocessor interrupt level #define DRS_LEVEL 14 // Deferred Recovery Service level #define POWER_LEVEL 14 // Power failure level #define PROFILE_LEVEL 15 // timer used for profiling. #define HIGH_LEVEL 15 // Highest interrupt level #endif #if defined(_ARM64_) // // Interrupt Request Level definitions // #define PASSIVE_LEVEL 0 // Passive release level #define LOW_LEVEL 0 // Lowest interrupt level #define APC_LEVEL 1 // APC interrupt level #define DISPATCH_LEVEL 2 // Dispatcher level #define CLOCK_LEVEL 13 // Interval clock level #define IPI_LEVEL 14 // Interprocessor interrupt level #define DRS_LEVEL 14 // Deferred Recovery Service level #define POWER_LEVEL 14 // Power failure level #define PROFILE_LEVEL 15 // timer used for profiling. #define HIGH_LEVEL 15 // Highest interrupt level #endif #define LOW_PRIORITY 0 // Lowest thread priority level #define LOW_REALTIME_PRIORITY 16 // Lowest realtime priority level #define HIGH_PRIORITY 31 // Highest thread priority level #define MAXIMUM_PRIORITY 32 // Number of thread priority levels #define MAXIMUM_WAIT_OBJECTS 64 // Maximum number of wait objects #define MAXIMUM_SUSPEND_COUNT MAXCHAR // Maximum times thread can be suspended // // Define system time structure. // typedef struct _KSYSTEM_TIME { ULONG LowPart; LONG High1Time; LONG High2Time; } KSYSTEM_TIME, *PKSYSTEM_TIME; // // Thread priority // typedef LONG KPRIORITY; // // Spin Lock // typedef ULONG_PTR KSPIN_LOCK; typedef KSPIN_LOCK *PKSPIN_LOCK; // // Define per processor lock queue structure. // // N.B. The lock field of the spin lock queue structure contains the address // of the associated kernel spin lock, an owner bit, and a lock bit. Bit // 0 of the spin lock address is the wait bit and bit 1 is the owner bit. // The use of this field is such that the bits can be set and cleared // noninterlocked, however, the back pointer must be preserved. // // The lock wait bit is set when a processor enqueues itself on the lock // queue and it is not the only entry in the queue. The processor will // spin on this bit waiting for the lock to be granted. // // The owner bit is set when the processor owns the respective lock. // // The next field of the spin lock queue structure is used to line the // queued lock structures together in fifo order. It also can set set and // cleared noninterlocked. // #define LOCK_QUEUE_WAIT 1 #define LOCK_QUEUE_WAIT_BIT 0 #define LOCK_QUEUE_OWNER 2 #define LOCK_QUEUE_OWNER_BIT 1 #if defined(_AMD64_) typedef ULONG64 KSPIN_LOCK_QUEUE_NUMBER; #define LockQueueUnusedSpare0 0 #define LockQueueUnusedSpare1 1 #define LockQueueUnusedSpare2 2 #define LockQueueUnusedSpare3 3 #define LockQueueVacbLock 4 #define LockQueueMasterLock 5 #define LockQueueNonPagedPoolLock 6 #define LockQueueIoCancelLock 7 #define LockQueueWorkQueueLock 8 #define LockQueueIoVpbLock 9 #define LockQueueIoDatabaseLock 10 #define LockQueueIoCompletionLock 11 #define LockQueueNtfsStructLock 12 #define LockQueueAfdWorkQueueLock 13 #define LockQueueBcbLock 14 #define LockQueueUnusedSpare15 15 #define LockQueueUnusedSpare16 16 #define LockQueueMaximumLock (LockQueueUnusedSpare16 + 1) #else typedef enum _KSPIN_LOCK_QUEUE_NUMBER { LockQueueUnusedSpare0, LockQueueUnusedSpare1, LockQueueUnusedSpare2, LockQueueUnusedSpare3, LockQueueVacbLock, LockQueueMasterLock, LockQueueNonPagedPoolLock, LockQueueIoCancelLock, LockQueueWorkQueueLock, LockQueueIoVpbLock, LockQueueIoDatabaseLock, LockQueueIoCompletionLock, LockQueueNtfsStructLock, LockQueueAfdWorkQueueLock, LockQueueBcbLock, LockQueueUnusedSpare15, LockQueueUnusedSpare16, LockQueueMaximumLock = LockQueueUnusedSpare16 + 1 } KSPIN_LOCK_QUEUE_NUMBER, *PKSPIN_LOCK_QUEUE_NUMBER; #endif typedef struct _KSPIN_LOCK_QUEUE { struct _KSPIN_LOCK_QUEUE * volatile Next; PKSPIN_LOCK volatile Lock; } KSPIN_LOCK_QUEUE, *PKSPIN_LOCK_QUEUE; typedef struct _KLOCK_QUEUE_HANDLE { KSPIN_LOCK_QUEUE LockQueue; KIRQL OldIrql; } KLOCK_QUEUE_HANDLE, *PKLOCK_QUEUE_HANDLE; // // Profile source types // typedef enum _KPROFILE_SOURCE { ProfileTime, ProfileAlignmentFixup, ProfileTotalIssues, ProfilePipelineDry, ProfileLoadInstructions, ProfilePipelineFrozen, ProfileBranchInstructions, ProfileTotalNonissues, ProfileDcacheMisses, ProfileIcacheMisses, ProfileCacheMisses, ProfileBranchMispredictions, ProfileStoreInstructions, ProfileFpInstructions, ProfileIntegerInstructions, Profile2Issue, Profile3Issue, Profile4Issue, ProfileSpecialInstructions, ProfileTotalCycles, ProfileIcacheIssues, ProfileDcacheAccesses, ProfileMemoryBarrierCycles, ProfileLoadLinkedIssues, ProfileMaximum } KPROFILE_SOURCE; // // Define 128-bit 16-byte aligned xmm register type. // typedef struct DECLSPEC_ALIGN(16) _M128A { ULONGLONG Low; LONGLONG High; } M128A, *PM128A; // // Format of data for (F)XSAVE/(F)XRSTOR instruction // typedef struct DECLSPEC_ALIGN(16) _XSAVE_FORMAT { USHORT ControlWord; USHORT StatusWord; UCHAR TagWord; UCHAR Reserved1; USHORT ErrorOpcode; ULONG ErrorOffset; USHORT ErrorSelector; USHORT Reserved2; ULONG DataOffset; USHORT DataSelector; USHORT Reserved3; ULONG MxCsr; ULONG MxCsr_Mask; M128A FloatRegisters[8]; #if defined(_WIN64) M128A XmmRegisters[16]; UCHAR Reserved4[96]; #else M128A XmmRegisters[8]; UCHAR Reserved4[224]; #endif } XSAVE_FORMAT, *PXSAVE_FORMAT; typedef struct DECLSPEC_ALIGN(8) _XSAVE_AREA_HEADER { ULONG64 Mask; ULONG64 CompactionMask; ULONG64 Reserved2[6]; } XSAVE_AREA_HEADER, *PXSAVE_AREA_HEADER; typedef struct DECLSPEC_ALIGN(16) _XSAVE_AREA { XSAVE_FORMAT LegacyState; XSAVE_AREA_HEADER Header; } XSAVE_AREA, *PXSAVE_AREA; typedef struct _XSTATE_CONTEXT { ULONG64 Mask; ULONG Length; ULONG Reserved1; _Field_size_bytes_opt_(Length) PXSAVE_AREA Area; #if defined(_X86_) ULONG Reserved2; #endif PVOID Buffer; #if defined(_X86_) ULONG Reserved3; #endif } XSTATE_CONTEXT, *PXSTATE_CONTEXT; #ifdef _X86_ // // Some intrinsics have a redundant __cdecl calling-convention specifier when // not compiled with /clr:pure. // #if defined(_M_CEE_PURE) #define CDECL_NON_WVMPURE #else #define CDECL_NON_WVMPURE __cdecl #endif // // Disable these two pragmas that evaluate to "sti" "cli" on x86 so that driver // writers to not leave them inadvertantly in their code. // #if !defined(MIDL_PASS) #if !defined(RC_INVOKED) #if _MSC_VER >= 1200 #pragma warning(push) #endif // _MSC_VER >= 1200 //#pragma warning(disable:4164) // disable C4164 warning so that apps that // build with /Od don't get weird errors ! #if _MSC_VER >= 1200 #pragma warning( pop ) #else #pragma warning( default:4164 ) // reenable C4164 warning #endif // _MSC_VER >= 1200 #endif // !defined(MIDL_PASS) #endif // !defined(RC_INVOKED) #if defined(_M_IX86) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #ifdef __cplusplus extern "C" { #endif #if !defined(_MANAGED) // // Define bit test intrinsics. // #define BitTest _bittest #define BitTestAndComplement _bittestandcomplement #define BitTestAndSet _bittestandset #define BitTestAndReset _bittestandreset #define InterlockedBitTestAndSet _interlockedbittestandset #define InterlockedBitTestAndSetAcquire _interlockedbittestandset #define InterlockedBitTestAndSetRelease _interlockedbittestandset #define InterlockedBitTestAndSetNoFence _interlockedbittestandset #define InterlockedBitTestAndReset _interlockedbittestandreset #define InterlockedBitTestAndResetAcquire _interlockedbittestandreset #define InterlockedBitTestAndResetRelease _interlockedbittestandreset #define InterlockedBitTestAndResetNoFence _interlockedbittestandreset _Must_inspect_result_ BOOLEAN _bittest ( _In_reads_bytes_((Offset/8)+1) LONG const *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _bittestandcomplement ( _Inout_updates_bytes_((Offset/8)+1) LONG *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _bittestandset ( _Inout_updates_bytes_((Offset/8)+1) LONG *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _bittestandreset ( _Inout_updates_bytes_((Offset/8)+1) LONG *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _interlockedbittestandset ( _Inout_updates_bytes_((Offset/8)+1) _Interlocked_operand_ LONG volatile *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _interlockedbittestandreset ( _Inout_updates_bytes_((Offset/8)+1) _Interlocked_operand_ LONG volatile *Base, _In_range_(>=,0) LONG Offset ); #pragma intrinsic(_bittest) #pragma intrinsic(_bittestandcomplement) #pragma intrinsic(_bittestandset) #pragma intrinsic(_bittestandreset) #pragma intrinsic(_interlockedbittestandset) #pragma intrinsic(_interlockedbittestandreset) // // Define bit scan intrinsics. // #define BitScanForward _BitScanForward #define BitScanReverse _BitScanReverse _Success_(return != 0) BOOLEAN _BitScanForward ( _Out_ ULONG *Index, _In_ ULONG Mask ); _Success_(return != 0) BOOLEAN _BitScanReverse ( _Out_ ULONG *Index, _In_ ULONG Mask ); #pragma intrinsic(_BitScanForward) #pragma intrinsic(_BitScanReverse) _Success_(return != 0) FORCEINLINE BOOLEAN _InlineBitScanForward64 ( _Out_ ULONG *Index, _In_ ULONG64 Mask ) { if (_BitScanForward(Index, (ULONG)Mask)) { return 1; } if (_BitScanForward(Index, (ULONG)(Mask >> 32))) { *Index += 32; return 1; } return 0; } #define BitScanForward64 _InlineBitScanForward64 _Success_(return != 0) FORCEINLINE BOOLEAN _InlineBitScanReverse64 ( _Out_ ULONG *Index, _In_ ULONG64 Mask ) { if (_BitScanReverse(Index, (ULONG)(Mask >> 32))) { *Index += 32; return 1; } if (_BitScanReverse(Index, (ULONG)Mask)) { return 1; } return 0; } #define BitScanReverse64 _InlineBitScanReverse64 #endif // !defined(_MANAGED) // // Interlocked intrinsic functions. // #if !defined(_MANAGED) #define InterlockedIncrement16 _InterlockedIncrement16 #define InterlockedIncrementAcquire16 _InterlockedIncrement16 #define InterlockedIncrementRelease16 _InterlockedIncrement16 #define InterlockedIncrementNoFence16 _InterlockedIncrement16 #define InterlockedDecrement16 _InterlockedDecrement16 #define InterlockedDecrementAcquire16 _InterlockedDecrement16 #define InterlockedDecrementRelease16 _InterlockedDecrement16 #define InterlockedDecrementNoFence16 _InterlockedDecrement16 #define InterlockedCompareExchange16 _InterlockedCompareExchange16 #define InterlockedCompareExchangeAcquire16 _InterlockedCompareExchange16 #define InterlockedCompareExchangeRelease16 _InterlockedCompareExchange16 #define InterlockedCompareExchangeNoFence16 _InterlockedCompareExchange16 #define InterlockedCompareExchange64 _InterlockedCompareExchange64 #define InterlockedCompareExchangeAcquire64 _InterlockedCompareExchange64 #define InterlockedCompareExchangeRelease64 _InterlockedCompareExchange64 #define InterlockedCompareExchangeNoFence64 _InterlockedCompareExchange64 SHORT InterlockedIncrement16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Addend ); SHORT InterlockedDecrement16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Addend ); SHORT InterlockedCompareExchange16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT ExChange, _In_ SHORT Comperand ); LONG64 InterlockedCompareExchange64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 ExChange, _In_ LONG64 Comperand ); #pragma intrinsic(_InterlockedIncrement16) #pragma intrinsic(_InterlockedDecrement16) #pragma intrinsic(_InterlockedCompareExchange16) #pragma intrinsic(_InterlockedCompareExchange64) #endif // !defined(_MANAGED) #define InterlockedAnd _InterlockedAnd #define InterlockedAndAcquire _InterlockedAnd #define InterlockedAndRelease _InterlockedAnd #define InterlockedAndNoFence _InterlockedAnd #define InterlockedOr _InterlockedOr #define InterlockedOrAcquire _InterlockedOr #define InterlockedOrRelease _InterlockedOr #define InterlockedOrNoFence _InterlockedOr #define InterlockedXor _InterlockedXor #define InterlockedXorAcquire _InterlockedXor #define InterlockedXorRelease _InterlockedXor #define InterlockedXorNoFence _InterlockedXor #define InterlockedIncrement _InterlockedIncrement #define InterlockedIncrementAcquire _InterlockedIncrement #define InterlockedIncrementRelease _InterlockedIncrement #define InterlockedIncrementNoFence _InterlockedIncrement #define InterlockedDecrement _InterlockedDecrement #define InterlockedDecrementAcquire _InterlockedDecrement #define InterlockedDecrementRelease _InterlockedDecrement #define InterlockedDecrementNoFence _InterlockedDecrement #define InterlockedAdd _InlineInterlockedAdd #define InterlockedAddAcquire _InlineInterlockedAdd #define InterlockedAddRelease _InlineInterlockedAdd #define InterlockedAddNoFence _InlineInterlockedAdd #define InterlockedAddNoFence64 _InlineInterlockedAdd64 #define InterlockedExchange _InterlockedExchange #define InterlockedExchangeAcquire _InterlockedExchange #define InterlockedExchangeNoFence _InterlockedExchange #define InterlockedExchangeAdd _InterlockedExchangeAdd #define InterlockedExchangeAddAcquire _InterlockedExchangeAdd #define InterlockedExchangeAddRelease _InterlockedExchangeAdd #define InterlockedExchangeAddNoFence _InterlockedExchangeAdd #define InterlockedCompareExchange _InterlockedCompareExchange #define InterlockedCompareExchangeAcquire _InterlockedCompareExchange #define InterlockedCompareExchangeRelease _InterlockedCompareExchange #define InterlockedCompareExchangeNoFence _InterlockedCompareExchange #define InterlockedExchange16 _InterlockedExchange16 LONG InterlockedAnd ( _Inout_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ); LONG InterlockedOr ( _Inout_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ); LONG InterlockedXor ( _Inout_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ); LONG CDECL_NON_WVMPURE InterlockedIncrement ( _Inout_ _Interlocked_operand_ LONG volatile *Addend ); LONG CDECL_NON_WVMPURE InterlockedDecrement ( _Inout_ _Interlocked_operand_ LONG volatile *Addend ); LONG __cdecl InterlockedExchange ( _Inout_ _Interlocked_operand_ LONG volatile *Target, _In_ LONG Value ); LONG __cdecl InterlockedExchangeAdd ( _Inout_ _Interlocked_operand_ LONG volatile *Addend, _In_ LONG Value ); FORCEINLINE LONG _InlineInterlockedAdd ( _Inout_ _Interlocked_operand_ LONG volatile *Addend, _In_ LONG Value ) { return InterlockedExchangeAdd(Addend, Value) + Value; } LONG CDECL_NON_WVMPURE InterlockedCompareExchange ( _Inout_ _Interlocked_operand_ LONG volatile * Destination, _In_ LONG ExChange, _In_ LONG Comperand ); #undef _InterlockedExchangePointer FORCEINLINE _Ret_writes_(_Inexpressible_(Unknown)) PVOID _InlineInterlockedExchangePointer( _Inout_ _At_(*Destination, _Pre_writable_byte_size_(_Inexpressible_(Unknown)) _Post_writable_byte_size_(_Inexpressible_(Unknown))) _Interlocked_operand_ PVOID volatile * Destination, _In_opt_ PVOID Value ) { return (PVOID)InterlockedExchange((LONG volatile *) Destination, (LONG) Value); } #define InterlockedExchangePointer _InlineInterlockedExchangePointer #define InterlockedExchangePointerAcquire _InlineInterlockedExchangePointer #define InterlockedExchangePointerRelease _InlineInterlockedExchangePointer #define InterlockedExchangePointerNoFence _InlineInterlockedExchangePointer FORCEINLINE _Ret_writes_(_Inexpressible_(Unknown)) PVOID _InlineInterlockedCompareExchangePointer ( _Inout_ _At_(*Destination, _Pre_writable_byte_size_(_Inexpressible_(Unknown)) _Post_writable_byte_size_(_Inexpressible_(Unknown))) _Interlocked_operand_ PVOID volatile * Destination, _In_opt_ PVOID ExChange, _In_opt_ PVOID Comperand ) { return (PVOID)InterlockedCompareExchange((LONG volatile *) Destination, (LONG) ExChange, (LONG) Comperand); } #define InterlockedCompareExchangePointer \ _InlineInterlockedCompareExchangePointer #define InterlockedCompareExchangePointerAcquire \ _InlineInterlockedCompareExchangePointer #define InterlockedCompareExchangePointerRelease \ _InlineInterlockedCompareExchangePointer #define InterlockedCompareExchangePointerNoFence \ _InlineInterlockedCompareExchangePointer #pragma intrinsic(_InterlockedAnd) #pragma intrinsic(_InterlockedOr) #pragma intrinsic(_InterlockedXor) #pragma intrinsic(_InterlockedIncrement) #pragma intrinsic(_InterlockedDecrement) #pragma intrinsic(_InterlockedExchange) #pragma intrinsic(_InterlockedExchangeAdd) #pragma intrinsic(_InterlockedCompareExchange) #if !defined(_MANAGED) #if (_MSC_VER >= 1600) #define InterlockedExchange8 _InterlockedExchange8 #define InterlockedExchange16 _InterlockedExchange16 CHAR InterlockedExchange8 ( _Inout_ _Interlocked_operand_ CHAR volatile *Target, _In_ CHAR Value ); SHORT InterlockedExchange16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT ExChange ); #pragma intrinsic(_InterlockedExchange8) #pragma intrinsic(_InterlockedExchange16) #endif // _MSC_VER >= 1600 #if _MSC_FULL_VER >= 140041204 #define InterlockedExchangeAdd8 _InterlockedExchangeAdd8 #define InterlockedAnd8 _InterlockedAnd8 #define InterlockedOr8 _InterlockedOr8 #define InterlockedXor8 _InterlockedXor8 #define InterlockedAnd16 _InterlockedAnd16 #define InterlockedOr16 _InterlockedOr16 #define InterlockedXor16 _InterlockedXor16 #define InterlockedCompareExchange16 _InterlockedCompareExchange16 #define InterlockedIncrement16 _InterlockedIncrement16 #define InterlockedDecrement16 _InterlockedDecrement16 char InterlockedExchangeAdd8 ( _Inout_ _Interlocked_operand_ char volatile * _Addend, _In_ char _Value ); char InterlockedAnd8 ( _Inout_ _Interlocked_operand_ char volatile *Destination, _In_ char Value ); char InterlockedOr8 ( _Inout_ _Interlocked_operand_ char volatile *Destination, _In_ char Value ); char InterlockedXor8 ( _Inout_ _Interlocked_operand_ char volatile *Destination, _In_ char Value ); SHORT _InterlockedAnd16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ); SHORT InterlockedXor16( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ); SHORT _InterlockedCompareExchange16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT ExChange, _In_ SHORT Comperand ); SHORT _InterlockedOr16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ); SHORT _InterlockedIncrement16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination ); SHORT _InterlockedDecrement16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination ); #pragma intrinsic (_InterlockedExchangeAdd8) #pragma intrinsic (_InterlockedAnd8) #pragma intrinsic (_InterlockedOr8) #pragma intrinsic (_InterlockedXor8) #pragma intrinsic (_InterlockedAnd16) #pragma intrinsic (_InterlockedOr16) #pragma intrinsic (_InterlockedXor16) #pragma intrinsic (_InterlockedCompareExchange16) #pragma intrinsic (_InterlockedIncrement16) #pragma intrinsic (_InterlockedDecrement16) #endif /* _MSC_FULL_VER >= 140040816 */ // // Define 64-bit operations in terms of InterlockedCompareExchange64 // #define InterlockedCompareExchange64 _InterlockedCompareExchange64 FORCEINLINE LONG64 _InlineInterlockedAnd64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { LONG64 Old; do { Old = *Destination; } while (InterlockedCompareExchange64(Destination, Old & Value, Old) != Old); return Old; } #define InterlockedAnd64 _InlineInterlockedAnd64 #define InterlockedAnd64Acquire _InlineInterlockedAnd64 #define InterlockedAnd64Release _InlineInterlockedAnd64 #define InterlockedAnd64NoFence _InlineInterlockedAnd64 FORCEINLINE LONG64 _InlineInterlockedAdd64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Addend, _In_ LONG64 Value ) { LONG64 Old; do { Old = *Addend; } while (InterlockedCompareExchange64(Addend, Old + Value, Old) != Old); return Old + Value; } #define InterlockedAdd64 _InlineInterlockedAdd64 #define InterlockedAddAcquire64 _InlineInterlockedAdd64 #define InterlockedAddRelease64 _InlineInterlockedAdd64 #define InterlockedAddNoFence64 _InlineInterlockedAdd64 #endif // !defined(_MANAGED) #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd((LONG *)a, b) #define InterlockedExchangeAddSizeTAcquire(a, b) InterlockedExchangeAdd((LONG *)a, b) #define InterlockedExchangeAddSizeTNoFence(a, b) InterlockedExchangeAdd((LONG *)a, b) #define InterlockedIncrementSizeT(a) InterlockedIncrement((LONG *)a) #define InterlockedIncrementSizeTNoFence(a) InterlockedIncrement((LONG *)a) #define InterlockedDecrementSizeT(a) InterlockedDecrement((LONG *)a) #define InterlockedDecrementSizeTNoFence(a) InterlockedDecrement((LONG *)a) // // Definitons below // LONG _InterlockedXor ( _Inout_ _Interlocked_operand_ LONG volatile *Target, _In_ LONG Set ); #pragma intrinsic(_InterlockedXor) #define InterlockedXor _InterlockedXor #if !defined(_MANAGED) LONGLONG FORCEINLINE _InlineInterlockedOr64 ( _Inout_ _Interlocked_operand_ LONGLONG volatile *Destination, _In_ LONGLONG Value ) { LONGLONG Old; do { Old = *Destination; } while (InterlockedCompareExchange64(Destination, Old | Value, Old) != Old); return Old; } #define InterlockedOr64 _InlineInterlockedOr64 FORCEINLINE LONG64 _InlineInterlockedXor64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { LONG64 Old; do { Old = *Destination; } while (InterlockedCompareExchange64(Destination, Old ^ Value, Old) != Old); return Old; } #define InterlockedXor64 _InlineInterlockedXor64 LONGLONG FORCEINLINE _InlineInterlockedIncrement64 ( _Inout_ _Interlocked_operand_ LONGLONG volatile *Addend ) { LONGLONG Old; do { Old = *Addend; } while (InterlockedCompareExchange64(Addend, Old + 1, Old) != Old); return Old + 1; } #define InterlockedIncrement64 _InlineInterlockedIncrement64 #define InterlockedIncrementAcquire64 InterlockedIncrement64 FORCEINLINE LONGLONG _InlineInterlockedDecrement64 ( _Inout_ _Interlocked_operand_ LONGLONG volatile *Addend ) { LONGLONG Old; do { Old = *Addend; } while (InterlockedCompareExchange64(Addend, Old - 1, Old) != Old); return Old - 1; } #define InterlockedDecrement64 _InlineInterlockedDecrement64 FORCEINLINE LONGLONG _InlineInterlockedExchange64 ( _Inout_ _Interlocked_operand_ LONGLONG volatile *Target, _In_ LONGLONG Value ) { LONGLONG Old; do { Old = *Target; } while (InterlockedCompareExchange64(Target, Value, Old) != Old); return Old; } #define InterlockedExchange64 _InlineInterlockedExchange64 #define InterlockedExchangeAcquire64 InterlockedExchange64 #define InterlockedExchangeNoFence64 _InlineInterlockedExchange64 FORCEINLINE LONGLONG _InlineInterlockedExchangeAdd64 ( _Inout_ _Interlocked_operand_ LONGLONG volatile *Addend, _In_ LONGLONG Value ) { LONGLONG Old; do { Old = *Addend; } while (InterlockedCompareExchange64(Addend, Old + Value, Old) != Old); return Old; } #define InterlockedExchangeAdd64 _InlineInterlockedExchangeAdd64 #define InterlockedExchangeAddNoFence64 _InlineInterlockedExchangeAdd64 // // FS relative adds and increments. // VOID __incfsbyte ( _In_ ULONG Offset ); VOID __addfsbyte ( _In_ ULONG Offset, _In_ UCHAR Value ); VOID __incfsword ( _In_ ULONG Offset ); VOID __addfsword ( _In_ ULONG Offset, _In_ USHORT Value ); VOID __incfsdword ( _In_ ULONG Offset ); VOID __addfsdword ( _In_ ULONG Offset, _In_ ULONG Value ); #pragma intrinsic(__incfsbyte) #pragma intrinsic(__addfsbyte) #pragma intrinsic(__incfsword) #pragma intrinsic(__addfsword) #pragma intrinsic(__incfsdword) #pragma intrinsic(__addfsdword) #endif // !defined(_MANAGED) #if !defined(_M_CEE_PURE) #if _MSC_VER >= 1500 // // Define extended CPUID intrinsic. // #define CpuIdEx __cpuidex VOID __cpuidex ( int CPUInfo[4], int Function, int SubLeaf ); #pragma intrinsic(__cpuidex) #endif // // Define FS read/write intrinsics // UCHAR __readfsbyte ( _In_ ULONG Offset ); USHORT __readfsword ( _In_ ULONG Offset ); ULONG __readfsdword ( _In_ ULONG Offset ); VOID __writefsbyte ( _In_ ULONG Offset, _In_ UCHAR Data ); VOID __writefsword ( _In_ ULONG Offset, _In_ USHORT Data ); VOID __writefsdword ( _In_ ULONG Offset, _In_ ULONG Data ); #pragma intrinsic(__readfsbyte) #pragma intrinsic(__readfsword) #pragma intrinsic(__readfsdword) #pragma intrinsic(__writefsbyte) #pragma intrinsic(__writefsword) #pragma intrinsic(__writefsdword) #endif // !defined(_M_CEE_PURE) #if !defined(_MANAGED) VOID _mm_pause ( VOID ); #pragma intrinsic(_mm_pause) #define YieldProcessor _mm_pause #endif // !defined(_MANAGED) #ifdef __cplusplus } #endif #endif /* !defined(MIDL_PASS) || defined(_M_IX86) */ #define MAXIMUM_SUPPORTED_EXTENSION 512 #if !defined(__midl) && !defined(MIDL_PASS) C_ASSERT(sizeof(XSAVE_FORMAT) == MAXIMUM_SUPPORTED_EXTENSION); #endif #if defined(_KERNEL_MODE) || defined(_BOOT_ENVIRONMENT) #define KI_USER_SHARED_DATA 0xffdf0000 #define SharedUserData ((KUSER_SHARED_DATA * const) KI_USER_SHARED_DATA) #endif #endif // _X86_ #ifdef _AMD64_ #if defined(_M_AMD64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) // // Define bit test intrinsics. // #ifdef __cplusplus extern "C" { #endif #define BitTest _bittest #define BitTestAndComplement _bittestandcomplement #define BitTestAndSet _bittestandset #define BitTestAndReset _bittestandreset #define InterlockedBitTestAndSet _interlockedbittestandset #define InterlockedBitTestAndSetAcquire _interlockedbittestandset #define InterlockedBitTestAndSetRelease _interlockedbittestandset #define InterlockedBitTestAndSetNoFence _interlockedbittestandset #define InterlockedBitTestAndReset _interlockedbittestandreset #define InterlockedBitTestAndResetAcquire _interlockedbittestandreset #define InterlockedBitTestAndResetRelease _interlockedbittestandreset #define InterlockedBitTestAndResetNoFence _interlockedbittestandreset #define BitTest64 _bittest64 #define BitTestAndComplement64 _bittestandcomplement64 #define BitTestAndSet64 _bittestandset64 #define BitTestAndReset64 _bittestandreset64 #define InterlockedBitTestAndSet64 _interlockedbittestandset64 #define InterlockedBitTestAndSet64Acquire _interlockedbittestandset64 #define InterlockedBitTestAndSet64Release _interlockedbittestandset64 #define InterlockedBitTestAndSet64NoFence _interlockedbittestandset64 #define InterlockedBitTestAndReset64 _interlockedbittestandreset64 #define InterlockedBitTestAndReset64Acquire _interlockedbittestandreset64 #define InterlockedBitTestAndReset64Release _interlockedbittestandreset64 #define InterlockedBitTestAndReset64NoFence _interlockedbittestandreset64 _Must_inspect_result_ BOOLEAN _bittest ( _In_reads_bytes_((Offset/8)+1) LONG const *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _bittestandcomplement ( _Inout_updates_bytes_((Offset/8)+1) LONG *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _bittestandset ( _Inout_updates_bytes_((Offset/8)+1) LONG *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _bittestandreset ( _Inout_updates_bytes_((Offset/8)+1) LONG *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _interlockedbittestandset ( _Inout_updates_bytes_((Offset/8)+1) _Interlocked_operand_ LONG volatile *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _interlockedbittestandreset ( _Inout_updates_bytes_((Offset/8)+1) _Interlocked_operand_ LONG volatile *Base, _In_range_(>=,0) LONG Offset ); BOOLEAN _bittest64 ( _In_reads_bytes_((Offset/8)+1) LONG64 const *Base, _In_range_(>=,0) LONG64 Offset ); BOOLEAN _bittestandcomplement64 ( _Inout_updates_bytes_((Offset/8)+1) LONG64 *Base, _In_range_(>=,0) LONG64 Offset ); BOOLEAN _bittestandset64 ( _Inout_updates_bytes_((Offset/8)+1) LONG64 *Base, _In_range_(>=,0) LONG64 Offset ); BOOLEAN _bittestandreset64 ( _Inout_updates_bytes_((Offset/8)+1) LONG64 *Base, _In_range_(>=,0) LONG64 Offset ); BOOLEAN _interlockedbittestandset64 ( _Inout_updates_bytes_((Offset/8)+1) _Interlocked_operand_ LONG64 volatile *Base, _In_range_(>=,0) LONG64 Offset ); BOOLEAN _interlockedbittestandreset64 ( _Inout_updates_bytes_((Offset/8)+1) _Interlocked_operand_ LONG64 volatile *Base, _In_range_(>=,0) LONG64 Offset ); #pragma intrinsic(_bittest) #pragma intrinsic(_bittestandcomplement) #pragma intrinsic(_bittestandset) #pragma intrinsic(_bittestandreset) #pragma intrinsic(_interlockedbittestandset) #pragma intrinsic(_interlockedbittestandreset) #pragma intrinsic(_bittest64) #pragma intrinsic(_bittestandcomplement64) #pragma intrinsic(_bittestandset64) #pragma intrinsic(_bittestandreset64) #pragma intrinsic(_interlockedbittestandset64) #pragma intrinsic(_interlockedbittestandreset64) // // Define bit scan intrinsics. // #define BitScanForward _BitScanForward #define BitScanReverse _BitScanReverse #define BitScanForward64 _BitScanForward64 #define BitScanReverse64 _BitScanReverse64 _Success_(return!=0) BOOLEAN _BitScanForward ( _Out_ ULONG *Index, _In_ ULONG Mask ); _Success_(return!=0) BOOLEAN _BitScanReverse ( _Out_ ULONG *Index, _In_ ULONG Mask ); _Success_(return!=0) BOOLEAN _BitScanForward64 ( _Out_ ULONG *Index, _In_ ULONG64 Mask ); _Success_(return!=0) BOOLEAN _BitScanReverse64 ( _Out_ ULONG *Index, _In_ ULONG64 Mask ); #pragma intrinsic(_BitScanForward) #pragma intrinsic(_BitScanReverse) #pragma intrinsic(_BitScanForward64) #pragma intrinsic(_BitScanReverse64) // // Interlocked intrinsic functions. // #define InterlockedIncrement16 _InterlockedIncrement16 #define InterlockedIncrementAcquire16 _InterlockedIncrement16 #define InterlockedIncrementRelease16 _InterlockedIncrement16 #define InterlockedIncrementNoFence16 _InterlockedIncrement16 #define InterlockedDecrement16 _InterlockedDecrement16 #define InterlockedDecrementAcquire16 _InterlockedDecrement16 #define InterlockedDecrementRelease16 _InterlockedDecrement16 #define InterlockedDecrementNoFence16 _InterlockedDecrement16 #define InterlockedCompareExchange16 _InterlockedCompareExchange16 #define InterlockedCompareExchangeAcquire16 _InterlockedCompareExchange16 #define InterlockedCompareExchangeRelease16 _InterlockedCompareExchange16 #define InterlockedCompareExchangeNoFence16 _InterlockedCompareExchange16 #define InterlockedAnd _InterlockedAnd #define InterlockedAndAcquire _InterlockedAnd #define InterlockedAndRelease _InterlockedAnd #define InterlockedAndNoFence _InterlockedAnd #define InterlockedOr _InterlockedOr #define InterlockedOrAcquire _InterlockedOr #define InterlockedOrRelease _InterlockedOr #define InterlockedOrNoFence _InterlockedOr #define InterlockedXor _InterlockedXor #define InterlockedXorAcquire _InterlockedXor #define InterlockedXorRelease _InterlockedXor #define InterlockedXorNoFence _InterlockedXor #define InterlockedIncrement _InterlockedIncrement #define InterlockedIncrementAcquire _InterlockedIncrement #define InterlockedIncrementRelease _InterlockedIncrement #define InterlockedIncrementNoFence _InterlockedIncrement #define InterlockedDecrement _InterlockedDecrement #define InterlockedDecrementAcquire _InterlockedDecrement #define InterlockedDecrementRelease _InterlockedDecrement #define InterlockedDecrementNoFence _InterlockedDecrement #define InterlockedAdd _InlineInterlockedAdd #define InterlockedAddAcquire _InlineInterlockedAdd #define InterlockedAddRelease _InlineInterlockedAdd #define InterlockedAddNoFence _InlineInterlockedAdd #define InterlockedExchange _InterlockedExchange #define InterlockedExchangeAcquire _InterlockedExchange #define InterlockedExchangeNoFence _InterlockedExchange #define InterlockedExchangeAdd _InterlockedExchangeAdd #define InterlockedExchangeAddAcquire _InterlockedExchangeAdd #define InterlockedExchangeAddRelease _InterlockedExchangeAdd #define InterlockedExchangeAddNoFence _InterlockedExchangeAdd #define InterlockedCompareExchange _InterlockedCompareExchange #define InterlockedCompareExchangeAcquire _InterlockedCompareExchange #define InterlockedCompareExchangeRelease _InterlockedCompareExchange #define InterlockedCompareExchangeNoFence _InterlockedCompareExchange #define InterlockedAnd64 _InterlockedAnd64 #define InterlockedAnd64Acquire _InterlockedAnd64 #define InterlockedAnd64Release _InterlockedAnd64 #define InterlockedAnd64NoFence _InterlockedAnd64 #define InterlockedAndAffinity InterlockedAnd64 #define InterlockedOr64 _InterlockedOr64 #define InterlockedOr64Acquire _InterlockedOr64 #define InterlockedOr64Release _InterlockedOr64 #define InterlockedOr64NoFence _InterlockedOr64 #define InterlockedOrAffinity InterlockedOr64 #define InterlockedXor64 _InterlockedXor64 #define InterlockedXor64Acquire _InterlockedXor64 #define InterlockedXor64Release _InterlockedXor64 #define InterlockedXor64NoFence _InterlockedXor64 #define InterlockedIncrement64 _InterlockedIncrement64 #define InterlockedIncrementAcquire64 _InterlockedIncrement64 #define InterlockedIncrementRelease64 _InterlockedIncrement64 #define InterlockedIncrementNoFence64 _InterlockedIncrement64 #define InterlockedDecrement64 _InterlockedDecrement64 #define InterlockedDecrementAcquire64 _InterlockedDecrement64 #define InterlockedDecrementRelease64 _InterlockedDecrement64 #define InterlockedDecrementNoFence64 _InterlockedDecrement64 #define InterlockedAdd64 _InlineInterlockedAdd64 #define InterlockedAddAcquire64 _InlineInterlockedAdd64 #define InterlockedAddRelease64 _InlineInterlockedAdd64 #define InterlockedAddNoFence64 _InlineInterlockedAdd64 #define InterlockedExchange64 _InterlockedExchange64 #define InterlockedExchangeAcquire64 InterlockedExchange64 #define InterlockedExchangeNoFence64 InterlockedExchange64 #define InterlockedExchangeAdd64 _InterlockedExchangeAdd64 #define InterlockedExchangeAddAcquire64 _InterlockedExchangeAdd64 #define InterlockedExchangeAddRelease64 _InterlockedExchangeAdd64 #define InterlockedExchangeAddNoFence64 _InterlockedExchangeAdd64 #define InterlockedCompareExchange64 _InterlockedCompareExchange64 #define InterlockedCompareExchangeAcquire64 InterlockedCompareExchange64 #define InterlockedCompareExchangeRelease64 InterlockedCompareExchange64 #define InterlockedCompareExchangeNoFence64 InterlockedCompareExchange64 #define InterlockedCompareExchange128 _InterlockedCompareExchange128 #define InterlockedExchangePointer _InterlockedExchangePointer #define InterlockedExchangePointerNoFence _InterlockedExchangePointer #define InterlockedExchangePointerAcquire _InterlockedExchangePointer #define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer #define InterlockedCompareExchangePointerAcquire _InterlockedCompareExchangePointer #define InterlockedCompareExchangePointerRelease _InterlockedCompareExchangePointer #define InterlockedCompareExchangePointerNoFence _InterlockedCompareExchangePointer #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd64((LONG64 *)a, b) #define InterlockedExchangeAddSizeTAcquire(a, b) InterlockedExchangeAdd64((LONG64 *)a, b) #define InterlockedExchangeAddSizeTNoFence(a, b) InterlockedExchangeAdd64((LONG64 *)a, b) #define InterlockedIncrementSizeT(a) InterlockedIncrement64((LONG64 *)a) #define InterlockedIncrementSizeTNoFence(a) InterlockedIncrement64((LONG64 *)a) #define InterlockedDecrementSizeT(a) InterlockedDecrement64((LONG64 *)a) #define InterlockedDecrementSizeTNoFence(a) InterlockedDecrement64((LONG64 *)a) SHORT InterlockedIncrement16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Addend ); SHORT InterlockedDecrement16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Addend ); SHORT InterlockedCompareExchange16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT ExChange, _In_ SHORT Comperand ); LONG InterlockedAnd ( _Inout_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ); LONG InterlockedOr ( _Inout_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ); LONG InterlockedXor ( _Inout_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ); LONG64 InterlockedAnd64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ); LONG64 InterlockedOr64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ); LONG64 InterlockedXor64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ); LONG InterlockedIncrement ( _Inout_ _Interlocked_operand_ LONG volatile *Addend ); LONG InterlockedDecrement ( _Inout_ _Interlocked_operand_ LONG volatile *Addend ); LONG InterlockedExchange ( _Inout_ _Interlocked_operand_ LONG volatile *Target, _In_ LONG Value ); LONG InterlockedExchangeAdd ( _Inout_ _Interlocked_operand_ LONG volatile *Addend, _In_ LONG Value ); #if !defined(_X86AMD64_) __forceinline LONG InterlockedAdd ( _Inout_ _Interlocked_operand_ LONG volatile *Addend, _In_ LONG Value ) { return InterlockedExchangeAdd(Addend, Value) + Value; } #endif LONG InterlockedCompareExchange ( _Inout_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG ExChange, _In_ LONG Comperand ); LONG64 InterlockedIncrement64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Addend ); LONG64 InterlockedDecrement64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Addend ); LONG64 InterlockedExchange64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Target, _In_ LONG64 Value ); LONG64 InterlockedExchangeAdd64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Addend, _In_ LONG64 Value ); #if !defined(_X86AMD64_) __forceinline LONG64 _InlineInterlockedAdd64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Addend, _In_ LONG64 Value ) { return InterlockedExchangeAdd64(Addend, Value) + Value; } #endif LONG64 InterlockedCompareExchange64 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 ExChange, _In_ LONG64 Comperand ); BOOLEAN InterlockedCompareExchange128 ( _Inout_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 ExchangeHigh, _In_ LONG64 ExchangeLow, _Inout_ LONG64 *ComparandResult ); _Ret_writes_(_Inexpressible_(Unknown)) PVOID InterlockedCompareExchangePointer ( _Inout_ _At_(*Destination, _Pre_writable_byte_size_(_Inexpressible_(Unknown)) _Post_writable_byte_size_(_Inexpressible_(Unknown))) _Interlocked_operand_ PVOID volatile *Destination, _In_opt_ PVOID Exchange, _In_opt_ PVOID Comperand ); _Ret_writes_(_Inexpressible_(Unknown)) PVOID InterlockedExchangePointer( _Inout_ _At_(*Target, _Pre_writable_byte_size_(_Inexpressible_(Unknown)) _Post_writable_byte_size_(_Inexpressible_(Unknown))) _Interlocked_operand_ PVOID volatile *Target, _In_opt_ PVOID Value ); #pragma intrinsic(_InterlockedIncrement16) #pragma intrinsic(_InterlockedDecrement16) #pragma intrinsic(_InterlockedCompareExchange16) #pragma intrinsic(_InterlockedAnd) #pragma intrinsic(_InterlockedOr) #pragma intrinsic(_InterlockedXor) #pragma intrinsic(_InterlockedIncrement) #pragma intrinsic(_InterlockedDecrement) #pragma intrinsic(_InterlockedExchange) #pragma intrinsic(_InterlockedExchangeAdd) #pragma intrinsic(_InterlockedCompareExchange) #pragma intrinsic(_InterlockedAnd64) #pragma intrinsic(_InterlockedOr64) #pragma intrinsic(_InterlockedXor64) #pragma intrinsic(_InterlockedIncrement64) #pragma intrinsic(_InterlockedDecrement64) #pragma intrinsic(_InterlockedExchange64) #pragma intrinsic(_InterlockedExchangeAdd64) #pragma intrinsic(_InterlockedCompareExchange64) #if _MSC_VER >= 1500 #pragma intrinsic(_InterlockedCompareExchange128) #endif #pragma intrinsic(_InterlockedExchangePointer) #pragma intrinsic(_InterlockedCompareExchangePointer) #if (_MSC_VER >= 1600) #define InterlockedExchange8 _InterlockedExchange8 #define InterlockedExchange16 _InterlockedExchange16 CHAR InterlockedExchange8 ( _Inout_ _Interlocked_operand_ CHAR volatile *Target, _In_ CHAR Value ); SHORT InterlockedExchange16 ( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT ExChange ); #pragma intrinsic(_InterlockedExchange8) #pragma intrinsic(_InterlockedExchange16) #endif /* _MSC_VER >= 1600 */ #if _MSC_FULL_VER >= 140041204 #define InterlockedExchangeAdd8 _InterlockedExchangeAdd8 #define InterlockedAnd8 _InterlockedAnd8 #define InterlockedOr8 _InterlockedOr8 #define InterlockedXor8 _InterlockedXor8 #define InterlockedAnd16 _InterlockedAnd16 #define InterlockedOr16 _InterlockedOr16 #define InterlockedXor16 _InterlockedXor16 char InterlockedExchangeAdd8 ( _Inout_ _Interlocked_operand_ char volatile * _Addend, _In_ char _Value ); char InterlockedAnd8 ( _Inout_ _Interlocked_operand_ char volatile *Destination, _In_ char Value ); char InterlockedOr8 ( _Inout_ _Interlocked_operand_ char volatile *Destination, _In_ char Value ); char InterlockedXor8 ( _Inout_ _Interlocked_operand_ char volatile *Destination, _In_ char Value ); SHORT InterlockedAnd16( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ); SHORT InterlockedOr16( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ); SHORT InterlockedXor16( _Inout_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ); #pragma intrinsic (_InterlockedExchangeAdd8) #pragma intrinsic (_InterlockedAnd8) #pragma intrinsic (_InterlockedOr8) #pragma intrinsic (_InterlockedXor8) #pragma intrinsic (_InterlockedAnd16) #pragma intrinsic (_InterlockedOr16) #pragma intrinsic (_InterlockedXor16) #endif // // Define extended CPUID intrinsic. // #define CpuIdEx __cpuidex VOID __cpuidex ( int CPUInfo[4], int Function, int SubLeaf ); #pragma intrinsic(__cpuidex) // // Define function to flush a cache line. // #define CacheLineFlush(Address) _mm_clflush(Address) VOID _mm_clflush ( _In_ VOID const *Address ); #pragma intrinsic(_mm_clflush) VOID _ReadWriteBarrier ( VOID ); #pragma intrinsic(_ReadWriteBarrier) // // Define memory fence intrinsics // #define FastFence __faststorefence #define LoadFence _mm_lfence #define MemoryFence _mm_mfence #define StoreFence _mm_sfence VOID __faststorefence ( VOID ); VOID _mm_lfence ( VOID ); VOID _mm_mfence ( VOID ); VOID _mm_sfence ( VOID ); VOID _mm_pause ( VOID ); VOID _mm_prefetch ( _In_ CHAR CONST *a, _In_ int sel ); VOID _m_prefetchw ( _In_ volatile CONST VOID *Source ); // // Define constants for use with _mm_prefetch. // #define _MM_HINT_T0 1 #define _MM_HINT_T1 2 #define _MM_HINT_T2 3 #define _MM_HINT_NTA 0 #pragma intrinsic(__faststorefence) #pragma intrinsic(_mm_pause) #pragma intrinsic(_mm_prefetch) #pragma intrinsic(_mm_lfence) #pragma intrinsic(_mm_mfence) #pragma intrinsic(_mm_sfence) #pragma intrinsic(_m_prefetchw) #define YieldProcessor _mm_pause #define MemoryBarrier __faststorefence #define PreFetchCacheLine(l, a) _mm_prefetch((CHAR CONST *) a, l) #define PrefetchForWrite(p) _m_prefetchw(p) #define ReadForWriteAccess(p) (_m_prefetchw(p), *(p)) // // PreFetchCacheLine level defines. // #define PF_TEMPORAL_LEVEL_1 _MM_HINT_T0 #define PF_TEMPORAL_LEVEL_2 _MM_HINT_T1 #define PF_TEMPORAL_LEVEL_3 _MM_HINT_T2 #define PF_NON_TEMPORAL_LEVEL_ALL _MM_HINT_NTA // // Define get/set MXCSR intrinsics. // #define ReadMxCsr _mm_getcsr #define WriteMxCsr _mm_setcsr unsigned int _mm_getcsr ( VOID ); VOID _mm_setcsr ( _In_ unsigned int MxCsr ); #pragma intrinsic(_mm_getcsr) #pragma intrinsic(_mm_setcsr) // // Define function to get the caller's EFLAGs value. // #define GetCallersEflags() __getcallerseflags() unsigned __int32 __getcallerseflags ( VOID ); #pragma intrinsic(__getcallerseflags) // // Define function to get segment limit. // #define GetSegmentLimit __segmentlimit ULONG __segmentlimit ( _In_ ULONG Selector ); #pragma intrinsic(__segmentlimit) // // Define function to read the value of a performance counter. // #define ReadPMC __readpmc ULONG64 __readpmc ( _In_ ULONG Counter ); #pragma intrinsic(__readpmc) // // Define function to read the value of the time stamp counter // #define ReadTimeStampCounter() __rdtsc() ULONG64 __rdtsc ( VOID ); #pragma intrinsic(__rdtsc) // // Define functions to move strings as bytes, words, dwords, and qwords. // VOID __movsb ( _Out_writes_all_(Count) PUCHAR Destination, _In_reads_(Count) UCHAR const *Source, _In_ SIZE_T Count ); VOID __movsw ( _Out_writes_all_(Count) PUSHORT Destination, _In_reads_(Count) USHORT const *Source, _In_ SIZE_T Count ); VOID __movsd ( _Out_writes_all_(Count) PULONG Destination, _In_reads_(Count) ULONG const *Source, _In_ SIZE_T Count ); VOID __movsq ( _Out_writes_all_(Count) PULONG64 Destination, _In_reads_(Count) ULONG64 const *Source, _In_ SIZE_T Count ); #pragma intrinsic(__movsb) #pragma intrinsic(__movsw) #pragma intrinsic(__movsd) #pragma intrinsic(__movsq) // // Define functions to store strings as bytes, words, dwords, and qwords. // VOID __stosb ( _Out_writes_all_(Count) PUCHAR Destination, _In_ UCHAR Value, _In_ SIZE_T Count ); VOID __stosw ( _Out_writes_all_(Count) PUSHORT Destination, _In_ USHORT Value, _In_ SIZE_T Count ); VOID __stosd ( _Out_writes_all_(Count) PULONG Destination, _In_ ULONG Value, _In_ SIZE_T Count ); VOID __stosq ( _Out_writes_all_(Count) PULONG64 Destination, _In_ ULONG64 Value, _In_ SIZE_T Count ); #pragma intrinsic(__stosb) #pragma intrinsic(__stosw) #pragma intrinsic(__stosd) #pragma intrinsic(__stosq) // // Define functions to capture the high 64-bits of a 128-bit multiply. // #define MultiplyHigh __mulh #define UnsignedMultiplyHigh __umulh LONGLONG MultiplyHigh ( _In_ LONG64 Multiplier, _In_ LONG64 Multiplicand ); ULONGLONG UnsignedMultiplyHigh ( _In_ ULONG64 Multiplier, _In_ ULONG64 Multiplicand ); #pragma intrinsic(__mulh) #pragma intrinsic(__umulh) // // Define population count intrinsic. // #define PopulationCount64 __popcnt64 ULONG64 PopulationCount64 ( _In_ ULONG64 operand ); #if _MSC_VER >= 1500 #pragma intrinsic(__popcnt64) #endif // // Define functions to perform 128-bit shifts // #define ShiftLeft128 __shiftleft128 #define ShiftRight128 __shiftright128 ULONG64 ShiftLeft128 ( _In_ ULONG64 LowPart, _In_ ULONG64 HighPart, _In_ UCHAR Shift ); ULONG64 ShiftRight128 ( _In_ ULONG64 LowPart, _In_ ULONG64 HighPart, _In_ UCHAR Shift ); #pragma intrinsic(__shiftleft128) #pragma intrinsic(__shiftright128) // // Define functions to perform 128-bit multiplies. // #define Multiply128 _mul128 LONG64 Multiply128 ( _In_ LONG64 Multiplier, _In_ LONG64 Multiplicand, _Out_ LONG64 *HighProduct ); #pragma intrinsic(_mul128) #ifndef UnsignedMultiply128 #define UnsignedMultiply128 _umul128 ULONG64 UnsignedMultiply128 ( _In_ ULONG64 Multiplier, _In_ ULONG64 Multiplicand, _Out_ ULONG64 *HighProduct ); #pragma intrinsic(_umul128) #endif __forceinline LONG64 MultiplyExtract128 ( _In_ LONG64 Multiplier, _In_ LONG64 Multiplicand, _In_ UCHAR Shift ) { LONG64 extractedProduct; LONG64 highProduct; LONG64 lowProduct; BOOLEAN negate; ULONG64 uhighProduct; ULONG64 ulowProduct; lowProduct = Multiply128(Multiplier, Multiplicand, &highProduct); negate = FALSE; uhighProduct = (ULONG64)highProduct; ulowProduct = (ULONG64)lowProduct; if (highProduct < 0) { negate = TRUE; uhighProduct = (ULONG64)(-highProduct); ulowProduct = (ULONG64)(-lowProduct); if (ulowProduct != 0) { uhighProduct -= 1; } } extractedProduct = (LONG64)ShiftRight128(ulowProduct, uhighProduct, Shift); if (negate != FALSE) { extractedProduct = -extractedProduct; } return extractedProduct; } __forceinline ULONG64 UnsignedMultiplyExtract128 ( _In_ ULONG64 Multiplier, _In_ ULONG64 Multiplicand, _In_ UCHAR Shift ) { ULONG64 extractedProduct; ULONG64 highProduct; ULONG64 lowProduct; lowProduct = UnsignedMultiply128(Multiplier, Multiplicand, &highProduct); extractedProduct = ShiftRight128(lowProduct, highProduct, Shift); return extractedProduct; } // // Define functions to read and write the uer TEB and the system PCR/PRCB. // UCHAR __readgsbyte ( _In_ ULONG Offset ); USHORT __readgsword ( _In_ ULONG Offset ); ULONG __readgsdword ( _In_ ULONG Offset ); ULONG64 __readgsqword ( _In_ ULONG Offset ); VOID __writegsbyte ( _In_ ULONG Offset, _In_ UCHAR Data ); VOID __writegsword ( _In_ ULONG Offset, _In_ USHORT Data ); VOID __writegsdword ( _In_ ULONG Offset, _In_ ULONG Data ); VOID __writegsqword ( _In_ ULONG Offset, _In_ ULONG64 Data ); #pragma intrinsic(__readgsbyte) #pragma intrinsic(__readgsword) #pragma intrinsic(__readgsdword) #pragma intrinsic(__readgsqword) #pragma intrinsic(__writegsbyte) #pragma intrinsic(__writegsword) #pragma intrinsic(__writegsdword) #pragma intrinsic(__writegsqword) #if !defined(_MANAGED) VOID __incgsbyte ( _In_ ULONG Offset ); VOID __addgsbyte ( _In_ ULONG Offset, _In_ UCHAR Value ); VOID __incgsword ( _In_ ULONG Offset ); VOID __addgsword ( _In_ ULONG Offset, _In_ USHORT Value ); VOID __incgsdword ( _In_ ULONG Offset ); VOID __addgsdword ( _In_ ULONG Offset, _In_ ULONG Value ); VOID __incgsqword ( _In_ ULONG Offset ); VOID __addgsqword ( _In_ ULONG Offset, _In_ ULONG64 Value ); #if 0 #pragma intrinsic(__incgsbyte) #pragma intrinsic(__addgsbyte) #pragma intrinsic(__incgsword) #pragma intrinsic(__addgsword) #pragma intrinsic(__incgsdword) #pragma intrinsic(__addgsdword) #pragma intrinsic(__incgsqword) #pragma intrinsic(__addgsqword) #endif #endif // !defined(_MANAGED) #ifdef __cplusplus } #endif #endif // defined(_M_AMD64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) typedef XSAVE_FORMAT XMM_SAVE_AREA32, *PXMM_SAVE_AREA32; #if defined(_KERNEL_MODE) || defined(_BOOT_ENVIRONMENT) #define KI_USER_SHARED_DATA 0xFFFFF78000000000UI64 #define SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA) #define SharedInterruptTime (KI_USER_SHARED_DATA + 0x8) #define SharedSystemTime (KI_USER_SHARED_DATA + 0x14) #define SharedTickCount (KI_USER_SHARED_DATA + 0x320) #define KeQueryInterruptTime() *((volatile ULONG64 *)(SharedInterruptTime)) #define KeQuerySystemTime(CurrentCount) \ *((PULONG64)(CurrentCount)) = *((volatile ULONG64 *)(SharedSystemTime)) #define KeQueryTickCount(CurrentCount) \ *((PULONG64)(CurrentCount)) = *((volatile ULONG64 *)(SharedTickCount)) #endif #endif // _AMD64_ #ifdef _ARM_ #if defined(_M_ARM) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #include #if !defined(_M_CEE_PURE) #ifdef __cplusplus extern "C" { #endif // // Memory barriers and prefetch intrinsics. // #pragma intrinsic(__yield) #pragma intrinsic(__prefetch) #if (_MSC_FULL_VER >= 170040825) #pragma intrinsic(__dmb) #pragma intrinsic(__dsb) #pragma intrinsic(__isb) #else #define __dmb(x) { __emit(0xF3BF); __emit(0x8F5F); } #define __dsb(x) { __emit(0xF3BF); __emit(0x8F4F); } #define __isb(x) { __emit(0xF3BF); __emit(0x8F6F); } #endif #pragma intrinsic(_ReadWriteBarrier) #pragma intrinsic(_WriteBarrier) FORCEINLINE VOID YieldProcessor ( VOID ) { __dmb(_ARM_BARRIER_ISHST); __yield(); } #define MemoryBarrier() __dmb(_ARM_BARRIER_SY) #define PreFetchCacheLine(l,a) __prefetch((const void *) (a)) #define PrefetchForWrite(p) __prefetch((const void *) (p)) #define ReadForWriteAccess(p) (*(p)) #define _DataSynchronizationBarrier() __dsb(_ARM_BARRIER_SY) #define _InstructionSynchronizationBarrier() __isb(_ARM_BARRIER_SY) // // Define bit test intrinsics. // #define BitTest _bittest #define BitTestAndComplement _bittestandcomplement #define BitTestAndSet _bittestandset #define BitTestAndReset _bittestandreset #define InterlockedBitTestAndSet _interlockedbittestandset #define InterlockedBitTestAndSetAcquire _interlockedbittestandset_acq #define InterlockedBitTestAndSetRelease _interlockedbittestandset_rel #define InterlockedBitTestAndSetNoFence _interlockedbittestandset_nf #define InterlockedBitTestAndReset _interlockedbittestandreset #define InterlockedBitTestAndResetAcquire _interlockedbittestandreset_acq #define InterlockedBitTestAndResetRelease _interlockedbittestandreset_rel #define InterlockedBitTestAndResetNoFence _interlockedbittestandreset_nf #pragma intrinsic(_bittest) #pragma intrinsic(_bittestandcomplement) #pragma intrinsic(_bittestandset) #pragma intrinsic(_bittestandreset) #pragma intrinsic(_interlockedbittestandset) #pragma intrinsic(_interlockedbittestandset_acq) #pragma intrinsic(_interlockedbittestandset_rel) #pragma intrinsic(_interlockedbittestandset_nf) #pragma intrinsic(_interlockedbittestandreset) #pragma intrinsic(_interlockedbittestandreset_acq) #pragma intrinsic(_interlockedbittestandreset_rel) #pragma intrinsic(_interlockedbittestandreset_nf) // // Define bit scan functions // #define BitScanForward _BitScanForward #define BitScanReverse _BitScanReverse #pragma intrinsic(_BitScanForward) #pragma intrinsic(_BitScanReverse) // // Interlocked intrinsic functions. // #pragma intrinsic(_InterlockedAnd8) #pragma intrinsic(_InterlockedOr8) #pragma intrinsic(_InterlockedXor8) #pragma intrinsic(_InterlockedExchangeAdd8) #pragma intrinsic(_InterlockedAnd16) #pragma intrinsic(_InterlockedOr16) #pragma intrinsic(_InterlockedXor16) #pragma intrinsic(_InterlockedIncrement16) #pragma intrinsic(_InterlockedDecrement16) #pragma intrinsic(_InterlockedCompareExchange16) #pragma intrinsic(_InterlockedAnd) #pragma intrinsic(_InterlockedOr) #pragma intrinsic(_InterlockedXor) #pragma intrinsic(_InterlockedIncrement) #pragma intrinsic(_InterlockedDecrement) #pragma intrinsic(_InterlockedExchange) #pragma intrinsic(_InterlockedExchangeAdd) #pragma intrinsic(_InterlockedCompareExchange) #pragma intrinsic(_InterlockedAnd64) #pragma intrinsic(_InterlockedOr64) #pragma intrinsic(_InterlockedXor64) #pragma intrinsic(_InterlockedIncrement64) #pragma intrinsic(_InterlockedDecrement64) #pragma intrinsic(_InterlockedExchange64) #pragma intrinsic(_InterlockedCompareExchange64) #pragma intrinsic(_InterlockedExchangePointer) #pragma intrinsic(_InterlockedCompareExchangePointer) #define InterlockedAnd8 _InterlockedAnd8 #define InterlockedOr8 _InterlockedOr8 #define InterlockedXor8 _InterlockedXor8 #define InterlockedExchangeAdd8 _InterlockedExchangeAdd8 #define InterlockedAnd16 _InterlockedAnd16 #define InterlockedOr16 _InterlockedOr16 #define InterlockedXor16 _InterlockedXor16 #define InterlockedIncrement16 _InterlockedIncrement16 #define InterlockedDecrement16 _InterlockedDecrement16 #define InterlockedCompareExchange16 _InterlockedCompareExchange16 #define InterlockedAnd _InterlockedAnd #define InterlockedOr _InterlockedOr #define InterlockedXor _InterlockedXor #define InterlockedIncrement _InterlockedIncrement #define InterlockedDecrement _InterlockedDecrement #define InterlockedAdd _InterlockedAdd #define InterlockedExchange _InterlockedExchange #define InterlockedExchangeAdd _InterlockedExchangeAdd #define InterlockedCompareExchange _InterlockedCompareExchange #define InterlockedAnd64 _InterlockedAnd64 #define InterlockedAndAffinity InterlockedAnd64 #define InterlockedOr64 _InterlockedOr64 #define InterlockedOrAffinity InterlockedOr64 #define InterlockedXor64 _InterlockedXor64 #define InterlockedIncrement64 _InterlockedIncrement64 #define InterlockedDecrement64 _InterlockedDecrement64 #define InterlockedAdd64 _InterlockedAdd64 #define InterlockedExchange64 _InterlockedExchange64 #define InterlockedExchangeAdd64 _InterlockedExchangeAdd64 #define InterlockedCompareExchange64 _InterlockedCompareExchange64 #define InterlockedExchangePointer _InterlockedExchangePointer #define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer #pragma intrinsic(_InterlockedExchange16) #define InterlockedExchange16 _InterlockedExchange16 #pragma intrinsic(_InterlockedAnd8_acq) #pragma intrinsic(_InterlockedAnd8_rel) #pragma intrinsic(_InterlockedAnd8_nf) #pragma intrinsic(_InterlockedOr8_acq) #pragma intrinsic(_InterlockedOr8_rel) #pragma intrinsic(_InterlockedOr8_nf) #pragma intrinsic(_InterlockedXor8_acq) #pragma intrinsic(_InterlockedXor8_rel) #pragma intrinsic(_InterlockedXor8_nf) #pragma intrinsic(_InterlockedAnd16_acq) #pragma intrinsic(_InterlockedAnd16_rel) #pragma intrinsic(_InterlockedAnd16_nf) #pragma intrinsic(_InterlockedOr16_acq) #pragma intrinsic(_InterlockedOr16_rel) #pragma intrinsic(_InterlockedOr16_nf) #pragma intrinsic(_InterlockedXor16_acq) #pragma intrinsic(_InterlockedXor16_rel) #pragma intrinsic(_InterlockedXor16_nf) #pragma intrinsic(_InterlockedIncrement16_acq) #pragma intrinsic(_InterlockedIncrement16_rel) #pragma intrinsic(_InterlockedIncrement16_nf) #pragma intrinsic(_InterlockedDecrement16_acq) #pragma intrinsic(_InterlockedDecrement16_rel) #pragma intrinsic(_InterlockedDecrement16_nf) #pragma intrinsic(_InterlockedExchange16_acq) #pragma intrinsic(_InterlockedExchange16_nf) #pragma intrinsic(_InterlockedCompareExchange16_acq) #pragma intrinsic(_InterlockedCompareExchange16_rel) #pragma intrinsic(_InterlockedCompareExchange16_nf) #pragma intrinsic(_InterlockedAnd_acq) #pragma intrinsic(_InterlockedAnd_rel) #pragma intrinsic(_InterlockedAnd_nf) #pragma intrinsic(_InterlockedOr_acq) #pragma intrinsic(_InterlockedOr_rel) #pragma intrinsic(_InterlockedOr_nf) #pragma intrinsic(_InterlockedXor_acq) #pragma intrinsic(_InterlockedXor_rel) #pragma intrinsic(_InterlockedXor_nf) #pragma intrinsic(_InterlockedIncrement_acq) #pragma intrinsic(_InterlockedIncrement_rel) #pragma intrinsic(_InterlockedIncrement_nf) #pragma intrinsic(_InterlockedDecrement_acq) #pragma intrinsic(_InterlockedDecrement_rel) #pragma intrinsic(_InterlockedDecrement_nf) #pragma intrinsic(_InterlockedExchange_acq) #pragma intrinsic(_InterlockedExchange_nf) #pragma intrinsic(_InterlockedExchangeAdd_acq) #pragma intrinsic(_InterlockedExchangeAdd_rel) #pragma intrinsic(_InterlockedExchangeAdd_nf) #pragma intrinsic(_InterlockedCompareExchange_acq) #pragma intrinsic(_InterlockedCompareExchange_rel) #pragma intrinsic(_InterlockedCompareExchange_nf) #pragma intrinsic(_InterlockedAnd64_acq) #pragma intrinsic(_InterlockedAnd64_rel) #pragma intrinsic(_InterlockedAnd64_nf) #pragma intrinsic(_InterlockedOr64_acq) #pragma intrinsic(_InterlockedOr64_rel) #pragma intrinsic(_InterlockedOr64_nf) #pragma intrinsic(_InterlockedXor64_acq) #pragma intrinsic(_InterlockedXor64_rel) #pragma intrinsic(_InterlockedXor64_nf) #pragma intrinsic(_InterlockedIncrement64_acq) #pragma intrinsic(_InterlockedIncrement64_rel) #pragma intrinsic(_InterlockedIncrement64_nf) #pragma intrinsic(_InterlockedDecrement64_acq) #pragma intrinsic(_InterlockedDecrement64_rel) #pragma intrinsic(_InterlockedDecrement64_nf) #pragma intrinsic(_InterlockedExchange64_acq) #pragma intrinsic(_InterlockedExchange64_nf) #pragma intrinsic(_InterlockedCompareExchange64_acq) #pragma intrinsic(_InterlockedCompareExchange64_rel) #pragma intrinsic(_InterlockedCompareExchange64_nf) #pragma intrinsic(_InterlockedExchangePointer_acq) #pragma intrinsic(_InterlockedExchangePointer_nf) #pragma intrinsic(_InterlockedCompareExchangePointer_acq) #pragma intrinsic(_InterlockedCompareExchangePointer_rel) #pragma intrinsic(_InterlockedCompareExchangePointer_nf) #define InterlockedAndAcquire8 _InterlockedAnd8_acq #define InterlockedAndRelease8 _InterlockedAnd8_rel #define InterlockedAndNoFence8 _InterlockedAnd8_nf #define InterlockedOrAcquire8 _InterlockedOr8_acq #define InterlockedOrRelease8 _InterlockedOr8_rel #define InterlockedOrNoFence8 _InterlockedOr8_nf #define InterlockedXorAcquire8 _InterlockedXor8_acq #define InterlockedXorRelease8 _InterlockedXor8_rel #define InterlockedXorNoFence8 _InterlockedXor8_nf #define InterlockedAndAcquire16 _InterlockedAnd16_acq #define InterlockedAndRelease16 _InterlockedAnd16_rel #define InterlockedAndNoFence16 _InterlockedAnd16_nf #define InterlockedOrAcquire16 _InterlockedOr16_acq #define InterlockedOrRelease16 _InterlockedOr16_rel #define InterlockedOrNoFence16 _InterlockedOr16_nf #define InterlockedXorAcquire16 _InterlockedXor16_acq #define InterlockedXorRelease16 _InterlockedXor16_rel #define InterlockedXorNoFence16 _InterlockedXor16_nf #define InterlockedIncrementAcquire16 _InterlockedIncrement16_acq #define InterlockedIncrementRelease16 _InterlockedIncrement16_rel #define InterlockedIncrementNoFence16 _InterlockedIncrement16_nf #define InterlockedDecrementAcquire16 _InterlockedDecrement16_acq #define InterlockedDecrementRelease16 _InterlockedDecrement16_rel #define InterlockedDecrementNoFence16 _InterlockedDecrement16_nf #define InterlockedExchangeAcquire16 _InterlockedExchange16_acq #define InterlockedExchangeNoFence16 _InterlockedExchange16_nf #define InterlockedCompareExchangeAcquire16 _InterlockedCompareExchange16_acq #define InterlockedCompareExchangeRelease16 _InterlockedCompareExchange16_rel #define InterlockedCompareExchangeNoFence16 _InterlockedCompareExchange16_nf #define InterlockedAndAcquire _InterlockedAnd_acq #define InterlockedAndRelease _InterlockedAnd_rel #define InterlockedAndNoFence _InterlockedAnd_nf #define InterlockedOrAcquire _InterlockedOr_acq #define InterlockedOrRelease _InterlockedOr_rel #define InterlockedOrNoFence _InterlockedOr_nf #define InterlockedXorAcquire _InterlockedXor_acq #define InterlockedXorRelease _InterlockedXor_rel #define InterlockedXorNoFence _InterlockedXor_nf #define InterlockedIncrementAcquire _InterlockedIncrement_acq #define InterlockedIncrementRelease _InterlockedIncrement_rel #define InterlockedIncrementNoFence _InterlockedIncrement_nf #define InterlockedDecrementAcquire _InterlockedDecrement_acq #define InterlockedDecrementRelease _InterlockedDecrement_rel #define InterlockedDecrementNoFence _InterlockedDecrement_nf #define InterlockedAddAcquire _InterlockedAdd_acq #define InterlockedAddRelease _InterlockedAdd_rel #define InterlockedAddNoFence _InterlockedAdd_nf #define InterlockedExchangeAcquire _InterlockedExchange_acq #define InterlockedExchangeNoFence _InterlockedExchange_nf #define InterlockedExchangeAddAcquire _InterlockedExchangeAdd_acq #define InterlockedExchangeAddRelease _InterlockedExchangeAdd_rel #define InterlockedExchangeAddNoFence _InterlockedExchangeAdd_nf #define InterlockedCompareExchangeAcquire _InterlockedCompareExchange_acq #define InterlockedCompareExchangeRelease _InterlockedCompareExchange_rel #define InterlockedCompareExchangeNoFence _InterlockedCompareExchange_nf #define InterlockedAndAcquire64 _InterlockedAnd64_acq #define InterlockedAndRelease64 _InterlockedAnd64_rel #define InterlockedAndNoFence64 _InterlockedAnd64_nf #define InterlockedOrAcquire64 _InterlockedOr64_acq #define InterlockedOrRelease64 _InterlockedOr64_rel #define InterlockedOrNoFence64 _InterlockedOr64_nf #define InterlockedXorAcquire64 _InterlockedXor64_acq #define InterlockedXorRelease64 _InterlockedXor64_rel #define InterlockedXorNoFence64 _InterlockedXor64_nf #define InterlockedIncrementAcquire64 _InterlockedIncrement64_acq #define InterlockedIncrementRelease64 _InterlockedIncrement64_rel #define InterlockedIncrementNoFence64 _InterlockedIncrement64_nf #define InterlockedDecrementAcquire64 _InterlockedDecrement64_acq #define InterlockedDecrementRelease64 _InterlockedDecrement64_rel #define InterlockedDecrementNoFence64 _InterlockedDecrement64_nf #define InterlockedAddAcquire64 _InterlockedAdd64_acq #define InterlockedAddRelease64 _InterlockedAdd64_rel #define InterlockedAddNoFence64 _InterlockedAdd64_nf #define InterlockedExchangeAcquire64 _InterlockedExchange64_acq #define InterlockedExchangeNoFence64 _InterlockedExchange64_nf #define InterlockedExchangeAddAcquire64 _InterlockedExchangeAdd64_acq #define InterlockedExchangeAddRelease64 _InterlockedExchangeAdd64_rel #define InterlockedExchangeAddNoFence64 _InterlockedExchangeAdd64_nf #define InterlockedCompareExchangeAcquire64 _InterlockedCompareExchange64_acq #define InterlockedCompareExchangeRelease64 _InterlockedCompareExchange64_rel #define InterlockedCompareExchangeNoFence64 _InterlockedCompareExchange64_nf #define InterlockedExchangePointerAcquire _InterlockedExchangePointer_acq #define InterlockedExchangePointerNoFence _InterlockedExchangePointer_nf #define InterlockedCompareExchangePointerAcquire _InterlockedCompareExchangePointer_acq #define InterlockedCompareExchangePointerRelease _InterlockedCompareExchangePointer_rel #define InterlockedCompareExchangePointerNoFence _InterlockedCompareExchangePointer_nf #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd((LONG *)a, b) #define InterlockedExchangeAddSizeTAcquire(a, b) InterlockedExchangeAddAcquire((LONG *)a, b) #define InterlockedExchangeAddSizeTNoFence(a, b) InterlockedExchangeAddNoFence((LONG *)a, b) #define InterlockedIncrementSizeT(a) InterlockedIncrement((LONG *)a) #define InterlockedIncrementSizeTNoFence(a) InterlockedIncrementNoFence((LONG *)a) #define InterlockedDecrementSizeT(a) InterlockedDecrement((LONG *)a) #define InterlockedDecrementSizeTNoFence(a) InterlockedDecrementNoFence((LONG *)a) // // Define accessors for volatile loads and stores. // #pragma intrinsic(__iso_volatile_load8) #pragma intrinsic(__iso_volatile_load16) #pragma intrinsic(__iso_volatile_load32) #pragma intrinsic(__iso_volatile_load64) #pragma intrinsic(__iso_volatile_store8) #pragma intrinsic(__iso_volatile_store16) #pragma intrinsic(__iso_volatile_store32) #pragma intrinsic(__iso_volatile_store64) FORCEINLINE CHAR ReadAcquire8 ( _In_ _Interlocked_operand_ CHAR const volatile *Source ) { CHAR Value; Value = __iso_volatile_load8(Source); __dmb(_ARM_BARRIER_ISH); return Value; } FORCEINLINE CHAR ReadNoFence8 ( _In_ _Interlocked_operand_ CHAR const volatile *Source ) { CHAR Value; Value = __iso_volatile_load8(Source); return Value; } FORCEINLINE VOID WriteRelease8 ( _Out_ _Interlocked_operand_ CHAR volatile *Destination, _In_ CHAR Value ) { __dmb(_ARM_BARRIER_ISH); __iso_volatile_store8(Destination, Value); return; } FORCEINLINE VOID WriteNoFence8 ( _Out_ _Interlocked_operand_ CHAR volatile *Destination, _In_ CHAR Value ) { __iso_volatile_store8(Destination, Value); return; } FORCEINLINE SHORT ReadAcquire16 ( _In_ _Interlocked_operand_ SHORT const volatile *Source ) { SHORT Value; Value = __iso_volatile_load16(Source); __dmb(_ARM_BARRIER_ISH); return Value; } FORCEINLINE SHORT ReadNoFence16 ( _In_ _Interlocked_operand_ SHORT const volatile *Source ) { SHORT Value; Value = __iso_volatile_load16(Source); return Value; } FORCEINLINE VOID WriteRelease16 ( _Out_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ) { __dmb(_ARM_BARRIER_ISH); __iso_volatile_store16(Destination, Value); return; } FORCEINLINE VOID WriteNoFence16 ( _Out_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ) { __iso_volatile_store16(Destination, Value); return; } FORCEINLINE LONG ReadAcquire ( _In_ _Interlocked_operand_ LONG const volatile *Source ) { LONG Value; Value = __iso_volatile_load32((int *)Source); __dmb(_ARM_BARRIER_ISH); return Value; } FORCEINLINE LONG ReadNoFence ( _In_ _Interlocked_operand_ LONG const volatile *Source ) { LONG Value; Value = __iso_volatile_load32((int *)Source); return Value; } CFORCEINLINE VOID WriteRelease ( _Out_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ) { __dmb(_ARM_BARRIER_ISH); __iso_volatile_store32((int *)Destination, Value); return; } FORCEINLINE VOID WriteNoFence ( _Out_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ) { __iso_volatile_store32((int *)Destination, Value); return; } FORCEINLINE LONG64 ReadAcquire64 ( _In_ _Interlocked_operand_ LONG64 const volatile *Source ) { LONG64 Value; Value = __iso_volatile_load64(Source); __dmb(_ARM_BARRIER_ISH); return Value; } FORCEINLINE LONG64 ReadNoFence64 ( _In_ _Interlocked_operand_ LONG64 const volatile *Source ) { LONG64 Value; Value = __iso_volatile_load64(Source); return Value; } CFORCEINLINE VOID WriteRelease64 ( _Out_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { __dmb(_ARM_BARRIER_ISH); __iso_volatile_store64(Destination, Value); return; } FORCEINLINE VOID WriteNoFence64 ( _Out_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { __iso_volatile_store64(Destination, Value); return; } // // Define coprocessor access intrinsics. Coprocessor 15 contains // registers for the MMU, cache, TLB, feature bits, core // identification and performance counters. // #define CP15_PMSELR 15, 0, 9, 12, 5 // Event Counter Selection Register #define CP15_PMXEVCNTR 15, 0, 9, 13, 2 // Event Count Register #define CP15_TPIDRURW 15, 0, 13, 0, 2 // Software Thread ID Register, User Read/Write #define CP15_TPIDRURO 15, 0, 13, 0, 3 // Software Thread ID Register, User Read Only #define CP15_TPIDRPRW 15, 0, 13, 0, 4 // Software Thread ID Register, Privileged Only #pragma intrinsic(_MoveToCoprocessor) #pragma intrinsic(_MoveFromCoprocessor) // // Coprocessor registers for synchronization // #define _InvalidateBTAC() _MoveToCoprocessor(0, CP15_BPIALL) // // PreFetchCacheLine level defines. // #define PF_TEMPORAL_LEVEL_1 0 #define PF_TEMPORAL_LEVEL_2 1 #define PF_TEMPORAL_LEVEL_3 2 #define PF_NON_TEMPORAL_LEVEL_ALL 3 // // Define function to read the value of the time stamp counter which // ARM doesn't have. // ULONG64 ReadTimeStampCounter( VOID ); FORCEINLINE ULONG64 ReadPMC ( _In_ ULONG Counter ) { _MoveToCoprocessor(Counter, CP15_PMSELR); return (ULONG64)_MoveFromCoprocessor(CP15_PMXEVCNTR); } #ifdef __cplusplus } #endif #endif // !defined(_M_CEE_PURE) #endif // defined(_M_ARM) && !defined(RC_INVOKED) && !defined(MIDL_PASS) && !defined(_M_CEE_PURE) #if defined(_M_CEE_PURE) FORCEINLINE VOID YieldProcessor ( VOID ) { } #endif #if defined(_KERNEL_MODE) || defined(_BOOT_ENVIRONMENT) #define KI_USER_SHARED_DATA 0xFFFF9000 #define SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA) #endif #endif // _ARM_ #ifdef _ARM64_ #if defined(_M_ARM64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #include #if !defined(_M_CEE_PURE) #pragma intrinsic(__getReg) #pragma intrinsic(__getCallerReg) #pragma intrinsic(__getRegFp) #pragma intrinsic(__getCallerRegFp) #pragma intrinsic(__setReg) #pragma intrinsic(__setCallerReg) #pragma intrinsic(__setRegFp) #pragma intrinsic(__setCallerRegFp) #pragma intrinsic(__readx18byte) #pragma intrinsic(__readx18word) #pragma intrinsic(__readx18dword) #pragma intrinsic(__readx18qword) #pragma intrinsic(__writex18byte) #pragma intrinsic(__writex18word) #pragma intrinsic(__writex18dword) #pragma intrinsic(__writex18qword) #pragma intrinsic(__addx18byte) #pragma intrinsic(__addx18word) #pragma intrinsic(__addx18dword) #pragma intrinsic(__addx18qword) #pragma intrinsic(__incx18byte) #pragma intrinsic(__incx18word) #pragma intrinsic(__incx18dword) #pragma intrinsic(__incx18qword) #ifdef __cplusplus extern "C" { #endif // // Memory barriers and prefetch intrinsics. // #pragma intrinsic(__yield) #pragma intrinsic(__prefetch) #pragma intrinsic(__dmb) #pragma intrinsic(__dsb) #pragma intrinsic(__isb) #pragma intrinsic(_ReadWriteBarrier) #pragma intrinsic(_WriteBarrier) FORCEINLINE VOID YieldProcessor ( VOID ) { __dmb(_ARM64_BARRIER_ISHST); __yield(); } #define MemoryBarrier() __dmb(_ARM64_BARRIER_SY) #define PreFetchCacheLine(l,a) __prefetch((const void *) (a)) #define PrefetchForWrite(p) __prefetch((const void *) (p)) #define ReadForWriteAccess(p) (*(p)) #define _DataSynchronizationBarrier() __dsb(_ARM64_BARRIER_SY) #define _InstructionSynchronizationBarrier() __isb(_ARM64_BARRIER_SY) // // Define bit test intrinsics. // #define BitTest _bittest #define BitTestAndComplement _bittestandcomplement #define BitTestAndSet _bittestandset #define BitTestAndReset _bittestandreset #define InterlockedBitTestAndSet _interlockedbittestandset #define InterlockedBitTestAndSetAcquire _interlockedbittestandset_acq #define InterlockedBitTestAndSetRelease _interlockedbittestandset_rel #define InterlockedBitTestAndSetNoFence _interlockedbittestandset_nf #define InterlockedBitTestAndReset _interlockedbittestandreset #define InterlockedBitTestAndResetAcquire _interlockedbittestandreset_acq #define InterlockedBitTestAndResetRelease _interlockedbittestandreset_rel #define InterlockedBitTestAndResetNoFence _interlockedbittestandreset_nf #define BitTest64 _bittest64 #define BitTestAndComplement64 _bittestandcomplement64 #define BitTestAndSet64 _bittestandset64 #define BitTestAndReset64 _bittestandreset64 #define InterlockedBitTestAndSet64 _interlockedbittestandset64 #define InterlockedBitTestAndSet64Acquire _interlockedbittestandset64 #define InterlockedBitTestAndSet64Release _interlockedbittestandset64 #define InterlockedBitTestAndReset64 _interlockedbittestandreset64 #define InterlockedBitTestAndReset64Acquire _interlockedbittestandreset64 #define InterlockedBitTestAndReset64Release _interlockedbittestandreset64 #pragma intrinsic(_bittest) #pragma intrinsic(_bittestandcomplement) #pragma intrinsic(_bittestandset) #pragma intrinsic(_bittestandreset) #pragma intrinsic(_interlockedbittestandset) #pragma intrinsic(_interlockedbittestandset_acq) #pragma intrinsic(_interlockedbittestandset_rel) #pragma intrinsic(_interlockedbittestandreset) #pragma intrinsic(_interlockedbittestandreset_acq) #pragma intrinsic(_interlockedbittestandreset_rel) #pragma intrinsic(_bittest64) #pragma intrinsic(_bittestandcomplement64) #pragma intrinsic(_bittestandset64) #pragma intrinsic(_bittestandreset64) #pragma intrinsic(_interlockedbittestandset64) #pragma intrinsic(_interlockedbittestandset64_acq) #pragma intrinsic(_interlockedbittestandset64_rel) #pragma intrinsic(_interlockedbittestandreset64) #pragma intrinsic(_interlockedbittestandreset64_acq) #pragma intrinsic(_interlockedbittestandreset64_rel) // // Define bit scan functions // #define BitScanForward _BitScanForward #define BitScanReverse _BitScanReverse #define BitScanForward64 _BitScanForward64 #define BitScanReverse64 _BitScanReverse64 #pragma intrinsic(_BitScanForward) #pragma intrinsic(_BitScanReverse) #pragma intrinsic(_BitScanForward64) #pragma intrinsic(_BitScanReverse64) // // Interlocked intrinsic functions. // #pragma intrinsic(_InterlockedAnd8) #pragma intrinsic(_InterlockedOr8) #pragma intrinsic(_InterlockedXor8) #pragma intrinsic(_InterlockedExchangeAdd8) #pragma intrinsic(_InterlockedAnd16) #pragma intrinsic(_InterlockedOr16) #pragma intrinsic(_InterlockedXor16) #pragma intrinsic(_InterlockedIncrement16) #pragma intrinsic(_InterlockedDecrement16) #pragma intrinsic(_InterlockedCompareExchange16) #pragma intrinsic(_InterlockedAnd) #pragma intrinsic(_InterlockedOr) #pragma intrinsic(_InterlockedXor) #pragma intrinsic(_InterlockedIncrement) #pragma intrinsic(_InterlockedDecrement) #pragma intrinsic(_InterlockedExchange) #pragma intrinsic(_InterlockedExchangeAdd) #pragma intrinsic(_InterlockedCompareExchange) #pragma intrinsic(_InterlockedAnd64) #pragma intrinsic(_InterlockedOr64) #pragma intrinsic(_InterlockedXor64) #pragma intrinsic(_InterlockedIncrement64) #pragma intrinsic(_InterlockedDecrement64) #pragma intrinsic(_InterlockedExchange64) #pragma intrinsic(_InterlockedCompareExchange64) #pragma intrinsic(_InterlockedCompareExchange128) #pragma intrinsic(_InterlockedExchangePointer) #pragma intrinsic(_InterlockedCompareExchangePointer) #define InterlockedAnd8 _InterlockedAnd8 #define InterlockedOr8 _InterlockedOr8 #define InterlockedXor8 _InterlockedXor8 #define InterlockedExchangeAdd8 _InterlockedExchangeAdd8 #define InterlockedAnd16 _InterlockedAnd16 #define InterlockedOr16 _InterlockedOr16 #define InterlockedXor16 _InterlockedXor16 #define InterlockedIncrement16 _InterlockedIncrement16 #define InterlockedDecrement16 _InterlockedDecrement16 #define InterlockedCompareExchange16 _InterlockedCompareExchange16 #define InterlockedAnd _InterlockedAnd #define InterlockedOr _InterlockedOr #define InterlockedXor _InterlockedXor #define InterlockedIncrement _InterlockedIncrement #define InterlockedDecrement _InterlockedDecrement #define InterlockedAdd _InterlockedAdd #define InterlockedExchange _InterlockedExchange #define InterlockedExchangeAdd _InterlockedExchangeAdd #define InterlockedCompareExchange _InterlockedCompareExchange #define InterlockedAnd64 _InterlockedAnd64 #define InterlockedAndAffinity InterlockedAnd64 #define InterlockedOr64 _InterlockedOr64 #define InterlockedOrAffinity InterlockedOr64 #define InterlockedXor64 _InterlockedXor64 #define InterlockedIncrement64 _InterlockedIncrement64 #define InterlockedDecrement64 _InterlockedDecrement64 #define InterlockedAdd64 _InterlockedAdd64 #define InterlockedExchange64 _InterlockedExchange64 #define InterlockedExchangeAdd64 _InterlockedExchangeAdd64 #define InterlockedCompareExchange64 _InterlockedCompareExchange64 #define InterlockedExchangePointer _InterlockedExchangePointer #define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer #pragma intrinsic(_InterlockedExchange16) #define InterlockedExchange16 _InterlockedExchange16 #pragma intrinsic(_InterlockedAnd8_acq) #pragma intrinsic(_InterlockedAnd8_rel) #pragma intrinsic(_InterlockedAnd8_nf) #pragma intrinsic(_InterlockedOr8_acq) #pragma intrinsic(_InterlockedOr8_rel) #pragma intrinsic(_InterlockedOr8_nf) #pragma intrinsic(_InterlockedXor8_acq) #pragma intrinsic(_InterlockedXor8_rel) #pragma intrinsic(_InterlockedXor8_nf) #pragma intrinsic(_InterlockedAnd16_acq) #pragma intrinsic(_InterlockedAnd16_rel) #pragma intrinsic(_InterlockedAnd16_nf) #pragma intrinsic(_InterlockedOr16_acq) #pragma intrinsic(_InterlockedOr16_rel) #pragma intrinsic(_InterlockedOr16_nf) #pragma intrinsic(_InterlockedXor16_acq) #pragma intrinsic(_InterlockedXor16_rel) #pragma intrinsic(_InterlockedXor16_nf) #pragma intrinsic(_InterlockedIncrement16_acq) #pragma intrinsic(_InterlockedIncrement16_rel) #pragma intrinsic(_InterlockedIncrement16_nf) #pragma intrinsic(_InterlockedDecrement16_acq) #pragma intrinsic(_InterlockedDecrement16_rel) #pragma intrinsic(_InterlockedDecrement16_nf) #pragma intrinsic(_InterlockedExchange16_acq) #pragma intrinsic(_InterlockedExchange16_nf) #pragma intrinsic(_InterlockedCompareExchange16_acq) #pragma intrinsic(_InterlockedCompareExchange16_rel) #pragma intrinsic(_InterlockedCompareExchange16_nf) #pragma intrinsic(_InterlockedAnd_acq) #pragma intrinsic(_InterlockedAnd_rel) #pragma intrinsic(_InterlockedAnd_nf) #pragma intrinsic(_InterlockedOr_acq) #pragma intrinsic(_InterlockedOr_rel) #pragma intrinsic(_InterlockedOr_nf) #pragma intrinsic(_InterlockedXor_acq) #pragma intrinsic(_InterlockedXor_rel) #pragma intrinsic(_InterlockedXor_nf) #pragma intrinsic(_InterlockedIncrement_acq) #pragma intrinsic(_InterlockedIncrement_rel) #pragma intrinsic(_InterlockedIncrement_nf) #pragma intrinsic(_InterlockedDecrement_acq) #pragma intrinsic(_InterlockedDecrement_rel) #pragma intrinsic(_InterlockedDecrement_nf) #pragma intrinsic(_InterlockedExchange_acq) #pragma intrinsic(_InterlockedExchange_nf) #pragma intrinsic(_InterlockedExchangeAdd_acq) #pragma intrinsic(_InterlockedExchangeAdd_rel) #pragma intrinsic(_InterlockedExchangeAdd_nf) #pragma intrinsic(_InterlockedCompareExchange_rel) #pragma intrinsic(_InterlockedCompareExchange_nf) #pragma intrinsic(_InterlockedAnd64_acq) #pragma intrinsic(_InterlockedAnd64_rel) #pragma intrinsic(_InterlockedAnd64_nf) #pragma intrinsic(_InterlockedOr64_acq) #pragma intrinsic(_InterlockedOr64_rel) #pragma intrinsic(_InterlockedOr64_nf) #pragma intrinsic(_InterlockedXor64_acq) #pragma intrinsic(_InterlockedXor64_rel) #pragma intrinsic(_InterlockedXor64_nf) #pragma intrinsic(_InterlockedIncrement64_acq) #pragma intrinsic(_InterlockedIncrement64_rel) #pragma intrinsic(_InterlockedIncrement64_nf) #pragma intrinsic(_InterlockedDecrement64_acq) #pragma intrinsic(_InterlockedDecrement64_rel) #pragma intrinsic(_InterlockedDecrement64_nf) #pragma intrinsic(_InterlockedExchange64_acq) #pragma intrinsic(_InterlockedExchange64_nf) #pragma intrinsic(_InterlockedCompareExchange64_acq) #pragma intrinsic(_InterlockedCompareExchange64_rel) #pragma intrinsic(_InterlockedCompareExchange64_nf) #pragma intrinsic(_InterlockedExchangePointer_acq) #pragma intrinsic(_InterlockedExchangePointer_nf) #pragma intrinsic(_InterlockedCompareExchangePointer_acq) #pragma intrinsic(_InterlockedCompareExchangePointer_rel) #pragma intrinsic(_InterlockedCompareExchangePointer_nf) #define InterlockedAndAcquire8 _InterlockedAnd8_acq #define InterlockedAndRelease8 _InterlockedAnd8_rel #define InterlockedAndNoFence8 _InterlockedAnd8_nf #define InterlockedOrAcquire8 _InterlockedOr8_acq #define InterlockedOrRelease8 _InterlockedOr8_rel #define InterlockedOrNoFence8 _InterlockedOr8_nf #define InterlockedXorAcquire8 _InterlockedXor8_acq #define InterlockedXorRelease8 _InterlockedXor8_rel #define InterlockedXorNoFence8 _InterlockedXor8_nf #define InterlockedAndAcquire16 _InterlockedAnd16_acq #define InterlockedAndRelease16 _InterlockedAnd16_rel #define InterlockedAndNoFence16 _InterlockedAnd16_nf #define InterlockedOrAcquire16 _InterlockedOr16_acq #define InterlockedOrRelease16 _InterlockedOr16_rel #define InterlockedOrNoFence16 _InterlockedOr16_nf #define InterlockedXorAcquire16 _InterlockedXor16_acq #define InterlockedXorRelease16 _InterlockedXor16_rel #define InterlockedXorNoFence16 _InterlockedXor16_nf #define InterlockedIncrementAcquire16 _InterlockedIncrement16_acq #define InterlockedIncrementRelease16 _InterlockedIncrement16_rel #define InterlockedIncrementNoFence16 _InterlockedIncrement16_nf #define InterlockedDecrementAcquire16 _InterlockedDecrement16_acq #define InterlockedDecrementRelease16 _InterlockedDecrement16_rel #define InterlockedDecrementNoFence16 _InterlockedDecrement16_nf #define InterlockedExchangeAcquire16 _InterlockedExchange16_acq #define InterlockedExchangeNoFence16 _InterlockedExchange16_nf #define InterlockedCompareExchangeAcquire16 _InterlockedCompareExchange16_acq #define InterlockedCompareExchangeRelease16 _InterlockedCompareExchange16_rel #define InterlockedCompareExchangeNoFence16 _InterlockedCompareExchange16_nf #define InterlockedAndAcquire _InterlockedAnd_acq #define InterlockedAndRelease _InterlockedAnd_rel #define InterlockedAndNoFence _InterlockedAnd_nf #define InterlockedOrAcquire _InterlockedOr_acq #define InterlockedOrRelease _InterlockedOr_rel #define InterlockedOrNoFence _InterlockedOr_nf #define InterlockedXorAcquire _InterlockedXor_acq #define InterlockedXorRelease _InterlockedXor_rel #define InterlockedXorNoFence _InterlockedXor_nf #define InterlockedIncrementAcquire _InterlockedIncrement_acq #define InterlockedIncrementRelease _InterlockedIncrement_rel #define InterlockedIncrementNoFence _InterlockedIncrement_nf #define InterlockedDecrementAcquire _InterlockedDecrement_acq #define InterlockedDecrementRelease _InterlockedDecrement_rel #define InterlockedDecrementNoFence _InterlockedDecrement_nf #define InterlockedAddAcquire _InterlockedAdd_acq #define InterlockedAddRelease _InterlockedAdd_rel #define InterlockedAddNoFence _InterlockedAdd_nf #define InterlockedExchangeAcquire _InterlockedExchange_acq #define InterlockedExchangeNoFence _InterlockedExchange_nf #define InterlockedExchangeAddAcquire _InterlockedExchangeAdd_acq #define InterlockedExchangeAddRelease _InterlockedExchangeAdd_rel #define InterlockedExchangeAddNoFence _InterlockedExchangeAdd_nf #define InterlockedCompareExchangeAcquire _InterlockedCompareExchange_acq #define InterlockedCompareExchangeRelease _InterlockedCompareExchange_rel #define InterlockedCompareExchangeNoFence _InterlockedCompareExchange_nf #define InterlockedAndAcquire64 _InterlockedAnd64_acq #define InterlockedAndRelease64 _InterlockedAnd64_rel #define InterlockedAndNoFence64 _InterlockedAnd64_nf #define InterlockedOrAcquire64 _InterlockedOr64_acq #define InterlockedOrRelease64 _InterlockedOr64_rel #define InterlockedOrNoFence64 _InterlockedOr64_nf #define InterlockedXorAcquire64 _InterlockedXor64_acq #define InterlockedXorRelease64 _InterlockedXor64_rel #define InterlockedXorNoFence64 _InterlockedXor64_nf #define InterlockedIncrementAcquire64 _InterlockedIncrement64_acq #define InterlockedIncrementRelease64 _InterlockedIncrement64_rel #define InterlockedIncrementNoFence64 _InterlockedIncrement64_nf #define InterlockedDecrementAcquire64 _InterlockedDecrement64_acq #define InterlockedDecrementRelease64 _InterlockedDecrement64_rel #define InterlockedDecrementNoFence64 _InterlockedDecrement64_nf #define InterlockedAddAcquire64 _InterlockedAdd64_acq #define InterlockedAddRelease64 _InterlockedAdd64_rel #define InterlockedAddNoFence64 _InterlockedAdd64_nf #define InterlockedExchangeAcquire64 _InterlockedExchange64_acq #define InterlockedExchangeNoFence64 _InterlockedExchange64_nf #define InterlockedExchangeAddAcquire64 _InterlockedExchangeAdd64_acq #define InterlockedExchangeAddRelease64 _InterlockedExchangeAdd64_rel #define InterlockedExchangeAddNoFence64 _InterlockedExchangeAdd64_nf #define InterlockedCompareExchangeAcquire64 _InterlockedCompareExchange64_acq #define InterlockedCompareExchangeRelease64 _InterlockedCompareExchange64_rel #define InterlockedCompareExchangeNoFence64 _InterlockedCompareExchange64_nf #define InterlockedCompareExchange128 _InterlockedCompareExchange128 // AMD64_WORKITEM : these are redundant but necessary for AMD64 compatibility #define InterlockedAnd64Acquire _InterlockedAnd64_acq #define InterlockedAnd64Release _InterlockedAnd64_rel #define InterlockedAnd64NoFence _InterlockedAnd64_nf #define InterlockedOr64Acquire _InterlockedOr64_acq #define InterlockedOr64Release _InterlockedOr64_rel #define InterlockedOr64NoFence _InterlockedOr64_nf #define InterlockedXor64Acquire _InterlockedXor64_acq #define InterlockedXor64Release _InterlockedXor64_rel #define InterlockedXor64NoFence _InterlockedXor64_nf #define InterlockedExchangePointerAcquire _InterlockedExchangePointer_acq #define InterlockedExchangePointerNoFence _InterlockedExchangePointer_nf #define InterlockedCompareExchangePointerAcquire _InterlockedCompareExchangePointer_acq #define InterlockedCompareExchangePointerRelease _InterlockedCompareExchangePointer_rel #define InterlockedCompareExchangePointerNoFence _InterlockedCompareExchangePointer_nf #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd64((LONG64 *)a, b) #define InterlockedExchangeAddSizeTAcquire(a, b) InterlockedExchangeAddAcquire64((LONG64 *)a, b) #define InterlockedExchangeAddSizeTNoFence(a, b) InterlockedExchangeAddNoFence64((LONG64 *)a, b) #define InterlockedIncrementSizeT(a) InterlockedIncrement64((LONG64 *)a) #define InterlockedIncrementSizeTNoFence(a) InterlockedIncrementNoFence64((LONG64 *)a) #define InterlockedDecrementSizeT(a) InterlockedDecrement64((LONG64 *)a) #define InterlockedDecrementSizeTNoFence(a) InterlockedDecrementNoFence64((LONG64 *)a) // // Define accessors for volatile loads and stores. // #pragma intrinsic(__iso_volatile_load8) #pragma intrinsic(__iso_volatile_load16) #pragma intrinsic(__iso_volatile_load32) #pragma intrinsic(__iso_volatile_load64) #pragma intrinsic(__iso_volatile_store8) #pragma intrinsic(__iso_volatile_store16) #pragma intrinsic(__iso_volatile_store32) #pragma intrinsic(__iso_volatile_store64) FORCEINLINE CHAR ReadAcquire8 ( _In_ _Interlocked_operand_ CHAR const volatile *Source ) { CHAR Value; Value = __iso_volatile_load8(Source); __dmb(_ARM64_BARRIER_ISH); return Value; } FORCEINLINE CHAR ReadNoFence8 ( _In_ _Interlocked_operand_ CHAR const volatile *Source ) { CHAR Value; Value = __iso_volatile_load8(Source); return Value; } FORCEINLINE VOID WriteRelease8 ( _Out_ _Interlocked_operand_ CHAR volatile *Destination, _In_ CHAR Value ) { __dmb(_ARM64_BARRIER_ISH); __iso_volatile_store8(Destination, Value); return; } FORCEINLINE VOID WriteNoFence8 ( _Out_ _Interlocked_operand_ CHAR volatile *Destination, _In_ CHAR Value ) { __iso_volatile_store8(Destination, Value); return; } FORCEINLINE SHORT ReadAcquire16 ( _In_ _Interlocked_operand_ SHORT const volatile *Source ) { SHORT Value; Value = __iso_volatile_load16(Source); __dmb(_ARM64_BARRIER_ISH); return Value; } FORCEINLINE SHORT ReadNoFence16 ( _In_ _Interlocked_operand_ SHORT const volatile *Source ) { SHORT Value; Value = __iso_volatile_load16(Source); return Value; } FORCEINLINE VOID WriteRelease16 ( _Out_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ) { __dmb(_ARM64_BARRIER_ISH); __iso_volatile_store16(Destination, Value); return; } FORCEINLINE VOID WriteNoFence16 ( _Out_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ) { __iso_volatile_store16(Destination, Value); return; } FORCEINLINE LONG ReadAcquire ( _In_ _Interlocked_operand_ LONG const volatile *Source ) { LONG Value; Value = __iso_volatile_load32((int *)Source); __dmb(_ARM64_BARRIER_ISH); return Value; } FORCEINLINE LONG ReadNoFence ( _In_ _Interlocked_operand_ LONG const volatile *Source ) { LONG Value; Value = __iso_volatile_load32((int *)Source); return Value; } FORCEINLINE VOID WriteRelease ( _Out_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ) { __dmb(_ARM64_BARRIER_ISH); __iso_volatile_store32((int *)Destination, Value); return; } FORCEINLINE VOID WriteNoFence ( _Out_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ) { __iso_volatile_store32((int *)Destination, Value); return; } FORCEINLINE LONG64 ReadAcquire64 ( _In_ _Interlocked_operand_ LONG64 const volatile *Source ) { LONG64 Value; Value = __iso_volatile_load64(Source); __dmb(_ARM64_BARRIER_ISH); return Value; } FORCEINLINE LONG64 ReadNoFence64 ( _In_ _Interlocked_operand_ LONG64 const volatile *Source ) { LONG64 Value; Value = __iso_volatile_load64(Source); return Value; } FORCEINLINE VOID WriteRelease64 ( _Out_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { __dmb(_ARM64_BARRIER_ISH); __iso_volatile_store64(Destination, Value); return; } FORCEINLINE VOID WriteNoFence64 ( _Out_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { __iso_volatile_store64(Destination, Value); return; } // // Define coprocessor access intrinsics. Coprocessor 15 contains // registers for the MMU, cache, TLB, feature bits, core // identification and performance counters. // #define ARM64_SYSREG(op0, op1, crn, crm, op2) \ ( ((op0 & 1) << 14) | \ ((op1 & 7) << 11) | \ ((crn & 15) << 7) | \ ((crm & 15) << 3) | \ ((op2 & 7) << 0) ) #define ARM64_PMCCNTR_EL0 ARM64_SYSREG(3,3, 9,13,0) // Cycle Count Register [CP15_PMCCNTR] #define ARM64_PMSELR_EL0 ARM64_SYSREG(3,3, 9,12,5) // Event Counter Selection Register [CP15_PMSELR] #define ARM64_PMXEVCNTR_EL0 ARM64_SYSREG(3,3, 9,13,2) // Event Count Register [CP15_PMXEVCNTR] #define ARM64_PMXEVCNTRn_EL0(n) ARM64_SYSREG(3,3,14, 8+((n)/8), (n)%8) // Direct Event Count Register [n/a] #define ARM64_TPIDR_EL0 ARM64_SYSREG(3,3,13, 0,2) // Thread ID Register, User Read/Write [CP15_TPIDRURW] #define ARM64_TPIDRRO_EL0 ARM64_SYSREG(3,3,13, 0,3) // Thread ID Register, User Read Only [CP15_TPIDRURO] #define ARM64_TPIDR_EL1 ARM64_SYSREG(3,0,13, 0,4) // Thread ID Register, Privileged Only [CP15_TPIDRPRW] #pragma intrinsic(_WriteStatusReg) #pragma intrinsic(_ReadStatusReg) // // PreFetchCacheLine level defines. // #define PF_TEMPORAL_LEVEL_1 0 #define PF_TEMPORAL_LEVEL_2 1 #define PF_TEMPORAL_LEVEL_3 2 #define PF_NON_TEMPORAL_LEVEL_ALL 3 // // Define function to read the value of the time stamp counter. // FORCEINLINE ULONG64 ReadTimeStampCounter( VOID ) { return (ULONG64)_ReadStatusReg(ARM64_PMCCNTR_EL0); } FORCEINLINE ULONG64 ReadPMC ( _In_ ULONG Counter ) { // ARM64_WORKITEM: These can be directly accessed, but // given our usage, it that any benefit? We need to know // the register index at compile time, though atomicity // benefits would still be good if needed, even if we // went with a big switch statement. _WriteStatusReg(ARM64_PMSELR_EL0, Counter); return (ULONG64)_ReadStatusReg(ARM64_PMXEVCNTR_EL0); } // // Define functions to capture the high 64-bits of a 128-bit multiply. // #define MultiplyHigh __mulh #define UnsignedMultiplyHigh __umulh #pragma intrinsic(__mulh) #pragma intrinsic(__umulh) #ifdef __cplusplus } #endif #endif // !defined(_M_CEE_PURE) #endif // defined(_M_ARM64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #if defined(_M_CEE_PURE) FORCEINLINE VOID YieldProcessor ( VOID ) { } #endif #if defined(_KERNEL_MODE) || defined(_BOOT_ENVIRONMENT) #define KI_USER_SHARED_DATA 0xFFFFF78000000000UI64 #define SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA) #define SharedInterruptTime (KI_USER_SHARED_DATA + 0x8) #define SharedSystemTime (KI_USER_SHARED_DATA + 0x14) #define SharedTickCount (KI_USER_SHARED_DATA + 0x320) #define KeQueryInterruptTime() ((ULONG64)ReadNoFence64((const volatile LONG64 *)(SharedInterruptTime))) #define KeQuerySystemTime(CurrentCount) \ *((PULONG64)(CurrentCount)) = ReadNoFence64((const volatile LONG64 *)(SharedSystemTime)) #define KeQueryTickCount(CurrentCount) \ *((PULONG64)(CurrentCount)) = ReadNoFence64((const volatile LONG64 *)(SharedTickCount)) #endif #endif // _ARM64_ #if !defined(RC_INVOKED) && !defined(MIDL_PASS) #if defined(_M_AMD64) || defined(_M_IX86) || defined(_M_CEE_PURE) #ifdef __cplusplus extern "C" { #endif FORCEINLINE CHAR ReadAcquire8 ( _In_ _Interlocked_operand_ CHAR const volatile *Source ) { CHAR Value; Value = *Source; return Value; } FORCEINLINE CHAR ReadNoFence8 ( _In_ _Interlocked_operand_ CHAR const volatile *Source ) { CHAR Value; Value = *Source; return Value; } FORCEINLINE VOID WriteRelease8 ( _Out_ _Interlocked_operand_ CHAR volatile *Destination, _In_ CHAR Value ) { *Destination = Value; return; } FORCEINLINE VOID WriteNoFence8 ( _Out_ _Interlocked_operand_ CHAR volatile *Destination, _In_ CHAR Value ) { *Destination = Value; return; } FORCEINLINE SHORT ReadAcquire16 ( _In_ _Interlocked_operand_ SHORT const volatile *Source ) { SHORT Value; Value = *Source; return Value; } FORCEINLINE SHORT ReadNoFence16 ( _In_ _Interlocked_operand_ SHORT const volatile *Source ) { SHORT Value; Value = *Source; return Value; } FORCEINLINE VOID WriteRelease16 ( _Out_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ) { *Destination = Value; return; } FORCEINLINE VOID WriteNoFence16 ( _Out_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ) { *Destination = Value; return; } FORCEINLINE LONG ReadAcquire ( _In_ _Interlocked_operand_ LONG const volatile *Source ) { LONG Value; Value = *Source; return Value; } FORCEINLINE LONG ReadNoFence ( _In_ _Interlocked_operand_ LONG const volatile *Source ) { LONG Value; Value = *Source; return Value; } CFORCEINLINE VOID WriteRelease ( _Out_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ) { *Destination = Value; return; } FORCEINLINE VOID WriteNoFence ( _Out_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ) { *Destination = Value; return; } FORCEINLINE LONG64 ReadAcquire64 ( _In_ _Interlocked_operand_ LONG64 const volatile *Source ) { LONG64 Value; Value = *Source; return Value; } FORCEINLINE LONG64 ReadNoFence64 ( _In_ _Interlocked_operand_ LONG64 const volatile *Source ) { LONG64 Value; Value = *Source; return Value; } CFORCEINLINE VOID WriteRelease64 ( _Out_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { *Destination = Value; return; } FORCEINLINE VOID WriteNoFence64 ( _Out_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { *Destination = Value; return; } #ifdef __cplusplus } #endif #endif // defined(_M_AMD64) || defined(_M_IX86) || defined(_M_CEE_PURE) // // Define "raw" operations which have no ordering or atomicity semantics. // FORCEINLINE CHAR ReadRaw8 ( _In_ _Interlocked_operand_ CHAR const volatile *Source ) { CHAR Value; Value = *(CHAR *)Source; return Value; } FORCEINLINE VOID WriteRaw8 ( _Out_ _Interlocked_operand_ CHAR volatile *Destination, _In_ CHAR Value ) { *(CHAR *)Destination = Value; return; } FORCEINLINE SHORT ReadRaw16 ( _In_ _Interlocked_operand_ SHORT const volatile *Source ) { SHORT Value; Value = *(SHORT *)Source; return Value; } FORCEINLINE VOID WriteRaw16 ( _Out_ _Interlocked_operand_ SHORT volatile *Destination, _In_ SHORT Value ) { *(SHORT *)Destination = Value; return; } FORCEINLINE LONG ReadRaw ( _In_ _Interlocked_operand_ LONG const volatile *Source ) { LONG Value; Value = *(LONG *)Source; return Value; } CFORCEINLINE VOID WriteRaw ( _Out_ _Interlocked_operand_ LONG volatile *Destination, _In_ LONG Value ) { *(LONG *)Destination = Value; return; } FORCEINLINE LONG64 ReadRaw64 ( _In_ _Interlocked_operand_ LONG64 const volatile *Source ) { LONG64 Value; Value = *(LONG64 *)Source; return Value; } FORCEINLINE VOID WriteRaw64 ( _Out_ _Interlocked_operand_ LONG64 volatile *Destination, _In_ LONG64 Value ) { *(LONG64 *)Destination = Value; return; } // // Define explicit read and write operations for derived types. // FORCEINLINE UCHAR ReadUCharAcquire ( _In_ _Interlocked_operand_ UCHAR const volatile *Source ) { return (UCHAR)ReadAcquire8((PCHAR)Source); } FORCEINLINE UCHAR ReadUCharNoFence ( _In_ _Interlocked_operand_ UCHAR const volatile *Source ) { return (UCHAR)ReadNoFence8((PCHAR)Source); } FORCEINLINE UCHAR ReadBooleanAcquire ( _In_ _Interlocked_operand_ BOOLEAN const volatile *Source ) { return (BOOLEAN)ReadAcquire8((PCHAR)Source); } FORCEINLINE UCHAR ReadBooleanNoFence ( _In_ _Interlocked_operand_ BOOLEAN const volatile *Source ) { return (BOOLEAN)ReadNoFence8((PCHAR)Source); } FORCEINLINE UCHAR ReadUCharRaw ( _In_ _Interlocked_operand_ UCHAR const volatile *Source ) { return (UCHAR)ReadRaw8((PCHAR)Source); } FORCEINLINE VOID WriteUCharRelease ( _Out_ _Interlocked_operand_ UCHAR volatile *Destination, _In_ UCHAR Value ) { WriteRelease8((PCHAR)Destination, (CHAR)Value); return; } FORCEINLINE VOID WriteUCharNoFence ( _Out_ _Interlocked_operand_ UCHAR volatile *Destination, _In_ UCHAR Value ) { WriteNoFence8((PCHAR)Destination, (CHAR)Value); return; } FORCEINLINE VOID WriteBooleanRelease ( _Out_ _Interlocked_operand_ BOOLEAN volatile *Destination, _In_ BOOLEAN Value ) { WriteRelease8((PCHAR)Destination, (CHAR)Value); return; } FORCEINLINE VOID WriteBooleanNoFence ( _Out_ _Interlocked_operand_ BOOLEAN volatile *Destination, _In_ BOOLEAN Value ) { WriteNoFence8((PCHAR)Destination, (CHAR)Value); return; } FORCEINLINE VOID WriteUCharRaw ( _Out_ _Interlocked_operand_ UCHAR volatile *Destination, _In_ UCHAR Value ) { WriteRaw8((PCHAR)Destination, (CHAR)Value); return; } FORCEINLINE USHORT ReadUShortAcquire ( _In_ _Interlocked_operand_ USHORT const volatile *Source ) { return (USHORT)ReadAcquire16((PSHORT)Source); } FORCEINLINE USHORT ReadUShortNoFence ( _In_ _Interlocked_operand_ USHORT const volatile *Source ) { return (USHORT)ReadNoFence16((PSHORT)Source); } FORCEINLINE USHORT ReadUShortRaw ( _In_ _Interlocked_operand_ USHORT const volatile *Source ) { return (USHORT)ReadRaw16((PSHORT)Source); } FORCEINLINE VOID WriteUShortRelease ( _Out_ _Interlocked_operand_ USHORT volatile *Destination, _In_ USHORT Value ) { WriteRelease16((PSHORT)Destination, (SHORT)Value); return; } FORCEINLINE VOID WriteUShortNoFence ( _Out_ _Interlocked_operand_ USHORT volatile *Destination, _In_ USHORT Value ) { WriteNoFence16((PSHORT)Destination, (SHORT)Value); return; } FORCEINLINE VOID WriteUShortRaw ( _Out_ _Interlocked_operand_ USHORT volatile *Destination, _In_ USHORT Value ) { WriteRaw16((PSHORT)Destination, (SHORT)Value); return; } FORCEINLINE ULONG ReadULongAcquire ( _In_ _Interlocked_operand_ ULONG const volatile *Source ) { return (ULONG)ReadAcquire((PLONG)Source); } FORCEINLINE ULONG ReadULongNoFence ( _In_ _Interlocked_operand_ ULONG const volatile *Source ) { return (ULONG)ReadNoFence((PLONG)Source); } FORCEINLINE ULONG ReadULongRaw ( _In_ _Interlocked_operand_ ULONG const volatile *Source ) { return (ULONG)ReadRaw((PLONG)Source); } CFORCEINLINE VOID WriteULongRelease ( _Out_ _Interlocked_operand_ ULONG volatile *Destination, _In_ ULONG Value ) { WriteRelease((PLONG)Destination, (LONG)Value); return; } FORCEINLINE VOID WriteULongNoFence ( _Out_ _Interlocked_operand_ ULONG volatile *Destination, _In_ ULONG Value ) { WriteNoFence((PLONG)Destination, (LONG)Value); return; } FORCEINLINE VOID WriteULongRaw ( _Out_ _Interlocked_operand_ ULONG volatile *Destination, _In_ ULONG Value ) { WriteRaw((PLONG)Destination, (LONG)Value); return; } FORCEINLINE ULONG64 ReadULong64Acquire ( _In_ _Interlocked_operand_ ULONG64 const volatile *Source ) { return (ULONG64)ReadAcquire64((PLONG64)Source); } FORCEINLINE ULONG64 ReadULong64NoFence ( _In_ _Interlocked_operand_ ULONG64 const volatile *Source ) { return (ULONG64)ReadNoFence64((PLONG64)Source); } FORCEINLINE ULONG64 ReadULong64Raw ( _In_ _Interlocked_operand_ ULONG64 const volatile *Source ) { return (ULONG64)ReadRaw64((PLONG64)Source); } CFORCEINLINE VOID WriteULong64Release ( _Out_ _Interlocked_operand_ ULONG64 volatile *Destination, _In_ ULONG64 Value ) { WriteRelease64((PLONG64)Destination, (LONG64)Value); return; } FORCEINLINE VOID WriteULong64NoFence ( _Out_ _Interlocked_operand_ ULONG64 volatile *Destination, _In_ ULONG64 Value ) { WriteNoFence64((PLONG64)Destination, (LONG64)Value); return; } FORCEINLINE VOID WriteULong64Raw ( _Out_ _Interlocked_operand_ ULONG64 volatile *Destination, _In_ ULONG64 Value ) { WriteRaw64((PLONG64)Destination, (LONG64)Value); return; } #define ReadSizeTAcquire ReadULongPtrAcquire #define ReadSizeTNoFence ReadULongPtrNoFence #define ReadSizeTRaw ReadULongPtrRaw #define WriteSizeTRelease WriteULongPtrRelease #define WriteSizeTNoFence WriteULongPtrNoFence #define WriteSizeTRaw WriteULongPtrRaw #if !defined(_WIN64) FORCEINLINE PVOID ReadPointerAcquire ( _In_ _Interlocked_operand_ PVOID const volatile *Source ) { return (PVOID)ReadAcquire((PLONG)Source); } FORCEINLINE PVOID ReadPointerNoFence ( _In_ _Interlocked_operand_ PVOID const volatile *Source ) { return (PVOID)ReadNoFence((PLONG)Source); } FORCEINLINE PVOID ReadPointerRaw ( _In_ _Interlocked_operand_ PVOID const volatile *Source ) { return (PVOID)ReadRaw((PLONG)Source); } CFORCEINLINE VOID WritePointerRelease ( _Out_ _Interlocked_operand_ PVOID volatile *Destination, _In_ PVOID Value ) { WriteRelease((PLONG)Destination, (LONG)Value); return; } FORCEINLINE VOID WritePointerNoFence ( _Out_ _Interlocked_operand_ PVOID volatile *Destination, _In_opt_ PVOID Value ) { WriteNoFence((PLONG)Destination, (LONG)Value); return; } FORCEINLINE VOID WritePointerRaw ( _Out_ _Interlocked_operand_ PVOID volatile *Destination, _In_opt_ PVOID Value ) { WriteRaw((PLONG)Destination, (LONG)Value); return; } #define ReadLongPtrAcquire ReadAcquire #define ReadLongPtrNoFence ReadNoFence #define ReadLongPtrRaw ReadRaw #define WriteLongPtrRelease WriteRelease #define WriteLongPtrNoFence WriteNoFence #define WriteLongPtrRaw WriteRaw #define ReadULongPtrAcquire ReadULongAcquire #define ReadULongPtrNoFence ReadULongNoFence #define ReadULongPtrRaw ReadULongRaw #define WriteULongPtrRelease WriteULongRelease #define WriteULongPtrNoFence WriteULongNoFence #define WriteULongPtrRaw WriteULongRaw #else // !defined(_WIN64) FORCEINLINE PVOID ReadPointerAcquire ( _In_ _Interlocked_operand_ PVOID const volatile *Source ) { return (PVOID)ReadAcquire64((PLONG64)Source); } FORCEINLINE PVOID ReadPointerNoFence ( _In_ _Interlocked_operand_ PVOID const volatile *Source ) { return (PVOID)ReadNoFence64((PLONG64)Source); } FORCEINLINE PVOID ReadPointerRaw ( _In_ _Interlocked_operand_ PVOID const volatile *Source ) { return (PVOID)ReadRaw64((PLONG64)Source); } FORCEINLINE VOID WritePointerRelease ( _Out_ _Interlocked_operand_ PVOID volatile *Destination, _In_ PVOID Value ) { WriteRelease64((PLONG64)Destination, (LONG64)Value); return; } FORCEINLINE VOID WritePointerNoFence ( _Out_ _Interlocked_operand_ PVOID volatile *Destination, _In_ PVOID Value ) { WriteNoFence64((PLONG64)Destination, (LONG64)Value); return; } FORCEINLINE VOID WritePointerRaw ( _Out_ _Interlocked_operand_ PVOID volatile *Destination, _In_ PVOID Value ) { WriteRaw64((PLONG64)Destination, (LONG64)Value); return; } #define ReadLongPtrAcquire ReadAcquire64 #define ReadLongPtrNoFence ReadNoFence64 #define ReadLongPtrRaw ReadRaw64 #define WriteLongPtrRelease WriteRelease64 #define WriteLongPtrNoFence WriteNoFence64 #define WriteLongPtrRaw WriteRaw64 #define ReadULongPtrAcquire ReadULong64Acquire #define ReadULongPtrNoFence ReadULong64NoFence #define ReadULongPtrRaw ReadULong64Raw #define WriteULongPtrRelease WriteULong64Release #define WriteULongPtrNoFence WriteULong64NoFence #define WriteULongPtrRaw WriteULong64Raw #endif // !defined(_WIN64) #endif // !defined(RC_INVOKED) && !defined(MIDL_PASS) #ifdef __cplusplus extern "C" { #endif // // Assert exception. // #if !defined(_DBGRAISEASSERTIONFAILURE_) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #define _DBGRAISEASSERTIONFAILURE_ #if defined(_PREFAST_) __analysis_noreturn FORCEINLINE VOID DbgRaiseAssertionFailure ( VOID ); #endif #if defined(_AMD64_) #if defined(_M_AMD64) VOID __int2c ( VOID ); #pragma intrinsic(__int2c) #if !defined(_PREFAST_) #define DbgRaiseAssertionFailure() __int2c() #endif // !defined(_PREFAST_) #endif // defined(_M_AMD64) #elif defined(_X86_) #if defined(_M_IX86) #if _MSC_FULL_VER >= 140030222 VOID __int2c ( VOID ); #pragma intrinsic(__int2c) #if !defined(_PREFAST_) #define DbgRaiseAssertionFailure() __int2c() #endif // !defined(_PREFAST_) #else // _MSC_FULL_VER >= 140030222 #pragma warning( push ) #pragma warning( disable : 4793 ) #if !defined(_PREFAST_) __analysis_noreturn FORCEINLINE VOID DbgRaiseAssertionFailure ( VOID ) { __asm int 0x2c } #endif // !defined(_PREFAST_) #pragma warning( pop ) #endif // _MSC_FULL_VER >= 140030222 #endif // defined(_M_IX86) #elif defined(_IA64_) #if defined(_M_IA64) void __break( _In_ int StIIM ); #pragma intrinsic (__break) #define BREAK_DEBUG_BASE 0x080000 #define ASSERT_BREAKPOINT (BREAK_DEBUG_BASE+3) // Cause a STATUS_ASSERTION_FAILURE exception to be raised. #if !defined(_PREFAST_) #define DbgRaiseAssertionFailure() __break(ASSERT_BREAKPOINT) #endif // !defined(_PREFAST_) #endif // defined(_M_IA64) #elif defined(_ARM64_) #if defined(_M_ARM64) void __break( _In_ int Code ); #pragma intrinsic (__break) #if !defined(_PREFAST_) #define DbgRaiseAssertionFailure() __break(0xf001) #endif // !defined(_PREFAST_) #endif // defined(_M_ARM64) #elif defined(_ARM_) #if defined(_M_ARM) VOID __emit( const unsigned __int32 opcode ); #pragma intrinsic(__emit) #if !defined(_PREFAST_) #define DbgRaiseAssertionFailure() __emit(0xdefc) // THUMB_ASSERT #endif // !defined(_PREFAST_) #endif // defined(_M_ARM) #endif // _AMD64_, _X86_, _IA64_, _ARM64_, _ARM_ #endif // !defined(_DBGRAISEASSERTIONFAILURE_) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #ifdef __cplusplus } #endif #if _MSC_VER >= 1300 #if defined(_PREFAST_) // _Analysis_assume_ will never result in any code generation for _exp, // so using it will not have runtime impact, even if _exp has side effects. #define NT_ANALYSIS_ASSUME(_exp) _Analysis_assume_(_exp) #else // _PREFAST_ // NT_ANALYSIS_ASSUME ensures that _exp is parsed in non-analysis compile. // On DBG, it's guaranteed to be parsed as part of the normal compile, but with // non-DBG, use __noop to ensure _exp is parseable but without code generation. #if DBG #define NT_ANALYSIS_ASSUME(_exp) ((void) 0) #else // DBG #define NT_ANALYSIS_ASSUME(_exp) __noop(_exp) #endif // DBG #endif // _PREFAST_ // NT_ASSERT_ACTION is the actual assertion action, i.e. raising runtime // assertion failure. It should be used only by the macro of NT_ASSERT // and NT_FRE_ASSERT below. #define NT_ASSERT_ACTION(_exp) \ ((!(_exp)) ? \ (__annotation(L"Debug", L"AssertFail", L#_exp), \ DbgRaiseAssertionFailure(), FALSE) : \ TRUE) #define NT_ASSERTMSG_ACTION(_msg, _exp) \ ((!(_exp)) ? \ (__annotation(L"Debug", L"AssertFail", L##_msg), \ DbgRaiseAssertionFailure(), FALSE) : \ TRUE) #define NT_ASSERTMSGW_ACTION(_msg, _exp) \ ((!(_exp)) ? \ (__annotation(L"Debug", L"AssertFail", _msg), \ DbgRaiseAssertionFailure(), FALSE) : \ TRUE) #if DBG #define NT_ASSERT_ASSUME(_exp) \ (NT_ANALYSIS_ASSUME(_exp), NT_ASSERT_ACTION(_exp)) #define NT_ASSERTMSG_ASSUME(_msg, _exp) \ (NT_ANALYSIS_ASSUME(_exp), NT_ASSERTMSG_ACTION(_msg, _exp)) #define NT_ASSERTMSGW_ASSUME(_msg, _exp) \ (NT_ANALYSIS_ASSUME(_exp), NT_ASSERTMSGW_ACTION(_msg, _exp)) // For DBG builds, NT_ASSERT_ASSUME and NT_ASSERT_NOASSUME have the same // behavior. The behavior only differs for non-DBG. #define NT_ASSERT_NOASSUME NT_ASSERT_ASSUME #define NT_ASSERTMSG_NOASSUME NT_ASSERTMSG_ASSUME #define NT_ASSERTMSGW_NOASSUME NT_ASSERTMSGW_ASSUME #define NT_VERIFY NT_ASSERT #define NT_VERIFYMSG NT_ASSERTMSG #define NT_VERIFYMSGW NT_ASSERTMSGW #else // DBG #define NT_ASSERT_ASSUME(_exp) (NT_ANALYSIS_ASSUME(_exp), 0) #define NT_ASSERTMSG_ASSUME(_msg, _exp) (NT_ANALYSIS_ASSUME(_exp), 0) #define NT_ASSERTMSGW_ASSUME(_msg, _exp) (NT_ANALYSIS_ASSUME(_exp), 0) #define NT_ASSERT_NOASSUME(_exp) ((void) 0) #define NT_ASSERTMSG_NOASSUME(_msg, _exp) ((void) 0) #define NT_ASSERTMSGW_NOASSUME(_msg, _exp) ((void) 0) #define NT_VERIFY(_exp) (NT_ANALYSIS_ASSUME(_exp), ((_exp) ? TRUE : FALSE)) #define NT_VERIFYMSG(_msg, _exp ) (NT_ANALYSIS_ASSUME(_exp), ((_exp) ? TRUE : FALSE)) #define NT_VERIFYMSGW(_msg, _exp) (NT_ANALYSIS_ASSUME(_exp), ((_exp) ? TRUE : FALSE)) #endif // DBG // NT_FRE_ASSERT always takes the assertion action whether DBG or non-DBG. #define NT_FRE_ASSERT(_exp) (NT_ANALYSIS_ASSUME(_exp), NT_ASSERT_ACTION(_exp)) #define NT_FRE_ASSERTMSG(_msg, _exp) (NT_ANALYSIS_ASSUME(_exp), NT_ASSERTMSG_ACTION(_msg, _exp)) #define NT_FRE_ASSERTMSGW(_msg, _exp) (NT_ANALYSIS_ASSUME(_exp), NT_ASSERTMSGW_ACTION(_msg, _exp)) #ifdef NT_ASSERT_ALWAYS_ASSUMES #define NT_ASSERT NT_ASSERT_ASSUME #define NT_ASSERTMSG NT_ASSERTMSG_ASSUME #define NT_ASSERTMSGW NT_ASSERTMSGW_ASSUME #else // NT_ASSERT_ALWAYS_ASSUMES #define NT_ASSERT NT_ASSERT_NOASSUME #define NT_ASSERTMSG NT_ASSERTMSG_NOASSUME #define NT_ASSERTMSGW NT_ASSERTMSGW_NOASSUME #endif // NT_ASSERT_ALWAYS_ASSUMES #endif // _MSC_VER >= 1300 // // Define an access token from a programmer's viewpoint. The structure is // completely opaque and the programer is only allowed to have pointers // to tokens. // typedef PVOID PACCESS_TOKEN; // // Pointer to a SECURITY_DESCRIPTOR opaque data type. // typedef PVOID PSECURITY_DESCRIPTOR; // // Define a pointer to the Security ID data type (an opaque data type) // typedef PVOID PSID; // // Define a pointer to the CLAIMS_BLOB opaque data type // typedef PVOID PCLAIMS_BLOB; typedef ULONG ACCESS_MASK; typedef ACCESS_MASK *PACCESS_MASK; // // The following are masks for the predefined standard access types // #define DELETE (0x00010000L) #define READ_CONTROL (0x00020000L) #define WRITE_DAC (0x00040000L) #define WRITE_OWNER (0x00080000L) #define SYNCHRONIZE (0x00100000L) #define STANDARD_RIGHTS_REQUIRED (0x000F0000L) #define STANDARD_RIGHTS_READ (READ_CONTROL) #define STANDARD_RIGHTS_WRITE (READ_CONTROL) #define STANDARD_RIGHTS_EXECUTE (READ_CONTROL) #define STANDARD_RIGHTS_ALL (0x001F0000L) #define SPECIFIC_RIGHTS_ALL (0x0000FFFFL) // // AccessSystemAcl access type // #define ACCESS_SYSTEM_SECURITY (0x01000000L) // // MaximumAllowed access type // #define MAXIMUM_ALLOWED (0x02000000L) // // These are the generic rights. // #define GENERIC_READ (0x80000000L) #define GENERIC_WRITE (0x40000000L) #define GENERIC_EXECUTE (0x20000000L) #define GENERIC_ALL (0x10000000L) // // Define the generic mapping array. This is used to denote the // mapping of each generic access right to a specific access mask. // typedef struct _GENERIC_MAPPING { ACCESS_MASK GenericRead; ACCESS_MASK GenericWrite; ACCESS_MASK GenericExecute; ACCESS_MASK GenericAll; } GENERIC_MAPPING; typedef GENERIC_MAPPING *PGENERIC_MAPPING; //////////////////////////////////////////////////////////////////////// // // // LUID_AND_ATTRIBUTES // // // //////////////////////////////////////////////////////////////////////// // // #include typedef struct _LUID_AND_ATTRIBUTES { LUID Luid; ULONG Attributes; } LUID_AND_ATTRIBUTES, * PLUID_AND_ATTRIBUTES; typedef LUID_AND_ATTRIBUTES LUID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY]; typedef LUID_AND_ATTRIBUTES_ARRAY *PLUID_AND_ATTRIBUTES_ARRAY; #include // This is the *current* ACL revision #define ACL_REVISION (2) #define ACL_REVISION_DS (4) // This is the history of ACL revisions. Add a new one whenever // ACL_REVISION is updated #define ACL_REVISION1 (1) #define MIN_ACL_REVISION ACL_REVISION2 #define ACL_REVISION2 (2) #define ACL_REVISION3 (3) #define ACL_REVISION4 (4) #define MAX_ACL_REVISION ACL_REVISION4 typedef struct _ACL { UCHAR AclRevision; UCHAR Sbz1; USHORT AclSize; USHORT AceCount; USHORT Sbz2; } ACL; typedef ACL *PACL; // // Current security descriptor revision value // #define SECURITY_DESCRIPTOR_REVISION (1) #define SECURITY_DESCRIPTOR_REVISION1 (1) // // Privilege attributes // #define SE_PRIVILEGE_ENABLED_BY_DEFAULT (0x00000001L) #define SE_PRIVILEGE_ENABLED (0x00000002L) #define SE_PRIVILEGE_REMOVED (0X00000004L) #define SE_PRIVILEGE_USED_FOR_ACCESS (0x80000000L) #define SE_PRIVILEGE_VALID_ATTRIBUTES (SE_PRIVILEGE_ENABLED_BY_DEFAULT | \ SE_PRIVILEGE_ENABLED | \ SE_PRIVILEGE_REMOVED | \ SE_PRIVILEGE_USED_FOR_ACCESS) // // Privilege Set Control flags // #define PRIVILEGE_SET_ALL_NECESSARY (1) // // Privilege Set - This is defined for a privilege set of one. // If more than one privilege is needed, then this structure // will need to be allocated with more space. // // Note: don't change this structure without fixing the INITIAL_PRIVILEGE_SET // structure (defined in se.h) // typedef struct _PRIVILEGE_SET { ULONG PrivilegeCount; ULONG Control; LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY]; } PRIVILEGE_SET, * PPRIVILEGE_SET; // // These must be converted to LUIDs before use. // #define SE_MIN_WELL_KNOWN_PRIVILEGE (2L) #define SE_CREATE_TOKEN_PRIVILEGE (2L) #define SE_ASSIGNPRIMARYTOKEN_PRIVILEGE (3L) #define SE_LOCK_MEMORY_PRIVILEGE (4L) #define SE_INCREASE_QUOTA_PRIVILEGE (5L) #define SE_MACHINE_ACCOUNT_PRIVILEGE (6L) #define SE_TCB_PRIVILEGE (7L) #define SE_SECURITY_PRIVILEGE (8L) #define SE_TAKE_OWNERSHIP_PRIVILEGE (9L) #define SE_LOAD_DRIVER_PRIVILEGE (10L) #define SE_SYSTEM_PROFILE_PRIVILEGE (11L) #define SE_SYSTEMTIME_PRIVILEGE (12L) #define SE_PROF_SINGLE_PROCESS_PRIVILEGE (13L) #define SE_INC_BASE_PRIORITY_PRIVILEGE (14L) #define SE_CREATE_PAGEFILE_PRIVILEGE (15L) #define SE_CREATE_PERMANENT_PRIVILEGE (16L) #define SE_BACKUP_PRIVILEGE (17L) #define SE_RESTORE_PRIVILEGE (18L) #define SE_SHUTDOWN_PRIVILEGE (19L) #define SE_DEBUG_PRIVILEGE (20L) #define SE_AUDIT_PRIVILEGE (21L) #define SE_SYSTEM_ENVIRONMENT_PRIVILEGE (22L) #define SE_CHANGE_NOTIFY_PRIVILEGE (23L) #define SE_REMOTE_SHUTDOWN_PRIVILEGE (24L) #define SE_UNDOCK_PRIVILEGE (25L) #define SE_SYNC_AGENT_PRIVILEGE (26L) #define SE_ENABLE_DELEGATION_PRIVILEGE (27L) #define SE_MANAGE_VOLUME_PRIVILEGE (28L) #define SE_IMPERSONATE_PRIVILEGE (29L) #define SE_CREATE_GLOBAL_PRIVILEGE (30L) #define SE_TRUSTED_CREDMAN_ACCESS_PRIVILEGE (31L) #define SE_RELABEL_PRIVILEGE (32L) #define SE_INC_WORKING_SET_PRIVILEGE (33L) #define SE_TIME_ZONE_PRIVILEGE (34L) #define SE_CREATE_SYMBOLIC_LINK_PRIVILEGE (35L) #define SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE (36L) #define SE_MAX_WELL_KNOWN_PRIVILEGE (SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE) // // Impersonation Level // // Impersonation level is represented by a pair of bits in Windows. // If a new impersonation level is added or lowest value is changed from // 0 to something else, fix the Windows CreateFile call. // typedef enum _SECURITY_IMPERSONATION_LEVEL { SecurityAnonymous, SecurityIdentification, SecurityImpersonation, SecurityDelegation } SECURITY_IMPERSONATION_LEVEL, * PSECURITY_IMPERSONATION_LEVEL; #define SECURITY_MAX_IMPERSONATION_LEVEL SecurityDelegation #define SECURITY_MIN_IMPERSONATION_LEVEL SecurityAnonymous #define DEFAULT_IMPERSONATION_LEVEL SecurityImpersonation #define VALID_IMPERSONATION_LEVEL(L) (((L) >= SECURITY_MIN_IMPERSONATION_LEVEL) && ((L) <= SECURITY_MAX_IMPERSONATION_LEVEL)) // // Security Tracking Mode // #define SECURITY_DYNAMIC_TRACKING (TRUE) #define SECURITY_STATIC_TRACKING (FALSE) typedef BOOLEAN SECURITY_CONTEXT_TRACKING_MODE, * PSECURITY_CONTEXT_TRACKING_MODE; // // Quality Of Service // typedef struct _SECURITY_QUALITY_OF_SERVICE { ULONG Length; SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; SECURITY_CONTEXT_TRACKING_MODE ContextTrackingMode; BOOLEAN EffectiveOnly; } SECURITY_QUALITY_OF_SERVICE, * PSECURITY_QUALITY_OF_SERVICE; // // Used to represent information related to a thread impersonation // typedef struct _SE_IMPERSONATION_STATE { PACCESS_TOKEN Token; BOOLEAN CopyOnOpen; BOOLEAN EffectiveOnly; SECURITY_IMPERSONATION_LEVEL Level; } SE_IMPERSONATION_STATE, *PSE_IMPERSONATION_STATE; typedef ULONG SECURITY_INFORMATION, *PSECURITY_INFORMATION; #define OWNER_SECURITY_INFORMATION (0x00000001L) #define GROUP_SECURITY_INFORMATION (0x00000002L) #define DACL_SECURITY_INFORMATION (0x00000004L) #define SACL_SECURITY_INFORMATION (0x00000008L) #define LABEL_SECURITY_INFORMATION (0x00000010L) #define ATTRIBUTE_SECURITY_INFORMATION (0x00000020L) #define SCOPE_SECURITY_INFORMATION (0x00000040L) #define PROCESS_TRUST_LABEL_SECURITY_INFORMATION (0x00000080L) #define BACKUP_SECURITY_INFORMATION (0x00010000L) #define PROTECTED_DACL_SECURITY_INFORMATION (0x80000000L) #define PROTECTED_SACL_SECURITY_INFORMATION (0x40000000L) #define UNPROTECTED_DACL_SECURITY_INFORMATION (0x20000000L) #define UNPROTECTED_SACL_SECURITY_INFORMATION (0x10000000L) #ifndef _NTLSA_IFS_ // // All of this stuff (between the Ifndef _NTLSA_AUDIT_ and its endif) were not // present in NTIFS prior to Windows Server 2003 SP1. All of the definitions however // exist down to windows 2000 (except for the few exceptions noted in the code). // #ifndef _NTLSA_AUDIT_ #define _NTLSA_AUDIT_ ///////////////////////////////////////////////////////////////////////// // // // Data types related to Auditing // // // ///////////////////////////////////////////////////////////////////////// // // The following enumerated type is used between the reference monitor and // LSA in the generation of audit messages. It is used to indicate the // type of data being passed as a parameter from the reference monitor // to LSA. LSA is responsible for transforming the specified data type // into a set of unicode strings that are added to the event record in // the audit log. // typedef enum _SE_ADT_PARAMETER_TYPE { SeAdtParmTypeNone = 0, //Produces 1 parameter //Received value: // // None. // //Results in: // // a unicode string containing "-". // //Note: This is typically used to // indicate that a parameter value // was not available. // SeAdtParmTypeString, //Produces 1 parameter. //Received Value: // // Unicode String (variable length) // //Results in: // // No transformation. The string // entered into the event record as // received. // // The Address value of the audit info // should be a pointer to a UNICODE_STRING // structure. SeAdtParmTypeFileSpec, //Produces 1 parameter. //Received value: // // Unicode string containing a file or // directory name. // //Results in: // // Unicode string with the prefix of the // file's path replaced by a drive letter // if possible. // SeAdtParmTypeUlong, //Produces 1 parameter //Received value: // // Ulong // //Results in: // // Unicode string representation of // unsigned integer value. SeAdtParmTypeSid, //Produces 1 parameter. //Received value: // // SID (variable length) // //Results in: // // String representation of SID // SeAdtParmTypeLogonId, //Produces 4 parameters. //Received Value: // // LUID (fixed length) // //Results in: // // param 1: Sid string // param 2: Username string // param 3: domain name string // param 4: Logon ID (Luid) string SeAdtParmTypeNoLogonId, //Produces 3 parameters. //Received value: // // None. // //Results in: // // param 1: "-" // param 2: "-" // param 3: "-" // param 4: "-" // //Note: // // This type is used when a logon ID // is needed, but one is not available // to pass. For example, if an // impersonation logon ID is expected // but the subject is not impersonating // anyone. // SeAdtParmTypeAccessMask, //Produces 1 parameter with formatting. //Received value: // // ACCESS_MASK followed by // a Unicode string. The unicode // string contains the name of the // type of object the access mask // applies to. The event's source // further qualifies the object type. // //Results in: // // formatted unicode string built to // take advantage of the specified // source's parameter message file. // //Note: // // An access mask containing three // access types for a Widget object // type (defined by the Foozle source) // might end up looking like: // // %%1062\n\t\t%1066\n\t\t%%601 // // The %%numbers are signals to the // event viewer to perform parameter // substitution before display. // SeAdtParmTypePrivs, //Produces 1 parameter with formatting. //Received value: // //Results in: // // formatted unicode string similar to // that for access types. Each priv // will be formatted to be displayed // on its own line. E.g., // // %%642\n\t\t%%651\n\t\t%%655 // SeAdtParmTypeObjectTypes, //Produces 10 parameters with formatting. //Received value: // // Produces a list a stringized GUIDS along // with information similar to that for // an access mask. SeAdtParmTypeHexUlong, //Produces 1 parameter //Received value: // // Ulong // //Results in: // // Unicode string representation of // unsigned integer value in hexadecimal. // In W2k this value did not exist, it was ParmTypeLUID SeAdtParmTypePtr, //Produces 1 parameter //Received value: // // pointer // //Results in: // // Unicode string representation of // unsigned integer value in hexadecimal. // // Everything below exists only in Windows XP and greater // SeAdtParmTypeTime, //Produces 2 parameters //Received value: // // LARGE_INTEGER // //Results in: // // Unicode string representation of // date and time. // SeAdtParmTypeGuid, //Produces 1 parameter //Received value: // // GUID pointer // //Results in: // // Unicode string representation of GUID // {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} // // // Everything below exists only in Windows Server 2003 and Greater // SeAdtParmTypeLuid, // //Produces 1 parameter //Received value: // // LUID // //Results in: // // Hex LUID // SeAdtParmTypeHexInt64, //Produces 1 parameter //Received value: // // 64 bit integer // //Results in: // // Unicode string representation of // unsigned integer value in hexadecimal. SeAdtParmTypeStringList, //Produces 1 parameter //Received value: // // ptr to LSAP_ADT_STRING_LIST // //Results in: // // Unicode string representation of // concatenation of the strings in the list SeAdtParmTypeSidList, //Produces 1 parameter //Received value: // // ptr to LSAP_ADT_SID_LIST // //Results in: // // Unicode string representation of // concatenation of the SIDs in the list SeAdtParmTypeDuration, //Produces 1 parameters //Received value: // // LARGE_INTEGER // //Results in: // // Unicode string representation of // a duration. SeAdtParmTypeUserAccountControl,//Produces 3 parameters //Received value: // // old and new UserAccountControl values // //Results in: // // Unicode string representations of // the flags in UserAccountControl. // 1 - old value in hex // 2 - new value in hex // 3 - difference as strings SeAdtParmTypeNoUac, //Produces 3 parameters //Received value: // // none // //Results in: // // Three dashes ('-') as unicode strings. SeAdtParmTypeMessage, //Produces 1 Parameter //Received value: // // ULONG (MessageNo from msobjs.mc) // //Results in: // // Unicode string representation of // %%MessageNo which the event viewer // will replace with the message string // from msobjs.mc SeAdtParmTypeDateTime, //Produces 1 Parameter //Received value: // // LARGE_INTEGER // //Results in: // // Unicode string representation of // date and time (in _one_ string). SeAdtParmTypeSockAddr, // Produces 2 parameters // // Received value: // // pointer to SOCKADDR_IN/SOCKADDR_IN6 // structure // // Results in: // // param 1: IP address string // param 2: Port number string // // // Everything below this exists only in Windows Server 2008 and greater // SeAdtParmTypeSD, // Produces 1 parameters // // Received value: // // pointer to SECURITY_DESCRIPTOR // structure. This HAS to appear in pairs. // The first parameter will represent the // old SD and the second parameter will // represent the New SD // // Results in: // // SDDL string representation of SD // SeAdtParmTypeLogonHours, // Produces 1 parameters // // Received value: // // pointer to LOGON_HOURS // structure // // Results in: // // String representation of allowed logon hours // SeAdtParmTypeLogonIdNoSid, //Produces 3 parameters. //Received Value: // // LUID (fixed length) // //Results in: // // param 1: Username string // param 2: domain name string // param 3: Logon ID (Luid) string SeAdtParmTypeUlongNoConv, // Produces 1 parameter. // Received Value: // Ulong // //Results in: // Not converted to string // SeAdtParmTypeSockAddrNoPort, // Produces 1 parameter // // Received value: // // pointer to SOCKADDR_IN/SOCKADDR_IN6 // structure // // Results in: // // param 1: IPv4/IPv6 address string // // // Everything below this exists only in Windows Server 2008 and greater // SeAdtParmTypeAccessReason, // Produces 1 parameters // // Received value: // // pointer to SE_ADT_ACCESS_REASON structure // // Results in: // // String representation of the access reason. // // // Everything below this exists only in Windows Server 2012 and greater // SeAdtParmTypeStagingReason, // Produces 1 parameters // // Received value: // // pointer to SE_ADT_ACCESS_REASON structure // // Results in: // // String representation of Staging policy's // access reason. // SeAdtParmTypeResourceAttribute, // Produces 1 parameters // // Received value: // // pointer to SECURITY_DESCRIPTOR // structure // // Results in: // // SDDL string representation of the // Resource Attribute ACEs in the SD // SeAdtParmTypeClaims, // Produces 1 parameters // // Received value: // // pointer to the structure - // CLAIM_SECURITY_ATTRIBUTES_INFORMATION // structure // // Results in: // // Claims information as attributes, value // pairs // SeAdtParmTypeLogonIdAsSid, // Produces 4 parameters. // Received Value: // // SID (variable length) // //Results in: // // param 1: Sid string (based on SID and not derived from the LUID) // param 2: - // param 3: - // param 4: - SeAdtParmTypeMultiSzString, //Produces 1 parameter //Received value: // // PZZWSTR string // //Results in: // // Unicode string with each null replaced with /r/n SeAdtParmTypeLogonIdEx, //Produces 4 parameters. //Received Value: // // LUID (fixed length) // //Results in: // // param 1: Sid string // param 2: Username string // param 3: domain name string // param 4: Logon ID (Luid) string } SE_ADT_PARAMETER_TYPE, *PSE_ADT_PARAMETER_TYPE; #ifndef GUID_DEFINED #include #endif /* GUID_DEFINED */ typedef struct _SE_ADT_OBJECT_TYPE { GUID ObjectType; USHORT Flags; #define SE_ADT_OBJECT_ONLY 0x1 USHORT Level; ACCESS_MASK AccessMask; } SE_ADT_OBJECT_TYPE, *PSE_ADT_OBJECT_TYPE; typedef struct _SE_ADT_PARAMETER_ARRAY_ENTRY { SE_ADT_PARAMETER_TYPE Type; ULONG Length; ULONG_PTR Data[2]; PVOID Address; } SE_ADT_PARAMETER_ARRAY_ENTRY, *PSE_ADT_PARAMETER_ARRAY_ENTRY; typedef struct _SE_ADT_ACCESS_REASON{ ACCESS_MASK AccessMask; ULONG AccessReasons[32]; ULONG ObjectTypeIndex; ULONG AccessGranted; PSECURITY_DESCRIPTOR SecurityDescriptor; // multple SDs may be stored here in self-relative way. } SE_ADT_ACCESS_REASON, *PSE_ADT_ACCESS_REASON; typedef struct _SE_ADT_CLAIMS { ULONG Length; PCLAIMS_BLOB Claims; // one claim blob will be stored here in self-relative way } SE_ADT_CLAIMS, *PSE_ADT_CLAIMS; // // Structure that will be passed between the Reference Monitor and LSA // to transmit auditing information. // #define SE_MAX_AUDIT_PARAMETERS 32 #define SE_MAX_GENERIC_AUDIT_PARAMETERS 28 typedef struct _SE_ADT_PARAMETER_ARRAY { ULONG CategoryId; ULONG AuditId; ULONG ParameterCount; ULONG Length; USHORT FlatSubCategoryId; USHORT Type; ULONG Flags; SE_ADT_PARAMETER_ARRAY_ENTRY Parameters[ SE_MAX_AUDIT_PARAMETERS ]; } SE_ADT_PARAMETER_ARRAY, *PSE_ADT_PARAMETER_ARRAY; typedef struct _SE_ADT_PARAMETER_ARRAY_EX { ULONG CategoryId; ULONG AuditId; ULONG Version; ULONG ParameterCount; ULONG Length; USHORT FlatSubCategoryId; USHORT Type; ULONG Flags; SE_ADT_PARAMETER_ARRAY_ENTRY Parameters[ SE_MAX_AUDIT_PARAMETERS ]; } SE_ADT_PARAMETER_ARRAY_EX, *PSE_ADT_PARAMETER_ARRAY_EX; #define SE_ADT_PARAMETERS_SELF_RELATIVE 0x00000001 #define SE_ADT_PARAMETERS_SEND_TO_LSA 0x00000002 #define SE_ADT_PARAMETER_EXTENSIBLE_AUDIT 0x00000004 #define SE_ADT_PARAMETER_GENERIC_AUDIT 0x00000008 #define SE_ADT_PARAMETER_WRITE_SYNCHRONOUS 0x00000010 // // This macro only existed in Windows Server 2008 and after // #define LSAP_SE_ADT_PARAMETER_ARRAY_TRUE_SIZE(AuditParameters) \ ( sizeof(SE_ADT_PARAMETER_ARRAY) - \ sizeof(SE_ADT_PARAMETER_ARRAY_ENTRY) * \ (SE_MAX_AUDIT_PARAMETERS - AuditParameters->ParameterCount) ) #endif // _NTLSA_AUDIT_ #endif // _NTLSA_IFS_ // // Define the various device type values. Note that values used by Microsoft // Corporation are in the range 0-32767, and 32768-65535 are reserved for use // by customers. // #define DEVICE_TYPE ULONG #define FILE_DEVICE_BEEP 0x00000001 #define FILE_DEVICE_CD_ROM 0x00000002 #define FILE_DEVICE_CD_ROM_FILE_SYSTEM 0x00000003 #define FILE_DEVICE_CONTROLLER 0x00000004 #define FILE_DEVICE_DATALINK 0x00000005 #define FILE_DEVICE_DFS 0x00000006 #define FILE_DEVICE_DISK 0x00000007 #define FILE_DEVICE_DISK_FILE_SYSTEM 0x00000008 #define FILE_DEVICE_FILE_SYSTEM 0x00000009 #define FILE_DEVICE_INPORT_PORT 0x0000000a #define FILE_DEVICE_KEYBOARD 0x0000000b #define FILE_DEVICE_MAILSLOT 0x0000000c #define FILE_DEVICE_MIDI_IN 0x0000000d #define FILE_DEVICE_MIDI_OUT 0x0000000e #define FILE_DEVICE_MOUSE 0x0000000f #define FILE_DEVICE_MULTI_UNC_PROVIDER 0x00000010 #define FILE_DEVICE_NAMED_PIPE 0x00000011 #define FILE_DEVICE_NETWORK 0x00000012 #define FILE_DEVICE_NETWORK_BROWSER 0x00000013 #define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014 #define FILE_DEVICE_NULL 0x00000015 #define FILE_DEVICE_PARALLEL_PORT 0x00000016 #define FILE_DEVICE_PHYSICAL_NETCARD 0x00000017 #define FILE_DEVICE_PRINTER 0x00000018 #define FILE_DEVICE_SCANNER 0x00000019 #define FILE_DEVICE_SERIAL_MOUSE_PORT 0x0000001a #define FILE_DEVICE_SERIAL_PORT 0x0000001b #define FILE_DEVICE_SCREEN 0x0000001c #define FILE_DEVICE_SOUND 0x0000001d #define FILE_DEVICE_STREAMS 0x0000001e #define FILE_DEVICE_TAPE 0x0000001f #define FILE_DEVICE_TAPE_FILE_SYSTEM 0x00000020 #define FILE_DEVICE_TRANSPORT 0x00000021 #define FILE_DEVICE_UNKNOWN 0x00000022 #define FILE_DEVICE_VIDEO 0x00000023 #define FILE_DEVICE_VIRTUAL_DISK 0x00000024 #define FILE_DEVICE_WAVE_IN 0x00000025 #define FILE_DEVICE_WAVE_OUT 0x00000026 #define FILE_DEVICE_8042_PORT 0x00000027 #define FILE_DEVICE_NETWORK_REDIRECTOR 0x00000028 #define FILE_DEVICE_BATTERY 0x00000029 #define FILE_DEVICE_BUS_EXTENDER 0x0000002a #define FILE_DEVICE_MODEM 0x0000002b #define FILE_DEVICE_VDM 0x0000002c #define FILE_DEVICE_MASS_STORAGE 0x0000002d #define FILE_DEVICE_SMB 0x0000002e #define FILE_DEVICE_KS 0x0000002f #define FILE_DEVICE_CHANGER 0x00000030 #define FILE_DEVICE_SMARTCARD 0x00000031 #define FILE_DEVICE_ACPI 0x00000032 #define FILE_DEVICE_DVD 0x00000033 #define FILE_DEVICE_FULLSCREEN_VIDEO 0x00000034 #define FILE_DEVICE_DFS_FILE_SYSTEM 0x00000035 #define FILE_DEVICE_DFS_VOLUME 0x00000036 #define FILE_DEVICE_SERENUM 0x00000037 #define FILE_DEVICE_TERMSRV 0x00000038 #define FILE_DEVICE_KSEC 0x00000039 #define FILE_DEVICE_FIPS 0x0000003A #define FILE_DEVICE_INFINIBAND 0x0000003B #define FILE_DEVICE_VMBUS 0x0000003E #define FILE_DEVICE_CRYPT_PROVIDER 0x0000003F #define FILE_DEVICE_WPD 0x00000040 #define FILE_DEVICE_BLUETOOTH 0x00000041 #define FILE_DEVICE_MT_COMPOSITE 0x00000042 #define FILE_DEVICE_MT_TRANSPORT 0x00000043 #define FILE_DEVICE_BIOMETRIC 0x00000044 #define FILE_DEVICE_PMI 0x00000045 #define FILE_DEVICE_EHSTOR 0x00000046 #define FILE_DEVICE_DEVAPI 0x00000047 #define FILE_DEVICE_GPIO 0x00000048 #define FILE_DEVICE_USBEX 0x00000049 #define FILE_DEVICE_CONSOLE 0x00000050 #define FILE_DEVICE_NFP 0x00000051 #define FILE_DEVICE_SYSENV 0x00000052 #define FILE_DEVICE_VIRTUAL_BLOCK 0x00000053 #define FILE_DEVICE_POINT_OF_SERVICE 0x00000054 #define FILE_DEVICE_STORAGE_REPLICATION 0x00000055 #define FILE_DEVICE_TRUST_ENV 0x00000056 #define FILE_DEVICE_UCM 0x00000057 #define FILE_DEVICE_UCMTCPCI 0x00000058 // // Macro definition for defining IOCTL and FSCTL function control codes. Note // that function codes 0-2047 are reserved for Microsoft Corporation, and // 2048-4095 are reserved for customers. // #define CTL_CODE( DeviceType, Function, Method, Access ) ( \ ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \ ) // // Macro to extract device type out of the device io control code // #define DEVICE_TYPE_FROM_CTL_CODE(ctrlCode) (((ULONG)(ctrlCode & 0xffff0000)) >> 16) // // Macro to extract buffering method out of the device io control code // #define METHOD_FROM_CTL_CODE(ctrlCode) ((ULONG)(ctrlCode & 3)) // // Define the method codes for how buffers are passed for I/O and FS controls // #define METHOD_BUFFERED 0 #define METHOD_IN_DIRECT 1 #define METHOD_OUT_DIRECT 2 #define METHOD_NEITHER 3 // // Define some easier to comprehend aliases: // METHOD_DIRECT_TO_HARDWARE (writes, aka METHOD_IN_DIRECT) // METHOD_DIRECT_FROM_HARDWARE (reads, aka METHOD_OUT_DIRECT) // #define METHOD_DIRECT_TO_HARDWARE METHOD_IN_DIRECT #define METHOD_DIRECT_FROM_HARDWARE METHOD_OUT_DIRECT // // Define the access check value for any access // // // The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in // ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these // constants *MUST* always be in sync. // // // FILE_SPECIAL_ACCESS is checked by the NT I/O system the same as FILE_ANY_ACCESS. // The file systems, however, may add additional access checks for I/O and FS controls // that use this value. // #define FILE_ANY_ACCESS 0 #define FILE_SPECIAL_ACCESS (FILE_ANY_ACCESS) #define FILE_READ_ACCESS ( 0x0001 ) // file & pipe #define FILE_WRITE_ACCESS ( 0x0002 ) // file & pipe // begin_access // // Define access rights to files and directories // // // The FILE_READ_DATA and FILE_WRITE_DATA constants are also defined in // devioctl.h as FILE_READ_ACCESS and FILE_WRITE_ACCESS. The values for these // constants *MUST* always be in sync. // The values are redefined in devioctl.h because they must be available to // both DOS and NT. // #define FILE_READ_DATA ( 0x0001 ) // file & pipe #define FILE_LIST_DIRECTORY ( 0x0001 ) // directory #define FILE_WRITE_DATA ( 0x0002 ) // file & pipe #define FILE_ADD_FILE ( 0x0002 ) // directory #define FILE_APPEND_DATA ( 0x0004 ) // file #define FILE_ADD_SUBDIRECTORY ( 0x0004 ) // directory #define FILE_CREATE_PIPE_INSTANCE ( 0x0004 ) // named pipe #define FILE_READ_EA ( 0x0008 ) // file & directory #define FILE_WRITE_EA ( 0x0010 ) // file & directory #define FILE_EXECUTE ( 0x0020 ) // file #define FILE_TRAVERSE ( 0x0020 ) // directory #define FILE_DELETE_CHILD ( 0x0040 ) // directory #define FILE_READ_ATTRIBUTES ( 0x0080 ) // all #define FILE_WRITE_ATTRIBUTES ( 0x0100 ) // all #define FILE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF) #define FILE_GENERIC_READ (STANDARD_RIGHTS_READ |\ FILE_READ_DATA |\ FILE_READ_ATTRIBUTES |\ FILE_READ_EA |\ SYNCHRONIZE) #define FILE_GENERIC_WRITE (STANDARD_RIGHTS_WRITE |\ FILE_WRITE_DATA |\ FILE_WRITE_ATTRIBUTES |\ FILE_WRITE_EA |\ FILE_APPEND_DATA |\ SYNCHRONIZE) #define FILE_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE |\ FILE_READ_ATTRIBUTES |\ FILE_EXECUTE |\ SYNCHRONIZE) // end_access // // Define share access rights to files and directories // #define FILE_SHARE_READ 0x00000001 #define FILE_SHARE_WRITE 0x00000002 #define FILE_SHARE_DELETE 0x00000004 #define FILE_SHARE_VALID_FLAGS 0x00000007 // // Define the file attributes values // // Note: 0x00000008 is reserved for use for the old DOS VOLID (volume ID) // and is therefore not considered valid in NT. // // Note: Note also that the order of these flags is set to allow both the // FAT and the Pinball File Systems to directly set the attributes // flags in attributes words without having to pick each flag out // individually. The order of these flags should not be changed! // #define FILE_ATTRIBUTE_READONLY 0x00000001 #define FILE_ATTRIBUTE_HIDDEN 0x00000002 #define FILE_ATTRIBUTE_SYSTEM 0x00000004 //OLD DOS VOLID 0x00000008 #define FILE_ATTRIBUTE_DIRECTORY 0x00000010 #define FILE_ATTRIBUTE_ARCHIVE 0x00000020 #define FILE_ATTRIBUTE_DEVICE 0x00000040 #define FILE_ATTRIBUTE_NORMAL 0x00000080 #define FILE_ATTRIBUTE_TEMPORARY 0x00000100 #define FILE_ATTRIBUTE_SPARSE_FILE 0x00000200 #define FILE_ATTRIBUTE_REPARSE_POINT 0x00000400 #define FILE_ATTRIBUTE_COMPRESSED 0x00000800 #define FILE_ATTRIBUTE_OFFLINE 0x00001000 #define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x00002000 #define FILE_ATTRIBUTE_ENCRYPTED 0x00004000 #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) #define FILE_ATTRIBUTE_INTEGRITY_STREAM 0x00008000 #endif #define FILE_ATTRIBUTE_VIRTUAL 0x00010000 #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) #define FILE_ATTRIBUTE_NO_SCRUB_DATA 0x00020000 #endif #if (_WIN32_WINNT > _WIN32_WINNT_WINBLUE || (_WIN32_WINNT == _WIN32_WINNT_WINBLUE && defined(WINBLUE_KBSPRING14))) #define FILE_ATTRIBUTE_EA 0x00040000 #endif #if (_WIN32_WINNT < _WIN32_WINNT_WIN8) #define FILE_ATTRIBUTE_VALID_FLAGS 0x00007fb7 #define FILE_ATTRIBUTE_VALID_SET_FLAGS 0x000031a7 #else #define FILE_ATTRIBUTE_VALID_FLAGS 0x0002ffb7 #define FILE_ATTRIBUTE_VALID_SET_FLAGS 0x000231a7 #endif // // Define the create disposition values // #define FILE_SUPERSEDE 0x00000000 #define FILE_OPEN 0x00000001 #define FILE_CREATE 0x00000002 #define FILE_OPEN_IF 0x00000003 #define FILE_OVERWRITE 0x00000004 #define FILE_OVERWRITE_IF 0x00000005 #define FILE_MAXIMUM_DISPOSITION 0x00000005 // // Define the create/open option flags // #define FILE_DIRECTORY_FILE 0x00000001 #define FILE_WRITE_THROUGH 0x00000002 #define FILE_SEQUENTIAL_ONLY 0x00000004 #define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008 #define FILE_SYNCHRONOUS_IO_ALERT 0x00000010 #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020 #define FILE_NON_DIRECTORY_FILE 0x00000040 #define FILE_CREATE_TREE_CONNECTION 0x00000080 #define FILE_COMPLETE_IF_OPLOCKED 0x00000100 #define FILE_NO_EA_KNOWLEDGE 0x00000200 #define FILE_OPEN_REMOTE_INSTANCE 0x00000400 #define FILE_RANDOM_ACCESS 0x00000800 #define FILE_DELETE_ON_CLOSE 0x00001000 #define FILE_OPEN_BY_FILE_ID 0x00002000 #define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000 #define FILE_NO_COMPRESSION 0x00008000 #if (NTDDI_VERSION >= NTDDI_WIN7) #define FILE_OPEN_REQUIRING_OPLOCK 0x00010000 #define FILE_DISALLOW_EXCLUSIVE 0x00020000 #endif /* NTDDI_VERSION >= NTDDI_WIN7 */ #if (NTDDI_VERSION >= NTDDI_WIN8) #define FILE_SESSION_AWARE 0x00040000 #endif /* NTDDI_VERSION >= NTDDI_WIN8 */ #define FILE_RESERVE_OPFILTER 0x00100000 #define FILE_OPEN_REPARSE_POINT 0x00200000 #define FILE_OPEN_NO_RECALL 0x00400000 #define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000 // // The FILE_VALID_OPTION_FLAGS mask cannot be expanded to include the // highest 8 bits of the DWORD because those are used to represent the // create disposition in the IO Request Packet when sending information // to the file system // #define FILE_VALID_OPTION_FLAGS 0x00ffffff #define FILE_VALID_PIPE_OPTION_FLAGS 0x00000032 #define FILE_VALID_MAILSLOT_OPTION_FLAGS 0x00000032 #define FILE_VALID_SET_FLAGS 0x00000036 // // Define the I/O status information return values for NtCreateFile/NtOpenFile // #define FILE_SUPERSEDED 0x00000000 #define FILE_OPENED 0x00000001 #define FILE_CREATED 0x00000002 #define FILE_OVERWRITTEN 0x00000003 #define FILE_EXISTS 0x00000004 #define FILE_DOES_NOT_EXIST 0x00000005 // // Define special ByteOffset parameters for read and write operations // #define FILE_WRITE_TO_END_OF_FILE 0xffffffff #define FILE_USE_FILE_POINTER_POSITION 0xfffffffe // // Define alignment requirement values // #define FILE_BYTE_ALIGNMENT 0x00000000 #define FILE_WORD_ALIGNMENT 0x00000001 #define FILE_LONG_ALIGNMENT 0x00000003 #define FILE_QUAD_ALIGNMENT 0x00000007 #define FILE_OCTA_ALIGNMENT 0x0000000f #define FILE_32_BYTE_ALIGNMENT 0x0000001f #define FILE_64_BYTE_ALIGNMENT 0x0000003f #define FILE_128_BYTE_ALIGNMENT 0x0000007f #define FILE_256_BYTE_ALIGNMENT 0x000000ff #define FILE_512_BYTE_ALIGNMENT 0x000001ff // // Define the maximum length of a filename string // #define MAXIMUM_FILENAME_LENGTH 256 // // Define the various device characteristics flags // #define FILE_REMOVABLE_MEDIA 0x00000001 #define FILE_READ_ONLY_DEVICE 0x00000002 #define FILE_FLOPPY_DISKETTE 0x00000004 #define FILE_WRITE_ONCE_MEDIA 0x00000008 #define FILE_REMOTE_DEVICE 0x00000010 #define FILE_DEVICE_IS_MOUNTED 0x00000020 #define FILE_VIRTUAL_VOLUME 0x00000040 #define FILE_AUTOGENERATED_DEVICE_NAME 0x00000080 #define FILE_DEVICE_SECURE_OPEN 0x00000100 #define FILE_CHARACTERISTIC_PNP_DEVICE 0x00000800 #define FILE_CHARACTERISTIC_TS_DEVICE 0x00001000 #define FILE_CHARACTERISTIC_WEBDAV_DEVICE 0x00002000 #define FILE_CHARACTERISTIC_CSV 0x00010000 #define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL 0x00020000 #define FILE_PORTABLE_DEVICE 0x00040000 // // Define the base asynchronous I/O argument types // typedef struct _IO_STATUS_BLOCK { union { NTSTATUS Status; PVOID Pointer; } DUMMYUNIONNAME; ULONG_PTR Information; } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; typedef struct _IO_STATUS_BLOCK32 { NTSTATUS Status; ULONG Information; } IO_STATUS_BLOCK32, *PIO_STATUS_BLOCK32; // // Define an Asynchronous Procedure Call from I/O viewpoint // typedef VOID (NTAPI *PIO_APC_ROUTINE) ( _In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved ); #define PIO_APC_ROUTINE_DEFINED // // Define the session states and events // typedef enum _IO_SESSION_EVENT { IoSessionEventIgnore = 0, IoSessionEventCreated, // 1 IoSessionEventTerminated, // 2 IoSessionEventConnected, // 3 IoSessionEventDisconnected, // 4 IoSessionEventLogon, // 5 IoSessionEventLogoff, // 6 IoSessionEventMax } IO_SESSION_EVENT, *PIO_SESSION_EVENT; typedef enum _IO_SESSION_STATE { IoSessionStateCreated = 1, IoSessionStateInitialized, // 2 IoSessionStateConnected, // 3 IoSessionStateDisconnected, // 4 IoSessionStateDisconnectedLoggedOn, // 5 IoSessionStateLoggedOn, // 6 IoSessionStateLoggedOff, // 7 IoSessionStateTerminated, // 8 IoSessionStateMax } IO_SESSION_STATE, *PIO_SESSION_STATE; // // Define masks that determine which events a driver that registers for // callbacks care about // #define IO_SESSION_STATE_ALL_EVENTS 0xffffffff #define IO_SESSION_STATE_CREATION_EVENT 0x00000001 #define IO_SESSION_STATE_TERMINATION_EVENT 0x00000002 #define IO_SESSION_STATE_CONNECT_EVENT 0x00000004 #define IO_SESSION_STATE_DISCONNECT_EVENT 0x00000008 #define IO_SESSION_STATE_LOGON_EVENT 0x00000010 #define IO_SESSION_STATE_LOGOFF_EVENT 0x00000020 #define IO_SESSION_STATE_VALID_EVENT_MASK 0x0000003f #define IO_SESSION_MAX_PAYLOAD_SIZE 256L // // Payload structures // // IoSessionEventConnected typedef struct _IO_SESSION_CONNECT_INFO { ULONG SessionId; BOOLEAN LocalSession; } IO_SESSION_CONNECT_INFO, *PIO_SESSION_CONNECT_INFO; // // Define the file information class values // // WARNING: The order of the following values are assumed by the I/O system. // Any changes made here should be reflected there as well. // typedef enum _FILE_INFORMATION_CLASS { FileDirectoryInformation = 1, FileFullDirectoryInformation, // 2 FileBothDirectoryInformation, // 3 FileBasicInformation, // 4 FileStandardInformation, // 5 FileInternalInformation, // 6 FileEaInformation, // 7 FileAccessInformation, // 8 FileNameInformation, // 9 FileRenameInformation, // 10 FileLinkInformation, // 11 FileNamesInformation, // 12 FileDispositionInformation, // 13 FilePositionInformation, // 14 FileFullEaInformation, // 15 FileModeInformation, // 16 FileAlignmentInformation, // 17 FileAllInformation, // 18 FileAllocationInformation, // 19 FileEndOfFileInformation, // 20 FileAlternateNameInformation, // 21 FileStreamInformation, // 22 FilePipeInformation, // 23 FilePipeLocalInformation, // 24 FilePipeRemoteInformation, // 25 FileMailslotQueryInformation, // 26 FileMailslotSetInformation, // 27 FileCompressionInformation, // 28 FileObjectIdInformation, // 29 FileCompletionInformation, // 30 FileMoveClusterInformation, // 31 FileQuotaInformation, // 32 FileReparsePointInformation, // 33 FileNetworkOpenInformation, // 34 FileAttributeTagInformation, // 35 FileTrackingInformation, // 36 FileIdBothDirectoryInformation, // 37 FileIdFullDirectoryInformation, // 38 FileValidDataLengthInformation, // 39 FileShortNameInformation, // 40 FileIoCompletionNotificationInformation, // 41 FileIoStatusBlockRangeInformation, // 42 FileIoPriorityHintInformation, // 43 FileSfioReserveInformation, // 44 FileSfioVolumeInformation, // 45 FileHardLinkInformation, // 46 FileProcessIdsUsingFileInformation, // 47 FileNormalizedNameInformation, // 48 FileNetworkPhysicalNameInformation, // 49 FileIdGlobalTxDirectoryInformation, // 50 FileIsRemoteDeviceInformation, // 51 FileUnusedInformation, // 52 FileNumaNodeInformation, // 53 FileStandardLinkInformation, // 54 FileRemoteProtocolInformation, // 55 // // These are special versions of these operations (defined earlier) // which can be used by kernel mode drivers only to bypass security // access checks for Rename and HardLink operations. These operations // are only recognized by the IOManager, a file system should never // receive these. // FileRenameInformationBypassAccessCheck, // 56 FileLinkInformationBypassAccessCheck, // 57 // // End of special information classes reserved for IOManager. // FileVolumeNameInformation, // 58 FileIdInformation, // 59 FileIdExtdDirectoryInformation, // 60 FileReplaceCompletionInformation, // 61 FileHardLinkFullIdInformation, // 62 FileIdExtdBothDirectoryInformation, // 63 FileDispositionInformationEx, // 64 FileRenameInformationEx, // 65 FileRenameInformationExBypassAccessCheck, // 66 FileMaximumInformation } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS; // // Define the various structures which are returned on query operations // typedef struct _FILE_BASIC_INFORMATION { LARGE_INTEGER CreationTime; LARGE_INTEGER LastAccessTime; LARGE_INTEGER LastWriteTime; LARGE_INTEGER ChangeTime; ULONG FileAttributes; } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION; typedef struct _FILE_STANDARD_INFORMATION { LARGE_INTEGER AllocationSize; LARGE_INTEGER EndOfFile; ULONG NumberOfLinks; BOOLEAN DeletePending; BOOLEAN Directory; } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION; #if (_WIN32_WINNT >= _WIN32_WINNT_WINTHRESHOLD) typedef struct _FILE_STANDARD_INFORMATION_EX { LARGE_INTEGER AllocationSize; LARGE_INTEGER EndOfFile; ULONG NumberOfLinks; BOOLEAN DeletePending; BOOLEAN Directory; BOOLEAN AlternateStream; BOOLEAN MetadataAttribute; } FILE_STANDARD_INFORMATION_EX, *PFILE_STANDARD_INFORMATION_EX; #endif typedef struct _FILE_POSITION_INFORMATION { LARGE_INTEGER CurrentByteOffset; } FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION; typedef struct _FILE_NETWORK_OPEN_INFORMATION { LARGE_INTEGER CreationTime; LARGE_INTEGER LastAccessTime; LARGE_INTEGER LastWriteTime; LARGE_INTEGER ChangeTime; LARGE_INTEGER AllocationSize; LARGE_INTEGER EndOfFile; ULONG FileAttributes; } FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION; typedef struct _FILE_FULL_EA_INFORMATION { ULONG NextEntryOffset; UCHAR Flags; UCHAR EaNameLength; USHORT EaValueLength; CHAR EaName[1]; } FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION; // // Support to reserve bandwidth for a file handle. // typedef struct _FILE_SFIO_RESERVE_INFORMATION { ULONG RequestsPerPeriod; ULONG Period; BOOLEAN RetryFailures; BOOLEAN Discardable; ULONG RequestSize; ULONG NumOutstandingRequests; } FILE_SFIO_RESERVE_INFORMATION, *PFILE_SFIO_RESERVE_INFORMATION; // // Support to query bandwidth properties of a volume. // typedef struct _FILE_SFIO_VOLUME_INFORMATION { ULONG MaximumRequestsPerPeriod; ULONG MinimumPeriod; ULONG MinimumTransferSize; } FILE_SFIO_VOLUME_INFORMATION, *PFILE_SFIO_VOLUME_INFORMATION; // // Support to set priority hints on a filehandle. // typedef enum _IO_PRIORITY_HINT { IoPriorityVeryLow = 0, // Defragging, content indexing and other background I/Os IoPriorityLow, // Prefetching for applications. IoPriorityNormal, // Normal I/Os IoPriorityHigh, // Used by filesystems for checkpoint I/O IoPriorityCritical, // Used by memory manager. Not available for applications. MaxIoPriorityTypes } IO_PRIORITY_HINT; typedef struct _FILE_IO_PRIORITY_HINT_INFORMATION { IO_PRIORITY_HINT PriorityHint; } FILE_IO_PRIORITY_HINT_INFORMATION, *PFILE_IO_PRIORITY_HINT_INFORMATION; typedef struct _FILE_IO_PRIORITY_HINT_INFORMATION_EX { IO_PRIORITY_HINT PriorityHint; BOOLEAN BoostOutstanding; } FILE_IO_PRIORITY_HINT_INFORMATION_EX, *PFILE_IO_PRIORITY_HINT_INFORMATION_EX; // // Don't queue an entry to an associated completion port if returning success // synchronously. // #define FILE_SKIP_COMPLETION_PORT_ON_SUCCESS 0x1 // // Don't set the file handle event on IO completion. // #define FILE_SKIP_SET_EVENT_ON_HANDLE 0x2 // // Don't set user supplied event on successful fast-path IO completion. // #define FILE_SKIP_SET_USER_EVENT_ON_FAST_IO 0x4 typedef struct _FILE_IO_COMPLETION_NOTIFICATION_INFORMATION { ULONG Flags; } FILE_IO_COMPLETION_NOTIFICATION_INFORMATION, *PFILE_IO_COMPLETION_NOTIFICATION_INFORMATION; typedef struct _FILE_PROCESS_IDS_USING_FILE_INFORMATION { ULONG NumberOfProcessIdsInList; ULONG_PTR ProcessIdList[1]; } FILE_PROCESS_IDS_USING_FILE_INFORMATION, *PFILE_PROCESS_IDS_USING_FILE_INFORMATION; typedef struct _FILE_IS_REMOTE_DEVICE_INFORMATION { BOOLEAN IsRemote; } FILE_IS_REMOTE_DEVICE_INFORMATION, *PFILE_IS_REMOTE_DEVICE_INFORMATION; typedef struct _FILE_NUMA_NODE_INFORMATION { USHORT NodeNumber; } FILE_NUMA_NODE_INFORMATION, *PFILE_NUMA_NODE_INFORMATION; // // Set an range of IOSBs on a file handle. // typedef struct _FILE_IOSTATUSBLOCK_RANGE_INFORMATION { PUCHAR IoStatusBlockRange; ULONG Length; } FILE_IOSTATUSBLOCK_RANGE_INFORMATION, *PFILE_IOSTATUSBLOCK_RANGE_INFORMATION; // // Define the file system information class values // // WARNING: The order of the following values are assumed by the I/O system. // Any changes made here should be reflected there as well. typedef enum _FSINFOCLASS { FileFsVolumeInformation = 1, FileFsLabelInformation, // 2 FileFsSizeInformation, // 3 FileFsDeviceInformation, // 4 FileFsAttributeInformation, // 5 FileFsControlInformation, // 6 FileFsFullSizeInformation, // 7 FileFsObjectIdInformation, // 8 FileFsDriverPathInformation, // 9 FileFsVolumeFlagsInformation, // 10 FileFsSectorSizeInformation, // 11 FileFsDataCopyInformation, // 12 FileFsMetadataSizeInformation, // 13 FileFsMaximumInformation } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS; typedef struct _FILE_FS_DEVICE_INFORMATION { DEVICE_TYPE DeviceType; ULONG Characteristics; } FILE_FS_DEVICE_INFORMATION, *PFILE_FS_DEVICE_INFORMATION; // // Define segement buffer structure for scatter/gather read/write. // typedef union _FILE_SEGMENT_ELEMENT { PVOID64 Buffer; ULONGLONG Alignment; }FILE_SEGMENT_ELEMENT, *PFILE_SEGMENT_ELEMENT; #if (NTDDI_VERSION >= NTDDI_WIN8) // // Flag defintions for NtFlushBuffersFileEx // // If none of the below flags are specified the following will occur for a // given file handle: // - Write any modified data for the given file from the Windows in-memory // cache. // - Commit all pending metadata changes for the given file from the // Windows in-memory cache. // - Send a SYNC command to the underlying storage device to commit all // written data in the devices cache to persistent storage. // // If a volume handle is specified: // - Write all modified data for all files on the volume from the Windows // in-memory cache. // - Commit all pending metadata changes for all files on the volume from // the Windows in-memory cache. // - Send a SYNC command to the underlying storage device to commit all // written data in the devices cache to persistent storage. // // This is equivalent to how NtFlushBuffersFile has always worked. // // // If set, this operation will write the data for the given file from the // Windows in-memory cache. This will NOT commit any associated metadata // changes. This will NOT send a SYNC to the storage device to flush its // cache. Not supported on volume handles. Only supported by the NTFS // filesystem. // #define FLUSH_FLAGS_FILE_DATA_ONLY 0x00000001 // // If set, this operation will commit both the data and metadata changes for // the given file from the Windows in-memory cache. This will NOT send a SYNC // to the storage device to flush its cache. Not supported on volume handles. // Only supported by the NTFS filesystem. // #define FLUSH_FLAGS_NO_SYNC 0x00000002 #endif // (NTDDI_VERSION >= NTDDI_WIN8) #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) // // If set, this operation will write the data for the given file from the // Windows in-memory cache. It will also try to skip updating the timestamp // as much as possible. This will send a SYNC to the storage device to flush its // cache. Not supported on volume or directory handles. Only supported by the NTFS // filesystem. // #define FLUSH_FLAGS_FILE_DATA_SYNC_ONLY 0x00000004 #endif // (NTDDI_VERSION >= NTDDI_WIN10_RS1) // // Define the I/O bus interface types. // typedef enum _INTERFACE_TYPE { InterfaceTypeUndefined = -1, Internal, Isa, Eisa, MicroChannel, TurboChannel, PCIBus, VMEBus, NuBus, PCMCIABus, CBus, MPIBus, MPSABus, ProcessorInternal, InternalPowerBus, PNPISABus, PNPBus, Vmcs, ACPIBus, MaximumInterfaceType }INTERFACE_TYPE, *PINTERFACE_TYPE; // // Define the DMA transfer widths. // typedef enum _DMA_WIDTH { Width8Bits, Width16Bits, Width32Bits, Width64Bits, WidthNoWrap, MaximumDmaWidth }DMA_WIDTH, *PDMA_WIDTH; // // Define DMA transfer speeds. // typedef enum _DMA_SPEED { Compatible, TypeA, TypeB, TypeC, TypeF, MaximumDmaSpeed }DMA_SPEED, *PDMA_SPEED; // // Define Interface reference/dereference routines for // Interfaces exported by IRP_MN_QUERY_INTERFACE // typedef VOID (*PINTERFACE_REFERENCE)(PVOID Context); typedef VOID (*PINTERFACE_DEREFERENCE)(PVOID Context); // // Define I/O Driver error log packet structure. This structure is filled in // by the driver. // typedef struct _IO_ERROR_LOG_PACKET { UCHAR MajorFunctionCode; UCHAR RetryCount; USHORT DumpDataSize; USHORT NumberOfStrings; USHORT StringOffset; USHORT EventCategory; NTSTATUS ErrorCode; ULONG UniqueErrorValue; NTSTATUS FinalStatus; ULONG SequenceNumber; ULONG IoControlCode; LARGE_INTEGER DeviceOffset; ULONG DumpData[1]; }IO_ERROR_LOG_PACKET, *PIO_ERROR_LOG_PACKET; // // Define the I/O error log message. This message is sent by the error log // thread over the lpc port. // typedef struct _IO_ERROR_LOG_MESSAGE { USHORT Type; USHORT Size; USHORT DriverNameLength; LARGE_INTEGER TimeStamp; ULONG DriverNameOffset; IO_ERROR_LOG_PACKET EntryData; }IO_ERROR_LOG_MESSAGE, *PIO_ERROR_LOG_MESSAGE; // // Define the maximum message size that will be sent over the LPC to the // application reading the error log entries. // // // Regardless of LPC size restrictions, ERROR_LOG_MAXIMUM_SIZE must remain // a value that can fit in a UCHAR. // #define ERROR_LOG_LIMIT_SIZE (256-16) // // This limit, exclusive of IO_ERROR_LOG_MESSAGE_HEADER_LENGTH, also applies // to IO_ERROR_LOG_MESSAGE_LENGTH // #define IO_ERROR_LOG_MESSAGE_HEADER_LENGTH (sizeof(IO_ERROR_LOG_MESSAGE) - \ sizeof(IO_ERROR_LOG_PACKET) + \ (sizeof(WCHAR) * 40)) #define ERROR_LOG_MESSAGE_LIMIT_SIZE \ (ERROR_LOG_LIMIT_SIZE + IO_ERROR_LOG_MESSAGE_HEADER_LENGTH) // // IO_ERROR_LOG_MESSAGE_LENGTH is // min(PORT_MAXIMUM_MESSAGE_LENGTH, ERROR_LOG_MESSAGE_LIMIT_SIZE) // #define IO_ERROR_LOG_MESSAGE_LENGTH \ ((PORT_MAXIMUM_MESSAGE_LENGTH > ERROR_LOG_MESSAGE_LIMIT_SIZE) ? \ ERROR_LOG_MESSAGE_LIMIT_SIZE : \ PORT_MAXIMUM_MESSAGE_LENGTH) // // Define the maximum packet size a driver can allocate. // #define ERROR_LOG_MAXIMUM_SIZE (IO_ERROR_LOG_MESSAGE_LENGTH - \ IO_ERROR_LOG_MESSAGE_HEADER_LENGTH) #ifdef _WIN64 #define PORT_MAXIMUM_MESSAGE_LENGTH 512 #else #define PORT_MAXIMUM_MESSAGE_LENGTH 256 #endif // begin_access // // Registry Specific Access Rights. // #define KEY_QUERY_VALUE (0x0001) #define KEY_SET_VALUE (0x0002) #define KEY_CREATE_SUB_KEY (0x0004) #define KEY_ENUMERATE_SUB_KEYS (0x0008) #define KEY_NOTIFY (0x0010) #define KEY_CREATE_LINK (0x0020) #define KEY_WOW64_32KEY (0x0200) #define KEY_WOW64_64KEY (0x0100) #define KEY_WOW64_RES (0x0300) #define KEY_READ ((STANDARD_RIGHTS_READ |\ KEY_QUERY_VALUE |\ KEY_ENUMERATE_SUB_KEYS |\ KEY_NOTIFY) \ & \ (~SYNCHRONIZE)) #define KEY_WRITE ((STANDARD_RIGHTS_WRITE |\ KEY_SET_VALUE |\ KEY_CREATE_SUB_KEY) \ & \ (~SYNCHRONIZE)) #define KEY_EXECUTE ((KEY_READ) \ & \ (~SYNCHRONIZE)) #define KEY_ALL_ACCESS ((STANDARD_RIGHTS_ALL |\ KEY_QUERY_VALUE |\ KEY_SET_VALUE |\ KEY_CREATE_SUB_KEY |\ KEY_ENUMERATE_SUB_KEYS |\ KEY_NOTIFY |\ KEY_CREATE_LINK) \ & \ (~SYNCHRONIZE)) // end_access // // Open/Create Options // #define REG_OPTION_RESERVED (0x00000000L) // Parameter is reserved #define REG_OPTION_NON_VOLATILE (0x00000000L) // Key is preserved // when system is rebooted #define REG_OPTION_VOLATILE (0x00000001L) // Key is not preserved // when system is rebooted #define REG_OPTION_CREATE_LINK (0x00000002L) // Created key is a // symbolic link #define REG_OPTION_BACKUP_RESTORE (0x00000004L) // open for backup or restore // special access rules // privilege required #define REG_OPTION_OPEN_LINK (0x00000008L) // Open symbolic link #define REG_LEGAL_OPTION \ (REG_OPTION_RESERVED |\ REG_OPTION_NON_VOLATILE |\ REG_OPTION_VOLATILE |\ REG_OPTION_CREATE_LINK |\ REG_OPTION_BACKUP_RESTORE |\ REG_OPTION_OPEN_LINK) #define REG_OPEN_LEGAL_OPTION \ (REG_OPTION_RESERVED |\ REG_OPTION_BACKUP_RESTORE |\ REG_OPTION_OPEN_LINK) // // Key creation/open disposition // #define REG_CREATED_NEW_KEY (0x00000001L) // New Registry Key created #define REG_OPENED_EXISTING_KEY (0x00000002L) // Existing Key opened // // hive format to be used by Reg(Nt)SaveKeyEx // #define REG_STANDARD_FORMAT 1 #define REG_LATEST_FORMAT 2 #define REG_NO_COMPRESSION 4 // // Key restore & hive load flags // #define REG_WHOLE_HIVE_VOLATILE (0x00000001L) // Restore whole hive volatile #define REG_REFRESH_HIVE (0x00000002L) // Unwind changes to last flush #define REG_NO_LAZY_FLUSH (0x00000004L) // Never lazy flush this hive #define REG_FORCE_RESTORE (0x00000008L) // Force the restore process even when we have open handles on subkeys #define REG_APP_HIVE (0x00000010L) // Loads the hive visible to the calling process #define REG_PROCESS_PRIVATE (0x00000020L) // Hive cannot be mounted by any other process while in use #define REG_START_JOURNAL (0x00000040L) // Starts Hive Journal #define REG_HIVE_EXACT_FILE_GROWTH (0x00000080L) // Grow hive file in exact 4k increments #define REG_HIVE_NO_RM (0x00000100L) // No RM is started for this hive (no transactions) #define REG_HIVE_SINGLE_LOG (0x00000200L) // Legacy single logging is used for this hive #define REG_BOOT_HIVE (0x00000400L) // This hive might be used by the OS loader #define REG_LOAD_HIVE_OPEN_HANDLE (0x00000800L) // Load the hive and return a handle to its root kcb #define REG_FLUSH_HIVE_FILE_GROWTH (0x00001000L) // Flush changes to primary hive file size as part of all flushes #define REG_OPEN_READ_ONLY (0x00002000L) // Open a hive's files in read-only mode #define REG_IMMUTABLE (0x00004000L) // Load the hive, but don't allow any modification of it #define REG_APP_HIVE_OPEN_READ_ONLY (REG_OPEN_READ_ONLY) // Open an app hive's files in read-only mode (if the hive was not previously loaded) // // Unload Flags // #define REG_FORCE_UNLOAD 1 // // Notify filter values // #define REG_NOTIFY_CHANGE_NAME (0x00000001L) // Create or delete (child) #define REG_NOTIFY_CHANGE_ATTRIBUTES (0x00000002L) #define REG_NOTIFY_CHANGE_LAST_SET (0x00000004L) // time stamp #define REG_NOTIFY_CHANGE_SECURITY (0x00000008L) #define REG_NOTIFY_THREAD_AGNOSTIC (0x10000000L) // Not associated with a calling thread, can only be used // for async user event based notification #define REG_LEGAL_CHANGE_FILTER \ (REG_NOTIFY_CHANGE_NAME |\ REG_NOTIFY_CHANGE_ATTRIBUTES |\ REG_NOTIFY_CHANGE_LAST_SET |\ REG_NOTIFY_CHANGE_SECURITY |\ REG_NOTIFY_THREAD_AGNOSTIC) // // Key query structures // typedef struct _KEY_BASIC_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG NameLength; WCHAR Name[1]; // Variable length string } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION; typedef struct _KEY_NODE_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG NameLength; WCHAR Name[1]; // Variable length string // Class[1]; // Variable length string not declared } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION; typedef struct _KEY_FULL_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG SubKeys; ULONG MaxNameLen; ULONG MaxClassLen; ULONG Values; ULONG MaxValueNameLen; ULONG MaxValueDataLen; WCHAR Class[1]; // Variable length } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION; typedef enum _KEY_INFORMATION_CLASS { KeyBasicInformation, KeyNodeInformation, KeyFullInformation, KeyNameInformation, KeyCachedInformation, KeyFlagsInformation, KeyVirtualizationInformation, KeyHandleTagsInformation, KeyTrustInformation, KeyLayerInformation, MaxKeyInfoClass // MaxKeyInfoClass should always be the last enum } KEY_INFORMATION_CLASS; typedef struct _KEY_WRITE_TIME_INFORMATION { LARGE_INTEGER LastWriteTime; } KEY_WRITE_TIME_INFORMATION, *PKEY_WRITE_TIME_INFORMATION; typedef struct _KEY_WOW64_FLAGS_INFORMATION { ULONG UserFlags; } KEY_WOW64_FLAGS_INFORMATION, *PKEY_WOW64_FLAGS_INFORMATION; typedef struct _KEY_CONTROL_FLAGS_INFORMATION { ULONG ControlFlags; } KEY_CONTROL_FLAGS_INFORMATION, *PKEY_CONTROL_FLAGS_INFORMATION; typedef struct _KEY_SET_VIRTUALIZATION_INFORMATION { ULONG VirtualTarget : 1; // Tells if the key is a virtual target key. ULONG VirtualStore : 1; // Tells if the key is a virtual store key. ULONG VirtualSource : 1; // Tells if the key has been virtualized at least one (virtual hint) ULONG Reserved : 29; } KEY_SET_VIRTUALIZATION_INFORMATION, *PKEY_SET_VIRTUALIZATION_INFORMATION; typedef enum _KEY_SET_INFORMATION_CLASS { KeyWriteTimeInformation, KeyWow64FlagsInformation, KeyControlFlagsInformation, KeySetVirtualizationInformation, KeySetDebugInformation, KeySetHandleTagsInformation, MaxKeySetInfoClass // MaxKeySetInfoClass should always be the last enum } KEY_SET_INFORMATION_CLASS; // // Value entry query structures // typedef struct _KEY_VALUE_BASIC_INFORMATION { ULONG TitleIndex; ULONG Type; ULONG NameLength; WCHAR Name[1]; // Variable size } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION; typedef struct _KEY_VALUE_FULL_INFORMATION { ULONG TitleIndex; ULONG Type; ULONG DataOffset; ULONG DataLength; ULONG NameLength; WCHAR Name[1]; // Variable size // Data[1]; // Variable size data not declared } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION; typedef struct _KEY_VALUE_PARTIAL_INFORMATION { ULONG TitleIndex; ULONG Type; ULONG DataLength; _Field_size_bytes_(DataLength) UCHAR Data[1]; // Variable size } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION; typedef struct _KEY_VALUE_PARTIAL_INFORMATION_ALIGN64 { ULONG Type; ULONG DataLength; _Field_size_bytes_(DataLength) UCHAR Data[1]; // Variable size } KEY_VALUE_PARTIAL_INFORMATION_ALIGN64, *PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64; typedef struct _KEY_VALUE_LAYER_INFORMATION { ULONG IsTombstone : 1; ULONG Reserved : 31; } KEY_VALUE_LAYER_INFORMATION, *PKEY_VALUE_LAYER_INFORMATION; typedef struct _KEY_VALUE_ENTRY { PUNICODE_STRING ValueName; ULONG DataLength; ULONG DataOffset; ULONG Type; } KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY; typedef enum _KEY_VALUE_INFORMATION_CLASS { KeyValueBasicInformation, KeyValueFullInformation, KeyValuePartialInformation, KeyValueFullInformationAlign64, KeyValuePartialInformationAlign64, KeyValueLayerInformation, MaxKeyValueInfoClass // MaxKeyValueInfoClass should always be the last enum } KEY_VALUE_INFORMATION_CLASS; typedef struct _KEY_TRUST_INFORMATION { ULONG TrustedKey : 1; // Tells if key is opened from a trusted hive. ULONG Reserved : 31; } KEY_TRUST_INFORMATION, *PKEY_TRUST_INFORMATION; #define OBJ_NAME_PATH_SEPARATOR ((WCHAR)L'\\') // // Object Manager Object Type Specific Access Rights. // #define OBJECT_TYPE_CREATE (0x0001) #define OBJECT_TYPE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1) // // Object Manager Directory Specific Access Rights. // #define DIRECTORY_QUERY (0x0001) #define DIRECTORY_TRAVERSE (0x0002) #define DIRECTORY_CREATE_OBJECT (0x0004) #define DIRECTORY_CREATE_SUBDIRECTORY (0x0008) #define DIRECTORY_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0xF) //begin_winnt // begin_access // // Object Manager Symbolic Link Specific Access Rights. // //end_winnt #define SYMBOLIC_LINK_QUERY (0x0001) #define SYMBOLIC_LINK_SET (0x0002) #define SYMBOLIC_LINK_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1) #define SYMBOLIC_LINK_ALL_ACCESS_EX (STANDARD_RIGHTS_REQUIRED | 0xFFFF) // end_access typedef struct _OBJECT_NAME_INFORMATION { UNICODE_STRING Name; } OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION; // begin_access #define DUPLICATE_CLOSE_SOURCE 0x00000001 #define DUPLICATE_SAME_ACCESS 0x00000002 #define DUPLICATE_SAME_ATTRIBUTES 0x00000004 // // Section Information Structures. // typedef enum _SECTION_INHERIT { ViewShare = 1, ViewUnmap = 2 } SECTION_INHERIT; // begin_access // // Section Access Rights. // #define SECTION_QUERY 0x0001 #define SECTION_MAP_WRITE 0x0002 #define SECTION_MAP_READ 0x0004 #define SECTION_MAP_EXECUTE 0x0008 #define SECTION_EXTEND_SIZE 0x0010 #define SECTION_MAP_EXECUTE_EXPLICIT 0x0020 // not included in SECTION_ALL_ACCESS #define SECTION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY|\ SECTION_MAP_WRITE | \ SECTION_MAP_READ | \ SECTION_MAP_EXECUTE | \ SECTION_EXTEND_SIZE) // // Session Specific Access Rights. // #define SESSION_QUERY_ACCESS 0x0001 #define SESSION_MODIFY_ACCESS 0x0002 #define SESSION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | \ SESSION_QUERY_ACCESS | \ SESSION_MODIFY_ACCESS) // // Partition Specific Access Rights. // #define MEMORY_PARTITION_QUERY_ACCESS 0x0001 #define MEMORY_PARTITION_MODIFY_ACCESS 0x0002 #define MEMORY_PARTITION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | \ SYNCHRONIZE | \ MEMORY_PARTITION_QUERY_ACCESS | \ MEMORY_PARTITION_MODIFY_ACCESS) // end_access #define SEGMENT_ALL_ACCESS SECTION_ALL_ACCESS #define PAGE_NOACCESS 0x01 #define PAGE_READONLY 0x02 #define PAGE_READWRITE 0x04 #define PAGE_WRITECOPY 0x08 #define PAGE_EXECUTE 0x10 #define PAGE_EXECUTE_READ 0x20 #define PAGE_EXECUTE_READWRITE 0x40 #define PAGE_EXECUTE_WRITECOPY 0x80 #define PAGE_GUARD 0x100 #define PAGE_NOCACHE 0x200 #define PAGE_WRITECOMBINE 0x400 // // PAGE_REVERT_TO_FILE_MAP can be combined with other protection // values to specify to VirtualProtect that the argument range // should be reverted to point back to the backing file. This // means the contents of any private (copy on write) pages in the // range will be discarded. Any reverted pages that were locked // into the working set are unlocked as well. // #define PAGE_REVERT_TO_FILE_MAP 0x80000000 #define PAGE_ENCLAVE_THREAD_CONTROL 0x80000000 #define PAGE_TARGETS_NO_UPDATE 0x40000000 #define PAGE_TARGETS_INVALID 0x40000000 #define PAGE_ENCLAVE_UNVALIDATED 0x20000000 #define PAGE_ENCLAVE_NO_CHANGE 0x20000000 #define MEM_COMMIT 0x00001000 #define MEM_RESERVE 0x00002000 #define MEM_DECOMMIT 0x00004000 #define MEM_RELEASE 0x00008000 #define MEM_FREE 0x00010000 #define MEM_PRIVATE 0x00020000 #define MEM_MAPPED 0x00040000 #define MEM_RESET 0x00080000 #define MEM_TOP_DOWN 0x00100000 #define MEM_RESET_UNDO 0x01000000 #define MEM_LARGE_PAGES 0x20000000 #define MEM_4MB_PAGES 0x80000000 #define MEM_64K_PAGES (MEM_LARGE_PAGES | MEM_PHYSICAL) #define SEC_64K_PAGES 0x00080000 #define SEC_FILE 0x00800000 #define SEC_RESERVE 0x04000000 #define SEC_COMMIT 0x08000000 #define SEC_LARGE_PAGES 0x80000000 #define PROCESS_DUP_HANDLE (0x0040) #if (NTDDI_VERSION >= NTDDI_VISTA) #define PROCESS_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0xFFFF) #else #define PROCESS_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0xFFF) #endif // // Thread Specific Access Rights // #define THREAD_TERMINATE (0x0001) #define THREAD_SUSPEND_RESUME (0x0002) #define THREAD_ALERT (0x0004) #define THREAD_GET_CONTEXT (0x0008) #define THREAD_SET_CONTEXT (0x0010) #define THREAD_SET_INFORMATION (0x0020) #define THREAD_SET_LIMITED_INFORMATION (0x0400) #define THREAD_QUERY_LIMITED_INFORMATION (0x0800) #define THREAD_RESUME (0x1000) #if (NTDDI_VERSION >= NTDDI_VISTA) #define THREAD_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0xFFFF) #else #define THREAD_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0x3FF) #endif // // ClientId // typedef struct _CLIENT_ID { HANDLE UniqueProcess; HANDLE UniqueThread; } CLIENT_ID; typedef CLIENT_ID *PCLIENT_ID; #define NtCurrentProcess() ( (HANDLE)(LONG_PTR) -1 ) #define ZwCurrentProcess() NtCurrentProcess() #define NtCurrentThread() ( (HANDLE)(LONG_PTR) -2 ) #define ZwCurrentThread() NtCurrentThread() #define NtCurrentSession() ( (HANDLE)(LONG_PTR) -3 ) #define ZwCurrentSession() NtCurrentSession() // // ========================================= // Define GUIDs which represent well-known power schemes // ========================================= // // // Maximum Power Savings - indicates that very aggressive power savings measures will be used to help // stretch battery life. // // {a1841308-3541-4fab-bc81-f71556f20b4a} // DEFINE_GUID( GUID_MAX_POWER_SAVINGS, 0xA1841308, 0x3541, 0x4FAB, 0xBC, 0x81, 0xF7, 0x15, 0x56, 0xF2, 0x0B, 0x4A ); // // No Power Savings - indicates that almost no power savings measures will be used. // // {8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c} // DEFINE_GUID( GUID_MIN_POWER_SAVINGS, 0x8C5E7FDA, 0xE8BF, 0x4A96, 0x9A, 0x85, 0xA6, 0xE2, 0x3A, 0x8C, 0x63, 0x5C ); // // Typical Power Savings - indicates that fairly aggressive power savings measures will be used. // // {381b4222-f694-41f0-9685-ff5bb260df2e} // DEFINE_GUID( GUID_TYPICAL_POWER_SAVINGS, 0x381B4222, 0xF694, 0x41F0, 0x96, 0x85, 0xFF, 0x5B, 0xB2, 0x60, 0xDF, 0x2E ); // // This is a special GUID that represents "no subgroup" of settings. That is, it indicates // that settings that are in the root of the power policy hierarchy as opposed to settings // that are buried under a subgroup of settings. This should be used when querying for // power settings that may not fall into a subgroup. // DEFINE_GUID( NO_SUBGROUP_GUID, 0xFEA3413E, 0x7E05, 0x4911, 0x9A, 0x71, 0x70, 0x03, 0x31, 0xF1, 0xC2, 0x94 ); // // This is a special GUID that represents "every power scheme". That is, it indicates // that any write to this power scheme should be reflected to every scheme present. // This allows users to write a single setting once and have it apply to all schemes. They // can then apply custom settings to specific power schemes that they care about. // DEFINE_GUID( ALL_POWERSCHEMES_GUID, 0x68A1E95E, 0x13EA, 0x41E1, 0x80, 0x11, 0x0C, 0x49, 0x6C, 0xA4, 0x90, 0xB0 ); // // This is a special GUID that represents a 'personality' that each power scheme will have. // In other words, each power scheme will have this key indicating "I'm most like *this* base // power scheme." This individual setting will have one of three settings: // GUID_MAX_POWER_SAVINGS // GUID_MIN_POWER_SAVINGS // GUID_TYPICAL_POWER_SAVINGS // // This allows several features: // 1. Drivers and applications can register for notification of this GUID. So when this power // scheme is activiated, this GUID's setting will be sent across the system and drivers/applications // can see "GUID_MAX_POWER_SAVINGS" which will tell them in a generic fashion "get real aggressive // about conserving power". // 2. UserB may install a driver or application which creates power settings, and UserB may modify // those power settings. Now UserA logs in. How does he see those settings? They simply don't // exist in his private power key. Well they do exist over in the system power key. When we // enumerate all the power settings in this system power key and don't find a corresponding entry // in the user's private power key, then we can go look at this "personality" key in the users // power scheme. We can then go get a default value for the power setting, depending on which // "personality" power scheme is being operated on. Here's an example: // A. UserB installs an application that creates a power setting Seetting1 // B. UserB changes Setting1 to have a value of 50 because that's one of the possible settings // available for setting1. // C. UserB logs out // D. UserA logs in and his active power scheme is some custom scheme that was derived from // the GUID_TYPICAL_POWER_SAVINGS. But remember that UserA has no setting1 in his // private power key. // E. When activating UserA's selected power scheme, all power settings in the system power key will // be enumerated (including Setting1). // F. The power manager will see that UserA has no Setting1 power setting in his private power scheme. // G. The power manager will query UserA's power scheme for its personality and retrieve // GUID_TYPICAL_POWER_SAVINGS. // H. The power manager then looks in Setting1 in the system power key and looks in its set of default // values for the corresponding value for GUID_TYPICAL_POWER_SAVINGS power schemes. // I. This derived power setting is applied. DEFINE_GUID( GUID_POWERSCHEME_PERSONALITY, 0x245D8541, 0x3943, 0x4422, 0xB0, 0x25, 0x13, 0xA7, 0x84, 0xF6, 0x79, 0xB7 ); // // Define a special GUID which will be used to define the active power scheme. // User will register for this power setting GUID, and when the active power // scheme changes, they'll get a callback where the payload is the GUID // representing the active powerscheme. // ( 31F9F286-5084-42FE-B720-2B0264993763 } // DEFINE_GUID( GUID_ACTIVE_POWERSCHEME, 0x31F9F286, 0x5084, 0x42FE, 0xB7, 0x20, 0x2B, 0x02, 0x64, 0x99, 0x37, 0x63 ); // // ========================================= // Define GUIDs which represent well-known power settings // ========================================= // // Idle resiliency settings // ------------------------- // // Specifies the subgroup which will contain all of the idle resiliency // settings for a single policy. // // {2E601130-5351-4d9d-8E04-252966BAD054} DEFINE_GUID(GUID_IDLE_RESILIENCY_SUBGROUP, 0x2e601130, 0x5351, 0x4d9d, 0x8e, 0x4, 0x25, 0x29, 0x66, 0xba, 0xd0, 0x54); // // Specifies the maximum clock interrupt period (in ms) // // N.B. This power setting is DEPRECATED. // // {C42B79AA-AA3A-484b-A98F-2CF32AA90A28} DEFINE_GUID(GUID_IDLE_RESILIENCY_PERIOD, 0xc42b79aa, 0xaa3a, 0x484b, 0xa9, 0x8f, 0x2c, 0xf3, 0x2a, 0xa9, 0xa, 0x28); // // Specifies the deep sleep policy setting. // This is intended to override the GUID_IDLE_RESILIENCY_PERIOD // {d502f7ee-1dc7-4efd-a55d-f04b6f5c0545} DEFINE_GUID(GUID_DEEP_SLEEP_ENABLED, 0xd502f7ee, 0x1dc7, 0x4efd, 0xa5, 0x5d, 0xf0, 0x4b, 0x6f, 0x5c, 0x5, 0x45); // // Specifies the platform idle state index associated with idle resiliency // period. // // N.B. This power setting is DEPRECATED. // // {D23F2FB8-9536-4038-9C94-1CE02E5C2152} DEFINE_GUID(GUID_DEEP_SLEEP_PLATFORM_STATE, 0xd23f2fb8, 0x9536, 0x4038, 0x9c, 0x94, 0x1c, 0xe0, 0x2e, 0x5c, 0x21, 0x52); // // Specifies (in milliseconds) how long we wait after the last disk access // before we power off the disk in case when IO coalescing is active. // // {C36F0EB4-2988-4a70-8EEE-0884FC2C2433} DEFINE_GUID(GUID_DISK_COALESCING_POWERDOWN_TIMEOUT, 0xc36f0eb4, 0x2988, 0x4a70, 0x8e, 0xee, 0x8, 0x84, 0xfc, 0x2c, 0x24, 0x33); // // Specifies (in seconds) how long we wait after the CS Enter before // we deactivate execution required request. // // 0 : implies execution power requests are disabled and have no effect // -1 : implies execution power requests are never deactivated // // Note: Execution required power requests are mapped into system required // power requests on non-AoAc machines and this value has no effect. // // {3166BC41-7E98-4e03-B34E-EC0F5F2B218E} DEFINE_GUID(GUID_EXECUTION_REQUIRED_REQUEST_TIMEOUT, 0x3166bc41, 0x7e98, 0x4e03, 0xb3, 0x4e, 0xec, 0xf, 0x5f, 0x2b, 0x21, 0x8e); // Video settings // -------------- // // Specifies the subgroup which will contain all of the video // settings for a single policy. // DEFINE_GUID( GUID_VIDEO_SUBGROUP, 0x7516B95F, 0xF776, 0x4464, 0x8C, 0x53, 0x06, 0x16, 0x7F, 0x40, 0xCC, 0x99 ); // // Specifies (in seconds) how long we wait after the last user input has been // recieved before we power off the video. // DEFINE_GUID( GUID_VIDEO_POWERDOWN_TIMEOUT, 0x3C0BC021, 0xC8A8, 0x4E07, 0xA9, 0x73, 0x6B, 0x14, 0xCB, 0xCB, 0x2B, 0x7E ); // // Specifies whether adaptive display dimming is turned on or off. // 82DBCF2D-CD67-40C5-BFDC-9F1A5CCD4663 // // N.B. This setting is DEPRECATED in Windows 8.1 // DEFINE_GUID( GUID_VIDEO_ANNOYANCE_TIMEOUT, 0x82DBCF2D, 0xCD67, 0x40C5, 0xBF, 0xDC, 0x9F, 0x1A, 0x5C, 0xCD, 0x46, 0x63 ); // // Specifies how much adaptive dim time out will be increased by. // EED904DF-B142-4183-B10B-5A1197A37864 // // N.B. This setting is DEPRECATED in Windows 8.1 // DEFINE_GUID( GUID_VIDEO_ADAPTIVE_PERCENT_INCREASE, 0xEED904DF, 0xB142, 0x4183, 0xB1, 0x0B, 0x5A, 0x11, 0x97, 0xA3, 0x78, 0x64 ); // // Specifies (in seconds) how long we wait after the last user input has been // recieved before we dim the video. // DEFINE_GUID( GUID_VIDEO_DIM_TIMEOUT, 0x17aaa29b, 0x8b43, 0x4b94, 0xaa, 0xfe, 0x35, 0xf6, 0x4d, 0xaa, 0xf1, 0xee); // // Specifies if the operating system should use adaptive timers (based on // previous behavior) to power down the video, // DEFINE_GUID( GUID_VIDEO_ADAPTIVE_POWERDOWN, 0x90959D22, 0xD6A1, 0x49B9, 0xAF, 0x93, 0xBC, 0xE8, 0x85, 0xAD, 0x33, 0x5B ); // // Specifies a maximum power consumption level. // DEFINE_GUID(GUID_DISK_MAX_POWER, 0x51dea550, 0xbb38, 0x4bc4, 0x99, 0x1b, 0xea, 0xcf, 0x37, 0xbe, 0x5e, 0xc8); // // Specifies if the monitor is currently being powered or not. // 02731015-4510-4526-99E6-E5A17EBD1AEA // DEFINE_GUID( GUID_MONITOR_POWER_ON, 0x02731015, 0x4510, 0x4526, 0x99, 0xE6, 0xE5, 0xA1, 0x7E, 0xBD, 0x1A, 0xEA ); // // Monitor brightness policy when in normal state // {aded5e82-b909-4619-9949-f5d71dac0bcb} DEFINE_GUID(GUID_DEVICE_POWER_POLICY_VIDEO_BRIGHTNESS, 0xaded5e82L, 0xb909, 0x4619, 0x99, 0x49, 0xf5, 0xd7, 0x1d, 0xac, 0x0b, 0xcb); // // // Monitor brightness policy when in dim state // {f1fbfde2-a960-4165-9f88-50667911ce96} DEFINE_GUID(GUID_DEVICE_POWER_POLICY_VIDEO_DIM_BRIGHTNESS, 0xf1fbfde2, 0xa960, 0x4165, 0x9f, 0x88, 0x50, 0x66, 0x79, 0x11, 0xce, 0x96); // // Current Monitor brightness // {8ffee2c6-2d01-46be-adb9-398addc5b4ff} DEFINE_GUID(GUID_VIDEO_CURRENT_MONITOR_BRIGHTNESS, 0x8ffee2c6, 0x2d01, 0x46be, 0xad, 0xb9, 0x39, 0x8a, 0xdd, 0xc5, 0xb4, 0xff); // // Specifies if the operating system should use ambient light sensor to change // disply brightness adatively. // {FBD9AA66-9553-4097-BA44-ED6E9D65EAB8} DEFINE_GUID(GUID_VIDEO_ADAPTIVE_DISPLAY_BRIGHTNESS, 0xFBD9AA66, 0x9553, 0x4097, 0xBA, 0x44, 0xED, 0x6E, 0x9D, 0x65, 0xEA, 0xB8); // // Specifies a change in the current monitor's display state. // 6fe69556-704a-47a0-8f24-c28d936fda47 // DEFINE_GUID(GUID_CONSOLE_DISPLAY_STATE, 0x6fe69556, 0x704a, 0x47a0, 0x8f, 0x24, 0xc2, 0x8d, 0x93, 0x6f, 0xda, 0x47); // // Defines a guid for enabling/disabling the ability to create display required // power requests. // // {A9CEB8DA-CD46-44FB-A98B-02AF69DE4623} // DEFINE_GUID( GUID_ALLOW_DISPLAY_REQUIRED, 0xA9CEB8DA, 0xCD46, 0x44FB, 0xA9, 0x8B, 0x02, 0xAF, 0x69, 0xDE, 0x46, 0x23 ); // // Specifies the video power down timeout (in seconds) after the interactive // console is locked (and sensors indicate UserNotPresent). Value 0 // effectively disables this feature. // // {8EC4B3A5-6868-48c2-BE75-4F3044BE88A7} DEFINE_GUID(GUID_VIDEO_CONSOLE_LOCK_TIMEOUT, 0x8ec4b3a5, 0x6868, 0x48c2, 0xbe, 0x75, 0x4f, 0x30, 0x44, 0xbe, 0x88, 0xa7); // Adaptive power behavior settings // -------------------------------- // // {8619B916-E004-4dd8-9B66-DAE86F806698} DEFINE_GUID(GUID_ADAPTIVE_POWER_BEHAVIOR_SUBGROUP, 0x8619b916, 0xe004, 0x4dd8, 0x9b, 0x66, 0xda, 0xe8, 0x6f, 0x80, 0x66, 0x98); // // Specifies the input timeout (in seconds) to be used to indicate UserUnkown. // Value 0 effectively disables this feature. // // {5ADBBFBC-074E-4da1-BA38-DB8B36B2C8F3} DEFINE_GUID(GUID_NON_ADAPTIVE_INPUT_TIMEOUT, 0x5adbbfbc, 0x74e, 0x4da1, 0xba, 0x38, 0xdb, 0x8b, 0x36, 0xb2, 0xc8, 0xf3); // Harddisk settings // ----------------- // // Specifies the subgroup which will contain all of the harddisk // settings for a single policy. // DEFINE_GUID( GUID_DISK_SUBGROUP, 0x0012EE47, 0x9041, 0x4B5D, 0x9B, 0x77, 0x53, 0x5F, 0xBA, 0x8B, 0x14, 0x42 ); // // Specifies (in seconds) how long we wait after the last disk access // before we power off the disk. // DEFINE_GUID( GUID_DISK_POWERDOWN_TIMEOUT, 0x6738E2C4, 0xE8A5, 0x4A42, 0xB1, 0x6A, 0xE0, 0x40, 0xE7, 0x69, 0x75, 0x6E ); // // Specifies (in milliseconds) how long we wait after the last disk access // before we power off the disk taking into account if IO coalescing is active. // // {58E39BA8-B8E6-4EF6-90D0-89AE32B258D6} DEFINE_GUID( GUID_DISK_IDLE_TIMEOUT, 0x58E39BA8, 0xB8E6, 0x4EF6, 0x90, 0xD0, 0x89, 0xAE, 0x32, 0xB2, 0x58, 0xD6 ); // // Specifies the amount of contiguous disk activity time to ignore when // calculating disk idleness. // // 80e3c60e-bb94-4ad8-bbe0-0d3195efc663 // DEFINE_GUID( GUID_DISK_BURST_IGNORE_THRESHOLD, 0x80e3c60e, 0xbb94, 0x4ad8, 0xbb, 0xe0, 0x0d, 0x31, 0x95, 0xef, 0xc6, 0x63 ); // // Specifies if the operating system should use adaptive timers (based on // previous behavior) to power down the disk, // DEFINE_GUID( GUID_DISK_ADAPTIVE_POWERDOWN, 0x396A32E1, 0x499A, 0x40B2, 0x91, 0x24, 0xA9, 0x6A, 0xFE, 0x70, 0x76, 0x67 ); // System sleep settings // --------------------- // // Specifies the subgroup which will contain all of the sleep // settings for a single policy. // { 238C9FA8-0AAD-41ED-83F4-97BE242C8F20 } // DEFINE_GUID( GUID_SLEEP_SUBGROUP, 0x238C9FA8, 0x0AAD, 0x41ED, 0x83, 0xF4, 0x97, 0xBE, 0x24, 0x2C, 0x8F, 0x20 ); // // Specifies an idle treshold percentage (0-100). The system must be this idle // over a period of time in order to idle to sleep. // // N.B. DEPRECATED IN WINDOWS 6.1 // DEFINE_GUID( GUID_SLEEP_IDLE_THRESHOLD, 0x81cd32e0, 0x7833, 0x44f3, 0x87, 0x37, 0x70, 0x81, 0xf3, 0x8d, 0x1f, 0x70 ); // // Specifies (in seconds) how long we wait after the system is deemed // "idle" before moving to standby (S1, S2 or S3). // DEFINE_GUID( GUID_STANDBY_TIMEOUT, 0x29F6C1DB, 0x86DA, 0x48C5, 0x9F, 0xDB, 0xF2, 0xB6, 0x7B, 0x1F, 0x44, 0xDA ); // // Specifies (in seconds) how long the system should go back to sleep after // waking unattended. 0 indicates that the standard standby/hibernate idle // policy should be used instead. // // {7bc4a2f9-d8fc-4469-b07b-33eb785aaca0} // DEFINE_GUID( GUID_UNATTEND_SLEEP_TIMEOUT, 0x7bc4a2f9, 0xd8fc, 0x4469, 0xb0, 0x7b, 0x33, 0xeb, 0x78, 0x5a, 0xac, 0xa0 ); // // Specifies (in seconds) how long we wait after the system is deemed // "idle" before moving to hibernate (S4). // DEFINE_GUID( GUID_HIBERNATE_TIMEOUT, 0x9D7815A6, 0x7EE4, 0x497E, 0x88, 0x88, 0x51, 0x5A, 0x05, 0xF0, 0x23, 0x64 ); // // Specifies whether or not Fast S4 should be enabled if the system supports it // 94AC6D29-73CE-41A6-809F-6363BA21B47E // DEFINE_GUID( GUID_HIBERNATE_FASTS4_POLICY, 0x94AC6D29, 0x73CE, 0x41A6, 0x80, 0x9F, 0x63, 0x63, 0xBA, 0x21, 0xB4, 0x7E ); // // Define a GUID for controlling the criticality of sleep state transitions. // Critical sleep transitions do not query applications, services or drivers // before transitioning the platform to a sleep state. // // {B7A27025-E569-46c2-A504-2B96CAD225A1} // DEFINE_GUID( GUID_CRITICAL_POWER_TRANSITION, 0xB7A27025, 0xE569, 0x46c2, 0xA5, 0x04, 0x2B, 0x96, 0xCA, 0xD2, 0x25, 0xA1); // // Specifies if the system is entering or exiting 'away mode'. // 98A7F580-01F7-48AA-9C0F-44352C29E5C0 // DEFINE_GUID( GUID_SYSTEM_AWAYMODE, 0x98A7F580, 0x01F7, 0x48AA, 0x9C, 0x0F, 0x44, 0x35, 0x2C, 0x29, 0xE5, 0xC0 ); // // Specify whether away mode is allowed // // {25DFA149-5DD1-4736-B5AB-E8A37B5B8187} // DEFINE_GUID( GUID_ALLOW_AWAYMODE, 0x25dfa149, 0x5dd1, 0x4736, 0xb5, 0xab, 0xe8, 0xa3, 0x7b, 0x5b, 0x81, 0x87 ); // // Defines a guid to control User Presence Prediction mode. // // {82011705-FB95-4D46-8D35-4042B1D20DEF} // DEFINE_GUID( GUID_USER_PRESENCE_PREDICTION, 0x82011705, 0xfb95, 0x4d46, 0x8d, 0x35, 0x40, 0x42, 0xb1, 0xd2, 0xd, 0xef ); // // Defines a guid to control Standby Budget Grace Period. // // {60C07FE1-0556-45CF-9903-D56E32210242} // DEFINE_GUID( GUID_STANDBY_BUDGET_GRACE_PERIOD, 0x60c07fe1, 0x0556, 0x45cf, 0x99, 0x03, 0xd5, 0x6e, 0x32, 0x21, 0x2, 0x42 ); // // Defines a guid to control Standby Budget Percent. // // {9FE527BE-1B70-48DA-930D-7BCF17B44990} // DEFINE_GUID( GUID_STANDBY_BUDGET_PERCENT, 0x9fe527be, 0x1b70, 0x48da, 0x93, 0x0d, 0x7b, 0xcf, 0x17, 0xb4, 0x49, 0x90 ); // // Defines a guid to control Standby Reserve Grace Period. // // {C763EE92-71E8-4127-84EB-F6ED043A3E3D} // DEFINE_GUID( GUID_STANDBY_RESERVE_GRACE_PERIOD, 0xc763ee92, 0x71e8, 0x4127, 0x84, 0xeb, 0xf6, 0xed, 0x04, 0x3a, 0x3e, 0x3d ); // // Defines a guid to control Standby Reserve Time. // // {468FE7E5-1158-46EC-88BC-5B96C9E44FD0} // DEFINE_GUID( GUID_STANDBY_RESERVE_TIME, 0x468FE7E5, 0x1158, 0x46EC, 0x88, 0xbc, 0x5b, 0x96, 0xc9, 0xe4, 0x4f, 0xd0 ); // // Defines a guid to control Standby Reset Percentage. // // {49CB11A5-56E2-4AFB-9D38-3DF47872E21B} // DEFINE_GUID(GUID_STANDBY_RESET_PERCENT, 0x49cb11a5, 0x56e2, 0x4afb, 0x9d, 0x38, 0x3d, 0xf4, 0x78, 0x72, 0xe2, 0x1b); // // Defines a guid for enabling/disabling standby (S1-S3) states. This does not // affect hibernation (S4). // // {abfc2519-3608-4c2a-94ea-171b0ed546ab} // DEFINE_GUID( GUID_ALLOW_STANDBY_STATES, 0xabfc2519, 0x3608, 0x4c2a, 0x94, 0xea, 0x17, 0x1b, 0x0e, 0xd5, 0x46, 0xab ); // // Defines a guid for enabling/disabling the ability to wake via RTC. // // {BD3B718A-0680-4D9D-8AB2-E1D2B4AC806D} // DEFINE_GUID( GUID_ALLOW_RTC_WAKE, 0xBD3B718A, 0x0680, 0x4D9D, 0x8A, 0xB2, 0xE1, 0xD2, 0xB4, 0xAC, 0x80, 0x6D ); // // Defines a guid for enabling/disabling the ability to create system required // power requests. // // {A4B195F5-8225-47D8-8012-9D41369786E2} // DEFINE_GUID( GUID_ALLOW_SYSTEM_REQUIRED, 0xA4B195F5, 0x8225, 0x47D8, 0x80, 0x12, 0x9D, 0x41, 0x36, 0x97, 0x86, 0xE2 ); // Energy Saver settings // --------------------- // // Indicates if Enegry Saver is ON or OFF. // // {E00958C0-C213-4ACE-AC77-FECCED2EEEA5} // DEFINE_GUID( GUID_POWER_SAVING_STATUS, 0xe00958c0, 0xc213, 0x4ace, 0xac, 0x77, 0xfe, 0xcc, 0xed, 0x2e, 0xee, 0xa5); // // Specifies the subgroup which will contain all of the Energy Saver settings // for a single policy. // // {DE830923-A562-41AF-A086-E3A2C6BAD2DA} // DEFINE_GUID( GUID_ENERGY_SAVER_SUBGROUP, 0xDE830923, 0xA562, 0x41AF, 0xA0, 0x86, 0xE3, 0xA2, 0xC6, 0xBA, 0xD2, 0xDA ); // // Defines a guid to engage Energy Saver at specific battery charge level // // {E69653CA-CF7F-4F05-AA73-CB833FA90AD4} // DEFINE_GUID( GUID_ENERGY_SAVER_BATTERY_THRESHOLD, 0xE69653CA, 0xCF7F, 0x4F05, 0xAA, 0x73, 0xCB, 0x83, 0x3F, 0xA9, 0x0A, 0xD4 ); // // Defines a guid to specify display brightness weight when Energy Saver is engaged // // {13D09884-F74E-474A-A852-B6BDE8AD03A8} // DEFINE_GUID( GUID_ENERGY_SAVER_BRIGHTNESS, 0x13D09884, 0xF74E, 0x474A, 0xA8, 0x52, 0xB6, 0xBD, 0xE8, 0xAD, 0x03, 0xA8 ); // // Defines a guid to specify the Energy Saver policy // // {5C5BB349-AD29-4ee2-9D0B-2B25270F7A81} // DEFINE_GUID( GUID_ENERGY_SAVER_POLICY, 0x5c5bb349, 0xad29, 0x4ee2, 0x9d, 0xb, 0x2b, 0x25, 0x27, 0xf, 0x7a, 0x81 ); // System button actions // --------------------- // // // Specifies the subgroup which will contain all of the system button // settings for a single policy. // DEFINE_GUID( GUID_SYSTEM_BUTTON_SUBGROUP, 0x4F971E89, 0xEEBD, 0x4455, 0xA8, 0xDE, 0x9E, 0x59, 0x04, 0x0E, 0x73, 0x47 ); #define POWERBUTTON_ACTION_INDEX_NOTHING 0 #define POWERBUTTON_ACTION_INDEX_SLEEP 1 #define POWERBUTTON_ACTION_INDEX_HIBERNATE 2 #define POWERBUTTON_ACTION_INDEX_SHUTDOWN 3 #define POWERBUTTON_ACTION_INDEX_TURN_OFF_THE_DISPLAY 4 // // System button values which contain the PowerAction* value for each action. // #define POWERBUTTON_ACTION_VALUE_NOTHING 0 #define POWERBUTTON_ACTION_VALUE_SLEEP 2 #define POWERBUTTON_ACTION_VALUE_HIBERNATE 3 #define POWERBUTTON_ACTION_VALUE_SHUTDOWN 6 #define POWERBUTTON_ACTION_VALUE_TURN_OFF_THE_DISPLAY 8 // Specifies (in a POWER_ACTION_POLICY structure) the appropriate action to // take when the system power button is pressed. // DEFINE_GUID( GUID_POWERBUTTON_ACTION, 0x7648EFA3, 0xDD9C, 0x4E3E, 0xB5, 0x66, 0x50, 0xF9, 0x29, 0x38, 0x62, 0x80 ); // // Specifies (in a POWER_ACTION_POLICY structure) the appropriate action to // take when the system sleep button is pressed. // DEFINE_GUID( GUID_SLEEPBUTTON_ACTION, 0x96996BC0, 0xAD50, 0x47EC, 0x92, 0x3B, 0x6F, 0x41, 0x87, 0x4D, 0xD9, 0xEB ); // // Specifies (in a POWER_ACTION_POLICY structure) the appropriate action to // take when the system sleep button is pressed. // { A7066653-8D6C-40A8-910E-A1F54B84C7E5 } // DEFINE_GUID( GUID_USERINTERFACEBUTTON_ACTION, 0xA7066653, 0x8D6C, 0x40A8, 0x91, 0x0E, 0xA1, 0xF5, 0x4B, 0x84, 0xC7, 0xE5 ); // // Specifies (in a POWER_ACTION_POLICY structure) the appropriate action to // take when the system lid is closed. // DEFINE_GUID( GUID_LIDCLOSE_ACTION, 0x5CA83367, 0x6E45, 0x459F, 0xA2, 0x7B, 0x47, 0x6B, 0x1D, 0x01, 0xC9, 0x36 ); DEFINE_GUID( GUID_LIDOPEN_POWERSTATE, 0x99FF10E7, 0x23B1, 0x4C07, 0xA9, 0xD1, 0x5C, 0x32, 0x06, 0xD7, 0x41, 0xB4 ); // Battery Discharge Settings // -------------------------- // // Specifies the subgroup which will contain all of the battery discharge // settings for a single policy. // DEFINE_GUID( GUID_BATTERY_SUBGROUP, 0xE73A048D, 0xBF27, 0x4F12, 0x97, 0x31, 0x8B, 0x20, 0x76, 0xE8, 0x89, 0x1F ); // // 4 battery discharge alarm settings. // // GUID_BATTERY_DISCHARGE_ACTION_x - This is the action to take. It is a value // of type POWER_ACTION // GUID_BATTERY_DISCHARGE_LEVEL_x - This is the battery level (%) // GUID_BATTERY_DISCHARGE_FLAGS_x - Flags defined below: // POWER_ACTION_POLICY->EventCode flags // BATTERY_DISCHARGE_FLAGS_EVENTCODE_MASK // BATTERY_DISCHARGE_FLAGS_ENABLE DEFINE_GUID( GUID_BATTERY_DISCHARGE_ACTION_0, 0x637EA02F, 0xBBCB, 0x4015, 0x8E, 0x2C, 0xA1, 0xC7, 0xB9, 0xC0, 0xB5, 0x46 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_LEVEL_0, 0x9A66D8D7, 0x4FF7, 0x4EF9, 0xB5, 0xA2, 0x5A, 0x32, 0x6C, 0xA2, 0xA4, 0x69 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_FLAGS_0, 0x5dbb7c9f, 0x38e9, 0x40d2, 0x97, 0x49, 0x4f, 0x8a, 0x0e, 0x9f, 0x64, 0x0f ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_ACTION_1, 0xD8742DCB, 0x3E6A, 0x4B3C, 0xB3, 0xFE, 0x37, 0x46, 0x23, 0xCD, 0xCF, 0x06 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_LEVEL_1, 0x8183BA9A, 0xE910, 0x48DA, 0x87, 0x69, 0x14, 0xAE, 0x6D, 0xC1, 0x17, 0x0A ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_FLAGS_1, 0xbcded951, 0x187b, 0x4d05, 0xbc, 0xcc, 0xf7, 0xe5, 0x19, 0x60, 0xc2, 0x58 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_ACTION_2, 0x421CBA38, 0x1A8E, 0x4881, 0xAC, 0x89, 0xE3, 0x3A, 0x8B, 0x04, 0xEC, 0xE4 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_LEVEL_2, 0x07A07CA2, 0xADAF, 0x40D7, 0xB0, 0x77, 0x53, 0x3A, 0xAD, 0xED, 0x1B, 0xFA ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_FLAGS_2, 0x7fd2f0c4, 0xfeb7, 0x4da3, 0x81, 0x17, 0xe3, 0xfb, 0xed, 0xc4, 0x65, 0x82 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_ACTION_3, 0x80472613, 0x9780, 0x455E, 0xB3, 0x08, 0x72, 0xD3, 0x00, 0x3C, 0xF2, 0xF8 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_LEVEL_3, 0x58AFD5A6, 0xC2DD, 0x47D2, 0x9F, 0xBF, 0xEF, 0x70, 0xCC, 0x5C, 0x59, 0x65 ); DEFINE_GUID( GUID_BATTERY_DISCHARGE_FLAGS_3, 0x73613ccf, 0xdbfa, 0x4279, 0x83, 0x56, 0x49, 0x35, 0xf6, 0xbf, 0x62, 0xf3 ); // Processor power settings // ------------------------ // // Specifies the subgroup which will contain all of the processor // settings for a single policy. // // {54533251-82be-4824-96c1-47b60b740d00} // DEFINE_GUID( GUID_PROCESSOR_SETTINGS_SUBGROUP, 0x54533251, 0x82BE, 0x4824, 0x96, 0xC1, 0x47, 0xB6, 0x0B, 0x74, 0x0D, 0x00 ); // // Specifies various attributes that control processor performance/throttle // states. // DEFINE_GUID( GUID_PROCESSOR_THROTTLE_POLICY, 0x57027304, 0x4AF6, 0x4104, 0x92, 0x60, 0xE3, 0xD9, 0x52, 0x48, 0xFC, 0x36 ); #define PERFSTATE_POLICY_CHANGE_IDEAL 0 #define PERFSTATE_POLICY_CHANGE_SINGLE 1 #define PERFSTATE_POLICY_CHANGE_ROCKET 2 #define PERFSTATE_POLICY_CHANGE_IDEAL_AGGRESSIVE 3 #define PERFSTATE_POLICY_CHANGE_DECREASE_MAX PERFSTATE_POLICY_CHANGE_ROCKET #define PERFSTATE_POLICY_CHANGE_INCREASE_MAX PERFSTATE_POLICY_CHANGE_IDEAL_AGGRESSIVE // // Specifies a percentage (between 0 and 100) that the processor frequency // should never go above. For example, if this value is set to 80, then // the processor frequency will never be throttled above 80 percent of its // maximum frequency by the system. // // {bc5038f7-23e0-4960-96da-33abaf5935ec} // DEFINE_GUID( GUID_PROCESSOR_THROTTLE_MAXIMUM, 0xBC5038F7, 0x23E0, 0x4960, 0x96, 0xDA, 0x33, 0xAB, 0xAF, 0x59, 0x35, 0xEC ); // // Specifies a percentage (between 0 and 100) that the processor frequency // should never go above for Processor Power Efficiency Class 1. // For example, if this value is set to 80, then the processor frequency will // never be throttled above 80 percent of its maximum frequency by the system. // // {bc5038f7-23e0-4960-96da-33abaf5935ed} // DEFINE_GUID( GUID_PROCESSOR_THROTTLE_MAXIMUM_1, 0xBC5038F7, 0x23E0, 0x4960, 0x96, 0xDA, 0x33, 0xAB, 0xAF, 0x59, 0x35, 0xED ); // // Specifies a percentage (between 0 and 100) that the processor frequency // should not drop below. For example, if this value is set to 50, then the // processor frequency will never be throttled below 50 percent of its // maximum frequency by the system. // // {893dee8e-2bef-41e0-89c6-b55d0929964c} // DEFINE_GUID( GUID_PROCESSOR_THROTTLE_MINIMUM, 0x893DEE8E, 0x2BEF, 0x41E0, 0x89, 0xC6, 0xB5, 0x5D, 0x09, 0x29, 0x96, 0x4C ); // // Specifies a percentage (between 0 and 100) that the processor frequency // should not drop below for Processor Power Efficiency Class 1. // For example, if this value is set to 50, then the processor frequency will // never be throttled below 50 percent of its maximum frequency by the system. // // {893dee8e-2bef-41e0-89c6-b55d0929964d} // DEFINE_GUID( GUID_PROCESSOR_THROTTLE_MINIMUM_1, 0x893DEE8E, 0x2BEF, 0x41E0, 0x89, 0xC6, 0xB5, 0x5D, 0x09, 0x29, 0x96, 0x4D ); // // Specifies whether throttle states are allowed to be used even when // performance states are available. // // {3b04d4fd-1cc7-4f23-ab1c-d1337819c4bb} // DEFINE_GUID( GUID_PROCESSOR_ALLOW_THROTTLING, 0x3b04d4fd, 0x1cc7, 0x4f23, 0xab, 0x1c, 0xd1, 0x33, 0x78, 0x19, 0xc4, 0xbb ); #define PROCESSOR_THROTTLE_DISABLED 0 #define PROCESSOR_THROTTLE_ENABLED 1 #define PROCESSOR_THROTTLE_AUTOMATIC 2 // // Specifies processor power settings for CState policy data // {68F262A7-F621-4069-B9A5-4874169BE23C} // DEFINE_GUID( GUID_PROCESSOR_IDLESTATE_POLICY, 0x68f262a7, 0xf621, 0x4069, 0xb9, 0xa5, 0x48, 0x74, 0x16, 0x9b, 0xe2, 0x3c); // // Specifies processor power settings for PerfState policy data // {BBDC3814-18E9-4463-8A55-D197327C45C0} // DEFINE_GUID( GUID_PROCESSOR_PERFSTATE_POLICY, 0xBBDC3814, 0x18E9, 0x4463, 0x8A, 0x55, 0xD1, 0x97, 0x32, 0x7C, 0x45, 0xC0); // // Specifies the increase busy percentage threshold that must be met before // increasing the processor performance state. // // {06cadf0e-64ed-448a-8927-ce7bf90eb35d} // DEFINE_GUID( GUID_PROCESSOR_PERF_INCREASE_THRESHOLD, 0x06cadf0e, 0x64ed, 0x448a, 0x89, 0x27, 0xce, 0x7b, 0xf9, 0x0e, 0xb3, 0x5d ); // // Specifies the increase busy percentage threshold that must be met before // increasing the processor performance state for Processor Power Efficiency // Class 1. // // {06cadf0e-64ed-448a-8927-ce7bf90eb35e} // DEFINE_GUID( GUID_PROCESSOR_PERF_INCREASE_THRESHOLD_1, 0x06cadf0e, 0x64ed, 0x448a, 0x89, 0x27, 0xce, 0x7b, 0xf9, 0x0e, 0xb3, 0x5e ); // // Specifies the decrease busy percentage threshold that must be met before // decreasing the processor performance state. // // {12a0ab44-fe28-4fa9-b3bd-4b64f44960a6} // DEFINE_GUID( GUID_PROCESSOR_PERF_DECREASE_THRESHOLD, 0x12a0ab44, 0xfe28, 0x4fa9, 0xb3, 0xbd, 0x4b, 0x64, 0xf4, 0x49, 0x60, 0xa6 ); // // Specifies the decrease busy percentage threshold that must be met before // decreasing the processor performance state for Processor Power Efficiency // Class 1. // // {12a0ab44-fe28-4fa9-b3bd-4b64f44960a7} // DEFINE_GUID( GUID_PROCESSOR_PERF_DECREASE_THRESHOLD_1, 0x12a0ab44, 0xfe28, 0x4fa9, 0xb3, 0xbd, 0x4b, 0x64, 0xf4, 0x49, 0x60, 0xa7 ); // // Specifies, either as ideal, single or rocket, how aggressive performance // states should be selected when increasing the processor performance state. // // {465E1F50-B610-473a-AB58-00D1077DC418} // DEFINE_GUID( GUID_PROCESSOR_PERF_INCREASE_POLICY, 0x465e1f50, 0xb610, 0x473a, 0xab, 0x58, 0x0, 0xd1, 0x7, 0x7d, 0xc4, 0x18); // // Specifies, either as ideal, single or rocket, how aggressive performance // states should be selected when increasing the processor performance state // for Processor Power Efficiency Class 1. // // {465E1F50-B610-473a-AB58-00D1077DC419} // DEFINE_GUID( GUID_PROCESSOR_PERF_INCREASE_POLICY_1, 0x465e1f50, 0xb610, 0x473a, 0xab, 0x58, 0x0, 0xd1, 0x7, 0x7d, 0xc4, 0x19); // // Specifies, either as ideal, single or rocket, how aggressive performance // states should be selected when decreasing the processor performance state. // // {40FBEFC7-2E9D-4d25-A185-0CFD8574BAC6} // DEFINE_GUID( GUID_PROCESSOR_PERF_DECREASE_POLICY, 0x40fbefc7, 0x2e9d, 0x4d25, 0xa1, 0x85, 0xc, 0xfd, 0x85, 0x74, 0xba, 0xc6); // // Specifies, either as ideal, single or rocket, how aggressive performance // states should be selected when decreasing the processor performance state for // Processor Power Efficiency Class 1. // // {40FBEFC7-2E9D-4d25-A185-0CFD8574BAC7} // DEFINE_GUID( GUID_PROCESSOR_PERF_DECREASE_POLICY_1, 0x40fbefc7, 0x2e9d, 0x4d25, 0xa1, 0x85, 0xc, 0xfd, 0x85, 0x74, 0xba, 0xc7); // // Specifies, in milliseconds, the minimum amount of time that must elapse after // the last processor performance state change before increasing the processor // performance state. // // {984CF492-3BED-4488-A8F9-4286C97BF5AA} // DEFINE_GUID( GUID_PROCESSOR_PERF_INCREASE_TIME, 0x984cf492, 0x3bed, 0x4488, 0xa8, 0xf9, 0x42, 0x86, 0xc9, 0x7b, 0xf5, 0xaa); // // Specifies, in milliseconds, the minimum amount of time that must elapse after // the last processor performance state change before increasing the processor // performance state for Processor Power Efficiency Class 1. // // {984CF492-3BED-4488-A8F9-4286C97BF5AB} // DEFINE_GUID( GUID_PROCESSOR_PERF_INCREASE_TIME_1, 0x984cf492, 0x3bed, 0x4488, 0xa8, 0xf9, 0x42, 0x86, 0xc9, 0x7b, 0xf5, 0xab); // // Specifies, in milliseconds, the minimum amount of time that must elapse after // the last processor performance state change before increasing the processor // performance state. // // {D8EDEB9B-95CF-4f95-A73C-B061973693C8} // DEFINE_GUID( GUID_PROCESSOR_PERF_DECREASE_TIME, 0xd8edeb9b, 0x95cf, 0x4f95, 0xa7, 0x3c, 0xb0, 0x61, 0x97, 0x36, 0x93, 0xc8); // // Specifies, in milliseconds, the minimum amount of time that must elapse after // the last processor performance state change before increasing the processor // performance state for Processor Power Efficiency Class 1. // // {D8EDEB9B-95CF-4f95-A73C-B061973693C9} // DEFINE_GUID( GUID_PROCESSOR_PERF_DECREASE_TIME_1, 0xd8edeb9b, 0x95cf, 0x4f95, 0xa7, 0x3c, 0xb0, 0x61, 0x97, 0x36, 0x93, 0xc9); // // Specifies the time, in milliseconds, that must expire before considering // a change in the processor performance states or parked core set. // // {4D2B0152-7D5C-498b-88E2-34345392A2C5} // DEFINE_GUID( GUID_PROCESSOR_PERF_TIME_CHECK, 0x4d2b0152, 0x7d5c, 0x498b, 0x88, 0xe2, 0x34, 0x34, 0x53, 0x92, 0xa2, 0xc5); // // Specifies how the processor should manage performance and efficiency // tradeoffs when boosting frequency above the maximum. // // {45BCC044-D885-43e2-8605-EE0EC6E96B59} // DEFINE_GUID(GUID_PROCESSOR_PERF_BOOST_POLICY, 0x45bcc044, 0xd885, 0x43e2, 0x86, 0x5, 0xee, 0xe, 0xc6, 0xe9, 0x6b, 0x59); #define PROCESSOR_PERF_BOOST_POLICY_DISABLED 0 #define PROCESSOR_PERF_BOOST_POLICY_MAX 100 // // Specifies how a processor opportunistically increases frequency above // the maximum when operating contitions allow it to do so safely. // // {BE337238-0D82-4146-A960-4F3749D470C7} // DEFINE_GUID(GUID_PROCESSOR_PERF_BOOST_MODE, 0xbe337238, 0xd82, 0x4146, 0xa9, 0x60, 0x4f, 0x37, 0x49, 0xd4, 0x70, 0xc7); #define PROCESSOR_PERF_BOOST_MODE_DISABLED 0 #define PROCESSOR_PERF_BOOST_MODE_ENABLED 1 #define PROCESSOR_PERF_BOOST_MODE_AGGRESSIVE 2 #define PROCESSOR_PERF_BOOST_MODE_EFFICIENT_ENABLED 3 #define PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE 4 #define PROCESSOR_PERF_BOOST_MODE_AGGRESSIVE_AT_GUARANTEED 5 #define PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE_AT_GUARANTEED 6 #define PROCESSOR_PERF_BOOST_MODE_MAX PROCESSOR_PERF_BOOST_MODE_EFFICIENT_AGGRESSIVE_AT_GUARANTEED // // Specifies whether or not a procesor should autonomously select its // operating performance state. // // {8BAA4A8A-14C6-4451-8E8B-14BDBD197537} // DEFINE_GUID(GUID_PROCESSOR_PERF_AUTONOMOUS_MODE, 0x8baa4a8a, 0x14c6, 0x4451, 0x8e, 0x8b, 0x14, 0xbd, 0xbd, 0x19, 0x75, 0x37); #define PROCESSOR_PERF_AUTONOMOUS_MODE_DISABLED 0 #define PROCESSOR_PERF_AUTONOMOUS_MODE_ENABLED 1 // // Specifies the tradeoff between performance and energy the processor should // make when operating in autonomous mode. // // {36687F9E-E3A5-4dbf-B1DC-15EB381C6863} DEFINE_GUID(GUID_PROCESSOR_PERF_ENERGY_PERFORMANCE_PREFERENCE, 0x36687f9e, 0xe3a5, 0x4dbf, 0xb1, 0xdc, 0x15, 0xeb, 0x38, 0x1c, 0x68, 0x63); #define PROCESSOR_PERF_PERFORMANCE_PREFERENCE 0xff #define PROCESSOR_PERF_ENERGY_PREFERENCE 0 // // Specifies the window over which the processor should observe utilization when // operating in autonomous mode, in microseconds. // // {CFEDA3D0-7697-4566-A922-A9086CD49DFA} DEFINE_GUID(GUID_PROCESSOR_PERF_AUTONOMOUS_ACTIVITY_WINDOW, 0xcfeda3d0, 0x7697, 0x4566, 0xa9, 0x22, 0xa9, 0x8, 0x6c, 0xd4, 0x9d, 0xfa); #define PROCESSOR_PERF_MINIMUM_ACTIVITY_WINDOW 0 #define PROCESSOR_PERF_MAXIMUM_ACTIVITY_WINDOW 1270000000 // // Specifies whether the processor should perform duty cycling. // // {4E4450B3-6179-4e91-B8F1-5BB9938F81A1} DEFINE_GUID(GUID_PROCESSOR_DUTY_CYCLING, 0x4e4450b3, 0x6179, 0x4e91, 0xb8, 0xf1, 0x5b, 0xb9, 0x93, 0x8f, 0x81, 0xa1); #define PROCESSOR_DUTY_CYCLING_DISABLED 0 #define PROCESSOR_DUTY_CYCLING_ENABLED 1 // // Specifies if idle state promotion and demotion values should be scaled based // on the current peformance state. // // {6C2993B0-8F48-481f-BCC6-00DD2742AA06} // DEFINE_GUID( GUID_PROCESSOR_IDLE_ALLOW_SCALING, 0x6c2993b0, 0x8f48, 0x481f, 0xbc, 0xc6, 0x0, 0xdd, 0x27, 0x42, 0xaa, 0x6); // // Specifies if idle states should be disabled. // // {5D76A2CA-E8C0-402f-A133-2158492D58AD} // DEFINE_GUID( GUID_PROCESSOR_IDLE_DISABLE, 0x5d76a2ca, 0xe8c0, 0x402f, 0xa1, 0x33, 0x21, 0x58, 0x49, 0x2d, 0x58, 0xad); // // Specifies the deepest idle state type that should be used. If this value is // set to zero, this setting is ignored. Values higher than supported by the // processor then this setting has no effect. // // {9943e905-9a30-4ec1-9b99-44dd3b76f7a2} // DEFINE_GUID( GUID_PROCESSOR_IDLE_STATE_MAXIMUM, 0x9943e905, 0x9a30, 0x4ec1, 0x9b, 0x99, 0x44, 0xdd, 0x3b, 0x76, 0xf7, 0xa2); // // Specifies the time that elapsed since the last idle state promotion or // demotion before idle states may be promoted or demoted again (in // microseconds). // // {C4581C31-89AB-4597-8E2B-9C9CAB440E6B} // DEFINE_GUID( GUID_PROCESSOR_IDLE_TIME_CHECK, 0xc4581c31, 0x89ab, 0x4597, 0x8e, 0x2b, 0x9c, 0x9c, 0xab, 0x44, 0xe, 0x6b); // // Specifies the upper busy threshold that must be met before demoting the // processor to a lighter idle state (in percentage). // // {4B92D758-5A24-4851-A470-815D78AEE119} // DEFINE_GUID( GUID_PROCESSOR_IDLE_DEMOTE_THRESHOLD, 0x4b92d758, 0x5a24, 0x4851, 0xa4, 0x70, 0x81, 0x5d, 0x78, 0xae, 0xe1, 0x19); // // Specifies the lower busy threshold that must be met before promoting the // processor to a deeper idle state (in percentage). // // {7B224883-B3CC-4d79-819F-8374152CBE7C} // DEFINE_GUID( GUID_PROCESSOR_IDLE_PROMOTE_THRESHOLD, 0x7b224883, 0xb3cc, 0x4d79, 0x81, 0x9f, 0x83, 0x74, 0x15, 0x2c, 0xbe, 0x7c); // // Specifies the utilization threshold in percent that must be crossed in order to un-park cores. // // N.B. This power setting is DEPRECATED. // // {df142941-20f3-4edf-9a4a-9c83d3d717d1} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_INCREASE_THRESHOLD, 0xdf142941, 0x20f3, 0x4edf, 0x9a, 0x4a, 0x9c, 0x83, 0xd3, 0xd7, 0x17, 0xd1 ); // // Specifies the utilization threshold in percent that must be crossed in order to park cores. // // N.B. This power setting is DEPRECATED. // // {68dd2f27-a4ce-4e11-8487-3794e4135dfa} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_DECREASE_THRESHOLD, 0x68dd2f27, 0xa4ce, 0x4e11, 0x84, 0x87, 0x37, 0x94, 0xe4, 0x13, 0x5d, 0xfa); // // Specifies, either as ideal, single or rocket, how aggressive core parking is when cores must be unparked. // // {c7be0679-2817-4d69-9d02-519a537ed0c6} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_INCREASE_POLICY, 0xc7be0679, 0x2817, 0x4d69, 0x9d, 0x02, 0x51, 0x9a, 0x53, 0x7e, 0xd0, 0xc6); #define CORE_PARKING_POLICY_CHANGE_IDEAL 0 #define CORE_PARKING_POLICY_CHANGE_SINGLE 1 #define CORE_PARKING_POLICY_CHANGE_ROCKET 2 #define CORE_PARKING_POLICY_CHANGE_MULTISTEP 3 #define CORE_PARKING_POLICY_CHANGE_MAX CORE_PARKING_POLICY_CHANGE_MULTISTEP // // Specifies, either as ideal, single or rocket, how aggressive core parking is when cores must be parked. // // {71021b41-c749-4d21-be74-a00f335d582b} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_DECREASE_POLICY, 0x71021b41, 0xc749, 0x4d21, 0xbe, 0x74, 0xa0, 0x0f, 0x33, 0x5d, 0x58, 0x2b); // // Specifies, on a per processor group basis, the maximum number of cores that can be kept unparked. // // {ea062031-0e34-4ff1-9b6d-eb1059334028} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_MAX_CORES, 0xea062031, 0x0e34, 0x4ff1, 0x9b, 0x6d, 0xeb, 0x10, 0x59, 0x33, 0x40, 0x28); // // Specifies, on a per processor group basis, the maximum number of cores that // can be kept unparked for Processor Power Efficiency Class 1. // // {ea062031-0e34-4ff1-9b6d-eb1059334029} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_MAX_CORES_1, 0xea062031, 0x0e34, 0x4ff1, 0x9b, 0x6d, 0xeb, 0x10, 0x59, 0x33, 0x40, 0x29); // // Specifies, on a per processor group basis, the minimum number of cores that must be kept unparked. // // {0cc5b647-c1df-4637-891a-dec35c318583} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_MIN_CORES, 0x0cc5b647, 0xc1df, 0x4637, 0x89, 0x1a, 0xde, 0xc3, 0x5c, 0x31, 0x85, 0x83); // // Specifies, on a per processor group basis, the minimum number of cores that // must be kept unparked in Processor Power Efficiency Class 1. // // {0cc5b647-c1df-4637-891a-dec35c318584} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_MIN_CORES_1, 0x0cc5b647, 0xc1df, 0x4637, 0x89, 0x1a, 0xde, 0xc3, 0x5c, 0x31, 0x85, 0x84); // // Specifies, in milliseconds, the minimum amount of time a core must be parked before it can be unparked. // // {2ddd5a84-5a71-437e-912a-db0b8c788732} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_INCREASE_TIME, 0x2ddd5a84, 0x5a71, 0x437e, 0x91, 0x2a, 0xdb, 0x0b, 0x8c, 0x78, 0x87, 0x32); // // Specifies, in milliseconds, the minimum amount of time a core must be unparked before it can be parked. // // {dfd10d17-d5eb-45dd-877a-9a34ddd15c82} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_DECREASE_TIME, 0xdfd10d17, 0xd5eb, 0x45dd, 0x87, 0x7a, 0x9a, 0x34, 0xdd, 0xd1, 0x5c, 0x82); // // Specifies the factor by which to decrease affinity history on each core after each check. // // {8f7b45e3-c393-480a-878c-f67ac3d07082} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_DECREASE_FACTOR, 0x8f7b45e3, 0xc393, 0x480a, 0x87, 0x8c, 0xf6, 0x7a, 0xc3, 0xd0, 0x70, 0x82); // // Specifies the threshold above which a core is considered to have had significant affinitized work scheduled to it while parked. // // {5b33697b-e89d-4d38-aa46-9e7dfb7cd2f9} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_AFFINITY_HISTORY_THRESHOLD, 0x5b33697b, 0xe89d, 0x4d38, 0xaa, 0x46, 0x9e, 0x7d, 0xfb, 0x7c, 0xd2, 0xf9); // // Specifies the weighting given to each occurence where affinitized work was scheduled to a parked core. // // {e70867f1-fa2f-4f4e-aea1-4d8a0ba23b20} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_AFFINITY_WEIGHTING, 0xe70867f1, 0xfa2f, 0x4f4e, 0xae, 0xa1, 0x4d, 0x8a, 0x0b, 0xa2, 0x3b, 0x20); // // Specifies the factor by which to decrease the over utilization history on each core after the current performance check. // // {1299023c-bc28-4f0a-81ec-d3295a8d815d} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_DECREASE_FACTOR, 0x1299023c, 0xbc28, 0x4f0a, 0x81, 0xec, 0xd3, 0x29, 0x5a, 0x8d, 0x81, 0x5d); // // Specifies the threshold above which a core is considered to have been recently over utilized while parked. // // {9ac18e92-aa3c-4e27-b307-01ae37307129} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_HISTORY_THRESHOLD, 0x9ac18e92, 0xaa3c, 0x4e27, 0xb3, 0x07, 0x01, 0xae, 0x37, 0x30, 0x71, 0x29); // // Specifies the weighting given to each occurence where a parked core is found to be over utilized. // // {8809c2d8-b155-42d4-bcda-0d345651b1db} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_WEIGHTING, 0x8809c2d8, 0xb155, 0x42d4, 0xbc, 0xda, 0x0d, 0x34, 0x56, 0x51, 0xb1, 0xdb); // // Specifies, in percentage, the busy threshold that must be met before a parked core is considered over utilized. // // {943c8cb6-6f93-4227-ad87-e9a3feec08d1} // DEFINE_GUID( GUID_PROCESSOR_CORE_PARKING_OVER_UTILIZATION_THRESHOLD, 0x943c8cb6, 0x6f93, 0x4227, 0xad, 0x87, 0xe9, 0xa3, 0xfe, 0xec, 0x08, 0xd1); // // Specifies if at least one processor per core should always remain unparked. // // {a55612aa-f624-42c6-a443-7397d064c04f} // DEFINE_GUID( GUID_PROCESSOR_PARKING_CORE_OVERRIDE, 0xa55612aa, 0xf624, 0x42c6, 0xa4, 0x43, 0x73, 0x97, 0xd0, 0x64, 0xc0, 0x4f); // // Specifies what performance state a processor should enter when first parked. // // {447235c7-6a8d-4cc0-8e24-9eaf70b96e2b} // DEFINE_GUID( GUID_PROCESSOR_PARKING_PERF_STATE, 0x447235c7, 0x6a8d, 0x4cc0, 0x8e, 0x24, 0x9e, 0xaf, 0x70, 0xb9, 0x6e, 0x2b); // // Specifies what performance state a processor should enter when first parked // for Processor Power Efficiency Class 1. // // {447235c7-6a8d-4cc0-8e24-9eaf70b96e2c} // DEFINE_GUID( GUID_PROCESSOR_PARKING_PERF_STATE_1, 0x447235c7, 0x6a8d, 0x4cc0, 0x8e, 0x24, 0x9e, 0xaf, 0x70, 0xb9, 0x6e, 0x2c); // // Specify the busy threshold that must be met when calculating the concurrency of a node's workload. // // {2430ab6f-a520-44a2-9601-f7f23b5134b1} // DEFINE_GUID( GUID_PROCESSOR_PARKING_CONCURRENCY_THRESHOLD, 0x2430ab6f, 0xa520, 0x44a2, 0x96, 0x01, 0xf7, 0xf2, 0x3b, 0x51, 0x34, 0xb1); // // Specify the busy threshold that must be met by all cores in a concurrency set to unpark an extra core. // // {f735a673-2066-4f80-a0c5-ddee0cf1bf5d} // DEFINE_GUID( GUID_PROCESSOR_PARKING_HEADROOM_THRESHOLD, 0xf735a673, 0x2066, 0x4f80, 0xa0, 0xc5, 0xdd, 0xee, 0x0c, 0xf1, 0xbf, 0x5d); // // Specify the percentage utilization used to calculate the distribution concurrency. // // {4bdaf4e9-d103-46d7-a5f0-6280121616ef} // DEFINE_GUID( GUID_PROCESSOR_PARKING_DISTRIBUTION_THRESHOLD, 0x4bdaf4e9, 0xd103, 0x46d7, 0xa5, 0xf0, 0x62, 0x80, 0x12, 0x16, 0x16, 0xef); // // Specifies the number of perf time check intervals to average utility over. // // {7d24baa7-0b84-480f-840c-1b0743c00f5f} // DEFINE_GUID( GUID_PROCESSOR_PERF_HISTORY, 0x7d24baa7, 0x0b84, 0x480f, 0x84, 0x0c, 0x1b, 0x07, 0x43, 0xc0, 0x0f, 0x5f); // // Specifies the number of perf time check intervals to average utility over in // Processor Power Efficiency Class 1. // // {7d24baa7-0b84-480f-840c-1b0743c00f60} // DEFINE_GUID( GUID_PROCESSOR_PERF_HISTORY_1, 0x7d24baa7, 0x0b84, 0x480f, 0x84, 0x0c, 0x1b, 0x07, 0x43, 0xc0, 0x0f, 0x60); // // Specifies the number of perf time check intervals to average utility over to // determine performance increase. // // N.B. This power setting is DEPRECATED. // // {99B3EF01-752F-46a1-80FB-7730011F2354} // DEFINE_GUID( GUID_PROCESSOR_PERF_INCREASE_HISTORY, 0x99b3ef01, 0x752f, 0x46a1, 0x80, 0xfb, 0x77, 0x30, 0x1, 0x1f, 0x23, 0x54); // // Specifies the number of perf time check intervals to average utility over to // determine performance decrease. // // N.B. This power setting is DEPRECATED. // // {0300F6F8-ABD6-45a9-B74F-4908691A40B5} // DEFINE_GUID( GUID_PROCESSOR_PERF_DECREASE_HISTORY, 0x300f6f8, 0xabd6, 0x45a9, 0xb7, 0x4f, 0x49, 0x8, 0x69, 0x1a, 0x40, 0xb5); // // Specifies the number of perf time check intervals to average utility over for // core parking. // // N.B. This power setting is DEPRECATED. // // {77D7F282-8F1A-42cd-8537-45450A839BE8} // DEFINE_GUID( GUID_PROCESSOR_PERF_CORE_PARKING_HISTORY, 0x77d7f282, 0x8f1a, 0x42cd, 0x85, 0x37, 0x45, 0x45, 0xa, 0x83, 0x9b, 0xe8); // // Specifies whether latency sensitivity hints should be taken into account by // the perf state engine. // // N.B. This power setting is DEPRECATED. // // {0822df31-9c83-441c-a079-0de4cf009c7b} // DEFINE_GUID( GUID_PROCESSOR_PERF_LATENCY_HINT, 0x0822df31, 0x9c83, 0x441c, 0xa0, 0x79, 0x0d, 0xe4, 0xcf, 0x00, 0x9c, 0x7b); // // Specifies the processor performance state in response to latency sensitivity hints. // // {619b7505-003b-4e82-b7a6-4dd29c300971} // DEFINE_GUID( GUID_PROCESSOR_PERF_LATENCY_HINT_PERF, 0x619b7505, 0x3b, 0x4e82, 0xb7, 0xa6, 0x4d, 0xd2, 0x9c, 0x30, 0x9, 0x71); // // Specifies the processor performance state in response to latency sensitivity // hints for Processor Power Efficiency Class 1. // // {619b7505-003b-4e82-b7a6-4dd29c300972} // DEFINE_GUID( GUID_PROCESSOR_PERF_LATENCY_HINT_PERF_1, 0x619b7505, 0x3b, 0x4e82, 0xb7, 0xa6, 0x4d, 0xd2, 0x9c, 0x30, 0x9, 0x72); // // Specifies the minimum unparked processors when a latency hint is active // (in a percentage). // // {616cdaa5-695e-4545-97ad-97dc2d1bdd88} // DEFINE_GUID( GUID_PROCESSOR_LATENCY_HINT_MIN_UNPARK, 0x616cdaa5, 0x695e, 0x4545, 0x97, 0xad, 0x97, 0xdc, 0x2d, 0x1b, 0xdd, 0x88); // // Specifies the minimum unparked processors when a latency hint is active // for Processor Power Efficiency Class 1 (in a percentage). // // {616cdaa5-695e-4545-97ad-97dc2d1bdd89} // DEFINE_GUID( GUID_PROCESSOR_LATENCY_HINT_MIN_UNPARK_1, 0x616cdaa5, 0x695e, 0x4545, 0x97, 0xad, 0x97, 0xdc, 0x2d, 0x1b, 0xdd, 0x89); // // Specifies whether the core parking engine should distribute processor // utility. // // {e0007330-f589-42ed-a401-5ddb10e785d3} // DEFINE_GUID( GUID_PROCESSOR_DISTRIBUTE_UTILITY, 0xe0007330, 0xf589, 0x42ed, 0xa4, 0x01, 0x5d, 0xdb, 0x10, 0xe7, 0x85, 0xd3); // // GUIDS to control PPM settings on computer system with more than one // Processor Power Efficiency Classes (heterogeneous system). // ----------------- // // Specifies the current active heterogeneous policy. // // {7f2f5cfa-f10c-4823-b5e1-e93ae85f46b5} // DEFINE_GUID( GUID_PROCESSOR_HETEROGENEOUS_POLICY, 0x7f2f5cfa, 0xf10c, 0x4823, 0xb5, 0xe1, 0xe9, 0x3a, 0xe8, 0x5f, 0x46, 0xb5); // // Specifies the number of perf check cycles required to decrease the number of // Processor Power Efficiency Class 1 processors. // // {7f2492b6-60b1-45e5-ae55-773f8cd5caec} // DEFINE_GUID( GUID_PROCESSOR_HETERO_DECREASE_TIME, 0x7f2492b6, 0x60b1, 0x45e5, 0xae, 0x55, 0x77, 0x3f, 0x8c, 0xd5, 0xca, 0xec); // // Specifies the number of perf check cycles required to increase the number of // Processor Power Efficiency Class 1 processors. // // {4009efa7-e72d-4cba-9edf-91084ea8cbc3} // DEFINE_GUID( GUID_PROCESSOR_HETERO_INCREASE_TIME, 0x4009efa7, 0xe72d, 0x4cba, 0x9e, 0xdf, 0x91, 0x08, 0x4e, 0xa8, 0xcb, 0xc3); // // Specifies the performance level (in units of Processor Power Efficiency // Class 0 processor performance) at which the number of Processor Power // Efficiency Class 1 processors is decreased. // // {f8861c27-95e7-475c-865b-13c0cb3f9d6b} // DEFINE_GUID( GUID_PROCESSOR_HETERO_DECREASE_THRESHOLD, 0xf8861c27, 0x95e7, 0x475c, 0x86, 0x5b, 0x13, 0xc0, 0xcb, 0x3f, 0x9d, 0x6b); // // Specifies the performance level (in units of Processor Power Efficiency // Class 0 processor performance) at which the number of Processor Power // Efficiency Class 1 processors is increased. // // {b000397d-9b0b-483d-98c9-692a6060cfbf} // DEFINE_GUID( GUID_PROCESSOR_HETERO_INCREASE_THRESHOLD, 0xb000397d, 0x9b0b, 0x483d, 0x98, 0xc9, 0x69, 0x2a, 0x60, 0x60, 0xcf, 0xbf); // // Specifies the performance target floor of a Processor Power Efficiency // Class 0 processor when the system unparks Processor Power Efficiency Class 1 // processor(s). // // {fddc842b-8364-4edc-94cf-c17f60de1c80} // DEFINE_GUID( GUID_PROCESSOR_CLASS0_FLOOR_PERF, 0xfddc842b, 0x8364, 0x4edc, 0x94, 0xcf, 0xc1, 0x7f, 0x60, 0xde, 0x1c, 0x80); // // Specifies the initial performance target of a Processor Power Efficiency // Class 1 processor when the system makes a transition up from zero Processor // Power Efficiency Class 1 processors. // // {1facfc65-a930-4bc5-9f38-504ec097bbc0} // DEFINE_GUID( GUID_PROCESSOR_CLASS1_INITIAL_PERF, 0x1facfc65, 0xa930, 0x4bc5, 0x9f, 0x38, 0x50, 0x4e, 0xc0, 0x97, 0xbb, 0xc0); // // Specifies active vs passive cooling. Although not directly related to // processor settings, it is the processor that gets throttled if we're doing // passive cooling, so it is fairly strongly related. // {94D3A615-A899-4AC5-AE2B-E4D8F634367F} // DEFINE_GUID( GUID_SYSTEM_COOLING_POLICY, 0x94D3A615, 0xA899, 0x4AC5, 0xAE, 0x2B, 0xE4, 0xD8, 0xF6, 0x34, 0x36, 0x7F); // Lock Console on Wake // -------------------- // // Specifies the behavior of the system when we wake from standby or // hibernate. If this is set, then we will cause the console to lock // after we resume. // DEFINE_GUID( GUID_LOCK_CONSOLE_ON_WAKE, 0x0E796BDB, 0x100D, 0x47D6, 0xA2, 0xD5, 0xF7, 0xD2, 0xDA, 0xA5, 0x1F, 0x51 ); // Device idle characteristics // --------------------------- // // Specifies whether to use the "performance" or "conservative" timeouts for // device idle management. // // 4faab71a-92e5-4726-b531-224559672d19 // DEFINE_GUID( GUID_DEVICE_IDLE_POLICY, 0x4faab71a, 0x92e5, 0x4726, 0xb5, 0x31, 0x22, 0x45, 0x59, 0x67, 0x2d, 0x19 ); #define POWER_DEVICE_IDLE_POLICY_PERFORMANCE 0 #define POWER_DEVICE_IDLE_POLICY_CONSERVATIVE 1 // // Specifies standby connectivity preference. // // F15576E8-98B7-4186-B944-EAFA664402D9 DEFINE_GUID( GUID_CONNECTIVITY_IN_STANDBY, 0xF15576E8, 0x98B7, 0x4186, 0xB9, 0x44, 0xEA, 0xFA, 0x66, 0x44, 0x02, 0xD9 ); #define POWER_CONNECTIVITY_IN_STANDBY_DISABLED 0 #define POWER_CONNECTIVITY_IN_STANDBY_ENABLED 1 // AC/DC power source // ------------------ // // Specifies the power source for the system. consumers may register for // notification when the power source changes and will be notified with // one of 3 values: // 0 - Indicates the system is being powered by an AC power source. // 1 - Indicates the system is being powered by a DC power source. // 2 - Indicates the system is being powered by a short-term DC power // source. For example, this would be the case if the system is // being powed by a short-term battery supply in a backing UPS // system. When this value is recieved, the consumer should make // preparations for either a system hibernate or system shutdown. // // { 5D3E9A59-E9D5-4B00-A6BD-FF34FF516548 } DEFINE_GUID( GUID_ACDC_POWER_SOURCE, 0x5D3E9A59, 0xE9D5, 0x4B00, 0xA6, 0xBD, 0xFF, 0x34, 0xFF, 0x51, 0x65, 0x48 ); // Lid state changes // ----------------- // // Specifies the current state of the lid (open or closed). The callback won't // be called at all until a lid device is found and its current state is known. // // Values: // // 0 - closed // 1 - opened // // { BA3E0F4D-B817-4094-A2D1-D56379E6A0F3 } // DEFINE_GUID( GUID_LIDSWITCH_STATE_CHANGE, 0xBA3E0F4D, 0xB817, 0x4094, 0xA2, 0xD1, 0xD5, 0x63, 0x79, 0xE6, 0xA0, 0xF3 ); // Battery status changes // ---------------------- // // Specifies the percentage of battery life remaining. The consumer // may register for notification in order to track battery life in // a fine-grained manner. // // Once registered, the consumer can expect to be notified as the battery // life percentage changes. // // The consumer will recieve a value between 0 and 100 (inclusive) which // indicates percent battery life remaining. // // { A7AD8041-B45A-4CAE-87A3-EECBB468A9E1 } DEFINE_GUID( GUID_BATTERY_PERCENTAGE_REMAINING, 0xA7AD8041, 0xB45A, 0x4CAE, 0x87, 0xA3, 0xEE, 0xCB, 0xB4, 0x68, 0xA9, 0xE1 ); // Specifies change in number of batteries present on the system. The consumer // may register for notification in order to track change in number of batteries // available on a system. // // Once registered, the consumer can expect to be notified whenever the // batteries are added or removed from the system. // // The consumer will recieve a value indicating number of batteries currently // present on the system. // // {7D263F15-FCA4-49E5-854B-A9F2BFBD5C24} DEFINE_GUID( GUID_BATTERY_COUNT, 0x7d263f15, 0xfca4, 0x49e5, 0x85, 0x4b, 0xa9, 0xf2, 0xbf, 0xbd, 0x5c, 0x24 ); // // Global notification indicating to listeners user activity/presence accross // all sessions in the system (Present, NotPresent, Inactive) // // {786E8A1D-B427-4344-9207-09E70BDCBEA9} DEFINE_GUID( GUID_GLOBAL_USER_PRESENCE, 0x786e8a1d, 0xb427, 0x4344, 0x92, 0x7, 0x9, 0xe7, 0xb, 0xdc, 0xbe, 0xa9 ); // // Session specific notification indicating to listeners whether or not the display // related to the given session is on/off/dim // // N.B. This is a session-specific notification, sent only to interactive // session registrants. Session 0 and kernel mode consumers do not receive // this notification. // // {2B84C20E-AD23-4ddf-93DB-05FFBD7EFCA5} DEFINE_GUID( GUID_SESSION_DISPLAY_STATUS, 0x2b84c20e, 0xad23, 0x4ddf, 0x93, 0xdb, 0x5, 0xff, 0xbd, 0x7e, 0xfc, 0xa5 ); // // Session specific notification indicating to listeners user activity/presence //(Present, NotPresent, Inactive) // // N.B. This is a session-specific notification, sent only to interactive // session registrants. Session 0 and kernel mode consumers do not receive // this notification. // {3C0F4548-C03F-4c4d-B9F2-237EDE686376} DEFINE_GUID( GUID_SESSION_USER_PRESENCE, 0x3c0f4548, 0xc03f, 0x4c4d, 0xb9, 0xf2, 0x23, 0x7e, 0xde, 0x68, 0x63, 0x76 ); // Notification to listeners that the system is fairly busy and won't be moving // into an idle state any time soon. This can be used as a hint to listeners // that now might be a good time to do background tasks. // DEFINE_GUID( GUID_IDLE_BACKGROUND_TASK, 0x515C31D8, 0xF734, 0x163D, 0xA0, 0xFD, 0x11, 0xA0, 0x8C, 0x91, 0xE8, 0xF1 ); // Notification to listeners that the system is fairly busy and won't be moving // into an idle state any time soon. This can be used as a hint to listeners // that now might be a good time to do background tasks. // // { CF23F240-2A54-48D8-B114-DE1518FF052E } DEFINE_GUID( GUID_BACKGROUND_TASK_NOTIFICATION, 0xCF23F240, 0x2A54, 0x48D8, 0xB1, 0x14, 0xDE, 0x15, 0x18, 0xFF, 0x05, 0x2E ); // Define a GUID that will represent the action of a direct experience button // on the platform. Users will register for this DPPE setting and recieve // notification when the h/w button is pressed. // // { 1A689231-7399-4E9A-8F99-B71F999DB3FA } // DEFINE_GUID( GUID_APPLAUNCH_BUTTON, 0x1A689231, 0x7399, 0x4E9A, 0x8F, 0x99, 0xB7, 0x1F, 0x99, 0x9D, 0xB3, 0xFA ); // PCI Express power settings // ------------------------ // // Specifies the subgroup which will contain all of the PCI Express // settings for a single policy. // // {501a4d13-42af-4429-9fd1-a8218c268e20} // DEFINE_GUID( GUID_PCIEXPRESS_SETTINGS_SUBGROUP, 0x501a4d13, 0x42af,0x4429, 0x9f, 0xd1, 0xa8, 0x21, 0x8c, 0x26, 0x8e, 0x20 ); // Specifies the PCI Express ASPM power policy. // // {ee12f906-d277-404b-b6da-e5fa1a576df5} // DEFINE_GUID( GUID_PCIEXPRESS_ASPM_POLICY, 0xee12f906, 0xd277, 0x404b, 0xb6, 0xda, 0xe5, 0xfa, 0x1a, 0x57, 0x6d, 0xf5 ); // POWER Shutdown settings // ------------------------ // // Specifies if forced shutdown should be used for all button and lid initiated // shutdown actions. // // {833a6b62-dfa4-46d1-82f8-e09e34d029d6} // DEFINE_GUID( GUID_ENABLE_SWITCH_FORCED_SHUTDOWN, 0x833a6b62, 0xdfa4, 0x46d1, 0x82, 0xf8, 0xe0, 0x9e, 0x34, 0xd0, 0x29, 0xd6 ); // Interrupt Steering power settings // ------------------------ // // {48672F38-7A9A-4bb2-8BF8-3D85BE19DE4E} DEFINE_GUID(GUID_INTSTEER_SUBGROUP, 0x48672f38, 0x7a9a, 0x4bb2, 0x8b, 0xf8, 0x3d, 0x85, 0xbe, 0x19, 0xde, 0x4e); // {2BFC24F9-5EA2-4801-8213-3DBAE01AA39D} DEFINE_GUID(GUID_INTSTEER_MODE, 0x2bfc24f9, 0x5ea2, 0x4801, 0x82, 0x13, 0x3d, 0xba, 0xe0, 0x1a, 0xa3, 0x9d); // {73CDE64D-D720-4bb2-A860-C755AFE77EF2} DEFINE_GUID(GUID_INTSTEER_LOAD_PER_PROC_TRIGGER, 0x73cde64d, 0xd720, 0x4bb2, 0xa8, 0x60, 0xc7, 0x55, 0xaf, 0xe7, 0x7e, 0xf2); // {D6BA4903-386F-4c2c-8ADB-5C21B3328D25} DEFINE_GUID(GUID_INTSTEER_TIME_UNPARK_TRIGGER, 0xd6ba4903, 0x386f, 0x4c2c, 0x8a, 0xdb, 0x5c, 0x21, 0xb3, 0x32, 0x8d, 0x25); #ifndef _PO_DDK_ #define _PO_DDK_ typedef enum _SYSTEM_POWER_STATE { PowerSystemUnspecified = 0, PowerSystemWorking = 1, PowerSystemSleeping1 = 2, PowerSystemSleeping2 = 3, PowerSystemSleeping3 = 4, PowerSystemHibernate = 5, PowerSystemShutdown = 6, PowerSystemMaximum = 7 } SYSTEM_POWER_STATE, *PSYSTEM_POWER_STATE; #define POWER_SYSTEM_MAXIMUM 7 typedef enum { PowerActionNone = 0, PowerActionReserved, PowerActionSleep, PowerActionHibernate, PowerActionShutdown, PowerActionShutdownReset, PowerActionShutdownOff, PowerActionWarmEject, PowerActionDisplayOff } POWER_ACTION, *PPOWER_ACTION; typedef enum _DEVICE_POWER_STATE { PowerDeviceUnspecified = 0, PowerDeviceD0, PowerDeviceD1, PowerDeviceD2, PowerDeviceD3, PowerDeviceMaximum } DEVICE_POWER_STATE, *PDEVICE_POWER_STATE; typedef enum _MONITOR_DISPLAY_STATE { PowerMonitorOff = 0, PowerMonitorOn, PowerMonitorDim } MONITOR_DISPLAY_STATE, *PMONITOR_DISPLAY_STATE; typedef enum _USER_ACTIVITY_PRESENCE { PowerUserPresent = 0, PowerUserNotPresent, PowerUserInactive, PowerUserMaximum, PowerUserInvalid = PowerUserMaximum } USER_ACTIVITY_PRESENCE, *PUSER_ACTIVITY_PRESENCE; typedef union _POWER_STATE { SYSTEM_POWER_STATE SystemState; DEVICE_POWER_STATE DeviceState; } POWER_STATE, *PPOWER_STATE; typedef enum _POWER_STATE_TYPE { SystemPowerState = 0, DevicePowerState } POWER_STATE_TYPE, *PPOWER_STATE_TYPE; #if (NTDDI_VERSION >= NTDDI_VISTA) typedef struct _SYSTEM_POWER_STATE_CONTEXT { union { struct { ULONG Reserved1 : 8; ULONG TargetSystemState : 4; ULONG EffectiveSystemState : 4; ULONG CurrentSystemState : 4; ULONG IgnoreHibernationPath : 1; ULONG PseudoTransition : 1; ULONG Reserved2 : 10; } DUMMYSTRUCTNAME; ULONG ContextAsUlong; } DUMMYUNIONNAME; } SYSTEM_POWER_STATE_CONTEXT, *PSYSTEM_POWER_STATE_CONTEXT; #endif // (NTDDI_VERSION >= NTDDI_VISTA) #if (NTDDI_VERSION >= NTDDI_WIN7) typedef struct _COUNTED_REASON_CONTEXT { ULONG Version; ULONG Flags; union { struct { UNICODE_STRING ResourceFileName; USHORT ResourceReasonId; ULONG StringCount; _Field_size_(StringCount) PUNICODE_STRING ReasonStrings; } DUMMYSTRUCTNAME; UNICODE_STRING SimpleString; } DUMMYUNIONNAME; } COUNTED_REASON_CONTEXT, *PCOUNTED_REASON_CONTEXT; #endif // (NTDDI_VERSION >= NTDDI_WIN7) // // Generic power related IOCTLs // #define IOCTL_QUERY_DEVICE_POWER_STATE \ CTL_CODE(FILE_DEVICE_BATTERY, 0x0, METHOD_BUFFERED, FILE_READ_ACCESS) #define IOCTL_SET_DEVICE_WAKE \ CTL_CODE(FILE_DEVICE_BATTERY, 0x1, METHOD_BUFFERED, FILE_WRITE_ACCESS) #define IOCTL_CANCEL_DEVICE_WAKE \ CTL_CODE(FILE_DEVICE_BATTERY, 0x2, METHOD_BUFFERED, FILE_WRITE_ACCESS) // // Defines for W32 interfaces // #define ES_SYSTEM_REQUIRED ((ULONG)0x00000001) #define ES_DISPLAY_REQUIRED ((ULONG)0x00000002) #define ES_USER_PRESENT ((ULONG)0x00000004) #define ES_AWAYMODE_REQUIRED ((ULONG)0x00000040) #define ES_CONTINUOUS ((ULONG)0x80000000) typedef ULONG EXECUTION_STATE, *PEXECUTION_STATE; typedef enum { LT_DONT_CARE, LT_LOWEST_LATENCY } LATENCY_TIME; #define DIAGNOSTIC_REASON_VERSION 0 #define DIAGNOSTIC_REASON_SIMPLE_STRING 0x00000001 #define DIAGNOSTIC_REASON_DETAILED_STRING 0x00000002 #define DIAGNOSTIC_REASON_NOT_SPECIFIED 0x80000000 #define DIAGNOSTIC_REASON_INVALID_FLAGS (~0x80000007) // // Defines for power request APIs // #define POWER_REQUEST_CONTEXT_VERSION DIAGNOSTIC_REASON_VERSION #define POWER_REQUEST_CONTEXT_SIMPLE_STRING DIAGNOSTIC_REASON_SIMPLE_STRING #define POWER_REQUEST_CONTEXT_DETAILED_STRING DIAGNOSTIC_REASON_DETAILED_STRING typedef enum _POWER_REQUEST_TYPE { PowerRequestDisplayRequired, PowerRequestSystemRequired, PowerRequestAwayModeRequired, PowerRequestExecutionRequired } POWER_REQUEST_TYPE, *PPOWER_REQUEST_TYPE; #if (NTDDI_VERSION >= NTDDI_WINXP) //----------------------------------------------------------------------------- // Device Power Information // Accessable via CM_Get_DevInst_Registry_Property_Ex(CM_DRP_DEVICE_POWER_DATA) //----------------------------------------------------------------------------- #define PDCAP_D0_SUPPORTED 0x00000001 #define PDCAP_D1_SUPPORTED 0x00000002 #define PDCAP_D2_SUPPORTED 0x00000004 #define PDCAP_D3_SUPPORTED 0x00000008 #define PDCAP_WAKE_FROM_D0_SUPPORTED 0x00000010 #define PDCAP_WAKE_FROM_D1_SUPPORTED 0x00000020 #define PDCAP_WAKE_FROM_D2_SUPPORTED 0x00000040 #define PDCAP_WAKE_FROM_D3_SUPPORTED 0x00000080 #define PDCAP_WARM_EJECT_SUPPORTED 0x00000100 typedef struct CM_Power_Data_s { ULONG PD_Size; DEVICE_POWER_STATE PD_MostRecentPowerState; ULONG PD_Capabilities; ULONG PD_D1Latency; ULONG PD_D2Latency; ULONG PD_D3Latency; DEVICE_POWER_STATE PD_PowerStateMapping[POWER_SYSTEM_MAXIMUM]; SYSTEM_POWER_STATE PD_DeepestSystemWake; } CM_POWER_DATA, *PCM_POWER_DATA; #endif // (NTDDI_VERSION >= NTDDI_WINXP) typedef enum { SystemPowerPolicyAc, SystemPowerPolicyDc, VerifySystemPolicyAc, VerifySystemPolicyDc, SystemPowerCapabilities, SystemBatteryState, SystemPowerStateHandler, ProcessorStateHandler, SystemPowerPolicyCurrent, AdministratorPowerPolicy, SystemReserveHiberFile, ProcessorInformation, SystemPowerInformation, ProcessorStateHandler2, LastWakeTime, // Compare with KeQueryInterruptTime() LastSleepTime, // Compare with KeQueryInterruptTime() SystemExecutionState, SystemPowerStateNotifyHandler, ProcessorPowerPolicyAc, ProcessorPowerPolicyDc, VerifyProcessorPowerPolicyAc, VerifyProcessorPowerPolicyDc, ProcessorPowerPolicyCurrent, SystemPowerStateLogging, SystemPowerLoggingEntry, SetPowerSettingValue, NotifyUserPowerSetting, PowerInformationLevelUnused0, SystemMonitorHiberBootPowerOff, SystemVideoState, TraceApplicationPowerMessage, TraceApplicationPowerMessageEnd, ProcessorPerfStates, ProcessorIdleStates, ProcessorCap, SystemWakeSource, SystemHiberFileInformation, TraceServicePowerMessage, ProcessorLoad, PowerShutdownNotification, MonitorCapabilities, SessionPowerInit, SessionDisplayState, PowerRequestCreate, PowerRequestAction, GetPowerRequestList, ProcessorInformationEx, NotifyUserModeLegacyPowerEvent, GroupPark, ProcessorIdleDomains, WakeTimerList, SystemHiberFileSize, ProcessorIdleStatesHv, ProcessorPerfStatesHv, ProcessorPerfCapHv, ProcessorSetIdle, LogicalProcessorIdling, UserPresence, PowerSettingNotificationName, GetPowerSettingValue, IdleResiliency, SessionRITState, SessionConnectNotification, SessionPowerCleanup, SessionLockState, SystemHiberbootState, PlatformInformation, PdcInvocation, MonitorInvocation, FirmwareTableInformationRegistered, SetShutdownSelectedTime, SuspendResumeInvocation, PlmPowerRequestCreate, ScreenOff, CsDeviceNotification, PlatformRole, LastResumePerformance, DisplayBurst, ExitLatencySamplingPercentage, RegisterSpmPowerSettings, PlatformIdleStates, ProcessorIdleVeto, PlatformIdleVeto, SystemBatteryStatePrecise, ThermalEvent, PowerRequestActionInternal, BatteryDeviceState, PowerInformationInternal, ThermalStandby, SystemHiberFileType, PhysicalPowerButtonPress, PowerInformationLevelMaximum } POWER_INFORMATION_LEVEL; // // User Presence Values // typedef enum { UserNotPresent = 0, UserPresent = 1, UserUnknown = 0xff } POWER_USER_PRESENCE_TYPE, *PPOWER_USER_PRESENCE_TYPE; typedef struct _POWER_USER_PRESENCE { POWER_USER_PRESENCE_TYPE UserPresence; } POWER_USER_PRESENCE, *PPOWER_USER_PRESENCE; // // Session Connect/Disconnect // typedef struct _POWER_SESSION_CONNECT { BOOLEAN Connected; // TRUE - connected, FALSE - disconnected BOOLEAN Console; // TRUE - console, FALSE - TS (not used for Connected = FALSE) } POWER_SESSION_CONNECT, *PPOWER_SESSION_CONNECT; typedef struct _POWER_SESSION_TIMEOUTS { ULONG InputTimeout; ULONG DisplayTimeout; } POWER_SESSION_TIMEOUTS, *PPOWER_SESSION_TIMEOUTS; // // Session RIT State // typedef struct _POWER_SESSION_RIT_STATE { BOOLEAN Active; // TRUE - RIT input received, FALSE - RIT timeout ULONG LastInputTime; // last input time held for this session } POWER_SESSION_RIT_STATE, *PPOWER_SESSION_RIT_STATE; // // Winlogon notifications // typedef struct _POWER_SESSION_WINLOGON { ULONG SessionId; // the Win32k session identifier BOOLEAN Console; // TRUE - for console session, FALSE - for remote session BOOLEAN Locked; // TRUE - lock, FALSE - unlock } POWER_SESSION_WINLOGON, *PPOWER_SESSION_WINLOGON; // // Idle resiliency // typedef struct _POWER_IDLE_RESILIENCY { ULONG CoalescingTimeout; ULONG IdleResiliencyPeriod; } POWER_IDLE_RESILIENCY, *PPOWER_IDLE_RESILIENCY; // // Monitor on/off reasons // typedef enum { MonitorRequestReasonUnknown, MonitorRequestReasonPowerButton, MonitorRequestReasonRemoteConnection, MonitorRequestReasonScMonitorpower, MonitorRequestReasonUserInput, MonitorRequestReasonAcDcDisplayBurst, MonitorRequestReasonUserDisplayBurst, MonitorRequestReasonPoSetSystemState, MonitorRequestReasonSetThreadExecutionState, MonitorRequestReasonFullWake, MonitorRequestReasonSessionUnlock, MonitorRequestReasonScreenOffRequest, MonitorRequestReasonIdleTimeout, MonitorRequestReasonPolicyChange, MonitorRequestReasonSleepButton, MonitorRequestReasonLid, MonitorRequestReasonBatteryCountChange, MonitorRequestReasonGracePeriod, MonitorRequestReasonPnP, MonitorRequestReasonDP, MonitorRequestReasonSxTransition, MonitorRequestReasonSystemIdle, MonitorRequestReasonNearProximity, MonitorRequestReasonThermalStandby, MonitorRequestReasonResumePdc, MonitorRequestReasonResumeS4, MonitorRequestReasonTerminal, MonitorRequestReasonPdcSignal, MonitorRequestReasonMax } POWER_MONITOR_REQUEST_REASON; typedef enum _POWER_MONITOR_REQUEST_TYPE { MonitorRequestTypeOff, MonitorRequestTypeOnAndPresent, MonitorRequestTypeToggleOn } POWER_MONITOR_REQUEST_TYPE; // // Monitor invocation // typedef struct _POWER_MONITOR_INVOCATION { BOOLEAN Console; POWER_MONITOR_REQUEST_REASON RequestReason; } POWER_MONITOR_INVOCATION, *PPOWER_MONITOR_INVOCATION; // // Last resume performance structure // typedef struct _RESUME_PERFORMANCE { ULONG PostTimeMs; ULONGLONG TotalResumeTimeMs; ULONGLONG ResumeCompleteTimestamp; } RESUME_PERFORMANCE, *PRESUME_PERFORMANCE; // // Power Setting definitions // typedef enum { PoAc, PoDc, PoHot, PoConditionMaximum } SYSTEM_POWER_CONDITION; typedef struct { // // Version of this structure. Currently should be set to // POWER_SETTING_VALUE_VERSION. // ULONG Version; // // GUID representing the power setting being applied. // GUID Guid; // // What power state should this setting be applied to? E.g. // AC, DC, thermal, ... // SYSTEM_POWER_CONDITION PowerCondition; // // Length (in bytes) of the 'Data' member. // ULONG DataLength; // // Data which contains the actual setting value. // UCHAR Data[ANYSIZE_ARRAY]; } SET_POWER_SETTING_VALUE, *PSET_POWER_SETTING_VALUE; #define POWER_SETTING_VALUE_VERSION (0x1) typedef struct { GUID Guid; } NOTIFY_USER_POWER_SETTING, *PNOTIFY_USER_POWER_SETTING; // // Package definition for an experience button device notification. When // someone registers for GUID_EXPERIENCE_BUTTON, this is the definition of // the setting data they'll get. // typedef struct _APPLICATIONLAUNCH_SETTING_VALUE { // // System time when the most recent button press ocurred. Note that this is // specified in 100ns internvals since January 1, 1601. // LARGE_INTEGER ActivationTime; // // Reserved for internal use. // ULONG Flags; // // which instance of this device was pressed? // ULONG ButtonInstanceID; } APPLICATIONLAUNCH_SETTING_VALUE, *PAPPLICATIONLAUNCH_SETTING_VALUE; // // define platform roles // typedef enum _POWER_PLATFORM_ROLE { PlatformRoleUnspecified = 0, PlatformRoleDesktop, PlatformRoleMobile, PlatformRoleWorkstation, PlatformRoleEnterpriseServer, PlatformRoleSOHOServer, PlatformRoleAppliancePC, PlatformRolePerformanceServer, // v1 last supported PlatformRoleSlate, // v2 last supported PlatformRoleMaximum } POWER_PLATFORM_ROLE, *PPOWER_PLATFORM_ROLE; #define POWER_PLATFORM_ROLE_V1 (0x00000001) #define POWER_PLATFORM_ROLE_V1_MAX (PlatformRolePerformanceServer + 1) #define POWER_PLATFORM_ROLE_V2 (0x00000002) #define POWER_PLATFORM_ROLE_V2_MAX (PlatformRoleSlate + 1) #if (NTDDI_VERSION >= NTDDI_WIN8) #define POWER_PLATFORM_ROLE_VERSION POWER_PLATFORM_ROLE_V2 #define POWER_PLATFORM_ROLE_VERSION_MAX POWER_PLATFORM_ROLE_V2_MAX #else #define POWER_PLATFORM_ROLE_VERSION POWER_PLATFORM_ROLE_V1 #define POWER_PLATFORM_ROLE_VERSION_MAX POWER_PLATFORM_ROLE_V1_MAX #endif typedef struct _POWER_PLATFORM_INFORMATION { BOOLEAN AoAc; } POWER_PLATFORM_INFORMATION, *PPOWER_PLATFORM_INFORMATION; // // System power manager capabilities // #if (NTDDI_VERSION >= NTDDI_WINXP) || !defined(_BATCLASS_) typedef struct { ULONG Granularity; ULONG Capacity; } BATTERY_REPORTING_SCALE, *PBATTERY_REPORTING_SCALE; #endif // (NTDDI_VERSION >= NTDDI_WINXP) || !defined(_BATCLASS_) #endif // !_PO_DDK_ _IRQL_requires_max_(APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtPowerInformation( _In_ POWER_INFORMATION_LEVEL InformationLevel, _In_reads_bytes_opt_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength ); // // Predefined Value Types. // #define REG_NONE ( 0ul ) // No value type #define REG_SZ ( 1ul ) // Unicode nul terminated string #define REG_EXPAND_SZ ( 2ul ) // Unicode nul terminated string // (with environment variable references) #define REG_BINARY ( 3ul ) // Free form binary #define REG_DWORD ( 4ul ) // 32-bit number #define REG_DWORD_LITTLE_ENDIAN ( 4ul ) // 32-bit number (same as REG_DWORD) #define REG_DWORD_BIG_ENDIAN ( 5ul ) // 32-bit number #define REG_LINK ( 6ul ) // Symbolic Link (unicode) #define REG_MULTI_SZ ( 7ul ) // Multiple Unicode strings #define REG_RESOURCE_LIST ( 8ul ) // Resource list in the resource map #define REG_FULL_RESOURCE_DESCRIPTOR ( 9ul ) // Resource list in the hardware description #define REG_RESOURCE_REQUIREMENTS_LIST ( 10ul ) #define REG_QWORD ( 11ul ) // 64-bit number #define REG_QWORD_LITTLE_ENDIAN ( 11ul ) // 64-bit number (same as REG_QWORD) // // Service Types (Bit Mask) // #define SERVICE_KERNEL_DRIVER 0x00000001 #define SERVICE_FILE_SYSTEM_DRIVER 0x00000002 #define SERVICE_ADAPTER 0x00000004 #define SERVICE_RECOGNIZER_DRIVER 0x00000008 #define SERVICE_DRIVER (SERVICE_KERNEL_DRIVER | \ SERVICE_FILE_SYSTEM_DRIVER | \ SERVICE_RECOGNIZER_DRIVER) #define SERVICE_WIN32_OWN_PROCESS 0x00000010 #define SERVICE_WIN32_SHARE_PROCESS 0x00000020 #define SERVICE_WIN32 (SERVICE_WIN32_OWN_PROCESS | \ SERVICE_WIN32_SHARE_PROCESS) #define SERVICE_USER_SERVICE 0x00000040 #define SERVICE_USERSERVICE_INSTANCE 0x00000080 #define SERVICE_USER_SHARE_PROCESS (SERVICE_USER_SERVICE | \ SERVICE_WIN32_SHARE_PROCESS) #define SERVICE_USER_OWN_PROCESS (SERVICE_USER_SERVICE | \ SERVICE_WIN32_OWN_PROCESS) #define SERVICE_INTERACTIVE_PROCESS 0x00000100 #define SERVICE_PKG_SERVICE 0x00000200 #define SERVICE_TYPE_ALL (SERVICE_WIN32 | \ SERVICE_ADAPTER | \ SERVICE_DRIVER | \ SERVICE_INTERACTIVE_PROCESS | \ SERVICE_USER_SERVICE | \ SERVICE_USERSERVICE_INSTANCE | \ SERVICE_PKG_SERVICE) // // Start Type // #define SERVICE_BOOT_START 0x00000000 #define SERVICE_SYSTEM_START 0x00000001 #define SERVICE_AUTO_START 0x00000002 #define SERVICE_DEMAND_START 0x00000003 #define SERVICE_DISABLED 0x00000004 // // Error control type // #define SERVICE_ERROR_IGNORE 0x00000000 #define SERVICE_ERROR_NORMAL 0x00000001 #define SERVICE_ERROR_SEVERE 0x00000002 #define SERVICE_ERROR_CRITICAL 0x00000003 // // // Define the registry driver node enumerations // typedef enum _CM_SERVICE_NODE_TYPE { DriverType = SERVICE_KERNEL_DRIVER, FileSystemType = SERVICE_FILE_SYSTEM_DRIVER, Win32ServiceOwnProcess = SERVICE_WIN32_OWN_PROCESS, Win32ServiceShareProcess = SERVICE_WIN32_SHARE_PROCESS, AdapterType = SERVICE_ADAPTER, RecognizerType = SERVICE_RECOGNIZER_DRIVER } SERVICE_NODE_TYPE; typedef enum _CM_SERVICE_LOAD_TYPE { BootLoad = SERVICE_BOOT_START, SystemLoad = SERVICE_SYSTEM_START, AutoLoad = SERVICE_AUTO_START, DemandLoad = SERVICE_DEMAND_START, DisableLoad = SERVICE_DISABLED } SERVICE_LOAD_TYPE; typedef enum _CM_ERROR_CONTROL_TYPE { IgnoreError = SERVICE_ERROR_IGNORE, NormalError = SERVICE_ERROR_NORMAL, SevereError = SERVICE_ERROR_SEVERE, CriticalError = SERVICE_ERROR_CRITICAL } SERVICE_ERROR_TYPE; // // Service node Flags. These flags are used by the OS loader to promote // a driver's start type to boot start if the system is booting using // the specified mechanism. The flags should be set in the driver's // registry configuration. // // CM_SERVICE_NETWORK_BOOT_LOAD - Specified if a driver should be // promoted on network boot. // // CM_SERVICE_VIRTUAL_DISK_BOOT_LOAD - Specified if a driver should be // promoted on booting from a VHD. // // CM_SERVICE_USB_DISK_BOOT_LOAD - Specified if a driver should be promoted // while booting from a USB disk. // // CM_SERVICE_SD_DISK_BOOT_LOAD - Specified if a driver should be promoted // while booting from SD storage. // // CM_SERVICE_USB3_DISK_BOOT_LOAD - Specified if a driver should be promoted // while booting from a disk on a USB3 controller. // // CM_SERVICE_MEASURED_BOOT_LOAD - Specified if a driver should be promoted // while booting with measured boot enabled. // // CM_SERVICE_VERIFIER_BOOT_LOAD - Specified if a driver should be promoted // while booting with verifier boot enabled. // // CM_SERVICE_WINPE_BOOT_LOAD - Specified if a driver should be promoted // on WinPE boot. // #define CM_SERVICE_NETWORK_BOOT_LOAD 0x00000001 #define CM_SERVICE_VIRTUAL_DISK_BOOT_LOAD 0x00000002 #define CM_SERVICE_USB_DISK_BOOT_LOAD 0x00000004 #define CM_SERVICE_SD_DISK_BOOT_LOAD 0x00000008 #define CM_SERVICE_USB3_DISK_BOOT_LOAD 0x00000010 #define CM_SERVICE_MEASURED_BOOT_LOAD 0x00000020 #define CM_SERVICE_VERIFIER_BOOT_LOAD 0x00000040 #define CM_SERVICE_WINPE_BOOT_LOAD 0x00000080 // // Mask defining the legal promotion flag values. // #define CM_SERVICE_VALID_PROMOTION_MASK (CM_SERVICE_NETWORK_BOOT_LOAD | \ CM_SERVICE_VIRTUAL_DISK_BOOT_LOAD | \ CM_SERVICE_USB_DISK_BOOT_LOAD | \ CM_SERVICE_SD_DISK_BOOT_LOAD | \ CM_SERVICE_USB3_DISK_BOOT_LOAD | \ CM_SERVICE_MEASURED_BOOT_LOAD | \ CM_SERVICE_VERIFIER_BOOT_LOAD | \ CM_SERVICE_WINPE_BOOT_LOAD) // // Resource List definitions // // // Defines the Type in the RESOURCE_DESCRIPTOR // // NOTE: For all CM_RESOURCE_TYPE values, there must be a // corresponding ResType value in the 32-bit ConfigMgr headerfile // (cfgmgr32.h). Values in the range [0x6,0x80) use the same values // as their ConfigMgr counterparts. CM_RESOURCE_TYPE values with // the high bit set (i.e., in the range [0x80,0xFF]), are // non-arbitrated resources. These correspond to the same values // in cfgmgr32.h that have their high bit set (however, since // cfgmgr32.h uses 16 bits for ResType values, these values are in // the range [0x8000,0x807F). Note that ConfigMgr ResType values // cannot be in the range [0x8080,0xFFFF), because they would not // be able to map into CM_RESOURCE_TYPE values. (0xFFFF itself is // a special value, because it maps to CmResourceTypeDeviceSpecific.) // typedef int CM_RESOURCE_TYPE; // CmResourceTypeNull is reserved #define CmResourceTypeNull 0 // ResType_All or ResType_None (0x0000) #define CmResourceTypePort 1 // ResType_IO (0x0002) #define CmResourceTypeInterrupt 2 // ResType_IRQ (0x0004) #define CmResourceTypeMemory 3 // ResType_Mem (0x0001) #define CmResourceTypeDma 4 // ResType_DMA (0x0003) #define CmResourceTypeDeviceSpecific 5 // ResType_ClassSpecific (0xFFFF) #define CmResourceTypeBusNumber 6 // ResType_BusNumber (0x0006) #define CmResourceTypeMemoryLarge 7 // ResType_MemLarge (0x0007) #define CmResourceTypeNonArbitrated 128 // Not arbitrated if 0x80 bit set #define CmResourceTypeConfigData 128 // ResType_Reserved (0x8000) #define CmResourceTypeDevicePrivate 129 // ResType_DevicePrivate (0x8001) #define CmResourceTypePcCardConfig 130 // ResType_PcCardConfig (0x8002) #define CmResourceTypeMfCardConfig 131 // ResType_MfCardConfig (0x8003) #define CmResourceTypeConnection 132 // ResType_Connection (0x8004) // // Defines the ShareDisposition in the RESOURCE_DESCRIPTOR // typedef enum _CM_SHARE_DISPOSITION { CmResourceShareUndetermined = 0, // Reserved CmResourceShareDeviceExclusive, CmResourceShareDriverExclusive, CmResourceShareShared } CM_SHARE_DISPOSITION; // // Define the bit masks for Flags when type is CmResourceTypeInterrupt // #define CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE 0x00 #define CM_RESOURCE_INTERRUPT_LATCHED 0x01 #define CM_RESOURCE_INTERRUPT_MESSAGE 0x02 #define CM_RESOURCE_INTERRUPT_POLICY_INCLUDED 0x04 #define CM_RESOURCE_INTERRUPT_SECONDARY_INTERRUPT 0x10 #define CM_RESOURCE_INTERRUPT_WAKE_HINT 0x20 // // A bitmask defining the bits in a resource or requirements descriptor // flags field that corresponds to the latch mode or a level triggered // interrupt. // #define CM_RESOURCE_INTERRUPT_LEVEL_LATCHED_BITS 0x0001 // // Define the token value used for an interrupt vector to mean that the vector // is message signaled. This value is used in the MaximumVector field. // #define CM_RESOURCE_INTERRUPT_MESSAGE_TOKEN ((ULONG)-2) // // Define the bit masks for Flags when type is CmResourceTypeMemory // or CmResourceTypeMemoryLarge // #define CM_RESOURCE_MEMORY_READ_WRITE 0x0000 #define CM_RESOURCE_MEMORY_READ_ONLY 0x0001 #define CM_RESOURCE_MEMORY_WRITE_ONLY 0x0002 #define CM_RESOURCE_MEMORY_WRITEABILITY_MASK 0x0003 #define CM_RESOURCE_MEMORY_PREFETCHABLE 0x0004 #define CM_RESOURCE_MEMORY_COMBINEDWRITE 0x0008 #define CM_RESOURCE_MEMORY_24 0x0010 #define CM_RESOURCE_MEMORY_CACHEABLE 0x0020 #define CM_RESOURCE_MEMORY_WINDOW_DECODE 0x0040 #define CM_RESOURCE_MEMORY_BAR 0x0080 #define CM_RESOURCE_MEMORY_COMPAT_FOR_INACCESSIBLE_RANGE 0x0100 // // Define the bit masks exclusive to type CmResourceTypeMemoryLarge. // #define CM_RESOURCE_MEMORY_LARGE 0x0E00 #define CM_RESOURCE_MEMORY_LARGE_40 0x0200 #define CM_RESOURCE_MEMORY_LARGE_48 0x0400 #define CM_RESOURCE_MEMORY_LARGE_64 0x0800 // // Define limits for large memory resources // #define CM_RESOURCE_MEMORY_LARGE_40_MAXLEN 0x000000FFFFFFFF00 #define CM_RESOURCE_MEMORY_LARGE_48_MAXLEN 0x0000FFFFFFFF0000 #define CM_RESOURCE_MEMORY_LARGE_64_MAXLEN 0xFFFFFFFF00000000 // // Define the bit masks for Flags when type is CmResourceTypePort // #define CM_RESOURCE_PORT_MEMORY 0x0000 #define CM_RESOURCE_PORT_IO 0x0001 #define CM_RESOURCE_PORT_10_BIT_DECODE 0x0004 #define CM_RESOURCE_PORT_12_BIT_DECODE 0x0008 #define CM_RESOURCE_PORT_16_BIT_DECODE 0x0010 #define CM_RESOURCE_PORT_POSITIVE_DECODE 0x0020 #define CM_RESOURCE_PORT_PASSIVE_DECODE 0x0040 #define CM_RESOURCE_PORT_WINDOW_DECODE 0x0080 #define CM_RESOURCE_PORT_BAR 0x0100 // // Define the bit masks for Flags when type is CmResourceTypeDma // #define CM_RESOURCE_DMA_8 0x0000 #define CM_RESOURCE_DMA_16 0x0001 #define CM_RESOURCE_DMA_32 0x0002 #define CM_RESOURCE_DMA_8_AND_16 0x0004 #define CM_RESOURCE_DMA_BUS_MASTER 0x0008 #define CM_RESOURCE_DMA_TYPE_A 0x0010 #define CM_RESOURCE_DMA_TYPE_B 0x0020 #define CM_RESOURCE_DMA_TYPE_F 0x0040 #define CM_RESOURCE_DMA_V3 0x0080 // // Define the different types of DMA transfer width values. // #define DMAV3_TRANFER_WIDTH_8 0x00 #define DMAV3_TRANFER_WIDTH_16 0x01 #define DMAV3_TRANFER_WIDTH_32 0x02 #define DMAV3_TRANFER_WIDTH_64 0x03 #define DMAV3_TRANFER_WIDTH_128 0x04 #define DMAV3_TRANFER_WIDTH_256 0x05 // // Define the Class and Type values for CmResourceTypeConnection // #define CM_RESOURCE_CONNECTION_CLASS_GPIO 0x01 #define CM_RESOURCE_CONNECTION_CLASS_SERIAL 0x02 #define CM_RESOURCE_CONNECTION_CLASS_FUNCTION_CONFIG 0x03 #define CM_RESOURCE_CONNECTION_TYPE_GPIO_IO 0x02 #define CM_RESOURCE_CONNECTION_TYPE_SERIAL_I2C 0x01 #define CM_RESOURCE_CONNECTION_TYPE_SERIAL_SPI 0x02 #define CM_RESOURCE_CONNECTION_TYPE_SERIAL_UART 0x03 #define CM_RESOURCE_CONNECTION_TYPE_FUNCTION_CONFIG 0x01 // // This structure defines one type of resource used by a driver. // // There can only be *1* DeviceSpecificData block. It must be located at // the end of all resource descriptors in a full descriptor block. // // // Make sure alignment is made properly by compiler; otherwise move // flags back to the top of the structure (common to all members of the // union). // #include "pshpack4.h" typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR { UCHAR Type; UCHAR ShareDisposition; USHORT Flags; union { // // Range of resources, inclusive. These are physical, bus relative. // It is known that Port and Memory below have the exact same layout // as Generic. // struct { PHYSICAL_ADDRESS Start; ULONG Length; } Generic; // // struct { PHYSICAL_ADDRESS Start; ULONG Length; } Port; // // struct { #if defined(NT_PROCESSOR_GROUPS) USHORT Level; USHORT Group; #else ULONG Level; #endif ULONG Vector; KAFFINITY Affinity; } Interrupt; // // Values for message signaled interrupts are distinct in the // raw and translated cases. // struct { union { struct { #if defined(NT_PROCESSOR_GROUPS) USHORT Group; #else USHORT Reserved; #endif USHORT MessageCount; ULONG Vector; KAFFINITY Affinity; } Raw; struct { #if defined(NT_PROCESSOR_GROUPS) USHORT Level; USHORT Group; #else ULONG Level; #endif ULONG Vector; KAFFINITY Affinity; } Translated; } DUMMYUNIONNAME; } MessageInterrupt; // // Range of memory addresses, inclusive. These are physical, bus // relative. The value should be the same as the one passed to // HalTranslateBusAddress(). // struct { PHYSICAL_ADDRESS Start; // 64 bit physical addresses. ULONG Length; } Memory; // // Physical DMA channel. // struct { ULONG Channel; ULONG Port; ULONG Reserved1; } Dma; struct { ULONG Channel; ULONG RequestLine; UCHAR TransferWidth; UCHAR Reserved1; UCHAR Reserved2; UCHAR Reserved3; } DmaV3; // // Device driver private data, usually used to help it figure // what the resource assignments decisions that were made. // struct { ULONG Data[3]; } DevicePrivate; // // Bus Number information. // struct { ULONG Start; ULONG Length; ULONG Reserved; } BusNumber; // // Device Specific information defined by the driver. // The DataSize field indicates the size of the data in bytes. The // data is located immediately after the DeviceSpecificData field in // the structure. // struct { ULONG DataSize; ULONG Reserved1; ULONG Reserved2; } DeviceSpecificData; // The following structures provide support for memory-mapped // IO resources greater than MAXULONG struct { PHYSICAL_ADDRESS Start; ULONG Length40; } Memory40; struct { PHYSICAL_ADDRESS Start; ULONG Length48; } Memory48; struct { PHYSICAL_ADDRESS Start; ULONG Length64; } Memory64; struct { UCHAR Class; UCHAR Type; UCHAR Reserved1; UCHAR Reserved2; ULONG IdLowPart; ULONG IdHighPart; } Connection; } u; } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR; #include "poppack.h" // // A Partial Resource List is what can be found in the ARC firmware // or will be generated by ntdetect.com. // The configuration manager will transform this structure into a Full // resource descriptor when it is about to store it in the regsitry. // // Note: There must a be a convention to the order of fields of same type, // (defined on a device by device basis) so that the fields can make sense // to a driver (i.e. when multiple memory ranges are necessary). // typedef struct _CM_PARTIAL_RESOURCE_LIST { USHORT Version; USHORT Revision; ULONG Count; CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1]; } CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST; // // A Full Resource Descriptor is what can be found in the registry. // This is what will be returned to a driver when it queries the registry // to get device information; it will be stored under a key in the hardware // description tree. // // Note: There must a be a convention to the order of fields of same type, // (defined on a device by device basis) so that the fields can make sense // to a driver (i.e. when multiple memory ranges are necessary). // typedef struct _CM_FULL_RESOURCE_DESCRIPTOR { INTERFACE_TYPE InterfaceType; // unused for WDM ULONG BusNumber; // unused for WDM CM_PARTIAL_RESOURCE_LIST PartialResourceList; } CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR; // // The Resource list is what will be stored by the drivers into the // resource map via the IO API. // typedef struct _CM_RESOURCE_LIST { ULONG Count; CM_FULL_RESOURCE_DESCRIPTOR List[1]; } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST; // // Define the structures used to interpret configuration data of // \\Registry\machine\hardware\description tree. // Basically, these structures are used to interpret component // sepcific data. // // // Define DEVICE_FLAGS // typedef struct _DEVICE_FLAGS { ULONG Failed : 1; ULONG ReadOnly : 1; ULONG Removable : 1; ULONG ConsoleIn : 1; ULONG ConsoleOut : 1; ULONG Input : 1; ULONG Output : 1; } DEVICE_FLAGS, *PDEVICE_FLAGS; // // Define Component Information structure // typedef struct _CM_COMPONENT_INFORMATION { DEVICE_FLAGS Flags; ULONG Version; ULONG Key; KAFFINITY AffinityMask; } CM_COMPONENT_INFORMATION, *PCM_COMPONENT_INFORMATION; // // The following structures are used to interpret x86 // DeviceSpecificData of CM_PARTIAL_RESOURCE_DESCRIPTOR. // (Most of the structures are defined by BIOS. They are // not aligned on word (or dword) boundary. // // // Define the Rom Block structure // typedef struct _CM_ROM_BLOCK { ULONG Address; ULONG Size; } CM_ROM_BLOCK, *PCM_ROM_BLOCK; #include "pshpack1.h" // // Define INT13 driver parameter block // typedef struct _CM_INT13_DRIVE_PARAMETER { USHORT DriveSelect; ULONG MaxCylinders; USHORT SectorsPerTrack; USHORT MaxHeads; USHORT NumberDrives; } CM_INT13_DRIVE_PARAMETER, *PCM_INT13_DRIVE_PARAMETER; // // Define Mca POS data block for slot // typedef struct _CM_MCA_POS_DATA { USHORT AdapterId; UCHAR PosData1; UCHAR PosData2; UCHAR PosData3; UCHAR PosData4; } CM_MCA_POS_DATA, *PCM_MCA_POS_DATA; // // Memory configuration of eisa data block structure // typedef struct _EISA_MEMORY_TYPE { UCHAR ReadWrite: 1; UCHAR Cached : 1; UCHAR Reserved0 :1; UCHAR Type:2; UCHAR Shared:1; UCHAR Reserved1 :1; UCHAR MoreEntries : 1; } EISA_MEMORY_TYPE, *PEISA_MEMORY_TYPE; typedef struct _EISA_MEMORY_CONFIGURATION { EISA_MEMORY_TYPE ConfigurationByte; UCHAR DataSize; USHORT AddressLowWord; UCHAR AddressHighByte; USHORT MemorySize; } EISA_MEMORY_CONFIGURATION, *PEISA_MEMORY_CONFIGURATION; // // Interrupt configurationn of eisa data block structure // typedef struct _EISA_IRQ_DESCRIPTOR { UCHAR Interrupt : 4; UCHAR Reserved :1; UCHAR LevelTriggered :1; UCHAR Shared : 1; UCHAR MoreEntries : 1; } EISA_IRQ_DESCRIPTOR, *PEISA_IRQ_DESCRIPTOR; typedef struct _EISA_IRQ_CONFIGURATION { EISA_IRQ_DESCRIPTOR ConfigurationByte; UCHAR Reserved; } EISA_IRQ_CONFIGURATION, *PEISA_IRQ_CONFIGURATION; // // DMA description of eisa data block structure // typedef struct _DMA_CONFIGURATION_BYTE0 { UCHAR Channel : 3; UCHAR Reserved : 3; UCHAR Shared :1; UCHAR MoreEntries :1; } DMA_CONFIGURATION_BYTE0; typedef struct _DMA_CONFIGURATION_BYTE1 { UCHAR Reserved0 : 2; UCHAR TransferSize : 2; UCHAR Timing : 2; UCHAR Reserved1 : 2; } DMA_CONFIGURATION_BYTE1; typedef struct _EISA_DMA_CONFIGURATION { DMA_CONFIGURATION_BYTE0 ConfigurationByte0; DMA_CONFIGURATION_BYTE1 ConfigurationByte1; } EISA_DMA_CONFIGURATION, *PEISA_DMA_CONFIGURATION; // // Port description of eisa data block structure // typedef struct _EISA_PORT_DESCRIPTOR { UCHAR NumberPorts : 5; UCHAR Reserved :1; UCHAR Shared :1; UCHAR MoreEntries : 1; } EISA_PORT_DESCRIPTOR, *PEISA_PORT_DESCRIPTOR; typedef struct _EISA_PORT_CONFIGURATION { EISA_PORT_DESCRIPTOR Configuration; USHORT PortAddress; } EISA_PORT_CONFIGURATION, *PEISA_PORT_CONFIGURATION; // // Eisa slot information definition // N.B. This structure is different from the one defined // in ARC eisa addendum. // typedef struct _CM_EISA_SLOT_INFORMATION { UCHAR ReturnCode; UCHAR ReturnFlags; UCHAR MajorRevision; UCHAR MinorRevision; USHORT Checksum; UCHAR NumberFunctions; UCHAR FunctionInformation; ULONG CompressedId; } CM_EISA_SLOT_INFORMATION, *PCM_EISA_SLOT_INFORMATION; // // Eisa function information definition // typedef struct _CM_EISA_FUNCTION_INFORMATION { ULONG CompressedId; UCHAR IdSlotFlags1; UCHAR IdSlotFlags2; UCHAR MinorRevision; UCHAR MajorRevision; UCHAR Selections[26]; UCHAR FunctionFlags; UCHAR TypeString[80]; EISA_MEMORY_CONFIGURATION EisaMemory[9]; EISA_IRQ_CONFIGURATION EisaIrq[7]; EISA_DMA_CONFIGURATION EisaDma[4]; EISA_PORT_CONFIGURATION EisaPort[20]; UCHAR InitializationData[60]; } CM_EISA_FUNCTION_INFORMATION, *PCM_EISA_FUNCTION_INFORMATION; // // The following defines the way pnp bios information is stored in // the registry \\HKEY_LOCAL_MACHINE\HARDWARE\Description\System\MultifunctionAdapter\x // key, where x is an integer number indicating adapter instance. The // "Identifier" of the key must equal to "PNP BIOS" and the // "ConfigurationData" is organized as follow: // // CM_PNP_BIOS_INSTALLATION_CHECK + // CM_PNP_BIOS_DEVICE_NODE for device 1 + // CM_PNP_BIOS_DEVICE_NODE for device 2 + // ... // CM_PNP_BIOS_DEVICE_NODE for device n // // // Pnp BIOS device node structure // typedef struct _CM_PNP_BIOS_DEVICE_NODE { USHORT Size; UCHAR Node; ULONG ProductId; UCHAR DeviceType[3]; USHORT DeviceAttributes; // followed by AllocatedResourceBlock, PossibleResourceBlock // and CompatibleDeviceId } CM_PNP_BIOS_DEVICE_NODE,*PCM_PNP_BIOS_DEVICE_NODE; // // Pnp BIOS Installation check // typedef struct _CM_PNP_BIOS_INSTALLATION_CHECK { UCHAR Signature[4]; // $PnP (ascii) UCHAR Revision; UCHAR Length; USHORT ControlField; UCHAR Checksum; ULONG EventFlagAddress; // Physical address USHORT RealModeEntryOffset; USHORT RealModeEntrySegment; USHORT ProtectedModeEntryOffset; ULONG ProtectedModeCodeBaseAddress; ULONG OemDeviceId; USHORT RealModeDataBaseAddress; ULONG ProtectedModeDataBaseAddress; } CM_PNP_BIOS_INSTALLATION_CHECK, *PCM_PNP_BIOS_INSTALLATION_CHECK; #include "poppack.h" // // Masks for EISA function information // #define EISA_FUNCTION_ENABLED 0x80 #define EISA_FREE_FORM_DATA 0x40 #define EISA_HAS_PORT_INIT_ENTRY 0x20 #define EISA_HAS_PORT_RANGE 0x10 #define EISA_HAS_DMA_ENTRY 0x08 #define EISA_HAS_IRQ_ENTRY 0x04 #define EISA_HAS_MEMORY_ENTRY 0x02 #define EISA_HAS_TYPE_ENTRY 0x01 #define EISA_HAS_INFORMATION EISA_HAS_PORT_RANGE + \ EISA_HAS_DMA_ENTRY + \ EISA_HAS_IRQ_ENTRY + \ EISA_HAS_MEMORY_ENTRY + \ EISA_HAS_TYPE_ENTRY // // Masks for EISA memory configuration // #define EISA_MORE_ENTRIES 0x80 #define EISA_SYSTEM_MEMORY 0x00 #define EISA_MEMORY_TYPE_RAM 0x01 // // Returned error code for EISA bios call // #define EISA_INVALID_SLOT 0x80 #define EISA_INVALID_FUNCTION 0x81 #define EISA_INVALID_CONFIGURATION 0x82 #define EISA_EMPTY_SLOT 0x83 #define EISA_INVALID_BIOS_CALL 0x86 // // The following structures are used to interpret mips // DeviceSpecificData of CM_PARTIAL_RESOURCE_DESCRIPTOR. // // // Device data records for adapters. // // // The device data record for the Emulex SCSI controller. // typedef struct _CM_SCSI_DEVICE_DATA { USHORT Version; USHORT Revision; UCHAR HostIdentifier; } CM_SCSI_DEVICE_DATA, *PCM_SCSI_DEVICE_DATA; // // Device data records for controllers. // // // The device data record for the Video controller. // typedef struct _CM_VIDEO_DEVICE_DATA { USHORT Version; USHORT Revision; ULONG VideoClock; } CM_VIDEO_DEVICE_DATA, *PCM_VIDEO_DEVICE_DATA; // // The device data record for the SONIC network controller. // typedef struct _CM_SONIC_DEVICE_DATA { USHORT Version; USHORT Revision; USHORT DataConfigurationRegister; UCHAR EthernetAddress[8]; } CM_SONIC_DEVICE_DATA, *PCM_SONIC_DEVICE_DATA; // // The device data record for the serial controller. // typedef struct _CM_SERIAL_DEVICE_DATA { USHORT Version; USHORT Revision; ULONG BaudClock; } CM_SERIAL_DEVICE_DATA, *PCM_SERIAL_DEVICE_DATA; // // Device data records for peripherals. // // // The device data record for the Monitor peripheral. // typedef struct _CM_MONITOR_DEVICE_DATA { USHORT Version; USHORT Revision; USHORT HorizontalScreenSize; USHORT VerticalScreenSize; USHORT HorizontalResolution; USHORT VerticalResolution; USHORT HorizontalDisplayTimeLow; USHORT HorizontalDisplayTime; USHORT HorizontalDisplayTimeHigh; USHORT HorizontalBackPorchLow; USHORT HorizontalBackPorch; USHORT HorizontalBackPorchHigh; USHORT HorizontalFrontPorchLow; USHORT HorizontalFrontPorch; USHORT HorizontalFrontPorchHigh; USHORT HorizontalSyncLow; USHORT HorizontalSync; USHORT HorizontalSyncHigh; USHORT VerticalBackPorchLow; USHORT VerticalBackPorch; USHORT VerticalBackPorchHigh; USHORT VerticalFrontPorchLow; USHORT VerticalFrontPorch; USHORT VerticalFrontPorchHigh; USHORT VerticalSyncLow; USHORT VerticalSync; USHORT VerticalSyncHigh; } CM_MONITOR_DEVICE_DATA, *PCM_MONITOR_DEVICE_DATA; // // The device data record for the Floppy peripheral. // typedef struct _CM_FLOPPY_DEVICE_DATA { USHORT Version; USHORT Revision; CHAR Size[8]; ULONG MaxDensity; ULONG MountDensity; // // New data fields for version >= 2.0 // UCHAR StepRateHeadUnloadTime; UCHAR HeadLoadTime; UCHAR MotorOffTime; UCHAR SectorLengthCode; UCHAR SectorPerTrack; UCHAR ReadWriteGapLength; UCHAR DataTransferLength; UCHAR FormatGapLength; UCHAR FormatFillCharacter; UCHAR HeadSettleTime; UCHAR MotorSettleTime; UCHAR MaximumTrackValue; UCHAR DataTransferRate; } CM_FLOPPY_DEVICE_DATA, *PCM_FLOPPY_DEVICE_DATA; // // The device data record for the Keyboard peripheral. // The KeyboardFlags is defined (by x86 BIOS INT 16h, function 02) as: // bit 7 : Insert on // bit 6 : Caps Lock on // bit 5 : Num Lock on // bit 4 : Scroll Lock on // bit 3 : Alt Key is down // bit 2 : Ctrl Key is down // bit 1 : Left shift key is down // bit 0 : Right shift key is down // typedef struct _CM_KEYBOARD_DEVICE_DATA { USHORT Version; USHORT Revision; UCHAR Type; UCHAR Subtype; USHORT KeyboardFlags; } CM_KEYBOARD_DEVICE_DATA, *PCM_KEYBOARD_DEVICE_DATA; // // Declaration of the structure for disk geometries // typedef struct _CM_DISK_GEOMETRY_DEVICE_DATA { ULONG BytesPerSector; ULONG NumberOfCylinders; ULONG SectorsPerTrack; ULONG NumberOfHeads; } CM_DISK_GEOMETRY_DEVICE_DATA, *PCM_DISK_GEOMETRY_DEVICE_DATA; // // Define the bitmasks for resource options // #define IO_RESOURCE_PREFERRED 0x01 #define IO_RESOURCE_DEFAULT 0x02 #define IO_RESOURCE_ALTERNATIVE 0x08 // // Define interrupt affinity policy values // #if defined(NT_PROCESSOR_GROUPS) typedef USHORT IRQ_DEVICE_POLICY, *PIRQ_DEVICE_POLICY; enum _IRQ_DEVICE_POLICY_USHORT { IrqPolicyMachineDefault = 0, IrqPolicyAllCloseProcessors = 1, IrqPolicyOneCloseProcessor = 2, IrqPolicyAllProcessorsInMachine = 3, IrqPolicyAllProcessorsInGroup = 3, IrqPolicySpecifiedProcessors = 4, IrqPolicySpreadMessagesAcrossAllProcessors = 5, IrqPolicyAllProcessorsInMachineWhenSteered = 6, IrqPolicyAllProcessorsInGroupWhenSteered = 6 }; #else typedef enum _IRQ_DEVICE_POLICY { IrqPolicyMachineDefault = 0, IrqPolicyAllCloseProcessors, IrqPolicyOneCloseProcessor, IrqPolicyAllProcessorsInMachine, IrqPolicySpecifiedProcessors, IrqPolicySpreadMessagesAcrossAllProcessors, IrqPolicyAllProcessorsInMachineWhenSteered } IRQ_DEVICE_POLICY, *PIRQ_DEVICE_POLICY; #endif // // Define interrupt priority policy values // typedef enum _IRQ_PRIORITY { IrqPriorityUndefined = 0, IrqPriorityLow, IrqPriorityNormal, IrqPriorityHigh } IRQ_PRIORITY, *PIRQ_PRIORITY; // // Define interrupt group affinity policy // typedef enum _IRQ_GROUP_POLICY { GroupAffinityAllGroupZero = 0, GroupAffinityDontCare } IRQ_GROUP_POLICY, *PIRQ_GROUP_POLICY; // // This structure defines one type of resource requested by the driver // typedef struct _IO_RESOURCE_DESCRIPTOR { UCHAR Option; UCHAR Type; // use CM_RESOURCE_TYPE UCHAR ShareDisposition; // use CM_SHARE_DISPOSITION UCHAR Spare1; USHORT Flags; // use CM resource flag defines USHORT Spare2; // align union { struct { ULONG Length; ULONG Alignment; PHYSICAL_ADDRESS MinimumAddress; PHYSICAL_ADDRESS MaximumAddress; } Port; struct { ULONG Length; ULONG Alignment; PHYSICAL_ADDRESS MinimumAddress; PHYSICAL_ADDRESS MaximumAddress; } Memory; struct { ULONG MinimumVector; ULONG MaximumVector; #if defined(NT_PROCESSOR_GROUPS) IRQ_DEVICE_POLICY AffinityPolicy; USHORT Group; #else IRQ_DEVICE_POLICY AffinityPolicy; #endif IRQ_PRIORITY PriorityPolicy; KAFFINITY TargetedProcessors; } Interrupt; struct { ULONG MinimumChannel; ULONG MaximumChannel; } Dma; struct { ULONG RequestLine; ULONG Reserved; ULONG Channel; ULONG TransferWidth; } DmaV3; struct { ULONG Length; ULONG Alignment; PHYSICAL_ADDRESS MinimumAddress; PHYSICAL_ADDRESS MaximumAddress; } Generic; struct { ULONG Data[3]; } DevicePrivate; // // Bus Number information. // struct { ULONG Length; ULONG MinBusNumber; ULONG MaxBusNumber; ULONG Reserved; } BusNumber; struct { ULONG Priority; // use LCPRI_Xxx values in cfg.h ULONG Reserved1; ULONG Reserved2; } ConfigData; // // The following structures provide descriptions // for memory resource requirement greater than MAXULONG // struct { ULONG Length40; ULONG Alignment40; PHYSICAL_ADDRESS MinimumAddress; PHYSICAL_ADDRESS MaximumAddress; } Memory40; struct { ULONG Length48; ULONG Alignment48; PHYSICAL_ADDRESS MinimumAddress; PHYSICAL_ADDRESS MaximumAddress; } Memory48; struct { ULONG Length64; ULONG Alignment64; PHYSICAL_ADDRESS MinimumAddress; PHYSICAL_ADDRESS MaximumAddress; } Memory64; struct { UCHAR Class; UCHAR Type; UCHAR Reserved1; UCHAR Reserved2; ULONG IdLowPart; ULONG IdHighPart; } Connection; } u; } IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR; typedef struct _IO_RESOURCE_LIST { USHORT Version; USHORT Revision; ULONG Count; IO_RESOURCE_DESCRIPTOR Descriptors[1]; } IO_RESOURCE_LIST, *PIO_RESOURCE_LIST; typedef struct _IO_RESOURCE_REQUIREMENTS_LIST { ULONG ListSize; INTERFACE_TYPE InterfaceType; // unused for WDM ULONG BusNumber; // unused for WDM ULONG SlotNumber; ULONG Reserved[3]; ULONG AlternativeLists; IO_RESOURCE_LIST List[1]; } IO_RESOURCE_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST; // // for move macros // #ifdef _MAC #ifndef _INC_STRING #include #endif /* _INC_STRING */ #else #include #endif // _MAC #ifndef _SLIST_HEADER_ #define _SLIST_HEADER_ #if defined(_WIN64) // // The type SINGLE_LIST_ENTRY is not suitable for use with SLISTs. For // WIN64, an entry on an SLIST is required to be 16-byte aligned, while a // SINGLE_LIST_ENTRY structure has only 8 byte alignment. // // Therefore, all SLIST code should use the SLIST_ENTRY type instead of the // SINGLE_LIST_ENTRY type. // #pragma warning(push) #pragma warning(disable:4324) // structure padded due to align() typedef struct DECLSPEC_ALIGN(16) _SLIST_ENTRY { struct _SLIST_ENTRY *Next; } SLIST_ENTRY, *PSLIST_ENTRY; #pragma warning(pop) #else typedef struct _SINGLE_LIST_ENTRY SLIST_ENTRY, *PSLIST_ENTRY; #endif // _WIN64 #if defined(_AMD64_) typedef union DECLSPEC_ALIGN(16) _SLIST_HEADER { struct { // original struct ULONGLONG Alignment; ULONGLONG Region; } DUMMYSTRUCTNAME; struct { // x64 16-byte header ULONGLONG Depth:16; ULONGLONG Sequence:48; ULONGLONG Reserved:4; ULONGLONG NextEntry:60; // last 4 bits are always 0's } HeaderX64; } SLIST_HEADER, *PSLIST_HEADER; #elif defined(_ARM64_) // ARM64_WORKITEM: should this be merged with AMD64 above? typedef union DECLSPEC_ALIGN(16) _SLIST_HEADER { struct { // original struct ULONGLONG Alignment; ULONGLONG Region; } DUMMYSTRUCTNAME; struct { // ARM64 16-byte header ULONGLONG Depth:16; ULONGLONG Sequence:48; ULONGLONG Reserved:4; ULONGLONG NextEntry:60; // last 4 bits are always 0's } HeaderArm64; } SLIST_HEADER, *PSLIST_HEADER; #elif defined(_X86_) typedef union _SLIST_HEADER { ULONGLONG Alignment; struct { SLIST_ENTRY Next; USHORT Depth; USHORT CpuId; } DUMMYSTRUCTNAME; } SLIST_HEADER, *PSLIST_HEADER; #elif defined(_ARM_) typedef union _SLIST_HEADER { ULONGLONG Alignment; struct { SLIST_ENTRY Next; USHORT Depth; USHORT Reserved; } DUMMYSTRUCTNAME; } SLIST_HEADER, *PSLIST_HEADER; #endif #endif // _SLIST_HEADER_ // // If debugging support enabled, define an ASSERT macro that works. Otherwise // define the ASSERT macro to expand to an empty expression. // // The ASSERT macro has been updated to be an expression instead of a statement. // NTSYSAPI __analysis_noreturn VOID NTAPI RtlAssert( _In_ PVOID VoidFailedAssertion, _In_ PVOID VoidFileName, _In_ ULONG LineNumber, _In_opt_ PSTR MutableMessage ); #if DBG #define ASSERT( exp ) \ ((!(exp)) ? \ (RtlAssert( #exp, __FILE__, __LINE__, NULL ),FALSE) : \ TRUE) #define ASSERTMSG( msg, exp ) \ ((!(exp)) ? \ (RtlAssert( #exp, __FILE__, __LINE__, msg ),FALSE) : \ TRUE) #define RTL_SOFT_ASSERT(_exp) \ ((!(_exp)) ? \ (DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n", __FILE__, __LINE__, #_exp),FALSE) : \ TRUE) #define RTL_SOFT_ASSERTMSG(_msg, _exp) \ ((!(_exp)) ? \ (DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n Message: %s\n", __FILE__, __LINE__, #_exp, (_msg)),FALSE) : \ TRUE) #define RTL_VERIFY ASSERT #define RTL_VERIFYMSG ASSERTMSG #define RTL_SOFT_VERIFY RTL_SOFT_ASSERT #define RTL_SOFT_VERIFYMSG RTL_SOFT_ASSERTMSG #else #define ASSERT( exp ) ((void) 0) #define ASSERTMSG( msg, exp ) ((void) 0) #define RTL_SOFT_ASSERT(_exp) ((void) 0) #define RTL_SOFT_ASSERTMSG(_msg, _exp) ((void) 0) #define RTL_VERIFY( exp ) ((exp) ? TRUE : FALSE) #define RTL_VERIFYMSG( msg, exp ) ((exp) ? TRUE : FALSE) #define RTL_SOFT_VERIFY(_exp) ((_exp) ? TRUE : FALSE) #define RTL_SOFT_VERIFYMSG(msg, _exp) ((_exp) ? TRUE : FALSE) #endif // DBG #if !defined(MIDL_PASS) && !defined(SORTPP_PASS) #pragma warning(push) #pragma warning(disable:4714) // function marked as FORCEINLINE not inlined #pragma warning(disable:4793) // function compiled as native // Include the more obscure SAL annotations (like __drv_aliasesMem) instead of assuming the crtdefs.h will include them. #include // // Fast fail failure codes. // // N.B. Failure code zero should not be used, but is required to be reserved // for compatibility with previous handling of the // STATUS_STACK_BUFFER_OVERRUN exception status code. // #define FAST_FAIL_LEGACY_GS_VIOLATION 0 #define FAST_FAIL_VTGUARD_CHECK_FAILURE 1 #define FAST_FAIL_STACK_COOKIE_CHECK_FAILURE 2 #define FAST_FAIL_CORRUPT_LIST_ENTRY 3 #define FAST_FAIL_INCORRECT_STACK 4 #define FAST_FAIL_INVALID_ARG 5 #define FAST_FAIL_GS_COOKIE_INIT 6 #define FAST_FAIL_FATAL_APP_EXIT 7 #define FAST_FAIL_RANGE_CHECK_FAILURE 8 #define FAST_FAIL_UNSAFE_REGISTRY_ACCESS 9 #define FAST_FAIL_GUARD_ICALL_CHECK_FAILURE 10 #define FAST_FAIL_GUARD_WRITE_CHECK_FAILURE 11 #define FAST_FAIL_INVALID_FIBER_SWITCH 12 #define FAST_FAIL_INVALID_SET_OF_CONTEXT 13 #define FAST_FAIL_INVALID_REFERENCE_COUNT 14 #define FAST_FAIL_INVALID_JUMP_BUFFER 18 #define FAST_FAIL_MRDATA_MODIFIED 19 #define FAST_FAIL_CERTIFICATION_FAILURE 20 #define FAST_FAIL_INVALID_EXCEPTION_CHAIN 21 #define FAST_FAIL_CRYPTO_LIBRARY 22 #define FAST_FAIL_INVALID_CALL_IN_DLL_CALLOUT 23 #define FAST_FAIL_INVALID_IMAGE_BASE 24 #define FAST_FAIL_DLOAD_PROTECTION_FAILURE 25 #define FAST_FAIL_UNSAFE_EXTENSION_CALL 26 #define FAST_FAIL_DEPRECATED_SERVICE_INVOKED 27 #define FAST_FAIL_INVALID_BUFFER_ACCESS 28 #define FAST_FAIL_INVALID_BALANCED_TREE 29 #define FAST_FAIL_INVALID_NEXT_THREAD 30 #define FAST_FAIL_GUARD_ICALL_CHECK_SUPPRESSED 31 // Telemetry, nonfatal #define FAST_FAIL_APCS_DISABLED 32 #define FAST_FAIL_INVALID_IDLE_STATE 33 #define FAST_FAIL_MRDATA_PROTECTION_FAILURE 34 #define FAST_FAIL_UNEXPECTED_HEAP_EXCEPTION 35 #define FAST_FAIL_INVALID_LOCK_STATE 36 #define FAST_FAIL_GUARD_JUMPTABLE 37 // Known to compiler, must retain value 37 #define FAST_FAIL_INVALID_LONGJUMP_TARGET 38 #define FAST_FAIL_INVALID_DISPATCH_CONTEXT 39 #define FAST_FAIL_INVALID_THREAD 40 #define FAST_FAIL_INVALID_FAST_FAIL_CODE 0xFFFFFFFF #if _MSC_VER >= 1610 DECLSPEC_NORETURN VOID __fastfail( _In_ unsigned int Code ); #pragma intrinsic(__fastfail) #endif #if _MSC_VER >= 1610 //++ //VOID //RtlFailFast ( // _In_ ULONG Code // ); // // Routine Description: // // This routine brings down the caller immediately in the event that // critical corruption has been detected. No exception handlers are // invoked. // // The routine may be used in libraries shared with user mode and // kernel mode. In user mode, the process is terminated, whereas in // kernel mode, a KERNEL_SECURITY_CHECK_FAILURE bug check is raised. // // Arguments // // Code - Supplies the reason code describing what type of corruption // was detected. // // Return Value: // // None. There is no return from this routine. // //-- DECLSPEC_NORETURN FORCEINLINE VOID RtlFailFast( _In_ ULONG Code ) { __fastfail(Code); } #endif // _MSC_VER // // The __fastfail intrinsic is only available for compilation to native code. // Pure and safe managed code may not reference it in compilation (though such // code should not invoke the LIST_ENTRY forceinlines anyway). // #if !defined(_MSC_FULL_VER) || (_MSC_FULL_VER < 161030716) || defined(_M_CEE_PURE) || defined(_M_CEE_SAFE) #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) #define NO_KERNEL_LIST_ENTRY_CHECKS #endif #endif // // Doubly-linked list manipulation routines. // // // VOID // InitializeListHead32( // PLIST_ENTRY32 ListHead // ); // #define InitializeListHead32(ListHead) (\ (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead))) #define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x } FORCEINLINE VOID InitializeListHead( _Out_ PLIST_ENTRY ListHead ) { ListHead->Flink = ListHead->Blink = ListHead; return; } _Must_inspect_result_ BOOLEAN CFORCEINLINE IsListEmpty( _In_ const LIST_ENTRY * ListHead ) { return (BOOLEAN)(ListHead->Flink == ListHead); } FORCEINLINE BOOLEAN RemoveEntryListUnsafe( _In_ PLIST_ENTRY Entry ) { PLIST_ENTRY Blink; PLIST_ENTRY Flink; Flink = Entry->Flink; Blink = Entry->Blink; Blink->Flink = Flink; Flink->Blink = Blink; return (BOOLEAN)(Flink == Blink); } #if defined(NO_KERNEL_LIST_ENTRY_CHECKS) FORCEINLINE BOOLEAN RemoveEntryList( _In_ PLIST_ENTRY Entry ) { PLIST_ENTRY Blink; PLIST_ENTRY Flink; Flink = Entry->Flink; Blink = Entry->Blink; Blink->Flink = Flink; Flink->Blink = Blink; return (BOOLEAN)(Flink == Blink); } FORCEINLINE PLIST_ENTRY RemoveHeadList( _Inout_ PLIST_ENTRY ListHead ) { PLIST_ENTRY Flink; PLIST_ENTRY Entry; Entry = ListHead->Flink; Flink = Entry->Flink; ListHead->Flink = Flink; Flink->Blink = ListHead; return Entry; } FORCEINLINE PLIST_ENTRY RemoveTailList( _Inout_ PLIST_ENTRY ListHead ) { PLIST_ENTRY Blink; PLIST_ENTRY Entry; Entry = ListHead->Blink; Blink = Entry->Blink; ListHead->Blink = Blink; Blink->Flink = ListHead; return Entry; } FORCEINLINE VOID InsertTailList( _Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry ) { PLIST_ENTRY Blink; Blink = ListHead->Blink; Entry->Flink = ListHead; Entry->Blink = Blink; Blink->Flink = Entry; ListHead->Blink = Entry; return; } FORCEINLINE VOID InsertHeadList( _Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry ) { PLIST_ENTRY Flink; Flink = ListHead->Flink; Entry->Flink = Flink; Entry->Blink = ListHead; Flink->Blink = Entry; ListHead->Flink = Entry; return; } FORCEINLINE VOID AppendTailList( _Inout_ PLIST_ENTRY ListHead, _Inout_ PLIST_ENTRY ListToAppend ) { PLIST_ENTRY ListEnd = ListHead->Blink; ListHead->Blink->Flink = ListToAppend; ListHead->Blink = ListToAppend->Blink; ListToAppend->Blink->Flink = ListHead; ListToAppend->Blink = ListEnd; return; } #else // NO_KERNEL_LIST_ENTRY_CHECKS //++ //VOID //FatalListEntryError ( // _In_ PVOID p1, // _In_ PVOID p2, // _In_ PVOID p3 // ); // // Routine Description: // // This routine reports a fatal list entry error. It is implemented here as a // wrapper around RtlFailFast so that alternative reporting mechanisms (such // as simply logging and trying to continue) can be easily switched in. // // Arguments: // // p1 - Supplies the first failure parameter. // // p2 - Supplies the second failure parameter. // // p3 - Supplies the third failure parameter. // //Return Value: // // None. //-- FORCEINLINE VOID FatalListEntryError( _In_ PVOID p1, _In_ PVOID p2, _In_ PVOID p3 ) { UNREFERENCED_PARAMETER(p1); UNREFERENCED_PARAMETER(p2); UNREFERENCED_PARAMETER(p3); RtlFailFast(FAST_FAIL_CORRUPT_LIST_ENTRY); } FORCEINLINE VOID RtlpCheckListEntry( _In_ PLIST_ENTRY Entry ) { if ((((Entry->Flink)->Blink) != Entry) || (((Entry->Blink)->Flink) != Entry)) { FatalListEntryError((PVOID)(Entry), (PVOID)((Entry->Flink)->Blink), (PVOID)((Entry->Blink)->Flink)); } } FORCEINLINE BOOLEAN RemoveEntryList( _In_ PLIST_ENTRY Entry ) { PLIST_ENTRY PrevEntry; PLIST_ENTRY NextEntry; NextEntry = Entry->Flink; PrevEntry = Entry->Blink; if ((NextEntry->Blink != Entry) || (PrevEntry->Flink != Entry)) { FatalListEntryError((PVOID)PrevEntry, (PVOID)Entry, (PVOID)NextEntry); } PrevEntry->Flink = NextEntry; NextEntry->Blink = PrevEntry; return (BOOLEAN)(PrevEntry == NextEntry); } FORCEINLINE PLIST_ENTRY RemoveHeadList( _Inout_ PLIST_ENTRY ListHead ) { PLIST_ENTRY Entry; PLIST_ENTRY NextEntry; Entry = ListHead->Flink; #if DBG RtlpCheckListEntry(ListHead); #endif NextEntry = Entry->Flink; if ((Entry->Blink != ListHead) || (NextEntry->Blink != Entry)) { FatalListEntryError((PVOID)ListHead, (PVOID)Entry, (PVOID)NextEntry); } ListHead->Flink = NextEntry; NextEntry->Blink = ListHead; return Entry; } FORCEINLINE PLIST_ENTRY RemoveTailList( _Inout_ PLIST_ENTRY ListHead ) { PLIST_ENTRY Entry; PLIST_ENTRY PrevEntry; Entry = ListHead->Blink; #if DBG RtlpCheckListEntry(ListHead); #endif PrevEntry = Entry->Blink; if ((Entry->Flink != ListHead) || (PrevEntry->Flink != Entry)) { FatalListEntryError((PVOID)PrevEntry, (PVOID)Entry, (PVOID)ListHead); } ListHead->Blink = PrevEntry; PrevEntry->Flink = ListHead; return Entry; } FORCEINLINE VOID InsertTailList( _Inout_ PLIST_ENTRY ListHead, _Out_ __drv_aliasesMem PLIST_ENTRY Entry ) { PLIST_ENTRY PrevEntry; #if DBG RtlpCheckListEntry(ListHead); #endif PrevEntry = ListHead->Blink; if (PrevEntry->Flink != ListHead) { FatalListEntryError((PVOID)PrevEntry, (PVOID)ListHead, (PVOID)PrevEntry->Flink); } Entry->Flink = ListHead; Entry->Blink = PrevEntry; PrevEntry->Flink = Entry; ListHead->Blink = Entry; return; } FORCEINLINE VOID InsertHeadList( _Inout_ PLIST_ENTRY ListHead, _Out_ __drv_aliasesMem PLIST_ENTRY Entry ) { PLIST_ENTRY NextEntry; #if DBG RtlpCheckListEntry(ListHead); #endif NextEntry = ListHead->Flink; if (NextEntry->Blink != ListHead) { FatalListEntryError((PVOID)ListHead, (PVOID)NextEntry, (PVOID)NextEntry->Blink); } Entry->Flink = NextEntry; Entry->Blink = ListHead; NextEntry->Blink = Entry; ListHead->Flink = Entry; return; } FORCEINLINE VOID AppendTailList( _Inout_ PLIST_ENTRY ListHead, _Inout_ PLIST_ENTRY ListToAppend ) { PLIST_ENTRY ListEnd = ListHead->Blink; RtlpCheckListEntry(ListHead); RtlpCheckListEntry(ListToAppend); ListHead->Blink->Flink = ListToAppend; ListHead->Blink = ListToAppend->Blink; ListToAppend->Blink->Flink = ListHead; ListToAppend->Blink = ListEnd; return; } #endif // NO_KERNEL_LIST_ENTRY_CHECKS FORCEINLINE PSINGLE_LIST_ENTRY PopEntryList( _Inout_ PSINGLE_LIST_ENTRY ListHead ) { PSINGLE_LIST_ENTRY FirstEntry; FirstEntry = ListHead->Next; if (FirstEntry != NULL) { ListHead->Next = FirstEntry->Next; } return FirstEntry; } FORCEINLINE VOID PushEntryList( _Inout_ PSINGLE_LIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry ) { Entry->Next = ListHead->Next; ListHead->Next = Entry; return; } #pragma warning(pop) #endif // !MIDL_PASS #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _At_(String->MaximumLength, _Const_) NTSYSAPI NTSTATUS NTAPI RtlIntegerToUnicodeString ( _In_ ULONG Value, _In_opt_ ULONG Base, _Inout_ PUNICODE_STRING String ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _At_(String->MaximumLength, _Const_) NTSYSAPI NTSTATUS NTAPI RtlInt64ToUnicodeString ( _In_ ULONGLONG Value, _In_opt_ ULONG Base, _Inout_ PUNICODE_STRING String ); #endif #ifdef _WIN64 #define RtlIntPtrToUnicodeString(Value, Base, String) RtlInt64ToUnicodeString(Value, Base, String) #else #define RtlIntPtrToUnicodeString(Value, Base, String) RtlIntegerToUnicodeString(Value, Base, String) #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToInteger ( _In_ PCUNICODE_STRING String, _In_opt_ ULONG Base, _Out_ PULONG Value ); #endif #if !defined(BLDR_KERNEL_RUNTIME) NTSTATUS RtlUnicodeStringToInt64 ( _In_ PCUNICODE_STRING String, _In_opt_ ULONG Base, _Out_ PLONG64 Number, _Out_opt_ PWSTR *EndPointer ); #endif // // String manipulation routines // #ifdef _NTSYSTEM_ #define NLS_MB_CODE_PAGE_TAG NlsMbCodePageTag #define NLS_MB_OEM_CODE_PAGE_TAG NlsMbOemCodePageTag #else #define NLS_MB_CODE_PAGE_TAG (*NlsMbCodePageTag) #define NLS_MB_OEM_CODE_PAGE_TAG (*NlsMbOemCodePageTag) #endif // _NTSYSTEM_ extern BOOLEAN NLS_MB_CODE_PAGE_TAG; // TRUE -> Multibyte CP, FALSE -> Singlebyte extern BOOLEAN NLS_MB_OEM_CODE_PAGE_TAG; // TRUE -> Multibyte CP, FALSE -> Singlebyte #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTSYSAPI VOID NTAPI RtlInitString( _Out_ PSTRING DestinationString, _In_opt_z_ __drv_aliasesMem PCSZ SourceString ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTSYSAPI VOID NTAPI RtlInitAnsiString( _Out_ PANSI_STRING DestinationString, _In_opt_z_ __drv_aliasesMem PCSZ SourceString ); #endif _IRQL_requires_max_(DISPATCH_LEVEL) _At_(DestinationString->Buffer, _Post_equal_to_(SourceString)) _At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) * sizeof(WCHAR))) _At_(DestinationString->MaximumLength, _Post_equal_to_((_String_length_(SourceString)+1) * sizeof(WCHAR))) NTSYSAPI VOID NTAPI RtlInitUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_opt_z_ __drv_aliasesMem PCWSTR SourceString ); #if !defined(MIDL_PASS) _At_(UnicodeString->Buffer, _Post_equal_to_(Buffer)) _At_(UnicodeString->Length, _Post_equal_to_(0)) _At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize)) FORCEINLINE VOID RtlInitEmptyUnicodeString( _Out_ PUNICODE_STRING UnicodeString, _Writable_bytes_(BufferSize) _When_(BufferSize != 0, _Notnull_) __drv_aliasesMem PWCHAR Buffer, _In_ USHORT BufferSize ) { UnicodeString->Length = 0; UnicodeString->MaximumLength = BufferSize; UnicodeString->Buffer = Buffer; } _At_(AnsiString->Buffer, _Post_equal_to_(Buffer)) _At_(AnsiString->Length, _Post_equal_to_(0)) _At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize)) FORCEINLINE VOID RtlInitEmptyAnsiString( _Out_ PANSI_STRING AnsiString, _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer, _In_ USHORT BufferSize ) { AnsiString->Length = 0; AnsiString->MaximumLength = BufferSize; AnsiString->Buffer = Buffer; } #endif // !defined(MIDL_PASS) // // Subroutines for dealing with the Registry // typedef _Function_class_(RTL_QUERY_REGISTRY_ROUTINE) _IRQL_requires_max_(PASSIVE_LEVEL) _IRQL_requires_same_ NTSTATUS NTAPI RTL_QUERY_REGISTRY_ROUTINE( _In_z_ PWSTR ValueName, _In_ ULONG ValueType, _In_reads_bytes_opt_(ValueLength) PVOID ValueData, _In_ ULONG ValueLength, _In_opt_ PVOID Context, _In_opt_ PVOID EntryContext ); typedef RTL_QUERY_REGISTRY_ROUTINE *PRTL_QUERY_REGISTRY_ROUTINE; typedef struct _RTL_QUERY_REGISTRY_TABLE { PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine; ULONG Flags; PWSTR Name; PVOID EntryContext; ULONG DefaultType; PVOID DefaultData; ULONG DefaultLength; } RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE; // // The following flags specify how the Name field of a RTL_QUERY_REGISTRY_TABLE // entry is interpreted. A NULL name indicates the end of the table. // #define RTL_QUERY_REGISTRY_SUBKEY 0x00000001 // Name is a subkey and remainder of // table or until next subkey are value // names for that subkey to look at. #define RTL_QUERY_REGISTRY_TOPKEY 0x00000002 // Reset current key to original key for // this and all following table entries. #define RTL_QUERY_REGISTRY_REQUIRED 0x00000004 // Fail if no match found for this table // entry. #define RTL_QUERY_REGISTRY_NOVALUE 0x00000008 // Used to mark a table entry that has no // value name, just wants a call out, not // an enumeration of all values. #define RTL_QUERY_REGISTRY_NOEXPAND 0x00000010 // Used to suppress the expansion of // REG_MULTI_SZ into multiple callouts or // to prevent the expansion of environment // variable values in REG_EXPAND_SZ #define RTL_QUERY_REGISTRY_DIRECT 0x00000020 // QueryRoutine field ignored. EntryContext // field points to location to store value. // For null terminated strings, EntryContext // points to UNICODE_STRING structure that // that describes maximum size of buffer. // If .Buffer field is NULL then a buffer is // allocated. // #define RTL_QUERY_REGISTRY_DELETE 0x00000040 // Used to delete value keys after they // are queried. #define RTL_QUERY_REGISTRY_NOSTRING 0x00000080 // THIS IS DEPRECATED - use RTL_QUERY_REGISTRY_TYPECHECK // // Used with RTL_QUERY_REGISTRY_DIRECT in // cases where the caller expects a // non-string value. Otherwise, the // assumption that EntryContext points to // a UNICODE_STRING structure can overrun // the caller's buffer. // #define RTL_QUERY_REGISTRY_TYPECHECK 0x00000100 // Used with RTL_QUERY_REGISTRY_DIRECT to // validate the registry value type // expected by caller with actual type thats // read from the registry. // // Use the most significant byte of DefaultType from QueryTable, as the // caller's expected REG_TYPE // #define RTL_QUERY_REGISTRY_TYPECHECK_SHIFT 24 #define RTL_QUERY_REGISTRY_TYPECHECK_MASK (0xff << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlQueryRegistryValues( _In_ ULONG RelativeTo, _In_ PCWSTR Path, _Inout_ _At_(*(*QueryTable).EntryContext, _Pre_unknown_) PRTL_QUERY_REGISTRY_TABLE QueryTable, _In_opt_ PVOID Context, _In_opt_ PVOID Environment ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) && !defined(MIDL_PASS) _IRQL_requires_max_(PASSIVE_LEVEL) DECLSPEC_IMPORT PVOID NTAPI MmGetSystemRoutineAddress ( _In_ PUNICODE_STRING SystemRoutineName ); _IRQL_requires_max_(PASSIVE_LEVEL) FORCEINLINE NTSTATUS RtlxQueryRegistryValues( _In_ ULONG RelativeTo, _In_ PCWSTR Path, _Inout_ _At_(*(*QueryTable).EntryContext, _Pre_unknown_) PRTL_QUERY_REGISTRY_TABLE QueryTable, _In_opt_ PVOID Context, _In_opt_ PVOID Environment ) { typedef NTSTATUS NTAPI QUERYFN( ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID); UNICODE_STRING FunctionName; QUERYFN* QueryRoutine; RtlInitUnicodeString(&FunctionName, L"RtlQueryRegistryValuesEx"); #pragma warning(push) #pragma warning(disable: 4055) QueryRoutine = (QUERYFN*)MmGetSystemRoutineAddress(&FunctionName); #pragma warning(pop) if (QueryRoutine == NULL) { QueryRoutine = &RtlQueryRegistryValues; } return QueryRoutine(RelativeTo, Path, QueryTable, Context, Environment); } #endif #if (NTDDI_VERSION >= NTDDI_WIN8) && !defined(MIDL_PASS) #undef RtlQueryRegistryValues #define RtlQueryRegistryValues RtlxQueryRegistryValues #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlWriteRegistryValue( _In_ ULONG RelativeTo, _In_ PCWSTR Path, _In_z_ PCWSTR ValueName, _In_ ULONG ValueType, _In_reads_bytes_opt_(ValueLength) PVOID ValueData, _In_ ULONG ValueLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlDeleteRegistryValue( _In_ ULONG RelativeTo, _In_ PCWSTR Path, _In_z_ PCWSTR ValueName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlCreateRegistryKey( _In_ ULONG RelativeTo, _In_ PWSTR Path ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlCheckRegistryKey( _In_ ULONG RelativeTo, _In_ PWSTR Path ); #endif // // The following values for the RelativeTo parameter determine what the // Path parameter to RtlQueryRegistryValues is relative to. // #define RTL_REGISTRY_ABSOLUTE 0 // Path is a full path #define RTL_REGISTRY_SERVICES 1 // \Registry\Machine\System\CurrentControlSet\Services #define RTL_REGISTRY_CONTROL 2 // \Registry\Machine\System\CurrentControlSet\Control #define RTL_REGISTRY_WINDOWS_NT 3 // \Registry\Machine\Software\Microsoft\Windows NT\CurrentVersion #define RTL_REGISTRY_DEVICEMAP 4 // \Registry\Machine\Hardware\DeviceMap #define RTL_REGISTRY_USER 5 // \Registry\User\CurrentUser #define RTL_REGISTRY_MAXIMUM 6 #define RTL_REGISTRY_HANDLE 0x40000000 // Low order bits are registry handle #define RTL_REGISTRY_OPTIONAL 0x80000000 // Indicates the key node is optional #if (NTDDI_VERSION >= NTDDI_WS03) _IRQL_requires_max_(DISPATCH_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlInitAnsiStringEx( _Out_ PANSI_STRING DestinationString, _In_opt_z_ __drv_aliasesMem PCSZ SourceString ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(DISPATCH_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlInitStringEx( _Out_ PSTRING DestinationString, _In_opt_z_ __drv_aliasesMem PCSZ SourceString ); #endif // // NLS String functions // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString( _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem))) _When_(!AllocateDestinationString, _Inout_) PUNICODE_STRING DestinationString, _In_ PCANSI_STRING SourceString, _In_ BOOLEAN AllocateDestinationString ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _When_(AllocateDestinationString, _At_(DestinationString->MaximumLength, _Out_range_(<=, (SourceString->MaximumLength / sizeof(WCHAR))))) _When_(!AllocateDestinationString, _At_(DestinationString->Buffer, _Const_) _At_(DestinationString->MaximumLength, _Const_)) _IRQL_requires_max_(PASSIVE_LEVEL) _When_(AllocateDestinationString, _Must_inspect_result_) NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString( _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem))) _When_(!AllocateDestinationString, _Inout_) PANSI_STRING DestinationString, _In_ PCUNICODE_STRING SourceString, _In_ BOOLEAN AllocateDestinationString ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI LONG NTAPI RtlCompareUnicodeStrings( _In_reads_(String1Length) PCWCH String1, _In_ SIZE_T String1Length, _In_reads_(String2Length) PCWCH String2, _In_ SIZE_T String2Length, _In_ BOOLEAN CaseInSensitive ); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI LONG NTAPI RtlCompareUnicodeString( _In_ PCUNICODE_STRING String1, _In_ PCUNICODE_STRING String2, _In_ BOOLEAN CaseInSensitive ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString( _In_ PCUNICODE_STRING String1, _In_ PCUNICODE_STRING String2, _In_ BOOLEAN CaseInSensitive ); #endif #define HASH_STRING_ALGORITHM_DEFAULT (0) #define HASH_STRING_ALGORITHM_X65599 (1) #define HASH_STRING_ALGORITHM_INVALID (0xffffffff) #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlHashUnicodeString( _In_ PCUNICODE_STRING String, _In_ BOOLEAN CaseInSensitive, _In_ ULONG HashAlgorithm, _Out_ PULONG HashValue ); #endif // NTDDI_VERSION >= NTDDI_WINXP #if (NTDDI_VERSION >= NTDDI_WIN2K) _Unchanged_(DestinationString->Buffer) _Unchanged_(DestinationString->MaximumLength) _At_(DestinationString->Length, _When_(SourceString->Length > DestinationString->MaximumLength, _Post_equal_to_(DestinationString->MaximumLength)) _When_(SourceString->Length <= DestinationString->MaximumLength, _Post_equal_to_(SourceString->Length))) NTSYSAPI VOID NTAPI RtlCopyUnicodeString( _Inout_ PUNICODE_STRING DestinationString, _In_opt_ PCUNICODE_STRING SourceString ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(1) _Unchanged_(Destination->MaximumLength) _Unchanged_(Destination->Buffer) _When_(_Old_(Destination->Length) + Source->Length <= Destination->MaximumLength, _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + Source->Length)) _At_(return, _Out_range_(==, 0))) _When_(_Old_(Destination->Length) + Source->Length > Destination->MaximumLength, _Unchanged_(Destination->Length) _At_(return, _Out_range_(<, 0))) NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString ( _Inout_ PUNICODE_STRING Destination, _In_ PCUNICODE_STRING Source ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(1) _Unchanged_(Destination->MaximumLength) _Unchanged_(Destination->Buffer) _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) <= Destination->MaximumLength, _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR))) _At_(return, _Out_range_(==, 0))) _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) > Destination->MaximumLength, _Unchanged_(Destination->Length) _At_(return, _Out_range_(<, 0))) NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeToString ( _Inout_ PUNICODE_STRING Destination, _In_opt_z_ PCWSTR Source ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI WCHAR NTAPI RtlUpcaseUnicodeChar( _In_ WCHAR SourceCharacter ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI WCHAR NTAPI RtlDowncaseUnicodeChar( _In_ WCHAR SourceCharacter ); #endif _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI VOID NTAPI RtlFreeUnicodeString( _Inout_ _At_(UnicodeString->Buffer, _Frees_ptr_opt_) PUNICODE_STRING UnicodeString ); #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI VOID NTAPI RtlFreeAnsiString( _Inout_ _At_(AnsiString->Buffer, _Frees_ptr_opt_) PANSI_STRING AnsiString ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI ULONG NTAPI RtlxUnicodeStringToAnsiSize( _In_ PCUNICODE_STRING UnicodeString ); #endif // // NTSYSAPI // ULONG // NTAPI // RtlUnicodeStringToAnsiSize( // PUNICODE_STRING UnicodeString // ); // #define RtlUnicodeStringToAnsiSize(STRING) ( \ NLS_MB_CODE_PAGE_TAG ? \ RtlxUnicodeStringToAnsiSize(STRING) : \ ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \ ) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI ULONG NTAPI RtlxAnsiStringToUnicodeSize( _In_ PCANSI_STRING AnsiString ); #endif // // NTSYSAPI // ULONG // NTAPI // RtlAnsiStringToUnicodeSize( // PANSI_STRING AnsiString // ); // #define RtlAnsiStringToUnicodeSize(STRING) ( \ NLS_MB_CODE_PAGE_TAG ? \ RtlxAnsiStringToUnicodeSize(STRING) : \ ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \ ) #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlUnicodeToUTF8N( _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount) PCHAR UTF8StringDestination, _In_ ULONG UTF8StringMaxByteCount, _Out_ PULONG UTF8StringActualByteCount, _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource, _In_ ULONG UnicodeStringByteCount ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlUTF8ToUnicodeN( _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount) PWSTR UnicodeStringDestination, _In_ ULONG UnicodeStringMaxByteCount, _Out_ PULONG UnicodeStringActualByteCount, _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource, _In_ ULONG UTF8StringByteCount ); #endif #include #ifndef DEFINE_GUIDEX #define DEFINE_GUIDEX(name) EXTERN_C const CDECL GUID name #endif // !defined(DEFINE_GUIDEX) #ifndef STATICGUIDOF #define STATICGUIDOF(guid) STATIC_##guid #endif // !defined(STATICGUIDOF) #ifndef __IID_ALIGNED__ #define __IID_ALIGNED__ #ifdef __cplusplus inline int IsEqualGUIDAligned(REFGUID guid1, REFGUID guid2) { return ((*(PLONGLONG)(&guid1) == *(PLONGLONG)(&guid2)) && (*((PLONGLONG)(&guid1) + 1) == *((PLONGLONG)(&guid2) + 1))); } #else // !__cplusplus #define IsEqualGUIDAligned(guid1, guid2) \ ((*(PLONGLONG)(guid1) == *(PLONGLONG)(guid2)) && (*((PLONGLONG)(guid1) + 1) == *((PLONGLONG)(guid2) + 1))) #endif // !__cplusplus #endif // !__IID_ALIGNED__ // // Length in characters of the GUID represented as string not including the // null terminator. // #define RTL_GUID_STRING_SIZE 38 _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlStringFromGUID( _In_ REFGUID Guid, _Out_ _At_(GuidString->Buffer, __drv_allocatesMem(Mem)) PUNICODE_STRING GuidString ); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlGUIDFromString( _In_ PCUNICODE_STRING GuidString, _Out_ GUID* Guid ); #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlGenerateClass5Guid( _In_ REFGUID NamespaceGuid, _In_reads_bytes_(BufferSize) PVOID Buffer, _In_ ULONG BufferSize, _Out_ GUID* Guid ); #endif // (NTDDI_VERSION >= NTDDI_WIN8) // // Fast primitives to compare, move, and zero memory // #if defined(_DBG_MEMCPY_INLINE_) && !defined(MIDL_PASS) && !defined(_MEMCPY_INLINE_) && !defined(_CRTBLD) #define _MEMCPY_INLINE_ FORCEINLINE PVOID __cdecl memcpy_inline ( _Out_writes_bytes_all_(size) void *dst, _In_reads_bytes_(size) const void *src, _In_ size_t size ) { // // Make sure the source and destination do not overlap such that the // move destroys the destination. // if (((char *)dst > (char *)src) && ((char *)dst < ((char *)src + size))) { __debugbreak(); } return memcpy(dst, src, size); } #define memcpy memcpy_inline #endif #define RtlEqualMemory(Destination,Source,Length) (!memcmp((Destination),(Source),(Length))) #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length)) #define RtlCopyMemory(Destination,Source,Length) memcpy((Destination),(Source),(Length)) #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length)) #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length)) #if !defined(MIDL_PASS) FORCEINLINE PVOID RtlSecureZeroMemory( _Out_writes_bytes_all_(cnt) PVOID ptr, _In_ SIZE_T cnt ) { volatile char *vptr = (volatile char *)ptr; #if defined(_M_AMD64) __stosb((PUCHAR)((ULONG64)vptr), 0, cnt); #else while (cnt) { #if !defined(_M_CEE) && (defined(_M_ARM) || defined(_M_ARM64)) __iso_volatile_store8(vptr, 0); #else *vptr = 0; #endif vptr++; cnt--; } #endif // _M_AMD64 return ptr; } #endif #define RtlCopyBytes RtlCopyMemory #define RtlZeroBytes RtlZeroMemory #define RtlFillBytes RtlFillMemory #if defined(_M_AMD64) NTSYSAPI VOID NTAPI RtlCopyMemoryNonTemporal ( _Out_writes_bytes_all_(Length) VOID UNALIGNED *Destination, _In_reads_bytes_(Length) CONST VOID UNALIGNED *Source, _In_ SIZE_T Length ); #else #define RtlCopyMemoryNonTemporal RtlCopyMemory #endif #if (NTDDI_VERSION >= NTDDI_WIN2KSP3) NTSYSAPI VOID FASTCALL RtlPrefetchMemoryNonTemporal( _In_ PVOID Source, _In_ SIZE_T Length ); #endif // // Define kernel debugger print prototypes and macros. // // N.B. The following function cannot be directly imported because there are // a few places in the source tree where this function is redefined. // #if (NTDDI_VERSION >= NTDDI_WIN2K) #if (_MSC_FULL_VER >= 150030729) && !defined(IMPORT_NATIVE_DBG_BREAK) #define DbgBreakPoint __debugbreak #else __analysis_noreturn VOID NTAPI DbgBreakPoint( VOID ); #endif #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) __analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus( _In_ ULONG Status ); #endif #define DBG_STATUS_CONTROL_C 1 #define DBG_STATUS_SYSRQ 2 #define DBG_STATUS_BUGCHECK_FIRST 3 #define DBG_STATUS_BUGCHECK_SECOND 4 #define DBG_STATUS_FATAL 5 #define DBG_STATUS_DEBUG_CONTROL 6 #define DBG_STATUS_WORKER 7 #if DBG #define KdPrint(_x_) DbgPrint _x_ #define KdPrintEx(_x_) DbgPrintEx _x_ #define vKdPrintEx(_x_) vDbgPrintEx _x_ #define vKdPrintExWithPrefix(_x_) vDbgPrintExWithPrefix _x_ #define KdBreakPoint() DbgBreakPoint() #define KdBreakPointWithStatus(s) DbgBreakPointWithStatus(s) #else #define KdPrint(_x_) #define KdPrintEx(_x_) #define vKdPrintEx(_x_) #define vKdPrintExWithPrefix(_x_) #define KdBreakPoint() #define KdBreakPointWithStatus(s) #endif // DBG wudfwdm #ifndef _DBGNT_ ULONG __cdecl DbgPrint ( _In_z_ _Printf_format_string_ PCSTR Format, ... ); #if (NTDDI_VERSION >= NTDDI_WINXP) NTSYSAPI ULONG __cdecl DbgPrintEx ( _In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ _Printf_format_string_ PCSTR Format, ... ); #endif #ifdef _VA_LIST_DEFINED #if (NTDDI_VERSION >= NTDDI_WINXP) NTSYSAPI ULONG NTAPI vDbgPrintEx( _In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ PCCH Format, _In_ va_list arglist ); NTSYSAPI ULONG NTAPI vDbgPrintExWithPrefix ( _In_z_ PCCH Prefix, _In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ PCCH Format, _In_ va_list arglist ); #endif #endif // _VA_LIST_DEFINED #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG __cdecl DbgPrintReturnControlC ( _In_z_ _Printf_format_string_ PCCH Format, ... ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTSYSAPI NTSTATUS NTAPI DbgQueryDebugFilterState ( _In_ ULONG ComponentId, _In_ ULONG Level ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTSYSAPI NTSTATUS NTAPI DbgSetDebugFilterState ( _In_ ULONG ComponentId, _In_ ULONG Level, _In_ BOOLEAN State ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) typedef VOID (*PDEBUG_PRINT_CALLBACK) ( _In_ PSTRING Output, _In_ ULONG ComponentId, _In_ ULONG Level ); NTSYSAPI NTSTATUS NTAPI DbgSetDebugPrintCallback ( _In_ PDEBUG_PRINT_CALLBACK DebugPrintCallback, _In_ BOOLEAN Enable ); #endif #endif // _DBGNT_ // // Large integer arithmetic routines. // // // Large integer add - 64-bits + 64-bits -> 64-bits // #if !defined(MIDL_PASS) DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlLargeIntegerAdd ( _In_ LARGE_INTEGER Addend1, _In_ LARGE_INTEGER Addend2 ) { LARGE_INTEGER Sum; Sum.QuadPart = Addend1.QuadPart + Addend2.QuadPart; return Sum; } // // Enlarged integer multiply - 32-bits * 32-bits -> 64-bits // DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlEnlargedIntegerMultiply ( _In_ LONG Multiplicand, _In_ LONG Multiplier ) { LARGE_INTEGER Product; Product.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier; return Product; } // // Unsigned enlarged integer multiply - 32-bits * 32-bits -> 64-bits // DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlEnlargedUnsignedMultiply ( _In_ ULONG Multiplicand, _In_ ULONG Multiplier ) { LARGE_INTEGER Product; Product.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier; return Product; } // // Enlarged integer divide - 64-bits / 32-bits > 32-bits // DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline ULONG NTAPI_INLINE RtlEnlargedUnsignedDivide ( _In_ ULARGE_INTEGER Dividend, _In_ ULONG Divisor, _Out_opt_ PULONG Remainder ) { ULONG Quotient; Quotient = (ULONG)(Dividend.QuadPart / Divisor); if (ARGUMENT_PRESENT(Remainder)) { *Remainder = (ULONG)(Dividend.QuadPart % Divisor); } return Quotient; } // // Large integer negation - -(64-bits) // DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlLargeIntegerNegate ( _In_ LARGE_INTEGER Subtrahend ) { LARGE_INTEGER Difference; Difference.QuadPart = -Subtrahend.QuadPart; return Difference; } // // Large integer subtract - 64-bits - 64-bits -> 64-bits. // DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlLargeIntegerSubtract ( _In_ LARGE_INTEGER Minuend, _In_ LARGE_INTEGER Subtrahend ) { LARGE_INTEGER Difference; Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart; return Difference; } // // Extended large integer magic divide - 64-bits / 32-bits -> 64-bits // #if (defined(_AMD64_) || defined(_ARM64_)) && !defined(_M_CEE_PURE) DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlExtendedMagicDivide ( _In_ LARGE_INTEGER Dividend, _In_ LARGE_INTEGER MagicDivisor, _In_ CCHAR ShiftCount ) { LARGE_INTEGER Quotient; if (Dividend.QuadPart >= 0) { Quotient.QuadPart = UnsignedMultiplyHigh(Dividend.QuadPart, (ULONG64)MagicDivisor.QuadPart); } else { Quotient.QuadPart = UnsignedMultiplyHigh(-Dividend.QuadPart, (ULONG64)MagicDivisor.QuadPart); } Quotient.QuadPart = (ULONG64)Quotient.QuadPart >> ShiftCount; if (Dividend.QuadPart < 0) { Quotient.QuadPart = - Quotient.QuadPart; } return Quotient; } #endif // defined(_AMD64_) || defined(_ARM64_) #if defined(_X86_) || defined(_ARM_) || defined(_IA64_) #if (NTDDI_VERSION >= NTDDI_WIN2K) DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") NTSYSAPI LARGE_INTEGER NTAPI RtlExtendedMagicDivide ( _In_ LARGE_INTEGER Dividend, _In_ LARGE_INTEGER MagicDivisor, _In_ CCHAR ShiftCount ); #endif #endif // defined(_X86_) || defined(_ARM_) || defined(_IA64_) #if defined(_AMD64_) || defined(_ARM_) || defined(_ARM64_) || defined(_IA64_) // // Large Integer divide - 64-bits / 32-bits -> 64-bits // DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlExtendedLargeIntegerDivide ( _In_ LARGE_INTEGER Dividend, _In_ ULONG Divisor, _Out_opt_ PULONG Remainder ) { LARGE_INTEGER Quotient; Quotient.QuadPart = (ULONG64)Dividend.QuadPart / Divisor; if (ARGUMENT_PRESENT(Remainder)) { *Remainder = (ULONG)((ULONG64)Dividend.QuadPart % Divisor); } return Quotient; } // // Extended integer multiply - 32-bits * 64-bits -> 64-bits // DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlExtendedIntegerMultiply ( _In_ LARGE_INTEGER Multiplicand, _In_ LONG Multiplier ) { LARGE_INTEGER Product; Product.QuadPart = Multiplicand.QuadPart * Multiplier; return Product; } #else // // Large Integer divide - 64-bits / 32-bits -> 64-bits // #if (NTDDI_VERSION >= NTDDI_WIN2K) DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") NTSYSAPI LARGE_INTEGER NTAPI RtlExtendedLargeIntegerDivide ( _In_ LARGE_INTEGER Dividend, _In_ ULONG Divisor, _Out_opt_ PULONG Remainder ); #endif // // Extended integer multiply - 32-bits * 64-bits -> 64-bits // #if (NTDDI_VERSION >= NTDDI_WIN2K) DECLSPEC_DEPRECATED_DDK // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") NTSYSAPI LARGE_INTEGER NTAPI RtlExtendedIntegerMultiply ( _In_ LARGE_INTEGER Multiplicand, _In_ LONG Multiplier ); #endif #endif // defined(_AMD64_) || defined(_ARM_) || defined(_ARM64_) || defined(_IA64_) // // Large integer and - 64-bite & 64-bits -> 64-bits. // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(RtlLargeIntegerAnd) // Use native __int64 math #endif #define RtlLargeIntegerAnd(Result, Source, Mask) \ Result.QuadPart = Source.QuadPart & Mask.QuadPart // // Convert signed integer to large integer. // DECLSPEC_DEPRECATED_DDK_WINXP // Use native __int64 math __inline LARGE_INTEGER NTAPI_INLINE RtlConvertLongToLargeInteger ( _In_ LONG SignedInteger ) { LARGE_INTEGER Result; Result.QuadPart = SignedInteger; return Result; } // // Convert unsigned integer to large integer. // DECLSPEC_DEPRECATED_DDK_WINXP // Use native __int64 math __inline LARGE_INTEGER NTAPI_INLINE RtlConvertUlongToLargeInteger ( _In_ ULONG UnsignedInteger ) { LARGE_INTEGER Result; Result.QuadPart = UnsignedInteger; return Result; } // // Large integer shift routines. // DECLSPEC_DEPRECATED_DDK_WINXP // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlLargeIntegerShiftLeft ( _In_ LARGE_INTEGER LargeInteger, _In_ CCHAR ShiftCount ) { LARGE_INTEGER Result; Result.QuadPart = LargeInteger.QuadPart << ShiftCount; return Result; } DECLSPEC_DEPRECATED_DDK_WINXP // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlLargeIntegerShiftRight ( _In_ LARGE_INTEGER LargeInteger, _In_ CCHAR ShiftCount ) { LARGE_INTEGER Result; Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount; return Result; } DECLSPEC_DEPRECATED_DDK_WINXP // Use native __int64 math __drv_preferredFunction("compiler support for 64 bit", "Obsolete") __inline LARGE_INTEGER NTAPI_INLINE RtlLargeIntegerArithmeticShift ( _In_ LARGE_INTEGER LargeInteger, _In_ CCHAR ShiftCount ) { LARGE_INTEGER Result; Result.QuadPart = LargeInteger.QuadPart >> ShiftCount; return Result; } // // Large integer comparison routines. // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(RtlLargeIntegerGreaterThan) // Use native __int64 math #pragma deprecated(RtlLargeIntegerGreaterThanOrEqualTo) // Use native __int64 math #pragma deprecated(RtlLargeIntegerEqualTo) // Use native __int64 math #pragma deprecated(RtlLargeIntegerNotEqualTo) // Use native __int64 math #pragma deprecated(RtlLargeIntegerLessThan) // Use native __int64 math #pragma deprecated(RtlLargeIntegerLessThanOrEqualTo) // Use native __int64 math #pragma deprecated(RtlLargeIntegerGreaterThanZero) // Use native __int64 math #pragma deprecated(RtlLargeIntegerGreaterOrEqualToZero) // Use native __int64 math #pragma deprecated(RtlLargeIntegerEqualToZero) // Use native __int64 math #pragma deprecated(RtlLargeIntegerNotEqualToZero) // Use native __int64 math #pragma deprecated(RtlLargeIntegerLessThanZero) // Use native __int64 math #pragma deprecated(RtlLargeIntegerLessOrEqualToZero) // Use native __int64 math #endif #define RtlLargeIntegerGreaterThan(X,Y) ( \ (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \ ((X).HighPart > (Y).HighPart) \ ) #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) ( \ (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \ ((X).HighPart > (Y).HighPart) \ ) #define RtlLargeIntegerEqualTo(X,Y) ( \ !(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \ ) #define RtlLargeIntegerNotEqualTo(X,Y) ( \ (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \ ) #define RtlLargeIntegerLessThan(X,Y) ( \ (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \ ((X).HighPart < (Y).HighPart) \ ) #define RtlLargeIntegerLessThanOrEqualTo(X,Y) ( \ (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \ ((X).HighPart < (Y).HighPart) \ ) #define RtlLargeIntegerGreaterThanZero(X) ( \ (((X).HighPart == 0) && ((X).LowPart > 0)) || \ ((X).HighPart > 0 ) \ ) #define RtlLargeIntegerGreaterOrEqualToZero(X) ( \ (X).HighPart >= 0 \ ) #define RtlLargeIntegerEqualToZero(X) ( \ !((X).LowPart | (X).HighPart) \ ) #define RtlLargeIntegerNotEqualToZero(X) ( \ ((X).LowPart | (X).HighPart) \ ) #define RtlLargeIntegerLessThanZero(X) ( \ ((X).HighPart < 0) \ ) #define RtlLargeIntegerLessOrEqualToZero(X) ( \ ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) \ ) #endif // !defined(MIDL_PASS) // // Time conversion routines // typedef struct _TIME_FIELDS { CSHORT Year; // range [1601...] CSHORT Month; // range [1..12] CSHORT Day; // range [1..31] CSHORT Hour; // range [0..23] CSHORT Minute; // range [0..59] CSHORT Second; // range [0..59] CSHORT Milliseconds;// range [0..999] CSHORT Weekday; // range [0..6] == [Sunday..Saturday] } TIME_FIELDS; typedef TIME_FIELDS *PTIME_FIELDS; #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI VOID NTAPI RtlTimeToTimeFields ( _In_ PLARGE_INTEGER Time, _Out_ PTIME_FIELDS TimeFields ); #endif // // A time field record (Weekday ignored) -> 64 bit Time value // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(return != 0) NTSYSAPI BOOLEAN NTAPI RtlTimeFieldsToTime ( _In_ PTIME_FIELDS TimeFields, _Out_ PLARGE_INTEGER Time ); #endif // // The following macros store and retrieve USHORTS and ULONGS from potentially // unaligned addresses, avoiding alignment faults. they should probably be // rewritten in assembler // #define SHORT_SIZE (sizeof(USHORT)) #define SHORT_MASK (SHORT_SIZE - 1) #define LONG_SIZE (sizeof(LONG)) #define LONGLONG_SIZE (sizeof(LONGLONG)) #define LONG_MASK (LONG_SIZE - 1) #define LONGLONG_MASK (LONGLONG_SIZE - 1) #define LOWBYTE_MASK 0x00FF #define FIRSTBYTE(VALUE) ((VALUE) & LOWBYTE_MASK) #define SECONDBYTE(VALUE) (((VALUE) >> 8) & LOWBYTE_MASK) #define THIRDBYTE(VALUE) (((VALUE) >> 16) & LOWBYTE_MASK) #define FOURTHBYTE(VALUE) (((VALUE) >> 24) & LOWBYTE_MASK) // // if MIPS Big Endian, order of bytes is reversed. // #define SHORT_LEAST_SIGNIFICANT_BIT 0 #define SHORT_MOST_SIGNIFICANT_BIT 1 #define LONG_LEAST_SIGNIFICANT_BIT 0 #define LONG_3RD_MOST_SIGNIFICANT_BIT 1 #define LONG_2ND_MOST_SIGNIFICANT_BIT 2 #define LONG_MOST_SIGNIFICANT_BIT 3 //++ // // VOID // RtlStoreUshort ( // PUSHORT ADDRESS // USHORT VALUE // ) // // Routine Description: // // This macro stores a USHORT value in at a particular address, avoiding // alignment faults. // // Arguments: // // ADDRESS - where to store USHORT value // VALUE - USHORT to store // // Return Value: // // none. // //-- #if defined(_AMD64_) #define RtlStoreUshort(ADDRESS,VALUE) \ *(USHORT UNALIGNED *)(ADDRESS) = (VALUE) #else #define RtlStoreUshort(ADDRESS,VALUE) \ if ((ULONG_PTR)(ADDRESS) & SHORT_MASK) { \ ((PUCHAR) (ADDRESS))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(VALUE)); \ ((PUCHAR) (ADDRESS))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(VALUE)); \ } \ else { \ *((PUSHORT) (ADDRESS)) = (USHORT) VALUE; \ } #endif //++ // // VOID // RtlStoreUlong ( // PULONG ADDRESS // ULONG VALUE // ) // // Routine Description: // // This macro stores a ULONG value in at a particular address, avoiding // alignment faults. // // Arguments: // // ADDRESS - where to store ULONG value // VALUE - ULONG to store // // Return Value: // // none. // // Note: // Depending on the machine, we might want to call storeushort in the // unaligned case. // //-- #if defined(_AMD64_) #define RtlStoreUlong(ADDRESS,VALUE) \ *(ULONG UNALIGNED *)(ADDRESS) = (VALUE) #else #define RtlStoreUlong(ADDRESS,VALUE) \ if ((ULONG_PTR)(ADDRESS) & LONG_MASK) { \ ((PUCHAR) (ADDRESS))[LONG_LEAST_SIGNIFICANT_BIT ] = (UCHAR)(FIRSTBYTE(VALUE)); \ ((PUCHAR) (ADDRESS))[LONG_3RD_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(VALUE)); \ ((PUCHAR) (ADDRESS))[LONG_2ND_MOST_SIGNIFICANT_BIT ] = (UCHAR)(THIRDBYTE(VALUE)); \ ((PUCHAR) (ADDRESS))[LONG_MOST_SIGNIFICANT_BIT ] = (UCHAR)(FOURTHBYTE(VALUE)); \ } \ else { \ *((PULONG) (ADDRESS)) = (ULONG) (VALUE); \ } #endif //++ // // VOID // RtlStoreUlonglong ( // PULONGLONG ADDRESS // ULONG VALUE // ) // // Routine Description: // // This macro stores a ULONGLONG value in at a particular address, avoiding // alignment faults. // // Arguments: // // ADDRESS - where to store ULONGLONG value // VALUE - ULONGLONG to store // // Return Value: // // none. // //-- #if defined(_AMD64_) #define RtlStoreUlonglong(ADDRESS,VALUE) \ *(ULONGLONG UNALIGNED *)(ADDRESS) = (VALUE) #else #define RtlStoreUlonglong(ADDRESS,VALUE) \ if ((ULONG_PTR)(ADDRESS) & LONGLONG_MASK) { \ RtlStoreUlong((ULONG_PTR)(ADDRESS), \ (ULONGLONG)(VALUE) & 0xFFFFFFFF); \ RtlStoreUlong((ULONG_PTR)(ADDRESS)+sizeof(ULONG), \ (ULONGLONG)(VALUE) >> 32); \ } else { \ *((PULONGLONG)(ADDRESS)) = (ULONGLONG)(VALUE); \ } #endif //++ // // VOID // RtlStoreUlongPtr ( // PULONG_PTR ADDRESS // ULONG_PTR VALUE // ) // // Routine Description: // // This macro stores a ULONG_PTR value in at a particular address, avoiding // alignment faults. // // Arguments: // // ADDRESS - where to store ULONG_PTR value // VALUE - ULONG_PTR to store // // Return Value: // // none. // //-- #ifdef _WIN64 #define RtlStoreUlongPtr(ADDRESS,VALUE) \ RtlStoreUlonglong(ADDRESS,VALUE) #else #define RtlStoreUlongPtr(ADDRESS,VALUE) \ RtlStoreUlong(ADDRESS,VALUE) #endif //++ // // VOID // RtlRetrieveUshort ( // PUSHORT DESTINATION_ADDRESS // PUSHORT SOURCE_ADDRESS // ) // // Routine Description: // // This macro retrieves a USHORT value from the SOURCE address, avoiding // alignment faults. The DESTINATION address is assumed to be aligned. // // Arguments: // // DESTINATION_ADDRESS - where to store USHORT value // SOURCE_ADDRESS - where to retrieve USHORT value from // // Return Value: // // none. // //-- #if defined(_AMD64_) #define RtlRetrieveUshort(DEST_ADDRESS,SRC_ADDRESS) \ *(USHORT UNALIGNED *)(DEST_ADDRESS) = *(PUSHORT)(SRC_ADDRESS) #else #define RtlRetrieveUshort(DEST_ADDRESS,SRC_ADDRESS) \ if ((ULONG_PTR)SRC_ADDRESS & SHORT_MASK) { \ ((PUCHAR) (DEST_ADDRESS))[0] = ((PUCHAR) (SRC_ADDRESS))[0]; \ ((PUCHAR) (DEST_ADDRESS))[1] = ((PUCHAR) (SRC_ADDRESS))[1]; \ } \ else { \ *((PUSHORT) DEST_ADDRESS) = *((PUSHORT) SRC_ADDRESS); \ } \ #endif //++ // // VOID // RtlRetrieveUlong ( // PULONG DESTINATION_ADDRESS // PULONG SOURCE_ADDRESS // ) // // Routine Description: // // This macro retrieves a ULONG value from the SOURCE address, avoiding // alignment faults. The DESTINATION address is assumed to be aligned. // // Arguments: // // DESTINATION_ADDRESS - where to store ULONG value // SOURCE_ADDRESS - where to retrieve ULONG value from // // Return Value: // // none. // // Note: // Depending on the machine, we might want to call retrieveushort in the // unaligned case. // //-- #if defined(_AMD64_) #define RtlRetrieveUlong(DEST_ADDRESS,SRC_ADDRESS) \ *(ULONG UNALIGNED *)(DEST_ADDRESS) = *(PULONG)(SRC_ADDRESS) #else #define RtlRetrieveUlong(DEST_ADDRESS,SRC_ADDRESS) \ if ((ULONG_PTR)SRC_ADDRESS & LONG_MASK) { \ ((PUCHAR) (DEST_ADDRESS))[0] = ((PUCHAR) (SRC_ADDRESS))[0]; \ ((PUCHAR) (DEST_ADDRESS))[1] = ((PUCHAR) (SRC_ADDRESS))[1]; \ ((PUCHAR) (DEST_ADDRESS))[2] = ((PUCHAR) (SRC_ADDRESS))[2]; \ ((PUCHAR) (DEST_ADDRESS))[3] = ((PUCHAR) (SRC_ADDRESS))[3]; \ } \ else { \ *((PULONG) DEST_ADDRESS) = *((PULONG) SRC_ADDRESS); \ } #endif // // BitMap routines. The following structure, routines, and macros are // for manipulating bitmaps. The user is responsible for allocating a bitmap // structure (which is really a header) and a buffer (which must be longword // aligned and multiple longwords in size). // typedef struct _RTL_BITMAP { ULONG SizeOfBitMap; // Number of bits in bit map PULONG Buffer; // Pointer to the bit map itself } RTL_BITMAP; typedef RTL_BITMAP *PRTL_BITMAP; // // The following routine initializes a new bitmap. It does not alter the // data currently in the bitmap. This routine must be called before // any other bitmap routine/macro. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI VOID NTAPI RtlInitializeBitMap ( _Out_ PRTL_BITMAP BitMapHeader, _In_opt_ __drv_aliasesMem PULONG BitMapBuffer, _In_opt_ ULONG SizeOfBitMap ); #endif // // The following three routines clear, set, and test the state of a // single bit in a bitmap. // #if (NTDDI_VERSION >= NTDDI_WINXP) NTSYSAPI VOID NTAPI RtlClearBit ( _In_ PRTL_BITMAP BitMapHeader, _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTSYSAPI VOID NTAPI RtlSetBit ( _In_ PRTL_BITMAP BitMapHeader, _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlTestBit ( _In_ PRTL_BITMAP BitMapHeader, _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber ); #endif // // The following two routines either clear or set all of the bits // in a bitmap. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI VOID NTAPI RtlClearAllBits ( _In_ PRTL_BITMAP BitMapHeader ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI VOID NTAPI RtlSetAllBits ( _In_ PRTL_BITMAP BitMapHeader ); #endif // // The following two routines locate a contiguous region of either // clear or set bits within the bitmap. The region will be at least // as large as the number specified, and the search of the bitmap will // begin at the specified hint index (which is a bit index within the // bitmap, zero based). The return value is the bit index of the located // region (zero based) or -1 (i.e., 0xffffffff) if such a region cannot // be located // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(return != -1) _Must_inspect_result_ NTSYSAPI ULONG NTAPI RtlFindClearBits ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(return != -1) _Must_inspect_result_ NTSYSAPI ULONG NTAPI RtlFindSetBits ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); #endif // // The following two routines locate a contiguous region of either // clear or set bits within the bitmap and either set or clear the bits // within the located region. The region will be as large as the number // specified, and the search for the region will begin at the specified // hint index (which is a bit index within the bitmap, zero based). The // return value is the bit index of the located region (zero based) or // -1 (i.e., 0xffffffff) if such a region cannot be located. If a region // cannot be located then the setting/clearing of the bitmap is not performed. // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(return != -1) NTSYSAPI ULONG NTAPI RtlFindClearBitsAndSet ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(return != -1) NTSYSAPI ULONG NTAPI RtlFindSetBitsAndClear ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); #endif // // The following two routines clear or set bits within a specified region // of the bitmap. The starting index is zero based. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI VOID NTAPI RtlClearBits ( _In_ PRTL_BITMAP BitMapHeader, _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex, _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI VOID NTAPI RtlSetBits ( _In_ PRTL_BITMAP BitMapHeader, _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex, _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet ); #endif // // The following routine locates a set of contiguous regions of clear // bits within the bitmap. The caller specifies whether to return the // longest runs or just the first found lcoated. The following structure is // used to denote a contiguous run of bits. The two routines return an array // of this structure, one for each run located. // typedef struct _RTL_BITMAP_RUN { ULONG StartingIndex; ULONG NumberOfBits; } RTL_BITMAP_RUN; typedef RTL_BITMAP_RUN *PRTL_BITMAP_RUN; #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG NTAPI RtlFindClearRuns ( _In_ PRTL_BITMAP BitMapHeader, _Out_writes_to_(SizeOfRunArray, return) PRTL_BITMAP_RUN RunArray, _In_range_(>, 0) ULONG SizeOfRunArray, _In_ BOOLEAN LocateLongestRuns ); #endif // // The following routine locates the longest contiguous region of // clear bits within the bitmap. The returned starting index value // denotes the first contiguous region located satisfying our requirements // The return value is the length (in bits) of the longest region found. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG NTAPI RtlFindLongestRunClear ( _In_ PRTL_BITMAP BitMapHeader, _Out_ PULONG StartingIndex ); #endif // // The following routine locates the first contiguous region of // clear bits within the bitmap. The returned starting index value // denotes the first contiguous region located satisfying our requirements // The return value is the length (in bits) of the region found. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG NTAPI RtlFindFirstRunClear ( _In_ PRTL_BITMAP BitMapHeader, _Out_ PULONG StartingIndex ); #endif // // The following macro returns the value of the bit stored within the // bitmap at the specified location. If the bit is set a value of 1 is // returned otherwise a value of 0 is returned. // // ULONG // RtlCheckBit ( // PRTL_BITMAP BitMapHeader, // ULONG BitPosition // ); // // // To implement CheckBit the macro retrieves the longword containing the // bit in question, shifts the longword to get the bit in question into the // low order bit position and masks out all other bits. // #if defined(_M_AMD64) && !defined(MIDL_PASS) _Must_inspect_result_ FORCEINLINE BOOLEAN RtlCheckBit ( _In_ PRTL_BITMAP BitMapHeader, _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitPosition ) { return BitTest64((LONG64 const *)BitMapHeader->Buffer, (LONG64)BitPosition); } #else #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP) / 32]) >> ((BP) % 32)) & 0x1) #endif // // The following two procedures return to the caller the total number of // clear or set bits within the specified bitmap. // #if (NTDDI_VERSION >= NTDDI_WIN8) NTSYSAPI ULONG NTAPI RtlNumberOfClearBitsInRange ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG Length ); NTSYSAPI ULONG NTAPI RtlNumberOfSetBitsInRange ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG Length ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG NTAPI RtlNumberOfClearBits ( _In_ PRTL_BITMAP BitMapHeader ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG NTAPI RtlNumberOfSetBits ( _In_ PRTL_BITMAP BitMapHeader ); #endif // // The following two procedures return to the caller a boolean value // indicating if the specified range of bits are all clear or set. // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlAreBitsClear ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG Length ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlAreBitsSet ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG Length ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG NTAPI RtlFindNextForwardRunClear ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG FromIndex, _Out_ PULONG StartingRunIndex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG NTAPI RtlFindLastBackwardRunClear ( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG FromIndex, _Out_ PULONG StartingRunIndex ); #endif // // The following two procedures return to the caller a value indicating // the position within a ULONGLONG of the most or least significant non-zero // bit. A value of zero results in a return value of -1. // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(return != -1) _Must_inspect_result_ NTSYSAPI CCHAR NTAPI RtlFindLeastSignificantBit ( _In_ ULONGLONG Set ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Success_(return != -1) _Must_inspect_result_ NTSYSAPI CCHAR NTAPI RtlFindMostSignificantBit ( _In_ ULONGLONG Set ); #endif // // The following procedure finds the number of set bits within a ULONG_PTR // value. // #if (NTDDI_VERSION >= NTDDI_VISTA) NTSYSAPI ULONG NTAPI RtlNumberOfSetBitsUlongPtr ( _In_ ULONG_PTR Target ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) NTSYSAPI VOID NTAPI RtlCopyBitMap ( _In_ PRTL_BITMAP Source, _In_ PRTL_BITMAP Destination, _In_range_(0, Destination->SizeOfBitMap - 1) ULONG TargetBit ); NTSYSAPI VOID NTAPI RtlExtractBitMap ( _In_ PRTL_BITMAP Source, _In_ PRTL_BITMAP Destination, _In_range_(0, Source->SizeOfBitMap - 1) ULONG TargetBit, _In_range_(0, Source->SizeOfBitMap) ULONG NumberOfBits ); #endif // // BOOLEAN // RtlEqualLuid( // PLUID L1, // PLUID L2 // ); #define RtlEqualLuid(L1, L2) (((L1)->LowPart == (L2)->LowPart) && \ ((L1)->HighPart == (L2)->HighPart)) // // BOOLEAN // RtlIsZeroLuid( // PLUID L1 // ); // #define RtlIsZeroLuid(L1) ((BOOLEAN) (((L1)->LowPart | (L1)->HighPart) == 0)) // // SecurityDescriptor RTL routine definitions // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlCreateSecurityDescriptor ( _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ ULONG Revision ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlValidSecurityDescriptor ( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTSYSAPI ULONG NTAPI RtlLengthSecurityDescriptor ( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlValidRelativeSecurityDescriptor ( _In_reads_bytes_(SecurityDescriptorLength) PSECURITY_DESCRIPTOR SecurityDescriptorInput, _In_ ULONG SecurityDescriptorLength, _In_ SECURITY_INFORMATION RequiredInformation ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlSetDaclSecurityDescriptor ( _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ BOOLEAN DaclPresent, _In_opt_ PACL Dacl, _In_ BOOLEAN DaclDefaulted ); #endif #define SEF_DACL_AUTO_INHERIT 0x01 #define SEF_SACL_AUTO_INHERIT 0x02 #define SEF_DEFAULT_DESCRIPTOR_FOR_OBJECT 0x04 #define SEF_AVOID_PRIVILEGE_CHECK 0x08 #define SEF_AVOID_OWNER_CHECK 0x10 #define SEF_DEFAULT_OWNER_FROM_PARENT 0x20 #define SEF_DEFAULT_GROUP_FROM_PARENT 0x40 #define SEF_MACL_NO_WRITE_UP 0x100 #define SEF_MACL_NO_READ_UP 0x200 #define SEF_MACL_NO_EXECUTE_UP 0x400 #define SEF_AI_USE_EXTRA_PARAMS 0x800 #define SEF_AVOID_OWNER_RESTRICTION 0x1000 #define SEF_MACL_VALID_FLAGS (SEF_MACL_NO_WRITE_UP | \ SEF_MACL_NO_READ_UP | \ SEF_MACL_NO_EXECUTE_UP) // // Byte swap routines. These are used to convert from little-endian to // big-endian and vice-versa. // #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037)) || ((defined(_M_AMD64) || defined(_M_IA64)) && (_MSC_FULL_VER > 13009175)) || defined(_M_ARM) || defined(_M_ARM64) #ifdef __cplusplus extern "C" { #endif _Check_return_ unsigned short __cdecl _byteswap_ushort(_In_ unsigned short); _Check_return_ unsigned long __cdecl _byteswap_ulong (_In_ unsigned long); _Check_return_ unsigned __int64 __cdecl _byteswap_uint64(_In_ unsigned __int64); #ifdef __cplusplus } #endif #pragma intrinsic(_byteswap_ushort) #pragma intrinsic(_byteswap_ulong) #pragma intrinsic(_byteswap_uint64) #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x)) #define RtlUlongByteSwap(_x) _byteswap_ulong((_x)) #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x)) #else #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI USHORT FASTCALL RtlUshortByteSwap( _In_ USHORT Source ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONG FASTCALL RtlUlongByteSwap( _In_ ULONG Source ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONGLONG FASTCALL RtlUlonglongByteSwap( _In_ ULONGLONG Source ); #endif #endif typedef struct _OSVERSIONINFOA { ULONG dwOSVersionInfoSize; ULONG dwMajorVersion; ULONG dwMinorVersion; ULONG dwBuildNumber; ULONG dwPlatformId; CHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA; typedef struct _OSVERSIONINFOW { ULONG dwOSVersionInfoSize; ULONG dwMajorVersion; ULONG dwMinorVersion; ULONG dwBuildNumber; ULONG dwPlatformId; WCHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage } OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW; #ifdef UNICODE typedef OSVERSIONINFOW OSVERSIONINFO; typedef POSVERSIONINFOW POSVERSIONINFO; typedef LPOSVERSIONINFOW LPOSVERSIONINFO; #else typedef OSVERSIONINFOA OSVERSIONINFO; typedef POSVERSIONINFOA POSVERSIONINFO; typedef LPOSVERSIONINFOA LPOSVERSIONINFO; #endif // UNICODE typedef struct _OSVERSIONINFOEXA { ULONG dwOSVersionInfoSize; ULONG dwMajorVersion; ULONG dwMinorVersion; ULONG dwBuildNumber; ULONG dwPlatformId; CHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage USHORT wServicePackMajor; USHORT wServicePackMinor; USHORT wSuiteMask; UCHAR wProductType; UCHAR wReserved; } OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA; typedef struct _OSVERSIONINFOEXW { ULONG dwOSVersionInfoSize; ULONG dwMajorVersion; ULONG dwMinorVersion; ULONG dwBuildNumber; ULONG dwPlatformId; WCHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage USHORT wServicePackMajor; USHORT wServicePackMinor; USHORT wSuiteMask; UCHAR wProductType; UCHAR wReserved; } OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW, RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW; #ifdef UNICODE typedef OSVERSIONINFOEXW OSVERSIONINFOEX; typedef POSVERSIONINFOEXW POSVERSIONINFOEX; typedef LPOSVERSIONINFOEXW LPOSVERSIONINFOEX; #else typedef OSVERSIONINFOEXA OSVERSIONINFOEX; typedef POSVERSIONINFOEXA POSVERSIONINFOEX; typedef LPOSVERSIONINFOEXA LPOSVERSIONINFOEX; #endif // UNICODE // // RtlVerifyVersionInfo() conditions // #define VER_EQUAL 1 #define VER_GREATER 2 #define VER_GREATER_EQUAL 3 #define VER_LESS 4 #define VER_LESS_EQUAL 5 #define VER_AND 6 #define VER_OR 7 #define VER_CONDITION_MASK 7 #define VER_NUM_BITS_PER_CONDITION_MASK 3 // // RtlVerifyVersionInfo() type mask bits // #define VER_MINORVERSION 0x0000001 #define VER_MAJORVERSION 0x0000002 #define VER_BUILDNUMBER 0x0000004 #define VER_PLATFORMID 0x0000008 #define VER_SERVICEPACKMINOR 0x0000010 #define VER_SERVICEPACKMAJOR 0x0000020 #define VER_SUITENAME 0x0000040 #define VER_PRODUCT_TYPE 0x0000080 // // RtlVerifyVersionInfo() os product type values // #define VER_NT_WORKSTATION 0x0000001 #define VER_NT_DOMAIN_CONTROLLER 0x0000002 #define VER_NT_SERVER 0x0000003 // // dwPlatformId defines: // #define VER_PLATFORM_WIN32s 0 #define VER_PLATFORM_WIN32_WINDOWS 1 #define VER_PLATFORM_WIN32_NT 2 #pragma region Desktop Family or OneCore Family #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) // // // VerifyVersionInfo() macro to set the condition mask // // For documentation sakes here's the old version of the macro that got // changed to call an API // #define VER_SET_CONDITION(_m_,_t_,_c_) _m_=(_m_|(_c_<<(1<<_t_))) // #define VER_SET_CONDITION(_m_,_t_,_c_) \ ((_m_)=VerSetConditionMask((_m_),(_t_),(_c_))) #if !defined(_WINBASE_) && !defined(MIDL_PASS) #if (NTDDI_VERSION >= NTDDI_WIN2K) NTSYSAPI ULONGLONG NTAPI VerSetConditionMask( _In_ ULONGLONG ConditionMask, _In_ ULONG TypeMask, _In_ UCHAR Condition ); #endif #endif // !defined(_WINBASE_) && !defined(MIDL_PASS) #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */ #pragma endregion // // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlGetVersion( _Out_ _At_(lpVersionInformation->dwOSVersionInfoSize, _Pre_ _Valid_) _When_(lpVersionInformation->dwOSVersionInfoSize == sizeof(RTL_OSVERSIONINFOEXW), _At_((PRTL_OSVERSIONINFOEXW)lpVersionInformation, _Out_)) PRTL_OSVERSIONINFOW lpVersionInformation ); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlVerifyVersionInfo( _In_ PRTL_OSVERSIONINFOEXW VersionInfo, _In_ ULONG TypeMask, _In_ ULONGLONG ConditionMask ); #endif // typedef BOOLEAN (*PFN_RTL_IS_NTDDI_VERSION_AVAILABLE)( _In_ ULONG Version ); typedef BOOLEAN (*PFN_RTL_IS_SERVICE_PACK_VERSION_INSTALLED)( _In_ ULONG Version ); BOOLEAN RtlIsNtDdiVersionAvailable ( _In_ ULONG Version ); BOOLEAN RtlIsServicePackVersionInstalled ( _In_ ULONG Version ); // // Interlocked bit manipulation interfaces // #define RtlInterlockedSetBits(Flags, Flag) \ InterlockedOr((PLONG)(Flags), Flag) #define RtlInterlockedAndBits(Flags, Flag) \ InterlockedAnd((PLONG)(Flags), Flag) #define RtlInterlockedClearBits(Flags, Flag) \ RtlInterlockedAndBits(Flags, ~(Flag)) #define RtlInterlockedXorBits(Flags, Flag) \ InterlockedXor(Flags, Flag) #define RtlInterlockedSetBitsDiscardReturn(Flags, Flag) \ (VOID) RtlInterlockedSetBits(Flags, Flag) #define RtlInterlockedAndBitsDiscardReturn(Flags, Flag) \ (VOID) RtlInterlockedAndBits(Flags, Flag) #define RtlInterlockedClearBitsDiscardReturn(Flags, Flag) \ RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag)) #if (NTDDI_VERSION >= NTDDI_WINXP) #include #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSYSAPI NTSTATUS NTAPI RtlIoEncodeMemIoResource ( _In_ PIO_RESOURCE_DESCRIPTOR Descriptor, _In_ UCHAR Type, _In_ ULONGLONG Length, _In_ ULONGLONG Alignment, _In_ ULONGLONG MinimumAddress, _In_ ULONGLONG MaximumAddress ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSYSAPI NTSTATUS NTAPI RtlCmEncodeMemIoResource ( _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, _In_ UCHAR Type, _In_ ULONGLONG Length, _In_ ULONGLONG Start ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSYSAPI ULONGLONG NTAPI RtlIoDecodeMemIoResource ( _In_ PIO_RESOURCE_DESCRIPTOR Descriptor, _Out_opt_ PULONGLONG Alignment, _Out_opt_ PULONGLONG MinimumAddress, _Out_opt_ PULONGLONG MaximumAddress ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSYSAPI ULONGLONG NTAPI RtlCmDecodeMemIoResource ( _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, _Out_opt_ PULONGLONG Start ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSYSAPI NTSTATUS NTAPI RtlFindClosestEncodableLength ( _In_ ULONGLONG SourceLength, _Out_ PULONGLONG TargetLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) && !defined(MIDL_PASS) NTSYSAPI NTSTATUS NTAPI RtlIsUntrustedObject ( _In_opt_ HANDLE Handle, _In_opt_ PVOID Object, _Out_ PBOOLEAN UntrustedObject ); #endif // (NTDDI_VERSION >= NTDDI_WIN8) && !defined(MIDL_PASS) #if (NTDDI_VERSION >= NTDDI_WIN8) NTSYSAPI ULONG NTAPI RtlQueryValidationRunlevel ( _In_opt_ PCUNICODE_STRING ComponentName ); #endif #if !defined(VRL_GLOBAL_LEVEL) #if (NTDDI_VERSION >= NTDDI_WIN8) // // VRL_GLOBAL_LEVEL is a shortcut to querying the global validation runlevel. // This should only be used when the component-specific level is unavailable or // cannot be queried for whatever reason. // // The following define can only be used by kernel-mode callers. It is redefined // suitably for user-mode callers if nturtl is included after. // #define VRL_GLOBAL_LEVEL (SharedUserData->GlobalValidationRunlevel) #endif // (NTDDI_VERSION >= NTDDI_WIN8) #endif // !defined(VRL_GLOBAL_LEVEL) #if !defined(IS_VALIDATION_ENABLED) #if (NTDDI_VERSION >= NTDDI_WIN8) // // Validation runlevel helper macro: checks if a particular level L enables the // validation class C. // // Returns a non-zero scalar if class C is enabled, and zero otherwise. // #define IS_VALIDATION_ENABLED(C,L) ((L) & (C)) // // Validation classes are broken into: // 8 predefined validation classes, spanning bits 0 to 7 of the level value // 24 custom-defined validation classes, spanning bits 8 to 31 // #define VRL_PREDEFINED_CLASS_BEGIN (1 << 0) #define VRL_CUSTOM_CLASS_BEGIN (1 << 8) // // The following are predefined validation classes. // #define VRL_CLASS_CONSISTENCY (VRL_PREDEFINED_CLASS_BEGIN << 0) // // Do not ignore kernel breaks when kernel debugging is disabled (debug builds only) // #define VRL_ENABLE_KERNEL_BREAKS (1 << 31) #endif // (NTDDI_VERSION >= NTDDI_WIN8) #endif // !defined(IS_VALIDATION_ENABLED) #if (NTDDI_VERSION >= NTDDI_WIN8) // // RtlCheckTokenMembership flags. // #define CTMF_INCLUDE_APPCONTAINER 0x00000001UL #define CTMF_VALID_FLAGS (CTMF_INCLUDE_APPCONTAINER) #endif // (NTDDI_VERSION >= NTDDI_WIN8) #if (NTDDI_VERSION >= NTDDI_WIN8) #pragma region Desktop Family or OneCore Family #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) // // Crc32 and Crc64 routines that use standardized algorithms // NTSYSAPI ULONG NTAPI RtlCrc32( _In_reads_bytes_(Size) const void *Buffer, _In_ size_t Size, _In_ ULONG InitialCrc ); NTSYSAPI ULONGLONG NTAPI RtlCrc64( _In_reads_bytes_(Size) const void *Buffer, _In_ size_t Size, _In_ ULONGLONG InitialCrc ); #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */ #pragma endregion #endif // (NTDDI_VERSION >= NTDDI_WIN8) #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) // // API to detect what type of OS Deployment this is. Current valid values // are listed below // // // Valid OsDeployment values that can be returned // typedef enum _OS_DEPLOYEMENT_STATE_VALUES { OS_DEPLOYMENT_STANDARD = 1, OS_DEPLOYMENT_COMPACT } OS_DEPLOYEMENT_STATE_VALUES; NTSYSAPI OS_DEPLOYEMENT_STATE_VALUES NTAPI RtlOsDeploymentState( _In_ ULONG Flags /* No flags currently defined, passed 0 */ ); #endif // NTDDI_VERSION >= NTDDI_WINTHRESHOLD #include #pragma region Desktop Family or OneCore Family #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) #if !(defined(_CONTRACT_GEN) && (_APISET_RTLSUPPORT_VER <= 0x0100) && defined(_X86_)) #if (NTDDI_VERSION >= NTDDI_WIN2K) _Check_return_ NTSYSAPI SIZE_T NTAPI RtlCompareMemory( _In_ const VOID * Source1, _In_ const VOID * Source2, _In_ SIZE_T Length ); #endif #endif // !(defined(_CONTRACT_GEN) && (_APISET_RTLSUPPORT_VER <= 0x0100) && defined(_X86_)) #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */ #pragma endregion #ifndef _NTTMAPI_ #define _NTTMAPI_ #ifdef __cplusplus extern "C" { #endif #include #if _MSC_VER >= 1200 #pragma warning(push) #pragma warning(disable:4820) // padding added after data member #endif // // Types for Nt level TM calls // // begin_access // // KTM Tm object rights // #define TRANSACTIONMANAGER_QUERY_INFORMATION ( 0x0001 ) #define TRANSACTIONMANAGER_SET_INFORMATION ( 0x0002 ) #define TRANSACTIONMANAGER_RECOVER ( 0x0004 ) #define TRANSACTIONMANAGER_RENAME ( 0x0008 ) #define TRANSACTIONMANAGER_CREATE_RM ( 0x0010 ) // The following right is intended for DTC's use only; it will be // deprecated, and no one else should take a dependency on it. #define TRANSACTIONMANAGER_BIND_TRANSACTION ( 0x0020 ) // // Generic mappings for transaction manager rights. // #define TRANSACTIONMANAGER_GENERIC_READ (STANDARD_RIGHTS_READ |\ TRANSACTIONMANAGER_QUERY_INFORMATION) #define TRANSACTIONMANAGER_GENERIC_WRITE (STANDARD_RIGHTS_WRITE |\ TRANSACTIONMANAGER_SET_INFORMATION |\ TRANSACTIONMANAGER_RECOVER |\ TRANSACTIONMANAGER_RENAME |\ TRANSACTIONMANAGER_CREATE_RM) #define TRANSACTIONMANAGER_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE) #define TRANSACTIONMANAGER_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED |\ TRANSACTIONMANAGER_GENERIC_READ |\ TRANSACTIONMANAGER_GENERIC_WRITE |\ TRANSACTIONMANAGER_GENERIC_EXECUTE |\ TRANSACTIONMANAGER_BIND_TRANSACTION) // // KTM transaction object rights. // #define TRANSACTION_QUERY_INFORMATION ( 0x0001 ) #define TRANSACTION_SET_INFORMATION ( 0x0002 ) #define TRANSACTION_ENLIST ( 0x0004 ) #define TRANSACTION_COMMIT ( 0x0008 ) #define TRANSACTION_ROLLBACK ( 0x0010 ) #define TRANSACTION_PROPAGATE ( 0x0020 ) #define TRANSACTION_RIGHT_RESERVED1 ( 0x0040 ) // // Generic mappings for transaction rights. // Resource managers, when enlisting, should generally use the macro // TRANSACTION_RESOURCE_MANAGER_RIGHTS when opening a transaction. // It's the same as generic read and write except that it does not allow // a commit decision to be made. // #define TRANSACTION_GENERIC_READ (STANDARD_RIGHTS_READ |\ TRANSACTION_QUERY_INFORMATION |\ SYNCHRONIZE) #define TRANSACTION_GENERIC_WRITE (STANDARD_RIGHTS_WRITE |\ TRANSACTION_SET_INFORMATION |\ TRANSACTION_COMMIT |\ TRANSACTION_ENLIST |\ TRANSACTION_ROLLBACK |\ TRANSACTION_PROPAGATE |\ SYNCHRONIZE) #define TRANSACTION_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE |\ TRANSACTION_COMMIT |\ TRANSACTION_ROLLBACK |\ SYNCHRONIZE) #define TRANSACTION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED |\ TRANSACTION_GENERIC_READ |\ TRANSACTION_GENERIC_WRITE |\ TRANSACTION_GENERIC_EXECUTE) #define TRANSACTION_RESOURCE_MANAGER_RIGHTS (TRANSACTION_GENERIC_READ |\ STANDARD_RIGHTS_WRITE |\ TRANSACTION_SET_INFORMATION |\ TRANSACTION_ENLIST |\ TRANSACTION_ROLLBACK |\ TRANSACTION_PROPAGATE |\ SYNCHRONIZE) // // KTM resource manager object rights. // #define RESOURCEMANAGER_QUERY_INFORMATION ( 0x0001 ) #define RESOURCEMANAGER_SET_INFORMATION ( 0x0002 ) #define RESOURCEMANAGER_RECOVER ( 0x0004 ) #define RESOURCEMANAGER_ENLIST ( 0x0008 ) #define RESOURCEMANAGER_GET_NOTIFICATION ( 0x0010 ) #define RESOURCEMANAGER_REGISTER_PROTOCOL ( 0x0020 ) #define RESOURCEMANAGER_COMPLETE_PROPAGATION ( 0x0040 ) // // Generic mappings for resource manager rights. // #define RESOURCEMANAGER_GENERIC_READ (STANDARD_RIGHTS_READ |\ RESOURCEMANAGER_QUERY_INFORMATION |\ SYNCHRONIZE) #define RESOURCEMANAGER_GENERIC_WRITE (STANDARD_RIGHTS_WRITE |\ RESOURCEMANAGER_SET_INFORMATION |\ RESOURCEMANAGER_RECOVER |\ RESOURCEMANAGER_ENLIST |\ RESOURCEMANAGER_GET_NOTIFICATION |\ RESOURCEMANAGER_REGISTER_PROTOCOL |\ RESOURCEMANAGER_COMPLETE_PROPAGATION |\ SYNCHRONIZE) #define RESOURCEMANAGER_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE |\ RESOURCEMANAGER_RECOVER |\ RESOURCEMANAGER_ENLIST |\ RESOURCEMANAGER_GET_NOTIFICATION |\ RESOURCEMANAGER_COMPLETE_PROPAGATION |\ SYNCHRONIZE) #define RESOURCEMANAGER_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED |\ RESOURCEMANAGER_GENERIC_READ |\ RESOURCEMANAGER_GENERIC_WRITE |\ RESOURCEMANAGER_GENERIC_EXECUTE) // // KTM enlistment object rights. // #define ENLISTMENT_QUERY_INFORMATION ( 0x0001 ) #define ENLISTMENT_SET_INFORMATION ( 0x0002 ) #define ENLISTMENT_RECOVER ( 0x0004 ) #define ENLISTMENT_SUBORDINATE_RIGHTS ( 0x0008 ) #define ENLISTMENT_SUPERIOR_RIGHTS ( 0x0010 ) // // Generic mappings for enlistment rights. // #define ENLISTMENT_GENERIC_READ (STANDARD_RIGHTS_READ |\ ENLISTMENT_QUERY_INFORMATION) #define ENLISTMENT_GENERIC_WRITE (STANDARD_RIGHTS_WRITE |\ ENLISTMENT_SET_INFORMATION |\ ENLISTMENT_RECOVER |\ ENLISTMENT_SUBORDINATE_RIGHTS |\ ENLISTMENT_SUPERIOR_RIGHTS) #define ENLISTMENT_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE |\ ENLISTMENT_RECOVER |\ ENLISTMENT_SUBORDINATE_RIGHTS |\ ENLISTMENT_SUPERIOR_RIGHTS) #define ENLISTMENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED |\ ENLISTMENT_GENERIC_READ |\ ENLISTMENT_GENERIC_WRITE |\ ENLISTMENT_GENERIC_EXECUTE) // end_access // // Transaction outcomes. // // TODO: warning, must match values in KTRANSACTION_OUTCOME duplicated def // in tm.h. // typedef enum _TRANSACTION_OUTCOME { TransactionOutcomeUndetermined = 1, TransactionOutcomeCommitted, TransactionOutcomeAborted, } TRANSACTION_OUTCOME; typedef enum _TRANSACTION_STATE { TransactionStateNormal = 1, TransactionStateIndoubt, TransactionStateCommittedNotify, } TRANSACTION_STATE; typedef struct _TRANSACTION_BASIC_INFORMATION { GUID TransactionId; ULONG State; ULONG Outcome; } TRANSACTION_BASIC_INFORMATION, *PTRANSACTION_BASIC_INFORMATION; typedef struct _TRANSACTIONMANAGER_BASIC_INFORMATION { GUID TmIdentity; LARGE_INTEGER VirtualClock; } TRANSACTIONMANAGER_BASIC_INFORMATION, *PTRANSACTIONMANAGER_BASIC_INFORMATION; typedef struct _TRANSACTIONMANAGER_LOG_INFORMATION { GUID LogIdentity; } TRANSACTIONMANAGER_LOG_INFORMATION, *PTRANSACTIONMANAGER_LOG_INFORMATION; typedef struct _TRANSACTIONMANAGER_LOGPATH_INFORMATION { ULONG LogPathLength; _Field_size_(LogPathLength) WCHAR LogPath[1]; // Variable size // Data[1]; // Variable size data not declared } TRANSACTIONMANAGER_LOGPATH_INFORMATION, *PTRANSACTIONMANAGER_LOGPATH_INFORMATION; typedef struct _TRANSACTIONMANAGER_RECOVERY_INFORMATION { ULONGLONG LastRecoveredLsn; } TRANSACTIONMANAGER_RECOVERY_INFORMATION, *PTRANSACTIONMANAGER_RECOVERY_INFORMATION; typedef struct _TRANSACTION_PROPERTIES_INFORMATION { ULONG IsolationLevel; ULONG IsolationFlags; LARGE_INTEGER Timeout; ULONG Outcome; ULONG DescriptionLength; WCHAR Description[1]; // Variable size // Data[1]; // Variable size data not declared } TRANSACTION_PROPERTIES_INFORMATION, *PTRANSACTION_PROPERTIES_INFORMATION; // The following info-class is intended for DTC's use only; it will be // deprecated, and no one else should take a dependency on it. typedef struct _TRANSACTION_BIND_INFORMATION { HANDLE TmHandle; } TRANSACTION_BIND_INFORMATION, *PTRANSACTION_BIND_INFORMATION; typedef struct _TRANSACTION_ENLISTMENT_PAIR { GUID EnlistmentId; GUID ResourceManagerId; } TRANSACTION_ENLISTMENT_PAIR, *PTRANSACTION_ENLISTMENT_PAIR; typedef struct _TRANSACTION_ENLISTMENTS_INFORMATION { ULONG NumberOfEnlistments; TRANSACTION_ENLISTMENT_PAIR EnlistmentPair[1]; // Variable size } TRANSACTION_ENLISTMENTS_INFORMATION, *PTRANSACTION_ENLISTMENTS_INFORMATION; typedef struct _TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION { TRANSACTION_ENLISTMENT_PAIR SuperiorEnlistmentPair; } TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION, *PTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION; typedef struct _RESOURCEMANAGER_BASIC_INFORMATION { GUID ResourceManagerId; ULONG DescriptionLength; WCHAR Description[1]; // Variable size } RESOURCEMANAGER_BASIC_INFORMATION, *PRESOURCEMANAGER_BASIC_INFORMATION; typedef struct _RESOURCEMANAGER_COMPLETION_INFORMATION { HANDLE IoCompletionPortHandle; ULONG_PTR CompletionKey; } RESOURCEMANAGER_COMPLETION_INFORMATION, *PRESOURCEMANAGER_COMPLETION_INFORMATION; typedef enum _TRANSACTION_INFORMATION_CLASS { TransactionBasicInformation, TransactionPropertiesInformation, TransactionEnlistmentInformation, TransactionSuperiorEnlistmentInformation } TRANSACTION_INFORMATION_CLASS; typedef enum _TRANSACTIONMANAGER_INFORMATION_CLASS { TransactionManagerBasicInformation, TransactionManagerLogInformation, TransactionManagerLogPathInformation, TransactionManagerRecoveryInformation = 4 } TRANSACTIONMANAGER_INFORMATION_CLASS; typedef enum _RESOURCEMANAGER_INFORMATION_CLASS { ResourceManagerBasicInformation, ResourceManagerCompletionInformation, } RESOURCEMANAGER_INFORMATION_CLASS; typedef struct _ENLISTMENT_BASIC_INFORMATION { GUID EnlistmentId; GUID TransactionId; GUID ResourceManagerId; } ENLISTMENT_BASIC_INFORMATION, *PENLISTMENT_BASIC_INFORMATION; typedef struct _ENLISTMENT_CRM_INFORMATION { GUID CrmTransactionManagerId; GUID CrmResourceManagerId; GUID CrmEnlistmentId; } ENLISTMENT_CRM_INFORMATION, *PENLISTMENT_CRM_INFORMATION; typedef enum _ENLISTMENT_INFORMATION_CLASS { EnlistmentBasicInformation, EnlistmentRecoveryInformation, EnlistmentCrmInformation } ENLISTMENT_INFORMATION_CLASS; typedef struct _TRANSACTION_LIST_ENTRY { UOW UOW; } TRANSACTION_LIST_ENTRY, *PTRANSACTION_LIST_ENTRY; typedef struct _TRANSACTION_LIST_INFORMATION { ULONG NumberOfTransactions; TRANSACTION_LIST_ENTRY TransactionInformation[1]; // Var size } TRANSACTION_LIST_INFORMATION, *PTRANSACTION_LIST_INFORMATION; // // Types of objects known to the kernel transaction manager. // typedef enum _KTMOBJECT_TYPE { KTMOBJECT_TRANSACTION, KTMOBJECT_TRANSACTION_MANAGER, KTMOBJECT_RESOURCE_MANAGER, KTMOBJECT_ENLISTMENT, KTMOBJECT_INVALID } KTMOBJECT_TYPE, *PKTMOBJECT_TYPE; // // KTMOBJECT_CURSOR // // Used by NtEnumerateTransactionObject to enumerate a transaction // object namespace (e.g. enlistments in a resource manager). // typedef struct _KTMOBJECT_CURSOR { // // The last GUID enumerated; zero if beginning enumeration. // GUID LastQuery; // // A count of GUIDs filled in by this last enumeration. // ULONG ObjectIdCount; // // ObjectIdCount GUIDs from the namespace specified. // GUID ObjectIds[1]; } KTMOBJECT_CURSOR, *PKTMOBJECT_CURSOR; // // Nt level transaction manager API calls // #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtCreateTransactionManager ( _Out_ PHANDLE TmHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PUNICODE_STRING LogFileName, _In_opt_ ULONG CreateOptions, _In_opt_ ULONG CommitStrength ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtOpenTransactionManager ( _Out_ PHANDLE TmHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PUNICODE_STRING LogFileName, _In_opt_ LPGUID TmIdentity, _In_opt_ ULONG OpenOptions ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRenameTransactionManager ( _In_ PUNICODE_STRING LogFileName, _In_ LPGUID ExistingTransactionManagerGuid ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRollforwardTransactionManager ( _In_ HANDLE TransactionManagerHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRecoverTransactionManager ( _In_ HANDLE TransactionManagerHandle ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationTransactionManager ( _In_ HANDLE TransactionManagerHandle, _In_ TRANSACTIONMANAGER_INFORMATION_CLASS TransactionManagerInformationClass, _Out_writes_bytes_(TransactionManagerInformationLength) PVOID TransactionManagerInformation, _In_ ULONG TransactionManagerInformationLength, _Out_ PULONG ReturnLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationTransactionManager ( _In_opt_ HANDLE TmHandle, _In_ TRANSACTIONMANAGER_INFORMATION_CLASS TransactionManagerInformationClass, _In_reads_bytes_(TransactionManagerInformationLength) PVOID TransactionManagerInformation, _In_ ULONG TransactionManagerInformationLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtEnumerateTransactionObject ( _In_opt_ HANDLE RootObjectHandle, _In_ KTMOBJECT_TYPE QueryType, _Inout_updates_bytes_(ObjectCursorLength) PKTMOBJECT_CURSOR ObjectCursor, _In_ ULONG ObjectCursorLength, _Out_ PULONG ReturnLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA typedef NTSTATUS (NTAPI * PFN_NT_CREATE_TRANSACTION)( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ LPGUID Uow, _In_opt_ HANDLE TmHandle, _In_opt_ ULONG CreateOptions, _In_opt_ ULONG IsolationLevel, _In_opt_ ULONG IsolationFlags, _In_opt_ PLARGE_INTEGER Timeout, _In_opt_ PUNICODE_STRING Description ); #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtCreateTransaction ( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ LPGUID Uow, _In_opt_ HANDLE TmHandle, _In_opt_ ULONG CreateOptions, _In_opt_ ULONG IsolationLevel, _In_opt_ ULONG IsolationFlags, _In_opt_ PLARGE_INTEGER Timeout, _In_opt_ PUNICODE_STRING Description ); #endif // NTDDI_VERSION >= NTDDI_VISTA typedef NTSTATUS (NTAPI *PFN_NT_OPEN_TRANSACTION)( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ LPGUID Uow, _In_opt_ HANDLE TmHandle ); #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtOpenTransaction ( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ LPGUID Uow, _In_opt_ HANDLE TmHandle ); #endif // NTDDI_VERSION >= NTDDI_VISTA typedef NTSTATUS (NTAPI * PFN_NT_QUERY_INFORMATION_TRANSACTION)( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _Out_writes_bytes_(TransactionInformationLength) PVOID TransactionInformation, _In_ ULONG TransactionInformationLength, _Out_opt_ PULONG ReturnLength ); #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationTransaction ( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _Out_writes_bytes_(TransactionInformationLength) PVOID TransactionInformation, _In_ ULONG TransactionInformationLength, _Out_opt_ PULONG ReturnLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA typedef NTSTATUS (NTAPI * PFN_NT_SET_INFORMATION_TRANSACTION)( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _In_ PVOID TransactionInformation, _In_ ULONG TransactionInformationLength ); #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationTransaction ( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _In_reads_bytes_(TransactionInformationLength) PVOID TransactionInformation, _In_ ULONG TransactionInformationLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA typedef NTSTATUS (NTAPI * PFN_NT_COMMIT_TRANSACTION)( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtCommitTransaction ( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); #endif // NTDDI_VERSION >= NTDDI_VISTA typedef NTSTATUS (NTAPI * PFN_NT_ROLLBACK_TRANSACTION)( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRollbackTransaction ( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtCreateEnlistment ( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE ResourceManagerHandle, _In_ HANDLE TransactionHandle, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG CreateOptions, _In_ NOTIFICATION_MASK NotificationMask, _In_opt_ PVOID EnlistmentKey ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtOpenEnlistment ( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE ResourceManagerHandle, _In_ LPGUID EnlistmentGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationEnlistment ( _In_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS EnlistmentInformationClass, _Out_writes_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformation, _In_ ULONG EnlistmentInformationLength, _Out_ PULONG ReturnLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationEnlistment ( _In_opt_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS EnlistmentInformationClass, _In_reads_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformation, _In_ ULONG EnlistmentInformationLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRecoverEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PVOID EnlistmentKey ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtPrePrepareEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtPrepareEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtCommitEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRollbackEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtPrePrepareComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtPrepareComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtCommitComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtReadOnlyEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRollbackComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtSinglePhaseReject ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtCreateResourceManager ( _Out_ PHANDLE ResourceManagerHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE TmHandle, _In_ LPGUID RmGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG CreateOptions, _In_opt_ PUNICODE_STRING Description ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtOpenResourceManager ( _Out_ PHANDLE ResourceManagerHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE TmHandle, _In_opt_ LPGUID ResourceManagerGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRecoverResourceManager ( _In_ HANDLE ResourceManagerHandle ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtGetNotificationResourceManager ( _In_ HANDLE ResourceManagerHandle, _Out_ PTRANSACTION_NOTIFICATION TransactionNotification, _In_ ULONG NotificationLength, _In_opt_ PLARGE_INTEGER Timeout, _Out_opt_ PULONG ReturnLength, _In_ ULONG Asynchronous, _In_opt_ ULONG_PTR AsynchronousContext ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationResourceManager ( _In_ HANDLE ResourceManagerHandle, _In_ RESOURCEMANAGER_INFORMATION_CLASS ResourceManagerInformationClass, _Out_writes_bytes_(ResourceManagerInformationLength) PVOID ResourceManagerInformation, _In_ ULONG ResourceManagerInformationLength, _Out_opt_ PULONG ReturnLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationResourceManager ( _In_ HANDLE ResourceManagerHandle, _In_ RESOURCEMANAGER_INFORMATION_CLASS ResourceManagerInformationClass, _In_reads_bytes_(ResourceManagerInformationLength) PVOID ResourceManagerInformation, _In_ ULONG ResourceManagerInformationLength ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRegisterProtocolAddressInformation( _In_ HANDLE ResourceManager, _In_ PCRM_PROTOCOL_ID ProtocolId, _In_ ULONG ProtocolInformationSize, _In_ PVOID ProtocolInformation, _In_opt_ ULONG CreateOptions ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtPropagationComplete( _In_ HANDLE ResourceManagerHandle, _In_ ULONG RequestCookie, _In_ ULONG BufferLength, _In_ PVOID Buffer ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtPropagationFailed( _In_ HANDLE ResourceManagerHandle, _In_ ULONG RequestCookie, _In_ NTSTATUS PropStatus ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if _MSC_VER >= 1200 #pragma warning(pop) #endif #ifdef __cplusplus } #endif #endif // _NTTMAPI_ // // Define alignment macros to align structure sizes and pointers up and down. // #undef ALIGN_DOWN_BY #undef ALIGN_UP_BY #undef ALIGN_DOWN_POINTER_BY #undef ALIGN_UP_POINTER_BY #undef ALIGN_DOWN #undef ALIGN_UP #undef ALIGN_DOWN_POINTER #undef ALIGN_UP_POINTER #define ALIGN_DOWN_BY(length, alignment) \ ((ULONG_PTR)(length) & ~(alignment - 1)) #define ALIGN_UP_BY(length, alignment) \ (ALIGN_DOWN_BY(((ULONG_PTR)(length) + alignment - 1), alignment)) #define ALIGN_DOWN_POINTER_BY(address, alignment) \ ((PVOID)((ULONG_PTR)(address) & ~((ULONG_PTR)alignment - 1))) #define ALIGN_UP_POINTER_BY(address, alignment) \ (ALIGN_DOWN_POINTER_BY(((ULONG_PTR)(address) + alignment - 1), alignment)) #define ALIGN_DOWN(length, type) \ ALIGN_DOWN_BY(length, sizeof(type)) #define ALIGN_UP(length, type) \ ALIGN_UP_BY(length, sizeof(type)) #define ALIGN_DOWN_POINTER(address, type) \ ALIGN_DOWN_POINTER_BY(address, sizeof(type)) #define ALIGN_UP_POINTER(address, type) \ ALIGN_UP_POINTER_BY(address, sizeof(type)) // // Calculate the byte offset of a field in a structure of type type. // #ifndef FIELD_OFFSET #define FIELD_OFFSET(type, field) ((ULONG)&(((type *)0)->field)) #endif #ifndef FIELD_SIZE #define FIELD_SIZE(type, field) (sizeof(((type *)0)->field)) #endif #if defined (_WIN64) #define BitScanReverseSizeT BitScanReverse64 #define BitScanForwardSizeT BitScanForward64 #else #define BitScanReverseSizeT BitScanReverse #define BitScanForwardSizeT BitScanForward #endif #define POOL_TAGGING 1 #if DBG #define IF_DEBUG if (TRUE) #else #define IF_DEBUG if (FALSE) #endif #if DEVL extern ULONG NtGlobalFlag; #define IF_NTOS_DEBUG(FlagName) \ if (NtGlobalFlag & (FLG_ ## FlagName)) #else #define IF_NTOS_DEBUG(FlagName) if(FALSE) #endif // // Define General Lookaside and supporting types here // typedef _Enum_is_bitflag_ enum _POOL_TYPE POOL_TYPE; typedef _IRQL_requires_same_ _Function_class_(ALLOCATE_FUNCTION) PVOID ALLOCATE_FUNCTION ( _In_ POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes, _In_ ULONG Tag ); typedef ALLOCATE_FUNCTION *PALLOCATE_FUNCTION; typedef _IRQL_requires_same_ _Function_class_(FREE_FUNCTION) VOID FREE_FUNCTION ( _In_ __drv_freesMem(Mem) PVOID Buffer ); typedef FREE_FUNCTION *PFREE_FUNCTION; typedef struct _LOOKASIDE_LIST_EX *PLOOKASIDE_LIST_EX; typedef _IRQL_requires_same_ _Function_class_(ALLOCATE_FUNCTION_EX) PVOID ALLOCATE_FUNCTION_EX ( _In_ POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes, _In_ ULONG Tag, _Inout_ PLOOKASIDE_LIST_EX Lookaside ); typedef ALLOCATE_FUNCTION_EX *PALLOCATE_FUNCTION_EX; typedef _IRQL_requires_same_ _Function_class_(FREE_FUNCTION_EX) VOID FREE_FUNCTION_EX ( _In_ __drv_freesMem(Mem) PVOID Buffer, _Inout_ PLOOKASIDE_LIST_EX Lookaside ); typedef FREE_FUNCTION_EX *PFREE_FUNCTION_EX; #if !defined(_WIN64) && (defined(_NTDDK_) || defined(_NTIFS_) || defined(_NDIS_)) #define LOOKASIDE_ALIGN #else #define LOOKASIDE_ALIGN DECLSPEC_CACHEALIGN #endif // // The goal here is to end up with two structure types that are identical except // for the fact that one (GENERAL_LOOKASIDE) is cache aligned, and the other // (GENERAL_LOOKASIDE_POOL) is merely naturally aligned. // // An anonymous structure element would do the trick except that C++ can't handle // such complex syntax, so we're stuck with this macro technique. // #define GENERAL_LOOKASIDE_LAYOUT \ union { \ SLIST_HEADER ListHead; \ SINGLE_LIST_ENTRY SingleListHead; \ } DUMMYUNIONNAME; \ USHORT Depth; \ USHORT MaximumDepth; \ ULONG TotalAllocates; \ union { \ ULONG AllocateMisses; \ ULONG AllocateHits; \ } DUMMYUNIONNAME2; \ \ ULONG TotalFrees; \ union { \ ULONG FreeMisses; \ ULONG FreeHits; \ } DUMMYUNIONNAME3; \ \ POOL_TYPE Type; \ ULONG Tag; \ ULONG Size; \ union { \ PALLOCATE_FUNCTION_EX AllocateEx; \ PALLOCATE_FUNCTION Allocate; \ } DUMMYUNIONNAME4; \ \ union { \ PFREE_FUNCTION_EX FreeEx; \ PFREE_FUNCTION Free; \ } DUMMYUNIONNAME5; \ \ LIST_ENTRY ListEntry; \ ULONG LastTotalAllocates; \ union { \ ULONG LastAllocateMisses; \ ULONG LastAllocateHits; \ } DUMMYUNIONNAME6; \ ULONG Future[2]; // // GENERAL_LOOKASIDE is a cache aligned type, typically shared between // multiple processors // #if _MSC_VER >= 1200 #pragma warning(push) #pragma warning(disable:4324) // structure was padded due to __declspec(align()) #endif typedef struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE { GENERAL_LOOKASIDE_LAYOUT } GENERAL_LOOKASIDE; typedef GENERAL_LOOKASIDE *PGENERAL_LOOKASIDE; #if _MSC_VER >= 1200 #pragma warning(pop) #endif // // GENERAL_LOOKASIDE_POOL is the same layout as GENERAL_LOOKASIDE but is // not cacheblock aligned, for use in cases where access is limited to a // single processor // typedef struct _GENERAL_LOOKASIDE_POOL { GENERAL_LOOKASIDE_LAYOUT } GENERAL_LOOKASIDE_POOL, *PGENERAL_LOOKASIDE_POOL; // // The above two structures should have identical layouts. A few spot-checks // just to make sure. // #define LOOKASIDE_CHECK(f) \ C_ASSERT(FIELD_OFFSET(GENERAL_LOOKASIDE,f)==FIELD_OFFSET(GENERAL_LOOKASIDE_POOL,f)) LOOKASIDE_CHECK(TotalFrees); LOOKASIDE_CHECK(Tag); LOOKASIDE_CHECK(Future); // // Kernel definitions that need to be here for forward reference purposes // // // Processor modes. // typedef CCHAR KPROCESSOR_MODE; typedef enum _MODE { KernelMode, UserMode, MaximumMode } MODE; typedef _Function_class_(KSYNCHRONIZE_ROUTINE) _IRQL_requires_(HIGH_LEVEL) // HIGH_LEVEL is best approximation of DIRQL _IRQL_requires_same_ BOOLEAN KSYNCHRONIZE_ROUTINE ( _In_opt_ PVOID SynchronizeContext ); typedef KSYNCHRONIZE_ROUTINE *PKSYNCHRONIZE_ROUTINE; typedef struct _KAPC { UCHAR Type; UCHAR SpareByte0; UCHAR Size; UCHAR SpareByte1; ULONG SpareLong0; struct _KTHREAD *Thread; LIST_ENTRY ApcListEntry; PVOID Reserved[3]; PVOID NormalContext; PVOID SystemArgument1; PVOID SystemArgument2; CCHAR ApcStateIndex; KPROCESSOR_MODE ApcMode; BOOLEAN Inserted; } KAPC, *PKAPC, *PRKAPC; #define KAPC_OFFSET_TO_SPARE_BYTE0 FIELD_OFFSET(KAPC, SpareByte0) #define KAPC_OFFSET_TO_SPARE_BYTE1 FIELD_OFFSET(KAPC, SpareByte1) #define KAPC_OFFSET_TO_SPARE_LONG FIELD_OFFSET(KAPC, SpareLong0) #define KAPC_OFFSET_TO_SYSTEMARGUMENT1 FIELD_OFFSET(KAPC, SystemArgument1) #define KAPC_OFFSET_TO_SYSTEMARGUMENT2 FIELD_OFFSET(KAPC, SystemArgument2) #define KAPC_OFFSET_TO_APCSTATEINDEX FIELD_OFFSET(KAPC, ApcStateIndex) #define KAPC_ACTUAL_LENGTH (FIELD_OFFSET(KAPC, Inserted) + sizeof(BOOLEAN)) // // DPC routine // struct _KDPC; _Function_class_(KDEFERRED_ROUTINE) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) _IRQL_requires_(DISPATCH_LEVEL) _IRQL_requires_same_ typedef VOID KDEFERRED_ROUTINE ( _In_ struct _KDPC *Dpc, _In_opt_ PVOID DeferredContext, _In_opt_ PVOID SystemArgument1, _In_opt_ PVOID SystemArgument2 ); typedef KDEFERRED_ROUTINE *PKDEFERRED_ROUTINE; // // Define DPC importance. // // LowImportance - Queue DPC at end of target DPC queue. // MediumImportance - Queue DPC at end of target DPC queue. // MediumHighImportance - Queue DPC at end of target DPC queue. // HighImportance - Queue DPC at front of target DPC DPC queue. // // If there is currently a DPC active on the target processor, or a DPC // interrupt has already been requested on the target processor when a // DPC is queued, then no further action is necessary. The DPC will be // executed on the target processor when its queue entry is processed. // // If there is not a DPC active on the target processor and a DPC interrupt // has not been requested on the target processor, then the exact treatment // of the DPC is dependent on whether the host system is a UP system or an // MP system. // // UP system. // // If the DPC is not of low importance, the current DPC queue depth // is greater than the maximum target depth, or current DPC request rate is // less the minimum target rate, then a DPC interrupt is requested on the // host processor and the DPC will be processed when the interrupt occurs. // Otherwise, no DPC interupt is requested and the DPC execution will be // delayed until the DPC queue depth is greater that the target depth or the // minimum DPC rate is less than the target rate. // // MP system. // // If the DPC is being queued to another processor and the depth of the DPC // queue on the target processor is greater than the maximum target depth or // the DPC is of medium high or high importance, then a DPC interrupt is // requested on the target processor and the DPC will be processed when the // Interrupt occurs. Otherwise, the DPC execution will be delayed on the target // processor until the DPC queue depth on the target processor is greater that // the maximum target depth or the minimum DPC rate on the target processor is // less than the target mimimum rate. // // If the DPC is being queued to the current processor and the DPC is not of // low importance, the current DPC queue depth is greater than the maximum // target depth, or the minimum DPC rate is less than the minimum target rate, // then a DPC interrupt is request on the current processor and the DPV will // be processed when the interrupt occurs. Otherwise, no DPC interupt is // requested and the DPC execution will be delayed until the DPC queue depth // is greater that the target depth or the minimum DPC rate is less than the // target rate. // typedef enum _KDPC_IMPORTANCE { LowImportance, MediumImportance, HighImportance, MediumHighImportance } KDPC_IMPORTANCE; // // Define DPC type indicies. // #define DPC_NORMAL 0 #define DPC_THREADED 1 // // Deferred Procedure Call (DPC) object // #define ASSERT_DPC(Object) \ NT_ASSERT(((Object)->Type == 0) || \ ((Object)->Type == DpcObject) || \ ((Object)->Type == ThreadedDpcObject)) typedef struct _KDPC { union { ULONG TargetInfoAsUlong; struct { UCHAR Type; UCHAR Importance; volatile USHORT Number; } DUMMYSTRUCTNAME; } DUMMYUNIONNAME; SINGLE_LIST_ENTRY DpcListEntry; KAFFINITY ProcessorHistory; PKDEFERRED_ROUTINE DeferredRoutine; PVOID DeferredContext; PVOID SystemArgument1; PVOID SystemArgument2; __volatile PVOID DpcData; } KDPC, *PKDPC, *PRKDPC; #if defined(_X86_) // // i386 Specific portions of Mm component. // // Define the page size for the Intel 386 as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeroes in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #elif defined(_AMD64_) // // AMD64 Specific portions of Mm component. // // Define the page size for the AMD64 as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeroes in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #elif defined(_ARM64_) // // ARM Specific portions of Mm component. // // Define the page size for the ARM64 as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeroes in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #elif defined(_ARM_) // // ARM Specific portions of Mm component. // // Define the page size for the ARM as 4096 (0x1000). // #define PAGE_SIZE 0x1000 // // Define the number of trailing zeroes in a page aligned virtual address. // This is used as the shift count when shifting virtual addresses to // virtual page numbers. // #define PAGE_SHIFT 12L #endif // // I/O system definitions. // // Define a Memory Descriptor List (MDL) // // An MDL describes pages in a virtual buffer in terms of physical pages. The // pages associated with the buffer are described in an array that is allocated // just after the MDL header structure itself. // // One simply calculates the base of the array by adding one to the base // MDL pointer: // // Pages = (PPFN_NUMBER) (Mdl + 1); // // Notice that while in the context of the subject thread, the base virtual // address of a buffer mapped by an MDL may be referenced using the following: // // Mdl->StartVa | Mdl->ByteOffset // // // Use _Inexpressible_ until the definition can be fixed (PAGE_SIZE may not be // defined at this point). // typedef _Struct_size_bytes_(_Inexpressible_(sizeof(struct _MDL) + // 747934 (ByteOffset + ByteCount + PAGE_SIZE-1) / PAGE_SIZE * sizeof(PFN_NUMBER))) struct _MDL { struct _MDL *Next; CSHORT Size; CSHORT MdlFlags; struct _EPROCESS *Process; PVOID MappedSystemVa; /* see creators for field size annotations. */ PVOID StartVa; /* see creators for validity; could be address 0. */ ULONG ByteCount; ULONG ByteOffset; } MDL, *PMDL; typedef _Readable_bytes_(_Inexpressible_(polymorphism)) MDL *PMDLX; #define MDL_MAPPED_TO_SYSTEM_VA 0x0001 #define MDL_PAGES_LOCKED 0x0002 #define MDL_SOURCE_IS_NONPAGED_POOL 0x0004 #define MDL_ALLOCATED_FIXED_SIZE 0x0008 #define MDL_PARTIAL 0x0010 #define MDL_PARTIAL_HAS_BEEN_MAPPED 0x0020 #define MDL_IO_PAGE_READ 0x0040 #define MDL_WRITE_OPERATION 0x0080 #define MDL_LOCKED_PAGE_TABLES 0x0100 #define MDL_PARENT_MAPPED_SYSTEM_VA MDL_LOCKED_PAGE_TABLES #define MDL_FREE_EXTRA_PTES 0x0200 #define MDL_DESCRIBES_AWE 0x0400 #define MDL_IO_SPACE 0x0800 #define MDL_NETWORK_HEADER 0x1000 #define MDL_MAPPING_CAN_FAIL 0x2000 #define MDL_PAGE_CONTENTS_INVARIANT 0x4000 #define MDL_ALLOCATED_MUST_SUCCEED MDL_PAGE_CONTENTS_INVARIANT #define MDL_INTERNAL 0x8000 #define MDL_MAPPING_FLAGS (MDL_MAPPED_TO_SYSTEM_VA | \ MDL_PAGES_LOCKED | \ MDL_SOURCE_IS_NONPAGED_POOL | \ MDL_PARTIAL_HAS_BEEN_MAPPED | \ MDL_PARENT_MAPPED_SYSTEM_VA | \ MDL_SYSTEM_VA | \ MDL_IO_SPACE ) // // switch to PREFast or DBG when appropriate // #if defined(_PREFAST_) _IRQL_requires_max_(APC_LEVEL) void __PREfastPagedCode(void); void __PREfastPagedCodeLocked(void); #define PAGED_CODE() __PREfastPagedCode(); #define PAGED_CODE_LOCKED() __PREfastPagedCodeLocked(); #elif DBG #if (NTDDI_VERSION >= NTDDI_VISTA) #define PAGED_ASSERT( exp ) NT_ASSERT( exp ) #else #define PAGED_ASSERT( exp ) ASSERT( exp ) #endif #define PAGED_CODE() PAGED_ASSERT(KeGetCurrentIrql() <= APC_LEVEL); #define PAGED_CODE_LOCKED() NOP_FUNCTION; #else #define PAGED_CODE() NOP_FUNCTION; #define PAGED_CODE_LOCKED() NOP_FUNCTION; #endif #define NTKERNELAPI DECLSPEC_IMPORT #if defined(_X86_) && !defined(_NTHAL_) #define _DECL_HAL_KE_IMPORT DECLSPEC_IMPORT #elif defined(_X86_) #define _DECL_HAL_KE_IMPORT #else #define _DECL_HAL_KE_IMPORT NTKERNELAPI #endif #if !defined(_NTHALDLL_) && !defined(_BLDR_) #define NTHALAPI DECLSPEC_IMPORT #else #define NTHALAPI #endif // // Common dispatcher object header // // N.B. The size field contains the number of dwords in the structure. // #if defined(_X86_) #define KENCODED_TIMER_PROCESSOR 1 // Timer processor is encoded in header #endif #define TIMER_TOLERABLE_DELAY_BITS 6 #define TIMER_EXPIRED_INDEX_BITS 6 #define TIMER_PROCESSOR_INDEX_BITS 5 typedef struct _DISPATCHER_HEADER { union { union { volatile LONG Lock; LONG LockNV; } DUMMYUNIONNAME; struct { // Events, Semaphores, Gates, etc. UCHAR Type; // All (accessible via KOBJECT_TYPE) UCHAR Signalling; UCHAR Size; UCHAR Reserved1; } DUMMYSTRUCTNAME; struct { // Timer UCHAR TimerType; union { UCHAR TimerControlFlags; struct { UCHAR Absolute : 1; UCHAR Wake : 1; UCHAR EncodedTolerableDelay : TIMER_TOLERABLE_DELAY_BITS; } DUMMYSTRUCTNAME; }; UCHAR Hand; union { UCHAR TimerMiscFlags; struct { #if !defined(KENCODED_TIMER_PROCESSOR) UCHAR Index : TIMER_EXPIRED_INDEX_BITS; #else UCHAR Index : 1; UCHAR Processor : TIMER_PROCESSOR_INDEX_BITS; #endif UCHAR Inserted : 1; volatile UCHAR Expired : 1; } DUMMYSTRUCTNAME; } DUMMYUNIONNAME; } DUMMYSTRUCTNAME2; struct { // Timer2 UCHAR Timer2Type; union { UCHAR Timer2Flags; struct { UCHAR Timer2Inserted : 1; UCHAR Timer2Expiring : 1; UCHAR Timer2CancelPending : 1; UCHAR Timer2SetPending : 1; UCHAR Timer2Running : 1; UCHAR Timer2Disabled : 1; UCHAR Timer2ReservedFlags : 2; } DUMMYSTRUCTNAME; } DUMMYUNIONNAME; UCHAR Timer2Reserved1; UCHAR Timer2Reserved2; } DUMMYSTRUCTNAME3; struct { // Queue UCHAR QueueType; union { UCHAR QueueControlFlags; struct { UCHAR Abandoned : 1; UCHAR DisableIncrement : 1; UCHAR QueueReservedControlFlags : 6; } DUMMYSTRUCTNAME; } DUMMYUNIONNAME; UCHAR QueueSize; UCHAR QueueReserved; } DUMMYSTRUCTNAME4; struct { // Thread UCHAR ThreadType; UCHAR ThreadReserved; union { UCHAR ThreadControlFlags; struct { UCHAR CycleProfiling : 1; UCHAR CounterProfiling : 1; UCHAR GroupScheduling : 1; UCHAR AffinitySet : 1; UCHAR Tagged : 1; UCHAR EnergyProfiling: 1; #if !defined(_X86_) UCHAR ThreadReservedControlFlags : 2; #else UCHAR Instrumented : 1; UCHAR ThreadReservedControlFlags : 1; #endif } DUMMYSTRUCTNAME; } DUMMYUNIONNAME; union { UCHAR DebugActive; #if !defined(_X86_) struct { BOOLEAN ActiveDR7 : 1; BOOLEAN Instrumented : 1; BOOLEAN Minimal : 1; BOOLEAN Reserved4 : 3; BOOLEAN UmsScheduled : 1; BOOLEAN UmsPrimary : 1; } DUMMYSTRUCTNAME; #endif } DUMMYUNIONNAME2; } DUMMYSTRUCTNAME5; struct { // Mutant UCHAR MutantType; UCHAR MutantSize; BOOLEAN DpcActive; UCHAR MutantReserved; } DUMMYSTRUCTNAME6; } DUMMYUNIONNAME; LONG SignalState; // Object lock LIST_ENTRY WaitListHead; // Object lock } DISPATCHER_HEADER, *PDISPATCHER_HEADER; // // Event object // typedef struct _KEVENT { DISPATCHER_HEADER Header; } KEVENT, *PKEVENT, *PRKEVENT; // // Gate object // // N.B. Gate object services allow the specification of synchronization // events. This allows fast mutex to be transparently replaced with // gates. // typedef struct _KGATE { DISPATCHER_HEADER Header; } KGATE, *PKGATE; // // Timer object // // N.B. The period field must be the last member of this structure. // typedef struct _KTIMER { DISPATCHER_HEADER Header; ULARGE_INTEGER DueTime; LIST_ENTRY TimerListEntry; struct _KDPC *Dpc; #if !defined(KENCODED_TIMER_PROCESSOR) ULONG Processor; #endif ULONG Period; } KTIMER, *PKTIMER, *PRKTIMER; #define KTIMER_ACTUAL_LENGTH \ (FIELD_OFFSET(KTIMER, Period) + sizeof(LONG)) typedef enum _LOCK_OPERATION { IoReadAccess, IoWriteAccess, IoModifyAccess } LOCK_OPERATION; typedef struct _FAST_MUTEX { LONG Count; PVOID Owner; ULONG Contention; KEVENT Event; ULONG OldIrql; } FAST_MUTEX, *PFAST_MUTEX, KGUARDED_MUTEX, *PKGUARDED_MUTEX; #if defined(_X86_) // // Types to use to contain PFNs and their counts. // typedef ULONG PFN_COUNT; typedef LONG SPFN_NUMBER, *PSPFN_NUMBER; typedef ULONG PFN_NUMBER, *PPFN_NUMBER; // // Define maximum size of flush multiple TB request. // #define FLUSH_MULTIPLE_MAXIMUM 32 // // Indicate that the i386 compiler supports the pragma textout construct. // #define ALLOC_PRAGMA 1 // // Indicate that the i386 compiler supports the DATA_SEG("INIT") and // DATA_SEG("PAGE") pragmas // #define ALLOC_DATA_PRAGMA 1 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(HIGH_LEVEL) _DECL_HAL_KE_IMPORT VOID FASTCALL KfLowerIrql ( _In_ _IRQL_restores_ _Notliteral_ KIRQL NewIrql ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(HIGH_LEVEL) _IRQL_raises_(NewIrql) _IRQL_saves_ _DECL_HAL_KE_IMPORT KIRQL FASTCALL KfRaiseIrql ( _In_ KIRQL NewIrql ); #endif #define KeLowerIrql(a) KfLowerIrql(a) #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_saves_ _IRQL_raises_(DISPATCH_LEVEL) _DECL_HAL_KE_IMPORT KIRQL KeRaiseIrqlToDpcLevel ( VOID ); #endif // // I/O space read and write macros. // // These have to be actual functions on the 386, because we need // to use assembler, but cannot return a value if we inline it. // // The READ/WRITE_REGISTER_* calls manipulate I/O registers in MEMORY space. // (Use x86 move instructions, with LOCK prefix to force correct behavior // w.r.t. caches and write buffers.) // // The READ/WRITE_PORT_* calls manipulate I/O registers in PORT space. // (Use x86 in/out instructions.) // NTKERNELAPI UCHAR NTAPI READ_REGISTER_UCHAR( _In_ _Notliteral_ volatile UCHAR *Register ); NTKERNELAPI USHORT NTAPI READ_REGISTER_USHORT( _In_ _Notliteral_ volatile USHORT *Register ); NTKERNELAPI ULONG NTAPI READ_REGISTER_ULONG( _In_ _Notliteral_ volatile ULONG *Register ); NTKERNELAPI VOID NTAPI READ_REGISTER_BUFFER_UCHAR( _In_ _Notliteral_ volatile UCHAR *Register, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTKERNELAPI VOID NTAPI READ_REGISTER_BUFFER_USHORT( _In_ _Notliteral_ volatile USHORT *Register, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTKERNELAPI VOID NTAPI READ_REGISTER_BUFFER_ULONG( _In_ _Notliteral_ volatile ULONG *Register, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ); NTKERNELAPI VOID NTAPI WRITE_REGISTER_UCHAR( _In_ _Notliteral_ volatile UCHAR *Register, _In_ UCHAR Value ); NTKERNELAPI VOID NTAPI WRITE_REGISTER_USHORT( _In_ _Notliteral_ volatile USHORT *Register, _In_ USHORT Value ); NTKERNELAPI VOID NTAPI WRITE_REGISTER_ULONG( _In_ _Notliteral_ volatile ULONG *Register, _In_ ULONG Value ); NTKERNELAPI VOID NTAPI WRITE_REGISTER_BUFFER_UCHAR( _In_ _Notliteral_ volatile UCHAR *Register, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTKERNELAPI VOID NTAPI WRITE_REGISTER_BUFFER_USHORT( _In_ _Notliteral_ volatile USHORT *Register, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTKERNELAPI VOID NTAPI WRITE_REGISTER_BUFFER_ULONG( _In_ _Notliteral_ volatile ULONG *Register, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ); NTHALAPI UCHAR NTAPI READ_PORT_UCHAR( _In_ _Notliteral_ PUCHAR Port ); NTHALAPI USHORT NTAPI READ_PORT_USHORT( _In_ _Notliteral_ PUSHORT Port ); NTHALAPI ULONG NTAPI READ_PORT_ULONG( _In_ _Notliteral_ PULONG Port ); NTHALAPI VOID NTAPI READ_PORT_BUFFER_UCHAR( _In_ _Notliteral_ PUCHAR Port, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTHALAPI VOID NTAPI READ_PORT_BUFFER_USHORT( _In_ _Notliteral_ PUSHORT Port, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTHALAPI VOID NTAPI READ_PORT_BUFFER_ULONG( _In_ _Notliteral_ PULONG Port, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ); NTHALAPI VOID NTAPI WRITE_PORT_UCHAR( _In_ _Notliteral_ PUCHAR Port, _In_ UCHAR Value ); NTHALAPI VOID NTAPI WRITE_PORT_USHORT( _In_ _Notliteral_ PUSHORT Port, _In_ USHORT Value ); NTHALAPI VOID NTAPI WRITE_PORT_ULONG( _In_ _Notliteral_ PULONG Port, _In_ ULONG Value ); NTHALAPI VOID NTAPI WRITE_PORT_BUFFER_UCHAR( _In_ _Notliteral_ PUCHAR Port, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTHALAPI VOID NTAPI WRITE_PORT_BUFFER_USHORT( _In_ _Notliteral_ PUSHORT Port, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTHALAPI VOID NTAPI WRITE_PORT_BUFFER_ULONG( _In_ _Notliteral_ PULONG Port, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ); // // Get data cache fill size. // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(KeGetDcacheFillSize) // Use GetDmaAlignment #endif #define KeGetDcacheFillSize() 1L #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) VOID KeFlushIoBuffers ( _In_ PMDL Mdl, _In_ BOOLEAN ReadOperation, _In_ BOOLEAN DmaOperation ); #else #define KeFlushIoBuffers(Mdl, ReadOperation, DmaOperation) #endif #define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql)) #define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql)) #define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock) #define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock) #define KeQueryTickCount(CurrentCount) { \ KSYSTEM_TIME volatile *_TickCount = *((PKSYSTEM_TIME *)(&KeTickCount)); \ for (;;) { \ (CurrentCount)->HighPart = _TickCount->High1Time; \ (CurrentCount)->LowPart = _TickCount->LowPart; \ if ((CurrentCount)->HighPart == _TickCount->High2Time) break; \ YieldProcessor(); \ } \ } // // The non-volatile 387 state // typedef struct _KFLOATING_SAVE { ULONG ControlWord; ULONG StatusWord; ULONG ErrorOffset; ULONG ErrorSelector; ULONG DataOffset; // Not used in wdm ULONG DataSelector; ULONG Spare0; ULONG Spare1; // Not used in wdm } KFLOATING_SAVE, *PKFLOATING_SAVE; // // Structure of AMD cache information returned by CPUID instruction // typedef union _AMD_L1_CACHE_INFO { ULONG Ulong; struct { UCHAR LineSize; UCHAR LinesPerTag; UCHAR Associativity; UCHAR Size; }; } AMD_L1_CACHE_INFO, *PAMD_L1_CACHE_INFO; typedef union _AMD_L2_CACHE_INFO { ULONG Ulong; struct { UCHAR LineSize; UCHAR LinesPerTag : 4; UCHAR Associativity : 4; USHORT Size; }; } AMD_L2_CACHE_INFO, *PAMD_L2_CACHE_INFO; typedef union _AMD_L3_CACHE_INFO { ULONG Ulong; struct { UCHAR LineSize; UCHAR LinesPerTag : 4; UCHAR Associativity : 4; USHORT Reserved : 2; USHORT Size : 14; }; } AMD_L3_CACHE_INFO, *PAMD_L3_CACHE_INFO; // // Structure of Intel deterministic cache information returned by // CPUID instruction // typedef enum _INTEL_CACHE_TYPE { IntelCacheNull, IntelCacheData, IntelCacheInstruction, IntelCacheUnified, IntelCacheRam, IntelCacheTrace } INTEL_CACHE_TYPE; typedef union INTEL_CACHE_INFO_EAX { ULONG Ulong; struct { INTEL_CACHE_TYPE Type : 5; ULONG Level : 3; ULONG SelfInitializing : 1; ULONG FullyAssociative : 1; ULONG Reserved : 4; ULONG ThreadsSharing : 12; ULONG ProcessorCores : 6; }; } INTEL_CACHE_INFO_EAX, *PINTEL_CACHE_INFO_EAX; typedef union INTEL_CACHE_INFO_EBX { ULONG Ulong; struct { ULONG LineSize : 12; ULONG Partitions : 10; ULONG Associativity : 10; }; } INTEL_CACHE_INFO_EBX, *PINTEL_CACHE_INFO_EBX; #define MmGetProcedureAddress(Address) (Address) #define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address) // // Result type definition for i386. (Machine specific enumerate type // which is return type for portable exinterlockedincrement/decrement // procedures.) In general, you should use the enumerated type defined // in ex.h instead of directly referencing these constants. // // Flags loaded into AH by LAHF instruction #define EFLAG_SIGN 0x8000 #define EFLAG_ZERO 0x4000 #define EFLAG_SELECT (EFLAG_SIGN | EFLAG_ZERO) #define RESULT_NEGATIVE ((EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT) #define RESULT_ZERO ((~EFLAG_SIGN & EFLAG_ZERO) & EFLAG_SELECT) #define RESULT_POSITIVE ((~EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT) // // Convert various portable ExInterlock APIs into their architectural // equivalents. // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(ExInterlockedIncrementLong) // Use InterlockedIncrement #pragma deprecated(ExInterlockedDecrementLong) // Use InterlockedDecrement #pragma deprecated(ExInterlockedExchangeUlong) // Use InterlockedExchange #endif #define ExInterlockedIncrementLong(Addend,Lock) \ Exfi386InterlockedIncrementLong(Addend) #define ExInterlockedDecrementLong(Addend,Lock) \ Exfi386InterlockedDecrementLong(Addend) #define ExInterlockedExchangeUlong(Target,Value,Lock) \ Exfi386InterlockedExchangeUlong(Target,Value) #define ExInterlockedAddUlong ExfInterlockedAddUlong #define ExInterlockedInsertHeadList ExfInterlockedInsertHeadList #define ExInterlockedInsertTailList ExfInterlockedInsertTailList #define ExInterlockedRemoveHeadList ExfInterlockedRemoveHeadList #define ExInterlockedPopEntryList ExfInterlockedPopEntryList #define ExInterlockedPushEntryList ExfInterlockedPushEntryList #if !defined(MIDL_PASS) && defined(_M_IX86) // // i386 function definitions // // // Get current IRQL. // // On x86 this function resides in the HAL // _IRQL_requires_max_(HIGH_LEVEL) _IRQL_saves_ NTHALAPI KIRQL NTAPI KeGetCurrentIrql( VOID ); #if (NTDDI_VERSION >= NTDDI_WIN7) FORCEINLINE ULONG NTAPI KeGetCurrentProcessorIndex ( VOID ) { return (ULONG)__readfsbyte(0x51); } #endif #endif // !defined(MIDL_PASS) && defined(_M_IX86) #ifdef __cplusplus extern "C" { #endif // // Define function to flush a cache line. // #define CacheLineFlush(Address) _mm_clflush(Address) VOID _mm_clflush ( VOID const *Address ); #pragma intrinsic(_mm_clflush) // // Define function to invalidate a page. // #define InvalidatePage(Page) __invlpg(Page) VOID __invlpg ( _In_ PVOID Page ); #define WritebackInvalidate() __wbinvd() VOID __wbinvd ( VOID ); #pragma intrinsic(__invlpg) #pragma intrinsic(__wbinvd) // // Define functions to read and write CR3. // #define ReadCR3() __readcr3() ULONG __readcr3 ( VOID ); #define WriteCR3(Data) __writecr3(Data) VOID __writecr3 ( _In_ UINT32 Data ); #pragma intrinsic(__readcr3) #pragma intrinsic(__writecr3) // // Define function to get eflags. // UINT32 __readeflags ( VOID ); #define ReadEflags() __readeflags() #pragma intrinsic(__readeflags) VOID _ReadWriteBarrier( VOID ); #ifdef __cplusplus } #endif #pragma intrinsic(_ReadWriteBarrier) #pragma prefast(push) #pragma prefast(disable : 6001 28113, "The barrier variable is accessed only to create a side effect.") FORCEINLINE VOID KeMemoryBarrier ( VOID ) { LONG Barrier; InterlockedOr(&Barrier, 0); return; } #pragma prefast(pop) #define KeMemoryBarrierWithoutFence() _ReadWriteBarrier() _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _When_(return>=0, _Kernel_float_saved_) _At_(*FloatSave, _When_(return>=0, _Kernel_acquires_resource_(FloatState))) NTKERNELAPI NTSTATUS NTAPI KeSaveFloatingPointState ( _Out_ PKFLOATING_SAVE FloatSave ); _Success_(1) _IRQL_requires_max_(DISPATCH_LEVEL) _Kernel_float_restored_ _At_(*FloatSave, _Kernel_requires_resource_held_(FloatState) _Kernel_releases_resource_(FloatState)) NTKERNELAPI NTSTATUS NTAPI KeRestoreFloatingPointState ( _In_ PKFLOATING_SAVE FloatSave ); #endif // defined(_X86_) #if defined(_M_AMD64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) // // Define intrinsic function to do in's and out's. // #ifdef __cplusplus extern "C" { #endif UCHAR __inbyte ( _In_ USHORT Port ); USHORT __inword ( _In_ USHORT Port ); ULONG __indword ( _In_ USHORT Port ); VOID __outbyte ( _In_ USHORT Port, _In_ UCHAR Data ); VOID __outword ( _In_ USHORT Port, _In_ USHORT Data ); VOID __outdword ( _In_ USHORT Port, _In_ ULONG Data ); VOID __inbytestring ( _In_ USHORT Port, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ); VOID __inwordstring ( _In_ USHORT Port, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ); VOID __indwordstring ( _In_ USHORT Port, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ); VOID __outbytestring ( _In_ USHORT Port, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ); VOID __outwordstring ( _In_ USHORT Port, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ); VOID __outdwordstring ( _In_ USHORT Port, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ); #pragma intrinsic(__inbyte) #pragma intrinsic(__inword) #pragma intrinsic(__indword) #pragma intrinsic(__outbyte) #pragma intrinsic(__outword) #pragma intrinsic(__outdword) #pragma intrinsic(__inbytestring) #pragma intrinsic(__inwordstring) #pragma intrinsic(__indwordstring) #pragma intrinsic(__outbytestring) #pragma intrinsic(__outwordstring) #pragma intrinsic(__outdwordstring) #ifdef __cplusplus } #endif #endif // defined(_M_AMD64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #if defined(_AMD64_) // ntddk nthal irqls // // Types to use to contain PFNs and their counts. // typedef ULONG PFN_COUNT; typedef LONG64 SPFN_NUMBER, *PSPFN_NUMBER; typedef ULONG64 PFN_NUMBER, *PPFN_NUMBER; // // Define maximum size of flush multiple TB request. // #define FLUSH_MULTIPLE_MAXIMUM 19 // // Indicate that the AMD64 compiler supports the allocate pragmas. // #define ALLOC_PRAGMA 1 #define ALLOC_DATA_PRAGMA 1 // // Define functions to read and write CR8. // // CR8 is the APIC TPR register. // #ifdef __cplusplus extern "C" { #endif #define ReadCR8() __readcr8() _IRQL_requires_max_(HIGH_LEVEL) _IRQL_saves_ ULONG64 __readcr8 ( VOID ); #define WriteCR8(Data) __writecr8(Data) _IRQL_requires_max_(HIGH_LEVEL) _IRQL_raises_(Data) VOID __writecr8 ( _In_ ULONG64 Data ); #pragma intrinsic(__readcr8) #pragma intrinsic(__writecr8) #ifdef __cplusplus } #endif #if defined(_AMD64_) && !defined(DSF_DRIVER) // // I/O space read and write macros. // // The READ/WRITE_REGISTER_* calls manipulate I/O registers in MEMORY space. // // The READ/WRITE_PORT_* calls manipulate I/O registers in PORT space. // #ifdef __cplusplus extern "C" { #endif __forceinline UCHAR READ_REGISTER_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register ) { _ReadWriteBarrier(); return *Register; } __forceinline USHORT READ_REGISTER_USHORT ( _In_ _Notliteral_ volatile USHORT *Register ) { _ReadWriteBarrier(); return *Register; } __forceinline ULONG READ_REGISTER_ULONG ( _In_ _Notliteral_ volatile ULONG *Register ) { _ReadWriteBarrier(); return *Register; } __forceinline ULONG64 READ_REGISTER_ULONG64 ( _In_ _Notliteral_ volatile ULONG64 *Register ) { _ReadWriteBarrier(); return *Register; } __forceinline VOID READ_REGISTER_BUFFER_UCHAR ( _In_reads_(Count) _Notliteral_ volatile UCHAR *Register, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __movsb(Buffer, (PUCHAR)Register, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_USHORT ( _In_reads_(Count) _Notliteral_ volatile USHORT *Register, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __movsw(Buffer, (PUSHORT)Register, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_ULONG ( _In_reads_(Count) _Notliteral_ volatile ULONG *Register, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __movsd(Buffer, (PULONG)Register, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_ULONG64 ( _In_reads_(Count) _Notliteral_ volatile ULONG64 *Register, _Out_writes_all_(Count) PULONG64 Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __movsq(Buffer, (PULONG64)Register, Count); return; } __forceinline VOID WRITE_REGISTER_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register, _In_ UCHAR Value ) { *Register = Value; FastFence(); return; } __forceinline VOID WRITE_REGISTER_USHORT ( _In_ _Notliteral_ volatile USHORT *Register, _In_ USHORT Value ) { *Register = Value; FastFence(); return; } __forceinline VOID WRITE_REGISTER_ULONG ( _In_ _Notliteral_ volatile ULONG *Register, _In_ ULONG Value ) { *Register = Value; FastFence(); return; } __forceinline VOID WRITE_REGISTER_ULONG64 ( _In_ _Notliteral_ volatile ULONG64 *Register, _In_ ULONG64 Value ) { *Register = Value; FastFence(); return; } __forceinline VOID WRITE_REGISTER_BUFFER_UCHAR ( _Out_writes_(Count) _Notliteral_ volatile UCHAR *Register, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ) { __movsb((PUCHAR)Register, Buffer, Count); FastFence(); return; } __forceinline VOID WRITE_REGISTER_BUFFER_USHORT ( _Out_writes_(Count) _Notliteral_ volatile USHORT *Register, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ) { __movsw((PUSHORT)Register, Buffer, Count); FastFence(); return; } __forceinline VOID WRITE_REGISTER_BUFFER_ULONG ( _Out_writes_(Count) _Notliteral_ volatile ULONG *Register, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ) { __movsd((PULONG)Register, Buffer, Count); FastFence(); return; } __forceinline VOID WRITE_REGISTER_BUFFER_ULONG64 ( _Out_writes_(Count) _Notliteral_ volatile ULONG64 *Register, _In_reads_(Count) PULONG64 Buffer, _In_ ULONG Count ) { __movsq((PULONG64)Register, Buffer, Count); FastFence(); return; } __forceinline UCHAR READ_PORT_UCHAR ( _In_ _Notliteral_ PUCHAR Port ) { UCHAR Result; _ReadWriteBarrier(); Result = __inbyte((USHORT)((ULONG_PTR)Port)); _ReadWriteBarrier(); return Result; } __forceinline USHORT READ_PORT_USHORT ( _In_ _Notliteral_ PUSHORT Port ) { USHORT Result; _ReadWriteBarrier(); Result = __inword((USHORT)((ULONG_PTR)Port)); _ReadWriteBarrier(); return Result; } __forceinline ULONG READ_PORT_ULONG ( _In_ _Notliteral_ PULONG Port ) { ULONG Result; _ReadWriteBarrier(); Result = __indword((USHORT)((ULONG_PTR)Port)); _ReadWriteBarrier(); return Result; } __forceinline VOID READ_PORT_BUFFER_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __inbytestring((USHORT)((ULONG_PTR)Port), Buffer, Count); _ReadWriteBarrier(); return; } __forceinline VOID READ_PORT_BUFFER_USHORT ( _In_ _Notliteral_ PUSHORT Port, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __inwordstring((USHORT)((ULONG_PTR)Port), Buffer, Count); _ReadWriteBarrier(); return; } __forceinline VOID READ_PORT_BUFFER_ULONG ( _In_ _Notliteral_ PULONG Port, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __indwordstring((USHORT)((ULONG_PTR)Port), Buffer, Count); _ReadWriteBarrier(); return; } __forceinline VOID WRITE_PORT_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _In_ UCHAR Value ) { _ReadWriteBarrier(); __outbyte((USHORT)((ULONG_PTR)Port), Value); _ReadWriteBarrier(); return; } __forceinline VOID WRITE_PORT_USHORT ( _In_ _Notliteral_ PUSHORT Port, _In_ USHORT Value ) { _ReadWriteBarrier(); __outword((USHORT)((ULONG_PTR)Port), Value); _ReadWriteBarrier(); return; } __forceinline VOID WRITE_PORT_ULONG ( _In_ _Notliteral_ PULONG Port, _In_ ULONG Value ) { _ReadWriteBarrier(); __outdword((USHORT)((ULONG_PTR)Port), Value); _ReadWriteBarrier(); return; } __forceinline VOID WRITE_PORT_BUFFER_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __outbytestring((USHORT)((ULONG_PTR)Port), Buffer, Count); _ReadWriteBarrier(); return; } __forceinline VOID WRITE_PORT_BUFFER_USHORT ( _In_ _Notliteral_ PUSHORT Port, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __outwordstring((USHORT)((ULONG_PTR)Port), Buffer, Count); _ReadWriteBarrier(); return; } __forceinline VOID WRITE_PORT_BUFFER_ULONG ( _In_ _Notliteral_ PULONG Port, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ) { _ReadWriteBarrier(); __outdwordstring((USHORT)((ULONG_PTR)Port), Buffer, Count); _ReadWriteBarrier(); return; } #ifdef __cplusplus } #endif #endif // // Get data cache fill size. // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(KeGetDcacheFillSize) // Use GetDmaAlignment #endif #define KeGetDcacheFillSize() 1L #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) VOID KeFlushIoBuffers ( _In_ PMDL Mdl, _In_ BOOLEAN ReadOperation, _In_ BOOLEAN DmaOperation ); #else #define KeFlushIoBuffers(Mdl, ReadOperation, DmaOperation) #endif #define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql)) #define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql)) #define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock) #define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock) // // Dummy nonvolatile floating state structure. // typedef struct _KFLOATING_SAVE { ULONG Dummy; } KFLOATING_SAVE, *PKFLOATING_SAVE; #define MmGetProcedureAddress(Address) (Address) #define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address) #if (NTDDI_VERSION >= NTDDI_WIN7) __forceinline ULONG KeGetCurrentProcessorIndex ( VOID ) { return __readgsdword(0x1a4); } #endif #if !defined(_CROSS_PLATFORM_) CFORCEINLINE VOID KeMemoryBarrier ( VOID ) /*++ Routine Description: This function orders memory accesses as seen by other processors. Arguments: None. Return Value: None. --*/ { FastFence(); return; } //++ // // VOID // KeMemoryBarrierWithoutFence ( // VOID // ) // // // Routine Description: // // This function instructs the compiler not to reorder loads and stores // across the function invocation. // // Arguments: // // None. // // Return Value: // // None. // //-- #define KeMemoryBarrierWithoutFence() _ReadWriteBarrier() #else #define KeMemoryBarrier() #define KeMemoryBarrierWithoutFence() #endif #pragma warning(push) #pragma warning(suppress:28104 28161 6001 6101) // PFD can't recognize the implementation _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _When_(return>=0, _Kernel_float_saved_) _At_(*FloatSave, _When_(return>=0, _Kernel_acquires_resource_(FloatState))) __forceinline NTSTATUS KeSaveFloatingPointState ( _Out_ PKFLOATING_SAVE FloatSave ) { UNREFERENCED_PARAMETER(FloatSave); return STATUS_SUCCESS; } #pragma warning(pop) #pragma warning(push) #pragma warning (suppress:28103 28162) // PFD can't recognize the implementation _Success_(1) _IRQL_requires_max_(DISPATCH_LEVEL) _Kernel_float_restored_ _At_(*FloatSave, _Kernel_requires_resource_held_(FloatState) _Kernel_releases_resource_(FloatState)) __forceinline NTSTATUS KeRestoreFloatingPointState ( _In_ PKFLOATING_SAVE FloatSave ) { UNREFERENCED_PARAMETER(FloatSave); return STATUS_SUCCESS; } #pragma warning(pop) #endif // defined(_AMD64_) // // Platform specific kernel fucntions to raise and lower IRQL. // #if defined(_AMD64_) && !defined(MIDL_PASS) _IRQL_requires_max_(HIGH_LEVEL) _IRQL_saves_ CFORCEINLINE KIRQL KeGetCurrentIrql ( VOID ) /*++ Routine Description: This function return the current IRQL. Arguments: None. Return Value: The current IRQL is returned as the function value. --*/ { return (KIRQL)ReadCR8(); } #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a) #if ((NTDDI_VERSION >= NTDDI_WIN8) && \ (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_) || defined(_BLDR_))) _IRQL_requires_max_(HIGH_LEVEL) NTKERNELAPI VOID KeLowerIrql ( _In_ _Notliteral_ _IRQL_restores_ KIRQL NewIrql ); _IRQL_requires_max_(HIGH_LEVEL) _IRQL_raises_(NewIrql) _IRQL_saves_ NTKERNELAPI KIRQL KfRaiseIrql ( _In_ KIRQL NewIrql ); #else _IRQL_requires_max_(HIGH_LEVEL) CFORCEINLINE VOID KzLowerIrql ( _In_ _Notliteral_ _IRQL_restores_ KIRQL NewIrql ) /*++ Routine Description: This function lowers the IRQL to the specified value. Arguments: NewIrql - Supplies the new IRQL value. Return Value: None. --*/ { NT_ASSERT(KeGetCurrentIrql() >= NewIrql); WriteCR8(NewIrql); return; } _IRQL_requires_max_(HIGH_LEVEL) _IRQL_raises_(NewIrql) _IRQL_saves_ CFORCEINLINE KIRQL KzRaiseIrql ( _In_ KIRQL NewIrql ) /*++ Routine Description: This function raises the current IRQL to the specified value and returns the previous IRQL. Arguments: NewIrql (cl) - Supplies the new IRQL value. Return Value: The previous IRQL is retured as the function value. --*/ { KIRQL OldIrql; OldIrql = KeGetCurrentIrql(); NT_ASSERT(OldIrql <= NewIrql); WriteCR8(NewIrql); return OldIrql; } #define KeLowerIrql KzLowerIrql #define KfRaiseIrql KzRaiseIrql #endif #endif // defined(_AMD64_) && !defined(MIDL_PASS) #if defined(_M_ARM) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #endif // defined(_M_ARM) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #if defined(_ARM_) // ntddk nthal irqls // // Types to use to contain PFNs and their counts. // typedef ULONG PFN_COUNT; typedef LONG SPFN_NUMBER, *PSPFN_NUMBER; typedef ULONG PFN_NUMBER, *PPFN_NUMBER; // // Maximum number of event counters in performance monitoring unit. // #define MAX_EVENT_COUNTERS 31 // // Define maximum size of flush multiple TB request. // #define FLUSH_MULTIPLE_MAXIMUM 32 // // Indicate that the ARM compiler supports the allocate pragmas. // #define ALLOC_PRAGMA 1 #define ALLOC_DATA_PRAGMA 1 // #ifdef __cplusplus extern "C" { #endif #ifdef __cplusplus } #endif #if defined(_ARM_) // // I/O space read and write macros. // // The READ/WRITE_REGISTER_* calls manipulate I/O registers in MEMORY space. // // N.B. This implementation assumes that the memory mapped registers // have been mapped using the OS concept of uncached memory // which is implemented using the ARMv7 strongly ordered memory // type. In addition, the register access is bracketed by a // compiler barrier to ensure that the compiler does not // re-order the I/O accesses with other accesses and a data // synchronization barrier to ensure that any side effects of // the access have started (but not necessairly completed). // // The READ/WRITE_PORT_* calls manipulate I/O registers in PORT // space. The ARM architecture doesn't have a seperate I/O space. // These operations bugcheck so as to identify incorrect code. // #ifdef __cplusplus extern "C" { #endif __forceinline UCHAR READ_REGISTER_NOFENCE_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register ) { return ReadUCharNoFence(Register); } __forceinline USHORT READ_REGISTER_NOFENCE_USHORT ( _In_ _Notliteral_ volatile USHORT *Register ) { return ReadUShortNoFence(Register); } __forceinline ULONG READ_REGISTER_NOFENCE_ULONG ( _In_ _Notliteral_ volatile ULONG *Register ) { return ReadULongNoFence(Register); } __forceinline VOID READ_REGISTER_NOFENCE_BUFFER_UCHAR ( _In_reads_(Count) _Notliteral_ volatile UCHAR *Register, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ) { volatile UCHAR *registerBuffer = Register; PUCHAR readBuffer = Buffer; ULONG readCount; for (readCount = Count; readCount--; readBuffer++, registerBuffer++) { *readBuffer = ReadUCharNoFence(registerBuffer); } return; } __forceinline VOID READ_REGISTER_NOFENCE_BUFFER_USHORT ( _In_reads_(Count) _Notliteral_ volatile USHORT *Register, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ) { volatile USHORT *registerBuffer = Register; PUSHORT readBuffer = Buffer; ULONG readCount; for (readCount = Count; readCount--; readBuffer++, registerBuffer++) { *readBuffer = ReadUShortNoFence(registerBuffer); } return; } __forceinline VOID READ_REGISTER_NOFENCE_BUFFER_ULONG ( _In_reads_(Count) _Notliteral_ volatile ULONG *Register, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ) { volatile ULONG *registerBuffer = Register; PULONG readBuffer = Buffer; ULONG readCount; for (readCount = Count; readCount--; readBuffer++, registerBuffer++) { *readBuffer = ReadULongNoFence(registerBuffer); } return; } __forceinline VOID WRITE_REGISTER_NOFENCE_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register, _In_ UCHAR Value ) { WriteUCharNoFence(Register, Value); return; } __forceinline VOID WRITE_REGISTER_NOFENCE_USHORT ( _In_ _Notliteral_ volatile USHORT *Register, _In_ USHORT Value ) { WriteUShortNoFence(Register, Value); return; } __forceinline VOID WRITE_REGISTER_NOFENCE_ULONG ( _In_ _Notliteral_ volatile ULONG *Register, _In_ ULONG Value ) { WriteULongNoFence(Register, Value); return; } __forceinline VOID WRITE_REGISTER_NOFENCE_BUFFER_UCHAR ( _Out_writes_(Count) _Notliteral_ volatile UCHAR *Register, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ) { volatile UCHAR *registerBuffer = Register; PUCHAR writeBuffer = Buffer; ULONG writeCount; for (writeCount = Count; writeCount--; writeBuffer++, registerBuffer++) { WriteUCharNoFence(registerBuffer, *writeBuffer); } return; } __forceinline VOID WRITE_REGISTER_NOFENCE_BUFFER_USHORT ( _Out_writes_(Count) _Notliteral_ volatile USHORT *Register, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ) { volatile USHORT *registerBuffer = Register; PUSHORT writeBuffer = Buffer; ULONG writeCount; for (writeCount = Count; writeCount--; writeBuffer++, registerBuffer++) { WriteUShortNoFence(registerBuffer, *writeBuffer); } return; } __forceinline VOID WRITE_REGISTER_NOFENCE_BUFFER_ULONG ( _Out_writes_(Count) _Notliteral_ volatile ULONG *Register, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ) { volatile ULONG *registerBuffer = Register; PULONG writeBuffer = Buffer; ULONG writeCount; for (writeCount = Count; writeCount--; writeBuffer++, registerBuffer++) { WriteULongNoFence(registerBuffer, *writeBuffer); } return; } __forceinline VOID REGISTER_FENCE ( VOID ) { _DataSynchronizationBarrier(); } __forceinline UCHAR READ_REGISTER_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register ) { UCHAR Value; _DataSynchronizationBarrier(); Value = READ_REGISTER_NOFENCE_UCHAR(Register); return Value; } __forceinline USHORT READ_REGISTER_USHORT ( _In_ _Notliteral_ volatile USHORT *Register ) { USHORT Value; _DataSynchronizationBarrier(); Value = READ_REGISTER_NOFENCE_USHORT(Register); return Value; } __forceinline ULONG READ_REGISTER_ULONG ( _In_ _Notliteral_ volatile ULONG *Register ) { ULONG Value; _DataSynchronizationBarrier(); Value = READ_REGISTER_NOFENCE_ULONG(Register); return Value; } __forceinline VOID READ_REGISTER_BUFFER_UCHAR ( _In_reads_(Count) _Notliteral_ volatile UCHAR *Register, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); READ_REGISTER_NOFENCE_BUFFER_UCHAR(Register, Buffer, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_USHORT ( _In_reads_(Count) _Notliteral_ volatile USHORT *Register, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); READ_REGISTER_NOFENCE_BUFFER_USHORT(Register, Buffer, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_ULONG ( _In_reads_(Count) _Notliteral_ volatile ULONG *Register, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); READ_REGISTER_NOFENCE_BUFFER_ULONG(Register, Buffer, Count); return; } __forceinline VOID WRITE_REGISTER_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register, _In_ UCHAR Value ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_UCHAR(Register, Value); return; } __forceinline VOID WRITE_REGISTER_USHORT ( _In_ _Notliteral_ volatile USHORT *Register, _In_ USHORT Value ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_USHORT(Register, Value); return; } __forceinline VOID WRITE_REGISTER_ULONG ( _In_ _Notliteral_ volatile ULONG *Register, _In_ ULONG Value ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_ULONG(Register, Value); return; } __forceinline VOID WRITE_REGISTER_BUFFER_UCHAR ( _Out_writes_(Count) _Notliteral_ volatile UCHAR *Register, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_BUFFER_UCHAR(Register, Buffer, Count); return; } __forceinline VOID WRITE_REGISTER_BUFFER_USHORT ( _Out_writes_(Count) _Notliteral_ volatile USHORT *Register, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_BUFFER_USHORT(Register, Buffer, Count); return; } __forceinline VOID WRITE_REGISTER_BUFFER_ULONG ( _Out_writes_(Count) _Notliteral_ volatile ULONG *Register, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_BUFFER_ULONG(Register, Buffer, Count); return; } NTHALAPI UCHAR READ_PORT_UCHAR ( _In_ _Notliteral_ PUCHAR Port ); NTHALAPI USHORT READ_PORT_USHORT ( _In_ _Notliteral_ PUSHORT Port ); NTHALAPI ULONG READ_PORT_ULONG ( _In_ _Notliteral_ PULONG Port ); NTHALAPI VOID READ_PORT_BUFFER_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTHALAPI VOID READ_PORT_BUFFER_USHORT ( _In_ _Notliteral_ PUSHORT Port, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTHALAPI VOID READ_PORT_BUFFER_ULONG ( _In_ _Notliteral_ PULONG Port, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ); NTHALAPI VOID WRITE_PORT_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _In_ UCHAR Value ); NTHALAPI VOID WRITE_PORT_USHORT ( _In_ _Notliteral_ PUSHORT Port, _In_ USHORT Value ); NTHALAPI VOID WRITE_PORT_ULONG ( _In_ _Notliteral_ PULONG Port, _In_ ULONG Value ); NTHALAPI VOID WRITE_PORT_BUFFER_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTHALAPI VOID WRITE_PORT_BUFFER_USHORT ( _In_ _Notliteral_ PUSHORT Port, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTHALAPI VOID WRITE_PORT_BUFFER_ULONG ( _In_ _Notliteral_ PULONG Port, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ); #ifdef __cplusplus } #endif #endif // // Get data cache fill size. // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(KeGetDcacheFillSize) // Use GetDmaAlignment #endif #define KeGetDcacheFillSize() 1L VOID KeFlushIoBuffers( _In_ PMDL Mdl, _In_ BOOLEAN ReadOperation, _In_ BOOLEAN DmaOperation ); VOID KeFlushIoRectangle ( _In_ PMDL Mdl, _In_ PVOID Start, _In_ ULONG Width, _In_ ULONG Height, _In_ ULONG Stride, _In_ BOOLEAN ReadOperation ); #define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql)) #define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql)) #define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock) #define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock) #define KeQueryTickCount(CurrentCount) { \ KSYSTEM_TIME volatile *_TickCount = *((PKSYSTEM_TIME *)(&KeTickCount)); \ for (;;) { \ (CurrentCount)->HighPart = _TickCount->High1Time; \ (CurrentCount)->LowPart = _TickCount->LowPart; \ if ((CurrentCount)->HighPart == _TickCount->High2Time) break; \ YieldProcessor(); \ } \ } // // Definitions for CP15 Register 0 e.g. ID and cache information // typedef union _ARM_IDCODE { ULONG Ulong; struct { ULONG MinorRevision : 4; ULONG Model : 12; ULONG Architecture : 4; ULONG Revision : 4; ULONG Implementer : 8; }; } ARM_IDCODE, *PARM_IDCODE; C_ASSERT(sizeof(ARM_IDCODE) == 4); // // Dummy nonvolatile floating state structure. // typedef struct _KFLOATING_SAVE { ULONG Dummy; } KFLOATING_SAVE, *PKFLOATING_SAVE; #define MmGetProcedureAddress(Address) (Address) #define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address) #define CP15_PCR_RESERVED_MASK 0xFFF #define KIPCR() ((ULONG_PTR)(_MoveFromCoprocessor(CP15_TPIDRPRW)) & ~CP15_PCR_RESERVED_MASK) #if (NTDDI_VERSION >= NTDDI_WIN7) CFORCEINLINE ULONG KeGetCurrentProcessorIndex ( VOID ) { return *(PULONG)(KIPCR() + 0x594); } #endif #if !defined(_CROSS_PLATFORM_) CFORCEINLINE VOID KeMemoryBarrier ( VOID ) /*++ Routine Description: This function orders memory accesses as seen by other processors. Arguments: None. Return Value: None. --*/ { _ReadWriteBarrier(); MemoryBarrier(); } //++ // // VOID // KeMemoryBarrierWithoutFence ( // VOID // ) // // // Routine Description: // // This function instructs the compiler not to reorder loads and stores // across the function invocation. // // Arguments: // // None. // // Return Value: // // None. // //-- #define KeMemoryBarrierWithoutFence() _ReadWriteBarrier() // // Define function to read the value of the time stamp counter. // // N.B. On some platforms (e.g., any non-Intel platform like ARM) // the "timestamp counter" may be backed by QueryPerformanceCounter // or the like, and may not be as low-latency as one might expect. // ULONG64 ReadTimeStampCounter ( VOID ); #else #define KeMemoryBarrier() #define KeMemoryBarrierWithoutFence() #endif #pragma warning(push) #pragma warning(suppress:28104 28161 6001 6101) // PFD can't recognize the implementation _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _When_(return>=0, _Kernel_float_saved_) _At_(*FloatSave, _When_(return>=0, _Kernel_acquires_resource_(FloatState))) __forceinline NTSTATUS KeSaveFloatingPointState ( _Out_ PKFLOATING_SAVE FloatSave ) { UNREFERENCED_PARAMETER(FloatSave); return STATUS_SUCCESS; } #pragma warning(pop) #pragma warning(push) #pragma warning (suppress:28103 28162) // PFD can't recognize the implementation _Success_(1) _IRQL_requires_max_(DISPATCH_LEVEL) _Kernel_float_restored_ _At_(*FloatSave, _Kernel_requires_resource_held_(FloatState) _Kernel_releases_resource_(FloatState)) __forceinline NTSTATUS KeRestoreFloatingPointState ( _In_ PKFLOATING_SAVE FloatSave ) { UNREFERENCED_PARAMETER(FloatSave); return STATUS_SUCCESS; } #pragma warning(pop) #endif // defined(_ARM_) // // Platform specific kernel fucntions to raise and lower IRQL. // #if defined(_ARM_) && !defined(MIDL_PASS) _IRQL_requires_max_(HIGH_LEVEL) _IRQL_saves_ NTHALAPI KIRQL KeGetCurrentIrql ( VOID ); _IRQL_requires_max_(HIGH_LEVEL) NTHALAPI VOID KfLowerIrql ( _In_ _IRQL_restores_ _Notliteral_ KIRQL NewIrql ); #define KeLowerIrql(a) KfLowerIrql(a) #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a) NTHALAPI KIRQL _IRQL_requires_max_(HIGH_LEVEL) _IRQL_raises_(NewIrql) _IRQL_saves_ KfRaiseIrql ( _In_ KIRQL NewIrql ); #endif // defined(_ARM_) && !defined(MIDL_PASS) #if defined(_M_ARM64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #endif // defined(_M_ARM64) && !defined(RC_INVOKED) && !defined(MIDL_PASS) #if defined(_ARM64_) // ntddk nthal irqls ntoshvp // // Types to use to contain PFNs and their counts. // typedef ULONG PFN_COUNT; typedef LONG64 SPFN_NUMBER, *PSPFN_NUMBER; typedef ULONG64 PFN_NUMBER, *PPFN_NUMBER; // // Maximum number of event counters in performance monitoring unit. // #define MAX_EVENT_COUNTERS 31 // // Define maximum size of flush multiple TB request. // #define FLUSH_MULTIPLE_MAXIMUM 32 // // Indicate that the ARM64 compiler supports the allocate pragmas. // #define ALLOC_PRAGMA 1 #define ALLOC_DATA_PRAGMA 1 // #ifdef __cplusplus extern "C" { #endif #ifdef __cplusplus } #endif #if defined(_ARM64_) // // I/O space read and write macros. // // The READ/WRITE_REGISTER_* calls manipulate I/O registers in MEMORY space. // // N.B. This implementation assumes that the memory mapped registers // have been mapped using the OS concept of uncached memory // which is implemented using the ARMv7 strongly ordered memory // type. In addition, the register access is bracketed by a // compiler barrier to ensure that the compiler does not // re-order the I/O accesses with other accesses and a data // synchronization barrier to ensure that any side effects of // the access have started (but not necessairly completed). // // The READ/WRITE_PORT_* calls manipulate I/O registers in PORT // space. The ARM architecture doesn't have a seperate I/O space. // These operations bugcheck so as to identify incorrect code. // #ifdef __cplusplus extern "C" { #endif __forceinline UCHAR READ_REGISTER_NOFENCE_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register ) { return ReadUCharNoFence(Register); } __forceinline USHORT READ_REGISTER_NOFENCE_USHORT ( _In_ _Notliteral_ volatile USHORT *Register ) { return ReadUShortNoFence(Register); } __forceinline ULONG READ_REGISTER_NOFENCE_ULONG ( _In_ _Notliteral_ volatile ULONG *Register ) { return ReadULongNoFence(Register); } __forceinline ULONG64 READ_REGISTER_NOFENCE_ULONG64 ( _In_ _Notliteral_ volatile ULONG64 *Register ) { return ReadULong64NoFence(Register); } __forceinline VOID READ_REGISTER_NOFENCE_BUFFER_UCHAR ( _In_reads_(Count) _Notliteral_ volatile UCHAR *Register, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ) { volatile UCHAR *registerBuffer = Register; PUCHAR readBuffer = Buffer; ULONG readCount; for (readCount = Count; readCount--; readBuffer++, registerBuffer++) { *readBuffer = ReadUCharNoFence(registerBuffer); } return; } __forceinline VOID READ_REGISTER_NOFENCE_BUFFER_USHORT ( _In_reads_(Count) _Notliteral_ volatile USHORT *Register, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ) { volatile USHORT *registerBuffer = Register; PUSHORT readBuffer = Buffer; ULONG readCount; for (readCount = Count; readCount--; readBuffer++, registerBuffer++) { *readBuffer = ReadUShortNoFence(registerBuffer); } return; } __forceinline VOID READ_REGISTER_NOFENCE_BUFFER_ULONG ( _In_reads_(Count) _Notliteral_ volatile ULONG *Register, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ) { volatile ULONG *registerBuffer = Register; PULONG readBuffer = Buffer; ULONG readCount; for (readCount = Count; readCount--; readBuffer++, registerBuffer++) { *readBuffer = ReadULongNoFence(registerBuffer); } return; } __forceinline VOID READ_REGISTER_NOFENCE_BUFFER_ULONG64 ( _In_reads_(Count) _Notliteral_ volatile ULONG64 *Register, _Out_writes_all_(Count) PULONG64 Buffer, _In_ ULONG Count ) { volatile ULONG64 *registerBuffer = Register; PULONG64 readBuffer = Buffer; ULONG readCount; for (readCount = Count; readCount--; readBuffer++, registerBuffer++) { *readBuffer = ReadULong64NoFence(registerBuffer); } return; } __forceinline VOID WRITE_REGISTER_NOFENCE_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register, _In_ UCHAR Value ) { WriteUCharNoFence(Register, Value); return; } __forceinline VOID WRITE_REGISTER_NOFENCE_USHORT ( _In_ _Notliteral_ volatile USHORT *Register, _In_ USHORT Value ) { WriteUShortNoFence(Register, Value); return; } __forceinline VOID WRITE_REGISTER_NOFENCE_ULONG ( _In_ _Notliteral_ volatile ULONG *Register, _In_ ULONG Value ) { WriteULongNoFence(Register, Value); return; } __forceinline VOID WRITE_REGISTER_NOFENCE_ULONG64 ( _In_ _Notliteral_ volatile ULONG64 *Register, _In_ ULONG64 Value ) { WriteULong64NoFence(Register, Value); return; } __forceinline VOID WRITE_REGISTER_NOFENCE_BUFFER_UCHAR ( _Out_writes_(Count) _Notliteral_ volatile UCHAR *Register, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ) { volatile UCHAR *registerBuffer = Register; PUCHAR writeBuffer = Buffer; ULONG writeCount; for (writeCount = Count; writeCount--; writeBuffer++, registerBuffer++) { WriteUCharNoFence(registerBuffer, *writeBuffer); } return; } __forceinline VOID WRITE_REGISTER_NOFENCE_BUFFER_USHORT ( _Out_writes_(Count) _Notliteral_ volatile USHORT *Register, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ) { volatile USHORT *registerBuffer = Register; PUSHORT writeBuffer = Buffer; ULONG writeCount; for (writeCount = Count; writeCount--; writeBuffer++, registerBuffer++) { WriteUShortNoFence(registerBuffer, *writeBuffer); } return; } __forceinline VOID WRITE_REGISTER_NOFENCE_BUFFER_ULONG ( _Out_writes_(Count) _Notliteral_ volatile ULONG *Register, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ) { volatile ULONG *registerBuffer = Register; PULONG writeBuffer = Buffer; ULONG writeCount; for (writeCount = Count; writeCount--; writeBuffer++, registerBuffer++) { WriteULongNoFence(registerBuffer, *writeBuffer); } return; } __forceinline VOID WRITE_REGISTER_NOFENCE_BUFFER_ULONG64 ( _Out_writes_(Count) _Notliteral_ volatile ULONG64 *Register, _In_reads_(Count) PULONG64 Buffer, _In_ ULONG Count ) { volatile ULONG64 *registerBuffer = Register; PULONG64 writeBuffer = Buffer; ULONG writeCount; for (writeCount = Count; writeCount--; writeBuffer++, registerBuffer++) { WriteULong64NoFence(registerBuffer, *writeBuffer); } return; } __forceinline VOID REGISTER_FENCE ( VOID ) { _DataSynchronizationBarrier(); } __forceinline UCHAR READ_REGISTER_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register ) { UCHAR Value; _DataSynchronizationBarrier(); Value = READ_REGISTER_NOFENCE_UCHAR(Register); return Value; } __forceinline USHORT READ_REGISTER_USHORT ( _In_ _Notliteral_ volatile USHORT *Register ) { USHORT Value; _DataSynchronizationBarrier(); Value = READ_REGISTER_NOFENCE_USHORT(Register); return Value; } __forceinline ULONG READ_REGISTER_ULONG ( _In_ _Notliteral_ volatile ULONG *Register ) { ULONG Value; _DataSynchronizationBarrier(); Value = READ_REGISTER_NOFENCE_ULONG(Register); return Value; } __forceinline ULONG64 READ_REGISTER_ULONG64 ( _In_ _Notliteral_ volatile ULONG64 *Register ) { ULONG64 Value; _DataSynchronizationBarrier(); Value = READ_REGISTER_NOFENCE_ULONG64(Register); return Value; } __forceinline VOID READ_REGISTER_BUFFER_UCHAR ( _In_reads_(Count) _Notliteral_ volatile UCHAR *Register, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); READ_REGISTER_NOFENCE_BUFFER_UCHAR(Register, Buffer, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_USHORT ( _In_reads_(Count) _Notliteral_ volatile USHORT *Register, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); READ_REGISTER_NOFENCE_BUFFER_USHORT(Register, Buffer, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_ULONG ( _In_reads_(Count) _Notliteral_ volatile ULONG *Register, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); READ_REGISTER_NOFENCE_BUFFER_ULONG(Register, Buffer, Count); return; } __forceinline VOID READ_REGISTER_BUFFER_ULONG64 ( _In_reads_(Count) _Notliteral_ volatile ULONG64 *Register, _Out_writes_all_(Count) PULONG64 Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); READ_REGISTER_NOFENCE_BUFFER_ULONG64(Register, Buffer, Count); return; } __forceinline VOID WRITE_REGISTER_UCHAR ( _In_ _Notliteral_ volatile UCHAR *Register, _In_ UCHAR Value ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_UCHAR(Register, Value); return; } __forceinline VOID WRITE_REGISTER_USHORT ( _In_ _Notliteral_ volatile USHORT *Register, _In_ USHORT Value ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_USHORT(Register, Value); return; } __forceinline VOID WRITE_REGISTER_ULONG ( _In_ _Notliteral_ volatile ULONG *Register, _In_ ULONG Value ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_ULONG(Register, Value); return; } __forceinline VOID WRITE_REGISTER_ULONG64 ( _In_ _Notliteral_ volatile ULONG64 *Register, _In_ ULONG64 Value ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_ULONG64(Register, Value); return; } __forceinline VOID WRITE_REGISTER_BUFFER_UCHAR ( _Out_writes_(Count) _Notliteral_ volatile UCHAR *Register, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_BUFFER_UCHAR(Register, Buffer, Count); return; } __forceinline VOID WRITE_REGISTER_BUFFER_USHORT ( _Out_writes_(Count) _Notliteral_ volatile USHORT *Register, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_BUFFER_USHORT(Register, Buffer, Count); return; } __forceinline VOID WRITE_REGISTER_BUFFER_ULONG ( _Out_writes_(Count) _Notliteral_ volatile ULONG *Register, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_BUFFER_ULONG(Register, Buffer, Count); return; } __forceinline VOID WRITE_REGISTER_BUFFER_ULONG64 ( _Out_writes_(Count) _Notliteral_ volatile ULONG64 *Register, _In_reads_(Count) PULONG64 Buffer, _In_ ULONG Count ) { _DataSynchronizationBarrier(); WRITE_REGISTER_NOFENCE_BUFFER_ULONG64(Register, Buffer, Count); return; } NTHALAPI UCHAR READ_PORT_UCHAR ( _In_ _Notliteral_ PUCHAR Port ); NTHALAPI USHORT READ_PORT_USHORT ( _In_ _Notliteral_ PUSHORT Port ); NTHALAPI ULONG READ_PORT_ULONG ( _In_ _Notliteral_ PULONG Port ); NTHALAPI VOID READ_PORT_BUFFER_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _Out_writes_all_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTHALAPI VOID READ_PORT_BUFFER_USHORT ( _In_ _Notliteral_ PUSHORT Port, _Out_writes_all_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTHALAPI VOID READ_PORT_BUFFER_ULONG ( _In_ _Notliteral_ PULONG Port, _Out_writes_all_(Count) PULONG Buffer, _In_ ULONG Count ); NTHALAPI VOID WRITE_PORT_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _In_ UCHAR Value ); NTHALAPI VOID WRITE_PORT_USHORT ( _In_ _Notliteral_ PUSHORT Port, _In_ USHORT Value ); NTHALAPI VOID WRITE_PORT_ULONG ( _In_ _Notliteral_ PULONG Port, _In_ ULONG Value ); NTHALAPI VOID WRITE_PORT_BUFFER_UCHAR ( _In_ _Notliteral_ PUCHAR Port, _In_reads_(Count) PUCHAR Buffer, _In_ ULONG Count ); NTHALAPI VOID WRITE_PORT_BUFFER_USHORT ( _In_ _Notliteral_ PUSHORT Port, _In_reads_(Count) PUSHORT Buffer, _In_ ULONG Count ); NTHALAPI VOID WRITE_PORT_BUFFER_ULONG ( _In_ _Notliteral_ PULONG Port, _In_reads_(Count) PULONG Buffer, _In_ ULONG Count ); #ifdef __cplusplus } #endif #endif // // Get data cache fill size. // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(KeGetDcacheFillSize) // Use GetDmaAlignment #endif #define KeGetDcacheFillSize() 1L VOID KeFlushIoBuffers( _In_ PMDL Mdl, _In_ BOOLEAN ReadOperation, _In_ BOOLEAN DmaOperation ); #define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql)) #define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql)) #define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock) #define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock) // // Definitions for MIDR Register e.g. ID and cache information // typedef union _ARM64_IDCODE { ULONG64 Ulong; struct { ULONG64 MinorRevision : 4; ULONG64 Model : 12; ULONG64 Architecture : 4; ULONG64 Revision : 4; ULONG64 Implementer : 8; ULONG64 Reserved : 32; }; } ARM64_IDCODE, *PARM64_IDCODE; C_ASSERT(sizeof(ARM64_IDCODE) == 8); // // Dummy nonvolatile floating state structure. // typedef struct _KFLOATING_SAVE { ULONG Dummy; } KFLOATING_SAVE, *PKFLOATING_SAVE; #define MmGetProcedureAddress(Address) (Address) #define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address) #define ARM64_PCR_RESERVED_MASK 0xFFF #define KIPCR() ((ULONG_PTR)(_ReadStatusReg(ARM64_TPIDR_EL1)) & ~ARM64_PCR_RESERVED_MASK) #if (NTDDI_VERSION >= NTDDI_WIN7) CFORCEINLINE ULONG KeGetCurrentProcessorIndex ( VOID ) { return __readx18dword(0x9a4); } #endif #if !defined(_CROSS_PLATFORM_) CFORCEINLINE VOID KeMemoryBarrier ( VOID ) /*++ Routine Description: This function orders memory accesses as seen by other processors. Arguments: None. Return Value: None. --*/ { _ReadWriteBarrier(); MemoryBarrier(); return; } //++ // // VOID // KeMemoryBarrierWithoutFence ( // VOID // ) // // // Routine Description: // // This function instructs the compiler not to reorder loads and stores // across the function invocation. // // Arguments: // // None. // // Return Value: // // None. // //-- #define KeMemoryBarrierWithoutFence() _ReadWriteBarrier() // // Define function to read the value of the time stamp counter. // // N.B. On some platforms (e.g., any non-Intel platform like ARM) // the "timestamp counter" may be backed by QueryPerformanceCounter // or the like, and may not be as low-latency as one might expect. // ULONG64 ReadTimeStampCounter ( VOID ); #else #define KeMemoryBarrier() #define KeMemoryBarrierWithoutFence() #endif #pragma warning(push) #pragma warning(suppress:28104 28161 6001 6101) // PFD can't recognize the implementation _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _When_(return>=0, _Kernel_float_saved_) _At_(*FloatSave, _When_(return>=0, _Kernel_acquires_resource_(FloatState))) __forceinline NTSTATUS KeSaveFloatingPointState ( _Out_ PKFLOATING_SAVE FloatSave ) { UNREFERENCED_PARAMETER(FloatSave); return STATUS_SUCCESS; } #pragma warning(pop) #pragma warning(push) #pragma warning (suppress:28103 28162) // PFD can't recognize the implementation _Success_(1) _IRQL_requires_max_(DISPATCH_LEVEL) _Kernel_float_restored_ _At_(*FloatSave, _Kernel_requires_resource_held_(FloatState) _Kernel_releases_resource_(FloatState)) __forceinline NTSTATUS KeRestoreFloatingPointState ( _In_ PKFLOATING_SAVE FloatSave ) { UNREFERENCED_PARAMETER(FloatSave); return STATUS_SUCCESS; } #pragma warning(pop) #endif // defined(_ARM64_) // // Platform specific kernel fucntions to raise and lower IRQL. // #if defined(_ARM64_) && !defined(MIDL_PASS) _IRQL_requires_max_(HIGH_LEVEL) _IRQL_saves_ NTHALAPI KIRQL KeGetCurrentIrql ( VOID ); _IRQL_requires_max_(HIGH_LEVEL) NTHALAPI VOID KfLowerIrql ( _In_ _IRQL_restores_ _Notliteral_ KIRQL NewIrql ); #define KeLowerIrql(a) KfLowerIrql(a) #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a) NTHALAPI KIRQL _IRQL_requires_max_(HIGH_LEVEL) _IRQL_raises_(NewIrql) _IRQL_saves_ KfRaiseIrql ( _In_ KIRQL NewIrql ); #endif // defined(_ARM64_) && !defined(MIDL_PASS) // begin_access // // Event Specific Access Rights. // #define EVENT_QUERY_STATE 0x0001 #define EVENT_MODIFY_STATE 0x0002 #define EVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3) // // Semaphore Specific Access Rights. // #define SEMAPHORE_QUERY_STATE 0x0001 #define SEMAPHORE_MODIFY_STATE 0x0002 #define SEMAPHORE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3) typedef enum _LOGICAL_PROCESSOR_RELATIONSHIP { RelationProcessorCore, RelationNumaNode, RelationCache, RelationProcessorPackage, RelationGroup, RelationAll = 0xffff } LOGICAL_PROCESSOR_RELATIONSHIP; #define LTP_PC_SMT 0x1 typedef enum _PROCESSOR_CACHE_TYPE { CacheUnified, CacheInstruction, CacheData, CacheTrace } PROCESSOR_CACHE_TYPE; #define CACHE_FULLY_ASSOCIATIVE 0xFF typedef struct _CACHE_DESCRIPTOR { UCHAR Level; UCHAR Associativity; USHORT LineSize; ULONG Size; PROCESSOR_CACHE_TYPE Type; } CACHE_DESCRIPTOR, *PCACHE_DESCRIPTOR; typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION { ULONG_PTR ProcessorMask; LOGICAL_PROCESSOR_RELATIONSHIP Relationship; union { struct { UCHAR Flags; } ProcessorCore; struct { ULONG NodeNumber; } NumaNode; CACHE_DESCRIPTOR Cache; ULONGLONG Reserved[2]; } DUMMYUNIONNAME; } SYSTEM_LOGICAL_PROCESSOR_INFORMATION, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION; typedef struct _PROCESSOR_RELATIONSHIP { UCHAR Flags; UCHAR EfficiencyClass; UCHAR Reserved[20]; USHORT GroupCount; _Field_size_(GroupCount) GROUP_AFFINITY GroupMask[ANYSIZE_ARRAY]; } PROCESSOR_RELATIONSHIP, *PPROCESSOR_RELATIONSHIP; typedef struct _NUMA_NODE_RELATIONSHIP { ULONG NodeNumber; UCHAR Reserved[20]; GROUP_AFFINITY GroupMask; } NUMA_NODE_RELATIONSHIP, *PNUMA_NODE_RELATIONSHIP; typedef struct _CACHE_RELATIONSHIP { UCHAR Level; UCHAR Associativity; USHORT LineSize; ULONG CacheSize; PROCESSOR_CACHE_TYPE Type; UCHAR Reserved[20]; GROUP_AFFINITY GroupMask; } CACHE_RELATIONSHIP, *PCACHE_RELATIONSHIP; typedef struct _PROCESSOR_GROUP_INFO { UCHAR MaximumProcessorCount; UCHAR ActiveProcessorCount; UCHAR Reserved[38]; KAFFINITY ActiveProcessorMask; } PROCESSOR_GROUP_INFO, *PPROCESSOR_GROUP_INFO; typedef struct _GROUP_RELATIONSHIP { USHORT MaximumGroupCount; USHORT ActiveGroupCount; UCHAR Reserved[20]; PROCESSOR_GROUP_INFO GroupInfo[ANYSIZE_ARRAY]; } GROUP_RELATIONSHIP, *PGROUP_RELATIONSHIP; _Struct_size_bytes_(Size) struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX { LOGICAL_PROCESSOR_RELATIONSHIP Relationship; ULONG Size; union { PROCESSOR_RELATIONSHIP Processor; NUMA_NODE_RELATIONSHIP NumaNode; CACHE_RELATIONSHIP Cache; GROUP_RELATIONSHIP Group; } DUMMYUNIONNAME; }; typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX; typedef enum _CPU_SET_INFORMATION_TYPE { CpuSetInformation } CPU_SET_INFORMATION_TYPE, *PCPU_SET_INFORMATION_TYPE; _Struct_size_bytes_(Size) struct _SYSTEM_CPU_SET_INFORMATION { ULONG Size; CPU_SET_INFORMATION_TYPE Type; union { struct { ULONG Id; USHORT Group; UCHAR LogicalProcessorIndex; UCHAR CoreIndex; UCHAR LastLevelCacheIndex; UCHAR NumaNodeIndex; UCHAR EfficiencyClass; union { #define SYSTEM_CPU_SET_INFORMATION_PARKED 0x1 #define SYSTEM_CPU_SET_INFORMATION_ALLOCATED 0x2 #define SYSTEM_CPU_SET_INFORMATION_ALLOCATED_TO_TARGET_PROCESS 0x4 #define SYSTEM_CPU_SET_INFORMATION_REALTIME 0x8 UCHAR AllFlags; struct { UCHAR Parked : 1; UCHAR Allocated : 1; UCHAR AllocatedToTargetProcess : 1; UCHAR RealTime : 1; UCHAR ReservedFlags : 4; } DUMMYSTRUCTNAME; } DUMMYUNIONNAME2; ULONG Reserved; ULONG64 AllocationTag; } CpuSet; } DUMMYUNIONNAME; }; typedef struct _SYSTEM_CPU_SET_INFORMATION SYSTEM_CPU_SET_INFORMATION, *PSYSTEM_CPU_SET_INFORMATION; // // Defined processor features // #define PF_FLOATING_POINT_PRECISION_ERRATA 0 #define PF_FLOATING_POINT_EMULATED 1 #define PF_COMPARE_EXCHANGE_DOUBLE 2 #define PF_MMX_INSTRUCTIONS_AVAILABLE 3 #define PF_PPC_MOVEMEM_64BIT_OK 4 #define PF_ALPHA_BYTE_INSTRUCTIONS 5 #define PF_XMMI_INSTRUCTIONS_AVAILABLE 6 #define PF_3DNOW_INSTRUCTIONS_AVAILABLE 7 #define PF_RDTSC_INSTRUCTION_AVAILABLE 8 #define PF_PAE_ENABLED 9 #define PF_XMMI64_INSTRUCTIONS_AVAILABLE 10 #define PF_SSE_DAZ_MODE_AVAILABLE 11 #define PF_NX_ENABLED 12 #define PF_SSE3_INSTRUCTIONS_AVAILABLE 13 #define PF_COMPARE_EXCHANGE128 14 #define PF_COMPARE64_EXCHANGE128 15 #define PF_CHANNELS_ENABLED 16 #define PF_XSAVE_ENABLED 17 #define PF_ARM_VFP_32_REGISTERS_AVAILABLE 18 #define PF_ARM_NEON_INSTRUCTIONS_AVAILABLE 19 #define PF_SECOND_LEVEL_ADDRESS_TRANSLATION 20 #define PF_VIRT_FIRMWARE_ENABLED 21 #define PF_RDWRFSGSBASE_AVAILABLE 22 #define PF_FASTFAIL_AVAILABLE 23 #define PF_ARM_DIVIDE_INSTRUCTION_AVAILABLE 24 #define PF_ARM_64BIT_LOADSTORE_ATOMIC 25 #define PF_ARM_EXTERNAL_CACHE_AVAILABLE 26 #define PF_ARM_FMAC_INSTRUCTIONS_AVAILABLE 27 #define PF_RDRAND_INSTRUCTION_AVAILABLE 28 #define PF_ARM_V8_INSTRUCTIONS_AVAILABLE 29 #define PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE 30 #define PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE 31 #define PF_RDTSCP_INSTRUCTION_AVAILABLE 32 typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE { StandardDesign, // None == 0 == standard design NEC98x86, // NEC PC98xx series on X86 EndAlternatives // past end of known alternatives } ALTERNATIVE_ARCHITECTURE_TYPE; // correctly define these run-time definitions for non X86 machines #ifndef _X86_ #ifndef IsNEC_98 #define IsNEC_98 (FALSE) #endif #ifndef IsNotNEC_98 #define IsNotNEC_98 (TRUE) #endif #ifndef SetNEC_98 #define SetNEC_98 #endif #ifndef SetNotNEC_98 #define SetNotNEC_98 #endif #endif // _X86_ #define PROCESSOR_FEATURE_MAX 64 // // Exception flag definitions. // #define EXCEPTION_NONCONTINUABLE 0x1 // Noncontinuable exception #define EXCEPTION_UNWINDING 0x2 // Unwind is in progress #define EXCEPTION_EXIT_UNWIND 0x4 // Exit unwind is in progress #define EXCEPTION_STACK_INVALID 0x8 // Stack out of limits or unaligned #define EXCEPTION_NESTED_CALL 0x10 // Nested exception handler call #define EXCEPTION_TARGET_UNWIND 0x20 // Target unwind in progress #define EXCEPTION_COLLIDED_UNWIND 0x40 // Collided exception handler call #define EXCEPTION_UNWIND (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND | \ EXCEPTION_TARGET_UNWIND | EXCEPTION_COLLIDED_UNWIND) #define IS_UNWINDING(Flag) ((Flag & EXCEPTION_UNWIND) != 0) #define IS_DISPATCHING(Flag) ((Flag & EXCEPTION_UNWIND) == 0) #define IS_TARGET_UNWIND(Flag) (Flag & EXCEPTION_TARGET_UNWIND) // // Define maximum number of exception parameters. // #define EXCEPTION_MAXIMUM_PARAMETERS 15 // maximum number of exception parameters // // Exception record definition. // typedef struct _EXCEPTION_RECORD { NTSTATUS ExceptionCode; ULONG ExceptionFlags; struct _EXCEPTION_RECORD *ExceptionRecord; PVOID ExceptionAddress; ULONG NumberParameters; ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; } EXCEPTION_RECORD; typedef EXCEPTION_RECORD *PEXCEPTION_RECORD; typedef struct _EXCEPTION_RECORD32 { NTSTATUS ExceptionCode; ULONG ExceptionFlags; ULONG ExceptionRecord; ULONG ExceptionAddress; ULONG NumberParameters; ULONG ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; } EXCEPTION_RECORD32, *PEXCEPTION_RECORD32; typedef struct _EXCEPTION_RECORD64 { NTSTATUS ExceptionCode; ULONG ExceptionFlags; ULONG64 ExceptionRecord; ULONG64 ExceptionAddress; ULONG NumberParameters; ULONG __unusedAlignment; ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; } EXCEPTION_RECORD64, *PEXCEPTION_RECORD64; // // Typedef for pointer returned by exception_info() // typedef struct _EXCEPTION_POINTERS { PEXCEPTION_RECORD ExceptionRecord; PCONTEXT ContextRecord; } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS; #define THREAD_WAIT_OBJECTS 3 // Builtin usable wait blocks // // Several routines have an architecture specific implementation. Generate // an error if a supported target is not defined. // #if !(defined(_X86_) || defined(_AMD64_) || defined(_ARM_) || defined(_ARM64_)) #error "No target architecture defined" #endif #if (NTDDI_VERSION < NTDDI_WIN7) || defined(_X86_) || !defined(NT_PROCESSOR_GROUPS) #define SINGLE_GROUP_LEGACY_API 1 #endif // // Interrupt modes. // typedef enum _KINTERRUPT_MODE { LevelSensitive, Latched } KINTERRUPT_MODE; typedef enum _KINTERRUPT_POLARITY { InterruptPolarityUnknown, InterruptActiveHigh, InterruptRisingEdge = InterruptActiveHigh, InterruptActiveLow, InterruptFallingEdge = InterruptActiveLow, #if (NTDDI_VERSION >= NTDDI_WIN8) InterruptActiveBoth, #endif #if (NTDDI_VERSION >= NTDDI_WINBLUE) InterruptActiveBothTriggerLow = InterruptActiveBoth, InterruptActiveBothTriggerHigh, #endif } KINTERRUPT_POLARITY, *PKINTERRUPT_POLARITY; // // Wait reasons // typedef enum _KWAIT_REASON { Executive, FreePage, PageIn, PoolAllocation, DelayExecution, Suspended, UserRequest, WrExecutive, WrFreePage, WrPageIn, WrPoolAllocation, WrDelayExecution, WrSuspended, WrUserRequest, WrSpare0, WrQueue, WrLpcReceive, WrLpcReply, WrVirtualMemory, WrPageOut, WrRendezvous, WrKeyedEvent, WrTerminated, WrProcessInSwap, WrCpuRateControl, WrCalloutStack, WrKernel, WrResource, WrPushLock, WrMutex, WrQuantumEnd, WrDispatchInt, WrPreempted, WrYieldExecution, WrFastMutex, WrGuardedMutex, WrRundown, WrAlertByThreadId, WrDeferredPreempt, MaximumWaitReason } KWAIT_REASON; typedef struct _KWAIT_BLOCK { LIST_ENTRY WaitListEntry; UCHAR WaitType; volatile UCHAR BlockState; USHORT WaitKey; #if defined(_WIN64) LONG SpareLong; #endif union { struct _KTHREAD *Thread; struct _KQUEUE *NotificationQueue; }; PVOID Object; PVOID SparePtr; } KWAIT_BLOCK, *PKWAIT_BLOCK, *PRKWAIT_BLOCK; // // Thread start function // typedef _IRQL_requires_same_ _Function_class_(KSTART_ROUTINE) VOID KSTART_ROUTINE ( _In_ PVOID StartContext ); typedef KSTART_ROUTINE *PKSTART_ROUTINE; // // Kernel object structure definitions // // // Device Queue object and entry // #define ASSERT_DEVICE_QUEUE(E) NT_ASSERT((E)->Type == DeviceQueueObject) typedef struct _KDEVICE_QUEUE { CSHORT Type; CSHORT Size; LIST_ENTRY DeviceListHead; KSPIN_LOCK Lock; #if defined(_AMD64_) union { BOOLEAN Busy; struct { LONG64 Reserved : 8; LONG64 Hint : 56; }; }; #else BOOLEAN Busy; #endif } KDEVICE_QUEUE, *PKDEVICE_QUEUE, *PRKDEVICE_QUEUE; typedef struct _KDEVICE_QUEUE_ENTRY { LIST_ENTRY DeviceListEntry; ULONG SortKey; BOOLEAN Inserted; } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY, *PRKDEVICE_QUEUE_ENTRY; // // Define the interrupt service function type and the empty struct // type. // typedef _Function_class_(KSERVICE_ROUTINE) _IRQL_requires_(HIGH_LEVEL) // HIGH_LEVEL is best approximation of DIRQL _IRQL_requires_same_ BOOLEAN KSERVICE_ROUTINE ( _In_ struct _KINTERRUPT *Interrupt, _In_opt_ PVOID ServiceContext ); typedef KSERVICE_ROUTINE *PKSERVICE_ROUTINE; typedef _Function_class_(KMESSAGE_SERVICE_ROUTINE) _IRQL_requires_same_ BOOLEAN KMESSAGE_SERVICE_ROUTINE ( _In_ struct _KINTERRUPT *Interrupt, _In_ PVOID ServiceContext, _In_ ULONG MessageID ); typedef KMESSAGE_SERVICE_ROUTINE *PKMESSAGE_SERVICE_ROUTINE; // // Mutant object // typedef struct _KMUTANT { DISPATCHER_HEADER Header; LIST_ENTRY MutantListEntry; struct _KTHREAD *OwnerThread; BOOLEAN Abandoned; UCHAR ApcDisable; } KMUTANT, *PKMUTANT, *PRKMUTANT, KMUTEX, *PKMUTEX, *PRKMUTEX; // // // Semaphore object // // N.B. The limit field must be the last member of this structure. // typedef struct _KSEMAPHORE { DISPATCHER_HEADER Header; LONG Limit; } KSEMAPHORE, *PKSEMAPHORE, *PRKSEMAPHORE; #define KSEMAPHORE_ACTUAL_LENGTH \ (FIELD_OFFSET(KSEMAPHORE, Limit) + sizeof(LONG)) // // DPC object // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID KeInitializeDpc ( _Out_ __drv_aliasesMem PRKDPC Dpc, _In_ PKDEFERRED_ROUTINE DeferredRoutine, _In_opt_ __drv_aliasesMem PVOID DeferredContext ); #endif #if (NTDDI_VERSION >= NTDDI_WS03) NTKERNELAPI VOID KeInitializeThreadedDpc ( _Out_ PRKDPC Dpc, _In_ PKDEFERRED_ROUTINE DeferredRoutine, _In_opt_ PVOID DeferredContext ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI BOOLEAN KeInsertQueueDpc ( _Inout_ PRKDPC Dpc, _In_opt_ PVOID SystemArgument1, _In_opt_ __drv_aliasesMem PVOID SystemArgument2 ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(HIGH_LEVEL) NTKERNELAPI BOOLEAN KeRemoveQueueDpc ( _Inout_ PRKDPC Dpc ); #endif #if (NTDDI_VERSION >= NTDDI_WINBLUE) _IRQL_requires_max_(HIGH_LEVEL) NTKERNELAPI BOOLEAN KeRemoveQueueDpcEx ( _Inout_ PRKDPC Dpc, _In_ BOOLEAN WaitIfActive ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTKERNELAPI NTSTATUS KeInitializeCrashDumpHeader( _In_ ULONG DumpType, _In_ ULONG Flags, _Out_writes_bytes_(BufferSize) PVOID Buffer, _In_ ULONG BufferSize, _Out_opt_ PULONG BufferNeeded ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID KeSetImportanceDpc ( _Inout_ PRKDPC Dpc, _In_ KDPC_IMPORTANCE Importance ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) && defined(SINGLE_GROUP_LEGACY_API) NTKERNELAPI VOID KeSetTargetProcessorDpc ( _Inout_ PRKDPC Dpc, _In_ CCHAR Number ); #endif #if (NTDDI_VERSION >= NTDDI_WINXPSP2) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeFlushQueuedDpcs ( VOID ); #endif // // Device queue object // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID KeInitializeDeviceQueue ( _Out_ PKDEVICE_QUEUE DeviceQueue ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeInsertDeviceQueue ( _Inout_ PKDEVICE_QUEUE DeviceQueue, _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeInsertByKeyDeviceQueue ( _Inout_ PKDEVICE_QUEUE DeviceQueue, _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry, _In_ ULONG SortKey ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI PKDEVICE_QUEUE_ENTRY KeRemoveDeviceQueue ( _Inout_ PKDEVICE_QUEUE DeviceQueue ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI PKDEVICE_QUEUE_ENTRY KeRemoveByKeyDeviceQueue ( _Inout_ PKDEVICE_QUEUE DeviceQueue, _In_ ULONG SortKey ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI PKDEVICE_QUEUE_ENTRY KeRemoveByKeyDeviceQueueIfBusy ( _Inout_ PKDEVICE_QUEUE DeviceQueue, _In_ ULONG SortKey ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeRemoveEntryDeviceQueue ( _Inout_ PKDEVICE_QUEUE DeviceQueue, _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(HIGH_LEVEL) // HIGH_LEVEL is best approximation of DIRQL NTKERNELAPI BOOLEAN KeSynchronizeExecution ( _Inout_ PKINTERRUPT Interrupt, _In_ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, _In_opt_ __drv_aliasesMem PVOID SynchronizeContext ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Requires_lock_not_held_(*Interrupt->ActualLock) _Acquires_lock_(*Interrupt->ActualLock) _IRQL_requires_max_(HIGH_LEVEL) // HIGH_LEVEL is best approximation of DIRQL _IRQL_saves_ _IRQL_raises_(HIGH_LEVEL) // HIGH_LEVEL is best approximation of DIRQL NTKERNELAPI KIRQL KeAcquireInterruptSpinLock ( _Inout_ PKINTERRUPT Interrupt ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Requires_lock_held_(*Interrupt->ActualLock) _Releases_lock_(*Interrupt->ActualLock) _IRQL_requires_(HIGH_LEVEL) // HIGH_LEVEL is best approximation of DIRQL NTKERNELAPI VOID KeReleaseInterruptSpinLock ( _Inout_ PKINTERRUPT Interrupt, _In_ _IRQL_restores_ KIRQL OldIrql ); #endif // // Kernel dispatcher object functions // // Event Object // NTKERNELAPI VOID KeInitializeEvent ( _Out_ PRKEVENT Event, _In_ EVENT_TYPE Type, _In_ BOOLEAN State ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID KeClearEvent ( _Inout_ PRKEVENT Event ); #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG KeReadStateEvent ( _In_ PRKEVENT Event ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG KeResetEvent ( _Inout_ PRKEVENT Event ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(Wait==1, _IRQL_requires_max_(APC_LEVEL)) _When_(Wait==1, __drv_reportError("Caution: 'Wait' argument does not provide" " any synchronization guarantees, only a hint" " to the system that the thread will immediately" " issue a wait operation")) NTKERNELAPI LONG KeSetEvent ( _Inout_ PRKEVENT Event, _In_ KPRIORITY Increment, _In_ _Literal_ BOOLEAN Wait ); #endif // // Mutex object // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID KeInitializeMutex ( _Out_ PRKMUTEX Mutex, _In_ ULONG Level ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG KeReadStateMutex ( _In_ PRKMUTEX Mutex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(Wait==1, _IRQL_requires_max_(APC_LEVEL)) _When_(Wait==1, __drv_reportError("Caution: 'Wait' argument does not provide" " any synchronization guarantees, only a hint" " to the system that the thread will immediately" " issue a wait operation")) NTKERNELAPI LONG KeReleaseMutex ( _Inout_ PRKMUTEX Mutex, _In_ BOOLEAN Wait ); #endif // // Semaphore object // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID KeInitializeSemaphore ( _Out_ PRKSEMAPHORE Semaphore, _In_ LONG Count, _In_ LONG Limit ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG KeReadStateSemaphore ( _In_ PRKSEMAPHORE Semaphore ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(Wait==1, _IRQL_requires_max_(APC_LEVEL)) _When_(Wait==1, __drv_reportError("Caution: 'Wait' argument does not provide" " any synchronization guarantees, only a hint" " to the system that the thread will immediately" " issue a wait operation")) NTKERNELAPI LONG KeReleaseSemaphore ( _Inout_ PRKSEMAPHORE Semaphore, _In_ KPRIORITY Increment, _In_ LONG Adjustment, _In_ _Literal_ BOOLEAN Wait ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS KeDelayExecutionThread ( _In_ KPROCESSOR_MODE WaitMode, _In_ BOOLEAN Alertable, _In_ PLARGE_INTEGER Interval ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI KPRIORITY KeQueryPriorityThread ( _In_ PKTHREAD Thread ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI ULONG KeQueryRuntimeThread ( _In_ PKTHREAD Thread, _Out_ PULONG UserTime ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_same_ ULONG64 KeQueryTotalCycleTimeThread ( _Inout_ PKTHREAD Thread, _Out_ PULONG64 CycleTimeStamp ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _Must_inspect_result_ NTKERNELAPI NTSTATUS KeSetTargetProcessorDpcEx ( _Inout_ PKDPC Dpc, _In_ PPROCESSOR_NUMBER ProcNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) && defined(SINGLE_GROUP_LEGACY_API) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeRevertToUserAffinityThread ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) && defined(SINGLE_GROUP_LEGACY_API) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeSetSystemAffinityThread ( _In_ KAFFINITY Affinity ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) && defined(SINGLE_GROUP_LEGACY_API) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeRevertToUserAffinityThreadEx ( _In_ KAFFINITY Affinity ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeSetSystemGroupAffinityThread ( _In_ PGROUP_AFFINITY Affinity, _Out_opt_ PGROUP_AFFINITY PreviousAffinity ); _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeRevertToUserGroupAffinityThread ( _In_ PGROUP_AFFINITY PreviousAffinity ); #endif #if (NTDDI_VERSION >= NTDDI_LONGHORN) && defined(SINGLE_GROUP_LEGACY_API) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI KAFFINITY KeSetSystemAffinityThreadEx ( _In_ KAFFINITY Affinity ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI KPRIORITY KeSetPriorityThread ( _Inout_ PKTHREAD Thread, _In_ KPRIORITY Priority ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Acquires_lock_(_Global_critical_region_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeEnterCriticalRegion ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Releases_lock_(_Global_critical_region_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeLeaveCriticalRegion ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Acquires_lock_(_Global_critical_region_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeEnterGuardedRegion ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Releases_lock_(_Global_critical_region_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID KeLeaveGuardedRegion ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeAreApcsDisabled ( VOID ); #endif // // Timer object // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID KeInitializeTimer ( _Out_ PKTIMER Timer ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID KeInitializeTimerEx ( _Out_ PKTIMER Timer, _In_ TIMER_TYPE Type ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeCancelTimer ( _Inout_ PKTIMER ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeReadStateTimer ( _In_ PKTIMER Timer ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeSetTimer ( _Inout_ PKTIMER Timer, _In_ LARGE_INTEGER DueTime, _In_opt_ PKDPC Dpc ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeSetTimerEx ( _Inout_ PKTIMER Timer, _In_ LARGE_INTEGER DueTime, _In_ LONG Period, _In_opt_ PKDPC Dpc ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeSetCoalescableTimer ( _Inout_ PKTIMER Timer, _In_ LARGE_INTEGER DueTime, _In_ ULONG Period, _In_ ULONG TolerableDelay, _In_opt_ PKDPC Dpc ); #endif #define KeWaitForMutexObject KeWaitForSingleObject #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_min_(PASSIVE_LEVEL) _When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL)) _When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL)) NTKERNELAPI NTSTATUS KeWaitForMultipleObjects ( _In_ ULONG Count, _In_reads_(Count) PVOID Object[], _In_ _Strict_type_match_ WAIT_TYPE WaitType, _In_ _Strict_type_match_ KWAIT_REASON WaitReason, _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout, _Out_opt_ PKWAIT_BLOCK WaitBlockArray ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_min_(PASSIVE_LEVEL) _When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL)) _When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL)) NTKERNELAPI NTSTATUS KeWaitForSingleObject ( _In_ _Points_to_data_ PVOID Object, _In_ _Strict_type_match_ KWAIT_REASON WaitReason, _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout ); #endif // // Define interprocess interrupt generic call types. // typedef _IRQL_requires_same_ _Function_class_(KIPI_BROADCAST_WORKER) _IRQL_requires_(IPI_LEVEL) ULONG_PTR KIPI_BROADCAST_WORKER ( _In_ ULONG_PTR Argument ); typedef KIPI_BROADCAST_WORKER *PKIPI_BROADCAST_WORKER; #if (NTDDI_VERSION >= NTDDI_WS03) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(IPI_LEVEL-1) NTKERNELAPI ULONG_PTR KeIpiGenericCall ( _In_ PKIPI_BROADCAST_WORKER BroadcastFunction, _In_ ULONG_PTR Context ); #endif // // Spin lock functions // #if ((defined(_X86_) && (defined(_WDM_INCLUDED_) || defined(WIN9X_COMPAT_SPINLOCK))) || \ ((NTDDI_VERSION > NTDDI_WIN7) && !defined(WIN9X_COMPAT_SPINLOCK) && \ (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_) || defined(_BLDR_)))) #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID NTAPI KeInitializeSpinLock ( _Out_ PKSPIN_LOCK SpinLock ); #endif #else CFORCEINLINE VOID NTAPI KzInitializeSpinLock ( _Out_ PKSPIN_LOCK SpinLock ) /*++ Routine Description: This function initializes a spinlock. Arguments: SpinLock - Supplies a pointer to a spinlock. Return Value: None. --*/ { *SpinLock = 0; return; } #define KeInitializeSpinLock KzInitializeSpinLock #endif #if (NTDDI_VERSION >= NTDDI_WS03) _Must_inspect_result_ NTKERNELAPI BOOLEAN FASTCALL KeTestSpinLock ( _In_ PKSPIN_LOCK SpinLock ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Must_inspect_result_ _IRQL_requires_min_(DISPATCH_LEVEL) _Post_satisfies_(return == 1 || return == 0) NTKERNELAPI BOOLEAN FASTCALL KeTryToAcquireSpinLockAtDpcLevel ( _Inout_ _Requires_lock_not_held_(*_Curr_) _When_(return!=0, _Acquires_lock_(*_Curr_)) PKSPIN_LOCK SpinLock ); #endif #if defined(_X86_) // ntifs #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_not_held_(*SpinLock) _Acquires_lock_(*SpinLock) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KefAcquireSpinLockAtDpcLevel ( _Inout_ PKSPIN_LOCK SpinLock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_held_(*SpinLock) _Releases_lock_(*SpinLock) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KefReleaseSpinLockFromDpcLevel ( _Inout_ PKSPIN_LOCK SpinLock ); #endif #define KeAcquireSpinLockAtDpcLevel(a) KefAcquireSpinLockAtDpcLevel(a) #define KeReleaseSpinLockFromDpcLevel(a) KefReleaseSpinLockFromDpcLevel(a) #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_not_held_(*SpinLock) _Acquires_lock_(*SpinLock) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_saves_ _IRQL_raises_(DISPATCH_LEVEL) NTKERNELAPI KIRQL FASTCALL KfAcquireSpinLock ( _Inout_ PKSPIN_LOCK SpinLock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_held_(*SpinLock) _Releases_lock_(*SpinLock) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KfReleaseSpinLock ( _Inout_ PKSPIN_LOCK SpinLock, _In_ _IRQL_restores_ KIRQL NewIrql ); #endif #define KeAcquireSpinLock(a,b) *(b) = KfAcquireSpinLock(a) #define KeReleaseSpinLock(a,b) KfReleaseSpinLock(a,b) #else // ntifs // // These functions are imported for ARM, ntddk, ntifs, nthal, ntosp, and wdm. // They can be inlined for the system on AMD64. // #define KeAcquireSpinLock(SpinLock, OldIrql) \ *(OldIrql) = KeAcquireSpinLockRaiseToDpc(SpinLock) #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_not_held_(*SpinLock) _Acquires_lock_(*SpinLock) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID KeAcquireSpinLockAtDpcLevel ( _Inout_ PKSPIN_LOCK SpinLock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_not_held_(*SpinLock) _Acquires_lock_(*SpinLock) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_saves_ _IRQL_raises_(DISPATCH_LEVEL) NTKERNELAPI KIRQL KeAcquireSpinLockRaiseToDpc ( _Inout_ PKSPIN_LOCK SpinLock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_held_(*SpinLock) _Releases_lock_(*SpinLock) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI VOID KeReleaseSpinLock ( _Inout_ PKSPIN_LOCK SpinLock, _In_ _IRQL_restores_ KIRQL NewIrql ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_held_(*SpinLock) _Releases_lock_(*SpinLock) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID KeReleaseSpinLockFromDpcLevel ( _Inout_ PKSPIN_LOCK SpinLock ); #endif #endif // ntifs #if (NTDDI_VERSION >= NTDDI_WS03) _Requires_lock_not_held_(*SpinLock) _Acquires_lock_(*SpinLock) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_saves_ NTKERNELAPI KIRQL FASTCALL KeAcquireSpinLockForDpc ( _Inout_ PKSPIN_LOCK SpinLock ); #endif #if (NTDDI_VERSION >= NTDDI_WS03) _Requires_lock_held_(*SpinLock) _Releases_lock_(*SpinLock) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KeReleaseSpinLockForDpc ( _Inout_ PKSPIN_LOCK SpinLock, _In_ _IRQL_restores_ KIRQL OldIrql ); #endif // // Queued spin lock functions for "in stack" lock handles. // // The following three functions RAISE and LOWER IRQL when a queued // in stack spin lock is acquired or released using these routines. // #if (NTDDI_VERSION >= NTDDI_WINXP) _Requires_lock_not_held_(*LockHandle) _Acquires_lock_(*LockHandle) _Post_same_lock_(*SpinLock, *LockHandle) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_saves_global_(QueuedSpinLock,LockHandle) _IRQL_raises_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KeAcquireInStackQueuedSpinLock ( _Inout_ PKSPIN_LOCK SpinLock, _Out_ PKLOCK_QUEUE_HANDLE LockHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Requires_lock_held_(*LockHandle) _Releases_lock_(*LockHandle) _IRQL_requires_(DISPATCH_LEVEL) _IRQL_restores_global_(QueuedSpinLock,LockHandle) NTKERNELAPI VOID FASTCALL KeReleaseInStackQueuedSpinLock ( _In_ PKLOCK_QUEUE_HANDLE LockHandle ); #endif // // The following two functions do NOT raise or lower IRQL when a queued // in stack spin lock is acquired or released using these functions. // #if (NTDDI_VERSION >= NTDDI_WINXP) _Requires_lock_not_held_(*LockHandle) _Acquires_lock_(*LockHandle) _Post_same_lock_(*SpinLock, *LockHandle) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KeAcquireInStackQueuedSpinLockAtDpcLevel ( _Inout_ PKSPIN_LOCK SpinLock, _Out_ PKLOCK_QUEUE_HANDLE LockHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Requires_lock_held_(*LockHandle) _Releases_lock_(*LockHandle) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KeReleaseInStackQueuedSpinLockFromDpcLevel ( _In_ PKLOCK_QUEUE_HANDLE LockHandle ); #endif // // The following two functions conditionally raise or lower IRQL when a // queued in-stack spin lock is acquired or released using these functions. // #if (NTDDI_VERSION >= NTDDI_VISTA) _Requires_lock_not_held_(*LockHandle) _Acquires_lock_(*LockHandle) _Post_same_lock_(*SpinLock, *LockHandle) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_saves_global_(QueuedSpinLock,LockHandle) NTKERNELAPI VOID FASTCALL KeAcquireInStackQueuedSpinLockForDpc ( _Inout_ PKSPIN_LOCK SpinLock, _Out_ PKLOCK_QUEUE_HANDLE LockHandle ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _Requires_lock_held_(*LockHandle) _Releases_lock_(*LockHandle) _IRQL_requires_(DISPATCH_LEVEL) _IRQL_restores_global_(QueuedSpinLock,LockHandle) NTKERNELAPI VOID FASTCALL KeReleaseInStackQueuedSpinLockForDpc ( _In_ PKLOCK_QUEUE_HANDLE LockHandle ); #endif // // Miscellaneous kernel functions // typedef struct _KDPC_WATCHDOG_INFORMATION { ULONG DpcTimeLimit; ULONG DpcTimeCount; ULONG DpcWatchdogLimit; ULONG DpcWatchdogCount; ULONG Reserved; } KDPC_WATCHDOG_INFORMATION, *PKDPC_WATCHDOG_INFORMATION; #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS KeQueryDpcWatchdogInformation ( _Out_ PKDPC_WATCHDOG_INFORMATION WatchdogInformation ); #endif typedef enum _KBUGCHECK_BUFFER_DUMP_STATE { BufferEmpty, BufferInserted, BufferStarted, BufferFinished, BufferIncomplete } KBUGCHECK_BUFFER_DUMP_STATE; typedef _Function_class_(KBUGCHECK_CALLBACK_ROUTINE) _IRQL_requires_same_ VOID KBUGCHECK_CALLBACK_ROUTINE ( IN PVOID Buffer, IN ULONG Length ); typedef KBUGCHECK_CALLBACK_ROUTINE *PKBUGCHECK_CALLBACK_ROUTINE; typedef struct _KBUGCHECK_CALLBACK_RECORD { LIST_ENTRY Entry; PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine; _Field_size_bytes_opt_(Length) PVOID Buffer; ULONG Length; PUCHAR Component; ULONG_PTR Checksum; UCHAR State; } KBUGCHECK_CALLBACK_RECORD, *PKBUGCHECK_CALLBACK_RECORD; #define KeInitializeCallbackRecord(CallbackRecord) \ (CallbackRecord)->State = BufferEmpty #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ NTKERNELAPI BOOLEAN KeDeregisterBugCheckCallback ( _Inout_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ NTKERNELAPI BOOLEAN KeRegisterBugCheckCallback ( _Out_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord, _In_ PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine, _In_reads_bytes_opt_(Length) PVOID Buffer, _In_ ULONG Length, _In_ PUCHAR Component ); #endif typedef enum _KBUGCHECK_CALLBACK_REASON { KbCallbackInvalid, KbCallbackReserved1, KbCallbackSecondaryDumpData, KbCallbackDumpIo, KbCallbackAddPages, KbCallbackSecondaryMultiPartDumpData, KbCallbackRemovePages } KBUGCHECK_CALLBACK_REASON; typedef _Function_class_(KBUGCHECK_REASON_CALLBACK_ROUTINE) _IRQL_requires_same_ VOID KBUGCHECK_REASON_CALLBACK_ROUTINE ( _In_ KBUGCHECK_CALLBACK_REASON Reason, _In_ struct _KBUGCHECK_REASON_CALLBACK_RECORD* Record, _Inout_ PVOID ReasonSpecificData, _In_ ULONG ReasonSpecificDataLength ); typedef KBUGCHECK_REASON_CALLBACK_ROUTINE *PKBUGCHECK_REASON_CALLBACK_ROUTINE; KBUGCHECK_REASON_CALLBACK_ROUTINE BugCheckSecondaryMultiPartDumpDataCallback; typedef struct _KBUGCHECK_REASON_CALLBACK_RECORD { LIST_ENTRY Entry; PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine; PUCHAR Component; ULONG_PTR Checksum; KBUGCHECK_CALLBACK_REASON Reason; UCHAR State; } KBUGCHECK_REASON_CALLBACK_RECORD, *PKBUGCHECK_REASON_CALLBACK_RECORD; typedef struct _KBUGCHECK_SECONDARY_DUMP_DATA { IN PVOID InBuffer; IN ULONG InBufferLength; IN ULONG MaximumAllowed; OUT GUID Guid; OUT PVOID OutBuffer; OUT ULONG OutBufferLength; } KBUGCHECK_SECONDARY_DUMP_DATA, *PKBUGCHECK_SECONDARY_DUMP_DATA; typedef struct _KBUGCHECK_SECONDARY_DUMP_DATA_EX { _In_ PVOID InBuffer; _In_ ULONG InBufferLength; _In_ ULONG MaximumAllowed; _Out_ GUID Guid; _Inout_ PVOID OutBuffer; _Inout_ ULONG OutBufferLength; _Inout_ PVOID Context; _Inout_ ULONG Flags; // KB_SECONDARY_DATA_FLAG_xxx _In_ ULONG DumpType; // DUMP_TYPE defined in ntiodump.h _In_ ULONG BugCheckCode; _In_ ULONG_PTR BugCheckParameter1; _In_ ULONG_PTR BugCheckParameter2; _In_ ULONG_PTR BugCheckParameter3; _In_ ULONG_PTR BugCheckParameter4; } KBUGCHECK_SECONDARY_DUMP_DATA_EX, *PKBUGCHECK_SECONDARY_DUMP_DATA_EX; #define KB_SECONDARY_DATA_FLAG_ADDITIONAL_DATA 0x00000001 #define KB_SECONDARY_DATA_FLAG_NO_DEVICE_ACCESS 0x00000002 typedef enum _KBUGCHECK_DUMP_IO_TYPE { KbDumpIoInvalid, KbDumpIoHeader, KbDumpIoBody, KbDumpIoSecondaryData, KbDumpIoComplete } KBUGCHECK_DUMP_IO_TYPE; typedef struct _KBUGCHECK_DUMP_IO { IN ULONG64 Offset; IN PVOID Buffer; IN ULONG BufferLength; IN KBUGCHECK_DUMP_IO_TYPE Type; } KBUGCHECK_DUMP_IO, *PKBUGCHECK_DUMP_IO; // // KbCallbackAddPages related definitions // #define KB_ADD_PAGES_FLAG_VIRTUAL_ADDRESS 0x00000001UL #define KB_ADD_PAGES_FLAG_PHYSICAL_ADDRESS 0x00000002UL #define KB_ADD_PAGES_FLAG_ADDITIONAL_RANGES_EXIST 0x80000000UL typedef struct _KBUGCHECK_ADD_PAGES { _Inout_ PVOID Context; // Private context for callback use _Inout_ ULONG Flags; // Zero initialized on input _In_ ULONG BugCheckCode; _Out_ ULONG_PTR Address; _Out_ ULONG_PTR Count; } KBUGCHECK_ADD_PAGES, *PKBUGCHECK_ADD_PAGES; // // KbCallbackRemovePages related definitions // #define KB_REMOVE_PAGES_FLAG_VIRTUAL_ADDRESS 0x00000001UL #define KB_REMOVE_PAGES_FLAG_PHYSICAL_ADDRESS 0x00000002UL #define KB_REMOVE_PAGES_FLAG_ADDITIONAL_RANGES_EXIST 0x80000000UL typedef struct _KBUGCHECK_REMOVE_PAGES { _Inout_ PVOID Context; // Private context for callback use _Inout_ ULONG Flags; // Zero initialized on input _In_ ULONG BugCheckCode; _Out_ ULONG_PTR Address; _Out_ ULONG_PTR Count; } KBUGCHECK_REMOVE_PAGES, *PKBUGCHECK_REMOVE_PAGES; // // Equates for exceptions which cause system fatal error // #define EXCEPTION_DIVIDED_BY_ZERO 0 #define EXCEPTION_DEBUG 1 #define EXCEPTION_NMI 2 #define EXCEPTION_INT3 3 #define EXCEPTION_BOUND_CHECK 5 #define EXCEPTION_INVALID_OPCODE 6 #define EXCEPTION_NPX_NOT_AVAILABLE 7 #define EXCEPTION_DOUBLE_FAULT 8 #define EXCEPTION_NPX_OVERRUN 9 #define EXCEPTION_INVALID_TSS 0x0A #define EXCEPTION_SEGMENT_NOT_PRESENT 0x0B #define EXCEPTION_STACK_FAULT 0x0C #define EXCEPTION_GP_FAULT 0x0D #define EXCEPTION_RESERVED_TRAP 0x0F #define EXCEPTION_NPX_ERROR 0x010 #define EXCEPTION_ALIGNMENT_CHECK 0x011 #if (NTDDI_VERSION >= NTDDI_WINXPSP1) _Must_inspect_result_ NTKERNELAPI BOOLEAN KeDeregisterBugCheckReasonCallback ( _Inout_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord ); #endif #if (NTDDI_VERSION >= NTDDI_WINXPSP1) _Must_inspect_result_ NTKERNELAPI BOOLEAN KeRegisterBugCheckReasonCallback ( _Out_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord, _In_ PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine, _In_ KBUGCHECK_CALLBACK_REASON Reason, _In_ PUCHAR Component ); #endif typedef _Function_class_(NMI_CALLBACK) _IRQL_requires_same_ BOOLEAN NMI_CALLBACK( _In_opt_ PVOID Context, _In_ BOOLEAN Handled ); typedef NMI_CALLBACK *PNMI_CALLBACK; #if (NTDDI_VERSION >= NTDDI_WS03) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID KeRegisterNmiCallback ( _In_ PNMI_CALLBACK CallbackRoutine, _In_opt_ PVOID Context ); #endif #if (NTDDI_VERSION >= NTDDI_WS03) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS KeDeregisterNmiCallback ( _In_ PVOID Handle ); #endif #if defined(_X86_) || defined(_AMD64_) #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) typedef enum _BOUND_CALLBACK_STATUS { BoundExceptionContinueSearch = 0, BoundExceptionHandled, BoundExceptionError, BoundExceptionMaximum } BOUND_CALLBACK_STATUS, *PBOUND_CALLBACK_STATUS; #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) typedef _IRQL_requires_same_ BOUND_CALLBACK_STATUS BOUND_CALLBACK( VOID ); typedef BOUND_CALLBACK *PBOUND_CALLBACK; #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID KeRegisterBoundCallback ( _In_ PBOUND_CALLBACK CallbackRoutine ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS KeDeregisterBoundCallback ( _In_ PVOID Handle ); #endif #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) __drv_preferredFunction("error logging or driver shutdown", "Whenever possible, all kernel-mode components should log an error and " "continue to run, rather than calling KeBugCheckEx") NTKERNELAPI DECLSPEC_NORETURN VOID NTAPI KeBugCheckEx( _In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4 ); #endif #if !defined(_AMD64_) && !defined(_ARM64_) #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI ULONGLONG KeQueryInterruptTime ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID KeQuerySystemTime ( _Out_ PLARGE_INTEGER CurrentTime ); #endif #endif // !_AMD64_ #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI VOID KeQuerySystemTimePrecise ( _Out_ PLARGE_INTEGER CurrentTime ); #endif #if (NTDDI_VERSION >= NTDDI_WINBLUE) _IRQL_requires_same_ ULONG64 KeQueryInterruptTimePrecise ( _Out_ PULONG64 QpcTimeStamp ); #endif #if (NTDDI_VERSION >= NTDDI_THRESHOLD) _IRQL_requires_same_ ULONG64 KeQueryUnbiasedInterruptTimePrecise ( _Out_ PULONG64 QpcTimeStamp ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI ULONG KeQueryTimeIncrement ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI ULONGLONG KeQueryUnbiasedInterruptTime ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI ULONG KeGetRecommendedSharedDataAlignment ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) && defined(SINGLE_GROUP_LEGACY_API) NTKERNELAPI KAFFINITY KeQueryActiveProcessors ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) && defined(SINGLE_GROUP_LEGACY_API) NTKERNELAPI ULONG KeQueryActiveProcessorCount ( _Out_opt_ PKAFFINITY ActiveProcessors ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI ULONG KeQueryActiveProcessorCountEx ( _In_ USHORT GroupNumber ); #endif #if (NTDDI_VERSION >= NTDDI_LONGHORN) && defined(SINGLE_GROUP_LEGACY_API) NTKERNELAPI ULONG KeQueryMaximumProcessorCount ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI ULONG KeQueryMaximumProcessorCountEx ( _In_ USHORT GroupNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI USHORT KeQueryActiveGroupCount ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI USHORT KeQueryMaximumGroupCount ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI KAFFINITY KeQueryGroupAffinity ( _In_ USHORT GroupNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI ULONG KeGetCurrentProcessorNumberEx ( _Out_opt_ PPROCESSOR_NUMBER ProcNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI VOID KeQueryNodeActiveAffinity ( _In_ USHORT NodeNumber, _Out_opt_ PGROUP_AFFINITY Affinity, _Out_opt_ PUSHORT Count ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI USHORT KeQueryNodeMaximumProcessorCount ( _In_ USHORT NodeNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI USHORT KeQueryHighestNodeNumber ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI USHORT KeGetCurrentNodeNumber ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) _When_(_Old_(*Length) == 0, _Post_satisfies_(return < 0)) NTKERNELAPI NTSTATUS KeQueryLogicalProcessorRelationship ( _In_opt_ PPROCESSOR_NUMBER ProcessorNumber, _In_ LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType, _Out_writes_bytes_opt_(*Length) PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Information, _Always_(_Inout_) PULONG Length ); #endif _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI LOGICAL KeShouldYieldProcessor ( VOID ); #if defined(_X86_) || defined(_ARM_) extern DECLSPEC_CACHEALIGN volatile KSYSTEM_TIME KeTickCount; #endif typedef enum _MEMORY_CACHING_TYPE_ORIG { MmFrameBufferCached = 2 } MEMORY_CACHING_TYPE_ORIG; typedef enum _MEMORY_CACHING_TYPE { MmNonCached = FALSE, MmCached = TRUE, MmWriteCombined = MmFrameBufferCached, MmHardwareCoherentCached, MmNonCachedUnordered, // IA64 MmUSWCCached, MmMaximumCacheType, MmNotMapped = -1 } MEMORY_CACHING_TYPE; #if (NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN KeAreAllApcsDisabled ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(APC_LEVEL) _IRQL_requires_min_(PASSIVE_LEVEL) NTKERNELAPI VOID FASTCALL KeInitializeGuardedMutex ( _Out_ PKGUARDED_MUTEX Mutex ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Acquires_lock_(_Global_critical_region_) _Requires_lock_not_held_(*Mutex) _Acquires_lock_(*Mutex) _IRQL_requires_max_(APC_LEVEL) _IRQL_requires_min_(PASSIVE_LEVEL) NTKERNELAPI VOID FASTCALL KeAcquireGuardedMutex ( _Inout_ PKGUARDED_MUTEX Mutex ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Releases_lock_(_Global_critical_region_) _Requires_lock_held_(*Mutex) _Releases_lock_(*Mutex) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID FASTCALL KeReleaseGuardedMutex ( _Inout_ PKGUARDED_MUTEX Mutex ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Must_inspect_result_ _Success_(return != FALSE) _IRQL_requires_max_(APC_LEVEL) _Post_satisfies_(return == 1 || return == 0) NTKERNELAPI BOOLEAN FASTCALL KeTryToAcquireGuardedMutex ( _When_ (return, _Acquires_exclusive_lock_(*_Curr_)) _Acquires_lock_(_Global_critical_region_) _Inout_ PKGUARDED_MUTEX Mutex ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Requires_lock_not_held_(*FastMutex) _Acquires_lock_(*FastMutex) _IRQL_requires_max_(APC_LEVEL) _IRQL_requires_min_(PASSIVE_LEVEL) NTKERNELAPI VOID FASTCALL KeAcquireGuardedMutexUnsafe ( _Inout_ PKGUARDED_MUTEX FastMutex ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Requires_lock_held_(*FastMutex) _Releases_lock_(*FastMutex) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID FASTCALL KeReleaseGuardedMutexUnsafe ( _Inout_ PKGUARDED_MUTEX FastMutex ); #endif // // Define dynamic processor add types. // typedef enum { KeProcessorAddStartNotify = 0, KeProcessorAddCompleteNotify, KeProcessorAddFailureNotify } KE_PROCESSOR_CHANGE_NOTIFY_STATE; typedef struct _KE_PROCESSOR_CHANGE_NOTIFY_CONTEXT { KE_PROCESSOR_CHANGE_NOTIFY_STATE State; ULONG NtNumber; NTSTATUS Status; #if (NTDDI_VERSION >= NTDDI_WIN7) PROCESSOR_NUMBER ProcNumber; #endif } KE_PROCESSOR_CHANGE_NOTIFY_CONTEXT, *PKE_PROCESSOR_CHANGE_NOTIFY_CONTEXT; typedef _IRQL_requires_same_ _Function_class_(PROCESSOR_CALLBACK_FUNCTION) VOID PROCESSOR_CALLBACK_FUNCTION ( _In_ PVOID CallbackContext, _In_ PKE_PROCESSOR_CHANGE_NOTIFY_CONTEXT ChangeContext, _Inout_ PNTSTATUS OperationStatus ); typedef PROCESSOR_CALLBACK_FUNCTION *PPROCESSOR_CALLBACK_FUNCTION; #define KE_PROCESSOR_CHANGE_ADD_EXISTING 1 #if (NTDDI_VERSION >= NTDDI_WS08) _IRQL_requires_max_(APC_LEVEL) PVOID KeRegisterProcessorChangeCallback ( _In_ PPROCESSOR_CALLBACK_FUNCTION CallbackFunction, _In_opt_ PVOID CallbackContext, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WS08) _IRQL_requires_max_(APC_LEVEL) VOID KeDeregisterProcessorChangeCallback ( _In_ PVOID CallbackHandle ); #endif #define INVALID_PROCESSOR_INDEX 0xffffffff NTSTATUS KeGetProcessorNumberFromIndex ( _In_ ULONG ProcIndex, _Out_ PPROCESSOR_NUMBER ProcNumber ); ULONG KeGetProcessorIndexFromNumber ( _In_ PPROCESSOR_NUMBER ProcNumber ); typedef struct _XSTATE_SAVE { #if defined(_AMD64_) struct _XSTATE_SAVE* Prev; struct _KTHREAD* Thread; UCHAR Level; XSTATE_CONTEXT XStateContext; #elif defined(_ARM_) || defined(_ARM64_) ULONG Dummy; #elif defined(_X86_) union { struct { LONG64 Reserved1; ULONG Reserved2; struct _XSTATE_SAVE* Prev; PXSAVE_AREA Reserved3; struct _KTHREAD* Thread; PVOID Reserved4; UCHAR Level; }; XSTATE_CONTEXT XStateContext; }; #endif } XSTATE_SAVE, *PXSTATE_SAVE; #if (NTDDI_VERSION >= NTDDI_WIN7) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _When_(return>=0, _Kernel_float_saved_) _At_(*XStateSave, _When_(return>=0, _Kernel_acquires_resource_(FloatState))) NTKERNELAPI NTSTATUS NTAPI KeSaveExtendedProcessorState ( _In_ ULONG64 Mask, _Out_ PXSTATE_SAVE XStateSave ); _IRQL_requires_max_(DISPATCH_LEVEL) _Kernel_float_restored_ _At_(*XStateSave, _Kernel_requires_resource_held_(FloatState) _Kernel_releases_resource_(FloatState)) NTKERNELAPI VOID NTAPI KeRestoreExtendedProcessorState ( _In_ PXSTATE_SAVE XStateSave ); #endif typedef struct _EXT_SET_PARAMETERS_V0 { ULONG Version; ULONG Reserved; LONGLONG NoWakeTolerance; } EXT_SET_PARAMETERS, *PEXT_SET_PARAMETERS; typedef EXT_SET_PARAMETERS KT2_SET_PARAMETERS, *PKT2_SET_PARAMETERS; #if (NTDDI_VERSION >= NTDDI_WINBLUE) FORCEINLINE VOID KeInitializeTimer2SetParameters ( _Out_ PKT2_SET_PARAMETERS Parameters ) /*++ Routine Description: This routine initializes extended initialize timer parameters. N.B. This routine is inlined so that a driver that is built to use one version of the parameters structure will always set the structure's version parameter to that version. A downlevel driver will set the version parameter to the appropriate, downlevel version. Arguments: Parameters - Supplies the parameters to be initialized. Return Value: None. --*/ { RtlZeroMemory(Parameters, sizeof(*Parameters)); NT_ASSERT(Parameters->Version == 0); return; } #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) NTSTATUS KeConvertAuxiliaryCounterToPerformanceCounter ( _In_ ULONG64 AuxiliaryCounterValue, _Out_ PULONG64 PerformanceCounterValue, _Out_opt_ PULONG64 ConversionError ); NTSTATUS KeConvertPerformanceCounterToAuxiliaryCounter ( _In_ ULONG64 PerformanceCounterValue, _Out_ PULONG64 AuxiliaryCounterValue, _Out_opt_ PULONG64 ConversionError ); NTSTATUS KeQueryAuxiliaryCounterFrequency ( _Out_opt_ PULONG64 AuxiliaryCounterFrequency ); #endif typedef struct _KWAIT_CHAIN { SINGLE_LIST_ENTRY Head; } KWAIT_CHAIN, *PKWAIT_CHAIN; // // Define external data. // #if defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_WDMDDK_) || defined(_NTOSP_) extern PBOOLEAN KdDebuggerNotPresent; extern PBOOLEAN KdDebuggerEnabled; #define KD_DEBUGGER_ENABLED *KdDebuggerEnabled #define KD_DEBUGGER_NOT_PRESENT *KdDebuggerNotPresent #else extern BOOLEAN KdDebuggerNotPresent; extern BOOLEAN KdDebuggerEnabled; #define KD_DEBUGGER_ENABLED KdDebuggerEnabled #define KD_DEBUGGER_NOT_PRESENT KdDebuggerNotPresent #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI NTSTATUS KdDisableDebugger( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI NTSTATUS KdEnableDebugger( VOID ); #endif // // KdRefreshDebuggerPresent attempts to communicate with // the debugger host machine to refresh the state of // KdDebuggerNotPresent. It returns the state of // KdDebuggerNotPresent while the kd locks are held. // KdDebuggerNotPresent may immediately change state // after the kd locks are released so it may not // match the return value. // #if (NTDDI_VERSION >= NTDDI_WS03) NTKERNELAPI BOOLEAN KdRefreshDebuggerNotPresent( VOID ); #endif typedef enum _KD_OPTION { KD_OPTION_SET_BLOCK_ENABLE, } KD_OPTION; #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTSTATUS KdChangeOption( _In_ KD_OPTION Option, _In_ ULONG InBufferBytes OPTIONAL, _In_ PVOID InBuffer, _In_ ULONG OutBufferBytes OPTIONAL, _Out_ PVOID OutBuffer, _Out_ PULONG OutBufferNeeded OPTIONAL ); #endif // // Pool Allocation routines (in pool.c) // typedef _Enum_is_bitflag_ enum _POOL_TYPE { NonPagedPool, NonPagedPoolExecute = NonPagedPool, PagedPool, NonPagedPoolMustSucceed = NonPagedPool + 2, DontUseThisType, NonPagedPoolCacheAligned = NonPagedPool + 4, PagedPoolCacheAligned, NonPagedPoolCacheAlignedMustS = NonPagedPool + 6, MaxPoolType, // // Define base types for NonPaged (versus Paged) pool, for use in cracking // the underlying pool type. // NonPagedPoolBase = 0, NonPagedPoolBaseMustSucceed = NonPagedPoolBase + 2, NonPagedPoolBaseCacheAligned = NonPagedPoolBase + 4, NonPagedPoolBaseCacheAlignedMustS = NonPagedPoolBase + 6, // // Note these per session types are carefully chosen so that the appropriate // masking still applies as well as MaxPoolType above. // NonPagedPoolSession = 32, PagedPoolSession = NonPagedPoolSession + 1, NonPagedPoolMustSucceedSession = PagedPoolSession + 1, DontUseThisTypeSession = NonPagedPoolMustSucceedSession + 1, NonPagedPoolCacheAlignedSession = DontUseThisTypeSession + 1, PagedPoolCacheAlignedSession = NonPagedPoolCacheAlignedSession + 1, NonPagedPoolCacheAlignedMustSSession = PagedPoolCacheAlignedSession + 1, NonPagedPoolNx = 512, NonPagedPoolNxCacheAligned = NonPagedPoolNx + 4, NonPagedPoolSessionNx = NonPagedPoolNx + 32, } _Enum_is_bitflag_ POOL_TYPE; #define POOL_COLD_ALLOCATION 256 // Note this cannot encode into the header. #define POOL_NX_ALLOCATION 512 // Note this cannot encode into the header. // // POOL_NX_OPTIN_AUTO makes non-paged pool allocations non-executable by // default without dynamically checking if this is supported by the operating // system. This opt-in method should only be used by drivers that are targeted // to run on operating system versions that are known to support NX non-paged // pool allocations. // // POOL_NX_OPTIN allows device drivers to dynamically opt-in to making // non-paged pool allocations non-executable by default based on whether or not // this is supported by the version of the operating system. Device drivers // must call ExInitializeDriverRuntime (DrvRtPoolNxOptIn) during driver // initialization to dynamically opt-in. This opt-in method should be used by // drivers that are designed to run on versions of Windows that may or may not // support NX non-paged pool allocations. // // In both cases, NonPagedPoolExecute should be used by drivers that need to // explicitly allocate executable memory from the non-paged pool. // // POOL_NX_OPTOUT may be used to locally override the pool opt-in setting for a // single source file. It is intended to be useful as an aid for porting large // projects to NX pool, where most source files do not contain code that needs // to allocate executable NonPaged pool (and thus it may be convenient to set // the opt-in define globally). In this case, if there existed a source file // that needed to manually control executable versus non-executable pool opt-in // then that source file could define POOL_NX_OPTOUT to 0 in order to override // the global default. // #if (!defined(_X86_) && !defined(_AMD64_) && !defined(_NTOS_)) // // New platforms default to NonPagedPoolNx unless explicitly overridden. The // exemption for _NTOS_ is there to allow NonPagedPool to be referenced when // cracking pool types. This is henceforth the default for platforms that // require a recompilation. // // N.B. The remapping is carefully performed with a preprocessor define such // that code which is NonPagedPoolNx-aware and which needs to crack the // pool type may undefine the symbol. // #undef POOL_NX_OPTIN #define POOL_NX_OPTIN_AUTO 1 #endif // !defined(_X86_) && !defined(_AMD64_) && !defined(_NTOSP_) #if !POOL_NX_OPTOUT #if POOL_NX_OPTIN_AUTO #define NonPagedPool NonPagedPoolNx #define NonPagedPoolCacheAligned NonPagedPoolNxCacheAligned #elif POOL_NX_OPTIN DECLSPEC_SELECTANY POOL_TYPE ExDefaultNonPagedPoolType = NonPagedPoolExecute; DECLSPEC_SELECTANY ULONG ExDefaultMdlProtection = 0; #define NonPagedPool ExDefaultNonPagedPoolType #define NonPagedPoolCacheAligned ((POOL_TYPE)(ExDefaultNonPagedPoolType + 4)) #endif // POOL_NX_OPTIN_AUTO #endif // !POOL_NX_OPTOUT #define POOL_QUOTA_FAIL_INSTEAD_OF_RAISE 8 #define POOL_RAISE_IF_ALLOCATION_FAILURE 16 #if (NTDDI_VERSION >= NTDDI_WIN2K) DECLSPEC_DEPRECATED_DDK // Use ExAllocatePoolWithTag __drv_preferredFunction("ExAllocatePoolWithTag", "No tag interferes with debugging.") __drv_allocatesMem(Mem) _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL)) _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_((PoolType & NonPagedPoolMustSucceed) != 0, __drv_reportError("Must succeed pool allocations are forbidden. " "Allocation failures cause a system crash")) _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) == 0, _Post_maybenull_ _Must_inspect_result_) _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) != 0, _Post_notnull_) _Post_writable_byte_size_(NumberOfBytes) NTKERNELAPI PVOID ExAllocatePool ( __drv_strictTypeMatch(__drv_typeExpr) _In_ POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) DECLSPEC_DEPRECATED_DDK // Use ExAllocatePoolWithQuotaTag __drv_preferredFunction("ExAllocatePoolWithQuotaTag", "No tag interferes with debugging.") __drv_allocatesMem(Mem) _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL)) _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_((PoolType & NonPagedPoolMustSucceed) != 0, __drv_reportError("Must succeed pool allocations are forbidden. " "Allocation failures cause a system crash")) _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) != 0, _Post_maybenull_ _Must_inspect_result_) _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) == 0, _Post_notnull_) _Post_writable_byte_size_(NumberOfBytes) NTKERNELAPI PVOID ExAllocatePoolWithQuota ( __drv_strictTypeMatch(__drv_typeExpr) _In_ POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) __drv_allocatesMem(Mem) _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL)) _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_((PoolType & NonPagedPoolMustSucceed) != 0, __drv_reportError("Must succeed pool allocations are forbidden. " "Allocation failures cause a system crash")) _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) == 0, _Post_maybenull_ _Must_inspect_result_) _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) != 0, _Post_notnull_) _Post_writable_byte_size_(NumberOfBytes) NTKERNELAPI PVOID NTAPI ExAllocatePoolWithTag ( _In_ __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes, _In_ ULONG Tag ); #endif // // _EX_POOL_PRIORITY_ provides a method for the system to handle requests // intelligently in low resource conditions. // // LowPoolPriority should be used when it is acceptable to the driver for the // mapping request to fail if the system is low on resources. An example of // this could be for a non-critical network connection where the driver can // handle the failure case when system resources are close to being depleted. // // NormalPoolPriority should be used when it is acceptable to the driver for the // mapping request to fail if the system is very low on resources. An example // of this could be for a non-critical local filesystem request. // // HighPoolPriority should be used when it is unacceptable to the driver for the // mapping request to fail unless the system is completely out of resources. // An example of this would be the paging file path in a driver. // // SpecialPool can be specified to bound the allocation at a page end (or // beginning). This should only be done on systems being debugged as the // memory cost is expensive. // // N.B. These values are very carefully chosen so that the pool allocation // code can quickly crack the priority request. // typedef _Enum_is_bitflag_ enum _EX_POOL_PRIORITY { LowPoolPriority, LowPoolPrioritySpecialPoolOverrun = 8, LowPoolPrioritySpecialPoolUnderrun = 9, NormalPoolPriority = 16, NormalPoolPrioritySpecialPoolOverrun = 24, NormalPoolPrioritySpecialPoolUnderrun = 25, HighPoolPriority = 32, HighPoolPrioritySpecialPoolOverrun = 40, HighPoolPrioritySpecialPoolUnderrun = 41 } EX_POOL_PRIORITY; #if (NTDDI_VERSION >= NTDDI_WIN2K) __drv_allocatesMem(Mem) _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL)) _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_((PoolType & NonPagedPoolMustSucceed) != 0, __drv_reportError("Must succeed pool allocations are forbidden. " "Allocation failures cause a system crash")) _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) == 0, _Post_maybenull_ _Must_inspect_result_) _When_((PoolType & (NonPagedPoolMustSucceed | POOL_RAISE_IF_ALLOCATION_FAILURE)) != 0, _Post_notnull_) _Post_writable_byte_size_(NumberOfBytes) NTKERNELAPI PVOID NTAPI ExAllocatePoolWithTagPriority ( _In_ __drv_strictTypeMatch(__drv_typeCond) POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes, _In_ ULONG Tag, _In_ __drv_strictTypeMatch(__drv_typeExpr) EX_POOL_PRIORITY Priority ); #endif #ifndef POOL_TAGGING #define ExAllocatePoolWithTag(a,b,c) ExAllocatePool(a,b) #endif //POOL_TAGGING #if (NTDDI_VERSION >= NTDDI_WIN2K) __drv_allocatesMem(Mem) _When_((PoolType & PagedPool) != 0, _IRQL_requires_max_(APC_LEVEL)) _When_((PoolType & PagedPool) == 0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_((PoolType & NonPagedPoolMustSucceed) != 0, __drv_reportError("Must succeed pool allocations are forbidden. " "Allocation failures cause a system crash")) _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) != 0, _Post_maybenull_ _Must_inspect_result_) _When_((PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE) == 0, _Post_notnull_) _Post_writable_byte_size_(NumberOfBytes) NTKERNELAPI PVOID ExAllocatePoolWithQuotaTag ( _In_ __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes, _In_ ULONG Tag ); #endif #ifndef POOL_TAGGING #define ExAllocatePoolWithQuotaTag(a,b,c) ExAllocatePoolWithQuota(a,b) #endif //POOL_TAGGING #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI ExFreePool ( _Pre_notnull_ __drv_freesMem(Mem) PVOID P ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExFreePoolWithTag ( _Pre_notnull_ __drv_freesMem(Mem) PVOID P, _In_ ULONG Tag ); #endif // // Routines to support fast mutexes. // #define FM_LOCK_BIT 0x1 // Actual lock bit, 1 = Unlocked, 0 = Locked #define FM_LOCK_BIT_V 0x0 // Lock bit as a bit number FORCEINLINE VOID ExInitializeFastMutex ( _Out_ PFAST_MUTEX FastMutex ) /*++ Routine Description: This function initializes a fast mutex object. Arguments: FastMutex - Supplies a pointer to a fast mutex object. Return Value: None. --*/ { WriteRaw(&FastMutex->Count, FM_LOCK_BIT); FastMutex->Owner = NULL; FastMutex->Contention = 0; KeInitializeEvent(&FastMutex->Event, SynchronizationEvent, FALSE); return; } #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Requires_lock_held_(_Global_critical_region_) NTKERNELAPI VOID FASTCALL ExAcquireFastMutexUnsafe( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PFAST_MUTEX FastMutex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Requires_lock_held_(_Global_critical_region_) NTKERNELAPI VOID FASTCALL ExReleaseFastMutexUnsafe( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PFAST_MUTEX FastMutex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_raises_(APC_LEVEL) _IRQL_saves_global_(OldIrql, FastMutex) NTKERNELAPI VOID FASTCALL ExAcquireFastMutex ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PFAST_MUTEX FastMutex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_(APC_LEVEL) _IRQL_restores_global_(OldIrql, FastMutex) NTKERNELAPI VOID FASTCALL ExReleaseFastMutex ( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PFAST_MUTEX FastMutex ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _Success_(return!=FALSE) _IRQL_raises_(APC_LEVEL) _IRQL_saves_global_(OldIrql, FastMutex) NTKERNELAPI BOOLEAN FASTCALL ExTryToAcquireFastMutex ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PFAST_MUTEX FastMutex ); #endif // #if defined(_X86_) #ifdef __cplusplus extern "C" { #endif #define ExInterlockedAddLargeStatistic(Addend, Increment) \ (VOID)_InterlockedAddLargeStatistic((PLONGLONG)&(Addend)->QuadPart, Increment) long _InterlockedAddLargeStatistic ( _Inout_ __int64 volatile *Addend, _In_ long Increment ); #ifdef __cplusplus } #endif #pragma intrinsic(_InterlockedAddLargeStatistic) #else #define ExInterlockedAddLargeStatistic(Addend, Increment) \ (VOID)InterlockedAddNoFence64(&(Addend)->QuadPart, Increment) #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI LARGE_INTEGER ExInterlockedAddLargeInteger ( _Inout_ PLARGE_INTEGER Addend, _In_ LARGE_INTEGER Increment, _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI ULONG FASTCALL ExInterlockedAddUlong ( _Inout_ PULONG Addend, _In_ ULONG Increment, _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #endif // NTDDI_VERSION >= NTDDI_WIN2K #if defined(_AMD64_) || defined(_ARM_) || defined(_ARM64_) #define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \ InterlockedCompareExchange64(Destination, *(Exchange), *(Comperand)) #else #define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \ ExfInterlockedCompareExchange64(Destination, Exchange, Comperand) NTKERNELAPI LONGLONG FASTCALL ExfInterlockedCompareExchange64 ( _Inout_ _Interlocked_operand_ LONGLONG volatile *Destination, _In_ PLONGLONG ExChange, _In_ PLONGLONG Comperand ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedInsertHeadList ( _Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY ListEntry, _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedInsertTailList ( _Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY ListEntry, _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedRemoveHeadList ( _Inout_ PLIST_ENTRY ListHead, _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI PSINGLE_LIST_ENTRY FASTCALL ExInterlockedPopEntryList ( _Inout_ PSINGLE_LIST_ENTRY ListHead, _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI PSINGLE_LIST_ENTRY FASTCALL ExInterlockedPushEntryList ( _Inout_ PSINGLE_LIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY ListEntry, _Inout_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #endif // // Define interlocked sequenced listhead functions. // // A sequenced interlocked list is a singly linked list with a header that // contains the current depth and a sequence number. Each time an entry is // inserted or removed from the list the depth is updated and the sequence // number is incremented. This enables AMD64, ARM, and Pentium and later // machines to insert and remove from the list without the use of spinlocks. // // // (Ex)InitializeSListHead // #if !defined(_WINBASE_) #if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_)) NTKERNELAPI VOID InitializeSListHead ( _Out_ PSLIST_HEADER SListHead ); #else // defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_)) // // Since the following function will be compiled inline for user code, the // initialization changes for x86 will only take effect if the user code is // recompiled with this new header. For those binaries that are recompiled with // this new code, it will not have to go through an extra step of header // initialization on its first push or pop operation. Note that the SLIST code // will still work perfectly even without the changes in this initialization // function. // __inline VOID InitializeSListHead ( _Out_ PSLIST_HEADER SListHead ) /*++ Routine Description: This function initializes a sequenced singly linked listhead. Arguments: SListHead - Supplies a pointer to a sequenced singly linked listhead. Return Value: None. --*/ { // // Slist headers must be 16 byte aligned. // #if defined(_WIN64) if (((ULONG_PTR)SListHead & 0xf) != 0) { RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT); } #endif RtlZeroMemory(SListHead, sizeof(SLIST_HEADER)); return; } #endif // defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_)) #endif // !defined(_WINBASE_) #define ExInitializeSListHead InitializeSListHead // // FirstEntrySList // NTKERNELAPI PSLIST_ENTRY FirstEntrySList ( _In_ PSLIST_HEADER SListHead ); // // (Ex)QueryDepthSList // #if !defined(_X86_) #if (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_)) NTKERNELAPI USHORT ExQueryDepthSList ( _In_ PSLIST_HEADER SListHead ); #else // (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_)) __inline USHORT ExQueryDepthSList ( _In_ PSLIST_HEADER SListHead ) /*++ Routine Description: This function queries the current number of entries contained in a sequenced single linked list. Arguments: SListHead - Supplies a pointer to the sequenced listhead which is be queried. Return Value: The current number of entries in the sequenced singly linked list is returned as the function value. --*/ { #if defined(_WIN64) return (USHORT)(SListHead->Alignment & 0xffff); #else return (USHORT)SListHead->Depth; #endif } #endif // (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_)) #else // !defined(_X86_) #define ExQueryDepthSList(_listhead_) (_listhead_)->Depth #endif // !defined(_X86_) #if !defined(_WINBASE_) #define QueryDepthSList(Head) \ ExQueryDepthSList(Head) #endif // !defined(_WINBASE_) // // ExInterlockedPopEntrySList // ExInterlockedPushEntrySList // ExInterlockedFlushSList // #if !defined(_X86_) #define ExInterlockedPopEntrySList(Head, Lock) \ ExpInterlockedPopEntrySList(Head) #define ExInterlockedPushEntrySList(Head, Entry, Lock) \ ExpInterlockedPushEntrySList(Head, Entry) #define ExInterlockedFlushSList(Head) \ ExpInterlockedFlushSList(Head) #if !defined(_WINBASE_) #define InterlockedPopEntrySList(Head) \ ExpInterlockedPopEntrySList(Head) #define InterlockedPushEntrySList(Head, Entry) \ ExpInterlockedPushEntrySList(Head, Entry) #define InterlockedFlushSList(Head) \ ExpInterlockedFlushSList(Head) #endif // !defined(_WINBASE_) NTKERNELAPI PSLIST_ENTRY ExpInterlockedPopEntrySList ( _Inout_ PSLIST_HEADER ListHead ); NTKERNELAPI PSLIST_ENTRY ExpInterlockedPushEntrySList ( _Inout_ PSLIST_HEADER ListHead, _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry ); NTKERNELAPI PSLIST_ENTRY ExpInterlockedFlushSList ( _Inout_ PSLIST_HEADER ListHead ); #else // !defined(_X86_) #if defined(_WIN2K_COMPAT_SLIST_USAGE) NTKERNELAPI PSLIST_ENTRY FASTCALL ExInterlockedPopEntrySList ( _Inout_ PSLIST_HEADER ListHead, _Inout_opt_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); NTKERNELAPI PSLIST_ENTRY FASTCALL ExInterlockedPushEntrySList ( _Inout_ PSLIST_HEADER ListHead, _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry, _Inout_opt_ _Requires_lock_not_held_(*_Curr_) PKSPIN_LOCK Lock ); #else // defined(_WIN2K_COMPAT_SLIST_USAGE) #define ExInterlockedPopEntrySList(ListHead, Lock) \ InterlockedPopEntrySList(ListHead) #define ExInterlockedPushEntrySList(ListHead, ListEntry, Lock) \ InterlockedPushEntrySList(ListHead, ListEntry) #endif // defined(_WIN2K_COMPAT_SLIST_USAGE) NTKERNELAPI PSLIST_ENTRY FASTCALL ExInterlockedFlushSList ( _Inout_ PSLIST_HEADER ListHead ); #if !defined(_WINBASE_) NTKERNELAPI PSLIST_ENTRY FASTCALL InterlockedPopEntrySList ( _Inout_ PSLIST_HEADER ListHead ); NTKERNELAPI PSLIST_ENTRY FASTCALL InterlockedPushEntrySList ( _Inout_ PSLIST_HEADER ListHead, _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry ); #define InterlockedFlushSList(Head) \ ExInterlockedFlushSList(Head) #endif // !defined(_WINBASE_) #endif // !defined(_X86_) #define LOOKASIDE_MINIMUM_BLOCK_SIZE (RTL_SIZEOF_THROUGH_FIELD (SLIST_ENTRY, Next)) // // N.B. Note that this structure is not cache aligned to enable its use // in a larger containing structure. // typedef struct _LOOKASIDE_LIST_EX { GENERAL_LOOKASIDE_POOL L; } LOOKASIDE_LIST_EX, *PLOOKASIDE_LIST_EX; #if (NTDDI_VERSION >= NTDDI_VISTA) #define EX_LOOKASIDE_LIST_EX_FLAGS_RAISE_ON_FAIL 0x00000001UL #define EX_LOOKASIDE_LIST_EX_FLAGS_FAIL_NO_RAISE 0x00000002UL #define EX_MAXIMUM_LOOKASIDE_DEPTH_BASE 256 // Base maximum depth #define EX_MAXIMUM_LOOKASIDE_DEPTH_LIMIT 1024 // Upper limit maximum depth _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS ExInitializeLookasideListEx ( _Out_ PLOOKASIDE_LIST_EX Lookaside, _In_opt_ PALLOCATE_FUNCTION_EX Allocate, _In_opt_ PFREE_FUNCTION_EX Free, _In_ POOL_TYPE PoolType, _In_ ULONG Flags, _In_ SIZE_T Size, _In_ ULONG Tag, _In_ USHORT Depth ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExDeleteLookasideListEx ( _Inout_ PLOOKASIDE_LIST_EX Lookaside ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExFlushLookasideListEx ( _Inout_ PLOOKASIDE_LIST_EX Lookaside ); __drv_allocatesMem(Mem) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) FORCEINLINE PVOID #pragma warning(suppress: 28195) // memory is not always allocated here, sometimes we reuse an entry from the list ExAllocateFromLookasideListEx ( _Inout_ PLOOKASIDE_LIST_EX Lookaside ) /*++ Routine Description: This function removes (pops) the first entry from the specified lookaside list. Arguments: Lookaside - Supplies a pointer to a LOOKASIDE_LIST_EX structure. Return Value: If an entry is removed from the specified lookaside list, then the address of the entry is returned as the function value. Otherwise, NULL is returned. --*/ { PVOID Entry; Lookaside->L.TotalAllocates += 1; Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead); if (Entry == NULL) { Lookaside->L.AllocateMisses += 1; Entry = (Lookaside->L.AllocateEx)(Lookaside->L.Type, Lookaside->L.Size, Lookaside->L.Tag, Lookaside); } return Entry; } _IRQL_requires_max_(DISPATCH_LEVEL) FORCEINLINE VOID ExFreeToLookasideListEx ( _Inout_ PLOOKASIDE_LIST_EX Lookaside, _In_ __drv_freesMem(Entry) PVOID Entry ) /*++ Routine Description: This function inserts (pushes) the specified entry into the specified lookaside list. Arguments: Lookaside - Supplies a pointer to a LOOKASIDE_LIST_EX structure. Entry - Supples a pointer to the entry that is inserted in the lookaside list. Return Value: None. --*/ { Lookaside->L.TotalFrees += 1; if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) { Lookaside->L.FreeMisses += 1; (Lookaside->L.FreeEx)(Entry, Lookaside); } else { InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry); } return; } #endif // (NTDDI_VERSION >= NTDDI_VISTA) typedef struct LOOKASIDE_ALIGN _NPAGED_LOOKASIDE_LIST { GENERAL_LOOKASIDE L; #if defined(_X86_) KSPIN_LOCK Lock__ObsoleteButDoNotDelete; #endif } NPAGED_LOOKASIDE_LIST, *PNPAGED_LOOKASIDE_LIST; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExInitializeNPagedLookasideList ( _Out_ PNPAGED_LOOKASIDE_LIST Lookaside, _In_opt_ PALLOCATE_FUNCTION Allocate, _In_opt_ PFREE_FUNCTION Free, _In_ ULONG Flags, _In_ SIZE_T Size, _In_ ULONG Tag, _In_ USHORT Depth ); #if !POOL_NX_OPTOUT && (POOL_NX_OPTIN || POOL_NX_OPTIN_AUTO) // // If NX Pool Opt-In is enabled, then ExInitializeNPagedLookasideList calls are // remapped to go through the following forceinline. // // N.B. Should NX Pool Opt-In be enabled, ExInitializeDriverRuntime(...) *MUST* // be invoked before any calls to ExInitializeNPagedLookasideList in // order for Opt-In to be correctly applied. // FORCEINLINE _IRQL_requires_max_(DISPATCH_LEVEL) VOID ExInitializeNPagedLookasideList_NXPoolOptIn ( _Out_ PNPAGED_LOOKASIDE_LIST Lookaside, _In_opt_ PALLOCATE_FUNCTION Allocate, _In_opt_ PFREE_FUNCTION Free, _In_ ULONG Flags, _In_ SIZE_T Size, _In_ ULONG Tag, _In_ USHORT Depth ) { ExInitializeNPagedLookasideList(Lookaside, Allocate, Free, #if POOL_NX_OPTIN_AUTO Flags | POOL_NX_ALLOCATION, #else Flags | (ULONG) ExDefaultNonPagedPoolType, #endif Size, Tag, Depth); return; } #define ExInitializeNPagedLookasideList ExInitializeNPagedLookasideList_NXPoolOptIn #endif // !POOL_NX_OPTOUT && (POOL_NX_OPTIN || POOL_NX_OPTIN_AUTO) #endif // (NTDDI_VERSION >= NTDDK_WIN2K) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExDeleteNPagedLookasideList ( _Inout_ PNPAGED_LOOKASIDE_LIST Lookaside ); #endif __drv_allocatesMem(Mem) _IRQL_requires_max_(DISPATCH_LEVEL) __inline _Ret_maybenull_ _Post_writable_byte_size_(Lookaside->L.Size) PVOID #pragma warning(suppress: 28195) // memory is not always allocated here, sometimes we reuse an entry from the list ExAllocateFromNPagedLookasideList ( _Inout_ PNPAGED_LOOKASIDE_LIST Lookaside ) /*++ Routine Description: This function removes (pops) the first entry from the specified nonpaged lookaside list. Arguments: Lookaside - Supplies a pointer to a nonpaged lookaside list structure. Return Value: If an entry is removed from the specified lookaside list, then the address of the entry is returned as the function value. Otherwise, NULL is returned. --*/ { PVOID Entry; Lookaside->L.TotalAllocates += 1; #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_) Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead, &Lookaside->Lock__ObsoleteButDoNotDelete); #else Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead); #endif if (Entry == NULL) { Lookaside->L.AllocateMisses += 1; Entry = (Lookaside->L.Allocate)(Lookaside->L.Type, Lookaside->L.Size, Lookaside->L.Tag); } return Entry; } _IRQL_requires_max_(DISPATCH_LEVEL) __inline VOID ExFreeToNPagedLookasideList ( _Inout_ PNPAGED_LOOKASIDE_LIST Lookaside, _In_ __drv_freesMem(Mem) PVOID Entry ) /*++ Routine Description: This function inserts (pushes) the specified entry into the specified nonpaged lookaside list. Arguments: Lookaside - Supplies a pointer to a nonpaged lookaside list structure. Entry - Supples a pointer to the entry that is inserted in the lookaside list. Return Value: None. --*/ { Lookaside->L.TotalFrees += 1; if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) { Lookaside->L.FreeMisses += 1; (Lookaside->L.Free)(Entry); } else { #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_) ExInterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry, &Lookaside->Lock__ObsoleteButDoNotDelete); #else InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry); #endif } return; } typedef struct LOOKASIDE_ALIGN _PAGED_LOOKASIDE_LIST { GENERAL_LOOKASIDE L; #if defined(_X86_) FAST_MUTEX Lock__ObsoleteButDoNotDelete; #endif } PAGED_LOOKASIDE_LIST, *PPAGED_LOOKASIDE_LIST; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExInitializePagedLookasideList ( _Out_ PPAGED_LOOKASIDE_LIST Lookaside, _In_opt_ PALLOCATE_FUNCTION Allocate, _In_opt_ PFREE_FUNCTION Free, _In_ ULONG Flags, _In_ SIZE_T Size, _In_ ULONG Tag, _In_ USHORT Depth ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExDeletePagedLookasideList ( _Inout_ PPAGED_LOOKASIDE_LIST Lookaside ); #endif #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID ExAllocateFromPagedLookasideList ( _Inout_ PPAGED_LOOKASIDE_LIST Lookaside ); #else #pragma warning(push) #pragma warning(disable: 28195) // memory is not always allocated here, sometimes we reuse an entry from the list __drv_allocatesMem(Mem) _IRQL_requires_max_(APC_LEVEL) __inline PVOID ExAllocateFromPagedLookasideList ( _Inout_ PPAGED_LOOKASIDE_LIST Lookaside ) /*++ Routine Description: This function removes (pops) the first entry from the specified paged lookaside list. Arguments: Lookaside - Supplies a pointer to a paged lookaside list structure. Return Value: If an entry is removed from the specified lookaside list, then the address of the entry is returned as the function value. Otherwise, NULL is returned. --*/ { PVOID Entry; Lookaside->L.TotalAllocates += 1; Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead); if (Entry == NULL) { Lookaside->L.AllocateMisses += 1; Entry = (Lookaside->L.Allocate)(Lookaside->L.Type, Lookaside->L.Size, Lookaside->L.Tag); } return Entry; } #pragma warning(pop) #endif #if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExFreeToPagedLookasideList ( _Inout_ PPAGED_LOOKASIDE_LIST Lookaside, _In_ PVOID Entry ); #else _IRQL_requires_max_(APC_LEVEL) __inline VOID ExFreeToPagedLookasideList ( _Inout_ PPAGED_LOOKASIDE_LIST Lookaside, _In_ __drv_freesMem(Mem) PVOID Entry ) /*++ Routine Description: This function inserts (pushes) the specified entry into the specified paged lookaside list. Arguments: Lookaside - Supplies a pointer to a nonpaged lookaside list structure. Entry - Supples a pointer to the entry that is inserted in the lookaside list. Return Value: None. --*/ { Lookaside->L.TotalFrees += 1; if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) { Lookaside->L.FreeMisses += 1; (Lookaside->L.Free)(Entry); } else { InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry); } return; } #endif #if defined(_NTDDK_) || defined(_NTIFS_) #if (NTDDI_VERSION >= NTDDI_WIN2K) #if defined(_PREFAST_) _Maybe_raises_SEH_exception_ _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI ProbeForRead ( __in_data_source(USER_MODE) _In_reads_bytes_(Length) const volatile VOID *Address, _In_ SIZE_T Length, _In_ ULONG Alignment ); #else _Maybe_raises_SEH_exception_ _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI ProbeForRead ( __in_data_source(USER_MODE) _In_reads_bytes_(Length) volatile VOID *Address, _In_ SIZE_T Length, _In_ ULONG Alignment ); #endif // _PREFAST_ #endif #endif // // Raise status from kernel mode. // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI DECLSPEC_NORETURN VOID NTAPI ExRaiseStatus ( _In_ NTSTATUS Status ); #endif // // Common probe for write functions. // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Maybe_raises_SEH_exception_ _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI ProbeForWrite ( __in_data_source(USER_MODE) _Inout_updates_bytes_(Length) volatile VOID *Address, _In_ SIZE_T Length, _In_ ULONG Alignment ); #endif // // Worker Thread // typedef _Enum_is_bitflag_ enum _WORK_QUEUE_TYPE { CriticalWorkQueue, DelayedWorkQueue, HyperCriticalWorkQueue, NormalWorkQueue, BackgroundWorkQueue, RealTimeWorkQueue, SuperCriticalWorkQueue, MaximumWorkQueue, CustomPriorityWorkQueue = 32 } WORK_QUEUE_TYPE; typedef _IRQL_requires_max_(PASSIVE_LEVEL) _IRQL_requires_same_ _Function_class_(WORKER_THREAD_ROUTINE) VOID WORKER_THREAD_ROUTINE ( _In_ PVOID Parameter ); typedef WORKER_THREAD_ROUTINE *PWORKER_THREAD_ROUTINE; typedef struct _WORK_QUEUE_ITEM { LIST_ENTRY List; PWORKER_THREAD_ROUTINE WorkerRoutine; __volatile PVOID Parameter; } WORK_QUEUE_ITEM, *PWORK_QUEUE_ITEM; DECLSPEC_DEPRECATED_DDK // Use IoAllocateWorkItem CFORCEINLINE VOID ExInitializeWorkItem ( _Out_ PWORK_QUEUE_ITEM Item, _In_opt_ PWORKER_THREAD_ROUTINE Routine, _In_opt_ PVOID Context ) { Item->WorkerRoutine = Routine; Item->Parameter = Context; Item->List.Flink = NULL; } #if (NTDDI_VERSION >= NTDDI_WIN2K) #ifdef _NTDDK_ _When_( (!__drv_defined(_DRIVER_TYPE_FILESYSTEM) && !__drv_defined(_DRIVER_TYPE_FILESYSTEM_FILTER)) || NTDDI_VERSION >= NTDDI_VISTA, __drv_preferredFunction("IoQueueWorkItem[Ex]", "Obsolete in all drivers for Vista. Obsolete downlevel except for limited " "use in IFS. See the documentation")) #endif _IRQL_requires_max_(DISPATCH_LEVEL) DECLSPEC_DEPRECATED_DDK // Use IoQueueWorkItem NTKERNELAPI VOID ExQueueWorkItem( _Inout_ __drv_aliasesMem PWORK_QUEUE_ITEM WorkItem, _In_ WORK_QUEUE_TYPE QueueType ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) __drv_preferredFunction("nothing", "Drivers should not be dependent on processor features") NTKERNELAPI BOOLEAN ExIsProcessorFeaturePresent( _In_ ULONG ProcessorFeature ); #endif // // Define executive resource data structures. // typedef ULONG_PTR ERESOURCE_THREAD; typedef ERESOURCE_THREAD *PERESOURCE_THREAD; typedef struct _OWNER_ENTRY { ERESOURCE_THREAD OwnerThread; union { struct { ULONG IoPriorityBoosted : 1; ULONG OwnerReferenced : 1; ULONG IoQoSPriorityBoosted : 1; ULONG OwnerCount : 29; }; ULONG TableSize; }; } OWNER_ENTRY, *POWNER_ENTRY; typedef struct _ERESOURCE { LIST_ENTRY SystemResourcesList; POWNER_ENTRY OwnerTable; // // ActiveEntries is the true, 32-bit count. Existing code // checks for ActiveCount == 0, so this toggles between // 0 and 1 and back as ActiveEntries goes from 0 to // non-zero and back. // SHORT ActiveCount; union { USHORT Flag; struct { UCHAR ReservedLowFlags; UCHAR WaiterPriority; }; }; KWAIT_CHAIN SharedWaiters; __volatile PKEVENT ExclusiveWaiters; // // If the resource is owned exclusive, OwnerEntry contains the // resource owner. // // If the resource is owned shared, OwnerEntry may contain one // of the shared owners. // OWNER_ENTRY OwnerEntry; ULONG ActiveEntries; ULONG ContentionCount; ULONG NumberOfSharedWaiters; ULONG NumberOfExclusiveWaiters; #if defined(_WIN64) PVOID Reserved2; #endif union { PVOID Address; ULONG_PTR CreatorBackTraceIndex; }; KSPIN_LOCK SpinLock; } ERESOURCE, *PERESOURCE; // // Values for ERESOURCE.Flag // #define ResourceNeverExclusive 0x0010 #define ResourceReleaseByOtherThread 0x0020 #define ResourceOwnedExclusive 0x0080 #define RESOURCE_HASH_TABLE_SIZE 64 typedef struct _RESOURCE_HASH_ENTRY { LIST_ENTRY ListEntry; PVOID Address; ULONG ContentionCount; ULONG Number; } RESOURCE_HASH_ENTRY, *PRESOURCE_HASH_ENTRY; typedef struct _RESOURCE_PERFORMANCE_DATA { ULONG ActiveResourceCount; ULONG TotalResourceCount; ULONG ExclusiveAcquire; ULONG SharedFirstLevel; ULONG SharedSecondLevel; ULONG StarveFirstLevel; ULONG StarveSecondLevel; ULONG WaitForExclusive; ULONG OwnerTableExpands; ULONG MaximumTableExpand; LIST_ENTRY HashTable[RESOURCE_HASH_TABLE_SIZE]; } RESOURCE_PERFORMANCE_DATA, *PRESOURCE_PERFORMANCE_DATA; // // Define executive resource function prototypes. // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS ExInitializeResourceLite ( _Out_ PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS ExReinitializeResourceLite ( _Inout_ PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Requires_lock_held_(_Global_critical_region_) _When_(Wait!=0, _Post_satisfies_(return == 1)) _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_) NTKERNELAPI BOOLEAN ExAcquireResourceSharedLite ( _Inout_ _Requires_lock_not_held_(*_Curr_) _When_(return!=0, _Acquires_shared_lock_(*_Curr_)) PERESOURCE Resource, _In_ BOOLEAN Wait ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA || NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(APC_LEVEL) _Acquires_lock_(_Global_critical_region_) NTKERNELAPI PVOID ExEnterCriticalRegionAndAcquireResourceShared ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_shared_lock_(*_Curr_) PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Requires_lock_held_(_Global_critical_region_) _When_(Wait!=0, _Post_satisfies_(return == 1)) _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_) NTKERNELAPI BOOLEAN ExAcquireResourceExclusiveLite ( _Inout_ _Requires_lock_not_held_(*_Curr_) _When_(return!=0, _Acquires_exclusive_lock_(*_Curr_)) PERESOURCE Resource, _In_ _Literal_ BOOLEAN Wait ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA || NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(APC_LEVEL) _Acquires_lock_(_Global_critical_region_) NTKERNELAPI PVOID ExEnterCriticalRegionAndAcquireResourceExclusive ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_exclusive_lock_(*_Curr_) PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Requires_lock_held_(_Global_critical_region_) _When_(Wait!=0, _Post_satisfies_(return == 1)) _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_) NTKERNELAPI BOOLEAN ExAcquireSharedStarveExclusive( _Inout_ _Requires_lock_not_held_(*_Curr_) _When_(return!=0, _Acquires_shared_lock_(*_Curr_)) PERESOURCE Resource, _In_ BOOLEAN Wait ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Requires_lock_held_(_Global_critical_region_) _When_(Wait!=0, _Post_satisfies_(return == 1)) _When_(Wait==0, _Post_satisfies_(return == 0 || return == 1) _Must_inspect_result_) NTKERNELAPI BOOLEAN ExAcquireSharedWaitForExclusive( _Inout_ _Requires_lock_not_held_(*_Curr_) _When_(return!=0, _Acquires_lock_(*_Curr_)) PERESOURCE Resource, _In_ BOOLEAN Wait ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA || NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(APC_LEVEL) _Acquires_lock_(_Global_critical_region_) NTKERNELAPI PVOID ExEnterCriticalRegionAndAcquireSharedWaitForExclusive ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PERESOURCE Resource ); #endif // // VOID // ExReleaseResource( // IN PERESOURCE Resource // ); // #if PRAGMA_DEPRECATED_DDK #pragma deprecated(ExReleaseResource) // Use ExReleaseResourceLite #endif #define ExReleaseResource(R) (ExReleaseResourceLite(R)) #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_held_(_Global_critical_region_) _Requires_lock_held_(*Resource) _Releases_lock_(*Resource) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL ExReleaseResourceLite( _Inout_ PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA || NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(DISPATCH_LEVEL) _Releases_lock_(_Global_critical_region_) NTKERNELAPI VOID FASTCALL ExReleaseResourceAndLeaveCriticalRegion( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _Requires_lock_held_(_Global_critical_region_) NTKERNELAPI VOID ExReleaseResourceForThreadLite( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PERESOURCE Resource, _In_ ERESOURCE_THREAD ResourceThreadId ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExSetResourceOwnerPointer( _Inout_ PERESOURCE Resource, _In_ PVOID OwnerPointer ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExSetResourceOwnerPointerEx( _Inout_ PERESOURCE Resource, _In_ PVOID OwnerPointer, _In_ ULONG Flags ); #define FLAG_OWNER_POINTER_IS_THREAD 0x1 #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExConvertExclusiveToSharedLite( _Inout_ _Requires_lock_held_(*_Curr_) PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS ExDeleteResourceLite ( _Inout_ PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI ULONG ExGetExclusiveWaiterCount ( _In_ PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI ULONG ExGetSharedWaiterCount ( _In_ PERESOURCE Resource ); #endif // // ERESOURCE_THREAD // ExGetCurrentResourceThread( // VOID // ); // #define ExGetCurrentResourceThread() ((ULONG_PTR)PsGetCurrentThread()) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN ExIsResourceAcquiredExclusiveLite ( _In_ PERESOURCE Resource ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI ULONG ExIsResourceAcquiredSharedLite ( _In_ PERESOURCE Resource ); #endif // // An acquired resource is always owned shared, as shared ownership is a subset // of exclusive ownership. // #define ExIsResourceAcquiredLite ExIsResourceAcquiredSharedLite // // Rundown protection structure // typedef struct _EX_RUNDOWN_REF { #define EX_RUNDOWN_ACTIVE 0x1 #define EX_RUNDOWN_COUNT_SHIFT 0x1 #define EX_RUNDOWN_COUNT_INC (1<= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI KPROCESSOR_MODE ExGetPreviousMode( VOID ); #endif // // Set timer resolution. // #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI ULONG ExSetTimerResolution ( _In_ ULONG DesiredTime, _In_ BOOLEAN SetResolution ); #endif // // Query timer resolution. // #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI VOID ExQueryTimerResolution ( _Out_ PULONG MaximumTime, _Out_ PULONG MinimumTime, _Out_ PULONG CurrentTime ); #endif // // Subtract time zone bias from system time to get local time. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID ExSystemTimeToLocalTime ( _In_ PLARGE_INTEGER SystemTime, _Out_ PLARGE_INTEGER LocalTime ); #endif // // Add time zone bias to local time to get system time. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID ExLocalTimeToSystemTime ( _In_ PLARGE_INTEGER LocalTime, _Out_ PLARGE_INTEGER SystemTime ); #endif typedef struct _EX_TIMER *PEX_TIMER; _Function_class_(EXT_CALLBACK) _IRQL_requires_(DISPATCH_LEVEL) _IRQL_requires_same_ typedef VOID EXT_CALLBACK ( _In_ PEX_TIMER Timer, _In_opt_ PVOID Context ); typedef EXT_CALLBACK *PEXT_CALLBACK; _Function_class_(EXT_DELETE_CALLBACK) _IRQL_requires_(DISPATCH_LEVEL) _IRQL_requires_same_ typedef VOID EXT_DELETE_CALLBACK ( _In_opt_ PVOID Context ); typedef EXT_DELETE_CALLBACK *PEXT_DELETE_CALLBACK; typedef PVOID PEXT_CANCEL_PARAMETERS; typedef struct _EXT_DELETE_PARAMETERS { ULONG Version; ULONG Reserved; PEXT_DELETE_CALLBACK DeleteCallback; PVOID DeleteContext; } EXT_DELETE_PARAMETERS, *PEXT_DELETE_PARAMETERS; #if (NTDDI_VERSION >= NTDDI_WINBLUE) #define EX_TIMER_HIGH_RESOLUTION 0x4 #define EX_TIMER_NO_WAKE 0x8 #define EX_TIMER_UNLIMITED_TOLERANCE ((LONGLONG)-1) #define EX_TIMER_NOTIFICATION (1UL << 31) NTKERNELAPI PEX_TIMER ExAllocateTimer ( _In_opt_ PEXT_CALLBACK Callback, _In_opt_ PVOID CallbackContext, _In_ ULONG Attributes ); NTKERNELAPI BOOLEAN ExSetTimer ( _In_ PEX_TIMER Timer, _In_ LONGLONG DueTime, _In_ LONGLONG Period, _In_opt_ PEXT_SET_PARAMETERS Parameters ); NTKERNELAPI BOOLEAN ExCancelTimer ( _Inout_ PEX_TIMER Timer, _In_opt_ PEXT_CANCEL_PARAMETERS Parameters ); NTKERNELAPI BOOLEAN ExDeleteTimer ( _In_ PEX_TIMER Timer, _In_ BOOLEAN Cancel, _In_ BOOLEAN Wait, _In_opt_ PEXT_DELETE_PARAMETERS Parameters ); FORCEINLINE VOID ExInitializeSetTimerParameters ( _Out_ PEXT_SET_PARAMETERS Parameters ) /*++ Routine Description: This routine initializes extended set timer parameters. N.B. This routine is inlined so that a driver that is built to use one version of the parameters structure will always set the structure's version parameter to that version. A downlevel driver will set the version parameter to the appropriate, downlevel version. Arguments: Parameters - Supplies the parameters to be initialized. Return Value: None. --*/ { KeInitializeTimer2SetParameters(Parameters); return; } FORCEINLINE VOID ExInitializeDeleteTimerParameters ( _Out_ PEXT_DELETE_PARAMETERS Parameters ) /*++ Routine Description: This routine initializes extended delete timer parameters. N.B. This routine is inlined so that a driver that is built to use one version of the parameters structure will always set the structure's version parameter to that version. A downlevel driver will set the version parameter to the appropriate, downlevel version. Arguments: Parameters - Supplies the parameters to be initialized. Return Value: None. --*/ { RtlZeroMemory(Parameters, sizeof(*Parameters)); NT_ASSERT(Parameters->Version == 0); return; } #endif // // Define the type for Callback function. // typedef struct _CALLBACK_OBJECT *PCALLBACK_OBJECT; typedef _IRQL_requires_same_ _Function_class_(CALLBACK_FUNCTION) VOID CALLBACK_FUNCTION ( _In_opt_ PVOID CallbackContext, _In_opt_ PVOID Argument1, _In_opt_ PVOID Argument2 ); typedef CALLBACK_FUNCTION *PCALLBACK_FUNCTION; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS ExCreateCallback ( _Outptr_ PCALLBACK_OBJECT *CallbackObject, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ BOOLEAN Create, _In_ BOOLEAN AllowMultipleCallbacks ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID ExRegisterCallback ( _Inout_ PCALLBACK_OBJECT CallbackObject, _In_ PCALLBACK_FUNCTION CallbackFunction, _In_opt_ PVOID CallbackContext ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExUnregisterCallback ( _Inout_ PVOID CallbackRegistration ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID ExNotifyCallback ( _In_ PVOID CallbackObject, _In_opt_ PVOID Argument1, _In_opt_ PVOID Argument2 ); #endif // // suite support // #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI BOOLEAN ExVerifySuite( __drv_strictTypeMatch(__drv_typeExpr) _In_ SUITE_TYPE SuiteType ); #endif // // Rundown Locks // #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI VOID FASTCALL ExInitializeRundownProtection ( _Out_ PEX_RUNDOWN_REF RunRef ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI VOID FASTCALL ExReInitializeRundownProtection ( _Inout_ PEX_RUNDOWN_REF RunRef ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Must_inspect_result_ _Post_satisfies_(return == 0 || return == 1) NTKERNELAPI BOOLEAN FASTCALL ExAcquireRundownProtection ( _Inout_ PEX_RUNDOWN_REF RunRef ); #endif #if (NTDDI_VERSION >= NTDDI_WINXPSP2 || NTDDI_VERSION >= NTDDI_WS03) _Must_inspect_result_ _Post_satisfies_(return == 0 || return == 1) NTKERNELAPI BOOLEAN FASTCALL ExAcquireRundownProtectionEx ( _Inout_ PEX_RUNDOWN_REF RunRef, _In_ ULONG Count ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL ExReleaseRundownProtection ( _Inout_ PEX_RUNDOWN_REF RunRef ); #endif #if (NTDDI_VERSION >= NTDDI_WINXPSP2 || NTDDI_VERSION >= NTDDI_WS03) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL ExReleaseRundownProtectionEx ( _Inout_ PEX_RUNDOWN_REF RunRef, _In_ ULONG Count ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI VOID FASTCALL ExRundownCompleted ( _Out_ PEX_RUNDOWN_REF RunRef ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID FASTCALL ExWaitForRundownProtectionRelease ( _Inout_ PEX_RUNDOWN_REF RunRef ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PEX_RUNDOWN_REF_CACHE_AWARE ExAllocateCacheAwareRundownProtection( __drv_strictTypeMatch(__drv_typeExpr) _In_ POOL_TYPE PoolType, _In_ ULONG PoolTag ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI SIZE_T ExSizeOfRundownProtectionCacheAware( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExInitializeRundownProtectionCacheAware( _Out_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware, _In_ SIZE_T RunRefSize ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExFreeCacheAwareRundownProtection( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Must_inspect_result_ _Post_satisfies_(return == 0 || return == 1) NTKERNELAPI BOOLEAN FASTCALL ExAcquireRundownProtectionCacheAware ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTKERNELAPI VOID FASTCALL ExReleaseRundownProtectionCacheAware ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Must_inspect_result_ _Post_satisfies_(return == 0 || return == 1) NTKERNELAPI BOOLEAN FASTCALL ExAcquireRundownProtectionCacheAwareEx ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware, _In_ ULONG Count ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTKERNELAPI VOID FASTCALL ExReleaseRundownProtectionCacheAwareEx ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRef, _In_ ULONG Count ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTKERNELAPI VOID FASTCALL ExWaitForRundownProtectionReleaseCacheAware ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRef ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTKERNELAPI VOID FASTCALL ExReInitializeRundownProtectionCacheAware ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTKERNELAPI VOID FASTCALL ExRundownCompletedCacheAware ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware ); #endif // // TODO: t-chrisk - Need to update this to the Blue + 1 constant once available. // #if (NTDDI_VERSION >= NTDDI_WINBLUE) #define EX_CARR_ALLOCATE_PAGED_POOL 0x00000000 #define EX_CARR_ALLOCATE_NONPAGED_POOL 0x00000001 #define EX_CARR_DISABLE_EXPANSION 0x00000002 #define EX_CARR_VALID_FLAGS (EX_CARR_ALLOCATE_NONPAGED_POOL | \ EX_CARR_DISABLE_EXPANSION) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExInitializeRundownProtectionCacheAwareEx ( _Out_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware, _In_ ULONG Flags ); #endif // // TODO: t-chrisk - Need to update this to the Blue + 1 constant once available. // #if (NTDDI_VERSION >= NTDDI_WINBLUE) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ExCleanupRundownProtectionCacheAware ( _Inout_ PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware ); #endif // // Define shared spinlock type and function prototypes. // typedef volatile LONG EX_SPIN_LOCK, *PEX_SPIN_LOCK; #define ALIGNED_EX_SPINLOCK DECLSPEC_CACHEALIGN EX_SPIN_LOCK #if (NTDDI_VERSION >= NTDDI_VISTASP1) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID ExAcquireSpinLockSharedAtDpcLevel ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock ); _IRQL_saves_ _IRQL_raises_(DISPATCH_LEVEL) NTKERNELAPI KIRQL ExAcquireSpinLockShared ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock ); _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID ExReleaseSpinLockSharedFromDpcLevel ( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock ); _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI VOID ExReleaseSpinLockShared ( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock, _In_ _IRQL_restores_ KIRQL OldIrql ); _Must_inspect_result_ _IRQL_requires_(DISPATCH_LEVEL) _Post_satisfies_(return == 0 || return == 1) NTKERNELAPI LOGICAL ExTryConvertSharedSpinLockExclusive ( _Inout_ PEX_SPIN_LOCK SpinLock ); _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID ExAcquireSpinLockExclusiveAtDpcLevel ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock ); _IRQL_saves_ _IRQL_raises_(DISPATCH_LEVEL) NTKERNELAPI KIRQL ExAcquireSpinLockExclusive ( _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock ); _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID ExReleaseSpinLockExclusiveFromDpcLevel ( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock ); _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI VOID ExReleaseSpinLockExclusive ( _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PEX_SPIN_LOCK SpinLock, _In_ _IRQL_restores_ KIRQL OldIrql ); #endif //#if (NTDDI_VERSION >= NTDDI_VISTASP1) #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) _Must_inspect_result_ LOGICAL ExTryAcquireSpinLockSharedAtDpcLevel ( _When_ (return!=FALSE, _Requires_lock_not_held_ (*_Curr_) _Acquires_lock_ (*_Curr_)) _Inout_ PEX_SPIN_LOCK SpinLock ); _Must_inspect_result_ LOGICAL ExTryAcquireSpinLockExclusiveAtDpcLevel ( _When_ (return!=FALSE, _Requires_lock_not_held_ (*_Curr_) _Acquires_lock_ (*_Curr_)) _Inout_ PEX_SPIN_LOCK SpinLock ); #endif // // Define a block to hold the actual routine registration. // typedef _IRQL_requires_same_ _Function_class_(EX_CALLBACK_FUNCTION) NTSTATUS EX_CALLBACK_FUNCTION ( _In_ PVOID CallbackContext, _In_opt_ PVOID Argument1, _In_opt_ PVOID Argument2 ); typedef EX_CALLBACK_FUNCTION *PEX_CALLBACK_FUNCTION; #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI NTSTATUS ExGetFirmwareEnvironmentVariable ( _In_ PUNICODE_STRING VariableName, _In_ LPGUID VendorGuid, _Out_writes_bytes_opt_(*ValueLength) PVOID Value, _Inout_ PULONG ValueLength, _Out_opt_ PULONG Attributes ); NTKERNELAPI NTSTATUS ExSetFirmwareEnvironmentVariable ( _In_ PUNICODE_STRING VariableName, _In_ LPGUID VendorGuid, _In_reads_bytes_opt_(ValueLength) PVOID Value, _In_ ULONG ValueLength, _In_ ULONG Attributes ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI BOOLEAN ExIsManufacturingModeEnabled ( VOID ); #endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS ExEnumerateSystemFirmwareTables( _In_ ULONG FirmwareTableProviderSignature, _Out_writes_bytes_to_opt_(BufferLength, *ReturnLength) PVOID FirmwareTableBuffer, _In_ ULONG BufferLength, _Out_opt_ PULONG ReturnLength ); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS ExGetSystemFirmwareTable( _In_ ULONG FirmwareTableProviderSignature, _In_ ULONG FirmwareTableID, _Out_writes_bytes_to_opt_(BufferLength, *ReturnLength) PVOID FirmwareTableBuffer, _In_ ULONG BufferLength, _Out_opt_ PULONG ReturnLength ); #endif // #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) // // Registry kernel mode callbacks // // // Hook selector // typedef enum _REG_NOTIFY_CLASS { RegNtDeleteKey, RegNtPreDeleteKey = RegNtDeleteKey, RegNtSetValueKey, RegNtPreSetValueKey = RegNtSetValueKey, RegNtDeleteValueKey, RegNtPreDeleteValueKey = RegNtDeleteValueKey, RegNtSetInformationKey, RegNtPreSetInformationKey = RegNtSetInformationKey, RegNtRenameKey, RegNtPreRenameKey = RegNtRenameKey, RegNtEnumerateKey, RegNtPreEnumerateKey = RegNtEnumerateKey, RegNtEnumerateValueKey, RegNtPreEnumerateValueKey = RegNtEnumerateValueKey, RegNtQueryKey, RegNtPreQueryKey = RegNtQueryKey, RegNtQueryValueKey, RegNtPreQueryValueKey = RegNtQueryValueKey, RegNtQueryMultipleValueKey, RegNtPreQueryMultipleValueKey = RegNtQueryMultipleValueKey, RegNtPreCreateKey, RegNtPostCreateKey, RegNtPreOpenKey, RegNtPostOpenKey, RegNtKeyHandleClose, RegNtPreKeyHandleClose = RegNtKeyHandleClose, // // .Net only // RegNtPostDeleteKey, RegNtPostSetValueKey, RegNtPostDeleteValueKey, RegNtPostSetInformationKey, RegNtPostRenameKey, RegNtPostEnumerateKey, RegNtPostEnumerateValueKey, RegNtPostQueryKey, RegNtPostQueryValueKey, RegNtPostQueryMultipleValueKey, RegNtPostKeyHandleClose, RegNtPreCreateKeyEx, RegNtPostCreateKeyEx, RegNtPreOpenKeyEx, RegNtPostOpenKeyEx, // // new to Windows Vista // RegNtPreFlushKey, RegNtPostFlushKey, RegNtPreLoadKey, RegNtPostLoadKey, RegNtPreUnLoadKey, RegNtPostUnLoadKey, RegNtPreQueryKeySecurity, RegNtPostQueryKeySecurity, RegNtPreSetKeySecurity, RegNtPostSetKeySecurity, // // per-object context cleanup // RegNtCallbackObjectContextCleanup, // // new in Vista SP2 // RegNtPreRestoreKey, RegNtPostRestoreKey, RegNtPreSaveKey, RegNtPostSaveKey, RegNtPreReplaceKey, RegNtPostReplaceKey, // // new to Windows 10 // RegNtPreQueryKeyName, RegNtPostQueryKeyName, MaxRegNtNotifyClass //should always be the last enum } REG_NOTIFY_CLASS; // // Parameter description for each notify class // typedef struct _REG_DELETE_KEY_INFORMATION { PVOID Object; // IN PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_DELETE_KEY_INFORMATION, *PREG_DELETE_KEY_INFORMATION #if (NTDDI_VERSION >= NTDDI_VISTA) , REG_FLUSH_KEY_INFORMATION, *PREG_FLUSH_KEY_INFORMATION #endif // NTDDI_VERSION >= NTDDI_VISTA ; typedef struct _REG_SET_VALUE_KEY_INFORMATION { PVOID Object; // IN PUNICODE_STRING ValueName; // IN ULONG TitleIndex; // IN ULONG Type; // IN PVOID Data; // IN ULONG DataSize; // IN PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_SET_VALUE_KEY_INFORMATION, *PREG_SET_VALUE_KEY_INFORMATION; typedef struct _REG_DELETE_VALUE_KEY_INFORMATION { PVOID Object; // IN PUNICODE_STRING ValueName; // IN PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_DELETE_VALUE_KEY_INFORMATION, *PREG_DELETE_VALUE_KEY_INFORMATION; typedef struct _REG_SET_INFORMATION_KEY_INFORMATION { PVOID Object; // IN KEY_SET_INFORMATION_CLASS KeySetInformationClass; // IN PVOID KeySetInformation; // IN ULONG KeySetInformationLength;// IN PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_SET_INFORMATION_KEY_INFORMATION, *PREG_SET_INFORMATION_KEY_INFORMATION; typedef struct _REG_ENUMERATE_KEY_INFORMATION { PVOID Object; // IN ULONG Index; // IN KEY_INFORMATION_CLASS KeyInformationClass; // IN PVOID KeyInformation; // IN ULONG Length; // IN PULONG ResultLength; // OUT PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_ENUMERATE_KEY_INFORMATION, *PREG_ENUMERATE_KEY_INFORMATION; typedef struct _REG_ENUMERATE_VALUE_KEY_INFORMATION { PVOID Object; // IN ULONG Index; // IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass; // IN PVOID KeyValueInformation; // IN ULONG Length; // IN PULONG ResultLength; // OUT PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_ENUMERATE_VALUE_KEY_INFORMATION, *PREG_ENUMERATE_VALUE_KEY_INFORMATION; typedef struct _REG_QUERY_KEY_INFORMATION { PVOID Object; // IN KEY_INFORMATION_CLASS KeyInformationClass; // IN PVOID KeyInformation; // IN ULONG Length; // IN PULONG ResultLength; // OUT PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_QUERY_KEY_INFORMATION, *PREG_QUERY_KEY_INFORMATION; typedef struct _REG_QUERY_VALUE_KEY_INFORMATION { PVOID Object; // IN PUNICODE_STRING ValueName; // IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass; // IN PVOID KeyValueInformation; // IN ULONG Length; // IN PULONG ResultLength; // OUT PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_QUERY_VALUE_KEY_INFORMATION, *PREG_QUERY_VALUE_KEY_INFORMATION; typedef struct _REG_QUERY_MULTIPLE_VALUE_KEY_INFORMATION { PVOID Object; // IN PKEY_VALUE_ENTRY ValueEntries; // IN ULONG EntryCount; // IN PVOID ValueBuffer; // IN PULONG BufferLength; // IN OUT PULONG RequiredBufferLength; // OUT PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_QUERY_MULTIPLE_VALUE_KEY_INFORMATION, *PREG_QUERY_MULTIPLE_VALUE_KEY_INFORMATION; typedef struct _REG_RENAME_KEY_INFORMATION { PVOID Object; // IN PUNICODE_STRING NewName; // IN PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_RENAME_KEY_INFORMATION, *PREG_RENAME_KEY_INFORMATION; typedef struct _REG_KEY_HANDLE_CLOSE_INFORMATION { PVOID Object; // IN PVOID CallContext; // new to Windows Vista PVOID ObjectContext;// new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_KEY_HANDLE_CLOSE_INFORMATION, *PREG_KEY_HANDLE_CLOSE_INFORMATION; /* .Net Only */ typedef struct _REG_CREATE_KEY_INFORMATION { PUNICODE_STRING CompleteName; // IN PVOID RootObject; // IN PVOID ObjectType; // new to Windows Vista ULONG CreateOptions;// new to Windows Vista PUNICODE_STRING Class; // new to Windows Vista PVOID SecurityDescriptor;// new to Windows Vista PVOID SecurityQualityOfService;// new to Windows Vista ACCESS_MASK DesiredAccess;// new to Windows Vista ACCESS_MASK GrantedAccess;// new to Windows Vista // to be filled in by callbacks // when bypassing native code PULONG Disposition; // new to Windows Vista // on pass through, callback should fill // in disposition PVOID *ResultObject;// new to Windows Vista // on pass through, callback should return // object to be used for the return handle PVOID CallContext; // new to Windows Vista PVOID RootObjectContext; // new to Windows Vista PVOID Transaction; // new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_CREATE_KEY_INFORMATION, REG_OPEN_KEY_INFORMATION,*PREG_CREATE_KEY_INFORMATION, *PREG_OPEN_KEY_INFORMATION; typedef struct _REG_CREATE_KEY_INFORMATION_V1 { PUNICODE_STRING CompleteName; // IN PVOID RootObject; // IN PVOID ObjectType; // new to Windows Vista ULONG Options; // new to Windows Vista PUNICODE_STRING Class; // new to Windows Vista PVOID SecurityDescriptor;// new to Windows Vista PVOID SecurityQualityOfService;// new to Windows Vista ACCESS_MASK DesiredAccess;// new to Windows Vista ACCESS_MASK GrantedAccess;// new to Windows Vista // to be filled in by callbacks // when bypassing native code PULONG Disposition; // new to Windows Vista // on pass through, callback should fill // in disposition PVOID *ResultObject;// new to Windows Vista // on pass through, callback should return // object to be used for the return handle PVOID CallContext; // new to Windows Vista PVOID RootObjectContext; // new to Windows Vista PVOID Transaction; // new to Windows Vista ULONG_PTR Version; // following is new to Windows 7 PUNICODE_STRING RemainingName;// the true path left to parse ULONG Wow64Flags; // Wow64 specific flags gotten from DesiredAccess input ULONG Attributes; // ObjectAttributes->Attributes KPROCESSOR_MODE CheckAccessMode; // mode used for the securiry checks } REG_CREATE_KEY_INFORMATION_V1, REG_OPEN_KEY_INFORMATION_V1,*PREG_CREATE_KEY_INFORMATION_V1, *PREG_OPEN_KEY_INFORMATION_V1; typedef struct _REG_POST_OPERATION_INFORMATION { PVOID Object; // IN NTSTATUS Status; // IN PVOID PreInformation; // new to Windows Vista; identical with the pre information that was sent // in the pre notification NTSTATUS ReturnStatus; // new to Windows Vista; callback can now change the outcome of the operation // during post by returning the new staus here PVOID CallContext; // new to Windows Vista PVOID ObjectContext; // new to Windows Vista PVOID Reserved; // new to Windows Vista } REG_POST_OPERATION_INFORMATION,*PREG_POST_OPERATION_INFORMATION; /* end .Net Only */ /* XP only */ typedef struct _REG_PRE_CREATE_KEY_INFORMATION { PUNICODE_STRING CompleteName; // IN } REG_PRE_CREATE_KEY_INFORMATION, REG_PRE_OPEN_KEY_INFORMATION,*PREG_PRE_CREATE_KEY_INFORMATION, *PREG_PRE_OPEN_KEY_INFORMATION;; typedef struct _REG_POST_CREATE_KEY_INFORMATION { PUNICODE_STRING CompleteName; // IN PVOID Object; // IN NTSTATUS Status; // IN } REG_POST_CREATE_KEY_INFORMATION,REG_POST_OPEN_KEY_INFORMATION, *PREG_POST_CREATE_KEY_INFORMATION, *PREG_POST_OPEN_KEY_INFORMATION; /* end XP only */ /* new to Windows Vista */ #if (NTDDI_VERSION >= NTDDI_VISTA) typedef struct _REG_LOAD_KEY_INFORMATION { PVOID Object; PUNICODE_STRING KeyName; PUNICODE_STRING SourceFile; ULONG Flags; PVOID TrustClassObject; PVOID UserEvent; ACCESS_MASK DesiredAccess; PHANDLE RootHandle; PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_LOAD_KEY_INFORMATION, *PREG_LOAD_KEY_INFORMATION; typedef struct _REG_UNLOAD_KEY_INFORMATION { PVOID Object; PVOID UserEvent; PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_UNLOAD_KEY_INFORMATION, *PREG_UNLOAD_KEY_INFORMATION; typedef struct _REG_CALLBACK_CONTEXT_CLEANUP_INFORMATION { PVOID Object; PVOID ObjectContext; PVOID Reserved; } REG_CALLBACK_CONTEXT_CLEANUP_INFORMATION, *PREG_CALLBACK_CONTEXT_CLEANUP_INFORMATION; typedef struct _REG_QUERY_KEY_SECURITY_INFORMATION { PVOID Object; PSECURITY_INFORMATION SecurityInformation; // IN PSECURITY_DESCRIPTOR SecurityDescriptor; // INOUT PULONG Length; // INOUT PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_QUERY_KEY_SECURITY_INFORMATION, *PREG_QUERY_KEY_SECURITY_INFORMATION; typedef struct _REG_SET_KEY_SECURITY_INFORMATION { PVOID Object; PSECURITY_INFORMATION SecurityInformation; // IN PSECURITY_DESCRIPTOR SecurityDescriptor; // IN PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_SET_KEY_SECURITY_INFORMATION, *PREG_SET_KEY_SECURITY_INFORMATION; /* new in Vista SP2 - Restore, Save, Replace */ typedef struct _REG_RESTORE_KEY_INFORMATION { PVOID Object; HANDLE FileHandle; ULONG Flags; PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_RESTORE_KEY_INFORMATION, *PREG_RESTORE_KEY_INFORMATION; typedef struct _REG_SAVE_KEY_INFORMATION { PVOID Object; HANDLE FileHandle; ULONG Format; PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_SAVE_KEY_INFORMATION, *PREG_SAVE_KEY_INFORMATION; typedef struct _REG_REPLACE_KEY_INFORMATION { PVOID Object; PUNICODE_STRING OldFileName; PUNICODE_STRING NewFileName; PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_REPLACE_KEY_INFORMATION, *PREG_REPLACE_KEY_INFORMATION; #endif // NTDDI_VERSION >= NTDDI_VISTA typedef struct _REG_QUERY_KEY_NAME { PVOID Object; POBJECT_NAME_INFORMATION ObjectNameInfo; ULONG Length; PULONG ReturnLength; PVOID CallContext; PVOID ObjectContext; PVOID Reserved; } REG_QUERY_KEY_NAME, *PREG_QUERY_KEY_NAME; #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS CmRegisterCallback(_In_ PEX_CALLBACK_FUNCTION Function, _In_opt_ PVOID Context, _Out_ PLARGE_INTEGER Cookie ); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS CmUnRegisterCallback(_In_ LARGE_INTEGER Cookie); #endif // NTDDI_VERSION >= NTDDI_WINXP #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS CmRegisterCallbackEx ( _In_ PEX_CALLBACK_FUNCTION Function, _In_ PCUNICODE_STRING Altitude, _In_ PVOID Driver, //PDRIVER_OBJECT _In_opt_ PVOID Context, _Out_ PLARGE_INTEGER Cookie, _Reserved_ PVOID Reserved ); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID CmGetCallbackVersion ( _Out_opt_ PULONG Major, _Out_opt_ PULONG Minor ); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS CmSetCallbackObjectContext (_Inout_ PVOID Object, _In_ PLARGE_INTEGER Cookie, _In_ PVOID NewContext, _Out_opt_ PVOID *OldContext ); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS CmCallbackGetKeyObjectID ( _In_ PLARGE_INTEGER Cookie, _In_ PVOID Object, _Out_opt_ PULONG_PTR ObjectID, _Outptr_opt_ PCUNICODE_STRING *ObjectName ); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID CmGetBoundTransaction(_In_ PLARGE_INTEGER Cookie, _In_ PVOID Object ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS CmCallbackGetKeyObjectIDEx ( _In_ PLARGE_INTEGER Cookie, _In_ PVOID Object, _Out_opt_ PULONG_PTR ObjectID, _Outptr_opt_ PCUNICODE_STRING *ObjectName, _In_ ULONG Flags ); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID CmCallbackReleaseKeyObjectIDEx ( _In_ PCUNICODE_STRING ObjectName ); #endif // NTDDI_VERSION >= NTDDI_WIN8 // // Priority increment definitions. The comment for each definition gives // the names of the system services that use the definition when satisfying // a wait. // // // Priority increment used when satisfying a wait on an executive event // (NtPulseEvent and NtSetEvent) // #define EVENT_INCREMENT 1 // // Priority increment when no I/O has been done. This is used by device // and file system drivers when completing an IRP (IoCompleteRequest). // #define IO_NO_INCREMENT 0 // // Priority increment for completing CD-ROM I/O. This is used by CD-ROM device // and file system drivers when completing an IRP (IoCompleteRequest) // #define IO_CD_ROM_INCREMENT 1 // // Priority increment for completing disk I/O. This is used by disk device // and file system drivers when completing an IRP (IoCompleteRequest) // #define IO_DISK_INCREMENT 1 // // Priority increment for completing keyboard I/O. This is used by keyboard // device drivers when completing an IRP (IoCompleteRequest) // #define IO_KEYBOARD_INCREMENT 6 // // Priority increment for completing mailslot I/O. This is used by the mail- // slot file system driver when completing an IRP (IoCompleteRequest). // #define IO_MAILSLOT_INCREMENT 2 // // Priority increment for completing mouse I/O. This is used by mouse device // drivers when completing an IRP (IoCompleteRequest) // #define IO_MOUSE_INCREMENT 6 // // Priority increment for completing named pipe I/O. This is used by the // named pipe file system driver when completing an IRP (IoCompleteRequest). // #define IO_NAMED_PIPE_INCREMENT 2 // // Priority increment for completing network I/O. This is used by network // device and network file system drivers when completing an IRP // (IoCompleteRequest). // #define IO_NETWORK_INCREMENT 2 // // Priority increment for completing parallel I/O. This is used by parallel // device drivers when completing an IRP (IoCompleteRequest) // #define IO_PARALLEL_INCREMENT 1 // // Priority increment for completing serial I/O. This is used by serial device // drivers when completing an IRP (IoCompleteRequest) // #define IO_SERIAL_INCREMENT 2 // // Priority increment for completing sound I/O. This is used by sound device // drivers when completing an IRP (IoCompleteRequest) // #define IO_SOUND_INCREMENT 8 // // Priority increment for completing video I/O. This is used by video device // drivers when completing an IRP (IoCompleteRequest) // #define IO_VIDEO_INCREMENT 1 // // Priority increment used when satisfying a wait on an executive semaphore // (NtReleaseSemaphore) // #define SEMAPHORE_INCREMENT 1 // // Indicates the system may do I/O to physical addresses above 4 GB. // extern PBOOLEAN Mm64BitPhysicalAddress; // // Provides a known bad pointer address which always bugchecks if // acccessed. This gives drivers a way to find pointer bugs by // initializing invalid pointers to this value. // extern PVOID MmBadPointer; #define MM_BAD_POINTER ( \ __pragma(warning(push)) \ __pragma(warning(disable:4995)) \ *(PVOID *) MmBadPointer \ __pragma(warning(pop)) \ ) #pragma deprecated(MmBadPointer) // Use MM_BAD_POINTER instead // // Define the old maximum disk transfer size to be used by MM and Cache // Manager. Current transfer sizes can typically be much larger. // #define MM_MAXIMUM_DISK_IO_SIZE (0x10000) //++ // // ULONG_PTR // ROUND_TO_PAGES ( // _In_ ULONG_PTR Size // ) // // Routine Description: // // The ROUND_TO_PAGES macro takes a size in bytes and rounds it up to a // multiple of the page size. // // NOTE: This macro fails for values 0xFFFFFFFF - (PAGE_SIZE - 1). // // Arguments: // // Size - Size in bytes to round up to a page multiple. // // Return Value: // // Returns the size rounded up to a multiple of the page size. // //-- #define ROUND_TO_PAGES(Size) (((ULONG_PTR)(Size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)) //++ // // ULONG // BYTES_TO_PAGES ( // _In_ ULONG Size // ) // // Routine Description: // // The BYTES_TO_PAGES macro takes the size in bytes and calculates the // number of pages required to contain the bytes. // // Arguments: // // Size - Size in bytes. // // Return Value: // // Returns the number of pages required to contain the specified size. // //-- #define BYTES_TO_PAGES(Size) (((Size) >> PAGE_SHIFT) + \ (((Size) & (PAGE_SIZE - 1)) != 0)) //++ // // ULONG // BYTE_OFFSET ( // _In_ PVOID Va // ) // // Routine Description: // // The BYTE_OFFSET macro takes a virtual address and returns the byte offset // of that address within the page. // // Arguments: // // Va - Virtual address. // // Return Value: // // Returns the byte offset portion of the virtual address. // //-- #define BYTE_OFFSET(Va) ((ULONG)((LONG_PTR)(Va) & (PAGE_SIZE - 1))) //++ // // PVOID // PAGE_ALIGN ( // _In_ PVOID Va // ) // // Routine Description: // // The PAGE_ALIGN macro takes a virtual address and returns a page-aligned // virtual address for that page. // // Arguments: // // Va - Virtual address. // // Return Value: // // Returns the page aligned virtual address. // //-- #define PAGE_ALIGN(Va) ((PVOID)((ULONG_PTR)(Va) & ~(PAGE_SIZE - 1))) //++ // // SIZE_T // ADDRESS_AND_SIZE_TO_SPAN_PAGES ( // _In_ PVOID Va, // _In_ SIZE_T Size // ) // // Routine Description: // // The ADDRESS_AND_SIZE_TO_SPAN_PAGES macro takes a virtual address and // size and returns the number of pages spanned by the size. // // Arguments: // // Va - Virtual address. // // Size - Size in bytes. // // Return Value: // // Returns the number of pages spanned by the size. // //-- #define ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va,Size) \ ((BYTE_OFFSET (Va) + ((SIZE_T) (Size)) + (PAGE_SIZE - 1)) >> PAGE_SHIFT) #if PRAGMA_DEPRECATED_DDK #pragma deprecated(COMPUTE_PAGES_SPANNED) // Use ADDRESS_AND_SIZE_TO_SPAN_PAGES #endif #define COMPUTE_PAGES_SPANNED(Va, Size) ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va,Size) //++ // PPFN_NUMBER // MmGetMdlPfnArray ( // _In_ PMDL Mdl // ) // // Routine Description: // // The MmGetMdlPfnArray routine returns the virtual address of the // first element of the array of physical page numbers associated with // the MDL. // // Arguments: // // Mdl - Pointer to an MDL. // // Return Value: // // Returns the virtual address of the first element of the array of // physical page numbers associated with the MDL. // //-- #define MmGetMdlPfnArray(Mdl) ((PPFN_NUMBER)(Mdl + 1)) //++ // // PVOID // MmGetMdlVirtualAddress ( // _In_ PMDL Mdl // ) // // Routine Description: // // The MmGetMdlVirtualAddress returns the virtual address of the buffer // described by the Mdl. // // Arguments: // // Mdl - Pointer to an MDL. // // Return Value: // // Returns the virtual address of the buffer described by the Mdl // //-- #define MmGetMdlVirtualAddress(Mdl) \ ((PVOID) ((PCHAR) ((Mdl)->StartVa) + (Mdl)->ByteOffset)) //++ // // ULONG // MmGetMdlByteCount ( // _In_ PMDL Mdl // ) // // Routine Description: // // The MmGetMdlByteCount returns the length in bytes of the buffer // described by the Mdl. // // Arguments: // // Mdl - Pointer to an MDL. // // Return Value: // // Returns the byte count of the buffer described by the Mdl // //-- #define MmGetMdlByteCount(Mdl) ((Mdl)->ByteCount) //++ // // ULONG // MmGetMdlByteOffset ( // _In_ PMDL Mdl // ) // // Routine Description: // // The MmGetMdlByteOffset returns the byte offset within the page // of the buffer described by the Mdl. // // Arguments: // // Mdl - Pointer to an MDL. // // Return Value: // // Returns the byte offset within the page of the buffer described by the Mdl // //-- #define MmGetMdlByteOffset(Mdl) ((Mdl)->ByteOffset) //++ // // PVOID // MmGetMdlStartVa ( // _In_ PMDL Mdl // ) // // Routine Description: // // The MmGetMdlBaseVa returns the virtual address of the buffer // described by the Mdl rounded down to the nearest page. // // Arguments: // // Mdl - Pointer to an MDL. // // Return Value: // // Returns the returns the starting virtual address of the MDL. // // //-- #define MmGetMdlBaseVa(Mdl) ((Mdl)->StartVa) typedef enum _MM_SYSTEM_SIZE { MmSmallSystem, MmMediumSystem, MmLargeSystem } MM_SYSTEMSIZE; #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI MM_SYSTEMSIZE MmQuerySystemSize ( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS MmIsVerifierEnabled ( _Out_ PULONG VerifierFlags ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS MmAddVerifierThunks ( _In_reads_bytes_ (ThunkBufferSize) PVOID ThunkBuffer, _In_ ULONG ThunkBufferSize ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS MmAddVerifierSpecialThunks( _In_ ULONG_PTR EntryRoutine, _In_reads_bytes_(ThunkBufferSize) PVOID ThunkBuffer, _In_ ULONG ThunkBufferSize ); #endif // // I/O support routines. // _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI VOID MmProbeAndLockSelectedPages ( _Inout_ PMDL MemoryDescriptorList, _In_ PFILE_SEGMENT_ELEMENT SegmentArray, _In_ KPROCESSOR_MODE AccessMode, _In_ LOCK_OPERATION Operation ); #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI VOID MmProbeAndLockProcessPages ( _Inout_ PMDL MemoryDescriptorList, _In_ PEPROCESS Process, _In_ KPROCESSOR_MODE AccessMode, _In_ LOCK_OPERATION Operation ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _At_(MemoryDescriptorList->StartVa + MemoryDescriptorList->ByteOffset, _Field_size_bytes_opt_(MemoryDescriptorList->ByteCount)) // Esp:823 Esp:829 NTKERNELAPI VOID MmProbeAndLockPages ( _Inout_ PMDL MemoryDescriptorList, _In_ KPROCESSOR_MODE AccessMode, _In_ LOCK_OPERATION Operation ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmUnlockPages ( _Inout_ PMDL MemoryDescriptorList ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmBuildMdlForNonPagedPool ( _Inout_ PMDL MemoryDescriptorList ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) typedef struct _MM_PHYSICAL_ADDRESS_LIST { PHYSICAL_ADDRESS PhysicalAddress; SIZE_T NumberOfBytes; } MM_PHYSICAL_ADDRESS_LIST, *PMM_PHYSICAL_ADDRESS_LIST; _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI NTSTATUS MmAllocateMdlForIoSpace ( _In_reads_ (NumberOfEntries) PMM_PHYSICAL_ADDRESS_LIST PhysicalAddressList, _In_ SIZE_T NumberOfEntries, _Out_ PMDL *NewMdl ); _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI LOGICAL MmAreMdlPagesCached ( _In_ PMDL MemoryDescriptorList ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) #define MM_PERMANENT_ADDRESS_IS_IO_SPACE 0x1 _IRQL_requires_max_ (PASSIVE_LEVEL) NTKERNELAPI NTSTATUS MmSetPermanentCacheAttribute ( _In_ PHYSICAL_ADDRESS StartAddress, _In_ LARGE_INTEGER NumberOfBytes, _In_ MEMORY_CACHING_TYPE CacheType, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ __drv_preferredFunction("MmMapLockedPagesSpecifyCache", "Obsolete except on Windows 98. Use MmGetSystemAddressForMdlSafe if this " "is a call to MmGetSystemAddressForMdl.") _When_(AccessMode==0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(AccessMode==1, _Maybe_raises_SEH_exception_ _IRQL_requires_max_(APC_LEVEL)) DECLSPEC_DEPRECATED_DDK NTKERNELAPI PVOID MmMapLockedPages ( _Inout_ PMDL MemoryDescriptorList, _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE AccessMode ); #endif #if (NTDDI_VERSION >= NTDDI_WS03) _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI LOGICAL MmIsIoSpaceActive ( _In_ PHYSICAL_ADDRESS StartAddress, _In_ SIZE_T NumberOfBytes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PVOID NTAPI MmGetSystemRoutineAddress ( _In_ PUNICODE_STRING SystemRoutineName ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS MmAdvanceMdl ( _Inout_ PMDL Mdl, _In_ ULONG NumberOfBytes ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS MmProtectMdlSystemAddress ( _In_ PMDL MemoryDescriptorList, _In_ ULONG NewProtect ); #endif // // _MM_PAGE_PRIORITY_ provides a method for the system to handle requests // intelligently in low resource conditions. // // LowPagePriority should be used when it is acceptable to the driver for the // mapping request to fail if the system is low on resources. An example of // this could be for a non-critical network connection where the driver can // handle the failure case when system resources are close to being depleted. // // NormalPagePriority should be used when it is acceptable to the driver for the // mapping request to fail if the system is very low on resources. An example // of this could be for a non-critical local filesystem request. // // HighPagePriority should be used when it is unacceptable to the driver for the // mapping request to fail unless the system is completely out of resources. // An example of this would be the paging file path in a driver. // typedef enum _MM_PAGE_PRIORITY { LowPagePriority, NormalPagePriority = 16, HighPagePriority = 32 } MM_PAGE_PRIORITY; #define MdlMappingNoWrite 0x80000000 // Create the mapping as nowrite #define MdlMappingNoExecute 0x40000000 // Create the mapping as noexecute // // Note: This function is not available in WDM 1.0 // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Post_writable_byte_size_(MemoryDescriptorList->ByteCount) _When_(AccessMode==KernelMode, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(AccessMode==UserMode, _Maybe_raises_SEH_exception_ _IRQL_requires_max_(APC_LEVEL) _Post_notnull_) _At_(MemoryDescriptorList->MappedSystemVa, _Post_writable_byte_size_(MemoryDescriptorList->ByteCount)) // Esp:829 _Must_inspect_result_ _Success_(return != NULL) NTKERNELAPI PVOID MmMapLockedPagesSpecifyCache ( _Inout_ PMDL MemoryDescriptorList, _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE AccessMode, _In_ __drv_strictTypeMatch(__drv_typeCond) MEMORY_CACHING_TYPE CacheType, _In_opt_ PVOID RequestedAddress, _In_ ULONG BugCheckOnFailure, _In_ ULONG Priority // MM_PAGE_PRIORITY logically OR'd with MdlMapping* ); #if !POOL_NX_OPTOUT && (POOL_NX_OPTIN || POOL_NX_OPTIN_AUTO) // // If NX Pool Opt-In is enabled, then MmMapLockedPagesSpecifyCache calls are // remapped to go through the following forceinline. // // N.B. Should NX Pool Opt-In be enabled, ExInitializeDriverRuntime(...) *MUST* // be invoked before any calls to MmMapLockedPagesSpecifyCache in order // for Opt-In to be correctly applied. // FORCEINLINE _Post_writable_byte_size_(MemoryDescriptorList->ByteCount) _When_(AccessMode==KernelMode, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(AccessMode==UserMode, _Maybe_raises_SEH_exception_ _IRQL_requires_max_(APC_LEVEL) _Post_notnull_) _At_(MemoryDescriptorList->MappedSystemVa, _Post_writable_byte_size_(MemoryDescriptorList->ByteCount)) // Esp:829 _Must_inspect_result_ _Success_(return != NULL) PVOID MmMapLockedPagesSpecifyCache_NXOptIn ( _Inout_ PMDL MemoryDescriptorList, _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE AccessMode, _In_ __drv_strictTypeMatch(__drv_typeCond) MEMORY_CACHING_TYPE CacheType, _In_opt_ PVOID RequestedAddress, _In_ ULONG BugCheckOnFailure, _In_ ULONG Priority // MM_PAGE_PRIORITY logically OR'd with MdlMapping* ) { return MmMapLockedPagesSpecifyCache (MemoryDescriptorList, AccessMode, CacheType, RequestedAddress, BugCheckOnFailure, #if POOL_NX_OPTIN_AUTO Priority | MdlMappingNoExecute #else Priority | ExDefaultMdlProtection #endif ); } #define MmMapLockedPagesSpecifyCache MmMapLockedPagesSpecifyCache_NXOptIn #endif // !POOL_NX_OPTOUT && (POOL_NX_OPTIN || POOL_NX_OPTIN_AUTO) #endif // (NTDDI_VERSION >= NTDDI_WIN2K) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmUnmapLockedPages ( _In_ PVOID BaseAddress, _Inout_ PMDL MemoryDescriptorList ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI _When_ (return != NULL, _Out_writes_bytes_opt_ (NumberOfBytes)) PVOID MmAllocateMappingAddress ( _In_ SIZE_T NumberOfBytes, _In_ ULONG PoolTag ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID MmFreeMappingAddress ( _In_ PVOID BaseAddress, _In_ ULONG PoolTag ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _Post_writable_byte_size_(MemoryDescriptorList->ByteCount) _IRQL_requires_max_(DISPATCH_LEVEL) _At_( MemoryDescriptorList->MappedSystemVa + MemoryDescriptorList->ByteOffset, // Esp:823 _Post_writable_byte_size_(MemoryDescriptorList->ByteCount)) // Esp:829 _Must_inspect_result_ _Success_(return != NULL) NTKERNELAPI PVOID MmMapLockedPagesWithReservedMapping ( _In_ PVOID MappingAddress, _In_ ULONG PoolTag, _Inout_ PMDL MemoryDescriptorList, _In_ __drv_strictTypeMatch(__drv_typeCond) MEMORY_CACHING_TYPE CacheType ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmUnmapReservedMapping ( _In_ PVOID BaseAddress, _In_ ULONG PoolTag, _Inout_ PMDL MemoryDescriptorList ); #endif #define MM_DONT_ZERO_ALLOCATION 0x00000001 #define MM_ALLOCATE_FROM_LOCAL_NODE_ONLY 0x00000002 #define MM_ALLOCATE_FULLY_REQUIRED 0x00000004 #define MM_ALLOCATE_NO_WAIT 0x00000008 #define MM_ALLOCATE_PREFER_CONTIGUOUS 0x00000010 #define MM_ALLOCATE_REQUIRE_CONTIGUOUS_CHUNKS 0x00000020 #define MM_ALLOCATE_FAST_LARGE_PAGES 0x00000040 #define MM_ALLOCATE_TRIM_IF_NECESSARY 0x00000080 #define MM_ALLOCATE_AND_HOT_REMOVE 0x00000100 #if (NTDDI_VERSION >= NTDDI_WIN8) _Must_inspect_result_ _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI PMDL MmAllocateNodePagesForMdlEx ( _In_ PHYSICAL_ADDRESS LowAddress, _In_ PHYSICAL_ADDRESS HighAddress, _In_ PHYSICAL_ADDRESS SkipBytes, _In_ SIZE_T TotalBytes, _In_ MEMORY_CACHING_TYPE CacheType, _In_ ULONG IdealNode, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) _Must_inspect_result_ _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI PMDL MmAllocatePartitionNodePagesForMdlEx ( _In_ PHYSICAL_ADDRESS LowAddress, _In_ PHYSICAL_ADDRESS HighAddress, _In_ PHYSICAL_ADDRESS SkipBytes, _In_ SIZE_T TotalBytes, _In_ MEMORY_CACHING_TYPE CacheType, _In_ ULONG IdealNode, _In_ ULONG Flags, _In_opt_ PVOID PartitionObject ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _Must_inspect_result_ _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI PMDL MmAllocatePagesForMdlEx ( _In_ PHYSICAL_ADDRESS LowAddress, _In_ PHYSICAL_ADDRESS HighAddress, _In_ PHYSICAL_ADDRESS SkipBytes, _In_ SIZE_T TotalBytes, _In_ MEMORY_CACHING_TYPE CacheType, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PMDL MmAllocatePagesForMdl ( _In_ PHYSICAL_ADDRESS LowAddress, _In_ PHYSICAL_ADDRESS HighAddress, _In_ PHYSICAL_ADDRESS SkipBytes, _In_ SIZE_T TotalBytes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) #define MM_FREE_MDL_PAGES_ZERO 0x1 _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmFreePagesFromMdlEx ( _Inout_ PMDL MemoryDescriptorList, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmFreePagesFromMdl ( _Inout_ PMDL MemoryDescriptorList ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI _Out_writes_bytes_opt_ (NumberOfBytes) PVOID MmMapIoSpace ( _In_ PHYSICAL_ADDRESS PhysicalAddress, _In_ SIZE_T NumberOfBytes, _In_ MEMORY_CACHING_TYPE CacheType ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmUnmapIoSpace ( _In_reads_bytes_ (NumberOfBytes) PVOID BaseAddress, _In_ SIZE_T NumberOfBytes ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _Must_inspect_result_ _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI _Out_writes_bytes_opt_ (NumberOfBytes) PVOID MmMapIoSpaceEx ( _In_ PHYSICAL_ADDRESS PhysicalAddress, _In_ SIZE_T NumberOfBytes, _In_ ULONG Protect ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI _When_ (return != NULL, _Post_writable_byte_size_ (NumberOfBytes)) PVOID MmAllocateContiguousMemory ( _In_ SIZE_T NumberOfBytes, _In_ PHYSICAL_ADDRESS HighestAcceptableAddress ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI _When_ (return != NULL, _Post_writable_byte_size_ (NumberOfBytes)) PVOID MmAllocateContiguousMemorySpecifyCache ( _In_ SIZE_T NumberOfBytes, _In_ PHYSICAL_ADDRESS LowestAcceptableAddress, _In_ PHYSICAL_ADDRESS HighestAcceptableAddress, _In_opt_ PHYSICAL_ADDRESS BoundaryAddressMultiple, _In_ MEMORY_CACHING_TYPE CacheType ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) typedef ULONG NODE_REQUIREMENT; #define MM_ANY_NODE_OK 0x80000000 #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI _When_ (return != NULL, _Post_writable_byte_size_ (NumberOfBytes)) PVOID MmAllocateContiguousMemorySpecifyCacheNode ( _In_ SIZE_T NumberOfBytes, _In_ PHYSICAL_ADDRESS LowestAcceptableAddress, _In_ PHYSICAL_ADDRESS HighestAcceptableAddress, _In_opt_ PHYSICAL_ADDRESS BoundaryAddressMultiple, _In_ MEMORY_CACHING_TYPE CacheType, _In_ NODE_REQUIREMENT PreferredNode ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI _When_ (return != NULL, _Post_writable_byte_size_ (NumberOfBytes)) PVOID MmAllocateContiguousNodeMemory ( _In_ SIZE_T NumberOfBytes, _In_ PHYSICAL_ADDRESS LowestAcceptableAddress, _In_ PHYSICAL_ADDRESS HighestAcceptableAddress, _In_opt_ PHYSICAL_ADDRESS BoundaryAddressMultiple, _In_ ULONG Protect, _In_ NODE_REQUIREMENT PreferredNode ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmFreeContiguousMemory ( _In_ PVOID BaseAddress ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI VOID MmFreeContiguousMemorySpecifyCache ( _In_reads_bytes_ (NumberOfBytes) PVOID BaseAddress, _In_ SIZE_T NumberOfBytes, _In_ MEMORY_CACHING_TYPE CacheType ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI SIZE_T MmSizeOfMdl ( _In_reads_bytes_opt_ (Length) PVOID Base, _In_ SIZE_T Length ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) DECLSPEC_DEPRECATED_DDK // Use IoAllocateMdl __drv_preferredFunction("IoAllocateMdl","Obsolete") NTKERNELAPI PMDL MmCreateMdl ( _Out_writes_bytes_opt_ (sizeof (MDL) + (sizeof (PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES (Base, Length))) PMDL MemoryDescriptorList, _In_reads_bytes_opt_ (Length) PVOID Base, _In_ SIZE_T Length ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) typedef enum _MM_MDL_PAGE_CONTENTS_STATE { MmMdlPageContentsDynamic, MmMdlPageContentsInvariant, MmMdlPageContentsQuery } MM_MDL_PAGE_CONTENTS_STATE, PMM_MDL_PAGE_CONTENTS_STATE; _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI MM_MDL_PAGE_CONTENTS_STATE MmMdlPageContentsState ( _Inout_ PMDL MemoryDescriptorList, _In_ MM_MDL_PAGE_CONTENTS_STATE State ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID MmLockPagableDataSection ( _In_ PVOID AddressWithinSection ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID MmResetDriverPaging ( _In_ PVOID AddressWithinSection ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID MmPageEntireDriver ( _In_ PVOID AddressWithinSection ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID MmUnlockPagableImageSection ( _In_ PVOID ImageSectionHandle ); #endif _IRQL_requires_max_(DISPATCH_LEVEL) FORCEINLINE VOID MmInitializeMdl ( _Out_writes_bytes_(sizeof(MDL)+(sizeof(PFN_NUMBER)*ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseVa,Length))) PMDL MemoryDescriptorList, _In_opt_ PVOID BaseVa, _In_ SIZE_T Length ) //++ // // Routine Description: // // This routine initializes the header of a Memory Descriptor List (MDL). // // Arguments: // // MemoryDescriptorList - Pointer to the MDL to initialize. // // BaseVa - Base virtual address mapped by the MDL. // // Length - Length, in bytes, of the buffer mapped by the MDL. // // Return Value: // // None. // //-- { MemoryDescriptorList->Next = (PMDL) NULL; MemoryDescriptorList->Size = (CSHORT)(sizeof(MDL) + (sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseVa, Length))); MemoryDescriptorList->MdlFlags = 0; MemoryDescriptorList->StartVa = (PVOID) PAGE_ALIGN(BaseVa); MemoryDescriptorList->ByteOffset = BYTE_OFFSET(BaseVa); MemoryDescriptorList->ByteCount = (ULONG)Length; } #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _Post_writable_byte_size_(Mdl->ByteCount) _At_(Mdl->MappedSystemVa, _Post_writable_byte_size_(Mdl->ByteCount)) // Esp:829 _Check_return_ _Success_(return != NULL) FORCEINLINE PVOID MmGetSystemAddressForMdlSafe ( _Inout_ PMDL Mdl, _In_ ULONG Priority // MM_PAGE_PRIORITY logically OR'd with MdlMapping* ) //++ // // Routine Description: // // This routine returns the mapped address of an MDL. If the // Mdl is not already mapped or a system address, it is mapped. // // Arguments: // // MemoryDescriptorList - Pointer to the MDL to map. // // Priority - Supplies an indication as to how important it is that this // request succeed under low available PTE conditions. // // Return Value: // // Returns the base address where the pages are mapped. The base address // has the same offset as the virtual address in the MDL. // // Unlike MmGetSystemAddressForMdl, Safe guarantees that it will always // return NULL on failure instead of bugchecking the system. // // This routine is not usable by WDM 1.0 drivers as 1.0 did not include // MmMapLockedPagesSpecifyCache. The solution for WDM 1.0 drivers is to // provide synchronization and set/reset the MDL_MAPPING_CAN_FAIL bit. // //-- { if (Mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | MDL_SOURCE_IS_NONPAGED_POOL)) { return Mdl->MappedSystemVa; } else { return MmMapLockedPagesSpecifyCache(Mdl, KernelMode, MmCached, NULL, FALSE, Priority); } } #endif //++ // // PVOID // MmGetSystemAddressForMdl ( // _In_ PMDL MDL // ) // // Routine Description: // // This routine returns the mapped address of an MDL, if the // Mdl is not already mapped or a system address, it is mapped. // // Arguments: // // MemoryDescriptorList - Pointer to the MDL to map. // // Return Value: // // Returns the base address where the pages are mapped. The base address // has the same offset as the virtual address in the MDL. // //-- //#define MmGetSystemAddressForMdl(MDL) // (((MDL)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA)) ? // ((MDL)->MappedSystemVa) : // ((((MDL)->MdlFlags & (MDL_SOURCE_IS_NONPAGED_POOL)) ? // ((PVOID)((ULONG)(MDL)->StartVa | (MDL)->ByteOffset)) : // (MmMapLockedPages((MDL),KernelMode))))) #if PRAGMA_DEPRECATED_DDK #pragma deprecated(MmGetSystemAddressForMdl) // Use MmGetSystemAddressForMdlSafe #endif #define MmGetSystemAddressForMdl(MDL) \ (((MDL)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | \ MDL_SOURCE_IS_NONPAGED_POOL)) ? \ ((MDL)->MappedSystemVa) : \ (MmMapLockedPages((MDL),KernelMode))) _IRQL_requires_max_(DISPATCH_LEVEL) VOID FORCEINLINE MmPrepareMdlForReuse ( _Inout_ PMDL MDL ) //++ // // Routine Description: // // This routine will take all of the steps necessary to allow an MDL to be // re-used. // // Arguments: // // MemoryDescriptorList - Pointer to the MDL that will be re-used. // // Return Value: // // None. // //-- { if ((MDL->MdlFlags & MDL_PARTIAL_HAS_BEEN_MAPPED) != 0) { NT_ASSERT((MDL->MdlFlags & MDL_PARTIAL) != 0); MmUnmapLockedPages( MDL->MappedSystemVa, MDL ); } else if ((MDL->MdlFlags & MDL_PARTIAL) == 0) { NT_ASSERT((MDL->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA) == 0); } } typedef NTSTATUS (*PMM_DLL_INITIALIZE) ( _In_ PUNICODE_STRING RegistryPath ); typedef NTSTATUS (*PMM_DLL_UNLOAD) ( VOID ); // // Define an empty typedef for the _DRIVER_OBJECT structure so it may be // referenced by function types before it is actually defined. // struct _DRIVER_OBJECT; #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI LOGICAL MmIsDriverSuspectForVerifier ( _In_ struct _DRIVER_OBJECT *DriverObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI LOGICAL MmIsDriverVerifying ( _In_ struct _DRIVER_OBJECT *DriverObject ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI LOGICAL MmIsDriverVerifyingByAddress ( _In_ PVOID AddressWithinSection ); #endif // // Security operation codes // typedef enum _SECURITY_OPERATION_CODE { SetSecurityDescriptor, QuerySecurityDescriptor, DeleteSecurityDescriptor, AssignSecurityDescriptor } SECURITY_OPERATION_CODE, *PSECURITY_OPERATION_CODE; // // Data structure used to capture subject security context // for access validations and auditing. // // THE FIELDS OF THIS DATA STRUCTURE SHOULD BE CONSIDERED OPAQUE // BY ALL EXCEPT THE SECURITY ROUTINES. // typedef struct _SECURITY_SUBJECT_CONTEXT { PACCESS_TOKEN ClientToken; SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; PACCESS_TOKEN PrimaryToken; PVOID ProcessAuditId; } SECURITY_SUBJECT_CONTEXT, *PSECURITY_SUBJECT_CONTEXT; /////////////////////////////////////////////////////////////////////////////// // // // ACCESS_STATE and related structures // // // /////////////////////////////////////////////////////////////////////////////// // // Initial Privilege Set - Room for three privileges, which should // be enough for most applications. This structure exists so that // it can be embedded in an ACCESS_STATE structure. Use PRIVILEGE_SET // for all other references to Privilege sets. // #define INITIAL_PRIVILEGE_COUNT 3 typedef struct _INITIAL_PRIVILEGE_SET { ULONG PrivilegeCount; ULONG Control; LUID_AND_ATTRIBUTES Privilege[INITIAL_PRIVILEGE_COUNT]; } INITIAL_PRIVILEGE_SET, *PINITIAL_PRIVILEGE_SET; // // Combine the information that describes the state // of an access-in-progress into a single structure // typedef struct _ACCESS_STATE { LUID OperationID; // Currently unused, replaced by TransactionId in AUX_ACCESS_DATA BOOLEAN SecurityEvaluated; BOOLEAN GenerateAudit; BOOLEAN GenerateOnClose; BOOLEAN PrivilegesAllocated; ULONG Flags; ACCESS_MASK RemainingDesiredAccess; ACCESS_MASK PreviouslyGrantedAccess; ACCESS_MASK OriginalDesiredAccess; SECURITY_SUBJECT_CONTEXT SubjectSecurityContext; PSECURITY_DESCRIPTOR SecurityDescriptor; // it stores SD supplied by caller when creating a new object. PVOID AuxData; union { INITIAL_PRIVILEGE_SET InitialPrivilegeSet; PRIVILEGE_SET PrivilegeSet; } Privileges; BOOLEAN AuditPrivileges; UNICODE_STRING ObjectName; UNICODE_STRING ObjectTypeName; } ACCESS_STATE, *PACCESS_STATE; typedef VOID NTFS_DEREF_EXPORTED_SECURITY_DESCRIPTOR( _In_ PVOID Vcb, _In_ PSECURITY_DESCRIPTOR SecurityDescriptor); typedef NTFS_DEREF_EXPORTED_SECURITY_DESCRIPTOR *PNTFS_DEREF_EXPORTED_SECURITY_DESCRIPTOR; #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID SeCaptureSubjectContext ( _Out_ PSECURITY_SUBJECT_CONTEXT SubjectContext ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID SeLockSubjectContext( _In_ PSECURITY_SUBJECT_CONTEXT SubjectContext ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID SeUnlockSubjectContext( _In_ PSECURITY_SUBJECT_CONTEXT SubjectContext ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID SeReleaseSubjectContext ( _Inout_ PSECURITY_SUBJECT_CONTEXT SubjectContext ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS SeAssignSecurity ( _In_opt_ PSECURITY_DESCRIPTOR ParentDescriptor, _In_opt_ PSECURITY_DESCRIPTOR ExplicitDescriptor, _Out_ PSECURITY_DESCRIPTOR *NewDescriptor, _In_ BOOLEAN IsDirectoryObject, _In_ PSECURITY_SUBJECT_CONTEXT SubjectContext, _In_ PGENERIC_MAPPING GenericMapping, _In_ POOL_TYPE PoolType ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI ULONG SeComputeAutoInheritByObjectType( _In_ PVOID ObjectType, _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_opt_ PSECURITY_DESCRIPTOR ParentSecurityDescriptor ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI NTSTATUS SeAssignSecurityEx ( _In_opt_ PSECURITY_DESCRIPTOR ParentDescriptor, _In_opt_ PSECURITY_DESCRIPTOR ExplicitDescriptor, _Out_ PSECURITY_DESCRIPTOR *NewDescriptor, _In_opt_ GUID *ObjectType, _In_ BOOLEAN IsDirectoryObject, _In_ ULONG AutoInheritFlags, _In_ PSECURITY_SUBJECT_CONTEXT SubjectContext, _In_ PGENERIC_MAPPING GenericMapping, _In_ POOL_TYPE PoolType ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS SeDeassignSecurity ( _Inout_ PSECURITY_DESCRIPTOR *SecurityDescriptor ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI ULONG SeObjectCreateSaclAccessBits( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor ); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI BOOLEAN SeAccessCheck ( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ PSECURITY_SUBJECT_CONTEXT SubjectSecurityContext, _In_ BOOLEAN SubjectContextLocked, _In_ ACCESS_MASK DesiredAccess, _In_ ACCESS_MASK PreviouslyGrantedAccess, _Outptr_opt_ PPRIVILEGE_SET *Privileges, _In_ PGENERIC_MAPPING GenericMapping, _In_ KPROCESSOR_MODE AccessMode, _Out_ PACCESS_MASK GrantedAccess, _Out_ PNTSTATUS AccessStatus ); #endif #ifdef SE_NTFS_WORLD_CACHE #if (NTDDI_VERSION >= NTDDI_VISTA) VOID SeGetWorldRights ( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ PGENERIC_MAPPING GenericMapping, _Out_ PACCESS_MASK GrantedAccess ); #endif #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) _At_(AuditParameters->ParameterCount, _Const_) NTSTATUS SeSetAuditParameter( _Inout_ PSE_ADT_PARAMETER_ARRAY AuditParameters, _In_ SE_ADT_PARAMETER_TYPE Type, _In_range_(<,SE_MAX_AUDIT_PARAMETERS) ULONG Index, _In_reads_(_Inexpressible_("depends on SE_ADT_PARAMETER_TYPE")) PVOID Data ); #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) NTSTATUS SeReportSecurityEvent( _In_ ULONG Flags, _In_ PUNICODE_STRING SourceName, _In_opt_ PSID UserSid, _In_ PSE_ADT_PARAMETER_ARRAY AuditParameters ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI BOOLEAN SeValidSecurityDescriptor( _In_ ULONG Length, _In_reads_bytes_(Length) PSECURITY_DESCRIPTOR SecurityDescriptor ); #endif // // Types of images. // typedef enum _SE_IMAGE_TYPE { SeImageTypeElamDriver = 0, SeImageTypeDriver, SeImageTypeMax } SE_IMAGE_TYPE, *PSE_IMAGE_TYPE; typedef struct _BDCB_IMAGE_INFORMATION *PBDCB_IMAGE_INFORMATION; typedef _IRQL_requires_same_ _Function_class_(SE_IMAGE_VERIFICATION_CALLBACK_FUNCTION) VOID SE_IMAGE_VERIFICATION_CALLBACK_FUNCTION ( _In_opt_ PVOID CallbackContext, _In_ SE_IMAGE_TYPE ImageType, _Inout_ PBDCB_IMAGE_INFORMATION ImageInformation ); typedef SE_IMAGE_VERIFICATION_CALLBACK_FUNCTION *PSE_IMAGE_VERIFICATION_CALLBACK_FUNCTION; typedef enum _SE_IMAGE_VERIFICATION_CALLBACK_TYPE { SeImageVerificationCallbackInformational = 0 } SE_IMAGE_VERIFICATION_CALLBACK_TYPE, *PSE_IMAGE_VERIFICATION_CALLBACK_TYPE; typedef PVOID SE_IMAGE_VERIFICATION_CALLBACK_TOKEN, *PSE_IMAGE_VERIFICATION_CALLBACK_TOKEN; #if (NTDDI_VERSION >= NTDDI_WINBLUE) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS SeRegisterImageVerificationCallback( _In_ SE_IMAGE_TYPE ImageType, _In_ SE_IMAGE_VERIFICATION_CALLBACK_TYPE CallbackType, _In_ PSE_IMAGE_VERIFICATION_CALLBACK_FUNCTION CallbackFunction, _In_opt_ PVOID CallbackContext, _Reserved_ SE_IMAGE_VERIFICATION_CALLBACK_TOKEN Token, _Out_ PVOID* CallbackHandle ); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID SeUnregisterImageVerificationCallback ( _In_ PVOID CallbackHandle ); #endif #if !defined(_PSGETCURRENTTHREAD_) #define _PSGETCURRENTTHREAD_ _IRQL_requires_max_(DISPATCH_LEVEL) CFORCEINLINE PETHREAD PsGetCurrentThread ( VOID ) /*++ Routine Description: This function returns a pointer to the current executive thread object. Arguments: None. Return Value: A pointer to the current executive thread object. --*/ { return (PETHREAD)KeGetCurrentThread(); } #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI _Must_inspect_result_ NTSTATUS PsCreateSystemThread( _Out_ PHANDLE ThreadHandle, _In_ ULONG DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ HANDLE ProcessHandle, _Out_opt_ PCLIENT_ID ClientId, _In_ PKSTART_ROUTINE StartRoutine, _In_opt_ _When_(return >= 0, __drv_aliasesMem) PVOID StartContext ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS PsTerminateSystemThread( _In_ NTSTATUS ExitStatus ); #endif NTKERNELAPI NTSTATUS PsWrapApcWow64Thread ( _Inout_ PVOID *ApcContext, _Inout_ PVOID *ApcRoutine); #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) __drv_preferredFunction("RtlGetVersion", "Obsolete") NTKERNELAPI BOOLEAN PsGetVersion( _Out_opt_ PULONG MajorVersion, _Out_opt_ PULONG MinorVersion, _Out_opt_ PULONG BuildNumber, _Out_opt_ PUNICODE_STRING CSDVersion ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(PASSIVE_LEVEL) ULONG64 PsQueryTotalCycleTimeProcess ( _Inout_ PEPROCESS Process, _Out_ PULONG64 CycleTimeStamp ); #endif // // Define I/O system data structure type codes. Each major data structure in // the I/O system has a type code The type field in each structure is at the // same offset. The following values can be used to determine which type of // data structure a pointer refers to. // #define IO_TYPE_ADAPTER 0x00000001 #define IO_TYPE_CONTROLLER 0x00000002 #define IO_TYPE_DEVICE 0x00000003 #define IO_TYPE_DRIVER 0x00000004 #define IO_TYPE_FILE 0x00000005 #define IO_TYPE_IRP 0x00000006 #define IO_TYPE_MASTER_ADAPTER 0x00000007 #define IO_TYPE_OPEN_PACKET 0x00000008 #define IO_TYPE_TIMER 0x00000009 #define IO_TYPE_VPB 0x0000000a #define IO_TYPE_ERROR_LOG 0x0000000b #define IO_TYPE_ERROR_MESSAGE 0x0000000c #define IO_TYPE_DEVICE_OBJECT_EXTENSION 0x0000000d // // Define the major function codes for IRPs. // #define IRP_MJ_CREATE 0x00 #define IRP_MJ_CREATE_NAMED_PIPE 0x01 #define IRP_MJ_CLOSE 0x02 #define IRP_MJ_READ 0x03 #define IRP_MJ_WRITE 0x04 #define IRP_MJ_QUERY_INFORMATION 0x05 #define IRP_MJ_SET_INFORMATION 0x06 #define IRP_MJ_QUERY_EA 0x07 #define IRP_MJ_SET_EA 0x08 #define IRP_MJ_FLUSH_BUFFERS 0x09 #define IRP_MJ_QUERY_VOLUME_INFORMATION 0x0a #define IRP_MJ_SET_VOLUME_INFORMATION 0x0b #define IRP_MJ_DIRECTORY_CONTROL 0x0c #define IRP_MJ_FILE_SYSTEM_CONTROL 0x0d #define IRP_MJ_DEVICE_CONTROL 0x0e #define IRP_MJ_INTERNAL_DEVICE_CONTROL 0x0f #define IRP_MJ_SHUTDOWN 0x10 #define IRP_MJ_LOCK_CONTROL 0x11 #define IRP_MJ_CLEANUP 0x12 #define IRP_MJ_CREATE_MAILSLOT 0x13 #define IRP_MJ_QUERY_SECURITY 0x14 #define IRP_MJ_SET_SECURITY 0x15 #define IRP_MJ_POWER 0x16 #define IRP_MJ_SYSTEM_CONTROL 0x17 #define IRP_MJ_DEVICE_CHANGE 0x18 #define IRP_MJ_QUERY_QUOTA 0x19 #define IRP_MJ_SET_QUOTA 0x1a #define IRP_MJ_PNP 0x1b #define IRP_MJ_PNP_POWER IRP_MJ_PNP // Obsolete.... #define IRP_MJ_MAXIMUM_FUNCTION 0x1b // // Make the Scsi major code the same as internal device control. // #define IRP_MJ_SCSI IRP_MJ_INTERNAL_DEVICE_CONTROL // // Define the minor function codes for IRPs. The lower 128 codes, from 0x00 to // 0x7f are reserved to Microsoft. The upper 128 codes, from 0x80 to 0xff, are // reserved to customers of Microsoft. // // // Device Control Request minor function codes for SCSI support. Note that // user requests are assumed to be zero. // #define IRP_MN_SCSI_CLASS 0x01 // // PNP minor function codes. // #define IRP_MN_START_DEVICE 0x00 #define IRP_MN_QUERY_REMOVE_DEVICE 0x01 #define IRP_MN_REMOVE_DEVICE 0x02 #define IRP_MN_CANCEL_REMOVE_DEVICE 0x03 #define IRP_MN_STOP_DEVICE 0x04 #define IRP_MN_QUERY_STOP_DEVICE 0x05 #define IRP_MN_CANCEL_STOP_DEVICE 0x06 #define IRP_MN_QUERY_DEVICE_RELATIONS 0x07 #define IRP_MN_QUERY_INTERFACE 0x08 #define IRP_MN_QUERY_CAPABILITIES 0x09 #define IRP_MN_QUERY_RESOURCES 0x0A #define IRP_MN_QUERY_RESOURCE_REQUIREMENTS 0x0B #define IRP_MN_QUERY_DEVICE_TEXT 0x0C #define IRP_MN_FILTER_RESOURCE_REQUIREMENTS 0x0D #define IRP_MN_READ_CONFIG 0x0F #define IRP_MN_WRITE_CONFIG 0x10 #define IRP_MN_EJECT 0x11 #define IRP_MN_SET_LOCK 0x12 #define IRP_MN_QUERY_ID 0x13 #define IRP_MN_QUERY_PNP_DEVICE_STATE 0x14 #define IRP_MN_QUERY_BUS_INFORMATION 0x15 #define IRP_MN_DEVICE_USAGE_NOTIFICATION 0x16 #define IRP_MN_SURPRISE_REMOVAL 0x17 #if (NTDDI_VERSION >= NTDDI_WIN7) #define IRP_MN_DEVICE_ENUMERATED 0x19 #endif // // POWER minor function codes // #define IRP_MN_WAIT_WAKE 0x00 #define IRP_MN_POWER_SEQUENCE 0x01 #define IRP_MN_SET_POWER 0x02 #define IRP_MN_QUERY_POWER 0x03 // // WMI minor function codes under IRP_MJ_SYSTEM_CONTROL // #define IRP_MN_QUERY_ALL_DATA 0x00 #define IRP_MN_QUERY_SINGLE_INSTANCE 0x01 #define IRP_MN_CHANGE_SINGLE_INSTANCE 0x02 #define IRP_MN_CHANGE_SINGLE_ITEM 0x03 #define IRP_MN_ENABLE_EVENTS 0x04 #define IRP_MN_DISABLE_EVENTS 0x05 #define IRP_MN_ENABLE_COLLECTION 0x06 #define IRP_MN_DISABLE_COLLECTION 0x07 #define IRP_MN_REGINFO 0x08 #define IRP_MN_EXECUTE_METHOD 0x09 // Minor code 0x0a is reserved #define IRP_MN_REGINFO_EX 0x0b // Minor code 0x0c is reserved // // Define option flags for IoCreateFile. Note that these values must be // exactly the same as the SL_... flags for a create function. Note also // that there are flags that may be passed to IoCreateFile that are not // placed in the stack location for the create IRP. These flags start in // the next byte. // #define IO_FORCE_ACCESS_CHECK 0x0001 #define IO_NO_PARAMETER_CHECKING 0x0100 // // Define Information fields for whether or not a REPARSE or a REMOUNT has // occurred in the file system. // #define IO_REPARSE 0x0 #define IO_REMOUNT 0x1 #define IO_REPARSE_GLOBAL 0x2 // // Define the objects that can be created by IoCreateFile. // typedef enum _CREATE_FILE_TYPE { CreateFileTypeNone, CreateFileTypeNamedPipe, CreateFileTypeMailslot } CREATE_FILE_TYPE; // // Define the named pipe create parameters structure used for internal calls // to IoCreateFile when a named pipe is being created. This structure allows // code invoking this routine to pass information specific to this function // when creating a named pipe. // typedef struct _NAMED_PIPE_CREATE_PARAMETERS { ULONG NamedPipeType; ULONG ReadMode; ULONG CompletionMode; ULONG MaximumInstances; ULONG InboundQuota; ULONG OutboundQuota; LARGE_INTEGER DefaultTimeout; BOOLEAN TimeoutSpecified; } NAMED_PIPE_CREATE_PARAMETERS, *PNAMED_PIPE_CREATE_PARAMETERS; // // Define the mailslot create parameters structure used for internal calls // to IoCreateFile when a mailslot is being created. This structure allows // code invoking this routine to pass information specific to this function // when creating a mailslot. // typedef struct _MAILSLOT_CREATE_PARAMETERS { ULONG MailslotQuota; ULONG MaximumMessageSize; LARGE_INTEGER ReadTimeout; BOOLEAN TimeoutSpecified; } MAILSLOT_CREATE_PARAMETERS, *PMAILSLOT_CREATE_PARAMETERS; // // Define the structures used by the I/O system // // // Define empty typedefs for the _IRP, _DEVICE_OBJECT, and _DRIVER_OBJECT // structures so they may be referenced by function types before they are // actually defined. // struct _DEVICE_DESCRIPTION; struct _DEVICE_OBJECT; struct _DMA_ADAPTER; struct _DRIVER_OBJECT; struct _DRIVE_LAYOUT_INFORMATION; struct _DISK_PARTITION; struct _FILE_OBJECT; #if defined(_WIN64) #define POINTER_ALIGNMENT DECLSPEC_ALIGN(8) #else #define POINTER_ALIGNMENT #endif struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _IRP; struct _SCSI_REQUEST_BLOCK; struct _SCATTER_GATHER_LIST; // // Define the I/O version of a DPC routine. // _Function_class_(IO_DPC_ROUTINE) _IRQL_always_function_min_(DISPATCH_LEVEL) _IRQL_requires_(DISPATCH_LEVEL) _IRQL_requires_same_ typedef VOID IO_DPC_ROUTINE ( _In_ PKDPC Dpc, _In_ struct _DEVICE_OBJECT *DeviceObject, _Inout_ struct _IRP *Irp, _In_opt_ PVOID Context ); typedef IO_DPC_ROUTINE *PIO_DPC_ROUTINE; // // Define driver timer routine type. // _Function_class_(IO_TIMER_ROUTINE) _IRQL_requires_same_ typedef VOID IO_TIMER_ROUTINE ( _In_ struct _DEVICE_OBJECT *DeviceObject, _In_opt_ PVOID Context ); typedef IO_TIMER_ROUTINE *PIO_TIMER_ROUTINE; // // Define driver initialization routine type. // _Function_class_(DRIVER_INITIALIZE) _IRQL_requires_same_ _IRQL_requires_(PASSIVE_LEVEL) typedef NTSTATUS DRIVER_INITIALIZE ( _In_ struct _DRIVER_OBJECT *DriverObject, _In_ PUNICODE_STRING RegistryPath ); typedef DRIVER_INITIALIZE *PDRIVER_INITIALIZE; // // Define driver cancel routine type. // _Function_class_(DRIVER_CANCEL) _Requires_lock_held_(_Global_cancel_spin_lock_) _Releases_lock_(_Global_cancel_spin_lock_) _IRQL_requires_min_(DISPATCH_LEVEL) _IRQL_requires_(DISPATCH_LEVEL) typedef VOID DRIVER_CANCEL ( _Inout_ struct _DEVICE_OBJECT *DeviceObject, _Inout_ _IRQL_uses_cancel_ struct _IRP *Irp ); typedef DRIVER_CANCEL *PDRIVER_CANCEL; // // Define driver dispatch routine type. // The default is that it can be called <= DISPATCH // because it might be called from another driver. // See also below. // _Function_class_(DRIVER_DISPATCH) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_same_ typedef NTSTATUS DRIVER_DISPATCH ( _In_ struct _DEVICE_OBJECT *DeviceObject, _Inout_ struct _IRP *Irp ); typedef DRIVER_DISPATCH *PDRIVER_DISPATCH; // Convenience typedef to indicate that the IRQL level // of the function has been considered, and that it might // be called at DISPATCH_LEVEL. typedef DRIVER_DISPATCH DRIVER_DISPATCH_RAISED; // Use this variant when there is no possibility of the // dispatch function being called at raised IRQL, as in // a top-level only driver. This is preferred when it is // safe because it enables more paged code. // (There may be reasons not to page a dispatch routine // that meets that criterion, but it can still use this // definition.) // _Function_class_(DRIVER_DISPATCH) _IRQL_requires_max_(PASSIVE_LEVEL) _IRQL_requires_same_ typedef NTSTATUS DRIVER_DISPATCH_PAGED ( _In_ struct _DEVICE_OBJECT *DeviceObject, _Inout_ struct _IRP *Irp ); typedef DRIVER_DISPATCH_PAGED *PDRIVER_DISPATCH_PAGED; // // Define driver start I/O routine type. // _Function_class_(DRIVER_STARTIO) _IRQL_always_function_min_(DISPATCH_LEVEL) _IRQL_requires_(DISPATCH_LEVEL) _IRQL_requires_same_ typedef VOID DRIVER_STARTIO ( _Inout_ struct _DEVICE_OBJECT *DeviceObject, _Inout_ struct _IRP *Irp ); typedef DRIVER_STARTIO *PDRIVER_STARTIO; // // Define driver unload routine type. // _Function_class_(DRIVER_UNLOAD) _IRQL_requires_(PASSIVE_LEVEL) _IRQL_requires_same_ typedef VOID DRIVER_UNLOAD ( _In_ struct _DRIVER_OBJECT *DriverObject ); typedef DRIVER_UNLOAD *PDRIVER_UNLOAD; // // Define driver AddDevice routine type. // _Function_class_(DRIVER_ADD_DEVICE) _IRQL_requires_(PASSIVE_LEVEL) _IRQL_requires_same_ _When_(return>=0, _Kernel_clear_do_init_(__yes)) typedef NTSTATUS DRIVER_ADD_DEVICE ( _In_ struct _DRIVER_OBJECT *DriverObject, _In_ struct _DEVICE_OBJECT *PhysicalDeviceObject ); typedef DRIVER_ADD_DEVICE *PDRIVER_ADD_DEVICE; // // Define fast I/O procedure prototypes. // // Fast I/O read and write procedures. // _Function_class_(FAST_IO_CHECK_IF_POSSIBLE) _IRQL_requires_same_ _Success_(return != FALSE) typedef BOOLEAN FAST_IO_CHECK_IF_POSSIBLE ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _In_ BOOLEAN CheckForReadOperation, _Pre_notnull_ _When_(return != FALSE, _Post_equal_to_(_Old_(IoStatus))) _When_(return == FALSE, _Post_valid_) PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_CHECK_IF_POSSIBLE *PFAST_IO_CHECK_IF_POSSIBLE; _Function_class_(FAST_IO_READ) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_READ ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _Out_ PVOID Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_READ *PFAST_IO_READ; _Function_class_(FAST_IO_WRITE) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_WRITE ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _In_ PVOID Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_WRITE *PFAST_IO_WRITE; // // Fast I/O query basic and standard information procedures. // _Function_class_(FAST_IO_QUERY_BASIC_INFO) _IRQL_requires_same_ _Success_(return != FALSE) typedef BOOLEAN FAST_IO_QUERY_BASIC_INFO ( _In_ struct _FILE_OBJECT *FileObject, _In_ BOOLEAN Wait, _Out_ PFILE_BASIC_INFORMATION Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_QUERY_BASIC_INFO *PFAST_IO_QUERY_BASIC_INFO; _Function_class_(FAST_IO_QUERY_STANDARD_INFO) _IRQL_requires_same_ _Success_(return != FALSE) typedef BOOLEAN FAST_IO_QUERY_STANDARD_INFO ( _In_ struct _FILE_OBJECT *FileObject, _In_ BOOLEAN Wait, _Out_ PFILE_STANDARD_INFORMATION Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_QUERY_STANDARD_INFO *PFAST_IO_QUERY_STANDARD_INFO; // // Fast I/O lock and unlock procedures. // _Function_class_(FAST_IO_LOCK) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_LOCK ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PLARGE_INTEGER Length, _In_ PEPROCESS ProcessId, _In_ ULONG Key, _In_ BOOLEAN FailImmediately, _In_ BOOLEAN ExclusiveLock, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_LOCK *PFAST_IO_LOCK; _Function_class_(FAST_IO_UNLOCK_SINGLE) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_UNLOCK_SINGLE ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PLARGE_INTEGER Length, _In_ PEPROCESS ProcessId, _In_ ULONG Key, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_UNLOCK_SINGLE *PFAST_IO_UNLOCK_SINGLE; _Function_class_(FAST_IO_UNLOCK_ALL) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_UNLOCK_ALL ( _In_ struct _FILE_OBJECT *FileObject, _In_ PEPROCESS ProcessId, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_UNLOCK_ALL *PFAST_IO_UNLOCK_ALL; _Function_class_(FAST_IO_UNLOCK_ALL_BY_KEY) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_UNLOCK_ALL_BY_KEY ( _In_ struct _FILE_OBJECT *FileObject, _In_ PVOID ProcessId, _In_ ULONG Key, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_UNLOCK_ALL_BY_KEY *PFAST_IO_UNLOCK_ALL_BY_KEY; // // Fast I/O device control procedure. // _Function_class_(FAST_IO_DEVICE_CONTROL) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_DEVICE_CONTROL ( _In_ struct _FILE_OBJECT *FileObject, _In_ BOOLEAN Wait, _In_opt_ PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_opt_ PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ ULONG IoControlCode, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_DEVICE_CONTROL *PFAST_IO_DEVICE_CONTROL; // // Define callbacks for NtCreateSection to synchronize correctly with // the file system. It pre-acquires the resources that will be needed // when calling to query and set file/allocation size in the file system. // _Function_class_(FAST_IO_ACQUIRE_FILE) _IRQL_requires_same_ typedef VOID FAST_IO_ACQUIRE_FILE ( _In_ struct _FILE_OBJECT *FileObject ); typedef FAST_IO_ACQUIRE_FILE *PFAST_IO_ACQUIRE_FILE; _Function_class_(FAST_IO_RELEASE_FILE) _IRQL_requires_same_ typedef VOID FAST_IO_RELEASE_FILE ( _In_ struct _FILE_OBJECT *FileObject ); typedef FAST_IO_RELEASE_FILE *PFAST_IO_RELEASE_FILE; // // Define callback for drivers that have device objects attached to lower- // level drivers' device objects. This callback is made when the lower-level // driver is deleting its device object. // _Function_class_(FAST_IO_DETACH_DEVICE) _IRQL_requires_same_ typedef VOID FAST_IO_DETACH_DEVICE ( _In_ struct _DEVICE_OBJECT *SourceDevice, _In_ struct _DEVICE_OBJECT *TargetDevice ); typedef FAST_IO_DETACH_DEVICE *PFAST_IO_DETACH_DEVICE; // // This structure is used by the server to quickly get the information needed // to service a server open call. It is takes what would be two fast io calls // one for basic information and the other for standard information and makes // it into one call. // _Function_class_(FAST_IO_QUERY_NETWORK_OPEN_INFO) _IRQL_requires_same_ _Success_(return != FALSE) typedef BOOLEAN FAST_IO_QUERY_NETWORK_OPEN_INFO ( _In_ struct _FILE_OBJECT *FileObject, _In_ BOOLEAN Wait, _Out_ struct _FILE_NETWORK_OPEN_INFORMATION *Buffer, _Out_ struct _IO_STATUS_BLOCK *IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_QUERY_NETWORK_OPEN_INFO *PFAST_IO_QUERY_NETWORK_OPEN_INFO; // // Define Mdl-based routines for the server to call // _Function_class_(FAST_IO_MDL_READ) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_MDL_READ ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_MDL_READ *PFAST_IO_MDL_READ; _Function_class_(FAST_IO_MDL_READ_COMPLETE) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_MDL_READ_COMPLETE ( _In_ struct _FILE_OBJECT *FileObject, _In_ PMDL MdlChain, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_MDL_READ_COMPLETE *PFAST_IO_MDL_READ_COMPLETE; _Function_class_(FAST_IO_PREPARE_MDL_WRITE) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_PREPARE_MDL_WRITE ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_PREPARE_MDL_WRITE *PFAST_IO_PREPARE_MDL_WRITE; _Function_class_(FAST_IO_MDL_WRITE_COMPLETE) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_MDL_WRITE_COMPLETE ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PMDL MdlChain, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_MDL_WRITE_COMPLETE *PFAST_IO_MDL_WRITE_COMPLETE; // // If this routine is present, it will be called by FsRtl // to acquire the file for the mapped page writer. // _Function_class_(FAST_IO_ACQUIRE_FOR_MOD_WRITE) _IRQL_requires_same_ typedef NTSTATUS FAST_IO_ACQUIRE_FOR_MOD_WRITE ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER EndingOffset, _Out_ struct _ERESOURCE **ResourceToRelease, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_ACQUIRE_FOR_MOD_WRITE *PFAST_IO_ACQUIRE_FOR_MOD_WRITE; _Function_class_(FAST_IO_RELEASE_FOR_MOD_WRITE) _IRQL_requires_same_ typedef NTSTATUS FAST_IO_RELEASE_FOR_MOD_WRITE ( _In_ struct _FILE_OBJECT *FileObject, _In_ struct _ERESOURCE *ResourceToRelease, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_RELEASE_FOR_MOD_WRITE *PFAST_IO_RELEASE_FOR_MOD_WRITE; // // If this routine is present, it will be called by FsRtl // to acquire the file for the mapped page writer. // _Function_class_(FAST_IO_ACQUIRE_FOR_CCFLUSH) _IRQL_requires_same_ typedef NTSTATUS FAST_IO_ACQUIRE_FOR_CCFLUSH ( _In_ struct _FILE_OBJECT *FileObject, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_ACQUIRE_FOR_CCFLUSH *PFAST_IO_ACQUIRE_FOR_CCFLUSH; _Function_class_(FAST_IO_RELEASE_FOR_CCFLUSH) _IRQL_requires_same_ typedef NTSTATUS FAST_IO_RELEASE_FOR_CCFLUSH ( _In_ struct _FILE_OBJECT *FileObject, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_RELEASE_FOR_CCFLUSH *PFAST_IO_RELEASE_FOR_CCFLUSH; _Function_class_(FAST_IO_READ_COMPRESSED) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_READ_COMPRESSED ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _Out_ PVOID Buffer, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _Out_ struct _COMPRESSED_DATA_INFO *CompressedDataInfo, _In_ ULONG CompressedDataInfoLength, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_READ_COMPRESSED *PFAST_IO_READ_COMPRESSED; _Function_class_(FAST_IO_WRITE_COMPRESSED) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_WRITE_COMPRESSED ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ ULONG LockKey, _In_ PVOID Buffer, _Out_ PMDL *MdlChain, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ struct _COMPRESSED_DATA_INFO *CompressedDataInfo, _In_ ULONG CompressedDataInfoLength, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_WRITE_COMPRESSED *PFAST_IO_WRITE_COMPRESSED; _Function_class_(FAST_IO_MDL_READ_COMPLETE_COMPRESSED) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_MDL_READ_COMPLETE_COMPRESSED ( _In_ struct _FILE_OBJECT *FileObject, _In_ PMDL MdlChain, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_MDL_READ_COMPLETE_COMPRESSED *PFAST_IO_MDL_READ_COMPLETE_COMPRESSED; _Function_class_(FAST_IO_MDL_WRITE_COMPLETE_COMPRESSED) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_MDL_WRITE_COMPLETE_COMPRESSED ( _In_ struct _FILE_OBJECT *FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PMDL MdlChain, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_MDL_WRITE_COMPLETE_COMPRESSED *PFAST_IO_MDL_WRITE_COMPLETE_COMPRESSED; _Function_class_(FAST_IO_QUERY_OPEN) _IRQL_requires_same_ typedef BOOLEAN FAST_IO_QUERY_OPEN ( _Inout_ struct _IRP *Irp, _Out_ PFILE_NETWORK_OPEN_INFORMATION NetworkInformation, _In_ struct _DEVICE_OBJECT *DeviceObject ); typedef FAST_IO_QUERY_OPEN *PFAST_IO_QUERY_OPEN; // // Define the structure to describe the Fast I/O dispatch routines. Any // additions made to this structure MUST be added monotonically to the end // of the structure, and fields CANNOT be removed from the middle. // typedef struct _FAST_IO_DISPATCH { ULONG SizeOfFastIoDispatch; PFAST_IO_CHECK_IF_POSSIBLE FastIoCheckIfPossible; PFAST_IO_READ FastIoRead; PFAST_IO_WRITE FastIoWrite; PFAST_IO_QUERY_BASIC_INFO FastIoQueryBasicInfo; PFAST_IO_QUERY_STANDARD_INFO FastIoQueryStandardInfo; PFAST_IO_LOCK FastIoLock; PFAST_IO_UNLOCK_SINGLE FastIoUnlockSingle; PFAST_IO_UNLOCK_ALL FastIoUnlockAll; PFAST_IO_UNLOCK_ALL_BY_KEY FastIoUnlockAllByKey; PFAST_IO_DEVICE_CONTROL FastIoDeviceControl; PFAST_IO_ACQUIRE_FILE AcquireFileForNtCreateSection; PFAST_IO_RELEASE_FILE ReleaseFileForNtCreateSection; PFAST_IO_DETACH_DEVICE FastIoDetachDevice; PFAST_IO_QUERY_NETWORK_OPEN_INFO FastIoQueryNetworkOpenInfo; PFAST_IO_ACQUIRE_FOR_MOD_WRITE AcquireForModWrite; PFAST_IO_MDL_READ MdlRead; PFAST_IO_MDL_READ_COMPLETE MdlReadComplete; PFAST_IO_PREPARE_MDL_WRITE PrepareMdlWrite; PFAST_IO_MDL_WRITE_COMPLETE MdlWriteComplete; PFAST_IO_READ_COMPRESSED FastIoReadCompressed; PFAST_IO_WRITE_COMPRESSED FastIoWriteCompressed; PFAST_IO_MDL_READ_COMPLETE_COMPRESSED MdlReadCompleteCompressed; PFAST_IO_MDL_WRITE_COMPLETE_COMPRESSED MdlWriteCompleteCompressed; PFAST_IO_QUERY_OPEN FastIoQueryOpen; PFAST_IO_RELEASE_FOR_MOD_WRITE ReleaseForModWrite; PFAST_IO_ACQUIRE_FOR_CCFLUSH AcquireForCcFlush; PFAST_IO_RELEASE_FOR_CCFLUSH ReleaseForCcFlush; } FAST_IO_DISPATCH, *PFAST_IO_DISPATCH; // // Define the actions that a driver execution routine may request of the // adapter/controller allocation routines upon return. // typedef enum _IO_ALLOCATION_ACTION { KeepObject = 1, DeallocateObject, DeallocateObjectKeepRegisters } IO_ALLOCATION_ACTION, *PIO_ALLOCATION_ACTION; // // Define device driver adapter/controller execution routine. // typedef _Function_class_(DRIVER_CONTROL) _IRQL_requires_same_ IO_ALLOCATION_ACTION DRIVER_CONTROL ( _In_ struct _DEVICE_OBJECT *DeviceObject, _Inout_ struct _IRP *Irp, _In_ PVOID MapRegisterBase, _In_ PVOID Context ); typedef DRIVER_CONTROL *PDRIVER_CONTROL; // // Define the I/O system's security context type for use by file system's // when checking access to volumes, files, and directories. // typedef struct _IO_SECURITY_CONTEXT { PSECURITY_QUALITY_OF_SERVICE SecurityQos; PACCESS_STATE AccessState; ACCESS_MASK DesiredAccess; ULONG FullCreateOptions; } IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT; // // Define Volume Parameter Block (VPB) flags. // #define VPB_MOUNTED 0x00000001 #define VPB_LOCKED 0x00000002 #define VPB_PERSISTENT 0x00000004 #define VPB_REMOVE_PENDING 0x00000008 #define VPB_RAW_MOUNT 0x00000010 #define VPB_DIRECT_WRITES_ALLOWED 0x00000020 // // Volume Parameter Block (VPB) // #define MAXIMUM_VOLUME_LABEL_LENGTH (32 * sizeof(WCHAR)) // 32 characters typedef struct _VPB { CSHORT Type; CSHORT Size; USHORT Flags; USHORT VolumeLabelLength; // in bytes struct _DEVICE_OBJECT *DeviceObject; struct _DEVICE_OBJECT *RealDevice; ULONG SerialNumber; ULONG ReferenceCount; WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH / sizeof(WCHAR)]; } VPB, *PVPB; #if defined(_WIN64) || defined(_ARM_) // // Use __inline DMA macros (hal.h) // #ifndef USE_DMA_MACROS #define USE_DMA_MACROS #endif // // Only PnP drivers! // #ifndef NO_LEGACY_DRIVERS #define NO_LEGACY_DRIVERS #endif #endif // _WIN64 #if defined(USE_DMA_MACROS) && !defined(_NTHAL_) && ( defined(_NTDDK_) || defined(_NTDRIVER_) || defined(_NTOSP_)) // // Define object type specific fields of various objects used by the I/O system // typedef struct _DMA_ADAPTER *PADAPTER_OBJECT; #elif defined(_WDM_INCLUDED_) typedef struct _DMA_ADAPTER *PADAPTER_OBJECT; #else // // Define object type specific fields of various objects used by the I/O system // typedef struct _ADAPTER_OBJECT *PADAPTER_OBJECT; #endif // USE_DMA_MACROS && (_NTDDK_ || _NTDRIVER_ || _NTOSP_) // // Define Wait Context Block (WCB) // typedef struct _WAIT_CONTEXT_BLOCK { union { KDEVICE_QUEUE_ENTRY WaitQueueEntry; struct { LIST_ENTRY DmaWaitEntry; ULONG NumberOfChannels; ULONG SyncCallback : 1; ULONG DmaContext : 1; ULONG ZeroMapRegisters : 1; ULONG Reserved : 29; }; }; PDRIVER_CONTROL DeviceRoutine; PVOID DeviceContext; ULONG NumberOfMapRegisters; PVOID DeviceObject; PVOID CurrentIrp; PKDPC BufferChainingDpc; } WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK; // // Define Device Object (DO) flags // // DO_DAX_VOLUME - If set, this is a DAX volume i.e. the volume supports mapping a file directly // on the persistent memory device. The cached and memory mapped IO to user files wouldn't // generate paging IO. // #define DO_VERIFY_VOLUME 0x00000002 #define DO_BUFFERED_IO 0x00000004 #define DO_EXCLUSIVE 0x00000008 #define DO_DIRECT_IO 0x00000010 #define DO_MAP_IO_BUFFER 0x00000020 #define DO_DEVICE_INITIALIZING 0x00000080 #define DO_SHUTDOWN_REGISTERED 0x00000800 #define DO_BUS_ENUMERATED_DEVICE 0x00001000 #define DO_POWER_PAGABLE 0x00002000 #define DO_POWER_INRUSH 0x00004000 #define DO_DEVICE_TO_BE_RESET 0x04000000 #define DO_DAX_VOLUME 0x10000000 // // Device Object structure definition // #if _MSC_VER >= 1200 #pragma warning(push) #pragma warning(disable:4324) // structure was padded due to __declspec(align()) #endif typedef struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _DEVICE_OBJECT { CSHORT Type; USHORT Size; LONG ReferenceCount; struct _DRIVER_OBJECT *DriverObject; struct _DEVICE_OBJECT *NextDevice; struct _DEVICE_OBJECT *AttachedDevice; struct _IRP *CurrentIrp; PIO_TIMER Timer; ULONG Flags; // See above: DO_... ULONG Characteristics; // See ntioapi: FILE_... __volatile PVPB Vpb; PVOID DeviceExtension; DEVICE_TYPE DeviceType; CCHAR StackSize; union { LIST_ENTRY ListEntry; WAIT_CONTEXT_BLOCK Wcb; } Queue; ULONG AlignmentRequirement; KDEVICE_QUEUE DeviceQueue; KDPC Dpc; // // The following field is for exclusive use by the filesystem to keep // track of the number of Fsp threads currently using the device // ULONG ActiveThreadCount; PSECURITY_DESCRIPTOR SecurityDescriptor; KEVENT DeviceLock; USHORT SectorSize; USHORT Spare1; struct _DEVOBJ_EXTENSION *DeviceObjectExtension; PVOID Reserved; } DEVICE_OBJECT; typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT; #if _MSC_VER >= 1200 #pragma warning(pop) #endif struct _DEVICE_OBJECT_POWER_EXTENSION; typedef struct _DEVOBJ_EXTENSION { CSHORT Type; USHORT Size; PDEVICE_OBJECT DeviceObject; // owning device object // // The remaining fields are reserved for system use. // ULONG PowerFlags; struct _DEVICE_OBJECT_POWER_EXTENSION *Dope; ULONG ExtensionFlags; PVOID DeviceNode; PDEVICE_OBJECT AttachedTo; __volatile LONG StartIoCount; LONG StartIoKey; ULONG StartIoFlags; PVPB Vpb; PVOID DependencyNode; PVOID InterruptContext; __volatile PVOID VerifierContext; } DEVOBJ_EXTENSION, *PDEVOBJ_EXTENSION; // // Define Driver Object (DRVO) flags // #define DRVO_UNLOAD_INVOKED 0x00000001 #define DRVO_LEGACY_DRIVER 0x00000002 #define DRVO_BUILTIN_DRIVER 0x00000004 // Driver objects for Hal, PnP Mgr typedef struct _DRIVER_EXTENSION { // // Back pointer to Driver Object // struct _DRIVER_OBJECT *DriverObject; // // The AddDevice entry point is called by the Plug & Play manager // to inform the driver when a new device instance arrives that this // driver must control. // PDRIVER_ADD_DEVICE AddDevice; // // The count field is used to count the number of times the driver has // had its registered reinitialization routine invoked. // ULONG Count; // // The service name field is used by the pnp manager to determine // where the driver related info is stored in the registry. // UNICODE_STRING ServiceKeyName; // // Note: any new shared fields get added here. // } DRIVER_EXTENSION, *PDRIVER_EXTENSION; typedef struct _DRIVER_OBJECT { CSHORT Type; CSHORT Size; // // The following links all of the devices created by a single driver // together on a list, and the Flags word provides an extensible flag // location for driver objects. // PDEVICE_OBJECT DeviceObject; ULONG Flags; // // The following section describes where the driver is loaded. The count // field is used to count the number of times the driver has had its // registered reinitialization routine invoked. // PVOID DriverStart; ULONG DriverSize; PVOID DriverSection; PDRIVER_EXTENSION DriverExtension; // // The driver name field is used by the error log thread // determine the name of the driver that an I/O request is/was bound. // UNICODE_STRING DriverName; // // The following section is for registry support. Thise is a pointer // to the path to the hardware information in the registry // PUNICODE_STRING HardwareDatabase; // // The following section contains the optional pointer to an array of // alternate entry points to a driver for "fast I/O" support. Fast I/O // is performed by invoking the driver routine directly with separate // parameters, rather than using the standard IRP call mechanism. Note // that these functions may only be used for synchronous I/O, and when // the file is cached. // PFAST_IO_DISPATCH FastIoDispatch; // // The following section describes the entry points to this particular // driver. Note that the major function dispatch table must be the last // field in the object so that it remains extensible. // PDRIVER_INITIALIZE DriverInit; PDRIVER_STARTIO DriverStartIo; PDRIVER_UNLOAD DriverUnload; PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1]; } DRIVER_OBJECT; typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT; // // The following structure is pointed to by the SectionObject pointer field // of a file object, and is allocated by the various NT file systems. // typedef struct _SECTION_OBJECT_POINTERS { PVOID DataSectionObject; PVOID SharedCacheMap; PVOID ImageSectionObject; } SECTION_OBJECT_POINTERS; typedef SECTION_OBJECT_POINTERS *PSECTION_OBJECT_POINTERS; // // Define the format of a completion message. // typedef struct _IO_COMPLETION_CONTEXT { PVOID Port; PVOID Key; } IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT; // // Define File Object (FO) flags // #define FO_FILE_OPEN 0x00000001 #define FO_SYNCHRONOUS_IO 0x00000002 #define FO_ALERTABLE_IO 0x00000004 #define FO_NO_INTERMEDIATE_BUFFERING 0x00000008 #define FO_WRITE_THROUGH 0x00000010 #define FO_SEQUENTIAL_ONLY 0x00000020 #define FO_CACHE_SUPPORTED 0x00000040 #define FO_NAMED_PIPE 0x00000080 #define FO_STREAM_FILE 0x00000100 #define FO_MAILSLOT 0x00000200 #define FO_GENERATE_AUDIT_ON_CLOSE 0x00000400 #define FO_QUEUE_IRP_TO_THREAD FO_GENERATE_AUDIT_ON_CLOSE #define FO_DIRECT_DEVICE_OPEN 0x00000800 #define FO_FILE_MODIFIED 0x00001000 #define FO_FILE_SIZE_CHANGED 0x00002000 #define FO_CLEANUP_COMPLETE 0x00004000 #define FO_TEMPORARY_FILE 0x00008000 #define FO_DELETE_ON_CLOSE 0x00010000 #define FO_OPENED_CASE_SENSITIVE 0x00020000 #define FO_HANDLE_CREATED 0x00040000 #define FO_FILE_FAST_IO_READ 0x00080000 #define FO_RANDOM_ACCESS 0x00100000 #define FO_FILE_OPEN_CANCELLED 0x00200000 #define FO_VOLUME_OPEN 0x00400000 #define FO_REMOTE_ORIGIN 0x01000000 #define FO_DISALLOW_EXCLUSIVE 0x02000000 #define FO_SKIP_COMPLETION_PORT FO_DISALLOW_EXCLUSIVE #define FO_SKIP_SET_EVENT 0x04000000 #define FO_SKIP_SET_FAST_IO 0x08000000 #define FO_INDIRECT_WAIT_OBJECT 0x10000000 #define FO_SECTION_MINSTORE_TREATMENT 0x20000000 // // This mask allows us to re-use flags that are not present during a create // operation for uses that are only valid for the duration of the create. // #define FO_FLAGS_VALID_ONLY_DURING_CREATE FO_DISALLOW_EXCLUSIVE typedef struct _FILE_OBJECT { CSHORT Type; CSHORT Size; PDEVICE_OBJECT DeviceObject; PVPB Vpb; PVOID FsContext; PVOID FsContext2; PSECTION_OBJECT_POINTERS SectionObjectPointer; PVOID PrivateCacheMap; NTSTATUS FinalStatus; struct _FILE_OBJECT *RelatedFileObject; BOOLEAN LockOperation; BOOLEAN DeletePending; BOOLEAN ReadAccess; BOOLEAN WriteAccess; BOOLEAN DeleteAccess; BOOLEAN SharedRead; BOOLEAN SharedWrite; BOOLEAN SharedDelete; ULONG Flags; UNICODE_STRING FileName; LARGE_INTEGER CurrentByteOffset; __volatile ULONG Waiters; __volatile ULONG Busy; PVOID LastLock; KEVENT Lock; KEVENT Event; __volatile PIO_COMPLETION_CONTEXT CompletionContext; KSPIN_LOCK IrpListLock; LIST_ENTRY IrpList; __volatile PVOID FileObjectExtension; } FILE_OBJECT; typedef struct _FILE_OBJECT *PFILE_OBJECT; // // Define I/O Request Packet (IRP) flags // #define IRP_NOCACHE 0x00000001 #define IRP_PAGING_IO 0x00000002 #define IRP_MOUNT_COMPLETION 0x00000002 #define IRP_SYNCHRONOUS_API 0x00000004 #define IRP_ASSOCIATED_IRP 0x00000008 #define IRP_BUFFERED_IO 0x00000010 #define IRP_DEALLOCATE_BUFFER 0x00000020 #define IRP_INPUT_OPERATION 0x00000040 #define IRP_SYNCHRONOUS_PAGING_IO 0x00000040 #define IRP_CREATE_OPERATION 0x00000080 #define IRP_READ_OPERATION 0x00000100 #define IRP_WRITE_OPERATION 0x00000200 #define IRP_CLOSE_OPERATION 0x00000400 #define IRP_DEFER_IO_COMPLETION 0x00000800 #define IRP_OB_QUERY_NAME 0x00001000 #define IRP_HOLD_DEVICE_QUEUE 0x00002000 #define IRP_UM_DRIVER_INITIATED_IO 0x00400000 // // Define I/O request packet (IRP) alternate flags for allocation control. // #define IRP_QUOTA_CHARGED 0x01 #define IRP_ALLOCATED_MUST_SUCCEED 0x02 #define IRP_ALLOCATED_FIXED_SIZE 0x04 #define IRP_LOOKASIDE_ALLOCATION 0x08 // // I/O Request Packet (IRP) definition // typedef struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _IRP { CSHORT Type; USHORT Size; // // Define the common fields used to control the IRP. // // // Define a pointer to the Memory Descriptor List (MDL) for this I/O // request. This field is only used if the I/O is "direct I/O". // PMDL MdlAddress; // // Flags word - used to remember various flags. // ULONG Flags; // // The following union is used for one of three purposes: // // 1. This IRP is an associated IRP. The field is a pointer to a master // IRP. // // 2. This is the master IRP. The field is the count of the number of // IRPs which must complete (associated IRPs) before the master can // complete. // // 3. This operation is being buffered and the field is the address of // the system space buffer. // union { struct _IRP *MasterIrp; __volatile LONG IrpCount; PVOID SystemBuffer; } AssociatedIrp; // // Thread list entry - allows queueing the IRP to the thread pending I/O // request packet list. // LIST_ENTRY ThreadListEntry; // // I/O status - final status of operation. // IO_STATUS_BLOCK IoStatus; // // Requestor mode - mode of the original requestor of this operation. // KPROCESSOR_MODE RequestorMode; // // Pending returned - TRUE if pending was initially returned as the // status for this packet. // BOOLEAN PendingReturned; // // Stack state information. // CHAR StackCount; CHAR CurrentLocation; // // Cancel - packet has been canceled. // BOOLEAN Cancel; // // Cancel Irql - Irql at which the cancel spinlock was acquired. // KIRQL CancelIrql; // // ApcEnvironment - Used to save the APC environment at the time that the // packet was initialized. // CCHAR ApcEnvironment; // // Allocation control flags. // UCHAR AllocationFlags; // // User parameters. // PIO_STATUS_BLOCK UserIosb; PKEVENT UserEvent; union { struct { union { PIO_APC_ROUTINE UserApcRoutine; PVOID IssuingProcess; }; PVOID UserApcContext; } AsynchronousParameters; LARGE_INTEGER AllocationSize; } Overlay; // // CancelRoutine - Used to contain the address of a cancel routine supplied // by a device driver when the IRP is in a cancelable state. // __volatile PDRIVER_CANCEL CancelRoutine; // // Note that the UserBuffer parameter is outside of the stack so that I/O // completion can copy data back into the user's address space without // having to know exactly which service was being invoked. The length // of the copy is stored in the second half of the I/O status block. If // the UserBuffer field is NULL, then no copy is performed. // PVOID UserBuffer; // // Kernel structures // // The following section contains kernel structures which the IRP needs // in order to place various work information in kernel controller system // queues. Because the size and alignment cannot be controlled, they are // placed here at the end so they just hang off and do not affect the // alignment of other fields in the IRP. // union { struct { union { // // DeviceQueueEntry - The device queue entry field is used to // queue the IRP to the device driver device queue. // KDEVICE_QUEUE_ENTRY DeviceQueueEntry; struct { // // The following are available to the driver to use in // whatever manner is desired, while the driver owns the // packet. // PVOID DriverContext[4]; } ; } ; // // Thread - pointer to caller's Thread Control Block. // PETHREAD Thread; // // Auxiliary buffer - pointer to any auxiliary buffer that is // required to pass information to a driver that is not contained // in a normal buffer. // PCHAR AuxiliaryBuffer; // // The following unnamed structure must be exactly identical // to the unnamed structure used in the minipacket header used // for completion queue entries. // struct { // // List entry - used to queue the packet to completion queue, among // others. // LIST_ENTRY ListEntry; union { // // Current stack location - contains a pointer to the current // IO_STACK_LOCATION structure in the IRP stack. This field // should never be directly accessed by drivers. They should // use the standard functions. // struct _IO_STACK_LOCATION *CurrentStackLocation; // // Minipacket type. // ULONG PacketType; }; }; // // Original file object - pointer to the original file object // that was used to open the file. This field is owned by the // I/O system and should not be used by any other drivers. // PFILE_OBJECT OriginalFileObject; } Overlay; // // APC - This APC control block is used for the special kernel APC as // well as for the caller's APC, if one was specified in the original // argument list. If so, then the APC is reused for the normal APC for // whatever mode the caller was in and the "special" routine that is // invoked before the APC gets control simply deallocates the IRP. // KAPC Apc; // // CompletionKey - This is the key that is used to distinguish // individual I/O operations initiated on a single file handle. // PVOID CompletionKey; } Tail; } IRP; typedef IRP *PIRP; // // Define completion routine types for use in stack locations in an IRP // _Function_class_(IO_COMPLETION_ROUTINE) _IRQL_requires_same_ _IRQL_requires_max_(DISPATCH_LEVEL) typedef NTSTATUS IO_COMPLETION_ROUTINE ( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context ); typedef IO_COMPLETION_ROUTINE *PIO_COMPLETION_ROUTINE; // // Define stack location control flags // #define SL_PENDING_RETURNED 0x01 #define SL_ERROR_RETURNED 0x02 #define SL_INVOKE_ON_CANCEL 0x20 #define SL_INVOKE_ON_SUCCESS 0x40 #define SL_INVOKE_ON_ERROR 0x80 // // Define flags for various functions // // // Create / Create Named Pipe (IRP_MJ_CREATE/IRP_MJ_CREATE_NAMED_PIPE) // // The following flags must exactly match those in the IoCreateFile call's // options. The case sensitive flag is added in later, by the parse routine, // and is not an actual option to open. Rather, it is part of the object // manager's attributes structure. // #define SL_FORCE_ACCESS_CHECK 0x01 #define SL_OPEN_PAGING_FILE 0x02 #define SL_OPEN_TARGET_DIRECTORY 0x04 #define SL_STOP_ON_SYMLINK 0x08 #define SL_CASE_SENSITIVE 0x80 // // Read / Write (IRP_MJ_READ/IRP_MJ_WRITE) // #define SL_KEY_SPECIFIED 0x01 #define SL_OVERRIDE_VERIFY_VOLUME 0x02 #define SL_WRITE_THROUGH 0x04 #define SL_FT_SEQUENTIAL_WRITE 0x08 #define SL_FORCE_DIRECT_WRITE 0x10 #define SL_REALTIME_STREAM 0x20 // valid only with optical media #define SL_PERSISTENT_MEMORY_FIXED_MAPPING 0x20 // valid only with persistent memory device and IRP_MJ_WRITE // // SL_KEY_SPECIFIED - when set this flag indicates that the IO_STACK_LOCATION.Parameters.Read(OrWrite).Key // contains which copy of a given sector should be read when redundancy is enabled. Today this flag is // only used with IRP_MJ_READ operations but could be expanded to IRP_MJ_WRITE in the future. // // // SL_REALTIME_STREAM - flag hints that the IO is for real-time streaming requests to CD-ROM class driver. // This hints the driver to perform READ / WRITE operations at a guaranteed speed for real-time streaming. // // // SL_PERSISTENT_MEMORY_FIXED_MAPPING - The persistent memory mapping of the bytes in the write request // cannot change while handling this write request. // // One of the reasons for remapping (modifying the physical address of a given LBA) on persistent memory // devices is to provide efficient sector level atomicity. // // If the flag is not set, remapping is allowed especially if it results in the driver providing sector // atomicity. File systems (or the requester) prefer that a persistent memory device driver provides // sector atomicity. // // If the flag is set, a persistent memory driver shall not remap the physical addresses corresponding // to the LBAs. If that means sector atomicity can't be provided, so be it. However, the driver is more // than welcome to provide sector atomicity as long as there is no remapping. // // // IRP_MJ_FLUSH_BUFFERS // #define SL_FORCE_ASYNCHRONOUS 0x01 // // SL_FORCE_ASYNCHRONOUS - a flush IRP specific flag in IrpStack to specify that the flush operation needs // to be async. This behavior is needed by Spaces as Spaces issues flushes to disks in a pool serially and // does not want to be blocked by disks whose flush operation is slow. // // // Device I/O Control // // // Same SL_OVERRIDE_VERIFY_VOLUME as for read/write above. // #define SL_READ_ACCESS_GRANTED 0x01 #define SL_WRITE_ACCESS_GRANTED 0x04 // Gap for SL_OVERRIDE_VERIFY_VOLUME // // Lock (IRP_MJ_LOCK_CONTROL) // #define SL_FAIL_IMMEDIATELY 0x01 #define SL_EXCLUSIVE_LOCK 0x02 // // QueryDirectory / QueryEa / QueryQuota (IRP_MJ_DIRECTORY_CONTROL/IRP_MJ_QUERY_EA/IRP_MJ_QUERY_QUOTA)) // #define SL_RESTART_SCAN 0x01 #define SL_RETURN_SINGLE_ENTRY 0x02 #define SL_INDEX_SPECIFIED 0x04 // // NotifyDirectory (IRP_MJ_DIRECTORY_CONTROL) // #define SL_WATCH_TREE 0x01 // // FileSystemControl (IRP_MJ_FILE_SYSTEM_CONTROL) // // minor: mount/verify volume // #define SL_ALLOW_RAW_MOUNT 0x01 // // SetInformationFile (IRP_MJ_SET_INFORMATION) // // Rename/Link Information // #define SL_BYPASS_ACCESS_CHECK 0x01 // // Define PNP/POWER types required by IRP_MJ_PNP/IRP_MJ_POWER. // typedef enum _DEVICE_RELATION_TYPE { BusRelations, EjectionRelations, PowerRelations, RemovalRelations, TargetDeviceRelation, SingleBusRelations, TransportRelations } DEVICE_RELATION_TYPE, *PDEVICE_RELATION_TYPE; typedef struct _DEVICE_RELATIONS { ULONG Count; _Field_size_(Count) PDEVICE_OBJECT Objects[1]; // variable length } DEVICE_RELATIONS, *PDEVICE_RELATIONS; // // IRP_MN_DEVICE_USAGE_NOTIFICATION types // // DeviceUsageTypePostDisplay - The POST display adapter must be sent this IRP // before IRP_MN_START_DEVICE, and with Parameters.UsageNotification.InPath // set to TRUE. After that, the adapter cannot be sent an // IRP_MN_DEVICE_USAGE_NOTIFICATION with InPath set to FALSE. // typedef enum _DEVICE_USAGE_NOTIFICATION_TYPE { DeviceUsageTypeUndefined, DeviceUsageTypePaging, DeviceUsageTypeHibernation, DeviceUsageTypeDumpFile, DeviceUsageTypeBoot, DeviceUsageTypePostDisplay } DEVICE_USAGE_NOTIFICATION_TYPE; // workaround overloaded definition (rpc generated headers all define INTERFACE // to match the class name). #undef INTERFACE typedef struct _INTERFACE { USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // interface specific entries go here } INTERFACE, *PINTERFACE; typedef _Struct_size_bytes_(Size) struct _DEVICE_CAPABILITIES { _Field_range_(==, sizeof(struct _DEVICE_CAPABILITIES)) USHORT Size; USHORT Version; // the version documented here is version 1 ULONG DeviceD1:1; ULONG DeviceD2:1; ULONG LockSupported:1; ULONG EjectSupported:1; // Ejectable in S0 ULONG Removable:1; ULONG DockDevice:1; ULONG UniqueID:1; ULONG SilentInstall:1; ULONG RawDeviceOK:1; ULONG SurpriseRemovalOK:1; ULONG WakeFromD0:1; ULONG WakeFromD1:1; ULONG WakeFromD2:1; ULONG WakeFromD3:1; ULONG HardwareDisabled:1; ULONG NonDynamic:1; ULONG WarmEjectSupported:1; ULONG NoDisplayInUI:1; ULONG Reserved1:1; ULONG WakeFromInterrupt:1; ULONG Reserved:12; ULONG Address; ULONG UINumber; DEVICE_POWER_STATE DeviceState[POWER_SYSTEM_MAXIMUM]; _Field_range_(PowerSystemUnspecified, PowerSystemHibernate) SYSTEM_POWER_STATE SystemWake; _Field_range_(PowerDeviceUnspecified, PowerDeviceD3) DEVICE_POWER_STATE DeviceWake; ULONG D1Latency; ULONG D2Latency; ULONG D3Latency; } DEVICE_CAPABILITIES, *PDEVICE_CAPABILITIES; typedef struct _POWER_SEQUENCE { ULONG SequenceD1; ULONG SequenceD2; ULONG SequenceD3; } POWER_SEQUENCE, *PPOWER_SEQUENCE; typedef enum { BusQueryDeviceID = 0, // \ BusQueryHardwareIDs = 1, // Hardware ids BusQueryCompatibleIDs = 2, // compatible device ids BusQueryInstanceID = 3, // persistent id for this instance of the device BusQueryDeviceSerialNumber = 4, // serial number for this device BusQueryContainerID = 5 // unique id of the device's physical container } BUS_QUERY_ID_TYPE, *PBUS_QUERY_ID_TYPE; typedef ULONG PNP_DEVICE_STATE, *PPNP_DEVICE_STATE; #define PNP_DEVICE_DISABLED 0x00000001 #define PNP_DEVICE_DONT_DISPLAY_IN_UI 0x00000002 #define PNP_DEVICE_FAILED 0x00000004 #define PNP_DEVICE_REMOVED 0x00000008 #define PNP_DEVICE_RESOURCE_REQUIREMENTS_CHANGED 0x00000010 #define PNP_DEVICE_NOT_DISABLEABLE 0x00000020 #define PNP_DEVICE_DISCONNECTED 0x00000040 typedef enum { DeviceTextDescription = 0, // DeviceDesc property DeviceTextLocationInformation = 1 // DeviceLocation property } DEVICE_TEXT_TYPE, *PDEVICE_TEXT_TYPE; // // Define I/O Request Packet (IRP) stack locations // #if !defined(_AMD64_) && !defined(_ARM_) && !defined(_ARM64_) #include "pshpack4.h" #endif #if defined(_WIN64) #define POINTER_ALIGNMENT DECLSPEC_ALIGN(8) #else #define POINTER_ALIGNMENT #endif #if _MSC_VER >= 1200 #pragma warning(push) #pragma warning(disable:4324) // structure was padded due to __declspec(align()) #endif typedef struct _IO_STACK_LOCATION { UCHAR MajorFunction; UCHAR MinorFunction; UCHAR Flags; UCHAR Control; // // The following user parameters are based on the service that is being // invoked. Drivers and file systems can determine which set to use based // on the above major and minor function codes. // union { // // System service parameters for: NtCreateFile // struct { PIO_SECURITY_CONTEXT SecurityContext; ULONG Options; USHORT POINTER_ALIGNMENT FileAttributes; USHORT ShareAccess; ULONG POINTER_ALIGNMENT EaLength; } Create; // // System service parameters for: NtCreateNamedPipeFile // // Notice that the fields in the following parameter structure must // match those for the create structure other than the last longword. // This is so that no distinctions need be made by the I/O system's // parse routine other than for the last longword. // struct { PIO_SECURITY_CONTEXT SecurityContext; ULONG Options; USHORT POINTER_ALIGNMENT Reserved; USHORT ShareAccess; PNAMED_PIPE_CREATE_PARAMETERS Parameters; } CreatePipe; // // System service parameters for: NtCreateMailslotFile // // Notice that the fields in the following parameter structure must // match those for the create structure other than the last longword. // This is so that no distinctions need be made by the I/O system's // parse routine other than for the last longword. // struct { PIO_SECURITY_CONTEXT SecurityContext; ULONG Options; USHORT POINTER_ALIGNMENT Reserved; USHORT ShareAccess; PMAILSLOT_CREATE_PARAMETERS Parameters; } CreateMailslot; // // System service parameters for: NtReadFile // struct { ULONG Length; ULONG POINTER_ALIGNMENT Key; LARGE_INTEGER ByteOffset; } Read; // // System service parameters for: NtWriteFile // struct { ULONG Length; ULONG POINTER_ALIGNMENT Key; LARGE_INTEGER ByteOffset; } Write; // // System service parameters for: NtQueryDirectoryFile // struct { ULONG Length; PUNICODE_STRING FileName; FILE_INFORMATION_CLASS FileInformationClass; ULONG POINTER_ALIGNMENT FileIndex; } QueryDirectory; // // System service parameters for: NtNotifyChangeDirectoryFile // struct { ULONG Length; ULONG POINTER_ALIGNMENT CompletionFilter; } NotifyDirectory; // // System service parameters for: NtQueryInformationFile // struct { ULONG Length; FILE_INFORMATION_CLASS POINTER_ALIGNMENT FileInformationClass; } QueryFile; // // System service parameters for: NtSetInformationFile // struct { ULONG Length; FILE_INFORMATION_CLASS POINTER_ALIGNMENT FileInformationClass; PFILE_OBJECT FileObject; union { struct { BOOLEAN ReplaceIfExists; BOOLEAN AdvanceOnly; }; ULONG ClusterCount; HANDLE DeleteHandle; }; } SetFile; // // System service parameters for: NtQueryEaFile // struct { ULONG Length; PVOID EaList; ULONG EaListLength; ULONG POINTER_ALIGNMENT EaIndex; } QueryEa; // // System service parameters for: NtSetEaFile // struct { ULONG Length; } SetEa; // // System service parameters for: NtQueryVolumeInformationFile // struct { ULONG Length; FS_INFORMATION_CLASS POINTER_ALIGNMENT FsInformationClass; } QueryVolume; // // System service parameters for: NtSetVolumeInformationFile // struct { ULONG Length; FS_INFORMATION_CLASS POINTER_ALIGNMENT FsInformationClass; } SetVolume; // // System service parameters for: NtFsControlFile // // Note that the user's output buffer is stored in the UserBuffer field // and the user's input buffer is stored in the SystemBuffer field. // struct { ULONG OutputBufferLength; ULONG POINTER_ALIGNMENT InputBufferLength; ULONG POINTER_ALIGNMENT FsControlCode; PVOID Type3InputBuffer; } FileSystemControl; // // System service parameters for: NtLockFile/NtUnlockFile // struct { PLARGE_INTEGER Length; ULONG POINTER_ALIGNMENT Key; LARGE_INTEGER ByteOffset; } LockControl; // // System service parameters for: NtFlushBuffersFile // // No extra user-supplied parameters. // // // System service parameters for: NtCancelIoFile // // No extra user-supplied parameters. // // // System service parameters for: NtDeviceIoControlFile // // Note that the user's output buffer is stored in the UserBuffer field // and the user's input buffer is stored in the SystemBuffer field. // struct { ULONG OutputBufferLength; ULONG POINTER_ALIGNMENT InputBufferLength; ULONG POINTER_ALIGNMENT IoControlCode; PVOID Type3InputBuffer; } DeviceIoControl; // // System service parameters for: NtQuerySecurityObject // struct { SECURITY_INFORMATION SecurityInformation; ULONG POINTER_ALIGNMENT Length; } QuerySecurity; // // System service parameters for: NtSetSecurityObject // struct { SECURITY_INFORMATION SecurityInformation; PSECURITY_DESCRIPTOR SecurityDescriptor; } SetSecurity; // // Non-system service parameters. // // Parameters for MountVolume // struct { PVPB Vpb; PDEVICE_OBJECT DeviceObject; } MountVolume; // // Parameters for VerifyVolume // struct { PVPB Vpb; PDEVICE_OBJECT DeviceObject; } VerifyVolume; // // Parameters for Scsi with internal device control. // struct { struct _SCSI_REQUEST_BLOCK *Srb; } Scsi; // // System service parameters for: NtQueryQuotaInformationFile // struct { ULONG Length; PSID StartSid; PFILE_GET_QUOTA_INFORMATION SidList; ULONG SidListLength; } QueryQuota; // // System service parameters for: NtSetQuotaInformationFile // struct { ULONG Length; } SetQuota; // // Parameters for IRP_MN_QUERY_DEVICE_RELATIONS // struct { DEVICE_RELATION_TYPE Type; } QueryDeviceRelations; // // Parameters for IRP_MN_QUERY_INTERFACE // struct { CONST GUID *InterfaceType; USHORT Size; USHORT Version; PINTERFACE Interface; PVOID InterfaceSpecificData; } QueryInterface; // // Parameters for IRP_MN_QUERY_CAPABILITIES // struct { PDEVICE_CAPABILITIES Capabilities; } DeviceCapabilities; // // Parameters for IRP_MN_FILTER_RESOURCE_REQUIREMENTS // struct { PIO_RESOURCE_REQUIREMENTS_LIST IoResourceRequirementList; } FilterResourceRequirements; // // Parameters for IRP_MN_READ_CONFIG and IRP_MN_WRITE_CONFIG // struct { ULONG WhichSpace; PVOID Buffer; ULONG Offset; ULONG POINTER_ALIGNMENT Length; } ReadWriteConfig; // // Parameters for IRP_MN_SET_LOCK // struct { BOOLEAN Lock; } SetLock; // // Parameters for IRP_MN_QUERY_ID // struct { BUS_QUERY_ID_TYPE IdType; } QueryId; // // Parameters for IRP_MN_QUERY_DEVICE_TEXT // struct { DEVICE_TEXT_TYPE DeviceTextType; LCID POINTER_ALIGNMENT LocaleId; } QueryDeviceText; // // Parameters for IRP_MN_DEVICE_USAGE_NOTIFICATION // struct { BOOLEAN InPath; BOOLEAN Reserved[3]; DEVICE_USAGE_NOTIFICATION_TYPE POINTER_ALIGNMENT Type; } UsageNotification; // // Parameters for IRP_MN_WAIT_WAKE // struct { SYSTEM_POWER_STATE PowerState; } WaitWake; // // Parameter for IRP_MN_POWER_SEQUENCE // struct { PPOWER_SEQUENCE PowerSequence; } PowerSequence; // // Parameters for IRP_MN_SET_POWER and IRP_MN_QUERY_POWER // #if (NTDDI_VERSION >= NTDDI_VISTA) struct { union { ULONG SystemContext; SYSTEM_POWER_STATE_CONTEXT SystemPowerStateContext; }; POWER_STATE_TYPE POINTER_ALIGNMENT Type; POWER_STATE POINTER_ALIGNMENT State; POWER_ACTION POINTER_ALIGNMENT ShutdownType; } Power; #else struct { ULONG SystemContext; POWER_STATE_TYPE POINTER_ALIGNMENT Type; POWER_STATE POINTER_ALIGNMENT State; POWER_ACTION POINTER_ALIGNMENT ShutdownType; } Power; #endif // (NTDDI_VERSION >= NTDDI_VISTA) // // Parameters for StartDevice // struct { PCM_RESOURCE_LIST AllocatedResources; PCM_RESOURCE_LIST AllocatedResourcesTranslated; } StartDevice; // // Parameters for Cleanup // // No extra parameters supplied // // // WMI Irps // struct { ULONG_PTR ProviderId; PVOID DataPath; ULONG BufferSize; PVOID Buffer; } WMI; // // Others - driver-specific // struct { PVOID Argument1; PVOID Argument2; PVOID Argument3; PVOID Argument4; } Others; } Parameters; // // Save a pointer to this device driver's device object for this request // so it can be passed to the completion routine if needed. // PDEVICE_OBJECT DeviceObject; // // The following location contains a pointer to the file object for this // request. // PFILE_OBJECT FileObject; // // The following routine is invoked depending on the flags in the above // flags field. // PIO_COMPLETION_ROUTINE CompletionRoutine; // // The following is used to store the address of the context parameter // that should be passed to the CompletionRoutine. // PVOID Context; } IO_STACK_LOCATION, *PIO_STACK_LOCATION; #if _MSC_VER >= 1200 #pragma warning(pop) #endif #if !defined(_AMD64_) && !defined(_ARM_) && !defined(_ARM64_) #include "poppack.h" #endif // // Define the share access structure used by file systems to determine // whether or not another accessor may open the file. // typedef struct _SHARE_ACCESS { ULONG OpenCount; ULONG Readers; ULONG Writers; ULONG Deleters; ULONG SharedRead; ULONG SharedWrite; ULONG SharedDelete; } SHARE_ACCESS, *PSHARE_ACCESS; // // Public I/O routine definitions // #if (NTDDI_VERSION >= NTDDI_WIN2K) _Acquires_lock_(_Global_cancel_spin_lock_) _Requires_lock_not_held_(_Global_cancel_spin_lock_) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_raises_(DISPATCH_LEVEL) NTKERNELAPI VOID IoAcquireCancelSpinLock( _Out_ _At_(*Irql, _IRQL_saves_) PKIRQL Irql ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS IoAllocateDriverObjectExtension( _In_ PDRIVER_OBJECT DriverObject, _In_ PVOID ClientIdentificationAddress, _In_ ULONG DriverObjectExtensionSize, // When successful, this always allocates already-aliased memory. _Post_ _At_(*DriverObjectExtension, _When_(return==0, __drv_aliasesMem __drv_allocatesMem(Mem) _Post_notnull_)) _When_(return == 0, _Outptr_result_bytebuffer_(DriverObjectExtensionSize)) PVOID *DriverObjectExtension ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PVOID IoAllocateErrorLogEntry( _In_ PVOID IoObject, _In_ UCHAR EntrySize ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PIRP IoAllocateIrp( _In_ CCHAR StackSize, _In_ BOOLEAN ChargeQuota ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PIRP IoAllocateIrpEx( _In_ PDEVICE_OBJECT DeviceObject, _In_ CCHAR StackSize, _In_ BOOLEAN ChargeQuota ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) #define DEVICE_WITH_IRP_EXTENSION ((PDEVICE_OBJECT) -1) #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PMDL IoAllocateMdl( _In_opt_ __drv_aliasesMem PVOID VirtualAddress, _In_ ULONG Length, _In_ BOOLEAN SecondaryBuffer, _In_ BOOLEAN ChargeQuota, _Inout_opt_ PIRP Irp ); #endif typedef enum _IO_PAGING_PRIORITY { IoPagingPriorityInvalid, // Returned if a non-paging IO IRP is passed. IoPagingPriorityNormal, // For regular paging IO IoPagingPriorityHigh, // For high priority paging IO IoPagingPriorityReserved1, // Reserved for future use. IoPagingPriorityReserved2 // Reserved for future use. } IO_PAGING_PRIORITY; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS IoAttachDevice( _In_ _When_(return==0, __drv_aliasesMem) PDEVICE_OBJECT SourceDevice, _In_ PUNICODE_STRING TargetDevice, _Out_ PDEVICE_OBJECT *AttachedDevice ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PDEVICE_OBJECT IoAttachDeviceToDeviceStack( _In_ _When_(return!=0, __drv_aliasesMem) PDEVICE_OBJECT SourceDevice, _In_ PDEVICE_OBJECT TargetDevice ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ __drv_aliasesMem _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PIRP IoBuildAsynchronousFsdRequest( _In_ ULONG MajorFunction, _In_ PDEVICE_OBJECT DeviceObject, _Inout_opt_ PVOID Buffer, _In_opt_ ULONG Length, _In_opt_ PLARGE_INTEGER StartingOffset, _In_opt_ PIO_STATUS_BLOCK IoStatusBlock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ __drv_aliasesMem _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PIRP IoBuildDeviceIoControlRequest( _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_opt_ PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _In_opt_ PKEVENT Event, _Out_ PIO_STATUS_BLOCK IoStatusBlock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoBuildPartialMdl( _In_ PMDL SourceMdl, _Inout_ PMDL TargetMdl, _Inout_ PVOID VirtualAddress, _In_ ULONG Length ); #endif typedef struct _BOOTDISK_INFORMATION { LONGLONG BootPartitionOffset; LONGLONG SystemPartitionOffset; ULONG BootDeviceSignature; ULONG SystemDeviceSignature; } BOOTDISK_INFORMATION, *PBOOTDISK_INFORMATION; // // This structure should follow the previous structure field for field. // typedef struct _BOOTDISK_INFORMATION_EX { LONGLONG BootPartitionOffset; LONGLONG SystemPartitionOffset; ULONG BootDeviceSignature; ULONG SystemDeviceSignature; GUID BootDeviceGuid; GUID SystemDeviceGuid; BOOLEAN BootDeviceIsGpt; BOOLEAN SystemDeviceIsGpt; } BOOTDISK_INFORMATION_EX, *PBOOTDISK_INFORMATION_EX; #if (NTDDI_VERSION >= NTDDI_WIN7) typedef struct _LOADER_PARTITION_INFORMATION_EX { ULONG PartitionStyle; ULONG PartitionNumber; union { ULONG Signature; GUID DeviceId; }; ULONG Flags; } LOADER_PARTITION_INFORMATION_EX, *PLOADER_PARTITION_INFORMATION_EX; typedef struct _BOOTDISK_INFORMATION_LITE { ULONG NumberEntries; LOADER_PARTITION_INFORMATION_EX Entries[1]; } BOOTDISK_INFORMATION_LITE, *PBOOTDISK_INFORMATION_LITE; #else #if (NTDDI_VERSION >= NTDDI_VISTA) typedef struct _BOOTDISK_INFORMATION_LITE { ULONG BootDeviceSignature; ULONG SystemDeviceSignature; GUID BootDeviceGuid; GUID SystemDeviceGuid; BOOLEAN BootDeviceIsGpt; BOOLEAN SystemDeviceIsGpt; } BOOTDISK_INFORMATION_LITE, *PBOOTDISK_INFORMATION_LITE; #endif // NTDDI_VERSION >= NTDDI_VISTA #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI NTSTATUS IoGetBootDiskInformation( _Inout_ PBOOTDISK_INFORMATION BootDiskInformation, _In_ ULONG Size ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI NTSTATUS IoGetBootDiskInformationLite( _Outptr_ PBOOTDISK_INFORMATION_LITE *BootDiskInformation ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_WIN2K) _When_(MajorFunction == IRP_MJ_WRITE, _At_(Buffer, _In_)) _When_(MajorFunction == IRP_MJ_READ, _At_(Buffer, _Out_)) _When_(MajorFunction != IRP_MJ_READ && MajorFunction != IRP_MJ_WRITE, _At_(Buffer, _Pre_null_)) _Must_inspect_result_ __drv_aliasesMem _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PIRP IoBuildSynchronousFsdRequest( _In_ ULONG MajorFunction, _In_ PDEVICE_OBJECT DeviceObject, PVOID Buffer, _In_ ULONG Length, _In_opt_ PLARGE_INTEGER StartingOffset, _In_ PKEVENT Event, _Out_ PIO_STATUS_BLOCK IoStatusBlock ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _Success_(TRUE) NTKERNELAPI NTSTATUS FASTCALL IofCallDriver( _In_ PDEVICE_OBJECT DeviceObject, _Inout_ __drv_aliasesMem PIRP Irp ); #endif #define IoCallDriver(a,b) \ IofCallDriver(a,b) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN IoCancelIrp( _In_ PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS IoCheckShareAccess( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess, _In_ BOOLEAN Update ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI NTSTATUS IoCheckShareAccessEx( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess, _In_ BOOLEAN Update, _In_ PBOOLEAN WritePermission ); #endif // // This value should be returned from completion routines to continue // completing the IRP upwards. Otherwise, STATUS_MORE_PROCESSING_REQUIRED // should be returned. // #define STATUS_CONTINUE_COMPLETION STATUS_SUCCESS // // Completion routines can also use this enumeration in place of status codes. // typedef enum _IO_COMPLETION_ROUTINE_RESULT { ContinueCompletion = STATUS_CONTINUE_COMPLETION, StopCompletion = STATUS_MORE_PROCESSING_REQUIRED } IO_COMPLETION_ROUTINE_RESULT, *PIO_COMPLETION_ROUTINE_RESULT; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL IofCompleteRequest( _In_ PIRP Irp, _In_ CCHAR PriorityBoost ); #endif #define IoCompleteRequest(a,b) \ IofCompleteRequest(a,b) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoConnectInterrupt( _Out_ PKINTERRUPT *InterruptObject, _In_ PKSERVICE_ROUTINE ServiceRoutine, _In_opt_ PVOID ServiceContext, _In_opt_ PKSPIN_LOCK SpinLock, _In_ ULONG Vector, _In_ KIRQL Irql, _In_ KIRQL SynchronizeIrql, _In_ KINTERRUPT_MODE InterruptMode, _In_ BOOLEAN ShareVector, _In_ KAFFINITY ProcessorEnableMask, _In_ BOOLEAN FloatingSave ); #endif // // Interrupt message information table entry definition // typedef struct _IO_INTERRUPT_MESSAGE_INFO_ENTRY { // // Message address - indicates the address the device should use to // generate this message signaled interrupt. // PHYSICAL_ADDRESS MessageAddress; // // Target processor set - indicates the set of processors that this // message in allowed to interrupt. // KAFFINITY TargetProcessorSet; // // Interrupt object - holds a pointer to the interrupt object associated // with this interrupt message. This structure is opaque to drivers. // PKINTERRUPT InterruptObject; // // Message data - supplies the value that the device should write to the // message address in order to generate this interrupt message. // ULONG MessageData; // // The remaining fields indicate the system interrupt vector, IRQL, // trigger mode, and interrupt polarity associated with this interrupt // message. These first three values are suitable for use in a fully // specified connection parameter structure in a call to // IoConnectInterruptEx. // ULONG Vector; KIRQL Irql; KINTERRUPT_MODE Mode; KINTERRUPT_POLARITY Polarity; } IO_INTERRUPT_MESSAGE_INFO_ENTRY, *PIO_INTERRUPT_MESSAGE_INFO_ENTRY; // // Interrupt message information table definition // typedef struct _IO_INTERRUPT_MESSAGE_INFO { // // Unified IRQL - indicates the IRQL that will be used when calling a // message service routine associated with any of the interrupt messages // in this table. Such a unified IRQL will only exist in cases where 1) a // driver provides a spinlock to IoConnectInterruptEx with the intent of // serializing delivery of all of the messages listed in this table or 2) // the driver provides a synchronization IRQL, and no spinlock, with the // intent of blocking any message service routine associated with this // table from directly preempting another one. If neither of these cases // applies, then the different messages in this table are allowed to be // delivered in parallel and at different IRQLs. In this case this field // will be set to zero. // KIRQL UnifiedIrql; // // Message count - indicates the number of entries contained in this // message information table. // ULONG MessageCount; // // Message info - lies at the start of a variable size array of // information table entries, with the size of the array dictated by the // message count associated with this table. Each entry describes a // different interrupt message that has been allocated to this device. // IO_INTERRUPT_MESSAGE_INFO_ENTRY MessageInfo[1]; } IO_INTERRUPT_MESSAGE_INFO, *PIO_INTERRUPT_MESSAGE_INFO; // // Define the connection parameters associated with a fully specified // interrupt connection request. // typedef struct _IO_CONNECT_INTERRUPT_FULLY_SPECIFIED_PARAMETERS { // // PhysicalDeviceObject - Supplies the physical device object associated // with the interrupt being connected. This is normally the physical // device object associated with the device that generates the given // interrupt. // _In_ PDEVICE_OBJECT PhysicalDeviceObject; // // InterruptObject - Supplies a pointer to the location that will be used // to return a pointer to the interrupt object allocated in // association with the interrupt being connected. // _Out_ PKINTERRUPT *InterruptObject; // // ServiceRoutine - Supplies the address of the interrupt service routine // (ISR) that should be executed when the interrupt occurs. // _In_ PKSERVICE_ROUTINE ServiceRoutine; // // ServiceContext - Supplies an opaque pointer to the driver context // information that should be passed to the ISR. // _In_ PVOID ServiceContext; // // SpinLock - Supplies an optional pointer to a spin lock that will be // acquired before every call to the ISR. After providing a spin // lock, the driver can synchronize with the ISR by acquiring the spin // lock at the synchronization IRQL associated with the interrupt. If // this parameter is not provided, then an internal spin lock will be // acquired before each call to the ISR. The driver can use // KeSynchronizeExecution to acquire this internal spin lock at the // appropriate IRQL and thus synchronize with the ISR. // _In_opt_ PKSPIN_LOCK SpinLock; // // SynchronizeIrql - Supplies the IRQL at which the interrupt spin lock // should be acquired and at which the ISR should be executed. This // parameter must be greater than or equal to the IRQL associated with // the interrupt. This parameter is most often used in conjunction // with a caller provided spin lock to serialize ISR execution across // multiple interrupts, however it can also be used without a spin // lock to block this ISR from directly preempting or being directly // preempted by some other ISR. // _In_ KIRQL SynchronizeIrql; // // FloatingSave - Supplies an indication of whether or not the machine's // floating point state should be saved before invoking the ISR. // _In_ BOOLEAN FloatingSave; // // ShareVector - Supplies an indication of whether this interrupt vector // can be shared with other interrupt objects. This value is usually // passed to a driver as part of the translated resources sent along // with IRP_MN_START_DEVICE. // _In_ BOOLEAN ShareVector; // // Vector - Supplies the system interrupt vector associated with the // interrupt being connected. This value is usually passed to a // driver as part of the translated resources sent along with // IRP_MN_START_DEVICE. // _In_ ULONG Vector; // // Irql - Supplies the IRQL associated with the interrupt being connected. // This value is usually passed to a driver as part of its translated // resources sent along with IRP_MN_START_DEVICE. // _In_ KIRQL Irql; // // InterruptMode - Supplies the trigger mode of the interrupt being // connected. This parameter must be LevelSensitive for level // triggered interrupts and Latched for edge triggered interrupts. // This value is usually passed to a driver as part of its translated // resources sent along with IRP_MN_START_DEVICE. // _In_ KINTERRUPT_MODE InterruptMode; // // ProcessorEnableMask - Supplies an affinity mask indicating the set of // processors on which delivery of the interrupt should be allowed. // This value is usually passed to a driver as part of its translated // resources sent along with IRP_MN_START_DEVICE. // _In_ KAFFINITY ProcessorEnableMask; // // Group - Supplies a group number indicating the group of the processors // on which delivery of the interrupt should be allowed. This value // is usually passed to a driver as part of its translated resources // sent along with IRP_MN_START_DEVICE. This value is ignored if the // the version CONNECT_FULLY_SPECIFIED is used, in which case the // group number is always 0. // _In_ USHORT Group; } IO_CONNECT_INTERRUPT_FULLY_SPECIFIED_PARAMETERS, *PIO_CONNECT_INTERRUPT_FULLY_SPECIFIED_PARAMETERS; // // Define the connection parameters associated with a line based interrupt // connection request. // typedef struct _IO_CONNECT_INTERRUPT_LINE_BASED_PARAMETERS { // // PhysicalDeviceObject - Supplies the physical device object associated // with the line based interrupt being connected. In order to // correctly determine the interrupt to connect, this is generally // required to be the physical device object associated with the // device that generates the interrupt of interest. // _In_ PDEVICE_OBJECT PhysicalDeviceObject; // // InterruptObject - Supplies a pointer to the location that will be used // to return a pointer to the interrupt object allocated in // association with the interrupt being connected. // _Out_ PKINTERRUPT *InterruptObject; // // ServiceRoutine - Supplies the address of the interrupt service routine // (ISR) that should be executed when the interrupt occurs. // _In_ PKSERVICE_ROUTINE ServiceRoutine; // // ServiceContext - Supplies an opaque pointer to the driver context // information that should be passed to the ISR. // _In_ PVOID ServiceContext; // // SpinLock - Supplies an optional pointer to a spin lock that will be // acquired before every call to the ISR. After providing a spin // lock, the driver can synchronize with the ISR by acquiring the spin // lock at the synchronization IRQL associated with the interrupt. If // this parameter is not provided, then an internal spin lock will be // acquired before each call to the ISR. The driver can use // KeSynchronizeExecution to acquire this internal spin lock at the // appropriate IRQL and thus synchronize with the ISR. // _In_opt_ PKSPIN_LOCK SpinLock; // // SynchronizeIrql - Supplies an optional IRQL at which the interrupt spin // lock should be acquired and at which the ISR should be executed. // If a nonzero value is provided for this parameter, it must be // greater than or equal to the IRQL associated with the interrupt. // This parameter is most often used in conjunction with a caller // provided spin lock to serialize ISR execution across multiple // interrupts, however it can also be used without a spin lock to // block this ISR from directly preempting or being directly preempted // by some other ISR. If this parameter is omitted then the IRQL of // the interrupt being connected is used as the sychronization IRQL, // both in the case where the caller provides a spin lock and in the // case where the spin lock is omitted. // _In_opt_ KIRQL SynchronizeIrql; // // FloatingSave - Supplies an indication of whether or not the machine's // floating point state should be saved before invoking the ISR. // _In_ BOOLEAN FloatingSave; } IO_CONNECT_INTERRUPT_LINE_BASED_PARAMETERS, *PIO_CONNECT_INTERRUPT_LINE_BASED_PARAMETERS; // // Define the connection parameters associated with a message signaled // interrupt connection request. // typedef struct _IO_CONNECT_INTERRUPT_MESSAGE_BASED_PARAMETERS { // // PhysicalDeviceObject - Supplies the physical device object associated // with the interrupt messages being connected. In order to correctly // determine the set of messages to connect, this is generally // required to be the physical device object associated with the // device that generates the interrupt messages of interest. // _In_ PDEVICE_OBJECT PhysicalDeviceObject; // // ConnectionContext - Supplies a union containing a pointer to the // location that will be used to return the interrupt connection // context to the caller. If message based interrupt connection is // successful, then the connection context is a pointer to the // associated interrupt message information table. If connection // succeeds only after falling back on the associated line based // interrupt, then the connection context is a pointer to the // associated interrupt object. // union { _Out_ PVOID *Generic; _Out_ PIO_INTERRUPT_MESSAGE_INFO *InterruptMessageTable; _Out_ PKINTERRUPT *InterruptObject; } ConnectionContext; // // MessageServiceRoutine - Supplies the interrupt message service routine // (IMSR) that should be executed every time any one of the interrupt // messages being connected is signaled. // _In_ PKMESSAGE_SERVICE_ROUTINE MessageServiceRoutine; // // ServiceContext - Supplies an opaque pointer to the driver context // information that should be passed to the IMSR. // _In_ PVOID ServiceContext; // // SpinLock - Supplies an optional pointer to a spin lock that will be // acquired before every call to the IMSR. After providing a spin // lock, the driver can synchronize with the IMSR by acquiring the // spin lock at the synchronization IRQL associated with the IMSR. // Note that providing a spin lock will serialize processing of all of // the interrupt messages being connected. In other words, providing // a spin lock implies that no two interrupt messages out of the set // being connected can ever be serviced in parallel by the IMSR. // // If this parameter is not provided, then an internal spin lock will // be acquired before each call to the IMSR. This internal spin lock // is associated with the interrupt object corresponding to the actual // message that caused us to execute the IMSR, meaning that the IMSR // can run on multiple processors and potentially at multiple IRQLs in // this case. KeSynchronizeExecution can be used to acquire this // internal spin lock at the appropriate IRQL, thus synchronizing with // IMSR execution associated with a specific interrupt message while // still allowing all other messages to be serviced as they are // signaled. // _In_opt_ PKSPIN_LOCK SpinLock; // // SynchronizeIrql - Supplies an optional IRQL at which the interrupt spin // lock should be acquired and at which the IMSR should be executed. // If a nonzero value is provided for this parameter, it must be // greater than or equal to the maximum IRQL associated with any of // the interrupt messages being connected. // // This parameter is most often used in conjunction with a caller // provided spin lock to serialize IMSR execution across multiple // messages. If a spin lock is provided and this parameter is // omitted, then the synchronization IRQL will be set to the maximum // IRQL associated with any of the interrupt messages. // // This parameter can be used without a spin lock to block this IMSR // from directly preempting or being directly preempted by itself, // some other IMSR, or some other line based interrupt service // routine. If this parameter is omitted and the spin lock is also // omitted, then the IMSR will be executed at the IRQL associated with // the individual message being serviced. In this case it is possible // for the IMSR to preempt itself if it is connected to multiple // messages with different associated IRQLs. // _In_opt_ KIRQL SynchronizeIrql; // // FloatingSave - Supplies an indication of whether or not the machine's // floating point state should be saved before invoking the IMSR. // _In_ BOOLEAN FloatingSave; // // FallBackServiceRoutine - Supplies an optional address of an interrupt // service routine (ISR) that should be executed when the line based // interrupt associated with this device is signaled. This parameter // will only be used when connection to this device's interrupt // messages fails, which most commonly occurs when no interrupt // messages are available for this device. // // Connection to the fall back service routine is functionally // identical to a normal line based interrupt connection operation, // the only difference being that in this case the service context, // spin lock, synchronization IRQL, and floating save parameters given // for the IMSR are reused when connecting the ISR. // _In_opt_ PKSERVICE_ROUTINE FallBackServiceRoutine; } IO_CONNECT_INTERRUPT_MESSAGE_BASED_PARAMETERS, *PIO_CONNECT_INTERRUPT_MESSAGE_BASED_PARAMETERS; // // Define the different interrupt connection types that can be requested // through IoConnectInterruptEx // #define CONNECT_FULLY_SPECIFIED 0x1 #define CONNECT_LINE_BASED 0x2 #define CONNECT_MESSAGE_BASED 0x3 #define CONNECT_FULLY_SPECIFIED_GROUP 0x4 #define CONNECT_MESSAGE_BASED_PASSIVE 0x5 #define CONNECT_CURRENT_VERSION 0x5 // // Interrupt connection parameter structure definition // typedef struct _IO_CONNECT_INTERRUPT_PARAMETERS { // // Version - Supplies the type of interrupt connection requested by this // structure. This field must hold one of the following values. // // CONNECT_FULLY_SPECIFIED - Indicates that an attempt should be // made to connect to the precise interrupt described by this // structure. This vector can be either line based or message // signaled. // // CONNECT_LINE_BASED - Indicates that an attempt should be made // to connect to the line based interrupt associated with this // device. // // CONNECT_MESSAGE_BASED - Indicates that an attempt should be // made to connect to the interrupt messages that have been // allocated for this device, optionally falling back on the // device's line based interrupt if interrupt messages aren't // available. // // CONNECT_FULLY_SPECIFIED_GROUP - Same as CONNECT_FULLY_SPECIFIED, // except that a group number is also specified to indicate // the group of processors on which the interrupt is allowed to // be delivered. // // CONNECT_MESSAGE_BASED_PASSIVE - Same as CONNECT_MESSAGE_BASED, // except that the interrupt will be connected at PASSIVE_LEVEL. // // After successfully connecting an interrupt, this field is filled on // output with the type of connection that was performed. This will // always be the connection type given by the caller except in the // case of a message based connection attempt that falls back to // connection to the associated line based interrupt. // // If the caller passes an unsupported connection type, this field is // filled on output with the maximum connection type supported by the // interrupt connection routine. // _Inout_ ULONG Version; // // Define a union to overlay the connection parameter structures // associated with the different connection types on top of one another. // union { IO_CONNECT_INTERRUPT_FULLY_SPECIFIED_PARAMETERS FullySpecified; IO_CONNECT_INTERRUPT_LINE_BASED_PARAMETERS LineBased; IO_CONNECT_INTERRUPT_MESSAGE_BASED_PARAMETERS MessageBased; }; } IO_CONNECT_INTERRUPT_PARAMETERS, *PIO_CONNECT_INTERRUPT_PARAMETERS; #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI NTSTATUS IoConnectInterruptEx ( _Inout_ PIO_CONNECT_INTERRUPT_PARAMETERS Parameters ); #endif // NTDDI_VERSION >= NTDDI_VISTA #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS IoCreateDevice( _In_ PDRIVER_OBJECT DriverObject, _In_ ULONG DeviceExtensionSize, _In_opt_ PUNICODE_STRING DeviceName, _In_ DEVICE_TYPE DeviceType, _In_ ULONG DeviceCharacteristics, _In_ BOOLEAN Exclusive, _Outptr_result_nullonfailure_ _At_(*DeviceObject, __drv_allocatesMem(Mem) _When_((((_In_function_class_(DRIVER_INITIALIZE)) ||(_In_function_class_(DRIVER_DISPATCH)))), __drv_aliasesMem)) PDEVICE_OBJECT *DeviceObject ); #endif #define WDM_MAJORVERSION 0x06 #define WDM_MINORVERSION 0x00 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) __drv_preferredFunction("RtlIsNtDdiVersionAvailable","Preferred") NTKERNELAPI BOOLEAN IoIsWdmVersionAvailable( _When_(MajorVersion!=1&&MajorVersion!=6, _In_ __drv_reportError("MajorVersion must be 1 or 6")) UCHAR MajorVersion, _In_ _When_(MinorVersion!=0 && MinorVersion!=5 && MinorVersion!=16 && MinorVersion!=32 && MinorVersion!=48, __drv_reportError("MinorVersion must be 0, 0x5, 0x10, 0x20, or 0x30")) UCHAR MinorVersion ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoCreateFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_opt_ PLARGE_INTEGER AllocationSize, _In_ ULONG FileAttributes, _In_ ULONG ShareAccess, _In_ ULONG Disposition, _In_ ULONG CreateOptions, _In_opt_ PVOID EaBuffer, _In_ ULONG EaLength, _In_ CREATE_FILE_TYPE CreateFileType, _In_opt_ PVOID InternalParameters, _In_ ULONG Options ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PKEVENT IoCreateNotificationEvent( _In_ PUNICODE_STRING EventName, _Out_ PHANDLE EventHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoCreateSymbolicLink( _In_ PUNICODE_STRING SymbolicLinkName, _In_ PUNICODE_STRING DeviceName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PKEVENT IoCreateSynchronizationEvent( _In_ PUNICODE_STRING EventName, _Out_ PHANDLE EventHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoCreateUnprotectedSymbolicLink( _In_ PUNICODE_STRING SymbolicLinkName, _In_ PUNICODE_STRING DeviceName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) _Kernel_clear_do_init_(__yes) NTKERNELAPI VOID IoDeleteDevice( _In_ __drv_freesMem(Mem) PDEVICE_OBJECT DeviceObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoDeleteSymbolicLink( _In_ PUNICODE_STRING SymbolicLinkName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID IoDetachDevice( _Inout_ PDEVICE_OBJECT TargetDevice ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID IoDisconnectInterrupt( _In_ PKINTERRUPT InterruptObject ); #endif // // Interrupt disconnection parameter structure definition // typedef struct _IO_DISCONNECT_INTERRUPT_PARAMETERS { // // Version - Supplies the type of interrupt disconnection operation // requested by this structure. This field must match the connection // type returned by a corresponding successful call to // IoConnectInterruptEx. // _In_ ULONG Version; // // ConnectionContext - Supplies a union containing the connection context // associated with the interrupt being disconnected. When // disconnecting fully specified or line based interrupts, this // parameter supplies the interrupt object pointer that was returned // when the interrupt was initially connected. When disconnecting a // set of interrupt messages, this parameter supplies the interrupt // message information table pointer that was returned when the // interrupt messages were initially connected. // union { _In_ PVOID Generic; _In_ PKINTERRUPT InterruptObject; _In_ PIO_INTERRUPT_MESSAGE_INFO InterruptMessageTable; } ConnectionContext; } IO_DISCONNECT_INTERRUPT_PARAMETERS, *PIO_DISCONNECT_INTERRUPT_PARAMETERS; #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI VOID IoDisconnectInterruptEx ( _In_ PIO_DISCONNECT_INTERRUPT_PARAMETERS Parameters ); #endif // NTDDI_VERSION >= NTDDI_VISTA // // Interrupt active/inactive reporting parameter structure definition // typedef struct _IO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS { // // Version - Supplies the type of interrupt reporting operation // requested by this structure. This field must match the connection // type returned by a corresponding successful call to // IoConnectInterruptEx. // _In_ ULONG Version; // // ConnectionContext - Supplies a union containing the connection context // associated with the interrupt being reported. When // referring to fully specified or line based interrupts, this // parameter supplies the interrupt object pointer that was returned // when the interrupt was initially connected. When reporting a // set of interrupt messages, this parameter supplies the interrupt // message information table pointer that was returned when the // interrupt messages were initially connected. // union { _In_ PVOID Generic; _In_ PKINTERRUPT InterruptObject; _In_ PIO_INTERRUPT_MESSAGE_INFO InterruptMessageTable; } ConnectionContext; } IO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS, *PIO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS; #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI VOID IoReportInterruptActive ( _In_ PIO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS Parameters ); VOID IoReportInterruptInactive ( _In_ PIO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS Parameters ); #endif // NTDDI_VERSION >= NTDDI_WIN8 #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI NTSTATUS IoGetAffinityInterrupt ( _In_ PKINTERRUPT InterruptObject, _Out_ PGROUP_AFFINITY GroupAffinity ); #endif // NTDDI_VERSION >= NTDDI_WIN7 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoFreeIrp( _In_ __drv_freesMem(Mem) PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoFreeMdl( PMDL Mdl ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PDEVICE_OBJECT IoGetAttachedDeviceReference( _In_ PDEVICE_OBJECT DeviceObject ); #endif FORCEINLINE __drv_aliasesMem PIO_STACK_LOCATION IoGetCurrentIrpStackLocation( _In_ PIRP Irp ) /*-- Routine Description: This routine is invoked to return a pointer to the current stack location in an I/O Request Packet (IRP). Arguments: Irp - Pointer to the I/O Request Packet. Return Value: The function value is a pointer to the current stack location in the packet. --*/ { NT_ASSERT(Irp->CurrentLocation <= Irp->StackCount + 1); return Irp->Tail.Overlay.CurrentStackLocation; } #if (NTDDI_VERSION >= NTDDI_WIN2K) __drv_aliasesMem _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PVOID IoGetDriverObjectExtension( _In_ PDRIVER_OBJECT DriverObject, _In_ PVOID ClientIdentificationAddress ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PEPROCESS IoGetCurrentProcess( VOID ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoGetDeviceObjectPointer( _In_ PUNICODE_STRING ObjectName, _In_ ACCESS_MASK DesiredAccess, _Out_ PFILE_OBJECT *FileObject, _Out_ PDEVICE_OBJECT *DeviceObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI struct _DMA_ADAPTER * IoGetDmaAdapter( _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, // required for PnP drivers _In_ struct _DEVICE_DESCRIPTION *DeviceDescription, _Out_ _When_(return!=0, _Kernel_IoGetDmaAdapter_ _At_(*NumberOfMapRegisters, _Must_inspect_result_)) PULONG NumberOfMapRegisters ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI BOOLEAN IoForwardIrpSynchronously( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp ); #define IoForwardAndCatchIrp IoForwardIrpSynchronously #endif #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI NTSTATUS IoSynchronousCallDriver( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp ); #endif //++ // // ULONG // IoGetFunctionCodeFromCtlCode( // _In_ ULONG ControlCode // ) // // Routine Description: // // This routine extracts the function code from IOCTL and FSCTL function // control codes. // This routine should only be used by kernel mode code. // // Arguments: // // ControlCode - A function control code (IOCTL or FSCTL) from which the // function code must be extracted. // // Return Value: // // The extracted function code. // // Note: // // The CTL_CODE macro, used to create IOCTL and FSCTL function control // codes, is defined in ntioapi.h // //-- #define IoGetFunctionCodeFromCtlCode( ControlCode ) (\ ( ControlCode >> 2) & 0x00000FFF ) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID IoGetInitialStack( VOID ); #endif _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID IoGetStackLimits ( _Out_ PULONG_PTR LowLimit, _Out_ PULONG_PTR HighLimit ); #if (NTDDI_VERSION >= NTDDI_VISTA) LOGICAL IoWithinStackLimits( _In_ ULONG_PTR RegionStart, _In_ SIZE_T RegionSize ); #endif #define IoCallDriverStackSafeDefault(a, b) IoCallDriver(a, b) // // The following function is used to tell the caller how much stack is available // _IRQL_requires_max_(APC_LEVEL) FORCEINLINE ULONG_PTR IoGetRemainingStackSize ( VOID ) { ULONG_PTR Top; ULONG_PTR Bottom; IoGetStackLimits( &Bottom, &Top ); return((ULONG_PTR)(&Top) - Bottom ); } FORCEINLINE __drv_aliasesMem PIO_STACK_LOCATION IoGetNextIrpStackLocation( _In_ PIRP Irp ) /*++ Routine Description: This routine is invoked to return a pointer to the next stack location in an I/O Request Packet (IRP). Arguments: Irp - Pointer to the I/O Request Packet. Return Value: The function value is a pointer to the next stack location in the packet. --*/ { NT_ASSERT(Irp->CurrentLocation > 0); return ((Irp)->Tail.Overlay.CurrentStackLocation - 1 ); } #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI PDEVICE_OBJECT IoGetRelatedDeviceObject( _In_ PFILE_OBJECT FileObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI PIRP IoGetTopLevelIrp( VOID ); #endif VOID FORCEINLINE IoInitializeDpcRequest( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_DPC_ROUTINE DpcRoutine ) /*++ Routine Description: This routine is invoked to initialize the DPC in a device object for a device driver during its initialization routine. The DPC is used later when the driver interrupt service routine requests that a DPC routine be queued for later execution. Arguments: DeviceObject - Pointer to the device object that the request is for. DpcRoutine - Address of the driver's DPC routine to be executed when the DPC is dequeued for processing. Return Value: None. --*/ { KeInitializeDpc( &DeviceObject->Dpc, #pragma warning (suppress: 28024) // implementation of the required way (PKDEFERRED_ROUTINE) DpcRoutine, DeviceObject ); } #if (NTDDI_VERSION >= NTDDI_WS03) VOID FORCEINLINE IoInitializeThreadedDpcRequest( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_DPC_ROUTINE DpcRoutine ) /*++ Routine Description: This routine is invoked to initialize the DPC in a device object for a device driver during its initialization routine. The DPC is used later when the driver interrupt service routine requests that a DPC routine be queued for later execution. This initializes the DPC as a threaded DPC. Arguments: DeviceObject - Pointer to the device object that the request is for. DpcRoutine - Address of the driver's DPC routine to be executed when the DPC is dequeued for processing. Return Value: None. --*/ { #pragma warning (suppress: 28128) // implementation of the required way KeInitializeThreadedDpc( &DeviceObject->Dpc, #pragma warning (suppress: 28165 28024) // implementation of the required way (PKDEFERRED_ROUTINE) DpcRoutine, DeviceObject ); } #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoInitializeIrp( _Inout_ PIRP Irp, _In_ USHORT PacketSize, _In_ CCHAR StackSize ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoCleanupIrp( _Inout_ PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoInitializeIrpEx( _Inout_ PIRP Irp, _In_opt_ PDEVICE_OBJECT DeviceObject, _In_ USHORT PacketSize, _In_ CCHAR StackSize ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) #if defined(_AMD64_) || defined(_X86_) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoInitializeTimer( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_TIMER_ROUTINE TimerRoutine, _In_opt_ __drv_aliasesMem PVOID Context ); #endif #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoReuseIrp( _Inout_ PIRP Irp, _In_ NTSTATUS Iostatus ); #endif //++ // // BOOLEAN // IoIsErrorUserInduced( // _In_ NTSTATUS Status // ) // // Routine Description: // // This routine is invoked to determine if an error was as a // result of user actions. Typically these error are related // to removable media and will result in a pop-up. // // Arguments: // // Status - The status value to check. // // Return Value: // The function value is TRUE if the user induced the error, // otherwise FALSE is returned. // //-- #define IoIsErrorUserInduced( Status ) ((BOOLEAN) \ (((Status) == STATUS_DEVICE_NOT_READY) || \ ((Status) == STATUS_IO_TIMEOUT) || \ ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \ ((Status) == STATUS_NO_MEDIA_IN_DEVICE) || \ ((Status) == STATUS_VERIFY_REQUIRED) || \ ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \ ((Status) == STATUS_WRONG_VOLUME))) FORCEINLINE VOID IoMarkIrpPending( _Inout_ PIRP Irp ) /*++ Routine Description: This routine marks the specified I/O Request Packet (IRP) to indicate that an initial status of STATUS_PENDING was returned to the caller. This is used so that I/O completion can determine whether or not to fully complete the I/O operation requested by the packet. Arguments: Irp - Pointer to the I/O Request Packet to be marked pending. Return Value: None. --*/ { IoGetCurrentIrpStackLocation( (Irp) )->Control |= SL_PENDING_RETURNED; } #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoRegisterShutdownNotification( _In_ PDEVICE_OBJECT DeviceObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoRegisterLastChanceShutdownNotification( _In_ PDEVICE_OBJECT DeviceObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Requires_lock_held_(_Global_cancel_spin_lock_) _Releases_lock_(_Global_cancel_spin_lock_) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID IoReleaseCancelSpinLock( _In_ _IRQL_restores_ _IRQL_uses_cancel_ KIRQL Irql ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID IoRemoveShareAccess( _In_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) FORCEINLINE VOID IoRequestDpc( _Inout_ PDEVICE_OBJECT DeviceObject, _In_opt_ PIRP Irp, _In_opt_ __drv_aliasesMem PVOID Context ) //++ // // Routine Description: // // This routine is invoked by the device driver's interrupt service routine // to request that a DPC routine be queued for later execution at a lower // IRQL. // // Arguments: // // DeviceObject - Device object for which the request is being processed. // // Irp - Pointer to the current I/O Request Packet (IRP) for the specified // device. // // Context - Provides a general context parameter to be passed to the // DPC routine. // // Return Value: // // None. // //-- { KeInsertQueueDpc( &DeviceObject->Dpc, Irp, Context ); } #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _Ret_maybenull_ FORCEINLINE PDRIVER_CANCEL IoSetCancelRoutine( _Inout_ PIRP Irp, _In_opt_ PDRIVER_CANCEL CancelRoutine ) //++ // // Routine Description: // // This routine is invoked to set the address of a cancel routine which // is to be invoked when an I/O packet has been canceled. // // Arguments: // // Irp - Pointer to the I/O Request Packet itself. // // CancelRoutine - Address of the cancel routine that is to be invoked // if the IRP is cancelled. // // Return Value: // // Previous value of CancelRoutine field in the IRP. // //-- { return (PDRIVER_CANCEL)(ULONG_PTR) InterlockedExchangePointer((PVOID *)&(Irp)->CancelRoutine, (PVOID)(ULONG_PTR)(CancelRoutine) ); } #endif _IRQL_requires_max_(DISPATCH_LEVEL) FORCEINLINE VOID IoSetCompletionRoutine( _In_ PIRP Irp, _In_opt_ PIO_COMPLETION_ROUTINE CompletionRoutine, _In_opt_ __drv_aliasesMem PVOID Context, _In_ BOOLEAN InvokeOnSuccess, _In_ BOOLEAN InvokeOnError, _In_ BOOLEAN InvokeOnCancel ) //++ // // Routine Description: // // This routine is invoked to set the address of a completion routine which // is to be invoked when an I/O packet has been completed by a lower-level // driver. // // Arguments: // // Irp - Pointer to the I/O Request Packet itself. // // CompletionRoutine - Address of the completion routine that is to be // invoked once the next level driver completes the packet. // // Context - Specifies a context parameter to be passed to the completion // routine. // // InvokeOnSuccess - Specifies that the completion routine is invoked when the // operation is successfully completed. // // InvokeOnError - Specifies that the completion routine is invoked when the // operation completes with an error status. // // InvokeOnCancel - Specifies that the completion routine is invoked when the // operation is being canceled. // // Return Value: // // None. // //-- { PIO_STACK_LOCATION irpSp; NT_ASSERT( (InvokeOnSuccess || InvokeOnError || InvokeOnCancel) ? (CompletionRoutine != NULL) : TRUE ); irpSp = IoGetNextIrpStackLocation(Irp); irpSp->CompletionRoutine = CompletionRoutine; irpSp->Context = Context; irpSp->Control = 0; if (InvokeOnSuccess) { irpSp->Control = SL_INVOKE_ON_SUCCESS; } if (InvokeOnError) { irpSp->Control |= SL_INVOKE_ON_ERROR; } if (InvokeOnCancel) { irpSp->Control |= SL_INVOKE_ON_CANCEL; } } #if (NTDDI_VERSION >= NTDDI_WINXP) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI _Must_inspect_result_ NTSTATUS IoSetCompletionRoutineEx( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PIO_COMPLETION_ROUTINE CompletionRoutine, _In_opt_ PVOID Context, _In_ BOOLEAN InvokeOnSuccess, _In_ BOOLEAN InvokeOnError, _In_ BOOLEAN InvokeOnCancel ); #endif FORCEINLINE VOID IoSetNextIrpStackLocation ( _Inout_ PIRP Irp ) /*-- Routine Description: This routine is invoked to set the current IRP stack location to the next stack location, i.e. it "pushes" the stack. Arguments: Irp - Pointer to the I/O Request Packet (IRP). Return Value: None. --*/ { NT_ASSERT(Irp->CurrentLocation > 0); Irp->CurrentLocation--; Irp->Tail.Overlay.CurrentStackLocation--; } FORCEINLINE VOID IoCopyCurrentIrpStackLocationToNext( _Inout_ PIRP Irp ) /*-- Routine Description: This routine is invoked to copy the IRP stack arguments and file pointer from the current IrpStackLocation to the next in an I/O Request Packet (IRP). If the caller wants to call IoCallDriver with a completion routine but does not wish to change the arguments otherwise, the caller first calls IoCopyCurrentIrpStackLocationToNext, then IoSetCompletionRoutine, then IoCallDriver. Arguments: Irp - Pointer to the I/O Request Packet. Return Value: None. --*/ { PIO_STACK_LOCATION irpSp; PIO_STACK_LOCATION nextIrpSp; irpSp = IoGetCurrentIrpStackLocation(Irp); nextIrpSp = IoGetNextIrpStackLocation(Irp); RtlCopyMemory( nextIrpSp, irpSp, FIELD_OFFSET(IO_STACK_LOCATION, CompletionRoutine)); nextIrpSp->Control = 0; } FORCEINLINE VOID IoSkipCurrentIrpStackLocation ( _Inout_ PIRP Irp ) /*-- Routine Description: This routine is invoked to increment the current stack location of a given IRP. If the caller wishes to call the next driver in a stack, and does not wish to change the arguments, nor does he wish to set a completion routine, then the caller first calls IoSkipCurrentIrpStackLocation and the calls IoCallDriver. Arguments: Irp - Pointer to the I/O Request Packet. Return Value: None --*/ { NT_ASSERT(Irp->CurrentLocation <= Irp->StackCount); Irp->CurrentLocation++; Irp->Tail.Overlay.CurrentStackLocation++; } #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID IoSetShareAccess( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Out_ PSHARE_ACCESS ShareAccess ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI VOID IoSetShareAccessEx( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Out_ PSHARE_ACCESS ShareAccess, _In_ PBOOLEAN WritePermission ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID IoSetTopLevelIrp( _In_opt_ PIRP Irp ); #endif typedef struct _IO_REMOVE_LOCK_TRACKING_BLOCK * PIO_REMOVE_LOCK_TRACKING_BLOCK; typedef struct _IO_REMOVE_LOCK_COMMON_BLOCK { BOOLEAN Removed; BOOLEAN Reserved [3]; __volatile LONG IoCount; KEVENT RemoveEvent; } IO_REMOVE_LOCK_COMMON_BLOCK; typedef struct _IO_REMOVE_LOCK_DBG_BLOCK { LONG Signature; ULONG HighWatermark; LONGLONG MaxLockedTicks; LONG AllocateTag; LIST_ENTRY LockList; KSPIN_LOCK Spin; __volatile LONG LowMemoryCount; ULONG Reserved1[4]; PVOID Reserved2; PIO_REMOVE_LOCK_TRACKING_BLOCK Blocks; } IO_REMOVE_LOCK_DBG_BLOCK; typedef struct _IO_REMOVE_LOCK { IO_REMOVE_LOCK_COMMON_BLOCK Common; #if DBG IO_REMOVE_LOCK_DBG_BLOCK Dbg; #endif } IO_REMOVE_LOCK, *PIO_REMOVE_LOCK; #define IoInitializeRemoveLock(Lock, Tag, Maxmin, HighWater) \ IoInitializeRemoveLockEx (Lock, Tag, Maxmin, HighWater, sizeof (IO_REMOVE_LOCK)) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoInitializeRemoveLockEx( _Out_ PIO_REMOVE_LOCK Lock, _In_ ULONG AllocateTag, // Used only on checked kernels _In_ ULONG MaxLockedMinutes, // Used only on checked kernels _In_ ULONG HighWatermark, // Used only on checked kernels _In_ ULONG RemlockSize // are we checked or free ); #endif // // Initialize a remove lock. // // Note: Allocation for remove locks needs to be within the device extension, // so that the memory for this structure stays allocated until such time as the // device object itself is deallocated. // #if DBG #define IoAcquireRemoveLock(RemoveLock, Tag) \ IoAcquireRemoveLockEx(RemoveLock, Tag, __FILE__, __LINE__, sizeof (IO_REMOVE_LOCK)) #else #define IoAcquireRemoveLock(RemoveLock, Tag) \ IoAcquireRemoveLockEx(RemoveLock, Tag, "", 1, sizeof (IO_REMOVE_LOCK)) #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoAcquireRemoveLockEx ( _Inout_ PIO_REMOVE_LOCK RemoveLock, _In_opt_ PVOID Tag, // Optional _In_ PCSTR File, _In_ ULONG Line, _In_ ULONG RemlockSize // are we checked or free ); #endif // // Routine Description: // // This routine is called to acquire the remove lock for a device object. // While the lock is held, the caller can assume that no pending pnp REMOVE // requests will be completed. // // The lock should be acquired immediately upon entering a dispatch routine. // It should also be acquired before creating any new reference to the // device object if there's a chance of releasing the reference before the // new one is done, in addition to references to the driver code itself, // which is removed from memory when the last device object goes. // // Arguments: // // RemoveLock - A pointer to an initialized REMOVE_LOCK structure. // // Tag - Used for tracking lock allocation and release. The same tag // specified when acquiring the lock must be used to release the lock. // Tags are only checked in checked versions of the driver. // // File - set to __FILE__ as the location in the code where the lock was taken. // // Line - set to __LINE__. // // Return Value: // // Returns whether or not the remove lock was obtained. // If successful the caller should continue with work calling // IoReleaseRemoveLock when finished. // // If not successful the lock was not obtained. The caller should abort the // work but not call IoReleaseRemoveLock. // #define IoReleaseRemoveLock(RemoveLock, Tag) \ IoReleaseRemoveLockEx(RemoveLock, Tag, sizeof (IO_REMOVE_LOCK)) #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI VOID NTAPI IoReleaseRemoveLockEx( _Inout_ PIO_REMOVE_LOCK RemoveLock, _In_opt_ PVOID Tag, // Optional _In_ ULONG RemlockSize // are we checked or free ); #endif // // // Routine Description: // // This routine is called to release the remove lock on the device object. It // must be called when finished using a previously locked reference to the // device object. If an Tag was specified when acquiring the lock then the // same Tag must be specified when releasing the lock. // // When the lock count reduces to zero, this routine will signal the waiting // event to release the waiting thread deleting the device object protected // by this lock. // // Arguments: // // DeviceObject - the device object to lock // // Tag - The TAG (if any) specified when acquiring the lock. This is used // for lock tracking purposes // // Return Value: // // none // #define IoReleaseRemoveLockAndWait(RemoveLock, Tag) \ IoReleaseRemoveLockAndWaitEx(RemoveLock, Tag, sizeof (IO_REMOVE_LOCK)) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoReleaseRemoveLockAndWaitEx( _Inout_ PIO_REMOVE_LOCK RemoveLock, _In_opt_ PVOID Tag, _In_ ULONG RemlockSize // are we checked or free ); #endif // // // Routine Description: // // This routine is called when the client would like to delete the // remove-locked resource. This routine will block until all the remove // locks have released. // // This routine MUST be called after acquiring the lock. // // Arguments: // // RemoveLock // // Return Value: // // none // //++ // // USHORT // IoSizeOfIrp( // _In_ CCHAR StackSize // ) // // Routine Description: // // Determines the size of an IRP given the number of stack locations // the IRP will have. // // Arguments: // // StackSize - Number of stack locations for the IRP. // // Return Value: // // Size in bytes of the IRP. // //-- #define IoSizeOfIrp( StackSize ) \ ((USHORT) (sizeof( IRP ) + ((StackSize) * (sizeof( IO_STACK_LOCATION ))))) #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI USHORT IoSizeOfIrpEx( _In_opt_ PDEVICE_OBJECT DeviceObject, _In_ CCHAR StackSize ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID IoStartNextPacket( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN Cancelable ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoStartNextPacketByKey( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN Cancelable, _In_ ULONG Key ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoStartPacket( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_opt_ PULONG Key, _In_opt_ PDRIVER_CANCEL CancelFunction ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) VOID IoSetStartIoAttributes( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN DeferredStartIo, _In_ BOOLEAN NonCancelable ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) #if defined(_AMD64_) || defined(_X86_) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoStartTimer( _In_ PDEVICE_OBJECT DeviceObject ); #endif #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) #if defined(_AMD64_) || defined(_X86_) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoStopTimer( _In_ PDEVICE_OBJECT DeviceObject ); #endif #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID IoUnregisterShutdownNotification( _In_ PDEVICE_OBJECT DeviceObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID IoUpdateShareAccess( _In_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoWriteErrorLogEntry( _In_ PVOID ElEntry ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_same_ _IRQL_requires_(PASSIVE_LEVEL) _Must_inspect_result_ NTSTATUS IoCreateSystemThread( _Inout_ PVOID IoObject, _Out_ PHANDLE ThreadHandle, _In_ ULONG DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ HANDLE ProcessHandle, _Out_opt_ PCLIENT_ID ClientId, _In_ PKSTART_ROUTINE StartRoutine, _In_opt_ PVOID StartContext ); #endif typedef struct _IO_WORKITEM *PIO_WORKITEM; _Function_class_(IO_WORKITEM_ROUTINE) _IRQL_requires_(PASSIVE_LEVEL) _IRQL_requires_same_ typedef VOID IO_WORKITEM_ROUTINE ( _In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PVOID Context ); typedef IO_WORKITEM_ROUTINE *PIO_WORKITEM_ROUTINE; #if (NTDDI_VERSION >= NTDDI_WIN2K) __drv_allocatesMem(Mem) _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTKERNELAPI PIO_WORKITEM IoAllocateWorkItem( _In_ PDEVICE_OBJECT DeviceObject ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoFreeWorkItem( _In_ __drv_freesMem(Mem) PIO_WORKITEM IoWorkItem ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoQueueWorkItem( _Inout_ __drv_aliasesMem PIO_WORKITEM IoWorkItem, _In_ PIO_WORKITEM_ROUTINE WorkerRoutine, _In_ WORK_QUEUE_TYPE QueueType, _In_opt_ __drv_aliasesMem PVOID Context ); #endif _Function_class_(IO_WORKITEM_ROUTINE_EX) _IRQL_requires_(PASSIVE_LEVEL) _IRQL_requires_same_ typedef VOID IO_WORKITEM_ROUTINE_EX ( _In_ PVOID IoObject, _In_opt_ PVOID Context, _In_ PIO_WORKITEM IoWorkItem ); typedef IO_WORKITEM_ROUTINE_EX *PIO_WORKITEM_ROUTINE_EX; #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(DISPATCH_LEVEL) VOID IoQueueWorkItemEx( _Inout_ __drv_aliasesMem PIO_WORKITEM IoWorkItem, _In_ PIO_WORKITEM_ROUTINE_EX WorkerRoutine, _In_ WORK_QUEUE_TYPE QueueType, _In_opt_ __drv_aliasesMem PVOID Context ); ULONG IoSizeofWorkItem( VOID ); VOID IoInitializeWorkItem( _In_ PVOID IoObject, _Out_ PIO_WORKITEM IoWorkItem ); VOID IoUninitializeWorkItem( _Inout_ PIO_WORKITEM IoWorkItem ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) BOOLEAN IoTryQueueWorkItem( _Inout_ __drv_when(return != 0, __drv_aliasesMem) PIO_WORKITEM IoWorkItem, _In_ PIO_WORKITEM_ROUTINE_EX WorkerRoutine, _In_ WORK_QUEUE_TYPE QueueType, _In_opt_ __drv_aliasesMem PVOID Context ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoWMIRegistrationControl( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG Action ); #endif // // Action code for IoWMIRegistrationControl api // #define WMIREG_ACTION_REGISTER 1 #define WMIREG_ACTION_DEREGISTER 2 #define WMIREG_ACTION_REREGISTER 3 #define WMIREG_ACTION_UPDATE_GUIDS 4 #define WMIREG_ACTION_BLOCK_IRPS 5 // // Code passed in IRP_MN_REGINFO WMI irp // #define WMIREGISTER 0 #define WMIUPDATE 1 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoWMIAllocateInstanceIds( _In_ LPCGUID Guid, _In_ ULONG InstanceCount, _Out_ ULONG *FirstInstanceId ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI NTSTATUS IoWMISuggestInstanceName( _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, _In_opt_ PUNICODE_STRING SymbolicLinkName, _In_ BOOLEAN CombineNames, _Out_ PUNICODE_STRING SuggestedInstanceName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS IoWMIWriteEvent( _Inout_ _When_(return==0, __drv_aliasesMem) PVOID WnodeEventItem ); #endif #if defined(_WIN64) NTKERNELAPI ULONG IoWMIDeviceObjectToProviderId( _In_ PDEVICE_OBJECT DeviceObject ); #else #define IoWMIDeviceObjectToProviderId(DeviceObject) ((ULONG)(DeviceObject)) #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMIOpenBlock ( _In_ LPCGUID Guid, _In_ ULONG DesiredAccess, _Out_ PVOID *DataBlockObject ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMIQueryAllData ( _In_ PVOID DataBlockObject, _Inout_ PULONG InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) /* non paged */ PVOID OutBuffer ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMIQueryAllDataMultiple ( _In_reads_(ObjectCount) PVOID *DataBlockObjectList, _In_ ULONG ObjectCount, _Inout_ PULONG InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) /* non paged */ PVOID OutBuffer ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMIQuerySingleInstance ( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _Inout_ PULONG InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) /* non paged */ PVOID OutBuffer ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) NTKERNELAPI NTSTATUS IoWMIQuerySingleInstanceMultiple ( _In_reads_(ObjectCount) PVOID *DataBlockObjectList, _In_reads_(ObjectCount) PUNICODE_STRING InstanceNames, _In_ ULONG ObjectCount, _Inout_ PULONG InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) /* non paged */ PVOID OutBuffer ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMISetSingleInstance( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _In_ ULONG Version, _In_ ULONG ValueBufferSize, _In_reads_bytes_(ValueBufferSize) PVOID ValueBuffer ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMISetSingleItem( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _In_ ULONG DataItemId, _In_ ULONG Version, _In_ ULONG ValueBufferSize, _In_reads_bytes_(ValueBufferSize) PVOID ValueBuffer ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMIExecuteMethod( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _In_ ULONG MethodId, _In_ ULONG InBufferSize, _Inout_ PULONG OutBufferSize, _Inout_updates_bytes_to_opt_(*OutBufferSize, InBufferSize) PUCHAR InOutBuffer ); #endif typedef _Function_class_(WMI_NOTIFICATION_CALLBACK) _IRQL_requires_same_ VOID FWMI_NOTIFICATION_CALLBACK ( PVOID Wnode, PVOID Context ); typedef FWMI_NOTIFICATION_CALLBACK *WMI_NOTIFICATION_CALLBACK; #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMISetNotificationCallback( _Inout_ PVOID Object, _In_ WMI_NOTIFICATION_CALLBACK Callback, _In_opt_ PVOID Context ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMIHandleToInstanceName( _In_ PVOID DataBlockObject, _In_ HANDLE FileHandle, _Out_ PUNICODE_STRING InstanceName ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoWMIDeviceObjectToInstanceName( _In_ PVOID DataBlockObject, _In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING InstanceName ); #endif _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN IoIs32bitProcess( _In_opt_ PIRP Irp ); #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN IoIsInitiator32bitProcess( _In_ PIRP Irp ); #endif // NTDDI_VERSION >= NTDDI_WIN8 #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI VOID IoFreeErrorLogEntry( _In_ PVOID ElEntry ); #endif // Cancel SAFE API set start // // The following APIs are to help ease the pain of writing queue packages that // handle the cancellation race well. The idea of this set of APIs is to not // force a single queue data structure but allow the cancel logic to be hidden // from the drivers. A driver implements a queue and as part of its header // includes the IO_CSQ structure. In its initialization routine it calls // IoInitializeCsq. Then in the dispatch routine when the driver wants to // insert an IRP into the queue it calls IoCsqInsertIrp. When the driver wants // to remove something from the queue it calls IoCsqRemoveIrp. Note that Insert // can fail if the IRP was cancelled in the meantime. Remove can also fail if // the IRP was already cancelled. // // There are typically two modes where drivers queue IRPs. These two modes are // covered by the cancel safe queue API set. // // Mode 1: // One is where the driver queues the IRP and at some later // point in time dequeues an IRP and issues the IO request. // For this mode the driver should use IoCsqInsertIrp and IoCsqRemoveNextIrp. // The driver in this case is expected to pass NULL to the irp context // parameter in IoInsertIrp. // // Mode 2: // In this the driver queues theIRP, issues the IO request (like issuing a DMA // request or writing to a register) and when the IO request completes (either // using a DPC or timer) the driver dequeues the IRP and completes it. For this // mode the driver should use IoCsqInsertIrp and IoCsqRemoveIrp. In this case // the driver should allocate an IRP context and pass it in to IoCsqInsertIrp. // The cancel API code creates an association between the IRP and the context // and thus ensures that when the time comes to remove the IRP it can ascertain // correctly. // // Note that the cancel API set assumes that the field DriverContext[3] is // always available for use and that the driver does not use it. // // // Bookkeeping structure. This should be opaque to drivers. // Drivers typically include this as part of their queue headers. // Given a CSQ pointer the driver should be able to get its // queue header using CONTAINING_RECORD macro // typedef struct _IO_CSQ IO_CSQ, *PIO_CSQ; #define IO_TYPE_CSQ_IRP_CONTEXT 1 #define IO_TYPE_CSQ 2 #define IO_TYPE_CSQ_EX 3 // // IRP context structure. This structure is necessary if the driver is using // the second mode. // typedef struct _IO_CSQ_IRP_CONTEXT { ULONG Type; PIRP Irp; PIO_CSQ Csq; } IO_CSQ_IRP_CONTEXT, *PIO_CSQ_IRP_CONTEXT; // // Routines that insert/remove IRP // typedef VOID IO_CSQ_INSERT_IRP ( _In_ struct _IO_CSQ *Csq, _In_ PIRP Irp ); typedef IO_CSQ_INSERT_IRP *PIO_CSQ_INSERT_IRP; typedef NTSTATUS IO_CSQ_INSERT_IRP_EX ( _In_ struct _IO_CSQ *Csq, _In_ PIRP Irp, _In_ PVOID InsertContext ); typedef IO_CSQ_INSERT_IRP_EX *PIO_CSQ_INSERT_IRP_EX; typedef VOID IO_CSQ_REMOVE_IRP ( _In_ PIO_CSQ Csq, _In_ PIRP Irp ); typedef IO_CSQ_REMOVE_IRP *PIO_CSQ_REMOVE_IRP; // // Retrieves next entry after Irp from the queue. // Returns NULL if there are no entries in the queue. // If Irp is NUL, returns the entry in the head of the queue. // This routine does not remove the IRP from the queue. // typedef PIRP IO_CSQ_PEEK_NEXT_IRP ( _In_ PIO_CSQ Csq, _In_ PIRP Irp, _In_ PVOID PeekContext ); typedef IO_CSQ_PEEK_NEXT_IRP *PIO_CSQ_PEEK_NEXT_IRP; // // Lock routine that protects the cancel safe queue. // typedef VOID IO_CSQ_ACQUIRE_LOCK ( _In_ PIO_CSQ Csq, _Out_ PKIRQL Irql ); typedef IO_CSQ_ACQUIRE_LOCK *PIO_CSQ_ACQUIRE_LOCK; typedef VOID IO_CSQ_RELEASE_LOCK ( _In_ PIO_CSQ Csq, _In_ KIRQL Irql ); typedef IO_CSQ_RELEASE_LOCK *PIO_CSQ_RELEASE_LOCK; // // Completes the IRP with STATUS_CANCELLED. IRP is guaranteed to be valid // In most cases this routine just calls IoCompleteRequest(Irp, STATUS_CANCELLED); // typedef VOID IO_CSQ_COMPLETE_CANCELED_IRP ( _In_ PIO_CSQ Csq, _In_ PIRP Irp ); typedef IO_CSQ_COMPLETE_CANCELED_IRP *PIO_CSQ_COMPLETE_CANCELED_IRP; // // Bookkeeping structure. This should be opaque to drivers. // Drivers typically include this as part of their queue headers. // Given a CSQ pointer the driver should be able to get its // queue header using CONTAINING_RECORD macro // typedef struct _IO_CSQ { ULONG Type; PIO_CSQ_INSERT_IRP CsqInsertIrp; PIO_CSQ_REMOVE_IRP CsqRemoveIrp; PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp; PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock; PIO_CSQ_RELEASE_LOCK CsqReleaseLock; PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp; PVOID ReservePointer; // Future expansion } IO_CSQ, *PIO_CSQ; // // Initializes the cancel queue structure. // #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI NTSTATUS IoCsqInitialize( _Out_ PIO_CSQ Csq, _In_ PIO_CSQ_INSERT_IRP CsqInsertIrp, _In_ PIO_CSQ_REMOVE_IRP CsqRemoveIrp, _In_ PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp, _In_ PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock, _In_ PIO_CSQ_RELEASE_LOCK CsqReleaseLock, _In_ PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp ); #endif #if (NTDDI_VERSION >= NTDDI_WS03) NTKERNELAPI NTSTATUS IoCsqInitializeEx( _Out_ PIO_CSQ Csq, _In_ PIO_CSQ_INSERT_IRP_EX CsqInsertIrp, _In_ PIO_CSQ_REMOVE_IRP CsqRemoveIrp, _In_ PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp, _In_ PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock, _In_ PIO_CSQ_RELEASE_LOCK CsqReleaseLock, _In_ PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp ); #endif // // The caller calls this routine to insert the IRP and return STATUS_PENDING. // #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI VOID IoCsqInsertIrp( _Inout_ PIO_CSQ Csq, _Inout_ PIRP Irp, _Out_opt_ PIO_CSQ_IRP_CONTEXT Context ); #endif #if (NTDDI_VERSION >= NTDDI_WS03) NTKERNELAPI NTSTATUS IoCsqInsertIrpEx( _Inout_ PIO_CSQ Csq, _Inout_ PIRP Irp, _Out_opt_ PIO_CSQ_IRP_CONTEXT Context, _In_opt_ PVOID InsertContext ); #endif // // Returns an IRP if one can be found. NULL otherwise. // #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI PIRP IoCsqRemoveNextIrp( _Inout_ PIO_CSQ Csq, _In_opt_ PVOID PeekContext ); #endif // // This routine is called from timeout or DPCs. // The context is presumably part of the DPC or timer context. // If succesfull returns the IRP associated with context. // #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI PIRP IoCsqRemoveIrp( _Inout_ PIO_CSQ Csq, _Inout_ PIO_CSQ_IRP_CONTEXT Context ); #endif // Cancel SAFE API set end #if (NTDDI_VERSION >= NTDDI_WINXPSP1) NTKERNELAPI NTSTATUS IoValidateDeviceIoControlAccess( _In_ PIRP Irp, _In_ ULONG RequiredAccess ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) IO_PRIORITY_HINT IoGetIoPriorityHint( _In_ PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSTATUS IoSetIoPriorityHint( _In_ PIRP Irp, _In_ IO_PRIORITY_HINT PriorityHint ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSTATUS IoAllocateSfioStreamIdentifier( _In_ PFILE_OBJECT FileObject, _In_ ULONG Length, _In_ PVOID Signature, _Out_ PVOID *StreamIdentifier ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) PVOID IoGetSfioStreamIdentifier( _In_ PFILE_OBJECT FileObject, _In_ PVOID Signature ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSTATUS IoFreeSfioStreamIdentifier( _In_ PFILE_OBJECT FileObject, _In_ PVOID Signature ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) NTSTATUS IoGetIoAttributionHandle ( _In_ PIRP Irp, _Out_ PVOID* IoAttributionHandle ); #define IO_ATTRIBUTION_INFO_V1 1 typedef struct _IO_ATTRIBUTION_INFORMATION { ULONG Version; union { struct { ULONG MajorCode : 8; ULONG IoStart : 1; ULONG QueueOnly : 1; ULONG IoFailed : 1; ULONG VirtualDevice : 1; ULONG Spare : 20; }; ULONG AllFlags; } Flags; ULONG Length; // // Times in units of 100ns. // ULONGLONG ServiceStartTime; ULONGLONG CurrentTime; } IO_ATTRIBUTION_INFORMATION, *PIO_ATTRIBUTION_INFORMATION; NTSTATUS IoRecordIoAttribution ( _Inout_ PVOID OpaqueHandle, _In_ IO_ATTRIBUTION_INFORMATION* AttributionInformation ); #define IO_SET_IRP_IO_ATTRIBUTION_FROM_THREAD 0x1 #define IO_SET_IRP_IO_ATTRIBUTION_FROM_PROCESS 0x2 #define IO_SET_IRP_IO_ATTRIBUTION_FLAGS_MASK 0x3 NTSTATUS IoSetIoAttributionIrp ( _Inout_ PIRP Irp, _In_ PVOID AttributionSource, _In_ ULONG Flags ); #endif typedef enum _IO_ACCESS_TYPE { // // Indicates that the Io will // be comprised solely of reads // ReadAccess, // // Indicates that the Io will // be comprised solely of writes // WriteAccess, // // Indicates that the Io will be // comprised of reads and writes // ModifyAccess } IO_ACCESS_TYPE; typedef enum _IO_ACCESS_MODE { // // Indicates that the Io will be // sent down in a sequential order // SequentialAccess, // // Indicates that the Io might // not be in a predictable order // RandomAccess } IO_ACCESS_MODE; typedef enum _IO_CONTAINER_NOTIFICATION_CLASS { IoSessionStateNotification, // 0 - Session State Notifications IoMaxContainerNotificationClass } IO_CONTAINER_NOTIFICATION_CLASS; typedef struct _IO_SESSION_STATE_NOTIFICATION { ULONG Size; ULONG Flags; PVOID IoObject; ULONG EventMask; PVOID Context; } IO_SESSION_STATE_NOTIFICATION, *PIO_SESSION_STATE_NOTIFICATION; typedef enum _IO_CONTAINER_INFORMATION_CLASS { IoSessionStateInformation, // 0 - Session State Information IoMaxContainerInformationClass } IO_CONTAINER_INFORMATION_CLASS; typedef struct _IO_SESSION_STATE_INFORMATION { ULONG SessionId; IO_SESSION_STATE SessionState; BOOLEAN LocalSession; } IO_SESSION_STATE_INFORMATION, *PIO_SESSION_STATE_INFORMATION; #if (NTDDI_VERSION >= NTDDI_WIN7) NTSTATUS IoGetContainerInformation ( _In_ IO_CONTAINER_INFORMATION_CLASS InformationClass, _In_opt_ PVOID ContainerObject, _Inout_updates_bytes_opt_(BufferLength) PVOID Buffer, _In_ ULONG BufferLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) typedef NTSTATUS (*PIO_CONTAINER_NOTIFICATION_FUNCTION)(); typedef NTSTATUS IO_SESSION_NOTIFICATION_FUNCTION ( _In_ PVOID SessionObject, _In_ PVOID IoObject, _In_ ULONG Event, _In_ PVOID Context, _In_reads_bytes_opt_(PayloadLength) PVOID NotificationPayload, _In_ ULONG PayloadLength ); typedef IO_SESSION_NOTIFICATION_FUNCTION *PIO_SESSION_NOTIFICATION_FUNCTION; #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTSTATUS IoRegisterContainerNotification( _In_ IO_CONTAINER_NOTIFICATION_CLASS NotificationClass, _In_ PIO_CONTAINER_NOTIFICATION_FUNCTION CallbackFunction, _In_reads_bytes_opt_(NotificationInformationLength) PVOID NotificationInformation, _In_ ULONG NotificationInformationLength, _Out_ PVOID CallbackRegistration ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) VOID IoUnregisterContainerNotification( _In_ PVOID CallbackRegistration ); #endif #ifdef RUN_WPP #include #include #endif // #ifdef RUN_WPP #ifndef _TRACEHANDLE_DEFINED #define _TRACEHANDLE_DEFINED typedef ULONG64 TRACEHANDLE, *PTRACEHANDLE; #endif // // Trace Provider APIs // #ifdef RUN_WPP #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) NTSTATUS WmiTraceMessage ( _In_ TRACEHANDLE LoggerHandle, _In_ ULONG MessageFlags, _In_ LPCGUID MessageGuid, _In_ USHORT MessageNumber, ... ); #endif #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) NTSTATUS WmiTraceMessageVa ( _In_ TRACEHANDLE LoggerHandle, _In_ ULONG MessageFlags, _In_ LPCGUID MessageGuid, _In_ USHORT MessageNumber, _In_ va_list MessageArgList ); #endif #endif // #ifdef RUN_WPP #ifndef TRACE_INFORMATION_CLASS_DEFINE typedef struct _ETW_TRACE_SESSION_SETTINGS { ULONG Version; ULONG BufferSize; ULONG MinimumBuffers; ULONG MaximumBuffers; ULONG LoggerMode; ULONG FlushTimer; ULONG FlushThreshold; ULONG ClockType; } ETW_TRACE_SESSION_SETTINGS, *PETW_TRACE_SESSION_SETTINGS; typedef enum _TRACE_INFORMATION_CLASS { TraceIdClass, TraceHandleClass, TraceEnableFlagsClass, TraceEnableLevelClass, GlobalLoggerHandleClass, EventLoggerHandleClass, AllLoggerHandlesClass, TraceHandleByNameClass, LoggerEventsLostClass, TraceSessionSettingsClass, LoggerEventsLoggedClass, DiskIoNotifyRoutinesClass, TraceInformationClassReserved1, FltIoNotifyRoutinesClass, TraceInformationClassReserved2, WdfNotifyRoutinesClass, MaxTraceInformationClass } TRACE_INFORMATION_CLASS; #if (NTDDI_VERSION >= NTDDI_WINXP) NTKERNELAPI _IRQL_requires_max_(APC_LEVEL) NTSTATUS WmiQueryTraceInformation ( _In_ TRACE_INFORMATION_CLASS TraceInformationClass, _Out_writes_bytes_(TraceInformationLength) PVOID TraceInformation, _In_ ULONG TraceInformationLength, _Out_opt_ PULONG RequiredLength, _In_opt_ PVOID Buffer ); #endif #define TRACE_INFORMATION_CLASS_DEFINE #endif // TRACE_INFORMATION_CLASS_DEFINE #ifndef _ETW_KM_ #define _ETW_KM_ #endif #include // // Optional callback function that users provide. // typedef _IRQL_requires_max_(PASSIVE_LEVEL) _IRQL_requires_same_ VOID NTAPI ETWENABLECALLBACK ( _In_ LPCGUID SourceId, _In_ ULONG ControlCode, _In_ UCHAR Level, _In_ ULONGLONG MatchAnyKeyword, _In_ ULONGLONG MatchAllKeyword, _In_opt_ PEVENT_FILTER_DESCRIPTOR FilterData, _Inout_opt_ PVOID CallbackContext ); typedef ETWENABLECALLBACK *PETWENABLECALLBACK; // // Kernel Mode Registration APIs. // #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EtwRegister ( _In_ LPCGUID ProviderId, _In_opt_ PETWENABLECALLBACK EnableCallback, _In_opt_ PVOID CallbackContext, _Out_ PREGHANDLE RegHandle ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EtwUnregister ( _In_ REGHANDLE RegHandle ); #endif #if (NTDDI_VERSION >= NTDDI_THRESHOLD) NTKERNELAPI _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS EtwSetInformation( _In_ REGHANDLE RegHandle, _In_ EVENT_INFO_CLASS InformationClass, _In_reads_bytes_opt_(InformationLength) PVOID EventInformation, _In_ ULONG InformationLength ); #endif // // Kernel Mode Control (Is Enabled) APIs // #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) BOOLEAN EtwEventEnabled ( _In_ REGHANDLE RegHandle, _In_ PCEVENT_DESCRIPTOR EventDescriptor ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) BOOLEAN EtwProviderEnabled ( _In_ REGHANDLE RegHandle, _In_ UCHAR Level, _In_ ULONGLONG Keyword ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _When_(ControlCode==EVENT_ACTIVITY_CTRL_CREATE_ID, _IRQL_requires_max_(HIGH_LEVEL) _At_(ActivityId, _Out_)) _When_(ControlCode==EVENT_ACTIVITY_CTRL_GET_ID, _IRQL_requires_max_(APC_LEVEL) _At_(ActivityId, _Out_)) _When_(ControlCode==EVENT_ACTIVITY_CTRL_SET_ID, _IRQL_requires_max_(APC_LEVEL) _At_(ActivityId, _In_)) _When_(ControlCode==EVENT_ACTIVITY_CTRL_GET_SET_ID, _IRQL_requires_max_(APC_LEVEL) _At_(ActivityId, _Inout_)) _When_(ControlCode==EVENT_ACTIVITY_CTRL_CREATE_SET_ID, _IRQL_requires_max_(APC_LEVEL) _At_(ActivityId, _Out_)) NTSTATUS EtwActivityIdControl ( _In_ ULONG ControlCode, _Inout_updates_bytes_(sizeof(GUID)) LPGUID ActivityId ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS EtwActivityIdControlKernel ( _In_ ULONG ControlCode, _Inout_ LPCGUID *ActivityId ); #endif // // Kernel Mode Writing (Publishing/Logging) APIs // #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) NTSTATUS EtwWrite ( _In_ REGHANDLE RegHandle, _In_ PCEVENT_DESCRIPTOR EventDescriptor, _In_opt_ LPCGUID ActivityId, _In_ ULONG UserDataCount, _In_reads_opt_(UserDataCount) PEVENT_DATA_DESCRIPTOR UserData ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) NTSTATUS EtwWriteTransfer ( _In_ REGHANDLE RegHandle, _In_ PCEVENT_DESCRIPTOR EventDescriptor, _In_opt_ LPCGUID ActivityId, _In_opt_ LPCGUID RelatedActivityId, _In_ ULONG UserDataCount, _In_reads_opt_(UserDataCount) PEVENT_DATA_DESCRIPTOR UserData ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) NTSTATUS EtwWriteString ( _In_ REGHANDLE RegHandle, _In_ UCHAR Level, _In_ ULONGLONG Keyword, _In_opt_ LPCGUID ActivityId, _In_ PCWSTR String ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI _IRQL_requires_max_(HIGH_LEVEL) NTSTATUS EtwWriteEx ( _In_ REGHANDLE RegHandle, _In_ PCEVENT_DESCRIPTOR EventDescriptor, _In_ ULONG64 Filter, _In_ ULONG Flags, _In_opt_ LPCGUID ActivityId, _In_opt_ LPCGUID RelatedActivityId, _In_ ULONG UserDataCount, _In_reads_opt_(UserDataCount) PEVENT_DATA_DESCRIPTOR UserData ); #endif #if (NTDDI_VERSION >= NTDDI_THRESHOLD) NTKERNELAPI _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS SeEtwWriteKMCveEvent ( _In_ PCUNICODE_STRING CveId, _In_opt_ PCUNICODE_STRING AdditionalDetails ); #endif // // Define PnP Device Property for IoGetDeviceProperty // #ifdef _PREFAST_ #define __string_type 0x1000 #define __guid_type 0x2000 #define __multiString_type 0x4000 #else #define __string_type 0 #define __guid_type 0 #define __multiString_type 0 #endif typedef enum { DevicePropertyDeviceDescription = 0x0 | __string_type, DevicePropertyHardwareID = 0x1 | __multiString_type, DevicePropertyCompatibleIDs = 0x2 | __multiString_type, DevicePropertyBootConfiguration = 0x3, DevicePropertyBootConfigurationTranslated = 0x4, DevicePropertyClassName = 0x5 | __string_type, DevicePropertyClassGuid = 0x6 | __string_type, DevicePropertyDriverKeyName = 0x7 | __string_type, DevicePropertyManufacturer = 0x8 | __string_type, DevicePropertyFriendlyName = 0x9 | __string_type, DevicePropertyLocationInformation = 0xa | __string_type, DevicePropertyPhysicalDeviceObjectName = 0xb | __string_type, DevicePropertyBusTypeGuid = 0xc | __guid_type, DevicePropertyLegacyBusType = 0xd, DevicePropertyBusNumber = 0xe, DevicePropertyEnumeratorName = 0xf | __string_type, DevicePropertyAddress = 0x10, DevicePropertyUINumber = 0x11, DevicePropertyInstallState = 0x12, DevicePropertyRemovalPolicy = 0x13, DevicePropertyResourceRequirements = 0x14, DevicePropertyAllocatedResources = 0x15, DevicePropertyContainerID = 0x16 | __string_type } DEVICE_REGISTRY_PROPERTY; typedef _Function_class_(TRANSLATE_BUS_ADDRESS) _IRQL_requires_same_ _Success_(return) BOOLEAN TRANSLATE_BUS_ADDRESS( _Inout_opt_ PVOID Context, _In_ PHYSICAL_ADDRESS BusAddress, _In_ ULONG Length, _Out_ PULONG AddressSpace, _Out_ PPHYSICAL_ADDRESS TranslatedAddress ); typedef TRANSLATE_BUS_ADDRESS *PTRANSLATE_BUS_ADDRESS; typedef _Function_class_(GET_DMA_ADAPTER) _IRQL_requires_same_ struct _DMA_ADAPTER *GET_DMA_ADAPTER( _Inout_opt_ PVOID Context, _In_ struct _DEVICE_DESCRIPTION *DeviceDescriptor, _Out_ PULONG NumberOfMapRegisters ); typedef GET_DMA_ADAPTER *PGET_DMA_ADAPTER; typedef _Function_class_(GET_SET_DEVICE_DATA) _IRQL_requires_same_ ULONG GET_SET_DEVICE_DATA ( _Inout_opt_ PVOID Context, _In_ ULONG DataType, _Inout_updates_bytes_(Length) PVOID Buffer, _In_ ULONG Offset, _In_range_(!=,0) ULONG Length ); typedef GET_SET_DEVICE_DATA *PGET_SET_DEVICE_DATA; typedef enum _DEVICE_INSTALL_STATE { InstallStateInstalled, InstallStateNeedsReinstall, InstallStateFailedInstall, InstallStateFinishInstall } DEVICE_INSTALL_STATE, *PDEVICE_INSTALL_STATE; // // Define structure returned in response to IRP_MN_QUERY_BUS_INFORMATION by a // PDO indicating the type of bus the device exists on. // typedef struct _PNP_BUS_INFORMATION { GUID BusTypeGuid; INTERFACE_TYPE LegacyBusType; ULONG BusNumber; } PNP_BUS_INFORMATION, *PPNP_BUS_INFORMATION; // // Define structure returned in response to IRP_MN_QUERY_LEGACY_BUS_INFORMATION // by an FDO indicating the type of bus it is. This is normally the same bus // type as the device's children (i.e., as retrieved from the child PDO's via // IRP_MN_QUERY_BUS_INFORMATION) except for cases like CardBus, which can // support both 16-bit (PCMCIABus) and 32-bit (PCIBus) cards. // typedef struct _LEGACY_BUS_INFORMATION { GUID BusTypeGuid; INTERFACE_TYPE LegacyBusType; ULONG BusNumber; } LEGACY_BUS_INFORMATION, *PLEGACY_BUS_INFORMATION; // // Defines for IoGetDeviceProperty(DevicePropertyRemovalPolicy). // typedef enum _DEVICE_REMOVAL_POLICY { RemovalPolicyExpectNoRemoval = 1, RemovalPolicyExpectOrderlyRemoval = 2, RemovalPolicyExpectSurpriseRemoval = 3 } DEVICE_REMOVAL_POLICY, *PDEVICE_REMOVAL_POLICY; typedef struct _BUS_INTERFACE_STANDARD { // // generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // standard bus interfaces // PTRANSLATE_BUS_ADDRESS TranslateBusAddress; PGET_DMA_ADAPTER GetDmaAdapter; PGET_SET_DEVICE_DATA SetBusData; PGET_SET_DEVICE_DATA GetBusData; } BUS_INTERFACE_STANDARD, *PBUS_INTERFACE_STANDARD; typedef _Function_class_(GET_VIRTUAL_DEVICE_DATA) _IRQL_requires_same_ _IRQL_requires_max_(DISPATCH_LEVEL) ULONG GET_VIRTUAL_DEVICE_DATA ( _Inout_ PVOID Context, _In_ USHORT VirtualFunction, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Offset, _In_ ULONG Length ); typedef GET_VIRTUAL_DEVICE_DATA *PGET_VIRTUAL_DEVICE_DATA; typedef _Function_class_(SET_VIRTUAL_DEVICE_DATA) _IRQL_requires_same_ _IRQL_requires_max_(DISPATCH_LEVEL) ULONG SET_VIRTUAL_DEVICE_DATA ( _Inout_ PVOID Context, _In_ USHORT VirtualFunction, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Offset, _In_ ULONG Length ); typedef SET_VIRTUAL_DEVICE_DATA *PSET_VIRTUAL_DEVICE_DATA; typedef _Function_class_(GET_VIRTUAL_DEVICE_LOCATION) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS GET_VIRTUAL_DEVICE_LOCATION ( _Inout_ PVOID Context, _In_ USHORT VirtualFunction, _Out_ PUINT16 SegmentNumber, _Out_ PUINT8 BusNumber, _Out_ PUINT8 FunctionNumber ); typedef GET_VIRTUAL_DEVICE_LOCATION *PGET_VIRTUAL_DEVICE_LOCATION; typedef _Function_class_(GET_VIRTUAL_DEVICE_RESOURCES) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) VOID GET_VIRTUAL_DEVICE_RESOURCES ( _Inout_ PVOID Context, _Out_ PUINT8 CapturedBusNumbers ); typedef GET_VIRTUAL_DEVICE_RESOURCES *PGET_VIRTUAL_DEVICE_RESOURCES; typedef _Function_class_(ENABLE_VIRTUALIZATION) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS ENABLE_VIRTUALIZATION ( _Inout_ PVOID Context, _In_ UINT16 NumVFs, _In_ BOOLEAN EnableVfMigration, _In_ BOOLEAN EnableMigrationInterrupt, _In_ BOOLEAN EnableVirtualization ); typedef ENABLE_VIRTUALIZATION *PENABLE_VIRTUALIZATION; typedef _Function_class_(GET_VIRTUAL_FUNCTION_PROBED_BARS) _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS GET_VIRTUAL_FUNCTION_PROBED_BARS( _Inout_ PVOID Context, _Out_writes_(6) PULONG BaseRegisterValues ) ; typedef GET_VIRTUAL_FUNCTION_PROBED_BARS *PGET_VIRTUAL_FUNCTION_PROBED_BARS; typedef struct _PCI_VIRTUALIZATION_INTERFACE { // // generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // virtualization interfaces // PSET_VIRTUAL_DEVICE_DATA SetVirtualFunctionData; PGET_VIRTUAL_DEVICE_DATA GetVirtualFunctionData; PGET_VIRTUAL_DEVICE_LOCATION GetLocation; PGET_VIRTUAL_DEVICE_RESOURCES GetResources; PENABLE_VIRTUALIZATION EnableVirtualization; PGET_VIRTUAL_FUNCTION_PROBED_BARS GetVirtualFunctionProbedBars; } PCI_VIRTUALIZATION_INTERFACE, *PPCI_VIRTUALIZATION_INTERFACE; // // PCI Security Interface - 6e7f1451-199e-4acc-ba2d-762b4edf4674 // #define PCI_SECURITY_INTERFACE_VERSION 1 typedef enum _PCI_ACS_BIT { PciAcsReserved = 0, PciAcsBitEnable, PciAcsBitDisable, PciAcsBitDontCare } PCI_ACS_BIT, *PPCI_ACS_BIT; typedef _Function_class_(PCI_SET_ACS) _IRQL_requires_same_ _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS PCI_SET_ACS ( _Inout_ PVOID Context, _In_ PCI_ACS_BIT EnableSourceValidation, _In_ PCI_ACS_BIT EnableTranslationBlocking, _In_ PCI_ACS_BIT EnableP2PRequestRedirect, _In_ PCI_ACS_BIT EnableCompletionRedirect, _In_ PCI_ACS_BIT EnableUpstreamForwarding, _In_ PCI_ACS_BIT EnableEgressControl, _In_ PCI_ACS_BIT EnableDirectTranslatedP2P ); typedef PCI_SET_ACS *PPCI_SET_ACS; typedef struct _PCI_SECURITY_INTERFACE { // // generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; PPCI_SET_ACS SetAccessControlServices; } PCI_SECURITY_INTERFACE, *PPCI_SECURITY_INTERFACE; typedef VOID (*PREENUMERATE_SELF)( _In_ PVOID Context ); typedef struct _REENUMERATE_SELF_INTERFACE_STANDARD { // // generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // Self-reenumeration interface // PREENUMERATE_SELF SurpriseRemoveAndReenumerateSelf; } REENUMERATE_SELF_INTERFACE_STANDARD, *PREENUMERATE_SELF_INTERFACE_STANDARD; // // D3Cold Support Interface // #define D3COLD_SUPPORT_INTERFACE_VERSION 1 typedef _Function_class_(SET_D3COLD_SUPPORT) _IRQL_requires_(PASSIVE_LEVEL) VOID SET_D3COLD_SUPPORT ( _In_reads_opt_(_Inexpressible_("varies")) PVOID Context, _In_ BOOLEAN D3ColdSupport ); typedef SET_D3COLD_SUPPORT *PSET_D3COLD_SUPPORT; typedef enum _DEVICE_WAKE_DEPTH { DeviceWakeDepthNotWakeable = 0, DeviceWakeDepthD0, DeviceWakeDepthD1, DeviceWakeDepthD2, DeviceWakeDepthD3hot, DeviceWakeDepthD3cold, DeviceWakeDepthMaximum } DEVICE_WAKE_DEPTH, *PDEVICE_WAKE_DEPTH; FORCEINLINE DEVICE_POWER_STATE MapWakeDepthToDstate( _In_ DEVICE_WAKE_DEPTH WakeDepth ) { const DEVICE_POWER_STATE dstateMap[DeviceWakeDepthMaximum] = { PowerDeviceD0, PowerDeviceD0, PowerDeviceD1, PowerDeviceD2, PowerDeviceD3, PowerDeviceD3 }; if (WakeDepth < 0 || WakeDepth >= DeviceWakeDepthMaximum) { return PowerDeviceUnspecified; } else { return dstateMap[WakeDepth]; } } typedef _Function_class_(GET_IDLE_WAKE_INFO) _IRQL_requires_(PASSIVE_LEVEL) NTSTATUS GET_IDLE_WAKE_INFO ( _In_reads_opt_(_Inexpressible_("varies")) PVOID Context, _In_ SYSTEM_POWER_STATE SystemPowerState, _Out_ PDEVICE_WAKE_DEPTH DeepestWakeableDstate ); typedef GET_IDLE_WAKE_INFO *PGET_IDLE_WAKE_INFO; typedef _Function_class_(GET_D3COLD_CAPABILITY) _IRQL_requires_(PASSIVE_LEVEL) NTSTATUS GET_D3COLD_CAPABILITY ( _In_reads_opt_(_Inexpressible_("varies")) PVOID Context, _Out_ PBOOLEAN D3ColdSupported ); typedef GET_D3COLD_CAPABILITY *PGET_D3COLD_CAPABILITY; typedef enum _D3COLD_LAST_TRANSITION_STATUS { LastDStateTransitionStatusUnknown = 0, LastDStateTransitionD3hot, LastDStateTransitionD3cold } D3COLD_LAST_TRANSITION_STATUS, *PD3COLD_LAST_TRANSITION_STATUS; typedef _Function_class_(GET_D3COLD_LAST_TRANSITION_STATUS) _IRQL_requires_max_(DISPATCH_LEVEL) VOID GET_D3COLD_LAST_TRANSITION_STATUS ( _In_reads_opt_(_Inexpressible_("varies")) PVOID Context, _Out_ PD3COLD_LAST_TRANSITION_STATUS LastTransitionStatus ); typedef GET_D3COLD_LAST_TRANSITION_STATUS *PGET_D3COLD_LAST_TRANSITION_STATUS; typedef struct _D3COLD_SUPPORT_INTERFACE { USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; PSET_D3COLD_SUPPORT SetD3ColdSupport; PGET_IDLE_WAKE_INFO GetIdleWakeInfo; PGET_D3COLD_CAPABILITY GetD3ColdCapability; PGET_D3COLD_CAPABILITY GetBusDriverD3ColdSupport; PGET_D3COLD_LAST_TRANSITION_STATUS GetLastTransitionStatus; } D3COLD_SUPPORT_INTERFACE, *PD3COLD_SUPPORT_INTERFACE; // // The following definitions are used in ACPI QueryInterface // typedef BOOLEAN (* PGPE_SERVICE_ROUTINE) ( PVOID, PVOID); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (* PGPE_CONNECT_VECTOR) ( PDEVICE_OBJECT, ULONG, KINTERRUPT_MODE, BOOLEAN, PGPE_SERVICE_ROUTINE, PVOID, PVOID); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (* PGPE_DISCONNECT_VECTOR) ( PVOID); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (* PGPE_ENABLE_EVENT) ( PDEVICE_OBJECT, PVOID); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (* PGPE_DISABLE_EVENT) ( PDEVICE_OBJECT, PVOID); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (* PGPE_CLEAR_STATUS) ( PDEVICE_OBJECT, PVOID); typedef VOID (* PDEVICE_NOTIFY_CALLBACK) ( PVOID, ULONG); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (* PREGISTER_FOR_DEVICE_NOTIFICATIONS) ( PDEVICE_OBJECT, PDEVICE_NOTIFY_CALLBACK, PVOID); typedef _IRQL_requires_max_(DISPATCH_LEVEL) void (* PUNREGISTER_FOR_DEVICE_NOTIFICATIONS) ( PDEVICE_OBJECT, PDEVICE_NOTIFY_CALLBACK); typedef struct _ACPI_INTERFACE_STANDARD { // // Generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // ACPI interfaces // PGPE_CONNECT_VECTOR GpeConnectVector; PGPE_DISCONNECT_VECTOR GpeDisconnectVector; PGPE_ENABLE_EVENT GpeEnableEvent; PGPE_DISABLE_EVENT GpeDisableEvent; PGPE_CLEAR_STATUS GpeClearStatus; PREGISTER_FOR_DEVICE_NOTIFICATIONS RegisterForDeviceNotifications; PUNREGISTER_FOR_DEVICE_NOTIFICATIONS UnregisterForDeviceNotifications; } ACPI_INTERFACE_STANDARD, *PACPI_INTERFACE_STANDARD; // // The following definitions are used in GUID_ACPI_INTERFACE_STANDARD2, // The first version (above) passes in DEVICE_OBJECs, where this one // is based on Contexts. // typedef BOOLEAN (*PGPE_SERVICE_ROUTINE2) ( PVOID ObjectContext, PVOID ServiceContext ); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (*PGPE_CONNECT_VECTOR2) ( PVOID Context, ULONG GpeNumber, KINTERRUPT_MODE Mode, BOOLEAN Shareable, PGPE_SERVICE_ROUTINE ServiceRoutine, PVOID ServiceContext, PVOID *ObjectContext ); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (*PGPE_DISCONNECT_VECTOR2) ( PVOID Context, PVOID ObjectContext ); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (*PGPE_ENABLE_EVENT2) ( PVOID Context, PVOID ObjectContext ); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (*PGPE_DISABLE_EVENT2) ( PVOID Context, PVOID ObjectContext ); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (*PGPE_CLEAR_STATUS2) ( PVOID Context, PVOID ObjectContext ); typedef _IRQL_requires_max_(PASSIVE_LEVEL) VOID (*PDEVICE_NOTIFY_CALLBACK2) ( PVOID NotificationContext, ULONG NotifyCode ); typedef _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTSTATUS (*PREGISTER_FOR_DEVICE_NOTIFICATIONS2) ( PVOID Context, PDEVICE_NOTIFY_CALLBACK2 NotificationHandler, PVOID NotificationContext ); typedef _IRQL_requires_max_(DISPATCH_LEVEL) VOID (*PUNREGISTER_FOR_DEVICE_NOTIFICATIONS2) ( PVOID Context ); typedef struct { // // Generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // ACPI interfaces // PGPE_CONNECT_VECTOR2 GpeConnectVector; PGPE_DISCONNECT_VECTOR2 GpeDisconnectVector; PGPE_ENABLE_EVENT2 GpeEnableEvent; PGPE_DISABLE_EVENT2 GpeDisableEvent; PGPE_CLEAR_STATUS2 GpeClearStatus; PREGISTER_FOR_DEVICE_NOTIFICATIONS2 RegisterForDeviceNotifications; PUNREGISTER_FOR_DEVICE_NOTIFICATIONS2 UnregisterForDeviceNotifications; } ACPI_INTERFACE_STANDARD2, *PACPI_INTERFACE_STANDARD2; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoInvalidateDeviceRelations( _In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_RELATION_TYPE Type ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoRequestDeviceEject( _In_ PDEVICE_OBJECT PhysicalDeviceObject ); #endif typedef VOID (*PIO_DEVICE_EJECT_CALLBACK)( _In_ NTSTATUS Status, _Inout_opt_ PVOID Context ); #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoRequestDeviceEjectEx( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_opt_ PIO_DEVICE_EJECT_CALLBACK Callback, _In_opt_ PVOID Context, _In_opt_ PDRIVER_OBJECT DriverObject ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _When_((DeviceProperty & __string_type), _At_(PropertyBuffer, _Post_z_) ) _When_((DeviceProperty & __multiString_type), _At_(PropertyBuffer, _Post_ _NullNull_terminated_) ) NTKERNELAPI NTSTATUS IoGetDeviceProperty( _In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_writes_bytes_opt_(BufferLength) PVOID PropertyBuffer, _Out_ _Deref_out_range_(<=, BufferLength) PULONG ResultLength ); #endif // // The following definitions are used in IoOpenDeviceRegistryKey // #define PLUGPLAY_REGKEY_DEVICE 1 #define PLUGPLAY_REGKEY_DRIVER 2 #define PLUGPLAY_REGKEY_CURRENT_HWPROFILE 4 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoOpenDeviceRegistryKey( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG DevInstKeyType, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE DevInstRegKey ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoRegisterDeviceInterface( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ CONST GUID *InterfaceClassGuid, _In_opt_ PUNICODE_STRING ReferenceString, _Out_ _When_(return==0, _At_(SymbolicLinkName->Buffer, __drv_allocatesMem(Mem))) PUNICODE_STRING SymbolicLinkName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoOpenDeviceInterfaceRegistryKey( _In_ PUNICODE_STRING SymbolicLinkName, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE DeviceInterfaceKey ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoSetDeviceInterfaceState( _In_ PUNICODE_STRING SymbolicLinkName, _In_ BOOLEAN Enable ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoGetDeviceInterfaces( _In_ CONST GUID *InterfaceClassGuid, _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ ULONG Flags, _Outptr_result_nullonfailure_ _At_(*SymbolicLinkList, _When_(return==0, __drv_allocatesMem(Mem))) PZZWSTR *SymbolicLinkList ); #endif #define DEVICE_INTERFACE_INCLUDE_NONACTIVE 0x00000001 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoGetDeviceInterfaceAlias( _In_ PUNICODE_STRING SymbolicLinkName, _In_ CONST GUID *AliasInterfaceClassGuid, _Out_ _When_(return==0, _At_(AliasSymbolicLinkName->Buffer, __drv_allocatesMem(Mem))) PUNICODE_STRING AliasSymbolicLinkName ); #endif // // Define PnP notification event categories // typedef enum _IO_NOTIFICATION_EVENT_CATEGORY { EventCategoryReserved, EventCategoryHardwareProfileChange, EventCategoryDeviceInterfaceChange, EventCategoryTargetDeviceChange } IO_NOTIFICATION_EVENT_CATEGORY; // // Define flags that modify the behavior of IoRegisterPlugPlayNotification // for the various event categories... // #define PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES 0x00000001 typedef _Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE) _IRQL_requires_max_(PASSIVE_LEVEL) NTSTATUS DRIVER_NOTIFICATION_CALLBACK_ROUTINE ( _In_ PVOID NotificationStructure, _Inout_opt_ PVOID Context ); typedef DRIVER_NOTIFICATION_CALLBACK_ROUTINE *PDRIVER_NOTIFICATION_CALLBACK_ROUTINE; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoRegisterPlugPlayNotification( _In_ IO_NOTIFICATION_EVENT_CATEGORY EventCategory, _In_ ULONG EventCategoryFlags, _In_opt_ PVOID EventCategoryData, _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_NOTIFICATION_CALLBACK_ROUTINE CallbackRoutine, _Inout_opt_ __drv_aliasesMem PVOID Context, _Outptr_result_nullonfailure_ _At_(*NotificationEntry, _When_(return==0, __drv_allocatesMem(Mem))) PVOID *NotificationEntry ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoUnregisterPlugPlayNotification( _In_ __drv_freesMem(Pool) PVOID NotificationEntry ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoUnregisterPlugPlayNotificationEx( _In_ __drv_freesMem(Pool) PVOID NotificationEntry ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS IoReportTargetDeviceChange( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ PVOID NotificationStructure // always begins with a PLUGPLAY_NOTIFICATION_HEADER ); #endif typedef _Function_class_(DEVICE_CHANGE_COMPLETE_CALLBACK) _IRQL_requires_same_ VOID DEVICE_CHANGE_COMPLETE_CALLBACK( _Inout_opt_ PVOID Context ); typedef DEVICE_CHANGE_COMPLETE_CALLBACK *PDEVICE_CHANGE_COMPLETE_CALLBACK; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID IoInvalidateDeviceState( _In_ PDEVICE_OBJECT PhysicalDeviceObject ); #endif #define IoAdjustPagingPathCount(_count_,_paging_) { \ if (_paging_) { \ InterlockedIncrement(_count_); \ } else { \ InterlockedDecrement(_count_); \ } \ } #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS IoReportTargetDeviceChangeAsynchronous( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ PVOID NotificationStructure, // always begins with a PLUGPLAY_NOTIFICATION_HEADER _In_opt_ PDEVICE_CHANGE_COMPLETE_CALLBACK Callback, _In_opt_ PVOID Context ); #endif // // Header structure for all Plug&Play notification events... // typedef struct _PLUGPLAY_NOTIFICATION_HEADER { USHORT Version; // presently at version 1. USHORT Size; // size (in bytes) of header + event-specific data. GUID Event; // // Event-specific stuff starts here. // } PLUGPLAY_NOTIFICATION_HEADER, *PPLUGPLAY_NOTIFICATION_HEADER; // // Notification structure for all EventCategoryHardwareProfileChange events... // typedef struct _HWPROFILE_CHANGE_NOTIFICATION { USHORT Version; USHORT Size; GUID Event; // // (No event-specific data) // } HWPROFILE_CHANGE_NOTIFICATION, *PHWPROFILE_CHANGE_NOTIFICATION; // // Notification structure for all EventCategoryDeviceInterfaceChange events... // typedef struct _DEVICE_INTERFACE_CHANGE_NOTIFICATION { USHORT Version; USHORT Size; GUID Event; // // Event-specific data // GUID InterfaceClassGuid; PUNICODE_STRING SymbolicLinkName; } DEVICE_INTERFACE_CHANGE_NOTIFICATION, *PDEVICE_INTERFACE_CHANGE_NOTIFICATION; // // Notification structures for EventCategoryTargetDeviceChange... // // // The following structure is used for TargetDeviceQueryRemove, // TargetDeviceRemoveCancelled, and TargetDeviceRemoveComplete: // typedef struct _TARGET_DEVICE_REMOVAL_NOTIFICATION { USHORT Version; USHORT Size; GUID Event; // // Event-specific data // PFILE_OBJECT FileObject; } TARGET_DEVICE_REMOVAL_NOTIFICATION, *PTARGET_DEVICE_REMOVAL_NOTIFICATION; // // The following structure header is used for all other (i.e., 3rd-party) // target device change events. The structure accommodates both a // variable-length binary data buffer, and a variable-length unicode text // buffer. The header must indicate where the text buffer begins, so that // the data can be delivered in the appropriate format (ANSI or Unicode) // to user-mode recipients (i.e., that have registered for handle-based // notification via RegisterDeviceNotification). // typedef struct _TARGET_DEVICE_CUSTOM_NOTIFICATION { USHORT Version; USHORT Size; GUID Event; // // Event-specific data // PFILE_OBJECT FileObject; // This field must be set to NULL by callers of // IoReportTargetDeviceChange. Clients that // have registered for target device change // notification on the affected PDO will be // called with this field set to the file object // they specified during registration. // LONG NameBufferOffset; // offset (in bytes) from beginning of // CustomDataBuffer where text begins (-1 if none) // UCHAR CustomDataBuffer[1]; // variable-length buffer, containing (optionally) // a binary data at the start of the buffer, // followed by an optional unicode text buffer // (word-aligned). // } TARGET_DEVICE_CUSTOM_NOTIFICATION, *PTARGET_DEVICE_CUSTOM_NOTIFICATION; #if (NTDDI_VERSION >= NTDDI_VISTA) // // Custom device properties... // #include // // Definitions of property flags. // #define PLUGPLAY_PROPERTY_PERSISTENT 0x00000001 #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoSetDevicePropertyData ( _In_ PDEVICE_OBJECT Pdo, _In_ CONST DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _In_ ULONG Flags, _In_ DEVPROPTYPE Type, _In_ ULONG Size, _In_reads_bytes_opt_(Size) PVOID Data ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoGetDevicePropertyData ( _In_ PDEVICE_OBJECT Pdo, _In_ CONST DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _Reserved_ ULONG Flags, _In_ ULONG Size, _Out_writes_bytes_to_(Size, *RequiredSize) PVOID Data, _Out_ PULONG RequiredSize, _Out_ PDEVPROPTYPE Type ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoSetDeviceInterfacePropertyData ( _In_ PUNICODE_STRING SymbolicLinkName, _In_ CONST DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _In_ ULONG Flags, _In_ DEVPROPTYPE Type, _In_ ULONG Size, _In_reads_bytes_opt_(Size) PVOID Data ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoGetDeviceInterfacePropertyData ( _In_ PUNICODE_STRING SymbolicLinkName, _In_ CONST DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _Reserved_ ULONG Flags, _In_ ULONG Size, _Out_writes_bytes_to_(Size, *RequiredSize) PVOID Data, _Out_ PULONG RequiredSize, _Out_ PDEVPROPTYPE Type ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS IoGetDeviceNumaNode ( _In_ PDEVICE_OBJECT Pdo, _Out_ PUSHORT NodeNumber ); #endif #if (NTDDI_VERSION >= NTDDI_WS08) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoReplacePartitionUnit ( _In_ PDEVICE_OBJECT TargetPdo, _In_ PDEVICE_OBJECT SparePdo, _In_ ULONG Flags ); #endif // // Define replace driver entrypoint. // typedef struct _PNP_REPLACE_DRIVER_INTERFACE *PPNP_REPLACE_DRIVER_INTERFACE; typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_DRIVER_INIT) ( _Inout_ PPNP_REPLACE_DRIVER_INTERFACE Interface, _In_ PVOID Unused ); // // Define parameters to replace driver. // #define PNP_REPLACE_NO_MAP MAXLONGLONG typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_MAP_MEMORY) ( _In_ PHYSICAL_ADDRESS TargetPhysicalAddress, _In_ PHYSICAL_ADDRESS SparePhysicalAddress, _Inout_ PLARGE_INTEGER NumberOfBytes, _Outptr_ PVOID *TargetAddress, _Outptr_ PVOID *SpareAddress ); typedef struct _PNP_REPLACE_MEMORY_LIST { ULONG AllocatedCount; ULONG Count; ULONGLONG TotalLength; struct { PHYSICAL_ADDRESS Address; ULONGLONG Length; } Ranges[ANYSIZE_ARRAY]; } PNP_REPLACE_MEMORY_LIST, *PPNP_REPLACE_MEMORY_LIST; typedef struct _PNP_REPLACE_PROCESSOR_LIST { PKAFFINITY Affinity; ULONG GroupCount; ULONG AllocatedCount; ULONG Count; ULONG ApicIds[ANYSIZE_ARRAY]; } PNP_REPLACE_PROCESSOR_LIST, *PPNP_REPLACE_PROCESSOR_LIST; typedef struct _PNP_REPLACE_PROCESSOR_LIST_V1 { KAFFINITY AffinityMask; ULONG AllocatedCount; ULONG Count; ULONG ApicIds[ANYSIZE_ARRAY]; } PNP_REPLACE_PROCESSOR_LIST_V1, *PPNP_REPLACE_PROCESSOR_LIST_V1; #define PNP_REPLACE_PARAMETERS_VERSION 2 typedef struct _PNP_REPLACE_PARAMETERS { ULONG Size; ULONG Version; ULONG64 Target; ULONG64 Spare; PPNP_REPLACE_PROCESSOR_LIST TargetProcessors; PPNP_REPLACE_PROCESSOR_LIST SpareProcessors; PPNP_REPLACE_MEMORY_LIST TargetMemory; PPNP_REPLACE_MEMORY_LIST SpareMemory; PREPLACE_MAP_MEMORY MapMemory; } PNP_REPLACE_PARAMETERS, *PPNP_REPLACE_PARAMETERS; // // Define replace driver interface. // typedef VOID (*PREPLACE_UNLOAD) ( VOID ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_BEGIN) ( _In_ PPNP_REPLACE_PARAMETERS Parameters, _Outptr_ PVOID *Context ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_END) ( _In_ PVOID Context ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_MIRROR_PHYSICAL_MEMORY) ( _In_ PVOID Context, _In_ PHYSICAL_ADDRESS PhysicalAddress, _In_ LARGE_INTEGER ByteCount ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_SET_PROCESSOR_ID) ( _In_ PVOID Context, _In_ ULONG ApicId, _In_ BOOLEAN Target ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_SWAP) ( _In_ PVOID Context ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_INITIATE_HARDWARE_MIRROR) ( _In_ PVOID Context ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_MIRROR_PLATFORM_MEMORY) ( _In_ PVOID Context ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_GET_MEMORY_DESTINATION) ( _In_ PVOID Context, _In_ PHYSICAL_ADDRESS SourceAddress, _Out_ PPHYSICAL_ADDRESS DestinationAddress ); typedef _Must_inspect_result_ NTSTATUS (*PREPLACE_ENABLE_DISABLE_HARDWARE_QUIESCE) ( _In_ PVOID Context, _In_ BOOLEAN Enable ); #define PNP_REPLACE_DRIVER_INTERFACE_VERSION 1 #define PNP_REPLACE_DRIVER_INTERFACE_MINIMUM_SIZE \ UFIELD_OFFSET(PNP_REPLACE_DRIVER_INTERFACE, InitiateHardwareMirror) #define PNP_REPLACE_MEMORY_SUPPORTED 0x0001 #define PNP_REPLACE_PROCESSOR_SUPPORTED 0x0002 #define PNP_REPLACE_HARDWARE_MEMORY_MIRRORING 0x0004 #define PNP_REPLACE_HARDWARE_PAGE_COPY 0x0008 #define PNP_REPLACE_HARDWARE_QUIESCE 0x0010 // // Define interface structure. // typedef struct _PNP_REPLACE_DRIVER_INTERFACE { ULONG Size; ULONG Version; ULONG Flags; PREPLACE_UNLOAD Unload; PREPLACE_BEGIN BeginReplace; PREPLACE_END EndReplace; PREPLACE_MIRROR_PHYSICAL_MEMORY MirrorPhysicalMemory; PREPLACE_SET_PROCESSOR_ID SetProcessorId; PREPLACE_SWAP Swap; PREPLACE_INITIATE_HARDWARE_MIRROR InitiateHardwareMirror; PREPLACE_MIRROR_PLATFORM_MEMORY MirrorPlatformMemory; PREPLACE_GET_MEMORY_DESTINATION GetMemoryDestination; PREPLACE_ENABLE_DISABLE_HARDWARE_QUIESCE EnableDisableHardwareQuiesce; } PNP_REPLACE_DRIVER_INTERFACE, *PPNP_REPLACE_DRIVER_INTERFACE; #if (NTDDI_VERSION >= NTDDI_WINBLUE) // // Define crashdump runtime power interface. // typedef NTSTATUS (*PCRASHDUMP_POWER_ON)( _In_opt_ PVOID Context ); typedef struct _CRASHDUMP_FUNCTIONS_INTERFACE { // // generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // Power-on at crashdump time method // PCRASHDUMP_POWER_ON PowerOn; } CRASHDUMP_FUNCTIONS_INTERFACE, *PCRASHDUMP_FUNCTIONS_INTERFACE; #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) #define DEVICE_RESET_INTERFACE_VERSION 1 #define DEVICE_RESET_IGNORE_OPEN_HANDLES 0x1 // // Define an enum for various reset types supported. // // Note reset type value should not exceed 31 as the "SupportedResetTypes" // field within the reset interface is a ULONG. // typedef enum _DEVICE_RESET_TYPE { FunctionLevelDeviceReset, PlatformLevelDeviceReset } DEVICE_RESET_TYPE; typedef VOID (DEVICE_RESET_COMPLETION)( _In_ NTSTATUS Status, _Inout_opt_ PVOID Context ); typedef DEVICE_RESET_COMPLETION *PDEVICE_RESET_COMPLETION; typedef struct _FUNCTION_LEVEL_DEVICE_RESET_PARAMETERS { ULONG Size; PDEVICE_RESET_COMPLETION DeviceResetCompletion; PVOID CompletionContext; } FUNCTION_LEVEL_DEVICE_RESET_PARAMETERS, *PFUNCTION_LEVEL_DEVICE_RESET_PARAMETERS; typedef NTSTATUS (*PDEVICE_RESET_HANDLER)( _In_ PVOID InterfaceContext, _In_ DEVICE_RESET_TYPE ResetType, _In_ ULONG Flags, _In_opt_ PVOID ResetParameters ); typedef struct _DEVICE_RESET_INTERFACE_STANDARD { // // generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // device reset interface // PDEVICE_RESET_HANDLER DeviceReset; ULONG SupportedResetTypes; PVOID Reserved; } DEVICE_RESET_INTERFACE_STANDARD, *PDEVICE_RESET_INTERFACE_STANDARD; #endif // // Define the device description structure. // typedef struct _DEVICE_DESCRIPTION { ULONG Version; BOOLEAN Master; BOOLEAN ScatterGather; BOOLEAN DemandMode; BOOLEAN AutoInitialize; BOOLEAN Dma32BitAddresses; BOOLEAN IgnoreCount; BOOLEAN Reserved1; // must be false BOOLEAN Dma64BitAddresses; ULONG BusNumber; // unused for WDM ULONG DmaChannel; INTERFACE_TYPE InterfaceType; DMA_WIDTH DmaWidth; DMA_SPEED DmaSpeed; ULONG MaximumLength; ULONG DmaPort; #if (NTDDI_VERSION >= NTDDI_WIN8) ULONG DmaAddressWidth; ULONG DmaControllerInstance; ULONG DmaRequestLine; PHYSICAL_ADDRESS DeviceAddress; #endif /* NTDDI_VERSION >= NTDDI_WIN8 */ } DEVICE_DESCRIPTION, *PDEVICE_DESCRIPTION; // // Define the supported version numbers for the device description structure. // #define DEVICE_DESCRIPTION_VERSION 0 #define DEVICE_DESCRIPTION_VERSION1 1 #define DEVICE_DESCRIPTION_VERSION2 2 #define DEVICE_DESCRIPTION_VERSION3 3 // // Define the supported version numbers for DMA adapter info and the // DMA transfer info structure. // #define DMA_ADAPTER_INFO_VERSION1 1 #define DMA_TRANSFER_INFO_VERSION1 1 typedef struct _DMA_ADAPTER_INFO_V1 { ULONG ReadDmaCounterAvailable; ULONG ScatterGatherLimit; ULONG DmaAddressWidth; ULONG Flags; ULONG MinimumTransferUnit; } DMA_ADAPTER_INFO_V1, *PDMA_ADAPTER_INFO_V1; typedef struct _DMA_ADAPTER_INFO { ULONG Version; union { DMA_ADAPTER_INFO_V1 V1; }; } DMA_ADAPTER_INFO, *PDMA_ADAPTER_INFO; // // Define the bits in the adapter info flags. // #define ADAPTER_INFO_SYNCHRONOUS_CALLBACK 0x0001 #define ADAPTER_INFO_API_BYPASS 0x0002 typedef struct _DMA_TRANSFER_INFO_V1 { ULONG MapRegisterCount; ULONG ScatterGatherElementCount; ULONG ScatterGatherListSize; } DMA_TRANSFER_INFO_V1, *PDMA_TRANSFER_INFO_V1; typedef struct _DMA_TRANSFER_INFO { ULONG Version; union { DMA_TRANSFER_INFO_V1 V1; }; } DMA_TRANSFER_INFO, *PDMA_TRANSFER_INFO; // // Define the supported version numbers and the corresponding sizes of opaque // DMA transfer context structure. // #define DMA_TRANSFER_CONTEXT_VERSION1 1 #if defined (_WIN64) #define DMA_TRANSFER_CONTEXT_SIZE_V1 128 #else #define DMA_TRANSFER_CONTEXT_SIZE_V1 64 #endif // // Define the flags used in AllocateAdapterChannelEx, GetScatterGatherListEx, // and BuildScatterGatherListEx. // #define DMA_SYNCHRONOUS_CALLBACK 0x01 #define DMA_ZERO_BUFFERS 0x02 NTHALAPI VOID KeFlushWriteBuffer ( VOID ); // // Performance counter function. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTHALAPI LARGE_INTEGER KeQueryPerformanceCounter ( _Out_opt_ PLARGE_INTEGER PerformanceFrequency ); #endif // // Stall processor execution function. // #if (NTDDI_VERSION >= NTDDI_WIN2K) NTHALAPI VOID KeStallExecutionProcessor ( _In_ ULONG MicroSeconds ); #endif #define HAL_MASK_UNMASK_FLAGS_NONE (0x0) #define HAL_MASK_UNMASK_FLAGS_SERVICING_DEFERRED (0x1) #define HAL_MASK_UNMASK_FLAGS_SERVICING_COMPLETE (0x2) // // Processor driver halt routine. // typedef NTSTATUS PROCESSOR_HALT_ROUTINE ( _Inout_opt_ PVOID Context ); typedef PROCESSOR_HALT_ROUTINE *PPROCESSOR_HALT_ROUTINE; typedef struct _SCATTER_GATHER_ELEMENT { PHYSICAL_ADDRESS Address; ULONG Length; ULONG_PTR Reserved; } SCATTER_GATHER_ELEMENT, *PSCATTER_GATHER_ELEMENT; #if defined(_MSC_EXTENSIONS) #if _MSC_VER >= 1200 #pragma warning(push) #endif #pragma warning(disable:4200) typedef struct _SCATTER_GATHER_LIST { ULONG NumberOfElements; ULONG_PTR Reserved; SCATTER_GATHER_ELEMENT Elements[]; } SCATTER_GATHER_LIST, *PSCATTER_GATHER_LIST; #if _MSC_VER >= 1200 #pragma warning(pop) #else #pragma warning(default:4200) #endif #else struct _SCATTER_GATHER_LIST; typedef struct _SCATTER_GATHER_LIST SCATTER_GATHER_LIST, *PSCATTER_GATHER_LIST; #endif typedef struct _DMA_OPERATIONS *PDMA_OPERATIONS; #define HAL_DMA_ADAPTER_VERSION_1 1 typedef struct _DMA_ADAPTER { USHORT Version; USHORT Size; PDMA_OPERATIONS DmaOperations; // Private Bus Device Driver data follows, } DMA_ADAPTER, *PDMA_ADAPTER; typedef enum { DmaComplete, DmaAborted, DmaError, DmaCancelled } DMA_COMPLETION_STATUS; typedef VOID (*PPUT_DMA_ADAPTER)( PDMA_ADAPTER DmaAdapter ); typedef PVOID (*PALLOCATE_COMMON_BUFFER)( _In_ PDMA_ADAPTER DmaAdapter, _In_ ULONG Length, _Out_ PPHYSICAL_ADDRESS LogicalAddress, _In_ BOOLEAN CacheEnabled ); typedef VOID (*PFREE_COMMON_BUFFER)( _In_ PDMA_ADAPTER DmaAdapter, _In_ ULONG Length, _In_ PHYSICAL_ADDRESS LogicalAddress, _In_ PVOID VirtualAddress, _In_ BOOLEAN CacheEnabled ); typedef NTSTATUS (*PALLOCATE_ADAPTER_CHANNEL)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG NumberOfMapRegisters, _In_ PDRIVER_CONTROL ExecutionRoutine, _In_ PVOID Context ); typedef BOOLEAN (*PFLUSH_ADAPTER_BUFFERS)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ PVOID CurrentVa, _In_ ULONG Length, _In_ BOOLEAN WriteToDevice ); typedef VOID (*PFREE_ADAPTER_CHANNEL)( _In_ PDMA_ADAPTER DmaAdapter ); typedef VOID (*PFREE_ADAPTER_OBJECT)( _In_ PDMA_ADAPTER DmaAdapter, _In_ IO_ALLOCATION_ACTION AllocationAction ); typedef VOID (*PFREE_MAP_REGISTERS)( _In_ PDMA_ADAPTER DmaAdapter, PVOID MapRegisterBase, ULONG NumberOfMapRegisters ); typedef PHYSICAL_ADDRESS (*PMAP_TRANSFER)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ PVOID CurrentVa, _Inout_ PULONG Length, _In_ BOOLEAN WriteToDevice ); typedef ULONG (*PGET_DMA_ALIGNMENT)( _In_ PDMA_ADAPTER DmaAdapter ); typedef ULONG (*PREAD_DMA_COUNTER)( _In_ PDMA_ADAPTER DmaAdapter ); typedef _Function_class_(DRIVER_LIST_CONTROL) _IRQL_requires_same_ VOID DRIVER_LIST_CONTROL( _In_ struct _DEVICE_OBJECT *DeviceObject, _In_ struct _IRP *Irp, _In_ PSCATTER_GATHER_LIST ScatterGather, _In_ PVOID Context ); typedef DRIVER_LIST_CONTROL *PDRIVER_LIST_CONTROL; typedef NTSTATUS (*PGET_SCATTER_GATHER_LIST)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ PMDL Mdl, _In_ PVOID CurrentVa, _In_ ULONG Length, _In_ PDRIVER_LIST_CONTROL ExecutionRoutine, _In_ PVOID Context, _In_ BOOLEAN WriteToDevice ); typedef VOID (*PPUT_SCATTER_GATHER_LIST)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PSCATTER_GATHER_LIST ScatterGather, _In_ BOOLEAN WriteToDevice ); typedef NTSTATUS (*PCALCULATE_SCATTER_GATHER_LIST_SIZE)( _In_ PDMA_ADAPTER DmaAdapter, _In_ OPTIONAL PMDL Mdl, _In_ PVOID CurrentVa, _In_ ULONG Length, _Out_ PULONG ScatterGatherListSize, _Out_ OPTIONAL PULONG pNumberOfMapRegisters ); typedef NTSTATUS (*PBUILD_SCATTER_GATHER_LIST)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ PMDL Mdl, _In_ PVOID CurrentVa, _In_ ULONG Length, _In_ PDRIVER_LIST_CONTROL ExecutionRoutine, _In_ PVOID Context, _In_ BOOLEAN WriteToDevice, _In_ PVOID ScatterGatherBuffer, _In_ ULONG ScatterGatherLength ); typedef NTSTATUS (*PBUILD_MDL_FROM_SCATTER_GATHER_LIST)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PSCATTER_GATHER_LIST ScatterGather, _In_ PMDL OriginalMdl, _Out_ PMDL *TargetMdl ); typedef NTSTATUS (*PGET_DMA_ADAPTER_INFO)( _In_ PDMA_ADAPTER DmaAdapter, _Inout_ PDMA_ADAPTER_INFO AdapterInfo ); typedef NTSTATUS (*PGET_DMA_TRANSFER_INFO)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ ULONGLONG Offset, _In_ ULONG Length, _In_ BOOLEAN WriteOnly, _Inout_ PDMA_TRANSFER_INFO TransferInfo ); typedef NTSTATUS (*PCONFIGURE_ADAPTER_CHANNEL)( _In_ PDMA_ADAPTER DmaAdapter, _In_ ULONG FunctionNumber, _In_ PVOID Context ); typedef NTSTATUS (*PINITIALIZE_DMA_TRANSFER_CONTEXT)( _In_ PDMA_ADAPTER DmaAdapter, _Out_ PVOID DmaTransferContext ); typedef PVOID (*PALLOCATE_COMMON_BUFFER_EX)( _In_ PDMA_ADAPTER DmaAdapter, _In_opt_ PPHYSICAL_ADDRESS MaximumAddress, _In_ ULONG Length, _Out_ PPHYSICAL_ADDRESS LogicalAddress, _In_ BOOLEAN CacheEnabled, _In_ NODE_REQUIREMENT PreferredNode ); typedef NTSTATUS (*PALLOCATE_ADAPTER_CHANNEL_EX)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ PVOID DmaTransferContext, _In_ ULONG NumberOfMapRegisters, _In_ ULONG Flags, _In_opt_ PDRIVER_CONTROL ExecutionRoutine, _In_opt_ PVOID ExecutionContext, _Out_opt_ PVOID *MapRegisterBase ); typedef VOID _Function_class_(DMA_COMPLETION_ROUTINE) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) DMA_COMPLETION_ROUTINE( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ PVOID CompletionContext, _In_ DMA_COMPLETION_STATUS Status ); typedef DMA_COMPLETION_ROUTINE *PDMA_COMPLETION_ROUTINE; typedef NTSTATUS (*PMAP_TRANSFER_EX)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ ULONGLONG Offset, _In_ ULONG DeviceOffset, _Inout_ PULONG Length, _In_ BOOLEAN WriteToDevice, _Out_writes_bytes_opt_(ScatterGatherBufferLength) PSCATTER_GATHER_LIST ScatterGatherBuffer, _In_ ULONG ScatterGatherBufferLength, _In_opt_ PDMA_COMPLETION_ROUTINE DmaCompletionRoutine, _In_opt_ PVOID CompletionContext ); typedef BOOLEAN (*PCANCEL_ADAPTER_CHANNEL)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ PVOID DmaTransferContext ); typedef NTSTATUS (*PCANCEL_MAPPED_TRANSFER)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PVOID DmaTransferContext ); typedef NTSTATUS (*PFLUSH_ADAPTER_BUFFERS_EX)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ ULONGLONG Offset, _In_ ULONG Length, _In_ BOOLEAN WriteToDevice ); typedef NTSTATUS (*PGET_SCATTER_GATHER_LIST_EX)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ PVOID DmaTransferContext, _In_ PMDL Mdl, _In_ ULONGLONG Offset, _In_ ULONG Length, _In_ ULONG Flags, _In_opt_ PDRIVER_LIST_CONTROL ExecutionRoutine, _In_opt_ PVOID Context, _In_ BOOLEAN WriteToDevice, _In_opt_ PDMA_COMPLETION_ROUTINE DmaCompletionRoutine, _In_opt_ PVOID CompletionContext, _Out_opt_ PSCATTER_GATHER_LIST *ScatterGatherList ); typedef NTSTATUS (*PBUILD_SCATTER_GATHER_LIST_EX)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ PVOID DmaTransferContext, _In_ PMDL Mdl, _In_ ULONGLONG Offset, _In_ ULONG Length, _In_ ULONG Flags, _In_opt_ PDRIVER_LIST_CONTROL ExecutionRoutine, _In_opt_ PVOID Context, _In_ BOOLEAN WriteToDevice, _In_ PVOID ScatterGatherBuffer, _In_ ULONG ScatterGatherLength, _In_opt_ PDMA_COMPLETION_ROUTINE DmaCompletionRoutine, _In_opt_ PVOID CompletionContext, _Out_opt_ PVOID ScatterGatherList ); typedef NTSTATUS (*PALLOCATE_DOMAIN_COMMON_BUFFER)( _In_ PDMA_ADAPTER DmaAdapter, _In_ HANDLE DomainHandle, _In_opt_ PPHYSICAL_ADDRESS MaximumAddress, _In_ ULONG Length, _In_ ULONG Flags, _In_opt_ MEMORY_CACHING_TYPE *CacheType, _In_ NODE_REQUIREMENT PreferredNode, _Out_ PPHYSICAL_ADDRESS LogicalAddress, _Out_ PVOID *VirtualAddress ); // // Define the bits in the allocate domain common buffer flags. // #define DOMAIN_COMMON_BUFFER_LARGE_PAGE 0x0001 typedef NTSTATUS (*PFLUSH_DMA_BUFFER)( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ BOOLEAN ReadOperation ); typedef NTSTATUS (*PJOIN_DMA_DOMAIN)( _In_ PDMA_ADAPTER DmaAdapter, _In_ HANDLE DomainHandle ); typedef NTSTATUS (*PLEAVE_DMA_DOMAIN)( _In_ PDMA_ADAPTER DmaAdapter ); typedef HANDLE (*PGET_DMA_DOMAIN)( _In_ PDMA_ADAPTER DmaAdapter ); typedef struct _DMA_OPERATIONS { ULONG Size; PPUT_DMA_ADAPTER PutDmaAdapter; PALLOCATE_COMMON_BUFFER AllocateCommonBuffer; PFREE_COMMON_BUFFER FreeCommonBuffer; PALLOCATE_ADAPTER_CHANNEL AllocateAdapterChannel; PFLUSH_ADAPTER_BUFFERS FlushAdapterBuffers; PFREE_ADAPTER_CHANNEL FreeAdapterChannel; PFREE_MAP_REGISTERS FreeMapRegisters; PMAP_TRANSFER MapTransfer; PGET_DMA_ALIGNMENT GetDmaAlignment; PREAD_DMA_COUNTER ReadDmaCounter; PGET_SCATTER_GATHER_LIST GetScatterGatherList; PPUT_SCATTER_GATHER_LIST PutScatterGatherList; PCALCULATE_SCATTER_GATHER_LIST_SIZE CalculateScatterGatherList; PBUILD_SCATTER_GATHER_LIST BuildScatterGatherList; PBUILD_MDL_FROM_SCATTER_GATHER_LIST BuildMdlFromScatterGatherList; PGET_DMA_ADAPTER_INFO GetDmaAdapterInfo; PGET_DMA_TRANSFER_INFO GetDmaTransferInfo; PINITIALIZE_DMA_TRANSFER_CONTEXT InitializeDmaTransferContext; PALLOCATE_COMMON_BUFFER_EX AllocateCommonBufferEx; PALLOCATE_ADAPTER_CHANNEL_EX AllocateAdapterChannelEx; PCONFIGURE_ADAPTER_CHANNEL ConfigureAdapterChannel; PCANCEL_ADAPTER_CHANNEL CancelAdapterChannel; PMAP_TRANSFER_EX MapTransferEx; PGET_SCATTER_GATHER_LIST_EX GetScatterGatherListEx; PBUILD_SCATTER_GATHER_LIST_EX BuildScatterGatherListEx; PFLUSH_ADAPTER_BUFFERS_EX FlushAdapterBuffersEx; PFREE_ADAPTER_OBJECT FreeAdapterObject; PCANCEL_MAPPED_TRANSFER CancelMappedTransfer; PALLOCATE_DOMAIN_COMMON_BUFFER AllocateDomainCommonBuffer; PFLUSH_DMA_BUFFER FlushDmaBuffer; PJOIN_DMA_DOMAIN JoinDmaDomain; PLEAVE_DMA_DOMAIN LeaveDmaDomain; PGET_DMA_DOMAIN GetDmaDomain; } DMA_OPERATIONS; #if defined(USE_DMA_MACROS) && !defined(_NTHAL_) && (defined(_NTDDK_) || defined(_NTDRIVER_)) || defined(_WDM_INCLUDED_) // ntddk DECLSPEC_DEPRECATED_DDK // Use AllocateCommonBuffer __drv_preferredFunction("AllocateCommonBuffer","Obsolete") FORCEINLINE PVOID HalAllocateCommonBuffer( _In_ PDMA_ADAPTER DmaAdapter, _In_ ULONG Length, _Out_ PPHYSICAL_ADDRESS LogicalAddress, _In_ BOOLEAN CacheEnabled ){ PALLOCATE_COMMON_BUFFER allocateCommonBuffer; PVOID commonBuffer; allocateCommonBuffer = *(DmaAdapter)->DmaOperations->AllocateCommonBuffer; NT_ASSERT( allocateCommonBuffer != NULL ); commonBuffer = allocateCommonBuffer( DmaAdapter, Length, LogicalAddress, CacheEnabled ); return commonBuffer; } DECLSPEC_DEPRECATED_DDK // Use FreeCommonBuffer __drv_preferredFunction("FreeCommonBuffer","Obsolete") FORCEINLINE VOID HalFreeCommonBuffer( _In_ PDMA_ADAPTER DmaAdapter, _In_ ULONG Length, _In_ PHYSICAL_ADDRESS LogicalAddress, _In_ PVOID VirtualAddress, _In_ BOOLEAN CacheEnabled ){ PFREE_COMMON_BUFFER freeCommonBuffer; freeCommonBuffer = *(DmaAdapter)->DmaOperations->FreeCommonBuffer; NT_ASSERT( freeCommonBuffer != NULL ); freeCommonBuffer( DmaAdapter, Length, LogicalAddress, VirtualAddress, CacheEnabled ); } DECLSPEC_DEPRECATED_DDK // Use AllocateAdapterChannel _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) __drv_preferredFunction("AllocateAdapterChannel","obsolete") FORCEINLINE NTSTATUS IoAllocateAdapterChannel( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG NumberOfMapRegisters, _In_ PDRIVER_CONTROL ExecutionRoutine, _In_ PVOID Context ){ PALLOCATE_ADAPTER_CHANNEL allocateAdapterChannel; NTSTATUS status; allocateAdapterChannel = *(DmaAdapter)->DmaOperations->AllocateAdapterChannel; NT_ASSERT( allocateAdapterChannel != NULL ); status = allocateAdapterChannel( DmaAdapter, DeviceObject, NumberOfMapRegisters, ExecutionRoutine, Context ); return status; } DECLSPEC_DEPRECATED_DDK // Use FlushAdapterBuffers __drv_preferredFunction("FlushAdapterBuffers","Obsolete") FORCEINLINE BOOLEAN IoFlushAdapterBuffers( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ PVOID CurrentVa, _In_ ULONG Length, _In_ BOOLEAN WriteToDevice ){ PFLUSH_ADAPTER_BUFFERS flushAdapterBuffers; BOOLEAN result; flushAdapterBuffers = *(DmaAdapter)->DmaOperations->FlushAdapterBuffers; NT_ASSERT( flushAdapterBuffers != NULL ); result = flushAdapterBuffers( DmaAdapter, Mdl, MapRegisterBase, CurrentVa, Length, WriteToDevice ); return result; } DECLSPEC_DEPRECATED_DDK // Use FreeAdapterChannel __drv_preferredFunction("FreeAdapterChannel","Obsolete") FORCEINLINE VOID IoFreeAdapterChannel( _In_ PDMA_ADAPTER DmaAdapter ){ PFREE_ADAPTER_CHANNEL freeAdapterChannel; freeAdapterChannel = *(DmaAdapter)->DmaOperations->FreeAdapterChannel; NT_ASSERT( freeAdapterChannel != NULL ); freeAdapterChannel( DmaAdapter ); } DECLSPEC_DEPRECATED_DDK // Use FreeMapRegisters __drv_preferredFunction("FreeMapRegisters","Obsolete") FORCEINLINE VOID IoFreeMapRegisters( _In_ PDMA_ADAPTER DmaAdapter, _In_ PVOID MapRegisterBase, _In_ ULONG NumberOfMapRegisters ){ PFREE_MAP_REGISTERS freeMapRegisters; freeMapRegisters = *(DmaAdapter)->DmaOperations->FreeMapRegisters; NT_ASSERT( freeMapRegisters != NULL ); freeMapRegisters( DmaAdapter, MapRegisterBase, NumberOfMapRegisters ); } DECLSPEC_DEPRECATED_DDK // Use MapTransfer __drv_preferredFunction("MapTransfer","Obsolete") FORCEINLINE PHYSICAL_ADDRESS IoMapTransfer( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ PVOID CurrentVa, _Inout_ PULONG Length, _In_ BOOLEAN WriteToDevice ){ PHYSICAL_ADDRESS physicalAddress; PMAP_TRANSFER mapTransfer; mapTransfer = *(DmaAdapter)->DmaOperations->MapTransfer; NT_ASSERT( mapTransfer != NULL ); physicalAddress = mapTransfer( DmaAdapter, Mdl, MapRegisterBase, CurrentVa, Length, WriteToDevice ); return physicalAddress; } DECLSPEC_DEPRECATED_DDK // Use GetDmaAlignment FORCEINLINE ULONG HalGetDmaAlignment( _In_ PDMA_ADAPTER DmaAdapter ) { PGET_DMA_ALIGNMENT getDmaAlignment; ULONG alignment; getDmaAlignment = *(DmaAdapter)->DmaOperations->GetDmaAlignment; NT_ASSERT( getDmaAlignment != NULL ); alignment = getDmaAlignment( DmaAdapter ); return alignment; } DECLSPEC_DEPRECATED_DDK // Use ReadDmaCounter __drv_preferredFunction("ReadDmaCounter","Obsolete") FORCEINLINE ULONG HalReadDmaCounter( _In_ PDMA_ADAPTER DmaAdapter ) { PREAD_DMA_COUNTER readDmaCounter; ULONG counter; readDmaCounter = *(DmaAdapter)->DmaOperations->ReadDmaCounter; NT_ASSERT( readDmaCounter != NULL ); counter = readDmaCounter( DmaAdapter ); return counter; } #endif // USE_DMA_MACROS && (_NTDDK_ || _NTDRIVER_) NTKERNELAPI VOID PoSetHiberRange ( _In_opt_ PVOID MemoryMap, _In_ ULONG Flags, _In_ PVOID Address, _In_ ULONG_PTR Length, _In_ ULONG Tag ); // memory_range.Type #define PO_MEM_PRESERVE 0x00000001 // memory range needs preserved #define PO_MEM_CLONE 0x00000002 // Clone this range #define PO_MEM_CL_OR_NCHK 0x00000004 // Either clone or do not checksum #define PO_MEM_DISCARD 0x00008000 // This range to be removed #define PO_MEM_PAGE_ADDRESS 0x00004000 // Arguments passed are physical pages #define PO_MEM_BOOT_PHASE 0x00010000 #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoSetSystemState ( _In_ EXECUTION_STATE Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID PoRegisterSystemState ( _Inout_opt_ PVOID StateHandle, _In_ EXECUTION_STATE Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS PoCreatePowerRequest ( _Outptr_ PVOID *PowerRequest, _In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PCOUNTED_REASON_CONTEXT Context ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS PoSetPowerRequest ( _Inout_ PVOID PowerRequest, _In_ POWER_REQUEST_TYPE Type ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS PoClearPowerRequest ( _Inout_ PVOID PowerRequest, _In_ POWER_REQUEST_TYPE Type ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID PoDeletePowerRequest ( _Inout_ PVOID PowerRequest ); #endif typedef _Function_class_(REQUEST_POWER_COMPLETE) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_same_ VOID REQUEST_POWER_COMPLETE ( _In_ PDEVICE_OBJECT DeviceObject, _In_ UCHAR MinorFunction, _In_ POWER_STATE PowerState, _In_opt_ PVOID Context, _In_ PIO_STATUS_BLOCK IoStatus ); typedef REQUEST_POWER_COMPLETE *PREQUEST_POWER_COMPLETE; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS PoRequestPowerIrp ( _In_ PDEVICE_OBJECT DeviceObject, _In_ UCHAR MinorFunction, _In_ POWER_STATE PowerState, _In_opt_ PREQUEST_POWER_COMPLETE CompletionFunction, _In_opt_ __drv_aliasesMem PVOID Context, _Outptr_opt_ PIRP *Irp ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoSetSystemWake ( _Inout_ PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN PoGetSystemWake ( _In_ PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID PoUnregisterSystemState ( _Inout_ PVOID StateHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI POWER_STATE PoSetPowerState ( _In_ PDEVICE_OBJECT DeviceObject, _In_ POWER_STATE_TYPE Type, _In_ POWER_STATE State ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS PoCallDriver ( _In_ PDEVICE_OBJECT DeviceObject, _Inout_ __drv_aliasesMem PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoStartNextPowerIrp( _Inout_ PIRP Irp ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PULONG PoRegisterDeviceForIdleDetection ( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ConservationIdleTime, _In_ ULONG PerformanceIdleTime, _In_ DEVICE_POWER_STATE State ); #endif #define PoSetDeviceBusy(IdlePointer) \ *IdlePointer = 0 #if (NTDDI_VERSION >= NTDDI_WIN6SP1) NTKERNELAPI VOID PoSetDeviceBusyEx ( _Inout_ PULONG IdlePointer ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI VOID PoStartDeviceBusy ( _Inout_ PULONG IdlePointer ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI VOID PoEndDeviceBusy ( _Inout_ PULONG IdlePointer ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN PoQueryWatchdogTime ( _In_ PDEVICE_OBJECT Pdo, _Out_ PULONG SecondsRemaining ); #endif typedef _Function_class_(POWER_SETTING_CALLBACK) _IRQL_requires_same_ NTSTATUS POWER_SETTING_CALLBACK ( _In_ LPCGUID SettingGuid, _In_reads_bytes_(ValueLength) PVOID Value, _In_ ULONG ValueLength, _Inout_opt_ PVOID Context ); typedef POWER_SETTING_CALLBACK *PPOWER_SETTING_CALLBACK; #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS PoRegisterPowerSettingCallback ( _In_opt_ PDEVICE_OBJECT DeviceObject, _In_ LPCGUID SettingGuid, _In_ PPOWER_SETTING_CALLBACK Callback, _In_opt_ PVOID Context, _Outptr_opt_ PVOID *Handle ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS PoUnregisterPowerSettingCallback ( _Inout_ PVOID Handle ); #endif // // \Callback\PowerState values // #define PO_CB_SYSTEM_POWER_POLICY 0 #define PO_CB_AC_STATUS 1 #define PO_CB_BUTTON_COLLISION 2 // deprecated #define PO_CB_SYSTEM_STATE_LOCK 3 #define PO_CB_LID_SWITCH_STATE 4 #define PO_CB_PROCESSOR_POWER_POLICY 5 // deprecated // // Runtime Power Management Framework // #define PO_FX_VERSION_V1 0x00000001 #define PO_FX_VERSION_V2 0x00000002 #define PO_FX_VERSION PO_FX_VERSION_V1 DECLARE_HANDLE(POHANDLE); typedef _Function_class_(PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component ); typedef PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK *PPO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK; typedef _Function_class_(PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component ); typedef PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK *PPO_FX_COMPONENT_IDLE_CONDITION_CALLBACK; typedef _Function_class_(PO_FX_COMPONENT_IDLE_STATE_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_COMPONENT_IDLE_STATE_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component, _In_ ULONG State ); typedef PO_FX_COMPONENT_IDLE_STATE_CALLBACK *PPO_FX_COMPONENT_IDLE_STATE_CALLBACK; typedef _Function_class_(PO_FX_DEVICE_POWER_REQUIRED_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_DEVICE_POWER_REQUIRED_CALLBACK ( _In_ PVOID Context ); typedef PO_FX_DEVICE_POWER_REQUIRED_CALLBACK *PPO_FX_DEVICE_POWER_REQUIRED_CALLBACK; typedef _Function_class_(PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) VOID PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK ( _In_ PVOID Context ); typedef PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK *PPO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK; typedef _Function_class_(PO_FX_POWER_CONTROL_CALLBACK) _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS PO_FX_POWER_CONTROL_CALLBACK ( _In_ PVOID DeviceContext, _In_ LPCGUID PowerControlCode, _In_reads_bytes_opt_(InBufferSize) PVOID InBuffer, _In_ SIZE_T InBufferSize, _Out_writes_bytes_opt_(OutBufferSize) PVOID OutBuffer, _In_ SIZE_T OutBufferSize, _Out_opt_ PSIZE_T BytesReturned ); typedef PO_FX_POWER_CONTROL_CALLBACK *PPO_FX_POWER_CONTROL_CALLBACK; typedef _Function_class_(PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK) _IRQL_requires_max_(HIGH_LEVEL) VOID PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK ( _In_ PVOID Context, _In_ ULONG Component, _In_ BOOLEAN Active ); typedef PO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK *PPO_FX_COMPONENT_CRITICAL_TRANSITION_CALLBACK; typedef struct _PO_FX_COMPONENT_IDLE_STATE { ULONGLONG TransitionLatency; ULONGLONG ResidencyRequirement; ULONG NominalPower; } PO_FX_COMPONENT_IDLE_STATE, *PPO_FX_COMPONENT_IDLE_STATE; typedef struct _PO_FX_COMPONENT_V1 { GUID Id; ULONG IdleStateCount; ULONG DeepestWakeableIdleState; _Field_size_full_(IdleStateCount) PPO_FX_COMPONENT_IDLE_STATE IdleStates; } PO_FX_COMPONENT_V1, *PPO_FX_COMPONENT_V1; typedef struct _PO_FX_DEVICE_V1 { ULONG Version; ULONG ComponentCount; PPO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK ComponentActiveConditionCallback; PPO_FX_COMPONENT_IDLE_CONDITION_CALLBACK ComponentIdleConditionCallback; PPO_FX_COMPONENT_IDLE_STATE_CALLBACK ComponentIdleStateCallback; PPO_FX_DEVICE_POWER_REQUIRED_CALLBACK DevicePowerRequiredCallback; PPO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK DevicePowerNotRequiredCallback; PPO_FX_POWER_CONTROL_CALLBACK PowerControlCallback; PVOID DeviceContext; _Field_size_full_(ComponentCount) PO_FX_COMPONENT_V1 Components[ANYSIZE_ARRAY]; } PO_FX_DEVICE_V1, *PPO_FX_DEVICE_V1; #define PO_FX_COMPONENT_FLAG_F0_ON_DX 0x0000000000000001 #define PO_FX_COMPONENT_FLAG_NO_DEBOUNCE 0x0000000000000002 typedef struct _PO_FX_COMPONENT_V2 { GUID Id; ULONGLONG Flags; ULONG DeepestWakeableIdleState; ULONG IdleStateCount; _Field_size_full_(IdleStateCount) PPO_FX_COMPONENT_IDLE_STATE IdleStates; ULONG ProviderCount; _Field_size_full_(ProviderCount) PULONG Providers; } PO_FX_COMPONENT_V2, *PPO_FX_COMPONENT_V2; typedef struct _PO_FX_DEVICE_V2 { ULONG Version; ULONGLONG Flags; PPO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK ComponentActiveConditionCallback; PPO_FX_COMPONENT_IDLE_CONDITION_CALLBACK ComponentIdleConditionCallback; PPO_FX_COMPONENT_IDLE_STATE_CALLBACK ComponentIdleStateCallback; PPO_FX_DEVICE_POWER_REQUIRED_CALLBACK DevicePowerRequiredCallback; PPO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK DevicePowerNotRequiredCallback; PPO_FX_POWER_CONTROL_CALLBACK PowerControlCallback; PVOID DeviceContext; ULONG ComponentCount; _Field_size_full_(ComponentCount) PO_FX_COMPONENT_V2 Components[ANYSIZE_ARRAY]; } PO_FX_DEVICE_V2, *PPO_FX_DEVICE_V2; #if (PO_FX_VERSION == PO_FX_VERSION_V1) typedef PO_FX_COMPONENT_V1 PO_FX_COMPONENT, *PPO_FX_COMPONENT; typedef PO_FX_DEVICE_V1 PO_FX_DEVICE, *PPO_FX_DEVICE; #elif (PO_FX_VERSION == PO_FX_VERSION_V2) typedef PO_FX_COMPONENT_V2 PO_FX_COMPONENT, *PPO_FX_COMPONENT; typedef PO_FX_DEVICE_V2 PO_FX_DEVICE, *PPO_FX_DEVICE; #else #error PO_FX_VERSION undefined! #endif typedef enum _PO_FX_PERF_STATE_UNIT { PoFxPerfStateUnitOther, PoFxPerfStateUnitFrequency, PoFxPerfStateUnitBandwidth, PoFxPerfStateUnitMaximum } PO_FX_PERF_STATE_UNIT, *PPO_FX_PERF_STATE_UNIT; typedef enum _PO_FX_PERF_STATE_TYPE { PoFxPerfStateTypeDiscrete, PoFxPerfStateTypeRange, PoFxPerfStateTypeMaximum } PO_FX_PERF_STATE_TYPE, *PPO_FX_PERF_STATE_TYPE; typedef struct _PO_FX_PERF_STATE { ULONGLONG Value; PVOID Context; } PO_FX_PERF_STATE, *PPO_FX_PERF_STATE; typedef struct _PO_FX_COMPONENT_PERF_SET { UNICODE_STRING Name; ULONGLONG Flags; PO_FX_PERF_STATE_UNIT Unit; PO_FX_PERF_STATE_TYPE Type; union { struct { ULONG Count; _Field_size_full_(Count) PPO_FX_PERF_STATE States; } Discrete; struct { ULONGLONG Minimum; ULONGLONG Maximum; } Range; }; } PO_FX_COMPONENT_PERF_SET, *PPO_FX_COMPONENT_PERF_SET; typedef struct _PO_FX_COMPONENT_PERF_INFO { ULONG PerfStateSetsCount; PO_FX_COMPONENT_PERF_SET PerfStateSets[ANYSIZE_ARRAY]; } PO_FX_COMPONENT_PERF_INFO, *PPO_FX_COMPONENT_PERF_INFO; typedef struct _PO_FX_PERF_STATE_CHANGE { ULONG Set; union { ULONG StateIndex; ULONGLONG StateValue; }; } PO_FX_PERF_STATE_CHANGE, *PPO_FX_PERF_STATE_CHANGE; // // Driver interfaces for runtime framework. // #define PO_FX_UNKNOWN_POWER 0xFFFFFFFF #define PO_FX_UNKNOWN_TIME 0xFFFFFFFFFFFFFFFF #define PO_FX_FLAG_BLOCKING 0x01 #define PO_FX_FLAG_ASYNC_ONLY 0x02 #define PO_FX_FLAG_PERF_PEP_OPTIONAL 0x01 #define PO_FX_FLAG_PERF_QUERY_ON_F0 0x02 #define PO_FX_FLAG_PERF_QUERY_ON_ALL_IDLE_STATES 0x04 #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS PoFxRegisterDevice ( _In_ PDEVICE_OBJECT Pdo, _In_ PPO_FX_DEVICE Device, _Out_ POHANDLE *Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID PoFxStartDevicePowerManagement ( _In_ POHANDLE Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID PoFxUnregisterDevice ( _In_ POHANDLE Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WINBLUE) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS PoFxRegisterCrashdumpDevice ( _In_ POHANDLE Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WINBLUE) _IRQL_requires_max_(HIGH_LEVEL) NTKERNELAPI NTSTATUS PoFxPowerOnCrashdumpDevice( _In_ POHANDLE Handle, _In_opt_ PVOID Context ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxActivateComponent ( _In_ POHANDLE Handle, _In_ ULONG Component, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxCompleteDevicePowerNotRequired ( _In_ POHANDLE Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxCompleteIdleCondition ( _In_ POHANDLE Handle, _In_ ULONG Component ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxCompleteIdleState ( _In_ POHANDLE Handle, _In_ ULONG Component ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxIdleComponent ( _In_ POHANDLE Handle, _In_ ULONG Component, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxSetComponentLatency ( _In_ POHANDLE Handle, _In_ ULONG Component, _In_ ULONGLONG Latency ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxSetComponentResidency ( _In_ POHANDLE Handle, _In_ ULONG Component, _In_ ULONGLONG Residency ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxSetComponentWake ( _In_ POHANDLE Handle, _In_ ULONG Component, _In_ BOOLEAN WakeHint ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxSetDeviceIdleTimeout ( _In_ POHANDLE Handle, _In_ ULONGLONG IdleTimeout ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxReportDevicePoweredOn ( _In_ POHANDLE Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS PoFxPowerControl ( _In_ POHANDLE Handle, _In_ LPCGUID PowerControlCode, _In_opt_ PVOID InBuffer, _In_ SIZE_T InBufferSize, _Out_opt_ PVOID OutBuffer, _In_ SIZE_T OutBufferSize, _Out_opt_ PSIZE_T BytesReturned ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxNotifySurprisePowerOn( _In_ PDEVICE_OBJECT Pdo ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) typedef _Function_class_(PO_FX_COMPONENT_PERF_STATE_CALLBACK) VOID PO_FX_COMPONENT_PERF_STATE_CALLBACK( _In_ PVOID Context, _In_ ULONG Component, _In_ BOOLEAN Succeeded, _In_ PVOID RequestContext ); typedef PO_FX_COMPONENT_PERF_STATE_CALLBACK *PPO_FX_COMPONENT_PERF_STATE_CALLBACK; _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS PoFxRegisterComponentPerfStates ( _In_ POHANDLE Handle, _In_ ULONG Component, _In_ ULONGLONG Flags, _In_ PPO_FX_COMPONENT_PERF_STATE_CALLBACK ComponentPerfStateCallback, _In_ PPO_FX_COMPONENT_PERF_INFO InputStateInfo, _Out_ PPO_FX_COMPONENT_PERF_INFO* OutputStateInfo ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxIssueComponentPerfStateChange ( _In_ POHANDLE Handle, _In_ ULONG Flags, _In_ ULONG Component, _In_ PPO_FX_PERF_STATE_CHANGE PerfChange, _In_ PVOID Context ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID PoFxIssueComponentPerfStateChangeMultiple ( _In_ POHANDLE Handle, _In_ ULONG Flags, _In_ ULONG Component, _In_ ULONG PerfChangesCount, _In_ PO_FX_PERF_STATE_CHANGE PerfChanges[], _In_ PVOID Context ); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS PoFxQueryCurrentComponentPerfState ( _In_ POHANDLE Handle, _In_ ULONG Flags, _In_ ULONG Component, _In_ ULONG SetIndex, _Out_ PULONGLONG CurrentPerf ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS PoCreateThermalRequest ( _Outptr_ PVOID *ThermalRequest, _In_ PDEVICE_OBJECT TargetDeviceObject, _In_ PDEVICE_OBJECT PolicyDeviceObject, _In_ PCOUNTED_REASON_CONTEXT Context, _In_ ULONG Flags ); #endif typedef enum _PO_THERMAL_REQUEST_TYPE { PoThermalRequestPassive, PoThermalRequestActive, } PO_THERMAL_REQUEST_TYPE, *PPO_THERMAL_REQUEST_TYPE; #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI BOOLEAN PoGetThermalRequestSupport ( _In_ PVOID ThermalRequest, _In_ PO_THERMAL_REQUEST_TYPE Type ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS PoSetThermalPassiveCooling ( _Inout_ PVOID ThermalRequest, _In_ UCHAR Throttle ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS PoSetThermalActiveCooling ( _Inout_ PVOID ThermalRequest, _In_ BOOLEAN Engaged ); #endif #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID PoDeleteThermalRequest ( _Inout_ PVOID ThermalRequest ); #endif // // Object Manager types // typedef struct _OBJECT_HANDLE_INFORMATION { ULONG HandleAttributes; ACCESS_MASK GrantedAccess; } OBJECT_HANDLE_INFORMATION, *POBJECT_HANDLE_INFORMATION; #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS ObReferenceObjectByHandle( _In_ HANDLE Handle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_TYPE ObjectType, _In_ KPROCESSOR_MODE AccessMode, _Out_ PVOID *Object, _Out_opt_ POBJECT_HANDLE_INFORMATION HandleInformation ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS ObReferenceObjectByHandleWithTag( _In_ HANDLE Handle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_TYPE ObjectType, _In_ KPROCESSOR_MODE AccessMode, _In_ ULONG Tag, _Out_ PVOID *Object, _Out_opt_ POBJECT_HANDLE_INFORMATION HandleInformation ); #endif #if (NTDDI_VERSION >= NTDDI_WIN8) NTKERNELAPI BOOLEAN FASTCALL ObReferenceObjectSafe ( _In_ PVOID Object ); NTKERNELAPI BOOLEAN FASTCALL ObReferenceObjectSafeWithTag ( _In_ PVOID Object, _In_ ULONG Tag ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI NTSTATUS ObCloseHandle ( _In_ HANDLE Handle, _In_ KPROCESSOR_MODE PreviousMode ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) #define ObDereferenceObject(a) \ ObfDereferenceObject(a) #define ObReferenceObject(Object) ObfReferenceObject(Object) #define ObDereferenceObjectWithTag(a, t) \ ObfDereferenceObjectWithTag(a, t) #define ObReferenceObjectWithTag(Object, Tag) ObfReferenceObjectWithTag(Object, Tag) #else #define ObDereferenceObject(a) \ ObfDereferenceObject(a) #define ObReferenceObject(Object) ObfReferenceObject(Object) #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG_PTR FASTCALL ObfReferenceObject( _In_ PVOID Object ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG_PTR FASTCALL ObfReferenceObjectWithTag( _In_ PVOID Object, _In_ ULONG Tag ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS ObReferenceObjectByPointer( _In_ PVOID Object, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_TYPE ObjectType, _In_ KPROCESSOR_MODE AccessMode ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS ObReferenceObjectByPointerWithTag( _In_ PVOID Object, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_TYPE ObjectType, _In_ KPROCESSOR_MODE AccessMode, _In_ ULONG Tag ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG_PTR FASTCALL ObfDereferenceObject( _In_ PVOID Object ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG_PTR FASTCALL ObfDereferenceObjectWithTag( _In_ PVOID Object, _In_ ULONG Tag ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTKERNELAPI VOID ObDereferenceObjectDeferDelete( _In_ PVOID Object ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) NTKERNELAPI VOID ObDereferenceObjectDeferDeleteWithTag( _In_ PVOID Object, _In_ ULONG Tag ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI NTSTATUS ObGetObjectSecurity( _In_ PVOID Object, _Out_ PSECURITY_DESCRIPTOR *SecurityDescriptor, _Out_ PBOOLEAN MemoryAllocated ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID ObReleaseObjectSecurity( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ BOOLEAN MemoryAllocated ); #endif // // Registration version for Vista SP1 and Windows Server 2007 // #define OB_FLT_REGISTRATION_VERSION_0100 0x0100 // // This value should be used by filters for registration // #define OB_FLT_REGISTRATION_VERSION OB_FLT_REGISTRATION_VERSION_0100 typedef ULONG OB_OPERATION; #define OB_OPERATION_HANDLE_CREATE 0x00000001 #define OB_OPERATION_HANDLE_DUPLICATE 0x00000002 typedef struct _OB_PRE_CREATE_HANDLE_INFORMATION { _Inout_ ACCESS_MASK DesiredAccess; _In_ ACCESS_MASK OriginalDesiredAccess; } OB_PRE_CREATE_HANDLE_INFORMATION, *POB_PRE_CREATE_HANDLE_INFORMATION; typedef struct _OB_PRE_DUPLICATE_HANDLE_INFORMATION { _Inout_ ACCESS_MASK DesiredAccess; _In_ ACCESS_MASK OriginalDesiredAccess; _In_ PVOID SourceProcess; _In_ PVOID TargetProcess; } OB_PRE_DUPLICATE_HANDLE_INFORMATION, * POB_PRE_DUPLICATE_HANDLE_INFORMATION; typedef union _OB_PRE_OPERATION_PARAMETERS { _Inout_ OB_PRE_CREATE_HANDLE_INFORMATION CreateHandleInformation; _Inout_ OB_PRE_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation; } OB_PRE_OPERATION_PARAMETERS, *POB_PRE_OPERATION_PARAMETERS; typedef struct _OB_PRE_OPERATION_INFORMATION { _In_ OB_OPERATION Operation; union { _In_ ULONG Flags; struct { _In_ ULONG KernelHandle:1; _In_ ULONG Reserved:31; }; }; _In_ PVOID Object; _In_ POBJECT_TYPE ObjectType; _Out_ PVOID CallContext; _In_ POB_PRE_OPERATION_PARAMETERS Parameters; } OB_PRE_OPERATION_INFORMATION, *POB_PRE_OPERATION_INFORMATION; typedef struct _OB_POST_CREATE_HANDLE_INFORMATION { _In_ ACCESS_MASK GrantedAccess; } OB_POST_CREATE_HANDLE_INFORMATION, *POB_POST_CREATE_HANDLE_INFORMATION; typedef struct _OB_POST_DUPLICATE_HANDLE_INFORMATION { _In_ ACCESS_MASK GrantedAccess; } OB_POST_DUPLICATE_HANDLE_INFORMATION, * POB_POST_DUPLICATE_HANDLE_INFORMATION; typedef union _OB_POST_OPERATION_PARAMETERS { _In_ OB_POST_CREATE_HANDLE_INFORMATION CreateHandleInformation; _In_ OB_POST_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation; } OB_POST_OPERATION_PARAMETERS, *POB_POST_OPERATION_PARAMETERS; typedef struct _OB_POST_OPERATION_INFORMATION { _In_ OB_OPERATION Operation; union { _In_ ULONG Flags; struct { _In_ ULONG KernelHandle:1; _In_ ULONG Reserved:31; }; }; _In_ PVOID Object; _In_ POBJECT_TYPE ObjectType; _In_ PVOID CallContext; _In_ NTSTATUS ReturnStatus; _In_ POB_POST_OPERATION_PARAMETERS Parameters; } OB_POST_OPERATION_INFORMATION,*POB_POST_OPERATION_INFORMATION; typedef enum _OB_PREOP_CALLBACK_STATUS { OB_PREOP_SUCCESS } OB_PREOP_CALLBACK_STATUS, *POB_PREOP_CALLBACK_STATUS; typedef OB_PREOP_CALLBACK_STATUS (*POB_PRE_OPERATION_CALLBACK) ( _In_ PVOID RegistrationContext, _Inout_ POB_PRE_OPERATION_INFORMATION OperationInformation ); typedef VOID (*POB_POST_OPERATION_CALLBACK) ( _In_ PVOID RegistrationContext, _In_ POB_POST_OPERATION_INFORMATION OperationInformation ); typedef struct _OB_OPERATION_REGISTRATION { _In_ POBJECT_TYPE *ObjectType; _In_ OB_OPERATION Operations; _In_ POB_PRE_OPERATION_CALLBACK PreOperation; _In_ POB_POST_OPERATION_CALLBACK PostOperation; } OB_OPERATION_REGISTRATION, *POB_OPERATION_REGISTRATION; typedef struct _OB_CALLBACK_REGISTRATION { _In_ USHORT Version; _In_ USHORT OperationRegistrationCount; _In_ UNICODE_STRING Altitude; _In_ PVOID RegistrationContext; _In_ OB_OPERATION_REGISTRATION *OperationRegistration; } OB_CALLBACK_REGISTRATION, *POB_CALLBACK_REGISTRATION; #if (NTDDI_VERSION >= NTDDI_VISTASP1) NTKERNELAPI NTSTATUS ObRegisterCallbacks ( _In_ POB_CALLBACK_REGISTRATION CallbackRegistration, _Outptr_ PVOID *RegistrationHandle ); NTKERNELAPI VOID ObUnRegisterCallbacks ( _In_ PVOID RegistrationHandle ); NTKERNELAPI USHORT ObGetFilterVersion (); #endif #ifndef _PCI_X_ #define _PCI_X_ // // A PCI driver can read the complete 256 bytes of configuration // information for any PCI device by calling: // // ULONG // HalGetBusData ( // _In_ BUS_DATA_TYPE PCIConfiguration, // _In_ ULONG PciBusNumber, // _In_ PCI_SLOT_NUMBER VirtualSlotNumber, // _In_ PPCI_COMMON_CONFIG &PCIDeviceConfig, // _In_ ULONG sizeof (PCIDeviceConfig) // ); // // A return value of 0 means that the specified PCI bus does not exist. // // A return value of 2, with a VendorID of PCI_INVALID_VENDORID means // that the PCI bus does exist, but there is no device at the specified // VirtualSlotNumber (PCI Device/Function number). // // typedef struct _PCI_SLOT_NUMBER { union { struct { ULONG DeviceNumber:5; ULONG FunctionNumber:3; ULONG Reserved:24; } bits; ULONG AsULONG; } u; } PCI_SLOT_NUMBER, *PPCI_SLOT_NUMBER; #define PCI_TYPE0_ADDRESSES 6 #define PCI_TYPE1_ADDRESSES 2 #define PCI_TYPE2_ADDRESSES 5 typedef struct _PCI_COMMON_HEADER { USHORT VendorID; // (ro) USHORT DeviceID; // (ro) USHORT Command; // Device control USHORT Status; UCHAR RevisionID; // (ro) UCHAR ProgIf; // (ro) UCHAR SubClass; // (ro) UCHAR BaseClass; // (ro) UCHAR CacheLineSize; // (ro+) UCHAR LatencyTimer; // (ro+) UCHAR HeaderType; // (ro) UCHAR BIST; // Built in self test union { struct _PCI_HEADER_TYPE_0 { ULONG BaseAddresses[PCI_TYPE0_ADDRESSES]; ULONG CIS; USHORT SubVendorID; USHORT SubSystemID; ULONG ROMBaseAddress; UCHAR CapabilitiesPtr; UCHAR Reserved1[3]; ULONG Reserved2; UCHAR InterruptLine; // UCHAR InterruptPin; // (ro) UCHAR MinimumGrant; // (ro) UCHAR MaximumLatency; // (ro) } type0; // // PCI to PCI Bridge // struct _PCI_HEADER_TYPE_1 { ULONG BaseAddresses[PCI_TYPE1_ADDRESSES]; UCHAR PrimaryBus; UCHAR SecondaryBus; UCHAR SubordinateBus; UCHAR SecondaryLatency; UCHAR IOBase; UCHAR IOLimit; USHORT SecondaryStatus; USHORT MemoryBase; USHORT MemoryLimit; USHORT PrefetchBase; USHORT PrefetchLimit; ULONG PrefetchBaseUpper32; ULONG PrefetchLimitUpper32; USHORT IOBaseUpper16; USHORT IOLimitUpper16; UCHAR CapabilitiesPtr; UCHAR Reserved1[3]; ULONG ROMBaseAddress; UCHAR InterruptLine; UCHAR InterruptPin; USHORT BridgeControl; } type1; // // PCI to CARDBUS Bridge // struct _PCI_HEADER_TYPE_2 { ULONG SocketRegistersBaseAddress; UCHAR CapabilitiesPtr; UCHAR Reserved; USHORT SecondaryStatus; UCHAR PrimaryBus; UCHAR SecondaryBus; UCHAR SubordinateBus; UCHAR SecondaryLatency; struct { ULONG Base; ULONG Limit; } Range[PCI_TYPE2_ADDRESSES-1]; UCHAR InterruptLine; UCHAR InterruptPin; USHORT BridgeControl; } type2; } u; } PCI_COMMON_HEADER, *PPCI_COMMON_HEADER; #ifdef __cplusplus typedef struct _PCI_COMMON_CONFIG : PCI_COMMON_HEADER { UCHAR DeviceSpecific[192]; } PCI_COMMON_CONFIG, *PPCI_COMMON_CONFIG; #else typedef struct _PCI_COMMON_CONFIG { PCI_COMMON_HEADER DUMMYSTRUCTNAME; UCHAR DeviceSpecific[192]; } PCI_COMMON_CONFIG, *PPCI_COMMON_CONFIG; #endif #define PCI_COMMON_HDR_LENGTH (FIELD_OFFSET (PCI_COMMON_CONFIG, DeviceSpecific)) #define PCI_EXTENDED_CONFIG_LENGTH 0x1000 #define PCI_MAX_DEVICES 32 #define PCI_MAX_FUNCTION 8 #define PCI_MAX_BRIDGE_NUMBER 0xFF #define PCI_INVALID_VENDORID 0xFFFF // // Bit encodings for PCI_COMMON_CONFIG.HeaderType // #define PCI_MULTIFUNCTION 0x80 #define PCI_DEVICE_TYPE 0x00 #define PCI_BRIDGE_TYPE 0x01 #define PCI_CARDBUS_BRIDGE_TYPE 0x02 #define PCI_CONFIGURATION_TYPE(PciData) \ (((PPCI_COMMON_CONFIG)(PciData))->HeaderType & ~PCI_MULTIFUNCTION) #define PCI_MULTIFUNCTION_DEVICE(PciData) \ ((((PPCI_COMMON_CONFIG)(PciData))->HeaderType & PCI_MULTIFUNCTION) != 0) // // Bit encodings for PCI_COMMON_CONFIG.Command // #define PCI_ENABLE_IO_SPACE 0x0001 #define PCI_ENABLE_MEMORY_SPACE 0x0002 #define PCI_ENABLE_BUS_MASTER 0x0004 #define PCI_ENABLE_SPECIAL_CYCLES 0x0008 #define PCI_ENABLE_WRITE_AND_INVALIDATE 0x0010 #define PCI_ENABLE_VGA_COMPATIBLE_PALETTE 0x0020 #define PCI_ENABLE_PARITY 0x0040 // (ro+) #define PCI_ENABLE_WAIT_CYCLE 0x0080 // (ro+) #define PCI_ENABLE_SERR 0x0100 // (ro+) #define PCI_ENABLE_FAST_BACK_TO_BACK 0x0200 // (ro) #define PCI_DISABLE_LEVEL_INTERRUPT 0x0400 // // Bit encodings for PCI_COMMON_CONFIG.Status // #define PCI_STATUS_INTERRUPT_PENDING 0x0008 #define PCI_STATUS_CAPABILITIES_LIST 0x0010 // (ro) #define PCI_STATUS_66MHZ_CAPABLE 0x0020 // (ro) #define PCI_STATUS_UDF_SUPPORTED 0x0040 // (ro) #define PCI_STATUS_FAST_BACK_TO_BACK 0x0080 // (ro) #define PCI_STATUS_DATA_PARITY_DETECTED 0x0100 #define PCI_STATUS_DEVSEL 0x0600 // 2 bits wide #define PCI_STATUS_SIGNALED_TARGET_ABORT 0x0800 #define PCI_STATUS_RECEIVED_TARGET_ABORT 0x1000 #define PCI_STATUS_RECEIVED_MASTER_ABORT 0x2000 #define PCI_STATUS_SIGNALED_SYSTEM_ERROR 0x4000 #define PCI_STATUS_DETECTED_PARITY_ERROR 0x8000 // // The NT PCI Driver uses a WhichSpace parameter on its CONFIG_READ/WRITE // routines. The following values are defined- // #define PCI_WHICHSPACE_CONFIG 0x0 #define PCI_WHICHSPACE_ROM 0x52696350 // // PCI Capability IDs // #define PCI_CAPABILITY_ID_POWER_MANAGEMENT 0x01 #define PCI_CAPABILITY_ID_AGP 0x02 #define PCI_CAPABILITY_ID_VPD 0x03 #define PCI_CAPABILITY_ID_SLOT_ID 0x04 #define PCI_CAPABILITY_ID_MSI 0x05 #define PCI_CAPABILITY_ID_CPCI_HOTSWAP 0x06 #define PCI_CAPABILITY_ID_PCIX 0x07 #define PCI_CAPABILITY_ID_HYPERTRANSPORT 0x08 #define PCI_CAPABILITY_ID_VENDOR_SPECIFIC 0x09 #define PCI_CAPABILITY_ID_DEBUG_PORT 0x0A #define PCI_CAPABILITY_ID_CPCI_RES_CTRL 0x0B #define PCI_CAPABILITY_ID_SHPC 0x0C #define PCI_CAPABILITY_ID_P2P_SSID 0x0D #define PCI_CAPABILITY_ID_AGP_TARGET 0x0E #define PCI_CAPABILITY_ID_SECURE 0x0F #define PCI_CAPABILITY_ID_PCI_EXPRESS 0x10 #define PCI_CAPABILITY_ID_MSIX 0x11 #define PCI_CAPABILITY_ID_SATA_CONFIG 0x12 #define PCI_CAPABILITY_ID_ADVANCED_FEATURES 0x13 // // All PCI Capability structures have the following header. // // CapabilityID is used to identify the type of the structure (is // one of the PCI_CAPABILITY_ID values above. // // Next is the offset in PCI Configuration space (0x40 - 0xfc) of the // next capability structure in the list, or 0x00 if there are no more // entries. // typedef struct _PCI_CAPABILITIES_HEADER { UCHAR CapabilityID; UCHAR Next; } PCI_CAPABILITIES_HEADER, *PPCI_CAPABILITIES_HEADER; // // Power Management Capability // typedef struct _PCI_PMC { UCHAR Version:3; UCHAR PMEClock:1; UCHAR Rsvd1:1; UCHAR DeviceSpecificInitialization:1; UCHAR Rsvd2:2; struct _PM_SUPPORT { UCHAR Rsvd2:1; UCHAR D1:1; UCHAR D2:1; UCHAR PMED0:1; UCHAR PMED1:1; UCHAR PMED2:1; UCHAR PMED3Hot:1; UCHAR PMED3Cold:1; } Support; } PCI_PMC, *PPCI_PMC; typedef struct _PCI_PMCSR { USHORT PowerState:2; USHORT Rsvd1:1; USHORT NoSoftReset:1; USHORT Rsvd2:4; USHORT PMEEnable:1; USHORT DataSelect:4; USHORT DataScale:2; USHORT PMEStatus:1; } PCI_PMCSR, *PPCI_PMCSR; typedef struct _PCI_PMCSR_BSE { UCHAR Rsvd1:6; UCHAR D3HotSupportsStopClock:1; // B2_B3# UCHAR BusPowerClockControlEnabled:1; // BPCC_EN } PCI_PMCSR_BSE, *PPCI_PMCSR_BSE; typedef struct _PCI_PM_CAPABILITY { PCI_CAPABILITIES_HEADER Header; // // Power Management Capabilities (Offset = 2) // union { PCI_PMC Capabilities; USHORT AsUSHORT; } PMC; // // Power Management Control/Status (Offset = 4) // union { PCI_PMCSR ControlStatus; USHORT AsUSHORT; } PMCSR; // // PMCSR PCI-PCI Bridge Support Extensions // union { PCI_PMCSR_BSE BridgeSupport; UCHAR AsUCHAR; } PMCSR_BSE; // // Optional read only 8 bit Data register. Contents controlled by // DataSelect and DataScale in ControlStatus. // UCHAR Data; } PCI_PM_CAPABILITY, *PPCI_PM_CAPABILITY; // // PCI-X Capability // typedef struct { PCI_CAPABILITIES_HEADER Header; union { struct { USHORT DataParityErrorRecoveryEnable:1; USHORT EnableRelaxedOrdering:1; USHORT MaxMemoryReadByteCount:2; USHORT MaxOutstandingSplitTransactions:3; USHORT Reserved:9; } bits; USHORT AsUSHORT; } Command; union { struct { ULONG FunctionNumber:3; ULONG DeviceNumber:5; ULONG BusNumber:8; ULONG Device64Bit:1; ULONG Capable133MHz:1; ULONG SplitCompletionDiscarded:1; ULONG UnexpectedSplitCompletion:1; ULONG DeviceComplexity:1; ULONG DesignedMaxMemoryReadByteCount:2; ULONG DesignedMaxOutstandingSplitTransactions:3; ULONG DesignedMaxCumulativeReadSize:3; ULONG ReceivedSplitCompletionErrorMessage:1; ULONG CapablePCIX266:1; ULONG CapablePCIX533:1; } bits; ULONG AsULONG; } Status; } PCI_X_CAPABILITY, *PPCI_X_CAPABILITY; // // PCI Express Extended Capabilities. // #define PCI_EXPRESS_ADVANCED_ERROR_REPORTING_CAP_ID 0x0001 #define PCI_EXPRESS_VIRTUAL_CHANNEL_CAP_ID 0x0002 #define PCI_EXPRESS_DEVICE_SERIAL_NUMBER_CAP_ID 0x0003 #define PCI_EXPRESS_POWER_BUDGETING_CAP_ID 0x0004 #define PCI_EXPRESS_RC_LINK_DECLARATION_CAP_ID 0x0005 #define PCI_EXPRESS_RC_INTERNAL_LINK_CONTROL_CAP_ID 0x0006 #define PCI_EXPRESS_RC_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION_CAP_ID 0x0007 #define PCI_EXPRESS_MFVC_CAP_ID 0x0008 #define PCI_EXPRESS_VC_AND_MFVC_CAP_ID 0x0009 #define PCI_EXPRESS_RCRB_HEADER_CAP_ID 0x000A #define PCI_EXPRESS_VENDOR_SPECIFIC_CAP_ID 0x000B #define PCI_EXPRESS_CONFIGURATION_ACCESS_CORRELATION_CAP_ID 0x000C #define PCI_EXPRESS_ACCESS_CONTROL_SERVICES_CAP_ID 0x000D #define PCI_EXPRESS_ARI_CAP_ID 0x000E #define PCI_EXPRESS_ATS_CAP_ID 0x000F #define PCI_EXPRESS_SINGLE_ROOT_IO_VIRTUALIZATION_CAP_ID 0x0010 #define PCI_EXPRESS_MULTI_ROOT_IO_VIRTUALIZATION_CAP_ID 0x0011 #define PCI_EXPRESS_MULTICAST_CAP_ID 0x0012 #define PCI_EXPRESS_PAGE_REQUEST_CAP_ID 0x0013 #define PCI_EXPRESS_RESERVED_FOR_AMD_CAP_ID 0x0014 #define PCI_EXPRESS_RESIZABLE_BAR_CAP_ID 0x0015 #define PCI_EXPRESS_DPA_CAP_ID 0x0016 #define PCI_EXPRESS_TPH_REQUESTER_CAP_ID 0x0017 #define PCI_EXPRESS_LTR_CAP_ID 0x0018 #define PCI_EXPRESS_SECONDARY_PCI_EXPRESS_CAP_ID 0x0019 #define PCI_EXPRESS_PMUX_CAP_ID 0x001A #define PCI_EXPRESS_PASID_CAP_ID 0x001B #define PCI_EXPRESS_LN_REQUESTER_CAP_ID 0x001C #define PCI_EXPRESS_DPC_CAP_ID 0x001D #define PCI_EXPRESS_L1_PM_SS_CAP_ID 0x001E #define PCI_EXPRESS_PTM_CAP_ID 0x001F #define PCI_EXPRESS_MPCIE_CAP_ID 0x0020 #define PCI_EXPRESS_FRS_QUEUEING_CAP_ID 0x0021 #define PCI_EXPRESS_READINESS_TIME_REPORTING_CAP_ID 0x0022 // // All Enhanced capabilities have the following header. // typedef struct _PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER { USHORT CapabilityID; USHORT Version:4; USHORT Next:12; } PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER, *PPCI_EXPRESS_ENHANCED_CAPABILITY_HEADER; // // Vendor Specific Capability // typedef struct _PCI_EXPRESS_VENDOR_SPECIFIC_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; USHORT VsecId; USHORT VsecRev:4; USHORT VsecLength:12; } PCI_EXPRESS_VENDOR_SPECIFIC_CAPABILITY, *PPCI_EXPRESS_VENDOR_SPECIFIC_CAPABILITY; // // Serial Number Capability. // typedef struct _PCI_EXPRESS_SERIAL_NUMBER_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; ULONG LowSerialNumber; ULONG HighSerialNumber; } PCI_EXPRESS_SERIAL_NUMBER_CAPABILITY, *PPCI_EXPRESS_SERIAL_NUMBER_CAPABILITY; // // ARI Capability structures // typedef struct _PCI_EXPRESS_ARI_CAPABILITY_REGISTER { USHORT MfvcFunctionGroupsCapability:1; USHORT AcsFunctionGroupsCapability:1; USHORT Reserved:6; USHORT NextFunctionNumber:8; } PCI_EXPRESS_ARI_CAPABILITY_REGISTER, *PPCI_EXPRESS_ARI_CAPABILITY_REGISTER; typedef struct _PCI_EXPRESS_ARI_CONTROL_REGISTER { USHORT MfvcFunctionGroupsEnable:1; USHORT AcsFunctionGroupsEnable:1; USHORT Reserved1:2; USHORT FunctionGroup:3; USHORT Reserved2:9; } PCI_EXPRESS_ARI_CONTROL_REGISTER, *PPCI_EXPRESS_ARI_CONTROL_REGISTER; typedef struct _PCI_EXPRESS_ARI_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_ARI_CAPABILITY_REGISTER Capability; PCI_EXPRESS_ARI_CONTROL_REGISTER Control; } PCI_EXPRESS_ARI_CAPABILITY, *PPCI_EXPRESS_ARI_CAPABILITY; // // Virtual Channel (VC) Capability structures // typedef union _VIRTUAL_CHANNEL_CAPABILITIES1 { struct { ULONG ExtendedVCCount:2; ULONG RsvdP1:1; ULONG LowPriorityExtendedVCCount:2; ULONG RsvdP2:1; ULONG ReferenceClock:2; ULONG PortArbitrationTableEntrySize:2; ULONG RsvdP3:20; }; ULONG AsULONG; } VIRTUAL_CHANNEL_CAPABILITIES1, *PVIRTUAL_CHANNEL_CAPABILITIES1; typedef union _VIRTUAL_CHANNEL_CAPABILITIES2 { struct { ULONG VCArbitrationCapability:8; ULONG RsvdP:16; ULONG VCArbitrationTableOffset:8; }; ULONG AsULONG; } VIRTUAL_CHANNEL_CAPABILITIES2, *PVIRTUAL_CHANNEL_CAPABILITIES2; typedef union _VIRTUAL_CHANNEL_CONTROL { struct { USHORT LoadVCArbitrationTable:1; USHORT VCArbitrationSelect:3; USHORT RsvdP:12; }; USHORT AsUSHORT; } VIRTUAL_CHANNEL_CONTROL, *PVIRTUAL_CHANNEL_CONTROL; typedef union _VIRTUAL_CHANNEL_STATUS { struct { USHORT VCArbitrationTableStatus:1; USHORT RsvdZ:15; }; USHORT AsUSHORT; } VIRTUAL_CHANNEL_STATUS, *PVIRTUAL_CHANNEL_STATUS; typedef union _VIRTUAL_RESOURCE_CAPABILITY { struct { ULONG PortArbitrationCapability:8; ULONG RsvdP1:6; ULONG Undefined:1; ULONG RejectSnoopTransactions:1; ULONG MaximumTimeSlots:7; ULONG RsvdP2:1; ULONG PortArbitrationTableOffset:8; }; ULONG AsULONG; } VIRTUAL_RESOURCE_CAPABILITY, *PVIRTUAL_RESOURCE_CAPABILITY; typedef union _VIRTUAL_RESOURCE_CONTROL { struct { ULONG TcVcMap:8; ULONG RsvdP1:8; ULONG LoadPortArbitrationTable:1; ULONG PortArbitrationSelect:3; ULONG RsvdP2:4; ULONG VcID:3; ULONG RsvdP3:4; ULONG VcEnable:1; }; ULONG AsULONG; } VIRTUAL_RESOURCE_CONTROL, *PVIRTUAL_RESOURCE_CONTROL; typedef union _VIRTUAL_RESOURCE_STATUS { struct { USHORT PortArbitrationTableStatus:1; USHORT VcNegotiationPending:1; USHORT RsvdZ:14; }; USHORT AsUSHORT; } VIRTUAL_RESOURCE_STATUS, *PVIRTUAL_RESOURCE_STATUS; typedef struct _VIRTUAL_RESOURCE { VIRTUAL_RESOURCE_CAPABILITY Capability; VIRTUAL_RESOURCE_CONTROL Control; USHORT RsvdP; VIRTUAL_RESOURCE_STATUS Status; } VIRTUAL_RESOURCE, *PVIRTUAL_RESOURCE; typedef struct _PCI_EXPRESS_VIRTUAL_CHANNEL_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; VIRTUAL_CHANNEL_CAPABILITIES1 Capabilities1; VIRTUAL_CHANNEL_CAPABILITIES2 Capabilities2; VIRTUAL_CHANNEL_CONTROL Control; VIRTUAL_CHANNEL_STATUS Status; VIRTUAL_RESOURCE Resource[8]; } PCI_EXPRESS_VIRTUAL_CHANNEL_CAPABILITY, *PPCI_EXPRESS_VIRTUAL_CHANNEL_CAPABILITY; // // ATS Capability structures // typedef struct _PCI_EXPRESS_ATS_CAPABILITY_REGISTER { USHORT InvalidateQueueDepth:5; USHORT PageAlignedRequest:1; USHORT GlobalInvalidateSupported:1; USHORT Reserved:9; } PCI_EXPRESS_ATS_CAPABILITY_REGISTER, *PPCI_EXPRESS_ATS_CAPABILITY_REGISTER; typedef struct _PCI_EXPRESS_ATS_CONTROL_REGISTER { USHORT SmallestTransactionUnit:5; USHORT Reserved:10; USHORT Enable:1; } PCI_EXPRESS_ATS_CONTROL_REGISTER, *PPCI_EXPRESS_ATS_CONTROL_REGISTER; typedef struct _PCI_EXPRESS_ATS_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_ATS_CAPABILITY_REGISTER Capability; PCI_EXPRESS_ATS_CONTROL_REGISTER Control; } PCI_EXPRESS_ATS_CAPABILITY, *PPCI_EXPRESS_ATS_CAPABILITY; // // PASID Extended Capability Structure // typedef union _PCI_EXPRESS_PASID_CAPABILITY_REGISTER { struct { USHORT Rsvd:1; USHORT ExecutePermissionSupported:1; USHORT PrivilegedModeSupported:1; USHORT Rsvd2:5; USHORT MaxPASIDWidth:5; USHORT Rsvd3:3; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_PASID_CAPABILITY_REGISTER, *PPCI_EXPRESS_PASID_CAPABILITY_REGISTER; typedef union _PCI_EXPRESS_PASID_CONTROL_REGISTER { struct { USHORT PASIDEnable:1; USHORT ExecutePermissionEnable:1; USHORT PrivilegedModeEnable:1; USHORT Rsvd:13; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_PASID_CONTROL_REGISTER, *PPCI_EXPRESS_PASID_CONTROL_REGISTER; typedef struct _PCI_EXPRESS_PASID_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_PASID_CAPABILITY_REGISTER Capability; PCI_EXPRESS_PASID_CONTROL_REGISTER Control; } PCI_EXPRESS_PASID_CAPABILITY, *PPCI_EXPRESS_PASID_CAPABILITY; // // PRI Extended Capability Structure // typedef union _PCI_EXPRESS_PRI_STATUS_REGISTER { struct { USHORT ResponseFailure:1; USHORT UnexpectedPageRequestGroupIndex:1; USHORT Rsvd:6; USHORT Stopped:1; USHORT Rsvd2:6; USHORT PrgResponsePasidRequired:1; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_PRI_STATUS_REGISTER, *PPCI_EXPRESS_PRI_STATUS_REGISTER; typedef union _PCI_EXPRESS_PRI_CONTROL_REGISTER { struct { USHORT Enable:1; USHORT Reset:1; USHORT Rsvd:14; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_PRI_CONTROL_REGISTER, *PPCI_EXPRESS_PRI_CONTROL_REGISTER; typedef struct _PCI_EXPRESS_PRI_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_PRI_CONTROL_REGISTER Control; PCI_EXPRESS_PRI_STATUS_REGISTER Status; ULONG PRCapacity; ULONG PRAllocation; } PCI_EXPRESS_PRI_CAPABILITY, *PPCI_EXPRESS_PRI_CAPABILITY; // // PCI Express Advanced Error Reporting structures. // typedef union _PCI_EXPRESS_UNCORRECTABLE_ERROR_STATUS { struct { ULONG Undefined:1; ULONG Reserved1:3; ULONG DataLinkProtocolError:1; ULONG SurpriseDownError:1; ULONG Reserved2:6; ULONG PoisonedTLP:1; ULONG FlowControlProtocolError:1; ULONG CompletionTimeout:1; ULONG CompleterAbort:1; ULONG UnexpectedCompletion:1; ULONG ReceiverOverflow:1; ULONG MalformedTLP:1; ULONG ECRCError:1; ULONG UnsupportedRequestError:1; ULONG AcsViolation:1; ULONG UncorrectableInternalError:1; ULONG MCBlockedTlp:1; ULONG AtomicOpEgressBlocked:1; ULONG TlpPrefixBlocked:1; ULONG Reserved3:6; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_UNCORRECTABLE_ERROR_STATUS, *PPCI_EXPRESS_UNCORRECTABLE_ERROR_STATUS; typedef union _PCI_EXPRESS_UNCORRECTABLE_ERROR_MASK { struct { ULONG Undefined:1; ULONG Reserved1:3; ULONG DataLinkProtocolError:1; ULONG SurpriseDownError:1; ULONG Reserved2:6; ULONG PoisonedTLP:1; ULONG FlowControlProtocolError:1; ULONG CompletionTimeout:1; ULONG CompleterAbort:1; ULONG UnexpectedCompletion:1; ULONG ReceiverOverflow:1; ULONG MalformedTLP:1; ULONG ECRCError:1; ULONG UnsupportedRequestError:1; ULONG AcsViolation:1; ULONG UncorrectableInternalError:1; ULONG MCBlockedTlp:1; ULONG AtomicOpEgressBlocked:1; ULONG TlpPrefixBlocked:1; ULONG Reserved3:6; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_UNCORRECTABLE_ERROR_MASK, *PPCI_EXPRESS_UNCORRECTABLE_ERROR_MASK; typedef union _PCI_EXPRESS_UNCORRECTABLE_ERROR_SEVERITY { struct { ULONG Undefined:1; ULONG Reserved1:3; ULONG DataLinkProtocolError:1; ULONG SurpriseDownError:1; ULONG Reserved2:6; ULONG PoisonedTLP:1; ULONG FlowControlProtocolError:1; ULONG CompletionTimeout:1; ULONG CompleterAbort:1; ULONG UnexpectedCompletion:1; ULONG ReceiverOverflow:1; ULONG MalformedTLP:1; ULONG ECRCError:1; ULONG UnsupportedRequestError:1; ULONG AcsViolation:1; ULONG UncorrectableInternalError:1; ULONG MCBlockedTlp:1; ULONG AtomicOpEgressBlocked:1; ULONG TlpPrefixBlocked:1; ULONG Reserved3:6; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_UNCORRECTABLE_ERROR_SEVERITY, *PPCI_EXPRESS_UNCORRECTABLE_ERROR_SEVERITY; typedef union _PCI_EXPRESS_CORRECTABLE_ERROR_STATUS { struct { ULONG ReceiverError:1; ULONG Reserved1:5; ULONG BadTLP:1; ULONG BadDLLP:1; ULONG ReplayNumRollover:1; ULONG Reserved2:3; ULONG ReplayTimerTimeout:1; ULONG AdvisoryNonFatalError:1; ULONG CorrectedInternalError:1; ULONG HeaderLogOverflow:1; ULONG Reserved3:16; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_CORRECTABLE_ERROR_STATUS, *PPCI_CORRECTABLE_ERROR_STATUS; typedef union _PCI_EXPRESS_CORRECTABLE_ERROR_MASK { struct { ULONG ReceiverError:1; ULONG Reserved1:5; ULONG BadTLP:1; ULONG BadDLLP:1; ULONG ReplayNumRollover:1; ULONG Reserved2:3; ULONG ReplayTimerTimeout:1; ULONG AdvisoryNonFatalError:1; ULONG CorrectedInternalError:1; ULONG HeaderLogOverflow:1; ULONG Reserved3:16; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_CORRECTABLE_ERROR_MASK, *PPCI_CORRECTABLE_ERROR_MASK; typedef union _PCI_EXPRESS_AER_CAPABILITIES { struct { ULONG FirstErrorPointer:5; ULONG ECRCGenerationCapable:1; ULONG ECRCGenerationEnable:1; ULONG ECRCCheckCapable:1; ULONG ECRCCheckEnable:1; ULONG MultipleHeaderRecordingCapable:1; ULONG MultipleHeaderRecordingEnable:1; ULONG TlpPrefixLogPresent:1; ULONG Reserved:20; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_AER_CAPABILITIES, *PPCI_EXPRESS_AER_CAPABILITIES; typedef union _PCI_EXPRESS_ROOT_ERROR_COMMAND { struct { ULONG CorrectableErrorReportingEnable:1; ULONG NonFatalErrorReportingEnable:1; ULONG FatalErrorReportingEnable:1; ULONG Reserved:29; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_ROOT_ERROR_COMMAND, *PPCI_EXPRESS_ROOT_ERROR_COMMAND; typedef union _PCI_EXPRESS_ROOT_ERROR_STATUS { struct { ULONG CorrectableErrorReceived:1; ULONG MultipleCorrectableErrorsReceived:1; ULONG UncorrectableErrorReceived:1; ULONG MultipleUncorrectableErrorsReceived:1; ULONG FirstUncorrectableFatal:1; ULONG NonFatalErrorMessagesReceived:1; ULONG FatalErrorMessagesReceived:1; ULONG Reserved:20; ULONG AdvancedErrorInterruptMessageNumber:5; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_ROOT_ERROR_STATUS, *PPCI_EXPRESS_ROOT_ERROR_STATUS; typedef union _PCI_EXPRESS_ERROR_SOURCE_ID { struct { USHORT CorrectableSourceIdFun:3; USHORT CorrectableSourceIdDev:5; USHORT CorrectableSourceIdBus:8; USHORT UncorrectableSourceIdFun:3; USHORT UncorrectableSourceIdDev:5; USHORT UncorrectableSourceIdBus:8; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_ERROR_SOURCE_ID, *PPCI_EXPRESS_ERROR_SOURCE_ID; typedef union _PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_STATUS { struct { ULONG TargetAbortOnSplitCompletion:1; ULONG MasterAbortOnSplitCompletion:1; ULONG ReceivedTargetAbort:1; ULONG ReceivedMasterAbort:1; ULONG RsvdZ:1; ULONG UnexpectedSplitCompletionError:1; ULONG UncorrectableSplitCompletion:1; ULONG UncorrectableDataError:1; ULONG UncorrectableAttributeError:1; ULONG UncorrectableAddressError:1; ULONG DelayedTransactionDiscardTimerExpired:1; ULONG PERRAsserted:1; ULONG SERRAsserted:1; ULONG InternalBridgeError:1; ULONG Reserved:18; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_STATUS, *PPCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_STATUS; typedef union _PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_MASK { struct { ULONG TargetAbortOnSplitCompletion:1; ULONG MasterAbortOnSplitCompletion:1; ULONG ReceivedTargetAbort:1; ULONG ReceivedMasterAbort:1; ULONG RsvdZ:1; ULONG UnexpectedSplitCompletionError:1; ULONG UncorrectableSplitCompletion:1; ULONG UncorrectableDataError:1; ULONG UncorrectableAttributeError:1; ULONG UncorrectableAddressError:1; ULONG DelayedTransactionDiscardTimerExpired:1; ULONG PERRAsserted:1; ULONG SERRAsserted:1; ULONG InternalBridgeError:1; ULONG Reserved:18; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_MASK, *PPCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_MASK; typedef union _PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_SEVERITY { struct { ULONG TargetAbortOnSplitCompletion:1; ULONG MasterAbortOnSplitCompletion:1; ULONG ReceivedTargetAbort:1; ULONG ReceivedMasterAbort:1; ULONG RsvdZ:1; ULONG UnexpectedSplitCompletionError:1; ULONG UncorrectableSplitCompletion:1; ULONG UncorrectableDataError:1; ULONG UncorrectableAttributeError:1; ULONG UncorrectableAddressError:1; ULONG DelayedTransactionDiscardTimerExpired:1; ULONG PERRAsserted:1; ULONG SERRAsserted:1; ULONG InternalBridgeError:1; ULONG Reserved:18; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_SEVERITY, *PPCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_SEVERITY; typedef union _PCI_EXPRESS_SEC_AER_CAPABILITIES { struct { ULONG SecondaryUncorrectableFirstErrorPtr:5; ULONG Reserved:27; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_SEC_AER_CAPABILITIES, *PPCI_EXPRESS_SEC_AER_CAPABILITIES; #define ROOT_CMD_ENABLE_CORRECTABLE_ERROR_REPORTING 0x00000001 #define ROOT_CMD_ENABLE_NONFATAL_ERROR_REPORTING 0x00000002 #define ROOT_CMD_ENABLE_FATAL_ERROR_REPORTING 0x00000004 #define ROOT_CMD_ERROR_REPORTING_ENABLE_MASK \ (ROOT_CMD_ENABLE_FATAL_ERROR_REPORTING | \ ROOT_CMD_ENABLE_NONFATAL_ERROR_REPORTING | \ ROOT_CMD_ENABLE_CORRECTABLE_ERROR_REPORTING) // // Advanced Error Reporting Capability structure. // typedef struct _PCI_EXPRESS_AER_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_UNCORRECTABLE_ERROR_STATUS UncorrectableErrorStatus; PCI_EXPRESS_UNCORRECTABLE_ERROR_MASK UncorrectableErrorMask; PCI_EXPRESS_UNCORRECTABLE_ERROR_SEVERITY UncorrectableErrorSeverity; PCI_EXPRESS_CORRECTABLE_ERROR_STATUS CorrectableErrorStatus; PCI_EXPRESS_CORRECTABLE_ERROR_MASK CorrectableErrorMask; PCI_EXPRESS_AER_CAPABILITIES CapabilitiesAndControl; ULONG HeaderLog[4]; PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_STATUS SecUncorrectableErrorStatus; PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_MASK SecUncorrectableErrorMask; PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_SEVERITY SecUncorrectableErrorSeverity; PCI_EXPRESS_SEC_AER_CAPABILITIES SecCapabilitiesAndControl; ULONG SecHeaderLog[4]; } PCI_EXPRESS_AER_CAPABILITY, *PPCI_EXPRESS_AER_CAPABILITY; // // Advanced Error Reporting Capability structure for root port. // typedef struct _PCI_EXPRESS_ROOTPORT_AER_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_UNCORRECTABLE_ERROR_STATUS UncorrectableErrorStatus; PCI_EXPRESS_UNCORRECTABLE_ERROR_MASK UncorrectableErrorMask; PCI_EXPRESS_UNCORRECTABLE_ERROR_SEVERITY UncorrectableErrorSeverity; PCI_EXPRESS_CORRECTABLE_ERROR_STATUS CorrectableErrorStatus; PCI_EXPRESS_CORRECTABLE_ERROR_MASK CorrectableErrorMask; PCI_EXPRESS_AER_CAPABILITIES CapabilitiesAndControl; ULONG HeaderLog[4]; PCI_EXPRESS_ROOT_ERROR_COMMAND RootErrorCommand; PCI_EXPRESS_ROOT_ERROR_STATUS RootErrorStatus; PCI_EXPRESS_ERROR_SOURCE_ID ErrorSourceId; } PCI_EXPRESS_ROOTPORT_AER_CAPABILITY, *PPCI_EXPRESS_ROOTPORT_AER_CAPABILITY; // // Advanced Error Reporting Capability structure for root port. // typedef struct _PCI_EXPRESS_BRIDGE_AER_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_UNCORRECTABLE_ERROR_STATUS UncorrectableErrorStatus; PCI_EXPRESS_UNCORRECTABLE_ERROR_MASK UncorrectableErrorMask; PCI_EXPRESS_UNCORRECTABLE_ERROR_SEVERITY UncorrectableErrorSeverity; PCI_EXPRESS_CORRECTABLE_ERROR_STATUS CorrectableErrorStatus; PCI_EXPRESS_CORRECTABLE_ERROR_MASK CorrectableErrorMask; PCI_EXPRESS_AER_CAPABILITIES CapabilitiesAndControl; ULONG HeaderLog[4]; PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_STATUS SecUncorrectableErrorStatus; PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_MASK SecUncorrectableErrorMask; PCI_EXPRESS_SEC_UNCORRECTABLE_ERROR_SEVERITY SecUncorrectableErrorSeverity; PCI_EXPRESS_SEC_AER_CAPABILITIES SecCapabilitiesAndControl; ULONG SecHeaderLog[4]; } PCI_EXPRESS_BRIDGE_AER_CAPABILITY, *PPCI_EXPRESS_BRIDGE_AER_CAPABILITY; // // Access Control Services Capability structure. // typedef union _PCI_EXPRESS_ACS_CAPABILITY_REGISTER { struct { USHORT SourceValidation:1; USHORT TranslationBlocking:1; USHORT RequestRedirect:1; USHORT CompletionRedirect:1; USHORT UpstreamForwarding:1; USHORT EgressControl:1; USHORT DirectTranslation:1; USHORT Reserved:1; USHORT EgressControlVectorSize:8; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_ACS_CAPABILITY_REGISTER, *PPCI_EXPRESS_ACS_CAPABILITY_REGISTER; typedef union _PCI_EXPRESS_ACS_CONTROL { struct { USHORT SourceValidation:1; USHORT TranslationBlocking:1; USHORT RequestRedirect:1; USHORT CompletionRedirect:1; USHORT UpstreamForwarding:1; USHORT EgressControl:1; USHORT DirectTranslation:1; USHORT Reserved:9; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_ACS_CONTROL, *PPCI_EXPRESS_ACS_CONTROL; typedef struct _PCI_EXPRESS_ACS_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_ACS_CAPABILITY_REGISTER Capability; PCI_EXPRESS_ACS_CONTROL Control; ULONG EgressControl[1]; } PCI_EXPRESS_ACS_CAPABILITY, *PPCI_EXPRESS_ACS_CAPABILITY ; // // Single-Root I/O Virtualization Capability structure for endpoints // typedef union _PCI_EXPRESS_SRIOV_CAPS { struct { ULONG VFMigrationCapable:1; ULONG Reserved1:20; ULONG VFMigrationInterruptNumber:11; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_SRIOV_CAPS, *PPCI_EXPRESS_SRIOV_CAPS; typedef union _PCI_EXPRESS_SRIOV_CONTROL { struct { USHORT VFEnable:1; USHORT VFMigrationEnable:1; USHORT VFMigrationInterruptEnable:1; USHORT VFMemorySpaceEnable:1; USHORT ARICapableHierarchy:1; USHORT Reserved1:11; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_SRIOV_CONTROL, *PPCI_EXPRESS_SRIOV_CONTROL; typedef union _PCI_EXPRESS_SRIOV_STATUS { struct { USHORT VFMigrationStatus:1; USHORT Reserved1:15; } DUMMYSTRUCTNAME; USHORT AsUSHORT; } PCI_EXPRESS_SRIOV_STATUS, *PPCI_EXPRESS_SRIOV_STATUS; typedef union _PCI_EXPRESS_SRIOV_MIGRATION_STATE_ARRAY { struct { ULONG VFMigrationStateBIR:3; ULONG VFMigrationStateOffset:29; } DUMMYSTRUCTNAME; ULONG AsULONG; } PCI_EXPRESS_SRIOV_MIGRATION_STATE_ARRAY, *PPCI_EXPRESS_SRIOV_MIGRATION_STATE_ARRAY; typedef struct _PCI_EXPRESS_SRIOV_CAPABILITY { PCI_EXPRESS_ENHANCED_CAPABILITY_HEADER Header; PCI_EXPRESS_SRIOV_CAPS SRIOVCapabilities; PCI_EXPRESS_SRIOV_CONTROL SRIOVControl; PCI_EXPRESS_SRIOV_STATUS SRIOVStatus; USHORT InitialVFs; USHORT TotalVFs; USHORT NumVFs; UCHAR FunctionDependencyLink; UCHAR RsvdP1; USHORT FirstVFOffset; USHORT VFStride; USHORT RsvdP2; USHORT VFDeviceId; ULONG SupportedPageSizes; ULONG SystemPageSize; ULONG BaseAddresses[PCI_TYPE0_ADDRESSES]; PCI_EXPRESS_SRIOV_MIGRATION_STATE_ARRAY VFMigrationStateArrayOffset; } PCI_EXPRESS_SRIOV_CAPABILITY, *PPCI_EXPRESS_SRIOV_CAPABILITY; // // Base Class Code encodings for Base Class (from PCI spec rev 2.1). // #define PCI_CLASS_PRE_20 0x00 #define PCI_CLASS_MASS_STORAGE_CTLR 0x01 #define PCI_CLASS_NETWORK_CTLR 0x02 #define PCI_CLASS_DISPLAY_CTLR 0x03 #define PCI_CLASS_MULTIMEDIA_DEV 0x04 #define PCI_CLASS_MEMORY_CTLR 0x05 #define PCI_CLASS_BRIDGE_DEV 0x06 #define PCI_CLASS_SIMPLE_COMMS_CTLR 0x07 #define PCI_CLASS_BASE_SYSTEM_DEV 0x08 #define PCI_CLASS_INPUT_DEV 0x09 #define PCI_CLASS_DOCKING_STATION 0x0a #define PCI_CLASS_PROCESSOR 0x0b #define PCI_CLASS_SERIAL_BUS_CTLR 0x0c #define PCI_CLASS_WIRELESS_CTLR 0x0d #define PCI_CLASS_INTELLIGENT_IO_CTLR 0x0e #define PCI_CLASS_SATELLITE_COMMS_CTLR 0x0f #define PCI_CLASS_ENCRYPTION_DECRYPTION 0x10 #define PCI_CLASS_DATA_ACQ_SIGNAL_PROC 0x11 // 0d thru fe reserved #define PCI_CLASS_NOT_DEFINED 0xff // // Sub Class Code encodings (PCI rev 2.1). // // Class 00 - PCI_CLASS_PRE_20 #define PCI_SUBCLASS_PRE_20_NON_VGA 0x00 #define PCI_SUBCLASS_PRE_20_VGA 0x01 // Class 01 - PCI_CLASS_MASS_STORAGE_CTLR #define PCI_SUBCLASS_MSC_SCSI_BUS_CTLR 0x00 #define PCI_SUBCLASS_MSC_IDE_CTLR 0x01 #define PCI_SUBCLASS_MSC_FLOPPY_CTLR 0x02 #define PCI_SUBCLASS_MSC_IPI_CTLR 0x03 #define PCI_SUBCLASS_MSC_RAID_CTLR 0x04 #define PCI_SUBCLASS_MSC_AHCI_CTLR 0x06 #define PCI_SUBCLASS_MSC_NVM_CTLR 0x08 #define PCI_SUBCLASS_MSC_OTHER 0x80 // SubClass 08 - PCI_SUBCLASS_MSC_NVM_CTLR #define PCI_PROGRAMMING_INTERFACE_MSC_NVM_EXPRESS 0x02 // Class 02 - PCI_CLASS_NETWORK_CTLR #define PCI_SUBCLASS_NET_ETHERNET_CTLR 0x00 #define PCI_SUBCLASS_NET_TOKEN_RING_CTLR 0x01 #define PCI_SUBCLASS_NET_FDDI_CTLR 0x02 #define PCI_SUBCLASS_NET_ATM_CTLR 0x03 #define PCI_SUBCLASS_NET_ISDN_CTLR 0x04 #define PCI_SUBCLASS_NET_OTHER 0x80 // Class 03 - PCI_CLASS_DISPLAY_CTLR // N.B. Sub Class 00 could be VGA or 8514 depending on Interface byte #define PCI_SUBCLASS_VID_VGA_CTLR 0x00 #define PCI_SUBCLASS_VID_XGA_CTLR 0x01 #define PCI_SUBLCASS_VID_3D_CTLR 0x02 #define PCI_SUBCLASS_VID_OTHER 0x80 // Class 04 - PCI_CLASS_MULTIMEDIA_DEV #define PCI_SUBCLASS_MM_VIDEO_DEV 0x00 #define PCI_SUBCLASS_MM_AUDIO_DEV 0x01 #define PCI_SUBCLASS_MM_TELEPHONY_DEV 0x02 #define PCI_SUBCLASS_MM_OTHER 0x80 // Class 05 - PCI_CLASS_MEMORY_CTLR #define PCI_SUBCLASS_MEM_RAM 0x00 #define PCI_SUBCLASS_MEM_FLASH 0x01 #define PCI_SUBCLASS_MEM_OTHER 0x80 // Class 06 - PCI_CLASS_BRIDGE_DEV #define PCI_SUBCLASS_BR_HOST 0x00 #define PCI_SUBCLASS_BR_ISA 0x01 #define PCI_SUBCLASS_BR_EISA 0x02 #define PCI_SUBCLASS_BR_MCA 0x03 #define PCI_SUBCLASS_BR_PCI_TO_PCI 0x04 #define PCI_SUBCLASS_BR_PCMCIA 0x05 #define PCI_SUBCLASS_BR_NUBUS 0x06 #define PCI_SUBCLASS_BR_CARDBUS 0x07 #define PCI_SUBCLASS_BR_RACEWAY 0x08 #define PCI_SUBCLASS_BR_OTHER 0x80 // Class 07 - PCI_CLASS_SIMPLE_COMMS_CTLR // N.B. Sub Class 00 and 01 additional info in Interface byte #define PCI_SUBCLASS_COM_SERIAL 0x00 #define PCI_SUBCLASS_COM_PARALLEL 0x01 #define PCI_SUBCLASS_COM_MULTIPORT 0x02 #define PCI_SUBCLASS_COM_MODEM 0x03 #define PCI_SUBCLASS_COM_OTHER 0x80 // Class 08 - PCI_CLASS_BASE_SYSTEM_DEV // N.B. See Interface byte for additional info. #define PCI_SUBCLASS_SYS_INTERRUPT_CTLR 0x00 #define PCI_SUBCLASS_SYS_DMA_CTLR 0x01 #define PCI_SUBCLASS_SYS_SYSTEM_TIMER 0x02 #define PCI_SUBCLASS_SYS_REAL_TIME_CLOCK 0x03 #define PCI_SUBCLASS_SYS_GEN_HOTPLUG_CTLR 0x04 #define PCI_SUBCLASS_SYS_SDIO_CTRL 0x05 #define PCI_SUBCLASS_SYS_OTHER 0x80 // Class 09 - PCI_CLASS_INPUT_DEV #define PCI_SUBCLASS_INP_KEYBOARD 0x00 #define PCI_SUBCLASS_INP_DIGITIZER 0x01 #define PCI_SUBCLASS_INP_MOUSE 0x02 #define PCI_SUBCLASS_INP_SCANNER 0x03 #define PCI_SUBCLASS_INP_GAMEPORT 0x04 #define PCI_SUBCLASS_INP_OTHER 0x80 // Class 0a - PCI_CLASS_DOCKING_STATION #define PCI_SUBCLASS_DOC_GENERIC 0x00 #define PCI_SUBCLASS_DOC_OTHER 0x80 // Class 0b - PCI_CLASS_PROCESSOR #define PCI_SUBCLASS_PROC_386 0x00 #define PCI_SUBCLASS_PROC_486 0x01 #define PCI_SUBCLASS_PROC_PENTIUM 0x02 #define PCI_SUBCLASS_PROC_ALPHA 0x10 #define PCI_SUBCLASS_PROC_POWERPC 0x20 #define PCI_SUBCLASS_PROC_COPROCESSOR 0x40 // Class 0c - PCI_CLASS_SERIAL_BUS_CTLR #define PCI_SUBCLASS_SB_IEEE1394 0x00 #define PCI_SUBCLASS_SB_ACCESS 0x01 #define PCI_SUBCLASS_SB_SSA 0x02 #define PCI_SUBCLASS_SB_USB 0x03 #define PCI_SUBCLASS_SB_FIBRE_CHANNEL 0x04 #define PCI_SUBCLASS_SB_SMBUS 0x05 #define PCI_SUBCLASS_SB_THUNDERBOLT 0x0A // Class 0d - PCI_CLASS_WIRELESS_CTLR #define PCI_SUBCLASS_WIRELESS_IRDA 0x00 #define PCI_SUBCLASS_WIRELESS_CON_IR 0x01 #define PCI_SUBCLASS_WIRELESS_RF 0x10 #define PCI_SUBCLASS_WIRELESS_OTHER 0x80 // Class 0e - PCI_CLASS_INTELLIGENT_IO_CTLR #define PCI_SUBCLASS_INTIO_I2O 0x00 // Class 0f - PCI_CLASS_SATELLITE_CTLR #define PCI_SUBCLASS_SAT_TV 0x01 #define PCI_SUBCLASS_SAT_AUDIO 0x02 #define PCI_SUBCLASS_SAT_VOICE 0x03 #define PCI_SUBCLASS_SAT_DATA 0x04 // Class 10 - PCI_CLASS_ENCRYPTION_DECRYPTION #define PCI_SUBCLASS_CRYPTO_NET_COMP 0x00 #define PCI_SUBCLASS_CRYPTO_ENTERTAINMENT 0x10 #define PCI_SUBCLASS_CRYPTO_OTHER 0x80 // Class 11 - PCI_CLASS_DATA_ACQ_SIGNAL_PROC #define PCI_SUBCLASS_DASP_DPIO 0x00 #define PCI_SUBCLASS_DASP_OTHER 0x80 // // Bit encodes for PCI_COMMON_CONFIG.u.type0.BaseAddresses // #define PCI_ADDRESS_IO_SPACE 0x00000001 // (ro) #define PCI_ADDRESS_MEMORY_TYPE_MASK 0x00000006 // (ro) #define PCI_ADDRESS_MEMORY_PREFETCHABLE 0x00000008 // (ro) #define PCI_ADDRESS_IO_ADDRESS_MASK 0xfffffffc #define PCI_ADDRESS_MEMORY_ADDRESS_MASK 0xfffffff0 #define PCI_ADDRESS_ROM_ADDRESS_MASK 0xfffff800 #define PCI_TYPE_32BIT 0 #define PCI_TYPE_20BIT 2 #define PCI_TYPE_64BIT 4 // // Bit encodes for PCI_COMMON_CONFIG.u.type0.ROMBaseAddresses // #define PCI_ROMADDRESS_ENABLED 0x00000001 // // Reference notes for PCI configuration fields: // // ro these field are read only. changes to these fields are ignored // // ro+ these field are intended to be read only and should be initialized // by the system to their proper values. However, driver may change // these settings. // // --- // // All resources comsumed by a PCI device start as unitialized // under NT. An uninitialized memory or I/O base address can be // determined by checking it's corrisponding enabled bit in the // PCI_COMMON_CONFIG.Command value. An InterruptLine is unitialized // if it contains the value of -1. // #endif // _PCI_X_ // // Device Presence interface // #define PCI_DEVICE_PRESENT_INTERFACE_VERSION 1 // // Flags for PCI_DEVICE_PRESENCE_PARAMETERS // #define PCI_USE_SUBSYSTEM_IDS 0x00000001 #define PCI_USE_REVISION 0x00000002 // The following flags are only valid for IsDevicePresentEx #define PCI_USE_VENDEV_IDS 0x00000004 #define PCI_USE_CLASS_SUBCLASS 0x00000008 #define PCI_USE_PROGIF 0x00000010 #define PCI_USE_LOCAL_BUS 0x00000020 #define PCI_USE_LOCAL_DEVICE 0x00000040 // // Search parameters structure for IsDevicePresentEx // typedef struct _PCI_DEVICE_PRESENCE_PARAMETERS { ULONG Size; ULONG Flags; USHORT VendorID; USHORT DeviceID; UCHAR RevisionID; USHORT SubVendorID; USHORT SubSystemID; UCHAR BaseClass; UCHAR SubClass; UCHAR ProgIf; } PCI_DEVICE_PRESENCE_PARAMETERS, *PPCI_DEVICE_PRESENCE_PARAMETERS; _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ typedef BOOLEAN PCI_IS_DEVICE_PRESENT ( _In_ USHORT VendorID, _In_ USHORT DeviceID, _In_ UCHAR RevisionID, _In_ USHORT SubVendorID, _In_ USHORT SubSystemID, _In_ ULONG Flags ); typedef PCI_IS_DEVICE_PRESENT *PPCI_IS_DEVICE_PRESENT; _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ typedef BOOLEAN PCI_IS_DEVICE_PRESENT_EX ( _In_ PVOID Context, _In_ PPCI_DEVICE_PRESENCE_PARAMETERS Parameters ); typedef PCI_IS_DEVICE_PRESENT_EX *PPCI_IS_DEVICE_PRESENT_EX; typedef struct _PCI_DEVICE_PRESENT_INTERFACE { // // generic interface header // USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; // // pci device info // PPCI_IS_DEVICE_PRESENT IsDevicePresent; PPCI_IS_DEVICE_PRESENT_EX IsDevicePresentEx; } PCI_DEVICE_PRESENT_INTERFACE, *PPCI_DEVICE_PRESENT_INTERFACE; // // Pci Express Link Quiesce Interface // #define PCI_EXPRESS_LINK_QUIESCENT_INTERFACE_VERSION 1 _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ typedef NTSTATUS PCI_EXPRESS_ENTER_LINK_QUIESCENT_MODE ( _Inout_ PVOID Context ); typedef PCI_EXPRESS_ENTER_LINK_QUIESCENT_MODE *PPCI_EXPRESS_ENTER_LINK_QUIESCENT_MODE; _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ typedef NTSTATUS PCI_EXPRESS_EXIT_LINK_QUIESCENT_MODE ( _Inout_ PVOID Context ); typedef PCI_EXPRESS_EXIT_LINK_QUIESCENT_MODE *PPCI_EXPRESS_EXIT_LINK_QUIESCENT_MODE; typedef struct _PCI_EXPRESS_LINK_QUIESCENT_INTERFACE { USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; PPCI_EXPRESS_ENTER_LINK_QUIESCENT_MODE PciExpressEnterLinkQuiescentMode; PPCI_EXPRESS_EXIT_LINK_QUIESCENT_MODE PciExpressExitLinkQuiescentMode; } PCI_EXPRESS_LINK_QUIESCENT_INTERFACE, *PPCI_EXPRESS_LINK_QUIESCENT_INTERFACE; // // Pci Express Root Port Access Interface // #define PCI_EXPRESS_ROOT_PORT_INTERFACE_VERSION 1 typedef ULONG (*PPCI_EXPRESS_ROOT_PORT_READ_CONFIG_SPACE) ( _In_ PVOID Context, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Offset, _In_ ULONG Length ); typedef ULONG (*PPCI_EXPRESS_ROOT_PORT_WRITE_CONFIG_SPACE) ( _In_ PVOID Context, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Offset, _In_ ULONG Length ); typedef struct _PCI_EXPRESS_ROOT_PORT_INTERFACE { USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; PPCI_EXPRESS_ROOT_PORT_READ_CONFIG_SPACE ReadConfigSpace; PPCI_EXPRESS_ROOT_PORT_WRITE_CONFIG_SPACE WriteConfigSpace; } PCI_EXPRESS_ROOT_PORT_INTERFACE, *PPCI_EXPRESS_ROOT_PORT_INTERFACE; // // MSI-X interrupt table configuration interface // #define PCI_MSIX_TABLE_CONFIG_INTERFACE_VERSION 1 _Must_inspect_result_ typedef NTSTATUS PCI_MSIX_SET_ENTRY ( _In_ PVOID Context, _In_ ULONG TableEntry, _In_ ULONG MessageNumber ); typedef PCI_MSIX_SET_ENTRY *PPCI_MSIX_SET_ENTRY; _Must_inspect_result_ typedef NTSTATUS PCI_MSIX_MASKUNMASK_ENTRY ( _In_ PVOID Context, _In_ ULONG TableEntry ); typedef PCI_MSIX_MASKUNMASK_ENTRY *PPCI_MSIX_MASKUNMASK_ENTRY; _Must_inspect_result_ typedef NTSTATUS PCI_MSIX_GET_ENTRY ( _In_ PVOID Context, _In_ ULONG TableEntry, _Out_ PULONG MessageNumber, _Out_ PBOOLEAN Masked ); typedef PCI_MSIX_GET_ENTRY *PPCI_MSIX_GET_ENTRY; _Must_inspect_result_ typedef NTSTATUS PCI_MSIX_GET_TABLE_SIZE ( _In_ PVOID Context, _Out_ PULONG TableSize ); typedef PCI_MSIX_GET_TABLE_SIZE *PPCI_MSIX_GET_TABLE_SIZE; typedef struct _PCI_MSIX_TABLE_CONFIG_INTERFACE { USHORT Size; USHORT Version; PVOID Context; PINTERFACE_REFERENCE InterfaceReference; PINTERFACE_DEREFERENCE InterfaceDereference; PPCI_MSIX_SET_ENTRY SetTableEntry; PPCI_MSIX_MASKUNMASK_ENTRY MaskTableEntry; PPCI_MSIX_MASKUNMASK_ENTRY UnmaskTableEntry; PPCI_MSIX_GET_ENTRY GetTableEntry; PPCI_MSIX_GET_TABLE_SIZE GetTableSize; } PCI_MSIX_TABLE_CONFIG_INTERFACE, *PPCI_MSIX_TABLE_CONFIG_INTERFACE; #define PCI_MSIX_TABLE_CONFIG_MINIMUM_SIZE \ RTL_SIZEOF_THROUGH_FIELD(PCI_MSIX_TABLE_CONFIG_INTERFACE, UnmaskTableEntry) #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwCreateFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_opt_ PLARGE_INTEGER AllocationSize, _In_ ULONG FileAttributes, _In_ ULONG ShareAccess, _In_ ULONG CreateDisposition, _In_ ULONG CreateOptions, _In_reads_bytes_opt_(EaLength) PVOID EaBuffer, _In_ ULONG EaLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwOpenFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG ShareAccess, _In_ ULONG OpenOptions ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwLoadDriver( _In_ PUNICODE_STRING DriverServiceName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwUnloadDriver( _In_ PUNICODE_STRING DriverServiceName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwQueryInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwSetInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_reads_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwReadFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _In_opt_ PLARGE_INTEGER ByteOffset, _In_opt_ PULONG Key ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwWriteFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _In_opt_ PLARGE_INTEGER ByteOffset, _In_opt_ PULONG Key ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwClose( _In_ HANDLE Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwCreateDirectoryObject( _Out_ PHANDLE DirectoryHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwMakeTemporaryObject( _In_ HANDLE Handle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(APC_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwCreateSection ( _Out_ PHANDLE SectionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PLARGE_INTEGER MaximumSize, _In_ ULONG SectionPageProtection, _In_ ULONG AllocationAttributes, _In_opt_ HANDLE FileHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwOpenSection( _Out_ PHANDLE SectionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _Must_inspect_result_ _Post_satisfies_(*ViewSize >= _Old_(*ViewSize)) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwMapViewOfSection( _In_ HANDLE SectionHandle, _In_ HANDLE ProcessHandle, _Outptr_result_bytebuffer_(*ViewSize) PVOID *BaseAddress, _In_ ULONG_PTR ZeroBits, _In_ SIZE_T CommitSize, _Inout_opt_ PLARGE_INTEGER SectionOffset, _Inout_ PSIZE_T ViewSize, _In_ SECTION_INHERIT InheritDisposition, _In_ ULONG AllocationType, _In_ ULONG Win32Protect ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwUnmapViewOfSection( _In_ HANDLE ProcessHandle, _In_opt_ PVOID BaseAddress ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwCreateKey( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Reserved_ ULONG TitleIndex, _In_opt_ PUNICODE_STRING Class, _In_ ULONG CreateOptions, _Out_opt_ PULONG Disposition ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS ZwCreateKeyTransacted( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Reserved_ ULONG TitleIndex, _In_opt_ PUNICODE_STRING Class, _In_ ULONG CreateOptions, _In_ HANDLE TransactionHandle, _Out_opt_ PULONG Disposition ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_TH2) _Must_inspect_result_ _IRQL_requires_max_ (PASSIVE_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI ZwCreateRegistryTransaction ( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG CreateOptions ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_TH2) _Must_inspect_result_ _IRQL_requires_max_ (PASSIVE_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtOpenRegistryTransaction ( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_TH2) _IRQL_requires_max_ (PASSIVE_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI ZwCommitRegistryTransaction ( _In_ HANDLE TransactionHandle, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_TH2) _IRQL_requires_max_ (PASSIVE_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtRollbackRegistryTransaction ( _In_ HANDLE TransactionHandle, _In_ ULONG Flags ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwOpenKey( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwOpenKeyEx( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ ULONG OpenOptions ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwOpenKeyTransacted( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE TransactionHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwOpenKeyTransactedEx( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ ULONG OpenOptions, _In_ HANDLE TransactionHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwDeleteKey( _In_ HANDLE KeyHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwDeleteValueKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _When_(Length == 0, _Post_satisfies_(return < 0)) _When_(Length > 0, _Post_satisfies_(return <= 0)) NTSYSAPI NTSTATUS NTAPI ZwEnumerateKey( _In_ HANDLE KeyHandle, _In_ ULONG Index, _In_ KEY_INFORMATION_CLASS KeyInformationClass, _Out_writes_bytes_opt_(Length) PVOID KeyInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _When_(Length == 0, _Post_satisfies_(return < 0)) _When_(Length > 0, _Post_satisfies_(return <= 0)) NTSYSAPI NTSTATUS NTAPI ZwEnumerateValueKey( _In_ HANDLE KeyHandle, _In_ ULONG Index, _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, _Out_writes_bytes_opt_(Length) PVOID KeyValueInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwFlushKey( _In_ HANDLE KeyHandle ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _When_(Length == 0, _Post_satisfies_(return < 0)) _When_(Length > 0, _Post_satisfies_(return <= 0)) NTSYSAPI NTSTATUS NTAPI ZwQueryKey( _In_ HANDLE KeyHandle, _In_ KEY_INFORMATION_CLASS KeyInformationClass, _Out_writes_bytes_opt_(Length) PVOID KeyInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) _When_(Length == 0, _Post_satisfies_(return < 0)) _When_(Length > 0, _Post_satisfies_(return <= 0)) _When_(return == STATUS_BUFFER_TOO_SMALL, _At_(ResultLength, _Post_valid_)) _When_(return == STATUS_BUFFER_OVERFLOW, _At_(ResultLength, _Post_valid_)) NTSYSAPI NTSTATUS NTAPI ZwQueryValueKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName, _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, _Out_writes_bytes_opt_(Length) PVOID KeyValueInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwRenameKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING NewName ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwSaveKey ( _In_ HANDLE KeyHandle, _In_ HANDLE FileHandle ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwSaveKeyEx ( _In_ HANDLE KeyHandle, _In_ HANDLE FileHandle, _In_ ULONG Format ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwRestoreKey ( _In_ HANDLE KeyHandle, _In_opt_ HANDLE FileHandle, _In_ ULONG Flags ); _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwSetInformationKey ( _In_ HANDLE KeyHandle, _In_ __drv_strictTypeMatch(__drv_typeConst) KEY_SET_INFORMATION_CLASS KeySetInformationClass, _In_reads_bytes_(KeySetInformationLength) PVOID KeySetInformation, _In_ ULONG KeySetInformationLength ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwSetValueKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName, _In_opt_ ULONG TitleIndex, _In_ ULONG Type, _In_reads_bytes_opt_(DataSize) PVOID Data, _In_ ULONG DataSize ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwOpenSymbolicLinkObject( _Out_ PHANDLE LinkHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwQuerySymbolicLinkObject( _In_ HANDLE LinkHandle, _Inout_ PUNICODE_STRING LinkTarget, _Out_opt_ PULONG ReturnedLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwCreateTransactionManager ( _Out_ PHANDLE TmHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PUNICODE_STRING LogFileName, _In_opt_ ULONG CreateOptions, _In_opt_ ULONG CommitStrength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwOpenTransactionManager ( _Out_ PHANDLE TmHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PUNICODE_STRING LogFileName, _In_opt_ LPGUID TmIdentity, _In_opt_ ULONG OpenOptions ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwRollforwardTransactionManager ( _In_ HANDLE TransactionManagerHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwRecoverTransactionManager ( _In_ HANDLE TransactionManagerHandle ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwQueryInformationTransactionManager ( _In_ HANDLE TransactionManagerHandle, _In_ TRANSACTIONMANAGER_INFORMATION_CLASS TransactionManagerInformationClass, _Out_writes_bytes_(TransactionManagerInformationLength) PVOID TransactionManagerInformation, _In_ ULONG TransactionManagerInformationLength, _Out_opt_ PULONG ReturnLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwSetInformationTransactionManager ( _In_ HANDLE TmHandle, _In_ TRANSACTIONMANAGER_INFORMATION_CLASS TransactionManagerInformationClass, _In_ PVOID TransactionManagerInformation, _In_ ULONG TransactionManagerInformationLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwEnumerateTransactionObject ( _In_opt_ HANDLE RootObjectHandle, _In_ KTMOBJECT_TYPE QueryType, _Inout_updates_bytes_(ObjectCursorLength) PKTMOBJECT_CURSOR ObjectCursor, _In_ ULONG ObjectCursorLength, _Out_ PULONG ReturnLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwCreateTransaction ( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ LPGUID Uow, _In_opt_ HANDLE TmHandle, _In_opt_ ULONG CreateOptions, _In_opt_ ULONG IsolationLevel, _In_opt_ ULONG IsolationFlags, _In_opt_ PLARGE_INTEGER Timeout, _In_opt_ PUNICODE_STRING Description ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwOpenTransaction ( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ LPGUID Uow, _In_opt_ HANDLE TmHandle ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwQueryInformationTransaction ( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _Out_writes_bytes_(TransactionInformationLength) PVOID TransactionInformation, _In_ ULONG TransactionInformationLength, _Out_opt_ PULONG ReturnLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwSetInformationTransaction ( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _In_ PVOID TransactionInformation, _In_ ULONG TransactionInformationLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwCommitTransaction ( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwRollbackTransaction ( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwCreateResourceManager ( _Out_ PHANDLE ResourceManagerHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE TmHandle, _In_opt_ LPGUID ResourceManagerGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG CreateOptions, _In_opt_ PUNICODE_STRING Description ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwOpenResourceManager ( _Out_ PHANDLE ResourceManagerHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE TmHandle, _In_ LPGUID ResourceManagerGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwRecoverResourceManager ( _In_ HANDLE ResourceManagerHandle ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwGetNotificationResourceManager ( _In_ HANDLE ResourceManagerHandle, _Out_ PTRANSACTION_NOTIFICATION TransactionNotification, _In_ ULONG NotificationLength, _In_ PLARGE_INTEGER Timeout, _Out_opt_ PULONG ReturnLength, _In_ ULONG Asynchronous, _In_opt_ ULONG_PTR AsynchronousContext ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwQueryInformationResourceManager ( _In_ HANDLE ResourceManagerHandle, _In_ RESOURCEMANAGER_INFORMATION_CLASS ResourceManagerInformationClass, _Out_writes_bytes_(ResourceManagerInformationLength) PVOID ResourceManagerInformation, _In_ ULONG ResourceManagerInformationLength, _Out_opt_ PULONG ReturnLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwSetInformationResourceManager ( _In_ HANDLE ResourceManagerHandle, _In_ RESOURCEMANAGER_INFORMATION_CLASS ResourceManagerInformationClass, _In_reads_bytes_(ResourceManagerInformationLength) PVOID ResourceManagerInformation, _In_ ULONG ResourceManagerInformationLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwCreateEnlistment ( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE ResourceManagerHandle, _In_ HANDLE TransactionHandle, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG CreateOptions, _In_ NOTIFICATION_MASK NotificationMask, _In_opt_ PVOID EnlistmentKey ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwOpenEnlistment ( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE RmHandle, _In_ LPGUID EnlistmentGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwQueryInformationEnlistment ( _In_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS EnlistmentInformationClass, _Out_writes_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformation, _In_ ULONG EnlistmentInformationLength, _Out_opt_ PULONG ReturnLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwSetInformationEnlistment ( _In_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS EnlistmentInformationClass, _In_reads_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformation, _In_ ULONG EnlistmentInformationLength ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwRecoverEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PVOID EnlistmentKey ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwPrePrepareEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwPrepareEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwCommitEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwRollbackEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwPrePrepareComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwPrepareComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwCommitComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwReadOnlyEnlistment ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) NTSYSCALLAPI NTSTATUS NTAPI ZwRollbackComplete ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_VISTA) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwSinglePhaseReject ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); #endif #if (NTDDI_VERSION >= NTDDI_WS03) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSCALLAPI NTSTATUS NTAPI ZwOpenEvent ( _Out_ PHANDLE EventHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif #if (NTDDI_VERSION >= NTDDI_WIN2K) _IRQL_requires_max_(PASSIVE_LEVEL) NTSYSAPI NTSTATUS NTAPI ZwQueryFullAttributesFile( _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PFILE_NETWORK_OPEN_INFORMATION FileInformation ); #endif #ifndef _CLFS_PUBLIC_H_ #define _CLFS_PUBLIC_H_ #if !defined(CLFSUSER_API) #if defined(__CLFSUSER_EXPORTS__) #define CLFSUSER_API #else #define CLFSUSER_API __declspec(dllimport) #endif #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // FILE_ATTRIBUTE_DEDICATED is defined as FILE_ATTRIBUTE_TEMPORARY. // #define FILE_ATTRIBUTE_DEDICATED FILE_ATTRIBUTE_TEMPORARY // // Container name and container size extended attribute entry names. // #define EA_CONTAINER_NAME "ContainerName" #define EA_CONTAINER_SIZE "ContainerSize" // // Base log file name 3-letter extension. // #define CLFS_BASELOG_EXTENSION L".blf" // // Common log file system public flags and constants. // #define CLFS_FLAG_NO_FLAGS 0x00000000 // No flags. #define CLFS_FLAG_FORCE_APPEND 0x00000001 // Flag to force an append to log queue #define CLFS_FLAG_FORCE_FLUSH 0x00000002 // Flag to force a log flush #define CLFS_FLAG_USE_RESERVATION 0x00000004 // Flag to charge a data append to reservation #define CLFS_FLAG_REENTRANT_FILE_SYSTEM 0x00000008 // Kernel mode create flag indicating a re-entrant file system. #define CLFS_FLAG_NON_REENTRANT_FILTER 0x00000010 // Kernel mode create flag indicating non-reentrant filter. #define CLFS_FLAG_REENTRANT_FILTER 0x00000020 // Kernel mode create flag indicating reentrant filter. #define CLFS_FLAG_IGNORE_SHARE_ACCESS 0x00000040 // Kernel mode create flag indicating IO_IGNORE_SHARE_ACCESS_CHECK semantics. #define CLFS_FLAG_READ_IN_PROGRESS 0x00000080 // Flag indicating read in progress and not completed. #define CLFS_FLAG_MINIFILTER_LEVEL 0x00000100 // Kernel mode create flag indicating mini-filter target. #define CLFS_FLAG_HIDDEN_SYSTEM_LOG 0x00000200 // Kernel mode create flag indicating the log and containers should be marked hidden & system. // // Flag indicating all CLFS I/O will be targeted to an intermediate level of the I/O stack // #define CLFS_FLAG_FILTER_INTERMEDIATE_LEVEL CLFS_FLAG_NON_REENTRANT_FILTER // // Flag indicating all CLFS I/O will be targeted to the top level of the I/O stack // #define CLFS_FLAG_FILTER_TOP_LEVEL CLFS_FLAG_REENTRANT_FILTER // // CLFS_CONTAINER_INDEX // // Index into the container table. // typedef ULONG CLFS_CONTAINER_ID; typedef CLFS_CONTAINER_ID *PCLFS_CONTAINER_ID; typedef CLFS_CONTAINER_ID **PPCLFS_CONTAINER_ID; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #ifdef __CLFS_PRIVATE_LSN__ #include #else #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_LSN // typedef struct _CLS_LSN { ULONGLONG Internal; } CLS_LSN, *PCLS_LSN, **PPCLS_LSN; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #endif /* __CLFS_PRIVATE_LSN__ */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Alias CLS prefixed types with CLFS prefixes. // typedef CLS_LSN CLFS_LSN; typedef CLFS_LSN *PCLFS_LSN, **PPCLFS_LSN; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) extern __declspec(dllimport) const CLFS_LSN CLFS_LSN_INVALID; extern __declspec(dllimport) const CLFS_LSN CLFS_LSN_NULL; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #ifdef __cplusplus } #endif /* __cplusplus */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_RECORD_TYPE // // Definition of record types. // #ifdef __cplusplus const UCHAR ClfsNullRecord = 0x00; // Null record type. const UCHAR ClfsDataRecord = 0x01; // Client data record. const UCHAR ClfsRestartRecord = 0x02; // Restart record. // Valid client records are restart and data records. const UCHAR ClfsClientRecord = 0x03; #else #define ClfsNullRecord 0x00 // Null record type. #define ClfsDataRecord 0x01 // Client data record. #define ClfsRestartRecord 0x02 // Restart record. // Valid client records are restart and data records. #define ClfsClientRecord (ClfsDataRecord|ClfsRestartRecord) #endif /* _cplusplus */ #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Log container path prefix indicating the log container's location is // actually a stream inside of the BLF. // #ifdef _cplusplus const LPCWSTR CLFS_CONTAINER_STREAM_PREFIX = L"%BLF%:" #else #define CLFS_CONTAINER_STREAM_PREFIX L"%BLF%:" #endif /* _cplusplus */ #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Log container path prefix indicating the log container's location is // relative to the base log file (BLF) and not an absolute path. // Paths which do not being with said prefix are absolute paths. // #ifdef _cplusplus const LPCWSTR CLFS_CONTAINER_RELATIVE_PREFIX = L"%BLF%\\" #else #define CLFS_CONTAINER_RELATIVE_PREFIX L"%BLF%\\" #endif /* _cplusplus */ #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Alias CLS prefix with CLFS prefixes. // typedef UCHAR CLS_RECORD_TYPE, *PCLS_RECORD_TYPE, **PPCLS_RECORD_TYPE; typedef CLS_RECORD_TYPE CLFS_RECORD_TYPE, *PCLFS_RECORD_TYPE, **PPCLFS_RECORD_TYPE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_CONTEXT_MODE // // The context mode specifies the dirction and access methods used to scan the // log file. // typedef enum _CLS_CONTEXT_MODE { ClsContextNone = 0x00, ClsContextUndoNext, ClsContextPrevious, ClsContextForward } CLS_CONTEXT_MODE, *PCLS_CONTEXT_MODE, **PPCLS_CONTEXT_MODE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Alias all CLS prefixes with CLFS prefixes. // typedef enum _CLFS_CONTEXT_MODE { ClfsContextNone = 0x00, ClfsContextUndoNext, ClfsContextPrevious, ClfsContextForward } CLFS_CONTEXT_MODE, *PCLFS_CONTEXT_MODE, **PPCLFS_CONTEXT_MODE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFSD_NODE_ID // // Common log file system node identifier. Every CLFS file system // structure has a node identity and type. The node type is a signature // field while the size is used in for consistency checking. // typedef struct _CLFS_NODE_ID { ULONG cType; // CLFS node type. ULONG cbNode; // CLFS node size. } CLFS_NODE_ID, *PCLFS_NODE_ID; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_WRITE_ENTRY // // Write entry specifying the contents of a user buffer and length that are // marshalled in the space reservation and append interface of the CLS API. // typedef struct _CLS_WRITE_ENTRY { PVOID Buffer; ULONG ByteLength; } CLS_WRITE_ENTRY, *PCLS_WRITE_ENTRY, **PPCLS_WRITE_ENTRY; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Alias all CLS prefixes with CLFS prefixes. // typedef CLS_WRITE_ENTRY CLFS_WRITE_ENTRY; typedef CLFS_WRITE_ENTRY *PCLFS_WRITE_ENTRY, **PPCLFS_WRITE_ENTRY; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_LOG_ID // // A log identifier is a GUID that describes uniquely a physical log file. // typedef GUID CLFS_LOG_ID; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_INFORMATION // // Logical log file information structure describing either virtual or physical log // file data, depending on the type of information queried. // typedef struct _CLS_INFORMATION { LONGLONG TotalAvailable; // Total log data space available. LONGLONG CurrentAvailable; // Useable space in the log file. LONGLONG TotalReservation; // Space reserved for UNDO's (aggregate for physical log) ULONGLONG BaseFileSize; // Size of the base log file. ULONGLONG ContainerSize; // Uniform size of log containers. ULONG TotalContainers; // Total number of containers. ULONG FreeContainers; // Number of containers not in active log. ULONG TotalClients; // Total number of clients. ULONG Attributes; // Log file attributes. ULONG FlushThreshold; // Log file flush threshold. ULONG SectorSize; // Underlying container sector size. CLS_LSN MinArchiveTailLsn; // Marks the global archive tail. CLS_LSN BaseLsn; // Start of the active log region. CLS_LSN LastFlushedLsn; // Last flushed LSN in active log. CLS_LSN LastLsn; // End of active log region. CLS_LSN RestartLsn; // Location of restart record. GUID Identity; // Unique identifier for the log. } CLS_INFORMATION, *PCLS_INFORMATION, *PPCLS_INFORMATION; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Alias CLS prefixes with CLS prefixes. // typedef CLS_INFORMATION CLFS_INFORMATION; typedef CLFS_INFORMATION *PCLFS_INFORMATION, *PPCLFS_INFORMATION; #endif /* NTDDI_VERSION || _WIN32_WINNT */ /* // // CLFS_CLIENT_INFORMATION // // The client information structure maintains client-based log metadata. // typedef struct _CLS_CLIENT_INFORMATION { CLS_INFORMATION ClfsInfo; // Contains base log file information. ULONG ClientAttributes; // Virtual log file attributes. LONGLONG ClientUndoCommitment; // Max. undo commitment for client. CLS_LSN ClientArchiveTailLsn; // Marks the client archive tail. CLS_LSN ClientBaseLsn; // Min. client LSN in active log region. CLS_LSN ClientLastLsn; // Max. client LSN in active log region. CLS_LSN ClientRestartLsn; // Location of restart record. } CLS_CLIENT_INFORMATION, *PCLS_CLIENT_INFORMATION, **PPCLS_CLIENT_INFORMATION; // // Alias CLS prefixes with CLS prefixes. // typedef CLS_CLIENT_INFORMATION CLFS_CLIENT_INFORMATION; typedef CLFS_CLIENT_INFORMATION *PCLFS_CLIENT_INFORMATION, *PPCLFS_CLIENT_INFORMATION; */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_LOG_NAME_INFORMATION // // The client information structure stores the name of a log. It is used // to communicate ClfsLogNameInformation and ClfsLogPhysicalNameInformation. // typedef struct _CLFS_LOG_NAME_INFORMATION { USHORT NameLengthInBytes; WCHAR Name[1]; } CLFS_LOG_NAME_INFORMATION, *PCLFS_LOG_NAME_INFORMATION, **PPCLFS_LOG_NAME_INFORMATION; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_STREAM_ID_INFORMATION // // The client information structure provides a permanent identifier unique // to the log for the stream in question. // typedef struct _CLFS_STREAM_ID_INFORMATION { UCHAR StreamIdentifier; } CLFS_STREAM_ID_INFORMATION, *PCLFS_STREAM_ID_INFORMATION, **PPCLFS_STREAM_ID_INFORMATION; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_VISTA) || (_WIN32_WINNT >= _WIN32_WINNT_LONGHORN) // // CLFS_PHYSICAL_LSN_INFORMATION // // An information structure that describes a virtual:physical LSN pairing // for the stream identified in the structure. // #pragma pack(push,8) typedef struct _CLFS_PHYSICAL_LSN_INFORMATION { UCHAR StreamIdentifier; CLFS_LSN VirtualLsn; CLFS_LSN PhysicalLsn; } CLFS_PHYSICAL_LSN_INFORMATION, *PCLFS_PHYSICAL_LSN_INFORMATION; #pragma pack(pop) #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_CONTAINER_STATE // // At any point in time a container could be inactive or unitialized, active, // pending deletion from the list of free containers, pending archival, or // pending deletion while waiting to be archived. // typedef UINT32 CLS_CONTAINER_STATE, *PCLS_CONTAINER_STATE, *PPCLS_CONTAINER_STATE; typedef CLS_CONTAINER_STATE CLFS_CONTAINER_STATE, *PCLFS_CONTAINER_STATE, *PPCLFS_CONTAINER_STATE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #ifdef __cplusplus #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) const CLFS_CONTAINER_STATE ClsContainerInitializing = 0x01; const CLFS_CONTAINER_STATE ClsContainerInactive = 0x02; const CLFS_CONTAINER_STATE ClsContainerActive = 0x04; const CLFS_CONTAINER_STATE ClsContainerActivePendingDelete = 0x08; const CLFS_CONTAINER_STATE ClsContainerPendingArchive = 0x10; const CLFS_CONTAINER_STATE ClsContainerPendingArchiveAndDelete = 0x20; const CLFS_CONTAINER_STATE ClfsContainerInitializing = 0x01; const CLFS_CONTAINER_STATE ClfsContainerInactive = 0x02; const CLFS_CONTAINER_STATE ClfsContainerActive = 0x04; const CLFS_CONTAINER_STATE ClfsContainerActivePendingDelete = 0x08; const CLFS_CONTAINER_STATE ClfsContainerPendingArchive = 0x10; const CLFS_CONTAINER_STATE ClfsContainerPendingArchiveAndDelete= 0x20; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #else #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) #define ClsContainerInitializing 0x01 #define ClsContainerInactive 0x02 #define ClsContainerActive 0x04 #define ClsContainerActivePendingDelete 0x08 #define ClsContainerPendingArchive 0x10 #define ClsContainerPendingArchiveAndDelete 0x20 #define ClfsContainerInitializing 0x01 #define ClfsContainerInactive 0x02 #define ClfsContainerActive 0x04 #define ClfsContainerActivePendingDelete 0x08 #define ClfsContainerPendingArchive 0x10 #define ClfsContainerPendingArchiveAndDelete 0x20 #endif /* NTDDI_VERSION || _WIN32_WINNT */ #endif /* __cplusplus */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_MAX_CONTAINER_INFO // // The maximum length, in bytes, of the FileName field in the CLFS // container information structure. // #ifdef __cplusplus const ULONG CLFS_MAX_CONTAINER_INFO = (256); #else #define CLFS_MAX_CONTAINER_INFO (256) #endif /* __cplusplus */ #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_CONTAINER_INFORMATION // // This structure defines a container descriptor. The descriptor specifies the // container's creation and access times, size, file system name, file system // attributes, state, minimum, and maximum LSNs. // typedef struct _CLS_CONTAINER_INFORMATION { ULONG FileAttributes; // File system attribute flag. ULONGLONG CreationTime; // File creation time. ULONGLONG LastAccessTime; // Last time container was read/written. ULONGLONG LastWriteTime; // Last time container was written. LONGLONG ContainerSize; // Size of container in bytes. ULONG FileNameActualLength; // Length of the actual file name. ULONG FileNameLength; // Length of file name in buffer WCHAR FileName [CLFS_MAX_CONTAINER_INFO];// File system name for container. CLFS_CONTAINER_STATE State; // Current state of the container. CLFS_CONTAINER_ID PhysicalContainerId; // Physical container identifier. CLFS_CONTAINER_ID LogicalContainerId; // Logical container identifier. } CLS_CONTAINER_INFORMATION, *PCLS_CONTAINER_INFORMATION, **PPCLS_CONTAINER_INFORMATION; // // Alias all CLS prefixes with CLFS prefixes. // typedef CLS_CONTAINER_INFORMATION CLFS_CONTAINER_INFORMATION; typedef CLFS_CONTAINER_INFORMATION *PCLFS_CONTAINER_INFORMATION, **PPCLFS_CONTAINER_INFORMATION; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_LOG_INFORMATION_CLASS // // The information class specifies the kind of information a caller // wishes to query or set on a log file. // typedef enum _CLS_LOG_INFORMATION_CLASS { ClfsLogBasicInformation = 0x00, // For virtual or physical logs, indicates the respective basic information. ClfsLogBasicInformationPhysical, // Always indicates physical log basic information. ClfsLogPhysicalNameInformation, // Always indicates physical name information. ClfsLogStreamIdentifierInformation, // Virtual/physical log agnostic. #if (NTDDI_VERSION >= NTDDI_VISTA) || (_WIN32_WINNT >= _WIN32_WINNT_LONGHORN) ClfsLogSystemMarkingInformation, // Count of system marking references. ClfsLogPhysicalLsnInformation // Maps virtual LSNs to physical LSNs; only valid for physical logs. #endif /* NTDDI_VERSION || _WIN32_WINNT */ } CLS_LOG_INFORMATION_CLASS, *PCLS_LOG_INFORMATION_CLASS, **PPCLS_LOG_INFORMATION_CLASS; // // Alias all CLS prefixes with CLFS prefixes. // typedef CLS_LOG_INFORMATION_CLASS CLFS_LOG_INFORMATION_CLASS; typedef CLFS_LOG_INFORMATION_CLASS *PCLFS_LOG_INFORMATION_CLASS, **PPCLFS_LOG_INFORMATION_CLASS; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_IOSTATS_CLASS // // Enumerated type defining the class of I/O statistics. // typedef enum _CLS_IOSTATS_CLASS { ClsIoStatsDefault = 0x0000, ClsIoStatsMax = 0xFFFF } CLS_IOSTATS_CLASS, *PCLS_IOSTATS_CLASS, **PPCLS_IOSTATS_CLASS; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_IOSTATS_CLASS // // Alias all CLS prefixes with CLFS prefixes. // typedef enum _CLFS_IOSTATS_CLASS { ClfsIoStatsDefault = 0x0000, ClfsIoStatsMax = 0xFFFF } CLFS_IOSTATS_CLASS, *PCLFS_IOSTATS_CLASS, **PPCLFS_IOSTATS_CLASS; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLS_IO_STATISTICS // // This structure defines I/O performance counters particular to a log file. It consists // of a header followed by the I/O statistics counters. The header is being ignored for // now. // typedef struct _CLS_IO_STATISTICS_HEADER { UCHAR ubMajorVersion; // Major version of the statistics buffer. UCHAR ubMinorVersion; // Minor version of the statistics buffer. CLFS_IOSTATS_CLASS eStatsClass; // I/O statistics class. USHORT cbLength; // Length of the statistics buffer. ULONG coffData; // Offset of statistics counters. } CLS_IO_STATISTICS_HEADER, *PCLS_IO_STATISTICS_HEADER, **PPCLS_IO_STATISTICS_HEADER; // // Alias all CLS prefixes with CLFS prefixes. // typedef CLS_IO_STATISTICS_HEADER CLFS_IO_STATISTICS_HEADER; typedef CLFS_IO_STATISTICS_HEADER *PCLFS_IO_STATISTICS_HEADER, **PPCLFS_IO_STATISTICS_HEADER; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) typedef struct _CLS_IO_STATISTICS { CLS_IO_STATISTICS_HEADER hdrIoStats; // Statistics buffer header. ULONGLONG cFlush; // Flush count. ULONGLONG cbFlush; // Cumulative number of bytes flushed. ULONGLONG cMetaFlush; // Metadata flush count. ULONGLONG cbMetaFlush; // Cumulative number of metadata bytes flushed. } CLS_IO_STATISTICS, *PCLS_IO_STATISTICS, **PPCLS_IO_STATISTICS; // // Alias all CLS prefixes with CLFS prefixes. // typedef CLS_IO_STATISTICS CLFS_IO_STATISTICS; typedef CLFS_IO_STATISTICS *PCLFS_IO_STATISTICS, **PPCLFS_IO_STATISTICS; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_SCAN_MODE // // Container scan mode flags. // #ifdef __cplusplus const UCHAR CLFS_SCAN_INIT = 0x01; const UCHAR CLFS_SCAN_FORWARD = 0x02; const UCHAR CLFS_SCAN_BACKWARD = 0x04; const UCHAR CLFS_SCAN_CLOSE = 0x08; const UCHAR CLFS_SCAN_INITIALIZED = 0x10; const UCHAR CLFS_SCAN_BUFFERED = 0x20; #else #define CLFS_SCAN_INIT 0x01 #define CLFS_SCAN_FORWARD 0x02 #define CLFS_SCAN_BACKWARD 0x04 #define CLFS_SCAN_CLOSE 0x08 #define CLFS_SCAN_INITIALIZED 0x10 #define CLFS_SCAN_BUFFERED 0x20 #endif typedef UCHAR CLFS_SCAN_MODE, *PCLFS_SCAN_MODE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_SCAN_CONTEXT // // Container scan context for scanning all containers in a given physical log // file. // // // The log file object wraps an NT file object and the size of the structure. // The log file object may be modified in the near future and there should be no // dependencies on the size of the structure itself. // typedef FILE_OBJECT LOG_FILE_OBJECT, *PLOG_FILE_OBJECT, **PPLOG_FILE_OBJECT; #if defined(_MSC_VER) #if (_MSC_VER >= 1200) #pragma warning(push) #pragma warning(disable:4324) // structure padded due to __declspec(align()) #endif #endif typedef struct _CLS_SCAN_CONTEXT { CLFS_NODE_ID cidNode; PLOG_FILE_OBJECT plfoLog; __declspec(align(8)) ULONG cIndex; __declspec(align(8)) ULONG cContainers; __declspec(align(8)) ULONG cContainersReturned; __declspec(align(8)) CLFS_SCAN_MODE eScanMode; __declspec(align(8)) PCLS_CONTAINER_INFORMATION pinfoContainer; } CLS_SCAN_CONTEXT, *PCLS_SCAN_CONTEXT, **PPCLS_SCAN_CONTEXT; #if defined(_MSC_VER) #if (_MSC_VER >= 1200) #pragma warning(pop) #endif #endif #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Alias all CLS prefixes with CLFS prefixes. // typedef CLS_SCAN_CONTEXT CLFS_SCAN_CONTEXT; typedef CLFS_SCAN_CONTEXT *PCLFS_SCAN_CONTEXT, **PPCLFS_SCAN_CONTEXT; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_ARCHIVE_DESCRIPTOR // // Log archive descriptors describe the set of discrete but logically // contiguous disk extents comprising a snapshot of the active log when // preparing for archival. Log archive descriptors specify enough information // for log archive clients directly access the relevant contents of containers // for archiving and restoring a snapshot of the log. // typedef struct _CLS_ARCHIVE_DESCRIPTOR { ULONGLONG coffLow; ULONGLONG coffHigh; CLS_CONTAINER_INFORMATION infoContainer; } CLS_ARCHIVE_DESCRIPTOR, *PCLS_ARCHIVE_DESCRIPTOR, **PPCLS_ARCHIVE_DESCRIPTOR; // // Alias CLS prefixes with CLFS prefixes. // typedef CLS_ARCHIVE_DESCRIPTOR CLFS_ARCHIVE_DESCRIPTOR; typedef CLFS_ARCHIVE_DESCRIPTOR *PCLFS_ARCHIVE_DESCRIPTOR, **PPCLFS_ARCHIVE_DESCRIPTOR; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_ALLOCATION_ROUTINE // // Allocate a blocks for marshalled reads or writes // typedef PVOID (* CLFS_BLOCK_ALLOCATION) (ULONG cbBufferLength, PVOID pvUserContext); // // CLFS_DEALLOCATION_ROUTINE // // Deallocate buffers allocated by the CLFS_ALLOCATION_ROUTINE. // typedef void (* CLFS_BLOCK_DEALLOCATION) (PVOID pvBuffer, PVOID pvUserContext); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_LOG_ARCHIVE_MODE // // Describes the archive support behavior for the log. // typedef enum _CLFS_LOG_ARCHIVE_MODE { ClfsLogArchiveEnabled = 0x01, ClfsLogArchiveDisabled = 0x02 } CLFS_LOG_ARCHIVE_MODE, *PCLFS_LOG_ARCHIVE_MODE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ //----------------------------------------------------------------------------- // LSN OPERATORS //----------------------------------------------------------------------------- #ifdef __cplusplus extern "C" { #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnEqual // // Method Description: // // Check for the equivalence of LSNs. // // Arguments: // // plsn1 -- first LSN comparator // plsn2 -- second LSN comparator // // // Return Value: // // TRUE if LSN values are equivalent and FALSE otherwise. // //----------------------------------------------------------------------------- CLFSUSER_API BOOLEAN NTAPI ClfsLsnEqual ( _In_ const CLFS_LSN* plsn1, _In_ const CLFS_LSN* plsn2 ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnLess // // Method Description: // // Check if LSN1 is less than LSN2. // // Arguments: // // plsn1 -- first LSN comparator // plsn2 -- second LSN comparator // // // Return Value: // // TRUE if LSN1 is less than LSN2 and FALSE otherwise. // //----------------------------------------------------------------------------- CLFSUSER_API BOOLEAN NTAPI ClfsLsnLess ( _In_ const CLFS_LSN* plsn1, _In_ const CLFS_LSN* plsn2 ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnGreater // // Method Description: // // Check if LSN1 is greater than LSN2. // // Arguments: // // plsn1 -- first LSN comparator // plsn2 -- second LSN comparator // // // Return Value: // // TRUE if LSN1 is greater than LSN2 and FALSE otherwise. // //----------------------------------------------------------------------------- CLFSUSER_API BOOLEAN NTAPI ClfsLsnGreater ( _In_ const CLFS_LSN* plsn1, _In_ const CLFS_LSN* plsn2 ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnNull (Inline) // // Method Description: // // Check whether or not an LSN is CLFS_LSN_NULL. // // Arguments: // // plsn -- reference to LSN tested against the NULL value. // // // Return Value: // // TRUE if and only if an LSN is equivalent to CLFS_LSN_NULL. // LSNs with the value CLFS_LSN_INVALID will return FALSE. // //----------------------------------------------------------------------------- CLFSUSER_API BOOLEAN NTAPI ClfsLsnNull ( _In_ const CLFS_LSN* plsn ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnContainer (Inline) // // Routine Description: // // Extract the container identifier from the LSN. // // Arguments: // // plsn -- get block offset from this LSN // // Return Value: // // Returns the container identifier for the LSN. // //----------------------------------------------------------------------------- CLFSUSER_API CLFS_CONTAINER_ID NTAPI ClfsLsnContainer ( _In_ const CLFS_LSN* plsn ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnCreate (Inline) // // Routine Description: // // Create an LSN given a log identifier, a container identifier, a block // offset and a bucket identifier. Caller must test for invalid LSN after // making this call. // // Arguments: // // cidContainer -- container identifier // offBlock -- block offset // cRecord -- ordinal number of the record in block // // Return Value: // // Returns a valid LSN if successful, otherwise it returns // CLFS_LSN_INVALID // //----------------------------------------------------------------------------- CLFSUSER_API CLFS_LSN NTAPI ClfsLsnCreate ( _In_ CLFS_CONTAINER_ID cidContainer, _In_ ULONG offBlock, _In_ ULONG cRecord ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnBlockOffset (Inline) // // Routine Description: // // Extract the block offset from the LSN. // // Arguments: // // plsn -- get block offset from this LSN // // Return Value: // // Returns the block offset for the LSN. // //----------------------------------------------------------------------------- CLFSUSER_API ULONG NTAPI ClfsLsnBlockOffset ( _In_ const CLFS_LSN* plsn ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnRecordSequence (Inline) // // Routine Description: // // Extract the bucket identifier from the LSN. // // Arguments: // // plsn -- get block offset from this LSN // // Return Value: // // Returns the bucket identifier for the LSN. // //----------------------------------------------------------------------------- CLFSUSER_API ULONG NTAPI ClfsLsnRecordSequence ( _In_ const CLFS_LSN* plsn ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnInvalid // // Method Description: // // Check whether or not an LSN is CLFS_LSN_INVALID. // // Arguments: // // plsn -- reference to LSN tested against CLFS_LSN_INVALID. // // // Return Value: // // TRUE if and only if an LSN is equivalent to CLFS_LSN_INVALID. // LSNs with the value CLFS_LSN_NULL will return FALSE. // //----------------------------------------------------------------------------- CLFSUSER_API BOOLEAN NTAPI ClfsLsnInvalid ( _In_ const CLFS_LSN* plsn ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) //----------------------------------------------------------------------------- // ClfsLsnIncrement // // Method Description: // // Increment and LSN by 1 // // Arguments: // // plsn -- LSN to be incremented. // // // Return Value: // // A valid LSN next in sequence to the input LSN, if successful. // Otherwise, this function returns CLFS_LSN_INVALID. // //----------------------------------------------------------------------------- CLFSUSER_API CLFS_LSN NTAPI ClfsLsnIncrement (_In_ PCLFS_LSN plsn); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #ifdef __cplusplus } #endif #ifdef __cplusplus #ifdef CLFS_OPERATORS #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // LSN arithmetic increment operator. // inline CLFS_LSN operator++ ( _Inout_ CLFS_LSN& refLsn ) { // // Prefix increment operator. // refLsn = ClfsLsnIncrement (&refLsn); return refLsn; } #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // BOOLEAN LSN operators. // inline BOOLEAN operator< ( _In_ const CLFS_LSN& refLsn1, _In_ const CLFS_LSN& refLsn2 ) { return (ClfsLsnLess ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2)); } #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) inline BOOLEAN operator> ( _In_ const CLFS_LSN& refLsn1, _In_ const CLFS_LSN& refLsn2 ) { return (ClfsLsnGreater ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2)); } #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) inline BOOLEAN operator== ( _In_ const CLFS_LSN& refLsn1, _In_ const CLFS_LSN& refLsn2 ) { return (ClfsLsnEqual ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2)); } #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) inline BOOLEAN operator!= ( _In_ const CLFS_LSN& refLsn1, _In_ const CLFS_LSN& refLsn2 ) { return (!ClfsLsnEqual ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2)); } #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) inline BOOLEAN operator<= ( _In_ const CLFS_LSN& refLsn1, _In_ const CLFS_LSN& refLsn2 ) { return (!ClfsLsnGreater ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2)); } #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) inline BOOLEAN operator>= ( _In_ const CLFS_LSN& refLsn1, _In_ const CLFS_LSN& refLsn2 ) { return (!ClfsLsnLess ((PCLFS_LSN) &refLsn1, (PCLFS_LSN) &refLsn2)); } #endif /* NTDDI_VERSION || _WIN32_WINNT */ #endif /* CLFS_OPERATORS */ #endif /* __cplusplus */ #endif /* _CLFS_PUBLIC_H_ */ #ifdef __cplusplus extern "C" { #endif #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // We start with the information that is shared // between user and kernel mode. // typedef enum _CLFS_MGMT_POLICY_TYPE { ClfsMgmtPolicyMaximumSize = 0x0, ClfsMgmtPolicyMinimumSize, ClfsMgmtPolicyNewContainerSize, ClfsMgmtPolicyGrowthRate, ClfsMgmtPolicyLogTail, ClfsMgmtPolicyAutoShrink, ClfsMgmtPolicyAutoGrow, ClfsMgmtPolicyNewContainerPrefix, ClfsMgmtPolicyNewContainerSuffix, ClfsMgmtPolicyNewContainerExtension, ClfsMgmtPolicyInvalid } CLFS_MGMT_POLICY_TYPE, *PCLFS_MGMT_POLICY_TYPE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) #define CLFS_MGMT_NUM_POLICIES ((ULONG)ClfsMgmtPolicyInvalid) #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Relative sizes used when explicitly setting log size. // #define CLFS_LOG_SIZE_MINIMUM ((ULONGLONG)(0)) #define CLFS_LOG_SIZE_MAXIMUM ((ULONGLONG)(-1)) #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // The version of a given policy structure. See CLFS_MGMT_POLICY. // #define CLFS_MGMT_POLICY_VERSION (0x01) #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // Log policy flags. // // LOG_POLICY_OVERWRITE: If set when adding a log policy, the previous // policy of given type will be replaced. // // LOG_POLICY_PERSIST: If set when adding a log policy, the policy // will be persisted with the log metadata. // #define LOG_POLICY_OVERWRITE (0x01) #define LOG_POLICY_PERSIST (0x02) #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_MGMT_POLICY // // This structure describes one particular policy that // may be present on a log file. These are installed // via InstallLogPolicy (Win32) or ClfsMgmtInstallPolicy (kernel). // typedef struct _CLFS_MGMT_POLICY { // // Version of the structure. Should be CLFS_MGMT_POLICY_VERSION. // ULONG Version; // // The entire length of the structure. // ULONG LengthInBytes; // // Flags which apply to all policies, such as LOG_POLICY_OVERWRITE // and LOG_POLICY_PERSIST. // ULONG PolicyFlags; // // Determines how PolicyParameters union is interpreted. // CLFS_MGMT_POLICY_TYPE PolicyType; // // The way to interpret the PolicyParameters union is // determined by the value of PolicyType -- if it is // ClfsMgmtPolicyMaximumSize, for instance, then the // MaximumSize structure is the relevant one. // union { struct { ULONG Containers; } MaximumSize; struct { ULONG Containers; } MinimumSize; struct { ULONG SizeInBytes; } NewContainerSize; struct { ULONG AbsoluteGrowthInContainers; ULONG RelativeGrowthPercentage; } GrowthRate; struct { ULONG MinimumAvailablePercentage; ULONG MinimumAvailableContainers; } LogTail; struct { ULONG Percentage; } AutoShrink; struct { ULONG Enabled; } AutoGrow; struct { USHORT PrefixLengthInBytes; WCHAR PrefixString[1]; // dynamic in length depending on PrefixLength } NewContainerPrefix; struct { ULONGLONG NextContainerSuffix; } NewContainerSuffix; struct { USHORT ExtensionLengthInBytes; WCHAR ExtensionString[1]; // dynamic in length depending on ExtensionLengthInBytes } NewContainerExtension; } PolicyParameters; // // Nothing will be added down here since the structure above // can be of dynamic length. // } CLFS_MGMT_POLICY, *PCLFS_MGMT_POLICY; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_MGMT_NOTIFICATION_TYPE // // The types of notifications given to either the callback proxy // or to readers of notifications. // typedef enum _CLFS_MGMT_NOTIFICATION_TYPE { // // Notification to advance base LSN. // ClfsMgmtAdvanceTailNotification = 0, // // Notification that a request to handle log full condition // has completed. // ClfsMgmtLogFullHandlerNotification, // // Notification that a previously pinned log is now considered // unpinned. // ClfsMgmtLogUnpinnedNotification, // // Notification that a non-zero number of bytes has been written // to the log. // ClfsMgmtLogWriteNotification } CLFS_MGMT_NOTIFICATION_TYPE, *PCLFS_MGMT_NOTIFICATION_TYPE; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_MGMT_NOTIFICATION // // A notification and associated parameters. // typedef struct _CLFS_MGMT_NOTIFICATION { // // Nature of the notification. // CLFS_MGMT_NOTIFICATION_TYPE Notification; // // Target LSN for base LSN advancement if the // notification type is ClfsMgmtAdvanceTailNotification. // CLFS_LSN Lsn; // // TRUE if the log is pinned, FALSE otherwise. // Especially meaningful when receiving an error // status for ClfsMgmtLogFullHandlerNotification. // USHORT LogIsPinned; } CLFS_MGMT_NOTIFICATION, *PCLFS_MGMT_NOTIFICATION; #endif /* NTDDI_VERSION || _WIN32_WINNT */ // // Kernel interface described below. // #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // The advance tail callback is required when log clients // register for management. It is invoked whenever the // management library decides that this client needs to // advance the tail of its log. Only minimal processing is // allowed. // typedef NTSTATUS (*PCLFS_CLIENT_ADVANCE_TAIL_CALLBACK) ( _In_ PLOG_FILE_OBJECT LogFile, _In_ PCLFS_LSN TargetLsn, _In_ PVOID ClientData ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // The log file full handler complete callback is invoked upon // completion of a log growth request (that is, via a call // to ClfsMgmtHandleLogFileFull). // typedef VOID (*PCLFS_CLIENT_LFF_HANDLER_COMPLETE_CALLBACK) ( _In_ PLOG_FILE_OBJECT LogFile, _In_ NTSTATUS OperationStatus, _In_ BOOLEAN LogIsPinned, _In_ PVOID ClientData ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // The log pinned callback is invoked when log space is freed up // after a log file full handler completion callback indicates an // NT_ERROR status code and LogIsPinned = TRUE. // typedef VOID (*PCLFS_CLIENT_LOG_UNPINNED_CALLBACK) ( _In_ PLOG_FILE_OBJECT LogFile, _In_ PVOID ClientData ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // The log size complete callback is invoked whenever // ClfsMgmtSetLogFileSize operation which returned // STATUS_PENDING is completed. // typedef VOID (*PCLFS_SET_LOG_SIZE_COMPLETE_CALLBACK) ( _In_ PLOG_FILE_OBJECT LogFile, _In_ NTSTATUS OperationStatus, _In_ PVOID ClientData ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_MGMT_CLIENT_REGISTRATION // // This structure is given to the CLFS management infrastructure // by clients who wish to be managed (via ClfsMgmtRegisterManagedClient). // The CLFS_MGMT_CLIENT_REGISTRATION_VERSION value must be stored // in the 'Version' field of the structure. // #define CLFS_MGMT_CLIENT_REGISTRATION_VERSION (0x1) typedef struct _CLFS_MGMT_CLIENT_REGISTRATION { // // Initialize Version to CLFS_MGMT_CLIENT_REGISTRATION_VERSION. // ULONG Version; PCLFS_CLIENT_ADVANCE_TAIL_CALLBACK AdvanceTailCallback; PVOID AdvanceTailCallbackData; PCLFS_CLIENT_LFF_HANDLER_COMPLETE_CALLBACK LogGrowthCompleteCallback; PVOID LogGrowthCompleteCallbackData; PCLFS_CLIENT_LOG_UNPINNED_CALLBACK LogUnpinnedCallback; PVOID LogUnpinnedCallbackData; } CLFS_MGMT_CLIENT_REGISTRATION, *PCLFS_MGMT_CLIENT_REGISTRATION; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // // CLFS_MGMT_CLIENT // // This is the cookie that clients are given when registering and // must give back to the management infrastructure whenever // performing an operation. // typedef PVOID CLFS_MGMT_CLIENT, *PCLFS_MGMT_CLIENT; #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtRegisterManagedClient( _In_ PLOG_FILE_OBJECT LogFile, _In_ PCLFS_MGMT_CLIENT_REGISTRATION RegistrationData, _Out_ PCLFS_MGMT_CLIENT ClientCookie ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtDeregisterManagedClient( _In_ CLFS_MGMT_CLIENT ClientCookie ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtTailAdvanceFailure( _In_ CLFS_MGMT_CLIENT Client, _In_ NTSTATUS Reason ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtHandleLogFileFull( _In_ CLFS_MGMT_CLIENT Client ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtInstallPolicy( _In_ PLOG_FILE_OBJECT LogFile, _In_reads_bytes_(PolicyLength) PCLFS_MGMT_POLICY Policy, _In_ ULONG PolicyLength ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtQueryPolicy( _In_ PLOG_FILE_OBJECT LogFile, _In_ CLFS_MGMT_POLICY_TYPE PolicyType, _Out_writes_bytes_(*PolicyLength) PCLFS_MGMT_POLICY Policy, _Out_ PULONG PolicyLength ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtRemovePolicy( _In_ PLOG_FILE_OBJECT LogFile, _In_ CLFS_MGMT_POLICY_TYPE PolicyType ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) CLFSUSER_API NTSTATUS ClfsMgmtSetLogFileSize( _In_ PLOG_FILE_OBJECT LogFile, _In_ PULONGLONG NewSizeInContainers, _Out_opt_ PULONGLONG ResultingSizeInContainers, _In_opt_ PCLFS_SET_LOG_SIZE_COMPLETE_CALLBACK CompletionRoutine, _In_opt_ PVOID CompletionRoutineData ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #if (NTDDI_VERSION >= NTDDI_VISTA) || (_WIN32_WINNT >= _WIN32_WINNT_LONGHORN) CLFSUSER_API NTSTATUS ClfsMgmtSetLogFileSizeAsClient( _In_ PLOG_FILE_OBJECT LogFile, _In_opt_ PCLFS_MGMT_CLIENT ClientCookie, _In_ PULONGLONG NewSizeInContainers, _Out_opt_ PULONGLONG ResultingSizeInContainers, _In_opt_ PCLFS_SET_LOG_SIZE_COMPLETE_CALLBACK CompletionRoutine, _In_opt_ PVOID CompletionRoutineData ); #endif /* NTDDI_VERSION || _WIN32_WINNT */ #ifdef __cplusplus } // extern "C" #endif #ifndef __CLFSPROC_H__ #define __CLFSPROC_H__ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsInitialize // // Utility to initialize CLFS global resources, lookaside lists, and memory. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsInitialize (void); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsFinalize // // Utility to cleanup CLFS global resources, lookaside lists, and memory. //------------------------------------------------------------------------------ CLFSUSER_API void ClfsFinalize (void); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsCreateLogFile // // Entry point to create a physical log file consisting of uniformly sized // containers lying in a given directory path. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsCreateLogFile ( _Out_ PPLOG_FILE_OBJECT pplfoLog, _In_ PUNICODE_STRING puszLogFileName, _In_ ACCESS_MASK fDesiredAccess, _In_ ULONG dwShareMode, _In_opt_ PSECURITY_DESCRIPTOR psdLogFile, _In_ ULONG fCreateDisposition, _In_ ULONG fCreateOptions, _In_ ULONG fFlagsAndAttributes, _In_ ULONG fLogOptionFlag, _In_reads_bytes_opt_(cbContext) PVOID pvContext, _In_ ULONG cbContext ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsDeleteLogByPointer // // Entry point to delete a physical log file and its underlying container // storage referencing a log file object. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsDeleteLogByPointer (_In_ PLOG_FILE_OBJECT plfoLog); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsDeleteLogFile // // Entry point to delete a physical log file and its underlying container // storage by name. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsDeleteLogFile ( _In_ PUNICODE_STRING puszLogFileName, _In_opt_ PVOID pvReserved, _In_ ULONG fLogOptionFlag, _In_reads_bytes_opt_(cbContext) PVOID pvContext, _In_ ULONG cbContext ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsAddLogContainer // // Adds a log container to a given physical file identified by the log // file object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsAddLogContainer ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ PULONGLONG pcbContainer, _In_ PUNICODE_STRING puszContainerPath ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsAddLogContainerSet // // Adds a set of log containers to a given physical file identified by the log // file object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsAddLogContainerSet ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ USHORT cContainers, _In_opt_ PULONGLONG pcbContainer, _In_reads_(cContainers) PUNICODE_STRING rguszContainerPath ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsRemoveLogContainer // // Removes a log container from a physical log file identified by // the log file object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsRemoveLogContainer ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ PUNICODE_STRING puszContainerPath, _In_ BOOLEAN fForce ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsRemoveLogContainerSet // // Removes a set of log containers from a physical log file identified by // the log file object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsRemoveLogContainerSet ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ USHORT cContainers, _In_reads_(cContainers) PUNICODE_STRING rgwszContainerPath, _In_ BOOLEAN fForce ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsSetArchiveTail // // Sets the archive tail for either a client or physical log file // depending on the type of the log handle. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsSetArchiveTail ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ PCLFS_LSN plsnArchiveTail ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsSetEndOfLog // // Sets the end of log for either a client or physical log file // depending on the type of the log handle. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsSetEndOfLog ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ PCLFS_LSN plsnEnd ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsCreateScanContext // // Create a scan context to enumerate scan descriptors for storage containers // that back the physical log file object. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsCreateScanContext ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ ULONG cFromContainer, _In_ ULONG cContainers, _In_ CLFS_SCAN_MODE eScanMode, _Inout_ PCLFS_SCAN_CONTEXT pcxScan ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsScanLogContainers // // Scan descriptors for storage containers backing the physical // log file stream. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsScanLogContainers ( _Inout_ PCLFS_SCAN_CONTEXT pcxScan, _In_ CLFS_SCAN_MODE eScanMode ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsGetContainerName // // ClfsGetContainerName gets the full path name of a container given its logical // container identifier. // //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsGetContainerName ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ CLFS_CONTAINER_ID cidLogicalContainer, _Inout_ PUNICODE_STRING puszContainerName, _Out_opt_ PULONG pcActualLenContainerName ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsGetLogFileInformation // // Get log file information for a physical log and client stream // specific to the log file object pointer. // // Deprecated. Use ClfsQueryLogFileInformation instead (it is equivalent // to this call if ClfsLogBasicInformation is used as information class). // //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsGetLogFileInformation ( _In_ PLOG_FILE_OBJECT plfoLog, _Out_writes_bytes_to_(*pcbInfoBuffer, *pcbInfoBuffer) PCLFS_INFORMATION pinfoBuffer, _Inout_ PULONG pcbInfoBuffer ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_VISTA) //------------------------------------------------------------------------------ // ClfsQueryLogFileInformation // // Get log file information for a physical log and client stream // specific to the log file object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsQueryLogFileInformation ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ CLFS_LOG_INFORMATION_CLASS eInformationClass, _In_reads_bytes_opt_(cbinfoInputBuffer) PVOID pinfoInputBuffer, _In_opt_ ULONG cbinfoInputBuffer, _Out_writes_bytes_(*pcbInfoBuffer) PVOID pinfoBuffer, _Inout_ PULONG pcbInfoBuffer ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsSetLogFileInformation // // Sets log file information for a physical log and client stream // specific to the log file object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsSetLogFileInformation ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ CLFS_LOG_INFORMATION_CLASS eInformationClass, _In_reads_bytes_(cbBuffer) PVOID pinfoBuffer, _In_ ULONG cbBuffer ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsReadRestartArea // // Read the last restart area successfully written to a physical or // client log stream given a marshalling context. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsReadRestartArea ( _Inout_ PVOID pvMarshalContext, _Outptr_result_bytebuffer_(*pcbRestartBuffer) PVOID *ppvRestartBuffer, _Out_ PULONG pcbRestartBuffer, _Out_ PCLFS_LSN plsn, _Outptr_ PVOID *ppvReadContext ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsReadPreviousRestartArea // // Read the previous restart area successfully written to a physical or // client log stream given the read context created by the a call to // ClfsReadRestartArea. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsReadPreviousRestartArea ( _In_ PVOID pvReadContext, _Outptr_result_bytebuffer_(*pcbRestartBuffer) PVOID *ppvRestartBuffer, _Out_ PULONG pcbRestartBuffer, _Out_ PCLFS_LSN plsnRestart ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsWriteRestartArea // // Write a new restart area to a physical or client log stream given a // a marshalling context. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsWriteRestartArea ( _Inout_ PVOID pvMarshalContext, _In_reads_bytes_(cbRestartBuffer) PVOID pvRestartBuffer, _In_ ULONG cbRestartBuffer, _In_opt_ PCLFS_LSN plsnBase, _In_ ULONG fFlags, _Out_opt_ PULONG pcbWritten, _Out_opt_ PCLFS_LSN plsnNext ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsAdvanceLogBase // // Set a new log base LSN without writing a restart record. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsAdvanceLogBase ( _Inout_ PVOID pvMarshalContext, _In_ PCLFS_LSN plsnBase, _In_ ULONG fFlags ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsCloseAndResetLogFile // // Orderly shutdown of a physical or client log file stream given the log file // object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsCloseAndResetLogFile (_In_ PLOG_FILE_OBJECT plfoLog); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsCloseLogFileObject // // Close a log file object without the orderly shutdown of the log. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsCloseLogFileObject (_In_ PLOG_FILE_OBJECT plfoLog); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsCreateMarshallingArea // // Initalize a marshalling area for a physical or client log // file stream given log file object pointer. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsCreateMarshallingArea ( _In_ PLOG_FILE_OBJECT plfoLog, _In_ POOL_TYPE ePoolType, _In_opt_ PALLOCATE_FUNCTION pfnAllocBuffer, _In_opt_ PFREE_FUNCTION pfnFreeBuffer, _In_ ULONG cbMarshallingBuffer, _In_ ULONG cMaxWriteBuffers, _In_ ULONG cMaxReadBuffers, _Outptr_ PVOID *ppvMarshalContext ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsDeleteMarshallingArea // // Delete a marshalling area for a physical or client log // file stream. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsDeleteMarshallingArea (_In_ PVOID pvMarshalContext); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsReserveAndAppendLog // // Reserve space and append log buffers to a physical or client // log stream. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsReserveAndAppendLog ( _In_ PVOID pvMarshalContext, _In_reads_opt_(cWriteEntries) PCLFS_WRITE_ENTRY rgWriteEntries, _In_ ULONG cWriteEntries, _In_opt_ PCLFS_LSN plsnUndoNext, _In_opt_ PCLFS_LSN plsnPrevious, _In_ ULONG cReserveRecords, _Inout_updates_opt_(cReserveRecords) PLONGLONG rgcbReservation, _In_ ULONG fFlags, _Out_opt_ PCLFS_LSN plsn ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsReserveAndAppendLogAligned // // Reserve space and append log buffers to a physical or client // log stream, aligning each of the write entries according to // the alignment specified. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsReserveAndAppendLogAligned ( _In_ PVOID pvMarshalContext, _In_reads_opt_(cWriteEntries) PCLFS_WRITE_ENTRY rgWriteEntries, _In_ ULONG cWriteEntries, _In_ ULONG cbEntryAlignment, _In_opt_ PCLFS_LSN plsnUndoNext, _In_opt_ PCLFS_LSN plsnPrevious, _In_ ULONG cReserveRecords, _Inout_updates_opt_(cReserveRecords) PLONGLONG rgcbReservation, _In_ ULONG fFlags, _Out_opt_ PCLFS_LSN plsn ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsAlignReservedLog // // Given a valid marshalling context, allocate an aggregate number of reserved // records and bytes. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsAlignReservedLog ( _In_ PVOID pvMarshalContext, _In_ ULONG cRecords, _In_reads_(cRecords) LONGLONG rgcbReservation [], _Out_ PLONGLONG pcbAlignReservation ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsAllocReservedLog // // Given a valid marshalling context, allocate an aggregate number of reserved // records and bytes. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsAllocReservedLog ( _In_ PVOID pvMarshalContext, _In_ ULONG cRecords, _In_reads_(cRecords) PLONGLONG pcbAdjustment ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsFreeReservedLog // // Set the reserved log space to a new size or specify a delta // for the reserved space given log file. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsFreeReservedLog ( _In_ PVOID pvMarshalContext, _In_ ULONG cRecords, _In_reads_(cRecords) PLONGLONG pcbAdjustment ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsFlushBuffers // // Append all buffers in the marshalling area up to the flush queue and flush // all buffers up to the disk. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsFlushBuffers (_In_ PVOID pvMarshalContext); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsFlushToLsn // // Flush all buffers in the marshalling area up to a target LSN to the flush // queue and flush all buffers up to the target LSN to the disk. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsFlushToLsn ( _In_ PVOID pvMarshalContext, _In_ PCLFS_LSN plsnFlush, _Out_opt_ PCLFS_LSN plsnLastFlushed ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsReadLogRecord // // Read a log record from a physical or client log stream given // a starting LSN. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsReadLogRecord ( _In_ PVOID pvMarshalContext, _Inout_ PCLFS_LSN plsnFirst, _In_ CLFS_CONTEXT_MODE peContextMode, _Outptr_result_bytebuffer_(*pcbReadBuffer) PVOID *ppvReadBuffer, _Out_ PULONG pcbReadBuffer, _Out_ PCLFS_RECORD_TYPE peRecordType, _Out_ PCLFS_LSN plsnUndoNext, _Out_ PCLFS_LSN plsnPrevious, _Outptr_ PVOID* ppvReadContext ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsReadNextLogRecord // // Read the next log record from a given marshalling context. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsReadNextLogRecord ( _Inout_ PVOID pvReadContext, _Outptr_result_bytebuffer_(*pcbBuffer) PVOID *ppvBuffer, _Out_ PULONG pcbBuffer, _Inout_ PCLFS_RECORD_TYPE peRecordType, _In_opt_ PCLFS_LSN plsnUser, _Out_ PCLFS_LSN plsnUndoNext, _Out_ PCLFS_LSN plsnPrevious, _Out_ PCLFS_LSN plsnRecord ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsTerminateReadLog // // Terminate the read context. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsTerminateReadLog (_In_ PVOID pvCursorContext); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsGetLastLsn // // Get the last used LSN. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsGetLastLsn ( _In_ PLOG_FILE_OBJECT plfoLog, _Out_ PCLFS_LSN plsnLast ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //------------------------------------------------------------------------------ // ClfsGetIoStatistics // // Get I/O statistics on the CLFS log file. //------------------------------------------------------------------------------ CLFSUSER_API NTSTATUS ClfsGetIoStatistics ( _In_ PLOG_FILE_OBJECT plfoLog, _Inout_updates_bytes_(cbStatsBuffer) PVOID pvStatsBuffer, _In_ ULONG cbStatsBuffer, _In_ CLFS_IOSTATS_CLASS eStatsClass, _Out_opt_ PULONG pcbStatsWritten ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //----------------------------------------------------------------------------- // ClfsLaterLsn // // Method Description: // // Increment an LSN by 1 // // Arguments: // // plsn -- LSN to be incremented. // // // Return Value: // // A valid LSN next in sequence to the input LSN, if successful. // Otherwise, this function returns CLFS_LSN_INVALID. // //----------------------------------------------------------------------------- CLFSUSER_API CLFS_LSN ClfsLaterLsn (_In_ PCLFS_LSN plsn); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //----------------------------------------------------------------------------- // ClfsEarlierLsn // // Method Description: // // Decrement an LSN by 1 // // Arguments: // // plsn -- LSN to be decremented. // // // Return Value: // // A valid LSN next in sequence to the input LSN, if successful. // Otherwise, this function returns CLFS_LSN_INVALID. // //----------------------------------------------------------------------------- CLFSUSER_API CLFS_LSN ClfsEarlierLsn (_In_ PCLFS_LSN plsn); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_WS03SP1) //---------------------------------------------------------------------------- // ClfsLsnDifference // // Method Description: // // Find the approximate number of bytes between two LSNs. // // Arguments: // // plsnStart -- LSN start of the log file range // plsnFinish -- LSN finish of the log file range // cbContainer -- size of a container // cbMaxBlock -- maximum size of an I/O block // pcbDifference -- approximate number of bytes between two LSNs. // // // // Return Value: // // STATUS_SUCCESS if difference is succeeds and an error status // otherwise. // //----------------------------------------------------------------------------- CLFSUSER_API NTSTATUS ClfsLsnDifference ( _In_ PCLFS_LSN plsnStart, _In_ PCLFS_LSN plsnFinish, _In_ ULONG cbContainer, _In_ ULONG cbMaxBlock, _Out_ PLONGLONG pcbDifference ); #endif /* NTDDI_VERSION */ #if (NTDDI_VERSION >= NTDDI_VISTA) //---------------------------------------------------------------------------- // ClfsValidTopLevelContext // // Method Description: // // Check that the current top level context is a common log (CLFS) // context. // // Arguments: // // pirp -- reference to top of top-level context stack // // Return Value: // // TRUE if this is a valid CLFS top-level context and FALSE otherwise. // //----------------------------------------------------------------------------- CLFSUSER_API BOOLEAN ClfsValidTopLevelContext (_In_ PIRP pirpTopLevelContext); #endif /* NTDDI_VERSION */ #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* __CLFSPROC_H__ */ typedef struct _KTRANSACTION KTRANSACTION, *PKTRANSACTION, *RESTRICTED_POINTER PRKTRANSACTION; typedef struct _KENLISTMENT KENLISTMENT, *PKENLISTMENT, *RESTRICTED_POINTER PRKENLISTMENT; typedef struct _KRESOURCEMANAGER KRESOURCEMANAGER, *PKRESOURCEMANAGER, *RESTRICTED_POINTER PRKRESOURCEMANAGER; typedef struct _KTM KTM, *PKTM, *RESTRICTED_POINTER PRKTM; typedef GUID UOW, *PUOW; typedef GUID *PGUID; // // Define ResourceManager Notification routine type. // typedef NTSTATUS (NTAPI *PTM_RM_NOTIFICATION) ( _In_ PKENLISTMENT EnlistmentObject, _In_ PVOID RMContext, _In_ PVOID TransactionContext, _In_ ULONG TransactionNotification, _Inout_ PLARGE_INTEGER TmVirtualClock, _In_ ULONG ArgumentLength, _In_ PVOID Argument ); // // CRM Protocol object // typedef GUID KCRM_PROTOCOL_ID, *PKCRM_PROTOCOL_ID; typedef NTSTATUS (NTAPI *PTM_PROPAGATE_ROUTINE) ( _In_ PVOID PropagationCookie, _In_ PVOID CallbackData, _In_ NTSTATUS PropagationStatus, _In_ GUID TransactionGuid ); // // Tm-level Transaction APIs // _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmInitializeTransactionManager ( _In_ PRKTM TransactionManager, _In_opt_ PCUNICODE_STRING LogFileName, _In_opt_ PGUID TmId, _In_ ULONG CreateOptions ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRenameTransactionManager ( _In_ PUNICODE_STRING LogFileName, _In_ LPGUID ExistingTransactionManagerGuid ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRecoverTransactionManager ( _In_ PKTM Tm, _In_ PLARGE_INTEGER TargetVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmCommitTransaction ( _In_ PKTRANSACTION Transaction, _In_ BOOLEAN Wait ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRollbackTransaction ( _In_ PKTRANSACTION Transaction, _In_ BOOLEAN Wait ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmCreateEnlistment ( _Out_ PHANDLE EnlistmentHandle, _In_ KPROCESSOR_MODE PreviousMode, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ PRKRESOURCEMANAGER ResourceManager, _In_ PKTRANSACTION Transaction, _In_opt_ ULONG CreateOptions, _In_ NOTIFICATION_MASK NotificationMask, _In_opt_ PVOID EnlistmentKey ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRecoverEnlistment ( _In_ PKENLISTMENT Enlistment, _In_ PVOID EnlistmentKey ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmPrePrepareEnlistment ( _In_ PKENLISTMENT Enlistment, _In_ PLARGE_INTEGER TmVirtualClock ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmPrepareEnlistment ( _In_ PKENLISTMENT Enlistment, _In_ PLARGE_INTEGER TmVirtualClock ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmCommitEnlistment ( _In_ PKENLISTMENT Enlistment, _In_ PLARGE_INTEGER TmVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRollbackEnlistment ( _In_ PKENLISTMENT Enlistment, _In_opt_ PLARGE_INTEGER TmVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmPrePrepareComplete ( _In_ PKENLISTMENT Enlistment, _In_ PLARGE_INTEGER TmVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmPrepareComplete ( _In_ PKENLISTMENT Enlistment, _In_opt_ PLARGE_INTEGER TmVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmReadOnlyEnlistment ( _In_ PKENLISTMENT Enlistment, _In_opt_ PLARGE_INTEGER TmVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmCommitComplete ( _In_ PKENLISTMENT Enlistment, _In_opt_ PLARGE_INTEGER TmVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRollbackComplete ( _In_ PKENLISTMENT Enlistment, _In_opt_ PLARGE_INTEGER TmVirtualClock ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmReferenceEnlistmentKey ( _In_ PKENLISTMENT Enlistment, _Out_ PVOID *Key ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmDereferenceEnlistmentKey ( _In_ PKENLISTMENT Enlistment, _Out_opt_ PBOOLEAN LastReference ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmSinglePhaseReject ( _In_ PKENLISTMENT Enlistment, _In_ PLARGE_INTEGER TmVirtualClock ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRequestOutcomeEnlistment ( _In_ PKENLISTMENT Enlistment, _In_ PLARGE_INTEGER TmVirtualClock ); // // ResourceManager APIs // _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmEnableCallbacks ( _In_ PKRESOURCEMANAGER ResourceManager, _In_ PTM_RM_NOTIFICATION CallbackRoutine, _In_opt_ PVOID RMKey ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmRecoverResourceManager ( _In_ PKRESOURCEMANAGER ResourceManager ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmPropagationComplete( _In_ PKRESOURCEMANAGER ResourceManager, _In_ ULONG RequestCookie, _In_ ULONG BufferLength, _In_ PVOID Buffer ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI NTSTATUS NTAPI TmPropagationFailed( _In_ PKRESOURCEMANAGER ResourceManager, _In_ ULONG RequestCookie, _In_ NTSTATUS Status ); _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI VOID NTAPI TmGetTransactionId( _In_ PKTRANSACTION Transaction, _Out_ PUOW TransactionId ); _Must_inspect_result_ _IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI BOOLEAN NTAPI TmIsTransactionActive ( _In_ PKTRANSACTION Transaction ); #define PCW_VERSION_1 0x0100 #define PCW_CURRENT_VERSION PCW_VERSION_1 typedef struct _PCW_INSTANCE *PPCW_INSTANCE; typedef struct _PCW_REGISTRATION *PPCW_REGISTRATION; typedef struct _PCW_BUFFER *PPCW_BUFFER; typedef struct _PCW_COUNTER_DESCRIPTOR { USHORT Id; USHORT StructIndex; USHORT Offset; USHORT Size; } PCW_COUNTER_DESCRIPTOR, *PPCW_COUNTER_DESCRIPTOR; typedef struct _PCW_DATA { _In_reads_bytes_(Size) const VOID *Data; _In_ ULONG Size; } PCW_DATA, *PPCW_DATA; typedef struct _PCW_COUNTER_INFORMATION { ULONG64 CounterMask; PCUNICODE_STRING InstanceMask; } PCW_COUNTER_INFORMATION, *PPCW_COUNTER_INFORMATION; typedef struct _PCW_MASK_INFORMATION { ULONG64 CounterMask; PCUNICODE_STRING InstanceMask; ULONG InstanceId; BOOLEAN CollectMultiple; PPCW_BUFFER Buffer; PKEVENT CancelEvent; } PCW_MASK_INFORMATION, *PPCW_MASK_INFORMATION; typedef union _PCW_CALLBACK_INFORMATION { PCW_COUNTER_INFORMATION AddCounter; PCW_COUNTER_INFORMATION RemoveCounter; PCW_MASK_INFORMATION EnumerateInstances; PCW_MASK_INFORMATION CollectData; } PCW_CALLBACK_INFORMATION, *PPCW_CALLBACK_INFORMATION; typedef enum _PCW_CALLBACK_TYPE { PcwCallbackAddCounter = 0, PcwCallbackRemoveCounter, PcwCallbackEnumerateInstances, PcwCallbackCollectData, } PCW_CALLBACK_TYPE, *PPCW_CALLBACK_TYPE; typedef NTSTATUS NTAPI PCW_CALLBACK( _In_ PCW_CALLBACK_TYPE Type, _In_ PPCW_CALLBACK_INFORMATION Info, _In_opt_ PVOID Context ); typedef PCW_CALLBACK *PPCW_CALLBACK; typedef struct _PCW_REGISTRATION_INFORMATION { _In_ ULONG Version; _In_ PCUNICODE_STRING Name; _In_ ULONG CounterCount; _In_reads_(CounterCount) PPCW_COUNTER_DESCRIPTOR Counters; _In_opt_ PPCW_CALLBACK Callback; _In_opt_ PVOID CallbackContext; } PCW_REGISTRATION_INFORMATION, *PPCW_REGISTRATION_INFORMATION; #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) NTSTATUS NTAPI PcwRegister( _Outptr_ PPCW_REGISTRATION *Registration, _In_ PPCW_REGISTRATION_INFORMATION Info ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) VOID NTAPI PcwUnregister( _In_ PPCW_REGISTRATION Registration ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) NTSTATUS NTAPI PcwCreateInstance( _Outptr_ PPCW_INSTANCE *Instance, _In_ PPCW_REGISTRATION Registration, _In_ PCUNICODE_STRING Name, _In_ ULONG Count, _In_reads_(Count) PPCW_DATA Data ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) VOID NTAPI PcwCloseInstance( _In_ PPCW_INSTANCE Instance ); #endif #if (NTDDI_VERSION >= NTDDI_WIN7) _IRQL_requires_max_(APC_LEVEL) NTSTATUS NTAPI PcwAddInstance( _In_ PPCW_BUFFER Buffer, _In_ PCUNICODE_STRING Name, _In_ ULONG Id, _In_ ULONG Count, _In_reads_(Count) PPCW_DATA Data ); #endif #ifndef _OB_REFERENCE_TAGS_ #define _OB_REFERENCE_TAGS_ // // Object Manager Public Reference Tags // #define REFTAG_AFDCONN 'CdfA' #define REFTAG_AFDENDPOINT 'EdfA' #define REFTAG_AFDPOLL 'PdfA' #define REFTAG_ALEIO 'IelA' #define REFTAG_ALEPROCTBL 'PelA' #define REFTAG_ALESIDTOKEN 'SelA' #define REFTAG_CFSFILTER 'FsfC' #define REFTAG_DWMKERNEL 'KmwD' #define REFTAG_HTTP 'pttH' #define REFTAG_MAILSLOT 'sFsM' #define REFTAG_NFSVOLUME 'VsfN' #define REFTAG_PGMFILE 'TmgP' #define REFTAG_PSLOOKUP 'ULsP' #define REFTAG_PSWAKE 'kWsP' #define REFTAG_RAWENDPOINT 'EwaR' #define REFTAG_TCPENDPOINT 'EpcT' #define REFTAG_TCPLISTENER 'LpcT' #define REFTAG_TCPTCB 'TpcT' #define REFTAG_UDPENDPOINT 'EpdU' #define REFTAG_USRKDESKTOP 'DrsU' #define REFTAG_VIDEO_PORT_I386 'idiV' #define REFTAG_VIDEO_PORT 'PdiV' #define REFTAG_WIN32K 'k23W' #define REFTAG_WIN32KQUEUE 'q23W' #define REFTAG_WIN32KRESTRICT 'r23W' #define REFTAG_WIN32KSERVER 'S23W' #define REFTAG_WIN32KSTUBS 's23W' #define REFTAG_WS2IFSL 'i2sW' #define REFTAG_WSKNAMERES 'NksW' #define REFTAG_WSKPROV 'PksW' #define REFTAG_WSKTDI 'TksW' #endif // _OB_REFERENCE_TAGS_ // // Define possible flags to be passed to ExInitializeDriverRuntime. These // flags define the behavior of the driver runtime opt-in package. // typedef enum _DRIVER_RUNTIME_INIT_FLAGS { // // The driver is built with POOL_NX_OPTIN and would like automatic // discovery of NonPagedPoolNx support. // // N.B. To automatically gain the benefit of DrvRtPoolNxOptIn, the driver // must also define POOL_NX_OPTIN. // DrvRtPoolNxOptIn = 0x00000001, LastDrvRtFlag } DRIVER_RUNTIME_INIT_FLAGS, * PDRIVER_RUNTIME_INIT_FLAGS; typedef const enum _DRIVER_RUNTIME_INIT_FLAGS * PCDRIVER_RUNTIME_INIT_FLAGS; FORCEINLINE VOID ExInitializeDriverRuntime( _In_ ULONG RuntimeFlags ) { #if POOL_NX_OPTIN && !POOL_NX_OPTOUT ULONG MajorVersion; ULONG MinorVersion; NTSTATUS Status; RTL_OSVERSIONINFOW VersionInfo; VersionInfo.dwOSVersionInfoSize = sizeof (VersionInfo); Status = RtlGetVersion (&VersionInfo); if (!NT_VERIFY (NT_SUCCESS (Status))) { MajorVersion = 5; MinorVersion = 0; } else { MajorVersion = VersionInfo.dwMajorVersion; MinorVersion = VersionInfo.dwMinorVersion; } if ((RuntimeFlags & DrvRtPoolNxOptIn) != 0) { // // Discover whether NX pool support is available on this platform, and, // if so, initialize the default non-paged pool type. // if ((MajorVersion > 6) || (MajorVersion == 6 && MinorVersion >= 2)) { ExDefaultNonPagedPoolType = NonPagedPoolNx; ExDefaultMdlProtection = MdlMappingNoExecute; } } #else UNREFERENCED_PARAMETER (RuntimeFlags); #endif } extern POBJECT_TYPE *CmKeyObjectType; extern POBJECT_TYPE *IoFileObjectType; extern POBJECT_TYPE *ExEventObjectType; extern POBJECT_TYPE *ExSemaphoreObjectType; extern POBJECT_TYPE *TmTransactionManagerObjectType; extern POBJECT_TYPE *TmResourceManagerObjectType; extern POBJECT_TYPE *TmEnlistmentObjectType; extern POBJECT_TYPE *TmTransactionObjectType; extern POBJECT_TYPE *PsProcessType; extern POBJECT_TYPE *PsThreadType; extern POBJECT_TYPE *PsJobType; extern POBJECT_TYPE *SeTokenObjectType; #if (NTDDI_VERSION >= NTDDI_THRESHOLD) extern POBJECT_TYPE *ExDesktopObjectType; #endif #ifdef __cplusplus } #endif #if _MSC_VER >= 1200 #pragma warning(pop) #else #pragma warning(default:4115) #pragma warning(default:4201) #pragma warning(default:4214) #endif #endif // _WDMDDK_