Smp (#23)

* Fire up multiple processors

* Use IPIs to wake up secondary processors

* Much better exception information

* Modifications to show more information on fault

* WIP: Use real libstd

* Add TLS (not complete)

* Add random function, export getpid, cleanup

* Do not spin APs until new context

* Update rust

* Update rust

* Use rd/wrfsbase

* Implement TLS

* Implement compiler builtins and update rust

* Update rust

* Back to Redox libstd

* Update rust

arch/x86_64/src/interrupt/exception.rs

@@ -1,115 +1,140 @@
 use super::{halt, stack_trace};
 
-interrupt!(divide_by_zero, {
-    print!("Divide by zero fault\n");
+use syscall::flag::*;
+
+extern {
+    fn ksignal(signal: usize);
+}
+
+interrupt_stack!(divide_by_zero, stack, {
+    println!("Divide by zero fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGFPE);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt!(debug, {
-    print!("Debug trap\n");
+interrupt_stack!(debug, stack, {
+    println!("Debug trap at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGTRAP);
 });
 
-interrupt!(non_maskable, {
-    print!("Non-maskable interrupt\n");
+interrupt_stack!(non_maskable, stack, {
+    println!("Non-maskable interrupt at {:>02X}:{:>016X}", stack.cs, stack.rip);
 });
 
-interrupt!(breakpoint, {
-    print!("Breakpoint trap\n");
+interrupt_stack!(breakpoint, stack, {
+    println!("Breakpoint trap at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGTRAP);
 });
 
-interrupt!(overflow, {
-    print!("Overflow trap\n");
+interrupt_stack!(overflow, stack, {
+    println!("Overflow trap at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGFPE);
 });
 
-interrupt!(bound_range, {
-    print!("Bound range exceeded fault\n");
+interrupt_stack!(bound_range, stack, {
+    println!("Bound range exceeded fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGSEGV);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt!(invalid_opcode, {
-    print!("Invalid opcode fault\n");
+interrupt_stack!(invalid_opcode, stack, {
+    println!("Invalid opcode fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGILL);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt!(device_not_available, {
-    print!("Device not available fault\n");
+interrupt_stack!(device_not_available, stack, {
+    println!("Device not available fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGILL);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt_error!(double_fault, {
-    print!("Double fault\n");
+interrupt_error!(double_fault, stack, {
+    println!("Double fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
+    ksignal(SIGSEGV);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt_error!(invalid_tss, {
-    print!("Invalid TSS fault\n");
+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(); }
 });
 
-interrupt_error!(segment_not_present, {
-    print!("Segment not present fault\n");
+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(); }
 });
 
-interrupt_error!(stack_segment, {
-    print!("Stack segment fault\n");
+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(); }
 });
 
-interrupt_error!(protection, {
-    print!("Protection fault\n");
+interrupt_error!(protection, stack, {
+    println!("Protection fault: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
+    ksignal(SIGSEGV);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt_error!(page, {
+interrupt_error!(page, stack, {
     let cr2: usize;
     asm!("mov rax, cr2" : "={rax}"(cr2) : : : "intel", "volatile");
-    println!("Page fault: {:>016X}", cr2);
+    println!("Page fault: {:>02X}:{:>016X} at {:>02X}:{:>016X}", stack.code, cr2, stack.cs, stack.rip);
+    ksignal(SIGSEGV);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt!(fpu, {
-    print!("FPU floating point fault\n");
+interrupt_stack!(fpu, stack, {
+    println!("FPU floating point fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGFPE);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt_error!(alignment_check, {
-    print!("Alignment check fault\n");
+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(); }
 });
 
-interrupt!(machine_check, {
-    print!("Machine check fault\n");
+interrupt_stack!(machine_check, stack, {
+    println!("Machine check fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGBUS);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt!(simd, {
-    print!("SIMD floating point fault\n");
+interrupt_stack!(simd, stack, {
+    println!("SIMD floating point fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGFPE);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt!(virtualization, {
-    print!("Virtualization fault\n");
+interrupt_stack!(virtualization, stack, {
+    println!("Virtualization fault at {:>02X}:{:>016X}", stack.cs, stack.rip);
+    ksignal(SIGBUS);
     stack_trace();
     loop { halt(); }
 });
 
-interrupt_error!(security, {
-    print!("Security exception\n");
+interrupt_error!(security, stack, {
+    println!("Security exception: {:X} at {:>02X}:{:>016X}", stack.code, stack.cs, stack.rip);
+    ksignal(SIGBUS);
     stack_trace();
     loop { halt(); }
 });

arch/x86_64/src/interrupt/ipi.rs

@@ -0,0 +1,5 @@
+use device::local_apic::LOCAL_APIC;
+
+interrupt!(ipi, {
+    LOCAL_APIC.eoi();
+});

arch/x86_64/src/interrupt/mod.rs

@@ -5,6 +5,7 @@ use core::mem;
 use paging::{ActivePageTable, VirtualAddress};
 
 pub mod exception;
+pub mod ipi;
 pub mod irq;
 pub mod syscall;
 

arch/x86_64/src/interrupt/syscall.rs

@@ -23,17 +23,21 @@ pub unsafe extern fn syscall() {
         asm!("" : : "{rax}"(a) : : "intel", "volatile");
     }
 
-    asm!("push fs
-        push rax
-        mov rax, 0x18
-        mov fs, ax
-        pop rax"
+    asm!("push r15
+        rdfsbase r15
+        push r15
+        push fs
+        mov r15, 0x18
+        mov fs, r15"
         : : : : "intel", "volatile");
 
     inner();
 
     // Interrupt return
     asm!("pop fs
+        pop r15
+        wrfsbase r15
+        pop r15
         iretq"
         : : : : "intel", "volatile");
 }