feat(runner): improve error handling for valgrind

Author: not-matthias

src/run/runner/valgrind/measure.rs

@@ -9,8 +9,12 @@ use crate::run::{config::Config, instruments::mongo_tracer::MongoTracer};
 use lazy_static::lazy_static;
 use std::env;
 use std::fs::canonicalize;
+use std::io::Write;
+use std::os::unix::fs::PermissionsExt;
+use std::os::unix::process::ExitStatusExt;
 use std::path::Path;
 use std::{env::consts::ARCH, process::Command};
+use tempfile::TempPath;
 
 lazy_static! {
     static ref VALGRIND_BASE_ARGS: Vec<String> = {
@@ -42,6 +46,63 @@ lazy_static! {
     };
 }
 
+/// Creates the command that executes the specified command safely.
+///
+/// # Returns
+///
+/// A tuple containing:
+/// 1. The command to execute
+/// 2. The path to the wrapper shell script file
+/// 3. The path to the file containing the exit code
+fn safe_run_cmd(to_execute: &str) -> anyhow::Result<(String, TempPath, TempPath)> {
+    const WRAPPER_SCRIPT: &str = r#"
+        #!/bin/sh
+
+        safe_run()
+        {
+            (eval $1)
+            status=$?
+            echo -n "$status" > "$2"
+        }
+
+        # Args:
+        # 1. Cmd that should be executed
+        # 2. File to write the status code to
+        if [ "$#" -ne 2 ]; then
+            echo "Usage: $0 <cmd> <file>"
+            exit 1
+        fi
+
+        safe_run "$1" "$2"
+        "#;
+
+    // The command is wrapped in a shell script, which executes it in a
+    // subprocess and then writes the exit code to a file. The process will
+    // always exit with status code 0, unless valgrind fails.
+    let script_path = {
+        let rwx = std::fs::Permissions::from_mode(0o777);
+        let mut script_file = tempfile::Builder::new()
+            .suffix(".sh")
+            .permissions(rwx)
+            .tempfile()?;
+        script_file.write_all(WRAPPER_SCRIPT.as_bytes())?;
+
+        // Note: We have to convert the fiel to a path to be able to execute it.
+        // Otherwise this will fail with 'File is busy' error.
+        script_file.into_temp_path()
+    };
+
+    let cmd_status_path = tempfile::NamedTempFile::new().unwrap().into_temp_path();
+    let run_cmd = format!(
+        "{} \"{}\" \"{}\"",
+        script_path.to_str().unwrap(),
+        to_execute,
+        cmd_status_path.to_str().unwrap()
+    );
+
+    Ok((run_cmd, script_path, cmd_status_path))
+}
+
 pub fn measure(
     config: &Config,
     profile_folder: &Path,
@@ -84,9 +145,9 @@ pub fn measure(
         )
         .arg(format!("--callgrind-out-file={}", profile_path.to_str().unwrap()).as_str())
         .arg(format!("--log-file={}", log_path.to_str().unwrap()).as_str());
-
-    // Set the command to execute
-    cmd.args(["sh", "-c", get_bench_command(config)?.as_str()]);
+    // Set the command to execute:
+    let (run_cmd, _script, cmd_status_file) = safe_run_cmd(get_bench_command(config)?.as_str())?;
+    cmd.args(["sh", "-c", &run_cmd]);
 
     // TODO: refactor and move this to the `Instruments` struct
     if let Some(mongo_tracer) = mongo_tracer {
@@ -96,9 +157,62 @@ pub fn measure(
     debug!("cmd: {:?}", cmd);
     let status = run_command_with_log_pipe(cmd)
         .map_err(|e| anyhow!("failed to execute the benchmark process. {}", e))?;
+    let cmd_status = {
+        let content = std::fs::read_to_string(&cmd_status_file)?;
+        content.parse::<u32>()?
+    };
+
+    debug!(
+        "Valgrind exit code = {:?}, Valgrind signal = {:?}, Program exit code = {}",
+        status.code(),
+        status.signal(),
+        cmd_status
+    );
+
+    // Check the valgrind exit code
     if !status.success() {
-        bail!("failed to execute the benchmark process");
+        let valgrind_log = profile_folder.join("valgrind.log");
+        let valgrind_log = std::fs::read_to_string(&valgrind_log).unwrap_or_default();
+        debug!("valgrind.log: {}", valgrind_log);
+
+        bail!("failed to execute valgrind");
+    }
+
+    // Check the exit code which was written to the file by the wrapper script.
+    if cmd_status != 0 {
+        bail!(
+            "failed to execute the benchmark process, exit code: {}",
+            cmd_status
+        );
     }
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn safe_run(to_execute: &str) -> String {
+        let (run_cmd, _script, out_status) = safe_run_cmd(to_execute).unwrap();
+
+        let mut cmd = Command::new("sh");
+        cmd.args(["-c", &run_cmd]);
+
+        assert!(cmd.output().unwrap().status.success());
+
+        std::fs::read_to_string(out_status).unwrap()
+    }
+
+    #[test]
+    fn test_run_wrapper_script() {
+        let output = safe_run("ls");
+        assert_eq!(output, "0");
+
+        let output = safe_run("exit 1");
+        assert_eq!(output, "1");
+
+        let output = safe_run("exit 42");
+        assert_eq!(output, "42");
+    }
+}