rust: fix darwin build

rust/hg-core/src/revlog/options.rs

@@ -1,421 +1,421
 //! Helpers for the revlog config and opening options
 
 use std::collections::HashSet;
 
 use crate::{
     config::{Config, ResourceProfileValue},
     errors::HgError,
     requirements::{
         CHANGELOGV2_REQUIREMENT, GENERALDELTA_REQUIREMENT, NARROW_REQUIREMENT,
         NODEMAP_REQUIREMENT, REVLOGV1_REQUIREMENT, REVLOGV2_REQUIREMENT,
         SPARSEREVLOG_REQUIREMENT,
     },
 };
 
 use super::{compression::CompressionConfig, RevlogType};
 
 const DEFAULT_CHUNK_CACHE_SIZE: u64 = 65536;
 const DEFAULT_SPARSE_READ_DENSITY_THRESHOLD: f64 = 0.50;
 const DEFAULT_SPARSE_READ_MIN_GAP_SIZE: u64 = 262144;
 
 /// The known revlog versions and their options
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum RevlogVersionOptions {
     V0,
     V1 { general_delta: bool, inline: bool },
     V2,
     ChangelogV2 { compute_rank: bool },
 }
 
 /// Options to govern how a revlog should be opened, usually from the
 /// repository configuration or requirements.
 #[derive(Debug, Copy, Clone)]
 pub struct RevlogOpenOptions {
     /// The revlog version, along with any option specific to this version
     pub version: RevlogVersionOptions,
     /// Whether the revlog uses a persistent nodemap.
     pub use_nodemap: bool,
     pub delta_config: RevlogDeltaConfig,
     pub data_config: RevlogDataConfig,
     pub feature_config: RevlogFeatureConfig,
 }
 
 #[cfg(test)]
 impl Default for RevlogOpenOptions {
     fn default() -> Self {
         Self {
             version: RevlogVersionOptions::V1 {
                 general_delta: true,
                 inline: false,
             },
             use_nodemap: true,
             data_config: Default::default(),
             delta_config: Default::default(),
             feature_config: Default::default(),
         }
     }
 }
 
 impl RevlogOpenOptions {
     pub fn new(
         inline: bool,
         data_config: RevlogDataConfig,
         delta_config: RevlogDeltaConfig,
         feature_config: RevlogFeatureConfig,
     ) -> Self {
         Self {
             version: RevlogVersionOptions::V1 {
                 general_delta: data_config.general_delta,
                 inline,
             },
             use_nodemap: false,
             data_config,
             delta_config,
             feature_config,
         }
     }
 
     pub fn index_header(&self) -> super::index::IndexHeader {
         super::index::IndexHeader {
             header_bytes: match self.version {
                 RevlogVersionOptions::V0 => [0, 0, 0, 0],
                 RevlogVersionOptions::V1 {
                     general_delta,
                     inline,
                 } => [
                     0,
                     if general_delta && inline {
                         3
                     } else if general_delta {
                         2
                     } else {
                         u8::from(inline)
                     },
                     0,
                     1,
                 ],
                 RevlogVersionOptions::V2 => 0xDEADu32.to_be_bytes(),
                 RevlogVersionOptions::ChangelogV2 { compute_rank: _ } => {
                     0xD34Du32.to_be_bytes()
                 }
             },
         }
     }
 }
 
 /// Technically only Linux 2.5.46+ has `MAP_POPULATE` and only `2.6.23` on
 /// private mappings, but if you're using such ancient Linux, you have other
 /// problems.
 #[cfg(target_os = "linux")]
 const fn can_populate_mmap() -> bool {
     true
 }
 
 /// There is a of populating mmaps for Windows, but it would need testing.
 #[cfg(not(target_os = "linux"))]
-const fn can_populate_mmap() {
+const fn can_populate_mmap() -> bool {
     false
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 /// Holds configuration values about how the revlog data is read
 pub struct RevlogDataConfig {
     /// Should we try to open the "pending" version of the revlog
     pub try_pending: bool,
     /// Should we try to open the "split" version of the revlog
     pub try_split: bool,
     /// When True, `indexfile` should be opened with `checkambig=True` at
     /// writing time, to avoid file stat ambiguity
     pub check_ambig: bool,
     /// If true, use mmap instead of reading to deal with large indexes
     pub mmap_large_index: bool,
     /// How much data is considered large
     pub mmap_index_threshold: Option<u64>,
     /// How much data to read and cache into the raw revlog data cache
     pub chunk_cache_size: u64,
     /// The size of the uncompressed cache compared to the largest revision
     /// seen
     pub uncompressed_cache_factor: Option<f64>,
     /// The number of chunks cached
     pub uncompressed_cache_count: Option<u64>,
     /// Allow sparse reading of the revlog data
     pub with_sparse_read: bool,
     /// Minimal density of a sparse read chunk
     pub sr_density_threshold: f64,
     /// Minimal size of the data we skip when performing sparse reads
     pub sr_min_gap_size: u64,
     /// Whether deltas are encoded against arbitrary bases
     pub general_delta: bool,
 }
 
 impl RevlogDataConfig {
     pub fn new(
         config: &Config,
         requirements: &HashSet<String>,
     ) -> Result<Self, HgError> {
         let mut data_config = Self::default();
         if let Some(chunk_cache_size) =
             config.get_byte_size(b"format", b"chunkcachesize")?
         {
             data_config.chunk_cache_size = chunk_cache_size;
         }
 
         let memory_profile = config.get_resource_profile(Some("memory"));
         if memory_profile.value >= ResourceProfileValue::Medium {
             data_config.uncompressed_cache_count = Some(10_000);
             data_config.uncompressed_cache_factor = Some(4.0);
             if memory_profile.value >= ResourceProfileValue::High {
                 data_config.uncompressed_cache_factor = Some(10.0)
             }
         }
 
         // Use mmap if requested, or by default if we can fully populate it
         let mmap_index = config
             .get_option_no_default(b"storage", b"revlog.mmap.index")?
             .unwrap_or(can_populate_mmap());
         if mmap_index {
             if let Some(mmap_index_threshold) = config.get_byte_size(
                 b"storage",
                 b"revlog.mmap.index:size-threshold",
             )? {
                 // Only mmap if above the requested size threshold
                 data_config.mmap_index_threshold = Some(mmap_index_threshold);
             }
         }
 
         if let Some(mmap_index_threshold) = config
             .get_byte_size(b"storage", b"revlog.mmap.index:size-threshold")?
         {
             data_config.mmap_index_threshold = Some(mmap_index_threshold);
         }
 
         let with_sparse_read =
             config.get_bool(b"experimental", b"sparse-read")?;
         if let Some(sr_density_threshold) = config
             .get_f64(b"experimental", b"sparse-read.density-threshold")?
         {
             data_config.sr_density_threshold = sr_density_threshold;
         }
         data_config.with_sparse_read = with_sparse_read;
         if let Some(sr_min_gap_size) = config
             .get_byte_size(b"experimental", b"sparse-read.min-gap-size")?
         {
             data_config.sr_min_gap_size = sr_min_gap_size;
         }
 
         data_config.with_sparse_read =
             requirements.contains(SPARSEREVLOG_REQUIREMENT);
 
         Ok(data_config)
     }
 }
 
 impl Default for RevlogDataConfig {
     fn default() -> Self {
         Self {
             chunk_cache_size: DEFAULT_CHUNK_CACHE_SIZE,
             sr_density_threshold: DEFAULT_SPARSE_READ_DENSITY_THRESHOLD,
             sr_min_gap_size: DEFAULT_SPARSE_READ_MIN_GAP_SIZE,
             try_pending: Default::default(),
             try_split: Default::default(),
             check_ambig: Default::default(),
             mmap_large_index: Default::default(),
             mmap_index_threshold: Default::default(),
             uncompressed_cache_factor: Default::default(),
             uncompressed_cache_count: Default::default(),
             with_sparse_read: Default::default(),
             general_delta: Default::default(),
         }
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 /// Holds configuration values about how new deltas are computed.
 ///
 /// Some attributes are duplicated from [`RevlogDataConfig`] to help having
 /// each object self contained.
 pub struct RevlogDeltaConfig {
     /// Whether deltas can be encoded against arbitrary bases
     pub general_delta: bool,
     /// Allow sparse writing of the revlog data
     pub sparse_revlog: bool,
     /// Maximum length of a delta chain
     pub max_chain_len: Option<u64>,
     /// Maximum distance between a delta chain's start and end
     pub max_deltachain_span: Option<u64>,
     /// If `upper_bound_comp` is not None, this is the expected maximal
     /// gain from compression for the data content
     pub upper_bound_comp: Option<f64>,
     /// Should we try a delta against both parents
     pub delta_both_parents: bool,
     /// Test delta base candidate groups by chunks of this maximal size
     pub candidate_group_chunk_size: u64,
     /// Should we display debug information about delta computation
     pub debug_delta: bool,
     /// Trust incoming deltas by default
     pub lazy_delta: bool,
     /// Trust the base of incoming deltas by default
     pub lazy_delta_base: bool,
 }
 
 impl RevlogDeltaConfig {
     pub fn new(
         config: &Config,
         requirements: &HashSet<String>,
         revlog_type: RevlogType,
     ) -> Result<Self, HgError> {
         let mut delta_config = Self {
             delta_both_parents: config
                 .get_option_no_default(
                     b"storage",
                     b"revlog.optimize-delta-parent-choice",
                 )?
                 .unwrap_or(true),
             candidate_group_chunk_size: config
                 .get_u64(
                     b"storage",
                     b"revlog.delta-parent-search.candidate-group-chunk-size",
                 )?
                 .unwrap_or_default(),
             ..Default::default()
         };
 
         delta_config.debug_delta =
             config.get_bool(b"debug", b"revlog.debug-delta")?;
 
         delta_config.general_delta =
             requirements.contains(GENERALDELTA_REQUIREMENT);
 
         let lazy_delta =
             config.get_bool(b"storage", b"revlog.reuse-external-delta")?;
 
         if revlog_type == RevlogType::Manifestlog {
             // upper bound of what we expect from compression
             // (real life value seems to be 3)
             delta_config.upper_bound_comp = Some(3.0)
         }
 
         let mut lazy_delta_base = false;
         if lazy_delta {
             lazy_delta_base = match config.get_option_no_default(
                 b"storage",
                 b"revlog.reuse-external-delta-parent",
             )? {
                 Some(base) => base,
                 None => config.get_bool(b"format", b"generaldelta")?,
             };
         }
         delta_config.lazy_delta = lazy_delta;
         delta_config.lazy_delta_base = lazy_delta_base;
 
         delta_config.max_deltachain_span =
             match config.get_i64(b"experimental", b"maxdeltachainspan")? {
                 Some(span) => {
                     if span < 0 {
                         None
                     } else {
                         Some(span as u64)
                     }
                 }
                 None => None,
             };
 
         delta_config.sparse_revlog =
             requirements.contains(SPARSEREVLOG_REQUIREMENT);
 
         delta_config.max_chain_len =
             config.get_byte_size_no_default(b"format", b"maxchainlen")?;
 
         Ok(delta_config)
     }
 }
 
 impl Default for RevlogDeltaConfig {
     fn default() -> Self {
         Self {
             delta_both_parents: true,
             lazy_delta: true,
             general_delta: Default::default(),
             sparse_revlog: Default::default(),
             max_chain_len: Default::default(),
             max_deltachain_span: Default::default(),
             upper_bound_comp: Default::default(),
             candidate_group_chunk_size: Default::default(),
             debug_delta: Default::default(),
             lazy_delta_base: Default::default(),
         }
     }
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 /// Holds configuration values about the available revlog features
 pub struct RevlogFeatureConfig {
     /// The compression engine and its options
     pub compression_engine: CompressionConfig,
     /// Can we use censor on this revlog
     pub censorable: bool,
     /// Does this revlog use the "side data" feature
     pub has_side_data: bool,
     /// Might remove this configuration once the rank computation has no
     /// impact
     pub compute_rank: bool,
     /// Parent order is supposed to be semantically irrelevant, so we
     /// normally re-sort parents to ensure that the first parent is non-null,
     /// if there is a non-null parent at all.
     /// filelog abuses the parent order as a flag to mark some instances of
     /// meta-encoded files, so allow it to disable this behavior.
     pub canonical_parent_order: bool,
     /// Can ellipsis commit be used
     pub enable_ellipsis: bool,
 }
 
 impl RevlogFeatureConfig {
     pub fn new(
         config: &Config,
         requirements: &HashSet<String>,
     ) -> Result<Self, HgError> {
         Ok(Self {
             compression_engine: CompressionConfig::new(config, requirements)?,
             enable_ellipsis: requirements.contains(NARROW_REQUIREMENT),
             ..Default::default()
         })
     }
 }
 
 /// Return the default options for a revlog of `revlog_type` according to the
 /// current config and requirements.
 pub fn default_revlog_options(
     config: &Config,
     requirements: &HashSet<String>,
     revlog_type: RevlogType,
 ) -> Result<RevlogOpenOptions, HgError> {
     let is_changelog = revlog_type == RevlogType::Changelog;
     let version =
         if is_changelog && requirements.contains(CHANGELOGV2_REQUIREMENT) {
             let compute_rank = config
                 .get_bool(b"experimental", b"changelog-v2.compute-rank")?;
             RevlogVersionOptions::ChangelogV2 { compute_rank }
         } else if requirements.contains(REVLOGV2_REQUIREMENT) {
             RevlogVersionOptions::V2
         } else if requirements.contains(REVLOGV1_REQUIREMENT) {
             RevlogVersionOptions::V1 {
                 general_delta: requirements.contains(GENERALDELTA_REQUIREMENT),
                 inline: !is_changelog,
             }
         } else {
             RevlogVersionOptions::V0
         };
     Ok(RevlogOpenOptions {
         version,
         // We don't need to dance around the slow path like in the Python
         // implementation since we know we have access to the fast code.
         use_nodemap: requirements.contains(NODEMAP_REQUIREMENT),
         delta_config: RevlogDeltaConfig::new(
             config,
             requirements,
             revlog_type,
         )?,
         data_config: RevlogDataConfig::new(config, requirements)?,
         feature_config: RevlogFeatureConfig::new(config, requirements)?,
     })
 }

rust/hg-core/src/vfs.rs

@@ -1,1130 +1,1131
 use crate::errors::{HgError, HgResultExt, IoErrorContext, IoResultExt};
 use crate::exit_codes;
 use crate::fncache::FnCache;
 use crate::revlog::path_encode::path_encode;
 use crate::utils::files::{get_bytes_from_path, get_path_from_bytes};
 use dyn_clone::DynClone;
 use format_bytes::format_bytes;
 use memmap2::{Mmap, MmapOptions};
 use rand::distributions::{Alphanumeric, DistString};
 use std::fs::{File, Metadata, OpenOptions};
 use std::io::{ErrorKind, Read, Seek, Write};
 use std::os::fd::AsRawFd;
 use std::os::unix::fs::{MetadataExt, PermissionsExt};
 use std::path::{Path, PathBuf};
 #[cfg(test)]
 use std::sync::atomic::AtomicUsize;
 #[cfg(test)]
 use std::sync::atomic::Ordering;
 use std::sync::OnceLock;
 
 /// Filesystem access abstraction for the contents of a given "base" diretory
 #[derive(Clone)]
 pub struct VfsImpl {
     pub(crate) base: PathBuf,
     pub readonly: bool,
     pub mode: Option<u32>,
 }
 
 struct FileNotFound(std::io::Error, PathBuf);
 
 /// Store the umask for the whole process since it's expensive to get.
 static UMASK: OnceLock<u32> = OnceLock::new();
 
 fn get_umask() -> u32 {
     *UMASK.get_or_init(|| unsafe {
         // TODO is there any way of getting the umask without temporarily
         // setting it? Doesn't this affect all threads in this tiny window?
         let mask = libc::umask(0);
         libc::umask(mask);
-        mask & 0o777
+        #[allow(clippy::useless_conversion)]
+        (mask & 0o777).into()
     })
 }
 
 /// Return the (unix) mode with which we will create/fix files
 fn get_mode(base: impl AsRef<Path>) -> Option<u32> {
     match base.as_ref().metadata() {
         Ok(meta) => {
             // files in .hg/ will be created using this mode
             let mode = meta.mode();
             // avoid some useless chmods
             if (0o777 & !get_umask()) == (0o777 & mode) {
                 None
             } else {
                 Some(mode)
             }
         }
         Err(_) => None,
     }
 }
 
 impl VfsImpl {
     pub fn new(base: PathBuf, readonly: bool) -> Self {
         let mode = get_mode(&base);
         Self {
             base,
             readonly,
             mode,
         }
     }
 
     // XXX these methods are probably redundant with VFS trait?
 
     pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
         self.base.join(relative_path)
     }
 
     pub fn symlink_metadata(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<std::fs::Metadata, HgError> {
         let path = self.join(relative_path);
         std::fs::symlink_metadata(&path).when_reading_file(&path)
     }
 
     pub fn read_link(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<PathBuf, HgError> {
         let path = self.join(relative_path);
         std::fs::read_link(&path).when_reading_file(&path)
     }
 
     pub fn read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Vec<u8>, HgError> {
         let path = self.join(relative_path);
         std::fs::read(&path).when_reading_file(&path)
     }
 
     /// Returns `Ok(None)` if the file does not exist.
     pub fn try_read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Option<Vec<u8>>, HgError> {
         match self.read(relative_path) {
             Err(e) => match &e {
                 HgError::IoError { error, .. } => match error.kind() {
                     ErrorKind::NotFound => Ok(None),
                     _ => Err(e),
                 },
                 _ => Err(e),
             },
             Ok(v) => Ok(Some(v)),
         }
     }
 
     fn mmap_open_gen(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Result<Mmap, FileNotFound>, HgError> {
         let path = self.join(relative_path);
         let file = match std::fs::File::open(&path) {
             Err(err) => {
                 if let ErrorKind::NotFound = err.kind() {
                     return Ok(Err(FileNotFound(err, path)));
                 };
                 return (Err(err)).when_reading_file(&path);
             }
             Ok(file) => file,
         };
         // Safety is "enforced" by locks and assuming other processes are
         // well-behaved. If any misbehaving or malicious process does touch
         // the index, it could lead to corruption. This is inherent
         // to file-based `mmap`, though some platforms have some ways of
         // mitigating.
         // TODO linux: set the immutable flag with `chattr(1)`?
         let mmap = unsafe { MmapOptions::new().map(&file) }
             .when_reading_file(&path)?;
         Ok(Ok(mmap))
     }
 
     pub fn mmap_open_opt(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Option<Mmap>, HgError> {
         self.mmap_open_gen(relative_path).map(|res| res.ok())
     }
 
     pub fn mmap_open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Mmap, HgError> {
         match self.mmap_open_gen(relative_path)? {
             Err(FileNotFound(err, path)) => Err(err).when_reading_file(&path),
             Ok(res) => Ok(res),
         }
     }
 
     #[cfg(unix)]
     pub fn create_symlink(
         &self,
         relative_link_path: impl AsRef<Path>,
         target_path: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let link_path = self.join(relative_link_path);
         std::os::unix::fs::symlink(target_path, &link_path)
             .when_writing_file(&link_path)
     }
 
     /// Write `contents` into a temporary file, then rename to `relative_path`.
     /// This makes writing to a file "atomic": a reader opening that path will
     /// see either the previous contents of the file or the complete new
     /// content, never a partial write.
     pub fn atomic_write(
         &self,
         relative_path: impl AsRef<Path>,
         contents: &[u8],
     ) -> Result<(), HgError> {
         let mut tmp = tempfile::NamedTempFile::new_in(&self.base)
             .when_writing_file(&self.base)?;
         tmp.write_all(contents)
             .and_then(|()| tmp.flush())
             .when_writing_file(tmp.path())?;
         let path = self.join(relative_path);
         tmp.persist(&path)
             .map_err(|e| e.error)
             .when_writing_file(&path)?;
         Ok(())
     }
 }
 
 fn fs_metadata(
     path: impl AsRef<Path>,
 ) -> Result<Option<std::fs::Metadata>, HgError> {
     let path = path.as_ref();
     match path.metadata() {
         Ok(meta) => Ok(Some(meta)),
         Err(error) => match error.kind() {
             // TODO: when we require a Rust version where `NotADirectory` is
             // stable, invert this logic and return None for it and `NotFound`
             // and propagate any other error.
             ErrorKind::PermissionDenied => Err(error).with_context(|| {
                 IoErrorContext::ReadingMetadata(path.to_owned())
             }),
             _ => Ok(None),
         },
     }
 }
 
 /// Abstraction over the files handled by a [`Vfs`].
 #[derive(Debug)]
 pub enum VfsFile {
     Atomic(AtomicFile),
 
     Normal {
         file: File,
         path: PathBuf,
         /// If `Some`, check (and maybe fix) this file's timestamp ambiguity.
         /// See [`is_filetime_ambiguous`].
         check_ambig: Option<Metadata>,
     },
 }
 
 impl VfsFile {
     pub fn normal(file: File, path: PathBuf) -> Self {
         Self::Normal {
             file,
             check_ambig: None,
             path,
         }
     }
     pub fn normal_check_ambig(
         file: File,
         path: PathBuf,
     ) -> Result<Self, HgError> {
         Ok(Self::Normal {
             file,
             check_ambig: Some(path.metadata().when_reading_file(&path)?),
             path,
         })
     }
     pub fn try_clone(&self) -> Result<VfsFile, HgError> {
         Ok(match self {
             VfsFile::Atomic(AtomicFile {
                 fp,
                 temp_path,
                 check_ambig,
                 target_name,
                 is_open,
             }) => Self::Atomic(AtomicFile {
                 fp: fp.try_clone().when_reading_file(temp_path)?,
                 temp_path: temp_path.clone(),
                 check_ambig: *check_ambig,
                 target_name: target_name.clone(),
                 is_open: *is_open,
             }),
             VfsFile::Normal {
                 file,
                 check_ambig,
                 path,
             } => Self::Normal {
                 file: file.try_clone().when_reading_file(path)?,
                 check_ambig: check_ambig.clone(),
                 path: path.to_owned(),
             },
         })
     }
     pub fn set_len(&self, len: u64) -> Result<(), std::io::Error> {
         match self {
             VfsFile::Atomic(atomic_file) => atomic_file.fp.set_len(len),
             VfsFile::Normal { file, .. } => file.set_len(len),
         }
     }
 
     pub fn metadata(&self) -> Result<std::fs::Metadata, std::io::Error> {
         match self {
             VfsFile::Atomic(atomic_file) => atomic_file.fp.metadata(),
             VfsFile::Normal { file, .. } => file.metadata(),
         }
     }
 }
 
 impl AsRawFd for VfsFile {
     fn as_raw_fd(&self) -> std::os::unix::prelude::RawFd {
         match self {
             VfsFile::Atomic(atomic_file) => atomic_file.fp.as_raw_fd(),
             VfsFile::Normal { file, .. } => file.as_raw_fd(),
         }
     }
 }
 
 impl Seek for VfsFile {
     fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
         match self {
             VfsFile::Atomic(atomic_file) => atomic_file.seek(pos),
             VfsFile::Normal { file, .. } => file.seek(pos),
         }
     }
 }
 
 impl Read for VfsFile {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         match self {
             VfsFile::Atomic(atomic_file) => atomic_file.fp.read(buf),
             VfsFile::Normal { file, .. } => file.read(buf),
         }
     }
 }
 
 impl Write for VfsFile {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         match self {
             VfsFile::Atomic(atomic_file) => atomic_file.fp.write(buf),
             VfsFile::Normal { file, .. } => file.write(buf),
         }
     }
 
     fn flush(&mut self) -> std::io::Result<()> {
         match self {
             VfsFile::Atomic(atomic_file) => atomic_file.fp.flush(),
             VfsFile::Normal { file, .. } => file.flush(),
         }
     }
 }
 
 impl Drop for VfsFile {
     fn drop(&mut self) {
         if let VfsFile::Normal {
             path,
             check_ambig: Some(old),
             ..
         } = self
         {
             avoid_timestamp_ambiguity(path, old)
         }
     }
 }
 
 /// Records the number of times we've fixed a timestamp ambiguity, only
 /// applicable for tests.
 #[cfg(test)]
 static TIMESTAMP_FIXES_CALLS: AtomicUsize = AtomicUsize::new(0);
 
 fn avoid_timestamp_ambiguity(path: &Path, old: &Metadata) {
     if let Ok(new) = path.metadata() {
         let is_ambiguous = is_filetime_ambiguous(&new, old);
         if is_ambiguous {
             let advanced =
                 filetime::FileTime::from_unix_time(old.mtime() + 1, 0);
             if filetime::set_file_times(path, advanced, advanced).is_ok() {
                 #[cfg(test)]
                 {
                     TIMESTAMP_FIXES_CALLS.fetch_add(1, Ordering::Relaxed);
                 }
             }
         }
     }
 }
 
 /// Examine whether new stat is ambiguous against old one
 ///
 /// `S[N]` below means stat of a file at `N`-th change:
 ///
 /// - `S[n-1].ctime  < S[n].ctime`: can detect change of a file
 /// - `S[n-1].ctime == S[n].ctime`
 ///   - `S[n-1].ctime  < S[n].mtime`: means natural advancing (*1)
 ///   - `S[n-1].ctime == S[n].mtime`: is ambiguous (*2)
 ///   - `S[n-1].ctime  > S[n].mtime`: never occurs naturally (don't care)
 /// - `S[n-1].ctime  > S[n].ctime`: never occurs naturally (don't care)
 ///
 /// Case (*2) above means that a file was changed twice or more at
 /// same time in sec (= `S[n-1].ctime`), and comparison of timestamp
 /// is ambiguous.
 ///
 /// Base idea to avoid such ambiguity is "advance mtime 1 sec, if
 /// timestamp is ambiguous".
 ///
 /// But advancing mtime only in case (*2) doesn't work as
 /// expected, because naturally advanced `S[n].mtime` in case (*1)
 /// might be equal to manually advanced `S[n-1 or earlier].mtime`.
 ///
 /// Therefore, all `S[n-1].ctime == S[n].ctime` cases should be
 /// treated as ambiguous regardless of mtime, to avoid overlooking
 /// by confliction between such mtime.
 ///
 /// Advancing mtime `if isambig(new, old)` ensures `S[n-1].mtime !=
 /// S[n].mtime`, even if size of a file isn't changed.
 pub fn is_filetime_ambiguous(new: &Metadata, old: &Metadata) -> bool {
     new.ctime() == old.ctime()
 }
 
 /// Writable file object that atomically updates a file
 ///
 /// All writes will go to a temporary copy of the original file. Call
 /// [`Self::close`] when you are done writing, and [`Self`] will rename
 /// the temporary copy to the original name, making the changes
 /// visible. If the object is destroyed without being closed, all your
 /// writes are discarded.
 #[derive(Debug)]
 pub struct AtomicFile {
     /// The temporary file to write to
     fp: std::fs::File,
     /// Path of the temp file
     temp_path: PathBuf,
     /// Used when stat'ing the file, is useful only if the target file is
     /// guarded by any lock (e.g. repo.lock or repo.wlock).
     check_ambig: bool,
     /// Path of the target file
     target_name: PathBuf,
     /// Whether the file is open or not
     is_open: bool,
 }
 
 impl AtomicFile {
     pub fn new(
         target_path: impl AsRef<Path>,
         empty: bool,
         check_ambig: bool,
     ) -> Result<Self, HgError> {
         let target_path = target_path.as_ref().to_owned();
 
         let random_id =
             Alphanumeric.sample_string(&mut rand::thread_rng(), 12);
         let filename =
             target_path.file_name().expect("target has no filename");
         let filename = get_bytes_from_path(filename);
         let temp_filename =
             format_bytes!(b".{}-{}~", filename, random_id.as_bytes());
         let temp_path =
             target_path.with_file_name(get_path_from_bytes(&temp_filename));
 
         if !empty {
             std::fs::copy(&target_path, &temp_path)
                 .with_context(|| IoErrorContext::CopyingFile {
                     from: target_path.to_owned(),
                     to: temp_path.to_owned(),
                 })
                 // If it doesn't exist, create it on open
                 .io_not_found_as_none()?;
         }
         let fp = std::fs::OpenOptions::new()
             .write(true)
             .create(true)
             .truncate(empty)
             .open(&temp_path)
             .when_writing_file(&temp_path)?;
 
         Ok(Self {
             fp,
             temp_path,
             check_ambig,
             target_name: target_path,
             is_open: true,
         })
     }
 
     pub fn from_file(
         fp: std::fs::File,
         check_ambig: bool,
         temp_name: PathBuf,
         target_name: PathBuf,
     ) -> Self {
         Self {
             fp,
             check_ambig,
             temp_path: temp_name,
             target_name,
             is_open: true,
         }
     }
 
     /// Write `buf` to the temporary file
     pub fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
         self.fp.write_all(buf)
     }
 
     fn target(&self) -> PathBuf {
         self.temp_path
             .parent()
             .expect("should not be at the filesystem root")
             .join(&self.target_name)
     }
 
     /// Close the temporary file and rename to the target
     pub fn close(mut self) -> Result<(), std::io::Error> {
         self.fp.flush()?;
         let target = self.target();
         if self.check_ambig {
             if let Ok(stat) = target.metadata() {
                 std::fs::rename(&self.temp_path, &target)?;
                 avoid_timestamp_ambiguity(&target, &stat);
             } else {
                 std::fs::rename(&self.temp_path, target)?;
             }
         } else {
             std::fs::rename(&self.temp_path, target)?;
         }
         self.is_open = false;
         Ok(())
     }
 }
 
 impl Seek for AtomicFile {
     fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
         self.fp.seek(pos)
     }
 }
 
 impl Drop for AtomicFile {
     fn drop(&mut self) {
         if self.is_open {
             std::fs::remove_file(&self.temp_path).ok();
         }
     }
 }
 
 /// Abstracts over the VFS to allow for different implementations of the
 /// filesystem layer (like passing one from Python).
 pub trait Vfs: Sync + Send + DynClone {
     /// Open a [`VfsFile::Normal`] for reading the file at `filename`,
     /// relative to this VFS's root.
     fn open(&self, filename: &Path) -> Result<VfsFile, HgError>;
     /// Open a [`VfsFile::Normal`] for writing and reading the file at
     /// `filename`, relative to this VFS's root.
     fn open_write(&self, filename: &Path) -> Result<VfsFile, HgError>;
     /// Open a [`VfsFile::Normal`] for reading and writing the file at
     /// `filename`, relative to this VFS's root. This file will be checked
     /// for an ambiguous mtime on [`drop`]. See [`is_filetime_ambiguous`].
     fn open_check_ambig(&self, filename: &Path) -> Result<VfsFile, HgError>;
     /// Create a [`VfsFile::Normal`] for reading and writing the file at
     /// `filename`, relative to this VFS's root. If the file already exists,
     /// it will be truncated to 0 bytes.
     fn create(
         &self,
         filename: &Path,
         check_ambig: bool,
     ) -> Result<VfsFile, HgError>;
     /// Create a [`VfsFile::Atomic`] for reading and writing the file at
     /// `filename`, relative to this VFS's root. If the file already exists,
     /// it will be truncated to 0 bytes.
     fn create_atomic(
         &self,
         filename: &Path,
         check_ambig: bool,
     ) -> Result<VfsFile, HgError>;
     /// Return the total file size in bytes of the open `file`. Errors are
     /// usual IO errors (invalid file handle, permissions, etc.)
     fn file_size(&self, file: &VfsFile) -> Result<u64, HgError>;
     /// Return `true` if `filename` exists relative to this VFS's root. Errors
     /// will coerce to `false`, to this also returns `false` if there are
     /// IO problems. This is fine because any operation that actually tries
     /// to do anything with this path will get the same error.
     fn exists(&self, filename: &Path) -> bool;
     /// Remove the file at `filename` relative to this VFS's root. Errors
     /// are the usual IO errors (lacking permission, file does not exist, etc.)
     fn unlink(&self, filename: &Path) -> Result<(), HgError>;
     /// Rename the file `from` to `to`, both relative to this VFS's root.
     /// Errors are the usual IO errors (lacking permission, file does not
     /// exist, etc.). If `check_ambig` is `true`, the VFS will check for an
     /// ambiguous mtime on rename. See [`is_filetime_ambiguous`].
     fn rename(
         &self,
         from: &Path,
         to: &Path,
         check_ambig: bool,
     ) -> Result<(), HgError>;
     /// Rename the file `from` to `to`, both relative to this VFS's root.
     /// Errors are the usual IO errors (lacking permission, file does not
     /// exist, etc.). If `check_ambig` is passed, the VFS will check for an
     /// ambiguous mtime on rename. See [`is_filetime_ambiguous`].
     fn copy(&self, from: &Path, to: &Path) -> Result<(), HgError>;
     /// Returns the absolute root path of this VFS, relative to which all
     /// operations are done.
     fn base(&self) -> &Path;
 }
 
 /// These methods will need to be implemented once `rhg` (and other) non-Python
 /// users of `hg-core` start doing more on their own, like writing to files.
 impl Vfs for VfsImpl {
     fn open(&self, filename: &Path) -> Result<VfsFile, HgError> {
         // TODO auditpath
         let path = self.base.join(filename);
         Ok(VfsFile::normal(
             std::fs::File::open(&path).when_reading_file(&path)?,
             filename.to_owned(),
         ))
     }
 
     fn open_write(&self, filename: &Path) -> Result<VfsFile, HgError> {
         if self.readonly {
             return Err(HgError::abort(
                 "write access in a readonly vfs",
                 exit_codes::ABORT,
                 None,
             ));
         }
         // TODO auditpath
         let path = self.base.join(filename);
         copy_in_place_if_hardlink(&path)?;
 
         Ok(VfsFile::normal(
             OpenOptions::new()
                 .create(false)
                 .create_new(false)
                 .write(true)
                 .read(true)
                 .open(&path)
                 .when_writing_file(&path)?,
             path.to_owned(),
         ))
     }
 
     fn open_check_ambig(&self, filename: &Path) -> Result<VfsFile, HgError> {
         if self.readonly {
             return Err(HgError::abort(
                 "write access in a readonly vfs",
                 exit_codes::ABORT,
                 None,
             ));
         }
 
         let path = self.base.join(filename);
         copy_in_place_if_hardlink(&path)?;
 
         // TODO auditpath
         VfsFile::normal_check_ambig(
             OpenOptions::new()
                 .write(true)
                 .read(true) // Can be used for reading to save on `open` calls
                 .create(false)
                 .open(&path)
                 .when_reading_file(&path)?,
             path.to_owned(),
         )
     }
 
     fn create(
         &self,
         filename: &Path,
         check_ambig: bool,
     ) -> Result<VfsFile, HgError> {
         if self.readonly {
             return Err(HgError::abort(
                 "write access in a readonly vfs",
                 exit_codes::ABORT,
                 None,
             ));
         }
         // TODO auditpath
         let path = self.base.join(filename);
         let parent = path.parent().expect("file at root");
         std::fs::create_dir_all(parent).when_writing_file(parent)?;
 
         let file = OpenOptions::new()
             .create(true)
             .truncate(true)
             .write(true)
             .read(true)
             .open(&path)
             .when_writing_file(&path)?;
 
         if let Some(mode) = self.mode {
             // Creating the file with the right permission (with `.mode()`)
             // may not work since umask takes effect for file creation.
             // So we need to fix the permission after creating the file.
             fix_directory_permissions(&self.base, &path, mode)?;
             let perm = std::fs::Permissions::from_mode(mode & 0o666);
             std::fs::set_permissions(&path, perm).when_writing_file(&path)?;
         }
 
         Ok(VfsFile::Normal {
             file,
             check_ambig: if check_ambig {
                 Some(path.metadata().when_reading_file(&path)?)
             } else {
                 None
             },
             path: path.to_owned(),
         })
     }
 
     fn create_atomic(
         &self,
         _filename: &Path,
         _check_ambig: bool,
     ) -> Result<VfsFile, HgError> {
         todo!()
     }
 
     fn file_size(&self, file: &VfsFile) -> Result<u64, HgError> {
         Ok(file
             .metadata()
             .map_err(|e| {
                 HgError::abort(
                     format!("Could not get file metadata: {}", e),
                     exit_codes::ABORT,
                     None,
                 )
             })?
             .size())
     }
 
     fn exists(&self, filename: &Path) -> bool {
         self.base.join(filename).exists()
     }
 
     fn unlink(&self, filename: &Path) -> Result<(), HgError> {
         if self.readonly {
             return Err(HgError::abort(
                 "write access in a readonly vfs",
                 exit_codes::ABORT,
                 None,
             ));
         }
         let path = self.base.join(filename);
         std::fs::remove_file(&path)
             .with_context(|| IoErrorContext::RemovingFile(path))
     }
 
     fn rename(
         &self,
         from: &Path,
         to: &Path,
         check_ambig: bool,
     ) -> Result<(), HgError> {
         if self.readonly {
             return Err(HgError::abort(
                 "write access in a readonly vfs",
                 exit_codes::ABORT,
                 None,
             ));
         }
         let old_stat = if check_ambig {
             Some(
                 from.metadata()
                     .when_reading_file(from)
                     .io_not_found_as_none()?,
             )
         } else {
             None
         };
         let from = self.base.join(from);
         let to = self.base.join(to);
         std::fs::rename(&from, &to).with_context(|| {
             IoErrorContext::RenamingFile {
                 from,
                 to: to.to_owned(),
             }
         })?;
         if let Some(Some(old)) = old_stat {
             avoid_timestamp_ambiguity(&to, &old);
         }
         Ok(())
     }
 
     fn copy(&self, from: &Path, to: &Path) -> Result<(), HgError> {
         let from = self.base.join(from);
         let to = self.base.join(to);
         std::fs::copy(&from, &to)
             .with_context(|| IoErrorContext::CopyingFile { from, to })
             .map(|_| ())
     }
 
     fn base(&self) -> &Path {
         &self.base
     }
 }
 
 fn fix_directory_permissions(
     base: &Path,
     path: &Path,
     mode: u32,
 ) -> Result<(), HgError> {
     let mut ancestors = path.ancestors();
     ancestors.next(); // yields the path itself
 
     for ancestor in ancestors {
         if ancestor == base {
             break;
         }
         let perm = std::fs::Permissions::from_mode(mode);
         std::fs::set_permissions(ancestor, perm)
             .when_writing_file(ancestor)?;
     }
     Ok(())
 }
 
 /// A VFS that understands the `fncache` store layout (file encoding), and
 /// adds new entries to the `fncache`.
 /// TODO Only works when using from Python for now.
 pub struct FnCacheVfs {
     inner: VfsImpl,
     fncache: Box<dyn FnCache>,
 }
 
 impl Clone for FnCacheVfs {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
             fncache: dyn_clone::clone_box(&*self.fncache),
         }
     }
 }
 
 impl FnCacheVfs {
     pub fn new(
         base: PathBuf,
         readonly: bool,
         fncache: Box<dyn FnCache>,
     ) -> Self {
         let inner = VfsImpl::new(base, readonly);
         Self { inner, fncache }
     }
 
     fn maybe_add_to_fncache(
         &self,
         filename: &Path,
         encoded_path: &Path,
     ) -> Result<(), HgError> {
         let relevant_file = (filename.starts_with("data/")
             || filename.starts_with("meta/"))
             && is_revlog_file(filename);
         if relevant_file {
             let not_load = !self.fncache.is_loaded()
                 && (self.exists(filename)
                     && self
                         .inner
                         .join(encoded_path)
                         .metadata()
                         .when_reading_file(encoded_path)?
                         .size()
                         != 0);
             if !not_load {
                 self.fncache.add(filename);
             }
         };
         Ok(())
     }
 }
 
 impl Vfs for FnCacheVfs {
     fn open(&self, filename: &Path) -> Result<VfsFile, HgError> {
         let encoded = path_encode(&get_bytes_from_path(filename));
         let filename = get_path_from_bytes(&encoded);
         self.inner.open(filename)
     }
 
     fn open_write(&self, filename: &Path) -> Result<VfsFile, HgError> {
         let encoded = path_encode(&get_bytes_from_path(filename));
         let encoded_path = get_path_from_bytes(&encoded);
         self.maybe_add_to_fncache(filename, encoded_path)?;
         self.inner.open_write(encoded_path)
     }
 
     fn open_check_ambig(&self, filename: &Path) -> Result<VfsFile, HgError> {
         let encoded = path_encode(&get_bytes_from_path(filename));
         let filename = get_path_from_bytes(&encoded);
         self.inner.open_check_ambig(filename)
     }
 
     fn create(
         &self,
         filename: &Path,
         check_ambig: bool,
     ) -> Result<VfsFile, HgError> {
         let encoded = path_encode(&get_bytes_from_path(filename));
         let encoded_path = get_path_from_bytes(&encoded);
         self.maybe_add_to_fncache(filename, encoded_path)?;
         self.inner.create(encoded_path, check_ambig)
     }
 
     fn create_atomic(
         &self,
         filename: &Path,
         check_ambig: bool,
     ) -> Result<VfsFile, HgError> {
         let encoded = path_encode(&get_bytes_from_path(filename));
         let filename = get_path_from_bytes(&encoded);
         self.inner.create_atomic(filename, check_ambig)
     }
 
     fn file_size(&self, file: &VfsFile) -> Result<u64, HgError> {
         self.inner.file_size(file)
     }
 
     fn exists(&self, filename: &Path) -> bool {
         let encoded = path_encode(&get_bytes_from_path(filename));
         let filename = get_path_from_bytes(&encoded);
         self.inner.exists(filename)
     }
 
     fn unlink(&self, filename: &Path) -> Result<(), HgError> {
         let encoded = path_encode(&get_bytes_from_path(filename));
         let filename = get_path_from_bytes(&encoded);
         self.inner.unlink(filename)
     }
 
     fn rename(
         &self,
         from: &Path,
         to: &Path,
         check_ambig: bool,
     ) -> Result<(), HgError> {
         let encoded = path_encode(&get_bytes_from_path(from));
         let from = get_path_from_bytes(&encoded);
         let encoded = path_encode(&get_bytes_from_path(to));
         let to = get_path_from_bytes(&encoded);
         self.inner.rename(from, to, check_ambig)
     }
 
     fn copy(&self, from: &Path, to: &Path) -> Result<(), HgError> {
         let encoded = path_encode(&get_bytes_from_path(from));
         let from = get_path_from_bytes(&encoded);
         let encoded = path_encode(&get_bytes_from_path(to));
         let to = get_path_from_bytes(&encoded);
         self.inner.copy(from, to)
     }
     fn base(&self) -> &Path {
         self.inner.base()
     }
 }
 
 /// Detects whether `path` is a hardlink and does a tmp copy + rename erase
 /// to turn it into its own file. Revlogs are usually hardlinked when doing
 /// a local clone, and we don't want to modify the original repo.
 fn copy_in_place_if_hardlink(path: &Path) -> Result<(), HgError> {
     let metadata = path.metadata().when_writing_file(path)?;
     if metadata.nlink() > 0 {
         // If it's hardlinked, copy it and rename it back before changing it.
         let tmpdir = path.parent().expect("file at root");
         let name = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
         let tmpfile = tmpdir.join(name);
         std::fs::create_dir_all(tmpfile.parent().expect("file at root"))
             .with_context(|| IoErrorContext::CopyingFile {
                 from: path.to_owned(),
                 to: tmpfile.to_owned(),
             })?;
         std::fs::copy(path, &tmpfile).with_context(|| {
             IoErrorContext::CopyingFile {
                 from: path.to_owned(),
                 to: tmpfile.to_owned(),
             }
         })?;
         std::fs::rename(&tmpfile, path).with_context(|| {
             IoErrorContext::RenamingFile {
                 from: tmpfile,
                 to: path.to_owned(),
             }
         })?;
     }
     Ok(())
 }
 
 pub fn is_revlog_file(path: impl AsRef<Path>) -> bool {
     path.as_ref()
         .extension()
         .map(|ext| {
             ["i", "idx", "d", "dat", "n", "nd", "sda"]
                 .contains(&ext.to_string_lossy().as_ref())
         })
         .unwrap_or(false)
 }
 
 pub(crate) fn is_dir(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_dir()))
 }
 
 pub(crate) fn is_file(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_file()))
 }
 
 /// Returns whether the given `path` is on a network file system.
 /// Taken from `cargo`'s codebase.
 #[cfg(target_os = "linux")]
 pub(crate) fn is_on_nfs_mount(path: impl AsRef<Path>) -> bool {
     use std::ffi::CString;
     use std::mem;
     use std::os::unix::prelude::*;
 
     let path = match CString::new(path.as_ref().as_os_str().as_bytes()) {
         Ok(path) => path,
         Err(_) => return false,
     };
 
     unsafe {
         let mut buf: libc::statfs = mem::zeroed();
         let r = libc::statfs(path.as_ptr(), &mut buf);
 
         r == 0 && buf.f_type as u32 == libc::NFS_SUPER_MAGIC as u32
     }
 }
 
 /// Similar to what Cargo does; although detecting NFS (or non-local
 /// file systems) _should_ be possible on other operating systems,
 /// we'll just assume that mmap() works there, for now; after all,
 /// _some_ functionality is better than a compile error, i.e. none at
 /// all
 #[cfg(not(target_os = "linux"))]
 pub(crate) fn is_on_nfs_mount(_path: impl AsRef<Path>) -> bool {
     false
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_atomic_file() {
         let dir = tempfile::tempdir().unwrap().into_path();
         let target_path = dir.join("sometargetname");
 
         for empty in [true, false] {
             let file = AtomicFile::new(&target_path, empty, false).unwrap();
             assert!(file.is_open);
             let filename =
                 file.temp_path.file_name().unwrap().to_str().unwrap();
             // Make sure we have a coherent temp name
             assert_eq!(filename.len(), 29, "{}", filename);
             assert!(filename.contains("sometargetname"));
 
             // Make sure the temp file is created in the same folder
             assert_eq!(target_path.parent(), file.temp_path.parent());
         }
 
         assert!(!target_path.exists());
         std::fs::write(&target_path, "version 1").unwrap();
         let mut file = AtomicFile::new(&target_path, false, false).unwrap();
         file.write_all(b"version 2!").unwrap();
         assert_eq!(
             std::fs::read(&target_path).unwrap(),
             b"version 1".to_vec()
         );
         let temp_path = file.temp_path.to_owned();
         // test that dropping the file should discard the temp file and not
         // affect the target path.
         drop(file);
         assert_eq!(
             std::fs::read(&target_path).unwrap(),
             b"version 1".to_vec()
         );
         assert!(!temp_path.exists());
 
         let mut file = AtomicFile::new(&target_path, false, false).unwrap();
         file.write_all(b"version 2!").unwrap();
         assert_eq!(
             std::fs::read(&target_path).unwrap(),
             b"version 1".to_vec()
         );
         file.close().unwrap();
         assert_eq!(
             std::fs::read(&target_path).unwrap(),
             b"version 2!".to_vec(),
             "{}",
             std::fs::read_to_string(&target_path).unwrap()
         );
         assert!(target_path.exists());
         assert!(!temp_path.exists());
     }
 
     #[test]
     fn test_vfs_file_check_ambig() {
         let dir = tempfile::tempdir().unwrap().into_path();
         let file_path = dir.join("file");
 
         fn vfs_file_write(file_path: &Path, check_ambig: bool) {
             let file = std::fs::OpenOptions::new()
                 .write(true)
                 .open(file_path)
                 .unwrap();
             let old_stat = if check_ambig {
                 Some(file.metadata().unwrap())
             } else {
                 None
             };
 
             let mut vfs_file = VfsFile::Normal {
                 file,
                 path: file_path.to_owned(),
                 check_ambig: old_stat,
             };
             vfs_file.write_all(b"contents").unwrap();
         }
 
         std::fs::OpenOptions::new()
             .write(true)
             .create(true)
             .truncate(false)
             .open(&file_path)
             .unwrap();
 
         let number_of_writes = 3;
 
         // Try multiple times, because reproduction of an ambiguity depends
         // on "filesystem time"
         for _ in 0..5 {
             TIMESTAMP_FIXES_CALLS.store(0, Ordering::Relaxed);
             vfs_file_write(&file_path, false);
             let old_stat = file_path.metadata().unwrap();
             if old_stat.ctime() != old_stat.mtime() {
                 // subsequent changing never causes ambiguity
                 continue;
             }
 
             // Repeat atomic write with `check_ambig == true`, to examine
             // whether the mtime is advanced multiple times as expected
             for _ in 0..number_of_writes {
                 vfs_file_write(&file_path, true);
             }
             let new_stat = file_path.metadata().unwrap();
             if !is_filetime_ambiguous(&new_stat, &old_stat) {
                 // timestamp ambiguity was naturally avoided while repetition
                 continue;
             }
 
             assert_eq!(
                 TIMESTAMP_FIXES_CALLS.load(Ordering::Relaxed),
                 number_of_writes
             );
             assert_eq!(
                 old_stat.mtime() + number_of_writes as i64,
                 file_path.metadata().unwrap().mtime()
             );
             break;
         }
         // If we've arrived here without breaking, we might not have
         // tested anything because the platform is too slow. This test will
         // still work on fast platforms.
     }
 }