decode & trace instructions while single-stepping

Summary:
This adds an ability to decode an instruction on top of the safeptrace::Stopped task and enables debug! tracing when single-stepping.

Note that performance overhead should not be present when higher tracing level  is requested

Reviewed By: jasonwhite

Differential Revision: D40895393

fbshipit-source-id: 867f237a0517304314f4ac43313c1f26cee3f646

Author: VladimirMakaev

reverie-ptrace/Cargo.toml

@@ -14,6 +14,7 @@ bincode = "1.3.3"
 bytes = { version = "1.1", features = ["serde"] }
 futures = { version = "0.3.22", features = ["async-await", "compat"] }
 goblin = "0.5.2"
+iced-x86 = "1.17.0"
 lazy_static = "1.4"
 libc = "0.2.137"
 nix = "0.25"

reverie-ptrace/src/decoder.rs

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+//! Routines for tracing and decoding instructions to a particular architecture
+use iced_x86::Decoder;
+use iced_x86::DecoderOptions;
+use iced_x86::Formatter;
+use iced_x86::IntelFormatter;
+use reverie::syscalls::MemoryAccess;
+
+use crate::regs::RegAccess;
+
+/// Decodes an instruction on top of the rip
+pub fn decode_instruction(task: &safeptrace::Stopped) -> Result<String, safeptrace::Error> {
+    let mut code = [0u8; 16];
+    let regs = task.getregs()?;
+    task.read_exact(regs.ip() as usize, &mut code)?;
+    let mut decoder = Decoder::with_ip(64, &code, regs.ip(), DecoderOptions::NONE);
+    let instruction = decoder.decode();
+    let mut formatter = IntelFormatter::new();
+    let mut output = String::new();
+    formatter.format(&instruction, &mut output);
+    Ok(output)
+}

reverie-ptrace/src/lib.rs

@@ -39,6 +39,8 @@ mod cp;
 #[allow(unused)]
 #[cfg(target_arch = "x86_64")]
 mod debug;
+#[cfg(target_arch = "x86_64")]
+pub mod decoder;
 mod error;
 mod gdbstub;
 mod perf;

reverie-ptrace/src/timer.rs

@@ -31,6 +31,8 @@
 
 use reverie::Errno;
 use reverie::Pid;
+use reverie::RegDisplay;
+use reverie::RegDisplayOptions;
 use reverie::Signal;
 use reverie::Tid;
 use safeptrace::Error as TraceError;
@@ -39,6 +41,7 @@ use safeptrace::Stopped;
 use safeptrace::Wait;
 use thiserror::Error;
 use tracing::debug;
+use tracing::trace;
 use tracing::warn;
 
 use crate::perf::*;
@@ -604,6 +607,13 @@ impl TimerImpl {
             if ctr >= target {
                 break;
             }
+            #[cfg(target_arch = "x86_64")]
+            trace!(
+                "[instruction]\n{}\n{}",
+                crate::decoder::decode_instruction(&task)?,
+                task.getregs()?
+                    .display_with_options(RegDisplayOptions { multiline: true })
+            );
             task = match task.step(None)?.next_state().await? {
                 // a successful single step results in SIGTRAP stop
                 Wait::Stopped(new_task, TraceEvent::Signal(Signal::SIGTRAP)) => new_task,