1#define NO_THE_INDEX_COMPATIBILITY_MACROS 2#include "cache.h" 3#include "dir.h" 4#include "tree.h" 5#include "tree-walk.h" 6#include "cache-tree.h" 7#include "unpack-trees.h" 8#include "progress.h" 9#include "refs.h" 10#include "attr.h" 11 12/* 13 * Error messages expected by scripts out of plumbing commands such as 14 * read-tree. Non-scripted Porcelain is not required to use these messages 15 * and in fact are encouraged to reword them to better suit their particular 16 * situation better. See how "git checkout" and "git merge" replaces 17 * them using setup_unpack_trees_porcelain(), for example. 18 */ 19static const char *unpack_plumbing_errors[NB_UNPACK_TREES_ERROR_TYPES] = { 20 /* ERROR_WOULD_OVERWRITE */ 21 "Entry '%s' would be overwritten by merge. Cannot merge.", 22 23 /* ERROR_NOT_UPTODATE_FILE */ 24 "Entry '%s' not uptodate. Cannot merge.", 25 26 /* ERROR_NOT_UPTODATE_DIR */ 27 "Updating '%s' would lose untracked files in it", 28 29 /* ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN */ 30 "Untracked working tree file '%s' would be overwritten by merge.", 31 32 /* ERROR_WOULD_LOSE_UNTRACKED_REMOVED */ 33 "Untracked working tree file '%s' would be removed by merge.", 34 35 /* ERROR_BIND_OVERLAP */ 36 "Entry '%s' overlaps with '%s'. Cannot bind.", 37 38 /* ERROR_SPARSE_NOT_UPTODATE_FILE */ 39 "Entry '%s' not uptodate. Cannot update sparse checkout.", 40 41 /* ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN */ 42 "Working tree file '%s' would be overwritten by sparse checkout update.", 43 44 /* ERROR_WOULD_LOSE_ORPHANED_REMOVED */ 45 "Working tree file '%s' would be removed by sparse checkout update.", 46}; 47 48#define ERRORMSG(o,type) \ 49 ( ((o) && (o)->msgs[(type)]) \ 50 ? ((o)->msgs[(type)]) \ 51 : (unpack_plumbing_errors[(type)]) ) 52 53void setup_unpack_trees_porcelain(struct unpack_trees_options *opts, 54 const char *cmd) 55{ 56 int i; 57 const char **msgs = opts->msgs; 58 const char *msg; 59 char *tmp; 60 const char *cmd2 = strcmp(cmd, "checkout") ? cmd : "switch branches"; 61 if (advice_commit_before_merge) 62 msg = "Your local changes to the following files would be overwritten by %s:\n%%s" 63 "Please, commit your changes or stash them before you can %s."; 64 else 65 msg = "Your local changes to the following files would be overwritten by %s:\n%%s"; 66 tmp = xmalloc(strlen(msg) + strlen(cmd) + strlen(cmd2) - 2); 67 sprintf(tmp, msg, cmd, cmd2); 68 msgs[ERROR_WOULD_OVERWRITE] = tmp; 69 msgs[ERROR_NOT_UPTODATE_FILE] = tmp; 70 71 msgs[ERROR_NOT_UPTODATE_DIR] = 72 "Updating the following directories would lose untracked files in it:\n%s"; 73 74 if (advice_commit_before_merge) 75 msg = "The following untracked working tree files would be %s by %s:\n%%s" 76 "Please move or remove them before you can %s."; 77 else 78 msg = "The following untracked working tree files would be %s by %s:\n%%s"; 79 tmp = xmalloc(strlen(msg) + strlen(cmd) + strlen("removed") + strlen(cmd2) - 4); 80 sprintf(tmp, msg, "removed", cmd, cmd2); 81 msgs[ERROR_WOULD_LOSE_UNTRACKED_REMOVED] = tmp; 82 tmp = xmalloc(strlen(msg) + strlen(cmd) + strlen("overwritten") + strlen(cmd2) - 4); 83 sprintf(tmp, msg, "overwritten", cmd, cmd2); 84 msgs[ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN] = tmp; 85 86 /* 87 * Special case: ERROR_BIND_OVERLAP refers to a pair of paths, we 88 * cannot easily display it as a list. 89 */ 90 msgs[ERROR_BIND_OVERLAP] = "Entry '%s' overlaps with '%s'. Cannot bind."; 91 92 msgs[ERROR_SPARSE_NOT_UPTODATE_FILE] = 93 "Cannot update sparse checkout: the following entries are not up-to-date:\n%s"; 94 msgs[ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN] = 95 "The following Working tree files would be overwritten by sparse checkout update:\n%s"; 96 msgs[ERROR_WOULD_LOSE_ORPHANED_REMOVED] = 97 "The following Working tree files would be removed by sparse checkout update:\n%s"; 98 99 opts->show_all_errors = 1; 100 /* rejected paths may not have a static buffer */ 101 for (i = 0; i < ARRAY_SIZE(opts->unpack_rejects); i++) 102 opts->unpack_rejects[i].strdup_strings = 1; 103} 104 105static void do_add_entry(struct unpack_trees_options *o, struct cache_entry *ce, 106 unsigned int set, unsigned int clear) 107{ 108 clear |= CE_HASHED | CE_UNHASHED; 109 110 if (set & CE_REMOVE) 111 set |= CE_WT_REMOVE; 112 113 ce->next = NULL; 114 ce->ce_flags = (ce->ce_flags & ~clear) | set; 115 add_index_entry(&o->result, ce, 116 ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); 117} 118 119static void add_entry(struct unpack_trees_options *o, struct cache_entry *ce, 120 unsigned int set, unsigned int clear) 121{ 122 unsigned int size = ce_size(ce); 123 struct cache_entry *new = xmalloc(size); 124 125 memcpy(new, ce, size); 126 do_add_entry(o, new, set, clear); 127} 128 129/* 130 * add error messages on path <path> 131 * corresponding to the type <e> with the message <msg> 132 * indicating if it should be display in porcelain or not 133 */ 134static int add_rejected_path(struct unpack_trees_options *o, 135 enum unpack_trees_error_types e, 136 const char *path) 137{ 138 if (!o->show_all_errors) 139 return error(ERRORMSG(o, e), path); 140 141 /* 142 * Otherwise, insert in a list for future display by 143 * display_error_msgs() 144 */ 145 string_list_append(&o->unpack_rejects[e], path); 146 return -1; 147} 148 149/* 150 * display all the error messages stored in a nice way 151 */ 152static void display_error_msgs(struct unpack_trees_options *o) 153{ 154 int e, i; 155 int something_displayed = 0; 156 for (e = 0; e < NB_UNPACK_TREES_ERROR_TYPES; e++) { 157 struct string_list *rejects = &o->unpack_rejects[e]; 158 if (rejects->nr > 0) { 159 struct strbuf path = STRBUF_INIT; 160 something_displayed = 1; 161 for (i = 0; i < rejects->nr; i++) 162 strbuf_addf(&path, "\t%s\n", rejects->items[i].string); 163 error(ERRORMSG(o, e), path.buf); 164 strbuf_release(&path); 165 } 166 string_list_clear(rejects, 0); 167 } 168 if (something_displayed) 169 fprintf(stderr, "Aborting\n"); 170} 171 172/* 173 * Unlink the last component and schedule the leading directories for 174 * removal, such that empty directories get removed. 175 */ 176static void unlink_entry(struct cache_entry *ce) 177{ 178 if (!check_leading_path(ce->name, ce_namelen(ce))) 179 return; 180 if (remove_or_warn(ce->ce_mode, ce->name)) 181 return; 182 schedule_dir_for_removal(ce->name, ce_namelen(ce)); 183} 184 185static struct checkout state; 186static int check_updates(struct unpack_trees_options *o) 187{ 188 unsigned cnt = 0, total = 0; 189 struct progress *progress = NULL; 190 struct index_state *index = &o->result; 191 int i; 192 int errs = 0; 193 194 if (o->update && o->verbose_update) { 195 for (total = cnt = 0; cnt < index->cache_nr; cnt++) { 196 struct cache_entry *ce = index->cache[cnt]; 197 if (ce->ce_flags & (CE_UPDATE | CE_WT_REMOVE)) 198 total++; 199 } 200 201 progress = start_progress_delay("Checking out files", 202 total, 50, 1); 203 cnt = 0; 204 } 205 206 if (o->update) 207 git_attr_set_direction(GIT_ATTR_CHECKOUT, &o->result); 208 for (i = 0; i < index->cache_nr; i++) { 209 struct cache_entry *ce = index->cache[i]; 210 211 if (ce->ce_flags & CE_WT_REMOVE) { 212 display_progress(progress, ++cnt); 213 if (o->update && !o->dry_run) 214 unlink_entry(ce); 215 continue; 216 } 217 } 218 remove_marked_cache_entries(&o->result); 219 remove_scheduled_dirs(); 220 221 for (i = 0; i < index->cache_nr; i++) { 222 struct cache_entry *ce = index->cache[i]; 223 224 if (ce->ce_flags & CE_UPDATE) { 225 display_progress(progress, ++cnt); 226 ce->ce_flags &= ~CE_UPDATE; 227 if (o->update && !o->dry_run) { 228 errs |= checkout_entry(ce, &state, NULL); 229 } 230 } 231 } 232 stop_progress(&progress); 233 if (o->update) 234 git_attr_set_direction(GIT_ATTR_CHECKIN, NULL); 235 return errs != 0; 236} 237 238static int verify_uptodate_sparse(struct cache_entry *ce, struct unpack_trees_options *o); 239static int verify_absent_sparse(struct cache_entry *ce, enum unpack_trees_error_types, struct unpack_trees_options *o); 240 241static int apply_sparse_checkout(struct cache_entry *ce, struct unpack_trees_options *o) 242{ 243 int was_skip_worktree = ce_skip_worktree(ce); 244 245 if (ce->ce_flags & CE_NEW_SKIP_WORKTREE) 246 ce->ce_flags |= CE_SKIP_WORKTREE; 247 else 248 ce->ce_flags &= ~CE_SKIP_WORKTREE; 249 250 /* 251 * if (!was_skip_worktree && !ce_skip_worktree()) { 252 * This is perfectly normal. Move on; 253 * } 254 */ 255 256 /* 257 * Merge strategies may set CE_UPDATE|CE_REMOVE outside checkout 258 * area as a result of ce_skip_worktree() shortcuts in 259 * verify_absent() and verify_uptodate(). 260 * Make sure they don't modify worktree if they are already 261 * outside checkout area 262 */ 263 if (was_skip_worktree && ce_skip_worktree(ce)) { 264 ce->ce_flags &= ~CE_UPDATE; 265 266 /* 267 * By default, when CE_REMOVE is on, CE_WT_REMOVE is also 268 * on to get that file removed from both index and worktree. 269 * If that file is already outside worktree area, don't 270 * bother remove it. 271 */ 272 if (ce->ce_flags & CE_REMOVE) 273 ce->ce_flags &= ~CE_WT_REMOVE; 274 } 275 276 if (!was_skip_worktree && ce_skip_worktree(ce)) { 277 /* 278 * If CE_UPDATE is set, verify_uptodate() must be called already 279 * also stat info may have lost after merged_entry() so calling 280 * verify_uptodate() again may fail 281 */ 282 if (!(ce->ce_flags & CE_UPDATE) && verify_uptodate_sparse(ce, o)) 283 return -1; 284 ce->ce_flags |= CE_WT_REMOVE; 285 } 286 if (was_skip_worktree && !ce_skip_worktree(ce)) { 287 if (verify_absent_sparse(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) 288 return -1; 289 ce->ce_flags |= CE_UPDATE; 290 } 291 return 0; 292} 293 294static inline int call_unpack_fn(struct cache_entry **src, struct unpack_trees_options *o) 295{ 296 int ret = o->fn(src, o); 297 if (ret > 0) 298 ret = 0; 299 return ret; 300} 301 302static void mark_ce_used(struct cache_entry *ce, struct unpack_trees_options *o) 303{ 304 ce->ce_flags |= CE_UNPACKED; 305 306 if (o->cache_bottom < o->src_index->cache_nr && 307 o->src_index->cache[o->cache_bottom] == ce) { 308 int bottom = o->cache_bottom; 309 while (bottom < o->src_index->cache_nr && 310 o->src_index->cache[bottom]->ce_flags & CE_UNPACKED) 311 bottom++; 312 o->cache_bottom = bottom; 313 } 314} 315 316static void mark_all_ce_unused(struct index_state *index) 317{ 318 int i; 319 for (i = 0; i < index->cache_nr; i++) 320 index->cache[i]->ce_flags &= ~(CE_UNPACKED | CE_ADDED | CE_NEW_SKIP_WORKTREE); 321} 322 323static int locate_in_src_index(struct cache_entry *ce, 324 struct unpack_trees_options *o) 325{ 326 struct index_state *index = o->src_index; 327 int len = ce_namelen(ce); 328 int pos = index_name_pos(index, ce->name, len); 329 if (pos < 0) 330 pos = -1 - pos; 331 return pos; 332} 333 334/* 335 * We call unpack_index_entry() with an unmerged cache entry 336 * only in diff-index, and it wants a single callback. Skip 337 * the other unmerged entry with the same name. 338 */ 339static void mark_ce_used_same_name(struct cache_entry *ce, 340 struct unpack_trees_options *o) 341{ 342 struct index_state *index = o->src_index; 343 int len = ce_namelen(ce); 344 int pos; 345 346 for (pos = locate_in_src_index(ce, o); pos < index->cache_nr; pos++) { 347 struct cache_entry *next = index->cache[pos]; 348 if (len != ce_namelen(next) || 349 memcmp(ce->name, next->name, len)) 350 break; 351 mark_ce_used(next, o); 352 } 353} 354 355static struct cache_entry *next_cache_entry(struct unpack_trees_options *o) 356{ 357 const struct index_state *index = o->src_index; 358 int pos = o->cache_bottom; 359 360 while (pos < index->cache_nr) { 361 struct cache_entry *ce = index->cache[pos]; 362 if (!(ce->ce_flags & CE_UNPACKED)) 363 return ce; 364 pos++; 365 } 366 return NULL; 367} 368 369static void add_same_unmerged(struct cache_entry *ce, 370 struct unpack_trees_options *o) 371{ 372 struct index_state *index = o->src_index; 373 int len = ce_namelen(ce); 374 int pos = index_name_pos(index, ce->name, len); 375 376 if (0 <= pos) 377 die("programming error in a caller of mark_ce_used_same_name"); 378 for (pos = -pos - 1; pos < index->cache_nr; pos++) { 379 struct cache_entry *next = index->cache[pos]; 380 if (len != ce_namelen(next) || 381 memcmp(ce->name, next->name, len)) 382 break; 383 add_entry(o, next, 0, 0); 384 mark_ce_used(next, o); 385 } 386} 387 388static int unpack_index_entry(struct cache_entry *ce, 389 struct unpack_trees_options *o) 390{ 391 struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, }; 392 int ret; 393 394 src[0] = ce; 395 396 mark_ce_used(ce, o); 397 if (ce_stage(ce)) { 398 if (o->skip_unmerged) { 399 add_entry(o, ce, 0, 0); 400 return 0; 401 } 402 } 403 ret = call_unpack_fn(src, o); 404 if (ce_stage(ce)) 405 mark_ce_used_same_name(ce, o); 406 return ret; 407} 408 409static int find_cache_pos(struct traverse_info *, const struct name_entry *); 410 411static void restore_cache_bottom(struct traverse_info *info, int bottom) 412{ 413 struct unpack_trees_options *o = info->data; 414 415 if (o->diff_index_cached) 416 return; 417 o->cache_bottom = bottom; 418} 419 420static int switch_cache_bottom(struct traverse_info *info) 421{ 422 struct unpack_trees_options *o = info->data; 423 int ret, pos; 424 425 if (o->diff_index_cached) 426 return 0; 427 ret = o->cache_bottom; 428 pos = find_cache_pos(info->prev, &info->name); 429 430 if (pos < -1) 431 o->cache_bottom = -2 - pos; 432 else if (pos < 0) 433 o->cache_bottom = o->src_index->cache_nr; 434 return ret; 435} 436 437static int traverse_trees_recursive(int n, unsigned long dirmask, 438 unsigned long df_conflicts, 439 struct name_entry *names, 440 struct traverse_info *info) 441{ 442 int i, ret, bottom; 443 struct tree_desc t[MAX_UNPACK_TREES]; 444 void *buf[MAX_UNPACK_TREES]; 445 struct traverse_info newinfo; 446 struct name_entry *p; 447 448 p = names; 449 while (!p->mode) 450 p++; 451 452 newinfo = *info; 453 newinfo.prev = info; 454 newinfo.pathspec = info->pathspec; 455 newinfo.name = *p; 456 newinfo.pathlen += tree_entry_len(p) + 1; 457 newinfo.conflicts |= df_conflicts; 458 459 for (i = 0; i < n; i++, dirmask >>= 1) { 460 const unsigned char *sha1 = NULL; 461 if (dirmask & 1) 462 sha1 = names[i].sha1; 463 buf[i] = fill_tree_descriptor(t+i, sha1); 464 } 465 466 bottom = switch_cache_bottom(&newinfo); 467 ret = traverse_trees(n, t, &newinfo); 468 restore_cache_bottom(&newinfo, bottom); 469 470 for (i = 0; i < n; i++) 471 free(buf[i]); 472 473 return ret; 474} 475 476/* 477 * Compare the traverse-path to the cache entry without actually 478 * having to generate the textual representation of the traverse 479 * path. 480 * 481 * NOTE! This *only* compares up to the size of the traverse path 482 * itself - the caller needs to do the final check for the cache 483 * entry having more data at the end! 484 */ 485static int do_compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) 486{ 487 int len, pathlen, ce_len; 488 const char *ce_name; 489 490 if (info->prev) { 491 int cmp = do_compare_entry(ce, info->prev, &info->name); 492 if (cmp) 493 return cmp; 494 } 495 pathlen = info->pathlen; 496 ce_len = ce_namelen(ce); 497 498 /* If ce_len < pathlen then we must have previously hit "name == directory" entry */ 499 if (ce_len < pathlen) 500 return -1; 501 502 ce_len -= pathlen; 503 ce_name = ce->name + pathlen; 504 505 len = tree_entry_len(n); 506 return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); 507} 508 509static int compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) 510{ 511 int cmp = do_compare_entry(ce, info, n); 512 if (cmp) 513 return cmp; 514 515 /* 516 * Even if the beginning compared identically, the ce should 517 * compare as bigger than a directory leading up to it! 518 */ 519 return ce_namelen(ce) > traverse_path_len(info, n); 520} 521 522static int ce_in_traverse_path(const struct cache_entry *ce, 523 const struct traverse_info *info) 524{ 525 if (!info->prev) 526 return 1; 527 if (do_compare_entry(ce, info->prev, &info->name)) 528 return 0; 529 /* 530 * If ce (blob) is the same name as the path (which is a tree 531 * we will be descending into), it won't be inside it. 532 */ 533 return (info->pathlen < ce_namelen(ce)); 534} 535 536static struct cache_entry *create_ce_entry(const struct traverse_info *info, const struct name_entry *n, int stage) 537{ 538 int len = traverse_path_len(info, n); 539 struct cache_entry *ce = xcalloc(1, cache_entry_size(len)); 540 541 ce->ce_mode = create_ce_mode(n->mode); 542 ce->ce_flags = create_ce_flags(len, stage); 543 hashcpy(ce->sha1, n->sha1); 544 make_traverse_path(ce->name, info, n); 545 546 return ce; 547} 548 549static int unpack_nondirectories(int n, unsigned long mask, 550 unsigned long dirmask, 551 struct cache_entry **src, 552 const struct name_entry *names, 553 const struct traverse_info *info) 554{ 555 int i; 556 struct unpack_trees_options *o = info->data; 557 unsigned long conflicts; 558 559 /* Do we have *only* directories? Nothing to do */ 560 if (mask == dirmask && !src[0]) 561 return 0; 562 563 conflicts = info->conflicts; 564 if (o->merge) 565 conflicts >>= 1; 566 conflicts |= dirmask; 567 568 /* 569 * Ok, we've filled in up to any potential index entry in src[0], 570 * now do the rest. 571 */ 572 for (i = 0; i < n; i++) { 573 int stage; 574 unsigned int bit = 1ul << i; 575 if (conflicts & bit) { 576 src[i + o->merge] = o->df_conflict_entry; 577 continue; 578 } 579 if (!(mask & bit)) 580 continue; 581 if (!o->merge) 582 stage = 0; 583 else if (i + 1 < o->head_idx) 584 stage = 1; 585 else if (i + 1 > o->head_idx) 586 stage = 3; 587 else 588 stage = 2; 589 src[i + o->merge] = create_ce_entry(info, names + i, stage); 590 } 591 592 if (o->merge) 593 return call_unpack_fn(src, o); 594 595 for (i = 0; i < n; i++) 596 if (src[i] && src[i] != o->df_conflict_entry) 597 do_add_entry(o, src[i], 0, 0); 598 return 0; 599} 600 601static int unpack_failed(struct unpack_trees_options *o, const char *message) 602{ 603 discard_index(&o->result); 604 if (!o->gently && !o->exiting_early) { 605 if (message) 606 return error("%s", message); 607 return -1; 608 } 609 return -1; 610} 611 612/* NEEDSWORK: give this a better name and share with tree-walk.c */ 613static int name_compare(const char *a, int a_len, 614 const char *b, int b_len) 615{ 616 int len = (a_len < b_len) ? a_len : b_len; 617 int cmp = memcmp(a, b, len); 618 if (cmp) 619 return cmp; 620 return (a_len - b_len); 621} 622 623/* 624 * The tree traversal is looking at name p. If we have a matching entry, 625 * return it. If name p is a directory in the index, do not return 626 * anything, as we will want to match it when the traversal descends into 627 * the directory. 628 */ 629static int find_cache_pos(struct traverse_info *info, 630 const struct name_entry *p) 631{ 632 int pos; 633 struct unpack_trees_options *o = info->data; 634 struct index_state *index = o->src_index; 635 int pfxlen = info->pathlen; 636 int p_len = tree_entry_len(p); 637 638 for (pos = o->cache_bottom; pos < index->cache_nr; pos++) { 639 struct cache_entry *ce = index->cache[pos]; 640 const char *ce_name, *ce_slash; 641 int cmp, ce_len; 642 643 if (ce->ce_flags & CE_UNPACKED) { 644 /* 645 * cache_bottom entry is already unpacked, so 646 * we can never match it; don't check it 647 * again. 648 */ 649 if (pos == o->cache_bottom) 650 ++o->cache_bottom; 651 continue; 652 } 653 if (!ce_in_traverse_path(ce, info)) 654 continue; 655 ce_name = ce->name + pfxlen; 656 ce_slash = strchr(ce_name, '/'); 657 if (ce_slash) 658 ce_len = ce_slash - ce_name; 659 else 660 ce_len = ce_namelen(ce) - pfxlen; 661 cmp = name_compare(p->path, p_len, ce_name, ce_len); 662 /* 663 * Exact match; if we have a directory we need to 664 * delay returning it. 665 */ 666 if (!cmp) 667 return ce_slash ? -2 - pos : pos; 668 if (0 < cmp) 669 continue; /* keep looking */ 670 /* 671 * ce_name sorts after p->path; could it be that we 672 * have files under p->path directory in the index? 673 * E.g. ce_name == "t-i", and p->path == "t"; we may 674 * have "t/a" in the index. 675 */ 676 if (p_len < ce_len && !memcmp(ce_name, p->path, p_len) && 677 ce_name[p_len] < '/') 678 continue; /* keep looking */ 679 break; 680 } 681 return -1; 682} 683 684static struct cache_entry *find_cache_entry(struct traverse_info *info, 685 const struct name_entry *p) 686{ 687 int pos = find_cache_pos(info, p); 688 struct unpack_trees_options *o = info->data; 689 690 if (0 <= pos) 691 return o->src_index->cache[pos]; 692 else 693 return NULL; 694} 695 696static void debug_path(struct traverse_info *info) 697{ 698 if (info->prev) { 699 debug_path(info->prev); 700 if (*info->prev->name.path) 701 putchar('/'); 702 } 703 printf("%s", info->name.path); 704} 705 706static void debug_name_entry(int i, struct name_entry *n) 707{ 708 printf("ent#%d %06o %s\n", i, 709 n->path ? n->mode : 0, 710 n->path ? n->path : "(missing)"); 711} 712 713static void debug_unpack_callback(int n, 714 unsigned long mask, 715 unsigned long dirmask, 716 struct name_entry *names, 717 struct traverse_info *info) 718{ 719 int i; 720 printf("* unpack mask %lu, dirmask %lu, cnt %d ", 721 mask, dirmask, n); 722 debug_path(info); 723 putchar('\n'); 724 for (i = 0; i < n; i++) 725 debug_name_entry(i, names + i); 726} 727 728static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info) 729{ 730 struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, }; 731 struct unpack_trees_options *o = info->data; 732 const struct name_entry *p = names; 733 734 /* Find first entry with a real name (we could use "mask" too) */ 735 while (!p->mode) 736 p++; 737 738 if (o->debug_unpack) 739 debug_unpack_callback(n, mask, dirmask, names, info); 740 741 /* Are we supposed to look at the index too? */ 742 if (o->merge) { 743 while (1) { 744 int cmp; 745 struct cache_entry *ce; 746 747 if (o->diff_index_cached) 748 ce = next_cache_entry(o); 749 else 750 ce = find_cache_entry(info, p); 751 752 if (!ce) 753 break; 754 cmp = compare_entry(ce, info, p); 755 if (cmp < 0) { 756 if (unpack_index_entry(ce, o) < 0) 757 return unpack_failed(o, NULL); 758 continue; 759 } 760 if (!cmp) { 761 if (ce_stage(ce)) { 762 /* 763 * If we skip unmerged index 764 * entries, we'll skip this 765 * entry *and* the tree 766 * entries associated with it! 767 */ 768 if (o->skip_unmerged) { 769 add_same_unmerged(ce, o); 770 return mask; 771 } 772 } 773 src[0] = ce; 774 } 775 break; 776 } 777 } 778 779 if (unpack_nondirectories(n, mask, dirmask, src, names, info) < 0) 780 return -1; 781 782 if (o->merge && src[0]) { 783 if (ce_stage(src[0])) 784 mark_ce_used_same_name(src[0], o); 785 else 786 mark_ce_used(src[0], o); 787 } 788 789 /* Now handle any directories.. */ 790 if (dirmask) { 791 unsigned long conflicts = mask & ~dirmask; 792 if (o->merge) { 793 conflicts <<= 1; 794 if (src[0]) 795 conflicts |= 1; 796 } 797 798 /* special case: "diff-index --cached" looking at a tree */ 799 if (o->diff_index_cached && 800 n == 1 && dirmask == 1 && S_ISDIR(names->mode)) { 801 int matches; 802 matches = cache_tree_matches_traversal(o->src_index->cache_tree, 803 names, info); 804 /* 805 * Everything under the name matches; skip the 806 * entire hierarchy. diff_index_cached codepath 807 * special cases D/F conflicts in such a way that 808 * it does not do any look-ahead, so this is safe. 809 */ 810 if (matches) { 811 o->cache_bottom += matches; 812 return mask; 813 } 814 } 815 816 if (traverse_trees_recursive(n, dirmask, conflicts, 817 names, info) < 0) 818 return -1; 819 return mask; 820 } 821 822 return mask; 823} 824 825static int clear_ce_flags_1(struct cache_entry **cache, int nr, 826 char *prefix, int prefix_len, 827 int select_mask, int clear_mask, 828 struct exclude_list *el, int defval); 829 830/* Whole directory matching */ 831static int clear_ce_flags_dir(struct cache_entry **cache, int nr, 832 char *prefix, int prefix_len, 833 char *basename, 834 int select_mask, int clear_mask, 835 struct exclude_list *el, int defval) 836{ 837 struct cache_entry **cache_end; 838 int dtype = DT_DIR; 839 int ret = is_excluded_from_list(prefix, prefix_len, 840 basename, &dtype, el); 841 842 prefix[prefix_len++] = '/'; 843 844 /* If undecided, use matching result of parent dir in defval */ 845 if (ret < 0) 846 ret = defval; 847 848 for (cache_end = cache; cache_end != cache + nr; cache_end++) { 849 struct cache_entry *ce = *cache_end; 850 if (strncmp(ce->name, prefix, prefix_len)) 851 break; 852 } 853 854 /* 855 * TODO: check el, if there are no patterns that may conflict 856 * with ret (iow, we know in advance the incl/excl 857 * decision for the entire directory), clear flag here without 858 * calling clear_ce_flags_1(). That function will call 859 * the expensive is_excluded_from_list() on every entry. 860 */ 861 return clear_ce_flags_1(cache, cache_end - cache, 862 prefix, prefix_len, 863 select_mask, clear_mask, 864 el, ret); 865} 866 867/* 868 * Traverse the index, find every entry that matches according to 869 * o->el. Do "ce_flags &= ~clear_mask" on those entries. Return the 870 * number of traversed entries. 871 * 872 * If select_mask is non-zero, only entries whose ce_flags has on of 873 * those bits enabled are traversed. 874 * 875 * cache : pointer to an index entry 876 * prefix_len : an offset to its path 877 * 878 * The current path ("prefix") including the trailing '/' is 879 * cache[0]->name[0..(prefix_len-1)] 880 * Top level path has prefix_len zero. 881 */ 882static int clear_ce_flags_1(struct cache_entry **cache, int nr, 883 char *prefix, int prefix_len, 884 int select_mask, int clear_mask, 885 struct exclude_list *el, int defval) 886{ 887 struct cache_entry **cache_end = cache + nr; 888 889 /* 890 * Process all entries that have the given prefix and meet 891 * select_mask condition 892 */ 893 while(cache != cache_end) { 894 struct cache_entry *ce = *cache; 895 const char *name, *slash; 896 int len, dtype, ret; 897 898 if (select_mask && !(ce->ce_flags & select_mask)) { 899 cache++; 900 continue; 901 } 902 903 if (prefix_len && strncmp(ce->name, prefix, prefix_len)) 904 break; 905 906 name = ce->name + prefix_len; 907 slash = strchr(name, '/'); 908 909 /* If it's a directory, try whole directory match first */ 910 if (slash) { 911 int processed; 912 913 len = slash - name; 914 memcpy(prefix + prefix_len, name, len); 915 916 /* 917 * terminate the string (no trailing slash), 918 * clear_c_f_dir needs it 919 */ 920 prefix[prefix_len + len] = '\0'; 921 processed = clear_ce_flags_dir(cache, cache_end - cache, 922 prefix, prefix_len + len, 923 prefix + prefix_len, 924 select_mask, clear_mask, 925 el, defval); 926 927 /* clear_c_f_dir eats a whole dir already? */ 928 if (processed) { 929 cache += processed; 930 continue; 931 } 932 933 prefix[prefix_len + len++] = '/'; 934 cache += clear_ce_flags_1(cache, cache_end - cache, 935 prefix, prefix_len + len, 936 select_mask, clear_mask, el, defval); 937 continue; 938 } 939 940 /* Non-directory */ 941 dtype = ce_to_dtype(ce); 942 ret = is_excluded_from_list(ce->name, ce_namelen(ce), 943 name, &dtype, el); 944 if (ret < 0) 945 ret = defval; 946 if (ret > 0) 947 ce->ce_flags &= ~clear_mask; 948 cache++; 949 } 950 return nr - (cache_end - cache); 951} 952 953static int clear_ce_flags(struct cache_entry **cache, int nr, 954 int select_mask, int clear_mask, 955 struct exclude_list *el) 956{ 957 char prefix[PATH_MAX]; 958 return clear_ce_flags_1(cache, nr, 959 prefix, 0, 960 select_mask, clear_mask, 961 el, 0); 962} 963 964/* 965 * Set/Clear CE_NEW_SKIP_WORKTREE according to $GIT_DIR/info/sparse-checkout 966 */ 967static void mark_new_skip_worktree(struct exclude_list *el, 968 struct index_state *the_index, 969 int select_flag, int skip_wt_flag) 970{ 971 int i; 972 973 /* 974 * 1. Pretend the narrowest worktree: only unmerged entries 975 * are checked out 976 */ 977 for (i = 0; i < the_index->cache_nr; i++) { 978 struct cache_entry *ce = the_index->cache[i]; 979 980 if (select_flag && !(ce->ce_flags & select_flag)) 981 continue; 982 983 if (!ce_stage(ce)) 984 ce->ce_flags |= skip_wt_flag; 985 else 986 ce->ce_flags &= ~skip_wt_flag; 987 } 988 989 /* 990 * 2. Widen worktree according to sparse-checkout file. 991 * Matched entries will have skip_wt_flag cleared (i.e. "in") 992 */ 993 clear_ce_flags(the_index->cache, the_index->cache_nr, 994 select_flag, skip_wt_flag, el); 995} 996 997static int verify_absent(struct cache_entry *, enum unpack_trees_error_types, struct unpack_trees_options *); 998/* 999 * N-way merge "len" trees. Returns 0 on success, -1 on failure to manipulate the1000 * resulting index, -2 on failure to reflect the changes to the work tree.1001 *1002 * CE_ADDED, CE_UNPACKED and CE_NEW_SKIP_WORKTREE are used internally1003 */1004int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)1005{1006 int i, ret;1007 static struct cache_entry *dfc;1008 struct exclude_list el;10091010 if (len > MAX_UNPACK_TREES)1011 die("unpack_trees takes at most %d trees", MAX_UNPACK_TREES);1012 memset(&state, 0, sizeof(state));1013 state.base_dir = "";1014 state.force = 1;1015 state.quiet = 1;1016 state.refresh_cache = 1;10171018 memset(&el, 0, sizeof(el));1019 if (!core_apply_sparse_checkout || !o->update)1020 o->skip_sparse_checkout = 1;1021 if (!o->skip_sparse_checkout) {1022 if (add_excludes_from_file_to_list(git_path("info/sparse-checkout"), "", 0, NULL, &el, 0) < 0)1023 o->skip_sparse_checkout = 1;1024 else1025 o->el = ⪙1026 }10271028 if (o->dir) {1029 o->path_exclude_check = xmalloc(sizeof(struct path_exclude_check));1030 path_exclude_check_init(o->path_exclude_check, o->dir);1031 }1032 memset(&o->result, 0, sizeof(o->result));1033 o->result.initialized = 1;1034 o->result.timestamp.sec = o->src_index->timestamp.sec;1035 o->result.timestamp.nsec = o->src_index->timestamp.nsec;1036 o->result.version = o->src_index->version;1037 o->merge_size = len;1038 mark_all_ce_unused(o->src_index);10391040 /*1041 * Sparse checkout loop #1: set NEW_SKIP_WORKTREE on existing entries1042 */1043 if (!o->skip_sparse_checkout)1044 mark_new_skip_worktree(o->el, o->src_index, 0, CE_NEW_SKIP_WORKTREE);10451046 if (!dfc)1047 dfc = xcalloc(1, cache_entry_size(0));1048 o->df_conflict_entry = dfc;10491050 if (len) {1051 const char *prefix = o->prefix ? o->prefix : "";1052 struct traverse_info info;10531054 setup_traverse_info(&info, prefix);1055 info.fn = unpack_callback;1056 info.data = o;1057 info.show_all_errors = o->show_all_errors;1058 info.pathspec = o->pathspec;10591060 if (o->prefix) {1061 /*1062 * Unpack existing index entries that sort before the1063 * prefix the tree is spliced into. Note that o->merge1064 * is always true in this case.1065 */1066 while (1) {1067 struct cache_entry *ce = next_cache_entry(o);1068 if (!ce)1069 break;1070 if (ce_in_traverse_path(ce, &info))1071 break;1072 if (unpack_index_entry(ce, o) < 0)1073 goto return_failed;1074 }1075 }10761077 if (traverse_trees(len, t, &info) < 0)1078 goto return_failed;1079 }10801081 /* Any left-over entries in the index? */1082 if (o->merge) {1083 while (1) {1084 struct cache_entry *ce = next_cache_entry(o);1085 if (!ce)1086 break;1087 if (unpack_index_entry(ce, o) < 0)1088 goto return_failed;1089 }1090 }1091 mark_all_ce_unused(o->src_index);10921093 if (o->trivial_merges_only && o->nontrivial_merge) {1094 ret = unpack_failed(o, "Merge requires file-level merging");1095 goto done;1096 }10971098 if (!o->skip_sparse_checkout) {1099 int empty_worktree = 1;11001101 /*1102 * Sparse checkout loop #2: set NEW_SKIP_WORKTREE on entries not in loop #11103 * If the will have NEW_SKIP_WORKTREE, also set CE_SKIP_WORKTREE1104 * so apply_sparse_checkout() won't attempt to remove it from worktree1105 */1106 mark_new_skip_worktree(o->el, &o->result, CE_ADDED, CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);11071108 ret = 0;1109 for (i = 0; i < o->result.cache_nr; i++) {1110 struct cache_entry *ce = o->result.cache[i];11111112 /*1113 * Entries marked with CE_ADDED in merged_entry() do not have1114 * verify_absent() check (the check is effectively disabled1115 * because CE_NEW_SKIP_WORKTREE is set unconditionally).1116 *1117 * Do the real check now because we have had1118 * correct CE_NEW_SKIP_WORKTREE1119 */1120 if (ce->ce_flags & CE_ADDED &&1121 verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) {1122 if (!o->show_all_errors)1123 goto return_failed;1124 ret = -1;1125 }11261127 if (apply_sparse_checkout(ce, o)) {1128 if (!o->show_all_errors)1129 goto return_failed;1130 ret = -1;1131 }1132 if (!ce_skip_worktree(ce))1133 empty_worktree = 0;11341135 }1136 if (ret < 0)1137 goto return_failed;1138 /*1139 * Sparse checkout is meant to narrow down checkout area1140 * but it does not make sense to narrow down to empty working1141 * tree. This is usually a mistake in sparse checkout rules.1142 * Do not allow users to do that.1143 */1144 if (o->result.cache_nr && empty_worktree) {1145 ret = unpack_failed(o, "Sparse checkout leaves no entry on working directory");1146 goto done;1147 }1148 }11491150 o->src_index = NULL;1151 ret = check_updates(o) ? (-2) : 0;1152 if (o->dst_index)1153 *o->dst_index = o->result;11541155done:1156 clear_exclude_list(&el);1157 if (o->path_exclude_check) {1158 path_exclude_check_clear(o->path_exclude_check);1159 free(o->path_exclude_check);1160 }1161 return ret;11621163return_failed:1164 if (o->show_all_errors)1165 display_error_msgs(o);1166 mark_all_ce_unused(o->src_index);1167 ret = unpack_failed(o, NULL);1168 if (o->exiting_early)1169 ret = 0;1170 goto done;1171}11721173/* Here come the merge functions */11741175static int reject_merge(struct cache_entry *ce, struct unpack_trees_options *o)1176{1177 return add_rejected_path(o, ERROR_WOULD_OVERWRITE, ce->name);1178}11791180static int same(struct cache_entry *a, struct cache_entry *b)1181{1182 if (!!a != !!b)1183 return 0;1184 if (!a && !b)1185 return 1;1186 if ((a->ce_flags | b->ce_flags) & CE_CONFLICTED)1187 return 0;1188 return a->ce_mode == b->ce_mode &&1189 !hashcmp(a->sha1, b->sha1);1190}119111921193/*1194 * When a CE gets turned into an unmerged entry, we1195 * want it to be up-to-date1196 */1197static int verify_uptodate_1(struct cache_entry *ce,1198 struct unpack_trees_options *o,1199 enum unpack_trees_error_types error_type)1200{1201 struct stat st;12021203 if (o->index_only)1204 return 0;12051206 /*1207 * CE_VALID and CE_SKIP_WORKTREE cheat, we better check again1208 * if this entry is truly up-to-date because this file may be1209 * overwritten.1210 */1211 if ((ce->ce_flags & CE_VALID) || ce_skip_worktree(ce))1212 ; /* keep checking */1213 else if (o->reset || ce_uptodate(ce))1214 return 0;12151216 if (!lstat(ce->name, &st)) {1217 int flags = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE;1218 unsigned changed = ie_match_stat(o->src_index, ce, &st, flags);1219 if (!changed)1220 return 0;1221 /*1222 * NEEDSWORK: the current default policy is to allow1223 * submodule to be out of sync wrt the superproject1224 * index. This needs to be tightened later for1225 * submodules that are marked to be automatically1226 * checked out.1227 */1228 if (S_ISGITLINK(ce->ce_mode))1229 return 0;1230 errno = 0;1231 }1232 if (errno == ENOENT)1233 return 0;1234 return o->gently ? -1 :1235 add_rejected_path(o, error_type, ce->name);1236}12371238static int verify_uptodate(struct cache_entry *ce,1239 struct unpack_trees_options *o)1240{1241 if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1242 return 0;1243 return verify_uptodate_1(ce, o, ERROR_NOT_UPTODATE_FILE);1244}12451246static int verify_uptodate_sparse(struct cache_entry *ce,1247 struct unpack_trees_options *o)1248{1249 return verify_uptodate_1(ce, o, ERROR_SPARSE_NOT_UPTODATE_FILE);1250}12511252static void invalidate_ce_path(struct cache_entry *ce, struct unpack_trees_options *o)1253{1254 if (ce)1255 cache_tree_invalidate_path(o->src_index->cache_tree, ce->name);1256}12571258/*1259 * Check that checking out ce->sha1 in subdir ce->name is not1260 * going to overwrite any working files.1261 *1262 * Currently, git does not checkout subprojects during a superproject1263 * checkout, so it is not going to overwrite anything.1264 */1265static int verify_clean_submodule(struct cache_entry *ce,1266 enum unpack_trees_error_types error_type,1267 struct unpack_trees_options *o)1268{1269 return 0;1270}12711272static int verify_clean_subdirectory(struct cache_entry *ce,1273 enum unpack_trees_error_types error_type,1274 struct unpack_trees_options *o)1275{1276 /*1277 * we are about to extract "ce->name"; we would not want to lose1278 * anything in the existing directory there.1279 */1280 int namelen;1281 int i;1282 struct dir_struct d;1283 char *pathbuf;1284 int cnt = 0;1285 unsigned char sha1[20];12861287 if (S_ISGITLINK(ce->ce_mode) &&1288 resolve_gitlink_ref(ce->name, "HEAD", sha1) == 0) {1289 /* If we are not going to update the submodule, then1290 * we don't care.1291 */1292 if (!hashcmp(sha1, ce->sha1))1293 return 0;1294 return verify_clean_submodule(ce, error_type, o);1295 }12961297 /*1298 * First let's make sure we do not have a local modification1299 * in that directory.1300 */1301 namelen = strlen(ce->name);1302 for (i = locate_in_src_index(ce, o);1303 i < o->src_index->cache_nr;1304 i++) {1305 struct cache_entry *ce2 = o->src_index->cache[i];1306 int len = ce_namelen(ce2);1307 if (len < namelen ||1308 strncmp(ce->name, ce2->name, namelen) ||1309 ce2->name[namelen] != '/')1310 break;1311 /*1312 * ce2->name is an entry in the subdirectory to be1313 * removed.1314 */1315 if (!ce_stage(ce2)) {1316 if (verify_uptodate(ce2, o))1317 return -1;1318 add_entry(o, ce2, CE_REMOVE, 0);1319 mark_ce_used(ce2, o);1320 }1321 cnt++;1322 }13231324 /*1325 * Then we need to make sure that we do not lose a locally1326 * present file that is not ignored.1327 */1328 pathbuf = xmalloc(namelen + 2);1329 memcpy(pathbuf, ce->name, namelen);1330 strcpy(pathbuf+namelen, "/");13311332 memset(&d, 0, sizeof(d));1333 if (o->dir)1334 d.exclude_per_dir = o->dir->exclude_per_dir;1335 i = read_directory(&d, pathbuf, namelen+1, NULL);1336 if (i)1337 return o->gently ? -1 :1338 add_rejected_path(o, ERROR_NOT_UPTODATE_DIR, ce->name);1339 free(pathbuf);1340 return cnt;1341}13421343/*1344 * This gets called when there was no index entry for the tree entry 'dst',1345 * but we found a file in the working tree that 'lstat()' said was fine,1346 * and we're on a case-insensitive filesystem.1347 *1348 * See if we can find a case-insensitive match in the index that also1349 * matches the stat information, and assume it's that other file!1350 */1351static int icase_exists(struct unpack_trees_options *o, const char *name, int len, struct stat *st)1352{1353 struct cache_entry *src;13541355 src = index_name_exists(o->src_index, name, len, 1);1356 return src && !ie_match_stat(o->src_index, src, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);1357}13581359static int check_ok_to_remove(const char *name, int len, int dtype,1360 struct cache_entry *ce, struct stat *st,1361 enum unpack_trees_error_types error_type,1362 struct unpack_trees_options *o)1363{1364 struct cache_entry *result;13651366 /*1367 * It may be that the 'lstat()' succeeded even though1368 * target 'ce' was absent, because there is an old1369 * entry that is different only in case..1370 *1371 * Ignore that lstat() if it matches.1372 */1373 if (ignore_case && icase_exists(o, name, len, st))1374 return 0;13751376 if (o->dir &&1377 is_path_excluded(o->path_exclude_check, name, -1, &dtype))1378 /*1379 * ce->name is explicitly excluded, so it is Ok to1380 * overwrite it.1381 */1382 return 0;1383 if (S_ISDIR(st->st_mode)) {1384 /*1385 * We are checking out path "foo" and1386 * found "foo/." in the working tree.1387 * This is tricky -- if we have modified1388 * files that are in "foo/" we would lose1389 * them.1390 */1391 if (verify_clean_subdirectory(ce, error_type, o) < 0)1392 return -1;1393 return 0;1394 }13951396 /*1397 * The previous round may already have decided to1398 * delete this path, which is in a subdirectory that1399 * is being replaced with a blob.1400 */1401 result = index_name_exists(&o->result, name, len, 0);1402 if (result) {1403 if (result->ce_flags & CE_REMOVE)1404 return 0;1405 }14061407 return o->gently ? -1 :1408 add_rejected_path(o, error_type, name);1409}14101411/*1412 * We do not want to remove or overwrite a working tree file that1413 * is not tracked, unless it is ignored.1414 */1415static int verify_absent_1(struct cache_entry *ce,1416 enum unpack_trees_error_types error_type,1417 struct unpack_trees_options *o)1418{1419 int len;1420 struct stat st;14211422 if (o->index_only || o->reset || !o->update)1423 return 0;14241425 len = check_leading_path(ce->name, ce_namelen(ce));1426 if (!len)1427 return 0;1428 else if (len > 0) {1429 char path[PATH_MAX + 1];1430 memcpy(path, ce->name, len);1431 path[len] = 0;1432 if (lstat(path, &st))1433 return error("cannot stat '%s': %s", path,1434 strerror(errno));14351436 return check_ok_to_remove(path, len, DT_UNKNOWN, NULL, &st,1437 error_type, o);1438 } else if (lstat(ce->name, &st)) {1439 if (errno != ENOENT)1440 return error("cannot stat '%s': %s", ce->name,1441 strerror(errno));1442 return 0;1443 } else {1444 return check_ok_to_remove(ce->name, ce_namelen(ce),1445 ce_to_dtype(ce), ce, &st,1446 error_type, o);1447 }1448}14491450static int verify_absent(struct cache_entry *ce,1451 enum unpack_trees_error_types error_type,1452 struct unpack_trees_options *o)1453{1454 if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1455 return 0;1456 return verify_absent_1(ce, error_type, o);1457}14581459static int verify_absent_sparse(struct cache_entry *ce,1460 enum unpack_trees_error_types error_type,1461 struct unpack_trees_options *o)1462{1463 enum unpack_trees_error_types orphaned_error = error_type;1464 if (orphaned_error == ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN)1465 orphaned_error = ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN;14661467 return verify_absent_1(ce, orphaned_error, o);1468}14691470static int merged_entry(struct cache_entry *merge, struct cache_entry *old,1471 struct unpack_trees_options *o)1472{1473 int update = CE_UPDATE;14741475 if (!old) {1476 /*1477 * New index entries. In sparse checkout, the following1478 * verify_absent() will be delayed until after1479 * traverse_trees() finishes in unpack_trees(), then:1480 *1481 * - CE_NEW_SKIP_WORKTREE will be computed correctly1482 * - verify_absent() be called again, this time with1483 * correct CE_NEW_SKIP_WORKTREE1484 *1485 * verify_absent() call here does nothing in sparse1486 * checkout (i.e. o->skip_sparse_checkout == 0)1487 */1488 update |= CE_ADDED;1489 merge->ce_flags |= CE_NEW_SKIP_WORKTREE;14901491 if (verify_absent(merge, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o))1492 return -1;1493 invalidate_ce_path(merge, o);1494 } else if (!(old->ce_flags & CE_CONFLICTED)) {1495 /*1496 * See if we can re-use the old CE directly?1497 * That way we get the uptodate stat info.1498 *1499 * This also removes the UPDATE flag on a match; otherwise1500 * we will end up overwriting local changes in the work tree.1501 */1502 if (same(old, merge)) {1503 copy_cache_entry(merge, old);1504 update = 0;1505 } else {1506 if (verify_uptodate(old, o))1507 return -1;1508 /* Migrate old flags over */1509 update |= old->ce_flags & (CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);1510 invalidate_ce_path(old, o);1511 }1512 } else {1513 /*1514 * Previously unmerged entry left as an existence1515 * marker by read_index_unmerged();1516 */1517 invalidate_ce_path(old, o);1518 }15191520 add_entry(o, merge, update, CE_STAGEMASK);1521 return 1;1522}15231524static int deleted_entry(struct cache_entry *ce, struct cache_entry *old,1525 struct unpack_trees_options *o)1526{1527 /* Did it exist in the index? */1528 if (!old) {1529 if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))1530 return -1;1531 return 0;1532 }1533 if (!(old->ce_flags & CE_CONFLICTED) && verify_uptodate(old, o))1534 return -1;1535 add_entry(o, ce, CE_REMOVE, 0);1536 invalidate_ce_path(ce, o);1537 return 1;1538}15391540static int keep_entry(struct cache_entry *ce, struct unpack_trees_options *o)1541{1542 add_entry(o, ce, 0, 0);1543 return 1;1544}15451546#if DBRT_DEBUG1547static void show_stage_entry(FILE *o,1548 const char *label, const struct cache_entry *ce)1549{1550 if (!ce)1551 fprintf(o, "%s (missing)\n", label);1552 else1553 fprintf(o, "%s%06o %s %d\t%s\n",1554 label,1555 ce->ce_mode,1556 sha1_to_hex(ce->sha1),1557 ce_stage(ce),1558 ce->name);1559}1560#endif15611562int threeway_merge(struct cache_entry **stages, struct unpack_trees_options *o)1563{1564 struct cache_entry *index;1565 struct cache_entry *head;1566 struct cache_entry *remote = stages[o->head_idx + 1];1567 int count;1568 int head_match = 0;1569 int remote_match = 0;15701571 int df_conflict_head = 0;1572 int df_conflict_remote = 0;15731574 int any_anc_missing = 0;1575 int no_anc_exists = 1;1576 int i;15771578 for (i = 1; i < o->head_idx; i++) {1579 if (!stages[i] || stages[i] == o->df_conflict_entry)1580 any_anc_missing = 1;1581 else1582 no_anc_exists = 0;1583 }15841585 index = stages[0];1586 head = stages[o->head_idx];15871588 if (head == o->df_conflict_entry) {1589 df_conflict_head = 1;1590 head = NULL;1591 }15921593 if (remote == o->df_conflict_entry) {1594 df_conflict_remote = 1;1595 remote = NULL;1596 }15971598 /*1599 * First, if there's a #16 situation, note that to prevent #131600 * and #14.1601 */1602 if (!same(remote, head)) {1603 for (i = 1; i < o->head_idx; i++) {1604 if (same(stages[i], head)) {1605 head_match = i;1606 }1607 if (same(stages[i], remote)) {1608 remote_match = i;1609 }1610 }1611 }16121613 /*1614 * We start with cases where the index is allowed to match1615 * something other than the head: #14(ALT) and #2ALT, where it1616 * is permitted to match the result instead.1617 */1618 /* #14, #14ALT, #2ALT */1619 if (remote && !df_conflict_head && head_match && !remote_match) {1620 if (index && !same(index, remote) && !same(index, head))1621 return o->gently ? -1 : reject_merge(index, o);1622 return merged_entry(remote, index, o);1623 }1624 /*1625 * If we have an entry in the index cache, then we want to1626 * make sure that it matches head.1627 */1628 if (index && !same(index, head))1629 return o->gently ? -1 : reject_merge(index, o);16301631 if (head) {1632 /* #5ALT, #15 */1633 if (same(head, remote))1634 return merged_entry(head, index, o);1635 /* #13, #3ALT */1636 if (!df_conflict_remote && remote_match && !head_match)1637 return merged_entry(head, index, o);1638 }16391640 /* #1 */1641 if (!head && !remote && any_anc_missing)1642 return 0;16431644 /*1645 * Under the "aggressive" rule, we resolve mostly trivial1646 * cases that we historically had git-merge-one-file resolve.1647 */1648 if (o->aggressive) {1649 int head_deleted = !head;1650 int remote_deleted = !remote;1651 struct cache_entry *ce = NULL;16521653 if (index)1654 ce = index;1655 else if (head)1656 ce = head;1657 else if (remote)1658 ce = remote;1659 else {1660 for (i = 1; i < o->head_idx; i++) {1661 if (stages[i] && stages[i] != o->df_conflict_entry) {1662 ce = stages[i];1663 break;1664 }1665 }1666 }16671668 /*1669 * Deleted in both.1670 * Deleted in one and unchanged in the other.1671 */1672 if ((head_deleted && remote_deleted) ||1673 (head_deleted && remote && remote_match) ||1674 (remote_deleted && head && head_match)) {1675 if (index)1676 return deleted_entry(index, index, o);1677 if (ce && !head_deleted) {1678 if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))1679 return -1;1680 }1681 return 0;1682 }1683 /*1684 * Added in both, identically.1685 */1686 if (no_anc_exists && head && remote && same(head, remote))1687 return merged_entry(head, index, o);16881689 }16901691 /* Below are "no merge" cases, which require that the index be1692 * up-to-date to avoid the files getting overwritten with1693 * conflict resolution files.1694 */1695 if (index) {1696 if (verify_uptodate(index, o))1697 return -1;1698 }16991700 o->nontrivial_merge = 1;17011702 /* #2, #3, #4, #6, #7, #9, #10, #11. */1703 count = 0;1704 if (!head_match || !remote_match) {1705 for (i = 1; i < o->head_idx; i++) {1706 if (stages[i] && stages[i] != o->df_conflict_entry) {1707 keep_entry(stages[i], o);1708 count++;1709 break;1710 }1711 }1712 }1713#if DBRT_DEBUG1714 else {1715 fprintf(stderr, "read-tree: warning #16 detected\n");1716 show_stage_entry(stderr, "head ", stages[head_match]);1717 show_stage_entry(stderr, "remote ", stages[remote_match]);1718 }1719#endif1720 if (head) { count += keep_entry(head, o); }1721 if (remote) { count += keep_entry(remote, o); }1722 return count;1723}17241725/*1726 * Two-way merge.1727 *1728 * The rule is to "carry forward" what is in the index without losing1729 * information across a "fast-forward", favoring a successful merge1730 * over a merge failure when it makes sense. For details of the1731 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.1732 *1733 */1734int twoway_merge(struct cache_entry **src, struct unpack_trees_options *o)1735{1736 struct cache_entry *current = src[0];1737 struct cache_entry *oldtree = src[1];1738 struct cache_entry *newtree = src[2];17391740 if (o->merge_size != 2)1741 return error("Cannot do a twoway merge of %d trees",1742 o->merge_size);17431744 if (oldtree == o->df_conflict_entry)1745 oldtree = NULL;1746 if (newtree == o->df_conflict_entry)1747 newtree = NULL;17481749 if (current) {1750 if ((!oldtree && !newtree) || /* 4 and 5 */1751 (!oldtree && newtree &&1752 same(current, newtree)) || /* 6 and 7 */1753 (oldtree && newtree &&1754 same(oldtree, newtree)) || /* 14 and 15 */1755 (oldtree && newtree &&1756 !same(oldtree, newtree) && /* 18 and 19 */1757 same(current, newtree))) {1758 return keep_entry(current, o);1759 }1760 else if (oldtree && !newtree && same(current, oldtree)) {1761 /* 10 or 11 */1762 return deleted_entry(oldtree, current, o);1763 }1764 else if (oldtree && newtree &&1765 same(current, oldtree) && !same(current, newtree)) {1766 /* 20 or 21 */1767 return merged_entry(newtree, current, o);1768 }1769 else {1770 /* all other failures */1771 if (oldtree)1772 return o->gently ? -1 : reject_merge(oldtree, o);1773 if (current)1774 return o->gently ? -1 : reject_merge(current, o);1775 if (newtree)1776 return o->gently ? -1 : reject_merge(newtree, o);1777 return -1;1778 }1779 }1780 else if (newtree) {1781 if (oldtree && !o->initial_checkout) {1782 /*1783 * deletion of the path was staged;1784 */1785 if (same(oldtree, newtree))1786 return 1;1787 return reject_merge(oldtree, o);1788 }1789 return merged_entry(newtree, current, o);1790 }1791 return deleted_entry(oldtree, current, o);1792}17931794/*1795 * Bind merge.1796 *1797 * Keep the index entries at stage0, collapse stage1 but make sure1798 * stage0 does not have anything there.1799 */1800int bind_merge(struct cache_entry **src,1801 struct unpack_trees_options *o)1802{1803 struct cache_entry *old = src[0];1804 struct cache_entry *a = src[1];18051806 if (o->merge_size != 1)1807 return error("Cannot do a bind merge of %d trees",1808 o->merge_size);1809 if (a && old)1810 return o->gently ? -1 :1811 error(ERRORMSG(o, ERROR_BIND_OVERLAP), a->name, old->name);1812 if (!a)1813 return keep_entry(old, o);1814 else1815 return merged_entry(a, NULL, o);1816}18171818/*1819 * One-way merge.1820 *1821 * The rule is:1822 * - take the stat information from stage0, take the data from stage11823 */1824int oneway_merge(struct cache_entry **src, struct unpack_trees_options *o)1825{1826 struct cache_entry *old = src[0];1827 struct cache_entry *a = src[1];18281829 if (o->merge_size != 1)1830 return error("Cannot do a oneway merge of %d trees",1831 o->merge_size);18321833 if (!a || a == o->df_conflict_entry)1834 return deleted_entry(old, old, o);18351836 if (old && same(old, a)) {1837 int update = 0;1838 if (o->reset && !ce_uptodate(old) && !ce_skip_worktree(old)) {1839 struct stat st;1840 if (lstat(old->name, &st) ||1841 ie_match_stat(o->src_index, old, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE))1842 update |= CE_UPDATE;1843 }1844 add_entry(o, old, update, 0);1845 return 0;1846 }1847 return merged_entry(a, old, o);1848}