Create TSS and GDT modules and use a double fault stack

src/interrupts/gdt.rs

@@ -0,0 +1,120 @@
+use bit_field::BitField;
+use collections::vec::Vec;
+use interrupts::tss::TaskStateSegment;
+
+pub struct Gdt(Vec<u64>);
+
+impl Gdt {
+    pub fn new() -> Gdt {
+        let zero_entry = 0;
+        Gdt(vec![zero_entry])
+    }
+
+    pub fn add_entry(&mut self, entry: Entry) -> Selector {
+        use core::mem::size_of;
+        let index = self.0.len() * size_of::<u64>();
+
+        match entry {
+            Entry::UserSegment(entry) => self.0.push(entry),
+            Entry::SystemSegment(entry_low, entry_high) => {
+                self.0.push(entry_low);
+                self.0.push(entry_high);
+            }
+        }
+
+        Selector(index as u16)
+    }
+
+    pub fn load(&'static self) {
+        use x86::dtables::{DescriptorTablePointer, lgdt};
+        use core::mem::size_of;
+
+        let ptr = DescriptorTablePointer {
+            base: self.0.as_ptr() as u64,
+            limit: (self.0.len() * size_of::<u64>() - 1) as u16,
+        };
+
+        unsafe { lgdt(&ptr) };
+    }
+}
+
+pub enum Entry {
+    UserSegment(u64),
+    SystemSegment(u64, u64),
+}
+
+impl Entry {
+    pub fn code_segment() -> Entry {
+        let flags = DESCRIPTOR_TYPE | PRESENT | READ_WRITE | EXECUTABLE | LONG_MODE;
+        Entry::UserSegment(flags.bits())
+    }
+
+    pub fn data_segment() -> Entry {
+        let flags = DESCRIPTOR_TYPE | PRESENT | READ_WRITE;
+        Entry::UserSegment(flags.bits())
+    }
+
+    pub fn tss_segment(tss: &'static TaskStateSegment) -> Entry {
+        use core::mem::size_of;
+
+        let ptr = tss as *const _ as u64;
+
+        let mut low = PRESENT.bits();
+        low.set_range(0..16, (size_of::<TaskStateSegment>() - 1) as u64);
+        low.set_range(16..40, ptr.get_range(0..24));
+        low.set_range(40..44, 0b1001); // type: available 64-bit tss
+
+        let mut high = 0;
+        high.set_range(0..32, ptr.get_range(32..64));
+
+        Entry::SystemSegment(low, high)
+    }
+}
+
+bitflags! {
+    flags EntryFlags: u64 {
+        const READ_WRITE        = 1 << 41,
+        const CONFORMING        = 1 << 42,
+        const EXECUTABLE        = 1 << 43,
+        const DESCRIPTOR_TYPE   = 1 << 44,
+        const PRESENT           = 1 << 47,
+        const LONG_MODE         = 1 << 53,
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Selector(u16);
+
+impl Selector {
+    pub fn new() -> Selector {
+        Selector(0)
+    }
+}
+
+pub fn reload_segment_registers(code_selector: Selector, data_selector: Selector) {
+
+    let current_code_selector: u16;
+    let current_data_selector: u16;
+
+    unsafe {
+        asm!("mov $0, cs" : "=r" (current_code_selector) ::: "intel");
+        asm!("mov $0, ds" : "=r" (current_data_selector) ::: "intel");
+    }
+    assert_eq!(code_selector.0, current_code_selector);
+    assert_eq!(data_selector.0, current_data_selector);
+
+    // jmp ax:.new_code_segment // TODO
+    // .new_code_segment:
+    // unsafe { asm!("
+    // mov ax, $1
+    // mov ss, ax
+    // mov ds, ax
+    // mov es, ax
+    // ":: "r" (code_selector.0), "r" (data_selector.0) :: "intel")};
+    //
+}
+
+/// Load the task state register.
+pub unsafe fn load_ltr(selector: Selector) {
+    asm!("ltr $0" :: "r" (selector));
+}

src/interrupts/idt.rs

@@ -102,14 +102,14 @@ impl EntryOptions {
     }
 
     #[allow(dead_code)]
-    pub fn set_privilege_level(&mut self, dpl: u16) -> &mut Self {
-        self.0.set_range(13..15, dpl);
+    pub fn set_privilege_level(&mut self, dpl: u8) -> &mut Self {
+        self.0.set_range(13..15, dpl.into());
         self
     }
 
     #[allow(dead_code)]
-    pub fn set_stack_index(&mut self, index: u16) -> &mut Self {
-        self.0.set_range(0..3, index);
+    pub fn set_stack_index(&mut self, index: u8) -> &mut Self {
+        self.0.set_range(0..3, index.into());
         self
     }
 }

src/interrupts/mod.rs

@@ -7,7 +7,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use spin::Once;
+use memory::StackPointer;
+
 mod idt;
+mod tss;
+mod gdt;
 
 macro_rules! save_scratch_registers {
     () => {
@@ -86,22 +91,53 @@ macro_rules! handler_with_error_code {
     }}
 }
 
-lazy_static! {
-    static ref IDT: idt::Idt = {
+static IDT: Once<idt::Idt> = Once::new();
+static TSS: Once<tss::TaskStateSegment> = Once::new();
+static GDT: Once<gdt::Gdt> = Once::new();
+
+pub fn init(double_fault_stack: StackPointer) {
+    let mut double_fault_ist_index = 0;
+
+    let tss = TSS.call_once(|| {
+        let mut tss = tss::TaskStateSegment::new();
+
+        double_fault_ist_index = tss.interrupt_stacks
+            .insert_stack(double_fault_stack)
+            .expect("IST flush_all");
+
+        tss
+    });
+
+    let mut code_selector = gdt::Selector::new();
+    let mut data_selector = gdt::Selector::new();
+    let mut tss_selector = gdt::Selector::new();
+    let gdt = GDT.call_once(|| {
+        let mut gdt = gdt::Gdt::new();
+
+        code_selector = gdt.add_entry(gdt::Entry::code_segment());
+        data_selector = gdt.add_entry(gdt::Entry::data_segment());
+        tss_selector = gdt.add_entry(gdt::Entry::tss_segment(tss));
+
+        gdt
+    });
+    gdt.load();
+    gdt::reload_segment_registers(code_selector, data_selector);
+    unsafe { gdt::load_ltr(tss_selector) };
+
+    let idt = IDT.call_once(|| {
         let mut idt = idt::Idt::new();
 
         idt.set_handler(0, handler!(divide_by_zero_handler));
         idt.set_handler(3, handler!(breakpoint_handler));
         idt.set_handler(6, handler!(invalid_opcode_handler));
-        idt.set_handler(8, handler_with_error_code!(double_fault_handler));
+        idt.set_handler(8, handler_with_error_code!(double_fault_handler))
+            .set_stack_index(double_fault_ist_index);
         idt.set_handler(14, handler_with_error_code!(page_fault_handler));
 
         idt
-    };
-}
+    });
 
-pub fn init() {
-    IDT.load();
+    idt.load();
 }
 
 #[derive(Debug)]

src/interrupts/tss.rs

@@ -0,0 +1,50 @@
+use memory::StackPointer;
+
+#[derive(Debug)]
+#[repr(C, packed)]
+pub struct TaskStateSegment {
+    reserved_0: u32,
+    pub privilege_stacks: PrivilegeStackTable,
+    reserved_1: u64,
+    pub interrupt_stacks: InterruptStackTable,
+    reserved_2: u64,
+    reserved_3: u16,
+    iomap_base: u16,
+}
+
+impl TaskStateSegment {
+    pub fn new() -> TaskStateSegment {
+        TaskStateSegment {
+            privilege_stacks: PrivilegeStackTable([None, None, None]),
+            interrupt_stacks: InterruptStackTable::new(),
+            iomap_base: 0,
+            reserved_0: 0,
+            reserved_1: 0,
+            reserved_2: 0,
+            reserved_3: 0,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PrivilegeStackTable([Option<StackPointer>; 3]);
+
+#[derive(Debug)]
+pub struct InterruptStackTable([Option<StackPointer>; 7]);
+
+impl InterruptStackTable {
+    pub fn new() -> InterruptStackTable {
+        InterruptStackTable([None, None, None, None, None, None, None])
+    }
+
+    pub fn insert_stack(&mut self, stack_pointer: StackPointer) -> Result<u8, StackPointer> {
+        // TSS index starts at 1
+        for (entry, i) in self.0.iter_mut().zip(1..) {
+            if entry.is_none() {
+                *entry = Some(stack_pointer);
+                return Ok(i);
+            }
+        }
+        Err(stack_pointer)
+    }
+}