wip: locking

Author: ranger-ross

src/cargo/core/compiler/build_runner/compilation_files.rs

@@ -277,6 +277,11 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
         self.layout(unit.kind).fingerprint(&dir)
     }
 
+    pub fn build_unit_lock(&self, unit: &Unit) -> PathBuf {
+        let dir = self.pkg_dir(unit);
+        self.layout(unit.kind).build_unit_lock(&dir)
+    }
+
     /// Directory where incremental output for the given unit should go.
     pub fn incremental_dir(&self, unit: &Unit) -> &Path {
         self.layout(unit.kind).incremental()

src/cargo/core/compiler/layout.rs

@@ -136,7 +136,7 @@ pub struct Layout {
     tmp: PathBuf,
     /// The lockfile for a build (`.cargo-lock`). Will be unlocked when this
     /// struct is `drop`ped.
-    _lock: FileLock,
+    _lock: Option<FileLock>,
     /// Same as `_lock` but for the build directory.
     ///
     /// Will be `None` when the build-dir and target-dir are the same path as we cannot
@@ -182,9 +182,13 @@ impl Layout {
         // For now we don't do any more finer-grained locking on the artifact
         // directory, so just lock the entire thing for the duration of this
         // compile.
-        let lock = dest.open_rw_exclusive_create(".cargo-lock", ws.gctx(), "build directory")?;
+        let lock = if !is_new_layout {
+            Some(dest.open_rw_exclusive_create(".cargo-lock", ws.gctx(), "build directory")?)
+        } else {
+            None
+        };
 
-        let build_lock = if root != build_root {
+        let build_lock = if root != build_root && !is_new_layout {
             Some(build_dest.open_rw_exclusive_create(
                 ".cargo-lock",
                 ws.gctx(),
@@ -300,6 +304,9 @@ impl Layout {
             self.build().join(pkg_dir)
         }
     }
+    pub fn build_unit_lock(&self, pkg_dir: &str) -> PathBuf {
+        self.build_unit(pkg_dir).join("lock")
+    }
     /// Fetch the artifact path.
     pub fn artifact(&self) -> &Path {
         &self.artifact

src/cargo/core/compiler/locking.rs

@@ -0,0 +1,67 @@
+use std::{
+    fs::{File, OpenOptions},
+    path::PathBuf,
+};
+
+use itertools::Itertools;
+
+use crate::core::compiler::{BuildRunner, Unit};
+
+pub struct CompilationLock {
+    /// The path to the lock file of the unit to compile
+    unit: PathBuf,
+    /// The paths to lock files of the unit's dependencies
+    dependency_units: Vec<PathBuf>,
+}
+
+impl CompilationLock {
+    pub fn new(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> Self {
+        let unit_path = build_runner.files().build_unit_lock(unit);
+
+        let dependency_units = build_runner
+            .unit_deps(unit)
+            .into_iter()
+            .map(|unit| build_runner.files().build_unit_lock(&unit.unit))
+            .collect_vec();
+
+        Self {
+            unit: unit_path,
+            dependency_units,
+        }
+    }
+
+    pub fn lock(self) -> CompilationLockGuard {
+        let unit_lock = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .append(true)
+            .open(self.unit)
+            .unwrap();
+        unit_lock.lock().unwrap();
+
+        let dependency_locks = self
+            .dependency_units
+            .into_iter()
+            .map(|d| {
+                let f = OpenOptions::new()
+                    .create(true)
+                    .write(true)
+                    .append(true)
+                    .open(d)
+                    .unwrap();
+                f.lock_shared().unwrap();
+                f
+            })
+            .collect::<Vec<_>>();
+
+        CompilationLockGuard {
+            _lock: unit_lock,
+            _dependency_locks: dependency_locks,
+        }
+    }
+}
+
+pub struct CompilationLockGuard {
+    _lock: File,
+    _dependency_locks: Vec<File>,
+}

src/cargo/core/compiler/mod.rs

@@ -45,6 +45,7 @@ pub mod future_incompat;
 pub(crate) mod job_queue;
 pub(crate) mod layout;
 mod links;
+mod locking;
 mod lto;
 mod output_depinfo;
 mod output_sbom;
@@ -95,6 +96,7 @@ use self::output_depinfo::output_depinfo;
 use self::output_sbom::build_sbom;
 use self::unit_graph::UnitDep;
 use crate::core::compiler::future_incompat::FutureIncompatReport;
+use crate::core::compiler::locking::CompilationLock;
 use crate::core::compiler::timings::SectionTiming;
 pub use crate::core::compiler::unit::{Unit, UnitInterner};
 use crate::core::manifest::TargetSourcePath;
@@ -351,7 +353,16 @@ fn rustc(
         output_options.show_diagnostics = false;
     }
     let env_config = Arc::clone(build_runner.bcx.gctx.env_config()?);
+
+    let lock = if build_runner.bcx.gctx.cli_unstable().build_dir_new_layout {
+        Some(CompilationLock::new(build_runner, unit))
+    } else {
+        None
+    };
+
     return Ok(Work::new(move |state| {
+        let _guard = lock.map(|v| v.lock());
+
         // Artifacts are in a different location than typical units,
         // hence we must assure the crate- and target-dependent
         // directory is present.