refactor the swapper to absorb the HALs developed for the loader

Remove the stand-in swapper functions we put in...oh god, so many
weeks, months ago...and replace it with actual battle-tested APIs
from the loader.
This commit is contained in:
bunnie 2024-05-03 16:05:58 +08:00
parent f708322a1e
commit ce20fdff8b
4 changed files with 247 additions and 30 deletions

View file

@ -18,13 +18,18 @@ num-derive = { version = "0.3.3", default-features = false }
num-traits = { version = "0.2.14", default-features = false }
log = "0.4.14"
loader = { path = "../../loader", features = ["swap"] }
aes-gcm-siv = { version = "0.11.1", default-features = false, features = [
"aes",
] }
cramium-hal = { path = "../../libs/cramium-hal", optional = true, default_features = false }
utralib = { version = "0.1.24", optional = true, default-features = false }
[target.'cfg(any(windows,unix))'.dependencies]
[features]
cramium-soc = ["utralib/cramium-soc"]
cramium-soc = ["utralib/cramium-soc", "cramium-hal"]
spi-alt-channel = [] # needs to match loader setting!
cramium-fpga = ["utralib/cramium-fpga"]
precursor = ["utralib/precursor"]
hosted = ["utralib/hosted"]

View file

@ -5,7 +5,7 @@ use core::sync::atomic::{AtomicUsize, Ordering};
use loader::swap::{SwapSpec, SWAP_CFG_VADDR, SWAP_PT_VADDR, SWAP_RPT_VADDR};
use num_traits::FromPrimitive;
use platform::SwapMac;
use platform::SwapHal;
use utralib::*;
static DUART_CSR_PA: AtomicUsize = AtomicUsize::new(0);
@ -76,11 +76,31 @@ impl Write for DebugUart {
/// This structure contains shared state accessible between the userspace code and the blocking swap call
/// handler.
struct SwapperSharedState {
pub key: [u8; 32],
pub pts: SwapPageTables,
pub macs: SwapMac,
pub hal: SwapHal,
pub rpt: RuntimePageTracker,
}
impl SwapperSharedState {
pub fn pt_walk(&self, pid: u8, va: usize) -> Option<usize> {
let l1_pt = &self.pts.roots[pid as usize - 1];
let l1_entry = (l1_pt.entries[(va & 0xFFC0_0000) >> 22] >> 10) << 12;
if l1_entry != 0 {
// this is safe because all possible values can be represented as `u32`, the pointer
// is valid, aligned, and the bounds are known.
let l0_pt = unsafe { core::slice::from_raw_parts(l1_entry as *const u32, 1024) };
let l0_entry = l0_pt[(va & 0x003F_F000) >> 12];
if l0_entry & 1 != 0 {
// bit 1 is the "valid" bit
Some(((l0_entry as usize >> 10) << 12) | va & 0xFFF)
} else {
None
}
} else {
None
}
}
}
struct SharedStateStorage {
pub inner: Option<SwapperSharedState>,
}
@ -113,16 +133,12 @@ fn swap_handler(
// 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
@ -135,7 +151,7 @@ fn swap_handler(
)
},
},
macs: SwapMac::new(swap_spec.mac_base as usize, swap_spec.mac_len as usize),
hal: SwapHal::new(swap_spec),
// safety: this is only safe because the loader guarantees this raw pointer is initialized and
// aligned correctly
rpt: RuntimePageTracker {
@ -164,14 +180,22 @@ fn swap_handler(
let vaddr_in_swap = a4;
writeln!(
DebugUart {},
"rfs PID{}, vaddr_pid {:x}, vaddr_swap {:x}",
"rfs ptw 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]
let paddr_in_swap = ss.pt_walk(pid as u8, vaddr_in_pid);
writeln!(
DebugUart {},
"resolved address in swap for 0x{:x}:{} -> 0x{:x?}",
vaddr_in_pid,
pid,
paddr_in_swap
)
.ok();
}
Some(Opcode::AllocateAdvisory) => {
let advisories = [
@ -213,8 +237,7 @@ fn main() {
// 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,
"Swap params: key: root: {:x}, rpt: {:?}",
ss.pts.roots[0].entries[0],
&ss.rpt.allocs[..8]
);

View file

@ -1,14 +1,110 @@
use core::mem::size_of;
use aes_gcm_siv::{aead::Aead, AeadInPlace, Aes256GcmSiv, Error, KeyInit, Nonce, Tag};
use cramium_hal::udma::*;
use loader::swap::{SwapSpec, SPIM_RAM_IFRAM_ADDR};
use num_traits::ToBytes;
pub const PAGE_SIZE: usize = 4096;
/// 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 SwapMac {
pub base: usize,
pub bounds: usize,
pub struct SwapHal {
swap_mac_start: usize,
cipher: Aes256GcmSiv,
ram_spim: Spim,
}
impl SwapMac {
pub fn new(base: usize, bounds: usize) -> Self { SwapMac { base, bounds } }
impl SwapHal {
pub fn new(spec: &SwapSpec) -> Self {
// compute the MAC area needed for the total RAM size. This is a slight over-estimate
// because once we remove the MAC area, we need even less storage, but it's a small error.
let mac_size = (spec.swap_len as usize / 4096) * size_of::<Tag>();
let mac_size_to_page = (mac_size + (PAGE_SIZE - 1)) & !(PAGE_SIZE - 1);
let ram_size_actual = (spec.swap_len as usize & !(PAGE_SIZE - 1)) - mac_size_to_page;
pub fn lookup_mac(&self, swap_page_offset: usize) -> [u8; 16] { todo!() }
#[cfg(feature = "spi-alt-channel")]
let channel = SpimChannel::Channel0;
#[cfg(not(feature = "spi-alt-channel"))]
let channel = SpimChannel::Channel1;
SwapMac {
swap_mac_start: ram_size_actual,
cipher: Aes256GcmSiv::new((spec.key).into()),
// safety: this is safe because the global clocks were gated on by the bootloader
// note that also the IFRAM0 range is pre-allocated by the bootloader
ram_spim: unsafe {
Spim::new_with_ifram(
channel,
50_000_000,
50_000_000,
SpimClkPol::LeadingEdgeRise,
SpimClkPha::CaptureOnLeading,
SpimCs::Cs1,
0,
0,
None,
1024, // this is limited by the page length
1024,
Some(6),
IframRange::from_raw_parts(SPIM_RAM_IFRAM_ADDR, SPIM_RAM_IFRAM_ADDR, 4096),
)
},
}
}
pub fn store_mac(&mut self, swap_page_offset: usize, mac: &[u8; 16]) { todo!() }
/// `buf` contents are replaced with encrypted data
pub fn encrypt_swap_to(
&mut self,
buf: &mut [u8],
swap_count: u32,
dest_offset: usize,
src_vaddr: usize,
src_pid: u8,
) {
assert!(buf.len() == PAGE_SIZE);
assert!(dest_offset & (PAGE_SIZE - 1) == 0);
let mut nonce = [0u8; size_of::<Nonce>()];
nonce[0..4].copy_from_slice(&swap_count.to_be_bytes()); // this is the `swap_count` field
nonce[5] = src_pid;
let ppage_masked = dest_offset & !(PAGE_SIZE - 1);
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
let vpage_masked = src_vaddr & !(PAGE_SIZE - 1);
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
let aad: &[u8] = &[];
match self.cipher.encrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf) {
Ok(tag) => {
self.ram_spim.mem_ram_write(dest_offset as u32, buf);
self.ram_spim.mem_ram_write(
(self.swap_mac_start + (dest_offset / PAGE_SIZE) * size_of::<Tag>()) as u32,
tag.as_slice(),
);
}
Err(e) => panic!("Encryption error to swap ram: {:?}", e),
}
}
pub fn decrypt_swap_from(
&mut self,
buf: &mut [u8],
swap_count: u32,
src_offset: usize,
dst_vaddr: usize,
dst_pid: u8,
) -> Result<(), Error> {
assert!(src_offset & (PAGE_SIZE - 1) == 0);
assert!(buf.len() == PAGE_SIZE);
let mut nonce = [0u8; size_of::<Nonce>()];
nonce[0..4].copy_from_slice(&swap_count.to_be_bytes()); // this is the `swap_count` field
nonce[5] = dst_pid;
let ppage_masked = src_offset & !(PAGE_SIZE - 1);
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
let vpage_masked = dst_vaddr & !(PAGE_SIZE - 1);
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
let aad: &[u8] = &[];
let mut tag = [0u8; size_of::<Tag>()];
self.ram_spim
.mem_read((self.swap_mac_start + (src_offset / PAGE_SIZE) * size_of::<Tag>()) as u32, &mut tag);
self.ram_spim.mem_read(src_offset as u32, buf);
self.cipher.decrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf, (&tag).into())
}
}

View file

@ -1,18 +1,111 @@
use core::mem::size_of;
use aes_gcm_siv::{AeadInPlace, Aes256GcmSiv, Error, KeyInit, Nonce, Tag};
use loader::swap::SwapSpec;
use xous::MemoryRange;
pub const PAGE_SIZE: usize = 4096;
/// This defines a set of functions to get and receive MACs (message
/// authentication codes, also referred to as the tag in AES-GCM-SIV.
pub struct SwapMac {
pub macs: &'static mut [[u8; 16]],
pub struct SwapHal {
swap_mem: MemoryRange,
dst_data_area: &'static mut [u8],
dst_mac_area: &'static mut [u8],
cipher: Aes256GcmSiv,
}
impl SwapMac {
pub fn new(base: usize, bounds: usize) -> Self {
SwapMac {
// 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(base as *mut [u8; 16], bounds as usize / 16) },
impl SwapHal {
pub fn new(spec: &SwapSpec) -> Self {
let swap_mem = xous::syscall::map_memory(
xous::MemoryAddress::new(spec.swap_base as usize),
None,
spec.swap_len as usize,
xous::MemoryFlags::R | xous::MemoryFlags::W,
)
.expect("Couldn't map swap area into swapper");
// compute the MAC area needed for the total RAM size. This is a slight over-estimate
// because once we remove the MAC area, we need even less storage, but it's a small error.
let mac_size = (spec.swap_len as usize / 4096) * size_of::<Tag>();
let mac_size_to_page = (mac_size + (PAGE_SIZE - 1)) & !(PAGE_SIZE - 1);
let ram_size_actual = (spec.swap_len as usize & !(PAGE_SIZE - 1)) - mac_size_to_page;
// safety: this is safe because all values within the memory region can be represented in `u8`
let swap_slice = swap_mem.as_mut_ptr();
Self {
swap_mem,
// safety: the ram swap area is guaranteed aligned by the ram_offset specifier, and our
// calculations on lengths ensure area alignment
dst_data_area: unsafe { core::slice::from_raw_parts_mut(swap_slice as *mut u8, ram_size_actual) },
// safety: the ram swap area is guaranteed aligned by the ram_offset specifier, and our
// calculations on lengths ensure area alignment
dst_mac_area: unsafe {
core::slice::from_raw_parts_mut((swap_slice as *mut u8).add(ram_size_actual), mac_size)
},
cipher: Aes256GcmSiv::new((&spec.key).into()),
}
}
pub fn lookup_mac(&self, swap_page_offset: usize) -> [u8; 16] { todo!() }
/// The data to be encrypted is provided in `buf`, and is replaced with part of the encrypted data upon
/// completion of the routine.
pub fn encrypt_swap_to(
&mut self,
buf: &mut [u8],
swap_count: u32,
dest_offset: usize,
src_vaddr: usize,
src_pid: u8,
) {
// println!("enc_to: pid: {}, src_vaddr: {:x} dest_offset: {:x}", src_pid, src_vaddr, dest_offset);
assert!(buf.len() == PAGE_SIZE);
assert!(dest_offset & (PAGE_SIZE - 1) == 0);
let mut nonce = [0u8; size_of::<Nonce>()];
nonce[0..4].copy_from_slice(&swap_count.to_be_bytes()); // this is the `swap_count` field
nonce[5] = src_pid;
let ppage_masked = dest_offset & !(PAGE_SIZE - 1);
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
let vpage_masked = src_vaddr & !(PAGE_SIZE - 1);
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
let aad: &[u8] = &[];
match self.cipher.encrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf) {
Ok(tag) => {
self.dst_data_area[dest_offset..dest_offset + PAGE_SIZE].copy_from_slice(buf);
let mac_offset = (dest_offset / PAGE_SIZE) * size_of::<Tag>();
self.dst_mac_area[mac_offset..mac_offset + size_of::<Tag>()].copy_from_slice(tag.as_slice());
// println!("Nonce: {:x?}, tag: {:x?}", &nonce, tag.as_slice());
// println!("dst_mac_area: {:x?}", &self.dst_mac_area[..32]);
}
Err(e) => panic!("Encryption error to swap ram: {:?}", e),
}
}
pub fn store_mac(&mut self, swap_page_offset: usize, mac: &[u8; 16]) { todo!() }
/// Used to examine contents of swap RAM. Decrypted data is returned as a slice.
pub fn decrypt_swap_from(
&mut self,
buf: &mut [u8],
swap_count: u32,
src_offset: usize,
dst_vaddr: usize,
dst_pid: u8,
) -> Result<(), Error> {
// println!("Decrypt swap:");
// println!(" offset: {:x}, vaddr: {:x}, pid: {}", src_offset, dst_vaddr, dst_pid);
assert!(src_offset & (PAGE_SIZE - 1) == 0);
assert!(buf.len() == PAGE_SIZE);
let mut nonce = [0u8; size_of::<Nonce>()];
nonce[0..4].copy_from_slice(&swap_count.to_be_bytes()); // this is the `swap_count` field
nonce[5] = dst_pid;
let ppage_masked = src_offset & !(PAGE_SIZE - 1);
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
let vpage_masked = dst_vaddr & !(PAGE_SIZE - 1);
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
let aad: &[u8] = &[];
let mut tag = [0u8; size_of::<Tag>()];
let mac_offset = (src_offset / PAGE_SIZE) * size_of::<Tag>();
tag.copy_from_slice(&self.dst_mac_area[mac_offset..mac_offset + size_of::<Tag>()]);
// println!("dst_mac_area: {:x?}", &self.dst_mac_area[..32]);
buf.copy_from_slice(&self.dst_data_area[src_offset..src_offset + PAGE_SIZE]);
// println!("Nonce: {:x?}, tag: {:x?}", &nonce, &tag);
self.cipher.decrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf, (&tag).into())
}
}