9482 lines
230 KiB
C
9482 lines
230 KiB
C
/*++ BUILD Version: 0095 // Increment this if a change has global effects
|
||
|
||
Copyright (c) 1990-1999 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
ntddk.h
|
||
|
||
Abstract:
|
||
|
||
This module defines the NT types, constants, and functions that are
|
||
exposed to device drivers.
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#ifndef _NTDDK_
|
||
#define _NTDDK_
|
||
|
||
#define NT_INCLUDED
|
||
#define _CTYPE_DISABLE_MACROS
|
||
|
||
#include <wdmwarn4.h>
|
||
#include <excpt.h>
|
||
#include <ntdef.h>
|
||
#include <ntstatus.h>
|
||
#include <bugcodes.h>
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" { // extern "C"
|
||
#endif
|
||
|
||
//
|
||
// Define types that are not exported.
|
||
//
|
||
|
||
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;
|
||
|
||
#if defined(_M_ALPHA)
|
||
void *__rdthread(void);
|
||
#pragma intrinsic(__rdthread)
|
||
|
||
unsigned char __swpirql(unsigned char);
|
||
#pragma intrinsic(__swpirql)
|
||
|
||
void *__rdpcr(void);
|
||
#pragma intrinsic(__rdpcr)
|
||
#define PCR ((PKPCR)__rdpcr())
|
||
|
||
#define KeGetCurrentThread() ((struct _KTHREAD *) __rdthread())
|
||
#endif // defined(_M_ALPHA)
|
||
|
||
#if defined(_M_IX86)
|
||
PKTHREAD NTAPI KeGetCurrentThread();
|
||
#endif // defined(_M_IX86)
|
||
|
||
#if defined(_M_IA64)
|
||
|
||
//
|
||
// Define Address of Processor Control Registers.
|
||
//
|
||
|
||
#define KIPCR ((ULONG_PTR)(KADDRESS_BASE + 0xffff0000)) // kernel address of first PCR
|
||
|
||
//
|
||
// Define Pointer to Processor Control Registers.
|
||
//
|
||
|
||
#define PCR ((volatile KPCR * const)KIPCR)
|
||
|
||
PKTHREAD NTAPI KeGetCurrentThread();
|
||
|
||
#endif // defined(_M_IA64)
|
||
|
||
#define PsGetCurrentProcess() IoGetCurrentProcess()
|
||
#define PsGetCurrentThread() ((PETHREAD) (KeGetCurrentThread()))
|
||
extern PCCHAR KeNumberProcessors;
|
||
|
||
#ifndef FAR
|
||
#define FAR
|
||
#endif
|
||
|
||
typedef union _SLIST_HEADER {
|
||
ULONGLONG Alignment;
|
||
struct {
|
||
SINGLE_LIST_ENTRY Next;
|
||
USHORT Depth;
|
||
USHORT Sequence;
|
||
};
|
||
} SLIST_HEADER, *PSLIST_HEADER;
|
||
|
||
|
||
//
|
||
// 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
|
||
//
|
||
|
||
//
|
||
// APC function types
|
||
//
|
||
|
||
//
|
||
// Put in an empty definition for the KAPC so that the
|
||
// routines can reference it before it is declared.
|
||
//
|
||
|
||
struct _KAPC;
|
||
|
||
typedef
|
||
VOID
|
||
(*PKNORMAL_ROUTINE) (
|
||
IN PVOID NormalContext,
|
||
IN PVOID SystemArgument1,
|
||
IN PVOID SystemArgument2
|
||
);
|
||
|
||
typedef
|
||
VOID
|
||
(*PKKERNEL_ROUTINE) (
|
||
IN struct _KAPC *Apc,
|
||
IN OUT PKNORMAL_ROUTINE *NormalRoutine,
|
||
IN OUT PVOID *NormalContext,
|
||
IN OUT PVOID *SystemArgument1,
|
||
IN OUT PVOID *SystemArgument2
|
||
);
|
||
|
||
typedef
|
||
VOID
|
||
(*PKRUNDOWN_ROUTINE) (
|
||
IN struct _KAPC *Apc
|
||
);
|
||
|
||
typedef
|
||
BOOLEAN
|
||
(*PKSYNCHRONIZE_ROUTINE) (
|
||
IN PVOID SynchronizeContext
|
||
);
|
||
|
||
typedef
|
||
BOOLEAN
|
||
(*PKTRANSFER_ROUTINE) (
|
||
VOID
|
||
);
|
||
|
||
//
|
||
//
|
||
// Asynchronous Procedure Call (APC) object
|
||
//
|
||
|
||
typedef struct _KAPC {
|
||
CSHORT Type;
|
||
KPROCESSOR_MODE ApcMode;
|
||
BOOLEAN Inserted;
|
||
struct _KTHREAD *Thread;
|
||
LIST_ENTRY ApcListEntry;
|
||
PKKERNEL_ROUTINE KernelRoutine;
|
||
PKRUNDOWN_ROUTINE RundownRoutine;
|
||
PKNORMAL_ROUTINE NormalRoutine;
|
||
PVOID NormalContext;
|
||
|
||
//
|
||
// N.B. The following two members MUST be together.
|
||
//
|
||
|
||
PVOID SystemArgument1;
|
||
PVOID SystemArgument2;
|
||
} KAPC, *PKAPC, *RESTRICTED_POINTER PRKAPC;
|
||
|
||
// begin_ntndis
|
||
//
|
||
// DPC routine
|
||
//
|
||
|
||
struct _KDPC;
|
||
|
||
typedef
|
||
VOID
|
||
(*PKDEFERRED_ROUTINE) (
|
||
IN struct _KDPC *Dpc,
|
||
IN PVOID DeferredContext,
|
||
IN PVOID SystemArgument1,
|
||
IN PVOID SystemArgument2
|
||
);
|
||
|
||
//
|
||
// Deferred Procedure Call (DPC) object
|
||
//
|
||
|
||
typedef struct _KDPC {
|
||
CSHORT Type;
|
||
BOOLEAN Inserted;
|
||
UCHAR Padding;
|
||
LIST_ENTRY DpcListEntry;
|
||
PKDEFERRED_ROUTINE DeferredRoutine;
|
||
PVOID DeferredContext;
|
||
PVOID SystemArgument1;
|
||
PVOID SystemArgument2;
|
||
} KDPC, *PKDPC, *RESTRICTED_POINTER PRKDPC;
|
||
|
||
// 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(_NTSYSTEM_)
|
||
|
||
#define NTKERNELAPI DECLSPEC_IMPORT // wdm
|
||
|
||
#else
|
||
|
||
#define NTKERNELAPI
|
||
|
||
#endif
|
||
|
||
//
|
||
// Define function decoration depending on whether the HAL or other kernel
|
||
// component is being build.
|
||
//
|
||
|
||
#define NTHALAPI NTKERNELAPI
|
||
|
||
//
|
||
// Define a statically allocated object string.
|
||
//
|
||
|
||
#define INITIALIZED_OBJECT_STRING(ObjectString, Value) \
|
||
OCHAR ObjectString##Buffer[] = Value; \
|
||
OBJECT_STRING ObjectString = { \
|
||
sizeof(Value) - sizeof(OCHAR), \
|
||
sizeof(Value), \
|
||
ObjectString##Buffer \
|
||
}
|
||
|
||
#define INITIALIZED_OBJECT_STRING_RDATA(ObjectString, Value) \
|
||
OCHAR DECLSPEC_RDATA ObjectString##Buffer[] = Value; \
|
||
OBJECT_STRING DECLSPEC_RDATA ObjectString = { \
|
||
sizeof(Value) - sizeof(OCHAR), \
|
||
sizeof(Value), \
|
||
ObjectString##Buffer \
|
||
}
|
||
|
||
//
|
||
// Define a statically allocated list entry.
|
||
//
|
||
|
||
#define INITIALIZED_LIST_ENTRY(ListEntry) \
|
||
LIST_ENTRY ListEntry = { \
|
||
&ListEntry, &ListEntry \
|
||
}
|
||
|
||
//
|
||
// Define an access token from a programmer's viewpoint. The structure is
|
||
// completely opaque and the programer is only allowed to have pointers
|
||
// to tokens.
|
||
//
|
||
|
||
typedef PVOID PACCESS_TOKEN; // winnt
|
||
|
||
//
|
||
// Pointer to a SECURITY_DESCRIPTOR opaque data type.
|
||
//
|
||
|
||
typedef PVOID PSECURITY_DESCRIPTOR; // winnt
|
||
|
||
//
|
||
// Define a pointer to the Security ID data type (an opaque data type)
|
||
//
|
||
|
||
typedef PVOID PSID; // winnt
|
||
|
||
typedef ULONG ACCESS_MASK;
|
||
typedef ACCESS_MASK *PACCESS_MASK;
|
||
|
||
// end_winnt
|
||
//
|
||
// The following are masks for the predefined standard access types
|
||
//
|
||
|
||
#define DELETE (0x00010000L)
|
||
#define READ_CONTROL (0x00020000L)
|
||
#define WRITE_DAC (0x00040000L)
|
||
#define WRITE_OWNER (0x00080000L)
|
||
#define SYNCHRONIZE (0x00100000L)
|
||
|
||
#define STANDARD_RIGHTS_REQUIRED (0x000F0000L)
|
||
|
||
#define STANDARD_RIGHTS_READ (READ_CONTROL)
|
||
#define STANDARD_RIGHTS_WRITE (READ_CONTROL)
|
||
#define STANDARD_RIGHTS_EXECUTE (READ_CONTROL)
|
||
|
||
#define STANDARD_RIGHTS_ALL (0x001F0000L)
|
||
|
||
#define SPECIFIC_RIGHTS_ALL (0x0000FFFFL)
|
||
|
||
//
|
||
// AccessSystemAcl access type
|
||
//
|
||
|
||
#define ACCESS_SYSTEM_SECURITY (0x01000000L)
|
||
|
||
//
|
||
// MaximumAllowed access type
|
||
//
|
||
|
||
#define MAXIMUM_ALLOWED (0x02000000L)
|
||
|
||
//
|
||
// These are the generic rights.
|
||
//
|
||
|
||
#define GENERIC_READ (0x80000000L)
|
||
#define GENERIC_WRITE (0x40000000L)
|
||
#define GENERIC_EXECUTE (0x20000000L)
|
||
#define GENERIC_ALL (0x10000000L)
|
||
|
||
|
||
//
|
||
// Define the generic mapping array. This is used to denote the
|
||
// mapping of each generic access right to a specific access mask.
|
||
//
|
||
|
||
typedef struct _GENERIC_MAPPING {
|
||
ACCESS_MASK GenericRead;
|
||
ACCESS_MASK GenericWrite;
|
||
ACCESS_MASK GenericExecute;
|
||
ACCESS_MASK GenericAll;
|
||
} GENERIC_MAPPING;
|
||
typedef GENERIC_MAPPING *PGENERIC_MAPPING;
|
||
|
||
|
||
|
||
////////////////////////////////////////////////////////////////////////
|
||
// //
|
||
// LUID_AND_ATTRIBUTES //
|
||
// //
|
||
////////////////////////////////////////////////////////////////////////
|
||
//
|
||
//
|
||
|
||
|
||
#include <pshpack4.h>
|
||
|
||
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 )
|
||
|
||
VOID
|
||
NTAPI
|
||
RtlRip(
|
||
IN PVOID ApiName,
|
||
IN PVOID Expression,
|
||
IN PVOID Message
|
||
);
|
||
|
||
#define RIP(Message) \
|
||
do { RtlRip( NULL, NULL, Message ); } while(0)
|
||
|
||
#define RIP_ON_NOT_TRUE(ApiName, Expression) \
|
||
do { if (!(Expression)) RtlRip(ApiName, #Expression, NULL); } while(0)
|
||
|
||
#define RIP_ON_NOT_TRUE_WITH_MESSAGE(Expression, Message) \
|
||
do { if (!(Expression)) RtlRip(NULL, #Expression, Message); } while(0)
|
||
|
||
#else
|
||
#define ASSERT( exp )
|
||
#define ASSERTMSG( msg, exp )
|
||
#define RIP(msg)
|
||
#define RIP_ON_NOT_TRUE(api, exp)
|
||
#define RIP_ON_NOT_TRUE_WITH_MESSAGE(exp, msg)
|
||
#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);
|
||
|
||
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
|
||
//
|
||
|
||
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
|
||
CHAR
|
||
NTAPI
|
||
RtlLowerChar (
|
||
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
|
||
);
|
||
|
||
NTSYSAPI
|
||
WCHAR
|
||
NTAPI
|
||
RtlDowncaseUnicodeChar(
|
||
WCHAR SourceCharacter
|
||
);
|
||
|
||
// begin_wdm
|
||
|
||
NTSYSAPI
|
||
VOID
|
||
NTAPI
|
||
RtlFreeUnicodeString(
|
||
PUNICODE_STRING UnicodeString
|
||
);
|
||
|
||
NTSYSAPI
|
||
VOID
|
||
NTAPI
|
||
RtlFreeAnsiString(
|
||
PANSI_STRING AnsiString
|
||
);
|
||
|
||
|
||
//
|
||
// NTSYSAPI
|
||
// ULONG
|
||
// NTAPI
|
||
// RtlAnsiStringToUnicodeSize(
|
||
// PANSI_STRING AnsiString
|
||
// );
|
||
//
|
||
|
||
#define RtlAnsiStringToUnicodeSize(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
|
||
);
|
||
|
||
#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))
|
||
|
||
// 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
|
||
);
|
||
|
||
|
||
NTSYSAPI
|
||
VOID
|
||
NTAPI
|
||
RtlMapGenericMask(
|
||
PACCESS_MASK AccessMask,
|
||
PGENERIC_MAPPING GenericMapping
|
||
);
|
||
|
||
//
|
||
// 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
|
||
);
|
||
//
|
||
//
|
||
//
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
RtlGetVersion(
|
||
OUT PRTL_OSVERSIONINFOW lpVersionInformation
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
RtlVerifyVersionInfo(
|
||
IN PRTL_OSVERSIONINFOEXW VersionInfo,
|
||
IN ULONG TypeMask,
|
||
IN ULONGLONG ConditionMask
|
||
);
|
||
|
||
//
|
||
|
||
typedef struct _RTL_CRITICAL_SECTION {
|
||
|
||
//
|
||
// The following field is used for blocking when there is contention for
|
||
// the resource
|
||
//
|
||
|
||
union {
|
||
// end_winnt
|
||
struct {
|
||
UCHAR Type;
|
||
UCHAR Absolute;
|
||
UCHAR Size;
|
||
UCHAR Inserted;
|
||
LONG SignalState;
|
||
LIST_ENTRY WaitListHead;
|
||
} Event;
|
||
// begin_winnt
|
||
ULONG_PTR RawEvent[4];
|
||
} Synchronization;
|
||
|
||
//
|
||
// The following three fields control entering and exiting the critical
|
||
// section for the resource
|
||
//
|
||
|
||
LONG LockCount;
|
||
LONG RecursionCount;
|
||
HANDLE OwningThread;
|
||
} RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
|
||
|
||
NTSYSAPI
|
||
VOID
|
||
NTAPI
|
||
RtlEnterCriticalSection(
|
||
PRTL_CRITICAL_SECTION CriticalSection
|
||
);
|
||
|
||
NTSYSAPI
|
||
VOID
|
||
NTAPI
|
||
RtlLeaveCriticalSection(
|
||
PRTL_CRITICAL_SECTION CriticalSection
|
||
);
|
||
|
||
NTSYSAPI
|
||
ULONG
|
||
NTAPI
|
||
RtlTryEnterCriticalSection(
|
||
PRTL_CRITICAL_SECTION CriticalSection
|
||
);
|
||
|
||
NTSYSAPI
|
||
VOID
|
||
NTAPI
|
||
RtlInitializeCriticalSection(
|
||
PRTL_CRITICAL_SECTION CriticalSection
|
||
);
|
||
|
||
#define RtlDeleteCriticalSection(CriticalSection) ((void)0)
|
||
|
||
//
|
||
// Define the various device type values. Note that values used by Microsoft
|
||
// Corporation are in the range 0-32767, and 32768-65535 are reserved for use
|
||
// by customers.
|
||
//
|
||
|
||
#define DEVICE_TYPE ULONG
|
||
|
||
#define FILE_DEVICE_BEEP 0x00000001
|
||
#define FILE_DEVICE_CD_ROM 0x00000002
|
||
#define FILE_DEVICE_CD_ROM_FILE_SYSTEM 0x00000003
|
||
#define FILE_DEVICE_CONTROLLER 0x00000004
|
||
#define FILE_DEVICE_DATALINK 0x00000005
|
||
#define FILE_DEVICE_DFS 0x00000006
|
||
#define FILE_DEVICE_DISK 0x00000007
|
||
#define FILE_DEVICE_DISK_FILE_SYSTEM 0x00000008
|
||
#define FILE_DEVICE_FILE_SYSTEM 0x00000009
|
||
#define FILE_DEVICE_INPORT_PORT 0x0000000a
|
||
#define FILE_DEVICE_KEYBOARD 0x0000000b
|
||
#define FILE_DEVICE_MAILSLOT 0x0000000c
|
||
#define FILE_DEVICE_MIDI_IN 0x0000000d
|
||
#define FILE_DEVICE_MIDI_OUT 0x0000000e
|
||
#define FILE_DEVICE_MOUSE 0x0000000f
|
||
#define FILE_DEVICE_MULTI_UNC_PROVIDER 0x00000010
|
||
#define FILE_DEVICE_NAMED_PIPE 0x00000011
|
||
#define FILE_DEVICE_NETWORK 0x00000012
|
||
#define FILE_DEVICE_NETWORK_BROWSER 0x00000013
|
||
#define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014
|
||
#define FILE_DEVICE_NULL 0x00000015
|
||
#define FILE_DEVICE_PARALLEL_PORT 0x00000016
|
||
#define FILE_DEVICE_PHYSICAL_NETCARD 0x00000017
|
||
#define FILE_DEVICE_PRINTER 0x00000018
|
||
#define FILE_DEVICE_SCANNER 0x00000019
|
||
#define FILE_DEVICE_SERIAL_MOUSE_PORT 0x0000001a
|
||
#define FILE_DEVICE_SERIAL_PORT 0x0000001b
|
||
#define FILE_DEVICE_SCREEN 0x0000001c
|
||
#define FILE_DEVICE_SOUND 0x0000001d
|
||
#define FILE_DEVICE_STREAMS 0x0000001e
|
||
#define FILE_DEVICE_TAPE 0x0000001f
|
||
#define FILE_DEVICE_TAPE_FILE_SYSTEM 0x00000020
|
||
#define FILE_DEVICE_TRANSPORT 0x00000021
|
||
#define FILE_DEVICE_UNKNOWN 0x00000022
|
||
#define FILE_DEVICE_VIDEO 0x00000023
|
||
#define FILE_DEVICE_VIRTUAL_DISK 0x00000024
|
||
#define FILE_DEVICE_WAVE_IN 0x00000025
|
||
#define FILE_DEVICE_WAVE_OUT 0x00000026
|
||
#define FILE_DEVICE_8042_PORT 0x00000027
|
||
#define FILE_DEVICE_NETWORK_REDIRECTOR 0x00000028
|
||
#define FILE_DEVICE_BATTERY 0x00000029
|
||
#define FILE_DEVICE_BUS_EXTENDER 0x0000002a
|
||
#define FILE_DEVICE_MODEM 0x0000002b
|
||
#define FILE_DEVICE_VDM 0x0000002c
|
||
#define FILE_DEVICE_MASS_STORAGE 0x0000002d
|
||
#define FILE_DEVICE_SMB 0x0000002e
|
||
#define FILE_DEVICE_KS 0x0000002f
|
||
#define FILE_DEVICE_CHANGER 0x00000030
|
||
#define FILE_DEVICE_SMARTCARD 0x00000031
|
||
#define FILE_DEVICE_ACPI 0x00000032
|
||
#define FILE_DEVICE_DVD 0x00000033
|
||
#define FILE_DEVICE_FULLSCREEN_VIDEO 0x00000034
|
||
#define FILE_DEVICE_DFS_FILE_SYSTEM 0x00000035
|
||
#define FILE_DEVICE_DFS_VOLUME 0x00000036
|
||
#define FILE_DEVICE_SERENUM 0x00000037
|
||
#define FILE_DEVICE_TERMSRV 0x00000038
|
||
#define FILE_DEVICE_KSEC 0x00000039
|
||
#define FILE_DEVICE_MEMORY_UNIT 0x0000003a
|
||
#define FILE_DEVICE_MEDIA_BOARD 0x0000003b
|
||
|
||
//
|
||
// 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
|
||
#define FILE_ATTRIBUTE_REPARSE_POINT 0x00000400
|
||
#define FILE_ATTRIBUTE_COMPRESSED 0x00000800
|
||
|
||
#define FILE_ATTRIBUTE_OFFLINE 0x00001000
|
||
#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x00002000
|
||
#define FILE_ATTRIBUTE_ENCRYPTED 0x00004000
|
||
|
||
//
|
||
// 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_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;
|
||
OCHAR 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;
|
||
|
||
//
|
||
// 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 segment buffer structure for scatter/gather read/write.
|
||
//
|
||
|
||
typedef union _FILE_SEGMENT_ELEMENT {
|
||
PVOID Buffer;
|
||
ULONG 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;
|
||
|
||
#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 ((OCHAR)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 {
|
||
OBJECT_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
|
||
typedef struct _MEMORY_BASIC_INFORMATION {
|
||
PVOID BaseAddress;
|
||
PVOID AllocationBase;
|
||
ULONG AllocationProtect;
|
||
SIZE_T RegionSize;
|
||
ULONG State;
|
||
ULONG Protect;
|
||
ULONG Type;
|
||
} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;
|
||
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 PAGE_VIDEO 0x0 // winnt
|
||
#define PAGE_OLD_VIDEO 0x800
|
||
|
||
#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_NOZERO 0x800000
|
||
#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 )
|
||
|
||
#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 22
|
||
#define DISPATCH_LENGTH NORMAL_DISPATCH_LENGTH
|
||
//
|
||
// 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 SMBUS_LEVEL 15 // System Management Bus interrupt level
|
||
#define PROFILE_LEVEL 26 // Profiler timer interrupt level
|
||
#define SCI_LEVEL 27 // System Control Interrupt (SCI) level
|
||
#define CLOCK_LEVEL 28 // Interval clock interrupt 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
|
||
);
|
||
|
||
|
||
#define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql))
|
||
#define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql))
|
||
#define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock)
|
||
#define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock)
|
||
|
||
|
||
//
|
||
// Processor Control Region Structure Definition
|
||
//
|
||
|
||
typedef struct _KPCR {
|
||
|
||
NT_TIB NtTib;
|
||
struct _KPCR *SelfPcr; // flat address of this PCR
|
||
struct _KPRCB *Prcb; // pointer to Prcb
|
||
KIRQL Irql;
|
||
|
||
} 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 PAGE_SIZE_LARGE 0x400000
|
||
|
||
//
|
||
// 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
|
||
#define PAGE_SHIFT_LARGE 22L
|
||
|
||
// end_wdm
|
||
|
||
//
|
||
// Define the highest user address and user probe address.
|
||
//
|
||
|
||
//
|
||
// The lowest user address reserves the low 64k.
|
||
//
|
||
|
||
#define MM_LOWEST_USER_ADDRESS (PVOID)0x10000
|
||
|
||
|
||
//
|
||
// 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)
|
||
|
||
// begin_wdm
|
||
|
||
#define ExInterlockedInsertHeadList ExfInterlockedInsertHeadList
|
||
#define ExInterlockedInsertTailList ExfInterlockedInsertTailList
|
||
#define ExInterlockedRemoveHeadList ExfInterlockedRemoveHeadList
|
||
|
||
// end_wdm
|
||
|
||
//
|
||
// Prototypes for architectural specific versions of Exi386 Api
|
||
//
|
||
|
||
NTKERNELAPI
|
||
LARGE_INTEGER
|
||
ExInterlockedExchangeAddLargeInteger (
|
||
IN PLARGE_INTEGER Addend,
|
||
IN LARGE_INTEGER Increment
|
||
);
|
||
|
||
//
|
||
// 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))
|
||
|
||
NTKERNELAPI
|
||
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
|
||
|
||
|
||
//
|
||
// Get current IRQL.
|
||
//
|
||
// On x86 this function resides in the HAL
|
||
//
|
||
|
||
FORCEINLINE KIRQL KeGetCurrentIrql(VOID)
|
||
{
|
||
#if defined(_NTSYSTEM_)
|
||
return KeGetPcr()->Irql;
|
||
#else
|
||
__asm { movzx eax, byte ptr fs:[0] KPCR.Irql }
|
||
#endif
|
||
}
|
||
|
||
|
||
|
||
#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_)
|
||
|
||
|
||
#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
|
||
|
||
//
|
||
// Size of kernel mode stack minus the overhead associated with the FPU save
|
||
// area and thread local storage area. A thread's stack should have at least
|
||
// this many bytes available for actual stack usage.
|
||
//
|
||
|
||
#define KERNEL_USABLE_STACK_SIZE (KERNEL_STACK_SIZE - sizeof(FX_SAVE_AREA) - 512)
|
||
|
||
#ifdef _X86_
|
||
|
||
//
|
||
// Define the size of the 80387 save area, which is in the context frame.
|
||
//
|
||
|
||
#define SIZE_OF_80387_REGISTERS 80
|
||
|
||
//
|
||
// Define the size of FP registers in the FXSAVE format.
|
||
//
|
||
|
||
#define SIZE_OF_FX_REGISTERS 128
|
||
|
||
//
|
||
// 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
|
||
|
||
// 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
|
||
|
||
#include <pshpack1.h>
|
||
typedef struct _FLOATING_SAVE_AREA {
|
||
USHORT ControlWord;
|
||
USHORT StatusWord;
|
||
USHORT TagWord;
|
||
USHORT ErrorOpcode;
|
||
ULONG ErrorOffset;
|
||
ULONG ErrorSelector;
|
||
ULONG DataOffset;
|
||
ULONG DataSelector;
|
||
ULONG MXCsr;
|
||
ULONG Reserved2;
|
||
UCHAR RegisterArea[SIZE_OF_FX_REGISTERS];
|
||
UCHAR XmmRegisterArea[SIZE_OF_FX_REGISTERS];
|
||
UCHAR Reserved4[224];
|
||
ULONG Cr0NpxState;
|
||
} FLOATING_SAVE_AREA;
|
||
#include <poppack.h>
|
||
|
||
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 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_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;
|
||
|
||
} CONTEXT;
|
||
|
||
typedef CONTEXT *PCONTEXT;
|
||
|
||
// begin_ntminiport
|
||
|
||
#endif //_X86_
|
||
|
||
#endif // _X86_
|
||
//
|
||
// 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
|
||
//
|
||
|
||
#define PF_FLOATING_POINT_PRECISION_ERRATA 0 // winnt
|
||
#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;
|
||
|
||
#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
|
||
|
||
#define PROCESSOR_FEATURE_MAX 64
|
||
|
||
// 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)
|
||
|
||
// end_winnt
|
||
//
|
||
// 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;
|
||
|
||
|
||
//
|
||
// 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
|
||
|
||
|
||
//
|
||
// 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,
|
||
WrFsCacheIn,
|
||
WrFsCacheOut,
|
||
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
|
||
);
|
||
|
||
// end_wdm
|
||
|
||
//
|
||
// Thread system function
|
||
//
|
||
|
||
typedef
|
||
VOID
|
||
(*PKSYSTEM_ROUTINE) (
|
||
IN PKSTART_ROUTINE StartRoutine OPTIONAL,
|
||
IN PVOID StartContext OPTIONAL
|
||
);
|
||
|
||
// begin_wdm
|
||
//
|
||
// Kernel object structure definitions
|
||
//
|
||
|
||
//
|
||
// Device Queue object and entry
|
||
//
|
||
|
||
typedef struct _KDEVICE_QUEUE {
|
||
CSHORT Type;
|
||
UCHAR Size;
|
||
BOOLEAN Busy;
|
||
LIST_ENTRY DeviceListHead;
|
||
} 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;
|
||
|
||
//
|
||
// 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;
|
||
} KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT;
|
||
|
||
//
|
||
//
|
||
// Semaphore object
|
||
//
|
||
|
||
typedef struct _KSEMAPHORE {
|
||
DISPATCHER_HEADER Header;
|
||
LONG Limit;
|
||
} KSEMAPHORE, *PKSEMAPHORE, *RESTRICTED_POINTER PRKSEMAPHORE;
|
||
|
||
//
|
||
//
|
||
// 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
|
||
);
|
||
|
||
#define INITIALIZED_KDPC(_Dpc, _DeferredRoutine, _DeferredContext) \
|
||
KDPC _Dpc = { \
|
||
DpcObject, \
|
||
FALSE, \
|
||
0, \
|
||
NULL, \
|
||
NULL, \
|
||
_DeferredRoutine, \
|
||
_DeferredContext \
|
||
}
|
||
|
||
NTKERNELAPI
|
||
BOOLEAN
|
||
KeInsertQueueDpc (
|
||
IN PRKDPC Dpc,
|
||
IN PVOID SystemArgument1,
|
||
IN PVOID SystemArgument2
|
||
);
|
||
|
||
NTKERNELAPI
|
||
BOOLEAN
|
||
KeRemoveQueueDpc (
|
||
IN PRKDPC Dpc
|
||
);
|
||
|
||
DECLSPEC_NORETURN
|
||
VOID
|
||
KeRetireDpcListLoop(
|
||
VOID
|
||
);
|
||
|
||
//
|
||
// 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
|
||
);
|
||
|
||
|
||
#define KeClearEvent(Event) ((Event)->Header.SignalState = 0)
|
||
|
||
NTKERNELAPI
|
||
LONG
|
||
KePulseEvent (
|
||
IN PRKEVENT Event,
|
||
IN KPRIORITY Increment,
|
||
IN BOOLEAN Wait
|
||
);
|
||
|
||
#define KeReadStateEvent(Event) (Event)->Header.SignalState
|
||
|
||
// begin_wdm
|
||
|
||
NTKERNELAPI
|
||
LONG
|
||
KeResetEvent (
|
||
IN PRKEVENT Event
|
||
);
|
||
|
||
NTKERNELAPI
|
||
LONG
|
||
KeSetEvent (
|
||
IN PRKEVENT Event,
|
||
IN KPRIORITY Increment,
|
||
IN BOOLEAN Wait
|
||
);
|
||
|
||
//
|
||
// Semaphore object
|
||
//
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
KeInitializeSemaphore (
|
||
IN PRKSEMAPHORE Semaphore,
|
||
IN LONG Count,
|
||
IN LONG Limit
|
||
);
|
||
|
||
#define KeReadStateSemaphore(Semaphore) (Semaphore)->Header.SignalState
|
||
|
||
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
|
||
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
|
||
//
|
||
|
||
#define KeInitializeTimer(Timer) KeInitializeTimerEx(Timer, NotificationTimer)
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
KeInitializeTimerEx (
|
||
IN PKTIMER Timer,
|
||
IN TIMER_TYPE Type
|
||
);
|
||
|
||
#define INITIALIZED_KTIMER(_Timer, _Type) \
|
||
KTIMER _Timer = { \
|
||
TimerNotificationObject + _Type, \
|
||
FALSE, \
|
||
sizeof(KTIMER) / sizeof(LONG), \
|
||
FALSE, \
|
||
FALSE, \
|
||
&_Timer.Header.WaitListHead, \
|
||
&_Timer.Header.WaitListHead \
|
||
}
|
||
|
||
NTKERNELAPI
|
||
BOOLEAN
|
||
KeCancelTimer (
|
||
IN PKTIMER
|
||
);
|
||
|
||
#define KeClearTimer(Timer) ((Timer)->Header.SignalState = 0)
|
||
|
||
#define KeReadStateTimer(Timer) ((BOOLEAN)(Timer)->Header.SignalState)
|
||
|
||
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
|
||
);
|
||
|
||
|
||
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
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
KeWaitForSingleObject (
|
||
IN PVOID Object,
|
||
IN KWAIT_REASON WaitReason,
|
||
IN KPROCESSOR_MODE WaitMode,
|
||
IN BOOLEAN Alertable,
|
||
IN PLARGE_INTEGER Timeout OPTIONAL
|
||
);
|
||
|
||
//
|
||
// spin lock functions
|
||
//
|
||
|
||
#define KeInitializeSpinLock(a) *(a) = 0
|
||
|
||
#define KeAcquireSpinLockAtDpcLevel(a) ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL)
|
||
#define KeReleaseSpinLockFromDpcLevel(a)
|
||
|
||
#define KeAcquireSpinLock(a,b) *(b) = KeRaiseIrqlToDpcLevel()
|
||
#define KeReleaseSpinLock(a,b) KeLowerIrql(b)
|
||
|
||
#define KeTryToAcquireSpinLock(a,b) (KeAcquireSpinLock(a,b),TRUE)
|
||
|
||
|
||
#if defined(_X86_)
|
||
|
||
NTHALAPI
|
||
VOID
|
||
FASTCALL
|
||
KfLowerIrql (
|
||
IN KIRQL NewIrql
|
||
);
|
||
|
||
NTHALAPI
|
||
KIRQL
|
||
FASTCALL
|
||
KfRaiseIrql (
|
||
IN KIRQL NewIrql
|
||
);
|
||
|
||
NTHALAPI
|
||
KIRQL
|
||
KeRaiseIrqlToDpcLevel(
|
||
VOID
|
||
);
|
||
|
||
NTHALAPI
|
||
KIRQL
|
||
KeRaiseIrqlToSynchLevel(
|
||
VOID
|
||
);
|
||
|
||
#define KeLowerIrql(a) KfLowerIrql(a)
|
||
#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
|
||
|
||
#endif
|
||
|
||
//
|
||
// Miscellaneous kernel functions
|
||
//
|
||
|
||
// end_wdm
|
||
|
||
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
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
KeEnterKernelDebugger (
|
||
VOID
|
||
);
|
||
|
||
|
||
NTKERNELAPI
|
||
ULONGLONG
|
||
KeQueryInterruptTime (
|
||
VOID
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
KeQuerySystemTime (
|
||
OUT PLARGE_INTEGER CurrentTime
|
||
);
|
||
|
||
#if !defined(_NTSYSTEM_)
|
||
|
||
#define KeQueryTickCount() *KeTickCount
|
||
|
||
#else
|
||
|
||
#define KeQueryTickCount() KeTickCount
|
||
|
||
#endif
|
||
|
||
#define KiQueryLowTickCount KeQueryTickCount
|
||
|
||
//
|
||
// Context swap notify routine.
|
||
//
|
||
|
||
typedef
|
||
VOID
|
||
(FASTCALL *PSWAP_CONTEXT_NOTIFY_ROUTINE)(
|
||
IN HANDLE OldThreadId,
|
||
IN HANDLE NewThreadId
|
||
);
|
||
|
||
//
|
||
// Thread select notify routine.
|
||
//
|
||
|
||
typedef
|
||
LOGICAL
|
||
(FASTCALL *PTHREAD_SELECT_NOTIFY_ROUTINE)(
|
||
IN HANDLE ThreadId
|
||
);
|
||
|
||
//
|
||
// Time update notify routine.
|
||
//
|
||
|
||
typedef
|
||
VOID
|
||
(FASTCALL *PTIME_UPDATE_NOTIFY_ROUTINE)(
|
||
IN HANDLE ThreadId,
|
||
IN KPROCESSOR_MODE Mode
|
||
);
|
||
|
||
//
|
||
// 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_) || defined(_XBDM_)
|
||
|
||
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
|
||
);
|
||
|
||
|
||
NTKERNELAPI
|
||
PVOID
|
||
ExAllocatePool(
|
||
IN SIZE_T NumberOfBytes
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PVOID
|
||
NTAPI
|
||
ExAllocatePoolWithTag(
|
||
IN SIZE_T NumberOfBytes,
|
||
IN ULONG Tag
|
||
);
|
||
|
||
#ifndef POOL_TAGGING
|
||
#define ExAllocatePoolWithTag(a,b) ExAllocatePool(a)
|
||
#endif //POOL_TAGGING
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
NTAPI
|
||
ExFreePool(
|
||
IN PVOID P
|
||
);
|
||
|
||
//
|
||
|
||
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
|
||
);
|
||
|
||
// begin_wdm begin_ntddk begin_nthal begin_ntifs
|
||
|
||
NTKERNELAPI
|
||
LONGLONG
|
||
FASTCALL
|
||
ExInterlockedCompareExchange64 (
|
||
IN PLONGLONG Destination,
|
||
IN PLONGLONG Exchange,
|
||
IN PLONGLONG Comperand
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PLIST_ENTRY
|
||
FASTCALL
|
||
ExInterlockedInsertHeadList (
|
||
IN PLIST_ENTRY ListHead,
|
||
IN PLIST_ENTRY ListEntry
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PLIST_ENTRY
|
||
FASTCALL
|
||
ExInterlockedInsertTailList (
|
||
IN PLIST_ENTRY ListHead,
|
||
IN PLIST_ENTRY ListEntry
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PLIST_ENTRY
|
||
FASTCALL
|
||
ExInterlockedRemoveHeadList (
|
||
IN PLIST_ENTRY ListHead
|
||
);
|
||
|
||
// 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(_WINBASE_)
|
||
|
||
NTKERNELAPI
|
||
PSINGLE_LIST_ENTRY
|
||
FASTCALL
|
||
InterlockedPopEntrySList (
|
||
IN PSLIST_HEADER ListHead
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PSINGLE_LIST_ENTRY
|
||
FASTCALL
|
||
InterlockedPushEntrySList (
|
||
IN PSLIST_HEADER ListHead,
|
||
IN PSINGLE_LIST_ENTRY ListEntry
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PSINGLE_LIST_ENTRY
|
||
FASTCALL
|
||
InterlockedFlushSList (
|
||
IN PSLIST_HEADER ListHead
|
||
);
|
||
|
||
#endif
|
||
|
||
// end_ntndis
|
||
//
|
||
// Raise status from kernel mode.
|
||
//
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
NTAPI
|
||
ExRaiseStatus (
|
||
IN NTSTATUS Status
|
||
);
|
||
|
||
|
||
//
|
||
// UUID Generation
|
||
//
|
||
|
||
typedef GUID 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
|
||
|
||
|
||
//++
|
||
//
|
||
// 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)))
|
||
|
||
//++
|
||
//
|
||
// ULONG
|
||
// BYTE_OFFSET_LARGE(
|
||
// IN PVOID Va
|
||
// )
|
||
//
|
||
// Routine Description:
|
||
//
|
||
// The BYTE_OFFSET macro takes a virtual address and returns the byte offset
|
||
// of that address within the large page.
|
||
//
|
||
// Arguments:
|
||
//
|
||
// Va - Virtual address.
|
||
//
|
||
// Return Value:
|
||
//
|
||
// Returns the byte offset portion of the virtual address.
|
||
//
|
||
//--
|
||
|
||
#define BYTE_OFFSET_LARGE(Va) ((ULONG)((LONG_PTR)(Va) & (PAGE_SIZE_LARGE - 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)))
|
||
|
||
//++
|
||
//
|
||
// PVOID
|
||
// PAGE_ALIGN_LARGE(
|
||
// 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_LARGE(Va) ((PVOID)((ULONG_PTR)(Va) & ~(PAGE_SIZE_LARGE - 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))
|
||
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
MmLockUnlockBufferPages(
|
||
IN PVOID BaseAddress,
|
||
IN SIZE_T NumberOfBytes,
|
||
IN BOOLEAN UnlockPages
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
MmLockUnlockPhysicalPage(
|
||
IN ULONG_PTR PhysicalAddress,
|
||
IN BOOLEAN UnlockPage
|
||
);
|
||
|
||
// begin_wdm
|
||
|
||
NTKERNELAPI
|
||
PVOID
|
||
MmMapIoSpace(
|
||
IN ULONG_PTR PhysicalAddress,
|
||
IN SIZE_T NumberOfBytes,
|
||
IN ULONG Protect
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
MmUnmapIoSpace(
|
||
IN PVOID BaseAddress,
|
||
IN SIZE_T NumberOfBytes
|
||
);
|
||
|
||
|
||
NTKERNELAPI
|
||
ULONG_PTR
|
||
MmGetPhysicalAddress(
|
||
IN PVOID BaseAddress
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PVOID
|
||
MmAllocateContiguousMemory(
|
||
IN SIZE_T NumberOfBytes
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PVOID
|
||
MmAllocateContiguousMemoryEx(
|
||
IN SIZE_T NumberOfBytes,
|
||
IN ULONG_PTR LowestAcceptableAddress,
|
||
IN ULONG_PTR HighestAcceptableAddress,
|
||
IN ULONG_PTR Alignment,
|
||
IN ULONG Protect
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
MmFreeContiguousMemory(
|
||
IN PVOID BaseAddress
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
MmPersistContiguousMemory(
|
||
IN PVOID BaseAddress,
|
||
IN SIZE_T NumberOfBytes,
|
||
IN BOOLEAN Persist
|
||
);
|
||
|
||
NTKERNELAPI
|
||
PVOID
|
||
MmAllocateSystemMemory(
|
||
IN SIZE_T NumberOfBytes,
|
||
IN ULONG Protect
|
||
);
|
||
|
||
NTKERNELAPI
|
||
ULONG
|
||
MmFreeSystemMemory(
|
||
IN PVOID BaseAddress,
|
||
IN SIZE_T NumberOfBytes
|
||
);
|
||
|
||
NTKERNELAPI
|
||
SIZE_T
|
||
MmQueryAllocationSize(
|
||
IN PVOID BaseAddress
|
||
);
|
||
|
||
NTKERNELAPI
|
||
ULONG
|
||
MmQueryAddressProtect(
|
||
IN PVOID VirtualAddress
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
MmSetAddressProtect(
|
||
IN PVOID BaseAddress,
|
||
IN ULONG NumberOfBytes,
|
||
IN ULONG NewProtect
|
||
);
|
||
|
||
NTKERNELAPI
|
||
BOOLEAN
|
||
MmIsAddressValid(
|
||
IN PVOID VirtualAddress
|
||
);
|
||
|
||
//
|
||
// System Thread and Process Creation and Termination
|
||
//
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
PsCreateSystemThread(
|
||
OUT PHANDLE ThreadHandle,
|
||
OUT PHANDLE ThreadId OPTIONAL,
|
||
IN PKSTART_ROUTINE StartRoutine,
|
||
IN PVOID StartContext,
|
||
IN BOOLEAN DebuggerThread
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
PsCreateSystemThreadEx(
|
||
OUT PHANDLE ThreadHandle,
|
||
IN SIZE_T ThreadExtensionSize,
|
||
IN SIZE_T KernelStackSize,
|
||
IN SIZE_T TlsDataSize,
|
||
OUT PHANDLE ThreadId OPTIONAL,
|
||
IN PKSTART_ROUTINE StartRoutine,
|
||
IN PVOID StartContext,
|
||
IN BOOLEAN CreateSuspended,
|
||
IN BOOLEAN DebuggerThread,
|
||
IN PKSYSTEM_ROUTINE SystemRoutine OPTIONAL
|
||
);
|
||
|
||
DECLSPEC_NORETURN
|
||
NTKERNELAPI
|
||
VOID
|
||
PsTerminateSystemThread(
|
||
IN NTSTATUS ExitStatus
|
||
);
|
||
|
||
|
||
typedef
|
||
VOID
|
||
(*PCREATE_THREAD_NOTIFY_ROUTINE)(
|
||
IN PETHREAD Thread,
|
||
IN HANDLE ThreadId,
|
||
IN BOOLEAN Create
|
||
);
|
||
|
||
NTSTATUS
|
||
PsSetCreateThreadNotifyRoutine(
|
||
IN PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
|
||
);
|
||
|
||
//
|
||
// 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_DEVICE 0x00000003
|
||
#define IO_TYPE_DRIVER 0x00000004
|
||
#define IO_TYPE_FILE 0x00000005
|
||
#define IO_TYPE_IRP 0x00000006
|
||
#define IO_TYPE_OPEN_PACKET 0x00000008
|
||
#define IO_TYPE_TIMER 0x00000009
|
||
|
||
//
|
||
// Define the major function codes for IRPs.
|
||
//
|
||
|
||
#define IRP_MJ_CREATE 0x00
|
||
#define IRP_MJ_CLOSE 0x01
|
||
#define IRP_MJ_READ 0x02
|
||
#define IRP_MJ_WRITE 0x03
|
||
#define IRP_MJ_QUERY_INFORMATION 0x04
|
||
#define IRP_MJ_SET_INFORMATION 0x05
|
||
#define IRP_MJ_FLUSH_BUFFERS 0x06
|
||
#define IRP_MJ_QUERY_VOLUME_INFORMATION 0x07
|
||
#define IRP_MJ_DIRECTORY_CONTROL 0x08
|
||
#define IRP_MJ_FILE_SYSTEM_CONTROL 0x09
|
||
#define IRP_MJ_DEVICE_CONTROL 0x0a
|
||
#define IRP_MJ_INTERNAL_DEVICE_CONTROL 0x0b
|
||
#define IRP_MJ_SHUTDOWN 0x0c
|
||
#define IRP_MJ_CLEANUP 0x0d
|
||
#define IRP_MJ_MAXIMUM_FUNCTION 0x0d
|
||
|
||
//
|
||
// 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_ntndis
|
||
|
||
//
|
||
// 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_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 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;
|
||
|
||
// end_wdm
|
||
|
||
// begin_wdm begin_ntndis
|
||
//
|
||
// 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 device object deletion routine type.
|
||
//
|
||
|
||
typedef
|
||
VOID
|
||
(*PDRIVER_DELETEDEVICE) (
|
||
IN struct _DEVICE_OBJECT *DeviceObject
|
||
);
|
||
|
||
//
|
||
// Define driver dismount volume routine type.
|
||
//
|
||
|
||
typedef
|
||
NTSTATUS
|
||
(*PDRIVER_DISMOUNTVOLUME) (
|
||
IN struct _DEVICE_OBJECT *DeviceObject
|
||
);
|
||
|
||
//
|
||
// Define Device Object (DO) flags
|
||
//
|
||
#define DO_EXCLUSIVE 0x00000002
|
||
#define DO_DIRECT_IO 0x00000004
|
||
#define DO_DEVICE_HAS_NAME 0x00000008
|
||
#define DO_DEVICE_INITIALIZING 0x00000010
|
||
//
|
||
// Device Object structure definition
|
||
//
|
||
|
||
typedef struct _DEVICE_OBJECT {
|
||
CSHORT Type;
|
||
USHORT Size;
|
||
LONG ReferenceCount;
|
||
struct _DRIVER_OBJECT *DriverObject;
|
||
struct _DEVICE_OBJECT *MountedOrSelfDevice;
|
||
struct _IRP *CurrentIrp;
|
||
ULONG Flags; // See above: DO_...
|
||
PVOID DeviceExtension;
|
||
UCHAR DeviceType;
|
||
UCHAR StartIoFlags;
|
||
CCHAR StackSize;
|
||
BOOLEAN DeletePending;
|
||
ULONG SectorSize;
|
||
ULONG AlignmentRequirement;
|
||
KDEVICE_QUEUE DeviceQueue;
|
||
KEVENT DeviceLock;
|
||
ULONG StartIoKey;
|
||
} DEVICE_OBJECT;
|
||
typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT; // ntndis
|
||
|
||
typedef struct _DRIVER_OBJECT {
|
||
|
||
//
|
||
// The following section describes the entry points to this particular
|
||
// driver. Note that the major function dispatch table must be the last
|
||
// field in the object so that it remains extensible.
|
||
//
|
||
|
||
PDRIVER_STARTIO DriverStartIo;
|
||
PDRIVER_DELETEDEVICE DriverDeleteDevice;
|
||
PDRIVER_DISMOUNTVOLUME DriverDismountVolume;
|
||
PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
|
||
|
||
} DRIVER_OBJECT;
|
||
typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT; // ntndis
|
||
|
||
//
|
||
// 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_SYNCHRONOUS_IO 0x00000001
|
||
#define FO_ALERTABLE_IO 0x00000002
|
||
#define FO_NO_INTERMEDIATE_BUFFERING 0x00000004
|
||
#define FO_SEQUENTIAL_ONLY 0x00000008
|
||
#define FO_CLEANUP_COMPLETE 0x00000010
|
||
#define FO_HANDLE_CREATED 0x00000020
|
||
#define FO_RANDOM_ACCESS 0x00000040
|
||
|
||
#include "pshpack4.h"
|
||
|
||
typedef struct _FILE_OBJECT {
|
||
CSHORT Type;
|
||
BOOLEAN DeletePending : 1;
|
||
BOOLEAN ReadAccess : 1;
|
||
BOOLEAN WriteAccess : 1;
|
||
BOOLEAN DeleteAccess : 1;
|
||
BOOLEAN SharedRead : 1;
|
||
BOOLEAN SharedWrite : 1;
|
||
BOOLEAN SharedDelete : 1;
|
||
BOOLEAN Reserved : 1;
|
||
UCHAR Flags;
|
||
PDEVICE_OBJECT DeviceObject;
|
||
PVOID FsContext;
|
||
PVOID FsContext2;
|
||
NTSTATUS FinalStatus;
|
||
LARGE_INTEGER CurrentByteOffset;
|
||
struct _FILE_OBJECT *RelatedFileObject;
|
||
PIO_COMPLETION_CONTEXT CompletionContext;
|
||
LONG LockCount;
|
||
KEVENT Lock;
|
||
KEVENT Event;
|
||
} FILE_OBJECT;
|
||
typedef struct _FILE_OBJECT *PFILE_OBJECT; // ntndis
|
||
|
||
#include "poppack.h"
|
||
|
||
//
|
||
// Define I/O Request Packet (IRP) flags
|
||
//
|
||
|
||
#define IRP_NOCACHE 0x00000001
|
||
#define IRP_MOUNT_COMPLETION 0x00000002
|
||
#define IRP_SYNCHRONOUS_API 0x00000004
|
||
#define IRP_CREATE_OPERATION 0x00000008
|
||
#define IRP_READ_OPERATION 0x00000010
|
||
#define IRP_WRITE_OPERATION 0x00000020
|
||
#define IRP_CLOSE_OPERATION 0x00000040
|
||
// end_wdm
|
||
|
||
#define IRP_DEFER_IO_COMPLETION 0x00000080
|
||
#define IRP_OB_QUERY_NAME 0x00000100
|
||
#define IRP_UNLOCK_USER_BUFFER 0x00000200
|
||
#define IRP_SCATTER_GATHER_OPERATION 0x00000400
|
||
#define IRP_UNMAP_SEGMENT_ARRAY 0x00000800
|
||
#define IRP_NO_CANCELIO 0x00001000
|
||
|
||
// begin_wdm
|
||
//
|
||
// I/O Request Packet (IRP) definition
|
||
//
|
||
|
||
typedef struct _IRP {
|
||
CSHORT Type;
|
||
USHORT Size;
|
||
|
||
//
|
||
// Define the common fields used to control the IRP.
|
||
//
|
||
|
||
//
|
||
// Flags word - used to remember various flags.
|
||
//
|
||
|
||
ULONG Flags;
|
||
|
||
//
|
||
// 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;
|
||
|
||
//
|
||
// Stack state information.
|
||
//
|
||
|
||
CHAR StackCount;
|
||
CHAR CurrentLocation;
|
||
|
||
//
|
||
// Pending returned - TRUE if pending was initially returned as the
|
||
// status for this packet.
|
||
//
|
||
|
||
BOOLEAN PendingReturned;
|
||
|
||
//
|
||
// Cancel - packet has been canceled.
|
||
//
|
||
|
||
BOOLEAN Cancel;
|
||
|
||
//
|
||
// User parameters.
|
||
//
|
||
|
||
PIO_STATUS_BLOCK UserIosb;
|
||
PKEVENT UserEvent;
|
||
union {
|
||
struct {
|
||
PIO_APC_ROUTINE UserApcRoutine;
|
||
PVOID UserApcContext;
|
||
} AsynchronousParameters;
|
||
LARGE_INTEGER AllocationSize;
|
||
} Overlay;
|
||
|
||
//
|
||
// 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;
|
||
|
||
//
|
||
// If this is a scatter/gather I/O request, then the individual pages for
|
||
// the request can be obtained via this array.
|
||
//
|
||
|
||
PFILE_SEGMENT_ELEMENT SegmentArray;
|
||
|
||
//
|
||
// Stores the number of bytes that were locked down for direct I/O.
|
||
//
|
||
|
||
ULONG LockedBufferLength;
|
||
|
||
//
|
||
// 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[5];
|
||
} ;
|
||
} ;
|
||
|
||
//
|
||
// Thread - pointer to caller's Thread Control Block.
|
||
//
|
||
|
||
PETHREAD Thread;
|
||
|
||
//
|
||
// 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_MUST_COMPLETE 0x02
|
||
#define SL_INVOKE_ON_CANCEL 0x20
|
||
#define SL_INVOKE_ON_SUCCESS 0x40
|
||
#define SL_INVOKE_ON_ERROR 0x80
|
||
|
||
//
|
||
// Define flags for various functions
|
||
//
|
||
|
||
//
|
||
// Create / Create Named Pipe
|
||
//
|
||
// 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_TARGET_DIRECTORY 0x04
|
||
|
||
#define SL_CASE_SENSITIVE 0x80
|
||
|
||
//
|
||
// Read / Write
|
||
//
|
||
|
||
#define SL_OVERRIDE_VERIFY_VOLUME 0x02
|
||
#define SL_FSCACHE_REQUEST 0x80
|
||
|
||
//
|
||
// Device I/O Control
|
||
//
|
||
//
|
||
// Same SL_OVERRIDE_VERIFY_VOLUME as for read/write above.
|
||
//
|
||
|
||
//
|
||
// QueryDirectory / QueryEa / QueryQuota
|
||
//
|
||
|
||
#define SL_RESTART_SCAN 0x01
|
||
#define SL_RETURN_SINGLE_ENTRY 0x02
|
||
#define SL_INDEX_SPECIFIED 0x04
|
||
|
||
//
|
||
// FileSystemControl
|
||
//
|
||
// minor: mount/verify volume
|
||
//
|
||
|
||
#define SL_ALLOW_RAW_MOUNT 0x01
|
||
|
||
//
|
||
// Define I/O Request Packet (IRP) stack locations
|
||
//
|
||
|
||
#include "pshpack4.h"
|
||
|
||
#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 {
|
||
ACCESS_MASK DesiredAccess;
|
||
ULONG Options;
|
||
USHORT POINTER_ALIGNMENT FileAttributes;
|
||
USHORT ShareAccess;
|
||
POBJECT_STRING RemainingName;
|
||
} Create;
|
||
|
||
//
|
||
// System service parameters for: NtReadFile
|
||
//
|
||
|
||
struct {
|
||
ULONG Length;
|
||
union {
|
||
ULONG BufferOffset;
|
||
PVOID CacheBuffer;
|
||
};
|
||
LARGE_INTEGER ByteOffset;
|
||
} Read;
|
||
|
||
//
|
||
// System service parameters for: NtWriteFile
|
||
//
|
||
|
||
struct {
|
||
ULONG Length;
|
||
union {
|
||
ULONG BufferOffset;
|
||
PVOID CacheBuffer;
|
||
};
|
||
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;
|
||
} 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
|
||
//
|
||
|
||
struct {
|
||
ULONG OutputBufferLength;
|
||
PVOID InputBuffer;
|
||
ULONG POINTER_ALIGNMENT InputBufferLength;
|
||
ULONG POINTER_ALIGNMENT IoControlCode;
|
||
} DeviceIoControl;
|
||
|
||
//
|
||
// Parameters for Scsi with internal device contorl.
|
||
//
|
||
|
||
struct {
|
||
struct _SCSI_REQUEST_BLOCK *Srb;
|
||
} Scsi;
|
||
|
||
//
|
||
// Parameters for Cleanup
|
||
//
|
||
// No extra parameters supplied
|
||
//
|
||
|
||
|
||
//
|
||
// 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;
|
||
|
||
#include "poppack.h"
|
||
|
||
//
|
||
// Define the share access structure used by file systems to determine
|
||
// whether or not another accessor may open the file.
|
||
//
|
||
|
||
typedef struct _SHARE_ACCESS {
|
||
UCHAR OpenCount;
|
||
UCHAR Readers;
|
||
UCHAR Writers;
|
||
UCHAR Deleters;
|
||
UCHAR SharedRead;
|
||
UCHAR SharedWrite;
|
||
UCHAR SharedDelete;
|
||
} SHARE_ACCESS, *PSHARE_ACCESS;
|
||
|
||
//
|
||
// Public I/O routine definitions
|
||
//
|
||
|
||
NTKERNELAPI
|
||
PIRP
|
||
IoAllocateIrp(
|
||
IN CCHAR StackSize
|
||
);
|
||
|
||
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
|
||
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
|
||
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)
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
IoCreateDevice(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN ULONG DeviceExtensionSize,
|
||
IN POBJECT_STRING DeviceName OPTIONAL,
|
||
IN DEVICE_TYPE DeviceType,
|
||
IN BOOLEAN Exclusive,
|
||
OUT PDEVICE_OBJECT *DeviceObject
|
||
);
|
||
|
||
// 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 ULONG Options
|
||
);
|
||
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
IoCreateSymbolicLink(
|
||
IN POBJECT_STRING SymbolicLinkName,
|
||
IN POBJECT_STRING DeviceName
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
IoDeleteDevice(
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
IoDeleteSymbolicLink(
|
||
IN POBJECT_STRING SymbolicLinkName
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
IoDismountVolume(
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
IoDismountVolumeByName(
|
||
IN POBJECT_STRING DeviceName
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
IoFreeIrp(
|
||
IN PIRP Irp
|
||
);
|
||
|
||
//++
|
||
//
|
||
// 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
|
||
|
||
//++
|
||
//
|
||
// 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
|
||
|
||
//++
|
||
//
|
||
// 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
|
||
VOID
|
||
IoInitializeIrp(
|
||
IN OUT PIRP Irp,
|
||
IN USHORT PacketSize,
|
||
IN CCHAR StackSize
|
||
);
|
||
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
IoInvalidDeviceRequest(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
//++
|
||
//
|
||
// 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)))
|
||
|
||
|
||
// begin_wdm
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
IoMarkIrpMustComplete(
|
||
IN OUT PIRP Irp
|
||
);
|
||
|
||
//++
|
||
//
|
||
// 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
|
||
VOID
|
||
IoRemoveShareAccess(
|
||
IN PFILE_OBJECT FileObject,
|
||
IN OUT PSHARE_ACCESS ShareAccess
|
||
);
|
||
|
||
// begin_wdm
|
||
|
||
//++
|
||
//
|
||
// 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; } }
|
||
|
||
//++
|
||
//
|
||
// 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
|
||
);
|
||
|
||
|
||
//++
|
||
//
|
||
// 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
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
IoStartNextPacketByKey(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN ULONG Key
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
IoStartPacket(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PULONG Key OPTIONAL
|
||
);
|
||
|
||
// begin_ntifs
|
||
|
||
//
|
||
// I/O driver configuration functions.
|
||
//
|
||
|
||
NTHALAPI
|
||
VOID
|
||
HalReadWritePCISpace(
|
||
IN ULONG BusNumber,
|
||
IN ULONG SlotNumber,
|
||
IN ULONG RegisterNumber,
|
||
IN PVOID Buffer,
|
||
IN ULONG Length,
|
||
IN BOOLEAN WritePCISpace
|
||
);
|
||
|
||
#define HalReadPCISpace(BusNumber, SlotNumber, RegisterNumber, Buffer, Length) \
|
||
HalReadWritePCISpace(BusNumber, SlotNumber, RegisterNumber, Buffer, Length, FALSE)
|
||
|
||
#define HalWritePCISpace(BusNumber, SlotNumber, RegisterNumber, Buffer, Length) \
|
||
HalReadWritePCISpace(BusNumber, SlotNumber, RegisterNumber, Buffer, Length, TRUE)
|
||
|
||
NTHALAPI
|
||
ULONG
|
||
HalGetInterruptVector(
|
||
IN ULONG BusInterruptLevel,
|
||
OUT PKIRQL Irql
|
||
);
|
||
|
||
#include <pshpack1.h>
|
||
|
||
typedef struct _PCI_DEVICE_ADDRESS {
|
||
UCHAR Type; //CmResourceType
|
||
UCHAR Valid;
|
||
UCHAR Reserved[2];
|
||
|
||
union {
|
||
|
||
struct {
|
||
PVOID TranslatedAddress;
|
||
ULONG Length;
|
||
} Port;
|
||
|
||
struct {
|
||
PVOID TranslatedAddress;
|
||
ULONG Length;
|
||
} Memory;
|
||
|
||
} u;
|
||
|
||
} PCI_DEVICE_ADDRESS, *PPCI_DEVICE_ADDRESS;
|
||
|
||
typedef struct _PCI_DEVICE_DESCRIPTOR {
|
||
ULONG Bus;
|
||
ULONG Slot;
|
||
USHORT VendorID;
|
||
USHORT DeviceID;
|
||
|
||
UCHAR BaseClass;
|
||
UCHAR SubClass;
|
||
UCHAR ProgIf;
|
||
UCHAR Reserved[1];
|
||
|
||
struct {
|
||
|
||
PCI_DEVICE_ADDRESS Address[1];
|
||
|
||
struct {
|
||
ULONG Vector;
|
||
ULONG Affinity;
|
||
KIRQL Irql; // KIRQL is uchar!
|
||
|
||
} Interrupt;
|
||
|
||
} ResourceData;
|
||
|
||
} PCI_DEVICE_DESCRIPTOR, *PPCI_DEVICE_DESCRIPTOR;
|
||
|
||
#include <poppack.h>
|
||
|
||
//
|
||
// Performance counter function.
|
||
//
|
||
|
||
NTHALAPI
|
||
LARGE_INTEGER
|
||
KeQueryPerformanceCounter(
|
||
VOID
|
||
);
|
||
|
||
NTHALAPI
|
||
LARGE_INTEGER
|
||
KeQueryPerformanceFrequency(
|
||
VOID
|
||
);
|
||
|
||
//
|
||
// Stall processor execution function.
|
||
//
|
||
|
||
NTHALAPI
|
||
VOID
|
||
KeStallExecutionProcessor(
|
||
IN ULONG MicroSeconds
|
||
);
|
||
|
||
// end_wdm
|
||
|
||
DECLSPEC_NORETURN
|
||
NTHALAPI
|
||
VOID
|
||
HalHaltSystem(
|
||
VOID
|
||
);
|
||
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
ObCreateObject(
|
||
IN POBJECT_TYPE ObjectType,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
|
||
IN ULONG ObjectBodySize,
|
||
OUT PVOID *Object
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
ObInsertObject(
|
||
IN PVOID Object,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
|
||
IN ULONG ObjectPointerBias,
|
||
OUT PHANDLE Handle
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
ObReferenceObjectByHandle(
|
||
IN HANDLE Handle,
|
||
IN POBJECT_TYPE ObjectType OPTIONAL,
|
||
OUT PVOID *Object
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
ObOpenObjectByName(
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
||
IN POBJECT_TYPE ObjectType,
|
||
IN OUT PVOID ParseContext OPTIONAL,
|
||
OUT PHANDLE Handle
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
ObOpenObjectByPointer(
|
||
IN PVOID Object,
|
||
IN POBJECT_TYPE ObjectType,
|
||
OUT PHANDLE Handle
|
||
);
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
ObReferenceObjectByName(
|
||
IN POBJECT_STRING ObjectName,
|
||
IN ULONG Attributes,
|
||
IN POBJECT_TYPE ObjectType,
|
||
IN OUT PVOID ParseContext OPTIONAL,
|
||
OUT PVOID *Object
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
ObMakeTemporaryObject(
|
||
IN PVOID Object
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
FASTCALL
|
||
ObfReferenceObject(
|
||
IN PVOID Object
|
||
);
|
||
|
||
#define ObReferenceObject(Object) ObfReferenceObject(Object)
|
||
|
||
NTKERNELAPI
|
||
NTSTATUS
|
||
ObReferenceObjectByPointer(
|
||
IN PVOID Object,
|
||
IN POBJECT_TYPE ObjectType
|
||
);
|
||
|
||
NTKERNELAPI
|
||
VOID
|
||
FASTCALL
|
||
ObfDereferenceObject(
|
||
IN PVOID Object
|
||
);
|
||
|
||
#define ObDereferenceObject(Object) ObfDereferenceObject(Object)
|
||
|
||
|
||
//
|
||
// 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
|
||
|
||
|
||
|
||
#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;
|
||
|
||
//
|
||
// Define exported ZwXxx routines to device drivers.
|
||
//
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwCreateFile(
|
||
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 CreateDisposition,
|
||
IN ULONG CreateOptions,
|
||
IN PVOID EaBuffer OPTIONAL,
|
||
IN ULONG EaLength
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwOpenFile(
|
||
OUT PHANDLE FileHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN ULONG ShareAccess,
|
||
IN ULONG OpenOptions
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwQueryInformationFile(
|
||
IN HANDLE FileHandle,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
OUT PVOID FileInformation,
|
||
IN ULONG Length,
|
||
IN FILE_INFORMATION_CLASS FileInformationClass
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwSetInformationFile(
|
||
IN HANDLE FileHandle,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN PVOID FileInformation,
|
||
IN ULONG Length,
|
||
IN FILE_INFORMATION_CLASS FileInformationClass
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwReadFile(
|
||
IN HANDLE FileHandle,
|
||
IN HANDLE Event OPTIONAL,
|
||
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
|
||
IN PVOID ApcContext OPTIONAL,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
OUT PVOID Buffer,
|
||
IN ULONG Length,
|
||
IN PLARGE_INTEGER ByteOffset OPTIONAL,
|
||
IN PULONG Key OPTIONAL
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwWriteFile(
|
||
IN HANDLE FileHandle,
|
||
IN HANDLE Event OPTIONAL,
|
||
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
|
||
IN PVOID ApcContext OPTIONAL,
|
||
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
||
IN PVOID Buffer,
|
||
IN ULONG Length,
|
||
IN PLARGE_INTEGER ByteOffset OPTIONAL,
|
||
IN PULONG Key OPTIONAL
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwClose(
|
||
IN HANDLE Handle
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwCreateDirectoryObject(
|
||
OUT PHANDLE DirectoryHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwMakeTemporaryObject(
|
||
IN HANDLE Handle
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwOpenSection(
|
||
OUT PHANDLE SectionHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwMapViewOfSection(
|
||
IN HANDLE SectionHandle,
|
||
IN HANDLE ProcessHandle,
|
||
IN OUT PVOID *BaseAddress,
|
||
IN ULONG ZeroBits,
|
||
IN ULONG CommitSize,
|
||
IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
|
||
IN OUT PSIZE_T ViewSize,
|
||
IN SECTION_INHERIT InheritDisposition,
|
||
IN ULONG AllocationType,
|
||
IN ULONG Protect
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwUnmapViewOfSection(
|
||
IN HANDLE ProcessHandle,
|
||
IN PVOID BaseAddress
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwSetInformationThread(
|
||
IN HANDLE ThreadHandle,
|
||
IN THREADINFOCLASS ThreadInformationClass,
|
||
IN PVOID ThreadInformation,
|
||
IN ULONG ThreadInformationLength
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwCreateKey(
|
||
OUT PHANDLE KeyHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
||
IN ULONG TitleIndex,
|
||
IN PUNICODE_STRING Class OPTIONAL,
|
||
IN ULONG CreateOptions,
|
||
OUT PULONG Disposition OPTIONAL
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwOpenKey(
|
||
OUT PHANDLE KeyHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwDeleteKey(
|
||
IN HANDLE KeyHandle
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwEnumerateKey(
|
||
IN HANDLE KeyHandle,
|
||
IN ULONG Index,
|
||
IN KEY_INFORMATION_CLASS KeyInformationClass,
|
||
OUT PVOID KeyInformation,
|
||
IN ULONG Length,
|
||
OUT PULONG ResultLength
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwEnumerateValueKey(
|
||
IN HANDLE KeyHandle,
|
||
IN ULONG Index,
|
||
IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
|
||
OUT PVOID KeyValueInformation,
|
||
IN ULONG Length,
|
||
OUT PULONG ResultLength
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwFlushKey(
|
||
IN HANDLE KeyHandle
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwQueryKey(
|
||
IN HANDLE KeyHandle,
|
||
IN KEY_INFORMATION_CLASS KeyInformationClass,
|
||
OUT PVOID KeyInformation,
|
||
IN ULONG Length,
|
||
OUT PULONG ResultLength
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwQueryValueKey(
|
||
IN HANDLE KeyHandle,
|
||
IN PUNICODE_STRING ValueName,
|
||
IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
|
||
OUT PVOID KeyValueInformation,
|
||
IN ULONG Length,
|
||
OUT PULONG ResultLength
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwSetValueKey(
|
||
IN HANDLE KeyHandle,
|
||
IN PUNICODE_STRING ValueName,
|
||
IN ULONG TitleIndex OPTIONAL,
|
||
IN ULONG Type,
|
||
IN PVOID Data,
|
||
IN ULONG DataSize
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwOpenSymbolicLinkObject(
|
||
OUT PHANDLE LinkHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes
|
||
);
|
||
|
||
NTSYSAPI
|
||
NTSTATUS
|
||
NTAPI
|
||
ZwQuerySymbolicLinkObject(
|
||
IN HANDLE LinkHandle,
|
||
IN OUT PUNICODE_STRING LinkTarget,
|
||
OUT PULONG ReturnedLength OPTIONAL
|
||
);
|
||
|
||
NTSTATUS
|
||
ZwCreateTimer (
|
||
OUT PHANDLE TimerHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
|
||
IN TIMER_TYPE TimerType
|
||
);
|
||
|
||
NTSTATUS
|
||
ZwOpenTimer (
|
||
OUT PHANDLE TimerHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN POBJECT_ATTRIBUTES ObjectAttributes
|
||
);
|
||
|
||
NTSTATUS
|
||
ZwCancelTimer (
|
||
IN HANDLE TimerHandle,
|
||
OUT PBOOLEAN CurrentState OPTIONAL
|
||
);
|
||
|
||
NTSTATUS
|
||
ZwSetTimer (
|
||
IN HANDLE TimerHandle,
|
||
IN PLARGE_INTEGER DueTime,
|
||
IN PTIMER_APC_ROUTINE TimerApcRoutine OPTIONAL,
|
||
IN PVOID TimerContext OPTIONAL,
|
||
IN BOOLEAN WakeTimer,
|
||
IN LONG Period OPTIONAL,
|
||
OUT PBOOLEAN PreviousState OPTIONAL
|
||
);
|
||
|
||
#ifdef __cplusplus
|
||
} // extern "C"
|
||
#endif
|
||
|
||
#endif // _NTDDK_
|