MemoryRange: move to using this struct for memory ranges

This is a combination of MemoryAddress and MemorySize.  This is
guaranteed to be not null.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-04-01 10:28:36 +08:00
parent 94459c8d43
commit bdb8eac9ad
12 changed files with 107 additions and 108 deletions

View file

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

View file

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

View file

@ -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<xous::MemoryMessage, xous::Error> {
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),
})

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -162,17 +162,18 @@ pub fn handle(call: SysCall) -> core::result::Result<xous::Result, xous::Error>
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::<usize>())
.as_mut_ptr()
.write_bytes(0, range.size.get() / mem::size_of::<usize>())
};
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<xous::Result, xous::Error>
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<xous::Result, xous::Error>
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,
}),

View file

@ -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 = []

View file

@ -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<MemoryAddress>,
/// 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<MemorySize>,
/// The offset within the buffer where the interesting
/// stuff starts.
/// The offset within the buffer where the interesting stuff starts.
pub offset: Option<MemorySize>,
/// How many bytes in the buffer are valid
pub valid: Option<MemorySize>,
}
#[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
}
}

View file

@ -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<Self, InvalidSyscall> {
) -> core::result::Result<Self, Error> {
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 {