Add launch argument parser, add debug parameter to machine

burritos now launch binary

src/kernel/exception.rs

@@ -245,7 +245,7 @@ mod test {
 
     #[test]
     fn test_sc_shutdown() {
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
         machine.write_int_register(17, SC_SHUTDOWN as i64); // Set type to shutdown
         let ecall = Instruction::new(0b000000000000_00000_000_00000_1110011);
 
@@ -261,7 +261,7 @@ mod test {
     #[test]
     #[ignore]
     fn test_sc_print() {
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
 
         let address = machine.read_int_register(10);
         // Write string 'HELLO' in memory

src/kernel/synch.rs

@@ -277,7 +277,7 @@ mod test {
     #[test]
     fn test_semaphore_single() {
         // Init
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
         let mut thread_manager = ThreadManager::new();
         let mut semaphore = Semaphore::new(1);
         let thread = Rc::new(RefCell::new(Thread::new("test_semaphore")));
@@ -297,7 +297,7 @@ mod test {
     fn test_semaphore_multiple() {
         // Init
         let mut tm = ThreadManager::new();
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
         let mut semaphore = Semaphore::new(2);
         let thread1 = Rc::new(RefCell::new(Thread::new("test_semaphore_1")));
         let thread2 = Rc::new(RefCell::new(Thread::new("test_semaphore_2")));
@@ -342,7 +342,7 @@ mod test {
 
     #[test]
     fn test_lock_simple() {
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
         let mut tm = ThreadManager::new();
         let thread = Rc::new(RefCell::new(Thread::new("test_lock")));
         tm.ready_to_run(Rc::clone(&thread));
@@ -364,7 +364,7 @@ mod test {
         let thread1 = Rc::new(RefCell::new(Thread::new("test_lock1")));
         let thread2 = Rc::new(RefCell::new(Thread::new("test_lock2")));
 
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
         let mut tm = ThreadManager::new();
         
         tm.ready_to_run(Rc::clone(&thread1));

src/kernel/thread_manager.rs

@@ -206,7 +206,7 @@ mod test {
 
     #[test]
     fn test_thread_context() {
-        let mut machine = Machine::default();
+        let mut machine = Machine::new(true);
 
         let (loader, ptr) = loader::Loader::new("./target/guac/halt.guac", &mut machine, 0).expect("IO Error");
         let start_pc = loader.elf_header.entrypoint;

src/main.rs

@@ -13,11 +13,45 @@ mod kernel;
 /// module containing useful tools which can be use in most part of the OS to ease the development of the OS
 pub mod utility;
 
-use kernel::system::System;
-use simulator::machine::Machine;
+use std::{rc::Rc, cell::RefCell};
+
+use kernel::{system::System, thread::Thread, process::Process};
+use simulator::{machine::Machine, loader};
+
+
+use clap::Parser;
+
+#[derive(Parser, Debug)]
+#[command(name = "BurritOS", author, version, about = "Burritos (BurritOS Using Rust Really Improves The Operating System)
+
+Burritos is an educational operating system written in Rust
+running on RISC-V emulator.", long_about = None)]
+struct Args {
+    /// Enable debug mode
+    #[arg(short, long)]
+    debug: bool,
+    /// Path to the executable binary file to execute
+    #[arg(short = 'x', long, value_name = "PATH")]
+    executable: String
+}
 
 fn main() {
-    let mut machine = Machine::init_machine();
+    let args = Args::parse();
+
+    let mut machine = Machine::new(args.debug);
+    let (loader, ptr) = loader::Loader::new(args.executable.as_str(), &mut machine, 0).expect("IO Error");
+    
     let mut system = System::default();
+
+    let thread_exec = Thread::new(args.executable.as_str());
+    let thread_exec = Rc::new(RefCell::new(thread_exec));
+    system.get_thread_manager().get_g_alive().push(Rc::clone(&thread_exec));
+
+    let owner1 = Process { num_thread: 0 };
+    system.get_thread_manager().start_thread(Rc::clone(&thread_exec), owner1, loader.elf_header.entrypoint, ptr, -1);
+    
+    let to_run = system.get_thread_manager().find_next_to_run().unwrap();
+    system.get_thread_manager().switch_to(&mut machine, Rc::clone(&to_run));
+
     machine.run(&mut system);
 }

src/simulator/loader.rs

@@ -612,7 +612,7 @@ mod test {
 
     #[test]
     fn test_parse_elf() {
-        let mut machine = Machine::default();
+        let mut machine = Machine::new(true);
         let loader = Loader::load_and_parse("./target/guac/unsigned_addition.guac").expect("IO Error");
         loader.load_into_machine(&mut machine, 0).expect("Parsing error");
         assert!(!loader.elf_header.is_32bits);
@@ -633,7 +633,7 @@ mod test {
 
     #[test]
     fn test_parse_section() {
-        let mut machine = Machine::default();
+        let mut machine = Machine::new(true);
         let loader = Loader::load_and_parse("./target/guac/unsigned_addition.guac").expect("IO Error");
         loader.load_into_machine(&mut machine, 0).expect("Parsing error");
         assert_eq!(9, loader.sections.len());

src/simulator/machine.rs

@@ -80,6 +80,8 @@ pub const MEM_SIZE : usize = (PAGE_SIZE*NUM_PHY_PAGE*100_000) as usize;
 
 /// RISC-V Simulator
 pub struct Machine {
+	/// Debug mode of the machine
+	debug: bool,
 	/// Program counter
 	pub pc : u64,
 	/// Stack pointer
@@ -107,9 +109,28 @@ pub struct Machine {
 impl Machine {
 
 	/// Machine constructor
-	#[deprecated]
-	pub fn init_machine() -> Machine {	
-		Self::default()
+	pub fn new(debug: bool) -> Self {
+		let mut shiftmask : [u64 ; 64] = [0 ; 64];
+		let mut value : u64 = 0xffffffff;
+
+		value = (value << 32) + value;
+		for item in &mut shiftmask {
+			*item = value;
+			value >>= 1;
+		}
+
+		Machine {
+			debug,
+			pc : 0,
+			sp: 0,
+			int_reg : { let mut r = Register::<i64>::init(); r.set_reg(10, -1); r },
+			fp_reg : Register::<f32>::init(),
+			main_memory : vec![0_u8; MEM_SIZE],
+			shiftmask,
+			interrupt: Interrupt::new(),
+			registers_trace : String::from(""),
+			status: MachineStatus::SystemMode
+		}
 	}
 
 	/// Read from main memory of the machine
@@ -189,10 +210,8 @@ impl Machine {
 			println!();
 		}
 		println!("________________SP________________");
-		let sp_index = self.int_reg.get_reg(2);
-		/* for i in 0..5 {
-			println!("SP+{:<2} : {:16x}", i*8, self.read_memory(8, (sp_index + i*8) as usize));
-		} */		
+		let sp = self.int_reg.get_reg(2);
+		println!("SP: {:16x}", self.read_memory(8, sp as usize));	
 		println!("##################################");
 	}
 
@@ -267,11 +286,13 @@ impl Machine {
 		
 		let val = u32::from_be_bytes(val) as u64;
 		let inst : Instruction = Instruction::new(val);
-		self.print_status();
-		println!("executing instruction : {:016x} at pc {:x}", val, self.pc);
-		println!("{}", instruction::instruction_debug(&inst, self.pc as i32));
-		let trace = Self::string_registers(self);
-		self.registers_trace.push_str(format!("{}\n", trace).as_str());
+		if self.debug {
+			self.print_status();
+			println!("executing instruction : {:016x} at pc {:x}", val, self.pc);
+			println!("{}", instruction::instruction_debug(&inst, self.pc as i32));
+			let trace = Self::string_registers(self);
+			self.registers_trace.push_str(format!("{}\n", trace).as_str());
+		}
 		
 		self.pc += 4;
 		
@@ -680,42 +701,12 @@ impl Machine {
 	}
 }
 
-impl Default for Machine {
-	/// Machine constructor
-    fn default() -> Self {
-        let mut shiftmask : [u64 ; 64] = [0 ; 64];
-		let mut value : u64 = 0xffffffff;
-
-		value = (value << 32) + value;
-		for item in &mut shiftmask {
-			*item = value;
-			value >>= 1;
-		}
-
-		Machine {
-			pc : 0,
-			sp: 0,
-			int_reg : { let mut r = Register::<i64>::init(); r.set_reg(10, -1); r },
-			fp_reg : Register::<f32>::init(),
-			main_memory : vec![0_u8; MEM_SIZE],
-			shiftmask,
-			interrupt: Interrupt::new(),
-			registers_trace : String::from(""),
-			status: MachineStatus::SystemMode
-		}
-    }
-}
-
 #[cfg(test)]
 
 mod test {
     use std::fs;
 
     use crate::simulator::{machine::Machine, mem_cmp};
-	use crate::kernel::thread::Thread;
-	use crate::kernel::process::Process;
-	use std::rc::Rc;
-	use std::cell::RefCell;
 
 	macro_rules! get_full_path {
 		($prefix: expr, $test_name:expr) => {{
@@ -729,7 +720,7 @@ mod test {
 
 	macro_rules! init_test {
 		($a:expr) => {{
-			let mut m = Machine::init_machine();
+			let mut m = Machine::new(true);
 			let end_file_name = { let mut s = String::from($a); s.push_str("End"); s };
 			let memory_before = mem_cmp::MemChecker::from(get_full_path!("memory", $a)).unwrap();
 			let memory_after = mem_cmp::MemChecker::from(get_full_path!("memory", &end_file_name)).unwrap();
@@ -744,12 +735,12 @@ mod test {
 
 	#[test]
 	fn test_init_machine() {
-		let _ = Machine::init_machine();
+		let _ = Machine::new(true);
 	}
 
 	#[test]
 	fn test_read_memory() {
-		let mut m = Machine::init_machine();
+		let mut m = Machine::new(true);
     	m.main_memory[4] = 43;
     	m.main_memory[5] = 150;
 		assert_eq!((43 << 8) + 150, m.read_memory(2, 4));
@@ -757,7 +748,7 @@ mod test {
 
 	#[test]
 	fn test_write_memory() {
-		let mut m = Machine::init_machine();
+		let mut m = Machine::new(true);
 		m.write_memory(2, 6, (43 << 8) + 150);
 		assert_eq!(43, m.main_memory[6]);
 		assert_eq!(150, m.main_memory[7]);

src/simulator/mem_cmp.rs

@@ -211,7 +211,7 @@ mod tests {
     #[test]
     fn test_fill_memory(){
         let m_c = MemChecker::from("test/machine/memoryAdd.txt").unwrap();
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
         MemChecker::fill_memory_from_mem_checker(&m_c, &mut machine);
         MemChecker::compare_print_m_c_machine(&m_c, &mut machine);
     }