kernel: riscv: use raw pointers for mmu mapping

This avoids using uninitialized arrays to manage the pagetables, and
instead uses raw pointers. This should avoid using potentially
uninitialized data.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2021-05-19 14:17:53 +08:00
parent 25f976dbb6
commit 47bf453325

View file

@ -21,6 +21,15 @@ extern "C" {
fn flush_mmu(); fn flush_mmu();
} }
pub unsafe fn memset(s: *mut u8, c: i32, n: usize) -> *mut u8 {
let mut i = 0;
while i < n {
*s.offset(i as isize) = c as u8;
i += 1;
}
s
}
bitflags! { bitflags! {
pub struct MMUFlags: usize { pub struct MMUFlags: usize {
const NONE = 0b00_0000_0000; const NONE = 0b00_0000_0000;
@ -199,7 +208,7 @@ impl MemoryMapping {
// Zero-out the new page // Zero-out the new page
let page_addr = l0pt_virt as *mut usize; let page_addr = l0pt_virt as *mut usize;
unsafe { page_addr.write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>()) }; unsafe { memset(page_addr as *mut u8, 0, PAGE_SIZE) };
} }
let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) }; let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) };
@ -337,47 +346,53 @@ pub fn map_page_inner(
assert!((virt & 0xfff) == 0); assert!((virt & 0xfff) == 0);
// The root (l1) pagetable is defined to be mapped into our virtual // The root (l1) pagetable is defined to be mapped into our virtual
// address space at this address. // address space at 0xff80_0000.
let l1_pt = unsafe { &mut (*(PAGE_TABLE_ROOT_OFFSET as *mut RootPageTable)) }; let l1_pt = PAGE_TABLE_ROOT_OFFSET as *mut usize;
let ref mut l1_pt = l1_pt.entries;
// Subsequent pagetables are defined as being mapped starting at // Subsequent pagetables are defined as being mapped starting at
// offset 0x0020_0004, so 4 must be added to the ppn1 value. // offset 0xff40_0000.
let l0pt_virt = PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE; let l0_pt = (PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE) as *mut usize;
let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) };
// Allocate a new level 1 pagetable entry if one doesn't exist. // Allocate a new level 1 pagetable entry if one doesn't exist.
if l1_pt[vpn1 as usize] & MMUFlags::VALID.bits() == 0 { if unsafe { l1_pt.add(vpn1).read_volatile() } & MMUFlags::VALID.bits() == 0 {
// Allocate a fresh page // Allocate a fresh page for the level 1 page table.
let l0pt_phys = mm.alloc_page(pid)?; let l0_pt_phys = mm.alloc_page(pid)?;
// Mark this entry as a leaf node (WRX as 0), and indicate // Mark this entry as a leaf node (WRX as 0), and indicate
// it is a valid page by setting "V". // it is a valid page by setting "V".
l1_pt[vpn1 as usize] = ((l0pt_phys >> 12) << 10) | MMUFlags::VALID.bits(); unsafe {
unsafe { flush_mmu() }; l1_pt
.add(vpn1)
.write_volatile(((l0_pt_phys >> 12) << 10) | MMUFlags::VALID.bits());
flush_mmu();
}
// Map the new physical page to the virtual page, so we can access it. // Map the new physical page to the virtual page, so we can access it.
map_page_inner( map_page_inner(
mm, mm,
pid, pid,
l0pt_phys, l0_pt_phys,
l0pt_virt, l0_pt as usize,
MemoryFlags::W | MemoryFlags::R, MemoryFlags::W | MemoryFlags::R,
false, false,
)?; )?;
// Zero-out the new page // Zero-out the new page
let page_addr = l0pt_virt as *mut usize; unsafe { memset(l0_pt as *mut u8, 0, PAGE_SIZE) };
unsafe { page_addr.write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>()) };
} }
// Ensure the entry hasn't already been mapped. // Ensure the entry hasn't already been mapped.
if l0_pt.entries[vpn0 as usize] & 1 != 0 { if unsafe { l0_pt.add(vpn0).read_volatile() } & 1 != 0 {
panic!("Page {:08x} already allocated!", virt); panic!("Page {:08x} already allocated!", virt);
} }
l0_pt.entries[vpn0 as usize] = unsafe {
(ppn1 << 20) | (ppn0 << 10) | (flags | MMUFlags::VALID | MMUFlags::D | MMUFlags::A).bits(); l0_pt.add(vpn0).write_volatile(
unsafe { flush_mmu() }; (ppn1 << 20)
| (ppn0 << 10)
| (flags | MMUFlags::VALID | MMUFlags::D | MMUFlags::A).bits(),
)
};
// unsafe { flush_mmu() };
Ok(()) Ok(())
} }
@ -650,7 +665,7 @@ pub fn ensure_page_exists_inner(address: usize) -> Result<usize, xous_kernel::Er
flush_mmu(); flush_mmu();
// Zero-out the page // Zero-out the page
(virt as *mut usize).write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>()); memset(virt as *mut u8, 0, PAGE_SIZE);
// Move the page into userspace // Move the page into userspace
*entry = (ppn1 << 20) *entry = (ppn1 << 20)