139 lines
4.5 KiB
Rust
139 lines
4.5 KiB
Rust
//! Page moves, release and heap placement.
|
|
|
|
use domain::{
|
|
error::KernelError,
|
|
memory::frame::{FrameUse, PAGE_SIZE},
|
|
};
|
|
use platform::Platform;
|
|
use types::{
|
|
address::{PhysicalAddress, VirtualAddress},
|
|
id::ProcessId,
|
|
mapping::PagePerms,
|
|
};
|
|
|
|
use super::{USER_HEAP_START, page_at};
|
|
use crate::Kernel;
|
|
|
|
impl<P: Platform> Kernel<P> {
|
|
/// Frame backing the user page at `va` in `pid`. Lets boot code fill
|
|
/// pages it has just mapped for a process.
|
|
pub fn user_page_frame(&self, pid: ProcessId, va: VirtualAddress) -> Option<PhysicalAddress> {
|
|
self.user_frame(pid, va).map(|(pa, _)| pa)
|
|
}
|
|
|
|
/// Maps `pages` fresh zeroed pages at `va`, all or nothing.
|
|
pub fn map_fresh_range(
|
|
&mut self,
|
|
pid: ProcessId,
|
|
va: VirtualAddress,
|
|
pages: usize,
|
|
perms: PagePerms,
|
|
) -> Result<(), KernelError> {
|
|
if !Self::in_user_window(va, pages) {
|
|
return Err(KernelError::InvalidAddress);
|
|
}
|
|
if !self.range_is_free(pid, va, pages) {
|
|
return Err(KernelError::AddressInUse);
|
|
}
|
|
for i in 0..pages {
|
|
if let Err(e) = self.map_fresh_page(pid, page_at(va, i), perms) {
|
|
for j in 0..i {
|
|
self.unmap_and_free(pid, page_at(va, j));
|
|
}
|
|
return Err(e);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Next-fit search for `pages` free heap pages from `pid`'s last request, then from the bottom.
|
|
pub(crate) fn find_free_heap_range(
|
|
&self,
|
|
pid: ProcessId,
|
|
pages: usize,
|
|
) -> Option<VirtualAddress> {
|
|
let bottom = USER_HEAP_START.max(P::USER_VA_START);
|
|
let cursor = self
|
|
.heap_cursors
|
|
.get(pid.raw() as usize)
|
|
.copied()
|
|
.unwrap_or(0)
|
|
.max(bottom);
|
|
self.first_fit_from(pid, cursor, pages)
|
|
.or_else(|| self.first_fit_from(pid, bottom, pages))
|
|
}
|
|
|
|
/// Records where `pid`'s next heap search starts.
|
|
pub(crate) fn advance_heap_cursor(&mut self, pid: ProcessId, past: VirtualAddress) {
|
|
if let Some(c) = self.heap_cursors.get_mut(pid.raw() as usize) {
|
|
*c = past.raw();
|
|
}
|
|
}
|
|
|
|
fn first_fit_from(&self, pid: ProcessId, from: usize, pages: usize) -> Option<VirtualAddress> {
|
|
let mut candidate = from;
|
|
while Self::in_user_window(VirtualAddress::from_raw(candidate), pages) {
|
|
let va = VirtualAddress::from_raw(candidate);
|
|
match (0..pages).find(|&i| self.is_mapped(pid, page_at(va, i))) {
|
|
None => return Some(va),
|
|
Some(busy) => candidate += (busy + 1) * PAGE_SIZE,
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
/// Validates that every page of the range is a user page `pid` owns,
|
|
/// then releases them all.
|
|
pub(crate) fn release_range(
|
|
&mut self,
|
|
pid: ProcessId,
|
|
va: VirtualAddress,
|
|
pages: usize,
|
|
) -> Result<(), KernelError> {
|
|
if !Self::in_user_window(va, pages) {
|
|
return Err(KernelError::InvalidAddress);
|
|
}
|
|
if !(0..pages).all(|i| self.user_frame(pid, page_at(va, i)).is_some()) {
|
|
return Err(KernelError::InvalidAddress);
|
|
}
|
|
for i in 0..pages {
|
|
self.unmap_and_free(pid, page_at(va, i));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Moves the page at `src` in `from` to `dst` in `to`. The frame and its
|
|
/// quota charge change hands; `from` loses access.
|
|
pub(crate) fn move_page(
|
|
&mut self,
|
|
from: ProcessId,
|
|
src: VirtualAddress,
|
|
to: ProcessId,
|
|
dst: VirtualAddress,
|
|
perms: PagePerms,
|
|
) -> Result<(), KernelError> {
|
|
if !Self::in_user_window(src, 1) || !Self::in_user_window(dst, 1) {
|
|
return Err(KernelError::InvalidAddress);
|
|
}
|
|
let (pa, _) = self
|
|
.user_frame(from, src)
|
|
.ok_or(KernelError::InvalidAddress)?;
|
|
self.processes.get(to)?;
|
|
if !self.range_is_free(to, dst, 1) {
|
|
return Err(KernelError::AddressInUse);
|
|
}
|
|
let usage = FrameUse::user(to, dst, perms).ok_or(KernelError::InvalidAddress)?;
|
|
if !self.quota_mut(to)?.charge(1) {
|
|
return Err(KernelError::OutOfMemory);
|
|
}
|
|
if let Err(e) = self.platform_map(to, dst, pa, perms) {
|
|
self.quota_mut(to)?.uncharge(1);
|
|
return Err(e);
|
|
}
|
|
self.platform.unmap_page(from, src);
|
|
self.frames.retag(pa, usage);
|
|
self.quota_mut(from)?.uncharge(1);
|
|
Ok(())
|
|
}
|
|
}
|