1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#define NO_THE_INDEX_COMPATIBILITY_MACROS 7#include"cache.h" 8#include"config.h" 9#include"tempfile.h" 10#include"lockfile.h" 11#include"cache-tree.h" 12#include"refs.h" 13#include"dir.h" 14#include"tree.h" 15#include"commit.h" 16#include"blob.h" 17#include"resolve-undo.h" 18#include"strbuf.h" 19#include"varint.h" 20#include"split-index.h" 21#include"utf8.h" 22#include"fsmonitor.h" 23 24/* Mask for the name length in ce_flags in the on-disk index */ 25 26#define CE_NAMEMASK (0x0fff) 27 28/* Index extensions. 29 * 30 * The first letter should be 'A'..'Z' for extensions that are not 31 * necessary for a correct operation (i.e. optimization data). 32 * When new extensions are added that _needs_ to be understood in 33 * order to correctly interpret the index file, pick character that 34 * is outside the range, to cause the reader to abort. 35 */ 36 37#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 38#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 39#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 40#define CACHE_EXT_LINK 0x6c696e6b/* "link" */ 41#define CACHE_EXT_UNTRACKED 0x554E5452/* "UNTR" */ 42#define CACHE_EXT_FSMONITOR 0x46534D4E/* "FSMN" */ 43 44/* changes that can be kept in $GIT_DIR/index (basically all extensions) */ 45#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \ 46 CE_ENTRY_ADDED | CE_ENTRY_REMOVED | CE_ENTRY_CHANGED | \ 47 SPLIT_INDEX_ORDERED | UNTRACKED_CHANGED | FSMONITOR_CHANGED) 48 49struct index_state the_index; 50static const char*alternate_index_output; 51 52static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 53{ 54 istate->cache[nr] = ce; 55add_name_hash(istate, ce); 56} 57 58static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 59{ 60struct cache_entry *old = istate->cache[nr]; 61 62replace_index_entry_in_base(istate, old, ce); 63remove_name_hash(istate, old); 64free(old); 65set_index_entry(istate, nr, ce); 66 ce->ce_flags |= CE_UPDATE_IN_BASE; 67mark_fsmonitor_invalid(istate, ce); 68 istate->cache_changed |= CE_ENTRY_CHANGED; 69} 70 71voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 72{ 73struct cache_entry *old = istate->cache[nr], *new; 74int namelen =strlen(new_name); 75 76new=xmalloc(cache_entry_size(namelen)); 77copy_cache_entry(new, old); 78new->ce_flags &= ~CE_HASHED; 79new->ce_namelen = namelen; 80new->index =0; 81memcpy(new->name, new_name, namelen +1); 82 83cache_tree_invalidate_path(istate, old->name); 84untracked_cache_remove_from_index(istate, old->name); 85remove_index_entry_at(istate, nr); 86add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 87} 88 89voidfill_stat_data(struct stat_data *sd,struct stat *st) 90{ 91 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 92 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 93 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 94 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 95 sd->sd_dev = st->st_dev; 96 sd->sd_ino = st->st_ino; 97 sd->sd_uid = st->st_uid; 98 sd->sd_gid = st->st_gid; 99 sd->sd_size = st->st_size; 100} 101 102intmatch_stat_data(const struct stat_data *sd,struct stat *st) 103{ 104int changed =0; 105 106if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 107 changed |= MTIME_CHANGED; 108if(trust_ctime && check_stat && 109 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 110 changed |= CTIME_CHANGED; 111 112#ifdef USE_NSEC 113if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 114 changed |= MTIME_CHANGED; 115if(trust_ctime && check_stat && 116 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 117 changed |= CTIME_CHANGED; 118#endif 119 120if(check_stat) { 121if(sd->sd_uid != (unsigned int) st->st_uid || 122 sd->sd_gid != (unsigned int) st->st_gid) 123 changed |= OWNER_CHANGED; 124if(sd->sd_ino != (unsigned int) st->st_ino) 125 changed |= INODE_CHANGED; 126} 127 128#ifdef USE_STDEV 129/* 130 * st_dev breaks on network filesystems where different 131 * clients will have different views of what "device" 132 * the filesystem is on 133 */ 134if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 135 changed |= INODE_CHANGED; 136#endif 137 138if(sd->sd_size != (unsigned int) st->st_size) 139 changed |= DATA_CHANGED; 140 141return changed; 142} 143 144/* 145 * This only updates the "non-critical" parts of the directory 146 * cache, ie the parts that aren't tracked by GIT, and only used 147 * to validate the cache. 148 */ 149voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 150{ 151fill_stat_data(&ce->ce_stat_data, st); 152 153if(assume_unchanged) 154 ce->ce_flags |= CE_VALID; 155 156if(S_ISREG(st->st_mode)) { 157ce_mark_uptodate(ce); 158mark_fsmonitor_valid(ce); 159} 160} 161 162static intce_compare_data(const struct cache_entry *ce,struct stat *st) 163{ 164int match = -1; 165int fd =git_open_cloexec(ce->name, O_RDONLY); 166 167if(fd >=0) { 168struct object_id oid; 169if(!index_fd(&oid, fd, st, OBJ_BLOB, ce->name,0)) 170 match =oidcmp(&oid, &ce->oid); 171/* index_fd() closed the file descriptor already */ 172} 173return match; 174} 175 176static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 177{ 178int match = -1; 179void*buffer; 180unsigned long size; 181enum object_type type; 182struct strbuf sb = STRBUF_INIT; 183 184if(strbuf_readlink(&sb, ce->name, expected_size)) 185return-1; 186 187 buffer =read_sha1_file(ce->oid.hash, &type, &size); 188if(buffer) { 189if(size == sb.len) 190 match =memcmp(buffer, sb.buf, size); 191free(buffer); 192} 193strbuf_release(&sb); 194return match; 195} 196 197static intce_compare_gitlink(const struct cache_entry *ce) 198{ 199struct object_id oid; 200 201/* 202 * We don't actually require that the .git directory 203 * under GITLINK directory be a valid git directory. It 204 * might even be missing (in case nobody populated that 205 * sub-project). 206 * 207 * If so, we consider it always to match. 208 */ 209if(resolve_gitlink_ref(ce->name,"HEAD", &oid) <0) 210return0; 211returnoidcmp(&oid, &ce->oid); 212} 213 214static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 215{ 216switch(st->st_mode & S_IFMT) { 217case S_IFREG: 218if(ce_compare_data(ce, st)) 219return DATA_CHANGED; 220break; 221case S_IFLNK: 222if(ce_compare_link(ce,xsize_t(st->st_size))) 223return DATA_CHANGED; 224break; 225case S_IFDIR: 226if(S_ISGITLINK(ce->ce_mode)) 227returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 228/* else fallthrough */ 229default: 230return TYPE_CHANGED; 231} 232return0; 233} 234 235static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 236{ 237unsigned int changed =0; 238 239if(ce->ce_flags & CE_REMOVE) 240return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 241 242switch(ce->ce_mode & S_IFMT) { 243case S_IFREG: 244 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 245/* We consider only the owner x bit to be relevant for 246 * "mode changes" 247 */ 248if(trust_executable_bit && 249(0100& (ce->ce_mode ^ st->st_mode))) 250 changed |= MODE_CHANGED; 251break; 252case S_IFLNK: 253if(!S_ISLNK(st->st_mode) && 254(has_symlinks || !S_ISREG(st->st_mode))) 255 changed |= TYPE_CHANGED; 256break; 257case S_IFGITLINK: 258/* We ignore most of the st_xxx fields for gitlinks */ 259if(!S_ISDIR(st->st_mode)) 260 changed |= TYPE_CHANGED; 261else if(ce_compare_gitlink(ce)) 262 changed |= DATA_CHANGED; 263return changed; 264default: 265die("internal error: ce_mode is%o", ce->ce_mode); 266} 267 268 changed |=match_stat_data(&ce->ce_stat_data, st); 269 270/* Racily smudged entry? */ 271if(!ce->ce_stat_data.sd_size) { 272if(!is_empty_blob_sha1(ce->oid.hash)) 273 changed |= DATA_CHANGED; 274} 275 276return changed; 277} 278 279static intis_racy_stat(const struct index_state *istate, 280const struct stat_data *sd) 281{ 282return(istate->timestamp.sec && 283#ifdef USE_NSEC 284/* nanosecond timestamped files can also be racy! */ 285(istate->timestamp.sec < sd->sd_mtime.sec || 286(istate->timestamp.sec == sd->sd_mtime.sec && 287 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 288#else 289 istate->timestamp.sec <= sd->sd_mtime.sec 290#endif 291); 292} 293 294static intis_racy_timestamp(const struct index_state *istate, 295const struct cache_entry *ce) 296{ 297return(!S_ISGITLINK(ce->ce_mode) && 298is_racy_stat(istate, &ce->ce_stat_data)); 299} 300 301intmatch_stat_data_racy(const struct index_state *istate, 302const struct stat_data *sd,struct stat *st) 303{ 304if(is_racy_stat(istate, sd)) 305return MTIME_CHANGED; 306returnmatch_stat_data(sd, st); 307} 308 309intie_match_stat(struct index_state *istate, 310const struct cache_entry *ce,struct stat *st, 311unsigned int options) 312{ 313unsigned int changed; 314int ignore_valid = options & CE_MATCH_IGNORE_VALID; 315int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 316int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 317int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR; 318 319if(!ignore_fsmonitor) 320refresh_fsmonitor(istate); 321/* 322 * If it's marked as always valid in the index, it's 323 * valid whatever the checked-out copy says. 324 * 325 * skip-worktree has the same effect with higher precedence 326 */ 327if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 328return0; 329if(!ignore_valid && (ce->ce_flags & CE_VALID)) 330return0; 331if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) 332return0; 333 334/* 335 * Intent-to-add entries have not been added, so the index entry 336 * by definition never matches what is in the work tree until it 337 * actually gets added. 338 */ 339if(ce_intent_to_add(ce)) 340return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 341 342 changed =ce_match_stat_basic(ce, st); 343 344/* 345 * Within 1 second of this sequence: 346 * echo xyzzy >file && git-update-index --add file 347 * running this command: 348 * echo frotz >file 349 * would give a falsely clean cache entry. The mtime and 350 * length match the cache, and other stat fields do not change. 351 * 352 * We could detect this at update-index time (the cache entry 353 * being registered/updated records the same time as "now") 354 * and delay the return from git-update-index, but that would 355 * effectively mean we can make at most one commit per second, 356 * which is not acceptable. Instead, we check cache entries 357 * whose mtime are the same as the index file timestamp more 358 * carefully than others. 359 */ 360if(!changed &&is_racy_timestamp(istate, ce)) { 361if(assume_racy_is_modified) 362 changed |= DATA_CHANGED; 363else 364 changed |=ce_modified_check_fs(ce, st); 365} 366 367return changed; 368} 369 370intie_modified(struct index_state *istate, 371const struct cache_entry *ce, 372struct stat *st,unsigned int options) 373{ 374int changed, changed_fs; 375 376 changed =ie_match_stat(istate, ce, st, options); 377if(!changed) 378return0; 379/* 380 * If the mode or type has changed, there's no point in trying 381 * to refresh the entry - it's not going to match 382 */ 383if(changed & (MODE_CHANGED | TYPE_CHANGED)) 384return changed; 385 386/* 387 * Immediately after read-tree or update-index --cacheinfo, 388 * the length field is zero, as we have never even read the 389 * lstat(2) information once, and we cannot trust DATA_CHANGED 390 * returned by ie_match_stat() which in turn was returned by 391 * ce_match_stat_basic() to signal that the filesize of the 392 * blob changed. We have to actually go to the filesystem to 393 * see if the contents match, and if so, should answer "unchanged". 394 * 395 * The logic does not apply to gitlinks, as ce_match_stat_basic() 396 * already has checked the actual HEAD from the filesystem in the 397 * subproject. If ie_match_stat() already said it is different, 398 * then we know it is. 399 */ 400if((changed & DATA_CHANGED) && 401(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 402return changed; 403 404 changed_fs =ce_modified_check_fs(ce, st); 405if(changed_fs) 406return changed | changed_fs; 407return0; 408} 409 410intbase_name_compare(const char*name1,int len1,int mode1, 411const char*name2,int len2,int mode2) 412{ 413unsigned char c1, c2; 414int len = len1 < len2 ? len1 : len2; 415int cmp; 416 417 cmp =memcmp(name1, name2, len); 418if(cmp) 419return cmp; 420 c1 = name1[len]; 421 c2 = name2[len]; 422if(!c1 &&S_ISDIR(mode1)) 423 c1 ='/'; 424if(!c2 &&S_ISDIR(mode2)) 425 c2 ='/'; 426return(c1 < c2) ? -1: (c1 > c2) ?1:0; 427} 428 429/* 430 * df_name_compare() is identical to base_name_compare(), except it 431 * compares conflicting directory/file entries as equal. Note that 432 * while a directory name compares as equal to a regular file, they 433 * then individually compare _differently_ to a filename that has 434 * a dot after the basename (because '\0' < '.' < '/'). 435 * 436 * This is used by routines that want to traverse the git namespace 437 * but then handle conflicting entries together when possible. 438 */ 439intdf_name_compare(const char*name1,int len1,int mode1, 440const char*name2,int len2,int mode2) 441{ 442int len = len1 < len2 ? len1 : len2, cmp; 443unsigned char c1, c2; 444 445 cmp =memcmp(name1, name2, len); 446if(cmp) 447return cmp; 448/* Directories and files compare equal (same length, same name) */ 449if(len1 == len2) 450return0; 451 c1 = name1[len]; 452if(!c1 &&S_ISDIR(mode1)) 453 c1 ='/'; 454 c2 = name2[len]; 455if(!c2 &&S_ISDIR(mode2)) 456 c2 ='/'; 457if(c1 =='/'&& !c2) 458return0; 459if(c2 =='/'&& !c1) 460return0; 461return c1 - c2; 462} 463 464intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 465{ 466size_t min_len = (len1 < len2) ? len1 : len2; 467int cmp =memcmp(name1, name2, min_len); 468if(cmp) 469return cmp; 470if(len1 < len2) 471return-1; 472if(len1 > len2) 473return1; 474return0; 475} 476 477intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 478{ 479int cmp; 480 481 cmp =name_compare(name1, len1, name2, len2); 482if(cmp) 483return cmp; 484 485if(stage1 < stage2) 486return-1; 487if(stage1 > stage2) 488return1; 489return0; 490} 491 492static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 493{ 494int first, last; 495 496 first =0; 497 last = istate->cache_nr; 498while(last > first) { 499int next = (last + first) >>1; 500struct cache_entry *ce = istate->cache[next]; 501int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 502if(!cmp) 503return next; 504if(cmp <0) { 505 last = next; 506continue; 507} 508 first = next+1; 509} 510return-first-1; 511} 512 513intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 514{ 515returnindex_name_stage_pos(istate, name, namelen,0); 516} 517 518intremove_index_entry_at(struct index_state *istate,int pos) 519{ 520struct cache_entry *ce = istate->cache[pos]; 521 522record_resolve_undo(istate, ce); 523remove_name_hash(istate, ce); 524save_or_free_index_entry(istate, ce); 525 istate->cache_changed |= CE_ENTRY_REMOVED; 526 istate->cache_nr--; 527if(pos >= istate->cache_nr) 528return0; 529MOVE_ARRAY(istate->cache + pos, istate->cache + pos +1, 530 istate->cache_nr - pos); 531return1; 532} 533 534/* 535 * Remove all cache entries marked for removal, that is where 536 * CE_REMOVE is set in ce_flags. This is much more effective than 537 * calling remove_index_entry_at() for each entry to be removed. 538 */ 539voidremove_marked_cache_entries(struct index_state *istate) 540{ 541struct cache_entry **ce_array = istate->cache; 542unsigned int i, j; 543 544for(i = j =0; i < istate->cache_nr; i++) { 545if(ce_array[i]->ce_flags & CE_REMOVE) { 546remove_name_hash(istate, ce_array[i]); 547save_or_free_index_entry(istate, ce_array[i]); 548} 549else 550 ce_array[j++] = ce_array[i]; 551} 552if(j == istate->cache_nr) 553return; 554 istate->cache_changed |= CE_ENTRY_REMOVED; 555 istate->cache_nr = j; 556} 557 558intremove_file_from_index(struct index_state *istate,const char*path) 559{ 560int pos =index_name_pos(istate, path,strlen(path)); 561if(pos <0) 562 pos = -pos-1; 563cache_tree_invalidate_path(istate, path); 564untracked_cache_remove_from_index(istate, path); 565while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 566remove_index_entry_at(istate, pos); 567return0; 568} 569 570static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 571{ 572return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 573} 574 575static intindex_name_pos_also_unmerged(struct index_state *istate, 576const char*path,int namelen) 577{ 578int pos =index_name_pos(istate, path, namelen); 579struct cache_entry *ce; 580 581if(pos >=0) 582return pos; 583 584/* maybe unmerged? */ 585 pos = -1- pos; 586if(pos >= istate->cache_nr || 587compare_name((ce = istate->cache[pos]), path, namelen)) 588return-1; 589 590/* order of preference: stage 2, 1, 3 */ 591if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 592ce_stage((ce = istate->cache[pos +1])) ==2&& 593!compare_name(ce, path, namelen)) 594 pos++; 595return pos; 596} 597 598static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 599{ 600int len =ce_namelen(ce); 601returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 602} 603 604/* 605 * If we add a filename that aliases in the cache, we will use the 606 * name that we already have - but we don't want to update the same 607 * alias twice, because that implies that there were actually two 608 * different files with aliasing names! 609 * 610 * So we use the CE_ADDED flag to verify that the alias was an old 611 * one before we accept it as 612 */ 613static struct cache_entry *create_alias_ce(struct index_state *istate, 614struct cache_entry *ce, 615struct cache_entry *alias) 616{ 617int len; 618struct cache_entry *new; 619 620if(alias->ce_flags & CE_ADDED) 621die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 622 623/* Ok, create the new entry using the name of the existing alias */ 624 len =ce_namelen(alias); 625new=xcalloc(1,cache_entry_size(len)); 626memcpy(new->name, alias->name, len); 627copy_cache_entry(new, ce); 628save_or_free_index_entry(istate, ce); 629return new; 630} 631 632voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 633{ 634unsigned char sha1[20]; 635if(write_sha1_file("",0, blob_type, sha1)) 636die("cannot create an empty blob in the object database"); 637hashcpy(ce->oid.hash, sha1); 638} 639 640intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 641{ 642int size, namelen, was_same; 643 mode_t st_mode = st->st_mode; 644struct cache_entry *ce, *alias = NULL; 645unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 646int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 647int pretend = flags & ADD_CACHE_PRETEND; 648int intent_only = flags & ADD_CACHE_INTENT; 649int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 650(intent_only ? ADD_CACHE_NEW_ONLY :0)); 651int newflags = HASH_WRITE_OBJECT; 652 653if(flags & HASH_RENORMALIZE) 654 newflags |= HASH_RENORMALIZE; 655 656if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 657returnerror("%s: can only add regular files, symbolic links or git-directories", path); 658 659 namelen =strlen(path); 660if(S_ISDIR(st_mode)) { 661while(namelen && path[namelen-1] =='/') 662 namelen--; 663} 664 size =cache_entry_size(namelen); 665 ce =xcalloc(1, size); 666memcpy(ce->name, path, namelen); 667 ce->ce_namelen = namelen; 668if(!intent_only) 669fill_stat_cache_info(ce, st); 670else 671 ce->ce_flags |= CE_INTENT_TO_ADD; 672 673 674if(trust_executable_bit && has_symlinks) { 675 ce->ce_mode =create_ce_mode(st_mode); 676}else{ 677/* If there is an existing entry, pick the mode bits and type 678 * from it, otherwise assume unexecutable regular file. 679 */ 680struct cache_entry *ent; 681int pos =index_name_pos_also_unmerged(istate, path, namelen); 682 683 ent = (0<= pos) ? istate->cache[pos] : NULL; 684 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 685} 686 687/* When core.ignorecase=true, determine if a directory of the same name but differing 688 * case already exists within the Git repository. If it does, ensure the directory 689 * case of the file being added to the repository matches (is folded into) the existing 690 * entry's directory case. 691 */ 692if(ignore_case) { 693adjust_dirname_case(istate, ce->name); 694} 695if(!(flags & HASH_RENORMALIZE)) { 696 alias =index_file_exists(istate, ce->name, 697ce_namelen(ce), ignore_case); 698if(alias && 699!ce_stage(alias) && 700!ie_match_stat(istate, alias, st, ce_option)) { 701/* Nothing changed, really */ 702if(!S_ISGITLINK(alias->ce_mode)) 703ce_mark_uptodate(alias); 704 alias->ce_flags |= CE_ADDED; 705 706free(ce); 707return0; 708} 709} 710if(!intent_only) { 711if(index_path(&ce->oid, path, st, newflags)) { 712free(ce); 713returnerror("unable to index file%s", path); 714} 715}else 716set_object_name_for_intent_to_add_entry(ce); 717 718if(ignore_case && alias &&different_name(ce, alias)) 719 ce =create_alias_ce(istate, ce, alias); 720 ce->ce_flags |= CE_ADDED; 721 722/* It was suspected to be racily clean, but it turns out to be Ok */ 723 was_same = (alias && 724!ce_stage(alias) && 725!oidcmp(&alias->oid, &ce->oid) && 726 ce->ce_mode == alias->ce_mode); 727 728if(pretend) 729free(ce); 730else if(add_index_entry(istate, ce, add_option)) { 731free(ce); 732returnerror("unable to add%sto index", path); 733} 734if(verbose && !was_same) 735printf("add '%s'\n", path); 736return0; 737} 738 739intadd_file_to_index(struct index_state *istate,const char*path,int flags) 740{ 741struct stat st; 742if(lstat(path, &st)) 743die_errno("unable to stat '%s'", path); 744returnadd_to_index(istate, path, &st, flags); 745} 746 747struct cache_entry *make_cache_entry(unsigned int mode, 748const unsigned char*sha1,const char*path,int stage, 749unsigned int refresh_options) 750{ 751int size, len; 752struct cache_entry *ce, *ret; 753 754if(!verify_path(path)) { 755error("Invalid path '%s'", path); 756return NULL; 757} 758 759 len =strlen(path); 760 size =cache_entry_size(len); 761 ce =xcalloc(1, size); 762 763hashcpy(ce->oid.hash, sha1); 764memcpy(ce->name, path, len); 765 ce->ce_flags =create_ce_flags(stage); 766 ce->ce_namelen = len; 767 ce->ce_mode =create_ce_mode(mode); 768 769 ret =refresh_cache_entry(ce, refresh_options); 770if(ret != ce) 771free(ce); 772return ret; 773} 774 775/* 776 * Chmod an index entry with either +x or -x. 777 * 778 * Returns -1 if the chmod for the particular cache entry failed (if it's 779 * not a regular file), -2 if an invalid flip argument is passed in, 0 780 * otherwise. 781 */ 782intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 783char flip) 784{ 785if(!S_ISREG(ce->ce_mode)) 786return-1; 787switch(flip) { 788case'+': 789 ce->ce_mode |=0111; 790break; 791case'-': 792 ce->ce_mode &= ~0111; 793break; 794default: 795return-2; 796} 797cache_tree_invalidate_path(istate, ce->name); 798 ce->ce_flags |= CE_UPDATE_IN_BASE; 799mark_fsmonitor_invalid(istate, ce); 800 istate->cache_changed |= CE_ENTRY_CHANGED; 801 802return0; 803} 804 805intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 806{ 807int len =ce_namelen(a); 808returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 809} 810 811/* 812 * We fundamentally don't like some paths: we don't want 813 * dot or dot-dot anywhere, and for obvious reasons don't 814 * want to recurse into ".git" either. 815 * 816 * Also, we don't want double slashes or slashes at the 817 * end that can make pathnames ambiguous. 818 */ 819static intverify_dotfile(const char*rest) 820{ 821/* 822 * The first character was '.', but that 823 * has already been discarded, we now test 824 * the rest. 825 */ 826 827/* "." is not allowed */ 828if(*rest =='\0'||is_dir_sep(*rest)) 829return0; 830 831switch(*rest) { 832/* 833 * ".git" followed by NUL or slash is bad. This 834 * shares the path end test with the ".." case. 835 */ 836case'g': 837case'G': 838if(rest[1] !='i'&& rest[1] !='I') 839break; 840if(rest[2] !='t'&& rest[2] !='T') 841break; 842 rest +=2; 843/* fallthrough */ 844case'.': 845if(rest[1] =='\0'||is_dir_sep(rest[1])) 846return0; 847} 848return1; 849} 850 851intverify_path(const char*path) 852{ 853char c; 854 855if(has_dos_drive_prefix(path)) 856return0; 857 858goto inside; 859for(;;) { 860if(!c) 861return1; 862if(is_dir_sep(c)) { 863inside: 864if(protect_hfs &&is_hfs_dotgit(path)) 865return0; 866if(protect_ntfs &&is_ntfs_dotgit(path)) 867return0; 868 c = *path++; 869if((c =='.'&& !verify_dotfile(path)) || 870is_dir_sep(c) || c =='\0') 871return0; 872} 873 c = *path++; 874} 875} 876 877/* 878 * Do we have another file that has the beginning components being a 879 * proper superset of the name we're trying to add? 880 */ 881static inthas_file_name(struct index_state *istate, 882const struct cache_entry *ce,int pos,int ok_to_replace) 883{ 884int retval =0; 885int len =ce_namelen(ce); 886int stage =ce_stage(ce); 887const char*name = ce->name; 888 889while(pos < istate->cache_nr) { 890struct cache_entry *p = istate->cache[pos++]; 891 892if(len >=ce_namelen(p)) 893break; 894if(memcmp(name, p->name, len)) 895break; 896if(ce_stage(p) != stage) 897continue; 898if(p->name[len] !='/') 899continue; 900if(p->ce_flags & CE_REMOVE) 901continue; 902 retval = -1; 903if(!ok_to_replace) 904break; 905remove_index_entry_at(istate, --pos); 906} 907return retval; 908} 909 910 911/* 912 * Like strcmp(), but also return the offset of the first change. 913 * If strings are equal, return the length. 914 */ 915intstrcmp_offset(const char*s1,const char*s2,size_t*first_change) 916{ 917size_t k; 918 919if(!first_change) 920returnstrcmp(s1, s2); 921 922for(k =0; s1[k] == s2[k]; k++) 923if(s1[k] =='\0') 924break; 925 926*first_change = k; 927return(unsigned char)s1[k] - (unsigned char)s2[k]; 928} 929 930/* 931 * Do we have another file with a pathname that is a proper 932 * subset of the name we're trying to add? 933 * 934 * That is, is there another file in the index with a path 935 * that matches a sub-directory in the given entry? 936 */ 937static inthas_dir_name(struct index_state *istate, 938const struct cache_entry *ce,int pos,int ok_to_replace) 939{ 940int retval =0; 941int stage =ce_stage(ce); 942const char*name = ce->name; 943const char*slash = name +ce_namelen(ce); 944size_t len_eq_last; 945int cmp_last =0; 946 947/* 948 * We are frequently called during an iteration on a sorted 949 * list of pathnames and while building a new index. Therefore, 950 * there is a high probability that this entry will eventually 951 * be appended to the index, rather than inserted in the middle. 952 * If we can confirm that, we can avoid binary searches on the 953 * components of the pathname. 954 * 955 * Compare the entry's full path with the last path in the index. 956 */ 957if(istate->cache_nr >0) { 958 cmp_last =strcmp_offset(name, 959 istate->cache[istate->cache_nr -1]->name, 960&len_eq_last); 961if(cmp_last >0) { 962if(len_eq_last ==0) { 963/* 964 * The entry sorts AFTER the last one in the 965 * index and their paths have no common prefix, 966 * so there cannot be a F/D conflict. 967 */ 968return retval; 969}else{ 970/* 971 * The entry sorts AFTER the last one in the 972 * index, but has a common prefix. Fall through 973 * to the loop below to disect the entry's path 974 * and see where the difference is. 975 */ 976} 977}else if(cmp_last ==0) { 978/* 979 * The entry exactly matches the last one in the 980 * index, but because of multiple stage and CE_REMOVE 981 * items, we fall through and let the regular search 982 * code handle it. 983 */ 984} 985} 986 987for(;;) { 988size_t len; 989 990for(;;) { 991if(*--slash =='/') 992break; 993if(slash <= ce->name) 994return retval; 995} 996 len = slash - name; 997 998if(cmp_last >0) { 999/*1000 * (len + 1) is a directory boundary (including1001 * the trailing slash). And since the loop is1002 * decrementing "slash", the first iteration is1003 * the longest directory prefix; subsequent1004 * iterations consider parent directories.1005 */10061007if(len +1<= len_eq_last) {1008/*1009 * The directory prefix (including the trailing1010 * slash) also appears as a prefix in the last1011 * entry, so the remainder cannot collide (because1012 * strcmp said the whole path was greater).1013 *1014 * EQ: last: xxx/A1015 * this: xxx/B1016 *1017 * LT: last: xxx/file_A1018 * this: xxx/file_B1019 */1020return retval;1021}10221023if(len > len_eq_last) {1024/*1025 * This part of the directory prefix (excluding1026 * the trailing slash) is longer than the known1027 * equal portions, so this sub-directory cannot1028 * collide with a file.1029 *1030 * GT: last: xxxA1031 * this: xxxB/file1032 */1033return retval;1034}10351036if(istate->cache_nr >0&&1037ce_namelen(istate->cache[istate->cache_nr -1]) > len) {1038/*1039 * The directory prefix lines up with part of1040 * a longer file or directory name, but sorts1041 * after it, so this sub-directory cannot1042 * collide with a file.1043 *1044 * last: xxx/yy-file (because '-' sorts before '/')1045 * this: xxx/yy/abc1046 */1047return retval;1048}10491050/*1051 * This is a possible collision. Fall through and1052 * let the regular search code handle it.1053 *1054 * last: xxx1055 * this: xxx/file1056 */1057}10581059 pos =index_name_stage_pos(istate, name, len, stage);1060if(pos >=0) {1061/*1062 * Found one, but not so fast. This could1063 * be a marker that says "I was here, but1064 * I am being removed". Such an entry is1065 * not a part of the resulting tree, and1066 * it is Ok to have a directory at the same1067 * path.1068 */1069if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) {1070 retval = -1;1071if(!ok_to_replace)1072break;1073remove_index_entry_at(istate, pos);1074continue;1075}1076}1077else1078 pos = -pos-1;10791080/*1081 * Trivial optimization: if we find an entry that1082 * already matches the sub-directory, then we know1083 * we're ok, and we can exit.1084 */1085while(pos < istate->cache_nr) {1086struct cache_entry *p = istate->cache[pos];1087if((ce_namelen(p) <= len) ||1088(p->name[len] !='/') ||1089memcmp(p->name, name, len))1090break;/* not our subdirectory */1091if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))1092/*1093 * p is at the same stage as our entry, and1094 * is a subdirectory of what we are looking1095 * at, so we cannot have conflicts at our1096 * level or anything shorter.1097 */1098return retval;1099 pos++;1100}1101}1102return retval;1103}11041105/* We may be in a situation where we already have path/file and path1106 * is being added, or we already have path and path/file is being1107 * added. Either one would result in a nonsense tree that has path1108 * twice when git-write-tree tries to write it out. Prevent it.1109 *1110 * If ok-to-replace is specified, we remove the conflicting entries1111 * from the cache so the caller should recompute the insert position.1112 * When this happens, we return non-zero.1113 */1114static intcheck_file_directory_conflict(struct index_state *istate,1115const struct cache_entry *ce,1116int pos,int ok_to_replace)1117{1118int retval;11191120/*1121 * When ce is an "I am going away" entry, we allow it to be added1122 */1123if(ce->ce_flags & CE_REMOVE)1124return0;11251126/*1127 * We check if the path is a sub-path of a subsequent pathname1128 * first, since removing those will not change the position1129 * in the array.1130 */1131 retval =has_file_name(istate, ce, pos, ok_to_replace);11321133/*1134 * Then check if the path might have a clashing sub-directory1135 * before it.1136 */1137return retval +has_dir_name(istate, ce, pos, ok_to_replace);1138}11391140static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1141{1142int pos;1143int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1144int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1145int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1146int new_only = option & ADD_CACHE_NEW_ONLY;11471148if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1149cache_tree_invalidate_path(istate, ce->name);11501151/*1152 * If this entry's path sorts after the last entry in the index,1153 * we can avoid searching for it.1154 */1155if(istate->cache_nr >0&&1156strcmp(ce->name, istate->cache[istate->cache_nr -1]->name) >0)1157 pos = -istate->cache_nr -1;1158else1159 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));11601161/* existing match? Just replace it. */1162if(pos >=0) {1163if(!new_only)1164replace_index_entry(istate, pos, ce);1165return0;1166}1167 pos = -pos-1;11681169if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1170untracked_cache_add_to_index(istate, ce->name);11711172/*1173 * Inserting a merged entry ("stage 0") into the index1174 * will always replace all non-merged entries..1175 */1176if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1177while(ce_same_name(istate->cache[pos], ce)) {1178 ok_to_add =1;1179if(!remove_index_entry_at(istate, pos))1180break;1181}1182}11831184if(!ok_to_add)1185return-1;1186if(!verify_path(ce->name))1187returnerror("Invalid path '%s'", ce->name);11881189if(!skip_df_check &&1190check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1191if(!ok_to_replace)1192returnerror("'%s' appears as both a file and as a directory",1193 ce->name);1194 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1195 pos = -pos-1;1196}1197return pos +1;1198}11991200intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1201{1202int pos;12031204if(option & ADD_CACHE_JUST_APPEND)1205 pos = istate->cache_nr;1206else{1207int ret;1208 ret =add_index_entry_with_check(istate, ce, option);1209if(ret <=0)1210return ret;1211 pos = ret -1;1212}12131214/* Make sure the array is big enough .. */1215ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);12161217/* Add it in.. */1218 istate->cache_nr++;1219if(istate->cache_nr > pos +1)1220memmove(istate->cache + pos +1,1221 istate->cache + pos,1222(istate->cache_nr - pos -1) *sizeof(ce));1223set_index_entry(istate, pos, ce);1224 istate->cache_changed |= CE_ENTRY_ADDED;1225return0;1226}12271228/*1229 * "refresh" does not calculate a new sha1 file or bring the1230 * cache up-to-date for mode/content changes. But what it1231 * _does_ do is to "re-match" the stat information of a file1232 * with the cache, so that you can refresh the cache for a1233 * file that hasn't been changed but where the stat entry is1234 * out of date.1235 *1236 * For example, you'd want to do this after doing a "git-read-tree",1237 * to link up the stat cache details with the proper files.1238 */1239static struct cache_entry *refresh_cache_ent(struct index_state *istate,1240struct cache_entry *ce,1241unsigned int options,int*err,1242int*changed_ret)1243{1244struct stat st;1245struct cache_entry *updated;1246int changed, size;1247int refresh = options & CE_MATCH_REFRESH;1248int ignore_valid = options & CE_MATCH_IGNORE_VALID;1249int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1250int ignore_missing = options & CE_MATCH_IGNORE_MISSING;1251int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR;12521253if(!refresh ||ce_uptodate(ce))1254return ce;12551256if(!ignore_fsmonitor)1257refresh_fsmonitor(istate);1258/*1259 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1260 * that the change to the work tree does not matter and told1261 * us not to worry.1262 */1263if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1264ce_mark_uptodate(ce);1265return ce;1266}1267if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1268ce_mark_uptodate(ce);1269return ce;1270}1271if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) {1272ce_mark_uptodate(ce);1273return ce;1274}12751276if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1277if(ignore_missing)1278return ce;1279if(err)1280*err = ENOENT;1281return NULL;1282}12831284if(lstat(ce->name, &st) <0) {1285if(ignore_missing && errno == ENOENT)1286return ce;1287if(err)1288*err = errno;1289return NULL;1290}12911292 changed =ie_match_stat(istate, ce, &st, options);1293if(changed_ret)1294*changed_ret = changed;1295if(!changed) {1296/*1297 * The path is unchanged. If we were told to ignore1298 * valid bit, then we did the actual stat check and1299 * found that the entry is unmodified. If the entry1300 * is not marked VALID, this is the place to mark it1301 * valid again, under "assume unchanged" mode.1302 */1303if(ignore_valid && assume_unchanged &&1304!(ce->ce_flags & CE_VALID))1305;/* mark this one VALID again */1306else{1307/*1308 * We do not mark the index itself "modified"1309 * because CE_UPTODATE flag is in-core only;1310 * we are not going to write this change out.1311 */1312if(!S_ISGITLINK(ce->ce_mode)) {1313ce_mark_uptodate(ce);1314mark_fsmonitor_valid(ce);1315}1316return ce;1317}1318}13191320if(ie_modified(istate, ce, &st, options)) {1321if(err)1322*err = EINVAL;1323return NULL;1324}13251326 size =ce_size(ce);1327 updated =xmalloc(size);1328memcpy(updated, ce, size);1329fill_stat_cache_info(updated, &st);1330/*1331 * If ignore_valid is not set, we should leave CE_VALID bit1332 * alone. Otherwise, paths marked with --no-assume-unchanged1333 * (i.e. things to be edited) will reacquire CE_VALID bit1334 * automatically, which is not really what we want.1335 */1336if(!ignore_valid && assume_unchanged &&1337!(ce->ce_flags & CE_VALID))1338 updated->ce_flags &= ~CE_VALID;13391340/* istate->cache_changed is updated in the caller */1341return updated;1342}13431344static voidshow_file(const char* fmt,const char* name,int in_porcelain,1345int* first,const char*header_msg)1346{1347if(in_porcelain && *first && header_msg) {1348printf("%s\n", header_msg);1349*first =0;1350}1351printf(fmt, name);1352}13531354intrefresh_index(struct index_state *istate,unsigned int flags,1355const struct pathspec *pathspec,1356char*seen,const char*header_msg)1357{1358int i;1359int has_errors =0;1360int really = (flags & REFRESH_REALLY) !=0;1361int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1362int quiet = (flags & REFRESH_QUIET) !=0;1363int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1364int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1365int first =1;1366int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1367unsigned int options = (CE_MATCH_REFRESH |1368(really ? CE_MATCH_IGNORE_VALID :0) |1369(not_new ? CE_MATCH_IGNORE_MISSING :0));1370const char*modified_fmt;1371const char*deleted_fmt;1372const char*typechange_fmt;1373const char*added_fmt;1374const char*unmerged_fmt;13751376 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1377 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1378 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1379 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1380 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1381for(i =0; i < istate->cache_nr; i++) {1382struct cache_entry *ce, *new;1383int cache_errno =0;1384int changed =0;1385int filtered =0;13861387 ce = istate->cache[i];1388if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1389continue;13901391if(pathspec && !ce_path_match(ce, pathspec, seen))1392 filtered =1;13931394if(ce_stage(ce)) {1395while((i < istate->cache_nr) &&1396!strcmp(istate->cache[i]->name, ce->name))1397 i++;1398 i--;1399if(allow_unmerged)1400continue;1401if(!filtered)1402show_file(unmerged_fmt, ce->name, in_porcelain,1403&first, header_msg);1404 has_errors =1;1405continue;1406}14071408if(filtered)1409continue;14101411new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1412if(new== ce)1413continue;1414if(!new) {1415const char*fmt;14161417if(really && cache_errno == EINVAL) {1418/* If we are doing --really-refresh that1419 * means the index is not valid anymore.1420 */1421 ce->ce_flags &= ~CE_VALID;1422 ce->ce_flags |= CE_UPDATE_IN_BASE;1423mark_fsmonitor_invalid(istate, ce);1424 istate->cache_changed |= CE_ENTRY_CHANGED;1425}1426if(quiet)1427continue;14281429if(cache_errno == ENOENT)1430 fmt = deleted_fmt;1431else if(ce_intent_to_add(ce))1432 fmt = added_fmt;/* must be before other checks */1433else if(changed & TYPE_CHANGED)1434 fmt = typechange_fmt;1435else1436 fmt = modified_fmt;1437show_file(fmt,1438 ce->name, in_porcelain, &first, header_msg);1439 has_errors =1;1440continue;1441}14421443replace_index_entry(istate, i,new);1444}1445return has_errors;1446}14471448struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1449unsigned int options)1450{1451returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1452}145314541455/*****************************************************************1456 * Index File I/O1457 *****************************************************************/14581459#define INDEX_FORMAT_DEFAULT 314601461static unsigned intget_index_format_default(void)1462{1463char*envversion =getenv("GIT_INDEX_VERSION");1464char*endp;1465int value;1466unsigned int version = INDEX_FORMAT_DEFAULT;14671468if(!envversion) {1469if(!git_config_get_int("index.version", &value))1470 version = value;1471if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1472warning(_("index.version set, but the value is invalid.\n"1473"Using version%i"), INDEX_FORMAT_DEFAULT);1474return INDEX_FORMAT_DEFAULT;1475}1476return version;1477}14781479 version =strtoul(envversion, &endp,10);1480if(*endp ||1481 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1482warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1483"Using version%i"), INDEX_FORMAT_DEFAULT);1484 version = INDEX_FORMAT_DEFAULT;1485}1486return version;1487}14881489/*1490 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1491 * Again - this is just a (very strong in practice) heuristic that1492 * the inode hasn't changed.1493 *1494 * We save the fields in big-endian order to allow using the1495 * index file over NFS transparently.1496 */1497struct ondisk_cache_entry {1498struct cache_time ctime;1499struct cache_time mtime;1500uint32_t dev;1501uint32_t ino;1502uint32_t mode;1503uint32_t uid;1504uint32_t gid;1505uint32_t size;1506unsigned char sha1[20];1507uint16_t flags;1508char name[FLEX_ARRAY];/* more */1509};15101511/*1512 * This struct is used when CE_EXTENDED bit is 11513 * The struct must match ondisk_cache_entry exactly from1514 * ctime till flags1515 */1516struct ondisk_cache_entry_extended {1517struct cache_time ctime;1518struct cache_time mtime;1519uint32_t dev;1520uint32_t ino;1521uint32_t mode;1522uint32_t uid;1523uint32_t gid;1524uint32_t size;1525unsigned char sha1[20];1526uint16_t flags;1527uint16_t flags2;1528char name[FLEX_ARRAY];/* more */1529};15301531/* These are only used for v3 or lower */1532#define align_padding_size(size, len) ((size + (len) + 8) & ~7) - (size + len)1533#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1534#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1535#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1536#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1537 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1538 ondisk_cache_entry_size(ce_namelen(ce)))15391540/* Allow fsck to force verification of the index checksum. */1541int verify_index_checksum;15421543/* Allow fsck to force verification of the cache entry order. */1544int verify_ce_order;15451546static intverify_hdr(struct cache_header *hdr,unsigned long size)1547{1548 git_hash_ctx c;1549unsigned char hash[GIT_MAX_RAWSZ];1550int hdr_version;15511552if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1553returnerror("bad signature");1554 hdr_version =ntohl(hdr->hdr_version);1555if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1556returnerror("bad index version%d", hdr_version);15571558if(!verify_index_checksum)1559return0;15601561 the_hash_algo->init_fn(&c);1562 the_hash_algo->update_fn(&c, hdr, size - the_hash_algo->rawsz);1563 the_hash_algo->final_fn(hash, &c);1564if(hashcmp(hash, (unsigned char*)hdr + size - the_hash_algo->rawsz))1565returnerror("bad index file sha1 signature");1566return0;1567}15681569static intread_index_extension(struct index_state *istate,1570const char*ext,void*data,unsigned long sz)1571{1572switch(CACHE_EXT(ext)) {1573case CACHE_EXT_TREE:1574 istate->cache_tree =cache_tree_read(data, sz);1575break;1576case CACHE_EXT_RESOLVE_UNDO:1577 istate->resolve_undo =resolve_undo_read(data, sz);1578break;1579case CACHE_EXT_LINK:1580if(read_link_extension(istate, data, sz))1581return-1;1582break;1583case CACHE_EXT_UNTRACKED:1584 istate->untracked =read_untracked_extension(data, sz);1585break;1586case CACHE_EXT_FSMONITOR:1587read_fsmonitor_extension(istate, data, sz);1588break;1589default:1590if(*ext <'A'||'Z'< *ext)1591returnerror("index uses %.4s extension, which we do not understand",1592 ext);1593fprintf(stderr,"ignoring %.4s extension\n", ext);1594break;1595}1596return0;1597}15981599inthold_locked_index(struct lock_file *lk,int lock_flags)1600{1601returnhold_lock_file_for_update(lk,get_index_file(), lock_flags);1602}16031604intread_index(struct index_state *istate)1605{1606returnread_index_from(istate,get_index_file());1607}16081609static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1610unsigned int flags,1611const char*name,1612size_t len)1613{1614struct cache_entry *ce =xmalloc(cache_entry_size(len));16151616 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1617 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1618 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1619 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1620 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1621 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1622 ce->ce_mode =get_be32(&ondisk->mode);1623 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1624 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1625 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1626 ce->ce_flags = flags & ~CE_NAMEMASK;1627 ce->ce_namelen = len;1628 ce->index =0;1629hashcpy(ce->oid.hash, ondisk->sha1);1630memcpy(ce->name, name, len);1631 ce->name[len] ='\0';1632return ce;1633}16341635/*1636 * Adjacent cache entries tend to share the leading paths, so it makes1637 * sense to only store the differences in later entries. In the v41638 * on-disk format of the index, each on-disk cache entry stores the1639 * number of bytes to be stripped from the end of the previous name,1640 * and the bytes to append to the result, to come up with its name.1641 */1642static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1643{1644const unsigned char*ep, *cp = (const unsigned char*)cp_;1645size_t len =decode_varint(&cp);16461647if(name->len < len)1648die("malformed name field in the index");1649strbuf_remove(name, name->len - len, len);1650for(ep = cp; *ep; ep++)1651;/* find the end */1652strbuf_add(name, cp, ep - cp);1653return(const char*)ep +1- cp_;1654}16551656static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1657unsigned long*ent_size,1658struct strbuf *previous_name)1659{1660struct cache_entry *ce;1661size_t len;1662const char*name;1663unsigned int flags;16641665/* On-disk flags are just 16 bits */1666 flags =get_be16(&ondisk->flags);1667 len = flags & CE_NAMEMASK;16681669if(flags & CE_EXTENDED) {1670struct ondisk_cache_entry_extended *ondisk2;1671int extended_flags;1672 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1673 extended_flags =get_be16(&ondisk2->flags2) <<16;1674/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1675if(extended_flags & ~CE_EXTENDED_FLAGS)1676die("Unknown index entry format%08x", extended_flags);1677 flags |= extended_flags;1678 name = ondisk2->name;1679}1680else1681 name = ondisk->name;16821683if(!previous_name) {1684/* v3 and earlier */1685if(len == CE_NAMEMASK)1686 len =strlen(name);1687 ce =cache_entry_from_ondisk(ondisk, flags, name, len);16881689*ent_size =ondisk_ce_size(ce);1690}else{1691unsigned long consumed;1692 consumed =expand_name_field(previous_name, name);1693 ce =cache_entry_from_ondisk(ondisk, flags,1694 previous_name->buf,1695 previous_name->len);16961697*ent_size = (name - ((char*)ondisk)) + consumed;1698}1699return ce;1700}17011702static voidcheck_ce_order(struct index_state *istate)1703{1704unsigned int i;17051706if(!verify_ce_order)1707return;17081709for(i =1; i < istate->cache_nr; i++) {1710struct cache_entry *ce = istate->cache[i -1];1711struct cache_entry *next_ce = istate->cache[i];1712int name_compare =strcmp(ce->name, next_ce->name);17131714if(0< name_compare)1715die("unordered stage entries in index");1716if(!name_compare) {1717if(!ce_stage(ce))1718die("multiple stage entries for merged file '%s'",1719 ce->name);1720if(ce_stage(ce) >ce_stage(next_ce))1721die("unordered stage entries for '%s'",1722 ce->name);1723}1724}1725}17261727static voidtweak_untracked_cache(struct index_state *istate)1728{1729switch(git_config_get_untracked_cache()) {1730case-1:/* keep: do nothing */1731break;1732case0:/* false */1733remove_untracked_cache(istate);1734break;1735case1:/* true */1736add_untracked_cache(istate);1737break;1738default:/* unknown value: do nothing */1739break;1740}1741}17421743static voidtweak_split_index(struct index_state *istate)1744{1745switch(git_config_get_split_index()) {1746case-1:/* unset: do nothing */1747break;1748case0:/* false */1749remove_split_index(istate);1750break;1751case1:/* true */1752add_split_index(istate);1753break;1754default:/* unknown value: do nothing */1755break;1756}1757}17581759static voidpost_read_index_from(struct index_state *istate)1760{1761check_ce_order(istate);1762tweak_untracked_cache(istate);1763tweak_split_index(istate);1764tweak_fsmonitor(istate);1765}17661767/* remember to discard_cache() before reading a different cache! */1768intdo_read_index(struct index_state *istate,const char*path,int must_exist)1769{1770int fd, i;1771struct stat st;1772unsigned long src_offset;1773struct cache_header *hdr;1774void*mmap;1775size_t mmap_size;1776struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17771778if(istate->initialized)1779return istate->cache_nr;17801781 istate->timestamp.sec =0;1782 istate->timestamp.nsec =0;1783 fd =open(path, O_RDONLY);1784if(fd <0) {1785if(!must_exist && errno == ENOENT)1786return0;1787die_errno("%s: index file open failed", path);1788}17891790if(fstat(fd, &st))1791die_errno("cannot stat the open index");17921793 mmap_size =xsize_t(st.st_size);1794if(mmap_size <sizeof(struct cache_header) + the_hash_algo->rawsz)1795die("index file smaller than expected");17961797 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);1798if(mmap == MAP_FAILED)1799die_errno("unable to map index file");1800close(fd);18011802 hdr = mmap;1803if(verify_hdr(hdr, mmap_size) <0)1804goto unmap;18051806hashcpy(istate->sha1, (const unsigned char*)hdr + mmap_size - the_hash_algo->rawsz);1807 istate->version =ntohl(hdr->hdr_version);1808 istate->cache_nr =ntohl(hdr->hdr_entries);1809 istate->cache_alloc =alloc_nr(istate->cache_nr);1810 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1811 istate->initialized =1;18121813if(istate->version ==4)1814 previous_name = &previous_name_buf;1815else1816 previous_name = NULL;18171818 src_offset =sizeof(*hdr);1819for(i =0; i < istate->cache_nr; i++) {1820struct ondisk_cache_entry *disk_ce;1821struct cache_entry *ce;1822unsigned long consumed;18231824 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1825 ce =create_from_disk(disk_ce, &consumed, previous_name);1826set_index_entry(istate, i, ce);18271828 src_offset += consumed;1829}1830strbuf_release(&previous_name_buf);1831 istate->timestamp.sec = st.st_mtime;1832 istate->timestamp.nsec =ST_MTIME_NSEC(st);18331834while(src_offset <= mmap_size - the_hash_algo->rawsz -8) {1835/* After an array of active_nr index entries,1836 * there can be arbitrary number of extended1837 * sections, each of which is prefixed with1838 * extension name (4-byte) and section length1839 * in 4-byte network byte order.1840 */1841uint32_t extsize;1842memcpy(&extsize, (char*)mmap + src_offset +4,4);1843 extsize =ntohl(extsize);1844if(read_index_extension(istate,1845(const char*) mmap + src_offset,1846(char*) mmap + src_offset +8,1847 extsize) <0)1848goto unmap;1849 src_offset +=8;1850 src_offset += extsize;1851}1852munmap(mmap, mmap_size);1853return istate->cache_nr;18541855unmap:1856munmap(mmap, mmap_size);1857die("index file corrupt");1858}18591860/*1861 * Signal that the shared index is used by updating its mtime.1862 *1863 * This way, shared index can be removed if they have not been used1864 * for some time.1865 */1866static voidfreshen_shared_index(char*base_sha1_hex,int warn)1867{1868char*shared_index =git_pathdup("sharedindex.%s", base_sha1_hex);1869if(!check_and_freshen_file(shared_index,1) && warn)1870warning("could not freshen shared index '%s'", shared_index);1871free(shared_index);1872}18731874intread_index_from(struct index_state *istate,const char*path)1875{1876struct split_index *split_index;1877int ret;1878char*base_sha1_hex;1879const char*base_path;18801881/* istate->initialized covers both .git/index and .git/sharedindex.xxx */1882if(istate->initialized)1883return istate->cache_nr;18841885 ret =do_read_index(istate, path,0);18861887 split_index = istate->split_index;1888if(!split_index ||is_null_sha1(split_index->base_sha1)) {1889post_read_index_from(istate);1890return ret;1891}18921893if(split_index->base)1894discard_index(split_index->base);1895else1896 split_index->base =xcalloc(1,sizeof(*split_index->base));18971898 base_sha1_hex =sha1_to_hex(split_index->base_sha1);1899 base_path =git_path("sharedindex.%s", base_sha1_hex);1900 ret =do_read_index(split_index->base, base_path,1);1901if(hashcmp(split_index->base_sha1, split_index->base->sha1))1902die("broken index, expect%sin%s, got%s",1903 base_sha1_hex, base_path,1904sha1_to_hex(split_index->base->sha1));19051906freshen_shared_index(base_sha1_hex,0);1907merge_base_index(istate);1908post_read_index_from(istate);1909return ret;1910}19111912intis_index_unborn(struct index_state *istate)1913{1914return(!istate->cache_nr && !istate->timestamp.sec);1915}19161917intdiscard_index(struct index_state *istate)1918{1919int i;19201921for(i =0; i < istate->cache_nr; i++) {1922if(istate->cache[i]->index &&1923 istate->split_index &&1924 istate->split_index->base &&1925 istate->cache[i]->index <= istate->split_index->base->cache_nr &&1926 istate->cache[i] == istate->split_index->base->cache[istate->cache[i]->index -1])1927continue;1928free(istate->cache[i]);1929}1930resolve_undo_clear_index(istate);1931 istate->cache_nr =0;1932 istate->cache_changed =0;1933 istate->timestamp.sec =0;1934 istate->timestamp.nsec =0;1935free_name_hash(istate);1936cache_tree_free(&(istate->cache_tree));1937 istate->initialized =0;1938FREE_AND_NULL(istate->cache);1939 istate->cache_alloc =0;1940discard_split_index(istate);1941free_untracked_cache(istate->untracked);1942 istate->untracked = NULL;1943return0;1944}19451946intunmerged_index(const struct index_state *istate)1947{1948int i;1949for(i =0; i < istate->cache_nr; i++) {1950if(ce_stage(istate->cache[i]))1951return1;1952}1953return0;1954}19551956#define WRITE_BUFFER_SIZE 81921957static unsigned char write_buffer[WRITE_BUFFER_SIZE];1958static unsigned long write_buffer_len;19591960static intce_write_flush(git_hash_ctx *context,int fd)1961{1962unsigned int buffered = write_buffer_len;1963if(buffered) {1964 the_hash_algo->update_fn(context, write_buffer, buffered);1965if(write_in_full(fd, write_buffer, buffered) <0)1966return-1;1967 write_buffer_len =0;1968}1969return0;1970}19711972static intce_write(git_hash_ctx *context,int fd,void*data,unsigned int len)1973{1974while(len) {1975unsigned int buffered = write_buffer_len;1976unsigned int partial = WRITE_BUFFER_SIZE - buffered;1977if(partial > len)1978 partial = len;1979memcpy(write_buffer + buffered, data, partial);1980 buffered += partial;1981if(buffered == WRITE_BUFFER_SIZE) {1982 write_buffer_len = buffered;1983if(ce_write_flush(context, fd))1984return-1;1985 buffered =0;1986}1987 write_buffer_len = buffered;1988 len -= partial;1989 data = (char*) data + partial;1990}1991return0;1992}19931994static intwrite_index_ext_header(git_hash_ctx *context,int fd,1995unsigned int ext,unsigned int sz)1996{1997 ext =htonl(ext);1998 sz =htonl(sz);1999return((ce_write(context, fd, &ext,4) <0) ||2000(ce_write(context, fd, &sz,4) <0)) ? -1:0;2001}20022003static intce_flush(git_hash_ctx *context,int fd,unsigned char*hash)2004{2005unsigned int left = write_buffer_len;20062007if(left) {2008 write_buffer_len =0;2009 the_hash_algo->update_fn(context, write_buffer, left);2010}20112012/* Flush first if not enough space for hash signature */2013if(left + the_hash_algo->rawsz > WRITE_BUFFER_SIZE) {2014if(write_in_full(fd, write_buffer, left) <0)2015return-1;2016 left =0;2017}20182019/* Append the hash signature at the end */2020 the_hash_algo->final_fn(write_buffer + left, context);2021hashcpy(hash, write_buffer + left);2022 left += the_hash_algo->rawsz;2023return(write_in_full(fd, write_buffer, left) <0) ? -1:0;2024}20252026static voidce_smudge_racily_clean_entry(struct cache_entry *ce)2027{2028/*2029 * The only thing we care about in this function is to smudge the2030 * falsely clean entry due to touch-update-touch race, so we leave2031 * everything else as they are. We are called for entries whose2032 * ce_stat_data.sd_mtime match the index file mtime.2033 *2034 * Note that this actually does not do much for gitlinks, for2035 * which ce_match_stat_basic() always goes to the actual2036 * contents. The caller checks with is_racy_timestamp() which2037 * always says "no" for gitlinks, so we are not called for them ;-)2038 */2039struct stat st;20402041if(lstat(ce->name, &st) <0)2042return;2043if(ce_match_stat_basic(ce, &st))2044return;2045if(ce_modified_check_fs(ce, &st)) {2046/* This is "racily clean"; smudge it. Note that this2047 * is a tricky code. At first glance, it may appear2048 * that it can break with this sequence:2049 *2050 * $ echo xyzzy >frotz2051 * $ git-update-index --add frotz2052 * $ : >frotz2053 * $ sleep 32054 * $ echo filfre >nitfol2055 * $ git-update-index --add nitfol2056 *2057 * but it does not. When the second update-index runs,2058 * it notices that the entry "frotz" has the same timestamp2059 * as index, and if we were to smudge it by resetting its2060 * size to zero here, then the object name recorded2061 * in index is the 6-byte file but the cached stat information2062 * becomes zero --- which would then match what we would2063 * obtain from the filesystem next time we stat("frotz").2064 *2065 * However, the second update-index, before calling2066 * this function, notices that the cached size is 62067 * bytes and what is on the filesystem is an empty2068 * file, and never calls us, so the cached size information2069 * for "frotz" stays 6 which does not match the filesystem.2070 */2071 ce->ce_stat_data.sd_size =0;2072}2073}20742075/* Copy miscellaneous fields but not the name */2076static voidcopy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,2077struct cache_entry *ce)2078{2079short flags;20802081 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);2082 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);2083 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);2084 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);2085 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);2086 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);2087 ondisk->mode =htonl(ce->ce_mode);2088 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);2089 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);2090 ondisk->size =htonl(ce->ce_stat_data.sd_size);2091hashcpy(ondisk->sha1, ce->oid.hash);20922093 flags = ce->ce_flags & ~CE_NAMEMASK;2094 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));2095 ondisk->flags =htons(flags);2096if(ce->ce_flags & CE_EXTENDED) {2097struct ondisk_cache_entry_extended *ondisk2;2098 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;2099 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);2100}2101}21022103static intce_write_entry(git_hash_ctx *c,int fd,struct cache_entry *ce,2104struct strbuf *previous_name,struct ondisk_cache_entry *ondisk)2105{2106int size;2107int saved_namelen = saved_namelen;/* compiler workaround */2108int result;2109static unsigned char padding[8] = {0x00};21102111if(ce->ce_flags & CE_STRIP_NAME) {2112 saved_namelen =ce_namelen(ce);2113 ce->ce_namelen =0;2114}21152116if(ce->ce_flags & CE_EXTENDED)2117 size =offsetof(struct ondisk_cache_entry_extended, name);2118else2119 size =offsetof(struct ondisk_cache_entry, name);21202121if(!previous_name) {2122int len =ce_namelen(ce);2123copy_cache_entry_to_ondisk(ondisk, ce);2124 result =ce_write(c, fd, ondisk, size);2125if(!result)2126 result =ce_write(c, fd, ce->name, len);2127if(!result)2128 result =ce_write(c, fd, padding,align_padding_size(size, len));2129}else{2130int common, to_remove, prefix_size;2131unsigned char to_remove_vi[16];2132for(common =0;2133(ce->name[common] &&2134 common < previous_name->len &&2135 ce->name[common] == previous_name->buf[common]);2136 common++)2137;/* still matching */2138 to_remove = previous_name->len - common;2139 prefix_size =encode_varint(to_remove, to_remove_vi);21402141copy_cache_entry_to_ondisk(ondisk, ce);2142 result =ce_write(c, fd, ondisk, size);2143if(!result)2144 result =ce_write(c, fd, to_remove_vi, prefix_size);2145if(!result)2146 result =ce_write(c, fd, ce->name + common,ce_namelen(ce) - common);2147if(!result)2148 result =ce_write(c, fd, padding,1);21492150strbuf_splice(previous_name, common, to_remove,2151 ce->name + common,ce_namelen(ce) - common);2152}2153if(ce->ce_flags & CE_STRIP_NAME) {2154 ce->ce_namelen = saved_namelen;2155 ce->ce_flags &= ~CE_STRIP_NAME;2156}21572158return result;2159}21602161/*2162 * This function verifies if index_state has the correct sha1 of the2163 * index file. Don't die if we have any other failure, just return 0.2164 */2165static intverify_index_from(const struct index_state *istate,const char*path)2166{2167int fd;2168 ssize_t n;2169struct stat st;2170unsigned char hash[GIT_MAX_RAWSZ];21712172if(!istate->initialized)2173return0;21742175 fd =open(path, O_RDONLY);2176if(fd <0)2177return0;21782179if(fstat(fd, &st))2180goto out;21812182if(st.st_size <sizeof(struct cache_header) + the_hash_algo->rawsz)2183goto out;21842185 n =pread_in_full(fd, hash, the_hash_algo->rawsz, st.st_size - the_hash_algo->rawsz);2186if(n != the_hash_algo->rawsz)2187goto out;21882189if(hashcmp(istate->sha1, hash))2190goto out;21912192close(fd);2193return1;21942195out:2196close(fd);2197return0;2198}21992200static intverify_index(const struct index_state *istate)2201{2202returnverify_index_from(istate,get_index_file());2203}22042205static inthas_racy_timestamp(struct index_state *istate)2206{2207int entries = istate->cache_nr;2208int i;22092210for(i =0; i < entries; i++) {2211struct cache_entry *ce = istate->cache[i];2212if(is_racy_timestamp(istate, ce))2213return1;2214}2215return0;2216}22172218voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2219{2220if((istate->cache_changed ||has_racy_timestamp(istate)) &&2221verify_index(istate))2222write_locked_index(istate, lockfile, COMMIT_LOCK);2223else2224rollback_lock_file(lockfile);2225}22262227/*2228 * On success, `tempfile` is closed. If it is the temporary file2229 * of a `struct lock_file`, we will therefore effectively perform2230 * a 'close_lock_file_gently()`. Since that is an implementation2231 * detail of lockfiles, callers of `do_write_index()` should not2232 * rely on it.2233 */2234static intdo_write_index(struct index_state *istate,struct tempfile *tempfile,2235int strip_extensions)2236{2237int newfd = tempfile->fd;2238 git_hash_ctx c;2239struct cache_header hdr;2240int i, err =0, removed, extended, hdr_version;2241struct cache_entry **cache = istate->cache;2242int entries = istate->cache_nr;2243struct stat st;2244struct ondisk_cache_entry_extended ondisk;2245struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;2246int drop_cache_tree =0;22472248for(i = removed = extended =0; i < entries; i++) {2249if(cache[i]->ce_flags & CE_REMOVE)2250 removed++;22512252/* reduce extended entries if possible */2253 cache[i]->ce_flags &= ~CE_EXTENDED;2254if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2255 extended++;2256 cache[i]->ce_flags |= CE_EXTENDED;2257}2258}22592260if(!istate->version) {2261 istate->version =get_index_format_default();2262if(getenv("GIT_TEST_SPLIT_INDEX"))2263init_split_index(istate);2264}22652266/* demote version 3 to version 2 when the latter suffices */2267if(istate->version ==3|| istate->version ==2)2268 istate->version = extended ?3:2;22692270 hdr_version = istate->version;22712272 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2273 hdr.hdr_version =htonl(hdr_version);2274 hdr.hdr_entries =htonl(entries - removed);22752276 the_hash_algo->init_fn(&c);2277if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2278return-1;22792280 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;22812282for(i =0; i < entries; i++) {2283struct cache_entry *ce = cache[i];2284if(ce->ce_flags & CE_REMOVE)2285continue;2286if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2287ce_smudge_racily_clean_entry(ce);2288if(is_null_oid(&ce->oid)) {2289static const char msg[] ="cache entry has null sha1:%s";2290static int allow = -1;22912292if(allow <0)2293 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2294if(allow)2295warning(msg, ce->name);2296else2297 err =error(msg, ce->name);22982299 drop_cache_tree =1;2300}2301if(ce_write_entry(&c, newfd, ce, previous_name, (struct ondisk_cache_entry *)&ondisk) <0)2302 err = -1;23032304if(err)2305break;2306}2307strbuf_release(&previous_name_buf);23082309if(err)2310return err;23112312/* Write extension data here */2313if(!strip_extensions && istate->split_index) {2314struct strbuf sb = STRBUF_INIT;23152316 err =write_link_extension(&sb, istate) <0||2317write_index_ext_header(&c, newfd, CACHE_EXT_LINK,2318 sb.len) <0||2319ce_write(&c, newfd, sb.buf, sb.len) <0;2320strbuf_release(&sb);2321if(err)2322return-1;2323}2324if(!strip_extensions && !drop_cache_tree && istate->cache_tree) {2325struct strbuf sb = STRBUF_INIT;23262327cache_tree_write(&sb, istate->cache_tree);2328 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <02329||ce_write(&c, newfd, sb.buf, sb.len) <0;2330strbuf_release(&sb);2331if(err)2332return-1;2333}2334if(!strip_extensions && istate->resolve_undo) {2335struct strbuf sb = STRBUF_INIT;23362337resolve_undo_write(&sb, istate->resolve_undo);2338 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,2339 sb.len) <02340||ce_write(&c, newfd, sb.buf, sb.len) <0;2341strbuf_release(&sb);2342if(err)2343return-1;2344}2345if(!strip_extensions && istate->untracked) {2346struct strbuf sb = STRBUF_INIT;23472348write_untracked_extension(&sb, istate->untracked);2349 err =write_index_ext_header(&c, newfd, CACHE_EXT_UNTRACKED,2350 sb.len) <0||2351ce_write(&c, newfd, sb.buf, sb.len) <0;2352strbuf_release(&sb);2353if(err)2354return-1;2355}2356if(!strip_extensions && istate->fsmonitor_last_update) {2357struct strbuf sb = STRBUF_INIT;23582359write_fsmonitor_extension(&sb, istate);2360 err =write_index_ext_header(&c, newfd, CACHE_EXT_FSMONITOR, sb.len) <02361||ce_write(&c, newfd, sb.buf, sb.len) <0;2362strbuf_release(&sb);2363if(err)2364return-1;2365}23662367if(ce_flush(&c, newfd, istate->sha1))2368return-1;2369if(close_tempfile_gently(tempfile)) {2370error(_("could not close '%s'"), tempfile->filename.buf);2371return-1;2372}2373if(stat(tempfile->filename.buf, &st))2374return-1;2375 istate->timestamp.sec = (unsigned int)st.st_mtime;2376 istate->timestamp.nsec =ST_MTIME_NSEC(st);2377return0;2378}23792380voidset_alternate_index_output(const char*name)2381{2382 alternate_index_output = name;2383}23842385static intcommit_locked_index(struct lock_file *lk)2386{2387if(alternate_index_output)2388returncommit_lock_file_to(lk, alternate_index_output);2389else2390returncommit_lock_file(lk);2391}23922393static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2394unsigned flags)2395{2396int ret =do_write_index(istate, lock->tempfile,0);2397if(ret)2398return ret;2399if(flags & COMMIT_LOCK)2400returncommit_locked_index(lock);2401returnclose_lock_file_gently(lock);2402}24032404static intwrite_split_index(struct index_state *istate,2405struct lock_file *lock,2406unsigned flags)2407{2408int ret;2409prepare_to_write_split_index(istate);2410 ret =do_write_locked_index(istate, lock, flags);2411finish_writing_split_index(istate);2412return ret;2413}24142415static const char*shared_index_expire ="2.weeks.ago";24162417static unsigned longget_shared_index_expire_date(void)2418{2419static unsigned long shared_index_expire_date;2420static int shared_index_expire_date_prepared;24212422if(!shared_index_expire_date_prepared) {2423git_config_get_expiry("splitindex.sharedindexexpire",2424&shared_index_expire);2425 shared_index_expire_date =approxidate(shared_index_expire);2426 shared_index_expire_date_prepared =1;2427}24282429return shared_index_expire_date;2430}24312432static intshould_delete_shared_index(const char*shared_index_path)2433{2434struct stat st;2435unsigned long expiration;24362437/* Check timestamp */2438 expiration =get_shared_index_expire_date();2439if(!expiration)2440return0;2441if(stat(shared_index_path, &st))2442returnerror_errno(_("could not stat '%s'"), shared_index_path);2443if(st.st_mtime > expiration)2444return0;24452446return1;2447}24482449static intclean_shared_index_files(const char*current_hex)2450{2451struct dirent *de;2452DIR*dir =opendir(get_git_dir());24532454if(!dir)2455returnerror_errno(_("unable to open git dir:%s"),get_git_dir());24562457while((de =readdir(dir)) != NULL) {2458const char*sha1_hex;2459const char*shared_index_path;2460if(!skip_prefix(de->d_name,"sharedindex.", &sha1_hex))2461continue;2462if(!strcmp(sha1_hex, current_hex))2463continue;2464 shared_index_path =git_path("%s", de->d_name);2465if(should_delete_shared_index(shared_index_path) >0&&2466unlink(shared_index_path))2467warning_errno(_("unable to unlink:%s"), shared_index_path);2468}2469closedir(dir);24702471return0;2472}24732474static intwrite_shared_index(struct index_state *istate,2475struct lock_file *lock,unsigned flags)2476{2477struct tempfile *temp;2478struct split_index *si = istate->split_index;2479int ret;24802481 temp =mks_tempfile(git_path("sharedindex_XXXXXX"));2482if(!temp) {2483hashclr(si->base_sha1);2484returndo_write_locked_index(istate, lock, flags);2485}2486move_cache_to_base_index(istate);2487 ret =do_write_index(si->base, temp,1);2488if(ret) {2489delete_tempfile(&temp);2490return ret;2491}2492 ret =adjust_shared_perm(get_tempfile_path(temp));2493if(ret) {2494int save_errno = errno;2495error("cannot fix permission bits on%s",get_tempfile_path(temp));2496delete_tempfile(&temp);2497 errno = save_errno;2498return ret;2499}2500 ret =rename_tempfile(&temp,2501git_path("sharedindex.%s",sha1_to_hex(si->base->sha1)));2502if(!ret) {2503hashcpy(si->base_sha1, si->base->sha1);2504clean_shared_index_files(sha1_to_hex(si->base->sha1));2505}25062507return ret;2508}25092510static const int default_max_percent_split_change =20;25112512static inttoo_many_not_shared_entries(struct index_state *istate)2513{2514int i, not_shared =0;2515int max_split =git_config_get_max_percent_split_change();25162517switch(max_split) {2518case-1:2519/* not or badly configured: use the default value */2520 max_split = default_max_percent_split_change;2521break;2522case0:2523return1;/* 0% means always write a new shared index */2524case100:2525return0;/* 100% means never write a new shared index */2526default:2527break;/* just use the configured value */2528}25292530/* Count not shared entries */2531for(i =0; i < istate->cache_nr; i++) {2532struct cache_entry *ce = istate->cache[i];2533if(!ce->index)2534 not_shared++;2535}25362537return(int64_t)istate->cache_nr * max_split < (int64_t)not_shared *100;2538}25392540intwrite_locked_index(struct index_state *istate,struct lock_file *lock,2541unsigned flags)2542{2543int new_shared_index, ret;2544struct split_index *si = istate->split_index;25452546if(istate->fsmonitor_last_update)2547fill_fsmonitor_bitmap(istate);25482549if(!si || alternate_index_output ||2550(istate->cache_changed & ~EXTMASK)) {2551if(si)2552hashclr(si->base_sha1);2553 ret =do_write_locked_index(istate, lock, flags);2554goto out;2555}25562557if(getenv("GIT_TEST_SPLIT_INDEX")) {2558int v = si->base_sha1[0];2559if((v &15) <6)2560 istate->cache_changed |= SPLIT_INDEX_ORDERED;2561}2562if(too_many_not_shared_entries(istate))2563 istate->cache_changed |= SPLIT_INDEX_ORDERED;25642565 new_shared_index = istate->cache_changed & SPLIT_INDEX_ORDERED;25662567if(new_shared_index) {2568 ret =write_shared_index(istate, lock, flags);2569if(ret)2570goto out;2571}25722573 ret =write_split_index(istate, lock, flags);25742575/* Freshen the shared index only if the split-index was written */2576if(!ret && !new_shared_index)2577freshen_shared_index(sha1_to_hex(si->base_sha1),1);25782579out:2580if(flags & COMMIT_LOCK)2581rollback_lock_file(lock);2582return ret;2583}25842585/*2586 * Read the index file that is potentially unmerged into given2587 * index_state, dropping any unmerged entries. Returns true if2588 * the index is unmerged. Callers who want to refuse to work2589 * from an unmerged state can call this and check its return value,2590 * instead of calling read_cache().2591 */2592intread_index_unmerged(struct index_state *istate)2593{2594int i;2595int unmerged =0;25962597read_index(istate);2598for(i =0; i < istate->cache_nr; i++) {2599struct cache_entry *ce = istate->cache[i];2600struct cache_entry *new_ce;2601int size, len;26022603if(!ce_stage(ce))2604continue;2605 unmerged =1;2606 len =ce_namelen(ce);2607 size =cache_entry_size(len);2608 new_ce =xcalloc(1, size);2609memcpy(new_ce->name, ce->name, len);2610 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;2611 new_ce->ce_namelen = len;2612 new_ce->ce_mode = ce->ce_mode;2613if(add_index_entry(istate, new_ce,0))2614returnerror("%s: cannot drop to stage #0",2615 new_ce->name);2616}2617return unmerged;2618}26192620/*2621 * Returns 1 if the path is an "other" path with respect to2622 * the index; that is, the path is not mentioned in the index at all,2623 * either as a file, a directory with some files in the index,2624 * or as an unmerged entry.2625 *2626 * We helpfully remove a trailing "/" from directories so that2627 * the output of read_directory can be used as-is.2628 */2629intindex_name_is_other(const struct index_state *istate,const char*name,2630int namelen)2631{2632int pos;2633if(namelen && name[namelen -1] =='/')2634 namelen--;2635 pos =index_name_pos(istate, name, namelen);2636if(0<= pos)2637return0;/* exact match */2638 pos = -pos -1;2639if(pos < istate->cache_nr) {2640struct cache_entry *ce = istate->cache[pos];2641if(ce_namelen(ce) == namelen &&2642!memcmp(ce->name, name, namelen))2643return0;/* Yup, this one exists unmerged */2644}2645return1;2646}26472648void*read_blob_data_from_index(const struct index_state *istate,2649const char*path,unsigned long*size)2650{2651int pos, len;2652unsigned long sz;2653enum object_type type;2654void*data;26552656 len =strlen(path);2657 pos =index_name_pos(istate, path, len);2658if(pos <0) {2659/*2660 * We might be in the middle of a merge, in which2661 * case we would read stage #2 (ours).2662 */2663int i;2664for(i = -pos -1;2665(pos <0&& i < istate->cache_nr &&2666!strcmp(istate->cache[i]->name, path));2667 i++)2668if(ce_stage(istate->cache[i]) ==2)2669 pos = i;2670}2671if(pos <0)2672return NULL;2673 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz);2674if(!data || type != OBJ_BLOB) {2675free(data);2676return NULL;2677}2678if(size)2679*size = sz;2680return data;2681}26822683voidstat_validity_clear(struct stat_validity *sv)2684{2685FREE_AND_NULL(sv->sd);2686}26872688intstat_validity_check(struct stat_validity *sv,const char*path)2689{2690struct stat st;26912692if(stat(path, &st) <0)2693return sv->sd == NULL;2694if(!sv->sd)2695return0;2696returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2697}26982699voidstat_validity_update(struct stat_validity *sv,int fd)2700{2701struct stat st;27022703if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2704stat_validity_clear(sv);2705else{2706if(!sv->sd)2707 sv->sd =xcalloc(1,sizeof(struct stat_data));2708fill_stat_data(sv->sd, &st);2709}2710}27112712voidmove_index_extensions(struct index_state *dst,struct index_state *src)2713{2714 dst->untracked = src->untracked;2715 src->untracked = NULL;2716}