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 {
 741   DevicePropertyDeviceDescription,
 742   DevicePropertyHardwareID,
 743   DevicePropertyCompatibleIDs,
 744   DevicePropertyBootConfiguration,
 745   DevicePropertyBootConfigurationTranslated,
 746   DevicePropertyClassName,
 747   DevicePropertyClassGuid,
 748   DevicePropertyDriverKeyName,
 749   DevicePropertyManufacturer,
 750   DevicePropertyFriendlyName,
 751   DevicePropertyLocationInformation,
 752   DevicePropertyPhysicalDeviceObjectName,
 753   DevicePropertyBusTypeGuid,
 754   DevicePropertyLegacyBusType,
 755   DevicePropertyBusNumber,
 756   DevicePropertyEnumeratorName,
 757   DevicePropertyAddress,
 758   DevicePropertyUINumber,
 759   DevicePropertyInstallState,
 760   DevicePropertyRemovalPolicy
 761 } DEVICE_REGISTRY_PROPERTY;
 762
 763 typedef enum _DEVICE_TEXT_TYPE {
 764   DeviceTextDescription,
 765   DeviceTextLocationInformation
 766 } DEVICE_TEXT_TYPE, *PDEVICE_TEXT_TYPE;
 767
 768 typedef enum _DEVICE_USAGE_NOTIFICATION_TYPE {
 769   DeviceUsageTypeUndefined,
 770   DeviceUsageTypePaging,
 771   DeviceUsageTypeHibernation,
 772   DeviceUsageTypeDumpFile
 773 } DEVICE_USAGE_NOTIFICATION_TYPE;
 774
 775 typedef struct _POWER_SEQUENCE {
 776   ULONG  SequenceD1;
 777   ULONG  SequenceD2;
 778   ULONG  SequenceD3;
 779 } POWER_SEQUENCE, *PPOWER_SEQUENCE;
 780
 781 typedef enum _POWER_STATE_TYPE {
 782   SystemPowerState,
 783   DevicePowerState
 784 } POWER_STATE_TYPE, *PPOWER_STATE_TYPE;
 785
 786 typedef union _POWER_STATE {
 787   SYSTEM_POWER_STATE  SystemState;
 788   DEVICE_POWER_STATE  DeviceState;
 789 } POWER_STATE, *PPOWER_STATE;
 790
 791 typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR {
 792   UCHAR Type;
 793   UCHAR ShareDisposition;
 794   USHORT Flags;
 795   union {
 796     struct {
 797       PHYSICAL_ADDRESS Start;
 798       ULONG Length;
 799     } Generic;
 800     struct {
 801       PHYSICAL_ADDRESS Start;
 802       ULONG Length;
 803     } Port;
 804     struct {
 805       ULONG Level;
 806       ULONG Vector;
 807       ULONG Affinity;
 808     } Interrupt;
 809     struct {
 810       PHYSICAL_ADDRESS Start;
 811       ULONG Length;
 812     } Memory;
 813     struct {
 814       ULONG Channel;
 815       ULONG Port;
 816       ULONG Reserved1;
 817     } Dma;
 818     struct {
 819       ULONG Data[3];
 820     } DevicePrivate;
 821     struct {
 822       ULONG Start;
 823       ULONG Length;
 824       ULONG Reserved;
 825     } BusNumber;
 826     struct {
 827       ULONG DataSize;
 828       ULONG Reserved1;
 829       ULONG Reserved2;
 830     } DeviceSpecificData;
 831   } u;
 832 } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
 833
 834 typedef struct _CM_PARTIAL_RESOURCE_LIST {
 835   USHORT  Version;
 836   USHORT  Revision;
 837   ULONG  Count;
 838   CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
 839 } CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST;
 840
 841 typedef struct _CM_FULL_RESOURCE_DESCRIPTOR {
 842   INTERFACE_TYPE  InterfaceType;
 843   ULONG  BusNumber;
 844   CM_PARTIAL_RESOURCE_LIST  PartialResourceList;
 845 } CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR;
 846
 847 typedef struct _CM_RESOURCE_LIST {
 848   ULONG  Count;
 849   CM_FULL_RESOURCE_DESCRIPTOR  List[1];
 850 } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
 851
 852 typedef NTSTATUS (WINAPI *PIO_COMPLETION_ROUTINE)(
 853   IN struct _DEVICE_OBJECT  *DeviceObject,
 854   IN struct _IRP  *Irp,
 855   IN PVOID  Context);
 856
 857 #define SL_PENDING_RETURNED             0x01
 858 #define SL_INVOKE_ON_CANCEL             0x20
 859 #define SL_INVOKE_ON_SUCCESS            0x40
 860 #define SL_INVOKE_ON_ERROR              0x80
 861
 862 #if !defined(_WIN64)
 863 #include <pshpack4.h>
 864 #endif
 865 typedef struct _IO_STACK_LOCATION {
 866   UCHAR  MajorFunction;
 867   UCHAR  MinorFunction;
 868   UCHAR  Flags;
 869   UCHAR  Control;
 870   union {
 871     struct {
 872       PIO_SECURITY_CONTEXT  SecurityContext;
 873       ULONG  Options;
 874       USHORT POINTER_ALIGNMENT  FileAttributes;
 875       USHORT  ShareAccess;
 876       ULONG POINTER_ALIGNMENT  EaLength;
 877     } Create;
 878     struct {
 879       ULONG  Length;
 880       ULONG POINTER_ALIGNMENT  Key;
 881       LARGE_INTEGER  ByteOffset;
 882     } Read;
 883     struct {
 884       ULONG  Length;
 885       ULONG POINTER_ALIGNMENT  Key;
 886       LARGE_INTEGER  ByteOffset;
 887     } Write;
 888     struct {
 889       ULONG  Length;
 890       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 891     } QueryFile;
 892     struct {
 893       ULONG  Length;
 894       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 895       PFILE_OBJECT  FileObject;
 896       union {
 897         struct {
 898           BOOLEAN  ReplaceIfExists;
 899           BOOLEAN  AdvanceOnly;
 900         } DUMMYSTRUCTNAME;
 901         ULONG  ClusterCount;
 902         HANDLE  DeleteHandle;
 903       } DUMMYUNIONNAME;
 904     } SetFile;
 905     struct {
 906       ULONG  Length;
 907       FS_INFORMATION_CLASS POINTER_ALIGNMENT  FsInformationClass;
 908     } QueryVolume;
 909     struct {
 910       ULONG  OutputBufferLength;
 911       ULONG POINTER_ALIGNMENT  InputBufferLength;
 912       ULONG POINTER_ALIGNMENT  IoControlCode;
 913       PVOID  Type3InputBuffer;
 914     } DeviceIoControl;
 915     struct {
 916       SECURITY_INFORMATION  SecurityInformation;
 917       ULONG POINTER_ALIGNMENT  Length;
 918     } QuerySecurity;
 919     struct {
 920       SECURITY_INFORMATION  SecurityInformation;
 921       PSECURITY_DESCRIPTOR  SecurityDescriptor;
 922     } SetSecurity;
 923     struct {
 924       PVPB  Vpb;
 925       PDEVICE_OBJECT  DeviceObject;
 926     } MountVolume;
 927     struct {
 928       PVPB  Vpb;
 929       PDEVICE_OBJECT  DeviceObject;
 930     } VerifyVolume;
 931     struct {
 932       struct _SCSI_REQUEST_BLOCK  *Srb;
 933     } Scsi;
 934     struct {
 935       DEVICE_RELATION_TYPE  Type;
 936     } QueryDeviceRelations;
 937     struct {
 938       const GUID  *InterfaceType;
 939       USHORT  Size;
 940       USHORT  Version;
 941       PINTERFACE  Interface;
 942       PVOID  InterfaceSpecificData;
 943     } QueryInterface;
 944     struct {
 945       PDEVICE_CAPABILITIES  Capabilities;
 946     } DeviceCapabilities;
 947     struct {
 948       PIO_RESOURCE_REQUIREMENTS_LIST  IoResourceRequirementList;
 949     } FilterResourceRequirements;
 950     struct {
 951       ULONG  WhichSpace;
 952       PVOID  Buffer;
 953       ULONG  Offset;
 954       ULONG POINTER_ALIGNMENT  Length;
 955     } ReadWriteConfig;
 956     struct {
 957       BOOLEAN  Lock;
 958     } SetLock;
 959     struct {
 960       BUS_QUERY_ID_TYPE  IdType;
 961     } QueryId;
 962     struct {
 963       DEVICE_TEXT_TYPE  DeviceTextType;
 964       LCID POINTER_ALIGNMENT  LocaleId;
 965     } QueryDeviceText;
 966     struct {
 967       BOOLEAN  InPath;
 968       BOOLEAN  Reserved[3];
 969       DEVICE_USAGE_NOTIFICATION_TYPE POINTER_ALIGNMENT  Type;
 970     } UsageNotification;
 971     struct {
 972       SYSTEM_POWER_STATE  PowerState;
 973     } WaitWake;
 974     struct {
 975       PPOWER_SEQUENCE  PowerSequence;
 976     } PowerSequence;
 977     struct {
 978       ULONG  SystemContext;
 979       POWER_STATE_TYPE POINTER_ALIGNMENT  Type;
 980       POWER_STATE POINTER_ALIGNMENT  State;
 981       POWER_ACTION POINTER_ALIGNMENT  ShutdownType;
 982     } Power;
 983     struct {
 984       PCM_RESOURCE_LIST  AllocatedResources;
 985       PCM_RESOURCE_LIST  AllocatedResourcesTranslated;
 986     } StartDevice;
 987     struct {
 988       ULONG_PTR  ProviderId;
 989       PVOID  DataPath;
 990       ULONG  BufferSize;
 991       PVOID  Buffer;
 992     } WMI;
 993     struct {
 994       PVOID  Argument1;
 995       PVOID  Argument2;
 996       PVOID  Argument3;
 997       PVOID  Argument4;
 998     } Others;
 999   } Parameters;
1000   PDEVICE_OBJECT  DeviceObject;
1001   PFILE_OBJECT  FileObject;
1002   PIO_COMPLETION_ROUTINE  CompletionRoutine;
1003   PVOID  Context;
1004 } IO_STACK_LOCATION, *PIO_STACK_LOCATION;
1005 #if !defined(_WIN64)
1006 #include <poppack.h>
1007 #endif
1008
1009 /* MDL definitions */
1010
1011 #define MDL_MAPPED_TO_SYSTEM_VA     0x0001
1012 #define MDL_PAGES_LOCKED            0x0002
1013 #define MDL_SOURCE_IS_NONPAGED_POOL 0x0004
1014 #define MDL_ALLOCATED_FIXED_SIZE    0x0008
1015 #define MDL_PARTIAL                 0x0010
1016 #define MDL_PARTIAL_HAS_BEEN_MAPPED 0x0020
1017 #define MDL_IO_PAGE_READ            0x0040
1018 #define MDL_WRITE_OPERATION         0x0080
1019 #define MDL_PARENT_MAPPED_SYSTEM_VA 0x0100
1020 #define MDL_FREE_EXTRA_PTES         0x0200
1021 #define MDL_DESCRIBES_AWE           0x0400
1022 #define MDL_IO_SPACE                0x0800
1023 #define MDL_NETWORK_HEADER          0x1000
1024 #define MDL_MAPPING_CAN_FAIL        0x2000
1025 #define MDL_ALLOCATED_MUST_SUCCEED  0x4000
1026 #define MDL_INTERNAL                0x8000
1027
1028 #define MDL_MAPPING_FLAGS (MDL_MAPPED_TO_SYSTEM_VA     | \
1029                            MDL_PAGES_LOCKED            | \
1030                            MDL_SOURCE_IS_NONPAGED_POOL | \
1031                            MDL_PARTIAL_HAS_BEEN_MAPPED | \
1032                            MDL_PARENT_MAPPED_SYSTEM_VA | \
1033                            MDL_SYSTEM_VA               | \
1034                            MDL_IO_SPACE )
1035
1036 typedef struct _MDL {
1037   struct _MDL  *Next;
1038   CSHORT  Size;
1039   CSHORT  MdlFlags;
1040   struct _EPROCESS  *Process;
1041   PVOID  MappedSystemVa;
1042   PVOID  StartVa;
1043   ULONG  ByteCount;
1044   ULONG  ByteOffset;
1045 } MDL, *PMDL;
1046
1047 typedef MDL *PMDLX;
1048 typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
1049
1050 static inline void MmInitializeMdl(MDL *mdl, void *va, SIZE_T length)
1051 {
1052     mdl->Next       = NULL;
1053     mdl->Size       = sizeof(MDL) + sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(va, length);
1054     mdl->MdlFlags   = 0;
1055     mdl->StartVa    = (void *)PAGE_ALIGN(va);
1056     mdl->ByteOffset = BYTE_OFFSET(va);
1057     mdl->ByteCount  = length;
1058 }
1059
1060 typedef struct _KTIMER {
1061     DISPATCHER_HEADER Header;
1062     ULARGE_INTEGER DueTime;
1063     LIST_ENTRY TimerListEntry;
1064     struct _KDPC *Dpc;
1065     LONG Period;
1066 } KTIMER, *PKTIMER;
1067
1068 typedef struct _KSYSTEM_TIME {
1069     ULONG LowPart;
1070     LONG High1Time;
1071     LONG High2Time;
1072 } KSYSTEM_TIME, *PKSYSTEM_TIME;
1073
1074 typedef enum _NT_PRODUCT_TYPE {
1075     NtProductWinNt = 1,
1076     NtProductLanManNt,
1077     NtProductServer
1078 } NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;
1079
1080 #define PROCESSOR_FEATURE_MAX 64
1081
1082 typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE
1083 {
1084    StandardDesign,
1085    NEC98x86,
1086    EndAlternatives
1087 } ALTERNATIVE_ARCHITECTURE_TYPE;
1088
1089 #define NX_SUPPORT_POLICY_ALWAYSOFF     0
1090 #define NX_SUPPORT_POLICY_ALWAYSON      1
1091 #define NX_SUPPORT_POLICY_OPTIN         2
1092 #define NX_SUPPORT_POLICY_OPTOUT        3
1093
1094 #define MAX_WOW64_SHARED_ENTRIES 16
1095
1096 typedef struct _KUSER_SHARED_DATA {
1097     ULONG TickCountLowDeprecated;
1098     ULONG TickCountMultiplier;
1099     volatile KSYSTEM_TIME InterruptTime;
1100     volatile KSYSTEM_TIME SystemTime;
1101     volatile KSYSTEM_TIME TimeZoneBias;
1102     USHORT ImageNumberLow;
1103     USHORT ImageNumberHigh;
1104     WCHAR NtSystemRoot[260];
1105     ULONG MaxStackTraceDepth;
1106     ULONG CryptoExponent;
1107     ULONG TimeZoneId;
1108     ULONG LargePageMinimum;
1109     ULONG Reserved2[7];
1110     NT_PRODUCT_TYPE NtProductType;
1111     BOOLEAN ProductTypeIsValid;
1112     ULONG NtMajorVersion;
1113     ULONG NtMinorVersion;
1114     BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX];
1115     ULONG Reserved1;
1116     ULONG Reserved3;
1117     volatile ULONG TimeSlip;
1118     ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
1119     LARGE_INTEGER SystemExpirationDate;
1120     ULONG SuiteMask;
1121     BOOLEAN KdDebuggerEnabled;
1122     UCHAR NXSupportPolicy;
1123     volatile ULONG ActiveConsoleId;
1124     volatile ULONG DismountCount;
1125     ULONG ComPlusPackage;
1126     ULONG LastSystemRITEventTickCount;
1127     ULONG NumberOfPhysicalPages;
1128     BOOLEAN SafeBootMode;
1129     ULONG TraceLogging;
1130     ULONGLONG TestRetInstruction;
1131     ULONG SystemCall;
1132     ULONG SystemCallReturn;
1133     ULONGLONG SystemCallPad[3];
1134     union {
1135         volatile KSYSTEM_TIME TickCount;
1136         volatile ULONG64 TickCountQuad;
1137     } DUMMYUNIONNAME;
1138     ULONG Cookie;
1139     ULONG Wow64SharedInformation[MAX_WOW64_SHARED_ENTRIES];
1140 } KSHARED_USER_DATA, *PKSHARED_USER_DATA;
1141
1142 typedef enum _MEMORY_CACHING_TYPE {
1143     MmNonCached = 0,
1144     MmCached = 1,
1145     MmWriteCombined = 2,
1146     MmHardwareCoherentCached = 3,
1147     MmNonCachedUnordered = 4,
1148     MmUSWCCached = 5,
1149     MmMaximumCacheType = 6
1150 } MEMORY_CACHING_TYPE;
1151
1152 typedef enum _MM_PAGE_PRIORITY {
1153     LowPagePriority,
1154     NormalPagePriority = 16,
1155     HighPagePriority = 32
1156 } MM_PAGE_PRIORITY;
1157
1158 typedef enum _MM_SYSTEM_SIZE
1159 {
1160     MmSmallSystem,
1161     MmMediumSystem,
1162     MmLargeSystem
1163 } MM_SYSTEMSIZE;
1164
1165 typedef struct _IO_REMOVE_LOCK_COMMON_BLOCK {
1166     BOOLEAN Removed;
1167     BOOLEAN Reserved[3];
1168     LONG IoCount;
1169     KEVENT RemoveEvent;
1170 } IO_REMOVE_LOCK_COMMON_BLOCK;
1171
1172 typedef struct _IO_REMOVE_LOCK_TRACKING_BLOCK *PIO_REMOVE_LOCK_TRACKING_BLOCK;
1173
1174 typedef struct _IO_REMOVE_LOCK_DBG_BLOCK {
1175     LONG Signature;
1176     LONG HighWatermark;
1177     LONGLONG MaxLockedTicks;
1178     LONG AllocateTag;
1179     LIST_ENTRY LockList;
1180     KSPIN_LOCK Spin;
1181     LONG LowMemoryCount;
1182     ULONG Reserved1[4];
1183     PVOID Reserved2;
1184     PIO_REMOVE_LOCK_TRACKING_BLOCK Blocks;
1185 } IO_REMOVE_LOCK_DBG_BLOCK;
1186
1187 typedef struct _IO_REMOVE_LOCK {
1188     IO_REMOVE_LOCK_COMMON_BLOCK Common;
1189     IO_REMOVE_LOCK_DBG_BLOCK Dbg;
1190 } IO_REMOVE_LOCK, *PIO_REMOVE_LOCK;
1191
1192 typedef enum  {
1193     IoReadAccess,
1194     IoWriteAccess,
1195     IoModifyAccess
1196 } LOCK_OPERATION;
1197
1198 typedef struct _CALLBACK_OBJECT
1199 {
1200     ULONG Signature;
1201     KSPIN_LOCK Lock;
1202     LIST_ENTRY RegisteredCallbacks;
1203     BOOLEAN AllowMultipleCallbacks;
1204     UCHAR reserved[3];
1205 } CALLBACK_OBJECT, *PCALLBACK_OBJECT;
1206
1207 typedef NTSTATUS (NTAPI EX_CALLBACK_FUNCTION)(void *CallbackContext, void *Argument1, void *Argument2);
1208 typedef EX_CALLBACK_FUNCTION *PEX_CALLBACK_FUNCTION;
1209
1210 NTSTATUS WINAPI ObCloseHandle(IN HANDLE handle);
1211
1212 #ifdef NONAMELESSUNION
1213 # ifdef NONAMELESSSTRUCT
1214 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.u2.CurrentStackLocation)
1215 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.u2.CurrentStackLocation - 1)
1216    static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.s.u2.CurrentStackLocation++; irp->CurrentLocation++;}
1217 # else
1218 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.u2.CurrentStackLocation)
1219 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.u2.CurrentStackLocation - 1)
1220    static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.u2.CurrentStackLocation++; irp->CurrentLocation++;}
1221 # endif
1222 #else
1223 # ifdef NONAMELESSSTRUCT
1224 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.CurrentStackLocation)
1225 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.s.CurrentStackLocation - 1)
1226     static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.s.CurrentStackLocation++; irp->CurrentLocation++;}
1227 # else
1228 #  define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.CurrentStackLocation)
1229 #  define IoGetNextIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.CurrentStackLocation - 1)
1230     static inline void IoSkipCurrentIrpStackLocation(IRP *irp) {irp->Tail.Overlay.CurrentStackLocation++; irp->CurrentLocation++;}
1231 # endif
1232 #endif
1233
1234 static inline void IoSetCompletionRoutine(IRP *irp, PIO_COMPLETION_ROUTINE routine, void *context,
1235                                           BOOLEAN on_success, BOOLEAN on_error, BOOLEAN on_cancel)
1236 {
1237     IO_STACK_LOCATION *irpsp = IoGetNextIrpStackLocation(irp);
1238     irpsp->CompletionRoutine = routine;
1239     irpsp->Context = context;
1240     irpsp->Control = 0;
1241     if (on_success) irpsp->Control |= SL_INVOKE_ON_SUCCESS;
1242     if (on_error)   irpsp->Control |= SL_INVOKE_ON_ERROR;
1243     if (on_cancel)  irpsp->Control |= SL_INVOKE_ON_CANCEL;
1244 }
1245
1246 #define KernelMode 0
1247 #define UserMode   1
1248
1249 /* directory object access rights */
1250 #define DIRECTORY_QUERY                 0x0001
1251 #define DIRECTORY_TRAVERSE              0x0002
1252 #define DIRECTORY_CREATE_OBJECT         0x0004
1253 #define DIRECTORY_CREATE_SUBDIRECTORY   0x0008
1254 #define DIRECTORY_ALL_ACCESS            (STANDARD_RIGHTS_REQUIRED | 0xF)
1255
1256 /* symbolic link access rights */
1257 #define SYMBOLIC_LINK_QUERY             0x0001
1258 #define SYMBOLIC_LINK_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | 0x1)
1259
1260 PVOID     WINAPI ExAllocatePool(POOL_TYPE,SIZE_T);
1261 PVOID     WINAPI ExAllocatePoolWithQuota(POOL_TYPE,SIZE_T);
1262 PVOID     WINAPI ExAllocatePoolWithTag(POOL_TYPE,SIZE_T,ULONG);
1263 PVOID     WINAPI ExAllocatePoolWithQuotaTag(POOL_TYPE,SIZE_T,ULONG);
1264 void      WINAPI ExFreePool(PVOID);
1265 void      WINAPI ExFreePoolWithTag(PVOID,ULONG);
1266
1267 NTSTATUS  WINAPI IoAllocateDriverObjectExtension(PDRIVER_OBJECT,PVOID,ULONG,PVOID*);
1268 PVOID     WINAPI IoAllocateErrorLogEntry(PVOID,UCHAR);
1269 PIRP      WINAPI IoAllocateIrp(CCHAR,BOOLEAN);
1270 PMDL      WINAPI IoAllocateMdl(PVOID,ULONG,BOOLEAN,BOOLEAN,IRP*);
1271 PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack(PDEVICE_OBJECT,PDEVICE_OBJECT);
1272 PIRP      WINAPI IoBuildDeviceIoControlRequest(ULONG,DEVICE_OBJECT*,PVOID,ULONG,PVOID,ULONG,BOOLEAN,PKEVENT,IO_STATUS_BLOCK*);
1273 PIRP      WINAPI IoBuildSynchronousFsdRequest(ULONG,DEVICE_OBJECT*,PVOID,ULONG,PLARGE_INTEGER,PKEVENT,IO_STATUS_BLOCK*);
1274 NTSTATUS  WINAPI IoCallDriver(DEVICE_OBJECT*,IRP*);
1275 VOID      WINAPI IoCompleteRequest(IRP*,UCHAR);
1276 NTSTATUS  WINAPI IoCreateDevice(DRIVER_OBJECT*,ULONG,UNICODE_STRING*,DEVICE_TYPE,ULONG,BOOLEAN,DEVICE_OBJECT**);
1277 NTSTATUS  WINAPI IoCreateDriver(UNICODE_STRING*,PDRIVER_INITIALIZE);
1278 NTSTATUS  WINAPI IoCreateSymbolicLink(UNICODE_STRING*,UNICODE_STRING*);
1279 void      WINAPI IoDeleteDevice(DEVICE_OBJECT*);
1280 void      WINAPI IoDeleteDriver(DRIVER_OBJECT*);
1281 NTSTATUS  WINAPI IoDeleteSymbolicLink(UNICODE_STRING*);
1282 void      WINAPI IoFreeIrp(IRP*);
1283 void      WINAPI IoFreeMdl(MDL*);
1284 PEPROCESS WINAPI IoGetCurrentProcess(void);
1285 NTSTATUS  WINAPI IoGetDeviceInterfaces(const GUID*,PDEVICE_OBJECT,ULONG,PWSTR*);
1286 NTSTATUS  WINAPI IoGetDeviceObjectPointer(UNICODE_STRING*,ACCESS_MASK,PFILE_OBJECT*,PDEVICE_OBJECT*);
1287 NTSTATUS  WINAPI IoGetDeviceProperty(PDEVICE_OBJECT,DEVICE_REGISTRY_PROPERTY,ULONG,PVOID,PULONG);
1288 PVOID     WINAPI IoGetDriverObjectExtension(PDRIVER_OBJECT,PVOID);
1289 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject(PFILE_OBJECT);
1290 void      WINAPI IoInitializeIrp(IRP*,USHORT,CCHAR);
1291 VOID      WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK,ULONG,ULONG,ULONG,ULONG);
1292 void      WINAPI IoInvalidateDeviceRelations(PDEVICE_OBJECT,DEVICE_RELATION_TYPE);
1293 NTSTATUS  WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT,ULONG);
1294
1295 PKTHREAD  WINAPI KeGetCurrentThread(void);
1296 void      WINAPI KeQuerySystemTime(LARGE_INTEGER*);
1297 void      WINAPI KeQueryTickCount(LARGE_INTEGER*);
1298 ULONG     WINAPI KeQueryTimeIncrement(void);
1299 LONG      WINAPI KeReleaseSemaphore(PRKSEMAPHORE,KPRIORITY,LONG,BOOLEAN);
1300 LONG      WINAPI KeResetEvent(PRKEVENT);
1301 LONG      WINAPI KeSetEvent(PRKEVENT,KPRIORITY,BOOLEAN);
1302 KPRIORITY WINAPI KeSetPriorityThread(PKTHREAD,KPRIORITY);
1303 void      WINAPI KeSetSystemAffinityThread(KAFFINITY);
1304
1305 PVOID     WINAPI MmAllocateContiguousMemory(SIZE_T,PHYSICAL_ADDRESS);
1306 PVOID     WINAPI MmAllocateNonCachedMemory(SIZE_T);
1307 PMDL      WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS,PHYSICAL_ADDRESS,PHYSICAL_ADDRESS,SIZE_T);
1308 void      WINAPI MmFreeNonCachedMemory(PVOID,SIZE_T);
1309 PVOID     WINAPI MmMapLockedPagesSpecifyCache(PMDL,KPROCESSOR_MODE,MEMORY_CACHING_TYPE,PVOID,ULONG,ULONG);
1310 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void);
1311
1312 static inline void *MmGetSystemAddressForMdlSafe(MDL *mdl, ULONG priority)
1313 {
1314     if (mdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | MDL_SOURCE_IS_NONPAGED_POOL))
1315         return mdl->MappedSystemVa;
1316     else
1317         return MmMapLockedPagesSpecifyCache(mdl, KernelMode, MmCached, NULL, FALSE, priority);
1318 }
1319
1320 void      WINAPI ObDereferenceObject(void*);
1321 NTSTATUS  WINAPI ObReferenceObjectByHandle(HANDLE,ACCESS_MASK,POBJECT_TYPE,KPROCESSOR_MODE,PVOID*,POBJECT_HANDLE_INFORMATION);
1322 NTSTATUS  WINAPI ObReferenceObjectByName(UNICODE_STRING*,ULONG,ACCESS_STATE*,ACCESS_MASK,POBJECT_TYPE,KPROCESSOR_MODE,void*,void**);
1323
1324 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT,POWER_STATE_TYPE,POWER_STATE);
1325 NTSTATUS  WINAPI PsCreateSystemThread(PHANDLE,ULONG,POBJECT_ATTRIBUTES,HANDLE,PCLIENT_ID,PKSTART_ROUTINE,PVOID);
1326 #define          PsGetCurrentProcess() IoGetCurrentProcess()
1327 #define          PsGetCurrentThread() ((PETHREAD)KeGetCurrentThread())
1328 HANDLE    WINAPI PsGetCurrentProcessId(void);
1329 HANDLE    WINAPI PsGetCurrentThreadId(void);
1330 BOOLEAN   WINAPI PsGetVersion(ULONG*,ULONG*,ULONG*,UNICODE_STRING*);
1331 NTSTATUS  WINAPI PsTerminateSystemThread(NTSTATUS);
1332
1333 NTSTATUS  WINAPI ZwAddBootEntry(PUNICODE_STRING,PUNICODE_STRING);
1334 NTSTATUS  WINAPI ZwAccessCheckAndAuditAlarm(PUNICODE_STRING,HANDLE,PUNICODE_STRING,PUNICODE_STRING,PSECURITY_DESCRIPTOR,ACCESS_MASK,PGENERIC_MAPPING,BOOLEAN,PACCESS_MASK,PBOOLEAN,PBOOLEAN);
1335 NTSTATUS  WINAPI ZwAdjustPrivilegesToken(HANDLE,BOOLEAN,PTOKEN_PRIVILEGES,DWORD,PTOKEN_PRIVILEGES,PDWORD);
1336 NTSTATUS  WINAPI ZwAlertThread(HANDLE ThreadHandle);
1337 NTSTATUS  WINAPI ZwAllocateVirtualMemory(HANDLE,PVOID*,ULONG,SIZE_T*,ULONG,ULONG);
1338 NTSTATUS  WINAPI ZwCancelIoFile(HANDLE,PIO_STATUS_BLOCK);
1339 NTSTATUS  WINAPI ZwCancelTimer(HANDLE, BOOLEAN*);
1340 NTSTATUS  WINAPI ZwClearEvent(HANDLE);
1341 NTSTATUS  WINAPI ZwClose(HANDLE);
1342 NTSTATUS  WINAPI ZwCloseObjectAuditAlarm(PUNICODE_STRING,HANDLE,BOOLEAN);
1343 NTSTATUS  WINAPI ZwConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
1344 NTSTATUS  WINAPI ZwCreateDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1345 NTSTATUS  WINAPI ZwCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1346 NTSTATUS  WINAPI ZwCreateFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
1347 NTSTATUS  WINAPI ZwCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,const UNICODE_STRING*,ULONG,PULONG);
1348 NTSTATUS  WINAPI ZwCreateSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
1349 NTSTATUS  WINAPI ZwCreateSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PUNICODE_STRING);
1350 NTSTATUS  WINAPI ZwCreateTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*, TIMER_TYPE);
1351 NTSTATUS  WINAPI ZwDeleteAtom(RTL_ATOM);
1352 NTSTATUS  WINAPI ZwDeleteFile(POBJECT_ATTRIBUTES);
1353 NTSTATUS  WINAPI ZwDeleteKey(HANDLE);
1354 NTSTATUS  WINAPI ZwDeleteValueKey(HANDLE,const UNICODE_STRING *);
1355 NTSTATUS  WINAPI ZwDeviceIoControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
1356 NTSTATUS  WINAPI ZwDisplayString(PUNICODE_STRING);
1357 NTSTATUS  WINAPI ZwDuplicateObject(HANDLE,HANDLE,HANDLE,PHANDLE,ACCESS_MASK,ULONG,ULONG);
1358 NTSTATUS  WINAPI ZwDuplicateToken(HANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
1359 NTSTATUS  WINAPI ZwEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1360 NTSTATUS  WINAPI ZwEnumerateValueKey(HANDLE,ULONG,KEY_VALUE_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1361 NTSTATUS  WINAPI ZwFlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
1362 NTSTATUS  WINAPI ZwFlushKey(HANDLE);
1363 NTSTATUS  WINAPI ZwFlushVirtualMemory(HANDLE,LPCVOID*,SIZE_T*,ULONG);
1364 NTSTATUS  WINAPI ZwFreeVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
1365 NTSTATUS  WINAPI ZwFsControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
1366 NTSTATUS  WINAPI ZwInitiatePowerAction(POWER_ACTION,SYSTEM_POWER_STATE,ULONG,BOOLEAN);
1367 NTSTATUS  WINAPI ZwLoadDriver(const UNICODE_STRING *);
1368 NTSTATUS  WINAPI ZwLoadKey(const OBJECT_ATTRIBUTES *,OBJECT_ATTRIBUTES *);
1369 NTSTATUS  WINAPI ZwLockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
1370 NTSTATUS  WINAPI ZwMakeTemporaryObject(HANDLE);
1371 NTSTATUS  WINAPI ZwMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG);
1372 NTSTATUS  WINAPI ZwNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
1373 NTSTATUS  WINAPI ZwOpenDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1374 NTSTATUS  WINAPI ZwOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1375 NTSTATUS  WINAPI ZwOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
1376 NTSTATUS  WINAPI ZwOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1377 NTSTATUS  WINAPI ZwOpenProcess(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
1378 NTSTATUS  WINAPI ZwOpenProcessToken(HANDLE,DWORD,HANDLE *);
1379 NTSTATUS  WINAPI ZwOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
1380 NTSTATUS  WINAPI ZwOpenSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1381 NTSTATUS  WINAPI ZwOpenThread(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
1382 NTSTATUS  WINAPI ZwOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
1383 NTSTATUS  WINAPI ZwOpenTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*);
1384 NTSTATUS  WINAPI ZwPowerInformation(POWER_INFORMATION_LEVEL,PVOID,ULONG,PVOID,ULONG);
1385 NTSTATUS  WINAPI ZwPulseEvent(HANDLE,PULONG);
1386 NTSTATUS  WINAPI ZwQueryDefaultLocale(BOOLEAN,LCID*);
1387 NTSTATUS  WINAPI ZwQueryDefaultUILanguage(LANGID*);
1388 NTSTATUS  WINAPI ZwQueryDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN);
1389 NTSTATUS  WINAPI ZwQueryDirectoryObject(HANDLE,PDIRECTORY_BASIC_INFORMATION,ULONG,BOOLEAN,BOOLEAN,PULONG,PULONG);
1390 NTSTATUS  WINAPI ZwQueryEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,BOOLEAN,PVOID,ULONG,PVOID,BOOLEAN);
1391 NTSTATUS  WINAPI ZwQueryFullAttributesFile(const OBJECT_ATTRIBUTES*,FILE_NETWORK_OPEN_INFORMATION*);
1392 NTSTATUS  WINAPI ZwQueryInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,LONG,FILE_INFORMATION_CLASS);
1393 NTSTATUS  WINAPI ZwQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
1394 NTSTATUS  WINAPI ZwQueryInformationToken(HANDLE,DWORD,PVOID,DWORD,LPDWORD);
1395 NTSTATUS  WINAPI ZwQueryInstallUILanguage(LANGID*);
1396 NTSTATUS  WINAPI ZwQueryKey(HANDLE,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1397 NTSTATUS  WINAPI ZwQueryObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG);
1398 NTSTATUS  WINAPI ZwQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
1399 NTSTATUS  WINAPI ZwQuerySection(HANDLE,SECTION_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1400 NTSTATUS  WINAPI ZwQuerySymbolicLinkObject(HANDLE,PUNICODE_STRING,PULONG);
1401 NTSTATUS  WINAPI ZwQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1402 NTSTATUS  WINAPI ZwQueryTimerResolution(PULONG,PULONG,PULONG);
1403 NTSTATUS  WINAPI ZwQueryValueKey(HANDLE,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
1404 NTSTATUS  WINAPI ZwQueryVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
1405 NTSTATUS  WINAPI ZwReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
1406 NTSTATUS  WINAPI ZwReplaceKey(POBJECT_ATTRIBUTES,HANDLE,POBJECT_ATTRIBUTES);
1407 NTSTATUS  WINAPI ZwRequestWaitReplyPort(HANDLE,PLPC_MESSAGE,PLPC_MESSAGE);
1408 NTSTATUS  WINAPI ZwResetEvent(HANDLE,PULONG);
1409 NTSTATUS  WINAPI ZwRestoreKey(HANDLE,HANDLE,ULONG);
1410 NTSTATUS  WINAPI ZwSaveKey(HANDLE,HANDLE);
1411 NTSTATUS  WINAPI ZwSecureConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PSID,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
1412 NTSTATUS  WINAPI ZwSetDefaultLocale(BOOLEAN,LCID);
1413 NTSTATUS  WINAPI ZwSetDefaultUILanguage(LANGID);
1414 NTSTATUS  WINAPI ZwSetEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG);
1415 NTSTATUS  WINAPI ZwSetEvent(HANDLE,PULONG);
1416 NTSTATUS  WINAPI ZwSetInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS);
1417 NTSTATUS  WINAPI ZwSetInformationKey(HANDLE,const int,PVOID,ULONG);
1418 NTSTATUS  WINAPI ZwSetInformationObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG);
1419 NTSTATUS  WINAPI ZwSetInformationProcess(HANDLE,PROCESS_INFORMATION_CLASS,PVOID,ULONG);
1420 NTSTATUS  WINAPI ZwSetInformationThread(HANDLE,THREADINFOCLASS,LPCVOID,ULONG);
1421 NTSTATUS  WINAPI ZwSetIoCompletion(HANDLE,ULONG,ULONG,NTSTATUS,ULONG);
1422 NTSTATUS  WINAPI ZwSetLdtEntries(ULONG,ULONG,ULONG,ULONG,ULONG,ULONG);
1423 NTSTATUS  WINAPI ZwSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
1424 NTSTATUS  WINAPI ZwSetSystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG);
1425 NTSTATUS  WINAPI ZwSetSystemTime(const LARGE_INTEGER*,LARGE_INTEGER*);
1426 NTSTATUS  WINAPI ZwSetTimer(HANDLE, const LARGE_INTEGER*, PTIMER_APC_ROUTINE, PVOID, BOOLEAN, ULONG, BOOLEAN*);
1427 NTSTATUS  WINAPI ZwSetValueKey(HANDLE,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
1428 NTSTATUS  WINAPI ZwSetVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
1429 NTSTATUS  WINAPI ZwSuspendThread(HANDLE,PULONG);
1430 NTSTATUS  WINAPI ZwTerminateProcess(HANDLE,LONG);
1431 NTSTATUS  WINAPI ZwUnloadDriver(const UNICODE_STRING *);
1432 NTSTATUS  WINAPI ZwUnloadKey(HANDLE);
1433 NTSTATUS  WINAPI ZwUnmapViewOfSection(HANDLE,PVOID);
1434 NTSTATUS  WINAPI ZwWaitForSingleObject(HANDLE,BOOLEAN,const LARGE_INTEGER*);
1435 NTSTATUS  WINAPI ZwWaitForMultipleObjects(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,const LARGE_INTEGER*);
1436 NTSTATUS  WINAPI ZwWriteFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,const void*,ULONG,PLARGE_INTEGER,PULONG);
1437 NTSTATUS  WINAPI ZwYieldExecution(void);
1438
1439 #endif