Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
NT4/private/ntos/ke/genxx.inc

808 lines
24 KiB
PHP
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
genxx.inc
Abstract:
This file contains common code to generate assembler definitions.
Author:
David N. Cutler (davec) 9-Aug-1995
Revision History:
--*/
//
// Process state enumerated type definitions.
//
genCom("Process State Enumerated Type Values");
genVal(ProcessInMemory, ProcessInMemory);
genVal(ProcessOutOfMemory, ProcessOutOfMemory);
genVal(ProcessInTransition, ProcessInTransition);
//
// Thread state enumerated type definitions.
//
genCom("Thread State Enumerated Type Values");
genVal(Initialized, Initialized);
genVal(Ready, Ready);
genVal(Running, Running);
genVal(Standby, Standby);
genVal(Terminated, Terminated);
genVal(Waiting, Waiting);
//
// Wait reason and wait type enumerated type definitions.
//
EnableInc(HAL);
genCom("Wait Reason and Wait Type Enumerated Type Values");
genVal(WrExecutive, Executive);
DisableInc(HAL);
genVal(WrEventPair, WrEventPair);
genVal(WaitAny, WaitAny);
genVal(WaitAll, WaitAll);
//
// APC state structure offset definitions.
//
genCom("Apc State Structure Offset Definitions");
genDef(As, KAPC_STATE, ApcListHead);
genDef(As, KAPC_STATE, Process);
genDef(As, KAPC_STATE, KernelApcInProgress);
genDef(As, KAPC_STATE, KernelApcPending);
genDef(As, KAPC_STATE, UserApcPending);
//
// Bug check code definitions
//
EnableInc(HAL);
genCom("Bug Check Code Definitions");
genVal(APC_INDEX_MISMATCH, APC_INDEX_MISMATCH);
genVal(DATA_BUS_ERROR, DATA_BUS_ERROR);
genVal(DATA_COHERENCY_EXCEPTION, DATA_COHERENCY_EXCEPTION);
genVal(HAL1_INITIALIZATION_FAILED, HAL1_INITIALIZATION_FAILED);
genVal(INSTRUCTION_BUS_ERROR, INSTRUCTION_BUS_ERROR);
genVal(INSTRUCTION_COHERENCY_EXCEPTION, INSTRUCTION_COHERENCY_EXCEPTION);
genVal(INTERRUPT_EXCEPTION_NOT_HANDLED, INTERRUPT_EXCEPTION_NOT_HANDLED);
genVal(INTERRUPT_UNWIND_ATTEMPTED, INTERRUPT_UNWIND_ATTEMPTED);
genVal(INVALID_AFFINITY_SET, INVALID_AFFINITY_SET);
genVal(INVALID_DATA_ACCESS_TRAP, INVALID_DATA_ACCESS_TRAP);
genVal(IRQL_GT_ZERO_AT_SYSTEM_SERVICE, IRQL_GT_ZERO_AT_SYSTEM_SERVICE);
genVal(IRQL_NOT_LESS_OR_EQUAL, IRQL_NOT_LESS_OR_EQUAL);
genVal(KMODE_EXCEPTION_NOT_HANDLED, KMODE_EXCEPTION_NOT_HANDLED);
genVal(NMI_HARDWARE_FAILURE, NMI_HARDWARE_FAILURE);
genVal(NO_USER_MODE_CONTEXT, NO_USER_MODE_CONTEXT);
genVal(PAGE_FAULT_WITH_INTERRUPTS_OFF, PAGE_FAULT_WITH_INTERRUPTS_OFF);
genVal(PANIC_STACK_SWITCH, PANIC_STACK_SWITCH);
genVal(SPIN_LOCK_INIT_FAILURE, SPIN_LOCK_INIT_FAILURE);
genVal(SYSTEM_EXIT_OWNED_MUTEX, SYSTEM_EXIT_OWNED_MUTEX);
genVal(SYSTEM_SERVICE_EXCEPTION, SYSTEM_SERVICE_EXCEPTION);
genVal(SYSTEM_UNWIND_PREVIOUS_USER, SYSTEM_UNWIND_PREVIOUS_USER);
genVal(TRAP_CAUSE_UNKNOWN, TRAP_CAUSE_UNKNOWN);
genVal(UNEXPECTED_KERNEL_MODE_TRAP, UNEXPECTED_KERNEL_MODE_TRAP);
DisableInc(HAL);
//
// Breakpoint types
//
EnableInc(HAL);
genCom("Breakpoint type definitions");
genVal(DBG_STATUS_CONTROL_C, DBG_STATUS_CONTROL_C);
DisableInc(HAL);
//
// Client Id structure offset definitions.
//
genCom("Client Id Structure Offset Definitions");
genDef(Cid, CLIENT_ID, UniqueProcess);
genDef(Cid, CLIENT_ID, UniqueThread);
//
// Critical section structure offset definitions.
//
genCom("Critical Section Structure Offset Definitions");
genDef(Cs, RTL_CRITICAL_SECTION, DebugInfo);
genDef(Cs, RTL_CRITICAL_SECTION, LockCount);
genDef(Cs, RTL_CRITICAL_SECTION, RecursionCount);
genDef(Cs, RTL_CRITICAL_SECTION, OwningThread);
genDef(Cs, RTL_CRITICAL_SECTION, LockSemaphore);
//
// Critical section debug information structure offset definitions.
//
genCom("Critical Section Debug Information Structure Offset Definitions");
genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, Type);
genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndex);
genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, CriticalSection);
genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, ProcessLocksList);
genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, EntryCount);
genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, ContentionCount);
//
// Exception dispatcher context structure offset definitions.
//
#if defined(_ALPHA_) || defined(_MIPS_) || defined(_PPC_)
genCom("Dispatcher Context Structure Offset Definitions");
genDef(Dc, DISPATCHER_CONTEXT, ControlPc);
genDef(Dc, DISPATCHER_CONTEXT, FunctionEntry);
genDef(Dc, DISPATCHER_CONTEXT, EstablisherFrame);
genDef(Dc, DISPATCHER_CONTEXT, ContextRecord);
#endif
//
// Exception record offset, flag, and enumerated type definitions.
//
EnableInc(HAL);
genCom("Exception Record Offset, Flag, and Enumerated Type Definitions");
genVal(EXCEPTION_NONCONTINUABLE, EXCEPTION_NONCONTINUABLE);
genVal(EXCEPTION_UNWINDING, EXCEPTION_UNWINDING);
genVal(EXCEPTION_EXIT_UNWIND, EXCEPTION_EXIT_UNWIND);
genVal(EXCEPTION_STACK_INVALID, EXCEPTION_STACK_INVALID);
genVal(EXCEPTION_NESTED_CALL, EXCEPTION_NESTED_CALL);
genVal(EXCEPTION_TARGET_UNWIND, EXCEPTION_TARGET_UNWIND);
genVal(EXCEPTION_COLLIDED_UNWIND, EXCEPTION_COLLIDED_UNWIND);
genVal(EXCEPTION_UNWIND, EXCEPTION_UNWIND);
genVal(EXCEPTION_EXECUTE_HANDLER, EXCEPTION_EXECUTE_HANDLER);
genVal(EXCEPTION_CONTINUE_SEARCH, EXCEPTION_CONTINUE_SEARCH);
genVal(EXCEPTION_CONTINUE_EXECUTION, EXCEPTION_CONTINUE_EXECUTION);
#if defined(_X86_)
genVal(EXCEPTION_CHAIN_END, (ULONG)EXCEPTION_CHAIN_END);
#endif
genSpc();
genVal(ExceptionContinueExecution, ExceptionContinueExecution);
genVal(ExceptionContinueSearch, ExceptionContinueSearch);
genVal(ExceptionNestedException, ExceptionNestedException);
genVal(ExceptionCollidedUnwind, ExceptionCollidedUnwind);
genSpc();
genDef(Er, EXCEPTION_RECORD, ExceptionCode);
genDef(Er, EXCEPTION_RECORD, ExceptionFlags);
genDef(Er, EXCEPTION_RECORD, ExceptionRecord);
genDef(Er, EXCEPTION_RECORD, ExceptionAddress);
genDef(Er, EXCEPTION_RECORD, NumberParameters);
genDef(Er, EXCEPTION_RECORD, ExceptionInformation);
genVal(ExceptionRecordLength, (sizeof(EXCEPTION_RECORD) + 15) & (~15));
DisableInc(HAL);
//
// Fast Mutex structure offset definitions.
//
EnableInc(HAL);
genCom("Fast Mutex Structure Offset Definitions");
genDef(Fm, FAST_MUTEX, Count);
genDef(Fm, FAST_MUTEX, Owner);
genDef(Fm, FAST_MUTEX, Contention);
genDef(Fm, FAST_MUTEX, Event);
genDef(Fm, FAST_MUTEX, OldIrql);
//
// Interrupt priority request level definitions
//
genCom("Interrupt Priority Request Level Definitions");
genVal(APC_LEVEL, APC_LEVEL);
genVal(DISPATCH_LEVEL, DISPATCH_LEVEL);
#if defined(_X86_)
genVal(CLOCK1_LEVEL, CLOCK1_LEVEL);
genVal(CLOCK2_LEVEL, CLOCK2_LEVEL);
#endif
genVal(IPI_LEVEL, IPI_LEVEL);
genVal(POWER_LEVEL, POWER_LEVEL);
genVal(PROFILE_LEVEL, PROFILE_LEVEL);
genVal(HIGH_LEVEL, HIGH_LEVEL);
genVal(SYNCH_LEVEL, SYNCH_LEVEL);
//
// Large integer structure offset definitions.
//
genCom("Large Integer Structure Offset Definitions");
genDef(Li, LARGE_INTEGER, LowPart);
genDef(Li, LARGE_INTEGER, HighPart);
//
// List entry structure offset definitions.
//
genCom("List Entry Structure Offset Definitions");
genDef(Ls, LIST_ENTRY, Flink);
genDef(Ls, LIST_ENTRY, Blink);
//
// String structure offset definitions.
//
genCom("String Structure Offset Definitions");
genDef(Str, STRING, Length);
genDef(Str, STRING, MaximumLength);
genDef(Str, STRING, Buffer);
//
// System time structure offset definitions.
//
#if defined(_MIPS_) || defined(_PPC_) || defined(_X86_)
genCom("System Time Structure Offset Definitions");
genAlt(StLowTime, KSYSTEM_TIME, LowPart);
genDef(St, KSYSTEM_TIME, High1Time);
genDef(St, KSYSTEM_TIME, High2Time);
#endif
//
// Time structure offset definitions.
//
genCom("Time Structure Offset Definitions");
genAlt(TmLowTime, LARGE_INTEGER, LowPart);
genAlt(TmHighTime, LARGE_INTEGER , HighPart);
DisableInc(HAL);
//
// Thread switch counter structure offset definitions.
//
genCom("Thread Switch Counter Offset Definitions");
genDef(Tw, KTHREAD_SWITCH_COUNTERS, FindAny);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, FindIdeal);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, FindLast);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleAny);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleCurrent);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleIdeal);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleLast);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, PreemptAny);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, PreemptCurrent);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, PreemptLast);
genDef(Tw, KTHREAD_SWITCH_COUNTERS, SwitchToIdle);
//
// Status code definitions
//
genCom("Status Code Definitions");
#if defined(_ALPHA_)
genVal(STATUS_ALPHA_ARITHMETIC_EXCEPTION, STATUS_ALPHA_ARITHMETIC_EXCEPTION);
genVal(STATUS_ALPHA_BAD_VIRTUAL_ADDRESS, STATUS_ALPHA_BAD_VIRTUAL_ADDRESS);
genVal(STATUS_ALPHA_FLOATING_NOT_IMPLEMENTED, STATUS_ALPHA_FLOATING_NOT_IMPLEMENTED);
genVal(STATUS_ALPHA_GENTRAP, STATUS_ALPHA_GENTRAP);
genVal(STATUS_ALPHA_MACHINE_CHECK, (DATA_BUS_ERROR | 0xdfff0000));
#endif
genVal(STATUS_ACCESS_VIOLATION, STATUS_ACCESS_VIOLATION);
genVal(STATUS_ARRAY_BOUNDS_EXCEEDED, STATUS_ARRAY_BOUNDS_EXCEEDED);
genVal(STATUS_BAD_COMPRESSION_BUFFER, STATUS_BAD_COMPRESSION_BUFFER);
genVal(STATUS_BREAKPOINT, STATUS_BREAKPOINT);
genVal(STATUS_DATATYPE_MISALIGNMENT, STATUS_DATATYPE_MISALIGNMENT);
genVal(STATUS_FLOAT_DENORMAL_OPERAND, STATUS_FLOAT_DENORMAL_OPERAND);
genVal(STATUS_FLOAT_DIVIDE_BY_ZERO, STATUS_FLOAT_DIVIDE_BY_ZERO);
genVal(STATUS_FLOAT_INEXACT_RESULT, STATUS_FLOAT_INEXACT_RESULT);
genVal(STATUS_FLOAT_INVALID_OPERATION, STATUS_FLOAT_INVALID_OPERATION);
genVal(STATUS_FLOAT_OVERFLOW, STATUS_FLOAT_OVERFLOW);
genVal(STATUS_FLOAT_STACK_CHECK, STATUS_FLOAT_STACK_CHECK);
genVal(STATUS_FLOAT_UNDERFLOW, STATUS_FLOAT_UNDERFLOW);
genVal(STATUS_GUARD_PAGE_VIOLATION, STATUS_GUARD_PAGE_VIOLATION);
genVal(STATUS_ILLEGAL_FLOAT_CONTEXT, STATUS_ILLEGAL_FLOAT_CONTEXT);
genVal(STATUS_ILLEGAL_INSTRUCTION, STATUS_ILLEGAL_INSTRUCTION);
genVal(STATUS_INSTRUCTION_MISALIGNMENT, STATUS_INSTRUCTION_MISALIGNMENT);
genVal(STATUS_INVALID_HANDLE, STATUS_INVALID_HANDLE);
genVal(STATUS_INVALID_LOCK_SEQUENCE, STATUS_INVALID_LOCK_SEQUENCE);
genVal(STATUS_INVALID_OWNER, STATUS_INVALID_OWNER);
genVal(STATUS_INVALID_PARAMETER_1, STATUS_INVALID_PARAMETER_1);
genVal(STATUS_INVALID_SYSTEM_SERVICE, STATUS_INVALID_SYSTEM_SERVICE);
genVal(STATUS_INTEGER_DIVIDE_BY_ZERO, STATUS_INTEGER_DIVIDE_BY_ZERO);
genVal(STATUS_INTEGER_OVERFLOW, STATUS_INTEGER_OVERFLOW);
genVal(STATUS_IN_PAGE_ERROR, STATUS_IN_PAGE_ERROR);
genVal(STATUS_KERNEL_APC, STATUS_KERNEL_APC);
genVal(STATUS_LONGJUMP, STATUS_LONGJUMP);
genVal(STATUS_NO_CALLBACK_ACTIVE, STATUS_NO_CALLBACK_ACTIVE);
genVal(STATUS_NO_EVENT_PAIR, STATUS_NO_EVENT_PAIR);
genVal(STATUS_PRIVILEGED_INSTRUCTION, STATUS_PRIVILEGED_INSTRUCTION);
genVal(STATUS_SINGLE_STEP, STATUS_SINGLE_STEP);
genVal(STATUS_STACK_OVERFLOW, STATUS_STACK_OVERFLOW);
genVal(STATUS_SUCCESS, STATUS_SUCCESS);
genVal(STATUS_THREAD_IS_TERMINATING, STATUS_THREAD_IS_TERMINATING);
genVal(STATUS_TIMEOUT, STATUS_TIMEOUT);
genVal(STATUS_UNWIND, STATUS_UNWIND);
genVal(STATUS_WAKE_SYSTEM_DEBUGGER, STATUS_WAKE_SYSTEM_DEBUGGER);
//
// Define kernel object structure definitions.
//
// APC object structure defintions.
//
genCom("APC Object Structure Offset Definitions");
genDef(Ap, KAPC, Type);
genDef(Ap, KAPC, Size);
genDef(Ap, KAPC, Thread);
genDef(Ap, KAPC, ApcListEntry);
genDef(Ap, KAPC, KernelRoutine);
genDef(Ap, KAPC, RundownRoutine);
genDef(Ap, KAPC, NormalRoutine);
genDef(Ap, KAPC, NormalContext);
genDef(Ap, KAPC, SystemArgument1);
genDef(Ap, KAPC, SystemArgument2);
genDef(Ap, KAPC, ApcStateIndex);
genDef(Ap, KAPC, ApcMode);
genDef(Ap, KAPC, Inserted);
genVal(ApcObjectLength, sizeof(KAPC));
//
// DPC Object structure definitions.
//
EnableInc(HAL);
genCom("DPC object Structure Offset Definitions");
genDef(Dp, KDPC, Type);
genDef(Dp, KDPC, Number);
genDef(Dp, KDPC, Importance);
genDef(Dp, KDPC, DpcListEntry);
genDef(Dp, KDPC, DeferredRoutine);
genDef(Dp, KDPC, DeferredContext);
genDef(Dp, KDPC, SystemArgument1);
genDef(Dp, KDPC, SystemArgument2);
genDef(Dp, KDPC, Lock);
genVal(DpcObjectLength, sizeof(KDPC));
DisableInc(HAL);
//
// Device queue object structure definitions.
//
genCom("Device Queue Object Structure Offset Definitions");
genDef(Dv, KDEVICE_QUEUE, Type);
genDef(Dv, KDEVICE_QUEUE, Size);
genDef(Dv, KDEVICE_QUEUE, DeviceListHead);
genAlt(DvSpinLock, KDEVICE_QUEUE, Lock);
genDef(Dv, KDEVICE_QUEUE, Busy);
genVal(DeviceQueueObjectLength, sizeof(KDEVICE_QUEUE));
//
// Device object entry structure definitions.
//
genCom("Device Queue Entry Structure Offset Definitions");
genDef(De, KDEVICE_QUEUE_ENTRY, DeviceListEntry);
genDef(De, KDEVICE_QUEUE_ENTRY, SortKey);
genDef(De, KDEVICE_QUEUE_ENTRY, Inserted);
genVal(DeviceQueueEntryLength, sizeof(KDEVICE_QUEUE_ENTRY));
//
// Event object structure definitions.
//
genCom("Event Object Structure Offset Definitions");
genDef(Ev, DISPATCHER_HEADER, Type);
genDef(Ev, DISPATCHER_HEADER, Size);
genDef(Ev, DISPATCHER_HEADER, SignalState);
genAlt(EvWaitListHead, KEVENT, Header.WaitListHead);
genVal(EventObjectLength, sizeof(KEVENT));
//
// Event pair object structure definitions.
//
genCom("Event Pair Object Structure Offset Definitions");
genDef(Ep, KEVENT_PAIR, Type);
genDef(Ep, KEVENT_PAIR, Size);
genDef(Ep, KEVENT_PAIR, EventLow);
genDef(Ep, KEVENT_PAIR, EventHigh);
#if defined(_MIPS_) || defined(_PPC_)
EventOffset = OFFSET(KEVENT_PAIR, EventHigh) - OFFSET(KEVENT_PAIR, EventLow);
if ((EventOffset & (EventOffset - 1)) != 0) {
fprintf(stderr, "GENXX: Event offset not log2N\n");
}
genVal(SET_LOW_WAIT_HIGH, - (EventOffset * 2));
genVal(SET_HIGH_WAIT_LOW, - EventOffset);
genVal(SET_EVENT_PAIR_MASK, EventOffset);
#endif
//
// Interrupt object structure definitions.
//
#if defined(_ALPHA_) || defined(_MIPS_) || defined(_PPC_)
EnableInc(HAL);
#endif
genCom("Interrupt Object Structure Offset Definitions");
genVal(InLevelSensitive, LevelSensitive);
genVal(InLatched, Latched);
genSpc();
genDef(In, KINTERRUPT, Type);
genDef(In, KINTERRUPT, Size);
genDef(In, KINTERRUPT, InterruptListEntry);
genDef(In, KINTERRUPT, ServiceRoutine);
genDef(In, KINTERRUPT, ServiceContext);
genDef(In, KINTERRUPT, SpinLock);
genDef(In, KINTERRUPT, ActualLock);
genDef(In, KINTERRUPT, DispatchAddress);
genDef(In, KINTERRUPT, Vector);
genDef(In, KINTERRUPT, Irql);
genDef(In, KINTERRUPT, SynchronizeIrql);
genDef(In, KINTERRUPT, FloatingSave);
genDef(In, KINTERRUPT, Connected);
genDef(In, KINTERRUPT, Number);
genDef(In, KINTERRUPT, Mode);
genDef(In, KINTERRUPT, ShareVector);
genDef(In, KINTERRUPT, DispatchCode);
genVal(InterruptObjectLength, sizeof(KINTERRUPT));
#if defined(_X86_)
genSpc();
genVal(NORMAL_DISPATCH_LENGTH, NORMAL_DISPATCH_LENGTH * sizeof(ULONG));
genVal(DISPATCH_LENGTH, DISPATCH_LENGTH * sizeof(ULONG));
#endif
#if defined(_ALPHA_) || defined(_MIPS_) || defined(_PPC_)
DisableInc(HAL);
#endif
//
// Process object structure offset definitions.
//
genCom("Process Object Structure Offset Definitions");
genDef(Pr, DISPATCHER_HEADER, Type);
genDef(Pr, DISPATCHER_HEADER, Size);
genDef(Pr, DISPATCHER_HEADER, SignalState);
genDef(Pr, KPROCESS, ProfileListHead);
genDef(Pr, KPROCESS, DirectoryTableBase);
#if defined(_X86_)
genDef(Pr, KPROCESS, LdtDescriptor);
genDef(Pr, KPROCESS, Int21Descriptor);
genDef(Pr, KPROCESS, IopmOffset);
genDef(Pr, KPROCESS, Iopl);
genDef(Pr, KPROCESS, VdmFlag);
#endif
#if defined(_PPC_)
genDef(Pr, KPROCESS, ProcessPid);
genDef(Pr, KPROCESS, ProcessSequence);
#endif
genDef(Pr, KPROCESS, ActiveProcessors);
genDef(Pr, KPROCESS, KernelTime);
genDef(Pr, KPROCESS, UserTime);
genDef(Pr, KPROCESS, ReadyListHead);
genDef(Pr, KPROCESS, SwapListEntry);
genDef(Pr, KPROCESS, ThreadListHead);
genDef(Pr, KPROCESS, ProcessLock);
genDef(Pr, KPROCESS, Affinity);
genDef(Pr, KPROCESS, StackCount);
genDef(Pr, KPROCESS, BasePriority);
genDef(Pr, KPROCESS, ThreadQuantum);
genDef(Pr, KPROCESS, AutoAlignment);
genDef(Pr, KPROCESS, State);
genVal(ProcessObjectLength, ((sizeof(KPROCESS) + 15) & ~15));
genVal(ExtendedProcessObjectLength, ((sizeof(EPROCESS) + 15) & ~15));
//
// Profile object structure offset definitions.
//
genCom("Profile Object Structure Offset Definitions");
genDef(Pf, KPROFILE, Type);
genDef(Pf, KPROFILE, Size);
genDef(Pf, KPROFILE, ProfileListEntry);
genDef(Pf, KPROFILE, Process);
genDef(Pf, KPROFILE, RangeBase);
genDef(Pf, KPROFILE, RangeLimit);
genDef(Pf, KPROFILE, BucketShift);
genDef(Pf, KPROFILE, Buffer);
genDef(Pf, KPROFILE, Segment);
genDef(Pf, KPROFILE, Affinity);
genDef(Pf, KPROFILE, Source);
genDef(Pf, KPROFILE, Started);
genVal(ProfileObjectLength, sizeof(KPROFILE));
//
// Queue object structure offset definitions.
//
genCom("Queue Object Structure Offset Definitions");
genDef(Qu, DISPATCHER_HEADER, Type);
genDef(Qu, DISPATCHER_HEADER, Size);
genDef(Qu, DISPATCHER_HEADER, SignalState);
genDef(Qu, KQUEUE, EntryListHead);
genDef(Qu, KQUEUE, CurrentCount);
genDef(Qu, KQUEUE, MaximumCount);
genDef(Qu, KQUEUE, ThreadListHead);
genVal(QueueObjectLength, sizeof(KQUEUE));
//
// Thread object structure offset definitions
//
genCom("Thread Object Structure Offset Definitions");
genDef(Ee, EEVENT_PAIR, KernelEventPair);
genDef(Et, ETHREAD, Cid);
genDef(Et, ETHREAD, EventPair);
genDef(Et, ETHREAD, PerformanceCountLow);
genDef(Et, ETHREAD, PerformanceCountHigh);
genVal(EtEthreadLength, ((sizeof(ETHREAD) + 15) & ~15));
genSpc();
genDef(Th, DISPATCHER_HEADER, Type);
genDef(Th, DISPATCHER_HEADER, Size);
genDef(Th, DISPATCHER_HEADER, SignalState);
genDef(Th, KTHREAD, MutantListHead);
genDef(Th, KTHREAD, InitialStack);
genDef(Th, KTHREAD, StackLimit);
genDef(Th, KTHREAD, Teb);
genDef(Th, KTHREAD, TlsArray);
genDef(Th, KTHREAD, KernelStack);
genDef(Th, KTHREAD, DebugActive);
genDef(Th, KTHREAD, State);
genDef(Th, KTHREAD, Alerted);
genDef(Th, KTHREAD, Iopl);
genDef(Th, KTHREAD, NpxState);
genDef(Th, KTHREAD, Saturation);
genDef(Th, KTHREAD, Priority);
genDef(Th, KTHREAD, ApcState);
genDef(Th, KTHREAD, ContextSwitches);
genDef(Th, KTHREAD, WaitStatus);
genDef(Th, KTHREAD, WaitIrql);
genDef(Th, KTHREAD, WaitMode);
genDef(Th, KTHREAD, WaitNext);
genDef(Th, KTHREAD, WaitReason);
genDef(Th, KTHREAD, WaitBlockList);
genDef(Th, KTHREAD, WaitListEntry);
genDef(Th, KTHREAD, WaitTime);
genDef(Th, KTHREAD, BasePriority);
genDef(Th, KTHREAD, DecrementCount);
genDef(Th, KTHREAD, PriorityDecrement);
genDef(Th, KTHREAD, Quantum);
genDef(Th, KTHREAD, WaitBlock);
genDef(Th, KTHREAD, KernelApcDisable);
genDef(Th, KTHREAD, UserAffinity);
genDef(Th, KTHREAD, SystemAffinityActive);
genDef(Th, KTHREAD, ServiceTable);
// genDef(Th, KTHREAD, Channel);
// genDef(Th, KTHREAD, Section);
// genDef(Th, KTHREAD, SystemView);
// genDef(Th, KTHREAD, ThreadView);
genDef(Th, KTHREAD, Queue);
genDef(Th, KTHREAD, ApcQueueLock);
genDef(Th, KTHREAD, Timer);
genDef(Th, KTHREAD, QueueListEntry);
genDef(Th, KTHREAD, Affinity);
genDef(Th, KTHREAD, Preempted);
genDef(Th, KTHREAD, ProcessReadyQueue);
genDef(Th, KTHREAD, KernelStackResident);
genDef(Th, KTHREAD, NextProcessor);
genDef(Th, KTHREAD, CallbackStack);
genDef(Th, KTHREAD, Win32Thread);
genDef(Th, KTHREAD, TrapFrame);
genDef(Th, KTHREAD, ApcStatePointer);
genDef(Th, KTHREAD, PreviousMode);
genDef(Th, KTHREAD, EnableStackSwap);
genDef(Th, KTHREAD, LargeStack);
genDef(Th, KTHREAD, KernelTime);
genDef(Th, KTHREAD, UserTime);
genDef(Th, KTHREAD, SavedApcState);
genDef(Th, KTHREAD, Alertable);
genDef(Th, KTHREAD, ApcStateIndex);
genDef(Th, KTHREAD, ApcQueueable);
genDef(Th, KTHREAD, AutoAlignment);
genDef(Th, KTHREAD, StackBase);
genDef(Th, KTHREAD, SuspendApc);
genDef(Th, KTHREAD, SuspendSemaphore);
genDef(Th, KTHREAD, ThreadListEntry);
genDef(Th, KTHREAD, FreezeCount);
genDef(Th, KTHREAD, SuspendCount);
genDef(Th, KTHREAD, IdealProcessor);
genDef(Th, KTHREAD, DisableBoost);
genVal(ThreadObjectLength, ((sizeof(KTHREAD) + 15) & ~15));
genVal(ExtendedThreadObjectLength, ((sizeof(ETHREAD) + 15) & ~15));
genSpc();
genVal(EVENT_WAIT_BLOCK_OFFSET, OFFSET(KTHREAD, WaitBlock) + (sizeof(KWAIT_BLOCK) * EVENT_WAIT_BLOCK));
#if defined(_X86_)
genVal(NPX_STATE_NOT_LOADED, NPX_STATE_NOT_LOADED);
genVal(NPX_STATE_LOADED, NPX_STATE_LOADED);
#endif
//
// Timer object structure offset definitions
//
genCom("Timer object Structure Offset Definitions");
genDef(Ti, DISPATCHER_HEADER, Type);
genDef(Ti, DISPATCHER_HEADER, Size);
genDef(Ti, DISPATCHER_HEADER, Inserted);
genDef(Ti, DISPATCHER_HEADER, SignalState);
genDef(Ti, KTIMER, DueTime);
genDef(Ti, KTIMER, TimerListEntry);
genDef(Ti, KTIMER, Dpc);
genDef(Ti, KTIMER, Period);
genVal(TimerObjectLength, sizeof(KTIMER));
genSpc();
genVal(TIMER_TABLE_SIZE, TIMER_TABLE_SIZE);
//
// Wait block structure offset definitions
//
genCom("Wait Block Structure Offset Definitions");
genDef(Wb, KWAIT_BLOCK, WaitListEntry);
genDef(Wb, KWAIT_BLOCK, Thread);
genDef(Wb, KWAIT_BLOCK, Object);
genDef(Wb, KWAIT_BLOCK, NextWaitBlock);
genDef(Wb, KWAIT_BLOCK, WaitKey);
genDef(Wb, KWAIT_BLOCK, WaitType);
//
// Fiber structure offset definitions.
//
genCom("Fiber Structure Offset Definitions");
genDef(Fb, FIBER, FiberData);
genDef(Fb, FIBER, ExceptionList);
genDef(Fb, FIBER, StackBase);
genDef(Fb, FIBER, StackLimit);
genDef(Fb, FIBER, DeallocationStack);
genDef(Fb, FIBER, FiberContext);
//
// Process environment block structure offset definitions.
//
genCom("Process Environment Block Structure Offset Definitions");
genDef(Pe, PEB, KernelCallbackTable);
//
// Define System Service Descriptor Table structures.
//
genCom("System Service Descriptor Table Structure Definitions");
genVal(NUMBER_SERVICE_TABLES, NUMBER_SERVICE_TABLES);
genVal(SERVICE_NUMBER_MASK, SERVICE_NUMBER_MASK);
genVal(SERVICE_TABLE_SHIFT, SERVICE_TABLE_SHIFT);
genVal(SERVICE_TABLE_MASK, SERVICE_TABLE_MASK);
genVal(SERVICE_TABLE_TEST, SERVICE_TABLE_TEST);
genSpc();
genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Base);
genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Count);
genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Limit);
genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Number);
//
// Common TEB structure offset definitions
//
genCom("Thread Environment Block Structure Offset Definitions");
genDef(Te, NT_TIB, StackBase);
genDef(Te, NT_TIB, StackLimit);
genDef(Te, NT_TIB, FiberData);
genDef(Te, TEB, EnvironmentPointer);
genDef(Te, TEB, ClientId);
genDef(Te, TEB, ActiveRpcHandle);
genDef(Te, TEB, ThreadLocalStoragePointer);
genAlt(TePeb, TEB, ProcessEnvironmentBlock);
genDef(Te, TEB, CsrClientThread);
genAlt(TeSoftFpcr, TEB, FpSoftwareStatusRegister);
genDef(Te, TEB, GdiClientPID);
genDef(Te, TEB, GdiClientTID);
genDef(Te, TEB, GdiThreadLocalInfo);
genDef(Te, TEB, glDispatchTable);
genDef(Te, TEB, glSectionInfo);
genDef(Te, TEB, glSection);
genDef(Te, TEB, glTable);
genDef(Te, TEB, glCurrentRC);
genDef(Te, TEB, glContext);
genDef(Te, TEB, DeallocationStack);
genDef(Te, TEB, GdiBatchCount);
genDef(Te, TEB, Instrumentation);
Reference in New Issue Copy Permalink