feat(exec-harness): embed the preload library in the binary

Author: GuillaumeLagrange

crates/exec-harness/Cargo.toml

@@ -19,13 +19,11 @@ serde_json = { workspace = true }
 serde = { workspace = true }
 humantime = "2.1"
 runner-shared = { path = "../runner-shared" }
+tempfile = { workspace = true }
 
 [build-dependencies]
 cargo_metadata = "0.19"
 cc = "1"
 
-[dev-dependencies]
-tempfile = { workspace = true }
-
 [package.metadata.dist]
 targets = ["aarch64-unknown-linux-musl", "x86_64-unknown-linux-musl"]

crates/exec-harness/build.rs

@@ -36,6 +36,9 @@ const PRELOAD_CONSTANTS: PreloadConstants = PreloadConstants {
     integration_version: "4.2.0",
 };
 
+/// Filename for the preload shared library.
+const PRELOAD_LIB_FILENAME: &str = "libcodspeed_preload.so";
+
 /// Paths required to build the preload shared library.
 struct PreloadBuildPaths {
     /// Path to the preload C source file (codspeed_preload.c).
@@ -65,6 +68,7 @@ fn main() {
         "cargo:rustc-env=CODSPEED_INTEGRATION_VERSION={}",
         PRELOAD_CONSTANTS.integration_version
     );
+    println!("cargo:rustc-env=CODSPEED_PRELOAD_LIB_FILENAME={PRELOAD_LIB_FILENAME}");
 
     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
@@ -81,16 +85,10 @@ fn main() {
         preload_c: manifest_dir.join("preload/codspeed_preload.c"),
         core_c: instrument_hooks_dir.join("dist/core.c"),
         includes_dir: instrument_hooks_dir.join("includes"),
-        output_lib: out_dir.join("libcodspeed_preload.so"),
+        output_lib: out_dir.join(PRELOAD_LIB_FILENAME),
     };
-    paths.check_all_exist();
+    paths.check_sources_exist();
     build_shared_library(&paths, &PRELOAD_CONSTANTS);
-
-    // Export the library path for use by the main crate
-    println!(
-        "cargo:rustc-env=CODSPEED_PRELOAD_LIB_PATH={}",
-        paths.output_lib.display()
-    );
 }
 
 /// Build the shared library using the cc crate
@@ -173,7 +171,7 @@ fn find_codspeed_instrument_hooks_dir() -> PathBuf {
 impl PreloadBuildPaths {
     /// Verify that all required source files and directories exist.
     /// Panics with a descriptive message if any path is missing.
-    fn check_all_exist(&self) {
+    fn check_sources_exist(&self) {
         if !self.core_c.exists() {
             panic!(
                 "core.c not found at {}. Make sure the codspeed crate is available.",

crates/exec-harness/src/analysis.rs

@@ -4,7 +4,10 @@ use crate::BenchmarkCommand;
 use crate::constants;
 use crate::uri;
 use codspeed::instrument_hooks::InstrumentHooks;
+use std::io::Write;
+use std::os::unix::fs::PermissionsExt;
 use std::process::Command;
+use std::sync::OnceLock;
 
 pub fn perform(commands: Vec<BenchmarkCommand>) -> Result<()> {
     let hooks = InstrumentHooks::instance();
@@ -30,19 +33,63 @@ pub fn perform(commands: Vec<BenchmarkCommand>) -> Result<()> {
     Ok(())
 }
 
-/// Path to the preload library built during compilation.
+/// Filename for the preload shared library.
+const PRELOAD_LIB_FILENAME: &str = env!("CODSPEED_PRELOAD_LIB_FILENAME");
+
+/// The preload library binary embedded at compile time.
 /// This library is used for LD_PRELOAD-based instrumentation injection.
-pub const PRELOAD_LIB_PATH: &str = env!("CODSPEED_PRELOAD_LIB_PATH");
+const PRELOAD_LIB_BYTES: &[u8] = include_bytes!(concat!(
+    env!("OUT_DIR"),
+    "/",
+    env!("CODSPEED_PRELOAD_LIB_FILENAME")
+));
+
+/// Lazily initialized path to the extracted preload library.
+static PRELOAD_LIB_PATH: OnceLock<std::path::PathBuf> = OnceLock::new();
+
+/// Extracts the preload library to a temp file and returns the path.
+fn extract_preload_lib() -> Result<std::path::PathBuf> {
+    let lib_path = std::env::temp_dir().join(PRELOAD_LIB_FILENAME);
+
+    let mut file = std::fs::File::create(&lib_path)
+        .context("Failed to create temp file for preload library")?;
+
+    file.write_all(PRELOAD_LIB_BYTES)
+        .context("Failed to write preload library to temp file")?;
+
+    // Make the library executable
+    let mut permissions = file
+        .metadata()
+        .context("Failed to get temp file metadata")?
+        .permissions();
+    permissions.set_mode(0o755);
+    file.set_permissions(permissions)
+        .context("Failed to set temp file permissions")?;
+
+    Ok(lib_path)
+}
+
+/// Returns the path to the preload library, extracting it to a temp file if needed.
+fn get_preload_lib_path() -> Result<&'static std::path::Path> {
+    if let Some(path) = PRELOAD_LIB_PATH.get() {
+        return Ok(path);
+    }
+
+    let path = extract_preload_lib()?;
+    Ok(PRELOAD_LIB_PATH.get_or_init(|| path))
+}
 
 pub fn perform_with_valgrind(commands: Vec<BenchmarkCommand>) -> Result<()> {
+    let preload_lib_path = get_preload_lib_path()?;
+
     for benchmark_cmd in commands {
         let name_and_uri = uri::generate_name_and_uri(&benchmark_cmd.name, &benchmark_cmd.command);
         name_and_uri.print_executing();
 
         let mut cmd = Command::new(&benchmark_cmd.command[0]);
         cmd.args(&benchmark_cmd.command[1..]);
         // Use LD_PRELOAD to inject instrumentation into the child process
-        cmd.env("LD_PRELOAD", PRELOAD_LIB_PATH);
+        cmd.env("LD_PRELOAD", preload_lib_path);
         cmd.env(constants::URI_ENV, &name_and_uri.uri);
 
         let status = cmd.status().context("Failed to execute command")?;