1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#include "cache.h" 7 8static int stage = 0; 9static int update = 0; 10 11static int unpack_tree(unsigned char *sha1) 12{ 13 void *buffer; 14 unsigned long size; 15 int ret; 16 17 buffer = read_object_with_reference(sha1, "tree", &size, NULL); 18 if (!buffer) 19 return -1; 20 ret = read_tree(buffer, size, stage); 21 free(buffer); 22 return ret; 23} 24 25static char *lockfile_name; 26 27static void remove_lock_file(void) 28{ 29 if (lockfile_name) 30 unlink(lockfile_name); 31} 32 33static int path_matches(struct cache_entry *a, struct cache_entry *b) 34{ 35 int len = ce_namelen(a); 36 return ce_namelen(b) == len && 37 !memcmp(a->name, b->name, len); 38} 39 40static int same(struct cache_entry *a, struct cache_entry *b) 41{ 42 return a->ce_mode == b->ce_mode && 43 !memcmp(a->sha1, b->sha1, 20); 44} 45 46 47/* 48 * This removes all trivial merges that don't change the tree 49 * and collapses them to state 0. 50 * 51 * _Any_ other merge is left to user policy. That includes "both 52 * created the same file", and "both removed the same file" - which are 53 * trivial, but the user might still want to _note_ it. 54 */ 55static struct cache_entry *merge_entries(struct cache_entry *a, 56 struct cache_entry *b, 57 struct cache_entry *c) 58{ 59 int len = ce_namelen(a); 60 61 /* 62 * Are they all the same filename? We won't do 63 * any name merging 64 */ 65 if (ce_namelen(b) != len || 66 ce_namelen(c) != len || 67 memcmp(a->name, b->name, len) || 68 memcmp(a->name, c->name, len)) 69 return NULL; 70 71 /* 72 * Ok, all three entries describe the same 73 * filename, but maybe the contents or file 74 * mode have changed? 75 * 76 * The trivial cases end up being the ones where two 77 * out of three files are the same: 78 * - both destinations the same, trivially take either 79 * - one of the destination versions hasn't changed, 80 * take the other. 81 * 82 * The "all entries exactly the same" case falls out as 83 * a special case of any of the "two same" cases. 84 * 85 * Here "a" is "original", and "b" and "c" are the two 86 * trees we are merging. 87 */ 88 if (same(b,c)) 89 return c; 90 if (same(a,b)) 91 return c; 92 if (same(a,c)) 93 return b; 94 return NULL; 95} 96 97/* 98 * When a CE gets turned into an unmerged entry, we 99 * want it to be up-to-date 100 */ 101static void verify_uptodate(struct cache_entry *ce) 102{ 103 struct stat st; 104 105 if (!lstat(ce->name, &st)) { 106 unsigned changed = ce_match_stat(ce, &st); 107 if (!changed) 108 return; 109 errno = 0; 110 } 111 if (errno == ENOENT) 112 return; 113 die("Entry '%s' not uptodate. Cannot merge.", ce->name); 114} 115 116/* 117 * If the old tree contained a CE that isn't even in the 118 * result, that's always a problem, regardless of whether 119 * it's up-to-date or not (ie it can be a file that we 120 * have updated but not committed yet). 121 */ 122static void reject_merge(struct cache_entry *ce) 123{ 124 die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name); 125} 126 127#define CHECK_OLD(ce) if (old && same(old, ce)) { verify_uptodate(old); old = NULL; } 128 129static void trivially_merge_cache(struct cache_entry **src, int nr) 130{ 131 struct cache_entry **dst = src; 132 struct cache_entry *old = NULL; 133 134 while (nr--) { 135 struct cache_entry *ce, *result; 136 137 ce = *src++; 138 139 /* We throw away original cache entries except for the stat information */ 140 if (!ce_stage(ce)) { 141 if (old) 142 reject_merge(old); 143 old = ce; 144 active_nr--; 145 continue; 146 } 147 if (old && !path_matches(old, ce)) 148 reject_merge(old); 149 if (nr > 2 && (result = merge_entries(ce, src[1], src[2])) != NULL) { 150 result->ce_flags |= htons(CE_UPDATE); 151 /* 152 * See if we can re-use the old CE directly? 153 * That way we get the uptodate stat info. 154 * 155 * This also removes the UPDATE flag on 156 * a match. 157 */ 158 if (old && same(old, result)) { 159 *result = *old; 160 old = NULL; 161 } 162 CHECK_OLD(ce); 163 CHECK_OLD(src[1]); 164 CHECK_OLD(src[2]); 165 ce = result; 166 ce->ce_flags &= ~htons(CE_STAGEMASK); 167 src += 2; 168 nr -= 2; 169 active_nr -= 2; 170 } 171 172 /* 173 * If we had an old entry that we now effectively 174 * overwrite, make sure it wasn't dirty. 175 */ 176 CHECK_OLD(ce); 177 *dst++ = ce; 178 } 179 if (old) 180 reject_merge(old); 181} 182 183/* 184 * When we find a "stage2" entry in the two-way merge, that's 185 * the one that will remain. If we have an exact old match, 186 * we don't care whether the file is up-to-date or not, we just 187 * re-use the thing directly. 188 * 189 * If we didn't have an exact match, then we want to make sure 190 * that we've seen a stage1 that matched the old, and that the 191 * old file was up-to-date. Because it will be gone after this 192 * merge.. 193 */ 194static void twoway_check(struct cache_entry *old, int seen_stage1, struct cache_entry *ce) 195{ 196 if (path_matches(old, ce)) { 197 /* 198 * This also removes the UPDATE flag on 199 * a match 200 */ 201 if (same(old, ce)) { 202 *ce = *old; 203 return; 204 } 205 if (!seen_stage1) 206 reject_merge(old); 207 } 208 verify_uptodate(old); 209} 210 211/* 212 * Two-way merge. 213 * 214 * The rule is: 215 * - every current entry has to match the old tree 216 * - if the current entry matches the new tree, we leave it 217 * as-is. Otherwise we require that it be up-to-date. 218 */ 219static void twoway_merge(struct cache_entry **src, int nr) 220{ 221 int seen_stage1 = 0; 222 struct cache_entry *old = NULL; 223 struct cache_entry **dst = src; 224 225 while (nr--) { 226 struct cache_entry *ce = *src++; 227 int stage = ce_stage(ce); 228 229 switch (stage) { 230 case 0: 231 if (old) 232 reject_merge(old); 233 old = ce; 234 seen_stage1 = 0; 235 active_nr--; 236 continue; 237 238 case 1: 239 active_nr--; 240 if (!old) 241 continue; 242 if (!path_matches(old, ce) || !same(old, ce)) 243 reject_merge(old); 244 seen_stage1 = 1; 245 continue; 246 247 case 2: 248 ce->ce_flags |= htons(CE_UPDATE); 249 if (old) { 250 twoway_check(old, seen_stage1, ce); 251 old = NULL; 252 } 253 ce->ce_flags &= ~htons(CE_STAGEMASK); 254 *dst++ = ce; 255 continue; 256 } 257 die("impossible two-way stage"); 258 } 259 260 /* 261 * Unmatched with a new entry? Make sure it was 262 * at least uptodate in the working directory _and_ 263 * the original tree.. 264 */ 265 if (old) { 266 if (!seen_stage1) 267 reject_merge(old); 268 verify_uptodate(old); 269 } 270} 271 272static void merge_stat_info(struct cache_entry **src, int nr) 273{ 274 static struct cache_entry null_entry; 275 struct cache_entry **dst = src; 276 struct cache_entry *stat = &null_entry; 277 278 while (nr--) { 279 struct cache_entry *ce = *src++; 280 281 /* We throw away original cache entries except for the stat information */ 282 if (!ce_stage(ce)) { 283 stat = ce; 284 active_nr--; 285 continue; 286 } 287 if (path_matches(ce, stat) && same(ce, stat)) 288 *ce = *stat; 289 ce->ce_flags &= ~htons(CE_STAGEMASK); 290 *dst++ = ce; 291 } 292} 293 294static void check_updates(struct cache_entry **src, int nr) 295{ 296 static struct checkout state = { 297 .base_dir = "", 298 .force = 1, 299 .quiet = 1, 300 .refresh_cache = 1, 301 }; 302 unsigned short mask = htons(CE_UPDATE); 303 while (nr--) { 304 struct cache_entry *ce = *src++; 305 if (ce->ce_flags & mask) { 306 ce->ce_flags &= ~mask; 307 if (update) 308 checkout_entry(ce, &state); 309 } 310 } 311} 312 313static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> [<sha3>]])"; 314 315int main(int argc, char **argv) 316{ 317 int i, newfd, merge; 318 unsigned char sha1[20]; 319 static char lockfile[MAXPATHLEN+1]; 320 const char *indexfile = get_index_file(); 321 322 snprintf(lockfile, sizeof(lockfile), "%s.lock", indexfile); 323 324 newfd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0600); 325 if (newfd < 0) 326 die("unable to create new cachefile"); 327 atexit(remove_lock_file); 328 lockfile_name = lockfile; 329 330 merge = 0; 331 for (i = 1; i < argc; i++) { 332 const char *arg = argv[i]; 333 334 /* "-u" means "update", meaning that a merge will update the working directory */ 335 if (!strcmp(arg, "-u")) { 336 update = 1; 337 continue; 338 } 339 340 /* "-m" stands for "merge", meaning we start in stage 1 */ 341 if (!strcmp(arg, "-m")) { 342 int i; 343 if (stage) 344 die("-m needs to come first"); 345 read_cache(); 346 for (i = 0; i < active_nr; i++) { 347 if (ce_stage(active_cache[i])) 348 die("you need to resolve your current index first"); 349 } 350 stage = 1; 351 merge = 1; 352 continue; 353 } 354 if (get_sha1(arg, sha1) < 0) 355 usage(read_tree_usage); 356 if (stage > 3) 357 usage(read_tree_usage); 358 if (unpack_tree(sha1) < 0) 359 die("failed to unpack tree object %s", arg); 360 stage++; 361 } 362 if (merge) { 363 switch (stage) { 364 case 4: /* Three-way merge */ 365 trivially_merge_cache(active_cache, active_nr); 366 check_updates(active_cache, active_nr); 367 break; 368 case 3: /* Update from one tree to another */ 369 twoway_merge(active_cache, active_nr); 370 check_updates(active_cache, active_nr); 371 break; 372 case 2: /* Just read a tree, merge with old cache contents */ 373 merge_stat_info(active_cache, active_nr); 374 break; 375 default: 376 die("just how do you expect me to merge %d trees?", stage-1); 377 } 378 } 379 if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile)) 380 die("unable to write new index file"); 381 lockfile_name = NULL; 382 return 0; 383}