win32k.h

一个 windows 内核级别的调试器

	void* Port;
	void* Key;
};

struct _SINGLE_LIST_ENTRY {
	_SINGLE_LIST_ENTRY* Next;
};

struct tagVERIFIERTRACKHDR {
	_LIST_ENTRY list;
	DWORD ulSize;
	DWORD ulTag;
};

struct tagVERIFIERTRACKHDR {
	_LIST_ENTRY list;
	DWORD ulSize;
	DWORD ulTag;
};

struct _SLIST_HEADER::__unnamed {
	_SINGLE_LIST_ENTRY Next;
	DWORD Depth;
	DWORD Sequence;
};

struct tagVSTATE {
	DWORD fl;
	int bSystemStable;
	DWORD ulRandomSeed;
	DWORD ulFailureMask;
	DWORD ulDebugLevel;
	HSEMAPHORE__* hsemPoolTracker;
	_LIST_ENTRY lePoolTrackerHead;
};

struct HSEMAPHORE__ {
	int unused;
};

struct tagVSTATE {
	DWORD fl;
	int bSystemStable;
	DWORD ulRandomSeed;
	DWORD ulFailureMask;
	DWORD ulDebugLevel;
	HSEMAPHORE__* hsemPoolTracker;
	_LIST_ENTRY lePoolTrackerHead;
};

struct GDIHandleBitFields {
	DWORD Index:16; 	// bit offset: 00, len=16
	DWORD Type:5; 	// bit offset: 10, len=5
	DWORD AltType:2; 	// bit offset: 15, len=2
	DWORD Stock:1; 	// bit offset: 17, len=1
	DWORD Unique:8; 	// bit offset: 18, len=8
};

struct GDIHandleBitFields {
	DWORD Index:16; 	// bit offset: 00, len=16
	DWORD Type:5; 	// bit offset: 10, len=5
	DWORD AltType:2; 	// bit offset: 15, len=2
	DWORD Stock:1; 	// bit offset: 17, len=1
	DWORD Unique:8; 	// bit offset: 18, len=8
};

struct _DRIVER_OBJECT {
	int Type;
	int Size;
	_DEVICE_OBJECT* DeviceObject;
	DWORD Flags;
	void* DriverStart;
	DWORD DriverSize;
	void* DriverSection;
	_DRIVER_EXTENSION* DriverExtension;
	_UNICODE_STRING DriverName;
	_UNICODE_STRING* HardwareDatabase;
	_FAST_IO_DISPATCH* FastIoDispatch;
	int (*DriverInit)(_DRIVER_OBJECT*, _UNICODE_STRING*);
	void (*DriverStartIo)(_DEVICE_OBJECT*, _IRP*);
	void (*DriverUnload)(_DRIVER_OBJECT*);
	int (*)(_DEVICE_OBJECT*, _IRP*) MajorFunction[28];
};

struct _IRP {
	int Type;
	DWORD Size;
	_MDL* MdlAddress;
	DWORD Flags;
	_IRP::__unnamed AssociatedIrp;
	_LIST_ENTRY ThreadListEntry;
	_IO_STATUS_BLOCK IoStatus;
	char RequestorMode;
	DWORD PendingReturned;
	char StackCount;
	char CurrentLocation;
	DWORD Cancel;
	DWORD CancelIrql;
	char ApcEnvironment;
	DWORD AllocationFlags;
	_IO_STATUS_BLOCK* UserIosb;
	_KEVENT* UserEvent;
	_IRP::__unnamed Overlay;
	void (*CancelRoutine)(_DEVICE_OBJECT*, _IRP*);
	void* UserBuffer;
	_IRP::__unnamed Tail;
};

struct _IO_TIMER {
};

struct _WAIT_CONTEXT_BLOCK {
	_KDEVICE_QUEUE_ENTRY WaitQueueEntry;
	enum _IO_ALLOCATION_ACTION (*DeviceRoutine)(_DEVICE_OBJECT*, _IRP*, void*, void*);
	void* DeviceContext;
	DWORD NumberOfMapRegisters;
	void* DeviceObject;
	void* CurrentIrp;
	_KDPC* BufferChainingDpc;
};

struct _DEVICE_OBJECT::__unnamed {
	_LIST_ENTRY ListEntry;
	_WAIT_CONTEXT_BLOCK Wcb;
};

struct _KDEVICE_QUEUE {
	int Type;
	int Size;
	_LIST_ENTRY DeviceListHead;
	DWORD Lock;
	DWORD Busy;
};

struct _KDPC {
	int Type;
	DWORD Number;
	DWORD Importance;
	_LIST_ENTRY DpcListEntry;
	void (*DeferredRoutine)(_KDPC*, void*, void*, void*);
	void* DeferredContext;
	void* SystemArgument1;
	void* SystemArgument2;
	DWORD* Lock;
};

struct _DEVOBJ_EXTENSION {
	int Type;
	DWORD Size;
	_DEVICE_OBJECT* DeviceObject;
};

struct _DEVICE_OBJECT {
	int Type;
	DWORD Size;
	int ReferenceCount;
	_DRIVER_OBJECT* DriverObject;
	_DEVICE_OBJECT* NextDevice;
	_DEVICE_OBJECT* AttachedDevice;
	_IRP* CurrentIrp;
	_IO_TIMER* Timer;
	DWORD Flags;
	DWORD Characteristics;
	_VPB* Vpb;
	void* DeviceExtension;
	DWORD DeviceType;
	char StackSize;
	_DEVICE_OBJECT::__unnamed Queue;
	DWORD AlignmentRequirement;
	_KDEVICE_QUEUE DeviceQueue;
	_KDPC Dpc;
	DWORD ActiveThreadCount;
	void* SecurityDescriptor;
	_KEVENT DeviceLock;
	DWORD SectorSize;
	DWORD Spare1;
	_DEVOBJ_EXTENSION* DeviceObjectExtension;
	void* Reserved;
};

struct _SECTION_OBJECT_POINTERS {
	void* DataSectionObject;
	void* SharedCacheMap;
	void* ImageSectionObject;
};

struct _KDEVICE_QUEUE {
	int Type;
	int Size;
	_LIST_ENTRY DeviceListHead;
	DWORD Lock;
	DWORD Busy;
};

struct _GENERIC_MAPPING {
	DWORD GenericRead;
	DWORD GenericWrite;
	DWORD GenericExecute;
	DWORD GenericAll;
};

struct _OBJECT_DUMP_CONTROL {
	void* Stream;
	DWORD Detail;
};

enum _OB_OPEN_REASON {
	ObCreateHandle,
	ObOpenHandle,
	ObDuplicateHandle,
	ObInheritHandle,
	ObMaxOpenReason,
};

struct _ACCESS_STATE {
	_LUID OperationID;
	DWORD SecurityEvaluated;
	DWORD GenerateAudit;
	DWORD GenerateOnClose;
	DWORD PrivilegesAllocated;
	DWORD Flags;
	DWORD RemainingDesiredAccess;
	DWORD PreviouslyGrantedAccess;
	DWORD OriginalDesiredAccess;
	_SECURITY_SUBJECT_CONTEXT SubjectSecurityContext;
	void* SecurityDescriptor;
	void* AuxData;
	_ACCESS_STATE::__unnamed Privileges;
	DWORD AuditPrivileges;
	_UNICODE_STRING ObjectName;
	_UNICODE_STRING ObjectTypeName;
};

struct _SECURITY_QUALITY_OF_SERVICE {
	DWORD Length;
	enum _SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
	DWORD ContextTrackingMode;
	DWORD EffectiveOnly;
};

enum _SECURITY_OPERATION_CODE {
	SetSecurityDescriptor,
	QuerySecurityDescriptor,
	DeleteSecurityDescriptor,
	AssignSecurityDescriptor,
};

struct _OBJECT_NAME_INFORMATION {
	_UNICODE_STRING Name;
};

struct _OBJECT_TYPE_INITIALIZER {
	DWORD Length;
	DWORD UseDefaultObject;
	DWORD CaseInsensitive;
	DWORD InvalidAttributes;
	_GENERIC_MAPPING GenericMapping;
	DWORD ValidAccessMask;
	DWORD SecurityRequired;
	DWORD MaintainHandleCount;
	DWORD MaintainTypeList;
	enum _POOL_TYPE PoolType;
	DWORD DefaultPagedPoolCharge;
	DWORD DefaultNonPagedPoolCharge;
	void (*DumpProcedure)(void*, _OBJECT_DUMP_CONTROL*);
	int (*OpenProcedure)(enum _OB_OPEN_REASON, _EPROCESS*, void*, DWORD, DWORD);
	void (*CloseProcedure)(_EPROCESS*, void*, DWORD, DWORD, DWORD);
	void (*DeleteProcedure)(void*);
	int (*ParseProcedure)(void*, void*, _ACCESS_STATE*, char, DWORD, _UNICODE_STRING*, _UNICODE_STRING*, void*, _SECURITY_QUALITY_OF_SERVICE*, void**);
	int (*SecurityProcedure)(void*, enum _SECURITY_OPERATION_CODE, DWORD*, void*, DWORD*, void**, enum _POOL_TYPE, _GENERIC_MAPPING*);
	int (*QueryNameProcedure)(void*, DWORD, _OBJECT_NAME_INFORMATION*, DWORD, DWORD*);
	DWORD (*OkayToCloseProcedure)(_EPROCESS*, void*, void*, char);
};

struct _OWNER_ENTRY {
	DWORD OwnerThread;
	int OwnerCount;
	DWORD TableSize;
};

struct _KSEMAPHORE {
	_DISPATCHER_HEADER Header;
	int Limit;
};

struct _ERESOURCE {
	_LIST_ENTRY SystemResourcesList;
	_OWNER_ENTRY* OwnerTable;
	int ActiveCount;
	DWORD Flag;
	_KSEMAPHORE* SharedWaiters;
	_KEVENT* ExclusiveWaiters;
	_OWNER_ENTRY OwnerThreads[2];
	DWORD ContentionCount;
	DWORD NumberOfSharedWaiters;
	DWORD NumberOfExclusiveWaiters;
	void* Address;
	DWORD CreatorBackTraceIndex;
	DWORD SpinLock;
};

struct _VPB {
	int Type;
	int Size;
	DWORD Flags;
	DWORD VolumeLabelLength;
	_DEVICE_OBJECT* DeviceObject;
	_DEVICE_OBJECT* RealDevice;
	DWORD SerialNumber;
	DWORD ReferenceCount;
	DWORD VolumeLabel[32];
};

struct _GENERIC_MAPPING {
	DWORD GenericRead;
	DWORD GenericWrite;
	DWORD GenericExecute;
	DWORD GenericAll;
};

enum _MEMORY_CACHING_TYPE_ORIG {
	MmFrameBufferCached,
};

struct _IMAGE_DATA_DIRECTORY {
	DWORD VirtualAddress;
	DWORD Size;
};

struct _IMAGE_OPTIONAL_HEADER {
	DWORD Magic;
	DWORD MajorLinkerVersion;
	DWORD MinorLinkerVersion;
	DWORD SizeOfCode;
	DWORD SizeOfInitializedData;
	DWORD SizeOfUninitializedData;
	DWORD AddressOfEntryPoint;
	DWORD BaseOfCode;
	DWORD BaseOfData;
	DWORD ImageBase;
	DWORD SectionAlignment;
	DWORD FileAlignment;
	DWORD MajorOperatingSystemVersion;
	DWORD MinorOperatingSystemVersion;
	DWORD MajorImageVersion;
	DWORD MinorImageVersion;
	DWORD MajorSubsystemVersion;
	DWORD MinorSubsystemVersion;
	DWORD Win32VersionValue;
	DWORD SizeOfImage;
	DWORD SizeOfHeaders;
	DWORD CheckSum;
	DWORD Subsystem;
	DWORD DllCharacteristics;
	DWORD SizeOfStackReserve;
	DWORD SizeOfStackCommit;
	DWORD SizeOfHeapReserve;
	DWORD SizeOfHeapCommit;
	DWORD LoaderFlags;
	DWORD NumberOfRvaAndSizes;
	_IMAGE_DATA_DIRECTORY DataDirectory[16];
};

enum _MODE {
	KernelMode,
	UserMode,
	MaximumMode,
};

enum GDILoObjType {
	GDILoObjType_LO_BRUSH_TYPE,
	GDILoObjType_LO_DC_TYPE,
	GDILoObjType_LO_BITMAP_TYPE,
	GDILoObjType_LO_PALETTE_TYPE,
	GDILoObjType_LO_FONT_TYPE,
	GDILoObjType_LO_REGION_TYPE,
	GDILoObjType_LO_ICMLCS_TYPE,
	GDILoObjType_LO_CLIENTOBJ_TYPE,
	GDILoObjType_LO_ALTDC_TYPE,
	GDILoObjType_LO_PEN_TYPE,
	GDILoObjType_LO_EXTPEN_TYPE,
	GDILoObjType_LO_DIBSECTION_TYPE,
	GDILoObjType_LO_METAFILE16_TYPE,
	GDILoObjType_LO_METAFILE_TYPE,
	GDILoObjType_LO_METADC16_TYPE,
};

struct _KDEVICE_QUEUE_ENTRY {
	_LIST_ENTRY DeviceListEntry;
	DWORD SortKey;
	DWORD Inserted;
};

enum _IO_ALLOCATION_ACTION {
	KeepObject,
	DeallocateObject,
	DeallocateObjectKeepRegisters,
};

struct _WAIT_CONTEXT_BLOCK {
	_KDEVICE_QUEUE_ENTRY WaitQueueEntry;
	enum _IO_ALLOCATION_ACTION (*DeviceRoutine)(_DEVICE_OBJECT*, _IRP*, void*, void*);
	void* DeviceContext;
	DWORD NumberOfMapRegisters;
	void* DeviceObject;
	void* CurrentIrp;
	_KDPC* BufferChainingDpc;
};

struct _KDPC {
	int Type;
	DWORD Number;
	DWORD Importance;
	_LIST_ENTRY DpcListEntry;
	void (*DeferredRoutine)(_KDPC*, void*, void*, void*);
	void* DeferredContext;
	void* SystemArgument1;
	void* SystemArgument2;
	DWORD* Lock;
};

struct _MDL {
	_MDL* Next;
	int Size;
	int MdlFlags;
	_EPROCESS* Process;
	void* MappedSystemVa;
	void* StartVa;
	DWORD ByteCount;
	DWORD ByteOffset;
};

struct _IRP::__unnamed {
	_IRP* MasterIrp;
	int IrpCount;
	void* SystemBuffer;
};

struct _IO_STATUS_BLOCK {
	int Status;
	void* Pointer;
	DWORD Information;
};

struct _IRP::__unnamed::__unnamed {
	void (*UserApcRoutine)(void*, _IO_STATUS_BLOCK*, DWORD);
	void* UserApcContext;
};

struct _IRP::__unnamed {
	_IRP::__unnamed::__unnamed AsynchronousParameters;
	_LARGE_INTEGER AllocationSize;
};

struct _IO_STACK_LOCATION {
	DWORD MajorFunction;
	DWORD MinorFunction;
	DWORD Flags;
	DWORD Control;
	_IO_STACK_LOCATION::__unnamed Parameters;
	_DEVICE_OBJECT* DeviceObject;
	_FILE_OBJECT* FileObject;
	int (*CompletionRoutine)(_DEVICE_OBJECT*, _IRP*, void*);
	void* Context;
};

struct _IRP::__unnamed::__unnamed {
	_KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
	void* DriverContext[4];
	_ETHREAD* Thread;
	char* AuxiliaryBuffer;
	_LIST_ENTRY ListEntry;
	_IO_STACK_LOCATION* CurrentStackLocation;
	DWORD PacketType;
	_FILE_OBJECT* OriginalFileObject;
};

struct _KAPC {
	int Type;
	int Size;
	DWORD Spare0;
	_KTHREAD* Thread;
	_LIST_ENTRY ApcListEntry;
	void (*KernelRoutine)(_KAPC*, void (*)(void*, void*, void*)*, void**, void**, void**);
	void (*RundownRoutine)(_KAPC*);
	void (*NormalRoutine)(void*, void*, void*);
	void* NormalContext;
	void* SystemArgument1;
	void* SystemArgument2;
	char ApcStateIndex;
	char ApcMode;
	DWORD Inserted;
};

struct _IRP::__unnamed {
	_IRP::__unnamed::__unnamed Overlay;
	_KAPC Apc;
	void* CompletionKey;
};

struct _IRP {
	int Type;
	DWORD Size;
	_MDL* MdlAddress;
	DWORD Flags;
	_IRP::__unnamed AssociatedIrp;
	_LIST_ENTRY ThreadListEntry;
	_IO_STATUS_BLOCK IoStatus;
	char RequestorMode;
	DWORD PendingReturned;
	char StackCount;
	char CurrentLocation;
	DWORD Cancel;
	DWORD CancelIrql;
	char ApcEnvironment;
	DWORD AllocationFlags;
	_IO_STATUS_BLOCK* UserIosb;
	_KEVENT* UserEvent;
	_IRP::__unnamed Overlay;
	void (*CancelRoutine)(_DEVICE_OBJECT*, _IRP*);
	void* UserBuffer;
	_IRP::__unnamed Tail;
};

struct _IRP::__unnamed::__unnamed::__unnamed {
	_KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
	void* DriverContext[4];
};

struct _IRP::__unnamed::__unnamed::__unnamed::__unnamed {
	void* DriverContext[4];
};

struct _IRP::__unnamed::__unnamed::__unnamed {
	_LIST_ENTRY ListEntry;
	_IO_STACK_LOCATION* CurrentStackLocation;
	DWORD PacketType;
};

struct _IRP::__unnamed::__unnamed::__unnamed::__unnamed {
	_IO_STACK_LOCATION* CurrentStackLocation;
	DWORD PacketType;
};

struct _OWNER_ENTRY {
	DWORD OwnerThread;
	int OwnerCount;
	DWORD TableSize;
};

struct _OWNER_ENTRY::__unnamed {
	int OwnerCount;
	DWORD TableSize;
};

enum ReplacesCorHdrNumericDefines {
	COMIMAGE_FLAGS_ILONLY,
	COMIMAGE_FLAGS_32BITREQUIRED,
	COMIMAGE_FLAGS_IL_LIBRARY,
	COMIMAGE_FLAGS_TRACKDEBUGDATA,
	COR_VERSION_MAJOR_V2,
	COR_VERSION_MAJOR,
	COR_VERSION_MINOR,
	COR_DELETED_NAME_LENGTH,
	COR_VTABLEGAP_NAME_LENGTH,
	NATIVE_TYPE_MAX_CB,
	COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE,
	IMAGE_COR_MIH_METHODRVA,
	IMAGE_COR_MIH_EHRVA,
	IMAGE_COR_MIH_BASICBLOCK,
	COR_VTABLE_32BIT,
	COR_VTABLE_64BIT,
	COR_VTABLE_FROM_UNMANAGED,
	COR_VTABLE_CALL_MOST_DERIVED,
	IMAGE_COR_EATJ_THUNK_SIZE,
	MAX_CLASS_NAME,
	MAX_PACKAGE_NAME,
};

enum _MEMORY_TYPE {
	MemoryExceptionBlock,
	MemorySystemBlock,
	MemoryFree,
	MemoryBad,