1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#define NO_THE_INDEX_COMPATIBILITY_MACROS 7#include"cache.h" 8#include"config.h" 9#include"tempfile.h" 10#include"lockfile.h" 11#include"cache-tree.h" 12#include"refs.h" 13#include"dir.h" 14#include"tree.h" 15#include"commit.h" 16#include"blob.h" 17#include"resolve-undo.h" 18#include"strbuf.h" 19#include"varint.h" 20#include"split-index.h" 21#include"utf8.h" 22 23/* Mask for the name length in ce_flags in the on-disk index */ 24 25#define CE_NAMEMASK (0x0fff) 26 27/* Index extensions. 28 * 29 * The first letter should be 'A'..'Z' for extensions that are not 30 * necessary for a correct operation (i.e. optimization data). 31 * When new extensions are added that _needs_ to be understood in 32 * order to correctly interpret the index file, pick character that 33 * is outside the range, to cause the reader to abort. 34 */ 35 36#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 37#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 38#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 39#define CACHE_EXT_LINK 0x6c696e6b/* "link" */ 40#define CACHE_EXT_UNTRACKED 0x554E5452/* "UNTR" */ 41 42/* changes that can be kept in $GIT_DIR/index (basically all extensions) */ 43#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \ 44 CE_ENTRY_ADDED | CE_ENTRY_REMOVED | CE_ENTRY_CHANGED | \ 45 SPLIT_INDEX_ORDERED | UNTRACKED_CHANGED) 46 47struct index_state the_index; 48static const char*alternate_index_output; 49 50static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 51{ 52 istate->cache[nr] = ce; 53add_name_hash(istate, ce); 54} 55 56static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 57{ 58struct cache_entry *old = istate->cache[nr]; 59 60replace_index_entry_in_base(istate, old, ce); 61remove_name_hash(istate, old); 62free(old); 63set_index_entry(istate, nr, ce); 64 ce->ce_flags |= CE_UPDATE_IN_BASE; 65 istate->cache_changed |= CE_ENTRY_CHANGED; 66} 67 68voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 69{ 70struct cache_entry *old = istate->cache[nr], *new; 71int namelen =strlen(new_name); 72 73new=xmalloc(cache_entry_size(namelen)); 74copy_cache_entry(new, old); 75new->ce_flags &= ~CE_HASHED; 76new->ce_namelen = namelen; 77new->index =0; 78memcpy(new->name, new_name, namelen +1); 79 80cache_tree_invalidate_path(istate, old->name); 81untracked_cache_remove_from_index(istate, old->name); 82remove_index_entry_at(istate, nr); 83add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 84} 85 86voidfill_stat_data(struct stat_data *sd,struct stat *st) 87{ 88 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 89 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 90 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 91 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 92 sd->sd_dev = st->st_dev; 93 sd->sd_ino = st->st_ino; 94 sd->sd_uid = st->st_uid; 95 sd->sd_gid = st->st_gid; 96 sd->sd_size = st->st_size; 97} 98 99intmatch_stat_data(const struct stat_data *sd,struct stat *st) 100{ 101int changed =0; 102 103if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 104 changed |= MTIME_CHANGED; 105if(trust_ctime && check_stat && 106 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 107 changed |= CTIME_CHANGED; 108 109#ifdef USE_NSEC 110if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 111 changed |= MTIME_CHANGED; 112if(trust_ctime && check_stat && 113 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 114 changed |= CTIME_CHANGED; 115#endif 116 117if(check_stat) { 118if(sd->sd_uid != (unsigned int) st->st_uid || 119 sd->sd_gid != (unsigned int) st->st_gid) 120 changed |= OWNER_CHANGED; 121if(sd->sd_ino != (unsigned int) st->st_ino) 122 changed |= INODE_CHANGED; 123} 124 125#ifdef USE_STDEV 126/* 127 * st_dev breaks on network filesystems where different 128 * clients will have different views of what "device" 129 * the filesystem is on 130 */ 131if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 132 changed |= INODE_CHANGED; 133#endif 134 135if(sd->sd_size != (unsigned int) st->st_size) 136 changed |= DATA_CHANGED; 137 138return changed; 139} 140 141/* 142 * This only updates the "non-critical" parts of the directory 143 * cache, ie the parts that aren't tracked by GIT, and only used 144 * to validate the cache. 145 */ 146voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 147{ 148fill_stat_data(&ce->ce_stat_data, st); 149 150if(assume_unchanged) 151 ce->ce_flags |= CE_VALID; 152 153if(S_ISREG(st->st_mode)) 154ce_mark_uptodate(ce); 155} 156 157static intce_compare_data(const struct cache_entry *ce,struct stat *st) 158{ 159int match = -1; 160int fd =git_open_cloexec(ce->name, O_RDONLY); 161 162if(fd >=0) { 163unsigned char sha1[20]; 164if(!index_fd(sha1, fd, st, OBJ_BLOB, ce->name,0)) 165 match =hashcmp(sha1, ce->oid.hash); 166/* index_fd() closed the file descriptor already */ 167} 168return match; 169} 170 171static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 172{ 173int match = -1; 174void*buffer; 175unsigned long size; 176enum object_type type; 177struct strbuf sb = STRBUF_INIT; 178 179if(strbuf_readlink(&sb, ce->name, expected_size)) 180return-1; 181 182 buffer =read_sha1_file(ce->oid.hash, &type, &size); 183if(buffer) { 184if(size == sb.len) 185 match =memcmp(buffer, sb.buf, size); 186free(buffer); 187} 188strbuf_release(&sb); 189return match; 190} 191 192static intce_compare_gitlink(const struct cache_entry *ce) 193{ 194unsigned char sha1[20]; 195 196/* 197 * We don't actually require that the .git directory 198 * under GITLINK directory be a valid git directory. It 199 * might even be missing (in case nobody populated that 200 * sub-project). 201 * 202 * If so, we consider it always to match. 203 */ 204if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 205return0; 206returnhashcmp(sha1, ce->oid.hash); 207} 208 209static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 210{ 211switch(st->st_mode & S_IFMT) { 212case S_IFREG: 213if(ce_compare_data(ce, st)) 214return DATA_CHANGED; 215break; 216case S_IFLNK: 217if(ce_compare_link(ce,xsize_t(st->st_size))) 218return DATA_CHANGED; 219break; 220case S_IFDIR: 221if(S_ISGITLINK(ce->ce_mode)) 222returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 223default: 224return TYPE_CHANGED; 225} 226return0; 227} 228 229static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 230{ 231unsigned int changed =0; 232 233if(ce->ce_flags & CE_REMOVE) 234return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 235 236switch(ce->ce_mode & S_IFMT) { 237case S_IFREG: 238 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 239/* We consider only the owner x bit to be relevant for 240 * "mode changes" 241 */ 242if(trust_executable_bit && 243(0100& (ce->ce_mode ^ st->st_mode))) 244 changed |= MODE_CHANGED; 245break; 246case S_IFLNK: 247if(!S_ISLNK(st->st_mode) && 248(has_symlinks || !S_ISREG(st->st_mode))) 249 changed |= TYPE_CHANGED; 250break; 251case S_IFGITLINK: 252/* We ignore most of the st_xxx fields for gitlinks */ 253if(!S_ISDIR(st->st_mode)) 254 changed |= TYPE_CHANGED; 255else if(ce_compare_gitlink(ce)) 256 changed |= DATA_CHANGED; 257return changed; 258default: 259die("internal error: ce_mode is%o", ce->ce_mode); 260} 261 262 changed |=match_stat_data(&ce->ce_stat_data, st); 263 264/* Racily smudged entry? */ 265if(!ce->ce_stat_data.sd_size) { 266if(!is_empty_blob_sha1(ce->oid.hash)) 267 changed |= DATA_CHANGED; 268} 269 270return changed; 271} 272 273static intis_racy_stat(const struct index_state *istate, 274const struct stat_data *sd) 275{ 276return(istate->timestamp.sec && 277#ifdef USE_NSEC 278/* nanosecond timestamped files can also be racy! */ 279(istate->timestamp.sec < sd->sd_mtime.sec || 280(istate->timestamp.sec == sd->sd_mtime.sec && 281 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 282#else 283 istate->timestamp.sec <= sd->sd_mtime.sec 284#endif 285); 286} 287 288static intis_racy_timestamp(const struct index_state *istate, 289const struct cache_entry *ce) 290{ 291return(!S_ISGITLINK(ce->ce_mode) && 292is_racy_stat(istate, &ce->ce_stat_data)); 293} 294 295intmatch_stat_data_racy(const struct index_state *istate, 296const struct stat_data *sd,struct stat *st) 297{ 298if(is_racy_stat(istate, sd)) 299return MTIME_CHANGED; 300returnmatch_stat_data(sd, st); 301} 302 303intie_match_stat(const struct index_state *istate, 304const struct cache_entry *ce,struct stat *st, 305unsigned int options) 306{ 307unsigned int changed; 308int ignore_valid = options & CE_MATCH_IGNORE_VALID; 309int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 310int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 311 312/* 313 * If it's marked as always valid in the index, it's 314 * valid whatever the checked-out copy says. 315 * 316 * skip-worktree has the same effect with higher precedence 317 */ 318if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 319return0; 320if(!ignore_valid && (ce->ce_flags & CE_VALID)) 321return0; 322 323/* 324 * Intent-to-add entries have not been added, so the index entry 325 * by definition never matches what is in the work tree until it 326 * actually gets added. 327 */ 328if(ce_intent_to_add(ce)) 329return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 330 331 changed =ce_match_stat_basic(ce, st); 332 333/* 334 * Within 1 second of this sequence: 335 * echo xyzzy >file && git-update-index --add file 336 * running this command: 337 * echo frotz >file 338 * would give a falsely clean cache entry. The mtime and 339 * length match the cache, and other stat fields do not change. 340 * 341 * We could detect this at update-index time (the cache entry 342 * being registered/updated records the same time as "now") 343 * and delay the return from git-update-index, but that would 344 * effectively mean we can make at most one commit per second, 345 * which is not acceptable. Instead, we check cache entries 346 * whose mtime are the same as the index file timestamp more 347 * carefully than others. 348 */ 349if(!changed &&is_racy_timestamp(istate, ce)) { 350if(assume_racy_is_modified) 351 changed |= DATA_CHANGED; 352else 353 changed |=ce_modified_check_fs(ce, st); 354} 355 356return changed; 357} 358 359intie_modified(const struct index_state *istate, 360const struct cache_entry *ce, 361struct stat *st,unsigned int options) 362{ 363int changed, changed_fs; 364 365 changed =ie_match_stat(istate, ce, st, options); 366if(!changed) 367return0; 368/* 369 * If the mode or type has changed, there's no point in trying 370 * to refresh the entry - it's not going to match 371 */ 372if(changed & (MODE_CHANGED | TYPE_CHANGED)) 373return changed; 374 375/* 376 * Immediately after read-tree or update-index --cacheinfo, 377 * the length field is zero, as we have never even read the 378 * lstat(2) information once, and we cannot trust DATA_CHANGED 379 * returned by ie_match_stat() which in turn was returned by 380 * ce_match_stat_basic() to signal that the filesize of the 381 * blob changed. We have to actually go to the filesystem to 382 * see if the contents match, and if so, should answer "unchanged". 383 * 384 * The logic does not apply to gitlinks, as ce_match_stat_basic() 385 * already has checked the actual HEAD from the filesystem in the 386 * subproject. If ie_match_stat() already said it is different, 387 * then we know it is. 388 */ 389if((changed & DATA_CHANGED) && 390(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 391return changed; 392 393 changed_fs =ce_modified_check_fs(ce, st); 394if(changed_fs) 395return changed | changed_fs; 396return0; 397} 398 399intbase_name_compare(const char*name1,int len1,int mode1, 400const char*name2,int len2,int mode2) 401{ 402unsigned char c1, c2; 403int len = len1 < len2 ? len1 : len2; 404int cmp; 405 406 cmp =memcmp(name1, name2, len); 407if(cmp) 408return cmp; 409 c1 = name1[len]; 410 c2 = name2[len]; 411if(!c1 &&S_ISDIR(mode1)) 412 c1 ='/'; 413if(!c2 &&S_ISDIR(mode2)) 414 c2 ='/'; 415return(c1 < c2) ? -1: (c1 > c2) ?1:0; 416} 417 418/* 419 * df_name_compare() is identical to base_name_compare(), except it 420 * compares conflicting directory/file entries as equal. Note that 421 * while a directory name compares as equal to a regular file, they 422 * then individually compare _differently_ to a filename that has 423 * a dot after the basename (because '\0' < '.' < '/'). 424 * 425 * This is used by routines that want to traverse the git namespace 426 * but then handle conflicting entries together when possible. 427 */ 428intdf_name_compare(const char*name1,int len1,int mode1, 429const char*name2,int len2,int mode2) 430{ 431int len = len1 < len2 ? len1 : len2, cmp; 432unsigned char c1, c2; 433 434 cmp =memcmp(name1, name2, len); 435if(cmp) 436return cmp; 437/* Directories and files compare equal (same length, same name) */ 438if(len1 == len2) 439return0; 440 c1 = name1[len]; 441if(!c1 &&S_ISDIR(mode1)) 442 c1 ='/'; 443 c2 = name2[len]; 444if(!c2 &&S_ISDIR(mode2)) 445 c2 ='/'; 446if(c1 =='/'&& !c2) 447return0; 448if(c2 =='/'&& !c1) 449return0; 450return c1 - c2; 451} 452 453intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 454{ 455size_t min_len = (len1 < len2) ? len1 : len2; 456int cmp =memcmp(name1, name2, min_len); 457if(cmp) 458return cmp; 459if(len1 < len2) 460return-1; 461if(len1 > len2) 462return1; 463return0; 464} 465 466intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 467{ 468int cmp; 469 470 cmp =name_compare(name1, len1, name2, len2); 471if(cmp) 472return cmp; 473 474if(stage1 < stage2) 475return-1; 476if(stage1 > stage2) 477return1; 478return0; 479} 480 481static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 482{ 483int first, last; 484 485 first =0; 486 last = istate->cache_nr; 487while(last > first) { 488int next = (last + first) >>1; 489struct cache_entry *ce = istate->cache[next]; 490int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 491if(!cmp) 492return next; 493if(cmp <0) { 494 last = next; 495continue; 496} 497 first = next+1; 498} 499return-first-1; 500} 501 502intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 503{ 504returnindex_name_stage_pos(istate, name, namelen,0); 505} 506 507intremove_index_entry_at(struct index_state *istate,int pos) 508{ 509struct cache_entry *ce = istate->cache[pos]; 510 511record_resolve_undo(istate, ce); 512remove_name_hash(istate, ce); 513save_or_free_index_entry(istate, ce); 514 istate->cache_changed |= CE_ENTRY_REMOVED; 515 istate->cache_nr--; 516if(pos >= istate->cache_nr) 517return0; 518memmove(istate->cache + pos, 519 istate->cache + pos +1, 520(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 521return1; 522} 523 524/* 525 * Remove all cache entries marked for removal, that is where 526 * CE_REMOVE is set in ce_flags. This is much more effective than 527 * calling remove_index_entry_at() for each entry to be removed. 528 */ 529voidremove_marked_cache_entries(struct index_state *istate) 530{ 531struct cache_entry **ce_array = istate->cache; 532unsigned int i, j; 533 534for(i = j =0; i < istate->cache_nr; i++) { 535if(ce_array[i]->ce_flags & CE_REMOVE) { 536remove_name_hash(istate, ce_array[i]); 537save_or_free_index_entry(istate, ce_array[i]); 538} 539else 540 ce_array[j++] = ce_array[i]; 541} 542if(j == istate->cache_nr) 543return; 544 istate->cache_changed |= CE_ENTRY_REMOVED; 545 istate->cache_nr = j; 546} 547 548intremove_file_from_index(struct index_state *istate,const char*path) 549{ 550int pos =index_name_pos(istate, path,strlen(path)); 551if(pos <0) 552 pos = -pos-1; 553cache_tree_invalidate_path(istate, path); 554untracked_cache_remove_from_index(istate, path); 555while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 556remove_index_entry_at(istate, pos); 557return0; 558} 559 560static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 561{ 562return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 563} 564 565static intindex_name_pos_also_unmerged(struct index_state *istate, 566const char*path,int namelen) 567{ 568int pos =index_name_pos(istate, path, namelen); 569struct cache_entry *ce; 570 571if(pos >=0) 572return pos; 573 574/* maybe unmerged? */ 575 pos = -1- pos; 576if(pos >= istate->cache_nr || 577compare_name((ce = istate->cache[pos]), path, namelen)) 578return-1; 579 580/* order of preference: stage 2, 1, 3 */ 581if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 582ce_stage((ce = istate->cache[pos +1])) ==2&& 583!compare_name(ce, path, namelen)) 584 pos++; 585return pos; 586} 587 588static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 589{ 590int len =ce_namelen(ce); 591returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 592} 593 594/* 595 * If we add a filename that aliases in the cache, we will use the 596 * name that we already have - but we don't want to update the same 597 * alias twice, because that implies that there were actually two 598 * different files with aliasing names! 599 * 600 * So we use the CE_ADDED flag to verify that the alias was an old 601 * one before we accept it as 602 */ 603static struct cache_entry *create_alias_ce(struct index_state *istate, 604struct cache_entry *ce, 605struct cache_entry *alias) 606{ 607int len; 608struct cache_entry *new; 609 610if(alias->ce_flags & CE_ADDED) 611die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 612 613/* Ok, create the new entry using the name of the existing alias */ 614 len =ce_namelen(alias); 615new=xcalloc(1,cache_entry_size(len)); 616memcpy(new->name, alias->name, len); 617copy_cache_entry(new, ce); 618save_or_free_index_entry(istate, ce); 619return new; 620} 621 622voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 623{ 624unsigned char sha1[20]; 625if(write_sha1_file("",0, blob_type, sha1)) 626die("cannot create an empty blob in the object database"); 627hashcpy(ce->oid.hash, sha1); 628} 629 630intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 631{ 632int size, namelen, was_same; 633 mode_t st_mode = st->st_mode; 634struct cache_entry *ce, *alias; 635unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 636int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 637int pretend = flags & ADD_CACHE_PRETEND; 638int intent_only = flags & ADD_CACHE_INTENT; 639int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 640(intent_only ? ADD_CACHE_NEW_ONLY :0)); 641 642if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 643returnerror("%s: can only add regular files, symbolic links or git-directories", path); 644 645 namelen =strlen(path); 646if(S_ISDIR(st_mode)) { 647while(namelen && path[namelen-1] =='/') 648 namelen--; 649} 650 size =cache_entry_size(namelen); 651 ce =xcalloc(1, size); 652memcpy(ce->name, path, namelen); 653 ce->ce_namelen = namelen; 654if(!intent_only) 655fill_stat_cache_info(ce, st); 656else 657 ce->ce_flags |= CE_INTENT_TO_ADD; 658 659 660if(trust_executable_bit && has_symlinks) { 661 ce->ce_mode =create_ce_mode(st_mode); 662}else{ 663/* If there is an existing entry, pick the mode bits and type 664 * from it, otherwise assume unexecutable regular file. 665 */ 666struct cache_entry *ent; 667int pos =index_name_pos_also_unmerged(istate, path, namelen); 668 669 ent = (0<= pos) ? istate->cache[pos] : NULL; 670 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 671} 672 673/* When core.ignorecase=true, determine if a directory of the same name but differing 674 * case already exists within the Git repository. If it does, ensure the directory 675 * case of the file being added to the repository matches (is folded into) the existing 676 * entry's directory case. 677 */ 678if(ignore_case) { 679adjust_dirname_case(istate, ce->name); 680} 681 682 alias =index_file_exists(istate, ce->name,ce_namelen(ce), ignore_case); 683if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 684/* Nothing changed, really */ 685if(!S_ISGITLINK(alias->ce_mode)) 686ce_mark_uptodate(alias); 687 alias->ce_flags |= CE_ADDED; 688 689free(ce); 690return0; 691} 692if(!intent_only) { 693if(index_path(ce->oid.hash, path, st, HASH_WRITE_OBJECT)) { 694free(ce); 695returnerror("unable to index file%s", path); 696} 697}else 698set_object_name_for_intent_to_add_entry(ce); 699 700if(ignore_case && alias &&different_name(ce, alias)) 701 ce =create_alias_ce(istate, ce, alias); 702 ce->ce_flags |= CE_ADDED; 703 704/* It was suspected to be racily clean, but it turns out to be Ok */ 705 was_same = (alias && 706!ce_stage(alias) && 707!oidcmp(&alias->oid, &ce->oid) && 708 ce->ce_mode == alias->ce_mode); 709 710if(pretend) 711free(ce); 712else if(add_index_entry(istate, ce, add_option)) { 713free(ce); 714returnerror("unable to add%sto index", path); 715} 716if(verbose && !was_same) 717printf("add '%s'\n", path); 718return0; 719} 720 721intadd_file_to_index(struct index_state *istate,const char*path,int flags) 722{ 723struct stat st; 724if(lstat(path, &st)) 725die_errno("unable to stat '%s'", path); 726returnadd_to_index(istate, path, &st, flags); 727} 728 729struct cache_entry *make_cache_entry(unsigned int mode, 730const unsigned char*sha1,const char*path,int stage, 731unsigned int refresh_options) 732{ 733int size, len; 734struct cache_entry *ce, *ret; 735 736if(!verify_path(path)) { 737error("Invalid path '%s'", path); 738return NULL; 739} 740 741 len =strlen(path); 742 size =cache_entry_size(len); 743 ce =xcalloc(1, size); 744 745hashcpy(ce->oid.hash, sha1); 746memcpy(ce->name, path, len); 747 ce->ce_flags =create_ce_flags(stage); 748 ce->ce_namelen = len; 749 ce->ce_mode =create_ce_mode(mode); 750 751 ret =refresh_cache_entry(ce, refresh_options); 752if(ret != ce) 753free(ce); 754return ret; 755} 756 757/* 758 * Chmod an index entry with either +x or -x. 759 * 760 * Returns -1 if the chmod for the particular cache entry failed (if it's 761 * not a regular file), -2 if an invalid flip argument is passed in, 0 762 * otherwise. 763 */ 764intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 765char flip) 766{ 767if(!S_ISREG(ce->ce_mode)) 768return-1; 769switch(flip) { 770case'+': 771 ce->ce_mode |=0111; 772break; 773case'-': 774 ce->ce_mode &= ~0111; 775break; 776default: 777return-2; 778} 779cache_tree_invalidate_path(istate, ce->name); 780 ce->ce_flags |= CE_UPDATE_IN_BASE; 781 istate->cache_changed |= CE_ENTRY_CHANGED; 782 783return0; 784} 785 786intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 787{ 788int len =ce_namelen(a); 789returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 790} 791 792/* 793 * We fundamentally don't like some paths: we don't want 794 * dot or dot-dot anywhere, and for obvious reasons don't 795 * want to recurse into ".git" either. 796 * 797 * Also, we don't want double slashes or slashes at the 798 * end that can make pathnames ambiguous. 799 */ 800static intverify_dotfile(const char*rest) 801{ 802/* 803 * The first character was '.', but that 804 * has already been discarded, we now test 805 * the rest. 806 */ 807 808/* "." is not allowed */ 809if(*rest =='\0'||is_dir_sep(*rest)) 810return0; 811 812switch(*rest) { 813/* 814 * ".git" followed by NUL or slash is bad. This 815 * shares the path end test with the ".." case. 816 */ 817case'g': 818case'G': 819if(rest[1] !='i'&& rest[1] !='I') 820break; 821if(rest[2] !='t'&& rest[2] !='T') 822break; 823 rest +=2; 824/* fallthrough */ 825case'.': 826if(rest[1] =='\0'||is_dir_sep(rest[1])) 827return0; 828} 829return1; 830} 831 832intverify_path(const char*path) 833{ 834char c; 835 836if(has_dos_drive_prefix(path)) 837return0; 838 839goto inside; 840for(;;) { 841if(!c) 842return1; 843if(is_dir_sep(c)) { 844inside: 845if(protect_hfs &&is_hfs_dotgit(path)) 846return0; 847if(protect_ntfs &&is_ntfs_dotgit(path)) 848return0; 849 c = *path++; 850if((c =='.'&& !verify_dotfile(path)) || 851is_dir_sep(c) || c =='\0') 852return0; 853} 854 c = *path++; 855} 856} 857 858/* 859 * Do we have another file that has the beginning components being a 860 * proper superset of the name we're trying to add? 861 */ 862static inthas_file_name(struct index_state *istate, 863const struct cache_entry *ce,int pos,int ok_to_replace) 864{ 865int retval =0; 866int len =ce_namelen(ce); 867int stage =ce_stage(ce); 868const char*name = ce->name; 869 870while(pos < istate->cache_nr) { 871struct cache_entry *p = istate->cache[pos++]; 872 873if(len >=ce_namelen(p)) 874break; 875if(memcmp(name, p->name, len)) 876break; 877if(ce_stage(p) != stage) 878continue; 879if(p->name[len] !='/') 880continue; 881if(p->ce_flags & CE_REMOVE) 882continue; 883 retval = -1; 884if(!ok_to_replace) 885break; 886remove_index_entry_at(istate, --pos); 887} 888return retval; 889} 890 891 892/* 893 * Like strcmp(), but also return the offset of the first change. 894 * If strings are equal, return the length. 895 */ 896intstrcmp_offset(const char*s1,const char*s2,size_t*first_change) 897{ 898size_t k; 899 900if(!first_change) 901returnstrcmp(s1, s2); 902 903for(k =0; s1[k] == s2[k]; k++) 904if(s1[k] =='\0') 905break; 906 907*first_change = k; 908return(unsigned char)s1[k] - (unsigned char)s2[k]; 909} 910 911/* 912 * Do we have another file with a pathname that is a proper 913 * subset of the name we're trying to add? 914 * 915 * That is, is there another file in the index with a path 916 * that matches a sub-directory in the given entry? 917 */ 918static inthas_dir_name(struct index_state *istate, 919const struct cache_entry *ce,int pos,int ok_to_replace) 920{ 921int retval =0; 922int stage =ce_stage(ce); 923const char*name = ce->name; 924const char*slash = name +ce_namelen(ce); 925size_t len_eq_last; 926int cmp_last =0; 927 928/* 929 * We are frequently called during an iteration on a sorted 930 * list of pathnames and while building a new index. Therefore, 931 * there is a high probability that this entry will eventually 932 * be appended to the index, rather than inserted in the middle. 933 * If we can confirm that, we can avoid binary searches on the 934 * components of the pathname. 935 * 936 * Compare the entry's full path with the last path in the index. 937 */ 938if(istate->cache_nr >0) { 939 cmp_last =strcmp_offset(name, 940 istate->cache[istate->cache_nr -1]->name, 941&len_eq_last); 942if(cmp_last >0) { 943if(len_eq_last ==0) { 944/* 945 * The entry sorts AFTER the last one in the 946 * index and their paths have no common prefix, 947 * so there cannot be a F/D conflict. 948 */ 949return retval; 950}else{ 951/* 952 * The entry sorts AFTER the last one in the 953 * index, but has a common prefix. Fall through 954 * to the loop below to disect the entry's path 955 * and see where the difference is. 956 */ 957} 958}else if(cmp_last ==0) { 959/* 960 * The entry exactly matches the last one in the 961 * index, but because of multiple stage and CE_REMOVE 962 * items, we fall through and let the regular search 963 * code handle it. 964 */ 965} 966} 967 968for(;;) { 969size_t len; 970 971for(;;) { 972if(*--slash =='/') 973break; 974if(slash <= ce->name) 975return retval; 976} 977 len = slash - name; 978 979if(cmp_last >0) { 980/* 981 * (len + 1) is a directory boundary (including 982 * the trailing slash). And since the loop is 983 * decrementing "slash", the first iteration is 984 * the longest directory prefix; subsequent 985 * iterations consider parent directories. 986 */ 987 988if(len +1<= len_eq_last) { 989/* 990 * The directory prefix (including the trailing 991 * slash) also appears as a prefix in the last 992 * entry, so the remainder cannot collide (because 993 * strcmp said the whole path was greater). 994 * 995 * EQ: last: xxx/A 996 * this: xxx/B 997 * 998 * LT: last: xxx/file_A 999 * this: xxx/file_B1000 */1001return retval;1002}10031004if(len > len_eq_last) {1005/*1006 * This part of the directory prefix (excluding1007 * the trailing slash) is longer than the known1008 * equal portions, so this sub-directory cannot1009 * collide with a file.1010 *1011 * GT: last: xxxA1012 * this: xxxB/file1013 */1014return retval;1015}10161017if(istate->cache_nr >0&&1018ce_namelen(istate->cache[istate->cache_nr -1]) > len) {1019/*1020 * The directory prefix lines up with part of1021 * a longer file or directory name, but sorts1022 * after it, so this sub-directory cannot1023 * collide with a file.1024 *1025 * last: xxx/yy-file (because '-' sorts before '/')1026 * this: xxx/yy/abc1027 */1028return retval;1029}10301031/*1032 * This is a possible collision. Fall through and1033 * let the regular search code handle it.1034 *1035 * last: xxx1036 * this: xxx/file1037 */1038}10391040 pos =index_name_stage_pos(istate, name, len, stage);1041if(pos >=0) {1042/*1043 * Found one, but not so fast. This could1044 * be a marker that says "I was here, but1045 * I am being removed". Such an entry is1046 * not a part of the resulting tree, and1047 * it is Ok to have a directory at the same1048 * path.1049 */1050if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) {1051 retval = -1;1052if(!ok_to_replace)1053break;1054remove_index_entry_at(istate, pos);1055continue;1056}1057}1058else1059 pos = -pos-1;10601061/*1062 * Trivial optimization: if we find an entry that1063 * already matches the sub-directory, then we know1064 * we're ok, and we can exit.1065 */1066while(pos < istate->cache_nr) {1067struct cache_entry *p = istate->cache[pos];1068if((ce_namelen(p) <= len) ||1069(p->name[len] !='/') ||1070memcmp(p->name, name, len))1071break;/* not our subdirectory */1072if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))1073/*1074 * p is at the same stage as our entry, and1075 * is a subdirectory of what we are looking1076 * at, so we cannot have conflicts at our1077 * level or anything shorter.1078 */1079return retval;1080 pos++;1081}1082}1083return retval;1084}10851086/* We may be in a situation where we already have path/file and path1087 * is being added, or we already have path and path/file is being1088 * added. Either one would result in a nonsense tree that has path1089 * twice when git-write-tree tries to write it out. Prevent it.1090 *1091 * If ok-to-replace is specified, we remove the conflicting entries1092 * from the cache so the caller should recompute the insert position.1093 * When this happens, we return non-zero.1094 */1095static intcheck_file_directory_conflict(struct index_state *istate,1096const struct cache_entry *ce,1097int pos,int ok_to_replace)1098{1099int retval;11001101/*1102 * When ce is an "I am going away" entry, we allow it to be added1103 */1104if(ce->ce_flags & CE_REMOVE)1105return0;11061107/*1108 * We check if the path is a sub-path of a subsequent pathname1109 * first, since removing those will not change the position1110 * in the array.1111 */1112 retval =has_file_name(istate, ce, pos, ok_to_replace);11131114/*1115 * Then check if the path might have a clashing sub-directory1116 * before it.1117 */1118return retval +has_dir_name(istate, ce, pos, ok_to_replace);1119}11201121static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1122{1123int pos;1124int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1125int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1126int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1127int new_only = option & ADD_CACHE_NEW_ONLY;11281129if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1130cache_tree_invalidate_path(istate, ce->name);11311132/*1133 * If this entry's path sorts after the last entry in the index,1134 * we can avoid searching for it.1135 */1136if(istate->cache_nr >0&&1137strcmp(ce->name, istate->cache[istate->cache_nr -1]->name) >0)1138 pos = -istate->cache_nr -1;1139else1140 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));11411142/* existing match? Just replace it. */1143if(pos >=0) {1144if(!new_only)1145replace_index_entry(istate, pos, ce);1146return0;1147}1148 pos = -pos-1;11491150if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1151untracked_cache_add_to_index(istate, ce->name);11521153/*1154 * Inserting a merged entry ("stage 0") into the index1155 * will always replace all non-merged entries..1156 */1157if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1158while(ce_same_name(istate->cache[pos], ce)) {1159 ok_to_add =1;1160if(!remove_index_entry_at(istate, pos))1161break;1162}1163}11641165if(!ok_to_add)1166return-1;1167if(!verify_path(ce->name))1168returnerror("Invalid path '%s'", ce->name);11691170if(!skip_df_check &&1171check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1172if(!ok_to_replace)1173returnerror("'%s' appears as both a file and as a directory",1174 ce->name);1175 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1176 pos = -pos-1;1177}1178return pos +1;1179}11801181intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1182{1183int pos;11841185if(option & ADD_CACHE_JUST_APPEND)1186 pos = istate->cache_nr;1187else{1188int ret;1189 ret =add_index_entry_with_check(istate, ce, option);1190if(ret <=0)1191return ret;1192 pos = ret -1;1193}11941195/* Make sure the array is big enough .. */1196ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);11971198/* Add it in.. */1199 istate->cache_nr++;1200if(istate->cache_nr > pos +1)1201memmove(istate->cache + pos +1,1202 istate->cache + pos,1203(istate->cache_nr - pos -1) *sizeof(ce));1204set_index_entry(istate, pos, ce);1205 istate->cache_changed |= CE_ENTRY_ADDED;1206return0;1207}12081209/*1210 * "refresh" does not calculate a new sha1 file or bring the1211 * cache up-to-date for mode/content changes. But what it1212 * _does_ do is to "re-match" the stat information of a file1213 * with the cache, so that you can refresh the cache for a1214 * file that hasn't been changed but where the stat entry is1215 * out of date.1216 *1217 * For example, you'd want to do this after doing a "git-read-tree",1218 * to link up the stat cache details with the proper files.1219 */1220static struct cache_entry *refresh_cache_ent(struct index_state *istate,1221struct cache_entry *ce,1222unsigned int options,int*err,1223int*changed_ret)1224{1225struct stat st;1226struct cache_entry *updated;1227int changed, size;1228int refresh = options & CE_MATCH_REFRESH;1229int ignore_valid = options & CE_MATCH_IGNORE_VALID;1230int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1231int ignore_missing = options & CE_MATCH_IGNORE_MISSING;12321233if(!refresh ||ce_uptodate(ce))1234return ce;12351236/*1237 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1238 * that the change to the work tree does not matter and told1239 * us not to worry.1240 */1241if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1242ce_mark_uptodate(ce);1243return ce;1244}1245if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1246ce_mark_uptodate(ce);1247return ce;1248}12491250if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1251if(ignore_missing)1252return ce;1253if(err)1254*err = ENOENT;1255return NULL;1256}12571258if(lstat(ce->name, &st) <0) {1259if(ignore_missing && errno == ENOENT)1260return ce;1261if(err)1262*err = errno;1263return NULL;1264}12651266 changed =ie_match_stat(istate, ce, &st, options);1267if(changed_ret)1268*changed_ret = changed;1269if(!changed) {1270/*1271 * The path is unchanged. If we were told to ignore1272 * valid bit, then we did the actual stat check and1273 * found that the entry is unmodified. If the entry1274 * is not marked VALID, this is the place to mark it1275 * valid again, under "assume unchanged" mode.1276 */1277if(ignore_valid && assume_unchanged &&1278!(ce->ce_flags & CE_VALID))1279;/* mark this one VALID again */1280else{1281/*1282 * We do not mark the index itself "modified"1283 * because CE_UPTODATE flag is in-core only;1284 * we are not going to write this change out.1285 */1286if(!S_ISGITLINK(ce->ce_mode))1287ce_mark_uptodate(ce);1288return ce;1289}1290}12911292if(ie_modified(istate, ce, &st, options)) {1293if(err)1294*err = EINVAL;1295return NULL;1296}12971298 size =ce_size(ce);1299 updated =xmalloc(size);1300memcpy(updated, ce, size);1301fill_stat_cache_info(updated, &st);1302/*1303 * If ignore_valid is not set, we should leave CE_VALID bit1304 * alone. Otherwise, paths marked with --no-assume-unchanged1305 * (i.e. things to be edited) will reacquire CE_VALID bit1306 * automatically, which is not really what we want.1307 */1308if(!ignore_valid && assume_unchanged &&1309!(ce->ce_flags & CE_VALID))1310 updated->ce_flags &= ~CE_VALID;13111312/* istate->cache_changed is updated in the caller */1313return updated;1314}13151316static voidshow_file(const char* fmt,const char* name,int in_porcelain,1317int* first,const char*header_msg)1318{1319if(in_porcelain && *first && header_msg) {1320printf("%s\n", header_msg);1321*first =0;1322}1323printf(fmt, name);1324}13251326intrefresh_index(struct index_state *istate,unsigned int flags,1327const struct pathspec *pathspec,1328char*seen,const char*header_msg)1329{1330int i;1331int has_errors =0;1332int really = (flags & REFRESH_REALLY) !=0;1333int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1334int quiet = (flags & REFRESH_QUIET) !=0;1335int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1336int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1337int first =1;1338int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1339unsigned int options = (CE_MATCH_REFRESH |1340(really ? CE_MATCH_IGNORE_VALID :0) |1341(not_new ? CE_MATCH_IGNORE_MISSING :0));1342const char*modified_fmt;1343const char*deleted_fmt;1344const char*typechange_fmt;1345const char*added_fmt;1346const char*unmerged_fmt;13471348 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1349 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1350 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1351 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1352 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1353for(i =0; i < istate->cache_nr; i++) {1354struct cache_entry *ce, *new;1355int cache_errno =0;1356int changed =0;1357int filtered =0;13581359 ce = istate->cache[i];1360if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1361continue;13621363if(pathspec && !ce_path_match(ce, pathspec, seen))1364 filtered =1;13651366if(ce_stage(ce)) {1367while((i < istate->cache_nr) &&1368!strcmp(istate->cache[i]->name, ce->name))1369 i++;1370 i--;1371if(allow_unmerged)1372continue;1373if(!filtered)1374show_file(unmerged_fmt, ce->name, in_porcelain,1375&first, header_msg);1376 has_errors =1;1377continue;1378}13791380if(filtered)1381continue;13821383new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1384if(new== ce)1385continue;1386if(!new) {1387const char*fmt;13881389if(really && cache_errno == EINVAL) {1390/* If we are doing --really-refresh that1391 * means the index is not valid anymore.1392 */1393 ce->ce_flags &= ~CE_VALID;1394 ce->ce_flags |= CE_UPDATE_IN_BASE;1395 istate->cache_changed |= CE_ENTRY_CHANGED;1396}1397if(quiet)1398continue;13991400if(cache_errno == ENOENT)1401 fmt = deleted_fmt;1402else if(ce_intent_to_add(ce))1403 fmt = added_fmt;/* must be before other checks */1404else if(changed & TYPE_CHANGED)1405 fmt = typechange_fmt;1406else1407 fmt = modified_fmt;1408show_file(fmt,1409 ce->name, in_porcelain, &first, header_msg);1410 has_errors =1;1411continue;1412}14131414replace_index_entry(istate, i,new);1415}1416return has_errors;1417}14181419struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1420unsigned int options)1421{1422returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1423}142414251426/*****************************************************************1427 * Index File I/O1428 *****************************************************************/14291430#define INDEX_FORMAT_DEFAULT 314311432static unsigned intget_index_format_default(void)1433{1434char*envversion =getenv("GIT_INDEX_VERSION");1435char*endp;1436int value;1437unsigned int version = INDEX_FORMAT_DEFAULT;14381439if(!envversion) {1440if(!git_config_get_int("index.version", &value))1441 version = value;1442if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1443warning(_("index.version set, but the value is invalid.\n"1444"Using version%i"), INDEX_FORMAT_DEFAULT);1445return INDEX_FORMAT_DEFAULT;1446}1447return version;1448}14491450 version =strtoul(envversion, &endp,10);1451if(*endp ||1452 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1453warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1454"Using version%i"), INDEX_FORMAT_DEFAULT);1455 version = INDEX_FORMAT_DEFAULT;1456}1457return version;1458}14591460/*1461 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1462 * Again - this is just a (very strong in practice) heuristic that1463 * the inode hasn't changed.1464 *1465 * We save the fields in big-endian order to allow using the1466 * index file over NFS transparently.1467 */1468struct ondisk_cache_entry {1469struct cache_time ctime;1470struct cache_time mtime;1471uint32_t dev;1472uint32_t ino;1473uint32_t mode;1474uint32_t uid;1475uint32_t gid;1476uint32_t size;1477unsigned char sha1[20];1478uint16_t flags;1479char name[FLEX_ARRAY];/* more */1480};14811482/*1483 * This struct is used when CE_EXTENDED bit is 11484 * The struct must match ondisk_cache_entry exactly from1485 * ctime till flags1486 */1487struct ondisk_cache_entry_extended {1488struct cache_time ctime;1489struct cache_time mtime;1490uint32_t dev;1491uint32_t ino;1492uint32_t mode;1493uint32_t uid;1494uint32_t gid;1495uint32_t size;1496unsigned char sha1[20];1497uint16_t flags;1498uint16_t flags2;1499char name[FLEX_ARRAY];/* more */1500};15011502/* These are only used for v3 or lower */1503#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1504#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1505#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1506#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1507 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1508 ondisk_cache_entry_size(ce_namelen(ce)))15091510/* Allow fsck to force verification of the index checksum. */1511int verify_index_checksum;15121513static intverify_hdr(struct cache_header *hdr,unsigned long size)1514{1515 git_SHA_CTX c;1516unsigned char sha1[20];1517int hdr_version;15181519if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1520returnerror("bad signature");1521 hdr_version =ntohl(hdr->hdr_version);1522if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1523returnerror("bad index version%d", hdr_version);15241525if(!verify_index_checksum)1526return0;15271528git_SHA1_Init(&c);1529git_SHA1_Update(&c, hdr, size -20);1530git_SHA1_Final(sha1, &c);1531if(hashcmp(sha1, (unsigned char*)hdr + size -20))1532returnerror("bad index file sha1 signature");1533return0;1534}15351536static intread_index_extension(struct index_state *istate,1537const char*ext,void*data,unsigned long sz)1538{1539switch(CACHE_EXT(ext)) {1540case CACHE_EXT_TREE:1541 istate->cache_tree =cache_tree_read(data, sz);1542break;1543case CACHE_EXT_RESOLVE_UNDO:1544 istate->resolve_undo =resolve_undo_read(data, sz);1545break;1546case CACHE_EXT_LINK:1547if(read_link_extension(istate, data, sz))1548return-1;1549break;1550case CACHE_EXT_UNTRACKED:1551 istate->untracked =read_untracked_extension(data, sz);1552break;1553default:1554if(*ext <'A'||'Z'< *ext)1555returnerror("index uses %.4s extension, which we do not understand",1556 ext);1557fprintf(stderr,"ignoring %.4s extension\n", ext);1558break;1559}1560return0;1561}15621563inthold_locked_index(struct lock_file *lk,int lock_flags)1564{1565returnhold_lock_file_for_update(lk,get_index_file(), lock_flags);1566}15671568intread_index(struct index_state *istate)1569{1570returnread_index_from(istate,get_index_file());1571}15721573static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1574unsigned int flags,1575const char*name,1576size_t len)1577{1578struct cache_entry *ce =xmalloc(cache_entry_size(len));15791580 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1581 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1582 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1583 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1584 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1585 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1586 ce->ce_mode =get_be32(&ondisk->mode);1587 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1588 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1589 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1590 ce->ce_flags = flags & ~CE_NAMEMASK;1591 ce->ce_namelen = len;1592 ce->index =0;1593hashcpy(ce->oid.hash, ondisk->sha1);1594memcpy(ce->name, name, len);1595 ce->name[len] ='\0';1596return ce;1597}15981599/*1600 * Adjacent cache entries tend to share the leading paths, so it makes1601 * sense to only store the differences in later entries. In the v41602 * on-disk format of the index, each on-disk cache entry stores the1603 * number of bytes to be stripped from the end of the previous name,1604 * and the bytes to append to the result, to come up with its name.1605 */1606static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1607{1608const unsigned char*ep, *cp = (const unsigned char*)cp_;1609size_t len =decode_varint(&cp);16101611if(name->len < len)1612die("malformed name field in the index");1613strbuf_remove(name, name->len - len, len);1614for(ep = cp; *ep; ep++)1615;/* find the end */1616strbuf_add(name, cp, ep - cp);1617return(const char*)ep +1- cp_;1618}16191620static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1621unsigned long*ent_size,1622struct strbuf *previous_name)1623{1624struct cache_entry *ce;1625size_t len;1626const char*name;1627unsigned int flags;16281629/* On-disk flags are just 16 bits */1630 flags =get_be16(&ondisk->flags);1631 len = flags & CE_NAMEMASK;16321633if(flags & CE_EXTENDED) {1634struct ondisk_cache_entry_extended *ondisk2;1635int extended_flags;1636 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1637 extended_flags =get_be16(&ondisk2->flags2) <<16;1638/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1639if(extended_flags & ~CE_EXTENDED_FLAGS)1640die("Unknown index entry format%08x", extended_flags);1641 flags |= extended_flags;1642 name = ondisk2->name;1643}1644else1645 name = ondisk->name;16461647if(!previous_name) {1648/* v3 and earlier */1649if(len == CE_NAMEMASK)1650 len =strlen(name);1651 ce =cache_entry_from_ondisk(ondisk, flags, name, len);16521653*ent_size =ondisk_ce_size(ce);1654}else{1655unsigned long consumed;1656 consumed =expand_name_field(previous_name, name);1657 ce =cache_entry_from_ondisk(ondisk, flags,1658 previous_name->buf,1659 previous_name->len);16601661*ent_size = (name - ((char*)ondisk)) + consumed;1662}1663return ce;1664}16651666static voidcheck_ce_order(struct index_state *istate)1667{1668unsigned int i;16691670for(i =1; i < istate->cache_nr; i++) {1671struct cache_entry *ce = istate->cache[i -1];1672struct cache_entry *next_ce = istate->cache[i];1673int name_compare =strcmp(ce->name, next_ce->name);16741675if(0< name_compare)1676die("unordered stage entries in index");1677if(!name_compare) {1678if(!ce_stage(ce))1679die("multiple stage entries for merged file '%s'",1680 ce->name);1681if(ce_stage(ce) >ce_stage(next_ce))1682die("unordered stage entries for '%s'",1683 ce->name);1684}1685}1686}16871688static voidtweak_untracked_cache(struct index_state *istate)1689{1690switch(git_config_get_untracked_cache()) {1691case-1:/* keep: do nothing */1692break;1693case0:/* false */1694remove_untracked_cache(istate);1695break;1696case1:/* true */1697add_untracked_cache(istate);1698break;1699default:/* unknown value: do nothing */1700break;1701}1702}17031704static voidtweak_split_index(struct index_state *istate)1705{1706switch(git_config_get_split_index()) {1707case-1:/* unset: do nothing */1708break;1709case0:/* false */1710remove_split_index(istate);1711break;1712case1:/* true */1713add_split_index(istate);1714break;1715default:/* unknown value: do nothing */1716break;1717}1718}17191720static voidpost_read_index_from(struct index_state *istate)1721{1722check_ce_order(istate);1723tweak_untracked_cache(istate);1724tweak_split_index(istate);1725}17261727/* remember to discard_cache() before reading a different cache! */1728intdo_read_index(struct index_state *istate,const char*path,int must_exist)1729{1730int fd, i;1731struct stat st;1732unsigned long src_offset;1733struct cache_header *hdr;1734void*mmap;1735size_t mmap_size;1736struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17371738if(istate->initialized)1739return istate->cache_nr;17401741 istate->timestamp.sec =0;1742 istate->timestamp.nsec =0;1743 fd =open(path, O_RDONLY);1744if(fd <0) {1745if(!must_exist && errno == ENOENT)1746return0;1747die_errno("%s: index file open failed", path);1748}17491750if(fstat(fd, &st))1751die_errno("cannot stat the open index");17521753 mmap_size =xsize_t(st.st_size);1754if(mmap_size <sizeof(struct cache_header) +20)1755die("index file smaller than expected");17561757 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);1758if(mmap == MAP_FAILED)1759die_errno("unable to map index file");1760close(fd);17611762 hdr = mmap;1763if(verify_hdr(hdr, mmap_size) <0)1764goto unmap;17651766hashcpy(istate->sha1, (const unsigned char*)hdr + mmap_size -20);1767 istate->version =ntohl(hdr->hdr_version);1768 istate->cache_nr =ntohl(hdr->hdr_entries);1769 istate->cache_alloc =alloc_nr(istate->cache_nr);1770 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1771 istate->initialized =1;17721773if(istate->version ==4)1774 previous_name = &previous_name_buf;1775else1776 previous_name = NULL;17771778 src_offset =sizeof(*hdr);1779for(i =0; i < istate->cache_nr; i++) {1780struct ondisk_cache_entry *disk_ce;1781struct cache_entry *ce;1782unsigned long consumed;17831784 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1785 ce =create_from_disk(disk_ce, &consumed, previous_name);1786set_index_entry(istate, i, ce);17871788 src_offset += consumed;1789}1790strbuf_release(&previous_name_buf);1791 istate->timestamp.sec = st.st_mtime;1792 istate->timestamp.nsec =ST_MTIME_NSEC(st);17931794while(src_offset <= mmap_size -20-8) {1795/* After an array of active_nr index entries,1796 * there can be arbitrary number of extended1797 * sections, each of which is prefixed with1798 * extension name (4-byte) and section length1799 * in 4-byte network byte order.1800 */1801uint32_t extsize;1802memcpy(&extsize, (char*)mmap + src_offset +4,4);1803 extsize =ntohl(extsize);1804if(read_index_extension(istate,1805(const char*) mmap + src_offset,1806(char*) mmap + src_offset +8,1807 extsize) <0)1808goto unmap;1809 src_offset +=8;1810 src_offset += extsize;1811}1812munmap(mmap, mmap_size);1813return istate->cache_nr;18141815unmap:1816munmap(mmap, mmap_size);1817die("index file corrupt");1818}18191820/*1821 * Signal that the shared index is used by updating its mtime.1822 *1823 * This way, shared index can be removed if they have not been used1824 * for some time.1825 */1826static voidfreshen_shared_index(char*base_sha1_hex,int warn)1827{1828char*shared_index =git_pathdup("sharedindex.%s", base_sha1_hex);1829if(!check_and_freshen_file(shared_index,1) && warn)1830warning("could not freshen shared index '%s'", shared_index);1831free(shared_index);1832}18331834intread_index_from(struct index_state *istate,const char*path)1835{1836struct split_index *split_index;1837int ret;1838char*base_sha1_hex;1839const char*base_path;18401841/* istate->initialized covers both .git/index and .git/sharedindex.xxx */1842if(istate->initialized)1843return istate->cache_nr;18441845 ret =do_read_index(istate, path,0);18461847 split_index = istate->split_index;1848if(!split_index ||is_null_sha1(split_index->base_sha1)) {1849post_read_index_from(istate);1850return ret;1851}18521853if(split_index->base)1854discard_index(split_index->base);1855else1856 split_index->base =xcalloc(1,sizeof(*split_index->base));18571858 base_sha1_hex =sha1_to_hex(split_index->base_sha1);1859 base_path =git_path("sharedindex.%s", base_sha1_hex);1860 ret =do_read_index(split_index->base, base_path,1);1861if(hashcmp(split_index->base_sha1, split_index->base->sha1))1862die("broken index, expect%sin%s, got%s",1863 base_sha1_hex, base_path,1864sha1_to_hex(split_index->base->sha1));18651866freshen_shared_index(base_sha1_hex,0);1867merge_base_index(istate);1868post_read_index_from(istate);1869return ret;1870}18711872intis_index_unborn(struct index_state *istate)1873{1874return(!istate->cache_nr && !istate->timestamp.sec);1875}18761877intdiscard_index(struct index_state *istate)1878{1879int i;18801881for(i =0; i < istate->cache_nr; i++) {1882if(istate->cache[i]->index &&1883 istate->split_index &&1884 istate->split_index->base &&1885 istate->cache[i]->index <= istate->split_index->base->cache_nr &&1886 istate->cache[i] == istate->split_index->base->cache[istate->cache[i]->index -1])1887continue;1888free(istate->cache[i]);1889}1890resolve_undo_clear_index(istate);1891 istate->cache_nr =0;1892 istate->cache_changed =0;1893 istate->timestamp.sec =0;1894 istate->timestamp.nsec =0;1895free_name_hash(istate);1896cache_tree_free(&(istate->cache_tree));1897 istate->initialized =0;1898free(istate->cache);1899 istate->cache = NULL;1900 istate->cache_alloc =0;1901discard_split_index(istate);1902free_untracked_cache(istate->untracked);1903 istate->untracked = NULL;1904return0;1905}19061907intunmerged_index(const struct index_state *istate)1908{1909int i;1910for(i =0; i < istate->cache_nr; i++) {1911if(ce_stage(istate->cache[i]))1912return1;1913}1914return0;1915}19161917#define WRITE_BUFFER_SIZE 81921918static unsigned char write_buffer[WRITE_BUFFER_SIZE];1919static unsigned long write_buffer_len;19201921static intce_write_flush(git_SHA_CTX *context,int fd)1922{1923unsigned int buffered = write_buffer_len;1924if(buffered) {1925git_SHA1_Update(context, write_buffer, buffered);1926if(write_in_full(fd, write_buffer, buffered) != buffered)1927return-1;1928 write_buffer_len =0;1929}1930return0;1931}19321933static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1934{1935while(len) {1936unsigned int buffered = write_buffer_len;1937unsigned int partial = WRITE_BUFFER_SIZE - buffered;1938if(partial > len)1939 partial = len;1940memcpy(write_buffer + buffered, data, partial);1941 buffered += partial;1942if(buffered == WRITE_BUFFER_SIZE) {1943 write_buffer_len = buffered;1944if(ce_write_flush(context, fd))1945return-1;1946 buffered =0;1947}1948 write_buffer_len = buffered;1949 len -= partial;1950 data = (char*) data + partial;1951}1952return0;1953}19541955static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1956unsigned int ext,unsigned int sz)1957{1958 ext =htonl(ext);1959 sz =htonl(sz);1960return((ce_write(context, fd, &ext,4) <0) ||1961(ce_write(context, fd, &sz,4) <0)) ? -1:0;1962}19631964static intce_flush(git_SHA_CTX *context,int fd,unsigned char*sha1)1965{1966unsigned int left = write_buffer_len;19671968if(left) {1969 write_buffer_len =0;1970git_SHA1_Update(context, write_buffer, left);1971}19721973/* Flush first if not enough space for SHA1 signature */1974if(left +20> WRITE_BUFFER_SIZE) {1975if(write_in_full(fd, write_buffer, left) != left)1976return-1;1977 left =0;1978}19791980/* Append the SHA1 signature at the end */1981git_SHA1_Final(write_buffer + left, context);1982hashcpy(sha1, write_buffer + left);1983 left +=20;1984return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1985}19861987static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1988{1989/*1990 * The only thing we care about in this function is to smudge the1991 * falsely clean entry due to touch-update-touch race, so we leave1992 * everything else as they are. We are called for entries whose1993 * ce_stat_data.sd_mtime match the index file mtime.1994 *1995 * Note that this actually does not do much for gitlinks, for1996 * which ce_match_stat_basic() always goes to the actual1997 * contents. The caller checks with is_racy_timestamp() which1998 * always says "no" for gitlinks, so we are not called for them ;-)1999 */2000struct stat st;20012002if(lstat(ce->name, &st) <0)2003return;2004if(ce_match_stat_basic(ce, &st))2005return;2006if(ce_modified_check_fs(ce, &st)) {2007/* This is "racily clean"; smudge it. Note that this2008 * is a tricky code. At first glance, it may appear2009 * that it can break with this sequence:2010 *2011 * $ echo xyzzy >frotz2012 * $ git-update-index --add frotz2013 * $ : >frotz2014 * $ sleep 32015 * $ echo filfre >nitfol2016 * $ git-update-index --add nitfol2017 *2018 * but it does not. When the second update-index runs,2019 * it notices that the entry "frotz" has the same timestamp2020 * as index, and if we were to smudge it by resetting its2021 * size to zero here, then the object name recorded2022 * in index is the 6-byte file but the cached stat information2023 * becomes zero --- which would then match what we would2024 * obtain from the filesystem next time we stat("frotz").2025 *2026 * However, the second update-index, before calling2027 * this function, notices that the cached size is 62028 * bytes and what is on the filesystem is an empty2029 * file, and never calls us, so the cached size information2030 * for "frotz" stays 6 which does not match the filesystem.2031 */2032 ce->ce_stat_data.sd_size =0;2033}2034}20352036/* Copy miscellaneous fields but not the name */2037static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,2038struct cache_entry *ce)2039{2040short flags;20412042 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);2043 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);2044 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);2045 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);2046 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);2047 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);2048 ondisk->mode =htonl(ce->ce_mode);2049 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);2050 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);2051 ondisk->size =htonl(ce->ce_stat_data.sd_size);2052hashcpy(ondisk->sha1, ce->oid.hash);20532054 flags = ce->ce_flags & ~CE_NAMEMASK;2055 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));2056 ondisk->flags =htons(flags);2057if(ce->ce_flags & CE_EXTENDED) {2058struct ondisk_cache_entry_extended *ondisk2;2059 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;2060 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);2061return ondisk2->name;2062}2063else{2064return ondisk->name;2065}2066}20672068static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,2069struct strbuf *previous_name)2070{2071int size;2072struct ondisk_cache_entry *ondisk;2073int saved_namelen = saved_namelen;/* compiler workaround */2074char*name;2075int result;20762077if(ce->ce_flags & CE_STRIP_NAME) {2078 saved_namelen =ce_namelen(ce);2079 ce->ce_namelen =0;2080}20812082if(!previous_name) {2083 size =ondisk_ce_size(ce);2084 ondisk =xcalloc(1, size);2085 name =copy_cache_entry_to_ondisk(ondisk, ce);2086memcpy(name, ce->name,ce_namelen(ce));2087}else{2088int common, to_remove, prefix_size;2089unsigned char to_remove_vi[16];2090for(common =0;2091(ce->name[common] &&2092 common < previous_name->len &&2093 ce->name[common] == previous_name->buf[common]);2094 common++)2095;/* still matching */2096 to_remove = previous_name->len - common;2097 prefix_size =encode_varint(to_remove, to_remove_vi);20982099if(ce->ce_flags & CE_EXTENDED)2100 size =offsetof(struct ondisk_cache_entry_extended, name);2101else2102 size =offsetof(struct ondisk_cache_entry, name);2103 size += prefix_size + (ce_namelen(ce) - common +1);21042105 ondisk =xcalloc(1, size);2106 name =copy_cache_entry_to_ondisk(ondisk, ce);2107memcpy(name, to_remove_vi, prefix_size);2108memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);21092110strbuf_splice(previous_name, common, to_remove,2111 ce->name + common,ce_namelen(ce) - common);2112}2113if(ce->ce_flags & CE_STRIP_NAME) {2114 ce->ce_namelen = saved_namelen;2115 ce->ce_flags &= ~CE_STRIP_NAME;2116}21172118 result =ce_write(c, fd, ondisk, size);2119free(ondisk);2120return result;2121}21222123/*2124 * This function verifies if index_state has the correct sha1 of the2125 * index file. Don't die if we have any other failure, just return 0.2126 */2127static intverify_index_from(const struct index_state *istate,const char*path)2128{2129int fd;2130 ssize_t n;2131struct stat st;2132unsigned char sha1[20];21332134if(!istate->initialized)2135return0;21362137 fd =open(path, O_RDONLY);2138if(fd <0)2139return0;21402141if(fstat(fd, &st))2142goto out;21432144if(st.st_size <sizeof(struct cache_header) +20)2145goto out;21462147 n =pread_in_full(fd, sha1,20, st.st_size -20);2148if(n !=20)2149goto out;21502151if(hashcmp(istate->sha1, sha1))2152goto out;21532154close(fd);2155return1;21562157out:2158close(fd);2159return0;2160}21612162static intverify_index(const struct index_state *istate)2163{2164returnverify_index_from(istate,get_index_file());2165}21662167static inthas_racy_timestamp(struct index_state *istate)2168{2169int entries = istate->cache_nr;2170int i;21712172for(i =0; i < entries; i++) {2173struct cache_entry *ce = istate->cache[i];2174if(is_racy_timestamp(istate, ce))2175return1;2176}2177return0;2178}21792180/*2181 * Opportunistically update the index but do not complain if we can't2182 */2183voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2184{2185if((istate->cache_changed ||has_racy_timestamp(istate)) &&2186verify_index(istate) &&2187write_locked_index(istate, lockfile, COMMIT_LOCK))2188rollback_lock_file(lockfile);2189}21902191static intdo_write_index(struct index_state *istate,int newfd,2192int strip_extensions)2193{2194 git_SHA_CTX c;2195struct cache_header hdr;2196int i, err, removed, extended, hdr_version;2197struct cache_entry **cache = istate->cache;2198int entries = istate->cache_nr;2199struct stat st;2200struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;22012202for(i = removed = extended =0; i < entries; i++) {2203if(cache[i]->ce_flags & CE_REMOVE)2204 removed++;22052206/* reduce extended entries if possible */2207 cache[i]->ce_flags &= ~CE_EXTENDED;2208if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2209 extended++;2210 cache[i]->ce_flags |= CE_EXTENDED;2211}2212}22132214if(!istate->version) {2215 istate->version =get_index_format_default();2216if(getenv("GIT_TEST_SPLIT_INDEX"))2217init_split_index(istate);2218}22192220/* demote version 3 to version 2 when the latter suffices */2221if(istate->version ==3|| istate->version ==2)2222 istate->version = extended ?3:2;22232224 hdr_version = istate->version;22252226 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2227 hdr.hdr_version =htonl(hdr_version);2228 hdr.hdr_entries =htonl(entries - removed);22292230git_SHA1_Init(&c);2231if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2232return-1;22332234 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;2235for(i =0; i < entries; i++) {2236struct cache_entry *ce = cache[i];2237if(ce->ce_flags & CE_REMOVE)2238continue;2239if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2240ce_smudge_racily_clean_entry(ce);2241if(is_null_oid(&ce->oid)) {2242static const char msg[] ="cache entry has null sha1:%s";2243static int allow = -1;22442245if(allow <0)2246 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2247if(allow)2248warning(msg, ce->name);2249else2250returnerror(msg, ce->name);2251}2252if(ce_write_entry(&c, newfd, ce, previous_name) <0)2253return-1;2254}2255strbuf_release(&previous_name_buf);22562257/* Write extension data here */2258if(!strip_extensions && istate->split_index) {2259struct strbuf sb = STRBUF_INIT;22602261 err =write_link_extension(&sb, istate) <0||2262write_index_ext_header(&c, newfd, CACHE_EXT_LINK,2263 sb.len) <0||2264ce_write(&c, newfd, sb.buf, sb.len) <0;2265strbuf_release(&sb);2266if(err)2267return-1;2268}2269if(!strip_extensions && istate->cache_tree) {2270struct strbuf sb = STRBUF_INIT;22712272cache_tree_write(&sb, istate->cache_tree);2273 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <02274||ce_write(&c, newfd, sb.buf, sb.len) <0;2275strbuf_release(&sb);2276if(err)2277return-1;2278}2279if(!strip_extensions && istate->resolve_undo) {2280struct strbuf sb = STRBUF_INIT;22812282resolve_undo_write(&sb, istate->resolve_undo);2283 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,2284 sb.len) <02285||ce_write(&c, newfd, sb.buf, sb.len) <0;2286strbuf_release(&sb);2287if(err)2288return-1;2289}2290if(!strip_extensions && istate->untracked) {2291struct strbuf sb = STRBUF_INIT;22922293write_untracked_extension(&sb, istate->untracked);2294 err =write_index_ext_header(&c, newfd, CACHE_EXT_UNTRACKED,2295 sb.len) <0||2296ce_write(&c, newfd, sb.buf, sb.len) <0;2297strbuf_release(&sb);2298if(err)2299return-1;2300}23012302if(ce_flush(&c, newfd, istate->sha1) ||fstat(newfd, &st))2303return-1;2304 istate->timestamp.sec = (unsigned int)st.st_mtime;2305 istate->timestamp.nsec =ST_MTIME_NSEC(st);2306return0;2307}23082309voidset_alternate_index_output(const char*name)2310{2311 alternate_index_output = name;2312}23132314static intcommit_locked_index(struct lock_file *lk)2315{2316if(alternate_index_output)2317returncommit_lock_file_to(lk, alternate_index_output);2318else2319returncommit_lock_file(lk);2320}23212322static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2323unsigned flags)2324{2325int ret =do_write_index(istate,get_lock_file_fd(lock),0);2326if(ret)2327return ret;2328assert((flags & (COMMIT_LOCK | CLOSE_LOCK)) !=2329(COMMIT_LOCK | CLOSE_LOCK));2330if(flags & COMMIT_LOCK)2331returncommit_locked_index(lock);2332else if(flags & CLOSE_LOCK)2333returnclose_lock_file(lock);2334else2335return ret;2336}23372338static intwrite_split_index(struct index_state *istate,2339struct lock_file *lock,2340unsigned flags)2341{2342int ret;2343prepare_to_write_split_index(istate);2344 ret =do_write_locked_index(istate, lock, flags);2345finish_writing_split_index(istate);2346return ret;2347}23482349static const char*shared_index_expire ="2.weeks.ago";23502351static unsigned longget_shared_index_expire_date(void)2352{2353static unsigned long shared_index_expire_date;2354static int shared_index_expire_date_prepared;23552356if(!shared_index_expire_date_prepared) {2357git_config_get_expiry("splitindex.sharedindexexpire",2358&shared_index_expire);2359 shared_index_expire_date =approxidate(shared_index_expire);2360 shared_index_expire_date_prepared =1;2361}23622363return shared_index_expire_date;2364}23652366static intshould_delete_shared_index(const char*shared_index_path)2367{2368struct stat st;2369unsigned long expiration;23702371/* Check timestamp */2372 expiration =get_shared_index_expire_date();2373if(!expiration)2374return0;2375if(stat(shared_index_path, &st))2376returnerror_errno(_("could not stat '%s'"), shared_index_path);2377if(st.st_mtime > expiration)2378return0;23792380return1;2381}23822383static intclean_shared_index_files(const char*current_hex)2384{2385struct dirent *de;2386DIR*dir =opendir(get_git_dir());23872388if(!dir)2389returnerror_errno(_("unable to open git dir:%s"),get_git_dir());23902391while((de =readdir(dir)) != NULL) {2392const char*sha1_hex;2393const char*shared_index_path;2394if(!skip_prefix(de->d_name,"sharedindex.", &sha1_hex))2395continue;2396if(!strcmp(sha1_hex, current_hex))2397continue;2398 shared_index_path =git_path("%s", de->d_name);2399if(should_delete_shared_index(shared_index_path) >0&&2400unlink(shared_index_path))2401warning_errno(_("unable to unlink:%s"), shared_index_path);2402}2403closedir(dir);24042405return0;2406}24072408static struct tempfile temporary_sharedindex;24092410static intwrite_shared_index(struct index_state *istate,2411struct lock_file *lock,unsigned flags)2412{2413struct split_index *si = istate->split_index;2414int fd, ret;24152416 fd =mks_tempfile(&temporary_sharedindex,git_path("sharedindex_XXXXXX"));2417if(fd <0) {2418hashclr(si->base_sha1);2419returndo_write_locked_index(istate, lock, flags);2420}2421move_cache_to_base_index(istate);2422 ret =do_write_index(si->base, fd,1);2423if(ret) {2424delete_tempfile(&temporary_sharedindex);2425return ret;2426}2427 ret =rename_tempfile(&temporary_sharedindex,2428git_path("sharedindex.%s",sha1_to_hex(si->base->sha1)));2429if(!ret) {2430hashcpy(si->base_sha1, si->base->sha1);2431clean_shared_index_files(sha1_to_hex(si->base->sha1));2432}24332434return ret;2435}24362437static const int default_max_percent_split_change =20;24382439static inttoo_many_not_shared_entries(struct index_state *istate)2440{2441int i, not_shared =0;2442int max_split =git_config_get_max_percent_split_change();24432444switch(max_split) {2445case-1:2446/* not or badly configured: use the default value */2447 max_split = default_max_percent_split_change;2448break;2449case0:2450return1;/* 0% means always write a new shared index */2451case100:2452return0;/* 100% means never write a new shared index */2453default:2454break;/* just use the configured value */2455}24562457/* Count not shared entries */2458for(i =0; i < istate->cache_nr; i++) {2459struct cache_entry *ce = istate->cache[i];2460if(!ce->index)2461 not_shared++;2462}24632464return(int64_t)istate->cache_nr * max_split < (int64_t)not_shared *100;2465}24662467intwrite_locked_index(struct index_state *istate,struct lock_file *lock,2468unsigned flags)2469{2470int new_shared_index, ret;2471struct split_index *si = istate->split_index;24722473if(!si || alternate_index_output ||2474(istate->cache_changed & ~EXTMASK)) {2475if(si)2476hashclr(si->base_sha1);2477returndo_write_locked_index(istate, lock, flags);2478}24792480if(getenv("GIT_TEST_SPLIT_INDEX")) {2481int v = si->base_sha1[0];2482if((v &15) <6)2483 istate->cache_changed |= SPLIT_INDEX_ORDERED;2484}2485if(too_many_not_shared_entries(istate))2486 istate->cache_changed |= SPLIT_INDEX_ORDERED;24872488 new_shared_index = istate->cache_changed & SPLIT_INDEX_ORDERED;24892490if(new_shared_index) {2491 ret =write_shared_index(istate, lock, flags);2492if(ret)2493return ret;2494}24952496 ret =write_split_index(istate, lock, flags);24972498/* Freshen the shared index only if the split-index was written */2499if(!ret && !new_shared_index)2500freshen_shared_index(sha1_to_hex(si->base_sha1),1);25012502return ret;2503}25042505/*2506 * Read the index file that is potentially unmerged into given2507 * index_state, dropping any unmerged entries. Returns true if2508 * the index is unmerged. Callers who want to refuse to work2509 * from an unmerged state can call this and check its return value,2510 * instead of calling read_cache().2511 */2512intread_index_unmerged(struct index_state *istate)2513{2514int i;2515int unmerged =0;25162517read_index(istate);2518for(i =0; i < istate->cache_nr; i++) {2519struct cache_entry *ce = istate->cache[i];2520struct cache_entry *new_ce;2521int size, len;25222523if(!ce_stage(ce))2524continue;2525 unmerged =1;2526 len =ce_namelen(ce);2527 size =cache_entry_size(len);2528 new_ce =xcalloc(1, size);2529memcpy(new_ce->name, ce->name, len);2530 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;2531 new_ce->ce_namelen = len;2532 new_ce->ce_mode = ce->ce_mode;2533if(add_index_entry(istate, new_ce,0))2534returnerror("%s: cannot drop to stage #0",2535 new_ce->name);2536}2537return unmerged;2538}25392540/*2541 * Returns 1 if the path is an "other" path with respect to2542 * the index; that is, the path is not mentioned in the index at all,2543 * either as a file, a directory with some files in the index,2544 * or as an unmerged entry.2545 *2546 * We helpfully remove a trailing "/" from directories so that2547 * the output of read_directory can be used as-is.2548 */2549intindex_name_is_other(const struct index_state *istate,const char*name,2550int namelen)2551{2552int pos;2553if(namelen && name[namelen -1] =='/')2554 namelen--;2555 pos =index_name_pos(istate, name, namelen);2556if(0<= pos)2557return0;/* exact match */2558 pos = -pos -1;2559if(pos < istate->cache_nr) {2560struct cache_entry *ce = istate->cache[pos];2561if(ce_namelen(ce) == namelen &&2562!memcmp(ce->name, name, namelen))2563return0;/* Yup, this one exists unmerged */2564}2565return1;2566}25672568void*read_blob_data_from_index(const struct index_state *istate,2569const char*path,unsigned long*size)2570{2571int pos, len;2572unsigned long sz;2573enum object_type type;2574void*data;25752576 len =strlen(path);2577 pos =index_name_pos(istate, path, len);2578if(pos <0) {2579/*2580 * We might be in the middle of a merge, in which2581 * case we would read stage #2 (ours).2582 */2583int i;2584for(i = -pos -1;2585(pos <0&& i < istate->cache_nr &&2586!strcmp(istate->cache[i]->name, path));2587 i++)2588if(ce_stage(istate->cache[i]) ==2)2589 pos = i;2590}2591if(pos <0)2592return NULL;2593 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz);2594if(!data || type != OBJ_BLOB) {2595free(data);2596return NULL;2597}2598if(size)2599*size = sz;2600return data;2601}26022603voidstat_validity_clear(struct stat_validity *sv)2604{2605free(sv->sd);2606 sv->sd = NULL;2607}26082609intstat_validity_check(struct stat_validity *sv,const char*path)2610{2611struct stat st;26122613if(stat(path, &st) <0)2614return sv->sd == NULL;2615if(!sv->sd)2616return0;2617returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2618}26192620voidstat_validity_update(struct stat_validity *sv,int fd)2621{2622struct stat st;26232624if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2625stat_validity_clear(sv);2626else{2627if(!sv->sd)2628 sv->sd =xcalloc(1,sizeof(struct stat_data));2629fill_stat_data(sv->sd, &st);2630}2631}