fix: run perf with sudo; support systemd-run for non-perf walltime

Author: not-matthias

src/run/runner/wall_time/executor.rs

@@ -5,7 +5,8 @@ use crate::run::runner::executor::Executor;
 use crate::run::runner::helpers::env::get_base_injected_env;
 use crate::run::runner::helpers::get_bench_command::get_bench_command;
 use crate::run::runner::helpers::run_command_with_log_pipe::run_command_with_log_pipe;
-use crate::run::runner::{ExecutorName, RunData, RunnerMode};
+use crate::run::runner::{ExecutorName, RunData};
+use crate::run::RunnerMode;
 use crate::run::{check_system::SystemInfo, config::Config};
 use async_trait::async_trait;
 use std::fs::canonicalize;
@@ -28,6 +29,18 @@ impl WallTimeExecutor {
             perf: use_perf.then(PerfRunner::new),
         }
     }
+
+    fn walltime_bench_cmd(config: &Config, run_data: &RunData) -> Result<String> {
+        let bench_cmd = get_bench_command(config)?;
+
+        let setenv = get_base_injected_env(RunnerMode::Walltime, &run_data.profile_folder)
+            .into_iter()
+            .map(|(env, value)| format!("--setenv={env}={value}"))
+            .join(" ");
+        let uid = nix::unistd::Uid::current().as_raw();
+        let gid = nix::unistd::Gid::current().as_raw();
+        Ok(format!("systemd-run --scope --slice=codspeed.slice --same-dir --uid={uid} --gid={gid} {setenv} -- {bench_cmd}"))
+    }
 }
 
 #[async_trait(?Send)]
@@ -51,25 +64,18 @@ impl Executor for WallTimeExecutor {
         run_data: &RunData,
         _mongo_tracer: &Option<MongoTracer>,
     ) -> Result<()> {
-        // IMPORTANT: Don't use `sh` here! We will use this pid to send signals to the
-        // spawned child process which won't work if we use a different shell.
-        let mut cmd = Command::new("bash");
-
-        cmd.envs(get_base_injected_env(
-            RunnerMode::Walltime,
-            &run_data.profile_folder,
-        ));
+        let mut cmd = Command::new("sh");
 
         if let Some(cwd) = &config.working_directory {
             let abs_cwd = canonicalize(cwd)?;
             cmd.current_dir(abs_cwd);
         }
 
-        let bench_cmd = get_bench_command(config)?;
+        let bench_cmd = Self::walltime_bench_cmd(config, run_data)?;
         let status = if let Some(perf) = &self.perf {
             perf.run(cmd, &bench_cmd).await
         } else {
-            cmd.args(["-c", &bench_cmd]);
+            cmd.args(["-c", &format!("sudo {bench_cmd}")]);
             debug!("cmd: {:?}", cmd);
 
             run_command_with_log_pipe(cmd).await

src/run/runner/wall_time/perf/mod.rs

@@ -108,22 +108,20 @@ impl PerfRunner {
                 ""
             }
         };
-        let user = nix::unistd::User::from_uid(nix::unistd::Uid::current())?.unwrap();
+
         cmd.args([
             "-c",
             &format!(
-                "perf record {quiet_flag} --user-callchains --freq=999 --switch-output --control=fifo:{},{} --delay=-1 -g --call-graph={cg_mode} --output={} -- \
-                sudo systemd-run --scope --slice=codspeed.slice --same-dir -- runuser -u {} -- {bench_cmd}",
+                "sudo perf record {quiet_flag} --user-callchains --freq=999 --switch-output --control=fifo:{},{} --delay=-1 -g --call-graph={cg_mode} --output={} -- {bench_cmd}",
                 perf_fifo.ctl_fifo_path.to_string_lossy(),
                 perf_fifo.ack_fifo_path.to_string_lossy(),
                 perf_file.path().to_string_lossy(),
-                user.name
             ),
         ]);
         debug!("cmd: {:?}", cmd);
 
-        let on_process_started = async |pid: u32| -> anyhow::Result<()> {
-            let data = Self::handle_fifo(pid, runner_fifo, perf_fifo).await?;
+        let on_process_started = async |_| -> anyhow::Result<()> {
+            let data = Self::handle_fifo(runner_fifo, perf_fifo).await?;
             let _ = self.benchmark_data.set(data);
 
             Ok(())
@@ -134,6 +132,18 @@ impl PerfRunner {
     pub async fn save_files_to(&self, profile_folder: &PathBuf) -> anyhow::Result<()> {
         let start = std::time::Instant::now();
 
+        // We ran perf with sudo, so we have to change the ownership of the perf data files
+        run_with_sudo(&[
+            "chown",
+            "-R",
+            &format!(
+                "{}:{}",
+                nix::unistd::Uid::current(),
+                nix::unistd::Gid::current()
+            ),
+            self.perf_dir.path().to_str().unwrap(),
+        ])?;
+
         // Copy the perf data files to the profile folder
         let copy_tasks = std::fs::read_dir(&self.perf_dir)?
             .filter_map(|entry| entry.ok())
@@ -194,7 +204,6 @@ impl PerfRunner {
     }
 
     async fn handle_fifo(
-        perf_pid: u32,
         mut runner_fifo: RunnerFifo,
         mut perf_fifo: PerfFifo,
     ) -> anyhow::Result<BenchmarkData> {
@@ -203,6 +212,7 @@ impl PerfRunner {
         let mut unwind_data_by_pid = HashMap::<u32, Vec<UnwindData>>::new();
         let mut integration = None;
 
+        let perf_pid = OnceCell::new();
         loop {
             let perf_ping = tokio::time::timeout(Duration::from_secs(1), perf_fifo.ping()).await;
             if let Ok(Err(_)) | Err(_) = perf_ping {
@@ -276,7 +286,22 @@ impl PerfRunner {
                     runner_fifo.send_cmd(FifoCommand::Ack).await?;
                 }
                 FifoCommand::StartBenchmark => {
-                    unsafe { libc::kill(perf_pid as i32, libc::SIGUSR2) };
+                    let perf_pid = perf_pid.get_or_init(|| {
+                        let output = std::process::Command::new("sh")
+                            .arg("-c")
+                            .arg("pidof -s perf")
+                            .output()
+                            .expect("Failed to run pidof command");
+
+                        String::from_utf8_lossy(&output.stdout)
+                            .trim()
+                            .parse::<u32>()
+                            .expect("Failed to parse perf pid")
+                    });
+
+                    // Split the perf.data file
+                    run_with_sudo(&["kill", "-USR2", &perf_pid.to_string()])?;
+
                     perf_fifo.start_events().await?;
                     runner_fifo.send_cmd(FifoCommand::Ack).await?;
                 }