services: add kernel-test

This was used to demonstrate the message passing bug.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2021-03-03 21:22:26 +08:00
parent 83da8c4e7d
commit 0c6cb9135e
8 changed files with 546 additions and 1 deletions

View file

@ -14,6 +14,7 @@ members = [
"services/fcc-agent",
"services/xous-names",
"services/keyboard",
"services/kernel-test",
"services/trng",
"services/gam",
"services/benchmark",

View file

@ -0,0 +1,16 @@
[package]
name = "kernel-test"
version = "0.1.0"
authors = ["Sean Cross <sean@xobs.io>"]
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"]

View file

@ -0,0 +1,5 @@
# Kernel Test
Run various tests inside the kernel.
This is supposed to be the only program running.

View file

@ -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");
}

View file

@ -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::<usize>(),
)
.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<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 });
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(())
}
}

View file

@ -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<xous::MemorySize>,
}
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(())
}
}

View file

@ -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<ControlMessage>,
rx: Receiver<ControlMessage>,
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<ControlMessage>,
}
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::<usize>(),
)
.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::<usize>() * 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 {}
}

View file

@ -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