diff --git a/kernel/src/arch/riscv/irq.rs b/kernel/src/arch/riscv/irq.rs index aa6b125e0..4b6cced66 100644 --- a/kernel/src/arch/riscv/irq.rs +++ b/kernel/src/arch/riscv/irq.rs @@ -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::()) }; + // Zero-out the page + let virt = addr & !0xfff; + (virt as *mut usize) + .write_bytes(0, PAGE_SIZE / core::mem::size_of::()); + + // 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()); diff --git a/kernel/src/arch/riscv/mem.rs b/kernel/src/arch/riscv/mem.rs index 06938a904..6691110ab 100644 --- a/kernel/src/arch/riscv/mem.rs +++ b/kernel/src/arch/riscv/mem.rs @@ -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); } diff --git a/kernel/src/irq.rs b/kernel/src/irq.rs index 487780448..edaaf840c 100644 --- a/kernel/src/irq.rs +++ b/kernel/src/irq.rs @@ -18,7 +18,7 @@ pub fn handle(irqs_pending: usize) -> Result { 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 diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index 13d30d445..c27055a7e 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -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::()) }; + 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. /// diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 701380e32..caae30f6c 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -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 { + println!("Looking through server list for free server"); + println!("Server entries are {} bytes long", mem::size_of::()); + assert!( + mem::size_of::() == 32, + "QueuedMessage was supposed to be 32 bytes, but instead was {} bytes", + mem::size_of::() + ); + 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::(), + ) + } }; + 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); } } diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index ad2ef5352..a9f4358b2 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -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::()) }; + } + 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 {