summaryrefslogtreecommitdiff
path: root/read-tree.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-06-06 03:02:31 (GMT)
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-06-06 03:02:31 (GMT)
commit02ede67ad45973f9f8d07db7896a537de97d21b6 (patch)
treed13f55becd5ed77a9fd0b47162bfa2d7f56285db /read-tree.c
parent9b63f50148bd155c00b6893dbbf48583f7b0848d (diff)
downloadgit-02ede67ad45973f9f8d07db7896a537de97d21b6.zip
git-02ede67ad45973f9f8d07db7896a537de97d21b6.tar.gz
git-02ede67ad45973f9f8d07db7896a537de97d21b6.tar.bz2
git-read-tree: be a lot more careful about merging dirty trees
We don't want to overwrite state that we haven't committed yet when merging, so it's better to make git-read-tree fail than end up with a merge tree that ends up not having the dirty changes. Update git-resolve-script to fail cleanly when git-read-tree fails.
Diffstat (limited to 'read-tree.c')
-rw-r--r--read-tree.c54
1 files changed, 51 insertions, 3 deletions
diff --git a/read-tree.c b/read-tree.c
index 283f4d8..647f501 100644
--- a/read-tree.c
+++ b/read-tree.c
@@ -93,11 +93,46 @@ static struct cache_entry *merge_entries(struct cache_entry *a,
return NULL;
}
+/*
+ * When a CE gets turned into an unmerged entry, we
+ * want it to be up-to-date
+ */
+static void verify_uptodate(struct cache_entry *ce)
+{
+ struct stat st;
+
+ if (!lstat(ce->name, &st)) {
+ unsigned changed = ce_match_stat(ce, &st);
+ if (!changed)
+ return;
+ errno = 0;
+ }
+ if (errno == ENOENT)
+ return;
+ die("Entry '%s' not uptodate. Cannot merge.", ce->name);
+}
+
+/*
+ * If the old tree contained a CE that isn't even in the
+ * result, that's always a problem, regardless of whether
+ * it's up-to-date or not (ie it can be a file that we
+ * have updated but not committed yet).
+ */
+static void verify_cleared(struct cache_entry *ce)
+{
+ if (ce)
+ die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name);
+}
+
+static int old_match(struct cache_entry *old, struct cache_entry *a)
+{
+ return old && path_matches(old, a) && same(old, a);
+}
+
static void trivially_merge_cache(struct cache_entry **src, int nr)
{
- static struct cache_entry null_entry;
struct cache_entry **dst = src;
- struct cache_entry *old = &null_entry;
+ struct cache_entry *old = NULL;
while (nr) {
struct cache_entry *ce, *result;
@@ -106,6 +141,7 @@ static void trivially_merge_cache(struct cache_entry **src, int nr)
/* We throw away original cache entries except for the stat information */
if (!ce_stage(ce)) {
+ verify_cleared(old);
old = ce;
src++;
nr--;
@@ -117,18 +153,30 @@ static void trivially_merge_cache(struct cache_entry **src, int nr)
* See if we can re-use the old CE directly?
* That way we get the uptodate stat info.
*/
- if (path_matches(result, old) && same(result, old))
+ if (old_match(old, result)) {
*result = *old;
+ old = NULL;
+ }
ce = result;
ce->ce_flags &= ~htons(CE_STAGEMASK);
src += 2;
nr -= 2;
active_nr -= 2;
}
+
+ /*
+ * If we had an old entry that we now effectively
+ * overwrite, make sure it wasn't dirty.
+ */
+ if (old_match(old, ce)) {
+ verify_uptodate(old);
+ old = NULL;
+ }
*dst++ = ce;
src++;
nr--;
}
+ verify_cleared(old);
}
static void merge_stat_info(struct cache_entry **src, int nr)