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