From 6efc6bdfd537f80883381fbfb6ac06b1850f3d51 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Thu, 25 Mar 2021 16:01:57 +0800 Subject: [PATCH] services: kernel-test: add loopback test Signed-off-by: Sean Cross --- services/kernel-test/src/debug.rs | 111 ------------------------- services/kernel-test/src/log_string.rs | 57 ------------- services/kernel-test/src/main.rs | 71 +++++++++++----- 3 files changed, 49 insertions(+), 190 deletions(-) delete mode 100644 services/kernel-test/src/debug.rs delete mode 100644 services/kernel-test/src/log_string.rs diff --git a/services/kernel-test/src/debug.rs b/services/kernel-test/src/debug.rs deleted file mode 100644 index b215ab28f..000000000 --- a/services/kernel-test/src/debug.rs +++ /dev/null @@ -1,111 +0,0 @@ -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 deleted file mode 100644 index 53c07ffda..000000000 --- a/services/kernel-test/src/log_string.rs +++ /dev/null @@ -1,57 +0,0 @@ -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 index b274b95d1..f2f325717 100644 --- a/services/kernel-test/src/main.rs +++ b/services/kernel-test/src/main.rs @@ -3,12 +3,18 @@ const EXTRA_KEY: usize = 42; -fn sleep_loop_4(sleep_ms: usize, conn: usize, pid: usize, extra: usize) { +fn sleep_loop_4(main_conn: usize, sleep_ms: usize, ticktimer_conn: usize, pid: usize) { let tid = xous::current_tid().unwrap(); - let conn = conn as _; + let ticktimer_conn = ticktimer_conn as _; // let pid = xous::current_pid().unwrap().get(); - log::info!("My thread number is {}, sleeping 0x{:08x} ({}) ms and EXTRA: {}", tid, sleep_ms, sleep_ms, extra); - assert_eq!(extra, EXTRA_KEY, "extra key in arg 4 didn't match -- was {}, not {}", extra, EXTRA_KEY); + log::info!( + "My thread number is {}, sleeping 0x{:08x} ({}) ms and main_conn: {}", + tid, + sleep_ms, + sleep_ms, + main_conn + ); + let main_conn = main_conn as xous::CID; let mut loop_count = 0; loop { @@ -18,9 +24,9 @@ fn sleep_loop_4(sleep_ms: usize, conn: usize, pid: usize, extra: usize) { // sleep_ms, // loop_count // ); - let start_time = ticktimer_server::elapsed_ms(conn).unwrap(); - ticktimer_server::sleep_ms(conn, sleep_ms).unwrap(); - let end_time = ticktimer_server::elapsed_ms(conn).unwrap(); + let start_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); + ticktimer_server::sleep_ms(ticktimer_conn, sleep_ms).unwrap(); + let end_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); log::info!( "TEST THREAD {}:{}: target {}ms, {} loops: Sleep finished (uptime: {}, took {} ms)", pid, @@ -31,36 +37,56 @@ fn sleep_loop_4(sleep_ms: usize, conn: usize, pid: usize, extra: usize) { end_time - start_time, ); loop_count += 1; + xous::send_message( + main_conn, + xous::Message::Scalar(xous::ScalarMessage::from_usize( + pid as _, + tid as _, + sleep_ms as _, + loop_count as _, + end_time as _, + )), + ).unwrap(); } } -fn sleep_loop_3(sleep_ms: usize, conn: usize, pid: usize) { - sleep_loop_4(sleep_ms, conn, pid, EXTRA_KEY); +fn sleep_loop_3(main_conn: usize, sleep_ms: usize, ticktimer_conn: usize) { + sleep_loop_4( + main_conn, + sleep_ms, + ticktimer_conn, + xous::current_pid().unwrap().get() as _, + ); } -fn sleep_loop_2(sleep_ms: usize, conn: usize) { - sleep_loop_3(sleep_ms, conn, xous::current_pid().unwrap().get() as _); -} - -fn sleep_loop_1(sleep_ms: usize) { +fn sleep_loop_2(main_conn: usize, sleep_ms: usize) { let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap(); - let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap(); - sleep_loop_2(sleep_ms, ticktimer_conn as _); + let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap() as usize; + sleep_loop_3(main_conn, sleep_ms, ticktimer_conn); } +fn sleep_loop_1(main_conn: usize) { + let sleep_ms = + (xous::current_pid().unwrap().get() as usize) * (xous::current_tid().unwrap() as usize); + sleep_loop_2(main_conn, sleep_ms); +} + +static mut MAIN_CONN: xous::CID = 0; fn sleep_loop_0() { - let sleep_ms = (xous::current_pid().unwrap().get() as usize) * (xous::current_tid().unwrap() as usize); - let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap(); - let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap(); - sleep_loop_2(sleep_ms, ticktimer_conn as _); + sleep_loop_1(unsafe { MAIN_CONN } as _); } #[xous::xous_main] fn test_main() -> ! { + log_server::init_wait().unwrap(); + let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap(); let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap(); - log_server::init_wait().unwrap(); + let main_server = xous::create_server().unwrap(); + let server_conn = xous::connect(main_server).unwrap(); + unsafe { MAIN_CONN = server_conn }; + let pid = xous::current_pid().unwrap().get() as usize; xous::create_thread_0(sleep_loop_0).unwrap(); @@ -70,6 +96,7 @@ fn test_main() -> ! { xous::create_thread_4(sleep_loop_4, 180 * pid, ticktimer_conn as _, pid, EXTRA_KEY).unwrap(); loop { - xous::wait_event(); + xous::receive_message(main_server).unwrap(); + log::info!("Received message from remote"); } }