[opentitanlib] change parameter on UartConsole to boolean quiet flag

We always use `stdout` if it's not `None`, so just use a boolean quiet flag
instead.

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

Author: nbdd0121

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

@@ -6,7 +6,6 @@ use crc::{CRC_32_ISO_HDLC, Crc};
 use regex::Regex;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
-use std::io::Write;
 use std::time::Duration;
 
 use crate::io::console::{ConsoleDevice, ConsoleError};
@@ -70,14 +69,7 @@ where
             Some(Regex::new(r"RESP_OK:(.*) CRC:([0-9]+)\n")?),
             Some(Regex::new(r"RESP_ERR:(.*) CRC:([0-9]+)\n")?),
         );
-        let mut stdout = std::io::stdout();
-        let out = if !quiet {
-            let w: &mut dyn Write = &mut stdout;
-            Some(w)
-        } else {
-            None
-        };
-        let result = console.interact(device, out)?;
+        let result = console.interact(device, quiet)?;
         println!();
         match result {
             ExitStatus::ExitSuccess => {

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

@@ -16,7 +16,6 @@ pub struct UartConsole {
     exit_failure: Option<Regex>,
     pub timestamp: bool,
     buffer: String,
-    newline: bool,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -40,32 +39,27 @@ impl UartConsole {
             exit_failure,
             timestamp: true,
             buffer: String::new(),
-            newline: true,
         }
     }
 
     // Runs an interactive console until CTRL_C is received.
-    pub fn interact<T>(&mut self, device: &T, stdout: Option<&mut dyn Write>) -> Result<ExitStatus>
+    pub fn interact<T>(&mut self, device: &T, quiet: bool) -> Result<ExitStatus>
     where
         T: ConsoleDevice + ?Sized,
     {
-        crate::util::runtime::block_on(self.interact_async(device, stdout))
+        crate::util::runtime::block_on(self.interact_async(device, quiet))
     }
 
     // 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.
-    pub async fn interact_async<T>(
-        &mut self,
-        device: &T,
-        mut stdout: Option<&mut dyn Write>,
-    ) -> Result<ExitStatus>
+    pub async fn interact_async<T>(&mut self, device: &T, quiet: bool) -> Result<ExitStatus>
     where
         T: ConsoleDevice + ?Sized,
     {
         let timeout = self.timeout;
         let rx = async {
             loop {
-                self.uart_read(device, &mut stdout).await?;
+                self.uart_read(device, quiet).await?;
                 if self
                     .exit_success
                     .as_ref()
@@ -115,35 +109,34 @@ impl UartConsole {
     }
 
     // Read from the console device and process the data read.
-    async fn uart_read<T>(&mut self, device: &T, stdout: &mut Option<&mut dyn Write>) -> Result<()>
+    async fn uart_read<T>(&mut self, device: &T, quiet: bool) -> Result<()>
     where
         T: ConsoleDevice + ?Sized,
     {
-        let mut buf = [0u8; 1024];
-        let effective_buf = if self.uses_regex() {
-            // Read one byte at a time when matching, to avoid the risk of consuming output past a
-            // match.
-            &mut buf[..1]
-        } else {
-            &mut buf
-        };
-        let len = std::future::poll_fn(|cx| device.poll_read(cx, effective_buf)).await?;
-        for i in 0..len {
-            if self.timestamp && self.newline {
+        let mut ch = 0;
+
+        // Read one byte at a time to avoid the risk of consuming output past a match.
+        let len =
+            std::future::poll_fn(|cx| device.poll_read(cx, std::slice::from_mut(&mut ch))).await?;
+
+        if len == 0 {
+            return Ok(());
+        }
+
+        if !quiet {
+            let mut stdout = std::io::stdout().lock();
+            stdout.write_all(std::slice::from_ref(&ch))?;
+
+            if self.timestamp && ch == b'\n' {
                 let t = humantime::format_rfc3339_millis(SystemTime::now());
-                stdout.as_mut().map_or(Ok(()), |out| {
-                    out.write_fmt(format_args!("[{}  console]", t))
-                })?;
-                self.newline = false;
+                stdout.write_fmt(format_args!("[{}  console]", t))?;
             }
-            self.newline = buf[i] == b'\n';
-            stdout
-                .as_mut()
-                .map_or(Ok(()), |out| out.write_all(&buf[i..i + 1]))?;
+
+            stdout.flush()?;
         }
-        stdout.as_mut().map_or(Ok(()), |out| out.flush())?;
+
         if self.uses_regex() {
-            self.append_buffer(&buf[..len]);
+            self.append_buffer(std::slice::from_ref(&ch));
         }
         Ok(())
     }
@@ -170,8 +163,7 @@ impl UartConsole {
         T: ConsoleDevice + ?Sized,
     {
         let mut console = UartConsole::new(Some(timeout), Some(Regex::new(rx)?), None);
-        let mut stdout = std::io::stdout();
-        let result = console.interact(device, Some(&mut stdout))?;
+        let result = console.interact(device, false)?;
         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)?;
+        let rc = self.console.interact(uart, true)?;
         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

@@ -169,11 +169,7 @@ impl CommandDispatch for Console {
                     }
                 };
 
-                let rx = async {
-                    console
-                        .interact_async(&uart_rx, Some(&mut std::io::stdout()))
-                        .await
-                };
+                let rx = async { console.interact_async(&uart_rx, false).await };
 
                 Result::<_>::Ok(tokio::select! {
                     v = tx => Err(v?),

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, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, false)?;
     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, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, false)?;
     log::info!("result: {:?}", result);
     jtag.halt()?;
     jtag.disconnect()?;

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

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

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

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

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, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, false)?;
     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, Some(&mut std::io::stdout()))?;
+    let result = console.interact(&*uart, false)?;
     if result != ExitStatus::ExitSuccess {
         bail!("FAIL: {:?}", result);
     };