Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-11 01:04:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/ntoskrnl/ke/arm/trap.s

137 lines
3.5 KiB
ArmAsm
Raw Normal View History

- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
/*
* PROJECT: ReactOS Kernel
- Implement beginnings of Ramdisk Port Driver. Planning compatibility with ISO, SDI and WIM files and full Windows support. - New license for our code. svn path=/trunk/; revision=34170
2008-06-29 02:58:05 +00:00
* LICENSE: BSD - See COPYING.ARM in the top level directory
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
* FILE: ntoskrnl/ke/arm/trap.s
* PURPOSE: Support for exceptions and interrupts on ARM machines
* PROGRAMMERS: ReactOS Portable Systems Group
*/
.title "ARM Trap Dispatching and Handling"
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
#include "ntoskrnl/include/internal/arm/kxarm.h"
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
.include "ntoskrnl/include/internal/arm/ksarm.h"
.global KiArmVectorTable
KiArmVectorTable:
b . // Reset
ldr pc, _KiUndefinedInstructionJump // Undefined Instruction
ldr pc, _KiSoftwareInterruptJump // Software Interrupt
ldr pc, _KiPrefetchAbortJump // Prefetch Abort
ldr pc, _KiDataAbortJump // Data Abort
- Enable interrupts after probing and capturing parameters during a system call. - Enable WFI during idle loop. - Implement undefined exception handler, and get rid of reserved exception code -- this will never happen except for an SoC bug. - Request an APC interrupt if the new thread we context switched to has APCs pending and enabled. - Perform DPC watchdog debugging code if a DPC lasted more than a second. - Do the appropriate bugcheck if DPCs are active during a context switch. - Go over the FIXMEs in the assembly files too, and create a new FIXME-PERF category. svn path=/trunk/; revision=34584
2008-07-19 06:53:03 +00:00
b . // Reserved
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
ldr pc, _KiInterruptJump // Interrupt
ldr pc, _KiFastInterruptJump // Fast Interrupt
_KiUndefinedInstructionJump: .word KiUndefinedInstructionException
_KiSoftwareInterruptJump: .word KiSoftwareInterruptException
_KiPrefetchAbortJump: .word KiPrefetchAbortException
_KiDataAbortJump: .word KiDataAbortException
_KiInterruptJump: .word KiInterruptException
_KiFastInterruptJump: .word KiFastInterruptException
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
TEXTAREA
NESTED_ENTRY KiUndefinedInstructionException
PROLOG_END KiUndefinedInstructionException
//
- Enable interrupts after probing and capturing parameters during a system call. - Enable WFI during idle loop. - Implement undefined exception handler, and get rid of reserved exception code -- this will never happen except for an SoC bug. - Request an APC interrupt if the new thread we context switched to has APCs pending and enabled. - Perform DPC watchdog debugging code if a DPC lasted more than a second. - Do the appropriate bugcheck if DPCs are active during a context switch. - Go over the FIXMEs in the assembly files too, and create a new FIXME-PERF category. svn path=/trunk/; revision=34584
2008-07-19 06:53:03 +00:00
// Handle trap entry
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
//
- Enable interrupts after probing and capturing parameters during a system call. - Enable WFI during idle loop. - Implement undefined exception handler, and get rid of reserved exception code -- this will never happen except for an SoC bug. - Request an APC interrupt if the new thread we context switched to has APCs pending and enabled. - Perform DPC watchdog debugging code if a DPC lasted more than a second. - Do the appropriate bugcheck if DPCs are active during a context switch. - Go over the FIXMEs in the assembly files too, and create a new FIXME-PERF category. svn path=/trunk/; revision=34584
2008-07-19 06:53:03 +00:00
TRAP_PROLOG 0 // NotFromAbort
//
// Call the C handler
//
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
ldr lr, =KiExceptionExit
- Enable interrupts after probing and capturing parameters during a system call. - Enable WFI during idle loop. - Implement undefined exception handler, and get rid of reserved exception code -- this will never happen except for an SoC bug. - Request an APC interrupt if the new thread we context switched to has APCs pending and enabled. - Perform DPC watchdog debugging code if a DPC lasted more than a second. - Do the appropriate bugcheck if DPCs are active during a context switch. - Go over the FIXMEs in the assembly files too, and create a new FIXME-PERF category. svn path=/trunk/; revision=34584
2008-07-19 06:53:03 +00:00
mov r0, sp
ldr pc, =KiUndefinedExceptionHandler
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
ENTRY_END KiUndefinedInstructionException
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
NESTED_ENTRY KiSoftwareInterruptException
PROLOG_END KiSoftwareInterruptException
- We now define a much simpler system call interface -- instead of using interrupt 2E with the system call ID in the ip register, we use the system call ID as the interrupt number! On ARM, all software interrupts have a generic handler, so ANY software interrupt will be a system call, and the interrupt number is the system call ID! - Removed a bunch more i386-only exports from the ARM kernel. - Implemented all the READ/WRITE_REGISTER* routines for ARM/PPC. - Implement half of KiSoftwareInterruptException, which calls KiSoftwareInterruptHandler, which calls KiSystemService. We now reach the first kernel-mode system call! (ZwClose from PspInitPhase0). - Reformat fastinterlck.c and change the way it's included per-architecture. svn path=/trunk/; revision=32666
2008-03-12 18:17:55 +00:00
//
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
// Handle trap entry
- We now make appropriate space on the stack to save the old IRQL in the trap frame. - Save the old IRQL and assert it in the interrupt handler. - Fix KTRAP_FRAME structure. svn path=/trunk/; revision=33934
2008-06-11 18:39:44 +00:00
//
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
SYSCALL_PROLOG
- We now make appropriate space on the stack to save the old IRQL in the trap frame. - Save the old IRQL and assert it in the interrupt handler. - Fix KTRAP_FRAME structure. svn path=/trunk/; revision=33934
2008-06-11 18:39:44 +00:00
- We now define a much simpler system call interface -- instead of using interrupt 2E with the system call ID in the ip register, we use the system call ID as the interrupt number! On ARM, all software interrupts have a generic handler, so ANY software interrupt will be a system call, and the interrupt number is the system call ID! - Removed a bunch more i386-only exports from the ARM kernel. - Implemented all the READ/WRITE_REGISTER* routines for ARM/PPC. - Implement half of KiSoftwareInterruptException, which calls KiSoftwareInterruptHandler, which calls KiSystemService. We now reach the first kernel-mode system call! (ZwClose from PspInitPhase0). - Reformat fastinterlck.c and change the way it's included per-architecture. svn path=/trunk/; revision=32666
2008-03-12 18:17:55 +00:00
//
// Call the C handler
//
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
ldr lr, =KiServiceExit
- We now define a much simpler system call interface -- instead of using interrupt 2E with the system call ID in the ip register, we use the system call ID as the interrupt number! On ARM, all software interrupts have a generic handler, so ANY software interrupt will be a system call, and the interrupt number is the system call ID! - Removed a bunch more i386-only exports from the ARM kernel. - Implemented all the READ/WRITE_REGISTER* routines for ARM/PPC. - Implement half of KiSoftwareInterruptException, which calls KiSoftwareInterruptHandler, which calls KiSystemService. We now reach the first kernel-mode system call! (ZwClose from PspInitPhase0). - Reformat fastinterlck.c and change the way it's included per-architecture. svn path=/trunk/; revision=32666
2008-03-12 18:17:55 +00:00
mov r0, sp
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
ldr pc, =KiSoftwareInterruptHandler
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
ENTRY_END KiSoftwareInterruptException
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
NESTED_ENTRY KiPrefetchAbortException
PROLOG_END KiPrefetchAbortException
//
- Write a DebugService routine for ARM in the RTL library and get rid of the hack in ntoskrnl. - Just like on x86, this routine generates a breakpoint -- on ARM this is done with BKPT followed by an index. - We use the BREAKPOINT_PRINT index just like on x86. - This generates a prefetch abort -- so now we implement the prefetch abort handler. Thanks to the trap macros, this was 10 lines of code. - This calls into the real C handler, which is now unimplemented and hangs the whole system, so we've regressed way back (on purpose). svn path=/trunk/; revision=34474
2008-07-13 22:40:36 +00:00
// Handle trap entry
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
//
- Prefetch aborts behave like other exceptions, not like data aborts, in terms of the PC offset due to the pipeline behavior. So call TRAP_PROLOG with 0, not 1 svn path=/trunk/; revision=34479
2008-07-13 23:32:38 +00:00
TRAP_PROLOG 0 // NotFromAbort
- Write a DebugService routine for ARM in the RTL library and get rid of the hack in ntoskrnl. - Just like on x86, this routine generates a breakpoint -- on ARM this is done with BKPT followed by an index. - We use the BREAKPOINT_PRINT index just like on x86. - This generates a prefetch abort -- so now we implement the prefetch abort handler. Thanks to the trap macros, this was 10 lines of code. - This calls into the real C handler, which is now unimplemented and hangs the whole system, so we've regressed way back (on purpose). svn path=/trunk/; revision=34474
2008-07-13 22:40:36 +00:00
//
// Call the C handler
//
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
ldr lr, =KiExceptionExit
- Write a DebugService routine for ARM in the RTL library and get rid of the hack in ntoskrnl. - Just like on x86, this routine generates a breakpoint -- on ARM this is done with BKPT followed by an index. - We use the BREAKPOINT_PRINT index just like on x86. - This generates a prefetch abort -- so now we implement the prefetch abort handler. Thanks to the trap macros, this was 10 lines of code. - This calls into the real C handler, which is now unimplemented and hangs the whole system, so we've regressed way back (on purpose). svn path=/trunk/; revision=34474
2008-07-13 22:40:36 +00:00
mov r0, sp
ldr pc, =KiPrefetchAbortHandler
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
ENTRY_END KiPrefetchAbortException
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
NESTED_ENTRY KiDataAbortException
PROLOG_END KiDataAbortException
//
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
// Handle trap entry
- Convert all Loader Block structures to virtual addresses (By adding KSEG0_BASE) since the kernel eventually unmaps the page table responsible for the physical->virtual identity mapping, but we'll still need to access the loader block. - Implement proper trap prolog/epilog code -- currently used and tested in the data abort handler. Currently hacked away some KTRAP_FRAME stuff on ARM. - The data abort handler has a very rudimentary check to detect page faults and will call MmAccessFaults, this means we now support paged pool! - We now succesfully go past MmInitSystem and go all the way until ObInitSystem (still in Phase 0). svn path=/trunk/; revision=32659
2008-03-11 16:13:43 +00:00
//
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
TRAP_PROLOG 1 // FromAbort
- Convert all Loader Block structures to virtual addresses (By adding KSEG0_BASE) since the kernel eventually unmaps the page table responsible for the physical->virtual identity mapping, but we'll still need to access the loader block. - Implement proper trap prolog/epilog code -- currently used and tested in the data abort handler. Currently hacked away some KTRAP_FRAME stuff on ARM. - The data abort handler has a very rudimentary check to detect page faults and will call MmAccessFaults, this means we now support paged pool! - We now succesfully go past MmInitSystem and go all the way until ObInitSystem (still in Phase 0). svn path=/trunk/; revision=32659
2008-03-11 16:13:43 +00:00
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
//
// Call the C handler
//
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
ldr lr, =KiExceptionExit
- Convert all Loader Block structures to virtual addresses (By adding KSEG0_BASE) since the kernel eventually unmaps the page table responsible for the physical->virtual identity mapping, but we'll still need to access the loader block. - Implement proper trap prolog/epilog code -- currently used and tested in the data abort handler. Currently hacked away some KTRAP_FRAME stuff on ARM. - The data abort handler has a very rudimentary check to detect page faults and will call MmAccessFaults, this means we now support paged pool! - We now succesfully go past MmInitSystem and go all the way until ObInitSystem (still in Phase 0). svn path=/trunk/; revision=32659
2008-03-11 16:13:43 +00:00
mov r0, sp
ldr pc, =KiDataAbortHandler
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
ENTRY_END KiDataAbortException
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
NESTED_ENTRY KiInterruptException
PROLOG_END KiInterruptException
- Fix build on ARM: - _iob is already defined as a dll_import - _rotl intrinsic is now implemented (should use rol instruction, but not sure on the syntax!) - Add a stub psctx.h for ARM - Added InterlockedEXchangePointers - Fix uninitialized variable warning in ex/resource.c - Start to implement interrupt handling: - We now have a rudimentary interrupt handler that takes care of software interrupts - We now have a rudimentary DPC handler which takes care of switching to the next thread, if any - We now setup the HAL Interrupt Source -> IRQL Table (The IRQLMask Table). - Implemented HalGetInterruptSource, which allows us to get the interrupt # that cause the IRQ. Note: this wasn't needed on Alpha/PPC/MIPS NT ports, because that information is stored on the CPU, and the kernel could read it -- we must abstract it through the HAL. - Add the OldIrql to the TRAP_FRAME, we don't use it yet. - We are now ready to context switch to the Phase 1 thread. svn path=/trunk/; revision=33933
2008-06-11 16:48:07 +00:00
//
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
// Handle trap entry
- Fix build on ARM: - _iob is already defined as a dll_import - _rotl intrinsic is now implemented (should use rol instruction, but not sure on the syntax!) - Add a stub psctx.h for ARM - Added InterlockedEXchangePointers - Fix uninitialized variable warning in ex/resource.c - Start to implement interrupt handling: - We now have a rudimentary interrupt handler that takes care of software interrupts - We now have a rudimentary DPC handler which takes care of switching to the next thread, if any - We now setup the HAL Interrupt Source -> IRQL Table (The IRQLMask Table). - Implemented HalGetInterruptSource, which allows us to get the interrupt # that cause the IRQ. Note: this wasn't needed on Alpha/PPC/MIPS NT ports, because that information is stored on the CPU, and the kernel could read it -- we must abstract it through the HAL. - Add the OldIrql to the TRAP_FRAME, we don't use it yet. - We are now ready to context switch to the Phase 1 thread. svn path=/trunk/; revision=33933
2008-06-11 16:48:07 +00:00
//
- Rewrite the low-level trap/exception/system call code from the ground up: - Do not corrupt the stack anymore - Use a consistent trap frame layout (enable OldIrql and PreviousMode, and set the 0xBADB0D00 debug mark) - Use slower but more correct trap prolog/epilog code for now. - Generalize all prolog/epilog code into macros just like on x86. As a result, traps are now 6 lines of code. - Rewrite the system call interface from the ground up: - System calls didn't actually work: a debug print made the stack layout magical enough so that they didn't normally crush, but only slowly ate the stack. - Copying arguments from caller to system call was, as the comment on the original code so aptly put it, "total shit". - Due to ABI concerns, and to provide an actual template on how you're -supposed- to implement something like system calls on RISC processors, we now use a model similar to BSD, but about ten times better (with that much less code too). We'll document it later on the RosPSG Wiki. - This code probably contains some of the most vile-yet-elegant macro magic ever written for such low-level code as system call dispatching. - The result of all this is that we're at the same place as before (RamdiskAddDevice needs to be implemented by the Ramdisk guys) but with a sane low-level backend that isn't slowly eating away the stack, corrupting data, and basically working through random chance. - Move timebase code from stubs.c to its own file, time.c. - Silence multiple debug prints and fix a corrupted debug print in KiSystemStartup. svn path=/trunk/; revision=34366
2008-07-08 09:11:44 +00:00
TRAP_PROLOG 0 // NotFromAbort
- We now make appropriate space on the stack to save the old IRQL in the trap frame. - Save the old IRQL and assert it in the interrupt handler. - Fix KTRAP_FRAME structure. svn path=/trunk/; revision=33934
2008-06-11 18:39:44 +00:00
- Fix build on ARM: - _iob is already defined as a dll_import - _rotl intrinsic is now implemented (should use rol instruction, but not sure on the syntax!) - Add a stub psctx.h for ARM - Added InterlockedEXchangePointers - Fix uninitialized variable warning in ex/resource.c - Start to implement interrupt handling: - We now have a rudimentary interrupt handler that takes care of software interrupts - We now have a rudimentary DPC handler which takes care of switching to the next thread, if any - We now setup the HAL Interrupt Source -> IRQL Table (The IRQLMask Table). - Implemented HalGetInterruptSource, which allows us to get the interrupt # that cause the IRQ. Note: this wasn't needed on Alpha/PPC/MIPS NT ports, because that information is stored on the CPU, and the kernel could read it -- we must abstract it through the HAL. - Add the OldIrql to the TRAP_FRAME, we don't use it yet. - We are now ready to context switch to the Phase 1 thread. svn path=/trunk/; revision=33933
2008-06-11 16:48:07 +00:00
//
// Call the C handler
//
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
ldr lr, =KiExceptionExit
- Fix build on ARM: - _iob is already defined as a dll_import - _rotl intrinsic is now implemented (should use rol instruction, but not sure on the syntax!) - Add a stub psctx.h for ARM - Added InterlockedEXchangePointers - Fix uninitialized variable warning in ex/resource.c - Start to implement interrupt handling: - We now have a rudimentary interrupt handler that takes care of software interrupts - We now have a rudimentary DPC handler which takes care of switching to the next thread, if any - We now setup the HAL Interrupt Source -> IRQL Table (The IRQLMask Table). - Implemented HalGetInterruptSource, which allows us to get the interrupt # that cause the IRQ. Note: this wasn't needed on Alpha/PPC/MIPS NT ports, because that information is stored on the CPU, and the kernel could read it -- we must abstract it through the HAL. - Add the OldIrql to the TRAP_FRAME, we don't use it yet. - We are now ready to context switch to the Phase 1 thread. svn path=/trunk/; revision=33933
2008-06-11 16:48:07 +00:00
mov r0, sp
mov r1, #0
ldr pc, =KiInterruptHandler
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
ENTRY_END KiInterruptException
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
NESTED_ENTRY KiFastInterruptException
PROLOG_END KiFastInterruptException
//
- Enable interrupts after probing and capturing parameters during a system call. - Enable WFI during idle loop. - Implement undefined exception handler, and get rid of reserved exception code -- this will never happen except for an SoC bug. - Request an APC interrupt if the new thread we context switched to has APCs pending and enabled. - Perform DPC watchdog debugging code if a DPC lasted more than a second. - Do the appropriate bugcheck if DPCs are active during a context switch. - Go over the FIXMEs in the assembly files too, and create a new FIXME-PERF category. svn path=/trunk/; revision=34584
2008-07-19 06:53:03 +00:00
// FIXME-PERF: Implement FIQ exception
- Fix incorrect definition of PCR and USERPCR which was making us incorrect memory. - Fix incorrect definition of ARM_CONTROL_REGISTER, which was stopping us from correctly enabling High Vectors. - The RtlCaptureStackLimits and RtlWakeChainFrame routines in libsupp.c cannot possibly be portable across all architectures -- separated ARM versions in an arm directory. - Setup the panic stack for abort/undefined exceptions, and the interrupt stack for FIQs. - Implement support for exceptions! We can now display the address which caused a data abort, and begin handling exceptions. - Implement all the HAL Spinlock/IRQL functions except KfRaise/LowerIrql which actually do the work. - We're booting all the way to setting up the user_shared_data memory area. svn path=/trunk/; revision=32653
2008-03-11 02:45:13 +00:00
//
b .
ENTRY_END KiFastInterruptException
- Improve system call handler by adding more debugging checks to be used later. - Optimize and simplify trap handling by using a common exit just like on x86's Kei386EoiHelper - KiExceptionExit. This way the code isn't duplicated 6 times. - Do the same for system calls (KiServiceExit). - Save the previous trap frame and restore it during each system call. svn path=/trunk/; revision=34640
2008-07-21 15:55:58 +00:00
NESTED_ENTRY KiExceptionExit
PROLOG_END KiExceptionExit
//
// Handle trap exit
//
TRAP_EPILOG 0 // NotFromSystemCall
ENTRY_END KiExceptionExit
NESTED_ENTRY KiServiceExit
PROLOG_END KiServiceExit
//
// Handle trap exit
//
TRAP_EPILOG 1 // FromSystemCall
ENTRY_END KiServiceExit
Reference in a new issue Copy permalink