From e18219b07864d629e57433109a1204c335029864 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Fri, 30 Oct 2020 21:26:19 +0800 Subject: [PATCH] log-server: add first draft of logging server This server implements `log`, and comes with a `lib` that allows for setting up logging. Signed-off-by: Sean Cross --- services/log-server/Cargo.toml | 1 + services/log-server/src/lib.rs | 86 ++++++++++++++++++++++++++ services/log-server/src/main.rs | 103 +++++++++++++++++++++----------- 3 files changed, 155 insertions(+), 35 deletions(-) create mode 100644 services/log-server/src/lib.rs diff --git a/services/log-server/Cargo.toml b/services/log-server/Cargo.toml index 03d46be37..8882815c7 100644 --- a/services/log-server/Cargo.toml +++ b/services/log-server/Cargo.toml @@ -7,6 +7,7 @@ description = "Log output program" [dependencies] xous = { path = "../../xous-rs" } +log = "0.4" [target.'cfg(not(any(windows,unix)))'.dependencies] utralib = { path = "../../utralib"} diff --git a/services/log-server/src/lib.rs b/services/log-server/src/lib.rs new file mode 100644 index 000000000..829e13986 --- /dev/null +++ b/services/log-server/src/lib.rs @@ -0,0 +1,86 @@ +#![cfg_attr(target_os = "none", no_std)] +use core::fmt::Write; +use core::sync::atomic::{AtomicBool, Ordering}; +use xous::String; + +static XOUS_LOGGER: XousLogger = XousLogger { + locked: AtomicBool::new(false), +}; + +struct XousLogger { + locked: AtomicBool, +} + +static mut XOUS_LOGGER_BACKING: XousLoggerBacking = XousLoggerBacking { + conn: 0, + initialized: false, + buffer: None, +}; + +struct XousLoggerBacking { + conn: xous::CID, + buffer: Option>, + initialized: bool, +} + +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::new(4096)); + self.initialized = true; + Ok(()) + } + + fn log_impl(&mut self, record: &log::Record) { + 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, 1).unwrap(); + } + } +} + +impl log::Log for XousLogger { + fn enabled(&self, _metadata: &log::Metadata) -> bool { + true + } + + fn log(&self, record: &log::Record) { + while self + .locked + .compare_exchange(false, true, Ordering::SeqCst, Ordering::Acquire) + .is_err() + { + xous::yield_slice(); + } + + unsafe { XOUS_LOGGER_BACKING.log_impl(record) }; + self.locked + .compare_exchange(true, false, Ordering::SeqCst, Ordering::Acquire) + .expect("LOG: logger became unlocked somehow"); + } + fn flush(&self) {} +} + +pub fn init() -> Result<(), log::SetLoggerError> { + log::set_logger(&XOUS_LOGGER)?; + log::set_max_level(log::LevelFilter::Info); + Ok(()) +} + +pub fn init_wait() -> Result<(), log::SetLoggerError> { + log::set_logger(&XOUS_LOGGER)?; + log::set_max_level(log::LevelFilter::Info); + unsafe { + while XOUS_LOGGER_BACKING.init().is_err() { + xous::yield_slice(); + } + } + Ok(()) +} diff --git a/services/log-server/src/main.rs b/services/log-server/src/main.rs index eb3bb77b6..8ef039f36 100644 --- a/services/log-server/src/main.rs +++ b/services/log-server/src/main.rs @@ -5,10 +5,8 @@ #[macro_use] mod debug; -mod log_string; - use core::fmt::Write; -use log_string::LogString; +use xous::String; #[cfg(not(target_os = "none"))] mod implementation { @@ -119,8 +117,12 @@ mod implementation { crate::debug::DEFAULT.enable_rx(); println!("Allocating IRQ..."); - xous::syscall::claim_interrupt(utra::console::CONSOLE_IRQ, handle_irq, core::ptr::null_mut::()) - .expect("couldn't claim interrupt"); + xous::syscall::claim_interrupt( + utra::console::CONSOLE_IRQ, + handle_irq, + core::ptr::null_mut::(), + ) + .expect("couldn't claim interrupt"); println!("Claimed IRQ {}", utra::console::CONSOLE_IRQ); Output { // addr: uart.as_mut_ptr() as usize, @@ -129,7 +131,7 @@ mod implementation { impl Output { pub fn get_writer(&self) -> OutputWriter { - OutputWriter { } + OutputWriter {} } pub fn run(&mut self) { @@ -172,12 +174,11 @@ mod implementation { println!(); } - pub struct OutputWriter { - } + pub struct OutputWriter {} impl OutputWriter { pub fn putc(&self, c: u8) { - let mut uart_csr = CSR::new(unsafe{ crate::debug::DEFAULT_UART_ADDR as *mut u32}); + let mut uart_csr = CSR::new(unsafe { crate::debug::DEFAULT_UART_ADDR as *mut u32 }); // Wait until TXFULL is `0` while uart_csr.r(utra::uart::TXFULL) != 0 {} @@ -211,44 +212,76 @@ fn reader_thread(mut output: implementation::OutputWriter) { writeln!(output, "LOG: Counter tick: {}", counter).unwrap(); } counter += 1; - writeln!(output, "LOG: Waiting for an event...").unwrap(); + // writeln!(output, "LOG: Waiting for an event...").unwrap(); let mut envelope = xous::syscall::receive_message(server_addr).expect("couldn't get address"); - writeln!(output, "LOG: Got message envelope: {:?}", envelope).unwrap(); + let sender = envelope.sender; + // writeln!(output, "LOG: Got message envelope: {:?}", envelope).unwrap(); match &mut envelope.body { xous::Message::Scalar(msg) => { - writeln!(output, "LOG: Scalar message from {}: {:?}", envelope.sender, msg).unwrap(); + writeln!( + output, + "LOG: Scalar message from {}: {:?}", + envelope.sender, msg + ) + .unwrap(); } xous::Message::BlockingScalar(msg) => { - writeln!(output, "LOG: BlockingScalar message from {}: {:?}", envelope.sender, msg).unwrap(); + writeln!( + output, + "LOG: BlockingScalar message from {}: {:?}", + envelope.sender, msg + ) + .unwrap(); } xous::Message::Move(msg) => { - let log_entry = LogString::from_message(msg); - writeln!( - output, - "LOG: Moved log message from {}: {}", - envelope.sender, log_entry - ) - .unwrap(); + String::from_message(msg) + .map(|log_entry| { + writeln!( + output, + "LOG: Moved log message from {}: {}", + sender, log_entry + ) + .unwrap() + }) + .or_else(|e| { + writeln!(output, "LOG: unable to convert Move message to str: {}", e) + }) + .ok(); } xous::Message::Borrow(msg) => { - let log_entry = LogString::from_message(msg); - writeln!( - output, - "LOG: Immutably borrowed log message from {}: {}", - envelope.sender, log_entry - ) - .unwrap(); + String::from_message(msg) + .map(|log_entry| writeln!(output, "{}", log_entry).unwrap()) + .or_else(|e| { + writeln!( + output, + "LOG: unable to convert Borrow message to str: {}", + e + ) + }) + .ok(); } xous::Message::MutableBorrow(msg) => { - let mut log_entry = LogString::from_message(msg); - writeln!( - output, - "LOG: Mutable borrowed log message from {} len {}:\n\r {}\n\r", - envelope.sender, log_entry.len, log_entry.s, - ) - .unwrap(); - writeln!(log_entry, " << HELLO FROM THE SERVER").unwrap(); + String::from_message(msg) + .map(|mut log_entry| { + writeln!( + output, + "LOG: Mutable borrowed log message from {} len {}:\n\r {}\n\r", + sender, + log_entry.len(), + log_entry, + ) + .unwrap(); + writeln!(log_entry, " << HELLO FROM THE SERVER").unwrap(); + }) + .or_else(|e| { + writeln!( + output, + "LOG: unable to convert MutableBorrow message to str: {}", + e + ) + }) + .ok(); } } }