test: add entry value recovery coverage

Author: swananan

e2e-tests/tests/entry_value_recovery_execution.rs

@@ -0,0 +1,269 @@
+mod common;
+
+use common::{fixture_compiler_available, init, runner::GhostscopeRunner, FixtureCompiler};
+use ghostscope_dwarf::{ComputeStep, MemoryAccessSize};
+use regex::Regex;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::process::{Command as StdCommand, Stdio};
+use std::sync::OnceLock;
+use std::time::Duration;
+use tokio::io::AsyncReadExt;
+use tokio::process::{Child, Command as TokioCommand};
+use tokio::task::JoinHandle;
+
+const FIXTURE_NAME: &str = "entry_value_recovery_program";
+const FIXTURE_SOURCE: &str = "entry_value_recovery_program.c";
+const POST_CALL_TRACE_LINE: u32 = 21;
+
+static CLANG_FIXTURE: OnceLock<Result<PathBuf, String>> = OnceLock::new();
+
+struct LoggedTarget {
+    child: Child,
+    pid: u32,
+    stdout_task: JoinHandle<anyhow::Result<String>>,
+    stderr_task: JoinHandle<anyhow::Result<String>>,
+}
+
+impl LoggedTarget {
+    async fn terminate_and_collect(mut self) -> anyhow::Result<(String, String)> {
+        let _ = self.child.start_kill();
+        let _ = self.child.wait().await;
+        let stdout = self
+            .stdout_task
+            .await
+            .map_err(|e| anyhow::anyhow!("stdout task panicked: {e}"))??;
+        let stderr = self
+            .stderr_task
+            .await
+            .map_err(|e| anyhow::anyhow!("stderr task panicked: {e}"))??;
+        Ok((stdout, stderr))
+    }
+}
+
+fn should_skip_for_ebpf_env(exit_code: i32, stderr: &str) -> bool {
+    exit_code != 0
+        && (stderr.contains("BPF_PROG_LOAD")
+            || stderr.contains("needs elevated privileges")
+            || stderr.contains("cap_bpf"))
+}
+
+fn compile_entry_value_recovery_program_clang() -> anyhow::Result<PathBuf> {
+    let result = CLANG_FIXTURE.get_or_init(|| {
+        let base = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/fixtures")
+            .join(FIXTURE_NAME);
+        let binary = base.join("entry_value_recovery_program_clang_dwarf5");
+        let output = StdCommand::new("make")
+            .arg("clean")
+            .current_dir(&base)
+            .output();
+        if let Err(e) = output {
+            return Err(format!("failed to run make clean for {FIXTURE_NAME}: {e}"));
+        }
+
+        let output = std::process::Command::new("make")
+            .arg("all")
+            .arg("CC=clang")
+            .arg("CFLAGS=-Wall -Wextra -gdwarf-5 -O3")
+            .arg("BINARY=entry_value_recovery_program_clang_dwarf5")
+            .arg("OBJ=entry_value_recovery_program_clang_dwarf5.o")
+            .current_dir(&base)
+            .output();
+
+        match output {
+            Ok(output) if output.status.success() => Ok(binary),
+            Ok(output) => Err(format!(
+                "failed to compile {FIXTURE_NAME} clang fixture: {}",
+                String::from_utf8_lossy(&output.stderr)
+            )),
+            Err(e) => Err(format!("failed to run make for {FIXTURE_NAME}: {e}")),
+        }
+    });
+
+    result.clone().map_err(|e| anyhow::anyhow!(e))
+}
+
+async fn spawn_logged_target(binary_path: &Path) -> anyhow::Result<LoggedTarget> {
+    let base = binary_path
+        .parent()
+        .ok_or_else(|| anyhow::anyhow!("fixture binary has no parent dir"))?;
+    let mut child = TokioCommand::new(binary_path)
+        .current_dir(base)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()?;
+    let pid = child
+        .id()
+        .ok_or_else(|| anyhow::anyhow!("spawned fixture had no pid"))?;
+    let mut stdout = child
+        .stdout
+        .take()
+        .ok_or_else(|| anyhow::anyhow!("fixture stdout was not piped"))?;
+    let mut stderr = child
+        .stderr
+        .take()
+        .ok_or_else(|| anyhow::anyhow!("fixture stderr was not piped"))?;
+    let stdout_task = tokio::spawn(async move {
+        let mut buf = String::new();
+        stdout.read_to_string(&mut buf).await?;
+        Ok(buf)
+    });
+    let stderr_task = tokio::spawn(async move {
+        let mut buf = String::new();
+        stderr.read_to_string(&mut buf).await?;
+        Ok(buf)
+    });
+    tokio::time::sleep(Duration::from_millis(500)).await;
+    Ok(LoggedTarget {
+        child,
+        pid,
+        stdout_task,
+        stderr_task,
+    })
+}
+
+#[tokio::test]
+async fn test_post_call_entry_value_recovers_state_members_at_runtime() -> anyhow::Result<()> {
+    init();
+    if !fixture_compiler_available(FixtureCompiler::ClangDwarf5) {
+        eprintln!("Skipping entry_value runtime test because clang is unavailable");
+        return Ok(());
+    }
+
+    let binary_path = compile_entry_value_recovery_program_clang()?;
+    let analyzer = ghostscope_dwarf::DwarfAnalyzer::from_exec_path(&binary_path).await?;
+    let addrs = analyzer.lookup_addresses_by_source_line(FIXTURE_SOURCE, POST_CALL_TRACE_LINE);
+    anyhow::ensure!(
+        !addrs.is_empty(),
+        "No DWARF addresses found for {FIXTURE_SOURCE}:{POST_CALL_TRACE_LINE}"
+    );
+
+    let target = spawn_logged_target(&binary_path).await?;
+    let script = format!(
+        "trace {FIXTURE_SOURCE}:{POST_CALL_TRACE_LINE} {{\n    print \"POSTCALL:{{}}:{{}}\", state.total_bytes, state.stream_id;\n}}\n"
+    );
+    let (exit_code, ghostscope_stdout, ghostscope_stderr) = GhostscopeRunner::new()
+        .with_script(&script)
+        .with_pid(target.pid)
+        .timeout_secs(4)
+        .enable_sysmon_shared_lib(false)
+        .run()
+        .await?;
+    let (target_stdout, target_stderr) = target.terminate_and_collect().await?;
+
+    if should_skip_for_ebpf_env(exit_code, &ghostscope_stderr) {
+        return Ok(());
+    }
+
+    assert_eq!(
+        exit_code, 0,
+        "ghostscope stderr={ghostscope_stderr} ghostscope stdout={ghostscope_stdout} target stderr={target_stderr}"
+    );
+    assert!(
+        !ghostscope_stdout.contains("ExprError"),
+        "Expected exact post-call entry_value recovery. STDOUT: {ghostscope_stdout}\nSTDERR: {ghostscope_stderr}"
+    );
+    assert!(
+        !ghostscope_stdout.contains("<optimized out>"),
+        "Post-call entry_value should not be optimized out. STDOUT: {ghostscope_stdout}\nSTDERR: {ghostscope_stderr}"
+    );
+
+    let actual_re = Regex::new(r"ACTUAL:([0-9-]+):([0-9-]+):([0-9-]+):([0-9-]+)")?;
+    let mut actual_by_seed = HashMap::new();
+    for caps in actual_re.captures_iter(&target_stdout) {
+        actual_by_seed.insert(
+            caps[1].parse::<i64>()?,
+            (
+                caps[2].parse::<i64>()?,
+                caps[3].parse::<i64>()?,
+                caps[4].parse::<i64>()?,
+            ),
+        );
+    }
+    anyhow::ensure!(
+        !actual_by_seed.is_empty(),
+        "fixture stdout did not contain ACTUAL lines: {target_stdout}"
+    );
+
+    let trace_re = Regex::new(r"POSTCALL:([0-9-]+):([0-9-]+)")?;
+    let mut seen = 0;
+    for caps in trace_re.captures_iter(&ghostscope_stdout) {
+        let total_bytes = caps[1].parse::<i64>()?;
+        let stream_id = caps[2].parse::<i64>()?;
+        assert!(
+            actual_by_seed
+                .values()
+                .any(|actual| actual.0 == total_bytes && actual.1 == stream_id),
+            "missing ACTUAL record for total_bytes={total_bytes}, stream_id={stream_id}; target stdout={target_stdout}"
+        );
+        seen += 1;
+    }
+
+    assert!(
+        seen >= 2,
+        "Expected multiple post-call trace events. GhostScope STDOUT: {ghostscope_stdout}\nTarget STDOUT: {target_stdout}"
+    );
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_recover_caller_frame_exposes_pc_and_callee_saved_steps() -> anyhow::Result<()> {
+    init();
+    if !fixture_compiler_available(FixtureCompiler::ClangDwarf5) {
+        eprintln!("Skipping caller-frame recovery test because clang is unavailable");
+        return Ok(());
+    }
+
+    let binary_path = compile_entry_value_recovery_program_clang()?;
+    let analyzer = ghostscope_dwarf::DwarfAnalyzer::from_exec_path(&binary_path).await?;
+    let addrs = analyzer.lookup_addresses_by_source_line(FIXTURE_SOURCE, POST_CALL_TRACE_LINE);
+    anyhow::ensure!(
+        !addrs.is_empty(),
+        "No DWARF addresses found for {FIXTURE_SOURCE}:{POST_CALL_TRACE_LINE}"
+    );
+
+    let recovery = analyzer
+        .recover_caller_frame(&addrs[0], &[3, 16])?
+        .ok_or_else(|| anyhow::anyhow!("no caller-frame recovery returned"))?;
+
+    assert_eq!(recovery.return_address_register, 16);
+    assert!(
+        recovery.caller_pc_steps.iter().any(|step| matches!(
+            step,
+            ComputeStep::Dereference {
+                size: MemoryAccessSize::U64
+            }
+        )),
+        "caller_pc_steps should load the caller PC from memory: {:?}",
+        recovery.caller_pc_steps
+    );
+    assert!(
+        recovery
+            .caller_pc_steps
+            .iter()
+            .any(|step| matches!(step, ComputeStep::PushConstant(_))),
+        "caller_pc_steps should include a CFA-relative offset: {:?}",
+        recovery.caller_pc_steps
+    );
+    let rbx_steps = recovery
+        .register_recovery_steps
+        .get(&3)
+        .ok_or_else(|| anyhow::anyhow!("missing rbx recovery steps"))?;
+    assert!(
+        rbx_steps.iter().any(|step| matches!(
+            step,
+            ComputeStep::Dereference {
+                size: MemoryAccessSize::U64
+            }
+        )),
+        "rbx should recover from the caller stack slot at the post-call PC: {rbx_steps:?}"
+    );
+    assert_eq!(
+        recovery.register_recovery_steps.get(&16),
+        Some(&recovery.caller_pc_steps),
+        "requesting the return-address register should reuse caller_pc_steps"
+    );
+
+    Ok(())
+}

e2e-tests/tests/fixtures/entry_value_recovery_program/Makefile

@@ -0,0 +1,18 @@
+CC ?= gcc
+BASE_CFLAGS = -Wall -Wextra -g
+CFLAGS ?= $(BASE_CFLAGS) -O3
+BINARY ?= entry_value_recovery_program
+OBJ ?= $(BINARY).o
+
+all: $(BINARY)
+
+$(BINARY): $(OBJ)
+	$(CC) $(CFLAGS) -o $@ $(OBJ)
+
+$(OBJ): entry_value_recovery_program.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+	rm -f *.o entry_value_recovery_program entry_value_recovery_program_clang_dwarf5
+
+.PHONY: all clean

e2e-tests/tests/fixtures/entry_value_recovery_program/entry_value_recovery_program.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <unistd.h>
+
+struct EntryState {
+    int total_bytes;
+    int stream_id;
+};
+
+static struct EntryState g_states[2] = {
+    {10, 8},
+    {20, 9},
+};
+
+__attribute__((noinline)) static int touch(int x, struct EntryState *state) {
+    asm volatile("" : : "r"(state) : "memory");
+    return x * 3;
+}
+
+__attribute__((noinline)) static int wrapper_state(int seed, struct EntryState *state) {
+    int combined = touch(seed, state);
+    int after_call = state->total_bytes + combined;
+    if (after_call & 1) {
+        after_call += state->stream_id;
+    }
+    asm volatile("" ::: "rbx", "memory");
+    asm volatile("" : "+r"(after_call) :: "memory");
+    return after_call;
+}
+
+int main(void) {
+    volatile int sink = 0;
+    int i = 1;
+
+    setvbuf(stdout, NULL, _IONBF, 0);
+
+    while (i < 20000) {
+        struct EntryState *state = &g_states[i & 1];
+        int result = wrapper_state(i, state);
+        printf("ACTUAL:%d:%d:%d:%d\n", i, state->total_bytes, state->stream_id, result);
+        sink = result;
+        i++;
+        usleep(10000);
+    }
+
+    return sink == 42 ? 0 : 0;
+}