From c06fa82588b58cde312e72c9daef9f80e1d0c563 Mon Sep 17 00:00:00 2001 From: Alex Ionescu Date: Sun, 27 Nov 2005 19:21:19 +0000 Subject: [PATCH] - Fix compile issues caused by previous patch. - 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 --- reactos/include/ndk/asm.h | 1 + reactos/include/ndk/fixmes.txt | 6 -- reactos/include/ndk/ketypes.h | 19 ++-- reactos/include/ndk/mmtypes.h | 2 + reactos/include/ndk/obtypes.h | 6 +- reactos/include/ndk/pstypes.h | 22 ++-- reactos/ntoskrnl/ke/i386/exp.c | 153 ++++++++++++++-------------- reactos/ntoskrnl/ke/i386/fpu.c | 4 +- reactos/ntoskrnl/ke/i386/irq.c | 28 ++--- reactos/ntoskrnl/ke/i386/thread.c | 6 +- reactos/ntoskrnl/ke/i386/tss.c | 58 +++++------ reactos/ntoskrnl/ke/i386/usertrap.c | 2 +- reactos/ntoskrnl/ke/i386/v86m.c | 80 +++++++-------- reactos/ntoskrnl/ke/profile.c | 30 +++--- reactos/ntoskrnl/mm/i386/pfault.c | 16 +-- 15 files changed, 215 insertions(+), 218 deletions(-) diff --git a/reactos/include/ndk/asm.h b/reactos/include/ndk/asm.h index 94658735aca..2f345309e0a 100644 --- a/reactos/include/ndk/asm.h +++ b/reactos/include/ndk/asm.h @@ -64,6 +64,7 @@ Author: #define KTSS_CR3 0x1C #define KTSS_EFLAGS 0x24 #define KTSS_IOMAPBASE 0x66 +#define KTSS_IO_MAPS 0x68 // // KTHREAD Offsets diff --git a/reactos/include/ndk/fixmes.txt b/reactos/include/ndk/fixmes.txt index a419982f150..b3a07e089ed 100644 --- a/reactos/include/ndk/fixmes.txt +++ b/reactos/include/ndk/fixmes.txt @@ -2,13 +2,7 @@ Complete list of NDK Fixmes before 1.0 Release (Nov 27th 2005) -------------------------------------------------------------- ______________________________________________________________________________________ [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 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 | [MAJOR] - Using incorrect, missing, or invalid names or definitions. diff --git a/reactos/include/ndk/ketypes.h b/reactos/include/ndk/ketypes.h index aad9d30f346..504ea1378cc 100644 --- a/reactos/include/ndk/ketypes.h +++ b/reactos/include/ndk/ketypes.h @@ -350,7 +350,7 @@ typedef struct _CONFIGURATION_COMPONENT_DATA } CONFIGURATION_COMPONENT_DATA, *PCONFIGURATION_COMPONENT_DATA; // -// Kernel Memory Node (FIXME: mmtypes? +// Kernel Memory Node // typedef struct _KNODE { @@ -367,25 +367,26 @@ typedef struct _KNODE } KNODE, *PKNODE; // -// Kernel Profile Object (FIXME: Fix with new defs) +// Kernel Profile Object // typedef struct _KPROFILE { CSHORT Type; CSHORT Size; - LIST_ENTRY ListEntry; - PVOID RegionStart; - PVOID RegionEnd; + LIST_ENTRY ProfileListEntry; + PKPROCESS Process; + PVOID RangeBase; + PVOID RangeLimit; ULONG BucketShift; PVOID Buffer; + ULONG Segment; + KAFFINITY Affinity; KPROFILE_SOURCE Source; - ULONG Affinity; - BOOLEAN Active; - struct _KPROCESS *Process; + BOOLEAN Started; } KPROFILE, *PKPROFILE; // -// Kernel Interrupt Object (FIXME: Verify) +// Kernel Interrupt Object // typedef struct _KINTERRUPT { diff --git a/reactos/include/ndk/mmtypes.h b/reactos/include/ndk/mmtypes.h index 9994de4aa86..11889dbfc75 100644 --- a/reactos/include/ndk/mmtypes.h +++ b/reactos/include/ndk/mmtypes.h @@ -202,6 +202,7 @@ typedef struct _SECTION_IMAGE_INFORMATION // // FIXME: REACTOS SPECIFIC HACK IN EPROCESS // +#ifdef _REACTOS_ typedef struct _MADDRESS_SPACE { struct _MEMORY_AREA *MemoryAreaRoot; @@ -211,6 +212,7 @@ typedef struct _MADDRESS_SPACE PUSHORT PageTableRefCountTable; ULONG PageTableRefCountTableSize; } MADDRESS_SPACE, *PMADDRESS_SPACE; +#endif // // Generic Address Range Structure diff --git a/reactos/include/ndk/obtypes.h b/reactos/include/ndk/obtypes.h index 586d12b4db8..6219d590eeb 100644 --- a/reactos/include/ndk/obtypes.h +++ b/reactos/include/ndk/obtypes.h @@ -341,11 +341,13 @@ typedef struct _OBJECT_HEADER_CREATOR_INFO } OBJECT_HEADER_CREATOR_INFO, *POBJECT_HEADER_CREATOR_INFO; // -// FIXME: Object Header +// Object Header // typedef struct _OBJECT_HEADER { - LIST_ENTRY Entry; +#ifdef _REACTOS_ + LIST_ENTRY Entry; // FIXME: REACTOS ONLY +#endif LONG PointerCount; union { diff --git a/reactos/include/ndk/pstypes.h b/reactos/include/ndk/pstypes.h index f600eda663d..1f366b0fa95 100644 --- a/reactos/include/ndk/pstypes.h +++ b/reactos/include/ndk/pstypes.h @@ -529,10 +529,6 @@ typedef struct _THREAD_BASIC_INFORMATION } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION; #ifndef NTOS_MODE_USER -/* FIXME: see note in mmtypes.h */ -#ifdef _NTOSKRNL_ -#include -#endif // // EPROCESS Quota Structures @@ -690,6 +686,10 @@ typedef struct _ETHREAD UCHAR ActiveFaultCount; /* 24E */ } ETHREAD; +#if defined(_NTOSKRNL_) + #include +#endif + // // Executive Process (EPROCESS) // @@ -818,16 +818,15 @@ typedef struct _EPROCESS MM_AVL_TABLE VadRoot; /* 250 */ ULONG Cookie; /* 270 */ -/*************************************************************** - * REACTOS SPECIFIC START - ***************************************************************/ - /* FIXME WILL BE DEPRECATED WITH PUSHLOCK SUPPORT IN 0.3.0 */ +#ifdef _REACTOS_ + /* FIXME: WILL BE DEPRECATED WITH PUSHLOCK SUPPORT IN 0.3.0*/ KEVENT LockEvent; /* 274 */ ULONG LockCount; /* 284 */ struct _KTHREAD *LockOwner; /* 288 */ - /* FIXME MOVE TO AVL TREES */ + /* FIXME: MOVE TO AVL TREES */ MADDRESS_SPACE AddressSpace; /* 28C */ +#endif } EPROCESS; #include @@ -919,11 +918,12 @@ typedef struct _W32_CALLOUT_DATA OB_DELETE_METHOD WinStaDelete; OB_PARSE_METHOD WinStaParse; OB_OPEN_METHOD WinStaOpen; - - /* FIXME: These are ROS-ONLY and are fixed in a future local patch */ +#ifdef _REACTOS_ + /* FIXME: REACTOS ONLY */ OB_FIND_METHOD WinStaFind; OB_OPEN_METHOD WinStaCreate; OB_CREATE_METHOD DesktopCreate; +#endif } W32_CALLOUT_DATA, *PW32_CALLOUT_DATA; #endif // !NTOS_MODE_USER diff --git a/reactos/ntoskrnl/ke/i386/exp.c b/reactos/ntoskrnl/ke/i386/exp.c index af8c5efb768..a5275b61dbb 100644 --- a/reactos/ntoskrnl/ke/i386/exp.c +++ b/reactos/ntoskrnl/ke/i386/exp.c @@ -167,7 +167,7 @@ KiKernelTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2) { Er.ExceptionCode = STATUS_ACCESS_VIOLATION; Er.NumberParameters = 2; - Er.ExceptionInformation[0] = Tf->ErrorCode & 0x1; + Er.ExceptionInformation[0] = Tf->ErrCode & 0x1; Er.ExceptionInformation[1] = (ULONG)Cr2; } else @@ -194,6 +194,7 @@ KiKernelTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2) VOID KiDoubleFaultHandler(VOID) { +#if 0 unsigned int cr2; ULONG StackLimit; ULONG StackBase; @@ -212,7 +213,7 @@ KiDoubleFaultHandler(VOID) #endif OldTss = KeGetCurrentKPCR()->TSS; - Esp0 = OldTss->Esp; + Esp0 = OldTss->Esp0; /* Get CR2 */ cr2 = Ke386GetCr2(); @@ -394,7 +395,7 @@ KiDoubleFaultHandler(VOID) } #endif } - +#endif DbgPrint("\n"); for(;;); } @@ -406,8 +407,8 @@ KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2) ULONG cr3_; ULONG StackLimit; ULONG Esp0; - ULONG ExceptionNr = (ULONG)Tf->DebugArgMark; - ULONG cr2 = (ULONG)Tf->DebugPointer; + ULONG ExceptionNr = (ULONG)Tf->DbgArgMark; + ULONG cr2 = (ULONG)Tf->DbgArgPointer; Esp0 = (ULONG)Tf; @@ -417,14 +418,14 @@ KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2) if (ExceptionNr < ARRAY_SIZE(ExceptionTypeStrings)) { DbgPrint("%s Exception: %d(%x)\n", ExceptionTypeStrings[ExceptionNr], - ExceptionNr, Tf->ErrorCode&0xffff); + ExceptionNr, Tf->ErrCode&0xffff); } 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(), - Tf->Cs&0xffff, Tf->Eip); + Tf->SegCs&0xffff, Tf->Eip); KeRosPrintAddress((PVOID)Tf->Eip); DbgPrint("\n"); Ke386GetPageTableDirectory(cr3_); @@ -442,13 +443,13 @@ KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2) PsGetCurrentThread()->Cid.UniqueThread); } DbgPrint("\n"); - DbgPrint("DS %x ES %x FS %x GS %x\n", Tf->Ds&0xffff, Tf->Es&0xffff, - Tf->Fs&0xffff, Tf->Gs&0xfff); + DbgPrint("DS %x ES %x FS %x GS %x\n", Tf->SegDs&0xffff, Tf->SegEs&0xffff, + Tf->SegFs&0xffff, Tf->SegGs&0xfff); 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, Tf->Ebp, Tf->Esi, Esp0); - DbgPrint("EDI: %.8x EFLAGS: %.8x ", Tf->Edi, Tf->Eflags); - if ((Tf->Cs&0xffff) == KGDT_R0_CODE) + DbgPrint("EDI: %.8x EFLAGS: %.8x ", Tf->Edi, Tf->EFlags); + if ((Tf->SegCs&0xffff) == KGDT_R0_CODE) { DbgPrint("kESP %.8x ", Esp0); if (PsGetCurrentThread() != NULL) @@ -490,21 +491,21 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr) ASSERT(ExceptionNr != 14); /* 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 */ Esp0 = (ULONG)&Tf->Eip; /* Get CR2 */ cr2 = Ke386GetCr2(); - Tf->DebugPointer = cr2; + Tf->DbgArgPointer = cr2; /* * 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)); } @@ -561,7 +562,7 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr) /* * 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)); } @@ -576,15 +577,15 @@ NTAPI KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame) { /* 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 TrapFrame->Esp; + return TrapFrame->HardwareEsp; } else { /* Edited frame */ - if (!(TrapFrame->Cs & FRAME_EDITED)) + if (!(TrapFrame->SegCs & FRAME_EDITED)) { /* Return edited value */ return TrapFrame->TempEsp; @@ -592,7 +593,7 @@ KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame) else { /* Virgin frame, calculate */ - return (ULONG)&TrapFrame->Esp; + return (ULONG)&TrapFrame->HardwareEsp; } } } @@ -605,10 +606,10 @@ KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame, ULONG Previous = KiEspFromTrapFrame(TrapFrame); /* 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 */ - TrapFrame->Esp = Esp; + TrapFrame->HardwareEsp = Esp; } else { @@ -619,7 +620,7 @@ KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame, } /* Create an edit frame, check if it was alrady */ - if (!(TrapFrame->Cs & FRAME_EDITED)) + if (!(TrapFrame->SegCs & FRAME_EDITED)) { /* Update the value */ TrapFrame->TempEsp = Esp; @@ -630,8 +631,8 @@ KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame, if (Previous != Esp) { /* Save CS */ - TrapFrame->TempCs = TrapFrame->Cs; - TrapFrame->Cs &= ~FRAME_EDITED; + TrapFrame->TempSegCs = TrapFrame->SegCs; + TrapFrame->SegCs &= ~FRAME_EDITED; /* Save ESP */ TrapFrame->TempEsp = Esp; @@ -645,15 +646,15 @@ NTAPI KiSsFromTrapFrame(IN PKTRAP_FRAME TrapFrame) { /* If this was V86 Mode */ - if (TrapFrame->Eflags & X86_EFLAGS_VM) + if (TrapFrame->EFlags & X86_EFLAGS_VM) { /* 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 */ - return TrapFrame->Ss | RPL_MASK; + return TrapFrame->HardwareSegSs | RPL_MASK; } else { @@ -671,15 +672,15 @@ KiSsToTrapFrame(IN PKTRAP_FRAME TrapFrame, Ss &= 0xFFFF; /* If this was V86 Mode */ - if (TrapFrame->Eflags & X86_EFLAGS_VM) + if (TrapFrame->EFlags & X86_EFLAGS_VM) { /* 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 */ - 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 */ if ((Context->EFlags & X86_EFLAGS_VM) != - (TrapFrame->Eflags & X86_EFLAGS_VM)) + (TrapFrame->EFlags & X86_EFLAGS_VM)) { /* We did, remember this for later */ V86Switch = TRUE; } /* Copy EFLAGS. FIXME: Needs to be sanitized */ - TrapFrame->Eflags = Context->EFlags; + TrapFrame->EFlags = Context->EFlags; /* Copy EBP and EIP */ TrapFrame->Ebp = Context->Ebp; TrapFrame->Eip = Context->Eip; /* Check if we were in V86 Mode */ - if (TrapFrame->Eflags & X86_EFLAGS_VM) + if (TrapFrame->EFlags & X86_EFLAGS_VM) { /* Simply copy the CS value */ - TrapFrame->Cs = Context->SegCs; + TrapFrame->SegCs = Context->SegCs; } else { /* 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 */ - if ((PreviousMode != KernelMode) && (TrapFrame->Cs < 8)) + if ((PreviousMode != KernelMode) && (TrapFrame->SegCs < 8)) { /* 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) { /* Check if we were in V86 Mode */ - if (TrapFrame->Eflags & X86_EFLAGS_VM) + if (TrapFrame->EFlags & X86_EFLAGS_VM) { /* Copy the V86 Segments directlry */ - TrapFrame->V86_Ds = Context->SegDs; - TrapFrame->V86_Es = Context->SegEs; - TrapFrame->V86_Fs = Context->SegFs; - TrapFrame->V86_Gs = Context->SegGs; + TrapFrame->V86Ds = Context->SegDs; + TrapFrame->V86Es = Context->SegEs; + TrapFrame->V86Fs = Context->SegFs; + TrapFrame->V86Gs = Context->SegGs; } - else if (!(TrapFrame->Cs & MODE_MASK)) + else if (!(TrapFrame->SegCs & MODE_MASK)) { /* For user mode, write the values directly */ - TrapFrame->Ds = KGDT_R3_DATA | RPL_MASK; - TrapFrame->Es = KGDT_R3_DATA | RPL_MASK; - TrapFrame->Fs = Context->SegFs; - TrapFrame->Gs = 0; + TrapFrame->SegDs = KGDT_R3_DATA | RPL_MASK; + TrapFrame->SegEs = KGDT_R3_DATA | RPL_MASK; + TrapFrame->SegFs = Context->SegFs; + TrapFrame->SegGs = 0; } else { /* For kernel-mode, return the values */ - TrapFrame->Ds = Context->SegDs; - TrapFrame->Es = Context->SegEs; - TrapFrame->Fs = Context->SegFs; + TrapFrame->SegDs = Context->SegDs; + TrapFrame->SegEs = Context->SegEs; + TrapFrame->SegFs = Context->SegFs; /* 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 */ - TrapFrame->Gs = 0; + TrapFrame->SegGs = 0; } else { /* 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 */ Context->Ebp = TrapFrame->Ebp; Context->Eip = TrapFrame->Eip; - Context->EFlags = TrapFrame->Eflags; + Context->EFlags = TrapFrame->EFlags; /* Return the correct CS */ - if (!(TrapFrame->Cs & FRAME_EDITED) && - !(TrapFrame->Eflags & X86_EFLAGS_VM)) + if (!(TrapFrame->SegCs & FRAME_EDITED) && + !(TrapFrame->EFlags & X86_EFLAGS_VM)) { /* Get it from the Temp location */ - Context->SegCs = TrapFrame->TempCs & 0xFFFF; + Context->SegCs = TrapFrame->TempSegCs & 0xFFFF; } else { /* Return it directly */ - Context->SegCs = TrapFrame->Cs & 0xFFFF; + Context->SegCs = TrapFrame->SegCs & 0xFFFF; } /* Get the Ss and ESP */ @@ -852,31 +853,31 @@ KeTrapFrameToContext(IN PKTRAP_FRAME TrapFrame, if ((Context->ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS) { /* Do V86 Mode first */ - if (TrapFrame->Eflags & X86_EFLAGS_VM) + if (TrapFrame->EFlags & X86_EFLAGS_VM) { /* Return from the V86 location */ - Context->SegGs = TrapFrame->V86_Gs & 0xFFFF; - Context->SegFs = TrapFrame->V86_Fs & 0xFFFF; - Context->SegEs = TrapFrame->V86_Es & 0xFFFF; - Context->SegDs = TrapFrame->V86_Ds & 0xFFFF; + Context->SegGs = TrapFrame->V86Gs & 0xFFFF; + Context->SegFs = TrapFrame->V86Fs & 0xFFFF; + Context->SegEs = TrapFrame->V86Es & 0xFFFF; + Context->SegDs = TrapFrame->V86Ds & 0xFFFF; } else { /* Check if this was a Kernel Trap */ - if (TrapFrame->Cs == KGDT_R0_CODE) + if (TrapFrame->SegCs == KGDT_R0_CODE) { /* Set valid selectors */ - TrapFrame->Gs = 0; - TrapFrame->Fs = KGDT_R0_PCR; - TrapFrame->Es = KGDT_R3_DATA | RPL_MASK; - TrapFrame->Ds = KGDT_R3_DATA | RPL_MASK; + TrapFrame->SegGs = 0; + TrapFrame->SegFs = KGDT_R0_PCR; + TrapFrame->SegEs = KGDT_R3_DATA | RPL_MASK; + TrapFrame->SegDs = KGDT_R3_DATA | RPL_MASK; } /* Return the segments */ - Context->SegGs = TrapFrame->Gs & 0xFFFF; - Context->SegFs = TrapFrame->Fs & 0xFFFF; - Context->SegEs = TrapFrame->Es & 0xFFFF; - Context->SegDs = TrapFrame->Ds & 0xFFFF; + Context->SegGs = TrapFrame->SegGs & 0xFFFF; + Context->SegFs = TrapFrame->SegFs & 0xFFFF; + Context->SegEs = TrapFrame->SegEs & 0xFFFF; + Context->SegDs = TrapFrame->SegDs & 0xFFFF; } } diff --git a/reactos/ntoskrnl/ke/i386/fpu.c b/reactos/ntoskrnl/ke/i386/fpu.c index 8662f49ff80..a9908da410f 100644 --- a/reactos/ntoskrnl/ke/i386/fpu.c +++ b/reactos/ntoskrnl/ke/i386/fpu.c @@ -373,7 +373,7 @@ KiHandleFpuFault(PKTRAP_FRAME Tf, ULONG ExceptionNr) (void) cr0; 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); /* disable scheduler, clear TS in cr0 */ @@ -485,7 +485,7 @@ KiHandleFpuFault(PKTRAP_FRAME Tf, ULONG ExceptionNr) } 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", (PreviousMode != KernelMode) ? ("UserMode") : ("KernelMode")); diff --git a/reactos/ntoskrnl/ke/i386/irq.c b/reactos/ntoskrnl/ke/i386/irq.c index abc833f7e83..cb0fd4d4d66 100644 --- a/reactos/ntoskrnl/ke/i386/irq.c +++ b/reactos/ntoskrnl/ke/i386/irq.c @@ -170,42 +170,42 @@ STATIC VOID KeIRQTrapFrameToTrapFrame(PKIRQ_TRAPFRAME IrqTrapFrame, PKTRAP_FRAME TrapFrame) { - TrapFrame->Gs = (USHORT)IrqTrapFrame->Gs; - TrapFrame->Fs = (USHORT)IrqTrapFrame->Fs; - TrapFrame->Es = (USHORT)IrqTrapFrame->Es; - TrapFrame->Ds = (USHORT)IrqTrapFrame->Ds; + TrapFrame->SegGs = (USHORT)IrqTrapFrame->Gs; + TrapFrame->SegFs = (USHORT)IrqTrapFrame->Fs; + TrapFrame->SegEs = (USHORT)IrqTrapFrame->Es; + TrapFrame->SegDs = (USHORT)IrqTrapFrame->Ds; TrapFrame->Eax = IrqTrapFrame->Eax; TrapFrame->Ecx = IrqTrapFrame->Ecx; TrapFrame->Edx = IrqTrapFrame->Edx; TrapFrame->Ebx = IrqTrapFrame->Ebx; - TrapFrame->Esp = IrqTrapFrame->Esp; + TrapFrame->HardwareEsp = IrqTrapFrame->Esp; TrapFrame->Ebp = IrqTrapFrame->Ebp; TrapFrame->Esi = IrqTrapFrame->Esi; TrapFrame->Edi = IrqTrapFrame->Edi; TrapFrame->Eip = IrqTrapFrame->Eip; - TrapFrame->Cs = IrqTrapFrame->Cs; - TrapFrame->Eflags = IrqTrapFrame->Eflags; + TrapFrame->SegCs = IrqTrapFrame->Cs; + TrapFrame->EFlags = IrqTrapFrame->Eflags; } STATIC VOID KeTrapFrameToIRQTrapFrame(PKTRAP_FRAME TrapFrame, PKIRQ_TRAPFRAME IrqTrapFrame) { - IrqTrapFrame->Gs = TrapFrame->Gs; - IrqTrapFrame->Fs = TrapFrame->Fs; - IrqTrapFrame->Es = TrapFrame->Es; - IrqTrapFrame->Ds = TrapFrame->Ds; + IrqTrapFrame->Gs = TrapFrame->SegGs; + IrqTrapFrame->Fs = TrapFrame->SegFs; + IrqTrapFrame->Es = TrapFrame->SegEs; + IrqTrapFrame->Ds = TrapFrame->SegDs; IrqTrapFrame->Eax = TrapFrame->Eax; IrqTrapFrame->Ecx = TrapFrame->Ecx; IrqTrapFrame->Edx = TrapFrame->Edx; IrqTrapFrame->Ebx = TrapFrame->Ebx; - IrqTrapFrame->Esp = TrapFrame->Esp; + IrqTrapFrame->Esp = TrapFrame->HardwareEsp; IrqTrapFrame->Ebp = TrapFrame->Ebp; IrqTrapFrame->Esi = TrapFrame->Esi; IrqTrapFrame->Edi = TrapFrame->Edi; IrqTrapFrame->Eip = TrapFrame->Eip; - IrqTrapFrame->Cs = TrapFrame->Cs; - IrqTrapFrame->Eflags = TrapFrame->Eflags; + IrqTrapFrame->Cs = TrapFrame->SegCs; + IrqTrapFrame->Eflags = TrapFrame->EFlags; } VOID STDCALL diff --git a/reactos/ntoskrnl/ke/i386/thread.c b/reactos/ntoskrnl/ke/i386/thread.c index d0f92e16354..7a9e8bbd90d 100644 --- a/reactos/ntoskrnl/ke/i386/thread.c +++ b/reactos/ntoskrnl/ke/i386/thread.c @@ -95,11 +95,11 @@ Ke386InitThreadWithContext(PKTHREAD Thread, } /* Enable Interrupts and disable some unsupported flags right now */ - TrapFrame->Eflags = Context->EFlags | X86_EFLAGS_IF; - TrapFrame->Eflags &= ~(X86_EFLAGS_VM | X86_EFLAGS_NT | X86_EFLAGS_IOPL); + TrapFrame->EFlags = Context->EFlags | X86_EFLAGS_IF; + TrapFrame->EFlags &= ~(X86_EFLAGS_VM | X86_EFLAGS_NT | X86_EFLAGS_IOPL); /* Set the previous mode as user */ - TrapFrame->PreviousMode = UserMode; + TrapFrame->PreviousPreviousMode = UserMode; /* Terminate the Exception Handler List */ TrapFrame->ExceptionList = (PVOID)0xFFFFFFFF; diff --git a/reactos/ntoskrnl/ke/i386/tss.c b/reactos/ntoskrnl/ke/i386/tss.c index f220a356046..cf37e9c9480 100644 --- a/reactos/ntoskrnl/ke/i386/tss.c +++ b/reactos/ntoskrnl/ke/i386/tss.c @@ -16,6 +16,11 @@ /* GLOBALS *******************************************************************/ +typedef struct _KTSSNOIOPM +{ + UCHAR TssData[KTSS_IO_MAPS]; +} KTSSNOIOPM; + static KTSS* Ki386TssArray[MAXIMUM_PROCESSORS]; PVOID Ki386InitialStackArray[MAXIMUM_PROCESSORS]; static KTSSNOIOPM* Ki386TrapTssArray[MAXIMUM_PROCESSORS]; @@ -38,7 +43,7 @@ Ke386IoSetAccessProcess(PEPROCESS Process, BOOL EnableDisable) USHORT Offset; if(EnableDisable > 1) return FALSE; - Offset = (EnableDisable) ? (USHORT) FIELD_OFFSET(KTSS, IoBitmap) : 0xffff; + Offset = (EnableDisable) ? (USHORT) FIELD_OFFSET(KTSS, IoMaps) : 0xffff; oldIrql = KeRaiseIrqlToSynchLevel(); Process->Pcb.IopmOffset = Offset; @@ -62,7 +67,7 @@ Ke386SetIoAccessMap(DWORD MapNumber, PULONG IOMapStart) oldIrql = KeRaiseIrqlToSynchLevel(); - memcpy(&KeGetCurrentKPCR()->TSS->IoBitmap[0], + memcpy(&KeGetCurrentKPCR()->TSS->IoMaps[0], IOMapStart, 0x2000); @@ -85,7 +90,7 @@ Ke386QueryIoAccessMap(DWORD MapNumber, PULONG IOMapStart) oldIrql = KeRaiseIrqlToSynchLevel(); memcpy(IOMapStart, - &KeGetCurrentKPCR()->TSS->IoBitmap[0], + &KeGetCurrentKPCR()->TSS->IoMaps[0], 0x2000); KeLowerIrql(oldIrql); @@ -96,8 +101,8 @@ VOID Ki386ApplicationProcessorInitializeTSS(VOID) { ULONG cr3_; - KTSS* Tss; - KTSSNOIOPM* TrapTss; + PKTSS Tss; + PKTSS TrapTss; PVOID TrapStack; ULONG Id; PUSHORT Gdt; @@ -113,7 +118,7 @@ Ki386ApplicationProcessorInitializeTSS(VOID) TrapStack = ExAllocatePool(NonPagedPool, MM_STACK_SIZE); Ki386TssArray[Id] = Tss; - Ki386TrapTssArray[Id] = TrapTss; + Ki386TrapTssArray[Id] = (KTSSNOIOPM*)TrapTss; Ki386TrapStackArray[Id] = TrapStack; KeGetCurrentKPCR()->TSS = Tss; @@ -121,8 +126,7 @@ Ki386ApplicationProcessorInitializeTSS(VOID) Tss->Esp0 = (ULONG)Ki386InitialStackArray[Id] + MM_STACK_SIZE; /* FIXME: - sizeof(FX_SAVE_AREA)? */ Tss->Ss0 = KGDT_R0_DATA; Tss->IoMapBase = 0xFFFF; /* No i/o bitmap */ - Tss->IoBitmap[8192] = 0xFF; - Tss->Ldt = 0; + Tss->LDT = 0; /* * Initialize a descriptor for the TSS @@ -137,20 +141,16 @@ Ki386ApplicationProcessorInitializeTSS(VOID) ((base & 0xFF000000) >> 16)); /* 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->Ss0 = KGDT_R0_DATA; - TrapTss->Esp = ((ULONG)TrapStack + MM_STACK_SIZE); /* FIXME: - sizeof(FX_SAVE_AREA)? */ TrapTss->Cs = KGDT_R0_CODE; TrapTss->Eip = (ULONG)KiTrap8; - TrapTss->Ss = KGDT_R0_DATA; TrapTss->Ds = KGDT_R0_DATA; TrapTss->Es = KGDT_R0_DATA; TrapTss->Fs = KGDT_R0_PCR; TrapTss->IoMapBase = 0xFFFF; /* No i/o bitmap */ - TrapTss->IoBitmap[0] = 0xFF; - TrapTss->Ldt = 0; - TrapTss->Cr3 = cr3_; + TrapTss->LDT = 0; /* * Initialize a descriptor for the trap TSS. @@ -185,6 +185,7 @@ Ki386BootInitializeTSS(VOID) ULONG cr3_; extern unsigned int trap_stack, trap_stack_top; unsigned int base, length; + PKTSS Tss; Ke386GetPageTableDirectory(cr3_); @@ -196,10 +197,8 @@ Ki386BootInitializeTSS(VOID) /* Initialize the boot TSS. */ KiBootTss.Esp0 = (ULONG)init_stack_top - sizeof(FX_SAVE_AREA); KiBootTss.Ss0 = KGDT_R0_DATA; - // KiBootTss.IoMapBase = FIELD_OFFSET(KTSS, IoBitmap); 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 @@ -214,20 +213,17 @@ Ki386BootInitializeTSS(VOID) ((base & 0xFF000000) >> 16); /* Initialize the TSS used for handling double faults. */ - KiBootTrapTss.Eflags = 0; - KiBootTrapTss.Esp0 = (ULONG)trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */ - KiBootTrapTss.Ss0 = KGDT_R0_DATA; - KiBootTrapTss.Esp = (ULONG)trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */ - KiBootTrapTss.Cs = KGDT_R0_CODE; - KiBootTrapTss.Eip = (ULONG)KiTrap8; - KiBootTrapTss.Ss = KGDT_R0_DATA; - KiBootTrapTss.Ds = KGDT_R0_DATA; - KiBootTrapTss.Es = KGDT_R0_DATA; - KiBootTrapTss.Fs = KGDT_R0_PCR; - KiBootTrapTss.IoMapBase = 0xFFFF; /* No i/o bitmap */ - KiBootTrapTss.IoBitmap[0] = 0xFF; - KiBootTrapTss.Ldt = 0x0; - KiBootTrapTss.Cr3 = cr3_; + Tss = (PKTSS)&KiBootTrapTss; + Tss->Flags = 0; + Tss->Esp0 = (ULONG)trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */ + Tss->Ss0 = KGDT_R0_DATA; + Tss->Cs = KGDT_R0_CODE; + Tss->Eip = (ULONG)KiTrap8; + Tss->Ds = KGDT_R0_DATA; + Tss->Es = KGDT_R0_DATA; + Tss->Fs = KGDT_R0_PCR; + Tss->IoMapBase = 0xFFFF; /* No i/o bitmap */ + Tss->LDT = 0x0; /* * Initialize a descriptor for the trap TSS. diff --git a/reactos/ntoskrnl/ke/i386/usertrap.c b/reactos/ntoskrnl/ke/i386/usertrap.c index 2710823f319..cb4c29facbf 100644 --- a/reactos/ntoskrnl/ke/i386/usertrap.c +++ b/reactos/ntoskrnl/ke/i386/usertrap.c @@ -117,7 +117,7 @@ KiUserTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2) if (ExceptionNr == 14) { Er.NumberParameters = 2; - Er.ExceptionInformation[0] = Tf->ErrorCode & 0x1; + Er.ExceptionInformation[0] = Tf->ErrCode & 0x1; Er.ExceptionInformation[1] = (ULONG)Cr2; } else diff --git a/reactos/ntoskrnl/ke/i386/v86m.c b/reactos/ntoskrnl/ke/i386/v86m.c index 07646d3bd9b..df5e988a5fc 100644 --- a/reactos/ntoskrnl/ke/i386/v86m.c +++ b/reactos/ntoskrnl/ke/i386/v86m.c @@ -37,12 +37,12 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) ULONG i = 0; BOOL Exit = FALSE; - ip = (PUCHAR)((Tf->Cs & 0xFFFF) * 16 + (Tf->Eip & 0xFFFF)); - sp = (PUSHORT)((Tf->Ss & 0xFFFF) * 16 + (Tf->Esp & 0xFFFF)); + ip = (PUCHAR)((Tf->SegCs & 0xFFFF) * 16 + (Tf->Eip & 0xFFFF)); + sp = (PUSHORT)((Tf->HardwareSegSs & 0xFFFF) * 16 + (Tf->HardwareEsp & 0xFFFF)); dsp = (PULONG)sp; 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) { @@ -113,9 +113,9 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) Tf->Eip++; if (!BigAddressPrefix) { - Tf->Esp = Tf->Esp - 2; + Tf->HardwareEsp = Tf->HardwareEsp - 2; sp = sp - 1; - sp[0] = (USHORT)(Tf->Eflags & 0xFFFF); + sp[0] = (USHORT)(Tf->EFlags & 0xFFFF); if (VTf->regs->Vif == 1) { sp[0] = (USHORT)(sp[0] | INTERRUPT_FLAG); @@ -127,9 +127,9 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) } else { - Tf->Esp = Tf->Esp - 4; + Tf->HardwareEsp = Tf->HardwareEsp - 4; dsp = dsp - 1; - dsp[0] = Tf->Eflags; + dsp[0] = Tf->EFlags; dsp[0] = dsp[0] & VALID_FLAGS; if (VTf->regs->Vif == 1) { @@ -157,9 +157,9 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) Tf->Eip++; if (!BigAddressPrefix) { - Tf->Eflags = Tf->Eflags & (~0xFFFF); - Tf->Eflags = Tf->Eflags | (sp[0] & VALID_FLAGS); - if (Tf->Eflags & INTERRUPT_FLAG) + Tf->EFlags = Tf->EFlags & (~0xFFFF); + Tf->EFlags = Tf->EFlags | (sp[0] & VALID_FLAGS); + if (Tf->EFlags & INTERRUPT_FLAG) { VTf->regs->Vif = 1; } @@ -167,12 +167,12 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) { VTf->regs->Vif = 0; } - Tf->Eflags = Tf->Eflags | INTERRUPT_FLAG; - Tf->Esp = Tf->Esp + 2; + Tf->EFlags = Tf->EFlags | INTERRUPT_FLAG; + Tf->HardwareEsp = Tf->HardwareEsp + 2; } else { - Tf->Eflags = Tf->Eflags | (dsp[0] & VALID_FLAGS); + Tf->EFlags = Tf->EFlags | (dsp[0] & VALID_FLAGS); if (dsp[0] & INTERRUPT_FLAG) { VTf->regs->Vif = 1; @@ -181,8 +181,8 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) { VTf->regs->Vif = 0; } - Tf->Eflags = Tf->Eflags | INTERRUPT_FLAG; - Tf->Esp = Tf->Esp + 2; + Tf->EFlags = Tf->EFlags | INTERRUPT_FLAG; + Tf->HardwareEsp = Tf->HardwareEsp + 2; } return(0); } @@ -199,10 +199,10 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) if (VTf->regs->Flags & KV86M_EMULATE_CLI_STI) { Tf->Eip = sp[0]; - Tf->Cs = sp[1]; - Tf->Eflags = Tf->Eflags & (~0xFFFF); - Tf->Eflags = Tf->Eflags | sp[2]; - if (Tf->Eflags & INTERRUPT_FLAG) + Tf->SegCs = sp[1]; + Tf->EFlags = Tf->EFlags & (~0xFFFF); + Tf->EFlags = Tf->EFlags | sp[2]; + if (Tf->EFlags & INTERRUPT_FLAG) { VTf->regs->Vif = 1; } @@ -210,8 +210,8 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) { VTf->regs->Vif = 0; } - Tf->Eflags = Tf->Eflags & (~INTERRUPT_FLAG); - Tf->Esp = Tf->Esp + 6; + Tf->EFlags = Tf->EFlags & (~INTERRUPT_FLAG); + Tf->HardwareEsp = Tf->HardwareEsp + 6; return(0); } Exit = TRUE; @@ -433,11 +433,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) { Offset = Offset & 0xFFFF; } - Buffer = (PUCHAR)((Tf->Es * 16) + Offset); + Buffer = (PUCHAR)((Tf->SegEs * 16) + Offset); for (; Count > 0; Count--) { WRITE_PORT_UCHAR(Port, *Buffer); - if (Tf->Eflags & DIRECTION_FLAG) + if (Tf->EFlags & DIRECTION_FLAG) { Buffer++; } @@ -480,11 +480,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) } if (BigDataPrefix) { - BufferL = (PULONG)((Tf->Es * 16) + Offset); + BufferL = (PULONG)((Tf->SegEs * 16) + Offset); } else { - BufferS = (PUSHORT)((Tf->Es * 16) + Offset); + BufferS = (PUSHORT)((Tf->SegEs * 16) + Offset); } for (; Count > 0; Count--) { @@ -496,7 +496,7 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) { WRITE_PORT_USHORT((PUSHORT)Port, *BufferS); } - if (Tf->Eflags & DIRECTION_FLAG) + if (Tf->EFlags & DIRECTION_FLAG) { if (BigDataPrefix) { @@ -550,11 +550,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) { Offset = Offset & 0xFFFF; } - Buffer = (PUCHAR)((Tf->Es * 16) + Offset); + Buffer = (PUCHAR)((Tf->SegEs * 16) + Offset); for (; Count > 0; Count--) { *Buffer = READ_PORT_UCHAR(Port); - if (Tf->Eflags & DIRECTION_FLAG) + if (Tf->EFlags & DIRECTION_FLAG) { Buffer++; } @@ -597,11 +597,11 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) } if (BigDataPrefix) { - BufferL = (PULONG)((Tf->Es * 16) + Offset); + BufferL = (PULONG)((Tf->SegEs * 16) + Offset); } else { - BufferS = (PUSHORT)((Tf->Es * 16) + Offset); + BufferS = (PUSHORT)((Tf->SegEs * 16) + Offset); } for (; Count > 0; Count--) { @@ -613,7 +613,7 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) { *BufferS = READ_PORT_USHORT((PUSHORT)Port); } - if (Tf->Eflags & DIRECTION_FLAG) + if (Tf->EFlags & DIRECTION_FLAG) { if (BigDataPrefix) { @@ -651,20 +651,20 @@ KeV86GPF(PKV86M_TRAP_FRAME VTf, PKTRAP_FRAME Tf) inum = ip[1]; entry = ((unsigned int *)0)[inum]; - Tf->Esp = Tf->Esp - 6; + Tf->HardwareEsp = Tf->HardwareEsp - 6; sp = sp - 3; sp[0] = (USHORT)((Tf->Eip & 0xFFFF) + 2); - sp[1] = (USHORT)(Tf->Cs & 0xFFFF); - sp[2] = (USHORT)(Tf->Eflags & 0xFFFF); + sp[1] = (USHORT)(Tf->SegCs & 0xFFFF); + sp[2] = (USHORT)(Tf->EFlags & 0xFFFF); if (VTf->regs->Vif == 1) { sp[2] = (USHORT)(sp[2] | INTERRUPT_FLAG); } DPRINT("sp[0] %x sp[1] %x sp[2] %x\n", sp[0], sp[1], sp[2]); Tf->Eip = entry & 0xFFFF; - Tf->Cs = entry >> 16; - Tf->Eflags = Tf->Eflags & (~TRAP_FLAG); + Tf->SegCs = entry >> 16; + Tf->EFlags = Tf->EFlags & (~TRAP_FLAG); return(0); } @@ -701,16 +701,16 @@ KeV86Exception(ULONG ExceptionNr, PKTRAP_FRAME Tf, ULONG address) /* * 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 " - "Tf->Eip %x\n", ExceptionNr, Ip[0], Ip[1], Ip[2], Ip[3], Tf->Cs, + 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->SegCs, Tf->Eip); DPRINT("VTf %x VTf->regs %x\n", VTf, VTf->regs); if (ExceptionNr == 6 && 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; return(1); diff --git a/reactos/ntoskrnl/ke/profile.c b/reactos/ntoskrnl/ke/profile.c index 224f5ac7b3d..e903050ddf8 100644 --- a/reactos/ntoskrnl/ke/profile.c +++ b/reactos/ntoskrnl/ke/profile.c @@ -38,10 +38,10 @@ KeInitializeProfile(PKPROFILE Profile, /* Copy all the settings we were given */ Profile->Process = Process; - Profile->RegionStart = ImageBase; + Profile->RangeBase = ImageBase; Profile->BucketShift = BucketSize - 2; /* See ntinternals.net -- Alex */ - Profile->RegionEnd = (PVOID)((ULONG_PTR)ImageBase + ImageSize); - Profile->Active = FALSE; + Profile->RangeLimit = (PVOID)((ULONG_PTR)ImageBase + ImageSize); + Profile->Started = FALSE; Profile->Source = ProfileSource; Profile->Affinity = Affinity; } @@ -68,11 +68,11 @@ KeStartProfile(PKPROFILE Profile, KeAcquireSpinLockAtDpcLevel(&KiProfileLock); /* Make sure it's not running */ - if (!Profile->Active) { + if (!Profile->Started) { - /* Set it as active */ + /* Set it as Started */ Profile->Buffer = Buffer; - Profile->Active = TRUE; + Profile->Started = TRUE; /* Get the process, if any */ ProfileProcess = Profile->Process; @@ -80,11 +80,11 @@ KeStartProfile(PKPROFILE Profile, /* Insert it into the Process List or Global List */ if (ProfileProcess) { - InsertTailList(&ProfileProcess->ProfileListHead, &Profile->ListEntry); + InsertTailList(&ProfileProcess->ProfileListHead, &Profile->ProfileListEntry); } else { - InsertTailList(&KiProfileListHead, &Profile->ListEntry); + InsertTailList(&KiProfileListHead, &Profile->ProfileListEntry); } /* Check if this type of profile (source) is already running */ @@ -134,11 +134,11 @@ KeStopProfile(PKPROFILE Profile) KeAcquireSpinLockAtDpcLevel(&KiProfileLock); /* Make sure it's running */ - if (Profile->Active) { + if (Profile->Started) { /* Remove it from the list and disable */ - RemoveEntryList(&Profile->ListEntry); - Profile->Active = FALSE; + RemoveEntryList(&Profile->ProfileListEntry); + Profile->Started = FALSE; /* Find the Source Object */ LIST_FOR_EACH(CurrentSource, &KiProfileSourceListHead, KPROFILE_SOURCE_OBJECT, ListEntry) @@ -227,19 +227,19 @@ KiParseProfileList(IN PKTRAP_FRAME TrapFrame, PKPROFILE Profile; /* 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 */ if ((Profile->Source != Source) || - (TrapFrame->Eip < (ULONG_PTR)Profile->RegionStart) || - (TrapFrame->Eip > (ULONG_PTR)Profile->RegionEnd)) { + (TrapFrame->Eip < (ULONG_PTR)Profile->RangeBase) || + (TrapFrame->Eip > (ULONG_PTR)Profile->RangeLimit)) { continue; } /* Get the Pointer to the Bucket Value representing this EIP */ BucketValue = (PULONG)((((ULONG_PTR)Profile->Buffer + - (TrapFrame->Eip - (ULONG_PTR)Profile->RegionStart)) + (TrapFrame->Eip - (ULONG_PTR)Profile->RangeBase)) >> Profile->BucketShift) &~ 0x3); /* Increment the value */ diff --git a/reactos/ntoskrnl/mm/i386/pfault.c b/reactos/ntoskrnl/mm/i386/pfault.c index 08bcadcef6f..3bfc9da0232 100644 --- a/reactos/ntoskrnl/mm/i386/pfault.c +++ b/reactos/ntoskrnl/mm/i386/pfault.c @@ -36,14 +36,14 @@ ULONG KiPageFaultHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr) ASSERT(ExceptionNr == 14); /* Store the exception number in an unused field in the trap frame. */ - Tf->DebugArgMark = 14; + Tf->DbgArgMark = 14; /* get the faulting address */ cr2 = Ke386GetCr2(); - Tf->DebugPointer = cr2; + Tf->DbgArgPointer = cr2; /* 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(); } @@ -51,22 +51,22 @@ ULONG KiPageFaultHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr) if (cr2 >= (ULONG_PTR)MmSystemRangeStart) { /* 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; } /* 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); } } - Mode = Tf->ErrorCode & 0x4 ? UserMode : KernelMode; + Mode = Tf->ErrCode & 0x4 ? UserMode : KernelMode; /* handle the fault */ - if (Tf->ErrorCode & 0x1) + if (Tf->ErrCode & 0x1) { Status = MmAccessFault(Mode, cr2, FALSE); } @@ -76,7 +76,7 @@ ULONG KiPageFaultHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr) } /* handle the return for v86 mode */ - if (Tf->Eflags & X86_EFLAGS_VM) + if (Tf->EFlags & X86_EFLAGS_VM) { if (!NT_SUCCESS(Status)) { -- 2.17.1