xous-rs: log panics to log-server

When a process panics, log the contents of the panic to the log server.

This removes the dependency on a `println!()` implementation needing to
be defined in a project.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-11-27 13:51:05 +08:00
parent 8e2faddd2f
commit 322051e8c1

View file

@ -12,14 +12,14 @@ pub mod arch;
pub mod carton;
pub mod definitions;
mod messages;
pub mod syscall;
pub mod string;
pub mod syscall;
pub use arch::{ProcessArgs, ProcessInit, ProcessKey, ThreadInit};
pub use definitions::*;
pub use messages::*;
pub use syscall::*;
pub use string::*;
pub use syscall::*;
#[cfg(not(target_os = "none"))]
pub use arch::ProcessArgsAsThread;
@ -70,10 +70,83 @@ macro_rules! maybe_main {
#[panic_handler]
fn handle_panic(arg: &PanicInfo) -> ! {
println!("PANIC!");
println!("Details: {:?}", arg);
xous::syscall::wait_event();
xous::syscall::terminate_process();
use core::fmt::Write;
use xous::{
terminate_process, try_connect, try_send_message, wait_event, Message,
ScalarMessage, CID, SID,
};
// Try to connect to the log server. If this fails, we won't be able to print
// anything anyway.
// We use `try_connect()` here because we want this to work even during an interrupt handler.
// If we've already connected to the log server, then the kernel will reuse the
// connection number.
if let Ok(conn) = try_connect(SID::from_bytes(b"xous-log-server ").unwrap()) {
struct PanicWriter {
conn: CID,
}
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>()];
for i in 0..core::mem::size_of::<usize>() {
out_array[i] = if i + start < data.len() {
data[start + i]
} else {
0
};
}
usize::from_le_bytes(out_array)
}
}
impl core::fmt::Write for PanicWriter {
fn write_str(&mut self, s: &str) -> core::result::Result<(), core::fmt::Error> {
for c in s.as_bytes().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.
let mut panic_msg = ScalarMessage {
id: 1100 + c.len(),
arg1: Self::group_or_null(&c, 0),
arg2: Self::group_or_null(&c, 1),
arg3: Self::group_or_null(&c, 2),
arg4: Self::group_or_null(&c, 3),
};
try_send_message(self.conn, Message::Scalar(panic_msg)).ok();
}
Ok(())
}
}
let mut pw = PanicWriter { conn };
// Send the "We're panicking" message (1000).
let panic_start_msg = ScalarMessage {
id: 1000,
arg1: 0,
arg2: 0,
arg3: 0,
arg4: 0,
};
try_send_message(conn, Message::Scalar(panic_start_msg)).ok();
// Send the contents of the panic.
writeln!(&mut pw, "{}", arg).ok();
// Send the "We're done panicking now it's time to quit" message (1200)
let panic_start_msg = ScalarMessage {
id: 1200,
arg1: 0,
arg2: 0,
arg3: 0,
arg4: 0,
};
try_send_message(conn, Message::Scalar(panic_start_msg)).ok();
}
wait_event();
terminate_process();
loop {}
}