kernel: properly zero out pages prior to handing them to userspace

Until now, we were relying on luck to ensure pages were zeroed.
However, now we properly zero pages in the kernel before handing them
off to userspace.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-03-17 11:35:38 +08:00
parent d10bc2e894
commit ebe3efc097
6 changed files with 139 additions and 32 deletions

View file

@ -1,7 +1,7 @@
use crate::arch::current_pid;
use crate::arch::mem::MemoryMapping;
use crate::arch::process::ProcessHandle;
use crate::mem::MemoryManagerHandle;
use crate::mem::{MemoryManagerHandle, PAGE_SIZE};
use crate::services::{ProcessContext, ProcessState, SystemServicesHandle, RETURN_FROM_ISR};
use riscv::register::{scause, sepc, sie, sstatus, stval, vexriscv::sim, vexriscv::sip};
use xous::{SysCall, PID};
@ -153,13 +153,21 @@ pub extern "C" fn trap_handler(
let ppn1 = (new_page >> 22) & ((1 << 12) - 1);
let ppn0 = (new_page >> 12) & ((1 << 10) - 1);
unsafe {
// Map the page to our process
entry.write_volatile((ppn1 << 20) | (ppn0 << 10) |
(flags | (1 << 0) /* valid */ | (1 << 4) /* USER */ | (1 << 6) /* D */ | (1 << 7) /* A */))
};
unsafe { flush_mmu() };
(flags | (1 << 0) /* valid */ | (1 << 6) /* D */ | (1 << 7) /* A */));
flush_mmu();
// Zero-out the page
// unsafe { (new_page as *mut usize).write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>()) };
// Zero-out the page
let virt = addr & !0xfff;
(virt as *mut usize)
.write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>());
// Move the page into userspace
entry.write_volatile((ppn1 << 20) | (ppn0 << 10) |
(flags | (1 << 0) /* valid */ | (1 << 4) /* USER */ | (1 << 6) /* D */ | (1 << 7) /* A */));
flush_mmu();
};
let mut process = ProcessHandle::get();
crate::arch::syscall::resume(current_pid() == 1, process.current_context());

View file

@ -165,7 +165,7 @@ impl MemoryMapping {
return 0 as *mut usize;
}
let l0_pt_virt = PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE;
let entry = (l0_pt_virt + vpn0*4) as *mut usize;
let entry = (l0_pt_virt + vpn0 * 4) as *mut usize;
entry
}
@ -264,6 +264,45 @@ impl fmt::Display for LeafPageTable {
}
}
/// When we allocate pages, they are owned by the kernel so we can zero
/// them out. After that is done, hand the page to the user.
pub fn hand_page_to_user(virt: *mut usize) -> Result<(), xous::Error> {
let virt = virt as usize;
let vpn1 = (virt >> 22) & ((1 << 10) - 1);
let vpn0 = (virt >> 12) & ((1 << 10) - 1);
let vpo = (virt >> 0) & ((1 << 12) - 1);
assert!(vpn1 < 1024);
assert!(vpn0 < 1024);
assert!(vpo < 4096);
// The root (l1) pagetable is defined to be mapped into our virtual
// address space at this address.
let l1_pt = unsafe { &mut (*(PAGE_TABLE_ROOT_OFFSET as *mut RootPageTable)) };
let ref mut l1_pt = l1_pt.entries;
// Subsequent pagetables are defined as being mapped starting at
// PAGE_TABLE_OFFSET
let l0pt_virt = PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE;
let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) };
// If the level 1 pagetable doesn't exist, then this address isn't valid.
if l1_pt[vpn1] & MMUFlags::VALID.bits() == 0 {
return Err(xous::Error::BadAddress);
}
// Ensure the entry hasn't already been mapped.
if l0_pt.entries[vpn0] & 1 == 0 {
return Err(xous::Error::BadAddress);
}
// Add the USER flag to the entry
l0_pt.entries[vpn0] |= MMUFlags::USER.bits();
unsafe { flush_mmu() };
Ok(())
}
/// Map the given page to the specified process table. If necessary,
/// allocate a new page.
///
@ -285,14 +324,14 @@ pub fn map_page_inner(
let vpn0 = (virt >> 12) & ((1 << 10) - 1);
let vpo = (virt >> 0) & ((1 << 12) - 1);
let mut flags = translate_flags(req_flags);
// The kernel runs in Supervisor mode, and therefore always needs
// exclusive access to this memory.
// Additionally, any address below the user area must be accessible
// by the kernel.
if pid != 1 && virt < USER_AREA_END {
flags |= MMUFlags::USER;
}
let flags = translate_flags(req_flags);
// // The kernel runs in Supervisor mode, and therefore always needs
// // exclusive access to this memory.
// // Additionally, any address below the user area must be accessible
// // by the kernel.
// if pid != 1 && virt < USER_AREA_END {
// flags |= MMUFlags::USER;
// }
assert!(ppn1 < 4096);
assert!(ppn0 < 1024);
@ -352,10 +391,7 @@ pub fn map_page_inner(
/// # Errors
///
/// * BadAddress - Address was not already mapped.
pub fn unmap_page_inner(
_mm: &mut MemoryManager,
virt: usize,
) -> Result<(), xous::Error> {
pub fn unmap_page_inner(_mm: &mut MemoryManager, virt: usize) -> Result<(), xous::Error> {
let vpn1 = (virt >> 22) & ((1 << 10) - 1);
let vpn0 = (virt >> 12) & ((1 << 10) - 1);
let vpo = (virt >> 0) & ((1 << 12) - 1);
@ -374,7 +410,7 @@ pub fn unmap_page_inner(
let l0pt_virt = PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE;
let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) };
// Allocate a new level 1 pagetable entry if one doesn't exist.
// If the level 1 pagetable doesn't exist, then this address isn't valid.
if l1_pt[vpn1] & MMUFlags::VALID.bits() == 0 {
return Err(xous::Error::BadAddress);
}

View file

@ -18,7 +18,7 @@ pub fn handle(irqs_pending: usize) -> Result<xous::Result, xous::Error> {
let mut ss = SystemServicesHandle::get();
// Disable all other IRQs and redirect into userspace
arch::irq::disable_all_irqs();
println!("Making a callback to PID{}: {:08x} ({:08x}, {:08x})", pid, f as usize, irq_no as usize, arg as usize);
// println!("Making a callback to PID{}: {:08x} ({:08x}, {:08x})", pid, f as usize, irq_no as usize, arg as usize);
return ss.make_callback_to(pid, f, irq_no, arg).map(|_| xous::Result::ResumeProcess);
} else {
// If there is no handler, mask this interrupt

View file

@ -349,7 +349,7 @@ impl MemoryManager {
/// Attempt to allocate a single page from the default section.
/// Note that this will be backed by a real page.
pub fn map_page(&mut self, pid: PID) -> Result<*mut usize, xous::Error> {
pub fn map_zeroed_page(&mut self, pid: PID) -> Result<*mut usize, xous::Error> {
let virt =
self.find_virtual_address(0 as *mut usize, PAGE_SIZE, xous::MemoryType::Default)?;
@ -372,9 +372,14 @@ impl MemoryManager {
// Zero-out the page
unsafe { virt.write_bytes(0, PAGE_SIZE / mem::size_of::<usize>()) };
crate::arch::mem::hand_page_to_user(virt)?;
Ok(virt)
}
pub fn is_main_memory(&self, phys: *mut usize) -> bool {
(phys as usize) >= self.ram_start && (phys as usize) < self.ram_start + self.ram_size
}
/// Attempt to map the given physical address into the virtual address space
/// of this process.
///

View file

@ -3,8 +3,8 @@ use crate::arch::mem::MemoryMapping;
use crate::arch::process::ProcessHandle;
pub use crate::arch::ProcessContext;
use crate::args::KernelArguments;
use crate::mem::MemoryManagerHandle;
use core::slice;
use crate::mem::{MemoryManagerHandle, PAGE_SIZE};
use core::{mem, slice};
use xous::{MemoryFlags, PID, SID};
const MAX_PROCESS_COUNT: usize = 32;
@ -114,6 +114,7 @@ impl Process {
}
#[derive(Copy, Clone, PartialEq)]
#[repr(usize)]
enum ServerState {
/// This server slot is unallocated
Free,
@ -125,6 +126,32 @@ enum ServerState {
Full,
}
/// Internal representation of a queued message for a server.
/// This should be exactly 8 words / 32 bytes, yielding 128
/// queued messages per server
#[repr(usize)]
enum QueuedMessage {
Empty,
ScalarMessage(
usize, /* sender */
usize, /* response flag */
usize, /* id */
usize, /* arg1 */
usize, /* arg2 */
usize, /* arg3 */
usize, /* arg4 */
),
MemoryMessage(
usize, /* sender */
usize, /* response flag */
usize, /* id */
usize, /* in_buf */
usize, /* in_buf_size */
usize, /* out_buf */
usize, /* out_buf_size */
),
}
/// A pointer to resolve a server ID to a particular process
#[derive(Copy, Clone)]
pub struct Server {
@ -138,7 +165,7 @@ pub struct Server {
state: ServerState,
/// Where data will appear
queue: *mut usize,
queue: &'static [QueuedMessage],
}
impl Default for Server {
@ -147,7 +174,7 @@ impl Default for Server {
sid: (0, 0, 0, 0),
pid: 0,
state: ServerState::Free,
queue: 0 as *mut usize,
queue: &[],
}
}
}
@ -192,7 +219,7 @@ static mut SYSTEM_SERVICES: SystemServices = SystemServices {
sid: (0, 0, 0, 0),
pid: 0,
state: ServerState::Free,
queue: 0 as *mut usize,
queue: &[],
}; MAX_SERVER_COUNT],
};
@ -383,7 +410,10 @@ impl SystemServices {
match new.state {
ProcessState::Setup(entrypoint, stack, stack_size) => {
let mut process = ProcessHandle::get();
println!("Initializing new process with stack size of {} bytes", stack_size);
println!(
"Initializing new process with stack size of {} bytes",
stack_size
);
process.init(entrypoint, stack);
// Mark the stack as "unallocated-but-free"
let init_sp = stack & !0xfff;
@ -427,17 +457,34 @@ impl SystemServices {
/// Allocate a new server ID for this process and return the address.
/// If the server table is full, return an error.
pub fn create_server(&mut self, name: usize) -> Result<SID, xous::Error> {
println!("Looking through server list for free server");
println!("Server entries are {} bytes long", mem::size_of::<Server>());
assert!(
mem::size_of::<QueuedMessage>() == 32,
"QueuedMessage was supposed to be 32 bytes, but instead was {} bytes",
mem::size_of::<QueuedMessage>()
);
for entry in self.servers.iter_mut() {
if entry.state == ServerState::Free {
let pid = self.pid;
println!("Found a free slot. Allocating an entry");
// Allocate memory for the new server.
entry.queue = {
let mut mm = MemoryManagerHandle::get();
mm.map_page(pid)?
let page = mm.map_zeroed_page(pid)?;
unsafe {
slice::from_raw_parts_mut(
page as *mut QueuedMessage,
PAGE_SIZE / mem::size_of::<QueuedMessage>(),
)
}
};
println!("Managed to allocate a handle");
entry.state = ServerState::Ready;
entry.pid = self.pid;
entry.sid = (pid as usize, pid as usize, pid as usize, pid as usize);
entry.sid = (pid as usize, name as usize, pid as usize, name as usize);
println!("Returning SID");
return Ok(entry.sid);
}
}

View file

@ -3,6 +3,7 @@ use crate::arch::process::ProcessHandle;
use crate::irq::interrupt_claim;
use crate::mem::{MemoryManagerHandle, PAGE_SIZE};
use crate::services::{ProcessState, SystemServicesHandle};
use core::mem;
use xous::*;
// extern "Rust" {
@ -152,8 +153,18 @@ pub fn handle(call: SysCall) -> xous::Result {
// "Mapping {:08x} -> {:08x} ({} bytes, flags: {:?})",
// phys as u32, virt as u32, size, req_flags
// );
mm.map_range(phys, virt, size, req_flags)
.unwrap_or_else(|e| xous::Result::Error(e))
let result = mm.map_range(phys, virt, size, req_flags)
.unwrap_or_else(|e| xous::Result::Error(e));
if let xous::Result::MemoryRange(ref r) = result {
// If we're handing back an address in main RAM, zero it out
if phys as usize == 0 || mm.is_main_memory(phys) {
unsafe { r.base.write_bytes(0, r.size / mem::size_of::<usize>()) };
}
for offset in ((r.base as usize)..(r.base as usize + r.size)).step_by(PAGE_SIZE) {
crate::arch::mem::hand_page_to_user(offset as *mut usize).expect("couldn't hand page to user");
}
}
result
}
SysCall::IncreaseHeap(delta, flags) => {
if delta & 0xfff != 0 {