From 7e94c7a82cf1340910889ff2a5c22daad0f2a3a5 Mon Sep 17 00:00:00 2001 From: elle-j Date: Mon, 16 Nov 2026 12:16:52 +0100 Subject: [PATCH 1/2] Fix intermittent access denied for linker's temp directory. --- crates/linker/src/elf.rs | 73 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 71 insertions(+), 2 deletions(-) diff --git a/crates/linker/src/elf.rs b/crates/linker/src/elf.rs index 2862d93ab..2f2484b57 100644 --- a/crates/linker/src/elf.rs +++ b/crates/linker/src/elf.rs @@ -1,6 +1,6 @@ //! The revive ELF object linker library. -use std::{ffi::CString, fs, path::PathBuf, sync::Mutex}; +use std::{ffi::CString, fs, io, path::PathBuf, sync::Mutex, thread, time::Duration}; use lld_sys::LLDELFLink; use tempfile::TempDir; @@ -9,6 +9,10 @@ use revive_builtins::COMPILER_RT; static GUARD: Mutex<()> = Mutex::new(()); +/// Bounded so that a persistent permission problem still surfaces instead of retrying forever. +const TEMPORARY_DIRECTORY_RETRIES: usize = 3; +const TEMPORARY_DIRECTORY_RETRY_PAUSE: Duration = Duration::from_millis(1); + /// The revive ELF object linker. pub struct ElfLinker { temporary_directory: TempDir, @@ -29,7 +33,7 @@ SECTIONS { /// The setup routine prepares a temporary working directory. pub fn setup() -> anyhow::Result { - let temporary_directory = TempDir::new()?; + let temporary_directory = retry_when_access_is_denied(TempDir::new)?; let object_path = temporary_directory.path().join("obj.o"); let output_path = temporary_directory.path().join("out.o"); let symbols_path = temporary_directory.path().join("sym.o"); @@ -112,3 +116,68 @@ fn lld(arguments: Vec) -> bool { let _lock = GUARD.lock().expect("ICE: linker mutex should not poison"); unsafe { LLDELFLink(args.as_ptr(), args.len()) == 0 } } + +/// Windows reports a name clash with a directory that is still being deleted as access denied +/// rather than as already existing, which `tempfile` does not retry. Each retry uses a new +/// random name with a short growing delay. +fn retry_when_access_is_denied(mut create: impl FnMut() -> io::Result) -> io::Result { + let mut retries = 0; + loop { + match create() { + Err(error) + if error.kind() == io::ErrorKind::PermissionDenied + && retries < TEMPORARY_DIRECTORY_RETRIES => + { + retries += 1; + thread::sleep(TEMPORARY_DIRECTORY_RETRY_PAUSE * retries as u32); + } + result => return result, + } + } +} + +#[cfg(test)] +mod tests { + use std::io; + + use super::{retry_when_access_is_denied, TEMPORARY_DIRECTORY_RETRIES}; + + #[test] + fn retries_when_access_is_denied_once() { + let mut calls = 0; + retry_when_access_is_denied(|| { + calls += 1; + if calls == 1 { + Err(io::Error::from(io::ErrorKind::PermissionDenied)) + } else { + Ok(()) + } + }) + .expect("an access permission denial should be retried"); + assert_eq!(calls, 2); + } + + #[test] + fn gives_up_when_access_stays_denied() { + let mut calls = 0; + let error = retry_when_access_is_denied(|| -> io::Result<()> { + calls += 1; + Err(io::Error::from(io::ErrorKind::PermissionDenied)) + }) + .unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::PermissionDenied); + assert_eq!(calls, TEMPORARY_DIRECTORY_RETRIES + 1); + } + + #[test] + fn returns_non_permission_denied_errors_without_retrying() { + let mut calls = 0; + let error = retry_when_access_is_denied(|| -> io::Result<()> { + calls += 1; + Err(io::Error::from(io::ErrorKind::NotFound)) + }) + .unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::NotFound); + assert_eq!(calls, 1); + } +} From 40b38c958b647b90d5b9cd0c600c017016c8714e Mon Sep 17 00:00:00 2001 From: elle-j Date: Mon, 16 Nov 2026 12:23:21 +0100 Subject: [PATCH 2/2] Update function name. --- crates/linker/src/elf.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/crates/linker/src/elf.rs b/crates/linker/src/elf.rs index 2f2484b57..d98d6db32 100644 --- a/crates/linker/src/elf.rs +++ b/crates/linker/src/elf.rs @@ -33,7 +33,7 @@ SECTIONS { /// The setup routine prepares a temporary working directory. pub fn setup() -> anyhow::Result { - let temporary_directory = retry_when_access_is_denied(TempDir::new)?; + let temporary_directory = create_temporary_directory(TempDir::new)?; let object_path = temporary_directory.path().join("obj.o"); let output_path = temporary_directory.path().join("out.o"); let symbols_path = temporary_directory.path().join("sym.o"); @@ -120,7 +120,7 @@ fn lld(arguments: Vec) -> bool { /// Windows reports a name clash with a directory that is still being deleted as access denied /// rather than as already existing, which `tempfile` does not retry. Each retry uses a new /// random name with a short growing delay. -fn retry_when_access_is_denied(mut create: impl FnMut() -> io::Result) -> io::Result { +fn create_temporary_directory(mut create: impl FnMut() -> io::Result) -> io::Result { let mut retries = 0; loop { match create() { @@ -140,12 +140,12 @@ fn retry_when_access_is_denied(mut create: impl FnMut() -> io::Result) -> mod tests { use std::io; - use super::{retry_when_access_is_denied, TEMPORARY_DIRECTORY_RETRIES}; + use super::{create_temporary_directory, TEMPORARY_DIRECTORY_RETRIES}; #[test] fn retries_when_access_is_denied_once() { let mut calls = 0; - retry_when_access_is_denied(|| { + create_temporary_directory(|| { calls += 1; if calls == 1 { Err(io::Error::from(io::ErrorKind::PermissionDenied)) @@ -160,7 +160,7 @@ mod tests { #[test] fn gives_up_when_access_stays_denied() { let mut calls = 0; - let error = retry_when_access_is_denied(|| -> io::Result<()> { + let error = create_temporary_directory(|| -> io::Result<()> { calls += 1; Err(io::Error::from(io::ErrorKind::PermissionDenied)) }) @@ -172,7 +172,7 @@ mod tests { #[test] fn returns_non_permission_denied_errors_without_retrying() { let mut calls = 0; - let error = retry_when_access_is_denied(|| -> io::Result<()> { + let error = create_temporary_directory(|| -> io::Result<()> { calls += 1; Err(io::Error::from(io::ErrorKind::NotFound)) })