mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
correspending kernel changes for run time page tracker split
memory alloc table split into RAM region and everything else ("extra")
This commit is contained in:
parent
903c903b2f
commit
84d42460eb
3 changed files with 65 additions and 35 deletions
|
|
@ -30,6 +30,7 @@ _start:
|
|||
|
||||
/////// resume prep code
|
||||
// if resume flag is false (0), skip this section
|
||||
andi a7, a7, 0x2 // select just the resume flag
|
||||
beq a7, zero, coldboot
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -41,12 +41,17 @@ use xous_kernel::*;
|
|||
/// # Safety
|
||||
///
|
||||
/// This is safe to call only to initialize the kernel.
|
||||
pub unsafe extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32) {
|
||||
pub unsafe extern "C" fn init(
|
||||
arg_offset: *const u32,
|
||||
init_offset: *const u32,
|
||||
rpt_offset: usize,
|
||||
xpt_offset: usize,
|
||||
) {
|
||||
args::KernelArguments::init(arg_offset);
|
||||
let args = args::KernelArguments::get();
|
||||
// Everything needs memory, so the first thing we should do is initialize the memory manager.
|
||||
crate::mem::MemoryManager::with_mut(|mm| {
|
||||
mm.init_from_memory(rpt_offset, &args).expect("couldn't initialize memory manager")
|
||||
mm.init_from_memory(rpt_offset, xpt_offset, &args).expect("couldn't initialize memory manager")
|
||||
});
|
||||
SystemServices::with_mut(|system_services| system_services.init_from_memory(init_offset, &args));
|
||||
|
||||
|
|
|
|||
|
|
@ -106,6 +106,7 @@ static mut MEMORY_ALLOCATIONS: &mut [SwapAlloc] = &mut [];
|
|||
#[cfg(baremetal)]
|
||||
#[cfg(not(feature = "swap"))]
|
||||
static mut MEMORY_ALLOCATIONS: &mut [Option<PID>] = &mut [];
|
||||
static mut EXTRA_ALLOCATIONS: &mut [Option<PID>] = &mut [];
|
||||
#[cfg(feature = "swap")]
|
||||
static mut SWAP_TIMESTAMP: u64 = 0;
|
||||
#[cfg(baremetal)]
|
||||
|
|
@ -165,7 +166,8 @@ impl MemoryManager {
|
|||
#[cfg(baremetal)]
|
||||
pub fn init_from_memory(
|
||||
&mut self,
|
||||
base: *mut u32,
|
||||
rpt_base: usize,
|
||||
xpt_base: usize,
|
||||
args: &crate::args::KernelArguments,
|
||||
) -> Result<(), xous_kernel::Error> {
|
||||
use core::slice;
|
||||
|
|
@ -180,7 +182,8 @@ impl MemoryManager {
|
|||
self.ram_size = xarg_def.data[3] as usize;
|
||||
self.ram_name = xarg_def.data[4];
|
||||
|
||||
let mut mem_size = self.ram_size / PAGE_SIZE;
|
||||
let mem_size = self.ram_size / PAGE_SIZE;
|
||||
let mut extra_size = 0;
|
||||
for tag in args_iter {
|
||||
if tag.name == u32::from_le_bytes(*b"MREx") {
|
||||
unsafe {
|
||||
|
|
@ -200,17 +203,18 @@ impl MemoryManager {
|
|||
|
||||
unsafe {
|
||||
for range in EXTRA_REGIONS.iter() {
|
||||
mem_size += range.mem_size as usize / PAGE_SIZE;
|
||||
extra_size += range.mem_size as usize / PAGE_SIZE;
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "swap")]
|
||||
unsafe {
|
||||
MEMORY_ALLOCATIONS = slice::from_raw_parts_mut(base as *mut SwapAlloc, mem_size)
|
||||
MEMORY_ALLOCATIONS = slice::from_raw_parts_mut(rpt_base as *mut SwapAlloc, mem_size)
|
||||
};
|
||||
#[cfg(not(feature = "swap"))]
|
||||
unsafe {
|
||||
MEMORY_ALLOCATIONS = slice::from_raw_parts_mut(base as *mut Option<PID>, mem_size)
|
||||
MEMORY_ALLOCATIONS = slice::from_raw_parts_mut(rpt_base as *mut Option<PID>, mem_size)
|
||||
};
|
||||
unsafe { EXTRA_ALLOCATIONS = slice::from_raw_parts_mut(xpt_base as *mut Option<PID>, extra_size) }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -242,7 +246,9 @@ impl MemoryManager {
|
|||
|
||||
#[cfg(all(baremetal, feature = "print-debug"))]
|
||||
pub fn print_ownership(&self) {
|
||||
println!("Ownership ({} bytes in all):", unsafe { MEMORY_ALLOCATIONS.len() });
|
||||
println!("Ownership ({} bytes in all):", unsafe {
|
||||
MEMORY_ALLOCATIONS.len() + EXTRA_ALLOCATIONS.len()
|
||||
});
|
||||
|
||||
let mut offset = 0;
|
||||
unsafe {
|
||||
|
|
@ -267,7 +273,7 @@ impl MemoryManager {
|
|||
}
|
||||
}
|
||||
|
||||
offset += self.ram_size / PAGE_SIZE;
|
||||
offset = 0;
|
||||
|
||||
// Go through additional regions looking for this address, and claim it
|
||||
// if it's not in use.
|
||||
|
|
@ -275,7 +281,7 @@ impl MemoryManager {
|
|||
for region in EXTRA_REGIONS {
|
||||
println!(" Region {}:", region);
|
||||
for o in 0..(region.mem_size as usize) / PAGE_SIZE {
|
||||
if MEMORY_ALLOCATIONS[offset + o].is_some() {
|
||||
if EXTRA_ALLOCATIONS[offset + o].is_some() {
|
||||
println!(
|
||||
" {:08x} => {}",
|
||||
(region.mem_start as usize) + o * PAGE_SIZE,
|
||||
|
|
@ -663,7 +669,6 @@ impl MemoryManager {
|
|||
) -> Result<(), xous_kernel::Error> {
|
||||
/// Modify the memory tracking table to note which process owns
|
||||
/// the specified address.
|
||||
#[cfg(not(feature = "swap"))]
|
||||
fn action_inner(
|
||||
owner_addr: &mut Option<PID>,
|
||||
pid: PID,
|
||||
|
|
@ -699,7 +704,7 @@ impl MemoryManager {
|
|||
Ok(())
|
||||
}
|
||||
#[cfg(feature = "swap")]
|
||||
fn action_inner(
|
||||
fn action_inner_tracking(
|
||||
owner_addr: &mut SwapAlloc,
|
||||
pid: PID,
|
||||
action: ClaimReleaseMove,
|
||||
|
|
@ -734,6 +739,7 @@ impl MemoryManager {
|
|||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
let addr = addr as usize;
|
||||
|
||||
// Ensure the address lies on a page boundary
|
||||
|
|
@ -748,10 +754,10 @@ impl MemoryManager {
|
|||
#[cfg(not(feature = "swap"))]
|
||||
return unsafe { action_inner(&mut MEMORY_ALLOCATIONS[offset], pid, action) };
|
||||
#[cfg(feature = "swap")]
|
||||
return unsafe { action_inner(&mut MEMORY_ALLOCATIONS[offset], pid, action, addr) };
|
||||
return unsafe { action_inner_tracking(&mut MEMORY_ALLOCATIONS[offset], pid, action, addr) };
|
||||
}
|
||||
|
||||
offset += self.ram_size / PAGE_SIZE;
|
||||
offset = 0;
|
||||
// Go through additional regions looking for this address, and claim it
|
||||
// if it's not in use.
|
||||
unsafe {
|
||||
|
|
@ -777,10 +783,7 @@ impl MemoryManager {
|
|||
// -------------------------------
|
||||
|
||||
offset += (addr - (region.mem_start as usize)) / PAGE_SIZE;
|
||||
#[cfg(not(feature = "swap"))]
|
||||
return action_inner(&mut MEMORY_ALLOCATIONS[offset], pid, action);
|
||||
#[cfg(feature = "swap")]
|
||||
return action_inner(&mut MEMORY_ALLOCATIONS[offset], pid, action, addr);
|
||||
return action_inner(&mut EXTRA_ALLOCATIONS[offset], pid, action);
|
||||
}
|
||||
offset += region.mem_size as usize / PAGE_SIZE;
|
||||
}
|
||||
|
|
@ -816,33 +819,39 @@ impl MemoryManager {
|
|||
if offset < self.ram_size as usize / PAGE_SIZE {
|
||||
Some(self.ram_start as usize + offset * PAGE_SIZE)
|
||||
} else {
|
||||
// The offset is not within RAM, so it must be in the extra
|
||||
// regions list. Loop through all regions looking for the
|
||||
// address. NOTE: This needs to be linear because each memory
|
||||
// region has a different length.
|
||||
let mut offset_in_region = offset - (self.ram_size as usize / PAGE_SIZE);
|
||||
unsafe {
|
||||
for region in EXTRA_REGIONS {
|
||||
// If the offset exceeds the current region, skip to the
|
||||
// next region.
|
||||
if offset_in_region >= (region.mem_size as usize / PAGE_SIZE) {
|
||||
offset_in_region -= region.mem_size as usize / PAGE_SIZE;
|
||||
continue;
|
||||
}
|
||||
return Some(region.mem_start as usize + (offset_in_region * PAGE_SIZE));
|
||||
}
|
||||
}
|
||||
|
||||
// No region was found.
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert an offset in the `EXTRA_ALLOCATIONS` array into a physical address.
|
||||
#[cfg(baremetal)]
|
||||
fn allocation_offset_to_address_extra(&self, offset: usize) -> Option<usize> {
|
||||
// Loop through all regions looking for the address.
|
||||
// NOTE: This needs to be linear because each memory region has a different length.
|
||||
let mut offset_in_region = offset;
|
||||
unsafe {
|
||||
for region in EXTRA_REGIONS {
|
||||
// If the offset exceeds the current region, skip to the
|
||||
// next region.
|
||||
if offset_in_region >= (region.mem_size as usize / PAGE_SIZE) {
|
||||
offset_in_region -= region.mem_size as usize / PAGE_SIZE;
|
||||
continue;
|
||||
}
|
||||
return Some(region.mem_start as usize + (offset_in_region * PAGE_SIZE));
|
||||
}
|
||||
}
|
||||
|
||||
// No region was found.
|
||||
None
|
||||
}
|
||||
|
||||
/// Free all memory that belongs to a process. This does not unmap the
|
||||
/// memory from the process, it only marks it as free.
|
||||
/// This is very unsafe because the memory can immediately be re-allocated
|
||||
/// to another process, so only call this as part of destroying a process.
|
||||
pub unsafe fn release_all_memory_for_process(&mut self, _pid: PID) {
|
||||
// release the main memory allocs
|
||||
#[cfg(baremetal)]
|
||||
for (idx, owner) in MEMORY_ALLOCATIONS.iter_mut().enumerate() {
|
||||
// If this address has been allocated to this process, consider
|
||||
|
|
@ -872,6 +881,21 @@ impl MemoryManager {
|
|||
}
|
||||
}
|
||||
}
|
||||
// release the extra allocs
|
||||
#[cfg(baremetal)]
|
||||
for (idx, owner) in EXTRA_ALLOCATIONS.iter_mut().enumerate() {
|
||||
if owner == &mut Some(_pid) {
|
||||
let phys_addr = self.allocation_offset_to_address_extra(idx).unwrap();
|
||||
if crate::arch::mem::page_is_lent(phys_addr as *mut u8) {
|
||||
// If the page is lent, reparent it to PID 1 so it will
|
||||
// get freed when it is returned.
|
||||
*owner = PID::new(1);
|
||||
} else {
|
||||
// Mark this page as free, which allows it to be re-allocated.
|
||||
*owner = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Adjust the flags on the given memory range. This allows for stripping flags from a memory
|
||||
|
|
|
|||
Loading…
Reference in a new issue