VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/include/ddk/wdm.h@ 19678

Last change on this file since 19678 was 19678, checked in by vboxsync, 16 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette