ntoskrnl/include/internal/ntoskrnl.h

   1 #pragma once
   2
   3 #include <section_attribs.h>
   4
   5
   6
   7 #ifdef _NTOSKRNL_
   8
   9 #ifndef _ARM_
  10 #define KeGetCurrentThread  _KeGetCurrentThread
  11 #define KeGetPreviousMode   _KeGetPreviousMode
  12 #endif
  13 #undef  PsGetCurrentProcess
  14 #define PsGetCurrentProcess _PsGetCurrentProcess
  15
  16 #define RVA(m, b) ((PVOID)((ULONG_PTR)(b) + (ULONG_PTR)(m)))
  17
  18 //
  19 // We are very lazy on ARM -- we just import intrinsics
  20 // Question: Why wasn't this done for x86 too? (see fastintrlck.asm)
  21 //
  22 #define InterlockedDecrement         _InterlockedDecrement
  23 #define InterlockedDecrement16       _InterlockedDecrement16
  24 #define InterlockedIncrement         _InterlockedIncrement
  25 #define InterlockedIncrement16       _InterlockedIncrement16
  26 #define InterlockedCompareExchange   _InterlockedCompareExchange
  27 #define InterlockedCompareExchange16 _InterlockedCompareExchange16
  28 #define InterlockedCompareExchange64 _InterlockedCompareExchange64
  29 #define InterlockedExchange          _InterlockedExchange
  30 #define InterlockedExchangeAdd       _InterlockedExchangeAdd
  31 #define InterlockedOr                _InterlockedOr
  32 #define InterlockedAnd               _InterlockedAnd
  33
  34 //
  35 // Use inlined versions of fast/guarded mutex routines
  36 //
  37 #define ExEnterCriticalRegionAndAcquireFastMutexUnsafe _ExEnterCriticalRegionAndAcquireFastMutexUnsafe
  38 #define ExReleaseFastMutexUnsafeAndLeaveCriticalRegion _ExReleaseFastMutexUnsafeAndLeaveCriticalRegion
  39 #define ExAcquireFastMutex _ExAcquireFastMutex
  40 #define ExReleaseFastMutex _ExReleaseFastMutex
  41 #define ExAcquireFastMutexUnsafe _ExAcquireFastMutexUnsafe
  42 #define ExReleaseFastMutexUnsafe _ExReleaseFastMutexUnsafe
  43 #define ExTryToAcquireFastMutex _ExTryToAcquireFastMutex
  44
  45 #define KeInitializeGuardedMutex _KeInitializeGuardedMutex
  46 #define KeAcquireGuardedMutex _KeAcquireGuardedMutex
  47 #define KeReleaseGuardedMutex _KeReleaseGuardedMutex
  48 #define KeAcquireGuardedMutexUnsafe _KeAcquireGuardedMutexUnsafe
  49 #define KeReleaseGuardedMutexUnsafe _KeReleaseGuardedMutexUnsafe
  50 #define KeTryToAcquireGuardedMutex _KeTryToAcquireGuardedMutex
  51
  52 #include "tag.h"
  53 #include "ke.h"
  54 #include "ob.h"
  55 #include "mm.h"
  56 #include "ex.h"
  57 #include "cm.h"
  58 #include "ps.h"
  59 #include "cc.h"
  60 #include "io.h"
  61 #include "po.h"
  62 #include "se.h"
  63 #include "ldr.h"
  64 #ifndef _WINKD_
  65 #include "kd.h"
  66 #else
  67 #include "kd64.h"
  68 #endif
  69 #include "fsrtl.h"
  70 #include "lpc.h"
  71 #include "rtl.h"
  72 #ifdef KDBG
  73 #include <kdbg/kdb.h>
  74 #endif
  75 #include "dbgk.h"
  76 #include "spinlock.h"
  77 #include "test.h"
  78 #include "inbv.h"
  79 #include "vdm.h"
  80 #include "hal.h"
  81 #include "hdl.h"
  82 #include "arch/intrin_i.h"
  83
  84 /*
  85  * generic information class probing code
  86  */
  87
  88 #define ICIF_QUERY               0x1
  89 #define ICIF_SET                 0x2
  90 #define ICIF_QUERY_SIZE_VARIABLE 0x4
  91 #define ICIF_SET_SIZE_VARIABLE   0x8
  92 #define ICIF_SIZE_VARIABLE (ICIF_QUERY_SIZE_VARIABLE | ICIF_SET_SIZE_VARIABLE)
  93
  94 typedef struct _INFORMATION_CLASS_INFO
  95 {
  96   ULONG RequiredSizeQUERY;
  97   ULONG RequiredSizeSET;
  98   ULONG AlignmentSET;
  99   ULONG AlignmentQUERY;
 100   ULONG Flags;
 101 } INFORMATION_CLASS_INFO, *PINFORMATION_CLASS_INFO;
 102
 103 #define ICI_SQ_SAME(Type, Alignment, Flags)                                    \
 104   { Type, Type, Alignment, Alignment, Flags }
 105
 106 #define ICI_SQ(TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags)        \
 107   { TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags }
 108
 109 //
 110 // TEMPORARY
 111 //
 112 #define IQS_SAME(Type, Alignment, Flags)                                    \
 113   { sizeof(Type), sizeof(Type), sizeof(Alignment), sizeof(Alignment), Flags }
 114
 115 #define IQS(TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags)        \
 116   { sizeof(TypeQuery), sizeof(TypeSet), sizeof(AlignmentQuery), sizeof(AlignmentSet), Flags }
 117
 118 /*
 119  * Use IsPointerOffset to test whether a pointer should be interpreted as an offset
 120  * or as a pointer
 121  */
 122 #if defined(_X86_) || defined(_M_AMD64) || defined(_MIPS_) || defined(_PPC_) || defined(_ARM_)
 123
 124 /* for x86 and x86-64 the MSB is 1 so we can simply test on that */
 125 #define IsPointerOffset(Ptr) ((LONG_PTR)(Ptr) >= 0)
 126
 127 #elif defined(_IA64_)
 128
 129 /* on Itanium if the 24 most significant bits are set, we're not dealing with
 130    offsets anymore. */
 131 #define IsPointerOffset(Ptr)  (((ULONG_PTR)(Ptr) & 0xFFFFFF0000000000ULL) == 0)
 132
 133 #else
 134 #error IsPointerOffset() needs to be defined for this architecture
 135 #endif
 136
 137 #endif
 138
 139 #ifndef _WIN64
 140 C_ASSERT(FIELD_OFFSET(KUSER_SHARED_DATA, SystemCall) == 0x300);
 141
 142 C_ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
 143 C_ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
 144 C_ASSERT(FIELD_OFFSET(KTHREAD, SystemAffinityActive) == FIELD_OFFSET(KTHREAD, WaitBlock) + FIELD_OFFSET(KWAIT_BLOCK, SpareByte));
 145 C_ASSERT(FIELD_OFFSET(KTHREAD, ApcState.Process) == KTHREAD_APCSTATE_PROCESS);
 146 C_ASSERT(FIELD_OFFSET(KTHREAD, ApcQueueable) == FIELD_OFFSET(KTHREAD, ApcState.UserApcPending) + 1);
 147 C_ASSERT(FIELD_OFFSET(KTHREAD, ApcQueueable) == 0x3F);
 148 C_ASSERT(FIELD_OFFSET(KTHREAD, NextProcessor) == 0x40);
 149 C_ASSERT(FIELD_OFFSET(KTHREAD, DeferredProcessor) == 0x41);
 150 C_ASSERT(FIELD_OFFSET(KTHREAD, AdjustReason) == 0x42);
 151 C_ASSERT(FIELD_OFFSET(KTHREAD, NpxState) == KTHREAD_NPX_STATE);
 152 C_ASSERT(FIELD_OFFSET(KTHREAD, Alertable) == 0x58);
 153 C_ASSERT(FIELD_OFFSET(KTHREAD, SwapBusy) == 0x05D);
 154 C_ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
 155 C_ASSERT(FIELD_OFFSET(KTHREAD, Timer) == 0x078);
 156 C_ASSERT(FIELD_OFFSET(KTHREAD, ThreadFlags) == 0x0A0);
 157 C_ASSERT(FIELD_OFFSET(KTHREAD, WaitBlock) == 0x0A8);
 158 C_ASSERT(FIELD_OFFSET(KTHREAD, WaitBlockFill0) == 0x0A8);
 159 C_ASSERT(FIELD_OFFSET(KTHREAD, QueueListEntry) == 0x108);
 160 C_ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
 161 C_ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == FIELD_OFFSET(KTHREAD, WaitBlock) + sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK, SpareByte));
 162 C_ASSERT(FIELD_OFFSET(KTHREAD, ResourceIndex) == FIELD_OFFSET(KTHREAD, WaitBlock) + 2*sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK, SpareByte));
 163 C_ASSERT(FIELD_OFFSET(KTHREAD, LargeStack) == FIELD_OFFSET(KTHREAD, WaitBlock) + 3*sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK, SpareByte));
 164 C_ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
 165 C_ASSERT(FIELD_OFFSET(KTHREAD, CallbackStack) == KTHREAD_CALLBACK_STACK);
 166 C_ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
 167 C_ASSERT(FIELD_OFFSET(KTHREAD, FreezeCount) == FIELD_OFFSET(KTHREAD, SavedApcState.UserApcPending) + 1);
 168 C_ASSERT(FIELD_OFFSET(KTHREAD, Quantum) == FIELD_OFFSET(KTHREAD, SuspendApc.SpareByte0));
 169 C_ASSERT(FIELD_OFFSET(KTHREAD, QuantumReset) == FIELD_OFFSET(KTHREAD, SuspendApc.SpareByte1));
 170 C_ASSERT(FIELD_OFFSET(KTHREAD, KernelTime) == FIELD_OFFSET(KTHREAD, SuspendApc.SpareLong0));
 171 C_ASSERT(FIELD_OFFSET(KTHREAD, TlsArray) == FIELD_OFFSET(KTHREAD, SuspendApc.SystemArgument1));
 172 C_ASSERT(FIELD_OFFSET(KTHREAD, LegoData) == FIELD_OFFSET(KTHREAD, SuspendApc.SystemArgument2));
 173 C_ASSERT(FIELD_OFFSET(KTHREAD, PowerState) == FIELD_OFFSET(KTHREAD, SuspendApc.Inserted) + 1);
 174 C_ASSERT(sizeof(KTHREAD) == 0x1B8);
 175
 176 C_ASSERT(FIELD_OFFSET(KPROCESS, DirectoryTableBase) == KPROCESS_DIRECTORY_TABLE_BASE);
 177
 178 C_ASSERT(FIELD_OFFSET(KPCR, NtTib.ExceptionList) == KPCR_EXCEPTION_LIST);
 179 C_ASSERT(FIELD_OFFSET(KPCR, SelfPcr) == KPCR_SELF);
 180 C_ASSERT(FIELD_OFFSET(KPCR, IRR) == KPCR_IRR);
 181 C_ASSERT(FIELD_OFFSET(KPCR, IDR) == KPCR_IDR);
 182 C_ASSERT(FIELD_OFFSET(KPCR, Irql) == KPCR_IRQL);
 183 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
 184 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NextThread) == KPCR_PRCB_NEXT_THREAD);
 185 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NpxThread) == KPCR_NPX_THREAD);
 186 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) == KPCR_PRCB_DATA);
 187 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, KeSystemCalls) == KPCR_SYSTEM_CALLS);
 188 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcData) + FIELD_OFFSET(KDPC_DATA, DpcQueueDepth) == KPCR_PRCB_DPC_QUEUE_DEPTH);
 189 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcData) + 16 == KPCR_PRCB_DPC_COUNT);
 190 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcStack) == KPCR_PRCB_DPC_STACK);
 191 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, TimerRequest) == KPCR_PRCB_TIMER_REQUEST);
 192 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, MaximumDpcQueueDepth) == KPCR_PRCB_MAXIMUM_DPC_QUEUE_DEPTH);
 193 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcRequestRate) == KPCR_PRCB_DPC_REQUEST_RATE);
 194 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcInterruptRequested) == KPCR_PRCB_DPC_INTERRUPT_REQUESTED);
 195 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcRoutineActive) == KPCR_PRCB_DPC_ROUTINE_ACTIVE);
 196 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcLastCount) == KPCR_PRCB_DPC_LAST_COUNT);
 197 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, TimerRequest) == KPCR_PRCB_TIMER_REQUEST);
 198 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, QuantumEnd) == KPCR_PRCB_QUANTUM_END);
 199 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DeferredReadyListHead) == KPCR_PRCB_DEFERRED_READY_LIST_HEAD);
 200 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, PowerState) == KPCR_PRCB_POWER_STATE_IDLE_FUNCTION);
 201 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, PrcbLock) == KPCR_PRCB_PRCB_LOCK);
 202 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcStack) == KPCR_PRCB_DPC_STACK);
 203 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, IdleSchedule) == KPCR_PRCB_IDLE_SCHEDULE);
 204 C_ASSERT(sizeof(FX_SAVE_AREA) == SIZEOF_FX_SAVE_AREA);
 205
 206 /* Platform specific checks */
 207 C_ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
 208 C_ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
 209 C_ASSERT(FIELD_OFFSET(KTSS, Esp0) == KTSS_ESP0);
 210 C_ASSERT(FIELD_OFFSET(KTSS, IoMapBase) == KTSS_IOMAPBASE);
 211 #endif