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