include/ddk/winddk.h

   1 /*
   2  * winddk.h
   3  *
   4  * Windows Device Driver Kit
   5  *
   6  * This file is part of the w32api package.
   7  *
   8  * Contributors:
   9  *   Created by Casper S. Hornstrup <chorns@users.sourceforge.net>
  10  *
  11  * THIS SOFTWARE IS NOT COPYRIGHTED
  12  *
  13  * This source code is offered for use in the public domain. You may
  14  * use, modify or distribute it freely.
  15  *
  16  * This code is distributed in the hope that it will be useful but
  17  * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
  18  * DISCLAIMED. This includes but is not limited to warranties of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  */
  22
  23 #ifndef __WINDDK_H
  24 #define __WINDDK_H
  25
  26 /* Helper macro to enable gcc's extension.  */
  27 #ifndef __GNU_EXTENSION
  28 #ifdef __GNUC__
  29 #define __GNU_EXTENSION __extension__
  30 #else
  31 #define __GNU_EXTENSION
  32 #endif
  33 #endif
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 #include <excpt.h>
  40 #include <ntdef.h>
  41 #include <ntstatus.h>
  42
  43 #include "intrin.h"
  44
  45 /* Pseudo modifiers for parameters */
  46 #ifndef IN
  47 #define IN
  48 #endif
  49 #ifndef OUT
  50 #define OUT
  51 #endif
  52 #ifndef OPTIONAL
  53 #define OPTIONAL
  54 #endif
  55 #ifndef UNALLIGNED
  56 #define UNALLIGNED
  57 #endif
  58
  59 #define CONST const
  60
  61 #define RESTRICTED_POINTER
  62
  63 #define DECLSPEC_ADDRSAFE
  64
  65 #ifdef NONAMELESSUNION
  66 # define _DDK_DUMMYUNION_MEMBER(name) DUMMYUNIONNAME.name
  67 # define _DDK_DUMMYUNION_N_MEMBER(n, name) DUMMYUNIONNAME##n.name
  68 #else
  69 # define _DDK_DUMMYUNION_MEMBER(name) name
  70 # define _DDK_DUMMYUNION_N_MEMBER(n, name) name
  71 #endif
  72
  73 /*
  74 ** Forward declarations
  75 */
  76
  77 struct _KPCR;
  78 struct _KPRCB;
  79 struct _KTSS;
  80 struct _DRIVE_LAYOUT_INFORMATION_EX;
  81 struct _LOADER_PARAMETER_BLOCK;
  82
  83
  84 #if 1
  85 /* FIXME: Unknown definitions */
  86 struct _SET_PARTITION_INFORMATION_EX;
  87 typedef ULONG WAIT_TYPE;
  88 #define WaitAll 0
  89 #define WaitAny 1
  90 typedef HANDLE TRACEHANDLE;
  91 typedef PVOID PWMILIB_CONTEXT;
  92 typedef ULONG LOGICAL;
  93 #endif
  94
  95 /*
  96 ** WmiLib specific structure
  97 */
  98 typedef enum
  99 {
 100     IrpProcessed,    // Irp was processed and possibly completed
 101     IrpNotCompleted, // Irp was process and NOT completed
 102     IrpNotWmi,       // Irp is not a WMI irp
 103     IrpForward       // Irp is wmi irp, but targeted at another device object
 104 } SYSCTL_IRP_DISPOSITION, *PSYSCTL_IRP_DISPOSITION;
 105
 106 //
 107 // Forwarder
 108 //
 109 struct _COMPRESSED_DATA_INFO;
 110
 111 #define KERNEL_STACK_SIZE                   12288
 112 #define KERNEL_LARGE_STACK_SIZE             61440
 113 #define KERNEL_LARGE_STACK_COMMIT           12288
 114
 115 #define EXCEPTION_READ_FAULT    0
 116 #define EXCEPTION_WRITE_FAULT   1
 117 #define EXCEPTION_EXECUTE_FAULT 8
 118
 119 #define DPFLTR_ERROR_LEVEL                  0
 120 #define DPFLTR_WARNING_LEVEL                1
 121 #define DPFLTR_TRACE_LEVEL                  2
 122 #define DPFLTR_INFO_LEVEL                   3
 123 #define DPFLTR_MASK                         0x80000000
 124
 125 typedef enum _DPFLTR_TYPE
 126 {
 127     DPFLTR_SYSTEM_ID = 0,
 128     DPFLTR_SMSS_ID = 1,
 129     DPFLTR_SETUP_ID = 2,
 130     DPFLTR_NTFS_ID = 3,
 131     DPFLTR_FSTUB_ID = 4,
 132     DPFLTR_CRASHDUMP_ID = 5,
 133     DPFLTR_CDAUDIO_ID = 6,
 134     DPFLTR_CDROM_ID = 7,
 135     DPFLTR_CLASSPNP_ID = 8,
 136     DPFLTR_DISK_ID = 9,
 137     DPFLTR_REDBOOK_ID = 10,
 138     DPFLTR_STORPROP_ID = 11,
 139     DPFLTR_SCSIPORT_ID = 12,
 140     DPFLTR_SCSIMINIPORT_ID = 13,
 141     DPFLTR_CONFIG_ID = 14,
 142     DPFLTR_I8042PRT_ID = 15,
 143     DPFLTR_SERMOUSE_ID = 16,
 144     DPFLTR_LSERMOUS_ID = 17,
 145     DPFLTR_KBDHID_ID = 18,
 146     DPFLTR_MOUHID_ID = 19,
 147     DPFLTR_KBDCLASS_ID = 20,
 148     DPFLTR_MOUCLASS_ID = 21,
 149     DPFLTR_TWOTRACK_ID = 22,
 150     DPFLTR_WMILIB_ID = 23,
 151     DPFLTR_ACPI_ID = 24,
 152     DPFLTR_AMLI_ID = 25,
 153     DPFLTR_HALIA64_ID = 26,
 154     DPFLTR_VIDEO_ID = 27,
 155     DPFLTR_SVCHOST_ID = 28,
 156     DPFLTR_VIDEOPRT_ID = 29,
 157     DPFLTR_TCPIP_ID = 30,
 158     DPFLTR_DMSYNTH_ID = 31,
 159     DPFLTR_NTOSPNP_ID = 32,
 160     DPFLTR_FASTFAT_ID = 33,
 161     DPFLTR_SAMSS_ID = 34,
 162     DPFLTR_PNPMGR_ID = 35,
 163     DPFLTR_NETAPI_ID = 36,
 164     DPFLTR_SCSERVER_ID = 37,
 165     DPFLTR_SCCLIENT_ID = 38,
 166     DPFLTR_SERIAL_ID = 39,
 167     DPFLTR_SERENUM_ID = 40,
 168     DPFLTR_UHCD_ID = 41,
 169     DPFLTR_BOOTOK_ID = 42,
 170     DPFLTR_BOOTVRFY_ID = 43,
 171     DPFLTR_RPCPROXY_ID = 44,
 172     DPFLTR_AUTOCHK_ID = 45,
 173     DPFLTR_DCOMSS_ID = 46,
 174     DPFLTR_UNIMODEM_ID = 47,
 175     DPFLTR_SIS_ID = 48,
 176     DPFLTR_FLTMGR_ID = 49,
 177     DPFLTR_WMICORE_ID = 50,
 178     DPFLTR_BURNENG_ID = 51,
 179     DPFLTR_IMAPI_ID = 52,
 180     DPFLTR_SXS_ID = 53,
 181     DPFLTR_FUSION_ID = 54,
 182     DPFLTR_IDLETASK_ID = 55,
 183     DPFLTR_SOFTPCI_ID = 56,
 184     DPFLTR_TAPE_ID = 57,
 185     DPFLTR_MCHGR_ID = 58,
 186     DPFLTR_IDEP_ID = 59,
 187     DPFLTR_PCIIDE_ID = 60,
 188     DPFLTR_FLOPPY_ID = 61,
 189     DPFLTR_FDC_ID = 62,
 190     DPFLTR_TERMSRV_ID = 63,
 191     DPFLTR_W32TIME_ID = 64,
 192     DPFLTR_PREFETCHER_ID = 65,
 193     DPFLTR_RSFILTER_ID = 66,
 194     DPFLTR_FCPORT_ID = 67,
 195     DPFLTR_PCI_ID = 68,
 196     DPFLTR_DMIO_ID = 69,
 197     DPFLTR_DMCONFIG_ID = 70,
 198     DPFLTR_DMADMIN_ID = 71,
 199     DPFLTR_WSOCKTRANSPORT_ID = 72,
 200     DPFLTR_VSS_ID = 73,
 201     DPFLTR_PNPMEM_ID = 74,
 202     DPFLTR_PROCESSOR_ID = 75,
 203     DPFLTR_DMSERVER_ID = 76,
 204     DPFLTR_SR_ID = 77,
 205     DPFLTR_INFINIBAND_ID = 78,
 206     DPFLTR_IHVDRIVER_ID = 79,
 207     DPFLTR_IHVVIDEO_ID = 80,
 208     DPFLTR_IHVAUDIO_ID = 81,
 209     DPFLTR_IHVNETWORK_ID = 82,
 210     DPFLTR_IHVSTREAMING_ID = 83,
 211     DPFLTR_IHVBUS_ID = 84,
 212     DPFLTR_HPS_ID = 85,
 213     DPFLTR_RTLTHREADPOOL_ID = 86,
 214     DPFLTR_LDR_ID = 87,
 215     DPFLTR_TCPIP6_ID = 88,
 216     DPFLTR_ISAPNP_ID = 89,
 217     DPFLTR_SHPC_ID = 90,
 218     DPFLTR_STORPORT_ID = 91,
 219     DPFLTR_STORMINIPORT_ID = 92,
 220     DPFLTR_PRINTSPOOLER_ID = 93,
 221     DPFLTR_VDS_ID = 94,
 222     DPFLTR_VDSBAS_ID = 95,
 223     DPFLTR_VDSDYNDR_ID = 96,
 224     DPFLTR_VDSUTIL_ID = 97,
 225     DPFLTR_DFRGIFC_ID = 98,
 226     DPFLTR_DEFAULT_ID = 99,
 227     DPFLTR_MM_ID = 100,
 228     DPFLTR_DFSC_ID = 101,
 229     DPFLTR_WOW64_ID = 102,
 230     DPFLTR_ENDOFTABLE_ID
 231 } DPFLTR_TYPE;
 232
 233 /* also in winnt.h */
 234
 235 #define FILE_COPY_STRUCTURED_STORAGE      0x00000041
 236 #define FILE_STRUCTURED_STORAGE           0x00000441
 237
 238 /* end winnt.h */
 239
 240 #define THREAD_ALERT (0x0004)
 241
 242 /* Exported object types */
 243 extern POBJECT_TYPE NTSYSAPI ExDesktopObjectType;
 244 extern POBJECT_TYPE NTSYSAPI ExEventObjectType;
 245 extern POBJECT_TYPE NTSYSAPI ExSemaphoreObjectType;
 246 extern POBJECT_TYPE NTSYSAPI ExWindowStationObjectType;
 247 extern ULONG NTSYSAPI IoDeviceHandlerObjectSize;
 248 extern POBJECT_TYPE NTSYSAPI IoDeviceHandlerObjectType;
 249 extern POBJECT_TYPE NTSYSAPI IoDeviceObjectType;
 250 extern POBJECT_TYPE NTSYSAPI IoDriverObjectType;
 251 extern POBJECT_TYPE NTSYSAPI IoFileObjectType;
 252 extern POBJECT_TYPE NTSYSAPI PsThreadType;
 253 extern POBJECT_TYPE NTSYSAPI LpcPortObjectType;
 254 extern POBJECT_TYPE NTSYSAPI SeTokenObjectType;
 255 extern POBJECT_TYPE NTSYSAPI PsProcessType;
 256
 257 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 258 extern volatile CCHAR NTSYSAPI KeNumberProcessors;
 259 #else
 260 #if (NTDDI_VERSION >= NTDDI_WINXP)
 261 extern CCHAR NTSYSAPI KeNumberProcessors;
 262 #else
 263 //extern PCCHAR KeNumberProcessors;
 264 extern NTSYSAPI CCHAR KeNumberProcessors; //FIXME: Note to Alex: I won't fix this atm, since I prefer to discuss this with you first.
 265 #endif
 266 #endif
 267
 268 #define MAX_WOW64_SHARED_ENTRIES 16
 269
 270 extern volatile KSYSTEM_TIME KeTickCount;
 271
 272 #define NX_SUPPORT_POLICY_ALWAYSOFF 0
 273 #define NX_SUPPORT_POLICY_ALWAYSON 1
 274 #define NX_SUPPORT_POLICY_OPTIN 2
 275 #define NX_SUPPORT_POLICY_OPTOUT 3
 276
 277 typedef struct _KUSER_SHARED_DATA
 278 {
 279     ULONG TickCountLowDeprecated;
 280     ULONG TickCountMultiplier;
 281     volatile KSYSTEM_TIME InterruptTime;
 282     volatile KSYSTEM_TIME SystemTime;
 283     volatile KSYSTEM_TIME TimeZoneBias;
 284     USHORT ImageNumberLow;
 285     USHORT ImageNumberHigh;
 286     WCHAR NtSystemRoot[260];
 287     ULONG MaxStackTraceDepth;
 288     ULONG CryptoExponent;
 289     ULONG TimeZoneId;
 290     ULONG LargePageMinimum;
 291     ULONG Reserved2[7];
 292     NT_PRODUCT_TYPE NtProductType;
 293     BOOLEAN ProductTypeIsValid;
 294     ULONG NtMajorVersion;
 295     ULONG NtMinorVersion;
 296     BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX];
 297     ULONG Reserved1;
 298     ULONG Reserved3;
 299     volatile ULONG TimeSlip;
 300     ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
 301     LARGE_INTEGER SystemExpirationDate;
 302     ULONG SuiteMask;
 303     BOOLEAN KdDebuggerEnabled;
 304 #if (NTDDI_VERSION >= NTDDI_WINXPSP2)
 305     UCHAR NXSupportPolicy;
 306 #endif
 307     volatile ULONG ActiveConsoleId;
 308     volatile ULONG DismountCount;
 309     ULONG ComPlusPackage;
 310     ULONG LastSystemRITEventTickCount;
 311     ULONG NumberOfPhysicalPages;
 312     BOOLEAN SafeBootMode;
 313     ULONG TraceLogging;
 314     ULONG Fill0;
 315     ULONGLONG TestRetInstruction;
 316     ULONG SystemCall;
 317     ULONG SystemCallReturn;
 318     ULONGLONG SystemCallPad[3];
 319     __GNU_EXTENSION union {
 320         volatile KSYSTEM_TIME TickCount;
 321         volatile ULONG64 TickCountQuad;
 322     };
 323     ULONG Cookie;
 324 #if (NTDDI_VERSION >= NTDDI_WS03)
 325     LONGLONG ConsoleSessionForegroundProcessId;
 326     ULONG Wow64SharedInformation[MAX_WOW64_SHARED_ENTRIES];
 327 #endif
 328 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 329     USHORT UserModeGlobalLogger[8];
 330     ULONG HeapTracingPid[2];
 331     ULONG CritSecTracingPid[2];
 332     __GNU_EXTENSION union
 333     {
 334         ULONG SharedDataFlags;
 335         __GNU_EXTENSION struct
 336         {
 337             ULONG DbgErrorPortPresent:1;
 338             ULONG DbgElevationEnabled:1;
 339             ULONG DbgVirtEnabled:1;
 340             ULONG DbgInstallerDetectEnabled:1;
 341             ULONG SpareBits:28;
 342         };
 343     };
 344     ULONG ImageFileExecutionOptions;
 345     KAFFINITY ActiveProcessorAffinity;
 346 #endif
 347 } KUSER_SHARED_DATA, *PKUSER_SHARED_DATA;
 348
 349 /*
 350 ** IRP function codes
 351 */
 352
 353 #define IRP_MN_QUERY_DIRECTORY            0x01
 354 #define IRP_MN_NOTIFY_CHANGE_DIRECTORY    0x02
 355
 356 #define IRP_MN_USER_FS_REQUEST            0x00
 357 #define IRP_MN_MOUNT_VOLUME               0x01
 358 #define IRP_MN_VERIFY_VOLUME              0x02
 359 #define IRP_MN_LOAD_FILE_SYSTEM           0x03
 360 #define IRP_MN_TRACK_LINK                 0x04
 361 #define IRP_MN_KERNEL_CALL                0x04
 362
 363 #define IRP_MN_LOCK                       0x01
 364 #define IRP_MN_UNLOCK_SINGLE              0x02
 365 #define IRP_MN_UNLOCK_ALL                 0x03
 366 #define IRP_MN_UNLOCK_ALL_BY_KEY          0x04
 367
 368 #define IRP_MN_NORMAL                     0x00
 369 #define IRP_MN_DPC                        0x01
 370 #define IRP_MN_MDL                        0x02
 371 #define IRP_MN_COMPLETE                   0x04
 372 #define IRP_MN_COMPRESSED                 0x08
 373
 374 #define IRP_MN_MDL_DPC                    (IRP_MN_MDL | IRP_MN_DPC)
 375 #define IRP_MN_COMPLETE_MDL               (IRP_MN_COMPLETE | IRP_MN_MDL)
 376 #define IRP_MN_COMPLETE_MDL_DPC           (IRP_MN_COMPLETE_MDL | IRP_MN_DPC)
 377
 378 #define IRP_MN_QUERY_LEGACY_BUS_INFORMATION 0x18
 379
 380 typedef EXCEPTION_DISPOSITION
 381 (DDKAPI *PEXCEPTION_ROUTINE)(
 382   IN struct _EXCEPTION_RECORD *ExceptionRecord,
 383   IN PVOID EstablisherFrame,
 384   IN OUT struct _CONTEXT *ContextRecord,
 385   IN OUT PVOID DispatcherContext);
 386
 387 typedef NTSTATUS
 388 (DDKAPI *PDRIVER_ENTRY)(
 389   IN struct _DRIVER_OBJECT  *DriverObject,
 390   IN PUNICODE_STRING  RegistryPath);
 391
 392 typedef VOID
 393 (DDKAPI *PDRIVER_REINITIALIZE)(
 394   IN struct _DRIVER_OBJECT  *DriverObject,
 395   IN PVOID  Context,
 396   IN ULONG  Count);
 397
 398 typedef BOOLEAN
 399 (DDKAPI *PKTRANSFER_ROUTINE)(
 400   VOID);
 401
 402 #define ASSERT_GATE(object) \
 403     ASSERT((((object)->Header.Type & KOBJECT_TYPE_MASK) == GateObject) || \
 404           (((object)->Header.Type & KOBJECT_TYPE_MASK) == EventSynchronizationObject))
 405
 406 #define TIMER_TABLE_SIZE 512
 407 #define TIMER_TABLE_SHIFT 9
 408
 409 #define ASSERT_TIMER(E) \
 410     ASSERT(((E)->Header.Type == TimerNotificationObject) || \
 411            ((E)->Header.Type == TimerSynchronizationObject))
 412
 413 #define ASSERT_MUTANT(E) \
 414     ASSERT((E)->Header.Type == MutantObject)
 415
 416 #define ASSERT_SEMAPHORE(E) \
 417     ASSERT((E)->Header.Type == SemaphoreObject)
 418
 419 #define ASSERT_EVENT(E) \
 420     ASSERT(((E)->Header.Type == NotificationEvent) || \
 421            ((E)->Header.Type == SynchronizationEvent))
 422
 423
 424 typedef enum _TIMER_TYPE {
 425   NotificationTimer,
 426   SynchronizationTimer
 427 } TIMER_TYPE;
 428
 429 #define KEYBOARD_INSERT_ON                0x08
 430 #define KEYBOARD_CAPS_LOCK_ON             0x04
 431 #define KEYBOARD_NUM_LOCK_ON              0x02
 432 #define KEYBOARD_SCROLL_LOCK_ON           0x01
 433 #define KEYBOARD_ALT_KEY_DOWN             0x80
 434 #define KEYBOARD_CTRL_KEY_DOWN            0x40
 435 #define KEYBOARD_LEFT_SHIFT_DOWN          0x20
 436 #define KEYBOARD_RIGHT_SHIFT_DOWN         0x10
 437
 438 typedef struct _IO_COUNTERS {
 439     ULONGLONG  ReadOperationCount;
 440     ULONGLONG  WriteOperationCount;
 441     ULONGLONG  OtherOperationCount;
 442     ULONGLONG ReadTransferCount;
 443     ULONGLONG WriteTransferCount;
 444     ULONGLONG OtherTransferCount;
 445 } IO_COUNTERS, *PIO_COUNTERS;
 446
 447 typedef struct _VM_COUNTERS
 448 {
 449     SIZE_T PeakVirtualSize;
 450     SIZE_T VirtualSize;
 451     ULONG PageFaultCount;
 452     SIZE_T PeakWorkingSetSize;
 453     SIZE_T WorkingSetSize;
 454     SIZE_T QuotaPeakPagedPoolUsage;
 455     SIZE_T QuotaPagedPoolUsage;
 456     SIZE_T QuotaPeakNonPagedPoolUsage;
 457     SIZE_T QuotaNonPagedPoolUsage;
 458     SIZE_T PagefileUsage;
 459     SIZE_T PeakPagefileUsage;
 460 } VM_COUNTERS, *PVM_COUNTERS;
 461
 462 typedef struct _VM_COUNTERS_EX
 463 {
 464     SIZE_T PeakVirtualSize;
 465     SIZE_T VirtualSize;
 466     ULONG PageFaultCount;
 467     SIZE_T PeakWorkingSetSize;
 468     SIZE_T WorkingSetSize;
 469     SIZE_T QuotaPeakPagedPoolUsage;
 470     SIZE_T QuotaPagedPoolUsage;
 471     SIZE_T QuotaPeakNonPagedPoolUsage;
 472     SIZE_T QuotaNonPagedPoolUsage;
 473     SIZE_T PagefileUsage;
 474     SIZE_T PeakPagefileUsage;
 475     SIZE_T PrivateUsage;
 476 } VM_COUNTERS_EX, *PVM_COUNTERS_EX;
 477
 478 typedef struct _POOLED_USAGE_AND_LIMITS
 479 {
 480     SIZE_T PeakPagedPoolUsage;
 481     SIZE_T PagedPoolUsage;
 482     SIZE_T PagedPoolLimit;
 483     SIZE_T PeakNonPagedPoolUsage;
 484     SIZE_T NonPagedPoolUsage;
 485     SIZE_T NonPagedPoolLimit;
 486     SIZE_T PeakPagefileUsage;
 487     SIZE_T PagefileUsage;
 488     SIZE_T PagefileLimit;
 489 } POOLED_USAGE_AND_LIMITS, *PPOOLED_USAGE_AND_LIMITS;
 490
 491 typedef struct _CONTROLLER_OBJECT {
 492   CSHORT  Type;
 493   CSHORT  Size;
 494   PVOID  ControllerExtension;
 495   KDEVICE_QUEUE  DeviceWaitQueue;
 496   ULONG  Spare1;
 497   LARGE_INTEGER  Spare2;
 498 } CONTROLLER_OBJECT, *PCONTROLLER_OBJECT;
 499
 500 /* DEVICE_OBJECT.Flags */
 501
 502 #define DO_DEVICE_HAS_NAME                0x00000040
 503 #define DO_SYSTEM_BOOT_PARTITION          0x00000100
 504 #define DO_LONG_TERM_REQUESTS             0x00000200
 505 #define DO_NEVER_LAST_DEVICE              0x00000400
 506 #define DO_LOW_PRIORITY_FILESYSTEM        0x00010000
 507 #define DO_XIP                            0x00020000
 508
 509 #define DRVO_REINIT_REGISTERED            0x00000008
 510 #define DRVO_INITIALIZED                  0x00000010
 511 #define DRVO_BOOTREINIT_REGISTERED        0x00000020
 512 #define DRVO_LEGACY_RESOURCES             0x00000040
 513
 514 typedef enum _ARBITER_REQUEST_SOURCE {
 515   ArbiterRequestUndefined = -1,
 516   ArbiterRequestLegacyReported,
 517   ArbiterRequestHalReported,
 518   ArbiterRequestLegacyAssigned,
 519   ArbiterRequestPnpDetected,
 520   ArbiterRequestPnpEnumerated
 521 } ARBITER_REQUEST_SOURCE;
 522
 523 typedef enum _ARBITER_RESULT {
 524   ArbiterResultUndefined = -1,
 525   ArbiterResultSuccess,
 526   ArbiterResultExternalConflict,
 527   ArbiterResultNullRequest
 528 } ARBITER_RESULT;
 529
 530 typedef enum _ARBITER_ACTION {
 531   ArbiterActionTestAllocation,
 532   ArbiterActionRetestAllocation,
 533   ArbiterActionCommitAllocation,
 534   ArbiterActionRollbackAllocation,
 535   ArbiterActionQueryAllocatedResources,
 536   ArbiterActionWriteReservedResources,
 537   ArbiterActionQueryConflict,
 538   ArbiterActionQueryArbitrate,
 539   ArbiterActionAddReserved,
 540   ArbiterActionBootAllocation
 541 } ARBITER_ACTION, *PARBITER_ACTION;
 542
 543 typedef struct _ARBITER_CONFLICT_INFO {
 544   PDEVICE_OBJECT  OwningObject;
 545   ULONGLONG  Start;
 546   ULONGLONG  End;
 547 } ARBITER_CONFLICT_INFO, *PARBITER_CONFLICT_INFO;
 548
 549 typedef struct _ARBITER_PARAMETERS {
 550   union {
 551     struct {
 552       IN OUT PLIST_ENTRY  ArbitrationList;
 553       IN ULONG  AllocateFromCount;
 554       IN PCM_PARTIAL_RESOURCE_DESCRIPTOR  AllocateFrom;
 555     } TestAllocation;
 556
 557     struct {
 558       IN OUT PLIST_ENTRY  ArbitrationList;
 559       IN ULONG  AllocateFromCount;
 560       IN PCM_PARTIAL_RESOURCE_DESCRIPTOR  AllocateFrom;
 561     } RetestAllocation;
 562
 563     struct {
 564       IN OUT PLIST_ENTRY  ArbitrationList;
 565     } BootAllocation;
 566
 567     struct {
 568       OUT PCM_PARTIAL_RESOURCE_LIST  *AllocatedResources;
 569     } QueryAllocatedResources;
 570
 571     struct {
 572       IN PDEVICE_OBJECT  PhysicalDeviceObject;
 573       IN PIO_RESOURCE_DESCRIPTOR  ConflictingResource;
 574       OUT PULONG  ConflictCount;
 575       OUT PARBITER_CONFLICT_INFO  *Conflicts;
 576     } QueryConflict;
 577
 578     struct {
 579       IN PLIST_ENTRY  ArbitrationList;
 580     } QueryArbitrate;
 581
 582     struct {
 583       IN PDEVICE_OBJECT  ReserveDevice;
 584     } AddReserved;
 585   } Parameters;
 586 } ARBITER_PARAMETERS, *PARBITER_PARAMETERS;
 587
 588 #define ARBITER_FLAG_BOOT_CONFIG 0x00000001
 589
 590 typedef struct _ARBITER_LIST_ENTRY {
 591   LIST_ENTRY  ListEntry;
 592   ULONG  AlternativeCount;
 593   PIO_RESOURCE_DESCRIPTOR  Alternatives;
 594   PDEVICE_OBJECT  PhysicalDeviceObject;
 595   ARBITER_REQUEST_SOURCE  RequestSource;
 596   ULONG  Flags;
 597   LONG_PTR  WorkSpace;
 598   INTERFACE_TYPE  InterfaceType;
 599   ULONG  SlotNumber;
 600   ULONG  BusNumber;
 601   PCM_PARTIAL_RESOURCE_DESCRIPTOR  Assignment;
 602   PIO_RESOURCE_DESCRIPTOR  SelectedAlternative;
 603   ARBITER_RESULT  Result;
 604 } ARBITER_LIST_ENTRY, *PARBITER_LIST_ENTRY;
 605
 606 typedef NTSTATUS
 607 (DDKAPI *PARBITER_HANDLER)(
 608   IN PVOID  Context,
 609   IN ARBITER_ACTION  Action,
 610   IN OUT PARBITER_PARAMETERS  Parameters);
 611
 612 #define ARBITER_PARTIAL 0x00000001
 613
 614 typedef struct _ARBITER_INTERFACE {
 615   USHORT  Size;
 616   USHORT  Version;
 617   PVOID  Context;
 618   PINTERFACE_REFERENCE  InterfaceReference;
 619   PINTERFACE_DEREFERENCE  InterfaceDereference;
 620   PARBITER_HANDLER  ArbiterHandler;
 621   ULONG  Flags;
 622 } ARBITER_INTERFACE, *PARBITER_INTERFACE;
 623
 624 typedef enum _HAL_QUERY_INFORMATION_CLASS {
 625   HalInstalledBusInformation,
 626   HalProfileSourceInformation,
 627   HalInformationClassUnused1,
 628   HalPowerInformation,
 629   HalProcessorSpeedInformation,
 630   HalCallbackInformation,
 631   HalMapRegisterInformation,
 632   HalMcaLogInformation,
 633   HalFrameBufferCachingInformation,
 634   HalDisplayBiosInformation,
 635   HalProcessorFeatureInformation,
 636   HalNumaTopologyInterface,
 637   HalErrorInformation,
 638   HalCmcLogInformation,
 639   HalCpeLogInformation,
 640   HalQueryMcaInterface,
 641   HalQueryAMLIIllegalIOPortAddresses,
 642   HalQueryMaxHotPlugMemoryAddress,
 643   HalPartitionIpiInterface,
 644   HalPlatformInformation,
 645   HalQueryProfileSourceList
 646 } HAL_QUERY_INFORMATION_CLASS, *PHAL_QUERY_INFORMATION_CLASS;
 647
 648 typedef enum _HAL_SET_INFORMATION_CLASS {
 649   HalProfileSourceInterval,
 650   HalProfileSourceInterruptHandler,
 651   HalMcaRegisterDriver,
 652   HalKernelErrorHandler,
 653   HalCmcRegisterDriver,
 654   HalCpeRegisterDriver,
 655   HalMcaLog,
 656   HalCmcLog,
 657   HalCpeLog,
 658   HalGenerateCmcInterrupt
 659 } HAL_SET_INFORMATION_CLASS, *PHAL_SET_INFORMATION_CLASS;
 660
 661 typedef struct _HAL_PROFILE_SOURCE_INTERVAL
 662 {
 663     KPROFILE_SOURCE Source;
 664     ULONG_PTR Interval;
 665 } HAL_PROFILE_SOURCE_INTERVAL, *PHAL_PROFILE_SOURCE_INTERVAL;
 666
 667 typedef struct _HAL_PROFILE_SOURCE_INFORMATION
 668 {
 669     KPROFILE_SOURCE Source;
 670     BOOLEAN Supported;
 671     ULONG Interval;
 672 } HAL_PROFILE_SOURCE_INFORMATION, *PHAL_PROFILE_SOURCE_INFORMATION;
 673
 674 typedef struct _MAP_REGISTER_ENTRY
 675 {
 676     PVOID MapRegister;
 677     BOOLEAN WriteToDevice;
 678 } MAP_REGISTER_ENTRY, *PMAP_REGISTER_ENTRY;
 679
 680 typedef struct
 681 {
 682     UCHAR Type;
 683     BOOLEAN Valid;
 684     UCHAR Reserved[2];
 685     PUCHAR TranslatedAddress;
 686     ULONG Length;
 687 } DEBUG_DEVICE_ADDRESS, *PDEBUG_DEVICE_ADDRESS;
 688
 689 typedef struct
 690 {
 691     PHYSICAL_ADDRESS Start;
 692     PHYSICAL_ADDRESS MaxEnd;
 693     PVOID VirtualAddress;
 694     ULONG Length;
 695     BOOLEAN Cached;
 696     BOOLEAN Aligned;
 697 } DEBUG_MEMORY_REQUIREMENTS, *PDEBUG_MEMORY_REQUIREMENTS;
 698
 699 typedef struct
 700 {
 701     ULONG Bus;
 702     ULONG Slot;
 703     USHORT VendorID;
 704     USHORT DeviceID;
 705     UCHAR BaseClass;
 706     UCHAR SubClass;
 707     UCHAR ProgIf;
 708     BOOLEAN Initialized;
 709     DEBUG_DEVICE_ADDRESS BaseAddress[6];
 710     DEBUG_MEMORY_REQUIREMENTS Memory;
 711 } DEBUG_DEVICE_DESCRIPTOR, *PDEBUG_DEVICE_DESCRIPTOR;
 712
 713 /* Function Type Defintions for Dispatch Functions */
 714 struct _DEVICE_CONTROL_CONTEXT;
 715
 716 typedef VOID
 717 (DDKAPI *PDEVICE_CONTROL_COMPLETION)(
 718   IN struct _DEVICE_CONTROL_CONTEXT  *ControlContext);
 719
 720 typedef struct _DEVICE_CONTROL_CONTEXT {
 721   NTSTATUS  Status;
 722   PDEVICE_HANDLER_OBJECT  DeviceHandler;
 723   PDEVICE_OBJECT  DeviceObject;
 724   ULONG  ControlCode;
 725   PVOID  Buffer;
 726   PULONG  BufferLength;
 727   PVOID  Context;
 728 } DEVICE_CONTROL_CONTEXT, *PDEVICE_CONTROL_CONTEXT;
 729
 730 typedef struct _PM_DISPATCH_TABLE {
 731   ULONG  Signature;
 732   ULONG  Version;
 733   PVOID  Function[1];
 734 } PM_DISPATCH_TABLE, *PPM_DISPATCH_TABLE;
 735
 736 typedef enum _RESOURCE_TRANSLATION_DIRECTION {
 737   TranslateChildToParent,
 738   TranslateParentToChild
 739 } RESOURCE_TRANSLATION_DIRECTION;
 740
 741 typedef NTSTATUS
 742 (DDKAPI *PTRANSLATE_RESOURCE_HANDLER)(
 743   IN PVOID  Context,
 744   IN PCM_PARTIAL_RESOURCE_DESCRIPTOR  Source,
 745   IN RESOURCE_TRANSLATION_DIRECTION  Direction,
 746   IN ULONG  AlternativesCount,
 747   IN IO_RESOURCE_DESCRIPTOR  Alternatives[],
 748   IN PDEVICE_OBJECT  PhysicalDeviceObject,
 749   OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR  Target);
 750
 751 typedef NTSTATUS
 752 (DDKAPI *PTRANSLATE_RESOURCE_REQUIREMENTS_HANDLER)(
 753   IN PVOID  Context,
 754   IN PIO_RESOURCE_DESCRIPTOR  Source,
 755   IN PDEVICE_OBJECT  PhysicalDeviceObject,
 756   OUT PULONG  TargetCount,
 757   OUT PIO_RESOURCE_DESCRIPTOR  *Target);
 758
 759 typedef struct _TRANSLATOR_INTERFACE {
 760   USHORT  Size;
 761   USHORT  Version;
 762   PVOID  Context;
 763   PINTERFACE_REFERENCE  InterfaceReference;
 764   PINTERFACE_DEREFERENCE  InterfaceDereference;
 765   PTRANSLATE_RESOURCE_HANDLER  TranslateResources;
 766   PTRANSLATE_RESOURCE_REQUIREMENTS_HANDLER  TranslateResourceRequirements;
 767 } TRANSLATOR_INTERFACE, *PTRANSLATOR_INTERFACE;
 768
 769 typedef NTSTATUS
 770 (DDKAPI *pHalDeviceControl)(
 771   IN PDEVICE_HANDLER_OBJECT  DeviceHandler,
 772   IN PDEVICE_OBJECT  DeviceObject,
 773   IN ULONG  ControlCode,
 774   IN OUT PVOID  Buffer OPTIONAL,
 775   IN OUT PULONG  BufferLength OPTIONAL,
 776   IN PVOID  Context,
 777   IN PDEVICE_CONTROL_COMPLETION  CompletionRoutine);
 778
 779 typedef VOID
 780 (FASTCALL *pHalExamineMBR)(
 781   IN PDEVICE_OBJECT  DeviceObject,
 782   IN ULONG  SectorSize,
 783   IN ULONG  MBRTypeIdentifier,
 784   OUT PVOID  *Buffer);
 785
 786 typedef VOID
 787 (FASTCALL *pHalIoAssignDriveLetters)(
 788   IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock,
 789   IN PSTRING NtDeviceName,
 790   OUT PUCHAR NtSystemPath,
 791   OUT PSTRING NtSystemPathString);
 792
 793 typedef NTSTATUS
 794 (FASTCALL *pHalIoReadPartitionTable)(
 795   IN PDEVICE_OBJECT  DeviceObject,
 796   IN ULONG  SectorSize,
 797   IN BOOLEAN  ReturnRecognizedPartitions,
 798   OUT struct _DRIVE_LAYOUT_INFORMATION **PartitionBuffer);
 799
 800 typedef NTSTATUS
 801 (FASTCALL *pHalIoSetPartitionInformation)(
 802   IN PDEVICE_OBJECT  DeviceObject,
 803   IN ULONG  SectorSize,
 804   IN ULONG  PartitionNumber,
 805   IN ULONG  PartitionType);
 806
 807 typedef NTSTATUS
 808 (FASTCALL *pHalIoWritePartitionTable)(
 809   IN PDEVICE_OBJECT  DeviceObject,
 810   IN ULONG  SectorSize,
 811   IN ULONG  SectorsPerTrack,
 812   IN ULONG  NumberOfHeads,
 813   IN struct _DRIVE_LAYOUT_INFORMATION *PartitionBuffer);
 814
 815 typedef PBUS_HANDLER
 816 (FASTCALL *pHalHandlerForBus)(
 817   IN INTERFACE_TYPE  InterfaceType,
 818   IN ULONG  BusNumber);
 819
 820 typedef VOID
 821 (FASTCALL *pHalReferenceBusHandler)(
 822   IN PBUS_HANDLER  BusHandler);
 823
 824 typedef NTSTATUS
 825 (DDKAPI *pHalQuerySystemInformation)(
 826   IN HAL_QUERY_INFORMATION_CLASS  InformationClass,
 827   IN ULONG  BufferSize,
 828   IN OUT PVOID  Buffer,
 829   OUT PULONG  ReturnedLength);
 830
 831 typedef NTSTATUS
 832 (DDKAPI *pHalSetSystemInformation)(
 833   IN HAL_SET_INFORMATION_CLASS  InformationClass,
 834   IN ULONG  BufferSize,
 835   IN PVOID  Buffer);
 836
 837 typedef NTSTATUS
 838 (DDKAPI *pHalQueryBusSlots)(
 839   IN PBUS_HANDLER  BusHandler,
 840   IN ULONG  BufferSize,
 841   OUT PULONG  SlotNumbers,
 842   OUT PULONG  ReturnedLength);
 843
 844 typedef NTSTATUS
 845 (DDKAPI *pHalInitPnpDriver)(
 846   VOID);
 847
 848 typedef NTSTATUS
 849 (DDKAPI *pHalInitPowerManagement)(
 850   IN PPM_DISPATCH_TABLE  PmDriverDispatchTable,
 851   OUT PPM_DISPATCH_TABLE  *PmHalDispatchTable);
 852
 853 typedef struct _DMA_ADAPTER*
 854 (DDKAPI *pHalGetDmaAdapter)(
 855   IN PVOID  Context,
 856   IN struct _DEVICE_DESCRIPTION  *DeviceDescriptor,
 857   OUT PULONG  NumberOfMapRegisters);
 858
 859 typedef NTSTATUS
 860 (DDKAPI *pHalGetInterruptTranslator)(
 861   IN INTERFACE_TYPE  ParentInterfaceType,
 862   IN ULONG  ParentBusNumber,
 863   IN INTERFACE_TYPE  BridgeInterfaceType,
 864   IN USHORT  Size,
 865   IN USHORT  Version,
 866   OUT PTRANSLATOR_INTERFACE  Translator,
 867   OUT PULONG  BridgeBusNumber);
 868
 869 typedef NTSTATUS
 870 (DDKAPI *pHalStartMirroring)(
 871   VOID);
 872
 873 typedef NTSTATUS
 874 (DDKAPI *pHalEndMirroring)(
 875   IN ULONG  PassNumber);
 876
 877 typedef NTSTATUS
 878 (DDKAPI *pHalMirrorPhysicalMemory)(
 879   IN PHYSICAL_ADDRESS  PhysicalAddress,
 880   IN LARGE_INTEGER  NumberOfBytes);
 881
 882 typedef NTSTATUS
 883 (DDKAPI *pHalMirrorVerify)(
 884   IN PHYSICAL_ADDRESS  PhysicalAddress,
 885   IN LARGE_INTEGER  NumberOfBytes);
 886
 887 typedef VOID
 888 (DDKAPI *pHalEndOfBoot)(
 889   VOID);
 890
 891 typedef
 892 BOOLEAN
 893 (DDKAPI *pHalTranslateBusAddress)(
 894     IN INTERFACE_TYPE InterfaceType,
 895     IN ULONG BusNumber,
 896     IN PHYSICAL_ADDRESS BusAddress,
 897     IN OUT PULONG AddressSpace,
 898     OUT PPHYSICAL_ADDRESS TranslatedAddress
 899 );
 900
 901 typedef
 902 NTSTATUS
 903 (DDKAPI *pHalAssignSlotResources)(
 904     IN PUNICODE_STRING RegistryPath,
 905     IN PUNICODE_STRING DriverClassName OPTIONAL,
 906     IN PDRIVER_OBJECT DriverObject,
 907     IN PDEVICE_OBJECT DeviceObject,
 908     IN INTERFACE_TYPE BusType,
 909     IN ULONG BusNumber,
 910     IN ULONG SlotNumber,
 911     IN OUT PCM_RESOURCE_LIST *AllocatedResources
 912 );
 913
 914 typedef
 915 VOID
 916 (DDKAPI *pHalHaltSystem)(
 917     VOID
 918 );
 919
 920 typedef
 921 BOOLEAN
 922 (DDKAPI *pHalResetDisplay)(
 923     VOID
 924 );
 925
 926 typedef
 927 UCHAR
 928 (DDKAPI *pHalVectorToIDTEntry)(
 929     ULONG Vector
 930 );
 931
 932 typedef
 933 BOOLEAN
 934 (DDKAPI *pHalFindBusAddressTranslation)(
 935     IN PHYSICAL_ADDRESS BusAddress,
 936     IN OUT PULONG AddressSpace,
 937     OUT PPHYSICAL_ADDRESS TranslatedAddress,
 938     IN OUT PULONG_PTR Context,
 939     IN BOOLEAN NextBus
 940 );
 941
 942 typedef
 943 NTSTATUS
 944 (DDKAPI *pKdSetupPciDeviceForDebugging)(
 945     IN PVOID LoaderBlock OPTIONAL,
 946     IN OUT PDEBUG_DEVICE_DESCRIPTOR PciDevice
 947 );
 948
 949 typedef
 950 NTSTATUS
 951 (DDKAPI *pKdReleasePciDeviceForDebugging)(
 952     IN OUT PDEBUG_DEVICE_DESCRIPTOR PciDevice
 953 );
 954
 955 typedef
 956 PVOID
 957 (DDKAPI *pKdGetAcpiTablePhase0)(
 958     IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock,
 959     IN ULONG Signature
 960 );
 961
 962 typedef
 963 VOID
 964 (DDKAPI *pKdCheckPowerButton)(
 965     VOID
 966 );
 967
 968 typedef
 969 ULONG
 970 (DDKAPI *pHalGetInterruptVector)(
 971     IN INTERFACE_TYPE InterfaceType,
 972     IN ULONG BusNumber,
 973     IN ULONG BusInterruptLevel,
 974     IN ULONG BusInterruptVector,
 975     OUT PKIRQL Irql,
 976     OUT PKAFFINITY Affinity
 977 );
 978
 979 typedef
 980 NTSTATUS
 981 (DDKAPI *pHalGetVectorInput)(
 982     IN ULONG Vector,
 983     IN KAFFINITY Affinity,
 984     OUT PULONG Input,
 985     OUT PKINTERRUPT_POLARITY Polarity
 986 );
 987
 988 typedef
 989 PVOID
 990 (DDKAPI *pKdMapPhysicalMemory64)(
 991     IN PHYSICAL_ADDRESS PhysicalAddress,
 992     IN ULONG NumberPages
 993 );
 994
 995 typedef
 996 VOID
 997 (DDKAPI *pKdUnmapVirtualAddress)(
 998     IN PVOID VirtualAddress,
 999     IN ULONG NumberPages
1000 );
1001
1002 typedef
1003 ULONG
1004 (DDKAPI *pKdGetPciDataByOffset)(
1005     IN ULONG BusNumber,
1006     IN ULONG SlotNumber,
1007     OUT PVOID Buffer,
1008     IN ULONG Offset,
1009     IN ULONG Length
1010 );
1011
1012 typedef
1013 ULONG
1014 (DDKAPI *pKdSetPciDataByOffset)(
1015     IN ULONG BusNumber,
1016     IN ULONG SlotNumber,
1017     IN PVOID Buffer,
1018     IN ULONG Offset,
1019     IN ULONG Length
1020 );
1021
1022 typedef BOOLEAN
1023 (DDKAPI *PHAL_RESET_DISPLAY_PARAMETERS)(
1024   ULONG Columns, ULONG Rows);
1025
1026 typedef struct {
1027   ULONG  Version;
1028   pHalQuerySystemInformation  HalQuerySystemInformation;
1029   pHalSetSystemInformation  HalSetSystemInformation;
1030   pHalQueryBusSlots  HalQueryBusSlots;
1031   ULONG  Spare1;
1032   pHalExamineMBR  HalExamineMBR;
1033   pHalIoAssignDriveLetters  HalIoAssignDriveLetters;
1034   pHalIoReadPartitionTable  HalIoReadPartitionTable;
1035   pHalIoSetPartitionInformation  HalIoSetPartitionInformation;
1036   pHalIoWritePartitionTable  HalIoWritePartitionTable;
1037   pHalHandlerForBus  HalReferenceHandlerForBus;
1038   pHalReferenceBusHandler  HalReferenceBusHandler;
1039   pHalReferenceBusHandler  HalDereferenceBusHandler;
1040   pHalInitPnpDriver  HalInitPnpDriver;
1041   pHalInitPowerManagement  HalInitPowerManagement;
1042   pHalGetDmaAdapter  HalGetDmaAdapter;
1043   pHalGetInterruptTranslator  HalGetInterruptTranslator;
1044   pHalStartMirroring  HalStartMirroring;
1045   pHalEndMirroring  HalEndMirroring;
1046   pHalMirrorPhysicalMemory  HalMirrorPhysicalMemory;
1047   pHalEndOfBoot  HalEndOfBoot;
1048   pHalMirrorVerify  HalMirrorVerify;
1049 } HAL_DISPATCH, *PHAL_DISPATCH;
1050
1051 #if defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTHAL_)
1052 extern NTSYSAPI PHAL_DISPATCH HalDispatchTable;
1053 #define HALDISPATCH ((PHAL_DISPATCH)&HalDispatchTable)
1054 #else
1055 extern __declspec(dllexport) HAL_DISPATCH HalDispatchTable;
1056 #define HALDISPATCH (&HalDispatchTable)
1057 #endif
1058
1059 #define HAL_DISPATCH_VERSION            3
1060 #define HalDispatchTableVersion         HALDISPATCH->Version
1061 #define HalQuerySystemInformation       HALDISPATCH->HalQuerySystemInformation
1062 #define HalSetSystemInformation         HALDISPATCH->HalSetSystemInformation
1063 #define HalQueryBusSlots                HALDISPATCH->HalQueryBusSlots
1064 #define HalReferenceHandlerForBus       HALDISPATCH->HalReferenceHandlerForBus
1065 #define HalReferenceBusHandler          HALDISPATCH->HalReferenceBusHandler
1066 #define HalDereferenceBusHandler        HALDISPATCH->HalDereferenceBusHandler
1067 #define HalInitPnpDriver                HALDISPATCH->HalInitPnpDriver
1068 #define HalInitPowerManagement          HALDISPATCH->HalInitPowerManagement
1069 #define HalGetDmaAdapter                HALDISPATCH->HalGetDmaAdapter
1070 #define HalGetInterruptTranslator       HALDISPATCH->HalGetInterruptTranslator
1071 #define HalStartMirroring               HALDISPATCH->HalStartMirroring
1072 #define HalEndMirroring                 HALDISPATCH->HalEndMirroring
1073 #define HalMirrorPhysicalMemory         HALDISPATCH->HalMirrorPhysicalMemory
1074 #define HalEndOfBoot                    HALDISPATCH->HalEndOfBoot
1075 #define HalMirrorVerify                 HALDISPATCH->HalMirrorVerify
1076
1077 typedef struct _FILE_ALIGNMENT_INFORMATION {
1078   ULONG  AlignmentRequirement;
1079 } FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION;
1080
1081 typedef struct _FILE_NAME_INFORMATION {
1082   ULONG  FileNameLength;
1083   WCHAR  FileName[1];
1084 } FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION;
1085
1086
1087 typedef struct _FILE_ATTRIBUTE_TAG_INFORMATION {
1088   ULONG  FileAttributes;
1089   ULONG  ReparseTag;
1090 } FILE_ATTRIBUTE_TAG_INFORMATION, *PFILE_ATTRIBUTE_TAG_INFORMATION;
1091
1092 typedef struct _FILE_DISPOSITION_INFORMATION {
1093   BOOLEAN  DeleteFile;
1094 } FILE_DISPOSITION_INFORMATION, *PFILE_DISPOSITION_INFORMATION;
1095
1096 typedef struct _FILE_END_OF_FILE_INFORMATION {
1097   LARGE_INTEGER  EndOfFile;
1098 } FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_INFORMATION;
1099
1100 typedef struct _FILE_VALID_DATA_LENGTH_INFORMATION {
1101   LARGE_INTEGER  ValidDataLength;
1102 } FILE_VALID_DATA_LENGTH_INFORMATION, *PFILE_VALID_DATA_LENGTH_INFORMATION;
1103
1104 typedef union _FILE_SEGMENT_ELEMENT {
1105     PVOID64 Buffer;
1106     ULONGLONG Alignment;
1107 }FILE_SEGMENT_ELEMENT, *PFILE_SEGMENT_ELEMENT;
1108
1109 #define SE_UNSOLICITED_INPUT_PRIVILEGE    6
1110
1111 typedef struct _KEY_USER_FLAGS_INFORMATION {
1112   ULONG  UserFlags;
1113 } KEY_USER_FLAGS_INFORMATION, *PKEY_USER_FLAGS_INFORMATION;
1114
1115 #define PCI_ADDRESS_MEMORY_SPACE            0x00000000
1116
1117 typedef struct _OSVERSIONINFOA {
1118     ULONG dwOSVersionInfoSize;
1119     ULONG dwMajorVersion;
1120     ULONG dwMinorVersion;
1121     ULONG dwBuildNumber;
1122     ULONG dwPlatformId;
1123     CHAR   szCSDVersion[128];
1124 } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
1125
1126 typedef struct _OSVERSIONINFOW {
1127     ULONG dwOSVersionInfoSize;
1128     ULONG dwMajorVersion;
1129     ULONG dwMinorVersion;
1130     ULONG dwBuildNumber;
1131     ULONG dwPlatformId;
1132     WCHAR  szCSDVersion[128];
1133 } OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
1134
1135 #ifdef UNICODE
1136 typedef OSVERSIONINFOW OSVERSIONINFO;
1137 typedef POSVERSIONINFOW POSVERSIONINFO;
1138 typedef LPOSVERSIONINFOW LPOSVERSIONINFO;
1139 #else
1140 typedef OSVERSIONINFOA OSVERSIONINFO;
1141 typedef POSVERSIONINFOA POSVERSIONINFO;
1142 typedef LPOSVERSIONINFOA LPOSVERSIONINFO;
1143 #endif // UNICODE
1144
1145 typedef struct _OSVERSIONINFOEXA {
1146     ULONG dwOSVersionInfoSize;
1147     ULONG dwMajorVersion;
1148     ULONG dwMinorVersion;
1149     ULONG dwBuildNumber;
1150     ULONG dwPlatformId;
1151     CHAR   szCSDVersion[128];
1152     USHORT wServicePackMajor;
1153     USHORT wServicePackMinor;
1154     USHORT wSuiteMask;
1155     UCHAR wProductType;
1156     UCHAR wReserved;
1157 } OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA;
1158
1159 typedef struct _OSVERSIONINFOEXW {
1160     ULONG dwOSVersionInfoSize;
1161     ULONG dwMajorVersion;
1162     ULONG dwMinorVersion;
1163     ULONG dwBuildNumber;
1164     ULONG dwPlatformId;
1165     WCHAR  szCSDVersion[128];
1166     USHORT wServicePackMajor;
1167     USHORT wServicePackMinor;
1168     USHORT wSuiteMask;
1169     UCHAR wProductType;
1170     UCHAR wReserved;
1171 } OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW, RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW;
1172
1173 #ifdef UNICODE
1174 typedef OSVERSIONINFOEXW OSVERSIONINFOEX;
1175 typedef POSVERSIONINFOEXW POSVERSIONINFOEX;
1176 typedef LPOSVERSIONINFOEXW LPOSVERSIONINFOEX;
1177 #else
1178 typedef OSVERSIONINFOEXA OSVERSIONINFOEX;
1179 typedef POSVERSIONINFOEXA POSVERSIONINFOEX;
1180 typedef LPOSVERSIONINFOEXA LPOSVERSIONINFOEX;
1181 #endif // UNICODE
1182
1183 NTSYSAPI
1184 ULONGLONG
1185 DDKAPI
1186 VerSetConditionMask(
1187   IN ULONGLONG  ConditionMask,
1188   IN ULONG  TypeMask,
1189   IN UCHAR  Condition);
1190
1191 #define VER_SET_CONDITION(ConditionMask, TypeBitMask, ComparisonType)  \
1192         ((ConditionMask) = VerSetConditionMask((ConditionMask), \
1193         (TypeBitMask), (ComparisonType)))
1194
1195 /* RtlVerifyVersionInfo() TypeMask */
1196
1197 #define VER_MINORVERSION                  0x0000001
1198 #define VER_MAJORVERSION                  0x0000002
1199 #define VER_BUILDNUMBER                   0x0000004
1200 #define VER_PLATFORMID                    0x0000008
1201 #define VER_SERVICEPACKMINOR              0x0000010
1202 #define VER_SERVICEPACKMAJOR              0x0000020
1203 #define VER_SUITENAME                     0x0000040
1204 #define VER_PRODUCT_TYPE                  0x0000080
1205
1206 /* RtlVerifyVersionInfo() ComparisonType */
1207
1208 #define VER_EQUAL                       1
1209 #define VER_GREATER                     2
1210 #define VER_GREATER_EQUAL               3
1211 #define VER_LESS                        4
1212 #define VER_LESS_EQUAL                  5
1213 #define VER_AND                         6
1214 #define VER_OR                          7
1215
1216 #define VER_CONDITION_MASK              7
1217 #define VER_NUM_BITS_PER_CONDITION_MASK 3
1218
1219 struct _RTL_RANGE;
1220
1221 typedef BOOLEAN
1222 (NTAPI *PRTL_CONFLICT_RANGE_CALLBACK) (
1223     PVOID Context,
1224     struct _RTL_RANGE *Range
1225 );
1226
1227 typedef struct _CONFIGURATION_INFORMATION {
1228   ULONG  DiskCount;
1229   ULONG  FloppyCount;
1230   ULONG  CdRomCount;
1231   ULONG  TapeCount;
1232   ULONG  ScsiPortCount;
1233   ULONG  SerialCount;
1234   ULONG  ParallelCount;
1235   BOOLEAN  AtDiskPrimaryAddressClaimed;
1236   BOOLEAN  AtDiskSecondaryAddressClaimed;
1237   ULONG  Version;
1238   ULONG  MediumChangerCount;
1239 } CONFIGURATION_INFORMATION, *PCONFIGURATION_INFORMATION;
1240
1241 typedef enum _CONFIGURATION_TYPE {
1242   ArcSystem,
1243   CentralProcessor,
1244   FloatingPointProcessor,
1245   PrimaryIcache,
1246   PrimaryDcache,
1247   SecondaryIcache,
1248   SecondaryDcache,
1249   SecondaryCache,
1250   EisaAdapter,
1251   TcAdapter,
1252   ScsiAdapter,
1253   DtiAdapter,
1254   MultiFunctionAdapter,
1255   DiskController,
1256   TapeController,
1257   CdromController,
1258   WormController,
1259   SerialController,
1260   NetworkController,
1261   DisplayController,
1262   ParallelController,
1263   PointerController,
1264   KeyboardController,
1265   AudioController,
1266   OtherController,
1267   DiskPeripheral,
1268   FloppyDiskPeripheral,
1269   TapePeripheral,
1270   ModemPeripheral,
1271   MonitorPeripheral,
1272   PrinterPeripheral,
1273   PointerPeripheral,
1274   KeyboardPeripheral,
1275   TerminalPeripheral,
1276   OtherPeripheral,
1277   LinePeripheral,
1278   NetworkPeripheral,
1279   SystemMemory,
1280   DockingInformation,
1281   RealModeIrqRoutingTable,
1282   RealModePCIEnumeration,
1283   MaximumType
1284 } CONFIGURATION_TYPE, *PCONFIGURATION_TYPE;
1285
1286 typedef NTSTATUS
1287 (DDKAPI *PIO_QUERY_DEVICE_ROUTINE)(
1288   IN PVOID  Context,
1289   IN PUNICODE_STRING  PathName,
1290   IN INTERFACE_TYPE  BusType,
1291   IN ULONG  BusNumber,
1292   IN PKEY_VALUE_FULL_INFORMATION  *BusInformation,
1293   IN CONFIGURATION_TYPE  ControllerType,
1294   IN ULONG  ControllerNumber,
1295   IN PKEY_VALUE_FULL_INFORMATION  *ControllerInformation,
1296   IN CONFIGURATION_TYPE  PeripheralType,
1297   IN ULONG  PeripheralNumber,
1298   IN PKEY_VALUE_FULL_INFORMATION  *PeripheralInformation);
1299
1300 typedef enum _IO_QUERY_DEVICE_DATA_FORMAT {
1301   IoQueryDeviceIdentifier = 0,
1302   IoQueryDeviceConfigurationData,
1303   IoQueryDeviceComponentInformation,
1304   IoQueryDeviceMaxData
1305 } IO_QUERY_DEVICE_DATA_FORMAT, *PIO_QUERY_DEVICE_DATA_FORMAT;
1306
1307 typedef VOID
1308 (DDKAPI *PCREATE_PROCESS_NOTIFY_ROUTINE)(
1309   IN HANDLE  ParentId,
1310   IN HANDLE  ProcessId,
1311   IN BOOLEAN  Create);
1312
1313 typedef VOID
1314 (DDKAPI *PCREATE_THREAD_NOTIFY_ROUTINE)(
1315   IN HANDLE  ProcessId,
1316   IN HANDLE  ThreadId,
1317   IN BOOLEAN  Create);
1318
1319 typedef struct _IMAGE_INFO {
1320   _ANONYMOUS_UNION union {
1321     ULONG  Properties;
1322     _ANONYMOUS_STRUCT struct {
1323       ULONG  ImageAddressingMode  : 8;
1324       ULONG  SystemModeImage      : 1;
1325       ULONG  ImageMappedToAllPids : 1;
1326       ULONG  Reserved             : 22;
1327     } DUMMYSTRUCTNAME;
1328   } DUMMYUNIONNAME;
1329   PVOID  ImageBase;
1330   ULONG  ImageSelector;
1331   SIZE_T  ImageSize;
1332   ULONG  ImageSectionNumber;
1333 } IMAGE_INFO, *PIMAGE_INFO;
1334
1335 #define IMAGE_ADDRESSING_MODE_32BIT       3
1336
1337 typedef VOID
1338 (DDKAPI *PLOAD_IMAGE_NOTIFY_ROUTINE)(
1339   IN PUNICODE_STRING  FullImageName,
1340   IN HANDLE  ProcessId,
1341   IN PIMAGE_INFO  ImageInfo);
1342
1343 #pragma pack(push,4)
1344 typedef enum _BUS_DATA_TYPE {
1345     ConfigurationSpaceUndefined = -1,
1346     Cmos,
1347     EisaConfiguration,
1348     Pos,
1349     CbusConfiguration,
1350     PCIConfiguration,
1351     VMEConfiguration,
1352     NuBusConfiguration,
1353     PCMCIAConfiguration,
1354     MPIConfiguration,
1355     MPSAConfiguration,
1356     PNPISAConfiguration,
1357     SgiInternalConfiguration,
1358     MaximumBusDataType
1359 } BUS_DATA_TYPE, *PBUS_DATA_TYPE;
1360 #pragma pack(pop)
1361
1362 typedef struct _NT_TIB {
1363     struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;
1364     PVOID StackBase;
1365     PVOID StackLimit;
1366     PVOID SubSystemTib;
1367         _ANONYMOUS_UNION union {
1368                 PVOID FiberData;
1369                 ULONG Version;
1370         } DUMMYUNIONNAME;
1371     PVOID ArbitraryUserPointer;
1372     struct _NT_TIB *Self;
1373 } NT_TIB, *PNT_TIB;
1374
1375 typedef struct _NT_TIB32 {
1376         ULONG ExceptionList;
1377         ULONG StackBase;
1378         ULONG StackLimit;
1379         ULONG SubSystemTib;
1380         __GNU_EXTENSION union {
1381                 ULONG FiberData;
1382                 ULONG Version;
1383         };
1384         ULONG ArbitraryUserPointer;
1385         ULONG Self;
1386 } NT_TIB32,*PNT_TIB32;
1387
1388 typedef struct _NT_TIB64 {
1389         ULONG64 ExceptionList;
1390         ULONG64 StackBase;
1391         ULONG64 StackLimit;
1392         ULONG64 SubSystemTib;
1393         __GNU_EXTENSION union {
1394                 ULONG64 FiberData;
1395                 ULONG Version;
1396         };
1397         ULONG64 ArbitraryUserPointer;
1398         ULONG64 Self;
1399 } NT_TIB64,*PNT_TIB64;
1400
1401 typedef enum _PROCESSINFOCLASS {
1402   ProcessBasicInformation,
1403   ProcessQuotaLimits,
1404   ProcessIoCounters,
1405   ProcessVmCounters,
1406   ProcessTimes,
1407   ProcessBasePriority,
1408   ProcessRaisePriority,
1409   ProcessDebugPort,
1410   ProcessExceptionPort,
1411   ProcessAccessToken,
1412   ProcessLdtInformation,
1413   ProcessLdtSize,
1414   ProcessDefaultHardErrorMode,
1415   ProcessIoPortHandlers,
1416   ProcessPooledUsageAndLimits,
1417   ProcessWorkingSetWatch,
1418   ProcessUserModeIOPL,
1419   ProcessEnableAlignmentFaultFixup,
1420   ProcessPriorityClass,
1421   ProcessWx86Information,
1422   ProcessHandleCount,
1423   ProcessAffinityMask,
1424   ProcessPriorityBoost,
1425   ProcessDeviceMap,
1426   ProcessSessionInformation,
1427   ProcessForegroundInformation,
1428   ProcessWow64Information,
1429   ProcessImageFileName,
1430   ProcessLUIDDeviceMapsEnabled,
1431   ProcessBreakOnTermination,
1432   ProcessDebugObjectHandle,
1433   ProcessDebugFlags,
1434   ProcessHandleTracing,
1435   ProcessIoPriority,
1436   ProcessExecuteFlags,
1437   ProcessTlsInformation,
1438   ProcessCookie,
1439   ProcessImageInformation,
1440   ProcessCycleTime,
1441   ProcessPagePriority,
1442   ProcessInstrumentationCallback,
1443   MaxProcessInfoClass
1444 } PROCESSINFOCLASS;
1445
1446 typedef enum _THREADINFOCLASS {
1447   ThreadBasicInformation,
1448   ThreadTimes,
1449   ThreadPriority,
1450   ThreadBasePriority,
1451   ThreadAffinityMask,
1452   ThreadImpersonationToken,
1453   ThreadDescriptorTableEntry,
1454   ThreadEnableAlignmentFaultFixup,
1455   ThreadEventPair_Reusable,
1456   ThreadQuerySetWin32StartAddress,
1457   ThreadZeroTlsCell,
1458   ThreadPerformanceCount,
1459   ThreadAmILastThread,
1460   ThreadIdealProcessor,
1461   ThreadPriorityBoost,
1462   ThreadSetTlsArrayAddress,
1463   ThreadIsIoPending,
1464   ThreadHideFromDebugger,
1465   ThreadBreakOnTermination,
1466   ThreadSwitchLegacyState,
1467   ThreadIsTerminated,
1468   ThreadLastSystemCall,
1469   ThreadIoPriority,
1470   ThreadCycleTime,
1471   ThreadPagePriority,
1472   ThreadActualBasePriority,
1473   MaxThreadInfoClass
1474 } THREADINFOCLASS;
1475
1476 typedef struct _PROCESS_BASIC_INFORMATION
1477 {
1478     NTSTATUS ExitStatus;
1479     struct _PEB *PebBaseAddress;
1480     ULONG_PTR AffinityMask;
1481     KPRIORITY BasePriority;
1482     ULONG_PTR UniqueProcessId;
1483     ULONG_PTR InheritedFromUniqueProcessId;
1484 } PROCESS_BASIC_INFORMATION,*PPROCESS_BASIC_INFORMATION;
1485
1486 typedef struct _PROCESS_WS_WATCH_INFORMATION
1487 {
1488     PVOID FaultingPc;
1489     PVOID FaultingVa;
1490 } PROCESS_WS_WATCH_INFORMATION, *PPROCESS_WS_WATCH_INFORMATION;
1491
1492 typedef struct _PROCESS_DEVICEMAP_INFORMATION
1493 {
1494     __GNU_EXTENSION union
1495     {
1496         struct
1497         {
1498             HANDLE DirectoryHandle;
1499         } Set;
1500         struct
1501         {
1502             ULONG DriveMap;
1503             UCHAR DriveType[32];
1504         } Query;
1505     };
1506 } PROCESS_DEVICEMAP_INFORMATION, *PPROCESS_DEVICEMAP_INFORMATION;
1507
1508 typedef struct _KERNEL_USER_TIMES
1509 {
1510     LARGE_INTEGER CreateTime;
1511     LARGE_INTEGER ExitTime;
1512     LARGE_INTEGER KernelTime;
1513     LARGE_INTEGER UserTime;
1514 } KERNEL_USER_TIMES, *PKERNEL_USER_TIMES;
1515
1516 typedef struct _PROCESS_ACCESS_TOKEN
1517 {
1518     HANDLE Token;
1519     HANDLE Thread;
1520 } PROCESS_ACCESS_TOKEN, *PPROCESS_ACCESS_TOKEN;
1521
1522 typedef struct _PROCESS_SESSION_INFORMATION
1523 {
1524     ULONG SessionId;
1525 } PROCESS_SESSION_INFORMATION, *PPROCESS_SESSION_INFORMATION;
1526
1527 /*
1528 ** Storage structures
1529 */
1530 typedef enum _PARTITION_STYLE {
1531   PARTITION_STYLE_MBR,
1532   PARTITION_STYLE_GPT,
1533   PARTITION_STYLE_RAW
1534 } PARTITION_STYLE;
1535
1536 typedef struct _CREATE_DISK_MBR {
1537   ULONG  Signature;
1538 } CREATE_DISK_MBR, *PCREATE_DISK_MBR;
1539
1540 typedef struct _CREATE_DISK_GPT {
1541   GUID  DiskId;
1542   ULONG  MaxPartitionCount;
1543 } CREATE_DISK_GPT, *PCREATE_DISK_GPT;
1544
1545 typedef struct _CREATE_DISK {
1546   PARTITION_STYLE  PartitionStyle;
1547   _ANONYMOUS_UNION union {
1548     CREATE_DISK_MBR  Mbr;
1549     CREATE_DISK_GPT  Gpt;
1550   } DUMMYUNIONNAME;
1551 } CREATE_DISK, *PCREATE_DISK;
1552
1553 typedef struct _DISK_SIGNATURE {
1554   ULONG  PartitionStyle;
1555   _ANONYMOUS_UNION union {
1556     struct {
1557       ULONG  Signature;
1558       ULONG  CheckSum;
1559     } Mbr;
1560     struct {
1561       GUID  DiskId;
1562     } Gpt;
1563   } DUMMYUNIONNAME;
1564 } DISK_SIGNATURE, *PDISK_SIGNATURE;
1565
1566 typedef VOID
1567 (FASTCALL*PTIME_UPDATE_NOTIFY_ROUTINE)(
1568   IN HANDLE  ThreadId,
1569   IN KPROCESSOR_MODE  Mode);
1570
1571 typedef struct _PHYSICAL_MEMORY_RANGE {
1572   PHYSICAL_ADDRESS  BaseAddress;
1573   LARGE_INTEGER  NumberOfBytes;
1574 } PHYSICAL_MEMORY_RANGE, *PPHYSICAL_MEMORY_RANGE;
1575
1576 typedef ULONG_PTR
1577 (NTAPI *PDRIVER_VERIFIER_THUNK_ROUTINE)(
1578   IN PVOID  Context);
1579
1580 typedef struct _DRIVER_VERIFIER_THUNK_PAIRS {
1581   PDRIVER_VERIFIER_THUNK_ROUTINE  PristineRoutine;
1582   PDRIVER_VERIFIER_THUNK_ROUTINE  NewRoutine;
1583 } DRIVER_VERIFIER_THUNK_PAIRS, *PDRIVER_VERIFIER_THUNK_PAIRS;
1584
1585 #define DRIVER_VERIFIER_SPECIAL_POOLING             0x0001
1586 #define DRIVER_VERIFIER_FORCE_IRQL_CHECKING         0x0002
1587 #define DRIVER_VERIFIER_INJECT_ALLOCATION_FAILURES  0x0004
1588 #define DRIVER_VERIFIER_TRACK_POOL_ALLOCATIONS      0x0008
1589 #define DRIVER_VERIFIER_IO_CHECKING                 0x0010
1590
1591 typedef VOID
1592 (DDKAPI *PTIMER_APC_ROUTINE)(
1593   IN PVOID  TimerContext,
1594   IN ULONG  TimerLowValue,
1595   IN LONG  TimerHighValue);
1596
1597 /*
1598 ** Architecture specific structures
1599 */
1600 #define PCR_MINOR_VERSION 1
1601 #define PCR_MAJOR_VERSION 1
1602
1603 #ifdef _X86_
1604
1605 #define SIZE_OF_80387_REGISTERS 80
1606 #define CONTEXT_i386    0x10000
1607 #define CONTEXT_i486    0x10000
1608 #define CONTEXT_CONTROL (CONTEXT_i386|0x00000001L)
1609 #define CONTEXT_INTEGER (CONTEXT_i386|0x00000002L)
1610 #define CONTEXT_SEGMENTS        (CONTEXT_i386|0x00000004L)
1611 #define CONTEXT_FLOATING_POINT  (CONTEXT_i386|0x00000008L)
1612 #define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386|0x00000010L)
1613 #define CONTEXT_EXTENDED_REGISTERS (CONTEXT_i386|0x00000020L)
1614 #define CONTEXT_FULL    (CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS)
1615
1616 typedef struct _FLOATING_SAVE_AREA {
1617     ULONG ControlWord;
1618     ULONG StatusWord;
1619     ULONG TagWord;
1620     ULONG ErrorOffset;
1621     ULONG ErrorSelector;
1622     ULONG DataOffset;
1623     ULONG DataSelector;
1624     UCHAR RegisterArea[SIZE_OF_80387_REGISTERS];
1625     ULONG Cr0NpxState;
1626 } FLOATING_SAVE_AREA, *PFLOATING_SAVE_AREA;
1627
1628 typedef struct _CONTEXT {
1629     ULONG ContextFlags;
1630     ULONG Dr0;
1631     ULONG Dr1;
1632     ULONG Dr2;
1633     ULONG Dr3;
1634     ULONG Dr6;
1635     ULONG Dr7;
1636     FLOATING_SAVE_AREA FloatSave;
1637     ULONG SegGs;
1638     ULONG SegFs;
1639     ULONG SegEs;
1640     ULONG SegDs;
1641     ULONG Edi;
1642     ULONG Esi;
1643     ULONG Ebx;
1644     ULONG Edx;
1645     ULONG Ecx;
1646     ULONG Eax;
1647     ULONG Ebp;
1648     ULONG Eip;
1649     ULONG SegCs;
1650     ULONG EFlags;
1651     ULONG Esp;
1652     ULONG SegSs;
1653     UCHAR ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];
1654 } CONTEXT;
1655
1656 typedef struct _KPCR_TIB {
1657   PVOID  ExceptionList;         /* 00 */
1658   PVOID  StackBase;             /* 04 */
1659   PVOID  StackLimit;            /* 08 */
1660   PVOID  SubSystemTib;          /* 0C */
1661   _ANONYMOUS_UNION union {
1662     PVOID  FiberData;           /* 10 */
1663     ULONG  Version;             /* 10 */
1664   } DUMMYUNIONNAME;
1665   PVOID  ArbitraryUserPointer;  /* 14 */
1666   struct _KPCR_TIB *Self;       /* 18 */
1667 } KPCR_TIB, *PKPCR_TIB;         /* 1C */
1668
1669 typedef struct _KPCR {
1670   KPCR_TIB  Tib;                /* 00 */
1671   struct _KPCR  *Self;          /* 1C */
1672   struct _KPRCB  *Prcb;         /* 20 */
1673   KIRQL  Irql;                  /* 24 */
1674   ULONG  IRR;                   /* 28 */
1675   ULONG  IrrActive;             /* 2C */
1676   ULONG  IDR;                   /* 30 */
1677   PVOID  KdVersionBlock;        /* 34 */
1678   PUSHORT  IDT;                 /* 38 */
1679   PUSHORT  GDT;                 /* 3C */
1680   struct _KTSS  *TSS;           /* 40 */
1681   USHORT  MajorVersion;         /* 44 */
1682   USHORT  MinorVersion;         /* 46 */
1683   KAFFINITY  SetMember;         /* 48 */
1684   ULONG  StallScaleFactor;      /* 4C */
1685   UCHAR  SpareUnused;           /* 50 */
1686   UCHAR  Number;                /* 51 */
1687   UCHAR Spare0;
1688   UCHAR SecondLevelCacheAssociativity;
1689   ULONG VdmAlert;
1690   ULONG KernelReserved[14];         // For use by the kernel
1691   ULONG SecondLevelCacheSize;
1692   ULONG HalReserved[16];            // For use by Hal
1693 } KPCR, *PKPCR;                 /* 54 */
1694
1695 #define KeGetPcr()                      PCR
1696
1697 FORCEINLINE
1698 ULONG
1699 KeGetCurrentProcessorNumber(VOID)
1700 {
1701     return (ULONG)__readfsbyte(FIELD_OFFSET(KPCR, Number));
1702 }
1703
1704 extern NTKERNELAPI PVOID MmHighestUserAddress;
1705 extern NTKERNELAPI PVOID MmSystemRangeStart;
1706 extern NTKERNELAPI ULONG_PTR MmUserProbeAddress;
1707
1708 #define MM_HIGHEST_USER_ADDRESS           MmHighestUserAddress
1709 #define MM_SYSTEM_RANGE_START             MmSystemRangeStart
1710 #define MM_USER_PROBE_ADDRESS             MmUserProbeAddress
1711 #define MM_LOWEST_USER_ADDRESS            (PVOID)0x10000
1712 #define MM_LOWEST_SYSTEM_ADDRESS          (PVOID)0xC0C00000
1713
1714 #define MM_KSEG0_BASE       MM_SYSTEM_RANGE_START
1715 #define MM_SYSTEM_SPACE_END 0xFFFFFFFF
1716
1717 #elif defined(__x86_64__)
1718
1719 #define CONTEXT_AMD64 0x100000
1720 #if !defined(RC_INVOKED)
1721 #define CONTEXT_CONTROL (CONTEXT_AMD64 | 0x1L)
1722 #define CONTEXT_INTEGER (CONTEXT_AMD64 | 0x2L)
1723 #define CONTEXT_SEGMENTS (CONTEXT_AMD64 | 0x4L)
1724 #define CONTEXT_FLOATING_POINT (CONTEXT_AMD64 | 0x8L)
1725 #define CONTEXT_DEBUG_REGISTERS (CONTEXT_AMD64 | 0x10L)
1726
1727 #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT)
1728 #define CONTEXT_ALL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS)
1729
1730 #define CONTEXT_EXCEPTION_ACTIVE 0x8000000
1731 #define CONTEXT_SERVICE_ACTIVE 0x10000000
1732 #define CONTEXT_EXCEPTION_REQUEST 0x40000000
1733 #define CONTEXT_EXCEPTION_REPORTING 0x80000000
1734 #endif
1735
1736 typedef struct DECLSPEC_ALIGN(16) _CONTEXT {
1737     ULONG64 P1Home;
1738     ULONG64 P2Home;
1739     ULONG64 P3Home;
1740     ULONG64 P4Home;
1741     ULONG64 P5Home;
1742     ULONG64 P6Home;
1743
1744     /* Control flags */
1745     ULONG ContextFlags;
1746     ULONG MxCsr;
1747
1748     /* Segment */
1749     USHORT SegCs;
1750     USHORT SegDs;
1751     USHORT SegEs;
1752     USHORT SegFs;
1753     USHORT SegGs;
1754     USHORT SegSs;
1755     ULONG EFlags;
1756
1757     /* Debug */
1758     ULONG64 Dr0;
1759     ULONG64 Dr1;
1760     ULONG64 Dr2;
1761     ULONG64 Dr3;
1762     ULONG64 Dr6;
1763     ULONG64 Dr7;
1764
1765     /* Integer */
1766     ULONG64 Rax;
1767     ULONG64 Rcx;
1768     ULONG64 Rdx;
1769     ULONG64 Rbx;
1770     ULONG64 Rsp;
1771     ULONG64 Rbp;
1772     ULONG64 Rsi;
1773     ULONG64 Rdi;
1774     ULONG64 R8;
1775     ULONG64 R9;
1776     ULONG64 R10;
1777     ULONG64 R11;
1778     ULONG64 R12;
1779     ULONG64 R13;
1780     ULONG64 R14;
1781     ULONG64 R15;
1782
1783     /* Counter */
1784     ULONG64 Rip;
1785
1786    /* Floating point */
1787    union {
1788        XMM_SAVE_AREA32 FltSave;
1789        struct {
1790            M128A Header[2];
1791            M128A Legacy[8];
1792            M128A Xmm0;
1793            M128A Xmm1;
1794            M128A Xmm2;
1795            M128A Xmm3;
1796            M128A Xmm4;
1797            M128A Xmm5;
1798            M128A Xmm6;
1799            M128A Xmm7;
1800            M128A Xmm8;
1801            M128A Xmm9;
1802            M128A Xmm10;
1803            M128A Xmm11;
1804            M128A Xmm12;
1805            M128A Xmm13;
1806            M128A Xmm14;
1807            M128A Xmm15;
1808       } DUMMYSTRUCTNAME;
1809     } DUMMYUNIONNAME;
1810
1811      /* Vector */
1812     M128A VectorRegister[26];
1813     ULONG64 VectorControl;
1814
1815     /* Debug control */
1816     ULONG64 DebugControl;
1817     ULONG64 LastBranchToRip;
1818     ULONG64 LastBranchFromRip;
1819     ULONG64 LastExceptionToRip;
1820     ULONG64 LastExceptionFromRip;
1821 } CONTEXT;
1822
1823 #define PAGE_SIZE   0x1000
1824 #define PAGE_SHIFT 12L
1825 #define PTI_SHIFT  12L
1826 #define PDI_SHIFT  21L
1827 #define PPI_SHIFT  30L
1828 #define PXI_SHIFT  39L
1829 #define PTE_PER_PAGE 512
1830 #define PDE_PER_PAGE 512
1831 #define PPE_PER_PAGE 512
1832 #define PXE_PER_PAGE 512
1833 #define PTI_MASK_AMD64 (PTE_PER_PAGE - 1)
1834 #define PDI_MASK_AMD64 (PDE_PER_PAGE - 1)
1835 #define PPI_MASK (PPE_PER_PAGE - 1)
1836 #define PXI_MASK (PXE_PER_PAGE - 1)
1837
1838 #define PXE_BASE    0xFFFFF6FB7DBED000ULL
1839 #define PXE_SELFMAP 0xFFFFF6FB7DBEDF68ULL
1840 #define PPE_BASE    0xFFFFF6FB7DA00000ULL
1841 #define PDE_BASE    0xFFFFF6FB40000000ULL
1842 #define PTE_BASE    0xFFFFF68000000000ULL
1843 #define PXE_TOP     0xFFFFF6FB7DBEDFFFULL
1844 #define PPE_TOP     0xFFFFF6FB7DBFFFFFULL
1845 #define PDE_TOP     0xFFFFF6FB7FFFFFFFULL
1846 #define PTE_TOP     0xFFFFF6FFFFFFFFFFULL
1847
1848 extern NTKERNELAPI PVOID MmHighestUserAddress;
1849 extern NTKERNELAPI PVOID MmSystemRangeStart;
1850 extern NTKERNELAPI ULONG_PTR MmUserProbeAddress;
1851
1852 #define MM_HIGHEST_USER_ADDRESS           MmHighestUserAddress
1853 #define MM_SYSTEM_RANGE_START             MmSystemRangeStart
1854 #define MM_USER_PROBE_ADDRESS             MmUserProbeAddress
1855 #define MM_LOWEST_USER_ADDRESS   (PVOID)0x10000
1856 #define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xFFFF080000000000ULL
1857 #define KI_USER_SHARED_DATA       0xFFFFF78000000000ULL
1858
1859 #define SharedUserData ((PKUSER_SHARED_DATA const)KI_USER_SHARED_DATA)
1860 #define SharedInterruptTime (&SharedUserData->InterruptTime)
1861 #define SharedSystemTime (&SharedUserData->SystemTime)
1862 #define SharedTickCount (&SharedUserData->TickCount)
1863
1864 #define KeQueryInterruptTime() \
1865     (*(volatile ULONG64*)SharedInterruptTime)
1866 #define KeQuerySystemTime(CurrentCount) \
1867     *(ULONG64*)(CurrentCount) = *(volatile ULONG64*)SharedSystemTime
1868 #define KeQueryTickCount(CurrentCount) \
1869     *(ULONG64*)(CurrentCount) = *(volatile ULONG64*)SharedTickCount
1870
1871 typedef struct _KPCR
1872 {
1873     __GNU_EXTENSION union
1874     {
1875         NT_TIB NtTib;
1876         __GNU_EXTENSION struct
1877         {
1878             union _KGDTENTRY64 *GdtBase;
1879             struct _KTSS64 *TssBase;
1880             ULONG64 UserRsp;
1881             struct _KPCR *Self;
1882             struct _KPRCB *CurrentPrcb;
1883             PKSPIN_LOCK_QUEUE LockArray;
1884             PVOID Used_Self;
1885         };
1886     };
1887     union _KIDTENTRY64 *IdtBase;
1888     ULONG64 Unused[2];
1889     KIRQL Irql;
1890     UCHAR SecondLevelCacheAssociativity;
1891     UCHAR ObsoleteNumber;
1892     UCHAR Fill0;
1893     ULONG Unused0[3];
1894     USHORT MajorVersion;
1895     USHORT MinorVersion;
1896     ULONG StallScaleFactor;
1897     PVOID Unused1[3];
1898     ULONG KernelReserved[15];
1899     ULONG SecondLevelCacheSize;
1900     ULONG HalReserved[16];
1901     ULONG Unused2;
1902     PVOID KdVersionBlock;
1903     PVOID Unused3;
1904     ULONG PcrAlign1[24];
1905 } KPCR, *PKPCR;
1906
1907 typedef struct _KFLOATING_SAVE {
1908   ULONG Dummy;
1909 } KFLOATING_SAVE, *PKFLOATING_SAVE;
1910
1911 FORCEINLINE
1912 PKPCR
1913 KeGetPcr(VOID)
1914 {
1915     return (PKPCR)__readgsqword(FIELD_OFFSET(KPCR, Self));
1916 }
1917
1918 FORCEINLINE
1919 ULONG
1920 KeGetCurrentProcessorNumber(VOID)
1921 {
1922     return (ULONG)__readgsword(0x184);
1923 }
1924
1925 #elif defined(__PowerPC__)
1926
1927 //
1928 // Used to contain PFNs and PFN counts
1929 //
1930 typedef ULONG PFN_COUNT;
1931 typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
1932 typedef LONG SPFN_NUMBER, *PSPFN_NUMBER;
1933
1934 #define PASSIVE_LEVEL                      0
1935 #define LOW_LEVEL                          0
1936 #define APC_LEVEL                          1
1937 #define DISPATCH_LEVEL                     2
1938 #define PROFILE_LEVEL                     27
1939 #define CLOCK1_LEVEL                      28
1940 #define CLOCK2_LEVEL                      28
1941 #define IPI_LEVEL                         29
1942 #define POWER_LEVEL                       30
1943 #define HIGH_LEVEL                        31
1944
1945 typedef struct _KFLOATING_SAVE {
1946   ULONG Dummy;
1947 } KFLOATING_SAVE, *PKFLOATING_SAVE;
1948
1949 typedef struct _KPCR_TIB {
1950   PVOID  ExceptionList;         /* 00 */
1951   PVOID  StackBase;             /* 04 */
1952   PVOID  StackLimit;            /* 08 */
1953   PVOID  SubSystemTib;          /* 0C */
1954   _ANONYMOUS_UNION union {
1955     PVOID  FiberData;           /* 10 */
1956     ULONG  Version;             /* 10 */
1957   } DUMMYUNIONNAME;
1958   PVOID  ArbitraryUserPointer;  /* 14 */
1959   struct _KPCR_TIB *Self;       /* 18 */
1960 } KPCR_TIB, *PKPCR_TIB;         /* 1C */
1961
1962 #define PCR_MINOR_VERSION 1
1963 #define PCR_MAJOR_VERSION 1
1964
1965 typedef struct _KPCR {
1966   KPCR_TIB  Tib;                /* 00 */
1967   struct _KPCR  *Self;          /* 1C */
1968   struct _KPRCB  *Prcb;         /* 20 */
1969   KIRQL  Irql;                  /* 24 */
1970   ULONG  IRR;                   /* 28 */
1971   ULONG  IrrActive;             /* 2C */
1972   ULONG  IDR;                   /* 30 */
1973   PVOID  KdVersionBlock;        /* 34 */
1974   PUSHORT  IDT;                 /* 38 */
1975   PUSHORT  GDT;                 /* 3C */
1976   struct _KTSS  *TSS;           /* 40 */
1977   USHORT  MajorVersion;         /* 44 */
1978   USHORT  MinorVersion;         /* 46 */
1979   KAFFINITY  SetMember;         /* 48 */
1980   ULONG  StallScaleFactor;      /* 4C */
1981   UCHAR  SpareUnused;           /* 50 */
1982   UCHAR  Number;                /* 51 */
1983 } KPCR, *PKPCR;                 /* 54 */
1984
1985 #define KeGetPcr()                      PCR
1986
1987 static __inline
1988 ULONG
1989 DDKAPI
1990 KeGetCurrentProcessorNumber(VOID)
1991 {
1992     ULONG Number;
1993   __asm__ __volatile__ (
1994     "lwz %0, %c1(12)\n"
1995     : "=r" (Number)
1996     : "i" (FIELD_OFFSET(KPCR, Number))
1997   );
1998   return Number;
1999 }
2000
2001 #elif defined(_MIPS_)
2002
2003 #error MIPS Headers are totally incorrect
2004
2005 //
2006 // Used to contain PFNs and PFN counts
2007 //
2008 typedef ULONG PFN_COUNT;
2009 typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
2010 typedef LONG SPFN_NUMBER, *PSPFN_NUMBER;
2011
2012 #define PASSIVE_LEVEL                      0
2013 #define APC_LEVEL                          1
2014 #define DISPATCH_LEVEL                     2
2015 #define PROFILE_LEVEL                     27
2016 #define IPI_LEVEL                         29
2017 #define HIGH_LEVEL                        31
2018
2019 typedef struct _KPCR {
2020     struct _KPRCB  *Prcb;         /* 20 */
2021     KIRQL  Irql;                  /* 24 */
2022     ULONG  IRR;                   /* 28 */
2023     ULONG  IDR;                   /* 30 */
2024 } KPCR, *PKPCR;
2025
2026 #define KeGetPcr()                      PCR
2027
2028 typedef struct _KFLOATING_SAVE {
2029 } KFLOATING_SAVE, *PKFLOATING_SAVE;
2030
2031 static __inline
2032 ULONG
2033 DDKAPI
2034 KeGetCurrentProcessorNumber(VOID)
2035 {
2036     return 0;
2037 }
2038
2039 #elif defined(_M_ARM)
2040
2041 //
2042 // NT-ARM is not documented, need DDK-ARM
2043 //
2044 #include <armddk.h>
2045
2046 #else
2047 #error Unknown architecture
2048 #endif
2049
2050 typedef enum _INTERLOCKED_RESULT {
2051   ResultNegative = RESULT_NEGATIVE,
2052   ResultZero = RESULT_ZERO,
2053   ResultPositive = RESULT_POSITIVE
2054 } INTERLOCKED_RESULT;
2055
2056 typedef VOID
2057 (NTAPI *PciPin2Line)(
2058     IN struct _BUS_HANDLER *BusHandler,
2059     IN struct _BUS_HANDLER *RootHandler,
2060     IN PCI_SLOT_NUMBER SlotNumber,
2061     IN PPCI_COMMON_CONFIG PciData
2062 );
2063
2064 typedef VOID
2065 (NTAPI *PciLine2Pin)(
2066     IN struct _BUS_HANDLER *BusHandler,
2067     IN struct _BUS_HANDLER *RootHandler,
2068     IN PCI_SLOT_NUMBER SlotNumber,
2069     IN PPCI_COMMON_CONFIG PciNewData,
2070     IN PPCI_COMMON_CONFIG PciOldData
2071 );
2072
2073 typedef VOID
2074 (NTAPI *PciReadWriteConfig)(
2075     IN struct _BUS_HANDLER *BusHandler,
2076     IN PCI_SLOT_NUMBER Slot,
2077     IN PVOID Buffer,
2078     IN ULONG Offset,
2079     IN ULONG Length
2080 );
2081
2082 #define PCI_DATA_TAG ' ICP'
2083 #define PCI_DATA_VERSION 1
2084
2085 typedef struct _PCIBUSDATA
2086 {
2087     ULONG Tag;
2088     ULONG Version;
2089     PciReadWriteConfig ReadConfig;
2090     PciReadWriteConfig WriteConfig;
2091     PciPin2Line Pin2Line;
2092     PciLine2Pin Line2Pin;
2093     PCI_SLOT_NUMBER ParentSlot;
2094     PVOID Reserved[4];
2095 } PCIBUSDATA, *PPCIBUSDATA;
2096
2097
2098 /** SPINLOCK FUNCTIONS ********************************************************/
2099
2100 #if defined (_X86_)
2101
2102 #if defined(WIN9X_COMPAT_SPINLOCK)
2103
2104 NTKERNELAPI
2105 VOID
2106 NTAPI
2107 KeInitializeSpinLock(
2108     IN PKSPIN_LOCK SpinLock
2109 );
2110
2111 #else
2112
2113 FORCEINLINE
2114 VOID
2115 KeInitializeSpinLock(IN PKSPIN_LOCK SpinLock)
2116 {
2117     /* Clear the lock */
2118     *SpinLock = 0;
2119 }
2120
2121 #endif
2122
2123 NTHALAPI
2124 KIRQL
2125 FASTCALL
2126 KfAcquireSpinLock(
2127   IN PKSPIN_LOCK SpinLock);
2128
2129 NTHALAPI
2130 VOID
2131 FASTCALL
2132 KfReleaseSpinLock(
2133   IN PKSPIN_LOCK SpinLock,
2134   IN KIRQL NewIrql);
2135
2136 NTKERNELAPI
2137 VOID
2138 FASTCALL
2139 KefAcquireSpinLockAtDpcLevel(
2140   IN PKSPIN_LOCK  SpinLock);
2141
2142 NTKERNELAPI
2143 VOID
2144 FASTCALL
2145 KefReleaseSpinLockFromDpcLevel(
2146   IN PKSPIN_LOCK  SpinLock);
2147
2148 #define KeAcquireSpinLockAtDpcLevel(SpinLock) KefAcquireSpinLockAtDpcLevel(SpinLock)
2149 #define KeReleaseSpinLockFromDpcLevel(SpinLock) KefReleaseSpinLockFromDpcLevel(SpinLock)
2150 #define KeAcquireSpinLock(a,b)  *(b) = KfAcquireSpinLock(a)
2151 #define KeReleaseSpinLock(a,b)  KfReleaseSpinLock(a,b)
2152
2153 #define KeGetDcacheFillSize() 1L
2154
2155 #elif defined(_M_ARM) // !defined (_X86_)
2156
2157     FORCEINLINE
2158     VOID
2159     KeInitializeSpinLock(IN PKSPIN_LOCK SpinLock)
2160     {
2161         /* Clear the lock */
2162         *SpinLock = 0;
2163     }
2164
2165     NTHALAPI
2166     KIRQL
2167     FASTCALL
2168     KfAcquireSpinLock(
2169                       IN PKSPIN_LOCK SpinLock);
2170
2171     NTHALAPI
2172     VOID
2173     FASTCALL
2174     KfReleaseSpinLock(
2175                       IN PKSPIN_LOCK SpinLock,
2176                       IN KIRQL NewIrql);
2177
2178
2179     NTKERNELAPI
2180     VOID
2181     FASTCALL
2182     KefAcquireSpinLockAtDpcLevel(
2183                                  IN PKSPIN_LOCK  SpinLock);
2184
2185     NTKERNELAPI
2186     VOID
2187     FASTCALL
2188     KefReleaseSpinLockFromDpcLevel(
2189                                    IN PKSPIN_LOCK  SpinLock);
2190
2191
2192 #define KeAcquireSpinLockAtDpcLevel(SpinLock) KefAcquireSpinLockAtDpcLevel(SpinLock)
2193 #define KeReleaseSpinLockFromDpcLevel(SpinLock) KefReleaseSpinLockFromDpcLevel(SpinLock)
2194 #define KeAcquireSpinLock(a,b)  *(b) = KfAcquireSpinLock(a)
2195 #define KeReleaseSpinLock(a,b)  KfReleaseSpinLock(a,b)
2196
2197     NTKERNELAPI
2198     VOID
2199     NTAPI
2200     KeInitializeSpinLock(
2201                          IN PKSPIN_LOCK  SpinLock);
2202
2203 #else
2204
2205 FORCEINLINE
2206 VOID
2207 NTAPI
2208 KeInitializeSpinLock(
2209   PKSPIN_LOCK SpinLock)
2210 {
2211     *SpinLock = 0;
2212 }
2213
2214 NTKERNELAPI
2215 VOID
2216 KeReleaseSpinLock(
2217   IN PKSPIN_LOCK SpinLock,
2218   IN KIRQL NewIrql);
2219
2220 NTKERNELAPI
2221 VOID
2222 KeAcquireSpinLockAtDpcLevel(
2223   IN PKSPIN_LOCK SpinLock);
2224
2225 NTKERNELAPI
2226 VOID
2227 KeReleaseSpinLockFromDpcLevel(
2228   IN PKSPIN_LOCK SpinLock);
2229
2230 NTKERNELAPI
2231 KIRQL
2232 KeAcquireSpinLockRaiseToDpc(
2233   IN PKSPIN_LOCK SpinLock);
2234
2235 #define KeAcquireSpinLock(SpinLock, OldIrql) \
2236   *(OldIrql) = KeAcquireSpinLockRaiseToDpc(SpinLock)
2237
2238 #endif // !defined (_X86_)
2239
2240 #define ARGUMENT_PRESENT(ArgumentPointer) \
2241   ((CHAR*)((ULONG_PTR)(ArgumentPointer)) != (CHAR*)NULL)
2242
2243 NTSYSAPI
2244 NTSTATUS
2245 NTAPI
2246 RtlCharToInteger(
2247   IN PCSZ  String,
2248   IN ULONG  Base  OPTIONAL,
2249   IN OUT PULONG  Value);
2250
2251 NTSYSAPI
2252 LONG
2253 NTAPI
2254 RtlCompareString(
2255   IN PSTRING  String1,
2256   IN PSTRING  String2,
2257   BOOLEAN  CaseInSensitive);
2258
2259 #if !defined(MIDL_PASS)
2260
2261 FORCEINLINE
2262 LUID
2263 NTAPI
2264 RtlConvertLongToLuid(
2265     IN LONG Val)
2266 {
2267     LUID Luid;
2268     LARGE_INTEGER Temp;
2269
2270     Temp.QuadPart = Val;
2271     Luid.LowPart = Temp.u.LowPart;
2272     Luid.HighPart = Temp.u.HighPart;
2273
2274     return Luid;
2275 }
2276
2277 FORCEINLINE
2278 LUID
2279 NTAPI
2280 RtlConvertUlongToLuid(
2281     IN ULONG Val)
2282 {
2283     LUID Luid;
2284
2285     Luid.LowPart = Val;
2286     Luid.HighPart = 0;
2287
2288     return Luid;
2289 }
2290 #endif
2291
2292
2293 NTSYSAPI
2294 VOID
2295 NTAPI
2296 RtlCopyMemory32(
2297   IN VOID UNALIGNED  *Destination,
2298   IN CONST VOID UNALIGNED  *Source,
2299   IN ULONG  Length);
2300
2301 NTSYSAPI
2302 VOID
2303 NTAPI
2304 RtlCopyString(
2305   IN OUT PSTRING  DestinationString,
2306   IN PSTRING  SourceString  OPTIONAL);
2307
2308 NTSYSAPI
2309 BOOLEAN
2310 NTAPI
2311 RtlEqualString(
2312   IN PSTRING  String1,
2313   IN PSTRING  String2,
2314   IN BOOLEAN  CaseInSensitive);
2315
2316 #if (defined(_M_AMD64) || defined(_M_IA64)) && !defined(_REALLY_GET_CALLERS_CALLER_)
2317 #define RtlGetCallersAddress(CallersAddress, CallersCaller) \
2318     *CallersAddress = (PVOID)_ReturnAddress(); \
2319     *CallersCaller = NULL;
2320 #else
2321 NTSYSAPI
2322 VOID
2323 NTAPI
2324 RtlGetCallersAddress(
2325   OUT PVOID  *CallersAddress,
2326   OUT PVOID  *CallersCaller);
2327 #endif
2328
2329 NTSYSAPI
2330 NTSTATUS
2331 NTAPI
2332 RtlGetVersion(
2333   IN OUT PRTL_OSVERSIONINFOW  lpVersionInformation);
2334
2335 NTSYSAPI
2336 VOID
2337 NTAPI
2338 RtlMapGenericMask(
2339   IN OUT PACCESS_MASK  AccessMask,
2340   IN PGENERIC_MAPPING  GenericMapping);
2341
2342 NTSYSAPI
2343 BOOLEAN
2344 NTAPI
2345 RtlPrefixUnicodeString(
2346   IN PCUNICODE_STRING  String1,
2347   IN PCUNICODE_STRING  String2,
2348   IN BOOLEAN  CaseInSensitive);
2349
2350 NTSYSAPI
2351 NTSTATUS
2352 NTAPI
2353 RtlUpcaseUnicodeString(
2354   IN OUT PUNICODE_STRING  DestinationString  OPTIONAL,
2355   IN PCUNICODE_STRING  SourceString,
2356   IN BOOLEAN  AllocateDestinationString);
2357
2358 NTSYSAPI
2359 CHAR
2360 NTAPI
2361 RtlUpperChar(
2362   IN CHAR Character);
2363
2364 NTSYSAPI
2365 VOID
2366 NTAPI
2367 RtlUpperString(
2368   IN OUT PSTRING  DestinationString,
2369   IN PSTRING  SourceString);
2370
2371 NTSYSAPI
2372 NTSTATUS
2373 NTAPI
2374 RtlVerifyVersionInfo(
2375   IN PRTL_OSVERSIONINFOEXW  VersionInfo,
2376   IN ULONG  TypeMask,
2377   IN ULONGLONG  ConditionMask);
2378
2379 NTSYSAPI
2380 NTSTATUS
2381 NTAPI
2382 RtlVolumeDeviceToDosName(
2383   IN PVOID  VolumeDeviceObject,
2384   OUT PUNICODE_STRING  DosName);
2385
2386 NTSYSAPI
2387 ULONG
2388 NTAPI
2389 RtlWalkFrameChain(
2390   OUT PVOID  *Callers,
2391   IN ULONG  Count,
2392   IN ULONG  Flags);
2393
2394 /******************************************************************************
2395  *                            Executive Types                                 *
2396  ******************************************************************************/
2397
2398 typedef struct _ZONE_SEGMENT_HEADER {
2399   SINGLE_LIST_ENTRY  SegmentList;
2400   PVOID  Reserved;
2401 } ZONE_SEGMENT_HEADER, *PZONE_SEGMENT_HEADER;
2402
2403 typedef struct _ZONE_HEADER {
2404   SINGLE_LIST_ENTRY  FreeList;
2405   SINGLE_LIST_ENTRY  SegmentList;
2406   ULONG  BlockSize;
2407   ULONG  TotalSegmentSize;
2408 } ZONE_HEADER, *PZONE_HEADER;
2409
2410 #define PROTECTED_POOL                    0x80000000
2411
2412 /******************************************************************************
2413  *                          Executive Functions                               *
2414  ******************************************************************************/
2415
2416 NTKERNELAPI
2417 NTSTATUS
2418 NTAPI
2419 ExExtendZone(
2420   IN PZONE_HEADER  Zone,
2421   IN PVOID  Segment,
2422   IN ULONG  SegmentSize);
2423
2424 static __inline PVOID
2425 ExAllocateFromZone(
2426   IN PZONE_HEADER  Zone)
2427 {
2428   if (Zone->FreeList.Next)
2429     Zone->FreeList.Next = Zone->FreeList.Next->Next;
2430   return (PVOID) Zone->FreeList.Next;
2431 }
2432
2433 static __inline PVOID
2434 ExFreeToZone(
2435   IN PZONE_HEADER  Zone,
2436   IN PVOID  Block)
2437 {
2438   ((PSINGLE_LIST_ENTRY) Block)->Next = Zone->FreeList.Next;
2439   Zone->FreeList.Next = ((PSINGLE_LIST_ENTRY) Block);
2440   return ((PSINGLE_LIST_ENTRY) Block)->Next;
2441 }
2442
2443 NTKERNELAPI
2444 NTSTATUS
2445 NTAPI
2446 ExInitializeZone(
2447   IN PZONE_HEADER  Zone,
2448   IN ULONG  BlockSize,
2449   IN PVOID  InitialSegment,
2450   IN ULONG  InitialSegmentSize);
2451
2452 /*
2453  * PVOID
2454  * ExInterlockedAllocateFromZone(
2455  *   IN PZONE_HEADER  Zone,
2456  *   IN PKSPIN_LOCK  Lock)
2457  */
2458 #define ExInterlockedAllocateFromZone(Zone, Lock) \
2459     ((PVOID) ExInterlockedPopEntryList(&Zone->FreeList, Lock))
2460
2461 NTKERNELAPI
2462 NTSTATUS
2463 NTAPI
2464 ExInterlockedExtendZone(
2465   IN PZONE_HEADER  Zone,
2466   IN PVOID  Segment,
2467   IN ULONG  SegmentSize,
2468   IN PKSPIN_LOCK  Lock);
2469
2470 /* PVOID
2471  * ExInterlockedFreeToZone(
2472  *  IN PZONE_HEADER  Zone,
2473  *  IN PVOID  Block,
2474  *  IN PKSPIN_LOCK  Lock);
2475  */
2476 #define ExInterlockedFreeToZone(Zone, Block, Lock) \
2477     ExInterlockedPushEntryList(&(Zone)->FreeList, (PSINGLE_LIST_ENTRY)(Block), Lock)
2478
2479 /*
2480  * BOOLEAN
2481  * ExIsFullZone(
2482  *  IN PZONE_HEADER  Zone)
2483  */
2484 #define ExIsFullZone(Zone) \
2485   ((Zone)->FreeList.Next == (PSINGLE_LIST_ENTRY) NULL)
2486
2487 /* BOOLEAN
2488  * ExIsObjectInFirstZoneSegment(
2489  *     IN PZONE_HEADER Zone,
2490  *     IN PVOID Object);
2491  */
2492 #define ExIsObjectInFirstZoneSegment(Zone,Object) \
2493     ((BOOLEAN)( ((PUCHAR)(Object) >= (PUCHAR)(Zone)->SegmentList.Next) && \
2494                 ((PUCHAR)(Object) <  (PUCHAR)(Zone)->SegmentList.Next + \
2495                          (Zone)->TotalSegmentSize)) )
2496
2497 NTKERNELAPI
2498 DECLSPEC_NORETURN
2499 VOID
2500 NTAPI
2501 ExRaiseAccessViolation(
2502   VOID);
2503
2504 NTKERNELAPI
2505 DECLSPEC_NORETURN
2506 VOID
2507 NTAPI
2508 ExRaiseDatatypeMisalignment(
2509   VOID);
2510
2511 NTKERNELAPI
2512 NTSTATUS
2513 NTAPI
2514 ExUuidCreate(
2515   OUT UUID  *Uuid);
2516
2517 #define ExAcquireResourceExclusive ExAcquireResourceExclusiveLite
2518 #define ExAcquireResourceShared ExAcquireResourceSharedLite
2519 #define ExConvertExclusiveToShared ExConvertExclusiveToSharedLite
2520 #define ExDeleteResource ExDeleteResourceLite
2521 #define ExInitializeResource ExInitializeResourceLite
2522 #define ExIsResourceAcquiredExclusive ExIsResourceAcquiredExclusiveLite
2523 #define ExIsResourceAcquiredShared ExIsResourceAcquiredSharedLite
2524 #define ExIsResourceAcquired ExIsResourceAcquiredSharedLite
2525 #define ExReleaseResourceForThread ExReleaseResourceForThreadLite
2526
2527 /** Filesystem runtime library routines **/
2528
2529 NTKERNELAPI
2530 BOOLEAN
2531 NTAPI
2532 FsRtlIsTotalDeviceFailure(
2533   IN NTSTATUS  Status);
2534
2535 /** Hardware abstraction layer routines **/
2536
2537 NTHALAPI
2538 BOOLEAN
2539 NTAPI
2540 HalMakeBeep(
2541   IN ULONG Frequency);
2542
2543 NTKERNELAPI
2544 VOID
2545 FASTCALL
2546 HalExamineMBR(
2547   IN PDEVICE_OBJECT  DeviceObject,
2548   IN ULONG  SectorSize,
2549   IN ULONG  MBRTypeIdentifier,
2550   OUT PVOID  *Buffer);
2551
2552 VOID
2553 NTAPI
2554 HalPutDmaAdapter(
2555     PADAPTER_OBJECT AdapterObject
2556 );
2557
2558 /** I/O manager routines **/
2559
2560 NTKERNELAPI
2561 VOID
2562 NTAPI
2563 IoAllocateController(
2564   IN PCONTROLLER_OBJECT  ControllerObject,
2565   IN PDEVICE_OBJECT  DeviceObject,
2566   IN PDRIVER_CONTROL  ExecutionRoutine,
2567   IN PVOID  Context);
2568
2569 /*
2570  * VOID IoAssignArcName(
2571  *   IN PUNICODE_STRING  ArcName,
2572  *   IN PUNICODE_STRING  DeviceName);
2573  */
2574 #define IoAssignArcName(_ArcName, _DeviceName) ( \
2575   IoCreateSymbolicLink((_ArcName), (_DeviceName)))
2576
2577 NTKERNELAPI
2578 VOID
2579 NTAPI
2580 IoCancelFileOpen(
2581   IN PDEVICE_OBJECT  DeviceObject,
2582   IN PFILE_OBJECT  FileObject);
2583
2584 NTKERNELAPI
2585 PCONTROLLER_OBJECT
2586 NTAPI
2587 IoCreateController(
2588   IN ULONG  Size);
2589
2590 NTKERNELAPI
2591 NTSTATUS
2592 NTAPI
2593 IoCreateDisk(
2594   IN PDEVICE_OBJECT  DeviceObject,
2595   IN PCREATE_DISK  Disk);
2596
2597 NTKERNELAPI
2598 NTSTATUS
2599 NTAPI
2600 IoCreateFile(
2601   OUT PHANDLE FileHandle,
2602   IN ACCESS_MASK DesiredAccess,
2603   IN POBJECT_ATTRIBUTES ObjectAttributes,
2604   OUT PIO_STATUS_BLOCK IoStatusBlock,
2605   IN PLARGE_INTEGER AllocationSize OPTIONAL,
2606   IN ULONG FileAttributes,
2607   IN ULONG ShareAccess,
2608   IN ULONG Disposition,
2609   IN ULONG CreateOptions,
2610   IN PVOID EaBuffer OPTIONAL,
2611   IN ULONG EaLength,
2612   IN CREATE_FILE_TYPE CreateFileType,
2613   IN PVOID ExtraCreateParameters OPTIONAL,
2614   IN ULONG Options);
2615
2616 NTKERNELAPI
2617 PKEVENT
2618 NTAPI
2619 IoCreateNotificationEvent(
2620   IN PUNICODE_STRING  EventName,
2621   OUT PHANDLE  EventHandle);
2622
2623 NTKERNELAPI
2624 NTSTATUS
2625 NTAPI
2626 IoCreateSymbolicLink(
2627   IN PUNICODE_STRING  SymbolicLinkName,
2628   IN PUNICODE_STRING  DeviceName);
2629
2630 NTKERNELAPI
2631 PKEVENT
2632 NTAPI
2633 IoCreateSynchronizationEvent(
2634   IN PUNICODE_STRING  EventName,
2635   OUT PHANDLE  EventHandle);
2636
2637 NTKERNELAPI
2638 NTSTATUS
2639 NTAPI
2640 IoCreateUnprotectedSymbolicLink(
2641   IN PUNICODE_STRING  SymbolicLinkName,
2642   IN PUNICODE_STRING  DeviceName);
2643
2644 NTKERNELAPI
2645 NTSTATUS
2646 NTAPI
2647 IoCsqInitialize(
2648   PIO_CSQ  Csq,
2649   IN PIO_CSQ_INSERT_IRP  CsqInsertIrp,
2650   IN PIO_CSQ_REMOVE_IRP  CsqRemoveIrp,
2651   IN PIO_CSQ_PEEK_NEXT_IRP  CsqPeekNextIrp,
2652   IN PIO_CSQ_ACQUIRE_LOCK  CsqAcquireLock,
2653   IN PIO_CSQ_RELEASE_LOCK  CsqReleaseLock,
2654   IN PIO_CSQ_COMPLETE_CANCELED_IRP  CsqCompleteCanceledIrp);
2655
2656 NTKERNELAPI
2657 VOID
2658 NTAPI
2659 IoCsqInsertIrp(
2660   IN  PIO_CSQ  Csq,
2661   IN  PIRP  Irp,
2662   IN  PIO_CSQ_IRP_CONTEXT  Context);
2663
2664 NTKERNELAPI
2665 PIRP
2666 NTAPI
2667 IoCsqRemoveIrp(
2668   IN  PIO_CSQ  Csq,
2669   IN  PIO_CSQ_IRP_CONTEXT  Context);
2670
2671 NTKERNELAPI
2672 PIRP
2673 NTAPI
2674 IoCsqRemoveNextIrp(
2675   IN PIO_CSQ  Csq,
2676   IN PVOID  PeekContext);
2677
2678 NTKERNELAPI
2679 VOID
2680 NTAPI
2681 IoDeleteController(
2682   IN PCONTROLLER_OBJECT  ControllerObject);
2683
2684 NTKERNELAPI
2685 VOID
2686 NTAPI
2687 IoDeleteDevice(
2688   IN PDEVICE_OBJECT  DeviceObject);
2689
2690 NTKERNELAPI
2691 NTSTATUS
2692 NTAPI
2693 IoDeleteSymbolicLink(
2694   IN PUNICODE_STRING  SymbolicLinkName);
2695
2696 /*
2697  * VOID
2698  * IoDeassignArcName(
2699  *   IN PUNICODE_STRING  ArcName)
2700  */
2701 #define IoDeassignArcName IoDeleteSymbolicLink
2702
2703 NTKERNELAPI
2704 VOID
2705 NTAPI
2706 IoDetachDevice(
2707   IN OUT PDEVICE_OBJECT  TargetDevice);
2708
2709 NTKERNELAPI
2710 VOID
2711 NTAPI
2712 IoDisconnectInterrupt(
2713   IN PKINTERRUPT  InterruptObject);
2714
2715 NTKERNELAPI
2716 BOOLEAN
2717 NTAPI
2718 IoForwardIrpSynchronously(
2719   IN PDEVICE_OBJECT  DeviceObject,
2720   IN PIRP  Irp);
2721
2722 #define IoForwardAndCatchIrp IoForwardIrpSynchronously
2723
2724 NTKERNELAPI
2725 VOID
2726 NTAPI
2727 IoFreeController(
2728   IN PCONTROLLER_OBJECT  ControllerObject);
2729
2730 NTKERNELAPI
2731 VOID
2732 NTAPI
2733 IoFreeErrorLogEntry(
2734   PVOID  ElEntry);
2735
2736 NTKERNELAPI
2737 VOID
2738 NTAPI
2739 IoFreeIrp(
2740   IN PIRP  Irp);
2741
2742 NTKERNELAPI
2743 VOID
2744 NTAPI
2745 IoFreeMdl(
2746   IN PMDL  Mdl);
2747
2748 NTKERNELAPI
2749 VOID
2750 NTAPI
2751 IoFreeWorkItem(
2752   IN PIO_WORKITEM  pIOWorkItem);
2753
2754 NTKERNELAPI
2755 PDEVICE_OBJECT
2756 NTAPI
2757 IoGetAttachedDevice(
2758   IN PDEVICE_OBJECT  DeviceObject);
2759
2760 NTKERNELAPI
2761 PDEVICE_OBJECT
2762 NTAPI
2763 IoGetAttachedDeviceReference(
2764   IN PDEVICE_OBJECT  DeviceObject);
2765
2766 NTKERNELAPI
2767 NTSTATUS
2768 NTAPI
2769 IoGetBootDiskInformation(
2770   IN OUT PBOOTDISK_INFORMATION  BootDiskInformation,
2771   IN ULONG  Size);
2772
2773 NTKERNELAPI
2774 PCONFIGURATION_INFORMATION
2775 NTAPI
2776 IoGetConfigurationInformation(
2777   VOID);
2778
2779 NTKERNELAPI
2780 PEPROCESS
2781 NTAPI
2782 IoGetCurrentProcess(
2783   VOID);
2784
2785 NTKERNELAPI
2786 NTSTATUS
2787 NTAPI
2788 IoGetDeviceInterfaceAlias(
2789   IN PUNICODE_STRING  SymbolicLinkName,
2790   IN CONST GUID  *AliasInterfaceClassGuid,
2791   OUT PUNICODE_STRING  AliasSymbolicLinkName);
2792
2793 #define DEVICE_INTERFACE_INCLUDE_NONACTIVE 0x00000001
2794
2795 NTKERNELAPI
2796 NTSTATUS
2797 NTAPI
2798 IoGetDeviceInterfaces(
2799   IN CONST GUID  *InterfaceClassGuid,
2800   IN PDEVICE_OBJECT  PhysicalDeviceObject  OPTIONAL,
2801   IN ULONG  Flags,
2802   OUT PWSTR  *SymbolicLinkList);
2803
2804 NTKERNELAPI
2805 NTSTATUS
2806 NTAPI
2807 IoGetDeviceObjectPointer(
2808   IN PUNICODE_STRING  ObjectName,
2809   IN ACCESS_MASK  DesiredAccess,
2810   OUT PFILE_OBJECT  *FileObject,
2811   OUT PDEVICE_OBJECT  *DeviceObject);
2812
2813 NTKERNELAPI
2814 NTSTATUS
2815 NTAPI
2816 IoGetDeviceProperty(
2817   IN PDEVICE_OBJECT  DeviceObject,
2818   IN DEVICE_REGISTRY_PROPERTY  DeviceProperty,
2819   IN ULONG  BufferLength,
2820   OUT PVOID  PropertyBuffer,
2821   OUT PULONG  ResultLength);
2822
2823 NTKERNELAPI
2824 PDEVICE_OBJECT
2825 NTAPI
2826 IoGetDeviceToVerify(
2827   IN PETHREAD  Thread);
2828
2829 NTKERNELAPI
2830 PDMA_ADAPTER
2831 NTAPI
2832 IoGetDmaAdapter(
2833   IN PDEVICE_OBJECT  PhysicalDeviceObject,
2834   IN PDEVICE_DESCRIPTION  DeviceDescription,
2835   IN OUT PULONG  NumberOfMapRegisters);
2836
2837 NTKERNELAPI
2838 PVOID
2839 NTAPI
2840 IoGetDriverObjectExtension(
2841   IN PDRIVER_OBJECT  DriverObject,
2842   IN PVOID  ClientIdentificationAddress);
2843
2844 NTKERNELAPI
2845 PGENERIC_MAPPING
2846 NTAPI
2847 IoGetFileObjectGenericMapping(
2848   VOID);
2849
2850 /*
2851  * ULONG
2852  * IoGetFunctionCodeFromCtlCode(
2853  *   IN ULONG  ControlCode)
2854  */
2855 #define IoGetFunctionCodeFromCtlCode(_ControlCode) \
2856   (((_ControlCode) >> 2) & 0x00000FFF)
2857
2858 NTKERNELAPI
2859 PVOID
2860 NTAPI
2861 IoGetInitialStack(
2862   VOID);
2863
2864 NTKERNELAPI
2865 PDEVICE_OBJECT
2866 NTAPI
2867 IoGetRelatedDeviceObject(
2868   IN PFILE_OBJECT  FileObject);
2869
2870 NTKERNELAPI
2871 VOID
2872 NTAPI
2873 IoGetStackLimits(
2874   OUT PULONG_PTR  LowLimit,
2875   OUT PULONG_PTR  HighLimit);
2876
2877 FORCEINLINE
2878 ULONG_PTR
2879 IoGetRemainingStackSize(
2880   VOID
2881 )
2882 {
2883     ULONG_PTR End, Begin;
2884     ULONG_PTR Result;
2885
2886     IoGetStackLimits(&Begin, &End);
2887     Result = (ULONG_PTR)(&End) - Begin;
2888     return Result;
2889 }
2890
2891 NTKERNELAPI
2892 VOID
2893 NTAPI
2894 KeInitializeDpc(
2895   IN PRKDPC  Dpc,
2896   IN PKDEFERRED_ROUTINE  DeferredRoutine,
2897   IN PVOID  DeferredContext);
2898
2899 /*
2900  * VOID
2901  * IoInitializeDpcRequest(
2902  *   IN PDEVICE_OBJECT DeviceObject,
2903  *   IN PIO_DPC_ROUTINE DpcRoutine)
2904  */
2905 #define IoInitializeDpcRequest(_DeviceObject, \
2906                                _DpcRoutine) \
2907   KeInitializeDpc(&(_DeviceObject)->Dpc, \
2908     (PKDEFERRED_ROUTINE) (_DpcRoutine), \
2909     _DeviceObject)
2910
2911 NTKERNELAPI
2912 VOID
2913 NTAPI
2914 IoInitializeIrp(
2915   IN OUT PIRP  Irp,
2916   IN USHORT  PacketSize,
2917   IN CCHAR  StackSize);
2918
2919 NTKERNELAPI
2920 VOID
2921 NTAPI
2922 IoInitializeRemoveLockEx(
2923   IN  PIO_REMOVE_LOCK Lock,
2924   IN  ULONG   AllocateTag,
2925   IN  ULONG   MaxLockedMinutes,
2926   IN  ULONG   HighWatermark,
2927   IN  ULONG   RemlockSize);
2928
2929 /* VOID
2930  * IoInitializeRemoveLock(
2931  *   IN PIO_REMOVE_LOCK  Lock,
2932  *   IN ULONG  AllocateTag,
2933  *   IN ULONG  MaxLockedMinutes,
2934  *   IN ULONG  HighWatermark)
2935  */
2936 #define IoInitializeRemoveLock( \
2937   Lock, AllocateTag, MaxLockedMinutes, HighWatermark) \
2938   IoInitializeRemoveLockEx(Lock, AllocateTag, MaxLockedMinutes, \
2939     HighWatermark, sizeof(IO_REMOVE_LOCK))
2940
2941 NTKERNELAPI
2942 NTSTATUS
2943 NTAPI
2944 IoInitializeTimer(
2945   IN PDEVICE_OBJECT  DeviceObject,
2946   IN PIO_TIMER_ROUTINE  TimerRoutine,
2947   IN PVOID  Context);
2948
2949 NTKERNELAPI
2950 VOID
2951 NTAPI
2952 IoInvalidateDeviceRelations(
2953   IN PDEVICE_OBJECT  DeviceObject,
2954   IN DEVICE_RELATION_TYPE  Type);
2955
2956 NTKERNELAPI
2957 VOID
2958 NTAPI
2959 IoInvalidateDeviceState(
2960   IN PDEVICE_OBJECT  PhysicalDeviceObject);
2961
2962 NTKERNELAPI
2963 BOOLEAN
2964 NTAPI
2965 IoIs32bitProcess(
2966   IN PIRP  Irp  OPTIONAL);
2967
2968 /*
2969  * BOOLEAN
2970  * IoIsErrorUserInduced(
2971  *   IN NTSTATUS  Status);
2972  */
2973 #define IoIsErrorUserInduced(Status) \
2974    ((BOOLEAN)(((Status) == STATUS_DEVICE_NOT_READY) || \
2975    ((Status) == STATUS_IO_TIMEOUT) || \
2976    ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \
2977    ((Status) == STATUS_NO_MEDIA_IN_DEVICE) || \
2978    ((Status) == STATUS_VERIFY_REQUIRED) || \
2979    ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \
2980    ((Status) == STATUS_WRONG_VOLUME)))
2981
2982 NTKERNELAPI
2983 BOOLEAN
2984 NTAPI
2985 IoIsWdmVersionAvailable(
2986   IN UCHAR  MajorVersion,
2987   IN UCHAR  MinorVersion);
2988
2989 NTKERNELAPI
2990 PIRP
2991 NTAPI
2992 IoMakeAssociatedIrp(
2993   IN PIRP  Irp,
2994   IN CCHAR  StackSize);
2995
2996 /*
2997  * VOID
2998  * IoMarkIrpPending(
2999  *   IN OUT PIRP  Irp)
3000  */
3001 #define IoMarkIrpPending(_Irp) \
3002   (IoGetCurrentIrpStackLocation(_Irp)->Control |= SL_PENDING_RETURNED)
3003
3004 NTKERNELAPI
3005 NTSTATUS
3006 NTAPI
3007 IoOpenDeviceInterfaceRegistryKey(
3008   IN PUNICODE_STRING  SymbolicLinkName,
3009   IN ACCESS_MASK  DesiredAccess,
3010   OUT PHANDLE  DeviceInterfaceKey);
3011
3012 #define PLUGPLAY_REGKEY_DEVICE                            1
3013 #define PLUGPLAY_REGKEY_DRIVER                            2
3014 #define PLUGPLAY_REGKEY_CURRENT_HWPROFILE                 4
3015
3016 NTKERNELAPI
3017 NTSTATUS
3018 NTAPI
3019 IoOpenDeviceRegistryKey(
3020   IN PDEVICE_OBJECT  DeviceObject,
3021   IN ULONG  DevInstKeyType,
3022   IN ACCESS_MASK  DesiredAccess,
3023   OUT PHANDLE  DevInstRegKey);
3024
3025 NTKERNELAPI
3026 NTSTATUS
3027 NTAPI
3028 IoQueryDeviceDescription(
3029   IN PINTERFACE_TYPE  BusType  OPTIONAL,
3030   IN PULONG  BusNumber  OPTIONAL,
3031   IN PCONFIGURATION_TYPE  ControllerType  OPTIONAL,
3032   IN PULONG  ControllerNumber  OPTIONAL,
3033   IN PCONFIGURATION_TYPE  PeripheralType  OPTIONAL,
3034   IN PULONG  PeripheralNumber  OPTIONAL,
3035   IN PIO_QUERY_DEVICE_ROUTINE  CalloutRoutine,
3036   IN PVOID  Context);
3037
3038 NTKERNELAPI
3039 VOID
3040 NTAPI
3041 IoQueueWorkItem(
3042   IN PIO_WORKITEM  pIOWorkItem,
3043   IN PIO_WORKITEM_ROUTINE  Routine,
3044   IN WORK_QUEUE_TYPE  QueueType,
3045   IN PVOID  Context);
3046
3047 NTKERNELAPI
3048 VOID
3049 NTAPI
3050 IoRaiseHardError(
3051   IN PIRP  Irp,
3052   IN PVPB  Vpb  OPTIONAL,
3053   IN PDEVICE_OBJECT  RealDeviceObject);
3054
3055 NTKERNELAPI
3056 BOOLEAN
3057 NTAPI
3058 IoRaiseInformationalHardError(
3059   IN NTSTATUS  ErrorStatus,
3060   IN PUNICODE_STRING  String  OPTIONAL,
3061   IN PKTHREAD  Thread  OPTIONAL);
3062
3063 NTKERNELAPI
3064 NTSTATUS
3065 NTAPI
3066 IoReadDiskSignature(
3067   IN PDEVICE_OBJECT  DeviceObject,
3068   IN ULONG  BytesPerSector,
3069   OUT PDISK_SIGNATURE  Signature);
3070
3071 NTKERNELAPI
3072 NTSTATUS
3073 FASTCALL
3074 IoReadPartitionTable(
3075   IN PDEVICE_OBJECT  DeviceObject,
3076   IN ULONG  SectorSize,
3077   IN BOOLEAN  ReturnRecognizedPartitions,
3078   OUT struct _DRIVE_LAYOUT_INFORMATION  **PartitionBuffer);
3079
3080 NTKERNELAPI
3081 NTSTATUS
3082 NTAPI
3083 IoReadPartitionTableEx(
3084   IN PDEVICE_OBJECT  DeviceObject,
3085   IN struct _DRIVE_LAYOUT_INFORMATION_EX  **PartitionBuffer);
3086
3087 NTKERNELAPI
3088 VOID
3089 NTAPI
3090 IoRegisterBootDriverReinitialization(
3091   IN PDRIVER_OBJECT  DriverObject,
3092   IN PDRIVER_REINITIALIZE  DriverReinitializationRoutine,
3093   IN PVOID  Context);
3094
3095 NTKERNELAPI
3096 VOID
3097 NTAPI
3098 IoRegisterBootDriverReinitialization(
3099   IN PDRIVER_OBJECT  DriverObject,
3100   IN PDRIVER_REINITIALIZE  DriverReinitializationRoutine,
3101   IN PVOID  Context);
3102
3103 NTKERNELAPI
3104 NTSTATUS
3105 NTAPI
3106 IoRegisterDeviceInterface(
3107   IN PDEVICE_OBJECT  PhysicalDeviceObject,
3108   IN CONST GUID  *InterfaceClassGuid,
3109   IN PUNICODE_STRING  ReferenceString  OPTIONAL,
3110   OUT PUNICODE_STRING  SymbolicLinkName);
3111
3112 NTKERNELAPI
3113 VOID
3114 NTAPI
3115 IoRegisterDriverReinitialization(
3116   IN PDRIVER_OBJECT  DriverObject,
3117   IN PDRIVER_REINITIALIZE  DriverReinitializationRoutine,
3118   IN PVOID  Context);
3119
3120 NTKERNELAPI
3121 NTSTATUS
3122 NTAPI
3123 IoRegisterPlugPlayNotification(
3124   IN IO_NOTIFICATION_EVENT_CATEGORY  EventCategory,
3125   IN ULONG  EventCategoryFlags,
3126   IN PVOID  EventCategoryData  OPTIONAL,
3127   IN PDRIVER_OBJECT  DriverObject,
3128   IN PDRIVER_NOTIFICATION_CALLBACK_ROUTINE  CallbackRoutine,
3129   IN PVOID  Context,
3130   OUT PVOID  *NotificationEntry);
3131
3132 NTKERNELAPI
3133 NTSTATUS
3134 NTAPI
3135 IoRegisterShutdownNotification(
3136   IN PDEVICE_OBJECT  DeviceObject);
3137
3138 NTKERNELAPI
3139 VOID
3140 NTAPI
3141 IoReleaseCancelSpinLock(
3142   IN KIRQL  Irql);
3143
3144 NTKERNELAPI
3145 VOID
3146 NTAPI
3147 IoReleaseRemoveLockAndWaitEx(
3148   IN PIO_REMOVE_LOCK  RemoveLock,
3149   IN PVOID  Tag,
3150   IN ULONG  RemlockSize);
3151
3152 NTKERNELAPI
3153 VOID
3154 NTAPI
3155 IoReleaseRemoveLockEx(
3156   IN PIO_REMOVE_LOCK  RemoveLock,
3157   IN PVOID  Tag,
3158   IN ULONG  RemlockSize);
3159
3160 /*
3161  * VOID
3162  * IoReleaseRemoveLock(
3163  *   IN PIO_REMOVE_LOCK  RemoveLock,
3164  *   IN PVOID  Tag)
3165  */
3166 #define IoReleaseRemoveLock(_RemoveLock, \
3167                             _Tag) \
3168   IoReleaseRemoveLockEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK))
3169
3170 /*
3171  * VOID
3172  * IoReleaseRemoveLockAndWait(
3173  *   IN PIO_REMOVE_LOCK  RemoveLock,
3174  *   IN PVOID  Tag)
3175  */
3176 #define IoReleaseRemoveLockAndWait(_RemoveLock, \
3177                                    _Tag) \
3178   IoReleaseRemoveLockAndWaitEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK))
3179
3180 NTKERNELAPI
3181 VOID
3182 NTAPI
3183 IoRemoveShareAccess(
3184   IN PFILE_OBJECT  FileObject,
3185   IN OUT PSHARE_ACCESS  ShareAccess);
3186
3187 NTKERNELAPI
3188 NTSTATUS
3189 NTAPI
3190 IoReportDetectedDevice(
3191   IN PDRIVER_OBJECT  DriverObject,
3192   IN INTERFACE_TYPE  LegacyBusType,
3193   IN ULONG  BusNumber,
3194   IN ULONG  SlotNumber,
3195   IN PCM_RESOURCE_LIST  ResourceList,
3196   IN PIO_RESOURCE_REQUIREMENTS_LIST  ResourceRequirements  OPTIONAL,
3197   IN BOOLEAN  ResourceAssigned,
3198   IN OUT PDEVICE_OBJECT  *DeviceObject);
3199
3200 NTKERNELAPI
3201 NTSTATUS
3202 NTAPI
3203 IoReportResourceForDetection(
3204   IN PDRIVER_OBJECT  DriverObject,
3205   IN PCM_RESOURCE_LIST  DriverList  OPTIONAL,
3206   IN ULONG  DriverListSize  OPTIONAL,
3207   IN PDEVICE_OBJECT  DeviceObject  OPTIONAL,
3208   IN PCM_RESOURCE_LIST  DeviceList  OPTIONAL,
3209   IN ULONG  DeviceListSize  OPTIONAL,
3210   OUT PBOOLEAN  ConflictDetected);
3211
3212 NTKERNELAPI
3213 NTSTATUS
3214 NTAPI
3215 IoReportResourceUsage(
3216   IN PUNICODE_STRING  DriverClassName  OPTIONAL,
3217   IN PDRIVER_OBJECT  DriverObject,
3218   IN PCM_RESOURCE_LIST  DriverList  OPTIONAL,
3219   IN ULONG  DriverListSize  OPTIONAL,
3220   IN PDEVICE_OBJECT  DeviceObject,
3221   IN PCM_RESOURCE_LIST  DeviceList  OPTIONAL,
3222   IN ULONG  DeviceListSize  OPTIONAL,
3223   IN BOOLEAN  OverrideConflict,
3224   OUT PBOOLEAN  ConflictDetected);
3225
3226 NTKERNELAPI
3227 NTSTATUS
3228 NTAPI
3229 IoReportTargetDeviceChange(
3230   IN PDEVICE_OBJECT  PhysicalDeviceObject,
3231   IN PVOID  NotificationStructure);
3232
3233 NTKERNELAPI
3234 NTSTATUS
3235 NTAPI
3236 IoReportTargetDeviceChangeAsynchronous(
3237   IN PDEVICE_OBJECT  PhysicalDeviceObject,
3238   IN PVOID  NotificationStructure,
3239   IN PDEVICE_CHANGE_COMPLETE_CALLBACK  Callback  OPTIONAL,
3240   IN PVOID  Context  OPTIONAL);
3241
3242 NTKERNELAPI
3243 VOID
3244 NTAPI
3245 IoRequestDeviceEject(
3246   IN PDEVICE_OBJECT  PhysicalDeviceObject);
3247
3248 /*
3249  * VOID
3250  * IoRequestDpc(
3251  *   IN PDEVICE_OBJECT  DeviceObject,
3252  *   IN PIRP  Irp,
3253  *   IN PVOID  Context);
3254  */
3255 #define IoRequestDpc(DeviceObject, Irp, Context)( \
3256   KeInsertQueueDpc(&(DeviceObject)->Dpc, (Irp), (Context)))
3257
3258 NTKERNELAPI
3259 VOID
3260 NTAPI
3261 IoReuseIrp(
3262   IN OUT PIRP  Irp,
3263   IN NTSTATUS  Status);
3264
3265 /*
3266  * PDRIVER_CANCEL
3267  * IoSetCancelRoutine(
3268  *   IN PIRP  Irp,
3269  *   IN PDRIVER_CANCEL  CancelRoutine)
3270  */
3271 #define IoSetCancelRoutine(_Irp, \
3272                            _CancelRoutine) \
3273   ((PDRIVER_CANCEL) InterlockedExchangePointer( \
3274     (PVOID *) &(_Irp)->CancelRoutine, (PVOID) (_CancelRoutine)))
3275
3276 /*
3277  * VOID
3278  * IoSetCompletionRoutine(
3279  *   IN PIRP  Irp,
3280  *   IN PIO_COMPLETION_ROUTINE  CompletionRoutine,
3281  *   IN PVOID  Context,
3282  *   IN BOOLEAN  InvokeOnSuccess,
3283  *   IN BOOLEAN  InvokeOnError,
3284  *   IN BOOLEAN  InvokeOnCancel)
3285  */
3286 #define IoSetCompletionRoutine(_Irp, \
3287                                _CompletionRoutine, \
3288                                _Context, \
3289                                _InvokeOnSuccess, \
3290                                _InvokeOnError, \
3291                                _InvokeOnCancel) \
3292 { \
3293   PIO_STACK_LOCATION _IrpSp; \
3294   ASSERT((_InvokeOnSuccess) || (_InvokeOnError) || (_InvokeOnCancel) ? \
3295     (_CompletionRoutine) != NULL : TRUE); \
3296   _IrpSp = IoGetNextIrpStackLocation(_Irp); \
3297   _IrpSp->CompletionRoutine = (PIO_COMPLETION_ROUTINE)(_CompletionRoutine); \
3298   _IrpSp->Context = (_Context); \
3299   _IrpSp->Control = 0; \
3300   if (_InvokeOnSuccess) _IrpSp->Control = SL_INVOKE_ON_SUCCESS; \
3301   if (_InvokeOnError) _IrpSp->Control |= SL_INVOKE_ON_ERROR; \
3302   if (_InvokeOnCancel) _IrpSp->Control |= SL_INVOKE_ON_CANCEL; \
3303 }
3304
3305 NTKERNELAPI
3306 NTSTATUS
3307 NTAPI
3308 IoSetCompletionRoutineEx(
3309   IN PDEVICE_OBJECT  DeviceObject,
3310   IN PIRP  Irp,
3311   IN PIO_COMPLETION_ROUTINE  CompletionRoutine,
3312   IN PVOID  Context,
3313   IN BOOLEAN  InvokeOnSuccess,
3314   IN BOOLEAN  InvokeOnError,
3315   IN BOOLEAN  InvokeOnCancel);
3316
3317 NTKERNELAPI
3318 NTSTATUS
3319 NTAPI
3320 IoSetDeviceInterfaceState(
3321   IN PUNICODE_STRING  SymbolicLinkName,
3322   IN BOOLEAN  Enable);
3323
3324 NTKERNELAPI
3325 VOID
3326 NTAPI
3327 IoSetHardErrorOrVerifyDevice(
3328   IN PIRP  Irp,
3329   IN PDEVICE_OBJECT  DeviceObject);
3330
3331 /*
3332  * VOID
3333  * IoSetNextIrpStackLocation(
3334  *   IN OUT PIRP  Irp)
3335  */
3336 #define IoSetNextIrpStackLocation(_Irp) \
3337 { \
3338   (_Irp)->CurrentLocation--; \
3339   (_Irp)->Tail.Overlay.CurrentStackLocation--; \
3340 }
3341
3342 NTKERNELAPI
3343 NTSTATUS
3344 FASTCALL
3345 IoSetPartitionInformation(
3346   IN PDEVICE_OBJECT  DeviceObject,
3347   IN ULONG  SectorSize,
3348   IN ULONG  PartitionNumber,
3349   IN ULONG  PartitionType);
3350
3351 NTKERNELAPI
3352 NTSTATUS
3353 NTAPI
3354 IoSetPartitionInformationEx(
3355   IN PDEVICE_OBJECT  DeviceObject,
3356   IN ULONG  PartitionNumber,
3357   IN struct _SET_PARTITION_INFORMATION_EX  *PartitionInfo);
3358
3359 NTKERNELAPI
3360 VOID
3361 NTAPI
3362 IoSetShareAccess(
3363   IN ACCESS_MASK  DesiredAccess,
3364   IN ULONG  DesiredShareAccess,
3365   IN OUT PFILE_OBJECT  FileObject,
3366   OUT PSHARE_ACCESS  ShareAccess);
3367
3368 NTKERNELAPI
3369 VOID
3370 NTAPI
3371 IoSetStartIoAttributes(
3372   IN PDEVICE_OBJECT  DeviceObject,
3373   IN BOOLEAN  DeferredStartIo,
3374   IN BOOLEAN  NonCancelable);
3375
3376 NTKERNELAPI
3377 NTSTATUS
3378 NTAPI
3379 IoSetSystemPartition(
3380   IN PUNICODE_STRING  VolumeNameString);
3381
3382 NTKERNELAPI
3383 BOOLEAN
3384 NTAPI
3385 IoSetThreadHardErrorMode(
3386   IN BOOLEAN  EnableHardErrors);
3387
3388 /*
3389  * USHORT
3390  * IoSizeOfIrp(
3391  *   IN CCHAR  StackSize)
3392  */
3393 #define IoSizeOfIrp(_StackSize) \
3394   ((USHORT) (sizeof(IRP) + ((_StackSize) * (sizeof(IO_STACK_LOCATION)))))
3395
3396 /*
3397  * VOID
3398  * IoSkipCurrentIrpStackLocation(
3399  *   IN PIRP  Irp)
3400  */
3401 #define IoSkipCurrentIrpStackLocation(_Irp) \
3402 { \
3403   (_Irp)->CurrentLocation++; \
3404   (_Irp)->Tail.Overlay.CurrentStackLocation++; \
3405 }
3406
3407 NTKERNELAPI
3408 VOID
3409 NTAPI
3410 IoStartNextPacket(
3411   IN PDEVICE_OBJECT  DeviceObject,
3412   IN BOOLEAN  Cancelable);
3413
3414 NTKERNELAPI
3415 VOID
3416 NTAPI
3417 IoStartNextPacketByKey(
3418   IN PDEVICE_OBJECT  DeviceObject,
3419   IN BOOLEAN  Cancelable,
3420   IN ULONG  Key);
3421
3422 NTKERNELAPI
3423 VOID
3424 NTAPI
3425 IoStartPacket(
3426   IN PDEVICE_OBJECT  DeviceObject,
3427   IN PIRP  Irp,
3428   IN PULONG  Key  OPTIONAL,
3429   IN PDRIVER_CANCEL  CancelFunction  OPTIONAL);
3430
3431 NTKERNELAPI
3432 VOID
3433 NTAPI
3434 IoStartTimer(
3435   IN PDEVICE_OBJECT  DeviceObject);
3436
3437 NTKERNELAPI
3438 VOID
3439 NTAPI
3440 IoStopTimer(
3441   IN PDEVICE_OBJECT  DeviceObject);
3442
3443 NTKERNELAPI
3444 NTSTATUS
3445 NTAPI
3446 IoUnregisterPlugPlayNotification(
3447   IN PVOID  NotificationEntry);
3448
3449 NTKERNELAPI
3450 VOID
3451 NTAPI
3452 IoUnregisterShutdownNotification(
3453   IN PDEVICE_OBJECT  DeviceObject);
3454
3455 NTKERNELAPI
3456 VOID
3457 NTAPI
3458 IoUpdateShareAccess(
3459   IN PFILE_OBJECT  FileObject,
3460   IN OUT PSHARE_ACCESS  ShareAccess);
3461
3462 NTKERNELAPI
3463 NTSTATUS
3464 NTAPI
3465 IoVerifyPartitionTable(
3466   IN PDEVICE_OBJECT  DeviceObject,
3467   IN BOOLEAN  FixErrors);
3468
3469 NTKERNELAPI
3470 NTSTATUS
3471 NTAPI
3472 IoVolumeDeviceToDosName(
3473   IN  PVOID  VolumeDeviceObject,
3474   OUT PUNICODE_STRING  DosName);
3475
3476 NTKERNELAPI
3477 NTSTATUS
3478 NTAPI
3479 IoWMIAllocateInstanceIds(
3480   IN GUID  *Guid,
3481   IN ULONG  InstanceCount,
3482   OUT ULONG  *FirstInstanceId);
3483
3484 NTKERNELAPI
3485 ULONG
3486 NTAPI
3487 IoWMIDeviceObjectToProviderId(
3488   IN PDEVICE_OBJECT  DeviceObject);
3489
3490 NTKERNELAPI
3491 NTSTATUS
3492 NTAPI
3493 IoWMIDeviceObjectToInstanceName(
3494   IN PVOID  DataBlockObject,
3495   IN PDEVICE_OBJECT  DeviceObject,
3496   OUT PUNICODE_STRING  InstanceName);
3497
3498 NTKERNELAPI
3499 NTSTATUS
3500 NTAPI
3501 IoWMIExecuteMethod(
3502   IN PVOID  DataBlockObject,
3503   IN PUNICODE_STRING  InstanceName,
3504   IN ULONG  MethodId,
3505   IN ULONG  InBufferSize,
3506   IN OUT PULONG  OutBufferSize,
3507   IN OUT  PUCHAR  InOutBuffer);
3508
3509 NTKERNELAPI
3510 NTSTATUS
3511 NTAPI
3512 IoWMIHandleToInstanceName(
3513   IN PVOID  DataBlockObject,
3514   IN HANDLE  FileHandle,
3515   OUT PUNICODE_STRING  InstanceName);
3516
3517 NTKERNELAPI
3518 NTSTATUS
3519 NTAPI
3520 IoWMIOpenBlock(
3521   IN GUID  *DataBlockGuid,
3522   IN ULONG  DesiredAccess,
3523   OUT PVOID  *DataBlockObject);
3524
3525 NTKERNELAPI
3526 NTSTATUS
3527 NTAPI
3528 IoWMIQueryAllData(
3529   IN PVOID  DataBlockObject,
3530   IN OUT ULONG  *InOutBufferSize,
3531   OUT PVOID  OutBuffer);
3532
3533 NTKERNELAPI
3534 NTSTATUS
3535 NTAPI
3536 IoWMIQueryAllDataMultiple(
3537   IN PVOID  *DataBlockObjectList,
3538   IN ULONG  ObjectCount,
3539   IN OUT ULONG  *InOutBufferSize,
3540   OUT PVOID  OutBuffer);
3541
3542 NTKERNELAPI
3543 NTSTATUS
3544 NTAPI
3545 IoWMIQuerySingleInstance(
3546   IN PVOID  DataBlockObject,
3547   IN PUNICODE_STRING  InstanceName,
3548   IN OUT ULONG  *InOutBufferSize,
3549   OUT PVOID OutBuffer);
3550
3551 NTKERNELAPI
3552 NTSTATUS
3553 NTAPI
3554 IoWMIQuerySingleInstanceMultiple(
3555   IN PVOID  *DataBlockObjectList,
3556   IN PUNICODE_STRING  InstanceNames,
3557   IN ULONG  ObjectCount,
3558   IN OUT ULONG  *InOutBufferSize,
3559   OUT PVOID  OutBuffer);
3560
3561 NTKERNELAPI
3562 NTSTATUS
3563 NTAPI
3564 IoWMIRegistrationControl(
3565   IN PDEVICE_OBJECT  DeviceObject,
3566   IN ULONG  Action);
3567
3568 NTKERNELAPI
3569 NTSTATUS
3570 NTAPI
3571 IoWMISetNotificationCallback(
3572   IN PVOID  Object,
3573   IN WMI_NOTIFICATION_CALLBACK  Callback,
3574   IN PVOID  Context);
3575
3576 NTKERNELAPI
3577 NTSTATUS
3578 NTAPI
3579 IoWMISetSingleInstance(
3580   IN PVOID  DataBlockObject,
3581   IN PUNICODE_STRING  InstanceName,
3582   IN ULONG  Version,
3583   IN ULONG  ValueBufferSize,
3584   IN PVOID  ValueBuffer);
3585
3586 NTKERNELAPI
3587 NTSTATUS
3588 NTAPI
3589 IoWMISetSingleItem(
3590   IN PVOID  DataBlockObject,
3591   IN PUNICODE_STRING  InstanceName,
3592   IN ULONG  DataItemId,
3593   IN ULONG  Version,
3594   IN ULONG  ValueBufferSize,
3595   IN PVOID  ValueBuffer);
3596
3597 NTKERNELAPI
3598 NTSTATUS
3599 NTAPI
3600 IoWMISuggestInstanceName(
3601   IN PDEVICE_OBJECT  PhysicalDeviceObject OPTIONAL,
3602   IN PUNICODE_STRING  SymbolicLinkName OPTIONAL,
3603   IN BOOLEAN  CombineNames,
3604   OUT PUNICODE_STRING  SuggestedInstanceName);
3605
3606 NTKERNELAPI
3607 NTSTATUS
3608 NTAPI
3609 IoWMIWriteEvent(
3610   IN PVOID  WnodeEventItem);
3611
3612 NTKERNELAPI
3613 VOID
3614 NTAPI
3615 IoWriteErrorLogEntry(
3616   IN PVOID  ElEntry);
3617
3618 NTKERNELAPI
3619 NTSTATUS
3620 FASTCALL
3621 IoWritePartitionTable(
3622   IN PDEVICE_OBJECT  DeviceObject,
3623   IN ULONG  SectorSize,
3624   IN ULONG  SectorsPerTrack,
3625   IN ULONG  NumberOfHeads,
3626   IN struct _DRIVE_LAYOUT_INFORMATION  *PartitionBuffer);
3627
3628 NTKERNELAPI
3629 NTSTATUS
3630 NTAPI
3631 IoWritePartitionTableEx(
3632   IN PDEVICE_OBJECT  DeviceObject,
3633   IN struct _DRIVE_LAYOUT_INFORMATION_EX  *PartitionBuffer);
3634
3635
3636
3637 /** Kernel routines **/
3638
3639 #if defined (_M_AMD64)
3640 NTKERNELAPI
3641 VOID
3642 FASTCALL
3643 KeAcquireInStackQueuedSpinLock(
3644   IN PKSPIN_LOCK  SpinLock,
3645   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3646
3647 NTKERNELAPI
3648 VOID
3649 FASTCALL
3650 KeReleaseInStackQueuedSpinLock(
3651   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3652 #else
3653 NTHALAPI
3654 VOID
3655 FASTCALL
3656 KeAcquireInStackQueuedSpinLock(
3657   IN PKSPIN_LOCK  SpinLock,
3658   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3659
3660 NTHALAPI
3661 VOID
3662 FASTCALL
3663 KeReleaseInStackQueuedSpinLock(
3664   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3665 #endif
3666
3667 NTKERNELAPI
3668 VOID
3669 FASTCALL
3670 KeAcquireInStackQueuedSpinLockAtDpcLevel(
3671   IN PKSPIN_LOCK  SpinLock,
3672   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3673
3674 NTKERNELAPI
3675 KIRQL
3676 NTAPI
3677 KeAcquireInterruptSpinLock(
3678   IN PKINTERRUPT  Interrupt);
3679
3680 NTKERNELAPI
3681 BOOLEAN
3682 NTAPI
3683 KeAreApcsDisabled(
3684   VOID);
3685
3686 NTKERNELAPI
3687 DECLSPEC_NORETURN
3688 VOID
3689 NTAPI
3690 KeBugCheck(
3691   IN ULONG  BugCheckCode);
3692
3693 NTKERNELAPI
3694 DECLSPEC_NORETURN
3695 VOID
3696 NTAPI
3697 KeBugCheckEx(
3698   IN ULONG  BugCheckCode,
3699   IN ULONG_PTR  BugCheckParameter1,
3700   IN ULONG_PTR  BugCheckParameter2,
3701   IN ULONG_PTR  BugCheckParameter3,
3702   IN ULONG_PTR  BugCheckParameter4);
3703
3704 NTKERNELAPI
3705 BOOLEAN
3706 NTAPI
3707 KeCancelTimer(
3708   IN PKTIMER  Timer);
3709
3710 NTKERNELAPI
3711 VOID
3712 NTAPI
3713 KeClearEvent(
3714   IN PRKEVENT  Event);
3715
3716 NTKERNELAPI
3717 NTSTATUS
3718 NTAPI
3719 KeDelayExecutionThread(
3720   IN KPROCESSOR_MODE  WaitMode,
3721   IN BOOLEAN  Alertable,
3722   IN PLARGE_INTEGER  Interval);
3723
3724 NTKERNELAPI
3725 BOOLEAN
3726 NTAPI
3727 KeDeregisterBugCheckCallback(
3728   IN PKBUGCHECK_CALLBACK_RECORD  CallbackRecord);
3729
3730 NTKERNELAPI
3731 VOID
3732 NTAPI
3733 KeEnterCriticalRegion(
3734   VOID);
3735
3736 /*
3737  * VOID
3738  * KeFlushIoBuffers(
3739  *   IN PMDL  Mdl,
3740  *   IN BOOLEAN  ReadOperation,
3741  *   IN BOOLEAN  DmaOperation)
3742  */
3743 #define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
3744
3745 #define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql))
3746 #define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql))
3747 #define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock)
3748 #define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock)
3749
3750 NTKERNELAPI
3751 VOID
3752 NTAPI
3753 KeFlushQueuedDpcs(
3754     VOID
3755 );
3756
3757 NTHALAPI
3758 VOID
3759 NTAPI
3760 KeFlushWriteBuffer(VOID);
3761
3762 NTKERNELAPI
3763 ULONG
3764 NTAPI
3765 KeGetRecommendedSharedDataAlignment(
3766   VOID);
3767
3768 NTKERNELAPI
3769 VOID
3770 NTAPI
3771 KeInitializeDeviceQueue(
3772   IN PKDEVICE_QUEUE  DeviceQueue);
3773
3774 NTKERNELAPI
3775 VOID
3776 NTAPI
3777 KeInitializeMutex(
3778   IN PRKMUTEX  Mutex,
3779   IN ULONG  Level);
3780
3781 NTKERNELAPI
3782 VOID
3783 NTAPI
3784 KeInitializeSemaphore(
3785   IN PRKSEMAPHORE  Semaphore,
3786   IN LONG  Count,
3787   IN LONG  Limit);
3788
3789 NTKERNELAPI
3790 VOID
3791 NTAPI
3792 KeInitializeTimer(
3793   IN PKTIMER  Timer);
3794
3795 NTKERNELAPI
3796 VOID
3797 NTAPI
3798 KeInitializeTimerEx(
3799   IN PKTIMER  Timer,
3800   IN TIMER_TYPE  Type);
3801
3802 NTKERNELAPI
3803 BOOLEAN
3804 NTAPI
3805 KeInsertByKeyDeviceQueue(
3806   IN PKDEVICE_QUEUE  DeviceQueue,
3807   IN PKDEVICE_QUEUE_ENTRY  DeviceQueueEntry,
3808   IN ULONG  SortKey);
3809
3810 NTKERNELAPI
3811 BOOLEAN
3812 NTAPI
3813 KeInsertDeviceQueue(
3814   IN PKDEVICE_QUEUE  DeviceQueue,
3815   IN PKDEVICE_QUEUE_ENTRY  DeviceQueueEntry);
3816
3817 NTKERNELAPI
3818 BOOLEAN
3819 NTAPI
3820 KeInsertQueueDpc(
3821   IN PRKDPC  Dpc,
3822   IN PVOID  SystemArgument1,
3823   IN PVOID  SystemArgument2);
3824
3825 NTKERNELAPI
3826 VOID
3827 NTAPI
3828 KeLeaveCriticalRegion(
3829   VOID);
3830
3831 #ifdef _X86_
3832
3833 static __inline
3834 VOID
3835 KeMemoryBarrier(
3836   VOID)
3837 {
3838   volatile LONG Barrier;
3839 #if defined(__GNUC__)
3840   __asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) : "%eax");
3841 #elif defined(_MSC_VER)
3842   __asm xchg [Barrier], eax
3843 #endif
3844 }
3845
3846 #endif
3847
3848 NTKERNELAPI
3849 LONG
3850 NTAPI
3851 KePulseEvent(
3852   IN PRKEVENT  Event,
3853   IN KPRIORITY  Increment,
3854   IN BOOLEAN  Wait);
3855
3856 NTKERNELAPI
3857 KAFFINITY
3858 NTAPI
3859 KeQueryActiveProcessors(
3860     VOID
3861 );
3862
3863 NTHALAPI
3864 LARGE_INTEGER
3865 NTAPI
3866 KeQueryPerformanceCounter(
3867   OUT PLARGE_INTEGER  PerformanceFrequency  OPTIONAL);
3868
3869 NTKERNELAPI
3870 KPRIORITY
3871 NTAPI
3872 KeQueryPriorityThread(
3873   IN PRKTHREAD  Thread);
3874
3875 NTKERNELAPI
3876 ULONG
3877 NTAPI
3878 KeQueryRuntimeThread(
3879   IN PKTHREAD Thread,
3880   OUT PULONG UserTime);
3881
3882 #if !defined(_M_AMD64)
3883 NTKERNELAPI
3884 ULONGLONG
3885 NTAPI
3886 KeQueryInterruptTime(
3887   VOID);
3888
3889 NTKERNELAPI
3890 VOID
3891 NTAPI
3892 KeQuerySystemTime(
3893   OUT PLARGE_INTEGER  CurrentTime);
3894
3895 NTKERNELAPI
3896 VOID
3897 NTAPI
3898 KeQueryTickCount(
3899   OUT PLARGE_INTEGER  TickCount);
3900 #endif
3901
3902 NTKERNELAPI
3903 ULONG
3904 NTAPI
3905 KeQueryTimeIncrement(
3906   VOID);
3907
3908 NTKERNELAPI
3909 LONG
3910 NTAPI
3911 KeReadStateEvent(
3912   IN PRKEVENT  Event);
3913
3914 NTKERNELAPI
3915 LONG
3916 NTAPI
3917 KeReadStateMutex(
3918   IN PRKMUTEX  Mutex);
3919
3920
3921 NTKERNELAPI
3922 LONG
3923 NTAPI
3924 KeReadStateSemaphore(
3925   IN PRKSEMAPHORE  Semaphore);
3926
3927 NTKERNELAPI
3928 BOOLEAN
3929 NTAPI
3930 KeReadStateTimer(
3931   IN PKTIMER  Timer);
3932
3933 NTKERNELAPI
3934 BOOLEAN
3935 NTAPI
3936 KeRegisterBugCheckCallback(
3937   IN PKBUGCHECK_CALLBACK_RECORD  CallbackRecord,
3938   IN PKBUGCHECK_CALLBACK_ROUTINE  CallbackRoutine,
3939   IN PVOID  Buffer,
3940   IN ULONG  Length,
3941   IN PUCHAR  Component);
3942
3943 NTKERNELAPI
3944 PVOID
3945 NTAPI
3946 KeRegisterNmiCallback(
3947   IN PNMI_CALLBACK CallbackRoutine,
3948   IN PVOID Context
3949 );
3950
3951 NTKERNELAPI
3952 NTSTATUS
3953 NTAPI
3954 KeDeregisterNmiCallback(
3955   IN PVOID Handle
3956 );
3957
3958 NTKERNELAPI
3959 VOID
3960 FASTCALL
3961 KeReleaseInStackQueuedSpinLockFromDpcLevel(
3962   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3963
3964 NTKERNELAPI
3965 VOID
3966 NTAPI
3967 KeReleaseInterruptSpinLock(
3968   IN PKINTERRUPT  Interrupt,
3969   IN KIRQL  OldIrql);
3970
3971 NTKERNELAPI
3972 LONG
3973 NTAPI
3974 KeReleaseMutex(
3975   IN PRKMUTEX  Mutex,
3976   IN BOOLEAN  Wait);
3977
3978 NTKERNELAPI
3979 LONG
3980 NTAPI
3981 KeReleaseSemaphore(
3982   IN PRKSEMAPHORE  Semaphore,
3983   IN KPRIORITY  Increment,
3984   IN LONG  Adjustment,
3985   IN BOOLEAN  Wait);
3986
3987 NTKERNELAPI
3988 PKDEVICE_QUEUE_ENTRY
3989 NTAPI
3990 KeRemoveByKeyDeviceQueue(
3991   IN PKDEVICE_QUEUE  DeviceQueue,
3992   IN ULONG  SortKey);
3993
3994 NTKERNELAPI
3995 PKDEVICE_QUEUE_ENTRY
3996 NTAPI
3997 KeRemoveDeviceQueue(
3998   IN PKDEVICE_QUEUE  DeviceQueue);
3999
4000 NTKERNELAPI
4001 BOOLEAN
4002 NTAPI
4003 KeRemoveEntryDeviceQueue(
4004   IN PKDEVICE_QUEUE  DeviceQueue,
4005   IN PKDEVICE_QUEUE_ENTRY  DeviceQueueEntry);
4006
4007 NTKERNELAPI
4008 BOOLEAN
4009 NTAPI
4010 KeRemoveQueueDpc(
4011   IN PRKDPC  Dpc);
4012
4013 NTKERNELAPI
4014 LONG
4015 NTAPI
4016 KeResetEvent(
4017   IN PRKEVENT  Event);
4018
4019 NTKERNELAPI
4020 NTSTATUS
4021 NTAPI
4022 KeRestoreFloatingPointState(
4023   IN PKFLOATING_SAVE  FloatSave);
4024
4025 NTKERNELAPI
4026 VOID
4027 NTAPI
4028 KeRevertToUserAffinityThread(VOID);
4029
4030 NTKERNELAPI
4031 NTSTATUS
4032 NTAPI
4033 KeSaveFloatingPointState(
4034   OUT PKFLOATING_SAVE  FloatSave);
4035
4036 NTKERNELAPI
4037 LONG
4038 NTAPI
4039 KeSetBasePriorityThread(
4040   IN PRKTHREAD  Thread,
4041   IN LONG  Increment);
4042
4043 NTKERNELAPI
4044 LONG
4045 NTAPI
4046 KeSetEvent(
4047   IN PRKEVENT  Event,
4048   IN KPRIORITY  Increment,
4049   IN BOOLEAN  Wait);
4050
4051 NTKERNELAPI
4052 VOID
4053 NTAPI
4054 KeSetImportanceDpc(
4055   IN PRKDPC  Dpc,
4056   IN KDPC_IMPORTANCE  Importance);
4057
4058 NTKERNELAPI
4059 KPRIORITY
4060 NTAPI
4061 KeSetPriorityThread(
4062   IN PKTHREAD  Thread,
4063   IN KPRIORITY  Priority);
4064
4065 NTKERNELAPI
4066 VOID
4067 NTAPI
4068 KeSetSystemAffinityThread(
4069     IN KAFFINITY Affinity);
4070
4071 NTKERNELAPI
4072 VOID
4073 NTAPI
4074 KeSetTargetProcessorDpc(
4075   IN PRKDPC  Dpc,
4076   IN CCHAR  Number);
4077
4078 NTKERNELAPI
4079 BOOLEAN
4080 NTAPI
4081 KeSetTimer(
4082   IN PKTIMER  Timer,
4083   IN LARGE_INTEGER  DueTime,
4084   IN PKDPC  Dpc  OPTIONAL);
4085
4086 NTKERNELAPI
4087 BOOLEAN
4088 NTAPI
4089 KeSetTimerEx(
4090   IN PKTIMER  Timer,
4091   IN LARGE_INTEGER  DueTime,
4092   IN LONG  Period  OPTIONAL,
4093   IN PKDPC  Dpc  OPTIONAL);
4094
4095 NTKERNELAPI
4096 VOID
4097 FASTCALL
4098 KeSetTimeUpdateNotifyRoutine(
4099   IN PTIME_UPDATE_NOTIFY_ROUTINE  NotifyRoutine);
4100
4101 NTHALAPI
4102 VOID
4103 NTAPI
4104 KeStallExecutionProcessor(
4105   IN ULONG  MicroSeconds);
4106
4107 NTKERNELAPI
4108 BOOLEAN
4109 NTAPI
4110 KeSynchronizeExecution(
4111   IN PKINTERRUPT    Interrupt,
4112   IN PKSYNCHRONIZE_ROUTINE  SynchronizeRoutine,
4113   IN PVOID  SynchronizeContext);
4114
4115 NTKERNELAPI
4116 NTSTATUS
4117 NTAPI
4118 KeWaitForMultipleObjects(
4119   IN ULONG  Count,
4120   IN PVOID  Object[],
4121   IN WAIT_TYPE  WaitType,
4122   IN KWAIT_REASON  WaitReason,
4123   IN KPROCESSOR_MODE  WaitMode,
4124   IN BOOLEAN  Alertable,
4125   IN PLARGE_INTEGER  Timeout  OPTIONAL,
4126   IN PKWAIT_BLOCK  WaitBlockArray  OPTIONAL);
4127
4128 NTKERNELAPI
4129 NTSTATUS
4130 NTAPI
4131 KeWaitForMutexObject(
4132   IN PRKMUTEX  Mutex,
4133   IN KWAIT_REASON  WaitReason,
4134   IN KPROCESSOR_MODE  WaitMode,
4135   IN BOOLEAN  Alertable,
4136   IN PLARGE_INTEGER  Timeout  OPTIONAL);
4137
4138 NTKERNELAPI
4139 NTSTATUS
4140 NTAPI
4141 KeWaitForSingleObject(
4142   IN PVOID  Object,
4143   IN KWAIT_REASON  WaitReason,
4144   IN KPROCESSOR_MODE  WaitMode,
4145   IN BOOLEAN  Alertable,
4146   IN PLARGE_INTEGER  Timeout  OPTIONAL);
4147
4148 typedef
4149 ULONG_PTR
4150 (NTAPI *PKIPI_BROADCAST_WORKER)(
4151     IN ULONG_PTR Argument
4152 );
4153
4154 NTKERNELAPI
4155 ULONG_PTR
4156 NTAPI
4157 KeIpiGenericCall(
4158     IN PKIPI_BROADCAST_WORKER BroadcastFunction,
4159     IN ULONG_PTR Context
4160 );
4161
4162 #if defined(_X86_)
4163
4164 NTHALAPI
4165 VOID
4166 FASTCALL
4167 KfLowerIrql(
4168   IN KIRQL  NewIrql);
4169
4170 NTHALAPI
4171 KIRQL
4172 FASTCALL
4173 KfRaiseIrql(
4174   IN KIRQL  NewIrql);
4175
4176 NTHALAPI
4177 KIRQL
4178 DDKAPI
4179 KeRaiseIrqlToDpcLevel(
4180   VOID);
4181
4182 NTHALAPI
4183 KIRQL
4184 DDKAPI
4185 KeRaiseIrqlToSynchLevel(
4186     VOID);
4187
4188 #define KeLowerIrql(a) KfLowerIrql(a)
4189 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
4190
4191 #elif defined(_M_AMD64)
4192
4193 FORCEINLINE
4194 KIRQL
4195 KeGetCurrentIrql(VOID)
4196 {
4197     return (KIRQL)__readcr8();
4198 }
4199
4200 FORCEINLINE
4201 VOID
4202 KeLowerIrql(IN KIRQL NewIrql)
4203 {
4204     ASSERT(KeGetCurrentIrql() >= NewIrql);
4205     __writecr8(NewIrql);
4206 }
4207
4208 FORCEINLINE
4209 KIRQL
4210 KfRaiseIrql(IN KIRQL NewIrql)
4211 {
4212     KIRQL OldIrql;
4213
4214     OldIrql = __readcr8();
4215     ASSERT(OldIrql <= NewIrql);
4216     __writecr8(NewIrql);
4217     return OldIrql;
4218 }
4219 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
4220
4221 FORCEINLINE
4222 KIRQL
4223 KeRaiseIrqlToDpcLevel(VOID)
4224 {
4225     return KfRaiseIrql(DISPATCH_LEVEL);
4226 }
4227
4228 FORCEINLINE
4229 KIRQL
4230 KeRaiseIrqlToSynchLevel(VOID)
4231 {
4232     return KfRaiseIrql(12); // SYNCH_LEVEL = IPI_LEVEL - 2
4233 }
4234
4235 #elif defined(__PowerPC__)
4236
4237 NTHALAPI
4238 VOID
4239 FASTCALL
4240 KfLowerIrql(
4241   IN KIRQL  NewIrql);
4242
4243 NTHALAPI
4244 KIRQL
4245 FASTCALL
4246 KfRaiseIrql(
4247   IN KIRQL  NewIrql);
4248
4249 NTHALAPI
4250 KIRQL
4251 DDKAPI
4252 KeRaiseIrqlToDpcLevel(
4253   VOID);
4254
4255 NTHALAPI
4256 KIRQL
4257 DDKAPI
4258 KeRaiseIrqlToSynchLevel(
4259     VOID);
4260
4261 #define KeLowerIrql(a) KfLowerIrql(a)
4262 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
4263
4264 #elif defined(_M_MIPS)
4265
4266 #define KeLowerIrql(a) KfLowerIrql(a)
4267 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
4268
4269 NTKERNELAPI
4270 VOID
4271 NTAPI
4272 KfLowerIrql(
4273   IN KIRQL  NewIrql);
4274
4275 NTKERNELAPI
4276 KIRQL
4277 NTAPI
4278 KfRaiseIrql(
4279   IN KIRQL  NewIrql);
4280
4281 NTKERNELAPI
4282 KIRQL
4283 NTAPI
4284 KeRaiseIrqlToDpcLevel(
4285   VOID);
4286
4287 NTKERNELAPI
4288 KIRQL
4289 DDKAPI
4290 KeRaiseIrqlToSynchLevel(
4291     VOID);
4292
4293 #elif defined(_M_ARM)
4294
4295 #include <armddk.h>
4296
4297 #else
4298
4299 NTKERNELAPI
4300 VOID
4301 NTAPI
4302 KeLowerIrql(
4303   IN KIRQL  NewIrql);
4304
4305 NTKERNELAPI
4306 VOID
4307 NTAPI
4308 KeRaiseIrql(
4309   IN KIRQL  NewIrql,
4310   OUT PKIRQL  OldIrql);
4311
4312 NTKERNELAPI
4313 KIRQL
4314 NTAPI
4315 KeRaiseIrqlToDpcLevel(
4316   VOID);
4317
4318 NTKERNELAPI
4319 KIRQL
4320 DDKAPI
4321 KeRaiseIrqlToSynchLevel(
4322     VOID);
4323
4324 #endif
4325
4326 /** Memory manager routines **/
4327
4328 NTKERNELAPI
4329 NTSTATUS
4330 NTAPI
4331 MmAdvanceMdl(
4332   IN PMDL  Mdl,
4333   IN ULONG  NumberOfBytes);
4334
4335 NTKERNELAPI
4336 PVOID
4337 NTAPI
4338 MmAllocateContiguousMemory(
4339   IN ULONG  NumberOfBytes,
4340   IN PHYSICAL_ADDRESS  HighestAcceptableAddress);
4341
4342 NTKERNELAPI
4343 PVOID
4344 NTAPI
4345 MmAllocateContiguousMemorySpecifyCache(
4346   IN SIZE_T  NumberOfBytes,
4347   IN PHYSICAL_ADDRESS  LowestAcceptableAddress,
4348   IN PHYSICAL_ADDRESS  HighestAcceptableAddress,
4349   IN PHYSICAL_ADDRESS  BoundaryAddressMultiple  OPTIONAL,
4350   IN MEMORY_CACHING_TYPE  CacheType);
4351
4352 NTKERNELAPI
4353 PVOID
4354 NTAPI
4355 MmAllocateMappingAddress(
4356   IN SIZE_T  NumberOfBytes,
4357   IN ULONG  PoolTag);
4358
4359 NTKERNELAPI
4360 PVOID
4361 NTAPI
4362 MmAllocateNonCachedMemory(
4363   IN ULONG  NumberOfBytes);
4364
4365 NTKERNELAPI
4366 PMDL
4367 NTAPI
4368 MmAllocatePagesForMdl(
4369   IN PHYSICAL_ADDRESS  LowAddress,
4370   IN PHYSICAL_ADDRESS  HighAddress,
4371   IN PHYSICAL_ADDRESS  SkipBytes,
4372   IN SIZE_T  TotalBytes);
4373
4374 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
4375 NTKERNELAPI
4376 PMDL
4377 NTAPI
4378 MmAllocatePagesForMdlEx(
4379   IN PHYSICAL_ADDRESS LowAddress,
4380   IN PHYSICAL_ADDRESS HighAddress,
4381   IN PHYSICAL_ADDRESS SkipBytes,
4382   IN SIZE_T TotalBytes,
4383   IN MEMORY_CACHING_TYPE CacheType,
4384   IN ULONG Flags);
4385 #endif
4386
4387 NTKERNELAPI
4388 VOID
4389 NTAPI
4390 MmBuildMdlForNonPagedPool(
4391   IN OUT PMDL  MemoryDescriptorList);
4392
4393 typedef enum _MMFLUSH_TYPE {
4394   MmFlushForDelete,
4395   MmFlushForWrite
4396 } MMFLUSH_TYPE;
4397
4398 NTKERNELAPI
4399 BOOLEAN
4400 NTAPI
4401 MmFlushImageSection(
4402   IN PSECTION_OBJECT_POINTERS  SectionObjectPointer,
4403   IN MMFLUSH_TYPE  FlushType);
4404
4405 NTKERNELAPI
4406 VOID
4407 NTAPI
4408 MmFreeContiguousMemory(
4409   IN PVOID  BaseAddress);
4410
4411 NTKERNELAPI
4412 VOID
4413 NTAPI
4414 MmFreeContiguousMemorySpecifyCache(
4415   IN PVOID  BaseAddress,
4416   IN SIZE_T  NumberOfBytes,
4417   IN MEMORY_CACHING_TYPE  CacheType);
4418
4419 NTKERNELAPI
4420 VOID
4421 NTAPI
4422 MmFreeMappingAddress(
4423   IN PVOID  BaseAddress,
4424   IN ULONG  PoolTag);
4425
4426 NTKERNELAPI
4427 VOID
4428 NTAPI
4429 MmFreeNonCachedMemory(
4430   IN PVOID  BaseAddress,
4431   IN SIZE_T  NumberOfBytes);
4432
4433 NTKERNELAPI
4434 VOID
4435 NTAPI
4436 MmFreePagesFromMdl(
4437   IN PMDL  MemoryDescriptorList);
4438
4439 /*
4440  * ULONG
4441  * MmGetMdlByteCount(
4442  *   IN PMDL  Mdl)
4443  */
4444 #define MmGetMdlByteCount(_Mdl) \
4445   ((_Mdl)->ByteCount)
4446
4447 /*
4448  * ULONG
4449  * MmGetMdlByteOffset(
4450  *   IN PMDL  Mdl)
4451  */
4452 #define MmGetMdlByteOffset(_Mdl) \
4453   ((_Mdl)->ByteOffset)
4454
4455 /*
4456  * PPFN_NUMBER
4457  * MmGetMdlPfnArray(
4458  *   IN PMDL  Mdl)
4459  */
4460 #define MmGetMdlPfnArray(_Mdl) \
4461   ((PPFN_NUMBER) ((_Mdl) + 1))
4462
4463 /*
4464  * PVOID
4465  * MmGetMdlVirtualAddress(
4466  *   IN PMDL  Mdl)
4467  */
4468 #define MmGetMdlVirtualAddress(_Mdl) \
4469   ((PVOID) ((PCHAR) ((_Mdl)->StartVa) + (_Mdl)->ByteOffset))
4470
4471 NTKERNELAPI
4472 PHYSICAL_ADDRESS
4473 NTAPI
4474 MmGetPhysicalAddress(
4475   IN PVOID  BaseAddress);
4476
4477 NTKERNELAPI
4478 PPHYSICAL_MEMORY_RANGE
4479 NTAPI
4480 MmGetPhysicalMemoryRanges(
4481   VOID);
4482
4483 NTKERNELAPI
4484 PVOID
4485 NTAPI
4486 MmGetVirtualForPhysical(
4487   IN PHYSICAL_ADDRESS  PhysicalAddress);
4488
4489 NTKERNELAPI
4490 PVOID
4491 NTAPI
4492 MmMapLockedPagesSpecifyCache(
4493   IN PMDL  MemoryDescriptorList,
4494   IN KPROCESSOR_MODE  AccessMode,
4495   IN MEMORY_CACHING_TYPE  CacheType,
4496   IN PVOID  BaseAddress,
4497   IN ULONG  BugCheckOnFailure,
4498   IN MM_PAGE_PRIORITY  Priority);
4499
4500 NTKERNELAPI
4501 PVOID
4502 NTAPI
4503 MmMapLockedPagesWithReservedMapping(
4504   IN PVOID  MappingAddress,
4505   IN ULONG  PoolTag,
4506   IN PMDL  MemoryDescriptorList,
4507   IN MEMORY_CACHING_TYPE  CacheType);
4508
4509 NTKERNELAPI
4510 NTSTATUS
4511 NTAPI
4512 MmMapUserAddressesToPage(
4513   IN PVOID  BaseAddress,
4514   IN SIZE_T  NumberOfBytes,
4515   IN PVOID  PageAddress);
4516
4517 NTKERNELAPI
4518 PVOID
4519 NTAPI
4520 MmMapVideoDisplay(
4521   IN PHYSICAL_ADDRESS  PhysicalAddress,
4522   IN SIZE_T  NumberOfBytes,
4523   IN MEMORY_CACHING_TYPE  CacheType);
4524
4525 NTKERNELAPI
4526 NTSTATUS
4527 NTAPI
4528 MmMapViewInSessionSpace(
4529   IN PVOID  Section,
4530   OUT PVOID  *MappedBase,
4531   IN OUT PSIZE_T  ViewSize);
4532
4533 NTKERNELAPI
4534 NTSTATUS
4535 NTAPI
4536 MmMapViewInSystemSpace(
4537   IN PVOID  Section,
4538   OUT PVOID  *MappedBase,
4539   IN PSIZE_T  ViewSize);
4540
4541 NTKERNELAPI
4542 NTSTATUS
4543 NTAPI
4544 MmMarkPhysicalMemoryAsBad(
4545   IN PPHYSICAL_ADDRESS  StartAddress,
4546   IN OUT PLARGE_INTEGER  NumberOfBytes);
4547
4548 NTKERNELAPI
4549 NTSTATUS
4550 NTAPI
4551 MmMarkPhysicalMemoryAsGood(
4552   IN PPHYSICAL_ADDRESS  StartAddress,
4553   IN OUT PLARGE_INTEGER  NumberOfBytes);
4554
4555 NTKERNELAPI
4556 PVOID
4557 NTAPI
4558 MmGetSystemRoutineAddress(
4559   IN PUNICODE_STRING  SystemRoutineName);
4560
4561 /*
4562  * ULONG
4563  * ADDRESS_AND_SIZE_TO_SPAN_PAGES(
4564  *   IN PVOID  Va,
4565  *   IN ULONG  Size)
4566  */
4567 #define ADDRESS_AND_SIZE_TO_SPAN_PAGES(_Va, \
4568                                        _Size) \
4569   ((ULONG) ((((ULONG_PTR) (_Va) & (PAGE_SIZE - 1)) \
4570     + (_Size) + (PAGE_SIZE - 1)) >> PAGE_SHIFT))
4571
4572 /*
4573  * VOID
4574  * MmInitializeMdl(
4575  *   IN PMDL  MemoryDescriptorList,
4576  *   IN PVOID  BaseVa,
4577  *   IN SIZE_T  Length)
4578  */
4579 #define MmInitializeMdl(_MemoryDescriptorList, \
4580                         _BaseVa, \
4581                         _Length) \
4582 { \
4583   (_MemoryDescriptorList)->Next = (PMDL) NULL; \
4584   (_MemoryDescriptorList)->Size = (CSHORT) (sizeof(MDL) + \
4585     (sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(_BaseVa, _Length))); \
4586   (_MemoryDescriptorList)->MdlFlags = 0; \
4587   (_MemoryDescriptorList)->StartVa = (PVOID) PAGE_ALIGN(_BaseVa); \
4588   (_MemoryDescriptorList)->ByteOffset = BYTE_OFFSET(_BaseVa); \
4589   (_MemoryDescriptorList)->ByteCount = (ULONG) _Length; \
4590 }
4591
4592 NTKERNELAPI
4593 BOOLEAN
4594 NTAPI
4595 MmIsAddressValid(
4596   IN PVOID  VirtualAddress);
4597
4598 NTKERNELAPI
4599 LOGICAL
4600 NTAPI
4601 MmIsDriverVerifying(
4602   IN PDRIVER_OBJECT  DriverObject);
4603
4604 NTKERNELAPI
4605 BOOLEAN
4606 NTAPI
4607 MmIsThisAnNtAsSystem(
4608   VOID);
4609
4610 NTKERNELAPI
4611 NTSTATUS
4612 NTAPI
4613 MmIsVerifierEnabled(
4614   OUT PULONG  VerifierFlags);
4615
4616 NTKERNELAPI
4617 PVOID
4618 NTAPI
4619 MmLockPagableDataSection(
4620   IN PVOID  AddressWithinSection);
4621
4622 NTKERNELAPI
4623 PVOID
4624 NTAPI
4625 MmLockPagableImageSection(
4626   IN PVOID  AddressWithinSection);
4627
4628 /*
4629  * PVOID
4630  * MmLockPagableCodeSection(
4631  *   IN PVOID  AddressWithinSection)
4632  */
4633 #define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address)
4634
4635 NTKERNELAPI
4636 VOID
4637 NTAPI
4638 MmLockPagableSectionByHandle(
4639   IN PVOID  ImageSectionHandle);
4640
4641 NTKERNELAPI
4642 PVOID
4643 NTAPI
4644 MmMapIoSpace(
4645   IN PHYSICAL_ADDRESS  PhysicalAddress,
4646   IN ULONG  NumberOfBytes,
4647   IN MEMORY_CACHING_TYPE  CacheEnable);
4648
4649 NTKERNELAPI
4650 PVOID
4651 NTAPI
4652 MmMapLockedPages(
4653   IN PMDL  MemoryDescriptorList,
4654   IN KPROCESSOR_MODE  AccessMode);
4655
4656 NTKERNELAPI
4657 PVOID
4658 NTAPI
4659 MmLockPageableDataSection (
4660     IN PVOID AddressWithinSection
4661 );
4662
4663 NTKERNELAPI
4664 VOID
4665 NTAPI
4666 MmUnlockPageableImageSection(
4667     IN PVOID ImageSectionHandle
4668 );
4669
4670 NTKERNELAPI
4671 PVOID
4672 NTAPI
4673 MmPageEntireDriver(
4674   IN PVOID  AddressWithinSection);
4675
4676 NTKERNELAPI
4677 VOID
4678 NTAPI
4679 MmProbeAndLockProcessPages(
4680   IN OUT PMDL  MemoryDescriptorList,
4681   IN PEPROCESS  Process,
4682   IN KPROCESSOR_MODE  AccessMode,
4683   IN LOCK_OPERATION  Operation);
4684
4685 NTKERNELAPI
4686 NTSTATUS
4687 NTAPI
4688 MmProtectMdlSystemAddress(
4689   IN PMDL  MemoryDescriptorList,
4690   IN ULONG  NewProtect);
4691
4692 NTKERNELAPI
4693 VOID
4694 NTAPI
4695 MmUnmapLockedPages(
4696   IN PVOID  BaseAddress,
4697   IN PMDL  MemoryDescriptorList);
4698
4699 NTKERNELAPI
4700 NTSTATUS
4701 NTAPI
4702 MmUnmapViewInSessionSpace(
4703   IN PVOID  MappedBase);
4704
4705 NTKERNELAPI
4706 NTSTATUS
4707 NTAPI
4708 MmUnmapViewInSystemSpace(
4709   IN PVOID MappedBase);
4710
4711 NTKERNELAPI
4712 VOID
4713 NTAPI
4714 MmUnsecureVirtualMemory(
4715   IN HANDLE  SecureHandle);
4716
4717 /*
4718  * VOID
4719  * MmPrepareMdlForReuse(
4720  *   IN PMDL  Mdl)
4721  */
4722 #define MmPrepareMdlForReuse(_Mdl) \
4723 { \
4724   if (((_Mdl)->MdlFlags & MDL_PARTIAL_HAS_BEEN_MAPPED) != 0) { \
4725     ASSERT(((_Mdl)->MdlFlags & MDL_PARTIAL) != 0); \
4726     MmUnmapLockedPages((_Mdl)->MappedSystemVa, (_Mdl)); \
4727   } else if (((_Mdl)->MdlFlags & MDL_PARTIAL) == 0) { \
4728     ASSERT(((_Mdl)->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA) == 0); \
4729   } \
4730 }
4731
4732 #define MmGetProcedureAddress(Address) (Address)
4733
4734 NTKERNELAPI
4735 VOID
4736 NTAPI
4737 MmProbeAndLockPages(
4738   IN OUT PMDL  MemoryDescriptorList,
4739   IN KPROCESSOR_MODE  AccessMode,
4740   IN LOCK_OPERATION  Operation);
4741
4742 NTKERNELAPI
4743 MM_SYSTEMSIZE
4744 NTAPI
4745 MmQuerySystemSize(
4746   VOID);
4747
4748 NTKERNELAPI
4749 NTSTATUS
4750 NTAPI
4751 MmRemovePhysicalMemory(
4752   IN PPHYSICAL_ADDRESS  StartAddress,
4753   IN OUT PLARGE_INTEGER  NumberOfBytes);
4754
4755 NTKERNELAPI
4756 VOID
4757 NTAPI
4758 MmResetDriverPaging(
4759   IN PVOID  AddressWithinSection);
4760
4761 NTKERNELAPI
4762 HANDLE
4763 NTAPI
4764 MmSecureVirtualMemory(
4765   IN PVOID  Address,
4766   IN SIZE_T  Size,
4767   IN ULONG  ProbeMode);
4768
4769 NTKERNELAPI
4770 SIZE_T
4771 NTAPI
4772 MmSizeOfMdl(
4773   IN PVOID  Base,
4774   IN SIZE_T  Length);
4775
4776 NTKERNELAPI
4777 VOID
4778 NTAPI
4779 MmUnlockPagableImageSection(
4780   IN PVOID  ImageSectionHandle);
4781
4782 NTKERNELAPI
4783 VOID
4784 NTAPI
4785 MmUnlockPages(
4786   IN PMDL  MemoryDescriptorList);
4787
4788 NTKERNELAPI
4789 VOID
4790 NTAPI
4791 MmUnmapIoSpace(
4792   IN PVOID  BaseAddress,
4793   IN SIZE_T  NumberOfBytes);
4794
4795 NTKERNELAPI
4796 VOID
4797 NTAPI
4798 MmUnmapReservedMapping(
4799   IN PVOID  BaseAddress,
4800   IN ULONG  PoolTag,
4801   IN PMDL  MemoryDescriptorList);
4802
4803 NTKERNELAPI
4804 VOID
4805 NTAPI
4806 MmUnmapVideoDisplay(
4807   IN PVOID  BaseAddress,
4808   IN SIZE_T  NumberOfBytes);
4809
4810
4811
4812 /** Object manager routines **/
4813
4814 NTKERNELAPI
4815 NTSTATUS
4816 NTAPI
4817 ObAssignSecurity(
4818   IN PACCESS_STATE  AccessState,
4819   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
4820   IN PVOID  Object,
4821   IN POBJECT_TYPE  Type);
4822
4823 NTKERNELAPI
4824 VOID
4825 NTAPI
4826 ObDereferenceSecurityDescriptor(
4827   PSECURITY_DESCRIPTOR  SecurityDescriptor,
4828   ULONG  Count);
4829
4830 NTKERNELAPI
4831 LONG_PTR
4832 FASTCALL
4833 ObfDereferenceObject(
4834   IN PVOID  Object);
4835
4836 /*
4837  * VOID
4838  * ObDereferenceObject(
4839  *   IN PVOID  Object)
4840  */
4841 #define ObDereferenceObject ObfDereferenceObject
4842
4843 NTKERNELAPI
4844 NTSTATUS
4845 NTAPI
4846 ObGetObjectSecurity(
4847   IN PVOID  Object,
4848   OUT PSECURITY_DESCRIPTOR  *SecurityDescriptor,
4849   OUT PBOOLEAN  MemoryAllocated);
4850
4851 NTKERNELAPI
4852 NTSTATUS
4853 NTAPI
4854 ObInsertObject(
4855   IN PVOID  Object,
4856   IN PACCESS_STATE  PassedAccessState  OPTIONAL,
4857   IN ACCESS_MASK  DesiredAccess,
4858   IN ULONG  AdditionalReferences,
4859   OUT PVOID*  ReferencedObject  OPTIONAL,
4860   OUT PHANDLE  Handle);
4861
4862 NTKERNELAPI
4863 LONG_PTR
4864 FASTCALL
4865 ObfReferenceObject(
4866   IN PVOID  Object);
4867
4868 NTKERNELAPI
4869 NTSTATUS
4870 NTAPI
4871 ObLogSecurityDescriptor(
4872   IN PSECURITY_DESCRIPTOR  InputSecurityDescriptor,
4873   OUT PSECURITY_DESCRIPTOR  *OutputSecurityDescriptor,
4874   IN ULONG RefBias);
4875 /*
4876  * VOID
4877  * ObReferenceObject(
4878  *   IN PVOID  Object)
4879  */
4880 #define ObReferenceObject ObfReferenceObject
4881
4882 NTKERNELAPI
4883 VOID
4884 NTAPI
4885 ObMakeTemporaryObject(
4886   IN PVOID  Object);
4887
4888 NTKERNELAPI
4889 NTSTATUS
4890 NTAPI
4891 ObOpenObjectByName(
4892   IN POBJECT_ATTRIBUTES  ObjectAttributes,
4893   IN POBJECT_TYPE  ObjectType,
4894   IN KPROCESSOR_MODE  AccessMode,
4895   IN PACCESS_STATE  PassedAccessState,
4896   IN ACCESS_MASK  DesiredAccess,
4897   IN OUT PVOID  ParseContext  OPTIONAL,
4898   OUT PHANDLE  Handle);
4899
4900 NTKERNELAPI
4901 NTSTATUS
4902 NTAPI
4903 ObOpenObjectByPointer(
4904   IN PVOID  Object,
4905   IN ULONG  HandleAttributes,
4906   IN PACCESS_STATE  PassedAccessState  OPTIONAL,
4907   IN ACCESS_MASK  DesiredAccess  OPTIONAL,
4908   IN POBJECT_TYPE  ObjectType  OPTIONAL,
4909   IN KPROCESSOR_MODE  AccessMode,
4910   OUT PHANDLE  Handle);
4911
4912 NTKERNELAPI
4913 NTSTATUS
4914 NTAPI
4915 ObQueryObjectAuditingByHandle(
4916   IN HANDLE  Handle,
4917   OUT PBOOLEAN  GenerateOnClose);
4918
4919 NTKERNELAPI
4920 NTSTATUS
4921 NTAPI
4922 ObReferenceObjectByHandle(
4923   IN HANDLE  Handle,
4924   IN ACCESS_MASK  DesiredAccess,
4925   IN POBJECT_TYPE  ObjectType  OPTIONAL,
4926   IN KPROCESSOR_MODE  AccessMode,
4927   OUT PVOID  *Object,
4928   OUT POBJECT_HANDLE_INFORMATION  HandleInformation  OPTIONAL);
4929
4930 NTKERNELAPI
4931 NTSTATUS
4932 NTAPI
4933 ObReferenceObjectByName(
4934   IN PUNICODE_STRING  ObjectPath,
4935   IN ULONG  Attributes,
4936   IN PACCESS_STATE  PassedAccessState  OPTIONAL,
4937   IN ACCESS_MASK  DesiredAccess  OPTIONAL,
4938   IN POBJECT_TYPE  ObjectType,
4939   IN KPROCESSOR_MODE  AccessMode,
4940   IN OUT PVOID  ParseContext  OPTIONAL,
4941   OUT PVOID  *Object);
4942
4943 NTKERNELAPI
4944 NTSTATUS
4945 NTAPI
4946 ObReferenceObjectByPointer(
4947   IN PVOID  Object,
4948   IN ACCESS_MASK  DesiredAccess,
4949   IN POBJECT_TYPE  ObjectType,
4950   IN KPROCESSOR_MODE  AccessMode);
4951
4952 NTKERNELAPI
4953 VOID
4954 NTAPI
4955 ObReferenceSecurityDescriptor(
4956   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
4957   IN ULONG  Count);
4958
4959 NTKERNELAPI
4960 VOID
4961 NTAPI
4962 ObReleaseObjectSecurity(
4963   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
4964   IN BOOLEAN  MemoryAllocated);
4965
4966
4967
4968 /** Process manager routines **/
4969
4970 NTKERNELAPI
4971 NTSTATUS
4972 NTAPI
4973 PsCreateSystemProcess(
4974   IN PHANDLE  ProcessHandle,
4975   IN ACCESS_MASK  DesiredAccess,
4976   IN POBJECT_ATTRIBUTES  ObjectAttributes);
4977
4978 NTKERNELAPI
4979 NTSTATUS
4980 NTAPI
4981 PsCreateSystemThread(
4982   OUT PHANDLE  ThreadHandle,
4983   IN ULONG  DesiredAccess,
4984   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
4985   IN HANDLE  ProcessHandle  OPTIONAL,
4986   OUT PCLIENT_ID  ClientId  OPTIONAL,
4987   IN PKSTART_ROUTINE  StartRoutine,
4988   IN PVOID  StartContext);
4989
4990 /*
4991  * PEPROCESS
4992  * PsGetCurrentProcess(VOID)
4993  */
4994 #define PsGetCurrentProcess IoGetCurrentProcess
4995
4996 NTKERNELAPI
4997 HANDLE
4998 NTAPI
4999 PsGetCurrentProcessId(
5000   VOID);
5001
5002 /*
5003  * PETHREAD
5004  * PsGetCurrentThread(VOID)
5005  */
5006 #define PsGetCurrentThread() \
5007   ((PETHREAD) KeGetCurrentThread())
5008
5009 NTKERNELAPI
5010 HANDLE
5011 NTAPI
5012 PsGetCurrentThreadId(
5013   VOID);
5014
5015 NTKERNELAPI
5016 HANDLE
5017 NTAPI
5018 PsGetProcessId(PEPROCESS Process);
5019
5020 NTKERNELAPI
5021 BOOLEAN
5022 NTAPI
5023 PsGetVersion(
5024   PULONG  MajorVersion  OPTIONAL,
5025   PULONG  MinorVersion  OPTIONAL,
5026   PULONG  BuildNumber  OPTIONAL,
5027   PUNICODE_STRING  CSDVersion  OPTIONAL);
5028
5029 NTKERNELAPI
5030 NTSTATUS
5031 NTAPI
5032 PsRemoveCreateThreadNotifyRoutine(
5033   IN PCREATE_THREAD_NOTIFY_ROUTINE  NotifyRoutine);
5034
5035 NTKERNELAPI
5036 NTSTATUS
5037 NTAPI
5038 PsRemoveLoadImageNotifyRoutine(
5039   IN PLOAD_IMAGE_NOTIFY_ROUTINE  NotifyRoutine);
5040
5041 NTKERNELAPI
5042 NTSTATUS
5043 NTAPI
5044 PsSetCreateProcessNotifyRoutine(
5045   IN PCREATE_PROCESS_NOTIFY_ROUTINE  NotifyRoutine,
5046   IN BOOLEAN  Remove);
5047
5048 NTKERNELAPI
5049 NTSTATUS
5050 NTAPI
5051 PsSetCreateThreadNotifyRoutine(
5052   IN PCREATE_THREAD_NOTIFY_ROUTINE  NotifyRoutine);
5053
5054 NTKERNELAPI
5055 NTSTATUS
5056 NTAPI
5057 PsSetLoadImageNotifyRoutine(
5058   IN PLOAD_IMAGE_NOTIFY_ROUTINE  NotifyRoutine);
5059
5060 NTKERNELAPI
5061 NTSTATUS
5062 NTAPI
5063 PsTerminateSystemThread(
5064   IN NTSTATUS  ExitStatus);
5065
5066 extern NTSYSAPI PEPROCESS PsInitialSystemProcess;
5067
5068
5069 /** Security reference monitor routines **/
5070
5071 NTKERNELAPI
5072 BOOLEAN
5073 NTAPI
5074 SeAccessCheck(
5075   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
5076   IN PSECURITY_SUBJECT_CONTEXT  SubjectSecurityContext,
5077   IN BOOLEAN  SubjectContextLocked,
5078   IN ACCESS_MASK  DesiredAccess,
5079   IN ACCESS_MASK  PreviouslyGrantedAccess,
5080   OUT PPRIVILEGE_SET  *Privileges  OPTIONAL,
5081   IN PGENERIC_MAPPING  GenericMapping,
5082   IN KPROCESSOR_MODE  AccessMode,
5083   OUT PACCESS_MASK  GrantedAccess,
5084   OUT PNTSTATUS  AccessStatus);
5085
5086 NTKERNELAPI
5087 NTSTATUS
5088 NTAPI
5089 SeAssignSecurity(
5090   IN PSECURITY_DESCRIPTOR  ParentDescriptor  OPTIONAL,
5091   IN PSECURITY_DESCRIPTOR  ExplicitDescriptor  OPTIONAL,
5092   OUT PSECURITY_DESCRIPTOR  *NewDescriptor,
5093   IN BOOLEAN  IsDirectoryObject,
5094   IN PSECURITY_SUBJECT_CONTEXT  SubjectContext,
5095   IN PGENERIC_MAPPING  GenericMapping,
5096   IN POOL_TYPE  PoolType);
5097
5098 NTKERNELAPI
5099 NTSTATUS
5100 NTAPI
5101 SeAssignSecurityEx(
5102   IN PSECURITY_DESCRIPTOR  ParentDescriptor  OPTIONAL,
5103   IN PSECURITY_DESCRIPTOR  ExplicitDescriptor  OPTIONAL,
5104   OUT PSECURITY_DESCRIPTOR  *NewDescriptor,
5105   IN GUID  *ObjectType  OPTIONAL,
5106   IN BOOLEAN  IsDirectoryObject,
5107   IN ULONG  AutoInheritFlags,
5108   IN PSECURITY_SUBJECT_CONTEXT  SubjectContext,
5109   IN PGENERIC_MAPPING  GenericMapping,
5110   IN POOL_TYPE  PoolType);
5111
5112 NTKERNELAPI
5113 NTSTATUS
5114 NTAPI
5115 SeDeassignSecurity(
5116   IN OUT PSECURITY_DESCRIPTOR  *SecurityDescriptor);
5117
5118 NTKERNELAPI
5119 BOOLEAN
5120 NTAPI
5121 SeSinglePrivilegeCheck(
5122   LUID  PrivilegeValue,
5123   KPROCESSOR_MODE  PreviousMode);
5124
5125 NTKERNELAPI
5126 BOOLEAN
5127 NTAPI
5128 SeValidSecurityDescriptor(
5129   IN ULONG  Length,
5130   IN PSECURITY_DESCRIPTOR  SecurityDescriptor);
5131
5132
5133
5134 /** NtXxx routines **/
5135
5136 NTSYSCALLAPI
5137 NTSTATUS
5138 NTAPI
5139 NtOpenProcess(
5140   OUT PHANDLE  ProcessHandle,
5141   IN ACCESS_MASK  DesiredAccess,
5142   IN POBJECT_ATTRIBUTES  ObjectAttributes,
5143   IN PCLIENT_ID  ClientId  OPTIONAL);
5144
5145 NTSYSCALLAPI
5146 NTSTATUS
5147 NTAPI
5148 NtQueryInformationProcess(
5149   IN HANDLE  ProcessHandle,
5150   IN PROCESSINFOCLASS  ProcessInformationClass,
5151   OUT PVOID  ProcessInformation,
5152   IN ULONG  ProcessInformationLength,
5153   OUT PULONG  ReturnLength OPTIONAL);
5154
5155
5156
5157 /** NtXxx and ZwXxx routines **/
5158
5159 NTSYSAPI
5160 NTSTATUS
5161 NTAPI
5162 ZwCancelTimer(
5163   IN HANDLE  TimerHandle,
5164   OUT PBOOLEAN  CurrentState  OPTIONAL);
5165
5166 NTSYSCALLAPI
5167 NTSTATUS
5168 NTAPI
5169 NtClose(
5170   IN HANDLE  Handle);
5171
5172 NTSYSAPI
5173 NTSTATUS
5174 NTAPI
5175 ZwClose(
5176   IN HANDLE  Handle);
5177
5178 NTSYSAPI
5179 NTSTATUS
5180 NTAPI
5181 ZwCreateDirectoryObject(
5182   OUT PHANDLE  DirectoryHandle,
5183   IN ACCESS_MASK  DesiredAccess,
5184   IN POBJECT_ATTRIBUTES  ObjectAttributes);
5185
5186 NTSYSCALLAPI
5187 NTSTATUS
5188 NTAPI
5189 NtCreateEvent(
5190   OUT PHANDLE  EventHandle,
5191   IN ACCESS_MASK  DesiredAccess,
5192   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
5193   IN EVENT_TYPE  EventType,
5194   IN BOOLEAN  InitialState);
5195
5196 NTSYSAPI
5197 NTSTATUS
5198 NTAPI
5199 ZwCreateEvent(
5200   OUT PHANDLE  EventHandle,
5201   IN ACCESS_MASK  DesiredAccess,
5202   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
5203   IN EVENT_TYPE  EventType,
5204   IN BOOLEAN  InitialState);
5205
5206 NTSYSAPI
5207 NTSTATUS
5208 NTAPI
5209 ZwCreateFile(
5210   OUT PHANDLE  FileHandle,
5211   IN ACCESS_MASK  DesiredAccess,
5212   IN POBJECT_ATTRIBUTES  ObjectAttributes,
5213   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5214   IN PLARGE_INTEGER  AllocationSize  OPTIONAL,
5215   IN ULONG  FileAttributes,
5216   IN ULONG  ShareAccess,
5217   IN ULONG  CreateDisposition,
5218   IN ULONG  CreateOptions,
5219   IN PVOID  EaBuffer  OPTIONAL,
5220   IN ULONG  EaLength);
5221
5222 NTSYSAPI
5223 NTSTATUS
5224 NTAPI
5225 ZwCreateKey(
5226   OUT PHANDLE  KeyHandle,
5227   IN ACCESS_MASK  DesiredAccess,
5228   IN POBJECT_ATTRIBUTES  ObjectAttributes,
5229   IN ULONG  TitleIndex,
5230   IN PUNICODE_STRING  Class  OPTIONAL,
5231   IN ULONG  CreateOptions,
5232   OUT PULONG  Disposition  OPTIONAL);
5233
5234 NTSYSAPI
5235 NTSTATUS
5236 NTAPI
5237 ZwCreateTimer(
5238   OUT PHANDLE  TimerHandle,
5239   IN ACCESS_MASK  DesiredAccess,
5240   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
5241   IN TIMER_TYPE  TimerType);
5242
5243 NTSYSAPI
5244 NTSTATUS
5245 NTAPI
5246 ZwDeleteKey(
5247   IN HANDLE  KeyHandle);
5248
5249 NTSYSAPI
5250 NTSTATUS
5251 NTAPI
5252 ZwDeleteValueKey(
5253   IN HANDLE  KeyHandle,
5254   IN PUNICODE_STRING  ValueName);
5255
5256 NTSYSCALLAPI
5257 NTSTATUS
5258 NTAPI
5259 NtDeviceIoControlFile(
5260   IN HANDLE  DeviceHandle,
5261   IN HANDLE  Event  OPTIONAL,
5262   IN PIO_APC_ROUTINE  UserApcRoutine  OPTIONAL,
5263   IN PVOID  UserApcContext  OPTIONAL,
5264   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5265   IN ULONG  IoControlCode,
5266   IN PVOID  InputBuffer,
5267   IN ULONG  InputBufferSize,
5268   OUT PVOID  OutputBuffer,
5269   IN ULONG  OutputBufferSize);
5270
5271 NTSYSAPI
5272 NTSTATUS
5273 NTAPI
5274 ZwDeviceIoControlFile(
5275   IN HANDLE  DeviceHandle,
5276   IN HANDLE  Event  OPTIONAL,
5277   IN PIO_APC_ROUTINE  UserApcRoutine  OPTIONAL,
5278   IN PVOID  UserApcContext  OPTIONAL,
5279   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5280   IN ULONG  IoControlCode,
5281   IN PVOID  InputBuffer,
5282   IN ULONG  InputBufferSize,
5283   OUT PVOID  OutputBuffer,
5284   IN ULONG  OutputBufferSize);
5285
5286 NTSYSAPI
5287 NTSTATUS
5288 NTAPI
5289 ZwEnumerateKey(
5290   IN HANDLE  KeyHandle,
5291   IN ULONG  Index,
5292   IN KEY_INFORMATION_CLASS  KeyInformationClass,
5293   OUT PVOID  KeyInformation,
5294   IN ULONG  Length,
5295   OUT PULONG  ResultLength);
5296
5297 NTSYSAPI
5298 NTSTATUS
5299 NTAPI
5300 ZwEnumerateValueKey(
5301   IN HANDLE  KeyHandle,
5302   IN ULONG  Index,
5303   IN KEY_VALUE_INFORMATION_CLASS  KeyValueInformationClass,
5304   OUT PVOID  KeyValueInformation,
5305   IN ULONG  Length,
5306   OUT PULONG  ResultLength);
5307
5308 NTSYSAPI
5309 NTSTATUS
5310 NTAPI
5311 ZwFlushKey(
5312   IN HANDLE  KeyHandle);
5313
5314 NTSYSAPI
5315 NTSTATUS
5316 NTAPI
5317 ZwMakeTemporaryObject(
5318   IN HANDLE  Handle);
5319
5320 NTSYSCALLAPI
5321 NTSTATUS
5322 NTAPI
5323 NtMapViewOfSection(
5324   IN HANDLE  SectionHandle,
5325   IN HANDLE  ProcessHandle,
5326   IN OUT PVOID  *BaseAddress,
5327   IN ULONG_PTR  ZeroBits,
5328   IN SIZE_T  CommitSize,
5329   IN OUT PLARGE_INTEGER  SectionOffset  OPTIONAL,
5330   IN OUT PSIZE_T  ViewSize,
5331   IN SECTION_INHERIT  InheritDisposition,
5332   IN ULONG  AllocationType,
5333   IN ULONG  Protect);
5334
5335 NTSYSAPI
5336 NTSTATUS
5337 NTAPI
5338 ZwMapViewOfSection(
5339   IN HANDLE  SectionHandle,
5340   IN HANDLE  ProcessHandle,
5341   IN OUT PVOID  *BaseAddress,
5342   IN ULONG_PTR  ZeroBits,
5343   IN SIZE_T  CommitSize,
5344   IN OUT PLARGE_INTEGER  SectionOffset  OPTIONAL,
5345   IN OUT PSIZE_T  ViewSize,
5346   IN SECTION_INHERIT  InheritDisposition,
5347   IN ULONG  AllocationType,
5348   IN ULONG  Protect);
5349
5350 NTSYSCALLAPI
5351 NTSTATUS
5352 NTAPI
5353 NtOpenFile(
5354   OUT PHANDLE  FileHandle,
5355   IN ACCESS_MASK  DesiredAccess,
5356   IN POBJECT_ATTRIBUTES  ObjectAttributes,
5357   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5358   IN ULONG  ShareAccess,
5359   IN ULONG  OpenOptions);
5360
5361 NTSYSAPI
5362 NTSTATUS
5363 NTAPI
5364 ZwOpenFile(
5365   OUT PHANDLE  FileHandle,
5366   IN ACCESS_MASK  DesiredAccess,
5367   IN POBJECT_ATTRIBUTES  ObjectAttributes,
5368   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5369   IN ULONG  ShareAccess,
5370   IN ULONG  OpenOptions);
5371
5372 NTSYSAPI
5373 NTSTATUS
5374 NTAPI
5375 ZwOpenKey(
5376   OUT PHANDLE  KeyHandle,
5377   IN ACCESS_MASK  DesiredAccess,
5378   IN POBJECT_ATTRIBUTES  ObjectAttributes);
5379
5380 NTSYSAPI
5381 NTSTATUS
5382 NTAPI
5383 ZwOpenSection(
5384   OUT PHANDLE  SectionHandle,
5385   IN ACCESS_MASK  DesiredAccess,
5386   IN POBJECT_ATTRIBUTES  ObjectAttributes);
5387
5388 NTSYSAPI
5389 NTSTATUS
5390 NTAPI
5391 ZwOpenSymbolicLinkObject(
5392   OUT PHANDLE  LinkHandle,
5393   IN ACCESS_MASK  DesiredAccess,
5394   IN POBJECT_ATTRIBUTES  ObjectAttributes);
5395
5396 NTSYSAPI
5397 NTSTATUS
5398 NTAPI
5399 ZwOpenTimer(
5400   OUT PHANDLE  TimerHandle,
5401   IN ACCESS_MASK  DesiredAccess,
5402   IN POBJECT_ATTRIBUTES  ObjectAttributes);
5403
5404 NTSYSAPI
5405 NTSTATUS
5406 NTAPI
5407 ZwQueryInformationFile(
5408   IN HANDLE  FileHandle,
5409   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5410   OUT PVOID  FileInformation,
5411   IN ULONG  Length,
5412   IN FILE_INFORMATION_CLASS  FileInformationClass);
5413
5414 NTSYSAPI
5415 NTSTATUS
5416 NTAPI
5417 ZwQueryKey(
5418   IN HANDLE  KeyHandle,
5419   IN KEY_INFORMATION_CLASS  KeyInformationClass,
5420   OUT PVOID  KeyInformation,
5421   IN ULONG  Length,
5422   OUT PULONG  ResultLength);
5423
5424 NTSYSAPI
5425 NTSTATUS
5426 NTAPI
5427 ZwQuerySymbolicLinkObject(
5428   IN HANDLE  LinkHandle,
5429   IN OUT PUNICODE_STRING  LinkTarget,
5430   OUT PULONG  ReturnedLength  OPTIONAL);
5431
5432 NTSYSAPI
5433 NTSTATUS
5434 NTAPI
5435 ZwQueryValueKey(
5436   IN HANDLE  KeyHandle,
5437   IN PUNICODE_STRING  ValueName,
5438   IN KEY_VALUE_INFORMATION_CLASS  KeyValueInformationClass,
5439   OUT PVOID  KeyValueInformation,
5440   IN ULONG  Length,
5441   OUT PULONG  ResultLength);
5442
5443 NTSYSCALLAPI
5444 NTSTATUS
5445 NTAPI
5446 NtReadFile(
5447   IN HANDLE  FileHandle,
5448   IN HANDLE  Event  OPTIONAL,
5449   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
5450   IN PVOID  ApcContext  OPTIONAL,
5451   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5452   OUT PVOID  Buffer,
5453   IN ULONG  Length,
5454   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
5455   IN PULONG  Key  OPTIONAL);
5456
5457 NTSYSAPI
5458 NTSTATUS
5459 NTAPI
5460 ZwReadFile(
5461   IN HANDLE  FileHandle,
5462   IN HANDLE  Event  OPTIONAL,
5463   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
5464   IN PVOID  ApcContext  OPTIONAL,
5465   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5466   OUT PVOID  Buffer,
5467   IN ULONG  Length,
5468   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
5469   IN PULONG  Key  OPTIONAL);
5470
5471 NTSYSCALLAPI
5472 NTSTATUS
5473 NTAPI
5474 NtSetEvent(
5475   IN HANDLE  EventHandle,
5476   OUT PLONG  PreviousState  OPTIONAL);
5477
5478 NTSYSAPI
5479 NTSTATUS
5480 NTAPI
5481 ZwSetEvent(
5482   IN HANDLE  EventHandle,
5483   OUT PLONG  PreviousState  OPTIONAL);
5484
5485 NTSYSAPI
5486 NTSTATUS
5487 NTAPI
5488 ZwSetInformationFile(
5489   IN HANDLE  FileHandle,
5490   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5491   IN PVOID  FileInformation,
5492   IN ULONG  Length,
5493   IN FILE_INFORMATION_CLASS  FileInformationClass);
5494
5495 NTSYSAPI
5496 NTSTATUS
5497 NTAPI
5498 ZwSetInformationThread(
5499   IN HANDLE  ThreadHandle,
5500   IN THREADINFOCLASS  ThreadInformationClass,
5501   IN PVOID  ThreadInformation,
5502   IN ULONG  ThreadInformationLength);
5503
5504 NTSYSAPI
5505 NTSTATUS
5506 NTAPI
5507 ZwSetTimer(
5508   IN HANDLE  TimerHandle,
5509   IN PLARGE_INTEGER  DueTime,
5510   IN PTIMER_APC_ROUTINE  TimerApcRoutine  OPTIONAL,
5511   IN PVOID  TimerContext  OPTIONAL,
5512   IN BOOLEAN  WakeTimer,
5513   IN LONG  Period  OPTIONAL,
5514   OUT PBOOLEAN  PreviousState  OPTIONAL);
5515
5516 NTSYSAPI
5517 NTSTATUS
5518 NTAPI
5519 ZwSetValueKey(
5520   IN HANDLE  KeyHandle,
5521   IN PUNICODE_STRING  ValueName,
5522   IN ULONG  TitleIndex  OPTIONAL,
5523   IN ULONG  Type,
5524   IN PVOID  Data,
5525   IN ULONG  DataSize);
5526
5527 /* [Nt|Zw]MapViewOfSection.InheritDisposition constants */
5528 #define AT_EXTENDABLE_FILE                0x00002000
5529 #define AT_RESERVED                       0x20000000
5530 #define AT_ROUND_TO_PAGE                  0x40000000
5531
5532 NTSYSCALLAPI
5533 NTSTATUS
5534 NTAPI
5535 NtUnmapViewOfSection(
5536   IN HANDLE  ProcessHandle,
5537   IN PVOID  BaseAddress);
5538
5539 NTSYSAPI
5540 NTSTATUS
5541 NTAPI
5542 ZwUnmapViewOfSection(
5543   IN HANDLE  ProcessHandle,
5544   IN PVOID  BaseAddress);
5545
5546 NTSYSCALLAPI
5547 NTSTATUS
5548 NTAPI
5549 NtWaitForSingleObject(
5550   IN HANDLE  ObjectHandle,
5551   IN BOOLEAN  Alertable,
5552   IN PLARGE_INTEGER  TimeOut  OPTIONAL);
5553
5554 NTSYSAPI
5555 NTSTATUS
5556 NTAPI
5557 ZwWaitForSingleObject(
5558   IN HANDLE  ObjectHandle,
5559   IN BOOLEAN  Alertable,
5560   IN PLARGE_INTEGER  TimeOut  OPTIONAL);
5561
5562 NTSYSCALLAPI
5563 NTSTATUS
5564 NTAPI
5565 NtWriteFile(
5566   IN HANDLE  FileHandle,
5567   IN HANDLE  Event  OPTIONAL,
5568   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
5569   IN PVOID  ApcContext  OPTIONAL,
5570   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5571   IN PVOID  Buffer,
5572   IN ULONG  Length,
5573   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
5574   IN PULONG  Key  OPTIONAL);
5575
5576 NTSYSAPI
5577 NTSTATUS
5578 NTAPI
5579 ZwWriteFile(
5580   IN HANDLE  FileHandle,
5581   IN HANDLE  Event  OPTIONAL,
5582   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
5583   IN PVOID  ApcContext  OPTIONAL,
5584   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5585   IN PVOID  Buffer,
5586   IN ULONG  Length,
5587   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
5588   IN PULONG  Key  OPTIONAL);
5589
5590
5591
5592 /** Power management support routines **/
5593
5594 NTKERNELAPI
5595 NTSTATUS
5596 NTAPI
5597 PoCallDriver(
5598   IN PDEVICE_OBJECT  DeviceObject,
5599   IN OUT PIRP  Irp);
5600
5601 NTKERNELAPI
5602 PULONG
5603 NTAPI
5604 PoRegisterDeviceForIdleDetection(
5605   IN PDEVICE_OBJECT  DeviceObject,
5606   IN ULONG  ConservationIdleTime,
5607   IN ULONG  PerformanceIdleTime,
5608   IN DEVICE_POWER_STATE  State);
5609
5610 NTKERNELAPI
5611 PVOID
5612 NTAPI
5613 PoRegisterSystemState(
5614   IN PVOID  StateHandle,
5615   IN EXECUTION_STATE  Flags);
5616
5617 NTKERNELAPI
5618 NTSTATUS
5619 NTAPI
5620 PoRequestPowerIrp(
5621   IN PDEVICE_OBJECT  DeviceObject,
5622   IN UCHAR  MinorFunction,
5623   IN POWER_STATE  PowerState,
5624   IN PREQUEST_POWER_COMPLETE  CompletionFunction,
5625   IN PVOID  Context,
5626   OUT PIRP  *Irp OPTIONAL);
5627
5628 NTKERNELAPI
5629 NTSTATUS
5630 NTAPI
5631 PoRequestShutdownEvent(
5632   OUT PVOID  *Event);
5633
5634 NTKERNELAPI
5635 VOID
5636 NTAPI
5637 PoSetDeviceBusy(
5638   PULONG  IdlePointer);
5639
5640 #define PoSetDeviceBusy(IdlePointer) \
5641  ((void)(*(IdlePointer) = 0))
5642
5643 NTKERNELAPI
5644 POWER_STATE
5645 NTAPI
5646 PoSetPowerState(
5647   IN PDEVICE_OBJECT  DeviceObject,
5648   IN POWER_STATE_TYPE  Type,
5649   IN POWER_STATE  State);
5650
5651 NTKERNELAPI
5652 VOID
5653 NTAPI
5654 PoSetSystemState(
5655   IN EXECUTION_STATE  Flags);
5656
5657 NTKERNELAPI
5658 VOID
5659 NTAPI
5660 PoStartNextPowerIrp(
5661   IN PIRP  Irp);
5662
5663 NTKERNELAPI
5664 VOID
5665 NTAPI
5666 PoUnregisterSystemState(
5667   IN PVOID  StateHandle);
5668
5669
5670
5671 /** WMI library support routines **/
5672
5673 NTSTATUS
5674 NTAPI
5675 WmiCompleteRequest(
5676   IN PDEVICE_OBJECT  DeviceObject,
5677   IN PIRP  Irp,
5678   IN NTSTATUS  Status,
5679   IN ULONG  BufferUsed,
5680   IN CCHAR  PriorityBoost);
5681
5682 NTSTATUS
5683 NTAPI
5684 WmiFireEvent(
5685   IN PDEVICE_OBJECT  DeviceObject,
5686   IN LPGUID  Guid,
5687   IN ULONG  InstanceIndex,
5688   IN ULONG  EventDataSize,
5689   IN PVOID  EventData);
5690
5691 NTKERNELAPI
5692 NTSTATUS
5693 NTAPI
5694 WmiQueryTraceInformation(
5695   IN TRACE_INFORMATION_CLASS  TraceInformationClass,
5696   OUT PVOID  TraceInformation,
5697   IN ULONG  TraceInformationLength,
5698   OUT PULONG  RequiredLength OPTIONAL,
5699   IN PVOID  Buffer OPTIONAL);
5700
5701 NTSTATUS
5702 NTAPI
5703 WmiSystemControl(
5704   IN PWMILIB_CONTEXT  WmiLibInfo,
5705   IN PDEVICE_OBJECT  DeviceObject,
5706   IN PIRP  Irp,
5707   OUT PSYSCTL_IRP_DISPOSITION  IrpDisposition);
5708
5709 NTKERNELAPI
5710 NTSTATUS
5711 DDKCDECLAPI
5712 WmiTraceMessage(
5713   IN TRACEHANDLE  LoggerHandle,
5714   IN ULONG  MessageFlags,
5715   IN LPGUID  MessageGuid,
5716   IN USHORT  MessageNumber,
5717   IN ...);
5718
5719 #if 0
5720 /* FIXME: Get va_list from where? */
5721 NTKERNELAPI
5722 NTSTATUS
5723 DDKCDECLAPI
5724 WmiTraceMessageVa(
5725   IN TRACEHANDLE  LoggerHandle,
5726   IN ULONG  MessageFlags,
5727   IN LPGUID  MessageGuid,
5728   IN USHORT  MessageNumber,
5729   IN va_list  MessageArgList);
5730 #endif
5731
5732
5733 /** Kernel debugger routines **/
5734
5735 NTKERNELAPI
5736 NTSTATUS
5737 NTAPI
5738 KdDisableDebugger(
5739   VOID);
5740
5741 NTKERNELAPI
5742 NTSTATUS
5743 NTAPI
5744 KdEnableDebugger(
5745   VOID);
5746
5747 NTKERNELAPI
5748 BOOLEAN
5749 NTAPI
5750 KdRefreshDebuggerNotPresent(
5751     VOID
5752 );
5753
5754 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
5755 NTKERNELAPI
5756 NTSTATUS
5757 NTAPI
5758 KdChangeOption(
5759   IN KD_OPTION Option,
5760   IN ULONG InBufferBytes OPTIONAL,
5761   IN PVOID InBuffer,
5762   IN ULONG OutBufferBytes OPTIONAL,
5763   OUT PVOID OutBuffer,
5764   OUT PULONG OutBufferNeeded OPTIONAL);
5765 #endif
5766
5767 VOID
5768 NTAPI
5769 DbgBreakPoint(
5770   VOID);
5771
5772 NTSYSAPI
5773 VOID
5774 NTAPI
5775 DbgBreakPointWithStatus(
5776   IN ULONG  Status);
5777
5778 ULONG
5779 DDKCDECLAPI
5780 DbgPrint(
5781   IN PCCH  Format,
5782   IN ...);
5783
5784 NTSYSAPI
5785 ULONG
5786 DDKCDECLAPI
5787 DbgPrintEx(
5788   IN ULONG  ComponentId,
5789   IN ULONG  Level,
5790   IN PCCH  Format,
5791   IN ...);
5792
5793 ULONG
5794 NTAPI
5795 vDbgPrintEx(
5796   IN ULONG ComponentId,
5797   IN ULONG Level,
5798   IN PCCH Format,
5799   IN va_list ap);
5800
5801 ULONG
5802 NTAPI
5803 vDbgPrintExWithPrefix(
5804   IN PCCH Prefix,
5805   IN ULONG ComponentId,
5806   IN ULONG Level,
5807   IN PCCH Format,
5808   IN va_list ap);
5809
5810 NTKERNELAPI
5811 ULONG
5812 DDKCDECLAPI
5813 DbgPrintReturnControlC(
5814   IN PCCH  Format,
5815   IN ...);
5816
5817 ULONG
5818 NTAPI
5819 DbgPrompt(
5820     IN PCCH Prompt,
5821     OUT PCH Response,
5822     IN ULONG MaximumResponseLength
5823 );
5824
5825 NTKERNELAPI
5826 NTSTATUS
5827 NTAPI
5828 DbgQueryDebugFilterState(
5829   IN ULONG  ComponentId,
5830   IN ULONG  Level);
5831
5832 NTKERNELAPI
5833 NTSTATUS
5834 NTAPI
5835 DbgSetDebugFilterState(
5836   IN ULONG  ComponentId,
5837   IN ULONG  Level,
5838   IN BOOLEAN  State);
5839
5840 #if DBG
5841
5842 #define KdPrint(_x_) DbgPrint _x_
5843 #define KdPrintEx(_x_) DbgPrintEx _x_
5844 #define KdBreakPoint() DbgBreakPoint()
5845 #define KdBreakPointWithStatus(s) DbgBreakPointWithStatus(s)
5846
5847 #else /* !DBG */
5848
5849 #define KdPrint(_x_)
5850 #define KdPrintEx(_x_)
5851 #define KdBreakPoint()
5852 #define KdBreakPointWithStatus(s)
5853
5854 #endif /* !DBG */
5855
5856 #if defined(__GNUC__)
5857
5858 extern NTKERNELAPI BOOLEAN KdDebuggerNotPresent;
5859 extern NTKERNELAPI BOOLEAN KdDebuggerEnabled;
5860 #define KD_DEBUGGER_ENABLED     KdDebuggerEnabled
5861 #define KD_DEBUGGER_NOT_PRESENT KdDebuggerNotPresent
5862
5863 #elif defined(_NTDDK_) || defined(_NTHAL_) || defined(_WDMDDK_) || defined(_NTOSP_)
5864
5865 extern NTKERNELAPI PBOOLEAN KdDebuggerNotPresent;
5866 extern NTKERNELAPI PBOOLEAN KdDebuggerEnabled;
5867 #define KD_DEBUGGER_ENABLED     *KdDebuggerEnabled
5868 #define KD_DEBUGGER_NOT_PRESENT *KdDebuggerNotPresent
5869
5870 #else
5871
5872 extern BOOLEAN KdDebuggerNotPresent;
5873 extern BOOLEAN KdDebuggerEnabled;
5874 #define KD_DEBUGGER_ENABLED     KdDebuggerEnabled
5875 #define KD_DEBUGGER_NOT_PRESENT KdDebuggerNotPresent
5876
5877 #endif
5878
5879 /** Stuff from winnt4.h */
5880
5881 #ifndef DMA_MACROS_DEFINED
5882
5883 #if (NTDDI_VERSION >= NTDDI_WIN2K)
5884
5885 //DECLSPEC_DEPRECATED_DDK
5886 NTHALAPI
5887 BOOLEAN
5888 NTAPI
5889 IoFlushAdapterBuffers(
5890     IN PADAPTER_OBJECT AdapterObject,
5891     IN PMDL Mdl,
5892     IN PVOID MapRegisterBase,
5893     IN PVOID CurrentVa,
5894     IN ULONG Length,
5895     IN BOOLEAN WriteToDevice);
5896
5897 //DECLSPEC_DEPRECATED_DDK
5898 NTHALAPI
5899 VOID
5900 NTAPI
5901 IoFreeAdapterChannel(
5902     IN PADAPTER_OBJECT AdapterObject);
5903
5904 //DECLSPEC_DEPRECATED_DDK
5905 NTHALAPI
5906 VOID
5907 NTAPI
5908 IoFreeMapRegisters(
5909     IN PADAPTER_OBJECT AdapterObject,
5910     IN PVOID MapRegisterBase,
5911     IN ULONG NumberOfMapRegisters);
5912
5913 //DECLSPEC_DEPRECATED_DDK
5914 NTHALAPI
5915 PHYSICAL_ADDRESS
5916 NTAPI
5917 IoMapTransfer(
5918     IN PADAPTER_OBJECT AdapterObject,
5919     IN PMDL Mdl,
5920     IN PVOID MapRegisterBase,
5921     IN PVOID CurrentVa,
5922     IN OUT PULONG Length,
5923     IN BOOLEAN WriteToDevice);
5924
5925
5926 #endif // (NTDDI_VERSION >= NTDDI_WIN2K)
5927 #endif // !defined(DMA_MACROS_DEFINED)
5928
5929 NTKERNELAPI
5930 NTSTATUS
5931 NTAPI
5932 IoAssignResources(
5933   IN PUNICODE_STRING  RegistryPath,
5934   IN PUNICODE_STRING  DriverClassName  OPTIONAL,
5935   IN PDRIVER_OBJECT  DriverObject,
5936   IN PDEVICE_OBJECT  DeviceObject  OPTIONAL,
5937   IN PIO_RESOURCE_REQUIREMENTS_LIST  RequestedResources,
5938   IN OUT PCM_RESOURCE_LIST  *AllocatedResources);
5939
5940 NTKERNELAPI
5941 NTSTATUS
5942 NTAPI
5943 IoAttachDeviceByPointer(
5944   IN PDEVICE_OBJECT  SourceDevice,
5945   IN PDEVICE_OBJECT  TargetDevice);
5946
5947 NTKERNELAPI
5948 BOOLEAN
5949 NTAPI
5950 MmIsNonPagedSystemAddressValid(
5951   IN PVOID  VirtualAddress);
5952
5953 #if defined(_AMD64_) || defined(_IA64_)
5954 //DECLSPEC_DEPRECATED_DDK_WINXP
5955 static __inline
5956 LARGE_INTEGER
5957 NTAPI_INLINE
5958 RtlLargeIntegerDivide(
5959     IN LARGE_INTEGER Dividend,
5960     IN LARGE_INTEGER Divisor,
5961     IN OUT PLARGE_INTEGER Remainder)
5962 {
5963     LARGE_INTEGER ret;
5964     ret.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
5965     if (Remainder)
5966         Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
5967     return ret;
5968 }
5969 #else
5970 NTSYSAPI
5971 LARGE_INTEGER
5972 NTAPI
5973 RtlLargeIntegerDivide(
5974   IN LARGE_INTEGER  Dividend,
5975   IN LARGE_INTEGER  Divisor,
5976   IN OUT PLARGE_INTEGER  Remainder);
5977 #endif
5978
5979 NTKERNELAPI
5980 INTERLOCKED_RESULT
5981 NTAPI
5982 ExInterlockedDecrementLong(
5983   IN PLONG  Addend,
5984   IN PKSPIN_LOCK  Lock);
5985
5986 NTKERNELAPI
5987 ULONG
5988 NTAPI
5989 ExInterlockedExchangeUlong(
5990   IN PULONG  Target,
5991   IN ULONG  Value,
5992   IN PKSPIN_LOCK  Lock);
5993
5994 NTKERNELAPI
5995 INTERLOCKED_RESULT
5996 NTAPI
5997 ExInterlockedIncrementLong(
5998   IN PLONG  Addend,
5999   IN PKSPIN_LOCK  Lock);
6000
6001 NTHALAPI
6002 VOID
6003 NTAPI
6004 HalAcquireDisplayOwnership(
6005   IN PHAL_RESET_DISPLAY_PARAMETERS  ResetDisplayParameters);
6006
6007 NTHALAPI
6008 NTSTATUS
6009 NTAPI
6010 HalAllocateAdapterChannel(
6011   IN PADAPTER_OBJECT  AdapterObject,
6012   IN PWAIT_CONTEXT_BLOCK  Wcb,
6013   IN ULONG  NumberOfMapRegisters,
6014   IN PDRIVER_CONTROL  ExecutionRoutine);
6015
6016 NTHALAPI
6017 PVOID
6018 NTAPI
6019 HalAllocateCommonBuffer(
6020   IN PADAPTER_OBJECT  AdapterObject,
6021   IN ULONG  Length,
6022   OUT PPHYSICAL_ADDRESS  LogicalAddress,
6023   IN BOOLEAN  CacheEnabled);
6024
6025 NTHALAPI
6026 NTSTATUS
6027 NTAPI
6028 HalAssignSlotResources(
6029   IN PUNICODE_STRING  RegistryPath,
6030   IN PUNICODE_STRING  DriverClassName,
6031   IN PDRIVER_OBJECT  DriverObject,
6032   IN PDEVICE_OBJECT  DeviceObject,
6033   IN INTERFACE_TYPE  BusType,
6034   IN ULONG  BusNumber,
6035   IN ULONG  SlotNumber,
6036   IN OUT PCM_RESOURCE_LIST  *AllocatedResources);
6037
6038 NTHALAPI
6039 VOID
6040 NTAPI
6041 HalFreeCommonBuffer(
6042   IN PADAPTER_OBJECT  AdapterObject,
6043   IN ULONG  Length,
6044   IN PHYSICAL_ADDRESS  LogicalAddress,
6045   IN PVOID  VirtualAddress,
6046   IN BOOLEAN  CacheEnabled);
6047
6048 NTHALAPI
6049 PADAPTER_OBJECT
6050 NTAPI
6051 HalGetAdapter(
6052   IN PDEVICE_DESCRIPTION  DeviceDescription,
6053   IN OUT PULONG  NumberOfMapRegisters);
6054
6055 NTHALAPI
6056 ULONG
6057 NTAPI
6058 HalGetBusData(
6059   IN BUS_DATA_TYPE  BusDataType,
6060   IN ULONG  BusNumber,
6061   IN ULONG  SlotNumber,
6062   IN PVOID  Buffer,
6063   IN ULONG  Length);
6064
6065 NTHALAPI
6066 ULONG
6067 NTAPI
6068 HalGetBusDataByOffset(
6069   IN BUS_DATA_TYPE  BusDataType,
6070   IN ULONG  BusNumber,
6071   IN ULONG  SlotNumber,
6072   IN PVOID  Buffer,
6073   IN ULONG  Offset,
6074   IN ULONG  Length);
6075
6076 NTHALAPI
6077 ULONG
6078 NTAPI
6079 HalGetDmaAlignmentRequirement(
6080   VOID);
6081
6082 NTHALAPI
6083 ULONG
6084 NTAPI
6085 HalGetInterruptVector(
6086   IN INTERFACE_TYPE  InterfaceType,
6087   IN ULONG  BusNumber,
6088   IN ULONG  BusInterruptLevel,
6089   IN ULONG  BusInterruptVector,
6090   OUT PKIRQL  Irql,
6091   OUT PKAFFINITY  Affinity);
6092
6093 NTHALAPI
6094 ULONG
6095 NTAPI
6096 HalReadDmaCounter(
6097   IN PADAPTER_OBJECT  AdapterObject);
6098
6099 NTHALAPI
6100 ULONG
6101 NTAPI
6102 HalSetBusData(
6103   IN BUS_DATA_TYPE  BusDataType,
6104   IN ULONG  BusNumber,
6105   IN ULONG  SlotNumber,
6106   IN PVOID  Buffer,
6107   IN ULONG  Length);
6108
6109 NTHALAPI
6110 ULONG
6111 NTAPI
6112 HalSetBusDataByOffset(
6113   IN BUS_DATA_TYPE  BusDataType,
6114   IN ULONG  BusNumber,
6115   IN ULONG  SlotNumber,
6116   IN PVOID  Buffer,
6117   IN ULONG  Offset,
6118   IN ULONG  Length);
6119
6120 NTHALAPI
6121 BOOLEAN
6122 NTAPI
6123 HalTranslateBusAddress(
6124   IN INTERFACE_TYPE  InterfaceType,
6125   IN ULONG  BusNumber,
6126   IN PHYSICAL_ADDRESS  BusAddress,
6127   IN OUT PULONG  AddressSpace,
6128   OUT PPHYSICAL_ADDRESS  TranslatedAddress);
6129
6130 NTSYSAPI
6131 BOOLEAN
6132 NTAPI
6133 RtlLargeIntegerEqualToZero(
6134   IN LARGE_INTEGER  Operand);
6135
6136 NTSYSAPI
6137 BOOLEAN
6138 NTAPI
6139 RtlLargeIntegerGreaterOrEqualToZero(
6140   IN LARGE_INTEGER  Operand);
6141
6142 NTSYSAPI
6143 BOOLEAN
6144 NTAPI
6145 RtlLargeIntegerGreaterThan(
6146   IN LARGE_INTEGER  Operand1,
6147   IN LARGE_INTEGER  Operand2);
6148
6149 NTSYSAPI
6150 BOOLEAN
6151 NTAPI
6152 RtlLargeIntegerGreaterThanOrEqualTo(
6153   IN LARGE_INTEGER  Operand1,
6154   IN LARGE_INTEGER  Operand2);
6155
6156 NTSYSAPI
6157 BOOLEAN
6158 NTAPI
6159 RtlLargeIntegerGreaterThanZero(
6160   IN LARGE_INTEGER  Operand);
6161
6162 NTSYSAPI
6163 BOOLEAN
6164 NTAPI
6165 RtlLargeIntegerLessOrEqualToZero(
6166   IN LARGE_INTEGER  Operand);
6167
6168 NTSYSAPI
6169 BOOLEAN
6170 NTAPI
6171 RtlLargeIntegerLessThan(
6172   IN LARGE_INTEGER  Operand1,
6173   IN LARGE_INTEGER  Operand2);
6174
6175 NTSYSAPI
6176 BOOLEAN
6177 NTAPI
6178 RtlLargeIntegerLessThanOrEqualTo(
6179   IN LARGE_INTEGER  Operand1,
6180   IN LARGE_INTEGER  Operand2);
6181
6182 NTSYSAPI
6183 BOOLEAN
6184 NTAPI
6185 RtlLargeIntegerLessThanZero(
6186   IN LARGE_INTEGER  Operand);
6187
6188 NTSYSAPI
6189 LARGE_INTEGER
6190 NTAPI
6191 RtlLargeIntegerNegate(
6192   IN LARGE_INTEGER  Subtrahend);
6193
6194 NTSYSAPI
6195 BOOLEAN
6196 NTAPI
6197 RtlLargeIntegerNotEqualTo(
6198   IN LARGE_INTEGER  Operand1,
6199   IN LARGE_INTEGER  Operand2);
6200
6201 NTSYSAPI
6202 BOOLEAN
6203 NTAPI
6204 RtlLargeIntegerNotEqualToZero(
6205   IN LARGE_INTEGER  Operand);
6206
6207 NTSYSAPI
6208 LARGE_INTEGER
6209 NTAPI
6210 RtlLargeIntegerShiftLeft(
6211   IN LARGE_INTEGER  LargeInteger,
6212   IN CCHAR  ShiftCount);
6213
6214 NTSYSAPI
6215 LARGE_INTEGER
6216 NTAPI
6217 RtlLargeIntegerShiftRight(
6218   IN LARGE_INTEGER  LargeInteger,
6219   IN CCHAR  ShiftCount);
6220
6221 NTSYSAPI
6222 LARGE_INTEGER
6223 NTAPI
6224 RtlLargeIntegerSubtract(
6225   IN LARGE_INTEGER  Minuend,
6226   IN LARGE_INTEGER  Subtrahend);
6227
6228
6229 /*
6230  * ULONG
6231  * COMPUTE_PAGES_SPANNED(
6232  *   IN PVOID  Va,
6233  *   IN ULONG  Size)
6234  */
6235 #define COMPUTE_PAGES_SPANNED(Va, \
6236                               Size) \
6237   (ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va, Size))
6238
6239
6240 /*
6241 ** Architecture specific structures
6242 */
6243
6244 #ifdef _X86_
6245
6246 NTKERNELAPI
6247 INTERLOCKED_RESULT
6248 FASTCALL
6249 Exfi386InterlockedIncrementLong(
6250   IN PLONG  Addend);
6251
6252 NTKERNELAPI
6253 INTERLOCKED_RESULT
6254 FASTCALL
6255 Exfi386InterlockedDecrementLong(
6256   IN PLONG  Addend);
6257
6258 NTKERNELAPI
6259 ULONG
6260 FASTCALL
6261 Exfi386InterlockedExchangeUlong(
6262   IN PULONG  Target,
6263   IN ULONG  Value);
6264
6265 #define ExInterlockedIncrementLong(Addend,Lock) Exfi386InterlockedIncrementLong(Addend)
6266 #define ExInterlockedDecrementLong(Addend,Lock) Exfi386InterlockedDecrementLong(Addend)
6267 #define ExInterlockedExchangeUlong(Target, Value, Lock) Exfi386InterlockedExchangeUlong(Target, Value)
6268
6269 #endif /* _X86_ */
6270
6271 #ifdef _M_ARM
6272 //
6273 // NT-ARM is not documented
6274 //
6275 #include <armddk.h>
6276 #endif
6277
6278 #ifdef __cplusplus
6279 }
6280 #endif
6281
6282 #endif /* __WINDDK_H */