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