std: xous: add panic support

When a process panics, it will send the panic message as a series of
scalar messages to the log server. This ensures that messages get out
while making sure the thread can clean up after itself.

Additionally, a panic message is sent to the graphics server if one
exists.

Signed-off-by: Sean Cross <[email protected]>

Author: xobs

library/std/src/sys/xous/stdio.rs

@@ -1,4 +1,6 @@
+use crate::cell::RefCell;
 use crate::io;
+thread_local! { static PANIC_WRITER: RefCell<Option<PanicWriter>> = RefCell::new(None) }
 
 pub struct Stdin;
 pub struct Stdout {}
@@ -32,14 +34,7 @@ impl io::Write for Stdout {
             for (dest, src) in lend_buffer.0.iter_mut().zip(chunk) {
                 *dest = *src;
             }
-            crate::os::xous::ffi::lend(
-                connection,
-                1,
-                &lend_buffer.0,
-                0,
-                chunk.len(),
-            )
-            .unwrap();
+            crate::os::xous::ffi::lend(connection, 1, &lend_buffer.0, 0, chunk.len()).unwrap();
         }
         Ok(buf.len())
     }
@@ -71,6 +66,95 @@ pub fn is_ebadf(_err: &io::Error) -> bool {
     true
 }
 
-pub fn panic_output() -> Option<Vec<u8>> {
-    None
+#[derive(Copy, Clone)]
+pub struct PanicWriter {
+    conn: crate::os::xous::ffi::Connection,
+    gfx_conn: Option<crate::os::xous::ffi::Connection>,
+}
+
+impl PanicWriter {
+    // Group `usize` bytes into a `usize` and return it, beginning
+    // from `offset` * sizeof(usize) bytes from the start. For example,
+    // `group_or_null([1,2,3,4,5,6,7,8], 1)` on a 32-bit system will
+    // return a usize with 5678 packed into it.
+    fn group_or_null(data: &[u8], offset: usize) -> usize {
+        let start = offset * core::mem::size_of::<usize>();
+        let mut out_array = [0u8; core::mem::size_of::<usize>()];
+        if start < data.len() {
+            for (dest, src) in out_array.iter_mut().zip(&data[start..]) {
+                *dest = *src;
+            }
+        }
+        usize::from_le_bytes(out_array)
+    }
+}
+
+impl io::Write for PanicWriter {
+    fn write(&mut self, s: &[u8]) -> core::result::Result<usize, io::Error> {
+        for c in s.chunks(core::mem::size_of::<usize>() * 4) {
+            // Text is grouped into 4x `usize` words. The id is 1100 plus
+            // the number of characters in this message.
+            // Ignore errors since we're already panicking.
+            crate::os::xous::ffi::try_scalar(
+                self.conn,
+                [
+                    1100 + c.len(),
+                    Self::group_or_null(&c, 0),
+                    Self::group_or_null(&c, 1),
+                    Self::group_or_null(&c, 2),
+                    Self::group_or_null(&c, 3),
+                ],
+            )
+            .ok();
+        }
+
+        // Serialze the text to the graphics panic handler, only if we were able
+        // to acquire a connection to it. Text length is encoded in the `valid` field,
+        // the data itself in the buffer. Typically several messages are require to
+        // fully transmit the entire panic message.
+        if let Some(connection) = self.gfx_conn {
+            #[repr(align(4096))]
+            struct Request([u8; 4096]);
+            let mut request = Request([0u8; 4096]);
+            for (&s, d) in s.iter().zip(request.0.iter_mut()) {
+                *d = s;
+            }
+            crate::os::xous::ffi::try_lend(
+                connection,
+                0, /* AppendPanicText */
+                &request.0,
+                0,
+                s.len(),
+            )
+            .ok();
+        }
+        Ok(s.len())
+    }
+
+    // Tests show that this does not seem to be reliably called at the end of a panic
+    // print, so, we can't rely on this to e.g. trigger a graphics update.
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+pub fn panic_output() -> Option<impl io::Write> {
+    PANIC_WRITER.with(|pwr| {
+        if pwr.borrow().is_none() {
+            // Generally this won't fail because every server has already allocated this connection.
+            let conn = crate::os::xous::services::log_server();
+
+            // This is possibly fallible in the case that the connection table is full,
+            // and we can't make the connection to the graphics server. Most servers do not already
+            // have this connection.
+            let gfx_conn = crate::os::xous::services::try_connect("panic-to-screen!");
+
+            let pw = PanicWriter { conn, gfx_conn };
+
+            // Send the "We're panicking" message (1000).
+            crate::os::xous::ffi::scalar(conn, [1000 /* BeginPanic */, 0, 0, 0, 0]).ok();
+            *pwr.borrow_mut() = Some(pw);
+        }
+        *pwr.borrow()
+    })
 }