[opentitanlib] remove UartConsole stdin handling

The feature is only ever used by `opentitantool console`, so have this feature
implemented there instead.

Signed-off-by: Gary Guo <[email protected]>

Author: nbdd0121

sw/host/opentitanlib/src/test_utils/rpc.rs

@@ -77,7 +77,7 @@ where
         } else {
             None
         };
-        let result = console.interact(device, None, out)?;
+        let result = console.interact(device, out)?;
         println!();
         match result {
             ExitStatus::ExitSuccess => {

sw/host/opentitanlib/src/uart/console.rs

@@ -2,14 +2,12 @@
 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
 // SPDX-License-Identifier: Apache-2.0
 
-use anyhow::{Result, anyhow};
-use regex::{Captures, Regex};
 use std::fs::File;
 use std::io::Write;
-use std::os::fd::AsFd;
 use std::time::{Duration, SystemTime};
 
-use tokio::io::AsyncReadExt;
+use anyhow::{Result, anyhow};
+use regex::{Captures, Regex};
 
 use crate::io::console::{ConsoleDevice, ConsoleError};
 
@@ -21,7 +19,6 @@ pub struct UartConsole {
     pub timestamp: bool,
     buffer: String,
     newline: bool,
-    break_en: bool,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -33,13 +30,7 @@ pub enum ExitStatus {
     ExitFailure,
 }
 
-// Creates a vtable for implementors of Read and AsFd traits.
-pub trait ReadAsFd: tokio::io::AsyncRead + AsFd + std::marker::Unpin {}
-impl<T: tokio::io::AsyncRead + AsFd + std::marker::Unpin> ReadAsFd for T {}
-
 impl UartConsole {
-    const CTRL_B: u8 = 2;
-    const CTRL_C: u8 = 3;
     const BUFFER_LEN: usize = 32768;
 
     pub fn new(
@@ -55,43 +46,28 @@ impl UartConsole {
             timestamp: true,
             buffer: String::new(),
             newline: true,
-            break_en: false,
         }
     }
 
     // Runs an interactive console until CTRL_C is received.
-    pub fn interact<T>(
-        &mut self,
-        device: &T,
-        stdin: Option<&mut dyn ReadAsFd>,
-        stdout: Option<&mut dyn Write>,
-    ) -> Result<ExitStatus>
+    pub fn interact<T>(&mut self, device: &T, stdout: Option<&mut dyn Write>) -> Result<ExitStatus>
     where
         T: ConsoleDevice + ?Sized,
     {
-        crate::util::runtime::block_on(self.interact_async(device, stdin, stdout))
+        crate::util::runtime::block_on(self.interact_async(device, stdout))
     }
 
     // Runs an interactive console until CTRL_C is received.  Uses `mio` library to simultaneously
     // wait for data from UART or from stdin, without need for timeouts and repeated calls.
-    async fn interact_async<T>(
+    pub async fn interact_async<T>(
         &mut self,
         device: &T,
-        mut stdin: Option<&mut dyn ReadAsFd>,
         mut stdout: Option<&mut dyn Write>,
     ) -> Result<ExitStatus>
     where
         T: ConsoleDevice + ?Sized,
     {
-        let mut break_en = self.break_en;
         let timeout = self.timeout;
-        let tx = async {
-            if let Some(stdin) = stdin.as_mut() {
-                Self::process_input(&mut break_en, device, stdin).await
-            } else {
-                std::future::pending().await
-            }
-        };
         let rx = async {
             loop {
                 self.uart_read(device, &mut stdout).await?;
@@ -121,13 +97,10 @@ impl UartConsole {
             }
         };
 
-        let r = tokio::select! {
-            v = tx => v,
+        tokio::select! {
             v = rx => v,
             _ = timeout => Ok(ExitStatus::Timeout),
-        };
-        self.break_en = break_en;
-        r
+        }
     }
 
     /// Returns `true` if any regular expressions are used to match the streamed output.  If so,
@@ -185,41 +158,6 @@ impl UartConsole {
         Ok(())
     }
 
-    async fn process_input<T>(
-        break_en: &mut bool,
-        device: &T,
-        stdin: &mut dyn ReadAsFd,
-    ) -> Result<ExitStatus>
-    where
-        T: ConsoleDevice + ?Sized,
-    {
-        loop {
-            let mut buf = [0u8; 256];
-            let len = stdin.read(&mut buf).await?;
-            if len == 1 {
-                if buf[0] == UartConsole::CTRL_C {
-                    return Ok(ExitStatus::CtrlC);
-                }
-                if buf[0] == UartConsole::CTRL_B {
-                    *break_en = !*break_en;
-                    eprint!(
-                        "\r\n{} break",
-                        if *break_en { "Setting" } else { "Clearing" }
-                    );
-                    let b = device.set_break(*break_en);
-                    if b.is_err() {
-                        eprint!(": {:?}", b);
-                    }
-                    eprint!("\r\n");
-                    continue;
-                }
-            }
-            if len > 0 {
-                device.write(&buf[..len])?;
-            }
-        }
-    }
-
     pub fn captures(&self, status: ExitStatus) -> Option<Captures<'_>> {
         match status {
             ExitStatus::ExitSuccess => self
@@ -243,7 +181,7 @@ impl UartConsole {
     {
         let mut console = UartConsole::new(Some(timeout), Some(Regex::new(rx)?), None);
         let mut stdout = std::io::stdout();
-        let result = console.interact(device, None, Some(&mut stdout))?;
+        let result = console.interact(device, Some(&mut stdout))?;
         println!();
         match result {
             ExitStatus::ExitSuccess => {

sw/host/opentitanlib/src/util/rom_detect.rs

@@ -30,7 +30,7 @@ impl RomDetect {
 
     pub fn detect(&mut self, uart: &dyn Uart) -> Result<bool> {
         let t0 = Instant::now();
-        let rc = self.console.interact(uart, None, None)?;
+        let rc = self.console.interact(uart, None)?;
         let t1 = Instant::now();
         log::debug!("detect exit={:?}, duration={:?}", rc, t1 - t0);
         if let Some(cap) = self.console.captures(ExitStatus::ExitSuccess) {

sw/host/opentitantool/src/command/console.rs

@@ -7,10 +7,13 @@ use clap::Args;
 use regex::Regex;
 use std::any::Any;
 use std::fs::File;
+use std::marker::Unpin;
 use std::time::Duration;
+use tokio::io::{AsyncRead, AsyncReadExt};
 
 use opentitanlib::app::TransportWrapper;
 use opentitanlib::app::command::CommandDispatch;
+use opentitanlib::io::console::ConsoleDevice;
 use opentitanlib::io::uart::UartParams;
 use opentitanlib::transport::Capability;
 use opentitanlib::uart::console::{ExitStatus, UartConsole};
@@ -52,6 +55,42 @@ pub struct Console {
     exit_failure: Option<String>,
 }
 
+const CTRL_B: u8 = 2;
+const CTRL_C: u8 = 3;
+
+/// Takes input from an input stream and send it to a console device. Breaks are handled.
+async fn process_input<T, R: AsyncRead + Unpin>(device: &T, stdin: &mut R) -> Result<ExitStatus>
+where
+    T: ConsoleDevice + ?Sized,
+{
+    let mut break_en = false;
+    loop {
+        let mut buf = [0u8; 256];
+        let len = stdin.read(&mut buf).await?;
+        if len == 1 {
+            if buf[0] == CTRL_C {
+                return Ok(ExitStatus::CtrlC);
+            }
+            if buf[0] == CTRL_B {
+                break_en = !break_en;
+                eprint!(
+                    "\r\n{} break",
+                    if break_en { "Setting" } else { "Clearing" }
+                );
+                let b = device.set_break(break_en);
+                if b.is_err() {
+                    eprint!(": {:?}", b);
+                }
+                eprint!("\r\n");
+                continue;
+            }
+        }
+        if len > 0 {
+            device.write(&buf[..len])?;
+        }
+    }
+}
+
 impl CommandDispatch for Console {
     fn run(
         &self,
@@ -97,7 +136,22 @@ impl CommandDispatch for Console {
             }
 
             transport.relinquish_exclusive_access(|| {
-                console.interact(&*uart, stdin.as_mut().map(|x| x as _), Some(&mut stdout))
+                opentitanlib::util::runtime::block_on(async {
+                    let tx = async {
+                        if let Some(stdin) = stdin.as_mut() {
+                            process_input(&*uart, stdin).await
+                        } else {
+                            std::future::pending().await
+                        }
+                    };
+
+                    let rx = console.interact_async(&*uart, Some(&mut stdout));
+
+                    tokio::select! {
+                        v = tx => v,
+                        v = rx => v,
+                    }
+                })
             })??
         };
         if !self.non_interactive {

sw/host/tests/chip/jtag/src/openocd_test.rs

@@ -42,7 +42,7 @@ fn test_openocd(opts: &Opts, transport: &TransportWrapper) -> Result<()> {
     const CONSOLE_TIMEOUT: Duration = Duration::from_secs(5);
 
     let mut console = UartConsole::new(Some(CONSOLE_TIMEOUT), Some(Regex::new(r"PASS!")?), None);
-    let result = console.interact(&*uart, None, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, Some(&mut std::io::stdout()))?;
     log::info!("result: {:?}", result);
 
     //

sw/host/tests/chip/jtag/src/sram_load.rs

@@ -54,7 +54,7 @@ fn test_sram_load(opts: &Opts, transport: &TransportWrapper) -> Result<()> {
         )?),
         None,
     );
-    let result = console.interact(&*uart, None, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, Some(&mut std::io::stdout()))?;
     log::info!("result: {:?}", result);
     jtag.halt()?;
     jtag.disconnect()?;

sw/host/tests/chip/power_virus/src/main.rs

@@ -32,7 +32,7 @@ fn power_virus_systemtest(opts: &Opts, transport: &TransportWrapper) -> Result<(
         Some(Regex::new(r"(FAIL|FAULT).*\n")?),
     );
     let mut stdout = std::io::stdout();
-    let result = console.interact(&*uart, None, Some(&mut stdout))?;
+    let result = console.interact(&*uart, Some(&mut stdout))?;
     match result {
         ExitStatus::None | ExitStatus::CtrlC => Ok(()),
         ExitStatus::Timeout => Err(anyhow!("Console timeout exceeded")),

sw/host/tests/chip/rv_core_ibex_epmp/src/main.rs

@@ -70,7 +70,7 @@ fn ibex_epmp_test(opts: &Opts, transport: &TransportWrapper) -> Result<()> {
     );
 
     let mut stdout = std::io::stdout();
-    let result = console.interact(&*uart, None, Some(&mut stdout))?;
+    let result = console.interact(&*uart, Some(&mut stdout))?;
     match result {
         ExitStatus::None | ExitStatus::CtrlC => Ok(()),
         ExitStatus::Timeout => Err(anyhow!("Console timeout exceeded")),

sw/host/tests/chip/spi_device/src/spi_device_flash_smoketest.rs

@@ -93,7 +93,7 @@ fn main() -> Result<()> {
     );
 
     // Now watch the console for the exit conditions.
-    let result = console.interact(&*uart, None, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, Some(&mut std::io::stdout()))?;
     if result != ExitStatus::ExitSuccess {
         bail!("FAIL: {:?}", result);
     };

sw/host/tests/chip/spi_device/src/spi_device_sleep_test.rs

@@ -104,7 +104,7 @@ fn main() -> Result<()> {
     );
 
     // Now watch the console for the exit conditions.
-    let result = console.interact(&*uart, None, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, Some(&mut std::io::stdout()))?;
     if result != ExitStatus::ExitSuccess {
         bail!("FAIL: {:?}", result);
     };