( )⚙ D11939 dirstate-v2: Apply SECOND_AMBIGUOUS to directory mtimes too

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11939

dirstate-v2: Apply SECOND_AMBIGUOUS to directory mtimes too
ClosedPublic

Authored by SimonSapin on Dec 17 2021, 8:18 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG4afb9627dc77: dirstate-v2: Apply SECOND_AMBIGUOUS to directory mtimes too
Summary

This would only be relevant in contrived scenarios such as a dirstate file
being written with a libc that supports sub-second precision in mtimes,
then transfered (at the filesystem level, not hg clone) to another
system where libc *doesn’t* have sub-second precision and truncates the stored
mtime of a directory to integer seconds.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Dec 17 2021, 8:18 AM
Alphare accepted this revision.Dec 17 2021, 8:58 AM
This revision is now accepted and ready to land.Dec 17 2021, 8:58 AM

Revision Contents
Changeset List

Diff 31529

rust/hg-core/src/dirstate/status.rs

// status.rs // status.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Rust implementation of dirstate.status (dirstate.py). //! Rust implementation of dirstate.status (dirstate.py).
//! It is currently missing a lot of functionality compared to the Python one //! It is currently missing a lot of functionality compared to the Python one
//! and will only be triggered in narrow cases. //! and will only be triggered in narrow cases.
use crate::dirstate::entry::TruncatedTimestamp;
use crate::dirstate_tree::on_disk::DirstateV2ParseError; use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::{ use crate::{
utils::hg_path::{HgPath, HgPathError}, utils::hg_path::{HgPath, HgPathError},
PatternError, PatternError,
}; };
use std::{borrow::Cow, fmt}; use std::{borrow::Cow, fmt};
/// Wrong type of file from a `BadMatch` /// Wrong type of file from a `BadMatch`
/// Used by `hg purge` for example. /// Used by `hg purge` for example.
pub collect_traversed_dirs: bool, pub collect_traversed_dirs: bool,
} }
#[derive(Default)] #[derive(Default)]
pub struct DirstateStatus<'a> { pub struct DirstateStatus<'a> {
/// The current time at the start of the `status()` algorithm, as measured /// The current time at the start of the `status()` algorithm, as measured
/// and possibly truncated by the filesystem. /// and possibly truncated by the filesystem.
pub filesystem_time_at_status_start: Option<std::time::SystemTime>, pub filesystem_time_at_status_start: Option<TruncatedTimestamp>,
/// Tracked files whose contents have changed since the parent revision /// Tracked files whose contents have changed since the parent revision
pub modified: Vec<StatusPath<'a>>, pub modified: Vec<StatusPath<'a>>,
/// Newly-tracked files that were not present in the parent /// Newly-tracked files that were not present in the parent
pub added: Vec<StatusPath<'a>>, pub added: Vec<StatusPath<'a>>,
/// Previously-tracked files that have been (re)moved with an hg command /// Previously-tracked files that have been (re)moved with an hg command

rust/hg-core/src/dirstate_tree/on_disk.rs

) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> { ) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> {
// For now we do not have code to handle the absence of // For now we do not have code to handle the absence of
// ALL_UNKNOWN_RECORDED, so we ignore the mtime if the flag is // ALL_UNKNOWN_RECORDED, so we ignore the mtime if the flag is
// unset. // unset.
if self.flags().contains(Flags::DIRECTORY) if self.flags().contains(Flags::DIRECTORY)
&& self.flags().contains(Flags::HAS_MTIME) && self.flags().contains(Flags::HAS_MTIME)
&& self.flags().contains(Flags::ALL_UNKNOWN_RECORDED) && self.flags().contains(Flags::ALL_UNKNOWN_RECORDED)
{ {
Ok(Some(self.mtime.try_into()?)) Ok(Some(self.mtime()?))
} else { } else {
Ok(None) Ok(None)
} }
} }
fn synthesize_unix_mode(&self) -> u32 { fn synthesize_unix_mode(&self) -> u32 {
let file_type = if self.flags().contains(Flags::MODE_IS_SYMLINK) { let file_type = if self.flags().contains(Flags::MODE_IS_SYMLINK) {
libc::S_IFLNK libc::S_IFLNK
} else { } else {
libc::S_IFREG libc::S_IFREG
}; };
let permisions = if self.flags().contains(Flags::MODE_EXEC_PERM) { let permisions = if self.flags().contains(Flags::MODE_EXEC_PERM) {
0o755 0o755
} else { } else {
0o644 0o644
}; };
file_type | permisions file_type | permisions
} }
fn mtime(&self) -> Result<TruncatedTimestamp, DirstateV2ParseError> {
let mut m: TruncatedTimestamp = self.mtime.try_into()?;
if self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS) {
m.second_ambiguous = true;
}
Ok(m)
}
fn assume_entry(&self) -> Result<DirstateEntry, DirstateV2ParseError> { fn assume_entry(&self) -> Result<DirstateEntry, DirstateV2ParseError> {
// TODO: convert through raw bits instead? // TODO: convert through raw bits instead?
let wdir_tracked = self.flags().contains(Flags::WDIR_TRACKED); let wdir_tracked = self.flags().contains(Flags::WDIR_TRACKED);
let p1_tracked = self.flags().contains(Flags::P1_TRACKED); let p1_tracked = self.flags().contains(Flags::P1_TRACKED);
let p2_info = self.flags().contains(Flags::P2_INFO); let p2_info = self.flags().contains(Flags::P2_INFO);
let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE) let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE)
&& !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED) && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
{ {
Some((self.synthesize_unix_mode(), self.size.into())) Some((self.synthesize_unix_mode(), self.size.into()))
} else { } else {
None None
}; };
let mtime = if self.flags().contains(Flags::HAS_MTIME) let mtime = if self.flags().contains(Flags::HAS_MTIME)
&& !self.flags().contains(Flags::DIRECTORY) && !self.flags().contains(Flags::DIRECTORY)
&& !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED) && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
{ {
let mut m: TruncatedTimestamp = self.mtime.try_into()?; Some(self.mtime()?)
if self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS) {
m.second_ambiguous = true;
}
Some(m)
} else { } else {
None None
}; };
let fallback_exec = if self.flags().contains(Flags::HAS_FALLBACK_EXEC) let fallback_exec = if self.flags().contains(Flags::HAS_FALLBACK_EXEC)
{ {
Some(self.flags().contains(Flags::FALLBACK_EXEC)) Some(self.flags().contains(Flags::FALLBACK_EXEC))
} else { } else {
None None
} }
}; };
on_disk_nodes.push(match node { on_disk_nodes.push(match node {
NodeRef::InMemory(path, node) => { NodeRef::InMemory(path, node) => {
let (flags, size, mtime) = match &node.data { let (flags, size, mtime) = match &node.data {
dirstate_map::NodeData::Entry(entry) => { dirstate_map::NodeData::Entry(entry) => {
Node::from_dirstate_entry(entry) Node::from_dirstate_entry(entry)
} }
dirstate_map::NodeData::CachedDirectory { mtime } => ( dirstate_map::NodeData::CachedDirectory { mtime } => {
// we currently never set a mtime if unknown file // we currently never set a mtime if unknown file
// are present. // are present.
// So if we have a mtime for a directory, we know // So if we have a mtime for a directory, we know
// they are no unknown // they are no unknown
// files and we // files and we
// blindly set ALL_UNKNOWN_RECORDED. // blindly set ALL_UNKNOWN_RECORDED.
// //
// We never set ALL_IGNORED_RECORDED since we // We never set ALL_IGNORED_RECORDED since we
// don't track that case // don't track that case
// currently. // currently.
Flags::DIRECTORY let mut flags = Flags::DIRECTORY
| Flags::HAS_MTIME | Flags::HAS_MTIME
| Flags::ALL_UNKNOWN_RECORDED, | Flags::ALL_UNKNOWN_RECORDED;
0.into(), if mtime.second_ambiguous {
(*mtime).into(), flags.insert(Flags::MTIME_SECOND_AMBIGUOUS)
), }
(flags, 0.into(), (*mtime).into())
}
dirstate_map::NodeData::None => ( dirstate_map::NodeData::None => (
Flags::DIRECTORY, Flags::DIRECTORY,
0.into(), 0.into(),
PackedTruncatedTimestamp::null(), PackedTruncatedTimestamp::null(),
), ),
}; };
Node { Node {
children, children,

rust/hg-core/src/dirstate_tree/status.rs

let new_hash = *hasher.finalize().as_ref(); let new_hash = *hasher.finalize().as_ref();
let changed = new_hash != dmap.ignore_patterns_hash; let changed = new_hash != dmap.ignore_patterns_hash;
dmap.ignore_patterns_hash = new_hash; dmap.ignore_patterns_hash = new_hash;
(ignore_fn, warnings, Some(changed)) (ignore_fn, warnings, Some(changed))
} else { } else {
(Box::new(|&_| true), vec![], None) (Box::new(|&_| true), vec![], None)
}; };
let filesystem_time_at_status_start = filesystem_now(&root_dir).ok(); let filesystem_time_at_status_start =
filesystem_now(&root_dir).ok().map(TruncatedTimestamp::from);
let outcome = DirstateStatus { let outcome = DirstateStatus {
filesystem_time_at_status_start, filesystem_time_at_status_start,
..Default::default() ..Default::default()
}; };
let common = StatusCommon { let common = StatusCommon {
dmap, dmap,
options, options,
matcher, matcher,
/// Whether ignore files like `.hgignore` have changed since the previous /// Whether ignore files like `.hgignore` have changed since the previous
/// time a `status()` call wrote their hash to the dirstate. `None` means /// time a `status()` call wrote their hash to the dirstate. `None` means
/// we don’t know as this run doesn’t list either ignored or uknown files /// we don’t know as this run doesn’t list either ignored or uknown files
/// and therefore isn’t reading `.hgignore`. /// and therefore isn’t reading `.hgignore`.
ignore_patterns_have_changed: Option<bool>, ignore_patterns_have_changed: Option<bool>,
/// The current time at the start of the `status()` algorithm, as measured /// The current time at the start of the `status()` algorithm, as measured
/// and possibly truncated by the filesystem. /// and possibly truncated by the filesystem.
filesystem_time_at_status_start: Option<SystemTime>, filesystem_time_at_status_start: Option<TruncatedTimestamp>,
} }
enum Outcome { enum Outcome {
Modified, Modified,
Added, Added,
Removed, Removed,
Deleted, Deleted,
Clean, Clean,
} }
fn maybe_save_directory_mtime( fn maybe_save_directory_mtime(
&self, &self,
children_all_have_dirstate_node_or_are_ignored: bool, children_all_have_dirstate_node_or_are_ignored: bool,
directory_metadata: &std::fs::Metadata, directory_metadata: &std::fs::Metadata,
dirstate_node: NodeRef<'tree, 'on_disk>, dirstate_node: NodeRef<'tree, 'on_disk>,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
if children_all_have_dirstate_node_or_are_ignored { if !children_all_have_dirstate_node_or_are_ignored {
return Ok(());
}
// All filesystem directory entries from `read_dir` have a // All filesystem directory entries from `read_dir` have a
// corresponding node in the dirstate, so we can reconstitute the // corresponding node in the dirstate, so we can reconstitute the
// names of those entries without calling `read_dir` again. // names of those entries without calling `read_dir` again.
if let (Some(status_start), Ok(directory_mtime)) = (
&self.filesystem_time_at_status_start, // TODO: use let-else here and below when available:
directory_metadata.modified(), // https://github.com/rust-lang/rust/issues/87335
) { let status_start = if let Some(status_start) =
&self.filesystem_time_at_status_start
{
status_start
} else {
return Ok(());
};
// Although the Rust standard library’s `SystemTime` type // Although the Rust standard library’s `SystemTime` type
// has nanosecond precision, the times reported for a // has nanosecond precision, the times reported for a
// directory’s (or file’s) modified time may have lower // directory’s (or file’s) modified time may have lower
// resolution based on the filesystem (for example ext3 // resolution based on the filesystem (for example ext3
// only stores integer seconds), kernel (see // only stores integer seconds), kernel (see
// https://stackoverflow.com/a/14393315/1162888), etc. // https://stackoverflow.com/a/14393315/1162888), etc.
if &directory_mtime >= status_start { let directory_mtime = if let Ok(option) =
// The directory was modified too recently, don’t cache its TruncatedTimestamp::for_reliable_mtime_of(
// `read_dir` results. directory_metadata,
// status_start,
// A timeline like this is possible: ) {
if let Some(directory_mtime) = option {
directory_mtime
} else {
// The directory was modified too recently,
// don’t cache its `read_dir` results.
// //
// 1. A change to this directory (direct child was // 1. A change to this directory (direct child was
// added or removed) cause its mtime to be set // added or removed) cause its mtime to be set
// (possibly truncated) to `directory_mtime` // (possibly truncated) to `directory_mtime`
// 2. This `status` algorithm calls `read_dir` // 2. This `status` algorithm calls `read_dir`
// 3. An other change is made to the same directory is // 3. An other change is made to the same directory is
// made so that calling `read_dir` agin would give // made so that calling `read_dir` agin would give
// different results, but soon enough after 1. that // different results, but soon enough after 1. that
// the mtime stays the same // the mtime stays the same
// //
// On a system where the time resolution poor, this // On a system where the time resolution poor, this
// scenario is not unlikely if all three steps are caused // scenario is not unlikely if all three steps are caused
// by the same script. // by the same script.
return Ok(());
}
} else { } else {
// OS/libc does not support mtime?
return Ok(());
};
// We’ve observed (through `status_start`) that time has // We’ve observed (through `status_start`) that time has
// “progressed” since `directory_mtime`, so any further // “progressed” since `directory_mtime`, so any further
// change to this directory is extremely likely to cause a // change to this directory is extremely likely to cause a
// different mtime. // different mtime.
// //
// Having the same mtime again is not entirely impossible // Having the same mtime again is not entirely impossible
// since the system clock is not monotonous. It could jump // since the system clock is not monotonous. It could jump
// backward to some point before `directory_mtime`, then a // backward to some point before `directory_mtime`, then a
// directory change could potentially happen during exactly // directory change could potentially happen during exactly
// the wrong tick. // the wrong tick.
// //
// We deem this scenario (unlike the previous one) to be // We deem this scenario (unlike the previous one) to be
// unlikely enough in practice. // unlikely enough in practice.
let truncated = TruncatedTimestamp::from(directory_mtime);
let is_up_to_date = if let Some(cached) = let is_up_to_date =
dirstate_node.cached_directory_mtime()? if let Some(cached) = dirstate_node.cached_directory_mtime()? {
{ cached.likely_equal(directory_mtime)
cached.likely_equal(truncated)
} else { } else {
false false
}; };
if !is_up_to_date { if !is_up_to_date {
let hg_path = dirstate_node let hg_path = dirstate_node
.full_path_borrowed(self.dmap.on_disk)? .full_path_borrowed(self.dmap.on_disk)?
.detach_from_tree(); .detach_from_tree();
self.new_cachable_directories self.new_cachable_directories
.lock() .lock()
.unwrap() .unwrap()
.push((hg_path, truncated)) .push((hg_path, directory_mtime))
}
}
}
} }
Ok(()) Ok(())
} }
/// A file with `EntryState::Normal` in the dirstate was found in the /// A file with `EntryState::Normal` in the dirstate was found in the
/// filesystem /// filesystem
fn handle_normal_file( fn handle_normal_file(
&self, &self,

rust/rhg/src/commands/status.rs

if display_states.ignored { if display_states.ignored {
output.display(b"I", ds_status.ignored)?; output.display(b"I", ds_status.ignored)?;
} }
if display_states.clean { if display_states.clean {
output.display(b"C", ds_status.clean)?; output.display(b"C", ds_status.clean)?;
} }
let mut dirstate_write_needed = ds_status.dirty; let mut dirstate_write_needed = ds_status.dirty;
let filesystem_time_at_status_start = ds_status let filesystem_time_at_status_start =
.filesystem_time_at_status_start ds_status.filesystem_time_at_status_start;
.map(TruncatedTimestamp::from);
if (fixup.is_empty() || filesystem_time_at_status_start.is_none()) if (fixup.is_empty() || filesystem_time_at_status_start.is_none())
&& !dirstate_write_needed && !dirstate_write_needed
{ {
// Nothing to update // Nothing to update
return Ok(()); return Ok(());
} }