Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-28 01:55:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

FPU/SSE state saving on taskswitching, FPU and SSE exception support.

Browse source 
svn path=/trunk/; revision=11728
This commit is contained in:
Gregor Anich 2004-11-20 23:46:37 +00:00
parent ede5e4a1f9
commit 8119f6f384
21 changed files with 866 additions and 242 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
reactos/include/ntos/tss.h
View file

@ -5,7 +5,8 @@
#ifndef __INCLUDE_DDK_I386_TSS_H #ifndef __INCLUDE_DDK_I386_TSS_H
#define __INCLUDE_DDK_I386_TSS_H #define __INCLUDE_DDK_I386_TSS_H
#define KTSS_ESP0 (0x4) #define KTSS_ESP0 (0x4)
#define KTSS_EFLAGS (0x24)
#define KTSS_IOMAPBASE (0x66) #define KTSS_IOMAPBASE (0x66)
#ifndef __ASM__ #ifndef __ASM__

27
reactos/ntoskrnl/include/internal/i386/fpu.h
View file

@ -20,10 +20,11 @@
#ifndef __NTOSKRNL_INCLUDE_INTERNAL_I386_FPU_H #ifndef __NTOSKRNL_INCLUDE_INTERNAL_I386_FPU_H
#define __NTOSKRNL_INCLUDE_INTERNAL_I386_FPU_H #define __NTOSKRNL_INCLUDE_INTERNAL_I386_FPU_H
extern ULONG HardwareMathSupport; #define SIZEOF_FX_SAVE_AREA 528
VOID #ifndef __ASM__
KiCheckFPU(VOID);
#include <internal/i386/ke.h>
typedef struct _FNSAVE_FORMAT { typedef struct _FNSAVE_FORMAT {
ULONG ControlWord; ULONG ControlWord;
@ -52,7 +53,7 @@ typedef struct _FXSAVE_FORMAT {
UCHAR Reserved4[224]; UCHAR Reserved4[224];
UCHAR Align16Byte[8]; UCHAR Align16Byte[8];
} FXSAVE_FORMAT, *PFXSAVE_FORMAT; } FXSAVE_FORMAT, *PFXSAVE_FORMAT;
typedef struct _FX_SAVE_AREA { typedef struct _FX_SAVE_AREA {
union { union {
FNSAVE_FORMAT FnArea; FNSAVE_FORMAT FnArea;
@ -62,4 +63,22 @@ typedef struct _FX_SAVE_AREA {
ULONG Cr0NpxState; ULONG Cr0NpxState;
} FX_SAVE_AREA, *PFX_SAVE_AREA; } FX_SAVE_AREA, *PFX_SAVE_AREA;
extern ULONG HardwareMathSupport;
VOID
KiCheckFPU(VOID);
NTSTATUS
KiHandleFpuFault(PKTRAP_FRAME Tf, ULONG ExceptionNr);
VOID
KiFloatingSaveAreaToFxSaveArea(PFX_SAVE_AREA FxSaveArea, CONST FLOATING_SAVE_AREA *FloatingSaveArea);
BOOL
KiContextToFxSaveArea(PFX_SAVE_AREA FxSaveArea, PCONTEXT Context);
#endif /* !__ASM__ */
#endif /* __NTOSKRNL_INCLUDE_INTERNAL_I386_FPU_H */ #endif /* __NTOSKRNL_INCLUDE_INTERNAL_I386_FPU_H */

32
reactos/ntoskrnl/include/internal/i386/ke.h
View file

@ -69,22 +69,39 @@
#define KTRAP_FRAME_RESERVED9 (0x8A) #define KTRAP_FRAME_RESERVED9 (0x8A)
#define KTRAP_FRAME_SIZE (0x8C) #define KTRAP_FRAME_SIZE (0x8C)
#define X86_EFLAGS_IF 0x00000200 /* Interrupt Enable flag */
#define X86_EFLAGS_IOPL 0x00003000 /* I/O Privilege Level bits */
#define X86_EFLAGS_NT 0x00004000 /* Nested Task flag */
#define X86_EFLAGS_VM 0x00020000 /* Virtual Mode */ #define X86_EFLAGS_VM 0x00020000 /* Virtual Mode */
#define X86_EFLAGS_ID 0x00200000 /* CPUID detection flag */ #define X86_EFLAGS_ID 0x00200000 /* CPUID detection flag */
#define X86_CR0_NE 0x00000020 /* enable native FPU error reporting */
#define X86_CR0_TS 0x00000008 /* enable exception on FPU instruction for task switch */
#define X86_CR0_EM 0x00000004 /* enable FPU emulation (disable FPU) */
#define X86_CR0_MP 0x00000002 /* enable FPU monitoring */
#define X86_CR4_PAE 0x00000020 /* enable physical address extensions */ #define X86_CR4_PAE 0x00000020 /* enable physical address extensions */
#define X86_CR4_PGE 0x00000080 /* enable global pages */ #define X86_CR4_PGE 0x00000080 /* enable global pages */
#define X86_CR4_OSFXSR 0x00000200 /* enable FXSAVE/FXRSTOR instructions */
#define X86_CR4_OSXMMEXCPT 0x00000400 /* enable #XF exception */
#define X86_FEATURE_TSC 0x00000010 /* time stamp counters are present */ #define X86_FEATURE_TSC 0x00000010 /* time stamp counters are present */
#define X86_FEATURE_PAE 0x00000040 /* physical address extension is present */ #define X86_FEATURE_PAE 0x00000040 /* physical address extension is present */
#define X86_FEATURE_CX8 0x00000100 /* CMPXCHG8B instruction present */ #define X86_FEATURE_CX8 0x00000100 /* CMPXCHG8B instruction present */
#define X86_FEATURE_PGE 0x00002000 /* Page Global Enable */ #define X86_FEATURE_PGE 0x00002000 /* Page Global Enable */
#define X86_FEATURE_MMX 0x00800000 /* MMX extension present */ #define X86_FEATURE_MMX 0x00800000 /* MMX extension present */
#define X86_FEATURE_FXSR 0x01000000 /* FXSAVE/FXRSTOR instructions present */
#define X86_FEATURE_SSE 0x02000000 /* SSE extension present */ #define X86_FEATURE_SSE 0x02000000 /* SSE extension present */
#define X86_FEATURE_SSE2 0x04000000 /* SSE2 extension present */ #define X86_FEATURE_SSE2 0x04000000 /* SSE2 extension present */
#define X86_EXT_FEATURE_SSE3 0x00000001 /* SSE3 extension present */
#define X86_EXT_FEATURE_3DNOW 0x40000000 /* 3DNOW! extension present */ #define X86_EXT_FEATURE_3DNOW 0x40000000 /* 3DNOW! extension present */
/* Possible values for KTHREAD's NpxState */
#define NPX_STATE_INVALID 0x01
#define NPX_STATE_VALID 0x02
#define NPX_STATE_DIRTY 0x04
#ifndef __ASM__ #ifndef __ASM__
typedef struct _KTRAP_FRAME typedef struct _KTRAP_FRAME
@ -187,12 +204,20 @@ NtEarlyInitVdm(VOID);
: "r" (X)); : "r" (X));
#define Ke386SaveFlags(x) __asm__ __volatile__("pushfl ; popl %0":"=g" (x): /* no input */) #define Ke386SaveFlags(x) __asm__ __volatile__("pushfl ; popl %0":"=g" (x): /* no input */)
#define Ke386RestoreFlags(x) __asm__ __volatile__("pushl %0 ; popfl": /* no output */ :"g" (x):"memory") #define Ke386RestoreFlags(x) __asm__ __volatile__("pushl %0 ; popfl": /* no output */ :"g" (x):"memory")
#define Ke386GetCr4() ({ \
#define _Ke386GetCr(N) ({ \
unsigned int __d; \ unsigned int __d; \
__asm__("movl %%cr4,%0\n\t" :"=r" (__d)); \ __asm__("movl %%cr" #N ",%0\n\t" :"=r" (__d)); \
__d; \ __d; \
}) })
#define Ke386SetCr4(X) __asm__ __volatile__("movl %0,%%cr4": :"r" (X)); #define _Ke386SetCr(N,X) __asm__ __volatile__("movl %0,%%cr" #N : :"r" (X));
#define Ke386GetCr0() _Ke386GetCr(0)
#define Ke386SetCr0(X) _Ke386SetCr(0,X)
#define Ke386GetCr2() _Ke386GetCr(2)
#define Ke386SetCr2(X) _Ke386SetCr(2,X)
#define Ke386GetCr4() _Ke386GetCr(4)
#define Ke386SetCr4(X) _Ke386SetCr(4,X)
static inline void Ki386Cpuid(ULONG Op, PULONG Eax, PULONG Ebx, PULONG Ecx, PULONG Edx) static inline void Ki386Cpuid(ULONG Op, PULONG Eax, PULONG Ebx, PULONG Ecx, PULONG Edx)
{ {
@ -207,6 +232,7 @@ static inline void Ki386Cpuid(ULONG Op, PULONG Eax, PULONG Ebx, PULONG Ecx, PULO
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
#define Ke386DisableInterrupts() __asm cli #define Ke386DisableInterrupts() __asm cli
#define Ke386EnableInterrupts() __asm sti #define Ke386EnableInterrupts() __asm sti
#define Ke386HaltProcessor() __asm hlt #define Ke386HaltProcessor() __asm hlt

6
reactos/ntoskrnl/include/internal/i386/ps.h
View file

@ -26,6 +26,7 @@
#define KTHREAD_STACK_LIMIT 0x1C #define KTHREAD_STACK_LIMIT 0x1C
#define KTHREAD_TEB 0x20 #define KTHREAD_TEB 0x20
#define KTHREAD_KERNEL_STACK 0x28 #define KTHREAD_KERNEL_STACK 0x28
#define KTHREAD_NPX_STATE 0x31
#define KTHREAD_APCSTATE_PROCESS 0x44 #define KTHREAD_APCSTATE_PROCESS 0x44
#define KTHREAD_SERVICE_TABLE 0xDC #define KTHREAD_SERVICE_TABLE 0xDC
#define KTHREAD_PREVIOUS_MODE 0x137 #define KTHREAD_PREVIOUS_MODE 0x137
@ -44,6 +45,7 @@
#define KPCR_SELF 0x1C #define KPCR_SELF 0x1C
#define KPCR_TSS 0x40 #define KPCR_TSS 0x40
#define KPCR_CURRENT_THREAD 0x124 #define KPCR_CURRENT_THREAD 0x124
#define KPCR_NPX_THREAD 0x2A4
#ifndef __ASM__ #ifndef __ASM__
@ -51,12 +53,12 @@
#pragma pack(push,4) #pragma pack(push,4)
// Fixme: Use correct types? /* Fixme: Use correct types? */
typedef struct _KPROCESSOR_STATE { typedef struct _KPROCESSOR_STATE {
PCONTEXT ContextFrame; PCONTEXT ContextFrame;
PVOID SpecialRegisters; PVOID SpecialRegisters;
} KPROCESSOR_STATE; } KPROCESSOR_STATE;
/* ProcessoR Control Block */ /* ProcessoR Control Block */
typedef struct _KPRCB { typedef struct _KPRCB {
USHORT MinorVersion; USHORT MinorVersion;

9
reactos/ntoskrnl/include/internal/trap.h
View file

@ -27,10 +27,9 @@
#ifndef __NTOSKRNL_INCLUDE_INTERNAL_TRAP_H #ifndef __NTOSKRNL_INCLUDE_INTERNAL_TRAP_H
#define __NTOSKRNL_INCLUDE_INTERNAL_TRAP_H #define __NTOSKRNL_INCLUDE_INTERNAL_TRAP_H
#define TF_SAVED_ORIG_STACK (0x8C) #define TF_SAVED_EXCEPTION_STACK (0x8C)
#define TF_REGS (0x90) #define TF_REGS (0x90)
#define TF_ORIG_EBP (0x94) #define TF_ORIG_EBP (0x94)
#ifndef __ASM__ #ifndef __ASM__
@ -40,7 +39,7 @@ typedef struct _KV86M_TRAP_FRAME
{ {
KTRAP_FRAME Tf; KTRAP_FRAME Tf;
ULONG SavedInitialStack; ULONG SavedExceptionStack;
/* /*
* These are put on the top of the stack by the routine that entered * These are put on the top of the stack by the routine that entered

2
reactos/ntoskrnl/include/ntoskrnl.h
View file

@ -24,6 +24,7 @@
#include <ddk/kefuncs.h> #include <ddk/kefuncs.h>
#include <ddk/pnptypes.h> #include <ddk/pnptypes.h>
#include <ddk/pnpfuncs.h> #include <ddk/pnpfuncs.h>
#include <ntdll/ldr.h>
#include <internal/ctype.h> #include <internal/ctype.h>
#include <internal/ntoskrnl.h> #include <internal/ntoskrnl.h>
#include <internal/id.h> #include <internal/id.h>
@ -55,7 +56,6 @@
#include <internal/trap.h> #include <internal/trap.h>
#include <internal/safe.h> #include <internal/safe.h>
#include <internal/test.h> #include <internal/test.h>
#include <ntdll/ldr.h>
#include <napi/core.h> #include <napi/core.h>
#include <napi/dbg.h> #include <napi/dbg.h>
#include <napi/teb.h> #include <napi/teb.h>

14
reactos/ntoskrnl/ke/i386/bthread.S
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* $Id: bthread.S,v 1.10 2004/10/31 19:46:10 ekohl Exp $ /* $Id: bthread.S,v 1.11 2004/11/20 23:46:36 blight Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -141,18 +141,6 @@ _PsBeginThreadWithContextInternal:
addl $24, %esp addl $24, %esp
.L3: .L3:
/*
* Load the floating point registers
*/
movl (_HardwareMathSupport), %eax
testl %eax,%eax
jz .L2
testl $(CONTEXT_FLOATING_POINT & ~CONTEXT_i386), %ebx
jz .L2
frstor (%esp)
.L2:
addl $112, %esp
/* Load the rest of the thread's user mode context. */ /* Load the rest of the thread's user mode context. */
movl $0, %eax movl $0, %eax
jmp KeReturnFromSystemCallWithHook jmp KeReturnFromSystemCallWithHook

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

@ -40,6 +40,10 @@
#define _STR(x) #x #define _STR(x) #x
#define STR(x) _STR(x) #define STR(x) _STR(x)
#ifndef ARRAY_SIZE
# define ARRAY_SIZE(x) (sizeof (x) / sizeof (x[0]))
#endif
extern void interrupt_handler2e(void); extern void interrupt_handler2e(void);
extern void interrupt_handler2d(void); extern void interrupt_handler2d(void);
@ -60,6 +64,9 @@ extern VOID KiTrap13(VOID);
extern VOID KiTrap14(VOID); extern VOID KiTrap14(VOID);
extern VOID KiTrap15(VOID); extern VOID KiTrap15(VOID);
extern VOID KiTrap16(VOID); extern VOID KiTrap16(VOID);
extern VOID KiTrap17(VOID);
extern VOID KiTrap18(VOID);
extern VOID KiTrap19(VOID);
extern VOID KiTrapUnknown(VOID); extern VOID KiTrapUnknown(VOID);
extern ULONG init_stack; extern ULONG init_stack;
@ -84,9 +91,11 @@ static char *ExceptionTypeStrings[] =
"Stack Segment Fault", "Stack Segment Fault",
"General Protection", "General Protection",
"Page Fault", "Page Fault",
"Reserved(15)",
"Math Fault", "Math Fault",
"Alignment Check", "Alignment Check",
"Machine Check" "Machine Check",
"SIMD Fault"
}; };
static NTSTATUS ExceptionToNtStatus[] = static NTSTATUS ExceptionToNtStatus[] =
@ -106,9 +115,11 @@ static NTSTATUS ExceptionToNtStatus[] =
STATUS_STACK_OVERFLOW, STATUS_STACK_OVERFLOW,
STATUS_ACCESS_VIOLATION, STATUS_ACCESS_VIOLATION,
STATUS_ACCESS_VIOLATION, STATUS_ACCESS_VIOLATION,
STATUS_ACCESS_VIOLATION, /* RESERVED */
STATUS_ACCESS_VIOLATION, /* STATUS_FLT_INVALID_OPERATION */ STATUS_ACCESS_VIOLATION, /* STATUS_FLT_INVALID_OPERATION */
STATUS_DATATYPE_MISALIGNMENT, STATUS_DATATYPE_MISALIGNMENT,
STATUS_ACCESS_VIOLATION STATUS_ACCESS_VIOLATION,
STATUS_ACCESS_VIOLATION /* STATUS_FLT_MULTIPLE_TRAPS? */
}; };
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
@ -167,7 +178,7 @@ KiKernelTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2)
} }
else else
{ {
if (ExceptionNr < 16) if (ExceptionNr < ARRAY_SIZE(ExceptionToNtStatus))
{ {
Er.ExceptionCode = ExceptionToNtStatus[ExceptionNr]; Er.ExceptionCode = ExceptionToNtStatus[ExceptionNr];
} }
@ -190,7 +201,7 @@ KiKernelTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2)
ULONG ULONG
KiDoubleFaultHandler(VOID) KiDoubleFaultHandler(VOID)
{ {
unsigned int cr2_; unsigned int cr2;
ULONG StackLimit; ULONG StackLimit;
ULONG StackBase; ULONG StackBase;
ULONG Esp0; ULONG Esp0;
@ -211,15 +222,7 @@ KiDoubleFaultHandler(VOID)
Esp0 = OldTss->Esp; Esp0 = OldTss->Esp;
/* Get CR2 */ /* Get CR2 */
#if defined(__GNUC__) cr2 = Ke386GetCr2();
__asm__("movl %%cr2,%0\n\t" : "=d" (cr2_));
#elif defined(_MSC_VER)
__asm mov eax, cr2;
__asm mov cr2_, eax;
#else
#error Unknown compiler for inline assembler
#endif
if (PsGetCurrentThread() != NULL && if (PsGetCurrentThread() != NULL &&
PsGetCurrentThread()->ThreadsProcess != NULL) PsGetCurrentThread()->ThreadsProcess != NULL)
{ {
@ -245,7 +248,7 @@ KiDoubleFaultHandler(VOID)
/* /*
* Print out the CPU registers * Print out the CPU registers
*/ */
if (ExceptionNr < 19) if (ExceptionNr < ARRAY_SIZE(ExceptionTypeStrings))
{ {
DbgPrint("%s Exception: %d(%x)\n", ExceptionTypeStrings[ExceptionNr], DbgPrint("%s Exception: %d(%x)\n", ExceptionTypeStrings[ExceptionNr],
ExceptionNr, 0); ExceptionNr, 0);
@ -257,7 +260,7 @@ KiDoubleFaultHandler(VOID)
DbgPrint("CS:EIP %x:%x ", OldTss->Cs, OldTss->Eip); DbgPrint("CS:EIP %x:%x ", OldTss->Cs, OldTss->Eip);
KeRosPrintAddress((PVOID)OldTss->Eip); KeRosPrintAddress((PVOID)OldTss->Eip);
DbgPrint("\n"); DbgPrint("\n");
DbgPrint("cr2 %x cr3 %x ", cr2_, OldCr3); DbgPrint("cr2 %x cr3 %x ", cr2, OldCr3);
DbgPrint("Proc: %x ",PsGetCurrentProcess()); DbgPrint("Proc: %x ",PsGetCurrentProcess());
if (PsGetCurrentProcess() != NULL) if (PsGetCurrentProcess() != NULL)
{ {
@ -420,7 +423,7 @@ KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2)
/* /*
* Print out the CPU registers * Print out the CPU registers
*/ */
if (ExceptionNr < 19) 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->ErrorCode&0xffff);
@ -529,7 +532,7 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
* Complete CPU context * Complete CPU context
*/ */
{ {
unsigned int cr2_; unsigned int cr2;
NTSTATUS Status; NTSTATUS Status;
ULONG Esp0; ULONG Esp0;
@ -540,22 +543,15 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
Esp0 = (ULONG)&Tf->Eip; Esp0 = (ULONG)&Tf->Eip;
/* Get CR2 */ /* Get CR2 */
#if defined(__GNUC__) cr2 = Ke386GetCr2();
__asm__("movl %%cr2,%0\n\t" : "=d" (cr2_)); Tf->DebugPointer = (PVOID)cr2;
#elif defined(_MSC_VER)
__asm mov eax, cr2;
__asm mov cr2_, eax;
#else
#error Unknown compiler for inline assembler
#endif
Tf->DebugPointer = (PVOID)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))
{ {
return(KeV86Exception(ExceptionNr, Tf, cr2_)); return(KeV86Exception(ExceptionNr, Tf, cr2));
} }
/* /*
@ -574,7 +570,7 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
*/ */
if (ExceptionNr == 14) if (ExceptionNr == 14)
{ {
if (Ke386NoExecute && Tf->ErrorCode & 0x10 && cr2_ >= KERNEL_BASE) if (Ke386NoExecute && Tf->ErrorCode & 0x10 && cr2 >= KERNEL_BASE)
{ {
KEBUGCHECKWITHTF(ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY, 0, 0, 0, 0, Tf); KEBUGCHECKWITHTF(ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY, 0, 0, 0, 0, Tf);
} }
@ -585,7 +581,7 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
Status = MmPageFault(Tf->Cs&0xffff, Status = MmPageFault(Tf->Cs&0xffff,
&Tf->Eip, &Tf->Eip,
&Tf->Eax, &Tf->Eax,
cr2_, cr2,
Tf->ErrorCode); Tf->ErrorCode);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
@ -605,16 +601,28 @@ KiTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr)
return(0); return(0);
} }
/*
* Try to handle device-not-present, math-fault and xmm-fault exceptions.
*/
if (ExceptionNr == 7 || ExceptionNr == 16 || ExceptionNr == 19)
{
Status = KiHandleFpuFault(Tf, ExceptionNr);
if (NT_SUCCESS(Status))
{
return(0);
}
}
/* /*
* Handle user exceptions differently * Handle user exceptions differently
*/ */
if ((Tf->Cs & 0xFFFF) == USER_CS) if ((Tf->Cs & 0xFFFF) == USER_CS)
{ {
return(KiUserTrapHandler(Tf, ExceptionNr, (PVOID)cr2_)); return(KiUserTrapHandler(Tf, ExceptionNr, (PVOID)cr2));
} }
else else
{ {
return(KiKernelTrapHandler(Tf, ExceptionNr, (PVOID)cr2_)); return(KiKernelTrapHandler(Tf, ExceptionNr, (PVOID)cr2));
} }
} }
@ -728,11 +736,14 @@ KeInitExceptions(VOID)
set_interrupt_gate(14, (ULONG)KiTrap14); set_interrupt_gate(14, (ULONG)KiTrap14);
set_trap_gate(15, (ULONG)KiTrap15, 0); set_trap_gate(15, (ULONG)KiTrap15, 0);
set_trap_gate(16, (ULONG)KiTrap16, 0); set_trap_gate(16, (ULONG)KiTrap16, 0);
set_trap_gate(17, (ULONG)KiTrap17, 0);
set_trap_gate(18, (ULONG)KiTrap18, 0);
set_trap_gate(19, (ULONG)KiTrap19, 0);
for (i=17;i<256;i++) for (i = 20; i < 256; i++)
{ {
set_trap_gate(i,(int)KiTrapUnknown, 0); set_trap_gate(i,(int)KiTrapUnknown, 0);
} }
set_system_call_gate(0x2d,(int)interrupt_handler2d); set_system_call_gate(0x2d,(int)interrupt_handler2d);
set_system_call_gate(0x2e,(int)interrupt_handler2e); set_system_call_gate(0x2e,(int)interrupt_handler2e);
@ -746,14 +757,14 @@ NTSTATUS STDCALL
KeRaiseUserException(IN NTSTATUS ExceptionCode) KeRaiseUserException(IN NTSTATUS ExceptionCode)
{ {
/* FIXME: This needs SEH */ /* FIXME: This needs SEH */
ULONG OldEip; ULONG OldEip;
PKTHREAD Thread = KeGetCurrentThread(); PKTHREAD Thread = KeGetCurrentThread();
ProbeForWrite(&Thread->Teb->ExceptionCode, sizeof(NTSTATUS), sizeof(NTSTATUS)); /* NT doesn't check this -- bad? */ ProbeForWrite(&Thread->Teb->ExceptionCode, sizeof(NTSTATUS), sizeof(NTSTATUS)); /* NT doesn't check this -- bad? */
OldEip = Thread->TrapFrame->Eip; OldEip = Thread->TrapFrame->Eip;
Thread->TrapFrame->Eip = (ULONG_PTR)LdrpGetSystemDllRaiseExceptionDispatcher(); Thread->TrapFrame->Eip = (ULONG_PTR)LdrpGetSystemDllRaiseExceptionDispatcher();
Thread->Teb->ExceptionCode = ExceptionCode; Thread->Teb->ExceptionCode = ExceptionCode;
return((NTSTATUS)OldEip); return((NTSTATUS)OldEip);
} }
VOID VOID

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

@ -1,4 +1,4 @@
/* $Id: fpu.c,v 1.13 2004/08/15 16:39:05 chorns Exp $ /* $Id: fpu.c,v 1.14 2004/11/20 23:46:36 blight Exp $
* *
* ReactOS kernel * ReactOS kernel
* Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
@ -32,71 +32,310 @@
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
/* DEFINES *******************************************************************/
#define EXCEPTION_FLT_DENORMAL_OPERAND (0xc000008dL)
#define EXCEPTION_FLT_DIVIDE_BY_ZERO (0xc000008eL)
#define EXCEPTION_FLT_INEXACT_RESULT (0xc000008fL)
#define EXCEPTION_FLT_INVALID_OPERATION (0xc0000090L)
#define EXCEPTION_FLT_OVERFLOW (0xc0000091L)
#define EXCEPTION_FLT_STACK_CHECK (0xc0000092L)
#define EXCEPTION_FLT_UNDERFLOW (0xc0000093L)
#define EXCEPTION_FLT_MULTIPLE_FAULTS (0xC00002B4L)
#define EXCEPTION_FLT_MULTIPLE_TRAPS (0xC00002B5L)
/* x87 Status Word exception flags */
#define X87_SW_IE (1<<0) /* Invalid Operation */
#define X87_SW_DE (1<<1) /* Denormalized Operand */
#define X87_SW_ZE (1<<2) /* Zero Devide */
#define X87_SW_OE (1<<3) /* Overflow */
#define X87_SW_UE (1<<4) /* Underflow */
#define X87_SW_PE (1<<5) /* Precision */
#define X87_SW_SE (1<<6) /* Stack Fault */
#define X87_SW_ES (1<<7) /* Error Summary */
/* MXCSR exception flags */
#define MXCSR_IE (1<<0) /* Invalid Operation */
#define MXCSR_DE (1<<1) /* Denormalized Operand */
#define MXCSR_ZE (1<<2) /* Zero Devide */
#define MXCSR_OE (1<<3) /* Overflow */
#define MXCSR_UE (1<<4) /* Underflow */
#define MXCSR_PE (1<<5) /* Precision */
#define MXCSR_DAZ (1<<6) /* Denormals Are Zeros (P4 only) */
/* GLOBALS *******************************************************************/ /* GLOBALS *******************************************************************/
ULONG HardwareMathSupport; ULONG HardwareMathSupport = 0;
static ULONG MxcsrFeatureMask = 0, FxsrSupport = 0, XmmSupport = 0;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
STATIC USHORT
KiTagWordFnsaveToFxsave(USHORT TagWord)
{
INT tmp;
/*
* Converts the tag-word. 11 (Empty) is converted into 0, everything else into 1
*/
tmp = ~TagWord; /* Empty is now 00, any 2 bits containing 1 mean valid */
tmp = (tmp | (tmp >> 1)) & 0x5555; /* 0V0V0V0V0V0V0V0V */
tmp = (tmp | (tmp >> 1)) & 0x3333; /* 00VV00VV00VV00VV */
tmp = (tmp | (tmp >> 2)) & 0x0f0f; /* 0000VVVV0000VVVV */
tmp = (tmp | (tmp >> 4)) & 0x00ff; /* 00000000VVVVVVVV */
return tmp;
}
STATIC USHORT
KiTagWordFxsaveToFnsave(PFXSAVE_FORMAT FxSave)
{
USHORT TagWord = 0;
UCHAR Tag;
INT i;
struct FPREG { USHORT Significand[4]; USHORT Exponent; } *FpReg;
for (i = 0; i < 8; i++)
{
if (FxSave->TagWord & (1 << i)) /* valid */
{
FpReg = (struct FPREG *)(FxSave->RegisterArea + (i * 16));
switch (FpReg->Exponent & 0x00007fff)
{
case 0x0000:
if (FpReg->Significand[0] == 0 && FpReg->Significand[1] == 0 &&
FpReg->Significand[2] == 0 && FpReg->Significand[3] == 0)
{
Tag = 1; /* Zero */
}
else
{
Tag = 2; /* Special */
}
break;
case 0x7fff:
Tag = 2; /* Special */
break;
default:
if (FpReg->Significand[3] & 0x00008000)
{
Tag = 0; /* Valid */
}
else
{
Tag = 2; /* Special */
}
break;
}
}
else /* empty */
{
Tag = 3;
}
TagWord |= Tag << (i * 2);
}
return TagWord;
}
STATIC VOID
KiFnsaveToFxsaveFormat(PFXSAVE_FORMAT FxSave, CONST PFNSAVE_FORMAT FnSave)
{
INT i;
FxSave->ControlWord = (USHORT)FnSave->ControlWord;
FxSave->StatusWord = (USHORT)FnSave->StatusWord;
FxSave->TagWord = KiTagWordFnsaveToFxsave((USHORT)FnSave->TagWord);
FxSave->ErrorOpcode = (USHORT)(FnSave->ErrorSelector >> 16);
FxSave->ErrorOffset = FnSave->ErrorOffset;
FxSave->ErrorSelector = FnSave->ErrorSelector & 0x0000ffff;
FxSave->DataOffset = FnSave->DataOffset;
FxSave->DataSelector = FnSave->DataSelector & 0x0000ffff;
if (XmmSupport)
FxSave->MXCsr = 0x00001f80 & MxcsrFeatureMask;
else
FxSave->MXCsr = 0;
FxSave->MXCsrMask = MxcsrFeatureMask;
memset(FxSave->Reserved3, 0, sizeof(FxSave->Reserved3) +
sizeof(FxSave->Reserved4)); /* XXX - doesnt zero Align16Byte because
Context->ExtendedRegisters is only 512 bytes, not 520 */
for (i = 0; i < 8; i++)
{
memcpy(FxSave->RegisterArea + (i * 16), FnSave->RegisterArea + (i * 10), 10);
memset(FxSave->RegisterArea + (i * 16) + 10, 0, 6);
}
}
STATIC VOID
KiFxsaveToFnsaveFormat(PFNSAVE_FORMAT FnSave, CONST PFXSAVE_FORMAT FxSave)
{
INT i;
FnSave->ControlWord = 0xffff0000 | FxSave->ControlWord;
FnSave->StatusWord = 0xffff0000 | FxSave->StatusWord;
FnSave->TagWord = 0xffff0000 | KiTagWordFxsaveToFnsave(FxSave);
FnSave->ErrorOffset = FxSave->ErrorOffset;
FnSave->ErrorSelector = FxSave->ErrorSelector & 0x0000ffff;
FnSave->ErrorSelector |= FxSave->ErrorOpcode << 16;
FnSave->DataOffset = FxSave->DataOffset;
FnSave->DataSelector = FxSave->DataSelector | 0xffff0000;
for (i = 0; i < 8; i++)
{
memcpy(FnSave->RegisterArea + (i * 10), FxSave->RegisterArea + (i * 16), 10);
}
}
VOID
KiFloatingSaveAreaToFxSaveArea(PFX_SAVE_AREA FxSaveArea, CONST FLOATING_SAVE_AREA *FloatingSaveArea)
{
if (FxsrSupport)
{
KiFnsaveToFxsaveFormat(&FxSaveArea->U.FxArea, (PFNSAVE_FORMAT)FloatingSaveArea);
}
else
{
memcpy(&FxSaveArea->U.FnArea, FloatingSaveArea, sizeof(FxSaveArea->U.FnArea));
}
FxSaveArea->NpxSavedCpu = 0;
FxSaveArea->Cr0NpxState = FloatingSaveArea->Cr0NpxState;
}
BOOL
KiContextToFxSaveArea(PFX_SAVE_AREA FxSaveArea, PCONTEXT Context)
{
BOOL FpuContextChanged = FALSE;
/* First of all convert the FLOATING_SAVE_AREA into the FX_SAVE_AREA */
if ((Context->ContextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT)
{
KiFloatingSaveAreaToFxSaveArea(FxSaveArea, &Context->FloatSave);
FpuContextChanged = TRUE;
}
/* Now merge the FX_SAVE_AREA from the context with the destination area */
if ((Context->ContextFlags & CONTEXT_EXTENDED_REGISTERS) == CONTEXT_EXTENDED_REGISTERS)
{
if (FxsrSupport)
{
PFXSAVE_FORMAT src = (PFXSAVE_FORMAT)Context->ExtendedRegisters;
PFXSAVE_FORMAT dst = &FxSaveArea->U.FxArea;
dst->MXCsr = src->MXCsr & MxcsrFeatureMask;
memcpy(dst->Reserved3, src->Reserved3,
sizeof(src->Reserved3) + sizeof(src->Reserved4));
if ((Context->ContextFlags & CONTEXT_FLOATING_POINT) != CONTEXT_FLOATING_POINT)
{
dst->ControlWord = src->ControlWord;
dst->StatusWord = src->StatusWord;
dst->TagWord = src->TagWord;
dst->ErrorOpcode = src->ErrorOpcode;
dst->ErrorOffset = src->ErrorOffset;
dst->ErrorSelector = src->ErrorSelector;
dst->DataOffset = src->DataOffset;
dst->DataSelector = src->DataSelector;
memcpy(dst->RegisterArea, src->RegisterArea, sizeof(src->RegisterArea));
FxSaveArea->NpxSavedCpu = 0;
FxSaveArea->Cr0NpxState = 0;
}
FpuContextChanged = TRUE;
}
}
return FpuContextChanged;
}
VOID INIT_FUNCTION VOID INIT_FUNCTION
KiCheckFPU(VOID) KiCheckFPU(VOID)
{ {
unsigned short int status; unsigned short int status;
int cr0_; int cr0;
ULONG Flags;
HardwareMathSupport = 0; PKPCR Pcr = KeGetCurrentKPCR();
#if defined(__GNUC__)
__asm__("movl %%cr0, %0\n\t" : "=a" (cr0_));
/* Set NE and MP. */
cr0_ = cr0_ | 0x22;
/* Clear EM */
cr0_ = cr0_ & (~0x4);
__asm__("movl %0, %%cr0\n\t" : : "a" (cr0_));
__asm__("clts\n\t"); Ke386SaveFlags(Flags);
__asm__("fninit\n\t"); Ke386DisableInterrupts();
__asm__("fstsw %0\n\t" : "=a" (status));
if (status != 0) HardwareMathSupport = 0;
{ FxsrSupport = 0;
__asm__("movl %%cr0, %0\n\t" : "=a" (cr0_)); XmmSupport = 0;
/* Set the EM flag in CR0 so any FPU instructions cause a trap. */
cr0_ = cr0_ | 0x4; cr0 = Ke386GetCr0();
__asm__("movl %0, %%cr0\n\t" : cr0 |= X86_CR0_NE | X86_CR0_MP;
: "a" (cr0_)); cr0 &= ~(X86_CR0_EM | X86_CR0_TS);
return; Ke386SetCr0(cr0);
}
/* fsetpm for i287, ignored by i387 */ #if defined(__GNUC__)
__asm__(".byte 0xDB, 0xE4\n\t"); asm volatile("fninit\n\t");
asm volatile("fstsw %0\n\t" : "=a" (status));
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
__asm mov eax, cr0;
__asm mov cr0_, eax;
cr0_ |= 0x22; /* Set NE and MP. */
cr0_ &= ~0x4; /* Clear EM */
__asm __asm
{ {
mov eax, cr0_;
mov cr0, eax;
clts;
fninit; fninit;
fstsw status fstsw status
} }
#else
#error Unknown compiler for inline assembler
#endif
if (status != 0) if (status != 0)
{ {
__asm mov eax, cr0_; /* Set the EM flag in CR0 so any FPU instructions cause a trap. */
__asm or eax, 4; /* Set the EM flag in CR0 so any FPU instructions cause a trap. */ Ke386SetCr0(Ke386GetCr0() | X86_CR0_EM);
__asm mov cr0, eax; Ke386RestoreFlags(Flags);
return; return;
} }
/* fsetpm for i287, ignored by i387 */ /* fsetpm for i287, ignored by i387 */
#if defined(__GNUC__)
asm volatile(".byte 0xDB, 0xE4\n\t");
#elif defined(_MSC_VER)
__asm _emit 0xDB __asm _emit 0xe4 __asm _emit 0xDB __asm _emit 0xe4
// __asm fsetpm;
// __asm__(".byte 0xDB, 0xE4\n\t");
#else #else
#error Unknown compiler for inline assembler #error Unknown compiler for inline assembler
#endif #endif
HardwareMathSupport = 1; HardwareMathSupport = 1;
/* check for and enable MMX/SSE support if possible */
if ((Pcr->PrcbData.FeatureBits & X86_FEATURE_FXSR) != 0)
{
BYTE DummyArea[sizeof(FX_SAVE_AREA) + 15];
PFX_SAVE_AREA FxSaveArea;
/* enable FXSR */
FxsrSupport = 1;
/* we need a 16 byte aligned FX_SAVE_AREA */
FxSaveArea = (PFX_SAVE_AREA)DummyArea;
if ((ULONG_PTR)FxSaveArea & 0x0f)
{
FxSaveArea = (PFX_SAVE_AREA)(((ULONG_PTR)FxSaveArea + 0x10) & (~0x0f));
}
Ke386SetCr4(Ke386GetCr4() | X86_CR4_OSFXSR);
memset(&FxSaveArea->U.FxArea, 0, sizeof(FxSaveArea->U.FxArea));
asm volatile("fxsave %0" : : "m"(FxSaveArea->U.FxArea));
MxcsrFeatureMask = FxSaveArea->U.FxArea.MXCsrMask;
if (MxcsrFeatureMask == 0)
{
MxcsrFeatureMask = 0x0000ffbf;
}
}
/* FIXME: Check for SSE3 in Ke386CpuidFlags2! */
if (Pcr->PrcbData.FeatureBits & (X86_FEATURE_SSE | X86_FEATURE_SSE2))
{
Ke386SetCr4(Ke386GetCr4() | X86_CR4_OSXMMEXCPT);
/* enable SSE */
XmmSupport = 1;
}
Ke386SetCr0(Ke386GetCr0() | X86_CR0_TS);
Ke386RestoreFlags(Flags);
} }
/* This is a rather naive implementation of Ke(Save/Restore)FloatingPointState /* This is a rather naive implementation of Ke(Save/Restore)FloatingPointState
@ -109,6 +348,14 @@ KeSaveFloatingPointState(OUT PKFLOATING_SAVE Save)
{ {
char *FpState; char *FpState;
ASSERT_IRQL(DISPATCH_LEVEL); /* FIXME: is this removed for non-debug builds? I hope not! */
/* check if we are doing software emulation */
if (!HardwareMathSupport)
{
return STATUS_ILLEGAL_FLOAT_CONTEXT;
}
FpState = ExAllocatePool(PagedPool, FPU_STATE_SIZE); FpState = ExAllocatePool(PagedPool, FPU_STATE_SIZE);
if (NULL == FpState) if (NULL == FpState)
{ {
@ -117,7 +364,7 @@ KeSaveFloatingPointState(OUT PKFLOATING_SAVE Save)
*((PVOID *) Save) = FpState; *((PVOID *) Save) = FpState;
#if defined(__GNUC__) #if defined(__GNUC__)
__asm__("fsave %0\n\t" : "=m" (*FpState)); asm volatile("fsave %0\n\t" : "=m" (*FpState));
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
__asm mov eax, FpState; __asm mov eax, FpState;
__asm fsave [eax]; __asm fsave [eax];
@ -125,6 +372,8 @@ KeSaveFloatingPointState(OUT PKFLOATING_SAVE Save)
#error Unknown compiler for inline assembler #error Unknown compiler for inline assembler
#endif #endif
KeGetCurrentThread()->NpxIrql = KeGetCurrentIrql();
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -133,6 +382,11 @@ KeRestoreFloatingPointState(IN PKFLOATING_SAVE Save)
{ {
char *FpState = *((PVOID *) Save); char *FpState = *((PVOID *) Save);
if (KeGetCurrentThread()->NpxIrql != KeGetCurrentIrql())
{
KEBUGCHECK(UNDEFINED_BUG_CODE);
}
#if defined(__GNUC__) #if defined(__GNUC__)
__asm__("frstor %0\n\t" : "=m" (*FpState)); __asm__("frstor %0\n\t" : "=m" (*FpState));
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
@ -146,3 +400,198 @@ KeRestoreFloatingPointState(IN PKFLOATING_SAVE Save)
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS
KiHandleFpuFault(PKTRAP_FRAME Tf, ULONG ExceptionNr)
{
if (ExceptionNr == 7) /* device not present */
{
unsigned int cr0 = Ke386GetCr0();
PKTHREAD CurrentThread, NpxThread;
PFX_SAVE_AREA FxSaveArea;
KIRQL oldIrql;
ASSERT((cr0 & X86_CR0_TS) == X86_CR0_TS);
ASSERT((Tf->Eflags & X86_EFLAGS_VM) == 0);
ASSERT((cr0 & X86_CR0_EM) == 0);
/* disable scheduler, clear TS in cr0 */
ASSERT_IRQL(DISPATCH_LEVEL);
KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
asm volatile("clts");
CurrentThread = KeGetCurrentThread();
NpxThread = KeGetCurrentKPCR()->PrcbData.NpxThread;
ASSERT(CurrentThread != NULL);
DPRINT("Device not present exception happened! (Cr0 = 0x%x, NpxState = 0x%x)\n", Ke386GetCr0(), CurrentThread->NpxState);
/* check if the current thread already owns the FPU */
if (NpxThread != CurrentThread) /* FIXME: maybe this could be an assertation */
{
BOOL FpuInitialized = FALSE;
/* save the FPU state into the owner's save area */
if (NpxThread != NULL)
{
KeGetCurrentKPCR()->PrcbData.NpxThread = NULL;
FxSaveArea = (PFX_SAVE_AREA)((char *)NpxThread->InitialStack - sizeof (FX_SAVE_AREA));
/* the fnsave might raise a delayed #MF exception */
if (FxsrSupport)
{
asm volatile("fxsave %0" : : "m"(FxSaveArea->U.FxArea));
}
else
{
asm volatile("fnsave %0" : : "m"(FxSaveArea->U.FnArea));
FpuInitialized = TRUE;
}
NpxThread->NpxState = NPX_STATE_VALID;
}
/* restore the state of the current thread */
ASSERT((CurrentThread->NpxState & NPX_STATE_DIRTY) == 0);
FxSaveArea = (PFX_SAVE_AREA)((char *)CurrentThread->InitialStack - sizeof (FX_SAVE_AREA));
if (CurrentThread->NpxState & NPX_STATE_VALID)
{
if (FxsrSupport)
{
FxSaveArea->U.FxArea.MXCsr &= MxcsrFeatureMask;
asm volatile("fxrstor %0" : : "m"(FxSaveArea->U.FxArea));
}
else
{
asm volatile("frstor %0" : : "m"(FxSaveArea->U.FnArea));
}
}
else /* NpxState & NPX_STATE_INVALID */
{
DPRINT("Setting up clean FPU state\n");
if (FxsrSupport)
{
memset(&FxSaveArea->U.FxArea, 0, sizeof(FxSaveArea->U.FxArea));
FxSaveArea->U.FxArea.ControlWord = 0x037f;
if (XmmSupport)
{
FxSaveArea->U.FxArea.MXCsr = 0x00001f80 & MxcsrFeatureMask;
}
asm volatile("fxrstor %0" : : "m"(FxSaveArea->U.FxArea));
}
else if (!FpuInitialized)
{
asm volatile("finit");
}
}
KeGetCurrentKPCR()->PrcbData.NpxThread = CurrentThread;
}
CurrentThread->NpxState |= NPX_STATE_DIRTY;
KeLowerIrql(oldIrql);
DPRINT("Device not present exception handled!\n");
return STATUS_SUCCESS;
}
else /* ExceptionNr == 16 || ExceptionNr == 19 */
{
EXCEPTION_RECORD Er;
UCHAR DummyContext[sizeof(CONTEXT) + 16];
PCONTEXT Context;
KPROCESSOR_MODE PreviousMode;
PKTHREAD CurrentThread, NpxThread;
KIRQL oldIrql;
ASSERT(ExceptionNr == 16 || ExceptionNr == 19); /* math fault or XMM fault*/
KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
NpxThread = KeGetCurrentKPCR()->PrcbData.NpxThread;
CurrentThread = KeGetCurrentThread();
if (NpxThread == NULL)
{
DPRINT1("!!! Math/Xmm fault ignored! (NpxThread == NULL)\n");
KeLowerIrql(oldIrql);
return STATUS_SUCCESS;
}
PreviousMode = ((Tf->Cs & 0xffff) == USER_CS) ? (UserMode) : (KernelMode);
DPRINT("Math/Xmm fault happened! (PreviousMode = %s)\n",
(PreviousMode == UserMode) ? ("UserMode") : ("KernelMode"));
ASSERT(NpxThread == CurrentThread); /* FIXME: Is not always true I think */
/* For fxsave we have to align Context->ExtendedRegisters on 16 bytes */
Context = (PCONTEXT)DummyContext;
Context = (PCONTEXT)((ULONG_PTR)Context + 0x10 - ((ULONG_PTR)Context->ExtendedRegisters & 0x0f));
/* Get FPU/XMM state */
Context->FloatSave.Cr0NpxState = 0;
if (FxsrSupport)
{
PFXSAVE_FORMAT FxSave = (PFXSAVE_FORMAT)Context->ExtendedRegisters;
FxSave->MXCsrMask = MxcsrFeatureMask;
memset(FxSave->RegisterArea, 0, sizeof(FxSave->RegisterArea) +
sizeof(FxSave->Reserved3) + sizeof(FxSave->Reserved4));
asm volatile("fxsave %0" : : "m"(*FxSave));
KeLowerIrql(oldIrql);
KiFxsaveToFnsaveFormat((PFNSAVE_FORMAT)&Context->FloatSave, FxSave);
}
else
{
PFNSAVE_FORMAT FnSave = (PFNSAVE_FORMAT)&Context->FloatSave;
asm volatile("fnsave %0" : : "m"(*FnSave));
KeLowerIrql(oldIrql);
memset(Context->FloatSave.RegisterArea, 0, sizeof(Context->FloatSave.RegisterArea));
KiFnsaveToFxsaveFormat((PFXSAVE_FORMAT)Context->ExtendedRegisters, FnSave);
}
/* Fill the rest of the context */
Context->ContextFlags = CONTEXT_FULL;
KeTrapFrameToContext(Tf, Context);
Context->ContextFlags |= CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS;
/* Determine exception code */
if (ExceptionNr == 16)
{
USHORT FpuStatusWord = Context->FloatSave.StatusWord & 0xffff;
DPRINT("FpuStatusWord = 0x%04x\n", FpuStatusWord);
if (FpuStatusWord & X87_SW_IE)
Er.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
else if (FpuStatusWord & X87_SW_DE)
Er.ExceptionCode = EXCEPTION_FLT_DENORMAL_OPERAND;
else if (FpuStatusWord & X87_SW_ZE)
Er.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
else if (FpuStatusWord & X87_SW_OE)
Er.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
else if (FpuStatusWord & X87_SW_UE)
Er.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
else if (FpuStatusWord & X87_SW_PE)
Er.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
else if (FpuStatusWord & X87_SW_SE)
Er.ExceptionCode = EXCEPTION_FLT_STACK_CHECK;
else
ASSERT(0); /* not reached */
/* FIXME: is this the right way to get the correct EIP of the faulting instruction? */
Er.ExceptionAddress = (PVOID)Context->FloatSave.ErrorOffset;
}
else /* ExceptionNr == 19 */
{
/* FIXME: When should we use EXCEPTION_FLT_MULTIPLE_FAULTS? */
Er.ExceptionCode = EXCEPTION_FLT_MULTIPLE_TRAPS;
Er.ExceptionAddress = (PVOID)Tf->Eip;
}
Er.ExceptionFlags = 0;
Er.ExceptionRecord = NULL;
Er.NumberParameters = 0;
/* Dispatch exception */
DPRINT("Dispatching exception (ExceptionCode = 0x%08x)\n", Er.ExceptionCode);
KiDispatchException(&Er, Context, Tf, PreviousMode, TRUE);
DPRINT("Math-fault handled!\n");
return STATUS_SUCCESS;
}
return STATUS_UNSUCCESSFUL;
}

34
reactos/ntoskrnl/ke/i386/kernel.c
View file

@ -181,8 +181,6 @@ KeApplicationProcessorInit(VOID)
Offset = InterlockedIncrement(&PcrsAllocated) - 1; Offset = InterlockedIncrement(&PcrsAllocated) - 1;
Pcr = (PKPCR)((ULONG_PTR)KPCR_BASE + Offset * PAGE_SIZE); Pcr = (PKPCR)((ULONG_PTR)KPCR_BASE + Offset * PAGE_SIZE);
KiCheckFPU();
/* /*
* Initialize the GDT * Initialize the GDT
*/ */
@ -191,6 +189,9 @@ KeApplicationProcessorInit(VOID)
/* Get processor information. */ /* Get processor information. */
Ki386GetCpuId(); Ki386GetCpuId();
/* Check FPU/MMX/SSE support. */
KiCheckFPU();
/* /*
* It is now safe to process interrupts * It is now safe to process interrupts
*/ */
@ -220,14 +221,18 @@ KeInit1(PCHAR CommandLine, PULONG LastKernelAddress)
extern USHORT KiBootGdt[]; extern USHORT KiBootGdt[];
extern KTSS KiBootTss; extern KTSS KiBootTss;
/* Get processor information. */
Ki386GetCpuId();
/* Check FPU/MMX/SSE support. */
KiCheckFPU(); KiCheckFPU();
KiInitializeGdt (NULL); KiInitializeGdt (NULL);
Ki386BootInitializeTSS(); Ki386BootInitializeTSS();
KeInitExceptions (); KeInitExceptions ();
KeInitInterrupts (); KeInitInterrupts ();
/* /*
* Initialize the initial PCR region. We can't allocate a page * Initialize the initial PCR region. We can't allocate a page
* with MmAllocPage() here because MmInit1() has not yet been * with MmAllocPage() here because MmInit1() has not yet been
* called, so we use a predefined page in low memory * called, so we use a predefined page in low memory
@ -251,9 +256,6 @@ KeInit1(PCHAR CommandLine, PULONG LastKernelAddress)
Ki386InitializeLdt(); Ki386InitializeLdt();
/* Get processor information. */
Ki386GetCpuId();
if (KPCR->PrcbData.FeatureBits & X86_FEATURE_PGE) if (KPCR->PrcbData.FeatureBits & X86_FEATURE_PGE)
{ {
ULONG Flags; ULONG Flags;
@ -348,6 +350,24 @@ KeInit2(VOID)
DPRINT1("CPU doesn't run in PAE mode\n"); DPRINT1("CPU doesn't run in PAE mode\n");
} }
} }
if ((Pcr->PrcbData.FeatureBits & (X86_FEATURE_FXSR | X86_FEATURE_MMX | X86_FEATURE_SSE | X86_FEATURE_SSE2)) ||
(Ke386CpuidFlags2 & X86_EXT_FEATURE_SSE3))
{
DPRINT1("CPU supports" "%s%s%s%s%s" ".\n",
((Pcr->PrcbData.FeatureBits & X86_FEATURE_FXSR) ? " FXSR" : ""),
((Pcr->PrcbData.FeatureBits & X86_FEATURE_MMX) ? " MMX" : ""),
((Pcr->PrcbData.FeatureBits & X86_FEATURE_SSE) ? " SSE" : ""),
((Pcr->PrcbData.FeatureBits & X86_FEATURE_SSE2) ? " SSE2" : ""),
((Ke386CpuidFlags2 & X86_EXT_FEATURE_SSE3) ? " SSE3" : ""));
}
if (Ke386GetCr4() & X86_CR4_OSFXSR)
{
DPRINT1("SSE enabled.\n");
}
if (Ke386GetCr4() & X86_CR4_OSXMMEXCPT)
{
DPRINT1("Unmasked SIMD exceptions enabled.\n");
}
if (Pcr->PrcbData.VendorString[0]) if (Pcr->PrcbData.VendorString[0])
{ {
DPRINT1("CPU Vendor: %s\n", Pcr->PrcbData.VendorString); DPRINT1("CPU Vendor: %s\n", Pcr->PrcbData.VendorString);

3
reactos/ntoskrnl/ke/i386/multiboot.S
View file

@ -3,6 +3,7 @@
#include <internal/i386/segment.h> #include <internal/i386/segment.h>
#include <internal/ps.h> #include <internal/ps.h>
#include <internal/i386/mm.h> #include <internal/i386/mm.h>
#include <internal/i386/fpu.h>
#define MULTIBOOT_HEADER_MAGIC (0x1BADB002) #define MULTIBOOT_HEADER_MAGIC (0x1BADB002)
@ -279,7 +280,7 @@ _multiboot_entry:
/* /*
* Load the initial kernel stack * Load the initial kernel stack
*/ */
movl $_init_stack_top, %esp movl $(_init_stack_top - SIZEOF_FX_SAVE_AREA), %esp
/* /*
* Initialize EFLAGS * Initialize EFLAGS

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

@ -31,13 +31,6 @@
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
/* GLOBALS *******************************************************************/
#define FLAG_NT (1<<14)
#define FLAG_VM (1<<17)
#define FLAG_IF (1<<9)
#define FLAG_IOPL ((1<<12)+(1<<13))
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
NTSTATUS NTSTATUS
@ -77,10 +70,10 @@ Ki386ValidateUserContext(PCONTEXT Context)
{ {
return(STATUS_UNSUCCESSFUL); return(STATUS_UNSUCCESSFUL);
} }
if ((Context->EFlags & FLAG_IOPL) != 0 || if ((Context->EFlags & X86_EFLAGS_IOPL) != 0 ||
(Context->EFlags & FLAG_NT) || (Context->EFlags & X86_EFLAGS_NT) ||
(Context->EFlags & FLAG_VM) || (Context->EFlags & X86_EFLAGS_VM) ||
(!(Context->EFlags & FLAG_IF))) (!(Context->EFlags & X86_EFLAGS_IF)))
{ {
return(STATUS_UNSUCCESSFUL); return(STATUS_UNSUCCESSFUL);
} }
@ -93,40 +86,37 @@ Ke386InitThreadWithContext(PKTHREAD Thread, PCONTEXT Context)
PULONG KernelStack; PULONG KernelStack;
ULONG InitSize; ULONG InitSize;
PKTRAP_FRAME TrapFrame; PKTRAP_FRAME TrapFrame;
PFX_SAVE_AREA FxSaveArea;
/* /*
* Setup a stack frame for exit from the task switching routine * Setup a stack frame for exit from the task switching routine
*/ */
InitSize = 5 * sizeof(DWORD) + sizeof(DWORD) + 6 * sizeof(DWORD) + InitSize = 6 * sizeof(DWORD) + sizeof(DWORD) + 6 * sizeof(DWORD) +
sizeof(FLOATING_SAVE_AREA) + sizeof(KTRAP_FRAME); + sizeof(KTRAP_FRAME) + sizeof (FX_SAVE_AREA);
KernelStack = (PULONG)((char*)Thread->KernelStack - InitSize); KernelStack = (PULONG)((char*)Thread->KernelStack - InitSize);
/* Set up the initial frame for the return from the dispatcher. */ /* Set up the initial frame for the return from the dispatcher. */
KernelStack[0] = 0; /* EDI */ KernelStack[0] = (ULONG)Thread->InitialStack - sizeof(FX_SAVE_AREA); /* TSS->Esp0 */
KernelStack[1] = 0; /* ESI */ KernelStack[1] = 0; /* EDI */
KernelStack[2] = 0; /* EBX */ KernelStack[2] = 0; /* ESI */
KernelStack[3] = 0; /* EBP */ KernelStack[3] = 0; /* EBX */
KernelStack[4] = (ULONG)&PsBeginThreadWithContextInternal; /* EIP */ KernelStack[4] = 0; /* EBP */
KernelStack[5] = (ULONG)&PsBeginThreadWithContextInternal; /* EIP */
/* Save the context flags. */ /* Save the context flags. */
KernelStack[5] = Context->ContextFlags; KernelStack[6] = Context->ContextFlags;
/* Set up the initial values of the debugging registers. */ /* Set up the initial values of the debugging registers. */
KernelStack[6] = Context->Dr0; KernelStack[7] = Context->Dr0;
KernelStack[7] = Context->Dr1; KernelStack[8] = Context->Dr1;
KernelStack[8] = Context->Dr2; KernelStack[9] = Context->Dr2;
KernelStack[9] = Context->Dr3; KernelStack[10] = Context->Dr3;
KernelStack[10] = Context->Dr6; KernelStack[11] = Context->Dr6;
KernelStack[11] = Context->Dr7; KernelStack[12] = Context->Dr7;
/* Set up the initial floating point state. */
memcpy((PVOID)&KernelStack[12], (PVOID)&Context->FloatSave,
sizeof(FLOATING_SAVE_AREA));
/* Set up a trap frame from the context. */ /* Set up a trap frame from the context. */
TrapFrame = (PKTRAP_FRAME) TrapFrame = (PKTRAP_FRAME)(&KernelStack[13]);
((char*)KernelStack + 12 * sizeof(DWORD) + sizeof(FLOATING_SAVE_AREA));
TrapFrame->DebugEbp = (PVOID)Context->Ebp; TrapFrame->DebugEbp = (PVOID)Context->Ebp;
TrapFrame->DebugEip = (PVOID)Context->Eip; TrapFrame->DebugEip = (PVOID)Context->Eip;
TrapFrame->DebugArgMark = 0; TrapFrame->DebugArgMark = 0;
@ -149,12 +139,24 @@ Ke386InitThreadWithContext(PKTHREAD Thread, PCONTEXT Context)
TrapFrame->ErrorCode = 0; TrapFrame->ErrorCode = 0;
TrapFrame->Cs = Context->SegCs; TrapFrame->Cs = Context->SegCs;
TrapFrame->Eip = Context->Eip; TrapFrame->Eip = Context->Eip;
TrapFrame->Eflags = Context->EFlags | FLAG_IF; TrapFrame->Eflags = Context->EFlags | X86_EFLAGS_IF;
TrapFrame->Eflags &= ~(FLAG_VM | FLAG_NT | FLAG_IOPL); TrapFrame->Eflags &= ~(X86_EFLAGS_VM | X86_EFLAGS_NT | X86_EFLAGS_IOPL);
TrapFrame->Esp = Context->Esp; TrapFrame->Esp = Context->Esp;
TrapFrame->Ss = (USHORT)Context->SegSs; TrapFrame->Ss = (USHORT)Context->SegSs;
/* FIXME: Should check for a v86 mode context here. */ /* FIXME: Should check for a v86 mode context here. */
/* Set up the initial floating point state. */
/* FIXME: Do we have to zero the FxSaveArea or is it already? */
FxSaveArea = (PFX_SAVE_AREA)((ULONG_PTR)KernelStack + InitSize - sizeof(FX_SAVE_AREA));
if (KiContextToFxSaveArea(FxSaveArea, Context))
{
Thread->NpxState = NPX_STATE_VALID;
}
else
{
Thread->NpxState = NPX_STATE_INVALID;
}
/* Save back the new value of the kernel stack. */ /* Save back the new value of the kernel stack. */
Thread->KernelStack = (PVOID)KernelStack; Thread->KernelStack = (PVOID)KernelStack;
@ -175,21 +177,25 @@ Ke386InitThread(PKTHREAD Thread,
* Setup a stack frame for exit from the task switching routine * Setup a stack frame for exit from the task switching routine
*/ */
KernelStack = (PULONG)((char*)Thread->KernelStack - (8*4)); KernelStack = (PULONG)((char*)Thread->KernelStack - (9 * sizeof(DWORD)) - sizeof(FX_SAVE_AREA));
KernelStack[0] = 0; /* EDI */ KernelStack[0] = (ULONG)Thread->InitialStack - sizeof(FX_SAVE_AREA); /* TSS->Esp0 */
KernelStack[1] = 0; /* ESI */ KernelStack[1] = 0; /* EDI */
KernelStack[2] = 0; /* EBX */ KernelStack[2] = 0; /* ESI */
KernelStack[3] = 0; /* EBP */ KernelStack[3] = 0; /* EBX */
KernelStack[4] = (ULONG)&PsBeginThread; /* EIP */ KernelStack[4] = 0; /* EBP */
KernelStack[5] = 0; /* Return EIP */ KernelStack[5] = (ULONG)&PsBeginThread; /* EIP */
KernelStack[6] = (ULONG)StartRoutine; /* First argument to PsBeginThread */ KernelStack[6] = 0; /* Return EIP */
KernelStack[7] = (ULONG)StartContext; /* Second argument to PsBeginThread */ KernelStack[7] = (ULONG)StartRoutine; /* First argument to PsBeginThread */
KernelStack[8] = (ULONG)StartContext; /* Second argument to PsBeginThread */
Thread->KernelStack = (VOID*)KernelStack; Thread->KernelStack = (VOID*)KernelStack;
/*
* Setup FPU state
*/
Thread->NpxState = NPX_STATE_INVALID;
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
/* EOF */ /* EOF */

29
reactos/ntoskrnl/ke/i386/trap.s
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* $Id: trap.s,v 1.20 2004/07/01 02:40:23 hyperion Exp $ /* $Id: trap.s,v 1.21 2004/11/20 23:46:36 blight Exp $
* *
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/i386/trap.s * FILE: ntoskrnl/ke/i386/trap.s
@ -353,6 +353,33 @@ _KiTrap16:
movl $16, %esi movl $16, %esi
jmp _KiTrapProlog jmp _KiTrapProlog
.globl _KiTrap17
_KiTrap17:
pushl $0
pushl %ebp
pushl %ebx
pushl %esi
movl $17, %esi
jmp _KiTrapProlog
.globl _KiTrap18
_KiTrap18:
pushl $0
pushl %ebp
pushl %ebx
pushl %esi
movl $18, %esi
jmp _KiTrapProlog
.globl _KiTrap19
_KiTrap19:
pushl $0
pushl %ebp
pushl %ebx
pushl %esi
movl $19, %esi
jmp _KiTrapProlog
.globl _KiTrapUnknown .globl _KiTrapUnknown
_KiTrapUnknown: _KiTrapUnknown:
pushl $0 pushl $0

66
reactos/ntoskrnl/ke/i386/tskswitch.S
View file

@ -17,16 +17,18 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* /*
* FILE: ntoskrnl/ke/i386/tskswitch.S * FILE: ntoskrnl/ke/i386/tskswitch.S
* PURPOSE: Microkernel thread support * PURPOSE: Microkernel thread support
* PROGRAMMER: David Welch (welch@cwcom.net) * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY: * UPDATE HISTORY:
* Created 09/10/00 * Created 09/10/00
*/ */
/* INCLUDES ******************************************************************/ /* INCLUDES ******************************************************************/
#include <internal/i386/segment.h> #include <internal/i386/segment.h>
#include <internal/i386/ke.h>
#include <internal/i386/fpu.h>
#include <internal/ps.h> #include <internal/ps.h>
#include <ntos/tss.h> #include <ntos/tss.h>
#include <internal/ntoskrnl.h> #include <internal/ntoskrnl.h>
@ -34,12 +36,13 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
.globl _Ki386ContextSwitch .globl _Ki386ContextSwitch
.func Ki386ContextSwitch
_Ki386ContextSwitch: _Ki386ContextSwitch:
/* /*
* FUNCTIONS: Switches to another thread's context * FUNCTIONS: Switches to another thread's context
* ARGUMENTS: * ARGUMENTS:
* Thread = Thread to switch to * Thread = Thread to switch to
* OldThread = Thread to switch from * OldThread = Thread to switch from
*/ */
pushl %ebp pushl %ebp
movl %esp, %ebp movl %esp, %ebp
@ -60,7 +63,7 @@ _Ki386ContextSwitch:
* Get the pointer to the new thread. * Get the pointer to the new thread.
*/ */
movl 8(%ebp), %ebx movl 8(%ebp), %ebx
/* /*
* Set the base of the TEB selector to the base of the TEB for * Set the base of the TEB selector to the base of the TEB for
* this thread. * this thread.
@ -89,7 +92,7 @@ _Ki386ContextSwitch:
xorl %eax, %eax xorl %eax, %eax
movl KTHREAD_APCSTATE_PROCESS(%ebx), %edi movl KTHREAD_APCSTATE_PROCESS(%ebx), %edi
testw $0xFFFF, KPROCESS_LDT_DESCRIPTOR0(%edi) testw $0xFFFF, KPROCESS_LDT_DESCRIPTOR0(%edi)
jz .L4 jz 0f
pushl KPROCESS_LDT_DESCRIPTOR1(%edi) pushl KPROCESS_LDT_DESCRIPTOR1(%edi)
pushl KPROCESS_LDT_DESCRIPTOR0(%edi) pushl KPROCESS_LDT_DESCRIPTOR0(%edi)
@ -99,9 +102,15 @@ _Ki386ContextSwitch:
movl $LDT_SELECTOR, %eax movl $LDT_SELECTOR, %eax
.L4: 0:
lldtw %ax lldtw %ax
movl 12(%ebp), %ebx
/*
* FIXME: Save debugging state.
*/
/* /*
* Load up the iomap offset for this thread in * Load up the iomap offset for this thread in
* preparation for setting it below. * preparation for setting it below.
@ -109,25 +118,19 @@ _Ki386ContextSwitch:
movl KPROCESS_IOPM_OFFSET(%edi), %eax movl KPROCESS_IOPM_OFFSET(%edi), %eax
/* /*
* FIXME: Save debugging state. * Save the stack pointer in this processors TSS
*/
/*
* FIXME: Save floating point state.
*/ */
movl %fs:KPCR_TSS, %esi
pushl KTSS_ESP0(%esi)
/* /*
* Switch stacks * Switch stacks
*/ */
movl 12(%ebp), %ebx
movl %esp, KTHREAD_KERNEL_STACK(%ebx) movl %esp, KTHREAD_KERNEL_STACK(%ebx)
movl 8(%ebp), %ebx movl 8(%ebp), %ebx
movl KTHREAD_KERNEL_STACK(%ebx), %esp movl KTHREAD_KERNEL_STACK(%ebx), %esp
movl KTHREAD_STACK_LIMIT(%ebx), %edi movl KTHREAD_STACK_LIMIT(%ebx), %edi
/*
* Set the stack pointer in this processors TSS
*/
movl %fs:KPCR_TSS, %esi movl %fs:KPCR_TSS, %esi
/* /*
@ -135,19 +138,28 @@ _Ki386ContextSwitch:
*/ */
movw %ax, KTSS_IOMAPBASE(%esi) movw %ax, KTSS_IOMAPBASE(%esi)
movl KTHREAD_INITIAL_STACK(%ebx), %eax
movl %eax, KTSS_ESP0(%esi)
/* /*
* Change the address space * Change the address space
*/ */
movl KTHREAD_APCSTATE_PROCESS(%ebx), %ebx movl KTHREAD_APCSTATE_PROCESS(%ebx), %eax
movl KPROCESS_DIRECTORY_TABLE_BASE(%ebx), %eax movl KPROCESS_DIRECTORY_TABLE_BASE(%eax), %eax
movl %eax, %cr3 movl %eax, %cr3
/* /*
* FIXME: Restore floating point state * Restore the stack pointer in this processors TSS
*/ */
popl KTSS_ESP0(%esi)
/*
* Set TS in cr0 to catch FPU code and load the FPU state when needed
* We do this only if NewThread != KPCR->NpxThread
*/
cmpl %ebx, %fs:KPCR_NPX_THREAD
je 1f
movl %cr0, %eax
orl $X86_CR0_TS, %eax
movl %eax, %cr0
1:
/* /*
* FIXME: Restore debugging state * FIXME: Restore debugging state
@ -162,9 +174,9 @@ _Ki386ContextSwitch:
call _KeReleaseSpinLockFromDpcLevel@4 call _KeReleaseSpinLockFromDpcLevel@4
cmpl $0, _PiNrThreadsAwaitingReaping cmpl $0, _PiNrThreadsAwaitingReaping
je .L3 je 4f
call _PiWakeupReaperThread@0 call _PiWakeupReaperThread@0
.L3: 4:
/* /*
* Restore the saved register and exit * Restore the saved register and exit
@ -175,3 +187,5 @@ _Ki386ContextSwitch:
popl %ebp popl %ebp
ret ret
.endfunc

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

@ -134,7 +134,7 @@ Ki386ApplicationProcessorInitializeTSS(VOID)
KeGetCurrentKPCR()->TSS = Tss; KeGetCurrentKPCR()->TSS = Tss;
/* Initialize the boot TSS. */ /* Initialize the boot TSS. */
Tss->Esp0 = (ULONG)Ki386InitialStackArray[Id]; Tss->Esp0 = (ULONG)Ki386InitialStackArray[Id] + MM_STACK_SIZE; /* FIXME: - sizeof(FX_SAVE_AREA)? */
Tss->Ss0 = KERNEL_DS; Tss->Ss0 = KERNEL_DS;
Tss->IoMapBase = 0xFFFF; /* No i/o bitmap */ Tss->IoMapBase = 0xFFFF; /* No i/o bitmap */
Tss->IoBitmap[8192] = 0xFF; Tss->IoBitmap[8192] = 0xFF;
@ -154,9 +154,9 @@ Ki386ApplicationProcessorInitializeTSS(VOID)
/* Initialize the TSS used for handling double faults. */ /* Initialize the TSS used for handling double faults. */
TrapTss->Eflags = 0; TrapTss->Eflags = 0;
TrapTss->Esp0 = ((ULONG)TrapStack + MM_STACK_SIZE); TrapTss->Esp0 = ((ULONG)TrapStack + MM_STACK_SIZE); /* FIXME: - sizeof(FX_SAVE_AREA)? */
TrapTss->Ss0 = KERNEL_DS; TrapTss->Ss0 = KERNEL_DS;
TrapTss->Esp = ((ULONG)TrapStack + MM_STACK_SIZE); TrapTss->Esp = ((ULONG)TrapStack + MM_STACK_SIZE); /* FIXME: - sizeof(FX_SAVE_AREA)? */
TrapTss->Cs = KERNEL_CS; TrapTss->Cs = KERNEL_CS;
TrapTss->Eip = (ULONG)KiTrap8; TrapTss->Eip = (ULONG)KiTrap8;
TrapTss->Ss = KERNEL_DS; TrapTss->Ss = KERNEL_DS;
@ -211,7 +211,7 @@ Ki386BootInitializeTSS(VOID)
Ki386InitialStackArray[0] = (PVOID)&init_stack; Ki386InitialStackArray[0] = (PVOID)&init_stack;
/* Initialize the boot TSS. */ /* Initialize the boot TSS. */
KiBootTss.Esp0 = (ULONG)&init_stack_top; KiBootTss.Esp0 = (ULONG)&init_stack_top - sizeof(FX_SAVE_AREA);
KiBootTss.Ss0 = KERNEL_DS; KiBootTss.Ss0 = KERNEL_DS;
// KiBootTss.IoMapBase = FIELD_OFFSET(KTSS, IoBitmap); // KiBootTss.IoMapBase = FIELD_OFFSET(KTSS, IoBitmap);
KiBootTss.IoMapBase = 0xFFFF; /* No i/o bitmap */ KiBootTss.IoMapBase = 0xFFFF; /* No i/o bitmap */
@ -232,9 +232,9 @@ Ki386BootInitializeTSS(VOID)
/* Initialize the TSS used for handling double faults. */ /* Initialize the TSS used for handling double faults. */
KiBootTrapTss.Eflags = 0; KiBootTrapTss.Eflags = 0;
KiBootTrapTss.Esp0 = (ULONG)&trap_stack_top; KiBootTrapTss.Esp0 = (ULONG)&trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */
KiBootTrapTss.Ss0 = KERNEL_DS; KiBootTrapTss.Ss0 = KERNEL_DS;
KiBootTrapTss.Esp = (ULONG)&trap_stack_top; KiBootTrapTss.Esp = (ULONG)&trap_stack_top; /* FIXME: - sizeof(FX_SAVE_AREA)? */
KiBootTrapTss.Cs = KERNEL_CS; KiBootTrapTss.Cs = KERNEL_CS;
KiBootTrapTss.Eip = (ULONG)KiTrap8; KiBootTrapTss.Eip = (ULONG)KiTrap8;
KiBootTrapTss.Ss = KERNEL_DS; KiBootTrapTss.Ss = KERNEL_DS;

33
reactos/ntoskrnl/ke/i386/v86m_sup.S
View file

@ -71,25 +71,19 @@ _Ki386RetToV86Mode:
* Since we are going to fiddle with the stack pointer this must be * Since we are going to fiddle with the stack pointer this must be
* a critical section for this processor * a critical section for this processor
*/ */
cli
/*
* Save the old initial stack /*
*/ * Save the exception handler stack from the TSS
movl %fs:KPCR_CURRENT_THREAD, %esi */
movl KTHREAD_INITIAL_STACK(%esi), %edi movl %fs:KPCR_TSS, %esi
pushl %edi pushl KTSS_ESP0(%esi)
/*
* We also need to set the stack in the kthread structure
*/
movl %esp, KTHREAD_INITIAL_STACK(%esi)
/* /*
* The stack used for handling exceptions from v86 mode in this thread * The stack used for handling exceptions from v86 mode in this thread
* will be the current stack adjusted so we don't overwrite the * will be the current stack adjusted so we don't overwrite the
* existing stack frames * existing stack frames
*/ */
movl %fs:KPCR_TSS, %esi
movl %esp, KTSS_ESP0(%esi) movl %esp, KTSS_ESP0(%esi)
/* /*
@ -180,18 +174,10 @@ _KiV86Complete:
cli cli
/* /*
* Restore the initial stack * Restore the exception handler stack in the TSS
*/ */
popl %eax
movl %fs:KPCR_TSS, %esi movl %fs:KPCR_TSS, %esi
movl %eax, KTSS_ESP0(%esi) popl KTSS_ESP0(%esi)
/*
* We also need to set the stack in the kthread structure
*/
movl %fs:KPCR_CURRENT_THREAD, %esi
movl KTHREAD_INITIAL_STACK(%esi), %edi
movl %eax, KTHREAD_INITIAL_STACK(%esi)
/* Exit the critical section */ /* Exit the critical section */
sti sti
@ -207,3 +193,4 @@ _KiV86Complete:
movl %ebp, %esp movl %ebp, %esp
popl %ebp popl %ebp
ret ret

11
reactos/ntoskrnl/ke/main.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* $Id: main.c,v 1.205 2004/11/13 22:30:18 hbirr Exp $ /* $Id: main.c,v 1.206 2004/11/20 23:46:37 blight Exp $
* *
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/main.c * FILE: ntoskrnl/ke/main.c
@ -299,6 +299,7 @@ ExpInitializeExecutive(VOID)
ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK); ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB); ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK); ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
ASSERT(FIELD_OFFSET(KTHREAD, NpxState) == KTHREAD_NPX_STATE);
ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE); ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE); ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME); ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
@ -309,12 +310,20 @@ ExpInitializeExecutive(VOID)
ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET); ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0); ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
ASSERT(FIELD_OFFSET(KTRAP_FRAME, Reserved9) == KTRAP_FRAME_RESERVED9); ASSERT(FIELD_OFFSET(KTRAP_FRAME, Reserved9) == KTRAP_FRAME_RESERVED9);
ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, SavedExceptionStack) == TF_SAVED_EXCEPTION_STACK);
ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS); ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS);
ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP); ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP);
ASSERT(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST); ASSERT(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST);
ASSERT(FIELD_OFFSET(KPCR, Self) == KPCR_SELF); ASSERT(FIELD_OFFSET(KPCR, Self) == KPCR_SELF);
ASSERT(FIELD_OFFSET(KPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD); ASSERT(FIELD_OFFSET(KPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
ASSERT(FIELD_OFFSET(KPCR, PrcbData) + FIELD_OFFSET(KPRCB, NpxThread) == KPCR_NPX_THREAD);
ASSERT(FIELD_OFFSET(KTSS, Esp0) == KTSS_ESP0);
ASSERT(FIELD_OFFSET(KTSS, Eflags) == KTSS_EFLAGS);
ASSERT(FIELD_OFFSET(KTSS, IoMapBase) == KTSS_IOMAPBASE);
ASSERT(sizeof(FX_SAVE_AREA) == SIZEOF_FX_SAVE_AREA);
LdrInit1(); LdrInit1();

19
reactos/ntoskrnl/ps/debug.c
View file

@ -17,7 +17,7 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* $Id: debug.c,v 1.14 2004/10/24 20:37:27 weiden Exp $ /* $Id: debug.c,v 1.15 2004/11/20 23:46:37 blight Exp $
* *
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ps/debug.c * FILE: ntoskrnl/ps/debug.c
@ -77,6 +77,9 @@ KeContextToTrapFrame(PCONTEXT Context,
{ {
/* /*
* Not handled * Not handled
*
* This should be handled separately I think.
* - blight
*/ */
} }
if ((Context->ContextFlags & CONTEXT_DEBUG_REGISTERS) == CONTEXT_DEBUG_REGISTERS) if ((Context->ContextFlags & CONTEXT_DEBUG_REGISTERS) == CONTEXT_DEBUG_REGISTERS)
@ -129,19 +132,33 @@ KeTrapFrameToContext(PKTRAP_FRAME TrapFrame,
/* /*
* FIXME: Implement this case * FIXME: Implement this case
*/ */
Context->ContextFlags &= (~CONTEXT_DEBUG_REGISTERS) | CONTEXT_i386;
} }
if ((Context->ContextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT) if ((Context->ContextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT)
{ {
/* /*
* FIXME: Implement this case * FIXME: Implement this case
*
* I think this should only be filled for FPU exceptions, otherwise I
* would not know where to get it from as it can be the current state
* of the FPU or already saved in the thread's FPU save area.
* -blight
*/ */
Context->ContextFlags &= (~CONTEXT_FLOATING_POINT) | CONTEXT_i386;
} }
#if 0 #if 0
if ((Context->ContextFlags & CONTEXT_EXTENDED_REGISTERS) == CONTEXT_EXTENDED_REGISTERS) if ((Context->ContextFlags & CONTEXT_EXTENDED_REGISTERS) == CONTEXT_EXTENDED_REGISTERS)
{ {
/* /*
* FIXME: Investigate this * FIXME: Investigate this
*
* This is the XMM state (first 512 bytes of FXSAVE_FORMAT/FX_SAVE_AREA)
* This should only be filled in case of a SIMD exception I think, so
* this is not the right place (like for FPU the state could already be
* saved in the thread's FX_SAVE_AREA or still be in the CPU)
* -blight
*/ */
Context->ContextFlags &= ~CONTEXT_EXTENDED_REGISTERS;
} }
#endif #endif
} }

32
reactos/ntoskrnl/ps/i386/continue.c
View file

@ -1,4 +1,4 @@
/* $Id: continue.c,v 1.5 2004/08/15 16:39:11 chorns Exp $ /* $Id: continue.c,v 1.6 2004/11/20 23:46:37 blight Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -32,6 +32,8 @@ NtContinue (
{ {
PKTRAP_FRAME TrapFrame = KeGetCurrentThread()->TrapFrame; PKTRAP_FRAME TrapFrame = KeGetCurrentThread()->TrapFrame;
PKTRAP_FRAME PrevTrapFrame = (PKTRAP_FRAME)TrapFrame->Edx; PKTRAP_FRAME PrevTrapFrame = (PKTRAP_FRAME)TrapFrame->Edx;
PFX_SAVE_AREA FxSaveArea;
KIRQL oldIrql;
DPRINT("NtContinue: Context: Eip=0x%x, Esp=0x%x\n", Context->Eip, Context->Esp ); DPRINT("NtContinue: Context: Eip=0x%x, Esp=0x%x\n", Context->Eip, Context->Esp );
PULONG Frame = 0; PULONG Frame = 0;
@ -54,12 +56,32 @@ NtContinue (
} }
/* /*
* Copy the supplied context over the register information that was saved * Copy the supplied context over the register information that was saved
* on entry to kernel mode, it will then be restored on exit * on entry to kernel mode, it will then be restored on exit
* FIXME: Validate the context * FIXME: Validate the context
*/ */
KeContextToTrapFrame ( Context, TrapFrame ); KeContextToTrapFrame ( Context, TrapFrame );
/* Put the floating point context into the thread's FX_SAVE_AREA
* and make sure it is reloaded when needed.
*/
FxSaveArea = (PFX_SAVE_AREA)((ULONG_PTR)KeGetCurrentThread()->InitialStack - sizeof(FX_SAVE_AREA));
if (KiContextToFxSaveArea(FxSaveArea, Context))
{
KeGetCurrentThread()->NpxState = NPX_STATE_VALID;
KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
if (KeGetCurrentKPCR()->PrcbData.NpxThread == KeGetCurrentThread())
{
KeGetCurrentKPCR()->PrcbData.NpxThread = NULL;
Ke386SetCr0(Ke386GetCr0() | X86_CR0_TS);
}
else
{
ASSERT((Ke386GetCr0() & X86_CR0_TS) == X86_CR0_TS);
}
KeLowerIrql(oldIrql);
}
KeRosTrapReturn ( TrapFrame, PrevTrapFrame ); KeRosTrapReturn ( TrapFrame, PrevTrapFrame );
return STATUS_SUCCESS; /* this doesn't actually happen b/c KeRosTrapReturn() won't return */ return STATUS_SUCCESS; /* this doesn't actually happen b/c KeRosTrapReturn() won't return */

11
reactos/ntoskrnl/ps/kill.c
View file

@ -1,4 +1,4 @@
/* $Id: kill.c,v 1.84 2004/11/20 16:46:05 weiden Exp $ /* $Id: kill.c,v 1.85 2004/11/20 23:46:37 blight Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -136,10 +136,17 @@ PsTerminateCurrentThread(NTSTATUS ExitStatus)
CurrentThread->ExitStatus = ExitStatus; CurrentThread->ExitStatus = ExitStatus;
KeQuerySystemTime((PLARGE_INTEGER)&CurrentThread->ExitTime); KeQuerySystemTime((PLARGE_INTEGER)&CurrentThread->ExitTime);
KeCancelTimer(&CurrentThread->Tcb.Timer); KeCancelTimer(&CurrentThread->Tcb.Timer);
/* If the ProcessoR Control Block's NpxThread points to the current thread
* unset it.
*/
InterlockedCompareExchange((LONG *)&KeGetCurrentKPCR()->PrcbData.NpxThread,
(LONG)NULL, (LONG)ETHREAD_TO_KTHREAD(CurrentThread));
KeReleaseSpinLock(&PiThreadLock, oldIrql); KeReleaseSpinLock(&PiThreadLock, oldIrql);
PsLockProcess(CurrentProcess, FALSE); PsLockProcess(CurrentProcess, FALSE);
/* Remove the thread from the thread list of its process */ /* Remove the thread from the thread list of its process */
RemoveEntryList(&CurrentThread->ThreadListEntry); RemoveEntryList(&CurrentThread->ThreadListEntry);
Last = IsListEmpty(&CurrentProcess->ThreadListHead); Last = IsListEmpty(&CurrentProcess->ThreadListHead);

45
reactos/ntoskrnl/ps/w32call.c
View file

@ -1,4 +1,4 @@
/* $Id: w32call.c,v 1.17 2004/10/30 23:48:57 navaraf Exp $ /* $Id: w32call.c,v 1.18 2004/11/20 23:46:37 blight Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -44,6 +44,7 @@ typedef struct _NTW32CALL_SAVED_STATE
PNTSTATUS CallbackStatus; PNTSTATUS CallbackStatus;
PKTRAP_FRAME SavedTrapFrame; PKTRAP_FRAME SavedTrapFrame;
PVOID SavedCallbackStack; PVOID SavedCallbackStack;
PVOID SavedExceptionStack;
} NTW32CALL_SAVED_STATE, *PNTW32CALL_SAVED_STATE; } NTW32CALL_SAVED_STATE, *PNTW32CALL_SAVED_STATE;
typedef struct typedef struct
@ -81,6 +82,7 @@ NtCallbackReturn (PVOID Result,
PNTW32CALL_SAVED_STATE State; PNTW32CALL_SAVED_STATE State;
PKTRAP_FRAME SavedTrapFrame; PKTRAP_FRAME SavedTrapFrame;
PVOID SavedCallbackStack; PVOID SavedCallbackStack;
PVOID SavedExceptionStack;
Thread = PsGetCurrentThread(); Thread = PsGetCurrentThread();
if (Thread->Tcb.CallbackStack == NULL) if (Thread->Tcb.CallbackStack == NULL)
@ -102,7 +104,8 @@ NtCallbackReturn (PVOID Result,
StackLimit = State->SavedStackLimit; StackLimit = State->SavedStackLimit;
SavedTrapFrame = State->SavedTrapFrame; SavedTrapFrame = State->SavedTrapFrame;
SavedCallbackStack = State->SavedCallbackStack; SavedCallbackStack = State->SavedCallbackStack;
SavedExceptionStack = State->SavedExceptionStack;
/* /*
* Copy the callback status and the callback result to NtW32Call * Copy the callback status and the callback result to NtW32Call
*/ */
@ -124,12 +127,20 @@ NtCallbackReturn (PVOID Result,
* Restore the old stack. * Restore the old stack.
*/ */
KeRaiseIrql(HIGH_LEVEL, &oldIrql); KeRaiseIrql(HIGH_LEVEL, &oldIrql);
if ((Thread->Tcb.NpxState & NPX_STATE_VALID) &&
ETHREAD_TO_KTHREAD(Thread) != KeGetCurrentKPCR()->PrcbData.NpxThread)
{
memcpy((char*)InitialStack - sizeof(FX_SAVE_AREA),
(char*)Thread->Tcb.InitialStack - sizeof(FX_SAVE_AREA),
sizeof(FX_SAVE_AREA));
}
Thread->Tcb.InitialStack = InitialStack; Thread->Tcb.InitialStack = InitialStack;
Thread->Tcb.StackBase = StackBase; Thread->Tcb.StackBase = StackBase;
Thread->Tcb.StackLimit = StackLimit; Thread->Tcb.StackLimit = StackLimit;
Thread->Tcb.TrapFrame = SavedTrapFrame; Thread->Tcb.TrapFrame = SavedTrapFrame;
Thread->Tcb.CallbackStack = SavedCallbackStack; Thread->Tcb.CallbackStack = SavedCallbackStack;
KeGetCurrentKPCR()->TSS->Esp0 = (ULONG)Thread->Tcb.InitialStack; KeGetCurrentKPCR()->TSS->Esp0 = (ULONG)SavedExceptionStack;
Ke386SetCr0(Ke386GetCr0() | X86_CR0_TS); /* set TS */
KeStackSwitchAndRet((PVOID)(OldStack + 1)); KeStackSwitchAndRet((PVOID)(OldStack + 1));
/* Should never return. */ /* Should never return. */
@ -258,7 +269,7 @@ NtW32Call (IN ULONG RoutineIndex,
Thread = PsGetCurrentThread(); Thread = PsGetCurrentThread();
/* Set up the new kernel and user environment. */ /* Set up the new kernel and user environment. */
StackSize = (ULONG_PTR)(Thread->Tcb.StackBase - Thread->Tcb.StackLimit); StackSize = (ULONG_PTR)Thread->Tcb.StackBase - Thread->Tcb.StackLimit;
KeAcquireSpinLock(&CallbackStackListLock, &oldIrql); KeAcquireSpinLock(&CallbackStackListLock, &oldIrql);
if (IsListEmpty(&CallbackStackListHead)) if (IsListEmpty(&CallbackStackListHead))
{ {
@ -274,18 +285,18 @@ NtW32Call (IN ULONG RoutineIndex,
StackEntry = RemoveHeadList(&CallbackStackListHead); StackEntry = RemoveHeadList(&CallbackStackListHead);
KeReleaseSpinLock(&CallbackStackListLock, oldIrql); KeReleaseSpinLock(&CallbackStackListLock, oldIrql);
AssignedStack = CONTAINING_RECORD(StackEntry, NTW32CALL_CALLBACK_STACK, AssignedStack = CONTAINING_RECORD(StackEntry, NTW32CALL_CALLBACK_STACK,
ListEntry); ListEntry);
NewStack = AssignedStack->BaseAddress; NewStack = AssignedStack->BaseAddress;
MmUpdatePageDir(PsGetCurrentProcess(), NewStack, StackSize); MmUpdatePageDir(PsGetCurrentProcess(), NewStack, StackSize);
} }
/* FIXME: Need to check whether we were interrupted from v86 mode. */ /* FIXME: Need to check whether we were interrupted from v86 mode. */
memcpy((char*)NewStack + StackSize - sizeof(KTRAP_FRAME), Thread->Tcb.TrapFrame, memcpy((char*)NewStack + StackSize - sizeof(KTRAP_FRAME) - sizeof(FX_SAVE_AREA),
sizeof(KTRAP_FRAME) - (4 * sizeof(DWORD))); Thread->Tcb.TrapFrame, sizeof(KTRAP_FRAME) - (4 * sizeof(DWORD)));
NewFrame = (PKTRAP_FRAME)((char*)NewStack + StackSize - sizeof(KTRAP_FRAME)); NewFrame = (PKTRAP_FRAME)((char*)NewStack + StackSize - sizeof(KTRAP_FRAME) - sizeof(FX_SAVE_AREA));
NewFrame->Esp -= (ArgumentLength + (4 * sizeof(ULONG))); NewFrame->Esp -= (ArgumentLength + (4 * sizeof(ULONG)));
NewFrame->Eip = (ULONG)LdrpGetSystemDllCallbackDispatcher(); NewFrame->Eip = (ULONG)LdrpGetSystemDllCallbackDispatcher();
UserEsp = (PULONG)NewFrame->Esp; UserEsp = (PULONG)NewFrame->Esp;
UserEsp[0] = 0; /* Return address. */ UserEsp[0] = 0; /* Return address. */
@ -304,10 +315,18 @@ NtW32Call (IN ULONG RoutineIndex,
SavedState.CallbackStatus = &CallbackStatus; SavedState.CallbackStatus = &CallbackStatus;
SavedState.SavedTrapFrame = Thread->Tcb.TrapFrame; SavedState.SavedTrapFrame = Thread->Tcb.TrapFrame;
SavedState.SavedCallbackStack = Thread->Tcb.CallbackStack; SavedState.SavedCallbackStack = Thread->Tcb.CallbackStack;
SavedState.SavedExceptionStack = (PVOID)KeGetCurrentKPCR()->TSS->Esp0;
if ((Thread->Tcb.NpxState & NPX_STATE_VALID) &&
ETHREAD_TO_KTHREAD(Thread) != KeGetCurrentKPCR()->PrcbData.NpxThread)
{
memcpy((char*)NewStack + StackSize - sizeof(FX_SAVE_AREA),
(char*)SavedState.SavedInitialStack - sizeof(FX_SAVE_AREA),
sizeof(FX_SAVE_AREA));
}
Thread->Tcb.InitialStack = Thread->Tcb.StackBase = (char*)NewStack + StackSize; Thread->Tcb.InitialStack = Thread->Tcb.StackBase = (char*)NewStack + StackSize;
Thread->Tcb.StackLimit = (ULONG_PTR)NewStack; Thread->Tcb.StackLimit = (ULONG)NewStack;
Thread->Tcb.KernelStack = (char*)NewStack + StackSize - sizeof(KTRAP_FRAME); Thread->Tcb.KernelStack = (char*)NewStack + StackSize - sizeof(KTRAP_FRAME) - sizeof(FX_SAVE_AREA);
KeGetCurrentKPCR()->TSS->Esp0 = (ULONG)Thread->Tcb.InitialStack; KeGetCurrentKPCR()->TSS->Esp0 = (ULONG)Thread->Tcb.InitialStack - sizeof(FX_SAVE_AREA);
KePushAndStackSwitchAndSysRet((ULONG)&SavedState, Thread->Tcb.KernelStack); KePushAndStackSwitchAndSysRet((ULONG)&SavedState, Thread->Tcb.KernelStack);
/* /*