mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-19 09:00:54 +00:00
implement retrieval from swap and allocation advisories
This commit is contained in:
parent
4eefbd88bc
commit
025e39913b
1 changed files with 181 additions and 45 deletions
|
|
@ -1,20 +1,52 @@
|
||||||
use xous_kernel::{MemoryFlags, Message, MessageEnvelope, SysCallResult, PID, SID, TID};
|
use xous_kernel::{PID, SID};
|
||||||
|
|
||||||
|
/* for non-blocking calls
|
||||||
|
use xous_Kernel::{try_send_message, MemoryFlags, Message, MessageEnvelope, SysCallResult, TID};
|
||||||
|
use crate::server::SenderID; */
|
||||||
use crate::arch::current_pid;
|
use crate::arch::current_pid;
|
||||||
use crate::arch::mem::PAGE_SIZE;
|
use crate::arch::mem::MMUFlags;
|
||||||
use crate::mem::MemoryManager;
|
use crate::mem::MemoryManager;
|
||||||
use crate::server::SenderID;
|
|
||||||
use crate::services::SystemServices;
|
use crate::services::SystemServices;
|
||||||
|
|
||||||
#[derive(Copy, Clone)]
|
#[derive(Copy, Clone)]
|
||||||
pub enum BlockingSwapOp {
|
pub enum BlockingSwapOp {
|
||||||
/// PID of the source block, current paddr of block, original vaddr in the space of source block PID
|
/// PID of source, vaddr of source, vaddr in swap space (block must already be mapped into swap space)
|
||||||
WriteToSwap(PID, usize, usize),
|
WriteToSwap(PID, usize, usize),
|
||||||
ReadFromSwap,
|
/// PID of the target block, current paddr of block, original vaddr in the space of target block PID,
|
||||||
AllocateAdvisory,
|
/// physical address of block
|
||||||
Free,
|
ReadFromSwap(PID, usize, usize, usize),
|
||||||
|
/// PID of the process to return to after the allocate advisory
|
||||||
|
AllocateAdvisory(PID),
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[derive(Copy, Clone, PartialEq, Eq)]
|
||||||
|
pub enum AllocAdvice {
|
||||||
|
/// the PID of the allocation, virtual address in PID space, physical address
|
||||||
|
Allocate(PID, usize, usize),
|
||||||
|
/// the PID of the page freed, virtuall address in PID space, physical address
|
||||||
|
Free(PID, usize, usize),
|
||||||
|
/// not yet initialized record
|
||||||
|
Uninit,
|
||||||
|
}
|
||||||
|
impl AllocAdvice {
|
||||||
|
pub fn serialize(&self) -> (usize, usize) {
|
||||||
|
match self {
|
||||||
|
AllocAdvice::Allocate(pid, vaddr, paddr) => {
|
||||||
|
(
|
||||||
|
(pid.get() as usize) << 24 | (vaddr >> 12),
|
||||||
|
(1 << 24) | (paddr >> 12), // 1 indicates an alloc
|
||||||
|
)
|
||||||
|
}
|
||||||
|
AllocAdvice::Free(pid, vaddr, paddr) => {
|
||||||
|
(
|
||||||
|
(pid.get() as usize) << 24 | (vaddr >> 12),
|
||||||
|
(0 << 24) | (paddr >> 12), // 0 indicates a free
|
||||||
|
)
|
||||||
|
}
|
||||||
|
AllocAdvice::Uninit => (0, 0),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
#[cfg(baremetal)]
|
#[cfg(baremetal)]
|
||||||
#[no_mangle]
|
#[no_mangle]
|
||||||
static mut SWAP: Swap = Swap {
|
static mut SWAP: Swap = Swap {
|
||||||
|
|
@ -27,6 +59,7 @@ static mut SWAP: Swap = Swap {
|
||||||
prev_op: None,
|
prev_op: None,
|
||||||
swapper_state: 0,
|
swapper_state: 0,
|
||||||
swapper_args: [0usize; 8],
|
swapper_args: [0usize; 8],
|
||||||
|
alloc_advisories: [AllocAdvice::Uninit, AllocAdvice::Uninit, AllocAdvice::Uninit],
|
||||||
};
|
};
|
||||||
|
|
||||||
pub struct Swap {
|
pub struct Swap {
|
||||||
|
|
@ -48,21 +81,10 @@ pub struct Swap {
|
||||||
swapper_state: usize,
|
swapper_state: usize,
|
||||||
/// storage for args
|
/// storage for args
|
||||||
swapper_args: [usize; 8],
|
swapper_args: [usize; 8],
|
||||||
|
/// track advisories to the allocator
|
||||||
|
alloc_advisories: [AllocAdvice; 3],
|
||||||
}
|
}
|
||||||
impl Swap {
|
impl Swap {
|
||||||
/// Calls the provided function with the current inner process state.
|
|
||||||
pub fn with<F, R>(f: F) -> R
|
|
||||||
where
|
|
||||||
F: FnOnce(&Swap) -> R,
|
|
||||||
{
|
|
||||||
#[cfg(baremetal)]
|
|
||||||
unsafe {
|
|
||||||
f(&SWAP)
|
|
||||||
}
|
|
||||||
#[cfg(not(baremetal))]
|
|
||||||
SWAP.with(|ss| f(&ss.borrow()))
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn with_mut<F, R>(f: F) -> R
|
pub fn with_mut<F, R>(f: F) -> R
|
||||||
where
|
where
|
||||||
F: FnOnce(&mut Swap) -> R,
|
F: FnOnce(&mut Swap) -> R,
|
||||||
|
|
@ -101,7 +123,6 @@ impl Swap {
|
||||||
handler: usize,
|
handler: usize,
|
||||||
state: usize,
|
state: usize,
|
||||||
) -> Result<xous_kernel::Result, xous_kernel::Error> {
|
) -> Result<xous_kernel::Result, xous_kernel::Error> {
|
||||||
let swapper_pid = PID::new(xous_kernel::SWAPPER_PID).unwrap();
|
|
||||||
if self.sid == SID::from_u32(0, 0, 0, 0) {
|
if self.sid == SID::from_u32(0, 0, 0, 0) {
|
||||||
self.sid = SID::from_u32(s0, s1, s2, s3);
|
self.sid = SID::from_u32(s0, s1, s2, s3);
|
||||||
self.pc = handler;
|
self.pc = handler;
|
||||||
|
|
@ -166,19 +187,32 @@ impl Swap {
|
||||||
/// Safety: the current page table mapping context must be PID 2 (the swapper's PID) for this to work
|
/// Safety: the current page table mapping context must be PID 2 (the swapper's PID) for this to work
|
||||||
/// `op` contains the opcode data
|
/// `op` contains the opcode data
|
||||||
/// `payload_ptr` is the pointer to the virtual address of the swapped block in PID2 space
|
/// `payload_ptr` is the pointer to the virtual address of the swapped block in PID2 space
|
||||||
unsafe fn blocking_activate_swapper(&mut self, op: BlockingSwapOp, payload_ptr: usize) {
|
unsafe fn blocking_activate_swapper(&mut self, op: BlockingSwapOp) -> ! {
|
||||||
// setup the argument block
|
// setup the argument block
|
||||||
match op {
|
match op {
|
||||||
BlockingSwapOp::WriteToSwap(pid, phys_addr, virt_addr) => {
|
BlockingSwapOp::WriteToSwap(pid, vaddr_in_pid, vaddr_in_swap) => {
|
||||||
self.swapper_args[0] = self.swapper_state;
|
self.swapper_args[0] = self.swapper_state;
|
||||||
self.swapper_args[1] = 0; // WriteToSwap opcode
|
self.swapper_args[1] = 0; // WriteToSwap opcode
|
||||||
self.swapper_args[2] = payload_ptr;
|
self.swapper_args[2] = pid.get() as usize;
|
||||||
self.swapper_args[3] = pid.get() as usize;
|
self.swapper_args[3] = vaddr_in_pid;
|
||||||
self.swapper_args[4] = phys_addr;
|
self.swapper_args[4] = vaddr_in_swap;
|
||||||
self.swapper_args[5] = virt_addr;
|
|
||||||
}
|
}
|
||||||
_ => {
|
BlockingSwapOp::ReadFromSwap(pid, vaddr_in_pid, vaddr_in_swap, _paddr) => {
|
||||||
todo!()
|
self.swapper_args[0] = self.swapper_state;
|
||||||
|
self.swapper_args[1] = 1; // ReadFromSwap opcode
|
||||||
|
self.swapper_args[2] = pid.get() as usize;
|
||||||
|
self.swapper_args[3] = vaddr_in_pid;
|
||||||
|
self.swapper_args[4] = vaddr_in_swap;
|
||||||
|
}
|
||||||
|
BlockingSwapOp::AllocateAdvisory(_pid) => {
|
||||||
|
self.swapper_args[0] = self.swapper_state;
|
||||||
|
self.swapper_args[1] = 2; // AllocateAdvisory
|
||||||
|
for (index, advisory) in self.alloc_advisories.iter_mut().enumerate() {
|
||||||
|
let (varg, parg) = advisory.serialize();
|
||||||
|
self.swapper_args[2 + index * 2] = varg;
|
||||||
|
self.swapper_args[3 + index * 2] = parg;
|
||||||
|
*advisory = AllocAdvice::Uninit;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
self.prev_op = Some(op);
|
self.prev_op = Some(op);
|
||||||
|
|
@ -198,42 +232,144 @@ impl Swap {
|
||||||
|
|
||||||
crate::services::ArchProcess::with_current_mut(|process| {
|
crate::services::ArchProcess::with_current_mut(|process| {
|
||||||
crate::arch::syscall::resume(current_pid().get() == 1, process.current_thread())
|
crate::arch::syscall::resume(current_pid().get() == 1, process.current_thread())
|
||||||
});
|
})
|
||||||
// the call above diverges; the return end of things is inside the IRQ handler, where we
|
// the call above diverges; the return end of things is inside the IRQ handler, where we
|
||||||
// conduct business as if we're returning from a syscall.
|
// conduct business as if we're returning from a syscall.
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Cleanup after `blocking_activate_swapper()` - called on return from the divergence at the end
|
/// Cleanup after `blocking_activate_swapper()` - called on return from the divergence at the end
|
||||||
/// of the previous call.
|
/// of the previous call.
|
||||||
pub fn exit_blocking_call(&mut self) -> Result<xous_kernel::Result, xous_kernel::Error> {
|
///
|
||||||
|
/// Safety: this call must only be invoked in the swapper's memory context
|
||||||
|
pub unsafe fn exit_blocking_call(&mut self) -> Result<xous_kernel::Result, xous_kernel::Error> {
|
||||||
match self.prev_op.take() {
|
match self.prev_op.take() {
|
||||||
Some(BlockingSwapOp::WriteToSwap(pid, addr, _virt_addr)) => {
|
Some(BlockingSwapOp::WriteToSwap(pid, addr, _virt_addr)) => {
|
||||||
// update the RPT: mark the physical memory as free
|
// update the RPT: mark the physical memory as free. The physical page is
|
||||||
|
// in the swapper's context at this point, so free it there (it's already been
|
||||||
|
// remapped as swapped in the target's context)
|
||||||
MemoryManager::with_mut(|mm| {
|
MemoryManager::with_mut(|mm| {
|
||||||
mm.release_page_swap(addr as *mut usize, pid)
|
mm.release_page_swap(addr as *mut usize, pid)
|
||||||
.expect("couldn't clear the RPT after flushing swap");
|
.expect("couldn't clear the RPT after flushing swap")
|
||||||
});
|
});
|
||||||
|
// this will resume into the swapper, because that is our memory space right now
|
||||||
|
Ok(xous_kernel::Result::ResumeProcess)
|
||||||
}
|
}
|
||||||
Some(BlockingSwapOp::ReadFromSwap) => {
|
Some(BlockingSwapOp::ReadFromSwap(pid, vaddr_in_pid, vaddr_in_swap, paddr)) => {
|
||||||
todo!()
|
MemoryManager::with_mut(|mm| {
|
||||||
|
// we are in the swapper's memory space a this point
|
||||||
|
// unmap the page from the swapper
|
||||||
|
crate::arch::mem::unmap_page_inner(mm, vaddr_in_swap)?;
|
||||||
|
|
||||||
|
// return to the target PID
|
||||||
|
SystemServices::with(|system_services| {
|
||||||
|
// swap to the swapper space
|
||||||
|
let target_map = system_services.get_process(pid).unwrap().mapping;
|
||||||
|
target_map.activate()
|
||||||
|
})?;
|
||||||
|
|
||||||
|
let entry = crate::arch::mem::pagetable_entry(vaddr_in_pid)
|
||||||
|
.or(Err(xous_kernel::Error::BadAddress))?;
|
||||||
|
let current_entry = entry.read_volatile();
|
||||||
|
// clear the swapped flag
|
||||||
|
let flags = current_entry & 0x1ff & !MMUFlags::P.bits();
|
||||||
|
let ppn1 = (paddr >> 22) & ((1 << 12) - 1);
|
||||||
|
let ppn0 = (paddr >> 12) & ((1 << 10) - 1);
|
||||||
|
// Map the retrieved page to the target memory space, and set valid. I don't think `A`/`D`
|
||||||
|
// has any meaning, but we set it because the regular path would set
|
||||||
|
// that.
|
||||||
|
*entry = (ppn1 << 20)
|
||||||
|
| (ppn0 << 10)
|
||||||
|
| (flags | crate::arch::mem::FLG_VALID /* valid */
|
||||||
|
| crate::arch::mem::FLG_A/* A */
|
||||||
|
| crate::arch::mem::FLG_D/* D */
|
||||||
|
| crate::arch::mem::FLG_U/* USER */);
|
||||||
|
crate::arch::mem::flush_mmu();
|
||||||
|
// the current memory space is the target PID, so we will resume into the target PID
|
||||||
|
Ok(xous_kernel::Result::ResumeProcess)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
Some(BlockingSwapOp::AllocateAdvisory(pid)) => {
|
||||||
|
// return to the target PID
|
||||||
|
SystemServices::with(|system_services| {
|
||||||
|
// swap back to the original allocator's space
|
||||||
|
system_services.get_process(pid).unwrap().mapping.activate()?;
|
||||||
|
Ok(xous_kernel::Result::ResumeProcess)
|
||||||
|
})
|
||||||
}
|
}
|
||||||
Some(BlockingSwapOp::Free) => (),
|
|
||||||
Some(BlockingSwapOp::AllocateAdvisory) => (),
|
|
||||||
None => panic!("No previous swap op was set"),
|
None => panic!("No previous swap op was set"),
|
||||||
}
|
}
|
||||||
Ok(xous_kernel::Result::ResumeProcess)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn evict_page(&mut self, target_pid: PID, vaddr: usize) -> SysCallResult {
|
pub fn evict_page(&mut self, target_pid: PID, vaddr: usize) -> ! {
|
||||||
let evicted_ptr = crate::arch::mem::evict_page(target_pid, vaddr)?;
|
let evicted_ptr = crate::arch::mem::evict_page_inner(target_pid, vaddr).expect("couldn't evict page");
|
||||||
|
|
||||||
// this is safe because evict_page() leaves us in the swapper memory context
|
// this is safe because evict_page() leaves us in the swapper memory context
|
||||||
unsafe {
|
unsafe {
|
||||||
self.blocking_activate_swapper(
|
self.blocking_activate_swapper(BlockingSwapOp::WriteToSwap(target_pid, vaddr, evicted_ptr));
|
||||||
BlockingSwapOp::WriteToSwap(target_pid, evicted_ptr, vaddr),
|
}
|
||||||
evicted_ptr,
|
}
|
||||||
);
|
|
||||||
|
/// The address space on entry to `retrieve_page` is `target_pid`; it must ensure
|
||||||
|
/// that the address space is still `target_pid` on return.
|
||||||
|
///
|
||||||
|
/// Also takes as argument the virtual address of the target page in the target PID,
|
||||||
|
/// as well as the physical address of the page.
|
||||||
|
pub fn retrieve_page(&mut self, target_pid: PID, target_vaddr_in_pid: usize, paddr: usize) -> ! {
|
||||||
|
let block_vaddr_in_swap =
|
||||||
|
crate::arch::mem::map_page_to_swapper(paddr).expect("couldn't map target page to swapper");
|
||||||
|
// we are now in the swapper's memory space
|
||||||
|
|
||||||
|
// this is safe because map_page_to_swapper() leaves us in the swapper memory context
|
||||||
|
unsafe {
|
||||||
|
self.blocking_activate_swapper(BlockingSwapOp::ReadFromSwap(
|
||||||
|
target_pid,
|
||||||
|
target_vaddr_in_pid,
|
||||||
|
block_vaddr_in_swap,
|
||||||
|
paddr,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Accumulate allocations and advise the swapper en-bulk of allocations. This will diverge
|
||||||
|
/// only when it's determined that we need to advise the swapper.
|
||||||
|
pub fn advise_alloc(
|
||||||
|
&mut self,
|
||||||
|
// also the PID to return from after reporting to the swapper
|
||||||
|
target_pid: PID,
|
||||||
|
target_vaddr_in_pid: usize,
|
||||||
|
paddr: usize,
|
||||||
|
is_allocate: bool,
|
||||||
|
) {
|
||||||
|
let mut placed_index: Option<usize> = None;
|
||||||
|
for (index, advisory) in self.alloc_advisories.iter_mut().enumerate() {
|
||||||
|
if *advisory == AllocAdvice::Uninit {
|
||||||
|
if is_allocate {
|
||||||
|
*advisory = AllocAdvice::Allocate(target_pid, target_vaddr_in_pid, paddr);
|
||||||
|
} else {
|
||||||
|
*advisory = AllocAdvice::Free(target_pid, target_vaddr_in_pid, paddr);
|
||||||
|
}
|
||||||
|
placed_index = Some(index);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
match placed_index {
|
||||||
|
Some(i) => {
|
||||||
|
if i == self.alloc_advisories.len() - 1 {
|
||||||
|
let swapper_pid = PID::new(xous_kernel::SWAPPER_PID).unwrap();
|
||||||
|
SystemServices::with(|ss| {
|
||||||
|
ss.get_process(swapper_pid).unwrap().mapping.activate().unwrap()
|
||||||
|
});
|
||||||
|
|
||||||
|
// this is safe because we've changed into the swapper's memory space
|
||||||
|
unsafe {
|
||||||
|
self.blocking_activate_swapper(BlockingSwapOp::AllocateAdvisory(target_pid));
|
||||||
|
// ^^ also note this has the side effect of clearing the advisory storage table
|
||||||
|
}
|
||||||
|
// call proceeds to swapper space -> we've diverged and will return via the
|
||||||
|
// swapper return path
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None => panic!("Error: advisory record ran out of space"),
|
||||||
}
|
}
|
||||||
SysCallResult::Ok(xous_kernel::Result::ResumeProcess)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue