* Use these to place a function in a specific section of the executable
*/
#define PLACE_IN_SECTION(s) __attribute__((section (s)))
-#define INIT_FUNCTION PLACE_IN_SECTION("init")
+#ifdef __GNUC__
+#define INIT_FUNCTION PLACE_IN_SECTION("INIT")
#define PAGE_LOCKED_FUNCTION PLACE_IN_SECTION("pagelk")
#define PAGE_UNLOCKED_FUNCTION PLACE_IN_SECTION("pagepo")
+#else
+#define INIT_FUNCTION
+#define PAGE_LOCKED_FUNCTION
+#define PAGE_UNLOCKED_FUNCTION
+#endif
#ifdef _NTOSKRNL_
+#ifndef _ARM_
+#define KeGetCurrentThread _KeGetCurrentThread
+#define KeGetPreviousMode _KeGetPreviousMode
+#endif
+#undef PsGetCurrentProcess
+#define PsGetCurrentProcess _PsGetCurrentProcess
+
+//
+// We are very lazy on ARM -- we just import intrinsics
+// Question: Why wasn't this done for x86 too? (see fastintrlck.asm)
+//
+#define InterlockedDecrement _InterlockedDecrement
+#define InterlockedDecrement16 _InterlockedDecrement16
+#define InterlockedIncrement _InterlockedIncrement
+#define InterlockedIncrement16 _InterlockedIncrement16
+#define InterlockedCompareExchange _InterlockedCompareExchange
+#define InterlockedCompareExchange16 _InterlockedCompareExchange16
+#define InterlockedCompareExchange64 _InterlockedCompareExchange64
+#define InterlockedExchange _InterlockedExchange
+#define InterlockedExchangeAdd _InterlockedExchangeAdd
+#define InterlockedOr _InterlockedOr
+#define InterlockedAnd _InterlockedAnd
+
#include "ke.h"
-#include "i386/mm.h"
-#include "i386/fpu.h"
#include "ob.h"
#include "mm.h"
+#include "ex.h"
+#include "cm.h"
#include "ps.h"
#include "cc.h"
#include "io.h"
#include "po.h"
#include "se.h"
#include "ldr.h"
+#ifndef _WINKD_
#include "kd.h"
-#include "ex.h"
+#else
+#include "kd64.h"
+#endif
#include "fsrtl.h"
#include "lpc.h"
#include "rtl.h"
#include "tag.h"
#include "test.h"
#include "inbv.h"
+#include "vdm.h"
+#include "hal.h"
+#include "arch/intrin_i.h"
+
+ULONG (*FrLdrDbgPrint)(const char *Format, ...);
#include <pshpack1.h>
/*
} IDT_DESCRIPTOR, GDT_DESCRIPTOR;
#include <poppack.h>
-
-extern IDT_DESCRIPTOR KiIdt[256];
//extern GDT_DESCRIPTOR KiGdt[256];
/*
* Initalization functions (called once by main())
*/
-VOID MmInitSystem(ULONG Phase, PLOADER_PARAMETER_BLOCK LoaderBlock, ULONG LastKernelAddress);
-VOID IoInit(VOID);
-VOID IoInit2(BOOLEAN BootLog);
-VOID STDCALL IoInit3(VOID);
-VOID ObInit(VOID);
-VOID PsInit(VOID);
-VOID CmInitializeRegistry(VOID);
-VOID STDCALL CmInitHives(BOOLEAN SetupBoot);
-VOID CmInit2(PCHAR CommandLine);
-VOID CmShutdownRegistry(VOID);
-BOOLEAN CmImportSystemHive(PCHAR ChunkBase, ULONG ChunkSize);
-BOOLEAN CmImportHardwareHive(PCHAR ChunkBase, ULONG ChunkSize);
-VOID KdInitSystem(ULONG Reserved, PLOADER_PARAMETER_BLOCK LoaderBlock);
+BOOLEAN NTAPI ObInit(VOID);
+BOOLEAN NTAPI CmInitSystem1(VOID);
+VOID NTAPI CmShutdownSystem(VOID);
+BOOLEAN NTAPI KdInitSystem(ULONG Reserved, PLOADER_PARAMETER_BLOCK LoaderBlock);
/* FIXME - RtlpCreateUnicodeString is obsolete and should be removed ASAP! */
BOOLEAN FASTCALL
IN PVOID ContextData,
IN ULONG Size);
-#define ExRaiseStatus RtlRaiseStatus
-
-static const UNICODE_STRING __emptyUnicodeString = {0};
-static const LARGE_INTEGER __emptyLargeInteger = {{0, 0}};
-static const ULARGE_INTEGER __emptyULargeInteger = {{0, 0}};
-
-/*
- * NOTE: Alignment of the pointers is not verified!
- */
-#define ProbeForWriteGenericType(Ptr, Type) \
- do { \
- if ((ULONG_PTR)(Ptr) + sizeof(Type) - 1 < (ULONG_PTR)(Ptr) || \
- (ULONG_PTR)(Ptr) + sizeof(Type) - 1 >= (ULONG_PTR)MmUserProbeAddress) { \
- RtlRaiseStatus (STATUS_ACCESS_VIOLATION); \
- } \
- *(volatile Type *)(Ptr) = *(volatile Type *)(Ptr); \
- } while (0)
-
-#define ProbeForWriteBoolean(Ptr) ProbeForWriteGenericType(Ptr, BOOLEAN)
-#define ProbeForWriteUchar(Ptr) ProbeForWriteGenericType(Ptr, UCHAR)
-#define ProbeForWriteChar(Ptr) ProbeForWriteGenericType(Ptr, Char)
-#define ProbeForWriteUshort(Ptr) ProbeForWriteGenericType(Ptr, USHORT)
-#define ProbeForWriteShort(Ptr) ProbeForWriteGenericType(Ptr, SHORT)
-#define ProbeForWriteUlong(Ptr) ProbeForWriteGenericType(Ptr, ULONG)
-#define ProbeForWriteLong(Ptr) ProbeForWriteGenericType(Ptr, LONG)
-#define ProbeForWriteUint(Ptr) ProbeForWriteGenericType(Ptr, UINT)
-#define ProbeForWriteInt(Ptr) ProbeForWriteGenericType(Ptr, INT)
-#define ProbeForWriteUlonglong(Ptr) ProbeForWriteGenericType(Ptr, ULONGLONG)
-#define ProbeForWriteLonglong(Ptr) ProbeForWriteGenericType(Ptr, LONGLONG)
-#define ProbeForWriteLonglong(Ptr) ProbeForWriteGenericType(Ptr, LONGLONG)
-#define ProbeForWritePointer(Ptr) ProbeForWriteGenericType(Ptr, PVOID)
-#define ProbeForWriteHandle(Ptr) ProbeForWriteGenericType(Ptr, HANDLE)
-#define ProbeForWriteLangid(Ptr) ProbeForWriteGenericType(Ptr, LANGID)
-#define ProbeForWriteLargeInteger(Ptr) ProbeForWriteGenericType(&(Ptr)->QuadPart, LONGLONG)
-#define ProbeForWriteUlargeInteger(Ptr) ProbeForWriteGenericType(&(Ptr)->QuadPart, ULONGLONG)
-#define ProbeForWriteUnicodeString(Ptr) ProbeForWriteGenericType(Ptr, UNICODE_STRING)
-
-#define ProbeForReadGenericType(Ptr, Type, Default) \
- (((ULONG_PTR)(Ptr) + sizeof(Type) - 1 < (ULONG_PTR)(Ptr) || \
- (ULONG_PTR)(Ptr) + sizeof(Type) - 1 >= (ULONG_PTR)MmUserProbeAddress) ? \
- ExRaiseStatus (STATUS_ACCESS_VIOLATION), Default : \
- *(Type *)&(*(volatile Type *)(Ptr)))
-
-#define ProbeForReadBoolean(Ptr) ProbeForReadGenericType(Ptr, BOOLEAN, FALSE)
-#define ProbeForReadUchar(Ptr) ProbeForReadGenericType(Ptr, UCHAR, 0)
-#define ProbeForReadChar(Ptr) ProbeForReadGenericType(Ptr, CHAR, 0)
-#define ProbeForReadUshort(Ptr) ProbeForReadGenericType(Ptr, USHORT, 0)
-#define ProbeForReadShort(Ptr) ProbeForReadGenericType(Ptr, SHORT, 0)
-#define ProbeForReadUlong(Ptr) ProbeForReadGenericType(Ptr, ULONG, 0)
-#define ProbeForReadLong(Ptr) ProbeForReadGenericType(Ptr, LONG, 0)
-#define ProbeForReadUint(Ptr) ProbeForReadGenericType(Ptr, UINT, 0)
-#define ProbeForReadInt(Ptr) ProbeForReadGenericType(Ptr, INT, 0)
-#define ProbeForReadUlonglong(Ptr) ProbeForReadGenericType(Ptr, ULONGLONG, 0)
-#define ProbeForReadLonglong(Ptr) ProbeForReadGenericType(Ptr, LONGLONG, 0)
-#define ProbeForReadPointer(Ptr) ProbeForReadGenericType(Ptr, PVOID, NULL)
-#define ProbeForReadHandle(Ptr) ProbeForReadGenericType(Ptr, HANDLE, NULL)
-#define ProbeForReadLangid(Ptr) ProbeForReadGenericType(Ptr, LANGID, 0)
-#define ProbeForReadLargeInteger(Ptr) ProbeForReadGenericType(Ptr, LARGE_INTEGER, __emptyLargeInteger)
-#define ProbeForReadUlargeInteger(Ptr) ProbeForReadGenericType(Ptr, ULARGE_INTEGER, __emptyULargeInteger)
-#define ProbeForReadUnicodeString(Ptr) ProbeForReadGenericType(Ptr, UNICODE_STRING, __emptyUnicodeString)
-
-/*
- * Inlined Probing Macros
- */
-static __inline
-NTSTATUS
-NTAPI
-ProbeAndCaptureUnicodeString(OUT PUNICODE_STRING Dest,
- IN KPROCESSOR_MODE CurrentMode,
- IN PUNICODE_STRING UnsafeSrc)
-{
- NTSTATUS Status = STATUS_SUCCESS;
- WCHAR *Buffer;
- ASSERT(Dest != NULL);
-
- /* Probe the structure and buffer*/
- if(CurrentMode != KernelMode)
- {
- _SEH_TRY
- {
- *Dest = ProbeForReadUnicodeString(UnsafeSrc);
- if(Dest->Buffer != NULL)
- {
- if (Dest->Length != 0)
- {
- ProbeForRead(Dest->Buffer,
- Dest->Length,
- sizeof(WCHAR));
-
- /* Allocate space for the buffer */
- Buffer = ExAllocatePoolWithTag(PagedPool,
- Dest->Length + sizeof(WCHAR),
- TAG('U', 'S', 'T', 'R'));
- if (Buffer == NULL)
- {
- Status = STATUS_INSUFFICIENT_RESOURCES;
- _SEH_LEAVE;
- }
-
- /* Copy it */
- RtlCopyMemory(Buffer, Dest->Buffer, Dest->Length);
- Buffer[Dest->Length / sizeof(WCHAR)] = UNICODE_NULL;
-
- /* Set it as the buffer */
- Dest->Buffer = Buffer;
- }
- else
- {
- /* sanitize structure */
- Dest->MaximumLength = 0;
- Dest->Buffer = NULL;
- }
- }
- else
- {
- /* sanitize structure */
- Dest->Length = 0;
- Dest->MaximumLength = 0;
- }
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- }
- else
- {
- /* Just copy the UNICODE_STRING structure, don't allocate new memory!
- We trust the caller to supply valid pointers and data. */
- *Dest = *UnsafeSrc;
- }
-
- /* Return */
- return Status;
-}
-
-static __inline
-VOID
-NTAPI
-ReleaseCapturedUnicodeString(IN PUNICODE_STRING CapturedString,
- IN KPROCESSOR_MODE CurrentMode)
-{
- if(CurrentMode != KernelMode && CapturedString->Buffer != NULL)
- {
- ExFreePool(CapturedString->Buffer);
- }
-}
-
/*
* generic information class probing code
*/
ULONG Flags;
} INFORMATION_CLASS_INFO, *PINFORMATION_CLASS_INFO;
-#define ICI_SQ_SAME(Size, Alignment, Flags) \
- { Size, Size, Alignment, Alignment, Flags }
-
-#define ICI_SQ(SizeQuery, SizeSet, AlignmentQuery, AlignmentSet, Flags) \
- { SizeQuery, SizeSet, AlignmentQuery, AlignmentSet, Flags }
+#define ICI_SQ_SAME(Type, Alignment, Flags) \
+ { Type, Type, Alignment, Alignment, Flags }
-static __inline NTSTATUS
-DefaultSetInfoBufferCheck(UINT Class,
- const INFORMATION_CLASS_INFO *ClassList,
- UINT ClassListEntries,
- PVOID Buffer,
- ULONG BufferLength,
- KPROCESSOR_MODE PreviousMode)
-{
- NTSTATUS Status = STATUS_SUCCESS;
-
- if (Class >= 0 && Class < ClassListEntries)
- {
- if (!(ClassList[Class].Flags & ICIF_SET))
- {
- Status = STATUS_INVALID_INFO_CLASS;
- }
- else if (ClassList[Class].RequiredSizeSET > 0 &&
- BufferLength != ClassList[Class].RequiredSizeSET)
- {
- if (!(ClassList[Class].Flags & ICIF_SET_SIZE_VARIABLE))
- {
- Status = STATUS_INFO_LENGTH_MISMATCH;
- }
- }
+#define ICI_SQ(TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags) \
+ { TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags }
- if (NT_SUCCESS(Status))
- {
- if (PreviousMode != KernelMode)
- {
- _SEH_TRY
- {
- ProbeForRead(Buffer,
- BufferLength,
- ClassList[Class].AlignmentSET);
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- }
- }
- }
- else
- Status = STATUS_INVALID_INFO_CLASS;
+//
+// TEMPORARY
+//
+#define IQS_SAME(Type, Alignment, Flags) \
+ { sizeof(Type), sizeof(Type), sizeof(Alignment), sizeof(Alignment), Flags }
- return Status;
-}
-
-static __inline NTSTATUS
-DefaultQueryInfoBufferCheck(UINT Class,
- const INFORMATION_CLASS_INFO *ClassList,
- UINT ClassListEntries,
- PVOID Buffer,
- ULONG BufferLength,
- PULONG ReturnLength,
- KPROCESSOR_MODE PreviousMode)
-{
- NTSTATUS Status = STATUS_SUCCESS;
-
- if (Class >= 0 && Class < ClassListEntries)
- {
- if (!(ClassList[Class].Flags & ICIF_QUERY))
- {
- Status = STATUS_INVALID_INFO_CLASS;
- }
- else if (ClassList[Class].RequiredSizeQUERY > 0 &&
- BufferLength != ClassList[Class].RequiredSizeQUERY)
- {
- if (!(ClassList[Class].Flags & ICIF_QUERY_SIZE_VARIABLE))
- {
- Status = STATUS_INFO_LENGTH_MISMATCH;
- }
- }
-
- if (NT_SUCCESS(Status))
- {
- if (PreviousMode != KernelMode)
- {
- _SEH_TRY
- {
- if (Buffer != NULL)
- {
- ProbeForWrite(Buffer,
- BufferLength,
- ClassList[Class].AlignmentQUERY);
- }
-
- if (ReturnLength != NULL)
- {
- ProbeForWriteUlong(ReturnLength);
- }
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- }
- }
- }
- else
- Status = STATUS_INVALID_INFO_CLASS;
-
- return Status;
-}
+#define IQS(TypeQuery, TypeSet, AlignmentQuery, AlignmentSet, Flags) \
+ { sizeof(TypeQuery), sizeof(TypeSet), sizeof(AlignmentQuery), sizeof(AlignmentSet), Flags }
/*
* Use IsPointerOffset to test whether a pointer should be interpreted as an offset
* or as a pointer
*/
-#if defined(_X86_) || defined(_M_AMD64)
+#if defined(_X86_) || defined(_M_AMD64) || defined(_MIPS_) || defined(_PPC_) || defined(_ARM_)
/* for x86 and x86-64 the MSB is 1 so we can simply test on that */
#define IsPointerOffset(Ptr) ((LONG_PTR)(Ptr) >= 0)
#endif
#endif
-/*
- *
- */
-#define MM_STACK_SIZE (3*4096)
+
+#ifndef _WIN64
+C_ASSERT(FIELD_OFFSET(KUSER_SHARED_DATA, SystemCall) == 0x300);
+C_ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
+C_ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
+C_ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
+C_ASSERT(FIELD_OFFSET(KTHREAD, NpxState) == KTHREAD_NPX_STATE);
+C_ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
+C_ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
+C_ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
+C_ASSERT(FIELD_OFFSET(KTHREAD, CallbackStack) == KTHREAD_CALLBACK_STACK);
+C_ASSERT(FIELD_OFFSET(KTHREAD, ApcState.Process) == KTHREAD_APCSTATE_PROCESS);
+C_ASSERT(FIELD_OFFSET(KPROCESS, DirectoryTableBase) == KPROCESS_DIRECTORY_TABLE_BASE);
+C_ASSERT(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST);
+
+C_ASSERT(FIELD_OFFSET(KPCR, Self) == KPCR_SELF);
+#endif
+
+#ifdef _M_IX86
+C_ASSERT(FIELD_OFFSET(KPCR, IRR) == KPCR_IRR);
+C_ASSERT(FIELD_OFFSET(KPCR, IDR) == KPCR_IDR);
+C_ASSERT(FIELD_OFFSET(KPCR, Irql) == KPCR_IRQL);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NextThread) == KPCR_PRCB_NEXT_THREAD);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NpxThread) == KPCR_NPX_THREAD);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) == KPCR_PRCB_DATA);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, KeSystemCalls) == KPCR_SYSTEM_CALLS);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcData) + FIELD_OFFSET(KDPC_DATA, DpcQueueDepth) == KPCR_PRCB_DPC_QUEUE_DEPTH);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcData) + 16 == KPCR_PRCB_DPC_COUNT);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcStack) == KPCR_PRCB_DPC_STACK);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, TimerRequest) == KPCR_PRCB_TIMER_REQUEST);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, MaximumDpcQueueDepth) == KPCR_PRCB_MAXIMUM_DPC_QUEUE_DEPTH);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcRequestRate) == KPCR_PRCB_DPC_REQUEST_RATE);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcInterruptRequested) == KPCR_PRCB_DPC_INTERRUPT_REQUESTED);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcRoutineActive) == KPCR_PRCB_DPC_ROUTINE_ACTIVE);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcLastCount) == KPCR_PRCB_DPC_LAST_COUNT);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, TimerRequest) == KPCR_PRCB_TIMER_REQUEST);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, QuantumEnd) == KPCR_PRCB_QUANTUM_END);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DeferredReadyListHead) == KPCR_PRCB_DEFERRED_READY_LIST_HEAD);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, PowerState) == KPCR_PRCB_POWER_STATE_IDLE_FUNCTION);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, PrcbLock) == KPCR_PRCB_PRCB_LOCK);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcStack) == KPCR_PRCB_DPC_STACK);
+C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, IdleSchedule) == KPCR_PRCB_IDLE_SCHEDULE);
+C_ASSERT(sizeof(FX_SAVE_AREA) == SIZEOF_FX_SAVE_AREA);
+
+/* Platform specific checks */
+C_ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
+C_ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
+C_ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, SavedExceptionStack) == TF_SAVED_EXCEPTION_STACK);
+C_ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS);
+C_ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP);
+C_ASSERT(FIELD_OFFSET(KTSS, Esp0) == KTSS_ESP0);
+C_ASSERT(FIELD_OFFSET(KTSS, IoMapBase) == KTSS_IOMAPBASE);
+#endif
#endif /* INCLUDE_INTERNAL_NTOSKRNL_H */
projects / reactos.git / blobdiff