2005-04-08 02:16:10 +04:00
|
|
|
/*
|
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
#define NO_THE_INDEX_COMPATIBILITY_MACROS
|
2005-04-08 02:13:13 +04:00
|
|
|
#include "cache.h"
|
2006-04-25 08:18:58 +04:00
|
|
|
#include "cache-tree.h"
|
2007-04-10 08:20:29 +04:00
|
|
|
#include "refs.h"
|
2007-08-12 01:59:01 +04:00
|
|
|
#include "dir.h"
|
2006-04-25 08:18:58 +04:00
|
|
|
|
|
|
|
|
/* Index extensions.
|
|
|
|
|
*
|
|
|
|
|
* The first letter should be 'A'..'Z' for extensions that are not
|
|
|
|
|
* necessary for a correct operation (i.e. optimization data).
|
|
|
|
|
* When new extensions are added that _needs_ to be understood in
|
|
|
|
|
* order to correctly interpret the index file, pick character that
|
|
|
|
|
* is outside the range, to cause the reader to abort.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) )
|
|
|
|
|
#define CACHE_EXT_TREE 0x54524545 /* "TREE" */
|
2005-04-08 02:13:13 +04:00
|
|
|
|
2007-04-02 05:14:06 +04:00
|
|
|
struct index_state the_index;
|
2006-07-26 08:32:18 +04:00
|
|
|
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
static unsigned int hash_name(const char *name, int namelen)
|
|
|
|
|
{
|
|
|
|
|
unsigned int hash = 0x123;
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
unsigned char c = *name++;
|
|
|
|
|
hash = hash*101 + c;
|
|
|
|
|
} while (--namelen);
|
|
|
|
|
return hash;
|
|
|
|
|
}
|
|
|
|
|
|
2008-01-23 10:01:13 +03:00
|
|
|
static void hash_index_entry(struct index_state *istate, struct cache_entry *ce)
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
{
|
|
|
|
|
void **pos;
|
|
|
|
|
unsigned int hash = hash_name(ce->name, ce_namelen(ce));
|
|
|
|
|
|
|
|
|
|
pos = insert_hash(hash, ce, &istate->name_hash);
|
|
|
|
|
if (pos) {
|
|
|
|
|
ce->next = *pos;
|
|
|
|
|
*pos = ce;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-01-23 10:01:13 +03:00
|
|
|
static void lazy_init_name_hash(struct index_state *istate)
|
|
|
|
|
{
|
|
|
|
|
int nr;
|
|
|
|
|
|
|
|
|
|
if (istate->name_hash_initialized)
|
|
|
|
|
return;
|
|
|
|
|
for (nr = 0; nr < istate->cache_nr; nr++)
|
|
|
|
|
hash_index_entry(istate, istate->cache[nr]);
|
|
|
|
|
istate->name_hash_initialized = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
istate->cache[nr] = ce;
|
|
|
|
|
if (istate->name_hash_initialized)
|
|
|
|
|
hash_index_entry(istate, ce);
|
|
|
|
|
}
|
|
|
|
|
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
/*
|
|
|
|
|
* We don't actually *remove* it, we can just mark it invalid so that
|
|
|
|
|
* we won't find it in lookups.
|
|
|
|
|
*
|
|
|
|
|
* Not only would we have to search the lists (simple enough), but
|
|
|
|
|
* we'd also have to rehash other hash buckets in case this makes the
|
|
|
|
|
* hash bucket empty (common). So it's much better to just mark
|
|
|
|
|
* it.
|
|
|
|
|
*/
|
|
|
|
|
static void remove_hash_entry(struct index_state *istate, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
ce->ce_flags |= CE_UNHASHED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void replace_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
struct cache_entry *old = istate->cache[nr];
|
|
|
|
|
|
|
|
|
|
if (ce != old) {
|
|
|
|
|
remove_hash_entry(istate, old);
|
|
|
|
|
set_index_entry(istate, nr, ce);
|
|
|
|
|
}
|
|
|
|
|
istate->cache_changed = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int index_name_exists(struct index_state *istate, const char *name, int namelen)
|
|
|
|
|
{
|
|
|
|
|
unsigned int hash = hash_name(name, namelen);
|
2008-01-23 10:01:13 +03:00
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
|
|
lazy_init_name_hash(istate);
|
|
|
|
|
ce = lookup_hash(hash, &istate->name_hash);
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
|
|
|
|
|
while (ce) {
|
|
|
|
|
if (!(ce->ce_flags & CE_UNHASHED)) {
|
|
|
|
|
if (!cache_name_compare(name, namelen, ce->name, ce->ce_flags))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
ce = ce->next;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-16 01:23:12 +04: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)
|
|
|
|
|
{
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_ctime = st->st_ctime;
|
|
|
|
|
ce->ce_mtime = st->st_mtime;
|
|
|
|
|
ce->ce_dev = st->st_dev;
|
|
|
|
|
ce->ce_ino = st->st_ino;
|
|
|
|
|
ce->ce_uid = st->st_uid;
|
|
|
|
|
ce->ce_gid = st->st_gid;
|
|
|
|
|
ce->ce_size = st->st_size;
|
2006-02-09 08:15:24 +03:00
|
|
|
|
|
|
|
|
if (assume_unchanged)
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_flags |= CE_VALID;
|
2008-01-19 10:45:24 +03:00
|
|
|
|
|
|
|
|
if (S_ISREG(st->st_mode))
|
|
|
|
|
ce_mark_uptodate(ce);
|
2005-05-16 01:23:12 +04: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 11:02:15 +03: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];
|
2007-02-28 22:52:04 +03:00
|
|
|
if (!index_fd(sha1, fd, st, 0, OBJ_BLOB, ce->name))
|
2006-08-17 22:54:57 +04:00
|
|
|
match = hashcmp(sha1, ce->sha1);
|
2006-07-31 20:55:15 +04:00
|
|
|
/* index_fd() closed the file descriptor already */
|
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 11:02:15 +03:00
|
|
|
}
|
|
|
|
|
return match;
|
|
|
|
|
}
|
|
|
|
|
|
2007-03-07 04:44:37 +03:00
|
|
|
static int ce_compare_link(struct cache_entry *ce, size_t expected_size)
|
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 11:02:15 +03:00
|
|
|
{
|
|
|
|
|
int match = -1;
|
|
|
|
|
char *target;
|
|
|
|
|
void *buffer;
|
|
|
|
|
unsigned long size;
|
2007-02-26 22:55:59 +03:00
|
|
|
enum object_type type;
|
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 11:02:15 +03:00
|
|
|
int len;
|
|
|
|
|
|
|
|
|
|
target = xmalloc(expected_size);
|
|
|
|
|
len = readlink(ce->name, target, expected_size);
|
|
|
|
|
if (len != expected_size) {
|
|
|
|
|
free(target);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2007-02-26 22:55:59 +03:00
|
|
|
buffer = read_sha1_file(ce->sha1, &type, &size);
|
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 11:02:15 +03:00
|
|
|
if (!buffer) {
|
|
|
|
|
free(target);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
if (size == expected_size)
|
|
|
|
|
match = memcmp(buffer, target, size);
|
|
|
|
|
free(buffer);
|
|
|
|
|
free(target);
|
|
|
|
|
return match;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-10 08:20:29 +04:00
|
|
|
static int ce_compare_gitlink(struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We don't actually require that the .git directory
|
2007-05-22 00:08:28 +04:00
|
|
|
* under GITLINK directory be a valid git directory. It
|
2007-04-10 08:20:29 +04:00
|
|
|
* might even be missing (in case nobody populated that
|
|
|
|
|
* sub-project).
|
|
|
|
|
*
|
|
|
|
|
* If so, we consider it always to match.
|
|
|
|
|
*/
|
|
|
|
|
if (resolve_gitlink_ref(ce->name, "HEAD", sha1) < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
return hashcmp(sha1, ce->sha1);
|
|
|
|
|
}
|
|
|
|
|
|
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 11:02:15 +03:00
|
|
|
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:
|
2007-03-07 04:44:37 +03:00
|
|
|
if (ce_compare_link(ce, xsize_t(st->st_size)))
|
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 11:02:15 +03:00
|
|
|
return DATA_CHANGED;
|
|
|
|
|
break;
|
2007-04-13 20:24:13 +04:00
|
|
|
case S_IFDIR:
|
2008-01-15 03:03:17 +03:00
|
|
|
if (S_ISGITLINK(ce->ce_mode))
|
2007-04-13 20:24:13 +04:00
|
|
|
return 0;
|
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 11:02:15 +03:00
|
|
|
default:
|
|
|
|
|
return TYPE_CHANGED;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-12-20 23:12:18 +03:00
|
|
|
static int ce_match_stat_basic(struct cache_entry *ce, struct stat *st)
|
2005-04-09 20:48:20 +04:00
|
|
|
{
|
|
|
|
|
unsigned int changed = 0;
|
|
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
|
|
|
|
return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED;
|
|
|
|
|
|
|
|
|
|
switch (ce->ce_mode & S_IFMT) {
|
2005-05-05 16:38:25 +04:00
|
|
|
case S_IFREG:
|
|
|
|
|
changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0;
|
2005-10-12 05:45:33 +04:00
|
|
|
/* We consider only the owner x bit to be relevant for
|
|
|
|
|
* "mode changes"
|
|
|
|
|
*/
|
|
|
|
|
if (trust_executable_bit &&
|
2008-01-15 03:03:17 +03:00
|
|
|
(0100 & (ce->ce_mode ^ st->st_mode)))
|
2005-05-06 17:45:01 +04:00
|
|
|
changed |= MODE_CHANGED;
|
2005-05-05 16:38:25 +04:00
|
|
|
break;
|
|
|
|
|
case S_IFLNK:
|
2007-03-03 00:11:30 +03:00
|
|
|
if (!S_ISLNK(st->st_mode) &&
|
|
|
|
|
(has_symlinks || !S_ISREG(st->st_mode)))
|
|
|
|
|
changed |= TYPE_CHANGED;
|
2005-05-05 16:38:25 +04:00
|
|
|
break;
|
2007-05-22 00:08:28 +04:00
|
|
|
case S_IFGITLINK:
|
2007-04-10 08:20:29 +04:00
|
|
|
if (!S_ISDIR(st->st_mode))
|
|
|
|
|
changed |= TYPE_CHANGED;
|
|
|
|
|
else if (ce_compare_gitlink(ce))
|
|
|
|
|
changed |= DATA_CHANGED;
|
2007-04-13 20:24:13 +04:00
|
|
|
return changed;
|
2005-05-05 16:38:25 +04:00
|
|
|
default:
|
2008-01-15 03:03:17 +03:00
|
|
|
die("internal error: ce_mode is %o", ce->ce_mode);
|
2005-05-05 16:38:25 +04:00
|
|
|
}
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_mtime != (unsigned int) st->st_mtime)
|
2005-04-15 21:44:27 +04:00
|
|
|
changed |= MTIME_CHANGED;
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_ctime != (unsigned int) st->st_ctime)
|
2005-04-09 20:48:20 +04:00
|
|
|
changed |= CTIME_CHANGED;
|
2005-04-15 21:44:27 +04:00
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_uid != (unsigned int) st->st_uid ||
|
|
|
|
|
ce->ce_gid != (unsigned int) st->st_gid)
|
2005-04-09 20:48:20 +04:00
|
|
|
changed |= OWNER_CHANGED;
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_ino != (unsigned int) st->st_ino)
|
2005-04-09 20:48:20 +04:00
|
|
|
changed |= INODE_CHANGED;
|
2005-05-23 02:08:15 +04:00
|
|
|
|
|
|
|
|
#ifdef USE_STDEV
|
|
|
|
|
/*
|
|
|
|
|
* st_dev breaks on network filesystems where different
|
|
|
|
|
* clients will have different views of what "device"
|
|
|
|
|
* the filesystem is on
|
|
|
|
|
*/
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_dev != (unsigned int) st->st_dev)
|
2005-05-23 02:08:15 +04:00
|
|
|
changed |= INODE_CHANGED;
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_size != (unsigned int) st->st_size)
|
2005-04-09 20:48:20 +04:00
|
|
|
changed |= DATA_CHANGED;
|
2005-09-20 02:11:15 +04:00
|
|
|
|
2005-12-20 23:12:18 +03:00
|
|
|
return changed;
|
|
|
|
|
}
|
|
|
|
|
|
2008-01-21 11:44:50 +03:00
|
|
|
static int is_racy_timestamp(struct index_state *istate, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
return (istate->timestamp &&
|
|
|
|
|
((unsigned int)istate->timestamp) <= ce->ce_mtime);
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int ie_match_stat(struct index_state *istate,
|
2007-11-10 11:15:03 +03:00
|
|
|
struct cache_entry *ce, struct stat *st,
|
|
|
|
|
unsigned int options)
|
2005-12-20 23:12:18 +03:00
|
|
|
{
|
2006-02-09 08:15:24 +03:00
|
|
|
unsigned int changed;
|
2007-11-10 11:15:03 +03:00
|
|
|
int ignore_valid = options & CE_MATCH_IGNORE_VALID;
|
|
|
|
|
int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY;
|
2006-02-09 08:15:24 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If it's marked as always valid in the index, it's
|
|
|
|
|
* valid whatever the checked-out copy says.
|
|
|
|
|
*/
|
2008-01-15 03:03:17 +03:00
|
|
|
if (!ignore_valid && (ce->ce_flags & CE_VALID))
|
2006-02-09 08:15:24 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
changed = ce_match_stat_basic(ce, st);
|
2005-12-20 23:12:18 +03: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 11:02:15 +03: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 08:15:24 +03: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 11:02:15 +03:00
|
|
|
*/
|
2008-01-21 11:44:50 +03:00
|
|
|
if (!changed && is_racy_timestamp(istate, ce)) {
|
2006-08-16 08:38:07 +04:00
|
|
|
if (assume_racy_is_modified)
|
|
|
|
|
changed |= DATA_CHANGED;
|
|
|
|
|
else
|
|
|
|
|
changed |= ce_modified_check_fs(ce, st);
|
|
|
|
|
}
|
2005-09-20 02:11:15 +04: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 11:02:15 +03:00
|
|
|
return changed;
|
2005-09-20 02:11:15 +04:00
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int ie_modified(struct index_state *istate,
|
2007-11-10 11:15:03 +03:00
|
|
|
struct cache_entry *ce, struct stat *st, unsigned int options)
|
2005-09-20 02:11:15 +04: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 11:02:15 +03:00
|
|
|
int changed, changed_fs;
|
2007-11-10 11:15:03 +03:00
|
|
|
|
|
|
|
|
changed = ie_match_stat(istate, ce, st, options);
|
2005-09-20 02:11:15 +04: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.
|
|
|
|
|
*/
|
2008-01-15 03:03:17 +03:00
|
|
|
if ((changed & DATA_CHANGED) && ce->ce_size != 0)
|
2005-09-20 02:11:15 +04:00
|
|
|
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 11:02:15 +03:00
|
|
|
changed_fs = ce_modified_check_fs(ce, st);
|
|
|
|
|
if (changed_fs)
|
|
|
|
|
return changed | changed_fs;
|
2005-09-20 02:11:15 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-20 20:09:18 +04: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];
|
Fix thinko in subproject entry sorting
This fixes a total thinko in my original series: subprojects do *not* sort
like directories, because the index is sorted purely by full pathname, and
since a subproject shows up in the index as a normal NUL-terminated
string, it never has the issues with sorting with the '/' at the end.
So if you have a subproject "proj" and a file "proj.c", the subproject
sorts alphabetically before the file in the index (and must thus also sort
that way in a tree object, since trees sort as the index).
In contrast, it you have two files "proj/file" and "proj.c", the "proj.c"
will sort alphabetically before "proj/file" in the index. The index
itself, of course, does not actually contain an entry "proj/", but in the
*tree* that gets written out, the tree entry "proj" will sort after the
file entry "proj.c", which is the only real magic sorting rule.
In other words: the magic sorting rule only affects tree entries, and
*only* affects tree entries that point to other trees (ie are of the type
S_IFDIR).
Anyway, that thinko just means that we should remove the special case to
make S_ISDIRLNK entries sort like S_ISDIR entries. They don't. They sort
like normal files.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-12 01:39:12 +04:00
|
|
|
if (!c1 && S_ISDIR(mode1))
|
2005-05-20 20:09:18 +04:00
|
|
|
c1 = '/';
|
Fix thinko in subproject entry sorting
This fixes a total thinko in my original series: subprojects do *not* sort
like directories, because the index is sorted purely by full pathname, and
since a subproject shows up in the index as a normal NUL-terminated
string, it never has the issues with sorting with the '/' at the end.
So if you have a subproject "proj" and a file "proj.c", the subproject
sorts alphabetically before the file in the index (and must thus also sort
that way in a tree object, since trees sort as the index).
In contrast, it you have two files "proj/file" and "proj.c", the "proj.c"
will sort alphabetically before "proj/file" in the index. The index
itself, of course, does not actually contain an entry "proj/", but in the
*tree* that gets written out, the tree entry "proj" will sort after the
file entry "proj.c", which is the only real magic sorting rule.
In other words: the magic sorting rule only affects tree entries, and
*only* affects tree entries that point to other trees (ie are of the type
S_IFDIR).
Anyway, that thinko just means that we should remove the special case to
make S_ISDIRLNK entries sort like S_ISDIR entries. They don't. They sort
like normal files.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-12 01:39:12 +04:00
|
|
|
if (!c2 && S_ISDIR(mode2))
|
2005-05-20 20:09:18 +04:00
|
|
|
c2 = '/';
|
|
|
|
|
return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 09:51:44 +04:00
|
|
|
int cache_name_compare(const char *name1, int flags1, const char *name2, int flags2)
|
2005-04-09 20:26:55 +04:00
|
|
|
{
|
2005-04-16 09:51:44 +04:00
|
|
|
int len1 = flags1 & CE_NAMEMASK;
|
|
|
|
|
int len2 = flags2 & CE_NAMEMASK;
|
2005-04-09 20:26:55 +04: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 08:15:24 +03:00
|
|
|
|
2006-02-13 10:46:25 +03:00
|
|
|
/* Compare stages */
|
|
|
|
|
flags1 &= CE_STAGEMASK;
|
|
|
|
|
flags2 &= CE_STAGEMASK;
|
2006-02-09 08:15:24 +03:00
|
|
|
|
2005-04-16 09:51:44 +04:00
|
|
|
if (flags1 < flags2)
|
|
|
|
|
return -1;
|
|
|
|
|
if (flags1 > flags2)
|
|
|
|
|
return 1;
|
2005-04-09 20:26:55 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int index_name_pos(struct index_state *istate, const char *name, int namelen)
|
2005-04-09 20:26:55 +04:00
|
|
|
{
|
|
|
|
|
int first, last;
|
|
|
|
|
|
|
|
|
|
first = 0;
|
2007-04-02 10:26:07 +04:00
|
|
|
last = istate->cache_nr;
|
2005-04-09 20:26:55 +04:00
|
|
|
while (last > first) {
|
|
|
|
|
int next = (last + first) >> 1;
|
2007-04-02 10:26:07 +04:00
|
|
|
struct cache_entry *ce = istate->cache[next];
|
2008-01-15 03:03:17 +03:00
|
|
|
int cmp = cache_name_compare(name, namelen, ce->name, ce->ce_flags);
|
2005-04-09 20:26:55 +04:00
|
|
|
if (!cmp)
|
2005-04-11 09:06:50 +04:00
|
|
|
return next;
|
2005-04-09 20:26:55 +04:00
|
|
|
if (cmp < 0) {
|
|
|
|
|
last = next;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
first = next+1;
|
|
|
|
|
}
|
2005-04-11 09:06:50 +04:00
|
|
|
return -first-1;
|
2005-04-09 20:26:55 +04:00
|
|
|
}
|
|
|
|
|
|
2005-04-16 23:05:45 +04:00
|
|
|
/* Remove entry, return true if there are more entries to go.. */
|
2007-04-02 10:26:07 +04:00
|
|
|
int remove_index_entry_at(struct index_state *istate, int pos)
|
2005-04-16 23:05:45 +04:00
|
|
|
{
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
struct cache_entry *ce = istate->cache[pos];
|
|
|
|
|
|
|
|
|
|
remove_hash_entry(istate, ce);
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->cache_changed = 1;
|
|
|
|
|
istate->cache_nr--;
|
|
|
|
|
if (pos >= istate->cache_nr)
|
2005-04-16 23:05:45 +04:00
|
|
|
return 0;
|
2007-04-02 10:26:07 +04:00
|
|
|
memmove(istate->cache + pos,
|
|
|
|
|
istate->cache + pos + 1,
|
|
|
|
|
(istate->cache_nr - pos) * sizeof(struct cache_entry *));
|
2005-04-16 23:05:45 +04:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int remove_file_from_index(struct index_state *istate, const char *path)
|
2005-04-09 23:09:27 +04:00
|
|
|
{
|
2007-04-02 10:26:07 +04:00
|
|
|
int pos = index_name_pos(istate, path, strlen(path));
|
2005-04-17 20:53:35 +04:00
|
|
|
if (pos < 0)
|
|
|
|
|
pos = -pos-1;
|
2007-09-14 07:33:11 +04:00
|
|
|
cache_tree_invalidate_path(istate->cache_tree, path);
|
2007-04-02 10:26:07 +04:00
|
|
|
while (pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path))
|
|
|
|
|
remove_index_entry_at(istate, pos);
|
2005-04-09 23:09:27 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-06-29 21:32:46 +04:00
|
|
|
static int compare_name(struct cache_entry *ce, const char *path, int namelen)
|
|
|
|
|
{
|
|
|
|
|
return namelen != ce_namelen(ce) || memcmp(path, ce->name, namelen);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int index_name_pos_also_unmerged(struct index_state *istate,
|
|
|
|
|
const char *path, int namelen)
|
|
|
|
|
{
|
|
|
|
|
int pos = index_name_pos(istate, path, namelen);
|
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
|
|
if (pos >= 0)
|
|
|
|
|
return pos;
|
|
|
|
|
|
|
|
|
|
/* maybe unmerged? */
|
|
|
|
|
pos = -1 - pos;
|
|
|
|
|
if (pos >= istate->cache_nr ||
|
|
|
|
|
compare_name((ce = istate->cache[pos]), path, namelen))
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/* order of preference: stage 2, 1, 3 */
|
|
|
|
|
if (ce_stage(ce) == 1 && pos + 1 < istate->cache_nr &&
|
|
|
|
|
ce_stage((ce = istate->cache[pos + 1])) == 2 &&
|
|
|
|
|
!compare_name(ce, path, namelen))
|
|
|
|
|
pos++;
|
|
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int add_file_to_index(struct index_state *istate, const char *path, int verbose)
|
2006-07-26 05:52:35 +04:00
|
|
|
{
|
2007-07-31 04:12:58 +04:00
|
|
|
int size, namelen, pos;
|
2006-07-26 05:52:35 +04:00
|
|
|
struct stat st;
|
|
|
|
|
struct cache_entry *ce;
|
git-add: make the entry stat-clean after re-adding the same contents
Earlier in commit 0781b8a9b2fe760fc4ed519a3a26e4b9bd6ccffe
(add_file_to_index: skip rehashing if the cached stat already
matches), add_file_to_index() were taught not to re-add the path
if it already matches the index.
The change meant well, but was not executed quite right. It
used ie_modified() to see if the file on the work tree is really
different from the index, and skipped adding the contents if the
function says "not modified".
This was wrong. There are three possible comparison results
between the index and the file in the work tree:
- with lstat(2) we _know_ they are different. E.g. if the
length or the owner in the cached stat information is
different from the length we just obtained from lstat(2), we
can tell the file is modified without looking at the actual
contents.
- with lstat(2) we _know_ they are the same. The same length,
the same owner, the same everything (but this has a twist, as
described below).
- we cannot tell from lstat(2) information alone and need to go
to the filesystem to actually compare.
The last case arises from what we call 'racy git' situation,
that can be caused with this sequence:
$ echo hello >file
$ git add file
$ echo aeiou >file ;# the same length
If the second "echo" is done within the same filesystem
timestamp granularity as the first "echo", then the timestamp
recorded by "git add" and the timestamp we get from lstat(2)
will be the same, and we can mistakenly say the file is not
modified. The path is called 'racily clean'. We need to
reliably detect racily clean paths are in fact modified.
To solve this problem, when we write out the index, we mark the
index entry that has the same timestamp as the index file itself
(that is the time from the point of view of the filesystem) to
tell any later code that does the lstat(2) comparison not to
trust the cached stat info, and ie_modified() then actually goes
to the filesystem to compare the contents for such a path.
That's all good, but it should not be used for this "git add"
optimization, as the goal of "git add" is to actually update the
path in the index and make it stat-clean. With the false
optimization, we did _not_ cause any data loss (after all, what
we failed to do was only to update the cached stat information),
but it made the following sequence leave the file stat dirty:
$ echo hello >file
$ git add file
$ echo hello >file ;# the same contents
$ git add file
The solution is not to use ie_modified() which goes to the
filesystem to see if it is really clean, but instead use
ie_match_stat() with "assume racily clean paths are dirty"
option, to force re-adding of such a path.
There was another problem with "git add -u". The codepath
shares the same issue when adding the paths that are found to be
modified, but in addition, it asked "git diff-files" machinery
run_diff_files() function (which is "git diff-files") to list
the paths that are modified. But "git diff-files" machinery
uses the same ie_modified() call so that it does not report
racily clean _and_ actually clean paths as modified, which is
not what we want.
The patch allows the callers of run_diff_files() to pass the
same "assume racily clean paths are dirty" option, and makes
"git-add -u" codepath to use that option, to discover and re-add
racily clean _and_ actually clean paths.
We could further optimize on top of this patch to differentiate
the case where the path really needs re-adding (i.e. the content
of the racily clean entry was indeed different) and the case
where only the cached stat information needs to be refreshed
(i.e. the racily clean entry was actually clean), but I do not
think it is worth it.
This patch applies to maint and all the way up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-10 05:22:52 +03:00
|
|
|
unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_RACY_IS_DIRTY;
|
2006-07-26 05:52:35 +04:00
|
|
|
|
|
|
|
|
if (lstat(path, &st))
|
|
|
|
|
die("%s: unable to stat (%s)", path, strerror(errno));
|
|
|
|
|
|
2007-04-10 08:20:29 +04:00
|
|
|
if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode) && !S_ISDIR(st.st_mode))
|
|
|
|
|
die("%s: can only add regular files, symbolic links or git-directories", path);
|
2006-07-26 05:52:35 +04:00
|
|
|
|
|
|
|
|
namelen = strlen(path);
|
2007-04-12 01:49:44 +04:00
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
|
while (namelen && path[namelen-1] == '/')
|
|
|
|
|
namelen--;
|
|
|
|
|
}
|
2006-07-26 05:52:35 +04:00
|
|
|
size = cache_entry_size(namelen);
|
|
|
|
|
ce = xcalloc(1, size);
|
|
|
|
|
memcpy(ce->name, path, namelen);
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_flags = namelen;
|
2006-07-26 05:52:35 +04:00
|
|
|
fill_stat_cache_info(ce, &st);
|
|
|
|
|
|
2007-03-03 00:11:30 +03:00
|
|
|
if (trust_executable_bit && has_symlinks)
|
2007-02-17 09:43:48 +03:00
|
|
|
ce->ce_mode = create_ce_mode(st.st_mode);
|
|
|
|
|
else {
|
2007-03-03 00:11:30 +03:00
|
|
|
/* If there is an existing entry, pick the mode bits and type
|
|
|
|
|
* from it, otherwise assume unexecutable regular file.
|
2006-07-26 05:52:35 +04:00
|
|
|
*/
|
2007-02-17 09:43:48 +03:00
|
|
|
struct cache_entry *ent;
|
2007-06-29 21:32:46 +04:00
|
|
|
int pos = index_name_pos_also_unmerged(istate, path, namelen);
|
2007-02-17 09:43:48 +03:00
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
ent = (0 <= pos) ? istate->cache[pos] : NULL;
|
2007-02-17 09:43:48 +03:00
|
|
|
ce->ce_mode = ce_mode_from_stat(ent, st.st_mode);
|
2006-07-26 05:52:35 +04:00
|
|
|
}
|
|
|
|
|
|
2007-07-31 04:12:58 +04:00
|
|
|
pos = index_name_pos(istate, ce->name, namelen);
|
|
|
|
|
if (0 <= pos &&
|
|
|
|
|
!ce_stage(istate->cache[pos]) &&
|
git-add: make the entry stat-clean after re-adding the same contents
Earlier in commit 0781b8a9b2fe760fc4ed519a3a26e4b9bd6ccffe
(add_file_to_index: skip rehashing if the cached stat already
matches), add_file_to_index() were taught not to re-add the path
if it already matches the index.
The change meant well, but was not executed quite right. It
used ie_modified() to see if the file on the work tree is really
different from the index, and skipped adding the contents if the
function says "not modified".
This was wrong. There are three possible comparison results
between the index and the file in the work tree:
- with lstat(2) we _know_ they are different. E.g. if the
length or the owner in the cached stat information is
different from the length we just obtained from lstat(2), we
can tell the file is modified without looking at the actual
contents.
- with lstat(2) we _know_ they are the same. The same length,
the same owner, the same everything (but this has a twist, as
described below).
- we cannot tell from lstat(2) information alone and need to go
to the filesystem to actually compare.
The last case arises from what we call 'racy git' situation,
that can be caused with this sequence:
$ echo hello >file
$ git add file
$ echo aeiou >file ;# the same length
If the second "echo" is done within the same filesystem
timestamp granularity as the first "echo", then the timestamp
recorded by "git add" and the timestamp we get from lstat(2)
will be the same, and we can mistakenly say the file is not
modified. The path is called 'racily clean'. We need to
reliably detect racily clean paths are in fact modified.
To solve this problem, when we write out the index, we mark the
index entry that has the same timestamp as the index file itself
(that is the time from the point of view of the filesystem) to
tell any later code that does the lstat(2) comparison not to
trust the cached stat info, and ie_modified() then actually goes
to the filesystem to compare the contents for such a path.
That's all good, but it should not be used for this "git add"
optimization, as the goal of "git add" is to actually update the
path in the index and make it stat-clean. With the false
optimization, we did _not_ cause any data loss (after all, what
we failed to do was only to update the cached stat information),
but it made the following sequence leave the file stat dirty:
$ echo hello >file
$ git add file
$ echo hello >file ;# the same contents
$ git add file
The solution is not to use ie_modified() which goes to the
filesystem to see if it is really clean, but instead use
ie_match_stat() with "assume racily clean paths are dirty"
option, to force re-adding of such a path.
There was another problem with "git add -u". The codepath
shares the same issue when adding the paths that are found to be
modified, but in addition, it asked "git diff-files" machinery
run_diff_files() function (which is "git diff-files") to list
the paths that are modified. But "git diff-files" machinery
uses the same ie_modified() call so that it does not report
racily clean _and_ actually clean paths as modified, which is
not what we want.
The patch allows the callers of run_diff_files() to pass the
same "assume racily clean paths are dirty" option, and makes
"git-add -u" codepath to use that option, to discover and re-add
racily clean _and_ actually clean paths.
We could further optimize on top of this patch to differentiate
the case where the path really needs re-adding (i.e. the content
of the racily clean entry was indeed different) and the case
where only the cached stat information needs to be refreshed
(i.e. the racily clean entry was actually clean), but I do not
think it is worth it.
This patch applies to maint and all the way up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-10 05:22:52 +03:00
|
|
|
!ie_match_stat(istate, istate->cache[pos], &st, ce_option)) {
|
2007-07-31 04:12:58 +04:00
|
|
|
/* Nothing changed, really */
|
|
|
|
|
free(ce);
|
2008-01-19 10:45:24 +03:00
|
|
|
ce_mark_uptodate(istate->cache[pos]);
|
2007-07-31 04:12:58 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-07-26 05:52:35 +04:00
|
|
|
if (index_path(ce->sha1, path, &st, 1))
|
|
|
|
|
die("unable to index file %s", path);
|
2007-04-02 10:26:07 +04:00
|
|
|
if (add_index_entry(istate, ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE))
|
2006-07-26 05:52:35 +04:00
|
|
|
die("unable to add %s to index",path);
|
|
|
|
|
if (verbose)
|
|
|
|
|
printf("add '%s'\n", path);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-09-11 07:17:28 +04:00
|
|
|
struct cache_entry *make_cache_entry(unsigned int mode,
|
|
|
|
|
const unsigned char *sha1, const char *path, int stage,
|
|
|
|
|
int refresh)
|
|
|
|
|
{
|
|
|
|
|
int size, len;
|
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
|
|
if (!verify_path(path))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
len = strlen(path);
|
|
|
|
|
size = cache_entry_size(len);
|
|
|
|
|
ce = xcalloc(1, size);
|
|
|
|
|
|
|
|
|
|
hashcpy(ce->sha1, sha1);
|
|
|
|
|
memcpy(ce->name, path, len);
|
|
|
|
|
ce->ce_flags = create_ce_flags(len, stage);
|
|
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
|
|
|
|
|
|
|
|
|
if (refresh)
|
|
|
|
|
return refresh_cache_entry(ce, 0);
|
|
|
|
|
|
|
|
|
|
return ce;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-15 06:04:25 +04:00
|
|
|
int ce_same_name(struct cache_entry *a, struct cache_entry *b)
|
2005-04-16 23:05:45 +04:00
|
|
|
{
|
|
|
|
|
int len = ce_namelen(a);
|
|
|
|
|
return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
|
|
|
|
|
}
|
|
|
|
|
|
2005-07-15 03:55:06 +04: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 07:44:32 +04:00
|
|
|
if (!matchlen)
|
|
|
|
|
return 1;
|
2005-07-15 03:55:06 +04:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-18 23:07:31 +04:00
|
|
|
/*
|
|
|
|
|
* We fundamentally don't like some paths: we don't want
|
|
|
|
|
* dot or dot-dot anywhere, and for obvious reasons don't
|
|
|
|
|
* want to recurse into ".git" either.
|
|
|
|
|
*
|
|
|
|
|
* Also, we don't want double slashes or slashes at the
|
|
|
|
|
* end that can make pathnames ambiguous.
|
|
|
|
|
*/
|
|
|
|
|
static int verify_dotfile(const char *rest)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* The first character was '.', but that
|
|
|
|
|
* has already been discarded, we now test
|
|
|
|
|
* the rest.
|
|
|
|
|
*/
|
|
|
|
|
switch (*rest) {
|
|
|
|
|
/* "." is not allowed */
|
|
|
|
|
case '\0': case '/':
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ".git" followed by NUL or slash is bad. This
|
|
|
|
|
* shares the path end test with the ".." case.
|
|
|
|
|
*/
|
|
|
|
|
case 'g':
|
|
|
|
|
if (rest[1] != 'i')
|
|
|
|
|
break;
|
|
|
|
|
if (rest[2] != 't')
|
|
|
|
|
break;
|
|
|
|
|
rest += 2;
|
|
|
|
|
/* fallthrough */
|
|
|
|
|
case '.':
|
|
|
|
|
if (rest[1] == '\0' || rest[1] == '/')
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int verify_path(const char *path)
|
|
|
|
|
{
|
|
|
|
|
char c;
|
|
|
|
|
|
|
|
|
|
goto inside;
|
|
|
|
|
for (;;) {
|
|
|
|
|
if (!c)
|
|
|
|
|
return 1;
|
|
|
|
|
if (c == '/') {
|
|
|
|
|
inside:
|
|
|
|
|
c = *path++;
|
|
|
|
|
switch (c) {
|
|
|
|
|
default:
|
|
|
|
|
continue;
|
|
|
|
|
case '/': case '\0':
|
|
|
|
|
break;
|
|
|
|
|
case '.':
|
|
|
|
|
if (verify_dotfile(path))
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
c = *path++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-06-19 07:21:34 +04: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 08:48:12 +04:00
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
static int has_file_name(struct index_state *istate,
|
|
|
|
|
const struct cache_entry *ce, int pos, int ok_to_replace)
|
2005-05-08 08:48:12 +04:00
|
|
|
{
|
2005-06-19 07:21:34 +04:00
|
|
|
int retval = 0;
|
|
|
|
|
int len = ce_namelen(ce);
|
2005-06-25 13:25:29 +04:00
|
|
|
int stage = ce_stage(ce);
|
2005-06-19 07:21:34 +04:00
|
|
|
const char *name = ce->name;
|
2005-05-08 08:48:12 +04:00
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
while (pos < istate->cache_nr) {
|
|
|
|
|
struct cache_entry *p = istate->cache[pos++];
|
2005-05-08 08:48:12 +04:00
|
|
|
|
2005-06-19 07:21:34 +04:00
|
|
|
if (len >= ce_namelen(p))
|
2005-05-08 08:48:12 +04:00
|
|
|
break;
|
2005-06-19 07:21:34 +04:00
|
|
|
if (memcmp(name, p->name, len))
|
|
|
|
|
break;
|
2005-06-25 13:25:29 +04:00
|
|
|
if (ce_stage(p) != stage)
|
|
|
|
|
continue;
|
2005-06-19 07:21:34 +04:00
|
|
|
if (p->name[len] != '/')
|
|
|
|
|
continue;
|
2008-01-15 03:03:17 +03:00
|
|
|
if (p->ce_flags & CE_REMOVE)
|
2007-03-30 12:55:37 +04:00
|
|
|
continue;
|
2005-06-19 07:21:34 +04:00
|
|
|
retval = -1;
|
|
|
|
|
if (!ok_to_replace)
|
|
|
|
|
break;
|
2007-04-02 10:26:07 +04:00
|
|
|
remove_index_entry_at(istate, --pos);
|
2005-05-08 08:48:12 +04:00
|
|
|
}
|
2005-06-19 07:21:34 +04:00
|
|
|
return retval;
|
|
|
|
|
}
|
2005-05-08 08:48:12 +04:00
|
|
|
|
2005-06-19 07:21:34 +04:00
|
|
|
/*
|
|
|
|
|
* Do we have another file with a pathname that is a proper
|
|
|
|
|
* subset of the name we're trying to add?
|
|
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
static int has_dir_name(struct index_state *istate,
|
|
|
|
|
const struct cache_entry *ce, int pos, int ok_to_replace)
|
2005-06-19 07:21:34 +04:00
|
|
|
{
|
|
|
|
|
int retval = 0;
|
2005-06-25 13:25:29 +04:00
|
|
|
int stage = ce_stage(ce);
|
2005-06-19 07:21:34 +04:00
|
|
|
const char *name = ce->name;
|
|
|
|
|
const char *slash = name + ce_namelen(ce);
|
2005-05-08 08:48:12 +04:00
|
|
|
|
2005-06-19 07:21:34 +04:00
|
|
|
for (;;) {
|
|
|
|
|
int len;
|
2005-05-08 08:48:12 +04:00
|
|
|
|
2005-06-19 07:21:34 +04:00
|
|
|
for (;;) {
|
|
|
|
|
if (*--slash == '/')
|
|
|
|
|
break;
|
|
|
|
|
if (slash <= ce->name)
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
len = slash - name;
|
2005-05-08 08:48:12 +04:00
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
pos = index_name_pos(istate, name, create_ce_flags(len, stage));
|
2005-06-19 07:21:34 +04:00
|
|
|
if (pos >= 0) {
|
2007-03-30 12:55:37 +04:00
|
|
|
/*
|
|
|
|
|
* Found one, but not so fast. This could
|
|
|
|
|
* be a marker that says "I was here, but
|
|
|
|
|
* I am being removed". Such an entry is
|
|
|
|
|
* not a part of the resulting tree, and
|
|
|
|
|
* it is Ok to have a directory at the same
|
|
|
|
|
* path.
|
|
|
|
|
*/
|
2008-01-23 08:24:21 +03:00
|
|
|
if (!(istate->cache[pos]->ce_flags & CE_REMOVE)) {
|
2007-03-30 12:55:37 +04:00
|
|
|
retval = -1;
|
|
|
|
|
if (!ok_to_replace)
|
|
|
|
|
break;
|
2007-04-02 10:26:07 +04:00
|
|
|
remove_index_entry_at(istate, pos);
|
2007-03-30 12:55:37 +04:00
|
|
|
continue;
|
|
|
|
|
}
|
2005-06-19 07:21:34 +04:00
|
|
|
}
|
2007-03-30 12:55:37 +04:00
|
|
|
else
|
|
|
|
|
pos = -pos-1;
|
2005-06-19 07:21:34 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Trivial optimization: if we find an entry that
|
|
|
|
|
* already matches the sub-directory, then we know
|
2005-06-25 13:25:29 +04:00
|
|
|
* we're ok, and we can exit.
|
2005-06-19 07:21:34 +04:00
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
while (pos < istate->cache_nr) {
|
|
|
|
|
struct cache_entry *p = istate->cache[pos];
|
2005-06-25 13:25:29 +04:00
|
|
|
if ((ce_namelen(p) <= len) ||
|
|
|
|
|
(p->name[len] != '/') ||
|
|
|
|
|
memcmp(p->name, name, len))
|
|
|
|
|
break; /* not our subdirectory */
|
2008-01-23 08:24:21 +03:00
|
|
|
if (ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))
|
|
|
|
|
/*
|
|
|
|
|
* p is at the same stage as our entry, and
|
2005-06-25 13:25:29 +04:00
|
|
|
* 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 08:55:21 +04:00
|
|
|
}
|
2005-05-08 08:48:12 +04:00
|
|
|
}
|
2005-06-19 07:21:34 +04: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.
|
2007-06-07 11:04:01 +04:00
|
|
|
*
|
2005-06-19 07:21:34 +04:00
|
|
|
* 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.
|
|
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
static int check_file_directory_conflict(struct index_state *istate,
|
|
|
|
|
const struct cache_entry *ce,
|
|
|
|
|
int pos, int ok_to_replace)
|
2005-06-19 07:21:34 +04:00
|
|
|
{
|
2007-03-30 12:55:37 +04:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* When ce is an "I am going away" entry, we allow it to be added
|
|
|
|
|
*/
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
2007-03-30 12:55:37 +04:00
|
|
|
return 0;
|
|
|
|
|
|
2005-06-19 07:21:34 +04:00
|
|
|
/*
|
|
|
|
|
* We check if the path is a sub-path of a subsequent pathname
|
|
|
|
|
* first, since removing those will not change the position
|
2007-03-30 12:55:37 +04:00
|
|
|
* in the array.
|
2005-06-19 07:21:34 +04:00
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
retval = has_file_name(istate, ce, pos, ok_to_replace);
|
2007-03-30 12:55:37 +04:00
|
|
|
|
2005-06-19 07:21:34 +04:00
|
|
|
/*
|
|
|
|
|
* Then check if the path might have a clashing sub-directory
|
|
|
|
|
* before it.
|
|
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
return retval + has_dir_name(istate, ce, pos, ok_to_replace);
|
2005-05-08 08:48:12 +04:00
|
|
|
}
|
|
|
|
|
|
2007-08-10 00:42:50 +04:00
|
|
|
static int add_index_entry_with_check(struct index_state *istate, struct cache_entry *ce, int option)
|
2005-04-09 23:09:27 +04:00
|
|
|
{
|
|
|
|
|
int pos;
|
2005-05-08 08:55:21 +04:00
|
|
|
int ok_to_add = option & ADD_CACHE_OK_TO_ADD;
|
|
|
|
|
int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;
|
2005-06-25 13:25:29 +04:00
|
|
|
int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;
|
2006-02-09 08:15:24 +03:00
|
|
|
|
2007-09-14 07:33:11 +04:00
|
|
|
cache_tree_invalidate_path(istate->cache_tree, ce->name);
|
2008-01-15 03:03:17 +03:00
|
|
|
pos = index_name_pos(istate, ce->name, ce->ce_flags);
|
2005-04-09 23:09:27 +04:00
|
|
|
|
2005-10-12 05:45:33 +04:00
|
|
|
/* existing match? Just replace it. */
|
2005-04-11 09:06:50 +04:00
|
|
|
if (pos >= 0) {
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
replace_index_entry(istate, pos, ce);
|
2005-04-09 23:09:27 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
2005-04-11 09:06:50 +04:00
|
|
|
pos = -pos-1;
|
2005-04-09 23:09:27 +04:00
|
|
|
|
2005-04-16 23:05:45 +04:00
|
|
|
/*
|
|
|
|
|
* Inserting a merged entry ("stage 0") into the index
|
|
|
|
|
* will always replace all non-merged entries..
|
|
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
if (pos < istate->cache_nr && ce_stage(ce) == 0) {
|
|
|
|
|
while (ce_same_name(istate->cache[pos], ce)) {
|
2005-04-16 23:05:45 +04:00
|
|
|
ok_to_add = 1;
|
2007-04-02 10:26:07 +04:00
|
|
|
if (!remove_index_entry_at(istate, pos))
|
2005-04-16 23:05:45 +04:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-10 22:32:54 +04:00
|
|
|
if (!ok_to_add)
|
|
|
|
|
return -1;
|
2006-05-18 23:07:31 +04:00
|
|
|
if (!verify_path(ce->name))
|
|
|
|
|
return -1;
|
2005-04-10 22:32:54 +04:00
|
|
|
|
2005-10-12 05:45:33 +04:00
|
|
|
if (!skip_df_check &&
|
2007-04-02 10:26:07 +04:00
|
|
|
check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {
|
2005-05-08 08:55:21 +04:00
|
|
|
if (!ok_to_replace)
|
2007-04-02 10:26:07 +04:00
|
|
|
return error("'%s' appears as both a file and as a directory",
|
|
|
|
|
ce->name);
|
2008-01-15 03:03:17 +03:00
|
|
|
pos = index_name_pos(istate, ce->name, ce->ce_flags);
|
2005-05-08 08:55:21 +04:00
|
|
|
pos = -pos-1;
|
|
|
|
|
}
|
2007-08-10 00:42:50 +04:00
|
|
|
return pos + 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int add_index_entry(struct index_state *istate, struct cache_entry *ce, int option)
|
|
|
|
|
{
|
|
|
|
|
int pos;
|
|
|
|
|
|
|
|
|
|
if (option & ADD_CACHE_JUST_APPEND)
|
|
|
|
|
pos = istate->cache_nr;
|
|
|
|
|
else {
|
|
|
|
|
int ret;
|
|
|
|
|
ret = add_index_entry_with_check(istate, ce, option);
|
|
|
|
|
if (ret <= 0)
|
|
|
|
|
return ret;
|
|
|
|
|
pos = ret - 1;
|
|
|
|
|
}
|
2005-05-08 08:48:12 +04:00
|
|
|
|
2005-04-09 23:09:27 +04:00
|
|
|
/* Make sure the array is big enough .. */
|
2007-04-02 10:26:07 +04:00
|
|
|
if (istate->cache_nr == istate->cache_alloc) {
|
|
|
|
|
istate->cache_alloc = alloc_nr(istate->cache_alloc);
|
|
|
|
|
istate->cache = xrealloc(istate->cache,
|
|
|
|
|
istate->cache_alloc * sizeof(struct cache_entry *));
|
2005-04-09 23:09:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add it in.. */
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->cache_nr++;
|
2007-08-10 00:42:50 +04:00
|
|
|
if (istate->cache_nr > pos + 1)
|
2007-04-02 10:26:07 +04:00
|
|
|
memmove(istate->cache + pos + 1,
|
|
|
|
|
istate->cache + pos,
|
|
|
|
|
(istate->cache_nr - pos - 1) * sizeof(ce));
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
set_index_entry(istate, pos, ce);
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->cache_changed = 1;
|
2005-04-09 23:09:27 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-19 20:56:35 +04:00
|
|
|
/*
|
|
|
|
|
* "refresh" does not calculate a new sha1 file or bring the
|
|
|
|
|
* cache up-to-date for mode/content changes. But what it
|
|
|
|
|
* _does_ do is to "re-match" the stat information of a file
|
|
|
|
|
* with the cache, so that you can refresh the cache for a
|
|
|
|
|
* file that hasn't been changed but where the stat entry is
|
|
|
|
|
* out of date.
|
|
|
|
|
*
|
|
|
|
|
* For example, you'd want to do this after doing a "git-read-tree",
|
|
|
|
|
* to link up the stat cache details with the proper files.
|
|
|
|
|
*/
|
2007-04-02 10:26:07 +04:00
|
|
|
static struct cache_entry *refresh_cache_ent(struct index_state *istate,
|
2007-11-10 11:15:03 +03:00
|
|
|
struct cache_entry *ce,
|
|
|
|
|
unsigned int options, int *err)
|
2006-05-19 20:56:35 +04:00
|
|
|
{
|
|
|
|
|
struct stat st;
|
|
|
|
|
struct cache_entry *updated;
|
|
|
|
|
int changed, size;
|
2007-11-10 11:15:03 +03:00
|
|
|
int ignore_valid = options & CE_MATCH_IGNORE_VALID;
|
2006-05-19 20:56:35 +04:00
|
|
|
|
2008-01-19 10:45:24 +03:00
|
|
|
if (ce_uptodate(ce))
|
|
|
|
|
return ce;
|
|
|
|
|
|
2006-07-26 08:32:18 +04:00
|
|
|
if (lstat(ce->name, &st) < 0) {
|
2007-04-02 08:34:34 +04:00
|
|
|
if (err)
|
|
|
|
|
*err = errno;
|
2006-07-26 08:32:18 +04:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2006-05-19 20:56:35 +04:00
|
|
|
|
2007-11-10 11:15:03 +03:00
|
|
|
changed = ie_match_stat(istate, ce, &st, options);
|
2006-05-19 20:56:35 +04:00
|
|
|
if (!changed) {
|
2007-11-10 11:15:03 +03:00
|
|
|
/*
|
|
|
|
|
* The path is unchanged. If we were told to ignore
|
|
|
|
|
* valid bit, then we did the actual stat check and
|
|
|
|
|
* found that the entry is unmodified. If the entry
|
|
|
|
|
* is not marked VALID, this is the place to mark it
|
|
|
|
|
* valid again, under "assume unchanged" mode.
|
|
|
|
|
*/
|
|
|
|
|
if (ignore_valid && assume_unchanged &&
|
2008-01-15 03:03:17 +03:00
|
|
|
!(ce->ce_flags & CE_VALID))
|
2006-05-19 20:56:35 +04:00
|
|
|
; /* mark this one VALID again */
|
2008-01-19 10:45:24 +03:00
|
|
|
else {
|
|
|
|
|
/*
|
|
|
|
|
* We do not mark the index itself "modified"
|
|
|
|
|
* because CE_UPTODATE flag is in-core only;
|
|
|
|
|
* we are not going to write this change out.
|
|
|
|
|
*/
|
|
|
|
|
ce_mark_uptodate(ce);
|
2006-07-26 08:32:18 +04:00
|
|
|
return ce;
|
2008-01-19 10:45:24 +03:00
|
|
|
}
|
2006-05-19 20:56:35 +04:00
|
|
|
}
|
|
|
|
|
|
2007-11-10 11:15:03 +03:00
|
|
|
if (ie_modified(istate, ce, &st, options)) {
|
2007-04-02 08:34:34 +04:00
|
|
|
if (err)
|
|
|
|
|
*err = EINVAL;
|
2006-07-26 08:32:18 +04:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2006-05-19 20:56:35 +04:00
|
|
|
|
|
|
|
|
size = ce_size(ce);
|
|
|
|
|
updated = xmalloc(size);
|
|
|
|
|
memcpy(updated, ce, size);
|
|
|
|
|
fill_stat_cache_info(updated, &st);
|
2007-11-10 11:15:03 +03:00
|
|
|
/*
|
|
|
|
|
* If ignore_valid is not set, we should leave CE_VALID bit
|
|
|
|
|
* alone. Otherwise, paths marked with --no-assume-unchanged
|
|
|
|
|
* (i.e. things to be edited) will reacquire CE_VALID bit
|
|
|
|
|
* automatically, which is not really what we want.
|
2006-05-19 20:56:35 +04:00
|
|
|
*/
|
2007-11-10 11:15:03 +03:00
|
|
|
if (!ignore_valid && assume_unchanged &&
|
2008-01-15 03:03:17 +03:00
|
|
|
!(ce->ce_flags & CE_VALID))
|
|
|
|
|
updated->ce_flags &= ~CE_VALID;
|
2006-05-19 20:56:35 +04:00
|
|
|
|
|
|
|
|
return updated;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-12 01:59:01 +04:00
|
|
|
int refresh_index(struct index_state *istate, unsigned int flags, const char **pathspec, char *seen)
|
2006-05-19 20:56:35 +04:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int has_errors = 0;
|
|
|
|
|
int really = (flags & REFRESH_REALLY) != 0;
|
|
|
|
|
int allow_unmerged = (flags & REFRESH_UNMERGED) != 0;
|
|
|
|
|
int quiet = (flags & REFRESH_QUIET) != 0;
|
|
|
|
|
int not_new = (flags & REFRESH_IGNORE_MISSING) != 0;
|
2007-11-10 11:15:03 +03:00
|
|
|
unsigned int options = really ? CE_MATCH_IGNORE_VALID : 0;
|
2006-05-19 20:56:35 +04:00
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
2006-05-19 20:56:35 +04:00
|
|
|
struct cache_entry *ce, *new;
|
2007-04-02 08:34:34 +04:00
|
|
|
int cache_errno = 0;
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
ce = istate->cache[i];
|
2006-05-19 20:56:35 +04:00
|
|
|
if (ce_stage(ce)) {
|
2007-04-02 10:26:07 +04:00
|
|
|
while ((i < istate->cache_nr) &&
|
|
|
|
|
! strcmp(istate->cache[i]->name, ce->name))
|
2006-05-19 20:56:35 +04:00
|
|
|
i++;
|
|
|
|
|
i--;
|
|
|
|
|
if (allow_unmerged)
|
|
|
|
|
continue;
|
|
|
|
|
printf("%s: needs merge\n", ce->name);
|
|
|
|
|
has_errors = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-12 01:59:01 +04:00
|
|
|
if (pathspec && !match_pathspec(pathspec, ce->name, strlen(ce->name), 0, seen))
|
|
|
|
|
continue;
|
|
|
|
|
|
2007-11-10 11:15:03 +03:00
|
|
|
new = refresh_cache_ent(istate, ce, options, &cache_errno);
|
2006-07-26 08:32:18 +04:00
|
|
|
if (new == ce)
|
2006-05-19 20:56:35 +04:00
|
|
|
continue;
|
2006-07-26 08:32:18 +04:00
|
|
|
if (!new) {
|
|
|
|
|
if (not_new && cache_errno == ENOENT)
|
2006-05-19 20:56:35 +04:00
|
|
|
continue;
|
2006-07-26 08:32:18 +04:00
|
|
|
if (really && cache_errno == EINVAL) {
|
2006-05-19 20:56:35 +04:00
|
|
|
/* If we are doing --really-refresh that
|
|
|
|
|
* means the index is not valid anymore.
|
|
|
|
|
*/
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_flags &= ~CE_VALID;
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->cache_changed = 1;
|
2006-05-19 20:56:35 +04:00
|
|
|
}
|
|
|
|
|
if (quiet)
|
|
|
|
|
continue;
|
|
|
|
|
printf("%s: needs update\n", ce->name);
|
|
|
|
|
has_errors = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
|
|
|
|
|
replace_index_entry(istate, i, new);
|
2006-05-19 20:56:35 +04:00
|
|
|
}
|
|
|
|
|
return has_errors;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 08:34:34 +04:00
|
|
|
struct cache_entry *refresh_cache_entry(struct cache_entry *ce, int really)
|
|
|
|
|
{
|
2007-04-02 10:26:07 +04:00
|
|
|
return refresh_cache_ent(&the_index, ce, really, NULL);
|
2007-04-02 08:34:34 +04:00
|
|
|
}
|
|
|
|
|
|
2006-04-25 08:18:58 +04:00
|
|
|
static int verify_hdr(struct cache_header *hdr, unsigned long size)
|
2005-04-08 02:13:13 +04:00
|
|
|
{
|
|
|
|
|
SHA_CTX c;
|
2006-04-25 08:18:58 +04:00
|
|
|
unsigned char sha1[20];
|
2005-04-08 02:13:13 +04:00
|
|
|
|
2005-04-15 21:44:27 +04:00
|
|
|
if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
|
2005-04-08 02:13:13 +04:00
|
|
|
return error("bad signature");
|
2005-04-20 23:36:41 +04:00
|
|
|
if (hdr->hdr_version != htonl(2))
|
|
|
|
|
return error("bad index version");
|
2005-04-08 02:13:13 +04:00
|
|
|
SHA1_Init(&c);
|
2005-04-20 23:36:41 +04:00
|
|
|
SHA1_Update(&c, hdr, size - 20);
|
2005-04-08 02:13:13 +04:00
|
|
|
SHA1_Final(sha1, &c);
|
2006-08-17 22:54:57 +04:00
|
|
|
if (hashcmp(sha1, (unsigned char *)hdr + size - 20))
|
2005-04-20 23:36:41 +04:00
|
|
|
return error("bad index file sha1 signature");
|
2005-04-08 02:13:13 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
static int read_index_extension(struct index_state *istate,
|
|
|
|
|
const char *ext, void *data, unsigned long sz)
|
2006-04-25 08:18:58 +04:00
|
|
|
{
|
|
|
|
|
switch (CACHE_EXT(ext)) {
|
|
|
|
|
case CACHE_EXT_TREE:
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->cache_tree = cache_tree_read(data, sz);
|
2006-04-25 08:18:58 +04:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
if (*ext < 'A' || 'Z' < *ext)
|
|
|
|
|
return error("index uses %.4s extension, which we do not understand",
|
|
|
|
|
ext);
|
|
|
|
|
fprintf(stderr, "ignoring %.4s extension\n", ext);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int read_index(struct index_state *istate)
|
2006-07-26 08:32:18 +04:00
|
|
|
{
|
2007-04-02 10:26:07 +04:00
|
|
|
return read_index_from(istate, get_index_file());
|
2006-07-26 08:32:18 +04:00
|
|
|
}
|
|
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
static void convert_from_disk(struct ondisk_cache_entry *ondisk, struct cache_entry *ce)
|
|
|
|
|
{
|
2008-01-19 10:42:00 +03:00
|
|
|
size_t len;
|
|
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_ctime = ntohl(ondisk->ctime.sec);
|
|
|
|
|
ce->ce_mtime = ntohl(ondisk->mtime.sec);
|
|
|
|
|
ce->ce_dev = ntohl(ondisk->dev);
|
|
|
|
|
ce->ce_ino = ntohl(ondisk->ino);
|
|
|
|
|
ce->ce_mode = ntohl(ondisk->mode);
|
|
|
|
|
ce->ce_uid = ntohl(ondisk->uid);
|
|
|
|
|
ce->ce_gid = ntohl(ondisk->gid);
|
|
|
|
|
ce->ce_size = ntohl(ondisk->size);
|
|
|
|
|
/* On-disk flags are just 16 bits */
|
|
|
|
|
ce->ce_flags = ntohs(ondisk->flags);
|
|
|
|
|
hashcpy(ce->sha1, ondisk->sha1);
|
2008-01-19 10:42:00 +03:00
|
|
|
|
|
|
|
|
len = ce->ce_flags & CE_NAMEMASK;
|
|
|
|
|
if (len == CE_NAMEMASK)
|
|
|
|
|
len = strlen(ondisk->name);
|
|
|
|
|
/*
|
|
|
|
|
* NEEDSWORK: If the original index is crafted, this copy could
|
|
|
|
|
* go unchecked.
|
|
|
|
|
*/
|
|
|
|
|
memcpy(ce->name, ondisk->name, len + 1);
|
2008-01-15 03:03:17 +03:00
|
|
|
}
|
|
|
|
|
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
static inline size_t estimate_cache_size(size_t ondisk_size, unsigned int entries)
|
|
|
|
|
{
|
|
|
|
|
long per_entry;
|
|
|
|
|
|
|
|
|
|
per_entry = sizeof(struct cache_entry) - sizeof(struct ondisk_cache_entry);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Alignment can cause differences. This should be "alignof", but
|
|
|
|
|
* since that's a gcc'ism, just use the size of a pointer.
|
|
|
|
|
*/
|
|
|
|
|
per_entry += sizeof(void *);
|
|
|
|
|
return ondisk_size + entries*per_entry;
|
|
|
|
|
}
|
|
|
|
|
|
2006-07-26 08:32:18 +04:00
|
|
|
/* remember to discard_cache() before reading a different cache! */
|
2007-04-02 10:26:07 +04:00
|
|
|
int read_index_from(struct index_state *istate, const char *path)
|
2005-04-08 02:13:13 +04:00
|
|
|
{
|
|
|
|
|
int fd, i;
|
|
|
|
|
struct stat st;
|
2008-01-15 03:03:17 +03:00
|
|
|
unsigned long src_offset, dst_offset;
|
2005-04-08 02:13:13 +04:00
|
|
|
struct cache_header *hdr;
|
2008-01-15 03:03:17 +03:00
|
|
|
void *mmap;
|
|
|
|
|
size_t mmap_size;
|
2005-04-08 02:13:13 +04:00
|
|
|
|
|
|
|
|
errno = EBUSY;
|
2008-01-15 03:03:17 +03:00
|
|
|
if (istate->alloc)
|
2007-04-02 10:26:07 +04:00
|
|
|
return istate->cache_nr;
|
2005-10-02 00:24:27 +04:00
|
|
|
|
2005-04-08 02:13:13 +04:00
|
|
|
errno = ENOENT;
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->timestamp = 0;
|
2006-07-26 08:32:18 +04:00
|
|
|
fd = open(path, O_RDONLY);
|
2005-10-02 00:24:27 +04:00
|
|
|
if (fd < 0) {
|
|
|
|
|
if (errno == ENOENT)
|
|
|
|
|
return 0;
|
|
|
|
|
die("index file open failed (%s)", strerror(errno));
|
|
|
|
|
}
|
2005-04-08 02:13:13 +04:00
|
|
|
|
2007-04-25 18:18:17 +04:00
|
|
|
if (fstat(fd, &st))
|
2006-12-26 07:40:58 +03:00
|
|
|
die("cannot stat the open index (%s)", strerror(errno));
|
2007-04-25 18:18:17 +04:00
|
|
|
|
|
|
|
|
errno = EINVAL;
|
2008-01-15 03:03:17 +03:00
|
|
|
mmap_size = xsize_t(st.st_size);
|
|
|
|
|
if (mmap_size < sizeof(struct cache_header) + 20)
|
2007-04-25 18:18:17 +04:00
|
|
|
die("index file smaller than expected");
|
|
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
mmap = xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
|
2005-04-08 02:13:13 +04:00
|
|
|
close(fd);
|
2008-01-15 03:03:17 +03:00
|
|
|
if (mmap == MAP_FAILED)
|
|
|
|
|
die("unable to map index file");
|
2005-04-08 02:13:13 +04:00
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
hdr = mmap;
|
|
|
|
|
if (verify_hdr(hdr, mmap_size) < 0)
|
2005-04-08 02:13:13 +04:00
|
|
|
goto unmap;
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->cache_nr = ntohl(hdr->hdr_entries);
|
|
|
|
|
istate->cache_alloc = alloc_nr(istate->cache_nr);
|
|
|
|
|
istate->cache = xcalloc(istate->cache_alloc, sizeof(struct cache_entry *));
|
2005-04-08 02:13:13 +04:00
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
/*
|
|
|
|
|
* The disk format is actually larger than the in-memory format,
|
|
|
|
|
* due to space for nsec etc, so even though the in-memory one
|
|
|
|
|
* has room for a few more flags, we can allocate using the same
|
|
|
|
|
* index size
|
|
|
|
|
*/
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
istate->alloc = xmalloc(estimate_cache_size(mmap_size, istate->cache_nr));
|
2008-01-15 03:03:17 +03:00
|
|
|
|
|
|
|
|
src_offset = sizeof(*hdr);
|
|
|
|
|
dst_offset = 0;
|
2007-04-02 10:26:07 +04:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
2008-01-15 03:03:17 +03:00
|
|
|
struct ondisk_cache_entry *disk_ce;
|
2007-04-02 10:26:07 +04:00
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
disk_ce = (struct ondisk_cache_entry *)((char *)mmap + src_offset);
|
|
|
|
|
ce = (struct cache_entry *)((char *)istate->alloc + dst_offset);
|
|
|
|
|
convert_from_disk(disk_ce, ce);
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
set_index_entry(istate, i, ce);
|
2008-01-15 03:03:17 +03:00
|
|
|
|
|
|
|
|
src_offset += ondisk_ce_size(ce);
|
|
|
|
|
dst_offset += ce_size(ce);
|
2005-04-08 02:13:13 +04:00
|
|
|
}
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->timestamp = st.st_mtime;
|
2008-01-15 03:03:17 +03:00
|
|
|
while (src_offset <= mmap_size - 20 - 8) {
|
2006-04-25 08:18:58 +04:00
|
|
|
/* After an array of active_nr index entries,
|
|
|
|
|
* there can be arbitrary number of extended
|
|
|
|
|
* sections, each of which is prefixed with
|
|
|
|
|
* extension name (4-byte) and section length
|
|
|
|
|
* in 4-byte network byte order.
|
|
|
|
|
*/
|
|
|
|
|
unsigned long extsize;
|
2008-01-15 03:03:17 +03:00
|
|
|
memcpy(&extsize, (char *)mmap + src_offset + 4, 4);
|
2006-04-25 08:18:58 +04:00
|
|
|
extsize = ntohl(extsize);
|
2007-04-02 10:26:07 +04:00
|
|
|
if (read_index_extension(istate,
|
2008-01-15 03:03:17 +03:00
|
|
|
(const char *) mmap + src_offset,
|
|
|
|
|
(char *) mmap + src_offset + 8,
|
2006-06-18 19:18:09 +04:00
|
|
|
extsize) < 0)
|
2006-04-25 08:18:58 +04:00
|
|
|
goto unmap;
|
2008-01-15 03:03:17 +03:00
|
|
|
src_offset += 8;
|
|
|
|
|
src_offset += extsize;
|
2006-04-25 08:18:58 +04:00
|
|
|
}
|
2008-01-15 03:03:17 +03:00
|
|
|
munmap(mmap, mmap_size);
|
2007-04-02 10:26:07 +04:00
|
|
|
return istate->cache_nr;
|
2005-04-08 02:13:13 +04:00
|
|
|
|
|
|
|
|
unmap:
|
2008-01-15 03:03:17 +03:00
|
|
|
munmap(mmap, mmap_size);
|
2005-04-08 02:13:13 +04:00
|
|
|
errno = EINVAL;
|
2005-10-02 00:24:27 +04:00
|
|
|
die("index file corrupt");
|
2005-04-08 02:13:13 +04:00
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int discard_index(struct index_state *istate)
|
Status update on merge-recursive in C
This is just an update for people being interested. Alex and me were
busy with that project for a few days now. While it has progressed nicely,
there are quite a couple TODOs in merge-recursive.c, just search for "TODO".
For impatient people: yes, it passes all the tests, and yes, according
to the evil test Alex did, it is faster than the Python script.
But no, it is not yet finished. Biggest points are:
- there are still three external calls
- in the end, it should not be necessary to write the index more than once
(just before exiting)
- a lot of things can be refactored to make the code easier and shorter
BTW we cannot just plug in git-merge-tree yet, because git-merge-tree
does not handle renames at all.
This patch is meant for testing, and as such,
- it compile the program to git-merge-recur
- it adjusts the scripts and tests to use git-merge-recur instead of
git-merge-recursive
- it provides "TEST", a script to execute the tests regarding -recursive
- it inlines the changes to read-cache.c (read_cache_from(), discard_cache()
and refresh_cache_entry())
Brought to you by Alex Riesen and Dscho
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-08 20:42:41 +04:00
|
|
|
{
|
2007-04-02 10:26:07 +04:00
|
|
|
istate->cache_nr = 0;
|
|
|
|
|
istate->cache_changed = 0;
|
|
|
|
|
istate->timestamp = 0;
|
Create pathname-based hash-table lookup into index
This creates a hash index of every single file added to the index.
Right now that hash index isn't actually used for much: I implemented a
"cache_name_exists()" function that uses it to efficiently look up a
filename in the index without having to do the O(logn) binary search,
but quite frankly, that's not why this patch is interesting.
No, the whole and only reason to create the hash of the filenames in the
index is that by modifying the hash function, you can fairly easily do
things like making it always hash equivalent names into the same bucket.
That, in turn, means that suddenly questions like "does this name exist
in the index under an _equivalent_ name?" becomes much much cheaper.
Guiding principles behind this patch:
- it shouldn't be too costly. In fact, my primary goal here was to
actually speed up "git commit" with a fully populated kernel tree, by
being faster at checking whether a file already existed in the index. I
did succeed, but only barely:
Best before:
[torvalds@woody linux]$ time git commit > /dev/null
real 0m0.255s
user 0m0.168s
sys 0m0.088s
Best after:
[torvalds@woody linux]$ time ~/git/git commit > /dev/null
real 0m0.233s
user 0m0.144s
sys 0m0.088s
so some things are actually faster (~8%).
Caveat: that's really the best case. Other things are invariably going
to be slightly slower, since we populate that index cache, and quite
frankly, few things really use it to look things up.
That said, the cost is really quite small. The worst case is probably
doing a "git ls-files", which will do very little except puopulate the
index, and never actually looks anything up in it, just lists it.
Before:
[torvalds@woody linux]$ time git ls-files > /dev/null
real 0m0.016s
user 0m0.016s
sys 0m0.000s
After:
[torvalds@woody linux]$ time ~/git/git ls-files > /dev/null
real 0m0.021s
user 0m0.012s
sys 0m0.008s
and while the thing has really gotten relatively much slower, we're
still talking about something almost unmeasurable (eg 5ms). And that
really should be pretty much the worst case.
So we lose 5ms on one "benchmark", but win 22ms on another. Pick your
poison - this patch has the advantage that it will _likely_ speed up
the cases that are complex and expensive more than it slows down the
cases that are already so fast that nobody cares. But if you look at
relative speedups/slowdowns, it doesn't look so good.
- It should be simple and clean
The code may be a bit subtle (the reasons I do hash removal the way I
do etc), but it re-uses the existing hash.c files, so it really is
fairly small and straightforward apart from a few odd details.
Now, this patch on its own doesn't really do much, but I think it's worth
looking at, if only because if done correctly, the name hashing really can
make an improvement to the whole issue of "do we have a filename that
looks like this in the index already". And at least it gets real testing
by being used even by default (ie there is a real use-case for it even
without any insane filesystems).
NOTE NOTE NOTE! The current hash is a joke. I'm ashamed of it, I'm just
not ashamed of it enough to really care. I took all the numbers out of my
nether regions - I'm sure it's good enough that it works in practice, but
the whole point was that you can make a really much fancier hash that
hashes characters not directly, but by their upper-case value or something
like that, and thus you get a case-insensitive hash, while still keeping
the name and the index itself totally case sensitive.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-23 05:41:14 +03:00
|
|
|
free_hash(&istate->name_hash);
|
2007-04-02 10:26:07 +04:00
|
|
|
cache_tree_free(&(istate->cache_tree));
|
2008-01-15 03:03:17 +03:00
|
|
|
free(istate->alloc);
|
|
|
|
|
istate->alloc = NULL;
|
Status update on merge-recursive in C
This is just an update for people being interested. Alex and me were
busy with that project for a few days now. While it has progressed nicely,
there are quite a couple TODOs in merge-recursive.c, just search for "TODO".
For impatient people: yes, it passes all the tests, and yes, according
to the evil test Alex did, it is faster than the Python script.
But no, it is not yet finished. Biggest points are:
- there are still three external calls
- in the end, it should not be necessary to write the index more than once
(just before exiting)
- a lot of things can be refactored to make the code easier and shorter
BTW we cannot just plug in git-merge-tree yet, because git-merge-tree
does not handle renames at all.
This patch is meant for testing, and as such,
- it compile the program to git-merge-recur
- it adjusts the scripts and tests to use git-merge-recur instead of
git-merge-recursive
- it provides "TEST", a script to execute the tests regarding -recursive
- it inlines the changes to read-cache.c (read_cache_from(), discard_cache()
and refresh_cache_entry())
Brought to you by Alex Riesen and Dscho
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-08 20:42:41 +04:00
|
|
|
|
|
|
|
|
/* no need to throw away allocated active_cache */
|
2008-01-15 03:03:17 +03:00
|
|
|
return 0;
|
Status update on merge-recursive in C
This is just an update for people being interested. Alex and me were
busy with that project for a few days now. While it has progressed nicely,
there are quite a couple TODOs in merge-recursive.c, just search for "TODO".
For impatient people: yes, it passes all the tests, and yes, according
to the evil test Alex did, it is faster than the Python script.
But no, it is not yet finished. Biggest points are:
- there are still three external calls
- in the end, it should not be necessary to write the index more than once
(just before exiting)
- a lot of things can be refactored to make the code easier and shorter
BTW we cannot just plug in git-merge-tree yet, because git-merge-tree
does not handle renames at all.
This patch is meant for testing, and as such,
- it compile the program to git-merge-recur
- it adjusts the scripts and tests to use git-merge-recur instead of
git-merge-recursive
- it provides "TEST", a script to execute the tests regarding -recursive
- it inlines the changes to read-cache.c (read_cache_from(), discard_cache()
and refresh_cache_entry())
Brought to you by Alex Riesen and Dscho
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-08 20:42:41 +04:00
|
|
|
}
|
|
|
|
|
|
2005-04-20 23:16:57 +04:00
|
|
|
#define WRITE_BUFFER_SIZE 8192
|
2005-05-18 16:14:09 +04:00
|
|
|
static unsigned char write_buffer[WRITE_BUFFER_SIZE];
|
2005-04-20 23:16:57 +04:00
|
|
|
static unsigned long write_buffer_len;
|
|
|
|
|
|
2006-08-09 01:47:32 +04:00
|
|
|
static int ce_write_flush(SHA_CTX *context, int fd)
|
|
|
|
|
{
|
|
|
|
|
unsigned int buffered = write_buffer_len;
|
|
|
|
|
if (buffered) {
|
|
|
|
|
SHA1_Update(context, write_buffer, buffered);
|
2007-01-08 18:58:23 +03:00
|
|
|
if (write_in_full(fd, write_buffer, buffered) != buffered)
|
2006-08-09 01:47:32 +04:00
|
|
|
return -1;
|
|
|
|
|
write_buffer_len = 0;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-20 23:36:41 +04:00
|
|
|
static int ce_write(SHA_CTX *context, int fd, void *data, unsigned int len)
|
2005-04-20 23:16:57 +04: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) {
|
2006-08-09 01:47:32 +04:00
|
|
|
write_buffer_len = buffered;
|
|
|
|
|
if (ce_write_flush(context, fd))
|
2005-04-20 23:16:57 +04:00
|
|
|
return -1;
|
|
|
|
|
buffered = 0;
|
|
|
|
|
}
|
|
|
|
|
write_buffer_len = buffered;
|
|
|
|
|
len -= partial;
|
2006-06-18 19:18:09 +04:00
|
|
|
data = (char *) data + partial;
|
2007-06-07 11:04:01 +04:00
|
|
|
}
|
|
|
|
|
return 0;
|
2005-04-20 23:16:57 +04:00
|
|
|
}
|
|
|
|
|
|
2006-04-25 08:18:58 +04:00
|
|
|
static int write_index_ext_header(SHA_CTX *context, int fd,
|
2006-05-28 23:08:08 +04:00
|
|
|
unsigned int ext, unsigned int sz)
|
2006-04-25 08:18:58 +04:00
|
|
|
{
|
|
|
|
|
ext = htonl(ext);
|
|
|
|
|
sz = htonl(sz);
|
2006-08-15 00:38:14 +04:00
|
|
|
return ((ce_write(context, fd, &ext, 4) < 0) ||
|
|
|
|
|
(ce_write(context, fd, &sz, 4) < 0)) ? -1 : 0;
|
2006-04-25 08:18:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ce_flush(SHA_CTX *context, int fd)
|
2005-04-20 23:16:57 +04:00
|
|
|
{
|
|
|
|
|
unsigned int left = write_buffer_len;
|
2005-04-20 23:36:41 +04:00
|
|
|
|
2005-04-20 23:16:57 +04:00
|
|
|
if (left) {
|
|
|
|
|
write_buffer_len = 0;
|
2005-04-20 23:36:41 +04:00
|
|
|
SHA1_Update(context, write_buffer, left);
|
2005-04-20 23:16:57 +04:00
|
|
|
}
|
2005-04-20 23:36:41 +04:00
|
|
|
|
2005-09-11 17:27:47 +04:00
|
|
|
/* Flush first if not enough space for SHA1 signature */
|
|
|
|
|
if (left + 20 > WRITE_BUFFER_SIZE) {
|
2007-01-08 18:58:23 +03:00
|
|
|
if (write_in_full(fd, write_buffer, left) != left)
|
2005-09-11 17:27:47 +04:00
|
|
|
return -1;
|
|
|
|
|
left = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-20 23:36:41 +04:00
|
|
|
/* Append the SHA1 signature at the end */
|
2006-04-25 08:18:58 +04:00
|
|
|
SHA1_Final(write_buffer + left, context);
|
2005-04-20 23:36:41 +04:00
|
|
|
left += 20;
|
2007-01-08 18:58:23 +03:00
|
|
|
return (write_in_full(fd, write_buffer, left) != left) ? -1 : 0;
|
2005-04-20 23:16:57 +04:00
|
|
|
}
|
|
|
|
|
|
2005-12-20 23:12:18 +03: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-21 01:18:47 +03: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
|
|
|
|
|
*
|
2006-08-05 15:16:02 +04:00
|
|
|
* but it does not. When the second update-index runs,
|
2005-12-21 01:18:47 +03:00
|
|
|
* 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
|
2007-06-07 11:04:01 +04:00
|
|
|
* obtain from the filesystem next time we stat("frotz").
|
2005-12-21 01:18:47 +03:00
|
|
|
*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_size = 0;
|
2005-12-20 23:12:18 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-01-15 03:03:17 +03:00
|
|
|
static int ce_write_entry(SHA_CTX *c, int fd, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
int size = ondisk_ce_size(ce);
|
|
|
|
|
struct ondisk_cache_entry *ondisk = xcalloc(1, size);
|
|
|
|
|
|
|
|
|
|
ondisk->ctime.sec = htonl(ce->ce_ctime);
|
|
|
|
|
ondisk->ctime.nsec = 0;
|
|
|
|
|
ondisk->mtime.sec = htonl(ce->ce_mtime);
|
|
|
|
|
ondisk->mtime.nsec = 0;
|
|
|
|
|
ondisk->dev = htonl(ce->ce_dev);
|
|
|
|
|
ondisk->ino = htonl(ce->ce_ino);
|
|
|
|
|
ondisk->mode = htonl(ce->ce_mode);
|
|
|
|
|
ondisk->uid = htonl(ce->ce_uid);
|
|
|
|
|
ondisk->gid = htonl(ce->ce_gid);
|
|
|
|
|
ondisk->size = htonl(ce->ce_size);
|
|
|
|
|
hashcpy(ondisk->sha1, ce->sha1);
|
|
|
|
|
ondisk->flags = htons(ce->ce_flags);
|
|
|
|
|
memcpy(ondisk->name, ce->name, ce_namelen(ce));
|
|
|
|
|
|
|
|
|
|
return ce_write(c, fd, ondisk, size);
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 10:26:07 +04:00
|
|
|
int write_index(struct index_state *istate, int newfd)
|
2005-04-09 23:09:27 +04:00
|
|
|
{
|
|
|
|
|
SHA_CTX c;
|
|
|
|
|
struct cache_header hdr;
|
2007-09-25 12:22:44 +04:00
|
|
|
int i, err, removed;
|
2007-04-02 10:26:07 +04:00
|
|
|
struct cache_entry **cache = istate->cache;
|
|
|
|
|
int entries = istate->cache_nr;
|
2005-06-10 12:32:37 +04:00
|
|
|
|
|
|
|
|
for (i = removed = 0; i < entries; i++)
|
2008-01-15 03:03:17 +03:00
|
|
|
if (cache[i]->ce_flags & CE_REMOVE)
|
2005-06-10 12:32:37 +04:00
|
|
|
removed++;
|
2005-04-09 23:09:27 +04:00
|
|
|
|
2005-04-15 21:44:27 +04:00
|
|
|
hdr.hdr_signature = htonl(CACHE_SIGNATURE);
|
2005-04-20 23:36:41 +04:00
|
|
|
hdr.hdr_version = htonl(2);
|
2005-06-10 12:32:37 +04:00
|
|
|
hdr.hdr_entries = htonl(entries - removed);
|
2005-04-09 23:09:27 +04:00
|
|
|
|
|
|
|
|
SHA1_Init(&c);
|
2005-04-20 23:36:41 +04:00
|
|
|
if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0)
|
2005-04-09 23:09:27 +04:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
|
|
|
struct cache_entry *ce = cache[i];
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
2005-06-10 02:34:04 +04:00
|
|
|
continue;
|
2008-01-21 11:44:50 +03:00
|
|
|
if (is_racy_timestamp(istate, ce))
|
2005-12-20 23:12:18 +03:00
|
|
|
ce_smudge_racily_clean_entry(ce);
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce_write_entry(&c, newfd, ce) < 0)
|
2005-04-09 23:09:27 +04:00
|
|
|
return -1;
|
|
|
|
|
}
|
2006-04-24 03:52:08 +04:00
|
|
|
|
2006-04-25 08:18:58 +04:00
|
|
|
/* Write extension data here */
|
2007-04-02 10:26:07 +04:00
|
|
|
if (istate->cache_tree) {
|
2007-09-25 12:22:44 +04:00
|
|
|
struct strbuf sb;
|
|
|
|
|
|
|
|
|
|
strbuf_init(&sb, 0);
|
|
|
|
|
cache_tree_write(&sb, istate->cache_tree);
|
|
|
|
|
err = write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) < 0
|
|
|
|
|
|| ce_write(&c, newfd, sb.buf, sb.len) < 0;
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
if (err)
|
2006-04-25 08:18:58 +04:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
return ce_flush(&c, newfd);
|
2005-04-09 23:09:27 +04:00
|
|
|
}
|
