include/ddk/wdm.h

   1 /*
   2  * Copyright 2004-2005 Ivan Leo Puoti
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef _WDMDDK_
  20 #define _WDMDDK_
  21 #define _NTDDK_
  22
  23 #include <ntstatus.h>
  24
  25 #ifdef _WIN64
  26 #define POINTER_ALIGNMENT DECLSPEC_ALIGN(8)
  27 #else
  28 #define POINTER_ALIGNMENT
  29 #endif
  30
  31 /* FIXME: We suppose that page size is 4096 */
  32 #undef PAGE_SIZE
  33 #define PAGE_SIZE   0x1000
  34 #define PAGE_SHIFT  12
  35
  36 #define BYTE_OFFSET(va) ((ULONG)((ULONG_PTR)(va) & (PAGE_SIZE - 1)))
  37 #define PAGE_ALIGN(va)  ((PVOID)((ULONG_PTR)(va) & ~(PAGE_SIZE - 1)))
  38 #define ADDRESS_AND_SIZE_TO_SPAN_PAGES(va, length) \
  39     ((BYTE_OFFSET(va) + ((SIZE_T)(length)) + (PAGE_SIZE - 1)) >> PAGE_SHIFT)
  40
  41 typedef LONG KPRIORITY;
  42
  43 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;
  44
  45 typedef ULONG_PTR ERESOURCE_THREAD;
  46 typedef ERESOURCE_THREAD *PERESOURCE_THREAD;
  47 typedef struct _FILE_GET_QUOTA_INFORMATION *PFILE_GET_QUOTA_INFORMATION;
  48
  49 struct _KDPC;
  50 struct _KAPC;
  51 struct _IRP;
  52 struct _DEVICE_OBJECT;
  53 struct _DRIVER_OBJECT;
  54
  55 typedef VOID (WINAPI *PKDEFERRED_ROUTINE)(struct _KDPC *, PVOID, PVOID, PVOID);
  56 typedef VOID (WINAPI *PKSTART_ROUTINE)(PVOID);
  57
  58 typedef NTSTATUS (WINAPI *PDRIVER_INITIALIZE)(struct _DRIVER_OBJECT *, PUNICODE_STRING);
  59 typedef NTSTATUS (WINAPI *PDRIVER_DISPATCH)(struct _DEVICE_OBJECT *, struct _IRP *);
  60 typedef void (WINAPI *PDRIVER_STARTIO)(struct _DEVICE_OBJECT *, struct _IRP *);
  61 typedef void (WINAPI *PDRIVER_UNLOAD)(struct _DRIVER_OBJECT *);
  62 typedef NTSTATUS (WINAPI *PDRIVER_ADD_DEVICE)(struct _DRIVER_OBJECT *, struct _DEVICE_OBJECT *);
  63
  64 typedef struct _DISPATCHER_HEADER {
  65   UCHAR  Type;
  66   UCHAR  Absolute;
  67   UCHAR  Size;
  68   UCHAR  Inserted;
  69   LONG  SignalState;
  70   LIST_ENTRY  WaitListHead;
  71 } DISPATCHER_HEADER, *PDISPATCHER_HEADER;
  72
  73 typedef struct _KEVENT {
  74   DISPATCHER_HEADER  Header;
  75 } KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;
  76
  77 typedef struct _KSEMAPHORE {
  78   DISPATCHER_HEADER  Header;
  79   LONG Limit;
  80 } KSEMAPHORE, *PKSEMAPHORE, *PRKSEMAPHORE;
  81
  82 typedef struct _KDPC {
  83   CSHORT  Type;
  84   UCHAR  Number;
  85   UCHAR  Importance;
  86   LIST_ENTRY  DpcListEntry;
  87   PKDEFERRED_ROUTINE  DeferredRoutine;
  88   PVOID  DeferredContext;
  89   PVOID  SystemArgument1;
  90   PVOID  SystemArgument2;
  91   PULONG_PTR  Lock;
  92 } KDPC, *PKDPC, *RESTRICTED_POINTER PRKDPC;
  93
  94 typedef struct _KDEVICE_QUEUE_ENTRY {
  95   LIST_ENTRY  DeviceListEntry;
  96   ULONG  SortKey;
  97   BOOLEAN  Inserted;
  98 } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY,
  99 *RESTRICTED_POINTER PRKDEVICE_QUEUE_ENTRY;
 100
 101 typedef struct _KDEVICE_QUEUE {
 102   CSHORT  Type;
 103   CSHORT  Size;
 104   LIST_ENTRY  DeviceListHead;
 105   KSPIN_LOCK  Lock;
 106   BOOLEAN  Busy;
 107 } KDEVICE_QUEUE, *PKDEVICE_QUEUE, *RESTRICTED_POINTER PRKDEVICE_QUEUE;
 108
 109 typedef struct _KMUTANT {
 110     DISPATCHER_HEADER Header;
 111     LIST_ENTRY MutantListEntry;
 112     struct _KTHREAD *RESTRICTED_POINTER OwnerThread;
 113     BOOLEAN Abandoned;
 114     UCHAR ApcDisable;
 115 } KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT, KMUTEX, *PKMUTEX, *RESTRICTED_POINTER PRKMUTEX;
 116
 117 typedef enum _KWAIT_REASON
 118 {
 119     Executive,
 120     FreePage,
 121     PageIn,
 122     PoolAllocation,
 123     DelayExecution,
 124     Suspended,
 125     UserRequest,
 126     WrExecutive,
 127     WrFreePage,
 128     WrPageIn,
 129     WrDelayExecution,
 130     WrSuspended,
 131     WrUserRequest,
 132     WrQueue,
 133     WrLpcReceive,
 134     WrLpcReply,
 135     WrVirtualMemory,
 136     WrPageOut,
 137     WrRendezvous,
 138     Spare2,
 139     Spare3,
 140     Spare4,
 141     Spare5,
 142     Spare6,
 143     WrKernel,
 144     MaximumWaitReason,
 145 } KWAIT_REASON;
 146
 147 typedef struct _KWAIT_BLOCK {
 148     LIST_ENTRY WaitListEntry;
 149     struct _KTHREAD *RESTRICTED_POINTER Thread;
 150     PVOID Object;
 151     struct _KWAIT_BLOCK *RESTRICTED_POINTER NextWaitBlock;
 152     USHORT WaitKey;
 153     USHORT WaitType;
 154 } KWAIT_BLOCK, *PKWAIT_BLOCK, *RESTRICTED_POINTER PRKWAIT_BLOCK;
 155
 156 typedef struct _OWNER_ENTRY
 157 {
 158     ERESOURCE_THREAD OwnerThread;
 159     union
 160     {
 161         struct
 162         {
 163             ULONG IoPriorityBoosted : 1;
 164             ULONG OwnerReferenced : 1;
 165             ULONG IoQoSPriorityBoosted : 1;
 166             ULONG OwnerCount : 29;
 167         };
 168         ULONG TableSize;
 169     };
 170 } OWNER_ENTRY, *POWNER_ENTRY;
 171
 172 #define ResourceNeverExclusive       0x0010
 173 #define ResourceReleaseByOtherThread 0x0020
 174 #define ResourceOwnedExclusive       0x0080
 175
 176 typedef struct _ERESOURCE
 177 {
 178     LIST_ENTRY SystemResourcesList;
 179     OWNER_ENTRY *OwnerTable;
 180     SHORT ActiveCount;
 181     union
 182     {
 183         USHORT Flag;
 184         struct
 185         {
 186             UCHAR ReservedLowFlags;
 187             UCHAR WaiterPriority;
 188         };
 189     };
 190     KSEMAPHORE *SharedWaiters;
 191     KEVENT *ExclusiveWaiters;
 192     OWNER_ENTRY OwnerEntry;
 193     ULONG ActiveEntries;
 194     ULONG ContentionCount;
 195     ULONG NumberOfSharedWaiters;
 196     ULONG NumberOfExclusiveWaiters;
 197 #ifdef _WIN64
 198     void *Reserved2;
 199 #endif
 200     union
 201     {
 202         void *Address;
 203         ULONG_PTR CreatorBackTraceIndex;
 204     };
 205     KSPIN_LOCK SpinLock;
 206 } ERESOURCE, *PERESOURCE;
 207
 208 typedef struct _IO_TIMER *PIO_TIMER;
 209 typedef struct _IO_TIMER_ROUTINE *PIO_TIMER_ROUTINE;
 210 typedef struct _ETHREAD *PETHREAD;
 211 typedef struct _KTHREAD *PKTHREAD, *PRKTHREAD;
 212 typedef struct _EPROCESS *PEPROCESS;
 213 typedef struct _IO_WORKITEM *PIO_WORKITEM;
 214 typedef struct _PAGED_LOOKASIDE_LIST *PPAGED_LOOKASIDE_LIST;
 215 typedef struct _OBJECT_TYPE *POBJECT_TYPE;
 216 typedef struct _OBJECT_HANDLE_INFORMATION *POBJECT_HANDLE_INFORMATION;
 217 typedef struct _ZONE_HEADER *PZONE_HEADER;
 218 typedef struct _LOOKASIDE_LIST_EX *PLOOKASIDE_LIST_EX;
 219
 220 #define FM_LOCK_BIT 0x1
 221
 222 typedef struct _FAST_MUTEX
 223 {
 224     LONG Count;
 225     PKTHREAD Owner;
 226     ULONG Contention;
 227     KEVENT Event;
 228     ULONG OldIrql;
 229 } FAST_MUTEX, *PFAST_MUTEX;
 230
 231 #define MAXIMUM_VOLUME_LABEL_LENGTH       (32 * sizeof(WCHAR))
 232
 233 typedef struct _VPB {
 234   CSHORT  Type;
 235   CSHORT  Size;
 236   USHORT  Flags;
 237   USHORT  VolumeLabelLength;
 238   struct _DEVICE_OBJECT  *DeviceObject;
 239   struct _DEVICE_OBJECT  *RealDevice;
 240   ULONG  SerialNumber;
 241   ULONG  ReferenceCount;
 242   WCHAR  VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH / sizeof(WCHAR)];
 243 } VPB, *PVPB;
 244
 245 #define POOL_QUOTA_FAIL_INSTEAD_OF_RAISE 0x0008
 246 #define POOL_RAISE_IF_ALLOCATION_FAILURE 0x0010
 247 #define POOL_COLD_ALLOCATION             0x0100
 248 #define POOL_NX_ALLOCATION               0x0200
 249
 250 typedef enum _POOL_TYPE {
 251   NonPagedPool,
 252   PagedPool,
 253   NonPagedPoolMustSucceed,
 254   DontUseThisType,
 255   NonPagedPoolCacheAligned,
 256   PagedPoolCacheAligned,
 257   NonPagedPoolCacheAlignedMustS,
 258   MaxPoolType
 259 } POOL_TYPE;
 260
 261 typedef struct _WAIT_CONTEXT_BLOCK {
 262   KDEVICE_QUEUE_ENTRY  WaitQueueEntry;
 263   struct _DRIVER_CONTROL  *DeviceRoutine;
 264   PVOID  DeviceContext;
 265   ULONG  NumberOfMapRegisters;
 266   PVOID  DeviceObject;
 267   PVOID  CurrentIrp;
 268   PKDPC  BufferChainingDpc;
 269 } WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
 270
 271 #define DO_BUFFERED_IO                  0x00000004
 272 #define DO_EXCLUSIVE                    0x00000008
 273 #define DO_DIRECT_IO                    0x00000010
 274 #define DO_MAP_IO_BUFFER                0x00000020
 275 #define DO_DEVICE_INITIALIZING          0x00000080
 276 #define DO_SHUTDOWN_REGISTERED          0x00000800
 277 #define DO_BUS_ENUMERATED_DEVICE        0x00001000
 278 #define DO_POWER_PAGABLE                0x00002000
 279 #define DO_POWER_INRUSH                 0x00004000
 280
 281 #define IO_NO_INCREMENT                     0
 282 #define IO_CD_ROM_INCREMENT                 1
 283 #define IO_DISK_INCREMENT                   1
 284 #define IO_KEYBOARD_INCREMENT               6
 285 #define IO_MAILSLOT_INCREMENT               2
 286 #define IO_MOUSE_INCREMENT                  6
 287 #define IO_NAMED_PIPE_INCREMENT             2
 288 #define IO_NETWORK_INCREMENT                2
 289 #define IO_PARALLEL_INCREMENT               1
 290 #define IO_SERIAL_INCREMENT                 2
 291 #define IO_SOUND_INCREMENT                  8
 292 #define IO_VIDEO_INCREMENT                  1
 293
 294 #ifndef DEVICE_TYPE
 295 #define DEVICE_TYPE ULONG
 296 #endif
 297 #define IRP_MJ_MAXIMUM_FUNCTION           0x1b
 298 #define IRP_MJ_CREATE                     0x00
 299 #define IRP_MJ_CREATE_NAMED_PIPE          0x01
 300 #define IRP_MJ_CLOSE                      0x02
 301 #define IRP_MJ_READ                       0x03
 302 #define IRP_MJ_WRITE                      0x04
 303 #define IRP_MJ_QUERY_INFORMATION          0x05
 304 #define IRP_MJ_SET_INFORMATION            0x06
 305 #define IRP_MJ_QUERY_EA                   0x07
 306 #define IRP_MJ_SET_EA                     0x08
 307 #define IRP_MJ_FLUSH_BUFFERS              0x09
 308 #define IRP_MJ_QUERY_VOLUME_INFORMATION   0x0a
 309 #define IRP_MJ_SET_VOLUME_INFORMATION     0x0b
 310 #define IRP_MJ_DIRECTORY_CONTROL          0x0c
 311 #define IRP_MJ_FILE_SYSTEM_CONTROL        0x0d
 312 #define IRP_MJ_DEVICE_CONTROL             0x0e
 313 #define IRP_MJ_INTERNAL_DEVICE_CONTROL    0x0f
 314 #define IRP_MJ_SHUTDOWN                   0x10
 315 #define IRP_MJ_LOCK_CONTROL               0x11
 316 #define IRP_MJ_CLEANUP                    0x12
 317 #define IRP_MJ_CREATE_MAILSLOT            0x13
 318 #define IRP_MJ_QUERY_SECURITY             0x14
 319 #define IRP_MJ_SET_SECURITY               0x15
 320 #define IRP_MJ_POWER                      0x16
 321 #define IRP_MJ_SYSTEM_CONTROL             0x17
 322 #define IRP_MJ_DEVICE_CHANGE              0x18
 323 #define IRP_MJ_QUERY_QUOTA                0x19
 324 #define IRP_MJ_SET_QUOTA                  0x1a
 325 #define IRP_MJ_PNP                        0x1b
 326
 327 #define IRP_MN_START_DEVICE                 0x00
 328 #define IRP_MN_QUERY_REMOVE_DEVICE          0x01
 329 #define IRP_MN_REMOVE_DEVICE                0x02
 330 #define IRP_MN_CANCEL_REMOVE_DEVICE         0x03
 331 #define IRP_MN_STOP_DEVICE                  0x04
 332 #define IRP_MN_QUERY_STOP_DEVICE            0x05
 333 #define IRP_MN_CANCEL_STOP_DEVICE           0x06
 334 #define IRP_MN_QUERY_DEVICE_RELATIONS       0x07
 335 #define IRP_MN_QUERY_INTERFACE              0x08
 336 #define IRP_MN_QUERY_CAPABILITIES           0x09
 337 #define IRP_MN_QUERY_RESOURCES              0x0A
 338 #define IRP_MN_QUERY_RESOURCE_REQUIREMENTS  0x0B
 339 #define IRP_MN_QUERY_DEVICE_TEXT            0x0C
 340 #define IRP_MN_FILTER_RESOURCE_REQUIREMENTS 0x0D
 341 #define IRP_MN_READ_CONFIG                  0x0F
 342 #define IRP_MN_WRITE_CONFIG                 0x10
 343 #define IRP_MN_EJECT                        0x11
 344 #define IRP_MN_SET_LOCK                     0x12
 345 #define IRP_MN_QUERY_ID                     0x13
 346 #define IRP_MN_QUERY_PNP_DEVICE_STATE       0x14
 347 #define IRP_MN_QUERY_BUS_INFORMATION        0x15
 348 #define IRP_MN_DEVICE_USAGE_NOTIFICATION    0x16
 349 #define IRP_MN_SURPRISE_REMOVAL             0x17
 350 #define IRP_MN_QUERY_LEGACY_BUS_INFORMATION 0x18
 351
 352 #define IRP_MN_WAIT_WAKE                    0x00
 353 #define IRP_MN_POWER_SEQUENCE               0x01
 354 #define IRP_MN_SET_POWER                    0x02
 355 #define IRP_MN_QUERY_POWER                  0x03
 356
 357 #define IRP_QUOTA_CHARGED               0x01
 358 #define IRP_ALLOCATED_MUST_SUCCEED      0x02
 359 #define IRP_ALLOCATED_FIXED_SIZE        0x04
 360 #define IRP_LOOKASIDE_ALLOCATION        0x08
 361
 362 #define IO_TYPE_ADAPTER                 0x01
 363 #define IO_TYPE_CONTROLLER              0x02
 364 #define IO_TYPE_DEVICE                  0x03
 365 #define IO_TYPE_DRIVER                  0x04
 366 #define IO_TYPE_FILE                    0x05
 367 #define IO_TYPE_IRP                     0x06
 368 #define IO_TYPE_MASTER_ADAPTER          0x07
 369 #define IO_TYPE_OPEN_PACKET             0x08
 370 #define IO_TYPE_TIMER                   0x09
 371 #define IO_TYPE_VPB                     0x0a
 372 #define IO_TYPE_ERROR_LOG               0x0b
 373 #define IO_TYPE_ERROR_MESSAGE           0x0c
 374 #define IO_TYPE_DEVICE_OBJECT_EXTENSION 0x0d
 375
 376 typedef struct _DEVICE_OBJECT {
 377   CSHORT  Type;
 378   USHORT  Size;
 379   LONG  ReferenceCount;
 380   struct _DRIVER_OBJECT  *DriverObject;
 381   struct _DEVICE_OBJECT  *NextDevice;
 382   struct _DEVICE_OBJECT  *AttachedDevice;
 383   struct _IRP  *CurrentIrp;
 384   PIO_TIMER  Timer;
 385   ULONG  Flags;
 386   ULONG  Characteristics;
 387   PVPB  Vpb;
 388   PVOID  DeviceExtension;
 389   DEVICE_TYPE  DeviceType;
 390   CCHAR  StackSize;
 391   union {
 392     LIST_ENTRY  ListEntry;
 393     WAIT_CONTEXT_BLOCK  Wcb;
 394   } Queue;
 395   ULONG  AlignmentRequirement;
 396   KDEVICE_QUEUE  DeviceQueue;
 397   KDPC  Dpc;
 398   ULONG  ActiveThreadCount;
 399   PSECURITY_DESCRIPTOR  SecurityDescriptor;
 400   KEVENT  DeviceLock;
 401   USHORT  SectorSize;
 402   USHORT  Spare1;
 403   struct _DEVOBJ_EXTENSION  *DeviceObjectExtension;
 404   PVOID  Reserved;
 405 } DEVICE_OBJECT;
 406 typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT;
 407
 408 typedef struct _DEVICE_RELATIONS {
 409   ULONG Count;
 410   PDEVICE_OBJECT Objects[1];
 411 } DEVICE_RELATIONS;
 412 typedef struct _DEVICE_RELATIONS *PDEVICE_RELATIONS;
 413
 414 typedef struct _DRIVER_EXTENSION {
 415   struct _DRIVER_OBJECT  *DriverObject;
 416   PDRIVER_ADD_DEVICE AddDevice;
 417   ULONG  Count;
 418   UNICODE_STRING  ServiceKeyName;
 419 } DRIVER_EXTENSION, *PDRIVER_EXTENSION;
 420
 421 typedef struct _DRIVER_OBJECT {
 422   CSHORT  Type;
 423   CSHORT  Size;
 424   PDEVICE_OBJECT  DeviceObject;
 425   ULONG  Flags;
 426   PVOID  DriverStart;
 427   ULONG  DriverSize;
 428   PVOID  DriverSection;
 429   PDRIVER_EXTENSION  DriverExtension;
 430   UNICODE_STRING  DriverName;
 431   PUNICODE_STRING  HardwareDatabase;
 432   PVOID  FastIoDispatch;
 433   PDRIVER_INITIALIZE DriverInit;
 434   PDRIVER_STARTIO    DriverStartIo;
 435   PDRIVER_UNLOAD     DriverUnload;
 436   PDRIVER_DISPATCH   MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
 437 } DRIVER_OBJECT;
 438 typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT;
 439
 440 /* Irp definitions */
 441 typedef UCHAR KIRQL, *PKIRQL;
 442 typedef CCHAR KPROCESSOR_MODE;
 443
 444 typedef VOID (WINAPI *PDRIVER_CANCEL)(
 445   IN struct _DEVICE_OBJECT  *DeviceObject,
 446   IN struct _IRP  *Irp);
 447
 448 typedef VOID (WINAPI *PKNORMAL_ROUTINE)(
 449   IN PVOID  NormalContext,
 450   IN PVOID  SystemArgument1,
 451   IN PVOID  SystemArgument2);
 452
 453 typedef VOID (WINAPI *PKKERNEL_ROUTINE)(
 454   IN struct _KAPC  *Apc,
 455   IN OUT PKNORMAL_ROUTINE  *NormalRoutine,
 456   IN OUT PVOID  *NormalContext,
 457   IN OUT PVOID  *SystemArgument1,
 458   IN OUT PVOID  *SystemArgument2);
 459
 460 typedef VOID (WINAPI *PKRUNDOWN_ROUTINE)(
 461   IN struct _KAPC  *Apc);
 462
 463 typedef struct _KAPC {
 464   CSHORT  Type;
 465   CSHORT  Size;
 466   ULONG  Spare0;
 467   struct _KTHREAD  *Thread;
 468   LIST_ENTRY  ApcListEntry;
 469   PKKERNEL_ROUTINE  KernelRoutine;
 470   PKRUNDOWN_ROUTINE  RundownRoutine;
 471   PKNORMAL_ROUTINE  NormalRoutine;
 472   PVOID  NormalContext;
 473   PVOID  SystemArgument1;
 474   PVOID  SystemArgument2;
 475   CCHAR  ApcStateIndex;
 476   KPROCESSOR_MODE  ApcMode;
 477   BOOLEAN  Inserted;
 478 } KAPC, *PKAPC, *RESTRICTED_POINTER PRKAPC;
 479
 480 typedef struct _IRP {
 481   CSHORT  Type;
 482   USHORT  Size;
 483   struct _MDL  *MdlAddress;
 484   ULONG  Flags;
 485   union {
 486     struct _IRP  *MasterIrp;
 487     LONG  IrpCount;
 488     PVOID  SystemBuffer;
 489   } AssociatedIrp;
 490   LIST_ENTRY  ThreadListEntry;
 491   IO_STATUS_BLOCK  IoStatus;
 492   KPROCESSOR_MODE  RequestorMode;
 493   BOOLEAN  PendingReturned;
 494   CHAR  StackCount;
 495   CHAR  CurrentLocation;
 496   BOOLEAN  Cancel;
 497   KIRQL  CancelIrql;
 498   CCHAR  ApcEnvironment;
 499   UCHAR  AllocationFlags;
 500   PIO_STATUS_BLOCK  UserIosb;
 501   PKEVENT  UserEvent;
 502   union {
 503     struct {
 504       PIO_APC_ROUTINE  UserApcRoutine;
 505       PVOID  UserApcContext;
 506     } AsynchronousParameters;
 507     LARGE_INTEGER  AllocationSize;
 508   } Overlay;
 509   PDRIVER_CANCEL  CancelRoutine;
 510   PVOID  UserBuffer;
 511   union {
 512     struct {
 513        union {
 514         KDEVICE_QUEUE_ENTRY  DeviceQueueEntry;
 515         struct {
 516           PVOID  DriverContext[4];
 517         } DUMMYSTRUCTNAME;
 518       } DUMMYUNIONNAME1;
 519       PETHREAD  Thread;
 520       PCHAR  AuxiliaryBuffer;
 521       struct {
 522         LIST_ENTRY  ListEntry;
 523         union {
 524           struct _IO_STACK_LOCATION  *CurrentStackLocation;
 525           ULONG  PacketType;
 526         } DUMMYUNIONNAME2;
 527       } DUMMYSTRUCTNAME;
 528       struct _FILE_OBJECT  *OriginalFileObject;
 529     } Overlay;
 530     KAPC  Apc;
 531     PVOID  CompletionKey;
 532   } Tail;
 533 } IRP;
 534 typedef struct _IRP *PIRP;
 535
 536 #define IRP_NOCACHE               0x0001
 537 #define IRP_PAGING_IO             0x0002
 538 #define IRP_MOUNT_COMPLETION      0x0002
 539 #define IRP_SYNCHRONOUS_API       0x0004
 540 #define IRP_ASSOCIATED_IRP        0x0008
 541 #define IRP_BUFFERED_IO           0x0010
 542 #define IRP_DEALLOCATE_BUFFER     0x0020
 543 #define IRP_INPUT_OPERATION       0x0040
 544 #define IRP_SYNCHRONOUS_PAGING_IO 0x0040
 545 #define IRP_CREATE_OPERATION      0x0080
 546 #define IRP_READ_OPERATION        0x0100
 547 #define IRP_WRITE_OPERATION       0x0200
 548 #define IRP_CLOSE_OPERATION       0x0400
 549 #define IRP_DEFER_IO_COMPLETION   0x0800
 550 #define IRP_OB_QUERY_NAME         0x1000
 551 #define IRP_HOLD_DEVICE_QUEUE     0x2000
 552
 553 typedef VOID (WINAPI *PINTERFACE_REFERENCE)(
 554   PVOID  Context);
 555
 556 typedef VOID (WINAPI *PINTERFACE_DEREFERENCE)(
 557   PVOID Context);
 558
 559 typedef struct _INTERFACE {
 560   USHORT  Size;
 561   USHORT  Version;
 562   PVOID  Context;
 563   PINTERFACE_REFERENCE  InterfaceReference;
 564   PINTERFACE_DEREFERENCE  InterfaceDereference;
 565 } INTERFACE, *PINTERFACE;
 566
 567 typedef struct _SECTION_OBJECT_POINTERS {
 568   PVOID  DataSectionObject;
 569   PVOID  SharedCacheMap;
 570   PVOID  ImageSectionObject;
 571 } SECTION_OBJECT_POINTERS, *PSECTION_OBJECT_POINTERS;
 572
 573 typedef struct _IO_COMPLETION_CONTEXT {
 574   PVOID  Port;
 575   PVOID  Key;
 576 } IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT;
 577
 578 typedef enum _DEVICE_RELATION_TYPE {
 579   BusRelations,
 580   EjectionRelations,
 581   PowerRelations,
 582   RemovalRelations,
 583   TargetDeviceRelation,
 584   SingleBusRelations
 585 } DEVICE_RELATION_TYPE, *PDEVICE_RELATION_TYPE;
 586
 587 typedef struct _FILE_OBJECT {
 588   CSHORT  Type;
 589   CSHORT  Size;
 590   PDEVICE_OBJECT  DeviceObject;
 591   PVPB  Vpb;
 592   PVOID  FsContext;
 593   PVOID  FsContext2;
 594   PSECTION_OBJECT_POINTERS  SectionObjectPointer;
 595   PVOID  PrivateCacheMap;
 596   NTSTATUS  FinalStatus;
 597   struct _FILE_OBJECT  *RelatedFileObject;
 598   BOOLEAN  LockOperation;
 599   BOOLEAN  DeletePending;
 600   BOOLEAN  ReadAccess;
 601   BOOLEAN  WriteAccess;
 602   BOOLEAN  DeleteAccess;
 603   BOOLEAN  SharedRead;
 604   BOOLEAN  SharedWrite;
 605   BOOLEAN  SharedDelete;
 606   ULONG  Flags;
 607   UNICODE_STRING  FileName;
 608   LARGE_INTEGER  CurrentByteOffset;
 609   ULONG  Waiters;
 610   ULONG  Busy;
 611   PVOID  LastLock;
 612   KEVENT  Lock;
 613   KEVENT  Event;
 614   PIO_COMPLETION_CONTEXT  CompletionContext;
 615 } FILE_OBJECT;
 616 typedef struct _FILE_OBJECT *PFILE_OBJECT;
 617
 618 #define INITIAL_PRIVILEGE_COUNT           3
 619
 620 typedef struct _INITIAL_PRIVILEGE_SET {
 621   ULONG  PrivilegeCount;
 622   ULONG  Control;
 623   LUID_AND_ATTRIBUTES  Privilege[INITIAL_PRIVILEGE_COUNT];
 624 } INITIAL_PRIVILEGE_SET, * PINITIAL_PRIVILEGE_SET;
 625
 626 typedef struct _SECURITY_SUBJECT_CONTEXT {
 627   PACCESS_TOKEN  ClientToken;
 628   SECURITY_IMPERSONATION_LEVEL  ImpersonationLevel;
 629   PACCESS_TOKEN  PrimaryToken;
 630   PVOID  ProcessAuditId;
 631 } SECURITY_SUBJECT_CONTEXT, *PSECURITY_SUBJECT_CONTEXT;
 632
 633 typedef struct _ACCESS_STATE {
 634   LUID  OperationID;
 635   BOOLEAN  SecurityEvaluated;
 636   BOOLEAN  GenerateAudit;
 637   BOOLEAN  GenerateOnClose;
 638   BOOLEAN  PrivilegesAllocated;
 639   ULONG  Flags;
 640   ACCESS_MASK  RemainingDesiredAccess;
 641   ACCESS_MASK  PreviouslyGrantedAccess;
 642   ACCESS_MASK  OriginalDesiredAccess;
 643   SECURITY_SUBJECT_CONTEXT  SubjectSecurityContext;
 644   PSECURITY_DESCRIPTOR  SecurityDescriptor;
 645   PVOID  AuxData;
 646   union {
 647     INITIAL_PRIVILEGE_SET  InitialPrivilegeSet;
 648     PRIVILEGE_SET  PrivilegeSet;
 649   } Privileges;
 650
 651   BOOLEAN  AuditPrivileges;
 652   UNICODE_STRING  ObjectName;
 653   UNICODE_STRING  ObjectTypeName;
 654 } ACCESS_STATE, *PACCESS_STATE;
 655
 656 typedef struct _IO_SECURITY_CONTEXT {
 657   PSECURITY_QUALITY_OF_SERVICE  SecurityQos;
 658   PACCESS_STATE  AccessState;
 659   ACCESS_MASK  DesiredAccess;
 660   ULONG  FullCreateOptions;
 661 } IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT;
 662
 663 typedef struct _DEVICE_CAPABILITIES {
 664   USHORT  Size;
 665   USHORT  Version;
 666   ULONG  DeviceD1 : 1;
 667   ULONG  DeviceD2 : 1;
 668   ULONG  LockSupported : 1;
 669   ULONG  EjectSupported : 1;
 670   ULONG  Removable : 1;
 671   ULONG  DockDevice : 1;
 672   ULONG  UniqueID : 1;
 673   ULONG  SilentInstall : 1;
 674   ULONG  RawDeviceOK : 1;
 675   ULONG  SurpriseRemovalOK : 1;
 676   ULONG  WakeFromD0 : 1;
 677   ULONG  WakeFromD1 : 1;
 678   ULONG  WakeFromD2 : 1;
 679   ULONG  WakeFromD3 : 1;
 680   ULONG  HardwareDisabled : 1;
 681   ULONG  NonDynamic : 1;
 682   ULONG  WarmEjectSupported : 1;
 683   ULONG  NoDisplayInUI : 1;
 684   ULONG  Reserved : 14;
 685   ULONG  Address;
 686   ULONG  UINumber;
 687   DEVICE_POWER_STATE  DeviceState[PowerSystemMaximum];
 688   SYSTEM_POWER_STATE  SystemWake;
 689   DEVICE_POWER_STATE  DeviceWake;
 690   ULONG  D1Latency;
 691   ULONG  D2Latency;
 692   ULONG  D3Latency;
 693 } DEVICE_CAPABILITIES, *PDEVICE_CAPABILITIES;
 694
 695 typedef struct _DEVICE_INTERFACE_CHANGE_NOTIFICATION {
 696   USHORT Version;
 697   USHORT Size;
 698   GUID Event;
 699   GUID InterfaceClassGuid;
 700   PUNICODE_STRING SymbolicLinkName;
 701 } DEVICE_INTERFACE_CHANGE_NOTIFICATION, *PDEVICE_INTERFACE_CHANGE_NOTIFICATION;
 702
 703 typedef enum _INTERFACE_TYPE {
 704   InterfaceTypeUndefined = -1,
 705   Internal,
 706   Isa,
 707   Eisa,
 708   MicroChannel,
 709   TurboChannel,
 710   PCIBus,
 711   VMEBus,
 712   NuBus,
 713   PCMCIABus,
 714   CBus,
 715   MPIBus,
 716   MPSABus,
 717   ProcessorInternal,
 718   InternalPowerBus,
 719   PNPISABus,
 720   PNPBus,
 721   MaximumInterfaceType
 722 } INTERFACE_TYPE, *PINTERFACE_TYPE;
 723
 724 typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;
 725
 726 #define IO_RESOURCE_PREFERRED             0x01
 727 #define IO_RESOURCE_DEFAULT               0x02
 728 #define IO_RESOURCE_ALTERNATIVE           0x08
 729
 730 typedef struct _IO_RESOURCE_DESCRIPTOR {
 731   UCHAR  Option;
 732   UCHAR  Type;
 733   UCHAR  ShareDisposition;
 734   UCHAR  Spare1;
 735   USHORT  Flags;
 736   USHORT  Spare2;
 737   union {
 738     struct {
 739       ULONG  Length;
 740       ULONG  Alignment;
 741       PHYSICAL_ADDRESS  MinimumAddress;
 742       PHYSICAL_ADDRESS  MaximumAddress;
 743     } Port;
 744     struct {
 745       ULONG  Length;
 746       ULONG  Alignment;
 747       PHYSICAL_ADDRESS  MinimumAddress;
 748       PHYSICAL_ADDRESS  MaximumAddress;
 749     } Memory;
 750     struct {
 751       ULONG  MinimumVector;
 752       ULONG  MaximumVector;
 753     } Interrupt;
 754     struct {
 755       ULONG  MinimumChannel;
 756       ULONG  MaximumChannel;
 757     } Dma;
 758     struct {
 759       ULONG  Length;
 760       ULONG  Alignment;
 761       PHYSICAL_ADDRESS  MinimumAddress;
 762       PHYSICAL_ADDRESS  MaximumAddress;
 763     } Generic;
 764     struct {
 765       ULONG  Data[3];
 766     } DevicePrivate;
 767     struct {
 768       ULONG  Length;
 769       ULONG  MinBusNumber;
 770       ULONG  MaxBusNumber;
 771       ULONG  Reserved;
 772     } BusNumber;
 773     struct {
 774       ULONG  Priority;
 775       ULONG  Reserved1;
 776       ULONG  Reserved2;
 777     } ConfigData;
 778   } u;
 779 } IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
 780
 781 typedef struct _IO_RESOURCE_LIST {
 782   USHORT  Version;
 783   USHORT  Revision;
 784   ULONG  Count;
 785   IO_RESOURCE_DESCRIPTOR  Descriptors[1];
 786 } IO_RESOURCE_LIST, *PIO_RESOURCE_LIST;
 787
 788 typedef struct _IO_RESOURCE_REQUIREMENTS_LIST {
 789   ULONG  ListSize;
 790   INTERFACE_TYPE  InterfaceType;
 791   ULONG  BusNumber;
 792   ULONG  SlotNumber;
 793   ULONG  Reserved[3];
 794   ULONG  AlternativeLists;
 795   IO_RESOURCE_LIST  List[1];
 796 } IO_RESOURCE_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST;
 797
 798 typedef enum _BUS_QUERY_ID_TYPE {
 799   BusQueryDeviceID,
 800   BusQueryHardwareIDs,
 801   BusQueryCompatibleIDs,
 802   BusQueryInstanceID,
 803   BusQueryDeviceSerialNumber
 804 } BUS_QUERY_ID_TYPE, *PBUS_QUERY_ID_TYPE;
 805
 806 typedef enum _CREATE_FILE_TYPE {
 807   CreateFileTypeNone,
 808   CreateFileTypeNamedPipe,
 809   CreateFileTypeMailslot
 810 } CREATE_FILE_TYPE;
 811
 812 typedef enum {
 813   DevicePropertyDeviceDescription,
 814   DevicePropertyHardwareID,
 815   DevicePropertyCompatibleIDs,
 816   DevicePropertyBootConfiguration,
 817   DevicePropertyBootConfigurationTranslated,
 818   DevicePropertyClassName,
 819   DevicePropertyClassGuid,
 820   DevicePropertyDriverKeyName,
 821   DevicePropertyManufacturer,
 822   DevicePropertyFriendlyName,
 823   DevicePropertyLocationInformation,
 824   DevicePropertyPhysicalDeviceObjectName,
 825   DevicePropertyBusTypeGuid,
 826   DevicePropertyLegacyBusType,
 827   DevicePropertyBusNumber,
 828   DevicePropertyEnumeratorName,
 829   DevicePropertyAddress,
 830   DevicePropertyUINumber,
 831   DevicePropertyInstallState,
 832   DevicePropertyRemovalPolicy
 833 } DEVICE_REGISTRY_PROPERTY;
 834
 835 typedef enum _DEVICE_TEXT_TYPE {
 836   DeviceTextDescription,
 837   DeviceTextLocationInformation
 838 } DEVICE_TEXT_TYPE, *PDEVICE_TEXT_TYPE;
 839
 840 typedef enum _DEVICE_USAGE_NOTIFICATION_TYPE {
 841   DeviceUsageTypeUndefined,
 842   DeviceUsageTypePaging,
 843   DeviceUsageTypeHibernation,
 844   DeviceUsageTypeDumpFile
 845 } DEVICE_USAGE_NOTIFICATION_TYPE;
 846
 847 typedef struct _POWER_SEQUENCE {
 848   ULONG  SequenceD1;
 849   ULONG  SequenceD2;
 850   ULONG  SequenceD3;
 851 } POWER_SEQUENCE, *PPOWER_SEQUENCE;
 852
 853 typedef enum _POWER_STATE_TYPE {
 854   SystemPowerState,
 855   DevicePowerState
 856 } POWER_STATE_TYPE, *PPOWER_STATE_TYPE;
 857
 858 typedef union _POWER_STATE {
 859   SYSTEM_POWER_STATE  SystemState;
 860   DEVICE_POWER_STATE  DeviceState;
 861 } POWER_STATE, *PPOWER_STATE;
 862
 863 typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR {
 864   UCHAR Type;
 865   UCHAR ShareDisposition;
 866   USHORT Flags;
 867   union {
 868     struct {
 869       PHYSICAL_ADDRESS Start;
 870       ULONG Length;
 871     } Generic;
 872     struct {
 873       PHYSICAL_ADDRESS Start;
 874       ULONG Length;
 875     } Port;
 876     struct {
 877       ULONG Level;
 878       ULONG Vector;
 879       ULONG Affinity;
 880     } Interrupt;
 881     struct {
 882       PHYSICAL_ADDRESS Start;
 883       ULONG Length;
 884     } Memory;
 885     struct {
 886       ULONG Channel;
 887       ULONG Port;
 888       ULONG Reserved1;
 889     } Dma;
 890     struct {
 891       ULONG Data[3];
 892     } DevicePrivate;
 893     struct {
 894       ULONG Start;
 895       ULONG Length;
 896       ULONG Reserved;
 897     } BusNumber;
 898     struct {
 899       ULONG DataSize;
 900       ULONG Reserved1;
 901       ULONG Reserved2;
 902     } DeviceSpecificData;
 903   } u;
 904 } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
 905
 906 typedef struct _CM_PARTIAL_RESOURCE_LIST {
 907   USHORT  Version;
 908   USHORT  Revision;
 909   ULONG  Count;
 910   CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
 911 } CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST;
 912
 913 typedef struct _CM_FULL_RESOURCE_DESCRIPTOR {
 914   INTERFACE_TYPE  InterfaceType;
 915   ULONG  BusNumber;
 916   CM_PARTIAL_RESOURCE_LIST  PartialResourceList;
 917 } CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR;
 918
 919 typedef struct _CM_RESOURCE_LIST {
 920   ULONG  Count;
 921   CM_FULL_RESOURCE_DESCRIPTOR  List[1];
 922 } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
 923
 924 typedef NTSTATUS (WINAPI *PIO_COMPLETION_ROUTINE)(
 925   IN struct _DEVICE_OBJECT  *DeviceObject,
 926   IN struct _IRP  *Irp,
 927   IN PVOID  Context);
 928
 929 #define SL_PENDING_RETURNED             0x01
 930 #define SL_INVOKE_ON_CANCEL             0x20
 931 #define SL_INVOKE_ON_SUCCESS            0x40
 932 #define SL_INVOKE_ON_ERROR              0x80
 933
 934 #if !defined(_WIN64)
 935 #include <pshpack4.h>
 936 #endif
 937 typedef struct _IO_STACK_LOCATION {
 938   UCHAR  MajorFunction;
 939   UCHAR  MinorFunction;
 940   UCHAR  Flags;
 941   UCHAR  Control;
 942   union {
 943     struct {
 944       PIO_SECURITY_CONTEXT  SecurityContext;
 945       ULONG  Options;
 946       USHORT POINTER_ALIGNMENT  FileAttributes;
 947       USHORT  ShareAccess;
 948       ULONG POINTER_ALIGNMENT  EaLength;
 949     } Create;
 950     struct {
 951       ULONG  Length;
 952       ULONG POINTER_ALIGNMENT  Key;
 953       LARGE_INTEGER  ByteOffset;
 954     } Read;
 955     struct {
 956       ULONG  Length;
 957       ULONG POINTER_ALIGNMENT  Key;
 958       LARGE_INTEGER  ByteOffset;
 959     } Write;
 960     struct {
 961       ULONG  Length;
 962       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 963     } QueryFile;
 964     struct {
 965       ULONG  Length;
 966       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 967       PFILE_OBJECT  FileObject;
 968       union {
 969         struct {
 970           BOOLEAN  ReplaceIfExists;
 971           BOOLEAN  AdvanceOnly;
 972         } DUMMYSTRUCTNAME;
 973         ULONG  ClusterCount;
 974         HANDLE  DeleteHandle;
 975       } DUMMYUNIONNAME;
 976     } SetFile;
 977     struct {
 978       ULONG  Length;
 979       FS_INFORMATION_CLASS POINTER_ALIGNMENT  FsInformationClass;
 980     } QueryVolume;
 981     struct {
 982       ULONG  OutputBufferLength;
 983       ULONG POINTER_ALIGNMENT  InputBufferLength;
 984       ULONG POINTER_ALIGNMENT  IoControlCode;
 985       PVOID  Type3InputBuffer;
 986     } DeviceIoControl;
 987     struct {
 988       SECURITY_INFORMATION  SecurityInformation;
 989       ULONG POINTER_ALIGNMENT  Length;
 990     } QuerySecurity;
 991     struct {
 992       SECURITY_INFORMATION  SecurityInformation;
 993       PSECURITY_DESCRIPTOR  SecurityDescriptor;
 994     } SetSecurity;
 995     struct {
 996       PVPB  Vpb;
 997       PDEVICE_OBJECT  DeviceObject;
 998     } MountVolume;
 999     struct {
1000       PVPB  Vpb;
1001       PDEVICE_OBJECT  DeviceObject;
1002     } VerifyVolume;
1003     struct {
1004       struct _SCSI_REQUEST_BLOCK  *Srb;
1005     } Scsi;
1006     struct {
1007       DEVICE_RELATION_TYPE  Type;
1008     } QueryDeviceRelations;
1009     struct {
1010       const GUID  *InterfaceType;
1011       USHORT  Size;
1012       USHORT  Version;
1013       PINTERFACE  Interface;
1014       PVOID  InterfaceSpecificData;
1015     } QueryInterface;
1016     struct {
1017       PDEVICE_CAPABILITIES  Capabilities;
1018     } DeviceCapabilities;
1019     struct {
1020       PIO_RESOURCE_REQUIREMENTS_LIST  IoResourceRequirementList;
1021     } FilterResourceRequirements;
1022     struct {
1023       ULONG  WhichSpace;
1024       PVOID  Buffer;
1025       ULONG  Offset;
1026       ULONG POINTER_ALIGNMENT  Length;
1027     } ReadWriteConfig;
1028     struct {
1029       BOOLEAN  Lock;
1030     } SetLock;
1031     struct {
1032       BUS_QUERY_ID_TYPE  IdType;
1033     } QueryId;
1034     struct {
1035       DEVICE_TEXT_TYPE  DeviceTextType;
1036       LCID POINTER_ALIGNMENT  LocaleId;
1037     } QueryDeviceText;
1038     struct {
1039       BOOLEAN  InPath;
1040       BOOLEAN  Reserved[3];
1041       DEVICE_USAGE_NOTIFICATION_TYPE POINTER_ALIGNMENT  Type;
1042     } UsageNotification;
1043     struct {
1044       SYSTEM_POWER_STATE  PowerState;
1045     } WaitWake;
1046     struct {
1047       PPOWER_SEQUENCE  PowerSequence;
1048     } PowerSequence;
1049     struct {
1050       ULONG  SystemContext;
1051       POWER_STATE_TYPE POINTER_ALIGNMENT  Type;
1052       POWER_STATE POINTER_ALIGNMENT  State;
1053       POWER_ACTION POINTER_ALIGNMENT  ShutdownType;
1054     } Power;
1055     struct {
1056       PCM_RESOURCE_LIST  AllocatedResources;
1057       PCM_RESOURCE_LIST  AllocatedResourcesTranslated;
1058     } StartDevice;
1059     struct {
1060       ULONG_PTR  ProviderId;
1061       PVOID  DataPath;
1062       ULONG  BufferSize;
1063       PVOID  Buffer;
1064     } WMI;
1065     struct {
1066       PVOID  Argument1;
1067       PVOID  Argument2;
1068       PVOID  Argument3;
1069       PVOID  Argument4;
1070     } Others;
1071   } Parameters;
1072   PDEVICE_OBJECT  DeviceObject;
1073   PFILE_OBJECT  FileObject;
1074   PIO_COMPLETION_ROUTINE  CompletionRoutine;
1075   PVOID  Context;
1076 } IO_STACK_LOCATION, *PIO_STACK_LOCATION;
1077 #if !defined(_WIN64)
1078 #include <poppack.h>
1079 #endif
1080
1081 /* MDL definitions */
1082
1083 #define MDL_MAPPED_TO_SYSTEM_VA     0x0001
1084 #define MDL_PAGES_LOCKED            0x0002
1085 #define MDL_SOURCE_IS_NONPAGED_POOL 0x0004
1086 #define MDL_ALLOCATED_FIXED_SIZE    0x0008
1087 #define MDL_PARTIAL                 0x0010
1088 #define MDL_PARTIAL_HAS_BEEN_MAPPED 0x0020
1089 #define MDL_IO_PAGE_READ            0x0040
1090 #define MDL_WRITE_OPERATION         0x0080
1091 #define MDL_PARENT_MAPPED_SYSTEM_VA 0x0100
1092 #define MDL_FREE_EXTRA_PTES         0x0200
1093 #define MDL_DESCRIBES_AWE           0x0400
1094 #define MDL_IO_SPACE                0x0800
1095 #define MDL_NETWORK_HEADER          0x1000
1096 #define MDL_MAPPING_CAN_FAIL        0x2000
1097 #define MDL_ALLOCATED_MUST_SUCCEED  0x4000
1098 #define MDL_INTERNAL                0x8000
1099
1100 #define MDL_MAPPING_FLAGS (MDL_MAPPED_TO_SYSTEM_VA     | \
1101                            MDL_PAGES_LOCKED            | \
1102                            MDL_SOURCE_IS_NONPAGED_POOL | \
1103                            MDL_PARTIAL_HAS_BEEN_MAPPED | \
1104                            MDL_PARENT_MAPPED_SYSTEM_VA | \
1105                            MDL_SYSTEM_VA               | \
1106                            MDL_IO_SPACE )
1107
1108 typedef struct _MDL {
1109   struct _MDL  *Next;
1110   CSHORT  Size;
1111   CSHORT  MdlFlags;
1112   struct _EPROCESS  *Process;
1113   PVOID  MappedSystemVa;
1114   PVOID  StartVa;
1115   ULONG  ByteCount;
1116   ULONG  ByteOffset;
1117 } MDL, *PMDL;
1118
1119 typedef MDL *PMDLX;
1120 typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
1121
1122 static inline void MmInitializeMdl(MDL *mdl, void *va, SIZE_T length)
1123 {
1124     mdl->Next       = NULL;
1125     mdl->Size       = sizeof(MDL) + sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(va, length);
1126     mdl->MdlFlags   = 0;
1127     mdl->StartVa    = (void *)PAGE_ALIGN(va);
1128     mdl->ByteOffset = BYTE_OFFSET(va);
1129     mdl->ByteCount  = length;
1130 }
1131
1132 typedef struct _KTIMER {
1133     DISPATCHER_HEADER Header;
1134     ULARGE_INTEGER DueTime;
1135     LIST_ENTRY TimerListEntry;
1136     struct _KDPC *Dpc;
1137     LONG Period;
1138 } KTIMER, *PKTIMER;
1139
1140 typedef struct _KSYSTEM_TIME {
1141     ULONG LowPart;
1142     LONG High1Time;
1143     LONG High2Time;
1144 } KSYSTEM_TIME, *PKSYSTEM_TIME;
1145
1146 typedef enum _NT_PRODUCT_TYPE {
1147     NtProductWinNt = 1,
1148     NtProductLanManNt,
1149     NtProductServer
1150 } NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;
1151
1152 #define PROCESSOR_FEATURE_MAX 64
1153
1154 typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE
1155 {
1156    StandardDesign,
1157    NEC98x86,
1158    EndAlternatives
1159 } ALTERNATIVE_ARCHITECTURE_TYPE;
1160
1161 #define NX_SUPPORT_POLICY_ALWAYSOFF     0
1162 #define NX_SUPPORT_POLICY_ALWAYSON      1
1163 #define NX_SUPPORT_POLICY_OPTIN         2
1164 #define NX_SUPPORT_POLICY_OPTOUT        3
1165
1166 #define MAX_WOW64_SHARED_ENTRIES 16
1167
1168 typedef struct _KUSER_SHARED_DATA {
1169     ULONG TickCountLowDeprecated;
1170     ULONG TickCountMultiplier;
1171     volatile KSYSTEM_TIME InterruptTime;
1172     volatile KSYSTEM_TIME SystemTime;
1173     volatile KSYSTEM_TIME TimeZoneBias;
1174     USHORT ImageNumberLow;
1175     USHORT ImageNumberHigh;
1176     WCHAR NtSystemRoot[260];
1177     ULONG MaxStackTraceDepth;
1178     ULONG CryptoExponent;
1179     ULONG TimeZoneId;
1180     ULONG LargePageMinimum;
1181     ULONG Reserved2[7];
1182     NT_PRODUCT_TYPE NtProductType;
1183     BOOLEAN ProductTypeIsValid;
1184     ULONG NtMajorVersion;
1185     ULONG NtMinorVersion;
1186     BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX];
1187     ULONG Reserved1;
1188     ULONG Reserved3;
1189     volatile ULONG TimeSlip;
1190     ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
1191     LARGE_INTEGER SystemExpirationDate;
1192     ULONG SuiteMask;
1193     BOOLEAN KdDebuggerEnabled;
1194     UCHAR NXSupportPolicy;
1195     volatile ULONG ActiveConsoleId;
1196     volatile ULONG DismountCount;
1197     ULONG ComPlusPackage;
1198     ULONG LastSystemRITEventTickCount;
1199     ULONG NumberOfPhysicalPages;
1200     BOOLEAN SafeBootMode;
1201     ULONG TraceLogging;
1202     ULONGLONG TestRetInstruction;
1203     ULONG SystemCall;
1204     ULONG SystemCallReturn;
1205     ULONGLONG SystemCallPad[3];
1206     union {
1207         volatile KSYSTEM_TIME TickCount;
1208         volatile ULONG64 TickCountQuad;
1209     } DUMMYUNIONNAME;
1210     ULONG Cookie;
1211     ULONG Wow64SharedInformation[MAX_WOW64_SHARED_ENTRIES];
1212 } KSHARED_USER_DATA, *PKSHARED_USER_DATA;
1213
1214 typedef enum _MEMORY_CACHING_TYPE {
1215     MmNonCached = 0,
1216     MmCached = 1,
1217     MmWriteCombined = 2,
1218     MmHardwareCoherentCached = 3,
1219     MmNonCachedUnordered = 4,
1220     MmUSWCCached = 5,
1221     MmMaximumCacheType = 6
1222 } MEMORY_CACHING_TYPE;
1223
1224 typedef enum _MM_PAGE_PRIORITY {
1225     LowPagePriority,
1226     NormalPagePriority = 16,
1227     HighPagePriority = 32
1228 } MM_PAGE_PRIORITY;
1229
1230 typedef enum _MM_SYSTEM_SIZE
1231 {
1232     MmSmallSystem,
1233     MmMediumSystem,
1234     MmLargeSystem
1235 } MM_SYSTEMSIZE;
1236
1237 typedef struct _IO_REMOVE_LOCK_COMMON_BLOCK {
1238     BOOLEAN Removed;
1239     BOOLEAN Reserved[3];
1240     LONG IoCount;
1241     KEVENT RemoveEvent;
1242 } IO_REMOVE_LOCK_COMMON_BLOCK;
1243
1244 typedef struct _IO_REMOVE_LOCK_TRACKING_BLOCK *PIO_REMOVE_LOCK_TRACKING_BLOCK;
1245
1246 typedef struct _IO_REMOVE_LOCK_DBG_BLOCK {
1247     LONG Signature;
1248     LONG HighWatermark;
1249     LONGLONG MaxLockedTicks;
1250     LONG AllocateTag;
1251     LIST_ENTRY LockList;
1252     KSPIN_LOCK Spin;
1253     LONG LowMemoryCount;
1254     ULONG Reserved1[4];
1255     PVOID Reserved2;
1256     PIO_REMOVE_LOCK_TRACKING_BLOCK Blocks;
1257 } IO_REMOVE_LOCK_DBG_BLOCK;
1258
1259 typedef struct _IO_REMOVE_LOCK {
1260     IO_REMOVE_LOCK_COMMON_BLOCK Common;
1261     IO_REMOVE_LOCK_DBG_BLOCK Dbg;
1262 } IO_REMOVE_LOCK, *PIO_REMOVE_LOCK;
1263
1264 typedef enum  {
1265     IoReadAccess,
1266     IoWriteAccess,
1267     IoModifyAccess
1268 } LOCK_OPERATION;
1269
1270 typedef struct _CALLBACK_OBJECT
1271 {
1272     ULONG Signature;
1273     KSPIN_LOCK Lock;
1274     LIST_ENTRY RegisteredCallbacks;
1275     BOOLEAN AllowMultipleCallbacks;
1276     UCHAR reserved[3];
1277 } CALLBACK_OBJECT, *PCALLBACK_OBJECT;
1278
1279 typedef struct _KSPIN_LOCK_QUEUE {
1280     struct _KSPIN_LOCK_QUEUE * volatile Next;
1281     volatile PKSPIN_LOCK Lock;
1282 } KSPIN_LOCK_QUEUE, *PKSPIN_LOCK_QUEUE;
1283
1284 typedef struct _KLOCK_QUEUE_HANDLE {
1285     KSPIN_LOCK_QUEUE LockQueue;
1286     KIRQL OldIrql;
1287 } KLOCK_QUEUE_HANDLE, *PKLOCK_QUEUE_HANDLE;
1288
1289 typedef void * (NTAPI *PALLOCATE_FUNCTION)(POOL_TYPE, SIZE_T, ULONG);
1290 typedef void * (NTAPI *PALLOCATE_FUNCTION_EX)(POOL_TYPE, SIZE_T, ULONG, PLOOKASIDE_LIST_EX);
1291 typedef void (NTAPI *PFREE_FUNCTION)(void *);
1292 typedef void (NTAPI *PFREE_FUNCTION_EX)(void *, PLOOKASIDE_LIST_EX);
1293
1294 #ifdef _WIN64
1295 #define LOOKASIDE_ALIGN DECLSPEC_CACHEALIGN
1296 #else
1297 #define LOOKASIDE_ALIGN
1298 #endif
1299
1300 #define LOOKASIDE_MINIMUM_BLOCK_SIZE (RTL_SIZEOF_THROUGH_FIELD(SLIST_ENTRY, Next))
1301
1302 #define GENERAL_LOOKASIDE_LAYOUT           \
1303     union                                  \
1304     {                                      \
1305         SLIST_HEADER ListHead;             \
1306         SINGLE_LIST_ENTRY SingleListHead;  \
1307     } DUMMYUNIONNAME;                      \
1308     USHORT Depth;                          \
1309     USHORT MaximumDepth;                   \
1310     ULONG TotalAllocates;                  \
1311     union                                  \
1312     {                                      \
1313         ULONG AllocateMisses;              \
1314         ULONG AllocateHits;                \
1315     } DUMMYUNIONNAME2;                     \
1316     ULONG TotalFrees;                      \
1317     union                                  \
1318     {                                      \
1319         ULONG FreeMisses;                  \
1320         ULONG FreeHits;                    \
1321     } DUMMYUNIONNAME3;                     \
1322     POOL_TYPE Type;                        \
1323     ULONG Tag;                             \
1324     ULONG Size;                            \
1325     union                                  \
1326     {                                      \
1327         PALLOCATE_FUNCTION_EX AllocateEx;  \
1328         PALLOCATE_FUNCTION Allocate;       \
1329     } DUMMYUNIONNAME4;                     \
1330     union                                  \
1331     {                                      \
1332         PFREE_FUNCTION_EX FreeEx;          \
1333         PFREE_FUNCTION Free;               \
1334     } DUMMYUNIONNAME5;                     \
1335     LIST_ENTRY ListEntry;                  \
1336     ULONG LastTotalAllocates;              \
1337     union                                  \
1338     {                                      \
1339         ULONG LastAllocateMisses;          \
1340         ULONG LastAllocateHits;            \
1341     } DUMMYUNIONNAME6;                     \
1342     ULONG Future[2];
1343
1344 typedef struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE
1345 {
1346     GENERAL_LOOKASIDE_LAYOUT
1347 } GENERAL_LOOKASIDE;
1348
1349 typedef struct _GENERAL_LOOKASIDE_POOL
1350 {
1351     GENERAL_LOOKASIDE_LAYOUT
1352 } GENERAL_LOOKASIDE_POOL, *PGENERAL_LOOKASIDE_POOL;
1353
1354 typedef struct _LOOKASIDE_LIST_EX
1355 {
1356     GENERAL_LOOKASIDE_POOL L;
1357 } LOOKASIDE_LIST_EX;
1358
1359 typedef struct LOOKASIDE_ALIGN _NPAGED_LOOKASIDE_LIST
1360 {
1361     GENERAL_LOOKASIDE L;
1362 #if defined(__i386__)
1363     KSPIN_LOCK Lock__ObsoleteButDoNotDelete;
1364 #endif
1365 } NPAGED_LOOKASIDE_LIST, *PNPAGED_LOOKASIDE_LIST;
1366
1367 typedef NTSTATUS (NTAPI EX_CALLBACK_FUNCTION)(void *CallbackContext, void *Argument1, void *Argument2);
1368 typedef EX_CALLBACK_FUNCTION *PEX_CALLBACK_FUNCTION;
1369
1370 typedef ULONG OB_OPERATION;
1371
1372 typedef struct _OB_PRE_CREATE_HANDLE_INFORMATION {
1373     ACCESS_MASK DesiredAccess;
1374     ACCESS_MASK OriginalDesiredAccess;
1375 } OB_PRE_CREATE_HANDLE_INFORMATION, *POB_PRE_CREATE_HANDLE_INFORMATION;
1376
1377 typedef struct _OB_PRE_DUPLICATE_HANDLE_INFORMATION {
1378     ACCESS_MASK DesiredAccess;
1379     ACCESS_MASK OriginalDesiredAccess;
1380     PVOID SourceProcess;
1381     PVOID TargetProcess;
1382 } OB_PRE_DUPLICATE_HANDLE_INFORMATION, *POB_PRE_DUPLICATE_HANDLE_INFORMATION;
1383
1384 typedef union _OB_PRE_OPERATION_PARAMETERS {
1385     OB_PRE_CREATE_HANDLE_INFORMATION CreateHandleInformation;
1386     OB_PRE_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation;
1387 } OB_PRE_OPERATION_PARAMETERS, *POB_PRE_OPERATION_PARAMETERS;
1388
1389 typedef struct _OB_PRE_OPERATION_INFORMATION {
1390     OB_OPERATION Operation;
1391     union {
1392         ULONG Flags;
1393         struct {
1394             ULONG KernelHandle:1;
1395             ULONG Reserved:31;
1396         } DUMMYSTRUCTNAME;
1397     } DUMMYUNIONNAME;
1398     PVOID Object;
1399     POBJECT_TYPE ObjectType;
1400     PVOID CallContext;
1401     POB_PRE_OPERATION_PARAMETERS Parameters;
1402 } OB_PRE_OPERATION_INFORMATION, *POB_PRE_OPERATION_INFORMATION;
1403
1404 typedef struct _OB_POST_CREATE_HANDLE_INFORMATION {
1405     ACCESS_MASK GrantedAccess;
1406 } OB_POST_CREATE_HANDLE_INFORMATION, *POB_POST_CREATE_HANDLE_INFORMATION;
1407
1408 typedef struct _OB_POST_DUPLICATE_HANDLE_INFORMATION {
1409     ACCESS_MASK GrantedAccess;
1410 } OB_POST_DUPLICATE_HANDLE_INFORMATION, *POB_POST_DUPLICATE_HANDLE_INFORMATION;
1411
1412 typedef union _OB_POST_OPERATION_PARAMETERS {
1413     OB_POST_CREATE_HANDLE_INFORMATION CreateHandleInformation;
1414     OB_POST_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation;
1415 } OB_POST_OPERATION_PARAMETERS, *POB_POST_OPERATION_PARAMETERS;
1416
1417 typedef struct _OB_POST_OPERATION_INFORMATION {
1418     OB_OPERATION Operation;
1419     union {
1420         ULONG Flags;
1421         struct {
1422             ULONG KernelHandle:1;
1423             ULONG Reserved:31;
1424         } DUMMYSTRUCTNAME;
1425     } DUMMYUNIONNAME;
1426     PVOID Object;
1427     POBJECT_TYPE ObjectType;
1428     PVOID CallContext;
1429     NTSTATUS ReturnStatus;
1430     POB_POST_OPERATION_PARAMETERS Parameters;
1431 } OB_POST_OPERATION_INFORMATION,*POB_POST_OPERATION_INFORMATION;
1432
1433 typedef enum _OB_PREOP_CALLBACK_STATUS {
1434     OB_PREOP_SUCCESS
1435 } OB_PREOP_CALLBACK_STATUS, *POB_PREOP_CALLBACK_STATUS;
1436
1437 typedef OB_PREOP_CALLBACK_STATUS (WINAPI *POB_PRE_OPERATION_CALLBACK)(void *context, POB_PRE_OPERATION_INFORMATION information);
1438 typedef void (WINAPI *POB_POST_OPERATION_CALLBACK)(void *context, POB_POST_OPERATION_INFORMATION information);
1439
1440 typedef struct _OB_OPERATION_REGISTRATION {
1441     POBJECT_TYPE *ObjectType;
1442     OB_OPERATION Operations;
1443     POB_PRE_OPERATION_CALLBACK PreOperation;
1444     POB_POST_OPERATION_CALLBACK PostOperation;
1445 } OB_OPERATION_REGISTRATION, *POB_OPERATION_REGISTRATION;
1446
1447 typedef struct _OB_CALLBACK_REGISTRATION {
1448     USHORT Version;
1449     USHORT OperationRegistrationCount;
1450     UNICODE_STRING Altitude;
1451     PVOID RegistrationContext;
1452     OB_OPERATION_REGISTRATION *OperationRegistration;
1453 } OB_CALLBACK_REGISTRATION, *POB_CALLBACK_REGISTRATION;
1454
1455 #define OB_FLT_REGISTRATION_VERSION_0100  0x0100
1456 #define OB_FLT_REGISTRATION_VERSION OB_FLT_REGISTRATION_VERSION_0100
1457
1458 typedef enum _DIRECTORY_NOTIFY_INFORMATION_CLASS {
1459     DirectoryNotifyInformation = 1,
1460     DirectoryNotifyExtendedInformation
1461 } DIRECTORY_NOTIFY_INFORMATION_CLASS, *PDIRECTORY_NOTIFY_INFORMATION_CLASS;
1462
1463 NTSTATUS WINAPI ObCloseHandle(IN HANDLE handle);
1464
1465 #ifdef NONAMELESSUNION
1466 # ifdef NONAMELESSSTRUCT
1467 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.u2.CurrentStackLocation)
1468 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.u2.CurrentStackLocation - 1)
1469    static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.s.u2.CurrentStackLocation++; irp->CurrentLocation++;}
1470 # else
1471 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.u2.CurrentStackLocation)
1472 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.u2.CurrentStackLocation - 1)
1473    static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.u2.CurrentStackLocation++; irp->CurrentLocation++;}
1474 # endif
1475 #else
1476 # ifdef NONAMELESSSTRUCT
1477 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.CurrentStackLocation)
1478 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.CurrentStackLocation - 1)
1479     static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.s.CurrentStackLocation++; irp->CurrentLocation++;}
1480 # else
1481 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.CurrentStackLocation)
1482 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.CurrentStackLocation - 1)
1483     static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.CurrentStackLocation++; irp->CurrentLocation++;}
1484 # endif
1485 #endif
1486
1487 static inline void IoSetCompletionRoutine(IRP *irp, PIO_COMPLETION_ROUTINE routine, void *context,
1488                                           BOOLEAN on_success, BOOLEAN on_error, BOOLEAN on_cancel)
1489 {
1490     IO_STACK_LOCATION *irpsp = IoGetNextIrpStackLocation(irp);
1491     irpsp->CompletionRoutine = routine;
1492     irpsp->Context = context;
1493     irpsp->Control = 0;
1494     if (on_success) irpsp->Control |= SL_INVOKE_ON_SUCCESS;
1495     if (on_error)   irpsp->Control |= SL_INVOKE_ON_ERROR;
1496     if (on_cancel)  irpsp->Control |= SL_INVOKE_ON_CANCEL;
1497 }
1498
1499 #define KernelMode 0
1500 #define UserMode   1
1501
1502 /* directory object access rights */
1503 #define DIRECTORY_QUERY                 0x0001
1504 #define DIRECTORY_TRAVERSE              0x0002
1505 #define DIRECTORY_CREATE_OBJECT         0x0004
1506 #define DIRECTORY_CREATE_SUBDIRECTORY   0x0008
1507 #define DIRECTORY_ALL_ACCESS            (STANDARD_RIGHTS_REQUIRED | 0xF)
1508
1509 /* symbolic link access rights */
1510 #define SYMBOLIC_LINK_QUERY             0x0001
1511 #define SYMBOLIC_LINK_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | 0x1)
1512
1513 NTSTATUS  WINAPI DbgQueryDebugFilterState(ULONG, ULONG);
1514 void      WINAPI ExAcquireFastMutexUnsafe(PFAST_MUTEX);
1515 BOOLEAN   WINAPI ExAcquireResourceExclusiveLite(ERESOURCE*,BOOLEAN);
1516 BOOLEAN   WINAPI ExAcquireResourceSharedLite(ERESOURCE*,BOOLEAN);
1517 BOOLEAN   WINAPI ExAcquireSharedStarveExclusive(ERESOURCE*,BOOLEAN);
1518 BOOLEAN   WINAPI ExAcquireSharedWaitForExclusive(ERESOURCE*,BOOLEAN);
1519 PVOID     WINAPI ExAllocatePool(POOL_TYPE,SIZE_T);
1520 PVOID     WINAPI ExAllocatePoolWithQuota(POOL_TYPE,SIZE_T);
1521 PVOID     WINAPI ExAllocatePoolWithTag(POOL_TYPE,SIZE_T,ULONG);
1522 PVOID     WINAPI ExAllocatePoolWithQuotaTag(POOL_TYPE,SIZE_T,ULONG);
1523 void      WINAPI ExDeleteNPagedLookasideList(PNPAGED_LOOKASIDE_LIST);
1524 NTSTATUS  WINAPI ExDeleteResourceLite(ERESOURCE*);
1525 void      WINAPI ExFreePool(PVOID);
1526 void      WINAPI ExFreePoolWithTag(PVOID,ULONG);
1527 ULONG     WINAPI ExGetExclusiveWaiterCount(ERESOURCE*);
1528 ULONG     WINAPI ExGetSharedWaiterCount(ERESOURCE*);
1529 void      WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST,PALLOCATE_FUNCTION,PFREE_FUNCTION,ULONG,SIZE_T,ULONG,USHORT);
1530 NTSTATUS  WINAPI ExInitializeResourceLite(ERESOURCE*);
1531 PSLIST_ENTRY WINAPI ExInterlockedFlushSList(PSLIST_HEADER);
1532 PSLIST_ENTRY WINAPI ExInterlockedPopEntrySList(PSLIST_HEADER,PKSPIN_LOCK);
1533 PSLIST_ENTRY WINAPI ExInterlockedPushEntrySList(PSLIST_HEADER,PSLIST_ENTRY,PKSPIN_LOCK);
1534 LIST_ENTRY * WINAPI ExInterlockedRemoveHeadList(LIST_ENTRY*,KSPIN_LOCK*);
1535 BOOLEAN   WINAPI ExIsResourceAcquiredExclusiveLite(ERESOURCE*);
1536 ULONG     WINAPI ExIsResourceAcquiredSharedLite(ERESOURCE*);
1537 void      WINAPI ExReleaseFastMutexUnsafe(PFAST_MUTEX);
1538 void      WINAPI ExReleaseResourceForThreadLite(ERESOURCE*,ERESOURCE_THREAD);
1539 ULONG     WINAPI ExSetTimerResolution(ULONG,BOOLEAN);
1540
1541 void      WINAPI IoAcquireCancelSpinLock(KIRQL*);
1542 NTSTATUS  WINAPI IoAllocateDriverObjectExtension(PDRIVER_OBJECT,PVOID,ULONG,PVOID*);
1543 PVOID     WINAPI IoAllocateErrorLogEntry(PVOID,UCHAR);
1544 PIRP      WINAPI IoAllocateIrp(CCHAR,BOOLEAN);
1545 PMDL      WINAPI IoAllocateMdl(PVOID,ULONG,BOOLEAN,BOOLEAN,IRP*);
1546 PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack(PDEVICE_OBJECT,PDEVICE_OBJECT);
1547 PIRP      WINAPI IoBuildDeviceIoControlRequest(ULONG,DEVICE_OBJECT*,PVOID,ULONG,PVOID,ULONG,BOOLEAN,PKEVENT,IO_STATUS_BLOCK*);
1548 PIRP      WINAPI IoBuildSynchronousFsdRequest(ULONG,DEVICE_OBJECT*,PVOID,ULONG,PLARGE_INTEGER,PKEVENT,IO_STATUS_BLOCK*);
1549 NTSTATUS  WINAPI IoCallDriver(DEVICE_OBJECT*,IRP*);
1550 VOID      WINAPI IoCompleteRequest(IRP*,UCHAR);
1551 NTSTATUS  WINAPI IoCreateDevice(DRIVER_OBJECT*,ULONG,UNICODE_STRING*,DEVICE_TYPE,ULONG,BOOLEAN,DEVICE_OBJECT**);
1552 NTSTATUS  WINAPI IoCreateDriver(UNICODE_STRING*,PDRIVER_INITIALIZE);
1553 NTSTATUS  WINAPI IoCreateSymbolicLink(UNICODE_STRING*,UNICODE_STRING*);
1554 PKEVENT   WINAPI IoCreateSynchronizationEvent(UNICODE_STRING*,HANDLE*);
1555 void      WINAPI IoDeleteDevice(DEVICE_OBJECT*);
1556 void      WINAPI IoDeleteDriver(DRIVER_OBJECT*);
1557 NTSTATUS  WINAPI IoDeleteSymbolicLink(UNICODE_STRING*);
1558 void      WINAPI IoFreeIrp(IRP*);
1559 void      WINAPI IoFreeMdl(MDL*);
1560 PEPROCESS WINAPI IoGetCurrentProcess(void);
1561 NTSTATUS  WINAPI IoGetDeviceInterfaces(const GUID*,PDEVICE_OBJECT,ULONG,PWSTR*);
1562 NTSTATUS  WINAPI IoGetDeviceObjectPointer(UNICODE_STRING*,ACCESS_MASK,PFILE_OBJECT*,PDEVICE_OBJECT*);
1563 NTSTATUS  WINAPI IoGetDeviceProperty(PDEVICE_OBJECT,DEVICE_REGISTRY_PROPERTY,ULONG,PVOID,PULONG);
1564 PVOID     WINAPI IoGetDriverObjectExtension(PDRIVER_OBJECT,PVOID);
1565 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject(PFILE_OBJECT);
1566 void      WINAPI IoInitializeIrp(IRP*,USHORT,CCHAR);
1567 VOID      WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK,ULONG,ULONG,ULONG,ULONG);
1568 void      WINAPI IoInvalidateDeviceRelations(PDEVICE_OBJECT,DEVICE_RELATION_TYPE);
1569 NTSTATUS  WINAPI IoRegisterDeviceInterface(PDEVICE_OBJECT,const GUID*,PUNICODE_STRING,PUNICODE_STRING);
1570 void      WINAPI IoReleaseCancelSpinLock(KIRQL);
1571 NTSTATUS  WINAPI IoSetDeviceInterfaceState(UNICODE_STRING*,BOOLEAN);
1572 NTSTATUS  WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT,ULONG);
1573
1574 #ifdef __i386__
1575 void      WINAPI KeAcquireSpinLock(KSPIN_LOCK*,KIRQL*);
1576 #else
1577 #define KeAcquireSpinLock( lock, irql ) *(irql) = KeAcquireSpinLockRaiseToDpc( lock )
1578 KIRQL     WINAPI KeAcquireSpinLockRaiseToDpc(KSPIN_LOCK*);
1579 #endif
1580 void      WINAPI KeAcquireSpinLockAtDpcLevel(KSPIN_LOCK*);
1581 BOOLEAN   WINAPI KeCancelTimer(KTIMER*);
1582 void      WINAPI KeClearEvent(PRKEVENT);
1583 NTSTATUS  WINAPI KeDelayExecutionThread(KPROCESSOR_MODE,BOOLEAN,LARGE_INTEGER*);
1584 void      WINAPI KeEnterCriticalRegion(void);
1585 PKTHREAD  WINAPI KeGetCurrentThread(void);
1586 void      WINAPI KeInitializeEvent(PRKEVENT,EVENT_TYPE,BOOLEAN);
1587 void      WINAPI KeInitializeMutex(PRKMUTEX,ULONG);
1588 void      WINAPI KeInitializeSemaphore(PRKSEMAPHORE,LONG,LONG);
1589 void      WINAPI KeInitializeSpinLock(KSPIN_LOCK*);
1590 void      WINAPI KeInitializeTimerEx(PKTIMER,TIMER_TYPE);
1591 void      WINAPI KeInitializeTimer(KTIMER*);
1592 void      WINAPI KeLeaveCriticalRegion(void);
1593 void      WINAPI KeQuerySystemTime(LARGE_INTEGER*);
1594 void      WINAPI KeQueryTickCount(LARGE_INTEGER*);
1595 ULONG     WINAPI KeQueryTimeIncrement(void);
1596 LONG      WINAPI KeReleaseMutex(PRKMUTEX,BOOLEAN);
1597 LONG      WINAPI KeReleaseSemaphore(PRKSEMAPHORE,KPRIORITY,LONG,BOOLEAN);
1598 void      WINAPI KeReleaseSpinLock(KSPIN_LOCK*,KIRQL);
1599 void      WINAPI KeReleaseSpinLockFromDpcLevel(KSPIN_LOCK*);
1600 LONG      WINAPI KeResetEvent(PRKEVENT);
1601 void      WINAPI KeRevertToUserAffinityThread(void);
1602 LONG      WINAPI KeSetEvent(PRKEVENT,KPRIORITY,BOOLEAN);
1603 KPRIORITY WINAPI KeSetPriorityThread(PKTHREAD,KPRIORITY);
1604 void      WINAPI KeSetSystemAffinityThread(KAFFINITY);
1605 BOOLEAN   WINAPI KeSetTimerEx(KTIMER*,LARGE_INTEGER,LONG,KDPC*);
1606 NTSTATUS  WINAPI KeWaitForMultipleObjects(ULONG,void*[],WAIT_TYPE,KWAIT_REASON,KPROCESSOR_MODE,BOOLEAN,LARGE_INTEGER*,KWAIT_BLOCK*);
1607 NTSTATUS  WINAPI KeWaitForSingleObject(void*,KWAIT_REASON,KPROCESSOR_MODE,BOOLEAN,LARGE_INTEGER*);
1608
1609 PVOID     WINAPI MmAllocateContiguousMemory(SIZE_T,PHYSICAL_ADDRESS);
1610 PVOID     WINAPI MmAllocateNonCachedMemory(SIZE_T);
1611 PMDL      WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS,PHYSICAL_ADDRESS,PHYSICAL_ADDRESS,SIZE_T);
1612 void      WINAPI MmBuildMdlForNonPagedPool(MDL*);
1613 void      WINAPI MmFreeNonCachedMemory(PVOID,SIZE_T);
1614 void *    WINAPI MmGetSystemRoutineAddress(UNICODE_STRING*);
1615 PVOID     WINAPI MmMapLockedPagesSpecifyCache(PMDL,KPROCESSOR_MODE,MEMORY_CACHING_TYPE,PVOID,ULONG,ULONG);
1616 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void);
1617 void      WINAPI MmProbeAndLockPages(PMDLX, KPROCESSOR_MODE, LOCK_OPERATION);
1618
1619 static inline void *MmGetSystemAddressForMdlSafe(MDL *mdl, ULONG priority)
1620 {
1621     if (mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | MDL_SOURCE_IS_NONPAGED_POOL))
1622         return mdl->MappedSystemVa;
1623     else
1624         return MmMapLockedPagesSpecifyCache(mdl, KernelMode, MmCached, NULL, FALSE, priority);
1625 }
1626
1627 void      WINAPI ObDereferenceObject(void*);
1628 USHORT    WINAPI ObGetFilterVersion(void);
1629 NTSTATUS  WINAPI ObRegisterCallbacks(POB_CALLBACK_REGISTRATION*, void**);
1630 NTSTATUS  WINAPI ObReferenceObjectByHandle(HANDLE,ACCESS_MASK,POBJECT_TYPE,KPROCESSOR_MODE,PVOID*,POBJECT_HANDLE_INFORMATION);
1631 NTSTATUS  WINAPI ObReferenceObjectByName(UNICODE_STRING*,ULONG,ACCESS_STATE*,ACCESS_MASK,POBJECT_TYPE,KPROCESSOR_MODE,void*,void**);
1632 NTSTATUS  WINAPI ObReferenceObjectByPointer(void*,ACCESS_MASK,POBJECT_TYPE,KPROCESSOR_MODE);
1633 void      WINAPI ObUnRegisterCallbacks(void*);
1634
1635 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT,POWER_STATE_TYPE,POWER_STATE);
1636 NTSTATUS  WINAPI PsCreateSystemThread(PHANDLE,ULONG,POBJECT_ATTRIBUTES,HANDLE,PCLIENT_ID,PKSTART_ROUTINE,PVOID);
1637 #define          PsGetCurrentProcess() IoGetCurrentProcess()
1638 #define          PsGetCurrentThread() ((PETHREAD)KeGetCurrentThread())
1639 HANDLE    WINAPI PsGetCurrentProcessId(void);
1640 HANDLE    WINAPI PsGetCurrentThreadId(void);
1641 BOOLEAN   WINAPI PsGetVersion(ULONG*,ULONG*,ULONG*,UNICODE_STRING*);
1642 NTSTATUS  WINAPI PsTerminateSystemThread(NTSTATUS);
1643
1644 NTSTATUS  WINAPI ZwAddBootEntry(PUNICODE_STRING,PUNICODE_STRING);
1645 NTSTATUS  WINAPI ZwAccessCheckAndAuditAlarm(PUNICODE_STRING,HANDLE,PUNICODE_STRING,PUNICODE_STRING,PSECURITY_DESCRIPTOR,ACCESS_MASK,PGENERIC_MAPPING,BOOLEAN,PACCESS_MASK,PBOOLEAN,PBOOLEAN);
1646 NTSTATUS  WINAPI ZwAdjustPrivilegesToken(HANDLE,BOOLEAN,PTOKEN_PRIVILEGES,DWORD,PTOKEN_PRIVILEGES,PDWORD);
1647 NTSTATUS  WINAPI ZwAlertThread(HANDLE ThreadHandle);
1648 NTSTATUS  WINAPI ZwAllocateVirtualMemory(HANDLE,PVOID*,ULONG,SIZE_T*,ULONG,ULONG);
1649 NTSTATUS  WINAPI ZwCancelIoFile(HANDLE,PIO_STATUS_BLOCK);
1650 NTSTATUS  WINAPI ZwCancelTimer(HANDLE, BOOLEAN*);
1651 NTSTATUS  WINAPI ZwClearEvent(HANDLE);
1652 NTSTATUS  WINAPI ZwClose(HANDLE);
1653 NTSTATUS  WINAPI ZwCloseObjectAuditAlarm(PUNICODE_STRING,HANDLE,BOOLEAN);
1654 NTSTATUS  WINAPI ZwConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
1655 NTSTATUS  WINAPI ZwCreateDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1656 NTSTATUS  WINAPI ZwCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1657 NTSTATUS  WINAPI ZwCreateFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
1658 NTSTATUS  WINAPI ZwCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,const UNICODE_STRING*,ULONG,PULONG);
1659 NTSTATUS  WINAPI ZwCreateSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
1660 NTSTATUS  WINAPI ZwCreateSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PUNICODE_STRING);
1661 NTSTATUS  WINAPI ZwCreateTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*, TIMER_TYPE);
1662 NTSTATUS  WINAPI ZwDeleteAtom(RTL_ATOM);
1663 NTSTATUS  WINAPI ZwDeleteFile(POBJECT_ATTRIBUTES);
1664 NTSTATUS  WINAPI ZwDeleteKey(HANDLE);
1665 NTSTATUS  WINAPI ZwDeleteValueKey(HANDLE,const UNICODE_STRING *);
1666 NTSTATUS  WINAPI ZwDeviceIoControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
1667 NTSTATUS  WINAPI ZwDisplayString(PUNICODE_STRING);
1668 NTSTATUS  WINAPI ZwDuplicateObject(HANDLE,HANDLE,HANDLE,PHANDLE,ACCESS_MASK,ULONG,ULONG);
1669 NTSTATUS  WINAPI ZwDuplicateToken(HANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
1670 NTSTATUS  WINAPI ZwEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1671 NTSTATUS  WINAPI ZwEnumerateValueKey(HANDLE,ULONG,KEY_VALUE_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1672 NTSTATUS  WINAPI ZwFlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
1673 NTSTATUS  WINAPI ZwFlushKey(HANDLE);
1674 NTSTATUS  WINAPI ZwFlushVirtualMemory(HANDLE,LPCVOID*,SIZE_T*,ULONG);
1675 NTSTATUS  WINAPI ZwFreeVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
1676 NTSTATUS  WINAPI ZwFsControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
1677 NTSTATUS  WINAPI ZwInitiatePowerAction(POWER_ACTION,SYSTEM_POWER_STATE,ULONG,BOOLEAN);
1678 NTSTATUS  WINAPI ZwLoadDriver(const UNICODE_STRING *);
1679 NTSTATUS  WINAPI ZwLoadKey(const OBJECT_ATTRIBUTES *,OBJECT_ATTRIBUTES *);
1680 NTSTATUS  WINAPI ZwLockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
1681 NTSTATUS  WINAPI ZwMakeTemporaryObject(HANDLE);
1682 NTSTATUS  WINAPI ZwMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG);
1683 NTSTATUS  WINAPI ZwNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
1684 NTSTATUS  WINAPI ZwOpenDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1685 NTSTATUS  WINAPI ZwOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1686 NTSTATUS  WINAPI ZwOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
1687 NTSTATUS  WINAPI ZwOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1688 NTSTATUS  WINAPI ZwOpenProcess(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
1689 NTSTATUS  WINAPI ZwOpenProcessToken(HANDLE,DWORD,HANDLE *);
1690 NTSTATUS  WINAPI ZwOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
1691 NTSTATUS  WINAPI ZwOpenSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1692 NTSTATUS  WINAPI ZwOpenThread(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
1693 NTSTATUS  WINAPI ZwOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
1694 NTSTATUS  WINAPI ZwOpenTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*);
1695 NTSTATUS  WINAPI ZwPowerInformation(POWER_INFORMATION_LEVEL,PVOID,ULONG,PVOID,ULONG);
1696 NTSTATUS  WINAPI ZwPulseEvent(HANDLE,PULONG);
1697 NTSTATUS  WINAPI ZwQueryDefaultLocale(BOOLEAN,LCID*);
1698 NTSTATUS  WINAPI ZwQueryDefaultUILanguage(LANGID*);
1699 NTSTATUS  WINAPI ZwQueryDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN);
1700 NTSTATUS  WINAPI ZwQueryDirectoryObject(HANDLE,PDIRECTORY_BASIC_INFORMATION,ULONG,BOOLEAN,BOOLEAN,PULONG,PULONG);
1701 NTSTATUS  WINAPI ZwQueryEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,BOOLEAN,PVOID,ULONG,PVOID,BOOLEAN);
1702 NTSTATUS  WINAPI ZwQueryFullAttributesFile(const OBJECT_ATTRIBUTES*,FILE_NETWORK_OPEN_INFORMATION*);
1703 NTSTATUS  WINAPI ZwQueryInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,LONG,FILE_INFORMATION_CLASS);
1704 NTSTATUS  WINAPI ZwQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
1705 NTSTATUS  WINAPI ZwQueryInformationToken(HANDLE,DWORD,PVOID,DWORD,LPDWORD);
1706 NTSTATUS  WINAPI ZwQueryInstallUILanguage(LANGID*);
1707 NTSTATUS  WINAPI ZwQueryKey(HANDLE,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1708 NTSTATUS  WINAPI ZwQueryObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG);
1709 NTSTATUS  WINAPI ZwQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
1710 NTSTATUS  WINAPI ZwQuerySection(HANDLE,SECTION_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1711 NTSTATUS  WINAPI ZwQuerySymbolicLinkObject(HANDLE,PUNICODE_STRING,PULONG);
1712 NTSTATUS  WINAPI ZwQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1713 NTSTATUS  WINAPI ZwQueryTimerResolution(PULONG,PULONG,PULONG);
1714 NTSTATUS  WINAPI ZwQueryValueKey(HANDLE,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
1715 NTSTATUS  WINAPI ZwQueryVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
1716 NTSTATUS  WINAPI ZwReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
1717 NTSTATUS  WINAPI ZwReplaceKey(POBJECT_ATTRIBUTES,HANDLE,POBJECT_ATTRIBUTES);
1718 NTSTATUS  WINAPI ZwRequestWaitReplyPort(HANDLE,PLPC_MESSAGE,PLPC_MESSAGE);
1719 NTSTATUS  WINAPI ZwResetEvent(HANDLE,PULONG);
1720 NTSTATUS  WINAPI ZwRestoreKey(HANDLE,HANDLE,ULONG);
1721 NTSTATUS  WINAPI ZwSaveKey(HANDLE,HANDLE);
1722 NTSTATUS  WINAPI ZwSecureConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PSID,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
1723 NTSTATUS  WINAPI ZwSetDefaultLocale(BOOLEAN,LCID);
1724 NTSTATUS  WINAPI ZwSetDefaultUILanguage(LANGID);
1725 NTSTATUS  WINAPI ZwSetEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG);
1726 NTSTATUS  WINAPI ZwSetEvent(HANDLE,PULONG);
1727 NTSTATUS  WINAPI ZwSetInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS);
1728 NTSTATUS  WINAPI ZwSetInformationKey(HANDLE,const int,PVOID,ULONG);
1729 NTSTATUS  WINAPI ZwSetInformationObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG);
1730 NTSTATUS  WINAPI ZwSetInformationProcess(HANDLE,PROCESS_INFORMATION_CLASS,PVOID,ULONG);
1731 NTSTATUS  WINAPI ZwSetInformationThread(HANDLE,THREADINFOCLASS,LPCVOID,ULONG);
1732 NTSTATUS  WINAPI ZwSetIoCompletion(HANDLE,ULONG,ULONG,NTSTATUS,ULONG);
1733 NTSTATUS  WINAPI ZwSetLdtEntries(ULONG,ULONG,ULONG,ULONG,ULONG,ULONG);
1734 NTSTATUS  WINAPI ZwSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
1735 NTSTATUS  WINAPI ZwSetSystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG);
1736 NTSTATUS  WINAPI ZwSetSystemTime(const LARGE_INTEGER*,LARGE_INTEGER*);
1737 NTSTATUS  WINAPI ZwSetTimer(HANDLE, const LARGE_INTEGER*, PTIMER_APC_ROUTINE, PVOID, BOOLEAN, ULONG, BOOLEAN*);
1738 NTSTATUS  WINAPI ZwSetValueKey(HANDLE,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
1739 NTSTATUS  WINAPI ZwSetVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
1740 NTSTATUS  WINAPI ZwSuspendThread(HANDLE,PULONG);
1741 NTSTATUS  WINAPI ZwTerminateProcess(HANDLE,LONG);
1742 NTSTATUS  WINAPI ZwUnloadDriver(const UNICODE_STRING *);
1743 NTSTATUS  WINAPI ZwUnloadKey(HANDLE);
1744 NTSTATUS  WINAPI ZwUnmapViewOfSection(HANDLE,PVOID);
1745 NTSTATUS  WINAPI ZwWaitForSingleObject(HANDLE,BOOLEAN,const LARGE_INTEGER*);
1746 NTSTATUS  WINAPI ZwWaitForMultipleObjects(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,const LARGE_INTEGER*);
1747 NTSTATUS  WINAPI ZwWriteFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,const void*,ULONG,PLARGE_INTEGER,PULONG);
1748 NTSTATUS  WINAPI ZwYieldExecution(void);
1749
1750 static inline void ExInitializeFastMutex( FAST_MUTEX *mutex )
1751 {
1752     mutex->Count = FM_LOCK_BIT;
1753     mutex->Owner = NULL;
1754     mutex->Contention = 0;
1755     KeInitializeEvent( &mutex->Event, SynchronizationEvent, FALSE );
1756 }
1757
1758 #endif