Add SCCACHE_BASEDIRS support

README.md

@@ -278,12 +278,49 @@ This is most useful when using sccache for Rust compilation, as rustc supports u
 
 ---
 
+Normalizing Paths with `SCCACHE_BASEDIRS`
+-----------------------------------------
+
+By default, sccache requires absolute paths to match for cache hits. To enable cache sharing across different build directories, you can set `SCCACHE_BASEDIRS` to strip a base directory from paths before hashing:
+
+```bash
+export SCCACHE_BASEDIRS=/home/user/project
+```
+
+You can also specify multiple base directories by separating them with `|` (pipe character). When multiple directories are provided, the longest matching prefix is used:
+
+```bash
+export SCCACHE_BASEDIRS="/home/user/project|/home/user/workspace"
+```
+
+Path matching is **case-insensitive** on Windows and **case-sensitive** on other operating systems.
+
+This is similar to ccache's `CCACHE_BASEDIR` and helps when:
+* Building the same project from different directories
+* Sharing cache between CI jobs with different checkout paths
+* Multiple developers working with different username paths
+* Working with multiple project checkouts simultaneously
+
+**Note:** Only absolute paths are supported. Relative paths will be ignored with a warning.
+
+You can also configure this in the sccache config file:
+
+```toml
+# Single directory
+basedirs = ["/home/user/project"]
+
+# Or multiple directories
+basedirs = ["/home/user/project", "/home/user/workspace"]
+```
+
+---
+
 Known Caveats
 -------------
 
 ### General
 
-* Absolute paths to files must match to get a cache hit. This means that even if you are using a shared cache, everyone will have to build at the same absolute path (i.e. not in `$HOME`) in order to benefit each other. In Rust this includes the source for third party crates which are stored in `$HOME/.cargo/registry/cache` by default.
+* By default, absolute paths to files must match to get a cache hit. To work around this, use `SCCACHE_BASEDIRS` (see above) to normalize paths before hashing.
 
 ### Rust
 

docs/Configuration.md

@@ -6,6 +6,19 @@
 # If specified, wait this long for the server to start up.
 server_startup_timeout_ms = 10000
 
+# Base directory (or directories) to strip from paths for cache key computation.
+# Similar to ccache's CCACHE_BASEDIR. This enables cache hits across
+# different absolute paths when compiling the same source code.
+# Can be an array of paths. When multiple paths are provided,
+# the longest matching prefix is used.
+# Path matching is case-insensitive on Windows and case-sensitive on other OSes.
+# For example, if basedir is "/home/user/project", then paths like
+# "/home/user/project/src/main.c" will be normalized to "./src/main.c"
+# for caching purposes.
+basedirs = ["/home/user/project"]
+# Or multiple directories:
+# basedirs = ["/home/user/project", "/home/user/workspace"]
+
 [dist]
 # where to find the scheduler
 scheduler_url = "http://1.2.3.4:10600"
@@ -134,6 +147,7 @@ Note that some env variables may need sccache server restart to take effect.
 
 * `SCCACHE_ALLOW_CORE_DUMPS` to enable core dumps by the server
 * `SCCACHE_CONF` configuration file path
+* `SCCACHE_BASEDIRS` base directory (or directories) to strip from paths for cache key computation. This is similar to ccache's `CCACHE_BASEDIR` and enables cache hits across different absolute paths when compiling the same source code. Multiple directories can be separated by `|` (pipe character). When multiple directories are specified, the longest matching prefix is used. Path matching is **case-insensitive** on Windows and **case-sensitive** on other operating systems. Environment variable takes precedence over file configuration. Only absolute paths are supported; relative paths will be ignored with a warning.
 * `SCCACHE_CACHED_CONF`
 * `SCCACHE_IDLE_TIMEOUT` how long the local daemon process waits for more client requests before exiting, in seconds. Set to `0` to run sccache permanently
 * `SCCACHE_STARTUP_NOTIFY` specify a path to a socket which will be used for server completion notification

src/cache/cache.rs

@@ -381,6 +381,10 @@ pub trait Storage: Send + Sync {
         // Enable by default, only in local mode
         PreprocessorCacheModeConfig::default()
     }
+    /// Return the base directories for path normalization if configured
+    fn basedirs(&self) -> &[PathBuf] {
+        &[]
+    }
     /// Return the preprocessor cache entry for a given preprocessor key,
     /// if it exists.
     /// Only applicable when using preprocessor cache mode.
@@ -736,12 +740,35 @@ pub fn storage_from_config(
     let preprocessor_cache_mode_config = config.fallback_cache.preprocessor_cache_mode;
     let rw_mode = config.fallback_cache.rw_mode.into();
     debug!("Init disk cache with dir {:?}, size {}", dir, size);
+
+    // Validate that all basedirs are absolute paths
+    let basedirs: Vec<PathBuf> = config
+        .basedirs
+        .iter()
+        .filter_map(|p| {
+            if p.is_absolute() {
+                Some(p.clone())
+            } else {
+                warn!(
+                    "Ignoring relative basedir path: {:?}. Only absolute paths are supported.",
+                    p
+                );
+                None
+            }
+        })
+        .collect();
+
+    if !basedirs.is_empty() {
+        debug!("Using basedirs for path normalization: {:?}", basedirs);
+    }
+
     Ok(Arc::new(DiskCache::new(
         dir,
         size,
         pool,
         preprocessor_cache_mode_config,
         rw_mode,
+        basedirs,
     )))
 }
 

src/cache/disk.rs

@@ -74,6 +74,7 @@ pub struct DiskCache {
     preprocessor_cache_mode_config: PreprocessorCacheModeConfig,
     preprocessor_cache: Arc<Mutex<LazyDiskCache>>,
     rw_mode: CacheMode,
+    basedirs: Vec<PathBuf>,
 }
 
 impl DiskCache {
@@ -84,6 +85,7 @@ impl DiskCache {
         pool: &tokio::runtime::Handle,
         preprocessor_cache_mode_config: PreprocessorCacheModeConfig,
         rw_mode: CacheMode,
+        basedirs: Vec<PathBuf>,
     ) -> DiskCache {
         DiskCache {
             lru: Arc::new(Mutex::new(LazyDiskCache::Uninit {
@@ -99,6 +101,7 @@ impl DiskCache {
                 max_size,
             })),
             rw_mode,
+            basedirs,
         }
     }
 }
@@ -181,6 +184,9 @@ impl Storage for DiskCache {
     fn preprocessor_cache_mode_config(&self) -> PreprocessorCacheModeConfig {
         self.preprocessor_cache_mode_config
     }
+    fn basedirs(&self) -> &[PathBuf] {
+        &self.basedirs
+    }
     async fn get_preprocessor_cache_entry(&self, key: &str) -> Result<Option<Box<dyn ReadSeek>>> {
         let key = normalize_key(key);
         Ok(self