xous: hosted: use Vec as a memory backing

Use a `Vec<u8>` as a backing for memory across the entire project.

Previously we used `Vec<u8>` as a backing for MemoryMessages and used
`alloc` for all other messages. This unifies that to always use
`Vec<u8>`.

I'd prefer if we used `alloc` instead, however that has not been working
and I'm not sure why. Standardize on this for now and look into why
later.

Signed-off-by: Sean Cross <sean@xobs.io>

xous-rs/src/arch/hosted/mem.rs

@@ -1,8 +1,5 @@
 use crate::{Error, MemoryAddress, MemoryFlags, MemoryRange};
 
-extern crate alloc;
-use alloc::alloc::{alloc, dealloc, Layout};
-
 pub fn map_memory_pre(
     _phys: &Option<MemoryAddress>,
     _virt: &Option<MemoryAddress>,
@@ -20,9 +17,13 @@ pub fn map_memory_post(
     _flags: MemoryFlags,
     mut range: MemoryRange,
 ) -> core::result::Result<MemoryRange, Error> {
-    let layout = Layout::from_size_align(range.len(), 4096).unwrap();
-    let new_mem = MemoryAddress::new(unsafe { alloc(layout) } as usize).ok_or(Error::BadAddress)?;
-    Ok(unsafe { MemoryRange::new(new_mem.get(), range.len()).unwrap() })
+    let data = vec![0u8; range.len()];
+    let mut data = std::mem::ManuallyDrop::new(data);
+    data.shrink_to_fit();
+    assert_eq!(data.len(), data.capacity());
+    let len = data.len();
+    let addr = data.as_mut_ptr();
+    Ok(unsafe { crate::MemoryRange::new(addr as _, len).unwrap() })
 }
 
 pub fn unmap_memory_pre(_range: &MemoryRange) -> core::result::Result<(), Error> {
@@ -30,8 +31,48 @@ pub fn unmap_memory_pre(_range: &MemoryRange) -> core::result::Result<(), Error>
 }
 
 pub fn unmap_memory_post(range: MemoryRange) -> core::result::Result<(), Error> {
-    let layout = Layout::from_size_align(range.len(), 4096).unwrap();
-    let ptr = range.as_mut_ptr();
-    unsafe { dealloc(ptr, layout) };
+    let _v = unsafe { std::vec::Vec::from_raw_parts(range.as_mut_ptr(), range.len(), range.len()) };
     Ok(())
 }
+
+// Ideally we'd use the `alloc` API directly, however this doesn't work for unknown reasons.
+// The code is left here as an exercise to someone who wants to figure out why.
+
+// use crate::{Error, MemoryAddress, MemoryFlags, MemoryRange};
+
+// extern crate alloc;
+// use alloc::alloc::{alloc, dealloc, Layout};
+
+// pub fn map_memory_pre(
+//     _phys: &Option<MemoryAddress>,
+//     _virt: &Option<MemoryAddress>,
+//     _size: usize,
+//     _flags: MemoryFlags,
+// ) -> core::result::Result<(), Error> {
+//     Ok(())
+// }
+
+// pub fn map_memory_post(
+//     _phys: Option<MemoryAddress>,
+//     _virt: Option<MemoryAddress>,
+//     size: usize,
+//     _flags: MemoryFlags,
+//     _range: MemoryRange,
+// ) -> core::result::Result<MemoryRange, Error> {
+//     let rounded_size = (size + 4095) / 4096;
+
+//     let layout = Layout::from_size_align(rounded_size, 4096).unwrap();
+//     unsafe { MemoryRange::new(alloc(layout) as usize, size) }
+// }
+
+// pub fn unmap_memory_pre(_range: &MemoryRange) -> core::result::Result<(), Error> {
+//     Ok(())
+// }
+
+// pub fn unmap_memory_post(range: MemoryRange) -> core::result::Result<(), Error> {
+//     // let rounded_size = (range.len() + 4095) / 4096;
+//     // let layout = Layout::from_size_align(rounded_size, 4096).unwrap();
+//     // let ptr = range.as_mut_ptr();
+//     // unsafe { dealloc(ptr, layout) };
+//     Ok(())
+// }

xous-rs/src/arch/hosted/mod.rs

@@ -361,18 +361,18 @@ fn read_next_syscall_result(
                 crate::Message::Move(ref mut memory_message)
                 | crate::Message::Borrow(ref mut memory_message)
                 | crate::Message::MutableBorrow(ref mut memory_message) => {
-                    let data = vec![0u8; memory_message.buf.len()];
-                    let mut data = std::mem::ManuallyDrop::new(data);
-                    if let Err(e) = stream.read_exact(&mut data) {
+                    memory_message.buf = mem::map_memory_post(
+                        None,
+                        None,
+                        memory_message.buf.len(),
+                        crate::MemoryFlags::R | crate::MemoryFlags::W,
+                        memory_message.buf,
+                    )
+                    .expect("couldn't allocate range");
+                    if let Err(e) = stream.read_exact(memory_message.buf.as_slice_mut()) {
                         eprintln!("Server shut down: {}", e);
                         std::process::exit(0);
                     }
-                    data.shrink_to_fit();
-                    assert_eq!(data.len(), data.capacity());
-                    let len = data.len();
-                    let addr = data.as_mut_ptr();
-                    memory_message.buf =
-                        unsafe { crate::MemoryRange::new(addr as _, len).unwrap() };
                 }
                 _ => (),
             }

xous-rs/src/definitions/messages/envelope.rs

@@ -40,16 +40,6 @@ impl Drop for Envelope {
                     .expect("couldn't return memory")
             }
             Message::Move(msg) => {
-                // Reconstitute the vec and drop it right away to ensure it's freed.
-                #[cfg(any(unix, windows))]
-                let _v = unsafe {
-                    std::vec::Vec::from_raw_parts(
-                        msg.buf.as_mut_ptr(),
-                        msg.buf.len(),
-                        msg.buf.len(),
-                    )
-                };
-                #[cfg(not(any(unix, windows)))]
                 crate::syscall::unmap_memory(msg.buf).expect("couldn't free memory message")
             }
             _ => (),