diff --git a/xous-ipc/src/buffer.rs b/xous-ipc/src/buffer.rs index e2d1cdad1..9954013da 100644 --- a/xous-ipc/src/buffer.rs +++ b/xous-ipc/src/buffer.rs @@ -1,54 +1,43 @@ -use core::convert::TryInto; +use core::mem::MaybeUninit; +use std::marker::PhantomData; -use rkyv::{ser::Serializer, Fallible}; +use rkyv::{ + api::low::LowSerializer, + rancor::{Panic, Strategy}, + ser::{allocator::SubAllocator, writer::Buffer as RkyvBuffer, Positional}, + with::{ArchiveWith, Identity, SerializeWith}, + Archive, Deserialize, Place, Portable, Serialize, +}; 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], +pub struct Buffer<'buf> { + pages: MemoryRange, + used: usize, + slice: &'buf mut [u8], should_drop: bool, - memory_message: Option<&'a mut MemoryMessage>, + memory_message: Option<&'buf mut MemoryMessage>, } +const PAGE_SIZE: usize = 0x1000; -pub struct XousDeserializer; +type Serializer<'a, 'b> = LowSerializer, SubAllocator<'a>, Panic>; -// 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> { +impl<'buf> Buffer<'buf> { #[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; + let len_to_page = (len + (PAGE_SIZE - 1)) & !(PAGE_SIZE - 1); // 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 new_mem = map_memory(None, None, len_to_page, flags).expect("xous-ipc: OOM in buffer allocation"); - let valid = unsafe { MemoryRange::new(new_mem.as_mut_ptr() as usize, 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, + pages: new_mem, + slice: unsafe { core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), len_to_page) }, + used: 0, should_drop: true, memory_message: None, } @@ -73,11 +62,7 @@ impl<'a> Buffer<'a> { // complex argument structures. #[allow(dead_code)] pub unsafe fn to_raw_parts(&self) -> (usize, usize, usize) { - if let Some(offset) = self.offset { - (self.valid.as_ptr() as usize, self.valid.len(), usize::from(offset)) - } else { - (self.valid.as_ptr() as usize, self.valid.len(), 0) - } + (self.pages.as_ptr() as usize, self.pages.len(), self.used) } // use to serialize a buffer between process-local threads. mainly for spawning new threads with more @@ -85,36 +70,32 @@ impl<'a> Buffer<'a> { #[allow(dead_code)] pub unsafe fn from_raw_parts(address: usize, len: usize, offset: usize) -> Self { let mem = MemoryRange::new(address, len).expect("invalid memory range args"); - let off = if offset != 0 { Some(offset.try_into().unwrap()) } else { None }; Buffer { - range: mem, + pages: mem, slice: core::slice::from_raw_parts_mut(mem.as_mut_ptr(), mem.len()), - valid: mem, - offset: off, + used: offset, should_drop: false, memory_message: None, } } #[allow(dead_code)] - pub unsafe fn from_memory_message(mem: &'a MemoryMessage) -> Self { + pub unsafe fn from_memory_message(mem: &'buf MemoryMessage) -> Self { Buffer { - range: mem.buf, + pages: mem.buf, slice: core::slice::from_raw_parts_mut(mem.buf.as_mut_ptr(), mem.buf.len()), - valid: mem.buf, - offset: mem.offset, + used: mem.offset.map_or(0, |v| v.get()), should_drop: false, memory_message: None, } } #[allow(dead_code)] - pub unsafe fn from_memory_message_mut(mem: &'a mut MemoryMessage) -> Self { + pub unsafe fn from_memory_message_mut(mem: &'buf mut MemoryMessage) -> Self { Buffer { - range: mem.buf, + pages: mem.buf, slice: core::slice::from_raw_parts_mut(mem.buf.as_mut_ptr(), mem.buf.len()), - valid: mem.buf, - offset: mem.offset, + used: mem.offset.map_or(0, |v| v.get()), should_drop: false, memory_message: Some(mem), } @@ -125,15 +106,15 @@ impl<'a> Buffer<'a> { 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()), + buf: self.pages, + offset: MemoryAddress::new(self.used), + valid: MemorySize::new(self.pages.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; + self.used = offset.map_or(0, |v| v.get()); } result @@ -143,9 +124,9 @@ impl<'a> Buffer<'a> { 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()), + buf: self.pages, + offset: MemoryAddress::new(self.used), + valid: MemorySize::new(self.pages.len()), }; send_message(connection, Message::Borrow(msg)) } @@ -154,9 +135,9 @@ impl<'a> Buffer<'a> { 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()), + buf: self.pages, + offset: MemoryAddress::new(self.used), + valid: MemorySize::new(self.pages.len()), }; let result = send_message(connection, Message::Move(msg))?; @@ -165,43 +146,97 @@ impl<'a> Buffer<'a> { Ok(result) } - #[allow(dead_code)] - pub fn into_buf(src: S) -> core::result::Result + fn into_buf_inner(src: &T) -> core::result::Result where - S: rkyv::Serialize>>, + F: for<'a, 'b> SerializeWith>, { - let buf = Self::new(core::mem::size_of::()); - 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) - } + struct Wrap<'a, F, T>(&'a T, PhantomData); - // erase ourself and re-use our allocated storage - #[allow(dead_code)] - pub fn rewrite(&mut self, src: S) -> core::result::Result<(), xous::Error> - where - S: rkyv::Serialize>, - { - let copied_slice = - unsafe { core::slice::from_raw_parts_mut(self.slice.as_mut_ptr(), self.slice.len()) }; - // zeroize the slice before using it - /*for &mut s in copied_slice { - s = 0; - }*/ - let mut ser = rkyv::ser::serializers::BufferSerializer::new(copied_slice); - let pos = ser.serialize_value(&src).or(Err(())).unwrap(); - self.slice = ser.into_inner(); - self.offset = MemoryAddress::new(pos); - Ok(()) + impl Archive for Wrap<'_, F, T> + where + F: ArchiveWith, + { + type Archived = >::Archived; + type Resolver = >::Resolver; + + fn resolve(&self, resolver: Self::Resolver, out: Place) { + F::resolve_with(self.0, resolver, out) + } + } + + impl<'a, 'b, F, T> Serialize> for Wrap<'_, F, T> + where + F: SerializeWith>, + { + fn serialize( + &self, + serializer: &mut Serializer<'a, 'b>, + ) -> core::result::Result { + F::serialize_with(self.0, serializer) + } + } + let mut xous_buf = Self::new(core::mem::size_of::()); + let mut scratch = [MaybeUninit::::uninit(); 256]; + + let wrap = Wrap(src, PhantomData::); + let writer = RkyvBuffer::from(&mut xous_buf.slice[..]); + let alloc = SubAllocator::new(&mut scratch); + + let serbuf = + rkyv::api::low::to_bytes_in_with_alloc::<_, _, Panic>(&wrap, writer, alloc).map_err(|_| ())?; + xous_buf.used = serbuf.pos(); + println!("pos: {}", xous_buf.used); + println!("scratch: {:x?}", &scratch[..16]); + Ok(xous_buf) } #[allow(dead_code)] - pub fn replace(&mut self, src: S) -> core::result::Result<(), &'static str> + pub fn into_buf(src: T) -> core::result::Result where - S: rkyv::Serialize>, + T: for<'b, 'a> rkyv::Serialize< + rkyv::rancor::Strategy< + rkyv::ser::Serializer< + rkyv::ser::writer::Buffer<'b>, + rkyv::ser::allocator::SubAllocator<'a>, + (), + >, + rkyv::rancor::Panic, + >, + >, { + Buffer::into_buf_inner::(&src) + } + + fn replace_inner(&mut self, src: T) -> core::result::Result<(), &'static str> + where + F: for<'a, 'b> SerializeWith>, + { + struct Wrap<'a, F, T>(&'a T, PhantomData); + + impl Archive for Wrap<'_, F, T> + where + F: ArchiveWith, + { + type Archived = >::Archived; + type Resolver = >::Resolver; + + fn resolve(&self, resolver: Self::Resolver, out: Place) { + F::resolve_with(self.0, resolver, out) + } + } + + impl<'a, 'b, F, T> Serialize> for Wrap<'_, F, T> + where + F: SerializeWith>, + { + fn serialize( + &self, + serializer: &mut Serializer<'a, 'b>, + ) -> core::result::Result { + F::serialize_with(self.0, serializer) + } + } + // 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() { @@ -216,24 +251,47 @@ impl<'a> Buffer<'a> { // 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).map_err(|err| err).unwrap(); - self.offset = MemoryAddress::new(pos); + let mut scratch = [MaybeUninit::::uninit(); 256]; + + let wrap = Wrap(&src, PhantomData::); + let writer = RkyvBuffer::from(&mut copied_slice[..]); + let alloc = SubAllocator::new(&mut scratch); + + let serbuf = rkyv::api::low::to_bytes_in_with_alloc::<_, _, Panic>(&wrap, writer, alloc).unwrap(); + self.used = serbuf.pos(); + if let Some(ref mut msg) = self.memory_message.as_mut() { - msg.offset = MemoryAddress::new(pos); + msg.offset = MemoryAddress::new(self.used); } Ok(()) } + #[allow(dead_code)] + pub fn replace(&mut self, src: T) -> core::result::Result<(), &'static str> + where + T: for<'b, 'a> rkyv::Serialize< + rkyv::rancor::Strategy< + rkyv::ser::Serializer< + rkyv::ser::writer::Buffer<'b>, + rkyv::ser::allocator::SubAllocator<'a>, + (), + >, + rkyv::rancor::Panic, + >, + >, + { + self.replace_inner::(src) + } + /// Zero-copy representation of the data on the receiving side, wrapped in an "Archived" trait and left in /// the heap. Cheap so uses "as_" prefix. #[allow(dead_code)] pub fn as_flat(&self) -> core::result::Result<&U, ()> where T: rkyv::Archive, + U: Portable, { - let pos = self.offset.map(|o| o.get()).unwrap_or_default(); - let r = unsafe { rkyv::archived_value::(self.slice, pos) }; + let r = unsafe { rkyv::access_unchecked::(&self.slice[..self.used]) }; Ok(r) } @@ -243,36 +301,38 @@ impl<'a> Buffer<'a> { pub fn to_original(&self) -> core::result::Result where T: rkyv::Archive, - U: rkyv::Deserialize>, + U: Portable, + ::Archived: 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()) + let r = unsafe { rkyv::access_unchecked::(&self.slice[..self.used]) }; + Ok(rkyv::deserialize::(r).unwrap()) } + + pub fn used(&self) -> usize { self.used } } impl<'a> core::convert::AsRef<[u8]> for Buffer<'a> { - fn as_ref(&self) -> &[u8] { self.slice } + fn as_ref(&self) -> &[u8] { &self.slice[..self.used] } } impl<'a> core::convert::AsMut<[u8]> for Buffer<'a> { - fn as_mut(&mut self) -> &mut [u8] { self.slice } + fn as_mut(&mut self) -> &mut [u8] { &mut self.slice[..self.used] } } impl<'a> core::ops::Deref for Buffer<'a> { type Target = [u8]; - fn deref(&self) -> &Self::Target { &*self.slice } + fn deref(&self) -> &Self::Target { &*(&self.slice[..self.used]) } } impl<'a> core::ops::DerefMut for Buffer<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { &mut *self.slice } + fn deref_mut(&mut self) -> &mut Self::Target { &mut *(&mut self.slice[..self.used]) } } impl<'a> Drop for Buffer<'a> { fn drop(&mut self) { if self.should_drop { - unmap_memory(self.range).expect("Buffer: failed to drop memory"); + unmap_memory(self.pages).expect("Buffer: failed to drop memory"); } } }