This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11694

dirstate-v2: adjust the meaning of directory flags
ClosedPublic

Authored by marmoute on Oct 19 2021, 2:18 PM.

Details

Reviewers
spectral
Alphare
Group Reviewers
hg-reviewers
Commits
rHGbb240915f69f: dirstate-v2: adjust the meaning of directory flags
Summary

Tracking directory "explicitly" give use the opportunity to distinct between
entry that are untracked because they are part of the directory structure and
entry that are ignored/unknown files on the files system.

The help is adjusted to the new semantic and the code now comply to it for both
read and write.

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.

Event Timeline

marmoute created this revision.Oct 19 2021, 2:18 PM
spectral accepted this revision.Oct 19 2021, 5:08 PM
Alphare requested changes to this revision.Oct 20 2021, 4:52 AM
Alphare added a subscriber: Alphare.

Since this needs a bit of work, you can also go back to add the docstring I asked in the earlier patch in the same update.

mercurial/dirstateutils/v2.py
59

mercurial*

mercurial/helptext/internals/dirstate-v2.txt
493–515

Unchanged*

502

that exists*

509

unknown file*

513

mtime matches*

517

taken into account*

rust/hg-core/src/dirstate_tree/on_disk.rs
332–336

to handle the absence of ALL_UNKNOWN_RECORDED

This revision now requires changes to proceed.Oct 20 2021, 4:52 AM
marmoute updated this revision to Diff 30934.Oct 20 2021, 5:12 AM
Alphare accepted this revision.Oct 20 2021, 5:26 AM
Alphare added inline comments.
mercurial/helptext/internals/dirstate-v2.txt
513

This is not done, commenting to remember to amend

This revision is now accepted and ready to land.Oct 20 2021, 5:26 AM
marmoute added a commit: rHGbb240915f69f: dirstate-v2: adjust the meaning of directory flags.Oct 20 2021, 5:31 AM
Closed by commit rHGbb240915f69f: dirstate-v2: adjust the meaning of directory flags (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30946

mercurial/cext/parsers.c

t->flags |= dirstate_flag_has_meaningful_data; t->flags |= dirstate_flag_has_meaningful_data;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
} else { } else {
t->mode = 0; t->mode = 0;
t->size = 0; t->size = 0;
} }
if (has_meaningful_mtime) { if (has_meaningful_mtime) {
t->flags |= dirstate_flag_has_file_mtime; t->flags |= dirstate_flag_has_mtime;
t->mtime_s = mtime_s; t->mtime_s = mtime_s;
t->mtime_ns = mtime_ns; t->mtime_ns = mtime_ns;
} else { } else {
t->mtime_s = 0; t->mtime_s = 0;
t->mtime_ns = 0; t->mtime_ns = 0;
} }
return (PyObject *)t; return (PyObject *)t;
} }
return dirstate_v1_nonnormal; return dirstate_v1_nonnormal;
} }
} }
static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self) static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)
{ {
if (dirstate_item_c_removed(self)) { if (dirstate_item_c_removed(self)) {
return 0; return 0;
} else if (!(self->flags & dirstate_flag_has_file_mtime) || } else if (!(self->flags & dirstate_flag_has_mtime) ||
!(self->flags & dirstate_flag_p1_tracked) || !(self->flags & dirstate_flag_p1_tracked) ||
!(self->flags & dirstate_flag_wc_tracked) || !(self->flags & dirstate_flag_wc_tracked) ||
(self->flags & dirstate_flag_p2_info)) { (self->flags & dirstate_flag_p2_info)) {
return ambiguous_time; return ambiguous_time;
} else { } else {
return self->mtime_s; return self->mtime_s;
} }
} }
static PyObject *dirstate_item_mtime_likely_equal_to(dirstateItemObject *self, static PyObject *dirstate_item_mtime_likely_equal_to(dirstateItemObject *self,
PyObject *other) PyObject *other)
{ {
int other_s; int other_s;
int other_ns; int other_ns;
if (!PyArg_ParseTuple(other, "ii", &other_s, &other_ns)) { if (!PyArg_ParseTuple(other, "ii", &other_s, &other_ns)) {
return NULL; return NULL;
} }
if ((self->flags & dirstate_flag_has_file_mtime) && if ((self->flags & dirstate_flag_has_mtime) &&
self->mtime_s == other_s && self->mtime_s == other_s &&
(self->mtime_ns == other_ns || self->mtime_ns == 0 || (self->mtime_ns == other_ns || self->mtime_ns == 0 ||
other_ns == 0)) { other_ns == 0)) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
dirstate_flag_p1_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data); dirstate_flag_has_meaningful_data);
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
} else { } else {
t->flags = (dirstate_flag_wc_tracked | t->flags = (dirstate_flag_wc_tracked |
dirstate_flag_p1_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_file_mtime); dirstate_flag_has_mtime);
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime_s = mtime; t->mtime_s = mtime;
} }
} else { } else {
PyErr_Format(PyExc_RuntimeError, PyErr_Format(PyExc_RuntimeError,
"unknown state: `%c` (%d, %d, %d)", state, mode, "unknown state: `%c` (%d, %d, %d)", state, mode,
size, mtime, NULL); size, mtime, NULL);
} }
if (!PyArg_ParseTuple(args, "iiii", &t->flags, &t->size, &t->mtime_s, if (!PyArg_ParseTuple(args, "iiii", &t->flags, &t->size, &t->mtime_s,
&t->mtime_ns)) { &t->mtime_ns)) {
return NULL; return NULL;
} }
if (t->flags & dirstate_flag_expected_state_is_modified) { if (t->flags & dirstate_flag_expected_state_is_modified) {
t->flags &= ~(dirstate_flag_expected_state_is_modified | t->flags &= ~(dirstate_flag_expected_state_is_modified |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_file_mtime); dirstate_flag_has_mtime);
} }
if (t->flags & dirstate_flag_mtime_second_ambiguous) { if (t->flags & dirstate_flag_mtime_second_ambiguous) {
/* The current code is not able to do the more subtle comparison /* The current code is not able to do the more subtle comparison
* that the MTIME_SECOND_AMBIGUOUS requires. So we ignore the * that the MTIME_SECOND_AMBIGUOUS requires. So we ignore the
* mtime */ * mtime */
t->flags &= ~(dirstate_flag_mtime_second_ambiguous | t->flags &= ~(dirstate_flag_mtime_second_ambiguous |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_file_mtime); dirstate_flag_has_mtime);
} }
t->mode = 0; t->mode = 0;
if (t->flags & dirstate_flag_has_meaningful_data) { if (t->flags & dirstate_flag_has_meaningful_data) {
if (t->flags & dirstate_flag_mode_exec_perm) { if (t->flags & dirstate_flag_mode_exec_perm) {
t->mode = 0755; t->mode = 0755;
} else { } else {
t->mode = 0644; t->mode = 0644;
} }
if (t->flags & dirstate_flag_mode_is_symlink) { if (t->flags & dirstate_flag_mode_is_symlink) {
t->mode |= S_IFLNK; t->mode |= S_IFLNK;
} else { } else {
t->mode |= S_IFREG; t->mode |= S_IFREG;
} }
} }
return (PyObject *)t; return (PyObject *)t;
}; };
/* This means the next status call will have to actually check its content /* This means the next status call will have to actually check its content
to make sure it is correct. */ to make sure it is correct. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
self->flags &= ~dirstate_flag_has_file_mtime; self->flags &= ~dirstate_flag_has_mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* See docstring of the python implementation for details */ /* See docstring of the python implementation for details */
static PyObject *dirstate_item_set_clean(dirstateItemObject *self, static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
PyObject *args) PyObject *args)
{ {
int size, mode, mtime_s, mtime_ns; int size, mode, mtime_s, mtime_ns;
if (!PyArg_ParseTuple(args, "ii(ii)", &mode, &size, &mtime_s, if (!PyArg_ParseTuple(args, "ii(ii)", &mode, &size, &mtime_s,
&mtime_ns)) { &mtime_ns)) {
return NULL; return NULL;
} }
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_file_mtime; dirstate_flag_has_mtime;
self->mode = mode; self->mode = mode;
self->size = size; self->size = size;
self->mtime_s = mtime_s; self->mtime_s = mtime_s;
self->mtime_ns = mtime_ns; self->mtime_ns = mtime_ns;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_tracked(dirstateItemObject *self) static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
{ {
self->flags |= dirstate_flag_wc_tracked; self->flags |= dirstate_flag_wc_tracked;
self->flags &= ~dirstate_flag_has_file_mtime; self->flags &= ~dirstate_flag_has_mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_untracked(dirstateItemObject *self) static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
{ {
self->flags &= ~dirstate_flag_wc_tracked; self->flags &= ~dirstate_flag_wc_tracked;
self->mode = 0; self->mode = 0;
self->size = 0; self->size = 0;
self->mtime_s = 0; self->mtime_s = 0;
self->mtime_ns = 0; self->mtime_ns = 0;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self) static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
{ {
if (self->flags & dirstate_flag_p2_info) { if (self->flags & dirstate_flag_p2_info) {
self->flags &= ~(dirstate_flag_p2_info | self->flags &= ~(dirstate_flag_p2_info |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_file_mtime); dirstate_flag_has_mtime);
self->mode = 0; self->mode = 0;
self->size = 0; self->size = 0;
self->mtime_s = 0; self->mtime_s = 0;
self->mtime_ns = 0; self->mtime_ns = 0;
} }
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyMethodDef dirstate_item_methods[] = { static PyMethodDef dirstate_item_methods[] = {

mercurial/cext/util.h

int mtime_ns; int mtime_ns;
} dirstateItemObject; } dirstateItemObject;
/* clang-format on */ /* clang-format on */
static const int dirstate_flag_wc_tracked = 1; static const int dirstate_flag_wc_tracked = 1;
static const int dirstate_flag_p1_tracked = 1 << 1; static const int dirstate_flag_p1_tracked = 1 << 1;
static const int dirstate_flag_p2_info = 1 << 2; static const int dirstate_flag_p2_info = 1 << 2;
static const int dirstate_flag_has_meaningful_data = 1 << 3; static const int dirstate_flag_has_meaningful_data = 1 << 3;
static const int dirstate_flag_has_file_mtime = 1 << 4; static const int dirstate_flag_has_mtime = 1 << 4;
static const int dirstate_flag_has_directory_mtime = 1 << 5; static const int dirstate_flag_directory = 1 << 5;
static const int dirstate_flag_mode_exec_perm = 1 << 6; static const int dirstate_flag_mode_exec_perm = 1 << 6;
static const int dirstate_flag_mode_is_symlink = 1 << 7; static const int dirstate_flag_mode_is_symlink = 1 << 7;
static const int dirstate_flag_expected_state_is_modified = 1 << 8; static const int dirstate_flag_expected_state_is_modified = 1 << 8;
static const int dirstate_flag_all_unknown_recorded = 1 << 9; static const int dirstate_flag_all_unknown_recorded = 1 << 9;
static const int dirstate_flag_all_ignored_recorded = 1 << 10; static const int dirstate_flag_all_ignored_recorded = 1 << 10;
static const int dirstate_flag_fallback_exec = 1 << 11; static const int dirstate_flag_fallback_exec = 1 << 11;
static const int dirstate_flag_has_fallback_exec = 1 << 12; static const int dirstate_flag_has_fallback_exec = 1 << 12;
static const int dirstate_flag_fallback_symlink = 1 << 13; static const int dirstate_flag_fallback_symlink = 1 << 13;

mercurial/dirstateutils/v2.py

# * 4 bytes: mtime seconds # * 4 bytes: mtime seconds
# * 4 bytes: mtime nanoseconds # * 4 bytes: mtime nanoseconds
NODE = struct.Struct('>LHHLHLLLLHlll') NODE = struct.Struct('>LHHLHLLLLHlll')
assert TREE_METADATA_SIZE == TREE_METADATA.size assert TREE_METADATA_SIZE == TREE_METADATA.size
assert NODE_SIZE == NODE.size assert NODE_SIZE == NODE.size
# match constant in mercurial/pure/parsers.py
AlphareUnsubmitted
Not Done

mercurial*

Alphare: mercurial*
DIRSTATE_V2_DIRECTORY = 1 << 5
def parse_dirstate(map, copy_map, data, tree_metadata): def parse_dirstate(map, copy_map, data, tree_metadata):
"""parse a full v2-dirstate from a binary data into dictionnaries: """parse a full v2-dirstate from a binary data into dictionnaries:
- map: a {path: entry} mapping that will be filled - map: a {path: entry} mapping that will be filled
- copy_map: a {path: copy-source} mapping that will be filled - copy_map: a {path: copy-source} mapping that will be filled
- data: a binary blob contains v2 nodes data - data: a binary blob contains v2 nodes data
- tree_metadata:: a binary blob of the top level node (from the docket) - tree_metadata:: a binary blob of the top level node (from the docket)
def parse_nodes(map, copy_map, data, start, len): def parse_nodes(map, copy_map, data, start, len):
"""parse <len> nodes from <data> starting at offset <start> """parse <len> nodes from <data> starting at offset <start>
This is used by parse_dirstate to recursively fill `map` and `copy_map`. This is used by parse_dirstate to recursively fill `map` and `copy_map`.
All directory specific information is ignored and do not need any All directory specific information is ignored and do not need any
processing (HAS_DIRECTORY_MTIME, ALL_UNKNOWN_RECORDED, ALL_IGNORED_RECORDED) processing (DIRECTORY, ALL_UNKNOWN_RECORDED, ALL_IGNORED_RECORDED)
""" """
for i in range(len): for i in range(len):
node_start = start + NODE_SIZE * i node_start = start + NODE_SIZE * i
node_bytes = slice_with_len(data, node_start, NODE_SIZE) node_bytes = slice_with_len(data, node_start, NODE_SIZE)
( (
path_start, path_start,
path_len, path_len,
_basename_start, _basename_start,
copy_source_len = len(copy) copy_source_len = len(copy)
else: else:
copy_source_start = 0 copy_source_start = 0
copy_source_len = 0 copy_source_len = 0
if entry is not None: if entry is not None:
flags, size, mtime_s, mtime_ns = entry.v2_data() flags, size, mtime_s, mtime_ns = entry.v2_data()
else: else:
# There are no mtime-cached directories in the Python implementation # There are no mtime-cached directories in the Python implementation
flags = 0 flags = DIRSTATE_V2_DIRECTORY
size = 0 size = 0
mtime_s = 0 mtime_s = 0
mtime_ns = 0 mtime_ns = 0
return NODE.pack( return NODE.pack(
path_start, path_start,
path_len, path_len,
basename_start, basename_start,
copy_source_start, copy_source_start,

mercurial/helptext/internals/dirstate-v2.txt

* Offset 30: * Offset 30:
A `flags` fields that packs some boolean values as bits of a 16-bit integer. A `flags` fields that packs some boolean values as bits of a 16-bit integer.
Starting from least-significant, bit masks are:: Starting from least-significant, bit masks are::
WDIR_TRACKED = 1 << 0 WDIR_TRACKED = 1 << 0
P1_TRACKED = 1 << 1 P1_TRACKED = 1 << 1
P2_INFO = 1 << 2 P2_INFO = 1 << 2
HAS_MODE_AND_SIZE = 1 << 3 HAS_MODE_AND_SIZE = 1 << 3
HAS_FILE_MTIME = 1 << 4 HAS_MTIME = 1 << 4
HAS_DIRECTORY_MTIME = 1 << 5 DIRECTORY = 1 << 5
MODE_EXEC_PERM = 1 << 6 MODE_EXEC_PERM = 1 << 6
MODE_IS_SYMLINK = 1 << 7 MODE_IS_SYMLINK = 1 << 7
EXPECTED_STATE_IS_MODIFIED = 1 << 8 EXPECTED_STATE_IS_MODIFIED = 1 << 8
ALL_UNKNOWN_RECORDED = 1 << 9 ALL_UNKNOWN_RECORDED = 1 << 9
ALL_IGNORED_RECORDED = 1 << 10 ALL_IGNORED_RECORDED = 1 << 10
HAS_FALLBACK_EXEC = 1 << 11 HAS_FALLBACK_EXEC = 1 << 11
FALLBACK_EXEC = 1 << 12 FALLBACK_EXEC = 1 << 12
HAS_FALLBACK_SYMLINK = 1 << 13 HAS_FALLBACK_SYMLINK = 1 << 13
in bytes truncated its lower to 31 bits. in bytes truncated its lower to 31 bits.
- The expected execute permission for the file’s owner - The expected execute permission for the file’s owner
is given by `MODE_EXEC_PERM` is given by `MODE_EXEC_PERM`
- The expected file type is given by `MODE_IS_SIMLINK`: - The expected file type is given by `MODE_IS_SIMLINK`:
a symbolic link if set, or a normal file if unset. a symbolic link if set, or a normal file if unset.
If this is unset the expected size, permission, and file type are unknown. If this is unset the expected size, permission, and file type are unknown.
The `size` field is unused (set to zero). The `size` field is unused (set to zero).
`HAS_FILE_MTIME` `HAS_MTIME`
Must be unset for untracked nodes. The nodes contains a "valid" last modification time in the `mtime` field.
If this and `HAS_DIRECTORY_MTIME` are both unset,
the `mtime` field is unused (set to zero).
If this is set, `mtime` is the expected modification time. It means the `mtime` was already strictly in the past when observed,
`HAS_DIRECTORY_MTIME`
Must be unset for file tracked anywhere.
If this and `HAS_DIRECTORY_MTIME` are both unset,
the `mtime` field is unused (set to zero).
If this is set, at some point,
this path in the working directory was observed:
- To be a directory
- With the modification time given in `mtime`
- 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
and must cause a different modification time and must cause a different modification time
(unless the system clock jumps back and we get unlucky, (unless the system clock jumps back and we get unlucky,
which is not impossible but deemed unlikely enough). which is not impossible but deemed unlikely enough).
- All direct children of this directory
(as returned by `std::fs::read_dir`)
either have a corresponding dirstate node,
or are ignored by ignore patterns whose hash is in tree metadata.
This means that if `std::fs::symlink_metadata` later reports This means that if `std::fs::symlink_metadata` later reports
the same modification time the same modification time
and ignored patterns haven’t changed, and ignored patterns haven’t changed,
a run of status that is not listing ignored files we can assume the node to be unchanged on disk.
can skip calling `std::fs::read_dir` again for this directory,
The `mtime` field can then be used to skip more expensive lookup when
checking the status of "tracked" nodes.
It can also be set for node where `DIRECTORY` is set.
See `DIRECTORY` documentation for details.
`DIRECTORY`
When set, this entry will match a directory that exists or existed on the
AlphareUnsubmitted
Not Done

that exists*

Alphare: that exists*
file system.
* When `HAS_MTIME` is set a directory has been seen on the file system and
`mtime` matches its last modificiation time. However, `HAS_MTIME` not being set
does not indicate the lack of directory on the file system.
* When not tracked anywhere, this node does not represent an ignored or
AlphareUnsubmitted
Not Done

unknown file*

Alphare: unknown file*
unknown file on disk.
If `HAS_MTIME` is set
and `mtime` matches the last modification time of the directory on disk,
AlphareUnsubmitted
Not Done

mtime matches*

Alphare: `mtime` matches*
AlphareUnsubmitted
Not Done

This is not done, commenting to remember to amend

Alphare: This is not done, commenting to remember to amend
the directory is unchanged
and we can skip calling `std::fs::read_dir` again for this directory,
AlphareUnsubmitted
Not Done

Unchanged*

Alphare: Unchanged*
and iterate child dirstate nodes instead. and iterate child dirstate nodes instead.
(as long as `ALL_UNKNOWN_RECORDED` and `ALL_IGNORED_RECORDED` are taken
AlphareUnsubmitted
Not Done

taken into account*

Alphare: taken into account*
into account)
`MODE_EXEC_PERM` `MODE_EXEC_PERM`
Must be unset if `HAS_MODE_AND_SIZE` is unset. Must be unset if `HAS_MODE_AND_SIZE` is unset.
If `HAS_MODE_AND_SIZE` is set, If `HAS_MODE_AND_SIZE` is set,
this indicates whether the file’s own is expected this indicates whether the file’s own is expected
to have execute permission. to have execute permission.
`MODE_IS_SYMLINK` `MODE_IS_SYMLINK`
Must be unset if `HAS_MODE_AND_SIZE` is unset. Must be unset if `HAS_MODE_AND_SIZE` is unset.
If `HAS_MODE_AND_SIZE` is set, If `HAS_MODE_AND_SIZE` is set,
this indicates whether the file is expected to be a symlink this indicates whether the file is expected to be a symlink
as opposed to a normal file. as opposed to a normal file.
`EXPECTED_STATE_IS_MODIFIED` `EXPECTED_STATE_IS_MODIFIED`
Must be unset for untracked nodes. Must be unset for untracked nodes.
For: For:
- a file tracked anywhere - a file tracked anywhere
- that has expected metadata (`HAS_MODE_AND_SIZE` and `HAS_FILE_MTIME`) - that has expected metadata (`HAS_MODE_AND_SIZE` and `HAS_MTIME`)
- if that metadata matches - if that metadata matches
metadata found in the working directory with `stat` metadata found in the working directory with `stat`
This bit indicates the status of the file. This bit indicates the status of the file.
If set, the status is modified. If unset, it is clean. If set, the status is modified. If unset, it is clean.
In cases where `hg status` needs to read the contents of a file In cases where `hg status` needs to read the contents of a file
because metadata is ambiguous, this bit lets it record the result because metadata is ambiguous, this bit lets it record the result
if the result is modified so that a future run of `hg status` if the result is modified so that a future run of `hg status`
does not need to do the same again. does not need to do the same again.
It is valid to never set this bit, It is valid to never set this bit,
and consider expected metadata ambiguous if it is set. and consider expected metadata ambiguous if it is set.
`ALL_UNKNOWN_RECORDED` `ALL_UNKNOWN_RECORDED`
If set, all "unknown" children existing on disk (at the time of the last If set, all "unknown" children existing on disk (at the time of the last
status) have been recorded and the `mtime` associated with status) have been recorded and the `mtime` associated with
`HAS_DIRECTORY_MTIME` can be used for optimization even when "unknown" file `DIRECTORY` can be used for optimization even when "unknown" file
are listed. are listed.
Note that the amount recorded "unknown" children can still be zero if None Note that the amount recorded "unknown" children can still be zero if None
where present. where present.
Also note that having this flag unset does not imply that no "unknown" Also note that having this flag unset does not imply that no "unknown"
children have been recorded. Some might be present, but there is no garantee children have been recorded. Some might be present, but there is no garantee
that is will be all of them. that is will be all of them.
`ALL_IGNORED_RECORDED` `ALL_IGNORED_RECORDED`
If set, all "ignored" children existing on disk (at the time of the last If set, all "ignored" children existing on disk (at the time of the last
status) have been recorded and the `mtime` associated with status) have been recorded and the `mtime` associated with
`HAS_DIRECTORY_MTIME` can be used for optimization even when "ignored" file `DIRECTORY` can be used for optimization even when "ignored" file
are listed. are listed.
Note that the amount recorded "ignored" children can still be zero if None Note that the amount recorded "ignored" children can still be zero if None
where present. where present.
Also note that having this flag unset does not imply that no "ignored" Also note that having this flag unset does not imply that no "ignored"
children have been recorded. Some might be present, but there is no garantee children have been recorded. Some might be present, but there is no garantee
that is will be all of them. that is will be all of them.

mercurial/pure/parsers.py

# a special value used internally for `time` if the time is ambigeous # a special value used internally for `time` if the time is ambigeous
AMBIGUOUS_TIME = -1 AMBIGUOUS_TIME = -1
# Bits of the `flags` byte inside a node in the file format # Bits of the `flags` byte inside a node in the file format
DIRSTATE_V2_WDIR_TRACKED = 1 << 0 DIRSTATE_V2_WDIR_TRACKED = 1 << 0
DIRSTATE_V2_P1_TRACKED = 1 << 1 DIRSTATE_V2_P1_TRACKED = 1 << 1
DIRSTATE_V2_P2_INFO = 1 << 2 DIRSTATE_V2_P2_INFO = 1 << 2
DIRSTATE_V2_HAS_MODE_AND_SIZE = 1 << 3 DIRSTATE_V2_HAS_MODE_AND_SIZE = 1 << 3
DIRSTATE_V2_HAS_FILE_MTIME = 1 << 4 DIRSTATE_V2_HAS_MTIME = 1 << 4
_DIRSTATE_V2_HAS_DIRCTORY_MTIME = 1 << 5 # Unused when Rust is not available DIRSTATE_V2_DIRECTORY = 1 << 5
DIRSTATE_V2_MODE_EXEC_PERM = 1 << 6 DIRSTATE_V2_MODE_EXEC_PERM = 1 << 6
DIRSTATE_V2_MODE_IS_SYMLINK = 1 << 7 DIRSTATE_V2_MODE_IS_SYMLINK = 1 << 7
DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED = 1 << 8 DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED = 1 << 8
DIRSTATE_V2_ALL_UNKNOWN_RECORDED = 1 << 9 DIRSTATE_V2_ALL_UNKNOWN_RECORDED = 1 << 9
DIRSTATE_V2_ALL_IGNORED_RECORDED = 1 << 10 DIRSTATE_V2_ALL_IGNORED_RECORDED = 1 << 10
DIRSTATE_V2_HAS_FALLBACK_EXEC = 1 << 11 DIRSTATE_V2_HAS_FALLBACK_EXEC = 1 << 11
DIRSTATE_V2_FALLBACK_EXEC = 1 << 12 DIRSTATE_V2_FALLBACK_EXEC = 1 << 12
DIRSTATE_V2_HAS_FALLBACK_SYMLINK = 1 << 13 DIRSTATE_V2_HAS_FALLBACK_SYMLINK = 1 << 13
self._size = parentfiledata[1] self._size = parentfiledata[1]
if has_meaningful_mtime: if has_meaningful_mtime:
self._mtime_s, self._mtime_ns = parentfiledata[2] self._mtime_s, self._mtime_ns = parentfiledata[2]
@classmethod @classmethod
def from_v2_data(cls, flags, size, mtime_s, mtime_ns): def from_v2_data(cls, flags, size, mtime_s, mtime_ns):
"""Build a new DirstateItem object from V2 data""" """Build a new DirstateItem object from V2 data"""
has_mode_size = bool(flags & DIRSTATE_V2_HAS_MODE_AND_SIZE) has_mode_size = bool(flags & DIRSTATE_V2_HAS_MODE_AND_SIZE)
has_meaningful_mtime = bool(flags & DIRSTATE_V2_HAS_FILE_MTIME) has_meaningful_mtime = bool(flags & DIRSTATE_V2_HAS_MTIME)
if flags & DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS: if flags & DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS:
# The current code is not able to do the more subtle comparison that the # The current code is not able to do the more subtle comparison that the
# MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime # MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime
has_meaningful_mtime = False has_meaningful_mtime = False
mode = None mode = None
if flags & +DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED: if flags & +DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED:
# we do not have support for this flag in the code yet, # we do not have support for this flag in the code yet,
flags |= DIRSTATE_V2_P2_INFO flags |= DIRSTATE_V2_P2_INFO
if self._mode is not None and self._size is not None: if self._mode is not None and self._size is not None:
flags |= DIRSTATE_V2_HAS_MODE_AND_SIZE flags |= DIRSTATE_V2_HAS_MODE_AND_SIZE
if self.mode & stat.S_IXUSR: if self.mode & stat.S_IXUSR:
flags |= DIRSTATE_V2_MODE_EXEC_PERM flags |= DIRSTATE_V2_MODE_EXEC_PERM
if stat.S_ISLNK(self.mode): if stat.S_ISLNK(self.mode):
flags |= DIRSTATE_V2_MODE_IS_SYMLINK flags |= DIRSTATE_V2_MODE_IS_SYMLINK
if self._mtime_s is not None: if self._mtime_s is not None:
flags |= DIRSTATE_V2_HAS_FILE_MTIME flags |= DIRSTATE_V2_HAS_MTIME
if self._fallback_exec is not None: if self._fallback_exec is not None:
flags |= DIRSTATE_V2_HAS_FALLBACK_EXEC flags |= DIRSTATE_V2_HAS_FALLBACK_EXEC
if self._fallback_exec: if self._fallback_exec:
flags |= DIRSTATE_V2_FALLBACK_EXEC flags |= DIRSTATE_V2_FALLBACK_EXEC
if self._fallback_symlink is not None: if self._fallback_symlink is not None:
flags |= DIRSTATE_V2_HAS_FALLBACK_SYMLINK flags |= DIRSTATE_V2_HAS_FALLBACK_SYMLINK

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

bitflags! { bitflags! {
#[repr(C)] #[repr(C)]
struct Flags: u16 { struct Flags: u16 {
const WDIR_TRACKED = 1 << 0; const WDIR_TRACKED = 1 << 0;
const P1_TRACKED = 1 << 1; const P1_TRACKED = 1 << 1;
const P2_INFO = 1 << 2; const P2_INFO = 1 << 2;
const HAS_MODE_AND_SIZE = 1 << 3; const HAS_MODE_AND_SIZE = 1 << 3;
const HAS_FILE_MTIME = 1 << 4; const HAS_MTIME = 1 << 4;
const HAS_DIRECTORY_MTIME = 1 << 5; const DIRECTORY = 1 << 5;
const MODE_EXEC_PERM = 1 << 6; const MODE_EXEC_PERM = 1 << 6;
const MODE_IS_SYMLINK = 1 << 7; const MODE_IS_SYMLINK = 1 << 7;
const EXPECTED_STATE_IS_MODIFIED = 1 << 8; const EXPECTED_STATE_IS_MODIFIED = 1 << 8;
const ALL_UNKNOWN_RECORDED = 1 << 9; const ALL_UNKNOWN_RECORDED = 1 << 9;
const ALL_IGNORED_RECORDED = 1 << 10; const ALL_IGNORED_RECORDED = 1 << 10;
const HAS_FALLBACK_EXEC = 1 << 11; const HAS_FALLBACK_EXEC = 1 << 11;
const FALLBACK_EXEC = 1 << 12; const FALLBACK_EXEC = 1 << 12;
const HAS_FALLBACK_SYMLINK = 1 << 13; const HAS_FALLBACK_SYMLINK = 1 << 13;
} else { } else {
Ok(dirstate_map::NodeData::None) Ok(dirstate_map::NodeData::None)
} }
} }
pub(super) fn cached_directory_mtime( pub(super) fn cached_directory_mtime(
&self, &self,
) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> { ) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> {
// For now we do not have code to handle ALL_UNKNOWN_RECORDED, so we // For now we do not have code to handle the absence of
// ignore the mtime if the flag is set. // ALL_UNKNOWN_RECORDED, so we ignore the mtime if the flag is
if self.flags().contains(Flags::HAS_DIRECTORY_MTIME) // unset.
if self.flags().contains(Flags::DIRECTORY)
&& self.flags().contains(Flags::HAS_MTIME)
AlphareUnsubmitted
Not Done

to handle the absence of ALL_UNKNOWN_RECORDED

Alphare: to handle the absence of `ALL_UNKNOWN_RECORDED`
&& self.flags().contains(Flags::ALL_UNKNOWN_RECORDED) && self.flags().contains(Flags::ALL_UNKNOWN_RECORDED)
{ {
if self.flags().contains(Flags::HAS_FILE_MTIME) {
Err(DirstateV2ParseError)
} else {
Ok(Some(self.mtime.try_into()?)) Ok(Some(self.mtime.try_into()?))
}
} 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
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_FILE_MTIME) let mtime = if self.flags().contains(Flags::HAS_MTIME)
&& !self.flags().contains(Flags::DIRECTORY)
&& !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED) && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
// The current code is not able to do the more subtle comparison that the // The current code is not able to do the more subtle comparison that the
// MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime // MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime
&& !self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS) && !self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS)
{ {
Some(self.mtime.try_into()?) Some(self.mtime.try_into()?)
} else { } else {
None None
flags.set(Flags::MODE_EXEC_PERM, exec_perm); flags.set(Flags::MODE_EXEC_PERM, exec_perm);
flags.set(Flags::MODE_IS_SYMLINK, is_symlink); flags.set(Flags::MODE_IS_SYMLINK, is_symlink);
flags.insert(Flags::HAS_MODE_AND_SIZE); flags.insert(Flags::HAS_MODE_AND_SIZE);
s.into() s.into()
} else { } else {
0.into() 0.into()
}; };
let mtime = if let Some(m) = mtime_opt { let mtime = if let Some(m) = mtime_opt {
flags.insert(Flags::HAS_FILE_MTIME); flags.insert(Flags::HAS_MTIME);
m.into() m.into()
} else { } else {
PackedTruncatedTimestamp::null() PackedTruncatedTimestamp::null()
}; };
if let Some(f_exec) = fallback_exec { if let Some(f_exec) = fallback_exec {
flags.insert(Flags::HAS_FALLBACK_EXEC); flags.insert(Flags::HAS_FALLBACK_EXEC);
if f_exec { if f_exec {
flags.insert(Flags::FALLBACK_EXEC); flags.insert(Flags::FALLBACK_EXEC);
// 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::HAS_DIRECTORY_MTIME Flags::DIRECTORY
| Flags::HAS_MTIME
| Flags::ALL_UNKNOWN_RECORDED, | Flags::ALL_UNKNOWN_RECORDED,
0.into(), 0.into(),
(*mtime).into(), (*mtime).into(),
), ),
dirstate_map::NodeData::None => ( dirstate_map::NodeData::None => (
Flags::empty(), Flags::DIRECTORY,
0.into(), 0.into(),
PackedTruncatedTimestamp::null(), PackedTruncatedTimestamp::null(),
), ),
}; };
Node { Node {
children, children,
copy_source, copy_source,
full_path, full_path,