Implement CPU exception handling

Currently the x86-interrupt calling convention seems to be broken; see
rust-lang/rust#109918. This results in junk
values when printing the InterruptStackFrame.

Author: SamZhang3

src/interrupt.rs

@@ -72,3 +72,131 @@ pub fn end_interrupt_disable() {
     assert!(prev_count > 0);
     interrupts::enable();
 }
+
+macro_rules! exception {
+    ($id:ident, $name:literal) => {
+        extern "x86-interrupt" fn $id(frame: InterruptStackFrame) {
+            cpu_exception(frame, $name);
+        }
+    };
+}
+
+macro_rules! exception_errcode {
+    ($id:ident, $name:literal) => {
+        extern "x86-interrupt" fn $id(frame: InterruptStackFrame, errcode: u64) {
+            cpu_exception_errcode(frame, $name, errcode);
+        }
+    };
+}
+
+macro_rules! exception_diverging {
+    ($id:ident, $name:literal) => {
+        extern "x86-interrupt" fn $id(frame: InterruptStackFrame) -> ! {
+            cpu_exception(frame, $name);
+        }
+    };
+}
+
+macro_rules! exception_diverging_errcode {
+    ($id:ident, $name:literal) => {
+        extern "x86-interrupt" fn $id(frame: InterruptStackFrame, errcode: u64) -> ! {
+            cpu_exception_errcode(frame, $name, errcode);
+        }
+    };
+}
+
+exception!(handler_divide_error, "Divide error");
+exception!(handler_debug, "Debug exception");
+exception!(handler_non_maskable_interrupt, "Non-maskable interrupt");
+exception!(handler_breakpoint, "Breakpoint exception");
+exception!(handler_overflow, "Overflow exception");
+exception!(handler_bound_range_exceeded, "Bound range exceeded");
+exception!(handler_invalid_opcode, "Invalid opcode");
+exception!(handler_device_not_available, "Device not available");
+exception_diverging_errcode!(handler_double_fault, "Double fault");
+exception_errcode!(handler_invalid_tss, "Invalid TSS");
+exception_errcode!(handler_segment_not_present, "Segment not present");
+exception_errcode!(handler_stack_segment_fault, "Stack segment exception");
+exception_errcode!(handler_general_protection_fault, "General protection fault");
+// See below for page fault handler
+exception!(handler_x87_floating_point, "x87 floating-point exception");
+exception_errcode!(handler_alignment_check, "Alignment check exception");
+exception_diverging!(handler_machine_check, "Machine check exception");
+exception!(handler_simd_floating_point, "SIMD floating-point exception");
+exception!(handler_virtualization, "Virtualization exception");
+exception_errcode!(
+    handler_vmm_communication_exception,
+    "VMM communication exception"
+);
+exception_errcode!(handler_security_exception, "Security exception");
+
+fn cpu_exception(frame: InterruptStackFrame, name: &'static str) -> ! {
+    IN_KERNEL_INTERRUPT_HANDLER.store(true, Ordering::Relaxed);
+    IN_KERNEL_EXCEPTION_HANDLER.store(true, Ordering::Relaxed);
+    panic!("CPU exception: {}, stack frame: {:?}", name, frame);
+}
+
+fn cpu_exception_errcode(frame: InterruptStackFrame, name: &'static str, errcode: u64) -> ! {
+    IN_KERNEL_INTERRUPT_HANDLER.store(true, Ordering::Relaxed);
+    IN_KERNEL_EXCEPTION_HANDLER.store(true, Ordering::Relaxed);
+    panic!(
+        "CPU exception: {}, error code: {}, stack frame: {:?}",
+        name, errcode, frame
+    );
+}
+
+extern "x86-interrupt" fn handler_page_fault(
+    frame: InterruptStackFrame,
+    errcode: idt::PageFaultErrorCode,
+) {
+    IN_KERNEL_INTERRUPT_HANDLER.store(true, Ordering::Relaxed);
+    IN_KERNEL_EXCEPTION_HANDLER.store(true, Ordering::Relaxed);
+    panic!(
+        "CPU exception: Page fault, error code: {:?}, address: {:?}, stack frame: {:?}",
+        errcode,
+        Cr2::read(),
+        frame
+    );
+}
+
+/// Initializes interrupt handling.
+///
+/// This requires heap allocation to be initialized first.
+pub fn init() {
+    let idt = Box::leak(
+        Box::try_new(InterruptDescriptorTable::new()).expect("Allocation should succeed"),
+    );
+    idt.divide_error.set_handler_fn(handler_divide_error);
+    idt.debug.set_handler_fn(handler_debug);
+    idt.non_maskable_interrupt
+        .set_handler_fn(handler_non_maskable_interrupt);
+    idt.breakpoint.set_handler_fn(handler_breakpoint);
+    idt.overflow.set_handler_fn(handler_overflow);
+    idt.bound_range_exceeded
+        .set_handler_fn(handler_bound_range_exceeded);
+    idt.invalid_opcode.set_handler_fn(handler_invalid_opcode);
+    idt.device_not_available
+        .set_handler_fn(handler_device_not_available);
+    idt.double_fault.set_handler_fn(handler_double_fault);
+    idt.invalid_tss.set_handler_fn(handler_invalid_tss);
+    idt.segment_not_present
+        .set_handler_fn(handler_segment_not_present);
+    idt.stack_segment_fault
+        .set_handler_fn(handler_stack_segment_fault);
+    idt.general_protection_fault
+        .set_handler_fn(handler_general_protection_fault);
+    idt.page_fault.set_handler_fn(handler_page_fault);
+    idt.x87_floating_point
+        .set_handler_fn(handler_x87_floating_point);
+    idt.alignment_check.set_handler_fn(handler_alignment_check);
+    idt.machine_check.set_handler_fn(handler_machine_check);
+    idt.simd_floating_point
+        .set_handler_fn(handler_simd_floating_point);
+    idt.virtualization.set_handler_fn(handler_virtualization);
+    idt.vmm_communication_exception
+        .set_handler_fn(handler_vmm_communication_exception);
+    idt.security_exception
+        .set_handler_fn(handler_security_exception);
+
+    idt.load();
+}

src/main.rs

@@ -3,7 +3,9 @@
 #![deny(missing_docs)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![feature(vec_push_within_capacity)]
+#![feature(allocator_api)]
 #![feature(const_mut_refs)]
+#![feature(abi_x86_interrupt)]
 
 //! # Doors
 //!
@@ -93,11 +95,18 @@ pub extern "C" fn _start() -> ! {
     }
 
     gdt::load();
+    interrupt::init();
+
     let mut v: Vec<i32> = Vec::new();
     v.try_reserve(1).unwrap();
     v.push_within_capacity(1).unwrap();
     kprintln!("{}", v[0]);
 
+    unsafe {
+        let _: i32 = core::ptr::read_volatile(0x0000067812345678 as *const i32);
+    }
+    //x86_64::instructions::interrupts::int3();
+
     panic!("We did it!");
 }