IDT

Author: katietheqt-old

linker.ld

@@ -47,6 +47,10 @@ SECTIONS {
 
     /DISCARD/ :
     {
+        /* 
+          Weird section that always puts itself at the start and causes the binary to be non-bootable
+          Only seems to appear on some platforms, and we can find no use of it in our circumstances
+        */
         *(.eh_frame)
     }
 }

src/protected/Cargo.lock

@@ -11,4 +11,8 @@ name = "stage_3"
 crate-type = ["staticlib"]
 
 [dependencies]
-shared = { path = "../../shared" }
+shared = { path = "../../shared" }
+
+[dependencies.lazy_static]
+version = "1.0"
+features = ["spin_no_std"]

src/protected/stage_3/Cargo.toml

@@ -0,0 +1,41 @@
+use shared::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
+use crate::println;
+use lazy_static::lazy_static;
+
+lazy_static! {
+    static ref IDT: InterruptDescriptorTable = {
+        let mut idt = InterruptDescriptorTable::new();
+
+        idt.divide_error.set_handler_fn(divide_handler);
+        idt.breakpoint.set_handler_fn(breakpoint_handler);
+        //idt.double_fault.set_handler_fn(double_fault_handler);
+
+        idt
+    };
+}
+
+
+pub fn init_idt() {
+	// Seems like we have to manually initialize it first for some reason, otherwise it crashes
+	::lazy_static::initialize(&IDT);
+	IDT.load();
+}
+
+extern "x86-interrupt" fn divide_handler(
+    stack_frame: &mut InterruptStackFrame)
+{
+    println!("[Bootloader] [IDT] Divide Exception");
+}
+
+extern "x86-interrupt" fn breakpoint_handler(
+    stack_frame: &mut InterruptStackFrame)
+{
+    println!("[Bootloader] [IDT] Breakpoint Hit");
+}
+
+/*extern "x86-interrupt" fn double_fault_handler(
+    stack_frame: &mut InterruptStackFrame, _error_code: u64) -> !
+{
+    panic!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
+    loop {};
+}*/

src/protected/stage_3/src/interrupts.rs

@@ -1,8 +1,10 @@
 #![no_std]
+#![feature(abi_x86_interrupt, asm)]
 
 use shared::println;
 use shared::instructions;
 
+mod interrupts;
 mod panic;
 
 #[no_mangle]
@@ -23,5 +25,13 @@ pub extern "C" fn third_stage() -> ! {
 
     println!("[Bootloader] [32] Loaded TSS");
 
-	loop {}
+    interrupts::init_idt();
+
+    println!("[Bootloader] [32] Loaded IDT");
+
+    unsafe { asm!("int 3") };
+
+    println!("[Bootloader] [32] It didn't crash!");
+
+    loop {};
 }

src/protected/stage_3/src/lib.rs

@@ -17,6 +17,7 @@ lazy_static! {
         let mut tss = TaskStateSegment::new();
 
         tss.privilege_stack_table[0].esp = linker_symbol!(_protected_mode_stack_end);
+        tss.privilege_stack_table[0].ss = 2 * 8; // Kernel data segment is 2nd segment (null, code, data)
 
         tss
     };

src/real/stage_2/src/lib.rs

@@ -34,8 +34,8 @@ pub struct InterruptDescriptorTable {
 impl InterruptDescriptorTable {
     /// Creates a new IDT filled with non-present entries.
     #[inline]
-    pub const fn new() -> InterruptDescriptorTable {
-        InterruptDescriptorTable {
+    pub fn new() -> InterruptDescriptorTable {
+        let idt = InterruptDescriptorTable {
             divide_error: Entry::missing(),
             debug: Entry::missing(),
             non_maskable_interrupt: Entry::missing(),
@@ -60,7 +60,9 @@ impl InterruptDescriptorTable {
             reserved_2: [Entry::missing(); 9],
             security_exception: Entry::missing(),
             reserved_3: Entry::missing(),
-        }
+        };
+
+        idt
     }
 
     /// Loads the IDT in the CPU using the `lidt` command.
@@ -122,7 +124,7 @@ pub struct Entry<F> {
 impl<F> Entry<F> {
     /// Creates a non-present IDT entry (but sets the must-be-one bits).
     #[inline]
-    pub const fn missing() -> Self {
+    pub fn missing() -> Self {
         Entry {
             gdt_selector: 0,
             offset_low: 0,
@@ -140,7 +142,7 @@ impl<F> Entry<F> {
     /// The function returns a mutable reference to the entry's options that allows
     /// further customization.
     #[inline]
-    fn set_handler_addr(&mut self, addr: u32) -> &mut EntryOptions {
+    pub fn set_handler_addr(&mut self, addr: u32) -> &mut EntryOptions {
         self.offset_low = addr as u16;
         self.offset_high = (addr >> 16) as u16;
 
@@ -196,7 +198,7 @@ impl EntryOptions {
     /// Set or reset the preset bit.
     #[inline]
     pub fn set_present(&mut self, present: bool) -> &mut Self {
-        self.0.set_bit(15, present);
+        self.0.set_bit(7, present);
         self
     }
 }
@@ -213,7 +215,7 @@ pub type DivergingHandlerFuncWithErrCode =
     extern "x86-interrupt" fn(&mut InterruptStackFrame, error_code: u64) -> !;
 
 /// Represents the interrupt stack frame pushed by the CPU on interrupt or exception entry.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 #[repr(C)]
 pub struct InterruptStackFrame {
     pub eip: u32,