Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 06:22:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Fix compile issues caused by previous patch.

Browse source 
- Fix KPROFILE definition.
- Protect ReactOS-only members of EPROCESS, OBJECT_HEADER, W32_CALLOUT_DATA.
- Protect MADDRESS_SPACE for ReactOS only.

svn path=/trunk/; revision=19694
This commit is contained in:
Alex Ionescu 2005-11-27 19:21:19 +00:00
parent 125b0fa6a3
commit c06fa82588
15 changed files with 215 additions and 218 deletions
Download patch file Download diff file Expand all files Collapse all files

1
reactos/include/ndk/asm.h
View file

@ -64,6 +64,7 @@ Author:
#define KTSS_CR3 0x1C #define KTSS_CR3 0x1C
#define KTSS_EFLAGS 0x24 #define KTSS_EFLAGS 0x24
#define KTSS_IOMAPBASE 0x66 #define KTSS_IOMAPBASE 0x66
#define KTSS_IO_MAPS 0x68
// //
// KTHREAD Offsets // KTHREAD Offsets

6
reactos/include/ndk/fixmes.txt
View file

@ -2,13 +2,7 @@ Complete list of NDK Fixmes before 1.0 Release (Nov 27th 2005)
-------------------------------------------------------------- --------------------------------------------------------------
______________________________________________________________________________________ ______________________________________________________________________________________
[CRITICAL] - Breaking compatibility with official structures. [CRITICAL] - Breaking compatibility with official structures.
|pstypes.h - EPROCESS has ReactOS only fields. Includes ReactOS Internal header. IFDEF_OUT
|pstypes.h - W32_CALLOUT_DATA has ReactOS only fields. IFDEF-OUT
|obtypes.h - Object callbacks are ReactOS only definitions. IFDEF-OUT ADDREAL |obtypes.h - Object callbacks are ReactOS only definitions. IFDEF-OUT ADDREAL
|obtypes.h - Object Header includes ReactOS only type. IFDEF-OUT
|mmtypes.h - _MADDRESS_SPACE is ReactOS only field. IFDEF-OUT
|ketypes.h - _KPROFILE needs to be updated with new definitions. FIXFIX
|ketypes.h - _KINTERRUPT needs to be verified with new definitions. FIXFIX
|haltypes.h - Loader Parameter Block is ReactOS Version, not NT. IFDEF-OUT ADDREAL |haltypes.h - Loader Parameter Block is ReactOS Version, not NT. IFDEF-OUT ADDREAL
| |
[MAJOR] - Using incorrect, missing, or invalid names or definitions. [MAJOR] - Using incorrect, missing, or invalid names or definitions.

19
reactos/include/ndk/ketypes.h
View file

@ -350,7 +350,7 @@ typedef struct _CONFIGURATION_COMPONENT_DATA
} CONFIGURATION_COMPONENT_DATA, *PCONFIGURATION_COMPONENT_DATA; } CONFIGURATION_COMPONENT_DATA, *PCONFIGURATION_COMPONENT_DATA;
// //
// Kernel Memory Node (FIXME: mmtypes? // Kernel Memory Node
// //
typedef struct _KNODE typedef struct _KNODE
{ {
@ -367,25 +367,26 @@ typedef struct _KNODE
} KNODE, *PKNODE; } KNODE, *PKNODE;
// //
// Kernel Profile Object (FIXME: Fix with new defs) // Kernel Profile Object
// //
typedef struct _KPROFILE typedef struct _KPROFILE
{ {
CSHORT Type; CSHORT Type;
CSHORT Size; CSHORT Size;
LIST_ENTRY ListEntry; LIST_ENTRY ProfileListEntry;
PVOID RegionStart; PKPROCESS Process;
PVOID RegionEnd; PVOID RangeBase;
PVOID RangeLimit;
ULONG BucketShift; ULONG BucketShift;
PVOID Buffer; PVOID Buffer;
ULONG Segment;
KAFFINITY Affinity;
KPROFILE_SOURCE Source; KPROFILE_SOURCE Source;
ULONG Affinity; BOOLEAN Started;
BOOLEAN Active;
struct _KPROCESS *Process;
} KPROFILE, *PKPROFILE; } KPROFILE, *PKPROFILE;
// //
// Kernel Interrupt Object (FIXME: Verify) // Kernel Interrupt Object
// //
typedef struct _KINTERRUPT typedef struct _KINTERRUPT
{ {

2
reactos/include/ndk/mmtypes.h
View file

@ -202,6 +202,7 @@ typedef struct _SECTION_IMAGE_INFORMATION
// //
// FIXME: REACTOS SPECIFIC HACK IN EPROCESS // FIXME: REACTOS SPECIFIC HACK IN EPROCESS
// //
#ifdef _REACTOS_
typedef struct _MADDRESS_SPACE typedef struct _MADDRESS_SPACE
{ {
struct _MEMORY_AREA *MemoryAreaRoot; struct _MEMORY_AREA *MemoryAreaRoot;
@ -211,6 +212,7 @@ typedef struct _MADDRESS_SPACE
PUSHORT PageTableRefCountTable; PUSHORT PageTableRefCountTable;
ULONG PageTableRefCountTableSize; ULONG PageTableRefCountTableSize;
} MADDRESS_SPACE, *PMADDRESS_SPACE; } MADDRESS_SPACE, *PMADDRESS_SPACE;
#endif
// //
// Generic Address Range Structure // Generic Address Range Structure

6
reactos/include/ndk/obtypes.h
View file

@ -341,11 +341,13 @@ typedef struct _OBJECT_HEADER_CREATOR_INFO
} OBJECT_HEADER_CREATOR_INFO, *POBJECT_HEADER_CREATOR_INFO; } OBJECT_HEADER_CREATOR_INFO, *POBJECT_HEADER_CREATOR_INFO;
// //
// FIXME: Object Header // Object Header
// //
typedef struct _OBJECT_HEADER typedef struct _OBJECT_HEADER
{ {
LIST_ENTRY Entry; #ifdef _REACTOS_
LIST_ENTRY Entry; // FIXME: REACTOS ONLY
#endif
LONG PointerCount; LONG PointerCount;
union union
{ {

22
reactos/include/ndk/pstypes.h
View file

@ -529,10 +529,6 @@ typedef struct _THREAD_BASIC_INFORMATION
} THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION; } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;
#ifndef NTOS_MODE_USER #ifndef NTOS_MODE_USER
/* FIXME: see note in mmtypes.h */
#ifdef _NTOSKRNL_
#include <internal/mm.h>
#endif
// //
// EPROCESS Quota Structures // EPROCESS Quota Structures
@ -690,6 +686,10 @@ typedef struct _ETHREAD
UCHAR ActiveFaultCount; /* 24E */ UCHAR ActiveFaultCount; /* 24E */
} ETHREAD; } ETHREAD;
#if defined(_NTOSKRNL_)
#include <internal/mm.h>
#endif
// //
// Executive Process (EPROCESS) // Executive Process (EPROCESS)
// //
@ -818,16 +818,15 @@ typedef struct _EPROCESS
MM_AVL_TABLE VadRoot; /* 250 */ MM_AVL_TABLE VadRoot; /* 250 */
ULONG Cookie; /* 270 */ ULONG Cookie; /* 270 */
/*************************************************************** #ifdef _REACTOS_
* REACTOS SPECIFIC START /* FIXME: WILL BE DEPRECATED WITH PUSHLOCK SUPPORT IN 0.3.0*/
***************************************************************/
/* FIXME WILL BE DEPRECATED WITH PUSHLOCK SUPPORT IN 0.3.0 */
KEVENT LockEvent; /* 274 */ KEVENT LockEvent; /* 274 */
ULONG LockCount; /* 284 */ ULONG LockCount; /* 284 */
struct _KTHREAD *LockOwner; /* 288 */ struct _KTHREAD *LockOwner; /* 288 */
/* FIXME MOVE TO AVL TREES */ /* FIXME: MOVE TO AVL TREES */
MADDRESS_SPACE AddressSpace; /* 28C */ MADDRESS_SPACE AddressSpace; /* 28C */
#endif
} EPROCESS; } EPROCESS;
#include <poppack.h> #include <poppack.h>
@ -919,11 +918,12 @@ typedef struct _W32_CALLOUT_DATA
OB_DELETE_METHOD WinStaDelete; OB_DELETE_METHOD WinStaDelete;
OB_PARSE_METHOD WinStaParse; OB_PARSE_METHOD WinStaParse;
OB_OPEN_METHOD WinStaOpen; OB_OPEN_METHOD WinStaOpen;
#ifdef _REACTOS_
/* FIXME: These are ROS-ONLY and are fixed in a future local patch */ /* FIXME: REACTOS ONLY */
OB_FIND_METHOD WinStaFind; OB_FIND_METHOD WinStaFind;
OB_OPEN_METHOD WinStaCreate; OB_OPEN_METHOD WinStaCreate;
OB_CREATE_METHOD DesktopCreate; OB_CREATE_METHOD DesktopCreate;
#endif
} W32_CALLOUT_DATA, *PW32_CALLOUT_DATA; } W32_CALLOUT_DATA, *PW32_CALLOUT_DATA;
#endif // !NTOS_MODE_USER #endif // !NTOS_MODE_USER

153
reactos/ntoskrnl/ke/i386/exp.c
View file

@ -167,7 +167,7 @@ KiKernelTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2)
{ {
Er.ExceptionCode = STATUS_ACCESS_VIOLATION; Er.ExceptionCode = STATUS_ACCESS_VIOLATION;
Er.NumberParameters = 2; Er.NumberParameters = 2;
Er.ExceptionInformation[0] = Tf->ErrorCode & 0x1; Er.ExceptionInformation[0] = Tf->ErrCode & 0x1;
Er.ExceptionInformation[1] = (ULONG)Cr2; Er.ExceptionInformation[1] = (ULONG)Cr2;
} }
else else
@ -194,6 +194,7 @@ KiKernelTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2)
VOID VOID
KiDoubleFaultHandler(VOID) KiDoubleFaultHandler(VOID)
{ {
#if 0
unsigned int cr2; unsigned int cr2;
ULONG StackLimit; ULONG StackLimit;
ULONG StackBase; ULONG StackBase;
@ -212,7 +213,7 @@ KiDoubleFaultHandler(VOID)
#endif #endif
OldTss = KeGetCurrentKPCR()->TSS; OldTss = KeGetCurrentKPCR()->TSS;
Esp0 = OldTss->Esp; Esp0 = OldTss->Esp0;
/* Get CR2 */ /* Get CR2 */
cr2 = Ke386GetCr2(); cr2 = Ke386GetCr2();
@ -394,7 +395,7 @@ KiDoubleFaultHandler(VOID)
} }
#endif #endif
} }
#endif
DbgPrint("\n"); DbgPrint("\n");
for(;;); for(;;);
} }
@ -406,8 +407,8 @@ KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2)
ULONG cr3_; ULONG cr3_;
ULONG StackLimit; ULONG StackLimit;
ULONG Esp0; ULONG Esp0;
ULONG ExceptionNr = (ULONG)Tf->DebugArgMark; ULONG ExceptionNr = (ULONG)Tf->DbgArgMark;
ULONG cr2 = (ULONG)Tf->DebugPointer; ULONG cr2 = (ULONG)Tf->DbgArgPointer;
Esp0 = (ULONG)Tf; Esp0 = (ULONG)Tf;
@ -417,14 +418,14 @@ KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2)
if (ExceptionNr < ARRAY_SIZE(ExceptionTypeStrings)) if (ExceptionNr < ARRAY_SIZE(ExceptionTypeStrings))
{ {
DbgPrint("%s Exception: %d(%x)\n", ExceptionTypeStrings[ExceptionNr], DbgPrint("%s Exception: %d(%x)\n", ExceptionTypeStrings[ExceptionNr],
ExceptionNr, Tf->ErrorCode&0xffff); ExceptionNr, Tf->ErrCode&0xffff);
} }
else else
{ {
DbgPrint("Exception: %d(%x)\n", ExceptionNr, Tf->ErrorCode&0xffff); DbgPrint("Exception: %d(%x)\n", ExceptionNr, Tf->ErrCode&0xffff);
} }
DbgPrint("Processor: %d CS:EIP %x:%x ", KeGetCurrentProcessorNumber(), DbgPrint("Processor: %d CS:EIP %x:%x ", KeGetCurrentProcessorNumber(),
Tf->Cs&0xffff, Tf->Eip); Tf->SegCs&0xffff, Tf->Eip);
KeRosPrintAddress((PVOID)Tf->Eip); KeRosPrintAddress((PVOID)Tf->Eip);
DbgPrint("\n"); DbgPrint("\n");
Ke386GetPageTableDirectory(cr3_); Ke386GetPageTableDirectory(cr3_);
@ -442,13 +443,13 @@ KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2)
PsGetCurrentThread()->Cid.UniqueThread); PsGetCurrentThread()->Cid.UniqueThread);
} }
DbgPrint("\n"); DbgPrint("\n");
DbgPrint("DS %x ES %x FS %x GS %x\n", Tf->Ds&0xffff, Tf->Es&0xffff, DbgPrint("DS %x ES %x FS %x GS %x\n", Tf->SegDs&0xffff, Tf->SegEs&0xffff,
Tf->Fs&0xffff, Tf->Gs&0xfff); Tf->SegFs&0xffff, Tf->SegGs&0xfff);
DbgPrint("EAX: %.8x EBX: %.8x ECX: %.8x\n", Tf->Eax, Tf->Ebx, Tf->Ecx); DbgPrint("EAX: %.8x EBX: %.8x ECX: %.8x\n", Tf->Eax, Tf->Ebx, Tf->Ecx);
DbgPrint("EDX: %.8x EBP: %.8x ESI: %.8x ESP: %.8x\n", Tf->Edx, DbgPrint("EDX: %.8x EBP: %.8x ESI: %.8x ESP: %.8x\n", Tf->Edx,
Tf->Ebp, Tf->Esi, Esp0); Tf->Ebp, Tf->Esi, Esp0);
DbgPrint("EDI: %.8x EFLAGS: %.8x ", Tf->Edi, Tf->Eflags); DbgPrint("EDI: %.8x EFLAGS: %.8x ", Tf->Edi, Tf->EFlags);
if ((Tf->Cs&0xffff) == KGDT_R0_CODE) if ((Tf->SegCs&0xffff) == KGDT_R0_CODE)
{ {
DbgPrint("kESP %.8x ", Esp0); DbgPrint("kESP %.8x ", Esp0);
if (PsGetCurrentThread() != NULL) if (PsGetCurrentThread() != NULL)
@ -490,21 +491,21 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
ASSERT(ExceptionNr != 14); ASSERT(ExceptionNr != 14);
/* Store the exception number in an unused field in the trap frame. */ /* Store the exception number in an unused field in the trap frame. */
Tf->DebugArgMark = ExceptionNr; Tf->DbgArgMark = ExceptionNr;
/* Use the address of the trap frame as approximation to the ring0 esp */ /* Use the address of the trap frame as approximation to the ring0 esp */
Esp0 = (ULONG)&Tf->Eip; Esp0 = (ULONG)&Tf->Eip;
/* Get CR2 */ /* Get CR2 */
cr2 = Ke386GetCr2(); cr2 = Ke386GetCr2();
Tf->DebugPointer = cr2; Tf->DbgArgPointer = cr2;
/* /*
* If this was a V86 mode exception then handle it specially * If this was a V86 mode exception then handle it specially
*/ */
if (Tf->Eflags & (1 << 17)) if (Tf->EFlags & (1 << 17))
{ {
DPRINT("Tf->Eflags, %x, Tf->Eip %x, ExceptionNr: %d\n", Tf->Eflags, Tf->Eip, ExceptionNr); DPRINT("Tf->Eflags, %x, Tf->Eip %x, ExceptionNr: %d\n", Tf->EFlags, Tf->Eip, ExceptionNr);
return(KeV86Exception(ExceptionNr, Tf, cr2)); return(KeV86Exception(ExceptionNr, Tf, cr2));
} }
@ -561,7 +562,7 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
/* /*
* Handle user exceptions differently * Handle user exceptions differently
*/ */
if ((Tf->Cs & 0xFFFF) == (KGDT_R3_CODE | RPL_MASK)) if ((Tf->SegCs & 0xFFFF) == (KGDT_R3_CODE | RPL_MASK))
{ {
return(KiUserTrapHandler(Tf, ExceptionNr, (PVOID)cr2)); return(KiUserTrapHandler(Tf, ExceptionNr, (PVOID)cr2));
} }
@ -576,15 +577,15 @@ NTAPI
KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame) KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame)
{ {
/* Check if this is user-mode or V86 */ /* Check if this is user-mode or V86 */
if ((TrapFrame->Cs & 1) || (TrapFrame->Eflags & X86_EFLAGS_VM)) if ((TrapFrame->SegCs & MODE_MASK) || (TrapFrame->EFlags & X86_EFLAGS_VM))
{ {
/* Return it directly */ /* Return it directly */
return TrapFrame->Esp; return TrapFrame->HardwareEsp;
} }
else else
{ {
/* Edited frame */ /* Edited frame */
if (!(TrapFrame->Cs & FRAME_EDITED)) if (!(TrapFrame->SegCs & FRAME_EDITED))
{ {
/* Return edited value */ /* Return edited value */
return TrapFrame->TempEsp; return TrapFrame->TempEsp;
@ -592,7 +593,7 @@ KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame)
else else
{ {
/* Virgin frame, calculate */ /* Virgin frame, calculate */
return (ULONG)&TrapFrame->Esp; return (ULONG)&TrapFrame->HardwareEsp;
} }
} }
} }
@ -605,10 +606,10 @@ KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame,
ULONG Previous = KiEspFromTrapFrame(TrapFrame); ULONG Previous = KiEspFromTrapFrame(TrapFrame);
/* Check if this is user-mode or V86 */ /* Check if this is user-mode or V86 */
if ((TrapFrame->Cs & MODE_MASK) || (TrapFrame->Eflags & X86_EFLAGS_VM)) if ((TrapFrame->SegCs & MODE_MASK) || (TrapFrame->EFlags & X86_EFLAGS_VM))
{ {
/* Write it directly */ /* Write it directly */
TrapFrame->Esp = Esp; TrapFrame->HardwareEsp = Esp;
} }
else else
{ {
@ -619,7 +620,7 @@ KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame,
} }
/* Create an edit frame, check if it was alrady */ /* Create an edit frame, check if it was alrady */
if (!(TrapFrame->Cs & FRAME_EDITED)) if (!(TrapFrame->SegCs & FRAME_EDITED))
{ {
/* Update the value */ /* Update the value */
TrapFrame->TempEsp = Esp; TrapFrame->TempEsp = Esp;
@ -630,8 +631,8 @@ KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame,
if (Previous != Esp) if (Previous != Esp)
{ {
/* Save CS */ /* Save CS */
TrapFrame->TempCs = TrapFrame->Cs; TrapFrame->TempSegCs = TrapFrame->SegCs;
TrapFrame->Cs &= ~FRAME_EDITED; TrapFrame->SegCs &= ~FRAME_EDITED;
/* Save ESP */ /* Save ESP */
TrapFrame->TempEsp = Esp; TrapFrame->TempEsp = Esp;
@ -645,15 +646,15 @@ NTAPI
KiSsFromTrapFrame(IN PKTRAP_FRAME TrapFrame) KiSsFromTrapFrame(IN PKTRAP_FRAME TrapFrame)
{ {
/* If this was V86 Mode */ /* If this was V86 Mode */
if (TrapFrame->Eflags & X86_EFLAGS_VM) if (TrapFrame->EFlags & X86_EFLAGS_VM)
{ {
/* Just return it */ /* Just return it */
return TrapFrame->Ss; return TrapFrame->HardwareSegSs;
} }
else if (TrapFrame->Cs & MODE_MASK) else if (TrapFrame->SegCs & MODE_MASK)
{ {
/* Usermode, return the User SS */ /* Usermode, return the User SS */
return TrapFrame->Ss | RPL_MASK; return TrapFrame->HardwareSegSs | RPL_MASK;
} }
else else
{ {
@ -671,15 +672,15 @@ KiSsToTrapFrame(IN PKTRAP_FRAME TrapFrame,
Ss &= 0xFFFF; Ss &= 0xFFFF;
/* If this was V86 Mode */ /* If this was V86 Mode */
if (TrapFrame->Eflags & X86_EFLAGS_VM) if (TrapFrame->EFlags & X86_EFLAGS_VM)
{ {
/* Just write it */ /* Just write it */
TrapFrame->Ss = Ss; TrapFrame->HardwareSegSs = Ss;
} }
else if (TrapFrame->Cs & MODE_MASK) else if (TrapFrame->SegCs & MODE_MASK)
{ {
/* Usermode, save the User SS */ /* Usermode, save the User SS */
TrapFrame->Ss = Ss | RPL_MASK; TrapFrame->HardwareSegSs = Ss | RPL_MASK;
} }
} }
@ -697,35 +698,35 @@ KeContextToTrapFrame(IN PCONTEXT Context,
{ {
/* Check if we went through a V86 switch */ /* Check if we went through a V86 switch */
if ((Context->EFlags & X86_EFLAGS_VM) != if ((Context->EFlags & X86_EFLAGS_VM) !=
(TrapFrame->Eflags & X86_EFLAGS_VM)) (TrapFrame->EFlags & X86_EFLAGS_VM))
{ {
/* We did, remember this for later */ /* We did, remember this for later */
V86Switch = TRUE; V86Switch = TRUE;
} }
/* Copy EFLAGS. FIXME: Needs to be sanitized */ /* Copy EFLAGS. FIXME: Needs to be sanitized */
TrapFrame->Eflags = Context->EFlags; TrapFrame->EFlags = Context->EFlags;
/* Copy EBP and EIP */ /* Copy EBP and EIP */
TrapFrame->Ebp = Context->Ebp; TrapFrame->Ebp = Context->Ebp;
TrapFrame->Eip = Context->Eip; TrapFrame->Eip = Context->Eip;
/* Check if we were in V86 Mode */ /* Check if we were in V86 Mode */
if (TrapFrame->Eflags & X86_EFLAGS_VM) if (TrapFrame->EFlags & X86_EFLAGS_VM)
{ {
/* Simply copy the CS value */ /* Simply copy the CS value */
TrapFrame->Cs = Context->SegCs; TrapFrame->SegCs = Context->SegCs;
} }
else else
{ {
/* We weren't in V86, so sanitize the CS (FIXME!) */ /* We weren't in V86, so sanitize the CS (FIXME!) */
TrapFrame->Cs = Context->SegCs; TrapFrame->SegCs = Context->SegCs;
/* Don't let it under 8, that's invalid */ /* Don't let it under 8, that's invalid */
if ((PreviousMode != KernelMode) && (TrapFrame->Cs < 8)) if ((PreviousMode != KernelMode) && (TrapFrame->SegCs < 8))
{ {
/* Force it to User CS */ /* Force it to User CS */
TrapFrame->Cs = (KGDT_R3_CODE | RPL_MASK); TrapFrame->SegCs = (KGDT_R3_CODE | RPL_MASK);
} }
} }
@ -754,39 +755,39 @@ KeContextToTrapFrame(IN PCONTEXT Context,
if ((Context->ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS) if ((Context->ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS)
{ {
/* Check if we were in V86 Mode */ /* Check if we were in V86 Mode */
if (TrapFrame->Eflags & X86_EFLAGS_VM) if (TrapFrame->EFlags & X86_EFLAGS_VM)
{ {
/* Copy the V86 Segments directlry */ /* Copy the V86 Segments directlry */
TrapFrame->V86_Ds = Context->SegDs; TrapFrame->V86Ds = Context->SegDs;
TrapFrame->V86_Es = Context->SegEs; TrapFrame->V86Es = Context->SegEs;
TrapFrame->V86_Fs = Context->SegFs; TrapFrame->V86Fs = Context->SegFs;
TrapFrame->V86_Gs = Context->SegGs; TrapFrame->V86Gs = Context->SegGs;
} }
else if (!(TrapFrame->Cs & MODE_MASK)) else if (!(TrapFrame->SegCs & MODE_MASK))
{ {
/* For user mode, write the values directly */ /* For user mode, write the values directly */
TrapFrame->Ds = KGDT_R3_DATA | RPL_MASK; TrapFrame->SegDs = KGDT_R3_DATA | RPL_MASK;
TrapFrame->Es = KGDT_R3_DATA | RPL_MASK; TrapFrame->SegEs = KGDT_R3_DATA | RPL_MASK;
TrapFrame->Fs = Context->SegFs; TrapFrame->SegFs = Context->SegFs;
TrapFrame->Gs = 0; TrapFrame->SegGs = 0;
} }
else else
{ {
/* For kernel-mode, return the values */ /* For kernel-mode, return the values */
TrapFrame->Ds = Context->SegDs; TrapFrame->SegDs = Context->SegDs;
TrapFrame->Es = Context->SegEs; TrapFrame->SegEs = Context->SegEs;
TrapFrame->Fs = Context->SegFs; TrapFrame->SegFs = Context->SegFs;
/* Handle GS specially */ /* Handle GS specially */
if (TrapFrame->Cs == (KGDT_R3_CODE | RPL_MASK)) if (TrapFrame->SegCs == (KGDT_R3_CODE | RPL_MASK))
{ {
/* Don't use it, if user */ /* Don't use it, if user */
TrapFrame->Gs = 0; TrapFrame->SegGs = 0;
} }
else else
{ {
/* Copy it if kernel */ /* Copy it if kernel */
TrapFrame->Gs = Context->SegGs; TrapFrame->SegGs = Context->SegGs;
} }
} }
} }
@ -828,19 +829,19 @@ KeTrapFrameToContext(IN PKTRAP_FRAME TrapFrame,
/* EBP, EIP and EFLAGS */ /* EBP, EIP and EFLAGS */
Context->Ebp = TrapFrame->Ebp; Context->Ebp = TrapFrame->Ebp;
Context->Eip = TrapFrame->Eip; Context->Eip = TrapFrame->Eip;
Context->EFlags = TrapFrame->Eflags; Context->EFlags = TrapFrame->EFlags;
/* Return the correct CS */ /* Return the correct CS */
if (!(TrapFrame->Cs & FRAME_EDITED) && if (!(TrapFrame->SegCs & FRAME_EDITED) &&
!(TrapFrame->Eflags & X86_EFLAGS_VM)) !(TrapFrame->EFlags & X86_EFLAGS_VM))
{ {
/* Get it from the Temp location */ /* Get it from the Temp location */
Context->SegCs = TrapFrame->TempCs & 0xFFFF; Context->SegCs = TrapFrame->TempSegCs & 0xFFFF;
} }
else else
{ {
/* Return it directly */ /* Return it directly */
Context->SegCs = TrapFrame->Cs & 0xFFFF; Context->SegCs = TrapFrame->SegCs & 0xFFFF;
} }
/* Get the Ss and ESP */ /* Get the Ss and ESP */
@ -852,31 +853,31 @@ KeTrapFrameToContext(IN PKTRAP_FRAME TrapFrame,
if ((Context->ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS) if ((Context->ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS)
{ {
/* Do V86 Mode first */ /* Do V86 Mode first */
if (TrapFrame->Eflags & X86_EFLAGS_VM) if (TrapFrame->EFlags & X86_EFLAGS_VM)
{ {
/* Return from the V86 location */ /* Return from the V86 location */
Context->SegGs = TrapFrame->V86_Gs & 0xFFFF; Context->SegGs = TrapFrame->V86Gs & 0xFFFF;
Context->SegFs = TrapFrame->V86_Fs & 0xFFFF; Context->SegFs = TrapFrame->V86Fs & 0xFFFF;
Context->SegEs = TrapFrame->V86_Es & 0xFFFF; Context->SegEs = TrapFrame->V86Es & 0xFFFF;
Context->SegDs = TrapFrame->V86_Ds & 0xFFFF; Context->SegDs = TrapFrame->V86Ds & 0xFFFF;
} }
else else
{ {
/* Check if this was a Kernel Trap */ /* Check if this was a Kernel Trap */
if (TrapFrame->Cs == KGDT_R0_CODE) if (TrapFrame->SegCs == KGDT_R0_CODE)
{ {
/* Set valid selectors */ /* Set valid selectors */
TrapFrame->Gs = 0; TrapFrame->SegGs = 0;
TrapFrame->Fs = KGDT_R0_PCR; TrapFrame->SegFs = KGDT_R0_PCR;
TrapFrame->Es = KGDT_R3_DATA | RPL_MASK; TrapFrame->SegEs = KGDT_R3_DATA | RPL_MASK;
TrapFrame->Ds = KGDT_R3_DATA | RPL_MASK; TrapFrame->SegDs = KGDT_R3_DATA | RPL_MASK;
} }
/* Return the segments */ /* Return the segments */
Context->SegGs = TrapFrame->Gs & 0xFFFF; Context->SegGs = TrapFrame->SegGs & 0xFFFF;
Context->SegFs = TrapFrame->Fs & 0xFFFF; Context->SegFs = TrapFrame->SegFs & 0xFFFF;
Context->SegEs = TrapFrame->Es & 0xFFFF; Context->SegEs = TrapFrame->SegEs & 0xFFFF;
Context->SegDs = TrapFrame->Ds & 0xFFFF; Context->SegDs = TrapFrame->SegDs & 0xFFFF;
} }
} }

4
reactos/ntoskrnl/ke/i386/fpu.c
View file

@ -373,7 +373,7 @@ KiHandleFpuFault(PKTRAP_FRAME Tf, ULONG ExceptionNr)
(void) cr0; (void) cr0;
ASSERT((cr0 & X86_CR0_TS) == X86_CR0_TS); ASSERT((cr0 & X86_CR0_TS) == X86_CR0_TS);
ASSERT((Tf->Eflags & X86_EFLAGS_VM) == 0); ASSERT((Tf->EFlags & X86_EFLAGS_VM) == 0);
ASSERT((cr0 & X86_CR0_EM) == 0); ASSERT((cr0 & X86_CR0_EM) == 0);
/* disable scheduler, clear TS in cr0 */ /* disable scheduler, clear TS in cr0 */
@ -485,7 +485,7 @@ KiHandleFpuFault(PKTRAP_FRAME Tf, ULONG ExceptionNr)
} }
KeLowerIrql(OldIrql); KeLowerIrql(OldIrql);
PreviousMode = ((Tf->Cs & 0xffff) == (KGDT_R3_CODE | RPL_MASK)) ? (UserMode) : (KernelMode); PreviousMode = ((Tf->SegCs & 0xffff) == (KGDT_R3_CODE | RPL_MASK)) ? (UserMode) : (KernelMode);
DPRINT("Math/Xmm fault happened! (PreviousMode = %s)\n", DPRINT("Math/Xmm fault happened! (PreviousMode = %s)\n",
(PreviousMode != KernelMode) ? ("UserMode") : ("KernelMode")); (PreviousMode != KernelMode) ? ("UserMode") : ("KernelMode"));

28
reactos/ntoskrnl/ke/i386/irq.c
View file

@ -170,42 +170,42 @@ STATIC VOID
KeIRQTrapFrameToTrapFrame(PKIRQ_TRAPFRAME IrqTrapFrame, KeIRQTrapFrameToTrapFrame(PKIRQ_TRAPFRAME IrqTrapFrame,
PKTRAP_FRAME TrapFrame) PKTRAP_FRAME TrapFrame)
{ {
TrapFrame->Gs = (USHORT)IrqTrapFrame->Gs; TrapFrame->SegGs = (USHORT)IrqTrapFrame->Gs;
TrapFrame->Fs = (USHORT)IrqTrapFrame->Fs; TrapFrame->SegFs = (USHORT)IrqTrapFrame->Fs;
TrapFrame->Es = (USHORT)IrqTrapFrame->Es; TrapFrame->SegEs = (USHORT)IrqTrapFrame->Es;
TrapFrame->Ds = (USHORT)IrqTrapFrame->Ds; TrapFrame->SegDs = (USHORT)IrqTrapFrame->Ds;
TrapFrame->Eax = IrqTrapFrame->Eax; TrapFrame->Eax = IrqTrapFrame->Eax;
TrapFrame->Ecx = IrqTrapFrame->Ecx; TrapFrame->Ecx = IrqTrapFrame->Ecx;
TrapFrame->Edx = IrqTrapFrame->Edx; TrapFrame->Edx = IrqTrapFrame->Edx;
TrapFrame->Ebx = IrqTrapFrame->Ebx; TrapFrame->Ebx = IrqTrapFrame->Ebx;
TrapFrame->Esp = IrqTrapFrame->Esp; TrapFrame->HardwareEsp = IrqTrapFrame->Esp;
TrapFrame->Ebp = IrqTrapFrame->Ebp; TrapFrame->Ebp = IrqTrapFrame->Ebp;
TrapFrame->Esi = IrqTrapFrame->Esi; TrapFrame->Esi = IrqTrapFrame->Esi;
TrapFrame->Edi = IrqTrapFrame->Edi; TrapFrame->Edi = IrqTrapFrame->Edi;
TrapFrame->Eip = IrqTrapFrame->Eip; TrapFrame->Eip = IrqTrapFrame->Eip;
TrapFrame->Cs = IrqTrapFrame->Cs; TrapFrame->SegCs = IrqTrapFrame->Cs;
TrapFrame->Eflags = IrqTrapFrame->Eflags; TrapFrame->EFlags = IrqTrapFrame->Eflags;
} }
STATIC VOID STATIC VOID
KeTrapFrameToIRQTrapFrame(PKTRAP_FRAME TrapFrame, KeTrapFrameToIRQTrapFrame(PKTRAP_FRAME TrapFrame,
PKIRQ_TRAPFRAME IrqTrapFrame) PKIRQ_TRAPFRAME IrqTrapFrame)
{ {
IrqTrapFrame->Gs = TrapFrame->Gs; IrqTrapFrame->Gs = TrapFrame->SegGs;
IrqTrapFrame->Fs = TrapFrame->Fs; IrqTrapFrame->Fs = TrapFrame->SegFs;
IrqTrapFrame->Es = TrapFrame->Es; IrqTrapFrame->Es = TrapFrame->SegEs;
IrqTrapFrame->Ds = TrapFrame->Ds; IrqTrapFrame->Ds = TrapFrame->SegDs;
IrqTrapFrame->Eax = TrapFrame->Eax; IrqTrapFrame->Eax = TrapFrame->Eax;
IrqTrapFrame->Ecx = TrapFrame->Ecx; IrqTrapFrame->Ecx = TrapFrame->Ecx;
IrqTrapFrame->Edx = TrapFrame->Edx; IrqTrapFrame->Edx = TrapFrame->Edx;
IrqTrapFrame->Ebx = TrapFrame->Ebx; IrqTrapFrame->Ebx = TrapFrame->Ebx;
IrqTrapFrame->Esp = TrapFrame->Esp; IrqTrapFrame->Esp = TrapFrame->HardwareEsp;
IrqTrapFrame->Ebp = TrapFrame->Ebp; IrqTrapFrame->Ebp = TrapFrame->Ebp;
IrqTrapFrame->Esi = TrapFrame->Esi; IrqTrapFrame->Esi = TrapFrame->Esi;
IrqTrapFrame->Edi = TrapFrame->Edi; IrqTrapFrame->Edi = TrapFrame->Edi;
IrqTrapFrame->Eip = TrapFrame->Eip; IrqTrapFrame->Eip = TrapFrame->Eip;
IrqTrapFrame->Cs = TrapFrame->Cs; IrqTrapFrame->Cs = TrapFrame->SegCs;
IrqTrapFrame->Eflags = TrapFrame->Eflags; IrqTrapFrame->Eflags = TrapFrame->EFlags;
} }
VOID STDCALL VOID STDCALL

6
reactos/ntoskrnl/ke/i386/thread.c
View file

@ -95,11 +95,11 @@ Ke386InitThreadWithContext(PKTHREAD Thread,
} }
/* Enable Interrupts and disable some unsupported flags right now */ /* Enable Interrupts and disable some unsupported flags right now */
TrapFrame->Eflags = Context->EFlags | X86_EFLAGS_IF; TrapFrame->EFlags = Context->EFlags | X86_EFLAGS_IF;
TrapFrame->Eflags &= ~(X86_EFLAGS_VM | X86_EFLAGS_NT | X86_EFLAGS_IOPL); TrapFrame->EFlags &= ~(X86_EFLAGS_VM | X86_EFLAGS_NT | X86_EFLAGS_IOPL);
/* Set the previous mode as user */ /* Set the previous mode as user */
TrapFrame->PreviousMode = UserMode; TrapFrame->PreviousPreviousMode = UserMode;
/* Terminate the Exception Handler List */ /* Terminate the Exception Handler List */
TrapFrame->ExceptionList = (PVOID)0xFFFFFFFF; TrapFrame->ExceptionList = (PVOID)0xFFFFFFFF;

58
reactos/ntoskrnl/ke/i386/tss.c
View file

@ -16,6 +16,11 @@
/* GLOBALS *******************************************************************/ /* GLOBALS *******************************************************************/
typedef struct _KTSSNOIOPM
{
UCHAR TssData[KTSS_IO_MAPS];
} KTSSNOIOPM;
static KTSS* Ki386TssArray[MAXIMUM_PROCESSORS]; static KTSS* Ki386TssArray[MAXIMUM_PROCESSORS];
PVOID Ki386InitialStackArray[MAXIMUM_PROCESSORS]; PVOID Ki386InitialStackArray[MAXIMUM_PROCESSORS];
static KTSSNOIOPM* Ki386TrapTssArray[MAXIMUM_PROCESSORS]; static KTSSNOIOPM* Ki386TrapTssArray[MAXIMUM_PROCESSORS];
@ -38,7 +43,7 @@ Ke386IoSetAccessProcess(PEPROCESS Process, BOOL EnableDisable)
USHORT Offset; USHORT Offset;
if(EnableDisable > 1) return FALSE; if(EnableDisable > 1) return FALSE;
Offset = (EnableDisable) ? (USHORT) FIELD_OFFSET(KTSS, IoBitmap) : 0xffff; Offset = (EnableDisable) ? (USHORT) FIELD_OFFSET(KTSS, IoMaps) : 0xffff;
oldIrql = KeRaiseIrqlToSynchLevel(); oldIrql = KeRaiseIrqlToSynchLevel();
Process->Pcb.IopmOffset = Offset; Process->Pcb.IopmOffset = Offset;
@ -62,7 +67,7 @@ Ke386SetIoAccessMap(DWORD MapNumber, PULONG IOMapStart)
oldIrql = KeRaiseIrqlToSynchLevel(); oldIrql = KeRaiseIrqlToSynchLevel();
memcpy(&KeGetCurrentKPCR()->TSS->IoBitmap[0], memcpy(&KeGetCurrentKPCR()->TSS->IoMaps[0],
IOMapStart, IOMapStart,
0x2000); 0x2000);
@ -85,7 +90,7 @@ Ke386QueryIoAccessMap(DWORD MapNumber, PULONG IOMapStart)
oldIrql = KeRaiseIrqlToSynchLevel(); oldIrql = KeRaiseIrqlToSynchLevel();
memcpy(IOMapStart, memcpy(IOMapStart,
&KeGetCurrentKPCR()->TSS->IoBitmap[0], &KeGetCurrentKPCR()->TSS->IoMaps[0],
0x2000); 0x2000);
KeLowerIrql(oldIrql); KeLowerIrql(oldIrql);
@ -96,8 +101,8 @@ VOID
Ki386ApplicationProcessorInitializeTSS(VOID) Ki386ApplicationProcessorInitializeTSS(VOID)
{ {
ULONG cr3_; ULONG cr3_;
KTSS* Tss; PKTSS Tss;
KTSSNOIOPM* TrapTss; PKTSS TrapTss;
PVOID TrapStack; PVOID TrapStack;
ULONG Id; ULONG Id;
PUSHORT Gdt; PUSHORT Gdt;
@ -113,7 +118,7 @@ Ki386ApplicationProcessorInitializeTSS(VOID)
TrapStack = ExAllocatePool(NonPagedPool, MM_STACK_SIZE); TrapStack = ExAllocatePool(NonPagedPool, MM_STACK_SIZE);
Ki386TssArray[Id] = Tss; Ki386TssArray[Id] = Tss;
Ki386TrapTssArray[Id] = TrapTss; Ki386TrapTssArray[Id] = (KTSSNOIOPM*)TrapTss;
Ki386TrapStackArray[Id] = TrapStack; Ki386TrapStackArray[Id] = TrapStack;
KeGetCurrentKPCR()->TSS = Tss; KeGetCurrentKPCR()->TSS = Tss;
@ -121,8 +126,7 @@ Ki386ApplicationProcessorInitializeTSS(VOID)
Tss->Esp0 = (ULONG)Ki386InitialStackArray[Id] + MM_STACK_SIZE; /* FIXME: - sizeof(FX_SAVE_AREA)? */ Tss->Esp0 = (ULONG)Ki386InitialStackArray[Id] + MM_STACK_SIZE; /* FIXME: - sizeof(FX_SAVE_AREA)? */
Tss->Ss0 = KGDT_R0_DATA; Tss->Ss0 = KGDT_R0_DATA;
Tss->IoMapBase = 0xFFFF; /* No i/o bitmap */ Tss->IoMapBase = 0xFFFF; /* No i/o bitmap */
Tss->IoBitmap[8192] = 0xFF; Tss->LDT = 0;
Tss->Ldt = 0;
/* /*
* Initialize a descriptor for the TSS * Initialize a descriptor for the TSS
@ -137,20 +141,16 @@ Ki386ApplicationProcessorInitializeTSS(VOID)
((base & 0xFF000000) >> 16)); ((base & 0xFF000000) >> 16));
/* Initialize the TSS used for handling double faults. */ /* Initialize the TSS used for handling double faults. */
TrapTss->Eflags = 0; TrapTss->Flags = 0;
TrapTss->Esp0 = ((ULONG)TrapStack + MM_STACK_SIZE); /* FIXME: - sizeof(FX_SAVE_AREA)? */ TrapTss->Esp0 = ((ULONG)TrapStack + MM_STACK_SIZE); /* FIXME: - sizeof(FX_SAVE_AREA)? */
TrapTss->Ss0 = KGDT_R0_DATA; TrapTss->Ss0 = KGDT_R0_DATA;
TrapTss->Esp = ((ULONG)TrapStack + MM_STACK_SIZE); /* FIXME: - sizeof(FX_SAVE_AREA)? */
TrapTss->Cs = KGDT_R0_CODE; TrapTss->Cs = KGDT_R0_CODE;
TrapTss->Eip = (ULONG)KiTrap8; TrapTss->Eip = (ULONG)KiTrap8;
TrapTss->Ss = KGDT_R0_DATA;
TrapTss->Ds = KGDT_R0_DATA; TrapTss->Ds = KGDT_R0_DATA;
TrapTss->Es = KGDT_R0_DATA; TrapTss->Es = KGDT_R0_DATA;
TrapTss->Fs = KGDT_R0_PCR; TrapTss->Fs = KGDT_R0_PCR;
TrapTss->IoMapBase = 0xFFFF; /* No i/o bitmap */ TrapTss->IoMapBase = 0xFFFF; /* No i/o bitmap */
TrapTss->IoBitmap[0] = 0xFF; TrapTss->LDT = 0;
TrapTss->Ldt = 0;
TrapTss->Cr3 = cr3_;
/* /*
* Initialize a descriptor for the trap TSS. * Initialize a descriptor for the trap TSS.
@ -185,6 +185,7 @@ Ki386BootInitializeTSS(VOID)
ULONG cr3_; ULONG cr3_;
extern unsigned int trap_stack, trap_stack_top; extern unsigned int trap_stack, trap_stack_top;
unsigned int base, length; unsigned int base, length;
PKTSS Tss;
Ke386GetPageTableDirectory(cr3_); Ke386GetPageTableDirectory(cr3_);
@ -196,10 +197,8 @@ Ki386BootInitializeTSS(VOID)
/* Initialize the boot TSS. */ /* Initialize the boot TSS. */
KiBootTss.Esp0 = (ULONG)init_stack_top - sizeof(FX_SAVE_AREA); KiBootTss.Esp0 = (ULONG)init_stack_top - sizeof(FX_SAVE_AREA);
KiBootTss.Ss0 = KGDT_R0_DATA; KiBootTss.Ss0 = KGDT_R0_DATA;
// KiBootTss.IoMapBase = FIELD_OFFSET(KTSS, IoBitmap);
KiBootTss.IoMapBase = 0xFFFF; /* No i/o bitmap */ KiBootTss.IoMapBase = 0xFFFF; /* No i/o bitmap */
KiBootTss.IoBitmap[8192] = 0xFF; KiBootTss.LDT = KGDT_LDT;
KiBootTss.Ldt = KGDT_LDT;
/* /*
* Initialize a descriptor for the TSS * Initialize a descriptor for the TSS
@ -214,20 +213,17 @@ Ki386BootInitializeTSS(VOID)
((base & 0xFF000000) >> 16); ((base & 0xFF000000) >> 16);
/* Initialize the TSS used for handling double faults. */ /* Initialize the TSS used for handling double faults. */
KiBootTrapTss.Eflags = 0; Tss = (PKTSS)&KiBootTrapTss;
KiBootTrapTss.Esp0 = (ULONG)trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */ Tss->Flags = 0;
KiBootTrapTss.Ss0 = KGDT_R0_DATA; Tss->Esp0 = (ULONG)trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */
KiBootTrapTss.Esp = (ULONG)trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */ Tss->Ss0 = KGDT_R0_DATA;
KiBootTrapTss.Cs = KGDT_R0_CODE; Tss->Cs = KGDT_R0_CODE;
KiBootTrapTss.Eip = (ULONG)KiTrap8; Tss->Eip = (ULONG)KiTrap8;
KiBootTrapTss.Ss = KGDT_R0_DATA; Tss->Ds = KGDT_R0_DATA;
KiBootTrapTss.Ds = KGDT_R0_DATA; Tss->Es = KGDT_R0_DATA;
KiBootTrapTss.Es = KGDT_R0_DATA; Tss->Fs = KGDT_R0_PCR;
KiBootTrapTss.Fs = KGDT_R0_PCR; Tss->IoMapBase = 0xFFFF; /* No i/o bitmap */
KiBootTrapTss.IoMapBase = 0xFFFF; /* No i/o bitmap */ Tss->LDT = 0x0;
KiBootTrapTss.IoBitmap[0] = 0xFF;
KiBootTrapTss.Ldt = 0x0;
KiBootTrapTss.Cr3 = cr3_;
/* /*
* Initialize a descriptor for the trap TSS. * Initialize a descriptor for the trap TSS.

2
reactos/ntoskrnl/ke/i386/usertrap.c
View file

@ -117,7 +117,7 @@ KiUserTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2)
if (ExceptionNr == 14) if (ExceptionNr == 14)
{ {
Er.NumberParameters = 2; Er.NumberParameters = 2;
Er.ExceptionInformation[0] = Tf->ErrorCode & 0x1; Er.ExceptionInformation[0] = Tf->ErrCode & 0x1;
Er.ExceptionInformation[1] = (ULONG)Cr2; Er.ExceptionInformation[1] = (ULONG)Cr2;
} }
else else

80
reactos/ntoskrnl/ke/i386/v86m.c
View file

@ -37,12 +37,12 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
ULONG i = 0; ULONG i = 0;
BOOL Exit = FALSE; BOOL Exit = FALSE;
ip = (PUCHAR)((Tf->Cs & 0xFFFF) * 16 + (Tf->Eip & 0xFFFF)); ip = (PUCHAR)((Tf->SegCs & 0xFFFF) * 16 + (Tf->Eip & 0xFFFF));
sp = (PUSHORT)((Tf->Ss & 0xFFFF) * 16 + (Tf->Esp & 0xFFFF)); sp = (PUSHORT)((Tf->HardwareSegSs & 0xFFFF) * 16 + (Tf->HardwareEsp & 0xFFFF));
dsp = (PULONG)sp; dsp = (PULONG)sp;
DPRINT("KeV86GPF handling %x at %x:%x ss:sp %x:%x Flags %x\n", DPRINT("KeV86GPF handling %x at %x:%x ss:sp %x:%x Flags %x\n",
ip[0], Tf->Cs, Tf->Eip, Tf->Ss, Tf->Esp, VTf->regs->Flags); ip[0], Tf->SegCs, Tf->Eip, Tf->Ss, Tf->HardwareEsp, VTf->regs->Flags);
while (!Exit) while (!Exit)
{ {
@ -113,9 +113,9 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
Tf->Eip++; Tf->Eip++;
if (!BigAddressPrefix) if (!BigAddressPrefix)
{ {
Tf->Esp = Tf->Esp - 2; Tf->HardwareEsp = Tf->HardwareEsp - 2;
sp = sp - 1; sp = sp - 1;
sp[0] = (USHORT)(Tf->Eflags & 0xFFFF); sp[0] = (USHORT)(Tf->EFlags & 0xFFFF);
if (VTf->regs->Vif == 1) if (VTf->regs->Vif == 1)
{ {
sp[0] = (USHORT)(sp[0] | INTERRUPT_FLAG); sp[0] = (USHORT)(sp[0] | INTERRUPT_FLAG);
@ -127,9 +127,9 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
} }
else else
{ {
Tf->Esp = Tf->Esp - 4; Tf->HardwareEsp = Tf->HardwareEsp - 4;
dsp = dsp - 1; dsp = dsp - 1;
dsp[0] = Tf->Eflags; dsp[0] = Tf->EFlags;
dsp[0] = dsp[0] & VALID_FLAGS; dsp[0] = dsp[0] & VALID_FLAGS;
if (VTf->regs->Vif == 1) if (VTf->regs->Vif == 1)
{ {
@ -157,9 +157,9 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
Tf->Eip++; Tf->Eip++;
if (!BigAddressPrefix) if (!BigAddressPrefix)
{ {
Tf->Eflags = Tf->Eflags & (~0xFFFF); Tf->EFlags = Tf->EFlags & (~0xFFFF);
Tf->Eflags = Tf->Eflags | (sp[0] & VALID_FLAGS); Tf->EFlags = Tf->EFlags | (sp[0] & VALID_FLAGS);
if (Tf->Eflags & INTERRUPT_FLAG) if (Tf->EFlags & INTERRUPT_FLAG)
{ {
VTf->regs->Vif = 1; VTf->regs->Vif = 1;
} }
@ -167,12 +167,12 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
{ {
VTf->regs->Vif = 0; VTf->regs->Vif = 0;
} }
Tf->Eflags = Tf->Eflags | INTERRUPT_FLAG; Tf->EFlags = Tf->EFlags | INTERRUPT_FLAG;
Tf->Esp = Tf->Esp + 2; Tf->HardwareEsp = Tf->HardwareEsp + 2;
} }
else else
{ {
Tf->Eflags = Tf->Eflags | (dsp[0] & VALID_FLAGS); Tf->EFlags = Tf->EFlags | (dsp[0] & VALID_FLAGS);
if (dsp[0] & INTERRUPT_FLAG) if (dsp[0] & INTERRUPT_FLAG)
{ {
VTf->regs->Vif = 1; VTf->regs->Vif = 1;
@ -181,8 +181,8 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
{ {
VTf->regs->Vif = 0; VTf->regs->Vif = 0;
} }
Tf->Eflags = Tf->Eflags | INTERRUPT_FLAG; Tf->EFlags = Tf->EFlags | INTERRUPT_FLAG;
Tf->Esp = Tf->Esp + 2; Tf->HardwareEsp = Tf->HardwareEsp + 2;
} }
return(0); return(0);
} }
@ -199,10 +199,10 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
if (VTf->regs->Flags & KV86M_EMULATE_CLI_STI) if (VTf->regs->Flags & KV86M_EMULATE_CLI_STI)
{ {
Tf->Eip = sp[0]; Tf->Eip = sp[0];
Tf->Cs = sp[1]; Tf->SegCs = sp[1];
Tf->Eflags = Tf->Eflags & (~0xFFFF); Tf->EFlags = Tf->EFlags & (~0xFFFF);
Tf->Eflags = Tf->Eflags | sp[2]; Tf->EFlags = Tf->EFlags | sp[2];
if (Tf->Eflags & INTERRUPT_FLAG) if (Tf->EFlags & INTERRUPT_FLAG)
{ {
VTf->regs->Vif = 1; VTf->regs->Vif = 1;
} }
@ -210,8 +210,8 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
{ {
VTf->regs->Vif = 0; VTf->regs->Vif = 0;
} }
Tf->Eflags = Tf->Eflags & (~INTERRUPT_FLAG); Tf->EFlags = Tf->EFlags & (~INTERRUPT_FLAG);
Tf->Esp = Tf->Esp + 6; Tf->HardwareEsp = Tf->HardwareEsp + 6;
return(0); return(0);
} }
Exit = TRUE; Exit = TRUE;
@ -433,11 +433,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
{ {
Offset = Offset & 0xFFFF; Offset = Offset & 0xFFFF;
} }
Buffer = (PUCHAR)((Tf->Es * 16) + Offset); Buffer = (PUCHAR)((Tf->SegEs * 16) + Offset);
for (; Count > 0; Count--) for (; Count > 0; Count--)
{ {
WRITE_PORT_UCHAR(Port, *Buffer); WRITE_PORT_UCHAR(Port, *Buffer);
if (Tf->Eflags & DIRECTION_FLAG) if (Tf->EFlags & DIRECTION_FLAG)
{ {
Buffer++; Buffer++;
} }
@ -480,11 +480,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
} }
if (BigDataPrefix) if (BigDataPrefix)
{ {
BufferL = (PULONG)((Tf->Es * 16) + Offset); BufferL = (PULONG)((Tf->SegEs * 16) + Offset);
} }
else else
{ {
BufferS = (PUSHORT)((Tf->Es * 16) + Offset); BufferS = (PUSHORT)((Tf->SegEs * 16) + Offset);
} }
for (; Count > 0; Count--) for (; Count > 0; Count--)
{ {
@ -496,7 +496,7 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
{ {
WRITE_PORT_USHORT((PUSHORT)Port, *BufferS); WRITE_PORT_USHORT((PUSHORT)Port, *BufferS);
} }
if (Tf->Eflags & DIRECTION_FLAG) if (Tf->EFlags & DIRECTION_FLAG)
{ {
if (BigDataPrefix) if (BigDataPrefix)
{ {
@ -550,11 +550,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
{ {
Offset = Offset & 0xFFFF; Offset = Offset & 0xFFFF;
} }
Buffer = (PUCHAR)((Tf->Es * 16) + Offset); Buffer = (PUCHAR)((Tf->SegEs * 16) + Offset);
for (; Count > 0; Count--) for (; Count > 0; Count--)
{ {
*Buffer = READ_PORT_UCHAR(Port); *Buffer = READ_PORT_UCHAR(Port);
if (Tf->Eflags & DIRECTION_FLAG) if (Tf->EFlags & DIRECTION_FLAG)
{ {
Buffer++; Buffer++;
} }
@ -597,11 +597,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
} }
if (BigDataPrefix) if (BigDataPrefix)
{ {
BufferL = (PULONG)((Tf->Es * 16) + Offset); BufferL = (PULONG)((Tf->SegEs * 16) + Offset);
} }
else else
{ {
BufferS = (PUSHORT)((Tf->Es * 16) + Offset); BufferS = (PUSHORT)((Tf->SegEs * 16) + Offset);
} }
for (; Count > 0; Count--) for (; Count > 0; Count--)
{ {
@ -613,7 +613,7 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
{ {
*BufferS = READ_PORT_USHORT((PUSHORT)Port); *BufferS = READ_PORT_USHORT((PUSHORT)Port);
} }
if (Tf->Eflags & DIRECTION_FLAG) if (Tf->EFlags & DIRECTION_FLAG)
{ {
if (BigDataPrefix) if (BigDataPrefix)
{ {
@ -651,20 +651,20 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf)
inum = ip[1]; inum = ip[1];
entry = ((unsigned int *)0)[inum]; entry = ((unsigned int *)0)[inum];
Tf->Esp = Tf->Esp - 6; Tf->HardwareEsp = Tf->HardwareEsp - 6;
sp = sp - 3; sp = sp - 3;
sp[0] = (USHORT)((Tf->Eip & 0xFFFF) + 2); sp[0] = (USHORT)((Tf->Eip & 0xFFFF) + 2);
sp[1] = (USHORT)(Tf->Cs & 0xFFFF); sp[1] = (USHORT)(Tf->SegCs & 0xFFFF);
sp[2] = (USHORT)(Tf->Eflags & 0xFFFF); sp[2] = (USHORT)(Tf->EFlags & 0xFFFF);
if (VTf->regs->Vif == 1) if (VTf->regs->Vif == 1)
{ {
sp[2] = (USHORT)(sp[2] | INTERRUPT_FLAG); sp[2] = (USHORT)(sp[2] | INTERRUPT_FLAG);
} }
DPRINT("sp[0] %x sp[1] %x sp[2] %x\n", sp[0], sp[1], sp[2]); DPRINT("sp[0] %x sp[1] %x sp[2] %x\n", sp[0], sp[1], sp[2]);
Tf->Eip = entry & 0xFFFF; Tf->Eip = entry & 0xFFFF;
Tf->Cs = entry >> 16; Tf->SegCs = entry >> 16;
Tf->Eflags = Tf->Eflags & (~TRAP_FLAG); Tf->EFlags = Tf->EFlags & (~TRAP_FLAG);
return(0); return(0);
} }
@ -701,16 +701,16 @@ KeV86Exception(ULONG ExceptionNr, PKTRAP_FRAME Tf, ULONG address)
/* /*
* Check if we have reached the recovery instruction * Check if we have reached the recovery instruction
*/ */
Ip = (PUCHAR)((Tf->Cs & 0xFFFF) * 16 + (Tf->Eip & 0xFFFF)); Ip = (PUCHAR)((Tf->SegCs & 0xFFFF) * 16 + (Tf->Eip & 0xFFFF));
DPRINT("ExceptionNr %d Ip[0] %x Ip[1] %x Ip[2] %x Ip[3] %x Tf->Cs %x " DPRINT("ExceptionNr %d Ip[0] %x Ip[1] %x Ip[2] %x Ip[3] %x Tf->SegCs %x "
"Tf->Eip %x\n", ExceptionNr, Ip[0], Ip[1], Ip[2], Ip[3], Tf->Cs, "Tf->Eip %x\n", ExceptionNr, Ip[0], Ip[1], Ip[2], Ip[3], Tf->SegCs,
Tf->Eip); Tf->Eip);
DPRINT("VTf %x VTf->regs %x\n", VTf, VTf->regs); DPRINT("VTf %x VTf->regs %x\n", VTf, VTf->regs);
if (ExceptionNr == 6 && if (ExceptionNr == 6 &&
memcmp(Ip, VTf->regs->RecoveryInstruction, 4) == 0 && memcmp(Ip, VTf->regs->RecoveryInstruction, 4) == 0 &&
(Tf->Cs * 16 + Tf->Eip) == VTf->regs->RecoveryAddress) (Tf->SegCs * 16 + Tf->Eip) == VTf->regs->RecoveryAddress)
{ {
*VTf->regs->PStatus = STATUS_SUCCESS; *VTf->regs->PStatus = STATUS_SUCCESS;
return(1); return(1);

30
reactos/ntoskrnl/ke/profile.c
View file

@ -38,10 +38,10 @@ KeInitializeProfile(PKPROFILE Profile,
/* Copy all the settings we were given */ /* Copy all the settings we were given */
Profile->Process = Process; Profile->Process = Process;
Profile->RegionStart = ImageBase; Profile->RangeBase = ImageBase;
Profile->BucketShift = BucketSize - 2; /* See ntinternals.net -- Alex */ Profile->BucketShift = BucketSize - 2; /* See ntinternals.net -- Alex */
Profile->RegionEnd = (PVOID)((ULONG_PTR)ImageBase + ImageSize); Profile->RangeLimit = (PVOID)((ULONG_PTR)ImageBase + ImageSize);
Profile->Active = FALSE; Profile->Started = FALSE;
Profile->Source = ProfileSource; Profile->Source = ProfileSource;
Profile->Affinity = Affinity; Profile->Affinity = Affinity;
} }
@ -68,11 +68,11 @@ KeStartProfile(PKPROFILE Profile,
KeAcquireSpinLockAtDpcLevel(&KiProfileLock); KeAcquireSpinLockAtDpcLevel(&KiProfileLock);
/* Make sure it's not running */ /* Make sure it's not running */
if (!Profile->Active) { if (!Profile->Started) {
/* Set it as active */ /* Set it as Started */
Profile->Buffer = Buffer; Profile->Buffer = Buffer;
Profile->Active = TRUE; Profile->Started = TRUE;
/* Get the process, if any */ /* Get the process, if any */
ProfileProcess = Profile->Process; ProfileProcess = Profile->Process;
@ -80,11 +80,11 @@ KeStartProfile(PKPROFILE Profile,
/* Insert it into the Process List or Global List */ /* Insert it into the Process List or Global List */
if (ProfileProcess) { if (ProfileProcess) {
InsertTailList(&ProfileProcess->ProfileListHead, &Profile->ListEntry); InsertTailList(&ProfileProcess->ProfileListHead, &Profile->ProfileListEntry);
} else { } else {
InsertTailList(&KiProfileListHead, &Profile->ListEntry); InsertTailList(&KiProfileListHead, &Profile->ProfileListEntry);
} }
/* Check if this type of profile (source) is already running */ /* Check if this type of profile (source) is already running */
@ -134,11 +134,11 @@ KeStopProfile(PKPROFILE Profile)
KeAcquireSpinLockAtDpcLevel(&KiProfileLock); KeAcquireSpinLockAtDpcLevel(&KiProfileLock);
/* Make sure it's running */ /* Make sure it's running */
if (Profile->Active) { if (Profile->Started) {
/* Remove it from the list and disable */ /* Remove it from the list and disable */
RemoveEntryList(&Profile->ListEntry); RemoveEntryList(&Profile->ProfileListEntry);
Profile->Active = FALSE; Profile->Started = FALSE;
/* Find the Source Object */ /* Find the Source Object */
LIST_FOR_EACH(CurrentSource, &KiProfileSourceListHead, KPROFILE_SOURCE_OBJECT, ListEntry) LIST_FOR_EACH(CurrentSource, &KiProfileSourceListHead, KPROFILE_SOURCE_OBJECT, ListEntry)
@ -227,19 +227,19 @@ KiParseProfileList(IN PKTRAP_FRAME TrapFrame,
PKPROFILE Profile; PKPROFILE Profile;
/* Loop the List */ /* Loop the List */
LIST_FOR_EACH(Profile, ListHead, KPROFILE, ListEntry) LIST_FOR_EACH(Profile, ListHead, KPROFILE, ProfileListEntry)
{ {
/* Check if the source is good, and if it's within the range */ /* Check if the source is good, and if it's within the range */
if ((Profile->Source != Source) || if ((Profile->Source != Source) ||
(TrapFrame->Eip < (ULONG_PTR)Profile->RegionStart) || (TrapFrame->Eip < (ULONG_PTR)Profile->RangeBase) ||
(TrapFrame->Eip > (ULONG_PTR)Profile->RegionEnd)) { (TrapFrame->Eip > (ULONG_PTR)Profile->RangeLimit)) {
continue; continue;
} }
/* Get the Pointer to the Bucket Value representing this EIP */ /* Get the Pointer to the Bucket Value representing this EIP */
BucketValue = (PULONG)((((ULONG_PTR)Profile->Buffer + BucketValue = (PULONG)((((ULONG_PTR)Profile->Buffer +
(TrapFrame->Eip - (ULONG_PTR)Profile->RegionStart)) (TrapFrame->Eip - (ULONG_PTR)Profile->RangeBase))
>> Profile->BucketShift) &~ 0x3); >> Profile->BucketShift) &~ 0x3);
/* Increment the value */ /* Increment the value */

16
reactos/ntoskrnl/mm/i386/pfault.c
View file

@ -36,14 +36,14 @@ ULONG KiPageFaultHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
ASSERT(ExceptionNr == 14); ASSERT(ExceptionNr == 14);
/* Store the exception number in an unused field in the trap frame. */ /* Store the exception number in an unused field in the trap frame. */
Tf->DebugArgMark = 14; Tf->DbgArgMark = 14;
/* get the faulting address */ /* get the faulting address */
cr2 = Ke386GetCr2(); cr2 = Ke386GetCr2();
Tf->DebugPointer = cr2; Tf->DbgArgPointer = cr2;
/* it's safe to enable interrupts after cr2 has been saved */ /* it's safe to enable interrupts after cr2 has been saved */
if (Tf->Eflags & (X86_EFLAGS_VM|X86_EFLAGS_IF)) if (Tf->EFlags & (X86_EFLAGS_VM|X86_EFLAGS_IF))
{ {
Ke386EnableInterrupts(); Ke386EnableInterrupts();
} }
@ -51,22 +51,22 @@ ULONG KiPageFaultHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
if (cr2 >= (ULONG_PTR)MmSystemRangeStart) if (cr2 >= (ULONG_PTR)MmSystemRangeStart)
{ {
/* check for an invalid page directory in kernel mode */ /* check for an invalid page directory in kernel mode */
if (!(Tf->ErrorCode & 0x5) && Mmi386MakeKernelPageTableGlobal((PVOID)cr2)) if (!(Tf->ErrCode & 0x5) && Mmi386MakeKernelPageTableGlobal((PVOID)cr2))
{ {
return 0; return 0;
} }
/* check for non executable memory in kernel mode */ /* check for non executable memory in kernel mode */
if (Ke386NoExecute && Tf->ErrorCode & 0x10) if (Ke386NoExecute && Tf->ErrCode & 0x10)
{ {
KEBUGCHECKWITHTF(ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY, 0, 0, 0, 0, Tf); KEBUGCHECKWITHTF(ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY, 0, 0, 0, 0, Tf);
} }
} }
Mode = Tf->ErrorCode & 0x4 ? UserMode : KernelMode; Mode = Tf->ErrCode & 0x4 ? UserMode : KernelMode;
/* handle the fault */ /* handle the fault */
if (Tf->ErrorCode & 0x1) if (Tf->ErrCode & 0x1)
{ {
Status = MmAccessFault(Mode, cr2, FALSE); Status = MmAccessFault(Mode, cr2, FALSE);
} }
@ -76,7 +76,7 @@ ULONG KiPageFaultHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
} }
/* handle the return for v86 mode */ /* handle the return for v86 mode */
if (Tf->Eflags & X86_EFLAGS_VM) if (Tf->EFlags & X86_EFLAGS_VM)
{ {
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {