feat: disable ASLR for walltime/memory and seed Go's global math/rand

crates/runner-shared/src/runtime_env/go.rs

@@ -0,0 +1,34 @@
+const GODEBUG: &str = "GODEBUG";
+/// Starts the global `math/rand` source from `Seed(1)` instead of a random seed.
+const RANDAUTOSEED_OFF: &str = "randautoseed=0";
+
+/// Go env:
+/// - `GODEBUG=randautoseed=0`: deterministic global `math/rand` in every mode.
+pub(super) fn env() -> Vec<(&'static str, String)> {
+    let user_godebug = std::env::var(GODEBUG).ok();
+    vec![(GODEBUG, godebug(user_godebug.as_deref()))]
+}
+
+/// Prepends our settings to the user's `GODEBUG`. Go uses the last occurrence
+/// of a setting, so an explicit `randautoseed` from the user still wins.
+fn godebug(user_godebug: Option<&str>) -> String {
+    match user_godebug {
+        Some(user) if !user.is_empty() => format!("{RANDAUTOSEED_OFF},{user}"),
+        _ => RANDAUTOSEED_OFF.to_owned(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn keeps_user_settings_after_ours() {
+        assert_eq!(godebug(None), "randautoseed=0");
+        assert_eq!(godebug(Some("")), "randautoseed=0");
+        assert_eq!(
+            godebug(Some("gctrace=1,randautoseed=1")),
+            "randautoseed=0,gctrace=1,randautoseed=1"
+        );
+    }
+}

crates/runner-shared/src/runtime_env/mod.rs

@@ -1,5 +1,6 @@
 use crate::measurement_mode::MeasurementMode;
 
+mod go;
 mod java;
 mod python;
 
@@ -10,5 +11,6 @@ pub fn env(mode: MeasurementMode) -> Vec<(&'static str, String)> {
     let mut env = vec![(RUNNER_MODE_ENV, mode.runner_mode_env_value().to_owned())];
     env.extend(python::env(mode));
     env.extend(java::env(mode));
+    env.extend(go::env());
     env
 }

src/executor/helpers/aslr.rs

@@ -0,0 +1,61 @@
+//! Disables ASLR for benchmark processes, so the memory layout and address-seeded
+//! hashes (e.g. abseil's `absl::Hash`) stay the same across runs.
+
+use crate::executor::helpers::command::CommandBuilder;
+use crate::prelude::*;
+use std::env::consts::ARCH;
+use std::process::{Command, Stdio};
+use std::sync::LazyLock;
+
+pub const SETARCH: &str = "setarch";
+pub const ADDR_NO_RANDOMIZE_FLAG: &str = "--addr-no-randomize";
+
+/// Wraps `cmd` in `setarch <arch> --addr-no-randomize`.
+///
+/// The kernel clears the flag when exec'ing setuid or file-capability binaries
+/// (`sudo`, `memtrack`), so this must wrap the innermost benchmark command.
+///
+/// Leaves `cmd` unchanged off Linux, or when `setarch` fails, e.g. because
+/// Docker's default seccomp profile blocks `personality(ADDR_NO_RANDOMIZE)`.
+pub fn wrap_with_aslr_disabled(cmd: &mut CommandBuilder) {
+    if !can_disable_aslr() {
+        return;
+    }
+    cmd.wrap(SETARCH, [ARCH, ADDR_NO_RANDOMIZE_FLAG]);
+}
+
+/// [`wrap_with_aslr_disabled`] for a shell command string, for callers that run
+/// their command through a shell. Returns `command` unchanged on the same
+/// conditions, so no extra shell is spawned when ASLR stays on.
+pub fn shell_command_with_aslr_disabled(command: String) -> String {
+    if !can_disable_aslr() {
+        return command;
+    }
+    shell_words::join([
+        SETARCH,
+        ARCH,
+        ADDR_NO_RANDOMIZE_FLAG,
+        "bash",
+        "-c",
+        &command,
+    ])
+}
+
+fn can_disable_aslr() -> bool {
+    cfg!(target_os = "linux") && *CAN_DISABLE_ASLR
+}
+
+static CAN_DISABLE_ASLR: LazyLock<bool> = LazyLock::new(|| {
+    let can_disable = Command::new(SETARCH)
+        .args([ARCH, ADDR_NO_RANDOMIZE_FLAG, "true"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .is_ok_and(|status| status.success());
+    if !can_disable {
+        warn!(
+            "Failed to disable ASLR with `{SETARCH} {ARCH} {ADDR_NO_RANDOMIZE_FLAG}`, memory addresses will vary between runs"
+        );
+    }
+    can_disable
+});

src/executor/helpers/mod.rs

@@ -1,4 +1,5 @@
 pub mod apt;
+pub mod aslr;
 #[cfg(target_os = "linux")]
 pub mod capabilities;
 pub mod command;

src/executor/memory/executor.rs

@@ -2,6 +2,7 @@ use crate::executor::ExecutorName;
 use crate::executor::ExecutorSupport;
 use crate::executor::PrivilegeStatus;
 use crate::executor::ToolStatus;
+use crate::executor::helpers::aslr::shell_command_with_aslr_disabled;
 use crate::executor::helpers::command::CommandBuilder;
 use crate::executor::helpers::env::{build_path_env, get_base_injected_env};
 use crate::executor::helpers::get_bench_command::get_bench_command;
@@ -58,9 +59,11 @@ impl MemoryExecutor {
         let (ipc_server, server_name) = ipc::IpcOneShotServer::new()?;
 
         // A file-capability binary runs in glibc secure-execution mode, which strips
-        // LD_* variables. The forwarded environment has to be re-sourced below that
-        // boundary, inside the benchmark, to survive.
-        let bench_command = get_bench_command(&execution_context.config)?;
+        // LD_* variables and clears the ASLR personality flag. The forwarded
+        // environment and `setarch` have to sit below that boundary, inside the
+        // benchmark, to survive.
+        let bench_command =
+            shell_command_with_aslr_disabled(get_bench_command(&execution_context.config)?);
         let (bench_command, env_file) = prefix_command_with_env(&bench_command, &extra_env)?;
 
         // Build the memtrack command

src/executor/valgrind/measure.rs

@@ -1,6 +1,7 @@
 use crate::executor::ExecutorConfig;
 use crate::executor::RunnerMode;
 use crate::executor::config::SimulationTool;
+use crate::executor::helpers::aslr::{ADDR_NO_RANDOMIZE_FLAG, SETARCH};
 use crate::executor::helpers::env::{build_path_env, get_base_injected_env};
 use crate::executor::helpers::get_bench_command::get_bench_command;
 use crate::executor::helpers::run_command_with_log_pipe::run_command_with_log_pipe;
@@ -130,8 +131,8 @@ pub async fn measure(
     }
 
     // Create the command
-    let mut cmd = Command::new("setarch");
-    cmd.arg(ARCH).arg("--addr-no-randomize");
+    let mut cmd = Command::new(SETARCH);
+    cmd.arg(ARCH).arg(ADDR_NO_RANDOMIZE_FLAG);
     // Configure the environment
     cmd.envs(get_base_injected_env(
         RunnerMode::Simulation,

src/executor/wall_time/executor.rs

@@ -7,6 +7,7 @@ use crate::executor::Executor;
 use crate::executor::ExecutorConfig;
 use crate::executor::ToolStatus;
 use crate::executor::config::WalltimeProfiler;
+use crate::executor::helpers::aslr::wrap_with_aslr_disabled;
 use crate::executor::helpers::command::CommandBuilder;
 use crate::executor::helpers::env::{build_path_env, get_base_injected_env};
 use crate::executor::helpers::get_bench_command::get_bench_command;
@@ -81,6 +82,7 @@ impl WallTimeExecutor {
 
         let mut bench_cmd = CommandBuilder::new("bash");
         bench_cmd.arg(script_file.path());
+        wrap_with_aslr_disabled(&mut bench_cmd);
         let (mut bench_cmd, env_file) = wrap_with_env(bench_cmd, &extra_env)?;
 
         if let Some(cwd) = &config.working_directory {