2008-03-06 20:26:14 +00:00
|
|
|
#define NO_THE_INDEX_COMPATIBILITY_MACROS
|
2006-07-30 18:25:18 +00:00
|
|
|
#include "cache.h"
|
2006-12-05 00:00:46 +00:00
|
|
|
#include "dir.h"
|
2006-07-30 18:25:18 +00:00
|
|
|
#include "tree.h"
|
|
|
|
#include "tree-walk.h"
|
2006-07-30 18:26:15 +00:00
|
|
|
#include "cache-tree.h"
|
2006-07-30 18:25:18 +00:00
|
|
|
#include "unpack-trees.h"
|
2007-04-18 18:27:45 +00:00
|
|
|
#include "progress.h"
|
2007-07-17 18:28:28 +00:00
|
|
|
#include "refs.h"
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-05-17 19:03:49 +00:00
|
|
|
/*
|
|
|
|
* Error messages expected by scripts out of plumbing commands such as
|
|
|
|
* read-tree. Non-scripted Porcelain is not required to use these messages
|
|
|
|
* and in fact are encouraged to reword them to better suit their particular
|
|
|
|
* situation better. See how "git checkout" replaces not_uptodate_file to
|
|
|
|
* explain why it does not allow switching between branches when you have
|
|
|
|
* local changes, for example.
|
|
|
|
*/
|
|
|
|
static struct unpack_trees_error_msgs unpack_plumbing_errors = {
|
|
|
|
/* would_overwrite */
|
|
|
|
"Entry '%s' would be overwritten by merge. Cannot merge.",
|
|
|
|
|
|
|
|
/* not_uptodate_file */
|
|
|
|
"Entry '%s' not uptodate. Cannot merge.",
|
|
|
|
|
|
|
|
/* not_uptodate_dir */
|
|
|
|
"Updating '%s' would lose untracked files in it",
|
|
|
|
|
|
|
|
/* would_lose_untracked */
|
|
|
|
"Untracked working tree file '%s' would be %s by merge.",
|
|
|
|
|
|
|
|
/* bind_overlap */
|
|
|
|
"Entry '%s' overlaps with '%s'. Cannot bind.",
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ERRORMSG(o,fld) \
|
|
|
|
( ((o) && (o)->msgs.fld) \
|
|
|
|
? ((o)->msgs.fld) \
|
|
|
|
: (unpack_plumbing_errors.fld) )
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
static void add_entry(struct unpack_trees_options *o, struct cache_entry *ce,
|
|
|
|
unsigned int set, unsigned int clear)
|
2007-08-10 19:15:54 +00:00
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
unsigned int size = ce_size(ce);
|
|
|
|
struct cache_entry *new = xmalloc(size);
|
|
|
|
|
|
|
|
clear |= CE_HASHED | CE_UNHASHED;
|
|
|
|
|
|
|
|
memcpy(new, ce, size);
|
|
|
|
new->next = NULL;
|
|
|
|
new->ce_flags = (new->ce_flags & ~clear) | set;
|
|
|
|
add_index_entry(&o->result, new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE|ADD_CACHE_SKIP_DFCHECK);
|
2007-08-10 19:15:54 +00:00
|
|
|
}
|
|
|
|
|
2009-02-09 20:54:07 +00:00
|
|
|
/*
|
|
|
|
* Unlink the last component and schedule the leading directories for
|
|
|
|
* removal, such that empty directories get removed.
|
2006-07-30 18:25:18 +00:00
|
|
|
*/
|
Optimize symlink/directory detection
This is the base for making symlink detection in the middle fo a pathname
saner and (much) more efficient.
Under various loads, we want to verify that the full path leading up to a
filename is a real directory tree, and that when we successfully do an
'lstat()' on a filename, we don't get a false positive due to a symlink in
the middle of the path that git should have seen as a symlink, not as a
normal path component.
The 'has_symlink_leading_path()' function already did this, and cached
a single level of symlink information, but didn't cache the _lack_ of a
symlink, so the normal behaviour was actually the wrong way around, and we
ended up doing an 'lstat()' on each path component to check that it was a
real directory.
This caches the last detected full directory and symlink entries, and
speeds up especially deep directory structures a lot by avoiding to
lstat() all the directories leading up to each entry in the index.
[ This can - and should - probably be extended upon so that we eventually
never do a bare 'lstat()' on any path entries at *all* when checking the
index, but always check the full path carefully. Right now we do not
generally check the whole path for all our normal quick index
revalidation.
We should also make sure that we're careful about all the invalidation,
ie when we remove a link and replace it by a directory we should
invalidate the symlink cache if it matches (and vice versa for the
directory cache).
But regardless, the basic function needs to be sane to do that. The old
'has_symlink_leading_path()' was not capable enough - or indeed the code
readable enough - to really do that sanely. So I'm pushing this as not
just an optimization, but as a base for further work. ]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-05-09 16:21:07 +00:00
|
|
|
static void unlink_entry(struct cache_entry *ce)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
2009-02-09 20:54:06 +00:00
|
|
|
if (has_symlink_or_noent_leading_path(ce->name, ce_namelen(ce)))
|
2007-05-11 06:44:53 +00:00
|
|
|
return;
|
2009-02-09 20:54:07 +00:00
|
|
|
if (unlink(ce->name))
|
2006-07-30 18:25:18 +00:00
|
|
|
return;
|
2009-02-09 20:54:07 +00:00
|
|
|
schedule_dir_for_removal(ce->name, ce_namelen(ce));
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct checkout state;
|
2008-03-19 05:01:28 +00:00
|
|
|
static int check_updates(struct unpack_trees_options *o)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
2007-04-18 18:27:45 +00:00
|
|
|
unsigned cnt = 0, total = 0;
|
2007-10-30 18:57:32 +00:00
|
|
|
struct progress *progress = NULL;
|
2008-03-07 02:12:28 +00:00
|
|
|
struct index_state *index = &o->result;
|
Discard "deleted" cache entries after using them to update the working tree
Way back in read-tree.c, we used a mode 0 cache entry to indicate that
an entry had been deleted, so that the update code would remove the
working tree file, and we would just skip it when writing out the
index file afterward.
These days, unpack_trees is a library function, and it is still
leaving these entries in the active cache. Furthermore, unpack_trees
doesn't correctly ignore those entries, and who knows what other code
wouldn't expect them to be there, but just isn't yet called after a
call to unpack_trees. To avoid having other code trip over these
entries, have check_updates() remove them after it removes the working
tree files.
While we're at it, simplify the loop in check_updates(), and avoid
passing global variables as parameters to check_updates(): there is
only one call site anyway.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
2008-02-07 16:39:59 +00:00
|
|
|
int i;
|
2008-03-19 05:01:28 +00:00
|
|
|
int errs = 0;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
if (o->update && o->verbose_update) {
|
2008-03-07 02:12:28 +00:00
|
|
|
for (total = cnt = 0; cnt < index->cache_nr; cnt++) {
|
|
|
|
struct cache_entry *ce = index->cache[cnt];
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & (CE_UPDATE | CE_REMOVE))
|
2006-07-30 18:25:18 +00:00
|
|
|
total++;
|
|
|
|
}
|
|
|
|
|
2007-10-30 18:57:32 +00:00
|
|
|
progress = start_progress_delay("Checking out files",
|
Be more verbose when checkout takes a long time
So I find it irritating when git thinks for a long time without telling me
what's taking so long. And by "long time" I definitely mean less than two
seconds, which is already way too long for me.
This hits me when doing a large pull and the checkout takes a long time,
or when just switching to another branch that is old and again checkout
takes a while.
Now, git read-tree already had support for the "-v" flag that does nice
updates about what's going on, but it was delayed by two seconds, and if
the thing had already done more than half by then it would be quiet even
after that, so in practice it meant that we migth be quiet for up to four
seconds. Much too long.
So this patch changes the timeout to just one second, which makes it much
more palatable to me.
The other thing this patch does is that "git checkout" now doesn't disable
the "-v" flag when doing its thing, and only disables the output when
given the -q flag. When allowing "checkout -m" to fall back to a 3-way
merge, the users will see the error message from straight "checkout",
so we will tell them that we do fall back to make them look less scary.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-23 21:36:08 +00:00
|
|
|
total, 50, 1);
|
2006-07-30 18:25:18 +00:00
|
|
|
cnt = 0;
|
|
|
|
}
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
for (i = 0; i < index->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = index->cache[i];
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_REMOVE) {
|
2008-03-22 16:48:41 +00:00
|
|
|
display_progress(progress, ++cnt);
|
2006-07-30 18:25:18 +00:00
|
|
|
if (o->update)
|
Optimize symlink/directory detection
This is the base for making symlink detection in the middle fo a pathname
saner and (much) more efficient.
Under various loads, we want to verify that the full path leading up to a
filename is a real directory tree, and that when we successfully do an
'lstat()' on a filename, we don't get a false positive due to a symlink in
the middle of the path that git should have seen as a symlink, not as a
normal path component.
The 'has_symlink_leading_path()' function already did this, and cached
a single level of symlink information, but didn't cache the _lack_ of a
symlink, so the normal behaviour was actually the wrong way around, and we
ended up doing an 'lstat()' on each path component to check that it was a
real directory.
This caches the last detected full directory and symlink entries, and
speeds up especially deep directory structures a lot by avoiding to
lstat() all the directories leading up to each entry in the index.
[ This can - and should - probably be extended upon so that we eventually
never do a bare 'lstat()' on any path entries at *all* when checking the
index, but always check the full path carefully. Right now we do not
generally check the whole path for all our normal quick index
revalidation.
We should also make sure that we're careful about all the invalidation,
ie when we remove a link and replace it by a directory we should
invalidate the symlink cache if it matches (and vice versa for the
directory cache).
But regardless, the basic function needs to be sane to do that. The old
'has_symlink_leading_path()' was not capable enough - or indeed the code
readable enough - to really do that sanely. So I'm pushing this as not
just an optimization, but as a base for further work. ]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-05-09 16:21:07 +00:00
|
|
|
unlink_entry(ce);
|
2008-03-07 02:12:28 +00:00
|
|
|
remove_index_entry_at(&o->result, i);
|
Discard "deleted" cache entries after using them to update the working tree
Way back in read-tree.c, we used a mode 0 cache entry to indicate that
an entry had been deleted, so that the update code would remove the
working tree file, and we would just skip it when writing out the
index file afterward.
These days, unpack_trees is a library function, and it is still
leaving these entries in the active cache. Furthermore, unpack_trees
doesn't correctly ignore those entries, and who knows what other code
wouldn't expect them to be there, but just isn't yet called after a
call to unpack_trees. To avoid having other code trip over these
entries, have check_updates() remove them after it removes the working
tree files.
While we're at it, simplify the loop in check_updates(), and avoid
passing global variables as parameters to check_updates(): there is
only one call site anyway.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
2008-02-07 16:39:59 +00:00
|
|
|
i--;
|
2006-07-30 18:25:18 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-03-22 16:48:41 +00:00
|
|
|
}
|
2009-02-09 20:54:07 +00:00
|
|
|
remove_scheduled_dirs();
|
2008-03-22 16:48:41 +00:00
|
|
|
|
|
|
|
for (i = 0; i < index->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = index->cache[i];
|
|
|
|
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_UPDATE) {
|
2008-03-22 16:48:41 +00:00
|
|
|
display_progress(progress, ++cnt);
|
2008-01-15 00:03:17 +00:00
|
|
|
ce->ce_flags &= ~CE_UPDATE;
|
2007-05-11 06:44:53 +00:00
|
|
|
if (o->update) {
|
2008-03-19 05:01:28 +00:00
|
|
|
errs |= checkout_entry(ce, &state, NULL);
|
2007-05-11 06:44:53 +00:00
|
|
|
}
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
}
|
2007-10-30 18:57:33 +00:00
|
|
|
stop_progress(&progress);
|
2008-03-19 05:01:28 +00:00
|
|
|
return errs != 0;
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
static inline int call_unpack_fn(struct cache_entry **src, struct unpack_trees_options *o)
|
2008-03-06 04:15:44 +00:00
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
int ret = o->fn(src, o);
|
|
|
|
if (ret > 0)
|
2008-03-06 04:15:44 +00:00
|
|
|
ret = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unpack_index_entry(struct cache_entry *ce, struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
struct cache_entry *src[5] = { ce, };
|
2008-03-07 02:12:28 +00:00
|
|
|
|
|
|
|
o->pos++;
|
2008-03-06 04:15:44 +00:00
|
|
|
if (ce_stage(ce)) {
|
|
|
|
if (o->skip_unmerged) {
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, ce, 0, 0);
|
|
|
|
return 0;
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
}
|
2008-03-07 02:12:28 +00:00
|
|
|
return call_unpack_fn(src, o);
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int traverse_trees_recursive(int n, unsigned long dirmask, unsigned long df_conflicts, struct name_entry *names, struct traverse_info *info)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
|
|
|
int i;
|
2008-03-14 05:07:18 +00:00
|
|
|
struct tree_desc t[MAX_UNPACK_TREES];
|
2008-03-06 04:15:44 +00:00
|
|
|
struct traverse_info newinfo;
|
|
|
|
struct name_entry *p;
|
|
|
|
|
|
|
|
p = names;
|
|
|
|
while (!p->mode)
|
|
|
|
p++;
|
|
|
|
|
|
|
|
newinfo = *info;
|
|
|
|
newinfo.prev = info;
|
|
|
|
newinfo.name = *p;
|
|
|
|
newinfo.pathlen += tree_entry_len(p->path, p->sha1) + 1;
|
|
|
|
newinfo.conflicts |= df_conflicts;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++, dirmask >>= 1) {
|
|
|
|
const unsigned char *sha1 = NULL;
|
|
|
|
if (dirmask & 1)
|
|
|
|
sha1 = names[i].sha1;
|
|
|
|
fill_tree_descriptor(t+i, sha1);
|
|
|
|
}
|
2008-03-10 08:26:23 +00:00
|
|
|
return traverse_trees(n, t, &newinfo);
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare the traverse-path to the cache entry without actually
|
|
|
|
* having to generate the textual representation of the traverse
|
|
|
|
* path.
|
|
|
|
*
|
|
|
|
* NOTE! This *only* compares up to the size of the traverse path
|
|
|
|
* itself - the caller needs to do the final check for the cache
|
|
|
|
* entry having more data at the end!
|
|
|
|
*/
|
|
|
|
static int do_compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n)
|
|
|
|
{
|
|
|
|
int len, pathlen, ce_len;
|
|
|
|
const char *ce_name;
|
|
|
|
|
|
|
|
if (info->prev) {
|
|
|
|
int cmp = do_compare_entry(ce, info->prev, &info->name);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
pathlen = info->pathlen;
|
|
|
|
ce_len = ce_namelen(ce);
|
|
|
|
|
|
|
|
/* If ce_len < pathlen then we must have previously hit "name == directory" entry */
|
|
|
|
if (ce_len < pathlen)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ce_len -= pathlen;
|
|
|
|
ce_name = ce->name + pathlen;
|
|
|
|
|
|
|
|
len = tree_entry_len(n->path, n->sha1);
|
|
|
|
return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n)
|
|
|
|
{
|
|
|
|
int cmp = do_compare_entry(ce, info, n);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Even if the beginning compared identically, the ce should
|
|
|
|
* compare as bigger than a directory leading up to it!
|
|
|
|
*/
|
|
|
|
return ce_namelen(ce) > traverse_path_len(info, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct cache_entry *create_ce_entry(const struct traverse_info *info, const struct name_entry *n, int stage)
|
|
|
|
{
|
|
|
|
int len = traverse_path_len(info, n);
|
|
|
|
struct cache_entry *ce = xcalloc(1, cache_entry_size(len));
|
|
|
|
|
|
|
|
ce->ce_mode = create_ce_mode(n->mode);
|
|
|
|
ce->ce_flags = create_ce_flags(len, stage);
|
|
|
|
hashcpy(ce->sha1, n->sha1);
|
|
|
|
make_traverse_path(ce->name, info, n);
|
|
|
|
|
|
|
|
return ce;
|
|
|
|
}
|
|
|
|
|
2009-01-31 14:39:10 +00:00
|
|
|
static int unpack_nondirectories(int n, unsigned long mask,
|
|
|
|
unsigned long dirmask,
|
|
|
|
struct cache_entry **src,
|
|
|
|
const struct name_entry *names,
|
|
|
|
const struct traverse_info *info)
|
2008-03-06 04:15:44 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct unpack_trees_options *o = info->data;
|
|
|
|
unsigned long conflicts;
|
|
|
|
|
|
|
|
/* Do we have *only* directories? Nothing to do */
|
|
|
|
if (mask == dirmask && !src[0])
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
conflicts = info->conflicts;
|
|
|
|
if (o->merge)
|
|
|
|
conflicts >>= 1;
|
|
|
|
conflicts |= dirmask;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok, we've filled in up to any potential index entry in src[0],
|
|
|
|
* now do the rest.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
int stage;
|
|
|
|
unsigned int bit = 1ul << i;
|
|
|
|
if (conflicts & bit) {
|
|
|
|
src[i + o->merge] = o->df_conflict_entry;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!(mask & bit))
|
|
|
|
continue;
|
|
|
|
if (!o->merge)
|
|
|
|
stage = 0;
|
|
|
|
else if (i + 1 < o->head_idx)
|
|
|
|
stage = 1;
|
|
|
|
else if (i + 1 > o->head_idx)
|
|
|
|
stage = 3;
|
|
|
|
else
|
|
|
|
stage = 2;
|
|
|
|
src[i + o->merge] = create_ce_entry(info, names + i, stage);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (o->merge)
|
2008-03-07 02:12:28 +00:00
|
|
|
return call_unpack_fn(src, o);
|
2008-03-06 04:15:44 +00:00
|
|
|
|
|
|
|
n += o->merge;
|
|
|
|
for (i = 0; i < n; i++)
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, src[i], 0, 0);
|
2008-03-06 04:15:44 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info)
|
|
|
|
{
|
2009-01-31 14:39:10 +00:00
|
|
|
struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, };
|
2008-03-06 04:15:44 +00:00
|
|
|
struct unpack_trees_options *o = info->data;
|
|
|
|
const struct name_entry *p = names;
|
|
|
|
|
|
|
|
/* Find first entry with a real name (we could use "mask" too) */
|
|
|
|
while (!p->mode)
|
|
|
|
p++;
|
|
|
|
|
|
|
|
/* Are we supposed to look at the index too? */
|
|
|
|
if (o->merge) {
|
2008-03-07 02:12:28 +00:00
|
|
|
while (o->pos < o->src_index->cache_nr) {
|
|
|
|
struct cache_entry *ce = o->src_index->cache[o->pos];
|
2008-03-06 04:15:44 +00:00
|
|
|
int cmp = compare_entry(ce, info, p);
|
|
|
|
if (cmp < 0) {
|
|
|
|
if (unpack_index_entry(ce, o) < 0)
|
|
|
|
return -1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!cmp) {
|
2008-03-07 02:12:28 +00:00
|
|
|
o->pos++;
|
2008-03-06 04:15:44 +00:00
|
|
|
if (ce_stage(ce)) {
|
|
|
|
/*
|
|
|
|
* If we skip unmerged index entries, we'll skip this
|
|
|
|
* entry *and* the tree entries associated with it!
|
|
|
|
*/
|
2008-03-07 02:12:28 +00:00
|
|
|
if (o->skip_unmerged) {
|
|
|
|
add_entry(o, ce, 0, 0);
|
2008-03-06 04:15:44 +00:00
|
|
|
return mask;
|
2008-03-07 02:12:28 +00:00
|
|
|
}
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
src[0] = ce;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
if (unpack_nondirectories(n, mask, dirmask, src, names, info) < 0)
|
2008-03-06 04:15:44 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* Now handle any directories.. */
|
|
|
|
if (dirmask) {
|
|
|
|
unsigned long conflicts = mask & ~dirmask;
|
|
|
|
if (o->merge) {
|
|
|
|
conflicts <<= 1;
|
|
|
|
if (src[0])
|
|
|
|
conflicts |= 1;
|
|
|
|
}
|
2008-03-10 08:26:23 +00:00
|
|
|
if (traverse_trees_recursive(n, dirmask, conflicts,
|
|
|
|
names, info) < 0)
|
|
|
|
return -1;
|
2008-03-06 04:15:44 +00:00
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unpack_failed(struct unpack_trees_options *o, const char *message)
|
|
|
|
{
|
2008-03-07 21:48:40 +00:00
|
|
|
discard_index(&o->result);
|
2008-03-06 04:15:44 +00:00
|
|
|
if (!o->gently) {
|
|
|
|
if (message)
|
2008-11-10 21:07:52 +00:00
|
|
|
return error("%s", message);
|
2008-03-06 04:15:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-05-28 22:12:30 +00:00
|
|
|
/*
|
|
|
|
* N-way merge "len" trees. Returns 0 on success, -1 on failure to manipulate the
|
|
|
|
* resulting index, -2 on failure to reflect the changes to the work tree.
|
|
|
|
*/
|
2008-03-06 04:15:44 +00:00
|
|
|
int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)
|
|
|
|
{
|
2008-05-28 22:12:30 +00:00
|
|
|
int ret;
|
2006-12-04 10:11:39 +00:00
|
|
|
static struct cache_entry *dfc;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-03-14 05:07:18 +00:00
|
|
|
if (len > MAX_UNPACK_TREES)
|
|
|
|
die("unpack_trees takes at most %d trees", MAX_UNPACK_TREES);
|
2006-07-30 18:26:15 +00:00
|
|
|
memset(&state, 0, sizeof(state));
|
2006-07-30 18:25:18 +00:00
|
|
|
state.base_dir = "";
|
|
|
|
state.force = 1;
|
|
|
|
state.quiet = 1;
|
|
|
|
state.refresh_cache = 1;
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
memset(&o->result, 0, sizeof(o->result));
|
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 19:57:30 +00:00
|
|
|
o->result.initialized = 1;
|
Fix recent 'unpack_trees()'-related changes breaking 'git stash'
On Sat, 15 Mar 2008, SZEDER G?bor wrote:
>
> The testcase usually fails during the first 25 run, but sometimes it
> runs more than 100 times before failing.
Damn, this series has had more subtle issues than I ever expected.
'git stash' creates its saved working tree object with:
# state of the working tree
w_tree=$( (
rm -f "$TMP-index" &&
cp -p ${GIT_INDEX_FILE-"$GIT_DIR/index"} "$TMP-index" &&
GIT_INDEX_FILE="$TMP-index" &&
export GIT_INDEX_FILE &&
git read-tree -m $i_tree &&
git add -u &&
git write-tree &&
rm -f "$TMP-index"
) ) ||
die "Cannot save the current worktree state"
which creates a new index file with the updates, and writes the tree from
that.
We have this logic where we compare the timestamp of the index with the
timestamp of the files and we then write them out "smudged" if they are
the same, and it basically depends on the fact that the date on the index
file is compared with the date encoded in the stat information itself.
And what is going on is:
- we create a new index file with that "cp". We are careful to preserve
the timestamps by using "-p", so this one should be all ok.
- then we *update* that index by resetting it to the tree with git
read-tree, but now we do *not* preserve the timestamp on this new copy
any more, even though we copy over all the timestamps on the files that
are indexed from the stat information!
Now, we always had that problem when re-writing the index, but we had this
clever workaround in the writing part: if the source had racily clean
entries, then when we wrote those out (and thus can't depend on the index
fiel timestamp showing that they are racily clean any more!), we would
smudge them when writing.
IOW, we handle this issue by having write_index() do this:
for (i = 0; i < entries; i++) {
...
if (is_racy_timestamp(istate, ce))
ce_smudge_racily_clean_entry(ce);
..
when writing out entries. And that all took care of it, because now when
we wrote the new index, we'd change the timestamp on the index, yes, but
we'd smudge the entries we wrote out, so now the resulting index would
still show that file as not-up-to-date any more.
But with commit 34110cd4e394e3f92c01a4709689b384c34645d8 ("Make
'unpack_trees()' have a separate source and destination index"), this
logic no longer triggers, because we now write out the "result" index, and
that one never got its timestamp updated from the source index, so it had
lost all that "is_racy_timestamp()" information!
This trivial patch fixes it. It looks trivial, and it's a simple fix, but
boy did it take me way too much thinking and explaining to myself to
explain why there was a problem in the first place!
The trivial fix is to just copy the index timestamp from the source index
into the result index. But we only do this if we *have* a source index, of
course, and if we will even bother to use the result.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-15 04:20:41 +00:00
|
|
|
if (o->src_index)
|
|
|
|
o->result.timestamp = o->src_index->timestamp;
|
2006-07-30 18:25:18 +00:00
|
|
|
o->merge_size = len;
|
2006-12-04 10:11:39 +00:00
|
|
|
|
|
|
|
if (!dfc)
|
correct cache_entry allocation
Most cache_entry structs are allocated by using the
cache_entry_size macro, which rounds the size of the struct
up to the nearest multiple of 8 bytes (presumably to avoid
memory fragmentation).
There is one exception: the special "conflict entry" is
allocated with an empty name, and so is explicitly given
just one extra byte to hold the NUL.
However, later code doesn't realize that this particular
struct has been allocated differently, and happily tries
reading and copying it based on the ce_size macro, which
assumes the 8-byte alignment.
This can lead to reading uninitalized data, though since
that data is simply padding, there shouldn't be any problem
as a result. Still, it makes sense to hold the padding
assumption so as not to surprise later maintainers.
This fixes valgrind errors in t1005, t3030, t4002, and
t4114.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-10-23 04:30:58 +00:00
|
|
|
dfc = xcalloc(1, cache_entry_size(0));
|
2006-12-04 10:11:39 +00:00
|
|
|
o->df_conflict_entry = dfc;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
if (len) {
|
2008-03-06 04:15:44 +00:00
|
|
|
const char *prefix = o->prefix ? o->prefix : "";
|
|
|
|
struct traverse_info info;
|
|
|
|
|
|
|
|
setup_traverse_info(&info, prefix);
|
|
|
|
info.fn = unpack_callback;
|
|
|
|
info.data = o;
|
|
|
|
|
|
|
|
if (traverse_trees(len, t, &info) < 0)
|
|
|
|
return unpack_failed(o, NULL);
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
|
2008-03-06 04:15:44 +00:00
|
|
|
/* Any left-over entries in the index? */
|
|
|
|
if (o->merge) {
|
2008-03-07 02:12:28 +00:00
|
|
|
while (o->pos < o->src_index->cache_nr) {
|
|
|
|
struct cache_entry *ce = o->src_index->cache[o->pos];
|
2008-03-06 04:15:44 +00:00
|
|
|
if (unpack_index_entry(ce, o) < 0)
|
|
|
|
return unpack_failed(o, NULL);
|
2008-02-07 16:39:52 +00:00
|
|
|
}
|
|
|
|
}
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-03-06 04:15:44 +00:00
|
|
|
if (o->trivial_merges_only && o->nontrivial_merge)
|
|
|
|
return unpack_failed(o, "Merge requires file-level merging");
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
o->src_index = NULL;
|
2008-05-28 22:12:30 +00:00
|
|
|
ret = check_updates(o) ? (-2) : 0;
|
2008-03-07 02:12:28 +00:00
|
|
|
if (o->dst_index)
|
|
|
|
*o->dst_index = o->result;
|
2008-05-28 22:12:30 +00:00
|
|
|
return ret;
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
/* Here come the merge functions */
|
|
|
|
|
2008-05-17 19:03:49 +00:00
|
|
|
static int reject_merge(struct cache_entry *ce, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
2008-05-17 19:03:49 +00:00
|
|
|
return error(ERRORMSG(o, would_overwrite), ce->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int same(struct cache_entry *a, struct cache_entry *b)
|
|
|
|
{
|
|
|
|
if (!!a != !!b)
|
|
|
|
return 0;
|
|
|
|
if (!a && !b)
|
|
|
|
return 1;
|
|
|
|
return a->ce_mode == b->ce_mode &&
|
2006-08-17 18:54:57 +00:00
|
|
|
!hashcmp(a->sha1, b->sha1);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When a CE gets turned into an unmerged entry, we
|
|
|
|
* want it to be up-to-date
|
|
|
|
*/
|
2008-02-07 16:39:48 +00:00
|
|
|
static int verify_uptodate(struct cache_entry *ce,
|
2006-07-30 18:26:15 +00:00
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (o->index_only || o->reset)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
if (!lstat(ce->name, &st)) {
|
2008-03-07 02:12:28 +00:00
|
|
|
unsigned changed = ie_match_stat(o->src_index, ce, &st, CE_MATCH_IGNORE_VALID);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (!changed)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
unpack-trees.c: assume submodules are clean during check-out
Sven originally raised this issue:
If you have a submodule checked out and you go back (or
forward) to a revision of the supermodule that contains a
different revision of the submodule and then switch to
another revision, it will complain that the submodule is not
uptodate, because git simply didn't update the submodule in
the first move.
The current policy is to consider it is perfectly normal that
checked-out submodule is out-of-sync wrt the supermodule index.
At least until we introduce a superproject repository
configuration option that says "in this repository, I do care
about this submodule and at any time I move around in the
superproject, recursively check out the submodule to match", it
is a reasonable policy, as we currently do not recursively
checkout the submodules at all. The most extreme case of this
policy is that the superproject index knows about the submodule
but the subdirectory does not even have to be checked out.
The function verify_uptodate(), called during the two-way merge
aka branch switching, is about "make sure the filesystem entity
that corresponds to this cache entry is up to date, lest we lose
the local modifications". As we explicitly allow submodule
checkout to drift from the supermodule index entry, the check
should say "Ok, for submodules, not matching is the norm" for
now.
Later when we have the ability to mark "I care about this
submodule to be always in sync with the superproject" (thereby
implementing automatic recursive checkout and perhaps diff,
among other things), we should check if the submodule in
question is marked as such and perform the current test.
Acked-by: Lars Hjemli <hjemli@gmail.com>
Acked-by: Sven Verdoolaege <skimo@kotnet.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-04 05:13:09 +00:00
|
|
|
/*
|
|
|
|
* NEEDSWORK: the current default policy is to allow
|
|
|
|
* submodule to be out of sync wrt the supermodule
|
|
|
|
* index. This needs to be tightened later for
|
|
|
|
* submodules that are marked to be automatically
|
|
|
|
* checked out.
|
|
|
|
*/
|
2008-01-15 00:03:17 +00:00
|
|
|
if (S_ISGITLINK(ce->ce_mode))
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
errno = 0;
|
|
|
|
}
|
|
|
|
if (errno == ENOENT)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
2008-05-17 19:03:49 +00:00
|
|
|
error(ERRORMSG(o, not_uptodate_file), ce->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
2008-03-06 20:26:14 +00:00
|
|
|
static void invalidate_ce_path(struct cache_entry *ce, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
if (ce)
|
2008-03-07 02:12:28 +00:00
|
|
|
cache_tree_invalidate_path(o->src_index->cache_tree, ce->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
2007-07-17 18:28:28 +00:00
|
|
|
/*
|
|
|
|
* Check that checking out ce->sha1 in subdir ce->name is not
|
|
|
|
* going to overwrite any working files.
|
|
|
|
*
|
|
|
|
* Currently, git does not checkout subprojects during a superproject
|
|
|
|
* checkout, so it is not going to overwrite anything.
|
|
|
|
*/
|
|
|
|
static int verify_clean_submodule(struct cache_entry *ce, const char *action,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int verify_clean_subdirectory(struct cache_entry *ce, const char *action,
|
2007-03-16 06:25:22 +00:00
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
/*
|
2007-07-17 18:28:28 +00:00
|
|
|
* we are about to extract "ce->name"; we would not want to lose
|
2007-03-16 06:25:22 +00:00
|
|
|
* anything in the existing directory there.
|
|
|
|
*/
|
|
|
|
int namelen;
|
2009-01-01 20:54:33 +00:00
|
|
|
int i;
|
2007-03-16 06:25:22 +00:00
|
|
|
struct dir_struct d;
|
|
|
|
char *pathbuf;
|
|
|
|
int cnt = 0;
|
2007-07-17 18:28:28 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
|
2008-01-15 00:03:17 +00:00
|
|
|
if (S_ISGITLINK(ce->ce_mode) &&
|
2007-07-17 18:28:28 +00:00
|
|
|
resolve_gitlink_ref(ce->name, "HEAD", sha1) == 0) {
|
|
|
|
/* If we are not going to update the submodule, then
|
|
|
|
* we don't care.
|
|
|
|
*/
|
|
|
|
if (!hashcmp(sha1, ce->sha1))
|
|
|
|
return 0;
|
|
|
|
return verify_clean_submodule(ce, action, o);
|
|
|
|
}
|
2007-03-16 06:25:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* First let's make sure we do not have a local modification
|
|
|
|
* in that directory.
|
|
|
|
*/
|
2007-07-17 18:28:28 +00:00
|
|
|
namelen = strlen(ce->name);
|
2009-01-01 20:54:33 +00:00
|
|
|
for (i = o->pos; i < o->src_index->cache_nr; i++) {
|
2009-01-01 20:54:32 +00:00
|
|
|
struct cache_entry *ce2 = o->src_index->cache[i];
|
|
|
|
int len = ce_namelen(ce2);
|
2007-03-16 06:25:22 +00:00
|
|
|
if (len < namelen ||
|
2009-01-01 20:54:32 +00:00
|
|
|
strncmp(ce->name, ce2->name, namelen) ||
|
|
|
|
ce2->name[namelen] != '/')
|
2007-03-16 06:25:22 +00:00
|
|
|
break;
|
|
|
|
/*
|
2009-01-01 20:54:32 +00:00
|
|
|
* ce2->name is an entry in the subdirectory.
|
2007-03-16 06:25:22 +00:00
|
|
|
*/
|
2009-01-01 20:54:32 +00:00
|
|
|
if (!ce_stage(ce2)) {
|
|
|
|
if (verify_uptodate(ce2, o))
|
2008-02-07 16:39:48 +00:00
|
|
|
return -1;
|
2009-01-01 20:54:32 +00:00
|
|
|
add_entry(o, ce2, CE_REMOVE, 0);
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Then we need to make sure that we do not lose a locally
|
|
|
|
* present file that is not ignored.
|
|
|
|
*/
|
|
|
|
pathbuf = xmalloc(namelen + 2);
|
2007-07-17 18:28:28 +00:00
|
|
|
memcpy(pathbuf, ce->name, namelen);
|
2007-03-16 06:25:22 +00:00
|
|
|
strcpy(pathbuf+namelen, "/");
|
|
|
|
|
|
|
|
memset(&d, 0, sizeof(d));
|
|
|
|
if (o->dir)
|
|
|
|
d.exclude_per_dir = o->dir->exclude_per_dir;
|
2007-07-17 18:28:28 +00:00
|
|
|
i = read_directory(&d, ce->name, pathbuf, namelen+1, NULL);
|
2007-03-16 06:25:22 +00:00
|
|
|
if (i)
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
2008-05-17 19:03:49 +00:00
|
|
|
error(ERRORMSG(o, not_uptodate_dir), ce->name);
|
2007-03-16 06:25:22 +00:00
|
|
|
free(pathbuf);
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2008-03-22 16:35:59 +00:00
|
|
|
/*
|
|
|
|
* This gets called when there was no index entry for the tree entry 'dst',
|
|
|
|
* but we found a file in the working tree that 'lstat()' said was fine,
|
|
|
|
* and we're on a case-insensitive filesystem.
|
|
|
|
*
|
|
|
|
* See if we can find a case-insensitive match in the index that also
|
|
|
|
* matches the stat information, and assume it's that other file!
|
|
|
|
*/
|
|
|
|
static int icase_exists(struct unpack_trees_options *o, struct cache_entry *dst, struct stat *st)
|
|
|
|
{
|
|
|
|
struct cache_entry *src;
|
|
|
|
|
|
|
|
src = index_name_exists(o->src_index, dst->name, ce_namelen(dst), 1);
|
|
|
|
return src && !ie_match_stat(o->src_index, src, st, CE_MATCH_IGNORE_VALID);
|
|
|
|
}
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
/*
|
|
|
|
* We do not want to remove or overwrite a working tree file that
|
2006-12-05 00:00:46 +00:00
|
|
|
* is not tracked, unless it is ignored.
|
2006-07-30 18:26:15 +00:00
|
|
|
*/
|
2008-02-07 16:39:48 +00:00
|
|
|
static int verify_absent(struct cache_entry *ce, const char *action,
|
|
|
|
struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (o->index_only || o->reset || !o->update)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
|
2009-02-09 20:54:06 +00:00
|
|
|
if (has_symlink_or_noent_leading_path(ce->name, ce_namelen(ce)))
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-07-12 08:04:16 +00:00
|
|
|
|
2007-07-17 18:28:28 +00:00
|
|
|
if (!lstat(ce->name, &st)) {
|
2009-01-01 20:54:31 +00:00
|
|
|
int ret;
|
2008-02-01 04:23:25 +00:00
|
|
|
int dtype = ce_to_dtype(ce);
|
2008-03-21 22:53:00 +00:00
|
|
|
struct cache_entry *result;
|
2007-03-16 06:25:22 +00:00
|
|
|
|
2008-03-22 16:35:59 +00:00
|
|
|
/*
|
|
|
|
* It may be that the 'lstat()' succeeded even though
|
|
|
|
* target 'ce' was absent, because there is an old
|
|
|
|
* entry that is different only in case..
|
|
|
|
*
|
|
|
|
* Ignore that lstat() if it matches.
|
|
|
|
*/
|
|
|
|
if (ignore_case && icase_exists(o, ce, &st))
|
|
|
|
return 0;
|
|
|
|
|
2008-02-01 04:23:25 +00:00
|
|
|
if (o->dir && excluded(o->dir, ce->name, &dtype))
|
2007-03-16 06:25:22 +00:00
|
|
|
/*
|
2007-07-17 18:28:28 +00:00
|
|
|
* ce->name is explicitly excluded, so it is Ok to
|
2007-03-16 06:25:22 +00:00
|
|
|
* overwrite it.
|
|
|
|
*/
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
/*
|
|
|
|
* We are checking out path "foo" and
|
|
|
|
* found "foo/." in the working tree.
|
|
|
|
* This is tricky -- if we have modified
|
|
|
|
* files that are in "foo/" we would lose
|
|
|
|
* it.
|
|
|
|
*/
|
2009-01-01 20:54:31 +00:00
|
|
|
ret = verify_clean_subdirectory(ce, action, o);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2007-03-16 06:25:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this removed entries from the index,
|
|
|
|
* what that means is:
|
|
|
|
*
|
2009-01-01 20:54:32 +00:00
|
|
|
* (1) the caller unpack_callback() saw path/foo
|
2007-03-16 06:25:22 +00:00
|
|
|
* in the index, and it has not removed it because
|
|
|
|
* it thinks it is handling 'path' as blob with
|
|
|
|
* D/F conflict;
|
|
|
|
* (2) we will return "ok, we placed a merged entry
|
|
|
|
* in the index" which would cause o->pos to be
|
|
|
|
* incremented by one;
|
|
|
|
* (3) however, original o->pos now has 'path/foo'
|
|
|
|
* marked with "to be removed".
|
|
|
|
*
|
|
|
|
* We need to increment it by the number of
|
|
|
|
* deleted entries here.
|
|
|
|
*/
|
2009-01-01 20:54:31 +00:00
|
|
|
o->pos += ret;
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The previous round may already have decided to
|
|
|
|
* delete this path, which is in a subdirectory that
|
|
|
|
* is being replaced with a blob.
|
|
|
|
*/
|
2008-03-21 22:55:19 +00:00
|
|
|
result = index_name_exists(&o->result, ce->name, ce_namelen(ce), 0);
|
2008-03-21 22:53:00 +00:00
|
|
|
if (result) {
|
|
|
|
if (result->ce_flags & CE_REMOVE)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
|
|
|
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
2008-05-17 19:03:49 +00:00
|
|
|
error(ERRORMSG(o, would_lose_untracked), ce->name, action);
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int merged_entry(struct cache_entry *merge, struct cache_entry *old,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
2008-03-16 18:42:50 +00:00
|
|
|
int update = CE_UPDATE;
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
if (old) {
|
|
|
|
/*
|
|
|
|
* See if we can re-use the old CE directly?
|
|
|
|
* That way we get the uptodate stat info.
|
|
|
|
*
|
2008-03-16 18:42:50 +00:00
|
|
|
* This also removes the UPDATE flag on a match; otherwise
|
|
|
|
* we will end up overwriting local changes in the work tree.
|
2006-07-30 18:26:15 +00:00
|
|
|
*/
|
|
|
|
if (same(old, merge)) {
|
2008-02-23 04:41:17 +00:00
|
|
|
copy_cache_entry(merge, old);
|
2008-03-16 18:42:50 +00:00
|
|
|
update = 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
} else {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_uptodate(old, o))
|
|
|
|
return -1;
|
2008-03-06 20:26:14 +00:00
|
|
|
invalidate_ce_path(old, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_absent(merge, "overwritten", o))
|
|
|
|
return -1;
|
2008-03-06 20:26:14 +00:00
|
|
|
invalidate_ce_path(merge, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
2008-03-16 18:42:50 +00:00
|
|
|
add_entry(o, merge, update, CE_STAGEMASK);
|
2006-07-30 18:26:15 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int deleted_entry(struct cache_entry *ce, struct cache_entry *old,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
/* Did it exist in the index? */
|
|
|
|
if (!old) {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_absent(ce, "removed", o))
|
|
|
|
return -1;
|
2008-03-07 02:12:28 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (verify_uptodate(old, o))
|
|
|
|
return -1;
|
|
|
|
add_entry(o, ce, CE_REMOVE, 0);
|
2008-03-06 20:26:14 +00:00
|
|
|
invalidate_ce_path(ce, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-04-02 07:06:12 +00:00
|
|
|
static int keep_entry(struct cache_entry *ce, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, ce, 0, 0);
|
2006-07-30 18:26:15 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if DBRT_DEBUG
|
|
|
|
static void show_stage_entry(FILE *o,
|
|
|
|
const char *label, const struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
if (!ce)
|
|
|
|
fprintf(o, "%s (missing)\n", label);
|
|
|
|
else
|
|
|
|
fprintf(o, "%s%06o %s %d\t%s\n",
|
|
|
|
label,
|
2008-01-15 00:03:17 +00:00
|
|
|
ce->ce_mode,
|
2006-07-30 18:26:15 +00:00
|
|
|
sha1_to_hex(ce->sha1),
|
|
|
|
ce_stage(ce),
|
|
|
|
ce->name);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
int threeway_merge(struct cache_entry **stages, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *index;
|
|
|
|
struct cache_entry *head;
|
|
|
|
struct cache_entry *remote = stages[o->head_idx + 1];
|
|
|
|
int count;
|
|
|
|
int head_match = 0;
|
|
|
|
int remote_match = 0;
|
|
|
|
|
|
|
|
int df_conflict_head = 0;
|
|
|
|
int df_conflict_remote = 0;
|
|
|
|
|
|
|
|
int any_anc_missing = 0;
|
|
|
|
int no_anc_exists = 1;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
2007-04-07 12:49:19 +00:00
|
|
|
if (!stages[i] || stages[i] == o->df_conflict_entry)
|
2006-07-30 18:26:15 +00:00
|
|
|
any_anc_missing = 1;
|
2007-04-07 12:49:19 +00:00
|
|
|
else
|
2006-07-30 18:26:15 +00:00
|
|
|
no_anc_exists = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = stages[0];
|
|
|
|
head = stages[o->head_idx];
|
|
|
|
|
|
|
|
if (head == o->df_conflict_entry) {
|
|
|
|
df_conflict_head = 1;
|
|
|
|
head = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (remote == o->df_conflict_entry) {
|
|
|
|
df_conflict_remote = 1;
|
|
|
|
remote = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* First, if there's a #16 situation, note that to prevent #13
|
|
|
|
* and #14.
|
|
|
|
*/
|
|
|
|
if (!same(remote, head)) {
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
|
|
|
if (same(stages[i], head)) {
|
|
|
|
head_match = i;
|
|
|
|
}
|
|
|
|
if (same(stages[i], remote)) {
|
|
|
|
remote_match = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We start with cases where the index is allowed to match
|
|
|
|
* something other than the head: #14(ALT) and #2ALT, where it
|
|
|
|
* is permitted to match the result instead.
|
|
|
|
*/
|
|
|
|
/* #14, #14ALT, #2ALT */
|
|
|
|
if (remote && !df_conflict_head && head_match && !remote_match) {
|
|
|
|
if (index && !same(index, remote) && !same(index, head))
|
2008-05-17 19:03:49 +00:00
|
|
|
return o->gently ? -1 : reject_merge(index, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
return merged_entry(remote, index, o);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we have an entry in the index cache, then we want to
|
|
|
|
* make sure that it matches head.
|
|
|
|
*/
|
2008-02-07 16:40:02 +00:00
|
|
|
if (index && !same(index, head))
|
2008-05-17 19:03:49 +00:00
|
|
|
return o->gently ? -1 : reject_merge(index, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
if (head) {
|
|
|
|
/* #5ALT, #15 */
|
|
|
|
if (same(head, remote))
|
|
|
|
return merged_entry(head, index, o);
|
|
|
|
/* #13, #3ALT */
|
|
|
|
if (!df_conflict_remote && remote_match && !head_match)
|
|
|
|
return merged_entry(head, index, o);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* #1 */
|
2008-03-07 02:12:28 +00:00
|
|
|
if (!head && !remote && any_anc_missing)
|
2006-07-30 18:26:15 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Under the new "aggressive" rule, we resolve mostly trivial
|
|
|
|
* cases that we historically had git-merge-one-file resolve.
|
|
|
|
*/
|
|
|
|
if (o->aggressive) {
|
|
|
|
int head_deleted = !head && !df_conflict_head;
|
|
|
|
int remote_deleted = !remote && !df_conflict_remote;
|
2007-07-17 18:28:28 +00:00
|
|
|
struct cache_entry *ce = NULL;
|
2007-04-07 12:49:19 +00:00
|
|
|
|
|
|
|
if (index)
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = index;
|
2007-04-07 12:49:19 +00:00
|
|
|
else if (head)
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = head;
|
2007-04-07 12:49:19 +00:00
|
|
|
else if (remote)
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = remote;
|
2007-04-07 12:49:19 +00:00
|
|
|
else {
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
|
|
|
if (stages[i] && stages[i] != o->df_conflict_entry) {
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = stages[i];
|
2007-04-07 12:49:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
/*
|
|
|
|
* Deleted in both.
|
|
|
|
* Deleted in one and unchanged in the other.
|
|
|
|
*/
|
|
|
|
if ((head_deleted && remote_deleted) ||
|
|
|
|
(head_deleted && remote && remote_match) ||
|
|
|
|
(remote_deleted && head && head_match)) {
|
|
|
|
if (index)
|
|
|
|
return deleted_entry(index, index, o);
|
2008-03-07 02:12:28 +00:00
|
|
|
if (ce && !head_deleted) {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_absent(ce, "removed", o))
|
|
|
|
return -1;
|
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Added in both, identically.
|
|
|
|
*/
|
|
|
|
if (no_anc_exists && head && remote && same(head, remote))
|
|
|
|
return merged_entry(head, index, o);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Below are "no merge" cases, which require that the index be
|
|
|
|
* up-to-date to avoid the files getting overwritten with
|
|
|
|
* conflict resolution files.
|
|
|
|
*/
|
|
|
|
if (index) {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_uptodate(index, o))
|
|
|
|
return -1;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
o->nontrivial_merge = 1;
|
|
|
|
|
2007-04-07 12:42:01 +00:00
|
|
|
/* #2, #3, #4, #6, #7, #9, #10, #11. */
|
2006-07-30 18:26:15 +00:00
|
|
|
count = 0;
|
|
|
|
if (!head_match || !remote_match) {
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
2007-04-07 12:49:19 +00:00
|
|
|
if (stages[i] && stages[i] != o->df_conflict_entry) {
|
2007-04-02 07:06:12 +00:00
|
|
|
keep_entry(stages[i], o);
|
2006-07-30 18:26:15 +00:00
|
|
|
count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#if DBRT_DEBUG
|
|
|
|
else {
|
|
|
|
fprintf(stderr, "read-tree: warning #16 detected\n");
|
|
|
|
show_stage_entry(stderr, "head ", stages[head_match]);
|
|
|
|
show_stage_entry(stderr, "remote ", stages[remote_match]);
|
|
|
|
}
|
|
|
|
#endif
|
2007-04-02 07:06:12 +00:00
|
|
|
if (head) { count += keep_entry(head, o); }
|
|
|
|
if (remote) { count += keep_entry(remote, o); }
|
2006-07-30 18:26:15 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Two-way merge.
|
|
|
|
*
|
|
|
|
* The rule is to "carry forward" what is in the index without losing
|
|
|
|
* information across a "fast forward", favoring a successful merge
|
|
|
|
* over a merge failure when it makes sense. For details of the
|
|
|
|
* "carry forward" rule, please see <Documentation/git-read-tree.txt>.
|
|
|
|
*
|
|
|
|
*/
|
2008-03-07 02:12:28 +00:00
|
|
|
int twoway_merge(struct cache_entry **src, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *current = src[0];
|
2007-04-02 23:29:56 +00:00
|
|
|
struct cache_entry *oldtree = src[1];
|
|
|
|
struct cache_entry *newtree = src[2];
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
if (o->merge_size != 2)
|
|
|
|
return error("Cannot do a twoway merge of %d trees",
|
|
|
|
o->merge_size);
|
|
|
|
|
2007-04-02 23:29:56 +00:00
|
|
|
if (oldtree == o->df_conflict_entry)
|
|
|
|
oldtree = NULL;
|
|
|
|
if (newtree == o->df_conflict_entry)
|
|
|
|
newtree = NULL;
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
if (current) {
|
|
|
|
if ((!oldtree && !newtree) || /* 4 and 5 */
|
|
|
|
(!oldtree && newtree &&
|
|
|
|
same(current, newtree)) || /* 6 and 7 */
|
|
|
|
(oldtree && newtree &&
|
|
|
|
same(oldtree, newtree)) || /* 14 and 15 */
|
|
|
|
(oldtree && newtree &&
|
2007-04-02 23:29:56 +00:00
|
|
|
!same(oldtree, newtree) && /* 18 and 19 */
|
2006-07-30 18:26:15 +00:00
|
|
|
same(current, newtree))) {
|
2007-04-02 07:06:12 +00:00
|
|
|
return keep_entry(current, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
else if (oldtree && !newtree && same(current, oldtree)) {
|
|
|
|
/* 10 or 11 */
|
|
|
|
return deleted_entry(oldtree, current, o);
|
|
|
|
}
|
|
|
|
else if (oldtree && newtree &&
|
|
|
|
same(current, oldtree) && !same(current, newtree)) {
|
|
|
|
/* 20 or 21 */
|
|
|
|
return merged_entry(newtree, current, o);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* all other failures */
|
|
|
|
if (oldtree)
|
2008-05-17 19:03:49 +00:00
|
|
|
return o->gently ? -1 : reject_merge(oldtree, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (current)
|
2008-05-17 19:03:49 +00:00
|
|
|
return o->gently ? -1 : reject_merge(current, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (newtree)
|
2008-05-17 19:03:49 +00:00
|
|
|
return o->gently ? -1 : reject_merge(newtree, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
checkout: do not lose staged removal
The logic to checkout a different commit implements the safety to never
lose user's local changes. For example, switching from a commit to
another commit, when you have changed a path that is different between
them, need to merge your changes to the version from the switched-to
commit, which you may not necessarily be able to resolve easily. By
default, "git checkout" refused to switch branches, to give you a chance
to stash your local changes (or use "-m" to merge, accepting the risks of
getting conflicts).
This safety, however, had one deliberate hole since early June 2005. When
your local change was to remove a path (and optionally to stage that
removal), the command checked out the path from the switched-to commit
nevertheless.
This was to allow an initial checkout to happen smoothly (e.g. an initial
checkout is done by starting with an empty index and switching from the
commit at the HEAD to the same commit). We can tighten the rule slightly
to allow this special case to pass, without losing sight of removal
explicitly done by the user, by noticing if the index is truly empty when
the operation begins.
For historical background, see:
http://thread.gmane.org/gmane.comp.version-control.git/4641/focus=4646
This case is marked as *0* in the message, which both Linus and I said "it
feels somewhat wrong but otherwise we cannot start from an empty index".
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-08 02:49:25 +00:00
|
|
|
else if (newtree) {
|
|
|
|
if (oldtree && !o->initial_checkout) {
|
|
|
|
/*
|
|
|
|
* deletion of the path was staged;
|
|
|
|
*/
|
|
|
|
if (same(oldtree, newtree))
|
|
|
|
return 1;
|
|
|
|
return reject_merge(oldtree, o);
|
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
return merged_entry(newtree, current, o);
|
checkout: do not lose staged removal
The logic to checkout a different commit implements the safety to never
lose user's local changes. For example, switching from a commit to
another commit, when you have changed a path that is different between
them, need to merge your changes to the version from the switched-to
commit, which you may not necessarily be able to resolve easily. By
default, "git checkout" refused to switch branches, to give you a chance
to stash your local changes (or use "-m" to merge, accepting the risks of
getting conflicts).
This safety, however, had one deliberate hole since early June 2005. When
your local change was to remove a path (and optionally to stage that
removal), the command checked out the path from the switched-to commit
nevertheless.
This was to allow an initial checkout to happen smoothly (e.g. an initial
checkout is done by starting with an empty index and switching from the
commit at the HEAD to the same commit). We can tighten the rule slightly
to allow this special case to pass, without losing sight of removal
explicitly done by the user, by noticing if the index is truly empty when
the operation begins.
For historical background, see:
http://thread.gmane.org/gmane.comp.version-control.git/4641/focus=4646
This case is marked as *0* in the message, which both Linus and I said "it
feels somewhat wrong but otherwise we cannot start from an empty index".
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-08 02:49:25 +00:00
|
|
|
}
|
2007-08-10 19:31:20 +00:00
|
|
|
return deleted_entry(oldtree, current, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bind merge.
|
|
|
|
*
|
|
|
|
* Keep the index entries at stage0, collapse stage1 but make sure
|
|
|
|
* stage0 does not have anything there.
|
|
|
|
*/
|
|
|
|
int bind_merge(struct cache_entry **src,
|
2008-03-07 02:12:28 +00:00
|
|
|
struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *old = src[0];
|
|
|
|
struct cache_entry *a = src[1];
|
|
|
|
|
|
|
|
if (o->merge_size != 1)
|
|
|
|
return error("Cannot do a bind merge of %d trees\n",
|
|
|
|
o->merge_size);
|
|
|
|
if (a && old)
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
2008-05-17 19:03:49 +00:00
|
|
|
error(ERRORMSG(o, bind_overlap), a->name, old->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (!a)
|
2007-04-02 07:06:12 +00:00
|
|
|
return keep_entry(old, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
else
|
|
|
|
return merged_entry(a, NULL, o);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* One-way merge.
|
|
|
|
*
|
|
|
|
* The rule is:
|
|
|
|
* - take the stat information from stage0, take the data from stage1
|
|
|
|
*/
|
2008-03-07 02:12:28 +00:00
|
|
|
int oneway_merge(struct cache_entry **src, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *old = src[0];
|
|
|
|
struct cache_entry *a = src[1];
|
|
|
|
|
|
|
|
if (o->merge_size != 1)
|
|
|
|
return error("Cannot do a oneway merge of %d trees",
|
|
|
|
o->merge_size);
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
if (!a)
|
2006-07-30 18:26:15 +00:00
|
|
|
return deleted_entry(old, old, o);
|
2008-03-07 02:12:28 +00:00
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
if (old && same(old, a)) {
|
2008-03-07 02:12:28 +00:00
|
|
|
int update = 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
if (o->reset) {
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(old->name, &st) ||
|
2008-03-07 02:12:28 +00:00
|
|
|
ie_match_stat(o->src_index, old, &st, CE_MATCH_IGNORE_VALID))
|
|
|
|
update |= CE_UPDATE;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, old, update, 0);
|
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
return merged_entry(a, old, o);
|
|
|
|
}
|