From cf1fc44f7e6adf7921ba3caaa7a6f91a3f3ce09d Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:14:16 +0800 Subject: [PATCH 01/10] xous: return buffer offset as part of MemoryMessages When a MemoryMessage goes out of scope, update the buffer offset and valid fields. This allows the caller to see what's changed. Signed-off-by: Sean Cross --- xous-rs/src/definitions.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index c550fc6b4..5e3378f4b 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -500,7 +500,7 @@ impl Drop for MessageEnvelope { fn drop(&mut self) { match &self.body { Message::Borrow(x) | Message::MutableBorrow(x) => { - crate::syscall::return_memory(self.sender, x.buf).expect("couldn't return memory") + crate::syscall::return_memory_offset(self.sender, x.buf, x.offset).expect("couldn't return memory") } Message::Move(msg) => { crate::syscall::unmap_memory(msg.buf).expect("couldn't free memory message") From 461f5c5f8dbf2ceaedff171571211e75cda483ac Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:15:13 +0800 Subject: [PATCH 02/10] rkyv-test-server: buffer: add from_memory_message_mut() This enables passing data back to the caller by modifying the original message `offset` field. Signed-off-by: Sean Cross --- services/rkyv-test-server/src/buffer.rs | 45 +++++++++++++++++++++---- 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/services/rkyv-test-server/src/buffer.rs b/services/rkyv-test-server/src/buffer.rs index 490386f23..8b5af32ee 100644 --- a/services/rkyv-test-server/src/buffer.rs +++ b/services/rkyv-test-server/src/buffer.rs @@ -11,6 +11,7 @@ pub struct Buffer<'a> { offset: Option, slice: &'a mut [u8], should_drop: bool, + memory_message: Option<&'a mut MemoryMessage>, } pub struct XousDeserializer; @@ -54,6 +55,7 @@ impl<'a> Buffer<'a> { valid, offset: None, should_drop: true, + memory_message: None, } } @@ -65,6 +67,19 @@ impl<'a> Buffer<'a> { valid: mem.buf, offset: mem.offset, should_drop: false, + memory_message: None, + } + } + + #[allow(dead_code)] + pub unsafe fn from_memory_message_mut(mem: &'a mut MemoryMessage) -> Self { + Buffer { + range: mem.buf, + slice: core::slice::from_raw_parts_mut(mem.buf.as_mut_ptr(), mem.buf.len()), + valid: mem.buf, + offset: mem.offset, + should_drop: false, + memory_message: Some(mem), } } @@ -127,15 +142,31 @@ impl<'a> Buffer<'a> { } #[allow(dead_code)] - pub fn serialize_from(self, src: S) -> core::result::Result + pub fn serialize_from(&mut self, src: S) -> core::result::Result<(), &'static str> where - S: rkyv::Serialize>>, + S: rkyv::Serialize>, { - let mut ser = rkyv::ser::serializers::BufferSerializer::new(self); - let pos = ser.serialize_value(&src).or(Err(()))?; - let mut buf = ser.into_inner(); - buf.offset = MemoryAddress::new(pos); - Ok(buf) + // We must have a `memory_message` to update in order for this to work. + // Otherwise, we risk having the pointer go to somewhere invalid. + if self.memory_message.is_none() { + // Create this message using `from_memory_message_mut()` instead of + // `from_memory_message()`. + Err("couldn't serialize because buffer wasn't mutable")?; + } + // Unsafe Warning: Create a copy of the backing slice to hand to the deserializer. + // This is required because the deserializer consumes the buffer and returns it + // later as part of `.into_inner()`. + // The "correct" way to do this would be to implement `rkyv::Serializer` an `rkyv::Fallible` + // for ourselves. + let copied_slice = + unsafe { core::slice::from_raw_parts_mut(self.slice.as_mut_ptr(), self.slice.len()) }; + let mut ser = rkyv::ser::serializers::BufferSerializer::new(copied_slice); + let pos = ser.serialize_value(&src).or(Err("couldn't serialize"))?; + self.offset = MemoryAddress::new(pos); + if let Some(ref mut msg) = self.memory_message.as_mut() { + msg.offset = MemoryAddress::new(pos); + } + Ok(()) } #[allow(dead_code)] From ff180ca737df74ec0438013adfee63b4d8653739 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:15:57 +0800 Subject: [PATCH 03/10] rkyv-test-server: add DoubleString api call This demonstrates how we might use strings in syscalls. Signed-off-by: Sean Cross --- services/rkyv-test-server/src/api.rs | 8 ++++++++ services/rkyv-test-server/src/lib.rs | 29 ++++++++++++++++++++++++++- services/rkyv-test-server/src/main.rs | 18 +++++++++++++++-- 3 files changed, 52 insertions(+), 3 deletions(-) diff --git a/services/rkyv-test-server/src/api.rs b/services/rkyv-test-server/src/api.rs index 92c6ee12e..970fe0df1 100644 --- a/services/rkyv-test-server/src/api.rs +++ b/services/rkyv-test-server/src/api.rs @@ -12,6 +12,9 @@ pub(crate) enum Opcode { /// Callback with log string AddLogStringCallback = 2, + + /// Double the string + DoubleString = 3, } /// These enums indicate what kind of callback type we're sending. @@ -43,6 +46,11 @@ pub(crate) struct LogString { pub(crate) message: xous::String<512>, } +#[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +pub(crate) struct StringDoubler { + pub(crate) value: xous::String<512>, +} + #[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Debug)] pub enum Error { InternalError, diff --git a/services/rkyv-test-server/src/lib.rs b/services/rkyv-test-server/src/lib.rs index 1ac3d572d..e9874a559 100644 --- a/services/rkyv-test-server/src/lib.rs +++ b/services/rkyv-test-server/src/lib.rs @@ -63,7 +63,14 @@ fn do_op(op: api::MathOperation) -> Result { api::Opcode::Mathematics.to_u32().unwrap(), ) .or(Err(api::Error::InternalError))?; - Err(api::Error::Overflow) + + // Don't deserialize it -- use the archived version + match *buf.try_into::().unwrap() { + api::ArchivedMathResult::Value(v) => Ok(v), + api::ArchivedMathResult::Error(api::ArchivedError::InternalError) => Err(api::Error::InternalError), + api::ArchivedMathResult::Error(api::ArchivedError::Overflow) => Err(api::Error::Overflow), + api::ArchivedMathResult::Error(api::ArchivedError::Underflow) => Err(api::Error::Underflow), + } } pub fn subtract(arg1: i32, arg2: i32) -> Result { @@ -156,3 +163,23 @@ pub fn hook_log_messages(cb: fn(&str, &str)) { .unwrap(); } } + +pub fn double_string(value: &xous::String) -> xous::String { + let op = api::StringDoubler { + value: xous::String::from_str(value.as_str().unwrap()), + }; + + // Convert the opcode into a serialized buffer. This consumes the opcode, which will + // exist on the heap in its own page. Furthermore, this will be in a flattened format + // suitable for passing around as a message. + let mut buf = buffer::Buffer::try_from(op).unwrap(); + + // Send the message to the server. + buf.lend_mut( + ensure_connection(), + api::Opcode::DoubleString.to_u32().unwrap(), + ) + .unwrap(); + + xous::String::from_str(buf.try_into::().unwrap().value.as_str()) +} diff --git a/services/rkyv-test-server/src/main.rs b/services/rkyv-test-server/src/main.rs index 95513eb3f..c9801cd4c 100644 --- a/services/rkyv-test-server/src/main.rs +++ b/services/rkyv-test-server/src/main.rs @@ -10,7 +10,7 @@ fn value_or(val: Option, default: api::MathResult) -> api::MathResult { } fn handle_math_withcopy(mem: &mut xous::MemoryMessage) { - let buffer = unsafe { buffer::Buffer::from_memory_message(mem) }; + let mut buffer = unsafe { buffer::Buffer::from_memory_message_mut(mem) }; let response = { use api::MathOperation::*; match buffer.deserialize().unwrap() { @@ -38,7 +38,7 @@ fn handle_math_withcopy(mem: &mut xous::MemoryMessage) { // This doesn't deserialize the struct, and therefore operates entirely // on the archived data. This saves a copy step. fn handle_math_zerocopy(mem: &mut xous::MemoryMessage) { - let buffer = unsafe { buffer::Buffer::from_memory_message(mem) }; + let mut buffer = unsafe { buffer::Buffer::from_memory_message_mut(mem) }; let response = { use api::ArchivedMathOperation::*; match *buffer.try_into::().unwrap() { @@ -73,6 +73,17 @@ fn handle_log_string(mem: &xous::MemoryMessage) { ); } +/// Take the given string and double each character in an output string. +fn double_string(mem: &mut xous::MemoryMessage) { + use core::fmt::Write; + let mut buffer = unsafe { buffer::Buffer::from_memory_message_mut(mem) }; + let mut response = api::StringDoubler { value: xous::String::new() }; + for ch in buffer.try_into::().unwrap().value.as_str().chars() { + write!(response.value, "{}{}", ch, ch).ok(); + } + buffer.serialize_from(response).unwrap(); +} + #[xous::xous_main] fn test_main() -> ! { let mut callback_conn = None; @@ -90,6 +101,9 @@ fn test_main() -> ! { Some(api::Opcode::Mathematics) => { handle_math_withcopy(msg.body.memory_message_mut().unwrap()) } + Some(api::Opcode::DoubleString) => { + double_string(msg.body.memory_message_mut().unwrap()) + } Some(api::Opcode::LogString) => { let memory = msg.body.memory_message().unwrap(); if let Some(callback_sid) = callback_conn { From 0f455a9a024605b9584944ae11d75248ca6c1f50 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:16:26 +0800 Subject: [PATCH 04/10] rkyv-test-client: use new double_string call Signed-off-by: Sean Cross --- services/rkyv-test-client/src/main.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/services/rkyv-test-client/src/main.rs b/services/rkyv-test-client/src/main.rs index 42c868441..b71adbe2d 100644 --- a/services/rkyv-test-client/src/main.rs +++ b/services/rkyv-test-client/src/main.rs @@ -2,7 +2,11 @@ #![cfg_attr(target_os = "none", no_main)] fn print_log_messages(log_message: &str, prefix: &str) { - log::info!("Got a message hook! Message: [{}], prefix: [{}]", log_message, prefix); + log::info!( + "Got a message hook! Message: [{}], prefix: [{}]", + log_message, + prefix + ); } #[xous::xous_main] @@ -18,10 +22,13 @@ fn rkyv_test_client() -> ! { rkyv_test_server::hook_log_messages(print_log_messages); let mut idx = 0; + let double_src = xous::String::<256>::from_str("12345678"); loop { log::info!("2 + {} = {}", idx, rkyv_test_server::add(2, idx).unwrap()); ticktimer_server::sleep_ms(ticktimer_conn, 500).ok(); rkyv_test_server::log_message("prefix", "Hi there"); + log::info!("Doubling string {}", double_src); + log::info!("Doubled string: {}", rkyv_test_server::double_string(&double_src)); idx += 1; } } From 32ebee0b8f10c9455c35f534138716fa7d3dda3b Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:31:59 +0800 Subject: [PATCH 05/10] xous: String: implement AsRef This allows xous Strings to be used in functions that expect to be able to stringify arguments. Signed-off-by: Sean Cross --- xous-rs/src/string.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/xous-rs/src/string.rs b/xous-rs/src/string.rs index f2c0f5c51..7be38f6f9 100644 --- a/xous-rs/src/string.rs +++ b/xous-rs/src/string.rs @@ -223,6 +223,12 @@ impl core::fmt::Debug for String { } } +impl core::convert::AsRef for String { + fn as_ref(&self) -> &str { + self.to_str() + } +} + #[repr(C)] pub struct ArchivedString { ptr: rkyv::RelPtr, @@ -296,4 +302,4 @@ impl Eq for String {} pub struct XousDeserializer; impl rkyv::Fallible for XousDeserializer { type Error = crate::Error; -} \ No newline at end of file +} From e27db818eff5cf051c5432f20b00465a6889fee5 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:32:42 +0800 Subject: [PATCH 06/10] rkyv-test-server: accept any string-like arguments As long as we can turn an argument into a string, that's good enough for us. Signed-off-by: Sean Cross --- services/rkyv-test-server/src/lib.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/services/rkyv-test-server/src/lib.rs b/services/rkyv-test-server/src/lib.rs index e9874a559..d99bf0722 100644 --- a/services/rkyv-test-server/src/lib.rs +++ b/services/rkyv-test-server/src/lib.rs @@ -85,10 +85,12 @@ pub fn divide(arg1: i32, arg2: i32) -> Result { do_op(api::MathOperation::Divide(arg1, arg2)) } -pub fn log_message(prefix: &str, message: &str) { +/// Log the given message to the server. +/// We accept any two parameters that can be treated as strings. +pub fn log_message, T: AsRef>(prefix: S, message: T) { let op = api::LogString { - prefix: xous::String::from_str(prefix), - message: xous::String::from_str(message), + prefix: xous::String::from_str(prefix.as_ref()), + message: xous::String::from_str(message.as_ref()), }; // Convert the opcode into a serialized buffer. This consumes the opcode, which will From 22b50d080b34524fd59608f13cd097d5d7c87337 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:33:30 +0800 Subject: [PATCH 07/10] rkyv-test-client: dynamically generate log message string By dynamically generating the log message string, we ensure dynamic buffer adjustments are accepted. Signed-off-by: Sean Cross --- services/rkyv-test-client/src/main.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/services/rkyv-test-client/src/main.rs b/services/rkyv-test-client/src/main.rs index b71adbe2d..4005be71c 100644 --- a/services/rkyv-test-client/src/main.rs +++ b/services/rkyv-test-client/src/main.rs @@ -1,6 +1,8 @@ #![cfg_attr(target_os = "none", no_std)] #![cfg_attr(target_os = "none", no_main)] +use core::fmt::Write; + fn print_log_messages(log_message: &str, prefix: &str) { log::info!( "Got a message hook! Message: [{}], prefix: [{}]", @@ -23,10 +25,15 @@ fn rkyv_test_client() -> ! { let mut idx = 0; let double_src = xous::String::<256>::from_str("12345678"); + + let mut message_string = xous::String::<64>::new(); loop { log::info!("2 + {} = {}", idx, rkyv_test_server::add(2, idx).unwrap()); ticktimer_server::sleep_ms(ticktimer_conn, 500).ok(); - rkyv_test_server::log_message("prefix", "Hi there"); + + message_string.clear(); + write!(message_string, "I'm at loop # {:^4}", idx); + rkyv_test_server::log_message("prefix", message_string); log::info!("Doubling string {}", double_src); log::info!("Doubled string: {}", rkyv_test_server::double_string(&double_src)); idx += 1; From 561a0c3e27a6a10505b96c33771fa5b30e495041 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:40:47 +0800 Subject: [PATCH 08/10] rkyv-test-client: make doubling string dynamic This tests for emoji as well as making sure it's working as intended. Signed-off-by: Sean Cross --- services/rkyv-test-client/src/main.rs | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/services/rkyv-test-client/src/main.rs b/services/rkyv-test-client/src/main.rs index 4005be71c..c8e8404d0 100644 --- a/services/rkyv-test-client/src/main.rs +++ b/services/rkyv-test-client/src/main.rs @@ -24,7 +24,11 @@ fn rkyv_test_client() -> ! { rkyv_test_server::hook_log_messages(print_log_messages); let mut idx = 0; - let double_src = xous::String::<256>::from_str("12345678"); + + // This is just some number. It should change width, ensuring our padding + // is working and we're not overwriting the buffer weirdly. + let mut some_number = 98653i32; + let mut double_src = xous::String::<256>::new(); let mut message_string = xous::String::<64>::new(); loop { @@ -32,10 +36,15 @@ fn rkyv_test_client() -> ! { ticktimer_server::sleep_ms(ticktimer_conn, 500).ok(); message_string.clear(); - write!(message_string, "I'm at loop # {:^4}", idx); + write!(message_string, "I'm at loop # {:^4} (some numer: {})", idx, some_number).unwrap(); + some_number = some_number.wrapping_mul(53); rkyv_test_server::log_message("prefix", message_string); + + double_src.clear(); + write!(double_src, "12345678 Loop {} 🎉 你好", idx).unwrap(); log::info!("Doubling string {}", double_src); log::info!("Doubled string: {}", rkyv_test_server::double_string(&double_src)); idx += 1; } } + From c1fe20c06bde222a000ce54f9a00e5dcf2c406f8 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:41:15 +0800 Subject: [PATCH 09/10] services: allow for multiple callbacks This means we can have multiple clients requesting a callback. Signed-off-by: Sean Cross --- services/rkyv-test-server/src/main.rs | 45 +++++++++++++++++++++------ 1 file changed, 36 insertions(+), 9 deletions(-) diff --git a/services/rkyv-test-server/src/main.rs b/services/rkyv-test-server/src/main.rs index c9801cd4c..88bf2048e 100644 --- a/services/rkyv-test-server/src/main.rs +++ b/services/rkyv-test-server/src/main.rs @@ -77,8 +77,16 @@ fn handle_log_string(mem: &xous::MemoryMessage) { fn double_string(mem: &mut xous::MemoryMessage) { use core::fmt::Write; let mut buffer = unsafe { buffer::Buffer::from_memory_message_mut(mem) }; - let mut response = api::StringDoubler { value: xous::String::new() }; - for ch in buffer.try_into::().unwrap().value.as_str().chars() { + let mut response = api::StringDoubler { + value: xous::String::new(), + }; + for ch in buffer + .try_into::() + .unwrap() + .value + .as_str() + .chars() + { write!(response.value, "{}{}", ch, ch).ok(); } buffer.serialize_from(response).unwrap(); @@ -86,7 +94,6 @@ fn double_string(mem: &mut xous::MemoryMessage) { #[xous::xous_main] fn test_main() -> ! { - let mut callback_conn = None; log_server::init_wait().unwrap(); log::info!( @@ -95,6 +102,8 @@ fn test_main() -> ! { ); let sid = xous_names::register_name(api::SERVER_NAME).unwrap(); + let mut logstring_callback_connections = [None; 32]; + loop { let mut msg = xous::receive_message(sid).unwrap(); match FromPrimitive::from_usize(msg.body.id()) { @@ -106,15 +115,23 @@ fn test_main() -> ! { } Some(api::Opcode::LogString) => { let memory = msg.body.memory_message().unwrap(); - if let Some(callback_sid) = callback_conn { - let buffer = unsafe { buffer::Buffer::from_memory_message(memory) }; - buffer - .lend(callback_sid, api::CallbackType::LogString.to_u32().unwrap()) - .unwrap(); + // If a callback exists, first pass this message to the callback server. + for callback_conn in logstring_callback_connections.iter() { + if let Some(callback_sid) = callback_conn { + let buffer = unsafe { buffer::Buffer::from_memory_message(memory) }; + buffer + .lend( + *callback_sid, + api::CallbackType::LogString.to_u32().unwrap(), + ) + .unwrap(); + } } handle_log_string(msg.body.memory_message().unwrap()) } Some(api::Opcode::AddLogStringCallback) => { + // The Log String Callback provides us a SID. Connect to that SID + // and add it to the list of connections available. if let xous::Message::Scalar(xous::ScalarMessage { id: _id, arg1, @@ -124,7 +141,17 @@ fn test_main() -> ! { }) = msg.body { let sid = xous::SID::from_u32(arg1 as _, arg2 as _, arg3 as _, arg4 as _); - callback_conn = Some(xous::connect(sid).unwrap()); + let cb_conn = Some(xous::connect(sid).unwrap()); + // Add this callback connection to the list of callbacks if it doesn't + // already exist. + if !logstring_callback_connections.contains(&cb_conn) { + for entry in logstring_callback_connections.iter_mut() { + if *entry == None { + *entry = cb_conn; + break; + } + } + } } } None => (), From f58f82a40dd2a5ab5b506b6371c08a647cdf4b93 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 26 Mar 2021 12:42:35 +0800 Subject: [PATCH 10/10] rkyv-test-server: support multiple callbacks for one client There doesn't seem to be a compelling reason to limit clients to just one callback. Signed-off-by: Sean Cross --- services/rkyv-test-server/src/main.rs | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/services/rkyv-test-server/src/main.rs b/services/rkyv-test-server/src/main.rs index 88bf2048e..c9c4762a9 100644 --- a/services/rkyv-test-server/src/main.rs +++ b/services/rkyv-test-server/src/main.rs @@ -142,14 +142,12 @@ fn test_main() -> ! { { let sid = xous::SID::from_u32(arg1 as _, arg2 as _, arg3 as _, arg4 as _); let cb_conn = Some(xous::connect(sid).unwrap()); - // Add this callback connection to the list of callbacks if it doesn't - // already exist. - if !logstring_callback_connections.contains(&cb_conn) { - for entry in logstring_callback_connections.iter_mut() { - if *entry == None { - *entry = cb_conn; - break; - } + // Add this callback connection to the list of callbacks. If `AddLogStringCallback` + // is called multiple times, then it will receive multiple callbacks. + for entry in logstring_callback_connections.iter_mut() { + if *entry == None { + *entry = cb_conn; + break; } } }