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