From 08ba0154f75460f50fbe49d658ef28c9b3dfc75a Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Mon, 27 Mar 2023 18:10:11 +0200 Subject: [PATCH 01/26] Add a bin loader --- src/kernel/mod.rs | 2 +- src/main.rs | 24 +++++++++++++++++++++--- src/simulator/loader.rs | 31 +++++++++++++++++++++++++++++++ src/simulator/machine.rs | 30 +++++++++++++++--------------- src/simulator/print.rs | 2 +- 5 files changed, 69 insertions(+), 20 deletions(-) diff --git a/src/kernel/mod.rs b/src/kernel/mod.rs index 67a43cb..1fe4f0f 100644 --- a/src/kernel/mod.rs +++ b/src/kernel/mod.rs @@ -1,4 +1,4 @@ -mod process; +pub mod process; pub mod thread; pub mod mgerror; pub mod system; diff --git a/src/main.rs b/src/main.rs index cc181fe..2774e7b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -13,10 +13,28 @@ 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 std::{rc::Rc, cell::RefCell}; + use kernel::system::System; -use simulator::machine::Machine; +use simulator::{machine::Machine, loader}; + +use crate::kernel::{thread::Thread, process::Process}; fn main() { - let machine = Machine::init_machine(); - let system = System::default(); + let mut machine = Machine::init_machine(); + loader::load("test.o", &mut machine, 0).expect("IO Error"); + let system = &mut System::default(); + let thread1 = Thread::new("th1"); + let thread1 = Rc::new(RefCell::new(thread1)); + system.get_thread_manager().get_g_alive().push(Rc::clone(&thread1)); + let owner = Process { num_thread: 0 }; + system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, 0 as i64, 0); + debug_assert_eq!(thread1.borrow_mut().thread_context.pc, 0 as i64); + let to_run = system.get_thread_manager().find_next_to_run().unwrap(); + debug_assert_eq!(to_run, Rc::clone(&thread1)); + debug_assert!(system.get_thread_manager().get_g_alive().contains(&Rc::clone(&thread1))); + system.get_thread_manager().switch_to(&mut machine, Rc::clone(&to_run)); + + machine.run(); + } diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 4b84b83..3404128 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -3,6 +3,7 @@ use crate::Machine; use std::fs; use std::io; use std::io::BufRead; +use std::io::Read; @@ -15,6 +16,7 @@ use std::io::BufRead; /// /// - **path** the path of the file to load /// - **size** the number of bytes to write (1, 2, 4 or 8) +#[deprecated] pub fn _load(path : &str, instruction_size: i32) -> Machine { let file = fs::File::open(path).expect("Wrong filename"); let reader = io::BufReader::new(file); @@ -31,4 +33,33 @@ pub fn _load(path : &str, instruction_size: i32) -> Machine { } println!("{:x}", Machine::read_memory(& mut machine, 4, 0)); machine +} + +/// load a 32-bits binary file into the machine +/// +/// ### Parameters +/// +/// - **path** path of the file to load +/// - **machine** the machine where the bin file will be loaded +/// - **start_index** at which index of machine memory you want to start to load the program +/// +/// Returns in a Result any io error +pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result<(), std::io::Error> { + let mut file = fs::File::open(path)?; + let mut instructions: Vec = Default::default(); + loop { + let mut buf: [u8; 4] = [0; 4]; + let res = file.read(&mut buf)?; + if res == 0 { + break; // eof + } else { + instructions.push(u32::from_le_bytes(buf)); + } + } + for i in 0..instructions.len() { + machine.write_memory(4, 4 * i + start_index, instructions[i] as u64); + } + #[cfg(debug_assertions)] + println!("{:04x?}", instructions); // only print loaded program in debug build + Ok(()) } \ No newline at end of file diff --git a/src/simulator/machine.rs b/src/simulator/machine.rs index e54bd87..7d62e78 100644 --- a/src/simulator/machine.rs +++ b/src/simulator/machine.rs @@ -146,7 +146,7 @@ impl Machine { /// - **machine** which contains the main memory /// - **size** the number of bytes to read (1, 2, 4, 8) /// - **address** in the memory to read - pub fn read_memory(machine : &mut Machine, size : i32, address : usize) -> u64 { + pub fn read_memory(&mut self, size : i32, address : usize) -> u64 { if ![1, 2, 4, 8].contains(&size) { panic!("ERROR read_memory : wrong size parameter {size}, must be (1, 2, 4 or 8)"); } @@ -154,7 +154,7 @@ impl Machine { let mut ret: u64 = 0; for i in 0..size { ret <<= 8; - ret += machine.main_memory[address + i as usize] as u64; + ret += self.main_memory[address + i as usize] as u64; } ret } @@ -169,13 +169,13 @@ impl Machine { /// - **size** the number of bytes to write (1, 2, 4 or 8) /// - **address** the address to write to /// - **value** data to be written - pub fn write_memory(machine: &mut Machine, size: i32, address: usize, value: u64) { + pub fn write_memory(&mut self, size: i32, address: usize, value: u64) { if ![1, 2, 4, 8].contains(&size) { panic!("ERROR write_memory: WRONG `size` PARAMETER ({size}), must be 1, 2, 4 or 8") } for i in 0..size as usize { let inv_i = size as usize - i - 1; - machine.main_memory[address + i] = ((value & 0xff << (8 * inv_i)) >> (inv_i * 8)) as u8; + self.main_memory[address + i] = ((value & 0xff << (8 * inv_i)) >> (inv_i * 8)) as u8; } } @@ -185,11 +185,11 @@ impl Machine { /// ### Parameters /// /// - **machine** contains the memory - pub fn _extract_memory(machine: &mut Machine){ + pub fn _extract_memory(&mut self){ let file_path = "burritos_memory.txt"; let write_to_file = |path| -> std::io::Result { let mut file = File::create(path)?; - file.write_all(&machine.main_memory)?; + file.write_all(&self.main_memory)?; Ok(file) }; match write_to_file(file_path) { @@ -198,20 +198,20 @@ impl Machine { }; } - pub fn print_machine_status(machine: &mut Machine) { + pub fn print_machine_status(&mut self) { println!("######### Machine status #########"); for i in (0..32).step_by(3) { - print!(">{0: <4} : {1:<16x} ", print::REG_X[i], machine.int_reg.get_reg(i)); - print!(">{0: <4} : {1:<16x} ", print::REG_X[i+1], machine.int_reg.get_reg(i+1)); + print!(">{0: <4} : {1:<16x} ", print::REG_X[i], self.int_reg.get_reg(i)); + print!(">{0: <4} : {1:<16x} ", print::REG_X[i+1], self.int_reg.get_reg(i+1)); if i+2 < 32 { - print!(">{0: <4} : {1:<16x} ", print::REG_X[i+2], machine.int_reg.get_reg(i+2)); + print!(">{0: <4} : {1:<16x} ", print::REG_X[i+2], self.int_reg.get_reg(i+2)); } println!(); } println!("________________SP________________"); - let sp_index = machine.int_reg.get_reg(2); + let sp_index = self.int_reg.get_reg(2); for i in 0..5 { - println!("SP+{:<2} : {:16x}", i*8, Self::read_memory(machine, 8, (sp_index + i*8) as usize)); + println!("SP+{:<2} : {:16x}", i*8, Self::read_memory(self, 8, (sp_index + i*8) as usize)); } println!("##################################"); } @@ -229,9 +229,9 @@ impl Machine { /// ### Parameters /// /// - **machine** which contains a table of instructions - pub fn run(machine : &mut Machine){ - while Machine::one_instruction(machine) == 0 {} - println!("trace : \n{}", machine.registers_trace); + pub fn run(&mut self){ + while Machine::one_instruction(self) == 0 {} + println!("trace : \n{}", self.registers_trace); } /// execute the current instruction diff --git a/src/simulator/print.rs b/src/simulator/print.rs index 54bcddf..c9b62b1 100644 --- a/src/simulator/print.rs +++ b/src/simulator/print.rs @@ -216,7 +216,7 @@ pub fn print(ins: Instruction, pc: i32) -> String { //TODO pc should be u64 RISCV_SYSTEM => { "ecall".to_string() }, - _ => todo!("{:x} opcode non géré pc : {:x}, value : {:x}", ins.opcode, pc, ins.value) // Change todo! to panic! in the future, I put todo! because there's a lot of opcode currently not implemented + _ => unreachable!("{:x} opcode non géré pc : {:x}, value : {:x}", ins.opcode, pc, ins.value) } } From 2f986da7ae746d499d5bbb12d5963a79735ed582 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Mon, 27 Mar 2023 22:20:29 +0200 Subject: [PATCH 02/26] fix save_processor_state, move test to thread_manager --- src/kernel/thread.rs | 4 ++-- src/kernel/thread_manager.rs | 30 ++++++++++++++++-------------- src/main.rs | 20 +------------------- 3 files changed, 19 insertions(+), 35 deletions(-) diff --git a/src/kernel/thread.rs b/src/kernel/thread.rs index 92f8986..05d94ad 100644 --- a/src/kernel/thread.rs +++ b/src/kernel/thread.rs @@ -16,7 +16,7 @@ macro_rules! get_new_thread { pub struct ThreadContext { pub int_registers: [i64; NUM_INT_REGS], pub float_registers: [f32; NUM_FP_REGS], - pub pc: i64, + pub pc: u64, } #[derive(PartialEq, Debug)] @@ -47,7 +47,7 @@ impl Thread { } } - pub fn init_thread_context(&mut self, initial_pc_reg: i64, initial_sp: i64, arg: i64) { + pub fn init_thread_context(&mut self, initial_pc_reg: u64, initial_sp: i64, arg: i64) { self.thread_context.pc = initial_pc_reg; self.thread_context.int_registers[10] = arg; self.thread_context.int_registers[STACK_REG] = initial_sp; diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs index 56db16b..3ffdad0 100644 --- a/src/kernel/thread_manager.rs +++ b/src/kernel/thread_manager.rs @@ -78,13 +78,15 @@ impl ThreadManager { } }, None => { - + self.thread_restore_processor_state(machine, Rc::clone(&next_thread)); + // next_thread.restore_simulator_state(); + self.set_g_current_thread(Some(next_thread)); } } } /// Start a thread, attaching it to a process - pub fn start_thread(&mut self, thread: Rc>, owner: Process, func_pc: i64, argument: i64) { + pub fn start_thread(&mut self, thread: Rc>, owner: Process, func_pc: u64, argument: i64) { let mut thread_m = thread.borrow_mut(); assert_eq!(thread_m.process, Option::None); thread_m.process = Option::Some(owner); @@ -153,6 +155,7 @@ impl ThreadManager { for i in 0..NUM_FP_REGS { t.thread_context.float_registers[i] = machine.read_fp_register(i); } + t.thread_context.pc = machine.pc; } /// Restore the CPU state of a user program on a context switch. @@ -161,6 +164,7 @@ impl ThreadManager { for i in 0..NUM_INT_REGS { machine.write_int_register(i, t.thread_context.int_registers[i]); } + machine.pc = t.thread_context.pc; } /// Currently running thread @@ -196,28 +200,26 @@ impl ThreadManager { mod test { use std::{rc::Rc, cell::RefCell}; - use crate::{simulator::machine::Machine, kernel::{system::System, thread::Thread, process::Process}}; + use crate::{simulator::{machine::Machine, loader}, kernel::{system::System, thread::Thread, process::Process}}; #[test] fn test_thread_context() { let mut machine = Machine::init_machine(); - let mut system = System::default(); + loader::load("../test.o", &mut machine, 0).expect("IO Error"); + let system = &mut System::default(); let thread1 = Thread::new("th1"); let thread1 = Rc::new(RefCell::new(thread1)); system.get_thread_manager().get_g_alive().push(Rc::clone(&thread1)); let owner = Process { num_thread: 0 }; - system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, thread1_func as i64, 0); - assert_eq!(thread1.borrow_mut().thread_context.pc, thread1_func as i64); + system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, 0x94 as u64, 0); + debug_assert_eq!(thread1.borrow_mut().thread_context.pc, 0x94 as u64); let to_run = system.get_thread_manager().find_next_to_run().unwrap(); - assert_eq!(to_run, Rc::clone(&thread1)); - assert!(system.get_thread_manager().get_g_alive().contains(&Rc::clone(&thread1))); + debug_assert_eq!(to_run, Rc::clone(&thread1)); + debug_assert!(system.get_thread_manager().get_g_alive().contains(&Rc::clone(&thread1))); system.get_thread_manager().switch_to(&mut machine, Rc::clone(&to_run)); - - println!("{:#?}", thread1.borrow_mut().thread_context); - } - - fn thread1_func() { - println!("Hello"); + debug_assert_eq!(system.get_thread_manager().g_current_thread, Option::Some(Rc::clone(&thread1))); + debug_assert_eq!(machine.pc, 0x94); + machine.run(); } } \ No newline at end of file diff --git a/src/main.rs b/src/main.rs index 2774e7b..874aa9a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -13,28 +13,10 @@ 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 std::{rc::Rc, cell::RefCell}; - use kernel::system::System; -use simulator::{machine::Machine, loader}; - -use crate::kernel::{thread::Thread, process::Process}; +use simulator::machine::Machine; fn main() { let mut machine = Machine::init_machine(); - loader::load("test.o", &mut machine, 0).expect("IO Error"); let system = &mut System::default(); - let thread1 = Thread::new("th1"); - let thread1 = Rc::new(RefCell::new(thread1)); - system.get_thread_manager().get_g_alive().push(Rc::clone(&thread1)); - let owner = Process { num_thread: 0 }; - system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, 0 as i64, 0); - debug_assert_eq!(thread1.borrow_mut().thread_context.pc, 0 as i64); - let to_run = system.get_thread_manager().find_next_to_run().unwrap(); - debug_assert_eq!(to_run, Rc::clone(&thread1)); - debug_assert!(system.get_thread_manager().get_g_alive().contains(&Rc::clone(&thread1))); - system.get_thread_manager().switch_to(&mut machine, Rc::clone(&to_run)); - - machine.run(); - } From c9792d1a1ae3f8fc51010f3c511195fb1e2bf7bf Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Mon, 27 Mar 2023 22:24:46 +0200 Subject: [PATCH 03/26] Ignore uncomplete test --- src/kernel/thread_manager.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs index 3ffdad0..4734b40 100644 --- a/src/kernel/thread_manager.rs +++ b/src/kernel/thread_manager.rs @@ -203,6 +203,7 @@ mod test { use crate::{simulator::{machine::Machine, loader}, kernel::{system::System, thread::Thread, process::Process}}; #[test] + #[ignore = "Pas encore terminé, contient des bugs"] fn test_thread_context() { let mut machine = Machine::init_machine(); loader::load("../test.o", &mut machine, 0).expect("IO Error"); From 7a32aa503c5c1411995d12e958bfa390aab82879 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Tue, 28 Mar 2023 17:54:05 +0200 Subject: [PATCH 04/26] Trying to make bin tests files --- test/Makefile | 11 ++++++++++- test/riscv_instructions/Makefile | 12 +++++++++++- test/riscv_instructions/boolean_logic/Makefile | 2 ++ test/userlib/Makefile | 5 ++++- 4 files changed, 27 insertions(+), 3 deletions(-) diff --git a/test/Makefile b/test/Makefile index ad2c039..c017d08 100644 --- a/test/Makefile +++ b/test/Makefile @@ -1,9 +1,15 @@ TOPDIR=. include $(TOPDIR)/Makefile.config + +all: dumps user_lib tests # # Main targets # + +build: user_lib + $(MAKE) build -C riscv_instructions/ + dumps: $(MAKE) dumps -C riscv_instructions/ mkdir -p ${TOPDIR}/target/dumps/ @@ -18,4 +24,7 @@ tests: user_lib find . -name '*.guac' -exec mv {} ${TOPDIR}/target/guac/ \; clean: - rm -rf $(TOPDIR)/target \ No newline at end of file + $(MAKE) clean -C userlib/ + $(MAKE) clean -C riscv_instructions/ + $(RM) -rf $(TOPDIR)/target + \ No newline at end of file diff --git a/test/riscv_instructions/Makefile b/test/riscv_instructions/Makefile index 22a1303..cabd3bb 100644 --- a/test/riscv_instructions/Makefile +++ b/test/riscv_instructions/Makefile @@ -1,3 +1,8 @@ +build: + make build -C boolean_logic/ +# make build -C jump_instructions/ +# make build -C simple_arithmetics/ + dumps: make dumps -C boolean_logic/ make dumps -C jump_instructions/ @@ -6,4 +11,9 @@ dumps: tests: make tests -C boolean_logic/ make tests -C jump_instructions/ - make tests -C simple_arithmetics/ \ No newline at end of file + make tests -C simple_arithmetics/ + +clean: + $(MAKE) clean -C boolean_logic/ + $(MAKE) clean -C jump_instructions/ + $(MAKE) clean -C simple_arithmetics/ \ No newline at end of file diff --git a/test/riscv_instructions/boolean_logic/Makefile b/test/riscv_instructions/boolean_logic/Makefile index 5f738e9..b1f6312 100644 --- a/test/riscv_instructions/boolean_logic/Makefile +++ b/test/riscv_instructions/boolean_logic/Makefile @@ -1,6 +1,8 @@ TOPDIR = ../.. include $(TOPDIR)/Makefile.tests +build: comparisons if switch + dumps: comparisons.dump if.dump switch.dump tests: comparisons.guac if.guac switch.guac diff --git a/test/userlib/Makefile b/test/userlib/Makefile index 903f3b5..6a5c70f 100644 --- a/test/userlib/Makefile +++ b/test/userlib/Makefile @@ -1,4 +1,7 @@ TOPDIR = ../ include $(TOPDIR)/Makefile.tests -default: sys.o libnachos.o \ No newline at end of file +default: sys.o libnachos.o + +clean: + $(RM) libnachos.o sys.o \ No newline at end of file From e170256c9b9f75cb144f213edda05af0f5c8b0f4 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Tue, 28 Mar 2023 19:35:24 +0200 Subject: [PATCH 05/26] Fix build makefiles --- test/Makefile.tests | 15 ++++++++++++--- test/riscv_instructions/.gitignore | 5 +++++ test/riscv_instructions/Makefile | 4 ++-- test/riscv_instructions/boolean_logic/Makefile | 12 +++++++++--- .../jump_instructions/Makefile | 15 ++++++++++++--- .../simple_arithmetics/Makefile | 16 +++++++++++++--- 6 files changed, 53 insertions(+), 14 deletions(-) create mode 100644 test/riscv_instructions/.gitignore diff --git a/test/Makefile.tests b/test/Makefile.tests index 681d31f..14dba3d 100644 --- a/test/Makefile.tests +++ b/test/Makefile.tests @@ -1,5 +1,11 @@ include $(TOPDIR)/Makefile.config + USERLIB = $(TOPDIR)/userlib + +AS = $(RISCV_AS) -c +GCC = $(RISCV_GCC) +LD = $(RISCV_LD) + INCPATH += -I$(TOPDIR) -I$(USERLIB) LDFLAGS = $(RISCV_LDFLAGS) -T $(USERLIB)/ldscript.lds ASFLAGS = $(RISCV_ASFLAGS) $(INCPATH) @@ -7,16 +13,16 @@ CFLAGS = $(RISCV_CFLAGS) $(INCPATH) # Rules %.o: %.s - $(RISCV_AS) $(ASFLAGS) -c $< + $(AS) $(ASFLAGS) -c $< %.o: %.c - $(RISCV_GCC) $(CFLAGS) -c $< + $(GCC) $(CFLAGS) -c $< %.dump: %.o $(RISCV_OBJCOPY) -j .text -O $(DUMP_FORMAT) $< $@ %.guac: %.o - $(RISCV_LD) $(LDFLAGS) $+ -o $@ + $(LD) $(LDFLAGS) $+ -o $@ # Dependencies .%.d: %.s @@ -31,6 +37,9 @@ CFLAGS = $(RISCV_CFLAGS) $(INCPATH) | sed '\''s/\($*\)\.o[ :]*/\1.o $@ : /g'\'' > $@; \ [ -s $@ ] || rm -f $@' +$(PROGRAMS): + $(LD) $(LDFLAGS) $+ -o $@ + # Targets #clean: # rm -rf *.o 2> /dev/null diff --git a/test/riscv_instructions/.gitignore b/test/riscv_instructions/.gitignore new file mode 100644 index 0000000..140fad6 --- /dev/null +++ b/test/riscv_instructions/.gitignore @@ -0,0 +1,5 @@ +* +!.gitignore +!*.c +!*.md +!**/Makefile \ No newline at end of file diff --git a/test/riscv_instructions/Makefile b/test/riscv_instructions/Makefile index cabd3bb..7c9a691 100644 --- a/test/riscv_instructions/Makefile +++ b/test/riscv_instructions/Makefile @@ -1,7 +1,7 @@ build: make build -C boolean_logic/ -# make build -C jump_instructions/ -# make build -C simple_arithmetics/ + make build -C jump_instructions/ + make build -C simple_arithmetics/ dumps: make dumps -C boolean_logic/ diff --git a/test/riscv_instructions/boolean_logic/Makefile b/test/riscv_instructions/boolean_logic/Makefile index b1f6312..e9b0a52 100644 --- a/test/riscv_instructions/boolean_logic/Makefile +++ b/test/riscv_instructions/boolean_logic/Makefile @@ -1,11 +1,17 @@ -TOPDIR = ../.. -include $(TOPDIR)/Makefile.tests -build: comparisons if switch +PROGRAMS = comparisons if switch + +build: $(PROGRAMS) dumps: comparisons.dump if.dump switch.dump tests: comparisons.guac if.guac switch.guac +TOPDIR = ../.. +include $(TOPDIR)/Makefile.tests + +clean: + $(RM) comparisons comparisons.o if if.o + # Dependances $(PROGRAMS): % : $(USERLIB)/sys.o $(USERLIB)/libnachos.o %.o \ No newline at end of file diff --git a/test/riscv_instructions/jump_instructions/Makefile b/test/riscv_instructions/jump_instructions/Makefile index ce69447..71ce3c0 100644 --- a/test/riscv_instructions/jump_instructions/Makefile +++ b/test/riscv_instructions/jump_instructions/Makefile @@ -1,6 +1,15 @@ -TOPDIR = ../.. -include $(TOPDIR)/Makefile.tests +PROGRAMS = jump ret + +build: $(PROGRAMS) dumps: jump.dump ret.dump -tests: jump.guac ret.guac \ No newline at end of file +tests: jump.guac ret.guac + +clean: + $(RM) jump jump.o ret ret.o + +TOPDIR = ../.. +include $(TOPDIR)/Makefile.tests + +$(PROGRAMS): % : $(USERLIB)/sys.o $(USERLIB)/libnachos.o %.o \ No newline at end of file diff --git a/test/riscv_instructions/simple_arithmetics/Makefile b/test/riscv_instructions/simple_arithmetics/Makefile index 623b297..9b42a4b 100644 --- a/test/riscv_instructions/simple_arithmetics/Makefile +++ b/test/riscv_instructions/simple_arithmetics/Makefile @@ -1,6 +1,16 @@ -TOPDIR = ../.. -include $(TOPDIR)/Makefile.tests + +PROGRAMS = unsigned_addition unsigned_division unsigned_multiplication unsigned_substraction + +build: $(PROGRAMS) dumps: unsigned_addition.dump unsigned_division.dump unsigned_multiplication.dump unsigned_substraction.dump -tests: unsigned_addition.guac unsigned_division.guac unsigned_multiplication.guac unsigned_substraction.guac \ No newline at end of file +tests: unsigned_addition.guac unsigned_division.guac unsigned_multiplication.guac unsigned_substraction.guac + +clean: + $(RM) unsigned_addition unsigned_addition.o unsigned_division unsigned_division.o unsigned_multiplication unsigned_multiplication.o unsigned_substraction unsigned_substraction.o + +TOPDIR = ../.. +include $(TOPDIR)/Makefile.tests + +$(PROGRAMS): % : $(USERLIB)/sys.o $(USERLIB)/libnachos.o %.o \ No newline at end of file From cfcdce750bffcde5b7660b3b1af490b132774b09 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Tue, 28 Mar 2023 19:47:42 +0200 Subject: [PATCH 06/26] Change filename in thread_manager::test-thread_context --- src/kernel/thread_manager.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs index 4734b40..07390a6 100644 --- a/src/kernel/thread_manager.rs +++ b/src/kernel/thread_manager.rs @@ -206,20 +206,21 @@ mod test { #[ignore = "Pas encore terminé, contient des bugs"] fn test_thread_context() { let mut machine = Machine::init_machine(); - loader::load("../test.o", &mut machine, 0).expect("IO Error"); + loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); + let start_pc = 0x4000; let system = &mut System::default(); let thread1 = Thread::new("th1"); let thread1 = Rc::new(RefCell::new(thread1)); system.get_thread_manager().get_g_alive().push(Rc::clone(&thread1)); let owner = Process { num_thread: 0 }; - system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, 0x94 as u64, 0); - debug_assert_eq!(thread1.borrow_mut().thread_context.pc, 0x94 as u64); + system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, start_pc, 0); + debug_assert_eq!(thread1.borrow_mut().thread_context.pc, start_pc); let to_run = system.get_thread_manager().find_next_to_run().unwrap(); debug_assert_eq!(to_run, Rc::clone(&thread1)); debug_assert!(system.get_thread_manager().get_g_alive().contains(&Rc::clone(&thread1))); system.get_thread_manager().switch_to(&mut machine, Rc::clone(&to_run)); debug_assert_eq!(system.get_thread_manager().g_current_thread, Option::Some(Rc::clone(&thread1))); - debug_assert_eq!(machine.pc, 0x94); + debug_assert_eq!(machine.pc, start_pc); machine.run(); } From 703c8e5448a92333b18b875178847259e3a17612 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Tue, 28 Mar 2023 21:26:58 +0200 Subject: [PATCH 07/26] Loader seem to work, be seem we have a problem with jalr --- src/kernel/thread_manager.rs | 9 +++++++-- src/simulator/loader.rs | 4 ++-- src/simulator/machine.rs | 2 +- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs index 07390a6..e88cf59 100644 --- a/src/kernel/thread_manager.rs +++ b/src/kernel/thread_manager.rs @@ -207,20 +207,25 @@ mod test { fn test_thread_context() { let mut machine = Machine::init_machine(); loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); - let start_pc = 0x4000; + let start_pc = 0x1000; let system = &mut System::default(); + let thread1 = Thread::new("th1"); let thread1 = Rc::new(RefCell::new(thread1)); system.get_thread_manager().get_g_alive().push(Rc::clone(&thread1)); + let owner = Process { num_thread: 0 }; - system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, start_pc, 0); + system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, start_pc, -1); debug_assert_eq!(thread1.borrow_mut().thread_context.pc, start_pc); + let to_run = system.get_thread_manager().find_next_to_run().unwrap(); debug_assert_eq!(to_run, Rc::clone(&thread1)); debug_assert!(system.get_thread_manager().get_g_alive().contains(&Rc::clone(&thread1))); + system.get_thread_manager().switch_to(&mut machine, Rc::clone(&to_run)); debug_assert_eq!(system.get_thread_manager().g_current_thread, Option::Some(Rc::clone(&thread1))); debug_assert_eq!(machine.pc, start_pc); + machine.run(); } diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 3404128..4ed2b64 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -59,7 +59,7 @@ pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result<(), for i in 0..instructions.len() { machine.write_memory(4, 4 * i + start_index, instructions[i] as u64); } - #[cfg(debug_assertions)] - println!("{:04x?}", instructions); // only print loaded program in debug build + // #[cfg(debug_assertions)] + // println!("{:04x?}", instructions); // only print loaded program in debug build Ok(()) } \ No newline at end of file diff --git a/src/simulator/machine.rs b/src/simulator/machine.rs index 0d9619b..1a8775a 100644 --- a/src/simulator/machine.rs +++ b/src/simulator/machine.rs @@ -240,7 +240,7 @@ impl Machine { let val = u32::from_be_bytes(val) as u64; let inst : Instruction = decode(val); self.print_status(); - println!("executing instruction : {:016x} at pc {:x}", val, self.pc); + println!("executing instruction : {:016x} at pc 0x{:x}", val, self.pc); println!("{}", print::print(decode(val), self.pc as i32)); let trace = Self::string_registers(self); self.registers_trace.push_str(format!("{}\n", trace).as_str()); From b4b7eb69c27414e944e77f3fd3bf34d9c0285433 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Fri, 31 Mar 2023 15:18:58 +0200 Subject: [PATCH 08/26] Add elf header parsing --- src/simulator/loader.rs | 198 ++++++++++++++++++++++++++++++++++------ 1 file changed, 168 insertions(+), 30 deletions(-) diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 4ed2b64..2f8a292 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -1,40 +1,11 @@ use crate::Machine; +use std::f32::consts::E; use std::fs; use std::io; use std::io::BufRead; use std::io::Read; - - - /// Load a file into a new machine - /// - /// `panic!` when size is not 1, 2, 4 or 8 - /// `panic!` when the text does not represents instructions in hexadecimal - /// - /// ### Parameters - /// - /// - **path** the path of the file to load - /// - **size** the number of bytes to write (1, 2, 4 or 8) -#[deprecated] -pub fn _load(path : &str, instruction_size: i32) -> Machine { - let file = fs::File::open(path).expect("Wrong filename"); - let reader = io::BufReader::new(file); - let mut machine = Machine::init_machine(); - - for (i,line) in reader.lines().enumerate() { - let res = u64::from_str_radix(&line.unwrap(), 16); - match res { - Ok(value) => { - Machine::write_memory(&mut machine, instruction_size, i*instruction_size as usize, value); - }, - _ => panic!() - } - } - println!("{:x}", Machine::read_memory(& mut machine, 4, 0)); - machine -} - /// load a 32-bits binary file into the machine /// /// ### Parameters @@ -62,4 +33,171 @@ pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result<(), // #[cfg(debug_assertions)] // println!("{:04x?}", instructions); // only print loaded program in debug build Ok(()) +} + +struct Loader { + bytes: Vec +} + +impl Loader { + + pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result { + let mut file = fs::File::open(path)?; + let mut instructions: Vec = Default::default(); + loop { + let mut buf: [u8; 1] = [0; 1]; + let res = file.read(&mut buf)?; + if res == 0 { + break; // eof + } else { + instructions.push(buf[0]); + } + } + // #[cfg(debug_assertions)] + // println!("{:04x?}", instructions); // only print loaded program in debug build + Ok(Self { bytes: instructions }) + } + + fn parse(&mut self) -> Result<(), ()> { + todo!(); + Ok(()) + } + + /// return true if the 4 first bytes constitude the elf magic number + fn is_elf(&self) -> bool { + self.bytes.get(0..4) == Option::Some(&[0x7f, 0x45, 0x4c, 0x46]) + } + + /// return true if big endian, false otherwise + fn check_endianess(&self) -> bool { + self.bytes.get(5) == Option::Some(&2) + } + + /// return true if file is 32 bits, false if 64 bits + fn is_32bits(&self) -> bool { + self.bytes.get(4) == Option::Some(&1) + } + + /// return the version of the elf file (should be 1) + /// Can be None if the file is smaller than 7 bytes -> the file is invalid + fn get_version(&self) -> Option { + self.bytes.get(6).copied() // work as primitives implements Copy + } + + /// return true if target abi of the binary file is System V, false otherwise + fn is_system_v_elf(&self) -> bool{ + self.bytes.get(7) == Option::Some(&0) + } + + /// return true if specified target instruction set architecture is RISCV + fn is_riscv_isa(&self) -> bool { + self.bytes.get(0x12) == Option::Some(&0xf7) + } + + /// memory address of the entry point from where the process starts its execution + fn get_entrypoint(&self, is_32bits: bool) -> Option { + if is_32bits { + self.get_address_point(0x18, true) + } else { + self.get_address_point(0x18, false) + } + } + + /// Memory address of the start of the program header table + fn get_program_header_table_location(&self, is_32bits: bool) -> Option { + if is_32bits { + self.get_address_point(0x1c, true) + } else { + self.get_address_point(0x20, false) + } + } + + /// Memory address of the start of the section header table + fn get_section_header_table_location(&self, is_32bits: bool) -> Option { + if is_32bits { + self.get_address_point(0x20, true) + } else { + self.get_address_point(0x28, false) + } + } + + /// Return the size of the header, normally, 0x40 for 64 bits bin and 0x34 for 32 bits + fn get_elf_header_size(&self, is_32bits: bool) -> Option { + let address = if is_32bits { 0x28 } else { 0x34 }; + self.get_u16_value(address) + } + + /// return the size of the program header + fn get_program_header_size(&self, is_32bits: bool) -> Option { + let address = if is_32bits { 0x2a } else { 0x34 }; + self.get_u16_value(address) + } + + /// return the number of entries in the program header + fn get_number_entries_program_header(&self, is_32bits: bool) -> Option { + let address = if is_32bits { 0x2c } else { 0x38 }; + self.get_u16_value(address) + } + + /// Return the size of the section header + fn get_section_header_size(&self, is_32bits: bool) -> Option { + let address = if is_32bits { 0x2e } else { 0x3a }; + self.get_u16_value(address) + } + + /// Return the number of entries in the section header + fn get_section_header_num_entries(&self, is_32bits: bool) -> Option { + let address = if is_32bits { 0x30 } else { 0x3c }; + self.get_u16_value(address) + } + + /// Return a u16 value, usually for the size or the number of entries inside a header + fn get_u16_value(&self, address: usize) -> Option { + let mut bytes: [u8; 2] = [0; 2]; + bytes[0] = self.bytes.get(address).copied()?; + bytes[1] = self.bytes.get(address + 1).copied()?; + Option::Some(u16::from_le_bytes(bytes)) + } + + /// return the memory address of something stored at address + /// Can return None if the file is smaller than adress + 4 (or 7 if 64 bits), in this case, the elf header is incorrect + fn get_address_point(&self, address: usize, is_32bits: bool) -> Option { + if is_32bits { + let mut bytes: [u8; 4] = [0; 4]; + bytes[0] = self.bytes.get(address).copied()?; + bytes[0] = self.bytes.get(address + 1).copied()?; + bytes[0] = self.bytes.get(address + 2).copied()?; + bytes[0] = self.bytes.get(address + 3).copied()?; + Option::Some(u32::from_le_bytes(bytes) as u64) + } else { + let mut bytes: [u8; 8] = [0; 8]; + bytes[0] = self.bytes.get(address).copied()?; + bytes[0] = self.bytes.get(address + 1).copied()?; + bytes[0] = self.bytes.get(address + 2).copied()?; + bytes[0] = self.bytes.get(address + 3).copied()?; + bytes[0] = self.bytes.get(address + 4).copied()?; + bytes[0] = self.bytes.get(address + 5).copied()?; + bytes[0] = self.bytes.get(address + 6).copied()?; + bytes[0] = self.bytes.get(address + 7).copied()?; + Option::Some(u64::from_le_bytes(bytes)) + } + } + + +} + +#[cfg(test)] +mod test { + use crate::simulator::{loader::Loader, machine::Machine}; + + + #[test] + fn test_parse() { + let mut machine = Machine::init_machine(); + let loader = Loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); + assert_eq!(true, loader.is_elf()); + assert_eq!(false, loader.is_32bits()); + assert_eq!(false, loader.check_endianess()); + } + } \ No newline at end of file From 453de4b704ea2dda6cc02cfa5f991e70e9945130 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Fri, 31 Mar 2023 15:34:04 +0200 Subject: [PATCH 09/26] Fix is_riscv_isa --- src/simulator/loader.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 2f8a292..904bc87 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -91,7 +91,7 @@ impl Loader { /// return true if specified target instruction set architecture is RISCV fn is_riscv_isa(&self) -> bool { - self.bytes.get(0x12) == Option::Some(&0xf7) + self.get_u16_value(0x12) == Option::Some(0xf3) } /// memory address of the entry point from where the process starts its execution @@ -198,6 +198,9 @@ mod test { assert_eq!(true, loader.is_elf()); assert_eq!(false, loader.is_32bits()); assert_eq!(false, loader.check_endianess()); + assert_eq!(true, loader.is_system_v_elf()); + assert_eq!(true, loader.is_riscv_isa()); + assert_eq!(Option::Some(1), loader.get_version()); } } \ No newline at end of file From 35c81e5269afa4f3203d1fe9f9dcf6f5c193a528 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Fri, 31 Mar 2023 19:34:45 +0200 Subject: [PATCH 10/26] Fix get_address_point --- src/simulator/loader.rs | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 904bc87..2eac03c 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -160,25 +160,25 @@ impl Loader { } /// return the memory address of something stored at address - /// Can return None if the file is smaller than adress + 4 (or 7 if 64 bits), in this case, the elf header is incorrect + /// Can return None if the file is smaller than adress + 3 (or 7 if 64 bits), in this case, the elf header is incorrect fn get_address_point(&self, address: usize, is_32bits: bool) -> Option { if is_32bits { let mut bytes: [u8; 4] = [0; 4]; bytes[0] = self.bytes.get(address).copied()?; - bytes[0] = self.bytes.get(address + 1).copied()?; - bytes[0] = self.bytes.get(address + 2).copied()?; - bytes[0] = self.bytes.get(address + 3).copied()?; + bytes[1] = self.bytes.get(address + 1).copied()?; + bytes[2] = self.bytes.get(address + 2).copied()?; + bytes[3] = self.bytes.get(address + 3).copied()?; Option::Some(u32::from_le_bytes(bytes) as u64) } else { let mut bytes: [u8; 8] = [0; 8]; bytes[0] = self.bytes.get(address).copied()?; - bytes[0] = self.bytes.get(address + 1).copied()?; - bytes[0] = self.bytes.get(address + 2).copied()?; - bytes[0] = self.bytes.get(address + 3).copied()?; - bytes[0] = self.bytes.get(address + 4).copied()?; - bytes[0] = self.bytes.get(address + 5).copied()?; - bytes[0] = self.bytes.get(address + 6).copied()?; - bytes[0] = self.bytes.get(address + 7).copied()?; + bytes[1] = self.bytes.get(address + 1).copied()?; + bytes[2] = self.bytes.get(address + 2).copied()?; + bytes[3] = self.bytes.get(address + 3).copied()?; + bytes[4] = self.bytes.get(address + 4).copied()?; + bytes[5] = self.bytes.get(address + 5).copied()?; + bytes[6] = self.bytes.get(address + 6).copied()?; + bytes[7] = self.bytes.get(address + 7).copied()?; Option::Some(u64::from_le_bytes(bytes)) } } @@ -201,6 +201,9 @@ mod test { assert_eq!(true, loader.is_system_v_elf()); assert_eq!(true, loader.is_riscv_isa()); assert_eq!(Option::Some(1), loader.get_version()); + assert_eq!(Option::Some(0x4000), loader.get_entrypoint(false)); + assert_eq!(Option::Some(64), loader.get_program_header_table_location(false)); + assert_eq!(Option::Some(18984), loader.get_section_header_table_location(false)); } } \ No newline at end of file From 443556b18a4753a99822cf1beb0661784a7be367 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Fri, 31 Mar 2023 21:49:26 +0200 Subject: [PATCH 11/26] Refactor loader into multiple struct --- src/simulator/loader.rs | 321 ++++++++++++++++++++++++++++------------ 1 file changed, 224 insertions(+), 97 deletions(-) diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 2eac03c..1a968c8 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -1,9 +1,6 @@ use crate::Machine; - -use std::f32::consts::E; +use std::fmt::Error; use std::fs; -use std::io; -use std::io::BufRead; use std::io::Read; /// load a 32-bits binary file into the machine @@ -35,154 +32,279 @@ pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result<(), Ok(()) } -struct Loader { - bytes: Vec +pub struct ElfHeader { + pub endianess: bool, + pub is_32bits: bool, + pub version: u8, + pub sys_v_abi: bool, + pub is_riscv_target: bool, + pub entrypoint: u64, + pub elf_header_size: u16, + pub program_header_location: u64, + pub program_header_entries: u16, + pub program_header_size: u16, + pub section_header_location: u64, + pub section_header_entries: u16, + pub section_header_size: u16, } -impl Loader { - - pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result { - let mut file = fs::File::open(path)?; - let mut instructions: Vec = Default::default(); - loop { - let mut buf: [u8; 1] = [0; 1]; - let res = file.read(&mut buf)?; - if res == 0 { - break; // eof - } else { - instructions.push(buf[0]); - } - } - // #[cfg(debug_assertions)] - // println!("{:04x?}", instructions); // only print loaded program in debug build - Ok(Self { bytes: instructions }) - } - - fn parse(&mut self) -> Result<(), ()> { - todo!(); - Ok(()) - } - +impl ElfHeader { + /// return true if the 4 first bytes constitude the elf magic number - fn is_elf(&self) -> bool { - self.bytes.get(0..4) == Option::Some(&[0x7f, 0x45, 0x4c, 0x46]) + fn is_elf(instructions: &Vec) -> bool { + instructions.get(0..4) == Option::Some(&[0x7f, 0x45, 0x4c, 0x46]) } /// return true if big endian, false otherwise - fn check_endianess(&self) -> bool { - self.bytes.get(5) == Option::Some(&2) + fn check_endianess(instructions: &Vec) -> bool { + instructions.get(5) == Option::Some(&2) } /// return true if file is 32 bits, false if 64 bits - fn is_32bits(&self) -> bool { - self.bytes.get(4) == Option::Some(&1) + fn is_32bits(instructions: &Vec) -> bool { + instructions.get(4) == Option::Some(&1) } /// return the version of the elf file (should be 1) /// Can be None if the file is smaller than 7 bytes -> the file is invalid - fn get_version(&self) -> Option { - self.bytes.get(6).copied() // work as primitives implements Copy + fn get_version(instructions: &Vec) -> Option { + instructions.get(6).copied() // work as primitives implements Copy } /// return true if target abi of the binary file is System V, false otherwise - fn is_system_v_elf(&self) -> bool{ - self.bytes.get(7) == Option::Some(&0) + fn is_system_v_elf(instructions: &Vec) -> bool { + instructions.get(7) == Option::Some(&0) } /// return true if specified target instruction set architecture is RISCV - fn is_riscv_isa(&self) -> bool { - self.get_u16_value(0x12) == Option::Some(0xf3) + fn is_riscv_isa(instructions: &Vec) -> bool { + Self::get_u16_value(instructions, 0x12) == Option::Some(0xf3) } /// memory address of the entry point from where the process starts its execution - fn get_entrypoint(&self, is_32bits: bool) -> Option { + fn get_entrypoint(instructions: &Vec, is_32bits: bool) -> Option { if is_32bits { - self.get_address_point(0x18, true) + Self::get_address_point(instructions, 0x18, true) } else { - self.get_address_point(0x18, false) + Self::get_address_point(instructions, 0x18, false) } } /// Memory address of the start of the program header table - fn get_program_header_table_location(&self, is_32bits: bool) -> Option { + fn get_program_header_table_location(instructions: &Vec, is_32bits: bool) -> Option { if is_32bits { - self.get_address_point(0x1c, true) + Self::get_address_point(instructions, 0x1c, true) } else { - self.get_address_point(0x20, false) + Self::get_address_point(instructions, 0x20, false) } } /// Memory address of the start of the section header table - fn get_section_header_table_location(&self, is_32bits: bool) -> Option { + fn get_section_header_table_location(instructions: &Vec, is_32bits: bool) -> Option { if is_32bits { - self.get_address_point(0x20, true) + Self::get_address_point(instructions, 0x20, true) } else { - self.get_address_point(0x28, false) + Self::get_address_point(instructions, 0x28, false) } } /// Return the size of the header, normally, 0x40 for 64 bits bin and 0x34 for 32 bits - fn get_elf_header_size(&self, is_32bits: bool) -> Option { + fn get_elf_header_size(instructions: &Vec, is_32bits: bool) -> Option { let address = if is_32bits { 0x28 } else { 0x34 }; - self.get_u16_value(address) + Self::get_u16_value(instructions, address) } - /// return the size of the program header - fn get_program_header_size(&self, is_32bits: bool) -> Option { - let address = if is_32bits { 0x2a } else { 0x34 }; - self.get_u16_value(address) + /// return the size of a program header table entry + fn get_program_header_size(instructions: &Vec, is_32bits: bool) -> Option { + let address = if is_32bits { 0x2a } else { 0x36 }; + Self::get_u16_value(instructions, address) } /// return the number of entries in the program header - fn get_number_entries_program_header(&self, is_32bits: bool) -> Option { + fn get_number_entries_program_header(instructions: &Vec, is_32bits: bool) -> Option { let address = if is_32bits { 0x2c } else { 0x38 }; - self.get_u16_value(address) + Self::get_u16_value(instructions, address) } - /// Return the size of the section header - fn get_section_header_size(&self, is_32bits: bool) -> Option { + /// Return the size of a section header table entry + fn get_section_header_size(instructions: &Vec, is_32bits: bool) -> Option { let address = if is_32bits { 0x2e } else { 0x3a }; - self.get_u16_value(address) + Self::get_u16_value(instructions, address) } /// Return the number of entries in the section header - fn get_section_header_num_entries(&self, is_32bits: bool) -> Option { + fn get_section_header_num_entries(instructions: &Vec, is_32bits: bool) -> Option { let address = if is_32bits { 0x30 } else { 0x3c }; - self.get_u16_value(address) - } - - /// Return a u16 value, usually for the size or the number of entries inside a header - fn get_u16_value(&self, address: usize) -> Option { - let mut bytes: [u8; 2] = [0; 2]; - bytes[0] = self.bytes.get(address).copied()?; - bytes[1] = self.bytes.get(address + 1).copied()?; - Option::Some(u16::from_le_bytes(bytes)) + Self::get_u16_value(instructions, address) } /// return the memory address of something stored at address /// Can return None if the file is smaller than adress + 3 (or 7 if 64 bits), in this case, the elf header is incorrect - fn get_address_point(&self, address: usize, is_32bits: bool) -> Option { + fn get_address_point(instructions: &Vec, address: usize, is_32bits: bool) -> Option { if is_32bits { let mut bytes: [u8; 4] = [0; 4]; - bytes[0] = self.bytes.get(address).copied()?; - bytes[1] = self.bytes.get(address + 1).copied()?; - bytes[2] = self.bytes.get(address + 2).copied()?; - bytes[3] = self.bytes.get(address + 3).copied()?; + bytes[0] = instructions.get(address).copied()?; + bytes[1] = instructions.get(address + 1).copied()?; + bytes[2] = instructions.get(address + 2).copied()?; + bytes[3] = instructions.get(address + 3).copied()?; Option::Some(u32::from_le_bytes(bytes) as u64) } else { let mut bytes: [u8; 8] = [0; 8]; - bytes[0] = self.bytes.get(address).copied()?; - bytes[1] = self.bytes.get(address + 1).copied()?; - bytes[2] = self.bytes.get(address + 2).copied()?; - bytes[3] = self.bytes.get(address + 3).copied()?; - bytes[4] = self.bytes.get(address + 4).copied()?; - bytes[5] = self.bytes.get(address + 5).copied()?; - bytes[6] = self.bytes.get(address + 6).copied()?; - bytes[7] = self.bytes.get(address + 7).copied()?; + bytes[0] = instructions.get(address).copied()?; + bytes[1] = instructions.get(address + 1).copied()?; + bytes[2] = instructions.get(address + 2).copied()?; + bytes[3] = instructions.get(address + 3).copied()?; + bytes[4] = instructions.get(address + 4).copied()?; + bytes[5] = instructions.get(address + 5).copied()?; + bytes[6] = instructions.get(address + 6).copied()?; + bytes[7] = instructions.get(address + 7).copied()?; Option::Some(u64::from_le_bytes(bytes)) } } + /// Return a u16 value, usually for the size or the number of entries inside a header + fn get_u16_value(instructions: &Vec, address: usize) -> Option { + let mut bytes: [u8; 2] = [0; 2]; + bytes[0] = instructions.get(address).copied()?; + bytes[1] = instructions.get(address + 1).copied()?; + Option::Some(u16::from_le_bytes(bytes)) + } + +} + +impl TryFrom<&Vec> for ElfHeader { + type Error = (); + + fn try_from(instructions: &Vec) -> Result { + if Self::is_elf(instructions) { + let format = Self::is_32bits(instructions); + let endianess = Self::check_endianess(instructions); + let version = Self::get_version(instructions).ok_or(())?; + let is_sys_v_abi = Self::is_system_v_elf(instructions); + let is_rv_target = Self::is_riscv_isa(instructions); + let entrypoint = Self::get_entrypoint(instructions, format).ok_or(())?; + let elf_header_size = Self::get_elf_header_size(instructions, format).ok_or(())?; + let program_header_location = Self::get_program_header_table_location(instructions, format).ok_or(())?; + let program_header_entries = Self::get_number_entries_program_header(instructions, format).ok_or(())? ; + let program_header_size = Self::get_program_header_size(instructions, format).ok_or(())?; + let section_header_location = Self::get_section_header_table_location(instructions, format).ok_or(())?; + let section_header_entries = Self::get_section_header_num_entries(instructions, format).ok_or(())?; + let section_header_size = Self::get_section_header_size(instructions, format).ok_or(())?; + Ok(ElfHeader { + endianess, + is_32bits: format, + version, + sys_v_abi: is_sys_v_abi, + is_riscv_target: is_rv_target, + entrypoint, + elf_header_size, + program_header_location, + program_header_entries, + program_header_size, + section_header_location, + section_header_entries, + section_header_size + }) + } else { + Err(()) + } + } +} + +pub struct SectionHeader { + pub name_offset: u32, + pub header_type: u32, + pub attribute: u64, + pub virt_addr: u64, + pub image_offset: u64, + pub section_size: u64, + pub section_index: u32, + pub section_info: u32, + pub required_align: u64, + pub entry_size: u64 +} + +impl TryFrom<(&Vec, u64)> for SectionHeader { + type Error = (); + + fn try_from(value: (&Vec, u64)) -> Result { + todo!() + } +} + +pub struct Loader { + bytes: Vec, + pub elf_header: ElfHeader, + pub sections: Vec +} + +pub enum LoaderError { + IOError(std::io::Error), + ParsingError +} + +impl Loader { + + pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result { + let file = fs::File::open(path); + match file { + Ok(mut file) => { + let mut instructions: Vec = Default::default(); + loop { + let mut buf: [u8; 1] = [0; 1]; + let res = file.read(&mut buf); + match res { + Ok(res) => { + if res == 0 { + break; // eof + } else { + instructions.push(buf[0]); + } + }, + Err(err) => { + return Err(LoaderError::IOError(err)) + } + } + + } + let elf_header = match ElfHeader::try_from(&instructions) { + Ok(header) => { + header + }, + Err(_) => { + return Err(LoaderError::ParsingError); + } + }; + let section_header = match Self::parse_section_header(&instructions, elf_header.is_32bits, elf_header.section_header_location, elf_header.section_header_entries, elf_header.section_header_size) { + Ok(header) => { + header + }, + Err(_) => { + return Err(LoaderError::ParsingError); + } + }; + // #[cfg(debug_assertions)] + // println!("{:04x?}", instructions); // only print loaded program in debug build + return Ok(Self { bytes: instructions, elf_header, sections: section_header }); + }, + Err(err) => { + return Err(LoaderError::IOError(err)); + } + }; + } + + fn parse_section_header(instructions: &Vec, is_32bits: bool, header_location: u64, num_of_entries: u16, entry_size: u16) -> Result, ()> { + let mut sections: Vec = Default::default(); + for i in 0..num_of_entries as u64 { + sections.push(Self::parse_section_entry(instructions, is_32bits, header_location + i * entry_size as u64)?); + } + Ok(sections) + } + + fn parse_section_entry(instructions: &Vec, is_32bits: bool, location: u64) -> Result { + SectionHeader::try_from((instructions, location)) + } + } @@ -192,18 +314,23 @@ mod test { #[test] - fn test_parse() { - let mut machine = Machine::init_machine(); - let loader = Loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); - assert_eq!(true, loader.is_elf()); - assert_eq!(false, loader.is_32bits()); - assert_eq!(false, loader.check_endianess()); - assert_eq!(true, loader.is_system_v_elf()); - assert_eq!(true, loader.is_riscv_isa()); - assert_eq!(Option::Some(1), loader.get_version()); - assert_eq!(Option::Some(0x4000), loader.get_entrypoint(false)); - assert_eq!(Option::Some(64), loader.get_program_header_table_location(false)); - assert_eq!(Option::Some(18984), loader.get_section_header_table_location(false)); + fn test_parse_elf() { + // let mut machine = Machine::init_machine(); + // let loader = Loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); + // assert_eq!(true, loader.is_elf()); + // assert_eq!(false, loader.is_32bits()); + // assert_eq!(false, loader.check_endianess()); + // assert_eq!(true, loader.is_system_v_elf()); + // assert_eq!(true, loader.is_riscv_isa()); + // assert_eq!(Option::Some(1), loader.get_version()); + // assert_eq!(Option::Some(0x4000), loader.get_entrypoint(false)); + // assert_eq!(Option::Some(64), loader.get_elf_header_size(false)); + // assert_eq!(Option::Some(64), loader.get_program_header_table_location(false)); + // assert_eq!(Option::Some(18984), loader.get_section_header_table_location(false)); + // assert_eq!(Option::Some(56), loader.get_program_header_size(false)); + // assert_eq!(Option::Some(64), loader.get_section_header_size(false)); + // assert_eq!(Option::Some(4), loader.get_number_entries_program_header(false)); + // assert_eq!(Option::Some(9), loader.get_section_header_num_entries(false)); } } \ No newline at end of file From 0a744f0f94f0250cdd74f2ca29c8c054b97b4e95 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Fri, 31 Mar 2023 22:48:02 +0200 Subject: [PATCH 12/26] Add parsing of sections --- src/simulator/loader.rs | 174 ++++++++++++++++++++++++++++------------ 1 file changed, 123 insertions(+), 51 deletions(-) diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 1a968c8..cf77546 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -84,27 +84,27 @@ impl ElfHeader { /// memory address of the entry point from where the process starts its execution fn get_entrypoint(instructions: &Vec, is_32bits: bool) -> Option { if is_32bits { - Self::get_address_point(instructions, 0x18, true) + get_address_point(instructions, 0x18, true) } else { - Self::get_address_point(instructions, 0x18, false) + get_address_point(instructions, 0x18, false) } } /// Memory address of the start of the program header table fn get_program_header_table_location(instructions: &Vec, is_32bits: bool) -> Option { if is_32bits { - Self::get_address_point(instructions, 0x1c, true) + get_address_point(instructions, 0x1c, true) } else { - Self::get_address_point(instructions, 0x20, false) + get_address_point(instructions, 0x20, false) } } /// Memory address of the start of the section header table fn get_section_header_table_location(instructions: &Vec, is_32bits: bool) -> Option { if is_32bits { - Self::get_address_point(instructions, 0x20, true) + get_address_point(instructions, 0x20, true) } else { - Self::get_address_point(instructions, 0x28, false) + get_address_point(instructions, 0x28, false) } } @@ -138,30 +138,6 @@ impl ElfHeader { Self::get_u16_value(instructions, address) } - /// return the memory address of something stored at address - /// Can return None if the file is smaller than adress + 3 (or 7 if 64 bits), in this case, the elf header is incorrect - fn get_address_point(instructions: &Vec, address: usize, is_32bits: bool) -> Option { - if is_32bits { - let mut bytes: [u8; 4] = [0; 4]; - bytes[0] = instructions.get(address).copied()?; - bytes[1] = instructions.get(address + 1).copied()?; - bytes[2] = instructions.get(address + 2).copied()?; - bytes[3] = instructions.get(address + 3).copied()?; - Option::Some(u32::from_le_bytes(bytes) as u64) - } else { - let mut bytes: [u8; 8] = [0; 8]; - bytes[0] = instructions.get(address).copied()?; - bytes[1] = instructions.get(address + 1).copied()?; - bytes[2] = instructions.get(address + 2).copied()?; - bytes[3] = instructions.get(address + 3).copied()?; - bytes[4] = instructions.get(address + 4).copied()?; - bytes[5] = instructions.get(address + 5).copied()?; - bytes[6] = instructions.get(address + 6).copied()?; - bytes[7] = instructions.get(address + 7).copied()?; - Option::Some(u64::from_le_bytes(bytes)) - } - } - /// Return a u16 value, usually for the size or the number of entries inside a header fn get_u16_value(instructions: &Vec, address: usize) -> Option { let mut bytes: [u8; 2] = [0; 2]; @@ -211,6 +187,7 @@ impl TryFrom<&Vec> for ElfHeader { } } +#[derive(Debug)] pub struct SectionHeader { pub name_offset: u32, pub header_type: u32, @@ -218,17 +195,86 @@ pub struct SectionHeader { pub virt_addr: u64, pub image_offset: u64, pub section_size: u64, - pub section_index: u32, + pub section_link: u32, pub section_info: u32, pub required_align: u64, pub entry_size: u64 } -impl TryFrom<(&Vec, u64)> for SectionHeader { +impl SectionHeader { + + fn get_name_offset(instructions: &Vec, address: usize) -> Option { + get_address_point(instructions, address, true).map(|v| { v as u32 }) + // set true to return a u32 + } + + fn get_header_type(instructions: &Vec, address: usize) -> Option { + get_address_point(instructions, address + 0x4, true).map(|v| { v as u32 }) + } + + fn get_attribute(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + 0x8, is_32bits) + } + + fn get_virtual_address(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + if is_32bits { 0x0C } else { 0x10 }, is_32bits) + } + + fn get_image_offset(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + if is_32bits { 0x10 } else { 0x18 }, is_32bits) + } + + fn get_section_size(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + if is_32bits { 0x14 } else { 0x20 }, is_32bits) + } + + fn get_section_link(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + if is_32bits { 0x18 } else { 0x28 }, false).map(|v| { v as u32 }) + } + + fn get_section_info(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + if is_32bits { 0x1C } else { 0x2C }, false).map(|v| { v as u32 }) + } + + fn get_required_align(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + if is_32bits { 0x20 } else { 0x30 }, is_32bits) + } + + fn get_entry_size(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + get_address_point(instructions, address + if is_32bits { 0x24 } else { 0x38 }, is_32bits) + } + +} + +impl TryFrom<(&Vec, u64, bool)> for SectionHeader { type Error = (); - fn try_from(value: (&Vec, u64)) -> Result { - todo!() + fn try_from(value: (&Vec, u64, bool)) -> Result { + let instructions = value.0; + let address = value.1 as usize; + let is_32bits = value.2; + + let name_offset = Self::get_name_offset(instructions, address).ok_or(())?; + let header_type = Self::get_header_type(instructions, address).ok_or(())?; + let attribute = Self::get_attribute(instructions, address, is_32bits).ok_or(())?; + let virt_addr = Self::get_virtual_address(instructions, address, is_32bits).ok_or(())?; + let image_offset = Self::get_image_offset(instructions, address, is_32bits).ok_or(())?; + let section_size = Self::get_section_size(instructions, address, is_32bits).ok_or(())?; + let section_link = Self::get_section_link(instructions, address, is_32bits).ok_or(())?; + let section_info = Self::get_section_info(instructions, address, is_32bits).ok_or(())?; + let required_align = Self::get_required_align(instructions, address, is_32bits).ok_or(())?; + let entry_size = Self::get_entry_size(instructions, address, is_32bits).ok_or(())?; + Ok(Self { name_offset, + header_type, + attribute, + virt_addr, + image_offset, + section_size, + section_link, + section_info, + required_align, + entry_size + }) } } @@ -238,6 +284,7 @@ pub struct Loader { pub sections: Vec } +#[derive(Debug)] pub enum LoaderError { IOError(std::io::Error), ParsingError @@ -302,35 +349,60 @@ impl Loader { } fn parse_section_entry(instructions: &Vec, is_32bits: bool, location: u64) -> Result { - SectionHeader::try_from((instructions, location)) + SectionHeader::try_from((instructions, location, is_32bits)) } } +/// return the memory address of something stored at address +/// Can return None if the file is smaller than adress + 3 (or 7 if 64 bits), in this case, the elf header is incorrect +fn get_address_point(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + if is_32bits { + let mut bytes: [u8; 4] = [0; 4]; + bytes[0] = instructions.get(address).copied()?; + bytes[1] = instructions.get(address + 1).copied()?; + bytes[2] = instructions.get(address + 2).copied()?; + bytes[3] = instructions.get(address + 3).copied()?; + Option::Some(u32::from_le_bytes(bytes) as u64) + } else { + let mut bytes: [u8; 8] = [0; 8]; + bytes[0] = instructions.get(address).copied()?; + bytes[1] = instructions.get(address + 1).copied()?; + bytes[2] = instructions.get(address + 2).copied()?; + bytes[3] = instructions.get(address + 3).copied()?; + bytes[4] = instructions.get(address + 4).copied()?; + bytes[5] = instructions.get(address + 5).copied()?; + bytes[6] = instructions.get(address + 6).copied()?; + bytes[7] = instructions.get(address + 7).copied()?; + Option::Some(u64::from_le_bytes(bytes)) + } +} + #[cfg(test)] mod test { use crate::simulator::{loader::Loader, machine::Machine}; #[test] + #[ignore = "CI gitlab a modifié"] fn test_parse_elf() { - // let mut machine = Machine::init_machine(); - // let loader = Loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); - // assert_eq!(true, loader.is_elf()); - // assert_eq!(false, loader.is_32bits()); - // assert_eq!(false, loader.check_endianess()); - // assert_eq!(true, loader.is_system_v_elf()); - // assert_eq!(true, loader.is_riscv_isa()); - // assert_eq!(Option::Some(1), loader.get_version()); - // assert_eq!(Option::Some(0x4000), loader.get_entrypoint(false)); - // assert_eq!(Option::Some(64), loader.get_elf_header_size(false)); - // assert_eq!(Option::Some(64), loader.get_program_header_table_location(false)); - // assert_eq!(Option::Some(18984), loader.get_section_header_table_location(false)); - // assert_eq!(Option::Some(56), loader.get_program_header_size(false)); - // assert_eq!(Option::Some(64), loader.get_section_header_size(false)); - // assert_eq!(Option::Some(4), loader.get_number_entries_program_header(false)); - // assert_eq!(Option::Some(9), loader.get_section_header_num_entries(false)); + let mut machine = Machine::init_machine(); + let loader = Loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); + assert_eq!(false, loader.elf_header.is_32bits); + assert_eq!(false, loader.elf_header.endianess); + assert_eq!(true, loader.elf_header.sys_v_abi); + assert_eq!(true, loader.elf_header.is_riscv_target); + assert_eq!(1, loader.elf_header.version); + assert_eq!(0x4000, loader.elf_header.entrypoint); + assert_eq!(64, loader.elf_header.elf_header_size); + assert_eq!(64, loader.elf_header.program_header_location); + assert_eq!(18984, loader.elf_header.section_header_location); + assert_eq!(56, loader.elf_header.program_header_size); + assert_eq!(64, loader.elf_header.section_header_size); + assert_eq!(4, loader.elf_header.program_header_entries); + assert_eq!(9, loader.elf_header.section_header_entries); + println!("{:#x?}", loader.sections); } } \ No newline at end of file From 8239079130c174e029a02df4b335b709bdfa93e0 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Sat, 1 Apr 2023 00:14:09 +0200 Subject: [PATCH 13/26] Add section flag support, loader now ready to run binary files --- src/kernel/thread_manager.rs | 4 +-- src/simulator/loader.rs | 53 ++++++++++++++++++++++++++++++++---- src/simulator/machine.rs | 4 +-- 3 files changed, 51 insertions(+), 10 deletions(-) diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs index e88cf59..acecc5b 100644 --- a/src/kernel/thread_manager.rs +++ b/src/kernel/thread_manager.rs @@ -206,8 +206,8 @@ mod test { #[ignore = "Pas encore terminé, contient des bugs"] fn test_thread_context() { let mut machine = Machine::init_machine(); - loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); - let start_pc = 0x1000; + let loader = loader::Loader::new("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); + let start_pc = loader.elf_header.entrypoint; let system = &mut System::default(); let thread1 = Thread::new("th1"); diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index cf77546..9bbe132 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -187,11 +187,22 @@ impl TryFrom<&Vec> for ElfHeader { } } + +pub enum FlagValue { + ShfWrite = 0x1, + ShfAlloc = 0x2, + ShfExecinstr = 0x4, + ShfMerge = 0x10, + ShfStrings = 0x20, + ShfInfoLink = 0x40, + ShfLinkOrder = 0x80, + // There is others but are unrelevant (I think) +} #[derive(Debug)] pub struct SectionHeader { pub name_offset: u32, pub header_type: u32, - pub attribute: u64, + pub flags: u64, pub virt_addr: u64, pub image_offset: u64, pub section_size: u64, @@ -203,6 +214,11 @@ pub struct SectionHeader { impl SectionHeader { + /// return true if flag of this section contains / have `key`, false otherwise + pub fn does_flag_contains_key(&self, key: FlagValue) -> bool { + self.flags & key as u64 != 0 + } + fn get_name_offset(instructions: &Vec, address: usize) -> Option { get_address_point(instructions, address, true).map(|v| { v as u32 }) // set true to return a u32 @@ -212,7 +228,7 @@ impl SectionHeader { get_address_point(instructions, address + 0x4, true).map(|v| { v as u32 }) } - fn get_attribute(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + fn get_flags(instructions: &Vec, address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + 0x8, is_32bits) } @@ -256,7 +272,7 @@ impl TryFrom<(&Vec, u64, bool)> for SectionHeader { let name_offset = Self::get_name_offset(instructions, address).ok_or(())?; let header_type = Self::get_header_type(instructions, address).ok_or(())?; - let attribute = Self::get_attribute(instructions, address, is_32bits).ok_or(())?; + let attribute = Self::get_flags(instructions, address, is_32bits).ok_or(())?; let virt_addr = Self::get_virtual_address(instructions, address, is_32bits).ok_or(())?; let image_offset = Self::get_image_offset(instructions, address, is_32bits).ok_or(())?; let section_size = Self::get_section_size(instructions, address, is_32bits).ok_or(())?; @@ -266,7 +282,7 @@ impl TryFrom<(&Vec, u64, bool)> for SectionHeader { let entry_size = Self::get_entry_size(instructions, address, is_32bits).ok_or(())?; Ok(Self { name_offset, header_type, - attribute, + flags: attribute, virt_addr, image_offset, section_size, @@ -292,7 +308,31 @@ pub enum LoaderError { impl Loader { - pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result { + pub fn new(path: &str, machine: &mut Machine, start_index: usize) -> Result { + let loader = Self::load_and_parse(path)?; + loader.load_into_machine(machine, start_index)?; + Ok(loader) + } + + fn load_into_machine(&self, machine: &mut Machine, start_index: usize) -> Result{ + for i in 0..self.sections.len() { + let section = &self.sections[i]; + if section.does_flag_contains_key(FlagValue::ShfAlloc) { + // Can allocate to machine memory + for j in (0..section.section_size as usize).step_by(4) { + let mut buf: [u8; 4] = [0; 4]; + for k in 0..4 { + buf[k] = self.bytes.get(section.image_offset as usize + j + k).copied().ok_or(LoaderError::ParsingError)?; + } + machine.write_memory(4, start_index + section.virt_addr as usize + j, u32::from_le_bytes(buf) as u64); + } + } + } + let last = self.sections.last().ok_or(LoaderError::ParsingError)?; + Ok(start_index as u64 + last.virt_addr + last.section_size) + } + + fn load_and_parse(path: &str) -> Result { let file = fs::File::open(path); match file { Ok(mut file) => { @@ -388,7 +428,8 @@ mod test { #[ignore = "CI gitlab a modifié"] fn test_parse_elf() { let mut machine = Machine::init_machine(); - let loader = Loader::load("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); + let loader = Loader::load_and_parse("./test/riscv_instructions/simple_arithmetics/unsigned_addition").expect("IO Error"); + loader.load_into_machine(&mut machine, 0).expect("Parsing error"); assert_eq!(false, loader.elf_header.is_32bits); assert_eq!(false, loader.elf_header.endianess); assert_eq!(true, loader.elf_header.sys_v_abi); diff --git a/src/simulator/machine.rs b/src/simulator/machine.rs index 1a8775a..1ab9087 100644 --- a/src/simulator/machine.rs +++ b/src/simulator/machine.rs @@ -188,9 +188,9 @@ impl Machine { } println!("________________SP________________"); let sp_index = self.int_reg.get_reg(2); - for i in 0..5 { + /* for i in 0..5 { println!("SP+{:<2} : {:16x}", i*8, self.read_memory(8, (sp_index + i*8) as usize)); - } + } */ println!("##################################"); } From 8c844c3e5cbea14c0e320ac21457df602d10b678 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Sun, 2 Apr 2023 19:55:06 +0200 Subject: [PATCH 14/26] Initialize sp value for each threads (temporary workaround) --- src/kernel/thread.rs | 4 ++-- src/kernel/thread_manager.rs | 8 ++++---- src/simulator/loader.rs | 13 +++++++------ 3 files changed, 13 insertions(+), 12 deletions(-) diff --git a/src/kernel/thread.rs b/src/kernel/thread.rs index 05d94ad..4b856c2 100644 --- a/src/kernel/thread.rs +++ b/src/kernel/thread.rs @@ -47,10 +47,10 @@ impl Thread { } } - pub fn init_thread_context(&mut self, initial_pc_reg: u64, initial_sp: i64, arg: i64) { + pub fn init_thread_context(&mut self, initial_pc_reg: u64, initial_sp: u64, arg: i64) { self.thread_context.pc = initial_pc_reg; self.thread_context.int_registers[10] = arg; - self.thread_context.int_registers[STACK_REG] = initial_sp; + self.thread_context.int_registers[STACK_REG] = initial_sp as i64; } pub fn init_simulator_context(&self, base_stack_addr: [i8; SIMULATORSTACKSIZE]) { diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs index acecc5b..e5b0e14 100644 --- a/src/kernel/thread_manager.rs +++ b/src/kernel/thread_manager.rs @@ -86,11 +86,11 @@ impl ThreadManager { } /// Start a thread, attaching it to a process - pub fn start_thread(&mut self, thread: Rc>, owner: Process, func_pc: u64, argument: i64) { + pub fn start_thread(&mut self, thread: Rc>, owner: Process, func_pc: u64, sp_loc: u64, argument: i64) { let mut thread_m = thread.borrow_mut(); assert_eq!(thread_m.process, Option::None); thread_m.process = Option::Some(owner); - let ptr = 0; // todo addrspace + let ptr = sp_loc; // todo addrspace thread_m.init_thread_context(func_pc, ptr, argument); let base_stack_addr: [i8; SIMULATORSTACKSIZE] = [0; SIMULATORSTACKSIZE]; // todo AllocBoundedArray thread_m.init_simulator_context(base_stack_addr); @@ -206,7 +206,7 @@ mod test { #[ignore = "Pas encore terminé, contient des bugs"] fn test_thread_context() { let mut machine = Machine::init_machine(); - let loader = loader::Loader::new("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); + let (loader, ptr) = loader::Loader::new("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error"); let start_pc = loader.elf_header.entrypoint; let system = &mut System::default(); @@ -215,7 +215,7 @@ mod test { system.get_thread_manager().get_g_alive().push(Rc::clone(&thread1)); let owner = Process { num_thread: 0 }; - system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, start_pc, -1); + system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, start_pc, ptr, -1); debug_assert_eq!(thread1.borrow_mut().thread_context.pc, start_pc); let to_run = system.get_thread_manager().find_next_to_run().unwrap(); diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 9bbe132..a3350e9 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -308,16 +308,18 @@ pub enum LoaderError { impl Loader { - pub fn new(path: &str, machine: &mut Machine, start_index: usize) -> Result { + pub fn new(path: &str, machine: &mut Machine, start_index: usize) -> Result<(Self, u64), LoaderError> { let loader = Self::load_and_parse(path)?; - loader.load_into_machine(machine, start_index)?; - Ok(loader) + let end_alloc = loader.load_into_machine(machine, start_index)?; + Ok((loader, end_alloc)) } - fn load_into_machine(&self, machine: &mut Machine, start_index: usize) -> Result{ + fn load_into_machine(&self, machine: &mut Machine, start_index: usize) -> Result { + let mut end_index = 0; for i in 0..self.sections.len() { let section = &self.sections[i]; if section.does_flag_contains_key(FlagValue::ShfAlloc) { + end_index = section.virt_addr + section.section_size; // Can allocate to machine memory for j in (0..section.section_size as usize).step_by(4) { let mut buf: [u8; 4] = [0; 4]; @@ -328,8 +330,7 @@ impl Loader { } } } - let last = self.sections.last().ok_or(LoaderError::ParsingError)?; - Ok(start_index as u64 + last.virt_addr + last.section_size) + Ok(start_index as u64 + end_index) } fn load_and_parse(path: &str) -> Result { From 025ede6080b3e92a876cbdea058cbe28f5c6b99c Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Mon, 3 Apr 2023 15:26:55 +0200 Subject: [PATCH 15/26] Add some comments --- src/simulator/loader.rs | 194 +++++++++++++++++++++++++++++++++------- 1 file changed, 164 insertions(+), 30 deletions(-) diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index a3350e9..3952013 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -1,5 +1,4 @@ use crate::Machine; -use std::fmt::Error; use std::fs; use std::io::Read; @@ -24,65 +23,117 @@ pub fn load(path: &str, machine: &mut Machine, start_index: usize) -> Result<(), instructions.push(u32::from_le_bytes(buf)); } } - for i in 0..instructions.len() { - machine.write_memory(4, 4 * i + start_index, instructions[i] as u64); + for (i, inst) in instructions.iter().enumerate() { + machine.write_memory(4, 4 * i + start_index, inst.to_owned() as u64); } // #[cfg(debug_assertions)] // println!("{:04x?}", instructions); // only print loaded program in debug build Ok(()) } +/// The elf header defines principes aspects of the binary files, it's place at the start of the file +/// see for more informations pub struct ElfHeader { + /// Defines whether the file is big or little endian + /// true correspond to big endian, false otherwise + /// + /// Offset: 0x05, size: 1 byte pub endianess: bool, + /// Defines whether the file is 32 bits or 64 bits + /// + /// Offset: 0x04, size: 1 byte pub is_32bits: bool, + /// Version of the elf file, current version is 1 + /// + /// Offset: 0x06, size: 1 byte pub version: u8, + /// Identifies the target ABI. + /// + /// In this implementation: Defines if the target abi is system V compliant + /// + /// Offset: 0x07, size: 1 byte pub sys_v_abi: bool, + /// Identifies target ISA, 0xF3 correspond to RISC-V + /// + /// In this implementatio, true if target isa is RISC-V, false otherwise + /// + /// Offset: 0x12, size: 2 bytes pub is_riscv_target: bool, + /// Memory address of the entry point from w) -> bool { + fn is_elf(instructions: &[u8]) -> bool { instructions.get(0..4) == Option::Some(&[0x7f, 0x45, 0x4c, 0x46]) } /// return true if big endian, false otherwise - fn check_endianess(instructions: &Vec) -> bool { + fn check_endianess(instructions: &[u8]) -> bool { instructions.get(5) == Option::Some(&2) } /// return true if file is 32 bits, false if 64 bits - fn is_32bits(instructions: &Vec) -> bool { + fn is_32bits(instructions: &[u8]) -> bool { instructions.get(4) == Option::Some(&1) } /// return the version of the elf file (should be 1) /// Can be None if the file is smaller than 7 bytes -> the file is invalid - fn get_version(instructions: &Vec) -> Option { + fn get_version(instructions: &[u8]) -> Option { instructions.get(6).copied() // work as primitives implements Copy } /// return true if target abi of the binary file is System V, false otherwise - fn is_system_v_elf(instructions: &Vec) -> bool { + fn is_system_v_elf(instructions: &[u8]) -> bool { instructions.get(7) == Option::Some(&0) } /// return true if specified target instruction set architecture is RISCV - fn is_riscv_isa(instructions: &Vec) -> bool { + fn is_riscv_isa(instructions: &[u8]) -> bool { Self::get_u16_value(instructions, 0x12) == Option::Some(0xf3) } /// memory address of the entry point from where the process starts its execution - fn get_entrypoint(instructions: &Vec, is_32bits: bool) -> Option { + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_entrypoint(instructions: &[u8], is_32bits: bool) -> Option { if is_32bits { get_address_point(instructions, 0x18, true) } else { @@ -91,7 +142,12 @@ impl ElfHeader { } /// Memory address of the start of the program header table - fn get_program_header_table_location(instructions: &Vec, is_32bits: bool) -> Option { + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_program_header_table_location(instructions: &[u8], is_32bits: bool) -> Option { if is_32bits { get_address_point(instructions, 0x1c, true) } else { @@ -99,8 +155,13 @@ impl ElfHeader { } } - /// Memory address of the start of the section header table - fn get_section_header_table_location(instructions: &Vec, is_32bits: bool) -> Option { + /// Memory address of the start of the section header table + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_section_header_table_location(instructions: &[u8], is_32bits: bool) -> Option { if is_32bits { get_address_point(instructions, 0x20, true) } else { @@ -109,37 +170,69 @@ impl ElfHeader { } /// Return the size of the header, normally, 0x40 for 64 bits bin and 0x34 for 32 bits - fn get_elf_header_size(instructions: &Vec, is_32bits: bool) -> Option { + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_elf_header_size(instructions: &[u8], is_32bits: bool) -> Option { let address = if is_32bits { 0x28 } else { 0x34 }; Self::get_u16_value(instructions, address) } /// return the size of a program header table entry - fn get_program_header_size(instructions: &Vec, is_32bits: bool) -> Option { + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_program_header_size(instructions: &[u8], is_32bits: bool) -> Option { let address = if is_32bits { 0x2a } else { 0x36 }; Self::get_u16_value(instructions, address) } /// return the number of entries in the program header - fn get_number_entries_program_header(instructions: &Vec, is_32bits: bool) -> Option { + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_number_entries_program_header(instructions: &[u8], is_32bits: bool) -> Option { let address = if is_32bits { 0x2c } else { 0x38 }; Self::get_u16_value(instructions, address) } /// Return the size of a section header table entry - fn get_section_header_size(instructions: &Vec, is_32bits: bool) -> Option { + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_section_header_size(instructions: &[u8], is_32bits: bool) -> Option { let address = if is_32bits { 0x2e } else { 0x3a }; Self::get_u16_value(instructions, address) } /// Return the number of entries in the section header - fn get_section_header_num_entries(instructions: &Vec, is_32bits: bool) -> Option { + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **is_32bits** defines whether the binary file is 32 bits or 64 bits + fn get_section_header_num_entries(instructions: &[u8], is_32bits: bool) -> Option { let address = if is_32bits { 0x30 } else { 0x3c }; Self::get_u16_value(instructions, address) } /// Return a u16 value, usually for the size or the number of entries inside a header - fn get_u16_value(instructions: &Vec, address: usize) -> Option { + /// + /// This method retrieve 2 bytes and concatenate them assuming the file is little endian + /// + /// ## Arguments: + /// + /// **instructions** List of bytes of the loaded binary file + /// **address** Position of the first byte + fn get_u16_value(instructions: &[u8], address: usize) -> Option { let mut bytes: [u8; 2] = [0; 2]; bytes[0] = instructions.get(address).copied()?; bytes[1] = instructions.get(address + 1).copied()?; @@ -188,27 +281,63 @@ impl TryFrom<&Vec> for ElfHeader { } +/// Flag of a section, a section can have multiples flags by adding the values +#[allow(clippy::enum_variant_names)] +#[allow(dead_code)] pub enum FlagValue { + /// The section is writable ShfWrite = 0x1, + /// The section need to be allocate/occupe memory during execution ShfAlloc = 0x2, + /// The section need to be executable ShfExecinstr = 0x4, + /// Section might ber merged ShfMerge = 0x10, + /// Contain null-terminated (\0) strings ShfStrings = 0x20, - ShfInfoLink = 0x40, - ShfLinkOrder = 0x80, // There is others but are unrelevant (I think) } + +/// Section header entry, contains useful informations for each sections of the binary file +/// +/// see #[derive(Debug)] pub struct SectionHeader { + /// Offset to a string in .shstrtab section that represent the name of this section + /// + /// Offset: 0x0, size: 4 bytes pub name_offset: u32, + /// Identify the type of this header + /// + /// Offset: 0x4, size: 4 bytes pub header_type: u32, + /// Identify the atributes of this section + /// + /// see `Self::does_flag_contains_key(self, FlagValue)` + /// + /// Offset: 0x8, size: 4 (32 bits) or 8 (64 bits) bytes pub flags: u64, + /// Virtual address of the section in memory if section is loaded, 0x0 otherwise + /// + /// Offset: 0x0C (32 bits) or 0x10 (64 bits), size: 4 (32 bits) or 8 (64 bits) bytes pub virt_addr: u64, + /// Offset of the section in the file image (binary file) + /// + /// Offset: 0x10 (32 bits) or 0x18 (64 bits), size: 4 (32 bits) or 8 (64 bits) bytes pub image_offset: u64, + /// Size of the section in the file image, may be 0 + /// + /// Offset: 0x14 (32 bits) or 0x20 (64 bits), size: 4 (32 bits) or 8 (64 bits) bytes pub section_size: u64, pub section_link: u32, pub section_info: u32, + /// Contain the required alignment of the section, must be a power of 2 + /// + /// Offset: 0x20 (32 bits) or 0x30 (64 bits), size: 4 (32 bits) or 8 (64 bits) bytes pub required_align: u64, + /// Contain the size of each entry, for sections that contain fixed size entries, otherwise 0 + /// + /// Offset: 0x24 (32 bits) or 0x38 (64 bits), size: 4 (32 bits) or 8 (64 bits) bytes pub entry_size: u64 } @@ -219,20 +348,25 @@ impl SectionHeader { self.flags & key as u64 != 0 } - fn get_name_offset(instructions: &Vec, address: usize) -> Option { + /// Return the offset to a string in .shstrtab that represents the name of this section + fn get_name_offset(instructions: &[u8], address: usize) -> Option { get_address_point(instructions, address, true).map(|v| { v as u32 }) // set true to return a u32 } - fn get_header_type(instructions: &Vec, address: usize) -> Option { + /// Return the type of header of the section + fn get_header_type(instructions: &[u8], address: usize) -> Option { get_address_point(instructions, address + 0x4, true).map(|v| { v as u32 }) } - fn get_flags(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + /// Return the flags of the section, can hold multiples values, see [`FlagValue`] + fn get_flags(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + 0x8, is_32bits) } - fn get_virtual_address(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + + /// Return the virtual address of the section in memory if the sectino is loaded(see section flag), otherwise 0 + fn get_virtual_address(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + if is_32bits { 0x0C } else { 0x10 }, is_32bits) } @@ -398,7 +532,7 @@ impl Loader { /// return the memory address of something stored at address /// Can return None if the file is smaller than adress + 3 (or 7 if 64 bits), in this case, the elf header is incorrect -fn get_address_point(instructions: &Vec, address: usize, is_32bits: bool) -> Option { +fn get_address_point(instructions: &[u8], address: usize, is_32bits: bool) -> Option { if is_32bits { let mut bytes: [u8; 4] = [0; 4]; bytes[0] = instructions.get(address).copied()?; @@ -431,10 +565,10 @@ mod test { let mut machine = Machine::init_machine(); let loader = Loader::load_and_parse("./test/riscv_instructions/simple_arithmetics/unsigned_addition").expect("IO Error"); loader.load_into_machine(&mut machine, 0).expect("Parsing error"); - assert_eq!(false, loader.elf_header.is_32bits); - assert_eq!(false, loader.elf_header.endianess); - assert_eq!(true, loader.elf_header.sys_v_abi); - assert_eq!(true, loader.elf_header.is_riscv_target); + assert!(!loader.elf_header.is_32bits); + assert!(!loader.elf_header.endianess); + assert!(loader.elf_header.sys_v_abi); + assert!(loader.elf_header.is_riscv_target); assert_eq!(1, loader.elf_header.version); assert_eq!(0x4000, loader.elf_header.entrypoint); assert_eq!(64, loader.elf_header.elf_header_size); From aef8d219d025c8833629532a6afeb1dfd4391245 Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Mon, 3 Apr 2023 15:58:57 +0200 Subject: [PATCH 16/26] Continue to add comments --- src/simulator/loader.rs | 106 +++++++++++++++++++++++++++++----------- 1 file changed, 77 insertions(+), 29 deletions(-) diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 3952013..82be5e7 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -129,7 +129,7 @@ impl ElfHeader { /// memory address of the entry point from where the process starts its execution /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -143,7 +143,7 @@ impl ElfHeader { /// Memory address of the start of the program header table /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -157,7 +157,7 @@ impl ElfHeader { /// Memory address of the start of the section header table /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -171,7 +171,7 @@ impl ElfHeader { /// Return the size of the header, normally, 0x40 for 64 bits bin and 0x34 for 32 bits /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -182,7 +182,7 @@ impl ElfHeader { /// return the size of a program header table entry /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -193,7 +193,7 @@ impl ElfHeader { /// return the number of entries in the program header /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -204,7 +204,7 @@ impl ElfHeader { /// Return the size of a section header table entry /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -215,7 +215,7 @@ impl ElfHeader { /// Return the number of entries in the section header /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **is_32bits** defines whether the binary file is 32 bits or 64 bits @@ -228,7 +228,7 @@ impl ElfHeader { /// /// This method retrieve 2 bytes and concatenate them assuming the file is little endian /// - /// ## Arguments: + /// ## Paramters: /// /// **instructions** List of bytes of the loaded binary file /// **address** Position of the first byte @@ -370,36 +370,40 @@ impl SectionHeader { get_address_point(instructions, address + if is_32bits { 0x0C } else { 0x10 }, is_32bits) } - fn get_image_offset(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + /// Return the offset of the section in the file image (binary file) + fn get_image_offset(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + if is_32bits { 0x10 } else { 0x18 }, is_32bits) } - fn get_section_size(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + /// Return the size of the section in the file image (binary file), may be 0 + fn get_section_size(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + if is_32bits { 0x14 } else { 0x20 }, is_32bits) } - fn get_section_link(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + fn get_section_link(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + if is_32bits { 0x18 } else { 0x28 }, false).map(|v| { v as u32 }) } - fn get_section_info(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + fn get_section_info(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + if is_32bits { 0x1C } else { 0x2C }, false).map(|v| { v as u32 }) } - fn get_required_align(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + /// Return the required alignment of the section, must be a power of 2 + fn get_required_align(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + if is_32bits { 0x20 } else { 0x30 }, is_32bits) } - fn get_entry_size(instructions: &Vec, address: usize, is_32bits: bool) -> Option { + /// Contain the size of each entry for sections that contain fixed-size entries, otherwise 0 + fn get_entry_size(instructions: &[u8], address: usize, is_32bits: bool) -> Option { get_address_point(instructions, address + if is_32bits { 0x24 } else { 0x38 }, is_32bits) } } -impl TryFrom<(&Vec, u64, bool)> for SectionHeader { +impl TryFrom<(&[u8], u64, bool)> for SectionHeader { type Error = (); - fn try_from(value: (&Vec, u64, bool)) -> Result { + fn try_from(value: (&[u8], u64, bool)) -> Result { let instructions = value.0; let address = value.1 as usize; let is_32bits = value.2; @@ -428,26 +432,47 @@ impl TryFrom<(&Vec, u64, bool)> for SectionHeader { } } -pub struct Loader { - bytes: Vec, - pub elf_header: ElfHeader, - pub sections: Vec -} - +/// Error enum for [`Loader`] #[derive(Debug)] pub enum LoaderError { + /// Correspond to std IO error IOError(std::io::Error), + /// Others errors ParsingError } +/// Global structure of the loader, one instance per loaded files +pub struct Loader { + /// List of bytes inside the binary file + bytes: Vec, + /// Elf header, see [`ElfHeader`] for more informations + pub elf_header: ElfHeader, + /// Section header table entries, see [`SectionHeader`] for more informations + pub sections: Vec +} impl Loader { + /// # Loader constructor + /// + /// Load the binary file given in parameter, parse it and load inside the machine memory + /// return the loader instance and the location of the end of the last a allocated section in memory + /// + /// ## Parameters + /// + /// **path**: location of the binary file on disk + /// **machine**: well, the risc-v simulator + /// **start_index**: The position at which you want to start to allocate the program pub fn new(path: &str, machine: &mut Machine, start_index: usize) -> Result<(Self, u64), LoaderError> { let loader = Self::load_and_parse(path)?; let end_alloc = loader.load_into_machine(machine, start_index)?; Ok((loader, end_alloc)) } + /// Try to load the binary file in memory after it been parsed + /// + /// Binary file is loaded according to sections order and rules, see [`SectionHeader`] + /// + /// Return the location of the end of the last a allocated section in memory fn load_into_machine(&self, machine: &mut Machine, start_index: usize) -> Result { let mut end_index = 0; for i in 0..self.sections.len() { @@ -457,7 +482,8 @@ impl Loader { // Can allocate to machine memory for j in (0..section.section_size as usize).step_by(4) { let mut buf: [u8; 4] = [0; 4]; - for k in 0..4 { + #[allow(clippy::needless_range_loop)] + for k in 0..buf.len() { buf[k] = self.bytes.get(section.image_offset as usize + j + k).copied().ok_or(LoaderError::ParsingError)?; } machine.write_memory(4, start_index + section.virt_addr as usize + j, u32::from_le_bytes(buf) as u64); @@ -467,6 +493,8 @@ impl Loader { Ok(start_index as u64 + end_index) } + /// Load the binary file and store it inside an array and try to parse it, + /// useful for a lot of thing like to know which sections to allocate memory and where fn load_and_parse(path: &str) -> Result { let file = fs::File::open(path); match file { @@ -507,15 +535,27 @@ impl Loader { }; // #[cfg(debug_assertions)] // println!("{:04x?}", instructions); // only print loaded program in debug build - return Ok(Self { bytes: instructions, elf_header, sections: section_header }); + Ok(Self { bytes: instructions, elf_header, sections: section_header }) }, Err(err) => { - return Err(LoaderError::IOError(err)); + Err(LoaderError::IOError(err)) } - }; + } } - fn parse_section_header(instructions: &Vec, is_32bits: bool, header_location: u64, num_of_entries: u16, entry_size: u16) -> Result, ()> { + + /// Try to parse sections header table + /// + /// Create one instance of [`SectionHeader`] for each entry and store it inside an array + /// + /// ## Parameters + /// + /// **instructions**: array of bytes of the binary file + /// **is_32bits**: contain whether the binary file is 32 bits or 64 bits + /// **header_location**: represent the position of the first entry of the header + /// **num_of_entries**: defines the number of section header entries + /// **entry_size**: Defines the size of an entry (each entry have the exact same size), value vary depending of if this binary file is 32 or 64 bits + fn parse_section_header(instructions: &[u8], is_32bits: bool, header_location: u64, num_of_entries: u16, entry_size: u16) -> Result, ()> { let mut sections: Vec = Default::default(); for i in 0..num_of_entries as u64 { sections.push(Self::parse_section_entry(instructions, is_32bits, header_location + i * entry_size as u64)?); @@ -523,7 +563,15 @@ impl Loader { Ok(sections) } - fn parse_section_entry(instructions: &Vec, is_32bits: bool, location: u64) -> Result { + + /// Parse one entry of the section header + /// + /// ## Parameters: + /// + /// **instructions**: array of bytes of the binary file + /// **is_32bits**: contain whether the binary file is 32 bits or 64 bits + /// **location**: represent the position of the entry on the file image + fn parse_section_entry(instructions: &[u8], is_32bits: bool, location: u64) -> Result { SectionHeader::try_from((instructions, location, is_32bits)) } From fc3237c4ad1ad63b028767e897406f3025b1667c Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Tue, 4 Apr 2023 11:50:29 +0200 Subject: [PATCH 17/26] Adding test to loader, update ci (hope it work) --- .gitlab-ci.yml | 2 ++ src/simulator/loader.rs | 22 ++++++++++++++++++++-- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 0746ff7..e6b0a50 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -7,6 +7,8 @@ stages: unit-test-job: stage: test script: + - echo "Compiling c files" + - cd test && make build && cd .. - echo "Running unit tests..." - cargo test diff --git a/src/simulator/loader.rs b/src/simulator/loader.rs index 82be5e7..7185c29 100644 --- a/src/simulator/loader.rs +++ b/src/simulator/loader.rs @@ -602,13 +602,15 @@ fn get_address_point(instructions: &[u8], address: usize, is_32bits: bool) -> Op } } +/// Tests has been made for C program compiled with RISC-V GCC 12.2.0, target: riscv64-unknown-elf +/// +/// It may not pass in the future if future gcc version modify order of the binary or something else #[cfg(test)] mod test { - use crate::simulator::{loader::Loader, machine::Machine}; + use crate::simulator::{loader::{Loader, SectionHeader}, machine::Machine}; #[test] - #[ignore = "CI gitlab a modifié"] fn test_parse_elf() { let mut machine = Machine::init_machine(); let loader = Loader::load_and_parse("./test/riscv_instructions/simple_arithmetics/unsigned_addition").expect("IO Error"); @@ -629,4 +631,20 @@ mod test { println!("{:#x?}", loader.sections); } + #[test] + fn test_parse_section() { + let mut machine = Machine::init_machine(); + let loader = Loader::load_and_parse("./test/riscv_instructions/simple_arithmetics/unsigned_addition").expect("IO Error"); + loader.load_into_machine(&mut machine, 0).expect("Parsing error"); + assert_eq!(9, loader.sections.len()); + let n = loader.sections.iter().filter(|p| { p.does_flag_contains_key(crate::simulator::loader::FlagValue::ShfAlloc)}).collect::>().len(); + assert_eq!(3, n); + assert_eq!(loader.sections[1].virt_addr, 0x4000); + assert_eq!(loader.sections[1].image_offset, 0x1000); + assert!(loader.sections[1].does_flag_contains_key(crate::simulator::loader::FlagValue::ShfAlloc)); + assert_eq!(loader.sections[2].virt_addr, 0x400_000); + assert_eq!(loader.sections[2].image_offset, 0x2000); + assert!(loader.sections[2].does_flag_contains_key(crate::simulator::loader::FlagValue::ShfAlloc)); + } + } \ No newline at end of file From 2eee88c1d353acbb1ec2912351070259d5d21737 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 14:35:33 +0200 Subject: [PATCH 18/26] Update .gitlab-ci.yml --- .gitlab-ci.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e6b0a50..0bf305f 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,5 +1,9 @@ default: image: rust:1.68 + before_script: + - wget https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz + - tar xzf https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz + - mv riscv64-unknown-elf /opt/riscv stages: - test From 025c62b243c7314ec44e7cc3a1c5ad30f3665961 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 14:36:40 +0200 Subject: [PATCH 19/26] i am stupid i reckon --- .gitlab-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 0bf305f..994f1d8 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -2,7 +2,7 @@ default: image: rust:1.68 before_script: - wget https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz - - tar xzf https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz + - tar xzf riscv64-cross-compiler-multilib.tar.gz - mv riscv64-unknown-elf /opt/riscv stages: From aa5ba94842f8f7cb8c410037ffda698a68420fe8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 14:41:14 +0200 Subject: [PATCH 20/26] Calmly asked wget to shut the fuck up --- .gitlab-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 994f1d8..dfc8b5c 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,7 +1,7 @@ default: image: rust:1.68 before_script: - - wget https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz + - wget -q https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz - tar xzf riscv64-cross-compiler-multilib.tar.gz - mv riscv64-unknown-elf /opt/riscv From 72743ded87d3fa2b7a3f7e43ff47d6d9641d5f7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 14:54:28 +0200 Subject: [PATCH 21/26] fixed compiler not being copied to /opt/riscv --- .gitlab-ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index dfc8b5c..6bbde90 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -2,8 +2,8 @@ default: image: rust:1.68 before_script: - wget -q https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz - - tar xzf riscv64-cross-compiler-multilib.tar.gz - - mv riscv64-unknown-elf /opt/riscv + - mkdir /opt/riscv + - tar xzf riscv64-cross-compiler-multilib.tar.gz -C /opt/riscv stages: - test From aeb5cacb4e8fb00a04e5d816411416388ca07cd6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 15:02:35 +0200 Subject: [PATCH 22/26] Added glibc dependency --- .gitlab-ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 6bbde90..d2d304c 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -4,6 +4,7 @@ default: - wget -q https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz - mkdir /opt/riscv - tar xzf riscv64-cross-compiler-multilib.tar.gz -C /opt/riscv + - sudo apt install glibc stages: - test From 63c2f62a19e8a572d3c9011a64d69c69c032bb72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 15:03:47 +0200 Subject: [PATCH 23/26] Ok no sudo i get it --- .gitlab-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index d2d304c..4072fd0 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -4,7 +4,7 @@ default: - wget -q https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz - mkdir /opt/riscv - tar xzf riscv64-cross-compiler-multilib.tar.gz -C /opt/riscv - - sudo apt install glibc + - apt install glibc stages: - test From f3f88e9beec9e2b2cad3a67947cda32bb8a324f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 15:05:45 +0200 Subject: [PATCH 24/26] UPDATING APT --- .gitlab-ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 4072fd0..b7f3679 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -4,6 +4,7 @@ default: - wget -q https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz - mkdir /opt/riscv - tar xzf riscv64-cross-compiler-multilib.tar.gz -C /opt/riscv + - apt update - apt install glibc stages: From 64c8104668906ea8b4b96146dbe6461dc90bb9b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 15:09:52 +0200 Subject: [PATCH 25/26] Correct package name --- .gitlab-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index b7f3679..b18d1af 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -5,7 +5,7 @@ default: - mkdir /opt/riscv - tar xzf riscv64-cross-compiler-multilib.tar.gz -C /opt/riscv - apt update - - apt install glibc + - apt install libc6 stages: - test From 2b10da1d7d1f273b422cacc99d8b02a3fb0a274b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Autin?= Date: Tue, 4 Apr 2023 15:16:41 +0200 Subject: [PATCH 26/26] Updated to debian bookworm --- .gitlab-ci.yml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index b18d1af..7f4eb4f 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,11 +1,9 @@ default: - image: rust:1.68 + image: rust:1.68-bookworm before_script: - wget -q https://cloud.cuwott.fr/s/9fyrejDxMdNRQNn/download/riscv64-cross-compiler-multilib.tar.gz - mkdir /opt/riscv - tar xzf riscv64-cross-compiler-multilib.tar.gz -C /opt/riscv - - apt update - - apt install libc6 stages: - test