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