VirtualBox

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

Last change on this file since 28475 was 28475, checked in by vboxsync, 15 years ago

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