]>
Commit | Line | Data |
---|---|---|
9e0c209e SL |
1 | //! This module manages how the incremental compilation cache is represented in |
2 | //! the file system. | |
3 | //! | |
4 | //! Incremental compilation caches are managed according to a copy-on-write | |
5 | //! strategy: Once a complete, consistent cache version is finalized, it is | |
6 | //! never modified. Instead, when a subsequent compilation session is started, | |
7 | //! the compiler will allocate a new version of the cache that starts out as | |
8 | //! a copy of the previous version. Then only this new copy is modified and it | |
9 | //! will not be visible to other processes until it is finalized. This ensures | |
10 | //! that multiple compiler processes can be executed concurrently for the same | |
11 | //! crate without interfering with each other or blocking each other. | |
12 | //! | |
13 | //! More concretely this is implemented via the following protocol: | |
14 | //! | |
15 | //! 1. For a newly started compilation session, the compiler allocates a | |
16 | //! new `session` directory within the incremental compilation directory. | |
17 | //! This session directory will have a unique name that ends with the suffix | |
18 | //! "-working" and that contains a creation timestamp. | |
19 | //! 2. Next, the compiler looks for the newest finalized session directory, | |
20 | //! that is, a session directory from a previous compilation session that | |
21 | //! has been marked as valid and consistent. A session directory is | |
22 | //! considered finalized if the "-working" suffix in the directory name has | |
23 | //! been replaced by the SVH of the crate. | |
24 | //! 3. Once the compiler has found a valid, finalized session directory, it will | |
25 | //! hard-link/copy its contents into the new "-working" directory. If all | |
26 | //! goes well, it will have its own, private copy of the source directory and | |
27 | //! subsequently not have to worry about synchronizing with other compiler | |
28 | //! processes. | |
29 | //! 4. Now the compiler can do its normal compilation process, which involves | |
30 | //! reading and updating its private session directory. | |
31 | //! 5. When compilation finishes without errors, the private session directory | |
32 | //! will be in a state where it can be used as input for other compilation | |
33 | //! sessions. That is, it will contain a dependency graph and cache artifacts | |
34 | //! that are consistent with the state of the source code it was compiled | |
35 | //! from, with no need to change them ever again. At this point, the compiler | |
36 | //! finalizes and "publishes" its private session directory by renaming it | |
37 | //! from "s-{timestamp}-{random}-working" to "s-{timestamp}-{SVH}". | |
38 | //! 6. At this point the "old" session directory that we copied our data from | |
39 | //! at the beginning of the session has become obsolete because we have just | |
40 | //! published a more current version. Thus the compiler will delete it. | |
41 | //! | |
42 | //! ## Garbage Collection | |
43 | //! | |
44 | //! Naively following the above protocol might lead to old session directories | |
45 | //! piling up if a compiler instance crashes for some reason before its able to | |
46 | //! remove its private session directory. In order to avoid wasting disk space, | |
47 | //! the compiler also does some garbage collection each time it is started in | |
48 | //! incremental compilation mode. Specifically, it will scan the incremental | |
49 | //! compilation directory for private session directories that are not in use | |
50 | //! any more and will delete those. It will also delete any finalized session | |
51 | //! directories for a given crate except for the most recent one. | |
52 | //! | |
53 | //! ## Synchronization | |
54 | //! | |
55 | //! There is some synchronization needed in order for the compiler to be able to | |
56 | //! determine whether a given private session directory is not in used any more. | |
57 | //! This is done by creating a lock file for each session directory and | |
58 | //! locking it while the directory is still being used. Since file locks have | |
59 | //! operating system support, we can rely on the lock being released if the | |
60 | //! compiler process dies for some unexpected reason. Thus, when garbage | |
61 | //! collecting private session directories, the collecting process can determine | |
62 | //! whether the directory is still in use by trying to acquire a lock on the | |
63 | //! file. If locking the file fails, the original process must still be alive. | |
64 | //! If locking the file succeeds, we know that the owning process is not alive | |
65 | //! any more and we can safely delete the directory. | |
66 | //! There is still a small time window between the original process creating the | |
67 | //! lock file and actually locking it. In order to minimize the chance that | |
68 | //! another process tries to acquire the lock in just that instance, only | |
69 | //! session directories that are older than a few seconds are considered for | |
70 | //! garbage collection. | |
71 | //! | |
72 | //! Another case that has to be considered is what happens if one process | |
73 | //! deletes a finalized session directory that another process is currently | |
74 | //! trying to copy from. This case is also handled via the lock file. Before | |
75 | //! a process starts copying a finalized session directory, it will acquire a | |
76 | //! shared lock on the directory's lock file. Any garbage collecting process, | |
77 | //! on the other hand, will acquire an exclusive lock on the lock file. | |
78 | //! Thus, if a directory is being collected, any reader process will fail | |
79 | //! acquiring the shared lock and will leave the directory alone. Conversely, | |
80 | //! if a collecting process can't acquire the exclusive lock because the | |
81 | //! directory is currently being read from, it will leave collecting that | |
82 | //! directory to another process at a later point in time. | |
83 | //! The exact same scheme is also used when reading the metadata hashes file | |
84 | //! from an extern crate. When a crate is compiled, the hash values of its | |
85 | //! metadata are stored in a file in its session directory. When the | |
86 | //! compilation session of another crate imports the first crate's metadata, | |
87 | //! it also has to read in the accompanying metadata hashes. It thus will access | |
88 | //! the finalized session directory of all crates it links to and while doing | |
89 | //! so, it will also place a read lock on that the respective session directory | |
90 | //! so that it won't be deleted while the metadata hashes are loaded. | |
91 | //! | |
92 | //! ## Preconditions | |
93 | //! | |
94 | //! This system relies on two features being available in the file system in | |
95 | //! order to work really well: file locking and hard linking. | |
96 | //! If hard linking is not available (like on FAT) the data in the cache | |
97 | //! actually has to be copied at the beginning of each session. | |
98 | //! If file locking does not work reliably (like on NFS), some of the | |
99 | //! synchronization will go haywire. | |
100 | //! In both cases we recommend to locate the incremental compilation directory | |
101 | //! on a file system that supports these things. | |
102 | //! It might be a good idea though to try and detect whether we are on an | |
103 | //! unsupported file system and emit a warning in that case. This is not yet | |
104 | //! implemented. | |
105 | ||
dfeec247 | 106 | use rustc_data_structures::fx::{FxHashMap, FxHashSet}; |
b7449926 | 107 | use rustc_data_structures::svh::Svh; |
dfeec247 | 108 | use rustc_data_structures::{base_n, flock}; |
5e7ed085 | 109 | use rustc_errors::ErrorGuaranteed; |
dfeec247 | 110 | use rustc_fs_util::{link_or_copy, LinkOrCopy}; |
136023e0 | 111 | use rustc_session::{Session, StableCrateId}; |
487cf647 | 112 | use rustc_span::Symbol; |
9e0c209e | 113 | |
9e0c209e | 114 | use std::fs as std_fs; |
5e7ed085 | 115 | use std::io::{self, ErrorKind}; |
9e0c209e SL |
116 | use std::mem; |
117 | use std::path::{Path, PathBuf}; | |
dfeec247 | 118 | use std::time::{Duration, SystemTime, UNIX_EPOCH}; |
abe05a73 | 119 | |
dfeec247 | 120 | use rand::{thread_rng, RngCore}; |
9e0c209e | 121 | |
416331ca XL |
122 | #[cfg(test)] |
123 | mod tests; | |
124 | ||
0731742a XL |
125 | const LOCK_FILE_EXT: &str = ".lock"; |
126 | const DEP_GRAPH_FILENAME: &str = "dep-graph.bin"; | |
cdc7bbd5 | 127 | const STAGING_DEP_GRAPH_FILENAME: &str = "dep-graph.part.bin"; |
0731742a XL |
128 | const WORK_PRODUCTS_FILENAME: &str = "work-products.bin"; |
129 | const QUERY_CACHE_FILENAME: &str = "query-cache.bin"; | |
9e0c209e | 130 | |
476ff2be SL |
131 | // We encode integers using the following base, so they are shorter than decimal |
132 | // or hexadecimal numbers (we want short file and directory names). Since these | |
133 | // numbers will be used in file names, we choose an encoding that is not | |
134 | // case-sensitive (as opposed to base64, for example). | |
ff7c6d11 | 135 | const INT_ENCODE_BASE: usize = base_n::CASE_INSENSITIVE; |
476ff2be | 136 | |
a2a8927a | 137 | /// Returns the path to a session's dependency graph. |
9e0c209e SL |
138 | pub fn dep_graph_path(sess: &Session) -> PathBuf { |
139 | in_incr_comp_dir_sess(sess, DEP_GRAPH_FILENAME) | |
140 | } | |
a2a8927a XL |
141 | /// Returns the path to a session's staging dependency graph. |
142 | /// | |
143 | /// On the difference between dep-graph and staging dep-graph, | |
144 | /// see `build_dep_graph`. | |
cdc7bbd5 XL |
145 | pub fn staging_dep_graph_path(sess: &Session) -> PathBuf { |
146 | in_incr_comp_dir_sess(sess, STAGING_DEP_GRAPH_FILENAME) | |
147 | } | |
9e0c209e SL |
148 | pub fn work_products_path(sess: &Session) -> PathBuf { |
149 | in_incr_comp_dir_sess(sess, WORK_PRODUCTS_FILENAME) | |
150 | } | |
a2a8927a | 151 | /// Returns the path to a session's query cache. |
abe05a73 XL |
152 | pub fn query_cache_path(sess: &Session) -> PathBuf { |
153 | in_incr_comp_dir_sess(sess, QUERY_CACHE_FILENAME) | |
154 | } | |
155 | ||
a2a8927a | 156 | /// Locks a given session directory. |
9e0c209e SL |
157 | pub fn lock_file_path(session_dir: &Path) -> PathBuf { |
158 | let crate_dir = session_dir.parent().unwrap(); | |
159 | ||
160 | let directory_name = session_dir.file_name().unwrap().to_string_lossy(); | |
161 | assert_no_characters_lost(&directory_name); | |
162 | ||
74b04a01 | 163 | let dash_indices: Vec<_> = directory_name.match_indices('-').map(|(idx, _)| idx).collect(); |
9e0c209e | 164 | if dash_indices.len() != 3 { |
dfeec247 XL |
165 | bug!( |
166 | "Encountered incremental compilation session directory with \ | |
9e0c209e | 167 | malformed name: {}", |
dfeec247 XL |
168 | session_dir.display() |
169 | ) | |
9e0c209e SL |
170 | } |
171 | ||
dfeec247 | 172 | crate_dir.join(&directory_name[0..dash_indices[2]]).with_extension(&LOCK_FILE_EXT[1..]) |
9e0c209e SL |
173 | } |
174 | ||
a2a8927a XL |
175 | /// Returns the path for a given filename within the incremental compilation directory |
176 | /// in the current session. | |
9e0c209e SL |
177 | pub fn in_incr_comp_dir_sess(sess: &Session, file_name: &str) -> PathBuf { |
178 | in_incr_comp_dir(&sess.incr_comp_session_dir(), file_name) | |
179 | } | |
180 | ||
a2a8927a XL |
181 | /// Returns the path for a given filename within the incremental compilation directory, |
182 | /// not necessarily from the current session. | |
183 | /// | |
184 | /// To ensure the file is part of the current session, use [`in_incr_comp_dir_sess`]. | |
9e0c209e SL |
185 | pub fn in_incr_comp_dir(incr_comp_session_dir: &Path, file_name: &str) -> PathBuf { |
186 | incr_comp_session_dir.join(file_name) | |
187 | } | |
188 | ||
a2a8927a XL |
189 | /// Allocates the private session directory. |
190 | /// | |
191 | /// If the result of this function is `Ok`, we have a valid incremental | |
192 | /// compilation session directory. A valid session | |
9e0c209e SL |
193 | /// directory is one that contains a locked lock file. It may or may not contain |
194 | /// a dep-graph and work products from a previous session. | |
a2a8927a XL |
195 | /// |
196 | /// This always attempts to load a dep-graph from the directory. | |
197 | /// If loading fails for some reason, we fallback to a disabled `DepGraph`. | |
198 | /// See [`rustc_interface::queries::dep_graph`]. | |
199 | /// | |
200 | /// If this function returns an error, it may leave behind an invalid session directory. | |
9e0c209e | 201 | /// The garbage collection will take care of it. |
a2a8927a XL |
202 | /// |
203 | /// [`rustc_interface::queries::dep_graph`]: ../../rustc_interface/struct.Queries.html#structfield.dep_graph | |
dfeec247 XL |
204 | pub fn prepare_session_directory( |
205 | sess: &Session, | |
487cf647 | 206 | crate_name: Symbol, |
136023e0 | 207 | stable_crate_id: StableCrateId, |
5e7ed085 | 208 | ) -> Result<(), ErrorGuaranteed> { |
ea8adc8c | 209 | if sess.opts.incremental.is_none() { |
17df50a5 | 210 | return Ok(()); |
ea8adc8c XL |
211 | } |
212 | ||
dfeec247 XL |
213 | let _timer = sess.timer("incr_comp_prepare_session_directory"); |
214 | ||
9e0c209e SL |
215 | debug!("prepare_session_directory"); |
216 | ||
217 | // {incr-comp-dir}/{crate-name-and-disambiguator} | |
136023e0 | 218 | let crate_dir = crate_path(sess, crate_name, stable_crate_id); |
9e0c209e | 219 | debug!("crate-dir: {}", crate_dir.display()); |
17df50a5 | 220 | create_dir(sess, &crate_dir, "crate")?; |
9e0c209e | 221 | |
476ff2be SL |
222 | // Hack: canonicalize the path *after creating the directory* |
223 | // because, on windows, long paths can cause problems; | |
224 | // canonicalization inserts this weird prefix that makes windows | |
225 | // tolerate long paths. | |
226 | let crate_dir = match crate_dir.canonicalize() { | |
227 | Ok(v) => v, | |
228 | Err(err) => { | |
5e7ed085 | 229 | let reported = sess.err(&format!( |
dfeec247 XL |
230 | "incremental compilation: error canonicalizing path `{}`: {}", |
231 | crate_dir.display(), | |
232 | err | |
233 | )); | |
5e7ed085 | 234 | return Err(reported); |
476ff2be SL |
235 | } |
236 | }; | |
237 | ||
0bf4aa26 | 238 | let mut source_directories_already_tried = FxHashSet::default(); |
9e0c209e SL |
239 | |
240 | loop { | |
241 | // Generate a session directory of the form: | |
242 | // | |
243 | // {incr-comp-dir}/{crate-name-and-disambiguator}/s-{timestamp}-{random}-working | |
244 | let session_dir = generate_session_dir_path(&crate_dir); | |
245 | debug!("session-dir: {}", session_dir.display()); | |
246 | ||
247 | // Lock the new session directory. If this fails, return an | |
248 | // error without retrying | |
17df50a5 | 249 | let (directory_lock, lock_file_path) = lock_directory(sess, &session_dir)?; |
9e0c209e SL |
250 | |
251 | // Now that we have the lock, we can actually create the session | |
252 | // directory | |
17df50a5 | 253 | create_dir(sess, &session_dir, "session")?; |
9e0c209e SL |
254 | |
255 | // Find a suitable source directory to copy from. Ignore those that we | |
256 | // have already tried before. | |
dfeec247 | 257 | let source_directory = find_source_directory(&crate_dir, &source_directories_already_tried); |
9e0c209e | 258 | |
3c0e092e | 259 | let Some(source_directory) = source_directory else { |
9e0c209e | 260 | // There's nowhere to copy from, we're done |
dfeec247 XL |
261 | debug!( |
262 | "no source directory found. Continuing with empty session \ | |
263 | directory." | |
264 | ); | |
9e0c209e | 265 | |
ea8adc8c | 266 | sess.init_incr_comp_session(session_dir, directory_lock, false); |
17df50a5 | 267 | return Ok(()); |
9e0c209e SL |
268 | }; |
269 | ||
dfeec247 | 270 | debug!("attempting to copy data from source: {}", source_directory.display()); |
9e0c209e SL |
271 | |
272 | // Try copying over all files from the source directory | |
dfeec247 XL |
273 | if let Ok(allows_links) = copy_files(sess, &session_dir, &source_directory) { |
274 | debug!("successfully copied data from: {}", source_directory.display()); | |
9e0c209e | 275 | |
c30ab7b3 | 276 | if !allows_links { |
dfeec247 XL |
277 | sess.warn(&format!( |
278 | "Hard linking files in the incremental \ | |
c30ab7b3 SL |
279 | compilation cache failed. Copying files \ |
280 | instead. Consider moving the cache \ | |
281 | directory to a file system which supports \ | |
282 | hard linking in session dir `{}`", | |
dfeec247 XL |
283 | session_dir.display() |
284 | )); | |
c30ab7b3 SL |
285 | } |
286 | ||
ea8adc8c | 287 | sess.init_incr_comp_session(session_dir, directory_lock, true); |
17df50a5 | 288 | return Ok(()); |
9e0c209e | 289 | } else { |
dfeec247 | 290 | debug!("copying failed - trying next directory"); |
9e0c209e SL |
291 | |
292 | // Something went wrong while trying to copy/link files from the | |
293 | // source directory. Try again with a different one. | |
294 | source_directories_already_tried.insert(source_directory); | |
295 | ||
296 | // Try to remove the session directory we just allocated. We don't | |
297 | // know if there's any garbage in it from the failed copy action. | |
298 | if let Err(err) = safe_remove_dir_all(&session_dir) { | |
dfeec247 XL |
299 | sess.warn(&format!( |
300 | "Failed to delete partly initialized \ | |
ea8adc8c | 301 | session dir `{}`: {}", |
dfeec247 XL |
302 | session_dir.display(), |
303 | err | |
304 | )); | |
9e0c209e SL |
305 | } |
306 | ||
ea8adc8c | 307 | delete_session_dir_lock_file(sess, &lock_file_path); |
9e0c209e SL |
308 | mem::drop(directory_lock); |
309 | } | |
310 | } | |
311 | } | |
312 | ||
9e0c209e SL |
313 | /// This function finalizes and thus 'publishes' the session directory by |
314 | /// renaming it to `s-{timestamp}-{svh}` and releasing the file lock. | |
315 | /// If there have been compilation errors, however, this function will just | |
316 | /// delete the presumably invalid session directory. | |
317 | pub fn finalize_session_directory(sess: &Session, svh: Svh) { | |
318 | if sess.opts.incremental.is_none() { | |
319 | return; | |
320 | } | |
321 | ||
dfeec247 XL |
322 | let _timer = sess.timer("incr_comp_finalize_session_directory"); |
323 | ||
9e0c209e SL |
324 | let incr_comp_session_dir: PathBuf = sess.incr_comp_session_dir().clone(); |
325 | ||
487cf647 | 326 | if let Some(_) = sess.has_errors_or_delayed_span_bugs() { |
9e0c209e SL |
327 | // If there have been any errors during compilation, we don't want to |
328 | // publish this session directory. Rather, we'll just delete it. | |
329 | ||
dfeec247 XL |
330 | debug!( |
331 | "finalize_session_directory() - invalidating session directory: {}", | |
332 | incr_comp_session_dir.display() | |
333 | ); | |
9e0c209e SL |
334 | |
335 | if let Err(err) = safe_remove_dir_all(&*incr_comp_session_dir) { | |
dfeec247 XL |
336 | sess.warn(&format!( |
337 | "Error deleting incremental compilation \ | |
9e0c209e | 338 | session directory `{}`: {}", |
dfeec247 XL |
339 | incr_comp_session_dir.display(), |
340 | err | |
341 | )); | |
9e0c209e SL |
342 | } |
343 | ||
344 | let lock_file_path = lock_file_path(&*incr_comp_session_dir); | |
345 | delete_session_dir_lock_file(sess, &lock_file_path); | |
346 | sess.mark_incr_comp_session_as_invalid(); | |
347 | } | |
348 | ||
dfeec247 | 349 | debug!("finalize_session_directory() - session directory: {}", incr_comp_session_dir.display()); |
9e0c209e | 350 | |
dfeec247 | 351 | let old_sub_dir_name = incr_comp_session_dir.file_name().unwrap().to_string_lossy(); |
9e0c209e SL |
352 | assert_no_characters_lost(&old_sub_dir_name); |
353 | ||
354 | // Keep the 's-{timestamp}-{random-number}' prefix, but replace the | |
355 | // '-working' part with the SVH of the crate | |
74b04a01 | 356 | let dash_indices: Vec<_> = old_sub_dir_name.match_indices('-').map(|(idx, _)| idx).collect(); |
9e0c209e | 357 | if dash_indices.len() != 3 { |
dfeec247 XL |
358 | bug!( |
359 | "Encountered incremental compilation session directory with \ | |
9e0c209e | 360 | malformed name: {}", |
dfeec247 XL |
361 | incr_comp_session_dir.display() |
362 | ) | |
9e0c209e SL |
363 | } |
364 | ||
365 | // State: "s-{timestamp}-{random-number}-" | |
dfeec247 | 366 | let mut new_sub_dir_name = String::from(&old_sub_dir_name[..=dash_indices[2]]); |
9e0c209e SL |
367 | |
368 | // Append the svh | |
ff7c6d11 | 369 | base_n::push_str(svh.as_u64() as u128, INT_ENCODE_BASE, &mut new_sub_dir_name); |
9e0c209e SL |
370 | |
371 | // Create the full path | |
372 | let new_path = incr_comp_session_dir.parent().unwrap().join(new_sub_dir_name); | |
373 | debug!("finalize_session_directory() - new path: {}", new_path.display()); | |
374 | ||
5e7ed085 | 375 | match rename_path_with_retry(&*incr_comp_session_dir, &new_path, 3) { |
9e0c209e SL |
376 | Ok(_) => { |
377 | debug!("finalize_session_directory() - directory renamed successfully"); | |
378 | ||
379 | // This unlocks the directory | |
380 | sess.finalize_incr_comp_session(new_path); | |
381 | } | |
382 | Err(e) => { | |
383 | // Warn about the error. However, no need to abort compilation now. | |
dfeec247 XL |
384 | sess.warn(&format!( |
385 | "Error finalizing incremental compilation \ | |
9e0c209e | 386 | session directory `{}`: {}", |
dfeec247 XL |
387 | incr_comp_session_dir.display(), |
388 | e | |
389 | )); | |
9e0c209e SL |
390 | |
391 | debug!("finalize_session_directory() - error, marking as invalid"); | |
392 | // Drop the file lock, so we can garage collect | |
393 | sess.mark_incr_comp_session_as_invalid(); | |
394 | } | |
395 | } | |
396 | ||
397 | let _ = garbage_collect_session_directories(sess); | |
398 | } | |
399 | ||
400 | pub fn delete_all_session_dir_contents(sess: &Session) -> io::Result<()> { | |
401 | let sess_dir_iterator = sess.incr_comp_session_dir().read_dir()?; | |
402 | for entry in sess_dir_iterator { | |
403 | let entry = entry?; | |
404 | safe_remove_file(&entry.path())? | |
405 | } | |
406 | Ok(()) | |
407 | } | |
408 | ||
dfeec247 | 409 | fn copy_files(sess: &Session, target_dir: &Path, source_dir: &Path) -> Result<bool, ()> { |
9e0c209e SL |
410 | // We acquire a shared lock on the lock file of the directory, so that |
411 | // nobody deletes it out from under us while we are reading from it. | |
412 | let lock_file_path = lock_file_path(source_dir); | |
3c0e092e XL |
413 | |
414 | // not exclusive | |
415 | let Ok(_lock) = flock::Lock::new( | |
dfeec247 XL |
416 | &lock_file_path, |
417 | false, // don't wait, | |
418 | false, // don't create | |
419 | false, | |
3c0e092e | 420 | ) else { |
9e0c209e | 421 | // Could not acquire the lock, don't try to copy from here |
dfeec247 | 422 | return Err(()); |
9e0c209e SL |
423 | }; |
424 | ||
5e7ed085 FG |
425 | let Ok(source_dir_iterator) = source_dir.read_dir() else { |
426 | return Err(()); | |
9e0c209e SL |
427 | }; |
428 | ||
429 | let mut files_linked = 0; | |
430 | let mut files_copied = 0; | |
431 | ||
432 | for entry in source_dir_iterator { | |
433 | match entry { | |
434 | Ok(entry) => { | |
435 | let file_name = entry.file_name(); | |
436 | ||
437 | let target_file_path = target_dir.join(file_name); | |
438 | let source_path = entry.path(); | |
439 | ||
440 | debug!("copying into session dir: {}", source_path.display()); | |
b7449926 | 441 | match link_or_copy(source_path, target_file_path) { |
dfeec247 XL |
442 | Ok(LinkOrCopy::Link) => files_linked += 1, |
443 | Ok(LinkOrCopy::Copy) => files_copied += 1, | |
444 | Err(_) => return Err(()), | |
9e0c209e SL |
445 | } |
446 | } | |
dfeec247 | 447 | Err(_) => return Err(()), |
9e0c209e SL |
448 | } |
449 | } | |
450 | ||
064997fb | 451 | if sess.opts.unstable_opts.incremental_info { |
6a06907d | 452 | eprintln!( |
dfeec247 XL |
453 | "[incremental] session directory: \ |
454 | {} files hard-linked", | |
455 | files_linked | |
456 | ); | |
6a06907d | 457 | eprintln!( |
dfeec247 XL |
458 | "[incremental] session directory: \ |
459 | {} files copied", | |
460 | files_copied | |
461 | ); | |
9e0c209e SL |
462 | } |
463 | ||
c30ab7b3 | 464 | Ok(files_linked > 0 || files_copied == 0) |
9e0c209e SL |
465 | } |
466 | ||
9fa01778 | 467 | /// Generates unique directory path of the form: |
9e0c209e SL |
468 | /// {crate_dir}/s-{timestamp}-{random-number}-working |
469 | fn generate_session_dir_path(crate_dir: &Path) -> PathBuf { | |
470 | let timestamp = timestamp_to_string(SystemTime::now()); | |
471 | debug!("generate_session_dir_path: timestamp = {}", timestamp); | |
472 | let random_number = thread_rng().next_u32(); | |
473 | debug!("generate_session_dir_path: random_number = {}", random_number); | |
474 | ||
dfeec247 XL |
475 | let directory_name = format!( |
476 | "s-{}-{}-working", | |
477 | timestamp, | |
478 | base_n::encode(random_number as u128, INT_ENCODE_BASE) | |
479 | ); | |
9e0c209e SL |
480 | debug!("generate_session_dir_path: directory_name = {}", directory_name); |
481 | let directory_path = crate_dir.join(directory_name); | |
482 | debug!("generate_session_dir_path: directory_path = {}", directory_path.display()); | |
483 | directory_path | |
484 | } | |
485 | ||
5e7ed085 | 486 | fn create_dir(sess: &Session, path: &Path, dir_tag: &str) -> Result<(), ErrorGuaranteed> { |
cc61c64b | 487 | match std_fs::create_dir_all(path) { |
9e0c209e SL |
488 | Ok(()) => { |
489 | debug!("{} directory created successfully", dir_tag); | |
490 | Ok(()) | |
491 | } | |
492 | Err(err) => { | |
5e7ed085 | 493 | let reported = sess.err(&format!( |
dfeec247 | 494 | "Could not create incremental compilation {} \ |
9e0c209e | 495 | directory `{}`: {}", |
dfeec247 XL |
496 | dir_tag, |
497 | path.display(), | |
498 | err | |
499 | )); | |
5e7ed085 | 500 | Err(reported) |
9e0c209e SL |
501 | } |
502 | } | |
503 | } | |
504 | ||
a1dfa0c6 | 505 | /// Allocate the lock-file and lock it. |
17df50a5 XL |
506 | fn lock_directory( |
507 | sess: &Session, | |
508 | session_dir: &Path, | |
5e7ed085 | 509 | ) -> Result<(flock::Lock, PathBuf), ErrorGuaranteed> { |
9e0c209e SL |
510 | let lock_file_path = lock_file_path(session_dir); |
511 | debug!("lock_directory() - lock_file: {}", lock_file_path.display()); | |
512 | ||
dfeec247 XL |
513 | match flock::Lock::new( |
514 | &lock_file_path, | |
515 | false, // don't wait | |
516 | true, // create the lock file | |
517 | true, | |
518 | ) { | |
519 | // the lock should be exclusive | |
9e0c209e | 520 | Ok(lock) => Ok((lock, lock_file_path)), |
17df50a5 XL |
521 | Err(lock_err) => { |
522 | let mut err = sess.struct_err(&format!( | |
dfeec247 | 523 | "incremental compilation: could not create \ |
17df50a5 XL |
524 | session directory lock file: {}", |
525 | lock_err | |
dfeec247 | 526 | )); |
17df50a5 XL |
527 | if flock::Lock::error_unsupported(&lock_err) { |
528 | err.note(&format!( | |
529 | "the filesystem for the incremental path at {} \ | |
530 | does not appear to support locking, consider changing the \ | |
531 | incremental path to a filesystem that supports locking \ | |
532 | or disable incremental compilation", | |
533 | session_dir.display() | |
534 | )); | |
535 | if std::env::var_os("CARGO").is_some() { | |
536 | err.help( | |
537 | "incremental compilation can be disabled by setting the \ | |
538 | environment variable CARGO_INCREMENTAL=0 (see \ | |
539 | https://doc.rust-lang.org/cargo/reference/profiles.html#incremental)", | |
540 | ); | |
541 | err.help( | |
542 | "the entire build directory can be changed to a different \ | |
543 | filesystem by setting the environment variable CARGO_TARGET_DIR \ | |
544 | to a different path (see \ | |
545 | https://doc.rust-lang.org/cargo/reference/config.html#buildtarget-dir)", | |
546 | ); | |
547 | } | |
548 | } | |
5e7ed085 | 549 | Err(err.emit()) |
9e0c209e SL |
550 | } |
551 | } | |
552 | } | |
553 | ||
dfeec247 | 554 | fn delete_session_dir_lock_file(sess: &Session, lock_file_path: &Path) { |
9e0c209e | 555 | if let Err(err) = safe_remove_file(&lock_file_path) { |
dfeec247 XL |
556 | sess.warn(&format!( |
557 | "Error deleting lock file for incremental \ | |
9e0c209e | 558 | compilation session directory `{}`: {}", |
dfeec247 XL |
559 | lock_file_path.display(), |
560 | err | |
561 | )); | |
9e0c209e SL |
562 | } |
563 | } | |
564 | ||
9fa01778 | 565 | /// Finds the most recent published session directory that is not in the |
9e0c209e | 566 | /// ignore-list. |
dfeec247 XL |
567 | fn find_source_directory( |
568 | crate_dir: &Path, | |
569 | source_directories_already_tried: &FxHashSet<PathBuf>, | |
570 | ) -> Option<PathBuf> { | |
571 | let iter = crate_dir | |
572 | .read_dir() | |
573 | .unwrap() // FIXME | |
574 | .filter_map(|e| e.ok().map(|e| e.path())); | |
9e0c209e SL |
575 | |
576 | find_source_directory_in_iter(iter, source_directories_already_tried) | |
577 | } | |
578 | ||
dfeec247 XL |
579 | fn find_source_directory_in_iter<I>( |
580 | iter: I, | |
581 | source_directories_already_tried: &FxHashSet<PathBuf>, | |
582 | ) -> Option<PathBuf> | |
583 | where | |
584 | I: Iterator<Item = PathBuf>, | |
9e0c209e SL |
585 | { |
586 | let mut best_candidate = (UNIX_EPOCH, None); | |
587 | ||
588 | for session_dir in iter { | |
dfeec247 | 589 | debug!("find_source_directory_in_iter - inspecting `{}`", session_dir.display()); |
9e0c209e SL |
590 | |
591 | let directory_name = session_dir.file_name().unwrap().to_string_lossy(); | |
592 | assert_no_characters_lost(&directory_name); | |
593 | ||
dfeec247 XL |
594 | if source_directories_already_tried.contains(&session_dir) |
595 | || !is_session_directory(&directory_name) | |
596 | || !is_finalized(&directory_name) | |
597 | { | |
416331ca | 598 | debug!("find_source_directory_in_iter - ignoring"); |
dfeec247 | 599 | continue; |
9e0c209e SL |
600 | } |
601 | ||
dfeec247 XL |
602 | let timestamp = extract_timestamp_from_session_dir(&directory_name).unwrap_or_else(|_| { |
603 | bug!("unexpected incr-comp session dir: {}", session_dir.display()) | |
604 | }); | |
9e0c209e SL |
605 | |
606 | if timestamp > best_candidate.0 { | |
607 | best_candidate = (timestamp, Some(session_dir.clone())); | |
608 | } | |
609 | } | |
610 | ||
611 | best_candidate.1 | |
612 | } | |
613 | ||
614 | fn is_finalized(directory_name: &str) -> bool { | |
615 | !directory_name.ends_with("-working") | |
616 | } | |
617 | ||
618 | fn is_session_directory(directory_name: &str) -> bool { | |
dfeec247 | 619 | directory_name.starts_with("s-") && !directory_name.ends_with(LOCK_FILE_EXT) |
9e0c209e SL |
620 | } |
621 | ||
622 | fn is_session_directory_lock_file(file_name: &str) -> bool { | |
623 | file_name.starts_with("s-") && file_name.ends_with(LOCK_FILE_EXT) | |
624 | } | |
625 | ||
dfeec247 | 626 | fn extract_timestamp_from_session_dir(directory_name: &str) -> Result<SystemTime, ()> { |
9e0c209e | 627 | if !is_session_directory(directory_name) { |
dfeec247 | 628 | return Err(()); |
9e0c209e SL |
629 | } |
630 | ||
74b04a01 | 631 | let dash_indices: Vec<_> = directory_name.match_indices('-').map(|(idx, _)| idx).collect(); |
9e0c209e | 632 | if dash_indices.len() != 3 { |
dfeec247 | 633 | return Err(()); |
9e0c209e SL |
634 | } |
635 | ||
dfeec247 | 636 | string_to_timestamp(&directory_name[dash_indices[0] + 1..dash_indices[1]]) |
9e0c209e SL |
637 | } |
638 | ||
9e0c209e SL |
639 | fn timestamp_to_string(timestamp: SystemTime) -> String { |
640 | let duration = timestamp.duration_since(UNIX_EPOCH).unwrap(); | |
dfeec247 | 641 | let micros = duration.as_secs() * 1_000_000 + (duration.subsec_nanos() as u64) / 1000; |
ff7c6d11 | 642 | base_n::encode(micros as u128, INT_ENCODE_BASE) |
9e0c209e SL |
643 | } |
644 | ||
645 | fn string_to_timestamp(s: &str) -> Result<SystemTime, ()> { | |
2c00a5a8 | 646 | let micros_since_unix_epoch = u64::from_str_radix(s, INT_ENCODE_BASE as u32); |
9e0c209e SL |
647 | |
648 | if micros_since_unix_epoch.is_err() { | |
dfeec247 | 649 | return Err(()); |
9e0c209e SL |
650 | } |
651 | ||
652 | let micros_since_unix_epoch = micros_since_unix_epoch.unwrap(); | |
653 | ||
dfeec247 XL |
654 | let duration = Duration::new( |
655 | micros_since_unix_epoch / 1_000_000, | |
656 | 1000 * (micros_since_unix_epoch % 1_000_000) as u32, | |
657 | ); | |
9e0c209e SL |
658 | Ok(UNIX_EPOCH + duration) |
659 | } | |
660 | ||
487cf647 | 661 | fn crate_path(sess: &Session, crate_name: Symbol, stable_crate_id: StableCrateId) -> PathBuf { |
9e0c209e SL |
662 | let incr_dir = sess.opts.incremental.as_ref().unwrap().clone(); |
663 | ||
136023e0 | 664 | let stable_crate_id = base_n::encode(stable_crate_id.to_u64() as u128, INT_ENCODE_BASE); |
9e0c209e | 665 | |
136023e0 | 666 | let crate_name = format!("{}-{}", crate_name, stable_crate_id); |
9e0c209e SL |
667 | incr_dir.join(crate_name) |
668 | } | |
669 | ||
670 | fn assert_no_characters_lost(s: &str) { | |
671 | if s.contains('\u{FFFD}') { | |
672 | bug!("Could not losslessly convert '{}'.", s) | |
673 | } | |
674 | } | |
675 | ||
676 | fn is_old_enough_to_be_collected(timestamp: SystemTime) -> bool { | |
677 | timestamp < SystemTime::now() - Duration::from_secs(10) | |
678 | } | |
679 | ||
a2a8927a | 680 | /// Runs garbage collection for the current session. |
9e0c209e SL |
681 | pub fn garbage_collect_session_directories(sess: &Session) -> io::Result<()> { |
682 | debug!("garbage_collect_session_directories() - begin"); | |
683 | ||
684 | let session_directory = sess.incr_comp_session_dir(); | |
dfeec247 XL |
685 | debug!( |
686 | "garbage_collect_session_directories() - session directory: {}", | |
687 | session_directory.display() | |
688 | ); | |
9e0c209e SL |
689 | |
690 | let crate_directory = session_directory.parent().unwrap(); | |
dfeec247 XL |
691 | debug!( |
692 | "garbage_collect_session_directories() - crate directory: {}", | |
693 | crate_directory.display() | |
694 | ); | |
9e0c209e SL |
695 | |
696 | // First do a pass over the crate directory, collecting lock files and | |
697 | // session directories | |
0bf4aa26 XL |
698 | let mut session_directories = FxHashSet::default(); |
699 | let mut lock_files = FxHashSet::default(); | |
9e0c209e | 700 | |
a1dfa0c6 | 701 | for dir_entry in crate_directory.read_dir()? { |
5e7ed085 FG |
702 | let Ok(dir_entry) = dir_entry else { |
703 | // Ignore any errors | |
704 | continue; | |
9e0c209e SL |
705 | }; |
706 | ||
707 | let entry_name = dir_entry.file_name(); | |
708 | let entry_name = entry_name.to_string_lossy(); | |
709 | ||
710 | if is_session_directory_lock_file(&entry_name) { | |
711 | assert_no_characters_lost(&entry_name); | |
712 | lock_files.insert(entry_name.into_owned()); | |
713 | } else if is_session_directory(&entry_name) { | |
714 | assert_no_characters_lost(&entry_name); | |
715 | session_directories.insert(entry_name.into_owned()); | |
716 | } else { | |
717 | // This is something we don't know, leave it alone | |
718 | } | |
719 | } | |
720 | ||
721 | // Now map from lock files to session directories | |
dfeec247 XL |
722 | let lock_file_to_session_dir: FxHashMap<String, Option<String>> = lock_files |
723 | .into_iter() | |
724 | .map(|lock_file_name| { | |
725 | assert!(lock_file_name.ends_with(LOCK_FILE_EXT)); | |
726 | let dir_prefix_end = lock_file_name.len() - LOCK_FILE_EXT.len(); | |
727 | let session_dir = { | |
728 | let dir_prefix = &lock_file_name[0..dir_prefix_end]; | |
729 | session_directories.iter().find(|dir_name| dir_name.starts_with(dir_prefix)) | |
730 | }; | |
731 | (lock_file_name, session_dir.map(String::clone)) | |
732 | }) | |
733 | .collect(); | |
9e0c209e SL |
734 | |
735 | // Delete all lock files, that don't have an associated directory. They must | |
736 | // be some kind of leftover | |
737 | for (lock_file_name, directory_name) in &lock_file_to_session_dir { | |
738 | if directory_name.is_none() { | |
5e7ed085 FG |
739 | let Ok(timestamp) = extract_timestamp_from_session_dir(lock_file_name) else { |
740 | debug!( | |
741 | "found lock-file with malformed timestamp: {}", | |
742 | crate_directory.join(&lock_file_name).display() | |
743 | ); | |
744 | // Ignore it | |
745 | continue; | |
9e0c209e SL |
746 | }; |
747 | ||
748 | let lock_file_path = crate_directory.join(&**lock_file_name); | |
749 | ||
750 | if is_old_enough_to_be_collected(timestamp) { | |
dfeec247 XL |
751 | debug!( |
752 | "garbage_collect_session_directories() - deleting \ | |
753 | garbage lock file: {}", | |
754 | lock_file_path.display() | |
755 | ); | |
9e0c209e SL |
756 | delete_session_dir_lock_file(sess, &lock_file_path); |
757 | } else { | |
dfeec247 XL |
758 | debug!( |
759 | "garbage_collect_session_directories() - lock file with \ | |
9e0c209e | 760 | no session dir not old enough to be collected: {}", |
dfeec247 XL |
761 | lock_file_path.display() |
762 | ); | |
9e0c209e SL |
763 | } |
764 | } | |
765 | } | |
766 | ||
767 | // Filter out `None` directories | |
dfeec247 XL |
768 | let lock_file_to_session_dir: FxHashMap<String, String> = lock_file_to_session_dir |
769 | .into_iter() | |
770 | .filter_map(|(lock_file_name, directory_name)| directory_name.map(|n| (lock_file_name, n))) | |
771 | .collect(); | |
9e0c209e | 772 | |
2c00a5a8 XL |
773 | // Delete all session directories that don't have a lock file. |
774 | for directory_name in session_directories { | |
775 | if !lock_file_to_session_dir.values().any(|dir| *dir == directory_name) { | |
776 | let path = crate_directory.join(directory_name); | |
777 | if let Err(err) = safe_remove_dir_all(&path) { | |
dfeec247 XL |
778 | sess.warn(&format!( |
779 | "Failed to garbage collect invalid incremental \ | |
2c00a5a8 | 780 | compilation session directory `{}`: {}", |
dfeec247 XL |
781 | path.display(), |
782 | err | |
783 | )); | |
2c00a5a8 XL |
784 | } |
785 | } | |
786 | } | |
787 | ||
788 | // Now garbage collect the valid session directories. | |
9e0c209e | 789 | let mut deletion_candidates = vec![]; |
9e0c209e SL |
790 | |
791 | for (lock_file_name, directory_name) in &lock_file_to_session_dir { | |
dfeec247 | 792 | debug!("garbage_collect_session_directories() - inspecting: {}", directory_name); |
9e0c209e | 793 | |
5e7ed085 FG |
794 | let Ok(timestamp) = extract_timestamp_from_session_dir(directory_name) else { |
795 | debug!( | |
796 | "found session-dir with malformed timestamp: {}", | |
797 | crate_directory.join(directory_name).display() | |
798 | ); | |
799 | // Ignore it | |
800 | continue; | |
9e0c209e SL |
801 | }; |
802 | ||
803 | if is_finalized(directory_name) { | |
804 | let lock_file_path = crate_directory.join(lock_file_name); | |
dfeec247 XL |
805 | match flock::Lock::new( |
806 | &lock_file_path, | |
807 | false, // don't wait | |
808 | false, // don't create the lock-file | |
809 | true, | |
810 | ) { | |
811 | // get an exclusive lock | |
9e0c209e | 812 | Ok(lock) => { |
dfeec247 XL |
813 | debug!( |
814 | "garbage_collect_session_directories() - \ | |
815 | successfully acquired lock" | |
816 | ); | |
817 | debug!( | |
818 | "garbage_collect_session_directories() - adding \ | |
819 | deletion candidate: {}", | |
820 | directory_name | |
821 | ); | |
9e0c209e SL |
822 | |
823 | // Note that we are holding on to the lock | |
dfeec247 XL |
824 | deletion_candidates.push(( |
825 | timestamp, | |
826 | crate_directory.join(directory_name), | |
827 | Some(lock), | |
828 | )); | |
9e0c209e SL |
829 | } |
830 | Err(_) => { | |
dfeec247 XL |
831 | debug!( |
832 | "garbage_collect_session_directories() - \ | |
833 | not collecting, still in use" | |
834 | ); | |
9e0c209e SL |
835 | } |
836 | } | |
837 | } else if is_old_enough_to_be_collected(timestamp) { | |
838 | // When cleaning out "-working" session directories, i.e. | |
839 | // session directories that might still be in use by another | |
840 | // compiler instance, we only look a directories that are | |
841 | // at least ten seconds old. This is supposed to reduce the | |
842 | // chance of deleting a directory in the time window where | |
843 | // the process has allocated the directory but has not yet | |
844 | // acquired the file-lock on it. | |
845 | ||
846 | // Try to acquire the directory lock. If we can't, it | |
847 | // means that the owning process is still alive and we | |
848 | // leave this directory alone. | |
849 | let lock_file_path = crate_directory.join(lock_file_name); | |
dfeec247 XL |
850 | match flock::Lock::new( |
851 | &lock_file_path, | |
852 | false, // don't wait | |
853 | false, // don't create the lock-file | |
854 | true, | |
855 | ) { | |
856 | // get an exclusive lock | |
9e0c209e | 857 | Ok(lock) => { |
dfeec247 XL |
858 | debug!( |
859 | "garbage_collect_session_directories() - \ | |
860 | successfully acquired lock" | |
861 | ); | |
9e0c209e | 862 | |
29967ef6 XL |
863 | delete_old(sess, &crate_directory.join(directory_name)); |
864 | ||
865 | // Let's make it explicit that the file lock is released at this point, | |
866 | // or rather, that we held on to it until here | |
867 | mem::drop(lock); | |
9e0c209e SL |
868 | } |
869 | Err(_) => { | |
dfeec247 XL |
870 | debug!( |
871 | "garbage_collect_session_directories() - \ | |
872 | not collecting, still in use" | |
873 | ); | |
9e0c209e SL |
874 | } |
875 | } | |
876 | } else { | |
dfeec247 XL |
877 | debug!( |
878 | "garbage_collect_session_directories() - not finalized, not \ | |
879 | old enough" | |
880 | ); | |
9e0c209e SL |
881 | } |
882 | } | |
883 | ||
884 | // Delete all but the most recent of the candidates | |
885 | for (path, lock) in all_except_most_recent(deletion_candidates) { | |
dfeec247 | 886 | debug!("garbage_collect_session_directories() - deleting `{}`", path.display()); |
9e0c209e SL |
887 | |
888 | if let Err(err) = safe_remove_dir_all(&path) { | |
dfeec247 XL |
889 | sess.warn(&format!( |
890 | "Failed to garbage collect finalized incremental \ | |
9e0c209e | 891 | compilation session directory `{}`: {}", |
dfeec247 XL |
892 | path.display(), |
893 | err | |
894 | )); | |
9e0c209e SL |
895 | } else { |
896 | delete_session_dir_lock_file(sess, &lock_file_path(&path)); | |
897 | } | |
898 | ||
9e0c209e SL |
899 | // Let's make it explicit that the file lock is released at this point, |
900 | // or rather, that we held on to it until here | |
901 | mem::drop(lock); | |
902 | } | |
903 | ||
29967ef6 XL |
904 | Ok(()) |
905 | } | |
9e0c209e | 906 | |
29967ef6 XL |
907 | fn delete_old(sess: &Session, path: &Path) { |
908 | debug!("garbage_collect_session_directories() - deleting `{}`", path.display()); | |
9e0c209e | 909 | |
29967ef6 XL |
910 | if let Err(err) = safe_remove_dir_all(&path) { |
911 | sess.warn(&format!( | |
912 | "Failed to garbage collect incremental compilation session directory `{}`: {}", | |
913 | path.display(), | |
914 | err | |
915 | )); | |
916 | } else { | |
917 | delete_session_dir_lock_file(sess, &lock_file_path(&path)); | |
9e0c209e | 918 | } |
9e0c209e SL |
919 | } |
920 | ||
dfeec247 XL |
921 | fn all_except_most_recent( |
922 | deletion_candidates: Vec<(SystemTime, PathBuf, Option<flock::Lock>)>, | |
923 | ) -> FxHashMap<PathBuf, Option<flock::Lock>> { | |
924 | let most_recent = deletion_candidates.iter().map(|&(timestamp, ..)| timestamp).max(); | |
9e0c209e SL |
925 | |
926 | if let Some(most_recent) = most_recent { | |
dfeec247 XL |
927 | deletion_candidates |
928 | .into_iter() | |
929 | .filter(|&(timestamp, ..)| timestamp != most_recent) | |
930 | .map(|(_, path, lock)| (path, lock)) | |
931 | .collect() | |
9e0c209e | 932 | } else { |
0bf4aa26 | 933 | FxHashMap::default() |
9e0c209e SL |
934 | } |
935 | } | |
936 | ||
937 | /// Since paths of artifacts within session directories can get quite long, we | |
938 | /// need to support deleting files with very long paths. The regular | |
939 | /// WinApi functions only support paths up to 260 characters, however. In order | |
940 | /// to circumvent this limitation, we canonicalize the path of the directory | |
941 | /// before passing it to std::fs::remove_dir_all(). This will convert the path | |
942 | /// into the '\\?\' format, which supports much longer paths. | |
943 | fn safe_remove_dir_all(p: &Path) -> io::Result<()> { | |
5869c6ff XL |
944 | let canonicalized = match std_fs::canonicalize(p) { |
945 | Ok(canonicalized) => canonicalized, | |
946 | Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(()), | |
947 | Err(err) => return Err(err), | |
948 | }; | |
949 | ||
950 | std_fs::remove_dir_all(canonicalized) | |
9e0c209e SL |
951 | } |
952 | ||
953 | fn safe_remove_file(p: &Path) -> io::Result<()> { | |
5869c6ff XL |
954 | let canonicalized = match std_fs::canonicalize(p) { |
955 | Ok(canonicalized) => canonicalized, | |
956 | Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(()), | |
957 | Err(err) => return Err(err), | |
958 | }; | |
959 | ||
960 | match std_fs::remove_file(canonicalized) { | |
961 | Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(()), | |
962 | result => result, | |
9e0c209e SL |
963 | } |
964 | } | |
5e7ed085 FG |
965 | |
966 | // On Windows the compiler would sometimes fail to rename the session directory because | |
967 | // the OS thought something was still being accessed in it. So we retry a few times to give | |
968 | // the OS time to catch up. | |
969 | // See https://github.com/rust-lang/rust/issues/86929. | |
970 | fn rename_path_with_retry(from: &Path, to: &Path, mut retries_left: usize) -> std::io::Result<()> { | |
971 | loop { | |
972 | match std_fs::rename(from, to) { | |
973 | Ok(()) => return Ok(()), | |
974 | Err(e) => { | |
975 | if retries_left > 0 && e.kind() == ErrorKind::PermissionDenied { | |
976 | // Try again after a short waiting period. | |
977 | std::thread::sleep(Duration::from_millis(50)); | |
978 | retries_left -= 1; | |
979 | } else { | |
980 | return Err(e); | |
981 | } | |
982 | } | |
983 | } | |
984 | } | |
985 | } |