split memory allocs into RAM and peripheral tables

RAM allocs can be augmented with more tracking data in the case of
swap.
This commit is contained in:
bunnie 2024-05-12 20:22:51 +08:00
parent f657caa176
commit 903c903b2f
4 changed files with 94 additions and 44 deletions

View file

@ -104,14 +104,12 @@ pub extern "C" fn start_kernel(
args: usize, args: usize,
ss: usize, ss: usize,
rpt: usize, rpt: usize,
xpt: usize,
satp: usize, satp: usize,
entrypoint: usize, entrypoint: usize,
stack: usize, stack: usize,
debug_: bool, debug_resume: usize,
resume_: bool,
) -> ! { ) -> ! {
let debug: usize = if debug_ { 1 } else { 0 };
let resume: usize = if resume_ { 1 } else { 0 };
unsafe { unsafe {
#[rustfmt::skip] #[rustfmt::skip]
asm! ( asm! (
@ -119,7 +117,7 @@ pub extern "C" fn start_kernel(
"mv a0, {args}", "mv a0, {args}",
"mv a1, {ss}", "mv a1, {ss}",
"mv a2, {rpt}", "mv a2, {rpt}",
"mv a7, {resume}", "mv a3, {xpt}",
// Delegate as much as we can supervisor mode // Delegate as much as we can supervisor mode
"li t0, 0xffffffff", "li t0, 0xffffffff",
"csrw mideleg, t0", "csrw mideleg, t0",
@ -128,13 +126,14 @@ pub extern "C" fn start_kernel(
// Return to Supervisor mode (1 << 11) when we call `reti`. // Return to Supervisor mode (1 << 11) when we call `reti`.
// Disable interrupts (0 << 5) // Disable interrupts (0 << 5)
"li t0, (1 << 11) | (0 << 5)", "li t0, (1 << 11) | (0 << 5)",
// If arg6 is "true", also set mstatus.SUM to allow the kernel // If debug_resume is "true", also set mstatus.SUM to allow the kernel
// to access userspace memory. // to access userspace memory.
"mv a6, {debug}", "mv t3, {debug_resume}",
"andi a6, a6, 1", "andi t3, t3, 1",
"slli a6, a6, 18", "slli t3, t3, 18",
"or t0, t0, a6", "or t0, t0, t3",
"csrw mstatus, t0", "csrw mstatus, t0",
"mv a7, {debug_resume}",
// Enable the MMU (once we issue `mret`) and flush the cache // Enable the MMU (once we issue `mret`) and flush the cache
"csrw satp, {satp}", "csrw satp, {satp}",
@ -151,11 +150,11 @@ pub extern "C" fn start_kernel(
args = in(reg) args, args = in(reg) args,
ss = in(reg) ss, ss = in(reg) ss,
rpt = in(reg) rpt, rpt = in(reg) rpt,
xpt = in(reg) xpt,
satp = in(reg) satp, satp = in(reg) satp,
entrypoint = in(reg) entrypoint, entrypoint = in(reg) entrypoint,
stack = in(reg) stack, stack = in(reg) stack,
debug = in(reg) debug, debug_resume = in(reg) debug_resume,
resume = in(reg) resume,
options(noreturn) options(noreturn)
); );
} }

View file

@ -44,9 +44,16 @@ pub struct BootConfig {
pub extra_pages: usize, pub extra_pages: usize,
/// This structure keeps track of which pages are owned /// This structure keeps track of which pages are owned
/// and which are free. A PID of `0` indicates it's free. /// and which are free in main RAM. A PID of `0` indicates it's free.
/// Because this area is swappable, a type alias of XousAlloc allows
/// us to expand the tracking for the RAM area.
pub runtime_page_tracker: &'static mut [XousAlloc], pub runtime_page_tracker: &'static mut [XousAlloc],
/// This structure keeps track of which pages are owned
/// and which are free in non-RAM areas. A PID of `0` indicates it's free.
/// These areas are non-swappable, so the tracking is a simple XousPid
pub extra_page_tracker: &'static mut [XousPid],
/// A list of processes that were set up. The first element /// A list of processes that were set up. The first element
/// is the kernel, and any subsequent elements are init processes. /// is the kernel, and any subsequent elements are init processes.
pub processes: &'static mut [InitialProcess], pub processes: &'static mut [InitialProcess],
@ -96,6 +103,7 @@ impl Default for BootConfig {
init_size: 0, init_size: 0,
extra_pages: 0, extra_pages: 0,
runtime_page_tracker: Default::default(), runtime_page_tracker: Default::default(),
extra_page_tracker: Default::default(),
init_process_count: 0, init_process_count: 0,
processes: Default::default(), processes: Default::default(),
swap_offset: 0, swap_offset: 0,
@ -162,16 +170,16 @@ impl BootConfig {
return; return;
} }
// The region isn't in RAM, so check the other memory regions. // The region isn't in RAM, so check the other memory regions.
let mut rpt_offset = self.sram_size / PAGE_SIZE; let mut xpt_offset = 0;
for region in self.regions.iter() { for region in self.regions.iter() {
let rstart = region.start as usize; let rstart = region.start as usize;
let rlen = region.length as usize; let rlen = region.length as usize;
if addr >= rstart && addr < rstart + rlen { if addr >= rstart && addr < rstart + rlen {
self.runtime_page_tracker[rpt_offset + (addr - rstart) / PAGE_SIZE] = XousAlloc::from(pid); self.extra_page_tracker[xpt_offset + (addr - rstart) / PAGE_SIZE] = XousPid::from(pid);
return; return;
} }
rpt_offset += rlen / PAGE_SIZE; xpt_offset += rlen / PAGE_SIZE;
} }
panic!("Tried to change region {:08x} that isn't in defined memory!", addr); panic!("Tried to change region {:08x} that isn't in defined memory!", addr);
} }

View file

@ -212,6 +212,8 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64]) -
resume_csr.wfo(utra::susres::INTERRUPT_INTERRUPT, 1); resume_csr.wfo(utra::susres::INTERRUPT_INTERRUPT, 1);
} }
// condense debug and resume arguments into a single register, so we have space for XPT
let debug_resume = if cfg.debug { 0x1 } else { 0x0 } | if clean { 0x2 } else { 0x0 };
if !clean { if !clean {
// The MMU should be set up now, and memory pages assigned to their // The MMU should be set up now, and memory pages assigned to their
// respective processes. // respective processes.
@ -241,13 +243,20 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64]) -
let ip_offset = cfg.processes.as_ptr() as usize - krn_struct_start + KERNEL_ARGUMENT_OFFSET; let ip_offset = cfg.processes.as_ptr() as usize - krn_struct_start + KERNEL_ARGUMENT_OFFSET;
let rpt_offset = let rpt_offset =
cfg.runtime_page_tracker.as_ptr() as usize - krn_struct_start + KERNEL_ARGUMENT_OFFSET; cfg.runtime_page_tracker.as_ptr() as usize - krn_struct_start + KERNEL_ARGUMENT_OFFSET;
let xpt_offset = cfg.extra_page_tracker.as_ptr() as usize - krn_struct_start + KERNEL_ARGUMENT_OFFSET;
#[cfg(not(feature = "atsama5d27"))] #[cfg(not(feature = "atsama5d27"))]
let _tt_addr = { cfg.processes[0].satp }; let _tt_addr = { cfg.processes[0].satp };
#[cfg(feature = "atsama5d27")] #[cfg(feature = "atsama5d27")]
let _tt_addr = { cfg.processes[0].ttbr0 }; let _tt_addr = { cfg.processes[0].ttbr0 };
println!( println!(
"Jumping to kernel @ {:08x} with map @ {:08x} and stack @ {:08x} (kargs: {:08x}, ip: {:08x}, rpt: {:08x})", "Jumping to kernel @ {:08x} with map @ {:08x} and stack @ {:08x} (kargs: {:08x}, ip: {:08x}, rpt: {:08x}, xpt: {:08x})",
cfg.processes[0].entrypoint, _tt_addr, cfg.processes[0].sp, arg_offset, ip_offset, rpt_offset, cfg.processes[0].entrypoint,
_tt_addr,
cfg.processes[0].sp,
arg_offset,
ip_offset,
rpt_offset,
xpt_offset,
); );
// save a copy of the computed kernel registers at the bottom of the page reserved // save a copy of the computed kernel registers at the bottom of the page reserved
@ -260,7 +269,7 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64]) -
// critical parameters like these kernel arguments. // critical parameters like these kernel arguments.
#[cfg(not(feature = "atsama5d27"))] #[cfg(not(feature = "atsama5d27"))]
unsafe { unsafe {
let backup_args: *mut [u32; 7] = BACKUP_ARGS_ADDR as *mut [u32; 7]; let backup_args: *mut [u32; 8] = BACKUP_ARGS_ADDR as *mut [u32; 8];
(*backup_args)[0] = arg_offset as u32; (*backup_args)[0] = arg_offset as u32;
(*backup_args)[1] = ip_offset as u32; (*backup_args)[1] = ip_offset as u32;
(*backup_args)[2] = rpt_offset as u32; (*backup_args)[2] = rpt_offset as u32;
@ -268,12 +277,13 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64]) -
(*backup_args)[4] = cfg.processes[0].entrypoint as u32; (*backup_args)[4] = cfg.processes[0].entrypoint as u32;
(*backup_args)[5] = cfg.processes[0].sp as u32; (*backup_args)[5] = cfg.processes[0].sp as u32;
(*backup_args)[6] = if cfg.debug { 1 } else { 0 }; (*backup_args)[6] = if cfg.debug { 1 } else { 0 };
(*backup_args)[7] = xpt_offset as u32;
#[cfg(feature = "debug-print")] #[cfg(feature = "debug-print")]
{ {
if VDBG { if VDBG {
println!("Backup kernel args:"); println!("Backup kernel args:");
for i in 0..7 { for &arg in (*backup_args).iter() {
println!("0x{:08x}", (*backup_args)[i]); println!("0x{:08x}", arg);
} }
} }
} }
@ -293,11 +303,11 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64]) -
arg_offset, arg_offset,
ip_offset, ip_offset,
rpt_offset, rpt_offset,
xpt_offset,
cfg.processes[0].satp, cfg.processes[0].satp,
cfg.processes[0].entrypoint, cfg.processes[0].entrypoint,
cfg.processes[0].sp, cfg.processes[0].sp,
cfg.debug, debug_resume,
clean,
); );
} }
@ -310,19 +320,19 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64]) -
arg_offset, arg_offset,
ip_offset, ip_offset,
rpt_offset, rpt_offset,
cfg.debug, xpt_offset,
clean, debug_resume,
) )
} }
} else { } else {
#[cfg(feature = "resume")] #[cfg(feature = "resume")]
unsafe { unsafe {
let backup_args: *mut [u32; 7] = BACKUP_ARGS_ADDR as *mut [u32; 7]; let backup_args: *mut [u32; 8] = BACKUP_ARGS_ADDR as *mut [u32; 8];
#[cfg(feature = "debug-print")] #[cfg(feature = "debug-print")]
{ {
println!("Using backed up kernel args:"); println!("Using backed up kernel args:");
for i in 0..7 { for &arg in (*backup_args).iter() {
println!("0x{:08x}", (*backup_args)[i]); println!("0x{:08x}", arg);
} }
} }
let satp = ((*backup_args)[3] as usize) & 0x803F_FFFF | (((susres_pid as usize) & 0x1FF) << 22); let satp = ((*backup_args)[3] as usize) & 0x803F_FFFF | (((susres_pid as usize) & 0x1FF) << 22);
@ -344,11 +354,11 @@ fn boot_sequence(args: KernelArguments, _signature: u32, fs_prehash: [u8; 64]) -
(*backup_args)[0] as usize, (*backup_args)[0] as usize,
(*backup_args)[1] as usize, (*backup_args)[1] as usize,
(*backup_args)[2] as usize, (*backup_args)[2] as usize,
(*backup_args)[7] as usize,
satp as usize, satp as usize,
(*backup_args)[4] as usize, (*backup_args)[4] as usize,
(*backup_args)[5] as usize, (*backup_args)[5] as usize,
if (*backup_args)[6] == 0 { false } else { true }, debug_resume,
clean,
); );
} }
#[cfg(not(feature = "resume"))] #[cfg(not(feature = "resume"))]

View file

@ -100,7 +100,7 @@ pub fn phase_1(cfg: &mut BootConfig) {
// needs to be claimed by the susres server before the kernel allocates it. // needs to be claimed by the susres server before the kernel allocates it.
// Lower numbered indices corresponding to higher address pages. // Lower numbered indices corresponding to higher address pages.
println!("Marking pages as in-use"); println!("Marking pages as in-use");
for i in 4..(cfg.init_size / PAGE_SIZE) { for i in ((GUARD_MEMORY_BYTES / PAGE_SIZE) + 1)..(cfg.init_size / PAGE_SIZE) {
cfg.runtime_page_tracker[cfg.sram_size / PAGE_SIZE - i] = XousAlloc::from(1); cfg.runtime_page_tracker[cfg.sram_size / PAGE_SIZE - i] = XousAlloc::from(1);
} }
} }
@ -111,18 +111,7 @@ pub fn allocate_regions(cfg: &mut BootConfig) {
// Number of individual pages in the system // Number of individual pages in the system
let mut rpt_pages = cfg.sram_size / PAGE_SIZE; let mut rpt_pages = cfg.sram_size / PAGE_SIZE;
for region in cfg.regions.iter() { // allocate the RPT
println!(
"Discovered memory region {:08x} ({:08x} - {:08x}) -- {} bytes",
region.name,
region.start,
region.start + region.length,
region.length
);
let region_length_rounded = (region.length as usize + PAGE_SIZE - 1) & !(PAGE_SIZE - 1);
rpt_pages += region_length_rounded / PAGE_SIZE;
}
#[cfg(not(feature = "swap"))] #[cfg(not(feature = "swap"))]
{ {
// Round the tracker to a multiple of the pointer size, so as to keep memory // Round the tracker to a multiple of the pointer size, so as to keep memory
@ -135,7 +124,7 @@ pub fn allocate_regions(cfg: &mut BootConfig) {
rpt_pages = (rpt_pages + PAGE_SIZE - 1) & !(PAGE_SIZE - 1); rpt_pages = (rpt_pages + PAGE_SIZE - 1) & !(PAGE_SIZE - 1);
} }
println!( println!(
"init_size bef: {:x}, ext pages: {:x}, rpt alloc: {:x}", "RPT ALLOC init_size before: {:x}, ext pages: {:x}, rpt alloc: {:x}",
cfg.init_size, cfg.init_size,
cfg.extra_pages, cfg.extra_pages,
rpt_pages * mem::size_of::<XousAlloc>() rpt_pages * mem::size_of::<XousAlloc>()
@ -165,6 +154,50 @@ pub fn allocate_regions(cfg: &mut BootConfig) {
runtime_page_tracker as usize + rpt_pages * core::mem::size_of::<XousAlloc>() runtime_page_tracker as usize + rpt_pages * core::mem::size_of::<XousAlloc>()
); );
} }
// allocate the XPT
let mut xpt_pages = 0;
for region in cfg.regions.iter() {
println!(
"Discovered memory region {:08x} ({:08x} - {:08x}) -- {} bytes",
region.name,
region.start,
region.start + region.length,
region.length
);
let region_length_rounded = (region.length as usize + PAGE_SIZE - 1) & !(PAGE_SIZE - 1);
xpt_pages += region_length_rounded / PAGE_SIZE;
}
// Round the tracker to a multiple of the pointer size, so as to keep memory
// operations fast.
xpt_pages = (xpt_pages + mem::size_of::<usize>() - 1) & !(mem::size_of::<usize>() - 1);
println!(
"XPT ALLOC init_size bef: {:x}, ext pages: {:x}, rpt alloc: {:x}",
cfg.init_size,
cfg.extra_pages,
xpt_pages * mem::size_of::<XousPid>()
);
cfg.init_size += xpt_pages * mem::size_of::<XousPid>();
// Clear all memory pages such that they're not owned by anyone
let extra_page_tracker = cfg.get_top();
println!("rpt value: {:x}", extra_page_tracker as usize);
assert!((extra_page_tracker as usize) < (cfg.sram_start as usize) + cfg.sram_size);
unsafe {
bzero(extra_page_tracker, extra_page_tracker.add(xpt_pages / mem::size_of::<usize>()));
}
cfg.extra_page_tracker =
unsafe { slice::from_raw_parts_mut(extra_page_tracker as *mut XousPid, xpt_pages) };
#[cfg(feature = "swap")]
if SDBG {
println!(
" -> XPT range: {:x} - {:x}",
extra_page_tracker as usize,
extra_page_tracker as usize + xpt_pages * core::mem::size_of::<XousPid>()
);
}
} }
pub fn allocate_processes(cfg: &mut BootConfig) { pub fn allocate_processes(cfg: &mut BootConfig) {