Add signal support - exit on signal

arch/x86_64/src/context.rs

@@ -1,3 +1,4 @@
+use core::mem;
 use core::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT};
 
 /// This must be used by the kernel to ensure that context switches are done atomically
@@ -65,6 +66,23 @@ impl Context {
         self.rsp = address;
     }
 
+    pub unsafe fn signal_stack(&mut self, handler: extern fn(usize), sig: u8) {
+        self.push_stack(sig as usize);
+        self.push_stack(handler as usize);
+        self.push_stack(signal_handler_wrapper as usize);
+    }
+
+    pub unsafe fn push_stack(&mut self, value: usize) {
+        self.rsp -= mem::size_of::<usize>();
+        *(self.rsp as *mut usize) = value;
+    }
+
+    pub unsafe fn pop_stack(&mut self) -> usize {
+        let value = *(self.rsp as *const usize);
+        self.rsp += mem::size_of::<usize>();
+        value
+    }
+
     /// Switch to the next context by restoring its stack and registers
     #[cold]
     #[inline(never)]
@@ -108,3 +126,61 @@ impl Context {
         asm!("mov rbp, $0" : : "r"(next.rbp) : "memory" : "intel", "volatile");
     }
 }
+
+#[repr(packed)]
+pub struct SignalHandlerStack {
+    r11: usize,
+    r10: usize,
+    r9: usize,
+    r8: usize,
+    rsi: usize,
+    rdi: usize,
+    rdx: usize,
+    rcx: usize,
+    rax: usize,
+    handler: extern fn(usize),
+    sig: usize,
+    rip: usize,
+}
+
+#[naked]
+unsafe extern fn signal_handler_wrapper() {
+    #[inline(never)]
+    unsafe fn inner(stack: &SignalHandlerStack) {
+        (stack.handler)(stack.sig);
+    }
+
+    // Push scratch registers
+    asm!("xchg bx, bx
+        push rax
+        push rcx
+        push rdx
+        push rdi
+        push rsi
+        push r8
+        push r9
+        push r10
+        push r11"
+        : : : : "intel", "volatile");
+
+    // Get reference to stack variables
+    let rsp: usize;
+    asm!("" : "={rsp}"(rsp) : : : "intel", "volatile");
+
+    // Call inner rust function
+    inner(&*(rsp as *const SignalHandlerStack));
+
+    // Pop scratch registers, error code, and return
+    asm!("xchg bx, bx
+        pop r11
+        pop r10
+        pop r9
+        pop r8
+        pop rsi
+        pop rdi
+        pop rdx
+        pop rcx
+        pop rax
+        add rsp, 16"
+        : : : : "intel", "volatile");
+}

arch/x86_64/src/interrupt/exception.rs

@@ -1,5 +1,4 @@
-use super::{halt, stack_trace};
-
+use interrupt::stack_trace;
 use syscall::flag::*;
 
 extern {
@@ -8,9 +7,8 @@ extern {
 
 interrupt_stack!(divide_by_zero, stack, {
     println!("Divide by zero fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGFPE);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGFPE);
 });
 
 interrupt_stack!(debug, stack, {
@@ -34,107 +32,92 @@ interrupt_stack!(overflow, stack, {
 
 interrupt_stack!(bound_range, stack, {
     println!("Bound range exceeded fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGSEGV);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGSEGV);
 });
 
 interrupt_stack!(invalid_opcode, stack, {
     println!("Invalid opcode fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGILL);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGILL);
 });
 
 interrupt_stack!(device_not_available, stack, {
     println!("Device not available fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGILL);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGILL);
 });
 
 interrupt_error!(double_fault, stack, {
     println!("Double fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
-    ksignal(SIGSEGV);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGSEGV);
 });
 
 interrupt_error!(invalid_tss, stack, {
     println!("Invalid TSS fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
-    ksignal(SIGSEGV);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGSEGV);
 });
 
 interrupt_error!(segment_not_present, stack, {
     println!("Segment not present fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
-    ksignal(SIGSEGV);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGSEGV);
 });
 
 interrupt_error!(stack_segment, stack, {
     println!("Stack segment fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
-    ksignal(SIGSEGV);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGSEGV);
 });
 
 interrupt_error!(protection, stack, {
     println!("Protection fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
-    ksignal(SIGSEGV);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGSEGV);
 });
 
 interrupt_error!(page, stack, {
     let cr2: usize;
     asm!("mov rax, cr2" : "={rax}"(cr2) : : : "intel", "volatile");
     println!("Page fault: {:>02X}:{:>016X} at {:>02X}:{:>016X}", stack.code, cr2, stack.cs, stack.rip);
-    ksignal(SIGSEGV);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGSEGV);
 });
 
 interrupt_stack!(fpu, stack, {
     println!("FPU floating point fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGFPE);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGFPE);
 });
 
 interrupt_error!(alignment_check, stack, {
     println!("Alignment check fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
-    ksignal(SIGBUS);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGBUS);
 });
 
 interrupt_stack!(machine_check, stack, {
     println!("Machine check fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGBUS);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGBUS);
 });
 
 interrupt_stack!(simd, stack, {
     println!("SIMD floating point fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGFPE);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGFPE);
 });
 
 interrupt_stack!(virtualization, stack, {
     println!("Virtualization fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
-    ksignal(SIGBUS);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGBUS);
 });
 
 interrupt_error!(security, stack, {
     println!("Security exception: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
-    ksignal(SIGBUS);
     stack_trace();
-    loop { halt(); }
+    ksignal(SIGBUS);
 });