diff --git a/examples/log/src/log_string.rs b/examples/log/src/log_string.rs index 66d5e19f7..e5f26c7c5 100644 --- a/examples/log/src/log_string.rs +++ b/examples/log/src/log_string.rs @@ -3,26 +3,19 @@ use core::slice; use xous; pub struct LogString<'a> { - backing: &'a [u8], s: &'a str, } impl<'a> LogString<'a> { - pub fn from_message(message: xous::MemoryMessage) -> LogString<'a> { + pub fn from_message(message: &xous::MemoryMessage) -> LogString<'a> { println!( "Message address is at {:08x}", - message.buf.expect("no buffer").get() + message.buf.addr.get() ); LogString { - backing: unsafe { - slice::from_raw_parts( - message.buf.expect("no buffer present").get() as *mut u8, - message.buf_size.expect("no buffer length present").get(), - ) - }, s: unsafe { core::str::from_utf8(slice::from_raw_parts( - message.buf.expect("no buffer present").get() as *mut u8, + message.buf.addr.get() as *mut u8, message.valid.expect("no buffer length present").get(), )) .expect("message didn't have valid utf8") @@ -36,10 +29,3 @@ impl<'a> fmt::Display for LogString<'a> { write!(f, "{}", self.s) } } - -impl<'a> Drop for LogString<'a> { - fn drop(&mut self) { - xous::syscall::unmap_memory(xous::MemoryAddress::new(self.backing.as_ptr() as usize).unwrap(), self.backing.len()) - .expect("couldn't free string"); - } -} diff --git a/examples/log/src/main.rs b/examples/log/src/main.rs index 5f36f5582..9a530eff9 100644 --- a/examples/log/src/main.rs +++ b/examples/log/src/main.rs @@ -34,8 +34,8 @@ fn main() { xous::MemoryFlags::R | xous::MemoryFlags::W, ) .expect("couldn't map serial port"); - unsafe { debug::DEFAULT_UART_ADDR = uart.base as *mut usize }; - println!("Mapped UART @ {:08x}", uart.base as usize); + unsafe { debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() }; + println!("Mapped UART @ {:08x}", uart.addr.get()); println!("Process: map success!"); debug::DEFAULT.enable_rx(); @@ -81,7 +81,7 @@ fn main() { // println!("Waiting for an event..."); let envelope = xous::syscall::receive_message(server_addr).expect("couldn't get address"); // println!("Got message envelope: {:?}", envelope); - match envelope.message { + match &envelope.message { xous::Message::Scalar(msg) => { println!("Scalar message from {}: {:?}", envelope.sender, msg) } diff --git a/examples/shell/src/logstr.rs b/examples/shell/src/logstr.rs index fb697f46d..8d33e6af4 100644 --- a/examples/shell/src/logstr.rs +++ b/examples/shell/src/logstr.rs @@ -18,13 +18,13 @@ impl<'a> LogStr<'a> { ) .expect("couldn't allocate memory"); - let raw_slice = unsafe { slice::from_raw_parts_mut(mem.base, 4096) }; + let raw_slice = unsafe { slice::from_raw_parts_mut(mem.as_ptr() as *mut u8, 4096) }; LogStr { raw_slice, len: 0, string: unsafe { - core::str::from_utf8_unchecked(slice::from_raw_parts(mem.base, 0)) + core::str::from_utf8_unchecked(slice::from_raw_parts(mem.as_ptr() as *mut u8, 0)) }, } } @@ -32,8 +32,7 @@ impl<'a> LogStr<'a> { pub fn into_memory_message(self, id: xous::MessageId) -> Result { Ok(xous::MemoryMessage { id: id, - buf: xous::MemoryAddress::new(self.raw_slice.as_ptr() as usize), - buf_size: xous::MemorySize::new(self.raw_slice.len()), + buf: xous::MemoryRange::new(self.raw_slice.as_ptr() as usize, self.raw_slice.len()), offset: None, valid: xous::MemorySize::new(self.len), }) diff --git a/examples/shell/src/main.rs b/examples/shell/src/main.rs index dd21f7f5c..8a3015dd0 100644 --- a/examples/shell/src/main.rs +++ b/examples/shell/src/main.rs @@ -45,8 +45,8 @@ fn main() { xous::MemoryFlags::R | xous::MemoryFlags::W, ) .expect("couldn't map uart"); - unsafe { debug::DEFAULT_UART_ADDR = uart.base as *mut usize }; - println!("Mapped UART @ {:08x}", uart.base as usize); + unsafe { debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() }; + println!("Mapped UART @ {:08x}", uart.addr.get() ); xous::syscall::map_memory( xous::MemoryAddress::new(0xf0002000), diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index a6b736746..c7db62f9a 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -8,7 +8,7 @@ description = "Core kernel for Xous, including task switching and memory managem [dependencies] bitflags = "1.2.1" riscv = "0.5.6" -xous = { path = "../xous-rs" } +xous = { path = "../xous-rs", features = ["forget-memory-messages"] } [dependencies.sha3] default-features = false diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index 7db7b6016..4e90253b5 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -6,7 +6,7 @@ use core::str; pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE}; use crate::arch::process::ProcessHandle; -use xous::{MemoryFlags, PID}; +use xous::{MemoryFlags, MemoryRange, PID}; #[derive(Debug)] enum ClaimOrRelease { @@ -339,10 +339,7 @@ impl MemoryManager { // FIXME: Un-reserve addresses if we encounter an error here mm.reserve_address(self, virt, flags)?; } - Ok(xous::MemoryRange { - base: virt_ptr as *mut u8, - size, - }) + Ok(xous::MemoryRange::new(virt_ptr as usize, size)) } /// Attempt to allocate a single page from the default section. @@ -433,10 +430,7 @@ impl MemoryManager { } } - Ok(xous::MemoryRange { - base: virt as *mut u8, - size, - }) + Ok(MemoryRange::new(virt, size)) } /// Attempt to map the given physical address into the virtual address space diff --git a/kernel/src/server.rs b/kernel/src/server.rs index d30fa476d..c30d84162 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -1,6 +1,6 @@ pub use crate::arch::ProcessContext; use core::{mem, slice}; -use xous::{CtxID, MemoryAddress, MemorySize, PID, SID}; +use xous::{CtxID, MemoryRange, MemorySize, PID, SID}; /// Internal representation of a queued message for a server. This should be /// exactly 8 words / 32 bytes, yielding 128 queued messages per server @@ -116,8 +116,7 @@ impl Server { sender: sender, message: xous::Message::ImmutableBorrow(xous::MemoryMessage { id, - buf: MemoryAddress::new(buf), - buf_size: MemorySize::new(buf_size), + buf: MemoryRange::new(buf, buf_size), offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -137,8 +136,7 @@ impl Server { sender: sender, message: xous::Message::MutableBorrow(xous::MemoryMessage { id, - buf: MemoryAddress::new(buf), - buf_size: MemorySize::new(buf_size), + buf: MemoryRange::new(buf, buf_size), offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -151,8 +149,7 @@ impl Server { sender: sender, message: xous::Message::Move(xous::MemoryMessage { id, - buf: MemoryAddress::new(buf), - buf_size: MemorySize::new(buf_size), + buf: MemoryRange::new(buf, buf_size), offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -206,8 +203,8 @@ impl Server { envelope.sender, context, msg.id, - msg.buf.map(|x| x.get()).unwrap_or(0) as usize, - msg.buf_size.map(|x| x.get()).unwrap_or(0) as usize, + msg.buf.addr.get(), + msg.buf.size.get(), msg.offset.map(|x| x.get()).unwrap_or(0) as usize, msg.valid.map(|x| x.get()).unwrap_or(0) as usize, ), diff --git a/kernel/src/services.rs b/kernel/src/services.rs index dba63e02f..534c990f8 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -712,7 +712,7 @@ impl SystemServices { ); if let Ok(ref range) = result { for offset in - ((range.base as usize)..(range.base as usize + range.size)).step_by(PAGE_SIZE) + (range.addr.get()..(range.addr.get() + range.size.get())).step_by(PAGE_SIZE) { println!("Handing page to user"); crate::arch::mem::hand_page_to_user(offset as *mut usize) @@ -729,9 +729,9 @@ impl SystemServices { "send_memory: Sent phys {:08x} from {:08x} to {:08x}", phys, src_virt as usize, - result.as_ref().unwrap().base as usize + result.as_ref().unwrap().addr.get() ); - result.map(|virt| virt.base as usize) + result.map(|virt| virt.addr.get()) } pub fn spawn_thread( diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index d5b6eb221..850c86865 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -162,17 +162,18 @@ pub fn handle(call: SysCall) -> core::result::Result if mm.is_main_memory(phys) { println!( "Going to zero out {} bytes @ {:08x}", - range.size, range.base as usize + range.size.get(), + range.addr.get() ); unsafe { range - .base - .write_bytes(0, range.size / mem::size_of::()) + .as_mut_ptr() + .write_bytes(0, range.size.get() / mem::size_of::()) }; println!("Done zeroing out"); } for offset in - ((range.base as usize)..(range.base as usize + range.size)).step_by(PAGE_SIZE) + (range.addr.get()..(range.addr.get() + range.size.get())).step_by(PAGE_SIZE) { println!("Handing page to user"); crate::arch::mem::hand_page_to_user(offset as *mut usize) @@ -189,7 +190,7 @@ pub fn handle(call: SysCall) -> core::result::Result if virt & 0xfff != 0 { return Err(xous::Error::BadAlignment); } - for addr in (virt..(virt+size)).step_by(PAGE_SIZE) { + for addr in (virt..(virt + size)).step_by(PAGE_SIZE) { if let Err(e) = mm.unmap_page(addr as *mut usize) { if result.is_ok() { result = Err(e); @@ -323,26 +324,17 @@ pub fn handle(call: SysCall) -> core::result::Result let (message, blocking) = match message { Message::Scalar(_) => (message, false), Message::Move(msg) => { - let new_virt = if let Some(virt) = msg.buf { - if msg.buf_size.is_none() { - return Err(xous::Error::BadAddress); - } - let len = msg.buf_size.unwrap().get(); - MemoryAddress::new(ss.send_memory( - virt.get() as *mut usize, + let new_virt = ss.send_memory( + msg.buf.as_mut_ptr(), server_pid, - len, + msg.buf.len(), true, false, - )?) - } else { - None - }; + )?; ( Message::Move(MemoryMessage { id: msg.id, - buf: new_virt, - buf_size: msg.buf_size, + buf: MemoryRange::new(new_virt, msg.buf.len()), offset: msg.offset, valid: msg.valid, }), diff --git a/xous-rs/Cargo.toml b/xous-rs/Cargo.toml index 8089f171d..1965b1b48 100644 --- a/xous-rs/Cargo.toml +++ b/xous-rs/Cargo.toml @@ -12,3 +12,8 @@ num-derive = "0.3.0" [dependencies.num-traits] version = "0.2" default-features = false + +[features] +# If this is set, then the "Drop" feature of MemoryMessage structs +# will not be implemented. This should only be set by the kernel. +forget-memory-messages = [] diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index ed6b9fc90..6560e45fd 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -21,6 +21,12 @@ pub type CtxID = usize; /// Equivalent to a RISC-V Hart ID pub type CpuID = usize; +#[derive(Debug, PartialEq)] +pub struct MemoryRange { + pub addr: MemoryAddress, + pub size: MemorySize, +} + #[repr(usize)] #[derive(Debug, PartialEq)] pub enum Error { @@ -42,6 +48,7 @@ pub enum Error { ServerQueueFull = 15, ContextNotAvailable = 16, UnhandledSyscall = 17, + InvalidSyscall = 18, } #[repr(C)] @@ -55,27 +62,33 @@ pub struct Context { /// A struct describing memory that is passed between processes. /// The `buf` value will get translated as necessary. pub struct MemoryMessage { - /// A user-assignable message ID. pub id: MessageId, - /// The offset of the buffer. This address will get - /// transformed when the message is moved between - /// processes. - pub buf: Option, + /// The offset of the buffer. This address will get transformed when the + /// message is moved between processes. + pub buf: MemoryRange, - /// The overall size of the buffer. Must be a multiple - /// of PAGE_SIZE. - pub buf_size: Option, - - /// The offset within the buffer where the interesting - /// stuff starts. + /// The offset within the buffer where the interesting stuff starts. pub offset: Option, /// How many bytes in the buffer are valid pub valid: Option, } +#[cfg(not(feature = "forget-memory-messages"))] +impl Drop for MessageEnvelope { + fn drop(&mut self) { + match &self.message { + Message::MutableBorrow(msg) | Message::ImmutableBorrow(msg) | Message::Move(msg) => { + crate::syscall::unmap_memory(msg.buf.addr, msg.buf.size) + .expect("couldn't free memory message"); + } + Message::Scalar(_) => (), + } + } +} + #[repr(C)] #[derive(Debug, PartialEq)] /// A simple scalar message. This is similar to a `move` message. @@ -102,3 +115,28 @@ pub struct MessageEnvelope { pub sender: MessageSender, pub message: Message, } + +impl MemoryRange { + pub fn new(addr: usize, size: usize) -> MemoryRange { + assert!( + addr != 0, + "tried to construct a memory range with a null pointer" + ); + MemoryRange { + addr: MemoryAddress::new(addr).unwrap(), + size: MemorySize::new(size).unwrap(), + } + } + + pub fn len(&self) -> usize { + self.size.get() + } + + pub fn as_ptr(&self) -> *const usize { + self.addr.get() as *const usize + } + + pub fn as_mut_ptr(&self) -> *mut usize { + self.addr.get() as *mut usize + } +} diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index 4d59dbe43..6b9714a52 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -1,6 +1,6 @@ use crate::{ - CpuID, CtxID, Error, MemoryAddress, MemoryMessage, MemorySize, Message, MessageEnvelope, - ScalarMessage, CID, PID, SID, + CpuID, CtxID, Error, MemoryAddress, MemoryMessage, MemoryRange, MemorySize, Message, + MessageEnvelope, ScalarMessage, CID, PID, SID, }; use num_derive::FromPrimitive; use num_traits::FromPrimitive; @@ -316,9 +316,6 @@ enum SysCallNumber { Invalid, } -#[derive(Debug)] -pub struct InvalidSyscall {} - impl SysCall { pub fn as_args(&self) -> [usize; 8] { use core::mem; @@ -462,8 +459,8 @@ impl SysCall { a1, 1, mm.id as usize, - mm.buf.map(|x| x.get()).unwrap_or(0) as usize, - mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize, + mm.buf.as_ptr() as usize, + mm.buf.len(), mm.offset.map(|x| x.get()).unwrap_or(0) as usize, mm.valid.map(|x| x.get()).unwrap_or(0) as usize, ], @@ -472,8 +469,8 @@ impl SysCall { a1, 2, mm.id as usize, - mm.buf.map(|x| x.get()).unwrap_or(0) as usize, - mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize, + mm.buf.as_ptr() as usize, + mm.buf.len(), mm.offset.map(|x| x.get()).unwrap_or(0) as usize, mm.valid.map(|x| x.get()).unwrap_or(0) as usize, ], @@ -482,8 +479,8 @@ impl SysCall { a1, 3, mm.id as usize, - mm.buf.map(|x| x.get()).unwrap_or(0) as usize, - mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize, + mm.buf.as_ptr() as usize, + mm.buf.len(), mm.offset.map(|x| x.get()).unwrap_or(0) as usize, mm.valid.map(|x| x.get()).unwrap_or(0) as usize, ], @@ -522,13 +519,13 @@ impl SysCall { a5: usize, a6: usize, a7: usize, - ) -> core::result::Result { + ) -> core::result::Result { Ok(match FromPrimitive::from_usize(a0) { Some(SysCallNumber::MapMemory) => SysCall::MapMemory( a1 as *mut usize, a2 as *mut usize, a3, - MemoryFlags::from_bits(a4).ok_or(InvalidSyscall {})?, + MemoryFlags::from_bits(a4).ok_or(Error::InvalidSyscall)?, ), Some(SysCallNumber::UnmapMemory) => SysCall::UnmapMemory(a1 as *mut usize, a2), Some(SysCallNumber::Yield) => SysCall::Yield, @@ -543,13 +540,13 @@ impl SysCall { Some(SysCallNumber::ReadyContexts) => SysCall::ReadyContexts(a1 as u8), Some(SysCallNumber::IncreaseHeap) => SysCall::IncreaseHeap( a1 as usize, - MemoryFlags::from_bits(a2).ok_or(InvalidSyscall {})?, + MemoryFlags::from_bits(a2).ok_or(Error::InvalidSyscall)?, ), Some(SysCallNumber::DecreaseHeap) => SysCall::DecreaseHeap(a1 as usize), Some(SysCallNumber::UpdateMemoryFlags) => SysCall::UpdateMemoryFlags( a1 as *mut usize, a2 as usize, - MemoryFlags::from_bits(a3).ok_or(InvalidSyscall {})?, + MemoryFlags::from_bits(a3).ok_or(Error::InvalidSyscall)?, ), Some(SysCallNumber::SetMemRegion) => { SysCall::SetMemRegion(a1 as PID, MemoryType::from(a2), a3 as *mut usize, a4) @@ -561,8 +558,7 @@ impl SysCall { a1, Message::MutableBorrow(MemoryMessage { id: a3, - buf: MemoryAddress::new(a4), - buf_size: MemorySize::new(a5), + buf: MemoryRange::new(a4, a5), offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -571,8 +567,7 @@ impl SysCall { a1, Message::ImmutableBorrow(MemoryMessage { id: a3, - buf: MemoryAddress::new(a4), - buf_size: MemorySize::new(a5), + buf: MemoryRange::new(a4, a5), offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -581,8 +576,7 @@ impl SysCall { a1, Message::Move(MemoryMessage { id: a3, - buf: MemoryAddress::new(a4), - buf_size: MemorySize::new(a5), + buf: MemoryRange::new(a4, a5), offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -603,17 +597,11 @@ impl SysCall { SysCall::SpawnThread(a1 as *mut usize, a2 as *mut usize, a3 as *mut usize) } Some(SysCallNumber::Invalid) => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7), - None => return Err(InvalidSyscall {}), + None => return Err(Error::InvalidSyscall), }) } } -#[derive(Debug, PartialEq)] -pub struct MemoryRange { - pub base: *mut u8, - pub size: usize, -} - #[repr(C)] #[derive(Debug, PartialEq)] pub enum Result { @@ -696,8 +684,8 @@ pub fn map_memory( /// Map the given physical address to the given virtual address. /// The `size` field must be page-aligned. -pub fn unmap_memory(virt: MemoryAddress, size: usize) -> core::result::Result<(), Error> { - let result = rsyscall(SysCall::UnmapMemory(virt.get() as *mut usize, size))?; +pub fn unmap_memory(virt: MemoryAddress, size: MemorySize) -> core::result::Result<(), Error> { + let result = rsyscall(SysCall::UnmapMemory(virt.get() as *mut usize, size.get()))?; if let Result::Ok = result { Ok(()) } else if let Result::Error(e) = result {