From 13ab7962ac131733400356241c37e3ddd68d1aff Mon Sep 17 00:00:00 2001 From: Chris Denton Date: Tue, 5 Jul 2022 07:53:27 +0100 Subject: [PATCH 1/5] `impl From for FileAttr` --- library/std/src/sys/windows/fs.rs | 37 ++++++++++++++++++------------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/library/std/src/sys/windows/fs.rs b/library/std/src/sys/windows/fs.rs index e9b1006907741..b5d2b4de704a3 100644 --- a/library/std/src/sys/windows/fs.rs +++ b/library/std/src/sys/windows/fs.rs @@ -155,22 +155,7 @@ impl DirEntry { } pub fn metadata(&self) -> io::Result { - Ok(FileAttr { - attributes: self.data.dwFileAttributes, - creation_time: self.data.ftCreationTime, - last_access_time: self.data.ftLastAccessTime, - last_write_time: self.data.ftLastWriteTime, - file_size: ((self.data.nFileSizeHigh as u64) << 32) | (self.data.nFileSizeLow as u64), - reparse_tag: if self.data.dwFileAttributes & c::FILE_ATTRIBUTE_REPARSE_POINT != 0 { - // reserved unless this is a reparse point - self.data.dwReserved0 - } else { - 0 - }, - volume_serial_number: None, - number_of_links: None, - file_index: None, - }) + Ok(self.data.into()) } } @@ -879,6 +864,26 @@ impl FileAttr { self.file_index } } +impl From for FileAttr { + fn from(wfd: c::WIN32_FIND_DATAW) -> Self { + FileAttr { + attributes: wfd.dwFileAttributes, + creation_time: wfd.ftCreationTime, + last_access_time: wfd.ftLastAccessTime, + last_write_time: wfd.ftLastWriteTime, + file_size: ((wfd.nFileSizeHigh as u64) << 32) | (wfd.nFileSizeLow as u64), + reparse_tag: if wfd.dwFileAttributes & c::FILE_ATTRIBUTE_REPARSE_POINT != 0 { + // reserved unless this is a reparse point + wfd.dwReserved0 + } else { + 0 + }, + volume_serial_number: None, + number_of_links: None, + file_index: None, + } + } +} fn to_u64(ft: &c::FILETIME) -> u64 { (ft.dwLowDateTime as u64) | ((ft.dwHighDateTime as u64) << 32) From 8d4adad953edef2ef94b02e2bb1ed9b22bb1d975 Mon Sep 17 00:00:00 2001 From: Chris Denton Date: Tue, 5 Jul 2022 09:13:40 +0100 Subject: [PATCH 2/5] Windows: Use `FindFirstFileW` if `metadata` fails Usually opening a file handle with access set to metadata only will always succeed, even if the file is locked. However some special system files, such as `C:\hiberfil.sys`, are locked by the system in a way that denies even that. So as a fallback we try reading the cached metadata from the directory. --- library/std/src/fs/tests.rs | 11 +++++ library/std/src/sys/windows/fs.rs | 71 ++++++++++++++++++++++++++----- 2 files changed, 72 insertions(+), 10 deletions(-) diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs index e8d0132f4b98c..e1ebb1a690b0a 100644 --- a/library/std/src/fs/tests.rs +++ b/library/std/src/fs/tests.rs @@ -1534,3 +1534,14 @@ fn read_large_dir() { entry.unwrap(); } } + +#[test] +#[cfg(windows)] +fn hiberfil_sys() { + // Get the system drive, which is usually `C:`. + let mut hiberfil = crate::env::var("SystemDrive").unwrap(); + hiberfil.push_str(r"\hiberfil.sys"); + + fs::metadata(&hiberfil).unwrap(); + fs::symlink_metadata(&hiberfil).unwrap(); +} diff --git a/library/std/src/sys/windows/fs.rs b/library/std/src/sys/windows/fs.rs index b5d2b4de704a3..4d3162f125462 100644 --- a/library/std/src/sys/windows/fs.rs +++ b/library/std/src/sys/windows/fs.rs @@ -1150,22 +1150,73 @@ pub fn link(_original: &Path, _link: &Path) -> io::Result<()> { } pub fn stat(path: &Path) -> io::Result { - let mut opts = OpenOptions::new(); - // No read or write permissions are necessary - opts.access_mode(0); - // This flag is so we can open directories too - opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS); - let file = File::open(path, &opts)?; - file.file_attr() + metadata(path, ReparsePoint::Follow) } pub fn lstat(path: &Path) -> io::Result { + metadata(path, ReparsePoint::Open) +} + +#[repr(u32)] +#[derive(Clone, Copy, PartialEq, Eq)] +enum ReparsePoint { + Follow = 0, + Open = c::FILE_FLAG_OPEN_REPARSE_POINT, +} +impl ReparsePoint { + fn as_flag(self) -> u32 { + self as u32 + } +} + +fn metadata(path: &Path, reparse: ReparsePoint) -> io::Result { let mut opts = OpenOptions::new(); // No read or write permissions are necessary opts.access_mode(0); - opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS | c::FILE_FLAG_OPEN_REPARSE_POINT); - let file = File::open(path, &opts)?; - file.file_attr() + opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS | reparse.as_flag()); + + // Attempt to open the file normally. + // If that fails with `ERROR_SHARING_VIOLATION` then retry using `FindFirstFileW`. + // If the fallback fails for any reason we return the original error. + match File::open(path, &opts) { + Ok(file) => file.file_attr(), + Err(e) if e.raw_os_error() == Some(c::ERROR_SHARING_VIOLATION as _) => { + // `ERROR_SHARING_VIOLATION` will almost never be returned. + // Usually if a file is locked you can still read some metadata. + // However, there are special system files, such as + // `C:\hiberfil.sys`, that are locked in a way that denies even that. + unsafe { + let path = maybe_verbatim(path)?; + + // `FindFirstFileW` accepts wildcard file names. + // Fortunately wildcards are not valid file names and + // `ERROR_SHARING_VIOLATION` means the file exists (but is locked) + // therefore it's safe to assume the file name given does not + // include wildcards. + let mut wfd = mem::zeroed(); + let handle = c::FindFirstFileW(path.as_ptr(), &mut wfd); + + if handle == c::INVALID_HANDLE_VALUE { + // This can fail if the user does not have read access to the + // directory. + Err(e) + } else { + // We no longer need the find handle. + c::FindClose(handle); + + // `FindFirstFileW` reads the cached file information from the + // directory. The downside is that this metadata may be outdated. + let attrs = FileAttr::from(wfd); + if reparse == ReparsePoint::Follow && attrs.file_type().is_symlink() { + Err(e) + } else { + Ok(attrs) + } + } + } + } + Err(e) => Err(e), + } } pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> { From 2d0650457f570ca3d0d1ff24092e71291155a8a6 Mon Sep 17 00:00:00 2001 From: Chris Denton Date: Tue, 5 Jul 2022 12:00:51 +0100 Subject: [PATCH 3/5] Add comment and simplify `hiberfil_sys` test --- library/std/src/fs/tests.rs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs index e1ebb1a690b0a..d028204e5a182 100644 --- a/library/std/src/fs/tests.rs +++ b/library/std/src/fs/tests.rs @@ -1535,13 +1535,14 @@ fn read_large_dir() { } } +/// Test the fallback for getting the metadata of files like hiberfil.sys that +/// Windows holds a special lock on, preventing normal means of querying +/// metadata. See #96980. #[test] #[cfg(windows)] fn hiberfil_sys() { - // Get the system drive, which is usually `C:`. - let mut hiberfil = crate::env::var("SystemDrive").unwrap(); - hiberfil.push_str(r"\hiberfil.sys"); + let hiberfil = r"C:\hiberfil.sys"; - fs::metadata(&hiberfil).unwrap(); - fs::symlink_metadata(&hiberfil).unwrap(); + fs::metadata(hiberfil).unwrap(); + fs::symlink_metadata(hiberfil).unwrap(); } From 5f5bcb369730a1095d44adc9843ec80cfddea443 Mon Sep 17 00:00:00 2001 From: Chris Denton Date: Tue, 5 Jul 2022 12:23:06 +0100 Subject: [PATCH 4/5] Test if `[try_]exists` can find `hiberfil.sys` --- library/std/src/fs/tests.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs index d028204e5a182..d8806b6ec60bf 100644 --- a/library/std/src/fs/tests.rs +++ b/library/std/src/fs/tests.rs @@ -1541,8 +1541,10 @@ fn read_large_dir() { #[test] #[cfg(windows)] fn hiberfil_sys() { - let hiberfil = r"C:\hiberfil.sys"; + let hiberfil = Path::new(r"C:\hiberfil.sys"); - fs::metadata(hiberfil).unwrap(); + assert_eq!(true, hiberfil.try_exists().unwrap()); fs::symlink_metadata(hiberfil).unwrap(); + fs::metadata(hiberfil).unwrap(); + assert_eq!(true, hiberfil.exists()); } From eee8ca9a44e89d56ed63cf5a76de64cc6cb23c23 Mon Sep 17 00:00:00 2001 From: Chris Denton Date: Mon, 18 Jul 2022 15:06:07 +0100 Subject: [PATCH 5/5] Ignore `hiberfil_sys` test in CI The file it's testing does not exist in the CI environment. --- library/std/src/fs/tests.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs index d8806b6ec60bf..b8959316de170 100644 --- a/library/std/src/fs/tests.rs +++ b/library/std/src/fs/tests.rs @@ -1538,11 +1538,14 @@ fn read_large_dir() { /// Test the fallback for getting the metadata of files like hiberfil.sys that /// Windows holds a special lock on, preventing normal means of querying /// metadata. See #96980. +/// +/// Note this fails in CI because `hiberfil.sys` does not actually exist there. +/// Therefore it's marked as ignored. #[test] +#[ignore] #[cfg(windows)] fn hiberfil_sys() { let hiberfil = Path::new(r"C:\hiberfil.sys"); - assert_eq!(true, hiberfil.try_exists().unwrap()); fs::symlink_metadata(hiberfil).unwrap(); fs::metadata(hiberfil).unwrap();