2005-04-08 00:16:10 +02:00
|
|
|
/*
|
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
|
*/
|
2007-04-02 08:26:07 +02:00
|
|
|
#define NO_THE_INDEX_COMPATIBILITY_MACROS
|
2005-04-08 00:13:13 +02:00
|
|
|
#include "cache.h"
|
2006-04-25 06:18:58 +02:00
|
|
|
#include "cache-tree.h"
|
2007-04-10 06:20:29 +02:00
|
|
|
#include "refs.h"
|
2007-08-11 23:59:01 +02:00
|
|
|
#include "dir.h"
|
2008-07-21 10:24:17 +02:00
|
|
|
#include "tree.h"
|
|
|
|
|
#include "commit.h"
|
2008-08-21 10:44:53 +02:00
|
|
|
#include "blob.h"
|
2009-12-25 09:30:51 +01:00
|
|
|
#include "resolve-undo.h"
|
2012-04-04 00:53:15 +02:00
|
|
|
#include "strbuf.h"
|
|
|
|
|
#include "varint.h"
|
2014-06-13 14:19:36 +02:00
|
|
|
#include "split-index.h"
|
2006-04-25 06:18:58 +02:00
|
|
|
|
2014-01-27 15:45:08 +01:00
|
|
|
static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,
|
|
|
|
|
unsigned int options);
|
2010-01-12 07:29:35 +01:00
|
|
|
|
2012-07-11 11:22:37 +02:00
|
|
|
/* Mask for the name length in ce_flags in the on-disk index */
|
|
|
|
|
|
|
|
|
|
#define CE_NAMEMASK (0x0fff)
|
|
|
|
|
|
2006-04-25 06:18:58 +02: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" */
|
2010-02-02 16:33:28 +01:00
|
|
|
#define CACHE_EXT_RESOLVE_UNDO 0x52455543 /* "REUC" */
|
2014-06-13 14:19:36 +02:00
|
|
|
#define CACHE_EXT_LINK 0x6c696e6b /* "link" */
|
|
|
|
|
|
|
|
|
|
/* changes that can be kept in $GIT_DIR/index (basically all extensions) */
|
2014-06-13 14:19:37 +02:00
|
|
|
#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \
|
2014-06-13 14:19:38 +02:00
|
|
|
CE_ENTRY_ADDED | CE_ENTRY_REMOVED)
|
2005-04-08 00:13:13 +02:00
|
|
|
|
2007-04-02 03:14:06 +02:00
|
|
|
struct index_state the_index;
|
2014-06-13 14:19:24 +02:00
|
|
|
static const char *alternate_index_output;
|
2006-07-26 06:32:18 +02:00
|
|
|
|
2008-01-23 08:01:13 +01:00
|
|
|
static void set_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
istate->cache[nr] = ce;
|
2008-03-21 21:16:24 +01:00
|
|
|
add_name_hash(istate, ce);
|
2008-01-23 08:01:13 +01: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 03:41:14 +01:00
|
|
|
static void replace_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
struct cache_entry *old = istate->cache[nr];
|
|
|
|
|
|
2013-02-28 00:57:48 +01:00
|
|
|
remove_name_hash(istate, old);
|
2013-11-14 20:24:37 +01:00
|
|
|
free(old);
|
Fix name re-hashing semantics
We handled the case of removing and re-inserting cache entries badly,
which is something that merging commonly needs to do (removing the
different stages, and then re-inserting one of them as the merged
state).
We even had a rather ugly special case for this failure case, where
replace_index_entry() basically turned itself into a no-op if the new
and the old entries were the same, exactly because the hash routines
didn't handle it on their own.
So what this patch does is to not just have the UNHASHED bit, but a
HASHED bit too, and when you insert an entry into the name hash, that
involves:
- clear the UNHASHED bit, because now it's valid again for lookup
(which is really all that UNHASHED meant)
- if we're being lazy, we're done here (but we still want to clear the
UNHASHED bit regardless of lazy mode, since we can become unlazy
later, and so we need the UNHASHED bit to always be set correctly,
even if we never actually insert the entry into the hash list)
- if it was already hashed, we just leave it on the list
- otherwise mark it HASHED and insert it into the list
this all means that unhashing and rehashing a name all just works
automatically. Obviously, you cannot change the name of an entry (that
would be a serious bug), but nothing can validly do that anyway (you'd
have to allocate a new struct cache_entry anyway since the name length
could change), so that's not a new limitation.
The code actually gets simpler in many ways, although the lazy hashing
does mean that there are a few odd cases (ie something can be marked
unhashed even though it was never on the hash in the first place, and
isn't actually marked hashed!).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-23 05:37:40 +01:00
|
|
|
set_index_entry(istate, nr, ce);
|
2014-06-13 14:19:27 +02:00
|
|
|
istate->cache_changed |= CE_ENTRY_CHANGED;
|
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 03:41:14 +01:00
|
|
|
}
|
|
|
|
|
|
2008-07-21 02:25:56 +02:00
|
|
|
void rename_index_entry_at(struct index_state *istate, int nr, const char *new_name)
|
|
|
|
|
{
|
|
|
|
|
struct cache_entry *old = istate->cache[nr], *new;
|
|
|
|
|
int namelen = strlen(new_name);
|
|
|
|
|
|
|
|
|
|
new = xmalloc(cache_entry_size(namelen));
|
|
|
|
|
copy_cache_entry(new, old);
|
2013-11-14 20:22:27 +01:00
|
|
|
new->ce_flags &= ~CE_HASHED;
|
2012-07-11 11:22:37 +02:00
|
|
|
new->ce_namelen = namelen;
|
2014-06-13 14:19:36 +02:00
|
|
|
new->index = 0;
|
2008-07-21 02:25:56 +02:00
|
|
|
memcpy(new->name, new_name, namelen + 1);
|
|
|
|
|
|
2014-06-13 14:19:31 +02:00
|
|
|
cache_tree_invalidate_path(istate, old->name);
|
2008-07-21 02:25:56 +02:00
|
|
|
remove_index_entry_at(istate, nr);
|
|
|
|
|
add_index_entry(istate, new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-20 10:37:50 +02:00
|
|
|
void fill_stat_data(struct stat_data *sd, struct stat *st)
|
|
|
|
|
{
|
|
|
|
|
sd->sd_ctime.sec = (unsigned int)st->st_ctime;
|
|
|
|
|
sd->sd_mtime.sec = (unsigned int)st->st_mtime;
|
|
|
|
|
sd->sd_ctime.nsec = ST_CTIME_NSEC(*st);
|
|
|
|
|
sd->sd_mtime.nsec = ST_MTIME_NSEC(*st);
|
|
|
|
|
sd->sd_dev = st->st_dev;
|
|
|
|
|
sd->sd_ino = st->st_ino;
|
|
|
|
|
sd->sd_uid = st->st_uid;
|
|
|
|
|
sd->sd_gid = st->st_gid;
|
|
|
|
|
sd->sd_size = st->st_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int match_stat_data(const struct stat_data *sd, struct stat *st)
|
|
|
|
|
{
|
|
|
|
|
int changed = 0;
|
|
|
|
|
|
|
|
|
|
if (sd->sd_mtime.sec != (unsigned int)st->st_mtime)
|
|
|
|
|
changed |= MTIME_CHANGED;
|
|
|
|
|
if (trust_ctime && check_stat &&
|
|
|
|
|
sd->sd_ctime.sec != (unsigned int)st->st_ctime)
|
|
|
|
|
changed |= CTIME_CHANGED;
|
|
|
|
|
|
|
|
|
|
#ifdef USE_NSEC
|
|
|
|
|
if (check_stat && sd->sd_mtime.nsec != ST_MTIME_NSEC(*st))
|
|
|
|
|
changed |= MTIME_CHANGED;
|
|
|
|
|
if (trust_ctime && check_stat &&
|
|
|
|
|
sd->sd_ctime.nsec != ST_CTIME_NSEC(*st))
|
|
|
|
|
changed |= CTIME_CHANGED;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (check_stat) {
|
|
|
|
|
if (sd->sd_uid != (unsigned int) st->st_uid ||
|
|
|
|
|
sd->sd_gid != (unsigned int) st->st_gid)
|
|
|
|
|
changed |= OWNER_CHANGED;
|
|
|
|
|
if (sd->sd_ino != (unsigned int) st->st_ino)
|
|
|
|
|
changed |= INODE_CHANGED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef USE_STDEV
|
|
|
|
|
/*
|
|
|
|
|
* st_dev breaks on network filesystems where different
|
|
|
|
|
* clients will have different views of what "device"
|
|
|
|
|
* the filesystem is on
|
|
|
|
|
*/
|
|
|
|
|
if (check_stat && sd->sd_dev != (unsigned int) st->st_dev)
|
|
|
|
|
changed |= INODE_CHANGED;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (sd->sd_size != (unsigned int) st->st_size)
|
|
|
|
|
changed |= DATA_CHANGED;
|
|
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-15 23:23:12 +02: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)
|
|
|
|
|
{
|
2013-06-20 10:37:50 +02:00
|
|
|
fill_stat_data(&ce->ce_stat_data, st);
|
2006-02-09 06:15:24 +01:00
|
|
|
|
|
|
|
|
if (assume_unchanged)
|
2008-01-15 01:03:17 +01:00
|
|
|
ce->ce_flags |= CE_VALID;
|
2008-01-19 08:45:24 +01:00
|
|
|
|
|
|
|
|
if (S_ISREG(st->st_mode))
|
|
|
|
|
ce_mark_uptodate(ce);
|
2005-05-15 23:23:12 +02:00
|
|
|
}
|
|
|
|
|
|
2013-06-02 17:46:52 +02:00
|
|
|
static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
|
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 09:02:15 +01:00
|
|
|
{
|
|
|
|
|
int match = -1;
|
|
|
|
|
int fd = open(ce->name, O_RDONLY);
|
|
|
|
|
|
|
|
|
|
if (fd >= 0) {
|
|
|
|
|
unsigned char sha1[20];
|
2011-05-08 10:47:33 +02:00
|
|
|
if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
|
2006-08-17 20:54:57 +02:00
|
|
|
match = hashcmp(sha1, ce->sha1);
|
2006-07-31 18:55:15 +02: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 09:02:15 +01:00
|
|
|
}
|
|
|
|
|
return match;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-02 17:46:52 +02:00
|
|
|
static int ce_compare_link(const 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 09:02:15 +01:00
|
|
|
{
|
|
|
|
|
int match = -1;
|
|
|
|
|
void *buffer;
|
|
|
|
|
unsigned long size;
|
2007-02-26 20:55:59 +01:00
|
|
|
enum object_type type;
|
2008-12-17 18:47:27 +01:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
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 09:02:15 +01:00
|
|
|
|
2008-12-17 18:47:27 +01:00
|
|
|
if (strbuf_readlink(&sb, ce->name, 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 09:02:15 +01:00
|
|
|
return -1;
|
2008-12-17 18:47:27 +01:00
|
|
|
|
2007-02-26 20:55:59 +01:00
|
|
|
buffer = read_sha1_file(ce->sha1, &type, &size);
|
2008-12-17 18:47:27 +01:00
|
|
|
if (buffer) {
|
|
|
|
|
if (size == sb.len)
|
|
|
|
|
match = memcmp(buffer, sb.buf, size);
|
|
|
|
|
free(buffer);
|
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 09:02:15 +01:00
|
|
|
}
|
2008-12-17 18:47:27 +01:00
|
|
|
strbuf_release(&sb);
|
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 09:02:15 +01:00
|
|
|
return match;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-02 17:46:52 +02:00
|
|
|
static int ce_compare_gitlink(const struct cache_entry *ce)
|
2007-04-10 06:20:29 +02:00
|
|
|
{
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We don't actually require that the .git directory
|
2007-05-21 22:08:28 +02:00
|
|
|
* under GITLINK directory be a valid git directory. It
|
2007-04-10 06:20:29 +02: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);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-02 17:46:52 +02:00
|
|
|
static int ce_modified_check_fs(const struct cache_entry *ce, struct stat *st)
|
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 09:02:15 +01:00
|
|
|
{
|
|
|
|
|
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 02:44:37 +01: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 09:02:15 +01:00
|
|
|
return DATA_CHANGED;
|
|
|
|
|
break;
|
2007-04-13 18:24:13 +02:00
|
|
|
case S_IFDIR:
|
2008-01-15 01:03:17 +01:00
|
|
|
if (S_ISGITLINK(ce->ce_mode))
|
2008-07-29 10:13:44 +02:00
|
|
|
return ce_compare_gitlink(ce) ? DATA_CHANGED : 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 09:02:15 +01:00
|
|
|
default:
|
|
|
|
|
return TYPE_CHANGED;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-02 17:46:52 +02:00
|
|
|
static int ce_match_stat_basic(const struct cache_entry *ce, struct stat *st)
|
2005-04-09 18:48:20 +02:00
|
|
|
{
|
|
|
|
|
unsigned int changed = 0;
|
|
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
|
|
|
|
return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED;
|
|
|
|
|
|
|
|
|
|
switch (ce->ce_mode & S_IFMT) {
|
2005-05-05 14:38:25 +02:00
|
|
|
case S_IFREG:
|
|
|
|
|
changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0;
|
2005-10-12 03:45:33 +02:00
|
|
|
/* We consider only the owner x bit to be relevant for
|
|
|
|
|
* "mode changes"
|
|
|
|
|
*/
|
|
|
|
|
if (trust_executable_bit &&
|
2008-01-15 01:03:17 +01:00
|
|
|
(0100 & (ce->ce_mode ^ st->st_mode)))
|
2005-05-06 15:45:01 +02:00
|
|
|
changed |= MODE_CHANGED;
|
2005-05-05 14:38:25 +02:00
|
|
|
break;
|
|
|
|
|
case S_IFLNK:
|
2007-03-02 22:11:30 +01:00
|
|
|
if (!S_ISLNK(st->st_mode) &&
|
|
|
|
|
(has_symlinks || !S_ISREG(st->st_mode)))
|
|
|
|
|
changed |= TYPE_CHANGED;
|
2005-05-05 14:38:25 +02:00
|
|
|
break;
|
2007-05-21 22:08:28 +02:00
|
|
|
case S_IFGITLINK:
|
2008-07-29 10:13:44 +02:00
|
|
|
/* We ignore most of the st_xxx fields for gitlinks */
|
2007-04-10 06:20:29 +02:00
|
|
|
if (!S_ISDIR(st->st_mode))
|
|
|
|
|
changed |= TYPE_CHANGED;
|
|
|
|
|
else if (ce_compare_gitlink(ce))
|
|
|
|
|
changed |= DATA_CHANGED;
|
2007-04-13 18:24:13 +02:00
|
|
|
return changed;
|
2005-05-05 14:38:25 +02:00
|
|
|
default:
|
2008-01-15 01:03:17 +01:00
|
|
|
die("internal error: ce_mode is %o", ce->ce_mode);
|
2005-05-05 14:38:25 +02:00
|
|
|
}
|
2005-05-23 00:08:15 +02:00
|
|
|
|
2013-06-20 10:37:50 +02:00
|
|
|
changed |= match_stat_data(&ce->ce_stat_data, st);
|
2005-09-20 00:11:15 +02:00
|
|
|
|
2008-06-10 19:44:43 +02:00
|
|
|
/* Racily smudged entry? */
|
2013-06-20 10:37:50 +02:00
|
|
|
if (!ce->ce_stat_data.sd_size) {
|
2008-06-10 19:44:43 +02:00
|
|
|
if (!is_empty_blob_sha1(ce->sha1))
|
|
|
|
|
changed |= DATA_CHANGED;
|
|
|
|
|
}
|
|
|
|
|
|
2005-12-20 21:12:18 +01:00
|
|
|
return changed;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-02 17:46:52 +02:00
|
|
|
static int is_racy_timestamp(const struct index_state *istate,
|
|
|
|
|
const struct cache_entry *ce)
|
2008-01-21 09:44:50 +01:00
|
|
|
{
|
2008-05-04 02:24:28 +02:00
|
|
|
return (!S_ISGITLINK(ce->ce_mode) &&
|
make USE_NSEC work as expected
Since the filesystem ext4 is now defined as stable in Linux v2.6.28,
and ext4 supports nanonsecond resolution timestamps natively, it is
time to make USE_NSEC work as expected.
This will make racy git situations less likely to happen. For 'git
checkout' this means it will be less likely that we have to open, read
the contents of the file into RAM, and check if file is really
modified or not. The result sould be a litle less used CPU time, less
pagefaults and a litle faster program, at least for 'git checkout'.
Since the number of possible racy git situations would increase when
disks gets faster, this patch would be more and more helpfull as times
go by. For a fast Solid State Disk, this patch should be helpfull.
Note that, when file operations starts to take less than 1 nanosecond,
one would again start to get more racy git situations.
For more info on racy git, see Documentation/technical/racy-git.txt
For more info on ext4, see http://kernelnewbies.org/Ext4
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-19 21:08:29 +01:00
|
|
|
istate->timestamp.sec &&
|
|
|
|
|
#ifdef USE_NSEC
|
|
|
|
|
/* nanosecond timestamped files can also be racy! */
|
2013-06-20 10:37:50 +02:00
|
|
|
(istate->timestamp.sec < ce->ce_stat_data.sd_mtime.sec ||
|
|
|
|
|
(istate->timestamp.sec == ce->ce_stat_data.sd_mtime.sec &&
|
|
|
|
|
istate->timestamp.nsec <= ce->ce_stat_data.sd_mtime.nsec))
|
make USE_NSEC work as expected
Since the filesystem ext4 is now defined as stable in Linux v2.6.28,
and ext4 supports nanonsecond resolution timestamps natively, it is
time to make USE_NSEC work as expected.
This will make racy git situations less likely to happen. For 'git
checkout' this means it will be less likely that we have to open, read
the contents of the file into RAM, and check if file is really
modified or not. The result sould be a litle less used CPU time, less
pagefaults and a litle faster program, at least for 'git checkout'.
Since the number of possible racy git situations would increase when
disks gets faster, this patch would be more and more helpfull as times
go by. For a fast Solid State Disk, this patch should be helpfull.
Note that, when file operations starts to take less than 1 nanosecond,
one would again start to get more racy git situations.
For more info on racy git, see Documentation/technical/racy-git.txt
For more info on ext4, see http://kernelnewbies.org/Ext4
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-19 21:08:29 +01:00
|
|
|
#else
|
2013-06-20 10:37:50 +02:00
|
|
|
istate->timestamp.sec <= ce->ce_stat_data.sd_mtime.sec
|
make USE_NSEC work as expected
Since the filesystem ext4 is now defined as stable in Linux v2.6.28,
and ext4 supports nanonsecond resolution timestamps natively, it is
time to make USE_NSEC work as expected.
This will make racy git situations less likely to happen. For 'git
checkout' this means it will be less likely that we have to open, read
the contents of the file into RAM, and check if file is really
modified or not. The result sould be a litle less used CPU time, less
pagefaults and a litle faster program, at least for 'git checkout'.
Since the number of possible racy git situations would increase when
disks gets faster, this patch would be more and more helpfull as times
go by. For a fast Solid State Disk, this patch should be helpfull.
Note that, when file operations starts to take less than 1 nanosecond,
one would again start to get more racy git situations.
For more info on racy git, see Documentation/technical/racy-git.txt
For more info on ext4, see http://kernelnewbies.org/Ext4
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-19 21:08:29 +01:00
|
|
|
#endif
|
|
|
|
|
);
|
2008-01-21 09:44:50 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-06 21:46:09 +01:00
|
|
|
int ie_match_stat(const struct index_state *istate,
|
2013-06-02 17:46:52 +02:00
|
|
|
const struct cache_entry *ce, struct stat *st,
|
2007-11-10 09:15:03 +01:00
|
|
|
unsigned int options)
|
2005-12-20 21:12:18 +01:00
|
|
|
{
|
2006-02-09 06:15:24 +01:00
|
|
|
unsigned int changed;
|
2007-11-10 09:15:03 +01:00
|
|
|
int ignore_valid = options & CE_MATCH_IGNORE_VALID;
|
2009-12-14 12:43:58 +01:00
|
|
|
int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;
|
2007-11-10 09:15:03 +01:00
|
|
|
int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY;
|
2006-02-09 06:15:24 +01:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If it's marked as always valid in the index, it's
|
|
|
|
|
* valid whatever the checked-out copy says.
|
2009-12-14 12:43:58 +01:00
|
|
|
*
|
|
|
|
|
* skip-worktree has the same effect with higher precedence
|
2006-02-09 06:15:24 +01:00
|
|
|
*/
|
2009-12-14 12:43:58 +01:00
|
|
|
if (!ignore_skip_worktree && ce_skip_worktree(ce))
|
|
|
|
|
return 0;
|
2008-01-15 01:03:17 +01:00
|
|
|
if (!ignore_valid && (ce->ce_flags & CE_VALID))
|
2006-02-09 06:15:24 +01:00
|
|
|
return 0;
|
|
|
|
|
|
2008-11-29 04:56:34 +01:00
|
|
|
/*
|
|
|
|
|
* Intent-to-add entries have not been added, so the index entry
|
|
|
|
|
* by definition never matches what is in the work tree until it
|
|
|
|
|
* actually gets added.
|
|
|
|
|
*/
|
|
|
|
|
if (ce->ce_flags & CE_INTENT_TO_ADD)
|
|
|
|
|
return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED;
|
|
|
|
|
|
2006-02-09 06:15:24 +01:00
|
|
|
changed = ce_match_stat_basic(ce, st);
|
2005-12-20 21:12:18 +01: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 09:02:15 +01: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 06:15:24 +01: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 09:02:15 +01:00
|
|
|
*/
|
2008-01-21 09:44:50 +01:00
|
|
|
if (!changed && is_racy_timestamp(istate, ce)) {
|
2006-08-16 06:38:07 +02:00
|
|
|
if (assume_racy_is_modified)
|
|
|
|
|
changed |= DATA_CHANGED;
|
|
|
|
|
else
|
|
|
|
|
changed |= ce_modified_check_fs(ce, st);
|
|
|
|
|
}
|
2005-09-20 00:11:15 +02: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 09:02:15 +01:00
|
|
|
return changed;
|
2005-09-20 00:11:15 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-06 21:46:09 +01:00
|
|
|
int ie_modified(const struct index_state *istate,
|
2013-06-02 17:46:52 +02:00
|
|
|
const struct cache_entry *ce,
|
|
|
|
|
struct stat *st, unsigned int options)
|
2005-09-20 00:11:15 +02: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 09:02:15 +01:00
|
|
|
int changed, changed_fs;
|
2007-11-10 09:15:03 +01:00
|
|
|
|
|
|
|
|
changed = ie_match_stat(istate, ce, st, options);
|
2005-09-20 00:11:15 +02: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;
|
|
|
|
|
|
2008-07-29 10:13:44 +02:00
|
|
|
/*
|
|
|
|
|
* Immediately after read-tree or update-index --cacheinfo,
|
|
|
|
|
* the length field is zero, as we have never even read the
|
|
|
|
|
* lstat(2) information once, and we cannot trust DATA_CHANGED
|
|
|
|
|
* returned by ie_match_stat() which in turn was returned by
|
|
|
|
|
* ce_match_stat_basic() to signal that the filesize of the
|
|
|
|
|
* blob changed. We have to actually go to the filesystem to
|
|
|
|
|
* see if the contents match, and if so, should answer "unchanged".
|
|
|
|
|
*
|
|
|
|
|
* The logic does not apply to gitlinks, as ce_match_stat_basic()
|
|
|
|
|
* already has checked the actual HEAD from the filesystem in the
|
|
|
|
|
* subproject. If ie_match_stat() already said it is different,
|
|
|
|
|
* then we know it is.
|
2005-09-20 00:11:15 +02:00
|
|
|
*/
|
2008-07-29 10:13:44 +02:00
|
|
|
if ((changed & DATA_CHANGED) &&
|
2013-06-20 10:37:50 +02:00
|
|
|
(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size != 0))
|
2005-09-20 00:11:15 +02: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 09:02:15 +01:00
|
|
|
changed_fs = ce_modified_check_fs(ce, st);
|
|
|
|
|
if (changed_fs)
|
|
|
|
|
return changed | changed_fs;
|
2005-09-20 00:11:15 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-20 18:09:18 +02: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-11 23:39:12 +02:00
|
|
|
if (!c1 && S_ISDIR(mode1))
|
2005-05-20 18:09:18 +02: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-11 23:39:12 +02:00
|
|
|
if (!c2 && S_ISDIR(mode2))
|
2005-05-20 18:09:18 +02:00
|
|
|
c2 = '/';
|
|
|
|
|
return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-06 03:25:10 +01:00
|
|
|
/*
|
|
|
|
|
* df_name_compare() is identical to base_name_compare(), except it
|
|
|
|
|
* compares conflicting directory/file entries as equal. Note that
|
|
|
|
|
* while a directory name compares as equal to a regular file, they
|
|
|
|
|
* then individually compare _differently_ to a filename that has
|
|
|
|
|
* a dot after the basename (because '\0' < '.' < '/').
|
|
|
|
|
*
|
|
|
|
|
* This is used by routines that want to traverse the git namespace
|
|
|
|
|
* but then handle conflicting entries together when possible.
|
|
|
|
|
*/
|
|
|
|
|
int df_name_compare(const char *name1, int len1, int mode1,
|
|
|
|
|
const char *name2, int len2, int mode2)
|
|
|
|
|
{
|
|
|
|
|
int len = len1 < len2 ? len1 : len2, cmp;
|
|
|
|
|
unsigned char c1, c2;
|
|
|
|
|
|
|
|
|
|
cmp = memcmp(name1, name2, len);
|
|
|
|
|
if (cmp)
|
|
|
|
|
return cmp;
|
|
|
|
|
/* Directories and files compare equal (same length, same name) */
|
|
|
|
|
if (len1 == len2)
|
|
|
|
|
return 0;
|
|
|
|
|
c1 = name1[len];
|
|
|
|
|
if (!c1 && S_ISDIR(mode1))
|
|
|
|
|
c1 = '/';
|
|
|
|
|
c2 = name2[len];
|
|
|
|
|
if (!c2 && S_ISDIR(mode2))
|
|
|
|
|
c2 = '/';
|
|
|
|
|
if (c1 == '/' && !c2)
|
|
|
|
|
return 0;
|
|
|
|
|
if (c2 == '/' && !c1)
|
|
|
|
|
return 0;
|
|
|
|
|
return c1 - c2;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-11 11:22:37 +02:00
|
|
|
int cache_name_stage_compare(const char *name1, int len1, int stage1, const char *name2, int len2, int stage2)
|
2005-04-09 18:26:55 +02:00
|
|
|
{
|
2012-07-11 11:22:37 +02:00
|
|
|
int len = len1 < len2 ? len1 : len2;
|
|
|
|
|
int cmp;
|
2005-04-09 18:26:55 +02:00
|
|
|
|
|
|
|
|
cmp = memcmp(name1, name2, len);
|
|
|
|
|
if (cmp)
|
|
|
|
|
return cmp;
|
|
|
|
|
if (len1 < len2)
|
|
|
|
|
return -1;
|
|
|
|
|
if (len1 > len2)
|
|
|
|
|
return 1;
|
2006-02-09 06:15:24 +01:00
|
|
|
|
2012-07-11 11:22:37 +02:00
|
|
|
if (stage1 < stage2)
|
2005-04-16 07:51:44 +02:00
|
|
|
return -1;
|
2012-07-11 11:22:37 +02:00
|
|
|
if (stage1 > stage2)
|
2005-04-16 07:51:44 +02:00
|
|
|
return 1;
|
2005-04-09 18:26:55 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-11 11:22:37 +02:00
|
|
|
int cache_name_compare(const char *name1, int len1, const char *name2, int len2)
|
|
|
|
|
{
|
|
|
|
|
return cache_name_stage_compare(name1, len1, 0, name2, len2, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-16 07:44:31 +02:00
|
|
|
static int index_name_stage_pos(const struct index_state *istate, const char *name, int namelen, int stage)
|
2005-04-09 18:26:55 +02:00
|
|
|
{
|
|
|
|
|
int first, last;
|
|
|
|
|
|
|
|
|
|
first = 0;
|
2007-04-02 08:26:07 +02:00
|
|
|
last = istate->cache_nr;
|
2005-04-09 18:26:55 +02:00
|
|
|
while (last > first) {
|
|
|
|
|
int next = (last + first) >> 1;
|
2007-04-02 08:26:07 +02:00
|
|
|
struct cache_entry *ce = istate->cache[next];
|
2012-07-11 11:22:37 +02:00
|
|
|
int cmp = cache_name_stage_compare(name, namelen, stage, ce->name, ce_namelen(ce), ce_stage(ce));
|
2005-04-09 18:26:55 +02:00
|
|
|
if (!cmp)
|
2005-04-11 07:06:50 +02:00
|
|
|
return next;
|
2005-04-09 18:26:55 +02:00
|
|
|
if (cmp < 0) {
|
|
|
|
|
last = next;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
first = next+1;
|
|
|
|
|
}
|
2005-04-11 07:06:50 +02:00
|
|
|
return -first-1;
|
2005-04-09 18:26:55 +02:00
|
|
|
}
|
|
|
|
|
|
2012-07-11 11:22:37 +02:00
|
|
|
int index_name_pos(const struct index_state *istate, const char *name, int namelen)
|
|
|
|
|
{
|
|
|
|
|
return index_name_stage_pos(istate, name, namelen, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 21:05:45 +02:00
|
|
|
/* Remove entry, return true if there are more entries to go.. */
|
2007-04-02 08:26:07 +02:00
|
|
|
int remove_index_entry_at(struct index_state *istate, int pos)
|
2005-04-16 21:05:45 +02: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 03:41:14 +01:00
|
|
|
struct cache_entry *ce = istate->cache[pos];
|
|
|
|
|
|
2009-12-25 09:30:51 +01:00
|
|
|
record_resolve_undo(istate, ce);
|
2013-02-28 00:57:48 +01:00
|
|
|
remove_name_hash(istate, ce);
|
2014-06-13 14:19:38 +02:00
|
|
|
save_or_free_index_entry(istate, ce);
|
2014-06-13 14:19:27 +02:00
|
|
|
istate->cache_changed |= CE_ENTRY_REMOVED;
|
2007-04-02 08:26:07 +02:00
|
|
|
istate->cache_nr--;
|
|
|
|
|
if (pos >= istate->cache_nr)
|
2005-04-16 21:05:45 +02:00
|
|
|
return 0;
|
2007-04-02 08:26:07 +02:00
|
|
|
memmove(istate->cache + pos,
|
|
|
|
|
istate->cache + pos + 1,
|
|
|
|
|
(istate->cache_nr - pos) * sizeof(struct cache_entry *));
|
2005-04-16 21:05:45 +02:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
check_updates(): effective removal of cache entries marked CE_REMOVE
Below is oprofile output from GIT command 'git chekcout -q my-v2.6.25'
(move from tag v2.6.27 to tag v2.6.25 of the Linux kernel):
CPU: Core 2, speed 1999.95 MHz (estimated)
Counted CPU_CLK_UNHALTED events (Clock cycles when not halted) with a unit
mask of 0x00 (Unhalted core cycles) count 20000
Counted INST_RETIRED_ANY_P events (number of instructions retired) with a
unit mask of 0x00 (No unit mask) count 20000
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
409247 100.000 342878 100.000 git
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
260476 63.6476 257843 75.1996 libz.so.1.2.3
100876 24.6492 64378 18.7758 kernel-2.6.28.4_2.vmlinux
30850 7.5382 7874 2.2964 libc-2.9.so
14775 3.6103 8390 2.4469 git
2020 0.4936 4325 1.2614 libcrypto.so.0.9.8
191 0.0467 32 0.0093 libpthread-2.9.so
58 0.0142 36 0.0105 ld-2.9.so
1 2.4e-04 0 0 libldap-2.3.so.0.2.31
Detail list of the top 20 function entries (libz counted in one blob):
CPU_CLK_UNHALTED INST_RETIRED_ANY_P
samples % samples % image name symbol name
260476 63.6862 257843 75.2725 libz.so.1.2.3 /lib/libz.so.1.2.3
16587 4.0555 3636 1.0615 libc-2.9.so memcpy
7710 1.8851 277 0.0809 libc-2.9.so memmove
3679 0.8995 1108 0.3235 kernel-2.6.28.4_2.vmlinux d_validate
3546 0.8670 2607 0.7611 kernel-2.6.28.4_2.vmlinux __getblk
3174 0.7760 1813 0.5293 libc-2.9.so _int_malloc
2396 0.5858 3681 1.0746 kernel-2.6.28.4_2.vmlinux copy_to_user
2270 0.5550 2528 0.7380 kernel-2.6.28.4_2.vmlinux __link_path_walk
2205 0.5391 1797 0.5246 kernel-2.6.28.4_2.vmlinux ext4_mark_iloc_dirty
2103 0.5142 1203 0.3512 kernel-2.6.28.4_2.vmlinux find_first_zero_bit
2077 0.5078 997 0.2911 kernel-2.6.28.4_2.vmlinux do_get_write_access
2070 0.5061 514 0.1501 git cache_name_compare
2043 0.4995 1501 0.4382 kernel-2.6.28.4_2.vmlinux rcu_irq_exit
2022 0.4944 1732 0.5056 kernel-2.6.28.4_2.vmlinux __ext4_get_inode_loc
2020 0.4939 4325 1.2626 libcrypto.so.0.9.8 /usr/lib/libcrypto.so.0.9.8
1965 0.4804 1384 0.4040 git patch_delta
1708 0.4176 984 0.2873 kernel-2.6.28.4_2.vmlinux rcu_sched_grace_period
1682 0.4112 727 0.2122 kernel-2.6.28.4_2.vmlinux sysfs_slab_alias
1659 0.4056 290 0.0847 git find_pack_entry_one
1480 0.3619 1307 0.3816 kernel-2.6.28.4_2.vmlinux ext4_writepage_trans_blocks
Notice the memmove line, where the CPU did 7710 / 277 = 27.8 cycles
per instruction, and compared to the total cycles spent inside the
source code of GIT for this command, all the memmove() calls
translates to (7710 * 100) / 14775 = 52.2% of this.
Retesting with a GIT program compiled for gcov usage, I found out that
the memmove() calls came from remove_index_entry_at() in read-cache.c,
where we have:
memmove(istate->cache + pos,
istate->cache + pos + 1,
(istate->cache_nr - pos) * sizeof(struct cache_entry *));
remove_index_entry_at() is called 4902 times from check_updates() in
unpack-trees.c, and each time called we move each cache_entry pointers
(from the removed one) one step to the left.
Since we have 28828 entries in the cache this time, and if we on
average move half of them each time, we in total move approximately
4902 * 0.5 * 28828 * 4 = 282 629 712 bytes, or twice this amount if
each pointer is 8 bytes (64 bit).
OK, is seems that the function check_updates() is called 28 times, so
the estimated guess above had been more correct if check_updates() had
been called only once, but the point is: we get lots of bytes moved.
To fix this, and use an O(N) algorithm instead, where N is the number
of cache_entries, we delete/remove all entries in one loop through all
entries.
From a retest, the new remove_marked_cache_entries() from the patch
below, ended up with the following output line from oprofile:
46 0.0105 15 0.0041 git remove_marked_cache_entries
If we can trust the numbers from oprofile in this case, we saved
approximately ((7710 - 46) * 20000) / (2 * 1000 * 1000 * 1000) = 0.077
seconds CPU time with this fix for this particular test. And notice
that now the CPU did only 46 / 15 = 3.1 cycles/instruction.
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-18 23:18:03 +01:00
|
|
|
/*
|
2013-07-29 10:18:21 +02:00
|
|
|
* Remove all cache entries marked for removal, that is where
|
check_updates(): effective removal of cache entries marked CE_REMOVE
Below is oprofile output from GIT command 'git chekcout -q my-v2.6.25'
(move from tag v2.6.27 to tag v2.6.25 of the Linux kernel):
CPU: Core 2, speed 1999.95 MHz (estimated)
Counted CPU_CLK_UNHALTED events (Clock cycles when not halted) with a unit
mask of 0x00 (Unhalted core cycles) count 20000
Counted INST_RETIRED_ANY_P events (number of instructions retired) with a
unit mask of 0x00 (No unit mask) count 20000
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
409247 100.000 342878 100.000 git
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
260476 63.6476 257843 75.1996 libz.so.1.2.3
100876 24.6492 64378 18.7758 kernel-2.6.28.4_2.vmlinux
30850 7.5382 7874 2.2964 libc-2.9.so
14775 3.6103 8390 2.4469 git
2020 0.4936 4325 1.2614 libcrypto.so.0.9.8
191 0.0467 32 0.0093 libpthread-2.9.so
58 0.0142 36 0.0105 ld-2.9.so
1 2.4e-04 0 0 libldap-2.3.so.0.2.31
Detail list of the top 20 function entries (libz counted in one blob):
CPU_CLK_UNHALTED INST_RETIRED_ANY_P
samples % samples % image name symbol name
260476 63.6862 257843 75.2725 libz.so.1.2.3 /lib/libz.so.1.2.3
16587 4.0555 3636 1.0615 libc-2.9.so memcpy
7710 1.8851 277 0.0809 libc-2.9.so memmove
3679 0.8995 1108 0.3235 kernel-2.6.28.4_2.vmlinux d_validate
3546 0.8670 2607 0.7611 kernel-2.6.28.4_2.vmlinux __getblk
3174 0.7760 1813 0.5293 libc-2.9.so _int_malloc
2396 0.5858 3681 1.0746 kernel-2.6.28.4_2.vmlinux copy_to_user
2270 0.5550 2528 0.7380 kernel-2.6.28.4_2.vmlinux __link_path_walk
2205 0.5391 1797 0.5246 kernel-2.6.28.4_2.vmlinux ext4_mark_iloc_dirty
2103 0.5142 1203 0.3512 kernel-2.6.28.4_2.vmlinux find_first_zero_bit
2077 0.5078 997 0.2911 kernel-2.6.28.4_2.vmlinux do_get_write_access
2070 0.5061 514 0.1501 git cache_name_compare
2043 0.4995 1501 0.4382 kernel-2.6.28.4_2.vmlinux rcu_irq_exit
2022 0.4944 1732 0.5056 kernel-2.6.28.4_2.vmlinux __ext4_get_inode_loc
2020 0.4939 4325 1.2626 libcrypto.so.0.9.8 /usr/lib/libcrypto.so.0.9.8
1965 0.4804 1384 0.4040 git patch_delta
1708 0.4176 984 0.2873 kernel-2.6.28.4_2.vmlinux rcu_sched_grace_period
1682 0.4112 727 0.2122 kernel-2.6.28.4_2.vmlinux sysfs_slab_alias
1659 0.4056 290 0.0847 git find_pack_entry_one
1480 0.3619 1307 0.3816 kernel-2.6.28.4_2.vmlinux ext4_writepage_trans_blocks
Notice the memmove line, where the CPU did 7710 / 277 = 27.8 cycles
per instruction, and compared to the total cycles spent inside the
source code of GIT for this command, all the memmove() calls
translates to (7710 * 100) / 14775 = 52.2% of this.
Retesting with a GIT program compiled for gcov usage, I found out that
the memmove() calls came from remove_index_entry_at() in read-cache.c,
where we have:
memmove(istate->cache + pos,
istate->cache + pos + 1,
(istate->cache_nr - pos) * sizeof(struct cache_entry *));
remove_index_entry_at() is called 4902 times from check_updates() in
unpack-trees.c, and each time called we move each cache_entry pointers
(from the removed one) one step to the left.
Since we have 28828 entries in the cache this time, and if we on
average move half of them each time, we in total move approximately
4902 * 0.5 * 28828 * 4 = 282 629 712 bytes, or twice this amount if
each pointer is 8 bytes (64 bit).
OK, is seems that the function check_updates() is called 28 times, so
the estimated guess above had been more correct if check_updates() had
been called only once, but the point is: we get lots of bytes moved.
To fix this, and use an O(N) algorithm instead, where N is the number
of cache_entries, we delete/remove all entries in one loop through all
entries.
From a retest, the new remove_marked_cache_entries() from the patch
below, ended up with the following output line from oprofile:
46 0.0105 15 0.0041 git remove_marked_cache_entries
If we can trust the numbers from oprofile in this case, we saved
approximately ((7710 - 46) * 20000) / (2 * 1000 * 1000 * 1000) = 0.077
seconds CPU time with this fix for this particular test. And notice
that now the CPU did only 46 / 15 = 3.1 cycles/instruction.
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-18 23:18:03 +01:00
|
|
|
* CE_REMOVE is set in ce_flags. This is much more effective than
|
|
|
|
|
* calling remove_index_entry_at() for each entry to be removed.
|
|
|
|
|
*/
|
|
|
|
|
void remove_marked_cache_entries(struct index_state *istate)
|
|
|
|
|
{
|
|
|
|
|
struct cache_entry **ce_array = istate->cache;
|
|
|
|
|
unsigned int i, j;
|
|
|
|
|
|
|
|
|
|
for (i = j = 0; i < istate->cache_nr; i++) {
|
2013-11-14 20:24:37 +01:00
|
|
|
if (ce_array[i]->ce_flags & CE_REMOVE) {
|
2013-02-28 00:57:48 +01:00
|
|
|
remove_name_hash(istate, ce_array[i]);
|
2014-06-13 14:19:38 +02:00
|
|
|
save_or_free_index_entry(istate, ce_array[i]);
|
2013-11-14 20:24:37 +01:00
|
|
|
}
|
check_updates(): effective removal of cache entries marked CE_REMOVE
Below is oprofile output from GIT command 'git chekcout -q my-v2.6.25'
(move from tag v2.6.27 to tag v2.6.25 of the Linux kernel):
CPU: Core 2, speed 1999.95 MHz (estimated)
Counted CPU_CLK_UNHALTED events (Clock cycles when not halted) with a unit
mask of 0x00 (Unhalted core cycles) count 20000
Counted INST_RETIRED_ANY_P events (number of instructions retired) with a
unit mask of 0x00 (No unit mask) count 20000
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
409247 100.000 342878 100.000 git
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
260476 63.6476 257843 75.1996 libz.so.1.2.3
100876 24.6492 64378 18.7758 kernel-2.6.28.4_2.vmlinux
30850 7.5382 7874 2.2964 libc-2.9.so
14775 3.6103 8390 2.4469 git
2020 0.4936 4325 1.2614 libcrypto.so.0.9.8
191 0.0467 32 0.0093 libpthread-2.9.so
58 0.0142 36 0.0105 ld-2.9.so
1 2.4e-04 0 0 libldap-2.3.so.0.2.31
Detail list of the top 20 function entries (libz counted in one blob):
CPU_CLK_UNHALTED INST_RETIRED_ANY_P
samples % samples % image name symbol name
260476 63.6862 257843 75.2725 libz.so.1.2.3 /lib/libz.so.1.2.3
16587 4.0555 3636 1.0615 libc-2.9.so memcpy
7710 1.8851 277 0.0809 libc-2.9.so memmove
3679 0.8995 1108 0.3235 kernel-2.6.28.4_2.vmlinux d_validate
3546 0.8670 2607 0.7611 kernel-2.6.28.4_2.vmlinux __getblk
3174 0.7760 1813 0.5293 libc-2.9.so _int_malloc
2396 0.5858 3681 1.0746 kernel-2.6.28.4_2.vmlinux copy_to_user
2270 0.5550 2528 0.7380 kernel-2.6.28.4_2.vmlinux __link_path_walk
2205 0.5391 1797 0.5246 kernel-2.6.28.4_2.vmlinux ext4_mark_iloc_dirty
2103 0.5142 1203 0.3512 kernel-2.6.28.4_2.vmlinux find_first_zero_bit
2077 0.5078 997 0.2911 kernel-2.6.28.4_2.vmlinux do_get_write_access
2070 0.5061 514 0.1501 git cache_name_compare
2043 0.4995 1501 0.4382 kernel-2.6.28.4_2.vmlinux rcu_irq_exit
2022 0.4944 1732 0.5056 kernel-2.6.28.4_2.vmlinux __ext4_get_inode_loc
2020 0.4939 4325 1.2626 libcrypto.so.0.9.8 /usr/lib/libcrypto.so.0.9.8
1965 0.4804 1384 0.4040 git patch_delta
1708 0.4176 984 0.2873 kernel-2.6.28.4_2.vmlinux rcu_sched_grace_period
1682 0.4112 727 0.2122 kernel-2.6.28.4_2.vmlinux sysfs_slab_alias
1659 0.4056 290 0.0847 git find_pack_entry_one
1480 0.3619 1307 0.3816 kernel-2.6.28.4_2.vmlinux ext4_writepage_trans_blocks
Notice the memmove line, where the CPU did 7710 / 277 = 27.8 cycles
per instruction, and compared to the total cycles spent inside the
source code of GIT for this command, all the memmove() calls
translates to (7710 * 100) / 14775 = 52.2% of this.
Retesting with a GIT program compiled for gcov usage, I found out that
the memmove() calls came from remove_index_entry_at() in read-cache.c,
where we have:
memmove(istate->cache + pos,
istate->cache + pos + 1,
(istate->cache_nr - pos) * sizeof(struct cache_entry *));
remove_index_entry_at() is called 4902 times from check_updates() in
unpack-trees.c, and each time called we move each cache_entry pointers
(from the removed one) one step to the left.
Since we have 28828 entries in the cache this time, and if we on
average move half of them each time, we in total move approximately
4902 * 0.5 * 28828 * 4 = 282 629 712 bytes, or twice this amount if
each pointer is 8 bytes (64 bit).
OK, is seems that the function check_updates() is called 28 times, so
the estimated guess above had been more correct if check_updates() had
been called only once, but the point is: we get lots of bytes moved.
To fix this, and use an O(N) algorithm instead, where N is the number
of cache_entries, we delete/remove all entries in one loop through all
entries.
From a retest, the new remove_marked_cache_entries() from the patch
below, ended up with the following output line from oprofile:
46 0.0105 15 0.0041 git remove_marked_cache_entries
If we can trust the numbers from oprofile in this case, we saved
approximately ((7710 - 46) * 20000) / (2 * 1000 * 1000 * 1000) = 0.077
seconds CPU time with this fix for this particular test. And notice
that now the CPU did only 46 / 15 = 3.1 cycles/instruction.
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-18 23:18:03 +01:00
|
|
|
else
|
|
|
|
|
ce_array[j++] = ce_array[i];
|
|
|
|
|
}
|
2014-06-13 14:19:26 +02:00
|
|
|
if (j == istate->cache_nr)
|
|
|
|
|
return;
|
2014-06-13 14:19:27 +02:00
|
|
|
istate->cache_changed |= CE_ENTRY_REMOVED;
|
check_updates(): effective removal of cache entries marked CE_REMOVE
Below is oprofile output from GIT command 'git chekcout -q my-v2.6.25'
(move from tag v2.6.27 to tag v2.6.25 of the Linux kernel):
CPU: Core 2, speed 1999.95 MHz (estimated)
Counted CPU_CLK_UNHALTED events (Clock cycles when not halted) with a unit
mask of 0x00 (Unhalted core cycles) count 20000
Counted INST_RETIRED_ANY_P events (number of instructions retired) with a
unit mask of 0x00 (No unit mask) count 20000
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
409247 100.000 342878 100.000 git
CPU_CLK_UNHALT...|INST_RETIRED:2...|
samples| %| samples| %|
------------------------------------
260476 63.6476 257843 75.1996 libz.so.1.2.3
100876 24.6492 64378 18.7758 kernel-2.6.28.4_2.vmlinux
30850 7.5382 7874 2.2964 libc-2.9.so
14775 3.6103 8390 2.4469 git
2020 0.4936 4325 1.2614 libcrypto.so.0.9.8
191 0.0467 32 0.0093 libpthread-2.9.so
58 0.0142 36 0.0105 ld-2.9.so
1 2.4e-04 0 0 libldap-2.3.so.0.2.31
Detail list of the top 20 function entries (libz counted in one blob):
CPU_CLK_UNHALTED INST_RETIRED_ANY_P
samples % samples % image name symbol name
260476 63.6862 257843 75.2725 libz.so.1.2.3 /lib/libz.so.1.2.3
16587 4.0555 3636 1.0615 libc-2.9.so memcpy
7710 1.8851 277 0.0809 libc-2.9.so memmove
3679 0.8995 1108 0.3235 kernel-2.6.28.4_2.vmlinux d_validate
3546 0.8670 2607 0.7611 kernel-2.6.28.4_2.vmlinux __getblk
3174 0.7760 1813 0.5293 libc-2.9.so _int_malloc
2396 0.5858 3681 1.0746 kernel-2.6.28.4_2.vmlinux copy_to_user
2270 0.5550 2528 0.7380 kernel-2.6.28.4_2.vmlinux __link_path_walk
2205 0.5391 1797 0.5246 kernel-2.6.28.4_2.vmlinux ext4_mark_iloc_dirty
2103 0.5142 1203 0.3512 kernel-2.6.28.4_2.vmlinux find_first_zero_bit
2077 0.5078 997 0.2911 kernel-2.6.28.4_2.vmlinux do_get_write_access
2070 0.5061 514 0.1501 git cache_name_compare
2043 0.4995 1501 0.4382 kernel-2.6.28.4_2.vmlinux rcu_irq_exit
2022 0.4944 1732 0.5056 kernel-2.6.28.4_2.vmlinux __ext4_get_inode_loc
2020 0.4939 4325 1.2626 libcrypto.so.0.9.8 /usr/lib/libcrypto.so.0.9.8
1965 0.4804 1384 0.4040 git patch_delta
1708 0.4176 984 0.2873 kernel-2.6.28.4_2.vmlinux rcu_sched_grace_period
1682 0.4112 727 0.2122 kernel-2.6.28.4_2.vmlinux sysfs_slab_alias
1659 0.4056 290 0.0847 git find_pack_entry_one
1480 0.3619 1307 0.3816 kernel-2.6.28.4_2.vmlinux ext4_writepage_trans_blocks
Notice the memmove line, where the CPU did 7710 / 277 = 27.8 cycles
per instruction, and compared to the total cycles spent inside the
source code of GIT for this command, all the memmove() calls
translates to (7710 * 100) / 14775 = 52.2% of this.
Retesting with a GIT program compiled for gcov usage, I found out that
the memmove() calls came from remove_index_entry_at() in read-cache.c,
where we have:
memmove(istate->cache + pos,
istate->cache + pos + 1,
(istate->cache_nr - pos) * sizeof(struct cache_entry *));
remove_index_entry_at() is called 4902 times from check_updates() in
unpack-trees.c, and each time called we move each cache_entry pointers
(from the removed one) one step to the left.
Since we have 28828 entries in the cache this time, and if we on
average move half of them each time, we in total move approximately
4902 * 0.5 * 28828 * 4 = 282 629 712 bytes, or twice this amount if
each pointer is 8 bytes (64 bit).
OK, is seems that the function check_updates() is called 28 times, so
the estimated guess above had been more correct if check_updates() had
been called only once, but the point is: we get lots of bytes moved.
To fix this, and use an O(N) algorithm instead, where N is the number
of cache_entries, we delete/remove all entries in one loop through all
entries.
From a retest, the new remove_marked_cache_entries() from the patch
below, ended up with the following output line from oprofile:
46 0.0105 15 0.0041 git remove_marked_cache_entries
If we can trust the numbers from oprofile in this case, we saved
approximately ((7710 - 46) * 20000) / (2 * 1000 * 1000 * 1000) = 0.077
seconds CPU time with this fix for this particular test. And notice
that now the CPU did only 46 / 15 = 3.1 cycles/instruction.
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-18 23:18:03 +01:00
|
|
|
istate->cache_nr = j;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 08:26:07 +02:00
|
|
|
int remove_file_from_index(struct index_state *istate, const char *path)
|
2005-04-09 21:09:27 +02:00
|
|
|
{
|
2007-04-02 08:26:07 +02:00
|
|
|
int pos = index_name_pos(istate, path, strlen(path));
|
2005-04-17 18:53:35 +02:00
|
|
|
if (pos < 0)
|
|
|
|
|
pos = -pos-1;
|
2014-06-13 14:19:31 +02:00
|
|
|
cache_tree_invalidate_path(istate, path);
|
2007-04-02 08:26:07 +02:00
|
|
|
while (pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path))
|
|
|
|
|
remove_index_entry_at(istate, pos);
|
2005-04-09 21:09:27 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-06-29 19:32:46 +02: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;
|
|
|
|
|
}
|
|
|
|
|
|
Make git-add behave more sensibly in a case-insensitive environment
This expands on the previous patch, and allows "git add" to sanely handle
a filename that has changed case, keeping the case in the index constant,
and avoiding aliases.
In particular, if you have an index entry called "File", but the
checked-out tree is case-corrupted and has an entry called "file"
instead, doing a
git add .
(or naming "file" explicitly) will automatically notice that we have an
alias, and will replace the name "file" with the existing index
capitalization (ie "File").
However, if we actually have *both* a file called "File" and one called
"file", and they don't have the same lstat() information (ie we're on a
case-sensitive filesystem but have the "core.ignorecase" flag set), we
will error out if we try to add them both.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-22 22:22:44 +01:00
|
|
|
static int different_name(struct cache_entry *ce, struct cache_entry *alias)
|
|
|
|
|
{
|
|
|
|
|
int len = ce_namelen(ce);
|
|
|
|
|
return ce_namelen(alias) != len || memcmp(ce->name, alias->name, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we add a filename that aliases in the cache, we will use the
|
|
|
|
|
* name that we already have - but we don't want to update the same
|
|
|
|
|
* alias twice, because that implies that there were actually two
|
|
|
|
|
* different files with aliasing names!
|
|
|
|
|
*
|
|
|
|
|
* So we use the CE_ADDED flag to verify that the alias was an old
|
|
|
|
|
* one before we accept it as
|
|
|
|
|
*/
|
2014-06-13 14:19:38 +02:00
|
|
|
static struct cache_entry *create_alias_ce(struct index_state *istate,
|
|
|
|
|
struct cache_entry *ce,
|
|
|
|
|
struct cache_entry *alias)
|
Make git-add behave more sensibly in a case-insensitive environment
This expands on the previous patch, and allows "git add" to sanely handle
a filename that has changed case, keeping the case in the index constant,
and avoiding aliases.
In particular, if you have an index entry called "File", but the
checked-out tree is case-corrupted and has an entry called "file"
instead, doing a
git add .
(or naming "file" explicitly) will automatically notice that we have an
alias, and will replace the name "file" with the existing index
capitalization (ie "File").
However, if we actually have *both* a file called "File" and one called
"file", and they don't have the same lstat() information (ie we're on a
case-sensitive filesystem but have the "core.ignorecase" flag set), we
will error out if we try to add them both.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-22 22:22:44 +01:00
|
|
|
{
|
|
|
|
|
int len;
|
|
|
|
|
struct cache_entry *new;
|
|
|
|
|
|
|
|
|
|
if (alias->ce_flags & CE_ADDED)
|
|
|
|
|
die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name);
|
|
|
|
|
|
|
|
|
|
/* Ok, create the new entry using the name of the existing alias */
|
|
|
|
|
len = ce_namelen(alias);
|
|
|
|
|
new = xcalloc(1, cache_entry_size(len));
|
|
|
|
|
memcpy(new->name, alias->name, len);
|
|
|
|
|
copy_cache_entry(new, ce);
|
2014-06-13 14:19:38 +02:00
|
|
|
save_or_free_index_entry(istate, ce);
|
Make git-add behave more sensibly in a case-insensitive environment
This expands on the previous patch, and allows "git add" to sanely handle
a filename that has changed case, keeping the case in the index constant,
and avoiding aliases.
In particular, if you have an index entry called "File", but the
checked-out tree is case-corrupted and has an entry called "file"
instead, doing a
git add .
(or naming "file" explicitly) will automatically notice that we have an
alias, and will replace the name "file" with the existing index
capitalization (ie "File").
However, if we actually have *both* a file called "File" and one called
"file", and they don't have the same lstat() information (ie we're on a
case-sensitive filesystem but have the "core.ignorecase" flag set), we
will error out if we try to add them both.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-22 22:22:44 +01:00
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-04 03:20:09 +01:00
|
|
|
void set_object_name_for_intent_to_add_entry(struct cache_entry *ce)
|
2008-08-21 10:44:53 +02:00
|
|
|
{
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
if (write_sha1_file("", 0, blob_type, sha1))
|
|
|
|
|
die("cannot create an empty blob in the object database");
|
|
|
|
|
hashcpy(ce->sha1, sha1);
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-21 21:04:34 +02:00
|
|
|
int add_to_index(struct index_state *istate, const char *path, struct stat *st, int flags)
|
2006-07-26 03:52:35 +02:00
|
|
|
{
|
2008-05-21 21:04:34 +02:00
|
|
|
int size, namelen, was_same;
|
2008-05-09 18:11:43 +02:00
|
|
|
mode_t st_mode = st->st_mode;
|
2008-03-22 21:19:49 +01:00
|
|
|
struct cache_entry *ce, *alias;
|
2009-12-14 12:43:58 +01:00
|
|
|
unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY;
|
2008-05-21 21:04:34 +02:00
|
|
|
int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND);
|
|
|
|
|
int pretend = flags & ADD_CACHE_PRETEND;
|
2008-08-21 10:44:53 +02:00
|
|
|
int intent_only = flags & ADD_CACHE_INTENT;
|
|
|
|
|
int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE|
|
|
|
|
|
(intent_only ? ADD_CACHE_NEW_ONLY : 0));
|
2006-07-26 03:52:35 +02:00
|
|
|
|
2008-05-09 18:11:43 +02:00
|
|
|
if (!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode))
|
2008-05-12 19:57:45 +02:00
|
|
|
return error("%s: can only add regular files, symbolic links or git-directories", path);
|
2006-07-26 03:52:35 +02:00
|
|
|
|
|
|
|
|
namelen = strlen(path);
|
2008-05-09 18:11:43 +02:00
|
|
|
if (S_ISDIR(st_mode)) {
|
2007-04-11 23:49:44 +02:00
|
|
|
while (namelen && path[namelen-1] == '/')
|
|
|
|
|
namelen--;
|
|
|
|
|
}
|
2006-07-26 03:52:35 +02:00
|
|
|
size = cache_entry_size(namelen);
|
|
|
|
|
ce = xcalloc(1, size);
|
|
|
|
|
memcpy(ce->name, path, namelen);
|
2012-07-11 11:22:37 +02:00
|
|
|
ce->ce_namelen = namelen;
|
2008-08-21 10:44:53 +02:00
|
|
|
if (!intent_only)
|
|
|
|
|
fill_stat_cache_info(ce, st);
|
2008-11-29 04:55:25 +01:00
|
|
|
else
|
|
|
|
|
ce->ce_flags |= CE_INTENT_TO_ADD;
|
2006-07-26 03:52:35 +02:00
|
|
|
|
2007-03-02 22:11:30 +01:00
|
|
|
if (trust_executable_bit && has_symlinks)
|
2008-05-09 18:11:43 +02:00
|
|
|
ce->ce_mode = create_ce_mode(st_mode);
|
2007-02-17 07:43:48 +01:00
|
|
|
else {
|
2007-03-02 22:11:30 +01:00
|
|
|
/* If there is an existing entry, pick the mode bits and type
|
|
|
|
|
* from it, otherwise assume unexecutable regular file.
|
2006-07-26 03:52:35 +02:00
|
|
|
*/
|
2007-02-17 07:43:48 +01:00
|
|
|
struct cache_entry *ent;
|
2007-06-29 19:32:46 +02:00
|
|
|
int pos = index_name_pos_also_unmerged(istate, path, namelen);
|
2007-02-17 07:43:48 +01:00
|
|
|
|
2007-04-02 08:26:07 +02:00
|
|
|
ent = (0 <= pos) ? istate->cache[pos] : NULL;
|
2008-05-09 18:11:43 +02:00
|
|
|
ce->ce_mode = ce_mode_from_stat(ent, st_mode);
|
2006-07-26 03:52:35 +02:00
|
|
|
}
|
|
|
|
|
|
Support case folding for git add when core.ignorecase=true
When MyDir/ABC/filea.txt is added to Git, the disk directory MyDir/ABC/
is renamed to mydir/aBc/, and then mydir/aBc/fileb.txt is added, the
index will contain MyDir/ABC/filea.txt and mydir/aBc/fileb.txt. Although
the earlier portions of this patch series account for those differences
in case, this patch makes the pathing consistent by folding the case of
newly added files against the first file added with that path.
In read-cache.c's add_to_index(), the index_name_exists() support used
for git status's case insensitive directory lookups is used to find the
proper directory case according to what the user already checked in.
That is, MyDir/ABC/'s case is used to alter the stored path for
fileb.txt to MyDir/ABC/fileb.txt (instead of mydir/aBc/fileb.txt).
This is especially important when cloning a repository to a case
sensitive file system. MyDir/ABC/ and mydir/aBc/ exist in the same
directory on a Windows machine, but on Linux, the files exist in two
separate directories. The update to add_to_index(), in effect, treats a
Windows file system as case sensitive by making path case consistent.
Signed-off-by: Joshua Jensen <jjensen@workspacewhiz.com>
Signed-off-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-10-03 11:56:45 +02:00
|
|
|
/* When core.ignorecase=true, determine if a directory of the same name but differing
|
|
|
|
|
* case already exists within the Git repository. If it does, ensure the directory
|
|
|
|
|
* case of the file being added to the repository matches (is folded into) the existing
|
|
|
|
|
* entry's directory case.
|
|
|
|
|
*/
|
|
|
|
|
if (ignore_case) {
|
|
|
|
|
const char *startPtr = ce->name;
|
|
|
|
|
const char *ptr = startPtr;
|
|
|
|
|
while (*ptr) {
|
|
|
|
|
while (*ptr && *ptr != '/')
|
|
|
|
|
++ptr;
|
|
|
|
|
if (*ptr == '/') {
|
|
|
|
|
struct cache_entry *foundce;
|
|
|
|
|
++ptr;
|
name-hash: stop storing trailing '/' on paths in index_state.dir_hash
When 5102c617 (Add case insensitivity support for directories when using
git status, 2010-10-03) added directories to the name-hash there was
only a single hash table in which both real cache entries and leading
directory prefixes were registered. To distinguish between the two types
of entries, directories were stored with a trailing '/'.
2092678c (name-hash.c: fix endless loop with core.ignorecase=true,
2013-02-28), however, moved directories to a separate hash table
(index_state.dir_hash) but retained the (now) redundant trailing '/',
thus callers continue to bear the burden of ensuring the slash's
presence before searching the index for a directory. Eliminate this
redundancy by storing paths in the dir-hash without the trailing '/'.
An important benefit of this change is that it eliminates undocumented
and dangerous behavior of dir.c:directory_exists_in_index_icase() in
which it assumes not only that it can validly access one character
beyond the end of its incoming directory argument, but also that that
character will unconditionally be a '/'. This perilous behavior was
"tolerated" because the string passed in by its lone caller always had a
'/' in that position, however, things broke [1] when 2eac2a4c (ls-files
-k: a directory only can be killed if the index has a non-directory,
2013-08-15) added a new caller which failed to respect the undocumented
assumption.
[1]: http://thread.gmane.org/gmane.comp.version-control.git/232727
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-09-17 09:06:16 +02:00
|
|
|
foundce = index_dir_exists(istate, ce->name, ptr - ce->name - 1);
|
Support case folding for git add when core.ignorecase=true
When MyDir/ABC/filea.txt is added to Git, the disk directory MyDir/ABC/
is renamed to mydir/aBc/, and then mydir/aBc/fileb.txt is added, the
index will contain MyDir/ABC/filea.txt and mydir/aBc/fileb.txt. Although
the earlier portions of this patch series account for those differences
in case, this patch makes the pathing consistent by folding the case of
newly added files against the first file added with that path.
In read-cache.c's add_to_index(), the index_name_exists() support used
for git status's case insensitive directory lookups is used to find the
proper directory case according to what the user already checked in.
That is, MyDir/ABC/'s case is used to alter the stored path for
fileb.txt to MyDir/ABC/fileb.txt (instead of mydir/aBc/fileb.txt).
This is especially important when cloning a repository to a case
sensitive file system. MyDir/ABC/ and mydir/aBc/ exist in the same
directory on a Windows machine, but on Linux, the files exist in two
separate directories. The update to add_to_index(), in effect, treats a
Windows file system as case sensitive by making path case consistent.
Signed-off-by: Joshua Jensen <jjensen@workspacewhiz.com>
Signed-off-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-10-03 11:56:45 +02:00
|
|
|
if (foundce) {
|
|
|
|
|
memcpy((void *)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr);
|
|
|
|
|
startPtr = ptr;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-17 09:06:15 +02:00
|
|
|
alias = index_file_exists(istate, ce->name, ce_namelen(ce), ignore_case);
|
2008-05-09 18:11:43 +02:00
|
|
|
if (alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) {
|
2007-07-31 02:12:58 +02:00
|
|
|
/* Nothing changed, really */
|
|
|
|
|
free(ce);
|
2010-01-24 09:10:20 +01:00
|
|
|
if (!S_ISGITLINK(alias->ce_mode))
|
|
|
|
|
ce_mark_uptodate(alias);
|
Make git-add behave more sensibly in a case-insensitive environment
This expands on the previous patch, and allows "git add" to sanely handle
a filename that has changed case, keeping the case in the index constant,
and avoiding aliases.
In particular, if you have an index entry called "File", but the
checked-out tree is case-corrupted and has an entry called "file"
instead, doing a
git add .
(or naming "file" explicitly) will automatically notice that we have an
alias, and will replace the name "file" with the existing index
capitalization (ie "File").
However, if we actually have *both* a file called "File" and one called
"file", and they don't have the same lstat() information (ie we're on a
case-sensitive filesystem but have the "core.ignorecase" flag set), we
will error out if we try to add them both.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-22 22:22:44 +01:00
|
|
|
alias->ce_flags |= CE_ADDED;
|
2007-07-31 02:12:58 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
2008-08-21 10:44:53 +02:00
|
|
|
if (!intent_only) {
|
2011-05-08 10:47:33 +02:00
|
|
|
if (index_path(ce->sha1, path, st, HASH_WRITE_OBJECT))
|
2008-08-21 10:44:53 +02:00
|
|
|
return error("unable to index file %s", path);
|
|
|
|
|
} else
|
2014-02-04 03:20:09 +01:00
|
|
|
set_object_name_for_intent_to_add_entry(ce);
|
2008-08-21 10:44:53 +02:00
|
|
|
|
Make git-add behave more sensibly in a case-insensitive environment
This expands on the previous patch, and allows "git add" to sanely handle
a filename that has changed case, keeping the case in the index constant,
and avoiding aliases.
In particular, if you have an index entry called "File", but the
checked-out tree is case-corrupted and has an entry called "file"
instead, doing a
git add .
(or naming "file" explicitly) will automatically notice that we have an
alias, and will replace the name "file" with the existing index
capitalization (ie "File").
However, if we actually have *both* a file called "File" and one called
"file", and they don't have the same lstat() information (ie we're on a
case-sensitive filesystem but have the "core.ignorecase" flag set), we
will error out if we try to add them both.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-22 22:22:44 +01:00
|
|
|
if (ignore_case && alias && different_name(ce, alias))
|
2014-06-13 14:19:38 +02:00
|
|
|
ce = create_alias_ce(istate, ce, alias);
|
Make git-add behave more sensibly in a case-insensitive environment
This expands on the previous patch, and allows "git add" to sanely handle
a filename that has changed case, keeping the case in the index constant,
and avoiding aliases.
In particular, if you have an index entry called "File", but the
checked-out tree is case-corrupted and has an entry called "file"
instead, doing a
git add .
(or naming "file" explicitly) will automatically notice that we have an
alias, and will replace the name "file" with the existing index
capitalization (ie "File").
However, if we actually have *both* a file called "File" and one called
"file", and they don't have the same lstat() information (ie we're on a
case-sensitive filesystem but have the "core.ignorecase" flag set), we
will error out if we try to add them both.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-22 22:22:44 +01:00
|
|
|
ce->ce_flags |= CE_ADDED;
|
2008-05-21 21:04:34 +02:00
|
|
|
|
2008-07-17 03:48:58 +02:00
|
|
|
/* It was suspected to be racily clean, but it turns out to be Ok */
|
2008-05-21 21:04:34 +02:00
|
|
|
was_same = (alias &&
|
|
|
|
|
!ce_stage(alias) &&
|
|
|
|
|
!hashcmp(alias->sha1, ce->sha1) &&
|
|
|
|
|
ce->ce_mode == alias->ce_mode);
|
|
|
|
|
|
|
|
|
|
if (pretend)
|
|
|
|
|
;
|
2008-08-21 10:44:53 +02:00
|
|
|
else if (add_index_entry(istate, ce, add_option))
|
2008-05-12 19:57:45 +02:00
|
|
|
return error("unable to add %s to index",path);
|
2008-05-21 21:04:34 +02:00
|
|
|
if (verbose && !was_same)
|
2006-07-26 03:52:35 +02:00
|
|
|
printf("add '%s'\n", path);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-21 21:04:34 +02:00
|
|
|
int add_file_to_index(struct index_state *istate, const char *path, int flags)
|
2008-05-09 18:11:43 +02:00
|
|
|
{
|
|
|
|
|
struct stat st;
|
|
|
|
|
if (lstat(path, &st))
|
2009-06-27 17:58:46 +02:00
|
|
|
die_errno("unable to stat '%s'", path);
|
2008-05-21 21:04:34 +02:00
|
|
|
return add_to_index(istate, path, &st, flags);
|
2008-05-09 18:11:43 +02:00
|
|
|
}
|
|
|
|
|
|
2007-09-11 05:17:28 +02:00
|
|
|
struct cache_entry *make_cache_entry(unsigned int mode,
|
|
|
|
|
const unsigned char *sha1, const char *path, int stage,
|
2014-01-27 15:45:08 +01:00
|
|
|
unsigned int refresh_options)
|
2007-09-11 05:17:28 +02:00
|
|
|
{
|
|
|
|
|
int size, len;
|
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
2008-10-11 18:39:37 +02:00
|
|
|
if (!verify_path(path)) {
|
|
|
|
|
error("Invalid path '%s'", path);
|
2007-09-11 05:17:28 +02:00
|
|
|
return NULL;
|
2008-10-11 18:39:37 +02:00
|
|
|
}
|
2007-09-11 05:17:28 +02:00
|
|
|
|
|
|
|
|
len = strlen(path);
|
|
|
|
|
size = cache_entry_size(len);
|
|
|
|
|
ce = xcalloc(1, size);
|
|
|
|
|
|
|
|
|
|
hashcpy(ce->sha1, sha1);
|
|
|
|
|
memcpy(ce->name, path, len);
|
2012-07-11 11:22:37 +02:00
|
|
|
ce->ce_flags = create_ce_flags(stage);
|
|
|
|
|
ce->ce_namelen = len;
|
2007-09-11 05:17:28 +02:00
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
|
|
|
|
|
2014-01-27 15:45:08 +01:00
|
|
|
return refresh_cache_entry(ce, refresh_options);
|
2007-09-11 05:17:28 +02:00
|
|
|
}
|
|
|
|
|
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
int ce_same_name(const struct cache_entry *a, const struct cache_entry *b)
|
2005-04-16 21:05:45 +02:00
|
|
|
{
|
|
|
|
|
int len = ce_namelen(a);
|
|
|
|
|
return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-18 21:07:31 +02: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.
|
|
|
|
|
*/
|
2011-06-08 14:04:41 +02:00
|
|
|
|
2006-05-18 21:07:31 +02:00
|
|
|
/* "." is not allowed */
|
2011-06-08 14:04:41 +02:00
|
|
|
if (*rest == '\0' || is_dir_sep(*rest))
|
2006-05-18 21:07:31 +02:00
|
|
|
return 0;
|
|
|
|
|
|
2011-06-08 14:04:41 +02:00
|
|
|
switch (*rest) {
|
2006-05-18 21:07:31 +02:00
|
|
|
/*
|
|
|
|
|
* ".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 '.':
|
2011-06-08 14:04:41 +02:00
|
|
|
if (rest[1] == '\0' || is_dir_sep(rest[1]))
|
2006-05-18 21:07:31 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int verify_path(const char *path)
|
|
|
|
|
{
|
|
|
|
|
char c;
|
|
|
|
|
|
2011-05-27 18:00:40 +02:00
|
|
|
if (has_dos_drive_prefix(path))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2006-05-18 21:07:31 +02:00
|
|
|
goto inside;
|
|
|
|
|
for (;;) {
|
|
|
|
|
if (!c)
|
|
|
|
|
return 1;
|
2011-05-27 18:00:40 +02:00
|
|
|
if (is_dir_sep(c)) {
|
2006-05-18 21:07:31 +02:00
|
|
|
inside:
|
|
|
|
|
c = *path++;
|
2011-06-07 05:49:06 +02:00
|
|
|
if ((c == '.' && !verify_dotfile(path)) ||
|
|
|
|
|
is_dir_sep(c) || c == '\0')
|
|
|
|
|
return 0;
|
2006-05-18 21:07:31 +02:00
|
|
|
}
|
|
|
|
|
c = *path++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-06-19 05:21:34 +02: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 06:48:12 +02:00
|
|
|
*/
|
2007-04-02 08:26:07 +02:00
|
|
|
static int has_file_name(struct index_state *istate,
|
|
|
|
|
const struct cache_entry *ce, int pos, int ok_to_replace)
|
2005-05-08 06:48:12 +02:00
|
|
|
{
|
2005-06-19 05:21:34 +02:00
|
|
|
int retval = 0;
|
|
|
|
|
int len = ce_namelen(ce);
|
2005-06-25 11:25:29 +02:00
|
|
|
int stage = ce_stage(ce);
|
2005-06-19 05:21:34 +02:00
|
|
|
const char *name = ce->name;
|
2005-05-08 06:48:12 +02:00
|
|
|
|
2007-04-02 08:26:07 +02:00
|
|
|
while (pos < istate->cache_nr) {
|
|
|
|
|
struct cache_entry *p = istate->cache[pos++];
|
2005-05-08 06:48:12 +02:00
|
|
|
|
2005-06-19 05:21:34 +02:00
|
|
|
if (len >= ce_namelen(p))
|
2005-05-08 06:48:12 +02:00
|
|
|
break;
|
2005-06-19 05:21:34 +02:00
|
|
|
if (memcmp(name, p->name, len))
|
|
|
|
|
break;
|
2005-06-25 11:25:29 +02:00
|
|
|
if (ce_stage(p) != stage)
|
|
|
|
|
continue;
|
2005-06-19 05:21:34 +02:00
|
|
|
if (p->name[len] != '/')
|
|
|
|
|
continue;
|
2008-01-15 01:03:17 +01:00
|
|
|
if (p->ce_flags & CE_REMOVE)
|
2007-03-30 10:55:37 +02:00
|
|
|
continue;
|
2005-06-19 05:21:34 +02:00
|
|
|
retval = -1;
|
|
|
|
|
if (!ok_to_replace)
|
|
|
|
|
break;
|
2007-04-02 08:26:07 +02:00
|
|
|
remove_index_entry_at(istate, --pos);
|
2005-05-08 06:48:12 +02:00
|
|
|
}
|
2005-06-19 05:21:34 +02:00
|
|
|
return retval;
|
|
|
|
|
}
|
2005-05-08 06:48:12 +02:00
|
|
|
|
2005-06-19 05:21:34 +02: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 08:26:07 +02:00
|
|
|
static int has_dir_name(struct index_state *istate,
|
|
|
|
|
const struct cache_entry *ce, int pos, int ok_to_replace)
|
2005-06-19 05:21:34 +02:00
|
|
|
{
|
|
|
|
|
int retval = 0;
|
2005-06-25 11:25:29 +02:00
|
|
|
int stage = ce_stage(ce);
|
2005-06-19 05:21:34 +02:00
|
|
|
const char *name = ce->name;
|
|
|
|
|
const char *slash = name + ce_namelen(ce);
|
2005-05-08 06:48:12 +02:00
|
|
|
|
2005-06-19 05:21:34 +02:00
|
|
|
for (;;) {
|
|
|
|
|
int len;
|
2005-05-08 06:48:12 +02:00
|
|
|
|
2005-06-19 05:21:34 +02:00
|
|
|
for (;;) {
|
|
|
|
|
if (*--slash == '/')
|
|
|
|
|
break;
|
|
|
|
|
if (slash <= ce->name)
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
len = slash - name;
|
2005-05-08 06:48:12 +02:00
|
|
|
|
2012-07-11 11:22:37 +02:00
|
|
|
pos = index_name_stage_pos(istate, name, len, stage);
|
2005-06-19 05:21:34 +02:00
|
|
|
if (pos >= 0) {
|
2007-03-30 10:55:37 +02: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 06:24:21 +01:00
|
|
|
if (!(istate->cache[pos]->ce_flags & CE_REMOVE)) {
|
2007-03-30 10:55:37 +02:00
|
|
|
retval = -1;
|
|
|
|
|
if (!ok_to_replace)
|
|
|
|
|
break;
|
2007-04-02 08:26:07 +02:00
|
|
|
remove_index_entry_at(istate, pos);
|
2007-03-30 10:55:37 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
2005-06-19 05:21:34 +02:00
|
|
|
}
|
2007-03-30 10:55:37 +02:00
|
|
|
else
|
|
|
|
|
pos = -pos-1;
|
2005-06-19 05:21:34 +02:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Trivial optimization: if we find an entry that
|
|
|
|
|
* already matches the sub-directory, then we know
|
2005-06-25 11:25:29 +02:00
|
|
|
* we're ok, and we can exit.
|
2005-06-19 05:21:34 +02:00
|
|
|
*/
|
2007-04-02 08:26:07 +02:00
|
|
|
while (pos < istate->cache_nr) {
|
|
|
|
|
struct cache_entry *p = istate->cache[pos];
|
2005-06-25 11:25:29 +02:00
|
|
|
if ((ce_namelen(p) <= len) ||
|
|
|
|
|
(p->name[len] != '/') ||
|
|
|
|
|
memcmp(p->name, name, len))
|
|
|
|
|
break; /* not our subdirectory */
|
2008-01-23 06:24:21 +01:00
|
|
|
if (ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))
|
|
|
|
|
/*
|
|
|
|
|
* p is at the same stage as our entry, and
|
2005-06-25 11:25:29 +02: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 06:55:21 +02:00
|
|
|
}
|
2005-05-08 06:48:12 +02:00
|
|
|
}
|
2005-06-19 05:21:34 +02: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 09:04:01 +02:00
|
|
|
*
|
2005-06-19 05:21:34 +02: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 08:26:07 +02: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 05:21:34 +02:00
|
|
|
{
|
2007-03-30 10:55:37 +02:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* When ce is an "I am going away" entry, we allow it to be added
|
|
|
|
|
*/
|
2008-01-15 01:03:17 +01:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
2007-03-30 10:55:37 +02:00
|
|
|
return 0;
|
|
|
|
|
|
2005-06-19 05:21:34 +02: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 10:55:37 +02:00
|
|
|
* in the array.
|
2005-06-19 05:21:34 +02:00
|
|
|
*/
|
2007-04-02 08:26:07 +02:00
|
|
|
retval = has_file_name(istate, ce, pos, ok_to_replace);
|
2007-03-30 10:55:37 +02:00
|
|
|
|
2005-06-19 05:21:34 +02:00
|
|
|
/*
|
|
|
|
|
* Then check if the path might have a clashing sub-directory
|
|
|
|
|
* before it.
|
|
|
|
|
*/
|
2007-04-02 08:26:07 +02:00
|
|
|
return retval + has_dir_name(istate, ce, pos, ok_to_replace);
|
2005-05-08 06:48:12 +02:00
|
|
|
}
|
|
|
|
|
|
2007-08-09 22:42:50 +02:00
|
|
|
static int add_index_entry_with_check(struct index_state *istate, struct cache_entry *ce, int option)
|
2005-04-09 21:09:27 +02:00
|
|
|
{
|
|
|
|
|
int pos;
|
2005-05-08 06:55:21 +02:00
|
|
|
int ok_to_add = option & ADD_CACHE_OK_TO_ADD;
|
|
|
|
|
int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;
|
2005-06-25 11:25:29 +02:00
|
|
|
int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;
|
2008-08-21 10:44:53 +02:00
|
|
|
int new_only = option & ADD_CACHE_NEW_ONLY;
|
2006-02-09 06:15:24 +01:00
|
|
|
|
2014-06-13 14:19:31 +02:00
|
|
|
cache_tree_invalidate_path(istate, ce->name);
|
2012-07-11 11:22:37 +02:00
|
|
|
pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce));
|
2005-04-09 21:09:27 +02:00
|
|
|
|
2005-10-12 03:45:33 +02:00
|
|
|
/* existing match? Just replace it. */
|
2005-04-11 07:06:50 +02:00
|
|
|
if (pos >= 0) {
|
2008-08-21 10:44:53 +02:00
|
|
|
if (!new_only)
|
|
|
|
|
replace_index_entry(istate, pos, ce);
|
2005-04-09 21:09:27 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
2005-04-11 07:06:50 +02:00
|
|
|
pos = -pos-1;
|
2005-04-09 21:09:27 +02:00
|
|
|
|
2005-04-16 21:05:45 +02:00
|
|
|
/*
|
|
|
|
|
* Inserting a merged entry ("stage 0") into the index
|
|
|
|
|
* will always replace all non-merged entries..
|
|
|
|
|
*/
|
2007-04-02 08:26:07 +02:00
|
|
|
if (pos < istate->cache_nr && ce_stage(ce) == 0) {
|
|
|
|
|
while (ce_same_name(istate->cache[pos], ce)) {
|
2005-04-16 21:05:45 +02:00
|
|
|
ok_to_add = 1;
|
2007-04-02 08:26:07 +02:00
|
|
|
if (!remove_index_entry_at(istate, pos))
|
2005-04-16 21:05:45 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-10 20:32:54 +02:00
|
|
|
if (!ok_to_add)
|
|
|
|
|
return -1;
|
2006-05-18 21:07:31 +02:00
|
|
|
if (!verify_path(ce->name))
|
2008-10-11 18:39:37 +02:00
|
|
|
return error("Invalid path '%s'", ce->name);
|
2005-04-10 20:32:54 +02:00
|
|
|
|
2005-10-12 03:45:33 +02:00
|
|
|
if (!skip_df_check &&
|
2007-04-02 08:26:07 +02:00
|
|
|
check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {
|
2005-05-08 06:55:21 +02:00
|
|
|
if (!ok_to_replace)
|
2007-04-02 08:26:07 +02:00
|
|
|
return error("'%s' appears as both a file and as a directory",
|
|
|
|
|
ce->name);
|
2012-07-11 11:22:37 +02:00
|
|
|
pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce));
|
2005-05-08 06:55:21 +02:00
|
|
|
pos = -pos-1;
|
|
|
|
|
}
|
2007-08-09 22:42:50 +02: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 06:48:12 +02:00
|
|
|
|
2005-04-09 21:09:27 +02:00
|
|
|
/* Make sure the array is big enough .. */
|
2014-03-03 23:32:01 +01:00
|
|
|
ALLOC_GROW(istate->cache, istate->cache_nr + 1, istate->cache_alloc);
|
2005-04-09 21:09:27 +02:00
|
|
|
|
|
|
|
|
/* Add it in.. */
|
2007-04-02 08:26:07 +02:00
|
|
|
istate->cache_nr++;
|
2007-08-09 22:42:50 +02:00
|
|
|
if (istate->cache_nr > pos + 1)
|
2007-04-02 08:26:07 +02: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 03:41:14 +01:00
|
|
|
set_index_entry(istate, pos, ce);
|
2014-06-13 14:19:27 +02:00
|
|
|
istate->cache_changed |= CE_ENTRY_ADDED;
|
2005-04-09 21:09:27 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-19 18:56:35 +02: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 08:26:07 +02:00
|
|
|
static struct cache_entry *refresh_cache_ent(struct index_state *istate,
|
2007-11-10 09:15:03 +01:00
|
|
|
struct cache_entry *ce,
|
2011-11-18 12:11:08 +01:00
|
|
|
unsigned int options, int *err,
|
|
|
|
|
int *changed_ret)
|
2006-05-19 18:56:35 +02:00
|
|
|
{
|
|
|
|
|
struct stat st;
|
|
|
|
|
struct cache_entry *updated;
|
|
|
|
|
int changed, size;
|
2014-01-27 15:45:08 +01:00
|
|
|
int refresh = options & CE_MATCH_REFRESH;
|
2007-11-10 09:15:03 +01:00
|
|
|
int ignore_valid = options & CE_MATCH_IGNORE_VALID;
|
2009-12-14 12:43:58 +01:00
|
|
|
int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;
|
2014-01-27 15:45:07 +01:00
|
|
|
int ignore_missing = options & CE_MATCH_IGNORE_MISSING;
|
2006-05-19 18:56:35 +02:00
|
|
|
|
2014-01-27 15:45:08 +01:00
|
|
|
if (!refresh || ce_uptodate(ce))
|
2008-01-19 08:45:24 +01:00
|
|
|
return ce;
|
|
|
|
|
|
2008-05-30 14:38:35 +02:00
|
|
|
/*
|
2009-12-14 12:43:58 +01:00
|
|
|
* CE_VALID or CE_SKIP_WORKTREE means the user promised us
|
|
|
|
|
* that the change to the work tree does not matter and told
|
|
|
|
|
* us not to worry.
|
2008-05-30 14:38:35 +02:00
|
|
|
*/
|
2009-12-14 12:43:58 +01:00
|
|
|
if (!ignore_skip_worktree && ce_skip_worktree(ce)) {
|
|
|
|
|
ce_mark_uptodate(ce);
|
|
|
|
|
return ce;
|
|
|
|
|
}
|
2008-05-30 14:38:35 +02:00
|
|
|
if (!ignore_valid && (ce->ce_flags & CE_VALID)) {
|
|
|
|
|
ce_mark_uptodate(ce);
|
|
|
|
|
return ce;
|
|
|
|
|
}
|
|
|
|
|
|
2006-07-26 06:32:18 +02:00
|
|
|
if (lstat(ce->name, &st) < 0) {
|
2014-01-27 15:45:07 +01:00
|
|
|
if (ignore_missing && errno == ENOENT)
|
|
|
|
|
return ce;
|
2007-04-02 06:34:34 +02:00
|
|
|
if (err)
|
|
|
|
|
*err = errno;
|
2006-07-26 06:32:18 +02:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2006-05-19 18:56:35 +02:00
|
|
|
|
2007-11-10 09:15:03 +01:00
|
|
|
changed = ie_match_stat(istate, ce, &st, options);
|
2011-11-18 12:11:08 +01:00
|
|
|
if (changed_ret)
|
|
|
|
|
*changed_ret = changed;
|
2006-05-19 18:56:35 +02:00
|
|
|
if (!changed) {
|
2007-11-10 09:15:03 +01: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 01:03:17 +01:00
|
|
|
!(ce->ce_flags & CE_VALID))
|
2006-05-19 18:56:35 +02:00
|
|
|
; /* mark this one VALID again */
|
2008-01-19 08:45:24 +01: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.
|
|
|
|
|
*/
|
2010-01-24 09:10:20 +01:00
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
|
ce_mark_uptodate(ce);
|
2006-07-26 06:32:18 +02:00
|
|
|
return ce;
|
2008-01-19 08:45:24 +01:00
|
|
|
}
|
2006-05-19 18:56:35 +02:00
|
|
|
}
|
|
|
|
|
|
2007-11-10 09:15:03 +01:00
|
|
|
if (ie_modified(istate, ce, &st, options)) {
|
2007-04-02 06:34:34 +02:00
|
|
|
if (err)
|
|
|
|
|
*err = EINVAL;
|
2006-07-26 06:32:18 +02:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2006-05-19 18:56:35 +02:00
|
|
|
|
|
|
|
|
size = ce_size(ce);
|
|
|
|
|
updated = xmalloc(size);
|
|
|
|
|
memcpy(updated, ce, size);
|
|
|
|
|
fill_stat_cache_info(updated, &st);
|
2007-11-10 09:15:03 +01: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 18:56:35 +02:00
|
|
|
*/
|
2007-11-10 09:15:03 +01:00
|
|
|
if (!ignore_valid && assume_unchanged &&
|
2008-01-15 01:03:17 +01:00
|
|
|
!(ce->ce_flags & CE_VALID))
|
|
|
|
|
updated->ce_flags &= ~CE_VALID;
|
2006-05-19 18:56:35 +02:00
|
|
|
|
2014-06-13 14:19:27 +02:00
|
|
|
/* istate->cache_changed is updated in the caller */
|
2006-05-19 18:56:35 +02:00
|
|
|
return updated;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-21 10:57:59 +02:00
|
|
|
static void show_file(const char * fmt, const char * name, int in_porcelain,
|
2011-02-22 23:43:23 +01:00
|
|
|
int * first, const char *header_msg)
|
2009-08-21 10:57:59 +02:00
|
|
|
{
|
|
|
|
|
if (in_porcelain && *first && header_msg) {
|
|
|
|
|
printf("%s\n", header_msg);
|
2011-08-25 23:46:52 +02:00
|
|
|
*first = 0;
|
2009-08-21 10:57:59 +02:00
|
|
|
}
|
|
|
|
|
printf(fmt, name);
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-14 10:35:54 +02:00
|
|
|
int refresh_index(struct index_state *istate, unsigned int flags,
|
|
|
|
|
const struct pathspec *pathspec,
|
2011-02-22 23:43:23 +01:00
|
|
|
char *seen, const char *header_msg)
|
2006-05-19 18:56:35 +02: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;
|
2008-05-14 19:03:45 +02:00
|
|
|
int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) != 0;
|
2009-08-21 10:57:59 +02:00
|
|
|
int first = 1;
|
|
|
|
|
int in_porcelain = (flags & REFRESH_IN_PORCELAIN);
|
2014-01-27 15:45:08 +01:00
|
|
|
unsigned int options = (CE_MATCH_REFRESH |
|
|
|
|
|
(really ? CE_MATCH_IGNORE_VALID : 0) |
|
2014-01-27 15:45:07 +01:00
|
|
|
(not_new ? CE_MATCH_IGNORE_MISSING : 0));
|
2011-11-18 12:11:28 +01:00
|
|
|
const char *modified_fmt;
|
2011-11-18 12:13:08 +01:00
|
|
|
const char *deleted_fmt;
|
|
|
|
|
const char *typechange_fmt;
|
|
|
|
|
const char *added_fmt;
|
2011-11-18 12:11:28 +01:00
|
|
|
const char *unmerged_fmt;
|
2006-05-19 18:56:35 +02:00
|
|
|
|
2011-11-18 12:11:28 +01:00
|
|
|
modified_fmt = (in_porcelain ? "M\t%s\n" : "%s: needs update\n");
|
2011-11-18 12:13:08 +01:00
|
|
|
deleted_fmt = (in_porcelain ? "D\t%s\n" : "%s: needs update\n");
|
|
|
|
|
typechange_fmt = (in_porcelain ? "T\t%s\n" : "%s needs update\n");
|
|
|
|
|
added_fmt = (in_porcelain ? "A\t%s\n" : "%s needs update\n");
|
2011-11-18 12:11:28 +01:00
|
|
|
unmerged_fmt = (in_porcelain ? "U\t%s\n" : "%s: needs merge\n");
|
2007-04-02 08:26:07 +02:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
2006-05-19 18:56:35 +02:00
|
|
|
struct cache_entry *ce, *new;
|
2007-04-02 06:34:34 +02:00
|
|
|
int cache_errno = 0;
|
2011-11-18 12:13:08 +01:00
|
|
|
int changed = 0;
|
2012-02-17 19:11:05 +01:00
|
|
|
int filtered = 0;
|
2007-04-02 06:34:34 +02:00
|
|
|
|
2007-04-02 08:26:07 +02:00
|
|
|
ce = istate->cache[i];
|
2008-05-14 19:03:45 +02:00
|
|
|
if (ignore_submodules && S_ISGITLINK(ce->ce_mode))
|
|
|
|
|
continue;
|
|
|
|
|
|
2014-01-24 14:40:28 +01:00
|
|
|
if (pathspec && !ce_path_match(ce, pathspec, seen))
|
2012-02-17 19:11:05 +01:00
|
|
|
filtered = 1;
|
|
|
|
|
|
2006-05-19 18:56:35 +02:00
|
|
|
if (ce_stage(ce)) {
|
2007-04-02 08:26:07 +02:00
|
|
|
while ((i < istate->cache_nr) &&
|
|
|
|
|
! strcmp(istate->cache[i]->name, ce->name))
|
2006-05-19 18:56:35 +02:00
|
|
|
i++;
|
|
|
|
|
i--;
|
|
|
|
|
if (allow_unmerged)
|
|
|
|
|
continue;
|
2012-02-17 19:11:05 +01:00
|
|
|
if (!filtered)
|
|
|
|
|
show_file(unmerged_fmt, ce->name, in_porcelain,
|
|
|
|
|
&first, header_msg);
|
2006-05-19 18:56:35 +02:00
|
|
|
has_errors = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-17 19:11:05 +01:00
|
|
|
if (filtered)
|
2007-08-11 23:59:01 +02:00
|
|
|
continue;
|
|
|
|
|
|
2011-11-18 12:13:08 +01:00
|
|
|
new = refresh_cache_ent(istate, ce, options, &cache_errno, &changed);
|
2006-07-26 06:32:18 +02:00
|
|
|
if (new == ce)
|
2006-05-19 18:56:35 +02:00
|
|
|
continue;
|
2006-07-26 06:32:18 +02:00
|
|
|
if (!new) {
|
2011-11-18 12:13:08 +01:00
|
|
|
const char *fmt;
|
|
|
|
|
|
2006-07-26 06:32:18 +02:00
|
|
|
if (really && cache_errno == EINVAL) {
|
2006-05-19 18:56:35 +02:00
|
|
|
/* If we are doing --really-refresh that
|
|
|
|
|
* means the index is not valid anymore.
|
|
|
|
|
*/
|
2008-01-15 01:03:17 +01:00
|
|
|
ce->ce_flags &= ~CE_VALID;
|
2014-06-13 14:19:27 +02:00
|
|
|
istate->cache_changed |= CE_ENTRY_CHANGED;
|
2006-05-19 18:56:35 +02:00
|
|
|
}
|
|
|
|
|
if (quiet)
|
|
|
|
|
continue;
|
2011-11-18 12:13:08 +01:00
|
|
|
|
|
|
|
|
if (cache_errno == ENOENT)
|
|
|
|
|
fmt = deleted_fmt;
|
|
|
|
|
else if (ce->ce_flags & CE_INTENT_TO_ADD)
|
|
|
|
|
fmt = added_fmt; /* must be before other checks */
|
|
|
|
|
else if (changed & TYPE_CHANGED)
|
|
|
|
|
fmt = typechange_fmt;
|
|
|
|
|
else
|
|
|
|
|
fmt = modified_fmt;
|
|
|
|
|
show_file(fmt,
|
|
|
|
|
ce->name, in_porcelain, &first, header_msg);
|
2006-05-19 18:56:35 +02:00
|
|
|
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 03:41:14 +01:00
|
|
|
|
|
|
|
|
replace_index_entry(istate, i, new);
|
2006-05-19 18:56:35 +02:00
|
|
|
}
|
|
|
|
|
return has_errors;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-27 15:45:08 +01:00
|
|
|
static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,
|
|
|
|
|
unsigned int options)
|
2007-04-02 06:34:34 +02:00
|
|
|
{
|
2014-01-27 15:45:08 +01:00
|
|
|
return refresh_cache_ent(&the_index, ce, options, NULL, NULL);
|
2007-04-02 06:34:34 +02:00
|
|
|
}
|
|
|
|
|
|
2012-04-04 00:53:09 +02:00
|
|
|
|
|
|
|
|
/*****************************************************************
|
|
|
|
|
* Index File I/O
|
|
|
|
|
*****************************************************************/
|
|
|
|
|
|
2012-04-04 18:12:43 +02:00
|
|
|
#define INDEX_FORMAT_DEFAULT 3
|
|
|
|
|
|
2014-02-23 21:49:59 +01:00
|
|
|
static int index_format_config(const char *var, const char *value, void *cb)
|
|
|
|
|
{
|
|
|
|
|
unsigned int *version = cb;
|
|
|
|
|
if (!strcmp(var, "index.version")) {
|
|
|
|
|
*version = git_config_int(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-23 21:49:57 +01:00
|
|
|
static unsigned int get_index_format_default(void)
|
|
|
|
|
{
|
|
|
|
|
char *envversion = getenv("GIT_INDEX_VERSION");
|
2014-02-23 21:49:59 +01:00
|
|
|
char *endp;
|
|
|
|
|
unsigned int version = INDEX_FORMAT_DEFAULT;
|
|
|
|
|
|
2014-02-23 21:49:57 +01:00
|
|
|
if (!envversion) {
|
2014-02-23 21:49:59 +01:00
|
|
|
git_config(index_format_config, &version);
|
|
|
|
|
if (version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {
|
|
|
|
|
warning(_("index.version set, but the value is invalid.\n"
|
2014-02-23 21:49:57 +01:00
|
|
|
"Using version %i"), INDEX_FORMAT_DEFAULT);
|
2014-02-23 21:49:59 +01:00
|
|
|
return INDEX_FORMAT_DEFAULT;
|
2014-02-23 21:49:57 +01:00
|
|
|
}
|
|
|
|
|
return version;
|
|
|
|
|
}
|
2014-02-23 21:49:59 +01:00
|
|
|
|
|
|
|
|
version = strtoul(envversion, &endp, 10);
|
|
|
|
|
if (*endp ||
|
|
|
|
|
version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {
|
|
|
|
|
warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"
|
|
|
|
|
"Using version %i"), INDEX_FORMAT_DEFAULT);
|
|
|
|
|
version = INDEX_FORMAT_DEFAULT;
|
|
|
|
|
}
|
|
|
|
|
return version;
|
2014-02-23 21:49:57 +01:00
|
|
|
}
|
|
|
|
|
|
2012-04-04 00:53:09 +02:00
|
|
|
/*
|
|
|
|
|
* dev/ino/uid/gid/size are also just tracked to the low 32 bits
|
|
|
|
|
* Again - this is just a (very strong in practice) heuristic that
|
|
|
|
|
* the inode hasn't changed.
|
|
|
|
|
*
|
|
|
|
|
* We save the fields in big-endian order to allow using the
|
|
|
|
|
* index file over NFS transparently.
|
|
|
|
|
*/
|
|
|
|
|
struct ondisk_cache_entry {
|
|
|
|
|
struct cache_time ctime;
|
|
|
|
|
struct cache_time mtime;
|
2013-08-18 21:41:51 +02:00
|
|
|
uint32_t dev;
|
|
|
|
|
uint32_t ino;
|
|
|
|
|
uint32_t mode;
|
|
|
|
|
uint32_t uid;
|
|
|
|
|
uint32_t gid;
|
|
|
|
|
uint32_t size;
|
2012-04-04 00:53:09 +02:00
|
|
|
unsigned char sha1[20];
|
2013-08-18 21:41:51 +02:00
|
|
|
uint16_t flags;
|
2012-04-04 00:53:09 +02:00
|
|
|
char name[FLEX_ARRAY]; /* more */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This struct is used when CE_EXTENDED bit is 1
|
|
|
|
|
* The struct must match ondisk_cache_entry exactly from
|
|
|
|
|
* ctime till flags
|
|
|
|
|
*/
|
|
|
|
|
struct ondisk_cache_entry_extended {
|
|
|
|
|
struct cache_time ctime;
|
|
|
|
|
struct cache_time mtime;
|
2013-08-18 21:41:51 +02:00
|
|
|
uint32_t dev;
|
|
|
|
|
uint32_t ino;
|
|
|
|
|
uint32_t mode;
|
|
|
|
|
uint32_t uid;
|
|
|
|
|
uint32_t gid;
|
|
|
|
|
uint32_t size;
|
2012-04-04 00:53:09 +02:00
|
|
|
unsigned char sha1[20];
|
2013-08-18 21:41:51 +02:00
|
|
|
uint16_t flags;
|
|
|
|
|
uint16_t flags2;
|
2012-04-04 00:53:09 +02:00
|
|
|
char name[FLEX_ARRAY]; /* more */
|
|
|
|
|
};
|
|
|
|
|
|
2012-04-04 00:53:15 +02:00
|
|
|
/* These are only used for v3 or lower */
|
2012-04-04 00:53:09 +02:00
|
|
|
#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)
|
|
|
|
|
#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)
|
|
|
|
|
#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)
|
|
|
|
|
#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \
|
|
|
|
|
ondisk_cache_entry_extended_size(ce_namelen(ce)) : \
|
|
|
|
|
ondisk_cache_entry_size(ce_namelen(ce)))
|
|
|
|
|
|
2006-04-25 06:18:58 +02:00
|
|
|
static int verify_hdr(struct cache_header *hdr, unsigned long size)
|
2005-04-08 00:13:13 +02:00
|
|
|
{
|
2008-10-01 20:05:20 +02:00
|
|
|
git_SHA_CTX c;
|
2006-04-25 06:18:58 +02:00
|
|
|
unsigned char sha1[20];
|
2012-04-04 00:53:12 +02:00
|
|
|
int hdr_version;
|
2005-04-08 00:13:13 +02:00
|
|
|
|
2005-04-15 19:44:27 +02:00
|
|
|
if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
|
2005-04-08 00:13:13 +02:00
|
|
|
return error("bad signature");
|
2012-04-04 00:53:12 +02:00
|
|
|
hdr_version = ntohl(hdr->hdr_version);
|
2013-02-22 13:09:24 +01:00
|
|
|
if (hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)
|
2012-04-04 00:53:12 +02:00
|
|
|
return error("bad index version %d", hdr_version);
|
2008-10-01 20:05:20 +02:00
|
|
|
git_SHA1_Init(&c);
|
|
|
|
|
git_SHA1_Update(&c, hdr, size - 20);
|
|
|
|
|
git_SHA1_Final(sha1, &c);
|
2006-08-17 20:54:57 +02:00
|
|
|
if (hashcmp(sha1, (unsigned char *)hdr + size - 20))
|
2005-04-20 21:36:41 +02:00
|
|
|
return error("bad index file sha1 signature");
|
2005-04-08 00:13:13 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-04-02 08:26:07 +02:00
|
|
|
static int read_index_extension(struct index_state *istate,
|
|
|
|
|
const char *ext, void *data, unsigned long sz)
|
2006-04-25 06:18:58 +02:00
|
|
|
{
|
|
|
|
|
switch (CACHE_EXT(ext)) {
|
|
|
|
|
case CACHE_EXT_TREE:
|
2007-04-02 08:26:07 +02:00
|
|
|
istate->cache_tree = cache_tree_read(data, sz);
|
2006-04-25 06:18:58 +02:00
|
|
|
break;
|
2009-12-25 09:30:51 +01:00
|
|
|
case CACHE_EXT_RESOLVE_UNDO:
|
|
|
|
|
istate->resolve_undo = resolve_undo_read(data, sz);
|
|
|
|
|
break;
|
2014-06-13 14:19:36 +02:00
|
|
|
case CACHE_EXT_LINK:
|
|
|
|
|
if (read_link_extension(istate, data, sz))
|
|
|
|
|
return -1;
|
|
|
|
|
break;
|
2006-04-25 06:18:58 +02:00
|
|
|
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 08:26:07 +02:00
|
|
|
int read_index(struct index_state *istate)
|
2006-07-26 06:32:18 +02:00
|
|
|
{
|
2007-04-02 08:26:07 +02:00
|
|
|
return read_index_from(istate, get_index_file());
|
2006-07-26 06:32:18 +02:00
|
|
|
}
|
|
|
|
|
|
2012-04-04 00:53:13 +02:00
|
|
|
static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,
|
|
|
|
|
unsigned int flags,
|
|
|
|
|
const char *name,
|
|
|
|
|
size_t len)
|
|
|
|
|
{
|
|
|
|
|
struct cache_entry *ce = xmalloc(cache_entry_size(len));
|
|
|
|
|
|
2014-01-23 22:26:42 +01:00
|
|
|
ce->ce_stat_data.sd_ctime.sec = get_be32(&ondisk->ctime.sec);
|
|
|
|
|
ce->ce_stat_data.sd_mtime.sec = get_be32(&ondisk->mtime.sec);
|
|
|
|
|
ce->ce_stat_data.sd_ctime.nsec = get_be32(&ondisk->ctime.nsec);
|
|
|
|
|
ce->ce_stat_data.sd_mtime.nsec = get_be32(&ondisk->mtime.nsec);
|
|
|
|
|
ce->ce_stat_data.sd_dev = get_be32(&ondisk->dev);
|
|
|
|
|
ce->ce_stat_data.sd_ino = get_be32(&ondisk->ino);
|
|
|
|
|
ce->ce_mode = get_be32(&ondisk->mode);
|
|
|
|
|
ce->ce_stat_data.sd_uid = get_be32(&ondisk->uid);
|
|
|
|
|
ce->ce_stat_data.sd_gid = get_be32(&ondisk->gid);
|
|
|
|
|
ce->ce_stat_data.sd_size = get_be32(&ondisk->size);
|
2012-07-11 11:22:37 +02:00
|
|
|
ce->ce_flags = flags & ~CE_NAMEMASK;
|
|
|
|
|
ce->ce_namelen = len;
|
2014-06-13 14:19:36 +02:00
|
|
|
ce->index = 0;
|
2012-04-04 00:53:13 +02:00
|
|
|
hashcpy(ce->sha1, ondisk->sha1);
|
|
|
|
|
memcpy(ce->name, name, len);
|
|
|
|
|
ce->name[len] = '\0';
|
|
|
|
|
return ce;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-04 00:53:15 +02:00
|
|
|
/*
|
|
|
|
|
* Adjacent cache entries tend to share the leading paths, so it makes
|
|
|
|
|
* sense to only store the differences in later entries. In the v4
|
|
|
|
|
* on-disk format of the index, each on-disk cache entry stores the
|
|
|
|
|
* number of bytes to be stripped from the end of the previous name,
|
|
|
|
|
* and the bytes to append to the result, to come up with its name.
|
|
|
|
|
*/
|
|
|
|
|
static unsigned long expand_name_field(struct strbuf *name, const char *cp_)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *ep, *cp = (const unsigned char *)cp_;
|
|
|
|
|
size_t len = decode_varint(&cp);
|
|
|
|
|
|
|
|
|
|
if (name->len < len)
|
|
|
|
|
die("malformed name field in the index");
|
|
|
|
|
strbuf_remove(name, name->len - len, len);
|
|
|
|
|
for (ep = cp; *ep; ep++)
|
|
|
|
|
; /* find the end */
|
|
|
|
|
strbuf_add(name, cp, ep - cp);
|
|
|
|
|
return (const char *)ep + 1 - cp_;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-04 00:53:11 +02:00
|
|
|
static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,
|
2012-04-04 00:53:15 +02:00
|
|
|
unsigned long *ent_size,
|
|
|
|
|
struct strbuf *previous_name)
|
2008-01-15 01:03:17 +01:00
|
|
|
{
|
2011-10-24 23:59:14 +02:00
|
|
|
struct cache_entry *ce;
|
2008-01-19 08:42:00 +01:00
|
|
|
size_t len;
|
2008-10-01 06:04:01 +02:00
|
|
|
const char *name;
|
2011-10-24 23:59:14 +02:00
|
|
|
unsigned int flags;
|
2008-01-19 08:42:00 +01:00
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
/* On-disk flags are just 16 bits */
|
2014-01-23 22:26:42 +01:00
|
|
|
flags = get_be16(&ondisk->flags);
|
2011-10-24 23:59:14 +02:00
|
|
|
len = flags & CE_NAMEMASK;
|
2008-01-19 08:42:00 +01:00
|
|
|
|
2011-10-24 23:59:14 +02:00
|
|
|
if (flags & CE_EXTENDED) {
|
2008-10-01 06:04:01 +02:00
|
|
|
struct ondisk_cache_entry_extended *ondisk2;
|
|
|
|
|
int extended_flags;
|
|
|
|
|
ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;
|
2014-01-23 22:26:42 +01:00
|
|
|
extended_flags = get_be16(&ondisk2->flags2) << 16;
|
2008-10-01 06:04:01 +02:00
|
|
|
/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */
|
|
|
|
|
if (extended_flags & ~CE_EXTENDED_FLAGS)
|
|
|
|
|
die("Unknown index entry format %08x", extended_flags);
|
2011-10-24 23:59:14 +02:00
|
|
|
flags |= extended_flags;
|
2008-10-01 06:04:01 +02:00
|
|
|
name = ondisk2->name;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
name = ondisk->name;
|
|
|
|
|
|
2012-04-04 00:53:15 +02:00
|
|
|
if (!previous_name) {
|
|
|
|
|
/* v3 and earlier */
|
|
|
|
|
if (len == CE_NAMEMASK)
|
|
|
|
|
len = strlen(name);
|
|
|
|
|
ce = cache_entry_from_ondisk(ondisk, flags, name, len);
|
|
|
|
|
|
|
|
|
|
*ent_size = ondisk_ce_size(ce);
|
|
|
|
|
} else {
|
|
|
|
|
unsigned long consumed;
|
|
|
|
|
consumed = expand_name_field(previous_name, name);
|
|
|
|
|
ce = cache_entry_from_ondisk(ondisk, flags,
|
|
|
|
|
previous_name->buf,
|
|
|
|
|
previous_name->len);
|
|
|
|
|
|
|
|
|
|
*ent_size = (name - ((char *)ondisk)) + consumed;
|
|
|
|
|
}
|
2011-10-24 23:59:14 +02:00
|
|
|
return 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 03:41:14 +01:00
|
|
|
}
|
|
|
|
|
|
2006-07-26 06:32:18 +02:00
|
|
|
/* remember to discard_cache() before reading a different cache! */
|
2014-06-13 14:19:36 +02:00
|
|
|
static int do_read_index(struct index_state *istate, const char *path,
|
|
|
|
|
int must_exist)
|
2005-04-08 00:13:13 +02:00
|
|
|
{
|
|
|
|
|
int fd, i;
|
|
|
|
|
struct stat st;
|
2011-10-24 23:59:14 +02:00
|
|
|
unsigned long src_offset;
|
2005-04-08 00:13:13 +02:00
|
|
|
struct cache_header *hdr;
|
2008-01-15 01:03:17 +01:00
|
|
|
void *mmap;
|
|
|
|
|
size_t mmap_size;
|
2012-04-04 00:53:15 +02:00
|
|
|
struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;
|
2005-04-08 00:13:13 +02:00
|
|
|
|
unpack_trees(): protect the handcrafted in-core index from read_cache()
unpack_trees() rebuilds the in-core index from scratch by allocating a new
structure and finishing it off by copying the built one to the final
index.
The resulting in-core index is Ok for most use, but read_cache() does not
recognize it as such. The function is meant to be no-op if you already
have loaded the index, until you call discard_cache().
This change the way read_cache() detects an already initialized in-core
index, by introducing an extra bit, and marks the handcrafted in-core
index as initialized, to avoid this problem.
A better fix in the longer term would be to change the read_cache() API so
that it will always discard and re-read from the on-disk index to avoid
confusion. But there are higher level API that have relied on the current
semantics, and they and their users all need to get converted, which is
outside the scope of 'maint' track.
An example of such a higher level API is write_cache_as_tree(), which is
used by git-write-tree as well as later Porcelains like git-merge, revert
and cherry-pick. In the longer term, we should remove read_cache() from
there and add one to cmd_write_tree(); other callers expect that the
in-core index they prepared is what gets written as a tree so no other
change is necessary for this particular codepath.
The original version of this patch marked the index by pointing an
otherwise wasted malloc'ed memory with o->result.alloc, but this version
uses Linus's idea to use a new "initialized" bit, which is conceptually
much cleaner.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-23 21:57:30 +02:00
|
|
|
if (istate->initialized)
|
2007-04-02 08:26:07 +02:00
|
|
|
return istate->cache_nr;
|
2005-10-01 22:24:27 +02:00
|
|
|
|
make USE_NSEC work as expected
Since the filesystem ext4 is now defined as stable in Linux v2.6.28,
and ext4 supports nanonsecond resolution timestamps natively, it is
time to make USE_NSEC work as expected.
This will make racy git situations less likely to happen. For 'git
checkout' this means it will be less likely that we have to open, read
the contents of the file into RAM, and check if file is really
modified or not. The result sould be a litle less used CPU time, less
pagefaults and a litle faster program, at least for 'git checkout'.
Since the number of possible racy git situations would increase when
disks gets faster, this patch would be more and more helpfull as times
go by. For a fast Solid State Disk, this patch should be helpfull.
Note that, when file operations starts to take less than 1 nanosecond,
one would again start to get more racy git situations.
For more info on racy git, see Documentation/technical/racy-git.txt
For more info on ext4, see http://kernelnewbies.org/Ext4
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-19 21:08:29 +01:00
|
|
|
istate->timestamp.sec = 0;
|
|
|
|
|
istate->timestamp.nsec = 0;
|
2006-07-26 06:32:18 +02:00
|
|
|
fd = open(path, O_RDONLY);
|
2005-10-01 22:24:27 +02:00
|
|
|
if (fd < 0) {
|
2014-06-13 14:19:36 +02:00
|
|
|
if (!must_exist && errno == ENOENT)
|
2005-10-01 22:24:27 +02:00
|
|
|
return 0;
|
2014-06-13 14:19:36 +02:00
|
|
|
die_errno("%s: index file open failed", path);
|
2005-10-01 22:24:27 +02:00
|
|
|
}
|
2005-04-08 00:13:13 +02:00
|
|
|
|
2007-04-25 16:18:17 +02:00
|
|
|
if (fstat(fd, &st))
|
2009-06-27 17:58:46 +02:00
|
|
|
die_errno("cannot stat the open index");
|
2007-04-25 16:18:17 +02:00
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
mmap_size = xsize_t(st.st_size);
|
|
|
|
|
if (mmap_size < sizeof(struct cache_header) + 20)
|
2007-04-25 16:18:17 +02:00
|
|
|
die("index file smaller than expected");
|
|
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
mmap = xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
|
|
|
|
|
if (mmap == MAP_FAILED)
|
2009-06-27 17:58:47 +02:00
|
|
|
die_errno("unable to map index file");
|
2012-08-06 13:27:09 +02:00
|
|
|
close(fd);
|
2005-04-08 00:13:13 +02:00
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
hdr = mmap;
|
|
|
|
|
if (verify_hdr(hdr, mmap_size) < 0)
|
2005-04-08 00:13:13 +02:00
|
|
|
goto unmap;
|
|
|
|
|
|
2014-06-13 14:19:35 +02:00
|
|
|
hashcpy(istate->sha1, (const unsigned char *)hdr + mmap_size - 20);
|
2012-04-04 18:12:43 +02:00
|
|
|
istate->version = ntohl(hdr->hdr_version);
|
2007-04-02 08:26:07 +02:00
|
|
|
istate->cache_nr = ntohl(hdr->hdr_entries);
|
|
|
|
|
istate->cache_alloc = alloc_nr(istate->cache_nr);
|
2013-05-30 15:56:19 +02:00
|
|
|
istate->cache = xcalloc(istate->cache_alloc, sizeof(*istate->cache));
|
unpack_trees(): protect the handcrafted in-core index from read_cache()
unpack_trees() rebuilds the in-core index from scratch by allocating a new
structure and finishing it off by copying the built one to the final
index.
The resulting in-core index is Ok for most use, but read_cache() does not
recognize it as such. The function is meant to be no-op if you already
have loaded the index, until you call discard_cache().
This change the way read_cache() detects an already initialized in-core
index, by introducing an extra bit, and marks the handcrafted in-core
index as initialized, to avoid this problem.
A better fix in the longer term would be to change the read_cache() API so
that it will always discard and re-read from the on-disk index to avoid
confusion. But there are higher level API that have relied on the current
semantics, and they and their users all need to get converted, which is
outside the scope of 'maint' track.
An example of such a higher level API is write_cache_as_tree(), which is
used by git-write-tree as well as later Porcelains like git-merge, revert
and cherry-pick. In the longer term, we should remove read_cache() from
there and add one to cmd_write_tree(); other callers expect that the
in-core index they prepared is what gets written as a tree so no other
change is necessary for this particular codepath.
The original version of this patch marked the index by pointing an
otherwise wasted malloc'ed memory with o->result.alloc, but this version
uses Linus's idea to use a new "initialized" bit, which is conceptually
much cleaner.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-23 21:57:30 +02:00
|
|
|
istate->initialized = 1;
|
2008-01-15 01:03:17 +01:00
|
|
|
|
2012-04-04 18:12:43 +02:00
|
|
|
if (istate->version == 4)
|
2012-04-04 00:53:15 +02:00
|
|
|
previous_name = &previous_name_buf;
|
|
|
|
|
else
|
|
|
|
|
previous_name = NULL;
|
|
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
src_offset = sizeof(*hdr);
|
2007-04-02 08:26:07 +02:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
2008-01-15 01:03:17 +01:00
|
|
|
struct ondisk_cache_entry *disk_ce;
|
2007-04-02 08:26:07 +02:00
|
|
|
struct cache_entry *ce;
|
2012-04-04 00:53:11 +02:00
|
|
|
unsigned long consumed;
|
2007-04-02 08:26:07 +02:00
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
disk_ce = (struct ondisk_cache_entry *)((char *)mmap + src_offset);
|
2012-04-04 00:53:15 +02:00
|
|
|
ce = create_from_disk(disk_ce, &consumed, previous_name);
|
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 03:41:14 +01:00
|
|
|
set_index_entry(istate, i, ce);
|
2008-01-15 01:03:17 +01:00
|
|
|
|
2012-04-04 00:53:11 +02:00
|
|
|
src_offset += consumed;
|
2005-04-08 00:13:13 +02:00
|
|
|
}
|
2012-04-04 00:53:15 +02:00
|
|
|
strbuf_release(&previous_name_buf);
|
make USE_NSEC work as expected
Since the filesystem ext4 is now defined as stable in Linux v2.6.28,
and ext4 supports nanonsecond resolution timestamps natively, it is
time to make USE_NSEC work as expected.
This will make racy git situations less likely to happen. For 'git
checkout' this means it will be less likely that we have to open, read
the contents of the file into RAM, and check if file is really
modified or not. The result sould be a litle less used CPU time, less
pagefaults and a litle faster program, at least for 'git checkout'.
Since the number of possible racy git situations would increase when
disks gets faster, this patch would be more and more helpfull as times
go by. For a fast Solid State Disk, this patch should be helpfull.
Note that, when file operations starts to take less than 1 nanosecond,
one would again start to get more racy git situations.
For more info on racy git, see Documentation/technical/racy-git.txt
For more info on ext4, see http://kernelnewbies.org/Ext4
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-19 21:08:29 +01:00
|
|
|
istate->timestamp.sec = st.st_mtime;
|
2009-03-04 18:47:40 +01:00
|
|
|
istate->timestamp.nsec = ST_MTIME_NSEC(st);
|
make USE_NSEC work as expected
Since the filesystem ext4 is now defined as stable in Linux v2.6.28,
and ext4 supports nanonsecond resolution timestamps natively, it is
time to make USE_NSEC work as expected.
This will make racy git situations less likely to happen. For 'git
checkout' this means it will be less likely that we have to open, read
the contents of the file into RAM, and check if file is really
modified or not. The result sould be a litle less used CPU time, less
pagefaults and a litle faster program, at least for 'git checkout'.
Since the number of possible racy git situations would increase when
disks gets faster, this patch would be more and more helpfull as times
go by. For a fast Solid State Disk, this patch should be helpfull.
Note that, when file operations starts to take less than 1 nanosecond,
one would again start to get more racy git situations.
For more info on racy git, see Documentation/technical/racy-git.txt
For more info on ext4, see http://kernelnewbies.org/Ext4
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-19 21:08:29 +01:00
|
|
|
|
2008-01-15 01:03:17 +01:00
|
|
|
while (src_offset <= mmap_size - 20 - 8) {
|
2006-04-25 06:18:58 +02: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.
|
|
|
|
|
*/
|
2009-12-27 07:11:21 +01:00
|
|
|
uint32_t extsize;
|
2008-01-15 01:03:17 +01:00
|
|
|
memcpy(&extsize, (char *)mmap + src_offset + 4, 4);
|
2006-04-25 06:18:58 +02:00
|
|
|
extsize = ntohl(extsize);
|
2007-04-02 08:26:07 +02:00
|
|
|
if (read_index_extension(istate,
|
2008-01-15 01:03:17 +01:00
|
|
|
(const char *) mmap + src_offset,
|
|
|
|
|
(char *) mmap + src_offset + 8,
|
2006-06-18 17:18:09 +02:00
|
|
|
extsize) < 0)
|
2006-04-25 06:18:58 +02:00
|
|
|
goto unmap;
|
2008-01-15 01:03:17 +01:00
|
|
|
src_offset += 8;
|
|
|
|
|
src_offset += extsize;
|
2006-04-25 06:18:58 +02:00
|
|
|
}
|
2008-01-15 01:03:17 +01:00
|
|
|
munmap(mmap, mmap_size);
|
2007-04-02 08:26:07 +02:00
|
|
|
return istate->cache_nr;
|
2005-04-08 00:13:13 +02:00
|
|
|
|
|
|
|
|
unmap:
|
2008-01-15 01:03:17 +01:00
|
|
|
munmap(mmap, mmap_size);
|
2005-10-01 22:24:27 +02:00
|
|
|
die("index file corrupt");
|
2005-04-08 00:13:13 +02:00
|
|
|
}
|
|
|
|
|
|
2014-06-13 14:19:36 +02:00
|
|
|
int read_index_from(struct index_state *istate, const char *path)
|
|
|
|
|
{
|
|
|
|
|
struct split_index *split_index;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/* istate->initialized covers both .git/index and .git/sharedindex.xxx */
|
|
|
|
|
if (istate->initialized)
|
|
|
|
|
return istate->cache_nr;
|
|
|
|
|
|
|
|
|
|
ret = do_read_index(istate, path, 0);
|
|
|
|
|
split_index = istate->split_index;
|
|
|
|
|
if (!split_index)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
if (is_null_sha1(split_index->base_sha1))
|
|
|
|
|
return ret;
|
|
|
|
|
if (istate->cache_nr)
|
|
|
|
|
die("index in split-index mode must contain no entries");
|
|
|
|
|
|
|
|
|
|
if (split_index->base)
|
|
|
|
|
discard_index(split_index->base);
|
|
|
|
|
else
|
|
|
|
|
split_index->base = xcalloc(1, sizeof(*split_index->base));
|
|
|
|
|
ret = do_read_index(split_index->base,
|
|
|
|
|
git_path("sharedindex.%s",
|
|
|
|
|
sha1_to_hex(split_index->base_sha1)), 1);
|
|
|
|
|
if (hashcmp(split_index->base_sha1, split_index->base->sha1))
|
|
|
|
|
die("broken index, expect %s in %s, got %s",
|
|
|
|
|
sha1_to_hex(split_index->base_sha1),
|
|
|
|
|
git_path("sharedindex.%s",
|
|
|
|
|
sha1_to_hex(split_index->base_sha1)),
|
|
|
|
|
sha1_to_hex(split_index->base->sha1));
|
|
|
|
|
merge_base_index(istate);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
checkout: Fix "initial checkout" detection
Earlier commit 5521883 (checkout: do not lose staged removal, 2008-09-07)
tightened the rule to prevent switching branches from losing local
changes, so that staged removal of paths can be protected, while
attempting to keep a loophole to still allow a special case of switching
out of an un-checked-out state.
However, the loophole was made a bit too tight, and did not allow
switching from one branch (in an un-checked-out state) to check out
another branch.
The change to builtin-checkout.c in this commit loosens it to allow this,
by not insisting the original commit and the new commit to be the same.
It also introduces a new function, is_index_unborn (and an associated
macro, is_cache_unborn), to check if the repository is truly in an
un-checked-out state more reliably, by making sure that $GIT_INDEX_FILE
did not exist when populating the in-core index structure. A few places
the earlier commit 5521883 added the check for the initial checkout
condition are updated to use this function.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-11-12 20:52:35 +01:00
|
|
|
int is_index_unborn(struct index_state *istate)
|
|
|
|
|
{
|
2011-10-24 23:59:14 +02:00
|
|
|
return (!istate->cache_nr && !istate->timestamp.sec);
|
checkout: Fix "initial checkout" detection
Earlier commit 5521883 (checkout: do not lose staged removal, 2008-09-07)
tightened the rule to prevent switching branches from losing local
changes, so that staged removal of paths can be protected, while
attempting to keep a loophole to still allow a special case of switching
out of an un-checked-out state.
However, the loophole was made a bit too tight, and did not allow
switching from one branch (in an un-checked-out state) to check out
another branch.
The change to builtin-checkout.c in this commit loosens it to allow this,
by not insisting the original commit and the new commit to be the same.
It also introduces a new function, is_index_unborn (and an associated
macro, is_cache_unborn), to check if the repository is truly in an
un-checked-out state more reliably, by making sure that $GIT_INDEX_FILE
did not exist when populating the in-core index structure. A few places
the earlier commit 5521883 added the check for the initial checkout
condition are updated to use this function.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-11-12 20:52:35 +01:00
|
|
|
}
|
|
|
|
|
|
2007-04-02 08:26:07 +02: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 18:42:41 +02:00
|
|
|
{
|
2011-10-24 23:59:14 +02:00
|
|
|
int i;
|
|
|
|
|
|
2014-06-13 14:19:36 +02:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
|
|
|
|
if (istate->cache[i]->index &&
|
|
|
|
|
istate->split_index &&
|
|
|
|
|
istate->split_index->base &&
|
|
|
|
|
istate->cache[i]->index <= istate->split_index->base->cache_nr &&
|
|
|
|
|
istate->cache[i] == istate->split_index->base->cache[istate->cache[i]->index - 1])
|
|
|
|
|
continue;
|
2011-10-24 23:59:14 +02:00
|
|
|
free(istate->cache[i]);
|
2014-06-13 14:19:36 +02:00
|
|
|
}
|
2009-12-25 09:30:51 +01:00
|
|
|
resolve_undo_clear_index(istate);
|
2007-04-02 08:26:07 +02:00
|
|
|
istate->cache_nr = 0;
|
|
|
|
|
istate->cache_changed = 0;
|
make USE_NSEC work as expected
Since the filesystem ext4 is now defined as stable in Linux v2.6.28,
and ext4 supports nanonsecond resolution timestamps natively, it is
time to make USE_NSEC work as expected.
This will make racy git situations less likely to happen. For 'git
checkout' this means it will be less likely that we have to open, read
the contents of the file into RAM, and check if file is really
modified or not. The result sould be a litle less used CPU time, less
pagefaults and a litle faster program, at least for 'git checkout'.
Since the number of possible racy git situations would increase when
disks gets faster, this patch would be more and more helpfull as times
go by. For a fast Solid State Disk, this patch should be helpfull.
Note that, when file operations starts to take less than 1 nanosecond,
one would again start to get more racy git situations.
For more info on racy git, see Documentation/technical/racy-git.txt
For more info on ext4, see http://kernelnewbies.org/Ext4
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-19 21:08:29 +01:00
|
|
|
istate->timestamp.sec = 0;
|
|
|
|
|
istate->timestamp.nsec = 0;
|
2013-02-28 00:57:48 +01:00
|
|
|
free_name_hash(istate);
|
2007-04-02 08:26:07 +02:00
|
|
|
cache_tree_free(&(istate->cache_tree));
|
unpack_trees(): protect the handcrafted in-core index from read_cache()
unpack_trees() rebuilds the in-core index from scratch by allocating a new
structure and finishing it off by copying the built one to the final
index.
The resulting in-core index is Ok for most use, but read_cache() does not
recognize it as such. The function is meant to be no-op if you already
have loaded the index, until you call discard_cache().
This change the way read_cache() detects an already initialized in-core
index, by introducing an extra bit, and marks the handcrafted in-core
index as initialized, to avoid this problem.
A better fix in the longer term would be to change the read_cache() API so
that it will always discard and re-read from the on-disk index to avoid
confusion. But there are higher level API that have relied on the current
semantics, and they and their users all need to get converted, which is
outside the scope of 'maint' track.
An example of such a higher level API is write_cache_as_tree(), which is
used by git-write-tree as well as later Porcelains like git-merge, revert
and cherry-pick. In the longer term, we should remove read_cache() from
there and add one to cmd_write_tree(); other callers expect that the
in-core index they prepared is what gets written as a tree so no other
change is necessary for this particular codepath.
The original version of this patch marked the index by pointing an
otherwise wasted malloc'ed memory with o->result.alloc, but this version
uses Linus's idea to use a new "initialized" bit, which is conceptually
much cleaner.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-23 21:57:30 +02:00
|
|
|
istate->initialized = 0;
|
2013-06-09 19:39:18 +02:00
|
|
|
free(istate->cache);
|
|
|
|
|
istate->cache = NULL;
|
|
|
|
|
istate->cache_alloc = 0;
|
2014-06-13 14:19:36 +02:00
|
|
|
discard_split_index(istate);
|
2008-01-15 01:03:17 +01: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 18:42:41 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-06 21:46:09 +01:00
|
|
|
int unmerged_index(const struct index_state *istate)
|
2008-02-07 17:40:13 +01:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
|
|
|
|
if (ce_stage(istate->cache[i]))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-20 21:16:57 +02:00
|
|
|
#define WRITE_BUFFER_SIZE 8192
|
2005-05-18 14:14:09 +02:00
|
|
|
static unsigned char write_buffer[WRITE_BUFFER_SIZE];
|
2005-04-20 21:16:57 +02:00
|
|
|
static unsigned long write_buffer_len;
|
|
|
|
|
|
2008-10-01 20:05:20 +02:00
|
|
|
static int ce_write_flush(git_SHA_CTX *context, int fd)
|
2006-08-08 23:47:32 +02:00
|
|
|
{
|
|
|
|
|
unsigned int buffered = write_buffer_len;
|
|
|
|
|
if (buffered) {
|
2008-10-01 20:05:20 +02:00
|
|
|
git_SHA1_Update(context, write_buffer, buffered);
|
2007-01-08 16:58:23 +01:00
|
|
|
if (write_in_full(fd, write_buffer, buffered) != buffered)
|
2006-08-08 23:47:32 +02:00
|
|
|
return -1;
|
|
|
|
|
write_buffer_len = 0;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-01 20:05:20 +02:00
|
|
|
static int ce_write(git_SHA_CTX *context, int fd, void *data, unsigned int len)
|
2005-04-20 21:16:57 +02: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-08 23:47:32 +02:00
|
|
|
write_buffer_len = buffered;
|
|
|
|
|
if (ce_write_flush(context, fd))
|
2005-04-20 21:16:57 +02:00
|
|
|
return -1;
|
|
|
|
|
buffered = 0;
|
|
|
|
|
}
|
|
|
|
|
write_buffer_len = buffered;
|
|
|
|
|
len -= partial;
|
2006-06-18 17:18:09 +02:00
|
|
|
data = (char *) data + partial;
|
2007-06-07 09:04:01 +02:00
|
|
|
}
|
|
|
|
|
return 0;
|
2005-04-20 21:16:57 +02:00
|
|
|
}
|
|
|
|
|
|
2008-10-01 20:05:20 +02:00
|
|
|
static int write_index_ext_header(git_SHA_CTX *context, int fd,
|
2006-05-28 21:08:08 +02:00
|
|
|
unsigned int ext, unsigned int sz)
|
2006-04-25 06:18:58 +02:00
|
|
|
{
|
|
|
|
|
ext = htonl(ext);
|
|
|
|
|
sz = htonl(sz);
|
2006-08-14 22:38:14 +02:00
|
|
|
return ((ce_write(context, fd, &ext, 4) < 0) ||
|
|
|
|
|
(ce_write(context, fd, &sz, 4) < 0)) ? -1 : 0;
|
2006-04-25 06:18:58 +02:00
|
|
|
}
|
|
|
|
|
|
2014-06-13 14:19:35 +02:00
|
|
|
static int ce_flush(git_SHA_CTX *context, int fd, unsigned char *sha1)
|
2005-04-20 21:16:57 +02:00
|
|
|
{
|
|
|
|
|
unsigned int left = write_buffer_len;
|
2005-04-20 21:36:41 +02:00
|
|
|
|
2005-04-20 21:16:57 +02:00
|
|
|
if (left) {
|
|
|
|
|
write_buffer_len = 0;
|
2008-10-01 20:05:20 +02:00
|
|
|
git_SHA1_Update(context, write_buffer, left);
|
2005-04-20 21:16:57 +02:00
|
|
|
}
|
2005-04-20 21:36:41 +02:00
|
|
|
|
2005-09-11 15:27:47 +02:00
|
|
|
/* Flush first if not enough space for SHA1 signature */
|
|
|
|
|
if (left + 20 > WRITE_BUFFER_SIZE) {
|
2007-01-08 16:58:23 +01:00
|
|
|
if (write_in_full(fd, write_buffer, left) != left)
|
2005-09-11 15:27:47 +02:00
|
|
|
return -1;
|
|
|
|
|
left = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-20 21:36:41 +02:00
|
|
|
/* Append the SHA1 signature at the end */
|
2008-10-01 20:05:20 +02:00
|
|
|
git_SHA1_Final(write_buffer + left, context);
|
2014-06-13 14:19:35 +02:00
|
|
|
hashcpy(sha1, write_buffer + left);
|
2005-04-20 21:36:41 +02:00
|
|
|
left += 20;
|
2007-01-08 16:58:23 +01:00
|
|
|
return (write_in_full(fd, write_buffer, left) != left) ? -1 : 0;
|
2005-04-20 21:16:57 +02:00
|
|
|
}
|
|
|
|
|
|
2005-12-20 21:12:18 +01: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
|
2013-06-20 10:37:50 +02:00
|
|
|
* ce_stat_data.sd_mtime match the index file mtime.
|
2008-07-29 10:13:44 +02:00
|
|
|
*
|
|
|
|
|
* Note that this actually does not do much for gitlinks, for
|
|
|
|
|
* which ce_match_stat_basic() always goes to the actual
|
|
|
|
|
* contents. The caller checks with is_racy_timestamp() which
|
|
|
|
|
* always says "no" for gitlinks, so we are not called for them ;-)
|
2005-12-20 21:12:18 +01:00
|
|
|
*/
|
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
|
|
if (lstat(ce->name, &st) < 0)
|
|
|
|
|
return;
|
|
|
|
|
if (ce_match_stat_basic(ce, &st))
|
|
|
|
|
return;
|
|
|
|
|
if (ce_modified_check_fs(ce, &st)) {
|
2005-12-20 23:18:47 +01: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 13:16:02 +02:00
|
|
|
* but it does not. When the second update-index runs,
|
2005-12-20 23:18:47 +01: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 09:04:01 +02:00
|
|
|
* obtain from the filesystem next time we stat("frotz").
|
2005-12-20 23:18:47 +01: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.
|
|
|
|
|
*/
|
2013-06-20 10:37:50 +02:00
|
|
|
ce->ce_stat_data.sd_size = 0;
|
2005-12-20 21:12:18 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-04 00:53:14 +02:00
|
|
|
/* Copy miscellaneous fields but not the name */
|
|
|
|
|
static char *copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,
|
|
|
|
|
struct cache_entry *ce)
|
2008-01-15 01:03:17 +01:00
|
|
|
{
|
2012-07-11 11:22:37 +02:00
|
|
|
short flags;
|
|
|
|
|
|
2013-06-20 10:37:50 +02:00
|
|
|
ondisk->ctime.sec = htonl(ce->ce_stat_data.sd_ctime.sec);
|
|
|
|
|
ondisk->mtime.sec = htonl(ce->ce_stat_data.sd_mtime.sec);
|
|
|
|
|
ondisk->ctime.nsec = htonl(ce->ce_stat_data.sd_ctime.nsec);
|
|
|
|
|
ondisk->mtime.nsec = htonl(ce->ce_stat_data.sd_mtime.nsec);
|
|
|
|
|
ondisk->dev = htonl(ce->ce_stat_data.sd_dev);
|
|
|
|
|
ondisk->ino = htonl(ce->ce_stat_data.sd_ino);
|
2008-01-15 01:03:17 +01:00
|
|
|
ondisk->mode = htonl(ce->ce_mode);
|
2013-06-20 10:37:50 +02:00
|
|
|
ondisk->uid = htonl(ce->ce_stat_data.sd_uid);
|
|
|
|
|
ondisk->gid = htonl(ce->ce_stat_data.sd_gid);
|
|
|
|
|
ondisk->size = htonl(ce->ce_stat_data.sd_size);
|
2008-01-15 01:03:17 +01:00
|
|
|
hashcpy(ondisk->sha1, ce->sha1);
|
2012-07-11 11:22:37 +02:00
|
|
|
|
2014-06-13 14:19:25 +02:00
|
|
|
flags = ce->ce_flags & ~CE_NAMEMASK;
|
2012-07-11 11:22:37 +02:00
|
|
|
flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK : ce_namelen(ce));
|
|
|
|
|
ondisk->flags = htons(flags);
|
2008-10-01 06:04:01 +02:00
|
|
|
if (ce->ce_flags & CE_EXTENDED) {
|
|
|
|
|
struct ondisk_cache_entry_extended *ondisk2;
|
|
|
|
|
ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;
|
|
|
|
|
ondisk2->flags2 = htons((ce->ce_flags & CE_EXTENDED_FLAGS) >> 16);
|
2012-04-04 00:53:14 +02:00
|
|
|
return ondisk2->name;
|
2008-10-01 06:04:01 +02:00
|
|
|
}
|
2012-04-04 00:53:14 +02:00
|
|
|
else {
|
|
|
|
|
return ondisk->name;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-04 18:12:43 +02:00
|
|
|
static int ce_write_entry(git_SHA_CTX *c, int fd, struct cache_entry *ce,
|
|
|
|
|
struct strbuf *previous_name)
|
2012-04-04 00:53:14 +02:00
|
|
|
{
|
2012-04-04 18:12:43 +02:00
|
|
|
int size;
|
|
|
|
|
struct ondisk_cache_entry *ondisk;
|
2012-04-04 00:53:14 +02:00
|
|
|
char *name;
|
|
|
|
|
int result;
|
|
|
|
|
|
2012-04-04 18:12:43 +02:00
|
|
|
if (!previous_name) {
|
|
|
|
|
size = ondisk_ce_size(ce);
|
|
|
|
|
ondisk = xcalloc(1, size);
|
|
|
|
|
name = copy_cache_entry_to_ondisk(ondisk, ce);
|
|
|
|
|
memcpy(name, ce->name, ce_namelen(ce));
|
|
|
|
|
} else {
|
|
|
|
|
int common, to_remove, prefix_size;
|
|
|
|
|
unsigned char to_remove_vi[16];
|
|
|
|
|
for (common = 0;
|
|
|
|
|
(ce->name[common] &&
|
|
|
|
|
common < previous_name->len &&
|
|
|
|
|
ce->name[common] == previous_name->buf[common]);
|
|
|
|
|
common++)
|
|
|
|
|
; /* still matching */
|
|
|
|
|
to_remove = previous_name->len - common;
|
|
|
|
|
prefix_size = encode_varint(to_remove, to_remove_vi);
|
|
|
|
|
|
|
|
|
|
if (ce->ce_flags & CE_EXTENDED)
|
|
|
|
|
size = offsetof(struct ondisk_cache_entry_extended, name);
|
|
|
|
|
else
|
|
|
|
|
size = offsetof(struct ondisk_cache_entry, name);
|
|
|
|
|
size += prefix_size + (ce_namelen(ce) - common + 1);
|
|
|
|
|
|
|
|
|
|
ondisk = xcalloc(1, size);
|
|
|
|
|
name = copy_cache_entry_to_ondisk(ondisk, ce);
|
|
|
|
|
memcpy(name, to_remove_vi, prefix_size);
|
|
|
|
|
memcpy(name + prefix_size, ce->name + common, ce_namelen(ce) - common);
|
|
|
|
|
|
|
|
|
|
strbuf_splice(previous_name, common, to_remove,
|
|
|
|
|
ce->name + common, ce_namelen(ce) - common);
|
2008-10-01 06:04:01 +02:00
|
|
|
}
|
2008-01-15 01:03:17 +01:00
|
|
|
|
2010-08-10 05:28:07 +02:00
|
|
|
result = ce_write(c, fd, ondisk, size);
|
|
|
|
|
free(ondisk);
|
|
|
|
|
return result;
|
2008-01-15 01:03:17 +01:00
|
|
|
}
|
|
|
|
|
|
2011-03-21 18:18:19 +01:00
|
|
|
static int has_racy_timestamp(struct index_state *istate)
|
|
|
|
|
{
|
|
|
|
|
int entries = istate->cache_nr;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
|
|
|
struct cache_entry *ce = istate->cache[i];
|
|
|
|
|
if (is_racy_timestamp(istate, ce))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-21 18:16:10 +01:00
|
|
|
/*
|
2013-07-29 10:18:21 +02:00
|
|
|
* Opportunistically update the index but do not complain if we can't
|
2011-03-21 18:16:10 +01:00
|
|
|
*/
|
|
|
|
|
void update_index_if_able(struct index_state *istate, struct lock_file *lockfile)
|
|
|
|
|
{
|
2011-03-21 18:18:19 +01:00
|
|
|
if ((istate->cache_changed || has_racy_timestamp(istate)) &&
|
2014-06-13 14:19:23 +02:00
|
|
|
write_locked_index(istate, lockfile, COMMIT_LOCK))
|
2011-03-21 18:16:10 +01:00
|
|
|
rollback_lock_file(lockfile);
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-13 14:19:23 +02:00
|
|
|
static int do_write_index(struct index_state *istate, int newfd)
|
2005-04-09 21:09:27 +02:00
|
|
|
{
|
2008-10-01 20:05:20 +02:00
|
|
|
git_SHA_CTX c;
|
2005-04-09 21:09:27 +02:00
|
|
|
struct cache_header hdr;
|
2012-04-04 18:12:43 +02:00
|
|
|
int i, err, removed, extended, hdr_version;
|
2007-04-02 08:26:07 +02:00
|
|
|
struct cache_entry **cache = istate->cache;
|
|
|
|
|
int entries = istate->cache_nr;
|
write_index(): update index_state->timestamp after flushing to disk
Since this timestamp is used to check for racy-clean files, it is
important to keep it uptodate.
For the 'git checkout' command without the '-q' option, this make a
huge difference. Before, each and every file which was updated, was
racy-clean after the call to unpack_trees() and write_index() but
before the GIT process ended.
And because of the call to show_local_changes() in builtin-checkout.c,
we ended up reading those files back into memory, doing a SHA1 to
check if the files was really different from the index. And, of
course, no file was different.
With this fix, 'git checkout' without the '-q' option should now be
almost as fast as with the '-q' option, but not quite, as we still do
some few lstat(2) calls more without the '-q' option.
Below is some average numbers for 10 checkout's to v2.6.27 and 10 to
v2.6.25 of the Linux kernel, to show the difference:
before (git version 1.6.2.rc1.256.g58a87):
7.860 user 2.427 sys 19.465 real 52.8% CPU faults: 0 major 95331 minor
after:
6.184 user 2.160 sys 17.619 real 47.4% CPU faults: 0 major 38994 minor
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-23 19:02:57 +01:00
|
|
|
struct stat st;
|
2012-04-04 18:12:43 +02:00
|
|
|
struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;
|
2005-06-10 10:32:37 +02:00
|
|
|
|
2008-10-01 06:04:01 +02:00
|
|
|
for (i = removed = extended = 0; i < entries; i++) {
|
2008-01-15 01:03:17 +01:00
|
|
|
if (cache[i]->ce_flags & CE_REMOVE)
|
2005-06-10 10:32:37 +02:00
|
|
|
removed++;
|
2005-04-09 21:09:27 +02:00
|
|
|
|
2008-10-01 06:04:01 +02:00
|
|
|
/* reduce extended entries if possible */
|
|
|
|
|
cache[i]->ce_flags &= ~CE_EXTENDED;
|
|
|
|
|
if (cache[i]->ce_flags & CE_EXTENDED_FLAGS) {
|
|
|
|
|
extended++;
|
|
|
|
|
cache[i]->ce_flags |= CE_EXTENDED;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-04 18:12:43 +02:00
|
|
|
if (!istate->version)
|
2014-02-23 21:49:57 +01:00
|
|
|
istate->version = get_index_format_default();
|
2012-04-04 18:12:43 +02:00
|
|
|
|
|
|
|
|
/* demote version 3 to version 2 when the latter suffices */
|
|
|
|
|
if (istate->version == 3 || istate->version == 2)
|
|
|
|
|
istate->version = extended ? 3 : 2;
|
|
|
|
|
|
|
|
|
|
hdr_version = istate->version;
|
|
|
|
|
|
2005-04-15 19:44:27 +02:00
|
|
|
hdr.hdr_signature = htonl(CACHE_SIGNATURE);
|
2012-04-04 18:12:43 +02:00
|
|
|
hdr.hdr_version = htonl(hdr_version);
|
2005-06-10 10:32:37 +02:00
|
|
|
hdr.hdr_entries = htonl(entries - removed);
|
2005-04-09 21:09:27 +02:00
|
|
|
|
2008-10-01 20:05:20 +02:00
|
|
|
git_SHA1_Init(&c);
|
2005-04-20 21:36:41 +02:00
|
|
|
if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0)
|
2005-04-09 21:09:27 +02:00
|
|
|
return -1;
|
|
|
|
|
|
2012-04-04 18:12:43 +02:00
|
|
|
previous_name = (hdr_version == 4) ? &previous_name_buf : NULL;
|
2005-04-09 21:09:27 +02:00
|
|
|
for (i = 0; i < entries; i++) {
|
|
|
|
|
struct cache_entry *ce = cache[i];
|
2008-01-15 01:03:17 +01:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
2005-06-10 00:34:04 +02:00
|
|
|
continue;
|
2008-03-30 18:25:52 +02:00
|
|
|
if (!ce_uptodate(ce) && is_racy_timestamp(istate, ce))
|
2005-12-20 21:12:18 +01:00
|
|
|
ce_smudge_racily_clean_entry(ce);
|
write_index: optionally allow broken null sha1s
Commit 4337b58 (do not write null sha1s to on-disk index,
2012-07-28) added a safety check preventing git from writing
null sha1s into the index. The intent was to catch errors in
other parts of the code that might let such an entry slip
into the index (or worse, a tree).
Some existing repositories may have invalid trees that
contain null sha1s already, though. Until 4337b58, a common
way to clean this up would be to use git-filter-branch's
index-filter to repair such broken entries. That now fails
when filter-branch tries to write out the index.
Introduce a GIT_ALLOW_NULL_SHA1 environment variable to
relax this check and make it easier to recover from such a
history.
It is tempting to not involve filter-branch in this commit
at all, and instead require the user to manually invoke
GIT_ALLOW_NULL_SHA1=1 git filter-branch ...
to perform an index-filter on a history with trees with null
sha1s. That would be slightly safer, but requires some
specialized knowledge from the user. So let's set the
GIT_ALLOW_NULL_SHA1 variable automatically when checking out
the to-be-filtered trees. Advice on using filter-branch to
remove such entries already exists on places like
stackoverflow, and this patch makes it Just Work again on
recent versions of git.
Further commands that touch the index will still notice and
fail, unless they actually remove the broken entries. A
filter-branch whose filters do not touch the index at all
will not error out (since we complain of the null sha1 only
on writing, not when making a tree out of the index), but
this is acceptable, as we still print a loud warning, so the
problem is unlikely to go unnoticed.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-27 22:41:12 +02:00
|
|
|
if (is_null_sha1(ce->sha1)) {
|
|
|
|
|
static const char msg[] = "cache entry has null sha1: %s";
|
|
|
|
|
static int allow = -1;
|
|
|
|
|
|
|
|
|
|
if (allow < 0)
|
|
|
|
|
allow = git_env_bool("GIT_ALLOW_NULL_SHA1", 0);
|
|
|
|
|
if (allow)
|
|
|
|
|
warning(msg, ce->name);
|
|
|
|
|
else
|
|
|
|
|
return error(msg, ce->name);
|
|
|
|
|
}
|
2012-04-04 18:12:43 +02:00
|
|
|
if (ce_write_entry(&c, newfd, ce, previous_name) < 0)
|
2005-04-09 21:09:27 +02:00
|
|
|
return -1;
|
|
|
|
|
}
|
2012-04-04 18:12:43 +02:00
|
|
|
strbuf_release(&previous_name_buf);
|
2006-04-24 01:52:08 +02:00
|
|
|
|
2006-04-25 06:18:58 +02:00
|
|
|
/* Write extension data here */
|
2014-06-13 14:19:36 +02:00
|
|
|
if (istate->split_index) {
|
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
|
|
|
|
err = write_link_extension(&sb, istate) < 0 ||
|
|
|
|
|
write_index_ext_header(&c, newfd, CACHE_EXT_LINK,
|
|
|
|
|
sb.len) < 0 ||
|
|
|
|
|
ce_write(&c, newfd, sb.buf, sb.len) < 0;
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
if (err)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2007-04-02 08:26:07 +02:00
|
|
|
if (istate->cache_tree) {
|
2008-10-09 21:12:12 +02:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2007-09-25 10:22:44 +02:00
|
|
|
|
|
|
|
|
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 06:18:58 +02:00
|
|
|
return -1;
|
|
|
|
|
}
|
2009-12-25 09:30:51 +01:00
|
|
|
if (istate->resolve_undo) {
|
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
|
|
|
|
resolve_undo_write(&sb, istate->resolve_undo);
|
|
|
|
|
err = write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,
|
|
|
|
|
sb.len) < 0
|
|
|
|
|
|| ce_write(&c, newfd, sb.buf, sb.len) < 0;
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
if (err)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
write_index(): update index_state->timestamp after flushing to disk
Since this timestamp is used to check for racy-clean files, it is
important to keep it uptodate.
For the 'git checkout' command without the '-q' option, this make a
huge difference. Before, each and every file which was updated, was
racy-clean after the call to unpack_trees() and write_index() but
before the GIT process ended.
And because of the call to show_local_changes() in builtin-checkout.c,
we ended up reading those files back into memory, doing a SHA1 to
check if the files was really different from the index. And, of
course, no file was different.
With this fix, 'git checkout' without the '-q' option should now be
almost as fast as with the '-q' option, but not quite, as we still do
some few lstat(2) calls more without the '-q' option.
Below is some average numbers for 10 checkout's to v2.6.27 and 10 to
v2.6.25 of the Linux kernel, to show the difference:
before (git version 1.6.2.rc1.256.g58a87):
7.860 user 2.427 sys 19.465 real 52.8% CPU faults: 0 major 95331 minor
after:
6.184 user 2.160 sys 17.619 real 47.4% CPU faults: 0 major 38994 minor
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-23 19:02:57 +01:00
|
|
|
|
2014-06-13 14:19:35 +02:00
|
|
|
if (ce_flush(&c, newfd, istate->sha1) || fstat(newfd, &st))
|
write_index(): update index_state->timestamp after flushing to disk
Since this timestamp is used to check for racy-clean files, it is
important to keep it uptodate.
For the 'git checkout' command without the '-q' option, this make a
huge difference. Before, each and every file which was updated, was
racy-clean after the call to unpack_trees() and write_index() but
before the GIT process ended.
And because of the call to show_local_changes() in builtin-checkout.c,
we ended up reading those files back into memory, doing a SHA1 to
check if the files was really different from the index. And, of
course, no file was different.
With this fix, 'git checkout' without the '-q' option should now be
almost as fast as with the '-q' option, but not quite, as we still do
some few lstat(2) calls more without the '-q' option.
Below is some average numbers for 10 checkout's to v2.6.27 and 10 to
v2.6.25 of the Linux kernel, to show the difference:
before (git version 1.6.2.rc1.256.g58a87):
7.860 user 2.427 sys 19.465 real 52.8% CPU faults: 0 major 95331 minor
after:
6.184 user 2.160 sys 17.619 real 47.4% CPU faults: 0 major 38994 minor
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-23 19:02:57 +01:00
|
|
|
return -1;
|
2009-03-15 12:38:55 +01:00
|
|
|
istate->timestamp.sec = (unsigned int)st.st_mtime;
|
|
|
|
|
istate->timestamp.nsec = ST_MTIME_NSEC(st);
|
write_index(): update index_state->timestamp after flushing to disk
Since this timestamp is used to check for racy-clean files, it is
important to keep it uptodate.
For the 'git checkout' command without the '-q' option, this make a
huge difference. Before, each and every file which was updated, was
racy-clean after the call to unpack_trees() and write_index() but
before the GIT process ended.
And because of the call to show_local_changes() in builtin-checkout.c,
we ended up reading those files back into memory, doing a SHA1 to
check if the files was really different from the index. And, of
course, no file was different.
With this fix, 'git checkout' without the '-q' option should now be
almost as fast as with the '-q' option, but not quite, as we still do
some few lstat(2) calls more without the '-q' option.
Below is some average numbers for 10 checkout's to v2.6.27 and 10 to
v2.6.25 of the Linux kernel, to show the difference:
before (git version 1.6.2.rc1.256.g58a87):
7.860 user 2.427 sys 19.465 real 52.8% CPU faults: 0 major 95331 minor
after:
6.184 user 2.160 sys 17.619 real 47.4% CPU faults: 0 major 38994 minor
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-02-23 19:02:57 +01:00
|
|
|
return 0;
|
2005-04-09 21:09:27 +02:00
|
|
|
}
|
2008-06-27 18:21:58 +02:00
|
|
|
|
2014-06-13 14:19:24 +02:00
|
|
|
void set_alternate_index_output(const char *name)
|
|
|
|
|
{
|
|
|
|
|
alternate_index_output = name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int commit_locked_index(struct lock_file *lk)
|
|
|
|
|
{
|
|
|
|
|
if (alternate_index_output) {
|
|
|
|
|
if (lk->fd >= 0 && close_lock_file(lk))
|
|
|
|
|
return -1;
|
|
|
|
|
if (rename(lk->filename, alternate_index_output))
|
|
|
|
|
return -1;
|
|
|
|
|
lk->filename[0] = 0;
|
|
|
|
|
return 0;
|
|
|
|
|
} else {
|
|
|
|
|
return commit_lock_file(lk);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-13 14:19:23 +02:00
|
|
|
static int do_write_locked_index(struct index_state *istate, struct lock_file *lock,
|
|
|
|
|
unsigned flags)
|
|
|
|
|
{
|
|
|
|
|
int ret = do_write_index(istate, lock->fd);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
assert((flags & (COMMIT_LOCK | CLOSE_LOCK)) !=
|
|
|
|
|
(COMMIT_LOCK | CLOSE_LOCK));
|
|
|
|
|
if (flags & COMMIT_LOCK)
|
|
|
|
|
return commit_locked_index(lock);
|
|
|
|
|
else if (flags & CLOSE_LOCK)
|
|
|
|
|
return close_lock_file(lock);
|
|
|
|
|
else
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-13 14:19:36 +02:00
|
|
|
static int write_split_index(struct index_state *istate,
|
|
|
|
|
struct lock_file *lock,
|
|
|
|
|
unsigned flags)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
prepare_to_write_split_index(istate);
|
|
|
|
|
ret = do_write_locked_index(istate, lock, flags);
|
|
|
|
|
finish_writing_split_index(istate);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-13 14:19:23 +02:00
|
|
|
int write_locked_index(struct index_state *istate, struct lock_file *lock,
|
|
|
|
|
unsigned flags)
|
|
|
|
|
{
|
2014-06-13 14:19:36 +02:00
|
|
|
struct split_index *si = istate->split_index;
|
|
|
|
|
|
|
|
|
|
if (!si || (istate->cache_changed & ~EXTMASK)) {
|
|
|
|
|
if (si)
|
|
|
|
|
hashclr(si->base_sha1);
|
|
|
|
|
return do_write_locked_index(istate, lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return write_split_index(istate, lock, flags);
|
2014-06-13 14:19:23 +02:00
|
|
|
}
|
|
|
|
|
|
2008-06-27 18:21:58 +02:00
|
|
|
/*
|
|
|
|
|
* Read the index file that is potentially unmerged into given
|
2008-12-06 02:54:11 +01:00
|
|
|
* index_state, dropping any unmerged entries. Returns true if
|
2008-06-27 18:21:58 +02:00
|
|
|
* the index is unmerged. Callers who want to refuse to work
|
|
|
|
|
* from an unmerged state can call this and check its return value,
|
|
|
|
|
* instead of calling read_cache().
|
|
|
|
|
*/
|
|
|
|
|
int read_index_unmerged(struct index_state *istate)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
2008-10-16 01:00:06 +02:00
|
|
|
int unmerged = 0;
|
2008-06-27 18:21:58 +02:00
|
|
|
|
|
|
|
|
read_index(istate);
|
|
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
|
|
|
|
struct cache_entry *ce = istate->cache[i];
|
2008-10-16 01:00:06 +02:00
|
|
|
struct cache_entry *new_ce;
|
|
|
|
|
int size, len;
|
|
|
|
|
|
|
|
|
|
if (!ce_stage(ce))
|
2008-06-27 18:21:58 +02:00
|
|
|
continue;
|
2008-10-16 01:00:06 +02:00
|
|
|
unmerged = 1;
|
2012-07-06 18:07:30 +02:00
|
|
|
len = ce_namelen(ce);
|
2008-10-16 01:00:06 +02:00
|
|
|
size = cache_entry_size(len);
|
|
|
|
|
new_ce = xcalloc(1, size);
|
|
|
|
|
memcpy(new_ce->name, ce->name, len);
|
2012-07-11 11:22:37 +02:00
|
|
|
new_ce->ce_flags = create_ce_flags(0) | CE_CONFLICTED;
|
|
|
|
|
new_ce->ce_namelen = len;
|
2008-10-16 01:00:06 +02:00
|
|
|
new_ce->ce_mode = ce->ce_mode;
|
|
|
|
|
if (add_index_entry(istate, new_ce, 0))
|
|
|
|
|
return error("%s: cannot drop to stage #0",
|
2013-11-14 20:24:37 +01:00
|
|
|
new_ce->name);
|
2008-10-16 01:00:06 +02:00
|
|
|
i = index_name_pos(istate, new_ce->name, len);
|
2008-06-27 18:21:58 +02:00
|
|
|
}
|
2008-10-16 01:00:06 +02:00
|
|
|
return unmerged;
|
2008-06-27 18:21:58 +02:00
|
|
|
}
|
2008-07-21 10:24:17 +02:00
|
|
|
|
2008-10-16 17:07:26 +02:00
|
|
|
/*
|
|
|
|
|
* Returns 1 if the path is an "other" path with respect to
|
|
|
|
|
* the index; that is, the path is not mentioned in the index at all,
|
|
|
|
|
* either as a file, a directory with some files in the index,
|
|
|
|
|
* or as an unmerged entry.
|
|
|
|
|
*
|
|
|
|
|
* We helpfully remove a trailing "/" from directories so that
|
|
|
|
|
* the output of read_directory can be used as-is.
|
|
|
|
|
*/
|
|
|
|
|
int index_name_is_other(const struct index_state *istate, const char *name,
|
|
|
|
|
int namelen)
|
|
|
|
|
{
|
|
|
|
|
int pos;
|
|
|
|
|
if (namelen && name[namelen - 1] == '/')
|
|
|
|
|
namelen--;
|
|
|
|
|
pos = index_name_pos(istate, name, namelen);
|
|
|
|
|
if (0 <= pos)
|
|
|
|
|
return 0; /* exact match */
|
|
|
|
|
pos = -pos - 1;
|
|
|
|
|
if (pos < istate->cache_nr) {
|
|
|
|
|
struct cache_entry *ce = istate->cache[pos];
|
|
|
|
|
if (ce_namelen(ce) == namelen &&
|
|
|
|
|
!memcmp(ce->name, name, namelen))
|
|
|
|
|
return 0; /* Yup, this one exists unmerged */
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2013-04-13 15:28:30 +02:00
|
|
|
|
2013-04-13 15:28:31 +02:00
|
|
|
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
|
2013-04-13 15:28:30 +02:00
|
|
|
{
|
|
|
|
|
int pos, len;
|
|
|
|
|
unsigned long sz;
|
|
|
|
|
enum object_type type;
|
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
|
|
len = strlen(path);
|
|
|
|
|
pos = index_name_pos(istate, path, len);
|
|
|
|
|
if (pos < 0) {
|
|
|
|
|
/*
|
|
|
|
|
* We might be in the middle of a merge, in which
|
|
|
|
|
* case we would read stage #2 (ours).
|
|
|
|
|
*/
|
|
|
|
|
int i;
|
|
|
|
|
for (i = -pos - 1;
|
|
|
|
|
(pos < 0 && i < istate->cache_nr &&
|
|
|
|
|
!strcmp(istate->cache[i]->name, path));
|
|
|
|
|
i++)
|
|
|
|
|
if (ce_stage(istate->cache[i]) == 2)
|
|
|
|
|
pos = i;
|
|
|
|
|
}
|
|
|
|
|
if (pos < 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
|
|
|
|
|
if (!data || type != OBJ_BLOB) {
|
|
|
|
|
free(data);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2013-04-13 15:28:31 +02:00
|
|
|
if (size)
|
|
|
|
|
*size = sz;
|
2013-04-13 15:28:30 +02:00
|
|
|
return data;
|
|
|
|
|
}
|
2013-06-20 10:37:51 +02:00
|
|
|
|
|
|
|
|
void stat_validity_clear(struct stat_validity *sv)
|
|
|
|
|
{
|
|
|
|
|
free(sv->sd);
|
|
|
|
|
sv->sd = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int stat_validity_check(struct stat_validity *sv, const char *path)
|
|
|
|
|
{
|
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
|
|
if (stat(path, &st) < 0)
|
|
|
|
|
return sv->sd == NULL;
|
|
|
|
|
if (!sv->sd)
|
|
|
|
|
return 0;
|
|
|
|
|
return S_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void stat_validity_update(struct stat_validity *sv, int fd)
|
|
|
|
|
{
|
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
|
|
if (fstat(fd, &st) < 0 || !S_ISREG(st.st_mode))
|
|
|
|
|
stat_validity_clear(sv);
|
|
|
|
|
else {
|
|
|
|
|
if (!sv->sd)
|
|
|
|
|
sv->sd = xcalloc(1, sizeof(struct stat_data));
|
|
|
|
|
fill_stat_data(sv->sd, &st);
|
|
|
|
|
}
|
|
|
|
|
}
|
