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 <sean@xobs.io>
This commit is contained in:
Sean Cross 2021-06-24 17:02:02 +08:00
parent f93e06939e
commit 977a175bb5
8 changed files with 43 additions and 38 deletions

View file

@ -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

View file

@ -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),
}),

View file

@ -337,7 +337,9 @@ impl SystemServices {
} else {
process.state = ProcessState::Setup(ThreadInit::new(
unsafe { core::mem::transmute::<usize, _>(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,

View file

@ -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,
})

View file

@ -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<ThreadInit, crate::Error> {
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,

View file

@ -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<MemoryRange, Error> {
pub unsafe fn new(addr: usize, size: usize) -> core::result::Result<MemoryRange, Error> {
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 }
}

View file

@ -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");
}
}

View file

@ -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,