User Mode working

Author: katietheqt-old

build.rs

@@ -29,7 +29,7 @@ fn main() {
     // Build stage 3
     build_subproject(
         Path::new("src/protected/stage_3"),
-        &["third_stage"],
+        &["third_stage", "iret_test"],
         "../i386-unknown-none.json",
         &target_dir,
         &objcopy,
@@ -55,7 +55,7 @@ fn main() {
     // Build stage 2
     build_subproject(
         Path::new("src/real/stage_2"),
-        &["second_stage"],
+        &["second_stage", "v8086_test"],
         "../i386-unknown-none-code16.json",
         &target_dir,
         &objcopy,

src/protected/stage_3/src/interrupts.rs

@@ -9,6 +9,7 @@ lazy_static! {
         idt.divide_error.set_handler_fn(divide_handler);
         idt.breakpoint.set_handler_fn(breakpoint_handler);
 
+        idt.general_protection_fault.set_handler_fn(general_protection_fault_handler);
         idt.double_fault.set_handler_fn(double_fault_handler);
 
         idt
@@ -38,4 +39,11 @@ extern "x86-interrupt" fn double_fault_handler(
     stack_frame: &mut InterruptStackFrame, _error_code: u32) -> !
 {
     panic!("[Bootloader] [IDT] Double Fault!");
+}
+
+extern "x86-interrupt" fn general_protection_fault_handler(
+	stack_frame: &mut InterruptStackFrame, error_code: u32)
+{
+    println!("[Bootloader] [IDT] GPF {} ({})", stack_frame.eip, error_code);
+    loop {};
 }

src/protected/stage_3/src/iret.s

@@ -0,0 +1,18 @@
+.att_syntax prefix
+iret_asm_test:
+    mov    $0x23, %eax
+    mov    %eax, %ds
+    mov    %eax, %es
+    mov    %eax, %fs
+    mov    %eax, %gs
+    mov    %esp, %eax
+    
+    push   $0x23
+    push   %eax
+
+    pushf
+
+    push   $0x1b
+    pushl  $iret_test
+    
+    iret

src/protected/stage_3/src/lib.rs

@@ -1,19 +1,27 @@
 #![no_std]
-#![feature(abi_x86_interrupt, asm)]
+#![feature(abi_x86_interrupt, asm, global_asm)]
 
 use shared::println;
 use shared::instructions;
+use shared::linker_symbol;
 
 mod interrupts;
 mod panic;
 
+global_asm!(include_str!("iret.s"));
+
+extern "C" {
+    fn v8086_test();
+    fn iret_asm_test();
+}
+
 #[no_mangle]
 pub extern "C" fn third_stage() -> ! {
-	println!("[Bootloader] [32] Stage 3");
+    println!("[Bootloader] [32] Stage 3");
 
-	unsafe {
-	    let ptr = 0x110000 as *mut u32;
-	    *ptr = 0xdeadbeef;
+    unsafe {
+        let ptr = 0x110000 as *mut u32;
+        *ptr = 0xdeadbeef;
     }
 
     println!("[Bootloader] [32] > 1MB");
@@ -29,5 +37,21 @@ pub extern "C" fn third_stage() -> ! {
 
     println!("[Bootloader] [32] Loaded IDT");
 
+    unsafe {
+        let eflags = instructions::read_eflags() ;//| (1 << 17);
+        let fn_addr = &iret_test as *const _ as u32;
+
+        println!("fn @ {}", fn_addr);
+
+        iret_asm_test();
+    }
+
+    println!("User mode returned");
+
     loop {};
+}
+
+#[no_mangle]
+pub extern "C" fn iret_test() {
+    println!("User mode");
 }

src/real/stage_2/src/lib.rs

@@ -8,16 +8,26 @@ use lazy_static::lazy_static;
 
 mod panic;
 
+#[no_mangle]
+pub fn v8086_test() {
+    loop {};
+    println!("v8086 mode! Yayyyy");
+    loop {};
+}
+
 extern "C" {
     fn protected_mode_switch() -> !;
 }
 
 lazy_static! {
     static ref TSS: TaskStateSegment = {
+        use core::mem::size_of;
+
         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.iomap_base = size_of::<TaskStateSegment>() as u16; 
 
         tss
     };

src/shared/src/instructions.rs

@@ -1,3 +1,5 @@
+global_asm!(include_str!("instructions.s"));
+
 /// Performs a retf instruction, jumping to cs:eip
 ///
 /// # Unsafety
@@ -10,6 +12,45 @@ pub unsafe fn retf(cs: u16, eip: u32) {
 		  in(reg) cs, in(reg) eip);
 }
 
+/// Performs an iret instruction, jumping to cs:eip (as well as setting the stack to ss:esp and setting eflags)
+///
+/// # Unsafety
+/// We make no guarantees that any of the parameters are valid
+extern "C" {
+	pub fn iret(ss: u32, esp: u32, cs: u32, eip: u32, eflags: u32);
+}
+
+/*
+#[inline(always)]
+pub unsafe fn iret(ss: u32, esp: u32, cs: u32, eip: u32, eflags: u32) {
+	use crate::println;
+	println!("ss - {} esp - {} cs - {} eip - {} eflags - {}", ss, esp, cs, eip, eflags);
+	asm!("push {ss:e}
+		  push {esp:e}
+		  push {eflags:e}
+		  push {cs:e}
+		  push {eip:e}
+		  iret",
+	     ss = in(reg) ss, esp = in(reg) esp, cs = in(reg) cs, eip = in(reg) eip, eflags = in(reg) eflags
+	);
+}*/
+
+/// Reads EFlags
+#[inline]
+pub fn read_eflags() -> u32 {
+	let mut eflags: u32;
+
+	unsafe {
+    	asm!(
+	    	"pushfd
+		     pop {}", 
+		     out(reg) eflags, options(nomem, preserves_flags)
+    	)
+    };
+
+	eflags
+}
+
 /// Loads a new value into the task state register
 ///
 /// # Unsafety

src/shared/src/instructions.s

@@ -0,0 +1,11 @@
+.intel_syntax noprefix
+
+iret:
+  mov ebp, esp
+
+  push dword PTR [ebp+4]
+  push dword PTR [ebp+8]
+  push dword PTR [ebp+12]  
+  push dword PTR [ebp+16]
+  push dword PTR [ebp+20]
+  iret

src/shared/src/structures/gdt.rs

@@ -49,6 +49,17 @@ impl GlobalDescriptorTable {
             limit: (self.table.len() * size_of::<u64>() - 1) as u16,
         };
 
+        use crate::println;
+        println!("GDT -");
+        println!("    {:#08x}", self.table[0]);
+        println!("    {:#08x}", self.table[1]);
+        println!("    {:#08x}", self.table[2]);
+        println!("    {:#08x}", self.table[3]);
+        println!("    {:#08x}", self.table[4]);
+        println!("    {:#08x}", self.table[5]);
+        println!("    {:#08x}", self.table[6]);
+        println!("    {:#08x}", self.table[7]);
+
         asm!("lgdt [{}]",
              in(reg) &ptr,
              options(nostack)
@@ -95,6 +106,9 @@ bitflags! {
         /// The DPL for this descriptor is Ring 3
         const DPL_RING_3        = 3 << 45;
 
+        /// Is this segment available for use
+        const AVAILABLE         = 1 << 52;
+
         /// If set, this page is a 32 bit descriptor
         const SIZE              = 1 << 54;
 
@@ -116,7 +130,7 @@ impl Descriptor {
         use self::DescriptorFlags as Flags;
 
         let flags =
-            Flags::USER_SEGMENT | Flags::PRESENT | Flags::EXECUTABLE | Flags::READABLE_WRITABLE | Flags::SIZE;
+            Flags::USER_SEGMENT | Flags::PRESENT | Flags::READABLE_WRITABLE | Flags::ACCESSED | Flags::SIZE | Flags::EXECUTABLE;
 
         Descriptor(flags.bits()).with_flat_limit()
     }
@@ -126,7 +140,8 @@ impl Descriptor {
     pub fn kernel_data_segment() -> Descriptor {
         use self::DescriptorFlags as Flags;
 
-        let flags = Flags::USER_SEGMENT | Flags::PRESENT | Flags::READABLE_WRITABLE | Flags::SIZE;
+        let flags = 
+            Flags::USER_SEGMENT | Flags::PRESENT | Flags::READABLE_WRITABLE | Flags::ACCESSED | Flags::SIZE;
         Descriptor(flags.bits()).with_flat_limit()
     }
 
@@ -136,7 +151,7 @@ impl Descriptor {
         use self::DescriptorFlags as Flags;
 
         let flags =
-            Flags::USER_SEGMENT | Flags::PRESENT | Flags::READABLE_WRITABLE | Flags::DPL_RING_3;
+            Flags::USER_SEGMENT | Flags::PRESENT | Flags::READABLE_WRITABLE | Flags::ACCESSED | Flags::SIZE | Flags::DPL_RING_3;
         Descriptor(flags.bits()).with_flat_limit()
     }
 
@@ -145,11 +160,8 @@ impl Descriptor {
     pub fn user_code_segment() -> Descriptor {
         use self::DescriptorFlags as Flags;
 
-        let flags = Flags::USER_SEGMENT
-            | Flags::PRESENT
-            | Flags::EXECUTABLE
-            | Flags::DPL_RING_3
-            | Flags::READABLE_WRITABLE;
+        let flags =
+            Flags::USER_SEGMENT | Flags::PRESENT | Flags::READABLE_WRITABLE | Flags::ACCESSED | Flags::SIZE | Flags::EXECUTABLE | Flags::DPL_RING_3;
         Descriptor(flags.bits()).with_flat_limit()
     }
 
@@ -162,7 +174,7 @@ impl Descriptor {
         let ptr = tss as *const _ as u64;
 
 
-        let mut val: u64 = (Flags::PRESENT | Flags::EXECUTABLE | Flags::ACCESSED | Flags::SIZE).bits();
+        let mut val: u64 = (Flags::PRESENT | Flags::EXECUTABLE | Flags::ACCESSED | Flags::SIZE | Flags::DPL_RING_3).bits();
 
         // base
         val.set_bits(16..40, ptr.get_bits(0..24));