diff --git a/Cargo.toml b/Cargo.toml index 8d79e4db4..23d88ecfd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,7 @@ members = [ "services/fcc-agent", "services/xous-names", "services/keyboard", + "services/kernel-test", "services/trng", "services/gam", "services/benchmark", diff --git a/services/kernel-test/Cargo.toml b/services/kernel-test/Cargo.toml new file mode 100644 index 000000000..743b522e3 --- /dev/null +++ b/services/kernel-test/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "kernel-test" +version = "0.1.0" +authors = ["Sean Cross "] +edition = "2018" +description = "Program to test various aspects of the kernel" + +[dependencies] +xous = { path = "../../xous-rs" } + +[target.'cfg(not(any(windows,unix)))'.dependencies] +utralib = { path = "../../utralib"} + +[features] +logging = [] # adding this allocates the UART for logging of Xous +default = ["logging"] diff --git a/services/kernel-test/README.md b/services/kernel-test/README.md new file mode 100644 index 000000000..f1d1ca67f --- /dev/null +++ b/services/kernel-test/README.md @@ -0,0 +1,5 @@ +# Kernel Test + +Run various tests inside the kernel. + +This is supposed to be the only program running. diff --git a/services/kernel-test/build.rs b/services/kernel-test/build.rs new file mode 100644 index 000000000..43c3deb4f --- /dev/null +++ b/services/kernel-test/build.rs @@ -0,0 +1,17 @@ +// NOTE: Adapted from cortex-m/build.rs +use std::env; + +fn main() { + let target = env::var("TARGET").unwrap(); + + let target_os = target.split('-').nth(2).unwrap_or("none"); + + // If we're not running on a desktop-class operating system, emit the "baremetal" + // config setting. This will enable software to do tasks such as + // managing memory. + if target_os == "none" { + println!("cargo:rustc-cfg=baremetal"); + } + + println!("cargo:rerun-if-changed=build.rs"); +} diff --git a/services/kernel-test/src/debug.rs b/services/kernel-test/src/debug.rs new file mode 100644 index 000000000..b215ab28f --- /dev/null +++ b/services/kernel-test/src/debug.rs @@ -0,0 +1,111 @@ +use core::fmt::{Error, Write}; + +use utralib::generated::*; + +#[macro_export] +macro_rules! print +{ + ($($args:tt)+) => ({ + use core::fmt::Write; + let _ = write!(crate::debug::Uart {}, $($args)+); + }); +} +#[macro_export] +macro_rules! println +{ + () => ({ + print!("\r\n") + }); + ($fmt:expr) => ({ + print!(concat!($fmt, "\r\n")) + }); + ($fmt:expr, $($args:tt)+) => ({ + print!(concat!($fmt, "\r\n"), $($args)+) + }); +} + +fn handle_irq(irq_no: usize, arg: *mut usize) { + print!("Handling IRQ {} (arg: {:08x}): ", irq_no, arg as usize); + + while let Some(c) = { crate::debug::Uart {} }.getc() { + print!("{}", c as char); + } + println!(); +} + +pub struct Uart {} + +// this is a hack to bypass an explicit initialization/allocation step for the debug structure +pub static mut DEFAULT_UART_ADDR: *mut usize = 0x0000_0000 as *mut usize; + +pub const DEFAULT: Uart = Uart {}; + +impl Uart { + fn map_uart(&self) { + /* + Note: the memory address and interrupt specified here needs to map to a unique hardware + UART resource. Modify in this function as necessary. + */ + let uart = xous::syscall::map_memory( + xous::MemoryAddress::new(utra::console::HW_CONSOLE_BASE), + None, + 4096, + xous::MemoryFlags::R | xous::MemoryFlags::W, + ) + .expect("couldn't map debug uart"); + unsafe { + DEFAULT_UART_ADDR = uart.as_mut_ptr() as _; + } + println!("Mapped UART @ {:08x}", uart.addr.get()); + // core::mem::forget(uart); + + println!("Allocating IRQ..."); + xous::claim_interrupt( + utra::console::CONSOLE_IRQ, + handle_irq, + core::ptr::null_mut::(), + ) + .expect("unable to allocate IRQ"); + self.enable_rx(); + } + + pub fn putc(&self, c: u8) { + if unsafe { DEFAULT_UART_ADDR } as usize == 0 { + self.map_uart(); + } + let mut uart_csr = CSR::new(unsafe { DEFAULT_UART_ADDR as *mut u32 }); + + // Wait until TXFULL is `0` + while uart_csr.r(utra::uart::TXFULL) != 0 {} + uart_csr.wo(utra::uart::RXTX, c as u32); + } + + pub fn enable_rx(&self) { + let mut uart_csr = CSR::new(unsafe { DEFAULT_UART_ADDR as *mut u32 }); + uart_csr.rmwf(utra::uart::EV_ENABLE_RX, 1); + } + + pub fn getc(&self) -> Option { + if unsafe { DEFAULT_UART_ADDR } as usize == 0 { + self.map_uart(); + } + let mut uart_csr = CSR::new(unsafe { DEFAULT_UART_ADDR as *mut u32 }); + match uart_csr.rf(utra::uart::EV_PENDING_RX) { + 0 => None, + ack => { + let c = Some(uart_csr.rf(utra::uart::RXTX_RXTX) as u8); + uart_csr.wfo(utra::uart::EV_PENDING_RX, ack); + c + } + } + } +} + +impl Write for Uart { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + for c in s.bytes() { + self.putc(c); + } + Ok(()) + } +} diff --git a/services/kernel-test/src/log_string.rs b/services/kernel-test/src/log_string.rs new file mode 100644 index 000000000..53c07ffda --- /dev/null +++ b/services/kernel-test/src/log_string.rs @@ -0,0 +1,57 @@ +use core::fmt; +use core::slice; + +pub struct LogString<'a> { + raw_slice: &'a mut [u8], + pub s: &'a str, + pub len: u32, + msg_len: &'a mut Option, +} + +impl<'a> LogString<'a> { + pub fn from_message(message: &'a mut xous::MemoryMessage) -> LogString<'a> { + // println!("LOG: Message address is at {:08x} (whole message: {:?})", message.buf.addr.get(), message); + let raw_slice = unsafe { slice::from_raw_parts_mut(message.buf.as_ptr() as *mut u8, message.buf.len() as usize) }; + let starting_length = message.valid.map(|x| x.get()).unwrap_or(0); + + // print!("LOG: String @ {:08x}:", message.buf.as_ptr() as usize); + // for offset in 0..starting_length { + // print!(" {:02x}", raw_slice[offset]); + // } + // println!(" (length: {})", starting_length); + + LogString { + s: unsafe { + core::str::from_utf8_unchecked(slice::from_raw_parts( + message.buf.as_ptr() as *mut u8, + starting_length, + )) + }, + len: starting_length as u32, + raw_slice, + msg_len: &mut message.valid, + } + } +} + +impl<'a> fmt::Display for LogString<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.s) + } +} + +impl<'a> fmt::Write for LogString<'a> { + fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> { + for c in s.bytes() { + if self.len as usize < self.raw_slice.len() { + self.raw_slice[self.len as usize] = c; + self.len += 1; + } + } + self.s = unsafe { + core::str::from_utf8_unchecked(slice::from_raw_parts(self.raw_slice.as_ptr(), self.len as usize)) + }; + *self.msg_len = Some(xous::MemorySize::new(self.len as usize).unwrap()); + Ok(()) + } +} diff --git a/services/kernel-test/src/main.rs b/services/kernel-test/src/main.rs new file mode 100644 index 000000000..b8242d049 --- /dev/null +++ b/services/kernel-test/src/main.rs @@ -0,0 +1,336 @@ +#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(target_os = "none", no_main)] + +#[cfg(baremetal)] +#[macro_use] +mod debug; + +use core::fmt::Write; +use xous::String; + +#[cfg(not(target_os = "none"))] +mod implementation { + use core::fmt::{Error, Write}; + use std::sync::mpsc::{channel, Receiver, Sender}; + + enum ControlMessage { + Text(String), + Byte(u8), + Exit, + } + + pub struct Output { + tx: Sender, + rx: Receiver, + stdout: std::io::Stdout, + } + + pub fn init() -> Output { + let (tx, rx) = channel(); + + Output { + tx, + rx, + stdout: std::io::stdout(), + } + } + + impl Output { + pub fn run(&mut self) { + use std::io::Write; + loop { + match self.rx.recv_timeout(std::time::Duration::from_millis(50)) { + Ok(msg) => match msg { + ControlMessage::Exit => break, + ControlMessage::Text(s) => print!("{}", s), + ControlMessage::Byte(s) => { + let mut handle = self.stdout.lock(); + handle.write_all(&[s]).unwrap(); + } + }, + Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {} + Err(e) => panic!("Error: {}", e), + } + } + } + + pub fn get_writer(&self) -> OutputWriter { + OutputWriter { + tx: self.tx.clone(), + } + } + } + + impl Drop for Output { + fn drop(&mut self) { + self.tx.send(ControlMessage::Exit).unwrap(); + } + } + + impl Write for Output { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + // It would be nice if this worked with &str + self.tx.send(ControlMessage::Text(s.to_owned())).unwrap(); + Ok(()) + } + } + + pub struct OutputWriter { + tx: Sender, + } + + impl OutputWriter { + pub fn putc(&self, c: u8) { + self.tx.send(ControlMessage::Byte(c)).unwrap(); + } + } + + impl Write for OutputWriter { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + // It would be nice if this worked with &str + self.tx.send(ControlMessage::Text(s.to_owned())).unwrap(); + Ok(()) + } + } +} + +#[cfg(target_os = "none")] +mod implementation { + use core::fmt::{Error, Write}; + use utralib::generated::*; + + pub struct Output {} + + pub fn init() -> Output { + if cfg!(feature = "logging") { + let uart = xous::syscall::map_memory( + xous::MemoryAddress::new(utra::console::HW_CONSOLE_BASE), + None, + 4096, + xous::MemoryFlags::R | xous::MemoryFlags::W, + ) + .expect("couldn't map serial port"); + unsafe { crate::debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() as _ }; + println!("Mapped UART @ {:08x}", uart.addr.get()); + + println!("Process: map success!"); + 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"); + println!("Claimed IRQ {}", utra::console::CONSOLE_IRQ); + } + Output {} + } + + impl Output { + pub fn get_writer(&self) -> OutputWriter { + OutputWriter {} + } + + pub fn run(&mut self) { + loop { + xous::wait_event(); + } + } + } + + fn handle_irq(irq_no: usize, arg: *mut usize) { + if cfg!(feature = "logging") { + print!("Handling IRQ {} (arg: {:08x}): ", irq_no, arg as usize); + + while let Some(c) = crate::debug::DEFAULT.getc() { + print!("0x{:02x}", c); + } + println!(); + } + } + + pub struct OutputWriter {} + + impl OutputWriter { + pub fn putc(&self, c: u8) { + if cfg!(feature = "logging") { + 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 {} + uart_csr.wo(utra::uart::RXTX, c as u32); + } + } + } + + impl Write for OutputWriter { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + for c in s.bytes() { + self.putc(c); + if c == '\n' as u8 { + self.putc('\r' as u8); + } + } + Ok(()) + } + } +} + +fn handle_scalar( + output: &mut implementation::OutputWriter, + sender: xous::MessageSender, + msg: &xous::ScalarMessage, + sender_pid: xous::PID, +) { + match msg.id { + 1000 => writeln!(output, "PANIC from PID {} | {}", sender_pid, sender).unwrap(), + 1100 => (), + 1101..=1132 => { + let mut output_bfr = [0u8; core::mem::size_of::() * 4]; + let output_iter = output_bfr.iter_mut(); + + // Combine the four arguments to form a single + // contiguous buffer. Note: The buffer size will change + // depending on the platfor's `usize` length. + let arg1_bytes = msg.arg1.to_le_bytes(); + let arg2_bytes = msg.arg2.to_le_bytes(); + let arg3_bytes = msg.arg3.to_le_bytes(); + let arg4_bytes = msg.arg4.to_le_bytes(); + let input_iter = arg1_bytes + .iter() + .chain(arg2_bytes.iter()) + .chain(arg3_bytes.iter()) + .chain(arg4_bytes.iter()); + for (dest, src) in output_iter.zip(input_iter) { + *dest = *src; + } + let total_chars = msg.id - 1100; + for (idx, c) in output_bfr.iter().enumerate() { + if idx >= total_chars { + break; + } + output.putc(*c); + } + } + 1200 => writeln!(output, "Terminating process").unwrap(), + _ => writeln!( + output, + "Unrecognized scalar message from {}: {:#?}", + sender, msg + ) + .unwrap(), + } +} + +fn reader_thread(mut output: implementation::OutputWriter) { + writeln!(output, "LOG: Xous Logging Server starting up...").unwrap(); + + writeln!(output, "LOG: ****************************************************************").unwrap(); + // time stamp isn't actually the time stamp of the build, unfortunately. It's the time stamp of the + // last time you managed to force a rebuild that also causes log-server to be rebuilt, not necessarily + // capturing the build time of the very most recent change! + // writeln!(output, "LOG: *** Built: {:49} ***", env!("VERGEN_BUILD_TIMESTAMP")).unwrap(); + writeln!(output, "LOG: ****************************************************************").unwrap(); + let server_addr = xous::create_server_with_address(b"xous-log-server ").unwrap(); + writeln!(output, "LOG: Server listening on address {:?}", server_addr).unwrap(); + + let mut counter: usize = 0; + loop { + if counter.trailing_zeros() >= 12 { + writeln!(output, "LOG: Counter tick: {}", counter).unwrap(); + } + counter += 1; + // writeln!(output, "LOG: Waiting for an event...").unwrap(); + let mut envelope = + xous::syscall::receive_message(server_addr).expect("couldn't get address"); + 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::BlockingScalar(msg) => { + writeln!( + output, + "LOG: BlockingScalar message from {}: {:?}", + envelope.sender, msg + ) + .unwrap(); + } + xous::Message::Move(msg) => { + String::<4000>::from_message(msg) + .map(|log_entry: String<4000>| { + 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) => { + 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::MutableBorrow(msg) => { + String::<4000>::from_message(msg) + .map(|mut log_entry: String<4000>| { + 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(); + } + } + } +} + +fn writer_thread(_ignored: usize) { + let mut counter = 0; + loop { + let conn = xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap()).unwrap(); + let mut buffer = xous::String::<4000>::new(); + write!(buffer, "Hello, myself! Loop: {}", counter).unwrap(); + buffer.lend(conn).unwrap(); + + counter += 1; + } +} + +#[xous::xous_main] +fn test_main() -> ! { + let mut output = implementation::init(); + let writer = output.get_writer(); + println!("LOG: my PID is {}", xous::process::id()); + println!("LOG: Creating the reader thread"); + xous::create_thread_simple(reader_thread, writer).unwrap(); + xous::create_thread_simple(writer_thread, 0usize).unwrap(); + println!("LOG: Running the output"); + output.run(); + loop {} +} diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 40eae4b8f..b167bdb3b 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -73,6 +73,7 @@ fn try_main() -> Result<(), DynError> { let task = env::args().nth(1); match task.as_deref() { Some("renode-image") => renode_image(false, &hw_pkgs)?, + Some("renode-test") => renode_image(false, &["kernel-test"])?, Some("renode-image-debug") => renode_image(true, &hw_pkgs)?, Some("run") => run(false)?, Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs)?, @@ -87,7 +88,8 @@ fn try_main() -> Result<(), DynError> { fn print_help() { eprintln!( "Tasks: -renode-image builds a test image for renode +renode-image builds a functional image for renode +renode-test builds a test image for renode renode-image-debug builds a test image for renode in debug mode hw-image [soc.svd] builds an image for real hardware run runs a release build using a hosted environment