Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
/*
|
|
|
|
* PROJECT: ReactOS Kernel
|
|
|
|
* LICENSE: BSD - See COPYING.ARM in the top level directory
|
|
|
|
* FILE: ntoskrnl/include/trap_x.h
|
|
|
|
* PURPOSE: Internal Inlined Functions for the Trap Handling Code
|
|
|
|
* PROGRAMMERS: ReactOS Portable Systems Group
|
|
|
|
*/
|
2010-02-26 11:43:19 +00:00
|
|
|
|
|
|
|
#pragma once
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
|
2010-03-17 13:12:46 +00:00
|
|
|
//#define TRAP_DEBUG 1
|
|
|
|
|
2010-01-24 05:40:04 +00:00
|
|
|
//
|
2010-01-24 15:18:50 +00:00
|
|
|
// Unreachable code hint for GCC 4.5.x, older GCC versions, and MSVC
|
2010-01-24 05:40:04 +00:00
|
|
|
//
|
2010-01-24 15:18:50 +00:00
|
|
|
#ifdef __GNUC__
|
2010-01-24 01:35:25 +00:00
|
|
|
#if __GNUC__ * 100 + __GNUC_MINOR__ >= 405
|
|
|
|
#define UNREACHABLE __builtin_unreachable()
|
2010-01-24 15:18:50 +00:00
|
|
|
#else
|
2010-01-24 05:40:04 +00:00
|
|
|
#define UNREACHABLE __builtin_trap()
|
2010-01-24 15:18:50 +00:00
|
|
|
#endif
|
2010-01-24 05:40:04 +00:00
|
|
|
#elif _MSC_VER
|
|
|
|
#define UNREACHABLE __assume(0)
|
2010-01-24 01:58:20 +00:00
|
|
|
#else
|
2010-01-24 02:25:20 +00:00
|
|
|
#define UNREACHABLE
|
|
|
|
#endif
|
|
|
|
|
2010-03-17 13:12:46 +00:00
|
|
|
//
|
|
|
|
// Helper Code
|
|
|
|
//
|
|
|
|
BOOLEAN
|
|
|
|
FORCEINLINE
|
|
|
|
KiUserTrap(IN PKTRAP_FRAME TrapFrame)
|
|
|
|
{
|
|
|
|
/* Anything else but Ring 0 is Ring 3 */
|
|
|
|
return (TrapFrame->SegCs & MODE_MASK);
|
|
|
|
}
|
|
|
|
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
//
|
|
|
|
// Debug Macros
|
|
|
|
//
|
|
|
|
VOID
|
2010-01-19 18:27:24 +00:00
|
|
|
FORCEINLINE
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
KiDumpTrapFrame(IN PKTRAP_FRAME TrapFrame)
|
|
|
|
{
|
|
|
|
/* Dump the whole thing */
|
2010-01-24 05:40:04 +00:00
|
|
|
DbgPrint("DbgEbp: %x\n", TrapFrame->DbgEbp);
|
|
|
|
DbgPrint("DbgEip: %x\n", TrapFrame->DbgEip);
|
|
|
|
DbgPrint("DbgArgMark: %x\n", TrapFrame->DbgArgMark);
|
|
|
|
DbgPrint("DbgArgPointer: %x\n", TrapFrame->DbgArgPointer);
|
|
|
|
DbgPrint("TempSegCs: %x\n", TrapFrame->TempSegCs);
|
|
|
|
DbgPrint("TempEsp: %x\n", TrapFrame->TempEsp);
|
|
|
|
DbgPrint("Dr0: %x\n", TrapFrame->Dr0);
|
|
|
|
DbgPrint("Dr1: %x\n", TrapFrame->Dr1);
|
|
|
|
DbgPrint("Dr2: %x\n", TrapFrame->Dr2);
|
|
|
|
DbgPrint("Dr3: %x\n", TrapFrame->Dr3);
|
|
|
|
DbgPrint("Dr6: %x\n", TrapFrame->Dr6);
|
|
|
|
DbgPrint("Dr7: %x\n", TrapFrame->Dr7);
|
|
|
|
DbgPrint("SegGs: %x\n", TrapFrame->SegGs);
|
|
|
|
DbgPrint("SegEs: %x\n", TrapFrame->SegEs);
|
|
|
|
DbgPrint("SegDs: %x\n", TrapFrame->SegDs);
|
|
|
|
DbgPrint("Edx: %x\n", TrapFrame->Edx);
|
|
|
|
DbgPrint("Ecx: %x\n", TrapFrame->Ecx);
|
|
|
|
DbgPrint("Eax: %x\n", TrapFrame->Eax);
|
|
|
|
DbgPrint("PreviousPreviousMode: %x\n", TrapFrame->PreviousPreviousMode);
|
|
|
|
DbgPrint("ExceptionList: %x\n", TrapFrame->ExceptionList);
|
|
|
|
DbgPrint("SegFs: %x\n", TrapFrame->SegFs);
|
|
|
|
DbgPrint("Edi: %x\n", TrapFrame->Edi);
|
|
|
|
DbgPrint("Esi: %x\n", TrapFrame->Esi);
|
|
|
|
DbgPrint("Ebx: %x\n", TrapFrame->Ebx);
|
|
|
|
DbgPrint("Ebp: %x\n", TrapFrame->Ebp);
|
|
|
|
DbgPrint("ErrCode: %x\n", TrapFrame->ErrCode);
|
|
|
|
DbgPrint("Eip: %x\n", TrapFrame->Eip);
|
|
|
|
DbgPrint("SegCs: %x\n", TrapFrame->SegCs);
|
|
|
|
DbgPrint("EFlags: %x\n", TrapFrame->EFlags);
|
|
|
|
DbgPrint("HardwareEsp: %x\n", TrapFrame->HardwareEsp);
|
|
|
|
DbgPrint("HardwareSegSs: %x\n", TrapFrame->HardwareSegSs);
|
|
|
|
DbgPrint("V86Es: %x\n", TrapFrame->V86Es);
|
|
|
|
DbgPrint("V86Ds: %x\n", TrapFrame->V86Ds);
|
|
|
|
DbgPrint("V86Fs: %x\n", TrapFrame->V86Fs);
|
|
|
|
DbgPrint("V86Gs: %x\n", TrapFrame->V86Gs);
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
|
2010-01-24 05:40:04 +00:00
|
|
|
#ifdef TRAP_DEBUG
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
VOID
|
2010-01-24 05:40:04 +00:00
|
|
|
FORCEINLINE
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
KiFillTrapFrameDebug(IN PKTRAP_FRAME TrapFrame)
|
|
|
|
{
|
|
|
|
/* Set the debug information */
|
|
|
|
TrapFrame->DbgArgPointer = TrapFrame->Edx;
|
|
|
|
TrapFrame->DbgArgMark = 0xBADB0D00;
|
|
|
|
TrapFrame->DbgEip = TrapFrame->Eip;
|
|
|
|
TrapFrame->DbgEbp = TrapFrame->Ebp;
|
2010-03-17 13:12:46 +00:00
|
|
|
TrapFrame->PreviousPreviousMode = -1;
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VOID
|
2010-01-24 05:40:04 +00:00
|
|
|
FORCEINLINE
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
KiExitTrapDebugChecks(IN PKTRAP_FRAME TrapFrame,
|
2010-03-17 13:12:46 +00:00
|
|
|
IN KTRAP_EXIT_SKIP_BITS SkipBits)
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
{
|
|
|
|
/* Make sure interrupts are disabled */
|
|
|
|
if (__readeflags() & EFLAGS_INTERRUPT_MASK)
|
|
|
|
{
|
2010-01-24 05:40:04 +00:00
|
|
|
DbgPrint("Exiting with interrupts enabled: %lx\n", __readeflags());
|
2010-03-17 13:12:46 +00:00
|
|
|
__debugbreak();
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure this is a real trap frame */
|
|
|
|
if (TrapFrame->DbgArgMark != 0xBADB0D00)
|
|
|
|
{
|
2010-01-24 05:40:04 +00:00
|
|
|
DbgPrint("Exiting with an invalid trap frame? (No MAGIC in trap frame)\n");
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
KiDumpTrapFrame(TrapFrame);
|
2010-03-17 13:12:46 +00:00
|
|
|
__debugbreak();
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure we're not in user-mode or something */
|
|
|
|
if (Ke386GetFs() != KGDT_R0_PCR)
|
|
|
|
{
|
2010-01-24 05:40:04 +00:00
|
|
|
DbgPrint("Exiting with an invalid FS: %lx\n", Ke386GetFs());
|
2010-03-17 13:12:46 +00:00
|
|
|
__debugbreak();
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure we have a valid SEH chain */
|
2010-03-12 16:28:04 +00:00
|
|
|
if (KeGetPcr()->NtTib.ExceptionList == 0)
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
{
|
2010-03-12 16:28:04 +00:00
|
|
|
DbgPrint("Exiting with NULL exception chain: %p\n", KeGetPcr()->NtTib.ExceptionList);
|
2010-03-17 13:12:46 +00:00
|
|
|
__debugbreak();
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure we're restoring a valid SEH chain */
|
|
|
|
if (TrapFrame->ExceptionList == 0)
|
|
|
|
{
|
2010-01-24 05:40:04 +00:00
|
|
|
DbgPrint("Entered a trap with a NULL exception chain: %p\n", TrapFrame->ExceptionList);
|
2010-03-17 13:12:46 +00:00
|
|
|
__debugbreak();
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If we're ignoring previous mode, make sure caller doesn't actually want it */
|
2010-01-10 15:00:44 +00:00
|
|
|
if ((SkipBits.SkipPreviousMode) && (TrapFrame->PreviousPreviousMode != -1))
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
{
|
2010-03-17 13:12:46 +00:00
|
|
|
DbgPrint("Exiting a trap witout restoring previous mode, yet previous mode seems valid: %lx\n", TrapFrame->PreviousPreviousMode);
|
|
|
|
__debugbreak();
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
}
|
|
|
|
}
|
2010-01-19 09:20:40 +00:00
|
|
|
|
|
|
|
VOID
|
2010-01-24 05:40:04 +00:00
|
|
|
FORCEINLINE
|
2010-01-19 09:20:40 +00:00
|
|
|
KiExitSystemCallDebugChecks(IN ULONG SystemCall,
|
|
|
|
IN PKTRAP_FRAME TrapFrame)
|
|
|
|
{
|
|
|
|
KIRQL OldIrql;
|
|
|
|
|
|
|
|
/* Check if this was a user call */
|
2010-03-17 13:12:46 +00:00
|
|
|
if (KiUserTrap(TrapFrame))
|
2010-01-19 09:20:40 +00:00
|
|
|
{
|
|
|
|
/* Make sure we are not returning with elevated IRQL */
|
|
|
|
OldIrql = KeGetCurrentIrql();
|
|
|
|
if (OldIrql != PASSIVE_LEVEL)
|
|
|
|
{
|
|
|
|
/* Forcibly put us in a sane state */
|
2010-03-17 13:12:46 +00:00
|
|
|
KeGetPcr()->Irql = PASSIVE_LEVEL;
|
2010-01-19 09:20:40 +00:00
|
|
|
_disable();
|
|
|
|
|
|
|
|
/* Fail */
|
|
|
|
KeBugCheckEx(IRQL_GT_ZERO_AT_SYSTEM_SERVICE,
|
|
|
|
SystemCall,
|
|
|
|
OldIrql,
|
|
|
|
0,
|
|
|
|
0);
|
|
|
|
}
|
2010-03-17 13:12:46 +00:00
|
|
|
#if 0
|
2010-01-19 09:20:40 +00:00
|
|
|
/* Make sure we're not attached and that APCs are not disabled */
|
|
|
|
if ((KeGetCurrentThread()->ApcStateIndex != CurrentApcEnvironment) ||
|
|
|
|
(KeGetCurrentThread()->CombinedApcDisable != 0))
|
|
|
|
{
|
|
|
|
/* Fail */
|
|
|
|
KeBugCheckEx(APC_INDEX_MISMATCH,
|
|
|
|
SystemCall,
|
|
|
|
KeGetCurrentThread()->ApcStateIndex,
|
|
|
|
KeGetCurrentThread()->CombinedApcDisable,
|
|
|
|
0);
|
|
|
|
}
|
2010-03-17 13:12:46 +00:00
|
|
|
#endif
|
2010-01-19 09:20:40 +00:00
|
|
|
}
|
|
|
|
}
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
#else
|
|
|
|
#define KiExitTrapDebugChecks(x, y)
|
|
|
|
#define KiFillTrapFrameDebug(x)
|
2010-01-19 09:20:40 +00:00
|
|
|
#define KiExitSystemCallDebugChecks(x, y)
|
Trap Handlers in C Patch 1 of X (Patch by Sir_Richard <ros.arm@reactos.org>):
[NTOS]: The kernel normally does not save FPU state during Ring 0 transitions since the FPU should not be used. The one exception is when a kernel debugger is attached. Unfortunately, the latter check in ReactOS results in even "print on the serial line" to count as "debugger attached", and thus FPU state was almost always saved, slowing down traps significantly.
[NTOS]: The kernel also does not typically save DRx (debug) registers unless they were in use. During an exception dispatch, they are zeroed out, and later during trap exit, if any debug register is set, DR7 is updated to enable that hardware breakpoint. Unfortunately, the code to clear the debug registers had a bug: DR2 was never cleared. Because DR2 ended up being a random stack value during trap frame generation, this caused a bogus address to be added to DR2, and DR7 would then enable the 2nd hardware breakpoint. This caused the kernel to always save DRx state, which is slow, and worse, could cause random hardware breakpoints to fire.
[NTOS]: Start implementing trap handling in C. ASM trap handlers will now only be 5 lines of assembly including a function call to a C handler. All C handling code uses maximum two arguments and is all FASTCALL for efficiency.
[NTOS]: Implement C versions of TRAP_PROLOG and TRAP_EPILOG. Implement C version of Ki386EoiHelper. Implement C version of CommonDispatchException (and helper) and KiFatalSystemException. Implement C version of CHECK_FOR_APC_DELIVER. Implement trap debugging checks as a separate entity instead of always doing them.
[NTOS]: Add missing intrinsics for DS/ES/GS segment query.
The kernel is now ready for some trap handling to be done in C. Due to the FPU/Debug fixes and relaxation of paranoid debug checks, the C code will likely be faster than the original assembly.
svn path=/trunk/; revision=45000
2010-01-08 15:04:19 +00:00
|
|
|
#endif
|
|
|
|
|
2010-01-24 05:40:04 +00:00
|
|
|
//
|
|
|
|
// Generic Exit Routine
|
|
|
|
//
|
2010-03-18 16:30:54 +00:00
|
|
|
DECLSPEC_NORETURN VOID FASTCALL KiSystemCallReturn(IN PKTRAP_FRAME TrapFrame);
|
|
|
|
DECLSPEC_NORETURN VOID FASTCALL KiSystemCallSysExitReturn(IN PKTRAP_FRAME TrapFrame);
|
|
|
|
DECLSPEC_NORETURN VOID FASTCALL KiSystemCallTrapReturn(IN PKTRAP_FRAME TrapFrame);
|
|
|
|
DECLSPEC_NORETURN VOID FASTCALL KiEditedTrapReturn(IN PKTRAP_FRAME TrapFrame);
|
|
|
|
DECLSPEC_NORETURN VOID FASTCALL KiTrapReturn(IN PKTRAP_FRAME TrapFrame);
|
|
|
|
DECLSPEC_NORETURN VOID FASTCALL KiTrapReturnNoSegments(IN PKTRAP_FRAME TrapFrame);
|
2010-01-24 05:40:04 +00:00
|
|
|
|
2010-03-17 13:12:46 +00:00
|
|
|
typedef
|
|
|
|
VOID
|
|
|
|
(FASTCALL
|
2010-03-18 16:30:54 +00:00
|
|
|
*PFAST_SYSTEM_CALL_EXIT)(IN PKTRAP_FRAME TrapFrame);
|
2010-01-27 03:05:10 +00:00
|
|
|
|
2010-03-17 13:12:46 +00:00
|
|
|
extern PFAST_SYSTEM_CALL_EXIT KiFastCallExitHandler;
|
2010-01-24 05:40:04 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// Virtual 8086 Mode Optimized Trap Exit
|
|
|
|
//
|
|
|
|
VOID
|
|
|
|
FORCEINLINE
|
2010-03-17 13:12:46 +00:00
|
|
|
DECLSPEC_NORETURN
|
2010-01-24 05:40:04 +00:00
|
|
|
KiExitV86Trap(IN PKTRAP_FRAME TrapFrame)
|
|
|
|
{
|
|
|
|
PKTHREAD Thread;
|
|
|
|
KIRQL OldIrql;
|
|
|
|
|
|
|
|
/* Get the thread */
|
|
|
|
Thread = KeGetCurrentThread();
|
|
|
|
while (TRUE)
|
|
|
|
{
|
2010-03-17 13:12:46 +00:00
|
|
|
/* Return if this isn't V86 mode anymore */
|
|
|
|
if (!(TrapFrame->EFlags & EFLAGS_V86_MASK)) KiEoiHelper(TrapFrame);;
|
|
|
|
|
2010-01-24 05:40:04 +00:00
|
|
|
/* Turn off the alerted state for kernel mode */
|
|
|
|
Thread->Alerted[KernelMode] = FALSE;
|
|
|
|
|
|
|
|
/* Are there pending user APCs? */
|
|
|
|
if (__builtin_expect(!Thread->ApcState.UserApcPending, 1)) break;
|
|
|
|
|
|
|
|
/* Raise to APC level and enable interrupts */
|
|
|
|
OldIrql = KfRaiseIrql(APC_LEVEL);
|
|
|
|
_enable();
|
|
|
|
|
|
|
|
/* Deliver APCs */
|
|
|
|
KiDeliverApc(UserMode, NULL, TrapFrame);
|
|
|
|
|
|
|
|
/* Restore IRQL and disable interrupts once again */
|
|
|
|
KfLowerIrql(OldIrql);
|
|
|
|
_disable();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we got here, we're still in a valid V8086 context, so quit it */
|
|
|
|
if (__builtin_expect(TrapFrame->Dr7 & ~DR7_RESERVED_MASK, 0))
|
|
|
|
{
|
|
|
|
/* Not handled yet */
|
|
|
|
DbgPrint("Need Hardware Breakpoint Support!\n");
|
|
|
|
while (TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return from interrupt */
|
2010-03-17 13:12:46 +00:00
|
|
|
KiTrapReturnNoSegments(TrapFrame);
|
2010-01-24 05:40:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Virtual 8086 Mode Optimized Trap Entry
|
|
|
|
//
|
|
|
|
VOID
|
|
|
|
FORCEINLINE
|
|
|
|
KiEnterV86Trap(IN PKTRAP_FRAME TrapFrame)
|
|
|
|
{
|
2010-01-30 18:25:30 +00:00
|
|
|
/* Save exception list */
|
2010-03-12 16:28:04 +00:00
|
|
|
TrapFrame->ExceptionList = KeGetPcr()->NtTib.ExceptionList;
|
2010-01-24 05:40:04 +00:00
|
|
|
|
|
|
|
/* Save DR7 and check for debugging */
|
|
|
|
TrapFrame->Dr7 = __readdr(7);
|
|
|
|
if (__builtin_expect(TrapFrame->Dr7 & ~DR7_RESERVED_MASK, 0))
|
|
|
|
{
|
|
|
|
DbgPrint("Need Hardware Breakpoint Support!\n");
|
|
|
|
while (TRUE);
|
|
|
|
}
|
2010-01-19 09:20:40 +00:00
|
|
|
}
|
2010-01-19 09:45:30 +00:00
|
|
|
|
2010-01-24 05:40:04 +00:00
|
|
|
//
|
|
|
|
// Interrupt Trap Entry
|
|
|
|
//
|
|
|
|
VOID
|
2010-01-19 09:45:30 +00:00
|
|
|
FORCEINLINE
|
2010-01-24 05:40:04 +00:00
|
|
|
KiEnterInterruptTrap(IN PKTRAP_FRAME TrapFrame)
|
2010-01-19 09:45:30 +00:00
|
|
|
{
|
2010-01-24 05:40:04 +00:00
|
|
|
/* Save exception list and terminate it */
|
2010-03-12 16:28:04 +00:00
|
|
|
TrapFrame->ExceptionList = KeGetPcr()->NtTib.ExceptionList;
|
|
|
|
KeGetPcr()->NtTib.ExceptionList = EXCEPTION_CHAIN_END;
|
2010-01-30 18:25:30 +00:00
|
|
|
|
2010-01-24 05:40:04 +00:00
|
|
|
/* Flush DR7 and check for debugging */
|
|
|
|
TrapFrame->Dr7 = 0;
|
|
|
|
if (__builtin_expect(KeGetCurrentThread()->DispatcherHeader.DebugActive & 0xFF, 0))
|
|
|
|
{
|
|
|
|
DbgPrint("Need Hardware Breakpoint Support!\n");
|
|
|
|
while (TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set debug header */
|
|
|
|
KiFillTrapFrameDebug(TrapFrame);
|
|
|
|
}
|
2010-01-19 09:45:30 +00:00
|
|
|
|
2010-01-24 05:40:04 +00:00
|
|
|
//
|
|
|
|
// Generic Trap Entry
|
|
|
|
//
|
|
|
|
VOID
|
|
|
|
FORCEINLINE
|
|
|
|
KiEnterTrap(IN PKTRAP_FRAME TrapFrame)
|
|
|
|
{
|
2010-01-30 18:25:30 +00:00
|
|
|
/* Save exception list */
|
2010-03-12 16:28:04 +00:00
|
|
|
TrapFrame->ExceptionList = KeGetPcr()->NtTib.ExceptionList;
|
2010-01-24 05:40:04 +00:00
|
|
|
|
|
|
|
/* Flush DR7 and check for debugging */
|
|
|
|
TrapFrame->Dr7 = 0;
|
|
|
|
if (__builtin_expect(KeGetCurrentThread()->DispatcherHeader.DebugActive & 0xFF, 0))
|
|
|
|
{
|
|
|
|
DbgPrint("Need Hardware Breakpoint Support!\n");
|
|
|
|
while (TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set debug header */
|
|
|
|
KiFillTrapFrameDebug(TrapFrame);
|
2010-01-19 18:27:24 +00:00
|
|
|
}
|