feat(locking): Disable locking on network file systems

Author: ranger-ross

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

@@ -10,6 +10,7 @@ use crate::core::compiler::locking::LockingMode;
 use crate::core::compiler::{self, Unit, artifact};
 use crate::util::cache_lock::CacheLockMode;
 use crate::util::errors::CargoResult;
+use crate::util::flock::is_on_nfs_mount;
 use crate::util::rlimit;
 use annotate_snippets::{Level, Message};
 use anyhow::{Context as _, bail};
@@ -748,6 +749,11 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
 pub fn determine_locking_mode(bcx: &BuildContext<'_, '_>) -> CargoResult<LockingMode> {
     let total_units = bcx.unit_graph.keys().len() as u64;
 
+    if is_on_nfs_mount(bcx.ws.build_dir().as_path_unlocked()) {
+        debug!("NFS detected. Disabling file system locking");
+        return Ok(LockingMode::None);
+    }
+
     // This is a bit arbitrary but if we do not have at least 10 times the remaining file
     // descriptors than total build units there is a chance we could hit the limit.
     // This is a fairly conservative estimate to make sure we don't hit max fd errors.

src/cargo/core/compiler/layout.rs

@@ -155,25 +155,29 @@ impl Layout {
         // directory, so just lock the entire thing for the duration of this
         // compile.
         let artifact_dir_lock = match locking_mode {
+            LockingMode::None => None,
             LockingMode::Fine => {
-                dest.open_ro_shared_create(".cargo-lock", ws.gctx(), "build directory")?
+                Some(dest.open_ro_shared_create(".cargo-lock", ws.gctx(), "build directory")?)
             }
             LockingMode::Coarse => {
-                dest.open_rw_exclusive_create(".cargo-lock", ws.gctx(), "build directory")?
+                Some(dest.open_rw_exclusive_create(".cargo-lock", ws.gctx(), "build directory")?)
             }
         };
 
         let build_dir_lock = if root != build_root {
-            Some(match locking_mode {
-                LockingMode::Fine => {
-                    build_dest.open_ro_shared_create(".cargo-lock", ws.gctx(), "build directory")?
-                }
-                LockingMode::Coarse => build_dest.open_rw_exclusive_create(
+            match locking_mode {
+                LockingMode::None => None,
+                LockingMode::Fine => Some(build_dest.open_ro_shared_create(
                     ".cargo-lock",
                     ws.gctx(),
                     "build directory",
-                )?,
-            })
+                )?),
+                LockingMode::Coarse => Some(build_dest.open_rw_exclusive_create(
+                    ".cargo-lock",
+                    ws.gctx(),
+                    "build directory",
+                )?),
+            }
         } else {
             None
         };
@@ -235,7 +239,7 @@ pub struct ArtifactDirLayout {
     timings: PathBuf,
     /// The lockfile for a build (`.cargo-lock`). Will be unlocked when this
     /// struct is `drop`ped.
-    _lock: FileLock,
+    _lock: Option<FileLock>,
 }
 
 impl ArtifactDirLayout {

src/cargo/core/compiler/locking.rs

@@ -49,6 +49,8 @@ use crate::{
 /// The locking mode that will be used for output directories.
 #[derive(Debug)]
 pub enum LockingMode {
+    /// Completely disables locking (used for filesystems that do not support locking)
+    None,
     /// Fine grain locking (Build unit level)
     Fine,
     /// Coarse grain locking (Profile level)

src/cargo/ops/cargo_clean.rs

@@ -6,6 +6,7 @@ use crate::ops;
 use crate::util::HumanBytes;
 use crate::util::edit_distance;
 use crate::util::errors::CargoResult;
+use crate::util::flock::is_on_nfs_mount;
 use crate::util::interning::InternedString;
 use crate::util::{GlobalContext, Progress, ProgressStyle};
 use anyhow::bail;
@@ -117,13 +118,17 @@ fn clean_specs(
     let target_data = RustcTargetData::new(ws, &requested_kinds)?;
     let (pkg_set, resolve) = ops::resolve_ws(ws, dry_run)?;
     let prof_dir_name = profiles.get_dir_name();
-    let host_layout = Layout::new(ws, None, &prof_dir_name, &LockingMode::Coarse)?;
+    let locking_mode = match is_on_nfs_mount(ws.build_dir().as_path_unlocked()) {
+        true => LockingMode::None,
+        false => LockingMode::Coarse,
+    };
+    let host_layout = Layout::new(ws, None, &prof_dir_name, &locking_mode)?;
     // Convert requested kinds to a Vec of layouts.
     let target_layouts: Vec<(CompileKind, Layout)> = requested_kinds
         .into_iter()
         .filter_map(|kind| match kind {
             CompileKind::Target(target) => {
-                match Layout::new(ws, Some(target), &prof_dir_name, &LockingMode::Coarse) {
+                match Layout::new(ws, Some(target), &prof_dir_name, &locking_mode) {
                     Ok(layout) => Some(Ok((kind, layout))),
                     Err(e) => Some(Err(e)),
                 }

src/cargo/util/flock.rs

@@ -427,7 +427,7 @@ fn acquire(
 }
 
 #[cfg(all(target_os = "linux", not(target_env = "musl")))]
-fn is_on_nfs_mount(path: &Path) -> bool {
+pub fn is_on_nfs_mount(path: &Path) -> bool {
     use std::ffi::CString;
     use std::mem;
     use std::os::unix::prelude::*;
@@ -445,7 +445,7 @@ fn is_on_nfs_mount(path: &Path) -> bool {
 }
 
 #[cfg(any(not(target_os = "linux"), target_env = "musl"))]
-fn is_on_nfs_mount(_path: &Path) -> bool {
+pub fn is_on_nfs_mount(_path: &Path) -> bool {
     false
 }
 

src/cargo/util/mod.rs

@@ -41,7 +41,7 @@ mod dependency_queue;
 pub mod diagnostic_server;
 pub mod edit_distance;
 pub mod errors;
-mod flock;
+pub mod flock;
 pub mod frontmatter;
 pub mod graph;
 mod hasher;