acpi.h

一个 windows 内核级别的调试器

struct _KTRAP_FRAME {
	DWORD DbgEbp;
	DWORD DbgEip;
	DWORD DbgArgMark;
	DWORD DbgArgPointer;
	DWORD TempSegCs;
	DWORD TempEsp;
	DWORD Dr0;
	DWORD Dr1;
	DWORD Dr2;
	DWORD Dr3;
	DWORD Dr6;
	DWORD Dr7;
	DWORD SegGs;
	DWORD SegEs;
	DWORD SegDs;
	DWORD Edx;
	DWORD Ecx;
	DWORD Eax;
	DWORD PreviousPreviousMode;
	_EXCEPTION_REGISTRATION_RECORD* ExceptionList;
	DWORD SegFs;
	DWORD Edi;
	DWORD Esi;
	DWORD Ebx;
	DWORD Ebp;
	DWORD ErrCode;
	DWORD Eip;
	DWORD SegCs;
	DWORD EFlags;
	DWORD HardwareEsp;
	DWORD HardwareSegSs;
	DWORD V86Es;
	DWORD V86Ds;
	DWORD V86Fs;
	DWORD V86Gs;
};

struct _KTHREAD {
	_DISPATCHER_HEADER Header;
	_LIST_ENTRY MutantListHead;
	void* InitialStack;
	void* StackLimit;
	void* Teb;
	void* TlsArray;
	void* KernelStack;
	DWORD DebugActive;
	DWORD State;
	DWORD Alerted[2];
	DWORD Iopl;
	DWORD NpxState;
	char Saturation;
	char Priority;
	_KAPC_STATE ApcState;
	DWORD ContextSwitches;
	DWORD IdleSwapBlock;
	DWORD Spare0[3];
	int WaitStatus;
	DWORD WaitIrql;
	char WaitMode;
	DWORD WaitNext;
	DWORD WaitReason;
	_KWAIT_BLOCK* WaitBlockList;
	_LIST_ENTRY WaitListEntry;
	_SINGLE_LIST_ENTRY SwapListEntry;
	DWORD WaitTime;
	char BasePriority;
	DWORD DecrementCount;
	char PriorityDecrement;
	char Quantum;
	_KWAIT_BLOCK WaitBlock[4];
	void* LegoData;
	DWORD KernelApcDisable;
	DWORD UserAffinity;
	DWORD SystemAffinityActive;
	DWORD PowerState;
	DWORD NpxIrql;
	DWORD InitialNode;
	void* ServiceTable;
	_KQUEUE* Queue;
	DWORD ApcQueueLock;
	_KTIMER Timer;
	_LIST_ENTRY QueueListEntry;
	DWORD SoftAffinity;
	DWORD Affinity;
	DWORD Preempted;
	DWORD ProcessReadyQueue;
	DWORD KernelStackResident;
	DWORD NextProcessor;
	void* CallbackStack;
	void* Win32Thread;
	_KTRAP_FRAME* TrapFrame;
	_KAPC_STATE* ApcStatePointer[2];
	char PreviousMode;
	DWORD EnableStackSwap;
	DWORD LargeStack;
	DWORD ResourceIndex;
	DWORD KernelTime;
	DWORD UserTime;
	_KAPC_STATE SavedApcState;
	DWORD Alertable;
	DWORD ApcStateIndex;
	DWORD ApcQueueable;
	DWORD AutoAlignment;
	void* StackBase;
	_KAPC SuspendApc;
	_KSEMAPHORE SuspendSemaphore;
	_LIST_ENTRY ThreadListEntry;
	char FreezeCount;
	char SuspendCount;
	DWORD IdealProcessor;
	DWORD DisableBoost;
};

struct _MMSUPPORT_FLAGS {
	DWORD SessionSpace:1; 	// bit offset: 00, len=1
	DWORD BeingTrimmed:1; 	// bit offset: 01, len=1
	DWORD SessionLeader:1; 	// bit offset: 02, len=1
	DWORD TrimHard:1; 	// bit offset: 03, len=1
	DWORD WorkingSetHard:1; 	// bit offset: 04, len=1
	DWORD AddressSpaceBeingDeleted:1; 	// bit offset: 05, len=1
	DWORD Available:10; 	// bit offset: 06, len=10
	DWORD AllowWorkingSetAdjustment:8; 	// bit offset: 10, len=8
	DWORD MemoryPriority:8; 	// bit offset: 18, len=8
};

struct RSDTELEMENT {
	DWORD Flags;
	void* Handle;
	void* Address;
};

struct _TERMINATION_PORT {
	_TERMINATION_PORT* Next;
	void* Port;
};

struct _OpRegionObj {
	DWORD uipOffset;
	DWORD dwLen;
	DWORD bRegionSpace;
	DWORD reserved[3];
	int RegionBusy;
	DWORD listLock;
	_List* plistWaiters;
};

struct _OpRegionObj {
	DWORD uipOffset;
	DWORD dwLen;
	DWORD bRegionSpace;
	DWORD reserved[3];
	int RegionBusy;
	DWORD listLock;
	_List* plistWaiters;
};

struct _FNSAVE_FORMAT {
	DWORD ControlWord;
	DWORD StatusWord;
	DWORD TagWord;
	DWORD ErrorOffset;
	DWORD ErrorSelector;
	DWORD DataOffset;
	DWORD DataSelector;
	DWORD RegisterArea[80];
};

struct PROCESSOR_PERF_STATE {
	DWORD PercentFrequency;
	DWORD MinCapacity;
	DWORD Power;
	DWORD IncreaseLevel;
	DWORD DecreaseLevel;
	DWORD Flags;
	DWORD IncreaseTime;
	DWORD DecreaseTime;
	DWORD IncreaseCount;
	DWORD DecreaseCount;
	DWORD PerformanceTime;
};

struct PROCESSOR_IDLE_TIMES {
	DWORD StartTime;
	DWORD EndTime;
	DWORD IdleHandlerReserved[4];
};

enum _KWAIT_REASON {
	Executive,
	FreePage,
	PageIn,
	PoolAllocation,
	DelayExecution,
	Suspended,
	UserRequest,
	WrExecutive,
	WrFreePage,
	WrPageIn,
	WrPoolAllocation,
	WrDelayExecution,
	WrSuspended,
	WrUserRequest,
	WrEventPair,
	WrQueue,
	WrLpcReceive,
	WrLpcReply,
	WrVirtualMemory,
	WrPageOut,
	WrRendezvous,
	Spare2,
	Spare3,
	Spare4,
	Spare5,
	Spare6,
	WrKernel,
	MaximumWaitReason,
};

struct _HANDLE_TRACE_DB_ENTRY {
	_CLIENT_ID ClientId;
	void* Handle;
	DWORD Type;
	void* StackTrace[16];
};

struct _HANDLE_TRACE_DEBUG_INFO {
	DWORD CurrentStackIndex;
	_HANDLE_TRACE_DB_ENTRY TraceDb[4096];
};

struct _PROCESS_WS_WATCH_INFORMATION {
	void* FaultingPc;
	void* FaultingVa;
};

struct _PAGEFAULT_HISTORY {
	DWORD CurrentIndex;
	DWORD MaxIndex;
	DWORD SpinLock;
	void* Reserved;
	_PROCESS_WS_WATCH_INFORMATION WatchInfo[1];
};

struct _HARDWARE_PTE_X86 {
	DWORD Valid:1; 	// bit offset: 00, len=1
	DWORD Write:1; 	// bit offset: 01, len=1
	DWORD Owner:1; 	// bit offset: 02, len=1
	DWORD WriteThrough:1; 	// bit offset: 03, len=1
	DWORD CacheDisable:1; 	// bit offset: 04, len=1
	DWORD Accessed:1; 	// bit offset: 05, len=1
	DWORD Dirty:1; 	// bit offset: 06, len=1
	DWORD LargePage:1; 	// bit offset: 07, len=1
	DWORD Global:1; 	// bit offset: 08, len=1
	DWORD CopyOnWrite:1; 	// bit offset: 09, len=1
	DWORD Prototype:1; 	// bit offset: 0A, len=1
	DWORD reserved:1; 	// bit offset: 0B, len=1
	DWORD PageFrameNumber:20; 	// bit offset: 0C, len=20
};

struct _GEN_ADDR {
	DWORD AddressSpaceID;
	DWORD BitWidth;
	DWORD BitOffset;
	DWORD Reserved;
	_LARGE_INTEGER Address;
};

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;
	__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 _LARGE_INTEGER {
	DWORD LowPart;
	int HighPart;
	__unnamed u;
	int QuadPart;
};

struct _List {
	_List* plistPrev;
	_List* plistNext;
};

struct _KWAIT_BLOCK {
	_LIST_ENTRY WaitListEntry;
	_KTHREAD* Thread;
	void* Object;
	_KWAIT_BLOCK* NextWaitBlock;
	DWORD WaitKey;
	DWORD WaitType;
};

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

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 _GENERIC_MAPPING {
	DWORD GenericRead;
	DWORD GenericWrite;
	DWORD GenericExecute;
	DWORD GenericAll;
};

struct _SID_AND_ATTRIBUTES {
	void* Sid;
	DWORD Attributes;
};

struct _LUID_AND_ATTRIBUTES {
	_LUID Luid;
	DWORD Attributes;
};

struct _PS_JOB_TOKEN_FILTER {
	DWORD CapturedSidCount;
	_SID_AND_ATTRIBUTES* CapturedSids;
	DWORD CapturedSidsLength;
	DWORD CapturedGroupCount;
	_SID_AND_ATTRIBUTES* CapturedGroups;
	DWORD CapturedGroupsLength;
	DWORD CapturedPrivilegeCount;
	_LUID_AND_ATTRIBUTES* CapturedPrivileges;
	DWORD CapturedPrivilegesLength;
};

enum _MEMORY_CACHING_TYPE_ORIG {
	MmFrameBufferCached,
};

struct _ProcessorObj {
	DWORD dwPBlk;
	DWORD dwPBlkLen;
	DWORD bApicID;
};

struct _ProcessorObj {
	DWORD dwPBlk;
	DWORD dwPBlkLen;
	DWORD bApicID;
};

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;
	__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;
	__unnamed Overlay;
	void (*CancelRoutine)(_DEVICE_OBJECT*, _IRP*);
	void* UserBuffer;
	__unnamed Tail;
};

struct _IO_TIMER {
	int Type;
	int TimerFlag;
	_LIST_ENTRY TimerList;
	void (*TimerRoutine)(_DEVICE_OBJECT*, void*);
	void* Context;
	_DEVICE_OBJECT* DeviceObject;
};

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

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 __unnamed {
	_LIST_ENTRY ListEntry;
	_WAIT_CONTEXT_BLOCK Wcb;
};

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

struct _DEVOBJ_EXTENSION {
	int Type;
	DWORD Size;
	_DEVICE_OBJECT* DeviceObject;
	DWORD PowerFlags;
	_DEVICE_OBJECT_POWER_EXTENSION* Dope;
	DWORD ExtensionFlags;
	void* DeviceNode;
	_DEVICE_OBJECT* AttachedTo;
	int StartIoCount;
	int StartIoKey;
	DWORD StartIoFlags;
	_VPB* Vpb;
};

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;
	__unnamed Queue;
	DWORD AlignmentRequirement;
	_KDEVICE_QUEUE DeviceQueue;
	_KDPC Dpc;
	DWORD ActiveThreadCount;
	void* SecurityDescriptor;
	_KEVENT D