[RFC 5/6] scripts/simpletrace-rust: Format simple trace output

[Zhao Liu <zhao1.liu@intel.com>]

Format simple trace output, as in the Python version. Further, complete
the trace file input and trace log output.

Additionally, remove `#![allow(dead_code)]` and
`#![allow(unused_variables)]` to allow rustc to do related checks.

Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Zhao Liu <zhao1.liu@intel.com>
---
 scripts/simpletrace-rust/src/main.rs | 80 ++++++++++++++++++++++++++--
 1 file changed, 75 insertions(+), 5 deletions(-)

diff --git a/scripts/simpletrace-rust/src/main.rs b/scripts/simpletrace-rust/src/main.rs
index f9a71d8dc243..ba4b96efb066 100644
--- a/scripts/simpletrace-rust/src/main.rs
+++ b/scripts/simpletrace-rust/src/main.rs
@@ -8,23 +8,25 @@
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
-#![allow(dead_code)]
-#![allow(unused_variables)]
-
 mod trace;
 
 use std::collections::HashMap;
 use std::env;
+use std::fmt;
 use std::fs::File;
+use std::io::stdout;
 use std::io::Error as IOError;
 use std::io::ErrorKind;
 use std::io::Read;
+use std::io::Write;
 use std::mem::size_of;
 
 use backtrace::Backtrace;
 use clap::Arg;
 use clap::Command;
 use thiserror::Error;
+use trace::read_events;
+use trace::Error as TraceError;
 use trace::Event;
 
 const DROPPED_EVENT_ID: u64 = 0xfffffffffffffffe;
@@ -45,8 +47,12 @@ pub enum Error
     InvalidHeaderId(u64, u64),
     #[error("Not a valid trace file, header magic {0} != {1}")]
     InvalidHeaderMagic(u64, u64),
+    #[error("Failed to open file: {0}")]
+    OpenFile(IOError),
     #[error("Failed to read file: {0}")]
     ReadFile(IOError),
+    #[error("Failed to read trace: {0}")]
+    ReadTrace(TraceError),
     #[error(
         "event {0} is logged but is not declared in the trace events \
         file, try using trace-events-all instead."
@@ -58,6 +64,8 @@ pub enum Error
     UnknownVersion(u64),
     #[error("Log format {0} not supported with this QEMU release!")]
     UnsupportedVersion(u64),
+    #[error("Failed to write trace: {0}")]
+    WriteTrace(IOError),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -254,6 +262,30 @@ impl EventArgPayload
     }
 }
 
+impl fmt::Display for EventArgPayload
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result
+    {
+        if let Some(s) = &self.raw_str {
+            write!(fmt, "{}", s)
+        } else {
+            write!(fmt, "")
+        }
+    }
+}
+
+impl fmt::LowerHex for EventArgPayload
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result
+    {
+        if let Some(v) = self.raw_val {
+            write!(fmt, "{:x}", v)
+        } else {
+            write!(fmt, "")
+        }
+    }
+}
+
 #[derive(Clone)]
 struct EventEntry
 {
@@ -485,10 +517,35 @@ impl Analyzer for Formatter
         event: &Event,
         timestamp_ns: u64,
         pid: u32,
-        event_id: u64,
+        _event_id: u64,
     ) -> Result<String>
     {
-        let fmt_str = String::new();
+        if self.last_timestamp_ns.is_none() {
+            self.last_timestamp_ns = Some(timestamp_ns);
+        }
+
+        let fields: Vec<String> = rec_args
+            .iter()
+            .zip(event.args.props.iter())
+            .map(|(arg, prop)| {
+                if prop.is_string() {
+                    format!("{}={}", prop.name, arg)
+                } else {
+                    format!("{}=0x{:x}", prop.name, arg)
+                }
+            })
+            .collect();
+
+        let delta_ns =
+            timestamp_ns as f64 - self.last_timestamp_ns.unwrap() as f64;
+        self.last_timestamp_ns = Some(timestamp_ns);
+        let fmt_str = format!(
+            "{} {:.3} pid={} {}\n",
+            event.name,
+            delta_ns / 1000.0,
+            pid,
+            fields.join(" "),
+        );
 
         Ok(fmt_str)
     }
@@ -501,7 +558,20 @@ fn process(
     read_header: bool,
 ) -> Result<()>
 {
+    let events = read_events(event_path).map_err(Error::ReadTrace)?;
+    let trace_fobj = File::open(trace_path).map_err(Error::OpenFile)?;
+    if read_header {
+        read_trace_header(&trace_fobj)?;
+    }
+
     analyzer.begin();
+
+    let rec_strs =
+        read_trace_records(&events, &trace_fobj, analyzer, read_header)?;
+    let mut lock = stdout().lock();
+    lock.write_all(rec_strs.join("").as_ref())
+        .map_err(Error::WriteTrace)?;
+
     analyzer.end();
 
     Ok(())
-- 
2.34.1