mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
Merge branch 'master' of github.com:betrusted-io/xous-core
This commit is contained in:
commit
4bb3f6db68
12 changed files with 106 additions and 94 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
);
|
||||
|
|
|
|||
|
|
@ -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<usize, xous::Error> {
|
||||
// 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<xous::Result, xous::Error> {
|
||||
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<MemoryAddress, xous::Error> {
|
||||
) -> Result<xous::Result, xous::Error> {
|
||||
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.
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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::<usize>())
|
||||
};
|
||||
} 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::<usize>(),
|
||||
),
|
||||
top.add(PAGE_SIZE as usize / mem::size_of::<usize>()),
|
||||
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::<usize>(),
|
||||
),
|
||||
)
|
||||
};
|
||||
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::<usize>()) as usize },
|
||||
unsafe { top.add((first_chunk_size + first_chunk_offset) / mem::size_of::<usize>())
|
||||
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::<usize>()),
|
||||
src_addr,
|
||||
first_chunk_size,
|
||||
);
|
||||
src_addr = src_addr.add(first_chunk_size / mem::size_of::<usize>());
|
||||
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::<usize>()),
|
||||
top.add(
|
||||
(first_chunk_offset + first_chunk_size) / mem::size_of::<usize>(),
|
||||
),
|
||||
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::<usize>());
|
||||
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::<usize>());
|
||||
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::<usize>()),
|
||||
top.add(PAGE_SIZE as usize / mem::size_of::<usize>()),
|
||||
top.add(previous_addr as usize & (PAGE_SIZE - 1)),
|
||||
top.add(PAGE_SIZE as usize),
|
||||
)
|
||||
};
|
||||
} else if tag.name == make_type!("XKrn") {
|
||||
|
|
|
|||
|
|
@ -191,6 +191,11 @@ fn read_word(satp: usize, virt: usize) -> Result<u32, &'static str> {
|
|||
Ok(unsafe { (page_base as *mut u32).read() })
|
||||
}
|
||||
|
||||
fn read_byte(satp: usize, virt: usize) -> Result<u8, &'static str> {
|
||||
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,
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -308,7 +308,6 @@ pub fn read_minielf<P: AsRef<Path>>(filename: P) -> Result<MiniElf, ElfReadError
|
|||
debug!(" size: {:?}", s.size());
|
||||
debug!(" link: {:?}", s.link());
|
||||
let size = s.size();
|
||||
let padding = (4 - (size & 3)) & 3;
|
||||
|
||||
if s.flags() & SHF_ALLOC == 0 {
|
||||
debug!("section has no allocations -- skipping");
|
||||
|
|
@ -326,12 +325,11 @@ pub fn read_minielf<P: AsRef<Path>>(filename: P) -> Result<MiniElf, ElfReadError
|
|||
|
||||
debug!("Adding {} to the file", name);
|
||||
debug!(
|
||||
"{} offset: {:08x} program_offset: {:08x} bytes: {} padding: {} seek: {}",
|
||||
"{} offset: {:08x} program_offset: {:08x} bytes: {} seek: {}",
|
||||
name,
|
||||
s.offset(),
|
||||
program_offset,
|
||||
s.raw_data(&elf).len(),
|
||||
padding,
|
||||
program_offset
|
||||
);
|
||||
let section_data = s.raw_data(&elf);
|
||||
|
|
@ -349,11 +347,10 @@ pub fn read_minielf<P: AsRef<Path>>(filename: P) -> Result<MiniElf, ElfReadError
|
|||
.write(section_data)
|
||||
.or_else(|x| Err(ElfReadError::WriteSectionError(x)))?;
|
||||
program_offset += section_data.len() as u64;
|
||||
program_offset += padding as u64;
|
||||
}
|
||||
sections.push(MiniElfSection {
|
||||
virt: s.address() as u32,
|
||||
size: (size + padding) as u32,
|
||||
size: size as u32,
|
||||
flags: flags,
|
||||
name: name.to_string(),
|
||||
});
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ impl XousArgument for IniE {
|
|||
written += output.write(&self.entrypoint.to_le_bytes())?;
|
||||
for section in &self.sections {
|
||||
written += output.write(§ion.virt.to_le_bytes())?;
|
||||
let mut word2 = (section.size >> 2).to_le_bytes();
|
||||
let mut word2 = section.size.to_le_bytes();
|
||||
word2[3] = section.flags.bits();
|
||||
written += output.write(&word2)?;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue