From a9abba0bb06833d02e5a0c14df95430419f2a080 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 5 Nov 2024 19:38:25 +0800 Subject: [PATCH] add a minimal pure terminal based console for baosec target The screen is tiny, so it's not useful for feedback -- all interaction happens on the serial console for this target. Main purpose for this console is debug/test/factory bringup. --- services/bao-console/Cargo.toml | 20 ++ services/bao-console/src/cmds.rs | 218 ++++++++++++++++++++++ services/bao-console/src/cmds/echo.rs | 16 ++ services/bao-console/src/cmds/test.rs | 31 +++ services/bao-console/src/cmds/trng_cmd.rs | 42 +++++ services/bao-console/src/cmds/ver.rs | 40 ++++ services/bao-console/src/main.rs | 18 ++ services/bao-console/src/repl.rs | 94 ++++++++++ services/bao-console/src/shell.rs | 106 +++++++++++ 9 files changed, 585 insertions(+) create mode 100644 services/bao-console/Cargo.toml create mode 100644 services/bao-console/src/cmds.rs create mode 100644 services/bao-console/src/cmds/echo.rs create mode 100644 services/bao-console/src/cmds/test.rs create mode 100644 services/bao-console/src/cmds/trng_cmd.rs create mode 100644 services/bao-console/src/cmds/ver.rs create mode 100644 services/bao-console/src/main.rs create mode 100644 services/bao-console/src/repl.rs create mode 100644 services/bao-console/src/shell.rs diff --git a/services/bao-console/Cargo.toml b/services/bao-console/Cargo.toml new file mode 100644 index 000000000..5aebf891b --- /dev/null +++ b/services/bao-console/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "bao-console" +version = "0.1.0" +edition = "2021" + +[dependencies] +utralib = { version = "0.1.25", optional = true, default-features = false } +xous-names = { package = "xous-api-names", version = "0.9.63" } +ticktimer = { package = "xous-api-ticktimer", version = "0.9.61" } +xous = "0.9.64" +log-server = { package = "xous-api-log", version = "0.1.61" } +log = "0.4.14" +num-derive = { version = "0.3.3", default-features = false } +num-traits = { version = "0.2.14", default-features = false } +cramium-hal = { path = "../../libs/cramium-hal", features = ["std"] } +cram-hal-service = { path = "../cram-hal-service" } + +[features] +cramium-soc = ["utralib/cramium-soc"] +default = [] diff --git a/services/bao-console/src/cmds.rs b/services/bao-console/src/cmds.rs new file mode 100644 index 000000000..6eb78c466 --- /dev/null +++ b/services/bao-console/src/cmds.rs @@ -0,0 +1,218 @@ +use core::fmt::Write; +use std::collections::HashMap; + +use String; +use cram_hal_service::trng; +use xous::MessageEnvelope; + +/////////////////////////// Common items to all commands +pub trait ShellCmdApi<'a> { + // user implemented: + // called to process the command with the remainder of the string attached + fn process(&mut self, args: String, env: &mut CommonEnv) -> Result, xous::Error>; + // called to process incoming messages that may have been origniated by the most recently issued command + fn callback( + &mut self, + msg: &MessageEnvelope, + _env: &mut CommonEnv, + ) -> Result, xous::Error> { + log::info!("received unhandled message {:?}", msg); + Ok(None) + } + + // created with cmd_api! macro + // checks if the command matches the current verb in question + fn matches(&self, verb: &str) -> bool; + // returns my verb + fn verb(&self) -> &'static str; +} +// the argument to this macro is the command verb +macro_rules! cmd_api { + ($verb:expr) => { + fn verb(&self) -> &'static str { stringify!($verb) } + fn matches(&self, verb: &str) -> bool { if verb == stringify!($verb) { true } else { false } } + }; +} + +/////////////////////////// Command shell integration +pub struct CommonEnv { + ticktimer: ticktimer::Ticktimer, + cb_registrations: HashMap, + trng: trng::Trng, + #[allow(dead_code)] + xns: xous_names::XousNames, +} +impl CommonEnv { + #[allow(dead_code)] + pub fn register_handler(&mut self, verb: String) -> u32 { + let mut key: u32; + loop { + key = self.trng.get_u32().unwrap(); + // reserve the bottom 1000 IDs for the main loop enums. + if !self.cb_registrations.contains_key(&key) && (key > 1000) { + break; + } + } + self.cb_registrations.insert(key, verb); + key + } +} + +/* + To add a new command: + 0. ensure that the command implements the ShellCmdApi (above) + 1. mod/use the new command + 2. create an entry for the command's storage in the CmdEnv structure + 3. initialize the persistant storage here + 4. add it to the "commands" array in the dispatch() routine below + + Side note: if your command doesn't require persistent storage, you could, + technically, generate the command dynamically every time it's called. Echo + demonstrates this. +*/ + +///// 1. add your module here, and pull its namespace into the local crate +mod echo; +use echo::*; +mod ver; +use ver::*; +mod test; +use test::*; +mod trng_cmd; +use trng_cmd::*; + +pub struct CmdEnv { + common_env: CommonEnv, + lastverb: String, + ///// 2. declare storage for your command here. + trng_cmd: TrngCmd, +} +impl CmdEnv { + pub fn new(xns: &xous_names::XousNames) -> CmdEnv { + let ticktimer = ticktimer::Ticktimer::new().expect("Couldn't connect to Ticktimer"); + // _ prefix allows us to leave the `mut` here without creating a warning. + // the `mut` option is needed for some features. + let mut _common = CommonEnv { + ticktimer, + cb_registrations: HashMap::new(), + trng: trng::Trng::new(&xns).unwrap(), + xns: xous_names::XousNames::new().unwrap(), + }; + CmdEnv { + common_env: _common, + lastverb: String::new(), + ///// 3. initialize your storage, by calling new() + trng_cmd: { + log::debug!("trng"); + TrngCmd::new() + }, + } + } + + pub fn dispatch( + &mut self, + maybe_cmdline: Option<&mut String>, + maybe_callback: Option<&MessageEnvelope>, + ) -> Result, xous::Error> { + let mut ret = String::new(); + + let mut echo_cmd = Echo {}; // this command has no persistent storage, so we can "create" it every time we call dispatch (but it's a zero-cost absraction so this doesn't actually create any instructions) + let mut ver_cmd = Ver {}; + let mut console_cmd = Test {}; + let commands: &mut [&mut dyn ShellCmdApi] = &mut [ + ///// 4. add your command to this array, so that it can be looked up and dispatched + &mut echo_cmd, + &mut ver_cmd, + &mut self.trng_cmd, + &mut console_cmd, + ]; + + if let Some(cmdline) = maybe_cmdline { + let maybe_verb = tokenize(cmdline); + + let mut cmd_ret: Result, xous::Error> = Ok(None); + if let Some(verb_string) = maybe_verb { + let verb = &verb_string; + + // search through the list of commands linearly until one matches, + // then run it. + let mut match_found = false; + for cmd in commands.iter_mut() { + if cmd.matches(verb) { + match_found = true; + cmd_ret = cmd.process(cmdline.to_string(), &mut self.common_env); + self.lastverb.clear(); + write!(self.lastverb, "{}", verb).expect("SHCH: couldn't record last verb"); + }; + } + + // if none match, create a list of available commands + if !match_found { + let mut first = true; + write!(ret, "Commands: ").unwrap(); + for cmd in commands.iter() { + if !first { + ret.push_str(", "); + } + ret.push_str(cmd.verb()); + first = false; + } + Ok(Some(ret)) + } else { + cmd_ret + } + } else { + Ok(None) + } + } else if let Some(callback) = maybe_callback { + let mut cmd_ret: Result, xous::Error> = Ok(None); + // first check and see if we have a callback registration; if not, just map to the last verb + let verb = match self.common_env.cb_registrations.get(&(callback.body.id() as u32)) { + Some(verb) => &verb, + None => &self.lastverb, + }; + // now dispatch + let mut verbfound = false; + for cmd in commands.iter_mut() { + if cmd.matches(verb) { + cmd_ret = cmd.callback(callback, &mut self.common_env); + verbfound = true; + break; + }; + } + if verbfound { cmd_ret } else { Ok(None) } + } else { + Ok(None) + } + } +} + +/// extract the first token, as delimited by spaces +/// modifies the incoming line by removing the token and returning the remainder +/// returns the found token +/// note: we don't have split() because of nostd +pub fn tokenize(line: &mut String) -> Option { + let mut token = String::new(); + let mut retline = String::new(); + + let lineiter = line.as_str().chars(); + let mut foundspace = false; + let mut foundrest = false; + for ch in lineiter { + if ch != ' ' && !foundspace { + token.push(ch); + } else if foundspace && foundrest { + retline.push(ch); + } else if foundspace && ch != ' ' { + // handle case of multiple spaces in a row + foundrest = true; + retline.push(ch); + } else { + foundspace = true; + // consume the space + } + } + line.clear(); + write!(line, "{}", retline.as_str()).unwrap(); + if token.len() > 0 { Some(token) } else { None } +} diff --git a/services/bao-console/src/cmds/echo.rs b/services/bao-console/src/cmds/echo.rs new file mode 100644 index 000000000..b76925551 --- /dev/null +++ b/services/bao-console/src/cmds/echo.rs @@ -0,0 +1,16 @@ +use String; + +use crate::{CommonEnv, ShellCmdApi}; + +#[derive(Debug)] +pub struct Echo {} + +impl<'a> ShellCmdApi<'a> for Echo { + cmd_api!(echo); + + // inserts boilerplate for command API + + fn process(&mut self, args: String, _env: &mut CommonEnv) -> Result, xous::Error> { + Ok(Some(args)) + } +} diff --git a/services/bao-console/src/cmds/test.rs b/services/bao-console/src/cmds/test.rs new file mode 100644 index 000000000..4a76ccea8 --- /dev/null +++ b/services/bao-console/src/cmds/test.rs @@ -0,0 +1,31 @@ +use String; + +use crate::{CommonEnv, ShellCmdApi}; + +#[derive(Debug)] +pub struct Test {} + +impl<'a> ShellCmdApi<'a> for Test { + cmd_api!(test); + + // inserts boilerplate for command API + + fn process(&mut self, args: String, _env: &mut CommonEnv) -> Result, xous::Error> { + use core::fmt::Write; + let mut ret = String::new(); + let helpstring = "Test commands. See code for options."; + + let mut tokens = args.split(' '); + + if let Some(sub_cmd) = tokens.next() { + match sub_cmd { + _ => { + write!(ret, "{}", helpstring).unwrap(); + } + } + } else { + write!(ret, "{}", helpstring).unwrap(); + } + Ok(Some(ret)) + } +} diff --git a/services/bao-console/src/cmds/trng_cmd.rs b/services/bao-console/src/cmds/trng_cmd.rs new file mode 100644 index 000000000..43c8845af --- /dev/null +++ b/services/bao-console/src/cmds/trng_cmd.rs @@ -0,0 +1,42 @@ +use String; + +use crate::{CommonEnv, ShellCmdApi}; + +#[derive(Debug)] +pub struct TrngCmd {} +impl TrngCmd { + pub fn new() -> Self { TrngCmd {} } +} + +impl<'a> ShellCmdApi<'a> for TrngCmd { + cmd_api!(trng); + + fn process(&mut self, args: String, env: &mut CommonEnv) -> Result, xous::Error> { + use core::fmt::Write; + let mut ret = String::new(); + let helpstring = "trng [pump]"; + + let mut tokens = args.split(' '); + + if let Some(sub_cmd) = tokens.next() { + match sub_cmd { + "pump" => { + const ROUNDS: usize = 16; + for i in 0..ROUNDS { + log::info!("pump round {}", i); + let mut buf: [u32; 1020] = [0; 1020]; + env.trng.fill_buf(&mut buf).unwrap(); + log::info!("pump samples: {:x}, {:x}, {:x}", buf[0], buf[512], buf[1019]); + } + write!(ret, "Pumped {}x1k values out of the engine", ROUNDS).unwrap(); + } + _ => { + write!(ret, "{}", helpstring).unwrap(); + } + } + } else { + write!(ret, "{}", helpstring).unwrap(); + } + Ok(Some(ret)) + } +} diff --git a/services/bao-console/src/cmds/ver.rs b/services/bao-console/src/cmds/ver.rs new file mode 100644 index 000000000..d025acd9e --- /dev/null +++ b/services/bao-console/src/cmds/ver.rs @@ -0,0 +1,40 @@ +use String; + +use crate::{CommonEnv, ShellCmdApi}; + +#[derive(Debug)] +pub struct Ver {} + +impl<'a> ShellCmdApi<'a> for Ver { + cmd_api!(ver); + + // inserts boilerplate for command API + + fn process(&mut self, args: String, env: &mut CommonEnv) -> Result, xous::Error> { + use core::fmt::Write; + let mut ret = String::new(); + let helpstring = "ver [xous]"; + + let mut tokens = args.split(' '); + + if let Some(sub_cmd) = tokens.next() { + match sub_cmd { + "xous" => { + write!(ret, "Xous version: {}", env.ticktimer.get_version()).unwrap(); + log::info!( + "{}VER.XOUS,{},{}", + xous::BOOKEND_START, + env.ticktimer.get_version(), + xous::BOOKEND_END + ); + } + _ => { + write!(ret, "{}", helpstring).unwrap(); + } + } + } else { + write!(ret, "{}", helpstring).unwrap(); + } + Ok(Some(ret)) + } +} diff --git a/services/bao-console/src/main.rs b/services/bao-console/src/main.rs new file mode 100644 index 000000000..7fcfbe544 --- /dev/null +++ b/services/bao-console/src/main.rs @@ -0,0 +1,18 @@ +mod cmds; +mod repl; +mod shell; + +use cmds::*; + +fn main() { + log_server::init_wait().unwrap(); + log::set_max_level(log::LevelFilter::Info); + + let tt = ticktimer::Ticktimer::new().unwrap(); + shell::start_shell(); + + loop { + // just sleep as this is the parent thread + tt.sleep_ms(120_000).ok(); + } +} diff --git a/services/bao-console/src/repl.rs b/services/bao-console/src/repl.rs new file mode 100644 index 000000000..cc7e01aa8 --- /dev/null +++ b/services/bao-console/src/repl.rs @@ -0,0 +1,94 @@ +use xous::MessageEnvelope; + +use crate::CmdEnv; + +#[derive(Debug)] +#[allow(dead_code)] // until we implement history processing... +pub(crate) struct History { + // the history record + pub text: String, + // if true, this was input from the user; if false, it's a response from the shell + pub is_input: bool, +} + +pub const HISTORY_DEPTH: usize = 10; +pub(crate) struct Repl { + // optional structures that indicate new input to the Repl loop per iteration + // an input string + input: Option, + // messages from other servers + msg: Option, + + // record our input history + history: Vec, + history_len: usize, + + // command environment + env: CmdEnv, +} +impl Repl { + pub(crate) fn new(xns: &xous_names::XousNames) -> Self { + Repl { + input: None, + msg: None, + history: Vec::new(), + history_len: HISTORY_DEPTH, + env: CmdEnv::new(xns), + } + } + + /// accept a new input string + pub(crate) fn input(&mut self, line: &str) -> Result<(), xous::Error> { + self.input = Some(String::from(line)); + + Ok(()) + } + + pub(crate) fn msg(&mut self, message: MessageEnvelope) { self.msg = Some(message); } + + pub(crate) fn circular_push(&mut self, item: History) { + if self.history.len() >= self.history_len { + self.history.remove(0); + } + self.history.push(item); + } + + // An index of -1 gives the most recent command. + // -2 would give the second most recent command + pub(crate) fn get_history(&mut self, index: isize) -> &str { + &self.history + [(self.history.len() as isize + index).max(0).min(self.history.len() as isize - 1) as usize] + .text + } + + /// update the loop, in response to various inputs + pub(crate) fn update(&mut self, _was_callback: bool, _init_done: bool) -> Result<(), xous::Error> { + // if we had an input string, do something + if let Some(local) = &self.input { + let input_history = History { text: local.to_string(), is_input: true }; + self.circular_push(input_history); + } + + // AT THIS POINT: if we have other inputs, update accordingly + // other inputs might be, for example, events that came in from other servers that would + // side effect our commands + // take the input and pass it on to the various command parsers, and attach result + if let Some(local) = &mut self.input { + log::trace!("processing line: {}", local); + if let Some(res) = self.env.dispatch(Some(local), None).expect("command dispatch failed") { + println!("{}", res); + } + } else if let Some(msg) = &self.msg { + log::trace!("processing callback msg: {:?}", msg); + if let Some(res) = self.env.dispatch(None, Some(msg)).expect("callback failed") { + println!("{}", res); + } + } + + // clear all the inputs to the loop, so we don't process them twice + self.input = None; + self.msg = None; + + Ok(()) + } +} diff --git a/services/bao-console/src/shell.rs b/services/bao-console/src/shell.rs new file mode 100644 index 000000000..09a2f7831 --- /dev/null +++ b/services/bao-console/src/shell.rs @@ -0,0 +1,106 @@ +use cram_hal_service::keyboard; +use xous::msg_scalar_unpack; + +pub fn start_shell() { + std::thread::spawn(move || { + shell(); + }); +} + +////////////////// local message passing from Ux Callback +use num_traits::*; + +use crate::repl::HISTORY_DEPTH; + +#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] +enum ConsoleOp { + /// A character is incoming + Keypress, + /// exit the application + Quit, +} + +pub(crate) const SERVER_NAME_SHELLCHAT: &str = "_Bao console application_"; // used internally by xous-names + +fn shell() { + let xns = xous_names::XousNames::new().unwrap(); + // unlimited connections allowed, this is a user app and it's up to the app to decide its policy + let shch_sid = xns.register_name(SERVER_NAME_SHELLCHAT, None).expect("can't register server"); + + let kbd = keyboard::Keyboard::new(&xns).unwrap(); + kbd.register_listener(SERVER_NAME_SHELLCHAT, ConsoleOp::Keypress.to_u32().unwrap() as usize); + + let mut repl = crate::repl::Repl::new(&xns); + let mut update_repl = false; + let mut was_callback = false; + let mut history_index: isize = 0; + + let mut input = String::new(); + loop { + let msg = xous::receive_message(shch_sid).unwrap(); + let console_op: Option = FromPrimitive::from_usize(msg.body.id()); + log::debug!("{:?}", console_op); + match console_op { + Some(ConsoleOp::Keypress) => msg_scalar_unpack!(msg, k1, _k2, _k3, _k4, { + let k = char::from_u32(k1 as u32).unwrap_or('\u{0000}'); + if k1 == 0x08 { + // backspace character + input.pop(); // returns None if empty + } else if k == '↑' || k == '↓' { + // a partial attempt at history processing. + if k == '↑' { + history_index -= 1; + } else if k == '↓' { + history_index += 1; + } + if history_index > -1 { + history_index = -1; + } + if history_index < -(HISTORY_DEPTH as isize) { + history_index = -(HISTORY_DEPTH as isize); + } + let input_len = input.len(); + // line editing doesn't work because the "print" implementation waits until a newline + // to send the buffer to reduce message traffic. I think it's reasonable to leave it + // without line editing for now to preserve this trade-off. + if false { + // clear the old input + let spaces: String = std::iter::repeat(' ').take(input_len).collect(); + print!("\r{}", spaces); + } + input.clear(); + input.push_str(repl.get_history(history_index)); + // print the new input + println!("{}", &input); + } else if k != '\u{0000}' && k != '\n' && k != '\r' { + input.push(k); + } else if k == '\n' || k == '\r' { + repl.input(input.as_str()).expect("REPL crashed"); + update_repl = true; + was_callback = false; + history_index = 0; + input.clear(); + } + }), + Some(ConsoleOp::Quit) => { + log::error!("got Quit"); + break; + } + _ => { + log::trace!("got unknown message, treating as callback"); + repl.msg(msg); + update_repl = true; + was_callback = true; + } + } + if update_repl { + repl.update(was_callback, true).expect("REPL had problems updating"); + update_repl = false; + } + } + + // clean up our program + log::error!("shell loop exit, destroying servers"); + xns.unregister_server(shch_sid).unwrap(); + xous::destroy_server(shch_sid).unwrap(); +}