Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-05 04:06:22 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/ntoskrnl/ke/i386/trap.s

258 lines
8.7 KiB
ArmAsm
Raw Normal View History

- Fix another V86 Mode exit bug which could cause non-volatiles to be incorrectly restored. - Make traps use the shared EOI (End Of Interrupt) helper instead of their own custom trap exit code. svn path=/trunk/; revision=20919
2006-01-16 19:59:32 +00:00
/*
[NTOS] Improve the FILE header section. Brought to you by Adam Stachowicz. CORE-10114 svn path=/trunk/; revision=69439
2015-10-04 11:54:25 +00:00
* FILE: ntoskrnl/ke/i386/trap.s
- Move some assembly functions around in better suited locations. - Merge syscall.S and trap.S into trap.S, and nicely document the software interrupt table that we service, as well as special cases. svn path=/trunk/; revision=20936
2006-01-17 06:36:35 +00:00
* COPYRIGHT: See COPYING in the top level directory
* PURPOSE: System Traps, Entrypoints and Exitpoints
* PROGRAMMER: Alex Ionescu (alex@relsoft.net)
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
* Timo Kreuzer (timo.kreuzer@reactos.org)
- Move some assembly functions around in better suited locations. - Merge syscall.S and trap.S into trap.S, and nicely document the software interrupt table that we service, as well as special cases. svn path=/trunk/; revision=20936
2006-01-17 06:36:35 +00:00
* NOTE: See asmmacro.S for the shared entry/exit code.
Added working set functions Seperated memory manager initialization Seperated trap functions Removed process/thread definitions from ddk headers Changed indentation back to sane style (please don't change) svn path=/trunk/; revision=1224
2000-07-04 08:52:47 +00:00
*/
All task switching is done in software. Beginnings of v86 mode support. Corrected locking bug when terminating multithreaded process. svn path=/trunk/; revision=1475
2000-12-23 02:37:41 +00:00
/* INCLUDES ******************************************************************/
Large partial cleanup of ntoskrnl internal headers, mostly to delete obsoleted or non-useful headers, to reformat some horrible tab, spaces, etc mixups, and to move to NDK some public structures and remove all the include headers so that the standard one can be added. Note the word partial, meaning more will come in order to fully fix the mess. svn path=/trunk/; revision=16268
2005-06-25 17:01:17 +00:00
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
#include <asm.inc>
#include <ks386.inc>
- Write the first of 3 shared trap prolog macros. Does not fully support V86 entry and DR saving yet. Used by all KiTraps (except double-fault for now) and KiDebugService. - Update asm.h with more stuff from ks386.inc. - Use only documented constants in syscall.S through asm.h. svn path=/trunk/; revision=20921
2006-01-16 21:14:32 +00:00
#include <internal/i386/asmmacro.S>
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
MACRO(GENERATE_IDT_STUB, Vector)
idt _KiUnexpectedInterrupt&Vector, INT_32_DPL0
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
ENDM
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
MACRO(GENERATE_INT_HANDLER, Vector)
[NTOS:KE][SDK:ASM] Code formatting/styling only. - Un-hardcode the RPL_MASK value. - s/KiUnexpectedInterrupt&Number/KiUnexpectedInterrupt&Vector/ - Use C-style comments in traphdlr.c as everywhere else in the file. - Update the URLs for the MSDN "FPO" macro documentation.
2019-02-04 00:02:26 +00:00
//.func KiUnexpectedInterrupt&Vector
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
_KiUnexpectedInterrupt&Vector:
/* This is a push instruction with 8bit operand. Since the instruction
sign extends the value to 32 bits, we need to offset it */
push (Vector - 128)
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
jmp _KiEndUnexpectedRange@0
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
//.endfunc
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
ENDM
Added working set functions Seperated memory manager initialization Seperated trap functions Removed process/thread definitions from ddk headers Changed indentation back to sane style (please don't change) svn path=/trunk/; revision=1224
2000-07-04 08:52:47 +00:00
- Update KeUpdateSystemTime to use variable increments. - Update KeTickCount properly instead of an ugly timecast hack. - Also update UserSharedData->TickCount. - Get rid of KiRawTicks. - Properly update KiTickOffset at the end. svn path=/trunk/; revision=23679
2006-08-24 06:27:29 +00:00
/* GLOBALS *******************************************************************/
- Move some assembly functions around in better suited locations. - Merge syscall.S and trap.S into trap.S, and nicely document the software interrupt table that we service, as well as special cases. svn path=/trunk/; revision=20936
2006-01-17 06:36:35 +00:00
- Put IDT in RW .data section - Fix Ki386InitializeTss to properly set Boot TSS descriptor data (set it to 32-bits). Also properly setup the DF/NMI Task Gates in the IDT. svn path=/trunk/; revision=24336
2006-10-01 07:24:24 +00:00
.data
[ASM] Fix boot with VS 16.7.3 / MSVC 19.27 See https://developercommunity.visualstudio.com/content/problem/1180800/ml-x86-assume-directive-causes-invalid-code-genera.html
2020-09-10 15:25:42 +00:00
ASSUME CS:nothing
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
[NTOSKRNL] Align the idt to 16 bytes. Fixes random boot problems on MSVC builds. svn path=/trunk/; revision=52647
2011-07-12 01:04:20 +00:00
.align 16
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
PUBLIC _KiIdt
- Use static IDT entries generated through a macro, instead of dynamically allocating them each boot. Note that we do not store them in an i386 compatible format, but much like NT, swap the bits so that our macro can more clearly define each entry. svn path=/trunk/; revision=20938
2006-01-17 17:28:41 +00:00
_KiIdt:
- Move some assembly functions around in better suited locations. - Merge syscall.S and trap.S into trap.S, and nicely document the software interrupt table that we service, as well as special cases. svn path=/trunk/; revision=20936
2006-01-17 06:36:35 +00:00
/* This is the Software Interrupt Table that we handle in this file: */
Patch that fixes VMWare boot (and should fix QEMu/KVM boot on the testbot): [NTOS]: A trap can get us into a state where DS/ES are invalid, making any pointer dereference (on DS/ES segmented memory, not SS, the stack) crash (and probably double-fault). Therefore, we have to be careful to switch to a good DS/ES before touching the TrapFrame pointer, which we don't have in ESP like the ASM code, but in a DS/ES-segmented register. For V8086 traps we can switch to the good DS/ES immediately, but for other kinds of traps, we actually need to save the current (bad) segments first. So we save them on the stack now, then switch to the good ones, then store the stack values into the trap frame. This is what happens on a non-optimized (-O0) build. On an optimized build, the segments will end up in registers instead, which is fine too (they'll be direct values). The order of instructions is guaranteed since the segment macros are volatile. [NTOS]: The GPF and Invalid Opcode handlers are performance critical when talking about V8086 traps, because they control the main flow of execution during that mode (GPFs will be issued for any privileged instruction we need to emulate, and invalid opcode might be generated for BOPs). Because of this, we employ a fast entry/exit macro into V8086 mode since we can make certain assumptions. We detect, and use, such scenarios when the V8086 flag is enabled in EFLAGS. However, because we can land in a GPF handler with an invalid DS/ES, as some V8086 code could trample this during BIOS calls for example, we must make sure that we are on a valid DS/ES before dereferencing any pointer. We fixup DS/ES either in KiEnterTrap (for normal entry/exit) or, for V86, in KiEnterV86Trap. Notice the problem: we need to detect which of these to use early on but we can't touch the EFLAGS in the frame because DS/ES could be invalid. Thankfully SS is always guaranteed valid, so stack dereferences are game! We therefore read the EFLAGS here, in assembly, where we can touch ESP as we please. We save this in EDX, which will be used as the second argument for the FASTCALL C trap entry. When we make the fast V86 check, we use the parameter instead of the trap frame, leading us to using the correct trap entry function, which fixes up DS/ES and lets us go on our merry way... [NTOS]: Make appropriate changes to GENERATE_TRAP_HANDLERS macro. [NTOS]: Switch to using well-known NT trap handler names (hex-based, double-zeroed) instead of decimal-based trap handler names which are confusing. [NTOS]: Clean up some debug spew. svn path=/trunk/; revision=45052
2010-01-12 05:50:45 +00:00
idt _KiTrap00, INT_32_DPL0 /* INT 00: Divide Error (#DE) */
idt _KiTrap01, INT_32_DPL0 /* INT 01: Debug Exception (#DB) */
idt _KiTrap02, INT_32_DPL0 /* INT 02: NMI Interrupt */
idt _KiTrap03, INT_32_DPL3 /* INT 03: Breakpoint Exception (#BP) */
idt _KiTrap04, INT_32_DPL3 /* INT 04: Overflow Exception (#OF) */
idt _KiTrap05, INT_32_DPL0 /* INT 05: BOUND Range Exceeded (#BR) */
idt _KiTrap06, INT_32_DPL0 /* INT 06: Invalid Opcode Code (#UD) */
idt _KiTrap07, INT_32_DPL0 /* INT 07: Device Not Available (#NM) */
idt _KiTrap08, INT_32_DPL0 /* INT 08: Double Fault Exception (#DF) */
idt _KiTrap09, INT_32_DPL0 /* INT 09: RESERVED */
idt _KiTrap0A, INT_32_DPL0 /* INT 0A: Invalid TSS Exception (#TS) */
idt _KiTrap0B, INT_32_DPL0 /* INT 0B: Segment Not Present (#NP) */
idt _KiTrap0C, INT_32_DPL0 /* INT 0C: Stack Fault Exception (#SS) */
idt _KiTrap0D, INT_32_DPL0 /* INT 0D: General Protection (#GP) */
idt _KiTrap0E, INT_32_DPL0 /* INT 0E: Page-Fault Exception (#PF) */
- Convert 8, 9, 10, 15/F svn path=/trunk/; revision=23634
2006-08-21 03:01:47 +00:00
idt _KiTrap0F, INT_32_DPL0 /* INT 0F: RESERVED */
Patch that fixes VMWare boot (and should fix QEMu/KVM boot on the testbot): [NTOS]: A trap can get us into a state where DS/ES are invalid, making any pointer dereference (on DS/ES segmented memory, not SS, the stack) crash (and probably double-fault). Therefore, we have to be careful to switch to a good DS/ES before touching the TrapFrame pointer, which we don't have in ESP like the ASM code, but in a DS/ES-segmented register. For V8086 traps we can switch to the good DS/ES immediately, but for other kinds of traps, we actually need to save the current (bad) segments first. So we save them on the stack now, then switch to the good ones, then store the stack values into the trap frame. This is what happens on a non-optimized (-O0) build. On an optimized build, the segments will end up in registers instead, which is fine too (they'll be direct values). The order of instructions is guaranteed since the segment macros are volatile. [NTOS]: The GPF and Invalid Opcode handlers are performance critical when talking about V8086 traps, because they control the main flow of execution during that mode (GPFs will be issued for any privileged instruction we need to emulate, and invalid opcode might be generated for BOPs). Because of this, we employ a fast entry/exit macro into V8086 mode since we can make certain assumptions. We detect, and use, such scenarios when the V8086 flag is enabled in EFLAGS. However, because we can land in a GPF handler with an invalid DS/ES, as some V8086 code could trample this during BIOS calls for example, we must make sure that we are on a valid DS/ES before dereferencing any pointer. We fixup DS/ES either in KiEnterTrap (for normal entry/exit) or, for V86, in KiEnterV86Trap. Notice the problem: we need to detect which of these to use early on but we can't touch the EFLAGS in the frame because DS/ES could be invalid. Thankfully SS is always guaranteed valid, so stack dereferences are game! We therefore read the EFLAGS here, in assembly, where we can touch ESP as we please. We save this in EDX, which will be used as the second argument for the FASTCALL C trap entry. When we make the fast V86 check, we use the parameter instead of the trap frame, leading us to using the correct trap entry function, which fixes up DS/ES and lets us go on our merry way... [NTOS]: Make appropriate changes to GENERATE_TRAP_HANDLERS macro. [NTOS]: Switch to using well-known NT trap handler names (hex-based, double-zeroed) instead of decimal-based trap handler names which are confusing. [NTOS]: Clean up some debug spew. svn path=/trunk/; revision=45052
2010-01-12 05:50:45 +00:00
idt _KiTrap10, INT_32_DPL0 /* INT 10: x87 FPU Error (#MF) */
idt _KiTrap11, INT_32_DPL0 /* INT 11: Align Check Exception (#AC) */
- Use MmUserProbeAddress in the system call handler to verify the parametes we got from user-mode are valid and return STATUS_ACCESS_VIOLATION if the check fails. - Handle failure after PsConvertToGuiThread and return STATUS_INVALID_SYSTEM_SERVICE and/or FALSE and/or -1 on failure. - Made MCE/XMMI interrupts unexpected on-boot. - Removed KiTrapUnknown and used KiTrap0F (15) instead, which is the generic unexpected handler. svn path=/trunk/; revision=20942
2006-01-17 22:41:39 +00:00
idt _KiTrap0F, INT_32_DPL0 /* INT 12: Machine Check Exception (#MC)*/
idt _KiTrap0F, INT_32_DPL0 /* INT 13: SIMD FPU Exception (#XF) */
[NTOS:KE] - Implement KiRaiseSecurityCheckFailure[Handler] to handle int 0x29 (__fastfail). Based on patch by Timo Kreuzer. (Yes, this is a Windows 8 feature. However all it does is improve the debugging experience, and we have a need for that) CORE-8419 svn path=/trunk/; revision=64665
2014-10-11 13:15:10 +00:00
REPEAT 21
idt _KiTrap0F, INT_32_DPL0 /* INT 14-28: UNDEFINED INTERRUPTS */
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
ENDR
[NTOS:KE] - Implement KiRaiseSecurityCheckFailure[Handler] to handle int 0x29 (__fastfail). Based on patch by Timo Kreuzer. (Yes, this is a Windows 8 feature. However all it does is improve the debugging experience, and we have a need for that) CORE-8419 svn path=/trunk/; revision=64665
2014-10-11 13:15:10 +00:00
idt _KiRaiseSecurityCheckFailure, INT_32_DPL3
/* INT 29: Handler for __fastfail */
- Use static IDT entries generated through a macro, instead of dynamically allocating them each boot. Note that we do not store them in an i386 compatible format, but much like NT, swap the bits so that our macro can more clearly define each entry. svn path=/trunk/; revision=20938
2006-01-17 17:28:41 +00:00
idt _KiGetTickCount, INT_32_DPL3 /* INT 2A: Get Tick Count Handler */
idt _KiCallbackReturn, INT_32_DPL3 /* INT 2B: User-Mode Callback Return */
idt _KiRaiseAssertion, INT_32_DPL3 /* INT 2C: Debug Assertion Handler */
idt _KiDebugService, INT_32_DPL3 /* INT 2D: Debug Service Handler */
idt _KiSystemService, INT_32_DPL3 /* INT 2E: System Call Service Handler */
- Use MmUserProbeAddress in the system call handler to verify the parametes we got from user-mode are valid and return STATUS_ACCESS_VIOLATION if the check fails. - Handle failure after PsConvertToGuiThread and return STATUS_INVALID_SYSTEM_SERVICE and/or FALSE and/or -1 on failure. - Made MCE/XMMI interrupts unexpected on-boot. - Removed KiTrapUnknown and used KiTrap0F (15) instead, which is the generic unexpected handler. svn path=/trunk/; revision=20942
2006-01-17 22:41:39 +00:00
idt _KiTrap0F, INT_32_DPL0 /* INT 2F: RESERVED */
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
i = HEX(30)
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
REPEAT 208
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
GENERATE_IDT_STUB %i
i = i + 1
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
ENDR
- Use static IDT entries generated through a macro, instead of dynamically allocating them each boot. Note that we do not store them in an i386 compatible format, but much like NT, swap the bits so that our macro can more clearly define each entry. svn path=/trunk/; revision=20938
2006-01-17 17:28:41 +00:00
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
PUBLIC _KiIdtDescriptor
- Use static IDT entries generated through a macro, instead of dynamically allocating them each boot. Note that we do not store them in an i386 compatible format, but much like NT, swap the bits so that our macro can more clearly define each entry. svn path=/trunk/; revision=20938
2006-01-17 17:28:41 +00:00
_KiIdtDescriptor:
- Fix definition of _DESCRIPTOR/KDESCRIPTOR - Fix all code/data structures of GDT/IDT to match new definition - Kernel is now MSVC/WDK compilable (but not linkable yet) - Remove two previous fixes for bootvid/kdcom MSVC/WDK compiling svn path=/trunk/; revision=28254
2007-08-09 07:12:59 +00:00
.short 0
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
.short HEX(7FF)
- Use static IDT entries generated through a macro, instead of dynamically allocating them each boot. Note that we do not store them in an i386 compatible format, but much like NT, swap the bits so that our macro can more clearly define each entry. svn path=/trunk/; revision=20938
2006-01-17 17:28:41 +00:00
.long _KiIdt
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
PUBLIC _KiUnexpectedEntrySize
- Implement Chained and Normal generic interrupt handlers. - Make generated handlers have a proper .func symbol for symbol data. - Make IDT writable, the page shouldn't be read-only. - Change some symbol names. svn path=/trunk/; revision=23676
2006-08-24 01:53:54 +00:00
_KiUnexpectedEntrySize:
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
.long _KiUnexpectedInterrupt49 - _KiUnexpectedInterrupt48
- Implement Chained and Normal generic interrupt handlers. - Make generated handlers have a proper .func symbol for symbol data. - Make IDT writable, the page shouldn't be read-only. - Change some symbol names. svn path=/trunk/; revision=23676
2006-08-24 01:53:54 +00:00
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
/******************************************************************************/
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
.code
- Implement GENERATE_IDT_STUBS/GENERATE_INT_HANDLERS - Generate actual Unexpected Interrupt entries in the IDT for INTs > 0x30 (basically IRQs). - Generated all 208 Unexpected Interrupt Handlers for all INTs (using a single macro line) and implement a "Tail" function to handle them instead of bugchecking like before (they're now sent to HAL properly). - Implement INT_PROLOG macro to create KTRAP_FRAME for interrupts (similar to traps). - Part 1 of major changes to come.... svn path=/trunk/; revision=23645
2006-08-21 22:40:23 +00:00
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
PUBLIC _KiStartUnexpectedRange@0
_KiStartUnexpectedRange@0:
i = HEX(30)
REPEAT 208
GENERATE_INT_HANDLER %i
i = i + 1
ENDR
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
TRAP_ENTRY KiTrap00, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap01, KI_PUSH_FAKE_ERROR_CODE
[NTOS:KE] Fixup for the NMI task handler: handle NMI recursion. -- Code was lost in commit 2efed8ef (r45040).
2019-04-23 01:42:24 +00:00
TASK_ENTRY KiTrap02, KI_NMI
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
TRAP_ENTRY KiTrap03, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap04, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap05, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap06, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap07, KI_PUSH_FAKE_ERROR_CODE
[NTOS:KE] Improvements for the Trap02 (NMI) and Trap08 (double-fault) exception handlers. - Add FRAME_TSS FPO debug information for Trap02 and Trap08. - Switch the active TSS in Trap08 in the very same way as is done in Trap02. This allows to correctly debug NMI and double-fault exceptions with WinDbg, by following the different TSS contexts, as described in: https://blogs.msdn.microsoft.com/debuggingtoolbox/2008/02/22/special-command-analyzing-and-reconstructing-the-stack-using-the-k-command-and-its-variations/ https://blogs.msdn.microsoft.com/ntdebugging/2009/11/25/part-1-got-stack-no-we-ran-out-of-kernel-mode-stack-and-kv-wont-tell-me-why/ http://www.osronline.com/article.cfm?article=254 and http://www.osronline.com/article.cfm?article=328
2019-02-04 00:16:29 +00:00
TASK_ENTRY KiTrap08, 0
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
TRAP_ENTRY KiTrap09, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap0A, 0
TRAP_ENTRY KiTrap0B, 0
TRAP_ENTRY KiTrap0C, 0
TRAP_ENTRY KiTrap0D, 0
TRAP_ENTRY KiTrap0E, 0
TRAP_ENTRY KiTrap0F, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap10, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap11, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiTrap13, KI_PUSH_FAKE_ERROR_CODE
[NTOS:KE] - Implement KiRaiseSecurityCheckFailure[Handler] to handle int 0x29 (__fastfail). Based on patch by Timo Kreuzer. (Yes, this is a Windows 8 feature. However all it does is improve the debugging experience, and we have a need for that) CORE-8419 svn path=/trunk/; revision=64665
2014-10-11 13:15:10 +00:00
TRAP_ENTRY KiRaiseSecurityCheckFailure, KI_PUSH_FAKE_ERROR_CODE
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
TRAP_ENTRY KiGetTickCount, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiCallbackReturn, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiRaiseAssertion, KI_PUSH_FAKE_ERROR_CODE
TRAP_ENTRY KiDebugService, KI_PUSH_FAKE_ERROR_CODE
[NTOS] Push vector as error code on the stack in KiUnexpectedInterrupt* instead of putting it into eax, because we must not clobber it. Spotted by jcatena. svn path=/trunk/; revision=45590
2010-02-13 02:01:33 +00:00
TRAP_ENTRY KiUnexpectedInterruptTail, 0
- Implement GENERATE_IDT_STUBS/GENERATE_INT_HANDLERS - Generate actual Unexpected Interrupt entries in the IDT for INTs > 0x30 (basically IRQs). - Generated all 208 Unexpected Interrupt Handlers for all INTs (using a single macro line) and implement a "Tail" function to handle them instead of bugchecking like before (they're now sent to HAL properly). - Implement INT_PROLOG macro to create KTRAP_FRAME for interrupts (similar to traps). - Part 1 of major changes to come.... svn path=/trunk/; revision=23645
2006-08-21 22:40:23 +00:00
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
ALIGN 4
[ASM] Merge asm related changes from cmake branch. svn path=/trunk/; revision=49826
2010-11-27 22:12:15 +00:00
EXTERN @KiInterruptTemplateHandler@8:PROC
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
PUBLIC _KiInterruptTemplate
_KiInterruptTemplate:
[NTOS:KE] Generate proper frame info for trap handler in GCC builds CORE-8531
2021-03-02 12:03:37 +00:00
CFI_STARTPROC
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
KiEnterTrap KI_PUSH_FAKE_ERROR_CODE
PUBLIC _KiInterruptTemplate2ndDispatch
_KiInterruptTemplate2ndDispatch:
mov edx, 0
PUBLIC _KiInterruptTemplateObject
_KiInterruptTemplateObject:
mov eax, offset @KiInterruptTemplateHandler@8
jmp eax
PUBLIC _KiInterruptTemplateDispatch
_KiInterruptTemplateDispatch:
[NTOS:KE] Generate proper frame info for trap handler in GCC builds CORE-8531
2021-03-02 12:03:37 +00:00
CFI_ENDPROC
- Implement GENERATE_IDT_STUBS/GENERATE_INT_HANDLERS - Generate actual Unexpected Interrupt entries in the IDT for INTs > 0x30 (basically IRQs). - Generated all 208 Unexpected Interrupt Handlers for all INTs (using a single macro line) and implement a "Tail" function to handle them instead of bugchecking like before (they're now sent to HAL properly). - Implement INT_PROLOG macro to create KTRAP_FRAME for interrupts (similar to traps). - Part 1 of major changes to come.... svn path=/trunk/; revision=23645
2006-08-21 22:40:23 +00:00
[NTOS] - Rewrite trap handler exit stubs in pure assembly, remove gcc inline assembly. - Replace jmp to C handler with KiCallHandler macro, that expands to jmp on release builds for speed and call on debug builds to fix backtraces. - Unroll the Syscall handler loop and use volatile keyword when reloading TrapFrame and DescriptorTable from the new stack to prevent the compiler from optimizing it away / moving it out of the loop. - Bugcheck in KiTrap0DHandler, if the fault couldn't be resolved. - Remove handling of V86 traps and edited traps in KiServiceExit, ASSERT to make sure they never happen. - Replace code patching of the syscall exit handler with a function pointer. - Use __debugbreak() instead of while(TRUE) in KiExitTrapDebugChecks svn path=/trunk/; revision=45774
2010-03-03 02:27:14 +00:00
EXTERN @KiSystemServiceHandler@8:PROC
PUBLIC _KiSystemService
[ASM] Improve .proc / .endproc syntax, so that the full symbolic name is passed, which allows to create fastcall symbols. Remove the need to pass the function name to .endp svn path=/trunk/; revision=54112
2011-10-13 15:16:29 +00:00
.PROC _KiSystemService
[ASM] Generate MSVC debugging info for KiUserExceptionDispatcher, KiIntSystemCall, KiFastSystemCall, KiFastSystemCallRet, KiSystemService, KiFastCallEntry, all systemcall stubs Now usermode backtraces look as they should in WinDbg svn path=/trunk/; revision=52705
2011-07-17 00:38:46 +00:00
FPO 0, 0, 0, 0, 1, FRAME_TRAP
[NTOS] - Rewrite trap handler exit stubs in pure assembly, remove gcc inline assembly. - Replace jmp to C handler with KiCallHandler macro, that expands to jmp on release builds for speed and call on debug builds to fix backtraces. - Unroll the Syscall handler loop and use volatile keyword when reloading TrapFrame and DescriptorTable from the new stack to prevent the compiler from optimizing it away / moving it out of the loop. - Bugcheck in KiTrap0DHandler, if the fault couldn't be resolved. - Remove handling of V86 traps and edited traps in KiServiceExit, ASSERT to make sure they never happen. - Replace code patching of the syscall exit handler with a function pointer. - Use __debugbreak() instead of while(TRUE) in KiExitTrapDebugChecks svn path=/trunk/; revision=45774
2010-03-03 02:27:14 +00:00
KiEnterTrap (KI_PUSH_FAKE_ERROR_CODE OR KI_NONVOLATILES_ONLY OR KI_DONT_SAVE_SEGS)
[NTOS] Rewrite Trap exits stubs in raw assembly (2nd try) and remove inline assembly. Bugcheck in KiTrap0DHandler, when the fault was not handled. Replace code patching for sysexit vs iret with a function pointer. Slightly refactor KiSystemServiceHandler/KiFastCallEntryHanlder. Unroll the loop in the systemcall handler and use volatile keyword when reloading TrapFrame and DescriptorTable from the new stack after converting to gui thread to prevent the compiler from optimizing it away (or moving it out of the loop). Add an asm macro KiCallHandler, which expands to call on debug builds to make sure backtraces work as expected and to jmp on release builds for improved performance. Modify KiExitV86Trap to always exit and add DECLSPEC_NORETURN. Use __debugbreak() instead of while(TRUE) on errors in KiExitTrapDebugChecks. The old code hat 2 issues: one was restoring segments in KiExitV86Trap when they shouldn't be, leading to a bugcheck. And the other was a long hang (5 mintes or more) in 3rd stage on qemu when selecting RosDbg, caused by the KiFastCallExitHandler function pointer being initialized with a pointer to the iret handler. Initializing it in code solved the issue. To figure out why is left as an exercise to the reader. svn path=/trunk/; revision=46247
2010-03-17 13:12:46 +00:00
KiCallHandler @KiSystemServiceHandler@8
[ASM] Improve .proc / .endproc syntax, so that the full symbolic name is passed, which allows to create fastcall symbols. Remove the need to pass the function name to .endp svn path=/trunk/; revision=54112
2011-10-13 15:16:29 +00:00
.ENDP
Revert r45774 until I know why qemu is broken svn path=/trunk/; revision=45792
2010-03-03 16:30:56 +00:00
PUBLIC _KiFastCallEntry
[ASM] Improve .proc / .endproc syntax, so that the full symbolic name is passed, which allows to create fastcall symbols. Remove the need to pass the function name to .endp svn path=/trunk/; revision=54112
2011-10-13 15:16:29 +00:00
.PROC _KiFastCallEntry
[ASM] Generate MSVC debugging info for KiUserExceptionDispatcher, KiIntSystemCall, KiFastSystemCall, KiFastSystemCallRet, KiSystemService, KiFastCallEntry, all systemcall stubs Now usermode backtraces look as they should in WinDbg svn path=/trunk/; revision=52705
2011-07-17 00:38:46 +00:00
FPO 0, 0, 0, 0, 1, FRAME_TRAP
Revert r45774 until I know why qemu is broken svn path=/trunk/; revision=45792
2010-03-03 16:30:56 +00:00
KiEnterTrap (KI_FAST_SYSTEM_CALL OR KI_NONVOLATILES_ONLY OR KI_DONT_SAVE_SEGS)
[NTOSKRNL] When a user mode debugger has single stepping enabled and steps over a sysenter instruction, you are obviously not supposed to enter the kernel debugger on the syscall entry handler. But exactly this happened on reactos. This was because the sysenter instruction doesn't disable single stepping, so we need to handle this special case manually in the single stepping handler (which we didn't). We now check if the single step comes from KiFastCallEntry and when it does, disable single stepping in the current (nested) trap frame and return back to a secondary fast call entry. The 2nd entrypoint will make sure to re-enable the single step flag in EFLAGS before returning to usermode. To make this actually work, the asm entry stub itself needs to handle saving of eflags, so some trap frame modification from KiFastCallEntryHandler was moved into the asm stub. Since the amount of asm instructions is rather small (10 instructions, pretty straight forward) I moved everything from KiSystemServiceHandler to the asm stub and killed KiFastCallEntryHandler entirely, calling KiSystemServiceHandler instead. Now stepping over a sysenter instruction works with OllyDbg without breaking into the kernel debugger. CORE-8057 #resolve svn path=/trunk/; revision=63420
2014-05-22 22:28:57 +00:00
KiCallHandler @KiSystemServiceHandler@8
[ASM] Improve .proc / .endproc syntax, so that the full symbolic name is passed, which allows to create fastcall symbols. Remove the need to pass the function name to .endp svn path=/trunk/; revision=54112
2011-10-13 15:16:29 +00:00
.ENDP
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
[NTOSKRNL] When a user mode debugger has single stepping enabled and steps over a sysenter instruction, you are obviously not supposed to enter the kernel debugger on the syscall entry handler. But exactly this happened on reactos. This was because the sysenter instruction doesn't disable single stepping, so we need to handle this special case manually in the single stepping handler (which we didn't). We now check if the single step comes from KiFastCallEntry and when it does, disable single stepping in the current (nested) trap frame and return back to a secondary fast call entry. The 2nd entrypoint will make sure to re-enable the single step flag in EFLAGS before returning to usermode. To make this actually work, the asm entry stub itself needs to handle saving of eflags, so some trap frame modification from KiFastCallEntryHandler was moved into the asm stub. Since the amount of asm instructions is rather small (10 instructions, pretty straight forward) I moved everything from KiSystemServiceHandler to the asm stub and killed KiFastCallEntryHandler entirely, calling KiSystemServiceHandler instead. Now stepping over a sysenter instruction works with OllyDbg without breaking into the kernel debugger. CORE-8057 #resolve svn path=/trunk/; revision=63420
2014-05-22 22:28:57 +00:00
PUBLIC _KiFastCallEntryWithSingleStep
.PROC _KiFastCallEntryWithSingleStep
FPO 0, 0, 0, 0, 1, FRAME_TRAP
KiEnterTrap (KI_FAST_SYSTEM_CALL OR KI_NONVOLATILES_ONLY OR KI_DONT_SAVE_SEGS)
or dword ptr [ecx + KTRAP_FRAME_EFLAGS], EFLAGS_TF
KiCallHandler @KiSystemServiceHandler@8
.ENDP
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
PUBLIC _KiEndUnexpectedRange@0
- Implement Chained and Normal generic interrupt handlers. - Make generated handlers have a proper .func symbol for symbol data. - Make IDT writable, the page shouldn't be read-only. - Change some symbol names. svn path=/trunk/; revision=23676
2006-08-24 01:53:54 +00:00
_KiEndUnexpectedRange@0:
[NTOSKRNL] The handlers for unexpected interrupts that we generate from asm macros use a push instruction with an 8 bit operand to push the interrupt number on the stack. Now the 8 bit push has the unfortunate behaviour of sign extending to 32 bit. But since the assembler is smart (or at least thinks so) it will not generate such a push instruction for values larger than 0x7f. This resulted in 7 bytes long stubs in the range of 0x30 .. 0x7f and 10 bytes long stubs after that. To fix this 128 is substracted from the value and later readded in the common code path. A second issue arose, because the assembler would start to use 8 bit relative short jumps as soon as the target was less than 127 bytes away, which happened for some of the higher interrupts, which then had a smaller stub then the others. Fix this by moving the stubs up in the code further away from the target label, so that always 32bit relative jumps will be used. These problems didn't show up so far, since we used the PIC and interrupts in the range of 0x30 .. 0x40 and the code that relied on the stubs all having the same length was working well. This changes with an APIC based hal, where interrupts of much higher number are likely to be used. svn path=/trunk/; revision=53679
2011-09-10 23:05:10 +00:00
add dword ptr[esp], 128
- Implement GENERATE_IDT_STUBS/GENERATE_INT_HANDLERS - Generate actual Unexpected Interrupt entries in the IDT for INTs > 0x30 (basically IRQs). - Generated all 208 Unexpected Interrupt Handlers for all INTs (using a single macro line) and implement a "Tail" function to handle them instead of bugchecking like before (they're now sent to HAL properly). - Implement INT_PROLOG macro to create KTRAP_FRAME for interrupts (similar to traps). - Part 1 of major changes to come.... svn path=/trunk/; revision=23645
2006-08-21 22:40:23 +00:00
jmp _KiUnexpectedInterruptTail
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
[NTOS] Rewrite Trap exits stubs in raw assembly (2nd try) and remove inline assembly. Bugcheck in KiTrap0DHandler, when the fault was not handled. Replace code patching for sysexit vs iret with a function pointer. Slightly refactor KiSystemServiceHandler/KiFastCallEntryHanlder. Unroll the loop in the systemcall handler and use volatile keyword when reloading TrapFrame and DescriptorTable from the new stack after converting to gui thread to prevent the compiler from optimizing it away (or moving it out of the loop). Add an asm macro KiCallHandler, which expands to call on debug builds to make sure backtraces work as expected and to jmp on release builds for improved performance. Modify KiExitV86Trap to always exit and add DECLSPEC_NORETURN. Use __debugbreak() instead of while(TRUE) on errors in KiExitTrapDebugChecks. The old code hat 2 issues: one was restoring segments in KiExitV86Trap when they shouldn't be, leading to a bugcheck. And the other was a long hang (5 mintes or more) in 3rd stage on qemu when selecting RosDbg, caused by the KiFastCallExitHandler function pointer being initialized with a pointer to the iret handler. Initializing it in code solved the issue. To figure out why is left as an exercise to the reader. svn path=/trunk/; revision=46247
2010-03-17 13:12:46 +00:00
/* EXIT CODE *****************************************************************/
KiTrapExitStub KiSystemCallReturn, (KI_RESTORE_EAX OR KI_RESTORE_EFLAGS OR KI_EXIT_JMP)
KiTrapExitStub KiSystemCallSysExitReturn, (KI_RESTORE_EAX OR KI_RESTORE_FS OR KI_RESTORE_EFLAGS OR KI_EXIT_SYSCALL)
KiTrapExitStub KiSystemCallTrapReturn, (KI_RESTORE_EAX OR KI_RESTORE_FS OR KI_EXIT_IRET)
KiTrapExitStub KiEditedTrapReturn, (KI_RESTORE_VOLATILES OR KI_RESTORE_EFLAGS OR KI_EDITED_FRAME OR KI_EXIT_RET)
KiTrapExitStub KiTrapReturn, (KI_RESTORE_VOLATILES OR KI_RESTORE_SEGMENTS OR KI_EXIT_IRET)
KiTrapExitStub KiTrapReturnNoSegments, (KI_RESTORE_VOLATILES OR KI_EXIT_IRET)
[NTOSKRNL] - Introduce a new and faster way to return to kernel mode from traps by using a ret 8 instruction instead of an iret. - Make use of KiUserTrap where appropriate - Remove some pointless toplevel volatile svn path=/trunk/; revision=60701
2013-10-19 11:33:34 +00:00
KiTrapExitStub KiTrapReturnNoSegmentsRet8,(KI_RESTORE_VOLATILES OR KI_RESTORE_EFLAGS OR KI_EXIT_RET8)
[NTOS] Rewrite Trap exits stubs in raw assembly (2nd try) and remove inline assembly. Bugcheck in KiTrap0DHandler, when the fault was not handled. Replace code patching for sysexit vs iret with a function pointer. Slightly refactor KiSystemServiceHandler/KiFastCallEntryHanlder. Unroll the loop in the systemcall handler and use volatile keyword when reloading TrapFrame and DescriptorTable from the new stack after converting to gui thread to prevent the compiler from optimizing it away (or moving it out of the loop). Add an asm macro KiCallHandler, which expands to call on debug builds to make sure backtraces work as expected and to jmp on release builds for improved performance. Modify KiExitV86Trap to always exit and add DECLSPEC_NORETURN. Use __debugbreak() instead of while(TRUE) on errors in KiExitTrapDebugChecks. The old code hat 2 issues: one was restoring segments in KiExitV86Trap when they shouldn't be, leading to a bugcheck. And the other was a long hang (5 mintes or more) in 3rd stage on qemu when selecting RosDbg, caused by the KiFastCallExitHandler function pointer being initialized with a pointer to the iret handler. Initializing it in code solved the issue. To figure out why is left as an exercise to the reader. svn path=/trunk/; revision=46247
2010-03-17 13:12:46 +00:00
[NTOSKRNL] Fix KiConvertToGuiThread on MSVC builds, by using a raw assembly function instead of a (broken) inline asembly function MSVC built kernel boots further now. svn path=/trunk/; revision=52509
2011-07-03 01:04:01 +00:00
EXTERN _PsConvertToGuiThread@0:PROC
PUBLIC _KiConvertToGuiThread@0
_KiConvertToGuiThread@0:
- Don't have two different implementation of KiConvertToGuiThread, first as inlined assembly gcc and second as a function call (for msvc). Always use the function call to be consistent with both compilers. svn path=/trunk/; revision=69032
2015-09-05 15:20:27 +00:00
/*
* Converting to a GUI thread safely updates ESP in-place as well as the
* current Thread->TrapFrame and EBP when KeSwitchKernelStack is called.
*
* However, PsConvertToGuiThread "helpfully" restores EBP to the original
* caller's value, since it is considered a nonvolatile register. As such,
* as soon as we're back after the conversion and we try to store the result
* which will probably be in some stack variable (EBP-based), we'll crash as
* we are touching the de-allocated non-expanded stack.
*
* Thus we need a way to update our EBP before EBP is touched, and the only
* way to guarantee this is to do the call itself in assembly, use the EAX
* register to store the result, fixup EBP, and then let the C code continue
* on its merry way.
*
*/
/* Save ebx */
[NTOSKRNL] Fix MSVC version of KiConvertToGuiThread (save and restore ebx) Noticed by Dmitry svn path=/trunk/; revision=52923
2011-07-27 13:37:57 +00:00
push ebx
[NTOSKRNL] Fix KiConvertToGuiThread on MSVC builds, by using a raw assembly function instead of a (broken) inline asembly function MSVC built kernel boots further now. svn path=/trunk/; revision=52509
2011-07-03 01:04:01 +00:00
/* Calculate the stack frame offset in ebx */
mov ebx, ebp
sub ebx, esp
/* Call the worker function */
call _PsConvertToGuiThread@0
/* Adjust ebp to the new stack */
mov ebp, esp
add ebp, ebx
[NTOSKRNL] Fix MSVC version of KiConvertToGuiThread (save and restore ebx) Noticed by Dmitry svn path=/trunk/; revision=52923
2011-07-27 13:37:57 +00:00
/* Restore ebx */
pop ebx
[NTOSKRNL] Fix KiConvertToGuiThread on MSVC builds, by using a raw assembly function instead of a (broken) inline asembly function MSVC built kernel boots further now. svn path=/trunk/; revision=52509
2011-07-03 01:04:01 +00:00
/* return to the caller */
ret
[NTOS:KE] Rewrite KiSystemCallTrampoline in assembly Instead of making assumptions about what the compiler does with forced-inline functions
2021-04-06 08:53:35 +00:00
/*
NTSTATUS
NTAPI
KiSystemCallTrampoline(IN PVOID Handler,
IN PVOID Arguments,
IN ULONG StackBytes);
*/
PUBLIC _KiSystemCallTrampoline@12
_KiSystemCallTrampoline@12:
push ebp
mov ebp, esp
push esi
push edi
/* Get handler */
mov eax, [ebp + 8]
/* Get arguments */
mov esi, [ebp + 12]
/* Get stack bytes */
mov ecx, [ebp + 16]
/* Copy args to the stack */
sub esp, ecx
mov edi, esp
shr ecx, 2
rep movsd
call eax
pop edi
pop esi
leave
ret 12
[REACTOS] Add asm.h containing macros to make assembly code both GAS and ML compatible at the same time. [NTOS/HAL] Move trap entry points from C into a GAS/ML compatile assembly file (might need fine tuning for ML). The entries are generated by a shared assembly macro TRAP_ENTRY. Removed KiTrapStub, KiIsV8086TrapSafe, KiIsUserTrapSafe, KiSetSaneSegments, removed segment handling from KiEnter*Trap. [NTOS] Make KiFastCallEntryHandler and KiSystemServiceHandler FASTCALL and pass the systemcall number in TrapFrame->Eax [HAL] Use _setjmp/longjmp instead of saving a trapframe in HalpBiosCall svn path=/trunk/; revision=45565
2010-02-10 23:24:59 +00:00
END
Reference in a new issue Copy permalink