git.oblomov.eu Git - wine/blob - 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 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;
  32
  33 struct _KDPC;
  34 struct _KAPC;
  35 struct _IRP;
  36 struct _DEVICE_OBJECT;
  37 struct _DRIVER_OBJECT;
  38
  39 typedef VOID (WINAPI *PKDEFERRED_ROUTINE)(struct _KDPC *, PVOID, PVOID, PVOID);
  40 typedef VOID (WINAPI *PKSTART_ROUTINE)(PVOID);
  41
  42 typedef NTSTATUS (WINAPI *PDRIVER_INITIALIZE)(struct _DRIVER_OBJECT *, PUNICODE_STRING);
  43 typedef NTSTATUS (WINAPI *PDRIVER_DISPATCH)(struct _DEVICE_OBJECT *, struct _IRP *);
  44 typedef void (WINAPI *PDRIVER_STARTIO)(struct _DEVICE_OBJECT *, struct _IRP *);
  45 typedef void (WINAPI *PDRIVER_UNLOAD)(struct _DRIVER_OBJECT *);
  46
  47 typedef struct _DISPATCHER_HEADER {
  48   UCHAR  Type;
  49   UCHAR  Absolute;
  50   UCHAR  Size;
  51   UCHAR  Inserted;
  52   LONG  SignalState;
  53   LIST_ENTRY  WaitListHead;
  54 } DISPATCHER_HEADER, *PDISPATCHER_HEADER;
  55
  56 typedef struct _KEVENT {
  57   DISPATCHER_HEADER  Header;
  58 } KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;
  59
  60 typedef struct _KDPC {
  61   CSHORT  Type;
  62   UCHAR  Number;
  63   UCHAR  Importance;
  64   LIST_ENTRY  DpcListEntry;
  65   PKDEFERRED_ROUTINE  DeferredRoutine;
  66   PVOID  DeferredContext;
  67   PVOID  SystemArgument1;
  68   PVOID  SystemArgument2;
  69   PULONG_PTR  Lock;
  70 } KDPC, *PKDPC, *RESTRICTED_POINTER PRKDPC;
  71
  72 typedef struct _KDEVICE_QUEUE_ENTRY {
  73   LIST_ENTRY  DeviceListEntry;
  74   ULONG  SortKey;
  75   BOOLEAN  Inserted;
  76 } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY,
  77 *RESTRICTED_POINTER PRKDEVICE_QUEUE_ENTRY;
  78
  79 typedef struct _KDEVICE_QUEUE {
  80   CSHORT  Type;
  81   CSHORT  Size;
  82   LIST_ENTRY  DeviceListHead;
  83   KSPIN_LOCK  Lock;
  84   BOOLEAN  Busy;
  85 } KDEVICE_QUEUE, *PKDEVICE_QUEUE, *RESTRICTED_POINTER PRKDEVICE_QUEUE;
  86
  87 typedef struct _IO_TIMER *PIO_TIMER;
  88 typedef struct _ETHREAD *PETHREAD;
  89 typedef struct _KTHREAD *PKTHREAD;
  90 typedef struct _EPROCESS *PEPROCESS;
  91
  92 #define MAXIMUM_VOLUME_LABEL_LENGTH       (32 * sizeof(WCHAR))
  93
  94 typedef struct _VPB {
  95   CSHORT  Type;
  96   CSHORT  Size;
  97   USHORT  Flags;
  98   USHORT  VolumeLabelLength;
  99   struct _DEVICE_OBJECT  *DeviceObject;
 100   struct _DEVICE_OBJECT  *RealDevice;
 101   ULONG  SerialNumber;
 102   ULONG  ReferenceCount;
 103   WCHAR  VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH / sizeof(WCHAR)];
 104 } VPB, *PVPB;
 105
 106 typedef enum _POOL_TYPE {
 107   NonPagedPool,
 108   PagedPool,
 109   NonPagedPoolMustSucceed,
 110   UnkownType,
 111   NonPagedPoolCacheAligned,
 112   PagedPoolCacheAligned,
 113   NonPagedPoolCacheAlignedMustS,
 114   MaxPoolType
 115 } POOL_TYPE;
 116
 117 typedef struct _WAIT_CONTEXT_BLOCK {
 118   KDEVICE_QUEUE_ENTRY  WaitQueueEntry;
 119   struct _DRIVER_CONTROL  *DeviceRoutine;
 120   PVOID  DeviceContext;
 121   ULONG  NumberOfMapRegisters;
 122   PVOID  DeviceObject;
 123   PVOID  CurrentIrp;
 124   PKDPC  BufferChainingDpc;
 125 } WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
 126
 127 #ifndef DEVICE_TYPE
 128 #define DEVICE_TYPE ULONG
 129 #endif
 130 #define IRP_MJ_MAXIMUM_FUNCTION           0x1b
 131 #define IRP_MJ_DEVICE_CONTROL             0x0e
 132
 133 typedef struct _DEVICE_OBJECT {
 134   CSHORT  Type;
 135   USHORT  Size;
 136   LONG  ReferenceCount;
 137   struct _DRIVER_OBJECT  *DriverObject;
 138   struct _DEVICE_OBJECT  *NextDevice;
 139   struct _DEVICE_OBJECT  *AttachedDevice;
 140   struct _IRP  *CurrentIrp;
 141   PIO_TIMER  Timer;
 142   ULONG  Flags;
 143   ULONG  Characteristics;
 144   PVPB  Vpb;
 145   PVOID  DeviceExtension;
 146   DEVICE_TYPE  DeviceType;
 147   CCHAR  StackSize;
 148   union {
 149     LIST_ENTRY  ListEntry;
 150     WAIT_CONTEXT_BLOCK  Wcb;
 151   } Queue;
 152   ULONG  AlignmentRequirement;
 153   KDEVICE_QUEUE  DeviceQueue;
 154   KDPC  Dpc;
 155   ULONG  ActiveThreadCount;
 156   PSECURITY_DESCRIPTOR  SecurityDescriptor;
 157   KEVENT  DeviceLock;
 158   USHORT  SectorSize;
 159   USHORT  Spare1;
 160   struct _DEVOBJ_EXTENSION  *DeviceObjectExtension;
 161   PVOID  Reserved;
 162 } DEVICE_OBJECT;
 163 typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT;
 164
 165 typedef struct _DRIVER_EXTENSION {
 166   struct _DRIVER_OBJECT  *DriverObject;
 167   PVOID  AddDevice;
 168   ULONG  Count;
 169   UNICODE_STRING  ServiceKeyName;
 170 } DRIVER_EXTENSION, *PDRIVER_EXTENSION;
 171
 172 typedef struct _DRIVER_OBJECT {
 173   CSHORT  Type;
 174   CSHORT  Size;
 175   PDEVICE_OBJECT  DeviceObject;
 176   ULONG  Flags;
 177   PVOID  DriverStart;
 178   ULONG  DriverSize;
 179   PVOID  DriverSection;
 180   PDRIVER_EXTENSION  DriverExtension;
 181   UNICODE_STRING  DriverName;
 182   PUNICODE_STRING  HardwareDatabase;
 183   PVOID  FastIoDispatch;
 184   PDRIVER_INITIALIZE DriverInit;
 185   PDRIVER_STARTIO    DriverStartIo;
 186   PDRIVER_UNLOAD     DriverUnload;
 187   PDRIVER_DISPATCH   MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
 188 } DRIVER_OBJECT;
 189 typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT;
 190
 191 /* Irp definitions */
 192 typedef UCHAR KIRQL, *PKIRQL;
 193 typedef CCHAR KPROCESSOR_MODE;
 194
 195 typedef VOID (WINAPI *PDRIVER_CANCEL)(
 196   IN struct _DEVICE_OBJECT  *DeviceObject,
 197   IN struct _IRP  *Irp);
 198
 199 typedef VOID (WINAPI *PKNORMAL_ROUTINE)(
 200   IN PVOID  NormalContext,
 201   IN PVOID  SystemArgument1,
 202   IN PVOID  SystemArgument2);
 203
 204 typedef VOID (WINAPI *PKKERNEL_ROUTINE)(
 205   IN struct _KAPC  *Apc,
 206   IN OUT PKNORMAL_ROUTINE  *NormalRoutine,
 207   IN OUT PVOID  *NormalContext,
 208   IN OUT PVOID  *SystemArgument1,
 209   IN OUT PVOID  *SystemArgument2);
 210
 211 typedef VOID (WINAPI *PKRUNDOWN_ROUTINE)(
 212   IN struct _KAPC  *Apc);
 213
 214 typedef struct _KAPC {
 215   CSHORT  Type;
 216   CSHORT  Size;
 217   ULONG  Spare0;
 218   struct _KTHREAD  *Thread;
 219   LIST_ENTRY  ApcListEntry;
 220   PKKERNEL_ROUTINE  KernelRoutine;
 221   PKRUNDOWN_ROUTINE  RundownRoutine;
 222   PKNORMAL_ROUTINE  NormalRoutine;
 223   PVOID  NormalContext;
 224   PVOID  SystemArgument1;
 225   PVOID  SystemArgument2;
 226   CCHAR  ApcStateIndex;
 227   KPROCESSOR_MODE  ApcMode;
 228   BOOLEAN  Inserted;
 229 } KAPC, *PKAPC, *RESTRICTED_POINTER PRKAPC;
 230
 231 #include <pshpack1.h>
 232 typedef struct _IRP {
 233   CSHORT  Type;
 234   USHORT  Size;
 235   struct _MDL  *MdlAddress;
 236   ULONG  Flags;
 237   union {
 238     struct _IRP  *MasterIrp;
 239     LONG  IrpCount;
 240     PVOID  SystemBuffer;
 241   } AssociatedIrp;
 242   LIST_ENTRY  ThreadListEntry;
 243   IO_STATUS_BLOCK  IoStatus;
 244   KPROCESSOR_MODE  RequestorMode;
 245   BOOLEAN  PendingReturned;
 246   CHAR  StackCount;
 247   CHAR  CurrentLocation;
 248   BOOLEAN  Cancel;
 249   KIRQL  CancelIrql;
 250   CCHAR  ApcEnvironment;
 251   UCHAR  AllocationFlags;
 252   PIO_STATUS_BLOCK  UserIosb;
 253   PKEVENT  UserEvent;
 254   union {
 255     struct {
 256       PIO_APC_ROUTINE  UserApcRoutine;
 257       PVOID  UserApcContext;
 258     } AsynchronousParameters;
 259     LARGE_INTEGER  AllocationSize;
 260   } Overlay;
 261   PDRIVER_CANCEL  CancelRoutine;
 262   PVOID  UserBuffer;
 263   union {
 264     struct {
 265        union {
 266         KDEVICE_QUEUE_ENTRY  DeviceQueueEntry;
 267         struct {
 268           PVOID  DriverContext[4];
 269         } DUMMYSTRUCTNAME;
 270       } DUMMYUNIONNAME;
 271       PETHREAD  Thread;
 272       PCHAR  AuxiliaryBuffer;
 273       struct {
 274         LIST_ENTRY  ListEntry;
 275         union {
 276           struct _IO_STACK_LOCATION  *CurrentStackLocation;
 277           ULONG  PacketType;
 278         } DUMMYUNIONNAME;
 279       } DUMMYSTRUCTNAME;
 280       struct _FILE_OBJECT  *OriginalFileObject;
 281     } Overlay;
 282     KAPC  Apc;
 283     PVOID  CompletionKey;
 284   } Tail;
 285 } IRP;
 286 typedef struct _IRP *PIRP;
 287 #include <poppack.h>
 288
 289 /* MDL definitions */
 290
 291 typedef VOID (WINAPI *PINTERFACE_REFERENCE)(
 292   PVOID  Context);
 293
 294 typedef VOID (WINAPI *PINTERFACE_DEREFERENCE)(
 295   PVOID Context);
 296
 297 typedef struct _INTERFACE {
 298   USHORT  Size;
 299   USHORT  Version;
 300   PVOID  Context;
 301   PINTERFACE_REFERENCE  InterfaceReference;
 302   PINTERFACE_DEREFERENCE  InterfaceDereference;
 303 } INTERFACE, *PINTERFACE;
 304
 305 typedef struct _SECTION_OBJECT_POINTERS {
 306   PVOID  DataSectionObject;
 307   PVOID  SharedCacheMap;
 308   PVOID  ImageSectionObject;
 309 } SECTION_OBJECT_POINTERS, *PSECTION_OBJECT_POINTERS;
 310
 311 typedef struct _IO_COMPLETION_CONTEXT {
 312   PVOID  Port;
 313   PVOID  Key;
 314 } IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT;
 315
 316 typedef enum _DEVICE_RELATION_TYPE {
 317   BusRelations,
 318   EjectionRelations,
 319   PowerRelations,
 320   RemovalRelations,
 321   TargetDeviceRelation,
 322   SingleBusRelations
 323 } DEVICE_RELATION_TYPE, *PDEVICE_RELATION_TYPE;
 324
 325 typedef struct _FILE_OBJECT {
 326   CSHORT  Type;
 327   CSHORT  Size;
 328   PDEVICE_OBJECT  DeviceObject;
 329   PVPB  Vpb;
 330   PVOID  FsContext;
 331   PVOID  FsContext2;
 332   PSECTION_OBJECT_POINTERS  SectionObjectPointer;
 333   PVOID  PrivateCacheMap;
 334   NTSTATUS  FinalStatus;
 335   struct _FILE_OBJECT  *RelatedFileObject;
 336   BOOLEAN  LockOperation;
 337   BOOLEAN  DeletePending;
 338   BOOLEAN  ReadAccess;
 339   BOOLEAN  WriteAccess;
 340   BOOLEAN  DeleteAccess;
 341   BOOLEAN  SharedRead;
 342   BOOLEAN  SharedWrite;
 343   BOOLEAN  SharedDelete;
 344   ULONG  Flags;
 345   UNICODE_STRING  FileName;
 346   LARGE_INTEGER  CurrentByteOffset;
 347   ULONG  Waiters;
 348   ULONG  Busy;
 349   PVOID  LastLock;
 350   KEVENT  Lock;
 351   KEVENT  Event;
 352   PIO_COMPLETION_CONTEXT  CompletionContext;
 353 } FILE_OBJECT;
 354 typedef struct _FILE_OBJECT *PFILE_OBJECT;
 355
 356 #define INITIAL_PRIVILEGE_COUNT           3
 357
 358 typedef struct _INITIAL_PRIVILEGE_SET {
 359   ULONG  PrivilegeCount;
 360   ULONG  Control;
 361   LUID_AND_ATTRIBUTES  Privilege[INITIAL_PRIVILEGE_COUNT];
 362 } INITIAL_PRIVILEGE_SET, * PINITIAL_PRIVILEGE_SET;
 363
 364 typedef struct _SECURITY_SUBJECT_CONTEXT {
 365   PACCESS_TOKEN  ClientToken;
 366   SECURITY_IMPERSONATION_LEVEL  ImpersonationLevel;
 367   PACCESS_TOKEN  PrimaryToken;
 368   PVOID  ProcessAuditId;
 369 } SECURITY_SUBJECT_CONTEXT, *PSECURITY_SUBJECT_CONTEXT;
 370
 371 typedef struct _ACCESS_STATE {
 372   LUID  OperationID;
 373   BOOLEAN  SecurityEvaluated;
 374   BOOLEAN  GenerateAudit;
 375   BOOLEAN  GenerateOnClose;
 376   BOOLEAN  PrivilegesAllocated;
 377   ULONG  Flags;
 378   ACCESS_MASK  RemainingDesiredAccess;
 379   ACCESS_MASK  PreviouslyGrantedAccess;
 380   ACCESS_MASK  OriginalDesiredAccess;
 381   SECURITY_SUBJECT_CONTEXT  SubjectSecurityContext;
 382   PSECURITY_DESCRIPTOR  SecurityDescriptor;
 383   PVOID  AuxData;
 384   union {
 385     INITIAL_PRIVILEGE_SET  InitialPrivilegeSet;
 386     PRIVILEGE_SET  PrivilegeSet;
 387   } Privileges;
 388
 389   BOOLEAN  AuditPrivileges;
 390   UNICODE_STRING  ObjectName;
 391   UNICODE_STRING  ObjectTypeName;
 392 } ACCESS_STATE, *PACCESS_STATE;
 393
 394 typedef struct _IO_SECURITY_CONTEXT {
 395   PSECURITY_QUALITY_OF_SERVICE  SecurityQos;
 396   PACCESS_STATE  AccessState;
 397   ACCESS_MASK  DesiredAccess;
 398   ULONG  FullCreateOptions;
 399 } IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT;
 400
 401 typedef struct _DEVICE_CAPABILITIES {
 402   USHORT  Size;
 403   USHORT  Version;
 404   ULONG  DeviceD1 : 1;
 405   ULONG  DeviceD2 : 1;
 406   ULONG  LockSupported : 1;
 407   ULONG  EjectSupported : 1;
 408   ULONG  Removable : 1;
 409   ULONG  DockDevice : 1;
 410   ULONG  UniqueID : 1;
 411   ULONG  SilentInstall : 1;
 412   ULONG  RawDeviceOK : 1;
 413   ULONG  SurpriseRemovalOK : 1;
 414   ULONG  WakeFromD0 : 1;
 415   ULONG  WakeFromD1 : 1;
 416   ULONG  WakeFromD2 : 1;
 417   ULONG  WakeFromD3 : 1;
 418   ULONG  HardwareDisabled : 1;
 419   ULONG  NonDynamic : 1;
 420   ULONG  WarmEjectSupported : 1;
 421   ULONG  NoDisplayInUI : 1;
 422   ULONG  Reserved : 14;
 423   ULONG  Address;
 424   ULONG  UINumber;
 425   DEVICE_POWER_STATE  DeviceState[PowerSystemMaximum];
 426   SYSTEM_POWER_STATE  SystemWake;
 427   DEVICE_POWER_STATE  DeviceWake;
 428   ULONG  D1Latency;
 429   ULONG  D2Latency;
 430   ULONG  D3Latency;
 431 } DEVICE_CAPABILITIES, *PDEVICE_CAPABILITIES;
 432
 433 typedef enum _INTERFACE_TYPE {
 434   InterfaceTypeUndefined = -1,
 435   Internal,
 436   Isa,
 437   Eisa,
 438   MicroChannel,
 439   TurboChannel,
 440   PCIBus,
 441   VMEBus,
 442   NuBus,
 443   PCMCIABus,
 444   CBus,
 445   MPIBus,
 446   MPSABus,
 447   ProcessorInternal,
 448   InternalPowerBus,
 449   PNPISABus,
 450   PNPBus,
 451   MaximumInterfaceType
 452 } INTERFACE_TYPE, *PINTERFACE_TYPE;
 453
 454 typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;
 455
 456 #define IO_RESOURCE_PREFERRED             0x01
 457 #define IO_RESOURCE_DEFAULT               0x02
 458 #define IO_RESOURCE_ALTERNATIVE           0x08
 459
 460 typedef struct _IO_RESOURCE_DESCRIPTOR {
 461   UCHAR  Option;
 462   UCHAR  Type;
 463   UCHAR  ShareDisposition;
 464   UCHAR  Spare1;
 465   USHORT  Flags;
 466   USHORT  Spare2;
 467   union {
 468     struct {
 469       ULONG  Length;
 470       ULONG  Alignment;
 471       PHYSICAL_ADDRESS  MinimumAddress;
 472       PHYSICAL_ADDRESS  MaximumAddress;
 473     } Port;
 474     struct {
 475       ULONG  Length;
 476       ULONG  Alignment;
 477       PHYSICAL_ADDRESS  MinimumAddress;
 478       PHYSICAL_ADDRESS  MaximumAddress;
 479     } Memory;
 480     struct {
 481       ULONG  MinimumVector;
 482       ULONG  MaximumVector;
 483     } Interrupt;
 484     struct {
 485       ULONG  MinimumChannel;
 486       ULONG  MaximumChannel;
 487     } Dma;
 488     struct {
 489       ULONG  Length;
 490       ULONG  Alignment;
 491       PHYSICAL_ADDRESS  MinimumAddress;
 492       PHYSICAL_ADDRESS  MaximumAddress;
 493     } Generic;
 494     struct {
 495       ULONG  Data[3];
 496     } DevicePrivate;
 497     struct {
 498       ULONG  Length;
 499       ULONG  MinBusNumber;
 500       ULONG  MaxBusNumber;
 501       ULONG  Reserved;
 502     } BusNumber;
 503     struct {
 504       ULONG  Priority;
 505       ULONG  Reserved1;
 506       ULONG  Reserved2;
 507     } ConfigData;
 508   } u;
 509 } IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
 510
 511 typedef struct _IO_RESOURCE_LIST {
 512   USHORT  Version;
 513   USHORT  Revision;
 514   ULONG  Count;
 515   IO_RESOURCE_DESCRIPTOR  Descriptors[1];
 516 } IO_RESOURCE_LIST, *PIO_RESOURCE_LIST;
 517
 518 typedef struct _IO_RESOURCE_REQUIREMENTS_LIST {
 519   ULONG  ListSize;
 520   INTERFACE_TYPE  InterfaceType;
 521   ULONG  BusNumber;
 522   ULONG  SlotNumber;
 523   ULONG  Reserved[3];
 524   ULONG  AlternativeLists;
 525   IO_RESOURCE_LIST  List[1];
 526 } IO_RESOURCE_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST;
 527
 528 typedef enum _BUS_QUERY_ID_TYPE {
 529   BusQueryDeviceID,
 530   BusQueryHardwareIDs,
 531   BusQueryCompatibleIDs,
 532   BusQueryInstanceID,
 533   BusQueryDeviceSerialNumber
 534 } BUS_QUERY_ID_TYPE, *PBUS_QUERY_ID_TYPE;
 535
 536 typedef enum _DEVICE_TEXT_TYPE {
 537   DeviceTextDescription,
 538   DeviceTextLocationInformation
 539 } DEVICE_TEXT_TYPE, *PDEVICE_TEXT_TYPE;
 540
 541 typedef enum _DEVICE_USAGE_NOTIFICATION_TYPE {
 542   DeviceUsageTypeUndefined,
 543   DeviceUsageTypePaging,
 544   DeviceUsageTypeHibernation,
 545   DeviceUsageTypeDumpFile
 546 } DEVICE_USAGE_NOTIFICATION_TYPE;
 547
 548 typedef struct _POWER_SEQUENCE {
 549   ULONG  SequenceD1;
 550   ULONG  SequenceD2;
 551   ULONG  SequenceD3;
 552 } POWER_SEQUENCE, *PPOWER_SEQUENCE;
 553
 554 typedef enum _POWER_STATE_TYPE {
 555   SystemPowerState,
 556   DevicePowerState
 557 } POWER_STATE_TYPE, *PPOWER_STATE_TYPE;
 558
 559 typedef union _POWER_STATE {
 560   SYSTEM_POWER_STATE  SystemState;
 561   DEVICE_POWER_STATE  DeviceState;
 562 } POWER_STATE, *PPOWER_STATE;
 563
 564 typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR {
 565   UCHAR Type;
 566   UCHAR ShareDisposition;
 567   USHORT Flags;
 568   union {
 569     struct {
 570       PHYSICAL_ADDRESS Start;
 571       ULONG Length;
 572     } Generic;
 573     struct {
 574       PHYSICAL_ADDRESS Start;
 575       ULONG Length;
 576     } Port;
 577     struct {
 578       ULONG Level;
 579       ULONG Vector;
 580       ULONG Affinity;
 581     } Interrupt;
 582     struct {
 583       PHYSICAL_ADDRESS Start;
 584       ULONG Length;
 585     } Memory;
 586     struct {
 587       ULONG Channel;
 588       ULONG Port;
 589       ULONG Reserved1;
 590     } Dma;
 591     struct {
 592       ULONG Data[3];
 593     } DevicePrivate;
 594     struct {
 595       ULONG Start;
 596       ULONG Length;
 597       ULONG Reserved;
 598     } BusNumber;
 599     struct {
 600       ULONG DataSize;
 601       ULONG Reserved1;
 602       ULONG Reserved2;
 603     } DeviceSpecificData;
 604   } u;
 605 } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
 606
 607 typedef struct _CM_PARTIAL_RESOURCE_LIST {
 608   USHORT  Version;
 609   USHORT  Revision;
 610   ULONG  Count;
 611   CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
 612 } CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST;
 613
 614 typedef struct _CM_FULL_RESOURCE_DESCRIPTOR {
 615   INTERFACE_TYPE  InterfaceType;
 616   ULONG  BusNumber;
 617   CM_PARTIAL_RESOURCE_LIST  PartialResourceList;
 618 } CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR;
 619
 620 typedef struct _CM_RESOURCE_LIST {
 621   ULONG  Count;
 622   CM_FULL_RESOURCE_DESCRIPTOR  List[1];
 623 } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
 624
 625 typedef NTSTATUS (WINAPI *PIO_COMPLETION_ROUTINE)(
 626   IN struct _DEVICE_OBJECT  *DeviceObject,
 627   IN struct _IRP  *Irp,
 628   IN PVOID  Context);
 629
 630 #include <pshpack1.h>
 631 typedef struct _IO_STACK_LOCATION {
 632   UCHAR  MajorFunction;
 633   UCHAR  MinorFunction;
 634   UCHAR  Flags;
 635   UCHAR  Control;
 636   union {
 637     struct {
 638       PIO_SECURITY_CONTEXT  SecurityContext;
 639       ULONG  Options;
 640       USHORT POINTER_ALIGNMENT  FileAttributes;
 641       USHORT  ShareAccess;
 642       ULONG POINTER_ALIGNMENT  EaLength;
 643     } Create;
 644     struct {
 645       ULONG  Length;
 646       ULONG POINTER_ALIGNMENT  Key;
 647       LARGE_INTEGER  ByteOffset;
 648     } Read;
 649     struct {
 650       ULONG  Length;
 651       ULONG POINTER_ALIGNMENT  Key;
 652       LARGE_INTEGER  ByteOffset;
 653     } Write;
 654     struct {
 655       ULONG  Length;
 656       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 657     } QueryFile;
 658     struct {
 659       ULONG  Length;
 660       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 661       PFILE_OBJECT  FileObject;
 662       union {
 663         struct {
 664           BOOLEAN  ReplaceIfExists;
 665           BOOLEAN  AdvanceOnly;
 666         } DUMMYSTRUCTNAME;
 667         ULONG  ClusterCount;
 668         HANDLE  DeleteHandle;
 669       } DUMMYUNIONNAME;
 670     } SetFile;
 671     struct {
 672       ULONG  Length;
 673       FS_INFORMATION_CLASS POINTER_ALIGNMENT  FsInformationClass;
 674     } QueryVolume;
 675     struct {
 676       ULONG  OutputBufferLength;
 677       ULONG POINTER_ALIGNMENT  InputBufferLength;
 678       ULONG POINTER_ALIGNMENT  IoControlCode;
 679       PVOID  Type3InputBuffer;
 680     } DeviceIoControl;
 681     struct {
 682       SECURITY_INFORMATION  SecurityInformation;
 683       ULONG POINTER_ALIGNMENT  Length;
 684     } QuerySecurity;
 685     struct {
 686       SECURITY_INFORMATION  SecurityInformation;
 687       PSECURITY_DESCRIPTOR  SecurityDescriptor;
 688     } SetSecurity;
 689     struct {
 690       PVPB  Vpb;
 691       PDEVICE_OBJECT  DeviceObject;
 692     } MountVolume;
 693     struct {
 694       PVPB  Vpb;
 695       PDEVICE_OBJECT  DeviceObject;
 696     } VerifyVolume;
 697     struct {
 698       struct _SCSI_REQUEST_BLOCK  *Srb;
 699     } Scsi;
 700     struct {
 701       DEVICE_RELATION_TYPE  Type;
 702     } QueryDeviceRelations;
 703     struct {
 704       CONST GUID  *InterfaceType;
 705       USHORT  Size;
 706       USHORT  Version;
 707       PINTERFACE  Interface;
 708       PVOID  InterfaceSpecificData;
 709     } QueryInterface;
 710     struct {
 711       PDEVICE_CAPABILITIES  Capabilities;
 712     } DeviceCapabilities;
 713     struct {
 714       PIO_RESOURCE_REQUIREMENTS_LIST  IoResourceRequirementList;
 715     } FilterResourceRequirements;
 716     struct {
 717       ULONG  WhichSpace;
 718       PVOID  Buffer;
 719       ULONG  Offset;
 720       ULONG POINTER_ALIGNMENT  Length;
 721     } ReadWriteConfig;
 722     struct {
 723       BOOLEAN  Lock;
 724     } SetLock;
 725     struct {
 726       BUS_QUERY_ID_TYPE  IdType;
 727     } QueryId;
 728     struct {
 729       DEVICE_TEXT_TYPE  DeviceTextType;
 730       LCID POINTER_ALIGNMENT  LocaleId;
 731     } QueryDeviceText;
 732     struct {
 733       BOOLEAN  InPath;
 734       BOOLEAN  Reserved[3];
 735       DEVICE_USAGE_NOTIFICATION_TYPE POINTER_ALIGNMENT  Type;
 736     } UsageNotification;
 737     struct {
 738       SYSTEM_POWER_STATE  PowerState;
 739     } WaitWake;
 740     struct {
 741       PPOWER_SEQUENCE  PowerSequence;
 742     } PowerSequence;
 743     struct {
 744       ULONG  SystemContext;
 745       POWER_STATE_TYPE POINTER_ALIGNMENT  Type;
 746       POWER_STATE POINTER_ALIGNMENT  State;
 747       POWER_ACTION POINTER_ALIGNMENT  ShutdownType;
 748     } Power;
 749     struct {
 750       PCM_RESOURCE_LIST  AllocatedResources;
 751       PCM_RESOURCE_LIST  AllocatedResourcesTranslated;
 752     } StartDevice;
 753     struct {
 754       ULONG_PTR  ProviderId;
 755       PVOID  DataPath;
 756       ULONG  BufferSize;
 757       PVOID  Buffer;
 758     } WMI;
 759     struct {
 760       PVOID  Argument1;
 761       PVOID  Argument2;
 762       PVOID  Argument3;
 763       PVOID  Argument4;
 764     } Others;
 765   } Parameters;
 766   PDEVICE_OBJECT  DeviceObject;
 767   PFILE_OBJECT  FileObject;
 768   PIO_COMPLETION_ROUTINE  CompletionRoutine;
 769   PVOID  Context;
 770 } IO_STACK_LOCATION, *PIO_STACK_LOCATION;
 771 #include <poppack.h>
 772
 773 typedef struct _MDL {
 774   struct _MDL  *Next;
 775   CSHORT  Size;
 776   CSHORT  MdlFlags;
 777   struct _EPROCESS  *Process;
 778   PVOID  MappedSystemVa;
 779   PVOID  StartVa;
 780   ULONG  ByteCount;
 781   ULONG  ByteOffset;
 782 } MDL, *PMDL;
 783
 784 typedef struct _KTIMER {
 785     DISPATCHER_HEADER Header;
 786     ULARGE_INTEGER DueTime;
 787     LIST_ENTRY TimerListEntry;
 788     struct _KDPC *Dpc;
 789     LONG Period;
 790 } KTIMER, *PKTIMER;
 791
 792 typedef struct _KSYSTEM_TIME {
 793     ULONG LowPart;
 794     LONG High1Time;
 795     LONG High2Time;
 796 } KSYSTEM_TIME, *PKSYSTEM_TIME;
 797
 798 typedef enum _NT_PRODUCT_TYPE {
 799     NtProductWinNt = 1,
 800     NtProductLanManNt,
 801     NtProductServer
 802 } NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;
 803
 804 #define PROCESSOR_FEATURE_MAX 64
 805
 806 typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE
 807 {
 808    StandardDesign,
 809    NEC98x86,
 810    EndAlternatives
 811 } ALTERNATIVE_ARCHITECTURE_TYPE;
 812
 813 typedef struct _KUSER_SHARED_DATA {
 814     ULONG TickCountLowDeprecated;
 815     ULONG TickCountMultiplier;
 816     volatile KSYSTEM_TIME InterruptTime;
 817     volatile KSYSTEM_TIME SystemTime;
 818     volatile KSYSTEM_TIME TimeZoneBias;
 819     USHORT ImageNumberLow;
 820     USHORT ImageNumberHigh;
 821     WCHAR NtSystemRoot[260];
 822     ULONG MaxStckTraceDepth;
 823     ULONG CryptoExponent;
 824     ULONG TimeZoneId;
 825     ULONG LargePageMinimum;
 826     ULONG Reserverd2[7];
 827     NT_PRODUCT_TYPE NtProductType;
 828     BOOLEAN ProductTypeIsValid;
 829     ULONG MajorNtVersion;
 830     ULONG MinorNtVersion;
 831     BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX];
 832     ULONG Reserved1;
 833     ULONG Reserved3;
 834     volatile ULONG TimeSlip;
 835     ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
 836     LARGE_INTEGER SystemExpirationDate;
 837     ULONG SuiteMask;
 838     BOOLEAN KdDebuggerEnabled;
 839     volatile ULONG ActiveConsoleId;
 840     volatile ULONG DismountCount;
 841     ULONG ComPlusPackage;
 842     ULONG LastSystemRITEventTickCount;
 843     ULONG NumberOfPhysicalPages;
 844     BOOLEAN SafeBootMode;
 845     ULONG TraceLogging;
 846     ULONGLONG Fill0;
 847     ULONGLONG SystemCall[4];
 848     union {
 849         volatile KSYSTEM_TIME TickCount;
 850         volatile ULONG64 TickCountQuad;
 851     } DUMMYUNIONNAME;
 852 } KSHARED_USER_DATA, *PKSHARED_USER_DATA;
 853
 854 NTSTATUS WINAPI ObCloseHandle(IN HANDLE handle);
 855
 856 #define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.CurrentStackLocation)
 857
 858 #define KernelMode 0
 859 #define UserMode   1
 860
 861 /* directory object access rights */
 862 #define DIRECTORY_QUERY                 0x0001
 863 #define DIRECTORY_TRAVERSE              0x0002
 864 #define DIRECTORY_CREATE_OBJECT         0x0004
 865 #define DIRECTORY_CREATE_SUBDIRECTORY   0x0008
 866 #define DIRECTORY_ALL_ACCESS            (STANDARD_RIGHTS_REQUIRED | 0xF)
 867
 868 /* symbolic link access rights */
 869 #define SYMBOLIC_LINK_QUERY             0x0001
 870 #define SYMBOLIC_LINK_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | 0x1)
 871
 872 PVOID     WINAPI ExAllocatePool(POOL_TYPE,SIZE_T);
 873 PVOID     WINAPI ExAllocatePoolWithQuota(POOL_TYPE,SIZE_T);
 874 PVOID     WINAPI ExAllocatePoolWithTag(POOL_TYPE,SIZE_T,ULONG);
 875 PVOID     WINAPI ExAllocatePoolWithQuotaTag(POOL_TYPE,SIZE_T,ULONG);
 876 void      WINAPI ExFreePool(PVOID);
 877 void      WINAPI ExFreePoolWithTag(PVOID,ULONG);
 878
 879 NTSTATUS  WINAPI IoCreateDevice(DRIVER_OBJECT*,ULONG,UNICODE_STRING*,DEVICE_TYPE,ULONG,BOOLEAN,DEVICE_OBJECT**);
 880 NTSTATUS  WINAPI IoCreateSymbolicLink(UNICODE_STRING*,UNICODE_STRING*);
 881 void      WINAPI IoDeleteDevice(DEVICE_OBJECT*);
 882 NTSTATUS  WINAPI IoDeleteSymbolicLink(UNICODE_STRING*);
 883 PEPROCESS WINAPI IoGetCurrentProcess(void);
 884
 885 PKTHREAD  WINAPI KeGetCurrentThread(void);
 886 void      WINAPI KeQuerySystemTime(LARGE_INTEGER*);
 887 void      WINAPI KeQueryTickCount(LARGE_INTEGER*);
 888 ULONG     WINAPI KeQueryTimeIncrement(void);
 889
 890 PVOID     WINAPI MmAllocateNonCachedMemory(SIZE_T);
 891 void      WINAPI MmFreeNonCachedMemory(PVOID,SIZE_T);
 892
 893 NTSTATUS  WINAPI PsCreateSystemThread(PHANDLE,ULONG,POBJECT_ATTRIBUTES,HANDLE,PCLIENT_ID,PKSTART_ROUTINE,PVOID);
 894 #define          PsGetCurrentProcess() IoGetCurrentProcess()
 895 #define          PsGetCurrentThread() ((PETHREAD)KeGetCurrentThread())
 896 HANDLE    WINAPI PsGetCurrentProcessId(void);
 897 HANDLE    WINAPI PsGetCurrentThreadId(void);
 898 BOOLEAN   WINAPI PsGetVersion(ULONG*,ULONG*,ULONG*,UNICODE_STRING*);
 899 NTSTATUS  WINAPI PsTerminateSystemThread(NTSTATUS);
 900
 901 NTSTATUS  WINAPI ZwAddBootEntry(PUNICODE_STRING,PUNICODE_STRING);
 902 NTSTATUS  WINAPI ZwAccessCheckAndAuditAlarm(PUNICODE_STRING,HANDLE,PUNICODE_STRING,PUNICODE_STRING,PSECURITY_DESCRIPTOR,ACCESS_MASK,PGENERIC_MAPPING,BOOLEAN,PACCESS_MASK,PBOOLEAN,PBOOLEAN);
 903 NTSTATUS  WINAPI ZwAdjustPrivilegesToken(HANDLE,BOOLEAN,PTOKEN_PRIVILEGES,DWORD,PTOKEN_PRIVILEGES,PDWORD);
 904 NTSTATUS  WINAPI ZwAlertThread(HANDLE ThreadHandle);
 905 NTSTATUS  WINAPI ZwAllocateVirtualMemory(HANDLE,PVOID*,ULONG,SIZE_T*,ULONG,ULONG);
 906 NTSTATUS  WINAPI ZwCancelIoFile(HANDLE,PIO_STATUS_BLOCK);
 907 NTSTATUS  WINAPI ZwCancelTimer(HANDLE, BOOLEAN*);
 908 NTSTATUS  WINAPI ZwClearEvent(HANDLE);
 909 NTSTATUS  WINAPI ZwClose(HANDLE);
 910 NTSTATUS  WINAPI ZwCloseObjectAuditAlarm(PUNICODE_STRING,HANDLE,BOOLEAN);
 911 NTSTATUS  WINAPI ZwConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
 912 NTSTATUS  WINAPI ZwCreateDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
 913 NTSTATUS  WINAPI ZwCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
 914 NTSTATUS  WINAPI ZwCreateFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
 915 NTSTATUS  WINAPI ZwCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,const UNICODE_STRING*,ULONG,PULONG);
 916 NTSTATUS  WINAPI ZwCreateSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
 917 NTSTATUS  WINAPI ZwCreateSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PUNICODE_STRING);
 918 NTSTATUS  WINAPI ZwCreateTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*, TIMER_TYPE);
 919 NTSTATUS  WINAPI ZwDeleteAtom(RTL_ATOM);
 920 NTSTATUS  WINAPI ZwDeleteFile(POBJECT_ATTRIBUTES);
 921 NTSTATUS  WINAPI ZwDeleteKey(HANDLE);
 922 NTSTATUS  WINAPI ZwDeleteValueKey(HANDLE,const UNICODE_STRING *);
 923 NTSTATUS  WINAPI ZwDeviceIoControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
 924 NTSTATUS  WINAPI ZwDisplayString(PUNICODE_STRING);
 925 NTSTATUS  WINAPI ZwDuplicateObject(HANDLE,HANDLE,HANDLE,PHANDLE,ACCESS_MASK,ULONG,ULONG);
 926 NTSTATUS  WINAPI ZwDuplicateToken(HANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
 927 NTSTATUS  WINAPI ZwEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
 928 NTSTATUS  WINAPI ZwEnumerateValueKey(HANDLE,ULONG,KEY_VALUE_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 929 NTSTATUS  WINAPI ZwFlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
 930 NTSTATUS  WINAPI ZwFlushKey(HANDLE);
 931 NTSTATUS  WINAPI ZwFlushVirtualMemory(HANDLE,LPCVOID*,SIZE_T*,ULONG);
 932 NTSTATUS  WINAPI ZwFreeVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
 933 NTSTATUS  WINAPI ZwFsControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
 934 NTSTATUS  WINAPI ZwInitiatePowerAction(POWER_ACTION,SYSTEM_POWER_STATE,ULONG,BOOLEAN);
 935 NTSTATUS  WINAPI ZwLoadDriver(const UNICODE_STRING *);
 936 NTSTATUS  WINAPI ZwLoadKey(const OBJECT_ATTRIBUTES *,OBJECT_ATTRIBUTES *);
 937 NTSTATUS  WINAPI ZwLockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
 938 NTSTATUS  WINAPI ZwMakeTemporaryObject(HANDLE);
 939 NTSTATUS  WINAPI ZwMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG);
 940 NTSTATUS  WINAPI ZwNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
 941 NTSTATUS  WINAPI ZwOpenDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
 942 NTSTATUS  WINAPI ZwOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 943 NTSTATUS  WINAPI ZwOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
 944 NTSTATUS  WINAPI ZwOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 945 NTSTATUS  WINAPI ZwOpenProcess(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
 946 NTSTATUS  WINAPI ZwOpenProcessToken(HANDLE,DWORD,HANDLE *);
 947 NTSTATUS  WINAPI ZwOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
 948 NTSTATUS  WINAPI ZwOpenSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
 949 NTSTATUS  WINAPI ZwOpenThread(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
 950 NTSTATUS  WINAPI ZwOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
 951 NTSTATUS  WINAPI ZwOpenTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*);
 952 NTSTATUS  WINAPI ZwPowerInformation(POWER_INFORMATION_LEVEL,PVOID,ULONG,PVOID,ULONG);
 953 NTSTATUS  WINAPI ZwPulseEvent(HANDLE,PULONG);
 954 NTSTATUS  WINAPI ZwQueryDefaultLocale(BOOLEAN,LCID*);
 955 NTSTATUS  WINAPI ZwQueryDefaultUILanguage(LANGID*);
 956 NTSTATUS  WINAPI ZwQueryDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN);
 957 NTSTATUS  WINAPI ZwQueryDirectoryObject(HANDLE,PDIRECTORY_BASIC_INFORMATION,ULONG,BOOLEAN,BOOLEAN,PULONG,PULONG);
 958 NTSTATUS  WINAPI ZwQueryEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,BOOLEAN,PVOID,ULONG,PVOID,BOOLEAN);
 959 NTSTATUS  WINAPI ZwQueryFullAttributesFile(const OBJECT_ATTRIBUTES*,FILE_NETWORK_OPEN_INFORMATION*);
 960 NTSTATUS  WINAPI ZwQueryInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,LONG,FILE_INFORMATION_CLASS);
 961 NTSTATUS  WINAPI ZwQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
 962 NTSTATUS  WINAPI ZwQueryInformationToken(HANDLE,DWORD,PVOID,DWORD,LPDWORD);
 963 NTSTATUS  WINAPI ZwQueryInstallUILanguage(LANGID*);
 964 NTSTATUS  WINAPI ZwQueryKey(HANDLE,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
 965 NTSTATUS  WINAPI ZwQueryObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG);
 966 NTSTATUS  WINAPI ZwQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
 967 NTSTATUS  WINAPI ZwQuerySection(HANDLE,SECTION_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 968 NTSTATUS  WINAPI ZwQuerySymbolicLinkObject(HANDLE,PUNICODE_STRING,PULONG);
 969 NTSTATUS  WINAPI ZwQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 970 NTSTATUS  WINAPI ZwQueryTimerResolution(PULONG,PULONG,PULONG);
 971 NTSTATUS  WINAPI ZwQueryValueKey(HANDLE,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
 972 NTSTATUS  WINAPI ZwQueryVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
 973 NTSTATUS  WINAPI ZwReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
 974 NTSTATUS  WINAPI ZwReplaceKey(POBJECT_ATTRIBUTES,HANDLE,POBJECT_ATTRIBUTES);
 975 NTSTATUS  WINAPI ZwRequestWaitReplyPort(HANDLE,PLPC_MESSAGE,PLPC_MESSAGE);
 976 NTSTATUS  WINAPI ZwResetEvent(HANDLE,PULONG);
 977 NTSTATUS  WINAPI ZwRestoreKey(HANDLE,HANDLE,ULONG);
 978 NTSTATUS  WINAPI ZwSaveKey(HANDLE,HANDLE);
 979 NTSTATUS  WINAPI ZwSecureConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PSID,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
 980 NTSTATUS  WINAPI ZwSetDefaultLocale(BOOLEAN,LCID);
 981 NTSTATUS  WINAPI ZwSetDefaultUILanguage(LANGID);
 982 NTSTATUS  WINAPI ZwSetEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG);
 983 NTSTATUS  WINAPI ZwSetEvent(HANDLE,PULONG);
 984 NTSTATUS  WINAPI ZwSetInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS);
 985 NTSTATUS  WINAPI ZwSetInformationKey(HANDLE,const int,PVOID,ULONG);
 986 NTSTATUS  WINAPI ZwSetInformationObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG);
 987 NTSTATUS  WINAPI ZwSetInformationProcess(HANDLE,PROCESS_INFORMATION_CLASS,PVOID,ULONG);
 988 NTSTATUS  WINAPI ZwSetInformationThread(HANDLE,THREADINFOCLASS,LPCVOID,ULONG);
 989 NTSTATUS  WINAPI ZwSetIoCompletion(HANDLE,ULONG,ULONG,NTSTATUS,ULONG);
 990 NTSTATUS  WINAPI ZwSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 991 NTSTATUS  WINAPI ZwSetSystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG);
 992 NTSTATUS  WINAPI ZwSetSystemTime(const LARGE_INTEGER*,LARGE_INTEGER*);
 993 NTSTATUS  WINAPI ZwSetTimer(HANDLE, const LARGE_INTEGER*, PTIMER_APC_ROUTINE, PVOID, BOOLEAN, ULONG, BOOLEAN*);
 994 NTSTATUS  WINAPI ZwSetValueKey(HANDLE,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
 995 NTSTATUS  WINAPI ZwSetVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
 996 NTSTATUS  WINAPI ZwSuspendThread(HANDLE,PULONG);
 997 NTSTATUS  WINAPI ZwTerminateProcess(HANDLE,LONG);
 998 NTSTATUS  WINAPI ZwUnloadDriver(const UNICODE_STRING *);
 999 NTSTATUS  WINAPI ZwUnloadKey(HANDLE);
1000 NTSTATUS  WINAPI ZwUnmapViewOfSection(HANDLE,PVOID);
1001 NTSTATUS  WINAPI ZwWaitForSingleObject(HANDLE,BOOLEAN,const LARGE_INTEGER*);
1002 NTSTATUS  WINAPI ZwWaitForMultipleObjects(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,const LARGE_INTEGER*);
1003 NTSTATUS  WINAPI ZwWriteFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,const void*,ULONG,PLARGE_INTEGER,PULONG);
1004 NTSTATUS  WINAPI ZwYieldExecution(void);
1005
1006 #endif