( )⚙ D11629 dirstate-v2: Change the representation of negative directory mtime

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11629

dirstate-v2: Change the representation of negative directory mtime
ClosedPublic

Authored by SimonSapin on Oct 12 2021, 7:55 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGa5a673ec8f6f: dirstate-v2: Change the representation of negative directory mtime
Summary

Change it from how I previously thought C’s timespec works
to how it actually works.

The previous behavior was also buggy for timestamps strictly before the
epoch but less than one second away from it, because two’s complement
does not distinguish negative zero from positive zero.

Diff Detail

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

Revision Contents
Changeset List

Diff 30719

mercurial/helptext/internals/dirstate-v2.txt

If an untracked node `HAS_MTIME` *unset*, this space is unused: If an untracked node `HAS_MTIME` *unset*, this space is unused:
* Offset 31: * Offset 31:
12 bytes set to zero 12 bytes set to zero
If an untracked node `HAS_MTIME` *set*, If an untracked node `HAS_MTIME` *set*,
what follows is the modification time of a directory what follows is the modification time of a directory
represented with separated second and sub-second components represented similarly to the C `timespec` struct:
since the Unix epoch:
* Offset 31: * Offset 31:
The number of seconds as a signed (two’s complement) 64-bit integer. The number of seconds elapsed since the Unix epoch,
as a signed (two’s complement) 64-bit integer.
* Offset 39: * Offset 39:
The number of nanoseconds as 32-bit integer. The number of nanoseconds elapsed since
the instant specified by the previous field alone,
as 32-bit integer.
Always greater than or equal to zero, and strictly less than a billion. Always greater than or equal to zero, and strictly less than a billion.
Increasing this component makes the modification time Increasing this component makes the modification time
go forward or backward in time dependening go forward in time regardless of the sign of the seconds component.
on the sign of the integral seconds components.
(Note: this is buggy because there is no negative zero integer,
but will be changed soon.)
The presence of a directory modification time means that at some point, The presence of a directory modification time means that at some point,
this path in the working directory was observed: this path in the working directory was observed:
- To be a directory - To be a directory
- With the given modification time - With the given modification time
- That time was already strictly in the past when observed, - That time was already strictly in the past when observed,
meaning that later changes cannot happen in the same clock tick meaning that later changes cannot happen in the same clock tick

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

/// Duration since the Unix epoch /// Duration since the Unix epoch
#[derive(BytesCast, Copy, Clone, PartialEq)] #[derive(BytesCast, Copy, Clone, PartialEq)]
#[repr(C)] #[repr(C)]
pub(super) struct Timestamp { pub(super) struct Timestamp {
seconds: I64Be, seconds: I64Be,
/// In `0 .. 1_000_000_000`. /// In `0 .. 1_000_000_000`.
/// ///
/// This timestamp is later or earlier than `(seconds, 0)` by this many /// This timestamp is after `(seconds, 0)` by this many nanoseconds.
/// nanoseconds, if `seconds` is non-negative or negative, respectively.
nanoseconds: U32Be, nanoseconds: U32Be,
} }
/// Counted in bytes from the start of the file /// Counted in bytes from the start of the file
/// ///
/// NOTE: not supporting `.hg/dirstate` files larger than 4 GiB. /// NOTE: not supporting `.hg/dirstate` files larger than 4 GiB.
type Offset = U32Be; type Offset = U32Be;
impl Timestamp { impl Timestamp {
pub fn seconds(&self) -> i64 { pub fn seconds(&self) -> i64 {
self.seconds.get() self.seconds.get()
} }
} }
impl From<SystemTime> for Timestamp { impl From<SystemTime> for Timestamp {
fn from(system_time: SystemTime) -> Self { fn from(system_time: SystemTime) -> Self {
// 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
// We want to effectively access its fields, but the Rust standard
// library does not expose them. The best we can do is:
let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) { let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) {
Ok(duration) => { Ok(duration) => {
(duration.as_secs() as i64, duration.subsec_nanos()) (duration.as_secs() as i64, duration.subsec_nanos())
} }
Err(error) => { Err(error) => {
// `system_time` is before `UNIX_EPOCH`.
// We need to undo this algorithm:
// https://github.com/rust-lang/rust/blob/6bed1f0bc3cc50c10aab26d5f94b16a00776b8a5/library/std/src/sys/unix/time.rs#L40-L41
let negative = error.duration(); let negative = error.duration();
(-(negative.as_secs() as i64), negative.subsec_nanos()) let negative_secs = negative.as_secs() as i64;
let negative_nanos = negative.subsec_nanos();
if negative_nanos == 0 {
(-negative_secs, 0)
} else {
// For example if `system_time` was 4.3!seconds before
// the Unix epoch we get a Duration that represents
// `(-4, -0.3)` but we want `(-5, +0.7)`:
const NSEC_PER_SEC: u32 = 1_000_000_000;
(-1 - negative_secs, NSEC_PER_SEC - negative_nanos)
}
} }
}; };
Timestamp { Timestamp {
seconds: secs.into(), seconds: secs.into(),
nanoseconds: nanos.into(), nanoseconds: nanos.into(),
} }
} }
} }