diff --git a/examples/log/src/log_string.rs b/examples/log/src/log_string.rs index e5f26c7c5..95192f284 100644 --- a/examples/log/src/log_string.rs +++ b/examples/log/src/log_string.rs @@ -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, } 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(()) + } +} diff --git a/examples/log/src/main.rs b/examples/log/src/main.rs index 6e26735de..3e1b68c7c 100644 --- a/examples/log/src/main.rs +++ b/examples/log/src/main.rs @@ -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(); + } } } } diff --git a/examples/shell/src/logstr.rs b/examples/shell/src/logstr.rs index bf499a3c8..08f621bea 100644 --- a/examples/shell/src/logstr.rs +++ b/examples/shell/src/logstr.rs @@ -29,6 +29,7 @@ impl<'a> LogStr<'a> { } } + #[allow(dead_code)] pub fn into_memory_message(self, id: xous::MessageId) -> Result { // 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) + } +} diff --git a/examples/shell/src/main.rs b/examples/shell/src/main.rs index 8ffdeaf92..99dce5924 100644 --- a/examples/shell/src/main.rs +++ b/examples/shell/src/main.rs @@ -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); } } diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index 78fc2778b..0816c45dd 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -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"); } } } diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index fcbe039f2..49e12eb6b 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -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 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 {