mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
big refactor of the swapper
- debug UART is now a static object. Less safe, kinda gross, but gets us debug access at any time! Probably fine, because once we turn off the feature all taht ugliness goes away. - use memory mapped structures for initialization of the swapper state
This commit is contained in:
parent
433cc7dfb7
commit
1bac53686c
1 changed files with 124 additions and 118 deletions
|
|
@ -1,51 +1,26 @@
|
||||||
use core::fmt::{Error, Write};
|
mod platform;
|
||||||
|
|
||||||
|
use core::fmt::{Error, Write};
|
||||||
|
use core::sync::atomic::{AtomicUsize, Ordering};
|
||||||
|
|
||||||
|
use loader::swap::{SwapSpec, SWAP_CFG_VADDR, SWAP_PT_VADDR, SWAP_RPT_VADDR};
|
||||||
use num_traits::FromPrimitive;
|
use num_traits::FromPrimitive;
|
||||||
|
use platform::SwapMac;
|
||||||
use utralib::*;
|
use utralib::*;
|
||||||
|
|
||||||
/// This trait defines a set of functions to get and receive MACs (message
|
static DUART_CSR_PA: AtomicUsize = AtomicUsize::new(0);
|
||||||
/// authentication codes, also referred to as the tag in AES-GCM-SIV.
|
|
||||||
///
|
pub struct PtPage {
|
||||||
/// The implementation of the MAC table depends on the details of the hardware;
|
pub entries: [u32; 1024],
|
||||||
/// we cannot always guarantee that the MACs are memory mapped, as they could
|
|
||||||
/// be stored in an off-chip SPI RAM that is accessible only through a register
|
|
||||||
/// interface.
|
|
||||||
pub trait SmtAccessor {
|
|
||||||
/// Lookup the MAC corresponding to a given page in swap. Offsets are
|
|
||||||
/// relative to the base of the swap region, and are given in units of pages, not bytes.
|
|
||||||
fn lookup_mac(swap_page_offset: usize) -> [u8; 16];
|
|
||||||
/// Store a MAC for a given page in swap.
|
|
||||||
fn store_mac(swap_page_offset: usize, mac: &[u8; 16]);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// An array of pointers to the SATPs (root page table) of all the processes.
|
/// An array of pointers to the root page tables of all the processes.
|
||||||
pub struct SwapPageTables {
|
pub struct SwapPageTables {
|
||||||
satps: &'static mut [usize],
|
pub roots: &'static mut [PtPage],
|
||||||
}
|
}
|
||||||
/// This is an implementation for SMTs that are memory mapped. Directly mapped
|
|
||||||
/// tables are just as lice of MACs
|
|
||||||
pub struct SwapMacTableMemMap {
|
|
||||||
macs: &'static mut [[u8; 16]],
|
|
||||||
}
|
|
||||||
impl SmtAccessor for SwapMacTableMemMap {
|
|
||||||
fn lookup_mac(swap_page_offset: usize) -> [u8; 16] { todo!() }
|
|
||||||
|
|
||||||
fn store_mac(swap_page_offset: usize, mac: &[u8; 16]) { todo!() }
|
|
||||||
}
|
|
||||||
/// This is an implementation for SMTs that are accessible only through a SPI
|
|
||||||
/// register interface. The base and bounds must be translated to SPI accesses
|
|
||||||
/// in a hardware-specific manner.
|
|
||||||
pub struct SwapMacTableSpi {
|
|
||||||
base: usize,
|
|
||||||
bounds: usize,
|
|
||||||
}
|
|
||||||
impl SmtAccessor for SwapMacTableSpi {
|
|
||||||
fn lookup_mac(swap_page_offset: usize) -> [u8; 16] { todo!() }
|
|
||||||
|
|
||||||
fn store_mac(swap_page_offset: usize, mac: &[u8; 16]) { todo!() }
|
|
||||||
}
|
|
||||||
pub struct RuntimePageTracker {
|
pub struct RuntimePageTracker {
|
||||||
allocs: &'static mut [u8],
|
pub allocs: &'static mut [u8],
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
||||||
|
|
@ -61,34 +36,29 @@ pub enum Opcode {
|
||||||
EvalTrim = 256,
|
EvalTrim = 256,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct DebugUart {
|
pub struct DebugUart {}
|
||||||
#[cfg(feature = "debug-print")]
|
|
||||||
csr: CSR<u32>,
|
|
||||||
}
|
|
||||||
impl DebugUart {
|
impl DebugUart {
|
||||||
#[cfg(feature = "debug-print")]
|
|
||||||
pub fn new() -> Self {
|
|
||||||
let debug_uart_mem = xous::syscall::map_memory(
|
|
||||||
xous::MemoryAddress::new(utra::app_uart::HW_APP_UART_BASE),
|
|
||||||
None,
|
|
||||||
4096,
|
|
||||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
|
||||||
)
|
|
||||||
.expect("couldn't claim the debug UART");
|
|
||||||
let debug_uart = CSR::new(debug_uart_mem.as_mut_ptr() as *mut u32);
|
|
||||||
|
|
||||||
Self { csr: debug_uart }
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "debug-print")]
|
#[cfg(feature = "debug-print")]
|
||||||
pub fn putc(&mut self, c: u8) {
|
pub fn putc(&mut self, c: u8) {
|
||||||
// Wait until TXFULL is `0`
|
let mut csr_ptr = DUART_CSR_PA.load(Ordering::SeqCst);
|
||||||
while self.csr.r(utra::app_uart::TXFULL) != 0 {}
|
// map it if it doesn't exist
|
||||||
self.csr.wfo(utra::app_uart::RXTX_RXTX, c as u32);
|
if csr_ptr == 0 {
|
||||||
}
|
let debug_uart_mem = xous::syscall::map_memory(
|
||||||
|
xous::MemoryAddress::new(utra::app_uart::HW_APP_UART_BASE),
|
||||||
|
None,
|
||||||
|
4096,
|
||||||
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
|
)
|
||||||
|
.expect("couldn't claim the debug UART");
|
||||||
|
DUART_CSR_PA.store(csr_ptr, Ordering::SeqCst);
|
||||||
|
csr_ptr = debug_uart_mem.as_ptr() as usize;
|
||||||
|
}
|
||||||
|
let mut csr = CSR::new(csr_ptr as *mut u32);
|
||||||
|
|
||||||
#[cfg(not(feature = "debug-print"))]
|
// Wait until TXFULL is `0`
|
||||||
pub fn new() -> Self { Self {} }
|
while csr.r(utra::app_uart::TXFULL) != 0 {}
|
||||||
|
csr.wfo(utra::app_uart::RXTX_RXTX, c as u32);
|
||||||
|
}
|
||||||
|
|
||||||
#[cfg(not(feature = "debug-print"))]
|
#[cfg(not(feature = "debug-print"))]
|
||||||
pub fn putc(&self, _c: u8) {}
|
pub fn putc(&self, _c: u8) {}
|
||||||
|
|
@ -106,10 +76,13 @@ impl Write for DebugUart {
|
||||||
/// This structure contains shared state accessible between the userspace code and the blocking swap call
|
/// This structure contains shared state accessible between the userspace code and the blocking swap call
|
||||||
/// handler.
|
/// handler.
|
||||||
struct SwapperSharedState {
|
struct SwapperSharedState {
|
||||||
duart: DebugUart,
|
pub key: [u8; 32],
|
||||||
|
pub pts: SwapPageTables,
|
||||||
|
pub macs: SwapMac,
|
||||||
|
pub rpt: RuntimePageTracker,
|
||||||
}
|
}
|
||||||
impl SwapperSharedState {
|
struct SharedStateStorage {
|
||||||
pub fn new() -> Self { Self { duart: DebugUart::new() } }
|
pub inner: Option<SwapperSharedState>,
|
||||||
}
|
}
|
||||||
|
|
||||||
/// blocking swap call handler
|
/// blocking swap call handler
|
||||||
|
|
@ -127,13 +100,58 @@ fn swap_handler(
|
||||||
a7: usize,
|
a7: usize,
|
||||||
) {
|
) {
|
||||||
// safety: lots of footguns actually, but this is the only way to get this pointer into
|
// safety: lots of footguns actually, but this is the only way to get this pointer into
|
||||||
// our context. SwapperSharedState is a Rust structure that is aligned and initialized,
|
// our context. SharedStateStorage is a Rust structure that is aligned and initialized,
|
||||||
// so the cast is safe enough, but we have to be careful because this is executed in an
|
// so the cast is safe enough, but we have to be careful because this is executed in an
|
||||||
// interrupt context: we can't wait on locks (they'll hang forever if they are locked).
|
// interrupt context: we can't wait on locks (they'll hang forever if they are locked).
|
||||||
let ss = unsafe { &mut *(shared_state as *mut SwapperSharedState) };
|
let sss = unsafe { &mut *(shared_state as *mut SharedStateStorage) };
|
||||||
|
if sss.inner.is_none() {
|
||||||
|
// Unearth all of our data trackers in the spots on the map where the loader should have buried them.
|
||||||
|
|
||||||
|
// safety: this is only safe because the loader initializes and aligns the SwapSpec structure:
|
||||||
|
// - The SwapSpec structure is Repr(C), page-aligned, and fully initialized.
|
||||||
|
// - Furthermore, SWAP_CFG_VADDR is already mapped into our address space by the loader; we don't
|
||||||
|
// have to do mapping requests because it's already done for us!
|
||||||
|
let swap_spec = unsafe { &*(SWAP_CFG_VADDR as *mut SwapSpec) };
|
||||||
|
|
||||||
|
// extract our key
|
||||||
|
let mut key = [0u8; 32];
|
||||||
|
key.copy_from_slice(&swap_spec.key);
|
||||||
|
// swapper is not allowed to use `log` for debugging under most circumstances, because
|
||||||
|
// the swapper can't send messages when handling a swap call. Instead, we use a local
|
||||||
|
// debug UART to handle this. This needs to be enabled with the "debug-print" feature
|
||||||
|
// and is mutually exclusive with the "gdb-stub" feature in the kernel since it uses
|
||||||
|
// the same physical hardware.
|
||||||
|
sss.inner = Some(SwapperSharedState {
|
||||||
|
key,
|
||||||
|
// safety: this is only safe because:
|
||||||
|
// - the loader puts the swap root page table pages starting at SWAP_PT_VADDR
|
||||||
|
// - all the page table entries are fully initialized and contains only representable data
|
||||||
|
// - the length of the region is guaranteed by the loader
|
||||||
|
pts: SwapPageTables {
|
||||||
|
roots: unsafe {
|
||||||
|
core::slice::from_raw_parts_mut(
|
||||||
|
SWAP_PT_VADDR as *mut PtPage,
|
||||||
|
swap_spec.pid_count as usize,
|
||||||
|
)
|
||||||
|
},
|
||||||
|
},
|
||||||
|
macs: SwapMac::new(swap_spec.mac_base as usize, swap_spec.mac_len as usize),
|
||||||
|
// safety: this is only safe because the loader guarantees this raw pointer is initialized and
|
||||||
|
// aligned correctly
|
||||||
|
rpt: RuntimePageTracker {
|
||||||
|
allocs: unsafe {
|
||||||
|
core::slice::from_raw_parts_mut(
|
||||||
|
SWAP_RPT_VADDR as *mut u8,
|
||||||
|
swap_spec.rpt_len_bytes as usize,
|
||||||
|
)
|
||||||
|
},
|
||||||
|
},
|
||||||
|
});
|
||||||
|
}
|
||||||
|
let ss = sss.inner.as_mut().expect("Shared state should be initialized");
|
||||||
|
|
||||||
let op: Option<Opcode> = FromPrimitive::from_usize(opcode);
|
let op: Option<Opcode> = FromPrimitive::from_usize(opcode);
|
||||||
writeln!(ss.duart, "got Opcode: {:?}", op).ok();
|
writeln!(DebugUart {}, "got Opcode: {:?}", op).ok();
|
||||||
match op {
|
match op {
|
||||||
Some(Opcode::WriteToSwap) => {
|
Some(Opcode::WriteToSwap) => {
|
||||||
let pid = a2 as u8;
|
let pid = a2 as u8;
|
||||||
|
|
@ -144,6 +162,16 @@ fn swap_handler(
|
||||||
let pid = a2 as u8;
|
let pid = a2 as u8;
|
||||||
let vaddr_in_pid = a3;
|
let vaddr_in_pid = a3;
|
||||||
let vaddr_in_swap = a4;
|
let vaddr_in_swap = a4;
|
||||||
|
writeln!(
|
||||||
|
DebugUart {},
|
||||||
|
"rfs PID{}, vaddr_pid {:x}, vaddr_swap {:x}",
|
||||||
|
pid,
|
||||||
|
vaddr_in_pid,
|
||||||
|
vaddr_in_swap
|
||||||
|
)
|
||||||
|
.ok();
|
||||||
|
// walk the PT to find the swap data
|
||||||
|
// ss.pts[pid as usize]
|
||||||
}
|
}
|
||||||
Some(Opcode::AllocateAdvisory) => {
|
Some(Opcode::AllocateAdvisory) => {
|
||||||
let advisories = [
|
let advisories = [
|
||||||
|
|
@ -153,82 +181,60 @@ fn swap_handler(
|
||||||
];
|
];
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
writeln!(ss.duart, "Unimplemented or unknown opcode: {}", opcode).ok();
|
writeln!(DebugUart {}, "Unimplemented or unknown opcode: {}", opcode).ok();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
// swapper is not allowed to use `log` for debugging under most circumstances, because
|
|
||||||
// the swapper can't send messages when handling a swap call. Instead, we use a local
|
|
||||||
// debug UART to handle this. This needs to be enabled with the "debug-print" feature
|
|
||||||
// and is mutually exclusive with the "gdb-stub" feature in the kernel since it uses
|
|
||||||
// the same physical hardware.
|
|
||||||
let mut ss = SwapperSharedState::new();
|
|
||||||
|
|
||||||
let sid = xous::create_server().unwrap();
|
let sid = xous::create_server().unwrap();
|
||||||
|
let mut sss = SharedStateStorage { inner: None };
|
||||||
// Register the swapper with the kernel. Written as a raw syscall, since this is
|
// Register the swapper with the kernel. Written as a raw syscall, since this is
|
||||||
// the only instance of its use (no point in use-once code to wrap it).
|
// the only instance of its use (no point in use-once code to wrap it).
|
||||||
|
// This is an "early registration" which allows us to see debug output quickly,
|
||||||
|
// even before we can constitute all of our shared state
|
||||||
let (s0, s1, s2, s3) = sid.to_u32();
|
let (s0, s1, s2, s3) = sid.to_u32();
|
||||||
let (spt_init, smt_base_init, smt_bounds_init, rpt_init) =
|
xous::rsyscall(xous::SysCall::RegisterSwapper(
|
||||||
xous::rsyscall(xous::SysCall::RegisterSwapper(
|
s0,
|
||||||
s0,
|
s1,
|
||||||
s1,
|
s2,
|
||||||
s2,
|
s3,
|
||||||
s3,
|
swap_handler as *mut usize as usize,
|
||||||
swap_handler as *mut usize as usize,
|
&mut sss as *mut SharedStateStorage as usize,
|
||||||
&mut ss as *mut SwapperSharedState as usize,
|
))
|
||||||
))
|
.unwrap();
|
||||||
.and_then(|result| {
|
|
||||||
if let xous::Result::Scalar5(spt, smt_base, smt_bounds, rpt, _) = result {
|
|
||||||
Ok((spt, smt_base, smt_bounds, rpt))
|
|
||||||
} else {
|
|
||||||
panic!("Failed to register swapper");
|
|
||||||
}
|
|
||||||
})
|
|
||||||
.unwrap();
|
|
||||||
// safety: this is only safe because the loader guarantees this raw pointer is initialized and aligned
|
|
||||||
// correctly
|
|
||||||
let spt = unsafe { &mut *(spt_init as *mut SwapPageTables) };
|
|
||||||
#[cfg(feature = "precursor")]
|
|
||||||
let smt = SwapMacTableMemMap {
|
|
||||||
// safety: this is only safe because the loader guarantees memory-mapped SMT is initialized and
|
|
||||||
// aligned and properly mapped into the swapper's memory space.
|
|
||||||
macs: unsafe { core::slice::from_raw_parts_mut(smt_base_init as *mut [u8; 16], smt_bounds_init) },
|
|
||||||
};
|
|
||||||
#[cfg(feature = "cramium-soc")]
|
|
||||||
let smt = SwapMacTableSpi { base: smt_base_init, bounds: smt_bounds_init };
|
|
||||||
// safety: this is only safe because the loader guarantees this raw pointer is initialized and aligned
|
|
||||||
// correctly
|
|
||||||
let rpt = unsafe { &mut *(rpt_init as *mut RuntimePageTracker) };
|
|
||||||
|
|
||||||
writeln!(
|
|
||||||
ss.duart,
|
|
||||||
"Swap params: spt {:x}, base {:x}, bounds: {:x}, rpt: {:x}",
|
|
||||||
spt_init, smt_base_init, smt_bounds_init, rpt_init
|
|
||||||
)
|
|
||||||
.ok();
|
|
||||||
|
|
||||||
// init the log, but this is mostly unused.
|
// init the log, but this is mostly unused.
|
||||||
log_server::init_wait().unwrap();
|
log_server::init_wait().unwrap();
|
||||||
log::set_max_level(log::LevelFilter::Info);
|
log::set_max_level(log::LevelFilter::Info);
|
||||||
log::info!("my PID is {}", xous::process::id());
|
log::info!("my PID is {}", xous::process::id());
|
||||||
// test the debug serial port
|
|
||||||
writeln!(ss.duart, "Swapper started.").ok();
|
// check that we got called by the kernel -- this should happen really early in the process
|
||||||
|
// due to the advisory allocs that start piling up very quickly
|
||||||
|
if let Some(ss) = sss.inner {
|
||||||
|
log::info!(
|
||||||
|
"Swap params: key: {:x?}, root: {:x}, rpt: {:?}",
|
||||||
|
ss.key,
|
||||||
|
ss.pts.roots[0].entries[0],
|
||||||
|
&ss.rpt.allocs[..8]
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
log::info!("Swapper did not get called to initialize its shared state.")
|
||||||
|
}
|
||||||
|
|
||||||
let mut msg_opt = None;
|
let mut msg_opt = None;
|
||||||
loop {
|
loop {
|
||||||
xous::reply_and_receive_next(sid, &mut msg_opt).unwrap();
|
xous::reply_and_receive_next(sid, &mut msg_opt).unwrap();
|
||||||
let msg = msg_opt.as_mut().unwrap();
|
let msg = msg_opt.as_mut().unwrap();
|
||||||
let op: Option<Opcode> = FromPrimitive::from_usize(msg.body.id());
|
let op: Option<Opcode> = FromPrimitive::from_usize(msg.body.id());
|
||||||
writeln!(ss.duart, "Swapper got {:?}", msg).ok();
|
log::info!("Swapper got {:?}", msg);
|
||||||
match op {
|
match op {
|
||||||
Some(Opcode::WriteToSwap) => {
|
Some(Opcode::WriteToSwap) => {
|
||||||
unimplemented!();
|
unimplemented!();
|
||||||
}
|
}
|
||||||
// ... todo, other opcodes.
|
// ... todo, other opcodes.
|
||||||
_ => {
|
_ => {
|
||||||
write!(ss.duart, "Unknown opcode {:?}", op).ok();
|
log::info!("Unknown opcode {:?}", op);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue