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