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