diff --git a/services/rkyv-test-server/src/buffer.rs b/services/rkyv-test-server/src/buffer.rs deleted file mode 100644 index 8b5af32ee..000000000 --- a/services/rkyv-test-server/src/buffer.rs +++ /dev/null @@ -1,226 +0,0 @@ -use rkyv::{ser::Serializer, Fallible}; -use xous::{ - map_memory, send_message, unmap_memory, Error, MemoryAddress, MemoryFlags, MemoryMessage, - MemoryRange, MemorySize, Message, Result, CID, -}; - -#[derive(Debug)] -pub struct Buffer<'a> { - range: MemoryRange, - valid: MemoryRange, - offset: Option, - slice: &'a mut [u8], - should_drop: bool, - memory_message: Option<&'a mut MemoryMessage>, -} - -pub struct XousDeserializer; - -// Unreachable enum pattern, swap out for the never type (!) whenever that gets stabilized -#[derive(Debug)] -pub enum XousUnreachable {} - -impl rkyv::Fallible for XousDeserializer { - type Error = XousUnreachable; -} - -impl<'a> Buffer<'a> { - #[allow(dead_code)] - pub fn new(len: usize) -> Self { - let remainder = if ((len & 0xFFF) == 0) && (len > 0) { - 0 - } else { - 0x1000 - (len & 0xFFF) - }; - - let flags = MemoryFlags::R | MemoryFlags::W; - - // Allocate enough memory to hold the requested data - let new_mem = map_memory( - None, - None, - // Ensure our byte size is a multiple of 4096 - len + remainder, - flags, - ) - .expect("Buffer: error in new()/map_memory"); - - let mut valid = new_mem; - valid.size = MemorySize::new(len + remainder).unwrap(); - Buffer { - range: new_mem, - slice: unsafe { - core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), len + remainder) - }, - valid, - offset: None, - should_drop: true, - memory_message: None, - } - } - - #[allow(dead_code)] - pub unsafe fn from_memory_message(mem: &'a 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: 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), - } - } - - /// Perform a mutable lend of this Buffer to the server. - #[allow(dead_code)] - pub fn lend_mut(&mut self, connection: CID, id: u32) -> core::result::Result { - let msg = MemoryMessage { - id: id as usize, - buf: self.valid, - offset: self.offset, - valid: MemorySize::new(self.slice.len()), - }; - - // Update the offset pointer if the server modified it. - let result = send_message(connection, Message::MutableBorrow(msg)); - if let Ok(Result::MemoryReturned(offset, _valid)) = result { - self.offset = offset; - } - - result - } - - #[allow(dead_code)] - pub fn lend(&self, connection: CID, id: u32) -> core::result::Result { - let msg = MemoryMessage { - id: id as usize, - buf: self.valid, - offset: self.offset, - valid: MemorySize::new(self.slice.len()), - }; - send_message(connection, Message::Borrow(msg)) - } - - #[allow(dead_code)] - pub fn send(mut self, connection: CID, id: u32) -> core::result::Result { - let msg = MemoryMessage { - id: id as usize, - buf: self.valid, - offset: self.offset, - valid: MemorySize::new(self.slice.len()), - }; - let result = send_message(connection, Message::Move(msg))?; - - // prevents it from being Dropped. - self.should_drop = false; - Ok(result) - } - - #[allow(dead_code)] - pub fn try_from(src: S) -> core::result::Result - where - S: rkyv::Serialize>>, - { - let buf = Self::new(4096); - let mut ser = rkyv::ser::serializers::BufferSerializer::new(buf); - let pos = ser.serialize_value(&src).or(Err(()))?; - let mut buf = ser.into_inner(); - buf.offset = MemoryAddress::new(pos); - Ok(buf) - } - - #[allow(dead_code)] - pub fn serialize_from(&mut self, src: S) -> core::result::Result<(), &'static str> - where - S: rkyv::Serialize>, - { - // 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)] - pub fn try_into(&self) -> core::result::Result<&U, ()> - where - T: rkyv::Archive, - { - let pos = self.offset.map(|o| o.get()).unwrap_or_default(); - let r = unsafe { rkyv::archived_value::(self.slice, pos) }; - Ok(r) - } - - #[allow(dead_code)] - pub fn deserialize(&self) -> core::result::Result - where - T: rkyv::Archive, - U: rkyv::Deserialize>, - { - let pos = self.offset.map(|o| o.get()).unwrap_or_default(); - let r = unsafe { rkyv::archived_value::(self.slice, pos) }; - Ok(r.deserialize(&mut XousDeserializer {}).unwrap()) - } -} - -impl<'a> core::convert::AsRef<[u8]> for Buffer<'a> { - fn as_ref(&self) -> &[u8] { - self.slice - } -} - -impl<'a> core::convert::AsMut<[u8]> for Buffer<'a> { - fn as_mut(&mut self) -> &mut [u8] { - self.slice - } -} - -impl<'a> core::ops::Deref for Buffer<'a> { - type Target = [u8]; - - fn deref(&self) -> &Self::Target { - &*self.slice - } -} - -impl<'a> core::ops::DerefMut for Buffer<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut *self.slice - } -} - -impl<'a> Drop for Buffer<'a> { - fn drop(&mut self) { - if self.should_drop { - unmap_memory(self.range).expect("Buffer: failed to drop memory"); - } - } -} diff --git a/services/rkyv-test-server/src/lib.rs b/services/rkyv-test-server/src/lib.rs index bc667e11b..853474505 100644 --- a/services/rkyv-test-server/src/lib.rs +++ b/services/rkyv-test-server/src/lib.rs @@ -1,12 +1,11 @@ #![cfg_attr(target_os = "none", no_std)] mod api; -mod buffer; use core::sync::atomic::{AtomicU32, Ordering}; use num_traits::{FromPrimitive, ToPrimitive}; -use xous_ipc::String; +use xous_ipc::{String, Buffer}; // Note that connection IDs are never 0, so this is invalid, and could map to `None`. static SERVER_CID: AtomicU32 = AtomicU32::new(0); @@ -31,7 +30,7 @@ pub fn add(arg1: i32, arg2: i32) -> Result { // 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).or(Err(api::Error::InternalError))?; + let mut buf = Buffer::try_from(op).or(Err(api::Error::InternalError))?; // Mutably lend our op to the server, specifying the `api::Opcode::Mathematics` opcode. // This will return a structure that we can deserialize back into something we @@ -55,7 +54,7 @@ fn do_op(op: api::MathOperation) -> Result { // 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).or(Err(api::Error::InternalError))?; + let mut buf = Buffer::try_from(op).or(Err(api::Error::InternalError))?; // Lend our op to the server, specifying the `api::Opcode::Mathematics` opcode. // This will return a structure that we can deserialize back into something we @@ -98,7 +97,7 @@ pub fn log_message, T: AsRef>(prefix: S, message: T) { // 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 buf = buffer::Buffer::try_from(op).unwrap(); + let buf = Buffer::try_from(op).unwrap(); // Send the message to the server. buf.lend( @@ -119,7 +118,7 @@ pub fn log_message_send, T: AsRef>(prefix: S, message: T) { // 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 buf = buffer::Buffer::try_from(op).unwrap(); + let buf = Buffer::try_from(op).unwrap(); // Send the message to the server. buf.send( @@ -142,7 +141,7 @@ fn callback_server() { match FromPrimitive::from_usize(msg.body.id()) { Some(api::CallbackType::LogString) => { let mem = msg.body.memory_message().unwrap(); - let buffer = unsafe { buffer::Buffer::from_memory_message(mem) }; + let buffer = unsafe { Buffer::from_memory_message(mem) }; let log_string = buffer.try_into::().unwrap(); unsafe { for entry in CALLBACK_ARRAY.iter() { @@ -197,7 +196,7 @@ pub fn double_string(value: &T) -> String<512> where T: AsRef { // 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(); + let mut buf = Buffer::try_from(op).unwrap(); // Send the message to the server. buf.lend_mut( diff --git a/services/rkyv-test-server/src/main.rs b/services/rkyv-test-server/src/main.rs index ad073ac7e..34dfe1870 100644 --- a/services/rkyv-test-server/src/main.rs +++ b/services/rkyv-test-server/src/main.rs @@ -2,16 +2,15 @@ #![cfg_attr(target_os = "none", no_main)] mod api; -mod buffer; use num_traits::{FromPrimitive, ToPrimitive}; -use xous_ipc::String; +use xous_ipc::{String, Buffer}; fn value_or(val: Option, default: api::MathResult) -> api::MathResult { val.map(|v| api::MathResult::Value(v)).unwrap_or(default) } fn handle_math_withcopy(mem: &mut xous::MemoryMessage) { - let mut buffer = unsafe { buffer::Buffer::from_memory_message_mut(mem) }; + let mut buffer = unsafe { Buffer::from_memory_message_mut(mem) }; let response = { use api::MathOperation::*; match buffer.deserialize().unwrap() { @@ -39,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 mut buffer = unsafe { buffer::Buffer::from_memory_message_mut(mem) }; + let mut buffer = unsafe { Buffer::from_memory_message_mut(mem) }; let response = { use api::ArchivedMathOperation::*; match *buffer.try_into::().unwrap() { @@ -65,7 +64,7 @@ fn handle_math_zerocopy(mem: &mut xous::MemoryMessage) { } fn handle_log_string(mem: &xous::MemoryMessage) { - let buffer = unsafe { buffer::Buffer::from_memory_message(mem) }; + let buffer = unsafe { Buffer::from_memory_message(mem) }; let log_string = buffer.try_into::().unwrap(); log::info!( "Prefix: {} Message: {}", @@ -77,7 +76,7 @@ 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 buffer = unsafe { Buffer::from_memory_message_mut(mem) }; let mut response = api::StringDoubler { value: String::new(), }; @@ -119,7 +118,7 @@ fn test_main() -> ! { // 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) }; + let buffer = unsafe { Buffer::from_memory_message(memory) }; buffer .lend( *callback_sid,