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.
This commit is contained in:
bunnie 2024-11-05 19:38:25 +08:00
parent 2afc139957
commit a9abba0bb0
9 changed files with 585 additions and 0 deletions

View file

@ -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 = []

View file

@ -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<Option<String>, 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<Option<String>, 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<u32, String>,
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<Option<String>, 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<Option<String>, 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<Option<String>, 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<String> {
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 }
}

View file

@ -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<Option<String>, xous::Error> {
Ok(Some(args))
}
}

View file

@ -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<Option<String>, 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))
}
}

View file

@ -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<Option<String>, 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))
}
}

View file

@ -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<Option<String>, 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))
}
}

View file

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

View file

@ -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<String>,
// messages from other servers
msg: Option<MessageEnvelope>,
// record our input history
history: Vec<History>,
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(())
}
}

View file

@ -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<ConsoleOp> = 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();
}