RTT input support

Author: Dirbaio

Cargo.toml

@@ -26,6 +26,10 @@ probe-rs-rtt = "0.3.0"
 rustc-demangle = "0.1.16"
 signal-hook = "0.1.16"
 structopt = "0.3.15"
+libc = "0.2.77"
+
+[target.'cfg(windows)'.dependencies]
+winapi = { version =  "0.3.8", features = ["winbase", "consoleapi", "processenv", "handleapi", "synchapi", "impl-default"] }
 
 [features]
 defmt = ["defmt-elf2table", "defmt-decoder"]

src/main.rs

@@ -1,5 +1,13 @@
 mod logger;
 
+#[cfg(windows)]
+#[path ="reader_windows.rs"]
+mod reader;
+
+#[cfg(unix)]
+#[path ="reader_unix.rs"]
+mod reader;
+
 use core::{
     cmp,
     convert::TryInto,
@@ -10,7 +18,7 @@ use std::{
     borrow::Cow,
     collections::{btree_map, BTreeMap, HashSet},
     fs,
-    io::{self, Write as _},
+    io::{self, Read as _, Write as _},
     path::{Path, PathBuf},
     process,
     sync::{Arc, Mutex},
@@ -34,7 +42,7 @@ use probe_rs::{
     flashing::{self, Format},
     Core, CoreRegisterAddress, DebugProbeInfo, DebugProbeSelector, MemoryInterface, Probe, Session,
 };
-use probe_rs_rtt::{Rtt, ScanRegion, UpChannel};
+use probe_rs_rtt::{Rtt, ScanRegion};
 use structopt::StructOpt;
 
 const TIMEOUT: Duration = Duration::from_secs(1);
@@ -59,9 +67,13 @@ struct Opts {
 
     /// Enable defmt decoding.
     #[cfg(feature = "defmt")]
-    #[structopt(long, conflicts_with = "no_flash")]
+    #[structopt(long)]
     defmt: bool,
 
+    /// Enable input RTT channel (host to target)
+    #[structopt(long)]
+    input: bool,
+
     /// The chip to program.
     #[structopt(long, required_unless_one(&["list-chips", "list-probes"]), env = "PROBE_RUN_CHIP")]
     chip: Option<String>,
@@ -75,7 +87,7 @@ struct Opts {
     elf: Option<PathBuf>,
 
     /// Skip writing the application binary to flash.
-    #[structopt(long, conflicts_with = "defmt")]
+    #[structopt(long)]
     no_flash: bool,
 
     /// Enable more verbose logging.
@@ -360,18 +372,62 @@ fn notmain() -> Result<i32, anyhow::Error> {
     let sig_id = signal_hook::flag::register(signal_hook::SIGINT, exit.clone())?;
 
     let sess = Arc::new(Mutex::new(sess));
-    let mut logging_channel = setup_logging_channel(rtt_addr, sess.clone())?;
+
+    let (mut logging_channel, mut input_channel) = if let Some(rtt_addr) = rtt_addr {
+        let mut rtt = setup_rtt(rtt_addr, sess.clone())?;
+
+        let logging_channel = rtt
+            .up_channels()
+            .take(0)
+            .ok_or_else(|| anyhow!("RTT up channel 0 not found"))?;
+
+        let input_channel = if opts.input {
+            Some(
+                rtt.down_channels()
+                    .take(0)
+                    .ok_or_else(|| anyhow!("RTT down channel 0 not found"))?,
+            )
+        } else {
+            None
+        };
+
+        (Some(logging_channel), input_channel)
+    } else {
+        eprintln!("RTT logs not available; blocking until the device halts..");
+        (None, None)
+    };
 
     // wait for breakpoint
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
     let mut read_buf = [0; 1024];
     #[cfg(feature = "defmt")]
     let mut frames = vec![];
+
+    let rd = reader::Reader::new();
+    let mut write_buf = [0; 1024];
+    let mut write_start = 0;
+    let mut write_end = 0;
+
     let mut was_halted = false;
     let current_dir = std::env::current_dir()?;
     // TODO strip prefix from crates-io paths (?)
     while !exit.load(Ordering::Relaxed) {
+        if let Some(input_channel) = &mut input_channel {
+            // If we have no pending data, read some.
+            if write_start == write_end {
+                let n  = rd.read(&mut write_buf);
+                write_start = 0;
+                write_end = n;
+            }
+
+            // If we have pending data, try to write it.
+            if write_start != write_end {
+                let n = input_channel.write(&write_buf[write_start..write_end])?;
+                write_start += n;
+            }
+        }
+
         if let Some(logging_channel) = &mut logging_channel {
             let num_bytes_read = match logging_channel.read(&mut read_buf) {
                 Ok(n) => n,
@@ -515,46 +571,31 @@ enum TopException {
     Other,
 }
 
-fn setup_logging_channel(
-    rtt_addr: Option<u32>,
-    sess: Arc<Mutex<Session>>,
-) -> Result<Option<UpChannel>, anyhow::Error> {
-    if let Some(rtt_addr_res) = rtt_addr {
-        const NUM_RETRIES: usize = 10; // picked at random, increase if necessary
-        let mut rtt_res: Result<Rtt, probe_rs_rtt::Error> =
-            Err(probe_rs_rtt::Error::ControlBlockNotFound);
-
-        for try_index in 0..=NUM_RETRIES {
-            rtt_res = Rtt::attach_region(sess.clone(), &ScanRegion::Exact(rtt_addr_res));
-            match rtt_res {
-                Ok(_) => {
-                    log::debug!("Successfully attached RTT");
-                    break;
-                }
-                Err(probe_rs_rtt::Error::ControlBlockNotFound) => {
-                    if try_index < NUM_RETRIES {
-                        log::trace!("Could not attach because the target's RTT control block isn't initialized (yet). retrying");
-                    } else {
-                        log::error!("Max number of RTT attach retries exceeded.");
-                        return Err(anyhow!(probe_rs_rtt::Error::ControlBlockNotFound));
-                    }
-                }
-                Err(e) => {
-                    return Err(anyhow!(e));
+fn setup_rtt(rtt_addr: u32, sess: Arc<Mutex<Session>>) -> Result<Rtt, anyhow::Error> {
+    const NUM_RETRIES: usize = 10; // picked at random, increase if necessary
+
+    for try_index in 0..=NUM_RETRIES {
+        let rtt_res = Rtt::attach_region(sess.clone(), &ScanRegion::Exact(rtt_addr));
+        match rtt_res {
+            Ok(rtt) => {
+                log::debug!("Successfully attached RTT");
+                return Ok(rtt);
+            }
+            Err(probe_rs_rtt::Error::ControlBlockNotFound) => {
+                if try_index < NUM_RETRIES {
+                    log::trace!("Could not attach because the target's RTT control block isn't initialized (yet). retrying");
+                } else {
+                    log::error!("Max number of RTT attach retries exceeded.");
+                    return Err(anyhow!(probe_rs_rtt::Error::ControlBlockNotFound));
                 }
             }
+            Err(e) => {
+                return Err(anyhow!(e));
+            }
         }
-
-        let channel = rtt_res
-            .expect("unreachable") // this block is only executed when rtt was successfully attached before
-            .up_channels()
-            .take(0)
-            .ok_or_else(|| anyhow!("RTT up channel 0 not found"))?;
-        Ok(Some(channel))
-    } else {
-        eprintln!("RTT logs not available; blocking until the device halts..");
-        Ok(None)
     }
+
+    Err(anyhow!(probe_rs_rtt::Error::ControlBlockNotFound))
 }
 
 fn gimli2probe(reg: &gimli::Register) -> CoreRegisterAddress {

src/reader_unix.rs

@@ -0,0 +1,42 @@
+use libc::{fcntl, tcgetattr, tcsetattr, termios, ECHO, F_SETFL, ICANON, O_NONBLOCK, TCSAFLUSH};
+use std::io::Read;
+use std::io;
+use std::mem;
+
+pub struct Reader {
+    termios_original: termios,
+}
+
+impl Drop for Reader {
+    fn drop(&mut self) {
+        unsafe {
+            tcsetattr(0, TCSAFLUSH, &self.termios_original);
+        }
+    }
+}
+
+impl Reader {
+    pub fn new() -> Self {
+        let termios_original = unsafe {
+            fcntl(0, F_SETFL, O_NONBLOCK);
+            let mut termios_original = mem::zeroed();
+            tcgetattr(0, &mut termios_original);
+            let mut termios = termios_original;
+            termios.c_lflag &= !(ECHO | ICANON);
+            tcsetattr(0, TCSAFLUSH, &termios);
+            termios_original
+        };
+
+        Self {
+            termios_original,
+        }
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> usize {
+        match io::stdin().read(buf) {
+            Ok(n) => Ok(n),
+            Err(e) if e.kind() == io::ErrorKind::WouldBlock => Ok(0),
+            Err(e) => Err(e),
+        }.unwrap()
+    }
+}

src/reader_windows.rs

@@ -0,0 +1,55 @@
+use core::mem;
+
+use winapi::ctypes::c_void;
+use winapi::shared::minwindef::DWORD;
+use winapi::shared::ntdef::NULL;
+use winapi::um::consoleapi::{
+    GetConsoleMode, GetNumberOfConsoleInputEvents, ReadConsoleInputW, SetConsoleMode, WriteConsoleW,
+};
+use winapi::um::processenv::GetStdHandle;
+use winapi::um::winbase::{STD_INPUT_HANDLE, STD_OUTPUT_HANDLE};
+use winapi::um::wincon::{INPUT_RECORD, KEY_EVENT};
+use winapi::um::winnt::HANDLE;
+
+pub struct Reader {
+    h: HANDLE,
+}
+
+impl Reader {
+    pub fn new() -> Self {
+        let h = unsafe { GetStdHandle(STD_INPUT_HANDLE) };
+        Self { h }
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> usize {
+        unsafe {
+            let mut got = 0;
+
+            while got < buf.len() {
+                let mut n = 0;
+                let ret = GetNumberOfConsoleInputEvents(self.h, &mut n);
+                assert_eq!(ret, 1);
+
+                if n == 0 {
+                    break;
+                }
+
+                let mut input = mem::zeroed();
+                let mut n = 0;
+                let ret = ReadConsoleInputW(self.h, &mut input, 1, &mut n);
+                assert_eq!(ret, 1);
+                assert_eq!(n, 1);
+
+                if input.EventType == KEY_EVENT && input.Event.KeyEvent().bKeyDown == 1 {
+                    let ch = *input.Event.KeyEvent().uChar.UnicodeChar() as u8;
+                    if ch != 0 {
+                        buf[got] = ch;
+                        got += 1
+                    }
+                }
+            }
+
+            got
+        }
+    }
+}