reactos/ntoskrnl/include/internal/ntoskrnl.h

   1 #ifndef __INCLUDE_INTERNAL_NTOSKRNL_H
   2 #define __INCLUDE_INTERNAL_NTOSKRNL_H
   3
   4 /*
   5  * Use these to place a function in a specific section of the executable
   6  */
   7 #define PLACE_IN_SECTION(s)     __attribute__((section (s)))
   8 #ifdef __GNUC__
   9 #define INIT_FUNCTION           PLACE_IN_SECTION("init")
  10 #define PAGE_LOCKED_FUNCTION    PLACE_IN_SECTION("pagelk")
  11 #define PAGE_UNLOCKED_FUNCTION  PLACE_IN_SECTION("pagepo")
  12 #else
  13 #define INIT_FUNCTION
  14 #define PAGE_LOCKED_FUNCTION
  15 #define PAGE_UNLOCKED_FUNCTION
  16 #endif
  17
  18 #ifdef _NTOSKRNL_
  19
  20 #ifndef _ARM_
  21 #define KeGetCurrentThread  _KeGetCurrentThread
  22 #define KeGetPreviousMode   _KeGetPreviousMode
  23 #endif
  24 #undef  PsGetCurrentProcess
  25 #define PsGetCurrentProcess _PsGetCurrentProcess
  26
  27 //
  28 // We are very lazy on ARM -- we just import intrinsics
  29 // Question: Why wasn't this done for x86 too? (see fastintrlck.asm)
  30 //
  31 #define InterlockedDecrement        _InterlockedDecrement
  32 #define InterlockedIncrement        _InterlockedIncrement
  33 #define InterlockedCompareExchange  (LONG)_InterlockedCompareExchange
  34 #define InterlockedExchange         _InterlockedExchange
  35 #define InterlockedExchangeAdd      _InterlockedExchangeAdd
  36
  37 #include "ke.h"
  38 #include "i386/mm.h"
  39 #include "i386/fpu.h"
  40 #include "i386/v86m.h"
  41 #include "ob.h"
  42 #include "mm.h"
  43 #include "ex.h"
  44 #include "cm.h"
  45 #include "ps.h"
  46 #include "cc.h"
  47 #include "io.h"
  48 #include "po.h"
  49 #include "se.h"
  50 #include "ldr.h"
  51 #ifndef _WINKD_
  52 #include "kd.h"
  53 #else
  54 #include "kd64.h"
  55 #endif
  56 #include "fsrtl.h"
  57 #include "lpc.h"
  58 #include "rtl.h"
  59 #ifdef KDBG
  60 #include "../kdbg/kdb.h"
  61 #endif
  62 #include "dbgk.h"
  63 #include "tag.h"
  64 #include "test.h"
  65 #include "inbv.h"
  66 #include "vdm.h"
  67 #include "hal.h"
  68 #include "arch/intrin_i.h"
  69
  70 #include <pshpack1.h>
  71 /*
  72  * Defines a descriptor as it appears in the processor tables
  73  */
  74 typedef struct __DESCRIPTOR
  75 {
  76   ULONG a;
  77   ULONG b;
  78 } IDT_DESCRIPTOR, GDT_DESCRIPTOR;
  79
  80 #include <poppack.h>
  81 //extern GDT_DESCRIPTOR KiGdt[256];
  82
  83 /*
  84  * Initalization functions (called once by main())
  85  */
  86 BOOLEAN NTAPI ObInit(VOID);
  87 BOOLEAN NTAPI CmInitSystem1(VOID);
  88 VOID NTAPI CmShutdownSystem(VOID);
  89 BOOLEAN NTAPI KdInitSystem(ULONG Reserved, PLOADER_PARAMETER_BLOCK LoaderBlock);
  90
  91 /* FIXME - RtlpCreateUnicodeString is obsolete and should be removed ASAP! */
  92 BOOLEAN FASTCALL
  93 RtlpCreateUnicodeString(
  94    IN OUT PUNICODE_STRING UniDest,
  95    IN PCWSTR  Source,
  96    IN POOL_TYPE PoolType);
  97
  98 VOID
  99 NTAPI
 100 RtlpLogException(IN PEXCEPTION_RECORD ExceptionRecord,
 101                  IN PCONTEXT ContextRecord,
 102                  IN PVOID ContextData,
 103                  IN ULONG Size);
 104
 105 /*
 106  * generic information class probing code
 107  */
 108
 109 #define ICIF_QUERY               0x1
 110 #define ICIF_SET                 0x2
 111 #define ICIF_QUERY_SIZE_VARIABLE 0x4
 112 #define ICIF_SET_SIZE_VARIABLE   0x8
 113 #define ICIF_SIZE_VARIABLE (ICIF_QUERY_SIZE_VARIABLE | ICIF_SET_SIZE_VARIABLE)
 114
 115 typedef struct _INFORMATION_CLASS_INFO
 116 {
 117   ULONG RequiredSizeQUERY;
 118   ULONG RequiredSizeSET;
 119   ULONG AlignmentSET;
 120   ULONG AlignmentQUERY;
 121   ULONG Flags;
 122 } INFORMATION_CLASS_INFO, *PINFORMATION_CLASS_INFO;
 123
 124 #define ICI_SQ_SAME(Type, Alignment, Flags)                                    \
 125   { Type, Type, Alignment, Alignment, Flags }
 126
 127 #define ICI_SQ(TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags)        \
 128   { TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags }
 129
 130 //
 131 // TEMPORARY
 132 //
 133 #define IQS_SAME(Type, Alignment, Flags)                                    \
 134   { sizeof(Type), sizeof(Type), sizeof(Alignment), sizeof(Alignment), Flags }
 135
 136 #define IQS(TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags)        \
 137   { sizeof(TypeQuery), sizeof(TypeSet), sizeof(AlignmentQuery), sizeof(AlignmentSet), Flags }
 138
 139 FORCEINLINE
 140 NTSTATUS
 141 DefaultSetInfoBufferCheck(ULONG Class,
 142                           const INFORMATION_CLASS_INFO *ClassList,
 143                           ULONG ClassListEntries,
 144                           PVOID Buffer,
 145                           ULONG BufferLength,
 146                           KPROCESSOR_MODE PreviousMode)
 147 {
 148     NTSTATUS Status = STATUS_SUCCESS;
 149
 150     if (Class < ClassListEntries)
 151     {
 152         if (!(ClassList[Class].Flags & ICIF_SET))
 153         {
 154             Status = STATUS_INVALID_INFO_CLASS;
 155         }
 156         else if (ClassList[Class].RequiredSizeSET > 0 &&
 157                  BufferLength != ClassList[Class].RequiredSizeSET)
 158         {
 159             if (!(ClassList[Class].Flags & ICIF_SET_SIZE_VARIABLE))
 160             {
 161                 Status = STATUS_INFO_LENGTH_MISMATCH;
 162             }
 163         }
 164
 165         if (NT_SUCCESS(Status))
 166         {
 167             if (PreviousMode != KernelMode)
 168             {
 169                 _SEH_TRY
 170                 {
 171                     ProbeForRead(Buffer,
 172                                  BufferLength,
 173                                  ClassList[Class].AlignmentSET);
 174                 }
 175                 _SEH_HANDLE
 176                 {
 177                     Status = _SEH_GetExceptionCode();
 178                 }
 179                 _SEH_END;
 180             }
 181         }
 182     }
 183     else
 184         Status = STATUS_INVALID_INFO_CLASS;
 185
 186     return Status;
 187 }
 188
 189 FORCEINLINE
 190 NTSTATUS
 191 DefaultQueryInfoBufferCheck(ULONG Class,
 192                             const INFORMATION_CLASS_INFO *ClassList,
 193                             ULONG ClassListEntries,
 194                             PVOID Buffer,
 195                             ULONG BufferLength,
 196                             PULONG ReturnLength,
 197                             KPROCESSOR_MODE PreviousMode)
 198 {
 199     NTSTATUS Status = STATUS_SUCCESS;
 200
 201     if (Class < ClassListEntries)
 202     {
 203         if (!(ClassList[Class].Flags & ICIF_QUERY))
 204         {
 205             Status = STATUS_INVALID_INFO_CLASS;
 206         }
 207         else if (ClassList[Class].RequiredSizeQUERY > 0 &&
 208                  BufferLength != ClassList[Class].RequiredSizeQUERY)
 209         {
 210             if (!(ClassList[Class].Flags & ICIF_QUERY_SIZE_VARIABLE))
 211             {
 212                 Status = STATUS_INFO_LENGTH_MISMATCH;
 213             }
 214         }
 215
 216         if (NT_SUCCESS(Status))
 217         {
 218             if (PreviousMode != KernelMode)
 219             {
 220                 _SEH_TRY
 221                 {
 222                     if (Buffer != NULL)
 223                     {
 224                         ProbeForWrite(Buffer,
 225                                       BufferLength,
 226                                       ClassList[Class].AlignmentQUERY);
 227                     }
 228
 229                     if (ReturnLength != NULL)
 230                     {
 231                         ProbeForWriteUlong(ReturnLength);
 232                     }
 233                 }
 234                 _SEH_HANDLE
 235                 {
 236                     Status = _SEH_GetExceptionCode();
 237                 }
 238                 _SEH_END;
 239             }
 240         }
 241     }
 242     else
 243         Status = STATUS_INVALID_INFO_CLASS;
 244
 245     return Status;
 246 }
 247
 248 /*
 249  * Use IsPointerOffset to test whether a pointer should be interpreted as an offset
 250  * or as a pointer
 251  */
 252 #if defined(_X86_) || defined(_M_AMD64) || defined(_MIPS_) || defined(_PPC_) || defined(_ARM_)
 253
 254 /* for x86 and x86-64 the MSB is 1 so we can simply test on that */
 255 #define IsPointerOffset(Ptr) ((LONG_PTR)(Ptr) >= 0)
 256
 257 #elif defined(_IA64_)
 258
 259 /* on Itanium if the 24 most significant bits are set, we're not dealing with
 260    offsets anymore. */
 261 #define IsPointerOffset(Ptr)  (((ULONG_PTR)(Ptr) & 0xFFFFFF0000000000ULL) == 0)
 262
 263 #else
 264 #error IsPointerOffset() needs to be defined for this architecture
 265 #endif
 266
 267 #endif
 268
 269 #ifndef _WIN64
 270 C_ASSERT(FIELD_OFFSET(KUSER_SHARED_DATA, SystemCall) == 0x300);
 271 C_ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
 272 C_ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
 273 C_ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
 274 C_ASSERT(FIELD_OFFSET(KTHREAD, NpxState) == KTHREAD_NPX_STATE);
 275 C_ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
 276 C_ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
 277 C_ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
 278 C_ASSERT(FIELD_OFFSET(KTHREAD, CallbackStack) == KTHREAD_CALLBACK_STACK);
 279 C_ASSERT(FIELD_OFFSET(KTHREAD, ApcState.Process) == KTHREAD_APCSTATE_PROCESS);
 280 C_ASSERT(FIELD_OFFSET(KPROCESS, DirectoryTableBase) == KPROCESS_DIRECTORY_TABLE_BASE);
 281 //C_ASSERT(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST);
 282 //C_ASSERT(FIELD_OFFSET(KPCR, Self) == KPCR_SELF);
 283 #endif
 284
 285 #ifdef _M_IX86
 286 C_ASSERT(FIELD_OFFSET(KPCR, IRR) == KPCR_IRR);
 287 C_ASSERT(FIELD_OFFSET(KPCR, IDR) == KPCR_IDR);
 288 C_ASSERT(FIELD_OFFSET(KPCR, Irql) == KPCR_IRQL);
 289 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
 290 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NextThread) == KPCR_PRCB_NEXT_THREAD);
 291 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NpxThread) == KPCR_NPX_THREAD);
 292 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) == KPCR_PRCB_DATA);
 293 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, KeSystemCalls) == KPCR_SYSTEM_CALLS);
 294 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcData) + /*FIELD_OFFSET(KDPC_DATA, DpcQueuDepth)*/12 == KPCR_PRCB_DPC_QUEUE_DEPTH);
 295 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcData) + 16 == KPCR_PRCB_DPC_COUNT);
 296 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcStack) == KPCR_PRCB_DPC_STACK);
 297 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, TimerRequest) == KPCR_PRCB_TIMER_REQUEST);
 298 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, MaximumDpcQueueDepth) == KPCR_PRCB_MAXIMUM_DPC_QUEUE_DEPTH);
 299 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcRequestRate) == KPCR_PRCB_DPC_REQUEST_RATE);
 300 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcInterruptRequested) == KPCR_PRCB_DPC_INTERRUPT_REQUESTED);
 301 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcRoutineActive) == KPCR_PRCB_DPC_ROUTINE_ACTIVE);
 302 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcLastCount) == KPCR_PRCB_DPC_LAST_COUNT);
 303 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, TimerRequest) == KPCR_PRCB_TIMER_REQUEST);
 304 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, QuantumEnd) == KPCR_PRCB_QUANTUM_END);
 305 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DeferredReadyListHead) == KPCR_PRCB_DEFERRED_READY_LIST_HEAD);
 306 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, PowerState) == KPCR_PRCB_POWER_STATE_IDLE_FUNCTION);
 307 //C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, PrcbLock) == KPCR_PRCB_PRCB_LOCK);
 308 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcStack) == KPCR_PRCB_DPC_STACK);
 309 C_ASSERT(sizeof(FX_SAVE_AREA) == SIZEOF_FX_SAVE_AREA);
 310
 311 /* Platform specific checks */
 312 C_ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
 313 C_ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
 314 C_ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, SavedExceptionStack) == TF_SAVED_EXCEPTION_STACK);
 315 C_ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS);
 316 C_ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP);
 317 C_ASSERT(FIELD_OFFSET(KTSS, Esp0) == KTSS_ESP0);
 318 C_ASSERT(FIELD_OFFSET(KTSS, IoMapBase) == KTSS_IOMAPBASE);
 319 #endif
 320
 321 #endif /* INCLUDE_INTERNAL_NTOSKRNL_H */