2005-04-07 22:16:10 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-04-07 22:13:13 +00:00
|
|
|
#include "cache.h"
|
|
|
|
|
|
|
|
struct cache_entry **active_cache = NULL;
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
static time_t index_file_timestamp;
|
2005-05-06 23:48:43 +00:00
|
|
|
unsigned int active_nr = 0, active_alloc = 0, active_cache_changed = 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
|
2005-05-15 21:23:12 +00:00
|
|
|
/*
|
|
|
|
* This only updates the "non-critical" parts of the directory
|
|
|
|
* cache, ie the parts that aren't tracked by GIT, and only used
|
|
|
|
* to validate the cache.
|
|
|
|
*/
|
|
|
|
void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
|
|
|
|
{
|
|
|
|
ce->ce_ctime.sec = htonl(st->st_ctime);
|
|
|
|
ce->ce_mtime.sec = htonl(st->st_mtime);
|
2005-05-22 22:08:15 +00:00
|
|
|
#ifdef USE_NSEC
|
2005-05-15 21:23:12 +00:00
|
|
|
ce->ce_ctime.nsec = htonl(st->st_ctim.tv_nsec);
|
|
|
|
ce->ce_mtime.nsec = htonl(st->st_mtim.tv_nsec);
|
|
|
|
#endif
|
|
|
|
ce->ce_dev = htonl(st->st_dev);
|
|
|
|
ce->ce_ino = htonl(st->st_ino);
|
|
|
|
ce->ce_uid = htonl(st->st_uid);
|
|
|
|
ce->ce_gid = htonl(st->st_gid);
|
|
|
|
ce->ce_size = htonl(st->st_size);
|
2006-02-09 05:15:24 +00:00
|
|
|
|
|
|
|
if (assume_unchanged)
|
|
|
|
ce->ce_flags |= htons(CE_VALID);
|
2005-05-15 21:23:12 +00:00
|
|
|
}
|
|
|
|
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
static int ce_compare_data(struct cache_entry *ce, struct stat *st)
|
|
|
|
{
|
|
|
|
int match = -1;
|
|
|
|
int fd = open(ce->name, O_RDONLY);
|
|
|
|
|
|
|
|
if (fd >= 0) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
if (!index_fd(sha1, fd, st, 0, NULL))
|
|
|
|
match = memcmp(sha1, ce->sha1, 20);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ce_compare_link(struct cache_entry *ce, unsigned long expected_size)
|
|
|
|
{
|
|
|
|
int match = -1;
|
|
|
|
char *target;
|
|
|
|
void *buffer;
|
|
|
|
unsigned long size;
|
|
|
|
char type[10];
|
|
|
|
int len;
|
|
|
|
|
|
|
|
target = xmalloc(expected_size);
|
|
|
|
len = readlink(ce->name, target, expected_size);
|
|
|
|
if (len != expected_size) {
|
|
|
|
free(target);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
buffer = read_sha1_file(ce->sha1, type, &size);
|
|
|
|
if (!buffer) {
|
|
|
|
free(target);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (size == expected_size)
|
|
|
|
match = memcmp(buffer, target, size);
|
|
|
|
free(buffer);
|
|
|
|
free(target);
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ce_modified_check_fs(struct cache_entry *ce, struct stat *st)
|
|
|
|
{
|
|
|
|
switch (st->st_mode & S_IFMT) {
|
|
|
|
case S_IFREG:
|
|
|
|
if (ce_compare_data(ce, st))
|
|
|
|
return DATA_CHANGED;
|
|
|
|
break;
|
|
|
|
case S_IFLNK:
|
|
|
|
if (ce_compare_link(ce, st->st_size))
|
|
|
|
return DATA_CHANGED;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return TYPE_CHANGED;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-20 20:12:18 +00:00
|
|
|
static int ce_match_stat_basic(struct cache_entry *ce, struct stat *st)
|
2005-04-09 16:48:20 +00:00
|
|
|
{
|
|
|
|
unsigned int changed = 0;
|
|
|
|
|
2005-05-05 12:38:25 +00:00
|
|
|
switch (ntohl(ce->ce_mode) & S_IFMT) {
|
|
|
|
case S_IFREG:
|
|
|
|
changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0;
|
2005-10-12 01:45:33 +00:00
|
|
|
/* We consider only the owner x bit to be relevant for
|
|
|
|
* "mode changes"
|
|
|
|
*/
|
|
|
|
if (trust_executable_bit &&
|
|
|
|
(0100 & (ntohl(ce->ce_mode) ^ st->st_mode)))
|
2005-05-06 13:45:01 +00:00
|
|
|
changed |= MODE_CHANGED;
|
2005-05-05 12:38:25 +00:00
|
|
|
break;
|
|
|
|
case S_IFLNK:
|
|
|
|
changed |= !S_ISLNK(st->st_mode) ? TYPE_CHANGED : 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
die("internal error: ce_mode is %o", ntohl(ce->ce_mode));
|
|
|
|
}
|
2005-04-15 17:44:27 +00:00
|
|
|
if (ce->ce_mtime.sec != htonl(st->st_mtime))
|
2005-04-09 16:48:20 +00:00
|
|
|
changed |= MTIME_CHANGED;
|
2005-04-15 17:44:27 +00:00
|
|
|
if (ce->ce_ctime.sec != htonl(st->st_ctime))
|
|
|
|
changed |= CTIME_CHANGED;
|
|
|
|
|
2005-05-22 22:08:15 +00:00
|
|
|
#ifdef USE_NSEC
|
2005-04-15 17:44:27 +00:00
|
|
|
/*
|
|
|
|
* nsec seems unreliable - not all filesystems support it, so
|
|
|
|
* as long as it is in the inode cache you get right nsec
|
|
|
|
* but after it gets flushed, you get zero nsec.
|
|
|
|
*/
|
2005-04-21 16:58:24 +00:00
|
|
|
if (ce->ce_mtime.nsec != htonl(st->st_mtim.tv_nsec))
|
2005-04-15 17:44:27 +00:00
|
|
|
changed |= MTIME_CHANGED;
|
2005-04-21 16:58:24 +00:00
|
|
|
if (ce->ce_ctime.nsec != htonl(st->st_ctim.tv_nsec))
|
2005-04-09 16:48:20 +00:00
|
|
|
changed |= CTIME_CHANGED;
|
2005-04-15 17:44:27 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (ce->ce_uid != htonl(st->st_uid) ||
|
|
|
|
ce->ce_gid != htonl(st->st_gid))
|
2005-04-09 16:48:20 +00:00
|
|
|
changed |= OWNER_CHANGED;
|
2005-05-22 22:08:15 +00:00
|
|
|
if (ce->ce_ino != htonl(st->st_ino))
|
2005-04-09 16:48:20 +00:00
|
|
|
changed |= INODE_CHANGED;
|
2005-05-22 22:08:15 +00:00
|
|
|
|
|
|
|
#ifdef USE_STDEV
|
|
|
|
/*
|
|
|
|
* st_dev breaks on network filesystems where different
|
|
|
|
* clients will have different views of what "device"
|
|
|
|
* the filesystem is on
|
|
|
|
*/
|
|
|
|
if (ce->ce_dev != htonl(st->st_dev))
|
|
|
|
changed |= INODE_CHANGED;
|
|
|
|
#endif
|
|
|
|
|
2005-04-15 17:44:27 +00:00
|
|
|
if (ce->ce_size != htonl(st->st_size))
|
2005-04-09 16:48:20 +00:00
|
|
|
changed |= DATA_CHANGED;
|
2005-09-19 22:11:15 +00:00
|
|
|
|
2005-12-20 20:12:18 +00:00
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2006-02-09 05:15:24 +00:00
|
|
|
int ce_match_stat(struct cache_entry *ce, struct stat *st, int ignore_valid)
|
2005-12-20 20:12:18 +00:00
|
|
|
{
|
2006-02-09 05:15:24 +00:00
|
|
|
unsigned int changed;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If it's marked as always valid in the index, it's
|
|
|
|
* valid whatever the checked-out copy says.
|
|
|
|
*/
|
|
|
|
if (!ignore_valid && (ce->ce_flags & htons(CE_VALID)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
changed = ce_match_stat_basic(ce, st);
|
2005-12-20 20:12:18 +00:00
|
|
|
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
/*
|
|
|
|
* Within 1 second of this sequence:
|
|
|
|
* echo xyzzy >file && git-update-index --add file
|
|
|
|
* running this command:
|
|
|
|
* echo frotz >file
|
|
|
|
* would give a falsely clean cache entry. The mtime and
|
|
|
|
* length match the cache, and other stat fields do not change.
|
|
|
|
*
|
|
|
|
* We could detect this at update-index time (the cache entry
|
|
|
|
* being registered/updated records the same time as "now")
|
|
|
|
* and delay the return from git-update-index, but that would
|
|
|
|
* effectively mean we can make at most one commit per second,
|
|
|
|
* which is not acceptable. Instead, we check cache entries
|
|
|
|
* whose mtime are the same as the index file timestamp more
|
2006-02-09 05:15:24 +00:00
|
|
|
* carefully than others.
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
*/
|
|
|
|
if (!changed &&
|
|
|
|
index_file_timestamp &&
|
|
|
|
index_file_timestamp <= ntohl(ce->ce_mtime.sec))
|
|
|
|
changed |= ce_modified_check_fs(ce, st);
|
2005-09-19 22:11:15 +00:00
|
|
|
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
return changed;
|
2005-09-19 22:11:15 +00:00
|
|
|
}
|
|
|
|
|
2006-02-09 05:15:24 +00:00
|
|
|
int ce_modified(struct cache_entry *ce, struct stat *st, int really)
|
2005-09-19 22:11:15 +00:00
|
|
|
{
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
int changed, changed_fs;
|
2006-02-09 05:15:24 +00:00
|
|
|
changed = ce_match_stat(ce, st, really);
|
2005-09-19 22:11:15 +00:00
|
|
|
if (!changed)
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* If the mode or type has changed, there's no point in trying
|
|
|
|
* to refresh the entry - it's not going to match
|
|
|
|
*/
|
|
|
|
if (changed & (MODE_CHANGED | TYPE_CHANGED))
|
|
|
|
return changed;
|
|
|
|
|
|
|
|
/* Immediately after read-tree or update-index --cacheinfo,
|
|
|
|
* the length field is zero. For other cases the ce_size
|
|
|
|
* should match the SHA1 recorded in the index entry.
|
|
|
|
*/
|
|
|
|
if ((changed & DATA_CHANGED) && ce->ce_size != htonl(0))
|
|
|
|
return changed;
|
|
|
|
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
changed_fs = ce_modified_check_fs(ce, st);
|
|
|
|
if (changed_fs)
|
|
|
|
return changed | changed_fs;
|
2005-09-19 22:11:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-05-20 16:09:18 +00:00
|
|
|
int base_name_compare(const char *name1, int len1, int mode1,
|
|
|
|
const char *name2, int len2, int mode2)
|
|
|
|
{
|
|
|
|
unsigned char c1, c2;
|
|
|
|
int len = len1 < len2 ? len1 : len2;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
cmp = memcmp(name1, name2, len);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
c1 = name1[len];
|
|
|
|
c2 = name2[len];
|
|
|
|
if (!c1 && S_ISDIR(mode1))
|
|
|
|
c1 = '/';
|
|
|
|
if (!c2 && S_ISDIR(mode2))
|
|
|
|
c2 = '/';
|
|
|
|
return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 05:51:44 +00:00
|
|
|
int cache_name_compare(const char *name1, int flags1, const char *name2, int flags2)
|
2005-04-09 16:26:55 +00:00
|
|
|
{
|
2005-04-16 05:51:44 +00:00
|
|
|
int len1 = flags1 & CE_NAMEMASK;
|
|
|
|
int len2 = flags2 & CE_NAMEMASK;
|
2005-04-09 16:26:55 +00:00
|
|
|
int len = len1 < len2 ? len1 : len2;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
cmp = memcmp(name1, name2, len);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
if (len1 < len2)
|
|
|
|
return -1;
|
|
|
|
if (len1 > len2)
|
|
|
|
return 1;
|
2006-02-09 05:15:24 +00:00
|
|
|
|
2006-02-13 07:46:25 +00:00
|
|
|
/* Compare stages */
|
|
|
|
flags1 &= CE_STAGEMASK;
|
|
|
|
flags2 &= CE_STAGEMASK;
|
2006-02-09 05:15:24 +00:00
|
|
|
|
2005-04-16 05:51:44 +00:00
|
|
|
if (flags1 < flags2)
|
|
|
|
return -1;
|
|
|
|
if (flags1 > flags2)
|
|
|
|
return 1;
|
2005-04-09 16:26:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int cache_name_pos(const char *name, int namelen)
|
|
|
|
{
|
|
|
|
int first, last;
|
|
|
|
|
|
|
|
first = 0;
|
|
|
|
last = active_nr;
|
|
|
|
while (last > first) {
|
|
|
|
int next = (last + first) >> 1;
|
|
|
|
struct cache_entry *ce = active_cache[next];
|
2005-06-07 20:35:56 +00:00
|
|
|
int cmp = cache_name_compare(name, namelen, ce->name, ntohs(ce->ce_flags));
|
2005-04-09 16:26:55 +00:00
|
|
|
if (!cmp)
|
2005-04-11 05:06:50 +00:00
|
|
|
return next;
|
2005-04-09 16:26:55 +00:00
|
|
|
if (cmp < 0) {
|
|
|
|
last = next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
first = next+1;
|
|
|
|
}
|
2005-04-11 05:06:50 +00:00
|
|
|
return -first-1;
|
2005-04-09 16:26:55 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 19:05:45 +00:00
|
|
|
/* Remove entry, return true if there are more entries to go.. */
|
2005-05-15 02:04:25 +00:00
|
|
|
int remove_cache_entry_at(int pos)
|
2005-04-16 19:05:45 +00:00
|
|
|
{
|
2005-05-06 23:48:43 +00:00
|
|
|
active_cache_changed = 1;
|
2005-04-16 19:05:45 +00:00
|
|
|
active_nr--;
|
|
|
|
if (pos >= active_nr)
|
|
|
|
return 0;
|
|
|
|
memmove(active_cache + pos, active_cache + pos + 1, (active_nr - pos) * sizeof(struct cache_entry *));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
int remove_file_from_cache(const char *path)
|
2005-04-09 19:09:27 +00:00
|
|
|
{
|
|
|
|
int pos = cache_name_pos(path, strlen(path));
|
2005-04-17 16:53:35 +00:00
|
|
|
if (pos < 0)
|
|
|
|
pos = -pos-1;
|
|
|
|
while (pos < active_nr && !strcmp(active_cache[pos]->name, path))
|
2005-05-15 02:04:25 +00:00
|
|
|
remove_cache_entry_at(pos);
|
2005-04-09 19:09:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-05-15 02:04:25 +00:00
|
|
|
int ce_same_name(struct cache_entry *a, struct cache_entry *b)
|
2005-04-16 19:05:45 +00:00
|
|
|
{
|
|
|
|
int len = ce_namelen(a);
|
|
|
|
return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
|
|
|
|
}
|
|
|
|
|
2005-07-14 23:55:06 +00:00
|
|
|
int ce_path_match(const struct cache_entry *ce, const char **pathspec)
|
|
|
|
{
|
|
|
|
const char *match, *name;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!pathspec)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
len = ce_namelen(ce);
|
|
|
|
name = ce->name;
|
|
|
|
while ((match = *pathspec++) != NULL) {
|
|
|
|
int matchlen = strlen(match);
|
|
|
|
if (matchlen > len)
|
|
|
|
continue;
|
|
|
|
if (memcmp(name, match, matchlen))
|
|
|
|
continue;
|
|
|
|
if (matchlen && name[matchlen-1] == '/')
|
|
|
|
return 1;
|
|
|
|
if (name[matchlen] == '/' || !name[matchlen])
|
|
|
|
return 1;
|
2005-08-17 03:44:32 +00:00
|
|
|
if (!matchlen)
|
|
|
|
return 1;
|
2005-07-14 23:55:06 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-06-19 03:21:34 +00:00
|
|
|
/*
|
|
|
|
* Do we have another file that has the beginning components being a
|
|
|
|
* proper superset of the name we're trying to add?
|
2005-05-08 04:48:12 +00:00
|
|
|
*/
|
2005-06-19 03:21:34 +00:00
|
|
|
static int has_file_name(const struct cache_entry *ce, int pos, int ok_to_replace)
|
2005-05-08 04:48:12 +00:00
|
|
|
{
|
2005-06-19 03:21:34 +00:00
|
|
|
int retval = 0;
|
|
|
|
int len = ce_namelen(ce);
|
2005-06-25 09:25:29 +00:00
|
|
|
int stage = ce_stage(ce);
|
2005-06-19 03:21:34 +00:00
|
|
|
const char *name = ce->name;
|
2005-05-08 04:48:12 +00:00
|
|
|
|
2005-06-19 03:21:34 +00:00
|
|
|
while (pos < active_nr) {
|
|
|
|
struct cache_entry *p = active_cache[pos++];
|
2005-05-08 04:48:12 +00:00
|
|
|
|
2005-06-19 03:21:34 +00:00
|
|
|
if (len >= ce_namelen(p))
|
2005-05-08 04:48:12 +00:00
|
|
|
break;
|
2005-06-19 03:21:34 +00:00
|
|
|
if (memcmp(name, p->name, len))
|
|
|
|
break;
|
2005-06-25 09:25:29 +00:00
|
|
|
if (ce_stage(p) != stage)
|
|
|
|
continue;
|
2005-06-19 03:21:34 +00:00
|
|
|
if (p->name[len] != '/')
|
|
|
|
continue;
|
|
|
|
retval = -1;
|
|
|
|
if (!ok_to_replace)
|
|
|
|
break;
|
|
|
|
remove_cache_entry_at(--pos);
|
2005-05-08 04:48:12 +00:00
|
|
|
}
|
2005-06-19 03:21:34 +00:00
|
|
|
return retval;
|
|
|
|
}
|
2005-05-08 04:48:12 +00:00
|
|
|
|
2005-06-19 03:21:34 +00:00
|
|
|
/*
|
|
|
|
* Do we have another file with a pathname that is a proper
|
|
|
|
* subset of the name we're trying to add?
|
|
|
|
*/
|
|
|
|
static int has_dir_name(const struct cache_entry *ce, int pos, int ok_to_replace)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
2005-06-25 09:25:29 +00:00
|
|
|
int stage = ce_stage(ce);
|
2005-06-19 03:21:34 +00:00
|
|
|
const char *name = ce->name;
|
|
|
|
const char *slash = name + ce_namelen(ce);
|
2005-05-08 04:48:12 +00:00
|
|
|
|
2005-06-19 03:21:34 +00:00
|
|
|
for (;;) {
|
|
|
|
int len;
|
2005-05-08 04:48:12 +00:00
|
|
|
|
2005-06-19 03:21:34 +00:00
|
|
|
for (;;) {
|
|
|
|
if (*--slash == '/')
|
|
|
|
break;
|
|
|
|
if (slash <= ce->name)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
len = slash - name;
|
2005-05-08 04:48:12 +00:00
|
|
|
|
2005-06-25 09:25:29 +00:00
|
|
|
pos = cache_name_pos(name, ntohs(create_ce_flags(len, stage)));
|
2005-06-19 03:21:34 +00:00
|
|
|
if (pos >= 0) {
|
|
|
|
retval = -1;
|
|
|
|
if (ok_to_replace)
|
|
|
|
break;
|
2005-05-15 02:04:25 +00:00
|
|
|
remove_cache_entry_at(pos);
|
2005-06-19 03:21:34 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Trivial optimization: if we find an entry that
|
|
|
|
* already matches the sub-directory, then we know
|
2005-06-25 09:25:29 +00:00
|
|
|
* we're ok, and we can exit.
|
2005-06-19 03:21:34 +00:00
|
|
|
*/
|
|
|
|
pos = -pos-1;
|
2005-06-25 09:25:29 +00:00
|
|
|
while (pos < active_nr) {
|
2005-06-19 03:21:34 +00:00
|
|
|
struct cache_entry *p = active_cache[pos];
|
2005-06-25 09:25:29 +00:00
|
|
|
if ((ce_namelen(p) <= len) ||
|
|
|
|
(p->name[len] != '/') ||
|
|
|
|
memcmp(p->name, name, len))
|
|
|
|
break; /* not our subdirectory */
|
|
|
|
if (ce_stage(p) == stage)
|
|
|
|
/* p is at the same stage as our entry, and
|
|
|
|
* is a subdirectory of what we are looking
|
|
|
|
* at, so we cannot have conflicts at our
|
|
|
|
* level or anything shorter.
|
|
|
|
*/
|
|
|
|
return retval;
|
|
|
|
pos++;
|
2005-05-08 04:55:21 +00:00
|
|
|
}
|
2005-05-08 04:48:12 +00:00
|
|
|
}
|
2005-06-19 03:21:34 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We may be in a situation where we already have path/file and path
|
|
|
|
* is being added, or we already have path and path/file is being
|
|
|
|
* added. Either one would result in a nonsense tree that has path
|
|
|
|
* twice when git-write-tree tries to write it out. Prevent it.
|
|
|
|
*
|
|
|
|
* If ok-to-replace is specified, we remove the conflicting entries
|
|
|
|
* from the cache so the caller should recompute the insert position.
|
|
|
|
* When this happens, we return non-zero.
|
|
|
|
*/
|
|
|
|
static int check_file_directory_conflict(const struct cache_entry *ce, int pos, int ok_to_replace)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We check if the path is a sub-path of a subsequent pathname
|
|
|
|
* first, since removing those will not change the position
|
|
|
|
* in the array
|
|
|
|
*/
|
|
|
|
int retval = has_file_name(ce, pos, ok_to_replace);
|
|
|
|
/*
|
|
|
|
* Then check if the path might have a clashing sub-directory
|
|
|
|
* before it.
|
|
|
|
*/
|
|
|
|
return retval + has_dir_name(ce, pos, ok_to_replace);
|
2005-05-08 04:48:12 +00:00
|
|
|
}
|
|
|
|
|
2005-05-08 04:55:21 +00:00
|
|
|
int add_cache_entry(struct cache_entry *ce, int option)
|
2005-04-09 19:09:27 +00:00
|
|
|
{
|
|
|
|
int pos;
|
2005-05-08 04:55:21 +00:00
|
|
|
int ok_to_add = option & ADD_CACHE_OK_TO_ADD;
|
|
|
|
int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;
|
2005-06-25 09:25:29 +00:00
|
|
|
int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;
|
2006-02-09 05:15:24 +00:00
|
|
|
|
2005-06-07 20:35:56 +00:00
|
|
|
pos = cache_name_pos(ce->name, ntohs(ce->ce_flags));
|
2005-04-09 19:09:27 +00:00
|
|
|
|
2005-10-12 01:45:33 +00:00
|
|
|
/* existing match? Just replace it. */
|
2005-04-11 05:06:50 +00:00
|
|
|
if (pos >= 0) {
|
2005-05-06 23:48:43 +00:00
|
|
|
active_cache_changed = 1;
|
2005-04-11 05:06:50 +00:00
|
|
|
active_cache[pos] = ce;
|
2005-04-09 19:09:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-11 05:06:50 +00:00
|
|
|
pos = -pos-1;
|
2005-04-09 19:09:27 +00:00
|
|
|
|
2005-04-16 19:05:45 +00:00
|
|
|
/*
|
|
|
|
* Inserting a merged entry ("stage 0") into the index
|
|
|
|
* will always replace all non-merged entries..
|
|
|
|
*/
|
|
|
|
if (pos < active_nr && ce_stage(ce) == 0) {
|
2005-05-15 02:04:25 +00:00
|
|
|
while (ce_same_name(active_cache[pos], ce)) {
|
2005-04-16 19:05:45 +00:00
|
|
|
ok_to_add = 1;
|
2005-05-15 02:04:25 +00:00
|
|
|
if (!remove_cache_entry_at(pos))
|
2005-04-16 19:05:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-10 18:32:54 +00:00
|
|
|
if (!ok_to_add)
|
|
|
|
return -1;
|
|
|
|
|
2005-10-12 01:45:33 +00:00
|
|
|
if (!skip_df_check &&
|
|
|
|
check_file_directory_conflict(ce, pos, ok_to_replace)) {
|
2005-05-08 04:55:21 +00:00
|
|
|
if (!ok_to_replace)
|
|
|
|
return -1;
|
2005-06-07 20:35:56 +00:00
|
|
|
pos = cache_name_pos(ce->name, ntohs(ce->ce_flags));
|
2005-05-08 04:55:21 +00:00
|
|
|
pos = -pos-1;
|
|
|
|
}
|
2005-05-08 04:48:12 +00:00
|
|
|
|
2005-04-09 19:09:27 +00:00
|
|
|
/* Make sure the array is big enough .. */
|
|
|
|
if (active_nr == active_alloc) {
|
|
|
|
active_alloc = alloc_nr(active_alloc);
|
2005-04-26 19:00:58 +00:00
|
|
|
active_cache = xrealloc(active_cache, active_alloc * sizeof(struct cache_entry *));
|
2005-04-09 19:09:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Add it in.. */
|
|
|
|
active_nr++;
|
|
|
|
if (active_nr > pos)
|
|
|
|
memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce));
|
|
|
|
active_cache[pos] = ce;
|
2005-05-06 23:48:43 +00:00
|
|
|
active_cache_changed = 1;
|
2005-04-09 19:09:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
static int verify_hdr(struct cache_header *hdr, unsigned long size)
|
|
|
|
{
|
|
|
|
SHA_CTX c;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
2005-04-15 17:44:27 +00:00
|
|
|
if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
|
2005-04-07 22:13:13 +00:00
|
|
|
return error("bad signature");
|
2005-04-20 19:36:41 +00:00
|
|
|
if (hdr->hdr_version != htonl(2))
|
|
|
|
return error("bad index version");
|
2005-04-07 22:13:13 +00:00
|
|
|
SHA1_Init(&c);
|
2005-04-20 19:36:41 +00:00
|
|
|
SHA1_Update(&c, hdr, size - 20);
|
2005-04-07 22:13:13 +00:00
|
|
|
SHA1_Final(sha1, &c);
|
2005-04-20 19:36:41 +00:00
|
|
|
if (memcmp(sha1, (void *)hdr + size - 20, 20))
|
|
|
|
return error("bad index file sha1 signature");
|
2005-04-07 22:13:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int read_cache(void)
|
|
|
|
{
|
|
|
|
int fd, i;
|
|
|
|
struct stat st;
|
|
|
|
unsigned long size, offset;
|
|
|
|
void *map;
|
|
|
|
struct cache_header *hdr;
|
|
|
|
|
|
|
|
errno = EBUSY;
|
|
|
|
if (active_cache)
|
2005-10-01 20:24:27 +00:00
|
|
|
return active_nr;
|
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
errno = ENOENT;
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
index_file_timestamp = 0;
|
2005-04-21 17:55:18 +00:00
|
|
|
fd = open(get_index_file(), O_RDONLY);
|
2005-10-01 20:24:27 +00:00
|
|
|
if (fd < 0) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return 0;
|
|
|
|
die("index file open failed (%s)", strerror(errno));
|
|
|
|
}
|
2005-04-07 22:13:13 +00:00
|
|
|
|
2005-04-08 16:59:28 +00:00
|
|
|
size = 0; // avoid gcc warning
|
2005-07-29 14:49:14 +00:00
|
|
|
map = MAP_FAILED;
|
2005-04-07 22:13:13 +00:00
|
|
|
if (!fstat(fd, &st)) {
|
|
|
|
size = st.st_size;
|
|
|
|
errno = EINVAL;
|
2005-04-20 19:36:41 +00:00
|
|
|
if (size >= sizeof(struct cache_header) + 20)
|
2005-04-27 02:27:27 +00:00
|
|
|
map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|
|
|
|
close(fd);
|
2005-07-29 14:49:14 +00:00
|
|
|
if (map == MAP_FAILED)
|
2005-10-01 20:24:27 +00:00
|
|
|
die("index file mmap failed (%s)", strerror(errno));
|
2005-04-07 22:13:13 +00:00
|
|
|
|
|
|
|
hdr = map;
|
|
|
|
if (verify_hdr(hdr, size) < 0)
|
|
|
|
goto unmap;
|
|
|
|
|
2005-04-15 17:44:27 +00:00
|
|
|
active_nr = ntohl(hdr->hdr_entries);
|
2005-04-07 22:13:13 +00:00
|
|
|
active_alloc = alloc_nr(active_nr);
|
|
|
|
active_cache = calloc(active_alloc, sizeof(struct cache_entry *));
|
|
|
|
|
|
|
|
offset = sizeof(*hdr);
|
2005-04-15 17:44:27 +00:00
|
|
|
for (i = 0; i < active_nr; i++) {
|
2005-04-07 22:13:13 +00:00
|
|
|
struct cache_entry *ce = map + offset;
|
|
|
|
offset = offset + ce_size(ce);
|
|
|
|
active_cache[i] = ce;
|
|
|
|
}
|
Racy GIT
This fixes the longstanding "Racy GIT" problem, which was pretty
much there from the beginning of time, but was first
demonstrated by Pasky in this message on October 24, 2005:
http://marc.theaimsgroup.com/?l=git&m=113014629716878
If you run the following sequence of commands:
echo frotz >infocom
git update-index --add infocom
echo xyzzy >infocom
so that the second update to file "infocom" does not change
st_mtime, what is recorded as the stat information for the cache
entry "infocom" exactly matches what is on the filesystem
(owner, group, inum, mtime, ctime, mode, length). After this
sequence, we incorrectly think "infocom" file still has string
"frotz" in it, and get really confused. E.g. git-diff-files
would say there is no change, git-update-index --refresh would
not even look at the filesystem to correct the situation.
Some ways of working around this issue were already suggested by
Linus in the same thread on the same day, including waiting
until the next second before returning from update-index if a
cache entry written out has the current timestamp, but that
means we can make at most one commit per second, and given that
the e-mail patch workflow used by Linus needs to process at
least 5 commits per second, it is not an acceptable solution.
Linus notes that git-apply is primarily used to update the index
while processing e-mailed patches, which is true, and
git-apply's up-to-date check is fooled by the same problem but
luckily in the other direction, so it is not really a big issue,
but still it is disturbing.
The function ce_match_stat() is called to bypass the comparison
against filesystem data when the stat data recorded in the cache
entry matches what stat() returns from the filesystem. This
patch tackles the problem by changing it to actually go to the
filesystem data for cache entries that have the same mtime as
the index file itself. This works as long as the index file and
working tree files are on the filesystems that share the same
monotonic clock. Files on network mounted filesystems sometimes
get skewed timestamps compared to "date" output, but as long as
working tree files' timestamps are skewed the same way as the
index file's, this approach still works. The only problematic
files are the ones that have the same timestamp as the index
file's, because two file updates that sandwitch the index file
update must happen within the same second to trigger the
problem.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-12-20 08:02:15 +00:00
|
|
|
index_file_timestamp = st.st_mtime;
|
2005-04-07 22:13:13 +00:00
|
|
|
return active_nr;
|
|
|
|
|
|
|
|
unmap:
|
|
|
|
munmap(map, size);
|
|
|
|
errno = EINVAL;
|
2005-10-01 20:24:27 +00:00
|
|
|
die("index file corrupt");
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|
|
|
|
|
2005-04-20 19:16:57 +00:00
|
|
|
#define WRITE_BUFFER_SIZE 8192
|
2005-05-18 12:14:09 +00:00
|
|
|
static unsigned char write_buffer[WRITE_BUFFER_SIZE];
|
2005-04-20 19:16:57 +00:00
|
|
|
static unsigned long write_buffer_len;
|
|
|
|
|
2005-04-20 19:36:41 +00:00
|
|
|
static int ce_write(SHA_CTX *context, int fd, void *data, unsigned int len)
|
2005-04-20 19:16:57 +00:00
|
|
|
{
|
|
|
|
while (len) {
|
|
|
|
unsigned int buffered = write_buffer_len;
|
|
|
|
unsigned int partial = WRITE_BUFFER_SIZE - buffered;
|
|
|
|
if (partial > len)
|
|
|
|
partial = len;
|
|
|
|
memcpy(write_buffer + buffered, data, partial);
|
|
|
|
buffered += partial;
|
|
|
|
if (buffered == WRITE_BUFFER_SIZE) {
|
2005-04-20 19:36:41 +00:00
|
|
|
SHA1_Update(context, write_buffer, WRITE_BUFFER_SIZE);
|
2005-04-20 19:16:57 +00:00
|
|
|
if (write(fd, write_buffer, WRITE_BUFFER_SIZE) != WRITE_BUFFER_SIZE)
|
|
|
|
return -1;
|
|
|
|
buffered = 0;
|
|
|
|
}
|
|
|
|
write_buffer_len = buffered;
|
|
|
|
len -= partial;
|
|
|
|
data += partial;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-20 19:36:41 +00:00
|
|
|
static int ce_flush(SHA_CTX *context, int fd)
|
2005-04-20 19:16:57 +00:00
|
|
|
{
|
|
|
|
unsigned int left = write_buffer_len;
|
2005-04-20 19:36:41 +00:00
|
|
|
|
2005-04-20 19:16:57 +00:00
|
|
|
if (left) {
|
|
|
|
write_buffer_len = 0;
|
2005-04-20 19:36:41 +00:00
|
|
|
SHA1_Update(context, write_buffer, left);
|
2005-04-20 19:16:57 +00:00
|
|
|
}
|
2005-04-20 19:36:41 +00:00
|
|
|
|
2005-09-11 13:27:47 +00:00
|
|
|
/* Flush first if not enough space for SHA1 signature */
|
|
|
|
if (left + 20 > WRITE_BUFFER_SIZE) {
|
|
|
|
if (write(fd, write_buffer, left) != left)
|
|
|
|
return -1;
|
|
|
|
left = 0;
|
|
|
|
}
|
|
|
|
|
2005-04-20 19:36:41 +00:00
|
|
|
/* Append the SHA1 signature at the end */
|
|
|
|
SHA1_Final(write_buffer + left, context);
|
|
|
|
left += 20;
|
|
|
|
if (write(fd, write_buffer, left) != left)
|
|
|
|
return -1;
|
2005-04-20 19:16:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-20 20:12:18 +00:00
|
|
|
static void ce_smudge_racily_clean_entry(struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* The only thing we care about in this function is to smudge the
|
|
|
|
* falsely clean entry due to touch-update-touch race, so we leave
|
|
|
|
* everything else as they are. We are called for entries whose
|
|
|
|
* ce_mtime match the index file mtime.
|
|
|
|
*/
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (lstat(ce->name, &st) < 0)
|
|
|
|
return;
|
|
|
|
if (ce_match_stat_basic(ce, &st))
|
|
|
|
return;
|
|
|
|
if (ce_modified_check_fs(ce, &st)) {
|
2005-12-20 22:18:47 +00:00
|
|
|
/* This is "racily clean"; smudge it. Note that this
|
|
|
|
* is a tricky code. At first glance, it may appear
|
|
|
|
* that it can break with this sequence:
|
|
|
|
*
|
|
|
|
* $ echo xyzzy >frotz
|
|
|
|
* $ git-update-index --add frotz
|
|
|
|
* $ : >frotz
|
|
|
|
* $ sleep 3
|
|
|
|
* $ echo filfre >nitfol
|
|
|
|
* $ git-update-index --add nitfol
|
|
|
|
*
|
|
|
|
* but it does not. Whe the second update-index runs,
|
|
|
|
* it notices that the entry "frotz" has the same timestamp
|
|
|
|
* as index, and if we were to smudge it by resetting its
|
|
|
|
* size to zero here, then the object name recorded
|
|
|
|
* in index is the 6-byte file but the cached stat information
|
|
|
|
* becomes zero --- which would then match what we would
|
|
|
|
* obtain from the filesystem next time we stat("frotz").
|
|
|
|
*
|
|
|
|
* However, the second update-index, before calling
|
|
|
|
* this function, notices that the cached size is 6
|
|
|
|
* bytes and what is on the filesystem is an empty
|
|
|
|
* file, and never calls us, so the cached size information
|
|
|
|
* for "frotz" stays 6 which does not match the filesystem.
|
|
|
|
*/
|
2005-12-20 20:12:18 +00:00
|
|
|
ce->ce_size = htonl(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-09 19:09:27 +00:00
|
|
|
int write_cache(int newfd, struct cache_entry **cache, int entries)
|
|
|
|
{
|
|
|
|
SHA_CTX c;
|
|
|
|
struct cache_header hdr;
|
2005-06-10 08:32:37 +00:00
|
|
|
int i, removed;
|
|
|
|
|
|
|
|
for (i = removed = 0; i < entries; i++)
|
|
|
|
if (!cache[i]->ce_mode)
|
|
|
|
removed++;
|
2005-04-09 19:09:27 +00:00
|
|
|
|
2005-04-15 17:44:27 +00:00
|
|
|
hdr.hdr_signature = htonl(CACHE_SIGNATURE);
|
2005-04-20 19:36:41 +00:00
|
|
|
hdr.hdr_version = htonl(2);
|
2005-06-10 08:32:37 +00:00
|
|
|
hdr.hdr_entries = htonl(entries - removed);
|
2005-04-09 19:09:27 +00:00
|
|
|
|
|
|
|
SHA1_Init(&c);
|
2005-04-20 19:36:41 +00:00
|
|
|
if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0)
|
2005-04-09 19:09:27 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
|
|
struct cache_entry *ce = cache[i];
|
2005-06-09 22:34:04 +00:00
|
|
|
if (!ce->ce_mode)
|
|
|
|
continue;
|
2005-12-20 20:12:18 +00:00
|
|
|
if (index_file_timestamp &&
|
|
|
|
index_file_timestamp <= ntohl(ce->ce_mtime.sec))
|
|
|
|
ce_smudge_racily_clean_entry(ce);
|
2005-04-20 19:36:41 +00:00
|
|
|
if (ce_write(&c, newfd, ce, ce_size(ce)) < 0)
|
2005-04-09 19:09:27 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2005-04-20 19:36:41 +00:00
|
|
|
return ce_flush(&c, newfd);
|
2005-04-09 19:09:27 +00:00
|
|
|
}
|