From 977a175bb57e5377f91e8af0cc62f60a48171ab6 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Thu, 24 Jun 2021 17:02:02 +0800 Subject: [PATCH] xous: mark `MemoryRange::new()` as `unsafe` This function allows for creating arbitrary memory ranges. Mark this function as `unsafe` in order to warn users that this can be used to create invalid memory regions. Signed-off-by: Sean Cross --- kernel/src/mem.rs | 4 ++-- kernel/src/server.rs | 17 ++++++++--------- kernel/src/services.rs | 14 ++++++++------ kernel/src/syscall.rs | 6 +++--- xous-rs/src/arch/native.rs | 4 ++-- xous-rs/src/definitions.rs | 9 +++++---- xous-rs/src/stringbuffer.rs | 11 +++++++---- xous-rs/src/syscall.rs | 16 ++++++++-------- 8 files changed, 43 insertions(+), 38 deletions(-) diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index 576d61f2e..025c971fb 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -386,7 +386,7 @@ impl MemoryManager { // FIXME: Un-reserve addresses if we encounter an error here mm.reserve_address(self, virt, flags)?; } - Ok(xous_kernel::MemoryRange::new(virt_ptr as usize, size)?) + Ok(unsafe { xous_kernel::MemoryRange::new(virt_ptr as usize, size) }?) } /// Attempt to allocate a single page from the default section. @@ -490,7 +490,7 @@ impl MemoryManager { } } - Ok(MemoryRange::new(virt as usize, size)?) + Ok(unsafe { MemoryRange::new(virt as usize, 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 06c750c64..be53be47f 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -632,10 +632,9 @@ impl Server { } if forget { - return Ok(WaitingMessage::ForgetMemory(MemoryRange::new( - server_addr, - len, - )?)); + return Ok(WaitingMessage::ForgetMemory(unsafe { + MemoryRange::new(server_addr, len) + }?)); } // If a `move` address somehow ends up here, indicate the memory has been moved. @@ -706,7 +705,7 @@ impl Server { sender: sender.into(), body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { id, - buf: MemoryRange::new(server_addr, buf_size).ok()?, + buf: unsafe { MemoryRange::new(server_addr, buf_size).ok() }?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -738,7 +737,7 @@ impl Server { sender: sender.into(), body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { id, - buf: MemoryRange::new(server_addr, buf_size).ok()?, + buf: unsafe { MemoryRange::new(server_addr, buf_size).ok() }?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -770,7 +769,7 @@ impl Server { sender: sender.into(), body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { id, - buf: MemoryRange::new(server_addr, buf_size).ok()?, + buf: unsafe { MemoryRange::new(server_addr, buf_size).ok() }?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -802,7 +801,7 @@ impl Server { sender: sender.into(), body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { id, - buf: MemoryRange::new(server_addr, buf_size).ok()?, + buf: unsafe { MemoryRange::new(server_addr, buf_size).ok() }?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -862,7 +861,7 @@ impl Server { sender: sender.into(), body: xous_kernel::Message::Move(xous_kernel::MemoryMessage { id, - buf: MemoryRange::new(server_addr, buf_size).ok()?, + buf: unsafe { MemoryRange::new(server_addr, buf_size).ok() }?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), diff --git a/kernel/src/services.rs b/kernel/src/services.rs index c4606fd09..293582121 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -337,7 +337,9 @@ impl SystemServices { } else { process.state = ProcessState::Setup(ThreadInit::new( unsafe { core::mem::transmute::(init.entrypoint) }, - MemoryRange::new(init.sp, crate::arch::process::DEFAULT_STACK_SIZE).unwrap(), + unsafe { + MemoryRange::new(init.sp, crate::arch::process::DEFAULT_STACK_SIZE).unwrap() + }, pid, 0, 0, @@ -465,8 +467,8 @@ impl SystemServices { // This can happen when the process handles a debug interrupt. ProcessState::Debug(_) => { crate::syscall::reset_switchto_caller(); - return self.switch_to_thread(ppid, None) - }, + return self.switch_to_thread(ppid, None); + } other => panic!( "process {} was in an invalid state {:?} -- thread {} not available to run", pid, other, tid @@ -1407,8 +1409,8 @@ impl SystemServices { len: usize, // buf: MemoryRange, ) -> Result<*mut usize, xous_kernel::Error> { - let buf = MemoryRange::new(src_virt as usize, len)?; - let buf = unsafe { core::slice::from_raw_parts(buf.as_ptr(), buf.len()) }; + let buf = unsafe { MemoryRange::new(src_virt as usize, len) }?; + let buf = buf.as_slice(); let current_pid = self.current_pid(); { let target_process = self.get_process(dest_pid)?; @@ -1586,7 +1588,7 @@ impl SystemServices { if entry == &None { #[cfg(baremetal)] // Allocate a single page for the server queue - let backing = crate::mem::MemoryManager::with_mut(|mm| { + let backing = crate::mem::MemoryManager::with_mut(|mm| unsafe { MemoryRange::new( mm.map_zeroed_page(pid, false)? as _, crate::arch::mem::PAGE_SIZE, diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 36518fb2f..e9a674baf 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -99,7 +99,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes )?; Message::Move(MemoryMessage { id: msg.id, - buf: MemoryRange::new(new_virt as usize, msg.buf.len())?, + buf: unsafe { MemoryRange::new(new_virt as usize, msg.buf.len()) }?, offset: msg.offset, valid: msg.valid, }) @@ -114,7 +114,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes )?; Message::MutableBorrow(MemoryMessage { id: msg.id, - buf: MemoryRange::new(new_virt as usize, msg.buf.len())?, + buf: unsafe { MemoryRange::new(new_virt as usize, msg.buf.len()) }?, offset: msg.offset, valid: msg.valid, }) @@ -137,7 +137,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes // ); Message::Borrow(MemoryMessage { id: msg.id, - buf: MemoryRange::new(new_virt as usize, msg.buf.len())?, + buf: unsafe { MemoryRange::new(new_virt as usize, msg.buf.len()) }?, offset: msg.offset, valid: msg.valid, }) diff --git a/xous-rs/src/arch/native.rs b/xous-rs/src/arch/native.rs index bbce6c22e..3dc1f1d1c 100644 --- a/xous-rs/src/arch/native.rs +++ b/xous-rs/src/arch/native.rs @@ -47,7 +47,7 @@ impl Default for ThreadInit { fn default() -> Self { ThreadInit { call: 1, - stack: MemoryRange::new(4, 4).unwrap(), + stack: unsafe { MemoryRange::new(4, 4).unwrap() }, arg1: 0, arg2: 0, arg3: 0, @@ -103,7 +103,7 @@ pub fn args_to_thread( ) -> core::result::Result { Ok(ThreadInit { call: a1, - stack: MemoryRange::new(a2, a3).map_err(|_| crate::Error::InvalidSyscall)?, + stack: unsafe { MemoryRange::new(a2, a3).map_err(|_| crate::Error::InvalidSyscall) }?, arg1: a4, arg2: a5, arg3: a6, diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index d15c81d4d..a1c48d707 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -512,19 +512,19 @@ impl TryFrom<(usize, usize, usize, usize, usize, usize)> for Message { match value.0 { 1 => Ok(Message::MutableBorrow(MemoryMessage { id: value.1, - buf: MemoryRange::new(value.2, value.3).map_err(|_| ())?, + buf: unsafe { MemoryRange::new(value.2, value.3).map_err(|_| ()) }?, offset: MemoryAddress::new(value.4), valid: MemorySize::new(value.5), })), 2 => Ok(Message::Borrow(MemoryMessage { id: value.1, - buf: MemoryRange::new(value.2, value.3).map_err(|_| ())?, + buf: unsafe { MemoryRange::new(value.2, value.3).map_err(|_| ()) }?, offset: MemoryAddress::new(value.4), valid: MemorySize::new(value.5), })), 3 => Ok(Message::Move(MemoryMessage { id: value.1, - buf: MemoryRange::new(value.2, value.3).map_err(|_| ())?, + buf: unsafe { MemoryRange::new(value.2, value.3).map_err(|_| ()) }?, offset: MemoryAddress::new(value.4), valid: MemorySize::new(value.5), })), @@ -605,7 +605,7 @@ impl Drop for MessageEnvelope { } impl MemoryRange { - pub fn new(addr: usize, size: usize) -> core::result::Result { + pub unsafe fn new(addr: usize, size: usize) -> core::result::Result { assert!( addr != 0, "tried to construct a memory range with a null pointer" @@ -617,6 +617,7 @@ impl MemoryRange { }) } + #[deprecated(since = "0.8.4", note = "Please use `new(addr, size)` instead")] pub fn from_parts(addr: MemoryAddress, size: MemorySize) -> MemoryRange { MemoryRange { addr, size } } diff --git a/xous-rs/src/stringbuffer.rs b/xous-rs/src/stringbuffer.rs index cdf0b6f93..6a84d838c 100644 --- a/xous-rs/src/stringbuffer.rs +++ b/xous-rs/src/stringbuffer.rs @@ -117,7 +117,8 @@ impl<'a> StringBuffer<'a> { if let Some(old_slice) = self.bytes.take() { let old_addr = old_slice.as_ptr(); let old_length = old_slice.len(); - unmap_memory(MemoryRange::new(old_addr as usize, old_length).unwrap()).unwrap(); + unmap_memory(unsafe { MemoryRange::new(old_addr as usize, old_length).unwrap() }) + .unwrap(); } self.bytes = new_slice; @@ -199,7 +200,8 @@ impl<'a> StringBuffer<'a> { fn create_memory_message(&self, id: u32) -> MemoryMessage { if let Some(bytes) = &self.bytes { - let backing_store = MemoryRange::new(bytes.as_ptr() as _, bytes.len()).unwrap(); + let backing_store = + unsafe { MemoryRange::new(bytes.as_ptr() as _, bytes.len()).unwrap() }; MemoryMessage { id: id as usize, buf: backing_store, @@ -316,8 +318,9 @@ impl<'a> Eq for StringBuffer<'a> {} impl<'a> Drop for StringBuffer<'a> { fn drop(&mut self) { if self.should_free && self.as_bytes().len() != 0 { - let range = - MemoryRange::new(self.as_bytes().as_ptr() as _, self.as_bytes().len()).unwrap(); + let range = unsafe { + MemoryRange::new(self.as_bytes().as_ptr() as _, self.as_bytes().len()).unwrap() + }; unmap_memory(range).expect("Buffer: failed to drop memory"); } } diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index 7f3650f53..a17dd81ec 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -767,9 +767,9 @@ impl SysCall { MemoryAddress::new(a3).ok_or(Error::InvalidSyscall)?, crate::from_bits(a4).ok_or(Error::InvalidSyscall)?, ), - SysCallNumber::UnmapMemory => { - SysCall::UnmapMemory(MemoryRange::new(a1, a2).or(Err(Error::InvalidSyscall))?) - } + SysCallNumber::UnmapMemory => SysCall::UnmapMemory(unsafe { + MemoryRange::new(a1, a2).or(Err(Error::InvalidSyscall)) + }?), SysCallNumber::Yield => SysCall::Yield, SysCallNumber::WaitEvent => SysCall::WaitEvent, SysCallNumber::ReceiveMessage => { @@ -815,7 +815,7 @@ impl SysCall { .unwrap_or_else(|_| SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7)), SysCallNumber::ReturnMemory => SysCall::ReturnMemory( MessageSender::from_usize(a1), - MemoryRange::new(a2, a3)?, + unsafe { MemoryRange::new(a2, a3) }?, MemorySize::new(a4), MemorySize::new(a5), ), @@ -835,7 +835,7 @@ impl SysCall { a1 as u32, Message::MutableBorrow(MemoryMessage { id: a3, - buf: MemoryRange::new(a4, a5)?, + buf: unsafe { MemoryRange::new(a4, a5) }?, offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -844,7 +844,7 @@ impl SysCall { a1 as u32, Message::Borrow(MemoryMessage { id: a3, - buf: MemoryRange::new(a4, a5)?, + buf: unsafe { MemoryRange::new(a4, a5) }?, offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -853,7 +853,7 @@ impl SysCall { a1 as u32, Message::Move(MemoryMessage { id: a3, - buf: MemoryRange::new(a4, a5)?, + buf: unsafe { MemoryRange::new(a4, a5) }?, offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -968,7 +968,7 @@ impl SysCall { /// Returns `true` if the given syscall may be called from an IRQ context pub fn can_call_from_interrupt(&self) -> bool { if let SysCall::TrySendMessage(_cid, msg) = self { - return ! msg.is_blocking(); + return !msg.is_blocking(); } matches!( self,