1#define NO_THE_INDEX_COMPATIBILITY_MACROS 2#include "cache.h" 3#include "argv-array.h" 4#include "repository.h" 5#include "config.h" 6#include "dir.h" 7#include "tree.h" 8#include "tree-walk.h" 9#include "cache-tree.h" 10#include "unpack-trees.h" 11#include "progress.h" 12#include "refs.h" 13#include "attr.h" 14#include "split-index.h" 15#include "dir.h" 16#include "submodule.h" 17#include "submodule-config.h" 18#include "fsmonitor.h" 19#include "object-store.h" 20#include "fetch-object.h" 21 22/* 23 * Error messages expected by scripts out of plumbing commands such as 24 * read-tree. Non-scripted Porcelain is not required to use these messages 25 * and in fact are encouraged to reword them to better suit their particular 26 * situation better. See how "git checkout" and "git merge" replaces 27 * them using setup_unpack_trees_porcelain(), for example. 28 */ 29static const char *unpack_plumbing_errors[NB_UNPACK_TREES_ERROR_TYPES] = { 30 /* ERROR_WOULD_OVERWRITE */ 31 "Entry '%s' would be overwritten by merge. Cannot merge.", 32 33 /* ERROR_NOT_UPTODATE_FILE */ 34 "Entry '%s' not uptodate. Cannot merge.", 35 36 /* ERROR_NOT_UPTODATE_DIR */ 37 "Updating '%s' would lose untracked files in it", 38 39 /* ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN */ 40 "Untracked working tree file '%s' would be overwritten by merge.", 41 42 /* ERROR_WOULD_LOSE_UNTRACKED_REMOVED */ 43 "Untracked working tree file '%s' would be removed by merge.", 44 45 /* ERROR_BIND_OVERLAP */ 46 "Entry '%s' overlaps with '%s'. Cannot bind.", 47 48 /* ERROR_SPARSE_NOT_UPTODATE_FILE */ 49 "Entry '%s' not uptodate. Cannot update sparse checkout.", 50 51 /* ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN */ 52 "Working tree file '%s' would be overwritten by sparse checkout update.", 53 54 /* ERROR_WOULD_LOSE_ORPHANED_REMOVED */ 55 "Working tree file '%s' would be removed by sparse checkout update.", 56 57 /* ERROR_WOULD_LOSE_SUBMODULE */ 58 "Submodule '%s' cannot checkout new HEAD.", 59}; 60 61#define ERRORMSG(o,type) \ 62 ( ((o) && (o)->msgs[(type)]) \ 63 ? ((o)->msgs[(type)]) \ 64 : (unpack_plumbing_errors[(type)]) ) 65 66static const char *super_prefixed(const char *path) 67{ 68 /* 69 * It is necessary and sufficient to have two static buffers 70 * here, as the return value of this function is fed to 71 * error() using the unpack_*_errors[] templates we see above. 72 */ 73 static struct strbuf buf[2] = {STRBUF_INIT, STRBUF_INIT}; 74 static int super_prefix_len = -1; 75 static unsigned idx = ARRAY_SIZE(buf) - 1; 76 77 if (super_prefix_len < 0) { 78 const char *super_prefix = get_super_prefix(); 79 if (!super_prefix) { 80 super_prefix_len = 0; 81 } else { 82 int i; 83 for (i = 0; i < ARRAY_SIZE(buf); i++) 84 strbuf_addstr(&buf[i], super_prefix); 85 super_prefix_len = buf[0].len; 86 } 87 } 88 89 if (!super_prefix_len) 90 return path; 91 92 if (++idx >= ARRAY_SIZE(buf)) 93 idx = 0; 94 95 strbuf_setlen(&buf[idx], super_prefix_len); 96 strbuf_addstr(&buf[idx], path); 97 98 return buf[idx].buf; 99} 100 101void setup_unpack_trees_porcelain(struct unpack_trees_options *opts, 102 const char *cmd) 103{ 104 int i; 105 const char **msgs = opts->msgs; 106 const char *msg; 107 108 argv_array_init(&opts->msgs_to_free); 109 110 if (!strcmp(cmd, "checkout")) 111 msg = advice_commit_before_merge 112 ? _("Your local changes to the following files would be overwritten by checkout:\n%%s" 113 "Please commit your changes or stash them before you switch branches.") 114 : _("Your local changes to the following files would be overwritten by checkout:\n%%s"); 115 else if (!strcmp(cmd, "merge")) 116 msg = advice_commit_before_merge 117 ? _("Your local changes to the following files would be overwritten by merge:\n%%s" 118 "Please commit your changes or stash them before you merge.") 119 : _("Your local changes to the following files would be overwritten by merge:\n%%s"); 120 else 121 msg = advice_commit_before_merge 122 ? _("Your local changes to the following files would be overwritten by %s:\n%%s" 123 "Please commit your changes or stash them before you %s.") 124 : _("Your local changes to the following files would be overwritten by %s:\n%%s"); 125 msgs[ERROR_WOULD_OVERWRITE] = msgs[ERROR_NOT_UPTODATE_FILE] = 126 argv_array_pushf(&opts->msgs_to_free, msg, cmd, cmd); 127 128 msgs[ERROR_NOT_UPTODATE_DIR] = 129 _("Updating the following directories would lose untracked files in them:\n%s"); 130 131 if (!strcmp(cmd, "checkout")) 132 msg = advice_commit_before_merge 133 ? _("The following untracked working tree files would be removed by checkout:\n%%s" 134 "Please move or remove them before you switch branches.") 135 : _("The following untracked working tree files would be removed by checkout:\n%%s"); 136 else if (!strcmp(cmd, "merge")) 137 msg = advice_commit_before_merge 138 ? _("The following untracked working tree files would be removed by merge:\n%%s" 139 "Please move or remove them before you merge.") 140 : _("The following untracked working tree files would be removed by merge:\n%%s"); 141 else 142 msg = advice_commit_before_merge 143 ? _("The following untracked working tree files would be removed by %s:\n%%s" 144 "Please move or remove them before you %s.") 145 : _("The following untracked working tree files would be removed by %s:\n%%s"); 146 msgs[ERROR_WOULD_LOSE_UNTRACKED_REMOVED] = 147 argv_array_pushf(&opts->msgs_to_free, msg, cmd, cmd); 148 149 if (!strcmp(cmd, "checkout")) 150 msg = advice_commit_before_merge 151 ? _("The following untracked working tree files would be overwritten by checkout:\n%%s" 152 "Please move or remove them before you switch branches.") 153 : _("The following untracked working tree files would be overwritten by checkout:\n%%s"); 154 else if (!strcmp(cmd, "merge")) 155 msg = advice_commit_before_merge 156 ? _("The following untracked working tree files would be overwritten by merge:\n%%s" 157 "Please move or remove them before you merge.") 158 : _("The following untracked working tree files would be overwritten by merge:\n%%s"); 159 else 160 msg = advice_commit_before_merge 161 ? _("The following untracked working tree files would be overwritten by %s:\n%%s" 162 "Please move or remove them before you %s.") 163 : _("The following untracked working tree files would be overwritten by %s:\n%%s"); 164 msgs[ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN] = 165 argv_array_pushf(&opts->msgs_to_free, msg, cmd, cmd); 166 167 /* 168 * Special case: ERROR_BIND_OVERLAP refers to a pair of paths, we 169 * cannot easily display it as a list. 170 */ 171 msgs[ERROR_BIND_OVERLAP] = _("Entry '%s' overlaps with '%s'. Cannot bind."); 172 173 msgs[ERROR_SPARSE_NOT_UPTODATE_FILE] = 174 _("Cannot update sparse checkout: the following entries are not up to date:\n%s"); 175 msgs[ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN] = 176 _("The following working tree files would be overwritten by sparse checkout update:\n%s"); 177 msgs[ERROR_WOULD_LOSE_ORPHANED_REMOVED] = 178 _("The following working tree files would be removed by sparse checkout update:\n%s"); 179 msgs[ERROR_WOULD_LOSE_SUBMODULE] = 180 _("Cannot update submodule:\n%s"); 181 182 opts->show_all_errors = 1; 183 /* rejected paths may not have a static buffer */ 184 for (i = 0; i < ARRAY_SIZE(opts->unpack_rejects); i++) 185 opts->unpack_rejects[i].strdup_strings = 1; 186} 187 188void clear_unpack_trees_porcelain(struct unpack_trees_options *opts) 189{ 190 argv_array_clear(&opts->msgs_to_free); 191 memset(opts->msgs, 0, sizeof(opts->msgs)); 192} 193 194static int do_add_entry(struct unpack_trees_options *o, struct cache_entry *ce, 195 unsigned int set, unsigned int clear) 196{ 197 clear |= CE_HASHED; 198 199 if (set & CE_REMOVE) 200 set |= CE_WT_REMOVE; 201 202 ce->ce_flags = (ce->ce_flags & ~clear) | set; 203 return add_index_entry(&o->result, ce, 204 ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); 205} 206 207static struct cache_entry *dup_entry(const struct cache_entry *ce) 208{ 209 unsigned int size = ce_size(ce); 210 struct cache_entry *new_entry = xmalloc(size); 211 212 memcpy(new_entry, ce, size); 213 return new_entry; 214} 215 216static void add_entry(struct unpack_trees_options *o, 217 const struct cache_entry *ce, 218 unsigned int set, unsigned int clear) 219{ 220 do_add_entry(o, dup_entry(ce), set, clear); 221} 222 223/* 224 * add error messages on path <path> 225 * corresponding to the type <e> with the message <msg> 226 * indicating if it should be display in porcelain or not 227 */ 228static int add_rejected_path(struct unpack_trees_options *o, 229 enum unpack_trees_error_types e, 230 const char *path) 231{ 232 if (!o->show_all_errors) 233 return error(ERRORMSG(o, e), super_prefixed(path)); 234 235 /* 236 * Otherwise, insert in a list for future display by 237 * display_error_msgs() 238 */ 239 string_list_append(&o->unpack_rejects[e], path); 240 return -1; 241} 242 243/* 244 * display all the error messages stored in a nice way 245 */ 246static void display_error_msgs(struct unpack_trees_options *o) 247{ 248 int e, i; 249 int something_displayed = 0; 250 for (e = 0; e < NB_UNPACK_TREES_ERROR_TYPES; e++) { 251 struct string_list *rejects = &o->unpack_rejects[e]; 252 if (rejects->nr > 0) { 253 struct strbuf path = STRBUF_INIT; 254 something_displayed = 1; 255 for (i = 0; i < rejects->nr; i++) 256 strbuf_addf(&path, "\t%s\n", rejects->items[i].string); 257 error(ERRORMSG(o, e), super_prefixed(path.buf)); 258 strbuf_release(&path); 259 } 260 string_list_clear(rejects, 0); 261 } 262 if (something_displayed) 263 fprintf(stderr, _("Aborting\n")); 264} 265 266static int check_submodule_move_head(const struct cache_entry *ce, 267 const char *old_id, 268 const char *new_id, 269 struct unpack_trees_options *o) 270{ 271 unsigned flags = SUBMODULE_MOVE_HEAD_DRY_RUN; 272 const struct submodule *sub = submodule_from_ce(ce); 273 274 if (!sub) 275 return 0; 276 277 if (o->reset) 278 flags |= SUBMODULE_MOVE_HEAD_FORCE; 279 280 if (submodule_move_head(ce->name, old_id, new_id, flags)) 281 return o->gently ? -1 : 282 add_rejected_path(o, ERROR_WOULD_LOSE_SUBMODULE, ce->name); 283 return 0; 284} 285 286/* 287 * Preform the loading of the repository's gitmodules file. This function is 288 * used by 'check_update()' to perform loading of the gitmodules file in two 289 * differnt situations: 290 * (1) before removing entries from the working tree if the gitmodules file has 291 * been marked for removal. This situation is specified by 'state' == NULL. 292 * (2) before checking out entries to the working tree if the gitmodules file 293 * has been marked for update. This situation is specified by 'state' != NULL. 294 */ 295static void load_gitmodules_file(struct index_state *index, 296 struct checkout *state) 297{ 298 int pos = index_name_pos(index, GITMODULES_FILE, strlen(GITMODULES_FILE)); 299 300 if (pos >= 0) { 301 struct cache_entry *ce = index->cache[pos]; 302 if (!state && ce->ce_flags & CE_WT_REMOVE) { 303 repo_read_gitmodules(the_repository); 304 } else if (state && (ce->ce_flags & CE_UPDATE)) { 305 submodule_free(the_repository); 306 checkout_entry(ce, state, NULL); 307 repo_read_gitmodules(the_repository); 308 } 309 } 310} 311 312/* 313 * Unlink the last component and schedule the leading directories for 314 * removal, such that empty directories get removed. 315 */ 316static void unlink_entry(const struct cache_entry *ce) 317{ 318 const struct submodule *sub = submodule_from_ce(ce); 319 if (sub) { 320 /* state.force is set at the caller. */ 321 submodule_move_head(ce->name, "HEAD", NULL, 322 SUBMODULE_MOVE_HEAD_FORCE); 323 } 324 if (!check_leading_path(ce->name, ce_namelen(ce))) 325 return; 326 if (remove_or_warn(ce->ce_mode, ce->name)) 327 return; 328 schedule_dir_for_removal(ce->name, ce_namelen(ce)); 329} 330 331static struct progress *get_progress(struct unpack_trees_options *o) 332{ 333 unsigned cnt = 0, total = 0; 334 struct index_state *index = &o->result; 335 336 if (!o->update || !o->verbose_update) 337 return NULL; 338 339 for (; cnt < index->cache_nr; cnt++) { 340 const struct cache_entry *ce = index->cache[cnt]; 341 if (ce->ce_flags & (CE_UPDATE | CE_WT_REMOVE)) 342 total++; 343 } 344 345 return start_delayed_progress(_("Checking out files"), total); 346} 347 348static int check_updates(struct unpack_trees_options *o) 349{ 350 unsigned cnt = 0; 351 int errs = 0; 352 struct progress *progress = NULL; 353 struct index_state *index = &o->result; 354 struct checkout state = CHECKOUT_INIT; 355 int i; 356 357 state.force = 1; 358 state.quiet = 1; 359 state.refresh_cache = 1; 360 state.istate = index; 361 362 progress = get_progress(o); 363 364 if (o->update) 365 git_attr_set_direction(GIT_ATTR_CHECKOUT, index); 366 367 if (should_update_submodules() && o->update && !o->dry_run) 368 load_gitmodules_file(index, NULL); 369 370 for (i = 0; i < index->cache_nr; i++) { 371 const struct cache_entry *ce = index->cache[i]; 372 373 if (ce->ce_flags & CE_WT_REMOVE) { 374 display_progress(progress, ++cnt); 375 if (o->update && !o->dry_run) 376 unlink_entry(ce); 377 } 378 } 379 remove_marked_cache_entries(index); 380 remove_scheduled_dirs(); 381 382 if (should_update_submodules() && o->update && !o->dry_run) 383 load_gitmodules_file(index, &state); 384 385 enable_delayed_checkout(&state); 386 if (repository_format_partial_clone && o->update && !o->dry_run) { 387 /* 388 * Prefetch the objects that are to be checked out in the loop 389 * below. 390 */ 391 struct oid_array to_fetch = OID_ARRAY_INIT; 392 int fetch_if_missing_store = fetch_if_missing; 393 fetch_if_missing = 0; 394 for (i = 0; i < index->cache_nr; i++) { 395 struct cache_entry *ce = index->cache[i]; 396 if ((ce->ce_flags & CE_UPDATE) && 397 !S_ISGITLINK(ce->ce_mode)) { 398 if (!has_object_file(&ce->oid)) 399 oid_array_append(&to_fetch, &ce->oid); 400 } 401 } 402 if (to_fetch.nr) 403 fetch_objects(repository_format_partial_clone, 404 &to_fetch); 405 fetch_if_missing = fetch_if_missing_store; 406 oid_array_clear(&to_fetch); 407 } 408 for (i = 0; i < index->cache_nr; i++) { 409 struct cache_entry *ce = index->cache[i]; 410 411 if (ce->ce_flags & CE_UPDATE) { 412 if (ce->ce_flags & CE_WT_REMOVE) 413 BUG("both update and delete flags are set on %s", 414 ce->name); 415 display_progress(progress, ++cnt); 416 ce->ce_flags &= ~CE_UPDATE; 417 if (o->update && !o->dry_run) { 418 errs |= checkout_entry(ce, &state, NULL); 419 } 420 } 421 } 422 stop_progress(&progress); 423 errs |= finish_delayed_checkout(&state); 424 if (o->update) 425 git_attr_set_direction(GIT_ATTR_CHECKIN, NULL); 426 return errs != 0; 427} 428 429static int verify_uptodate_sparse(const struct cache_entry *ce, 430 struct unpack_trees_options *o); 431static int verify_absent_sparse(const struct cache_entry *ce, 432 enum unpack_trees_error_types, 433 struct unpack_trees_options *o); 434 435static int apply_sparse_checkout(struct index_state *istate, 436 struct cache_entry *ce, 437 struct unpack_trees_options *o) 438{ 439 int was_skip_worktree = ce_skip_worktree(ce); 440 441 if (ce->ce_flags & CE_NEW_SKIP_WORKTREE) 442 ce->ce_flags |= CE_SKIP_WORKTREE; 443 else 444 ce->ce_flags &= ~CE_SKIP_WORKTREE; 445 if (was_skip_worktree != ce_skip_worktree(ce)) { 446 ce->ce_flags |= CE_UPDATE_IN_BASE; 447 mark_fsmonitor_invalid(istate, ce); 448 istate->cache_changed |= CE_ENTRY_CHANGED; 449 } 450 451 /* 452 * if (!was_skip_worktree && !ce_skip_worktree()) { 453 * This is perfectly normal. Move on; 454 * } 455 */ 456 457 /* 458 * Merge strategies may set CE_UPDATE|CE_REMOVE outside checkout 459 * area as a result of ce_skip_worktree() shortcuts in 460 * verify_absent() and verify_uptodate(). 461 * Make sure they don't modify worktree if they are already 462 * outside checkout area 463 */ 464 if (was_skip_worktree && ce_skip_worktree(ce)) { 465 ce->ce_flags &= ~CE_UPDATE; 466 467 /* 468 * By default, when CE_REMOVE is on, CE_WT_REMOVE is also 469 * on to get that file removed from both index and worktree. 470 * If that file is already outside worktree area, don't 471 * bother remove it. 472 */ 473 if (ce->ce_flags & CE_REMOVE) 474 ce->ce_flags &= ~CE_WT_REMOVE; 475 } 476 477 if (!was_skip_worktree && ce_skip_worktree(ce)) { 478 /* 479 * If CE_UPDATE is set, verify_uptodate() must be called already 480 * also stat info may have lost after merged_entry() so calling 481 * verify_uptodate() again may fail 482 */ 483 if (!(ce->ce_flags & CE_UPDATE) && verify_uptodate_sparse(ce, o)) 484 return -1; 485 ce->ce_flags |= CE_WT_REMOVE; 486 ce->ce_flags &= ~CE_UPDATE; 487 } 488 if (was_skip_worktree && !ce_skip_worktree(ce)) { 489 if (verify_absent_sparse(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) 490 return -1; 491 ce->ce_flags |= CE_UPDATE; 492 } 493 return 0; 494} 495 496static inline int call_unpack_fn(const struct cache_entry * const *src, 497 struct unpack_trees_options *o) 498{ 499 int ret = o->fn(src, o); 500 if (ret > 0) 501 ret = 0; 502 return ret; 503} 504 505static void mark_ce_used(struct cache_entry *ce, struct unpack_trees_options *o) 506{ 507 ce->ce_flags |= CE_UNPACKED; 508 509 if (o->cache_bottom < o->src_index->cache_nr && 510 o->src_index->cache[o->cache_bottom] == ce) { 511 int bottom = o->cache_bottom; 512 while (bottom < o->src_index->cache_nr && 513 o->src_index->cache[bottom]->ce_flags & CE_UNPACKED) 514 bottom++; 515 o->cache_bottom = bottom; 516 } 517} 518 519static void mark_all_ce_unused(struct index_state *index) 520{ 521 int i; 522 for (i = 0; i < index->cache_nr; i++) 523 index->cache[i]->ce_flags &= ~(CE_UNPACKED | CE_ADDED | CE_NEW_SKIP_WORKTREE); 524} 525 526static int locate_in_src_index(const struct cache_entry *ce, 527 struct unpack_trees_options *o) 528{ 529 struct index_state *index = o->src_index; 530 int len = ce_namelen(ce); 531 int pos = index_name_pos(index, ce->name, len); 532 if (pos < 0) 533 pos = -1 - pos; 534 return pos; 535} 536 537/* 538 * We call unpack_index_entry() with an unmerged cache entry 539 * only in diff-index, and it wants a single callback. Skip 540 * the other unmerged entry with the same name. 541 */ 542static void mark_ce_used_same_name(struct cache_entry *ce, 543 struct unpack_trees_options *o) 544{ 545 struct index_state *index = o->src_index; 546 int len = ce_namelen(ce); 547 int pos; 548 549 for (pos = locate_in_src_index(ce, o); pos < index->cache_nr; pos++) { 550 struct cache_entry *next = index->cache[pos]; 551 if (len != ce_namelen(next) || 552 memcmp(ce->name, next->name, len)) 553 break; 554 mark_ce_used(next, o); 555 } 556} 557 558static struct cache_entry *next_cache_entry(struct unpack_trees_options *o) 559{ 560 const struct index_state *index = o->src_index; 561 int pos = o->cache_bottom; 562 563 while (pos < index->cache_nr) { 564 struct cache_entry *ce = index->cache[pos]; 565 if (!(ce->ce_flags & CE_UNPACKED)) 566 return ce; 567 pos++; 568 } 569 return NULL; 570} 571 572static void add_same_unmerged(const struct cache_entry *ce, 573 struct unpack_trees_options *o) 574{ 575 struct index_state *index = o->src_index; 576 int len = ce_namelen(ce); 577 int pos = index_name_pos(index, ce->name, len); 578 579 if (0 <= pos) 580 die("programming error in a caller of mark_ce_used_same_name"); 581 for (pos = -pos - 1; pos < index->cache_nr; pos++) { 582 struct cache_entry *next = index->cache[pos]; 583 if (len != ce_namelen(next) || 584 memcmp(ce->name, next->name, len)) 585 break; 586 add_entry(o, next, 0, 0); 587 mark_ce_used(next, o); 588 } 589} 590 591static int unpack_index_entry(struct cache_entry *ce, 592 struct unpack_trees_options *o) 593{ 594 const struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, }; 595 int ret; 596 597 src[0] = ce; 598 599 mark_ce_used(ce, o); 600 if (ce_stage(ce)) { 601 if (o->skip_unmerged) { 602 add_entry(o, ce, 0, 0); 603 return 0; 604 } 605 } 606 ret = call_unpack_fn(src, o); 607 if (ce_stage(ce)) 608 mark_ce_used_same_name(ce, o); 609 return ret; 610} 611 612static int find_cache_pos(struct traverse_info *, const struct name_entry *); 613 614static void restore_cache_bottom(struct traverse_info *info, int bottom) 615{ 616 struct unpack_trees_options *o = info->data; 617 618 if (o->diff_index_cached) 619 return; 620 o->cache_bottom = bottom; 621} 622 623static int switch_cache_bottom(struct traverse_info *info) 624{ 625 struct unpack_trees_options *o = info->data; 626 int ret, pos; 627 628 if (o->diff_index_cached) 629 return 0; 630 ret = o->cache_bottom; 631 pos = find_cache_pos(info->prev, &info->name); 632 633 if (pos < -1) 634 o->cache_bottom = -2 - pos; 635 else if (pos < 0) 636 o->cache_bottom = o->src_index->cache_nr; 637 return ret; 638} 639 640static inline int are_same_oid(struct name_entry *name_j, struct name_entry *name_k) 641{ 642 return name_j->oid && name_k->oid && !oidcmp(name_j->oid, name_k->oid); 643} 644 645static int traverse_trees_recursive(int n, unsigned long dirmask, 646 unsigned long df_conflicts, 647 struct name_entry *names, 648 struct traverse_info *info) 649{ 650 int i, ret, bottom; 651 int nr_buf = 0; 652 struct tree_desc t[MAX_UNPACK_TREES]; 653 void *buf[MAX_UNPACK_TREES]; 654 struct traverse_info newinfo; 655 struct name_entry *p; 656 657 p = names; 658 while (!p->mode) 659 p++; 660 661 newinfo = *info; 662 newinfo.prev = info; 663 newinfo.pathspec = info->pathspec; 664 newinfo.name = *p; 665 newinfo.pathlen += tree_entry_len(p) + 1; 666 newinfo.df_conflicts |= df_conflicts; 667 668 /* 669 * Fetch the tree from the ODB for each peer directory in the 670 * n commits. 671 * 672 * For 2- and 3-way traversals, we try to avoid hitting the 673 * ODB twice for the same OID. This should yield a nice speed 674 * up in checkouts and merges when the commits are similar. 675 * 676 * We don't bother doing the full O(n^2) search for larger n, 677 * because wider traversals don't happen that often and we 678 * avoid the search setup. 679 * 680 * When 2 peer OIDs are the same, we just copy the tree 681 * descriptor data. This implicitly borrows the buffer 682 * data from the earlier cell. 683 */ 684 for (i = 0; i < n; i++, dirmask >>= 1) { 685 if (i > 0 && are_same_oid(&names[i], &names[i - 1])) 686 t[i] = t[i - 1]; 687 else if (i > 1 && are_same_oid(&names[i], &names[i - 2])) 688 t[i] = t[i - 2]; 689 else { 690 const struct object_id *oid = NULL; 691 if (dirmask & 1) 692 oid = names[i].oid; 693 buf[nr_buf++] = fill_tree_descriptor(t + i, oid); 694 } 695 } 696 697 bottom = switch_cache_bottom(&newinfo); 698 ret = traverse_trees(n, t, &newinfo); 699 restore_cache_bottom(&newinfo, bottom); 700 701 for (i = 0; i < nr_buf; i++) 702 free(buf[i]); 703 704 return ret; 705} 706 707/* 708 * Compare the traverse-path to the cache entry without actually 709 * having to generate the textual representation of the traverse 710 * path. 711 * 712 * NOTE! This *only* compares up to the size of the traverse path 713 * itself - the caller needs to do the final check for the cache 714 * entry having more data at the end! 715 */ 716static int do_compare_entry_piecewise(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) 717{ 718 int len, pathlen, ce_len; 719 const char *ce_name; 720 721 if (info->prev) { 722 int cmp = do_compare_entry_piecewise(ce, info->prev, 723 &info->name); 724 if (cmp) 725 return cmp; 726 } 727 pathlen = info->pathlen; 728 ce_len = ce_namelen(ce); 729 730 /* If ce_len < pathlen then we must have previously hit "name == directory" entry */ 731 if (ce_len < pathlen) 732 return -1; 733 734 ce_len -= pathlen; 735 ce_name = ce->name + pathlen; 736 737 len = tree_entry_len(n); 738 return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); 739} 740 741static int do_compare_entry(const struct cache_entry *ce, 742 const struct traverse_info *info, 743 const struct name_entry *n) 744{ 745 int len, pathlen, ce_len; 746 const char *ce_name; 747 int cmp; 748 749 /* 750 * If we have not precomputed the traverse path, it is quicker 751 * to avoid doing so. But if we have precomputed it, 752 * it is quicker to use the precomputed version. 753 */ 754 if (!info->traverse_path) 755 return do_compare_entry_piecewise(ce, info, n); 756 757 cmp = strncmp(ce->name, info->traverse_path, info->pathlen); 758 if (cmp) 759 return cmp; 760 761 pathlen = info->pathlen; 762 ce_len = ce_namelen(ce); 763 764 if (ce_len < pathlen) 765 return -1; 766 767 ce_len -= pathlen; 768 ce_name = ce->name + pathlen; 769 770 len = tree_entry_len(n); 771 return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); 772} 773 774static int compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) 775{ 776 int cmp = do_compare_entry(ce, info, n); 777 if (cmp) 778 return cmp; 779 780 /* 781 * Even if the beginning compared identically, the ce should 782 * compare as bigger than a directory leading up to it! 783 */ 784 return ce_namelen(ce) > traverse_path_len(info, n); 785} 786 787static int ce_in_traverse_path(const struct cache_entry *ce, 788 const struct traverse_info *info) 789{ 790 if (!info->prev) 791 return 1; 792 if (do_compare_entry(ce, info->prev, &info->name)) 793 return 0; 794 /* 795 * If ce (blob) is the same name as the path (which is a tree 796 * we will be descending into), it won't be inside it. 797 */ 798 return (info->pathlen < ce_namelen(ce)); 799} 800 801static struct cache_entry *create_ce_entry(const struct traverse_info *info, const struct name_entry *n, int stage) 802{ 803 int len = traverse_path_len(info, n); 804 struct cache_entry *ce = xcalloc(1, cache_entry_size(len)); 805 806 ce->ce_mode = create_ce_mode(n->mode); 807 ce->ce_flags = create_ce_flags(stage); 808 ce->ce_namelen = len; 809 oidcpy(&ce->oid, n->oid); 810 make_traverse_path(ce->name, info, n); 811 812 return ce; 813} 814 815static int unpack_nondirectories(int n, unsigned long mask, 816 unsigned long dirmask, 817 struct cache_entry **src, 818 const struct name_entry *names, 819 const struct traverse_info *info) 820{ 821 int i; 822 struct unpack_trees_options *o = info->data; 823 unsigned long conflicts = info->df_conflicts | dirmask; 824 825 /* Do we have *only* directories? Nothing to do */ 826 if (mask == dirmask && !src[0]) 827 return 0; 828 829 /* 830 * Ok, we've filled in up to any potential index entry in src[0], 831 * now do the rest. 832 */ 833 for (i = 0; i < n; i++) { 834 int stage; 835 unsigned int bit = 1ul << i; 836 if (conflicts & bit) { 837 src[i + o->merge] = o->df_conflict_entry; 838 continue; 839 } 840 if (!(mask & bit)) 841 continue; 842 if (!o->merge) 843 stage = 0; 844 else if (i + 1 < o->head_idx) 845 stage = 1; 846 else if (i + 1 > o->head_idx) 847 stage = 3; 848 else 849 stage = 2; 850 src[i + o->merge] = create_ce_entry(info, names + i, stage); 851 } 852 853 if (o->merge) { 854 int rc = call_unpack_fn((const struct cache_entry * const *)src, 855 o); 856 for (i = 0; i < n; i++) { 857 struct cache_entry *ce = src[i + o->merge]; 858 if (ce != o->df_conflict_entry) 859 free(ce); 860 } 861 return rc; 862 } 863 864 for (i = 0; i < n; i++) 865 if (src[i] && src[i] != o->df_conflict_entry) 866 if (do_add_entry(o, src[i], 0, 0)) 867 return -1; 868 869 return 0; 870} 871 872static int unpack_failed(struct unpack_trees_options *o, const char *message) 873{ 874 discard_index(&o->result); 875 if (!o->gently && !o->exiting_early) { 876 if (message) 877 return error("%s", message); 878 return -1; 879 } 880 return -1; 881} 882 883/* 884 * The tree traversal is looking at name p. If we have a matching entry, 885 * return it. If name p is a directory in the index, do not return 886 * anything, as we will want to match it when the traversal descends into 887 * the directory. 888 */ 889static int find_cache_pos(struct traverse_info *info, 890 const struct name_entry *p) 891{ 892 int pos; 893 struct unpack_trees_options *o = info->data; 894 struct index_state *index = o->src_index; 895 int pfxlen = info->pathlen; 896 int p_len = tree_entry_len(p); 897 898 for (pos = o->cache_bottom; pos < index->cache_nr; pos++) { 899 const struct cache_entry *ce = index->cache[pos]; 900 const char *ce_name, *ce_slash; 901 int cmp, ce_len; 902 903 if (ce->ce_flags & CE_UNPACKED) { 904 /* 905 * cache_bottom entry is already unpacked, so 906 * we can never match it; don't check it 907 * again. 908 */ 909 if (pos == o->cache_bottom) 910 ++o->cache_bottom; 911 continue; 912 } 913 if (!ce_in_traverse_path(ce, info)) { 914 /* 915 * Check if we can skip future cache checks 916 * (because we're already past all possible 917 * entries in the traverse path). 918 */ 919 if (info->traverse_path) { 920 if (strncmp(ce->name, info->traverse_path, 921 info->pathlen) > 0) 922 break; 923 } 924 continue; 925 } 926 ce_name = ce->name + pfxlen; 927 ce_slash = strchr(ce_name, '/'); 928 if (ce_slash) 929 ce_len = ce_slash - ce_name; 930 else 931 ce_len = ce_namelen(ce) - pfxlen; 932 cmp = name_compare(p->path, p_len, ce_name, ce_len); 933 /* 934 * Exact match; if we have a directory we need to 935 * delay returning it. 936 */ 937 if (!cmp) 938 return ce_slash ? -2 - pos : pos; 939 if (0 < cmp) 940 continue; /* keep looking */ 941 /* 942 * ce_name sorts after p->path; could it be that we 943 * have files under p->path directory in the index? 944 * E.g. ce_name == "t-i", and p->path == "t"; we may 945 * have "t/a" in the index. 946 */ 947 if (p_len < ce_len && !memcmp(ce_name, p->path, p_len) && 948 ce_name[p_len] < '/') 949 continue; /* keep looking */ 950 break; 951 } 952 return -1; 953} 954 955static struct cache_entry *find_cache_entry(struct traverse_info *info, 956 const struct name_entry *p) 957{ 958 int pos = find_cache_pos(info, p); 959 struct unpack_trees_options *o = info->data; 960 961 if (0 <= pos) 962 return o->src_index->cache[pos]; 963 else 964 return NULL; 965} 966 967static void debug_path(struct traverse_info *info) 968{ 969 if (info->prev) { 970 debug_path(info->prev); 971 if (*info->prev->name.path) 972 putchar('/'); 973 } 974 printf("%s", info->name.path); 975} 976 977static void debug_name_entry(int i, struct name_entry *n) 978{ 979 printf("ent#%d %06o %s\n", i, 980 n->path ? n->mode : 0, 981 n->path ? n->path : "(missing)"); 982} 983 984static void debug_unpack_callback(int n, 985 unsigned long mask, 986 unsigned long dirmask, 987 struct name_entry *names, 988 struct traverse_info *info) 989{ 990 int i; 991 printf("* unpack mask %lu, dirmask %lu, cnt %d ", 992 mask, dirmask, n); 993 debug_path(info); 994 putchar('\n'); 995 for (i = 0; i < n; i++) 996 debug_name_entry(i, names + i); 997} 998 999static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info)1000{1001 struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, };1002 struct unpack_trees_options *o = info->data;1003 const struct name_entry *p = names;10041005 /* Find first entry with a real name (we could use "mask" too) */1006 while (!p->mode)1007 p++;10081009 if (o->debug_unpack)1010 debug_unpack_callback(n, mask, dirmask, names, info);10111012 /* Are we supposed to look at the index too? */1013 if (o->merge) {1014 while (1) {1015 int cmp;1016 struct cache_entry *ce;10171018 if (o->diff_index_cached)1019 ce = next_cache_entry(o);1020 else1021 ce = find_cache_entry(info, p);10221023 if (!ce)1024 break;1025 cmp = compare_entry(ce, info, p);1026 if (cmp < 0) {1027 if (unpack_index_entry(ce, o) < 0)1028 return unpack_failed(o, NULL);1029 continue;1030 }1031 if (!cmp) {1032 if (ce_stage(ce)) {1033 /*1034 * If we skip unmerged index1035 * entries, we'll skip this1036 * entry *and* the tree1037 * entries associated with it!1038 */1039 if (o->skip_unmerged) {1040 add_same_unmerged(ce, o);1041 return mask;1042 }1043 }1044 src[0] = ce;1045 }1046 break;1047 }1048 }10491050 if (unpack_nondirectories(n, mask, dirmask, src, names, info) < 0)1051 return -1;10521053 if (o->merge && src[0]) {1054 if (ce_stage(src[0]))1055 mark_ce_used_same_name(src[0], o);1056 else1057 mark_ce_used(src[0], o);1058 }10591060 /* Now handle any directories.. */1061 if (dirmask) {1062 /* special case: "diff-index --cached" looking at a tree */1063 if (o->diff_index_cached &&1064 n == 1 && dirmask == 1 && S_ISDIR(names->mode)) {1065 int matches;1066 matches = cache_tree_matches_traversal(o->src_index->cache_tree,1067 names, info);1068 /*1069 * Everything under the name matches; skip the1070 * entire hierarchy. diff_index_cached codepath1071 * special cases D/F conflicts in such a way that1072 * it does not do any look-ahead, so this is safe.1073 */1074 if (matches) {1075 o->cache_bottom += matches;1076 return mask;1077 }1078 }10791080 if (traverse_trees_recursive(n, dirmask, mask & ~dirmask,1081 names, info) < 0)1082 return -1;1083 return mask;1084 }10851086 return mask;1087}10881089static int clear_ce_flags_1(struct cache_entry **cache, int nr,1090 struct strbuf *prefix,1091 int select_mask, int clear_mask,1092 struct exclude_list *el, int defval);10931094/* Whole directory matching */1095static int clear_ce_flags_dir(struct cache_entry **cache, int nr,1096 struct strbuf *prefix,1097 char *basename,1098 int select_mask, int clear_mask,1099 struct exclude_list *el, int defval)1100{1101 struct cache_entry **cache_end;1102 int dtype = DT_DIR;1103 int ret = is_excluded_from_list(prefix->buf, prefix->len,1104 basename, &dtype, el, &the_index);1105 int rc;11061107 strbuf_addch(prefix, '/');11081109 /* If undecided, use matching result of parent dir in defval */1110 if (ret < 0)1111 ret = defval;11121113 for (cache_end = cache; cache_end != cache + nr; cache_end++) {1114 struct cache_entry *ce = *cache_end;1115 if (strncmp(ce->name, prefix->buf, prefix->len))1116 break;1117 }11181119 /*1120 * TODO: check el, if there are no patterns that may conflict1121 * with ret (iow, we know in advance the incl/excl1122 * decision for the entire directory), clear flag here without1123 * calling clear_ce_flags_1(). That function will call1124 * the expensive is_excluded_from_list() on every entry.1125 */1126 rc = clear_ce_flags_1(cache, cache_end - cache,1127 prefix,1128 select_mask, clear_mask,1129 el, ret);1130 strbuf_setlen(prefix, prefix->len - 1);1131 return rc;1132}11331134/*1135 * Traverse the index, find every entry that matches according to1136 * o->el. Do "ce_flags &= ~clear_mask" on those entries. Return the1137 * number of traversed entries.1138 *1139 * If select_mask is non-zero, only entries whose ce_flags has on of1140 * those bits enabled are traversed.1141 *1142 * cache : pointer to an index entry1143 * prefix_len : an offset to its path1144 *1145 * The current path ("prefix") including the trailing '/' is1146 * cache[0]->name[0..(prefix_len-1)]1147 * Top level path has prefix_len zero.1148 */1149static int clear_ce_flags_1(struct cache_entry **cache, int nr,1150 struct strbuf *prefix,1151 int select_mask, int clear_mask,1152 struct exclude_list *el, int defval)1153{1154 struct cache_entry **cache_end = cache + nr;11551156 /*1157 * Process all entries that have the given prefix and meet1158 * select_mask condition1159 */1160 while(cache != cache_end) {1161 struct cache_entry *ce = *cache;1162 const char *name, *slash;1163 int len, dtype, ret;11641165 if (select_mask && !(ce->ce_flags & select_mask)) {1166 cache++;1167 continue;1168 }11691170 if (prefix->len && strncmp(ce->name, prefix->buf, prefix->len))1171 break;11721173 name = ce->name + prefix->len;1174 slash = strchr(name, '/');11751176 /* If it's a directory, try whole directory match first */1177 if (slash) {1178 int processed;11791180 len = slash - name;1181 strbuf_add(prefix, name, len);11821183 processed = clear_ce_flags_dir(cache, cache_end - cache,1184 prefix,1185 prefix->buf + prefix->len - len,1186 select_mask, clear_mask,1187 el, defval);11881189 /* clear_c_f_dir eats a whole dir already? */1190 if (processed) {1191 cache += processed;1192 strbuf_setlen(prefix, prefix->len - len);1193 continue;1194 }11951196 strbuf_addch(prefix, '/');1197 cache += clear_ce_flags_1(cache, cache_end - cache,1198 prefix,1199 select_mask, clear_mask, el, defval);1200 strbuf_setlen(prefix, prefix->len - len - 1);1201 continue;1202 }12031204 /* Non-directory */1205 dtype = ce_to_dtype(ce);1206 ret = is_excluded_from_list(ce->name, ce_namelen(ce),1207 name, &dtype, el, &the_index);1208 if (ret < 0)1209 ret = defval;1210 if (ret > 0)1211 ce->ce_flags &= ~clear_mask;1212 cache++;1213 }1214 return nr - (cache_end - cache);1215}12161217static int clear_ce_flags(struct cache_entry **cache, int nr,1218 int select_mask, int clear_mask,1219 struct exclude_list *el)1220{1221 static struct strbuf prefix = STRBUF_INIT;12221223 strbuf_reset(&prefix);12241225 return clear_ce_flags_1(cache, nr,1226 &prefix,1227 select_mask, clear_mask,1228 el, 0);1229}12301231/*1232 * Set/Clear CE_NEW_SKIP_WORKTREE according to $GIT_DIR/info/sparse-checkout1233 */1234static void mark_new_skip_worktree(struct exclude_list *el,1235 struct index_state *the_index,1236 int select_flag, int skip_wt_flag)1237{1238 int i;12391240 /*1241 * 1. Pretend the narrowest worktree: only unmerged entries1242 * are checked out1243 */1244 for (i = 0; i < the_index->cache_nr; i++) {1245 struct cache_entry *ce = the_index->cache[i];12461247 if (select_flag && !(ce->ce_flags & select_flag))1248 continue;12491250 if (!ce_stage(ce) && !(ce->ce_flags & CE_CONFLICTED))1251 ce->ce_flags |= skip_wt_flag;1252 else1253 ce->ce_flags &= ~skip_wt_flag;1254 }12551256 /*1257 * 2. Widen worktree according to sparse-checkout file.1258 * Matched entries will have skip_wt_flag cleared (i.e. "in")1259 */1260 clear_ce_flags(the_index->cache, the_index->cache_nr,1261 select_flag, skip_wt_flag, el);1262}12631264static int verify_absent(const struct cache_entry *,1265 enum unpack_trees_error_types,1266 struct unpack_trees_options *);1267/*1268 * N-way merge "len" trees. Returns 0 on success, -1 on failure to manipulate the1269 * resulting index, -2 on failure to reflect the changes to the work tree.1270 *1271 * CE_ADDED, CE_UNPACKED and CE_NEW_SKIP_WORKTREE are used internally1272 */1273int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)1274{1275 int i, ret;1276 static struct cache_entry *dfc;1277 struct exclude_list el;12781279 if (len > MAX_UNPACK_TREES)1280 die("unpack_trees takes at most %d trees", MAX_UNPACK_TREES);12811282 memset(&el, 0, sizeof(el));1283 if (!core_apply_sparse_checkout || !o->update)1284 o->skip_sparse_checkout = 1;1285 if (!o->skip_sparse_checkout) {1286 char *sparse = git_pathdup("info/sparse-checkout");1287 if (add_excludes_from_file_to_list(sparse, "", 0, &el, NULL) < 0)1288 o->skip_sparse_checkout = 1;1289 else1290 o->el = ⪙1291 free(sparse);1292 }12931294 memset(&o->result, 0, sizeof(o->result));1295 o->result.initialized = 1;1296 o->result.timestamp.sec = o->src_index->timestamp.sec;1297 o->result.timestamp.nsec = o->src_index->timestamp.nsec;1298 o->result.version = o->src_index->version;1299 if (!o->src_index->split_index) {1300 o->result.split_index = NULL;1301 } else if (o->src_index == o->dst_index) {1302 /*1303 * o->dst_index (and thus o->src_index) will be discarded1304 * and overwritten with o->result at the end of this function,1305 * so just use src_index's split_index to avoid having to1306 * create a new one.1307 */1308 o->result.split_index = o->src_index->split_index;1309 o->result.split_index->refcount++;1310 } else {1311 o->result.split_index = init_split_index(&o->result);1312 }1313 oidcpy(&o->result.oid, &o->src_index->oid);1314 o->merge_size = len;1315 mark_all_ce_unused(o->src_index);13161317 /*1318 * Sparse checkout loop #1: set NEW_SKIP_WORKTREE on existing entries1319 */1320 if (!o->skip_sparse_checkout)1321 mark_new_skip_worktree(o->el, o->src_index, 0, CE_NEW_SKIP_WORKTREE);13221323 if (!dfc)1324 dfc = xcalloc(1, cache_entry_size(0));1325 o->df_conflict_entry = dfc;13261327 if (len) {1328 const char *prefix = o->prefix ? o->prefix : "";1329 struct traverse_info info;13301331 setup_traverse_info(&info, prefix);1332 info.fn = unpack_callback;1333 info.data = o;1334 info.show_all_errors = o->show_all_errors;1335 info.pathspec = o->pathspec;13361337 if (o->prefix) {1338 /*1339 * Unpack existing index entries that sort before the1340 * prefix the tree is spliced into. Note that o->merge1341 * is always true in this case.1342 */1343 while (1) {1344 struct cache_entry *ce = next_cache_entry(o);1345 if (!ce)1346 break;1347 if (ce_in_traverse_path(ce, &info))1348 break;1349 if (unpack_index_entry(ce, o) < 0)1350 goto return_failed;1351 }1352 }13531354 if (traverse_trees(len, t, &info) < 0)1355 goto return_failed;1356 }13571358 /* Any left-over entries in the index? */1359 if (o->merge) {1360 while (1) {1361 struct cache_entry *ce = next_cache_entry(o);1362 if (!ce)1363 break;1364 if (unpack_index_entry(ce, o) < 0)1365 goto return_failed;1366 }1367 }1368 mark_all_ce_unused(o->src_index);13691370 if (o->trivial_merges_only && o->nontrivial_merge) {1371 ret = unpack_failed(o, "Merge requires file-level merging");1372 goto done;1373 }13741375 if (!o->skip_sparse_checkout) {1376 int empty_worktree = 1;13771378 /*1379 * Sparse checkout loop #2: set NEW_SKIP_WORKTREE on entries not in loop #11380 * If the will have NEW_SKIP_WORKTREE, also set CE_SKIP_WORKTREE1381 * so apply_sparse_checkout() won't attempt to remove it from worktree1382 */1383 mark_new_skip_worktree(o->el, &o->result, CE_ADDED, CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);13841385 ret = 0;1386 for (i = 0; i < o->result.cache_nr; i++) {1387 struct cache_entry *ce = o->result.cache[i];13881389 /*1390 * Entries marked with CE_ADDED in merged_entry() do not have1391 * verify_absent() check (the check is effectively disabled1392 * because CE_NEW_SKIP_WORKTREE is set unconditionally).1393 *1394 * Do the real check now because we have had1395 * correct CE_NEW_SKIP_WORKTREE1396 */1397 if (ce->ce_flags & CE_ADDED &&1398 verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) {1399 if (!o->show_all_errors)1400 goto return_failed;1401 ret = -1;1402 }14031404 if (apply_sparse_checkout(&o->result, ce, o)) {1405 if (!o->show_all_errors)1406 goto return_failed;1407 ret = -1;1408 }1409 if (!ce_skip_worktree(ce))1410 empty_worktree = 0;14111412 }1413 if (ret < 0)1414 goto return_failed;1415 /*1416 * Sparse checkout is meant to narrow down checkout area1417 * but it does not make sense to narrow down to empty working1418 * tree. This is usually a mistake in sparse checkout rules.1419 * Do not allow users to do that.1420 */1421 if (o->result.cache_nr && empty_worktree) {1422 ret = unpack_failed(o, "Sparse checkout leaves no entry on working directory");1423 goto done;1424 }1425 }14261427 ret = check_updates(o) ? (-2) : 0;1428 if (o->dst_index) {1429 if (!ret) {1430 if (!o->result.cache_tree)1431 o->result.cache_tree = cache_tree();1432 if (!cache_tree_fully_valid(o->result.cache_tree))1433 cache_tree_update(&o->result,1434 WRITE_TREE_SILENT |1435 WRITE_TREE_REPAIR);1436 }1437 move_index_extensions(&o->result, o->src_index);1438 discard_index(o->dst_index);1439 *o->dst_index = o->result;1440 } else {1441 discard_index(&o->result);1442 }1443 o->src_index = NULL;14441445done:1446 clear_exclude_list(&el);1447 return ret;14481449return_failed:1450 if (o->show_all_errors)1451 display_error_msgs(o);1452 mark_all_ce_unused(o->src_index);1453 ret = unpack_failed(o, NULL);1454 if (o->exiting_early)1455 ret = 0;1456 goto done;1457}14581459/* Here come the merge functions */14601461static int reject_merge(const struct cache_entry *ce,1462 struct unpack_trees_options *o)1463{1464 return o->gently ? -1 :1465 add_rejected_path(o, ERROR_WOULD_OVERWRITE, ce->name);1466}14671468static int same(const struct cache_entry *a, const struct cache_entry *b)1469{1470 if (!!a != !!b)1471 return 0;1472 if (!a && !b)1473 return 1;1474 if ((a->ce_flags | b->ce_flags) & CE_CONFLICTED)1475 return 0;1476 return a->ce_mode == b->ce_mode &&1477 !oidcmp(&a->oid, &b->oid);1478}147914801481/*1482 * When a CE gets turned into an unmerged entry, we1483 * want it to be up-to-date1484 */1485static int verify_uptodate_1(const struct cache_entry *ce,1486 struct unpack_trees_options *o,1487 enum unpack_trees_error_types error_type)1488{1489 struct stat st;14901491 if (o->index_only)1492 return 0;14931494 /*1495 * CE_VALID and CE_SKIP_WORKTREE cheat, we better check again1496 * if this entry is truly up-to-date because this file may be1497 * overwritten.1498 */1499 if ((ce->ce_flags & CE_VALID) || ce_skip_worktree(ce))1500 ; /* keep checking */1501 else if (o->reset || ce_uptodate(ce))1502 return 0;15031504 if (!lstat(ce->name, &st)) {1505 int flags = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE;1506 unsigned changed = ie_match_stat(o->src_index, ce, &st, flags);15071508 if (submodule_from_ce(ce)) {1509 int r = check_submodule_move_head(ce,1510 "HEAD", oid_to_hex(&ce->oid), o);1511 if (r)1512 return o->gently ? -1 :1513 add_rejected_path(o, error_type, ce->name);1514 return 0;1515 }15161517 if (!changed)1518 return 0;1519 /*1520 * Historic default policy was to allow submodule to be out1521 * of sync wrt the superproject index. If the submodule was1522 * not considered interesting above, we don't care here.1523 */1524 if (S_ISGITLINK(ce->ce_mode))1525 return 0;15261527 errno = 0;1528 }1529 if (errno == ENOENT)1530 return 0;1531 return o->gently ? -1 :1532 add_rejected_path(o, error_type, ce->name);1533}15341535int verify_uptodate(const struct cache_entry *ce,1536 struct unpack_trees_options *o)1537{1538 if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1539 return 0;1540 return verify_uptodate_1(ce, o, ERROR_NOT_UPTODATE_FILE);1541}15421543static int verify_uptodate_sparse(const struct cache_entry *ce,1544 struct unpack_trees_options *o)1545{1546 return verify_uptodate_1(ce, o, ERROR_SPARSE_NOT_UPTODATE_FILE);1547}15481549static void invalidate_ce_path(const struct cache_entry *ce,1550 struct unpack_trees_options *o)1551{1552 if (!ce)1553 return;1554 cache_tree_invalidate_path(o->src_index, ce->name);1555 untracked_cache_invalidate_path(o->src_index, ce->name, 1);1556}15571558/*1559 * Check that checking out ce->sha1 in subdir ce->name is not1560 * going to overwrite any working files.1561 *1562 * Currently, git does not checkout subprojects during a superproject1563 * checkout, so it is not going to overwrite anything.1564 */1565static int verify_clean_submodule(const char *old_sha1,1566 const struct cache_entry *ce,1567 enum unpack_trees_error_types error_type,1568 struct unpack_trees_options *o)1569{1570 if (!submodule_from_ce(ce))1571 return 0;15721573 return check_submodule_move_head(ce, old_sha1,1574 oid_to_hex(&ce->oid), o);1575}15761577static int verify_clean_subdirectory(const struct cache_entry *ce,1578 enum unpack_trees_error_types error_type,1579 struct unpack_trees_options *o)1580{1581 /*1582 * we are about to extract "ce->name"; we would not want to lose1583 * anything in the existing directory there.1584 */1585 int namelen;1586 int i;1587 struct dir_struct d;1588 char *pathbuf;1589 int cnt = 0;15901591 if (S_ISGITLINK(ce->ce_mode)) {1592 struct object_id oid;1593 int sub_head = resolve_gitlink_ref(ce->name, "HEAD", &oid);1594 /*1595 * If we are not going to update the submodule, then1596 * we don't care.1597 */1598 if (!sub_head && !oidcmp(&oid, &ce->oid))1599 return 0;1600 return verify_clean_submodule(sub_head ? NULL : oid_to_hex(&oid),1601 ce, error_type, o);1602 }16031604 /*1605 * First let's make sure we do not have a local modification1606 * in that directory.1607 */1608 namelen = ce_namelen(ce);1609 for (i = locate_in_src_index(ce, o);1610 i < o->src_index->cache_nr;1611 i++) {1612 struct cache_entry *ce2 = o->src_index->cache[i];1613 int len = ce_namelen(ce2);1614 if (len < namelen ||1615 strncmp(ce->name, ce2->name, namelen) ||1616 ce2->name[namelen] != '/')1617 break;1618 /*1619 * ce2->name is an entry in the subdirectory to be1620 * removed.1621 */1622 if (!ce_stage(ce2)) {1623 if (verify_uptodate(ce2, o))1624 return -1;1625 add_entry(o, ce2, CE_REMOVE, 0);1626 mark_ce_used(ce2, o);1627 }1628 cnt++;1629 }16301631 /*1632 * Then we need to make sure that we do not lose a locally1633 * present file that is not ignored.1634 */1635 pathbuf = xstrfmt("%.*s/", namelen, ce->name);16361637 memset(&d, 0, sizeof(d));1638 if (o->dir)1639 d.exclude_per_dir = o->dir->exclude_per_dir;1640 i = read_directory(&d, &the_index, pathbuf, namelen+1, NULL);1641 if (i)1642 return o->gently ? -1 :1643 add_rejected_path(o, ERROR_NOT_UPTODATE_DIR, ce->name);1644 free(pathbuf);1645 return cnt;1646}16471648/*1649 * This gets called when there was no index entry for the tree entry 'dst',1650 * but we found a file in the working tree that 'lstat()' said was fine,1651 * and we're on a case-insensitive filesystem.1652 *1653 * See if we can find a case-insensitive match in the index that also1654 * matches the stat information, and assume it's that other file!1655 */1656static int icase_exists(struct unpack_trees_options *o, const char *name, int len, struct stat *st)1657{1658 const struct cache_entry *src;16591660 src = index_file_exists(o->src_index, name, len, 1);1661 return src && !ie_match_stat(o->src_index, src, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);1662}16631664static int check_ok_to_remove(const char *name, int len, int dtype,1665 const struct cache_entry *ce, struct stat *st,1666 enum unpack_trees_error_types error_type,1667 struct unpack_trees_options *o)1668{1669 const struct cache_entry *result;16701671 /*1672 * It may be that the 'lstat()' succeeded even though1673 * target 'ce' was absent, because there is an old1674 * entry that is different only in case..1675 *1676 * Ignore that lstat() if it matches.1677 */1678 if (ignore_case && icase_exists(o, name, len, st))1679 return 0;16801681 if (o->dir &&1682 is_excluded(o->dir, &the_index, name, &dtype))1683 /*1684 * ce->name is explicitly excluded, so it is Ok to1685 * overwrite it.1686 */1687 return 0;1688 if (S_ISDIR(st->st_mode)) {1689 /*1690 * We are checking out path "foo" and1691 * found "foo/." in the working tree.1692 * This is tricky -- if we have modified1693 * files that are in "foo/" we would lose1694 * them.1695 */1696 if (verify_clean_subdirectory(ce, error_type, o) < 0)1697 return -1;1698 return 0;1699 }17001701 /*1702 * The previous round may already have decided to1703 * delete this path, which is in a subdirectory that1704 * is being replaced with a blob.1705 */1706 result = index_file_exists(&o->result, name, len, 0);1707 if (result) {1708 if (result->ce_flags & CE_REMOVE)1709 return 0;1710 }17111712 return o->gently ? -1 :1713 add_rejected_path(o, error_type, name);1714}17151716/*1717 * We do not want to remove or overwrite a working tree file that1718 * is not tracked, unless it is ignored.1719 */1720static int verify_absent_1(const struct cache_entry *ce,1721 enum unpack_trees_error_types error_type,1722 struct unpack_trees_options *o)1723{1724 int len;1725 struct stat st;17261727 if (o->index_only || o->reset || !o->update)1728 return 0;17291730 len = check_leading_path(ce->name, ce_namelen(ce));1731 if (!len)1732 return 0;1733 else if (len > 0) {1734 char *path;1735 int ret;17361737 path = xmemdupz(ce->name, len);1738 if (lstat(path, &st))1739 ret = error_errno("cannot stat '%s'", path);1740 else {1741 if (submodule_from_ce(ce))1742 ret = check_submodule_move_head(ce,1743 oid_to_hex(&ce->oid),1744 NULL, o);1745 else1746 ret = check_ok_to_remove(path, len, DT_UNKNOWN, NULL,1747 &st, error_type, o);1748 }1749 free(path);1750 return ret;1751 } else if (lstat(ce->name, &st)) {1752 if (errno != ENOENT)1753 return error_errno("cannot stat '%s'", ce->name);1754 return 0;1755 } else {1756 if (submodule_from_ce(ce))1757 return check_submodule_move_head(ce, oid_to_hex(&ce->oid),1758 NULL, o);17591760 return check_ok_to_remove(ce->name, ce_namelen(ce),1761 ce_to_dtype(ce), ce, &st,1762 error_type, o);1763 }1764}17651766static int verify_absent(const struct cache_entry *ce,1767 enum unpack_trees_error_types error_type,1768 struct unpack_trees_options *o)1769{1770 if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))1771 return 0;1772 return verify_absent_1(ce, error_type, o);1773}17741775static int verify_absent_sparse(const struct cache_entry *ce,1776 enum unpack_trees_error_types error_type,1777 struct unpack_trees_options *o)1778{1779 enum unpack_trees_error_types orphaned_error = error_type;1780 if (orphaned_error == ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN)1781 orphaned_error = ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN;17821783 return verify_absent_1(ce, orphaned_error, o);1784}17851786static int merged_entry(const struct cache_entry *ce,1787 const struct cache_entry *old,1788 struct unpack_trees_options *o)1789{1790 int update = CE_UPDATE;1791 struct cache_entry *merge = dup_entry(ce);17921793 if (!old) {1794 /*1795 * New index entries. In sparse checkout, the following1796 * verify_absent() will be delayed until after1797 * traverse_trees() finishes in unpack_trees(), then:1798 *1799 * - CE_NEW_SKIP_WORKTREE will be computed correctly1800 * - verify_absent() be called again, this time with1801 * correct CE_NEW_SKIP_WORKTREE1802 *1803 * verify_absent() call here does nothing in sparse1804 * checkout (i.e. o->skip_sparse_checkout == 0)1805 */1806 update |= CE_ADDED;1807 merge->ce_flags |= CE_NEW_SKIP_WORKTREE;18081809 if (verify_absent(merge,1810 ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o)) {1811 free(merge);1812 return -1;1813 }1814 invalidate_ce_path(merge, o);18151816 if (submodule_from_ce(ce)) {1817 int ret = check_submodule_move_head(ce, NULL,1818 oid_to_hex(&ce->oid),1819 o);1820 if (ret)1821 return ret;1822 }18231824 } else if (!(old->ce_flags & CE_CONFLICTED)) {1825 /*1826 * See if we can re-use the old CE directly?1827 * That way we get the uptodate stat info.1828 *1829 * This also removes the UPDATE flag on a match; otherwise1830 * we will end up overwriting local changes in the work tree.1831 */1832 if (same(old, merge)) {1833 copy_cache_entry(merge, old);1834 update = 0;1835 } else {1836 if (verify_uptodate(old, o)) {1837 free(merge);1838 return -1;1839 }1840 /* Migrate old flags over */1841 update |= old->ce_flags & (CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);1842 invalidate_ce_path(old, o);1843 }18441845 if (submodule_from_ce(ce)) {1846 int ret = check_submodule_move_head(ce, oid_to_hex(&old->oid),1847 oid_to_hex(&ce->oid),1848 o);1849 if (ret)1850 return ret;1851 }1852 } else {1853 /*1854 * Previously unmerged entry left as an existence1855 * marker by read_index_unmerged();1856 */1857 invalidate_ce_path(old, o);1858 }18591860 do_add_entry(o, merge, update, CE_STAGEMASK);1861 return 1;1862}18631864static int deleted_entry(const struct cache_entry *ce,1865 const struct cache_entry *old,1866 struct unpack_trees_options *o)1867{1868 /* Did it exist in the index? */1869 if (!old) {1870 if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))1871 return -1;1872 return 0;1873 }1874 if (!(old->ce_flags & CE_CONFLICTED) && verify_uptodate(old, o))1875 return -1;1876 add_entry(o, ce, CE_REMOVE, 0);1877 invalidate_ce_path(ce, o);1878 return 1;1879}18801881static int keep_entry(const struct cache_entry *ce,1882 struct unpack_trees_options *o)1883{1884 add_entry(o, ce, 0, 0);1885 return 1;1886}18871888#if DBRT_DEBUG1889static void show_stage_entry(FILE *o,1890 const char *label, const struct cache_entry *ce)1891{1892 if (!ce)1893 fprintf(o, "%s (missing)\n", label);1894 else1895 fprintf(o, "%s%06o %s %d\t%s\n",1896 label,1897 ce->ce_mode,1898 oid_to_hex(&ce->oid),1899 ce_stage(ce),1900 ce->name);1901}1902#endif19031904int threeway_merge(const struct cache_entry * const *stages,1905 struct unpack_trees_options *o)1906{1907 const struct cache_entry *index;1908 const struct cache_entry *head;1909 const struct cache_entry *remote = stages[o->head_idx + 1];1910 int count;1911 int head_match = 0;1912 int remote_match = 0;19131914 int df_conflict_head = 0;1915 int df_conflict_remote = 0;19161917 int any_anc_missing = 0;1918 int no_anc_exists = 1;1919 int i;19201921 for (i = 1; i < o->head_idx; i++) {1922 if (!stages[i] || stages[i] == o->df_conflict_entry)1923 any_anc_missing = 1;1924 else1925 no_anc_exists = 0;1926 }19271928 index = stages[0];1929 head = stages[o->head_idx];19301931 if (head == o->df_conflict_entry) {1932 df_conflict_head = 1;1933 head = NULL;1934 }19351936 if (remote == o->df_conflict_entry) {1937 df_conflict_remote = 1;1938 remote = NULL;1939 }19401941 /*1942 * First, if there's a #16 situation, note that to prevent #131943 * and #14.1944 */1945 if (!same(remote, head)) {1946 for (i = 1; i < o->head_idx; i++) {1947 if (same(stages[i], head)) {1948 head_match = i;1949 }1950 if (same(stages[i], remote)) {1951 remote_match = i;1952 }1953 }1954 }19551956 /*1957 * We start with cases where the index is allowed to match1958 * something other than the head: #14(ALT) and #2ALT, where it1959 * is permitted to match the result instead.1960 */1961 /* #14, #14ALT, #2ALT */1962 if (remote && !df_conflict_head && head_match && !remote_match) {1963 if (index && !same(index, remote) && !same(index, head))1964 return reject_merge(index, o);1965 return merged_entry(remote, index, o);1966 }1967 /*1968 * If we have an entry in the index cache, then we want to1969 * make sure that it matches head.1970 */1971 if (index && !same(index, head))1972 return reject_merge(index, o);19731974 if (head) {1975 /* #5ALT, #15 */1976 if (same(head, remote))1977 return merged_entry(head, index, o);1978 /* #13, #3ALT */1979 if (!df_conflict_remote && remote_match && !head_match)1980 return merged_entry(head, index, o);1981 }19821983 /* #1 */1984 if (!head && !remote && any_anc_missing)1985 return 0;19861987 /*1988 * Under the "aggressive" rule, we resolve mostly trivial1989 * cases that we historically had git-merge-one-file resolve.1990 */1991 if (o->aggressive) {1992 int head_deleted = !head;1993 int remote_deleted = !remote;1994 const struct cache_entry *ce = NULL;19951996 if (index)1997 ce = index;1998 else if (head)1999 ce = head;2000 else if (remote)2001 ce = remote;2002 else {2003 for (i = 1; i < o->head_idx; i++) {2004 if (stages[i] && stages[i] != o->df_conflict_entry) {2005 ce = stages[i];2006 break;2007 }2008 }2009 }20102011 /*2012 * Deleted in both.2013 * Deleted in one and unchanged in the other.2014 */2015 if ((head_deleted && remote_deleted) ||2016 (head_deleted && remote && remote_match) ||2017 (remote_deleted && head && head_match)) {2018 if (index)2019 return deleted_entry(index, index, o);2020 if (ce && !head_deleted) {2021 if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))2022 return -1;2023 }2024 return 0;2025 }2026 /*2027 * Added in both, identically.2028 */2029 if (no_anc_exists && head && remote && same(head, remote))2030 return merged_entry(head, index, o);20312032 }20332034 /* Below are "no merge" cases, which require that the index be2035 * up-to-date to avoid the files getting overwritten with2036 * conflict resolution files.2037 */2038 if (index) {2039 if (verify_uptodate(index, o))2040 return -1;2041 }20422043 o->nontrivial_merge = 1;20442045 /* #2, #3, #4, #6, #7, #9, #10, #11. */2046 count = 0;2047 if (!head_match || !remote_match) {2048 for (i = 1; i < o->head_idx; i++) {2049 if (stages[i] && stages[i] != o->df_conflict_entry) {2050 keep_entry(stages[i], o);2051 count++;2052 break;2053 }2054 }2055 }2056#if DBRT_DEBUG2057 else {2058 fprintf(stderr, "read-tree: warning #16 detected\n");2059 show_stage_entry(stderr, "head ", stages[head_match]);2060 show_stage_entry(stderr, "remote ", stages[remote_match]);2061 }2062#endif2063 if (head) { count += keep_entry(head, o); }2064 if (remote) { count += keep_entry(remote, o); }2065 return count;2066}20672068/*2069 * Two-way merge.2070 *2071 * The rule is to "carry forward" what is in the index without losing2072 * information across a "fast-forward", favoring a successful merge2073 * over a merge failure when it makes sense. For details of the2074 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.2075 *2076 */2077int twoway_merge(const struct cache_entry * const *src,2078 struct unpack_trees_options *o)2079{2080 const struct cache_entry *current = src[0];2081 const struct cache_entry *oldtree = src[1];2082 const struct cache_entry *newtree = src[2];20832084 if (o->merge_size != 2)2085 return error("Cannot do a twoway merge of %d trees",2086 o->merge_size);20872088 if (oldtree == o->df_conflict_entry)2089 oldtree = NULL;2090 if (newtree == o->df_conflict_entry)2091 newtree = NULL;20922093 if (current) {2094 if (current->ce_flags & CE_CONFLICTED) {2095 if (same(oldtree, newtree) || o->reset) {2096 if (!newtree)2097 return deleted_entry(current, current, o);2098 else2099 return merged_entry(newtree, current, o);2100 }2101 return reject_merge(current, o);2102 } else if ((!oldtree && !newtree) || /* 4 and 5 */2103 (!oldtree && newtree &&2104 same(current, newtree)) || /* 6 and 7 */2105 (oldtree && newtree &&2106 same(oldtree, newtree)) || /* 14 and 15 */2107 (oldtree && newtree &&2108 !same(oldtree, newtree) && /* 18 and 19 */2109 same(current, newtree))) {2110 return keep_entry(current, o);2111 } else if (oldtree && !newtree && same(current, oldtree)) {2112 /* 10 or 11 */2113 return deleted_entry(oldtree, current, o);2114 } else if (oldtree && newtree &&2115 same(current, oldtree) && !same(current, newtree)) {2116 /* 20 or 21 */2117 return merged_entry(newtree, current, o);2118 } else2119 return reject_merge(current, o);2120 }2121 else if (newtree) {2122 if (oldtree && !o->initial_checkout) {2123 /*2124 * deletion of the path was staged;2125 */2126 if (same(oldtree, newtree))2127 return 1;2128 return reject_merge(oldtree, o);2129 }2130 return merged_entry(newtree, current, o);2131 }2132 return deleted_entry(oldtree, current, o);2133}21342135/*2136 * Bind merge.2137 *2138 * Keep the index entries at stage0, collapse stage1 but make sure2139 * stage0 does not have anything there.2140 */2141int bind_merge(const struct cache_entry * const *src,2142 struct unpack_trees_options *o)2143{2144 const struct cache_entry *old = src[0];2145 const struct cache_entry *a = src[1];21462147 if (o->merge_size != 1)2148 return error("Cannot do a bind merge of %d trees",2149 o->merge_size);2150 if (a && old)2151 return o->gently ? -1 :2152 error(ERRORMSG(o, ERROR_BIND_OVERLAP),2153 super_prefixed(a->name),2154 super_prefixed(old->name));2155 if (!a)2156 return keep_entry(old, o);2157 else2158 return merged_entry(a, NULL, o);2159}21602161/*2162 * One-way merge.2163 *2164 * The rule is:2165 * - take the stat information from stage0, take the data from stage12166 */2167int oneway_merge(const struct cache_entry * const *src,2168 struct unpack_trees_options *o)2169{2170 const struct cache_entry *old = src[0];2171 const struct cache_entry *a = src[1];21722173 if (o->merge_size != 1)2174 return error("Cannot do a oneway merge of %d trees",2175 o->merge_size);21762177 if (!a || a == o->df_conflict_entry)2178 return deleted_entry(old, old, o);21792180 if (old && same(old, a)) {2181 int update = 0;2182 if (o->reset && o->update && !ce_uptodate(old) && !ce_skip_worktree(old)) {2183 struct stat st;2184 if (lstat(old->name, &st) ||2185 ie_match_stat(o->src_index, old, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE))2186 update |= CE_UPDATE;2187 }2188 if (o->update && S_ISGITLINK(old->ce_mode) &&2189 should_update_submodules() && !verify_uptodate(old, o))2190 update |= CE_UPDATE;2191 add_entry(o, old, update, 0);2192 return 0;2193 }2194 return merged_entry(a, old, o);2195}