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"diff.h" 10#include"diffcore.h" 11#include"tempfile.h" 12#include"lockfile.h" 13#include"cache-tree.h" 14#include"refs.h" 15#include"dir.h" 16#include"object-store.h" 17#include"tree.h" 18#include"commit.h" 19#include"blob.h" 20#include"resolve-undo.h" 21#include"strbuf.h" 22#include"varint.h" 23#include"split-index.h" 24#include"utf8.h" 25#include"fsmonitor.h" 26#include"thread-utils.h" 27#include"progress.h" 28 29/* Mask for the name length in ce_flags in the on-disk index */ 30 31#define CE_NAMEMASK (0x0fff) 32 33/* Index extensions. 34 * 35 * The first letter should be 'A'..'Z' for extensions that are not 36 * necessary for a correct operation (i.e. optimization data). 37 * When new extensions are added that _needs_ to be understood in 38 * order to correctly interpret the index file, pick character that 39 * is outside the range, to cause the reader to abort. 40 */ 41 42#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 43#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 44#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 45#define CACHE_EXT_LINK 0x6c696e6b/* "link" */ 46#define CACHE_EXT_UNTRACKED 0x554E5452/* "UNTR" */ 47#define CACHE_EXT_FSMONITOR 0x46534D4E/* "FSMN" */ 48#define CACHE_EXT_ENDOFINDEXENTRIES 0x454F4945/* "EOIE" */ 49#define CACHE_EXT_INDEXENTRYOFFSETTABLE 0x49454F54/* "IEOT" */ 50 51/* changes that can be kept in $GIT_DIR/index (basically all extensions) */ 52#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \ 53 CE_ENTRY_ADDED | CE_ENTRY_REMOVED | CE_ENTRY_CHANGED | \ 54 SPLIT_INDEX_ORDERED | UNTRACKED_CHANGED | FSMONITOR_CHANGED) 55 56 57/* 58 * This is an estimate of the pathname length in the index. We use 59 * this for V4 index files to guess the un-deltafied size of the index 60 * in memory because of pathname deltafication. This is not required 61 * for V2/V3 index formats because their pathnames are not compressed. 62 * If the initial amount of memory set aside is not sufficient, the 63 * mem pool will allocate extra memory. 64 */ 65#define CACHE_ENTRY_PATH_LENGTH 80 66 67staticinlinestruct cache_entry *mem_pool__ce_alloc(struct mem_pool *mem_pool,size_t len) 68{ 69struct cache_entry *ce; 70 ce =mem_pool_alloc(mem_pool,cache_entry_size(len)); 71 ce->mem_pool_allocated =1; 72return ce; 73} 74 75staticinlinestruct cache_entry *mem_pool__ce_calloc(struct mem_pool *mem_pool,size_t len) 76{ 77struct cache_entry * ce; 78 ce =mem_pool_calloc(mem_pool,1,cache_entry_size(len)); 79 ce->mem_pool_allocated =1; 80return ce; 81} 82 83static struct mem_pool *find_mem_pool(struct index_state *istate) 84{ 85struct mem_pool **pool_ptr; 86 87if(istate->split_index && istate->split_index->base) 88 pool_ptr = &istate->split_index->base->ce_mem_pool; 89else 90 pool_ptr = &istate->ce_mem_pool; 91 92if(!*pool_ptr) 93mem_pool_init(pool_ptr,0); 94 95return*pool_ptr; 96} 97 98struct index_state the_index; 99static const char*alternate_index_output; 100 101static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 102{ 103 istate->cache[nr] = ce; 104add_name_hash(istate, ce); 105} 106 107static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 108{ 109struct cache_entry *old = istate->cache[nr]; 110 111replace_index_entry_in_base(istate, old, ce); 112remove_name_hash(istate, old); 113discard_cache_entry(old); 114 ce->ce_flags &= ~CE_HASHED; 115set_index_entry(istate, nr, ce); 116 ce->ce_flags |= CE_UPDATE_IN_BASE; 117mark_fsmonitor_invalid(istate, ce); 118 istate->cache_changed |= CE_ENTRY_CHANGED; 119} 120 121voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 122{ 123struct cache_entry *old_entry = istate->cache[nr], *new_entry; 124int namelen =strlen(new_name); 125 126 new_entry =make_empty_cache_entry(istate, namelen); 127copy_cache_entry(new_entry, old_entry); 128 new_entry->ce_flags &= ~CE_HASHED; 129 new_entry->ce_namelen = namelen; 130 new_entry->index =0; 131memcpy(new_entry->name, new_name, namelen +1); 132 133cache_tree_invalidate_path(istate, old_entry->name); 134untracked_cache_remove_from_index(istate, old_entry->name); 135remove_index_entry_at(istate, nr); 136add_index_entry(istate, new_entry, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 137} 138 139voidfill_stat_data(struct stat_data *sd,struct stat *st) 140{ 141 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 142 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 143 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 144 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 145 sd->sd_dev = st->st_dev; 146 sd->sd_ino = st->st_ino; 147 sd->sd_uid = st->st_uid; 148 sd->sd_gid = st->st_gid; 149 sd->sd_size = st->st_size; 150} 151 152intmatch_stat_data(const struct stat_data *sd,struct stat *st) 153{ 154int changed =0; 155 156if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 157 changed |= MTIME_CHANGED; 158if(trust_ctime && check_stat && 159 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 160 changed |= CTIME_CHANGED; 161 162#ifdef USE_NSEC 163if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 164 changed |= MTIME_CHANGED; 165if(trust_ctime && check_stat && 166 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 167 changed |= CTIME_CHANGED; 168#endif 169 170if(check_stat) { 171if(sd->sd_uid != (unsigned int) st->st_uid || 172 sd->sd_gid != (unsigned int) st->st_gid) 173 changed |= OWNER_CHANGED; 174if(sd->sd_ino != (unsigned int) st->st_ino) 175 changed |= INODE_CHANGED; 176} 177 178#ifdef USE_STDEV 179/* 180 * st_dev breaks on network filesystems where different 181 * clients will have different views of what "device" 182 * the filesystem is on 183 */ 184if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 185 changed |= INODE_CHANGED; 186#endif 187 188if(sd->sd_size != (unsigned int) st->st_size) 189 changed |= DATA_CHANGED; 190 191return changed; 192} 193 194/* 195 * This only updates the "non-critical" parts of the directory 196 * cache, ie the parts that aren't tracked by GIT, and only used 197 * to validate the cache. 198 */ 199voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 200{ 201fill_stat_data(&ce->ce_stat_data, st); 202 203if(assume_unchanged) 204 ce->ce_flags |= CE_VALID; 205 206if(S_ISREG(st->st_mode)) { 207ce_mark_uptodate(ce); 208mark_fsmonitor_valid(ce); 209} 210} 211 212static intce_compare_data(struct index_state *istate, 213const struct cache_entry *ce, 214struct stat *st) 215{ 216int match = -1; 217int fd =git_open_cloexec(ce->name, O_RDONLY); 218 219if(fd >=0) { 220struct object_id oid; 221if(!index_fd(istate, &oid, fd, st, OBJ_BLOB, ce->name,0)) 222 match = !oideq(&oid, &ce->oid); 223/* index_fd() closed the file descriptor already */ 224} 225return match; 226} 227 228static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 229{ 230int match = -1; 231void*buffer; 232unsigned long size; 233enum object_type type; 234struct strbuf sb = STRBUF_INIT; 235 236if(strbuf_readlink(&sb, ce->name, expected_size)) 237return-1; 238 239 buffer =read_object_file(&ce->oid, &type, &size); 240if(buffer) { 241if(size == sb.len) 242 match =memcmp(buffer, sb.buf, size); 243free(buffer); 244} 245strbuf_release(&sb); 246return match; 247} 248 249static intce_compare_gitlink(const struct cache_entry *ce) 250{ 251struct object_id oid; 252 253/* 254 * We don't actually require that the .git directory 255 * under GITLINK directory be a valid git directory. It 256 * might even be missing (in case nobody populated that 257 * sub-project). 258 * 259 * If so, we consider it always to match. 260 */ 261if(resolve_gitlink_ref(ce->name,"HEAD", &oid) <0) 262return0; 263return!oideq(&oid, &ce->oid); 264} 265 266static intce_modified_check_fs(struct index_state *istate, 267const struct cache_entry *ce, 268struct stat *st) 269{ 270switch(st->st_mode & S_IFMT) { 271case S_IFREG: 272if(ce_compare_data(istate, ce, st)) 273return DATA_CHANGED; 274break; 275case S_IFLNK: 276if(ce_compare_link(ce,xsize_t(st->st_size))) 277return DATA_CHANGED; 278break; 279case S_IFDIR: 280if(S_ISGITLINK(ce->ce_mode)) 281returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 282/* else fallthrough */ 283default: 284return TYPE_CHANGED; 285} 286return0; 287} 288 289static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 290{ 291unsigned int changed =0; 292 293if(ce->ce_flags & CE_REMOVE) 294return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 295 296switch(ce->ce_mode & S_IFMT) { 297case S_IFREG: 298 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 299/* We consider only the owner x bit to be relevant for 300 * "mode changes" 301 */ 302if(trust_executable_bit && 303(0100& (ce->ce_mode ^ st->st_mode))) 304 changed |= MODE_CHANGED; 305break; 306case S_IFLNK: 307if(!S_ISLNK(st->st_mode) && 308(has_symlinks || !S_ISREG(st->st_mode))) 309 changed |= TYPE_CHANGED; 310break; 311case S_IFGITLINK: 312/* We ignore most of the st_xxx fields for gitlinks */ 313if(!S_ISDIR(st->st_mode)) 314 changed |= TYPE_CHANGED; 315else if(ce_compare_gitlink(ce)) 316 changed |= DATA_CHANGED; 317return changed; 318default: 319die("internal error: ce_mode is%o", ce->ce_mode); 320} 321 322 changed |=match_stat_data(&ce->ce_stat_data, st); 323 324/* Racily smudged entry? */ 325if(!ce->ce_stat_data.sd_size) { 326if(!is_empty_blob_sha1(ce->oid.hash)) 327 changed |= DATA_CHANGED; 328} 329 330return changed; 331} 332 333static intis_racy_stat(const struct index_state *istate, 334const struct stat_data *sd) 335{ 336return(istate->timestamp.sec && 337#ifdef USE_NSEC 338/* nanosecond timestamped files can also be racy! */ 339(istate->timestamp.sec < sd->sd_mtime.sec || 340(istate->timestamp.sec == sd->sd_mtime.sec && 341 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 342#else 343 istate->timestamp.sec <= sd->sd_mtime.sec 344#endif 345); 346} 347 348intis_racy_timestamp(const struct index_state *istate, 349const struct cache_entry *ce) 350{ 351return(!S_ISGITLINK(ce->ce_mode) && 352is_racy_stat(istate, &ce->ce_stat_data)); 353} 354 355intmatch_stat_data_racy(const struct index_state *istate, 356const struct stat_data *sd,struct stat *st) 357{ 358if(is_racy_stat(istate, sd)) 359return MTIME_CHANGED; 360returnmatch_stat_data(sd, st); 361} 362 363intie_match_stat(struct index_state *istate, 364const struct cache_entry *ce,struct stat *st, 365unsigned int options) 366{ 367unsigned int changed; 368int ignore_valid = options & CE_MATCH_IGNORE_VALID; 369int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 370int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 371int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR; 372 373if(!ignore_fsmonitor) 374refresh_fsmonitor(istate); 375/* 376 * If it's marked as always valid in the index, it's 377 * valid whatever the checked-out copy says. 378 * 379 * skip-worktree has the same effect with higher precedence 380 */ 381if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 382return0; 383if(!ignore_valid && (ce->ce_flags & CE_VALID)) 384return0; 385if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) 386return0; 387 388/* 389 * Intent-to-add entries have not been added, so the index entry 390 * by definition never matches what is in the work tree until it 391 * actually gets added. 392 */ 393if(ce_intent_to_add(ce)) 394return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 395 396 changed =ce_match_stat_basic(ce, st); 397 398/* 399 * Within 1 second of this sequence: 400 * echo xyzzy >file && git-update-index --add file 401 * running this command: 402 * echo frotz >file 403 * would give a falsely clean cache entry. The mtime and 404 * length match the cache, and other stat fields do not change. 405 * 406 * We could detect this at update-index time (the cache entry 407 * being registered/updated records the same time as "now") 408 * and delay the return from git-update-index, but that would 409 * effectively mean we can make at most one commit per second, 410 * which is not acceptable. Instead, we check cache entries 411 * whose mtime are the same as the index file timestamp more 412 * carefully than others. 413 */ 414if(!changed &&is_racy_timestamp(istate, ce)) { 415if(assume_racy_is_modified) 416 changed |= DATA_CHANGED; 417else 418 changed |=ce_modified_check_fs(istate, ce, st); 419} 420 421return changed; 422} 423 424intie_modified(struct index_state *istate, 425const struct cache_entry *ce, 426struct stat *st,unsigned int options) 427{ 428int changed, changed_fs; 429 430 changed =ie_match_stat(istate, ce, st, options); 431if(!changed) 432return0; 433/* 434 * If the mode or type has changed, there's no point in trying 435 * to refresh the entry - it's not going to match 436 */ 437if(changed & (MODE_CHANGED | TYPE_CHANGED)) 438return changed; 439 440/* 441 * Immediately after read-tree or update-index --cacheinfo, 442 * the length field is zero, as we have never even read the 443 * lstat(2) information once, and we cannot trust DATA_CHANGED 444 * returned by ie_match_stat() which in turn was returned by 445 * ce_match_stat_basic() to signal that the filesize of the 446 * blob changed. We have to actually go to the filesystem to 447 * see if the contents match, and if so, should answer "unchanged". 448 * 449 * The logic does not apply to gitlinks, as ce_match_stat_basic() 450 * already has checked the actual HEAD from the filesystem in the 451 * subproject. If ie_match_stat() already said it is different, 452 * then we know it is. 453 */ 454if((changed & DATA_CHANGED) && 455(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 456return changed; 457 458 changed_fs =ce_modified_check_fs(istate, ce, st); 459if(changed_fs) 460return changed | changed_fs; 461return0; 462} 463 464intbase_name_compare(const char*name1,int len1,int mode1, 465const char*name2,int len2,int mode2) 466{ 467unsigned char c1, c2; 468int len = len1 < len2 ? len1 : len2; 469int cmp; 470 471 cmp =memcmp(name1, name2, len); 472if(cmp) 473return cmp; 474 c1 = name1[len]; 475 c2 = name2[len]; 476if(!c1 &&S_ISDIR(mode1)) 477 c1 ='/'; 478if(!c2 &&S_ISDIR(mode2)) 479 c2 ='/'; 480return(c1 < c2) ? -1: (c1 > c2) ?1:0; 481} 482 483/* 484 * df_name_compare() is identical to base_name_compare(), except it 485 * compares conflicting directory/file entries as equal. Note that 486 * while a directory name compares as equal to a regular file, they 487 * then individually compare _differently_ to a filename that has 488 * a dot after the basename (because '\0' < '.' < '/'). 489 * 490 * This is used by routines that want to traverse the git namespace 491 * but then handle conflicting entries together when possible. 492 */ 493intdf_name_compare(const char*name1,int len1,int mode1, 494const char*name2,int len2,int mode2) 495{ 496int len = len1 < len2 ? len1 : len2, cmp; 497unsigned char c1, c2; 498 499 cmp =memcmp(name1, name2, len); 500if(cmp) 501return cmp; 502/* Directories and files compare equal (same length, same name) */ 503if(len1 == len2) 504return0; 505 c1 = name1[len]; 506if(!c1 &&S_ISDIR(mode1)) 507 c1 ='/'; 508 c2 = name2[len]; 509if(!c2 &&S_ISDIR(mode2)) 510 c2 ='/'; 511if(c1 =='/'&& !c2) 512return0; 513if(c2 =='/'&& !c1) 514return0; 515return c1 - c2; 516} 517 518intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 519{ 520size_t min_len = (len1 < len2) ? len1 : len2; 521int cmp =memcmp(name1, name2, min_len); 522if(cmp) 523return cmp; 524if(len1 < len2) 525return-1; 526if(len1 > len2) 527return1; 528return0; 529} 530 531intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 532{ 533int cmp; 534 535 cmp =name_compare(name1, len1, name2, len2); 536if(cmp) 537return cmp; 538 539if(stage1 < stage2) 540return-1; 541if(stage1 > stage2) 542return1; 543return0; 544} 545 546static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 547{ 548int first, last; 549 550 first =0; 551 last = istate->cache_nr; 552while(last > first) { 553int next = (last + first) >>1; 554struct cache_entry *ce = istate->cache[next]; 555int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 556if(!cmp) 557return next; 558if(cmp <0) { 559 last = next; 560continue; 561} 562 first = next+1; 563} 564return-first-1; 565} 566 567intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 568{ 569returnindex_name_stage_pos(istate, name, namelen,0); 570} 571 572intremove_index_entry_at(struct index_state *istate,int pos) 573{ 574struct cache_entry *ce = istate->cache[pos]; 575 576record_resolve_undo(istate, ce); 577remove_name_hash(istate, ce); 578save_or_free_index_entry(istate, ce); 579 istate->cache_changed |= CE_ENTRY_REMOVED; 580 istate->cache_nr--; 581if(pos >= istate->cache_nr) 582return0; 583MOVE_ARRAY(istate->cache + pos, istate->cache + pos +1, 584 istate->cache_nr - pos); 585return1; 586} 587 588/* 589 * Remove all cache entries marked for removal, that is where 590 * CE_REMOVE is set in ce_flags. This is much more effective than 591 * calling remove_index_entry_at() for each entry to be removed. 592 */ 593voidremove_marked_cache_entries(struct index_state *istate) 594{ 595struct cache_entry **ce_array = istate->cache; 596unsigned int i, j; 597 598for(i = j =0; i < istate->cache_nr; i++) { 599if(ce_array[i]->ce_flags & CE_REMOVE) { 600remove_name_hash(istate, ce_array[i]); 601save_or_free_index_entry(istate, ce_array[i]); 602} 603else 604 ce_array[j++] = ce_array[i]; 605} 606if(j == istate->cache_nr) 607return; 608 istate->cache_changed |= CE_ENTRY_REMOVED; 609 istate->cache_nr = j; 610} 611 612intremove_file_from_index(struct index_state *istate,const char*path) 613{ 614int pos =index_name_pos(istate, path,strlen(path)); 615if(pos <0) 616 pos = -pos-1; 617cache_tree_invalidate_path(istate, path); 618untracked_cache_remove_from_index(istate, path); 619while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 620remove_index_entry_at(istate, pos); 621return0; 622} 623 624static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 625{ 626return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 627} 628 629static intindex_name_pos_also_unmerged(struct index_state *istate, 630const char*path,int namelen) 631{ 632int pos =index_name_pos(istate, path, namelen); 633struct cache_entry *ce; 634 635if(pos >=0) 636return pos; 637 638/* maybe unmerged? */ 639 pos = -1- pos; 640if(pos >= istate->cache_nr || 641compare_name((ce = istate->cache[pos]), path, namelen)) 642return-1; 643 644/* order of preference: stage 2, 1, 3 */ 645if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 646ce_stage((ce = istate->cache[pos +1])) ==2&& 647!compare_name(ce, path, namelen)) 648 pos++; 649return pos; 650} 651 652static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 653{ 654int len =ce_namelen(ce); 655returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 656} 657 658/* 659 * If we add a filename that aliases in the cache, we will use the 660 * name that we already have - but we don't want to update the same 661 * alias twice, because that implies that there were actually two 662 * different files with aliasing names! 663 * 664 * So we use the CE_ADDED flag to verify that the alias was an old 665 * one before we accept it as 666 */ 667static struct cache_entry *create_alias_ce(struct index_state *istate, 668struct cache_entry *ce, 669struct cache_entry *alias) 670{ 671int len; 672struct cache_entry *new_entry; 673 674if(alias->ce_flags & CE_ADDED) 675die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 676 677/* Ok, create the new entry using the name of the existing alias */ 678 len =ce_namelen(alias); 679 new_entry =make_empty_cache_entry(istate, len); 680memcpy(new_entry->name, alias->name, len); 681copy_cache_entry(new_entry, ce); 682save_or_free_index_entry(istate, ce); 683return new_entry; 684} 685 686voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 687{ 688struct object_id oid; 689if(write_object_file("",0, blob_type, &oid)) 690die("cannot create an empty blob in the object database"); 691oidcpy(&ce->oid, &oid); 692} 693 694intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 695{ 696int namelen, was_same; 697 mode_t st_mode = st->st_mode; 698struct cache_entry *ce, *alias = NULL; 699unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 700int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 701int pretend = flags & ADD_CACHE_PRETEND; 702int intent_only = flags & ADD_CACHE_INTENT; 703int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 704(intent_only ? ADD_CACHE_NEW_ONLY :0)); 705int newflags = HASH_WRITE_OBJECT; 706 707if(flags & HASH_RENORMALIZE) 708 newflags |= HASH_RENORMALIZE; 709 710if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 711returnerror("%s: can only add regular files, symbolic links or git-directories", path); 712 713 namelen =strlen(path); 714if(S_ISDIR(st_mode)) { 715while(namelen && path[namelen-1] =='/') 716 namelen--; 717} 718 ce =make_empty_cache_entry(istate, namelen); 719memcpy(ce->name, path, namelen); 720 ce->ce_namelen = namelen; 721if(!intent_only) 722fill_stat_cache_info(ce, st); 723else 724 ce->ce_flags |= CE_INTENT_TO_ADD; 725 726 727if(trust_executable_bit && has_symlinks) { 728 ce->ce_mode =create_ce_mode(st_mode); 729}else{ 730/* If there is an existing entry, pick the mode bits and type 731 * from it, otherwise assume unexecutable regular file. 732 */ 733struct cache_entry *ent; 734int pos =index_name_pos_also_unmerged(istate, path, namelen); 735 736 ent = (0<= pos) ? istate->cache[pos] : NULL; 737 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 738} 739 740/* When core.ignorecase=true, determine if a directory of the same name but differing 741 * case already exists within the Git repository. If it does, ensure the directory 742 * case of the file being added to the repository matches (is folded into) the existing 743 * entry's directory case. 744 */ 745if(ignore_case) { 746adjust_dirname_case(istate, ce->name); 747} 748if(!(flags & HASH_RENORMALIZE)) { 749 alias =index_file_exists(istate, ce->name, 750ce_namelen(ce), ignore_case); 751if(alias && 752!ce_stage(alias) && 753!ie_match_stat(istate, alias, st, ce_option)) { 754/* Nothing changed, really */ 755if(!S_ISGITLINK(alias->ce_mode)) 756ce_mark_uptodate(alias); 757 alias->ce_flags |= CE_ADDED; 758 759discard_cache_entry(ce); 760return0; 761} 762} 763if(!intent_only) { 764if(index_path(istate, &ce->oid, path, st, newflags)) { 765discard_cache_entry(ce); 766returnerror("unable to index file%s", path); 767} 768}else 769set_object_name_for_intent_to_add_entry(ce); 770 771if(ignore_case && alias &&different_name(ce, alias)) 772 ce =create_alias_ce(istate, ce, alias); 773 ce->ce_flags |= CE_ADDED; 774 775/* It was suspected to be racily clean, but it turns out to be Ok */ 776 was_same = (alias && 777!ce_stage(alias) && 778oideq(&alias->oid, &ce->oid) && 779 ce->ce_mode == alias->ce_mode); 780 781if(pretend) 782discard_cache_entry(ce); 783else if(add_index_entry(istate, ce, add_option)) { 784discard_cache_entry(ce); 785returnerror("unable to add%sto index", path); 786} 787if(verbose && !was_same) 788printf("add '%s'\n", path); 789return0; 790} 791 792intadd_file_to_index(struct index_state *istate,const char*path,int flags) 793{ 794struct stat st; 795if(lstat(path, &st)) 796die_errno("unable to stat '%s'", path); 797returnadd_to_index(istate, path, &st, flags); 798} 799 800struct cache_entry *make_empty_cache_entry(struct index_state *istate,size_t len) 801{ 802returnmem_pool__ce_calloc(find_mem_pool(istate), len); 803} 804 805struct cache_entry *make_empty_transient_cache_entry(size_t len) 806{ 807returnxcalloc(1,cache_entry_size(len)); 808} 809 810struct cache_entry *make_cache_entry(struct index_state *istate, 811unsigned int mode, 812const struct object_id *oid, 813const char*path, 814int stage, 815unsigned int refresh_options) 816{ 817struct cache_entry *ce, *ret; 818int len; 819 820if(!verify_path(path, mode)) { 821error("Invalid path '%s'", path); 822return NULL; 823} 824 825 len =strlen(path); 826 ce =make_empty_cache_entry(istate, len); 827 828oidcpy(&ce->oid, oid); 829memcpy(ce->name, path, len); 830 ce->ce_flags =create_ce_flags(stage); 831 ce->ce_namelen = len; 832 ce->ce_mode =create_ce_mode(mode); 833 834 ret =refresh_cache_entry(istate, ce, refresh_options); 835if(ret != ce) 836discard_cache_entry(ce); 837return ret; 838} 839 840struct cache_entry *make_transient_cache_entry(unsigned int mode,const struct object_id *oid, 841const char*path,int stage) 842{ 843struct cache_entry *ce; 844int len; 845 846if(!verify_path(path, mode)) { 847error("Invalid path '%s'", path); 848return NULL; 849} 850 851 len =strlen(path); 852 ce =make_empty_transient_cache_entry(len); 853 854oidcpy(&ce->oid, oid); 855memcpy(ce->name, path, len); 856 ce->ce_flags =create_ce_flags(stage); 857 ce->ce_namelen = len; 858 ce->ce_mode =create_ce_mode(mode); 859 860return ce; 861} 862 863/* 864 * Chmod an index entry with either +x or -x. 865 * 866 * Returns -1 if the chmod for the particular cache entry failed (if it's 867 * not a regular file), -2 if an invalid flip argument is passed in, 0 868 * otherwise. 869 */ 870intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 871char flip) 872{ 873if(!S_ISREG(ce->ce_mode)) 874return-1; 875switch(flip) { 876case'+': 877 ce->ce_mode |=0111; 878break; 879case'-': 880 ce->ce_mode &= ~0111; 881break; 882default: 883return-2; 884} 885cache_tree_invalidate_path(istate, ce->name); 886 ce->ce_flags |= CE_UPDATE_IN_BASE; 887mark_fsmonitor_invalid(istate, ce); 888 istate->cache_changed |= CE_ENTRY_CHANGED; 889 890return0; 891} 892 893intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 894{ 895int len =ce_namelen(a); 896returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 897} 898 899/* 900 * We fundamentally don't like some paths: we don't want 901 * dot or dot-dot anywhere, and for obvious reasons don't 902 * want to recurse into ".git" either. 903 * 904 * Also, we don't want double slashes or slashes at the 905 * end that can make pathnames ambiguous. 906 */ 907static intverify_dotfile(const char*rest,unsigned mode) 908{ 909/* 910 * The first character was '.', but that 911 * has already been discarded, we now test 912 * the rest. 913 */ 914 915/* "." is not allowed */ 916if(*rest =='\0'||is_dir_sep(*rest)) 917return0; 918 919switch(*rest) { 920/* 921 * ".git" followed by NUL or slash is bad. Note that we match 922 * case-insensitively here, even if ignore_case is not set. 923 * This outlaws ".GIT" everywhere out of an abundance of caution, 924 * since there's really no good reason to allow it. 925 * 926 * Once we've seen ".git", we can also find ".gitmodules", etc (also 927 * case-insensitively). 928 */ 929case'g': 930case'G': 931if(rest[1] !='i'&& rest[1] !='I') 932break; 933if(rest[2] !='t'&& rest[2] !='T') 934break; 935if(rest[3] =='\0'||is_dir_sep(rest[3])) 936return0; 937if(S_ISLNK(mode)) { 938 rest +=3; 939if(skip_iprefix(rest,"modules", &rest) && 940(*rest =='\0'||is_dir_sep(*rest))) 941return0; 942} 943break; 944case'.': 945if(rest[1] =='\0'||is_dir_sep(rest[1])) 946return0; 947} 948return1; 949} 950 951intverify_path(const char*path,unsigned mode) 952{ 953char c; 954 955if(has_dos_drive_prefix(path)) 956return0; 957 958goto inside; 959for(;;) { 960if(!c) 961return1; 962if(is_dir_sep(c)) { 963inside: 964if(protect_hfs) { 965if(is_hfs_dotgit(path)) 966return0; 967if(S_ISLNK(mode)) { 968if(is_hfs_dotgitmodules(path)) 969return0; 970} 971} 972if(protect_ntfs) { 973if(is_ntfs_dotgit(path)) 974return0; 975if(S_ISLNK(mode)) { 976if(is_ntfs_dotgitmodules(path)) 977return0; 978} 979} 980 981 c = *path++; 982if((c =='.'&& !verify_dotfile(path, mode)) || 983is_dir_sep(c) || c =='\0') 984return0; 985} 986 c = *path++; 987} 988} 989 990/* 991 * Do we have another file that has the beginning components being a 992 * proper superset of the name we're trying to add? 993 */ 994static inthas_file_name(struct index_state *istate, 995const struct cache_entry *ce,int pos,int ok_to_replace) 996{ 997int retval =0; 998int len =ce_namelen(ce); 999int stage =ce_stage(ce);1000const char*name = ce->name;10011002while(pos < istate->cache_nr) {1003struct cache_entry *p = istate->cache[pos++];10041005if(len >=ce_namelen(p))1006break;1007if(memcmp(name, p->name, len))1008break;1009if(ce_stage(p) != stage)1010continue;1011if(p->name[len] !='/')1012continue;1013if(p->ce_flags & CE_REMOVE)1014continue;1015 retval = -1;1016if(!ok_to_replace)1017break;1018remove_index_entry_at(istate, --pos);1019}1020return retval;1021}102210231024/*1025 * Like strcmp(), but also return the offset of the first change.1026 * If strings are equal, return the length.1027 */1028intstrcmp_offset(const char*s1,const char*s2,size_t*first_change)1029{1030size_t k;10311032if(!first_change)1033returnstrcmp(s1, s2);10341035for(k =0; s1[k] == s2[k]; k++)1036if(s1[k] =='\0')1037break;10381039*first_change = k;1040return(unsigned char)s1[k] - (unsigned char)s2[k];1041}10421043/*1044 * Do we have another file with a pathname that is a proper1045 * subset of the name we're trying to add?1046 *1047 * That is, is there another file in the index with a path1048 * that matches a sub-directory in the given entry?1049 */1050static inthas_dir_name(struct index_state *istate,1051const struct cache_entry *ce,int pos,int ok_to_replace)1052{1053int retval =0;1054int stage =ce_stage(ce);1055const char*name = ce->name;1056const char*slash = name +ce_namelen(ce);1057size_t len_eq_last;1058int cmp_last =0;10591060/*1061 * We are frequently called during an iteration on a sorted1062 * list of pathnames and while building a new index. Therefore,1063 * there is a high probability that this entry will eventually1064 * be appended to the index, rather than inserted in the middle.1065 * If we can confirm that, we can avoid binary searches on the1066 * components of the pathname.1067 *1068 * Compare the entry's full path with the last path in the index.1069 */1070if(istate->cache_nr >0) {1071 cmp_last =strcmp_offset(name,1072 istate->cache[istate->cache_nr -1]->name,1073&len_eq_last);1074if(cmp_last >0) {1075if(len_eq_last ==0) {1076/*1077 * The entry sorts AFTER the last one in the1078 * index and their paths have no common prefix,1079 * so there cannot be a F/D conflict.1080 */1081return retval;1082}else{1083/*1084 * The entry sorts AFTER the last one in the1085 * index, but has a common prefix. Fall through1086 * to the loop below to disect the entry's path1087 * and see where the difference is.1088 */1089}1090}else if(cmp_last ==0) {1091/*1092 * The entry exactly matches the last one in the1093 * index, but because of multiple stage and CE_REMOVE1094 * items, we fall through and let the regular search1095 * code handle it.1096 */1097}1098}10991100for(;;) {1101size_t len;11021103for(;;) {1104if(*--slash =='/')1105break;1106if(slash <= ce->name)1107return retval;1108}1109 len = slash - name;11101111if(cmp_last >0) {1112/*1113 * (len + 1) is a directory boundary (including1114 * the trailing slash). And since the loop is1115 * decrementing "slash", the first iteration is1116 * the longest directory prefix; subsequent1117 * iterations consider parent directories.1118 */11191120if(len +1<= len_eq_last) {1121/*1122 * The directory prefix (including the trailing1123 * slash) also appears as a prefix in the last1124 * entry, so the remainder cannot collide (because1125 * strcmp said the whole path was greater).1126 *1127 * EQ: last: xxx/A1128 * this: xxx/B1129 *1130 * LT: last: xxx/file_A1131 * this: xxx/file_B1132 */1133return retval;1134}11351136if(len > len_eq_last) {1137/*1138 * This part of the directory prefix (excluding1139 * the trailing slash) is longer than the known1140 * equal portions, so this sub-directory cannot1141 * collide with a file.1142 *1143 * GT: last: xxxA1144 * this: xxxB/file1145 */1146return retval;1147}11481149if(istate->cache_nr >0&&1150ce_namelen(istate->cache[istate->cache_nr -1]) > len) {1151/*1152 * The directory prefix lines up with part of1153 * a longer file or directory name, but sorts1154 * after it, so this sub-directory cannot1155 * collide with a file.1156 *1157 * last: xxx/yy-file (because '-' sorts before '/')1158 * this: xxx/yy/abc1159 */1160return retval;1161}11621163/*1164 * This is a possible collision. Fall through and1165 * let the regular search code handle it.1166 *1167 * last: xxx1168 * this: xxx/file1169 */1170}11711172 pos =index_name_stage_pos(istate, name, len, stage);1173if(pos >=0) {1174/*1175 * Found one, but not so fast. This could1176 * be a marker that says "I was here, but1177 * I am being removed". Such an entry is1178 * not a part of the resulting tree, and1179 * it is Ok to have a directory at the same1180 * path.1181 */1182if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) {1183 retval = -1;1184if(!ok_to_replace)1185break;1186remove_index_entry_at(istate, pos);1187continue;1188}1189}1190else1191 pos = -pos-1;11921193/*1194 * Trivial optimization: if we find an entry that1195 * already matches the sub-directory, then we know1196 * we're ok, and we can exit.1197 */1198while(pos < istate->cache_nr) {1199struct cache_entry *p = istate->cache[pos];1200if((ce_namelen(p) <= len) ||1201(p->name[len] !='/') ||1202memcmp(p->name, name, len))1203break;/* not our subdirectory */1204if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))1205/*1206 * p is at the same stage as our entry, and1207 * is a subdirectory of what we are looking1208 * at, so we cannot have conflicts at our1209 * level or anything shorter.1210 */1211return retval;1212 pos++;1213}1214}1215return retval;1216}12171218/* We may be in a situation where we already have path/file and path1219 * is being added, or we already have path and path/file is being1220 * added. Either one would result in a nonsense tree that has path1221 * twice when git-write-tree tries to write it out. Prevent it.1222 *1223 * If ok-to-replace is specified, we remove the conflicting entries1224 * from the cache so the caller should recompute the insert position.1225 * When this happens, we return non-zero.1226 */1227static intcheck_file_directory_conflict(struct index_state *istate,1228const struct cache_entry *ce,1229int pos,int ok_to_replace)1230{1231int retval;12321233/*1234 * When ce is an "I am going away" entry, we allow it to be added1235 */1236if(ce->ce_flags & CE_REMOVE)1237return0;12381239/*1240 * We check if the path is a sub-path of a subsequent pathname1241 * first, since removing those will not change the position1242 * in the array.1243 */1244 retval =has_file_name(istate, ce, pos, ok_to_replace);12451246/*1247 * Then check if the path might have a clashing sub-directory1248 * before it.1249 */1250return retval +has_dir_name(istate, ce, pos, ok_to_replace);1251}12521253static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1254{1255int pos;1256int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1257int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1258int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1259int new_only = option & ADD_CACHE_NEW_ONLY;12601261if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1262cache_tree_invalidate_path(istate, ce->name);12631264/*1265 * If this entry's path sorts after the last entry in the index,1266 * we can avoid searching for it.1267 */1268if(istate->cache_nr >0&&1269strcmp(ce->name, istate->cache[istate->cache_nr -1]->name) >0)1270 pos = -istate->cache_nr -1;1271else1272 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));12731274/* existing match? Just replace it. */1275if(pos >=0) {1276if(!new_only)1277replace_index_entry(istate, pos, ce);1278return0;1279}1280 pos = -pos-1;12811282if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1283untracked_cache_add_to_index(istate, ce->name);12841285/*1286 * Inserting a merged entry ("stage 0") into the index1287 * will always replace all non-merged entries..1288 */1289if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1290while(ce_same_name(istate->cache[pos], ce)) {1291 ok_to_add =1;1292if(!remove_index_entry_at(istate, pos))1293break;1294}1295}12961297if(!ok_to_add)1298return-1;1299if(!verify_path(ce->name, ce->ce_mode))1300returnerror("Invalid path '%s'", ce->name);13011302if(!skip_df_check &&1303check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1304if(!ok_to_replace)1305returnerror("'%s' appears as both a file and as a directory",1306 ce->name);1307 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1308 pos = -pos-1;1309}1310return pos +1;1311}13121313intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1314{1315int pos;13161317if(option & ADD_CACHE_JUST_APPEND)1318 pos = istate->cache_nr;1319else{1320int ret;1321 ret =add_index_entry_with_check(istate, ce, option);1322if(ret <=0)1323return ret;1324 pos = ret -1;1325}13261327/* Make sure the array is big enough .. */1328ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);13291330/* Add it in.. */1331 istate->cache_nr++;1332if(istate->cache_nr > pos +1)1333MOVE_ARRAY(istate->cache + pos +1, istate->cache + pos,1334 istate->cache_nr - pos -1);1335set_index_entry(istate, pos, ce);1336 istate->cache_changed |= CE_ENTRY_ADDED;1337return0;1338}13391340/*1341 * "refresh" does not calculate a new sha1 file or bring the1342 * cache up-to-date for mode/content changes. But what it1343 * _does_ do is to "re-match" the stat information of a file1344 * with the cache, so that you can refresh the cache for a1345 * file that hasn't been changed but where the stat entry is1346 * out of date.1347 *1348 * For example, you'd want to do this after doing a "git-read-tree",1349 * to link up the stat cache details with the proper files.1350 */1351static struct cache_entry *refresh_cache_ent(struct index_state *istate,1352struct cache_entry *ce,1353unsigned int options,int*err,1354int*changed_ret)1355{1356struct stat st;1357struct cache_entry *updated;1358int changed;1359int refresh = options & CE_MATCH_REFRESH;1360int ignore_valid = options & CE_MATCH_IGNORE_VALID;1361int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1362int ignore_missing = options & CE_MATCH_IGNORE_MISSING;1363int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR;13641365if(!refresh ||ce_uptodate(ce))1366return ce;13671368if(!ignore_fsmonitor)1369refresh_fsmonitor(istate);1370/*1371 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1372 * that the change to the work tree does not matter and told1373 * us not to worry.1374 */1375if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1376ce_mark_uptodate(ce);1377return ce;1378}1379if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1380ce_mark_uptodate(ce);1381return ce;1382}1383if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) {1384ce_mark_uptodate(ce);1385return ce;1386}13871388if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1389if(ignore_missing)1390return ce;1391if(err)1392*err = ENOENT;1393return NULL;1394}13951396if(lstat(ce->name, &st) <0) {1397if(ignore_missing && errno == ENOENT)1398return ce;1399if(err)1400*err = errno;1401return NULL;1402}14031404 changed =ie_match_stat(istate, ce, &st, options);1405if(changed_ret)1406*changed_ret = changed;1407if(!changed) {1408/*1409 * The path is unchanged. If we were told to ignore1410 * valid bit, then we did the actual stat check and1411 * found that the entry is unmodified. If the entry1412 * is not marked VALID, this is the place to mark it1413 * valid again, under "assume unchanged" mode.1414 */1415if(ignore_valid && assume_unchanged &&1416!(ce->ce_flags & CE_VALID))1417;/* mark this one VALID again */1418else{1419/*1420 * We do not mark the index itself "modified"1421 * because CE_UPTODATE flag is in-core only;1422 * we are not going to write this change out.1423 */1424if(!S_ISGITLINK(ce->ce_mode)) {1425ce_mark_uptodate(ce);1426mark_fsmonitor_valid(ce);1427}1428return ce;1429}1430}14311432if(ie_modified(istate, ce, &st, options)) {1433if(err)1434*err = EINVAL;1435return NULL;1436}14371438 updated =make_empty_cache_entry(istate,ce_namelen(ce));1439copy_cache_entry(updated, ce);1440memcpy(updated->name, ce->name, ce->ce_namelen +1);1441fill_stat_cache_info(updated, &st);1442/*1443 * If ignore_valid is not set, we should leave CE_VALID bit1444 * alone. Otherwise, paths marked with --no-assume-unchanged1445 * (i.e. things to be edited) will reacquire CE_VALID bit1446 * automatically, which is not really what we want.1447 */1448if(!ignore_valid && assume_unchanged &&1449!(ce->ce_flags & CE_VALID))1450 updated->ce_flags &= ~CE_VALID;14511452/* istate->cache_changed is updated in the caller */1453return updated;1454}14551456static voidshow_file(const char* fmt,const char* name,int in_porcelain,1457int* first,const char*header_msg)1458{1459if(in_porcelain && *first && header_msg) {1460printf("%s\n", header_msg);1461*first =0;1462}1463printf(fmt, name);1464}14651466intrefresh_index(struct index_state *istate,unsigned int flags,1467const struct pathspec *pathspec,1468char*seen,const char*header_msg)1469{1470int i;1471int has_errors =0;1472int really = (flags & REFRESH_REALLY) !=0;1473int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1474int quiet = (flags & REFRESH_QUIET) !=0;1475int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1476int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1477int first =1;1478int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1479unsigned int options = (CE_MATCH_REFRESH |1480(really ? CE_MATCH_IGNORE_VALID :0) |1481(not_new ? CE_MATCH_IGNORE_MISSING :0));1482const char*modified_fmt;1483const char*deleted_fmt;1484const char*typechange_fmt;1485const char*added_fmt;1486const char*unmerged_fmt;1487struct progress *progress = NULL;14881489if(flags & REFRESH_PROGRESS &&isatty(2))1490 progress =start_delayed_progress(_("Refresh index"),1491 istate->cache_nr);14921493trace_performance_enter();1494 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1495 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1496 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1497 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1498 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1499for(i =0; i < istate->cache_nr; i++) {1500struct cache_entry *ce, *new_entry;1501int cache_errno =0;1502int changed =0;1503int filtered =0;15041505 ce = istate->cache[i];1506if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1507continue;15081509if(pathspec && !ce_path_match(istate, ce, pathspec, seen))1510 filtered =1;15111512if(ce_stage(ce)) {1513while((i < istate->cache_nr) &&1514!strcmp(istate->cache[i]->name, ce->name))1515 i++;1516 i--;1517if(allow_unmerged)1518continue;1519if(!filtered)1520show_file(unmerged_fmt, ce->name, in_porcelain,1521&first, header_msg);1522 has_errors =1;1523continue;1524}15251526if(filtered)1527continue;15281529 new_entry =refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1530if(new_entry == ce)1531continue;1532if(progress)1533display_progress(progress, i);1534if(!new_entry) {1535const char*fmt;15361537if(really && cache_errno == EINVAL) {1538/* If we are doing --really-refresh that1539 * means the index is not valid anymore.1540 */1541 ce->ce_flags &= ~CE_VALID;1542 ce->ce_flags |= CE_UPDATE_IN_BASE;1543mark_fsmonitor_invalid(istate, ce);1544 istate->cache_changed |= CE_ENTRY_CHANGED;1545}1546if(quiet)1547continue;15481549if(cache_errno == ENOENT)1550 fmt = deleted_fmt;1551else if(ce_intent_to_add(ce))1552 fmt = added_fmt;/* must be before other checks */1553else if(changed & TYPE_CHANGED)1554 fmt = typechange_fmt;1555else1556 fmt = modified_fmt;1557show_file(fmt,1558 ce->name, in_porcelain, &first, header_msg);1559 has_errors =1;1560continue;1561}15621563replace_index_entry(istate, i, new_entry);1564}1565if(progress) {1566display_progress(progress, istate->cache_nr);1567stop_progress(&progress);1568}1569trace_performance_leave("refresh index");1570return has_errors;1571}15721573struct cache_entry *refresh_cache_entry(struct index_state *istate,1574struct cache_entry *ce,1575unsigned int options)1576{1577returnrefresh_cache_ent(istate, ce, options, NULL, NULL);1578}157915801581/*****************************************************************1582 * Index File I/O1583 *****************************************************************/15841585#define INDEX_FORMAT_DEFAULT 315861587static unsigned intget_index_format_default(void)1588{1589char*envversion =getenv("GIT_INDEX_VERSION");1590char*endp;1591int value;1592unsigned int version = INDEX_FORMAT_DEFAULT;15931594if(!envversion) {1595if(!git_config_get_int("index.version", &value))1596 version = value;1597if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1598warning(_("index.version set, but the value is invalid.\n"1599"Using version%i"), INDEX_FORMAT_DEFAULT);1600return INDEX_FORMAT_DEFAULT;1601}1602return version;1603}16041605 version =strtoul(envversion, &endp,10);1606if(*endp ||1607 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1608warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1609"Using version%i"), INDEX_FORMAT_DEFAULT);1610 version = INDEX_FORMAT_DEFAULT;1611}1612return version;1613}16141615/*1616 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1617 * Again - this is just a (very strong in practice) heuristic that1618 * the inode hasn't changed.1619 *1620 * We save the fields in big-endian order to allow using the1621 * index file over NFS transparently.1622 */1623struct ondisk_cache_entry {1624struct cache_time ctime;1625struct cache_time mtime;1626uint32_t dev;1627uint32_t ino;1628uint32_t mode;1629uint32_t uid;1630uint32_t gid;1631uint32_t size;1632unsigned char sha1[20];1633uint16_t flags;1634char name[FLEX_ARRAY];/* more */1635};16361637/*1638 * This struct is used when CE_EXTENDED bit is 11639 * The struct must match ondisk_cache_entry exactly from1640 * ctime till flags1641 */1642struct ondisk_cache_entry_extended {1643struct cache_time ctime;1644struct cache_time mtime;1645uint32_t dev;1646uint32_t ino;1647uint32_t mode;1648uint32_t uid;1649uint32_t gid;1650uint32_t size;1651unsigned char sha1[20];1652uint16_t flags;1653uint16_t flags2;1654char name[FLEX_ARRAY];/* more */1655};16561657/* These are only used for v3 or lower */1658#define align_padding_size(size, len) ((size + (len) + 8) & ~7) - (size + len)1659#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1660#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1661#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1662#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1663 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1664 ondisk_cache_entry_size(ce_namelen(ce)))16651666/* Allow fsck to force verification of the index checksum. */1667int verify_index_checksum;16681669/* Allow fsck to force verification of the cache entry order. */1670int verify_ce_order;16711672static intverify_hdr(const struct cache_header *hdr,unsigned long size)1673{1674 git_hash_ctx c;1675unsigned char hash[GIT_MAX_RAWSZ];1676int hdr_version;16771678if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1679returnerror("bad signature");1680 hdr_version =ntohl(hdr->hdr_version);1681if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1682returnerror("bad index version%d", hdr_version);16831684if(!verify_index_checksum)1685return0;16861687 the_hash_algo->init_fn(&c);1688 the_hash_algo->update_fn(&c, hdr, size - the_hash_algo->rawsz);1689 the_hash_algo->final_fn(hash, &c);1690if(!hasheq(hash, (unsigned char*)hdr + size - the_hash_algo->rawsz))1691returnerror("bad index file sha1 signature");1692return0;1693}16941695static intread_index_extension(struct index_state *istate,1696const char*ext,const char*data,unsigned long sz)1697{1698switch(CACHE_EXT(ext)) {1699case CACHE_EXT_TREE:1700 istate->cache_tree =cache_tree_read(data, sz);1701break;1702case CACHE_EXT_RESOLVE_UNDO:1703 istate->resolve_undo =resolve_undo_read(data, sz);1704break;1705case CACHE_EXT_LINK:1706if(read_link_extension(istate, data, sz))1707return-1;1708break;1709case CACHE_EXT_UNTRACKED:1710 istate->untracked =read_untracked_extension(data, sz);1711break;1712case CACHE_EXT_FSMONITOR:1713read_fsmonitor_extension(istate, data, sz);1714break;1715case CACHE_EXT_ENDOFINDEXENTRIES:1716case CACHE_EXT_INDEXENTRYOFFSETTABLE:1717/* already handled in do_read_index() */1718break;1719default:1720if(*ext <'A'||'Z'< *ext)1721returnerror("index uses %.4s extension, which we do not understand",1722 ext);1723fprintf(stderr,"ignoring %.4s extension\n", ext);1724break;1725}1726return0;1727}17281729inthold_locked_index(struct lock_file *lk,int lock_flags)1730{1731returnhold_lock_file_for_update(lk,get_index_file(), lock_flags);1732}17331734intread_index(struct index_state *istate)1735{1736returnread_index_from(istate,get_index_file(),get_git_dir());1737}17381739static struct cache_entry *create_from_disk(struct mem_pool *ce_mem_pool,1740unsigned int version,1741struct ondisk_cache_entry *ondisk,1742unsigned long*ent_size,1743const struct cache_entry *previous_ce)1744{1745struct cache_entry *ce;1746size_t len;1747const char*name;1748unsigned int flags;1749size_t copy_len;1750/*1751 * Adjacent cache entries tend to share the leading paths, so it makes1752 * sense to only store the differences in later entries. In the v41753 * on-disk format of the index, each on-disk cache entry stores the1754 * number of bytes to be stripped from the end of the previous name,1755 * and the bytes to append to the result, to come up with its name.1756 */1757int expand_name_field = version ==4;17581759/* On-disk flags are just 16 bits */1760 flags =get_be16(&ondisk->flags);1761 len = flags & CE_NAMEMASK;17621763if(flags & CE_EXTENDED) {1764struct ondisk_cache_entry_extended *ondisk2;1765int extended_flags;1766 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1767 extended_flags =get_be16(&ondisk2->flags2) <<16;1768/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1769if(extended_flags & ~CE_EXTENDED_FLAGS)1770die("Unknown index entry format%08x", extended_flags);1771 flags |= extended_flags;1772 name = ondisk2->name;1773}1774else1775 name = ondisk->name;17761777if(expand_name_field) {1778const unsigned char*cp = (const unsigned char*)name;1779size_t strip_len, previous_len;17801781/* If we're at the begining of a block, ignore the previous name */1782 strip_len =decode_varint(&cp);1783if(previous_ce) {1784 previous_len = previous_ce->ce_namelen;1785if(previous_len < strip_len)1786die(_("malformed name field in the index, near path '%s'"),1787 previous_ce->name);1788 copy_len = previous_len - strip_len;1789}else{1790 copy_len =0;1791}1792 name = (const char*)cp;1793}17941795if(len == CE_NAMEMASK) {1796 len =strlen(name);1797if(expand_name_field)1798 len += copy_len;1799}18001801 ce =mem_pool__ce_alloc(ce_mem_pool, len);18021803 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1804 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1805 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1806 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1807 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1808 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1809 ce->ce_mode =get_be32(&ondisk->mode);1810 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1811 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1812 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1813 ce->ce_flags = flags & ~CE_NAMEMASK;1814 ce->ce_namelen = len;1815 ce->index =0;1816hashcpy(ce->oid.hash, ondisk->sha1);18171818if(expand_name_field) {1819if(copy_len)1820memcpy(ce->name, previous_ce->name, copy_len);1821memcpy(ce->name + copy_len, name, len +1- copy_len);1822*ent_size = (name - ((char*)ondisk)) + len +1- copy_len;1823}else{1824memcpy(ce->name, name, len +1);1825*ent_size =ondisk_ce_size(ce);1826}1827return ce;1828}18291830static voidcheck_ce_order(struct index_state *istate)1831{1832unsigned int i;18331834if(!verify_ce_order)1835return;18361837for(i =1; i < istate->cache_nr; i++) {1838struct cache_entry *ce = istate->cache[i -1];1839struct cache_entry *next_ce = istate->cache[i];1840int name_compare =strcmp(ce->name, next_ce->name);18411842if(0< name_compare)1843die("unordered stage entries in index");1844if(!name_compare) {1845if(!ce_stage(ce))1846die("multiple stage entries for merged file '%s'",1847 ce->name);1848if(ce_stage(ce) >ce_stage(next_ce))1849die("unordered stage entries for '%s'",1850 ce->name);1851}1852}1853}18541855static voidtweak_untracked_cache(struct index_state *istate)1856{1857switch(git_config_get_untracked_cache()) {1858case-1:/* keep: do nothing */1859break;1860case0:/* false */1861remove_untracked_cache(istate);1862break;1863case1:/* true */1864add_untracked_cache(istate);1865break;1866default:/* unknown value: do nothing */1867break;1868}1869}18701871static voidtweak_split_index(struct index_state *istate)1872{1873switch(git_config_get_split_index()) {1874case-1:/* unset: do nothing */1875break;1876case0:/* false */1877remove_split_index(istate);1878break;1879case1:/* true */1880add_split_index(istate);1881break;1882default:/* unknown value: do nothing */1883break;1884}1885}18861887static voidpost_read_index_from(struct index_state *istate)1888{1889check_ce_order(istate);1890tweak_untracked_cache(istate);1891tweak_split_index(istate);1892tweak_fsmonitor(istate);1893}18941895static size_testimate_cache_size_from_compressed(unsigned int entries)1896{1897return entries * (sizeof(struct cache_entry) + CACHE_ENTRY_PATH_LENGTH);1898}18991900static size_testimate_cache_size(size_t ondisk_size,unsigned int entries)1901{1902long per_entry =sizeof(struct cache_entry) -sizeof(struct ondisk_cache_entry);19031904/*1905 * Account for potential alignment differences.1906 */1907 per_entry +=align_padding_size(sizeof(struct cache_entry), -sizeof(struct ondisk_cache_entry));1908return ondisk_size + entries * per_entry;1909}19101911struct index_entry_offset1912{1913/* starting byte offset into index file, count of index entries in this block */1914int offset, nr;1915};19161917struct index_entry_offset_table1918{1919int nr;1920struct index_entry_offset entries[FLEX_ARRAY];1921};19221923static struct index_entry_offset_table *read_ieot_extension(const char*mmap,size_t mmap_size,size_t offset);1924static voidwrite_ieot_extension(struct strbuf *sb,struct index_entry_offset_table *ieot);19251926static size_tread_eoie_extension(const char*mmap,size_t mmap_size);1927static voidwrite_eoie_extension(struct strbuf *sb, git_hash_ctx *eoie_context,size_t offset);19281929struct load_index_extensions1930{1931 pthread_t pthread;1932struct index_state *istate;1933const char*mmap;1934size_t mmap_size;1935unsigned long src_offset;1936};19371938static void*load_index_extensions(void*_data)1939{1940struct load_index_extensions *p = _data;1941unsigned long src_offset = p->src_offset;19421943while(src_offset <= p->mmap_size - the_hash_algo->rawsz -8) {1944/* After an array of active_nr index entries,1945 * there can be arbitrary number of extended1946 * sections, each of which is prefixed with1947 * extension name (4-byte) and section length1948 * in 4-byte network byte order.1949 */1950uint32_t extsize =get_be32(p->mmap + src_offset +4);1951if(read_index_extension(p->istate,1952 p->mmap + src_offset,1953 p->mmap + src_offset +8,1954 extsize) <0) {1955munmap((void*)p->mmap, p->mmap_size);1956die(_("index file corrupt"));1957}1958 src_offset +=8;1959 src_offset += extsize;1960}19611962return NULL;1963}19641965/*1966 * A helper function that will load the specified range of cache entries1967 * from the memory mapped file and add them to the given index.1968 */1969static unsigned longload_cache_entry_block(struct index_state *istate,1970struct mem_pool *ce_mem_pool,int offset,int nr,const char*mmap,1971unsigned long start_offset,const struct cache_entry *previous_ce)1972{1973int i;1974unsigned long src_offset = start_offset;19751976for(i = offset; i < offset + nr; i++) {1977struct ondisk_cache_entry *disk_ce;1978struct cache_entry *ce;1979unsigned long consumed;19801981 disk_ce = (struct ondisk_cache_entry *)(mmap + src_offset);1982 ce =create_from_disk(ce_mem_pool, istate->version, disk_ce, &consumed, previous_ce);1983set_index_entry(istate, i, ce);19841985 src_offset += consumed;1986 previous_ce = ce;1987}1988return src_offset - start_offset;1989}19901991static unsigned longload_all_cache_entries(struct index_state *istate,1992const char*mmap,size_t mmap_size,unsigned long src_offset)1993{1994unsigned long consumed;19951996if(istate->version ==4) {1997mem_pool_init(&istate->ce_mem_pool,1998estimate_cache_size_from_compressed(istate->cache_nr));1999}else{2000mem_pool_init(&istate->ce_mem_pool,2001estimate_cache_size(mmap_size, istate->cache_nr));2002}20032004 consumed =load_cache_entry_block(istate, istate->ce_mem_pool,20050, istate->cache_nr, mmap, src_offset, NULL);2006return consumed;2007}20082009/*2010 * Mostly randomly chosen maximum thread counts: we2011 * cap the parallelism to online_cpus() threads, and we want2012 * to have at least 10000 cache entries per thread for it to2013 * be worth starting a thread.2014 */20152016#define THREAD_COST (10000)20172018struct load_cache_entries_thread_data2019{2020 pthread_t pthread;2021struct index_state *istate;2022struct mem_pool *ce_mem_pool;2023int offset;2024const char*mmap;2025struct index_entry_offset_table *ieot;2026int ieot_start;/* starting index into the ieot array */2027int ieot_blocks;/* count of ieot entries to process */2028unsigned long consumed;/* return # of bytes in index file processed */2029};20302031/*2032 * A thread proc to run the load_cache_entries() computation2033 * across multiple background threads.2034 */2035static void*load_cache_entries_thread(void*_data)2036{2037struct load_cache_entries_thread_data *p = _data;2038int i;20392040/* iterate across all ieot blocks assigned to this thread */2041for(i = p->ieot_start; i < p->ieot_start + p->ieot_blocks; i++) {2042 p->consumed +=load_cache_entry_block(p->istate, p->ce_mem_pool,2043 p->offset, p->ieot->entries[i].nr, p->mmap, p->ieot->entries[i].offset, NULL);2044 p->offset += p->ieot->entries[i].nr;2045}2046return NULL;2047}20482049static unsigned longload_cache_entries_threaded(struct index_state *istate,const char*mmap,size_t mmap_size,2050unsigned long src_offset,int nr_threads,struct index_entry_offset_table *ieot)2051{2052int i, offset, ieot_blocks, ieot_start, err;2053struct load_cache_entries_thread_data *data;2054unsigned long consumed =0;20552056/* a little sanity checking */2057if(istate->name_hash_initialized)2058BUG("the name hash isn't thread safe");20592060mem_pool_init(&istate->ce_mem_pool,0);20612062/* ensure we have no more threads than we have blocks to process */2063if(nr_threads > ieot->nr)2064 nr_threads = ieot->nr;2065 data =xcalloc(nr_threads,sizeof(*data));20662067 offset = ieot_start =0;2068 ieot_blocks =DIV_ROUND_UP(ieot->nr, nr_threads);2069for(i =0; i < nr_threads; i++) {2070struct load_cache_entries_thread_data *p = &data[i];2071int nr, j;20722073if(ieot_start + ieot_blocks > ieot->nr)2074 ieot_blocks = ieot->nr - ieot_start;20752076 p->istate = istate;2077 p->offset = offset;2078 p->mmap = mmap;2079 p->ieot = ieot;2080 p->ieot_start = ieot_start;2081 p->ieot_blocks = ieot_blocks;20822083/* create a mem_pool for each thread */2084 nr =0;2085for(j = p->ieot_start; j < p->ieot_start + p->ieot_blocks; j++)2086 nr += p->ieot->entries[j].nr;2087if(istate->version ==4) {2088mem_pool_init(&p->ce_mem_pool,2089estimate_cache_size_from_compressed(nr));2090}else{2091mem_pool_init(&p->ce_mem_pool,2092estimate_cache_size(mmap_size, nr));2093}20942095 err =pthread_create(&p->pthread, NULL, load_cache_entries_thread, p);2096if(err)2097die(_("unable to create load_cache_entries thread:%s"),strerror(err));20982099/* increment by the number of cache entries in the ieot block being processed */2100for(j =0; j < ieot_blocks; j++)2101 offset += ieot->entries[ieot_start + j].nr;2102 ieot_start += ieot_blocks;2103}21042105for(i =0; i < nr_threads; i++) {2106struct load_cache_entries_thread_data *p = &data[i];21072108 err =pthread_join(p->pthread, NULL);2109if(err)2110die(_("unable to join load_cache_entries thread:%s"),strerror(err));2111mem_pool_combine(istate->ce_mem_pool, p->ce_mem_pool);2112 consumed += p->consumed;2113}21142115free(data);21162117return consumed;2118}21192120/* remember to discard_cache() before reading a different cache! */2121intdo_read_index(struct index_state *istate,const char*path,int must_exist)2122{2123int fd;2124struct stat st;2125unsigned long src_offset;2126const struct cache_header *hdr;2127const char*mmap;2128size_t mmap_size;2129struct load_index_extensions p;2130size_t extension_offset =0;2131int nr_threads, cpus;2132struct index_entry_offset_table *ieot = NULL;21332134if(istate->initialized)2135return istate->cache_nr;21362137 istate->timestamp.sec =0;2138 istate->timestamp.nsec =0;2139 fd =open(path, O_RDONLY);2140if(fd <0) {2141if(!must_exist && errno == ENOENT)2142return0;2143die_errno("%s: index file open failed", path);2144}21452146if(fstat(fd, &st))2147die_errno("cannot stat the open index");21482149 mmap_size =xsize_t(st.st_size);2150if(mmap_size <sizeof(struct cache_header) + the_hash_algo->rawsz)2151die("index file smaller than expected");21522153 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);2154if(mmap == MAP_FAILED)2155die_errno("unable to map index file");2156close(fd);21572158 hdr = (const struct cache_header *)mmap;2159if(verify_hdr(hdr, mmap_size) <0)2160goto unmap;21612162hashcpy(istate->oid.hash, (const unsigned char*)hdr + mmap_size - the_hash_algo->rawsz);2163 istate->version =ntohl(hdr->hdr_version);2164 istate->cache_nr =ntohl(hdr->hdr_entries);2165 istate->cache_alloc =alloc_nr(istate->cache_nr);2166 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));2167 istate->initialized =1;21682169 p.istate = istate;2170 p.mmap = mmap;2171 p.mmap_size = mmap_size;21722173 src_offset =sizeof(*hdr);21742175 nr_threads =git_config_get_index_threads();21762177/* TODO: does creating more threads than cores help? */2178if(!nr_threads) {2179 nr_threads = istate->cache_nr / THREAD_COST;2180 cpus =online_cpus();2181if(nr_threads > cpus)2182 nr_threads = cpus;2183}21842185if(!HAVE_THREADS)2186 nr_threads =1;21872188if(nr_threads >1) {2189 extension_offset =read_eoie_extension(mmap, mmap_size);2190if(extension_offset) {2191int err;21922193 p.src_offset = extension_offset;2194 err =pthread_create(&p.pthread, NULL, load_index_extensions, &p);2195if(err)2196die(_("unable to create load_index_extensions thread:%s"),strerror(err));21972198 nr_threads--;2199}2200}22012202/*2203 * Locate and read the index entry offset table so that we can use it2204 * to multi-thread the reading of the cache entries.2205 */2206if(extension_offset && nr_threads >1)2207 ieot =read_ieot_extension(mmap, mmap_size, extension_offset);22082209if(ieot) {2210 src_offset +=load_cache_entries_threaded(istate, mmap, mmap_size, src_offset, nr_threads, ieot);2211free(ieot);2212}else{2213 src_offset +=load_all_cache_entries(istate, mmap, mmap_size, src_offset);2214}22152216 istate->timestamp.sec = st.st_mtime;2217 istate->timestamp.nsec =ST_MTIME_NSEC(st);22182219/* if we created a thread, join it otherwise load the extensions on the primary thread */2220if(extension_offset) {2221int ret =pthread_join(p.pthread, NULL);2222if(ret)2223die(_("unable to join load_index_extensions thread:%s"),strerror(ret));2224}else{2225 p.src_offset = src_offset;2226load_index_extensions(&p);2227}2228munmap((void*)mmap, mmap_size);2229return istate->cache_nr;22302231unmap:2232munmap((void*)mmap, mmap_size);2233die("index file corrupt");2234}22352236/*2237 * Signal that the shared index is used by updating its mtime.2238 *2239 * This way, shared index can be removed if they have not been used2240 * for some time.2241 */2242static voidfreshen_shared_index(const char*shared_index,int warn)2243{2244if(!check_and_freshen_file(shared_index,1) && warn)2245warning("could not freshen shared index '%s'", shared_index);2246}22472248intread_index_from(struct index_state *istate,const char*path,2249const char*gitdir)2250{2251struct split_index *split_index;2252int ret;2253char*base_oid_hex;2254char*base_path;22552256/* istate->initialized covers both .git/index and .git/sharedindex.xxx */2257if(istate->initialized)2258return istate->cache_nr;22592260trace_performance_enter();2261 ret =do_read_index(istate, path,0);2262trace_performance_leave("read cache%s", path);22632264 split_index = istate->split_index;2265if(!split_index ||is_null_oid(&split_index->base_oid)) {2266post_read_index_from(istate);2267return ret;2268}22692270trace_performance_enter();2271if(split_index->base)2272discard_index(split_index->base);2273else2274 split_index->base =xcalloc(1,sizeof(*split_index->base));22752276 base_oid_hex =oid_to_hex(&split_index->base_oid);2277 base_path =xstrfmt("%s/sharedindex.%s", gitdir, base_oid_hex);2278 ret =do_read_index(split_index->base, base_path,1);2279if(!oideq(&split_index->base_oid, &split_index->base->oid))2280die("broken index, expect%sin%s, got%s",2281 base_oid_hex, base_path,2282oid_to_hex(&split_index->base->oid));22832284freshen_shared_index(base_path,0);2285merge_base_index(istate);2286post_read_index_from(istate);2287free(base_path);2288trace_performance_leave("read cache%s", base_path);2289return ret;2290}22912292intis_index_unborn(struct index_state *istate)2293{2294return(!istate->cache_nr && !istate->timestamp.sec);2295}22962297intdiscard_index(struct index_state *istate)2298{2299/*2300 * Cache entries in istate->cache[] should have been allocated2301 * from the memory pool associated with this index, or from an2302 * associated split_index. There is no need to free individual2303 * cache entries. validate_cache_entries can detect when this2304 * assertion does not hold.2305 */2306validate_cache_entries(istate);23072308resolve_undo_clear_index(istate);2309 istate->cache_nr =0;2310 istate->cache_changed =0;2311 istate->timestamp.sec =0;2312 istate->timestamp.nsec =0;2313free_name_hash(istate);2314cache_tree_free(&(istate->cache_tree));2315 istate->initialized =0;2316FREE_AND_NULL(istate->cache);2317 istate->cache_alloc =0;2318discard_split_index(istate);2319free_untracked_cache(istate->untracked);2320 istate->untracked = NULL;23212322if(istate->ce_mem_pool) {2323mem_pool_discard(istate->ce_mem_pool,should_validate_cache_entries());2324 istate->ce_mem_pool = NULL;2325}23262327return0;2328}23292330/*2331 * Validate the cache entries of this index.2332 * All cache entries associated with this index2333 * should have been allocated by the memory pool2334 * associated with this index, or by a referenced2335 * split index.2336 */2337voidvalidate_cache_entries(const struct index_state *istate)2338{2339int i;23402341if(!should_validate_cache_entries() ||!istate || !istate->initialized)2342return;23432344for(i =0; i < istate->cache_nr; i++) {2345if(!istate) {2346die("internal error: cache entry is not allocated from expected memory pool");2347}else if(!istate->ce_mem_pool ||2348!mem_pool_contains(istate->ce_mem_pool, istate->cache[i])) {2349if(!istate->split_index ||2350!istate->split_index->base ||2351!istate->split_index->base->ce_mem_pool ||2352!mem_pool_contains(istate->split_index->base->ce_mem_pool, istate->cache[i])) {2353die("internal error: cache entry is not allocated from expected memory pool");2354}2355}2356}23572358if(istate->split_index)2359validate_cache_entries(istate->split_index->base);2360}23612362intunmerged_index(const struct index_state *istate)2363{2364int i;2365for(i =0; i < istate->cache_nr; i++) {2366if(ce_stage(istate->cache[i]))2367return1;2368}2369return0;2370}23712372intindex_has_changes(struct index_state *istate,2373struct tree *tree,2374struct strbuf *sb)2375{2376struct object_id cmp;2377int i;23782379if(istate != &the_index) {2380BUG("index_has_changes cannot yet accept istate != &the_index; do_diff_cache needs updating first.");2381}2382if(tree)2383 cmp = tree->object.oid;2384if(tree || !get_oid_tree("HEAD", &cmp)) {2385struct diff_options opt;23862387repo_diff_setup(the_repository, &opt);2388 opt.flags.exit_with_status =1;2389if(!sb)2390 opt.flags.quick =1;2391do_diff_cache(&cmp, &opt);2392diffcore_std(&opt);2393for(i =0; sb && i < diff_queued_diff.nr; i++) {2394if(i)2395strbuf_addch(sb,' ');2396strbuf_addstr(sb, diff_queued_diff.queue[i]->two->path);2397}2398diff_flush(&opt);2399return opt.flags.has_changes !=0;2400}else{2401for(i =0; sb && i < istate->cache_nr; i++) {2402if(i)2403strbuf_addch(sb,' ');2404strbuf_addstr(sb, istate->cache[i]->name);2405}2406return!!istate->cache_nr;2407}2408}24092410#define WRITE_BUFFER_SIZE 81922411static unsigned char write_buffer[WRITE_BUFFER_SIZE];2412static unsigned long write_buffer_len;24132414static intce_write_flush(git_hash_ctx *context,int fd)2415{2416unsigned int buffered = write_buffer_len;2417if(buffered) {2418 the_hash_algo->update_fn(context, write_buffer, buffered);2419if(write_in_full(fd, write_buffer, buffered) <0)2420return-1;2421 write_buffer_len =0;2422}2423return0;2424}24252426static intce_write(git_hash_ctx *context,int fd,void*data,unsigned int len)2427{2428while(len) {2429unsigned int buffered = write_buffer_len;2430unsigned int partial = WRITE_BUFFER_SIZE - buffered;2431if(partial > len)2432 partial = len;2433memcpy(write_buffer + buffered, data, partial);2434 buffered += partial;2435if(buffered == WRITE_BUFFER_SIZE) {2436 write_buffer_len = buffered;2437if(ce_write_flush(context, fd))2438return-1;2439 buffered =0;2440}2441 write_buffer_len = buffered;2442 len -= partial;2443 data = (char*) data + partial;2444}2445return0;2446}24472448static intwrite_index_ext_header(git_hash_ctx *context, git_hash_ctx *eoie_context,2449int fd,unsigned int ext,unsigned int sz)2450{2451 ext =htonl(ext);2452 sz =htonl(sz);2453if(eoie_context) {2454 the_hash_algo->update_fn(eoie_context, &ext,4);2455 the_hash_algo->update_fn(eoie_context, &sz,4);2456}2457return((ce_write(context, fd, &ext,4) <0) ||2458(ce_write(context, fd, &sz,4) <0)) ? -1:0;2459}24602461static intce_flush(git_hash_ctx *context,int fd,unsigned char*hash)2462{2463unsigned int left = write_buffer_len;24642465if(left) {2466 write_buffer_len =0;2467 the_hash_algo->update_fn(context, write_buffer, left);2468}24692470/* Flush first if not enough space for hash signature */2471if(left + the_hash_algo->rawsz > WRITE_BUFFER_SIZE) {2472if(write_in_full(fd, write_buffer, left) <0)2473return-1;2474 left =0;2475}24762477/* Append the hash signature at the end */2478 the_hash_algo->final_fn(write_buffer + left, context);2479hashcpy(hash, write_buffer + left);2480 left += the_hash_algo->rawsz;2481return(write_in_full(fd, write_buffer, left) <0) ? -1:0;2482}24832484static voidce_smudge_racily_clean_entry(struct index_state *istate,2485struct cache_entry *ce)2486{2487/*2488 * The only thing we care about in this function is to smudge the2489 * falsely clean entry due to touch-update-touch race, so we leave2490 * everything else as they are. We are called for entries whose2491 * ce_stat_data.sd_mtime match the index file mtime.2492 *2493 * Note that this actually does not do much for gitlinks, for2494 * which ce_match_stat_basic() always goes to the actual2495 * contents. The caller checks with is_racy_timestamp() which2496 * always says "no" for gitlinks, so we are not called for them ;-)2497 */2498struct stat st;24992500if(lstat(ce->name, &st) <0)2501return;2502if(ce_match_stat_basic(ce, &st))2503return;2504if(ce_modified_check_fs(istate, ce, &st)) {2505/* This is "racily clean"; smudge it. Note that this2506 * is a tricky code. At first glance, it may appear2507 * that it can break with this sequence:2508 *2509 * $ echo xyzzy >frotz2510 * $ git-update-index --add frotz2511 * $ : >frotz2512 * $ sleep 32513 * $ echo filfre >nitfol2514 * $ git-update-index --add nitfol2515 *2516 * but it does not. When the second update-index runs,2517 * it notices that the entry "frotz" has the same timestamp2518 * as index, and if we were to smudge it by resetting its2519 * size to zero here, then the object name recorded2520 * in index is the 6-byte file but the cached stat information2521 * becomes zero --- which would then match what we would2522 * obtain from the filesystem next time we stat("frotz").2523 *2524 * However, the second update-index, before calling2525 * this function, notices that the cached size is 62526 * bytes and what is on the filesystem is an empty2527 * file, and never calls us, so the cached size information2528 * for "frotz" stays 6 which does not match the filesystem.2529 */2530 ce->ce_stat_data.sd_size =0;2531}2532}25332534/* Copy miscellaneous fields but not the name */2535static voidcopy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,2536struct cache_entry *ce)2537{2538short flags;25392540 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);2541 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);2542 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);2543 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);2544 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);2545 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);2546 ondisk->mode =htonl(ce->ce_mode);2547 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);2548 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);2549 ondisk->size =htonl(ce->ce_stat_data.sd_size);2550hashcpy(ondisk->sha1, ce->oid.hash);25512552 flags = ce->ce_flags & ~CE_NAMEMASK;2553 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));2554 ondisk->flags =htons(flags);2555if(ce->ce_flags & CE_EXTENDED) {2556struct ondisk_cache_entry_extended *ondisk2;2557 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;2558 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);2559}2560}25612562static intce_write_entry(git_hash_ctx *c,int fd,struct cache_entry *ce,2563struct strbuf *previous_name,struct ondisk_cache_entry *ondisk)2564{2565int size;2566int result;2567unsigned int saved_namelen;2568int stripped_name =0;2569static unsigned char padding[8] = {0x00};25702571if(ce->ce_flags & CE_STRIP_NAME) {2572 saved_namelen =ce_namelen(ce);2573 ce->ce_namelen =0;2574 stripped_name =1;2575}25762577if(ce->ce_flags & CE_EXTENDED)2578 size =offsetof(struct ondisk_cache_entry_extended, name);2579else2580 size =offsetof(struct ondisk_cache_entry, name);25812582if(!previous_name) {2583int len =ce_namelen(ce);2584copy_cache_entry_to_ondisk(ondisk, ce);2585 result =ce_write(c, fd, ondisk, size);2586if(!result)2587 result =ce_write(c, fd, ce->name, len);2588if(!result)2589 result =ce_write(c, fd, padding,align_padding_size(size, len));2590}else{2591int common, to_remove, prefix_size;2592unsigned char to_remove_vi[16];2593for(common =0;2594(ce->name[common] &&2595 common < previous_name->len &&2596 ce->name[common] == previous_name->buf[common]);2597 common++)2598;/* still matching */2599 to_remove = previous_name->len - common;2600 prefix_size =encode_varint(to_remove, to_remove_vi);26012602copy_cache_entry_to_ondisk(ondisk, ce);2603 result =ce_write(c, fd, ondisk, size);2604if(!result)2605 result =ce_write(c, fd, to_remove_vi, prefix_size);2606if(!result)2607 result =ce_write(c, fd, ce->name + common,ce_namelen(ce) - common);2608if(!result)2609 result =ce_write(c, fd, padding,1);26102611strbuf_splice(previous_name, common, to_remove,2612 ce->name + common,ce_namelen(ce) - common);2613}2614if(stripped_name) {2615 ce->ce_namelen = saved_namelen;2616 ce->ce_flags &= ~CE_STRIP_NAME;2617}26182619return result;2620}26212622/*2623 * This function verifies if index_state has the correct sha1 of the2624 * index file. Don't die if we have any other failure, just return 0.2625 */2626static intverify_index_from(const struct index_state *istate,const char*path)2627{2628int fd;2629 ssize_t n;2630struct stat st;2631unsigned char hash[GIT_MAX_RAWSZ];26322633if(!istate->initialized)2634return0;26352636 fd =open(path, O_RDONLY);2637if(fd <0)2638return0;26392640if(fstat(fd, &st))2641goto out;26422643if(st.st_size <sizeof(struct cache_header) + the_hash_algo->rawsz)2644goto out;26452646 n =pread_in_full(fd, hash, the_hash_algo->rawsz, st.st_size - the_hash_algo->rawsz);2647if(n != the_hash_algo->rawsz)2648goto out;26492650if(!hasheq(istate->oid.hash, hash))2651goto out;26522653close(fd);2654return1;26552656out:2657close(fd);2658return0;2659}26602661static intverify_index(const struct index_state *istate)2662{2663returnverify_index_from(istate,get_index_file());2664}26652666static inthas_racy_timestamp(struct index_state *istate)2667{2668int entries = istate->cache_nr;2669int i;26702671for(i =0; i < entries; i++) {2672struct cache_entry *ce = istate->cache[i];2673if(is_racy_timestamp(istate, ce))2674return1;2675}2676return0;2677}26782679voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2680{2681if((istate->cache_changed ||has_racy_timestamp(istate)) &&2682verify_index(istate))2683write_locked_index(istate, lockfile, COMMIT_LOCK);2684else2685rollback_lock_file(lockfile);2686}26872688/*2689 * On success, `tempfile` is closed. If it is the temporary file2690 * of a `struct lock_file`, we will therefore effectively perform2691 * a 'close_lock_file_gently()`. Since that is an implementation2692 * detail of lockfiles, callers of `do_write_index()` should not2693 * rely on it.2694 */2695static intdo_write_index(struct index_state *istate,struct tempfile *tempfile,2696int strip_extensions)2697{2698uint64_t start =getnanotime();2699int newfd = tempfile->fd;2700 git_hash_ctx c, eoie_c;2701struct cache_header hdr;2702int i, err =0, removed, extended, hdr_version;2703struct cache_entry **cache = istate->cache;2704int entries = istate->cache_nr;2705struct stat st;2706struct ondisk_cache_entry_extended ondisk;2707struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;2708int drop_cache_tree = istate->drop_cache_tree;2709 off_t offset;2710int ieot_entries =1;2711struct index_entry_offset_table *ieot = NULL;2712int nr, nr_threads;27132714for(i = removed = extended =0; i < entries; i++) {2715if(cache[i]->ce_flags & CE_REMOVE)2716 removed++;27172718/* reduce extended entries if possible */2719 cache[i]->ce_flags &= ~CE_EXTENDED;2720if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2721 extended++;2722 cache[i]->ce_flags |= CE_EXTENDED;2723}2724}27252726if(!istate->version) {2727 istate->version =get_index_format_default();2728if(git_env_bool("GIT_TEST_SPLIT_INDEX",0))2729init_split_index(istate);2730}27312732/* demote version 3 to version 2 when the latter suffices */2733if(istate->version ==3|| istate->version ==2)2734 istate->version = extended ?3:2;27352736 hdr_version = istate->version;27372738 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2739 hdr.hdr_version =htonl(hdr_version);2740 hdr.hdr_entries =htonl(entries - removed);27412742 the_hash_algo->init_fn(&c);2743if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2744return-1;27452746if(HAVE_THREADS)2747 nr_threads =git_config_get_index_threads();2748else2749 nr_threads =1;27502751if(nr_threads !=1) {2752int ieot_blocks, cpus;27532754/*2755 * ensure default number of ieot blocks maps evenly to the2756 * default number of threads that will process them leaving2757 * room for the thread to load the index extensions.2758 */2759if(!nr_threads) {2760 ieot_blocks = istate->cache_nr / THREAD_COST;2761 cpus =online_cpus();2762if(ieot_blocks > cpus -1)2763 ieot_blocks = cpus -1;2764}else{2765 ieot_blocks = nr_threads;2766if(ieot_blocks > istate->cache_nr)2767 ieot_blocks = istate->cache_nr;2768}27692770/*2771 * no reason to write out the IEOT extension if we don't2772 * have enough blocks to utilize multi-threading2773 */2774if(ieot_blocks >1) {2775 ieot =xcalloc(1,sizeof(struct index_entry_offset_table)2776+ (ieot_blocks *sizeof(struct index_entry_offset)));2777 ieot_entries =DIV_ROUND_UP(entries, ieot_blocks);2778}2779}27802781 offset =lseek(newfd,0, SEEK_CUR);2782if(offset <0) {2783free(ieot);2784return-1;2785}2786 offset += write_buffer_len;2787 nr =0;2788 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;27892790for(i =0; i < entries; i++) {2791struct cache_entry *ce = cache[i];2792if(ce->ce_flags & CE_REMOVE)2793continue;2794if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2795ce_smudge_racily_clean_entry(istate, ce);2796if(is_null_oid(&ce->oid)) {2797static const char msg[] ="cache entry has null sha1:%s";2798static int allow = -1;27992800if(allow <0)2801 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2802if(allow)2803warning(msg, ce->name);2804else2805 err =error(msg, ce->name);28062807 drop_cache_tree =1;2808}2809if(ieot && i && (i % ieot_entries ==0)) {2810 ieot->entries[ieot->nr].nr = nr;2811 ieot->entries[ieot->nr].offset = offset;2812 ieot->nr++;2813/*2814 * If we have a V4 index, set the first byte to an invalid2815 * character to ensure there is nothing common with the previous2816 * entry2817 */2818if(previous_name)2819 previous_name->buf[0] =0;2820 nr =0;2821 offset =lseek(newfd,0, SEEK_CUR);2822if(offset <0) {2823free(ieot);2824return-1;2825}2826 offset += write_buffer_len;2827}2828if(ce_write_entry(&c, newfd, ce, previous_name, (struct ondisk_cache_entry *)&ondisk) <0)2829 err = -1;28302831if(err)2832break;2833 nr++;2834}2835if(ieot && nr) {2836 ieot->entries[ieot->nr].nr = nr;2837 ieot->entries[ieot->nr].offset = offset;2838 ieot->nr++;2839}2840strbuf_release(&previous_name_buf);28412842if(err) {2843free(ieot);2844return err;2845}28462847/* Write extension data here */2848 offset =lseek(newfd,0, SEEK_CUR);2849if(offset <0) {2850free(ieot);2851return-1;2852}2853 offset += write_buffer_len;2854 the_hash_algo->init_fn(&eoie_c);28552856/*2857 * Lets write out CACHE_EXT_INDEXENTRYOFFSETTABLE first so that we2858 * can minimize the number of extensions we have to scan through to2859 * find it during load. Write it out regardless of the2860 * strip_extensions parameter as we need it when loading the shared2861 * index.2862 */2863if(ieot) {2864struct strbuf sb = STRBUF_INIT;28652866write_ieot_extension(&sb, ieot);2867 err =write_index_ext_header(&c, &eoie_c, newfd, CACHE_EXT_INDEXENTRYOFFSETTABLE, sb.len) <02868||ce_write(&c, newfd, sb.buf, sb.len) <0;2869strbuf_release(&sb);2870free(ieot);2871if(err)2872return-1;2873}28742875if(!strip_extensions && istate->split_index) {2876struct strbuf sb = STRBUF_INIT;28772878 err =write_link_extension(&sb, istate) <0||2879write_index_ext_header(&c, &eoie_c, newfd, CACHE_EXT_LINK,2880 sb.len) <0||2881ce_write(&c, newfd, sb.buf, sb.len) <0;2882strbuf_release(&sb);2883if(err)2884return-1;2885}2886if(!strip_extensions && !drop_cache_tree && istate->cache_tree) {2887struct strbuf sb = STRBUF_INIT;28882889cache_tree_write(&sb, istate->cache_tree);2890 err =write_index_ext_header(&c, &eoie_c, newfd, CACHE_EXT_TREE, sb.len) <02891||ce_write(&c, newfd, sb.buf, sb.len) <0;2892strbuf_release(&sb);2893if(err)2894return-1;2895}2896if(!strip_extensions && istate->resolve_undo) {2897struct strbuf sb = STRBUF_INIT;28982899resolve_undo_write(&sb, istate->resolve_undo);2900 err =write_index_ext_header(&c, &eoie_c, newfd, CACHE_EXT_RESOLVE_UNDO,2901 sb.len) <02902||ce_write(&c, newfd, sb.buf, sb.len) <0;2903strbuf_release(&sb);2904if(err)2905return-1;2906}2907if(!strip_extensions && istate->untracked) {2908struct strbuf sb = STRBUF_INIT;29092910write_untracked_extension(&sb, istate->untracked);2911 err =write_index_ext_header(&c, &eoie_c, newfd, CACHE_EXT_UNTRACKED,2912 sb.len) <0||2913ce_write(&c, newfd, sb.buf, sb.len) <0;2914strbuf_release(&sb);2915if(err)2916return-1;2917}2918if(!strip_extensions && istate->fsmonitor_last_update) {2919struct strbuf sb = STRBUF_INIT;29202921write_fsmonitor_extension(&sb, istate);2922 err =write_index_ext_header(&c, &eoie_c, newfd, CACHE_EXT_FSMONITOR, sb.len) <02923||ce_write(&c, newfd, sb.buf, sb.len) <0;2924strbuf_release(&sb);2925if(err)2926return-1;2927}29282929/*2930 * CACHE_EXT_ENDOFINDEXENTRIES must be written as the last entry before the SHA12931 * so that it can be found and processed before all the index entries are2932 * read. Write it out regardless of the strip_extensions parameter as we need it2933 * when loading the shared index.2934 */2935if(offset) {2936struct strbuf sb = STRBUF_INIT;29372938write_eoie_extension(&sb, &eoie_c, offset);2939 err =write_index_ext_header(&c, NULL, newfd, CACHE_EXT_ENDOFINDEXENTRIES, sb.len) <02940||ce_write(&c, newfd, sb.buf, sb.len) <0;2941strbuf_release(&sb);2942if(err)2943return-1;2944}29452946if(ce_flush(&c, newfd, istate->oid.hash))2947return-1;2948if(close_tempfile_gently(tempfile)) {2949error(_("could not close '%s'"), tempfile->filename.buf);2950return-1;2951}2952if(stat(tempfile->filename.buf, &st))2953return-1;2954 istate->timestamp.sec = (unsigned int)st.st_mtime;2955 istate->timestamp.nsec =ST_MTIME_NSEC(st);2956trace_performance_since(start,"write index, changed mask =%x", istate->cache_changed);2957return0;2958}29592960voidset_alternate_index_output(const char*name)2961{2962 alternate_index_output = name;2963}29642965static intcommit_locked_index(struct lock_file *lk)2966{2967if(alternate_index_output)2968returncommit_lock_file_to(lk, alternate_index_output);2969else2970returncommit_lock_file(lk);2971}29722973static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2974unsigned flags)2975{2976int ret =do_write_index(istate, lock->tempfile,0);2977if(ret)2978return ret;2979if(flags & COMMIT_LOCK)2980returncommit_locked_index(lock);2981returnclose_lock_file_gently(lock);2982}29832984static intwrite_split_index(struct index_state *istate,2985struct lock_file *lock,2986unsigned flags)2987{2988int ret;2989prepare_to_write_split_index(istate);2990 ret =do_write_locked_index(istate, lock, flags);2991finish_writing_split_index(istate);2992return ret;2993}29942995static const char*shared_index_expire ="2.weeks.ago";29962997static unsigned longget_shared_index_expire_date(void)2998{2999static unsigned long shared_index_expire_date;3000static int shared_index_expire_date_prepared;30013002if(!shared_index_expire_date_prepared) {3003git_config_get_expiry("splitindex.sharedindexexpire",3004&shared_index_expire);3005 shared_index_expire_date =approxidate(shared_index_expire);3006 shared_index_expire_date_prepared =1;3007}30083009return shared_index_expire_date;3010}30113012static intshould_delete_shared_index(const char*shared_index_path)3013{3014struct stat st;3015unsigned long expiration;30163017/* Check timestamp */3018 expiration =get_shared_index_expire_date();3019if(!expiration)3020return0;3021if(stat(shared_index_path, &st))3022returnerror_errno(_("could not stat '%s'"), shared_index_path);3023if(st.st_mtime > expiration)3024return0;30253026return1;3027}30283029static intclean_shared_index_files(const char*current_hex)3030{3031struct dirent *de;3032DIR*dir =opendir(get_git_dir());30333034if(!dir)3035returnerror_errno(_("unable to open git dir:%s"),get_git_dir());30363037while((de =readdir(dir)) != NULL) {3038const char*sha1_hex;3039const char*shared_index_path;3040if(!skip_prefix(de->d_name,"sharedindex.", &sha1_hex))3041continue;3042if(!strcmp(sha1_hex, current_hex))3043continue;3044 shared_index_path =git_path("%s", de->d_name);3045if(should_delete_shared_index(shared_index_path) >0&&3046unlink(shared_index_path))3047warning_errno(_("unable to unlink:%s"), shared_index_path);3048}3049closedir(dir);30503051return0;3052}30533054static intwrite_shared_index(struct index_state *istate,3055struct tempfile **temp)3056{3057struct split_index *si = istate->split_index;3058int ret;30593060move_cache_to_base_index(istate);3061 ret =do_write_index(si->base, *temp,1);3062if(ret)3063return ret;3064 ret =adjust_shared_perm(get_tempfile_path(*temp));3065if(ret) {3066error("cannot fix permission bits on%s",get_tempfile_path(*temp));3067return ret;3068}3069 ret =rename_tempfile(temp,3070git_path("sharedindex.%s",oid_to_hex(&si->base->oid)));3071if(!ret) {3072oidcpy(&si->base_oid, &si->base->oid);3073clean_shared_index_files(oid_to_hex(&si->base->oid));3074}30753076return ret;3077}30783079static const int default_max_percent_split_change =20;30803081static inttoo_many_not_shared_entries(struct index_state *istate)3082{3083int i, not_shared =0;3084int max_split =git_config_get_max_percent_split_change();30853086switch(max_split) {3087case-1:3088/* not or badly configured: use the default value */3089 max_split = default_max_percent_split_change;3090break;3091case0:3092return1;/* 0% means always write a new shared index */3093case100:3094return0;/* 100% means never write a new shared index */3095default:3096break;/* just use the configured value */3097}30983099/* Count not shared entries */3100for(i =0; i < istate->cache_nr; i++) {3101struct cache_entry *ce = istate->cache[i];3102if(!ce->index)3103 not_shared++;3104}31053106return(int64_t)istate->cache_nr * max_split < (int64_t)not_shared *100;3107}31083109intwrite_locked_index(struct index_state *istate,struct lock_file *lock,3110unsigned flags)3111{3112int new_shared_index, ret;3113struct split_index *si = istate->split_index;31143115if(git_env_bool("GIT_TEST_CHECK_CACHE_TREE",0))3116cache_tree_verify(istate);31173118if((flags & SKIP_IF_UNCHANGED) && !istate->cache_changed) {3119if(flags & COMMIT_LOCK)3120rollback_lock_file(lock);3121return0;3122}31233124if(istate->fsmonitor_last_update)3125fill_fsmonitor_bitmap(istate);31263127if(!si || alternate_index_output ||3128(istate->cache_changed & ~EXTMASK)) {3129if(si)3130oidclr(&si->base_oid);3131 ret =do_write_locked_index(istate, lock, flags);3132goto out;3133}31343135if(git_env_bool("GIT_TEST_SPLIT_INDEX",0)) {3136int v = si->base_oid.hash[0];3137if((v &15) <6)3138 istate->cache_changed |= SPLIT_INDEX_ORDERED;3139}3140if(too_many_not_shared_entries(istate))3141 istate->cache_changed |= SPLIT_INDEX_ORDERED;31423143 new_shared_index = istate->cache_changed & SPLIT_INDEX_ORDERED;31443145if(new_shared_index) {3146struct tempfile *temp;3147int saved_errno;31483149 temp =mks_tempfile(git_path("sharedindex_XXXXXX"));3150if(!temp) {3151oidclr(&si->base_oid);3152 ret =do_write_locked_index(istate, lock, flags);3153goto out;3154}3155 ret =write_shared_index(istate, &temp);31563157 saved_errno = errno;3158if(is_tempfile_active(temp))3159delete_tempfile(&temp);3160 errno = saved_errno;31613162if(ret)3163goto out;3164}31653166 ret =write_split_index(istate, lock, flags);31673168/* Freshen the shared index only if the split-index was written */3169if(!ret && !new_shared_index) {3170const char*shared_index =git_path("sharedindex.%s",3171oid_to_hex(&si->base_oid));3172freshen_shared_index(shared_index,1);3173}31743175out:3176if(flags & COMMIT_LOCK)3177rollback_lock_file(lock);3178return ret;3179}31803181/*3182 * Read the index file that is potentially unmerged into given3183 * index_state, dropping any unmerged entries to stage #0 (potentially3184 * resulting in a path appearing as both a file and a directory in the3185 * index; the caller is responsible to clear out the extra entries3186 * before writing the index to a tree). Returns true if the index is3187 * unmerged. Callers who want to refuse to work from an unmerged3188 * state can call this and check its return value, instead of calling3189 * read_cache().3190 */3191intread_index_unmerged(struct index_state *istate)3192{3193int i;3194int unmerged =0;31953196read_index(istate);3197for(i =0; i < istate->cache_nr; i++) {3198struct cache_entry *ce = istate->cache[i];3199struct cache_entry *new_ce;3200int len;32013202if(!ce_stage(ce))3203continue;3204 unmerged =1;3205 len =ce_namelen(ce);3206 new_ce =make_empty_cache_entry(istate, len);3207memcpy(new_ce->name, ce->name, len);3208 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;3209 new_ce->ce_namelen = len;3210 new_ce->ce_mode = ce->ce_mode;3211if(add_index_entry(istate, new_ce, ADD_CACHE_SKIP_DFCHECK))3212returnerror("%s: cannot drop to stage #0",3213 new_ce->name);3214}3215return unmerged;3216}32173218/*3219 * Returns 1 if the path is an "other" path with respect to3220 * the index; that is, the path is not mentioned in the index at all,3221 * either as a file, a directory with some files in the index,3222 * or as an unmerged entry.3223 *3224 * We helpfully remove a trailing "/" from directories so that3225 * the output of read_directory can be used as-is.3226 */3227intindex_name_is_other(const struct index_state *istate,const char*name,3228int namelen)3229{3230int pos;3231if(namelen && name[namelen -1] =='/')3232 namelen--;3233 pos =index_name_pos(istate, name, namelen);3234if(0<= pos)3235return0;/* exact match */3236 pos = -pos -1;3237if(pos < istate->cache_nr) {3238struct cache_entry *ce = istate->cache[pos];3239if(ce_namelen(ce) == namelen &&3240!memcmp(ce->name, name, namelen))3241return0;/* Yup, this one exists unmerged */3242}3243return1;3244}32453246void*read_blob_data_from_index(const struct index_state *istate,3247const char*path,unsigned long*size)3248{3249int pos, len;3250unsigned long sz;3251enum object_type type;3252void*data;32533254 len =strlen(path);3255 pos =index_name_pos(istate, path, len);3256if(pos <0) {3257/*3258 * We might be in the middle of a merge, in which3259 * case we would read stage #2 (ours).3260 */3261int i;3262for(i = -pos -1;3263(pos <0&& i < istate->cache_nr &&3264!strcmp(istate->cache[i]->name, path));3265 i++)3266if(ce_stage(istate->cache[i]) ==2)3267 pos = i;3268}3269if(pos <0)3270return NULL;3271 data =read_object_file(&istate->cache[pos]->oid, &type, &sz);3272if(!data || type != OBJ_BLOB) {3273free(data);3274return NULL;3275}3276if(size)3277*size = sz;3278return data;3279}32803281voidstat_validity_clear(struct stat_validity *sv)3282{3283FREE_AND_NULL(sv->sd);3284}32853286intstat_validity_check(struct stat_validity *sv,const char*path)3287{3288struct stat st;32893290if(stat(path, &st) <0)3291return sv->sd == NULL;3292if(!sv->sd)3293return0;3294returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);3295}32963297voidstat_validity_update(struct stat_validity *sv,int fd)3298{3299struct stat st;33003301if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))3302stat_validity_clear(sv);3303else{3304if(!sv->sd)3305 sv->sd =xcalloc(1,sizeof(struct stat_data));3306fill_stat_data(sv->sd, &st);3307}3308}33093310voidmove_index_extensions(struct index_state *dst,struct index_state *src)3311{3312 dst->untracked = src->untracked;3313 src->untracked = NULL;3314 dst->cache_tree = src->cache_tree;3315 src->cache_tree = NULL;3316}33173318struct cache_entry *dup_cache_entry(const struct cache_entry *ce,3319struct index_state *istate)3320{3321unsigned int size =ce_size(ce);3322int mem_pool_allocated;3323struct cache_entry *new_entry =make_empty_cache_entry(istate,ce_namelen(ce));3324 mem_pool_allocated = new_entry->mem_pool_allocated;33253326memcpy(new_entry, ce, size);3327 new_entry->mem_pool_allocated = mem_pool_allocated;3328return new_entry;3329}33303331voiddiscard_cache_entry(struct cache_entry *ce)3332{3333if(ce &&should_validate_cache_entries())3334memset(ce,0xCD,cache_entry_size(ce->ce_namelen));33353336if(ce && ce->mem_pool_allocated)3337return;33383339free(ce);3340}33413342intshould_validate_cache_entries(void)3343{3344static int validate_index_cache_entries = -1;33453346if(validate_index_cache_entries <0) {3347if(getenv("GIT_TEST_VALIDATE_INDEX_CACHE_ENTRIES"))3348 validate_index_cache_entries =1;3349else3350 validate_index_cache_entries =0;3351}33523353return validate_index_cache_entries;3354}33553356#define EOIE_SIZE (4 + GIT_SHA1_RAWSZ)/* <4-byte offset> + <20-byte hash> */3357#define EOIE_SIZE_WITH_HEADER (4 + 4 + EOIE_SIZE)/* <4-byte signature> + <4-byte length> + EOIE_SIZE */33583359static size_tread_eoie_extension(const char*mmap,size_t mmap_size)3360{3361/*3362 * The end of index entries (EOIE) extension is guaranteed to be last3363 * so that it can be found by scanning backwards from the EOF.3364 *3365 * "EOIE"3366 * <4-byte length>3367 * <4-byte offset>3368 * <20-byte hash>3369 */3370const char*index, *eoie;3371uint32_t extsize;3372size_t offset, src_offset;3373unsigned char hash[GIT_MAX_RAWSZ];3374 git_hash_ctx c;33753376/* ensure we have an index big enough to contain an EOIE extension */3377if(mmap_size <sizeof(struct cache_header) + EOIE_SIZE_WITH_HEADER + the_hash_algo->rawsz)3378return0;33793380/* validate the extension signature */3381 index = eoie = mmap + mmap_size - EOIE_SIZE_WITH_HEADER - the_hash_algo->rawsz;3382if(CACHE_EXT(index) != CACHE_EXT_ENDOFINDEXENTRIES)3383return0;3384 index +=sizeof(uint32_t);33853386/* validate the extension size */3387 extsize =get_be32(index);3388if(extsize != EOIE_SIZE)3389return0;3390 index +=sizeof(uint32_t);33913392/*3393 * Validate the offset we're going to look for the first extension3394 * signature is after the index header and before the eoie extension.3395 */3396 offset =get_be32(index);3397if(mmap + offset < mmap +sizeof(struct cache_header))3398return0;3399if(mmap + offset >= eoie)3400return0;3401 index +=sizeof(uint32_t);34023403/*3404 * The hash is computed over extension types and their sizes (but not3405 * their contents). E.g. if we have "TREE" extension that is N-bytes3406 * long, "REUC" extension that is M-bytes long, followed by "EOIE",3407 * then the hash would be:3408 *3409 * SHA-1("TREE" + <binary representation of N> +3410 * "REUC" + <binary representation of M>)3411 */3412 src_offset = offset;3413 the_hash_algo->init_fn(&c);3414while(src_offset < mmap_size - the_hash_algo->rawsz - EOIE_SIZE_WITH_HEADER) {3415/* After an array of active_nr index entries,3416 * there can be arbitrary number of extended3417 * sections, each of which is prefixed with3418 * extension name (4-byte) and section length3419 * in 4-byte network byte order.3420 */3421uint32_t extsize;3422memcpy(&extsize, mmap + src_offset +4,4);3423 extsize =ntohl(extsize);34243425/* verify the extension size isn't so large it will wrap around */3426if(src_offset +8+ extsize < src_offset)3427return0;34283429 the_hash_algo->update_fn(&c, mmap + src_offset,8);34303431 src_offset +=8;3432 src_offset += extsize;3433}3434 the_hash_algo->final_fn(hash, &c);3435if(!hasheq(hash, (const unsigned char*)index))3436return0;34373438/* Validate that the extension offsets returned us back to the eoie extension. */3439if(src_offset != mmap_size - the_hash_algo->rawsz - EOIE_SIZE_WITH_HEADER)3440return0;34413442return offset;3443}34443445static voidwrite_eoie_extension(struct strbuf *sb, git_hash_ctx *eoie_context,size_t offset)3446{3447uint32_t buffer;3448unsigned char hash[GIT_MAX_RAWSZ];34493450/* offset */3451put_be32(&buffer, offset);3452strbuf_add(sb, &buffer,sizeof(uint32_t));34533454/* hash */3455 the_hash_algo->final_fn(hash, eoie_context);3456strbuf_add(sb, hash, the_hash_algo->rawsz);3457}34583459#define IEOT_VERSION (1)34603461static struct index_entry_offset_table *read_ieot_extension(const char*mmap,size_t mmap_size,size_t offset)3462{3463const char*index = NULL;3464uint32_t extsize, ext_version;3465struct index_entry_offset_table *ieot;3466int i, nr;34673468/* find the IEOT extension */3469if(!offset)3470return NULL;3471while(offset <= mmap_size - the_hash_algo->rawsz -8) {3472 extsize =get_be32(mmap + offset +4);3473if(CACHE_EXT((mmap + offset)) == CACHE_EXT_INDEXENTRYOFFSETTABLE) {3474 index = mmap + offset +4+4;3475break;3476}3477 offset +=8;3478 offset += extsize;3479}3480if(!index)3481return NULL;34823483/* validate the version is IEOT_VERSION */3484 ext_version =get_be32(index);3485if(ext_version != IEOT_VERSION) {3486error("invalid IEOT version%d", ext_version);3487return NULL;3488}3489 index +=sizeof(uint32_t);34903491/* extension size - version bytes / bytes per entry */3492 nr = (extsize -sizeof(uint32_t)) / (sizeof(uint32_t) +sizeof(uint32_t));3493if(!nr) {3494error("invalid number of IEOT entries%d", nr);3495return NULL;3496}3497 ieot =xmalloc(sizeof(struct index_entry_offset_table)3498+ (nr *sizeof(struct index_entry_offset)));3499 ieot->nr = nr;3500for(i =0; i < nr; i++) {3501 ieot->entries[i].offset =get_be32(index);3502 index +=sizeof(uint32_t);3503 ieot->entries[i].nr =get_be32(index);3504 index +=sizeof(uint32_t);3505}35063507return ieot;3508}35093510static voidwrite_ieot_extension(struct strbuf *sb,struct index_entry_offset_table *ieot)3511{3512uint32_t buffer;3513int i;35143515/* version */3516put_be32(&buffer, IEOT_VERSION);3517strbuf_add(sb, &buffer,sizeof(uint32_t));35183519/* ieot */3520for(i =0; i < ieot->nr; i++) {35213522/* offset */3523put_be32(&buffer, ieot->entries[i].offset);3524strbuf_add(sb, &buffer,sizeof(uint32_t));35253526/* count */3527put_be32(&buffer, ieot->entries[i].nr);3528strbuf_add(sb, &buffer,sizeof(uint32_t));3529}3530}