Cap the maximum hard links per file

NTFS has a limit of 1023 hard links per file, and we have no guarantees
about garbage collection latency on the disk. After a conservative
number of links, make a new file to link to and use that instead.

Author: rbtcollins

tests/mock/clitools.rs

@@ -9,7 +9,7 @@ use std::fs;
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::sync::Arc;
+use std::sync::{Arc, RwLock, RwLockWriteGuard};
 use std::time::Instant;
 
 use enum_map::{enum_map, Enum, EnumMap};
@@ -117,6 +117,15 @@ struct ConstState {
     const_dist_dir: tempfile::TempDir,
 }
 
+/// The lock to be used when creating test environments.
+///
+/// Essentially we use this in `.read()` mode to gate access to `fork()`
+/// new subprocesses, and in `.write()` mode to gate creation of new test
+/// environments. In doing this we can ensure that new test environment creation
+/// does not result in ETXTBSY because the FDs in question happen to be in
+/// newly `fork()`d but not yet `exec()`d subprocesses of other tests.
+pub static CMD_LOCK: Lazy<RwLock<usize>> = Lazy::new(|| RwLock::new(0));
+
 impl ConstState {
     fn new(const_dist_dir: tempfile::TempDir) -> Self {
         Self {
@@ -187,9 +196,9 @@ pub fn setup_test_state(test_dist_dir: tempfile::TempDir) -> (tempfile::TempDir,
     }
 
     let current_exe_path = env::current_exe().unwrap();
-    let mut exe_dir = current_exe_path.parent().unwrap();
-    if exe_dir.ends_with("deps") {
-        exe_dir = exe_dir.parent().unwrap();
+    let mut built_exe_dir = current_exe_path.parent().unwrap();
+    if built_exe_dir.ends_with("deps") {
+        built_exe_dir = built_exe_dir.parent().unwrap();
     }
     let test_dir = rustup_test::test_dir().unwrap();
 
@@ -226,17 +235,47 @@ pub fn setup_test_state(test_dist_dir: tempfile::TempDir) -> (tempfile::TempDir,
         test_root_dir: test_dir.path().to_path_buf(),
     };
 
-    let build_path = exe_dir.join(format!("rustup-init{EXE_SUFFIX}"));
+    let build_path = built_exe_dir.join(format!("rustup-init{EXE_SUFFIX}"));
 
     let rustup_path = config.exedir.join(format!("rustup{EXE_SUFFIX}"));
-    let setup_path = config.exedir.join(format!("rustup-init{EXE_SUFFIX}"));
+    // Used to create dist servers. Perhaps should only link when needed?
+    let init_path = config.exedir.join(format!("rustup-init{EXE_SUFFIX}"));
     let rustc_path = config.exedir.join(format!("rustc{EXE_SUFFIX}"));
     let cargo_path = config.exedir.join(format!("cargo{EXE_SUFFIX}"));
     let rls_path = config.exedir.join(format!("rls{EXE_SUFFIX}"));
     let rust_lldb_path = config.exedir.join(format!("rust-lldb{EXE_SUFFIX}"));
 
-    hard_link(build_path, &rustup_path).unwrap();
-    hard_link(&rustup_path, setup_path).unwrap();
+    const ESTIMATED_LINKS_PER_TEST: usize = 6 * 2;
+    // NTFS has a limit of 1023 links per file; test setup creates 6 links, and
+    // then some tests will link the cached installer to rustup/cargo etc,
+    // adding more links
+    const MAX_TESTS_PER_RUSTUP_EXE: usize = 1023 / ESTIMATED_LINKS_PER_TEST;
+    // This returning-result inner structure allows failures without poisoning
+    // cmd_lock.
+    {
+        fn link_or_copy(
+            original: &Path,
+            link: &Path,
+            lock: &mut RwLockWriteGuard<usize>,
+        ) -> io::Result<()> {
+            **lock += 1;
+            if **lock < MAX_TESTS_PER_RUSTUP_EXE {
+                hard_link(original, link)
+            } else {
+                // break the *original* so new tests form a new distinct set of
+                // links. Do this by copying to link, breaking the source,
+                // linking back.
+                **lock = 0;
+                fs::copy(original, link)?;
+                fs::remove_file(original)?;
+                hard_link(link, original)
+            }
+        }
+        let mut lock = CMD_LOCK.write().unwrap();
+        link_or_copy(&build_path, &rustup_path, &mut lock)
+    }
+    .unwrap();
+    hard_link(&rustup_path, init_path).unwrap();
     hard_link(&rustup_path, rustc_path).unwrap();
     hard_link(&rustup_path, cargo_path).unwrap();
     hard_link(&rustup_path, rls_path).unwrap();
@@ -285,7 +324,8 @@ fn create_local_update_server(self_dist: &Path, exedir: &Path, version: &str) ->
 
     fs::create_dir_all(dist_dir).unwrap();
     output_release_file(self_dist, "1", version);
-    // TODO: should this hardlink?
+    // TODO: should this hardlink since the modify-codepath presumes it has to
+    // link break?
     fs::copy(rustup_bin, dist_exe).unwrap();
 
     let root_url = format!("file://{}", self_dist.display());
@@ -693,7 +733,7 @@ impl Config {
 
         let mut retries = 8;
         let out = loop {
-            let lock = cmd_lock().read().unwrap();
+            let lock = CMD_LOCK.read().unwrap();
             let out = cmd.output();
             drop(lock);
             match out {
@@ -783,22 +823,6 @@ pub fn env<E: rustup_test::Env>(config: &Config, cmd: &mut E) {
     config.env(cmd)
 }
 
-use std::sync::RwLock;
-
-/// Returns the lock to be used when creating test environments.
-///
-/// Essentially we use this in `.read()` mode to gate access to `fork()`
-/// new subprocesses, and in `.write()` mode to gate creation of new test
-/// environments. In doing this we can ensure that new test environment creation
-/// does not result in ETXTBSY because the FDs in question happen to be in
-/// newly `fork()`d but not yet `exec()`d subprocesses of other tests.
-pub fn cmd_lock() -> &'static RwLock<()> {
-    lazy_static! {
-        static ref LOCK: RwLock<()> = RwLock::new(());
-    };
-    &LOCK
-}
-
 fn allow_inprocess<I, A>(name: &str, args: I) -> bool
 where
     I: IntoIterator<Item = A>,
@@ -1514,7 +1538,7 @@ fn create_custom_toolchains(customdir: &Path) {
     }
 }
 
-pub fn hard_link<A, B>(a: A, b: B) -> io::Result<()>
+pub fn hard_link<A, B>(original: A, link: B) -> io::Result<()>
 where
     A: AsRef<Path>,
     B: AsRef<Path>,
@@ -1526,5 +1550,5 @@ where
         }
         fs::hard_link(a, b).map(drop)
     }
-    inner(a.as_ref(), b.as_ref())
+    inner(original.as_ref(), link.as_ref())
 }