refactor: discover jitdump paths from MMAP2 records

Instead of searching hardcoded filesystem paths, extract jitdump file
paths from MMAP2 records in the perf data. This is how perf inject
finds them and works for any jitdump location.

Author: DaniPopes

src/executor/wall_time/perf/jit_dump.rs

@@ -5,7 +5,7 @@ use crate::{
 use linux_perf_data::jitdump::{JitDumpReader, JitDumpRecord};
 use runner_shared::unwind_data::{ProcessUnwindData, UnwindData};
 use std::{
-    collections::{HashMap, HashSet},
+    collections::HashMap,
     path::{Path, PathBuf},
 };
 
@@ -108,44 +108,10 @@ impl JitDump {
     }
 }
 
-/// Finds all jitdump file paths for a given PID.
+/// Converts all the `jit-<pid>.dump` into a perf-<pid>.map with symbols, and collects the unwind data.
 ///
-/// Searches in order:
-/// 1. `/tmp/jit-{pid}.dump` (standard perf jitdump location)
-/// 2. `{jitdumpdir}/.debug/jit/*/jit-{pid}.dump` where `jitdumpdir` is `$JITDUMPDIR` or `$HOME`
-///    (LLVM ORC JIT / PerfSupportPlugin location)
-fn find_jit_dumps_for_pid(pid: libc::pid_t) -> Vec<PathBuf> {
-    let name = format!("jit-{pid}.dump");
-    let mut paths = Vec::new();
-
-    // Standard perf location.
-    let tmp_path = PathBuf::from("/tmp").join(&name);
-    if tmp_path.exists() {
-        paths.push(tmp_path);
-    }
-
-    // LLVM ORC JIT location: {base}/.debug/jit/*/jit-{pid}.dump
-    // See LLVM's JITLoaderPerf.cpp for the path construction logic.
-    let base_dir = std::env::var("JITDUMPDIR")
-        .or_else(|_| std::env::var("HOME"))
-        .ok()
-        .map(PathBuf::from);
-    if let Some(base) = base_dir {
-        let jit_dir = base.join(".debug/jit");
-        if let Ok(entries) = std::fs::read_dir(&jit_dir) {
-            for entry in entries.filter_map(|e| e.ok()) {
-                let candidate = entry.path().join(&name);
-                if candidate.exists() {
-                    paths.push(candidate);
-                }
-            }
-        }
-    }
-
-    paths
-}
-
-/// Converts all the `jit-<pid>.dump` into a perf-<pid>.map with symbols, and collects the unwind data
+/// Jitdump file paths are discovered from MMAP2 records in the perf data, since JIT runtimes
+/// mmap the jitdump file and perf records the mapping with the actual path on disk.
 ///
 /// # Symbols
 /// Since a jit dump is by definition specific to a single pid, we append the harvested symbols
@@ -155,16 +121,11 @@ fn find_jit_dumps_for_pid(pid: libc::pid_t) -> Vec<PathBuf> {
 /// Unwind data is generated as a list
 pub async fn save_symbols_and_harvest_unwind_data_for_pids(
     profile_folder: &Path,
-    pids: &HashSet<libc::pid_t>,
+    jit_dump_paths_by_pid: &HashMap<libc::pid_t, Vec<PathBuf>>,
 ) -> Result<HashMap<i32, Vec<(UnwindData, ProcessUnwindData)>>> {
-    let mut jit_unwind_data_by_path = HashMap::new();
-
-    for pid in pids {
-        let paths = find_jit_dumps_for_pid(*pid);
-        if paths.is_empty() {
-            continue;
-        }
+    let mut jit_unwind_data_by_pid = HashMap::new();
 
+    for (pid, paths) in jit_dump_paths_by_pid {
         for path in paths {
             debug!("Found JIT dump file: {path:?}");
 
@@ -178,20 +139,20 @@ pub async fn save_symbols_and_harvest_unwind_data_for_pids(
 
             symbols.append_to_file(profile_folder.join(format!("perf-{pid}.map")))?;
 
-            let jit_unwind_data = match JitDump::new(path).into_unwind_data() {
+            let jit_unwind_data = match JitDump::new(path.clone()).into_unwind_data() {
                 Ok(data) => data,
                 Err(error) => {
                     warn!("Failed to convert jit dump into unwind data: {error:?}");
                     continue;
                 }
             };
 
-            jit_unwind_data_by_path
+            jit_unwind_data_by_pid
                 .entry(*pid)
                 .or_insert_with(Vec::new)
                 .extend(jit_unwind_data);
         }
     }
 
-    Ok(jit_unwind_data_by_path)
+    Ok(jit_unwind_data_by_pid)
 }

src/executor/wall_time/perf/mod.rs

@@ -300,6 +300,7 @@ impl BenchmarkData {
         let MemmapRecordsOutput {
             loaded_modules_by_path,
             tracked_pids,
+            jit_dump_paths_by_pid,
         } = {
             parse_perf_file::parse_for_memmap2(perf_file_path, pid_filter).map_err(|e| {
                 error!("Failed to parse perf file: {e}");
@@ -317,13 +318,15 @@ impl BenchmarkData {
                 error!("Failed to harvest perf maps: {e}");
                 BenchmarkDataSaveError::FailedToHarvestPerfMaps
             })?;
-        let jit_unwind_data_by_pid =
-            jit_dump::save_symbols_and_harvest_unwind_data_for_pids(path_ref, &tracked_pids)
-                .await
-                .map_err(|e| {
-                    error!("Failed to harvest jit dumps: {e}");
-                    BenchmarkDataSaveError::FailedToHarvestJitDumps
-                })?;
+        let jit_unwind_data_by_pid = jit_dump::save_symbols_and_harvest_unwind_data_for_pids(
+            path_ref,
+            &jit_dump_paths_by_pid,
+        )
+        .await
+        .map_err(|e| {
+            error!("Failed to harvest jit dumps: {e}");
+            BenchmarkDataSaveError::FailedToHarvestJitDumps
+        })?;
 
         let artifacts = save_artifacts::save_artifacts(
             path_ref,

src/executor/wall_time/perf/parse_perf_file.rs

@@ -42,6 +42,8 @@ pub struct MemmapRecordsOutput {
     /// Module symbols and the computed load bias for each pid that maps the ELF path.
     pub loaded_modules_by_path: HashMap<PathBuf, LoadedModule>,
     pub tracked_pids: HashSet<pid_t>,
+    /// Jitdump file paths discovered from MMAP2 records, keyed by PID.
+    pub jit_dump_paths_by_pid: HashMap<pid_t, Vec<PathBuf>>,
 }
 
 /// Parse the perf file at `perf_file_path` and look for MMAP2 records for the given `pids`.
@@ -53,6 +55,7 @@ pub fn parse_for_memmap2<P: AsRef<Path>>(
     mut pid_filter: PidFilter,
 ) -> Result<MemmapRecordsOutput> {
     let mut loaded_modules_by_path = HashMap::<PathBuf, LoadedModule>::new();
+    let mut jit_dump_paths_by_pid = HashMap::<pid_t, Vec<PathBuf>>::new();
 
     // 1MiB buffer
     let reader = std::io::BufReader::with_capacity(
@@ -105,6 +108,21 @@ pub fn parse_for_memmap2<P: AsRef<Path>>(
                     continue;
                 }
 
+                // Collect jitdump file paths before the PROT_EXEC filter in process_mmap2_record
+                // skips them. JIT runtimes mmap the jitdump file so perf records it.
+                if mmap2_record.path.as_slice().ends_with(b".dump") {
+                    let path = PathBuf::from(
+                        String::from_utf8_lossy(&mmap2_record.path.as_slice()).into_owned(),
+                    );
+                    if path.exists() {
+                        debug!("Found jitdump path from MMAP2 record: {path:?}");
+                        jit_dump_paths_by_pid
+                            .entry(mmap2_record.pid)
+                            .or_default()
+                            .push(path);
+                    }
+                }
+
                 process_mmap2_record(mmap2_record, &mut loaded_modules_by_path);
             }
             _ => continue,
@@ -123,6 +141,7 @@ pub fn parse_for_memmap2<P: AsRef<Path>>(
     Ok(MemmapRecordsOutput {
         loaded_modules_by_path,
         tracked_pids,
+        jit_dump_paths_by_pid,
     })
 }