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