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{ 199unsigned char sha1[20]; 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", sha1) <0) 210return0; 211returnhashcmp(sha1, ce->oid.hash); 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; 228default: 229return TYPE_CHANGED; 230} 231return0; 232} 233 234static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 235{ 236unsigned int changed =0; 237 238if(ce->ce_flags & CE_REMOVE) 239return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 240 241switch(ce->ce_mode & S_IFMT) { 242case S_IFREG: 243 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 244/* We consider only the owner x bit to be relevant for 245 * "mode changes" 246 */ 247if(trust_executable_bit && 248(0100& (ce->ce_mode ^ st->st_mode))) 249 changed |= MODE_CHANGED; 250break; 251case S_IFLNK: 252if(!S_ISLNK(st->st_mode) && 253(has_symlinks || !S_ISREG(st->st_mode))) 254 changed |= TYPE_CHANGED; 255break; 256case S_IFGITLINK: 257/* We ignore most of the st_xxx fields for gitlinks */ 258if(!S_ISDIR(st->st_mode)) 259 changed |= TYPE_CHANGED; 260else if(ce_compare_gitlink(ce)) 261 changed |= DATA_CHANGED; 262return changed; 263default: 264die("internal error: ce_mode is%o", ce->ce_mode); 265} 266 267 changed |=match_stat_data(&ce->ce_stat_data, st); 268 269/* Racily smudged entry? */ 270if(!ce->ce_stat_data.sd_size) { 271if(!is_empty_blob_sha1(ce->oid.hash)) 272 changed |= DATA_CHANGED; 273} 274 275return changed; 276} 277 278static intis_racy_stat(const struct index_state *istate, 279const struct stat_data *sd) 280{ 281return(istate->timestamp.sec && 282#ifdef USE_NSEC 283/* nanosecond timestamped files can also be racy! */ 284(istate->timestamp.sec < sd->sd_mtime.sec || 285(istate->timestamp.sec == sd->sd_mtime.sec && 286 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 287#else 288 istate->timestamp.sec <= sd->sd_mtime.sec 289#endif 290); 291} 292 293static intis_racy_timestamp(const struct index_state *istate, 294const struct cache_entry *ce) 295{ 296return(!S_ISGITLINK(ce->ce_mode) && 297is_racy_stat(istate, &ce->ce_stat_data)); 298} 299 300intmatch_stat_data_racy(const struct index_state *istate, 301const struct stat_data *sd,struct stat *st) 302{ 303if(is_racy_stat(istate, sd)) 304return MTIME_CHANGED; 305returnmatch_stat_data(sd, st); 306} 307 308intie_match_stat(struct index_state *istate, 309const struct cache_entry *ce,struct stat *st, 310unsigned int options) 311{ 312unsigned int changed; 313int ignore_valid = options & CE_MATCH_IGNORE_VALID; 314int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 315int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 316int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR; 317 318if(!ignore_fsmonitor) 319refresh_fsmonitor(istate); 320/* 321 * If it's marked as always valid in the index, it's 322 * valid whatever the checked-out copy says. 323 * 324 * skip-worktree has the same effect with higher precedence 325 */ 326if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 327return0; 328if(!ignore_valid && (ce->ce_flags & CE_VALID)) 329return0; 330if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) 331return0; 332 333/* 334 * Intent-to-add entries have not been added, so the index entry 335 * by definition never matches what is in the work tree until it 336 * actually gets added. 337 */ 338if(ce_intent_to_add(ce)) 339return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 340 341 changed =ce_match_stat_basic(ce, st); 342 343/* 344 * Within 1 second of this sequence: 345 * echo xyzzy >file && git-update-index --add file 346 * running this command: 347 * echo frotz >file 348 * would give a falsely clean cache entry. The mtime and 349 * length match the cache, and other stat fields do not change. 350 * 351 * We could detect this at update-index time (the cache entry 352 * being registered/updated records the same time as "now") 353 * and delay the return from git-update-index, but that would 354 * effectively mean we can make at most one commit per second, 355 * which is not acceptable. Instead, we check cache entries 356 * whose mtime are the same as the index file timestamp more 357 * carefully than others. 358 */ 359if(!changed &&is_racy_timestamp(istate, ce)) { 360if(assume_racy_is_modified) 361 changed |= DATA_CHANGED; 362else 363 changed |=ce_modified_check_fs(ce, st); 364} 365 366return changed; 367} 368 369intie_modified(struct index_state *istate, 370const struct cache_entry *ce, 371struct stat *st,unsigned int options) 372{ 373int changed, changed_fs; 374 375 changed =ie_match_stat(istate, ce, st, options); 376if(!changed) 377return0; 378/* 379 * If the mode or type has changed, there's no point in trying 380 * to refresh the entry - it's not going to match 381 */ 382if(changed & (MODE_CHANGED | TYPE_CHANGED)) 383return changed; 384 385/* 386 * Immediately after read-tree or update-index --cacheinfo, 387 * the length field is zero, as we have never even read the 388 * lstat(2) information once, and we cannot trust DATA_CHANGED 389 * returned by ie_match_stat() which in turn was returned by 390 * ce_match_stat_basic() to signal that the filesize of the 391 * blob changed. We have to actually go to the filesystem to 392 * see if the contents match, and if so, should answer "unchanged". 393 * 394 * The logic does not apply to gitlinks, as ce_match_stat_basic() 395 * already has checked the actual HEAD from the filesystem in the 396 * subproject. If ie_match_stat() already said it is different, 397 * then we know it is. 398 */ 399if((changed & DATA_CHANGED) && 400(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 401return changed; 402 403 changed_fs =ce_modified_check_fs(ce, st); 404if(changed_fs) 405return changed | changed_fs; 406return0; 407} 408 409intbase_name_compare(const char*name1,int len1,int mode1, 410const char*name2,int len2,int mode2) 411{ 412unsigned char c1, c2; 413int len = len1 < len2 ? len1 : len2; 414int cmp; 415 416 cmp =memcmp(name1, name2, len); 417if(cmp) 418return cmp; 419 c1 = name1[len]; 420 c2 = name2[len]; 421if(!c1 &&S_ISDIR(mode1)) 422 c1 ='/'; 423if(!c2 &&S_ISDIR(mode2)) 424 c2 ='/'; 425return(c1 < c2) ? -1: (c1 > c2) ?1:0; 426} 427 428/* 429 * df_name_compare() is identical to base_name_compare(), except it 430 * compares conflicting directory/file entries as equal. Note that 431 * while a directory name compares as equal to a regular file, they 432 * then individually compare _differently_ to a filename that has 433 * a dot after the basename (because '\0' < '.' < '/'). 434 * 435 * This is used by routines that want to traverse the git namespace 436 * but then handle conflicting entries together when possible. 437 */ 438intdf_name_compare(const char*name1,int len1,int mode1, 439const char*name2,int len2,int mode2) 440{ 441int len = len1 < len2 ? len1 : len2, cmp; 442unsigned char c1, c2; 443 444 cmp =memcmp(name1, name2, len); 445if(cmp) 446return cmp; 447/* Directories and files compare equal (same length, same name) */ 448if(len1 == len2) 449return0; 450 c1 = name1[len]; 451if(!c1 &&S_ISDIR(mode1)) 452 c1 ='/'; 453 c2 = name2[len]; 454if(!c2 &&S_ISDIR(mode2)) 455 c2 ='/'; 456if(c1 =='/'&& !c2) 457return0; 458if(c2 =='/'&& !c1) 459return0; 460return c1 - c2; 461} 462 463intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 464{ 465size_t min_len = (len1 < len2) ? len1 : len2; 466int cmp =memcmp(name1, name2, min_len); 467if(cmp) 468return cmp; 469if(len1 < len2) 470return-1; 471if(len1 > len2) 472return1; 473return0; 474} 475 476intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 477{ 478int cmp; 479 480 cmp =name_compare(name1, len1, name2, len2); 481if(cmp) 482return cmp; 483 484if(stage1 < stage2) 485return-1; 486if(stage1 > stage2) 487return1; 488return0; 489} 490 491static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 492{ 493int first, last; 494 495 first =0; 496 last = istate->cache_nr; 497while(last > first) { 498int next = (last + first) >>1; 499struct cache_entry *ce = istate->cache[next]; 500int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 501if(!cmp) 502return next; 503if(cmp <0) { 504 last = next; 505continue; 506} 507 first = next+1; 508} 509return-first-1; 510} 511 512intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 513{ 514returnindex_name_stage_pos(istate, name, namelen,0); 515} 516 517intremove_index_entry_at(struct index_state *istate,int pos) 518{ 519struct cache_entry *ce = istate->cache[pos]; 520 521record_resolve_undo(istate, ce); 522remove_name_hash(istate, ce); 523save_or_free_index_entry(istate, ce); 524 istate->cache_changed |= CE_ENTRY_REMOVED; 525 istate->cache_nr--; 526if(pos >= istate->cache_nr) 527return0; 528MOVE_ARRAY(istate->cache + pos, istate->cache + pos +1, 529 istate->cache_nr - pos); 530return1; 531} 532 533/* 534 * Remove all cache entries marked for removal, that is where 535 * CE_REMOVE is set in ce_flags. This is much more effective than 536 * calling remove_index_entry_at() for each entry to be removed. 537 */ 538voidremove_marked_cache_entries(struct index_state *istate) 539{ 540struct cache_entry **ce_array = istate->cache; 541unsigned int i, j; 542 543for(i = j =0; i < istate->cache_nr; i++) { 544if(ce_array[i]->ce_flags & CE_REMOVE) { 545remove_name_hash(istate, ce_array[i]); 546save_or_free_index_entry(istate, ce_array[i]); 547} 548else 549 ce_array[j++] = ce_array[i]; 550} 551if(j == istate->cache_nr) 552return; 553 istate->cache_changed |= CE_ENTRY_REMOVED; 554 istate->cache_nr = j; 555} 556 557intremove_file_from_index(struct index_state *istate,const char*path) 558{ 559int pos =index_name_pos(istate, path,strlen(path)); 560if(pos <0) 561 pos = -pos-1; 562cache_tree_invalidate_path(istate, path); 563untracked_cache_remove_from_index(istate, path); 564while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 565remove_index_entry_at(istate, pos); 566return0; 567} 568 569static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 570{ 571return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 572} 573 574static intindex_name_pos_also_unmerged(struct index_state *istate, 575const char*path,int namelen) 576{ 577int pos =index_name_pos(istate, path, namelen); 578struct cache_entry *ce; 579 580if(pos >=0) 581return pos; 582 583/* maybe unmerged? */ 584 pos = -1- pos; 585if(pos >= istate->cache_nr || 586compare_name((ce = istate->cache[pos]), path, namelen)) 587return-1; 588 589/* order of preference: stage 2, 1, 3 */ 590if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 591ce_stage((ce = istate->cache[pos +1])) ==2&& 592!compare_name(ce, path, namelen)) 593 pos++; 594return pos; 595} 596 597static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 598{ 599int len =ce_namelen(ce); 600returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 601} 602 603/* 604 * If we add a filename that aliases in the cache, we will use the 605 * name that we already have - but we don't want to update the same 606 * alias twice, because that implies that there were actually two 607 * different files with aliasing names! 608 * 609 * So we use the CE_ADDED flag to verify that the alias was an old 610 * one before we accept it as 611 */ 612static struct cache_entry *create_alias_ce(struct index_state *istate, 613struct cache_entry *ce, 614struct cache_entry *alias) 615{ 616int len; 617struct cache_entry *new; 618 619if(alias->ce_flags & CE_ADDED) 620die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 621 622/* Ok, create the new entry using the name of the existing alias */ 623 len =ce_namelen(alias); 624new=xcalloc(1,cache_entry_size(len)); 625memcpy(new->name, alias->name, len); 626copy_cache_entry(new, ce); 627save_or_free_index_entry(istate, ce); 628return new; 629} 630 631voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 632{ 633unsigned char sha1[20]; 634if(write_sha1_file("",0, blob_type, sha1)) 635die("cannot create an empty blob in the object database"); 636hashcpy(ce->oid.hash, sha1); 637} 638 639intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 640{ 641int size, namelen, was_same; 642 mode_t st_mode = st->st_mode; 643struct cache_entry *ce, *alias; 644unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 645int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 646int pretend = flags & ADD_CACHE_PRETEND; 647int intent_only = flags & ADD_CACHE_INTENT; 648int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 649(intent_only ? ADD_CACHE_NEW_ONLY :0)); 650 651if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 652returnerror("%s: can only add regular files, symbolic links or git-directories", path); 653 654 namelen =strlen(path); 655if(S_ISDIR(st_mode)) { 656while(namelen && path[namelen-1] =='/') 657 namelen--; 658} 659 size =cache_entry_size(namelen); 660 ce =xcalloc(1, size); 661memcpy(ce->name, path, namelen); 662 ce->ce_namelen = namelen; 663if(!intent_only) 664fill_stat_cache_info(ce, st); 665else 666 ce->ce_flags |= CE_INTENT_TO_ADD; 667 668 669if(trust_executable_bit && has_symlinks) { 670 ce->ce_mode =create_ce_mode(st_mode); 671}else{ 672/* If there is an existing entry, pick the mode bits and type 673 * from it, otherwise assume unexecutable regular file. 674 */ 675struct cache_entry *ent; 676int pos =index_name_pos_also_unmerged(istate, path, namelen); 677 678 ent = (0<= pos) ? istate->cache[pos] : NULL; 679 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 680} 681 682/* When core.ignorecase=true, determine if a directory of the same name but differing 683 * case already exists within the Git repository. If it does, ensure the directory 684 * case of the file being added to the repository matches (is folded into) the existing 685 * entry's directory case. 686 */ 687if(ignore_case) { 688adjust_dirname_case(istate, ce->name); 689} 690 691 alias =index_file_exists(istate, ce->name,ce_namelen(ce), ignore_case); 692if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 693/* Nothing changed, really */ 694if(!S_ISGITLINK(alias->ce_mode)) 695ce_mark_uptodate(alias); 696 alias->ce_flags |= CE_ADDED; 697 698free(ce); 699return0; 700} 701if(!intent_only) { 702if(index_path(&ce->oid, path, st, HASH_WRITE_OBJECT)) { 703free(ce); 704returnerror("unable to index file%s", path); 705} 706}else 707set_object_name_for_intent_to_add_entry(ce); 708 709if(ignore_case && alias &&different_name(ce, alias)) 710 ce =create_alias_ce(istate, ce, alias); 711 ce->ce_flags |= CE_ADDED; 712 713/* It was suspected to be racily clean, but it turns out to be Ok */ 714 was_same = (alias && 715!ce_stage(alias) && 716!oidcmp(&alias->oid, &ce->oid) && 717 ce->ce_mode == alias->ce_mode); 718 719if(pretend) 720free(ce); 721else if(add_index_entry(istate, ce, add_option)) { 722free(ce); 723returnerror("unable to add%sto index", path); 724} 725if(verbose && !was_same) 726printf("add '%s'\n", path); 727return0; 728} 729 730intadd_file_to_index(struct index_state *istate,const char*path,int flags) 731{ 732struct stat st; 733if(lstat(path, &st)) 734die_errno("unable to stat '%s'", path); 735returnadd_to_index(istate, path, &st, flags); 736} 737 738struct cache_entry *make_cache_entry(unsigned int mode, 739const unsigned char*sha1,const char*path,int stage, 740unsigned int refresh_options) 741{ 742int size, len; 743struct cache_entry *ce, *ret; 744 745if(!verify_path(path)) { 746error("Invalid path '%s'", path); 747return NULL; 748} 749 750 len =strlen(path); 751 size =cache_entry_size(len); 752 ce =xcalloc(1, size); 753 754hashcpy(ce->oid.hash, sha1); 755memcpy(ce->name, path, len); 756 ce->ce_flags =create_ce_flags(stage); 757 ce->ce_namelen = len; 758 ce->ce_mode =create_ce_mode(mode); 759 760 ret =refresh_cache_entry(ce, refresh_options); 761if(ret != ce) 762free(ce); 763return ret; 764} 765 766/* 767 * Chmod an index entry with either +x or -x. 768 * 769 * Returns -1 if the chmod for the particular cache entry failed (if it's 770 * not a regular file), -2 if an invalid flip argument is passed in, 0 771 * otherwise. 772 */ 773intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 774char flip) 775{ 776if(!S_ISREG(ce->ce_mode)) 777return-1; 778switch(flip) { 779case'+': 780 ce->ce_mode |=0111; 781break; 782case'-': 783 ce->ce_mode &= ~0111; 784break; 785default: 786return-2; 787} 788cache_tree_invalidate_path(istate, ce->name); 789 ce->ce_flags |= CE_UPDATE_IN_BASE; 790mark_fsmonitor_invalid(istate, ce); 791 istate->cache_changed |= CE_ENTRY_CHANGED; 792 793return0; 794} 795 796intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 797{ 798int len =ce_namelen(a); 799returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 800} 801 802/* 803 * We fundamentally don't like some paths: we don't want 804 * dot or dot-dot anywhere, and for obvious reasons don't 805 * want to recurse into ".git" either. 806 * 807 * Also, we don't want double slashes or slashes at the 808 * end that can make pathnames ambiguous. 809 */ 810static intverify_dotfile(const char*rest) 811{ 812/* 813 * The first character was '.', but that 814 * has already been discarded, we now test 815 * the rest. 816 */ 817 818/* "." is not allowed */ 819if(*rest =='\0'||is_dir_sep(*rest)) 820return0; 821 822switch(*rest) { 823/* 824 * ".git" followed by NUL or slash is bad. This 825 * shares the path end test with the ".." case. 826 */ 827case'g': 828case'G': 829if(rest[1] !='i'&& rest[1] !='I') 830break; 831if(rest[2] !='t'&& rest[2] !='T') 832break; 833 rest +=2; 834/* fallthrough */ 835case'.': 836if(rest[1] =='\0'||is_dir_sep(rest[1])) 837return0; 838} 839return1; 840} 841 842intverify_path(const char*path) 843{ 844char c; 845 846if(has_dos_drive_prefix(path)) 847return0; 848 849goto inside; 850for(;;) { 851if(!c) 852return1; 853if(is_dir_sep(c)) { 854inside: 855if(protect_hfs &&is_hfs_dotgit(path)) 856return0; 857if(protect_ntfs &&is_ntfs_dotgit(path)) 858return0; 859 c = *path++; 860if((c =='.'&& !verify_dotfile(path)) || 861is_dir_sep(c) || c =='\0') 862return0; 863} 864 c = *path++; 865} 866} 867 868/* 869 * Do we have another file that has the beginning components being a 870 * proper superset of the name we're trying to add? 871 */ 872static inthas_file_name(struct index_state *istate, 873const struct cache_entry *ce,int pos,int ok_to_replace) 874{ 875int retval =0; 876int len =ce_namelen(ce); 877int stage =ce_stage(ce); 878const char*name = ce->name; 879 880while(pos < istate->cache_nr) { 881struct cache_entry *p = istate->cache[pos++]; 882 883if(len >=ce_namelen(p)) 884break; 885if(memcmp(name, p->name, len)) 886break; 887if(ce_stage(p) != stage) 888continue; 889if(p->name[len] !='/') 890continue; 891if(p->ce_flags & CE_REMOVE) 892continue; 893 retval = -1; 894if(!ok_to_replace) 895break; 896remove_index_entry_at(istate, --pos); 897} 898return retval; 899} 900 901 902/* 903 * Like strcmp(), but also return the offset of the first change. 904 * If strings are equal, return the length. 905 */ 906intstrcmp_offset(const char*s1,const char*s2,size_t*first_change) 907{ 908size_t k; 909 910if(!first_change) 911returnstrcmp(s1, s2); 912 913for(k =0; s1[k] == s2[k]; k++) 914if(s1[k] =='\0') 915break; 916 917*first_change = k; 918return(unsigned char)s1[k] - (unsigned char)s2[k]; 919} 920 921/* 922 * Do we have another file with a pathname that is a proper 923 * subset of the name we're trying to add? 924 * 925 * That is, is there another file in the index with a path 926 * that matches a sub-directory in the given entry? 927 */ 928static inthas_dir_name(struct index_state *istate, 929const struct cache_entry *ce,int pos,int ok_to_replace) 930{ 931int retval =0; 932int stage =ce_stage(ce); 933const char*name = ce->name; 934const char*slash = name +ce_namelen(ce); 935size_t len_eq_last; 936int cmp_last =0; 937 938/* 939 * We are frequently called during an iteration on a sorted 940 * list of pathnames and while building a new index. Therefore, 941 * there is a high probability that this entry will eventually 942 * be appended to the index, rather than inserted in the middle. 943 * If we can confirm that, we can avoid binary searches on the 944 * components of the pathname. 945 * 946 * Compare the entry's full path with the last path in the index. 947 */ 948if(istate->cache_nr >0) { 949 cmp_last =strcmp_offset(name, 950 istate->cache[istate->cache_nr -1]->name, 951&len_eq_last); 952if(cmp_last >0) { 953if(len_eq_last ==0) { 954/* 955 * The entry sorts AFTER the last one in the 956 * index and their paths have no common prefix, 957 * so there cannot be a F/D conflict. 958 */ 959return retval; 960}else{ 961/* 962 * The entry sorts AFTER the last one in the 963 * index, but has a common prefix. Fall through 964 * to the loop below to disect the entry's path 965 * and see where the difference is. 966 */ 967} 968}else if(cmp_last ==0) { 969/* 970 * The entry exactly matches the last one in the 971 * index, but because of multiple stage and CE_REMOVE 972 * items, we fall through and let the regular search 973 * code handle it. 974 */ 975} 976} 977 978for(;;) { 979size_t len; 980 981for(;;) { 982if(*--slash =='/') 983break; 984if(slash <= ce->name) 985return retval; 986} 987 len = slash - name; 988 989if(cmp_last >0) { 990/* 991 * (len + 1) is a directory boundary (including 992 * the trailing slash). And since the loop is 993 * decrementing "slash", the first iteration is 994 * the longest directory prefix; subsequent 995 * iterations consider parent directories. 996 */ 997 998if(len +1<= len_eq_last) { 999/*1000 * The directory prefix (including the trailing1001 * slash) also appears as a prefix in the last1002 * entry, so the remainder cannot collide (because1003 * strcmp said the whole path was greater).1004 *1005 * EQ: last: xxx/A1006 * this: xxx/B1007 *1008 * LT: last: xxx/file_A1009 * this: xxx/file_B1010 */1011return retval;1012}10131014if(len > len_eq_last) {1015/*1016 * This part of the directory prefix (excluding1017 * the trailing slash) is longer than the known1018 * equal portions, so this sub-directory cannot1019 * collide with a file.1020 *1021 * GT: last: xxxA1022 * this: xxxB/file1023 */1024return retval;1025}10261027if(istate->cache_nr >0&&1028ce_namelen(istate->cache[istate->cache_nr -1]) > len) {1029/*1030 * The directory prefix lines up with part of1031 * a longer file or directory name, but sorts1032 * after it, so this sub-directory cannot1033 * collide with a file.1034 *1035 * last: xxx/yy-file (because '-' sorts before '/')1036 * this: xxx/yy/abc1037 */1038return retval;1039}10401041/*1042 * This is a possible collision. Fall through and1043 * let the regular search code handle it.1044 *1045 * last: xxx1046 * this: xxx/file1047 */1048}10491050 pos =index_name_stage_pos(istate, name, len, stage);1051if(pos >=0) {1052/*1053 * Found one, but not so fast. This could1054 * be a marker that says "I was here, but1055 * I am being removed". Such an entry is1056 * not a part of the resulting tree, and1057 * it is Ok to have a directory at the same1058 * path.1059 */1060if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) {1061 retval = -1;1062if(!ok_to_replace)1063break;1064remove_index_entry_at(istate, pos);1065continue;1066}1067}1068else1069 pos = -pos-1;10701071/*1072 * Trivial optimization: if we find an entry that1073 * already matches the sub-directory, then we know1074 * we're ok, and we can exit.1075 */1076while(pos < istate->cache_nr) {1077struct cache_entry *p = istate->cache[pos];1078if((ce_namelen(p) <= len) ||1079(p->name[len] !='/') ||1080memcmp(p->name, name, len))1081break;/* not our subdirectory */1082if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))1083/*1084 * p is at the same stage as our entry, and1085 * is a subdirectory of what we are looking1086 * at, so we cannot have conflicts at our1087 * level or anything shorter.1088 */1089return retval;1090 pos++;1091}1092}1093return retval;1094}10951096/* We may be in a situation where we already have path/file and path1097 * is being added, or we already have path and path/file is being1098 * added. Either one would result in a nonsense tree that has path1099 * twice when git-write-tree tries to write it out. Prevent it.1100 *1101 * If ok-to-replace is specified, we remove the conflicting entries1102 * from the cache so the caller should recompute the insert position.1103 * When this happens, we return non-zero.1104 */1105static intcheck_file_directory_conflict(struct index_state *istate,1106const struct cache_entry *ce,1107int pos,int ok_to_replace)1108{1109int retval;11101111/*1112 * When ce is an "I am going away" entry, we allow it to be added1113 */1114if(ce->ce_flags & CE_REMOVE)1115return0;11161117/*1118 * We check if the path is a sub-path of a subsequent pathname1119 * first, since removing those will not change the position1120 * in the array.1121 */1122 retval =has_file_name(istate, ce, pos, ok_to_replace);11231124/*1125 * Then check if the path might have a clashing sub-directory1126 * before it.1127 */1128return retval +has_dir_name(istate, ce, pos, ok_to_replace);1129}11301131static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1132{1133int pos;1134int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1135int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1136int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1137int new_only = option & ADD_CACHE_NEW_ONLY;11381139if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1140cache_tree_invalidate_path(istate, ce->name);11411142/*1143 * If this entry's path sorts after the last entry in the index,1144 * we can avoid searching for it.1145 */1146if(istate->cache_nr >0&&1147strcmp(ce->name, istate->cache[istate->cache_nr -1]->name) >0)1148 pos = -istate->cache_nr -1;1149else1150 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));11511152/* existing match? Just replace it. */1153if(pos >=0) {1154if(!new_only)1155replace_index_entry(istate, pos, ce);1156return0;1157}1158 pos = -pos-1;11591160if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1161untracked_cache_add_to_index(istate, ce->name);11621163/*1164 * Inserting a merged entry ("stage 0") into the index1165 * will always replace all non-merged entries..1166 */1167if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1168while(ce_same_name(istate->cache[pos], ce)) {1169 ok_to_add =1;1170if(!remove_index_entry_at(istate, pos))1171break;1172}1173}11741175if(!ok_to_add)1176return-1;1177if(!verify_path(ce->name))1178returnerror("Invalid path '%s'", ce->name);11791180if(!skip_df_check &&1181check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1182if(!ok_to_replace)1183returnerror("'%s' appears as both a file and as a directory",1184 ce->name);1185 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1186 pos = -pos-1;1187}1188return pos +1;1189}11901191intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1192{1193int pos;11941195if(option & ADD_CACHE_JUST_APPEND)1196 pos = istate->cache_nr;1197else{1198int ret;1199 ret =add_index_entry_with_check(istate, ce, option);1200if(ret <=0)1201return ret;1202 pos = ret -1;1203}12041205/* Make sure the array is big enough .. */1206ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);12071208/* Add it in.. */1209 istate->cache_nr++;1210if(istate->cache_nr > pos +1)1211memmove(istate->cache + pos +1,1212 istate->cache + pos,1213(istate->cache_nr - pos -1) *sizeof(ce));1214set_index_entry(istate, pos, ce);1215 istate->cache_changed |= CE_ENTRY_ADDED;1216return0;1217}12181219/*1220 * "refresh" does not calculate a new sha1 file or bring the1221 * cache up-to-date for mode/content changes. But what it1222 * _does_ do is to "re-match" the stat information of a file1223 * with the cache, so that you can refresh the cache for a1224 * file that hasn't been changed but where the stat entry is1225 * out of date.1226 *1227 * For example, you'd want to do this after doing a "git-read-tree",1228 * to link up the stat cache details with the proper files.1229 */1230static struct cache_entry *refresh_cache_ent(struct index_state *istate,1231struct cache_entry *ce,1232unsigned int options,int*err,1233int*changed_ret)1234{1235struct stat st;1236struct cache_entry *updated;1237int changed, size;1238int refresh = options & CE_MATCH_REFRESH;1239int ignore_valid = options & CE_MATCH_IGNORE_VALID;1240int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1241int ignore_missing = options & CE_MATCH_IGNORE_MISSING;1242int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR;12431244if(!refresh ||ce_uptodate(ce))1245return ce;12461247if(!ignore_fsmonitor)1248refresh_fsmonitor(istate);1249/*1250 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1251 * that the change to the work tree does not matter and told1252 * us not to worry.1253 */1254if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1255ce_mark_uptodate(ce);1256return ce;1257}1258if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1259ce_mark_uptodate(ce);1260return ce;1261}1262if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) {1263ce_mark_uptodate(ce);1264return ce;1265}12661267if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1268if(ignore_missing)1269return ce;1270if(err)1271*err = ENOENT;1272return NULL;1273}12741275if(lstat(ce->name, &st) <0) {1276if(ignore_missing && errno == ENOENT)1277return ce;1278if(err)1279*err = errno;1280return NULL;1281}12821283 changed =ie_match_stat(istate, ce, &st, options);1284if(changed_ret)1285*changed_ret = changed;1286if(!changed) {1287/*1288 * The path is unchanged. If we were told to ignore1289 * valid bit, then we did the actual stat check and1290 * found that the entry is unmodified. If the entry1291 * is not marked VALID, this is the place to mark it1292 * valid again, under "assume unchanged" mode.1293 */1294if(ignore_valid && assume_unchanged &&1295!(ce->ce_flags & CE_VALID))1296;/* mark this one VALID again */1297else{1298/*1299 * We do not mark the index itself "modified"1300 * because CE_UPTODATE flag is in-core only;1301 * we are not going to write this change out.1302 */1303if(!S_ISGITLINK(ce->ce_mode)) {1304ce_mark_uptodate(ce);1305mark_fsmonitor_valid(ce);1306}1307return ce;1308}1309}13101311if(ie_modified(istate, ce, &st, options)) {1312if(err)1313*err = EINVAL;1314return NULL;1315}13161317 size =ce_size(ce);1318 updated =xmalloc(size);1319memcpy(updated, ce, size);1320fill_stat_cache_info(updated, &st);1321/*1322 * If ignore_valid is not set, we should leave CE_VALID bit1323 * alone. Otherwise, paths marked with --no-assume-unchanged1324 * (i.e. things to be edited) will reacquire CE_VALID bit1325 * automatically, which is not really what we want.1326 */1327if(!ignore_valid && assume_unchanged &&1328!(ce->ce_flags & CE_VALID))1329 updated->ce_flags &= ~CE_VALID;13301331/* istate->cache_changed is updated in the caller */1332return updated;1333}13341335static voidshow_file(const char* fmt,const char* name,int in_porcelain,1336int* first,const char*header_msg)1337{1338if(in_porcelain && *first && header_msg) {1339printf("%s\n", header_msg);1340*first =0;1341}1342printf(fmt, name);1343}13441345intrefresh_index(struct index_state *istate,unsigned int flags,1346const struct pathspec *pathspec,1347char*seen,const char*header_msg)1348{1349int i;1350int has_errors =0;1351int really = (flags & REFRESH_REALLY) !=0;1352int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1353int quiet = (flags & REFRESH_QUIET) !=0;1354int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1355int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1356int first =1;1357int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1358unsigned int options = (CE_MATCH_REFRESH |1359(really ? CE_MATCH_IGNORE_VALID :0) |1360(not_new ? CE_MATCH_IGNORE_MISSING :0));1361const char*modified_fmt;1362const char*deleted_fmt;1363const char*typechange_fmt;1364const char*added_fmt;1365const char*unmerged_fmt;13661367 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1368 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1369 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1370 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1371 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1372for(i =0; i < istate->cache_nr; i++) {1373struct cache_entry *ce, *new;1374int cache_errno =0;1375int changed =0;1376int filtered =0;13771378 ce = istate->cache[i];1379if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1380continue;13811382if(pathspec && !ce_path_match(ce, pathspec, seen))1383 filtered =1;13841385if(ce_stage(ce)) {1386while((i < istate->cache_nr) &&1387!strcmp(istate->cache[i]->name, ce->name))1388 i++;1389 i--;1390if(allow_unmerged)1391continue;1392if(!filtered)1393show_file(unmerged_fmt, ce->name, in_porcelain,1394&first, header_msg);1395 has_errors =1;1396continue;1397}13981399if(filtered)1400continue;14011402new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1403if(new== ce)1404continue;1405if(!new) {1406const char*fmt;14071408if(really && cache_errno == EINVAL) {1409/* If we are doing --really-refresh that1410 * means the index is not valid anymore.1411 */1412 ce->ce_flags &= ~CE_VALID;1413 ce->ce_flags |= CE_UPDATE_IN_BASE;1414mark_fsmonitor_invalid(istate, ce);1415 istate->cache_changed |= CE_ENTRY_CHANGED;1416}1417if(quiet)1418continue;14191420if(cache_errno == ENOENT)1421 fmt = deleted_fmt;1422else if(ce_intent_to_add(ce))1423 fmt = added_fmt;/* must be before other checks */1424else if(changed & TYPE_CHANGED)1425 fmt = typechange_fmt;1426else1427 fmt = modified_fmt;1428show_file(fmt,1429 ce->name, in_porcelain, &first, header_msg);1430 has_errors =1;1431continue;1432}14331434replace_index_entry(istate, i,new);1435}1436return has_errors;1437}14381439struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1440unsigned int options)1441{1442returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1443}144414451446/*****************************************************************1447 * Index File I/O1448 *****************************************************************/14491450#define INDEX_FORMAT_DEFAULT 314511452static unsigned intget_index_format_default(void)1453{1454char*envversion =getenv("GIT_INDEX_VERSION");1455char*endp;1456int value;1457unsigned int version = INDEX_FORMAT_DEFAULT;14581459if(!envversion) {1460if(!git_config_get_int("index.version", &value))1461 version = value;1462if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1463warning(_("index.version set, but the value is invalid.\n"1464"Using version%i"), INDEX_FORMAT_DEFAULT);1465return INDEX_FORMAT_DEFAULT;1466}1467return version;1468}14691470 version =strtoul(envversion, &endp,10);1471if(*endp ||1472 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1473warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1474"Using version%i"), INDEX_FORMAT_DEFAULT);1475 version = INDEX_FORMAT_DEFAULT;1476}1477return version;1478}14791480/*1481 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1482 * Again - this is just a (very strong in practice) heuristic that1483 * the inode hasn't changed.1484 *1485 * We save the fields in big-endian order to allow using the1486 * index file over NFS transparently.1487 */1488struct ondisk_cache_entry {1489struct cache_time ctime;1490struct cache_time mtime;1491uint32_t dev;1492uint32_t ino;1493uint32_t mode;1494uint32_t uid;1495uint32_t gid;1496uint32_t size;1497unsigned char sha1[20];1498uint16_t flags;1499char name[FLEX_ARRAY];/* more */1500};15011502/*1503 * This struct is used when CE_EXTENDED bit is 11504 * The struct must match ondisk_cache_entry exactly from1505 * ctime till flags1506 */1507struct ondisk_cache_entry_extended {1508struct cache_time ctime;1509struct cache_time mtime;1510uint32_t dev;1511uint32_t ino;1512uint32_t mode;1513uint32_t uid;1514uint32_t gid;1515uint32_t size;1516unsigned char sha1[20];1517uint16_t flags;1518uint16_t flags2;1519char name[FLEX_ARRAY];/* more */1520};15211522/* These are only used for v3 or lower */1523#define align_padding_size(size, len) ((size + (len) + 8) & ~7) - (size + len)1524#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1525#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1526#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1527#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1528 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1529 ondisk_cache_entry_size(ce_namelen(ce)))15301531/* Allow fsck to force verification of the index checksum. */1532int verify_index_checksum;15331534static intverify_hdr(struct cache_header *hdr,unsigned long size)1535{1536 git_SHA_CTX c;1537unsigned char sha1[20];1538int hdr_version;15391540if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1541returnerror("bad signature");1542 hdr_version =ntohl(hdr->hdr_version);1543if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1544returnerror("bad index version%d", hdr_version);15451546if(!verify_index_checksum)1547return0;15481549git_SHA1_Init(&c);1550git_SHA1_Update(&c, hdr, size -20);1551git_SHA1_Final(sha1, &c);1552if(hashcmp(sha1, (unsigned char*)hdr + size -20))1553returnerror("bad index file sha1 signature");1554return0;1555}15561557static intread_index_extension(struct index_state *istate,1558const char*ext,void*data,unsigned long sz)1559{1560switch(CACHE_EXT(ext)) {1561case CACHE_EXT_TREE:1562 istate->cache_tree =cache_tree_read(data, sz);1563break;1564case CACHE_EXT_RESOLVE_UNDO:1565 istate->resolve_undo =resolve_undo_read(data, sz);1566break;1567case CACHE_EXT_LINK:1568if(read_link_extension(istate, data, sz))1569return-1;1570break;1571case CACHE_EXT_UNTRACKED:1572 istate->untracked =read_untracked_extension(data, sz);1573break;1574case CACHE_EXT_FSMONITOR:1575read_fsmonitor_extension(istate, data, sz);1576break;1577default:1578if(*ext <'A'||'Z'< *ext)1579returnerror("index uses %.4s extension, which we do not understand",1580 ext);1581fprintf(stderr,"ignoring %.4s extension\n", ext);1582break;1583}1584return0;1585}15861587inthold_locked_index(struct lock_file *lk,int lock_flags)1588{1589returnhold_lock_file_for_update(lk,get_index_file(), lock_flags);1590}15911592intread_index(struct index_state *istate)1593{1594returnread_index_from(istate,get_index_file());1595}15961597static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1598unsigned int flags,1599const char*name,1600size_t len)1601{1602struct cache_entry *ce =xmalloc(cache_entry_size(len));16031604 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1605 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1606 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1607 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1608 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1609 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1610 ce->ce_mode =get_be32(&ondisk->mode);1611 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1612 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1613 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1614 ce->ce_flags = flags & ~CE_NAMEMASK;1615 ce->ce_namelen = len;1616 ce->index =0;1617hashcpy(ce->oid.hash, ondisk->sha1);1618memcpy(ce->name, name, len);1619 ce->name[len] ='\0';1620return ce;1621}16221623/*1624 * Adjacent cache entries tend to share the leading paths, so it makes1625 * sense to only store the differences in later entries. In the v41626 * on-disk format of the index, each on-disk cache entry stores the1627 * number of bytes to be stripped from the end of the previous name,1628 * and the bytes to append to the result, to come up with its name.1629 */1630static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1631{1632const unsigned char*ep, *cp = (const unsigned char*)cp_;1633size_t len =decode_varint(&cp);16341635if(name->len < len)1636die("malformed name field in the index");1637strbuf_remove(name, name->len - len, len);1638for(ep = cp; *ep; ep++)1639;/* find the end */1640strbuf_add(name, cp, ep - cp);1641return(const char*)ep +1- cp_;1642}16431644static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1645unsigned long*ent_size,1646struct strbuf *previous_name)1647{1648struct cache_entry *ce;1649size_t len;1650const char*name;1651unsigned int flags;16521653/* On-disk flags are just 16 bits */1654 flags =get_be16(&ondisk->flags);1655 len = flags & CE_NAMEMASK;16561657if(flags & CE_EXTENDED) {1658struct ondisk_cache_entry_extended *ondisk2;1659int extended_flags;1660 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1661 extended_flags =get_be16(&ondisk2->flags2) <<16;1662/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1663if(extended_flags & ~CE_EXTENDED_FLAGS)1664die("Unknown index entry format%08x", extended_flags);1665 flags |= extended_flags;1666 name = ondisk2->name;1667}1668else1669 name = ondisk->name;16701671if(!previous_name) {1672/* v3 and earlier */1673if(len == CE_NAMEMASK)1674 len =strlen(name);1675 ce =cache_entry_from_ondisk(ondisk, flags, name, len);16761677*ent_size =ondisk_ce_size(ce);1678}else{1679unsigned long consumed;1680 consumed =expand_name_field(previous_name, name);1681 ce =cache_entry_from_ondisk(ondisk, flags,1682 previous_name->buf,1683 previous_name->len);16841685*ent_size = (name - ((char*)ondisk)) + consumed;1686}1687return ce;1688}16891690static voidcheck_ce_order(struct index_state *istate)1691{1692unsigned int i;16931694for(i =1; i < istate->cache_nr; i++) {1695struct cache_entry *ce = istate->cache[i -1];1696struct cache_entry *next_ce = istate->cache[i];1697int name_compare =strcmp(ce->name, next_ce->name);16981699if(0< name_compare)1700die("unordered stage entries in index");1701if(!name_compare) {1702if(!ce_stage(ce))1703die("multiple stage entries for merged file '%s'",1704 ce->name);1705if(ce_stage(ce) >ce_stage(next_ce))1706die("unordered stage entries for '%s'",1707 ce->name);1708}1709}1710}17111712static voidtweak_untracked_cache(struct index_state *istate)1713{1714switch(git_config_get_untracked_cache()) {1715case-1:/* keep: do nothing */1716break;1717case0:/* false */1718remove_untracked_cache(istate);1719break;1720case1:/* true */1721add_untracked_cache(istate);1722break;1723default:/* unknown value: do nothing */1724break;1725}1726}17271728static voidtweak_split_index(struct index_state *istate)1729{1730switch(git_config_get_split_index()) {1731case-1:/* unset: do nothing */1732break;1733case0:/* false */1734remove_split_index(istate);1735break;1736case1:/* true */1737add_split_index(istate);1738break;1739default:/* unknown value: do nothing */1740break;1741}1742}17431744static voidpost_read_index_from(struct index_state *istate)1745{1746check_ce_order(istate);1747tweak_untracked_cache(istate);1748tweak_split_index(istate);1749tweak_fsmonitor(istate);1750}17511752/* remember to discard_cache() before reading a different cache! */1753intdo_read_index(struct index_state *istate,const char*path,int must_exist)1754{1755int fd, i;1756struct stat st;1757unsigned long src_offset;1758struct cache_header *hdr;1759void*mmap;1760size_t mmap_size;1761struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17621763if(istate->initialized)1764return istate->cache_nr;17651766 istate->timestamp.sec =0;1767 istate->timestamp.nsec =0;1768 fd =open(path, O_RDONLY);1769if(fd <0) {1770if(!must_exist && errno == ENOENT)1771return0;1772die_errno("%s: index file open failed", path);1773}17741775if(fstat(fd, &st))1776die_errno("cannot stat the open index");17771778 mmap_size =xsize_t(st.st_size);1779if(mmap_size <sizeof(struct cache_header) +20)1780die("index file smaller than expected");17811782 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);1783if(mmap == MAP_FAILED)1784die_errno("unable to map index file");1785close(fd);17861787 hdr = mmap;1788if(verify_hdr(hdr, mmap_size) <0)1789goto unmap;17901791hashcpy(istate->sha1, (const unsigned char*)hdr + mmap_size -20);1792 istate->version =ntohl(hdr->hdr_version);1793 istate->cache_nr =ntohl(hdr->hdr_entries);1794 istate->cache_alloc =alloc_nr(istate->cache_nr);1795 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1796 istate->initialized =1;17971798if(istate->version ==4)1799 previous_name = &previous_name_buf;1800else1801 previous_name = NULL;18021803 src_offset =sizeof(*hdr);1804for(i =0; i < istate->cache_nr; i++) {1805struct ondisk_cache_entry *disk_ce;1806struct cache_entry *ce;1807unsigned long consumed;18081809 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1810 ce =create_from_disk(disk_ce, &consumed, previous_name);1811set_index_entry(istate, i, ce);18121813 src_offset += consumed;1814}1815strbuf_release(&previous_name_buf);1816 istate->timestamp.sec = st.st_mtime;1817 istate->timestamp.nsec =ST_MTIME_NSEC(st);18181819while(src_offset <= mmap_size -20-8) {1820/* After an array of active_nr index entries,1821 * there can be arbitrary number of extended1822 * sections, each of which is prefixed with1823 * extension name (4-byte) and section length1824 * in 4-byte network byte order.1825 */1826uint32_t extsize;1827memcpy(&extsize, (char*)mmap + src_offset +4,4);1828 extsize =ntohl(extsize);1829if(read_index_extension(istate,1830(const char*) mmap + src_offset,1831(char*) mmap + src_offset +8,1832 extsize) <0)1833goto unmap;1834 src_offset +=8;1835 src_offset += extsize;1836}1837munmap(mmap, mmap_size);1838return istate->cache_nr;18391840unmap:1841munmap(mmap, mmap_size);1842die("index file corrupt");1843}18441845/*1846 * Signal that the shared index is used by updating its mtime.1847 *1848 * This way, shared index can be removed if they have not been used1849 * for some time.1850 */1851static voidfreshen_shared_index(char*base_sha1_hex,int warn)1852{1853char*shared_index =git_pathdup("sharedindex.%s", base_sha1_hex);1854if(!check_and_freshen_file(shared_index,1) && warn)1855warning("could not freshen shared index '%s'", shared_index);1856free(shared_index);1857}18581859intread_index_from(struct index_state *istate,const char*path)1860{1861struct split_index *split_index;1862int ret;1863char*base_sha1_hex;1864const char*base_path;18651866/* istate->initialized covers both .git/index and .git/sharedindex.xxx */1867if(istate->initialized)1868return istate->cache_nr;18691870 ret =do_read_index(istate, path,0);18711872 split_index = istate->split_index;1873if(!split_index ||is_null_sha1(split_index->base_sha1)) {1874post_read_index_from(istate);1875return ret;1876}18771878if(split_index->base)1879discard_index(split_index->base);1880else1881 split_index->base =xcalloc(1,sizeof(*split_index->base));18821883 base_sha1_hex =sha1_to_hex(split_index->base_sha1);1884 base_path =git_path("sharedindex.%s", base_sha1_hex);1885 ret =do_read_index(split_index->base, base_path,1);1886if(hashcmp(split_index->base_sha1, split_index->base->sha1))1887die("broken index, expect%sin%s, got%s",1888 base_sha1_hex, base_path,1889sha1_to_hex(split_index->base->sha1));18901891freshen_shared_index(base_sha1_hex,0);1892merge_base_index(istate);1893post_read_index_from(istate);1894return ret;1895}18961897intis_index_unborn(struct index_state *istate)1898{1899return(!istate->cache_nr && !istate->timestamp.sec);1900}19011902intdiscard_index(struct index_state *istate)1903{1904int i;19051906for(i =0; i < istate->cache_nr; i++) {1907if(istate->cache[i]->index &&1908 istate->split_index &&1909 istate->split_index->base &&1910 istate->cache[i]->index <= istate->split_index->base->cache_nr &&1911 istate->cache[i] == istate->split_index->base->cache[istate->cache[i]->index -1])1912continue;1913free(istate->cache[i]);1914}1915resolve_undo_clear_index(istate);1916 istate->cache_nr =0;1917 istate->cache_changed =0;1918 istate->timestamp.sec =0;1919 istate->timestamp.nsec =0;1920free_name_hash(istate);1921cache_tree_free(&(istate->cache_tree));1922 istate->initialized =0;1923FREE_AND_NULL(istate->cache);1924 istate->cache_alloc =0;1925discard_split_index(istate);1926free_untracked_cache(istate->untracked);1927 istate->untracked = NULL;1928return0;1929}19301931intunmerged_index(const struct index_state *istate)1932{1933int i;1934for(i =0; i < istate->cache_nr; i++) {1935if(ce_stage(istate->cache[i]))1936return1;1937}1938return0;1939}19401941#define WRITE_BUFFER_SIZE 81921942static unsigned char write_buffer[WRITE_BUFFER_SIZE];1943static unsigned long write_buffer_len;19441945static intce_write_flush(git_SHA_CTX *context,int fd)1946{1947unsigned int buffered = write_buffer_len;1948if(buffered) {1949git_SHA1_Update(context, write_buffer, buffered);1950if(write_in_full(fd, write_buffer, buffered) != buffered)1951return-1;1952 write_buffer_len =0;1953}1954return0;1955}19561957static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1958{1959while(len) {1960unsigned int buffered = write_buffer_len;1961unsigned int partial = WRITE_BUFFER_SIZE - buffered;1962if(partial > len)1963 partial = len;1964memcpy(write_buffer + buffered, data, partial);1965 buffered += partial;1966if(buffered == WRITE_BUFFER_SIZE) {1967 write_buffer_len = buffered;1968if(ce_write_flush(context, fd))1969return-1;1970 buffered =0;1971}1972 write_buffer_len = buffered;1973 len -= partial;1974 data = (char*) data + partial;1975}1976return0;1977}19781979static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1980unsigned int ext,unsigned int sz)1981{1982 ext =htonl(ext);1983 sz =htonl(sz);1984return((ce_write(context, fd, &ext,4) <0) ||1985(ce_write(context, fd, &sz,4) <0)) ? -1:0;1986}19871988static intce_flush(git_SHA_CTX *context,int fd,unsigned char*sha1)1989{1990unsigned int left = write_buffer_len;19911992if(left) {1993 write_buffer_len =0;1994git_SHA1_Update(context, write_buffer, left);1995}19961997/* Flush first if not enough space for SHA1 signature */1998if(left +20> WRITE_BUFFER_SIZE) {1999if(write_in_full(fd, write_buffer, left) != left)2000return-1;2001 left =0;2002}20032004/* Append the SHA1 signature at the end */2005git_SHA1_Final(write_buffer + left, context);2006hashcpy(sha1, write_buffer + left);2007 left +=20;2008return(write_in_full(fd, write_buffer, left) != left) ? -1:0;2009}20102011static voidce_smudge_racily_clean_entry(struct cache_entry *ce)2012{2013/*2014 * The only thing we care about in this function is to smudge the2015 * falsely clean entry due to touch-update-touch race, so we leave2016 * everything else as they are. We are called for entries whose2017 * ce_stat_data.sd_mtime match the index file mtime.2018 *2019 * Note that this actually does not do much for gitlinks, for2020 * which ce_match_stat_basic() always goes to the actual2021 * contents. The caller checks with is_racy_timestamp() which2022 * always says "no" for gitlinks, so we are not called for them ;-)2023 */2024struct stat st;20252026if(lstat(ce->name, &st) <0)2027return;2028if(ce_match_stat_basic(ce, &st))2029return;2030if(ce_modified_check_fs(ce, &st)) {2031/* This is "racily clean"; smudge it. Note that this2032 * is a tricky code. At first glance, it may appear2033 * that it can break with this sequence:2034 *2035 * $ echo xyzzy >frotz2036 * $ git-update-index --add frotz2037 * $ : >frotz2038 * $ sleep 32039 * $ echo filfre >nitfol2040 * $ git-update-index --add nitfol2041 *2042 * but it does not. When the second update-index runs,2043 * it notices that the entry "frotz" has the same timestamp2044 * as index, and if we were to smudge it by resetting its2045 * size to zero here, then the object name recorded2046 * in index is the 6-byte file but the cached stat information2047 * becomes zero --- which would then match what we would2048 * obtain from the filesystem next time we stat("frotz").2049 *2050 * However, the second update-index, before calling2051 * this function, notices that the cached size is 62052 * bytes and what is on the filesystem is an empty2053 * file, and never calls us, so the cached size information2054 * for "frotz" stays 6 which does not match the filesystem.2055 */2056 ce->ce_stat_data.sd_size =0;2057}2058}20592060/* Copy miscellaneous fields but not the name */2061static voidcopy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,2062struct cache_entry *ce)2063{2064short flags;20652066 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);2067 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);2068 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);2069 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);2070 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);2071 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);2072 ondisk->mode =htonl(ce->ce_mode);2073 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);2074 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);2075 ondisk->size =htonl(ce->ce_stat_data.sd_size);2076hashcpy(ondisk->sha1, ce->oid.hash);20772078 flags = ce->ce_flags & ~CE_NAMEMASK;2079 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));2080 ondisk->flags =htons(flags);2081if(ce->ce_flags & CE_EXTENDED) {2082struct ondisk_cache_entry_extended *ondisk2;2083 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;2084 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);2085}2086}20872088static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,2089struct strbuf *previous_name,struct ondisk_cache_entry *ondisk)2090{2091int size;2092int saved_namelen = saved_namelen;/* compiler workaround */2093int result;2094static unsigned char padding[8] = {0x00};20952096if(ce->ce_flags & CE_STRIP_NAME) {2097 saved_namelen =ce_namelen(ce);2098 ce->ce_namelen =0;2099}21002101if(ce->ce_flags & CE_EXTENDED)2102 size =offsetof(struct ondisk_cache_entry_extended, name);2103else2104 size =offsetof(struct ondisk_cache_entry, name);21052106if(!previous_name) {2107int len =ce_namelen(ce);2108copy_cache_entry_to_ondisk(ondisk, ce);2109 result =ce_write(c, fd, ondisk, size);2110if(!result)2111 result =ce_write(c, fd, ce->name, len);2112if(!result)2113 result =ce_write(c, fd, padding,align_padding_size(size, len));2114}else{2115int common, to_remove, prefix_size;2116unsigned char to_remove_vi[16];2117for(common =0;2118(ce->name[common] &&2119 common < previous_name->len &&2120 ce->name[common] == previous_name->buf[common]);2121 common++)2122;/* still matching */2123 to_remove = previous_name->len - common;2124 prefix_size =encode_varint(to_remove, to_remove_vi);21252126copy_cache_entry_to_ondisk(ondisk, ce);2127 result =ce_write(c, fd, ondisk, size);2128if(!result)2129 result =ce_write(c, fd, to_remove_vi, prefix_size);2130if(!result)2131 result =ce_write(c, fd, ce->name + common,ce_namelen(ce) - common +1);21322133strbuf_splice(previous_name, common, to_remove,2134 ce->name + common,ce_namelen(ce) - common);2135}2136if(ce->ce_flags & CE_STRIP_NAME) {2137 ce->ce_namelen = saved_namelen;2138 ce->ce_flags &= ~CE_STRIP_NAME;2139}21402141return result;2142}21432144/*2145 * This function verifies if index_state has the correct sha1 of the2146 * index file. Don't die if we have any other failure, just return 0.2147 */2148static intverify_index_from(const struct index_state *istate,const char*path)2149{2150int fd;2151 ssize_t n;2152struct stat st;2153unsigned char sha1[20];21542155if(!istate->initialized)2156return0;21572158 fd =open(path, O_RDONLY);2159if(fd <0)2160return0;21612162if(fstat(fd, &st))2163goto out;21642165if(st.st_size <sizeof(struct cache_header) +20)2166goto out;21672168 n =pread_in_full(fd, sha1,20, st.st_size -20);2169if(n !=20)2170goto out;21712172if(hashcmp(istate->sha1, sha1))2173goto out;21742175close(fd);2176return1;21772178out:2179close(fd);2180return0;2181}21822183static intverify_index(const struct index_state *istate)2184{2185returnverify_index_from(istate,get_index_file());2186}21872188static inthas_racy_timestamp(struct index_state *istate)2189{2190int entries = istate->cache_nr;2191int i;21922193for(i =0; i < entries; i++) {2194struct cache_entry *ce = istate->cache[i];2195if(is_racy_timestamp(istate, ce))2196return1;2197}2198return0;2199}22002201/*2202 * Opportunistically update the index but do not complain if we can't2203 */2204voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2205{2206if((istate->cache_changed ||has_racy_timestamp(istate)) &&2207verify_index(istate) &&2208write_locked_index(istate, lockfile, COMMIT_LOCK))2209rollback_lock_file(lockfile);2210}22112212static intdo_write_index(struct index_state *istate,struct tempfile *tempfile,2213int strip_extensions)2214{2215int newfd = tempfile->fd;2216 git_SHA_CTX c;2217struct cache_header hdr;2218int i, err =0, removed, extended, hdr_version;2219struct cache_entry **cache = istate->cache;2220int entries = istate->cache_nr;2221struct stat st;2222struct ondisk_cache_entry_extended ondisk;2223struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;2224int drop_cache_tree =0;22252226for(i = removed = extended =0; i < entries; i++) {2227if(cache[i]->ce_flags & CE_REMOVE)2228 removed++;22292230/* reduce extended entries if possible */2231 cache[i]->ce_flags &= ~CE_EXTENDED;2232if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2233 extended++;2234 cache[i]->ce_flags |= CE_EXTENDED;2235}2236}22372238if(!istate->version) {2239 istate->version =get_index_format_default();2240if(getenv("GIT_TEST_SPLIT_INDEX"))2241init_split_index(istate);2242}22432244/* demote version 3 to version 2 when the latter suffices */2245if(istate->version ==3|| istate->version ==2)2246 istate->version = extended ?3:2;22472248 hdr_version = istate->version;22492250 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2251 hdr.hdr_version =htonl(hdr_version);2252 hdr.hdr_entries =htonl(entries - removed);22532254git_SHA1_Init(&c);2255if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2256return-1;22572258 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;22592260for(i =0; i < entries; i++) {2261struct cache_entry *ce = cache[i];2262if(ce->ce_flags & CE_REMOVE)2263continue;2264if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2265ce_smudge_racily_clean_entry(ce);2266if(is_null_oid(&ce->oid)) {2267static const char msg[] ="cache entry has null sha1:%s";2268static int allow = -1;22692270if(allow <0)2271 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2272if(allow)2273warning(msg, ce->name);2274else2275 err =error(msg, ce->name);22762277 drop_cache_tree =1;2278}2279if(ce_write_entry(&c, newfd, ce, previous_name, (struct ondisk_cache_entry *)&ondisk) <0)2280 err = -1;22812282if(err)2283break;2284}2285strbuf_release(&previous_name_buf);22862287if(err)2288return err;22892290/* Write extension data here */2291if(!strip_extensions && istate->split_index) {2292struct strbuf sb = STRBUF_INIT;22932294 err =write_link_extension(&sb, istate) <0||2295write_index_ext_header(&c, newfd, CACHE_EXT_LINK,2296 sb.len) <0||2297ce_write(&c, newfd, sb.buf, sb.len) <0;2298strbuf_release(&sb);2299if(err)2300return-1;2301}2302if(!strip_extensions && !drop_cache_tree && istate->cache_tree) {2303struct strbuf sb = STRBUF_INIT;23042305cache_tree_write(&sb, istate->cache_tree);2306 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <02307||ce_write(&c, newfd, sb.buf, sb.len) <0;2308strbuf_release(&sb);2309if(err)2310return-1;2311}2312if(!strip_extensions && istate->resolve_undo) {2313struct strbuf sb = STRBUF_INIT;23142315resolve_undo_write(&sb, istate->resolve_undo);2316 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,2317 sb.len) <02318||ce_write(&c, newfd, sb.buf, sb.len) <0;2319strbuf_release(&sb);2320if(err)2321return-1;2322}2323if(!strip_extensions && istate->untracked) {2324struct strbuf sb = STRBUF_INIT;23252326write_untracked_extension(&sb, istate->untracked);2327 err =write_index_ext_header(&c, newfd, CACHE_EXT_UNTRACKED,2328 sb.len) <0||2329ce_write(&c, newfd, sb.buf, sb.len) <0;2330strbuf_release(&sb);2331if(err)2332return-1;2333}2334if(!strip_extensions && istate->fsmonitor_last_update) {2335struct strbuf sb = STRBUF_INIT;23362337write_fsmonitor_extension(&sb, istate);2338 err =write_index_ext_header(&c, newfd, CACHE_EXT_FSMONITOR, sb.len) <02339||ce_write(&c, newfd, sb.buf, sb.len) <0;2340strbuf_release(&sb);2341if(err)2342return-1;2343}23442345if(ce_flush(&c, newfd, istate->sha1))2346return-1;2347if(close_tempfile(tempfile))2348returnerror(_("could not close '%s'"), tempfile->filename.buf);2349if(stat(tempfile->filename.buf, &st))2350return-1;2351 istate->timestamp.sec = (unsigned int)st.st_mtime;2352 istate->timestamp.nsec =ST_MTIME_NSEC(st);2353return0;2354}23552356voidset_alternate_index_output(const char*name)2357{2358 alternate_index_output = name;2359}23602361static intcommit_locked_index(struct lock_file *lk)2362{2363if(alternate_index_output)2364returncommit_lock_file_to(lk, alternate_index_output);2365else2366returncommit_lock_file(lk);2367}23682369static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2370unsigned flags)2371{2372int ret =do_write_index(istate, &lock->tempfile,0);2373if(ret)2374return ret;2375assert((flags & (COMMIT_LOCK | CLOSE_LOCK)) !=2376(COMMIT_LOCK | CLOSE_LOCK));2377if(flags & COMMIT_LOCK)2378returncommit_locked_index(lock);2379else if(flags & CLOSE_LOCK)2380returnclose_lock_file(lock);2381else2382return ret;2383}23842385static intwrite_split_index(struct index_state *istate,2386struct lock_file *lock,2387unsigned flags)2388{2389int ret;2390prepare_to_write_split_index(istate);2391 ret =do_write_locked_index(istate, lock, flags);2392finish_writing_split_index(istate);2393return ret;2394}23952396static const char*shared_index_expire ="2.weeks.ago";23972398static unsigned longget_shared_index_expire_date(void)2399{2400static unsigned long shared_index_expire_date;2401static int shared_index_expire_date_prepared;24022403if(!shared_index_expire_date_prepared) {2404git_config_get_expiry("splitindex.sharedindexexpire",2405&shared_index_expire);2406 shared_index_expire_date =approxidate(shared_index_expire);2407 shared_index_expire_date_prepared =1;2408}24092410return shared_index_expire_date;2411}24122413static intshould_delete_shared_index(const char*shared_index_path)2414{2415struct stat st;2416unsigned long expiration;24172418/* Check timestamp */2419 expiration =get_shared_index_expire_date();2420if(!expiration)2421return0;2422if(stat(shared_index_path, &st))2423returnerror_errno(_("could not stat '%s'"), shared_index_path);2424if(st.st_mtime > expiration)2425return0;24262427return1;2428}24292430static intclean_shared_index_files(const char*current_hex)2431{2432struct dirent *de;2433DIR*dir =opendir(get_git_dir());24342435if(!dir)2436returnerror_errno(_("unable to open git dir:%s"),get_git_dir());24372438while((de =readdir(dir)) != NULL) {2439const char*sha1_hex;2440const char*shared_index_path;2441if(!skip_prefix(de->d_name,"sharedindex.", &sha1_hex))2442continue;2443if(!strcmp(sha1_hex, current_hex))2444continue;2445 shared_index_path =git_path("%s", de->d_name);2446if(should_delete_shared_index(shared_index_path) >0&&2447unlink(shared_index_path))2448warning_errno(_("unable to unlink:%s"), shared_index_path);2449}2450closedir(dir);24512452return0;2453}24542455static struct tempfile temporary_sharedindex;24562457static intwrite_shared_index(struct index_state *istate,2458struct lock_file *lock,unsigned flags)2459{2460struct split_index *si = istate->split_index;2461int fd, ret;24622463 fd =mks_tempfile(&temporary_sharedindex,git_path("sharedindex_XXXXXX"));2464if(fd <0) {2465hashclr(si->base_sha1);2466returndo_write_locked_index(istate, lock, flags);2467}2468move_cache_to_base_index(istate);2469 ret =do_write_index(si->base, &temporary_sharedindex,1);2470if(ret) {2471delete_tempfile(&temporary_sharedindex);2472return ret;2473}2474 ret =adjust_shared_perm(get_tempfile_path(&temporary_sharedindex));2475if(ret) {2476int save_errno = errno;2477error("cannot fix permission bits on%s",get_tempfile_path(&temporary_sharedindex));2478delete_tempfile(&temporary_sharedindex);2479 errno = save_errno;2480return ret;2481}2482 ret =rename_tempfile(&temporary_sharedindex,2483git_path("sharedindex.%s",sha1_to_hex(si->base->sha1)));2484if(!ret) {2485hashcpy(si->base_sha1, si->base->sha1);2486clean_shared_index_files(sha1_to_hex(si->base->sha1));2487}24882489return ret;2490}24912492static const int default_max_percent_split_change =20;24932494static inttoo_many_not_shared_entries(struct index_state *istate)2495{2496int i, not_shared =0;2497int max_split =git_config_get_max_percent_split_change();24982499switch(max_split) {2500case-1:2501/* not or badly configured: use the default value */2502 max_split = default_max_percent_split_change;2503break;2504case0:2505return1;/* 0% means always write a new shared index */2506case100:2507return0;/* 100% means never write a new shared index */2508default:2509break;/* just use the configured value */2510}25112512/* Count not shared entries */2513for(i =0; i < istate->cache_nr; i++) {2514struct cache_entry *ce = istate->cache[i];2515if(!ce->index)2516 not_shared++;2517}25182519return(int64_t)istate->cache_nr * max_split < (int64_t)not_shared *100;2520}25212522intwrite_locked_index(struct index_state *istate,struct lock_file *lock,2523unsigned flags)2524{2525int new_shared_index, ret;2526struct split_index *si = istate->split_index;25272528if(!si || alternate_index_output ||2529(istate->cache_changed & ~EXTMASK)) {2530if(si)2531hashclr(si->base_sha1);2532returndo_write_locked_index(istate, lock, flags);2533}25342535if(getenv("GIT_TEST_SPLIT_INDEX")) {2536int v = si->base_sha1[0];2537if((v &15) <6)2538 istate->cache_changed |= SPLIT_INDEX_ORDERED;2539}2540if(too_many_not_shared_entries(istate))2541 istate->cache_changed |= SPLIT_INDEX_ORDERED;25422543 new_shared_index = istate->cache_changed & SPLIT_INDEX_ORDERED;25442545if(new_shared_index) {2546 ret =write_shared_index(istate, lock, flags);2547if(ret)2548return ret;2549}25502551 ret =write_split_index(istate, lock, flags);25522553/* Freshen the shared index only if the split-index was written */2554if(!ret && !new_shared_index)2555freshen_shared_index(sha1_to_hex(si->base_sha1),1);25562557return ret;2558}25592560/*2561 * Read the index file that is potentially unmerged into given2562 * index_state, dropping any unmerged entries. Returns true if2563 * the index is unmerged. Callers who want to refuse to work2564 * from an unmerged state can call this and check its return value,2565 * instead of calling read_cache().2566 */2567intread_index_unmerged(struct index_state *istate)2568{2569int i;2570int unmerged =0;25712572read_index(istate);2573for(i =0; i < istate->cache_nr; i++) {2574struct cache_entry *ce = istate->cache[i];2575struct cache_entry *new_ce;2576int size, len;25772578if(!ce_stage(ce))2579continue;2580 unmerged =1;2581 len =ce_namelen(ce);2582 size =cache_entry_size(len);2583 new_ce =xcalloc(1, size);2584memcpy(new_ce->name, ce->name, len);2585 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;2586 new_ce->ce_namelen = len;2587 new_ce->ce_mode = ce->ce_mode;2588if(add_index_entry(istate, new_ce,0))2589returnerror("%s: cannot drop to stage #0",2590 new_ce->name);2591}2592return unmerged;2593}25942595/*2596 * Returns 1 if the path is an "other" path with respect to2597 * the index; that is, the path is not mentioned in the index at all,2598 * either as a file, a directory with some files in the index,2599 * or as an unmerged entry.2600 *2601 * We helpfully remove a trailing "/" from directories so that2602 * the output of read_directory can be used as-is.2603 */2604intindex_name_is_other(const struct index_state *istate,const char*name,2605int namelen)2606{2607int pos;2608if(namelen && name[namelen -1] =='/')2609 namelen--;2610 pos =index_name_pos(istate, name, namelen);2611if(0<= pos)2612return0;/* exact match */2613 pos = -pos -1;2614if(pos < istate->cache_nr) {2615struct cache_entry *ce = istate->cache[pos];2616if(ce_namelen(ce) == namelen &&2617!memcmp(ce->name, name, namelen))2618return0;/* Yup, this one exists unmerged */2619}2620return1;2621}26222623void*read_blob_data_from_index(const struct index_state *istate,2624const char*path,unsigned long*size)2625{2626int pos, len;2627unsigned long sz;2628enum object_type type;2629void*data;26302631 len =strlen(path);2632 pos =index_name_pos(istate, path, len);2633if(pos <0) {2634/*2635 * We might be in the middle of a merge, in which2636 * case we would read stage #2 (ours).2637 */2638int i;2639for(i = -pos -1;2640(pos <0&& i < istate->cache_nr &&2641!strcmp(istate->cache[i]->name, path));2642 i++)2643if(ce_stage(istate->cache[i]) ==2)2644 pos = i;2645}2646if(pos <0)2647return NULL;2648 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz);2649if(!data || type != OBJ_BLOB) {2650free(data);2651return NULL;2652}2653if(size)2654*size = sz;2655return data;2656}26572658voidstat_validity_clear(struct stat_validity *sv)2659{2660FREE_AND_NULL(sv->sd);2661}26622663intstat_validity_check(struct stat_validity *sv,const char*path)2664{2665struct stat st;26662667if(stat(path, &st) <0)2668return sv->sd == NULL;2669if(!sv->sd)2670return0;2671returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2672}26732674voidstat_validity_update(struct stat_validity *sv,int fd)2675{2676struct stat st;26772678if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2679stat_validity_clear(sv);2680else{2681if(!sv->sd)2682 sv->sd =xcalloc(1,sizeof(struct stat_data));2683fill_stat_data(sv->sd, &st);2684}2685}26862687voidmove_index_extensions(struct index_state *dst,struct index_state *src)2688{2689 dst->untracked = src->untracked;2690 src->untracked = NULL;2691}