test mutable borrows

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-04-03 14:24:02 +08:00
parent fd5cc8a1f0
commit 8789203eb3
6 changed files with 84 additions and 28 deletions

View file

@ -3,23 +3,27 @@ use core::slice;
use xous;
pub struct LogString<'a> {
raw_slice: &'a mut [u8],
s: &'a str,
len: usize,
msg_len: &'a mut Option<xous::MemorySize>,
}
impl<'a> LogString<'a> {
pub fn from_message(message: &xous::MemoryMessage) -> LogString<'a> {
println!(
"Message address is at {:08x}",
message.buf.addr.get()
);
pub fn from_message(message: &'a mut xous::MemoryMessage) -> LogString<'a> {
println!("Message address is at {:08x}", message.buf.addr.get());
let raw_slice = unsafe { slice::from_raw_parts_mut(message.buf.as_ptr() as *mut u8, message.buf.len()) };
let starting_length = message.valid.map(|x| x.get()).unwrap_or(0);
LogString {
s: unsafe {
core::str::from_utf8(slice::from_raw_parts(
message.buf.addr.get() as *mut u8,
message.valid.expect("no buffer length present").get(),
core::str::from_utf8_unchecked(slice::from_raw_parts(
message.buf.as_ptr() as *mut u8,
starting_length,
))
.expect("message didn't have valid utf8")
},
len: starting_length,
raw_slice,
msg_len: &mut message.valid,
}
}
}
@ -29,3 +33,17 @@ impl<'a> fmt::Display for LogString<'a> {
write!(f, "{}", self.s)
}
}
impl<'a> fmt::Write for LogString<'a> {
fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
for c in s.bytes() {
self.raw_slice[self.len] = c;
self.len += 1;
}
self.s = unsafe {
core::str::from_utf8_unchecked(slice::from_raw_parts(self.raw_slice.as_ptr(), self.len))
};
*self.msg_len = Some(xous::MemorySize::new(self.len).unwrap());
Ok(())
}
}

View file

@ -7,6 +7,7 @@ mod log_string;
mod start;
use core::panic::PanicInfo;
use core::fmt::Write;
use log_string::LogString;
#[panic_handler]
@ -80,9 +81,9 @@ fn main() {
loop {
// println!("Waiting for an event...");
let envelope = xous::syscall::receive_message(server_addr).expect("couldn't get address");
let mut envelope = xous::syscall::receive_message(server_addr).expect("couldn't get address");
// println!("Got message envelope: {:?}", envelope);
match &envelope.message {
match &mut envelope.message {
xous::Message::Scalar(msg) => {
println!("Scalar message from {}: {:?}", envelope.sender, msg)
}
@ -94,7 +95,11 @@ fn main() {
let log_entry = LogString::from_message(msg);
println!("Immutably borrowed log message from {}: {}", envelope.sender, log_entry);
}
_ => unimplemented!(),
xous::Message::MutableBorrow(msg) => {
let mut log_entry = LogString::from_message(msg);
println!("Immutably borrowed log message from {}: {}", envelope.sender, log_entry);
writeln!(log_entry, " << HELLO FROM THE SERVER").unwrap();
}
}
}
}

View file

@ -29,6 +29,7 @@ impl<'a> LogStr<'a> {
}
}
#[allow(dead_code)]
pub fn into_memory_message(self, id: xous::MessageId) -> Result<xous::MemoryMessage, xous::Error> {
// XXX This should forget the memory allocated, as it will be sent to the other process
Ok(xous::MemoryMessage {
@ -51,6 +52,11 @@ impl<'a> LogStr<'a> {
pub fn clear(&mut self) {
self.len = 0;
}
pub unsafe fn set_len(&mut self, len: usize) {
self.len = len;
self.string = core::str::from_utf8_unchecked(slice::from_raw_parts(self.raw_slice.as_ptr(), self.len));
}
}
impl<'a> Write for LogStr<'a> {
@ -63,3 +69,9 @@ impl<'a> Write for LogStr<'a> {
Ok(())
}
}
impl<'a> core::fmt::Display for LogStr<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.string)
}
}

View file

@ -147,13 +147,15 @@ fn main() {
write!(ls, "Hello, Server! This memory is borrowed from another process. Loop number: {}", counter).expect("couldn't send hello message");
println!("Sending a mutable borrow message");
xous::syscall::send_message(
let response = xous::syscall::send_message(
connection,
xous::Message::ImmutableBorrow(
xous::Message::MutableBorrow(
ls.as_memory_message(0)
.expect("couldn't form memory message"),
),
)
.expect("couldn't send memory message");
unsafe { ls.set_len(response.0)};
println!("Message came back with args ({}, {}) as: {}", response.0, response.1, ls);
}
}

View file

@ -27,7 +27,6 @@ pub struct MemoryRange {
pub size: MemorySize,
}
bitflags! {
/// Flags to be passed to the MapMemory struct.
/// Note that it is an error to have memory be
@ -135,10 +134,17 @@ pub struct MessageEnvelope {
/// (in the case of a Borrow). Ignore Scalar messages.
impl Drop for MessageEnvelope {
fn drop(&mut self) {
crate::syscall::return_memory(self.sender).expect("couldn't return memory");
let (arg1, arg2) = match &self.message {
Message::ImmutableBorrow(x) | Message::MutableBorrow(x) => (
x.valid.map(|x| x.get()).unwrap_or(0),
x.offset.map(|x| x.get()).unwrap_or(0),
),
_ => (0, 0),
};
crate::syscall::return_memory(self.sender, arg1, arg2).expect("couldn't return memory");
if let Message::Move(msg) = &self.message {
crate::syscall::unmap_memory(msg.buf.addr, msg.buf.size)
.expect("couldn't free memory message");
.expect("couldn't free memory message");
}
}
}

View file

@ -1,6 +1,6 @@
use crate::{
CpuID, CtxID, Error, MemoryAddress, MemoryFlags, MemoryMessage, MemoryRange, MemorySize, Message,
MessageEnvelope, MessageSender, ScalarMessage, CID, PID, SID,
CpuID, CtxID, Error, MemoryAddress, MemoryFlags, MemoryMessage, MemoryRange, MemorySize,
Message, MessageEnvelope, MessageSender, ScalarMessage, CID, PID, SID,
};
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
@ -259,7 +259,7 @@ pub enum SysCall {
SendMessage(CID, Message),
/// Return a Borrowed memory region to a sender
ReturnMemory(MessageSender),
ReturnMemory(MessageSender, usize /* arg1 */, usize /* arg2 */),
/// Spawn a new thread
SpawnThread(
@ -475,8 +475,16 @@ impl SysCall {
sc.arg4,
],
},
SysCall::ReturnMemory(a1) => [SysCallNumber::ReturnMemory as usize,
*a1, 0, 0, 0, 0, 0, 0],
SysCall::ReturnMemory(a1, a2, a3) => [
SysCallNumber::ReturnMemory as usize,
*a1,
*a2,
*a3,
0,
0,
0,
0,
],
SysCall::SpawnThread(a1, a2, a3) => [
SysCallNumber::SpawnThread as usize,
*a1 as usize,
@ -582,7 +590,7 @@ impl SysCall {
),
_ => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
},
Some(SysCallNumber::ReturnMemory) => SysCall::ReturnMemory(a1),
Some(SysCallNumber::ReturnMemory) => SysCall::ReturnMemory(a1, a2, a3),
Some(SysCallNumber::SpawnThread) => {
SysCall::SpawnThread(a1 as *mut usize, a2 as *mut usize, a3 as *mut usize)
}
@ -613,6 +621,7 @@ pub enum Result {
ConnectionID(CID),
Message(MessageEnvelope),
ThreadID(CtxID),
MessageResult(usize, usize),
UnknownResult(usize, usize, usize, usize, usize, usize, usize),
}
@ -687,8 +696,12 @@ pub fn unmap_memory(virt: MemoryAddress, size: MemorySize) -> core::result::Resu
/// Map the given physical address to the given virtual address.
/// The `size` field must be page-aligned.
pub fn return_memory(sender: MessageSender) -> core::result::Result<(), Error> {
let result = rsyscall(SysCall::ReturnMemory(sender))?;
pub fn return_memory(
sender: MessageSender,
arg1: usize,
arg2: usize,
) -> core::result::Result<(), Error> {
let result = rsyscall(SysCall::ReturnMemory(sender, arg1, arg2))?;
if let Result::Ok = result {
Ok(())
} else if let Result::Error(e) = result {
@ -777,11 +790,11 @@ pub fn receive_message(server: SID) -> core::result::Result<MessageEnvelope, Err
/// * **ServerNotFound**: The server does not exist so the connection is now invalid
/// * **BadAddress**: The client tried to pass a Memory message using an address it doesn't own
/// * **Timeout**: The timeout limit has been reached
pub fn send_message(connection: CID, message: Message) -> core::result::Result<(), Error> {
pub fn send_message(connection: CID, message: Message) -> core::result::Result<(usize, usize), Error> {
let result =
rsyscall(SysCall::SendMessage(connection, message)).expect("couldn't send message");
if result == Result::Ok {
Ok(())
if let Result::MessageResult(arg1, arg2) = result {
Ok((arg1, arg2))
} else if let Result::Error(e) = result {
Err(e)
} else {