Merge remote-tracking branch 'betrusted/fix-section-loading' into bunnie-dev

This commit is contained in:
bunnie 2021-04-12 20:49:40 +08:00
commit fbe2b7d961
3 changed files with 141 additions and 80 deletions

View file

@ -1,11 +1,12 @@
use utralib::generated::*; use utralib::generated::*;
pub struct Uart { pub struct Uart {
pub base: *mut u32, // pub base: *mut u32,
} }
impl Uart { impl Uart {
pub fn putc(&self, c: u8) { pub fn putc(&self, c: u8) {
let mut uart = CSR::new(self.base); let base = utra::uart::HW_UART_BASE as *mut u32;
let mut uart = CSR::new(base);
// Wait until TXFULL is `0` // Wait until TXFULL is `0`
while uart.r(utra::uart::TXFULL) != 0 {} while uart.r(utra::uart::TXFULL) != 0 {}
uart.wo(utra::uart::RXTX, c as u32) uart.wo(utra::uart::RXTX, c as u32)
@ -25,17 +26,12 @@ impl Write for Uart {
#[macro_use] #[macro_use]
#[cfg(all(not(test), feature = "debug-print"))] #[cfg(all(not(test), feature = "debug-print"))]
pub mod debug_print_hardware { pub mod debug_print_hardware {
use crate::debug::*;
pub const SUPERVISOR_UART: Uart = Uart {
base: utra::uart::HW_UART_BASE as *mut u32,
};
#[macro_export] #[macro_export]
macro_rules! print macro_rules! print
{ {
($($args:tt)+) => ({ ($($args:tt)+) => ({
use core::fmt::Write; use core::fmt::Write;
let _ = write!(crate::debug::debug_print_hardware::SUPERVISOR_UART, $($args)+); let _ = write!(crate::debug::Uart {}, $($args)+);
}); });
} }
} }

View file

@ -5,6 +5,7 @@
mod args; mod args;
use args::{KernelArgument, KernelArguments}; use args::{KernelArgument, KernelArguments};
use core::num::NonZeroUsize;
use core::{mem, ptr, slice}; use core::{mem, ptr, slice};
pub type XousPid = u8; pub type XousPid = u8;
@ -210,7 +211,7 @@ impl MiniElf {
println!("Mapping PID {} starting at offset {:08x}", pid, load_offset); println!("Mapping PID {} starting at offset {:08x}", pid, load_offset);
let mut allocated_bytes = 0; let mut allocated_bytes = 0;
let mut page_addr: usize = 0; let mut current_page_addr: usize = 0;
let mut previous_addr: usize = 0; let mut previous_addr: usize = 0;
// The load offset is the end of this process. Shift it down by one page // The load offset is the end of this process. Shift it down by one page
@ -223,22 +224,16 @@ impl MiniElf {
allocator.change_owner(pid as XousPid, satp_address); allocator.change_owner(pid as XousPid, satp_address);
// Turn the satp address into a pointer // Turn the satp address into a pointer
println!(" Pagetable"); println!(" Pagetable @ {:08x}", satp_address);
let satp = unsafe { &mut *(satp_address as *mut PageTable) }; let satp = unsafe { &mut *(satp_address as *mut PageTable) };
allocator.map_page(satp, satp_address, PAGE_TABLE_ROOT_OFFSET, FLG_R | FLG_W); allocator.map_page(satp, satp_address, PAGE_TABLE_ROOT_OFFSET, FLG_R | FLG_W);
// Allocate thread 1 for this process // Allocate thread 1 for this process
println!(" Thread");
let thread_address = allocator.alloc() as usize; let thread_address = allocator.alloc() as usize;
println!(" Thread 1 @ {:08x}", thread_address);
allocator.map_page(satp, thread_address, CONTEXT_OFFSET, FLG_R | FLG_W); allocator.map_page(satp, thread_address, CONTEXT_OFFSET, FLG_R | FLG_W);
allocator.change_owner(pid as XousPid, thread_address as usize); allocator.change_owner(pid as XousPid, thread_address as usize);
// Ensure the pagetables are mapped as well
println!(" Pagetables");
let pt_addr = allocator.alloc() as usize;
allocator.map_page(satp, pt_addr, PAGE_TABLE_OFFSET, FLG_R | FLG_W);
allocator.change_owner(pid as XousPid, pt_addr as usize);
// Allocate stack pages. // Allocate stack pages.
println!(" Stack"); println!(" Stack");
for i in 0..STACK_PAGE_COUNT { for i in 0..STACK_PAGE_COUNT {
@ -263,7 +258,7 @@ impl MiniElf {
// Example: Page starts at 0xf000 and is 128 bytes long // Example: Page starts at 0xf000 and is 128 bytes long
// 1. Copy 128 bytes to page 1 // 1. Copy 128 bytes to page 1
// //
// Example: Page starts at oxf0c0 and is 128 bytes long // Example: Page starts at 0xf0c0 and is 128 bytes long
// 1. Copy 128 bytes to page 1 // 1. Copy 128 bytes to page 1
for section in self.sections { for section in self.sections {
println!(" Section @ {:08x}", section.virt as usize); println!(" Section @ {:08x}", section.virt as usize);
@ -281,23 +276,46 @@ impl MiniElf {
// If this is not a new page, ensure the uninitialized values from between // If this is not a new page, ensure the uninitialized values from between
// this section and the previous one are all zeroed out. // this section and the previous one are all zeroed out.
if this_page != page_addr { if this_page != current_page_addr {
println!("1 {:08x} -> {:08x}", top as usize, this_page);
allocator.map_page(satp, top as usize, this_page, flag_defaults); allocator.map_page(satp, top as usize, this_page, flag_defaults);
allocator.change_owner(pid as XousPid, top as usize); allocator.change_owner(pid as XousPid, top as usize);
allocated_bytes += PAGE_SIZE; allocated_bytes += PAGE_SIZE;
top -= PAGE_SIZE; top -= PAGE_SIZE;
this_page += PAGE_SIZE; this_page += PAGE_SIZE;
}
// Part 1: Copy the first chunk over. // Part 1: Copy the first chunk over.
let mut first_chunk_size = PAGE_SIZE - (section.virt as usize & (PAGE_SIZE - 1)); let mut first_chunk_size = PAGE_SIZE - (section.virt as usize & (PAGE_SIZE - 1));
if first_chunk_size > section.len() { if first_chunk_size > section.len() {
first_chunk_size = section.len(); first_chunk_size = section.len();
}
bytes_to_copy -= first_chunk_size;
} else {
println!(
"This page is {:08x}, and last page was {:08x}",
this_page, current_page_addr
);
// This is a continuation of the previous section, and as a result
// the memory will have been copied already. Avoid copying this data
// to a new page.
let first_chunk_size = PAGE_SIZE - (section.virt as usize & (PAGE_SIZE - 1));
println!("First chunk size: {}", first_chunk_size);
if bytes_to_copy < first_chunk_size {
bytes_to_copy = 0;
println!("Clamping to 0 bytes");
} else {
bytes_to_copy -= first_chunk_size;
println!(
"Clamping to {} bytes by cutting off {} bytes",
bytes_to_copy, first_chunk_size
);
}
this_page += PAGE_SIZE;
} }
bytes_to_copy -= first_chunk_size;
// Part 2: Copy any full pages. // Part 2: Copy any full pages.
while bytes_to_copy > PAGE_SIZE { while bytes_to_copy > PAGE_SIZE {
println!("2 {:08x} -> {:08x}", top as usize, this_page);
allocator.map_page(satp, top as usize, this_page, flag_defaults); allocator.map_page(satp, top as usize, this_page, flag_defaults);
allocator.change_owner(pid as XousPid, top as usize); allocator.change_owner(pid as XousPid, top as usize);
allocated_bytes += PAGE_SIZE; allocated_bytes += PAGE_SIZE;
@ -309,6 +327,7 @@ impl MiniElf {
// Part 3: Copy the final residual partial page // Part 3: Copy the final residual partial page
if bytes_to_copy > 0 { if bytes_to_copy > 0 {
let this_page = (section.virt as usize + section.len()) & !(PAGE_SIZE - 1); let this_page = (section.virt as usize + section.len()) & !(PAGE_SIZE - 1);
println!("3 {:08x} -> {:08x}", top as usize, this_page);
allocator.map_page(satp, top as usize, this_page, flag_defaults); allocator.map_page(satp, top as usize, this_page, flag_defaults);
allocator.change_owner(pid as XousPid, top as usize); allocator.change_owner(pid as XousPid, top as usize);
allocated_bytes += PAGE_SIZE; allocated_bytes += PAGE_SIZE;
@ -316,7 +335,7 @@ impl MiniElf {
} }
previous_addr = section.virt as usize + section.len(); previous_addr = section.virt as usize + section.len();
page_addr = previous_addr & !(PAGE_SIZE - 1); current_page_addr = previous_addr & !(PAGE_SIZE - 1);
} }
let mut process = &mut allocator.processes[pid as usize - 1]; let mut process = &mut allocator.processes[pid as usize - 1];
@ -416,13 +435,12 @@ impl ProgramDescription {
allocator.map_page(satp, thread_address, CONTEXT_OFFSET, FLG_R | FLG_W); allocator.map_page(satp, thread_address, CONTEXT_OFFSET, FLG_R | FLG_W);
allocator.change_owner(pid as XousPid, thread_address as usize); allocator.change_owner(pid as XousPid, thread_address as usize);
// Ensure the pagetables are mapped as well
let pt_addr = allocator.alloc() as usize;
allocator.map_page(satp, pt_addr, PAGE_TABLE_OFFSET, FLG_R | FLG_W);
allocator.change_owner(pid as XousPid, pt_addr as usize);
// Allocate stack pages. // Allocate stack pages.
for i in 0..if is_kernel { KERNEL_STACK_PAGE_COUNT} else { STACK_PAGE_COUNT } { for i in 0..if is_kernel {
KERNEL_STACK_PAGE_COUNT
} else {
STACK_PAGE_COUNT
} {
let sp_page = allocator.alloc() as usize; let sp_page = allocator.alloc() as usize;
allocator.map_page( allocator.map_page(
satp, satp,
@ -710,7 +728,11 @@ fn copy_processes(cfg: &mut BootConfig) {
// Part 3: Copy the final residual partial page // Part 3: Copy the final residual partial page
if bytes_to_copy > 0 { if bytes_to_copy > 0 {
println!("Copying final section -- {} bytes", bytes_to_copy); println!(
"Copying final section -- {} bytes @ {:08x}",
bytes_to_copy,
section.virt + (section.len() as u32) - (bytes_to_copy as u32)
);
cfg.extra_pages += 1; cfg.extra_pages += 1;
top = cfg.get_top() as *mut u8; top = cfg.get_top() as *mut u8;
if !section.no_copy() { if !section.no_copy() {
@ -905,38 +927,52 @@ impl BootConfig {
assert!(vpo < 4096); assert!(vpo < 4096);
let l1_pt = &mut root.entries; let l1_pt = &mut root.entries;
let mut new_addr = 0; let mut new_addr = None;
// Allocate a new level 1 pagetable entry if one doesn't exist. // Allocate a new level 1 pagetable entry if one doesn't exist.
if l1_pt[vpn1] & FLG_VALID == 0 { if l1_pt[vpn1] & FLG_VALID == 0 {
new_addr = self.alloc() as usize; let na = self.alloc() as usize;
println!("The Level 1 page table is invalid ({:08x}) @ {:08x} -- allocating a new one @ {:08x}",
unsafe { l1_pt.as_ptr().add(vpn1) } as usize, l1_pt[vpn1], na);
// Mark this entry as a leaf node (WRX as 0), and indicate // Mark this entry as a leaf node (WRX as 0), and indicate
// it is a valid page by setting "V". // it is a valid page by setting "V".
l1_pt[vpn1] = ((new_addr >> 12) << 10) | FLG_VALID; l1_pt[vpn1] = ((na >> 12) << 10) | FLG_VALID;
new_addr = Some(NonZeroUsize::new(na).unwrap());
} }
let l0_pt_idx = let l0_pt_idx =
unsafe { &mut (*(((l1_pt[vpn1] << 2) & !((1 << 12) - 1)) as *mut PageTable)) }; unsafe { &mut (*(((l1_pt[vpn1] << 2) & !((1 << 12) - 1)) as *mut PageTable)) };
let l0_pt = &mut l0_pt_idx.entries; let l0_pt = &mut l0_pt_idx.entries;
// Ensure the entry hasn't already been mapped. // Ensure the entry hasn't already been mapped to a different address.
// if l0_pt[vpn0] & 1 != 0 { if l0_pt[vpn0] & 1 != 0 && (l0_pt[vpn0] & 0xffff_fc00) != ((ppn1 << 20) | (ppn0 << 10)) {
// panic!("Page already allocated!"); panic!(
// } "Page {:08x} was already allocated to {:08x}, so cannot map to {:08x}!",
phys,
(l0_pt[vpn0] >> 10) << 12,
virt
);
}
let previous_flags = l0_pt[vpn0] & 0xf; let previous_flags = l0_pt[vpn0] & 0xf;
l0_pt[vpn0] = l0_pt[vpn0] =
(ppn1 << 20) | (ppn0 << 10) | flags | previous_flags | FLG_VALID | FLG_D | FLG_A; (ppn1 << 20) | (ppn0 << 10) | flags | previous_flags | FLG_VALID | FLG_D | FLG_A;
// If we had to allocate a level 1 pagetable entry, ensure that it's // If we had to allocate a level 1 pagetable entry, ensure that it's
// mapped into our address space. // mapped into our address space, owned by PID 1.
if new_addr != 0 { if let Some(addr) = new_addr {
println!(
">>> Mapping new address {:08x} -> {:08x}",
addr.get(),
PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE
);
self.map_page( self.map_page(
root, root,
new_addr, addr.get(),
PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE, PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE,
FLG_R | FLG_W, FLG_R | FLG_W,
); );
self.change_owner(1 as XousPid, new_addr as usize); self.change_owner(1 as XousPid, addr.get());
println!("<<< Done mapping new address");
} }
} }
} }
@ -1042,7 +1078,10 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! {
println!("Font maps located as follows:"); println!("Font maps located as follows:");
println!(" Hanzi @ {:08x}", fonts::hanzi::DATA_HANZI.as_ptr() as u32); println!(" Hanzi @ {:08x}", fonts::hanzi::DATA_HANZI.as_ptr() as u32);
println!(" Emoji @ {:08x}", fonts::emoji::DATA_EMOJI.as_ptr() as u32); println!(" Emoji @ {:08x}", fonts::emoji::DATA_EMOJI.as_ptr() as u32);
println!(" Regular @ {:08x}", fonts::regular::DATA_REGULAR.as_ptr() as u32); println!(
" Regular @ {:08x}",
fonts::regular::DATA_REGULAR.as_ptr() as u32
);
println!(" Small @ {:08x}", fonts::small::DATA_SMALL.as_ptr() as u32); println!(" Small @ {:08x}", fonts::small::DATA_SMALL.as_ptr() as u32);
println!(" Bold @ {:08x}", fonts::bold::DATA_BOLD.as_ptr() as u32); println!(" Bold @ {:08x}", fonts::bold::DATA_BOLD.as_ptr() as u32);

View file

@ -1,10 +1,16 @@
#![cfg_attr(target_os = "none", no_std)] #![cfg_attr(target_os = "none", no_std)]
use core::fmt::Write; use core::fmt::Write;
use core::sync::atomic::{AtomicBool, Ordering}; use core::sync::atomic::{AtomicBool, Ordering};
use xous_ipc::{String, Buffer}; use xous_ipc::{Buffer, String};
pub mod api; pub mod api;
#[derive(Debug)]
pub enum LogError {
LoggerExists,
NoConnection,
}
static XOUS_LOGGER: XousLogger = XousLogger { static XOUS_LOGGER: XousLogger = XousLogger {
locked: AtomicBool::new(false), locked: AtomicBool::new(false),
}; };
@ -13,33 +19,41 @@ struct XousLogger {
locked: AtomicBool, locked: AtomicBool,
} }
static mut XOUS_LOGGER_BACKING: XousLoggerBacking = XousLoggerBacking { // static mut XOUS_LOGGER_BACKING: XousLoggerBacking = XousLoggerBacking {
conn: 0, // conn: 0,
initialized: false, // initialized: false,
buffer: None, // buffer: None,
}; // };
static mut XOUS_LOGGER_BACKING: Option<XousLoggerBacking> = None;
struct XousLoggerBacking<'a> { struct XousLoggerBacking<'a> {
conn: xous::CID, conn: xous::CID,
buffer: Option<Buffer<'a>>, buffer: Buffer<'a>,
initialized: bool, }
impl<'a> XousLoggerBacking<'a> {
pub fn new() -> Result<Self, xous::Error> {
Ok(XousLoggerBacking {
conn: xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap())?,
// why 4000? tests non-power of 2 sizes in rkyv APIs. Could make it 4096 as well...
buffer: Buffer::new(4000),
})
}
}
impl Default for XousLoggerBacking<'_> {
fn default() -> Self {
XousLoggerBacking {
conn: xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap()).unwrap(),
// why 4000? tests non-power of 2 sizes in rkyv APIs. Could make it 4096 as well...
buffer: Buffer::new(4000),
}
}
} }
impl XousLoggerBacking<'_> { impl XousLoggerBacking<'_> {
fn init(&mut self) -> Result<(), xous::Error> {
if self.initialized {
return Ok(());
}
self.conn = xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap())?;
self.buffer = Some(Buffer::new(4000)); // why 4000? tests non-power of 2 sizes in rkyv APIs. Could make it 4096 as well...
self.initialized = true;
Ok(())
}
fn log_impl(&mut self, record: &log::Record) { fn log_impl(&mut self, record: &log::Record) {
if !self.initialized && self.init().is_err() {
return;
}
let mut args = String::<2800>::new(); let mut args = String::<2800>::new();
write!(args, "{}", record.args()).unwrap(); write!(args, "{}", record.args()).unwrap();
let lr = api::LogRecord { let lr = api::LogRecord {
@ -50,10 +64,8 @@ impl XousLoggerBacking<'_> {
args, args,
}; };
if let Some(buf) = self.buffer.as_mut() { self.buffer.rewrite(lr).unwrap();
buf.rewrite(lr).unwrap(); self.buffer.lend(self.conn, 0).unwrap(); // there is only one type of buffer we should be sending!
buf.lend(self.conn, 0).unwrap(); // there is only one type of buffer we should be sending!
}
} }
} }
@ -71,7 +83,10 @@ impl log::Log for XousLogger {
xous::yield_slice(); xous::yield_slice();
} }
unsafe { XOUS_LOGGER_BACKING.log_impl(record) }; if unsafe { XOUS_LOGGER_BACKING.is_none() } {
unsafe { XOUS_LOGGER_BACKING = Some(XousLoggerBacking::default()) };
}
unsafe { XOUS_LOGGER_BACKING.as_mut().unwrap().log_impl(record) };
self.locked self.locked
.compare_exchange(true, false, Ordering::SeqCst, Ordering::Acquire) .compare_exchange(true, false, Ordering::SeqCst, Ordering::Acquire)
.expect("LOG: logger became unlocked somehow"); .expect("LOG: logger became unlocked somehow");
@ -79,19 +94,30 @@ impl log::Log for XousLogger {
fn flush(&self) {} fn flush(&self) {}
} }
pub fn init() -> Result<(), log::SetLoggerError> { pub fn init() -> Result<(), LogError> {
log::set_logger(&XOUS_LOGGER)?; if let Ok(backing) = XousLoggerBacking::new() {
log::set_max_level(log::LevelFilter::Info); unsafe {
Ok(()) XOUS_LOGGER_BACKING = Some(backing);
}
log::set_logger(&XOUS_LOGGER).map_err(|_| LogError::LoggerExists)?;
log::set_max_level(log::LevelFilter::Info);
Ok(())
} else {
Err(LogError::NoConnection)
}
} }
pub fn init_wait() -> Result<(), log::SetLoggerError> { pub fn init_wait() -> Result<(), log::SetLoggerError> {
loop {
if let Ok(backing) = XousLoggerBacking::new() {
unsafe {
XOUS_LOGGER_BACKING = Some(backing);
break;
}
}
xous::yield_slice();
}
log::set_logger(&XOUS_LOGGER)?; log::set_logger(&XOUS_LOGGER)?;
log::set_max_level(log::LevelFilter::Info); log::set_max_level(log::LevelFilter::Info);
unsafe {
while XOUS_LOGGER_BACKING.init().is_err() {
xous::yield_slice();
}
}
Ok(()) Ok(())
} }