From 7210f100f4ab50bddbe32c753d65a06edfc42acc Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 2 Apr 2021 01:54:17 +0800 Subject: [PATCH] upgrade log server to pass rich message types --- Cargo.lock | 1 + services/log-server/Cargo.toml | 1 + services/log-server/src/api.rs | 8 ++++++ services/log-server/src/lib.rs | 29 +++++++++++++++------- services/log-server/src/main.rs | 44 ++++++++++++++++++++++++--------- xous-ipc/src/buffer.rs | 19 ++++++++++++++ 6 files changed, 81 insertions(+), 21 deletions(-) create mode 100644 services/log-server/src/api.rs diff --git a/Cargo.lock b/Cargo.lock index f35d9617b..a02d0acfa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -687,6 +687,7 @@ name = "log-server" version = "0.1.0" dependencies = [ "log", + "rkyv 0.4.3", "utralib", "vergen", "xous", diff --git a/services/log-server/Cargo.toml b/services/log-server/Cargo.toml index f5b2f784c..a7bf66f87 100644 --- a/services/log-server/Cargo.toml +++ b/services/log-server/Cargo.toml @@ -9,6 +9,7 @@ version = "0.1.0" log = "0.4" xous = {path = "../../xous-rs"} xous-ipc = {path = "../../xous-ipc"} +rkyv = {version = "0.4.3", features = ["const_generics"], default-features = false} [build-dependencies] vergen = "3" diff --git a/services/log-server/src/api.rs b/services/log-server/src/api.rs new file mode 100644 index 000000000..70da90221 --- /dev/null +++ b/services/log-server/src/api.rs @@ -0,0 +1,8 @@ +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +pub struct LogRecord { + pub file: xous_ipc::String<128>, + pub line: Option, + pub module: xous_ipc::String<128>, + pub level: u32, + pub args: xous_ipc::String<2800>, +} diff --git a/services/log-server/src/lib.rs b/services/log-server/src/lib.rs index 8a52757af..116a6f0cb 100644 --- a/services/log-server/src/lib.rs +++ b/services/log-server/src/lib.rs @@ -1,7 +1,9 @@ #![cfg_attr(target_os = "none", no_std)] use core::fmt::Write; use core::sync::atomic::{AtomicBool, Ordering}; -use xous_ipc::String; +use xous_ipc::{String, Buffer}; + +pub mod api; static XOUS_LOGGER: XousLogger = XousLogger { locked: AtomicBool::new(false), @@ -17,19 +19,19 @@ static mut XOUS_LOGGER_BACKING: XousLoggerBacking = XousLoggerBacking { buffer: None, }; -struct XousLoggerBacking { +struct XousLoggerBacking<'a> { conn: xous::CID, - buffer: Option>, // why 4000? tests non-power of 2 sizes in rkyv APIs. Could make it 4096 as well... + buffer: Option>, initialized: bool, } -impl XousLoggerBacking { +impl XousLoggerBacking<'_> { fn init(&mut self) -> Result<(), xous::Error> { if self.initialized { return Ok(()); } self.conn = xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap())?; - self.buffer = Some(String::<4000>::new()); + self.buffer = Some(Buffer::new(4000)); // why 4000? tests non-power of 2 sizes in rkyv APIs. Could make it 4096 as well... self.initialized = true; Ok(()) } @@ -38,10 +40,19 @@ impl XousLoggerBacking { if !self.initialized && self.init().is_err() { return; } - if let Some(ref mut buf) = self.buffer { - buf.clear(); - write!(buf, "{} - {}", record.level(), record.args()).unwrap(); - buf.lend(self.conn).unwrap(); + let mut args = String::<2800>::new(); + write!(args, "{}", record.args()).unwrap(); + let lr = api::LogRecord { + file: String::from_str(record.file().unwrap_or("")), + line: record.line(), + module: String::from_str(record.module_path().unwrap_or("")), + level: record.level() as u32, + args, + }; + + if let Some(buf) = self.buffer.as_mut() { + buf.rewrite(lr).unwrap(); + buf.lend(self.conn, 0).unwrap(); // there is only one type of buffer we should be sending! } } } diff --git a/services/log-server/src/main.rs b/services/log-server/src/main.rs index 37e05c1fd..d4d55c812 100644 --- a/services/log-server/src/main.rs +++ b/services/log-server/src/main.rs @@ -1,6 +1,9 @@ #![cfg_attr(target_os = "none", no_std)] #![cfg_attr(target_os = "none", no_main)] +mod api; +use api::*; + #[cfg(baremetal)] #[macro_use] mod debug; @@ -250,7 +253,8 @@ fn reader_thread(arg: usize) { let sender = envelope.sender; // writeln!(output, "LOG: Got message envelope: {:?}", envelope).unwrap(); match &mut envelope.body { - xous::Message::Scalar(msg) => handle_scalar(&mut output, sender, msg, envelope.sender.pid().unwrap()), + xous::Message::Scalar(msg) => + handle_scalar(&mut output, sender, msg, envelope.sender.pid().unwrap()), xous::Message::BlockingScalar(msg) => { writeln!( output, @@ -274,17 +278,33 @@ fn reader_thread(arg: usize) { }) .ok(); } - xous::Message::Borrow(msg) => { - String::<4000>::from_message(msg) - .map(|log_entry: String<4000>| writeln!(output, "{}", log_entry).unwrap()) - .or_else(|e| { - writeln!( - output, - "LOG: unable to convert Borrow message to str: {}", - e - ) - }) - .ok(); + xous::Message::Borrow(_msg) => { + let mem = envelope.body.memory_message().unwrap(); + let buffer = unsafe { xous_ipc::Buffer::from_memory_message(mem) }; + let lr: LogRecord = buffer.to_original::().unwrap(); + let level = + if log::Level::Error as u32 == lr.level { + "ERR " } + else if log::Level::Warn as u32 == lr.level { + "WARN" } + else if log::Level::Info as u32 == lr.level { + "INFO" } + else if log::Level::Debug as u32 == lr.level { + "DBG " } + else if log::Level::Trace as u32 == lr.level { + "TRCE" } + else { + "UNKNOWN" + }; + if let Some(line)= lr.line { + writeln!(output, "{}:{}: {} ({}:{})", + level, lr.module, lr.args, lr.file, line + ).unwrap(); + } else { + writeln!(output, "{}:{}: {} ({})", + level, lr.module, lr.args, lr.file + ).unwrap(); + } } xous::Message::MutableBorrow(msg) => { String::<4000>::from_message(msg) diff --git a/xous-ipc/src/buffer.rs b/xous-ipc/src/buffer.rs index 5b41e5cb4..e8e62259f 100644 --- a/xous-ipc/src/buffer.rs +++ b/xous-ipc/src/buffer.rs @@ -141,6 +141,25 @@ impl<'a> Buffer<'a> { Ok(buf) } + // 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(()) + } + #[allow(dead_code)] pub fn replace(&mut self, src: S) -> core::result::Result<(), &'static str> where