clouduser/SHA256
1
0
Fork 0
mirror of https://github.com/stasenso/SHA256.git synced 2026-06-27 05:42:43 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
bae0af96936fec8f0651efc3e74d475ed4ffa7f7
SHA256/includes/ntddk.inc
T

18744 lines
454 KiB
PHP
Raw Blame History

MUTEX_LEVEL_VDM_IO equ 1
MUTEX_LEVEL_EX_PROFILE equ 40h
MUTEX_LEVEL_RDR_FILESYS_DATABASE equ 10100000h
MUTEX_LEVEL_RDR_FILESYS_SECURITY equ 10100001h
MUTEX_LEVEL_FILESYSTEM_RAW_VCB equ 11000006h
MUTEX_LEVEL_STREAMS_SUBSYS equ 11001001h
MUTEX_LEVEL_PS_LDT equ 1F000000h
PULONG_PTR TYPEDEF PTR ULONG
;typedef struct _KTHREAD *PKTHREAD;
;typedef struct _ETHREAD *PETHREAD;
;typedef struct _EPROCESS *PEPROCESS;
;typedef struct _PEB *PPEB;
;typedef struct _KINTERRUPT *PKINTERRUPT;
;typedef struct _IO_TIMER *PIO_TIMER;
;typedef struct _OBJECT_TYPE *POBJECT_TYPE;
;typedef struct _CALLBACK_OBJECT *PCALLBACK_OBJECT;
;typedef struct _DEVICE_HANDLER_OBJECT *PDEVICE_HANDLER_OBJECT;
;typedef struct _BUS_HANDLER *PBUS_HANDLER;
SLIST_HEADER64 STRUC
Alignment ULONGLONG ?
Next BYTE 5 dup(?)
Sequence BYTE ?
Depth WORD ?
SLIST_HEADER64 ENDS
SLIST_HEADER TYPEDEF SLIST_HEADER64
PSLIST_HEADER TYPEDEF PTR SLIST_HEADER
SLIST_HEADER32 STRUC
Alignment ULONGLONG ?
STRUC
Next SINGLE_LIST_ENTRY<>
Depth USHORT ?
Sequence USHORT ?
ENDS
SLIST_HEADER32 ENDS
PSLIST_HEADER32 TYPEDEF PTR SLIST_HEADER32
;
;#endif
;
;
;//
;// Define alignment macros to align structure sizes and pointers up and down.
;//
;
;#define ALIGN_DOWN(length, type) \
; ((ULONG)(length) & ~(sizeof(type) - 1))
;
;#define ALIGN_UP(length, type) \
; (ALIGN_DOWN(((ULONG)(length) + sizeof(type) - 1), type))
;
;#define ALIGN_DOWN_POINTER(address, type) \
; ((PVOID)((ULONG_PTR)(address) & ~((ULONG_PTR)sizeof(type) - 1)))
;
;#define ALIGN_UP_POINTER(address, type) \
; (ALIGN_DOWN_POINTER(((ULONG_PTR)(address) + sizeof(type) - 1), type))
;
;#define POOL_TAGGING 1
;
;#ifndef DBG
;#define DBG 0
;#endif
;
;#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
;
;//
;// Kernel definitions that need to be here for forward reference purposes
;//
;
;// begin_ntndis
;//
;// Processor modes.
;//
KPROCESSOR_MODE TYPEDEF CCHAR
MODE TYPEDEF HANDLE
KernelMode equ 0
UserMode equ 1
MaximumMode equ 2
;
;// end_ntndis
;//
;// APC function types
;//
;
;//
;// Put in an empty definition for the KAPC so that the
;// routines can reference it before it is declared.
;begin_ntndis
;DPC routine
KNORMAL_ROUTINE TYPEDEF PROTO NormalContext:PVOID,SystemArgument1:PVOID,SystemArgument2:PVOID
PKNORMAL_ROUTINE TYPEDEF PTR KNORMAL_ROUTINE
KKERNEL_ROUTINE TYPEDEF PROTO Apc:PVOID,NormalRoutine:PKNORMAL_ROUTINE,NormalContext:PVOID,\
SystemArgument1:PVOID,SystemArgument2:PVOID
PKKERNEL_ROUTINE TYPEDEF PTR KKERNEL_ROUTINE
KRUNDOWN_ROUTINE TYPEDEF PROTO Apc:PVOID
PKRUNDOWN_ROUTINE TYPEDEF PTR KRUNDOWN_ROUTINE
KSYNCHRONIZE_ROUTINE TYPEDEF PROTO SynchronizeContext:PVOID
PKSYNCHRONIZE_ROUTINE TYPEDEF PTR KSYNCHRONIZE_ROUTINE
KTRANSFER_ROUTINE TYPEDEF PROTO
PKTRANSFER_ROUTINE TYPEDEF PTR KTRANSFER_ROUTINE
KAPC STRUC
kType CSHORT ?
kSize CSHORT ?
Spare0 ULONG ?
Thread PVOID ?
ApcListEntry LIST_ENTRY<>
KernelRoutine PKKERNEL_ROUTINE ?
RundownRoutine PKRUNDOWN_ROUTINE ?
NormalRoutine PKNORMAL_ROUTINE ?
NormalContext PVOID ?
SystemArgument1 PVOID ?
SystemArgument2 PVOID ?
ApcStateIndex CCHAR ?
ApcMode KPROCESSOR_MODE ?
Inserted BOOLEAN ?
KAPC ENDS
PKAPC TYPEDEF PTR KAPC
;Asynchronous Procedure Call (APC) object
KDEFERRED_ROUTINE TYPEDEF PROTO Dpc:PVOID,DeferredContext:PVOID,SystemArgument1:PVOID,SystemArgument2:PVOID
PKDEFERRED_ROUTINE TYPEDEF PTR KDEFERRED_ROUTINE
; Define DPC importance.
;
; LowImportance - Queue DPC at end of target DPC queue.
; MediumImportance - 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 of medium or high 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 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 whne 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.
KDPC_IMPORTANCE TYPEDEF DWORD
LowImportance equ 0
MediumImportance equ 1
HighImportance equ 2
;Deferred Procedure Call (DPC) object
KDPC STRUC
kType CSHORT ?
Number UCHAR ?
Importance UCHAR ?
DWORD ?
DpcListEntry LIST_ENTRY<>
DeferredRoutine PKDEFERRED_ROUTINE ?
DeferredContext PVOID ?
SystemArgument1 PVOID ?
SystemArgument2 PVOID ?
kLock PULONG_PTR ?
KDPC ENDS
PKDPC TYPEDEF PTR KDPC
; Interprocessor interrupt worker routine function prototype.
PKIPI_CONTEXT TYPEDEF PVOID
KIPI_WORKER TYPEDEF PROTO PacketContext:PKIPI_CONTEXT,Parameter1:PVOID,Parameter2:PVOID,Parameter3:PVOID
PKIPI_WORKER TYPEDEF PTR KIPI_WORKER
KIPI_COUNTS STRUC
Freeze ULONG ?
Packet ULONG ?
DPC ULONG ?
APC ULONG ?
FlushSingleTb ULONG ?
FlushMultipleTb ULONG ?
FlushEntireTb ULONG ?
GenericCall ULONG ?
ChangeColor ULONG ?
SweepDcache ULONG ?
SweepIcache ULONG ?
SweepIcacheRange ULONG ?
FlushIoBuffers ULONG ?
GratuitousDPC ULONG ?
KIPI_COUNTS ENDS
PKIPI_COUNTS TYPEDEF PTR KIPI_COUNTS
;#if defined(NT_UP)
;
;#define HOT_STATISTIC(a) a
;
;#else
;
;#define HOT_STATISTIC(a) (KeGetCurrentPrcb()->a)
;
;#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. In a future compiler this will
; be placed at:
;
; ULONG Pages[];
;
; Until this declaration is permitted, however, one simply calculates the
; base of the array by adding one to the base MDL pointer:
;
; Pages = (PULONG) (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
MDL STRUC
Next PVOID ?
mSize CSHORT ?
MdlFlags CSHORT ?
DWORD ?
Process PVOID ?
MappedSystemVa PVOID ?
StartVa PVOID ?
ByteCount ULONG ?
ByteOffset ULONG ?
MDL ENDS
PMDL TYPEDEF PTR MDL
MDL_MAPPED_TO_SYSTEM_VA equ 0001h
MDL_PAGES_LOCKED equ 0002h
MDL_SOURCE_IS_NONPAGED_POOL equ 0004h
MDL_ALLOCATED_FIXED_SIZE equ 0008h
MDL_PARTIAL equ 0010h
MDL_PARTIAL_HAS_BEEN_MAPPED equ 0020h
MDL_IO_PAGE_READ equ 0040h
MDL_WRITE_OPERATION equ 0080h
MDL_PARENT_MAPPED_SYSTEM_VA equ 0100h
MDL_LOCK_HELD equ 0200h
MDL_PHYSICAL_VIEW equ 0400h
MDL_IO_SPACE equ 0800h
MDL_NETWORK_HEADER equ 1000h
MDL_MAPPING_CAN_FAIL equ 2000h
MDL_ALLOCATED_MUST_SUCCEED equ 4000h
MDL_MAPPING_FLAGS equ MDL_MAPPED_TO_SYSTEM_VA or MDL_PAGES_LOCKED or MDL_SOURCE_IS_NONPAGED_POOL or MDL_PARTIAL_HAS_BEEN_MAPPED or \
MDL_PARENT_MAPPED_SYSTEM_VA or MDL_LOCK_HELD or MDL_SYSTEM_VA or MDL_IO_SPACE
; end_ntndis
; switch to DBG when appropriate
;#if DBG
;#define PAGED_CODE() \
; if (KeGetCurrentIrql() > APC_LEVEL) { \
; KdPrint(( "EX: Pageable code called at IRQL %d\n", KeGetCurrentIrql() )); \
; ASSERT(FALSE); \
; }
;#else
;#define PAGED_CODE()
;#endif
; Define function decoration depending on whether a driver, a file system,
; or a kernel component is being built.
; end_wdm
;#if (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_)) && !defined(_BLDR_)
;
;#define NTKERNELAPI DECLSPEC_IMPORT // wdm
;
;#else
;
;#define NTKERNELAPI
;
;#endif
; Define function decoration depending on whether the HAL or other kernel
; component is being build.
;#if !defined(_NTHAL_) && !defined(_BLDR_)
;
;#define NTHALAPI DECLSPEC_IMPORT // wdm
;
;#else
;
;#define NTHALAPI
;
;#endif
; 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.
PACCESS_TOKEN TYPEDEF PVOID ;winnt
PSECURITY_DESCRIPTOR TYPEDEF PVOID ;winnt
; Define a pointer to the Security ID data type (an opaque data type)
PSID TYPEDEF PVOID ;winnt
ACCESS_MASK TYPEDEF ULONG
PACCESS_MASK TYPEDEF ACCESS_MASK
;end_winnt
;The following are masks for the predefined standard access types
;
;DELETE equ 00010000h
;READ_CONTROL equ 00020000h
;WRITE_DAC equ 00040000h
;WRITE_OWNER equ 00080000h
;SYNCHRONIZE equ 00100000h
;STANDARD_RIGHTS_REQUIRED equ 000F0000h
;STANDARD_RIGHTS_READ equ READ_CONTROL
;STANDARD_RIGHTS_WRITE equ READ_CONTROL
;STANDARD_RIGHTS_EXECUTE equ READ_CONTROL
;STANDARD_RIGHTS_ALL equ 001F0000h
;SPECIFIC_RIGHTS_ALL equ 0000FFFFh
;; AccessSystemAcl access type
;ACCESS_SYSTEM_SECURITY equ 01000000h
;;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 pshpack4.inc
;
;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 <poppack.h>
;
;// 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_USED_FOR_ACCESS (0x80000000L)
;
;//
;// 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)
;
;//
;// Unsolicited Input is obsolete and unused.
;//
;
;#define SE_UNSOLICITED_INPUT_PRIVILEGE (6L)
;
;#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_MAX_WELL_KNOWN_PRIVILEGE (SE_ENABLE_DELEGATION_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 DEFAULT_IMPERSONATION_LEVEL SecurityImpersonation
;
;//
;// 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 PROTECTED_DACL_SECURITY_INFORMATION (0x80000000L)
;#define PROTECTED_SACL_SECURITY_INFORMATION (0x40000000L)
;#define UNPROTECTED_DACL_SECURITY_INFORMATION (0x20000000L)
;#define UNPROTECTED_SACL_SECURITY_INFORMATION (0x10000000L)
;
;
;#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
;// begin_winnt
;#define MAXIMUM_WAIT_OBJECTS 64 // Maximum number of wait objects
;
;#define MAXIMUM_SUSPEND_COUNT MAXCHAR // Maximum times thread can be suspended
;// end_winnt
;
;//
;// Thread affinity
;//
;
;typedef ULONG KAFFINITY;
;typedef KAFFINITY *PKAFFINITY;
;
;//
;// Thread priority
;//
;
;typedef LONG KPRIORITY;
;
;//
;// Spin Lock
;//
;
;// begin_ntndis begin_winnt
;
;typedef ULONG_PTR KSPIN_LOCK;
;typedef KSPIN_LOCK *PKSPIN_LOCK;
;
;// end_ntndis end_winnt
;
;//
;// Interrupt routine (first level dispatch)
;//
;
;typedef
;VOID
;(*PKINTERRUPT_ROUTINE) (
; VOID
; );
;
;//
;// 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;
;
;//
;// for move macros
;//
;#ifdef _MAC
;#ifndef _INC_STRING
;#include <string.h>
;#endif /* _INC_STRING */
;#else
;#include <string.h>
;#endif // _MAC
;
;//
;// If debugging support enabled, define an ASSERT macro that works. Otherwise
;// define the ASSERT macro to expand to an empty expression.
;//
;
;#if DBG
;NTSYSAPI
;VOID
;NTAPI
;RtlAssert(
; PVOID FailedAssertion,
; PVOID FileName,
; ULONG LineNumber,
; PCHAR Message
; );
;
;#define ASSERT( exp ) \
; if (!(exp)) \
; RtlAssert( #exp, __FILE__, __LINE__, NULL )
;
;#define ASSERTMSG( msg, exp ) \
; if (!(exp)) \
; RtlAssert( #exp, __FILE__, __LINE__, msg )
;
;#else
;#define ASSERT( exp )
;#define ASSERTMSG( msg, exp )
;#endif // DBG
;
;//
;// Doubly-linked list manipulation routines. Implemented as macros
;// but logically these are procedures.
;//
;
;//
;// VOID
;// InitializeListHead(
;// PLIST_ENTRY ListHead
;// );
;//
;
;#define InitializeListHead(ListHead) (\
; (ListHead)->Flink = (ListHead)->Blink = (ListHead))
;
;//
;// BOOLEAN
;// IsListEmpty(
;// PLIST_ENTRY ListHead
;// );
;//
;
;#define IsListEmpty(ListHead) \
; ((ListHead)->Flink == (ListHead))
;
;//
;// PLIST_ENTRY
;// RemoveHeadList(
;// PLIST_ENTRY ListHead
;// );
;//
;
;#define RemoveHeadList(ListHead) \
; (ListHead)->Flink;\
; {RemoveEntryList((ListHead)->Flink)}
;
;//
;// PLIST_ENTRY
;// RemoveTailList(
;// PLIST_ENTRY ListHead
;// );
;//
;
;#define RemoveTailList(ListHead) \
; (ListHead)->Blink;\
; {RemoveEntryList((ListHead)->Blink)}
;
;//
;// VOID
;// RemoveEntryList(
;// PLIST_ENTRY Entry
;// );
;//
;
;#define RemoveEntryList(Entry) {\
; PLIST_ENTRY _EX_Blink;\
; PLIST_ENTRY _EX_Flink;\
; _EX_Flink = (Entry)->Flink;\
; _EX_Blink = (Entry)->Blink;\
; _EX_Blink->Flink = _EX_Flink;\
; _EX_Flink->Blink = _EX_Blink;\
; }
;
;//
;// VOID
;// InsertTailList(
;// PLIST_ENTRY ListHead,
;// PLIST_ENTRY Entry
;// );
;//
;
;#define InsertTailList(ListHead,Entry) {\
; PLIST_ENTRY _EX_Blink;\
; PLIST_ENTRY _EX_ListHead;\
; _EX_ListHead = (ListHead);\
; _EX_Blink = _EX_ListHead->Blink;\
; (Entry)->Flink = _EX_ListHead;\
; (Entry)->Blink = _EX_Blink;\
; _EX_Blink->Flink = (Entry);\
; _EX_ListHead->Blink = (Entry);\
; }
;
;//
;// VOID
;// InsertHeadList(
;// PLIST_ENTRY ListHead,
;// PLIST_ENTRY Entry
;// );
;//
;
;#define InsertHeadList(ListHead,Entry) {\
; PLIST_ENTRY _EX_Flink;\
; PLIST_ENTRY _EX_ListHead;\
; _EX_ListHead = (ListHead);\
; _EX_Flink = _EX_ListHead->Flink;\
; (Entry)->Flink = _EX_Flink;\
; (Entry)->Blink = _EX_ListHead;\
; _EX_Flink->Blink = (Entry);\
; _EX_ListHead->Flink = (Entry);\
; }
;
;//
;//
;// PSINGLE_LIST_ENTRY
;// PopEntryList(
;// PSINGLE_LIST_ENTRY ListHead
;// );
;//
;
;#define PopEntryList(ListHead) \
; (ListHead)->Next;\
; {\
; PSINGLE_LIST_ENTRY FirstEntry;\
; FirstEntry = (ListHead)->Next;\
; if (FirstEntry != NULL) { \
; (ListHead)->Next = FirstEntry->Next;\
; } \
; }
;
;
;//
;// VOID
;// PushEntryList(
;// PSINGLE_LIST_ENTRY ListHead,
;// PSINGLE_LIST_ENTRY Entry
;// );
;//
;
;#define PushEntryList(ListHead,Entry) \
; (Entry)->Next = (ListHead)->Next; \
; (ListHead)->Next = (Entry)
;
;// end_wdm end_nthal end_ntifs end_ntndis
;
;
;
;#if defined(_M_ALPHA) || defined(_M_AXP64) || defined(_M_IA64)
;PVOID
;_ReturnAddress (
; VOID
; );
;
;#pragma intrinsic(_ReturnAddress)
;
;#define RtlGetCallersAddress(CallersAddress, CallersCaller) \
; *CallersAddress = (PVOID)_ReturnAddress(); \
; *CallersCaller = NULL;
;#else
;NTSYSAPI
;VOID
;NTAPI
;RtlGetCallersAddress(
; OUT PVOID *CallersAddress,
; OUT PVOID *CallersCaller
; );
;#endif
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlWalkFrameChain (
; OUT PVOID *Callers,
; IN ULONG Count,
; IN ULONG Flags);
;
;//
;// Subroutines for dealing with the Registry
;//
;
;typedef NTSTATUS (NTAPI * PRTL_QUERY_REGISTRY_ROUTINE)(
; IN PWSTR ValueName,
; IN ULONG ValueType,
; IN PVOID ValueData,
; IN ULONG ValueLength,
; IN PVOID Context,
; IN PVOID EntryContext
; );
;
;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.
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlQueryRegistryValues(
; IN ULONG RelativeTo,
; IN PCWSTR Path,
; IN PRTL_QUERY_REGISTRY_TABLE QueryTable,
; IN PVOID Context,
; IN PVOID Environment OPTIONAL
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlWriteRegistryValue(
; IN ULONG RelativeTo,
; IN PCWSTR Path,
; IN PCWSTR ValueName,
; IN ULONG ValueType,
; IN PVOID ValueData,
; IN ULONG ValueLength
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlDeleteRegistryValue(
; IN ULONG RelativeTo,
; IN PCWSTR Path,
; IN PCWSTR ValueName
; );
;
;// end_wdm
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlCreateRegistryKey(
; IN ULONG RelativeTo,
; IN PWSTR Path
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlCheckRegistryKey(
; IN ULONG RelativeTo,
; IN PWSTR Path
; );
;
;// begin_wdm
;//
;// The following values for the RelativeTo parameter determine what the
;// Path parameter to RtlQueryRegistryValues is relative to.
;//
;
RTL_REGISTRY_ABSOLUTE equ 0 ; Path is a full path
RTL_REGISTRY_SERVICES equ 1 ; \Registry\Machine\System\CurrentControlSet\Services
RTL_REGISTRY_CONTROL equ 2 ; \Registry\Machine\System\CurrentControlSet\Control
RTL_REGISTRY_WINDOWS_NT equ 3 ; \Registry\Machine\Software\Microsoft\Windows NT\CurrentVersion
RTL_REGISTRY_DEVICEMAP equ 4 ; \Registry\Machine\Hardware\DeviceMap
RTL_REGISTRY_USER equ 5 ; \Registry\User\CurrentUser
RTL_REGISTRY_MAXIMUM equ 6
RTL_REGISTRY_HANDLE equ 40000000h ; Low order bits are registry handle
RTL_REGISTRY_OPTIONAL equ 80000000h ; Indicates the key node is optional
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlCharToInteger (
; PCSZ String,
; ULONG Base,
; PULONG Value
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlIntegerToUnicodeString (
; ULONG Value,
; ULONG Base,
; PUNICODE_STRING String
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlInt64ToUnicodeString (
; IN ULONGLONG Value,
; IN ULONG Base OPTIONAL,
; IN OUT PUNICODE_STRING String
; );
;
;#ifdef _WIN64
;#define RtlIntPtrToUnicodeString(Value, Base, String) RtlInt64ToUnicodeString(Value, Base, String)
;#else
;#define RtlIntPtrToUnicodeString(Value, Base, String) RtlIntegerToUnicodeString(Value, Base, String)
;#endif
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlUnicodeStringToInteger (
; PUNICODE_STRING String,
; ULONG Base,
; PULONG Value
; );
;
;
;//
;// 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
;
;NTSYSAPI
;VOID
;NTAPI
;RtlInitString(
; PSTRING DestinationString,
; PCSZ SourceString
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlInitAnsiString(
; PANSI_STRING DestinationString,
; PCSZ SourceString
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlInitUnicodeString(
; PUNICODE_STRING DestinationString,
; PCWSTR SourceString
; );
;
;
;NTSYSAPI
;VOID
;NTAPI
;RtlCopyString(
; PSTRING DestinationString,
; PSTRING SourceString
; );
;
;NTSYSAPI
;CHAR
;NTAPI
;RtlUpperChar (
; CHAR Character
; );
;
;NTSYSAPI
;LONG
;NTAPI
;RtlCompareString(
; PSTRING String1,
; PSTRING String2,
; BOOLEAN CaseInSensitive
; );
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlEqualString(
; PSTRING String1,
; PSTRING String2,
; BOOLEAN CaseInSensitive
; );
;
;
;NTSYSAPI
;VOID
;NTAPI
;RtlUpperString(
; PSTRING DestinationString,
; PSTRING SourceString
; );
;
;//
;// NLS String functions
;//
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlAnsiStringToUnicodeString(
; PUNICODE_STRING DestinationString,
; PANSI_STRING SourceString,
; BOOLEAN AllocateDestinationString
; );
;
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlUnicodeStringToAnsiString(
; PANSI_STRING DestinationString,
; PUNICODE_STRING SourceString,
; BOOLEAN AllocateDestinationString
; );
;
;
;NTSYSAPI
;LONG
;NTAPI
;RtlCompareUnicodeString(
; PUNICODE_STRING String1,
; PUNICODE_STRING String2,
; BOOLEAN CaseInSensitive
; );
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlEqualUnicodeString(
; const UNICODE_STRING *String1,
; const UNICODE_STRING *String2,
; BOOLEAN CaseInSensitive
; );
;
;// end_wdm
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlPrefixUnicodeString(
; IN PUNICODE_STRING String1,
; IN PUNICODE_STRING String2,
; IN BOOLEAN CaseInSensitive
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlUpcaseUnicodeString(
; PUNICODE_STRING DestinationString,
; PCUNICODE_STRING SourceString,
; BOOLEAN AllocateDestinationString
; );
;
;
;NTSYSAPI
;VOID
;NTAPI
;RtlCopyUnicodeString(
; PUNICODE_STRING DestinationString,
; PUNICODE_STRING SourceString
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlAppendUnicodeStringToString (
; PUNICODE_STRING Destination,
; PUNICODE_STRING Source
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlAppendUnicodeToString (
; PUNICODE_STRING Destination,
; PCWSTR Source
; );
;
;// end_ntndis end_wdm
;
;NTSYSAPI
;WCHAR
;NTAPI
;RtlUpcaseUnicodeChar(
; WCHAR SourceCharacter
; );
;
;// begin_wdm
;
;NTSYSAPI
;VOID
;NTAPI
;RtlFreeUnicodeString(
; PUNICODE_STRING UnicodeString
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlFreeAnsiString(
; PANSI_STRING AnsiString
; );
;
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlxAnsiStringToUnicodeSize(
; PANSI_STRING AnsiString
; );
;
;//
;// NTSYSAPI
;// ULONG
;// NTAPI
;// RtlAnsiStringToUnicodeSize(
;// PANSI_STRING AnsiString
;// );
;//
;
;#define RtlAnsiStringToUnicodeSize(STRING) ( \
; NLS_MB_CODE_PAGE_TAG ? \
; RtlxAnsiStringToUnicodeSize(STRING) : \
; ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \
;)
;
;
;// begin_ntminiport
;
;#include <guiddef.h>
;
;// end_ntminiport
;
;#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__
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlStringFromGUID(
; IN REFGUID Guid,
; OUT PUNICODE_STRING GuidString
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlGUIDFromString(
; IN PUNICODE_STRING GuidString,
; OUT GUID* Guid
; );
;
;//
;// Fast primitives to compare, move, and zero memory
;//
;
;// begin_winnt begin_ntndis
;
;NTSYSAPI
;SIZE_T
;NTAPI
;RtlCompareMemory (
; const VOID *Source1,
; const VOID *Source2,
; SIZE_T Length
; );
;
;#if defined(_M_AXP64) || defined(_M_IA64)
;
;#define RtlEqualMemory(Source1, Source2, Length) \
; ((Length) == RtlCompareMemory(Source1, Source2, Length))
;
;NTSYSAPI
;VOID
;NTAPI
;RtlCopyMemory (
; VOID UNALIGNED *Destination,
; CONST VOID UNALIGNED *Source,
; SIZE_T Length
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlCopyMemory32 (
; VOID UNALIGNED *Destination,
; CONST VOID UNALIGNED *Source,
; ULONG Length
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlMoveMemory (
; VOID UNALIGNED *Destination,
; CONST VOID UNALIGNED *Source,
; SIZE_T Length
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlFillMemory (
; VOID UNALIGNED *Destination,
; SIZE_T Length,
; UCHAR Fill
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlZeroMemory (
; VOID UNALIGNED *Destination,
; SIZE_T Length
; );
;
;#else
;
;#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))
;
;#endif
;
;// end_ntndis end_winnt
;
;#if defined(_M_ALPHA)
;
;//
;// Guaranteed byte granularity memory copy function.
;//
;
;NTSYSAPI
;VOID
;NTAPI
;RtlCopyBytes (
; PVOID Destination,
; CONST VOID *Source,
; SIZE_T Length
; );
;
;//
;// Guaranteed byte granularity memory zero function.
;//
;
;NTSYSAPI
;VOID
;NTAPI
;RtlZeroBytes (
; PVOID Destination,
; SIZE_T Length
; );
;
;//
;// Guaranteed byte granularity memory fill function.
;//
;
;NTSYSAPI
;VOID
;NTAPI
;RtlFillBytes (
; PVOID Destination,
; SIZE_T Length,
; UCHAR Fill
; );
;
;#else
;
;#define RtlCopyBytes RtlCopyMemory
;#define RtlZeroBytes RtlZeroMemory
;#define RtlFillBytes RtlFillMemory
;
;#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.
;//
;
;VOID
;NTAPI
;DbgBreakPoint(
; VOID
; );
;
;// end_wdm
;
;NTSYSAPI
;VOID
;NTAPI
;DbgBreakPointWithStatus(
; IN ULONG Status
; );
;
;// begin_wdm
;
;#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
;
;#if DBG
;
;#define KdPrint(_x_) DbgPrint _x_
;#define KdBreakPoint() DbgBreakPoint()
;
;// end_wdm
;
;#define KdBreakPointWithStatus(s) DbgBreakPointWithStatus(s)
;
;// begin_wdm
;
;#else
;
;#define KdPrint(_x_)
;#define KdBreakPoint()
;
;// end_wdm
;
;#define KdBreakPointWithStatus(s)
;
;// begin_wdm
;#endif
;
;#ifndef _DBGNT_
;
;ULONG
;_cdecl
;DbgPrint(
; PCH Format,
; ...
; );
;
;// end_wdm
;
;ULONG
;_cdecl
;DbgPrintReturnControlC(
; PCH Format,
; ...
; );
;
;// begin_wdm
;#endif // _DBGNT_
;//
;// Large integer arithmetic routines.
;//
;
;//
;// Large integer add - 64-bits + 64-bits -> 64-bits
;//
;
;#if !defined(MIDL_PASS)
;
;__inline
;LARGE_INTEGER
;NTAPI
;RtlLargeIntegerAdd (
; LARGE_INTEGER Addend1,
; LARGE_INTEGER Addend2
; )
;{
; LARGE_INTEGER Sum;
;
; Sum.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
; return Sum;
;}
;
;//
;// Enlarged integer multiply - 32-bits * 32-bits -> 64-bits
;//
;
;__inline
;LARGE_INTEGER
;NTAPI
;RtlEnlargedIntegerMultiply (
; LONG Multiplicand,
; LONG Multiplier
; )
;{
; LARGE_INTEGER Product;
;
; Product.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
; return Product;
;}
;
;//
;// Unsigned enlarged integer multiply - 32-bits * 32-bits -> 64-bits
;//
;
;__inline
;LARGE_INTEGER
;NTAPI
;RtlEnlargedUnsignedMultiply (
; ULONG Multiplicand,
; ULONG Multiplier
; )
;{
; LARGE_INTEGER Product;
;
; Product.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
; return Product;
;}
;
;//
;// Enlarged integer divide - 64-bits / 32-bits > 32-bits
;//
;
;__inline
;ULONG
;NTAPI
;RtlEnlargedUnsignedDivide (
; IN ULARGE_INTEGER Dividend,
; IN ULONG Divisor,
; IN 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)
;//
;
;__inline
;LARGE_INTEGER
;NTAPI
;RtlLargeIntegerNegate (
; LARGE_INTEGER Subtrahend
; )
;{
; LARGE_INTEGER Difference;
;
; Difference.QuadPart = -Subtrahend.QuadPart;
; return Difference;
;}
;
;//
;// Large integer subtract - 64-bits - 64-bits -> 64-bits.
;//
;
;__inline
;LARGE_INTEGER
;NTAPI
;RtlLargeIntegerSubtract (
; LARGE_INTEGER Minuend,
; LARGE_INTEGER Subtrahend
; )
;{
; LARGE_INTEGER Difference;
;
; Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
; return Difference;
;}
;
;#endif
;
;//
;// Extended large integer magic divide - 64-bits / 32-bits -> 64-bits
;//
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlExtendedMagicDivide (
; LARGE_INTEGER Dividend,
; LARGE_INTEGER MagicDivisor,
; CCHAR ShiftCount
; );
;
;//
;// Large Integer divide - 64-bits / 32-bits -> 64-bits
;//
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlExtendedLargeIntegerDivide (
; LARGE_INTEGER Dividend,
; ULONG Divisor,
; PULONG Remainder
; );
;
;// end_wdm
;//
;// Large Integer divide - 64-bits / 32-bits -> 64-bits
;//
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlLargeIntegerDivide (
; LARGE_INTEGER Dividend,
; LARGE_INTEGER Divisor,
; PLARGE_INTEGER Remainder
; );
;
;// begin_wdm
;//
;// Extended integer multiply - 32-bits * 64-bits -> 64-bits
;//
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlExtendedIntegerMultiply (
; LARGE_INTEGER Multiplicand,
; LONG Multiplier
; );
;
;//
;// Large integer and - 64-bite & 64-bits -> 64-bits.
;//
;
;#define RtlLargeIntegerAnd(Result, Source, Mask) \
; { \
; Result.HighPart = Source.HighPart & Mask.HighPart; \
; Result.LowPart = Source.LowPart & Mask.LowPart; \
; }
;
;//
;// Large integer conversion routines.
;//
;
;#if defined(MIDL_PASS) || defined(__cplusplus) || !defined(_M_IX86)
;
;//
;// Convert signed integer to large integer.
;//
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlConvertLongToLargeInteger (
; LONG SignedInteger
; );
;
;//
;// Convert unsigned integer to large integer.
;//
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlConvertUlongToLargeInteger (
; ULONG UnsignedInteger
; );
;
;
;//
;// Large integer shift routines.
;//
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlLargeIntegerShiftLeft (
; LARGE_INTEGER LargeInteger,
; CCHAR ShiftCount
; );
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlLargeIntegerShiftRight (
; LARGE_INTEGER LargeInteger,
; CCHAR ShiftCount
; );
;
;NTSYSAPI
;LARGE_INTEGER
;NTAPI
;RtlLargeIntegerArithmeticShift (
; LARGE_INTEGER LargeInteger,
; CCHAR ShiftCount
; );
;
;#else
;
;#if _MSC_VER >= 1200
;#pragma warning(push)
;#endif
;#pragma warning(disable:4035) // re-enable below
;
;//
;// Convert signed integer to large integer.
;//
;
;__inline LARGE_INTEGER
;NTAPI
;RtlConvertLongToLargeInteger (
; LONG SignedInteger
; )
;{
; __asm {
; mov eax, SignedInteger
; cdq ; (edx:eax) = signed LargeInt
; }
;}
;
;//
;// Convert unsigned integer to large integer.
;//
;
;__inline LARGE_INTEGER
;NTAPI
;RtlConvertUlongToLargeInteger (
; ULONG UnsignedInteger
; )
;{
; __asm {
; sub edx, edx ; zero highpart
; mov eax, UnsignedInteger
; }
;}
;
;//
;// Large integer shift routines.
;//
;
;__inline LARGE_INTEGER
;NTAPI
;RtlLargeIntegerShiftLeft (
; LARGE_INTEGER LargeInteger,
; CCHAR ShiftCount
; )
;{
; __asm {
; mov cl, ShiftCount
; and cl, 0x3f ; mod 64
;
; cmp cl, 32
; jc short sl10
;
; mov edx, LargeInteger.LowPart ; ShiftCount >= 32
; xor eax, eax ; lowpart is zero
; shl edx, cl ; store highpart
; jmp short done
;
;sl10:
; mov eax, LargeInteger.LowPart ; ShiftCount < 32
; mov edx, LargeInteger.HighPart
; shld edx, eax, cl
; shl eax, cl
;done:
; }
;}
;
;
;__inline LARGE_INTEGER
;NTAPI
;RtlLargeIntegerShiftRight (
; LARGE_INTEGER LargeInteger,
; CCHAR ShiftCount
; )
;{
; __asm {
; mov cl, ShiftCount
; and cl, 0x3f ; mod 64
;
; cmp cl, 32
; jc short sr10
;
; mov eax, LargeInteger.HighPart ; ShiftCount >= 32
; xor edx, edx ; lowpart is zero
; shr eax, cl ; store highpart
; jmp short done
;
;sr10:
; mov eax, LargeInteger.LowPart ; ShiftCount < 32
; mov edx, LargeInteger.HighPart
; shrd eax, edx, cl
; shr edx, cl
;done:
; }
;}
;
;
;__inline LARGE_INTEGER
;NTAPI
;RtlLargeIntegerArithmeticShift (
; LARGE_INTEGER LargeInteger,
; CCHAR ShiftCount
; )
;{
; __asm {
; mov cl, ShiftCount
; and cl, 3fh ; mod 64
;
; cmp cl, 32
; jc short sar10
;
; mov eax, LargeInteger.HighPart
; sar eax, cl
; bt eax, 31 ; sign bit set?
; sbb edx, edx ; duplicate sign bit into highpart
; jmp short done
;sar10:
; mov eax, LargeInteger.LowPart ; (eax) = LargeInteger.LowPart
; mov edx, LargeInteger.HighPart ; (edx) = LargeInteger.HighPart
; shrd eax, edx, cl
; sar edx, cl
;done:
; }
;}
;
;#if _MSC_VER >= 1200
;#pragma warning(pop)
;#else
;#pragma warning(default:4035)
;#endif
;
;#endif
;
;//
;// Large integer comparison routines.
;//
;// BOOLEAN
;// RtlLargeIntegerGreaterThan (
;// LARGE_INTEGER Operand1,
;// LARGE_INTEGER Operand2
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerGreaterThanOrEqualTo (
;// LARGE_INTEGER Operand1,
;// LARGE_INTEGER Operand2
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerEqualTo (
;// LARGE_INTEGER Operand1,
;// LARGE_INTEGER Operand2
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerNotEqualTo (
;// LARGE_INTEGER Operand1,
;// LARGE_INTEGER Operand2
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerLessThan (
;// LARGE_INTEGER Operand1,
;// LARGE_INTEGER Operand2
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerLessThanOrEqualTo (
;// LARGE_INTEGER Operand1,
;// LARGE_INTEGER Operand2
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerGreaterThanZero (
;// LARGE_INTEGER Operand
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerGreaterOrEqualToZero (
;// LARGE_INTEGER Operand
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerEqualToZero (
;// LARGE_INTEGER Operand
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerNotEqualToZero (
;// LARGE_INTEGER Operand
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerLessThanZero (
;// LARGE_INTEGER Operand
;// );
;//
;// BOOLEAN
;// RtlLargeIntegerLessOrEqualToZero (
;// LARGE_INTEGER Operand
;// );
;//
;
;#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) \
;)
;
;
;//
;// 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;
;
;
;NTSYSAPI
;VOID
;NTAPI
;RtlTimeToTimeFields (
; PLARGE_INTEGER Time,
; PTIME_FIELDS TimeFields
; );
;
;//
;// A time field record (Weekday ignored) -> 64 bit Time value
;//
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlTimeFieldsToTime (
; PTIME_FIELDS TimeFields,
; PLARGE_INTEGER Time
; );
;
;//
;// 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.
;//
;//--
;
;#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; \
; }
;
;
;//++
;//
;// 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.
;//
;//--
;
;#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); \
; }
;
;//++
;//
;// 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.
;//
;//--
;
;#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); \
; }
;
;//++
;//
;// 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.
;//
;//--
;
;#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); \
; } \
;
;//++
;//
;// 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.
;//
;//--
;
;#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); \
; }
;//
;// 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.
;//
;
;NTSYSAPI
;VOID
;NTAPI
;RtlInitializeBitMap (
; PRTL_BITMAP BitMapHeader,
; PULONG BitMapBuffer,
; ULONG SizeOfBitMap
; );
;
;//
;// The following two routines either clear or set all of the bits
;// in a bitmap.
;//
;
;NTSYSAPI
;VOID
;NTAPI
;RtlClearAllBits (
; PRTL_BITMAP BitMapHeader
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlSetAllBits (
; PRTL_BITMAP BitMapHeader
; );
;
;//
;// 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
;//
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindClearBits (
; PRTL_BITMAP BitMapHeader,
; ULONG NumberToFind,
; ULONG HintIndex
; );
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindSetBits (
; PRTL_BITMAP BitMapHeader,
; ULONG NumberToFind,
; ULONG HintIndex
; );
;
;//
;// 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.
;//
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindClearBitsAndSet (
; PRTL_BITMAP BitMapHeader,
; ULONG NumberToFind,
; ULONG HintIndex
; );
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindSetBitsAndClear (
; PRTL_BITMAP BitMapHeader,
; ULONG NumberToFind,
; ULONG HintIndex
; );
;
;//
;// The following two routines clear or set bits within a specified region
;// of the bitmap. The starting index is zero based.
;//
;
;NTSYSAPI
;VOID
;NTAPI
;RtlClearBits (
; PRTL_BITMAP BitMapHeader,
; ULONG StartingIndex,
; ULONG NumberToClear
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlSetBits (
; PRTL_BITMAP BitMapHeader,
; ULONG StartingIndex,
; ULONG NumberToSet
; );
;
;//
;// 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;
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindClearRuns (
; PRTL_BITMAP BitMapHeader,
; PRTL_BITMAP_RUN RunArray,
; ULONG SizeOfRunArray,
; BOOLEAN LocateLongestRuns
; );
;
;//
;// 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.
;//
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindLongestRunClear (
; PRTL_BITMAP BitMapHeader,
; PULONG StartingIndex
; );
;
;//
;// 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.
;//
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindFirstRunClear (
; PRTL_BITMAP BitMapHeader,
; PULONG StartingIndex
; );
;
;//
;// 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.
;//
;
;#define RtlCheckBit(BMH,BP) ((((BMH)->Buffer[(BP) / 32]) >> ((BP) % 32)) & 0x1)
;
;//
;// The following two procedures return to the caller the total number of
;// clear or set bits within the specified bitmap.
;//
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlNumberOfClearBits (
; PRTL_BITMAP BitMapHeader
; );
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlNumberOfSetBits (
; PRTL_BITMAP BitMapHeader
; );
;
;//
;// The following two procedures return to the caller a boolean value
;// indicating if the specified range of bits are all clear or set.
;//
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlAreBitsClear (
; PRTL_BITMAP BitMapHeader,
; ULONG StartingIndex,
; ULONG Length
; );
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlAreBitsSet (
; PRTL_BITMAP BitMapHeader,
; ULONG StartingIndex,
; ULONG Length
; );
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindNextForwardRunClear (
; IN PRTL_BITMAP BitMapHeader,
; IN ULONG FromIndex,
; IN PULONG StartingRunIndex
; );
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlFindLastBackwardRunClear (
; IN PRTL_BITMAP BitMapHeader,
; IN ULONG FromIndex,
; IN PULONG StartingRunIndex
; );
;
;//
;// 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.
;//
;
;NTSYSAPI
;CCHAR
;NTAPI
;RtlFindLeastSignificantBit (
; IN ULONGLONG Set
; );
;
;NTSYSAPI
;CCHAR
;NTAPI
;RtlFindMostSignificantBit (
; IN ULONGLONG Set
; );
;
;
;//
;// 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))
;
;
;#if !defined(MIDL_PASS)
;
;__inline LUID
;NTAPI
;RtlConvertLongToLuid(
; LONG Long
; )
;{
; LUID TempLuid;
; LARGE_INTEGER TempLi;
;
; TempLi = RtlConvertLongToLargeInteger(Long);
; TempLuid.LowPart = TempLi.LowPart;
; TempLuid.HighPart = TempLi.HighPart;
; return(TempLuid);
;}
;
;__inline LUID
;NTAPI
;RtlConvertUlongToLuid(
; ULONG Ulong
; )
;{
; LUID TempLuid;
;
; TempLuid.LowPart = Ulong;
; TempLuid.HighPart = 0;
; return(TempLuid);
;}
;#endif
;
;
;NTSYSAPI
;VOID
;NTAPI
;RtlMapGenericMask(
; PACCESS_MASK AccessMask,
; PGENERIC_MAPPING GenericMapping
; );
;//
;// SecurityDescriptor RTL routine definitions
;//
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlCreateSecurityDescriptor (
; PSECURITY_DESCRIPTOR SecurityDescriptor,
; ULONG Revision
; );
;
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlValidSecurityDescriptor (
; PSECURITY_DESCRIPTOR SecurityDescriptor
; );
;
;
;NTSYSAPI
;ULONG
;NTAPI
;RtlLengthSecurityDescriptor (
; PSECURITY_DESCRIPTOR SecurityDescriptor
; );
;
;NTSYSAPI
;BOOLEAN
;NTAPI
;RtlValidRelativeSecurityDescriptor (
; IN PSECURITY_DESCRIPTOR SecurityDescriptorInput,
; IN ULONG SecurityDescriptorLength,
; IN SECURITY_INFORMATION RequiredInformation
; );
;
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlSetDaclSecurityDescriptor (
; PSECURITY_DESCRIPTOR SecurityDescriptor,
; BOOLEAN DaclPresent,
; PACL Dacl,
; BOOLEAN DaclDefaulted
; );
;
;
;//
;// Range list package
;//
;
;typedef struct _RTL_RANGE {
;
; //
; // The start of the range
; //
; ULONGLONG Start; // Read only
;
; //
; // The end of the range
; //
; ULONGLONG End; // Read only
;
; //
; // Data the user passed in when they created the range
; //
; PVOID UserData; // Read/Write
;
; //
; // The owner of the range
; //
; PVOID Owner; // Read/Write
;
; //
; // User defined flags the user specified when they created the range
; //
; UCHAR Attributes; // Read/Write
;
; //
; // Flags (RTL_RANGE_*)
; //
; UCHAR Flags; // Read only
;
;} RTL_RANGE, *PRTL_RANGE;
;
;
;#define RTL_RANGE_SHARED 0x01
;#define RTL_RANGE_CONFLICT 0x02
;
;typedef struct _RTL_RANGE_LIST {
;
; //
; // The list of ranges
; //
; LIST_ENTRY ListHead;
;
; //
; // These always come in useful
; //
; ULONG Flags; // use RANGE_LIST_FLAG_*
;
; //
; // The number of entries in the list
; //
; ULONG Count;
;
; //
; // Every time an add/delete operation is performed on the list this is
; // incremented. It is checked during iteration to ensure that the list
; // hasn't changed between GetFirst/GetNext or GetNext/GetNext calls
; //
; ULONG Stamp;
;
;} RTL_RANGE_LIST, *PRTL_RANGE_LIST;
;
;typedef struct _RANGE_LIST_ITERATOR {
;
; PLIST_ENTRY RangeListHead;
; PLIST_ENTRY MergedHead;
; PVOID Current;
; ULONG Stamp;
;
;} RTL_RANGE_LIST_ITERATOR, *PRTL_RANGE_LIST_ITERATOR;
;
;
;NTSYSAPI
;VOID
;NTAPI
;RtlInitializeRangeList(
; IN OUT PRTL_RANGE_LIST RangeList
; );
;
;NTSYSAPI
;VOID
;NTAPI
;RtlFreeRangeList(
; IN PRTL_RANGE_LIST RangeList
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlCopyRangeList(
; OUT PRTL_RANGE_LIST CopyRangeList,
; IN PRTL_RANGE_LIST RangeList
; );
;
;#define RTL_RANGE_LIST_ADD_IF_CONFLICT 0x00000001
;#define RTL_RANGE_LIST_ADD_SHARED 0x00000002
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlAddRange(
; IN OUT PRTL_RANGE_LIST RangeList,
; IN ULONGLONG Start,
; IN ULONGLONG End,
; IN UCHAR Attributes,
; IN ULONG Flags,
; IN PVOID UserData, OPTIONAL
; IN PVOID Owner OPTIONAL
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlDeleteRange(
; IN OUT PRTL_RANGE_LIST RangeList,
; IN ULONGLONG Start,
; IN ULONGLONG End,
; IN PVOID Owner
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlDeleteOwnersRanges(
; IN OUT PRTL_RANGE_LIST RangeList,
; IN PVOID Owner
; );
;
;#define RTL_RANGE_LIST_SHARED_OK 0x00000001
;#define RTL_RANGE_LIST_NULL_CONFLICT_OK 0x00000002
;
;typedef
;BOOLEAN
;(*PRTL_CONFLICT_RANGE_CALLBACK) (
; IN PVOID Context,
; IN PRTL_RANGE Range
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlFindRange(
; IN PRTL_RANGE_LIST RangeList,
; IN ULONGLONG Minimum,
; IN ULONGLONG Maximum,
; IN ULONG Length,
; IN ULONG Alignment,
; IN ULONG Flags,
; IN UCHAR AttributeAvailableMask,
; IN PVOID Context OPTIONAL,
; IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL,
; OUT PULONGLONG Start
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlIsRangeAvailable(
; IN PRTL_RANGE_LIST RangeList,
; IN ULONGLONG Start,
; IN ULONGLONG End,
; IN ULONG Flags,
; IN UCHAR AttributeAvailableMask,
; IN PVOID Context OPTIONAL,
; IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL,
; OUT PBOOLEAN Available
; );
;
;#define FOR_ALL_RANGES(RangeList, Iterator, Current) \
; for (RtlGetFirstRange((RangeList), (Iterator), &(Current)); \
; (Current) != NULL; \
; RtlGetNextRange((Iterator), &(Current), TRUE) \
; )
;
;#define FOR_ALL_RANGES_BACKWARDS(RangeList, Iterator, Current) \
; for (RtlGetLastRange((RangeList), (Iterator), &(Current)); \
; (Current) != NULL; \
; RtlGetNextRange((Iterator), &(Current), FALSE) \
; )
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlGetFirstRange(
; IN PRTL_RANGE_LIST RangeList,
; OUT PRTL_RANGE_LIST_ITERATOR Iterator,
; OUT PRTL_RANGE *Range
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlGetLastRange(
; IN PRTL_RANGE_LIST RangeList,
; OUT PRTL_RANGE_LIST_ITERATOR Iterator,
; OUT PRTL_RANGE *Range
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlGetNextRange(
; IN OUT PRTL_RANGE_LIST_ITERATOR Iterator,
; OUT PRTL_RANGE *Range,
; IN BOOLEAN MoveForwards
; );
;
;#define RTL_RANGE_LIST_MERGE_IF_CONFLICT RTL_RANGE_LIST_ADD_IF_CONFLICT
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlMergeRangeLists(
; OUT PRTL_RANGE_LIST MergedRangeList,
; IN PRTL_RANGE_LIST RangeList1,
; IN PRTL_RANGE_LIST RangeList2,
; IN ULONG Flags
; );
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlInvertRangeList(
; OUT PRTL_RANGE_LIST InvertedRangeList,
; IN PRTL_RANGE_LIST RangeList
; );
;
;// end_nthal
;
;// begin_wdm
;
;//
;// Byte swap routines. These are used to convert from little-endian to
;// big-endian and vice-versa.
;//
;
;USHORT
;FASTCALL
;RtlUshortByteSwap(
; IN USHORT Source
; );
;
;ULONG
;FASTCALL
;RtlUlongByteSwap(
; IN ULONG Source
; );
;
;ULONGLONG
;FASTCALL
;RtlUlonglongByteSwap(
; IN ULONGLONG Source
; );
;
;
;//
;// Routine for converting from a volume device object to a DOS name.
;//
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;RtlVolumeDeviceToDosName(
; IN PVOID VolumeDeviceObject,
; OUT PUNICODE_STRING DosName
; );
;
;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
;
;
;//
;//
;// 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_)))
;
;ULONGLONG
;NTAPI
;VerSetConditionMask(
; IN ULONGLONG ConditionMask,
; IN ULONG TypeMask,
; IN UCHAR Condition
; );
;//
;// end_winnt
;//
;
;NTSYSAPI
;NTSTATUS
;RtlGetVersion(
; OUT PRTL_OSVERSIONINFOW lpVersionInformation
; );
;
;NTSYSAPI
;NTSTATUS
;RtlVerifyVersionInfo(
; IN PRTL_OSVERSIONINFOEXW VersionInfo,
; IN ULONG TypeMask,
; IN ULONGLONG ConditionMask
; );
;
;//
;//
;// 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
;FILE_DEVICE_NETWORK equ 12h
;#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
;
;//
;// 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)
;
;//
;// 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 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_winnt
;
;//
;// 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_winnt
;
;
;//
;// Define share access rights to files and directories
;//
;
;#define FILE_SHARE_READ 0x00000001 // winnt
;#define FILE_SHARE_WRITE 0x00000002 // winnt
;#define FILE_SHARE_DELETE 0x00000004 // winnt
;#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: 0x00000010 is reserved for use for the old DOS SUBDIRECTORY flag
;// and is therefore not considered valid in NT. This flag has
;// been disassociated with file attributes since the other flags are
;// protected with READ_ and WRITE_ATTRIBUTES access to the file.
;//
;// 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 // winnt
;#define FILE_ATTRIBUTE_HIDDEN 0x00000002 // winnt
;#define FILE_ATTRIBUTE_SYSTEM 0x00000004 // winnt
;//OLD DOS VOLID 0x00000008
;
;#define FILE_ATTRIBUTE_DIRECTORY 0x00000010 // winnt
;#define FILE_ATTRIBUTE_ARCHIVE 0x00000020 // winnt
;#define FILE_ATTRIBUTE_DEVICE 0x00000040 // winnt
;#define FILE_ATTRIBUTE_NORMAL 0x00000080 // winnt
;
;#define FILE_ATTRIBUTE_TEMPORARY 0x00000100 // winnt
;#define FILE_ATTRIBUTE_SPARSE_FILE 0x00000200 // winnt
;#define FILE_ATTRIBUTE_REPARSE_POINT 0x00000400 // winnt
;#define FILE_ATTRIBUTE_COMPRESSED 0x00000800 // winnt
;
;#define FILE_ATTRIBUTE_OFFLINE 0x00001000 // winnt
;#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x00002000 // winnt
;#define FILE_ATTRIBUTE_ENCRYPTED 0x00004000 // winnt
;
;//
;// This definition is old and will disappear shortly
;//
;
;#define FILE_ATTRIBUTE_CONTENT_INDEXED FILE_ATTRIBUTE_NOT_CONTENT_INDEXED
;
;#define FILE_ATTRIBUTE_VALID_FLAGS 0x00007fb7
;#define FILE_ATTRIBUTE_VALID_SET_FLAGS 0x000031a7
;
;//
;// 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_FOR_RECOVERY 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
;
;#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
;
;#define FILE_COPY_STRUCTURED_STORAGE 0x00000041
;#define FILE_STRUCTURED_STORAGE 0x00000441
;
;#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
;
;// end_wdm
;
;//
;// flags specified here will be propagated up and down a device stack
;// after FDO and all filter devices are added, but before the device
;// stack is started
;//
;
;#define FILE_CHARACTERISTICS_PROPAGATED ( FILE_REMOVABLE_MEDIA | \
; FILE_READ_ONLY_DEVICE | \
; FILE_FLOPPY_DISKETTE | \
; FILE_WRITE_ONCE_MEDIA | \
; FILE_DEVICE_SECURE_OPEN )
;
;//
;// Define the base asynchronous I/O argument types
;//
;
;typedef struct _IO_STATUS_BLOCK {
; union {
; NTSTATUS Status;
; PVOID Pointer;
; };
;
; ULONG_PTR Information;
;} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
;
;#if defined(_WIN64)
;typedef struct _IO_STATUS_BLOCK32 {
; NTSTATUS Status;
; ULONG Information;
;} IO_STATUS_BLOCK32, *PIO_STATUS_BLOCK32;
;#endif
;
;
;//
;// 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 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 {
;// end_wdm
; FileDirectoryInformation = 1,
; FileFullDirectoryInformation, // 2
; FileBothDirectoryInformation, // 3
; FileBasicInformation, // 4 wdm
; FileStandardInformation, // 5 wdm
; FileInternalInformation, // 6
; FileEaInformation, // 7
; FileAccessInformation, // 8
; FileNameInformation, // 9
; FileRenameInformation, // 10
; FileLinkInformation, // 11
; FileNamesInformation, // 12
; FileDispositionInformation, // 13
; FilePositionInformation, // 14 wdm
; FileFullEaInformation, // 15
; FileModeInformation, // 16
; FileAlignmentInformation, // 17
; FileAllInformation, // 18
; FileAllocationInformation, // 19
; FileEndOfFileInformation, // 20 wdm
; 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
; FileMaximumInformation
;// begin_wdm
;} 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;
;
;typedef struct _FILE_POSITION_INFORMATION {
; LARGE_INTEGER CurrentByteOffset;
;} FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION;
;
;typedef struct _FILE_ALIGNMENT_INFORMATION {
; ULONG AlignmentRequirement;
;} FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION;
;
;typedef struct _FILE_NAME_INFORMATION {
; ULONG FileNameLength;
; WCHAR FileName[1];
;} FILE_NAME_INFORMATION, *PFILE_NAME_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_ATTRIBUTE_TAG_INFORMATION {
; ULONG FileAttributes;
; ULONG ReparseTag;
;} FILE_ATTRIBUTE_TAG_INFORMATION, *PFILE_ATTRIBUTE_TAG_INFORMATION;
;
;typedef struct _FILE_DISPOSITION_INFORMATION {
; BOOLEAN DeleteFile;
;} FILE_DISPOSITION_INFORMATION, *PFILE_DISPOSITION_INFORMATION;
;
;typedef struct _FILE_END_OF_FILE_INFORMATION {
; LARGE_INTEGER EndOfFile;
;} FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_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;
;
;//
;// 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
; 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;
;
;//
;// 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,
; MaximumInterfaceType
;}INTERFACE_TYPE, *PINTERFACE_TYPE;
;
;//
;// Define the DMA transfer widths.
;//
;
;typedef enum _DMA_WIDTH {
; Width8Bits,
; Width16Bits,
; Width32Bits,
; 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);
;
;// end_wdm
;
;//
;// Define types of bus information.
;//
;
;typedef enum _BUS_DATA_TYPE {
; ConfigurationSpaceUndefined = -1,
; Cmos,
; EisaConfiguration,
; Pos,
; CbusConfiguration,
; PCIConfiguration,
; VMEConfiguration,
; NuBusConfiguration,
; PCMCIAConfiguration,
; MPIConfiguration,
; MPSAConfiguration,
; PNPISAConfiguration,
; SgiInternalConfiguration,
; MaximumBusDataType
;} BUS_DATA_TYPE, *PBUS_DATA_TYPE;
;
;//
;// 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
;//
;// 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_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))
;
;//
;// 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)
;
;//
;// Key creation/open disposition
;//
;
;#define REG_CREATED_NEW_KEY (0x00000001L) // New Registry Key created
;#define REG_OPENED_EXISTING_KEY (0x00000002L) // Existing Key opened
;
;//
;// Key restore 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
;
;//
;// 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;
;
;// end_wdm
;typedef struct _KEY_NAME_INFORMATION {
; ULONG NameLength;
; WCHAR Name[1]; // Variable length string
;} KEY_NAME_INFORMATION, *PKEY_NAME_INFORMATION;
;
;// begin_wdm
;typedef enum _KEY_INFORMATION_CLASS {
; KeyBasicInformation,
; KeyNodeInformation,
; KeyFullInformation
;// end_wdm
; ,
; KeyNameInformation
;// begin_wdm
;} KEY_INFORMATION_CLASS;
;
;typedef struct _KEY_WRITE_TIME_INFORMATION {
; LARGE_INTEGER LastWriteTime;
;} KEY_WRITE_TIME_INFORMATION, *PKEY_WRITE_TIME_INFORMATION;
;
;typedef enum _KEY_SET_INFORMATION_CLASS {
; KeyWriteTimeInformation
;} 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;
; UCHAR Data[1]; // Variable size
;} KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
;
;typedef struct _KEY_VALUE_PARTIAL_INFORMATION_ALIGN64 {
; ULONG Type;
; ULONG DataLength;
; UCHAR Data[1]; // Variable size
;} KEY_VALUE_PARTIAL_INFORMATION_ALIGN64, *PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64;
;
;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
;} KEY_VALUE_INFORMATION_CLASS;
;
;
;
;#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)
;
;//
;// Object Manager Symbolic Link Specific Access Rights.
;//
;
;#define SYMBOLIC_LINK_QUERY (0x0001)
;
;#define SYMBOLIC_LINK_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1)
;
;typedef struct _OBJECT_NAME_INFORMATION {
; UNICODE_STRING Name;
;} OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION;
;#define DUPLICATE_CLOSE_SOURCE 0x00000001 // winnt
;#define DUPLICATE_SAME_ACCESS 0x00000002 // winnt
;#define DUPLICATE_SAME_ATTRIBUTES 0x00000004
;
;//
;// Section Information Structures.
;//
;
;typedef enum _SECTION_INHERIT {
; ViewShare = 1,
; ViewUnmap = 2
;} SECTION_INHERIT;
;
;//
;// Section Access Rights.
;//
;
;// begin_winnt
;#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_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY|\
; SECTION_MAP_WRITE | \
; SECTION_MAP_READ | \
; SECTION_MAP_EXECUTE | \
; SECTION_EXTEND_SIZE)
;// end_winnt
;
;#define SEGMENT_ALL_ACCESS SECTION_ALL_ACCESS
;
;#define PAGE_NOACCESS 0x01 // winnt
;#define PAGE_READONLY 0x02 // winnt
;#define PAGE_READWRITE 0x04 // winnt
;#define PAGE_WRITECOPY 0x08 // winnt
;#define PAGE_EXECUTE 0x10 // winnt
;#define PAGE_EXECUTE_READ 0x20 // winnt
;#define PAGE_EXECUTE_READWRITE 0x40 // winnt
;#define PAGE_EXECUTE_WRITECOPY 0x80 // winnt
;#define PAGE_GUARD 0x100 // winnt
;#define PAGE_NOCACHE 0x200 // winnt
;#define PAGE_WRITECOMBINE 0x400 // winnt
;
;#define MEM_COMMIT 0x1000
;#define MEM_RESERVE 0x2000
;#define MEM_DECOMMIT 0x4000
;#define MEM_RELEASE 0x8000
;#define MEM_FREE 0x10000
;#define MEM_PRIVATE 0x20000
;#define MEM_MAPPED 0x40000
;#define MEM_RESET 0x80000
;#define MEM_TOP_DOWN 0x100000
;#define MEM_LARGE_PAGES 0x20000000
;#define MEM_4MB_PAGES 0x80000000
;#define SEC_RESERVE 0x4000000
;#define PROCESS_DUP_HANDLE (0x0040) // winnt
;#define PROCESS_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
; 0xFFF)
;
;// end_ntifs
;
;#define MAXIMUM_PROCESSORS 32
;
;// end_winnt
;
;//
;// Thread Specific Access Rights
;//
;
;#define THREAD_TERMINATE (0x0001) // winnt
;#define THREAD_SET_INFORMATION (0x0020) // winnt
;
;#define THREAD_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
; 0x3FF)
;
;//
;// ClientId
;//
;
;typedef struct _CLIENT_ID {
; HANDLE UniqueProcess;
; HANDLE UniqueThread;
;} CLIENT_ID;
;typedef CLIENT_ID *PCLIENT_ID;
;
;//
;// Thread Environment Block (and portable part of Thread Information Block)
;//
;
;//
;// NT_TIB - Thread Information Block - Portable part.
;//
;// This is the subsystem portable part of the Thread Information Block.
;// It appears as the first part of the TEB for all threads which have
;// a user mode component.
;//
;//
;
;// begin_winnt
;
;typedef struct _NT_TIB {
; struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;
; PVOID StackBase;
; PVOID StackLimit;
; PVOID SubSystemTib;
; union {
; PVOID FiberData;
; ULONG Version;
; };
; PVOID ArbitraryUserPointer;
; struct _NT_TIB *Self;
;} NT_TIB;
;typedef NT_TIB *PNT_TIB;
;//
;// Process Information Classes
;//
;
;typedef enum _PROCESSINFOCLASS {
; ProcessBasicInformation,
; ProcessQuotaLimits,
; ProcessIoCounters,
; ProcessVmCounters,
; ProcessTimes,
; ProcessBasePriority,
; ProcessRaisePriority,
; ProcessDebugPort,
; ProcessExceptionPort,
; ProcessAccessToken,
; ProcessLdtInformation,
; ProcessLdtSize,
; ProcessDefaultHardErrorMode,
; ProcessIoPortHandlers, // Note: this is kernel mode only
; ProcessPooledUsageAndLimits,
; ProcessWorkingSetWatch,
; ProcessUserModeIOPL,
; ProcessEnableAlignmentFaultFixup,
; ProcessPriorityClass,
; ProcessWx86Information,
; ProcessHandleCount,
; ProcessAffinityMask,
; ProcessPriorityBoost,
; ProcessDeviceMap,
; ProcessSessionInformation,
; ProcessForegroundInformation,
; ProcessWow64Information,
; MaxProcessInfoClass
; } PROCESSINFOCLASS;
;//
;// Thread Information Classes
;//
;
;typedef enum _THREADINFOCLASS {
; ThreadBasicInformation,
; ThreadTimes,
; ThreadPriority,
; ThreadBasePriority,
; ThreadAffinityMask,
; ThreadImpersonationToken,
; ThreadDescriptorTableEntry,
; ThreadEnableAlignmentFaultFixup,
; ThreadEventPair_Reusable,
; ThreadQuerySetWin32StartAddress,
; ThreadZeroTlsCell,
; ThreadPerformanceCount,
; ThreadAmILastThread,
; ThreadIdealProcessor,
; ThreadPriorityBoost,
; ThreadSetTlsArrayAddress,
; ThreadIsIoPending,
; ThreadHideFromDebugger,
; MaxThreadInfoClass
; } THREADINFOCLASS;
;//
;// Process Information Structures
;//
;
;//
;// PageFaultHistory Information
;// NtQueryInformationProcess using ProcessWorkingSetWatch
;//
;typedef struct _PROCESS_WS_WATCH_INFORMATION {
; PVOID FaultingPc;
; PVOID FaultingVa;
;} PROCESS_WS_WATCH_INFORMATION, *PPROCESS_WS_WATCH_INFORMATION;
;
;//
;// Basic Process Information
;// NtQueryInformationProcess using ProcessBasicInfo
;//
;
;typedef struct _PROCESS_BASIC_INFORMATION {
; NTSTATUS ExitStatus;
; PPEB PebBaseAddress;
; ULONG_PTR AffinityMask;
; KPRIORITY BasePriority;
; ULONG_PTR UniqueProcessId;
; ULONG_PTR InheritedFromUniqueProcessId;
;} PROCESS_BASIC_INFORMATION;
;typedef PROCESS_BASIC_INFORMATION *PPROCESS_BASIC_INFORMATION;
;
;
;//
;// Process Device Map information
;// NtQueryInformationProcess using ProcessDeviceMap
;// NtSetInformationProcess using ProcessDeviceMap
;//
;
;typedef struct _PROCESS_DEVICEMAP_INFORMATION {
; union {
; struct {
; HANDLE DirectoryHandle;
; } Set;
; struct {
; ULONG DriveMap;
; UCHAR DriveType[ 32 ];
; } Query;
; };
;} PROCESS_DEVICEMAP_INFORMATION, *PPROCESS_DEVICEMAP_INFORMATION;
;
;
;//
;// Multi-User Session specific Process Information
;// NtQueryInformationProcess using ProcessSessionInformation
;//
;
;typedef struct _PROCESS_SESSION_INFORMATION {
; ULONG SessionId;
;} PROCESS_SESSION_INFORMATION, *PPROCESS_SESSION_INFORMATION;
;
;
;//
;// Process Quotas
;// NtQueryInformationProcess using ProcessQuotaLimits
;// NtQueryInformationProcess using ProcessPooledQuotaLimits
;// NtSetInformationProcess using ProcessQuotaLimits
;//
;
;// begin_winnt begin_ntsrv
;
;typedef struct _QUOTA_LIMITS {
; SIZE_T PagedPoolLimit;
; SIZE_T NonPagedPoolLimit;
; SIZE_T MinimumWorkingSetSize;
; SIZE_T MaximumWorkingSetSize;
; SIZE_T PagefileLimit;
; LARGE_INTEGER TimeLimit;
;} QUOTA_LIMITS;
;typedef QUOTA_LIMITS *PQUOTA_LIMITS;
;
;// end_winnt end_ntsrv
;
;//
;// Process I/O Counters
;// NtQueryInformationProcess using ProcessIoCounters
;//
;
;// begin_winnt
;typedef struct _IO_COUNTERS {
; ULONGLONG ReadOperationCount;
; ULONGLONG WriteOperationCount;
; ULONGLONG OtherOperationCount;
; ULONGLONG ReadTransferCount;
; ULONGLONG WriteTransferCount;
; ULONGLONG OtherTransferCount;
;} IO_COUNTERS;
;typedef IO_COUNTERS *PIO_COUNTERS;
;// end_winnt
;
;//
;// Process Virtual Memory Counters
;// NtQueryInformationProcess using ProcessVmCounters
;//
;
;typedef struct _VM_COUNTERS {
; SIZE_T PeakVirtualSize;
; SIZE_T VirtualSize;
; ULONG PageFaultCount;
; SIZE_T PeakWorkingSetSize;
; SIZE_T WorkingSetSize;
; SIZE_T QuotaPeakPagedPoolUsage;
; SIZE_T QuotaPagedPoolUsage;
; SIZE_T QuotaPeakNonPagedPoolUsage;
; SIZE_T QuotaNonPagedPoolUsage;
; SIZE_T PagefileUsage;
; SIZE_T PeakPagefileUsage;
;} VM_COUNTERS;
;typedef VM_COUNTERS *PVM_COUNTERS;
;
;//
;// Process Pooled Quota Usage and Limits
;// NtQueryInformationProcess using ProcessPooledUsageAndLimits
;//
;
;typedef struct _POOLED_USAGE_AND_LIMITS {
; SIZE_T PeakPagedPoolUsage;
; SIZE_T PagedPoolUsage;
; SIZE_T PagedPoolLimit;
; SIZE_T PeakNonPagedPoolUsage;
; SIZE_T NonPagedPoolUsage;
; SIZE_T NonPagedPoolLimit;
; SIZE_T PeakPagefileUsage;
; SIZE_T PagefileUsage;
; SIZE_T PagefileLimit;
;} POOLED_USAGE_AND_LIMITS;
;typedef POOLED_USAGE_AND_LIMITS *PPOOLED_USAGE_AND_LIMITS;
;
;//
;// Process Security Context Information
;// NtSetInformationProcess using ProcessAccessToken
;// PROCESS_SET_ACCESS_TOKEN access to the process is needed
;// to use this info level.
;//
;
;typedef struct _PROCESS_ACCESS_TOKEN {
;
; //
; // Handle to Primary token to assign to the process.
; // TOKEN_ASSIGN_PRIMARY access to this token is needed.
; //
;
; HANDLE Token;
;
; //
; // Handle to the initial thread of the process.
; // A process's access token can only be changed if the process has
; // no threads or one thread. If the process has no threads, this
; // field must be set to NULL. Otherwise, it must contain a handle
; // open to the process's only thread. THREAD_QUERY_INFORMATION access
; // is needed via this handle.
;
; HANDLE Thread;
;
;} PROCESS_ACCESS_TOKEN, *PPROCESS_ACCESS_TOKEN;
;
;//
;// Process/Thread System and User Time
;// NtQueryInformationProcess using ProcessTimes
;// NtQueryInformationThread using ThreadTimes
;//
;
;typedef struct _KERNEL_USER_TIMES {
; LARGE_INTEGER CreateTime;
; LARGE_INTEGER ExitTime;
; LARGE_INTEGER KernelTime;
; LARGE_INTEGER UserTime;
;} KERNEL_USER_TIMES;
;typedef KERNEL_USER_TIMES *PKERNEL_USER_TIMES;
;NTSYSCALLAPI
;NTSTATUS
;NTAPI
;NtOpenProcess (
; OUT PHANDLE ProcessHandle,
; IN ACCESS_MASK DesiredAccess,
; IN POBJECT_ATTRIBUTES ObjectAttributes,
; IN PCLIENT_ID ClientId OPTIONAL
; );
;#define NtCurrentProcess() ( (HANDLE) -1 )
;NTSYSCALLAPI
;NTSTATUS
;NTAPI
;NtQueryInformationProcess(
; IN HANDLE ProcessHandle,
; IN PROCESSINFOCLASS ProcessInformationClass,
; OUT PVOID ProcessInformation,
; IN ULONG ProcessInformationLength,
; OUT PULONG ReturnLength OPTIONAL
; );
;#define NtCurrentThread() ( (HANDLE) -2 )
;
;#ifndef _PO_DDK_
;#define _PO_DDK_
;
;typedef enum _SYSTEM_POWER_STATE {
; PowerSystemUnspecified = 0,
; PowerSystemWorking,
; PowerSystemSleeping1,
; PowerSystemSleeping2,
; PowerSystemSleeping3,
; PowerSystemHibernate,
; PowerSystemShutdown,
; PowerSystemMaximum
;} SYSTEM_POWER_STATE, *PSYSTEM_POWER_STATE;
;
;typedef enum {
; PowerActionNone = 0,
; PowerActionReserved,
; PowerActionSleep,
; PowerActionHibernate,
; PowerActionShutdown,
; PowerActionShutdownReset,
; PowerActionShutdownOff,
; PowerActionWarmEject
;} POWER_ACTION, *PPOWER_ACTION;
;
;typedef enum _DEVICE_POWER_STATE {
; PowerDeviceUnspecified = 0,
; PowerDeviceD0,
; PowerDeviceD1,
; PowerDeviceD2,
; PowerDeviceD3,
; PowerDeviceMaximum
;} DEVICE_POWER_STATE, *PDEVICE_POWER_STATE;
;
;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;
;
;
;//
;// 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
;//
;
;// begin_winnt
;
;#define ES_SYSTEM_REQUIRED ((ULONG)0x00000001)
;#define ES_DISPLAY_REQUIRED ((ULONG)0x00000002)
;#define ES_USER_PRESENT ((ULONG)0x00000004)
;#define ES_CONTINUOUS ((ULONG)0x80000000)
;
;typedef ULONG EXECUTION_STATE;
;
;typedef enum {
; LT_DONT_CARE,
; LT_LOWEST_LATENCY
;} LATENCY_TIME;
;
;// end_winnt end_ntminiport end_wdm end_ntifs
;
;typedef enum {
; SystemPowerPolicyAc,
; SystemPowerPolicyDc,
; VerifySystemPolicyAc,
; VerifySystemPolicyDc,
; SystemPowerCapabilities,
; SystemBatteryState,
; SystemPowerStateHandler,
; ProcessorStateHandler,
; SystemPowerPolicyCurrent,
; AdministratorPowerPolicy,
; SystemReserveHiberFile,
; ProcessorInformation,
; SystemPowerInformation
;} POWER_INFORMATION_LEVEL;
;
;// begin_ntminiport begin_wdm begin_ntifs
;
;#endif // !_PO_DDK_
;
;
;#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 16
;
;//
;// 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
;
;#define NORMAL_DISPATCH_LENGTH 106
;#define DISPATCH_LENGTH NORMAL_DISPATCH_LENGTH
;//
;// STATUS register for each MCA bank.
;//
;
;typedef union _MCI_STATS {
; struct {
; USHORT McaCod;
; USHORT MsCod;
; ULONG OtherInfo : 25;
; ULONG Damage : 1;
; ULONG AddressValid : 1;
; ULONG MiscValid : 1;
; ULONG Enabled : 1;
; ULONG UnCorrected : 1;
; ULONG OverFlow : 1;
; ULONG Valid : 1;
; } MciStats;
;
; ULONGLONG QuadPart;
;
;} MCI_STATS, *PMCI_STATS;
;
;//
;// 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 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 SYNCH_LEVEL (IPI_LEVEL-1) // synchronization level
;
;//
;// 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.)
;//
;
;NTHALAPI
;UCHAR
;READ_REGISTER_UCHAR(
; PUCHAR Register
; );
;
;NTHALAPI
;USHORT
;READ_REGISTER_USHORT(
; PUSHORT Register
; );
;
;NTHALAPI
;ULONG
;READ_REGISTER_ULONG(
; PULONG Register
; );
;
;NTHALAPI
;VOID
;READ_REGISTER_BUFFER_UCHAR(
; PUCHAR Register,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_REGISTER_BUFFER_USHORT(
; PUSHORT Register,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_REGISTER_BUFFER_ULONG(
; PULONG Register,
; PULONG Buffer,
; ULONG Count
; );
;
;
;NTHALAPI
;VOID
;WRITE_REGISTER_UCHAR(
; PUCHAR Register,
; UCHAR Value
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_USHORT(
; PUSHORT Register,
; USHORT Value
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_ULONG(
; PULONG Register,
; ULONG Value
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_BUFFER_UCHAR(
; PUCHAR Register,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_BUFFER_USHORT(
; PUSHORT Register,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_BUFFER_ULONG(
; PULONG Register,
; PULONG Buffer,
; ULONG Count
; );
;
;NTHALAPI
;UCHAR
;READ_PORT_UCHAR(
; PUCHAR Port
; );
;
;NTHALAPI
;USHORT
;READ_PORT_USHORT(
; PUSHORT Port
; );
;
;NTHALAPI
;ULONG
;READ_PORT_ULONG(
; PULONG Port
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_UCHAR(
; PUCHAR Port,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_USHORT(
; PUSHORT Port,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_ULONG(
; PULONG Port,
; PULONG Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_UCHAR(
; PUCHAR Port,
; UCHAR Value
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_USHORT(
; PUSHORT Port,
; USHORT Value
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_ULONG(
; PULONG Port,
; ULONG Value
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_UCHAR(
; PUCHAR Port,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_USHORT(
; PUSHORT Port,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_ULONG(
; PULONG Port,
; PULONG Buffer,
; ULONG Count
; );
;
;// end_ntndis
;//
;// Get data cache fill size.
;//
;
;#define KeGetDcacheFillSize() 1L
;
;
;#define KeFlushIoBuffers(Mdl, ReadOperation, 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)
;
;
;#define KeQueryTickCount(CurrentCount ) { \
; volatile PKSYSTEM_TIME _TickCount = *((PKSYSTEM_TIME *)(&KeTickCount)); \
; while (TRUE) { \
; (CurrentCount)->HighPart = _TickCount->High1Time; \
; (CurrentCount)->LowPart = _TickCount->LowPart; \
; if ((CurrentCount)->HighPart == _TickCount->High2Time) break; \
; _asm { rep nop } \
; } \
;}
;
;
;//
;// Processor Control Region Structure Definition
;//
;
;#define PCR_MINOR_VERSION 1
;#define PCR_MAJOR_VERSION 1
;
;typedef struct _KPCR {
;
;//
;// Start of the architecturally defined section of the PCR. This section
;// may be directly addressed by vendor/platform specific HAL code and will
;// not change from version to version of NT.
;//
;
; NT_TIB NtTib;
; struct _KPCR *SelfPcr; // flat address of this PCR
; struct _KPRCB *Prcb; // pointer to Prcb
; KIRQL Irql;
; ULONG IRR;
; ULONG IrrActive;
; ULONG IDR;
; ULONG Reserved2;
;
; struct _KIDTENTRY *IDT;
; struct _KGDTENTRY *GDT;
; struct _KTSS *TSS;
; USHORT MajorVersion;
; USHORT MinorVersion;
; KAFFINITY SetMember;
; ULONG StallScaleFactor;
; UCHAR DebugActive;
; UCHAR Number;
;
;} KPCR;
;typedef KPCR *PKPCR;
;
;//
;// 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 Cr0NpxState;
; ULONG Spare1; // Not used in wdm
;} KFLOATING_SAVE, *PKFLOATING_SAVE;
;
;//
;// 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
;
;// end_ntndis end_wdm
;//
;// Define the number of bits to shift to right justify the Page Directory Index
;// field of a PTE.
;//
;
;#define PDI_SHIFT_X86 22
;#define PDI_SHIFT_X86PAE 21
;
;#if !defined (_X86PAE_)
;#define PDI_SHIFT PDI_SHIFT_X86
;#else
;#define PDI_SHIFT PDI_SHIFT_X86PAE
;#define PPI_SHIFT 30
;#endif
;
;//
;// Define the number of bits to shift to right justify the Page Table Index
;// field of a PTE.
;//
;
;#define PTI_SHIFT 12
;
;//
;// Define the highest user address and user probe address.
;//
;
;
;extern PVOID *MmHighestUserAddress;
;extern PVOID *MmSystemRangeStart;
;extern ULONG *MmUserProbeAddress;
;
;#define MM_HIGHEST_USER_ADDRESS *MmHighestUserAddress
;#define MM_SYSTEM_RANGE_START *MmSystemRangeStart
;#define MM_USER_PROBE_ADDRESS *MmUserProbeAddress
;
;//
;// The lowest user address reserves the low 64k.
;//
;
;#define MM_LOWEST_USER_ADDRESS (PVOID)0x10000
;
;//
;// The lowest address for system space.
;//
;
;#if !defined (_X86PAE_)
;#define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xC0800000
;#else
;#define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xC0C00000
;#endif
;
;// begin_wdm
;
;#define MmGetProcedureAddress(Address) (Address)
;#define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address)
;
;
;#define KI_USER_SHARED_DATA 0xffdf0000
;#define SharedUserData ((KUSER_SHARED_DATA * const) KI_USER_SHARED_DATA)
;
;//
;// 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.
;//
;
;#define ExInterlockedIncrementLong(Addend,Lock) \
; Exfi386InterlockedIncrementLong(Addend)
;
;#define ExInterlockedDecrementLong(Addend,Lock) \
; Exfi386InterlockedDecrementLong(Addend)
;
;#define ExInterlockedExchangeUlong(Target,Value,Lock) \
; Exfi386InterlockedExchangeUlong(Target,Value)
;
;// begin_wdm
;
;#define ExInterlockedAddUlong ExfInterlockedAddUlong
;#define ExInterlockedInsertHeadList ExfInterlockedInsertHeadList
;#define ExInterlockedInsertTailList ExfInterlockedInsertTailList
;#define ExInterlockedRemoveHeadList ExfInterlockedRemoveHeadList
;#define ExInterlockedPopEntryList ExfInterlockedPopEntryList
;#define ExInterlockedPushEntryList ExfInterlockedPushEntryList
;
;// end_wdm
;
;//
;// Prototypes for architectural specific versions of Exi386 Api
;//
;
;//
;// Interlocked result type is portable, but its values are machine specific.
;// Constants for value are in i386.h, mips.h, etc.
;//
;
;typedef enum _INTERLOCKED_RESULT {
; ResultNegative = RESULT_NEGATIVE,
; ResultZero = RESULT_ZERO,
; ResultPositive = RESULT_POSITIVE
;} INTERLOCKED_RESULT;
;
;NTKERNELAPI
;INTERLOCKED_RESULT
;FASTCALL
;Exfi386InterlockedIncrementLong (
; IN PLONG Addend
; );
;
;NTKERNELAPI
;INTERLOCKED_RESULT
;FASTCALL
;Exfi386InterlockedDecrementLong (
; IN PLONG Addend
; );
;
;NTKERNELAPI
;LARGE_INTEGER
;ExInterlockedExchangeAddLargeInteger (
; IN PLARGE_INTEGER Addend,
; IN LARGE_INTEGER Increment,
; IN PKSPIN_LOCK Lock
; );
;
;NTKERNELAPI
;ULONG
;FASTCALL
;Exfi386InterlockedExchangeUlong (
; IN PULONG Target,
; IN ULONG Value
; );
;
;//
;// Intrinsic interlocked functions
;//
;
;#if (defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(NO_INTERLOCKED_INTRINSICS)) && !defined(_WINBASE_)
;
;// begin_wdm
;
;NTKERNELAPI
;LONG
;FASTCALL
;InterlockedIncrement(
; IN PLONG Addend
; );
;
;NTKERNELAPI
;LONG
;FASTCALL
;InterlockedDecrement(
; IN PLONG Addend
; );
;
;NTKERNELAPI
;LONG
;FASTCALL
;InterlockedExchange(
; IN OUT PLONG Target,
; IN LONG Value
; );
;
;#define InterlockedExchangePointer(Target, Value) \
; (PVOID)InterlockedExchange((PLONG)(Target), (LONG)(Value))
;
;LONG
;FASTCALL
;InterlockedExchangeAdd(
; IN OUT PLONG Addend,
; IN LONG Increment
; );
;
;NTKERNELAPI
;LONG
;FASTCALL
;InterlockedCompareExchange(
; IN OUT PLONG Destination,
; IN LONG ExChange,
; IN LONG Comperand
; );
;
;#define InterlockedCompareExchangePointer(Destination, ExChange, Comperand) \
; (PVOID)InterlockedCompareExchange((PLONG)Destination, (LONG)ExChange, (LONG)Comperand)
;
;// end_wdm
;
;#endif
;
;
;#if !defined(MIDL_PASS) && defined(_M_IX86)
;
;//
;// i386 function definitions
;//
;
;#pragma warning(disable:4035) // re-enable below
;
; #define _PCR fs:[0]
;
;//
;// Get current IRQL.
;//
;// On x86 this function resides in the HAL
;//
;
;NTHALAPI
;KIRQL
;KeGetCurrentIrql();
;
;// end_wdm
;//
;// Get the current processor number
;//
;
;__inline ULONG KeGetCurrentProcessorNumber(VOID)
;{
; __asm { movzx eax, _PCR KPCR.Number }
;}
;
;
;#endif // !defined(MIDL_PASS) && defined(_M_IX86)
;
;
;NTKERNELAPI
;NTSTATUS
;NTAPI
;KeSaveFloatingPointState (
; OUT PKFLOATING_SAVE FloatSave
; );
;
;NTKERNELAPI
;NTSTATUS
;NTAPI
;KeRestoreFloatingPointState (
; IN PKFLOATING_SAVE FloatSave
; );
;
;
;#endif // defined(_X86_)
;
;
;// Use the following for kernel mode runtime checks of X86 system architecture
;
;#ifdef _X86_
;
;#ifdef IsNEC_98
;#undef IsNEC_98
;#endif
;
;#ifdef IsNotNEC_98
;#undef IsNotNEC_98
;#endif
;
;#ifdef SetNEC_98
;#undef SetNEC_98
;#endif
;
;#ifdef SetNotNEC_98
;#undef SetNotNEC_98
;#endif
;
;#define IsNEC_98 (SharedUserData->AlternativeArchitecture == NEC98x86)
;#define IsNotNEC_98 (SharedUserData->AlternativeArchitecture != NEC98x86)
;#define SetNEC_98 SharedUserData->AlternativeArchitecture = NEC98x86
;#define SetNotNEC_98 SharedUserData->AlternativeArchitecture = StandardDesign
;
;#endif
;
;
;#if defined(_ALPHA_)
;#ifdef __cplusplus
;extern "C" {
;#endif
;
;//
;// Types to use to contain PFNs and their counts.
;//
;
;typedef ULONG PFN_COUNT;
;
;typedef LONG_PTR SPFN_NUMBER, *PSPFN_NUMBER;
;typedef ULONG_PTR PFN_NUMBER, *PPFN_NUMBER;
;
;//
;// Define maximum size of flush multiple TB request.
;//
;
;#define FLUSH_MULTIPLE_MAXIMUM 16
;
;//
;// Indicate that the Alpha compiler supports the pragma textout construct.
;//
;
;#define ALLOC_PRAGMA 1
;
;// end_ntndis
;//
;// Include the Alpha instruction definitions
;//
;
;#include "alphaops.h"
;
;//
;// Include reference machine definitions.
;//
;
;#include "alpharef.h"
;
;//
;// Define macro to generate import names.
;//
;
;#define IMPORT_NAME(name) __imp_##name
;
;//
;// Define length of interrupt vector table.
;//
;
;#define MAXIMUM_VECTOR 256
;
;//
;// Define bus error routine type.
;//
;
;struct _EXCEPTION_RECORD;
;struct _KEXCEPTION_FRAME;
;struct _KTRAP_FRAME;
;
;typedef
;BOOLEAN
;(*PKBUS_ERROR_ROUTINE) (
; IN struct _EXCEPTION_RECORD *ExceptionRecord,
; IN struct _KEXCEPTION_FRAME *ExceptionFrame,
; IN struct _KTRAP_FRAME *TrapFrame
; );
;
;
;#define PCR_MINOR_VERSION 1
;#define PCR_MAJOR_VERSION 1
;
;typedef struct _KPCR {
;
;//
;// Major and minor version numbers of the PCR.
;//
;
; ULONG MinorVersion;
; ULONG MajorVersion;
;
;//
;// Start of the architecturally defined section of the PCR. This section
;// may be directly addressed by vendor/platform specific PAL/HAL code and will
;// not change from version to version of NT.
;
;//
;// PALcode information.
;//
;
; ULONGLONG PalBaseAddress;
; ULONG PalMajorVersion;
; ULONG PalMinorVersion;
; ULONG PalSequenceVersion;
; ULONG PalMajorSpecification;
; ULONG PalMinorSpecification;
;
;//
;// Firmware restart information.
;//
;
; ULONGLONG FirmwareRestartAddress;
; PVOID RestartBlock;
;
;//
;// Reserved per-processor region for the PAL (3K-8 bytes).
;//
;
; ULONGLONG PalReserved[383];
;
;//
;// Alignment fixup count updated by PAL and read by kernel.
;//
;
; ULONGLONG PalAlignmentFixupCount;
;
;//
;// Panic Stack Address.
;//
;
; PVOID PanicStack;
;
;//
;// Processor parameters.
;//
;
; ULONG ProcessorType;
; ULONG ProcessorRevision;
; ULONG PhysicalAddressBits;
; ULONG MaximumAddressSpaceNumber;
; ULONG PageSize;
; ULONG FirstLevelDcacheSize;
; ULONG FirstLevelDcacheFillSize;
; ULONG FirstLevelIcacheSize;
; ULONG FirstLevelIcacheFillSize;
;
;//
;// System Parameters.
;//
;
; ULONG FirmwareRevisionId;
; UCHAR SystemType[8];
; ULONG SystemVariant;
; ULONG SystemRevision;
; UCHAR SystemSerialNumber[16];
; ULONG CycleClockPeriod;
; ULONG SecondLevelCacheSize;
; ULONG SecondLevelCacheFillSize;
; ULONG ThirdLevelCacheSize;
; ULONG ThirdLevelCacheFillSize;
; ULONG FourthLevelCacheSize;
; ULONG FourthLevelCacheFillSize;
;
;//
;// Pointer to processor control block.
;//
;
; struct _KPRCB *Prcb;
;
;//
;// Processor identification.
;//
;
; CCHAR Number;
; KAFFINITY SetMember;
;
;//
;// Reserved per-processor region for the HAL (.5K bytes).
;//
;
; ULONGLONG HalReserved[64];
;
;//
;// IRQL mapping tables.
;//
;
; ULONG IrqlTable[8];
;
;#define SFW_IMT_ENTRIES 4
;#define HDW_IMT_ENTRIES 128
;
; struct _IRQLMASK {
; USHORT IrqlTableIndex; // synchronization irql level
; USHORT IDTIndex; // vector in IDT
; } IrqlMask[SFW_IMT_ENTRIES + HDW_IMT_ENTRIES];
;
;//
;// Interrupt Dispatch Table (IDT).
;//
;
; PKINTERRUPT_ROUTINE InterruptRoutine[MAXIMUM_VECTOR];
;
;//
;// Reserved vectors mask, these vectors cannot be attached to via
;// standard interrupt objects.
;//
;
; ULONG ReservedVectors;
;
;//
;// Complement of processor affinity mask.
;//
;
; KAFFINITY NotMember;
;
; ULONG InterruptInProgress;
; ULONG DpcRequested;
;
;//
;// Pointer to machine check handler
;//
;
; PKBUS_ERROR_ROUTINE MachineCheckError;
;
;//
;// DPC Stack.
;//
;
; PVOID DpcStack;
;
;//
;// End of the architecturally defined section of the PCR. This section
;// may be directly addressed by vendor/platform specific HAL code and will
;// not change from version to version of NT. Some of these values are
;// reserved for chip-specific palcode.
;} KPCR, *PKPCR;
;
;#if defined(_AXP64_)
;
;#define KI_USER_SHARED_DATA 0xffffffffff000000UI64
;
;#else
;
;#define KI_USER_SHARED_DATA 0xff000000UL
;
;#endif
;
;#define SharedUserData ((KUSER_SHARED_DATA * const) KI_USER_SHARED_DATA)
;
;// begin_wdm
;//
;// length of dispatch code in interrupt template
;//
;#define DISPATCH_LENGTH 4
;
;//
;// Define IRQL levels across the architecture.
;//
;
;#define PASSIVE_LEVEL 0
;#define LOW_LEVEL 0
;#define APC_LEVEL 1
;#define DISPATCH_LEVEL 2
;#define HIGH_LEVEL 7
;#define SYNCH_LEVEL (IPI_LEVEL-1)
;
;//
;// Non-volatile floating point state
;//
;
;typedef struct _KFLOATING_SAVE {
; ULONGLONG Fpcr;
; ULONGLONG SoftFpcr;
; ULONG Reserved1; // These reserved words are here to make it
; ULONG Reserved2; // the same size as i386/WDM.
; ULONG Reserved3;
; ULONG Reserved4;
;} KFLOATING_SAVE, *PKFLOATING_SAVE;
;
;//
;// Processor Control Block (PRCB)
;//
;
;#define PRCB_MINOR_VERSION 1
;#define PRCB_MAJOR_VERSION 2
;#define PRCB_BUILD_DEBUG 0x0001
;#define PRCB_BUILD_UNIPROCESSOR 0x0002
;
;typedef struct _KPRCB {
;
;//
;// Major and minor version numbers of the PCR.
;//
;
; USHORT MinorVersion;
; USHORT MajorVersion;
;
;//
;// Start of the architecturally defined section of the PRCB. This section
;// may be directly addressed by vendor/platform specific HAL code and will
;// not change from version to version of NT.
;//
;
; struct _KTHREAD *CurrentThread;
; struct _KTHREAD *NextThread;
; struct _KTHREAD *IdleThread;
; CCHAR Number;
; CCHAR Reserved;
; USHORT BuildType;
; KAFFINITY SetMember;
; struct _RESTART_BLOCK *RestartBlock;
;
;//
;// End of the architecturally defined section of the PRCB. This section
;// may be directly addressed by vendor/platform specific HAL code and will
;// not change from version to version of NT.
;//
;} KPRCB, *PKPRCB, *RESTRICTED_POINTER PRKPRCB;
;//
;// I/O space read and write macros.
;//
;// These have to be actual functions on Alpha, because we need
;// to shift the VA and OR in the BYTE ENABLES.
;//
;// These can become INLINEs if we require that ALL Alpha systems shift
;// the same number of bits and have the SAME byte enables.
;//
;// The READ/WRITE_REGISTER_* calls manipulate I/O registers in MEMORY space?
;//
;// The READ/WRITE_PORT_* calls manipulate I/O registers in PORT space?
;//
;
;NTHALAPI
;UCHAR
;READ_REGISTER_UCHAR(
; PUCHAR Register
; );
;
;NTHALAPI
;USHORT
;READ_REGISTER_USHORT(
; PUSHORT Register
; );
;
;NTHALAPI
;ULONG
;READ_REGISTER_ULONG(
; PULONG Register
; );
;
;NTHALAPI
;VOID
;READ_REGISTER_BUFFER_UCHAR(
; PUCHAR Register,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_REGISTER_BUFFER_USHORT(
; PUSHORT Register,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_REGISTER_BUFFER_ULONG(
; PULONG Register,
; PULONG Buffer,
; ULONG Count
; );
;
;
;NTHALAPI
;VOID
;WRITE_REGISTER_UCHAR(
; PUCHAR Register,
; UCHAR Value
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_USHORT(
; PUSHORT Register,
; USHORT Value
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_ULONG(
; PULONG Register,
; ULONG Value
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_BUFFER_UCHAR(
; PUCHAR Register,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_BUFFER_USHORT(
; PUSHORT Register,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_REGISTER_BUFFER_ULONG(
; PULONG Register,
; PULONG Buffer,
; ULONG Count
; );
;
;NTHALAPI
;UCHAR
;READ_PORT_UCHAR(
; PUCHAR Port
; );
;
;NTHALAPI
;USHORT
;READ_PORT_USHORT(
; PUSHORT Port
; );
;
;NTHALAPI
;ULONG
;READ_PORT_ULONG(
; PULONG Port
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_UCHAR(
; PUCHAR Port,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_USHORT(
; PUSHORT Port,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_ULONG(
; PULONG Port,
; PULONG Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_UCHAR(
; PUCHAR Port,
; UCHAR Value
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_USHORT(
; PUSHORT Port,
; USHORT Value
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_ULONG(
; PULONG Port,
; ULONG Value
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_UCHAR(
; PUCHAR Port,
; PUCHAR Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_USHORT(
; PUSHORT Port,
; PUSHORT Buffer,
; ULONG Count
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_ULONG(
; PULONG Port,
; PULONG Buffer,
; ULONG Count
; );
;
;// end_ntndis end_wdm
;//
;// Define Interlocked operation result values.
;//
;
;#define RESULT_ZERO 0
;#define RESULT_NEGATIVE 1
;#define RESULT_POSITIVE 2
;
;//
;// Interlocked result type is portable, but its values are machine specific.
;// Constants for value are in i386.h, mips.h, etc.
;//
;
;typedef enum _INTERLOCKED_RESULT {
; ResultNegative = RESULT_NEGATIVE,
; ResultZero = RESULT_ZERO,
; ResultPositive = RESULT_POSITIVE
;} INTERLOCKED_RESULT;
;
;//
;// Convert portable interlock interfaces to architecture specific interfaces.
;//
;
;#define ExInterlockedIncrementLong(Addend, Lock) \
; ExAlphaInterlockedIncrementLong(Addend)
;
;#define ExInterlockedDecrementLong(Addend, Lock) \
; ExAlphaInterlockedDecrementLong(Addend)
;
;#define ExInterlockedExchangeAddLargeInteger(Target, Value, Lock) \
; ExpInterlockedExchangeAddLargeInteger(Target, Value)
;
;#define ExInterlockedExchangeUlong(Target, Value, Lock) \
; ExAlphaInterlockedExchangeUlong(Target, Value)
;
;NTKERNELAPI
;INTERLOCKED_RESULT
;ExAlphaInterlockedIncrementLong (
; IN PLONG Addend
; );
;
;NTKERNELAPI
;INTERLOCKED_RESULT
;ExAlphaInterlockedDecrementLong (
; IN PLONG Addend
; );
;
;NTKERNELAPI
;LARGE_INTEGER
;ExpInterlockedExchangeAddLargeInteger (
; IN PLARGE_INTEGER Addend,
; IN LARGE_INTEGER Increment
; );
;
;NTKERNELAPI
;ULONG
;ExAlphaInterlockedExchangeUlong (
; IN PULONG Target,
; IN ULONG Value
; );
;
;// begin_wdm
;
;#if defined(_M_ALPHA) && !defined(RC_INVOKED)
;
;#define InterlockedIncrement _InterlockedIncrement
;#define InterlockedDecrement _InterlockedDecrement
;#define InterlockedExchange _InterlockedExchange
;#define InterlockedExchangeAdd _InterlockedExchangeAdd
;
;LONG
;InterlockedIncrement (
; IN OUT PLONG Addend
; );
;
;LONG
;InterlockedDecrement (
; IN OUT PLONG Addend
; );
;
;LONG
;InterlockedExchange (
; IN OUT PLONG Target,
; LONG Value
; );
;
;#if defined(_M_AXP64)
;
;#define InterlockedCompareExchange _InterlockedCompareExchange
;#define InterlockedCompareExchange64 _InterlockedCompareExchange64
;#define InterlockedExchangePointer _InterlockedExchangePointer
;#define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer
;#define InterlockedExchange64 _InterlockedExchange64
;
;LONG
;InterlockedCompareExchange (
; IN OUT PLONG Destination,
; IN LONG ExChange,
; IN LONG Comperand
; );
;
;LONGLONG
;InterlockedCompareExchange64 (
; IN OUT PLONGLONG Destination,
; IN LONGLONG ExChange,
; IN LONGLONG Comperand
; );
;
;PVOID
;InterlockedExchangePointer (
; IN OUT PVOID *Target,
; IN PVOID Value
; );
;
;PVOID
;InterlockedCompareExchangePointer (
; IN OUT PVOID *Destination,
; IN PVOID ExChange,
; IN PVOID Comperand
; );
;
;LONGLONG
;InterlockedExchange64(
; IN OUT PLONGLONG Target,
; IN LONGLONG Value
; );
;
;#pragma intrinsic(_InterlockedCompareExchange64)
;#pragma intrinsic(_InterlockedExchangePointer)
;#pragma intrinsic(_InterlockedCompareExchangePointer)
;#pragma intrinsic(_InterlockedExchange64)
;
;#else
;
;#define InterlockedExchangePointer(Target, Value) \
; (PVOID)InterlockedExchange((PLONG)(Target), (LONG)(Value))
;
;#define InterlockedCompareExchange(Destination, ExChange, Comperand) \
; (LONG)_InterlockedCompareExchange((PVOID *)(Destination), (PVOID)(ExChange), (PVOID)(Comperand))
;
;#define InterlockedCompareExchangePointer(Destination, ExChange, Comperand) \
; _InterlockedCompareExchange(Destination, ExChange, Comperand)
;
;PVOID
;_InterlockedCompareExchange (
; IN OUT PVOID *Destination,
; IN PVOID ExChange,
; IN PVOID Comperand
; );
;
;NTKERNELAPI
;LONGLONG
;ExpInterlockedCompareExchange64 (
; IN OUT PLONGLONG Destination,
; IN PLONGLONG Exchange,
; IN PLONGLONG Comperand
; );
;
;#endif
;
;LONG
;InterlockedExchangeAdd(
; IN OUT PLONG Addend,
; IN LONG Value
; );
;
;#pragma intrinsic(_InterlockedIncrement)
;#pragma intrinsic(_InterlockedDecrement)
;#pragma intrinsic(_InterlockedExchange)
;#pragma intrinsic(_InterlockedExchangeAdd)
;#pragma intrinsic(_InterlockedCompareExchange)
;
;#endif
;
;// there is a lot of other stuff that could go in here
;// probe macros
;// others
;
;//
;// Define the page size for the Alpha ev4 and lca as 8k.
;//
;
;#define PAGE_SIZE 0x2000
;
;//
;// 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 13L
;
;
;//
;// The highest user address reserves 64K bytes for a guard page. This is so
;// the probing of addresses from kernel mode only have to check the
;// starting address for structures of 64K bytes or less.
;//
;
;#if defined(_AXP64_)
;
;#define MM_HIGHEST_USER_ADDRESS (PVOID)0x3FFFFFEFFFF // highest user address
;#define MM_USER_PROBE_ADDRESS 0x3FFFFFF0000UI64 // guard page address
;#define MM_SYSTEM_RANGE_START (PVOID)0xFFFFFC0000000000 // start of system space
;
;#else
;
;#define MM_HIGHEST_USER_ADDRESS (PVOID)0x7FFEFFFF // highest user address
;#define MM_USER_PROBE_ADDRESS 0x7FFF0000 // starting address of guard page
;#define MM_SYSTEM_RANGE_START (PVOID)KSEG0_BASE // start of system space
;
;#endif
;
;
;//
;// The following definitions are required for the debugger data block.
;//
;
;extern PVOID MmHighestUserAddress;
;extern PVOID MmSystemRangeStart;
;extern ULONG_PTR MmUserProbeAddress;
;
;//
;// The lowest user address reserves the low 64k.
;//
;
;#define MM_LOWEST_USER_ADDRESS (PVOID)0x00010000
;
;// begin_wdm
;
;#define MmGetProcedureAddress(Address) (Address)
;#define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address)
;
;//
;// The lowest address for system space.
;//
;
;#if defined(_AXP64_)
;
;#define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xFFFFFE0200000000
;
;#else
;
;#define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xC0800000
;
;#endif
;
;
;//
;// Define prototypes to access PCR values
;//
;
;NTKERNELAPI
;KIRQL
;KeGetCurrentIrql();
;
;
;NTSTATUS
;KeSaveFloatingPointState (
; OUT PKFLOATING_SAVE FloatSave
; );
;
;NTSTATUS
;KeRestoreFloatingPointState (
; IN PKFLOATING_SAVE FloatSave
; );
;
;//
;// Get address of current PRCB.
;//
;
;#define KeGetCurrentPrcb() (PCR->Prcb)
;
;//
;// Get current processor number.
;//
;
;#define KeGetCurrentProcessorNumber() KeGetCurrentPrcb()->Number
;
;//
;// Cache and write buffer flush functions.
;//
;
;VOID
;KeFlushIoBuffers (
; IN PMDL Mdl,
; IN BOOLEAN ReadOperation,
; IN BOOLEAN DmaOperation
; );
;
;
;#define KeQueryTickCount(CurrentCount ) \
; *(PULONGLONG)(CurrentCount) = **((volatile ULONGLONG **)(&KeTickCount));
;
;
;#define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql))
;#define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql))
;#define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock)
;#define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock)
;
;#ifdef __cplusplus
;} // extern "C"
;#endif
;#endif // _ALPHA_
;
;#if defined(_IA64_)
;
;//
;// Types to use to contain PFNs and their counts.
;//
;
;typedef ULONG PFN_COUNT;
;
;typedef LONG_PTR SPFN_NUMBER, *PSPFN_NUMBER;
;typedef ULONG_PTR PFN_NUMBER, *PPFN_NUMBER;
;
;//
;// Define maximum size of flush multiple TB request.
;//
;
;#define FLUSH_MULTIPLE_MAXIMUM 100
;
;//
;// Indicate that the IA64 compiler supports the pragma textout construct.
;//
;
;#define ALLOC_PRAGMA 1
;
;//
;// Define intrinsic calls and their prototypes
;//
;
;#include "ia64reg.h"
;
;// Please contact INTEL to get IA64-specific information
;
;// end_wdm end_ntndis
;
;//
;// Define macro to generate import names.
;//
;
;#define IMPORT_NAME(name) __imp_##name
;
;// begin_wdm
;
;//
;// Define length of interrupt vector table.
;//
;
;// Please contact INTEL to get IA64-specific information
;#define MAXIMUM_VECTOR 256
;
;// end_wdm
;
;
;//
;// IA64 specific interlocked operation result values.
;//
;
;#define RESULT_ZERO 0
;#define RESULT_NEGATIVE 1
;#define RESULT_POSITIVE 2
;
;//
;// Interlocked result type is portable, but its values are machine specific.
;// Constants for values are in i386.h, mips.h, etc.
;//
;
;typedef enum _INTERLOCKED_RESULT {
; ResultNegative = RESULT_NEGATIVE,
; ResultZero = RESULT_ZERO,
; ResultPositive = RESULT_POSITIVE
;} INTERLOCKED_RESULT;
;
;//
;// Convert portable interlock interfaces to architecture specific interfaces.
;//
;
;#define ExInterlockedIncrementLong(Addend, Lock) \
; ExIa64InterlockedIncrementLong(Addend)
;
;#define ExInterlockedDecrementLong(Addend, Lock) \
; ExIa64InterlockedDecrementLong(Addend)
;
;#define ExInterlockedExchangeAddLargeInteger(Target, Value, Lock) \
; ExpInterlockedExchangeAddLargeInteger(Target, Value)
;
;#define ExInterlockedExchangeUlong(Target, Value, Lock) \
; ExIa64InterlockedExchangeUlong(Target, Value)
;
;NTKERNELAPI
;INTERLOCKED_RESULT
;ExIa64InterlockedIncrementLong (
; IN PLONG Addend
; );
;
;NTKERNELAPI
;INTERLOCKED_RESULT
;ExIa64InterlockedDecrementLong (
; IN PLONG Addend
; );
;
;NTKERNELAPI
;LARGE_INTEGER
;ExpInterlockedExchangeAddLargeInteger (
; IN PLARGE_INTEGER Addend,
; IN LARGE_INTEGER Increment
; );
;
;NTKERNELAPI
;ULONG
;ExIa64InterlockedExchangeUlong (
; IN PULONG Target,
; IN ULONG Value
; );
;
;// begin_wdm
;
;//
;// IA64 Interrupt Definitions.
;//
;// Define length of interrupt object dispatch code in longwords.
;//
;
;// Please contact INTEL to get IA64-specific information
;
;//
;// Begin of a block of definitions that must be synchronized with kxia64.h.
;//
;
;//
;// Define Interrupt Request Levels.
;//
;
;#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 CMC_LEVEL 3 // Correctable machine check level
;#define DEVICE_LEVEL_BASE 4 // 4 - 11 - Device IRQLs
;#define PROFILE_LEVEL 12 // Profiling level
;#define PC_LEVEL 12 // Performance Counter IRQL
;#define SYNCH_LEVEL (IPI_LEVEL-1) // Synchronization level
;#define IPI_LEVEL 14 // IPI IRQL
;#define CLOCK_LEVEL 13 // Clock Timer IRQL
;#define POWER_LEVEL 15 // Power failure level
;#define HIGH_LEVEL 15 // Highest interrupt level
;
;// Please contact INTEL to get IA64-specific information
;
;//
;// End of a block of definitions that must be synchronized with kxia64.h.
;//
;
;//
;// Define profile intervals.
;//
;
;#define DEFAULT_PROFILE_COUNT 0x40000000 // ~= 20 seconds @50mhz
;#define DEFAULT_PROFILE_INTERVAL (10 * 500) // 500 microseconds
;#define MAXIMUM_PROFILE_INTERVAL (10 * 1000 * 1000) // 1 second
;#define MINIMUM_PROFILE_INTERVAL (10 * 40) // 40 microseconds
;
;#if defined(_M_IA64) && !defined(RC_INVOKED)
;
;#define InterlockedAdd _InterlockedAdd
;#define InterlockedIncrement _InterlockedIncrement
;#define InterlockedDecrement _InterlockedDecrement
;#define InterlockedExchange _InterlockedExchange
;#define InterlockedExchangeAdd _InterlockedExchangeAdd
;
;#define InterlockedAdd64 _InterlockedAdd64
;#define InterlockedIncrement64 _InterlockedIncrement64
;#define InterlockedDecrement64 _InterlockedDecrement64
;#define InterlockedExchange64 _InterlockedExchange64
;#define InterlockedExchangeAdd64 _InterlockedExchangeAdd64
;#define InterlockedCompareExchange64 _InterlockedCompareExchange64
;
;#define InterlockedCompareExchange _InterlockedCompareExchange
;#define InterlockedExchangePointer _InterlockedExchangePointer
;#define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer
;
;LONG
;__cdecl
;InterlockedAdd (
; LONG *Addend,
; LONG Value
; );
;
;LONGLONG
;__cdecl
;InterlockedAdd64 (
; LONGLONG *Addend,
; LONGLONG Value
; );
;
;LONG
;__cdecl
;InterlockedIncrement(
; IN OUT PLONG Addend
; );
;
;LONG
;__cdecl
;InterlockedDecrement(
; IN OUT PLONG Addend
; );
;
;LONG
;__cdecl
;InterlockedExchange(
; IN OUT PLONG Target,
; IN LONG Value
; );
;
;LONG
;__cdecl
;InterlockedExchangeAdd(
; IN OUT PLONG Addend,
; IN LONG Value
; );
;
;LONG
;__cdecl
;InterlockedCompareExchange (
; IN OUT PLONG Destination,
; IN LONG ExChange,
; IN LONG Comperand
; );
;
;LONGLONG
;__cdecl
;InterlockedIncrement64(
; IN OUT PLONGLONG Addend
; );
;
;LONGLONG
;__cdecl
;InterlockedDecrement64(
; IN OUT PLONGLONG Addend
; );
;
;LONGLONG
;__cdecl
;InterlockedExchange64(
; IN OUT PLONGLONG Target,
; IN LONGLONG Value
; );
;
;LONGLONG
;__cdecl
;InterlockedExchangeAdd64(
; IN OUT PLONGLONG Addend,
; IN LONGLONG Value
; );
;
;LONGLONG
;__cdecl
;InterlockedCompareExchange64 (
; IN OUT PLONGLONG Destination,
; IN LONGLONG ExChange,
; IN LONGLONG Comperand
; );
;
;PVOID
;__cdecl
;InterlockedCompareExchangePointer (
; IN OUT PVOID *Destination,
; IN PVOID Exchange,
; IN PVOID Comperand
; );
;
;PVOID
;__cdecl
;InterlockedExchangePointer(
; IN OUT PVOID *Target,
; IN PVOID Value
; );
;
;#pragma intrinsic(_InterlockedAdd)
;#pragma intrinsic(_InterlockedIncrement)
;#pragma intrinsic(_InterlockedDecrement)
;#pragma intrinsic(_InterlockedExchange)
;#pragma intrinsic(_InterlockedCompareExchange)
;#pragma intrinsic(_InterlockedExchangeAdd)
;#pragma intrinsic(_InterlockedAdd64)
;#pragma intrinsic(_InterlockedIncrement64)
;#pragma intrinsic(_InterlockedDecrement64)
;#pragma intrinsic(_InterlockedExchange64)
;#pragma intrinsic(_InterlockedCompareExchange64)
;#pragma intrinsic(_InterlockedExchangeAdd64)
;#pragma intrinsic(_InterlockedExchangePointer)
;#pragma intrinsic(_InterlockedCompareExchangePointer)
;
;#endif // defined(_M_IA64) && !defined(RC_INVOKED)
;
;
;#define KI_USER_SHARED_DATA ((ULONG_PTR)(KADDRESS_BASE + 0xFFFE0000))
;#define SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA)
;
;//
;// Prototype for get current IRQL. **** TBD (read TPR)
;//
;
;NTKERNELAPI
;KIRQL
;KeGetCurrentIrql();
;
;// end_wdm
;
;//
;// Get address of current processor block.
;//
;
;#define KeGetCurrentPrcb() PCR->Prcb
;
;//
;// Get address of processor control region.
;//
;
;#define KeGetPcr() PCR
;
;//
;// Get address of current kernel thread object.
;//
;
;#define KeGetCurrentThread() PCR->CurrentThread
;
;//
;// Get current processor number.
;//
;
;#define KeGetCurrentProcessorNumber() PCR->Number
;
;//
;// Get data cache fill size.
;//
;
;#define KeGetDcacheFillSize() PCR->DcacheFillSize
;
;
;#define KeSaveFloatingPointState(a) STATUS_SUCCESS
;#define KeRestoreFloatingPointState(a) STATUS_SUCCESS
;
;
;//
;// Define the page size
;//
;
;#define PAGE_SIZE 0x2000
;
;//
;// 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 13L
;
;//
;// Cache and write buffer flush functions.
;//
;
;NTKERNELAPI
;VOID
;KeFlushIoBuffers (
; IN PMDL Mdl,
; IN BOOLEAN ReadOperation,
; IN BOOLEAN DmaOperation
; );
;
;
;//
;// Kernel breakin breakpoint
;//
;
;VOID
;KeBreakinBreakpoint (
; VOID
; );
;
;
;#define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql))
;#define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql))
;#define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock)
;#define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock)
;
;
;#if defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_)
;
;// begin_wdm
;
;#define KeQueryTickCount(CurrentCount ) \
; *(PULONGLONG)(CurrentCount) = **((volatile ULONGLONG **)(&KeTickCount));
;
;// end_wdm
;
;#else
;
;#define KiQueryTickCount(CurrentCount) \
; *(PULONGLONG)(CurrentCount) = KeTickCount;
;
;NTKERNELAPI
;VOID
;KeQueryTickCount (
; OUT PLARGE_INTEGER CurrentCount
; );
;
;#endif // defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_)
;
;//
;// I/O space read and write macros.
;//
;
;NTHALAPI
;UCHAR
;READ_PORT_UCHAR (
; PUCHAR RegisterAddress
; );
;
;NTHALAPI
;USHORT
;READ_PORT_USHORT (
; PUSHORT RegisterAddress
; );
;
;NTHALAPI
;ULONG
;READ_PORT_ULONG (
; PULONG RegisterAddress
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_UCHAR (
; PUCHAR portAddress,
; PUCHAR readBuffer,
; ULONG readCount
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_USHORT (
; PUSHORT portAddress,
; PUSHORT readBuffer,
; ULONG readCount
; );
;
;NTHALAPI
;VOID
;READ_PORT_BUFFER_ULONG (
; PULONG portAddress,
; PULONG readBuffer,
; ULONG readCount
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_UCHAR (
; PUCHAR portAddress,
; UCHAR Data
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_USHORT (
; PUSHORT portAddress,
; USHORT Data
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_ULONG (
; PULONG portAddress,
; ULONG Data
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_UCHAR (
; PUCHAR portAddress,
; PUCHAR writeBuffer,
; ULONG writeCount
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_USHORT (
; PUSHORT portAddress,
; PUSHORT writeBuffer,
; ULONG writeCount
; );
;
;NTHALAPI
;VOID
;WRITE_PORT_BUFFER_ULONG (
; PULONG portAddress,
; PULONG writeBuffer,
; ULONG writeCount
; );
;
;
;#define READ_REGISTER_UCHAR(x) \
; (__mf(), *(volatile UCHAR * const)(x))
;
;#define READ_REGISTER_USHORT(x) \
; (__mf(), *(volatile USHORT * const)(x))
;
;#define READ_REGISTER_ULONG(x) \
; (__mf(), *(volatile ULONG * const)(x))
;
;#define READ_REGISTER_BUFFER_UCHAR(x, y, z) { \
; PUCHAR registerBuffer = x; \
; PUCHAR readBuffer = y; \
; ULONG readCount; \
; __mf(); \
; for (readCount = z; readCount--; readBuffer++, registerBuffer++) { \
; *readBuffer = *(volatile UCHAR * const)(registerBuffer); \
; } \
;}
;
;#define READ_REGISTER_BUFFER_USHORT(x, y, z) { \
; PUSHORT registerBuffer = x; \
; PUSHORT readBuffer = y; \
; ULONG readCount; \
; __mf(); \
; for (readCount = z; readCount--; readBuffer++, registerBuffer++) { \
; *readBuffer = *(volatile USHORT * const)(registerBuffer); \
; } \
;}
;
;#define READ_REGISTER_BUFFER_ULONG(x, y, z) { \
; PULONG registerBuffer = x; \
; PULONG readBuffer = y; \
; ULONG readCount; \
; __mf(); \
; for (readCount = z; readCount--; readBuffer++, registerBuffer++) { \
; *readBuffer = *(volatile ULONG * const)(registerBuffer); \
; } \
;}
;
;#define WRITE_REGISTER_UCHAR(x, y) { \
; *(volatile UCHAR * const)(x) = y; \
; KeFlushWriteBuffer(); \
;}
;
;#define WRITE_REGISTER_USHORT(x, y) { \
; *(volatile USHORT * const)(x) = y; \
; KeFlushWriteBuffer(); \
;}
;
;#define WRITE_REGISTER_ULONG(x, y) { \
; *(volatile ULONG * const)(x) = y; \
; KeFlushWriteBuffer(); \
;}
;
;#define WRITE_REGISTER_BUFFER_UCHAR(x, y, z) { \
; PUCHAR registerBuffer = x; \
; PUCHAR writeBuffer = y; \
; ULONG writeCount; \
; for (writeCount = z; writeCount--; writeBuffer++, registerBuffer++) { \
; *(volatile UCHAR * const)(registerBuffer) = *writeBuffer; \
; } \
; KeFlushWriteBuffer(); \
;}
;
;#define WRITE_REGISTER_BUFFER_USHORT(x, y, z) { \
; PUSHORT registerBuffer = x; \
; PUSHORT writeBuffer = y; \
; ULONG writeCount; \
; for (writeCount = z; writeCount--; writeBuffer++, registerBuffer++) { \
; *(volatile USHORT * const)(registerBuffer) = *writeBuffer; \
; } \
; KeFlushWriteBuffer(); \
;}
;
;#define WRITE_REGISTER_BUFFER_ULONG(x, y, z) { \
; PULONG registerBuffer = x; \
; PULONG writeBuffer = y; \
; ULONG writeCount; \
; for (writeCount = z; writeCount--; writeBuffer++, registerBuffer++) { \
; *(volatile ULONG * const)(registerBuffer) = *writeBuffer; \
; } \
; KeFlushWriteBuffer(); \
;}
;
;//
;// Non-volatile floating point state
;//
;
;typedef struct _KFLOATING_SAVE {
; ULONG Reserved;
;} KFLOATING_SAVE, *PKFLOATING_SAVE;
;
;//
;// STATUS register for each MCA bank.
;//
;
;typedef union _MCI_STATS {
; struct {
; USHORT McaCod;
; USHORT MsCod;
; ULONG OtherInfo : 25;
; ULONG Damage : 1;
; ULONG AddressValid : 1;
; ULONG MiscValid : 1;
; ULONG Enabled : 1;
; ULONG UnCorrected : 1;
; ULONG OverFlow : 1;
; ULONG Valid : 1;
; } MciStats;
;
; ULONGLONG QuadPart;
;
;} MCI_STATS, *PMCI_STATS;
;
;
;//
;// Processor Control Block (PRCB)
;//
;
;#define PRCB_MINOR_VERSION 1
;#define PRCB_MAJOR_VERSION 1
;#define PRCB_BUILD_DEBUG 0x0001
;#define PRCB_BUILD_UNIPROCESSOR 0x0002
;
;struct _RESTART_BLOCK;
;
;typedef struct _KPRCB {
;
;//
;// Major and minor version numbers of the PCR.
;//
;
; USHORT MinorVersion;
; USHORT MajorVersion;
;
;//
;// Start of the architecturally defined section of the PRCB. This section
;// may be directly addressed by vendor/platform specific HAL code and will
;// not change from version to version of NT.
;//
;//
;
; struct _KTHREAD *CurrentThread;
; struct _KTHREAD *RESTRICTED_POINTER NextThread;
; struct _KTHREAD *IdleThread;
; CCHAR Number;
; CCHAR Reserved;
; USHORT BuildType;
; KAFFINITY SetMember;
; struct _RESTART_BLOCK *RestartBlock;
; ULONG_PTR PcrPage;
; ULONG Spares1[4];
;
;//
;// Space reserved for the system.
;//
;
; ULONGLONG SystemReserved[8];
;
;//
;// Space reserved for the HAL.
;//
;
; ULONGLONG HalReserved[16];
;
;//
;// End of the architecturally defined section of the PRCB.
;} KPRCB, *PKPRCB, *RESTRICTED_POINTER PRKPRCB;
;
;// begin_ntndis
;
;//
;// Define Processor Control Region Structure.
;//
;
;PCR_MINOR_VERSION equ 1
;PCR_MAJOR_VERSION equ 1
;
;typedef struct _KPCR {
;
;//
;// Major and minor version numbers of the PCR.
;//
; ULONG MinorVersion;
; ULONG MajorVersion;
;
;//
;// Start of the architecturally defined section of the PCR. This section
;// may be directly addressed by vendor/platform specific HAL code and will
;// not change from version to version of NT.
;//
;
;//
;// First and second level cache parameters.
;//
;
; ULONG FirstLevelDcacheSize;
; ULONG FirstLevelDcacheFillSize;
; ULONG FirstLevelIcacheSize;
; ULONG FirstLevelIcacheFillSize;
; ULONG SecondLevelDcacheSize;
; ULONG SecondLevelDcacheFillSize;
; ULONG SecondLevelIcacheSize;
; ULONG SecondLevelIcacheFillSize;
;
;//
;// Data cache alignment and fill size used for cache flushing and alignment.
;// These fields are set to the larger of the first and second level data
;// cache fill sizes.
;//
;
; ULONG DcacheAlignment;
; ULONG DcacheFillSize;
;
;//
;// Instruction cache alignment and fill size used for cache flushing and
;// alignment. These fields are set to the larger of the first and second
;// level data cache fill sizes.
;//
;
; ULONG IcacheAlignment;
; ULONG IcacheFillSize;
;
;//
;// Processor identification from PrId register.
;//
;
; ULONG ProcessorId;
;
;//
;// Profiling data.
;//
;
; ULONG ProfileInterval;
; ULONG ProfileCount;
;
;//
;// Stall execution count and scale factor.
;//
;
; ULONG StallExecutionCount;
; ULONG StallScaleFactor;
;
; ULONG InterruptionCount;
;
;//
;// Space reserved for the system.
;//
;
; ULONGLONG SystemReserved[6];
;
;//
;// Space reserved for the HAL
;//
;
; ULONGLONG HalReserved[64];
;
;//
;// IRQL mapping tables.
;//
;
; UCHAR IrqlMask[64];
; UCHAR IrqlTable[64];
;
;//
;// External Interrupt vectors.
;//
;
; PKINTERRUPT_ROUTINE InterruptRoutine[MAXIMUM_VECTOR];
;
;//
;// Reserved interrupt vector mask.
;//
;
; ULONG ReservedVectors;
;
;//
;// Processor affinity mask.
;//
;
; KAFFINITY SetMember;
;
;//
;// Complement of the processor affinity mask.
;//
;
; KAFFINITY NotMember;
;
;//
;// Pointer to processor control block.
;//
;
; struct _KPRCB *Prcb;
;
;//
;// Shadow copy of Prcb->CurrentThread for fast access
;//
;
; struct _KTHREAD *CurrentThread;
;
;//
;// Processor number.
;//
;
; CCHAR Number; // Processor Number
; UCHAR DebugActive; // debug register active in user flag
; UCHAR KernelDebugActive; // debug register active in kernel flag
; UCHAR CurrentIrql; // Current IRQL
; union {
; USHORT SoftwareInterruptPending; // Software Interrupt Pending Flag
; struct {
; UCHAR ApcInterrupt; // 0x01 if APC int pending
; UCHAR DispatchInterrupt; // 0x01 if dispatch int pending
; };
; };
;
;//
;// End of the architecturally defined section of the PCR. This section
;// may be directly addressed by vendor/platform specific HAL code and will
;// not change from version to version of NT.
;//
;
;
;} KPCR, *PKPCR;
;
;//
;// The highest user address reserves 64K bytes for a guard page. This
;// the probing of address from kernel mode to only have to check the
;// starting address for structures of 64k bytes or less.
;//
;
;#define MM_HIGHEST_USER_ADDRESS (PVOID) (ULONG_PTR)((UADDRESS_BASE + 0x3FFFFFEFFFF)) // highest user address
;#define MM_USER_PROBE_ADDRESS ((ULONG_PTR)(UADDRESS_BASE + 0x3FFFFFF0000UI64)) // starting address of guard page
;#define MM_SYSTEM_RANGE_START (PVOID) (KSEG0_BASE) // start of system space
;
;//
;// The following definitions are required for the debugger data block.
;//
;
;extern PVOID MmHighestUserAddress;
;extern PVOID MmSystemRangeStart;
;extern ULONG_PTR MmUserProbeAddress;
;
;//
;// The lowest user address reserves the low 64k.
;//
;
;#define MM_LOWEST_USER_ADDRESS (PVOID)((ULONG_PTR)(UADDRESS_BASE+0x00010000))
;
;// begin_wdm
;
;#define MmGetProcedureAddress(Address) (Address)
;#define MmLockPagableCodeSection(PLabelAddress) \
; MmLockPagableDataSection((PVOID)(*((PULONGLONG)PLabelAddress)))
;
;//
;// The lowest address for system space.
;//
;
;#define MM_LOWEST_SYSTEM_ADDRESS ((PVOID)((ULONG_PTR)(KADDRESS_BASE + 0xC0C00000)))
;#endif // defined(_IA64_)
;
;#if defined(_X86_)
;
;//
;// Define system time structure.
;//
;
;typedef struct _KSYSTEM_TIME {
; ULONG LowPart;
; LONG High1Time;
; LONG High2Time;
;} KSYSTEM_TIME, *PKSYSTEM_TIME;
;
;#endif
;
;
;#ifdef _X86_
;
;//
;// Disable these two pramas 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
;#pragma warning(disable:4164) // disable C4164 warning so that apps that
; // build with /Od don't get weird errors !
;#ifdef _M_IX86
;#pragma function(_enable)
;#pragma function(_disable)
;#endif
;
;#if _MSC_VER >= 1200
;#pragma warning(pop)
;#else
;#pragma warning(default:4164) // reenable C4164 warning
;#endif
;
;#endif
;#endif
;
;//
;// Size of kernel mode stack.
;//
;
;#define KERNEL_STACK_SIZE 12288
;
;//
;// Define size of large kernel mode stack for callbacks.
;//
;
;#define KERNEL_LARGE_STACK_SIZE 61440
;
;//
;// Define number of pages to initialize in a large kernel stack.
;//
;
;#define KERNEL_LARGE_STACK_COMMIT 12288
;
;#ifdef _X86_
;
;//
;// Define the size of the 80387 save area, which is in the context frame.
;//
;
;#define SIZE_OF_80387_REGISTERS 80
;
;//
;// The following flags control the contents of the CONTEXT structure.
;//
;
;#if !defined(RC_INVOKED)
;
;CONTEXT_i386 equ 00010000h ; this assumes that i386 and
;CONTEXT_i486 equ 00010000h ; i486 have identical context records
;
;// end_wx86
;
;#define CONTEXT_CONTROL (CONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP
;#define CONTEXT_INTEGER (CONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI
;#define CONTEXT_SEGMENTS (CONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS
;#define CONTEXT_FLOATING_POINT (CONTEXT_i386 | 0x00000008L) // 387 state
;#define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386 | 0x00000010L) // DB 0-3,6,7
;#define CONTEXT_EXTENDED_REGISTERS (CONTEXT_i386 | 0x00000020L) // cpu specific extensions
;
;#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER |\
; CONTEXT_SEGMENTS)
;
;// begin_wx86
;
;#endif
;
;#define MAXIMUM_SUPPORTED_EXTENSION 512
;
;FLOATING_SAVE_AREA STRUC
; ControlWord ULONG ?
; ULONG StatusWord;
; ULONG TagWord;
; ULONG ErrorOffset;
; ULONG ErrorSelector;
; ULONG DataOffset;
; ULONG DataSelector;
; UCHAR RegisterArea[SIZE_OF_80387_REGISTERS];
; ULONG Cr0NpxState;
;FLOATING_SAVE_AREA ENDS
;
;typedef FLOATING_SAVE_AREA *PFLOATING_SAVE_AREA;
;
;//
;// Context Frame
;//
;// This frame has a several purposes: 1) it is used as an argument to
;// NtContinue, 2) is is used to constuct a call frame for APC delivery,
;// and 3) it is used in the user level thread creation routines.
;//
;// The layout of the record conforms to a standard call frame.
;//
;
;typedef struct _CONTEXT {
;
; //
; // The flags values within this flag control the contents of
; // a CONTEXT record.
; //
; // If the context record is used as an input parameter, then
; // for each portion of the context record controlled by a flag
; // whose value is set, it is assumed that that portion of the
; // context record contains valid context. If the context record
; // is being used to modify a threads context, then only that
; // portion of the threads context will be modified.
; //
; // If the context record is used as an IN OUT parameter to capture
; // the context of a thread, then only those portions of the thread's
; // context corresponding to set flags will be returned.
; //
; // The context record is never used as an OUT only parameter.
; //
;
; ULONG ContextFlags;
;
; //
; // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
; // set in ContextFlags. Note that CONTEXT_DEBUG_REGISTERS is NOT
; // included in CONTEXT_FULL.
; //
;
; ULONG Dr0;
; ULONG Dr1;
; ULONG Dr2;
; ULONG Dr3;
; ULONG Dr6;
; ULONG Dr7;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
; //
;
; FLOATING_SAVE_AREA FloatSave;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_SEGMENTS.
; //
;
; ULONG SegGs;
; ULONG SegFs;
; ULONG SegEs;
; ULONG SegDs;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_INTEGER.
; //
;
; ULONG Edi;
; ULONG Esi;
; ULONG Ebx;
; ULONG Edx;
; ULONG Ecx;
; ULONG Eax;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_CONTROL.
; //
;
; ULONG Ebp;
; ULONG Eip;
; ULONG SegCs; // MUST BE SANITIZED
; ULONG EFlags; // MUST BE SANITIZED
; ULONG Esp;
; ULONG SegSs;
;
; //
; // This section is specified/returned if the ContextFlags word
; // contains the flag CONTEXT_EXTENDED_REGISTERS.
; // The format and contexts are processor specific
; //
;
; UCHAR ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];
;
;} CONTEXT;
;
;
;
;typedef CONTEXT *PCONTEXT;
;
;// begin_ntminiport
;
;#endif //_X86_
;
;#endif // _X86_
;
;#if defined(_ALPHA_)
;
;//
;// Define system time structure.
;//
;
;typedef ULONGLONG KSYSTEM_TIME;
;typedef KSYSTEM_TIME *PKSYSTEM_TIME;
;
;#endif
;
;#ifdef _ALPHA_
;//
;// Define size of kernel mode stack.
;//
;
;#if defined(_AXP64_)
;
;#define KERNEL_STACK_SIZE 0x6000
;
;#else
;
;#define KERNEL_STACK_SIZE 0x4000
;
;#endif
;
;//
;// Define size of large kernel mode stack for callbacks.
;//
;
;#define KERNEL_LARGE_STACK_SIZE 65536
;
;//
;// Define number of pages to initialize in a large kernel stack.
;//
;
;#define KERNEL_LARGE_STACK_COMMIT KERNEL_STACK_SIZE
;
;//
;// The following flags control the contents of the CONTEXT structure.
;//
;
;#if !defined(RC_INVOKED)
;
;#define CONTEXT_ALPHA 0x00020000
;
;#define CONTEXT_CONTROL (CONTEXT_ALPHA | 0x00000001L)
;#define CONTEXT_FLOATING_POINT (CONTEXT_ALPHA | 0x00000002L)
;#define CONTEXT_INTEGER (CONTEXT_ALPHA | 0x00000004L)
;
;#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
;
;#endif
;
;#ifndef _PORTABLE_32BIT_CONTEXT
;
;//
;// Context Frame
;//
;// This frame has a several purposes: 1) it is used as an argument to
;// NtContinue, 2) it is used to construct a call frame for APC delivery,
;// 3) it is used to construct a call frame for exception dispatching
;// in user mode, 4) it is used in the user level thread creation
;// routines, and 5) it is used to to pass thread state to debuggers.
;//
;// N.B. Because this record is used as a call frame, it must be EXACTLY
;// a multiple of 16 bytes in length.
;//
;// There are two variations of the context structure. This is the real one.
;//
;
;typedef struct _CONTEXT {
;
; //
; // This section is specified/returned if the ContextFlags word contains
; // the flag CONTEXT_FLOATING_POINT.
; //
;
; ULONGLONG FltF0;
; ULONGLONG FltF1;
; ULONGLONG FltF2;
; ULONGLONG FltF3;
; ULONGLONG FltF4;
; ULONGLONG FltF5;
; ULONGLONG FltF6;
; ULONGLONG FltF7;
; ULONGLONG FltF8;
; ULONGLONG FltF9;
; ULONGLONG FltF10;
; ULONGLONG FltF11;
; ULONGLONG FltF12;
; ULONGLONG FltF13;
; ULONGLONG FltF14;
; ULONGLONG FltF15;
; ULONGLONG FltF16;
; ULONGLONG FltF17;
; ULONGLONG FltF18;
; ULONGLONG FltF19;
; ULONGLONG FltF20;
; ULONGLONG FltF21;
; ULONGLONG FltF22;
; ULONGLONG FltF23;
; ULONGLONG FltF24;
; ULONGLONG FltF25;
; ULONGLONG FltF26;
; ULONGLONG FltF27;
; ULONGLONG FltF28;
; ULONGLONG FltF29;
; ULONGLONG FltF30;
; ULONGLONG FltF31;
;
; //
; // This section is specified/returned if the ContextFlags word contains
; // the flag CONTEXT_INTEGER.
; //
; // N.B. The registers gp, sp, and ra are defined in this section, but are
; // considered part of the control context rather than part of the integer
; // context.
; //
;
; ULONGLONG IntV0; // $0: return value register, v0
; ULONGLONG IntT0; // $1: temporary registers, t0 - t7
; ULONGLONG IntT1; // $2:
; ULONGLONG IntT2; // $3:
; ULONGLONG IntT3; // $4:
; ULONGLONG IntT4; // $5:
; ULONGLONG IntT5; // $6:
; ULONGLONG IntT6; // $7:
; ULONGLONG IntT7; // $8:
; ULONGLONG IntS0; // $9: nonvolatile registers, s0 - s5
; ULONGLONG IntS1; // $10:
; ULONGLONG IntS2; // $11:
; ULONGLONG IntS3; // $12:
; ULONGLONG IntS4; // $13:
; ULONGLONG IntS5; // $14:
; ULONGLONG IntFp; // $15: frame pointer register, fp/s6
; ULONGLONG IntA0; // $16: argument registers, a0 - a5
; ULONGLONG IntA1; // $17:
; ULONGLONG IntA2; // $18:
; ULONGLONG IntA3; // $19:
; ULONGLONG IntA4; // $20:
; ULONGLONG IntA5; // $21:
; ULONGLONG IntT8; // $22: temporary registers, t8 - t11
; ULONGLONG IntT9; // $23:
; ULONGLONG IntT10; // $24:
; ULONGLONG IntT11; // $25:
; ULONGLONG IntRa; // $26: return address register, ra
; ULONGLONG IntT12; // $27: temporary register, t12
; ULONGLONG IntAt; // $28: assembler temp register, at
; ULONGLONG IntGp; // $29: global pointer register, gp
; ULONGLONG IntSp; // $30: stack pointer register, sp
; ULONGLONG IntZero; // $31: zero register, zero
;
; //
; // This section is specified/returned if the ContextFlags word contains
; // the flag CONTEXT_FLOATING_POINT.
; //
;
; ULONGLONG Fpcr; // floating point control register
; ULONGLONG SoftFpcr; // software extension to FPCR
;
; //
; // This section is specified/returned if the ContextFlags word contains
; // the flag CONTEXT_CONTROL.
; //
; // N.B. The registers gp, sp, and ra are defined in the integer section,
; // but are considered part of the control context rather than part of
; // the integer context.
; //
;
; ULONGLONG Fir; // (fault instruction) continuation address
; ULONG Psr; // processor status
;
; //
; // The flags values within this flag control the contents of
; // a CONTEXT record.
; //
; // If the context record is used as an input parameter, then
; // for each portion of the context record controlled by a flag
; // whose value is set, it is assumed that that portion of the
; // context record contains valid context. If the context record
; // is being used to modify a thread's context, then only that
; // portion of the threads context will be modified.
; //
; // If the context record is used as an IN OUT parameter to capture
; // the context of a thread, then only those portions of the thread's
; // context corresponding to set flags will be returned.
; //
; // The context record is never used as an OUT only parameter.
; //
;
; ULONG ContextFlags;
; ULONG Fill[4]; // padding for 16-byte stack frame alignment
;
;} CONTEXT, *PCONTEXT;
;
;#else
;
;#error _PORTABLE_32BIT_CONTEXT no longer supported on Alpha.
;
;#endif // _PORTABLE_32BIT_CONTEXT
;
;#endif
;#ifdef _IA64_
;
;//
;// Define system time structure (use alpha approach).
;//
;
;typedef ULONGLONG KSYSTEM_TIME;
;typedef KSYSTEM_TIME *PKSYSTEM_TIME;
;
;#endif // _IA64_
;
;#ifdef _IA64_
;
;// Please contact INTEL to get IA64-specific information
;//
;// Define size of kernel mode stack.
;//
;
;#define KERNEL_STACK_SIZE 0x8000
;
;//
;// Define size of large kernel mode stack for callbacks.
;//
;
;#define KERNEL_LARGE_STACK_SIZE 0xC000
;
;//
;// Define number of pages to initialize in a large kernel stack.
;//
;
;KERNEL_LARGE_STACK_COMMIT equ 8000h
;
;//
;// Intel-IA64-Filler ; Define size of kernel mode backing store stack.
;//
;
;#define KERNEL_BSTORE_SIZE 0x4000
;
;//
;// Intel-IA64-Filler ; Define size of large kernel mode backing store for callbacks.
;//
;
;#define KERNEL_LARGE_BSTORE_SIZE 0x8000
;
;//
;// Intel-IA64-Filler ; Define number of pages to initialize in a large kernel backing store
;//
;
;#define KERNEL_LARGE_BSTORE_COMMIT 0x4000
;
;//
;// Define base address for kernel and user space
;//
;
;#define UREGION_INDEX 0
;
;#define KREGION_INDEX 7
;
;#define UADDRESS_BASE ((ULONGLONG)UREGION_INDEX << 61)
;
;
;#define KADDRESS_BASE ((ULONGLONG)KREGION_INDEX << 61)
;
;
;//
;// The following flags control the contents of the CONTEXT structure.
;//
;
;#if !defined(RC_INVOKED)
;
;// Please contact INTEL to get IA64-specific information
;
;#endif // !defined(RC_INVOKED)
;
;//
;// Context Frame
;//
;// This frame has a several purposes: 1) it is used as an argument to
;// NtContinue, 2) it is used to construct a call frame for APC delivery,
;// 3) it is used to construct a call frame for exception dispatching
;// in user mode, 4) it is used in the user level thread creation
;// routines, and 5) it is used to to pass thread state to debuggers.
;//
;// N.B. Because this record is used as a call frame, it must be EXACTLY
;// a multiple of 16 bytes in length and aligned on a 16-byte boundary.
;//
;
;typedef struct _CONTEXT {
;
; //
; // The flags values within this flag control the contents of
; // a CONTEXT record.
; //
; // If the context record is used as an input parameter, then
; // for each portion of the context record controlled by a flag
; // whose value is set, it is assumed that that portion of the
; // context record contains valid context. If the context record
; // is being used to modify a thread's context, then only that
; // portion of the threads context will be modified.
; //
; // If the context record is used as an IN OUT parameter to capture
; // the context of a thread, then only those portions of the thread's
; // context corresponding to set flags will be returned.
; //
; // The context record is never used as an OUT only parameter.
; //
;
; ULONG ContextFlags;
; ULONG Fill1[3]; // for alignment of following on 16-byte boundary
;
; //
; // This section is specified/returned if the ContextFlags word contains
; // the flag CONTEXT_DEBUG.
; //
; // N.B. CONTEXT_DEBUG is *not* part of CONTEXT_FULL.
; //
;
;// Please contact INTEL to get IA64-specific information
;
;} CONTEXT, *PCONTEXT;
;
;//
;// Followings are the data structures that required to support Legacy x86
;//
;
;
;//
;// Define the size of the 80387 save area, which is in the context frame.
;//
;
;#define SIZE_OF_80387_REGISTERS 80
;
;//
;// The following flags control the contents of the CONTEXT structure.
;//
;
;#if !defined(RC_INVOKED)
;
;#define CONTEXT_i386 0x00010000 // this assumes that i386 and
;#define CONTEXT_i486 0x00010000 // i486 have identical context records
;#define CONTEXT_X86 0x00010000 // X86 have identical context records
;
;#define CONTEXT86_CONTROL (CONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP
;#define CONTEXT86_INTEGER (CONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI
;#define CONTEXT86_SEGMENTS (CONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS
;#define CONTEXT86_FLOATING_POINT (CONTEXT_i386 | 0x00000008L) // 387 state
;#define CONTEXT86_DEBUG_REGISTERS (CONTEXT_i386 | 0x00000010L) // DB 0-3,6,7
;
;#define CONTEXT86_FULL (CONTEXT86_CONTROL | CONTEXT86_INTEGER |\
; CONTEXT86_SEGMENTS) // context corresponding to set flags will be returned.
;
;#endif // !defined(RC_INVOKED)
;
;typedef struct _FLOATING_SAVE_AREA {
; ULONG ControlWord;
; ULONG StatusWord;
; ULONG TagWord;
; ULONG ErrorOffset;
; ULONG ErrorSelector;
; ULONG DataOffset;
; ULONG DataSelector;
; UCHAR RegisterArea[SIZE_OF_80387_REGISTERS];
; ULONG Cr0NpxState;
;} FLOATING_SAVE_AREA;
;
;typedef FLOATING_SAVE_AREA *PFLOATING_SAVE_AREA;
;
;//
;// Context Frame
;//
;// This frame has a several purposes: 1) it is used as an argument to
;// NtContinue, 2) is is used to constuct a call frame for APC delivery,
;// and 3) it is used in the user level thread creation routines.
;//
;// The layout of the record conforms to a standard call frame.
;//
;
;typedef struct _CONTEXT86 {
;
; //
; // The flags values within this flag control the contents of
; // a CONTEXT record.
; //
; // If the context record is used as an input parameter, then
; // for each portion of the context record controlled by a flag
; // whose value is set, it is assumed that that portion of the
; // context record contains valid context. If the context record
; // is being used to modify a threads context, then only that
; // portion of the threads context will be modified.
; //
; // If the context record is used as an IN OUT parameter to capture
; // the context of a thread, then only those portions of the thread's
; // context corresponding to set flags will be returned.
; //
; // The context record is never used as an OUT only parameter.
; //
;
; ULONG ContextFlags;
;
; //
; // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
; // set in ContextFlags. Note that CONTEXT_DEBUG_REGISTERS is NOT
; // included in CONTEXT_FULL.
; //
;
; ULONG Dr0;
; ULONG Dr1;
; ULONG Dr2;
; ULONG Dr3;
; ULONG Dr6;
; ULONG Dr7;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
; //
;
; FLOATING_SAVE_AREA FloatSave;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_SEGMENTS.
; //
;
; ULONG SegGs;
; ULONG SegFs;
; ULONG SegEs;
; ULONG SegDs;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_INTEGER.
; //
; //
;
; ULONG Edi;
; ULONG Esi;
; ULONG Ebx;
; ULONG Edx;
; ULONG Ecx;
; ULONG Eax;
;
; //
; // This section is specified/returned if the
; // ContextFlags word contians the flag CONTEXT_CONTROL.
; //
;
; ULONG Ebp;
; ULONG Eip;
; ULONG SegCs; // MUST BE SANITIZED
; ULONG EFlags; // MUST BE SANITIZED
; ULONG Esp;
; ULONG SegSs;
;
;} CONTEXT86;
;
;// end_winnt
;
;typedef CONTEXT86 *PCONTEXT86;
;
;#define CONTEXT86_TO_PROGRAM_COUNTER(Context) (PVOID)((Context)->Eip)
;
;#define CONTEXT86_LENGTH (sizeof(CONTEXT86))
;#define CONTEXT86_ALIGN (sizeof(ULONG))
;#define CONTEXT86_ROUND (CONTEXT86_ALIGN - 1)
;
;//
;// GDT selectors - These defines are R0 selector numbers, which means
;// they happen to match the byte offset relative to
;// the base of the GDT.
;//
;
;#define KGDT_NULL 0
;#define KGDT_R0_CODE 8
;#define KGDT_R0_DATA 16
;#define KGDT_R3_CODE 24
;#define KGDT_R3_DATA 32
;#define KGDT_TSS 40
;#define KGDT_R0_PCR 48
;#define KGDT_R3_TEB 56
;#define KGDT_VDM_TILE 64
;#define KGDT_LDT 72
;#define KGDT_DF_TSS 80
;#define KGDT_NMI_TSS 88
;
;//
;// GDT selectors - These defines are R0 selector numbers, which means
;// they happen to match the byte offset relative to
;// the base of the GDT.
;//
;
;#define KGDT_NULL 0
;#define KGDT_R3_CODE 24
;#define KGDT_R3_DATA 32
;#define KGDT_R3_TEB 56
;#define KGDT_VDM_TILE 64
;
;//
;// GDT table is now reside in TEB structure, and the entries can only
;// accomerdate 24 entries. We purposely take away KGDT_NUMBER and use
;// GDT_TABLE_SIZE
;//
;
;#define GDT_ENTRIES 24
;#define GDT_TABLE_SIZE (GDT_ENTRIES<<3)
;
;
;// begin_winnt
;
;#ifndef _LDT_ENTRY_DEFINED
;#define _LDT_ENTRY_DEFINED
;
;//
;// LDT descriptor entry
;//
;
;typedef struct _LDT_ENTRY {
; USHORT LimitLow;
; USHORT BaseLow;
; union {
; struct {
; UCHAR BaseMid;
; UCHAR Flags1; // Declare as bytes to avoid alignment
; UCHAR Flags2; // Problems.
; UCHAR BaseHi;
; } Bytes;
; struct {
; ULONG BaseMid : 8;
; ULONG Type : 5;
; ULONG Dpl : 2;
; ULONG Pres : 1;
; ULONG LimitHi : 4;
; ULONG Sys : 1;
; ULONG Reserved_0 : 1;
; ULONG Default_Big : 1;
; ULONG Granularity : 1;
; ULONG BaseHi : 8;
; } Bits;
; } HighWord;
;} LDT_ENTRY, *PLDT_ENTRY;
;
;#endif // _LDT_ENTRY_DEFINED
;
;// end_winnt
;
;#define LDT_TABLE_SIZE ( 8 * 1024 * sizeof(LDT_ENTRY) )
;
;//
;// Process Ldt Information
;// NtQueryInformationProcess using ProcessLdtInformation
;//
;
;typedef struct _LDT_INFORMATION {
; ULONG Start;
; ULONG Length;
; LDT_ENTRY LdtEntries[1];
;} PROCESS_LDT_INFORMATION, *PPROCESS_LDT_INFORMATION;
;
;//
;// Process Ldt Size
;// NtSetInformationProcess using ProcessLdtSize
;//
;
;typedef struct _LDT_SIZE {
; ULONG Length;
;} PROCESS_LDT_SIZE, *PPROCESS_LDT_SIZE;
;
;//
;// Thread Descriptor Table Entry
;// NtQueryInformationThread using ThreadDescriptorTableEntry
;//
;
;// begin_windbgkd
;
;#ifndef _DESCRIPTOR_TABLE_ENTRY_DEFINED
;#define _DESCRIPTOR_TABLE_ENTRY_DEFINED
;
;typedef struct _DESCRIPTOR_TABLE_ENTRY {
; ULONG Selector;
; LDT_ENTRY Descriptor;
;} DESCRIPTOR_TABLE_ENTRY, *PDESCRIPTOR_TABLE_ENTRY;
;
;#endif // _DESCRIPTOR_TABLE_ENTRY_DEFINED
;
;// end_windbgkd
;
;// begin_winnt
;
;//
;// Plabel descriptor structure definition
;//
;
;// Please contact INTEL to get IA64-specific information
;
;// end_winnt
;
;#endif // _IA64_
;//
;// Event Specific Access Rights.
;//
;
;#define EVENT_QUERY_STATE 0x0001
;#define EVENT_MODIFY_STATE 0x0002 // winnt
;#define EVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3) // winnt
;
;//
;// Semaphore Specific Access Rights.
;//
;
;#define SEMAPHORE_QUERY_STATE 0x0001
;#define SEMAPHORE_MODIFY_STATE 0x0002 // winnt
;
;#define SEMAPHORE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3) // winnt
;
;//
;// Timer APC routine definition.
;//
;
;typedef
;VOID
;(*PTIMER_APC_ROUTINE) (
; IN PVOID TimerContext,
; IN ULONG TimerLowValue,
; IN LONG TimerHighValue
; );
;
;
;//
;// Defined processor features
;//
;
;PF_FLOATING_POINT_PRECISION_ERRATA equ 0
;#define PF_FLOATING_POINT_EMULATED 1 // winnt
;#define PF_COMPARE_EXCHANGE_DOUBLE 2 // winnt
;#define PF_MMX_INSTRUCTIONS_AVAILABLE 3 // winnt
;#define PF_PPC_MOVEMEM_64BIT_OK 4 // winnt
;#define PF_ALPHA_BYTE_INSTRUCTIONS 5 // winnt
;#define PF_XMMI_INSTRUCTIONS_AVAILABLE 6 // winnt
;#define PF_3DNOW_INSTRUCTIONS_AVAILABLE 7 // winnt
;#define PF_RDTSC_INSTRUCTION_AVAILABLE 8 // winnt
;#define PF_PAE_ENABLED 9 // winnt
;
;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
;
;#define PROCESSOR_FEATURE_MAX 64
;
;#if defined(REMOTE_BOOT)
;//
;// Defined system flags.
;//
;
;/* the following two lines should be tagged with "winnt" when REMOTE_BOOT is on. */
;#define SYSTEM_FLAG_REMOTE_BOOT_CLIENT 0x00000001
;#define SYSTEM_FLAG_DISKLESS_CLIENT 0x00000002
;#endif // defined(REMOTE_BOOT)
;
;//
;// Define data shared between kernel and user mode.
;//
;// N.B. User mode has read only access to this data
;//
;#ifdef _MAC
;#pragma warning( disable : 4121)
;#endif
;
;typedef struct _KUSER_SHARED_DATA {
;
; //
; // Current low 32-bit of tick count and tick count multiplier.
; //
; // N.B. The tick count is updated each time the clock ticks.
; //
;
; volatile ULONG TickCountLow;
; ULONG TickCountMultiplier;
;
; //
; // Current 64-bit interrupt time in 100ns units.
; //
;
; volatile KSYSTEM_TIME InterruptTime;
;#if defined(_WIN64)
; volatile LONG InterruptHigh2Time;
;#endif
;
; //
; // Current 64-bit system time in 100ns units.
; //
;
;#if defined(_WIN64)
; volatile ULONG SystemLowTime;
; volatile LONG SystemHigh1Time;
; volatile LONG SystemHigh2Time;
;#else
; volatile KSYSTEM_TIME SystemTime;
;#endif
;
; //
; // Current 64-bit time zone bias.
; //
;
; volatile KSYSTEM_TIME TimeZoneBias;
;#if defined(_WIN64)
; volatile LONG TimeZoneBiasHigh2Time;
;#endif
;
; //
; // Support image magic number range for the host system.
; //
; // N.B. This is an inclusive range.
; //
;
; USHORT ImageNumberLow;
; USHORT ImageNumberHigh;
;
; //
; // Copy of system root in Unicode
; //
;
; WCHAR NtSystemRoot[ 260 ];
;
; //
; // Maximum stack trace depth if tracing enabled.
; //
;
; ULONG MaxStackTraceDepth;
;
; //
; // Crypto Exponent
; //
;
; ULONG CryptoExponent;
;
; //
; // TimeZoneId
; //
;
; ULONG TimeZoneId;
;
; ULONG Reserved2[ 8 ];
;
; //
; // product type
; //
;
; NT_PRODUCT_TYPE NtProductType;
; BOOLEAN ProductTypeIsValid;
;
; //
; // NT Version. Note that each process sees a version from its PEB, but
; // if the process is running with an altered view of the system version,
; // the following two fields are used to correctly identify the version
; //
;
; ULONG NtMajorVersion;
; ULONG NtMinorVersion;
;
; //
; // Processor Feature Bits
; //
;
; BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX];
;
; //
; // Reserved fields - do not use
; //
; ULONG Reserved1;
; ULONG Reserved3;
;
; //
; // Time slippage while in debugger
; //
;
; volatile ULONG TimeSlip;
;
; //
; // Alternative system architecture. Example: NEC PC98xx on x86
; //
;
; ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
;
; //
; // If the system is an evaluation unit, the following field contains the
; // date and time that the evaluation unit expires. A value of 0 indicates
; // that there is no expiration. A non-zero value is the UTC absolute time
; // that the system expires.
; //
;
; LARGE_INTEGER SystemExpirationDate;
;
; //
; // Suite Support
; //
; ULONG SuiteMask;
;
;#if defined(REMOTE_BOOT)
; //
; // System flags.
; //
;
; ULONG SystemFlags;
;
; //
; // Server path to remote boot root. Only valid for remote boot clients.
; //
;
; WCHAR RemoteBootServerPath[ 260 ];
;#endif // defined(REMOTE_BOOT)
;
; //
; // TRUE if a kernel debugger is connected/enabled
; //
; BOOLEAN KdDebuggerEnabled;
;
;} KUSER_SHARED_DATA, *PKUSER_SHARED_DATA;
;
;
;#ifdef _MAC
;#pragma warning( default : 4121 )
;#endif
;
;// begin_winnt
;//
;// Predefined Value Types.
;//
;
;#define REG_NONE ( 0 ) // No value type
;#define REG_SZ ( 1 ) // Unicode nul terminated string
;#define REG_EXPAND_SZ ( 2 ) // Unicode nul terminated string
; // (with environment variable references)
;#define REG_BINARY ( 3 ) // Free form binary
;#define REG_DWORD ( 4 ) // 32-bit number
;#define REG_DWORD_LITTLE_ENDIAN ( 4 ) // 32-bit number (same as REG_DWORD)
;#define REG_DWORD_BIG_ENDIAN ( 5 ) // 32-bit number
;#define REG_LINK ( 6 ) // Symbolic Link (unicode)
;#define REG_MULTI_SZ ( 7 ) // Multiple Unicode strings
;#define REG_RESOURCE_LIST ( 8 ) // Resource list in the resource map
;#define REG_FULL_RESOURCE_DESCRIPTOR ( 9 ) // Resource list in the hardware description
;#define REG_RESOURCE_REQUIREMENTS_LIST ( 10 )
;#define REG_QWORD ( 11 ) // 64-bit number
;#define REG_QWORD_LITTLE_ENDIAN ( 11 ) // 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_INTERACTIVE_PROCESS 0x00000100
;
;#define SERVICE_TYPE_ALL (SERVICE_WIN32 | \
; SERVICE_ADAPTER | \
; SERVICE_DRIVER | \
; SERVICE_INTERACTIVE_PROCESS)
;
;//
;// 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;
;
;// end_winnt
;
;//
;// Resource List definitions
;//
;
;// begin_ntminiport begin_ntndis
;
;//
;// 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)
;// end_wdm
;#define CmResourceTypeMaximum 7
;#define CmResourceTypeAssignedResource 8 // BUGBUG--remove
;#define CmResourceTypeSubAllocateFrom 9 // BUGBUG--remove
;// begin_wdm
;#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)
;
;//
;// Defines the ShareDisposition in the RESOURCE_DESCRIPTOR
;//
;
;typedef enum _CM_SHARE_DISPOSITION {
; CmResourceShareUndetermined = 0, // Reserved
; CmResourceShareDeviceExclusive,
; CmResourceShareDriverExclusive,
; CmResourceShareShared
;} CM_SHARE_DISPOSITION;
;
;//
;// Define the PASSIGNED_RESOURCE type
;//
;
;#ifndef PASSIGNED_RESOURCE_DEFINED
;#define PASSIGNED_RESOURCE_DEFINED
;typedef PVOID PASSIGNED_RESOURCE;
;#endif // PASSIGNED_RESOURCE_DEFINED
;
;// end_wdm
;
;//
;// Define the bit masks for Flags common for all CM_RESOURCE_TYPE
;//
;// BUGBUG--remove the following 3 flags...
;//
;#define CM_RESOURCE_COMMON_COMPUTE_LENGTH_FROM_DEPENDENTS 0x8000
;#define CM_RESOURCE_COMMON_NOT_REASSIGNED 0x4000
;#define CM_RESOURCE_COMMON_SUBSTRACTIVE 0x2000
;
;// begin_wdm
;
;//
;// Define the bit masks for Flags when type is CmResourceTypeInterrupt
;//
;
;#define CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE 0
;#define CM_RESOURCE_INTERRUPT_LATCHED 1
;
;//
;// Define the bit masks for Flags when type is CmResourceTypeMemory
;//
;
;#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_PREFETCHABLE 0x0004
;
;#define CM_RESOURCE_MEMORY_COMBINEDWRITE 0x0008
;#define CM_RESOURCE_MEMORY_24 0x0010
;#define CM_RESOURCE_MEMORY_CACHEABLE 0x0020
;
;//
;// Define the bit masks for Flags when type is CmResourceTypePort
;//
;
;#define CM_RESOURCE_PORT_MEMORY 0x0000
;#define CM_RESOURCE_PORT_IO 0x0001
;// end_wdm
;#define CM_RESOURCE_PORT_FORWARD_FIRST_256_OF_EACH_1024 0x0002 // BUGBUG--remove
;// begin_wdm
;#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 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
;// end_wdm
;
;//
;// Define the bit masks for Flags when type is CmResourceTypeBusNumber
;//
;
;#define CM_RESOURCE_BUSNUMBER_SUBALLOCATE_FIRST_VALUE 0x0001 // BUGBUG--remove
;
;//
;// Define the bit masks for Flags when type is CmResourceTypeSubAllocateFrom
;//
;
;#define CM_RESOURCE_SUBALLOCATEFROM_FIXED_TRANSLATION 0x0001 // BUGBUG--remove
;#define CM_RESOURCE_SUBALLOCATEFROM_WIRED_TRANSLATION 0x0002 // BUGBUG--remove
;
;// end_ntminiport end_ntndis
;
;// begin_wdm
;
;//
;// 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).
;//
;// begin_ntndis
;
;#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;
;
; //
; // end_wdm
; // Range of port numbers, inclusive. These are physical, bus
; // relative. The value should be the same as the one passed to
; // HalTranslateBusAddress().
; // begin_wdm
; //
;
; struct {
; PHYSICAL_ADDRESS Start;
; ULONG Length;
; } Port;
;
; //
; // end_wdm
; // IRQL and vector. Should be same values as were passed to
; // HalGetInterruptVector().
; // begin_wdm
; //
;
; struct {
; ULONG Level;
; ULONG Vector;
; ULONG Affinity;
; } Interrupt;
;
; //
; // 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;
;
; //
; // 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;
; } 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.
;//
;// end_wdm
;// Note: The BusNumber and Type are redundant information, but we will keep
;// it since it allows the driver _not_ to append it when it is creating
;// a resource list which could possibly span multiple buses.
;//
;// begin_wdm
;// 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;
;
;// end_ntndis
;//
;// 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;
; ULONG 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;
;
;// begin_ntminiport begin_ntndis
;
;#include "pshpack1.h"
;
;// end_ntminiport end_ntndis
;
;//
;// 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;
;
;// begin_ntminiport begin_ntndis
;
;//
;// 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
;
;// end_ntminiport end_ntndis
;
;//
;// 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;
;
;// end_wdm
;//
;// Declaration of the structure for the PcCard ISA IRQ map
;//
;
;typedef struct _CM_PCCARD_DEVICE_DATA {
; UCHAR Flags;
; UCHAR ErrorCode;
; USHORT Reserved;
; ULONG BusData;
; ULONG DeviceId;
; ULONG LegacyBaseAddress;
; UCHAR IRQMap[16];
;} CM_PCCARD_DEVICE_DATA, *PCM_PCCARD_DEVICE_DATA;
;
;// Definitions for Flags
;
;#define PCCARD_MAP_ERROR 0x01
;#define PCCARD_DEVICE_PCI 0x10
;
;#define PCCARD_SCAN_DISABLED 0x01
;#define PCCARD_MAP_ZERO 0x02
;#define PCCARD_NO_TIMER 0x03
;#define PCCARD_NO_PIC 0x04
;#define PCCARD_NO_LEGACY_BASE 0x05
;#define PCCARD_DUP_LEGACY_BASE 0x06
;#define PCCARD_NO_CONTROLLERS 0x07
;
;// begin_wdm
;// begin_ntminiport
;
;//
;// Defines Resource Options
;//
;
;#define IO_RESOURCE_PREFERRED 0x01
;#define IO_RESOURCE_DEFAULT 0x02
;#define IO_RESOURCE_ALTERNATIVE 0x08
;
;
;//
;// 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;
; } Interrupt;
;
; struct {
; ULONG MinimumChannel;
; ULONG MaximumChannel;
; } Dma;
;
; 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;
;
;// end_wdm
;
; struct {
; PASSIGNED_RESOURCE AssignedResource;
; } AssignedResource; // will be obsoleted
;
; struct {
; UCHAR Type; // use CM_RESOURCE_TYPE
; UCHAR Reserved[3];
; PASSIGNED_RESOURCE AssignedResource;
; PHYSICAL_ADDRESS Transformation;
; } SubAllocateFrom; // will be obsoleted
;
;// begin_wdm
;
; struct {
; ULONG Priority; // use LCPRI_Xxx values in cfg.h
; ULONG Reserved1;
; ULONG Reserved2;
; } ConfigData;
;
; } u;
;
;} IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
;
;// end_ntminiport
;
;
;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;
;
;//
;// Exception flag definitions.
;//
;
;// begin_winnt
;#define EXCEPTION_NONCONTINUABLE 0x1 // Noncontinuable exception
;// end_winnt
;
;//
;// Define maximum number of exception parameters.
;//
;
;// begin_winnt
;#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;
;// end_winnt
;
;//
;// Define configuration routine types.
;//
;// Configuration information.
;//
;
;typedef enum _CONFIGURATION_TYPE {
; ArcSystem,
; CentralProcessor,
; FloatingPointProcessor,
; PrimaryIcache,
; PrimaryDcache,
; SecondaryIcache,
; SecondaryDcache,
; SecondaryCache,
; EisaAdapter,
; TcAdapter,
; ScsiAdapter,
; DtiAdapter,
; MultiFunctionAdapter,
; DiskController,
; TapeController,
; CdromController,
; WormController,
; SerialController,
; NetworkController,
; DisplayController,
; ParallelController,
; PointerController,
; KeyboardController,
; AudioController,
; OtherController,
; DiskPeripheral,
; FloppyDiskPeripheral,
; TapePeripheral,
; ModemPeripheral,
; MonitorPeripheral,
; PrinterPeripheral,
; PointerPeripheral,
; KeyboardPeripheral,
; TerminalPeripheral,
; OtherPeripheral,
; LinePeripheral,
; NetworkPeripheral,
; SystemMemory,
; DockingInformation,
; RealModeIrqRoutingTable,
; MaximumType
;} CONFIGURATION_TYPE, *PCONFIGURATION_TYPE;
;
;#define THREAD_WAIT_OBJECTS 3 // Builtin usable wait blocks
;
;//
;// Interrupt modes.
;//
;
;typedef enum _KINTERRUPT_MODE {
; LevelSensitive,
; Latched
; } KINTERRUPT_MODE;
;
;//
;// Wait reasons
;//
;
;typedef enum _KWAIT_REASON {
; Executive,
; FreePage,
; PageIn,
; PoolAllocation,
; DelayExecution,
; Suspended,
; UserRequest,
; WrExecutive,
; WrFreePage,
; WrPageIn,
; WrPoolAllocation,
; WrDelayExecution,
; WrSuspended,
; WrUserRequest,
; WrEventPair,
; WrQueue,
; WrLpcReceive,
; WrLpcReply,
; WrVirtualMemory,
; WrPageOut,
; WrRendezvous,
; Spare2,
; Spare3,
; Spare4,
; Spare5,
; Spare6,
; WrKernel,
; MaximumWaitReason
; } KWAIT_REASON;
;
;//
;// Common dispatcher object header
;//
;// N.B. The size field contains the number of dwords in the structure.
;//
;
;typedef struct _DISPATCHER_HEADER {
; UCHAR Type;
; UCHAR Absolute;
; UCHAR Size;
; UCHAR Inserted;
; LONG SignalState;
; LIST_ENTRY WaitListHead;
;} DISPATCHER_HEADER;
;
;
;typedef struct _KWAIT_BLOCK {
; LIST_ENTRY WaitListEntry;
; struct _KTHREAD *RESTRICTED_POINTER Thread;
; PVOID Object;
; struct _KWAIT_BLOCK *RESTRICTED_POINTER NextWaitBlock;
; USHORT WaitKey;
; USHORT WaitType;
;} KWAIT_BLOCK, *PKWAIT_BLOCK, *RESTRICTED_POINTER PRKWAIT_BLOCK;
;
;//
;// Thread start function
;//
;
;typedef
;VOID
;(*PKSTART_ROUTINE) (
; IN PVOID StartContext
; );
;
;//
;// Kernel object structure definitions
;//
;
;//
;// Device Queue object and entry
;//
;
;typedef struct _KDEVICE_QUEUE {
; CSHORT Type;
; CSHORT Size;
; LIST_ENTRY DeviceListHead;
; KSPIN_LOCK Lock;
; BOOLEAN Busy;
;} KDEVICE_QUEUE, *PKDEVICE_QUEUE, *RESTRICTED_POINTER PRKDEVICE_QUEUE;
;
;typedef struct _KDEVICE_QUEUE_ENTRY {
; LIST_ENTRY DeviceListEntry;
; ULONG SortKey;
; BOOLEAN Inserted;
;} KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY, *RESTRICTED_POINTER PRKDEVICE_QUEUE_ENTRY;
;
;// begin_ntndis
;//
;// Event object
;//
;
;typedef struct _KEVENT {
; DISPATCHER_HEADER Header;
;} KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;
;
;//
;// Define the interrupt service function type and the empty struct
;// type.
;//
;typedef
;BOOLEAN
;(*PKSERVICE_ROUTINE) (
; IN struct _KINTERRUPT *Interrupt,
; IN PVOID ServiceContext
; );
;//
;// Mutant object
;//
;
;typedef struct _KMUTANT {
; DISPATCHER_HEADER Header;
; LIST_ENTRY MutantListEntry;
; struct _KTHREAD *RESTRICTED_POINTER OwnerThread;
; BOOLEAN Abandoned;
; UCHAR ApcDisable;
;} KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT, KMUTEX, *PKMUTEX, *RESTRICTED_POINTER PRKMUTEX;
;
;//
;//
;// Semaphore object
;//
;
;typedef struct _KSEMAPHORE {
; DISPATCHER_HEADER Header;
; LONG Limit;
;} KSEMAPHORE, *PKSEMAPHORE, *RESTRICTED_POINTER PRKSEMAPHORE;
;
;// begin_ntndis
;//
;// Timer object
;//
;
;typedef struct _KTIMER {
; DISPATCHER_HEADER Header;
; ULARGE_INTEGER DueTime;
; LIST_ENTRY TimerListEntry;
; struct _KDPC *Dpc;
; LONG Period;
;} KTIMER, *PKTIMER, *RESTRICTED_POINTER PRKTIMER;
;
;//
;// DPC object
;//
;
;NTKERNELAPI
;VOID
;KeInitializeDpc (
; IN PRKDPC Dpc,
; IN PKDEFERRED_ROUTINE DeferredRoutine,
; IN PVOID DeferredContext
; );
;
;NTKERNELAPI
;BOOLEAN
;KeInsertQueueDpc (
; IN PRKDPC Dpc,
; IN PVOID SystemArgument1,
; IN PVOID SystemArgument2
; );
;
;NTKERNELAPI
;BOOLEAN
;KeRemoveQueueDpc (
; IN PRKDPC Dpc
; );
;
;// end_wdm
;
;NTKERNELAPI
;VOID
;KeSetImportanceDpc (
; IN PRKDPC Dpc,
; IN KDPC_IMPORTANCE Importance
; );
;
;NTKERNELAPI
;VOID
;KeSetTargetProcessorDpc (
; IN PRKDPC Dpc,
; IN CCHAR Number
; );
;
;// begin_wdm
;//
;// Device queue object
;//
;
;NTKERNELAPI
;VOID
;KeInitializeDeviceQueue (
; IN PKDEVICE_QUEUE DeviceQueue
; );
;
;NTKERNELAPI
;BOOLEAN
;KeInsertDeviceQueue (
; IN PKDEVICE_QUEUE DeviceQueue,
; IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry
; );
;
;NTKERNELAPI
;BOOLEAN
;KeInsertByKeyDeviceQueue (
; IN PKDEVICE_QUEUE DeviceQueue,
; IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry,
; IN ULONG SortKey
; );
;
;NTKERNELAPI
;PKDEVICE_QUEUE_ENTRY
;KeRemoveDeviceQueue (
; IN PKDEVICE_QUEUE DeviceQueue
; );
;
;NTKERNELAPI
;PKDEVICE_QUEUE_ENTRY
;KeRemoveByKeyDeviceQueue (
; IN PKDEVICE_QUEUE DeviceQueue,
; IN ULONG SortKey
; );
;
;NTKERNELAPI
;BOOLEAN
;KeRemoveEntryDeviceQueue (
; IN PKDEVICE_QUEUE DeviceQueue,
; IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry
; );
;
;NTKERNELAPI
;BOOLEAN
;KeSynchronizeExecution (
; IN PKINTERRUPT Interrupt,
; IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
; IN PVOID SynchronizeContext
; );
;
;//
;// Kernel dispatcher object functions
;//
;// Event Object
;//
;
;
;NTKERNELAPI
;VOID
;KeInitializeEvent (
; IN PRKEVENT Event,
; IN EVENT_TYPE Type,
; IN BOOLEAN State
; );
;
;NTKERNELAPI
;VOID
;KeClearEvent (
; IN PRKEVENT Event
; );
;
;NTKERNELAPI
;LONG
;KePulseEvent (
; IN PRKEVENT Event,
; IN KPRIORITY Increment,
; IN BOOLEAN Wait
; );
;
;NTKERNELAPI
;LONG
;KeReadStateEvent (
; IN PRKEVENT Event
; );
;
;// begin_wdm
;
;NTKERNELAPI
;LONG
;KeResetEvent (
; IN PRKEVENT Event
; );
;
;NTKERNELAPI
;LONG
;KeSetEvent (
; IN PRKEVENT Event,
; IN KPRIORITY Increment,
; IN BOOLEAN Wait
; );
;
;//
;// Mutex object
;//
;
;NTKERNELAPI
;VOID
;KeInitializeMutex (
; IN PRKMUTEX Mutex,
; IN ULONG Level
; );
;
;#define KeReadStateMutex(Mutex) KeReadStateMutant(Mutex)
;
;NTKERNELAPI
;LONG
;KeReleaseMutex (
; IN PRKMUTEX Mutex,
; IN BOOLEAN Wait
; );
;
;//
;// Semaphore object
;//
;
;NTKERNELAPI
;VOID
;KeInitializeSemaphore (
; IN PRKSEMAPHORE Semaphore,
; IN LONG Count,
; IN LONG Limit
; );
;
;NTKERNELAPI
;LONG
;KeReadStateSemaphore (
; IN PRKSEMAPHORE Semaphore
; );
;
;NTKERNELAPI
;LONG
;KeReleaseSemaphore (
; IN PRKSEMAPHORE Semaphore,
; IN KPRIORITY Increment,
; IN LONG Adjustment,
; IN BOOLEAN Wait
; );
;
;NTKERNELAPI
;NTSTATUS
;KeDelayExecutionThread (
; IN KPROCESSOR_MODE WaitMode,
; IN BOOLEAN Alertable,
; IN PLARGE_INTEGER Interval
; );
;
;NTKERNELAPI
;KPRIORITY
;KeQueryPriorityThread (
; IN PKTHREAD Thread
; );
;
;NTKERNELAPI
;LONG
;KeSetBasePriorityThread (
; IN PKTHREAD Thread,
; IN LONG Increment
; );
;
;NTKERNELAPI
;KPRIORITY
;KeSetPriorityThread (
; IN PKTHREAD Thread,
; IN KPRIORITY Priority
; );
;
;
;#if (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_)) && !defined(_NTSYSTEM_DRIVER_)
;
;// begin_wdm
;
;NTKERNELAPI
;VOID
;KeEnterCriticalRegion (
; VOID
; );
;
;NTKERNELAPI
;VOID
;KeLeaveCriticalRegion (
; VOID
; );
;
;// end_wdm
;
;#else
;
;//++
;//
;// VOID
;// KeEnterCriticalRegion (
;// VOID
;// )
;//
;//
;// Routine Description:
;//
;// This function disables kernel APC's.
;//
;// N.B. The following code does not require any interlocks. There are
;// two cases of interest: 1) On an MP system, the thread cannot
;// be running on two processors as once, and 2) if the thread is
;// is interrupted to deliver a kernel mode APC which also calls
;// this routine, the values read and stored will stack and unstack
;// properly.
;//
;// Arguments:
;//
;// None.
;//
;// Return Value:
;//
;// None.
;//--
;
;#define KeEnterCriticalRegion() KeGetCurrentThread()->KernelApcDisable -= 1;
;
;//++
;//
;// VOID
;// KeLeaveCriticalRegion (
;// VOID
;// )
;//
;//
;// Routine Description:
;//
;// This function enables kernel APC's.
;//
;// N.B. The following code does not require any interlocks. There are
;// two cases of interest: 1) On an MP system, the thread cannot
;// be running on two processors as once, and 2) if the thread is
;// is interrupted to deliver a kernel mode APC which also calls
;// this routine, the values read and stored will stack and unstack
;// properly.
;//
;// Arguments:
;//
;// None.
;//
;// Return Value:
;//
;// None.
;//--
;
;#define KeLeaveCriticalRegion() KiLeaveCriticalRegion()
;
;#endif
;
;// begin_wdm
;
;//
;// Timer object
;//
;
;NTKERNELAPI
;VOID
;KeInitializeTimer (
; IN PKTIMER Timer
; );
;
;NTKERNELAPI
;VOID
;KeInitializeTimerEx (
; IN PKTIMER Timer,
; IN TIMER_TYPE Type
; );
;
;NTKERNELAPI
;BOOLEAN
;KeCancelTimer (
; IN PKTIMER
; );
;
;NTKERNELAPI
;BOOLEAN
;KeReadStateTimer (
; PKTIMER Timer
; );
;
;NTKERNELAPI
;BOOLEAN
;KeSetTimer (
; IN PKTIMER Timer,
; IN LARGE_INTEGER DueTime,
; IN PKDPC Dpc OPTIONAL
; );
;
;NTKERNELAPI
;BOOLEAN
;KeSetTimerEx (
; IN PKTIMER Timer,
; IN LARGE_INTEGER DueTime,
; IN LONG Period OPTIONAL,
; IN PKDPC Dpc OPTIONAL
; );
;
;
;#define KeWaitForMutexObject KeWaitForSingleObject
;
;NTKERNELAPI
;NTSTATUS
;KeWaitForMultipleObjects (
; IN ULONG Count,
; IN PVOID Object[],
; IN WAIT_TYPE WaitType,
; IN KWAIT_REASON WaitReason,
; IN KPROCESSOR_MODE WaitMode,
; IN BOOLEAN Alertable,
; IN PLARGE_INTEGER Timeout OPTIONAL,
; IN PKWAIT_BLOCK WaitBlockArray OPTIONAL
; );
;
;NTKERNELAPI
;NTSTATUS
;KeWaitForSingleObject (
; IN PVOID Object,
; IN KWAIT_REASON WaitReason,
; IN KPROCESSOR_MODE WaitMode,
; IN BOOLEAN Alertable,
; IN PLARGE_INTEGER Timeout OPTIONAL
; );
;
;
;//
;// On X86 the following routines are defined in the HAL and imported by
;// all other modules.
;//
;
;#if defined(_X86_) && !defined(_NTHAL_)
;
;#define _DECL_HAL_KE_IMPORT __declspec(dllimport)
;
;#else
;
;#define _DECL_HAL_KE_IMPORT
;
;#endif
;
;//
;// spin lock functions
;//
;
;NTKERNELAPI
;VOID
;NTAPI
;KeInitializeSpinLock (
; IN PKSPIN_LOCK SpinLock
; );
;
;#if defined(_X86_)
;
;NTKERNELAPI
;VOID
;FASTCALL
;KefAcquireSpinLockAtDpcLevel (
; IN PKSPIN_LOCK SpinLock
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;KefReleaseSpinLockFromDpcLevel (
; IN PKSPIN_LOCK SpinLock
; );
;
;#define KeAcquireSpinLockAtDpcLevel(a) KefAcquireSpinLockAtDpcLevel(a)
;#define KeReleaseSpinLockFromDpcLevel(a) KefReleaseSpinLockFromDpcLevel(a)
;
;_DECL_HAL_KE_IMPORT
;KIRQL
;FASTCALL
;KfAcquireSpinLock (
; IN PKSPIN_LOCK SpinLock
; );
;
;_DECL_HAL_KE_IMPORT
;VOID
;FASTCALL
;KfReleaseSpinLock (
; IN PKSPIN_LOCK SpinLock,
; IN KIRQL NewIrql
; );
;
;// end_wdm
;
;_DECL_HAL_KE_IMPORT
;KIRQL
;FASTCALL
;KeAcquireSpinLockRaiseToSynch (
; IN PKSPIN_LOCK SpinLock
; );
;
;// begin_wdm
;
;#define KeAcquireSpinLock(a,b) *(b) = KfAcquireSpinLock(a)
;#define KeReleaseSpinLock(a,b) KfReleaseSpinLock(a,b)
;
;#else
;
;NTKERNELAPI
;KIRQL
;FASTCALL
;KeAcquireSpinLockRaiseToSynch (
; IN PKSPIN_LOCK SpinLock
; );
;
;NTKERNELAPI
;VOID
;KeAcquireSpinLockAtDpcLevel (
; IN PKSPIN_LOCK SpinLock
; );
;
;NTKERNELAPI
;VOID
;KeReleaseSpinLockFromDpcLevel (
; IN PKSPIN_LOCK SpinLock
; );
;
;NTKERNELAPI
;KIRQL
;KeAcquireSpinLockRaiseToDpc (
; IN PKSPIN_LOCK SpinLock
; );
;
;#define KeAcquireSpinLock(SpinLock, OldIrql) \
; *(OldIrql) = KeAcquireSpinLockRaiseToDpc(SpinLock)
;
;NTKERNELAPI
;VOID
;KeReleaseSpinLock (
; IN PKSPIN_LOCK SpinLock,
; IN KIRQL NewIrql
; );
;
;#endif
;
;
;#if defined(_X86_)
;
;_DECL_HAL_KE_IMPORT
;VOID
;FASTCALL
;KfLowerIrql (
; IN KIRQL NewIrql
; );
;
;_DECL_HAL_KE_IMPORT
;KIRQL
;FASTCALL
;KfRaiseIrql (
; IN KIRQL NewIrql
; );
;
;// end_wdm
;
;_DECL_HAL_KE_IMPORT
;KIRQL
;KeRaiseIrqlToDpcLevel(
; VOID
; );
;
;_DECL_HAL_KE_IMPORT
;KIRQL
;KeRaiseIrqlToSynchLevel(
; VOID
; );
;
;// begin_wdm
;
;#define KeLowerIrql(a) KfLowerIrql(a)
;#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
;
;// end_wdm
;
;// begin_wdm
;
;#elif defined(_ALPHA_)
;
;#define KeLowerIrql(a) __swpirql(a)
;#define KeRaiseIrql(a,b) *(b) = __swpirql(a)
;
;// end_wdm
;
;#define KfRaiseIrql(a) __swpirql(a)
;#define KeRaiseIrqlToDpcLevel() __swpirql(DISPATCH_LEVEL)
;#define KeRaiseIrqlToSynchLevel() __swpirql((UCHAR)KiSynchIrql)
;
;// begin_wdm
;
;#elif defined(_IA64_)
;
;VOID
;KeLowerIrql (
; IN KIRQL NewIrql
; );
;
;VOID
;KeRaiseIrql (
; IN KIRQL NewIrql,
; OUT PKIRQL OldIrql
; );
;
;// end_wdm
;
;KIRQL
;KeRaiseIrqlToDpcLevel (
; VOID
; );
;
;KIRQL
;KeRaiseIrqlToSynchLevel (
; VOID
; );
;
;// begin_wdm
;
;#endif
;
;//
;// Miscellaneous kernel functions
;//
;
;// end_wdm
;
;BOOLEAN
;KeGetBugMessageText(
; IN ULONG MessageId,
; IN PANSI_STRING ReturnedString OPTIONAL
; );
;
;typedef enum _KBUGCHECK_BUFFER_DUMP_STATE {
; BufferEmpty,
; BufferInserted,
; BufferStarted,
; BufferFinished,
; BufferIncomplete
;} KBUGCHECK_BUFFER_DUMP_STATE;
;
;typedef
;VOID
;(*PKBUGCHECK_CALLBACK_ROUTINE) (
; IN PVOID Buffer,
; IN ULONG Length
; );
;
;typedef struct _KBUGCHECK_CALLBACK_RECORD {
; LIST_ENTRY Entry;
; PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine;
; PVOID Buffer;
; ULONG Length;
; PUCHAR Component;
; ULONG_PTR Checksum;
; UCHAR State;
;} KBUGCHECK_CALLBACK_RECORD, *PKBUGCHECK_CALLBACK_RECORD;
;
;NTKERNELAPI
;DECLSPEC_NORETURN
;VOID
;NTAPI
;KeBugCheck (
; IN ULONG BugCheckCode
; );
;
;// begin_wdm
;
;NTKERNELAPI
;DECLSPEC_NORETURN
;VOID
;KeBugCheckEx(
; IN ULONG BugCheckCode,
; IN ULONG_PTR BugCheckParameter1,
; IN ULONG_PTR BugCheckParameter2,
; IN ULONG_PTR BugCheckParameter3,
; IN ULONG_PTR BugCheckParameter4
; );
;
;// end_wdm
;
;#define KeInitializeCallbackRecord(CallbackRecord) \
; (CallbackRecord)->State = BufferEmpty
;
;NTKERNELAPI
;BOOLEAN
;KeDeregisterBugCheckCallback (
; IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord
; );
;
;NTKERNELAPI
;BOOLEAN
;KeRegisterBugCheckCallback (
; IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
; IN PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
; IN PVOID Buffer,
; IN ULONG Length,
; IN PUCHAR Component
; );
;
;NTKERNELAPI
;VOID
;KeEnterKernelDebugger (
; VOID
; );
;
;
;NTKERNELAPI
;ULONGLONG
;KeQueryInterruptTime (
; VOID
; );
;
;NTKERNELAPI
;VOID
;KeQuerySystemTime (
; OUT PLARGE_INTEGER CurrentTime
; );
;
;NTKERNELAPI
;ULONG
;KeQueryTimeIncrement (
; VOID
; );
;
;// end_wdm
;NTKERNELAPI
;KAFFINITY
;KeQueryActiveProcessors (
; VOID
; );
;
;//
;// Context swap notify routine.
;//
;
;typedef
;VOID
;(FASTCALL *PSWAP_CONTEXT_NOTIFY_ROUTINE)(
; IN HANDLE OldThreadId,
; IN HANDLE NewThreadId
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;KeSetSwapContextNotifyRoutine(
; IN PSWAP_CONTEXT_NOTIFY_ROUTINE NotifyRoutine
; );
;
;//
;// Thread select notify routine.
;//
;
;typedef
;LOGICAL
;(FASTCALL *PTHREAD_SELECT_NOTIFY_ROUTINE)(
; IN HANDLE ThreadId
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;KeSetThreadSelectNotifyRoutine(
; IN PTHREAD_SELECT_NOTIFY_ROUTINE NotifyRoutine
; );
;
;//
;// Time update notify routine.
;//
;
;typedef
;VOID
;(FASTCALL *PTIME_UPDATE_NOTIFY_ROUTINE)(
; IN HANDLE ThreadId,
; IN KPROCESSOR_MODE Mode
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;KeSetTimeUpdateNotifyRoutine(
; IN PTIME_UPDATE_NOTIFY_ROUTINE NotifyRoutine
; );
;
;extern volatile KSYSTEM_TIME KeTickCount;
;
;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
;} MEMORY_CACHING_TYPE;
;
;//
;// Define external data.
;// because of indirection for all drivers external to ntoskrnl these are actually ptrs
;//
;
;#if defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_WDMDDK_)
;
;extern PBOOLEAN KdDebuggerNotPresent;
;extern PBOOLEAN KdDebuggerEnabled;
;
;#else
;
;extern BOOLEAN KdDebuggerNotPresent;
;extern BOOLEAN KdDebuggerEnabled;
;
;#endif
;
;
;
;
;typedef struct _DBGKD_DEBUG_DATA_HEADER64 *PDBGKD_DEBUG_DATA_HEADER64;
;
;BOOLEAN
;KdRegisterDebuggerDataBlock(
; IN ULONG Tag,
; IN PDBGKD_DEBUG_DATA_HEADER64 DataHeader,
; IN ULONG Size
; );
;
;VOID
;KdDeregisterDebuggerDataBlock32(
; IN PDBGKD_DEBUG_DATA_HEADER64 DataHeader
; );
;
;VOID
;KdDisableDebugger(
; VOID
; );
;
;VOID
;KdEnableDebugger(
; VOID
; );
;
;//
;// Pool Allocation routines (in pool.c)
;//
;
;typedef enum _POOL_TYPE {
; NonPagedPool,
; PagedPool,
; NonPagedPoolMustSucceed,
; DontUseThisType,
; NonPagedPoolCacheAligned,
; PagedPoolCacheAligned,
; NonPagedPoolCacheAlignedMustS,
; MaxPoolType
;
; // end_wdm
; ,
; //
; // 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,
;
; // begin_wdm
;
; } POOL_TYPE;
;
;
;NTKERNELAPI
;PVOID
;ExAllocatePool(
; IN POOL_TYPE PoolType,
; IN SIZE_T NumberOfBytes
; );
;
;NTKERNELAPI
;PVOID
;ExAllocatePoolWithQuota(
; IN POOL_TYPE PoolType,
; IN SIZE_T NumberOfBytes
; );
;
;NTKERNELAPI
;PVOID
;NTAPI
;ExAllocatePoolWithTag(
; IN POOL_TYPE PoolType,
; IN SIZE_T NumberOfBytes,
; IN ULONG Tag
; );
;
;// end_wdm
;
;//
;// _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 _EX_POOL_PRIORITY {
; LowPoolPriority,
; LowPoolPrioritySpecialPoolOverrun = 8,
; LowPoolPrioritySpecialPoolUnderrun = 9,
; NormalPoolPriority = 16,
; NormalPoolPrioritySpecialPoolOverrun = 24,
; NormalPoolPrioritySpecialPoolUnderrun = 25,
; HighPoolPriority = 32,
; HighPoolPrioritySpecialPoolOverrun = 40,
; HighPoolPrioritySpecialPoolUnderrun = 41
;
; } EX_POOL_PRIORITY;
;
;NTKERNELAPI
;PVOID
;NTAPI
;ExAllocatePoolWithTagPriority(
; IN POOL_TYPE PoolType,
; IN SIZE_T NumberOfBytes,
; IN ULONG Tag,
; IN EX_POOL_PRIORITY Priority
; );
;
;// begin_wdm
;
;#ifndef POOL_TAGGING
;#define ExAllocatePoolWithTag(a,b,c) ExAllocatePool(a,b)
;#endif //POOL_TAGGING
;
;NTKERNELAPI
;PVOID
;ExAllocatePoolWithQuotaTag(
; IN POOL_TYPE PoolType,
; IN SIZE_T NumberOfBytes,
; IN ULONG Tag
; );
;
;#ifndef POOL_TAGGING
;#define ExAllocatePoolWithQuotaTag(a,b,c) ExAllocatePoolWithQuota(a,b)
;#endif //POOL_TAGGING
;
;NTKERNELAPI
;VOID
;NTAPI
;ExFreePool(
; IN PVOID P
; );
;
;//
;// Routines to support fast mutexes.
;//
;
;typedef struct _FAST_MUTEX {
; LONG Count;
; PKTHREAD Owner;
; ULONG Contention;
; KEVENT Event;
; ULONG OldIrql;
;} FAST_MUTEX, *PFAST_MUTEX;
;
;#if DBG
;#define ExInitializeFastMutex(_FastMutex) \
; (_FastMutex)->Count = 1; \
; (_FastMutex)->Owner = NULL; \
; (_FastMutex)->Contention = 0; \
; KeInitializeEvent(&(_FastMutex)->Event, \
; SynchronizationEvent, \
; FALSE);
;#else
;#define ExInitializeFastMutex(_FastMutex) \
; (_FastMutex)->Count = 1; \
; (_FastMutex)->Contention = 0; \
; KeInitializeEvent(&(_FastMutex)->Event, \
; SynchronizationEvent, \
; FALSE);
;#endif // DBG
;
;NTKERNELAPI
;VOID
;FASTCALL
;ExAcquireFastMutexUnsafe (
; IN PFAST_MUTEX FastMutex
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;ExReleaseFastMutexUnsafe (
; IN PFAST_MUTEX FastMutex
; );
;
;#if defined(_ALPHA_) || defined(_IA64_)
;
;NTKERNELAPI
;VOID
;FASTCALL
;ExAcquireFastMutex (
; IN PFAST_MUTEX FastMutex
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;ExReleaseFastMutex (
; IN PFAST_MUTEX FastMutex
; );
;
;// end_wdm
;
;NTKERNELAPI
;BOOLEAN
;FASTCALL
;ExTryToAcquireFastMutex (
; IN PFAST_MUTEX FastMutex
; );
;
;// begin_wdm
;
;#elif defined(_X86_)
;
;NTHALAPI
;VOID
;FASTCALL
;ExAcquireFastMutex (
; IN PFAST_MUTEX FastMutex
; );
;
;NTHALAPI
;VOID
;FASTCALL
;ExReleaseFastMutex (
; IN PFAST_MUTEX FastMutex
; );
;
;// end_wdm
;
;NTHALAPI
;BOOLEAN
;FASTCALL
;ExTryToAcquireFastMutex (
; IN PFAST_MUTEX FastMutex
; );
;
;// begin_wdm
;
;#else
;
;#error "Target architecture not defined"
;
;#endif
;
;//
;
;NTKERNELAPI
;VOID
;FASTCALL
;ExInterlockedAddLargeStatistic (
; IN PLARGE_INTEGER Addend,
; IN ULONG Increment
; );
;
;// end_ntndis
;
;NTKERNELAPI
;LARGE_INTEGER
;ExInterlockedAddLargeInteger (
; IN PLARGE_INTEGER Addend,
; IN LARGE_INTEGER Increment,
; IN PKSPIN_LOCK Lock
; );
;
;
;NTKERNELAPI
;ULONG
;FASTCALL
;ExInterlockedAddUlong (
; IN PULONG Addend,
; IN ULONG Increment,
; IN PKSPIN_LOCK Lock
; );
;
;
;#if defined(_AXP64_)
;
;#define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \
; InterlockedCompareExchange64(Destination, *(Exchange), *(Comperand))
;
;#elif defined(_ALPHA_)
;
;#define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \
; ExpInterlockedCompareExchange64(Destination, Exchange, Comperand)
;
;#elif defined(_IA64_)
;
;#define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock) \
; InterlockedCompareExchange64(Destination, *(Exchange), *(Comperand))
;
;#else
;
;NTKERNELAPI
;LONGLONG
;FASTCALL
;ExInterlockedCompareExchange64 (
; IN PLONGLONG Destination,
; IN PLONGLONG Exchange,
; IN PLONGLONG Comperand,
; IN PKSPIN_LOCK Lock
; );
;
;#endif
;
;NTKERNELAPI
;PLIST_ENTRY
;FASTCALL
;ExInterlockedInsertHeadList (
; IN PLIST_ENTRY ListHead,
; IN PLIST_ENTRY ListEntry,
; IN PKSPIN_LOCK Lock
; );
;
;NTKERNELAPI
;PLIST_ENTRY
;FASTCALL
;ExInterlockedInsertTailList (
; IN PLIST_ENTRY ListHead,
; IN PLIST_ENTRY ListEntry,
; IN PKSPIN_LOCK Lock
; );
;
;NTKERNELAPI
;PLIST_ENTRY
;FASTCALL
;ExInterlockedRemoveHeadList (
; IN PLIST_ENTRY ListHead,
; IN PKSPIN_LOCK Lock
; );
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;FASTCALL
;ExInterlockedPopEntryList (
; IN PSINGLE_LIST_ENTRY ListHead,
; IN PKSPIN_LOCK Lock
; );
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;FASTCALL
;ExInterlockedPushEntryList (
; IN PSINGLE_LIST_ENTRY ListHead,
; IN PSINGLE_LIST_ENTRY ListEntry,
; IN PKSPIN_LOCK Lock
; );
;
;// begin_ntndis
;
;//
;// 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 MIPS, Alpha, and Pentium and later
;// machines to insert and remove from the list without the use of spinlocks.
;// The PowerPc, however, must use a spinlock to synchronize access to the
;// list.
;//
;// N.B. A spinlock must be specified with SLIST operations. However, it may
;// not actually be used.
;//
;
;/*++
;
;VOID
;ExInitializeSListHead (
; IN 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.
;
;--*/
;
;#define ExInitializeSListHead(_listhead_) (_listhead_)->Alignment = 0
;
;/*++
;
;USHORT
;ExQueryDepthSList (
; IN PSLIST_HEADERT 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.
;
;--*/
;
;#define ExQueryDepthSList(_listhead_) (USHORT)(_listhead_)->Depth
;
;#if defined(_MIPS_) || defined(_ALPHA_) || defined(_IA64_)
;
;#define ExInterlockedPopEntrySList(Head, Lock) \
; ExpInterlockedPopEntrySList(Head)
;
;#define ExInterlockedPushEntrySList(Head, Entry, Lock) \
; ExpInterlockedPushEntrySList(Head, Entry)
;
;#define ExInterlockedFlushSList(Head) \
; ExpInterlockedFlushSList(Head)
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;ExpInterlockedPopEntrySList (
; IN PSLIST_HEADER ListHead
; );
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;ExpInterlockedPushEntrySList (
; IN PSLIST_HEADER ListHead,
; IN PSINGLE_LIST_ENTRY ListEntry
; );
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;ExpInterlockedFlushSList (
; IN PSLIST_HEADER ListHead
; );
;
;#else
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;FASTCALL
;ExInterlockedPopEntrySList (
; IN PSLIST_HEADER ListHead,
; IN PKSPIN_LOCK Lock
; );
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;FASTCALL
;ExInterlockedPushEntrySList (
; IN PSLIST_HEADER ListHead,
; IN PSINGLE_LIST_ENTRY ListEntry,
; IN PKSPIN_LOCK Lock
; );
;
;NTKERNELAPI
;PSINGLE_LIST_ENTRY
;FASTCALL
;ExInterlockedFlushSList (
; IN PSLIST_HEADER ListHead
; );
;
;#endif
;
;
;typedef
;PVOID
;(*PALLOCATE_FUNCTION) (
; IN POOL_TYPE PoolType,
; IN SIZE_T NumberOfBytes,
; IN ULONG Tag
; );
;
;typedef
;VOID
;(*PFREE_FUNCTION) (
; IN PVOID Buffer
; );
;
;typedef struct _GENERAL_LOOKASIDE {
; SLIST_HEADER ListHead;
; USHORT Depth;
; USHORT MaximumDepth;
; ULONG TotalAllocates;
; union {
; ULONG AllocateMisses;
; ULONG AllocateHits;
; };
;
; ULONG TotalFrees;
; union {
; ULONG FreeMisses;
; ULONG FreeHits;
; };
;
; POOL_TYPE Type;
; ULONG Tag;
; ULONG Size;
; PALLOCATE_FUNCTION Allocate;
; PFREE_FUNCTION Free;
; LIST_ENTRY ListEntry;
; ULONG LastTotalAllocates;
; union {
; ULONG LastAllocateMisses;
; ULONG LastAllocateHits;
; };
;
; ULONG Future[2];
;} GENERAL_LOOKASIDE, *PGENERAL_LOOKASIDE;
;
;typedef struct _NPAGED_LOOKASIDE_LIST {
; GENERAL_LOOKASIDE L;
; KSPIN_LOCK Lock;
;} NPAGED_LOOKASIDE_LIST, *PNPAGED_LOOKASIDE_LIST;
;
;
;NTKERNELAPI
;VOID
;ExInitializeNPagedLookasideList (
; IN PNPAGED_LOOKASIDE_LIST Lookaside,
; IN PALLOCATE_FUNCTION Allocate,
; IN PFREE_FUNCTION Free,
; IN ULONG Flags,
; IN SIZE_T Size,
; IN ULONG Tag,
; IN USHORT Depth
; );
;
;NTKERNELAPI
;VOID
;ExDeleteNPagedLookasideList (
; IN PNPAGED_LOOKASIDE_LIST Lookaside
; );
;
;__inline
;PVOID
;ExAllocateFromNPagedLookasideList(
; IN 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;
; Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead, &Lookaside->Lock);
; if (Entry == NULL) {
; Lookaside->L.AllocateMisses += 1;
; Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
; Lookaside->L.Size,
; Lookaside->L.Tag);
; }
;
; return Entry;
;}
;
;__inline
;VOID
;ExFreeToNPagedLookasideList(
; IN PNPAGED_LOOKASIDE_LIST Lookaside,
; IN 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 {
; ExInterlockedPushEntrySList(&Lookaside->L.ListHead,
; (PSINGLE_LIST_ENTRY)Entry,
; &Lookaside->Lock);
; }
;
; return;
;}
;
;// end_ntndis
;
;typedef struct _PAGED_LOOKASIDE_LIST {
; GENERAL_LOOKASIDE L;
; FAST_MUTEX Lock;
;} PAGED_LOOKASIDE_LIST, *PPAGED_LOOKASIDE_LIST;
;
;NTKERNELAPI
;VOID
;ExInitializePagedLookasideList (
; IN PPAGED_LOOKASIDE_LIST Lookaside,
; IN PALLOCATE_FUNCTION Allocate,
; IN PFREE_FUNCTION Free,
; IN ULONG Flags,
; IN SIZE_T Size,
; IN ULONG Tag,
; IN USHORT Depth
; );
;
;NTKERNELAPI
;VOID
;ExDeletePagedLookasideList (
; IN PPAGED_LOOKASIDE_LIST Lookaside
; );
;
;#if defined(_X86_)
;
;NTKERNELAPI
;PVOID
;ExAllocateFromPagedLookasideList(
; IN PPAGED_LOOKASIDE_LIST Lookaside
; );
;
;NTKERNELAPI
;VOID
;ExFreeToPagedLookasideList(
; IN PPAGED_LOOKASIDE_LIST Lookaside,
; IN PVOID Entry
; );
;
;#else
;
;__inline
;PVOID
;ExAllocateFromPagedLookasideList(
; IN 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 = ExInterlockedPopEntrySList(&Lookaside->L.ListHead, NULL);
; if (Entry == NULL) {
; Lookaside->L.AllocateMisses += 1;
; Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
; Lookaside->L.Size,
; Lookaside->L.Tag);
; }
;
; return Entry;
;}
;
;__inline
;VOID
;ExFreeToPagedLookasideList(
; IN PPAGED_LOOKASIDE_LIST Lookaside,
; IN 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 {
; ExInterlockedPushEntrySList(&Lookaside->L.ListHead,
; (PSINGLE_LIST_ENTRY)Entry,
; NULL);
; }
;
; return;
;}
;
;#endif
;
;
;NTKERNELAPI
;VOID
;NTAPI
;ProbeForRead(
; IN CONST VOID *Address,
; IN ULONG Length,
; IN ULONG Alignment
; );
;
;//
;// Common probe for write functions.
;//
;
;NTKERNELAPI
;VOID
;NTAPI
;ProbeForWrite (
; IN PVOID Address,
; IN ULONG Length,
; IN ULONG Alignment
; );
;
;//
;// Worker Thread
;//
;
;typedef enum _WORK_QUEUE_TYPE {
; CriticalWorkQueue,
; DelayedWorkQueue,
; HyperCriticalWorkQueue,
; MaximumWorkQueue
;} WORK_QUEUE_TYPE;
;
;typedef
;VOID
;(*PWORKER_THREAD_ROUTINE)(
; IN PVOID Parameter
; );
;
;typedef struct _WORK_QUEUE_ITEM {
; LIST_ENTRY List;
; PWORKER_THREAD_ROUTINE WorkerRoutine;
; PVOID Parameter;
;} WORK_QUEUE_ITEM, *PWORK_QUEUE_ITEM;
;
;
;#define ExInitializeWorkItem(Item, Routine, Context) \
; (Item)->WorkerRoutine = (Routine); \
; (Item)->Parameter = (Context); \
; (Item)->List.Flink = NULL;
;
;NTKERNELAPI
;VOID
;ExQueueWorkItem(
; IN PWORK_QUEUE_ITEM WorkItem,
; IN WORK_QUEUE_TYPE QueueType
; );
;
;// end_wdm
;
;NTKERNELAPI
;BOOLEAN
;ExIsProcessorFeaturePresent(
; ULONG ProcessorFeature
; );
;
;//
;// Zone Allocation
;//
;
;typedef struct _ZONE_SEGMENT_HEADER {
; SINGLE_LIST_ENTRY SegmentList;
; PVOID Reserved;
;} ZONE_SEGMENT_HEADER, *PZONE_SEGMENT_HEADER;
;
;typedef struct _ZONE_HEADER {
; SINGLE_LIST_ENTRY FreeList;
; SINGLE_LIST_ENTRY SegmentList;
; ULONG BlockSize;
; ULONG TotalSegmentSize;
;} ZONE_HEADER, *PZONE_HEADER;
;
;
;NTKERNELAPI
;NTSTATUS
;ExInitializeZone(
; IN PZONE_HEADER Zone,
; IN ULONG BlockSize,
; IN PVOID InitialSegment,
; IN ULONG InitialSegmentSize
; );
;
;NTKERNELAPI
;NTSTATUS
;ExExtendZone(
; IN PZONE_HEADER Zone,
; IN PVOID Segment,
; IN ULONG SegmentSize
; );
;
;NTKERNELAPI
;NTSTATUS
;ExInterlockedExtendZone(
; IN PZONE_HEADER Zone,
; IN PVOID Segment,
; IN ULONG SegmentSize,
; IN PKSPIN_LOCK Lock
; );
;
;//++
;//
;// PVOID
;// ExAllocateFromZone(
;// IN PZONE_HEADER Zone
;// )
;//
;// Routine Description:
;//
;// This routine removes an entry from the zone and returns a pointer to it.
;//
;// Arguments:
;//
;// Zone - Pointer to the zone header controlling the storage from which the
;// entry is to be allocated.
;//
;// Return Value:
;//
;// The function value is a pointer to the storage allocated from the zone.
;//
;//--
;
;#define ExAllocateFromZone(Zone) \
; (PVOID)((Zone)->FreeList.Next); \
; if ( (Zone)->FreeList.Next ) (Zone)->FreeList.Next = (Zone)->FreeList.Next->Next
;
;
;//++
;//
;// PVOID
;// ExFreeToZone(
;// IN PZONE_HEADER Zone,
;// IN PVOID Block
;// )
;//
;// Routine Description:
;//
;// This routine places the specified block of storage back onto the free
;// list in the specified zone.
;//
;// Arguments:
;//
;// Zone - Pointer to the zone header controlling the storage to which the
;// entry is to be inserted.
;//
;// Block - Pointer to the block of storage to be freed back to the zone.
;//
;// Return Value:
;//
;// Pointer to previous block of storage that was at the head of the free
;// list. NULL implies the zone went from no available free blocks to
;// at least one free block.
;//
;//--
;
;#define ExFreeToZone(Zone,Block) \
; ( ((PSINGLE_LIST_ENTRY)(Block))->Next = (Zone)->FreeList.Next, \
; (Zone)->FreeList.Next = ((PSINGLE_LIST_ENTRY)(Block)), \
; ((PSINGLE_LIST_ENTRY)(Block))->Next \
; )
;
;//++
;//
;// BOOLEAN
;// ExIsFullZone(
;// IN PZONE_HEADER Zone
;// )
;//
;// Routine Description:
;//
;// This routine determines if the specified zone is full or not. A zone
;// is considered full if the free list is empty.
;//
;// Arguments:
;//
;// Zone - Pointer to the zone header to be tested.
;//
;// Return Value:
;//
;// TRUE if the zone is full and FALSE otherwise.
;//
;//--
;
;#define ExIsFullZone(Zone) \
; ( (Zone)->FreeList.Next == (PSINGLE_LIST_ENTRY)NULL )
;
;//++
;//
;// PVOID
;// ExInterlockedAllocateFromZone(
;// IN PZONE_HEADER Zone,
;// IN PKSPIN_LOCK Lock
;// )
;//
;// Routine Description:
;//
;// This routine removes an entry from the zone and returns a pointer to it.
;// The removal is performed with the specified lock owned for the sequence
;// to make it MP-safe.
;//
;// Arguments:
;//
;// Zone - Pointer to the zone header controlling the storage from which the
;// entry is to be allocated.
;//
;// Lock - Pointer to the spin lock which should be obtained before removing
;// the entry from the allocation list. The lock is released before
;// returning to the caller.
;//
;// Return Value:
;//
;// The function value is a pointer to the storage allocated from the zone.
;//
;//--
;
;#define ExInterlockedAllocateFromZone(Zone,Lock) \
; (PVOID) ExInterlockedPopEntryList( &(Zone)->FreeList, Lock )
;
;//++
;//
;// PVOID
;// ExInterlockedFreeToZone(
;// IN PZONE_HEADER Zone,
;// IN PVOID Block,
;// IN PKSPIN_LOCK Lock
;// )
;//
;// Routine Description:
;//
;// This routine places the specified block of storage back onto the free
;// list in the specified zone. The insertion is performed with the lock
;// owned for the sequence to make it MP-safe.
;//
;// Arguments:
;//
;// Zone - Pointer to the zone header controlling the storage to which the
;// entry is to be inserted.
;//
;// Block - Pointer to the block of storage to be freed back to the zone.
;//
;// Lock - Pointer to the spin lock which should be obtained before inserting
;// the entry onto the free list. The lock is released before returning
;// to the caller.
;//
;// Return Value:
;//
;// Pointer to previous block of storage that was at the head of the free
;// list. NULL implies the zone went from no available free blocks to
;// at least one free block.
;//
;//--
;
;#define ExInterlockedFreeToZone(Zone,Block,Lock) \
; ExInterlockedPushEntryList( &(Zone)->FreeList, ((PSINGLE_LIST_ENTRY) (Block)), Lock )
;
;
;//++
;//
;// BOOLEAN
;// ExIsObjectInFirstZoneSegment(
;// IN PZONE_HEADER Zone,
;// IN PVOID Object
;// )
;//
;// Routine Description:
;//
;// This routine determines if the specified pointer lives in the zone.
;//
;// Arguments:
;//
;// Zone - Pointer to the zone header controlling the storage to which the
;// object may belong.
;//
;// Object - Pointer to the object in question.
;//
;// Return Value:
;//
;// TRUE if the Object came from the first segment of zone.
;//
;//--
;
;#define ExIsObjectInFirstZoneSegment(Zone,Object) ((BOOLEAN) \
; (((PUCHAR)(Object) >= (PUCHAR)(Zone)->SegmentList.Next) && \
; ((PUCHAR)(Object) < (PUCHAR)(Zone)->SegmentList.Next + \
; (Zone)->TotalSegmentSize)) \
;)
;
;//
;// Define executive resource data structures.
;//
;
;typedef ULONG_PTR ERESOURCE_THREAD;
;typedef ERESOURCE_THREAD *PERESOURCE_THREAD;
;
;typedef struct _OWNER_ENTRY {
; ERESOURCE_THREAD OwnerThread;
; union {
; LONG OwnerCount;
; ULONG TableSize;
; };
;
;} OWNER_ENTRY, *POWNER_ENTRY;
;
;typedef struct _ERESOURCE {
; LIST_ENTRY SystemResourcesList;
; POWNER_ENTRY OwnerTable;
; SHORT ActiveCount;
; USHORT Flag;
; PKSEMAPHORE SharedWaiters;
; PKEVENT ExclusiveWaiters;
; OWNER_ENTRY OwnerThreads[2];
; ULONG ContentionCount;
; USHORT NumberOfSharedWaiters;
; USHORT NumberOfExclusiveWaiters;
; union {
; PVOID Address;
; ULONG_PTR CreatorBackTraceIndex;
; };
;
; KSPIN_LOCK SpinLock;
;} ERESOURCE, *PERESOURCE;
;
;//
;// Values for ERESOURCE.Flag
;//
;
;#define ResourceNeverExclusive 0x10
;#define ResourceReleaseByOtherThread 0x20
;#define ResourceOwnedExclusive 0x80
;
;#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.
;//
;
;NTKERNELAPI
;NTSTATUS
;ExInitializeResourceLite(
; IN PERESOURCE Resource
; );
;
;NTKERNELAPI
;NTSTATUS
;ExReinitializeResourceLite(
; IN PERESOURCE Resource
; );
;
;NTKERNELAPI
;BOOLEAN
;ExAcquireResourceSharedLite(
; IN PERESOURCE Resource,
; IN BOOLEAN Wait
; );
;
;NTKERNELAPI
;BOOLEAN
;ExAcquireResourceExclusiveLite(
; IN PERESOURCE Resource,
; IN BOOLEAN Wait
; );
;
;NTKERNELAPI
;BOOLEAN
;ExAcquireSharedStarveExclusive(
; IN PERESOURCE Resource,
; IN BOOLEAN Wait
; );
;
;NTKERNELAPI
;BOOLEAN
;ExAcquireSharedWaitForExclusive(
; IN PERESOURCE Resource,
; IN BOOLEAN Wait
; );
;
;NTKERNELAPI
;BOOLEAN
;ExTryToAcquireResourceExclusiveLite(
; IN PERESOURCE Resource
; );
;
;//
;// VOID
;// ExReleaseResource(
;// IN PERESOURCE Resource
;// );
;//
;
;#define ExReleaseResource(R) (ExReleaseResourceLite(R))
;
;NTKERNELAPI
;VOID
;FASTCALL
;ExReleaseResourceLite(
; IN PERESOURCE Resource
; );
;
;NTKERNELAPI
;VOID
;ExReleaseResourceForThreadLite(
; IN PERESOURCE Resource,
; IN ERESOURCE_THREAD ResourceThreadId
; );
;
;NTKERNELAPI
;VOID
;ExSetResourceOwnerPointer(
; IN PERESOURCE Resource,
; IN PVOID OwnerPointer
; );
;
;NTKERNELAPI
;VOID
;ExConvertExclusiveToSharedLite(
; IN PERESOURCE Resource
; );
;
;NTKERNELAPI
;NTSTATUS
;ExDeleteResourceLite (
; IN PERESOURCE Resource
; );
;
;NTKERNELAPI
;ULONG
;ExGetExclusiveWaiterCount (
; IN PERESOURCE Resource
; );
;
;NTKERNELAPI
;ULONG
;ExGetSharedWaiterCount (
; IN PERESOURCE Resource
; );
;
;//
;// ERESOURCE_THREAD
;// ExGetCurrentResourceThread(
;// );
;//
;
;#define ExGetCurrentResourceThread() ((ULONG_PTR)PsGetCurrentThread())
;
;NTKERNELAPI
;BOOLEAN
;ExIsResourceAcquiredExclusiveLite (
; IN PERESOURCE Resource
; );
;
;NTKERNELAPI
;ULONG
;ExIsResourceAcquiredSharedLite (
; IN PERESOURCE Resource
; );
;
;//
;// ntddk.h stole the entrypoints we wanted so fix them up here.
;//
;
;#define ExInitializeResource ExInitializeResourceLite
;#define ExAcquireResourceShared ExAcquireResourceSharedLite
;#define ExAcquireResourceExclusive ExAcquireResourceExclusiveLite
;#define ExReleaseResourceForThread ExReleaseResourceForThreadLite
;#define ExConvertExclusiveToShared ExConvertExclusiveToSharedLite
;#define ExDeleteResource ExDeleteResourceLite
;#define ExIsResourceAcquiredExclusive ExIsResourceAcquiredExclusiveLite
;#define ExIsResourceAcquiredShared ExIsResourceAcquiredSharedLite
;
;
;//
;// Get previous mode
;//
;
;NTKERNELAPI
;KPROCESSOR_MODE
;ExGetPreviousMode(
; VOID
; );
;//
;// Raise status from kernel mode.
;//
;
;NTKERNELAPI
;VOID
;NTAPI
;ExRaiseStatus (
; IN NTSTATUS Status
; );
;
;// end_wdm
;
;NTKERNELAPI
;VOID
;ExRaiseDatatypeMisalignment (
; VOID
; );
;
;NTKERNELAPI
;VOID
;ExRaiseAccessViolation (
; VOID
; );
;
;//
;// Set timer resolution.
;//
;
;NTKERNELAPI
;ULONG
;ExSetTimerResolution (
; IN ULONG DesiredTime,
; IN BOOLEAN SetResolution
; );
;
;// end_wdm
;//
;// Subtract time zone bias from system time to get local time.
;//
;
;NTKERNELAPI
;VOID
;ExSystemTimeToLocalTime (
; IN PLARGE_INTEGER SystemTime,
; OUT PLARGE_INTEGER LocalTime
; );
;
;//
;// Add time zone bias to local time to get system time.
;//
;
;NTKERNELAPI
;VOID
;ExLocalTimeToSystemTime (
; IN PLARGE_INTEGER LocalTime,
; OUT PLARGE_INTEGER SystemTime
; );
;
;
;//
;// Define the type for Callback function.
;//
;
;typedef struct _CALLBACK_OBJECT *PCALLBACK_OBJECT;
;
;typedef VOID (*PCALLBACK_FUNCTION ) (
; IN PVOID CallbackContext,
; IN PVOID Argument1,
; IN PVOID Argument2
; );
;
;
;NTKERNELAPI
;NTSTATUS
;ExCreateCallback (
; OUT PCALLBACK_OBJECT *CallbackObject,
; IN POBJECT_ATTRIBUTES ObjectAttributes,
; IN BOOLEAN Create,
; IN BOOLEAN AllowMultipleCallbacks
; );
;
;NTKERNELAPI
;PVOID
;ExRegisterCallback (
; IN PCALLBACK_OBJECT CallbackObject,
; IN PCALLBACK_FUNCTION CallbackFunction,
; IN PVOID CallbackContext
; );
;
;NTKERNELAPI
;VOID
;ExUnregisterCallback (
; IN PVOID CallbackRegistration
; );
;
;NTKERNELAPI
;VOID
;ExNotifyCallback (
; IN PVOID CallbackObject,
; IN PVOID Argument1,
; IN PVOID Argument2
; );
;
;
;//
;// UUID Generation
;//
;
;typedef GUID UUID;
;
;NTKERNELAPI
;NTSTATUS
;ExUuidCreate(
; OUT UUID *Uuid
; );
;
;//
;// 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
;
;// end_ntifs
;//
;// Priority increment for completing keyboard I/O. This is used by keyboard
;// device drivers when completing an IRP (IoCompleteRequest)
;//
;
;#define IO_KEYBOARD_INCREMENT 6
;
;// begin_ntifs
;//
;// 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
;
;// end_ntifs
;//
;// Priority increment for completing mouse I/O. This is used by mouse device
;// drivers when completing an IRP (IoCompleteRequest)
;//
;
;#define IO_MOUSE_INCREMENT 6
;
;// begin_ntifs
;//
;// 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
;
;// end_ntifs
;//
;// 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;
;
;
;//
;// Define maximum disk transfer size to be used by MM and Cache Manager,
;// so that packet-oriented disk drivers can optimize their packet allocation
;// to this size.
;//
;
;#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) ((ULONG)((ULONG_PTR)(Size) >> PAGE_SHIFT) + \
; (((ULONG)(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)))
;
;//++
;//
;// ULONG
;// ADDRESS_AND_SIZE_TO_SPAN_PAGES (
;// IN PVOID Va,
;// IN ULONG 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) \
; (((((Size) - 1) >> PAGE_SHIFT) + \
; (((((ULONG)(Size-1)&(PAGE_SIZE-1)) + (PtrToUlong(Va) & (PAGE_SIZE -1)))) >> PAGE_SHIFT)) + 1L)
;
;#define COMPUTE_PAGES_SPANNED(Va, Size) \
; ((ULONG)((((ULONG_PTR)(Va) & (PAGE_SIZE -1)) + (Size) + (PAGE_SIZE - 1)) >> PAGE_SHIFT))
;
;
;//++
;// 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;
;
;NTKERNELAPI
;MM_SYSTEMSIZE
;MmQuerySystemSize(
; VOID
; );
;
;// end_wdm
;
;NTKERNELAPI
;BOOLEAN
;MmIsThisAnNtAsSystem(
; VOID
; );
;
;// begin_wdm
;
;typedef enum _LOCK_OPERATION {
; IoReadAccess,
; IoWriteAccess,
; IoModifyAccess
;} LOCK_OPERATION;
;
;
;NTKERNELAPI
;VOID
;MmProbeAndLockProcessPages (
; IN OUT PMDL MemoryDescriptorList,
; IN PEPROCESS Process,
; IN KPROCESSOR_MODE AccessMode,
; IN LOCK_OPERATION Operation
; );
;
;
;// begin_nthal
;//
;// I/O support routines.
;//
;
;NTKERNELAPI
;VOID
;MmProbeAndLockPages (
; IN OUT PMDL MemoryDescriptorList,
; IN KPROCESSOR_MODE AccessMode,
; IN LOCK_OPERATION Operation
; );
;
;
;NTKERNELAPI
;VOID
;MmUnlockPages (
; IN PMDL MemoryDescriptorList
; );
;
;NTKERNELAPI
;VOID
;MmBuildMdlForNonPagedPool (
; IN OUT PMDL MemoryDescriptorList
; );
;
;NTKERNELAPI
;PVOID
;MmMapLockedPages (
; IN PMDL MemoryDescriptorList,
; IN KPROCESSOR_MODE AccessMode
; );
;
;NTKERNELAPI
;PVOID
;MmGetSystemRoutineAddress (
; IN PUNICODE_STRING SystemRoutineName
; );
;
;// end_wdm
;
;NTKERNELAPI
;NTSTATUS
;MmMapUserAddressesToPage (
; IN PVOID BaseAddress,
; IN SIZE_T NumberOfBytes,
; IN PVOID PageAddress
; );
;
;// begin_wdm
;
;//
;// _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;
;
;//
;// Note: This function is not available in WDM 1.0
;//
;NTKERNELAPI
;PVOID
;MmMapLockedPagesSpecifyCache (
; IN PMDL MemoryDescriptorList,
; IN KPROCESSOR_MODE AccessMode,
; IN MEMORY_CACHING_TYPE CacheType,
; IN PVOID BaseAddress,
; IN ULONG BugCheckOnFailure,
; IN MM_PAGE_PRIORITY Priority
; );
;
;NTKERNELAPI
;VOID
;MmUnmapLockedPages (
; IN PVOID BaseAddress,
; IN PMDL MemoryDescriptorList
; );
;
;// end_wdm
;
;typedef struct _PHYSICAL_MEMORY_RANGE {
; PHYSICAL_ADDRESS BaseAddress;
; LARGE_INTEGER NumberOfBytes;
;} PHYSICAL_MEMORY_RANGE, *PPHYSICAL_MEMORY_RANGE;
;
;NTKERNELAPI
;NTSTATUS
;MmAddPhysicalMemory (
; IN PPHYSICAL_ADDRESS StartAddress,
; IN OUT PLARGE_INTEGER NumberOfBytes
; );
;
;NTKERNELAPI
;NTSTATUS
;MmRemovePhysicalMemory (
; IN PPHYSICAL_ADDRESS StartAddress,
; IN OUT PLARGE_INTEGER NumberOfBytes
; );
;
;NTKERNELAPI
;PPHYSICAL_MEMORY_RANGE
;MmGetPhysicalMemoryRanges (
; VOID
; );
;
;NTKERNELAPI
;PMDL
;MmAllocatePagesForMdl (
; IN PHYSICAL_ADDRESS LowAddress,
; IN PHYSICAL_ADDRESS HighAddress,
; IN PHYSICAL_ADDRESS SkipBytes,
; IN SIZE_T TotalBytes
; );
;
;NTKERNELAPI
;VOID
;MmFreePagesFromMdl (
; IN PMDL MemoryDescriptorList
; );
;
;// begin_wdm
;
;NTKERNELAPI
;PVOID
;MmMapIoSpace (
; IN PHYSICAL_ADDRESS PhysicalAddress,
; IN SIZE_T NumberOfBytes,
; IN MEMORY_CACHING_TYPE CacheType
; );
;
;NTKERNELAPI
;VOID
;MmUnmapIoSpace (
; IN PVOID BaseAddress,
; IN SIZE_T NumberOfBytes
; );
;
;
;NTKERNELAPI
;PVOID
;MmMapVideoDisplay (
; IN PHYSICAL_ADDRESS PhysicalAddress,
; IN SIZE_T NumberOfBytes,
; IN MEMORY_CACHING_TYPE CacheType
; );
;
;NTKERNELAPI
;VOID
;MmUnmapVideoDisplay (
; IN PVOID BaseAddress,
; IN SIZE_T NumberOfBytes
; );
;
;NTKERNELAPI
;PHYSICAL_ADDRESS
;MmGetPhysicalAddress (
; IN PVOID BaseAddress
; );
;
;NTKERNELAPI
;PVOID
;MmGetVirtualForPhysical (
; IN PHYSICAL_ADDRESS PhysicalAddress
; );
;
;NTKERNELAPI
;PVOID
;MmAllocateContiguousMemory (
; IN SIZE_T NumberOfBytes,
; IN PHYSICAL_ADDRESS HighestAcceptableAddress
; );
;
;NTKERNELAPI
;PVOID
;MmAllocateContiguousMemorySpecifyCache (
; IN SIZE_T NumberOfBytes,
; IN PHYSICAL_ADDRESS LowestAcceptableAddress,
; IN PHYSICAL_ADDRESS HighestAcceptableAddress,
; IN PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL,
; IN MEMORY_CACHING_TYPE CacheType
; );
;
;NTKERNELAPI
;VOID
;MmFreeContiguousMemory (
; IN PVOID BaseAddress
; );
;
;NTKERNELAPI
;VOID
;MmFreeContiguousMemorySpecifyCache (
; IN PVOID BaseAddress,
; IN SIZE_T NumberOfBytes,
; IN MEMORY_CACHING_TYPE CacheType
; );
;
;
;NTKERNELAPI
;PVOID
;MmAllocateNonCachedMemory (
; IN SIZE_T NumberOfBytes
; );
;
;NTKERNELAPI
;VOID
;MmFreeNonCachedMemory (
; IN PVOID BaseAddress,
; IN SIZE_T NumberOfBytes
; );
;
;NTKERNELAPI
;BOOLEAN
;MmIsAddressValid (
; IN PVOID VirtualAddress
; );
;
;NTKERNELAPI
;BOOLEAN
;MmIsNonPagedSystemAddressValid (
; IN PVOID VirtualAddress
; );
;
;// begin_wdm
;
;NTKERNELAPI
;SIZE_T
;MmSizeOfMdl(
; IN PVOID Base,
; IN SIZE_T Length
; );
;
;NTKERNELAPI
;PMDL
;MmCreateMdl(
; IN PMDL MemoryDescriptorList OPTIONAL,
; IN PVOID Base,
; IN SIZE_T Length
; );
;
;NTKERNELAPI
;PVOID
;MmLockPagableDataSection(
; IN PVOID AddressWithinSection
; );
;
;// end_wdm
;
;NTKERNELAPI
;VOID
;MmLockPagableSectionByHandle (
; IN PVOID ImageSectionHandle
; );
;
;NTKERNELAPI
;VOID
;MmResetDriverPaging (
; IN PVOID AddressWithinSection
; );
;
;
;NTKERNELAPI
;PVOID
;MmPageEntireDriver (
; IN PVOID AddressWithinSection
; );
;
;NTKERNELAPI
;VOID
;MmUnlockPagableImageSection(
; IN PVOID ImageSectionHandle
; );
;
;// end_wdm
;
;NTKERNELAPI
;HANDLE
;MmSecureVirtualMemory (
; IN PVOID Address,
; IN SIZE_T Size,
; IN ULONG ProbeMode
; );
;
;NTKERNELAPI
;VOID
;MmUnsecureVirtualMemory (
; IN HANDLE SecureHandle
; );
;
;NTKERNELAPI
;NTSTATUS
;MmMapViewInSystemSpace (
; IN PVOID Section,
; OUT PVOID *MappedBase,
; IN PSIZE_T ViewSize
; );
;
;NTKERNELAPI
;NTSTATUS
;MmUnmapViewInSystemSpace (
; IN PVOID MappedBase
; );
;
;NTKERNELAPI
;NTSTATUS
;MmMapViewInSessionSpace (
; IN PVOID Section,
; OUT PVOID *MappedBase,
; IN OUT PSIZE_T ViewSize
; );
;
;NTKERNELAPI
;NTSTATUS
;MmUnmapViewInSessionSpace (
; IN PVOID MappedBase
; );
;
;// begin_wdm
;
;//++
;//
;// VOID
;// MmInitializeMdl (
;// IN PMDL MemoryDescriptorList,
;// IN 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.
;//
;//--
;
;#define MmInitializeMdl(MemoryDescriptorList, BaseVa, Length) { \
; (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); \
; }
;
;//++
;//
;// PVOID
;// MmGetSystemAddressForMdlSafe (
;// IN PMDL MDL,
;// IN MM_PAGE_PRIORITY PRIORITY
;// )
;//
;// 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 macro 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.
;//
;//--
;
;#define MmGetSystemAddressForMdlSafe(MDL, PRIORITY) \
; (((MDL)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | \
; MDL_SOURCE_IS_NONPAGED_POOL)) ? \
; ((MDL)->MappedSystemVa) : \
; (MmMapLockedPagesSpecifyCache((MDL), \
; KernelMode, \
; MmCached, \
; NULL, \
; FALSE, \
; (PRIORITY))))
;
;//++
;//
;// 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)))))
;
;#define MmGetSystemAddressForMdl(MDL) \
; (((MDL)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | \
; MDL_SOURCE_IS_NONPAGED_POOL)) ? \
; ((MDL)->MappedSystemVa) : \
; (MmMapLockedPages((MDL),KernelMode)))
;
;//++
;//
;// VOID
;// MmPrepareMdlForReuse (
;// IN 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.
;//
;//--
;
;#define MmPrepareMdlForReuse(MDL) \
; if (((MDL)->MdlFlags & MDL_PARTIAL_HAS_BEEN_MAPPED) != 0) { \
; ASSERT(((MDL)->MdlFlags & MDL_PARTIAL) != 0); \
; MmUnmapLockedPages( (MDL)->MappedSystemVa, (MDL) ); \
; } else if (((MDL)->MdlFlags & MDL_PARTIAL) == 0) { \
; 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;
;
;NTKERNELAPI
;LOGICAL
;MmIsDriverVerifying (
; IN struct _DRIVER_OBJECT *DriverObject
; );
;
;//
;// 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 imbedded 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;
; 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;
; PVOID AuxData;
; union {
; INITIAL_PRIVILEGE_SET InitialPrivilegeSet;
; PRIVILEGE_SET PrivilegeSet;
; } Privileges;
;
; BOOLEAN AuditPrivileges;
; UNICODE_STRING ObjectName;
; UNICODE_STRING ObjectTypeName;
;
; } ACCESS_STATE, *PACCESS_STATE;
;
;
;NTKERNELAPI
;NTSTATUS
;SeAssignSecurity (
; IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
; IN PSECURITY_DESCRIPTOR ExplicitDescriptor,
; OUT PSECURITY_DESCRIPTOR *NewDescriptor,
; IN BOOLEAN IsDirectoryObject,
; IN PSECURITY_SUBJECT_CONTEXT SubjectContext,
; IN PGENERIC_MAPPING GenericMapping,
; IN POOL_TYPE PoolType
; );
;
;NTKERNELAPI
;NTSTATUS
;SeAssignSecurityEx (
; IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
; IN PSECURITY_DESCRIPTOR ExplicitDescriptor OPTIONAL,
; OUT PSECURITY_DESCRIPTOR *NewDescriptor,
; IN GUID *ObjectType OPTIONAL,
; IN BOOLEAN IsDirectoryObject,
; IN ULONG AutoInheritFlags,
; IN PSECURITY_SUBJECT_CONTEXT SubjectContext,
; IN PGENERIC_MAPPING GenericMapping,
; IN POOL_TYPE PoolType
; );
;
;NTKERNELAPI
;NTSTATUS
;SeDeassignSecurity (
; IN OUT PSECURITY_DESCRIPTOR *SecurityDescriptor
; );
;
;NTKERNELAPI
;BOOLEAN
;SeAccessCheck (
; IN PSECURITY_DESCRIPTOR SecurityDescriptor,
; IN PSECURITY_SUBJECT_CONTEXT SubjectSecurityContext,
; IN BOOLEAN SubjectContextLocked,
; IN ACCESS_MASK DesiredAccess,
; IN ACCESS_MASK PreviouslyGrantedAccess,
; OUT PPRIVILEGE_SET *Privileges OPTIONAL,
; IN PGENERIC_MAPPING GenericMapping,
; IN KPROCESSOR_MODE AccessMode,
; OUT PACCESS_MASK GrantedAccess,
; OUT PNTSTATUS AccessStatus
; );
;
;
;NTKERNELAPI
;BOOLEAN
;SeValidSecurityDescriptor(
; IN ULONG Length,
; IN PSECURITY_DESCRIPTOR SecurityDescriptor
; );
;
;NTKERNELAPI
;BOOLEAN
;SeSinglePrivilegeCheck(
; LUID PrivilegeValue,
; KPROCESSOR_MODE PreviousMode
; );
;//
;// System Thread and Process Creation and Termination
;//
;
;NTKERNELAPI
;NTSTATUS
;PsCreateSystemThread(
; OUT PHANDLE ThreadHandle,
; IN ULONG DesiredAccess,
; IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
; IN HANDLE ProcessHandle OPTIONAL,
; OUT PCLIENT_ID ClientId OPTIONAL,
; IN PKSTART_ROUTINE StartRoutine,
; IN PVOID StartContext
; );
;
;NTKERNELAPI
;NTSTATUS
;PsTerminateSystemThread(
; IN NTSTATUS ExitStatus
; );
;
;
;typedef
;VOID
;(*PCREATE_PROCESS_NOTIFY_ROUTINE)(
; IN HANDLE ParentId,
; IN HANDLE ProcessId,
; IN BOOLEAN Create
; );
;
;NTSTATUS
;PsSetCreateProcessNotifyRoutine(
; IN PCREATE_PROCESS_NOTIFY_ROUTINE NotifyRoutine,
; IN BOOLEAN Remove
; );
;
;typedef
;VOID
;(*PCREATE_THREAD_NOTIFY_ROUTINE)(
; IN HANDLE ProcessId,
; IN HANDLE ThreadId,
; IN BOOLEAN Create
; );
;
;NTSTATUS
;PsSetCreateThreadNotifyRoutine(
; IN PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
; );
;
;//
;// Structures for Load Image Notify
;//
;
;typedef struct _IMAGE_INFO {
; union {
; ULONG Properties;
; struct {
; ULONG ImageAddressingMode : 8; // code addressing mode
; ULONG SystemModeImage : 1; // system mode image
; ULONG ImageMappedToAllPids : 1; // image mapped into all processes
; ULONG Reserved : 22;
; };
; };
; PVOID ImageBase;
; ULONG ImageSelector;
; SIZE_T ImageSize;
; ULONG ImageSectionNumber;
;} IMAGE_INFO, *PIMAGE_INFO;
;
;#define IMAGE_ADDRESSING_MODE_32BIT 3
;
;typedef
;VOID
;(*PLOAD_IMAGE_NOTIFY_ROUTINE)(
; IN PUNICODE_STRING FullImageName,
; IN HANDLE ProcessId, // pid into which image is being mapped
; IN PIMAGE_INFO ImageInfo
; );
;
;NTSTATUS
;PsSetLoadImageNotifyRoutine(
; IN PLOAD_IMAGE_NOTIFY_ROUTINE NotifyRoutine
; );
;
;HANDLE
;PsGetCurrentProcessId( VOID );
;
;HANDLE
;PsGetCurrentThreadId( VOID );
;
;BOOLEAN
;PsGetVersion(
; PULONG MajorVersion OPTIONAL,
; PULONG MinorVersion OPTIONAL,
; PULONG BuildNumber OPTIONAL,
; PUNICODE_STRING CSDVersion OPTIONAL
; );
;
;//
;// 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.
;//
;
;// end_wdm end_ntndis
;//
;// Directory control minor function codes
;//
;
;#define IRP_MN_QUERY_DIRECTORY 0x01
;#define IRP_MN_NOTIFY_CHANGE_DIRECTORY 0x02
;
;//
;// File system control minor function codes. Note that "user request" is
;// assumed to be zero by both the I/O system and file systems. Do not change
;// this value.
;//
;
;#define IRP_MN_USER_FS_REQUEST 0x00
;#define IRP_MN_MOUNT_VOLUME 0x01
;#define IRP_MN_VERIFY_VOLUME 0x02
;#define IRP_MN_LOAD_FILE_SYSTEM 0x03
;#define IRP_MN_TRACK_LINK 0x04 // To be obsoleted soon
;#define IRP_MN_KERNEL_CALL 0x04
;
;//
;// Lock control minor function codes
;//
;
;#define IRP_MN_LOCK 0x01
;#define IRP_MN_UNLOCK_SINGLE 0x02
;#define IRP_MN_UNLOCK_ALL 0x03
;#define IRP_MN_UNLOCK_ALL_BY_KEY 0x04
;
;//
;// Read and Write minor function codes for file systems supporting Lan Manager
;// software. All of these subfunction codes are invalid if the file has been
;// opened with FO_NO_INTERMEDIATE_BUFFERING. They are also invalid in combi-
;// nation with synchronous calls (Irp Flag or file open option).
;//
;// Note that "normal" is assumed to be zero by both the I/O system and file
;// systems. Do not change this value.
;//
;
;#define IRP_MN_NORMAL 0x00
;#define IRP_MN_DPC 0x01
;#define IRP_MN_MDL 0x02
;#define IRP_MN_COMPLETE 0x04
;#define IRP_MN_COMPRESSED 0x08
;
;#define IRP_MN_MDL_DPC (IRP_MN_MDL | IRP_MN_DPC)
;#define IRP_MN_COMPLETE_MDL (IRP_MN_COMPLETE | IRP_MN_MDL)
;#define IRP_MN_COMPLETE_MDL_DPC (IRP_MN_COMPLETE_MDL | IRP_MN_DPC)
;
;// begin_wdm
;//
;// 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
;// end_wdm
;#define IRP_MN_QUERY_LEGACY_BUS_INFORMATION 0x18
;// begin_wdm
;
;//
;// 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
;
;// begin_ntminiport
;//
;// 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
;
;// end_ntminiport
;
;//
;// 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_OPEN_PAGING_FILE 0x0002
;#define IO_OPEN_TARGET_DIRECTORY 0x0004
;#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 callout routine type for use in IoQueryDeviceDescription().
;//
;
;typedef NTSTATUS (*PIO_QUERY_DEVICE_ROUTINE)(
; IN PVOID Context,
; IN PUNICODE_STRING PathName,
; IN INTERFACE_TYPE BusType,
; IN ULONG BusNumber,
; IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
; IN CONFIGURATION_TYPE ControllerType,
; IN ULONG ControllerNumber,
; IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
; IN CONFIGURATION_TYPE PeripheralType,
; IN ULONG PeripheralNumber,
; IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
; );
;
;//
;// Defines the order of the information in the array of
;// PKEY_VALUE_FULL_INFORMATION.
;//
;
;typedef enum _IO_QUERY_DEVICE_DATA_FORMAT {
; IoQueryDeviceIdentifier = 0,
; IoQueryDeviceConfigurationData,
; IoQueryDeviceComponentInformation,
; IoQueryDeviceMaxData
;} IO_QUERY_DEVICE_DATA_FORMAT, *PIO_QUERY_DEVICE_DATA_FORMAT;
;
;// begin_wdm begin_ntifs
;//
;// Define the objects that can be created by IoCreateFile.
;//
;
;typedef enum _CREATE_FILE_TYPE {
; CreateFileTypeNone,
; CreateFileTypeNamedPipe,
; CreateFileTypeMailslot
;} CREATE_FILE_TYPE;
;
;//
;// 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;
;struct _IRP;
;struct _SCSI_REQUEST_BLOCK;
;
;//
;// Define the I/O version of a DPC routine.
;//
;
;typedef
;VOID
;(*PIO_DPC_ROUTINE) (
; IN PKDPC Dpc,
; IN struct _DEVICE_OBJECT *DeviceObject,
; IN struct _IRP *Irp,
; IN PVOID Context
; );
;
;//
;// Define driver timer routine type.
;//
;
;typedef
;VOID
;(*PIO_TIMER_ROUTINE) (
; IN struct _DEVICE_OBJECT *DeviceObject,
; IN PVOID Context
; );
;
;//
;// Define driver initialization routine type.
;//
;
;typedef
;NTSTATUS
;(*PDRIVER_INITIALIZE) (
; IN struct _DRIVER_OBJECT *DriverObject,
; IN PUNICODE_STRING RegistryPath
; );
;
;// end_wdm
;//
;// Define driver reinitialization routine type.
;//
;
;typedef
;VOID
;(*PDRIVER_REINITIALIZE) (
; IN struct _DRIVER_OBJECT *DriverObject,
; IN PVOID Context,
; IN ULONG Count
; );
;
;// begin_wdm begin_ntndis
;//
;// Define driver cancel routine type.
;//
;
;typedef
;VOID
;(*PDRIVER_CANCEL) (
; IN struct _DEVICE_OBJECT *DeviceObject,
; IN struct _IRP *Irp
; );
;
;//
;// Define driver dispatch routine type.
;//
;
;typedef
;NTSTATUS
;(*PDRIVER_DISPATCH) (
; IN struct _DEVICE_OBJECT *DeviceObject,
; IN struct _IRP *Irp
; );
;
;//
;// Define driver start I/O routine type.
;//
;
;typedef
;VOID
;(*PDRIVER_STARTIO) (
; IN struct _DEVICE_OBJECT *DeviceObject,
; IN struct _IRP *Irp
; );
;
;//
;// Define driver unload routine type.
;//
;
;typedef
;VOID
;(*PDRIVER_UNLOAD) (
; IN struct _DRIVER_OBJECT *DriverObject
; );
;
;//
;// Define driver AddDevice routine type.
;//
;
;typedef
;NTSTATUS
;(*PDRIVER_ADD_DEVICE) (
; IN struct _DRIVER_OBJECT *DriverObject,
; IN struct _DEVICE_OBJECT *PhysicalDeviceObject
; );
;
;
;//
;// Define fast I/O procedure prototypes.
;//
;// Fast I/O read and write procedures.
;//
;
;typedef
;BOOLEAN
;(*PFAST_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,
; OUT PIO_STATUS_BLOCK IoStatus,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_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
;BOOLEAN
;(*PFAST_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
; );
;
;//
;// Fast I/O query basic and standard information procedures.
;//
;
;typedef
;BOOLEAN
;(*PFAST_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
;BOOLEAN
;(*PFAST_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
; );
;
;//
;// Fast I/O lock and unlock procedures.
;//
;
;typedef
;BOOLEAN
;(*PFAST_IO_LOCK) (
; IN struct _FILE_OBJECT *FileObject,
; IN PLARGE_INTEGER FileOffset,
; IN PLARGE_INTEGER Length,
; PEPROCESS ProcessId,
; ULONG Key,
; BOOLEAN FailImmediately,
; BOOLEAN ExclusiveLock,
; OUT PIO_STATUS_BLOCK IoStatus,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_IO_UNLOCK_SINGLE) (
; IN struct _FILE_OBJECT *FileObject,
; IN PLARGE_INTEGER FileOffset,
; IN PLARGE_INTEGER Length,
; PEPROCESS ProcessId,
; ULONG Key,
; OUT PIO_STATUS_BLOCK IoStatus,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_IO_UNLOCK_ALL) (
; IN struct _FILE_OBJECT *FileObject,
; PEPROCESS ProcessId,
; OUT PIO_STATUS_BLOCK IoStatus,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_IO_UNLOCK_ALL_BY_KEY) (
; IN struct _FILE_OBJECT *FileObject,
; PVOID ProcessId,
; ULONG Key,
; OUT PIO_STATUS_BLOCK IoStatus,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;//
;// Fast I/O device control procedure.
;//
;
;typedef
;BOOLEAN
;(*PFAST_IO_DEVICE_CONTROL) (
; IN struct _FILE_OBJECT *FileObject,
; IN BOOLEAN Wait,
; IN PVOID InputBuffer OPTIONAL,
; IN ULONG InputBufferLength,
; OUT PVOID OutputBuffer OPTIONAL,
; IN ULONG OutputBufferLength,
; IN ULONG IoControlCode,
; OUT PIO_STATUS_BLOCK IoStatus,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;//
;// 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.
;//
;
;typedef
;VOID
;(*PFAST_IO_ACQUIRE_FILE) (
; IN struct _FILE_OBJECT *FileObject
; );
;
;typedef
;VOID
;(*PFAST_IO_RELEASE_FILE) (
; IN struct _FILE_OBJECT *FileObject
; );
;
;//
;// 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.
;//
;
;typedef
;VOID
;(*PFAST_IO_DETACH_DEVICE) (
; IN struct _DEVICE_OBJECT *SourceDevice,
; IN struct _DEVICE_OBJECT *TargetDevice
; );
;
;//
;// 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.
;//
;
;typedef
;BOOLEAN
;(*PFAST_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
; );
;
;//
;// Define Mdl-based routines for the server to call
;//
;
;typedef
;BOOLEAN
;(*PFAST_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
;BOOLEAN
;(*PFAST_IO_MDL_READ_COMPLETE) (
; IN struct _FILE_OBJECT *FileObject,
; IN PMDL MdlChain,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_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
;BOOLEAN
;(*PFAST_IO_MDL_WRITE_COMPLETE) (
; IN struct _FILE_OBJECT *FileObject,
; IN PLARGE_INTEGER FileOffset,
; IN PMDL MdlChain,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;//
;// If this routine is present, it will be called by FsRtl
;// to acquire the file for the mapped page writer.
;//
;
;typedef
;NTSTATUS
;(*PFAST_IO_ACQUIRE_FOR_MOD_WRITE) (
; IN struct _FILE_OBJECT *FileObject,
; IN PLARGE_INTEGER EndingOffset,
; OUT struct _ERESOURCE **ResourceToRelease,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;NTSTATUS
;(*PFAST_IO_RELEASE_FOR_MOD_WRITE) (
; IN struct _FILE_OBJECT *FileObject,
; IN struct _ERESOURCE *ResourceToRelease,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;//
;// If this routine is present, it will be called by FsRtl
;// to acquire the file for the mapped page writer.
;//
;
;typedef
;NTSTATUS
;(*PFAST_IO_ACQUIRE_FOR_CCFLUSH) (
; IN struct _FILE_OBJECT *FileObject,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;NTSTATUS
;(*PFAST_IO_RELEASE_FOR_CCFLUSH) (
; IN struct _FILE_OBJECT *FileObject,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_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
;BOOLEAN
;(*PFAST_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
;BOOLEAN
;(*PFAST_IO_MDL_READ_COMPLETE_COMPRESSED) (
; IN struct _FILE_OBJECT *FileObject,
; IN PMDL MdlChain,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_IO_MDL_WRITE_COMPLETE_COMPRESSED) (
; IN struct _FILE_OBJECT *FileObject,
; IN PLARGE_INTEGER FileOffset,
; IN PMDL MdlChain,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;typedef
;BOOLEAN
;(*PFAST_IO_QUERY_OPEN) (
; IN struct _IRP *Irp,
; OUT PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
; IN struct _DEVICE_OBJECT *DeviceObject
; );
;
;//
;// 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
;IO_ALLOCATION_ACTION
;(*PDRIVER_CONTROL) (
; IN struct _DEVICE_OBJECT *DeviceObject,
; IN struct _IRP *Irp,
; IN PVOID MapRegisterBase,
; IN PVOID Context
; );
;
;//
;// 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
;
;
;//
;// 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(_AXP64_)
;
;//
;// 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 // _AXP64_
;
;
;#if defined(USE_DMA_MACROS) && (defined(_NTDDK_) || defined(_NTDRIVER_))
;
;// begin_wdm
;//
;// Define object type specific fields of various objects used by the I/O system
;//
;
;typedef struct _DMA_ADAPTER *PADAPTER_OBJECT;
;
;// end_wdm
;#else
;
;//
;// Define object type specific fields of various objects used by the I/O system
;//
;
;typedef struct _ADAPTER_OBJECT *PADAPTER_OBJECT; // ntndis
;
;#endif // USE_DMA_MACROS && (_NTDDK_ || _NTDRIVER_)
;
;// begin_wdm
;//
;// Define Wait Context Block (WCB)
;//
;
;typedef struct _WAIT_CONTEXT_BLOCK {
; KDEVICE_QUEUE_ENTRY WaitQueueEntry;
; PDRIVER_CONTROL DeviceRoutine;
; PVOID DeviceContext;
; ULONG NumberOfMapRegisters;
; PVOID DeviceObject;
; PVOID CurrentIrp;
; PKDPC BufferChainingDpc;
;} WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
;
;// end_wdm
;
;typedef struct _CONTROLLER_OBJECT {
; CSHORT Type;
; CSHORT Size;
; PVOID ControllerExtension;
; KDEVICE_QUEUE DeviceWaitQueue;
;
; ULONG Spare1;
; LARGE_INTEGER Spare2;
;
;} CONTROLLER_OBJECT, *PCONTROLLER_OBJECT;
;
;// begin_wdm
;//
;// Define Device Object (DO) flags
;//
;#define DO_VERIFY_VOLUME 0x00000002h
;#define DO_BUFFERED_IO 0x00000004h
;#define DO_EXCLUSIVE 0x00000008h
;#define DO_DIRECT_IO 0x00000010h
;#define DO_MAP_IO_BUFFER 0x00000020h
;#define DO_DEVICE_HAS_NAME 0x00000040h
;#define DO_DEVICE_INITIALIZING 0x00000080h
;#define DO_SYSTEM_BOOT_PARTITION 0x00000100h
;#define DO_LONG_TERM_REQUESTS 0x00000200h
;#define DO_NEVER_LAST_DEVICE 0x00000400h
;#define DO_SHUTDOWN_REGISTERED 0x00000800h
;#define DO_BUS_ENUMERATED_DEVICE 0x00001000h
;#define DO_POWER_PAGABLE 0x00002000h
;#define DO_POWER_INRUSH 0x00004000h
;#define DO_LOW_PRIORITY_FILESYSTEM 0x00010000
;//
;// Device Object structure definition
;//
;
;DEVICE_OBJECT {
; dType CSHORT
; dSize USHORT
; ReferenceCount LONG ?
; DriverObject PVIOD ?
; NextDevice PVOID ?
; AttachedDevice PVOID ?
; CurrentIrp PVOID ?
; PIO_TIMER Timer;
; ULONG Flags; // See above: DO_...
; ULONG Characteristics; // See ntioapi: FILE_...
; 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;
; 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; // ntndis
;
;
;struct _DEVICE_OBJECT_POWER_EXTENSION;
;
;DEVOBJ_EXTENSION STRUC
; dType CSHORT ?
; dSize USHORT ?
; Reserved DWORD ?
; DeviceObject PDEVICE_OBJECT ?
;DEVOBJ_EXTENSION ENDS
;PDEVOBJ_EXTENSION TYPEDEF PTR DEVOBJ_EXTENSION
;DRVO_UNLOAD_INVOKED equ 00000001h
;DRVO_LEGACY_DRIVER equ 00000002h
;DRVO_BUILTIN_DRIVER equ 00000004h ; Driver objects for Hal, PnP Mgr
;DRVO_REINIT_REGISTERED equ 00000008h
;DRVO_INITIALIZED equ 00000010h
;DRVO_BOOTREINIT_REGISTERED equ 00000020h
;DRVO_LEGACY_RESOURCES equ 00000040h
;DRIVER_EXTENSION STRUC
; DriverObject PVOID ?
; AddDevice PDRIVER_ADD_DEVICE ?
; Count ULONG ?
; Reserved DWORD ?
; ServiceKeyName UNICODE_STRING<>
;DRIVER_EXTENSION ENDS
;PDRIVER_EXTENSION TYPEDEF PTR DRIVER_EXTENSION
;DRIVER_OBJECT STRUC
; dType CSHORT ?
; dSize CSHORT ?
; Reserved1 DWORD ?
; DeviceObject PDEVICE_OBJECT ?
; Flags ULONG ?
; Reserved2 DWORD ?
; DriverStart PVOID ?
; DriverSize ULONG ?
; Reserved3 DWORD ?
; DriverSection PVOID ?
; DriverExtension PDRIVER_EXTENSION ?
; DriverName UNICODE_STRING<>
; HardwareDatabase PUNICODE_STRING ?
; FastIoDispatch PFAST_IO_DISPATCH ?
; DriverInit PDRIVER_INITIALIZE ?
; DriverStartIo PDRIVER_STARTIO ?
; DriverUnload PDRIVER_UNLOAD ?
; MajorFunction PDRIVER_DISPATCH IRP_MJ_MAXIMUM_FUNCTION + 1 dup(?)
;DRIVER_OBJECT ENDS
;PDRIVER_OBJECT TYPEDEF PTR DRIVER_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.
;//
;SECTION_OBJECT_POINTERS STRUC
; DataSectionObject PVOID ?
; SharedCacheMap PVOID ?
; ImageSectionObject PVOID ?
;SECTION_OBJECT_POINTERS ENDS
;PSECTION_OBJECT_POINTERS TYPEDEF PTR SECTION_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_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
;
;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;
; ULONG Waiters;
; ULONG Busy;
; PVOID LastLock;
; KEVENT Lock;
; KEVENT Event;
; PIO_COMPLETION_CONTEXT CompletionContext;
;} FILE_OBJECT;
;typedef struct _FILE_OBJECT *PFILE_OBJECT; // ntndis
;
;//
;// 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
;// end_wdm
;
;#define IRP_DEFER_IO_COMPLETION 0x00000800
;#define IRP_OB_QUERY_NAME 0x00001000
;#define IRP_HOLD_DEVICE_QUEUE 0x00002000
;#define IRP_RETRY_IO_COMPLETION 0x00004000
;
;// begin_wdm
;//
;// 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 _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;
; 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 {
; PIO_APC_ROUTINE UserApcRoutine;
; 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.
; //
;
; 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, *PIRP;
;
;//
;// Define completion routine types for use in stack locations in an IRP
;//
;
;typedef
;NTSTATUS
;(*PIO_COMPLETION_ROUTINE) (
; IN PDEVICE_OBJECT DeviceObject,
; IN PIRP Irp,
; IN PVOID Context
; );
;
;//
;// Define stack location control flags
;//
;
;#define SL_PENDING_RETURNED 0x01
;#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
;//
;// 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_CASE_SENSITIVE 0x80
;
;//
;// Read / Write
;//
;
;#define SL_KEY_SPECIFIED 0x01
;#define SL_OVERRIDE_VERIFY_VOLUME 0x02
;#define SL_WRITE_THROUGH 0x04
;#define SL_FT_SEQUENTIAL_WRITE 0x08
;
;//
;// Device I/O Control
;//
;//
;// Same SL_OVERRIDE_VERIFY_VOLUME as for read/write above.
;//
;
;//
;// Lock
;//
;
;#define SL_FAIL_IMMEDIATELY 0x01
;#define SL_EXCLUSIVE_LOCK 0x02
;
;//
;// QueryDirectory / QueryEa / QueryQuota
;//
;
;#define SL_RESTART_SCAN 0x01
;#define SL_RETURN_SINGLE_ENTRY 0x02
;#define SL_INDEX_SPECIFIED 0x04
;
;//
;// NotifyDirectory
;//
;
;#define SL_WATCH_TREE 0x01
;
;//
;// FileSystemControl
;//
;// minor: mount/verify volume
;//
;
;#define SL_ALLOW_RAW_MOUNT 0x01
;
;//
;// Define PNP/POWER types required by IRP_MJ_PNP/IRP_MJ_POWER.
;//
;
;typedef enum _DEVICE_RELATION_TYPE {
; BusRelations,
; EjectionRelations,
; PowerRelations,
; RemovalRelations,
; TargetDeviceRelation
;} DEVICE_RELATION_TYPE, *PDEVICE_RELATION_TYPE;
;
;typedef struct _DEVICE_RELATIONS {
; ULONG Count;
; PDEVICE_OBJECT Objects[1]; // variable length
;} DEVICE_RELATIONS, *PDEVICE_RELATIONS;
;
;typedef enum _DEVICE_USAGE_NOTIFICATION_TYPE {
; DeviceUsageTypeUndefined,
; DeviceUsageTypePaging,
; DeviceUsageTypeHibernation,
; DeviceUsageTypeDumpFile
;} DEVICE_USAGE_NOTIFICATION_TYPE;
;
;// begin_ntminiport
;
;typedef struct _INTERFACE {
; USHORT Size;
; USHORT Version;
; PVOID Context;
; PINTERFACE_REFERENCE InterfaceReference;
; PINTERFACE_DEREFERENCE InterfaceDereference;
; // interface specific entries go here
;} INTERFACE, *PINTERFACE;
;
;// end_ntminiport
;
;typedef 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 Reserved:14;
;
; ULONG Address;
; ULONG UINumber;
;
; DEVICE_POWER_STATE DeviceState[PowerSystemMaximum];
; SYSTEM_POWER_STATE SystemWake;
; 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, // <Enumerator>\<Enumerator-specific device id>
; 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
;} 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
;
;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(_ALPHA_) && !defined(_IA64_)
;#include "pshpack4.h"
;#endif
;
;#if defined(_WIN64)
;#define POINTER_ALIGNMENT DECLSPEC_ALIGN(8)
;#else
;#define POINTER_ALIGNMENT
;#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: 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: 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: NtQueryVolumeInformationFile
; //
;
; struct {
; ULONG Length;
; FS_INFORMATION_CLASS POINTER_ALIGNMENT FsInformationClass;
; } QueryVolume;
;
;
; //
; // System service parameters for: NtFlushBuffersFile
; //
; // 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;
;
;// end_wdm
; //
; // 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;
;
;// begin_wdm
; //
; // 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 contorl.
; //
;
; struct {
; struct _SCSI_REQUEST_BLOCK *Srb;
; } Scsi;
;
;
; //
; // 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;
;
;// end_ntifs
;
; //
; // 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
; //
;
; struct {
; ULONG SystemContext;
; POWER_STATE_TYPE POINTER_ALIGNMENT Type;
; POWER_STATE POINTER_ALIGNMENT State;
; POWER_ACTION POINTER_ALIGNMENT ShutdownType;
; } Power;
;
; //
; // Parameters for StartDevice
; //
;
; struct {
; PCM_RESOURCE_LIST AllocatedResources;
; PCM_RESOURCE_LIST AllocatedResourcesTranslated;
; } StartDevice;
;
;// begin_ntifs
; //
; // 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
; //
;
; 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 !defined(_ALPHA_) && !defined(_IA64_)
;#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;
;
;// end_wdm
;
;//
;// The following structure is used by drivers that are initializing to
;// determine the number of devices of a particular type that have already
;// been initialized. It is also used to track whether or not the AtDisk
;// address range has already been claimed. Finally, it is used by the
;// NtQuerySystemInformation system service to return device type counts.
;//
;
;typedef struct _CONFIGURATION_INFORMATION {
;
; //
; // This field indicates the total number of disks in the system. This
; // number should be used by the driver to determine the name of new
; // disks. This field should be updated by the driver as it finds new
; // disks.
; //
;
; ULONG DiskCount; // Count of hard disks thus far
; ULONG FloppyCount; // Count of floppy disks thus far
; ULONG CdRomCount; // Count of CD-ROM drives thus far
; ULONG TapeCount; // Count of tape drives thus far
; ULONG ScsiPortCount; // Count of SCSI port adapters thus far
; ULONG SerialCount; // Count of serial devices thus far
; ULONG ParallelCount; // Count of parallel devices thus far
;
; //
; // These next two fields indicate ownership of one of the two IO address
; // spaces that are used by WD1003-compatable disk controllers.
; //
;
; BOOLEAN AtDiskPrimaryAddressClaimed; // 0x1F0 - 0x1FF
; BOOLEAN AtDiskSecondaryAddressClaimed; // 0x170 - 0x17F
;
; //
; // Indicates the structure version, as anything value belong this will have been added.
; // Use the structure size as the version.
; //
;
; ULONG Version;
;
; //
; // Indicates the total number of medium changer devices in the system.
; // This field will be updated by the drivers as it determines that
; // new devices have been found and will be supported.
; //
;
; ULONG MediumChangerCount;
;
;} CONFIGURATION_INFORMATION, *PCONFIGURATION_INFORMATION;
;
;//
;// Public I/O routine definitions
;//
;
;NTKERNELAPI
;VOID
;IoAcquireCancelSpinLock(
; OUT PKIRQL Irql
; );
;
;
;NTKERNELAPI
;NTSTATUS
;IoAllocateAdapterChannel(
; IN PADAPTER_OBJECT AdapterObject,
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG NumberOfMapRegisters,
; IN PDRIVER_CONTROL ExecutionRoutine,
; IN PVOID Context
; );
;
;NTKERNELAPI
;VOID
;IoAllocateController(
; IN PCONTROLLER_OBJECT ControllerObject,
; IN PDEVICE_OBJECT DeviceObject,
; IN PDRIVER_CONTROL ExecutionRoutine,
; IN PVOID Context
; );
;
;// begin_wdm
;
;NTKERNELAPI
;NTSTATUS
;IoAllocateDriverObjectExtension(
; IN PDRIVER_OBJECT DriverObject,
; IN PVOID ClientIdentificationAddress,
; IN ULONG DriverObjectExtensionSize,
; OUT PVOID *DriverObjectExtension
; );
;
;// begin_ntifs
;
;NTKERNELAPI
;PVOID
;IoAllocateErrorLogEntry(
; IN PVOID IoObject,
; IN UCHAR EntrySize
; );
;
;NTKERNELAPI
;PIRP
;IoAllocateIrp(
; IN CCHAR StackSize,
; IN BOOLEAN ChargeQuota
; );
;
;NTKERNELAPI
;PMDL
;IoAllocateMdl(
; IN PVOID VirtualAddress,
; IN ULONG Length,
; IN BOOLEAN SecondaryBuffer,
; IN BOOLEAN ChargeQuota,
; IN OUT PIRP Irp OPTIONAL
; );
;
;// end_wdm end_ntifs
;//++
;//
;// VOID
;// IoAssignArcName(
;// IN PUNICODE_STRING ArcName,
;// IN PUNICODE_STRING DeviceName
;// )
;//
;// Routine Description:
;//
;// This routine is invoked by drivers of bootable media to create a symbolic
;// link between the ARC name of their device and its NT name. This allows
;// the system to determine which device in the system was actually booted
;// from since the ARC firmware only deals in ARC names, and NT only deals
;// in NT names.
;//
;// Arguments:
;//
;// ArcName - Supplies the Unicode string representing the ARC name.
;//
;// DeviceName - Supplies the name to which the ARCname refers.
;//
;// Return Value:
;//
;// None.
;//
;//--
;
;#define IoAssignArcName( ArcName, DeviceName ) ( \
; IoCreateSymbolicLink( (ArcName), (DeviceName) ) )
;
;NTKERNELAPI
;NTSTATUS
;IoAssignResources (
; IN PUNICODE_STRING RegistryPath,
; IN PUNICODE_STRING DriverClassName OPTIONAL,
; IN PDRIVER_OBJECT DriverObject,
; IN PDEVICE_OBJECT DeviceObject OPTIONAL,
; IN PIO_RESOURCE_REQUIREMENTS_LIST RequestedResources,
; IN OUT PCM_RESOURCE_LIST *AllocatedResources
; );
;
;
;NTKERNELAPI
;NTSTATUS
;IoAttachDevice(
; IN PDEVICE_OBJECT SourceDevice,
; IN PUNICODE_STRING TargetDevice,
; OUT PDEVICE_OBJECT *AttachedDevice
; );
;
;// end_wdm
;
;NTKERNELAPI
;NTSTATUS
;IoAttachDeviceByPointer(
; IN PDEVICE_OBJECT SourceDevice,
; IN PDEVICE_OBJECT TargetDevice
; );
;
;// begin_wdm
;
;NTKERNELAPI
;PDEVICE_OBJECT
;IoAttachDeviceToDeviceStack(
; IN PDEVICE_OBJECT SourceDevice,
; IN PDEVICE_OBJECT TargetDevice
; );
;
;NTKERNELAPI
;PIRP
;IoBuildAsynchronousFsdRequest(
; IN ULONG MajorFunction,
; IN PDEVICE_OBJECT DeviceObject,
; IN OUT PVOID Buffer OPTIONAL,
; IN ULONG Length OPTIONAL,
; IN PLARGE_INTEGER StartingOffset OPTIONAL,
; IN PIO_STATUS_BLOCK IoStatusBlock OPTIONAL
; );
;
;NTKERNELAPI
;PIRP
;IoBuildDeviceIoControlRequest(
; IN ULONG IoControlCode,
; IN PDEVICE_OBJECT DeviceObject,
; IN PVOID InputBuffer OPTIONAL,
; IN ULONG InputBufferLength,
; OUT PVOID OutputBuffer OPTIONAL,
; IN ULONG OutputBufferLength,
; IN BOOLEAN InternalDeviceIoControl,
; IN PKEVENT Event,
; OUT PIO_STATUS_BLOCK IoStatusBlock
; );
;
;NTKERNELAPI
;VOID
;IoBuildPartialMdl(
; IN PMDL SourceMdl,
; IN OUT PMDL TargetMdl,
; IN PVOID VirtualAddress,
; IN ULONG Length
; );
;
;typedef struct _BOOTDISK_INFORMATION {
; LONGLONG BootPartitionOffset;
; LONGLONG SystemPartitionOffset;
; ULONG BootDeviceSignature;
; ULONG SystemDeviceSignature;
;} BOOTDISK_INFORMATION, *PBOOTDISK_INFORMATION;
;
;NTKERNELAPI
;NTSTATUS
;IoGetBootDiskInformation(
; IN OUT PBOOTDISK_INFORMATION BootDiskInformation,
; IN ULONG Size
; );
;
;
;NTKERNELAPI
;PIRP
;IoBuildSynchronousFsdRequest(
; IN ULONG MajorFunction,
; IN PDEVICE_OBJECT DeviceObject,
; IN OUT PVOID Buffer OPTIONAL,
; IN ULONG Length OPTIONAL,
; IN PLARGE_INTEGER StartingOffset OPTIONAL,
; IN PKEVENT Event,
; OUT PIO_STATUS_BLOCK IoStatusBlock
; );
;
;NTKERNELAPI
;NTSTATUS
;FASTCALL
;IofCallDriver(
; IN PDEVICE_OBJECT DeviceObject,
; IN OUT PIRP Irp
; );
;
;#define IoCallDriver(a,b) \
; IofCallDriver(a,b)
;
;NTKERNELAPI
;BOOLEAN
;IoCancelIrp(
; IN PIRP Irp
; );
;
;
;NTKERNELAPI
;NTSTATUS
;IoCheckShareAccess(
; IN ACCESS_MASK DesiredAccess,
; IN ULONG DesiredShareAccess,
; IN OUT PFILE_OBJECT FileObject,
; IN OUT PSHARE_ACCESS ShareAccess,
; IN BOOLEAN Update
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;IofCompleteRequest(
; IN PIRP Irp,
; IN CCHAR PriorityBoost
; );
;
;#define IoCompleteRequest(a,b) \
; IofCompleteRequest(a,b)
;
;// end_ntifs
;
;NTKERNELAPI
;NTSTATUS
;IoConnectInterrupt(
; OUT PKINTERRUPT *InterruptObject,
; IN PKSERVICE_ROUTINE ServiceRoutine,
; IN PVOID ServiceContext,
; IN PKSPIN_LOCK SpinLock OPTIONAL,
; IN ULONG Vector,
; IN KIRQL Irql,
; IN KIRQL SynchronizeIrql,
; IN KINTERRUPT_MODE InterruptMode,
; IN BOOLEAN ShareVector,
; IN KAFFINITY ProcessorEnableMask,
; IN BOOLEAN FloatingSave
; );
;
;// end_wdm
;
;NTKERNELAPI
;PCONTROLLER_OBJECT
;IoCreateController(
; IN ULONG Size
; );
;
;// begin_wdm begin_ntifs
;
;NTKERNELAPI
;NTSTATUS
;IoCreateDevice(
; IN PDRIVER_OBJECT DriverObject,
; IN ULONG DeviceExtensionSize,
; IN PUNICODE_STRING DeviceName OPTIONAL,
; IN DEVICE_TYPE DeviceType,
; IN ULONG DeviceCharacteristics,
; IN BOOLEAN Exclusive,
; OUT PDEVICE_OBJECT *DeviceObject
; );
;
;#define WDM_MAJORVERSION 0x01
;#define WDM_MINORVERSION 0x10
;
;NTKERNELAPI
;BOOLEAN
;IoIsWdmVersionAvailable(
; IN UCHAR MajorVersion,
; IN UCHAR MinorVersion
; );
;
;// end_nthal
;
;NTKERNELAPI
;NTSTATUS
;IoCreateFile(
; OUT PHANDLE FileHandle,
; IN ACCESS_MASK DesiredAccess,
; IN POBJECT_ATTRIBUTES ObjectAttributes,
; OUT PIO_STATUS_BLOCK IoStatusBlock,
; IN PLARGE_INTEGER AllocationSize OPTIONAL,
; IN ULONG FileAttributes,
; IN ULONG ShareAccess,
; IN ULONG Disposition,
; IN ULONG CreateOptions,
; IN PVOID EaBuffer OPTIONAL,
; IN ULONG EaLength,
; IN CREATE_FILE_TYPE CreateFileType,
; IN PVOID ExtraCreateParameters OPTIONAL,
; IN ULONG Options
; );
;
;
;NTKERNELAPI
;PKEVENT
;IoCreateNotificationEvent(
; IN PUNICODE_STRING EventName,
; OUT PHANDLE EventHandle
; );
;
;NTKERNELAPI
;NTSTATUS
;IoCreateSymbolicLink(
; IN PUNICODE_STRING SymbolicLinkName,
; IN PUNICODE_STRING DeviceName
; );
;
;// end_wdm
;
;NTKERNELAPI
;PKEVENT
;IoCreateSynchronizationEvent(
; IN PUNICODE_STRING EventName,
; OUT PHANDLE EventHandle
; );
;
;// begin_wdm
;
;NTKERNELAPI
;NTSTATUS
;IoCreateUnprotectedSymbolicLink(
; IN PUNICODE_STRING SymbolicLinkName,
; IN PUNICODE_STRING DeviceName
; );
;
;// end_wdm
;
;//++
;//
;// VOID
;// IoDeassignArcName(
;// IN PUNICODE_STRING ArcName
;// )
;//
;// Routine Description:
;//
;// This routine is invoked by drivers to deassign an ARC name that they
;// created to a device. This is generally only called if the driver is
;// deleting the device object, which means that the driver is probably
;// unloading.
;//
;// Arguments:
;//
;// ArcName - Supplies the ARC name to be removed.
;//
;// Return Value:
;//
;// None.
;//
;//--
;
;#define IoDeassignArcName( ArcName ) ( \
; IoDeleteSymbolicLink( (ArcName) ) )
;
;// end_ntifs
;
;NTKERNELAPI
;VOID
;IoDeleteController(
; IN PCONTROLLER_OBJECT ControllerObject
; );
;
;// begin_wdm begin_ntifs
;
;NTKERNELAPI
;VOID
;IoDeleteDevice(
; IN PDEVICE_OBJECT DeviceObject
; );
;
;NTKERNELAPI
;NTSTATUS
;IoDeleteSymbolicLink(
; IN PUNICODE_STRING SymbolicLinkName
; );
;
;NTKERNELAPI
;VOID
;IoDetachDevice(
; IN OUT PDEVICE_OBJECT TargetDevice
; );
;
;// end_ntifs
;
;NTKERNELAPI
;VOID
;IoDisconnectInterrupt(
; IN PKINTERRUPT InterruptObject
; );
;
;
;NTKERNELAPI
;VOID
;IoFreeController(
; IN PCONTROLLER_OBJECT ControllerObject
; );
;
;// begin_wdm begin_ntifs
;
;NTKERNELAPI
;VOID
;IoFreeIrp(
; IN PIRP Irp
; );
;
;NTKERNELAPI
;VOID
;IoFreeMdl(
; IN PMDL Mdl
; );
;
;NTKERNELAPI
;PDEVICE_OBJECT
;IoGetAttachedDeviceReference(
; IN PDEVICE_OBJECT DeviceObject
; );
;
;NTKERNELAPI
;PCONFIGURATION_INFORMATION
;IoGetConfigurationInformation( VOID );
;
;//++
;//
;// 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.
;//
;//--
;
;#define IoGetCurrentIrpStackLocation( Irp ) ( (Irp)->Tail.Overlay.CurrentStackLocation )
;
;// end_nthal end_wdm
;
;NTKERNELAPI
;PDEVICE_OBJECT
;IoGetDeviceToVerify(
; IN PETHREAD Thread
; );
;
;// begin_wdm
;
;NTKERNELAPI
;PVOID
;IoGetDriverObjectExtension(
; IN PDRIVER_OBJECT DriverObject,
; IN PVOID ClientIdentificationAddress
; );
;
;NTKERNELAPI
;PEPROCESS
;IoGetCurrentProcess(
; VOID
; );
;
;// begin_nthal
;
;NTKERNELAPI
;NTSTATUS
;IoGetDeviceObjectPointer(
; IN PUNICODE_STRING ObjectName,
; IN ACCESS_MASK DesiredAccess,
; OUT PFILE_OBJECT *FileObject,
; OUT PDEVICE_OBJECT *DeviceObject
; );
;
;NTKERNELAPI
;struct _DMA_ADAPTER *
;IoGetDmaAdapter(
; IN PDEVICE_OBJECT PhysicalDeviceObject, OPTIONAL // required for PnP drivers
; IN struct _DEVICE_DESCRIPTION *DeviceDescription,
; IN OUT PULONG NumberOfMapRegisters
; );
;
;// end_wdm
;
;NTKERNELAPI
;PGENERIC_MAPPING
;IoGetFileObjectGenericMapping(
; VOID
; );
;
;// end_nthal
;
;
;// begin_wdm
;
;//++
;//
;// 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 )
;
;// begin_nthal end_wdm
;
;NTKERNELAPI
;PVOID
;IoGetInitialStack(
; VOID
; );
;
;NTKERNELAPI
;VOID
;IoGetStackLimits (
; OUT PULONG_PTR LowLimit,
; OUT PULONG_PTR HighLimit
; );
;
;
;//
;// The following function is used to tell the caller how much stack is available
;//
;
;__inline
;ULONG_PTR
;IoGetRemainingStackSize (
; VOID
; )
;{
; ULONG_PTR Top;
; ULONG_PTR Bottom;
;
; IoGetStackLimits( &Bottom, &Top );
; return((ULONG_PTR)(&Top) - Bottom );
;}
;
;// begin_wdm
;
;//++
;//
;// 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.
;//
;//--
;
;#define IoGetNextIrpStackLocation( Irp ) (\
; (Irp)->Tail.Overlay.CurrentStackLocation - 1 )
;
;NTKERNELAPI
;PDEVICE_OBJECT
;IoGetRelatedDeviceObject(
; IN PFILE_OBJECT FileObject
; );
;
;
;//++
;//
;// VOID
;// 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.
;//
;//--
;
;#define IoInitializeDpcRequest( DeviceObject, DpcRoutine ) (\
; KeInitializeDpc( &(DeviceObject)->Dpc, \
; (PKDEFERRED_ROUTINE) (DpcRoutine), \
; (DeviceObject) ) )
;
;NTKERNELAPI
;VOID
;IoInitializeIrp(
; IN OUT PIRP Irp,
; IN USHORT PacketSize,
; IN CCHAR StackSize
; );
;
;NTKERNELAPI
;NTSTATUS
;IoInitializeTimer(
; IN PDEVICE_OBJECT DeviceObject,
; IN PIO_TIMER_ROUTINE TimerRoutine,
; IN PVOID Context
; );
;
;
;NTKERNELAPI
;VOID
;IoReuseIrp(
; IN OUT PIRP Irp,
; IN NTSTATUS Iostatus
; );
;
;
;NTKERNELAPI
;VOID
;IoCancelFileOpen(
; IN PDEVICE_OBJECT DeviceObject,
; IN PFILE_OBJECT FileObject
; );
;
;//++
;//
;// 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)))
;
;
;NTKERNELAPI
;PIRP
;IoMakeAssociatedIrp(
; IN PIRP Irp,
; IN CCHAR StackSize
; );
;
;// begin_wdm
;
;//++
;//
;// VOID
;// IoMarkIrpPending(
;// IN OUT 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.
;//
;//--
;
;#define IoMarkIrpPending( Irp ) ( \
; IoGetCurrentIrpStackLocation( (Irp) )->Control |= SL_PENDING_RETURNED )
;
;NTKERNELAPI
;NTSTATUS
;IoQueryDeviceDescription(
; IN PINTERFACE_TYPE BusType OPTIONAL,
; IN PULONG BusNumber OPTIONAL,
; IN PCONFIGURATION_TYPE ControllerType OPTIONAL,
; IN PULONG ControllerNumber OPTIONAL,
; IN PCONFIGURATION_TYPE PeripheralType OPTIONAL,
; IN PULONG PeripheralNumber OPTIONAL,
; IN PIO_QUERY_DEVICE_ROUTINE CalloutRoutine,
; IN PVOID Context
; );
;
;NTKERNELAPI
;VOID
;IoRaiseHardError(
; IN PIRP Irp,
; IN PVPB Vpb OPTIONAL,
; IN PDEVICE_OBJECT RealDeviceObject
; );
;
;NTKERNELAPI
;BOOLEAN
;IoRaiseInformationalHardError(
; IN NTSTATUS ErrorStatus,
; IN PUNICODE_STRING String OPTIONAL,
; IN PKTHREAD Thread OPTIONAL
; );
;
;NTKERNELAPI
;BOOLEAN
;IoSetThreadHardErrorMode(
; IN BOOLEAN EnableHardErrors
; );
;
;NTKERNELAPI
;VOID
;IoRegisterBootDriverReinitialization(
; IN PDRIVER_OBJECT DriverObject,
; IN PDRIVER_REINITIALIZE DriverReinitializationRoutine,
; IN PVOID Context
; );
;
;NTKERNELAPI
;VOID
;IoRegisterDriverReinitialization(
; IN PDRIVER_OBJECT DriverObject,
; IN PDRIVER_REINITIALIZE DriverReinitializationRoutine,
; IN PVOID Context
; );
;
;
;NTKERNELAPI
;NTSTATUS
;IoRegisterShutdownNotification(
; IN PDEVICE_OBJECT DeviceObject
; );
;
;NTKERNELAPI
;NTSTATUS
;IoRegisterLastChanceShutdownNotification(
; IN PDEVICE_OBJECT DeviceObject
; );
;
;// begin_wdm
;
;NTKERNELAPI
;VOID
;IoReleaseCancelSpinLock(
; IN KIRQL Irql
; );
;
;
;NTKERNELAPI
;VOID
;IoRemoveShareAccess(
; IN PFILE_OBJECT FileObject,
; IN OUT PSHARE_ACCESS ShareAccess
; );
;
;
;NTKERNELAPI
;NTSTATUS
;IoReportResourceUsage(
; IN PUNICODE_STRING DriverClassName OPTIONAL,
; IN PDRIVER_OBJECT DriverObject,
; IN PCM_RESOURCE_LIST DriverList OPTIONAL,
; IN ULONG DriverListSize OPTIONAL,
; IN PDEVICE_OBJECT DeviceObject,
; IN PCM_RESOURCE_LIST DeviceList OPTIONAL,
; IN ULONG DeviceListSize OPTIONAL,
; IN BOOLEAN OverrideConflict,
; OUT PBOOLEAN ConflictDetected
; );
;
;// begin_wdm
;
;//++
;//
;// VOID
;// IoRequestDpc(
;// IN PDEVICE_OBJECT DeviceObject,
;// IN PIRP Irp,
;// IN 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.
;//
;//--
;
;#define IoRequestDpc( DeviceObject, Irp, Context ) ( \
; KeInsertQueueDpc( &(DeviceObject)->Dpc, (Irp), (Context) ) )
;
;//++
;//
;// PDRIVER_CANCEL
;// IoSetCancelRoutine(
;// IN PIRP Irp,
;// IN 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.
;//
;//--
;
;#define IoSetCancelRoutine( Irp, NewCancelRoutine ) ( \
; (PDRIVER_CANCEL) InterlockedExchangePointer( (PVOID *) &(Irp)->CancelRoutine, (PVOID) (NewCancelRoutine) ) )
;
;//++
;//
;// VOID
;// IoSetCompletionRoutine(
;// IN PIRP Irp,
;// IN PIO_COMPLETION_ROUTINE CompletionRoutine,
;// IN 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.
;//
;//--
;
;#define IoSetCompletionRoutine( Irp, Routine, CompletionContext, Success, Error, Cancel ) { \
; PIO_STACK_LOCATION irpSp; \
; ASSERT( (Success) | (Error) | (Cancel) ? (Routine) != NULL : TRUE ); \
; irpSp = IoGetNextIrpStackLocation( (Irp) ); \
; irpSp->CompletionRoutine = (Routine); \
; irpSp->Context = (CompletionContext); \
; irpSp->Control = 0; \
; if ((Success)) { irpSp->Control = SL_INVOKE_ON_SUCCESS; } \
; if ((Error)) { irpSp->Control |= SL_INVOKE_ON_ERROR; } \
; if ((Cancel)) { irpSp->Control |= SL_INVOKE_ON_CANCEL; } }
;
;
;NTKERNELAPI
;VOID
;IoSetHardErrorOrVerifyDevice(
; IN PIRP Irp,
; IN PDEVICE_OBJECT DeviceObject
; );
;
;
;//++
;//
;// VOID
;// IoSetNextIrpStackLocation (
;// IN OUT 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.
;//
;//--
;
;#define IoSetNextIrpStackLocation( Irp ) { \
; (Irp)->CurrentLocation--; \
; (Irp)->Tail.Overlay.CurrentStackLocation--; }
;
;//++
;//
;// VOID
;// IoCopyCurrentIrpStackLocationToNext(
;// IN 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.
;//
;//--
;
;#define IoCopyCurrentIrpStackLocationToNext( Irp ) { \
; 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; }
;
;//++
;//
;// VOID
;// IoSkipCurrentIrpStackLocation (
;// IN 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
;//
;//--
;
;#define IoSkipCurrentIrpStackLocation( Irp ) \
; (Irp)->CurrentLocation++; \
; (Irp)->Tail.Overlay.CurrentStackLocation++;
;
;
;NTKERNELAPI
;VOID
;IoSetShareAccess(
; IN ACCESS_MASK DesiredAccess,
; IN ULONG DesiredShareAccess,
; IN OUT PFILE_OBJECT FileObject,
; OUT PSHARE_ACCESS ShareAccess
; );
;
;
;
;typedef struct _IO_REMOVE_LOCK_TRACKING_BLOCK * PIO_REMOVE_LOCK_TRACKING_BLOCK;
;
;typedef struct _IO_REMOVE_LOCK_COMMON_BLOCK {
; BOOLEAN Removed;
; BOOLEAN Reserved [3];
; LONG IoCount;
; KEVENT RemoveEvent;
;
;} IO_REMOVE_LOCK_COMMON_BLOCK;
;
;typedef struct _IO_REMOVE_LOCK_DBG_BLOCK {
; LONG Signature;
; LONG HighWatermark;
; LONGLONG MaxLockedTicks;
; LONG AllocateTag;
; LIST_ENTRY LockList;
; KSPIN_LOCK Spin;
; 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))
;
;NTSYSAPI
;VOID
;NTAPI
;IoInitializeRemoveLockEx(
; IN 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
; );
;//
;// 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.
;//
;
;#define IoAcquireRemoveLock(RemoveLock, Tag) \
; IoAcquireRemoveLockEx(RemoveLock, Tag, __FILE__, __LINE__, sizeof (IO_REMOVE_LOCK))
;
;NTSYSAPI
;NTSTATUS
;NTAPI
;IoAcquireRemoveLockEx (
; IN PIO_REMOVE_LOCK RemoveLock,
; IN OPTIONAL PVOID Tag, // Optional
; IN PCSTR File,
; IN ULONG Line,
; IN ULONG RemlockSize // are we checked or free
; );
;
;//
;// 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))
;
;NTSYSAPI
;VOID
;NTAPI
;IoReleaseRemoveLockEx(
; IN PIO_REMOVE_LOCK RemoveLock,
; IN PVOID Tag, // Optional
; IN ULONG RemlockSize // are we checked or free
; );
;//
;//
;// 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))
;
;NTSYSAPI
;VOID
;NTAPI
;IoReleaseRemoveLockAndWaitEx(
; IN PIO_REMOVE_LOCK RemoveLock,
; IN PVOID Tag,
; IN ULONG RemlockSize // are we checked or free
; );
;//
;//
;// 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 )))))
;
;// end_ntifs
;
;
;NTKERNELAPI
;VOID
;IoStartNextPacket(
; IN PDEVICE_OBJECT DeviceObject,
; IN BOOLEAN Cancelable
; );
;
;NTKERNELAPI
;VOID
;IoStartNextPacketByKey(
; IN PDEVICE_OBJECT DeviceObject,
; IN BOOLEAN Cancelable,
; IN ULONG Key
; );
;
;NTKERNELAPI
;VOID
;IoStartPacket(
; IN PDEVICE_OBJECT DeviceObject,
; IN PIRP Irp,
; IN PULONG Key OPTIONAL,
; IN PDRIVER_CANCEL CancelFunction OPTIONAL
; );
;
;// begin_ntifs
;
;NTKERNELAPI
;VOID
;IoStartTimer(
; IN PDEVICE_OBJECT DeviceObject
; );
;
;NTKERNELAPI
;VOID
;IoStopTimer(
; IN PDEVICE_OBJECT DeviceObject
; );
;
;
;NTKERNELAPI
;VOID
;IoUnregisterShutdownNotification(
; IN PDEVICE_OBJECT DeviceObject
; );
;
;// end_wdm
;
;NTKERNELAPI
;VOID
;IoUpdateShareAccess(
; IN PFILE_OBJECT FileObject,
; IN OUT PSHARE_ACCESS ShareAccess
; );
;
;NTKERNELAPI
;VOID
;IoWriteErrorLogEntry(
; IN PVOID ElEntry
; );
;
;typedef struct _IO_WORKITEM *PIO_WORKITEM;
;
;typedef
;VOID
;(*PIO_WORKITEM_ROUTINE) (
; IN PDEVICE_OBJECT DeviceObject,
; IN PVOID Context
; );
;
;PIO_WORKITEM
;IoAllocateWorkItem(
; PDEVICE_OBJECT DeviceObject
; );
;
;VOID
;IoFreeWorkItem(
; PIO_WORKITEM IoWorkItem
; );
;
;VOID
;IoQueueWorkItem(
; IN PIO_WORKITEM IoWorkItem,
; IN PIO_WORKITEM_ROUTINE WorkerRoutine,
; IN WORK_QUEUE_TYPE QueueType,
; IN PVOID Context
; );
;
;// end_ntsrv
;
;// begin_ntifs
;
;NTKERNELAPI
;NTSTATUS
;IoWMIRegistrationControl(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG Action
;);
;
;//
;// Action code for IoWMIRetgistrationControl 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
;
;NTKERNELAPI
;NTSTATUS
;IoWMIAllocateInstanceIds(
; IN GUID *Guid,
; IN ULONG InstanceCount,
; OUT ULONG *FirstInstanceId
; );
;
;NTKERNELAPI
;NTSTATUS
;IoWMISuggestInstanceName(
; IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
; IN PUNICODE_STRING SymbolicLinkName OPTIONAL,
; IN BOOLEAN CombineNames,
; OUT PUNICODE_STRING SuggestedInstanceName
; );
;
;NTKERNELAPI
;NTSTATUS
;IoWMIWriteEvent(
; IN PVOID WnodeEventItem
; );
;
;#if defined(_WIN64)
;ULONG IoWMIDeviceObjectToProviderId(
; PDEVICE_OBJECT DeviceObject
; );
;#else
;#define IoWMIDeviceObjectToProviderId(DeviceObject) ((ULONG)(DeviceObject))
;#endif
;
;
;//
;// Define PnP Device Property for IoGetDeviceProperty
;//
;
;typedef enum {
; DevicePropertyDeviceDescription,
; DevicePropertyHardwareID,
; DevicePropertyCompatibleIDs,
; DevicePropertyBootConfiguration,
; DevicePropertyBootConfigurationTranslated,
; DevicePropertyClassName,
; DevicePropertyClassGuid,
; DevicePropertyDriverKeyName,
; DevicePropertyManufacturer,
; DevicePropertyFriendlyName,
; DevicePropertyLocationInformation,
; DevicePropertyPhysicalDeviceObjectName,
; DevicePropertyBusTypeGuid,
; DevicePropertyLegacyBusType,
; DevicePropertyBusNumber,
; DevicePropertyEnumeratorName,
; DevicePropertyAddress,
; DevicePropertyUINumber
;} DEVICE_REGISTRY_PROPERTY;
;
;typedef BOOLEAN (*PTRANSLATE_BUS_ADDRESS)(
; IN PVOID Context,
; IN PHYSICAL_ADDRESS BusAddress,
; IN ULONG Length,
; IN OUT PULONG AddressSpace,
; OUT PPHYSICAL_ADDRESS TranslatedAddress
; );
;
;typedef struct _DMA_ADAPTER *(*PGET_DMA_ADAPTER)(
; IN PVOID Context,
; IN struct _DEVICE_DESCRIPTION *DeviceDescriptor,
; OUT PULONG NumberOfMapRegisters
; );
;
;typedef ULONG (*PGET_SET_DEVICE_DATA)(
; IN PVOID Context,
; IN ULONG DataType,
; IN PVOID Buffer,
; IN ULONG Offset,
; IN ULONG Length
; );
;
;//
;// 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;
;
;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;
;
;//
;// The following definitions are used in ACPI QueryInterface
;//
;typedef BOOLEAN (* PGPE_SERVICE_ROUTINE) (
; PVOID,
; PVOID);
;
;typedef NTSTATUS (* PGPE_CONNECT_VECTOR) (
; PDEVICE_OBJECT,
; ULONG,
; KINTERRUPT_MODE,
; BOOLEAN,
; PGPE_SERVICE_ROUTINE,
; PVOID,
; PVOID);
;
;typedef NTSTATUS (* PGPE_DISCONNECT_VECTOR) (
; PVOID);
;
;typedef NTSTATUS (* PGPE_ENABLE_EVENT) (
; PDEVICE_OBJECT,
; PVOID);
;
;typedef NTSTATUS (* PGPE_DISABLE_EVENT) (
; PDEVICE_OBJECT,
; PVOID);
;
;typedef NTSTATUS (* PGPE_CLEAR_STATUS) (
; PDEVICE_OBJECT,
; PVOID);
;
;typedef VOID (* PDEVICE_NOTIFY_CALLBACK) (
; PVOID,
; ULONG);
;
;typedef NTSTATUS (* PREGISTER_FOR_DEVICE_NOTIFICATIONS) (
; PDEVICE_OBJECT,
; PDEVICE_NOTIFY_CALLBACK,
; PVOID);
;
;typedef 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;
;
;// end_wdm
;
;typedef enum _ACPI_REG_TYPE {
; PM1a_ENABLE,
; PM1b_ENABLE,
; PM1a_STATUS,
; PM1b_STATUS,
; PM1a_CONTROL,
; PM1b_CONTROL,
; GP_STATUS,
; GP_ENABLE,
; SMI_CMD,
; MaxRegType
;} ACPI_REG_TYPE, *PACPI_REG_TYPE;
;
;typedef USHORT (*PREAD_ACPI_REGISTER) (
; IN ACPI_REG_TYPE AcpiReg,
; IN ULONG Register);
;
;typedef VOID (*PWRITE_ACPI_REGISTER) (
; IN ACPI_REG_TYPE AcpiReg,
; IN ULONG Register,
; IN USHORT Value
; );
;
;typedef struct ACPI_REGS_INTERFACE_STANDARD {
; //
; // generic interface header
; //
; USHORT Size;
; USHORT Version;
; PVOID Context;
; PINTERFACE_REFERENCE InterfaceReference;
; PINTERFACE_DEREFERENCE InterfaceDereference;
;
; //
; // READ/WRITE_ACPI_REGISTER functions
; //
; PREAD_ACPI_REGISTER ReadAcpiRegister;
; PWRITE_ACPI_REGISTER WriteAcpiRegister;
;
;} ACPI_REGS_INTERFACE_STANDARD, *PACPI_REGS_INTERFACE_STANDARD;
;
;//
;// These definitions are used for getting PCI Interrupt Routing interfaces
;//
;
;typedef struct {
; PVOID LinkNode;
; ULONG StaticVector;
; UCHAR Flags;
;} ROUTING_TOKEN, *PROUTING_TOKEN;
;
;//
;// Flag indicating that the device supports
;// MSI interrupt routing or that the provided token contains
;// MSI routing information
;//
;
;#define PCI_MSI_ROUTING 0x1
;
;typedef
;NTSTATUS
;(*PGET_INTERRUPT_ROUTING)(
; IN PDEVICE_OBJECT Pdo,
; OUT ULONG *Bus,
; OUT ULONG *PciSlot,
; OUT UCHAR *InterruptLine,
; OUT UCHAR *InterruptPin,
; OUT UCHAR *ClassCode,
; OUT UCHAR *SubClassCode,
; OUT PDEVICE_OBJECT *ParentPdo,
; OUT ROUTING_TOKEN *RoutingToken,
; OUT UCHAR *Flags
; );
;
;typedef
;NTSTATUS
;(*PSET_INTERRUPT_ROUTING_TOKEN)(
; IN PDEVICE_OBJECT Pdo,
; IN PROUTING_TOKEN RoutingToken
; );
;
;typedef
;VOID
;(*PUPDATE_INTERRUPT_LINE)(
; IN PDEVICE_OBJECT Pdo,
; IN UCHAR LineRegister
; );
;
;typedef struct _INT_ROUTE_INTERFACE_STANDARD {
; //
; // generic interface header
; //
; USHORT Size;
; USHORT Version;
; PVOID Context;
; PINTERFACE_REFERENCE InterfaceReference;
; PINTERFACE_DEREFERENCE InterfaceDereference;
; //
; // standard bus interfaces
; //
; PGET_INTERRUPT_ROUTING GetInterruptRouting;
; PSET_INTERRUPT_ROUTING_TOKEN SetInterruptRoutingToken;
; PUPDATE_INTERRUPT_LINE UpdateInterruptLine;
;
;} INT_ROUTE_INTERFACE_STANDARD, *PINT_ROUTE_INTERFACE_STANDARD;
;
;// Some well-known interface versions supported by the PCI Bus Driver
;
;#define PCI_INT_ROUTE_INTRF_STANDARD_VER 1
;
;
;typedef struct _IO_ASSIGNED_RESOURCES {
; ULONG Count;
; PASSIGNED_RESOURCE AssignedResources[1];
;} IO_ASSIGNED_RESOURCES, *PIO_ASSIGNED_RESOURCES;
;
;NTKERNELAPI
;NTSTATUS
;IoGetAssignedResourcesForSuballocation (
; IN INTERFACE_TYPE InterfaceType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN PIO_RESOURCE_DESCRIPTOR ResourceDescriptor,
; OUT PIO_ASSIGNED_RESOURCES *List
; );
;
;NTKERNELAPI
;NTSTATUS
;IoReportDetectedDevice(
; IN PDRIVER_OBJECT DriverObject,
; IN INTERFACE_TYPE LegacyBusType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN PCM_RESOURCE_LIST ResourceList,
; IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements OPTIONAL,
; IN BOOLEAN ResourceAssigned,
; IN OUT PDEVICE_OBJECT *DeviceObject
; );
;
;// begin_wdm
;
;NTKERNELAPI
;VOID
;IoInvalidateDeviceRelations(
; IN PDEVICE_OBJECT DeviceObject,
; IN DEVICE_RELATION_TYPE Type
; );
;
;NTKERNELAPI
;VOID
;IoRequestDeviceEject(
; IN PDEVICE_OBJECT PhysicalDeviceObject
; );
;
;NTKERNELAPI
;NTSTATUS
;IoGetDeviceProperty(
; IN PDEVICE_OBJECT DeviceObject,
; IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
; IN ULONG BufferLength,
; OUT PVOID PropertyBuffer,
; OUT PULONG ResultLength
; );
;
;//
;// The following definitions are used in IoOpenDeviceRegistryKey
;//
;
;#define PLUGPLAY_REGKEY_DEVICE 1
;#define PLUGPLAY_REGKEY_DRIVER 2
;#define PLUGPLAY_REGKEY_CURRENT_HWPROFILE 4
;
;NTKERNELAPI
;NTSTATUS
;IoOpenDeviceRegistryKey(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG DevInstKeyType,
; IN ACCESS_MASK DesiredAccess,
; OUT PHANDLE DevInstRegKey
; );
;
;NTKERNELAPI
;NTSTATUS
;NTAPI
;IoRegisterDeviceInterface(
; IN PDEVICE_OBJECT PhysicalDeviceObject,
; IN CONST GUID *InterfaceClassGuid,
; IN PUNICODE_STRING ReferenceString, OPTIONAL
; OUT PUNICODE_STRING SymbolicLinkName
; );
;
;NTKERNELAPI
;NTSTATUS
;IoOpenDeviceInterfaceRegistryKey(
; IN PUNICODE_STRING SymbolicLinkName,
; IN ACCESS_MASK DesiredAccess,
; OUT PHANDLE DeviceInterfaceKey
; );
;
;// begin_ntsrv
;
;NTKERNELAPI
;NTSTATUS
;IoSetDeviceInterfaceState(
; IN PUNICODE_STRING SymbolicLinkName,
; IN BOOLEAN Enable
; );
;
;// end_ntsrv
;
;NTKERNELAPI
;NTSTATUS
;NTAPI
;IoGetDeviceInterfaces(
; IN CONST GUID *InterfaceClassGuid,
; IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
; IN ULONG Flags,
; OUT PWSTR *SymbolicLinkList
; );
;
;#define DEVICE_INTERFACE_INCLUDE_NONACTIVE 0x00000001
;
;NTKERNELAPI
;NTSTATUS
;NTAPI
;IoGetDeviceInterfaceAlias(
; IN PUNICODE_STRING SymbolicLinkName,
; IN CONST GUID *AliasInterfaceClassGuid,
; OUT PUNICODE_STRING AliasSymbolicLinkName
; );
;
;//
;// 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
;NTSTATUS
;(*PDRIVER_NOTIFICATION_CALLBACK_ROUTINE) (
; IN PVOID NotificationStructure,
; IN PVOID Context
;);
;
;
;NTKERNELAPI
;NTSTATUS
;IoRegisterPlugPlayNotification(
; IN IO_NOTIFICATION_EVENT_CATEGORY EventCategory,
; IN ULONG EventCategoryFlags,
; IN PVOID EventCategoryData OPTIONAL,
; IN PDRIVER_OBJECT DriverObject,
; IN PDRIVER_NOTIFICATION_CALLBACK_ROUTINE CallbackRoutine,
; IN PVOID Context,
; OUT PVOID *NotificationEntry
; );
;
;NTKERNELAPI
;NTSTATUS
;IoUnregisterPlugPlayNotification(
; IN PVOID NotificationEntry
; );
;
;NTKERNELAPI
;NTSTATUS
;IoReportTargetDeviceChange(
; IN PDEVICE_OBJECT PhysicalDeviceObject,
; IN PVOID NotificationStructure // always begins with a PLUGPLAY_NOTIFICATION_HEADER
; );
;
;typedef
;VOID
;(*PDEVICE_CHANGE_COMPLETE_CALLBACK)(
; IN PVOID Context
; );
;
;NTKERNELAPI
;VOID
;IoInvalidateDeviceState(
; IN PDEVICE_OBJECT PhysicalDeviceObject
; );
;
;#define IoAdjustPagingPathCount(_count_,_paging_) { \
; if (_paging_) { \
; InterlockedIncrement(_count_); \
; } else { \
; InterlockedDecrement(_count_); \
; } \
;}
;
;// end_wdm
;
;NTKERNELAPI
;NTSTATUS
;IoReportTargetDeviceChangeAsynchronous(
; IN PDEVICE_OBJECT PhysicalDeviceObject,
; IN PVOID NotificationStructure, // always begins with a PLUGPLAY_NOTIFICATION_HEADER
; IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback, OPTIONAL
; IN PVOID Context OPTIONAL
; );
;
;
;//
;// Resource arbiter declarations
;//
;
;typedef enum _ARBITER_ACTION {
; ArbiterActionTestAllocation,
; ArbiterActionRetestAllocation,
; ArbiterActionCommitAllocation,
; ArbiterActionRollbackAllocation,
; ArbiterActionQueryAllocatedResources,
; ArbiterActionWriteReservedResources,
; ArbiterActionQueryConflict,
; ArbiterActionQueryArbitrate,
; ArbiterActionAddReserved,
; ArbiterActionBootAllocation
;} ARBITER_ACTION, *PARBITER_ACTION;
;
;typedef struct _ARBITER_CONFLICT_INFO {
; //
; // The device object owning the device that is causing the conflict
; //
; PDEVICE_OBJECT OwningObject;
;
; //
; // The start of the conflicting range
; //
; ULONGLONG Start;
;
; //
; // The end of the conflicting range
; //
; ULONGLONG End;
;
;} ARBITER_CONFLICT_INFO, *PARBITER_CONFLICT_INFO;
;
;//
;// The parameters for those actions
;//
;
;typedef struct _ARBITER_PARAMETERS {
;
; union {
;
; struct {
;
; //
; // Doubly linked list of ARBITER_LIST_ENTRY's
; //
; IN OUT PLIST_ENTRY ArbitrationList;
;
; //
; // The size of the AllocateFrom array
; //
; IN ULONG AllocateFromCount;
;
; //
; // Array of resource descriptors describing the resources available
; // to the arbiter for it to arbitrate
; //
; IN PCM_PARTIAL_RESOURCE_DESCRIPTOR AllocateFrom;
;
; } TestAllocation;
;
; struct {
;
; //
; // Doubly linked list of ARBITER_LIST_ENTRY's
; //
; IN OUT PLIST_ENTRY ArbitrationList;
;
; //
; // The size of the AllocateFrom array
; //
; IN ULONG AllocateFromCount;
;
; //
; // Array of resource descriptors describing the resources available
; // to the arbiter for it to arbitrate
; //
; IN PCM_PARTIAL_RESOURCE_DESCRIPTOR AllocateFrom;
;
; } RetestAllocation;
;
; struct {
;
; //
; // Doubly linked list of ARBITER_LIST_ENTRY's
; //
; IN OUT PLIST_ENTRY ArbitrationList;
;
; } BootAllocation;
;
; struct {
;
; //
; // The resources that are currently allocated
; //
; OUT PCM_PARTIAL_RESOURCE_LIST *AllocatedResources;
;
; } QueryAllocatedResources;
;
; struct {
;
; //
; // This is the device we are trying to find a conflict for
; //
; IN PDEVICE_OBJECT PhysicalDeviceObject;
;
; //
; // This is the resource to find the conflict for
; //
; IN PIO_RESOURCE_DESCRIPTOR ConflictingResource;
;
; //
; // Number of devices conflicting on the resource
; //
; OUT PULONG ConflictCount;
;
; //
; // Pointer to array describing the conflicting device objects and ranges
; //
; OUT PARBITER_CONFLICT_INFO *Conflicts;
;
; } QueryConflict;
;
; struct {
;
; //
; // Doubly linked list of ARBITER_LIST_ENTRY's - should have
; // only one entry
; //
; IN PLIST_ENTRY ArbitrationList;
;
; } QueryArbitrate;
;
; struct {
;
; //
; // Indicates the device whose resources are to be marked as reserved
; //
; PDEVICE_OBJECT ReserveDevice;
;
; } AddReserved;
;
; } Parameters;
;
;} ARBITER_PARAMETERS, *PARBITER_PARAMETERS;
;
;
;
;typedef enum _ARBITER_REQUEST_SOURCE {
;
; ArbiterRequestUndefined = -1,
; ArbiterRequestLegacyReported, // IoReportResourceUsage
; ArbiterRequestHalReported, // IoReportHalResourceUsage
; ArbiterRequestLegacyAssigned, // IoAssignResources
; ArbiterRequestPnpDetected, // IoReportResourceForDetection
; ArbiterRequestPnpEnumerated // IRP_MN_QUERY_RESOURCE_REQUIREMENTS
;
;} ARBITER_REQUEST_SOURCE;
;
;
;typedef enum _ARBITER_RESULT {
;
; ArbiterResultUndefined = -1,
; ArbiterResultSuccess,
; ArbiterResultExternalConflict, // This indicates that the request can never be solved for devices in this list
; ArbiterResultNullRequest // The request was for length zero and thus no translation should be attempted
;
;} ARBITER_RESULT;
;
;//
;// ARBITER_FLAG_BOOT_CONFIG - this indicates that the request is for the
;// resources assigned by the firmware/BIOS. It should be succeeded even if
;// it conflicts with another devices boot config.
;//
;
;#define ARBITER_FLAG_BOOT_CONFIG 0x00000001
;
;NTKERNELAPI
;NTSTATUS
;IoReportResourceForDetection(
; IN PDRIVER_OBJECT DriverObject,
; IN PCM_RESOURCE_LIST DriverList OPTIONAL,
; IN ULONG DriverListSize OPTIONAL,
; IN PDEVICE_OBJECT DeviceObject OPTIONAL,
; IN PCM_RESOURCE_LIST DeviceList OPTIONAL,
; IN ULONG DeviceListSize OPTIONAL,
; OUT PBOOLEAN ConflictDetected
; );
;
;
;typedef struct _ARBITER_LIST_ENTRY {
;
; //
; // This is a doubly linked list of entries for easy sorting
; //
; LIST_ENTRY ListEntry;
;
; //
; // The number of alternative allocation
; //
; ULONG AlternativeCount;
;
; //
; // Pointer to an array of resource descriptors for the possible allocations
; //
; PIO_RESOURCE_DESCRIPTOR Alternatives;
;
; //
; // The device object of the device requesting these resources.
; //
; PDEVICE_OBJECT PhysicalDeviceObject;
;
; //
; // Indicates where the request came from
; //
; ARBITER_REQUEST_SOURCE RequestSource;
;
; //
; // Flags these indicate a variety of things (use ARBITER_FLAG_*)
; //
; ULONG Flags;
;
; //
; // Space to aid the arbiter in processing the list it is initialized to 0 when
; // the entry is created. The system will not attempt to interpret it.
; //
; LONG_PTR WorkSpace;
;
; //
; // Interface Type, Slot Number and Bus Number from Resource Requirements list,
; // used only for reverse identification.
; //
; INTERFACE_TYPE InterfaceType;
; ULONG SlotNumber;
; ULONG BusNumber;
;
; //
; // A pointer to a descriptor to indicate the resource that was allocated.
; // This is allocated by the system and filled in by the arbiter in response to an
; // ArbiterActionTestAllocation.
; //
; PCM_PARTIAL_RESOURCE_DESCRIPTOR Assignment;
;
; //
; // Pointer to the alternative that was chosen from to provide the assignment.
; // This is filled in by the arbiter in response to an ArbiterActionTestAllocation.
; //
; PIO_RESOURCE_DESCRIPTOR SelectedAlternative;
;
; //
; // The result of the operation
; // This is filled in by the arbiter in response to an ArbiterActionTestAllocation.
; //
; ARBITER_RESULT Result;
;
;} ARBITER_LIST_ENTRY, *PARBITER_LIST_ENTRY;
;
;//
;// The arbiter's entry point
;//
;
;typedef
;NTSTATUS
;(*PARBITER_HANDLER) (
; IN PVOID Context,
; IN ARBITER_ACTION Action,
; IN OUT PARBITER_PARAMETERS Parameters
; );
;
;//
;// Arbiter interface
;//
;
;//
;// A partial arbiter is one which may not arbitrate all the resources for
;// its children but may defer to the next arbiter in the chain by returning
;// STATUS_ARBITRATION_UNHANDLED.
;//
;
;#define ARBITER_PARTIAL 0x00000001
;
;
;typedef struct _ARBITER_INTERFACE {
;
; //
; // Generic interface header
; //
; USHORT Size;
; USHORT Version;
; PVOID Context;
; PINTERFACE_REFERENCE InterfaceReference;
; PINTERFACE_DEREFERENCE InterfaceDereference;
;
; //
; // Entry point to the arbiter
; //
; PARBITER_HANDLER ArbiterHandler;
;
; //
; // Other information about the arbiter, use ARBITER_* flags
; //
; ULONG Flags;
;
;} ARBITER_INTERFACE, *PARBITER_INTERFACE;
;
;//
;// The directions translation can take place in
;//
;
;typedef enum _RESOURCE_TRANSLATION_DIRECTION {
; TranslateChildToParent,
; TranslateParentToChild
;} RESOURCE_TRANSLATION_DIRECTION;
;
;//
;// Translation functions
;//
;
;typedef
;NTSTATUS
;(*PTRANSLATE_RESOURCE_HANDLER)(
; IN PVOID Context,
; IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Source,
; IN RESOURCE_TRANSLATION_DIRECTION Direction,
; IN ULONG AlternativesCount, OPTIONAL
; IN IO_RESOURCE_DESCRIPTOR Alternatives[], OPTIONAL
; IN PDEVICE_OBJECT PhysicalDeviceObject,
; OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR Target
;);
;
;typedef
;NTSTATUS
;(*PTRANSLATE_RESOURCE_REQUIREMENTS_HANDLER)(
; IN PVOID Context,
; IN PIO_RESOURCE_DESCRIPTOR Source,
; IN PDEVICE_OBJECT PhysicalDeviceObject,
; OUT PULONG TargetCount,
; OUT PIO_RESOURCE_DESCRIPTOR *Target
;);
;
;//
;// Translator Interface
;//
;
;typedef struct _TRANSLATOR_INTERFACE {
; USHORT Size;
; USHORT Version;
; PVOID Context;
; PINTERFACE_REFERENCE InterfaceReference;
; PINTERFACE_DEREFERENCE InterfaceDereference;
; PTRANSLATE_RESOURCE_HANDLER TranslateResources;
; PTRANSLATE_RESOURCE_REQUIREMENTS_HANDLER TranslateResourceRequirements;
;} TRANSLATOR_INTERFACE, *PTRANSLATOR_INTERFACE;
;
;// end_wdm
;
;//
;// Legacy Device Detection Handler
;//
;
;typedef
;NTSTATUS
;(*PLEGACY_DEVICE_DETECTION_HANDLER)(
; IN PVOID Context,
; IN INTERFACE_TYPE LegacyBusType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; OUT PDEVICE_OBJECT *PhysicalDeviceObject
;);
;
;//
;// Legacy Device Detection Interface
;//
;
;typedef struct _LEGACY_DEVICE_DETECTION_INTERFACE {
; USHORT Size;
; USHORT Version;
; PVOID Context;
; PINTERFACE_REFERENCE InterfaceReference;
; PINTERFACE_DEREFERENCE InterfaceDereference;
; PLEGACY_DEVICE_DETECTION_HANDLER LegacyDeviceDetection;
;} LEGACY_DEVICE_DETECTION_INTERFACE, *PLEGACY_DEVICE_DETECTION_INTERFACE;
;
;
;//
;// 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;
;
;//
;// 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;
;} DEVICE_DESCRIPTION, *PDEVICE_DESCRIPTION;
;
;//
;// Define the supported version numbers for the device description structure.
;//
;
;#define DEVICE_DESCRIPTION_VERSION 0
;#define DEVICE_DESCRIPTION_VERSION1 1
;
;//
;// The following function prototypes are for HAL routines with a prefix of Hal.
;//
;// General functions.
;//
;
;typedef
;BOOLEAN
;(*PHAL_RESET_DISPLAY_PARAMETERS) (
; IN ULONG Columns,
; IN ULONG Rows
; );
;
;NTHALAPI
;VOID
;HalAcquireDisplayOwnership (
; IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters
; );
;
;#if defined(_ALPHA_) || defined(_IA64_)
;
;NTHALAPI
;ULONG
;HalGetDmaAlignmentRequirement (
; VOID
; );
;
;#endif
;
;#if defined(_M_IX86)
;
;#define HalGetDmaAlignmentRequirement() 1L
;#endif
;
;NTHALAPI
;VOID
;KeFlushWriteBuffer (
; VOID
; );
;
;//
;// I/O driver configuration functions.
;//
;#if !defined(NO_LEGACY_DRIVERS)
;NTHALAPI
;NTSTATUS
;HalAssignSlotResources (
; IN PUNICODE_STRING RegistryPath,
; IN PUNICODE_STRING DriverClassName OPTIONAL,
; IN PDRIVER_OBJECT DriverObject,
; IN PDEVICE_OBJECT DeviceObject,
; IN INTERFACE_TYPE BusType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN OUT PCM_RESOURCE_LIST *AllocatedResources
; );
;
;NTHALAPI
;ULONG
;HalGetInterruptVector(
; IN INTERFACE_TYPE InterfaceType,
; IN ULONG BusNumber,
; IN ULONG BusInterruptLevel,
; IN ULONG BusInterruptVector,
; OUT PKIRQL Irql,
; OUT PKAFFINITY Affinity
; );
;
;NTHALAPI
;ULONG
;HalSetBusData(
; IN BUS_DATA_TYPE BusDataType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN PVOID Buffer,
; IN ULONG Length
; );
;#endif // NO_LEGACY_DRIVERS
;
;NTHALAPI
;ULONG
;HalSetBusDataByOffset(
; IN BUS_DATA_TYPE BusDataType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN PVOID Buffer,
; IN ULONG Offset,
; IN ULONG Length
; );
;
;NTHALAPI
;BOOLEAN
;HalTranslateBusAddress(
; IN INTERFACE_TYPE InterfaceType,
; IN ULONG BusNumber,
; IN PHYSICAL_ADDRESS BusAddress,
; IN OUT PULONG AddressSpace,
; OUT PPHYSICAL_ADDRESS TranslatedAddress
; );
;
;//
;// Values for AddressSpace parameter of HalTranslateBusAddress
;//
;// BUGBUG--figure out which flags should be added to resource descriptor structures
;//
;// 0x0 - Memory space
;// 0x1 - Port space
;// 0x2 - 0x1F - Address spaces specific for Alpha
;// 0x2 - UserMode view of memory space
;// 0x3 - UserMode view of port space
;// 0x4 - Dense memory space
;// 0x5 - reserved
;// 0x6 - UserMode view of dense memory space
;// 0x7 - 0x1F - reserved
;//
;
;NTHALAPI
;PVOID
;HalAllocateCrashDumpRegisters(
; IN PADAPTER_OBJECT AdapterObject,
; IN OUT PULONG NumberOfMapRegisters
; );
;
;#if !defined(NO_LEGACY_DRIVERS)
;NTHALAPI
;ULONG
;HalGetBusData(
; IN BUS_DATA_TYPE BusDataType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN PVOID Buffer,
; IN ULONG Length
; );
;#endif // NO_LEGACY_DRIVERS
;
;NTHALAPI
;ULONG
;HalGetBusDataByOffset(
; IN BUS_DATA_TYPE BusDataType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN PVOID Buffer,
; IN ULONG Offset,
; IN ULONG Length
; );
;
;NTHALAPI
;PADAPTER_OBJECT
;HalGetAdapter(
; IN PDEVICE_DESCRIPTION DeviceDescription,
; IN OUT PULONG NumberOfMapRegisters
; );
;
;//
;// System beep functions.
;//
;#if !defined(NO_LEGACY_DRIVERS)
;NTHALAPI
;BOOLEAN
;HalMakeBeep(
; IN ULONG Frequency
; );
;#endif // NO_LEGACY_DRIVERS
;
;//
;// The following function prototypes are for HAL routines with a prefix of Io.
;//
;// DMA adapter object functions.
;//
;
;
;
;#if defined(NO_LEGACY_DRIVERS)
;NTKERNELAPI
;NTSTATUS
;IoReadPartitionTable(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN BOOLEAN ReturnRecognizedPartitions,
; OUT struct _DRIVE_LAYOUT_INFORMATION **PartitionBuffer
; );
;
;NTKERNELAPI
;NTSTATUS
;IoSetPartitionInformation(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN ULONG PartitionNumber,
; IN ULONG PartitionType
; );
;
;NTKERNELAPI
;NTSTATUS
;IoWritePartitionTable(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN ULONG SectorsPerTrack,
; IN ULONG NumberOfHeads,
; IN struct _DRIVE_LAYOUT_INFORMATION *PartitionBuffer
; );
;
;#else
;NTHALAPI
;NTSTATUS
;IoReadPartitionTable(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN BOOLEAN ReturnRecognizedPartitions,
; OUT struct _DRIVE_LAYOUT_INFORMATION **PartitionBuffer
; );
;
;NTHALAPI
;NTSTATUS
;IoSetPartitionInformation(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN ULONG PartitionNumber,
; IN ULONG PartitionType
; );
;
;NTHALAPI
;NTSTATUS
;IoWritePartitionTable(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN ULONG SectorsPerTrack,
; IN ULONG NumberOfHeads,
; IN struct _DRIVE_LAYOUT_INFORMATION *PartitionBuffer
; );
;#endif // NO_LEGACY_DRIVERS
;
;//
;// Performance counter function.
;//
;
;NTHALAPI
;LARGE_INTEGER
;KeQueryPerformanceCounter (
; IN PLARGE_INTEGER PerformanceFrequency OPTIONAL
; );
;
;// begin_ntndis
;//
;// Stall processor execution function.
;//
;
;NTHALAPI
;VOID
;KeStallExecutionProcessor (
; IN ULONG MicroSeconds
; );
;
;
;typedef
;VOID
;(*PDEVICE_CONTROL_COMPLETION)(
; IN struct _DEVICE_CONTROL_CONTEXT *ControlContext
; );
;
;typedef struct _DEVICE_CONTROL_CONTEXT {
; NTSTATUS Status;
; PDEVICE_HANDLER_OBJECT DeviceHandler;
; PDEVICE_OBJECT DeviceObject;
; ULONG ControlCode;
; PVOID Buffer;
; PULONG BufferLength;
; PVOID Context;
;} DEVICE_CONTROL_CONTEXT, *PDEVICE_CONTROL_CONTEXT;
;
;typedef
;PBUS_HANDLER
;(FASTCALL *pHalHandlerForBus) (
; IN INTERFACE_TYPE InterfaceType,
; IN ULONG BusNumber
; );
;typedef
;VOID
;(FASTCALL *pHalReferenceBusHandler) (
; IN PBUS_HANDLER BusHandler
; );
;
;//*****************************************************************************
;// HAL Function dispatch
;//
;
;typedef enum _HAL_QUERY_INFORMATION_CLASS {
; HalInstalledBusInformation,
; HalProfileSourceInformation,
; HalInformationClassUnused1,
; HalPowerInformation,
; HalProcessorSpeedInformation,
; HalCallbackInformation,
; HalMapRegisterInformation,
; HalMcaLogInformation,
; HalFrameBufferCachingInformation,
; HalDisplayBiosInformation,
; HalProcessorFeatureInformation
; // information levels >= 0x8000000 reserved for OEM use
;} HAL_QUERY_INFORMATION_CLASS, *PHAL_QUERY_INFORMATION_CLASS;
;
;
;typedef enum _HAL_SET_INFORMATION_CLASS {
; HalProfileSourceInterval,
; HalProfileSourceInterruptHandler,
; HalMcaRegisterDriver
;} HAL_SET_INFORMATION_CLASS, *PHAL_SET_INFORMATION_CLASS;
;
;
;typedef
;NTSTATUS
;(*pHalQuerySystemInformation)(
; IN HAL_QUERY_INFORMATION_CLASS InformationClass,
; IN ULONG BufferSize,
; IN OUT PVOID Buffer,
; OUT PULONG ReturnedLength
; );
;
;NTSTATUS
;HaliQuerySystemInformation(
; IN HAL_SET_INFORMATION_CLASS InformationClass,
; IN ULONG BufferSize,
; IN OUT PVOID Buffer,
; OUT PULONG ReturnedLength
; );
;
;typedef
;NTSTATUS
;(*pHalSetSystemInformation)(
; IN HAL_SET_INFORMATION_CLASS InformationClass,
; IN ULONG BufferSize,
; IN PVOID Buffer
; );
;
;NTSTATUS
;HaliSetSystemInformation(
; IN HAL_SET_INFORMATION_CLASS InformationClass,
; IN ULONG BufferSize,
; IN PVOID Buffer
; );
;
;typedef
;VOID
;(FASTCALL *pHalExamineMBR)(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN ULONG MBRTypeIdentifier,
; OUT PVOID *Buffer
; );
;
;typedef
;VOID
;(FASTCALL *pHalIoAssignDriveLetters)(
; IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock,
; IN PSTRING NtDeviceName,
; OUT PUCHAR NtSystemPath,
; OUT PSTRING NtSystemPathString
; );
;
;typedef
;NTSTATUS
;(FASTCALL *pHalIoReadPartitionTable)(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN BOOLEAN ReturnRecognizedPartitions,
; OUT struct _DRIVE_LAYOUT_INFORMATION **PartitionBuffer
; );
;
;typedef
;NTSTATUS
;(FASTCALL *pHalIoSetPartitionInformation)(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN ULONG PartitionNumber,
; IN ULONG PartitionType
; );
;
;typedef
;NTSTATUS
;(FASTCALL *pHalIoWritePartitionTable)(
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG SectorSize,
; IN ULONG SectorsPerTrack,
; IN ULONG NumberOfHeads,
; IN struct _DRIVE_LAYOUT_INFORMATION *PartitionBuffer
; );
;
;typedef
;NTSTATUS
;(*pHalQueryBusSlots)(
; IN PBUS_HANDLER BusHandler,
; IN ULONG BufferSize,
; OUT PULONG SlotNumbers,
; OUT PULONG ReturnedLength
; );
;
;typedef
;NTSTATUS
;(*pHalInitPnpDriver)(
; VOID
; );
;
;NTSTATUS
;HaliInitPnpDriver(
; VOID
; );
;
;typedef struct _PM_DISPATCH_TABLE {
; ULONG Signature;
; ULONG Version;
; PVOID Function[1];
;} PM_DISPATCH_TABLE, *PPM_DISPATCH_TABLE;
;
;typedef
;NTSTATUS
;(*pHalInitPowerManagement)(
; IN PPM_DISPATCH_TABLE PmDriverDispatchTable,
; OUT PPM_DISPATCH_TABLE *PmHalDispatchTable
; );
;
;NTSTATUS
;HaliInitPowerManagement(
; IN PPM_DISPATCH_TABLE PmDriverDispatchTable,
; IN OUT PPM_DISPATCH_TABLE *PmHalDispatchTable
; );
;
;typedef
;struct _DMA_ADAPTER *
;(*pHalGetDmaAdapter)(
; IN PVOID Context,
; IN struct _DEVICE_DESCRIPTION *DeviceDescriptor,
; OUT PULONG NumberOfMapRegisters
; );
;
;struct _DMA_ADAPTER *
;HaliGetDmaAdapter(
; IN PVOID Context,
; IN struct _DEVICE_DESCRIPTION *DeviceDescriptor,
; OUT PULONG NumberOfMapRegisters
; );
;
;typedef
;NTSTATUS
;(*pHalGetInterruptTranslator)(
; IN INTERFACE_TYPE ParentInterfaceType,
; IN ULONG ParentBusNumber,
; IN INTERFACE_TYPE BridgeInterfaceType,
; IN USHORT Size,
; IN USHORT Version,
; OUT PTRANSLATOR_INTERFACE Translator,
; OUT PULONG BridgeBusNumber
; );
;
;NTSTATUS
;HaliGetInterruptTranslator(
; IN INTERFACE_TYPE ParentInterfaceType,
; IN ULONG ParentBusNumber,
; IN INTERFACE_TYPE BridgeInterfaceType,
; IN USHORT Size,
; IN USHORT Version,
; OUT PTRANSLATOR_INTERFACE Translator,
; OUT PULONG BridgeBusNumber
; );
;
;typedef
;BOOLEAN
;(*pHalTranslateBusAddress)(
; IN INTERFACE_TYPE InterfaceType,
; IN ULONG BusNumber,
; IN PHYSICAL_ADDRESS BusAddress,
; IN OUT PULONG AddressSpace,
; OUT PPHYSICAL_ADDRESS TranslatedAddress
; );
;
;typedef
;NTSTATUS
;(*pHalAssignSlotResources) (
; IN PUNICODE_STRING RegistryPath,
; IN PUNICODE_STRING DriverClassName OPTIONAL,
; IN PDRIVER_OBJECT DriverObject,
; IN PDEVICE_OBJECT DeviceObject,
; IN INTERFACE_TYPE BusType,
; IN ULONG BusNumber,
; IN ULONG SlotNumber,
; IN OUT PCM_RESOURCE_LIST *AllocatedResources
; );
;
;typedef
;VOID
;(*pHalHaltSystem) (
; VOID
; );
;
;typedef
;VOID
;(*pHalResetDisplay) (
; VOID
; );
;
;typedef
;BOOLEAN
;(*pHalFindBusAddressTranslation) (
; IN PHYSICAL_ADDRESS BusAddress,
; IN OUT PULONG AddressSpace,
; OUT PPHYSICAL_ADDRESS TranslatedAddress,
; IN OUT PULONG_PTR Context,
; IN BOOLEAN NextBus
; );
;
;typedef struct {
; ULONG Version;
; pHalQuerySystemInformation HalQuerySystemInformation;
; pHalSetSystemInformation HalSetSystemInformation;
; pHalQueryBusSlots HalQueryBusSlots;
; ULONG Spare1;
; pHalExamineMBR HalExamineMBR;
; pHalIoAssignDriveLetters HalIoAssignDriveLetters;
; pHalIoReadPartitionTable HalIoReadPartitionTable;
; pHalIoSetPartitionInformation HalIoSetPartitionInformation;
; pHalIoWritePartitionTable HalIoWritePartitionTable;
;
; pHalHandlerForBus HalReferenceHandlerForBus;
; pHalReferenceBusHandler HalReferenceBusHandler;
; pHalReferenceBusHandler HalDereferenceBusHandler;
;
; pHalInitPnpDriver HalInitPnpDriver;
; pHalInitPowerManagement HalInitPowerManagement;
;
; pHalGetDmaAdapter HalGetDmaAdapter;
; pHalGetInterruptTranslator HalGetInterruptTranslator;
;} HAL_DISPATCH, *PHAL_DISPATCH;
;
;#if defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_)
;
;extern PHAL_DISPATCH HalDispatchTable;
;#define HALDISPATCH HalDispatchTable
;
;#else
;
;extern HAL_DISPATCH HalDispatchTable;
;#define HALDISPATCH (&HalDispatchTable)
;
;#endif
;
;#define HAL_DISPATCH_VERSION 2
;
;#define HalDispatchTableVersion HALDISPATCH->Version
;#define HalQuerySystemInformation HALDISPATCH->HalQuerySystemInformation
;#define HalSetSystemInformation HALDISPATCH->HalSetSystemInformation
;#define HalQueryBusSlots HALDISPATCH->HalQueryBusSlots
;#define HalExamineMBR HALDISPATCH->HalExamineMBR
;#define HalIoAssignDriveLetters HALDISPATCH->HalIoAssignDriveLetters
;#define HalIoReadPartitionTable HALDISPATCH->HalIoReadPartitionTable
;#define HalIoSetPartitionInformation HALDISPATCH->HalIoSetPartitionInformation
;#define HalIoWritePartitionTable HALDISPATCH->HalIoWritePartitionTable
;
;#define HalReferenceHandlerForBus HALDISPATCH->HalReferenceHandlerForBus
;#define HalReferenceBusHandler HALDISPATCH->HalReferenceBusHandler
;#define HalDereferenceBusHandler HALDISPATCH->HalDereferenceBusHandler
;
;#define HalInitPnpDriver HALDISPATCH->HalInitPnpDriver
;#define HalInitPowerManagement HALDISPATCH->HalInitPowerManagement
;
;#define HalGetDmaAdapter HALDISPATCH->HalGetDmaAdapter
;#define HalGetInterruptTranslator HALDISPATCH->HalGetInterruptTranslator
;
;//
;// HAL System Information Structures.
;//
;
;// for the information class "HalInstalledBusInformation"
;typedef struct _HAL_BUS_INFORMATION{
; INTERFACE_TYPE BusType;
; BUS_DATA_TYPE ConfigurationType;
; ULONG BusNumber;
; ULONG Reserved;
;} HAL_BUS_INFORMATION, *PHAL_BUS_INFORMATION;
;
;// for the information class "HalProfileSourceInformation"
;typedef struct _HAL_PROFILE_SOURCE_INFORMATION {
; KPROFILE_SOURCE Source;
; BOOLEAN Supported;
; ULONG Interval;
;} HAL_PROFILE_SOURCE_INFORMATION, *PHAL_PROFILE_SOURCE_INFORMATION;
;
;// for the information class "HalProfileSourceInterval"
;typedef struct _HAL_PROFILE_SOURCE_INTERVAL {
; KPROFILE_SOURCE Source;
; ULONG_PTR Interval;
;} HAL_PROFILE_SOURCE_INTERVAL, *PHAL_PROFILE_SOURCE_INTERVAL;
;
;// for the information class "HalDispayBiosInformation"
;typedef enum _HAL_DISPLAY_BIOS_INFORMATION {
; HalDisplayInt10Bios,
; HalDisplayEmulatedBios,
; HalDisplayNoBios
;} HAL_DISPLAY_BIOS_INFORMATION, *PHAL_DISPLAY_BIOS_INFORMATION;
;
;// for the information class "HalPowerInformation"
;typedef struct _HAL_POWER_INFORMATION {
; ULONG TBD;
;} HAL_POWER_INFORMATION, *PHAL_POWER_INFORMATION;
;
;// for the information class "HalProcessorSpeedInformation"
;typedef struct _HAL_PROCESSOR_SPEED_INFO {
; ULONG TBD;
;} HAL_PROCESSOR_SPEED_INFORMATION, *PHAL_PROCESSOR_SPEED_INFORMATION;
;
;// for the information class "HalCallbackInformation"
;typedef struct _HAL_CALLBACKS {
; PCALLBACK_OBJECT SetSystemInformation;
; PCALLBACK_OBJECT BusCheck;
;} HAL_CALLBACKS, *PHAL_CALLBACKS;
;
;// for the information class "HalProcessorFeatureInformation"
;typedef struct _HAL_PROCESSOR_FEATURE {
; ULONG UsableFeatureBits;
;} HAL_PROCESSOR_FEATURE;
;
;#if defined(_X86_) || defined(_IA64_)
;
;// for the information class "HalMcaLogInformation"
;
;//
;// ADDR register for each MCA bank
;//
;
;typedef union _MCI_ADDR{
; struct {
; ULONG Address;
; ULONG Reserved;
; };
;
; ULONGLONG QuadPart;
;} MCI_ADDR, *PMCI_ADDR;
;
;
;typedef enum {
; HAL_MCE_RECORD,
; HAL_MCA_RECORD
;} MCA_EXCEPTION_TYPE;
;
;//
;// MCA exception log entry
;// Defined as a union to contain MCA specific log or Pentium style MCE info.
;//
;
;typedef struct _MCA_EXCEPTION {
;
; ULONG VersionNumber; // Version number of this record type
; MCA_EXCEPTION_TYPE ExceptionType; // MCA or MCE
; LARGE_INTEGER TimeStamp; // exception recording timestamp
; ULONG ProcessorNumber;
;
; union {
; struct {
; UCHAR BankNumber;
; MCI_STATS Status;
; MCI_ADDR Address;
; ULONGLONG Misc;
; } Mca;
;
; struct {
; ULONGLONG Address; // physical addr of cycle causing the error
; ULONGLONG Type; // cycle specification causing the error
; } Mce;
; } u;
;
;} MCA_EXCEPTION, *PMCA_EXCEPTION;
;
;
;// for the information class "HalMcaRegisterDriver"
;
;typedef
;VOID
;(*PDRIVER_EXCPTN_CALLBACK) (
; IN PVOID Context,
; IN PMCA_EXCEPTION BankLog
;);
;
;//
;// Structure to record the callbacks from driver
;//
;typedef struct _MCA_DRIVER_INFO {
; PDRIVER_EXCPTN_CALLBACK ExceptionCallback;
; PKDEFERRED_ROUTINE DpcCallback;
; PVOID DeviceContext;
;} MCA_DRIVER_INFO, *PMCA_DRIVER_INFO;
;
;#endif
;
;// begin_wdm begin_ntndis
;
;typedef struct _SCATTER_GATHER_ELEMENT {
; PHYSICAL_ADDRESS Address;
; ULONG Length;
; ULONG_PTR Reserved;
;} SCATTER_GATHER_ELEMENT, *PSCATTER_GATHER_ELEMENT;
;
;#pragma warning(disable:4200)
;typedef struct _SCATTER_GATHER_LIST {
; ULONG NumberOfElements;
; ULONG_PTR Reserved;
; SCATTER_GATHER_ELEMENT Elements[];
;} SCATTER_GATHER_LIST, *PSCATTER_GATHER_LIST;
;#pragma warning(default:4200)
;
;// end_ntndis
;
;typedef struct _DMA_OPERATIONS *PDMA_OPERATIONS;
;
;typedef struct _DMA_ADAPTER {
; USHORT Version;
; USHORT Size;
; PDMA_OPERATIONS DmaOperations;
; // Private Bus Device Driver data follows,
;} DMA_ADAPTER, *PDMA_ADAPTER;
;
;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_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,
; IN OUT PULONG Length,
; IN BOOLEAN WriteToDevice
; );
;
;typedef ULONG (*PGET_DMA_ALIGNMENT)(
; IN PDMA_ADAPTER DmaAdapter
; );
;
;typedef ULONG (*PREAD_DMA_COUNTER)(
; IN PDMA_ADAPTER DmaAdapter
; );
;
;typedef VOID
;(*PDRIVER_LIST_CONTROL)(
; IN struct _DEVICE_OBJECT *DeviceObject,
; IN struct _IRP *Irp,
; IN PSCATTER_GATHER_LIST ScatterGather,
; IN PVOID Context
; );
;
;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 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;
;} DMA_OPERATIONS;
;
;// end_wdm
;
;
;#if defined(_AXP64_)
;
;//
;// 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 // _AXP64_
;
;
;#if defined(USE_DMA_MACROS) && (defined(_NTDDK_) || defined(_NTDRIVER_))
;
;// begin_wdm
;
;__inline
;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;
; ASSERT( allocateCommonBuffer != NULL );
;
; commonBuffer = allocateCommonBuffer( DmaAdapter,
; Length,
; LogicalAddress,
; CacheEnabled );
;
; return commonBuffer;
;}
;
;__inline
;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;
; ASSERT( freeCommonBuffer != NULL );
;
; freeCommonBuffer( DmaAdapter,
; Length,
; LogicalAddress,
; VirtualAddress,
; CacheEnabled );
;}
;
;__inline
;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;
;
; ASSERT( allocateAdapterChannel != NULL );
;
; status = allocateAdapterChannel( DmaAdapter,
; DeviceObject,
; NumberOfMapRegisters,
; ExecutionRoutine,
; Context );
;
; return status;
;}
;
;__inline
;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;
; ASSERT( flushAdapterBuffers != NULL );
;
; result = flushAdapterBuffers( DmaAdapter,
; Mdl,
; MapRegisterBase,
; CurrentVa,
; Length,
; WriteToDevice );
; return result;
;}
;
;__inline
;VOID
;IoFreeAdapterChannel(
; IN PDMA_ADAPTER DmaAdapter
; ){
;
; PFREE_ADAPTER_CHANNEL freeAdapterChannel;
;
; freeAdapterChannel = *(DmaAdapter)->DmaOperations->FreeAdapterChannel;
; ASSERT( freeAdapterChannel != NULL );
;
; freeAdapterChannel( DmaAdapter );
;}
;
;__inline
;VOID
;IoFreeMapRegisters(
; IN PDMA_ADAPTER DmaAdapter,
; IN PVOID MapRegisterBase,
; IN ULONG NumberOfMapRegisters
; ){
;
; PFREE_MAP_REGISTERS freeMapRegisters;
;
; freeMapRegisters = *(DmaAdapter)->DmaOperations->FreeMapRegisters;
; ASSERT( freeMapRegisters != NULL );
;
; freeMapRegisters( DmaAdapter,
; MapRegisterBase,
; NumberOfMapRegisters );
;}
;
;
;__inline
;PHYSICAL_ADDRESS
;IoMapTransfer(
; IN PDMA_ADAPTER DmaAdapter,
; IN PMDL Mdl,
; IN PVOID MapRegisterBase,
; IN PVOID CurrentVa,
; IN OUT PULONG Length,
; IN BOOLEAN WriteToDevice
; ){
;
; PHYSICAL_ADDRESS physicalAddress;
; PMAP_TRANSFER mapTransfer;
;
; mapTransfer = *(DmaAdapter)->DmaOperations->MapTransfer;
; ASSERT( mapTransfer != NULL );
;
; physicalAddress = mapTransfer( DmaAdapter,
; Mdl,
; MapRegisterBase,
; CurrentVa,
; Length,
; WriteToDevice );
;
; return physicalAddress;
;}
;
;__inline
;ULONG
;HalGetDmaAlignment(
; IN PDMA_ADAPTER DmaAdapter
; )
;{
; PGET_DMA_ALIGNMENT getDmaAlignment;
; ULONG alignment;
;
; getDmaAlignment = *(DmaAdapter)->DmaOperations->GetDmaAlignment;
; ASSERT( getDmaAlignment != NULL );
;
; alignment = getDmaAlignment( DmaAdapter );
; return alignment;
;}
;
;__inline
;ULONG
;HalReadDmaCounter(
; IN PDMA_ADAPTER DmaAdapter
; )
;{
; PREAD_DMA_COUNTER readDmaCounter;
; ULONG counter;
;
; readDmaCounter = *(DmaAdapter)->DmaOperations->ReadDmaCounter;
; ASSERT( readDmaCounter != NULL );
;
; counter = readDmaCounter( DmaAdapter );
; return counter;
;}
;
;// end_wdm
;
;#else
;
;//
;// DMA adapter object functions.
;//
;NTHALAPI
;NTSTATUS
;HalAllocateAdapterChannel(
; IN PADAPTER_OBJECT AdapterObject,
; IN PWAIT_CONTEXT_BLOCK Wcb,
; IN ULONG NumberOfMapRegisters,
; IN PDRIVER_CONTROL ExecutionRoutine
; );
;
;NTHALAPI
;PVOID
;HalAllocateCommonBuffer(
; IN PADAPTER_OBJECT AdapterObject,
; IN ULONG Length,
; OUT PPHYSICAL_ADDRESS LogicalAddress,
; IN BOOLEAN CacheEnabled
; );
;
;NTHALAPI
;VOID
;HalFreeCommonBuffer(
; IN PADAPTER_OBJECT AdapterObject,
; IN ULONG Length,
; IN PHYSICAL_ADDRESS LogicalAddress,
; IN PVOID VirtualAddress,
; IN BOOLEAN CacheEnabled
; );
;
;NTHALAPI
;ULONG
;HalReadDmaCounter(
; IN PADAPTER_OBJECT AdapterObject
; );
;
;NTHALAPI
;BOOLEAN
;IoFlushAdapterBuffers(
; IN PADAPTER_OBJECT AdapterObject,
; IN PMDL Mdl,
; IN PVOID MapRegisterBase,
; IN PVOID CurrentVa,
; IN ULONG Length,
; IN BOOLEAN WriteToDevice
; );
;
;NTHALAPI
;VOID
;IoFreeAdapterChannel(
; IN PADAPTER_OBJECT AdapterObject
; );
;
;NTHALAPI
;VOID
;IoFreeMapRegisters(
; IN PADAPTER_OBJECT AdapterObject,
; IN PVOID MapRegisterBase,
; IN ULONG NumberOfMapRegisters
; );
;
;NTHALAPI
;PHYSICAL_ADDRESS
;IoMapTransfer(
; IN PADAPTER_OBJECT AdapterObject,
; IN PMDL Mdl,
; IN PVOID MapRegisterBase,
; IN PVOID CurrentVa,
; IN OUT PULONG Length,
; IN BOOLEAN WriteToDevice
; );
;#endif // USE_DMA_MACROS && (_NTDDK_ || _NTDRIVER_)
;
;NTSTATUS
;HalGetScatterGatherList (
; IN PADAPTER_OBJECT 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
; );
;
;VOID
;HalPutScatterGatherList (
; IN PADAPTER_OBJECT DmaAdapter,
; IN PSCATTER_GATHER_LIST ScatterGather,
; IN BOOLEAN WriteToDevice
; );
;
;VOID
;HalPutDmaAdapter(
; IN PADAPTER_OBJECT DmaAdapter
; );
;
;
;NTKERNELAPI
;VOID
;PoSetSystemState (
; IN EXECUTION_STATE Flags
; );
;
;NTKERNELAPI
;PVOID
;PoRegisterSystemState (
; IN PVOID StateHandle,
; IN EXECUTION_STATE Flags
; );
;
;typedef
;VOID
;(*PREQUEST_POWER_COMPLETE) (
; IN PDEVICE_OBJECT DeviceObject,
; IN UCHAR MinorFunction,
; IN POWER_STATE PowerState,
; IN PVOID Context,
; IN PIO_STATUS_BLOCK IoStatus
; );
;
;NTKERNELAPI
;NTSTATUS
;PoRequestPowerIrp (
; IN PDEVICE_OBJECT DeviceObject,
; IN UCHAR MinorFunction,
; IN POWER_STATE PowerState,
; IN PREQUEST_POWER_COMPLETE CompletionFunction,
; IN PVOID Context,
; OUT PIRP *Irp OPTIONAL
; );
;
;NTKERNELAPI
;VOID
;PoUnregisterSystemState (
; IN PVOID StateHandle
; );
;
;
;NTKERNELAPI
;POWER_STATE
;PoSetPowerState (
; IN PDEVICE_OBJECT DeviceObject,
; IN POWER_STATE_TYPE Type,
; IN POWER_STATE State
; );
;
;NTKERNELAPI
;NTSTATUS
;PoCallDriver (
; IN PDEVICE_OBJECT DeviceObject,
; IN OUT PIRP Irp
; );
;
;NTKERNELAPI
;VOID
;PoStartNextPowerIrp(
; IN PIRP Irp
; );
;
;
;NTKERNELAPI
;PULONG
;PoRegisterDeviceForIdleDetection (
; IN PDEVICE_OBJECT DeviceObject,
; IN ULONG ConservationIdleTime,
; IN ULONG PerformanceIdleTime,
; IN DEVICE_POWER_STATE State
; );
;
;#define PoSetDeviceBusy(IdlePointer) \
; *IdlePointer = 0
;
;//
;// \Callback\PowerState values
;//
;
;#define PO_CB_SYSTEM_POWER_POLICY 0
;#define PO_CB_AC_STATUS 1
;#define PO_CB_BUTTON_COLLISION 2
;#define PO_CB_SYSTEM_STATE_LOCK 3
;
;
;//
;// Determine if there is a complete device failure on an error.
;//
;
;NTKERNELAPI
;BOOLEAN
;FsRtlIsTotalDeviceFailure(
; IN NTSTATUS Status
; );
;
;//
;// Object Manager types
;//
;
;typedef struct _OBJECT_HANDLE_INFORMATION {
; ULONG HandleAttributes;
; ACCESS_MASK GrantedAccess;
;} OBJECT_HANDLE_INFORMATION, *POBJECT_HANDLE_INFORMATION;
;
;NTKERNELAPI
;NTSTATUS
;ObReferenceObjectByHandle(
; IN HANDLE Handle,
; IN ACCESS_MASK DesiredAccess,
; IN POBJECT_TYPE ObjectType OPTIONAL,
; IN KPROCESSOR_MODE AccessMode,
; OUT PVOID *Object,
; OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL
; );
;
;#define ObDereferenceObject(a) \
; ObfDereferenceObject(a)
;
;#define ObReferenceObject(Object) ObfReferenceObject(Object)
;
;NTKERNELAPI
;VOID
;FASTCALL
;ObfReferenceObject(
; IN PVOID Object
; );
;
;
;NTKERNELAPI
;NTSTATUS
;ObReferenceObjectByPointer(
; IN PVOID Object,
; IN ACCESS_MASK DesiredAccess,
; IN POBJECT_TYPE ObjectType,
; IN KPROCESSOR_MODE AccessMode
; );
;
;NTKERNELAPI
;VOID
;FASTCALL
;ObfDereferenceObject(
; IN PVOID Object
; );
;
;NTSTATUS
;ObGetObjectSecurity(
; IN PVOID Object,
; OUT PSECURITY_DESCRIPTOR *SecurityDescriptor,
; OUT PBOOLEAN MemoryAllocated
; );
;
;VOID
;ObReleaseObjectSecurity(
; IN PSECURITY_DESCRIPTOR SecurityDescriptor,
; IN BOOLEAN MemoryAllocated
; );
;
;//
;// 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).
;//
;//
;
;// begin_wdm begin_ntminiport begin_ntndis
;
;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_CONFIG {
; 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;
;
;// end_wdm end_ntminiport end_ntndis
;
; //
; // 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;
;
;// begin_wdm begin_ntminiport begin_ntndis
;
; } u;
;
; UCHAR DeviceSpecific[192];
;
;} PCI_COMMON_CONFIG, *PPCI_COMMON_CONFIG;
;
;
;#define PCI_COMMON_HDR_LENGTH (FIELD_OFFSET (PCI_COMMON_CONFIG, DeviceSpecific))
;
;#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)
;
;//
;// Bit encodings for PCI_COMMON_CONFIG.Status
;//
;
;#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
;
;// end_wdm
;//
;// PCI Capability IDs
;//
;
;#define PCI_CAPABILITY_ID_POWER_MANAGEMENT 0x01
;#define PCI_CAPABILITY_ID_AGP 0x02
;#define PCI_CAPABILITY_ID_MSI 0x05
;
;//
;// 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:6;
; 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;
;
;//
;// AGP Capability
;//
;
;typedef struct _PCI_AGP_CAPABILITY {
;
; PCI_CAPABILITIES_HEADER Header;
;
; USHORT Minor:4;
; USHORT Major:4;
; USHORT Rsvd1:8;
;
; struct _PCI_AGP_STATUS {
; ULONG Rate:3;
; ULONG Rsvd1:1;
; ULONG FastWrite:1;
; ULONG FourGB:1;
; ULONG Rsvd2:3;
; ULONG SideBandAddressing:1; // SBA
; ULONG Rsvd3:14;
; ULONG RequestQueueDepthMaximum:8; // RQ
; } AGPStatus;
;
; struct _PCI_AGP_COMMAND {
; ULONG Rate:3;
; ULONG Rsvd1:1;
; ULONG FastWriteEnable:1;
; ULONG FourGBEnable:1;
; ULONG Rsvd2:2;
; ULONG AGPEnable:1;
; ULONG SBAEnable:1;
; ULONG Rsvd3:14;
; ULONG RequestQueueDepth:8;
; } AGPCommand;
;
;} PCI_AGP_CAPABILITY, *PPCI_AGP_CAPABILITY;
;
;#define PCI_AGP_RATE_1X 0x1
;#define PCI_AGP_RATE_2X 0x2
;#define PCI_AGP_RATE_4X 0x4
;
;//
;// MSI (Message Signalled Interrupts) Capability
;//
;
;typedef struct _PCI_MSI_CAPABILITY {
;
; PCI_CAPABILITIES_HEADER Header;
;
; struct _PCI_MSI_MESSAGE_CONTROL {
; USHORT MSIEnable:1;
; USHORT MultipleMessageCapable:3;
; USHORT MultipleMessageEnable:3;
; USHORT CapableOf64Bits:1;
; USHORT Reserved:8;
; } MessageControl;
;
; union {
; struct _PCI_MSI_MESSAGE_ADDRESS {
; ULONG_PTR Reserved:2; // always zero, DWORD aligned address
; ULONG_PTR Address:30;
; } Register;
; ULONG_PTR Raw;
; } MessageAddress;
;
; //
; // The rest of the Capability structure differs depending on whether
; // 32bit or 64bit addressing is being used.
; //
; // (The CapableOf64Bits bit above determines this)
; //
;
; union {
;
; // For 64 bit devices
;
; struct _PCI_MSI_64BIT_DATA {
; ULONG MessageUpperAddress;
; USHORT MessageData;
; } Bit64;
;
; // For 32 bit devices
;
; struct _PCI_MSI_32BIT_DATA {
; USHORT MessageData;
; ULONG Unused;
; } Bit32;
; } Data;
;
;} PCI_MSI_CAPABILITY, *PPCI_PCI_CAPABILITY;
;
;// begin_wdm
;//
;// 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
;
;// 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_OTHER 0x80
;
;// 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_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_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_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_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_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_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_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
;
;
;// end_ntndis
;
;//
;// 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.
;//
;
;// end_ntminiport
;
;
;//
;// Portable portion of HAL & HAL bus extender definitions for BUSHANDLER
;// BusData for installed PCI buses.
;//
;
;typedef VOID
;(*PciPin2Line) (
; IN struct _BUS_HANDLER *BusHandler,
; IN struct _BUS_HANDLER *RootHandler,
; IN PCI_SLOT_NUMBER SlotNumber,
; IN PPCI_COMMON_CONFIG PciData
; );
;
;typedef VOID
;(*PciLine2Pin) (
; IN struct _BUS_HANDLER *BusHandler,
; IN struct _BUS_HANDLER *RootHandler,
; IN PCI_SLOT_NUMBER SlotNumber,
; IN PPCI_COMMON_CONFIG PciNewData,
; IN PPCI_COMMON_CONFIG PciOldData
; );
;
;typedef VOID
;(*PciReadWriteConfig) (
; IN struct _BUS_HANDLER *BusHandler,
; IN PCI_SLOT_NUMBER Slot,
; IN PVOID Buffer,
; IN ULONG Offset,
; IN ULONG Length
; );
;
;#define PCI_DATA_TAG ' ICP'
;#define PCI_DATA_VERSION 1
;
;typedef struct _PCIBUSDATA {
; ULONG Tag;
; ULONG Version;
; PciReadWriteConfig ReadConfig;
; PciReadWriteConfig WriteConfig;
; PciPin2Line Pin2Line;
; PciLine2Pin Line2Pin;
; PCI_SLOT_NUMBER ParentSlot;
; PVOID Reserved[4];
;} PCIBUSDATA, *PPCIBUSDATA;
;
;typedef ULONG (*PCI_READ_WRITE_CONFIG)(
; IN PVOID Context,
; IN UCHAR BusOffset,
; IN ULONG Slot,
; IN PVOID Buffer,
; IN ULONG Offset,
; IN ULONG Length
; );
;
;typedef VOID (*PCI_PIN_TO_LINE)(
; IN PVOID Context,
; IN PPCI_COMMON_CONFIG PciData
; );
;
;typedef VOID (*PCI_LINE_TO_PIN)(
; IN PVOID Context,
; IN PPCI_COMMON_CONFIG PciNewData,
; IN PPCI_COMMON_CONFIG PciOldData
; );
;
;typedef struct _PCI_BUS_INTERFACE_STANDARD {
; //
; // generic interface header
; //
; USHORT Size;
; USHORT Version;
; PVOID Context;
; PINTERFACE_REFERENCE InterfaceReference;
; PINTERFACE_DEREFERENCE InterfaceDereference;
; //
; // standard PCI bus interfaces
; //
; PCI_READ_WRITE_CONFIG ReadConfig;
; PCI_READ_WRITE_CONFIG WriteConfig;
; PCI_PIN_TO_LINE PinToLine;
; PCI_LINE_TO_PIN LineToPin;
;} PCI_BUS_INTERFACE_STANDARD, *PPCI_BUS_INTERFACE_STANDARD;
;
;#define PCI_BUS_INTERFACE_STANDARD_VERSION 1
;
;#define PCI_DEVICE_PRESENT_INTERFACE_VERSION 1
;
;typedef
;BOOLEAN
;(*PPCI_IS_DEVICE_PRESENT) (
; IN USHORT VendorID,
; IN USHORT DeviceID,
; IN UCHAR RevisionID,
; IN USHORT SubVendorID,
; IN USHORT SubSystemID,
; IN ULONG Flags
;);
;
;#define PCI_USE_SUBSYSTEM_IDS 0x00000001
;#define PCI_USE_REVISION 0x00000002
;
;
;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;
;} PCI_DEVICE_PRESENT_INTERFACE, *PPCI_DEVICE_PRESENT_INTERFACE;
;
;
;
;
;#ifdef POOL_TAGGING
;#define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,' kdD')
;#define ExAllocatePoolWithQuota(a,b) ExAllocatePoolWithQuotaTag(a,b,' kdD')
;#endif
;
;extern POBJECT_TYPE *IoFileObjectType;
;extern POBJECT_TYPE *ExEventObjectType;
;extern POBJECT_TYPE *ExSemaphoreObjectType;
Reference in New Issue View Git Blame Copy Permalink