feat: implement thread (wip)

Author: mopp

src/arch/mod.rs

@@ -29,6 +29,7 @@ macro_rules! with_arch {
  ($arch: ident) => {
  mod $arch;
  pub use self::$arch::Initializer;
+ pub use self::$arch::Thread;
  };
 }
 

src/arch/x86_64/interrupt.rs

@@ -6,6 +6,7 @@ mod handler;
 mod pic;
 mod pit;
 mod table;
+pub use handler::InterruptFrame;
 use table::InterruptDescriptorTable;
 
 // 0x00007E00 - 0x0007FFFF is free region.

src/arch/x86_64/interrupt/handler.rs

@@ -15,10 +15,10 @@ bitfield! {
 #[repr(C)]
 pub struct InterruptFrame {
  ip: usize,
- cs: usize,
+ pub cs: usize,
  flags: usize,
  sp: usize,
- ss: usize,
+ pub ss: usize,
 }
 
 impl fmt::Debug for InterruptFrame {
@@ -27,15 +27,15 @@ impl fmt::Debug for InterruptFrame {
  }
 }
 
-pub type Handler = extern "x86-interrupt" fn(&InterruptFrame);
-pub type HandlerWithErrorCode = extern "x86-interrupt" fn(&InterruptFrame, ErrorCode);
+pub type Handler = extern "x86-interrupt" fn(&mut InterruptFrame);
+pub type HandlerWithErrorCode = extern "x86-interrupt" fn(&mut InterruptFrame, ErrorCode);
 
-pub extern "x86-interrupt" fn default_handler(interrupt_frame: &InterruptFrame) {
+pub extern "x86-interrupt" fn default_handler(interrupt_frame: &mut InterruptFrame) {
  println!("Got interrupt");
  println!(" {:?}", interrupt_frame);
 }
 
-pub extern "x86-interrupt" fn default_handler_with_error_code(interrupt_frame: &InterruptFrame, error: ErrorCode) {
+pub extern "x86-interrupt" fn default_handler_with_error_code(interrupt_frame: &mut InterruptFrame, error: ErrorCode) {
  println!("Got interrupt");
  println!(" {:?}", interrupt_frame);
  println!(" {:x}", error.0);

src/arch/x86_64/interrupt/pic.rs

@@ -1,3 +1,4 @@
+use super::super::thread;
 use super::handler::InterruptFrame;
 use super::table::InterruptDescriptorTable;
 use lazy_static::lazy_static;
@@ -71,9 +72,10 @@ pub unsafe fn enable_timer_interrupt() {
  MASTER_DATA_PORT.lock().write(0b1111_1110);
 }
 
-pub extern "x86-interrupt" fn timer_handler(_: &InterruptFrame) {
+pub extern "x86-interrupt" fn timer_handler(frame: &mut InterruptFrame) {
  // FIXME: use listener pattern.
- crate::process::switch_process();
+ thread::switch_context(frame);
+
  send_end_of_interrupt(IRQ_NUMBER_TIMER);
 }
 

src/arch/x86_64/mod.rs

@@ -8,6 +8,9 @@ use lazy_static::lazy_static;
 
 mod interrupt;
 mod tss;
+mod thread;
+
+pub use thread::Thread;
 
 const VRAM_ADDR: PhysicalAddress = 0xB8000;
 

src/arch/x86_64/thread.rs

@@ -0,0 +1,53 @@
+use super::interrupt::InterruptFrame;
+
+pub struct Thread {}
+
+impl Thread {
+ pub fn new() -> Thread {
+ Thread {}
+ }
+}
+
+pub fn switch_context(frame: &mut InterruptFrame) {
+ crate::process::select_threads(|| {
+ frame.cs = 8 * 3 + 3;
+ frame.ss = 8 * 4 + 3;
+ unsafe {
+ asm!("mov ds, $0
+ mov es, $0
+ mov fs, $0
+ mov gs, $0
+ "
+ :
+ : "r"(frame.ss as u16)
+ : "ax"
+ : "intel", "volatile"
+ );
+ }
+
+ // let mut current_ip = 0;
+ // let mut current_sp = 0;
+ // let mut next_ip = 0;
+ // let mut next_sp = 0;
+ // unsafe {
+ // asm!("
+ // pushf
+ //
+ // mov [$0], $2
+ // mov [$1], rsp
+ // "
+ // : "=r"(&mut current_ip) "=r"(&mut current_sp)
+ // : "r"(landing_point as usize)
+ // : "memory"
+ // : "intel", "volatile");
+ // }
+ //
+ // println!("{}", current_ip);
+ // println!("{}", current_sp);
+ })
+}
+
+// #[no_mangle]
+// pub extern "C" fn landing_point() {
+// unsafe { asm!("popf") }
+// }

src/process.rs

@@ -1,3 +1,4 @@
+use crate::arch::Thread;
 use crate::memory::{ActivePageTable, FrameAllocator, InActivePageTable};
 use core::mem;
 use core::ptr;
@@ -6,13 +7,15 @@ use spin::Mutex;
 
 struct Process {
  page_table: InActivePageTable,
+ thread: Thread,
 }
 
 impl Process {
  fn new(allocator: &mut FrameAllocator) -> Process {
  // FIXME: remove 1st argument (ActivePageTable).
  Process {
  page_table: InActivePageTable::new(unsafe { &mut ActivePageTable::new() }, allocator).unwrap(),
+ thread: Thread::new(),
  }
  }
 }
@@ -40,29 +43,10 @@ lazy_static! {
  static ref PROCESS_MANAGER: Mutex<ProcessManager> = Mutex::new(ProcessManager::new());
 }
 
-pub fn switch_process() {
- // let mut current_ip = 0;
- // let mut current_sp = 0;
- // let mut next_ip = 0;
- // let mut next_sp = 0;
- // unsafe {
- // asm!("
- // pushf
- //
- // mov [$0], $2
- // mov [$1], rsp
- // "
- // : "=r"(&mut current_ip) "=r"(&mut current_sp)
- // : "r"(landing_point as usize)
- // : "memory"
- // : "intel", "volatile");
- // }
- //
- // println!("{}", current_ip);
- // println!("{}", current_sp);
+pub fn select_threads<F>(mut switch_context: F)
+where
+ F: FnMut(),
+{
+ // TODO: pass current process and next process.
+ switch_context();
 }
-
-// #[no_mangle]
-// pub extern "C" fn landing_point() {
-// unsafe { asm!("popf") }
-// }