Auto merge of #11 - fluffysquirrels:input, r=japaric

 More input handling options

In particular:

* Arguments to read to the end of a file or follow the end (like tail -f)
* Extract a chosen stimulus port instead of only 0

Also:
* Logging with env_logger

Author: homunkulus

Cargo.lock

@@ -10,10 +10,11 @@ repository = "https://github.com/japaric/itm"
 version = "0.1.1"
 
 [dependencies]
-clap = "2.14.0"
-error-chain = "0.5.0"
-libc = "0.2.17"
-ref_slice = "1.1.0"
+chrono = "^0.4"
+clap = "^2.14.0"
+env_logger = "^0.4.3"
+error-chain = "^0.11.0"
+log = "^0.3.8"
 
 [dev-dependencies]
 tempdir = "0.3.5"

Cargo.toml

@@ -3,7 +3,7 @@
 
 # `itm`
 
-> Tool to parse and dump [ITM] packets
+> A Rust crate and tool `itmdump` to parse and dump ARM [ITM] packets.
 
 [ITM]: http://infocenter.arm.com/help/topic/com.arm.doc.ddi0314h/Chdbicbg.html
 

README.md

@@ -1,35 +1,37 @@
-extern crate clap;
-extern crate libc;
-extern crate ref_slice;
+#![deny(warnings)]
 
+extern crate chrono;
+extern crate clap;
+extern crate env_logger;
+extern crate itm;
 #[macro_use]
-extern crate error_chain;
-
-use std::io::{Read, Write};
-use std::path::PathBuf;
-use std::time::Duration;
-use std::{env, fs, io, process, thread};
+extern crate log;
 
-#[cfg(not(unix))]
-use std::fs::OpenOptions;
-
-#[cfg(unix)]
-use std::ffi::CString;
-#[cfg(unix)]
+use clap::{Arg, App, ArgMatches};
+use itm::{packet, Decoder};
+use itm::error::{Error, ErrorKind, Result, ResultExt};
+use log::{LogRecord, LogLevelFilter};
 use std::fs::File;
-#[cfg(unix)]
-use std::os::unix::ffi::OsStringExt;
-
-use clap::{App, Arg};
-use ref_slice::ref_slice_mut;
-
-use errors::*;
-
-mod errors {
-    error_chain!();
-}
+use std::io::Write;
+use std::time::Duration;
+use std::{env, io, process, thread};
 
 fn main() {
+    // Initialise logging.
+    env_logger::LogBuilder::new()
+        .format(|r: &LogRecord|
+            format!("\n{time} {lvl} {mod} @{file}:{line}\n  {args}",
+                time = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S%.3f_UTC"),
+                lvl = r.level(),
+                mod = r.location().module_path(),
+                file = r.location().file(),
+                line = r.location().line(),
+                args = r.args())
+        )
+        .filter(None, LogLevelFilter::Info)
+        .parse(&env::var("RUST_LOG").unwrap_or(String::from("")))
+        .init().unwrap();
+
     fn show_backtrace() -> bool {
         env::var("RUST_BACKTRACE").as_ref().map(|s| &s[..]) == Ok("1")
     }
@@ -38,15 +40,15 @@ fn main() {
         let stderr = io::stderr();
         let mut stderr = stderr.lock();
 
-        writeln!(stderr, "{}", e).ok();
+        writeln!(stderr, "{}", e).unwrap();
 
         for e in e.iter().skip(1) {
-            writeln!(stderr, "caused by: {}", e).ok();
+            writeln!(stderr, "caused by: {}", e).unwrap();
         }
 
         if show_backtrace() {
             if let Some(backtrace) = e.backtrace() {
-                writeln!(stderr, "{:?}", backtrace).ok();
+                writeln!(stderr, "{:?}", backtrace).unwrap();
             }
         }
 
@@ -57,93 +59,95 @@ fn main() {
 fn run() -> Result<()> {
     let matches = App::new("itmdump")
         .version(include_str!(concat!(env!("OUT_DIR"), "/commit-info.txt")))
-        .arg(Arg::with_name("PATH").help("Named pipe to use").required(true))
+        .about("\n\
+                Reads data from an ARM CPU ITM and decodes it. \n\
+                \n\
+                Input is from an existing file (or named pipe) at a \
+                supplied path, or else from standard input.")
+        .arg(Arg::with_name("file")
+                 .long("file")
+                 .short("f")
+                 .help("Path to file (or named pipe) to read from")
+                 .takes_value(true))
+        .arg(Arg::with_name("follow")
+                 .long("follow")
+                 .short("F")
+                 .help("Keep the file open after reading through it and \
+                        append new output as it is written. Like `tail -f'."))
+        .arg(Arg::with_name("port")
+                 .long("stimulus")
+                 .short("s")
+                 .help("Stimulus port to extract ITM data for.")
+                 .takes_value(true)
+                 .default_value("0")
+                 .validator(|s| match s.parse::<u8>() {
+                                    Ok(_) => Ok(()),
+                                    Err(e) => Err(e.to_string())
+                                }))
         .get_matches();
 
-    let pipe = PathBuf::from(matches.value_of("PATH").unwrap());
-    let pipe_ = pipe.display();
-
-    if pipe.exists() {
-        try!(fs::remove_file(&pipe)
-            .chain_err(|| format!("couldn't remove {}", pipe_)));
-    }
-
-    let mut stream = match () {
-        #[cfg(unix)]
-        () => {
-            let cpipe =
-                try!(CString::new(pipe.clone().into_os_string().into_vec())
-                     .chain_err(|| {
-                         format!("error converting {} to a C string", pipe_)
-                     }));
-
-            match unsafe { libc::mkfifo(cpipe.as_ptr(), 0o644) } {
-                0 => {}
-                e => {
-                    try!(Err(io::Error::from_raw_os_error(e)).chain_err(|| {
-                        format!("couldn't create a named pipe in {}", pipe_)
-                    }))
-                }
-            }
+    let port = matches.value_of("port")
+                           .unwrap() // We supplied a default value
+                           .parse::<u8>()
+                           .expect("Arg validator should ensure this parses");
 
-            try!(File::open(&pipe)
-                .chain_err(|| format!("couldn't open {}", pipe_)))
-        }
-        #[cfg(not(unix))]
-        () => {
-            try!(OpenOptions::new()
-                 .create(true)
-                 .read(true)
-                 .write(true)
-                 .open(&pipe)
-                 .chain_err(|| format!("couldn't open {}", pipe_)))
-        }
-    };
+    let follow = matches.is_present("follow");
 
-    let mut header = 0;
+    let read = open_read(&matches)?;
+    let mut decoder = Decoder::new(read);
 
-    let (stdout, stderr) = (io::stdout(), io::stderr());
-    let (mut stdout, mut stderr) = (stdout.lock(), stderr.lock());
+    let stdout = io::stdout();
+    let mut stdout = stdout.lock();
     loop {
-        if let Err(e) = (|| {
-            try!(stream.read_exact(ref_slice_mut(&mut header)));
-            let port = header >> 3;
-
-            // Ignore all the packets that don't come from the stimulus port 0
-            if port != 0 {
-                return Ok(());
-            }
-
-            match header & 0b111 {
-                0b01 => {
-                    let mut payload = 0;
-                    try!(stream.read_exact(ref_slice_mut(&mut payload)));
-                    stdout.write_all(&[payload])
-                }
-                0b10 => {
-                    let mut payload = [0; 2];
-                    try!(stream.read_exact(&mut payload));
-                    stdout.write_all(&payload)
-                }
-                0b11 => {
-                    let mut payload = [0; 4];
-                    try!(stream.read_exact(&mut payload));
-                    stdout.write_all(&payload)
-                }
-                _ => {
-                    // Not a valid header, skip.
-                    Ok(())
+        let p = decoder.read_packet();
+        match p {
+            Ok(p) => {
+                match p.kind() {
+                    &packet::Kind::Instrumentation(ref i) if i.port() == port => {
+                        stdout.write_all(&i.payload())?;
+                    }
+                    _ => (),
                 }
             }
-        })() {
-            match e.kind() {
-                io::ErrorKind::UnexpectedEof => {
+            Err(e @ Error(ErrorKind::UnknownHeader(_), _)) => {
+                // We don't know this header type; warn and continue.
+                debug!("{}", e);
+            },
+            Err(Error(ErrorKind::EofBeforePacket, _)) => {
+                if follow {
                     thread::sleep(Duration::from_millis(100));
+                } else {
+                    // !follow and EOF. Exit.
+                    return Ok(())
                 }
-                _ => {
-                    writeln!(stderr, "error: {:?}", e.kind()).ok();
-                }
-            }
+            },
+
+            // FIXME: If in follow mode, we may try to read a packet
+            // but reach the end of the file in the middle. Currently
+            // we'd just return an error and hence exit. When we
+            // receive an error, we've already read and discarded some
+            // data, so we can't just go around this loop again.
+            //
+            // We could make a file following wrapper around `read`
+            // that blocks in a loop retrying the read and sleeping if
+            // there's no data.
+            Err(e) => return Err(e),
         }
-    }
+    } // end of read loop
+
+    // Unreachable.
+}
+
+fn open_read(matches: &ArgMatches) -> Result<Box<io::Read + 'static>> {
+    let path = matches.value_of("file");
+    Ok(match path {
+        Some(path) => {
+            let f =
+                File::open(path)
+                     .chain_err(|| format!("Couldn't open source file '{}'",
+                                           path))?;
+            Box::new(f) as Box<io::Read + 'static>
+        },
+        None => Box::new(io::stdin()) as Box<io::Read + 'static>,
+    })
 }