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 VOID
2599 NTAPI
2600 IoDeleteController(
2601   IN PCONTROLLER_OBJECT  ControllerObject);
2602
2603 /*
2604  * VOID
2605  * IoDeassignArcName(
2606  *   IN PUNICODE_STRING  ArcName)
2607  */
2608 #define IoDeassignArcName IoDeleteSymbolicLink
2609
2610 NTKERNELAPI
2611 VOID
2612 NTAPI
2613 IoFreeController(
2614   IN PCONTROLLER_OBJECT  ControllerObject);
2615
2616 NTKERNELAPI
2617 PCONFIGURATION_INFORMATION
2618 NTAPI
2619 IoGetConfigurationInformation(
2620   VOID);
2621
2622 NTKERNELAPI
2623 PDEVICE_OBJECT
2624 NTAPI
2625 IoGetDeviceToVerify(
2626   IN PETHREAD  Thread);
2627
2628 NTKERNELAPI
2629 PGENERIC_MAPPING
2630 NTAPI
2631 IoGetFileObjectGenericMapping(
2632   VOID);
2633
2634 NTKERNELAPI
2635 PIRP
2636 NTAPI
2637 IoMakeAssociatedIrp(
2638   IN PIRP  Irp,
2639   IN CCHAR  StackSize);
2640
2641 NTKERNELAPI
2642 NTSTATUS
2643 NTAPI
2644 IoQueryDeviceDescription(
2645   IN PINTERFACE_TYPE  BusType  OPTIONAL,
2646   IN PULONG  BusNumber  OPTIONAL,
2647   IN PCONFIGURATION_TYPE  ControllerType  OPTIONAL,
2648   IN PULONG  ControllerNumber  OPTIONAL,
2649   IN PCONFIGURATION_TYPE  PeripheralType  OPTIONAL,
2650   IN PULONG  PeripheralNumber  OPTIONAL,
2651   IN PIO_QUERY_DEVICE_ROUTINE  CalloutRoutine,
2652   IN PVOID  Context);
2653
2654 NTKERNELAPI
2655 VOID
2656 NTAPI
2657 IoRaiseHardError(
2658   IN PIRP  Irp,
2659   IN PVPB  Vpb  OPTIONAL,
2660   IN PDEVICE_OBJECT  RealDeviceObject);
2661
2662 NTKERNELAPI
2663 BOOLEAN
2664 NTAPI
2665 IoRaiseInformationalHardError(
2666   IN NTSTATUS  ErrorStatus,
2667   IN PUNICODE_STRING  String  OPTIONAL,
2668   IN PKTHREAD  Thread  OPTIONAL);
2669
2670 NTKERNELAPI
2671 NTSTATUS
2672 NTAPI
2673 IoReadDiskSignature(
2674   IN PDEVICE_OBJECT  DeviceObject,
2675   IN ULONG  BytesPerSector,
2676   OUT PDISK_SIGNATURE  Signature);
2677
2678 NTKERNELAPI
2679 NTSTATUS
2680 FASTCALL
2681 IoReadPartitionTable(
2682   IN PDEVICE_OBJECT  DeviceObject,
2683   IN ULONG  SectorSize,
2684   IN BOOLEAN  ReturnRecognizedPartitions,
2685   OUT struct _DRIVE_LAYOUT_INFORMATION  **PartitionBuffer);
2686
2687 NTKERNELAPI
2688 NTSTATUS
2689 NTAPI
2690 IoReadPartitionTableEx(
2691   IN PDEVICE_OBJECT  DeviceObject,
2692   IN struct _DRIVE_LAYOUT_INFORMATION_EX  **PartitionBuffer);
2693
2694 NTKERNELAPI
2695 VOID
2696 NTAPI
2697 IoRegisterBootDriverReinitialization(
2698   IN PDRIVER_OBJECT  DriverObject,
2699   IN PDRIVER_REINITIALIZE  DriverReinitializationRoutine,
2700   IN PVOID  Context);
2701
2702 NTKERNELAPI
2703 VOID
2704 NTAPI
2705 IoRegisterBootDriverReinitialization(
2706   IN PDRIVER_OBJECT  DriverObject,
2707   IN PDRIVER_REINITIALIZE  DriverReinitializationRoutine,
2708   IN PVOID  Context);
2709
2710 NTKERNELAPI
2711 VOID
2712 NTAPI
2713 IoRegisterDriverReinitialization(
2714   IN PDRIVER_OBJECT  DriverObject,
2715   IN PDRIVER_REINITIALIZE  DriverReinitializationRoutine,
2716   IN PVOID  Context);
2717
2718 NTKERNELAPI
2719 NTSTATUS
2720 NTAPI
2721 IoReportDetectedDevice(
2722   IN PDRIVER_OBJECT  DriverObject,
2723   IN INTERFACE_TYPE  LegacyBusType,
2724   IN ULONG  BusNumber,
2725   IN ULONG  SlotNumber,
2726   IN PCM_RESOURCE_LIST  ResourceList,
2727   IN PIO_RESOURCE_REQUIREMENTS_LIST  ResourceRequirements  OPTIONAL,
2728   IN BOOLEAN  ResourceAssigned,
2729   IN OUT PDEVICE_OBJECT  *DeviceObject);
2730
2731 NTKERNELAPI
2732 NTSTATUS
2733 NTAPI
2734 IoReportResourceForDetection(
2735   IN PDRIVER_OBJECT  DriverObject,
2736   IN PCM_RESOURCE_LIST  DriverList  OPTIONAL,
2737   IN ULONG  DriverListSize  OPTIONAL,
2738   IN PDEVICE_OBJECT  DeviceObject  OPTIONAL,
2739   IN PCM_RESOURCE_LIST  DeviceList  OPTIONAL,
2740   IN ULONG  DeviceListSize  OPTIONAL,
2741   OUT PBOOLEAN  ConflictDetected);
2742
2743 NTKERNELAPI
2744 NTSTATUS
2745 NTAPI
2746 IoReportResourceUsage(
2747   IN PUNICODE_STRING  DriverClassName  OPTIONAL,
2748   IN PDRIVER_OBJECT  DriverObject,
2749   IN PCM_RESOURCE_LIST  DriverList  OPTIONAL,
2750   IN ULONG  DriverListSize  OPTIONAL,
2751   IN PDEVICE_OBJECT  DeviceObject,
2752   IN PCM_RESOURCE_LIST  DeviceList  OPTIONAL,
2753   IN ULONG  DeviceListSize  OPTIONAL,
2754   IN BOOLEAN  OverrideConflict,
2755   OUT PBOOLEAN  ConflictDetected);
2756
2757 NTKERNELAPI
2758 NTSTATUS
2759 NTAPI
2760 IoReportTargetDeviceChange(
2761   IN PDEVICE_OBJECT  PhysicalDeviceObject,
2762   IN PVOID  NotificationStructure);
2763
2764 NTKERNELAPI
2765 NTSTATUS
2766 NTAPI
2767 IoReportTargetDeviceChangeAsynchronous(
2768   IN PDEVICE_OBJECT  PhysicalDeviceObject,
2769   IN PVOID  NotificationStructure,
2770   IN PDEVICE_CHANGE_COMPLETE_CALLBACK  Callback  OPTIONAL,
2771   IN PVOID  Context  OPTIONAL);
2772
2773 NTKERNELAPI
2774 VOID
2775 NTAPI
2776 IoRequestDeviceEject(
2777   IN PDEVICE_OBJECT  PhysicalDeviceObject);
2778
2779 /*
2780  * VOID
2781  * IoRequestDpc(
2782  *   IN PDEVICE_OBJECT  DeviceObject,
2783  *   IN PIRP  Irp,
2784  *   IN PVOID  Context);
2785  */
2786 #define IoRequestDpc(DeviceObject, Irp, Context)( \
2787   KeInsertQueueDpc(&(DeviceObject)->Dpc, (Irp), (Context)))
2788
2789 NTKERNELAPI
2790 VOID
2791 NTAPI
2792 IoReuseIrp(
2793   IN OUT PIRP  Irp,
2794   IN NTSTATUS  Status);
2795
2796 /*
2797  * PDRIVER_CANCEL
2798  * IoSetCancelRoutine(
2799  *   IN PIRP  Irp,
2800  *   IN PDRIVER_CANCEL  CancelRoutine)
2801  */
2802 #define IoSetCancelRoutine(_Irp, \
2803                            _CancelRoutine) \
2804   ((PDRIVER_CANCEL) InterlockedExchangePointer( \
2805     (PVOID *) &(_Irp)->CancelRoutine, (PVOID) (_CancelRoutine)))
2806
2807 /*
2808  * VOID
2809  * IoSetCompletionRoutine(
2810  *   IN PIRP  Irp,
2811  *   IN PIO_COMPLETION_ROUTINE  CompletionRoutine,
2812  *   IN PVOID  Context,
2813  *   IN BOOLEAN  InvokeOnSuccess,
2814  *   IN BOOLEAN  InvokeOnError,
2815  *   IN BOOLEAN  InvokeOnCancel)
2816  */
2817 #define IoSetCompletionRoutine(_Irp, \
2818                                _CompletionRoutine, \
2819                                _Context, \
2820                                _InvokeOnSuccess, \
2821                                _InvokeOnError, \
2822                                _InvokeOnCancel) \
2823 { \
2824   PIO_STACK_LOCATION _IrpSp; \
2825   ASSERT((_InvokeOnSuccess) || (_InvokeOnError) || (_InvokeOnCancel) ? \
2826     (_CompletionRoutine) != NULL : TRUE); \
2827   _IrpSp = IoGetNextIrpStackLocation(_Irp); \
2828   _IrpSp->CompletionRoutine = (PIO_COMPLETION_ROUTINE)(_CompletionRoutine); \
2829   _IrpSp->Context = (_Context); \
2830   _IrpSp->Control = 0; \
2831   if (_InvokeOnSuccess) _IrpSp->Control = SL_INVOKE_ON_SUCCESS; \
2832   if (_InvokeOnError) _IrpSp->Control |= SL_INVOKE_ON_ERROR; \
2833   if (_InvokeOnCancel) _IrpSp->Control |= SL_INVOKE_ON_CANCEL; \
2834 }
2835
2836 NTKERNELAPI
2837 NTSTATUS
2838 NTAPI
2839 IoSetCompletionRoutineEx(
2840   IN PDEVICE_OBJECT  DeviceObject,
2841   IN PIRP  Irp,
2842   IN PIO_COMPLETION_ROUTINE  CompletionRoutine,
2843   IN PVOID  Context,
2844   IN BOOLEAN  InvokeOnSuccess,
2845   IN BOOLEAN  InvokeOnError,
2846   IN BOOLEAN  InvokeOnCancel);
2847
2848 NTKERNELAPI
2849 NTSTATUS
2850 NTAPI
2851 IoSetDeviceInterfaceState(
2852   IN PUNICODE_STRING  SymbolicLinkName,
2853   IN BOOLEAN  Enable);
2854
2855 NTKERNELAPI
2856 VOID
2857 NTAPI
2858 IoSetHardErrorOrVerifyDevice(
2859   IN PIRP  Irp,
2860   IN PDEVICE_OBJECT  DeviceObject);
2861
2862 /*
2863  * VOID
2864  * IoSetNextIrpStackLocation(
2865  *   IN OUT PIRP  Irp)
2866  */
2867 #define IoSetNextIrpStackLocation(_Irp) \
2868 { \
2869   (_Irp)->CurrentLocation--; \
2870   (_Irp)->Tail.Overlay.CurrentStackLocation--; \
2871 }
2872
2873 NTKERNELAPI
2874 NTSTATUS
2875 FASTCALL
2876 IoSetPartitionInformation(
2877   IN PDEVICE_OBJECT  DeviceObject,
2878   IN ULONG  SectorSize,
2879   IN ULONG  PartitionNumber,
2880   IN ULONG  PartitionType);
2881
2882 NTKERNELAPI
2883 NTSTATUS
2884 NTAPI
2885 IoSetPartitionInformationEx(
2886   IN PDEVICE_OBJECT  DeviceObject,
2887   IN ULONG  PartitionNumber,
2888   IN struct _SET_PARTITION_INFORMATION_EX  *PartitionInfo);
2889
2890 NTKERNELAPI
2891 VOID
2892 NTAPI
2893 IoSetShareAccess(
2894   IN ACCESS_MASK  DesiredAccess,
2895   IN ULONG  DesiredShareAccess,
2896   IN OUT PFILE_OBJECT  FileObject,
2897   OUT PSHARE_ACCESS  ShareAccess);
2898
2899 NTKERNELAPI
2900 VOID
2901 NTAPI
2902 IoSetStartIoAttributes(
2903   IN PDEVICE_OBJECT  DeviceObject,
2904   IN BOOLEAN  DeferredStartIo,
2905   IN BOOLEAN  NonCancelable);
2906
2907 NTKERNELAPI
2908 NTSTATUS
2909 NTAPI
2910 IoSetSystemPartition(
2911   IN PUNICODE_STRING  VolumeNameString);
2912
2913 NTKERNELAPI
2914 BOOLEAN
2915 NTAPI
2916 IoSetThreadHardErrorMode(
2917   IN BOOLEAN  EnableHardErrors);
2918
2919 /*
2920  * USHORT
2921  * IoSizeOfIrp(
2922  *   IN CCHAR  StackSize)
2923  */
2924 #define IoSizeOfIrp(_StackSize) \
2925   ((USHORT) (sizeof(IRP) + ((_StackSize) * (sizeof(IO_STACK_LOCATION)))))
2926
2927 /*
2928  * VOID
2929  * IoSkipCurrentIrpStackLocation(
2930  *   IN PIRP  Irp)
2931  */
2932 #define IoSkipCurrentIrpStackLocation(_Irp) \
2933 { \
2934   (_Irp)->CurrentLocation++; \
2935   (_Irp)->Tail.Overlay.CurrentStackLocation++; \
2936 }
2937
2938 NTKERNELAPI
2939 VOID
2940 NTAPI
2941 IoStartNextPacket(
2942   IN PDEVICE_OBJECT  DeviceObject,
2943   IN BOOLEAN  Cancelable);
2944
2945 NTKERNELAPI
2946 VOID
2947 NTAPI
2948 IoStartNextPacketByKey(
2949   IN PDEVICE_OBJECT  DeviceObject,
2950   IN BOOLEAN  Cancelable,
2951   IN ULONG  Key);
2952
2953 NTKERNELAPI
2954 VOID
2955 NTAPI
2956 IoStartPacket(
2957   IN PDEVICE_OBJECT  DeviceObject,
2958   IN PIRP  Irp,
2959   IN PULONG  Key  OPTIONAL,
2960   IN PDRIVER_CANCEL  CancelFunction  OPTIONAL);
2961
2962 NTKERNELAPI
2963 VOID
2964 NTAPI
2965 IoStartTimer(
2966   IN PDEVICE_OBJECT  DeviceObject);
2967
2968 NTKERNELAPI
2969 VOID
2970 NTAPI
2971 IoStopTimer(
2972   IN PDEVICE_OBJECT  DeviceObject);
2973
2974 NTKERNELAPI
2975 NTSTATUS
2976 NTAPI
2977 IoUnregisterPlugPlayNotification(
2978   IN PVOID  NotificationEntry);
2979
2980 NTKERNELAPI
2981 VOID
2982 NTAPI
2983 IoUnregisterShutdownNotification(
2984   IN PDEVICE_OBJECT  DeviceObject);
2985
2986 NTKERNELAPI
2987 VOID
2988 NTAPI
2989 IoUpdateShareAccess(
2990   IN PFILE_OBJECT  FileObject,
2991   IN OUT PSHARE_ACCESS  ShareAccess);
2992
2993 NTKERNELAPI
2994 NTSTATUS
2995 NTAPI
2996 IoVerifyPartitionTable(
2997   IN PDEVICE_OBJECT  DeviceObject,
2998   IN BOOLEAN  FixErrors);
2999
3000 NTKERNELAPI
3001 NTSTATUS
3002 NTAPI
3003 IoVolumeDeviceToDosName(
3004   IN  PVOID  VolumeDeviceObject,
3005   OUT PUNICODE_STRING  DosName);
3006
3007 NTKERNELAPI
3008 NTSTATUS
3009 NTAPI
3010 IoWMIAllocateInstanceIds(
3011   IN GUID  *Guid,
3012   IN ULONG  InstanceCount,
3013   OUT ULONG  *FirstInstanceId);
3014
3015 NTKERNELAPI
3016 ULONG
3017 NTAPI
3018 IoWMIDeviceObjectToProviderId(
3019   IN PDEVICE_OBJECT  DeviceObject);
3020
3021 NTKERNELAPI
3022 NTSTATUS
3023 NTAPI
3024 IoWMIDeviceObjectToInstanceName(
3025   IN PVOID  DataBlockObject,
3026   IN PDEVICE_OBJECT  DeviceObject,
3027   OUT PUNICODE_STRING  InstanceName);
3028
3029 NTKERNELAPI
3030 NTSTATUS
3031 NTAPI
3032 IoWMIExecuteMethod(
3033   IN PVOID  DataBlockObject,
3034   IN PUNICODE_STRING  InstanceName,
3035   IN ULONG  MethodId,
3036   IN ULONG  InBufferSize,
3037   IN OUT PULONG  OutBufferSize,
3038   IN OUT  PUCHAR  InOutBuffer);
3039
3040 NTKERNELAPI
3041 NTSTATUS
3042 NTAPI
3043 IoWMIHandleToInstanceName(
3044   IN PVOID  DataBlockObject,
3045   IN HANDLE  FileHandle,
3046   OUT PUNICODE_STRING  InstanceName);
3047
3048 NTKERNELAPI
3049 NTSTATUS
3050 NTAPI
3051 IoWMIOpenBlock(
3052   IN GUID  *DataBlockGuid,
3053   IN ULONG  DesiredAccess,
3054   OUT PVOID  *DataBlockObject);
3055
3056 NTKERNELAPI
3057 NTSTATUS
3058 NTAPI
3059 IoWMIQueryAllData(
3060   IN PVOID  DataBlockObject,
3061   IN OUT ULONG  *InOutBufferSize,
3062   OUT PVOID  OutBuffer);
3063
3064 NTKERNELAPI
3065 NTSTATUS
3066 NTAPI
3067 IoWMIQueryAllDataMultiple(
3068   IN PVOID  *DataBlockObjectList,
3069   IN ULONG  ObjectCount,
3070   IN OUT ULONG  *InOutBufferSize,
3071   OUT PVOID  OutBuffer);
3072
3073 NTKERNELAPI
3074 NTSTATUS
3075 NTAPI
3076 IoWMIQuerySingleInstance(
3077   IN PVOID  DataBlockObject,
3078   IN PUNICODE_STRING  InstanceName,
3079   IN OUT ULONG  *InOutBufferSize,
3080   OUT PVOID OutBuffer);
3081
3082 NTKERNELAPI
3083 NTSTATUS
3084 NTAPI
3085 IoWMIQuerySingleInstanceMultiple(
3086   IN PVOID  *DataBlockObjectList,
3087   IN PUNICODE_STRING  InstanceNames,
3088   IN ULONG  ObjectCount,
3089   IN OUT ULONG  *InOutBufferSize,
3090   OUT PVOID  OutBuffer);
3091
3092 NTKERNELAPI
3093 NTSTATUS
3094 NTAPI
3095 IoWMIRegistrationControl(
3096   IN PDEVICE_OBJECT  DeviceObject,
3097   IN ULONG  Action);
3098
3099 NTKERNELAPI
3100 NTSTATUS
3101 NTAPI
3102 IoWMISetNotificationCallback(
3103   IN PVOID  Object,
3104   IN WMI_NOTIFICATION_CALLBACK  Callback,
3105   IN PVOID  Context);
3106
3107 NTKERNELAPI
3108 NTSTATUS
3109 NTAPI
3110 IoWMISetSingleInstance(
3111   IN PVOID  DataBlockObject,
3112   IN PUNICODE_STRING  InstanceName,
3113   IN ULONG  Version,
3114   IN ULONG  ValueBufferSize,
3115   IN PVOID  ValueBuffer);
3116
3117 NTKERNELAPI
3118 NTSTATUS
3119 NTAPI
3120 IoWMISetSingleItem(
3121   IN PVOID  DataBlockObject,
3122   IN PUNICODE_STRING  InstanceName,
3123   IN ULONG  DataItemId,
3124   IN ULONG  Version,
3125   IN ULONG  ValueBufferSize,
3126   IN PVOID  ValueBuffer);
3127
3128 NTKERNELAPI
3129 NTSTATUS
3130 NTAPI
3131 IoWMISuggestInstanceName(
3132   IN PDEVICE_OBJECT  PhysicalDeviceObject OPTIONAL,
3133   IN PUNICODE_STRING  SymbolicLinkName OPTIONAL,
3134   IN BOOLEAN  CombineNames,
3135   OUT PUNICODE_STRING  SuggestedInstanceName);
3136
3137 NTKERNELAPI
3138 NTSTATUS
3139 NTAPI
3140 IoWMIWriteEvent(
3141   IN PVOID  WnodeEventItem);
3142
3143 NTKERNELAPI
3144 VOID
3145 NTAPI
3146 IoWriteErrorLogEntry(
3147   IN PVOID  ElEntry);
3148
3149 NTKERNELAPI
3150 NTSTATUS
3151 FASTCALL
3152 IoWritePartitionTable(
3153   IN PDEVICE_OBJECT  DeviceObject,
3154   IN ULONG  SectorSize,
3155   IN ULONG  SectorsPerTrack,
3156   IN ULONG  NumberOfHeads,
3157   IN struct _DRIVE_LAYOUT_INFORMATION  *PartitionBuffer);
3158
3159 NTKERNELAPI
3160 NTSTATUS
3161 NTAPI
3162 IoWritePartitionTableEx(
3163   IN PDEVICE_OBJECT  DeviceObject,
3164   IN struct _DRIVE_LAYOUT_INFORMATION_EX  *PartitionBuffer);
3165
3166
3167
3168 /** Kernel routines **/
3169
3170 #if defined (_M_AMD64)
3171 NTKERNELAPI
3172 VOID
3173 FASTCALL
3174 KeAcquireInStackQueuedSpinLock(
3175   IN PKSPIN_LOCK  SpinLock,
3176   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3177
3178 NTKERNELAPI
3179 VOID
3180 FASTCALL
3181 KeReleaseInStackQueuedSpinLock(
3182   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3183 #else
3184 NTHALAPI
3185 VOID
3186 FASTCALL
3187 KeAcquireInStackQueuedSpinLock(
3188   IN PKSPIN_LOCK  SpinLock,
3189   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3190
3191 NTHALAPI
3192 VOID
3193 FASTCALL
3194 KeReleaseInStackQueuedSpinLock(
3195   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3196 #endif
3197
3198 NTKERNELAPI
3199 VOID
3200 FASTCALL
3201 KeAcquireInStackQueuedSpinLockAtDpcLevel(
3202   IN PKSPIN_LOCK  SpinLock,
3203   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3204
3205 NTKERNELAPI
3206 KIRQL
3207 NTAPI
3208 KeAcquireInterruptSpinLock(
3209   IN PKINTERRUPT  Interrupt);
3210
3211 NTKERNELAPI
3212 BOOLEAN
3213 NTAPI
3214 KeAreApcsDisabled(
3215   VOID);
3216
3217 NTKERNELAPI
3218 DECLSPEC_NORETURN
3219 VOID
3220 NTAPI
3221 KeBugCheck(
3222   IN ULONG  BugCheckCode);
3223
3224 NTKERNELAPI
3225 DECLSPEC_NORETURN
3226 VOID
3227 NTAPI
3228 KeBugCheckEx(
3229   IN ULONG  BugCheckCode,
3230   IN ULONG_PTR  BugCheckParameter1,
3231   IN ULONG_PTR  BugCheckParameter2,
3232   IN ULONG_PTR  BugCheckParameter3,
3233   IN ULONG_PTR  BugCheckParameter4);
3234
3235 NTKERNELAPI
3236 BOOLEAN
3237 NTAPI
3238 KeCancelTimer(
3239   IN PKTIMER  Timer);
3240
3241 NTKERNELAPI
3242 VOID
3243 NTAPI
3244 KeClearEvent(
3245   IN PRKEVENT  Event);
3246
3247 NTKERNELAPI
3248 NTSTATUS
3249 NTAPI
3250 KeDelayExecutionThread(
3251   IN KPROCESSOR_MODE  WaitMode,
3252   IN BOOLEAN  Alertable,
3253   IN PLARGE_INTEGER  Interval);
3254
3255 NTKERNELAPI
3256 BOOLEAN
3257 NTAPI
3258 KeDeregisterBugCheckCallback(
3259   IN PKBUGCHECK_CALLBACK_RECORD  CallbackRecord);
3260
3261 NTKERNELAPI
3262 VOID
3263 NTAPI
3264 KeEnterCriticalRegion(
3265   VOID);
3266
3267 /*
3268  * VOID
3269  * KeFlushIoBuffers(
3270  *   IN PMDL  Mdl,
3271  *   IN BOOLEAN  ReadOperation,
3272  *   IN BOOLEAN  DmaOperation)
3273  */
3274 #define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
3275
3276 #define ExAcquireSpinLock(Lock, OldIrql) KeAcquireSpinLock((Lock), (OldIrql))
3277 #define ExReleaseSpinLock(Lock, OldIrql) KeReleaseSpinLock((Lock), (OldIrql))
3278 #define ExAcquireSpinLockAtDpcLevel(Lock) KeAcquireSpinLockAtDpcLevel(Lock)
3279 #define ExReleaseSpinLockFromDpcLevel(Lock) KeReleaseSpinLockFromDpcLevel(Lock)
3280
3281 NTKERNELAPI
3282 VOID
3283 NTAPI
3284 KeFlushQueuedDpcs(
3285     VOID
3286 );
3287
3288 NTHALAPI
3289 VOID
3290 NTAPI
3291 KeFlushWriteBuffer(VOID);
3292
3293 NTKERNELAPI
3294 ULONG
3295 NTAPI
3296 KeGetRecommendedSharedDataAlignment(
3297   VOID);
3298
3299 NTKERNELAPI
3300 VOID
3301 NTAPI
3302 KeInitializeDeviceQueue(
3303   IN PKDEVICE_QUEUE  DeviceQueue);
3304
3305 NTKERNELAPI
3306 VOID
3307 NTAPI
3308 KeInitializeMutex(
3309   IN PRKMUTEX  Mutex,
3310   IN ULONG  Level);
3311
3312 NTKERNELAPI
3313 VOID
3314 NTAPI
3315 KeInitializeSemaphore(
3316   IN PRKSEMAPHORE  Semaphore,
3317   IN LONG  Count,
3318   IN LONG  Limit);
3319
3320 NTKERNELAPI
3321 VOID
3322 NTAPI
3323 KeInitializeTimer(
3324   IN PKTIMER  Timer);
3325
3326 NTKERNELAPI
3327 VOID
3328 NTAPI
3329 KeInitializeTimerEx(
3330   IN PKTIMER  Timer,
3331   IN TIMER_TYPE  Type);
3332
3333 NTKERNELAPI
3334 BOOLEAN
3335 NTAPI
3336 KeInsertByKeyDeviceQueue(
3337   IN PKDEVICE_QUEUE  DeviceQueue,
3338   IN PKDEVICE_QUEUE_ENTRY  DeviceQueueEntry,
3339   IN ULONG  SortKey);
3340
3341 NTKERNELAPI
3342 BOOLEAN
3343 NTAPI
3344 KeInsertDeviceQueue(
3345   IN PKDEVICE_QUEUE  DeviceQueue,
3346   IN PKDEVICE_QUEUE_ENTRY  DeviceQueueEntry);
3347
3348 NTKERNELAPI
3349 BOOLEAN
3350 NTAPI
3351 KeInsertQueueDpc(
3352   IN PRKDPC  Dpc,
3353   IN PVOID  SystemArgument1,
3354   IN PVOID  SystemArgument2);
3355
3356 NTKERNELAPI
3357 VOID
3358 NTAPI
3359 KeLeaveCriticalRegion(
3360   VOID);
3361
3362 #ifdef _X86_
3363
3364 static __inline
3365 VOID
3366 KeMemoryBarrier(
3367   VOID)
3368 {
3369   volatile LONG Barrier;
3370 #if defined(__GNUC__)
3371   __asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) : "%eax");
3372 #elif defined(_MSC_VER)
3373   __asm xchg [Barrier], eax
3374 #endif
3375 }
3376
3377 #endif
3378
3379 NTKERNELAPI
3380 LONG
3381 NTAPI
3382 KePulseEvent(
3383   IN PRKEVENT  Event,
3384   IN KPRIORITY  Increment,
3385   IN BOOLEAN  Wait);
3386
3387 NTKERNELAPI
3388 KAFFINITY
3389 NTAPI
3390 KeQueryActiveProcessors(
3391     VOID
3392 );
3393
3394 NTHALAPI
3395 LARGE_INTEGER
3396 NTAPI
3397 KeQueryPerformanceCounter(
3398   OUT PLARGE_INTEGER  PerformanceFrequency  OPTIONAL);
3399
3400 NTKERNELAPI
3401 KPRIORITY
3402 NTAPI
3403 KeQueryPriorityThread(
3404   IN PRKTHREAD  Thread);
3405
3406 NTKERNELAPI
3407 ULONG
3408 NTAPI
3409 KeQueryRuntimeThread(
3410   IN PKTHREAD Thread,
3411   OUT PULONG UserTime);
3412
3413 #if !defined(_M_AMD64)
3414 NTKERNELAPI
3415 ULONGLONG
3416 NTAPI
3417 KeQueryInterruptTime(
3418   VOID);
3419
3420 NTKERNELAPI
3421 VOID
3422 NTAPI
3423 KeQuerySystemTime(
3424   OUT PLARGE_INTEGER  CurrentTime);
3425
3426 NTKERNELAPI
3427 VOID
3428 NTAPI
3429 KeQueryTickCount(
3430   OUT PLARGE_INTEGER  TickCount);
3431 #endif
3432
3433 NTKERNELAPI
3434 ULONG
3435 NTAPI
3436 KeQueryTimeIncrement(
3437   VOID);
3438
3439 NTKERNELAPI
3440 LONG
3441 NTAPI
3442 KeReadStateEvent(
3443   IN PRKEVENT  Event);
3444
3445 NTKERNELAPI
3446 LONG
3447 NTAPI
3448 KeReadStateMutex(
3449   IN PRKMUTEX  Mutex);
3450
3451
3452 NTKERNELAPI
3453 LONG
3454 NTAPI
3455 KeReadStateSemaphore(
3456   IN PRKSEMAPHORE  Semaphore);
3457
3458 NTKERNELAPI
3459 BOOLEAN
3460 NTAPI
3461 KeReadStateTimer(
3462   IN PKTIMER  Timer);
3463
3464 NTKERNELAPI
3465 BOOLEAN
3466 NTAPI
3467 KeRegisterBugCheckCallback(
3468   IN PKBUGCHECK_CALLBACK_RECORD  CallbackRecord,
3469   IN PKBUGCHECK_CALLBACK_ROUTINE  CallbackRoutine,
3470   IN PVOID  Buffer,
3471   IN ULONG  Length,
3472   IN PUCHAR  Component);
3473
3474 NTKERNELAPI
3475 PVOID
3476 NTAPI
3477 KeRegisterNmiCallback(
3478   IN PNMI_CALLBACK CallbackRoutine,
3479   IN PVOID Context
3480 );
3481
3482 NTKERNELAPI
3483 NTSTATUS
3484 NTAPI
3485 KeDeregisterNmiCallback(
3486   IN PVOID Handle
3487 );
3488
3489 NTKERNELAPI
3490 VOID
3491 FASTCALL
3492 KeReleaseInStackQueuedSpinLockFromDpcLevel(
3493   IN PKLOCK_QUEUE_HANDLE  LockHandle);
3494
3495 NTKERNELAPI
3496 VOID
3497 NTAPI
3498 KeReleaseInterruptSpinLock(
3499   IN PKINTERRUPT  Interrupt,
3500   IN KIRQL  OldIrql);
3501
3502 NTKERNELAPI
3503 LONG
3504 NTAPI
3505 KeReleaseMutex(
3506   IN PRKMUTEX  Mutex,
3507   IN BOOLEAN  Wait);
3508
3509 NTKERNELAPI
3510 LONG
3511 NTAPI
3512 KeReleaseSemaphore(
3513   IN PRKSEMAPHORE  Semaphore,
3514   IN KPRIORITY  Increment,
3515   IN LONG  Adjustment,
3516   IN BOOLEAN  Wait);
3517
3518 NTKERNELAPI
3519 PKDEVICE_QUEUE_ENTRY
3520 NTAPI
3521 KeRemoveByKeyDeviceQueue(
3522   IN PKDEVICE_QUEUE  DeviceQueue,
3523   IN ULONG  SortKey);
3524
3525 NTKERNELAPI
3526 PKDEVICE_QUEUE_ENTRY
3527 NTAPI
3528 KeRemoveDeviceQueue(
3529   IN PKDEVICE_QUEUE  DeviceQueue);
3530
3531 NTKERNELAPI
3532 BOOLEAN
3533 NTAPI
3534 KeRemoveEntryDeviceQueue(
3535   IN PKDEVICE_QUEUE  DeviceQueue,
3536   IN PKDEVICE_QUEUE_ENTRY  DeviceQueueEntry);
3537
3538 NTKERNELAPI
3539 BOOLEAN
3540 NTAPI
3541 KeRemoveQueueDpc(
3542   IN PRKDPC  Dpc);
3543
3544 NTKERNELAPI
3545 LONG
3546 NTAPI
3547 KeResetEvent(
3548   IN PRKEVENT  Event);
3549
3550 NTKERNELAPI
3551 NTSTATUS
3552 NTAPI
3553 KeRestoreFloatingPointState(
3554   IN PKFLOATING_SAVE  FloatSave);
3555
3556 NTKERNELAPI
3557 VOID
3558 NTAPI
3559 KeRevertToUserAffinityThread(VOID);
3560
3561 NTKERNELAPI
3562 NTSTATUS
3563 NTAPI
3564 KeSaveFloatingPointState(
3565   OUT PKFLOATING_SAVE  FloatSave);
3566
3567 NTKERNELAPI
3568 LONG
3569 NTAPI
3570 KeSetBasePriorityThread(
3571   IN PRKTHREAD  Thread,
3572   IN LONG  Increment);
3573
3574 NTKERNELAPI
3575 LONG
3576 NTAPI
3577 KeSetEvent(
3578   IN PRKEVENT  Event,
3579   IN KPRIORITY  Increment,
3580   IN BOOLEAN  Wait);
3581
3582 NTKERNELAPI
3583 VOID
3584 NTAPI
3585 KeSetImportanceDpc(
3586   IN PRKDPC  Dpc,
3587   IN KDPC_IMPORTANCE  Importance);
3588
3589 NTKERNELAPI
3590 KPRIORITY
3591 NTAPI
3592 KeSetPriorityThread(
3593   IN PKTHREAD  Thread,
3594   IN KPRIORITY  Priority);
3595
3596 NTKERNELAPI
3597 VOID
3598 NTAPI
3599 KeSetSystemAffinityThread(
3600     IN KAFFINITY Affinity);
3601
3602 NTKERNELAPI
3603 VOID
3604 NTAPI
3605 KeSetTargetProcessorDpc(
3606   IN PRKDPC  Dpc,
3607   IN CCHAR  Number);
3608
3609 NTKERNELAPI
3610 BOOLEAN
3611 NTAPI
3612 KeSetTimer(
3613   IN PKTIMER  Timer,
3614   IN LARGE_INTEGER  DueTime,
3615   IN PKDPC  Dpc  OPTIONAL);
3616
3617 NTKERNELAPI
3618 BOOLEAN
3619 NTAPI
3620 KeSetTimerEx(
3621   IN PKTIMER  Timer,
3622   IN LARGE_INTEGER  DueTime,
3623   IN LONG  Period  OPTIONAL,
3624   IN PKDPC  Dpc  OPTIONAL);
3625
3626 NTKERNELAPI
3627 VOID
3628 FASTCALL
3629 KeSetTimeUpdateNotifyRoutine(
3630   IN PTIME_UPDATE_NOTIFY_ROUTINE  NotifyRoutine);
3631
3632 NTHALAPI
3633 VOID
3634 NTAPI
3635 KeStallExecutionProcessor(
3636   IN ULONG  MicroSeconds);
3637
3638 NTKERNELAPI
3639 BOOLEAN
3640 NTAPI
3641 KeSynchronizeExecution(
3642   IN PKINTERRUPT    Interrupt,
3643   IN PKSYNCHRONIZE_ROUTINE  SynchronizeRoutine,
3644   IN PVOID  SynchronizeContext);
3645
3646 NTKERNELAPI
3647 NTSTATUS
3648 NTAPI
3649 KeWaitForMultipleObjects(
3650   IN ULONG  Count,
3651   IN PVOID  Object[],
3652   IN WAIT_TYPE  WaitType,
3653   IN KWAIT_REASON  WaitReason,
3654   IN KPROCESSOR_MODE  WaitMode,
3655   IN BOOLEAN  Alertable,
3656   IN PLARGE_INTEGER  Timeout  OPTIONAL,
3657   IN PKWAIT_BLOCK  WaitBlockArray  OPTIONAL);
3658
3659 NTKERNELAPI
3660 NTSTATUS
3661 NTAPI
3662 KeWaitForMutexObject(
3663   IN PRKMUTEX  Mutex,
3664   IN KWAIT_REASON  WaitReason,
3665   IN KPROCESSOR_MODE  WaitMode,
3666   IN BOOLEAN  Alertable,
3667   IN PLARGE_INTEGER  Timeout  OPTIONAL);
3668
3669 NTKERNELAPI
3670 NTSTATUS
3671 NTAPI
3672 KeWaitForSingleObject(
3673   IN PVOID  Object,
3674   IN KWAIT_REASON  WaitReason,
3675   IN KPROCESSOR_MODE  WaitMode,
3676   IN BOOLEAN  Alertable,
3677   IN PLARGE_INTEGER  Timeout  OPTIONAL);
3678
3679 typedef
3680 ULONG_PTR
3681 (NTAPI *PKIPI_BROADCAST_WORKER)(
3682     IN ULONG_PTR Argument
3683 );
3684
3685 NTKERNELAPI
3686 ULONG_PTR
3687 NTAPI
3688 KeIpiGenericCall(
3689     IN PKIPI_BROADCAST_WORKER BroadcastFunction,
3690     IN ULONG_PTR Context
3691 );
3692
3693 #if defined(_X86_)
3694
3695 NTHALAPI
3696 VOID
3697 FASTCALL
3698 KfLowerIrql(
3699   IN KIRQL  NewIrql);
3700
3701 NTHALAPI
3702 KIRQL
3703 FASTCALL
3704 KfRaiseIrql(
3705   IN KIRQL  NewIrql);
3706
3707 NTHALAPI
3708 KIRQL
3709 DDKAPI
3710 KeRaiseIrqlToDpcLevel(
3711   VOID);
3712
3713 NTHALAPI
3714 KIRQL
3715 DDKAPI
3716 KeRaiseIrqlToSynchLevel(
3717     VOID);
3718
3719 #define KeLowerIrql(a) KfLowerIrql(a)
3720 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
3721
3722 #elif defined(_M_AMD64)
3723
3724 FORCEINLINE
3725 KIRQL
3726 KeGetCurrentIrql(VOID)
3727 {
3728     return (KIRQL)__readcr8();
3729 }
3730
3731 FORCEINLINE
3732 VOID
3733 KeLowerIrql(IN KIRQL NewIrql)
3734 {
3735     ASSERT(KeGetCurrentIrql() >= NewIrql);
3736     __writecr8(NewIrql);
3737 }
3738
3739 FORCEINLINE
3740 KIRQL
3741 KfRaiseIrql(IN KIRQL NewIrql)
3742 {
3743     KIRQL OldIrql;
3744
3745     OldIrql = __readcr8();
3746     ASSERT(OldIrql <= NewIrql);
3747     __writecr8(NewIrql);
3748     return OldIrql;
3749 }
3750 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
3751
3752 FORCEINLINE
3753 KIRQL
3754 KeRaiseIrqlToDpcLevel(VOID)
3755 {
3756     return KfRaiseIrql(DISPATCH_LEVEL);
3757 }
3758
3759 FORCEINLINE
3760 KIRQL
3761 KeRaiseIrqlToSynchLevel(VOID)
3762 {
3763     return KfRaiseIrql(12); // SYNCH_LEVEL = IPI_LEVEL - 2
3764 }
3765
3766 #elif defined(__PowerPC__)
3767
3768 NTHALAPI
3769 VOID
3770 FASTCALL
3771 KfLowerIrql(
3772   IN KIRQL  NewIrql);
3773
3774 NTHALAPI
3775 KIRQL
3776 FASTCALL
3777 KfRaiseIrql(
3778   IN KIRQL  NewIrql);
3779
3780 NTHALAPI
3781 KIRQL
3782 DDKAPI
3783 KeRaiseIrqlToDpcLevel(
3784   VOID);
3785
3786 NTHALAPI
3787 KIRQL
3788 DDKAPI
3789 KeRaiseIrqlToSynchLevel(
3790     VOID);
3791
3792 #define KeLowerIrql(a) KfLowerIrql(a)
3793 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
3794
3795 #elif defined(_M_MIPS)
3796
3797 #define KeLowerIrql(a) KfLowerIrql(a)
3798 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
3799
3800 NTKERNELAPI
3801 VOID
3802 NTAPI
3803 KfLowerIrql(
3804   IN KIRQL  NewIrql);
3805
3806 NTKERNELAPI
3807 KIRQL
3808 NTAPI
3809 KfRaiseIrql(
3810   IN KIRQL  NewIrql);
3811
3812 NTKERNELAPI
3813 KIRQL
3814 NTAPI
3815 KeRaiseIrqlToDpcLevel(
3816   VOID);
3817
3818 NTKERNELAPI
3819 KIRQL
3820 DDKAPI
3821 KeRaiseIrqlToSynchLevel(
3822     VOID);
3823
3824 #elif defined(_M_ARM)
3825
3826 #include <armddk.h>
3827
3828 #else
3829
3830 NTKERNELAPI
3831 VOID
3832 NTAPI
3833 KeLowerIrql(
3834   IN KIRQL  NewIrql);
3835
3836 NTKERNELAPI
3837 VOID
3838 NTAPI
3839 KeRaiseIrql(
3840   IN KIRQL  NewIrql,
3841   OUT PKIRQL  OldIrql);
3842
3843 NTKERNELAPI
3844 KIRQL
3845 NTAPI
3846 KeRaiseIrqlToDpcLevel(
3847   VOID);
3848
3849 NTKERNELAPI
3850 KIRQL
3851 DDKAPI
3852 KeRaiseIrqlToSynchLevel(
3853     VOID);
3854
3855 #endif
3856
3857 /** Memory manager routines **/
3858
3859 NTKERNELAPI
3860 NTSTATUS
3861 NTAPI
3862 MmAdvanceMdl(
3863   IN PMDL  Mdl,
3864   IN ULONG  NumberOfBytes);
3865
3866 NTKERNELAPI
3867 PVOID
3868 NTAPI
3869 MmAllocateContiguousMemory(
3870   IN ULONG  NumberOfBytes,
3871   IN PHYSICAL_ADDRESS  HighestAcceptableAddress);
3872
3873 NTKERNELAPI
3874 PVOID
3875 NTAPI
3876 MmAllocateContiguousMemorySpecifyCache(
3877   IN SIZE_T  NumberOfBytes,
3878   IN PHYSICAL_ADDRESS  LowestAcceptableAddress,
3879   IN PHYSICAL_ADDRESS  HighestAcceptableAddress,
3880   IN PHYSICAL_ADDRESS  BoundaryAddressMultiple  OPTIONAL,
3881   IN MEMORY_CACHING_TYPE  CacheType);
3882
3883 NTKERNELAPI
3884 PVOID
3885 NTAPI
3886 MmAllocateMappingAddress(
3887   IN SIZE_T  NumberOfBytes,
3888   IN ULONG  PoolTag);
3889
3890 NTKERNELAPI
3891 PVOID
3892 NTAPI
3893 MmAllocateNonCachedMemory(
3894   IN ULONG  NumberOfBytes);
3895
3896 NTKERNELAPI
3897 PMDL
3898 NTAPI
3899 MmAllocatePagesForMdl(
3900   IN PHYSICAL_ADDRESS  LowAddress,
3901   IN PHYSICAL_ADDRESS  HighAddress,
3902   IN PHYSICAL_ADDRESS  SkipBytes,
3903   IN SIZE_T  TotalBytes);
3904
3905 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
3906 NTKERNELAPI
3907 PMDL
3908 NTAPI
3909 MmAllocatePagesForMdlEx(
3910   IN PHYSICAL_ADDRESS LowAddress,
3911   IN PHYSICAL_ADDRESS HighAddress,
3912   IN PHYSICAL_ADDRESS SkipBytes,
3913   IN SIZE_T TotalBytes,
3914   IN MEMORY_CACHING_TYPE CacheType,
3915   IN ULONG Flags);
3916 #endif
3917
3918 NTKERNELAPI
3919 VOID
3920 NTAPI
3921 MmBuildMdlForNonPagedPool(
3922   IN OUT PMDL  MemoryDescriptorList);
3923
3924 typedef enum _MMFLUSH_TYPE {
3925   MmFlushForDelete,
3926   MmFlushForWrite
3927 } MMFLUSH_TYPE;
3928
3929 NTKERNELAPI
3930 BOOLEAN
3931 NTAPI
3932 MmFlushImageSection(
3933   IN PSECTION_OBJECT_POINTERS  SectionObjectPointer,
3934   IN MMFLUSH_TYPE  FlushType);
3935
3936 NTKERNELAPI
3937 VOID
3938 NTAPI
3939 MmFreeContiguousMemory(
3940   IN PVOID  BaseAddress);
3941
3942 NTKERNELAPI
3943 VOID
3944 NTAPI
3945 MmFreeContiguousMemorySpecifyCache(
3946   IN PVOID  BaseAddress,
3947   IN SIZE_T  NumberOfBytes,
3948   IN MEMORY_CACHING_TYPE  CacheType);
3949
3950 NTKERNELAPI
3951 VOID
3952 NTAPI
3953 MmFreeMappingAddress(
3954   IN PVOID  BaseAddress,
3955   IN ULONG  PoolTag);
3956
3957 NTKERNELAPI
3958 VOID
3959 NTAPI
3960 MmFreeNonCachedMemory(
3961   IN PVOID  BaseAddress,
3962   IN SIZE_T  NumberOfBytes);
3963
3964 NTKERNELAPI
3965 VOID
3966 NTAPI
3967 MmFreePagesFromMdl(
3968   IN PMDL  MemoryDescriptorList);
3969
3970 /*
3971  * ULONG
3972  * MmGetMdlByteCount(
3973  *   IN PMDL  Mdl)
3974  */
3975 #define MmGetMdlByteCount(_Mdl) \
3976   ((_Mdl)->ByteCount)
3977
3978 /*
3979  * ULONG
3980  * MmGetMdlByteOffset(
3981  *   IN PMDL  Mdl)
3982  */
3983 #define MmGetMdlByteOffset(_Mdl) \
3984   ((_Mdl)->ByteOffset)
3985
3986 /*
3987  * PPFN_NUMBER
3988  * MmGetMdlPfnArray(
3989  *   IN PMDL  Mdl)
3990  */
3991 #define MmGetMdlPfnArray(_Mdl) \
3992   ((PPFN_NUMBER) ((_Mdl) + 1))
3993
3994 /*
3995  * PVOID
3996  * MmGetMdlVirtualAddress(
3997  *   IN PMDL  Mdl)
3998  */
3999 #define MmGetMdlVirtualAddress(_Mdl) \
4000   ((PVOID) ((PCHAR) ((_Mdl)->StartVa) + (_Mdl)->ByteOffset))
4001
4002 NTKERNELAPI
4003 PHYSICAL_ADDRESS
4004 NTAPI
4005 MmGetPhysicalAddress(
4006   IN PVOID  BaseAddress);
4007
4008 NTKERNELAPI
4009 PPHYSICAL_MEMORY_RANGE
4010 NTAPI
4011 MmGetPhysicalMemoryRanges(
4012   VOID);
4013
4014 NTKERNELAPI
4015 PVOID
4016 NTAPI
4017 MmGetVirtualForPhysical(
4018   IN PHYSICAL_ADDRESS  PhysicalAddress);
4019
4020 NTKERNELAPI
4021 PVOID
4022 NTAPI
4023 MmMapLockedPagesSpecifyCache(
4024   IN PMDL  MemoryDescriptorList,
4025   IN KPROCESSOR_MODE  AccessMode,
4026   IN MEMORY_CACHING_TYPE  CacheType,
4027   IN PVOID  BaseAddress,
4028   IN ULONG  BugCheckOnFailure,
4029   IN MM_PAGE_PRIORITY  Priority);
4030
4031 NTKERNELAPI
4032 PVOID
4033 NTAPI
4034 MmMapLockedPagesWithReservedMapping(
4035   IN PVOID  MappingAddress,
4036   IN ULONG  PoolTag,
4037   IN PMDL  MemoryDescriptorList,
4038   IN MEMORY_CACHING_TYPE  CacheType);
4039
4040 NTKERNELAPI
4041 NTSTATUS
4042 NTAPI
4043 MmMapUserAddressesToPage(
4044   IN PVOID  BaseAddress,
4045   IN SIZE_T  NumberOfBytes,
4046   IN PVOID  PageAddress);
4047
4048 NTKERNELAPI
4049 PVOID
4050 NTAPI
4051 MmMapVideoDisplay(
4052   IN PHYSICAL_ADDRESS  PhysicalAddress,
4053   IN SIZE_T  NumberOfBytes,
4054   IN MEMORY_CACHING_TYPE  CacheType);
4055
4056 NTKERNELAPI
4057 NTSTATUS
4058 NTAPI
4059 MmMapViewInSessionSpace(
4060   IN PVOID  Section,
4061   OUT PVOID  *MappedBase,
4062   IN OUT PSIZE_T  ViewSize);
4063
4064 NTKERNELAPI
4065 NTSTATUS
4066 NTAPI
4067 MmMapViewInSystemSpace(
4068   IN PVOID  Section,
4069   OUT PVOID  *MappedBase,
4070   IN PSIZE_T  ViewSize);
4071
4072 NTKERNELAPI
4073 NTSTATUS
4074 NTAPI
4075 MmMarkPhysicalMemoryAsBad(
4076   IN PPHYSICAL_ADDRESS  StartAddress,
4077   IN OUT PLARGE_INTEGER  NumberOfBytes);
4078
4079 NTKERNELAPI
4080 NTSTATUS
4081 NTAPI
4082 MmMarkPhysicalMemoryAsGood(
4083   IN PPHYSICAL_ADDRESS  StartAddress,
4084   IN OUT PLARGE_INTEGER  NumberOfBytes);
4085
4086 NTKERNELAPI
4087 PVOID
4088 NTAPI
4089 MmGetSystemRoutineAddress(
4090   IN PUNICODE_STRING  SystemRoutineName);
4091
4092 /*
4093  * ULONG
4094  * ADDRESS_AND_SIZE_TO_SPAN_PAGES(
4095  *   IN PVOID  Va,
4096  *   IN ULONG  Size)
4097  */
4098 #define ADDRESS_AND_SIZE_TO_SPAN_PAGES(_Va, \
4099                                        _Size) \
4100   ((ULONG) ((((ULONG_PTR) (_Va) & (PAGE_SIZE - 1)) \
4101     + (_Size) + (PAGE_SIZE - 1)) >> PAGE_SHIFT))
4102
4103 /*
4104  * VOID
4105  * MmInitializeMdl(
4106  *   IN PMDL  MemoryDescriptorList,
4107  *   IN PVOID  BaseVa,
4108  *   IN SIZE_T  Length)
4109  */
4110 #define MmInitializeMdl(_MemoryDescriptorList, \
4111                         _BaseVa, \
4112                         _Length) \
4113 { \
4114   (_MemoryDescriptorList)->Next = (PMDL) NULL; \
4115   (_MemoryDescriptorList)->Size = (CSHORT) (sizeof(MDL) + \
4116     (sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(_BaseVa, _Length))); \
4117   (_MemoryDescriptorList)->MdlFlags = 0; \
4118   (_MemoryDescriptorList)->StartVa = (PVOID) PAGE_ALIGN(_BaseVa); \
4119   (_MemoryDescriptorList)->ByteOffset = BYTE_OFFSET(_BaseVa); \
4120   (_MemoryDescriptorList)->ByteCount = (ULONG) _Length; \
4121 }
4122
4123 NTKERNELAPI
4124 BOOLEAN
4125 NTAPI
4126 MmIsAddressValid(
4127   IN PVOID  VirtualAddress);
4128
4129 NTKERNELAPI
4130 LOGICAL
4131 NTAPI
4132 MmIsDriverVerifying(
4133   IN PDRIVER_OBJECT  DriverObject);
4134
4135 NTKERNELAPI
4136 BOOLEAN
4137 NTAPI
4138 MmIsThisAnNtAsSystem(
4139   VOID);
4140
4141 NTKERNELAPI
4142 NTSTATUS
4143 NTAPI
4144 MmIsVerifierEnabled(
4145   OUT PULONG  VerifierFlags);
4146
4147 NTKERNELAPI
4148 PVOID
4149 NTAPI
4150 MmLockPagableDataSection(
4151   IN PVOID  AddressWithinSection);
4152
4153 NTKERNELAPI
4154 PVOID
4155 NTAPI
4156 MmLockPagableImageSection(
4157   IN PVOID  AddressWithinSection);
4158
4159 /*
4160  * PVOID
4161  * MmLockPagableCodeSection(
4162  *   IN PVOID  AddressWithinSection)
4163  */
4164 #define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address)
4165
4166 NTKERNELAPI
4167 VOID
4168 NTAPI
4169 MmLockPagableSectionByHandle(
4170   IN PVOID  ImageSectionHandle);
4171
4172 NTKERNELAPI
4173 PVOID
4174 NTAPI
4175 MmMapIoSpace(
4176   IN PHYSICAL_ADDRESS  PhysicalAddress,
4177   IN ULONG  NumberOfBytes,
4178   IN MEMORY_CACHING_TYPE  CacheEnable);
4179
4180 NTKERNELAPI
4181 PVOID
4182 NTAPI
4183 MmMapLockedPages(
4184   IN PMDL  MemoryDescriptorList,
4185   IN KPROCESSOR_MODE  AccessMode);
4186
4187 NTKERNELAPI
4188 PVOID
4189 NTAPI
4190 MmLockPageableDataSection (
4191     IN PVOID AddressWithinSection
4192 );
4193
4194 NTKERNELAPI
4195 VOID
4196 NTAPI
4197 MmUnlockPageableImageSection(
4198     IN PVOID ImageSectionHandle
4199 );
4200
4201 NTKERNELAPI
4202 PVOID
4203 NTAPI
4204 MmPageEntireDriver(
4205   IN PVOID  AddressWithinSection);
4206
4207 NTKERNELAPI
4208 VOID
4209 NTAPI
4210 MmProbeAndLockProcessPages(
4211   IN OUT PMDL  MemoryDescriptorList,
4212   IN PEPROCESS  Process,
4213   IN KPROCESSOR_MODE  AccessMode,
4214   IN LOCK_OPERATION  Operation);
4215
4216 NTKERNELAPI
4217 NTSTATUS
4218 NTAPI
4219 MmProtectMdlSystemAddress(
4220   IN PMDL  MemoryDescriptorList,
4221   IN ULONG  NewProtect);
4222
4223 NTKERNELAPI
4224 VOID
4225 NTAPI
4226 MmUnmapLockedPages(
4227   IN PVOID  BaseAddress,
4228   IN PMDL  MemoryDescriptorList);
4229
4230 NTKERNELAPI
4231 NTSTATUS
4232 NTAPI
4233 MmUnmapViewInSessionSpace(
4234   IN PVOID  MappedBase);
4235
4236 NTKERNELAPI
4237 NTSTATUS
4238 NTAPI
4239 MmUnmapViewInSystemSpace(
4240   IN PVOID MappedBase);
4241
4242 NTKERNELAPI
4243 VOID
4244 NTAPI
4245 MmUnsecureVirtualMemory(
4246   IN HANDLE  SecureHandle);
4247
4248 /*
4249  * VOID
4250  * MmPrepareMdlForReuse(
4251  *   IN PMDL  Mdl)
4252  */
4253 #define MmPrepareMdlForReuse(_Mdl) \
4254 { \
4255   if (((_Mdl)->MdlFlags & MDL_PARTIAL_HAS_BEEN_MAPPED) != 0) { \
4256     ASSERT(((_Mdl)->MdlFlags & MDL_PARTIAL) != 0); \
4257     MmUnmapLockedPages((_Mdl)->MappedSystemVa, (_Mdl)); \
4258   } else if (((_Mdl)->MdlFlags & MDL_PARTIAL) == 0) { \
4259     ASSERT(((_Mdl)->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA) == 0); \
4260   } \
4261 }
4262
4263 #define MmGetProcedureAddress(Address) (Address)
4264
4265 NTKERNELAPI
4266 VOID
4267 NTAPI
4268 MmProbeAndLockPages(
4269   IN OUT PMDL  MemoryDescriptorList,
4270   IN KPROCESSOR_MODE  AccessMode,
4271   IN LOCK_OPERATION  Operation);
4272
4273 NTKERNELAPI
4274 MM_SYSTEMSIZE
4275 NTAPI
4276 MmQuerySystemSize(
4277   VOID);
4278
4279 NTKERNELAPI
4280 NTSTATUS
4281 NTAPI
4282 MmRemovePhysicalMemory(
4283   IN PPHYSICAL_ADDRESS  StartAddress,
4284   IN OUT PLARGE_INTEGER  NumberOfBytes);
4285
4286 NTKERNELAPI
4287 VOID
4288 NTAPI
4289 MmResetDriverPaging(
4290   IN PVOID  AddressWithinSection);
4291
4292 NTKERNELAPI
4293 HANDLE
4294 NTAPI
4295 MmSecureVirtualMemory(
4296   IN PVOID  Address,
4297   IN SIZE_T  Size,
4298   IN ULONG  ProbeMode);
4299
4300 NTKERNELAPI
4301 SIZE_T
4302 NTAPI
4303 MmSizeOfMdl(
4304   IN PVOID  Base,
4305   IN SIZE_T  Length);
4306
4307 NTKERNELAPI
4308 VOID
4309 NTAPI
4310 MmUnlockPagableImageSection(
4311   IN PVOID  ImageSectionHandle);
4312
4313 NTKERNELAPI
4314 VOID
4315 NTAPI
4316 MmUnlockPages(
4317   IN PMDL  MemoryDescriptorList);
4318
4319 NTKERNELAPI
4320 VOID
4321 NTAPI
4322 MmUnmapIoSpace(
4323   IN PVOID  BaseAddress,
4324   IN SIZE_T  NumberOfBytes);
4325
4326 NTKERNELAPI
4327 VOID
4328 NTAPI
4329 MmUnmapReservedMapping(
4330   IN PVOID  BaseAddress,
4331   IN ULONG  PoolTag,
4332   IN PMDL  MemoryDescriptorList);
4333
4334 NTKERNELAPI
4335 VOID
4336 NTAPI
4337 MmUnmapVideoDisplay(
4338   IN PVOID  BaseAddress,
4339   IN SIZE_T  NumberOfBytes);
4340
4341
4342
4343 /** Object manager routines **/
4344
4345 NTKERNELAPI
4346 NTSTATUS
4347 NTAPI
4348 ObAssignSecurity(
4349   IN PACCESS_STATE  AccessState,
4350   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
4351   IN PVOID  Object,
4352   IN POBJECT_TYPE  Type);
4353
4354 NTKERNELAPI
4355 VOID
4356 NTAPI
4357 ObDereferenceSecurityDescriptor(
4358   PSECURITY_DESCRIPTOR  SecurityDescriptor,
4359   ULONG  Count);
4360
4361 NTKERNELAPI
4362 LONG_PTR
4363 FASTCALL
4364 ObfDereferenceObject(
4365   IN PVOID  Object);
4366
4367 /*
4368  * VOID
4369  * ObDereferenceObject(
4370  *   IN PVOID  Object)
4371  */
4372 #define ObDereferenceObject ObfDereferenceObject
4373
4374 NTKERNELAPI
4375 NTSTATUS
4376 NTAPI
4377 ObGetObjectSecurity(
4378   IN PVOID  Object,
4379   OUT PSECURITY_DESCRIPTOR  *SecurityDescriptor,
4380   OUT PBOOLEAN  MemoryAllocated);
4381
4382 NTKERNELAPI
4383 NTSTATUS
4384 NTAPI
4385 ObInsertObject(
4386   IN PVOID  Object,
4387   IN PACCESS_STATE  PassedAccessState  OPTIONAL,
4388   IN ACCESS_MASK  DesiredAccess,
4389   IN ULONG  AdditionalReferences,
4390   OUT PVOID*  ReferencedObject  OPTIONAL,
4391   OUT PHANDLE  Handle);
4392
4393 NTKERNELAPI
4394 LONG_PTR
4395 FASTCALL
4396 ObfReferenceObject(
4397   IN PVOID  Object);
4398
4399 NTKERNELAPI
4400 NTSTATUS
4401 NTAPI
4402 ObLogSecurityDescriptor(
4403   IN PSECURITY_DESCRIPTOR  InputSecurityDescriptor,
4404   OUT PSECURITY_DESCRIPTOR  *OutputSecurityDescriptor,
4405   IN ULONG RefBias);
4406 /*
4407  * VOID
4408  * ObReferenceObject(
4409  *   IN PVOID  Object)
4410  */
4411 #define ObReferenceObject ObfReferenceObject
4412
4413 NTKERNELAPI
4414 VOID
4415 NTAPI
4416 ObMakeTemporaryObject(
4417   IN PVOID  Object);
4418
4419 NTKERNELAPI
4420 NTSTATUS
4421 NTAPI
4422 ObOpenObjectByName(
4423   IN POBJECT_ATTRIBUTES  ObjectAttributes,
4424   IN POBJECT_TYPE  ObjectType,
4425   IN KPROCESSOR_MODE  AccessMode,
4426   IN PACCESS_STATE  PassedAccessState,
4427   IN ACCESS_MASK  DesiredAccess,
4428   IN OUT PVOID  ParseContext  OPTIONAL,
4429   OUT PHANDLE  Handle);
4430
4431 NTKERNELAPI
4432 NTSTATUS
4433 NTAPI
4434 ObOpenObjectByPointer(
4435   IN PVOID  Object,
4436   IN ULONG  HandleAttributes,
4437   IN PACCESS_STATE  PassedAccessState  OPTIONAL,
4438   IN ACCESS_MASK  DesiredAccess  OPTIONAL,
4439   IN POBJECT_TYPE  ObjectType  OPTIONAL,
4440   IN KPROCESSOR_MODE  AccessMode,
4441   OUT PHANDLE  Handle);
4442
4443 NTKERNELAPI
4444 NTSTATUS
4445 NTAPI
4446 ObQueryObjectAuditingByHandle(
4447   IN HANDLE  Handle,
4448   OUT PBOOLEAN  GenerateOnClose);
4449
4450 NTKERNELAPI
4451 NTSTATUS
4452 NTAPI
4453 ObReferenceObjectByHandle(
4454   IN HANDLE  Handle,
4455   IN ACCESS_MASK  DesiredAccess,
4456   IN POBJECT_TYPE  ObjectType  OPTIONAL,
4457   IN KPROCESSOR_MODE  AccessMode,
4458   OUT PVOID  *Object,
4459   OUT POBJECT_HANDLE_INFORMATION  HandleInformation  OPTIONAL);
4460
4461 NTKERNELAPI
4462 NTSTATUS
4463 NTAPI
4464 ObReferenceObjectByName(
4465   IN PUNICODE_STRING  ObjectPath,
4466   IN ULONG  Attributes,
4467   IN PACCESS_STATE  PassedAccessState  OPTIONAL,
4468   IN ACCESS_MASK  DesiredAccess  OPTIONAL,
4469   IN POBJECT_TYPE  ObjectType,
4470   IN KPROCESSOR_MODE  AccessMode,
4471   IN OUT PVOID  ParseContext  OPTIONAL,
4472   OUT PVOID  *Object);
4473
4474 NTKERNELAPI
4475 NTSTATUS
4476 NTAPI
4477 ObReferenceObjectByPointer(
4478   IN PVOID  Object,
4479   IN ACCESS_MASK  DesiredAccess,
4480   IN POBJECT_TYPE  ObjectType,
4481   IN KPROCESSOR_MODE  AccessMode);
4482
4483 NTKERNELAPI
4484 VOID
4485 NTAPI
4486 ObReferenceSecurityDescriptor(
4487   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
4488   IN ULONG  Count);
4489
4490 NTKERNELAPI
4491 VOID
4492 NTAPI
4493 ObReleaseObjectSecurity(
4494   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
4495   IN BOOLEAN  MemoryAllocated);
4496
4497
4498
4499 /** Process manager routines **/
4500
4501 NTKERNELAPI
4502 NTSTATUS
4503 NTAPI
4504 PsCreateSystemProcess(
4505   IN PHANDLE  ProcessHandle,
4506   IN ACCESS_MASK  DesiredAccess,
4507   IN POBJECT_ATTRIBUTES  ObjectAttributes);
4508
4509 NTKERNELAPI
4510 NTSTATUS
4511 NTAPI
4512 PsCreateSystemThread(
4513   OUT PHANDLE  ThreadHandle,
4514   IN ULONG  DesiredAccess,
4515   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
4516   IN HANDLE  ProcessHandle  OPTIONAL,
4517   OUT PCLIENT_ID  ClientId  OPTIONAL,
4518   IN PKSTART_ROUTINE  StartRoutine,
4519   IN PVOID  StartContext);
4520
4521 /*
4522  * PEPROCESS
4523  * PsGetCurrentProcess(VOID)
4524  */
4525 #define PsGetCurrentProcess IoGetCurrentProcess
4526
4527 NTKERNELAPI
4528 HANDLE
4529 NTAPI
4530 PsGetCurrentProcessId(
4531   VOID);
4532
4533 /*
4534  * PETHREAD
4535  * PsGetCurrentThread(VOID)
4536  */
4537 #define PsGetCurrentThread() \
4538   ((PETHREAD) KeGetCurrentThread())
4539
4540 NTKERNELAPI
4541 HANDLE
4542 NTAPI
4543 PsGetCurrentThreadId(
4544   VOID);
4545
4546 NTKERNELAPI
4547 HANDLE
4548 NTAPI
4549 PsGetProcessId(PEPROCESS Process);
4550
4551 NTKERNELAPI
4552 BOOLEAN
4553 NTAPI
4554 PsGetVersion(
4555   PULONG  MajorVersion  OPTIONAL,
4556   PULONG  MinorVersion  OPTIONAL,
4557   PULONG  BuildNumber  OPTIONAL,
4558   PUNICODE_STRING  CSDVersion  OPTIONAL);
4559
4560 NTKERNELAPI
4561 NTSTATUS
4562 NTAPI
4563 PsRemoveCreateThreadNotifyRoutine(
4564   IN PCREATE_THREAD_NOTIFY_ROUTINE  NotifyRoutine);
4565
4566 NTKERNELAPI
4567 NTSTATUS
4568 NTAPI
4569 PsRemoveLoadImageNotifyRoutine(
4570   IN PLOAD_IMAGE_NOTIFY_ROUTINE  NotifyRoutine);
4571
4572 NTKERNELAPI
4573 NTSTATUS
4574 NTAPI
4575 PsSetCreateProcessNotifyRoutine(
4576   IN PCREATE_PROCESS_NOTIFY_ROUTINE  NotifyRoutine,
4577   IN BOOLEAN  Remove);
4578
4579 NTKERNELAPI
4580 NTSTATUS
4581 NTAPI
4582 PsSetCreateThreadNotifyRoutine(
4583   IN PCREATE_THREAD_NOTIFY_ROUTINE  NotifyRoutine);
4584
4585 NTKERNELAPI
4586 NTSTATUS
4587 NTAPI
4588 PsSetLoadImageNotifyRoutine(
4589   IN PLOAD_IMAGE_NOTIFY_ROUTINE  NotifyRoutine);
4590
4591 NTKERNELAPI
4592 NTSTATUS
4593 NTAPI
4594 PsTerminateSystemThread(
4595   IN NTSTATUS  ExitStatus);
4596
4597 extern NTSYSAPI PEPROCESS PsInitialSystemProcess;
4598
4599
4600 /** Security reference monitor routines **/
4601
4602 NTKERNELAPI
4603 BOOLEAN
4604 NTAPI
4605 SeAccessCheck(
4606   IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
4607   IN PSECURITY_SUBJECT_CONTEXT  SubjectSecurityContext,
4608   IN BOOLEAN  SubjectContextLocked,
4609   IN ACCESS_MASK  DesiredAccess,
4610   IN ACCESS_MASK  PreviouslyGrantedAccess,
4611   OUT PPRIVILEGE_SET  *Privileges  OPTIONAL,
4612   IN PGENERIC_MAPPING  GenericMapping,
4613   IN KPROCESSOR_MODE  AccessMode,
4614   OUT PACCESS_MASK  GrantedAccess,
4615   OUT PNTSTATUS  AccessStatus);
4616
4617 NTKERNELAPI
4618 NTSTATUS
4619 NTAPI
4620 SeAssignSecurity(
4621   IN PSECURITY_DESCRIPTOR  ParentDescriptor  OPTIONAL,
4622   IN PSECURITY_DESCRIPTOR  ExplicitDescriptor  OPTIONAL,
4623   OUT PSECURITY_DESCRIPTOR  *NewDescriptor,
4624   IN BOOLEAN  IsDirectoryObject,
4625   IN PSECURITY_SUBJECT_CONTEXT  SubjectContext,
4626   IN PGENERIC_MAPPING  GenericMapping,
4627   IN POOL_TYPE  PoolType);
4628
4629 NTKERNELAPI
4630 NTSTATUS
4631 NTAPI
4632 SeAssignSecurityEx(
4633   IN PSECURITY_DESCRIPTOR  ParentDescriptor  OPTIONAL,
4634   IN PSECURITY_DESCRIPTOR  ExplicitDescriptor  OPTIONAL,
4635   OUT PSECURITY_DESCRIPTOR  *NewDescriptor,
4636   IN GUID  *ObjectType  OPTIONAL,
4637   IN BOOLEAN  IsDirectoryObject,
4638   IN ULONG  AutoInheritFlags,
4639   IN PSECURITY_SUBJECT_CONTEXT  SubjectContext,
4640   IN PGENERIC_MAPPING  GenericMapping,
4641   IN POOL_TYPE  PoolType);
4642
4643 NTKERNELAPI
4644 NTSTATUS
4645 NTAPI
4646 SeDeassignSecurity(
4647   IN OUT PSECURITY_DESCRIPTOR  *SecurityDescriptor);
4648
4649 NTKERNELAPI
4650 BOOLEAN
4651 NTAPI
4652 SeSinglePrivilegeCheck(
4653   LUID  PrivilegeValue,
4654   KPROCESSOR_MODE  PreviousMode);
4655
4656 NTKERNELAPI
4657 BOOLEAN
4658 NTAPI
4659 SeValidSecurityDescriptor(
4660   IN ULONG  Length,
4661   IN PSECURITY_DESCRIPTOR  SecurityDescriptor);
4662
4663
4664
4665 /** NtXxx routines **/
4666
4667 NTSYSCALLAPI
4668 NTSTATUS
4669 NTAPI
4670 NtOpenProcess(
4671   OUT PHANDLE  ProcessHandle,
4672   IN ACCESS_MASK  DesiredAccess,
4673   IN POBJECT_ATTRIBUTES  ObjectAttributes,
4674   IN PCLIENT_ID  ClientId  OPTIONAL);
4675
4676 NTSYSCALLAPI
4677 NTSTATUS
4678 NTAPI
4679 NtQueryInformationProcess(
4680   IN HANDLE  ProcessHandle,
4681   IN PROCESSINFOCLASS  ProcessInformationClass,
4682   OUT PVOID  ProcessInformation,
4683   IN ULONG  ProcessInformationLength,
4684   OUT PULONG  ReturnLength OPTIONAL);
4685
4686
4687
4688 /** NtXxx and ZwXxx routines **/
4689
4690 NTSYSAPI
4691 NTSTATUS
4692 NTAPI
4693 ZwCancelTimer(
4694   IN HANDLE  TimerHandle,
4695   OUT PBOOLEAN  CurrentState  OPTIONAL);
4696
4697 NTSYSCALLAPI
4698 NTSTATUS
4699 NTAPI
4700 NtClose(
4701   IN HANDLE  Handle);
4702
4703 NTSYSAPI
4704 NTSTATUS
4705 NTAPI
4706 ZwClose(
4707   IN HANDLE  Handle);
4708
4709 NTSYSAPI
4710 NTSTATUS
4711 NTAPI
4712 ZwCreateDirectoryObject(
4713   OUT PHANDLE  DirectoryHandle,
4714   IN ACCESS_MASK  DesiredAccess,
4715   IN POBJECT_ATTRIBUTES  ObjectAttributes);
4716
4717 NTSYSCALLAPI
4718 NTSTATUS
4719 NTAPI
4720 NtCreateEvent(
4721   OUT PHANDLE  EventHandle,
4722   IN ACCESS_MASK  DesiredAccess,
4723   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
4724   IN EVENT_TYPE  EventType,
4725   IN BOOLEAN  InitialState);
4726
4727 NTSYSAPI
4728 NTSTATUS
4729 NTAPI
4730 ZwCreateEvent(
4731   OUT PHANDLE  EventHandle,
4732   IN ACCESS_MASK  DesiredAccess,
4733   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
4734   IN EVENT_TYPE  EventType,
4735   IN BOOLEAN  InitialState);
4736
4737 NTSYSAPI
4738 NTSTATUS
4739 NTAPI
4740 ZwCreateFile(
4741   OUT PHANDLE  FileHandle,
4742   IN ACCESS_MASK  DesiredAccess,
4743   IN POBJECT_ATTRIBUTES  ObjectAttributes,
4744   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4745   IN PLARGE_INTEGER  AllocationSize  OPTIONAL,
4746   IN ULONG  FileAttributes,
4747   IN ULONG  ShareAccess,
4748   IN ULONG  CreateDisposition,
4749   IN ULONG  CreateOptions,
4750   IN PVOID  EaBuffer  OPTIONAL,
4751   IN ULONG  EaLength);
4752
4753 NTSYSAPI
4754 NTSTATUS
4755 NTAPI
4756 ZwCreateKey(
4757   OUT PHANDLE  KeyHandle,
4758   IN ACCESS_MASK  DesiredAccess,
4759   IN POBJECT_ATTRIBUTES  ObjectAttributes,
4760   IN ULONG  TitleIndex,
4761   IN PUNICODE_STRING  Class  OPTIONAL,
4762   IN ULONG  CreateOptions,
4763   OUT PULONG  Disposition  OPTIONAL);
4764
4765 NTSYSAPI
4766 NTSTATUS
4767 NTAPI
4768 ZwCreateTimer(
4769   OUT PHANDLE  TimerHandle,
4770   IN ACCESS_MASK  DesiredAccess,
4771   IN POBJECT_ATTRIBUTES  ObjectAttributes  OPTIONAL,
4772   IN TIMER_TYPE  TimerType);
4773
4774 NTSYSAPI
4775 NTSTATUS
4776 NTAPI
4777 ZwDeleteKey(
4778   IN HANDLE  KeyHandle);
4779
4780 NTSYSAPI
4781 NTSTATUS
4782 NTAPI
4783 ZwDeleteValueKey(
4784   IN HANDLE  KeyHandle,
4785   IN PUNICODE_STRING  ValueName);
4786
4787 NTSYSCALLAPI
4788 NTSTATUS
4789 NTAPI
4790 NtDeviceIoControlFile(
4791   IN HANDLE  DeviceHandle,
4792   IN HANDLE  Event  OPTIONAL,
4793   IN PIO_APC_ROUTINE  UserApcRoutine  OPTIONAL,
4794   IN PVOID  UserApcContext  OPTIONAL,
4795   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4796   IN ULONG  IoControlCode,
4797   IN PVOID  InputBuffer,
4798   IN ULONG  InputBufferSize,
4799   OUT PVOID  OutputBuffer,
4800   IN ULONG  OutputBufferSize);
4801
4802 NTSYSAPI
4803 NTSTATUS
4804 NTAPI
4805 ZwDeviceIoControlFile(
4806   IN HANDLE  DeviceHandle,
4807   IN HANDLE  Event  OPTIONAL,
4808   IN PIO_APC_ROUTINE  UserApcRoutine  OPTIONAL,
4809   IN PVOID  UserApcContext  OPTIONAL,
4810   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4811   IN ULONG  IoControlCode,
4812   IN PVOID  InputBuffer,
4813   IN ULONG  InputBufferSize,
4814   OUT PVOID  OutputBuffer,
4815   IN ULONG  OutputBufferSize);
4816
4817 NTSYSAPI
4818 NTSTATUS
4819 NTAPI
4820 ZwEnumerateKey(
4821   IN HANDLE  KeyHandle,
4822   IN ULONG  Index,
4823   IN KEY_INFORMATION_CLASS  KeyInformationClass,
4824   OUT PVOID  KeyInformation,
4825   IN ULONG  Length,
4826   OUT PULONG  ResultLength);
4827
4828 NTSYSAPI
4829 NTSTATUS
4830 NTAPI
4831 ZwEnumerateValueKey(
4832   IN HANDLE  KeyHandle,
4833   IN ULONG  Index,
4834   IN KEY_VALUE_INFORMATION_CLASS  KeyValueInformationClass,
4835   OUT PVOID  KeyValueInformation,
4836   IN ULONG  Length,
4837   OUT PULONG  ResultLength);
4838
4839 NTSYSAPI
4840 NTSTATUS
4841 NTAPI
4842 ZwFlushKey(
4843   IN HANDLE  KeyHandle);
4844
4845 NTSYSAPI
4846 NTSTATUS
4847 NTAPI
4848 ZwMakeTemporaryObject(
4849   IN HANDLE  Handle);
4850
4851 NTSYSCALLAPI
4852 NTSTATUS
4853 NTAPI
4854 NtMapViewOfSection(
4855   IN HANDLE  SectionHandle,
4856   IN HANDLE  ProcessHandle,
4857   IN OUT PVOID  *BaseAddress,
4858   IN ULONG_PTR  ZeroBits,
4859   IN SIZE_T  CommitSize,
4860   IN OUT PLARGE_INTEGER  SectionOffset  OPTIONAL,
4861   IN OUT PSIZE_T  ViewSize,
4862   IN SECTION_INHERIT  InheritDisposition,
4863   IN ULONG  AllocationType,
4864   IN ULONG  Protect);
4865
4866 NTSYSAPI
4867 NTSTATUS
4868 NTAPI
4869 ZwMapViewOfSection(
4870   IN HANDLE  SectionHandle,
4871   IN HANDLE  ProcessHandle,
4872   IN OUT PVOID  *BaseAddress,
4873   IN ULONG_PTR  ZeroBits,
4874   IN SIZE_T  CommitSize,
4875   IN OUT PLARGE_INTEGER  SectionOffset  OPTIONAL,
4876   IN OUT PSIZE_T  ViewSize,
4877   IN SECTION_INHERIT  InheritDisposition,
4878   IN ULONG  AllocationType,
4879   IN ULONG  Protect);
4880
4881 NTSYSCALLAPI
4882 NTSTATUS
4883 NTAPI
4884 NtOpenFile(
4885   OUT PHANDLE  FileHandle,
4886   IN ACCESS_MASK  DesiredAccess,
4887   IN POBJECT_ATTRIBUTES  ObjectAttributes,
4888   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4889   IN ULONG  ShareAccess,
4890   IN ULONG  OpenOptions);
4891
4892 NTSYSAPI
4893 NTSTATUS
4894 NTAPI
4895 ZwOpenFile(
4896   OUT PHANDLE  FileHandle,
4897   IN ACCESS_MASK  DesiredAccess,
4898   IN POBJECT_ATTRIBUTES  ObjectAttributes,
4899   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4900   IN ULONG  ShareAccess,
4901   IN ULONG  OpenOptions);
4902
4903 NTSYSAPI
4904 NTSTATUS
4905 NTAPI
4906 ZwOpenKey(
4907   OUT PHANDLE  KeyHandle,
4908   IN ACCESS_MASK  DesiredAccess,
4909   IN POBJECT_ATTRIBUTES  ObjectAttributes);
4910
4911 NTSYSAPI
4912 NTSTATUS
4913 NTAPI
4914 ZwOpenSection(
4915   OUT PHANDLE  SectionHandle,
4916   IN ACCESS_MASK  DesiredAccess,
4917   IN POBJECT_ATTRIBUTES  ObjectAttributes);
4918
4919 NTSYSAPI
4920 NTSTATUS
4921 NTAPI
4922 ZwOpenSymbolicLinkObject(
4923   OUT PHANDLE  LinkHandle,
4924   IN ACCESS_MASK  DesiredAccess,
4925   IN POBJECT_ATTRIBUTES  ObjectAttributes);
4926
4927 NTSYSAPI
4928 NTSTATUS
4929 NTAPI
4930 ZwOpenTimer(
4931   OUT PHANDLE  TimerHandle,
4932   IN ACCESS_MASK  DesiredAccess,
4933   IN POBJECT_ATTRIBUTES  ObjectAttributes);
4934
4935 NTSYSAPI
4936 NTSTATUS
4937 NTAPI
4938 ZwQueryInformationFile(
4939   IN HANDLE  FileHandle,
4940   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4941   OUT PVOID  FileInformation,
4942   IN ULONG  Length,
4943   IN FILE_INFORMATION_CLASS  FileInformationClass);
4944
4945 NTSYSAPI
4946 NTSTATUS
4947 NTAPI
4948 ZwQueryKey(
4949   IN HANDLE  KeyHandle,
4950   IN KEY_INFORMATION_CLASS  KeyInformationClass,
4951   OUT PVOID  KeyInformation,
4952   IN ULONG  Length,
4953   OUT PULONG  ResultLength);
4954
4955 NTSYSAPI
4956 NTSTATUS
4957 NTAPI
4958 ZwQuerySymbolicLinkObject(
4959   IN HANDLE  LinkHandle,
4960   IN OUT PUNICODE_STRING  LinkTarget,
4961   OUT PULONG  ReturnedLength  OPTIONAL);
4962
4963 NTSYSAPI
4964 NTSTATUS
4965 NTAPI
4966 ZwQueryValueKey(
4967   IN HANDLE  KeyHandle,
4968   IN PUNICODE_STRING  ValueName,
4969   IN KEY_VALUE_INFORMATION_CLASS  KeyValueInformationClass,
4970   OUT PVOID  KeyValueInformation,
4971   IN ULONG  Length,
4972   OUT PULONG  ResultLength);
4973
4974 NTSYSCALLAPI
4975 NTSTATUS
4976 NTAPI
4977 NtReadFile(
4978   IN HANDLE  FileHandle,
4979   IN HANDLE  Event  OPTIONAL,
4980   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
4981   IN PVOID  ApcContext  OPTIONAL,
4982   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4983   OUT PVOID  Buffer,
4984   IN ULONG  Length,
4985   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
4986   IN PULONG  Key  OPTIONAL);
4987
4988 NTSYSAPI
4989 NTSTATUS
4990 NTAPI
4991 ZwReadFile(
4992   IN HANDLE  FileHandle,
4993   IN HANDLE  Event  OPTIONAL,
4994   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
4995   IN PVOID  ApcContext  OPTIONAL,
4996   OUT PIO_STATUS_BLOCK  IoStatusBlock,
4997   OUT PVOID  Buffer,
4998   IN ULONG  Length,
4999   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
5000   IN PULONG  Key  OPTIONAL);
5001
5002 NTSYSCALLAPI
5003 NTSTATUS
5004 NTAPI
5005 NtSetEvent(
5006   IN HANDLE  EventHandle,
5007   OUT PLONG  PreviousState  OPTIONAL);
5008
5009 NTSYSAPI
5010 NTSTATUS
5011 NTAPI
5012 ZwSetEvent(
5013   IN HANDLE  EventHandle,
5014   OUT PLONG  PreviousState  OPTIONAL);
5015
5016 NTSYSAPI
5017 NTSTATUS
5018 NTAPI
5019 ZwSetInformationFile(
5020   IN HANDLE  FileHandle,
5021   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5022   IN PVOID  FileInformation,
5023   IN ULONG  Length,
5024   IN FILE_INFORMATION_CLASS  FileInformationClass);
5025
5026 NTSYSAPI
5027 NTSTATUS
5028 NTAPI
5029 ZwSetInformationThread(
5030   IN HANDLE  ThreadHandle,
5031   IN THREADINFOCLASS  ThreadInformationClass,
5032   IN PVOID  ThreadInformation,
5033   IN ULONG  ThreadInformationLength);
5034
5035 NTSYSAPI
5036 NTSTATUS
5037 NTAPI
5038 ZwSetTimer(
5039   IN HANDLE  TimerHandle,
5040   IN PLARGE_INTEGER  DueTime,
5041   IN PTIMER_APC_ROUTINE  TimerApcRoutine  OPTIONAL,
5042   IN PVOID  TimerContext  OPTIONAL,
5043   IN BOOLEAN  WakeTimer,
5044   IN LONG  Period  OPTIONAL,
5045   OUT PBOOLEAN  PreviousState  OPTIONAL);
5046
5047 NTSYSAPI
5048 NTSTATUS
5049 NTAPI
5050 ZwSetValueKey(
5051   IN HANDLE  KeyHandle,
5052   IN PUNICODE_STRING  ValueName,
5053   IN ULONG  TitleIndex  OPTIONAL,
5054   IN ULONG  Type,
5055   IN PVOID  Data,
5056   IN ULONG  DataSize);
5057
5058 /* [Nt|Zw]MapViewOfSection.InheritDisposition constants */
5059 #define AT_EXTENDABLE_FILE                0x00002000
5060 #define AT_RESERVED                       0x20000000
5061 #define AT_ROUND_TO_PAGE                  0x40000000
5062
5063 NTSYSCALLAPI
5064 NTSTATUS
5065 NTAPI
5066 NtUnmapViewOfSection(
5067   IN HANDLE  ProcessHandle,
5068   IN PVOID  BaseAddress);
5069
5070 NTSYSAPI
5071 NTSTATUS
5072 NTAPI
5073 ZwUnmapViewOfSection(
5074   IN HANDLE  ProcessHandle,
5075   IN PVOID  BaseAddress);
5076
5077 NTSYSCALLAPI
5078 NTSTATUS
5079 NTAPI
5080 NtWaitForSingleObject(
5081   IN HANDLE  ObjectHandle,
5082   IN BOOLEAN  Alertable,
5083   IN PLARGE_INTEGER  TimeOut  OPTIONAL);
5084
5085 NTSYSAPI
5086 NTSTATUS
5087 NTAPI
5088 ZwWaitForSingleObject(
5089   IN HANDLE  ObjectHandle,
5090   IN BOOLEAN  Alertable,
5091   IN PLARGE_INTEGER  TimeOut  OPTIONAL);
5092
5093 NTSYSCALLAPI
5094 NTSTATUS
5095 NTAPI
5096 NtWriteFile(
5097   IN HANDLE  FileHandle,
5098   IN HANDLE  Event  OPTIONAL,
5099   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
5100   IN PVOID  ApcContext  OPTIONAL,
5101   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5102   IN PVOID  Buffer,
5103   IN ULONG  Length,
5104   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
5105   IN PULONG  Key  OPTIONAL);
5106
5107 NTSYSAPI
5108 NTSTATUS
5109 NTAPI
5110 ZwWriteFile(
5111   IN HANDLE  FileHandle,
5112   IN HANDLE  Event  OPTIONAL,
5113   IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
5114   IN PVOID  ApcContext  OPTIONAL,
5115   OUT PIO_STATUS_BLOCK  IoStatusBlock,
5116   IN PVOID  Buffer,
5117   IN ULONG  Length,
5118   IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
5119   IN PULONG  Key  OPTIONAL);
5120
5121
5122
5123 /** Power management support routines **/
5124
5125 NTKERNELAPI
5126 NTSTATUS
5127 NTAPI
5128 PoCallDriver(
5129   IN PDEVICE_OBJECT  DeviceObject,
5130   IN OUT PIRP  Irp);
5131
5132 NTKERNELAPI
5133 PULONG
5134 NTAPI
5135 PoRegisterDeviceForIdleDetection(
5136   IN PDEVICE_OBJECT  DeviceObject,
5137   IN ULONG  ConservationIdleTime,
5138   IN ULONG  PerformanceIdleTime,
5139   IN DEVICE_POWER_STATE  State);
5140
5141 NTKERNELAPI
5142 PVOID
5143 NTAPI
5144 PoRegisterSystemState(
5145   IN PVOID  StateHandle,
5146   IN EXECUTION_STATE  Flags);
5147
5148 NTKERNELAPI
5149 NTSTATUS
5150 NTAPI
5151 PoRequestPowerIrp(
5152   IN PDEVICE_OBJECT  DeviceObject,
5153   IN UCHAR  MinorFunction,
5154   IN POWER_STATE  PowerState,
5155   IN PREQUEST_POWER_COMPLETE  CompletionFunction,
5156   IN PVOID  Context,
5157   OUT PIRP  *Irp OPTIONAL);
5158
5159 NTKERNELAPI
5160 NTSTATUS
5161 NTAPI
5162 PoRequestShutdownEvent(
5163   OUT PVOID  *Event);
5164
5165 NTKERNELAPI
5166 VOID
5167 NTAPI
5168 PoSetDeviceBusy(
5169   PULONG  IdlePointer);
5170
5171 #define PoSetDeviceBusy(IdlePointer) \
5172  ((void)(*(IdlePointer) = 0))
5173
5174 NTKERNELAPI
5175 POWER_STATE
5176 NTAPI
5177 PoSetPowerState(
5178   IN PDEVICE_OBJECT  DeviceObject,
5179   IN POWER_STATE_TYPE  Type,
5180   IN POWER_STATE  State);
5181
5182 NTKERNELAPI
5183 VOID
5184 NTAPI
5185 PoSetSystemState(
5186   IN EXECUTION_STATE  Flags);
5187
5188 NTKERNELAPI
5189 VOID
5190 NTAPI
5191 PoStartNextPowerIrp(
5192   IN PIRP  Irp);
5193
5194 NTKERNELAPI
5195 VOID
5196 NTAPI
5197 PoUnregisterSystemState(
5198   IN PVOID  StateHandle);
5199
5200
5201
5202 /** WMI library support routines **/
5203
5204 NTSTATUS
5205 NTAPI
5206 WmiCompleteRequest(
5207   IN PDEVICE_OBJECT  DeviceObject,
5208   IN PIRP  Irp,
5209   IN NTSTATUS  Status,
5210   IN ULONG  BufferUsed,
5211   IN CCHAR  PriorityBoost);
5212
5213 NTSTATUS
5214 NTAPI
5215 WmiFireEvent(
5216   IN PDEVICE_OBJECT  DeviceObject,
5217   IN LPGUID  Guid,
5218   IN ULONG  InstanceIndex,
5219   IN ULONG  EventDataSize,
5220   IN PVOID  EventData);
5221
5222 NTKERNELAPI
5223 NTSTATUS
5224 NTAPI
5225 WmiQueryTraceInformation(
5226   IN TRACE_INFORMATION_CLASS  TraceInformationClass,
5227   OUT PVOID  TraceInformation,
5228   IN ULONG  TraceInformationLength,
5229   OUT PULONG  RequiredLength OPTIONAL,
5230   IN PVOID  Buffer OPTIONAL);
5231
5232 NTSTATUS
5233 NTAPI
5234 WmiSystemControl(
5235   IN PWMILIB_CONTEXT  WmiLibInfo,
5236   IN PDEVICE_OBJECT  DeviceObject,
5237   IN PIRP  Irp,
5238   OUT PSYSCTL_IRP_DISPOSITION  IrpDisposition);
5239
5240 NTKERNELAPI
5241 NTSTATUS
5242 DDKCDECLAPI
5243 WmiTraceMessage(
5244   IN TRACEHANDLE  LoggerHandle,
5245   IN ULONG  MessageFlags,
5246   IN LPGUID  MessageGuid,
5247   IN USHORT  MessageNumber,
5248   IN ...);
5249
5250 #if 0
5251 /* FIXME: Get va_list from where? */
5252 NTKERNELAPI
5253 NTSTATUS
5254 DDKCDECLAPI
5255 WmiTraceMessageVa(
5256   IN TRACEHANDLE  LoggerHandle,
5257   IN ULONG  MessageFlags,
5258   IN LPGUID  MessageGuid,
5259   IN USHORT  MessageNumber,
5260   IN va_list  MessageArgList);
5261 #endif
5262
5263
5264 /** Kernel debugger routines **/
5265
5266 NTKERNELAPI
5267 NTSTATUS
5268 NTAPI
5269 KdDisableDebugger(
5270   VOID);
5271
5272 NTKERNELAPI
5273 NTSTATUS
5274 NTAPI
5275 KdEnableDebugger(
5276   VOID);
5277
5278 NTKERNELAPI
5279 BOOLEAN
5280 NTAPI
5281 KdRefreshDebuggerNotPresent(
5282     VOID
5283 );
5284
5285 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
5286 NTKERNELAPI
5287 NTSTATUS
5288 NTAPI
5289 KdChangeOption(
5290   IN KD_OPTION Option,
5291   IN ULONG InBufferBytes OPTIONAL,
5292   IN PVOID InBuffer,
5293   IN ULONG OutBufferBytes OPTIONAL,
5294   OUT PVOID OutBuffer,
5295   OUT PULONG OutBufferNeeded OPTIONAL);
5296 #endif
5297
5298 VOID
5299 NTAPI
5300 DbgBreakPoint(
5301   VOID);
5302
5303 NTSYSAPI
5304 VOID
5305 NTAPI
5306 DbgBreakPointWithStatus(
5307   IN ULONG  Status);
5308
5309 ULONG
5310 DDKCDECLAPI
5311 DbgPrint(
5312   IN PCCH  Format,
5313   IN ...);
5314
5315 NTSYSAPI
5316 ULONG
5317 DDKCDECLAPI
5318 DbgPrintEx(
5319   IN ULONG  ComponentId,
5320   IN ULONG  Level,
5321   IN PCCH  Format,
5322   IN ...);
5323
5324 ULONG
5325 NTAPI
5326 vDbgPrintEx(
5327   IN ULONG ComponentId,
5328   IN ULONG Level,
5329   IN PCCH Format,
5330   IN va_list ap);
5331
5332 ULONG
5333 NTAPI
5334 vDbgPrintExWithPrefix(
5335   IN PCCH Prefix,
5336   IN ULONG ComponentId,
5337   IN ULONG Level,
5338   IN PCCH Format,
5339   IN va_list ap);
5340
5341 NTKERNELAPI
5342 ULONG
5343 DDKCDECLAPI
5344 DbgPrintReturnControlC(
5345   IN PCCH  Format,
5346   IN ...);
5347
5348 ULONG
5349 NTAPI
5350 DbgPrompt(
5351     IN PCCH Prompt,
5352     OUT PCH Response,
5353     IN ULONG MaximumResponseLength
5354 );
5355
5356 NTKERNELAPI
5357 NTSTATUS
5358 NTAPI
5359 DbgQueryDebugFilterState(
5360   IN ULONG  ComponentId,
5361   IN ULONG  Level);
5362
5363 NTKERNELAPI
5364 NTSTATUS
5365 NTAPI
5366 DbgSetDebugFilterState(
5367   IN ULONG  ComponentId,
5368   IN ULONG  Level,
5369   IN BOOLEAN  State);
5370
5371 #if DBG
5372
5373 #define KdPrint(_x_) DbgPrint _x_
5374 #define KdPrintEx(_x_) DbgPrintEx _x_
5375 #define KdBreakPoint() DbgBreakPoint()
5376 #define KdBreakPointWithStatus(s) DbgBreakPointWithStatus(s)
5377
5378 #else /* !DBG */
5379
5380 #define KdPrint(_x_)
5381 #define KdPrintEx(_x_)
5382 #define KdBreakPoint()
5383 #define KdBreakPointWithStatus(s)
5384
5385 #endif /* !DBG */
5386
5387 #if defined(__GNUC__)
5388
5389 extern NTKERNELAPI BOOLEAN KdDebuggerNotPresent;
5390 extern NTKERNELAPI BOOLEAN KdDebuggerEnabled;
5391 #define KD_DEBUGGER_ENABLED     KdDebuggerEnabled
5392 #define KD_DEBUGGER_NOT_PRESENT KdDebuggerNotPresent
5393
5394 #elif defined(_NTDDK_) || defined(_NTHAL_) || defined(_WDMDDK_) || defined(_NTOSP_)
5395
5396 extern NTKERNELAPI PBOOLEAN KdDebuggerNotPresent;
5397 extern NTKERNELAPI PBOOLEAN KdDebuggerEnabled;
5398 #define KD_DEBUGGER_ENABLED     *KdDebuggerEnabled
5399 #define KD_DEBUGGER_NOT_PRESENT *KdDebuggerNotPresent
5400
5401 #else
5402
5403 extern BOOLEAN KdDebuggerNotPresent;
5404 extern BOOLEAN KdDebuggerEnabled;
5405 #define KD_DEBUGGER_ENABLED     KdDebuggerEnabled
5406 #define KD_DEBUGGER_NOT_PRESENT KdDebuggerNotPresent
5407
5408 #endif
5409
5410 /** Stuff from winnt4.h */
5411
5412 #ifndef DMA_MACROS_DEFINED
5413
5414 #if (NTDDI_VERSION >= NTDDI_WIN2K)
5415
5416 //DECLSPEC_DEPRECATED_DDK
5417 NTHALAPI
5418 BOOLEAN
5419 NTAPI
5420 IoFlushAdapterBuffers(
5421     IN PADAPTER_OBJECT AdapterObject,
5422     IN PMDL Mdl,
5423     IN PVOID MapRegisterBase,
5424     IN PVOID CurrentVa,
5425     IN ULONG Length,
5426     IN BOOLEAN WriteToDevice);
5427
5428 //DECLSPEC_DEPRECATED_DDK
5429 NTHALAPI
5430 VOID
5431 NTAPI
5432 IoFreeAdapterChannel(
5433     IN PADAPTER_OBJECT AdapterObject);
5434
5435 //DECLSPEC_DEPRECATED_DDK
5436 NTHALAPI
5437 VOID
5438 NTAPI
5439 IoFreeMapRegisters(
5440     IN PADAPTER_OBJECT AdapterObject,
5441     IN PVOID MapRegisterBase,
5442     IN ULONG NumberOfMapRegisters);
5443
5444 //DECLSPEC_DEPRECATED_DDK
5445 NTHALAPI
5446 PHYSICAL_ADDRESS
5447 NTAPI
5448 IoMapTransfer(
5449     IN PADAPTER_OBJECT AdapterObject,
5450     IN PMDL Mdl,
5451     IN PVOID MapRegisterBase,
5452     IN PVOID CurrentVa,
5453     IN OUT PULONG Length,
5454     IN BOOLEAN WriteToDevice);
5455
5456
5457 #endif // (NTDDI_VERSION >= NTDDI_WIN2K)
5458 #endif // !defined(DMA_MACROS_DEFINED)
5459
5460 NTKERNELAPI
5461 NTSTATUS
5462 NTAPI
5463 IoAssignResources(
5464   IN PUNICODE_STRING  RegistryPath,
5465   IN PUNICODE_STRING  DriverClassName  OPTIONAL,
5466   IN PDRIVER_OBJECT  DriverObject,
5467   IN PDEVICE_OBJECT  DeviceObject  OPTIONAL,
5468   IN PIO_RESOURCE_REQUIREMENTS_LIST  RequestedResources,
5469   IN OUT PCM_RESOURCE_LIST  *AllocatedResources);
5470
5471 NTKERNELAPI
5472 NTSTATUS
5473 NTAPI
5474 IoAttachDeviceByPointer(
5475   IN PDEVICE_OBJECT  SourceDevice,
5476   IN PDEVICE_OBJECT  TargetDevice);
5477
5478 NTKERNELAPI
5479 BOOLEAN
5480 NTAPI
5481 MmIsNonPagedSystemAddressValid(
5482   IN PVOID  VirtualAddress);
5483
5484 #if defined(_AMD64_) || defined(_IA64_)
5485 //DECLSPEC_DEPRECATED_DDK_WINXP
5486 static __inline
5487 LARGE_INTEGER
5488 NTAPI_INLINE
5489 RtlLargeIntegerDivide(
5490     IN LARGE_INTEGER Dividend,
5491     IN LARGE_INTEGER Divisor,
5492     IN OUT PLARGE_INTEGER Remainder)
5493 {
5494     LARGE_INTEGER ret;
5495     ret.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
5496     if (Remainder)
5497         Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
5498     return ret;
5499 }
5500 #else
5501 NTSYSAPI
5502 LARGE_INTEGER
5503 NTAPI
5504 RtlLargeIntegerDivide(
5505   IN LARGE_INTEGER  Dividend,
5506   IN LARGE_INTEGER  Divisor,
5507   IN OUT PLARGE_INTEGER  Remainder);
5508 #endif
5509
5510 NTKERNELAPI
5511 INTERLOCKED_RESULT
5512 NTAPI
5513 ExInterlockedDecrementLong(
5514   IN PLONG  Addend,
5515   IN PKSPIN_LOCK  Lock);
5516
5517 NTKERNELAPI
5518 ULONG
5519 NTAPI
5520 ExInterlockedExchangeUlong(
5521   IN PULONG  Target,
5522   IN ULONG  Value,
5523   IN PKSPIN_LOCK  Lock);
5524
5525 NTKERNELAPI
5526 INTERLOCKED_RESULT
5527 NTAPI
5528 ExInterlockedIncrementLong(
5529   IN PLONG  Addend,
5530   IN PKSPIN_LOCK  Lock);
5531
5532 NTHALAPI
5533 VOID
5534 NTAPI
5535 HalAcquireDisplayOwnership(
5536   IN PHAL_RESET_DISPLAY_PARAMETERS  ResetDisplayParameters);
5537
5538 NTHALAPI
5539 NTSTATUS
5540 NTAPI
5541 HalAllocateAdapterChannel(
5542   IN PADAPTER_OBJECT  AdapterObject,
5543   IN PWAIT_CONTEXT_BLOCK  Wcb,
5544   IN ULONG  NumberOfMapRegisters,
5545   IN PDRIVER_CONTROL  ExecutionRoutine);
5546
5547 NTHALAPI
5548 PVOID
5549 NTAPI
5550 HalAllocateCommonBuffer(
5551   IN PADAPTER_OBJECT  AdapterObject,
5552   IN ULONG  Length,
5553   OUT PPHYSICAL_ADDRESS  LogicalAddress,
5554   IN BOOLEAN  CacheEnabled);
5555
5556 NTHALAPI
5557 NTSTATUS
5558 NTAPI
5559 HalAssignSlotResources(
5560   IN PUNICODE_STRING  RegistryPath,
5561   IN PUNICODE_STRING  DriverClassName,
5562   IN PDRIVER_OBJECT  DriverObject,
5563   IN PDEVICE_OBJECT  DeviceObject,
5564   IN INTERFACE_TYPE  BusType,
5565   IN ULONG  BusNumber,
5566   IN ULONG  SlotNumber,
5567   IN OUT PCM_RESOURCE_LIST  *AllocatedResources);
5568
5569 NTHALAPI
5570 VOID
5571 NTAPI
5572 HalFreeCommonBuffer(
5573   IN PADAPTER_OBJECT  AdapterObject,
5574   IN ULONG  Length,
5575   IN PHYSICAL_ADDRESS  LogicalAddress,
5576   IN PVOID  VirtualAddress,
5577   IN BOOLEAN  CacheEnabled);
5578
5579 NTHALAPI
5580 PADAPTER_OBJECT
5581 NTAPI
5582 HalGetAdapter(
5583   IN PDEVICE_DESCRIPTION  DeviceDescription,
5584   IN OUT PULONG  NumberOfMapRegisters);
5585
5586 NTHALAPI
5587 ULONG
5588 NTAPI
5589 HalGetBusData(
5590   IN BUS_DATA_TYPE  BusDataType,
5591   IN ULONG  BusNumber,
5592   IN ULONG  SlotNumber,
5593   IN PVOID  Buffer,
5594   IN ULONG  Length);
5595
5596 NTHALAPI
5597 ULONG
5598 NTAPI
5599 HalGetBusDataByOffset(
5600   IN BUS_DATA_TYPE  BusDataType,
5601   IN ULONG  BusNumber,
5602   IN ULONG  SlotNumber,
5603   IN PVOID  Buffer,
5604   IN ULONG  Offset,
5605   IN ULONG  Length);
5606
5607 NTHALAPI
5608 ULONG
5609 NTAPI
5610 HalGetDmaAlignmentRequirement(
5611   VOID);
5612
5613 NTHALAPI
5614 ULONG
5615 NTAPI
5616 HalGetInterruptVector(
5617   IN INTERFACE_TYPE  InterfaceType,
5618   IN ULONG  BusNumber,
5619   IN ULONG  BusInterruptLevel,
5620   IN ULONG  BusInterruptVector,
5621   OUT PKIRQL  Irql,
5622   OUT PKAFFINITY  Affinity);
5623
5624 NTHALAPI
5625 ULONG
5626 NTAPI
5627 HalReadDmaCounter(
5628   IN PADAPTER_OBJECT  AdapterObject);
5629
5630 NTHALAPI
5631 ULONG
5632 NTAPI
5633 HalSetBusData(
5634   IN BUS_DATA_TYPE  BusDataType,
5635   IN ULONG  BusNumber,
5636   IN ULONG  SlotNumber,
5637   IN PVOID  Buffer,
5638   IN ULONG  Length);
5639
5640 NTHALAPI
5641 ULONG
5642 NTAPI
5643 HalSetBusDataByOffset(
5644   IN BUS_DATA_TYPE  BusDataType,
5645   IN ULONG  BusNumber,
5646   IN ULONG  SlotNumber,
5647   IN PVOID  Buffer,
5648   IN ULONG  Offset,
5649   IN ULONG  Length);
5650
5651 NTHALAPI
5652 BOOLEAN
5653 NTAPI
5654 HalTranslateBusAddress(
5655   IN INTERFACE_TYPE  InterfaceType,
5656   IN ULONG  BusNumber,
5657   IN PHYSICAL_ADDRESS  BusAddress,
5658   IN OUT PULONG  AddressSpace,
5659   OUT PPHYSICAL_ADDRESS  TranslatedAddress);
5660
5661 NTSYSAPI
5662 BOOLEAN
5663 NTAPI
5664 RtlLargeIntegerEqualToZero(
5665   IN LARGE_INTEGER  Operand);
5666
5667 NTSYSAPI
5668 BOOLEAN
5669 NTAPI
5670 RtlLargeIntegerGreaterOrEqualToZero(
5671   IN LARGE_INTEGER  Operand);
5672
5673 NTSYSAPI
5674 BOOLEAN
5675 NTAPI
5676 RtlLargeIntegerGreaterThan(
5677   IN LARGE_INTEGER  Operand1,
5678   IN LARGE_INTEGER  Operand2);
5679
5680 NTSYSAPI
5681 BOOLEAN
5682 NTAPI
5683 RtlLargeIntegerGreaterThanOrEqualTo(
5684   IN LARGE_INTEGER  Operand1,
5685   IN LARGE_INTEGER  Operand2);
5686
5687 NTSYSAPI
5688 BOOLEAN
5689 NTAPI
5690 RtlLargeIntegerGreaterThanZero(
5691   IN LARGE_INTEGER  Operand);
5692
5693 NTSYSAPI
5694 BOOLEAN
5695 NTAPI
5696 RtlLargeIntegerLessOrEqualToZero(
5697   IN LARGE_INTEGER  Operand);
5698
5699 NTSYSAPI
5700 BOOLEAN
5701 NTAPI
5702 RtlLargeIntegerLessThan(
5703   IN LARGE_INTEGER  Operand1,
5704   IN LARGE_INTEGER  Operand2);
5705
5706 NTSYSAPI
5707 BOOLEAN
5708 NTAPI
5709 RtlLargeIntegerLessThanOrEqualTo(
5710   IN LARGE_INTEGER  Operand1,
5711   IN LARGE_INTEGER  Operand2);
5712
5713 NTSYSAPI
5714 BOOLEAN
5715 NTAPI
5716 RtlLargeIntegerLessThanZero(
5717   IN LARGE_INTEGER  Operand);
5718
5719 NTSYSAPI
5720 LARGE_INTEGER
5721 NTAPI
5722 RtlLargeIntegerNegate(
5723   IN LARGE_INTEGER  Subtrahend);
5724
5725 NTSYSAPI
5726 BOOLEAN
5727 NTAPI
5728 RtlLargeIntegerNotEqualTo(
5729   IN LARGE_INTEGER  Operand1,
5730   IN LARGE_INTEGER  Operand2);
5731
5732 NTSYSAPI
5733 BOOLEAN
5734 NTAPI
5735 RtlLargeIntegerNotEqualToZero(
5736   IN LARGE_INTEGER  Operand);
5737
5738 NTSYSAPI
5739 LARGE_INTEGER
5740 NTAPI
5741 RtlLargeIntegerShiftLeft(
5742   IN LARGE_INTEGER  LargeInteger,
5743   IN CCHAR  ShiftCount);
5744
5745 NTSYSAPI
5746 LARGE_INTEGER
5747 NTAPI
5748 RtlLargeIntegerShiftRight(
5749   IN LARGE_INTEGER  LargeInteger,
5750   IN CCHAR  ShiftCount);
5751
5752 NTSYSAPI
5753 LARGE_INTEGER
5754 NTAPI
5755 RtlLargeIntegerSubtract(
5756   IN LARGE_INTEGER  Minuend,
5757   IN LARGE_INTEGER  Subtrahend);
5758
5759
5760 /*
5761  * ULONG
5762  * COMPUTE_PAGES_SPANNED(
5763  *   IN PVOID  Va,
5764  *   IN ULONG  Size)
5765  */
5766 #define COMPUTE_PAGES_SPANNED(Va, \
5767                               Size) \
5768   (ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va, Size))
5769
5770
5771 /*
5772 ** Architecture specific structures
5773 */
5774
5775 #ifdef _X86_
5776
5777 NTKERNELAPI
5778 INTERLOCKED_RESULT
5779 FASTCALL
5780 Exfi386InterlockedIncrementLong(
5781   IN PLONG  Addend);
5782
5783 NTKERNELAPI
5784 INTERLOCKED_RESULT
5785 FASTCALL
5786 Exfi386InterlockedDecrementLong(
5787   IN PLONG  Addend);
5788
5789 NTKERNELAPI
5790 ULONG
5791 FASTCALL
5792 Exfi386InterlockedExchangeUlong(
5793   IN PULONG  Target,
5794   IN ULONG  Value);
5795
5796 #define ExInterlockedIncrementLong(Addend,Lock) Exfi386InterlockedIncrementLong(Addend)
5797 #define ExInterlockedDecrementLong(Addend,Lock) Exfi386InterlockedDecrementLong(Addend)
5798 #define ExInterlockedExchangeUlong(Target, Value, Lock) Exfi386InterlockedExchangeUlong(Target, Value)
5799
5800 #endif /* _X86_ */
5801
5802 #ifdef _M_ARM
5803 //
5804 // NT-ARM is not documented
5805 //
5806 #include <armddk.h>
5807 #endif
5808
5809 #ifdef __cplusplus
5810 }
5811 #endif
5812
5813 #endif /* __WINDDK_H */