This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11654

status: Extract TruncatedTimestamp from fs::Metadata without SystemTime
ClosedPublic

Authored by SimonSapin on Oct 13 2021, 11:39 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG15dedc0c5c35: status: Extract TruncatedTimestamp from fs::Metadata without SystemTime
Summary

On Unix, the Rust standard library exposes mtime and mtime_nsec methods
for std::fs::Metada whih is exactly what we need to construct a
TruncatedTimestamp. This skips the computation in the conversion through
SystemTime and Result<Duration, Duration>.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

Diff 30794

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

use crate::dirstate_tree::on_disk::DirstateV2ParseError; use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::errors::HgError; use crate::errors::HgError;
use bitflags::bitflags; use bitflags::bitflags;
use std::convert::TryFrom; use std::convert::{TryFrom, TryInto};
use std::fs;
use std::io;
use std::time::{SystemTime, UNIX_EPOCH}; use std::time::{SystemTime, UNIX_EPOCH};
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum EntryState { pub enum EntryState {
Normal, Normal,
Added, Added,
Removed, Removed,
Merged, Merged,
truncated_seconds, truncated_seconds,
nanoseconds, nanoseconds,
}) })
} else { } else {
Err(DirstateV2ParseError) Err(DirstateV2ParseError)
} }
} }
pub fn for_mtime_of(metadata: &fs::Metadata) -> io::Result<Self> {
#[cfg(unix)]
{
use std::os::unix::fs::MetadataExt;
let seconds = metadata.mtime();
// i64!-> u32 with value always in the `0 .. NSEC_PER_SEC` range
let nanoseconds = metadata.mtime_nsec().try_into().unwrap();
Ok(Self::new_truncate(seconds, nanoseconds))
}
#[cfg(not(unix))]
{
metadata.modified().map(Self::from)
}
}
/// The lower 31 bits of the number of seconds since the epoch. /// The lower 31 bits of the number of seconds since the epoch.
pub fn truncated_seconds(&self) -> u32 { pub fn truncated_seconds(&self) -> u32 {
self.truncated_seconds self.truncated_seconds
} }
/// The sub-second component of this timestamp, in nanoseconds. /// The sub-second component of this timestamp, in nanoseconds.
/// Always in the `0 .. 1_000_000_000` range. /// Always in the `0 .. 1_000_000_000` range.
/// ///
/// This timestamp is after `(seconds, 0)` by this many nanoseconds. /// This timestamp is after `(seconds, 0)` by this many nanoseconds.
pub fn nanoseconds(&self) -> u32 { pub fn nanoseconds(&self) -> u32 {
self.nanoseconds self.nanoseconds
} }
/// Returns whether two timestamps are equal modulo 2**31 seconds. /// Returns whether two timestamps are equal modulo 2**31 seconds.
/// ///
/// If this returns `true`, the original values converted from `SystemTime` /// If this returns `true`, the original values converted from `SystemTime`
/// or given to `new_truncate` were very likely equal. A false positive is /// or given to `new_truncate` were very likely equal. A false positive is
/// possible if they were exactly a multiple of 2**31 seconds apart (around /// possible if they were exactly a multiple of 2**31 seconds apart (around
/// 68 years). This is deemed very unlikely to happen by chance, especially /// 68 years). This is deemed very unlikely to happen by chance, especially
/// on filesystems that support sub-second precision. /// on filesystems that support sub-second precision.
/// ///
/// If someone is manipulating the modification times of some files to /// If someone is manipulating the modification times of some files to
/// intentionally make `hg status` return incorrect results, not truncating /// intentionally make `hg status` return incorrect results, not truncating
/// wouldn’t help much since they can set exactly the expected timestamp. /// wouldn’t help much since they can set exactly the expected timestamp.
pub fn very_likely_equal(&self, other: &Self) -> bool { pub fn very_likely_equal(self, other: Self) -> bool {
self.truncated_seconds == other.truncated_seconds self.truncated_seconds == other.truncated_seconds
&& self.nanoseconds == other.nanoseconds && self.nanoseconds == other.nanoseconds
} }
pub fn very_likely_equal_to_mtime_of(
self,
metadata: &fs::Metadata,
) -> io::Result<bool> {
Ok(self.very_likely_equal(Self::for_mtime_of(metadata)?))
}
} }
impl From<SystemTime> for TruncatedTimestamp { impl From<SystemTime> for TruncatedTimestamp {
fn from(system_time: SystemTime) -> Self { fn from(system_time: SystemTime) -> Self {
// On Unix, `SystemTime` is a wrapper for the `timespec` C struct: // On Unix, `SystemTime` is a wrapper for the `timespec` C struct:
// https://www.gnu.org/software/libc/manual/html_node/Time-Types.html#index-struct-timespec // https://www.gnu.org/software/libc/manual/html_node/Time-Types.html#index-struct-timespec
// We want to effectively access its fields, but the Rust standard // We want to effectively access its fields, but the Rust standard
// library does not expose them. The best we can do is: // library does not expose them. The best we can do is:

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

if !self.options.list_ignored if !self.options.list_ignored
&& self.ignore_patterns_have_changed == Some(false) && self.ignore_patterns_have_changed == Some(false)
{ {
if let Some(cached_mtime) = cached_directory_mtime { if let Some(cached_mtime) = cached_directory_mtime {
// The dirstate contains a cached mtime for this directory, set // The dirstate contains a cached mtime for this directory, set
// by a previous run of the `status` algorithm which found this // by a previous run of the `status` algorithm which found this
// directory eligible for `read_dir` caching. // directory eligible for `read_dir` caching.
if let Some(meta) = directory_metadata { if let Some(meta) = directory_metadata {
if let Ok(current_mtime) = meta.modified() { if cached_mtime
let truncated = .very_likely_equal_to_mtime_of(meta)
TruncatedTimestamp::from(current_mtime); .unwrap_or(false)
if truncated.very_likely_equal(&cached_mtime) { {
// The mtime of that directory has not changed // The mtime of that directory has not changed
// since then, which means that the results of // since then, which means that the results of
// `read_dir` should also be unchanged. // `read_dir` should also be unchanged.
return true; return true;
} }
} }
} }
} }
}
false false
} }
/// Returns whether all child entries of the filesystem directory have a /// Returns whether all child entries of the filesystem directory have a
/// corresponding dirstate node or are ignored. /// corresponding dirstate node or are ignored.
fn traverse_fs_directory_and_dirstate( fn traverse_fs_directory_and_dirstate(
&self, &self,
has_ignored_ancestor: bool, has_ignored_ancestor: bool,
// 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 truncated = TruncatedTimestamp::from(directory_mtime);
let is_up_to_date = if let Some(cached) = let is_up_to_date = if let Some(cached) =
dirstate_node.cached_directory_mtime()? dirstate_node.cached_directory_mtime()?
{ {
cached.very_likely_equal(&truncated) cached.very_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