mem: better handling of memory alloc failures

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-03-12 16:51:14 +08:00
parent 36faa8354f
commit c1b575507d

View file

@ -6,7 +6,7 @@ use core::slice;
use core::str; use core::str;
pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE}; pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE};
use xous::{MemoryAddress, MemoryFlags, PID}; use xous::{MemoryFlags, PID};
#[derive(Debug)] #[derive(Debug)]
enum ClaimOrRelease { enum ClaimOrRelease {
@ -167,10 +167,10 @@ impl MemoryManager {
// First, we build a &[u8]... // First, we build a &[u8]...
let name_bytes = self.ram_name.to_le_bytes(); let name_bytes = self.ram_name.to_le_bytes();
// ... and then convert that slice into a string slice // ... and then convert that slice into a string slice
let ram_name = str::from_utf8_unchecked(&name_bytes); let _ram_name = str::from_utf8_unchecked(&name_bytes);
println!( println!(
" Region {} ({:08x}) {:08x} - {:08x} {} bytes:", " Region {} ({:08x}) {:08x} - {:08x} {} bytes:",
ram_name, _ram_name,
self.ram_name, self.ram_name,
self.ram_start, self.ram_start,
self.ram_start + self.ram_size, self.ram_start + self.ram_size,
@ -253,6 +253,7 @@ impl MemoryManager {
let mut mm = MemoryMapping::current(); let mut mm = MemoryMapping::current();
for virt in (virt..(virt + size)).step_by(PAGE_SIZE) { for virt in (virt..(virt + size)).step_by(PAGE_SIZE) {
// FIXME: Un-reserve addresses if we encounter an error here
mm.reserve_address(self, virt, flags)?; mm.reserve_address(self, virt, flags)?;
} }
Ok(xous::Result::MemoryRange(virt_ptr as *mut u8, size)) Ok(xous::Result::MemoryRange(virt_ptr as *mut u8, size))
@ -270,48 +271,47 @@ impl MemoryManager {
virt_ptr: *mut usize, virt_ptr: *mut usize,
size: usize, size: usize,
flags: MemoryFlags, flags: MemoryFlags,
) -> Result<MemoryAddress, xous::Error> { ) -> Result<xous::Result, xous::Error> {
let ss = SystemServicesHandle::get(); let ss = SystemServicesHandle::get();
let pid = ss.current_pid(); let pid = ss.current_pid();
let phys = phys_ptr as usize; let phys = phys_ptr as usize;
let virt = virt_ptr as usize; let virt = virt_ptr as usize;
if phys == 0 || virt == 0 { // If no physical address is specified, give the user the next available pages
println!("Attempted to map a range without specifying phys or virt"); if phys == 0 {
return Err(xous::Error::BadAddress); return self.reserve_range(virt_ptr, size, flags);
} }
let mut error = None; // 1. Attempt to claim all physical pages in the range
for phys in (phys..(phys + size)).step_by(PAGE_SIZE) { for claim_phys in (phys..(phys + size)).step_by(PAGE_SIZE) {
if let Err(err) = self.claim_page(phys as *mut usize, pid) { if let Err(err) = self.claim_page(claim_phys as *mut usize, pid) {
error = Some(err); // If we were unable to claim one or more pages, release everything and return
break; for rel_phys in (phys..claim_phys).step_by(PAGE_SIZE) {
} self.release_page(rel_phys as *mut usize, pid).ok();
} }
if let Some(err) = error { return Err(err);
for phys in (phys..(phys + size)).step_by(PAGE_SIZE) {
self.release_page(phys as *mut usize, pid).ok();
}
return Err(err);
}
for phys in (phys..(phys + size)).step_by(PAGE_SIZE) {
if let Err(e) =
crate::arch::mem::map_page_inner(self, pid, phys as usize, virt as usize, flags)
{
error = Some(e);
break;
} }
} }
if let Some(err) = error { // Actually perform the map. At this stage, every physical page should be owned by us.
for phys in (phys..(phys + size)).step_by(PAGE_SIZE) { for offset in (0..size).step_by(PAGE_SIZE) {
self.release_page(phys as *mut usize, pid).ok(); if let Err(e) = crate::arch::mem::map_page_inner(
self,
pid,
offset + phys as usize,
offset + virt as usize,
flags,
) {
for unmap_offset in (0..offset).step_by(PAGE_SIZE) {
crate::arch::mem::unmap_page_inner(self, unmap_offset + virt).ok();
self.release_page((unmap_offset + phys) as *mut usize, pid)
.ok();
}
return Err(e);
} }
return Err(err);
} }
Ok(MemoryAddress::new(virt).unwrap()) Ok(xous::Result::MemoryRange(virt as *mut u8, size))
} }
// /// Map a range of physical addresses into the current memory space. // /// Map a range of physical addresses into the current memory space.