0002-xous-fs-add-initial-filesystem-support.patch

From 37d3ffcf441085be658a211e8e4b2a9fec042b66 Mon Sep 17 00:00:00 2001
From: Sean Cross <sean@osdyne.com>
Date: Tue, 6 Aug 2024 22:45:11 +0800
Subject: [PATCH 2/3] xous: fs: add initial filesystem support

This also adds senres, which is a method for sending and receiving structs.
It is a cut-down version of rkyv and similar modules.

Signed-off-by: Sean Cross <sean@xobs.io>
---
 library/std/src/os/xous/fs.rs            |  33 ++
 library/std/src/os/xous/mod.rs           |   3 +
 library/std/src/os/xous/path.rs          |  42 ++
 library/std/src/os/xous/services.rs      |   3 +
 library/std/src/os/xous/services/pddb.rs |  88 +++
 library/std/src/sys/fs/mod.rs            |   3 +
 library/std/src/sys/fs/xous.rs           | 651 +++++++++++++++++++++++
 library/std/src/sys/fs/xous/senres.rs    | 628 ++++++++++++++++++++++
 8 files changed, 1451 insertions(+)
 create mode 100644 library/std/src/os/xous/fs.rs
 create mode 100644 library/std/src/os/xous/path.rs
 create mode 100644 library/std/src/os/xous/services/pddb.rs
 create mode 100644 library/std/src/sys/fs/xous.rs
 create mode 100644 library/std/src/sys/fs/xous/senres.rs

diff --git a/library/std/src/os/xous/fs.rs b/library/std/src/os/xous/fs.rs
new file mode 100644
index 00000000000..cd19095bd0c
--- /dev/null
+++ b/library/std/src/os/xous/fs.rs
@@ -0,0 +1,33 @@
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::fs;
+use crate::sys_common::AsInner;
+
+#[stable(feature = "file_type_ext", since = "1.5.0")]
+pub trait FileTypeExt {
+    /// Returns `true` if this file type is a basis.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::fs;
+    /// use std::os::xous::fs::FileTypeExt;
+    /// use std::io;
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let meta = fs::metadata(":.System")?;
+    ///     let file_type = meta.file_type();
+    ///     assert!(file_type.is_basis());
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "file_type_ext", since = "1.5.0")]
+    fn is_basis(&self) -> bool;
+}
+
+#[stable(feature = "file_type_ext", since = "1.5.0")]
+impl FileTypeExt for fs::FileType {
+    fn is_basis(&self) -> bool {
+        self.as_inner().is_basis()
+    }
+}
diff --git a/library/std/src/os/xous/mod.rs b/library/std/src/os/xous/mod.rs
index 4b21695c4ac..644327ac514 100644
--- a/library/std/src/os/xous/mod.rs
+++ b/library/std/src/os/xous/mod.rs
@@ -7,6 +7,9 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 pub mod services;
 
+pub mod fs;
+pub mod path;
+
 /// A prelude for conveniently writing platform-specific code.
 ///
 /// Includes all extension traits, and some important type definitions.
diff --git a/library/std/src/os/xous/path.rs b/library/std/src/os/xous/path.rs
new file mode 100644
index 00000000000..c601ff8f1a2
--- /dev/null
+++ b/library/std/src/os/xous/path.rs
@@ -0,0 +1,42 @@
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::path;
+
+#[stable(feature = "file_type_ext", since = "1.5.0")]
+pub trait PathExt {
+    /// Returns `true` if this file type is a basis.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::fs;
+    /// use std::os::xous::fs::FileTypeExt;
+    /// use std::io;
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let meta = fs::metadata(":.System")?;
+    ///     let file_type = meta.file_type();
+    ///     assert!(file_type.is_basis());
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "file_type_ext", since = "1.5.0")]
+    fn is_basis(&self) -> bool;
+}
+
+#[stable(feature = "file_type_ext", since = "1.5.0")]
+impl PathExt for path::Path {
+    fn is_basis(&self) -> bool {
+        let as_str = match self.as_os_str().to_str() {
+            Some(o) => o,
+            None => return false,
+        };
+
+        let (basis, path) = match crate::sys::path::split_basis_and_dict(as_str, || Some("")) {
+            Ok(o) => o,
+            Err(_) => return false,
+        };
+
+        basis.is_some() && path.is_none()
+    }
+}
diff --git a/library/std/src/os/xous/services.rs b/library/std/src/os/xous/services.rs
index 93916750c05..bfdc1377fd6 100644
--- a/library/std/src/os/xous/services.rs
+++ b/library/std/src/os/xous/services.rs
@@ -11,6 +11,9 @@
 mod net;
 pub(crate) use net::*;
 
+mod pddb;
+pub(crate) use pddb::*;
+
 mod systime;
 pub(crate) use systime::*;
 
diff --git a/library/std/src/os/xous/services/pddb.rs b/library/std/src/os/xous/services/pddb.rs
new file mode 100644
index 00000000000..f8459b5bac9
--- /dev/null
+++ b/library/std/src/os/xous/services/pddb.rs
@@ -0,0 +1,88 @@
+use crate::io::SeekFrom;
+use crate::os::xous::ffi::Connection;
+use crate::os::xous::services::connect;
+use core::sync::atomic::{AtomicU32, Ordering};
+
+#[repr(usize)]
+pub(crate) enum PddbBlockingScalar {
+    SeekKeyStd(u16 /* fd */, SeekFrom),
+    CloseKeyStd(u16 /* fd */),
+}
+
+#[repr(usize)]
+pub(crate) enum PddbLendMut {
+    OpenKeyStd,
+    ReadKeyStd(u16 /* fd */),
+    DeleteKeyStd = 35,
+    ListPathStd = 37,
+    StatPathStd = 38,
+
+    /// Create a dict
+    CreateDictStd,
+
+    /// Remove an empty dict
+    DeleteDictStd,
+}
+
+#[repr(usize)]
+pub(crate) enum PddbLend {
+    WriteKeyStd(u16 /* fd */),
+}
+
+impl Into<usize> for PddbLendMut {
+    fn into(self) -> usize {
+        match self {
+            PddbLendMut::OpenKeyStd => 30,
+            PddbLendMut::ReadKeyStd(fd) => 31 | ((fd as usize) << 16),
+            PddbLendMut::DeleteKeyStd => 35,
+            PddbLendMut::ListPathStd => 37,
+            PddbLendMut::StatPathStd => 38,
+            PddbLendMut::CreateDictStd => 40,
+            PddbLendMut::DeleteDictStd => 41,
+        }
+    }
+}
+
+impl Into<usize> for PddbLend {
+    fn into(self) -> usize {
+        match self {
+            PddbLend::WriteKeyStd(fd) => 32 | ((fd as usize) << 16),
+        }
+    }
+}
+
+impl<'a> Into<[usize; 5]> for PddbBlockingScalar {
+    fn into(self) -> [usize; 5] {
+        match self {
+            PddbBlockingScalar::SeekKeyStd(fd, from) => {
+                let (a1, a2, a3) = match from {
+                    SeekFrom::Start(off) => {
+                        (0, (off as usize & 0xffff_ffff), ((off >> 32) as usize) & 0xffff_ffff)
+                    }
+                    SeekFrom::Current(off) => {
+                        (1, (off as usize & 0xffff_ffff), ((off >> 32) as usize) & 0xffff_ffff)
+                    }
+                    SeekFrom::End(off) => {
+                        (2, (off as usize & 0xffff_ffff), ((off >> 32) as usize) & 0xffff_ffff)
+                    }
+                };
+                [39 | ((fd as usize) << 16), a1, a2, a3, 0]
+            }
+            PddbBlockingScalar::CloseKeyStd(fd) => [34 | ((fd as usize) << 16), 0, 0, 0, 0],
+        }
+    }
+}
+
+/// Return a `Connection` to the PDDB database server. This server is used for
+/// communicating with the persistent database.
+pub(crate) fn pddb_server() -> Connection {
+    static PDDB_CONNECTION: AtomicU32 = AtomicU32::new(0);
+    let cid = PDDB_CONNECTION.load(Ordering::Relaxed);
+    if cid != 0 {
+        return cid.into();
+    }
+
+    let cid = connect("_Plausibly Deniable Database_").unwrap();
+    PDDB_CONNECTION.store(cid.into(), Ordering::Relaxed);
+    cid
+}
diff --git a/library/std/src/sys/fs/mod.rs b/library/std/src/sys/fs/mod.rs
index 3b176d0d16c..46dbdb4f730 100644
--- a/library/std/src/sys/fs/mod.rs
+++ b/library/std/src/sys/fs/mod.rs
@@ -32,6 +32,9 @@
     } else if #[cfg(target_os = "wasi")] {
         mod wasi;
         use wasi as imp;
+    } else if #[cfg(target_os = "xous")] {
+        mod xous;
+        use xous as imp;
     } else {
         mod unsupported;
         use unsupported as imp;
diff --git a/library/std/src/sys/fs/xous.rs b/library/std/src/sys/fs/xous.rs
new file mode 100644
index 00000000000..b5c08e04a6e
--- /dev/null
+++ b/library/std/src/sys/fs/xous.rs
@@ -0,0 +1,651 @@
+mod senres;
+
+use alloc::str::FromStr;
+
+use crate::ffi::OsString;
+use crate::fmt;
+use crate::hash::Hash;
+use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
+use crate::os::xous::ffi::{OsStrExt, blocking_scalar, lend_mut};
+use crate::os::xous::services::{PddbBlockingScalar, PddbLend, PddbLendMut, pddb_server};
+use crate::path::{Path, PathBuf};
+use crate::sys::time::SystemTime;
+use crate::sys::unsupported;
+use senres::{Senres, SenresMut, Stack};
+
+pub use crate::sys::fs::common::exists;
+
+pub struct File {
+    fd: u16,
+    len: u64,
+}
+
+#[derive(Clone)]
+pub struct FileAttr {
+    pub(crate) kind: FileType,
+    pub(crate) len: u64,
+}
+
+pub struct ReadDir {
+    root: PathBuf,
+    entries: Vec<DirEntry>,
+}
+
+pub struct DirEntry {
+    name: String,
+    path: String,
+    // basis: Option<String>,
+    kind: FileType,
+}
+
+#[derive(Clone, Debug)]
+pub struct OpenOptions {
+    create_file: bool,
+    append: bool,
+    truncate: bool,
+    create_new: bool,
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct FileTimes {}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FilePermissions {}
+
+#[derive(PartialEq, Eq, Debug, Copy, Clone, Hash)]
+pub enum FileType {
+    Basis = 0,
+    Dict = 1,
+    Key = 2,
+    /// This represents both a dict and a key that share the same name
+    DictKey = 3,
+    None = 4,
+    Unknown = 5,
+}
+
+#[derive(Debug)]
+pub struct DirBuilder {}
+
+impl FileAttr {
+    pub fn size(&self) -> u64 {
+        self.len
+    }
+
+    pub fn perm(&self) -> FilePermissions {
+        FilePermissions {}
+    }
+
+    pub fn file_type(&self) -> FileType {
+        self.kind
+    }
+
+    pub fn modified(&self) -> io::Result<SystemTime> {
+        // println!("rust: FileAttr::copy()");
+        unsupported()
+    }
+
+    pub fn accessed(&self) -> io::Result<SystemTime> {
+        // println!("rust: FileAttr::accessed()");
+        unsupported()
+    }
+
+    pub fn created(&self) -> io::Result<SystemTime> {
+        // println!("rust: FileAttr::created()");
+        unsupported()
+    }
+}
+
+impl FilePermissions {
+    pub fn readonly(&self) -> bool {
+        false
+    }
+
+    pub fn set_readonly(&mut self, _readonly: bool) {}
+}
+
+impl FileTimes {
+    pub fn set_accessed(&mut self, _t: SystemTime) {}
+    pub fn set_modified(&mut self, _t: SystemTime) {}
+}
+
+impl FileType {
+    pub fn is_dir(&self) -> bool {
+        let is_dir = match *self {
+            FileType::Basis | FileType::Dict | FileType::DictKey => true,
+            FileType::Key | FileType::Unknown | FileType::None => false,
+        };
+        // println!("rust: {:?} is_dir()? {:?}", self, is_dir);
+        is_dir
+    }
+
+    pub fn is_file(&self) -> bool {
+        let is_file = match *self {
+            FileType::DictKey | FileType::Key => true,
+            FileType::Basis | FileType::Dict | FileType::Unknown | FileType::None => false,
+        };
+        // println!("rust: {:?} is_file()? {:?}", self, is_file);
+        is_file
+    }
+
+    pub fn is_symlink(&self) -> bool {
+        false
+    }
+
+    pub fn is_basis(&self) -> bool {
+        *self == FileType::Basis
+    }
+}
+
+impl Iterator for ReadDir {
+    type Item = io::Result<DirEntry>;
+
+    fn next(&mut self) -> Option<io::Result<DirEntry>> {
+        self.entries.pop().map(|v| Ok(v))
+    }
+}
+
+impl fmt::Debug for ReadDir {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // This will only be called from std::fs::ReadDir, which will add a "ReadDir()" frame.
+        // Thus the result will be e g 'ReadDir("C:\")'
+        fmt::Debug::fmt(&*self.root, f)
+    }
+}
+
+impl DirEntry {
+    pub fn path(&self) -> PathBuf {
+        PathBuf::from_str(&self.path).unwrap()
+    }
+
+    pub fn file_name(&self) -> OsString {
+        crate::ffi::OsStr::from_bytes(self.name.as_bytes()).to_os_string()
+    }
+
+    pub fn metadata(&self) -> io::Result<FileAttr> {
+        match self.kind {
+            FileType::None | FileType::Unknown => Err(crate::io::Error::new(
+                crate::io::ErrorKind::NotFound,
+                "File or directory does not exist, or is corrupted",
+            )),
+            _ => Ok(FileAttr { kind: self.kind, len: 0 }),
+        }
+    }
+
+    pub fn file_type(&self) -> io::Result<FileType> {
+        Ok(self.kind)
+    }
+}
+
+impl OpenOptions {
+    pub fn new() -> OpenOptions {
+        OpenOptions { create_file: false, truncate: false, append: false, create_new: false }
+    }
+
+    pub fn read(&mut self, _read: bool) {}
+    pub fn write(&mut self, _write: bool) {}
+    pub fn append(&mut self, append: bool) {
+        self.append = append;
+    }
+    pub fn truncate(&mut self, truncate: bool) {
+        self.truncate = truncate;
+    }
+    pub fn create(&mut self, create: bool) {
+        self.create_file = create;
+    }
+    pub fn create_new(&mut self, create_new: bool) {
+        self.create_new = create_new;
+    }
+}
+
+impl File {
+    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+        let mut request = Stack::<4096>::new();
+        let path_as_str = path.as_os_str().to_str().ok_or_else(|| {
+            crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+        })?;
+
+        {
+            let mut writer = request.writer(*b"KyOQ").ok_or_else(|| {
+                crate::io::Error::new(
+                    crate::io::ErrorKind::InvalidFilename,
+                    "unable to create request",
+                )
+            })?;
+
+            writer.append(path_as_str);
+            writer.append(opts.create_file);
+            writer.append(false); // create_path
+            writer.append(opts.create_new);
+            writer.append(opts.append);
+            writer.append(opts.truncate);
+            writer.append(0u64); // alloc_hint
+            writer.append::<Option<[u32; 4]>>(None); // callback SID
+        }
+
+        // Make the actual call
+        let (err, _) =
+            request.lend_mut(pddb_server(), PddbLendMut::OpenKeyStd.into()).or_else(|_| {
+                Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+            })?;
+
+        if err != 0 {
+            return Err(crate::io::Error::new(
+                crate::io::ErrorKind::Other,
+                "error occurred when opening file",
+            ));
+        }
+
+        let reader = request.reader(*b"KyOR").ok_or_else(|| {
+            crate::io::Error::new(crate::io::ErrorKind::Other, "invalid response from server")
+        })?;
+
+        let fd: u16 = reader.try_get_from().or_else(|_| {
+            Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+        })?;
+
+        let len: u64 = reader.try_get_from().or_else(|_| {
+            Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+        })?;
+
+        Ok(File { len, fd })
+    }
+
+    pub fn file_attr(&self) -> io::Result<FileAttr> {
+        Ok(FileAttr { kind: FileType::Key, len: self.len })
+    }
+
+    pub fn fsync(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn datasync(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn lock(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn lock_shared(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn try_lock(&self) -> io::Result<bool> {
+        unsupported()
+    }
+
+    pub fn try_lock_shared(&self) -> io::Result<bool> {
+        unsupported()
+    }
+
+    pub fn unlock(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn truncate(&self, _size: u64) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        #[repr(C, align(4096))]
+        struct ReadBuffer {
+            data: [u8; 4096],
+        }
+        let mut buffer = ReadBuffer { data: [0u8; 4096] };
+        let buffer_len = buffer.data.len();
+
+        let (offset, valid) = lend_mut(
+            pddb_server(),
+            PddbLendMut::ReadKeyStd(self.fd).into(),
+            &mut buffer.data,
+            0,
+            buf.len().min(buffer_len),
+        )
+        .map_err(|_| {
+            crate::io::Error::new(crate::io::ErrorKind::Other, "read() encountered an error")
+        })?;
+
+        if offset != 0 {
+            return Err(crate::io::Error::new(
+                crate::io::ErrorKind::Other,
+                "read() encountered an error",
+            ));
+        }
+        let valid = buf.len().min(valid).min(buffer.data.len());
+        let contents = &buffer.data[0..valid];
+        for (src, dest) in contents.iter().zip(buf.iter_mut()) {
+            *dest = *src;
+        }
+        Ok(valid)
+    }
+
+    pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        crate::io::default_read_vectored(|buf| self.read(buf), bufs)
+    }
+
+    pub fn is_read_vectored(&self) -> bool {
+        false
+    }
+
+    pub fn read_buf(&self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        crate::io::default_read_buf(|buf| self.read(buf), cursor)
+    }
+
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        #[repr(C, align(4096))]
+        struct ReadBuffer {
+            data: [u8; 4096],
+        }
+        let mut buffer = ReadBuffer { data: [0u8; 4096] };
+
+        let valid = buf.len().min(buffer.data.len());
+        {
+            let contents = &mut buffer.data[0..valid];
+            for (src, dest) in buf.iter().zip(contents.iter_mut()) {
+                *dest = *src;
+            }
+        }
+
+        // This needs to be mutable for now because pddb uses libxous which doesn't
+        // support returning values with non-mutable lends, and we need to get the
+        // "offset" as a return value.
+        let (offset, valid) = lend_mut(
+            pddb_server(),
+            PddbLend::WriteKeyStd(self.fd).into(),
+            &mut buffer.data,
+            0,
+            valid,
+        )
+        .map_err(|_| {
+            crate::io::Error::new(crate::io::ErrorKind::Other, "write() encountered an error")
+        })?;
+
+        if offset == 0 {
+            Ok(valid)
+        } else {
+            Err(crate::io::Error::new(
+                crate::io::ErrorKind::Other,
+                "write operation encountered an error",
+            ))
+        }
+    }
+
+    pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        crate::io::default_write_vectored(|buf| self.write(buf), bufs)
+    }
+
+    pub fn is_write_vectored(&self) -> bool {
+        false
+    }
+
+    pub fn flush(&self) -> io::Result<()> {
+        // println!("rust: File::flush()");
+        unsupported()
+    }
+
+    pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
+        let result =
+            blocking_scalar(pddb_server(), PddbBlockingScalar::SeekKeyStd(self.fd, pos).into())
+                .map_err(|_| {
+                    crate::io::Error::new(crate::io::ErrorKind::NotSeekable, "error when seeking")
+                })?;
+
+        Ok((result[0] as u64) | ((result[1] as u64) << 32))
+    }
+
+    pub fn tell(&self) -> io::Result<u64> {
+        self.seek(SeekFrom::Current(0))
+    }
+
+    pub fn duplicate(&self) -> io::Result<File> {
+        unsupported()
+    }
+
+    pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
+        unsupported()
+    }
+}
+
+impl Drop for File {
+    fn drop(&mut self) {
+        blocking_scalar(pddb_server(), PddbBlockingScalar::CloseKeyStd(self.fd).into()).unwrap();
+    }
+}
+
+impl DirBuilder {
+    pub fn new() -> DirBuilder {
+        DirBuilder {}
+    }
+
+    pub fn mkdir(&self, p: &Path) -> io::Result<()> {
+        let path_as_str = p.as_os_str().to_str().ok_or_else(|| {
+            crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+        })?;
+
+        let mut request = Stack::<4096>::new();
+
+        let mut writer = request.writer(*b"NuDQ").ok_or_else(|| {
+            crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+        })?;
+        writer.append(path_as_str);
+
+        // Make the actual call
+        request.lend_mut(pddb_server(), PddbLendMut::CreateDictStd.into()).or_else(|_| {
+            Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+        })?;
+        Ok(())
+    }
+}
+
+impl fmt::Debug for File {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("File").field("fd", &self.fd).finish()
+    }
+}
+
+pub fn readdir(p: &Path) -> io::Result<ReadDir> {
+    let path_as_str = p.as_os_str().to_str().ok_or_else(|| {
+        crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+    })?;
+    let (_basis, _dict) = match crate::sys::path::split_basis_and_dict(path_as_str, || None) {
+        Ok(s) => s,
+        Err(_) => {
+            return Err(crate::io::Error::new(crate::io::ErrorKind::Other, "path was not valid"));
+        }
+    };
+
+    let mut request = Stack::<4096>::new();
+
+    // Write the request to the call
+    {
+        let mut writer = request.writer(*b"PthQ").ok_or_else(|| {
+            crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+        })?;
+        writer.append(path_as_str);
+    }
+
+    // Make the actual call
+    request.lend_mut(pddb_server(), PddbLendMut::ListPathStd.into()).or_else(|_| {
+        Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+    })?;
+
+    // Read the data back
+    let reader = request.reader(*b"PthR").ok_or_else(|| {
+        crate::io::Error::new(crate::io::ErrorKind::Other, "invalid response from server")
+    })?;
+
+    let mut entries = vec![];
+    let count = reader.try_get_from::<u32>().unwrap() as usize;
+    for _ in 0..count {
+        let name = reader.try_get_ref_from().unwrap();
+        let kind = match reader.try_get_from::<u8>() {
+            Ok(0) => FileType::Basis,
+            Ok(1) => FileType::Dict,
+            Ok(2) => FileType::Key,
+            Ok(3) => FileType::DictKey,
+            Ok(4) => FileType::None,
+            _ => FileType::Unknown,
+        };
+        let mut path = path_as_str.to_owned();
+        if !path.is_empty() && !path.ends_with(crate::path::MAIN_SEPARATOR) {
+            path.push(crate::path::MAIN_SEPARATOR);
+        }
+        path.push_str(name);
+        entries.push(DirEntry {
+            name: name.to_owned(),
+            path,
+            // basis: basis.map(|m| m.to_owned()),
+            kind,
+        });
+    }
+
+    return Ok(ReadDir { entries, root: p.to_owned() });
+}
+
+pub fn unlink(p: &Path) -> io::Result<()> {
+    let path_as_str = p.as_os_str().to_str().ok_or_else(|| {
+        crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+    })?;
+    let mut request = Stack::<4096>::new();
+    {
+        let mut writer = request.writer(*b"RmKQ").ok_or_else(|| {
+            crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+        })?;
+        writer.append(path_as_str);
+    }
+
+    // Make the actual call
+    let (err, _) =
+        request.lend_mut(pddb_server(), PddbLendMut::DeleteKeyStd.into()).or_else(|_| {
+            Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+        })?;
+
+    if err != 0 {
+        return Err(crate::io::Error::new(crate::io::ErrorKind::Other, "error during operation"));
+    }
+    Ok(())
+}
+
+pub fn rename(_old: &Path, _new: &Path) -> io::Result<()> {
+    // println!("rust: rename()");
+    unsupported()
+}
+
+pub fn set_perm(_p: &Path, _perm: FilePermissions) -> io::Result<()> {
+    // println!("rust: set_perm()");
+    unsupported()
+}
+
+pub fn rmdir(p: &Path) -> io::Result<()> {
+    let path_as_str = p.as_os_str().to_str().ok_or_else(|| {
+        crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+    })?;
+
+    let mut request = Stack::<4096>::new();
+
+    let mut writer = request.writer(*b"RmDQ").ok_or_else(|| {
+        crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+    })?;
+    writer.append(path_as_str);
+
+    // Make the actual call
+    let (err, _) =
+        request.lend_mut(pddb_server(), PddbLendMut::DeleteDictStd.into()).or_else(|_| {
+            Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+        })?;
+    if err != 0 {
+        return Err(crate::io::Error::new(crate::io::ErrorKind::Other, "error during operation"));
+    }
+    Ok(())
+}
+
+pub fn remove_dir_all(path: &Path) -> io::Result<()> {
+    for child in readdir(path)? {
+        let child = child?;
+        let child_type = child.file_type()?;
+        if child_type.is_dir() {
+            remove_dir_all(&child.path())?;
+        } else {
+            unlink(&child.path())?;
+        }
+    }
+    rmdir(path)
+}
+
+pub fn readlink(p: &Path) -> io::Result<PathBuf> {
+    stat(p)?;
+    Err(io::const_error!(io::ErrorKind::InvalidInput, "not a symbolic link"))
+}
+
+pub fn symlink(_original: &Path, _link: &Path) -> io::Result<()> {
+    // This target doesn't support symlinks
+    unsupported()
+}
+
+pub fn link(_src: &Path, _dst: &Path) -> io::Result<()> {
+    // This target doesn't support links
+    unsupported()
+}
+
+pub fn stat(p: &Path) -> io::Result<FileAttr> {
+    let path_as_str = p.as_os_str().to_str().ok_or_else(|| {
+        crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+    })?;
+    let mut request = Stack::<4096>::new();
+
+    // Write the request to the call
+    {
+        let mut writer = request.writer(*b"StaQ").ok_or_else(|| {
+            crate::io::Error::new(crate::io::ErrorKind::InvalidFilename, "invalid path")
+        })?;
+        writer.append(path_as_str);
+    }
+
+    // Make the actual call
+    request.lend_mut(pddb_server(), PddbLendMut::StatPathStd.into()).or_else(|_| {
+        Err(crate::io::Error::new(crate::io::ErrorKind::Other, "unable to query database"))
+    })?;
+
+    // Read the data back
+    let reader = request.reader(*b"StaR").expect("unable to get reader");
+    let kind = match reader.try_get_from::<u8>() {
+        Ok(0) => FileType::Basis,
+        Ok(1) => FileType::Dict,
+        Ok(2) => FileType::Key,
+        Ok(3) => FileType::DictKey,
+        Ok(4) => FileType::None,
+        Ok(5) => FileType::Unknown,
+        _ => FileType::Unknown,
+    };
+
+    match kind {
+        FileType::None | FileType::Unknown => Err(crate::io::Error::new(
+            crate::io::ErrorKind::NotFound,
+            "File or directory does not exist, or is corrupted",
+        )),
+        _ => Ok(FileAttr { kind, len: 0 }),
+    }
+}
+
+pub fn lstat(p: &Path) -> io::Result<FileAttr> {
+    // This target doesn't support symlinks
+    stat(p)
+}
+
+pub fn canonicalize(_p: &Path) -> io::Result<PathBuf> {
+    // println!("rust: canonicalize()");
+    unsupported()
+}
+
+pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
+    use crate::fs::File;
+
+    let mut reader = File::open(from)?;
+    let mut writer = File::create(to)?;
+
+    io::copy(&mut reader, &mut writer)
+}
diff --git a/library/std/src/sys/fs/xous/senres.rs b/library/std/src/sys/fs/xous/senres.rs
new file mode 100644
index 00000000000..3511ad53288
--- /dev/null
+++ b/library/std/src/sys/fs/xous/senres.rs
@@ -0,0 +1,628 @@
+#![allow(unused)]
+#![allow(elided_lifetimes_in_paths)]
+
+use crate::os::xous::ffi::{Connection, InvokeType, Syscall, SyscallResult};
+use core::cell::Cell;
+use core::convert::TryInto;
+
+/// Senres V1 always begins with the number 0x344cb6ca to indicate it's valid.
+/// This number will change on subsequent versions.
+const SENRES_V1_MAGIC: u32 = 0x344cb6ca;
+
+/// A struct to send and receive data. This struct must be page-aligned
+/// in order to be sendable across processes.
+#[repr(C, align(4096))]
+pub struct Stack<const N: usize = 4096> {
+    data: [u8; N],
+}
+
+/// A version of the message on the receiving side, reconstituted from
+/// a slice from a message.
+pub struct Message<'a> {
+    message_id: usize,
+    auto_return: bool,
+    data: &'a [u8],
+}
+
+/// A version of the message on the receiving side, reconstituted from
+/// a slice from a message.
+pub struct MutableMessage<'a> {
+    message_id: usize,
+    mutable: bool,
+    auto_return: bool,
+    data: &'a mut [u8],
+}
+
+impl<'a> Message<'a> {
+    pub fn new(message_id: usize, data: usize, len: usize, mutable: bool) -> Result<Self, ()> {
+        if data & 4095 != 0 || len & 4095 != 0 {
+            return Err(());
+        }
+        Ok(Message {
+            message_id,
+            auto_return: true,
+            data: unsafe {
+                core::slice::from_raw_parts_mut(crate::ptr::with_exposed_provenance_mut::<u8>(data), len)
+            },
+        })
+    }
+    // Need to figure out how to make the non-mutable version work, since `data`
+    // must be a mutable vec.
+    pub fn from_slice(data: &'a [u8]) -> Result<Self, ()> {
+        Ok(Message { message_id: 0, auto_return: false, data })
+    }
+    pub fn from_mut_slice(data: &'a mut [u8]) -> Result<MutableMessage<'a>, ()> {
+        Ok(MutableMessage { message_id: 0, mutable: true, auto_return: false, data })
+    }
+    pub fn auto_return(&mut self, enable: bool) {
+        self.auto_return = enable;
+    }
+}
+
+#[cfg(target_os = "xous")]
+fn return_memory_message(message_id: usize, data_addr: usize, data_len: usize) -> usize {
+    let a0 = Syscall::ReturnMemory as usize;
+
+    // "Offset"
+    let a4 = 0;
+
+    // "Valid"
+    let a5 = 0;
+
+    let mut result: usize;
+
+    unsafe {
+        core::arch::asm!(
+            "ecall",
+            inlateout("a0") a0 => result,
+            inlateout("a1") message_id => _,
+            inlateout("a2") data_addr => _,
+            inlateout("a3") data_len=> _,
+            inlateout("a4") a4 => _,
+            inlateout("a5") a5 => _,
+            out("a6") _,
+            out("a7") _,
+        )
+    };
+    result
+}
+
+impl<'a> Drop for Message<'a> {
+    fn drop(&mut self) {
+        if self.auto_return {
+            #[cfg(target_os = "xous")]
+            return_memory_message(self.message_id, self.data.as_ptr() as usize, self.data.len());
+        }
+    }
+}
+
+impl<'a> SenresMut for MutableMessage<'a> {
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.data
+    }
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
+}
+
+impl<'a> Senres for MutableMessage<'a> {
+    fn as_slice(&self) -> &[u8] {
+        self.data
+    }
+    fn len(&self) -> usize {
+        self.data.len()
+    }
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+    fn can_create_writer(&self) -> bool {
+        self.mutable
+    }
+}
+
+impl<'a> Senres for Message<'a> {
+    fn as_slice(&self) -> &[u8] {
+        self.data
+    }
+    fn len(&self) -> usize {
+        self.data.len()
+    }
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+    fn can_create_writer(&self) -> bool {
+        false
+    }
+}
+
+pub trait Senres {
+    fn as_slice(&self) -> &[u8];
+    fn as_ptr(&self) -> *const u8;
+    fn len(&self) -> usize;
+
+    fn can_create_writer(&self) -> bool {
+        true
+    }
+
+    fn reader(&self, fourcc: [u8; 4]) -> Option<Reader<Self>>
+    where
+        Self: core::marker::Sized,
+    {
+        let reader = Reader { backing: self, offset: core::cell::Cell::new(0) };
+        if SENRES_V1_MAGIC != reader.try_get_from().ok()? {
+            return None;
+        }
+        let target_fourcc: [u8; 4] = reader.try_get_from().ok()?;
+        if target_fourcc != fourcc {
+            return None;
+        }
+        Some(reader)
+    }
+
+    #[cfg(not(target_os = "xous"))]
+    fn lend(&self, _connection: u32, _opcode: usize) -> Result<(), ()> {
+        Ok(())
+    }
+
+    #[cfg(target_os = "xous")]
+    fn lend(&self, connection: u32, opcode: usize) -> Result<(), ()> {
+        let mut a0 = Syscall::SendMessage as usize;
+        let a1: usize = connection.try_into().unwrap();
+        let a2 = InvokeType::Lend as usize;
+        let a3 = opcode;
+        let a4 = self.as_ptr() as usize;
+        let a5 = self.len();
+
+        unsafe {
+            core::arch::asm!(
+                "ecall",
+                inlateout("a0") a0,
+                inlateout("a1") a1 => _,
+                inlateout("a2") a2 => _,
+                inlateout("a3") a3 => _,
+                inlateout("a4") a4 => _,
+                inlateout("a5") a5 => _,
+                out("a6") _,
+                out("a7") _,
+            )
+        };
+
+        let result = a0;
+        if result == SyscallResult::MemoryReturned as usize {
+            Ok(())
+        } else {
+            println!("Unexpected memory return value: {}", result);
+            Err(())
+        }
+    }
+}
+
+pub trait SenresMut: Senres {
+    fn as_mut_slice(&mut self) -> &mut [u8];
+    fn as_mut_ptr(&mut self) -> *mut u8;
+    fn writer(&mut self, fourcc: [u8; 4]) -> Option<Writer<Self>>
+    where
+        Self: core::marker::Sized,
+    {
+        if !self.can_create_writer() {
+            return None;
+        }
+        let mut writer = Writer { backing: self, offset: 0 };
+        writer.append(SENRES_V1_MAGIC);
+        writer.append(fourcc);
+        Some(writer)
+    }
+    #[cfg(not(target_os = "xous"))]
+    fn lend_mut(&mut self, _connection: u32, _opcode: usize) -> Result<(usize, usize), ()> {
+        Ok((0, 0))
+    }
+    #[cfg(target_os = "xous")]
+    fn lend_mut(&mut self, connection: Connection, opcode: usize) -> Result<(usize, usize), ()> {
+        crate::os::xous::ffi::lend_mut(connection, opcode, self.as_mut_slice(), 0, 0).map_err(|_| ())
+    }
+}
+
+pub struct Writer<'a, Backing: SenresMut> {
+    backing: &'a mut Backing,
+    offset: usize,
+}
+
+pub struct DelayedWriter<Backing: SenresMut, T: SenSer<Backing>> {
+    offset: usize,
+    _kind: core::marker::PhantomData<T>,
+    _backing: core::marker::PhantomData<Backing>,
+}
+
+pub struct Reader<'a, Backing: Senres> {
+    backing: &'a Backing,
+    offset: Cell<usize>,
+}
+
+pub trait SenSer<Backing: SenresMut> {
+    fn append_to(&self, senres: &mut Writer<Backing>);
+}
+
+pub trait RecDes<Backing: Senres> {
+    fn try_get_from(senres: &Reader<Backing>) -> Result<Self, ()>
+    where
+        Self: core::marker::Sized;
+}
+
+pub trait RecDesRef<'a, Backing: Senres> {
+    fn try_get_ref_from(senres: &'a Reader<Backing>) -> Result<&'a Self, ()>;
+}
+
+impl<const N: usize> Stack<N> {
+    /// Ensure that `N` is a multiple of 4096. This constant should
+    /// be evaluated in the constructor function.
+    const CHECK_ALIGNED: () = if N & 4095 != 0 {
+        panic!("Senres size must be a multiple of 4096")
+    };
+
+    pub const fn new() -> Self {
+        // Ensure the `N` that was specified is a multiple of 4096
+        #[allow(clippy::no_effect, clippy::let_unit_value)]
+        let _ = Self::CHECK_ALIGNED;
+        Stack { data: [0u8; N] }
+    }
+}
+
+impl<const N: usize> SenresMut for Stack<N> {
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.data.as_mut_slice()
+    }
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        &mut self.data as *mut _ as *mut u8
+    }
+}
+
+impl<const N: usize> Senres for Stack<N> {
+    fn as_slice(&self) -> &[u8] {
+        self.data.as_slice()
+    }
+    fn len(&self) -> usize {
+        N
+    }
+    fn as_ptr(&self) -> *const u8 {
+        &self.data as *const _ as *const u8
+    }
+}
+
+impl<'a, Backing: SenresMut> Writer<'a, Backing> {
+    pub fn append<T: SenSer<Backing>>(&mut self, other: T) {
+        other.append_to(self);
+    }
+
+    pub fn delayed_append<T: SenSer<Backing>>(&mut self) -> DelayedWriter<Backing, T> {
+        let delayed_writer = DelayedWriter {
+            offset: self.offset,
+            _backing: core::marker::PhantomData::<Backing>,
+            _kind: core::marker::PhantomData::<T>,
+        };
+        self.offset += core::mem::size_of::<T>();
+        delayed_writer
+    }
+
+    pub fn do_delayed_append<T: SenSer<Backing>>(
+        &mut self,
+        delayed_writer: DelayedWriter<Backing, T>,
+        other: T,
+    ) {
+        let current_offset = self.offset;
+        self.offset = delayed_writer.offset;
+        other.append_to(self);
+        if self.offset != delayed_writer.offset + core::mem::size_of::<T>() {
+            panic!("writer incorrectly increased offset");
+        }
+        self.offset = current_offset;
+    }
+
+    pub fn align_to(&mut self, alignment: usize) {
+        while self.offset & (alignment - 1) != 0 {
+            self.offset += 1;
+        }
+    }
+}
+
+impl<'a, Backing: Senres> Reader<'a, Backing> {
+    pub fn try_get_from<T: RecDes<Backing>>(&self) -> Result<T, ()> {
+        T::try_get_from(self)
+    }
+
+    pub fn try_get_ref_from<T: RecDesRef<'a, Backing> + ?Sized>(&'a self) -> Result<&'a T, ()> {
+        T::try_get_ref_from(self)
+    }
+
+    fn align_to(&self, alignment: usize) {
+        while self.offset.get() & (alignment - 1) != 0 {
+            self.offset.set(self.offset.get() + 1);
+        }
+    }
+}
+
+macro_rules! primitive_impl {
+    ($SelfT:ty) => {
+        impl<Backing: SenresMut> SenSer<Backing> for $SelfT {
+            fn append_to(&self, senres: &mut Writer<Backing>) {
+                senres.align_to(core::mem::align_of::<Self>());
+                for (src, dest) in self
+                    .to_le_bytes()
+                    .iter()
+                    .zip(senres.backing.as_mut_slice()[senres.offset..].iter_mut())
+                {
+                    *dest = *src;
+                    senres.offset += 1;
+                }
+            }
+        }
+
+        impl<Backing: Senres> RecDes<Backing> for $SelfT {
+            fn try_get_from(senres: &Reader<Backing>) -> Result<Self, ()> {
+                senres.align_to(core::mem::align_of::<Self>());
+                let my_size = core::mem::size_of::<Self>();
+                let offset = senres.offset.get();
+                if offset + my_size > senres.backing.as_slice().len() {
+                    return Err(());
+                }
+                let val = Self::from_le_bytes(
+                    senres.backing.as_slice()[offset..offset + my_size].try_into().unwrap(),
+                );
+                senres.offset.set(offset + my_size);
+                Ok(val)
+            }
+        }
+    };
+}
+
+impl<Backing: SenresMut> SenSer<Backing> for bool {
+    fn append_to(&self, senres: &mut Writer<Backing>) {
+        senres.align_to(core::mem::align_of::<Self>());
+        senres.backing.as_mut_slice()[senres.offset] = if *self { 1 } else { 0 };
+        senres.offset += 1;
+    }
+}
+
+impl<Backing: Senres> RecDes<Backing> for bool {
+    fn try_get_from(senres: &Reader<Backing>) -> Result<Self, ()> {
+        senres.align_to(core::mem::align_of::<Self>());
+        let my_size = core::mem::size_of::<Self>();
+        let offset = senres.offset.get();
+        if offset + my_size > senres.backing.as_slice().len() {
+            return Err(());
+        }
+        let val = match senres.backing.as_slice()[offset] {
+            0 => Ok(false),
+            1 => Ok(true),
+            _ => Err(()),
+        };
+        senres.offset.set(offset + my_size);
+        val
+    }
+}
+
+impl<T: SenSer<Backing>, Backing: SenresMut> SenSer<Backing> for Option<T> {
+    fn append_to(&self, senres: &mut Writer<Backing>) {
+        if let Some(val) = self {
+            senres.append(1u8);
+            val.append_to(senres);
+        } else {
+            senres.append(0u8);
+        }
+    }
+}
+
+impl<T: RecDes<Backing>, Backing: Senres> RecDes<Backing> for Option<T> {
+    fn try_get_from(senres: &Reader<Backing>) -> Result<Self, ()> {
+        if senres.offset.get() + 1 > senres.backing.as_slice().len() {
+            return Err(());
+        }
+        let check = senres.try_get_from::<u8>()?;
+        if check == 0 {
+            return Ok(None);
+        }
+        if check != 1 {
+            return Err(());
+        }
+        let my_size = core::mem::size_of::<Self>();
+        if senres.offset.get() + my_size > senres.backing.as_slice().len() {
+            return Err(());
+        }
+        Ok(Some(T::try_get_from(senres)?))
+    }
+}
+
+primitive_impl! {u8}
+primitive_impl! {i8}
+primitive_impl! {u16}
+primitive_impl! {i16}
+primitive_impl! {u32}
+primitive_impl! {i32}
+primitive_impl! {u64}
+primitive_impl! {i64}
+
+impl<T: SenSer<Backing>, Backing: SenresMut> SenSer<Backing> for &[T] {
+    fn append_to(&self, senres: &mut Writer<Backing>) {
+        senres.append(self.len() as u32);
+        for entry in self.iter() {
+            entry.append_to(senres)
+        }
+    }
+}
+
+impl<T: SenSer<Backing>, Backing: SenresMut, const N: usize> SenSer<Backing> for [T; N] {
+    fn append_to(&self, senres: &mut Writer<Backing>) {
+        // senres.append(self.len() as u32);
+        senres.align_to(core::mem::align_of::<Self>());
+        for entry in self.iter() {
+            entry.append_to(senres)
+        }
+    }
+}
+
+impl<T: RecDes<Backing>, Backing: Senres, const N: usize> RecDes<Backing> for [T; N] {
+    fn try_get_from(senres: &Reader<Backing>) -> Result<Self, ()> {
+        let len = core::mem::size_of::<Self>();
+        senres.align_to(core::mem::align_of::<Self>());
+        let offset = senres.offset.get();
+        if offset + len > senres.backing.as_slice().len() {
+            return Err(());
+        }
+
+        // See https://github.com/rust-lang/rust/issues/61956 for why this
+        // is awful
+        let mut output: [core::mem::MaybeUninit<T>; N] =
+            unsafe { core::mem::MaybeUninit::uninit().assume_init() };
+        for elem in &mut output[..] {
+            elem.write(T::try_get_from(senres)?);
+        }
+
+        // Using &mut as an assertion of unique "ownership"
+        let ptr = &mut output as *mut _ as *mut [T; N];
+        let res = unsafe { ptr.read() };
+        core::mem::forget(output);
+        Ok(res)
+    }
+}
+
+impl<Backing: SenresMut> SenSer<Backing> for str {
+    fn append_to(&self, senres: &mut Writer<Backing>) {
+        senres.append(self.len() as u32);
+        for (src, dest) in
+            self.as_bytes().iter().zip(senres.backing.as_mut_slice()[senres.offset..].iter_mut())
+        {
+            *dest = *src;
+            senres.offset += 1;
+        }
+    }
+}
+
+impl<Backing: SenresMut> SenSer<Backing> for &str {
+    fn append_to(&self, senres: &mut Writer<Backing>) {
+        senres.append(self.len() as u32);
+        for (src, dest) in
+            self.as_bytes().iter().zip(senres.backing.as_mut_slice()[senres.offset..].iter_mut())
+        {
+            *dest = *src;
+            senres.offset += 1;
+        }
+    }
+}
+
+impl<Backing: Senres> RecDes<Backing> for String {
+    fn try_get_from(senres: &Reader<Backing>) -> Result<Self, ()> {
+        let len = senres.try_get_from::<u32>()? as usize;
+        let offset = senres.offset.get();
+        if offset + len > senres.backing.as_slice().len() {
+            return Err(());
+        }
+        core::str::from_utf8(&senres.backing.as_slice()[offset..offset + len]).or(Err(())).map(
+            |e| {
+                senres.offset.set(offset + len);
+                e.to_owned()
+            },
+        )
+    }
+}
+
+impl<'a, Backing: Senres> RecDesRef<'a, Backing> for str {
+    fn try_get_ref_from(senres: &'a Reader<Backing>) -> Result<&'a Self, ()> {
+        let len = senres.try_get_from::<u32>()? as usize;
+        let offset = senres.offset.get();
+        if offset + len > senres.backing.as_slice().len() {
+            return Err(());
+        }
+        core::str::from_utf8(&senres.backing.as_slice()[offset..offset + len]).or(Err(())).map(
+            |e| {
+                senres.offset.set(offset + len);
+                e
+            },
+        )
+    }
+}
+
+impl<'a, Backing: Senres, T: RecDes<Backing>> RecDesRef<'a, Backing> for [T] {
+    fn try_get_ref_from(senres: &'a Reader<Backing>) -> Result<&'a Self, ()> {
+        let len = senres.try_get_from::<u32>()? as usize;
+        let offset = senres.offset.get();
+        if offset + (len * core::mem::size_of::<T>()) > senres.backing.as_slice().len() {
+            return Err(());
+        }
+        let ret = unsafe {
+            core::slice::from_raw_parts(
+                senres.backing.as_slice().as_ptr().add(offset) as *const T,
+                len,
+            )
+        };
+        senres.offset.set(offset + len * core::mem::size_of::<T>());
+        Ok(ret)
+    }
+}
+
+impl<const N: usize> Default for Stack<N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn do_stuff(_r: &Stack) {
+    println!("Stuff!");
+}
+
+#[test]
+fn smoke_test() {
+    let mut sr1 = Stack::<4096>::new();
+    // let sr2 = Senres::<4097>::new();
+    let sr3 = Stack::<8192>::new();
+    // let sr4 = Senres::<4098>::new();
+    let sr5 = Stack::new();
+
+    do_stuff(&sr5);
+    println!("Size of sr1: {}", core::mem::size_of_val(&sr1));
+    println!("Size of sr3: {}", core::mem::size_of_val(&sr3));
+    println!("Size of sr5: {}", core::mem::size_of_val(&sr5));
+
+    {
+        let mut writer = sr1.writer(*b"test").unwrap();
+        writer.append(16777215u32);
+        writer.append(u64::MAX);
+        writer.append("Hello, world!");
+        writer.append("String2");
+        writer.append::<Option<u32>>(None);
+        writer.append::<Option<u32>>(Some(42));
+        writer.append(96u8);
+        writer.append([1i32, 2, 3, 4, 5].as_slice());
+        writer.append([5u8, 4, 3, 2].as_slice());
+        writer.append([5u16, 4, 2]);
+        writer.append(["Hi", "There", "123456789"]);
+        // writer.append(["Hello".to_owned(), "There".to_owned(), "World".to_owned()].as_slice());
+    }
+    // println!("sr1: {:?}", sr1);
+
+    {
+        let reader = sr1.reader(*b"test").expect("couldn't get reader");
+        let val: u32 = reader.try_get_from().expect("couldn't get the u32 value");
+        println!("u32 val: {}", val);
+        let val: u64 = reader.try_get_from().expect("couldn't get the u64 value");
+        println!("u64 val: {:x}", val);
+        let val: &str = reader.try_get_ref_from().expect("couldn't get string value");
+        println!("String val: {}", val);
+        let val: String = reader.try_get_from().expect("couldn't get string2 value");
+        println!("String2 val: {}", val);
+        let val: Option<u32> = reader.try_get_from().expect("couldn't get Option<u32>");
+        println!("Option<u32> val: {:?}", val);
+        let val: Option<u32> = reader.try_get_from().expect("couldn't get Option<u32>");
+        println!("Option<u32> val: {:?}", val);
+
+        let val: u8 = reader.try_get_from().expect("couldn't get u8 weird padding");
+        println!("u8 val: {}", val);
+
+        let val: &[i32] = reader.try_get_ref_from().expect("couldn't get &[i32]");
+        println!("&[i32] val: {:?}", val);
+        let val: &[u8] = reader.try_get_ref_from().expect("couldn't get &[u8]");
+        println!("&[u8] val: {:?}", val);
+        let val: [u16; 3] = reader.try_get_from().expect("couldn't get [u16; 3]");
+        println!("[u16; 3] val: {:?}", val);
+        let val: [String; 3] = reader.try_get_from().expect("couldn't get [String; 3]");
+        println!("[String; 3] val: {:?}", val);
+    }
+}
-- 
2.34.1