diff --git a/Cargo.toml b/Cargo.toml index b4ddc9208..4de8bbffd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ members = [ "xous-rs", "examples/shell", ] -default-members = ["kernel", "loader", "xous-rs", "examples/shell"] +default-members = ["xous-rs", "examples/shell"] [profile.release] codegen-units = 1 # 1 better optimizations diff --git a/README.md b/README.md index b4461e106..6b18facb3 100644 --- a/README.md +++ b/README.md @@ -22,16 +22,21 @@ $ cargo build --target riscv32imac-unknown-none-elf $ cd kernel $ cargo build -p kernel --target riscv32imac-unknown-none-elf $ cd .. +$ cd loader +$ cargo build -p loader --target riscv32imac-unknown-none-elf +$ cd .. ``` This will compile all runtime packages for `riscv32imac-unknown-none-elf`. +Note that the kernel and loader must currently be built separately, due +to the fact that they have custom linker scripts. These need to be packaged into a loadable binary. You can generate such a binary by running the following: ```sh $ cargo run -p tools --bin create-image -- \ - --csv emulation/csr.csv + --csv emulation/csr.csv \ --kernel target/riscv32imac-unknown-none-elf/debug/kernel \ --init target/riscv32imac-unknown-none-elf/debug/shell \ target/args.bin diff --git a/docs/arguments.md b/docs/arguments.md index 1bacf6c4e..9a1674b33 100644 --- a/docs/arguments.md +++ b/docs/arguments.md @@ -86,8 +86,8 @@ following values: The fields `size`, `flags`, and `offset` occupy 64 bits (8 bytes). The `OFFSET` is a full 32-bit address. The `SIZE` field is in units of -words, however as it is only 24 bits, meaning the largest section size -is `2^26` bytes. +bytes, however as it is only 24 bits, meaning the largest section size +is `2^24` bytes. The `FLAGS` field contains the following four bits. Any region may be marked NOCOPY, however RISC-V does not allow regions to be marked diff --git a/emulation/boot.resc b/emulation/boot.resc index eb0aef675..8eca04e1a 100644 --- a/emulation/boot.resc +++ b/emulation/boot.resc @@ -1,5 +1,9 @@ # Boot Renode Script (boot.resc) +# Add this script's path to the global path, so +# we can include files relative to ourselves. +path add $ORIGIN + using sysbus mach create diff --git a/kernel/src/arch/riscv/mem.rs b/kernel/src/arch/riscv/mem.rs index 8c7f855cd..a4bb7086f 100644 --- a/kernel/src/arch/riscv/mem.rs +++ b/kernel/src/arch/riscv/mem.rs @@ -119,11 +119,11 @@ impl MemoryMapping { if *l1_entry == 0 { continue; } - let superpage_addr = i as u32 * (1 << 22); + let _superpage_addr = i as u32 * (1 << 22); println!( " {:4} Superpage for {:08x} @ {:08x} (flags: {:?})", i, - superpage_addr, + _superpage_addr, (*l1_entry >> 10) << 12, MMUFlags::from_bits(l1_entry & 0xff).unwrap() ); @@ -141,11 +141,11 @@ impl MemoryMapping { if *l0_entry & 1 == 0 { continue; } - let page_addr = j as u32 * (1 << 12); + let _page_addr = j as u32 * (1 << 12); println!( " {:4} {:08x} -> {:08x} (flags: {:?})", j, - superpage_addr + page_addr, + _superpage_addr + _page_addr, (*l0_entry >> 10) << 12, MMUFlags::from_bits(l0_entry & 0xff).unwrap() ); diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index 4017ad4a2..a05edbc3d 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -6,7 +6,7 @@ use core::slice; use core::str; pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE}; -use xous::{MemoryAddress, MemoryFlags, PID}; +use xous::{MemoryFlags, PID}; #[derive(Debug)] enum ClaimOrRelease { @@ -167,10 +167,10 @@ impl MemoryManager { // First, we build a &[u8]... let name_bytes = self.ram_name.to_le_bytes(); // ... and then convert that slice into a string slice - let ram_name = str::from_utf8_unchecked(&name_bytes); + let _ram_name = str::from_utf8_unchecked(&name_bytes); println!( " Region {} ({:08x}) {:08x} - {:08x} {} bytes:", - ram_name, + _ram_name, self.ram_name, self.ram_start, self.ram_start + self.ram_size, @@ -232,6 +232,18 @@ impl MemoryManager { Err(xous::Error::OutOfMemory) } + // Find a virtual address in the current process that is big enough + // to fit `size` bytes. + fn find_virtual_address(&mut self, virt_ptr: *mut usize, size: usize) -> Result { + // If we were supplied a perfectly good address, return that. + if virt_ptr as usize != 0 { + return Ok(virt_ptr as usize); + } + + // let mm = SystemServicesHandle::get().current_process(); + Err(xous::Error::BadAddress) + } + /// Reserve the given range without actually allocating memory. /// That way we can overpromise on stack size and heap size without /// needing to actually have pages to back it. @@ -241,7 +253,10 @@ impl MemoryManager { size: usize, flags: MemoryFlags, ) -> Result { - let virt = virt_ptr as usize; + + // If no address was specified, pick the next address that fits + // in the "default" range + let virt = self.find_virtual_address(virt_ptr, size)?; if virt & 0xfff != 0 { return Err(xous::Error::BadAlignment); @@ -253,6 +268,7 @@ impl MemoryManager { let mut mm = MemoryMapping::current(); for virt in (virt..(virt + size)).step_by(PAGE_SIZE) { + // FIXME: Un-reserve addresses if we encounter an error here mm.reserve_address(self, virt, flags)?; } Ok(xous::Result::MemoryRange(virt_ptr as *mut u8, size)) @@ -270,48 +286,47 @@ impl MemoryManager { virt_ptr: *mut usize, size: usize, flags: MemoryFlags, - ) -> Result { + ) -> Result { let ss = SystemServicesHandle::get(); let pid = ss.current_pid(); let phys = phys_ptr as usize; - let virt = virt_ptr as usize; + let virt = self.find_virtual_address(virt_ptr, size)?; - if phys == 0 || virt == 0 { - println!("Attempted to map a range without specifying phys or virt"); - return Err(xous::Error::BadAddress); + // If no physical address is specified, give the user the next available pages + if phys == 0 { + return self.reserve_range(virt as *mut usize, size, flags); } - let mut error = None; - for phys in (phys..(phys + size)).step_by(PAGE_SIZE) { - if let Err(err) = self.claim_page(phys as *mut usize, pid) { - error = Some(err); - break; - } - } - if let Some(err) = error { - for phys in (phys..(phys + size)).step_by(PAGE_SIZE) { - self.release_page(phys as *mut usize, pid).ok(); - } - return Err(err); - } - - for phys in (phys..(phys + size)).step_by(PAGE_SIZE) { - if let Err(e) = - crate::arch::mem::map_page_inner(self, pid, phys as usize, virt as usize, flags) - { - error = Some(e); - break; + // 1. Attempt to claim all physical pages in the range + for claim_phys in (phys..(phys + size)).step_by(PAGE_SIZE) { + if let Err(err) = self.claim_page(claim_phys as *mut usize, pid) { + // If we were unable to claim one or more pages, release everything and return + for rel_phys in (phys..claim_phys).step_by(PAGE_SIZE) { + self.release_page(rel_phys as *mut usize, pid).ok(); + } + return Err(err); } } - if let Some(err) = error { - for phys in (phys..(phys + size)).step_by(PAGE_SIZE) { - self.release_page(phys as *mut usize, pid).ok(); + // Actually perform the map. At this stage, every physical page should be owned by us. + for offset in (0..size).step_by(PAGE_SIZE) { + if let Err(e) = crate::arch::mem::map_page_inner( + self, + pid, + offset + phys as usize, + offset + virt as usize, + flags, + ) { + for unmap_offset in (0..offset).step_by(PAGE_SIZE) { + crate::arch::mem::unmap_page_inner(self, unmap_offset + virt).ok(); + self.release_page((unmap_offset + phys) as *mut usize, pid) + .ok(); + } + return Err(e); } - return Err(err); } - Ok(MemoryAddress::new(virt).unwrap()) + Ok(xous::Result::MemoryRange(virt as *mut u8, size)) } // /// Map a range of physical addresses into the current memory space. diff --git a/kernel/src/processtable.rs b/kernel/src/processtable.rs index 543d8fc30..d1a3fd599 100644 --- a/kernel/src/processtable.rs +++ b/kernel/src/processtable.rs @@ -59,6 +59,9 @@ pub struct Process { /// Default virtual address when MapMemory is called with no `virt` pub mem_default_base: usize, + /// The last address allocated from + pub mem_default_last: usize, + /// Address where messages are passed into pub mem_message_base: usize, @@ -110,6 +113,7 @@ static mut SYSTEM_SERVICES: SystemServices = SystemServices { ppid: 0, mapping: arch::mem::DEFAULT_MEMORY_MAPPING, mem_default_base: arch::mem::DEFAULT_BASE, + mem_default_last: arch::mem::DEFAULT_BASE, mem_message_base: arch::mem::DEFAULT_MESSAGE_BASE, mem_heap_base: arch::mem::DEFAULT_HEAP_BASE, mem_heap_size: 0, diff --git a/loader/src/main.rs b/loader/src/main.rs index 7ebad226d..ff152173a 100644 --- a/loader/src/main.rs +++ b/loader/src/main.rs @@ -155,9 +155,7 @@ pub struct MiniElfSection { impl MiniElfSection { pub fn len(&self) -> usize { // Strip off the top four bits, which contain the flags. - // Also shift everything up by two bits, since it's in - // units of 32-bit words. - let len = (self.size_and_flags << 2) & !0xf000_0000; + let len = self.size_and_flags & !0xff00_0000; len as usize } @@ -577,13 +575,13 @@ fn copy_processes(cfg: &mut BootConfig) { if tag.name == make_type!("IniE") { let mut page_addr: usize = 0; let mut previous_addr: usize = 0; - let mut top = 0 as *mut usize; + let mut top = 0 as *mut u8; let inie = MiniElf::new(&tag); let mut src_addr = unsafe { cfg.base_addr .add(inie.load_offset as usize / mem::size_of::()) - }; + } as *const u8; // Example: Page starts at 0xf0c0 and is 8192 bytes long. // 1. Copy 3094 bytes to page 1 @@ -622,28 +620,18 @@ fn copy_processes(cfg: &mut BootConfig) { ); unsafe { bzero( - top.add( - (previous_addr as usize & (PAGE_SIZE - 1)) - / mem::size_of::(), - ), - top.add(PAGE_SIZE as usize / mem::size_of::()), + top.add(previous_addr as usize & (PAGE_SIZE - 1)), + top.add(PAGE_SIZE as usize), ) }; } // Allocate a new page. cfg.extra_pages += 1; - top = cfg.get_top(); + top = cfg.get_top() as *mut u8; // Zero out the page, if necessary. - unsafe { - bzero( - top, - top.add( - (section.virt as usize & (PAGE_SIZE - 1)) / mem::size_of::(), - ), - ) - }; + unsafe { bzero(top, top.add(section.virt as usize & (PAGE_SIZE - 1))) }; } // Part 1: Copy the first chunk over. @@ -656,29 +644,23 @@ fn copy_processes(cfg: &mut BootConfig) { "First chunk is {} bytes, copying from {:08x}:{:08x} -> {:08x}:{:08x} (virt: {:08x})", first_chunk_size, src_addr as usize, - unsafe { src_addr.add(first_chunk_size / 4) as usize }, - unsafe { top.add(first_chunk_offset / mem::size_of::()) as usize }, - unsafe { top.add((first_chunk_size + first_chunk_offset) / mem::size_of::()) + unsafe { src_addr.add(first_chunk_size) as usize }, + unsafe { top.add(first_chunk_offset) as usize }, + unsafe { top.add(first_chunk_size + first_chunk_offset) as usize }, this_page + first_chunk_offset, ); // Perform the copy, if NOCOPY is not set if !section.no_copy() { unsafe { - memcpy( - top.add(first_chunk_offset / mem::size_of::()), - src_addr, - first_chunk_size, - ); - src_addr = src_addr.add(first_chunk_size / mem::size_of::()); + memcpy(top.add(first_chunk_offset), src_addr, first_chunk_size); + src_addr = src_addr.add(first_chunk_size); } } else { unsafe { bzero( - top.add(first_chunk_offset / mem::size_of::()), - top.add( - (first_chunk_offset + first_chunk_size) / mem::size_of::(), - ), + top.add(first_chunk_offset), + top.add(first_chunk_offset + first_chunk_size), ); } } @@ -687,7 +669,7 @@ fn copy_processes(cfg: &mut BootConfig) { // Part 2: Copy any full pages. while bytes_to_copy > PAGE_SIZE { cfg.extra_pages += 1; - top = cfg.get_top(); + top = cfg.get_top() as *mut u8; // println!( // "Copying next page from {:08x} {:08x}", // src_addr as usize, top as usize @@ -695,10 +677,10 @@ fn copy_processes(cfg: &mut BootConfig) { if !section.no_copy() { unsafe { memcpy(top, src_addr, PAGE_SIZE); - src_addr = src_addr.add(PAGE_SIZE / mem::size_of::()); + src_addr = src_addr.add(PAGE_SIZE); } } else { - unsafe { bzero(top, top.add(PAGE_SIZE / 4)) }; + unsafe { bzero(top, top.add(PAGE_SIZE)) }; } bytes_to_copy -= PAGE_SIZE; } @@ -707,14 +689,14 @@ fn copy_processes(cfg: &mut BootConfig) { if bytes_to_copy > 0 { println!("Copying final section -- {} bytes", bytes_to_copy); cfg.extra_pages += 1; - top = cfg.get_top(); + top = cfg.get_top() as *mut u8; if !section.no_copy() { unsafe { memcpy(top, src_addr, bytes_to_copy); - src_addr = src_addr.add(bytes_to_copy / mem::size_of::()); + src_addr = src_addr.add(bytes_to_copy); } } else { - unsafe { bzero(top, top.add(bytes_to_copy / 4)) }; + unsafe { bzero(top, top.add(bytes_to_copy)) }; } } @@ -727,8 +709,8 @@ fn copy_processes(cfg: &mut BootConfig) { // Zero-out the trailing bytes unsafe { bzero( - top.add((previous_addr as usize & (PAGE_SIZE - 1)) / mem::size_of::()), - top.add(PAGE_SIZE as usize / mem::size_of::()), + top.add(previous_addr as usize & (PAGE_SIZE - 1)), + top.add(PAGE_SIZE as usize), ) }; } else if tag.name == make_type!("XKrn") { diff --git a/loader/src/test.rs b/loader/src/test.rs index 19dc3e1c0..aca2ea793 100644 --- a/loader/src/test.rs +++ b/loader/src/test.rs @@ -191,6 +191,11 @@ fn read_word(satp: usize, virt: usize) -> Result { Ok(unsafe { (page_base as *mut u32).read() }) } +fn read_byte(satp: usize, virt: usize) -> Result { + let word = read_word(satp, virt & 0xfffffffc)?; + Ok(word.to_le_bytes()[virt & 3]) +} + fn verify_kernel(cfg: &BootConfig, pid: usize, arg: &crate::args::KernelArgument) { let prog = unsafe { &*(arg.data.as_ptr() as *const crate::ProgramDescription) }; let program_offset = prog.load_offset as usize; @@ -273,21 +278,21 @@ fn verify_program(cfg: &BootConfig, pid: usize, arg: &crate::args::KernelArgumen let mut program_offset = elf.load_offset as usize; for section in elf.sections.iter() { - for addr in (section.virt..(section.virt + section.len() as u32)).step_by(4) { + for addr in section.virt..(section.virt + section.len() as u32) { let addr = addr as usize; - let word = read_word(cfg.processes[pid].satp as usize, addr).unwrap(); + let word = read_byte(cfg.processes[pid].satp as usize, addr).unwrap(); if section.no_copy() { assert!(word == 0, "bss is {:08x}, not 0 @ {:08x}", word, addr); } else { let check_word = unsafe { - (cfg.base_addr as *mut u32) - .add(program_offset / 4) + (cfg.base_addr as *mut u8) + .add(program_offset) .read() }; - program_offset += 4; + program_offset += 1; assert!( word == check_word, - "program doesn't match @ {:08x} (expected: {:08x} found: {:08x})", + "program doesn't match @ {:08x} (expected: {:02x} found: {:02x})", addr, check_word, word, diff --git a/loader/test/args.bin b/loader/test/args.bin index 7df7f69b2..aa67a29b5 100644 Binary files a/loader/test/args.bin and b/loader/test/args.bin differ diff --git a/tools/src/elf.rs b/tools/src/elf.rs index 95c876420..98ffb526f 100644 --- a/tools/src/elf.rs +++ b/tools/src/elf.rs @@ -308,7 +308,6 @@ pub fn read_minielf>(filename: P) -> Result>(filename: P) -> Result>(filename: P) -> Result> 2).to_le_bytes(); + let mut word2 = section.size.to_le_bytes(); word2[3] = section.flags.bits(); written += output.write(&word2)?; }