Avoid double-caching when ccache is installed in PATH

On Linux, ccache is typically installed in $PATH as /usr/lib64/ccache/g++
or similar. If we keep it there, all compilations will be cached by both
ccache and sccache.

While the user could easily disable ccache with CCACHE_DISABLE, it's
reasonable to assume many will forget and will have their disk space
doubly consumed by both caches. Better to recognize this and disable
ccache under sccache.

This patch does this by removing the ccache binary paths from $PATH.
The check is fuzzy - any directory that has a `ccache` component is
removed. It's assumed that people won't have directories with such
names in $PATH that are not ccache masquarade directories.

Fixes #2519

Author: avikivity

src/compiler/compiler.rs

@@ -35,7 +35,7 @@ use crate::dist::pkg;
 use crate::lru_disk_cache;
 use crate::mock_command::{CommandChild, CommandCreatorSync, RunCommand, exit_status};
 use crate::server;
-use crate::util::{fmt_duration_as_secs, run_input_output};
+use crate::util::{filter_ccache_from_path, fmt_duration_as_secs, run_input_output};
 use crate::{counted_array, dist};
 use async_trait::async_trait;
 use filetime::FileTime;
@@ -194,10 +194,13 @@ impl CompileCommandImpl for SingleCompileCommand {
             env_vars,
             cwd,
         } = self;
+        // Filter out ccache directories from PATH to avoid double-caching
+        // when ccache is also installed on the system.
+        let env_vars = filter_ccache_from_path(env_vars.to_vec());
         let mut cmd = creator.clone().new_command_sync(executable);
         cmd.args(arguments)
             .env_clear()
-            .envs(env_vars.to_vec())
+            .envs(env_vars)
             .current_dir(cwd);
         run_input_output(cmd, None).await
     }
@@ -1662,6 +1665,10 @@ compiler_version=__VERSION__
     .to_vec();
     let (tempdir, src) = write_temp_file(&pool, "testfile.c".as_ref(), test).await?;
 
+    // Filter out ccache directories from PATH to avoid double-caching
+    // when ccache is also installed on the system.
+    let env = filter_ccache_from_path(env);
+
     let executable = executable.as_ref();
     let mut cmd = creator.clone().new_command_sync(executable);
     cmd.stdout(Stdio::piped())

src/compiler/nvcc.rs

@@ -25,7 +25,7 @@ use crate::compiler::{
 use crate::mock_command::{
     CommandChild, CommandCreator, CommandCreatorSync, ExitStatusValue, RunCommand, exit_status,
 };
-use crate::util::{OsStrExt, run_input_output};
+use crate::util::{OsStrExt, filter_ccache_from_path, run_input_output};
 use crate::{counted_array, dist, protocol, server};
 use async_trait::async_trait;
 use fs::File;
@@ -181,6 +181,10 @@ impl CCompilerImpl for Nvcc {
             _ => Err(anyhow!("PCH not supported by nvcc")),
         }?;
 
+        // Filter out ccache directories from PATH to avoid double-caching
+        // when ccache is also installed on the system.
+        let env_vars = filter_ccache_from_path(env_vars.clone());
+
         let initialize_cmd_and_args = || {
             let mut command = creator.clone().new_command_sync(executable);
             command
@@ -913,7 +917,7 @@ async fn select_nvcc_subcommands<T, F>(
     creator: &T,
     executable: &Path,
     cwd: &Path,
-    env_vars: &mut Vec<(OsString, OsString)>,
+    env_vars: &mut [(OsString, OsString)],
     remap_filenames: bool,
     arguments: &[OsString],
     select_subcommand: F,
@@ -938,13 +942,17 @@ where
         );
     }
 
+    // Filter out ccache directories from PATH to avoid double-caching
+    // when ccache is also installed on the system.
+    let mut env_vars = filter_ccache_from_path(env_vars.to_vec());
+
     let mut nvcc_dryrun_cmd = creator.clone().new_command_sync(executable);
 
     nvcc_dryrun_cmd
         .args(&[arguments, &["--dryrun".into(), "--keep".into()][..]].concat())
         .env_clear()
         .current_dir(cwd)
-        .envs(env_vars.to_vec());
+        .envs(env_vars.clone());
 
     let nvcc_dryrun_output = run_input_output(nvcc_dryrun_cmd, None).await?;
 
@@ -1257,14 +1265,18 @@ where
             );
         }
 
+        // Filter out ccache directories from PATH to avoid double-caching
+        // when ccache is also installed on the system.
+        let env_vars = filter_ccache_from_path(env_vars.to_vec());
+
         let out = match cacheable {
             Cacheable::No => {
                 let mut cmd = creator.clone().new_command_sync(exe);
 
                 cmd.args(args)
                     .current_dir(cwd)
                     .env_clear()
-                    .envs(env_vars.to_vec());
+                    .envs(env_vars.clone());
 
                 run_input_output(cmd, None)
                     .await
@@ -1275,11 +1287,11 @@ where
                 let args = dist::strings_to_osstrings(args);
 
                 match srvc
-                    .compiler_info(exe.clone(), cwd.to_owned(), &args, env_vars)
+                    .compiler_info(exe.clone(), cwd.to_owned(), &args, &env_vars)
                     .await
                 {
                     Err(err) => error_to_output(err),
-                    Ok(compiler) => match compiler.parse_arguments(&args, cwd, env_vars) {
+                    Ok(compiler) => match compiler.parse_arguments(&args, cwd, &env_vars) {
                         CompilerArguments::NotCompilation => Err(anyhow!("Not compilation")),
                         CompilerArguments::CannotCache(why, extra_info) => Err(extra_info
                             .map_or_else(

src/util.rs

@@ -1015,11 +1015,125 @@ pub fn num_cpus() -> usize {
     std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get)
 }
 
+/// Filter out ccache directories from PATH environment variable.
+///
+/// This prevents double-caching when ccache is installed and has
+/// /usr/lib/ccache or /usr/lib64/ccache (or similar) in PATH, since those
+/// directories contain wrapper scripts that would call ccache.
+pub fn filter_ccache_from_path(env_vars: Vec<(OsString, OsString)>) -> Vec<(OsString, OsString)> {
+    use std::env;
+
+    const CCACHE_DIR_COMPONENT: &str = "ccache";
+
+    let path_contains_ccache = |value: &OsString| -> bool {
+        std::env::split_paths(value).any(|p| {
+            p.components()
+                .any(|c| c.as_os_str() == CCACHE_DIR_COMPONENT)
+        })
+    };
+
+    // First pass: check if any PATH contains ccache
+    let has_ccache = env_vars
+        .iter()
+        .any(|(key, value)| key == "PATH" && path_contains_ccache(value));
+
+    if !has_ccache {
+        return env_vars;
+    }
+
+    // Second pass: filter out ccache directories from PATH
+    env_vars
+        .into_iter()
+        .map(|(key, value)| {
+            if key == "PATH" {
+                let filtered_path = env::split_paths(&value)
+                    .filter(|p| {
+                        !p.components()
+                            .any(|c| c.as_os_str() == CCACHE_DIR_COMPONENT)
+                    })
+                    .collect::<Vec<_>>();
+                let new_value = env::join_paths(filtered_path).unwrap_or(value.clone());
+                (key, new_value)
+            } else {
+                (key, value)
+            }
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{OsStrExt, TimeMacroFinder};
+    use super::{OsStrExt, TimeMacroFinder, filter_ccache_from_path};
     use std::ffi::{OsStr, OsString};
 
+    #[test]
+    fn test_filter_ccache_from_path() {
+        use std::env;
+
+        // Create a PATH with ccache directories
+        let path_with_ccache = env::join_paths([
+            "/usr/bin",
+            "/usr/lib64/ccache",
+            "/usr/local/bin",
+            "/usr/lib/ccache",
+            "/home/user/bin",
+        ])
+        .unwrap();
+
+        let env_vars = vec![
+            (OsString::from("HOME"), OsString::from("/home/user")),
+            (OsString::from("PATH"), path_with_ccache),
+            (OsString::from("LANG"), OsString::from("en_US.UTF-8")),
+        ];
+
+        let filtered = filter_ccache_from_path(env_vars);
+
+        // Other env vars should be unchanged
+        assert_eq!(filtered.len(), 3);
+        assert_eq!(
+            filtered.iter().find(|(k, _)| k == "HOME").unwrap().1,
+            OsString::from("/home/user")
+        );
+        assert_eq!(
+            filtered.iter().find(|(k, _)| k == "LANG").unwrap().1,
+            OsString::from("en_US.UTF-8")
+        );
+
+        // PATH should have ccache directories removed
+        let new_path = &filtered.iter().find(|(k, _)| k == "PATH").unwrap().1;
+        let expected_path =
+            env::join_paths(["/usr/bin", "/usr/local/bin", "/home/user/bin"]).unwrap();
+        assert_eq!(new_path, &expected_path);
+    }
+
+    #[test]
+    fn test_filter_ccache_from_path_no_ccache() {
+        use std::env;
+
+        // Create a PATH without ccache directories
+        let path_without_ccache = env::join_paths(["/usr/bin", "/usr/local/bin"]).unwrap();
+
+        let env_vars = vec![(OsString::from("PATH"), path_without_ccache.clone())];
+
+        let filtered = filter_ccache_from_path(env_vars);
+
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].1, path_without_ccache);
+    }
+
+    #[test]
+    fn test_filter_ccache_from_path_no_path() {
+        // No PATH variable at all
+        let env_vars = vec![
+            (OsString::from("HOME"), OsString::from("/home/user")),
+            (OsString::from("LANG"), OsString::from("en_US.UTF-8")),
+        ];
+
+        let filtered = filter_ccache_from_path(env_vars.clone());
+
+        assert_eq!(filtered, env_vars);
+    }
+
     #[test]
     fn simple_starts_with() {
         let a: &OsStr = "foo".as_ref();