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#include "split-index.h" 12#include "dir.h" 13 14/* 15 * Error messages expected by scripts out of plumbing commands such as 16 * read-tree. Non-scripted Porcelain is not required to use these messages 17 * and in fact are encouraged to reword them to better suit their particular 18 * situation better. See how "git checkout" and "git merge" replaces 19 * them using setup_unpack_trees_porcelain(), for example. 20 */ 21static const char *unpack_plumbing_errors[NB_UNPACK_TREES_ERROR_TYPES] = { 22 /* ERROR_WOULD_OVERWRITE */ 23 "Entry '%s' would be overwritten by merge. Cannot merge.", 24 25 /* ERROR_NOT_UPTODATE_FILE */ 26 "Entry '%s' not uptodate. Cannot merge.", 27 28 /* ERROR_NOT_UPTODATE_DIR */ 29 "Updating '%s' would lose untracked files in it", 30 31 /* ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN */ 32 "Untracked working tree file '%s' would be overwritten by merge.", 33 34 /* ERROR_WOULD_LOSE_UNTRACKED_REMOVED */ 35 "Untracked working tree file '%s' would be removed by merge.", 36 37 /* ERROR_BIND_OVERLAP */ 38 "Entry '%s' overlaps with '%s'. Cannot bind.", 39 40 /* ERROR_SPARSE_NOT_UPTODATE_FILE */ 41 "Entry '%s' not uptodate. Cannot update sparse checkout.", 42 43 /* ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN */ 44 "Working tree file '%s' would be overwritten by sparse checkout update.", 45 46 /* ERROR_WOULD_LOSE_ORPHANED_REMOVED */ 47 "Working tree file '%s' would be removed by sparse checkout update.", 48}; 49 50#define ERRORMSG(o,type) \ 51 ( ((o) && (o)->msgs[(type)]) \ 52 ? ((o)->msgs[(type)]) \ 53 : (unpack_plumbing_errors[(type)]) ) 54 55void setup_unpack_trees_porcelain(struct unpack_trees_options *opts, 56 const char *cmd) 57{ 58 int i; 59 const char **msgs = opts->msgs; 60 const char *msg; 61 const char *cmd2 = strcmp(cmd, "checkout") ? cmd : "switch branches"; 62 63 if (advice_commit_before_merge) 64 msg = _("Your local changes to the following files would be overwritten by %s:\n%%s" 65 "Please, commit your changes or stash them before you can %s."); 66 else 67 msg = _("Your local changes to the following files would be overwritten by %s:\n%%s"); 68 msgs[ERROR_WOULD_OVERWRITE] = msgs[ERROR_NOT_UPTODATE_FILE] = 69 xstrfmt(msg, cmd, cmd2); 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 80 msgs[ERROR_WOULD_LOSE_UNTRACKED_REMOVED] = xstrfmt(msg, "removed", cmd, cmd2); 81 msgs[ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN] = xstrfmt(msg, "overwritten", cmd, cmd2); 82 83 /* 84 * Special case: ERROR_BIND_OVERLAP refers to a pair of paths, we 85 * cannot easily display it as a list. 86 */ 87 msgs[ERROR_BIND_OVERLAP] = _("Entry '%s' overlaps with '%s'. Cannot bind."); 88 89 msgs[ERROR_SPARSE_NOT_UPTODATE_FILE] = 90 _("Cannot update sparse checkout: the following entries are not up-to-date:\n%s"); 91 msgs[ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN] = 92 _("The following Working tree files would be overwritten by sparse checkout update:\n%s"); 93 msgs[ERROR_WOULD_LOSE_ORPHANED_REMOVED] = 94 _("The following Working tree files would be removed by sparse checkout update:\n%s"); 95 96 opts->show_all_errors = 1; 97 /* rejected paths may not have a static buffer */ 98 for (i = 0; i < ARRAY_SIZE(opts->unpack_rejects); i++) 99 opts->unpack_rejects[i].strdup_strings = 1; 100} 101 102static int do_add_entry(struct unpack_trees_options *o, struct cache_entry *ce, 103 unsigned int set, unsigned int clear) 104{ 105 clear |= CE_HASHED; 106 107 if (set & CE_REMOVE) 108 set |= CE_WT_REMOVE; 109 110 ce->ce_flags = (ce->ce_flags & ~clear) | set; 111 return add_index_entry(&o->result, ce, 112 ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); 113} 114 115static struct cache_entry *dup_entry(const struct cache_entry *ce) 116{ 117 unsigned int size = ce_size(ce); 118 struct cache_entry *new = xmalloc(size); 119 120 memcpy(new, ce, size); 121 return new; 122} 123 124static void add_entry(struct unpack_trees_options *o, 125 const struct cache_entry *ce, 126 unsigned int set, unsigned int clear) 127{ 128 do_add_entry(o, dup_entry(ce), set, clear); 129} 130 131/* 132 * add error messages on path <path> 133 * corresponding to the type <e> with the message <msg> 134 * indicating if it should be display in porcelain or not 135 */ 136static int add_rejected_path(struct unpack_trees_options *o, 137 enum unpack_trees_error_types e, 138 const char *path) 139{ 140 if (!o->show_all_errors) 141 return error(ERRORMSG(o, e), path); 142 143 /* 144 * Otherwise, insert in a list for future display by 145 * display_error_msgs() 146 */ 147 string_list_append(&o->unpack_rejects[e], path); 148 return -1; 149} 150 151/* 152 * display all the error messages stored in a nice way 153 */ 154static void display_error_msgs(struct unpack_trees_options *o) 155{ 156 int e, i; 157 int something_displayed = 0; 158 for (e = 0; e < NB_UNPACK_TREES_ERROR_TYPES; e++) { 159 struct string_list *rejects = &o->unpack_rejects[e]; 160 if (rejects->nr > 0) { 161 struct strbuf path = STRBUF_INIT; 162 something_displayed = 1; 163 for (i = 0; i < rejects->nr; i++) 164 strbuf_addf(&path, "\t%s\n", rejects->items[i].string); 165 error(ERRORMSG(o, e), path.buf); 166 strbuf_release(&path); 167 } 168 string_list_clear(rejects, 0); 169 } 170 if (something_displayed) 171 fprintf(stderr, _("Aborting\n")); 172} 173 174/* 175 * Unlink the last component and schedule the leading directories for 176 * removal, such that empty directories get removed. 177 */ 178static void unlink_entry(const struct cache_entry *ce) 179{ 180 if (!check_leading_path(ce->name, ce_namelen(ce))) 181 return; 182 if (remove_or_warn(ce->ce_mode, ce->name)) 183 return; 184 schedule_dir_for_removal(ce->name, ce_namelen(ce)); 185} 186 187static struct checkout state; 188static int check_updates(struct unpack_trees_options *o) 189{ 190 unsigned cnt = 0, total = 0; 191 struct progress *progress = NULL; 192 struct index_state *index = &o->result; 193 int i; 194 int errs = 0; 195 196 if (o->update && o->verbose_update) { 197 for (total = cnt = 0; cnt < index->cache_nr; cnt++) { 198 const struct cache_entry *ce = index->cache[cnt]; 199 if (ce->ce_flags & (CE_UPDATE | CE_WT_REMOVE)) 200 total++; 201 } 202 203 progress = start_progress_delay(_("Checking out files"), 204 total, 50, 1); 205 cnt = 0; 206 } 207 208 if (o->update) 209 git_attr_set_direction(GIT_ATTR_CHECKOUT, &o->result); 210 for (i = 0; i < index->cache_nr; i++) { 211 const struct cache_entry *ce = index->cache[i]; 212 213 if (ce->ce_flags & CE_WT_REMOVE) { 214 display_progress(progress, ++cnt); 215 if (o->update && !o->dry_run) 216 unlink_entry(ce); 217 continue; 218 } 219 } 220 remove_marked_cache_entries(&o->result); 221 remove_scheduled_dirs(); 222 223 for (i = 0; i < index->cache_nr; i++) { 224 struct cache_entry *ce = index->cache[i]; 225 226 if (ce->ce_flags & CE_UPDATE) { 227 if (ce->ce_flags & CE_WT_REMOVE) 228 die("BUG: both update and delete flags are set on %s", 229 ce->name); 230 display_progress(progress, ++cnt); 231 ce->ce_flags &= ~CE_UPDATE; 232 if (o->update && !o->dry_run) { 233 errs |= checkout_entry(ce, &state, NULL); 234 } 235 } 236 } 237 stop_progress(&progress); 238 if (o->update) 239 git_attr_set_direction(GIT_ATTR_CHECKIN, NULL); 240 return errs != 0; 241} 242 243static int verify_uptodate_sparse(const struct cache_entry *ce, 244 struct unpack_trees_options *o); 245static int verify_absent_sparse(const struct cache_entry *ce, 246 enum unpack_trees_error_types, 247 struct unpack_trees_options *o); 248 249static int apply_sparse_checkout(struct index_state *istate, 250 struct cache_entry *ce, 251 struct unpack_trees_options *o) 252{ 253 int was_skip_worktree = ce_skip_worktree(ce); 254 255 if (ce->ce_flags & CE_NEW_SKIP_WORKTREE) 256 ce->ce_flags |= CE_SKIP_WORKTREE; 257 else 258 ce->ce_flags &= ~CE_SKIP_WORKTREE; 259 if (was_skip_worktree != ce_skip_worktree(ce)) { 260 ce->ce_flags |= CE_UPDATE_IN_BASE; 261 istate->cache_changed |= CE_ENTRY_CHANGED; 262 } 263 264 /* 265 * if (!was_skip_worktree && !ce_skip_worktree()) { 266 * This is perfectly normal. Move on; 267 * } 268 */ 269 270 /* 271 * Merge strategies may set CE_UPDATE|CE_REMOVE outside checkout 272 * area as a result of ce_skip_worktree() shortcuts in 273 * verify_absent() and verify_uptodate(). 274 * Make sure they don't modify worktree if they are already 275 * outside checkout area 276 */ 277 if (was_skip_worktree && ce_skip_worktree(ce)) { 278 ce->ce_flags &= ~CE_UPDATE; 279 280 /* 281 * By default, when CE_REMOVE is on, CE_WT_REMOVE is also 282 * on to get that file removed from both index and worktree. 283 * If that file is already outside worktree area, don't 284 * bother remove it. 285 */ 286 if (ce->ce_flags & CE_REMOVE) 287 ce->ce_flags &= ~CE_WT_REMOVE; 288 } 289 290 if (!was_skip_worktree && ce_skip_worktree(ce)) { 291 /* 292 * If CE_UPDATE is set, verify_uptodate() must be called already 293 * also stat info may have lost after merged_entry() so calling 294 * verify_uptodate() again may fail 295 */ 296 if (!(ce->ce_flags & CE_UPDATE) && verify_uptodate_sparse(ce, o)) 297 return -1; 298 ce->ce_flags |= CE_WT_REMOVE; 299 ce->ce_flags &= ~CE_UPDATE; 300 } 301 if (was_skip_worktree && !ce_skip_worktree(ce)) { 302 if (verify_absent_sparse(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) 303 return -1; 304 ce->ce_flags |= CE_UPDATE; 305 } 306 return 0; 307} 308 309static inline int call_unpack_fn(const struct cache_entry * const *src, 310 struct unpack_trees_options *o) 311{ 312 int ret = o->fn(src, o); 313 if (ret > 0) 314 ret = 0; 315 return ret; 316} 317 318static void mark_ce_used(struct cache_entry *ce, struct unpack_trees_options *o) 319{ 320 ce->ce_flags |= CE_UNPACKED; 321 322 if (o->cache_bottom < o->src_index->cache_nr && 323 o->src_index->cache[o->cache_bottom] == ce) { 324 int bottom = o->cache_bottom; 325 while (bottom < o->src_index->cache_nr && 326 o->src_index->cache[bottom]->ce_flags & CE_UNPACKED) 327 bottom++; 328 o->cache_bottom = bottom; 329 } 330} 331 332static void mark_all_ce_unused(struct index_state *index) 333{ 334 int i; 335 for (i = 0; i < index->cache_nr; i++) 336 index->cache[i]->ce_flags &= ~(CE_UNPACKED | CE_ADDED | CE_NEW_SKIP_WORKTREE); 337} 338 339static int locate_in_src_index(const 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 = index_name_pos(index, ce->name, len); 345 if (pos < 0) 346 pos = -1 - pos; 347 return pos; 348} 349 350/* 351 * We call unpack_index_entry() with an unmerged cache entry 352 * only in diff-index, and it wants a single callback. Skip 353 * the other unmerged entry with the same name. 354 */ 355static void mark_ce_used_same_name(struct cache_entry *ce, 356 struct unpack_trees_options *o) 357{ 358 struct index_state *index = o->src_index; 359 int len = ce_namelen(ce); 360 int pos; 361 362 for (pos = locate_in_src_index(ce, o); pos < index->cache_nr; pos++) { 363 struct cache_entry *next = index->cache[pos]; 364 if (len != ce_namelen(next) || 365 memcmp(ce->name, next->name, len)) 366 break; 367 mark_ce_used(next, o); 368 } 369} 370 371static struct cache_entry *next_cache_entry(struct unpack_trees_options *o) 372{ 373 const struct index_state *index = o->src_index; 374 int pos = o->cache_bottom; 375 376 while (pos < index->cache_nr) { 377 struct cache_entry *ce = index->cache[pos]; 378 if (!(ce->ce_flags & CE_UNPACKED)) 379 return ce; 380 pos++; 381 } 382 return NULL; 383} 384 385static void add_same_unmerged(const struct cache_entry *ce, 386 struct unpack_trees_options *o) 387{ 388 struct index_state *index = o->src_index; 389 int len = ce_namelen(ce); 390 int pos = index_name_pos(index, ce->name, len); 391 392 if (0 <= pos) 393 die("programming error in a caller of mark_ce_used_same_name"); 394 for (pos = -pos - 1; pos < index->cache_nr; pos++) { 395 struct cache_entry *next = index->cache[pos]; 396 if (len != ce_namelen(next) || 397 memcmp(ce->name, next->name, len)) 398 break; 399 add_entry(o, next, 0, 0); 400 mark_ce_used(next, o); 401 } 402} 403 404static int unpack_index_entry(struct cache_entry *ce, 405 struct unpack_trees_options *o) 406{ 407 const struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, }; 408 int ret; 409 410 src[0] = ce; 411 412 mark_ce_used(ce, o); 413 if (ce_stage(ce)) { 414 if (o->skip_unmerged) { 415 add_entry(o, ce, 0, 0); 416 return 0; 417 } 418 } 419 ret = call_unpack_fn(src, o); 420 if (ce_stage(ce)) 421 mark_ce_used_same_name(ce, o); 422 return ret; 423} 424 425static int find_cache_pos(struct traverse_info *, const struct name_entry *); 426 427static void restore_cache_bottom(struct traverse_info *info, int bottom) 428{ 429 struct unpack_trees_options *o = info->data; 430 431 if (o->diff_index_cached) 432 return; 433 o->cache_bottom = bottom; 434} 435 436static int switch_cache_bottom(struct traverse_info *info) 437{ 438 struct unpack_trees_options *o = info->data; 439 int ret, pos; 440 441 if (o->diff_index_cached) 442 return 0; 443 ret = o->cache_bottom; 444 pos = find_cache_pos(info->prev, &info->name); 445 446 if (pos < -1) 447 o->cache_bottom = -2 - pos; 448 else if (pos < 0) 449 o->cache_bottom = o->src_index->cache_nr; 450 return ret; 451} 452 453static int traverse_trees_recursive(int n, unsigned long dirmask, 454 unsigned long df_conflicts, 455 struct name_entry *names, 456 struct traverse_info *info) 457{ 458 int i, ret, bottom; 459 struct tree_desc t[MAX_UNPACK_TREES]; 460 void *buf[MAX_UNPACK_TREES]; 461 struct traverse_info newinfo; 462 struct name_entry *p; 463 464 p = names; 465 while (!p->mode) 466 p++; 467 468 newinfo = *info; 469 newinfo.prev = info; 470 newinfo.pathspec = info->pathspec; 471 newinfo.name = *p; 472 newinfo.pathlen += tree_entry_len(p) + 1; 473 newinfo.df_conflicts |= df_conflicts; 474 475 for (i = 0; i < n; i++, dirmask >>= 1) { 476 const unsigned char *sha1 = NULL; 477 if (dirmask & 1) 478 sha1 = names[i].sha1; 479 buf[i] = fill_tree_descriptor(t+i, sha1); 480 } 481 482 bottom = switch_cache_bottom(&newinfo); 483 ret = traverse_trees(n, t, &newinfo); 484 restore_cache_bottom(&newinfo, bottom); 485 486 for (i = 0; i < n; i++) 487 free(buf[i]); 488 489 return ret; 490} 491 492/* 493 * Compare the traverse-path to the cache entry without actually 494 * having to generate the textual representation of the traverse 495 * path. 496 * 497 * NOTE! This *only* compares up to the size of the traverse path 498 * itself - the caller needs to do the final check for the cache 499 * entry having more data at the end! 500 */ 501static int do_compare_entry_piecewise(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) 502{ 503 int len, pathlen, ce_len; 504 const char *ce_name; 505 506 if (info->prev) { 507 int cmp = do_compare_entry_piecewise(ce, info->prev, 508 &info->name); 509 if (cmp) 510 return cmp; 511 } 512 pathlen = info->pathlen; 513 ce_len = ce_namelen(ce); 514 515 /* If ce_len < pathlen then we must have previously hit "name == directory" entry */ 516 if (ce_len < pathlen) 517 return -1; 518 519 ce_len -= pathlen; 520 ce_name = ce->name + pathlen; 521 522 len = tree_entry_len(n); 523 return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); 524} 525 526static int do_compare_entry(const struct cache_entry *ce, 527 const struct traverse_info *info, 528 const struct name_entry *n) 529{ 530 int len, pathlen, ce_len; 531 const char *ce_name; 532 int cmp; 533 534 /* 535 * If we have not precomputed the traverse path, it is quicker 536 * to avoid doing so. But if we have precomputed it, 537 * it is quicker to use the precomputed version. 538 */ 539 if (!info->traverse_path) 540 return do_compare_entry_piecewise(ce, info, n); 541 542 cmp = strncmp(ce->name, info->traverse_path, info->pathlen); 543 if (cmp) 544 return cmp; 545 546 pathlen = info->pathlen; 547 ce_len = ce_namelen(ce); 548 549 if (ce_len < pathlen) 550 return -1; 551 552 ce_len -= pathlen; 553 ce_name = ce->name + pathlen; 554 555 len = tree_entry_len(n); 556 return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); 557} 558 559static int compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) 560{ 561 int cmp = do_compare_entry(ce, info, n); 562 if (cmp) 563 return cmp; 564 565 /* 566 * Even if the beginning compared identically, the ce should 567 * compare as bigger than a directory leading up to it! 568 */ 569 return ce_namelen(ce) > traverse_path_len(info, n); 570} 571 572static int ce_in_traverse_path(const struct cache_entry *ce, 573 const struct traverse_info *info) 574{ 575 if (!info->prev) 576 return 1; 577 if (do_compare_entry(ce, info->prev, &info->name)) 578 return 0; 579 /* 580 * If ce (blob) is the same name as the path (which is a tree 581 * we will be descending into), it won't be inside it. 582 */ 583 return (info->pathlen < ce_namelen(ce)); 584} 585 586static struct cache_entry *create_ce_entry(const struct traverse_info *info, const struct name_entry *n, int stage) 587{ 588 int len = traverse_path_len(info, n); 589 struct cache_entry *ce = xcalloc(1, cache_entry_size(len)); 590 591 ce->ce_mode = create_ce_mode(n->mode); 592 ce->ce_flags = create_ce_flags(stage); 593 ce->ce_namelen = len; 594 hashcpy(ce->sha1, n->sha1); 595 make_traverse_path(ce->name, info, n); 596 597 return ce; 598} 599 600static int unpack_nondirectories(int n, unsigned long mask, 601 unsigned long dirmask, 602 struct cache_entry **src, 603 const struct name_entry *names, 604 const struct traverse_info *info) 605{ 606 int i; 607 struct unpack_trees_options *o = info->data; 608 unsigned long conflicts = info->df_conflicts | dirmask; 609 610 /* Do we have *only* directories? Nothing to do */ 611 if (mask == dirmask && !src[0]) 612 return 0; 613 614 /* 615 * Ok, we've filled in up to any potential index entry in src[0], 616 * now do the rest. 617 */ 618 for (i = 0; i < n; i++) { 619 int stage; 620 unsigned int bit = 1ul << i; 621 if (conflicts & bit) { 622 src[i + o->merge] = o->df_conflict_entry; 623 continue; 624 } 625 if (!(mask & bit)) 626 continue; 627 if (!o->merge) 628 stage = 0; 629 else if (i + 1 < o->head_idx) 630 stage = 1; 631 else if (i + 1 > o->head_idx) 632 stage = 3; 633 else 634 stage = 2; 635 src[i + o->merge] = create_ce_entry(info, names + i, stage); 636 } 637 638 if (o->merge) { 639 int rc = call_unpack_fn((const struct cache_entry * const *)src, 640 o); 641 for (i = 0; i < n; i++) { 642 struct cache_entry *ce = src[i + o->merge]; 643 if (ce != o->df_conflict_entry) 644 free(ce); 645 } 646 return rc; 647 } 648 649 for (i = 0; i < n; i++) 650 if (src[i] && src[i] != o->df_conflict_entry) 651 if (do_add_entry(o, src[i], 0, 0)) 652 return -1; 653 654 return 0; 655} 656 657static int unpack_failed(struct unpack_trees_options *o, const char *message) 658{ 659 discard_index(&o->result); 660 if (!o->gently && !o->exiting_early) { 661 if (message) 662 return error("%s", message); 663 return -1; 664 } 665 return -1; 666} 667 668/* 669 * The tree traversal is looking at name p. If we have a matching entry, 670 * return it. If name p is a directory in the index, do not return 671 * anything, as we will want to match it when the traversal descends into 672 * the directory. 673 */ 674static int find_cache_pos(struct traverse_info *info, 675 const struct name_entry *p) 676{ 677 int pos; 678 struct unpack_trees_options *o = info->data; 679 struct index_state *index = o->src_index; 680 int pfxlen = info->pathlen; 681 int p_len = tree_entry_len(p); 682 683 for (pos = o->cache_bottom; pos < index->cache_nr; pos++) { 684 const struct cache_entry *ce = index->cache[pos]; 685 const char *ce_name, *ce_slash; 686 int cmp, ce_len; 687 688 if (ce->ce_flags & CE_UNPACKED) { 689 /* 690 * cache_bottom entry is already unpacked, so 691 * we can never match it; don't check it 692 * again. 693 */ 694 if (pos == o->cache_bottom) 695 ++o->cache_bottom; 696 continue; 697 } 698 if (!ce_in_traverse_path(ce, info)) { 699 /* 700 * Check if we can skip future cache checks 701 * (because we're already past all possible 702 * entries in the traverse path). 703 */ 704 if (info->traverse_path) { 705 if (strncmp(ce->name, info->traverse_path, 706 info->pathlen) > 0) 707 break; 708 } 709 continue; 710 } 711 ce_name = ce->name + pfxlen; 712 ce_slash = strchr(ce_name, '/'); 713 if (ce_slash) 714 ce_len = ce_slash - ce_name; 715 else 716 ce_len = ce_namelen(ce) - pfxlen; 717 cmp = name_compare(p->path, p_len, ce_name, ce_len); 718 /* 719 * Exact match; if we have a directory we need to 720 * delay returning it. 721 */ 722 if (!cmp) 723 return ce_slash ? -2 - pos : pos; 724 if (0 < cmp) 725 continue; /* keep looking */ 726 /* 727 * ce_name sorts after p->path; could it be that we 728 * have files under p->path directory in the index? 729 * E.g. ce_name == "t-i", and p->path == "t"; we may 730 * have "t/a" in the index. 731 */ 732 if (p_len < ce_len && !memcmp(ce_name, p->path, p_len) && 733 ce_name[p_len] < '/') 734 continue; /* keep looking */ 735 break; 736 } 737 return -1; 738} 739 740static struct cache_entry *find_cache_entry(struct traverse_info *info, 741 const struct name_entry *p) 742{ 743 int pos = find_cache_pos(info, p); 744 struct unpack_trees_options *o = info->data; 745 746 if (0 <= pos) 747 return o->src_index->cache[pos]; 748 else 749 return NULL; 750} 751 752static void debug_path(struct traverse_info *info) 753{ 754 if (info->prev) { 755 debug_path(info->prev); 756 if (*info->prev->name.path) 757 putchar('/'); 758 } 759 printf("%s", info->name.path); 760} 761 762static void debug_name_entry(int i, struct name_entry *n) 763{ 764 printf("ent#%d %06o %s\n", i, 765 n->path ? n->mode : 0, 766 n->path ? n->path : "(missing)"); 767} 768 769static void debug_unpack_callback(int n, 770 unsigned long mask, 771 unsigned long dirmask, 772 struct name_entry *names, 773 struct traverse_info *info) 774{ 775 int i; 776 printf("* unpack mask %lu, dirmask %lu, cnt %d ", 777 mask, dirmask, n); 778 debug_path(info); 779 putchar('\n'); 780 for (i = 0; i < n; i++) 781 debug_name_entry(i, names + i); 782} 783 784static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info) 785{ 786 struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, }; 787 struct unpack_trees_options *o = info->data; 788 const struct name_entry *p = names; 789 790 /* Find first entry with a real name (we could use "mask" too) */ 791 while (!p->mode) 792 p++; 793 794 if (o->debug_unpack) 795 debug_unpack_callback(n, mask, dirmask, names, info); 796 797 /* Are we supposed to look at the index too? */ 798 if (o->merge) { 799 while (1) { 800 int cmp; 801 struct cache_entry *ce; 802 803 if (o->diff_index_cached) 804 ce = next_cache_entry(o); 805 else 806 ce = find_cache_entry(info, p); 807 808 if (!ce) 809 break; 810 cmp = compare_entry(ce, info, p); 811 if (cmp < 0) { 812 if (unpack_index_entry(ce, o) < 0) 813 return unpack_failed(o, NULL); 814 continue; 815 } 816 if (!cmp) { 817 if (ce_stage(ce)) { 818 /* 819 * If we skip unmerged index 820 * entries, we'll skip this 821 * entry *and* the tree 822 * entries associated with it! 823 */ 824 if (o->skip_unmerged) { 825 add_same_unmerged(ce, o); 826 return mask; 827 } 828 } 829 src[0] = ce; 830 } 831 break; 832 } 833 } 834 835 if (unpack_nondirectories(n, mask, dirmask, src, names, info) < 0) 836 return -1; 837 838 if (o->merge && src[0]) { 839 if (ce_stage(src[0])) 840 mark_ce_used_same_name(src[0], o); 841 else 842 mark_ce_used(src[0], o); 843 } 844 845 /* Now handle any directories.. */ 846 if (dirmask) { 847 /* special case: "diff-index --cached" looking at a tree */ 848 if (o->diff_index_cached && 849 n == 1 && dirmask == 1 && S_ISDIR(names->mode)) { 850 int matches; 851 matches = cache_tree_matches_traversal(o->src_index->cache_tree, 852 names, info); 853 /* 854 * Everything under the name matches; skip the 855 * entire hierarchy. diff_index_cached codepath 856 * special cases D/F conflicts in such a way that 857 * it does not do any look-ahead, so this is safe. 858 */ 859 if (matches) { 860 o->cache_bottom += matches; 861 return mask; 862 } 863 } 864 865 if (traverse_trees_recursive(n, dirmask, mask & ~dirmask, 866 names, info) < 0) 867 return -1; 868 return mask; 869 } 870 871 return mask; 872} 873 874static int clear_ce_flags_1(struct cache_entry **cache, int nr, 875 struct strbuf *prefix, 876 int select_mask, int clear_mask, 877 struct exclude_list *el, int defval); 878 879/* Whole directory matching */ 880static int clear_ce_flags_dir(struct cache_entry **cache, int nr, 881 struct strbuf *prefix, 882 char *basename, 883 int select_mask, int clear_mask, 884 struct exclude_list *el, int defval) 885{ 886 struct cache_entry **cache_end; 887 int dtype = DT_DIR; 888 int ret = is_excluded_from_list(prefix->buf, prefix->len, 889 basename, &dtype, el); 890 int rc; 891 892 strbuf_addch(prefix, '/'); 893 894 /* If undecided, use matching result of parent dir in defval */ 895 if (ret < 0) 896 ret = defval; 897 898 for (cache_end = cache; cache_end != cache + nr; cache_end++) { 899 struct cache_entry *ce = *cache_end; 900 if (strncmp(ce->name, prefix->buf, prefix->len)) 901 break; 902 } 903 904 /* 905 * TODO: check el, if there are no patterns that may conflict 906 * with ret (iow, we know in advance the incl/excl 907 * decision for the entire directory), clear flag here without 908 * calling clear_ce_flags_1(). That function will call 909 * the expensive is_excluded_from_list() on every entry. 910 */ 911 rc = clear_ce_flags_1(cache, cache_end - cache, 912 prefix, 913 select_mask, clear_mask, 914 el, ret); 915 strbuf_setlen(prefix, prefix->len - 1); 916 return rc; 917} 918 919/* 920 * Traverse the index, find every entry that matches according to 921 * o->el. Do "ce_flags &= ~clear_mask" on those entries. Return the 922 * number of traversed entries. 923 * 924 * If select_mask is non-zero, only entries whose ce_flags has on of 925 * those bits enabled are traversed. 926 * 927 * cache : pointer to an index entry 928 * prefix_len : an offset to its path 929 * 930 * The current path ("prefix") including the trailing '/' is 931 * cache[0]->name[0..(prefix_len-1)] 932 * Top level path has prefix_len zero. 933 */ 934static int clear_ce_flags_1(struct cache_entry **cache, int nr, 935 struct strbuf *prefix, 936 int select_mask, int clear_mask, 937 struct exclude_list *el, int defval) 938{ 939 struct cache_entry **cache_end = cache + nr; 940 941 /* 942 * Process all entries that have the given prefix and meet 943 * select_mask condition 944 */ 945 while(cache != cache_end) { 946 struct cache_entry *ce = *cache; 947 const char *name, *slash; 948 int len, dtype, ret; 949 950 if (select_mask && !(ce->ce_flags & select_mask)) { 951 cache++; 952 continue; 953 } 954 955 if (prefix->len && strncmp(ce->name, prefix->buf, prefix->len)) 956 break; 957 958 name = ce->name + prefix->len; 959 slash = strchr(name, '/'); 960 961 /* If it's a directory, try whole directory match first */ 962 if (slash) { 963 int processed; 964 965 len = slash - name; 966 strbuf_add(prefix, name, len); 967 968 processed = clear_ce_flags_dir(cache, cache_end - cache, 969 prefix, 970 prefix->buf + prefix->len - len, 971 select_mask, clear_mask, 972 el, defval); 973 974 /* clear_c_f_dir eats a whole dir already? */ 975 if (processed) { 976 cache += processed; 977 strbuf_setlen(prefix, prefix->len - len); 978 continue; 979 } 980 981 strbuf_addch(prefix, '/'); 982 cache += clear_ce_flags_1(cache, cache_end - cache, 983 prefix, 984 select_mask, clear_mask, el, defval); 985 strbuf_setlen(prefix, prefix->len - len - 1); 986 continue; 987 } 988 989 /* Non-directory */ 990 dtype = ce_to_dtype(ce); 991 ret = is_excluded_from_list(ce->name, ce_namelen(ce), 992 name, &dtype, el); 993 if (ret < 0) 994 ret = defval; 995 if (ret > 0) 996 ce->ce_flags &= ~clear_mask; 997 cache++; 998 } 999 return nr - (cache_end - cache);1000}10011002static int clear_ce_flags(struct cache_entry **cache, int nr,1003 int select_mask, int clear_mask,1004 struct exclude_list *el)1005{1006 static struct strbuf prefix = STRBUF_INIT;10071008 strbuf_reset(&prefix);10091010 return clear_ce_flags_1(cache, nr,1011 &prefix,1012 select_mask, clear_mask,1013 el, 0);1014}10151016/*1017 * Set/Clear CE_NEW_SKIP_WORKTREE according to $GIT_DIR/info/sparse-checkout1018 */1019static void mark_new_skip_worktree(struct exclude_list *el,1020 struct index_state *the_index,1021 int select_flag, int skip_wt_flag)1022{1023 int i;10241025 /*1026 * 1. Pretend the narrowest worktree: only unmerged entries1027 * are checked out1028 */1029 for (i = 0; i < the_index->cache_nr; i++) {1030 struct cache_entry *ce = the_index->cache[i];10311032 if (select_flag && !(ce->ce_flags & select_flag))1033 continue;10341035 if (!ce_stage(ce))1036 ce->ce_flags |= skip_wt_flag;1037 else1038 ce->ce_flags &= ~skip_wt_flag;1039 }10401041 /*1042 * 2. Widen worktree according to sparse-checkout file.1043 * Matched entries will have skip_wt_flag cleared (i.e. "in")1044 */1045 clear_ce_flags(the_index->cache, the_index->cache_nr,1046 select_flag, skip_wt_flag, el);1047}10481049static int verify_absent(const struct cache_entry *,1050 enum unpack_trees_error_types,1051 struct unpack_trees_options *);1052/*1053 * N-way merge "len" trees. Returns 0 on success, -1 on failure to manipulate the1054 * resulting index, -2 on failure to reflect the changes to the work tree.1055 *1056 * CE_ADDED, CE_UNPACKED and CE_NEW_SKIP_WORKTREE are used internally1057 */1058int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)1059{1060 int i, ret;1061 static struct cache_entry *dfc;1062 struct exclude_list el;10631064 if (len > MAX_UNPACK_TREES)1065 die("unpack_trees takes at most %d trees", MAX_UNPACK_TREES);1066 memset(&state, 0, sizeof(state));1067 state.base_dir = "";1068 state.force = 1;1069 state.quiet = 1;1070 state.refresh_cache = 1;1071 state.istate = &o->result;10721073 memset(&el, 0, sizeof(el));1074 if (!core_apply_sparse_checkout || !o->update)1075 o->skip_sparse_checkout = 1;1076 if (!o->skip_sparse_checkout) {1077 char *sparse = git_pathdup("info/sparse-checkout");1078 if (add_excludes_from_file_to_list(sparse, "", 0, &el, 0) < 0)1079 o->skip_sparse_checkout = 1;1080 else1081 o->el = ⪙1082 free(sparse);1083 }10841085 memset(&o->result, 0, sizeof(o->result));1086 o->result.initialized = 1;1087 o->result.timestamp.sec = o->src_index->timestamp.sec;1088 o->result.timestamp.nsec = o->src_index->timestamp.nsec;1089 o->result.version = o->src_index->version;1090 o->result.split_index = o->src_index->split_index;1091 if (o->result.split_index)1092 o->result.split_index->refcount++;1093 hashcpy(o->result.sha1, o->src_index->sha1);1094 o->merge_size = len;1095 mark_all_ce_unused(o->src_index);10961097 /*1098 * Sparse checkout loop #1: set NEW_SKIP_WORKTREE on existing entries1099 */1100 if (!o->skip_sparse_checkout)1101 mark_new_skip_worktree(o->el, o->src_index, 0, CE_NEW_SKIP_WORKTREE);11021103 if (!dfc)1104 dfc = xcalloc(1, cache_entry_size(0));1105 o->df_conflict_entry = dfc;11061107 if (len) {1108 const char *prefix = o->prefix ? o->prefix : "";1109 struct traverse_info info;11101111 setup_traverse_info(&info, prefix);1112 info.fn = unpack_callback;1113 info.data = o;1114 info.show_all_errors = o->show_all_errors;1115 info.pathspec = o->pathspec;11161117 if (o->prefix) {1118 /*1119 * Unpack existing index entries that sort before the1120 * prefix the tree is spliced into. Note that o->merge1121 * is always true in this case.1122 */1123 while (1) {1124 struct cache_entry *ce = next_cache_entry(o);1125 if (!ce)1126 break;1127 if (ce_in_traverse_path(ce, &info))1128 break;1129 if (unpack_index_entry(ce, o) < 0)1130 goto return_failed;1131 }1132 }11331134 if (traverse_trees(len, t, &info) < 0)1135 goto return_failed;1136 }11371138 /* Any left-over entries in the index? */1139 if (o->merge) {1140 while (1) {1141 struct cache_entry *ce = next_cache_entry(o);1142 if (!ce)1143 break;1144 if (unpack_index_entry(ce, o) < 0)1145 goto return_failed;1146 }1147 }1148 mark_all_ce_unused(o->src_index);11491150 if (o->trivial_merges_only && o->nontrivial_merge) {1151 ret = unpack_failed(o, "Merge requires file-level merging");1152 goto done;1153 }11541155 if (!o->skip_sparse_checkout) {1156 int empty_worktree = 1;11571158 /*1159 * Sparse checkout loop #2: set NEW_SKIP_WORKTREE on entries not in loop #11160 * If the will have NEW_SKIP_WORKTREE, also set CE_SKIP_WORKTREE1161 * so apply_sparse_checkout() won't attempt to remove it from worktree1162 */1163 mark_new_skip_worktree(o->el, &o->result, CE_ADDED, CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);11641165 ret = 0;1166 for (i = 0; i < o->result.cache_nr; i++) {1167 struct cache_entry *ce = o->result.cache[i];11681169 /*1170 * Entries marked with CE_ADDED in merged_entry() do not have1171 * verify_absent() check (the check is effectively disabled1172 * because CE_NEW_SKIP_WORKTREE is set unconditionally).1173 *1174 * Do the real check now because we have had1175 * correct CE_NEW_SKIP_WORKTREE1176 */1177 if (ce->ce_flags & CE_ADDED &&1178 verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) {1179 if (!o->show_all_errors)1180 goto return_failed;1181 ret = -1;1182 }11831184 if (apply_sparse_checkout(&o->result, ce, o)) {1185 if (!o->show_all_errors)1186 goto return_failed;1187 ret = -1;1188 }1189 if (!ce_skip_worktree(ce))1190 empty_worktree = 0;11911192 }1193 if (ret < 0)1194 goto return_failed;1195 /*1196 * Sparse checkout is meant to narrow down checkout area1197 * but it does not make sense to narrow down to empty working1198 * tree. This is usually a mistake in sparse checkout rules.1199 * Do not allow users to do that.1200 */1201 if (o->result.cache_nr && empty_worktree) {1202 ret = unpack_failed(o, "Sparse checkout leaves no entry on working directory");1203 goto done;1204 }1205 }12061207 o->src_index = NULL;1208 ret = check_updates(o) ? (-2) : 0;1209 if (o->dst_index) {1210 if (!ret) {1211 if (!o->result.cache_tree)1212 o->result.cache_tree = cache_tree();1213 if (!cache_tree_fully_valid(o->result.cache_tree))1214 cache_tree_update(&o->result,1215 WRITE_TREE_SILENT |1216 WRITE_TREE_REPAIR);1217 }1218 discard_index(o->dst_index);1219 *o->dst_index = o->result;1220 } else {1221 discard_index(&o->result);1222 }12231224done:1225 clear_exclude_list(&el);1226 return ret;12271228return_failed:1229 if (o->show_all_errors)1230 display_error_msgs(o);1231 mark_all_ce_unused(o->src_index);1232 ret = unpack_failed(o, NULL);1233 if (o->exiting_early)1234 ret = 0;1235 goto done;1236}12371238/* Here come the merge functions */12391240static int reject_merge(const struct cache_entry *ce,1241 struct unpack_trees_options *o)1242{1243 return o->gently ? -1 :1244 add_rejected_path(o, ERROR_WOULD_OVERWRITE, ce->name);1245}12461247static int same(const struct cache_entry *a, const struct cache_entry *b)1248{1249 if (!!a != !!b)1250 return 0;1251 if (!a && !b)1252 return 1;1253 if ((a->ce_flags | b->ce_flags) & CE_CONFLICTED)1254 return 0;1255 return a->ce_mode == b->ce_mode &&1256 !hashcmp(a->sha1, b->sha1);1257}125812591260/*1261 * When a CE gets turned into an unmerged entry, we1262 * want it to be up-to-date1263 */1264static int verify_uptodate_1(const struct cache_entry *ce,1265 struct unpack_trees_options *o,1266 enum unpack_trees_error_types error_type)1267{1268 struct stat st;12691270 if (o->index_only)1271 return 0;12721273 /*1274 * CE_VALID and CE_SKIP_WORKTREE cheat, we better check again1275 * if this entry is truly up-to-date because this file may be1276 * overwritten.1277 */1278 if ((ce->ce_flags & CE_VALID) || ce_skip_worktree(ce))1279 ; /* keep checking */1280 else if (o->reset || ce_uptodate(ce))1281 return 0;12821283 if (!lstat(ce->name, &st)) {1284 int flags = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE;1285 unsigned changed = ie_match_stat(o->src_index, ce, &st, flags);1286 if (!changed)1287 return 0;1288 /*1289 * NEEDSWORK: the current default policy is to allow1290 * submodule to be out of sync wrt the superproject1291 * index. This needs to be tightened later for1292 * submodules that are marked to be automatically1293 * checked out.1294 */1295 if (S_ISGITLINK(ce->ce_mode))1296 return 0;1297 errno = 0;1298 }1299 if (errno == ENOENT)1300 return 0;1301 return o->gently ? -1 :1302 add_rejected_path(o, error_type, ce->name);1303}13041305static int verify_uptodate(const struct cache_entry *ce,1306 struct unpack_trees_options *o)1307{1308 if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1309 return 0;1310 return verify_uptodate_1(ce, o, ERROR_NOT_UPTODATE_FILE);1311}13121313static int verify_uptodate_sparse(const struct cache_entry *ce,1314 struct unpack_trees_options *o)1315{1316 return verify_uptodate_1(ce, o, ERROR_SPARSE_NOT_UPTODATE_FILE);1317}13181319static void invalidate_ce_path(const struct cache_entry *ce,1320 struct unpack_trees_options *o)1321{1322 if (!ce)1323 return;1324 cache_tree_invalidate_path(o->src_index, ce->name);1325 untracked_cache_invalidate_path(o->src_index, ce->name);1326}13271328/*1329 * Check that checking out ce->sha1 in subdir ce->name is not1330 * going to overwrite any working files.1331 *1332 * Currently, git does not checkout subprojects during a superproject1333 * checkout, so it is not going to overwrite anything.1334 */1335static int verify_clean_submodule(const struct cache_entry *ce,1336 enum unpack_trees_error_types error_type,1337 struct unpack_trees_options *o)1338{1339 return 0;1340}13411342static int verify_clean_subdirectory(const struct cache_entry *ce,1343 enum unpack_trees_error_types error_type,1344 struct unpack_trees_options *o)1345{1346 /*1347 * we are about to extract "ce->name"; we would not want to lose1348 * anything in the existing directory there.1349 */1350 int namelen;1351 int i;1352 struct dir_struct d;1353 char *pathbuf;1354 int cnt = 0;1355 unsigned char sha1[20];13561357 if (S_ISGITLINK(ce->ce_mode) &&1358 resolve_gitlink_ref(ce->name, "HEAD", sha1) == 0) {1359 /* If we are not going to update the submodule, then1360 * we don't care.1361 */1362 if (!hashcmp(sha1, ce->sha1))1363 return 0;1364 return verify_clean_submodule(ce, error_type, o);1365 }13661367 /*1368 * First let's make sure we do not have a local modification1369 * in that directory.1370 */1371 namelen = ce_namelen(ce);1372 for (i = locate_in_src_index(ce, o);1373 i < o->src_index->cache_nr;1374 i++) {1375 struct cache_entry *ce2 = o->src_index->cache[i];1376 int len = ce_namelen(ce2);1377 if (len < namelen ||1378 strncmp(ce->name, ce2->name, namelen) ||1379 ce2->name[namelen] != '/')1380 break;1381 /*1382 * ce2->name is an entry in the subdirectory to be1383 * removed.1384 */1385 if (!ce_stage(ce2)) {1386 if (verify_uptodate(ce2, o))1387 return -1;1388 add_entry(o, ce2, CE_REMOVE, 0);1389 mark_ce_used(ce2, o);1390 }1391 cnt++;1392 }13931394 /*1395 * Then we need to make sure that we do not lose a locally1396 * present file that is not ignored.1397 */1398 pathbuf = xstrfmt("%.*s/", namelen, ce->name);13991400 memset(&d, 0, sizeof(d));1401 if (o->dir)1402 d.exclude_per_dir = o->dir->exclude_per_dir;1403 i = read_directory(&d, pathbuf, namelen+1, NULL);1404 if (i)1405 return o->gently ? -1 :1406 add_rejected_path(o, ERROR_NOT_UPTODATE_DIR, ce->name);1407 free(pathbuf);1408 return cnt;1409}14101411/*1412 * This gets called when there was no index entry for the tree entry 'dst',1413 * but we found a file in the working tree that 'lstat()' said was fine,1414 * and we're on a case-insensitive filesystem.1415 *1416 * See if we can find a case-insensitive match in the index that also1417 * matches the stat information, and assume it's that other file!1418 */1419static int icase_exists(struct unpack_trees_options *o, const char *name, int len, struct stat *st)1420{1421 const struct cache_entry *src;14221423 src = index_file_exists(o->src_index, name, len, 1);1424 return src && !ie_match_stat(o->src_index, src, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);1425}14261427static int check_ok_to_remove(const char *name, int len, int dtype,1428 const struct cache_entry *ce, struct stat *st,1429 enum unpack_trees_error_types error_type,1430 struct unpack_trees_options *o)1431{1432 const struct cache_entry *result;14331434 /*1435 * It may be that the 'lstat()' succeeded even though1436 * target 'ce' was absent, because there is an old1437 * entry that is different only in case..1438 *1439 * Ignore that lstat() if it matches.1440 */1441 if (ignore_case && icase_exists(o, name, len, st))1442 return 0;14431444 if (o->dir &&1445 is_excluded(o->dir, name, &dtype))1446 /*1447 * ce->name is explicitly excluded, so it is Ok to1448 * overwrite it.1449 */1450 return 0;1451 if (S_ISDIR(st->st_mode)) {1452 /*1453 * We are checking out path "foo" and1454 * found "foo/." in the working tree.1455 * This is tricky -- if we have modified1456 * files that are in "foo/" we would lose1457 * them.1458 */1459 if (verify_clean_subdirectory(ce, error_type, o) < 0)1460 return -1;1461 return 0;1462 }14631464 /*1465 * The previous round may already have decided to1466 * delete this path, which is in a subdirectory that1467 * is being replaced with a blob.1468 */1469 result = index_file_exists(&o->result, name, len, 0);1470 if (result) {1471 if (result->ce_flags & CE_REMOVE)1472 return 0;1473 }14741475 return o->gently ? -1 :1476 add_rejected_path(o, error_type, name);1477}14781479/*1480 * We do not want to remove or overwrite a working tree file that1481 * is not tracked, unless it is ignored.1482 */1483static int verify_absent_1(const struct cache_entry *ce,1484 enum unpack_trees_error_types error_type,1485 struct unpack_trees_options *o)1486{1487 int len;1488 struct stat st;14891490 if (o->index_only || o->reset || !o->update)1491 return 0;14921493 len = check_leading_path(ce->name, ce_namelen(ce));1494 if (!len)1495 return 0;1496 else if (len > 0) {1497 char *path;1498 int ret;14991500 path = xmemdupz(ce->name, len);1501 if (lstat(path, &st))1502 ret = error("cannot stat '%s': %s", path,1503 strerror(errno));1504 else1505 ret = check_ok_to_remove(path, len, DT_UNKNOWN, NULL,1506 &st, error_type, o);1507 free(path);1508 return ret;1509 } else if (lstat(ce->name, &st)) {1510 if (errno != ENOENT)1511 return error("cannot stat '%s': %s", ce->name,1512 strerror(errno));1513 return 0;1514 } else {1515 return check_ok_to_remove(ce->name, ce_namelen(ce),1516 ce_to_dtype(ce), ce, &st,1517 error_type, o);1518 }1519}15201521static int verify_absent(const struct cache_entry *ce,1522 enum unpack_trees_error_types error_type,1523 struct unpack_trees_options *o)1524{1525 if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1526 return 0;1527 return verify_absent_1(ce, error_type, o);1528}15291530static int verify_absent_sparse(const struct cache_entry *ce,1531 enum unpack_trees_error_types error_type,1532 struct unpack_trees_options *o)1533{1534 enum unpack_trees_error_types orphaned_error = error_type;1535 if (orphaned_error == ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN)1536 orphaned_error = ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN;15371538 return verify_absent_1(ce, orphaned_error, o);1539}15401541static int merged_entry(const struct cache_entry *ce,1542 const struct cache_entry *old,1543 struct unpack_trees_options *o)1544{1545 int update = CE_UPDATE;1546 struct cache_entry *merge = dup_entry(ce);15471548 if (!old) {1549 /*1550 * New index entries. In sparse checkout, the following1551 * verify_absent() will be delayed until after1552 * traverse_trees() finishes in unpack_trees(), then:1553 *1554 * - CE_NEW_SKIP_WORKTREE will be computed correctly1555 * - verify_absent() be called again, this time with1556 * correct CE_NEW_SKIP_WORKTREE1557 *1558 * verify_absent() call here does nothing in sparse1559 * checkout (i.e. o->skip_sparse_checkout == 0)1560 */1561 update |= CE_ADDED;1562 merge->ce_flags |= CE_NEW_SKIP_WORKTREE;15631564 if (verify_absent(merge,1565 ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) {1566 free(merge);1567 return -1;1568 }1569 invalidate_ce_path(merge, o);1570 } else if (!(old->ce_flags & CE_CONFLICTED)) {1571 /*1572 * See if we can re-use the old CE directly?1573 * That way we get the uptodate stat info.1574 *1575 * This also removes the UPDATE flag on a match; otherwise1576 * we will end up overwriting local changes in the work tree.1577 */1578 if (same(old, merge)) {1579 copy_cache_entry(merge, old);1580 update = 0;1581 } else {1582 if (verify_uptodate(old, o)) {1583 free(merge);1584 return -1;1585 }1586 /* Migrate old flags over */1587 update |= old->ce_flags & (CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);1588 invalidate_ce_path(old, o);1589 }1590 } else {1591 /*1592 * Previously unmerged entry left as an existence1593 * marker by read_index_unmerged();1594 */1595 invalidate_ce_path(old, o);1596 }15971598 do_add_entry(o, merge, update, CE_STAGEMASK);1599 return 1;1600}16011602static int deleted_entry(const struct cache_entry *ce,1603 const struct cache_entry *old,1604 struct unpack_trees_options *o)1605{1606 /* Did it exist in the index? */1607 if (!old) {1608 if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))1609 return -1;1610 return 0;1611 }1612 if (!(old->ce_flags & CE_CONFLICTED) && verify_uptodate(old, o))1613 return -1;1614 add_entry(o, ce, CE_REMOVE, 0);1615 invalidate_ce_path(ce, o);1616 return 1;1617}16181619static int keep_entry(const struct cache_entry *ce,1620 struct unpack_trees_options *o)1621{1622 add_entry(o, ce, 0, 0);1623 return 1;1624}16251626#if DBRT_DEBUG1627static void show_stage_entry(FILE *o,1628 const char *label, const struct cache_entry *ce)1629{1630 if (!ce)1631 fprintf(o, "%s (missing)\n", label);1632 else1633 fprintf(o, "%s%06o %s %d\t%s\n",1634 label,1635 ce->ce_mode,1636 sha1_to_hex(ce->sha1),1637 ce_stage(ce),1638 ce->name);1639}1640#endif16411642int threeway_merge(const struct cache_entry * const *stages,1643 struct unpack_trees_options *o)1644{1645 const struct cache_entry *index;1646 const struct cache_entry *head;1647 const struct cache_entry *remote = stages[o->head_idx + 1];1648 int count;1649 int head_match = 0;1650 int remote_match = 0;16511652 int df_conflict_head = 0;1653 int df_conflict_remote = 0;16541655 int any_anc_missing = 0;1656 int no_anc_exists = 1;1657 int i;16581659 for (i = 1; i < o->head_idx; i++) {1660 if (!stages[i] || stages[i] == o->df_conflict_entry)1661 any_anc_missing = 1;1662 else1663 no_anc_exists = 0;1664 }16651666 index = stages[0];1667 head = stages[o->head_idx];16681669 if (head == o->df_conflict_entry) {1670 df_conflict_head = 1;1671 head = NULL;1672 }16731674 if (remote == o->df_conflict_entry) {1675 df_conflict_remote = 1;1676 remote = NULL;1677 }16781679 /*1680 * First, if there's a #16 situation, note that to prevent #131681 * and #14.1682 */1683 if (!same(remote, head)) {1684 for (i = 1; i < o->head_idx; i++) {1685 if (same(stages[i], head)) {1686 head_match = i;1687 }1688 if (same(stages[i], remote)) {1689 remote_match = i;1690 }1691 }1692 }16931694 /*1695 * We start with cases where the index is allowed to match1696 * something other than the head: #14(ALT) and #2ALT, where it1697 * is permitted to match the result instead.1698 */1699 /* #14, #14ALT, #2ALT */1700 if (remote && !df_conflict_head && head_match && !remote_match) {1701 if (index && !same(index, remote) && !same(index, head))1702 return reject_merge(index, o);1703 return merged_entry(remote, index, o);1704 }1705 /*1706 * If we have an entry in the index cache, then we want to1707 * make sure that it matches head.1708 */1709 if (index && !same(index, head))1710 return reject_merge(index, o);17111712 if (head) {1713 /* #5ALT, #15 */1714 if (same(head, remote))1715 return merged_entry(head, index, o);1716 /* #13, #3ALT */1717 if (!df_conflict_remote && remote_match && !head_match)1718 return merged_entry(head, index, o);1719 }17201721 /* #1 */1722 if (!head && !remote && any_anc_missing)1723 return 0;17241725 /*1726 * Under the "aggressive" rule, we resolve mostly trivial1727 * cases that we historically had git-merge-one-file resolve.1728 */1729 if (o->aggressive) {1730 int head_deleted = !head;1731 int remote_deleted = !remote;1732 const struct cache_entry *ce = NULL;17331734 if (index)1735 ce = index;1736 else if (head)1737 ce = head;1738 else if (remote)1739 ce = remote;1740 else {1741 for (i = 1; i < o->head_idx; i++) {1742 if (stages[i] && stages[i] != o->df_conflict_entry) {1743 ce = stages[i];1744 break;1745 }1746 }1747 }17481749 /*1750 * Deleted in both.1751 * Deleted in one and unchanged in the other.1752 */1753 if ((head_deleted && remote_deleted) ||1754 (head_deleted && remote && remote_match) ||1755 (remote_deleted && head && head_match)) {1756 if (index)1757 return deleted_entry(index, index, o);1758 if (ce && !head_deleted) {1759 if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))1760 return -1;1761 }1762 return 0;1763 }1764 /*1765 * Added in both, identically.1766 */1767 if (no_anc_exists && head && remote && same(head, remote))1768 return merged_entry(head, index, o);17691770 }17711772 /* Below are "no merge" cases, which require that the index be1773 * up-to-date to avoid the files getting overwritten with1774 * conflict resolution files.1775 */1776 if (index) {1777 if (verify_uptodate(index, o))1778 return -1;1779 }17801781 o->nontrivial_merge = 1;17821783 /* #2, #3, #4, #6, #7, #9, #10, #11. */1784 count = 0;1785 if (!head_match || !remote_match) {1786 for (i = 1; i < o->head_idx; i++) {1787 if (stages[i] && stages[i] != o->df_conflict_entry) {1788 keep_entry(stages[i], o);1789 count++;1790 break;1791 }1792 }1793 }1794#if DBRT_DEBUG1795 else {1796 fprintf(stderr, "read-tree: warning #16 detected\n");1797 show_stage_entry(stderr, "head ", stages[head_match]);1798 show_stage_entry(stderr, "remote ", stages[remote_match]);1799 }1800#endif1801 if (head) { count += keep_entry(head, o); }1802 if (remote) { count += keep_entry(remote, o); }1803 return count;1804}18051806/*1807 * Two-way merge.1808 *1809 * The rule is to "carry forward" what is in the index without losing1810 * information across a "fast-forward", favoring a successful merge1811 * over a merge failure when it makes sense. For details of the1812 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.1813 *1814 */1815int twoway_merge(const struct cache_entry * const *src,1816 struct unpack_trees_options *o)1817{1818 const struct cache_entry *current = src[0];1819 const struct cache_entry *oldtree = src[1];1820 const struct cache_entry *newtree = src[2];18211822 if (o->merge_size != 2)1823 return error("Cannot do a twoway merge of %d trees",1824 o->merge_size);18251826 if (oldtree == o->df_conflict_entry)1827 oldtree = NULL;1828 if (newtree == o->df_conflict_entry)1829 newtree = NULL;18301831 if (current) {1832 if (current->ce_flags & CE_CONFLICTED) {1833 if (same(oldtree, newtree) || o->reset) {1834 if (!newtree)1835 return deleted_entry(current, current, o);1836 else1837 return merged_entry(newtree, current, o);1838 }1839 return reject_merge(current, o);1840 } else if ((!oldtree && !newtree) || /* 4 and 5 */1841 (!oldtree && newtree &&1842 same(current, newtree)) || /* 6 and 7 */1843 (oldtree && newtree &&1844 same(oldtree, newtree)) || /* 14 and 15 */1845 (oldtree && newtree &&1846 !same(oldtree, newtree) && /* 18 and 19 */1847 same(current, newtree))) {1848 return keep_entry(current, o);1849 } else if (oldtree && !newtree && same(current, oldtree)) {1850 /* 10 or 11 */1851 return deleted_entry(oldtree, current, o);1852 } else if (oldtree && newtree &&1853 same(current, oldtree) && !same(current, newtree)) {1854 /* 20 or 21 */1855 return merged_entry(newtree, current, o);1856 } else1857 return reject_merge(current, o);1858 }1859 else if (newtree) {1860 if (oldtree && !o->initial_checkout) {1861 /*1862 * deletion of the path was staged;1863 */1864 if (same(oldtree, newtree))1865 return 1;1866 return reject_merge(oldtree, o);1867 }1868 return merged_entry(newtree, current, o);1869 }1870 return deleted_entry(oldtree, current, o);1871}18721873/*1874 * Bind merge.1875 *1876 * Keep the index entries at stage0, collapse stage1 but make sure1877 * stage0 does not have anything there.1878 */1879int bind_merge(const struct cache_entry * const *src,1880 struct unpack_trees_options *o)1881{1882 const struct cache_entry *old = src[0];1883 const struct cache_entry *a = src[1];18841885 if (o->merge_size != 1)1886 return error("Cannot do a bind merge of %d trees",1887 o->merge_size);1888 if (a && old)1889 return o->gently ? -1 :1890 error(ERRORMSG(o, ERROR_BIND_OVERLAP), a->name, old->name);1891 if (!a)1892 return keep_entry(old, o);1893 else1894 return merged_entry(a, NULL, o);1895}18961897/*1898 * One-way merge.1899 *1900 * The rule is:1901 * - take the stat information from stage0, take the data from stage11902 */1903int oneway_merge(const struct cache_entry * const *src,1904 struct unpack_trees_options *o)1905{1906 const struct cache_entry *old = src[0];1907 const struct cache_entry *a = src[1];19081909 if (o->merge_size != 1)1910 return error("Cannot do a oneway merge of %d trees",1911 o->merge_size);19121913 if (!a || a == o->df_conflict_entry)1914 return deleted_entry(old, old, o);19151916 if (old && same(old, a)) {1917 int update = 0;1918 if (o->reset && o->update && !ce_uptodate(old) && !ce_skip_worktree(old)) {1919 struct stat st;1920 if (lstat(old->name, &st) ||1921 ie_match_stat(o->src_index, old, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE))1922 update |= CE_UPDATE;1923 }1924 add_entry(o, old, update, 0);1925 return 0;1926 }1927 return merged_entry(a, old, o);1928}