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 49 50/* 51 * This is an estimate of the pathname length in the index. We use 52 * this for V4 index files to guess the un-deltafied size of the index 53 * in memory because of pathname deltafication. This is not required 54 * for V2/V3 index formats because their pathnames are not compressed. 55 * If the initial amount of memory set aside is not sufficient, the 56 * mem pool will allocate extra memory. 57 */ 58#define CACHE_ENTRY_PATH_LENGTH 80 59 60staticinlinestruct cache_entry *mem_pool__ce_alloc(struct mem_pool *mem_pool,size_t len) 61{ 62struct cache_entry *ce; 63 ce =mem_pool_alloc(mem_pool,cache_entry_size(len)); 64 ce->mem_pool_allocated =1; 65return ce; 66} 67 68staticinlinestruct cache_entry *mem_pool__ce_calloc(struct mem_pool *mem_pool,size_t len) 69{ 70struct cache_entry * ce; 71 ce =mem_pool_calloc(mem_pool,1,cache_entry_size(len)); 72 ce->mem_pool_allocated =1; 73return ce; 74} 75 76static struct mem_pool *find_mem_pool(struct index_state *istate) 77{ 78struct mem_pool **pool_ptr; 79 80if(istate->split_index && istate->split_index->base) 81 pool_ptr = &istate->split_index->base->ce_mem_pool; 82else 83 pool_ptr = &istate->ce_mem_pool; 84 85if(!*pool_ptr) 86mem_pool_init(pool_ptr,0); 87 88return*pool_ptr; 89} 90 91struct index_state the_index; 92static const char*alternate_index_output; 93 94static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 95{ 96 istate->cache[nr] = ce; 97add_name_hash(istate, ce); 98} 99 100static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 101{ 102struct cache_entry *old = istate->cache[nr]; 103 104replace_index_entry_in_base(istate, old, ce); 105remove_name_hash(istate, old); 106discard_cache_entry(old); 107 ce->ce_flags &= ~CE_HASHED; 108set_index_entry(istate, nr, ce); 109 ce->ce_flags |= CE_UPDATE_IN_BASE; 110mark_fsmonitor_invalid(istate, ce); 111 istate->cache_changed |= CE_ENTRY_CHANGED; 112} 113 114voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 115{ 116struct cache_entry *old_entry = istate->cache[nr], *new_entry; 117int namelen =strlen(new_name); 118 119 new_entry =make_empty_cache_entry(istate, namelen); 120copy_cache_entry(new_entry, old_entry); 121 new_entry->ce_flags &= ~CE_HASHED; 122 new_entry->ce_namelen = namelen; 123 new_entry->index =0; 124memcpy(new_entry->name, new_name, namelen +1); 125 126cache_tree_invalidate_path(istate, old_entry->name); 127untracked_cache_remove_from_index(istate, old_entry->name); 128remove_index_entry_at(istate, nr); 129add_index_entry(istate, new_entry, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 130} 131 132voidfill_stat_data(struct stat_data *sd,struct stat *st) 133{ 134 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 135 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 136 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 137 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 138 sd->sd_dev = st->st_dev; 139 sd->sd_ino = st->st_ino; 140 sd->sd_uid = st->st_uid; 141 sd->sd_gid = st->st_gid; 142 sd->sd_size = st->st_size; 143} 144 145intmatch_stat_data(const struct stat_data *sd,struct stat *st) 146{ 147int changed =0; 148 149if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 150 changed |= MTIME_CHANGED; 151if(trust_ctime && check_stat && 152 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 153 changed |= CTIME_CHANGED; 154 155#ifdef USE_NSEC 156if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 157 changed |= MTIME_CHANGED; 158if(trust_ctime && check_stat && 159 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 160 changed |= CTIME_CHANGED; 161#endif 162 163if(check_stat) { 164if(sd->sd_uid != (unsigned int) st->st_uid || 165 sd->sd_gid != (unsigned int) st->st_gid) 166 changed |= OWNER_CHANGED; 167if(sd->sd_ino != (unsigned int) st->st_ino) 168 changed |= INODE_CHANGED; 169} 170 171#ifdef USE_STDEV 172/* 173 * st_dev breaks on network filesystems where different 174 * clients will have different views of what "device" 175 * the filesystem is on 176 */ 177if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 178 changed |= INODE_CHANGED; 179#endif 180 181if(sd->sd_size != (unsigned int) st->st_size) 182 changed |= DATA_CHANGED; 183 184return changed; 185} 186 187/* 188 * This only updates the "non-critical" parts of the directory 189 * cache, ie the parts that aren't tracked by GIT, and only used 190 * to validate the cache. 191 */ 192voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 193{ 194fill_stat_data(&ce->ce_stat_data, st); 195 196if(assume_unchanged) 197 ce->ce_flags |= CE_VALID; 198 199if(S_ISREG(st->st_mode)) { 200ce_mark_uptodate(ce); 201mark_fsmonitor_valid(ce); 202} 203} 204 205static intce_compare_data(const struct cache_entry *ce,struct stat *st) 206{ 207int match = -1; 208int fd =git_open_cloexec(ce->name, O_RDONLY); 209 210if(fd >=0) { 211struct object_id oid; 212if(!index_fd(&oid, fd, st, OBJ_BLOB, ce->name,0)) 213 match =oidcmp(&oid, &ce->oid); 214/* index_fd() closed the file descriptor already */ 215} 216return match; 217} 218 219static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 220{ 221int match = -1; 222void*buffer; 223unsigned long size; 224enum object_type type; 225struct strbuf sb = STRBUF_INIT; 226 227if(strbuf_readlink(&sb, ce->name, expected_size)) 228return-1; 229 230 buffer =read_object_file(&ce->oid, &type, &size); 231if(buffer) { 232if(size == sb.len) 233 match =memcmp(buffer, sb.buf, size); 234free(buffer); 235} 236strbuf_release(&sb); 237return match; 238} 239 240static intce_compare_gitlink(const struct cache_entry *ce) 241{ 242struct object_id oid; 243 244/* 245 * We don't actually require that the .git directory 246 * under GITLINK directory be a valid git directory. It 247 * might even be missing (in case nobody populated that 248 * sub-project). 249 * 250 * If so, we consider it always to match. 251 */ 252if(resolve_gitlink_ref(ce->name,"HEAD", &oid) <0) 253return0; 254returnoidcmp(&oid, &ce->oid); 255} 256 257static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 258{ 259switch(st->st_mode & S_IFMT) { 260case S_IFREG: 261if(ce_compare_data(ce, st)) 262return DATA_CHANGED; 263break; 264case S_IFLNK: 265if(ce_compare_link(ce,xsize_t(st->st_size))) 266return DATA_CHANGED; 267break; 268case S_IFDIR: 269if(S_ISGITLINK(ce->ce_mode)) 270returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 271/* else fallthrough */ 272default: 273return TYPE_CHANGED; 274} 275return0; 276} 277 278static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 279{ 280unsigned int changed =0; 281 282if(ce->ce_flags & CE_REMOVE) 283return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 284 285switch(ce->ce_mode & S_IFMT) { 286case S_IFREG: 287 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 288/* We consider only the owner x bit to be relevant for 289 * "mode changes" 290 */ 291if(trust_executable_bit && 292(0100& (ce->ce_mode ^ st->st_mode))) 293 changed |= MODE_CHANGED; 294break; 295case S_IFLNK: 296if(!S_ISLNK(st->st_mode) && 297(has_symlinks || !S_ISREG(st->st_mode))) 298 changed |= TYPE_CHANGED; 299break; 300case S_IFGITLINK: 301/* We ignore most of the st_xxx fields for gitlinks */ 302if(!S_ISDIR(st->st_mode)) 303 changed |= TYPE_CHANGED; 304else if(ce_compare_gitlink(ce)) 305 changed |= DATA_CHANGED; 306return changed; 307default: 308die("internal error: ce_mode is%o", ce->ce_mode); 309} 310 311 changed |=match_stat_data(&ce->ce_stat_data, st); 312 313/* Racily smudged entry? */ 314if(!ce->ce_stat_data.sd_size) { 315if(!is_empty_blob_sha1(ce->oid.hash)) 316 changed |= DATA_CHANGED; 317} 318 319return changed; 320} 321 322static intis_racy_stat(const struct index_state *istate, 323const struct stat_data *sd) 324{ 325return(istate->timestamp.sec && 326#ifdef USE_NSEC 327/* nanosecond timestamped files can also be racy! */ 328(istate->timestamp.sec < sd->sd_mtime.sec || 329(istate->timestamp.sec == sd->sd_mtime.sec && 330 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 331#else 332 istate->timestamp.sec <= sd->sd_mtime.sec 333#endif 334); 335} 336 337static intis_racy_timestamp(const struct index_state *istate, 338const struct cache_entry *ce) 339{ 340return(!S_ISGITLINK(ce->ce_mode) && 341is_racy_stat(istate, &ce->ce_stat_data)); 342} 343 344intmatch_stat_data_racy(const struct index_state *istate, 345const struct stat_data *sd,struct stat *st) 346{ 347if(is_racy_stat(istate, sd)) 348return MTIME_CHANGED; 349returnmatch_stat_data(sd, st); 350} 351 352intie_match_stat(struct index_state *istate, 353const struct cache_entry *ce,struct stat *st, 354unsigned int options) 355{ 356unsigned int changed; 357int ignore_valid = options & CE_MATCH_IGNORE_VALID; 358int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 359int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 360int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR; 361 362if(!ignore_fsmonitor) 363refresh_fsmonitor(istate); 364/* 365 * If it's marked as always valid in the index, it's 366 * valid whatever the checked-out copy says. 367 * 368 * skip-worktree has the same effect with higher precedence 369 */ 370if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 371return0; 372if(!ignore_valid && (ce->ce_flags & CE_VALID)) 373return0; 374if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) 375return0; 376 377/* 378 * Intent-to-add entries have not been added, so the index entry 379 * by definition never matches what is in the work tree until it 380 * actually gets added. 381 */ 382if(ce_intent_to_add(ce)) 383return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 384 385 changed =ce_match_stat_basic(ce, st); 386 387/* 388 * Within 1 second of this sequence: 389 * echo xyzzy >file && git-update-index --add file 390 * running this command: 391 * echo frotz >file 392 * would give a falsely clean cache entry. The mtime and 393 * length match the cache, and other stat fields do not change. 394 * 395 * We could detect this at update-index time (the cache entry 396 * being registered/updated records the same time as "now") 397 * and delay the return from git-update-index, but that would 398 * effectively mean we can make at most one commit per second, 399 * which is not acceptable. Instead, we check cache entries 400 * whose mtime are the same as the index file timestamp more 401 * carefully than others. 402 */ 403if(!changed &&is_racy_timestamp(istate, ce)) { 404if(assume_racy_is_modified) 405 changed |= DATA_CHANGED; 406else 407 changed |=ce_modified_check_fs(ce, st); 408} 409 410return changed; 411} 412 413intie_modified(struct index_state *istate, 414const struct cache_entry *ce, 415struct stat *st,unsigned int options) 416{ 417int changed, changed_fs; 418 419 changed =ie_match_stat(istate, ce, st, options); 420if(!changed) 421return0; 422/* 423 * If the mode or type has changed, there's no point in trying 424 * to refresh the entry - it's not going to match 425 */ 426if(changed & (MODE_CHANGED | TYPE_CHANGED)) 427return changed; 428 429/* 430 * Immediately after read-tree or update-index --cacheinfo, 431 * the length field is zero, as we have never even read the 432 * lstat(2) information once, and we cannot trust DATA_CHANGED 433 * returned by ie_match_stat() which in turn was returned by 434 * ce_match_stat_basic() to signal that the filesize of the 435 * blob changed. We have to actually go to the filesystem to 436 * see if the contents match, and if so, should answer "unchanged". 437 * 438 * The logic does not apply to gitlinks, as ce_match_stat_basic() 439 * already has checked the actual HEAD from the filesystem in the 440 * subproject. If ie_match_stat() already said it is different, 441 * then we know it is. 442 */ 443if((changed & DATA_CHANGED) && 444(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 445return changed; 446 447 changed_fs =ce_modified_check_fs(ce, st); 448if(changed_fs) 449return changed | changed_fs; 450return0; 451} 452 453intbase_name_compare(const char*name1,int len1,int mode1, 454const char*name2,int len2,int mode2) 455{ 456unsigned char c1, c2; 457int len = len1 < len2 ? len1 : len2; 458int cmp; 459 460 cmp =memcmp(name1, name2, len); 461if(cmp) 462return cmp; 463 c1 = name1[len]; 464 c2 = name2[len]; 465if(!c1 &&S_ISDIR(mode1)) 466 c1 ='/'; 467if(!c2 &&S_ISDIR(mode2)) 468 c2 ='/'; 469return(c1 < c2) ? -1: (c1 > c2) ?1:0; 470} 471 472/* 473 * df_name_compare() is identical to base_name_compare(), except it 474 * compares conflicting directory/file entries as equal. Note that 475 * while a directory name compares as equal to a regular file, they 476 * then individually compare _differently_ to a filename that has 477 * a dot after the basename (because '\0' < '.' < '/'). 478 * 479 * This is used by routines that want to traverse the git namespace 480 * but then handle conflicting entries together when possible. 481 */ 482intdf_name_compare(const char*name1,int len1,int mode1, 483const char*name2,int len2,int mode2) 484{ 485int len = len1 < len2 ? len1 : len2, cmp; 486unsigned char c1, c2; 487 488 cmp =memcmp(name1, name2, len); 489if(cmp) 490return cmp; 491/* Directories and files compare equal (same length, same name) */ 492if(len1 == len2) 493return0; 494 c1 = name1[len]; 495if(!c1 &&S_ISDIR(mode1)) 496 c1 ='/'; 497 c2 = name2[len]; 498if(!c2 &&S_ISDIR(mode2)) 499 c2 ='/'; 500if(c1 =='/'&& !c2) 501return0; 502if(c2 =='/'&& !c1) 503return0; 504return c1 - c2; 505} 506 507intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 508{ 509size_t min_len = (len1 < len2) ? len1 : len2; 510int cmp =memcmp(name1, name2, min_len); 511if(cmp) 512return cmp; 513if(len1 < len2) 514return-1; 515if(len1 > len2) 516return1; 517return0; 518} 519 520intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 521{ 522int cmp; 523 524 cmp =name_compare(name1, len1, name2, len2); 525if(cmp) 526return cmp; 527 528if(stage1 < stage2) 529return-1; 530if(stage1 > stage2) 531return1; 532return0; 533} 534 535static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 536{ 537int first, last; 538 539 first =0; 540 last = istate->cache_nr; 541while(last > first) { 542int next = (last + first) >>1; 543struct cache_entry *ce = istate->cache[next]; 544int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 545if(!cmp) 546return next; 547if(cmp <0) { 548 last = next; 549continue; 550} 551 first = next+1; 552} 553return-first-1; 554} 555 556intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 557{ 558returnindex_name_stage_pos(istate, name, namelen,0); 559} 560 561intremove_index_entry_at(struct index_state *istate,int pos) 562{ 563struct cache_entry *ce = istate->cache[pos]; 564 565record_resolve_undo(istate, ce); 566remove_name_hash(istate, ce); 567save_or_free_index_entry(istate, ce); 568 istate->cache_changed |= CE_ENTRY_REMOVED; 569 istate->cache_nr--; 570if(pos >= istate->cache_nr) 571return0; 572MOVE_ARRAY(istate->cache + pos, istate->cache + pos +1, 573 istate->cache_nr - pos); 574return1; 575} 576 577/* 578 * Remove all cache entries marked for removal, that is where 579 * CE_REMOVE is set in ce_flags. This is much more effective than 580 * calling remove_index_entry_at() for each entry to be removed. 581 */ 582voidremove_marked_cache_entries(struct index_state *istate) 583{ 584struct cache_entry **ce_array = istate->cache; 585unsigned int i, j; 586 587for(i = j =0; i < istate->cache_nr; i++) { 588if(ce_array[i]->ce_flags & CE_REMOVE) { 589remove_name_hash(istate, ce_array[i]); 590save_or_free_index_entry(istate, ce_array[i]); 591} 592else 593 ce_array[j++] = ce_array[i]; 594} 595if(j == istate->cache_nr) 596return; 597 istate->cache_changed |= CE_ENTRY_REMOVED; 598 istate->cache_nr = j; 599} 600 601intremove_file_from_index(struct index_state *istate,const char*path) 602{ 603int pos =index_name_pos(istate, path,strlen(path)); 604if(pos <0) 605 pos = -pos-1; 606cache_tree_invalidate_path(istate, path); 607untracked_cache_remove_from_index(istate, path); 608while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 609remove_index_entry_at(istate, pos); 610return0; 611} 612 613static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 614{ 615return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 616} 617 618static intindex_name_pos_also_unmerged(struct index_state *istate, 619const char*path,int namelen) 620{ 621int pos =index_name_pos(istate, path, namelen); 622struct cache_entry *ce; 623 624if(pos >=0) 625return pos; 626 627/* maybe unmerged? */ 628 pos = -1- pos; 629if(pos >= istate->cache_nr || 630compare_name((ce = istate->cache[pos]), path, namelen)) 631return-1; 632 633/* order of preference: stage 2, 1, 3 */ 634if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 635ce_stage((ce = istate->cache[pos +1])) ==2&& 636!compare_name(ce, path, namelen)) 637 pos++; 638return pos; 639} 640 641static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 642{ 643int len =ce_namelen(ce); 644returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 645} 646 647/* 648 * If we add a filename that aliases in the cache, we will use the 649 * name that we already have - but we don't want to update the same 650 * alias twice, because that implies that there were actually two 651 * different files with aliasing names! 652 * 653 * So we use the CE_ADDED flag to verify that the alias was an old 654 * one before we accept it as 655 */ 656static struct cache_entry *create_alias_ce(struct index_state *istate, 657struct cache_entry *ce, 658struct cache_entry *alias) 659{ 660int len; 661struct cache_entry *new_entry; 662 663if(alias->ce_flags & CE_ADDED) 664die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 665 666/* Ok, create the new entry using the name of the existing alias */ 667 len =ce_namelen(alias); 668 new_entry =make_empty_cache_entry(istate, len); 669memcpy(new_entry->name, alias->name, len); 670copy_cache_entry(new_entry, ce); 671save_or_free_index_entry(istate, ce); 672return new_entry; 673} 674 675voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 676{ 677struct object_id oid; 678if(write_object_file("",0, blob_type, &oid)) 679die("cannot create an empty blob in the object database"); 680oidcpy(&ce->oid, &oid); 681} 682 683intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 684{ 685int namelen, was_same; 686 mode_t st_mode = st->st_mode; 687struct cache_entry *ce, *alias = NULL; 688unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 689int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 690int pretend = flags & ADD_CACHE_PRETEND; 691int intent_only = flags & ADD_CACHE_INTENT; 692int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 693(intent_only ? ADD_CACHE_NEW_ONLY :0)); 694int newflags = HASH_WRITE_OBJECT; 695 696if(flags & HASH_RENORMALIZE) 697 newflags |= HASH_RENORMALIZE; 698 699if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 700returnerror("%s: can only add regular files, symbolic links or git-directories", path); 701 702 namelen =strlen(path); 703if(S_ISDIR(st_mode)) { 704while(namelen && path[namelen-1] =='/') 705 namelen--; 706} 707 ce =make_empty_cache_entry(istate, namelen); 708memcpy(ce->name, path, namelen); 709 ce->ce_namelen = namelen; 710if(!intent_only) 711fill_stat_cache_info(ce, st); 712else 713 ce->ce_flags |= CE_INTENT_TO_ADD; 714 715 716if(trust_executable_bit && has_symlinks) { 717 ce->ce_mode =create_ce_mode(st_mode); 718}else{ 719/* If there is an existing entry, pick the mode bits and type 720 * from it, otherwise assume unexecutable regular file. 721 */ 722struct cache_entry *ent; 723int pos =index_name_pos_also_unmerged(istate, path, namelen); 724 725 ent = (0<= pos) ? istate->cache[pos] : NULL; 726 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 727} 728 729/* When core.ignorecase=true, determine if a directory of the same name but differing 730 * case already exists within the Git repository. If it does, ensure the directory 731 * case of the file being added to the repository matches (is folded into) the existing 732 * entry's directory case. 733 */ 734if(ignore_case) { 735adjust_dirname_case(istate, ce->name); 736} 737if(!(flags & HASH_RENORMALIZE)) { 738 alias =index_file_exists(istate, ce->name, 739ce_namelen(ce), ignore_case); 740if(alias && 741!ce_stage(alias) && 742!ie_match_stat(istate, alias, st, ce_option)) { 743/* Nothing changed, really */ 744if(!S_ISGITLINK(alias->ce_mode)) 745ce_mark_uptodate(alias); 746 alias->ce_flags |= CE_ADDED; 747 748discard_cache_entry(ce); 749return0; 750} 751} 752if(!intent_only) { 753if(index_path(&ce->oid, path, st, newflags)) { 754discard_cache_entry(ce); 755returnerror("unable to index file%s", path); 756} 757}else 758set_object_name_for_intent_to_add_entry(ce); 759 760if(ignore_case && alias &&different_name(ce, alias)) 761 ce =create_alias_ce(istate, ce, alias); 762 ce->ce_flags |= CE_ADDED; 763 764/* It was suspected to be racily clean, but it turns out to be Ok */ 765 was_same = (alias && 766!ce_stage(alias) && 767!oidcmp(&alias->oid, &ce->oid) && 768 ce->ce_mode == alias->ce_mode); 769 770if(pretend) 771discard_cache_entry(ce); 772else if(add_index_entry(istate, ce, add_option)) { 773discard_cache_entry(ce); 774returnerror("unable to add%sto index", path); 775} 776if(verbose && !was_same) 777printf("add '%s'\n", path); 778return0; 779} 780 781intadd_file_to_index(struct index_state *istate,const char*path,int flags) 782{ 783struct stat st; 784if(lstat(path, &st)) 785die_errno("unable to stat '%s'", path); 786returnadd_to_index(istate, path, &st, flags); 787} 788 789struct cache_entry *make_empty_cache_entry(struct index_state *istate,size_t len) 790{ 791returnmem_pool__ce_calloc(find_mem_pool(istate), len); 792} 793 794struct cache_entry *make_empty_transient_cache_entry(size_t len) 795{ 796returnxcalloc(1,cache_entry_size(len)); 797} 798 799struct cache_entry *make_cache_entry(struct index_state *istate, 800unsigned int mode, 801const struct object_id *oid, 802const char*path, 803int stage, 804unsigned int refresh_options) 805{ 806struct cache_entry *ce, *ret; 807int len; 808 809if(!verify_path(path, mode)) { 810error("Invalid path '%s'", path); 811return NULL; 812} 813 814 len =strlen(path); 815 ce =make_empty_cache_entry(istate, len); 816 817oidcpy(&ce->oid, oid); 818memcpy(ce->name, path, len); 819 ce->ce_flags =create_ce_flags(stage); 820 ce->ce_namelen = len; 821 ce->ce_mode =create_ce_mode(mode); 822 823 ret =refresh_cache_entry(&the_index, ce, refresh_options); 824if(ret != ce) 825discard_cache_entry(ce); 826return ret; 827} 828 829struct cache_entry *make_transient_cache_entry(unsigned int mode,const struct object_id *oid, 830const char*path,int stage) 831{ 832struct cache_entry *ce; 833int len; 834 835if(!verify_path(path, mode)) { 836error("Invalid path '%s'", path); 837return NULL; 838} 839 840 len =strlen(path); 841 ce =make_empty_transient_cache_entry(len); 842 843oidcpy(&ce->oid, oid); 844memcpy(ce->name, path, len); 845 ce->ce_flags =create_ce_flags(stage); 846 ce->ce_namelen = len; 847 ce->ce_mode =create_ce_mode(mode); 848 849return ce; 850} 851 852/* 853 * Chmod an index entry with either +x or -x. 854 * 855 * Returns -1 if the chmod for the particular cache entry failed (if it's 856 * not a regular file), -2 if an invalid flip argument is passed in, 0 857 * otherwise. 858 */ 859intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 860char flip) 861{ 862if(!S_ISREG(ce->ce_mode)) 863return-1; 864switch(flip) { 865case'+': 866 ce->ce_mode |=0111; 867break; 868case'-': 869 ce->ce_mode &= ~0111; 870break; 871default: 872return-2; 873} 874cache_tree_invalidate_path(istate, ce->name); 875 ce->ce_flags |= CE_UPDATE_IN_BASE; 876mark_fsmonitor_invalid(istate, ce); 877 istate->cache_changed |= CE_ENTRY_CHANGED; 878 879return0; 880} 881 882intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 883{ 884int len =ce_namelen(a); 885returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 886} 887 888/* 889 * We fundamentally don't like some paths: we don't want 890 * dot or dot-dot anywhere, and for obvious reasons don't 891 * want to recurse into ".git" either. 892 * 893 * Also, we don't want double slashes or slashes at the 894 * end that can make pathnames ambiguous. 895 */ 896static intverify_dotfile(const char*rest,unsigned mode) 897{ 898/* 899 * The first character was '.', but that 900 * has already been discarded, we now test 901 * the rest. 902 */ 903 904/* "." is not allowed */ 905if(*rest =='\0'||is_dir_sep(*rest)) 906return0; 907 908switch(*rest) { 909/* 910 * ".git" followed by NUL or slash is bad. Note that we match 911 * case-insensitively here, even if ignore_case is not set. 912 * This outlaws ".GIT" everywhere out of an abundance of caution, 913 * since there's really no good reason to allow it. 914 * 915 * Once we've seen ".git", we can also find ".gitmodules", etc (also 916 * case-insensitively). 917 */ 918case'g': 919case'G': 920if(rest[1] !='i'&& rest[1] !='I') 921break; 922if(rest[2] !='t'&& rest[2] !='T') 923break; 924if(rest[3] =='\0'||is_dir_sep(rest[3])) 925return0; 926if(S_ISLNK(mode)) { 927 rest +=3; 928if(skip_iprefix(rest,"modules", &rest) && 929(*rest =='\0'||is_dir_sep(*rest))) 930return0; 931} 932break; 933case'.': 934if(rest[1] =='\0'||is_dir_sep(rest[1])) 935return0; 936} 937return1; 938} 939 940intverify_path(const char*path,unsigned mode) 941{ 942char c; 943 944if(has_dos_drive_prefix(path)) 945return0; 946 947goto inside; 948for(;;) { 949if(!c) 950return1; 951if(is_dir_sep(c)) { 952inside: 953if(protect_hfs) { 954if(is_hfs_dotgit(path)) 955return0; 956if(S_ISLNK(mode)) { 957if(is_hfs_dotgitmodules(path)) 958return0; 959} 960} 961if(protect_ntfs) { 962if(is_ntfs_dotgit(path)) 963return0; 964if(S_ISLNK(mode)) { 965if(is_ntfs_dotgitmodules(path)) 966return0; 967} 968} 969 970 c = *path++; 971if((c =='.'&& !verify_dotfile(path, mode)) || 972is_dir_sep(c) || c =='\0') 973return0; 974} 975 c = *path++; 976} 977} 978 979/* 980 * Do we have another file that has the beginning components being a 981 * proper superset of the name we're trying to add? 982 */ 983static inthas_file_name(struct index_state *istate, 984const struct cache_entry *ce,int pos,int ok_to_replace) 985{ 986int retval =0; 987int len =ce_namelen(ce); 988int stage =ce_stage(ce); 989const char*name = ce->name; 990 991while(pos < istate->cache_nr) { 992struct cache_entry *p = istate->cache[pos++]; 993 994if(len >=ce_namelen(p)) 995break; 996if(memcmp(name, p->name, len)) 997break; 998if(ce_stage(p) != stage) 999continue;1000if(p->name[len] !='/')1001continue;1002if(p->ce_flags & CE_REMOVE)1003continue;1004 retval = -1;1005if(!ok_to_replace)1006break;1007remove_index_entry_at(istate, --pos);1008}1009return retval;1010}101110121013/*1014 * Like strcmp(), but also return the offset of the first change.1015 * If strings are equal, return the length.1016 */1017intstrcmp_offset(const char*s1,const char*s2,size_t*first_change)1018{1019size_t k;10201021if(!first_change)1022returnstrcmp(s1, s2);10231024for(k =0; s1[k] == s2[k]; k++)1025if(s1[k] =='\0')1026break;10271028*first_change = k;1029return(unsigned char)s1[k] - (unsigned char)s2[k];1030}10311032/*1033 * Do we have another file with a pathname that is a proper1034 * subset of the name we're trying to add?1035 *1036 * That is, is there another file in the index with a path1037 * that matches a sub-directory in the given entry?1038 */1039static inthas_dir_name(struct index_state *istate,1040const struct cache_entry *ce,int pos,int ok_to_replace)1041{1042int retval =0;1043int stage =ce_stage(ce);1044const char*name = ce->name;1045const char*slash = name +ce_namelen(ce);1046size_t len_eq_last;1047int cmp_last =0;10481049/*1050 * We are frequently called during an iteration on a sorted1051 * list of pathnames and while building a new index. Therefore,1052 * there is a high probability that this entry will eventually1053 * be appended to the index, rather than inserted in the middle.1054 * If we can confirm that, we can avoid binary searches on the1055 * components of the pathname.1056 *1057 * Compare the entry's full path with the last path in the index.1058 */1059if(istate->cache_nr >0) {1060 cmp_last =strcmp_offset(name,1061 istate->cache[istate->cache_nr -1]->name,1062&len_eq_last);1063if(cmp_last >0) {1064if(len_eq_last ==0) {1065/*1066 * The entry sorts AFTER the last one in the1067 * index and their paths have no common prefix,1068 * so there cannot be a F/D conflict.1069 */1070return retval;1071}else{1072/*1073 * The entry sorts AFTER the last one in the1074 * index, but has a common prefix. Fall through1075 * to the loop below to disect the entry's path1076 * and see where the difference is.1077 */1078}1079}else if(cmp_last ==0) {1080/*1081 * The entry exactly matches the last one in the1082 * index, but because of multiple stage and CE_REMOVE1083 * items, we fall through and let the regular search1084 * code handle it.1085 */1086}1087}10881089for(;;) {1090size_t len;10911092for(;;) {1093if(*--slash =='/')1094break;1095if(slash <= ce->name)1096return retval;1097}1098 len = slash - name;10991100if(cmp_last >0) {1101/*1102 * (len + 1) is a directory boundary (including1103 * the trailing slash). And since the loop is1104 * decrementing "slash", the first iteration is1105 * the longest directory prefix; subsequent1106 * iterations consider parent directories.1107 */11081109if(len +1<= len_eq_last) {1110/*1111 * The directory prefix (including the trailing1112 * slash) also appears as a prefix in the last1113 * entry, so the remainder cannot collide (because1114 * strcmp said the whole path was greater).1115 *1116 * EQ: last: xxx/A1117 * this: xxx/B1118 *1119 * LT: last: xxx/file_A1120 * this: xxx/file_B1121 */1122return retval;1123}11241125if(len > len_eq_last) {1126/*1127 * This part of the directory prefix (excluding1128 * the trailing slash) is longer than the known1129 * equal portions, so this sub-directory cannot1130 * collide with a file.1131 *1132 * GT: last: xxxA1133 * this: xxxB/file1134 */1135return retval;1136}11371138if(istate->cache_nr >0&&1139ce_namelen(istate->cache[istate->cache_nr -1]) > len) {1140/*1141 * The directory prefix lines up with part of1142 * a longer file or directory name, but sorts1143 * after it, so this sub-directory cannot1144 * collide with a file.1145 *1146 * last: xxx/yy-file (because '-' sorts before '/')1147 * this: xxx/yy/abc1148 */1149return retval;1150}11511152/*1153 * This is a possible collision. Fall through and1154 * let the regular search code handle it.1155 *1156 * last: xxx1157 * this: xxx/file1158 */1159}11601161 pos =index_name_stage_pos(istate, name, len, stage);1162if(pos >=0) {1163/*1164 * Found one, but not so fast. This could1165 * be a marker that says "I was here, but1166 * I am being removed". Such an entry is1167 * not a part of the resulting tree, and1168 * it is Ok to have a directory at the same1169 * path.1170 */1171if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) {1172 retval = -1;1173if(!ok_to_replace)1174break;1175remove_index_entry_at(istate, pos);1176continue;1177}1178}1179else1180 pos = -pos-1;11811182/*1183 * Trivial optimization: if we find an entry that1184 * already matches the sub-directory, then we know1185 * we're ok, and we can exit.1186 */1187while(pos < istate->cache_nr) {1188struct cache_entry *p = istate->cache[pos];1189if((ce_namelen(p) <= len) ||1190(p->name[len] !='/') ||1191memcmp(p->name, name, len))1192break;/* not our subdirectory */1193if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))1194/*1195 * p is at the same stage as our entry, and1196 * is a subdirectory of what we are looking1197 * at, so we cannot have conflicts at our1198 * level or anything shorter.1199 */1200return retval;1201 pos++;1202}1203}1204return retval;1205}12061207/* We may be in a situation where we already have path/file and path1208 * is being added, or we already have path and path/file is being1209 * added. Either one would result in a nonsense tree that has path1210 * twice when git-write-tree tries to write it out. Prevent it.1211 *1212 * If ok-to-replace is specified, we remove the conflicting entries1213 * from the cache so the caller should recompute the insert position.1214 * When this happens, we return non-zero.1215 */1216static intcheck_file_directory_conflict(struct index_state *istate,1217const struct cache_entry *ce,1218int pos,int ok_to_replace)1219{1220int retval;12211222/*1223 * When ce is an "I am going away" entry, we allow it to be added1224 */1225if(ce->ce_flags & CE_REMOVE)1226return0;12271228/*1229 * We check if the path is a sub-path of a subsequent pathname1230 * first, since removing those will not change the position1231 * in the array.1232 */1233 retval =has_file_name(istate, ce, pos, ok_to_replace);12341235/*1236 * Then check if the path might have a clashing sub-directory1237 * before it.1238 */1239return retval +has_dir_name(istate, ce, pos, ok_to_replace);1240}12411242static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1243{1244int pos;1245int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1246int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1247int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1248int new_only = option & ADD_CACHE_NEW_ONLY;12491250if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1251cache_tree_invalidate_path(istate, ce->name);12521253/*1254 * If this entry's path sorts after the last entry in the index,1255 * we can avoid searching for it.1256 */1257if(istate->cache_nr >0&&1258strcmp(ce->name, istate->cache[istate->cache_nr -1]->name) >0)1259 pos = -istate->cache_nr -1;1260else1261 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));12621263/* existing match? Just replace it. */1264if(pos >=0) {1265if(!new_only)1266replace_index_entry(istate, pos, ce);1267return0;1268}1269 pos = -pos-1;12701271if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1272untracked_cache_add_to_index(istate, ce->name);12731274/*1275 * Inserting a merged entry ("stage 0") into the index1276 * will always replace all non-merged entries..1277 */1278if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1279while(ce_same_name(istate->cache[pos], ce)) {1280 ok_to_add =1;1281if(!remove_index_entry_at(istate, pos))1282break;1283}1284}12851286if(!ok_to_add)1287return-1;1288if(!verify_path(ce->name, ce->ce_mode))1289returnerror("Invalid path '%s'", ce->name);12901291if(!skip_df_check &&1292check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1293if(!ok_to_replace)1294returnerror("'%s' appears as both a file and as a directory",1295 ce->name);1296 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1297 pos = -pos-1;1298}1299return pos +1;1300}13011302intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1303{1304int pos;13051306if(option & ADD_CACHE_JUST_APPEND)1307 pos = istate->cache_nr;1308else{1309int ret;1310 ret =add_index_entry_with_check(istate, ce, option);1311if(ret <=0)1312return ret;1313 pos = ret -1;1314}13151316/* Make sure the array is big enough .. */1317ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);13181319/* Add it in.. */1320 istate->cache_nr++;1321if(istate->cache_nr > pos +1)1322MOVE_ARRAY(istate->cache + pos +1, istate->cache + pos,1323 istate->cache_nr - pos -1);1324set_index_entry(istate, pos, ce);1325 istate->cache_changed |= CE_ENTRY_ADDED;1326return0;1327}13281329/*1330 * "refresh" does not calculate a new sha1 file or bring the1331 * cache up-to-date for mode/content changes. But what it1332 * _does_ do is to "re-match" the stat information of a file1333 * with the cache, so that you can refresh the cache for a1334 * file that hasn't been changed but where the stat entry is1335 * out of date.1336 *1337 * For example, you'd want to do this after doing a "git-read-tree",1338 * to link up the stat cache details with the proper files.1339 */1340static struct cache_entry *refresh_cache_ent(struct index_state *istate,1341struct cache_entry *ce,1342unsigned int options,int*err,1343int*changed_ret)1344{1345struct stat st;1346struct cache_entry *updated;1347int changed;1348int refresh = options & CE_MATCH_REFRESH;1349int ignore_valid = options & CE_MATCH_IGNORE_VALID;1350int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1351int ignore_missing = options & CE_MATCH_IGNORE_MISSING;1352int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR;13531354if(!refresh ||ce_uptodate(ce))1355return ce;13561357if(!ignore_fsmonitor)1358refresh_fsmonitor(istate);1359/*1360 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1361 * that the change to the work tree does not matter and told1362 * us not to worry.1363 */1364if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1365ce_mark_uptodate(ce);1366return ce;1367}1368if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1369ce_mark_uptodate(ce);1370return ce;1371}1372if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) {1373ce_mark_uptodate(ce);1374return ce;1375}13761377if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1378if(ignore_missing)1379return ce;1380if(err)1381*err = ENOENT;1382return NULL;1383}13841385if(lstat(ce->name, &st) <0) {1386if(ignore_missing && errno == ENOENT)1387return ce;1388if(err)1389*err = errno;1390return NULL;1391}13921393 changed =ie_match_stat(istate, ce, &st, options);1394if(changed_ret)1395*changed_ret = changed;1396if(!changed) {1397/*1398 * The path is unchanged. If we were told to ignore1399 * valid bit, then we did the actual stat check and1400 * found that the entry is unmodified. If the entry1401 * is not marked VALID, this is the place to mark it1402 * valid again, under "assume unchanged" mode.1403 */1404if(ignore_valid && assume_unchanged &&1405!(ce->ce_flags & CE_VALID))1406;/* mark this one VALID again */1407else{1408/*1409 * We do not mark the index itself "modified"1410 * because CE_UPTODATE flag is in-core only;1411 * we are not going to write this change out.1412 */1413if(!S_ISGITLINK(ce->ce_mode)) {1414ce_mark_uptodate(ce);1415mark_fsmonitor_valid(ce);1416}1417return ce;1418}1419}14201421if(ie_modified(istate, ce, &st, options)) {1422if(err)1423*err = EINVAL;1424return NULL;1425}14261427 updated =make_empty_cache_entry(istate,ce_namelen(ce));1428copy_cache_entry(updated, ce);1429memcpy(updated->name, ce->name, ce->ce_namelen +1);1430fill_stat_cache_info(updated, &st);1431/*1432 * If ignore_valid is not set, we should leave CE_VALID bit1433 * alone. Otherwise, paths marked with --no-assume-unchanged1434 * (i.e. things to be edited) will reacquire CE_VALID bit1435 * automatically, which is not really what we want.1436 */1437if(!ignore_valid && assume_unchanged &&1438!(ce->ce_flags & CE_VALID))1439 updated->ce_flags &= ~CE_VALID;14401441/* istate->cache_changed is updated in the caller */1442return updated;1443}14441445static voidshow_file(const char* fmt,const char* name,int in_porcelain,1446int* first,const char*header_msg)1447{1448if(in_porcelain && *first && header_msg) {1449printf("%s\n", header_msg);1450*first =0;1451}1452printf(fmt, name);1453}14541455intrefresh_index(struct index_state *istate,unsigned int flags,1456const struct pathspec *pathspec,1457char*seen,const char*header_msg)1458{1459int i;1460int has_errors =0;1461int really = (flags & REFRESH_REALLY) !=0;1462int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1463int quiet = (flags & REFRESH_QUIET) !=0;1464int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1465int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1466int first =1;1467int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1468unsigned int options = (CE_MATCH_REFRESH |1469(really ? CE_MATCH_IGNORE_VALID :0) |1470(not_new ? CE_MATCH_IGNORE_MISSING :0));1471const char*modified_fmt;1472const char*deleted_fmt;1473const char*typechange_fmt;1474const char*added_fmt;1475const char*unmerged_fmt;1476uint64_t start =getnanotime();14771478 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1479 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1480 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1481 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1482 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1483for(i =0; i < istate->cache_nr; i++) {1484struct cache_entry *ce, *new_entry;1485int cache_errno =0;1486int changed =0;1487int filtered =0;14881489 ce = istate->cache[i];1490if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1491continue;14921493if(pathspec && !ce_path_match(ce, pathspec, seen))1494 filtered =1;14951496if(ce_stage(ce)) {1497while((i < istate->cache_nr) &&1498!strcmp(istate->cache[i]->name, ce->name))1499 i++;1500 i--;1501if(allow_unmerged)1502continue;1503if(!filtered)1504show_file(unmerged_fmt, ce->name, in_porcelain,1505&first, header_msg);1506 has_errors =1;1507continue;1508}15091510if(filtered)1511continue;15121513 new_entry =refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1514if(new_entry == ce)1515continue;1516if(!new_entry) {1517const char*fmt;15181519if(really && cache_errno == EINVAL) {1520/* If we are doing --really-refresh that1521 * means the index is not valid anymore.1522 */1523 ce->ce_flags &= ~CE_VALID;1524 ce->ce_flags |= CE_UPDATE_IN_BASE;1525mark_fsmonitor_invalid(istate, ce);1526 istate->cache_changed |= CE_ENTRY_CHANGED;1527}1528if(quiet)1529continue;15301531if(cache_errno == ENOENT)1532 fmt = deleted_fmt;1533else if(ce_intent_to_add(ce))1534 fmt = added_fmt;/* must be before other checks */1535else if(changed & TYPE_CHANGED)1536 fmt = typechange_fmt;1537else1538 fmt = modified_fmt;1539show_file(fmt,1540 ce->name, in_porcelain, &first, header_msg);1541 has_errors =1;1542continue;1543}15441545replace_index_entry(istate, i, new_entry);1546}1547trace_performance_since(start,"refresh index");1548return has_errors;1549}15501551struct cache_entry *refresh_cache_entry(struct index_state *istate,1552struct cache_entry *ce,1553unsigned int options)1554{1555returnrefresh_cache_ent(istate, ce, options, NULL, NULL);1556}155715581559/*****************************************************************1560 * Index File I/O1561 *****************************************************************/15621563#define INDEX_FORMAT_DEFAULT 315641565static unsigned intget_index_format_default(void)1566{1567char*envversion =getenv("GIT_INDEX_VERSION");1568char*endp;1569int value;1570unsigned int version = INDEX_FORMAT_DEFAULT;15711572if(!envversion) {1573if(!git_config_get_int("index.version", &value))1574 version = value;1575if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1576warning(_("index.version set, but the value is invalid.\n"1577"Using version%i"), INDEX_FORMAT_DEFAULT);1578return INDEX_FORMAT_DEFAULT;1579}1580return version;1581}15821583 version =strtoul(envversion, &endp,10);1584if(*endp ||1585 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1586warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1587"Using version%i"), INDEX_FORMAT_DEFAULT);1588 version = INDEX_FORMAT_DEFAULT;1589}1590return version;1591}15921593/*1594 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1595 * Again - this is just a (very strong in practice) heuristic that1596 * the inode hasn't changed.1597 *1598 * We save the fields in big-endian order to allow using the1599 * index file over NFS transparently.1600 */1601struct ondisk_cache_entry {1602struct cache_time ctime;1603struct cache_time mtime;1604uint32_t dev;1605uint32_t ino;1606uint32_t mode;1607uint32_t uid;1608uint32_t gid;1609uint32_t size;1610unsigned char sha1[20];1611uint16_t flags;1612char name[FLEX_ARRAY];/* more */1613};16141615/*1616 * This struct is used when CE_EXTENDED bit is 11617 * The struct must match ondisk_cache_entry exactly from1618 * ctime till flags1619 */1620struct ondisk_cache_entry_extended {1621struct cache_time ctime;1622struct cache_time mtime;1623uint32_t dev;1624uint32_t ino;1625uint32_t mode;1626uint32_t uid;1627uint32_t gid;1628uint32_t size;1629unsigned char sha1[20];1630uint16_t flags;1631uint16_t flags2;1632char name[FLEX_ARRAY];/* more */1633};16341635/* These are only used for v3 or lower */1636#define align_padding_size(size, len) ((size + (len) + 8) & ~7) - (size + len)1637#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1638#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1639#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1640#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1641 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1642 ondisk_cache_entry_size(ce_namelen(ce)))16431644/* Allow fsck to force verification of the index checksum. */1645int verify_index_checksum;16461647/* Allow fsck to force verification of the cache entry order. */1648int verify_ce_order;16491650static intverify_hdr(struct cache_header *hdr,unsigned long size)1651{1652 git_hash_ctx c;1653unsigned char hash[GIT_MAX_RAWSZ];1654int hdr_version;16551656if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1657returnerror("bad signature");1658 hdr_version =ntohl(hdr->hdr_version);1659if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1660returnerror("bad index version%d", hdr_version);16611662if(!verify_index_checksum)1663return0;16641665 the_hash_algo->init_fn(&c);1666 the_hash_algo->update_fn(&c, hdr, size - the_hash_algo->rawsz);1667 the_hash_algo->final_fn(hash, &c);1668if(hashcmp(hash, (unsigned char*)hdr + size - the_hash_algo->rawsz))1669returnerror("bad index file sha1 signature");1670return0;1671}16721673static intread_index_extension(struct index_state *istate,1674const char*ext,void*data,unsigned long sz)1675{1676switch(CACHE_EXT(ext)) {1677case CACHE_EXT_TREE:1678 istate->cache_tree =cache_tree_read(data, sz);1679break;1680case CACHE_EXT_RESOLVE_UNDO:1681 istate->resolve_undo =resolve_undo_read(data, sz);1682break;1683case CACHE_EXT_LINK:1684if(read_link_extension(istate, data, sz))1685return-1;1686break;1687case CACHE_EXT_UNTRACKED:1688 istate->untracked =read_untracked_extension(data, sz);1689break;1690case CACHE_EXT_FSMONITOR:1691read_fsmonitor_extension(istate, data, sz);1692break;1693default:1694if(*ext <'A'||'Z'< *ext)1695returnerror("index uses %.4s extension, which we do not understand",1696 ext);1697fprintf(stderr,"ignoring %.4s extension\n", ext);1698break;1699}1700return0;1701}17021703inthold_locked_index(struct lock_file *lk,int lock_flags)1704{1705returnhold_lock_file_for_update(lk,get_index_file(), lock_flags);1706}17071708intread_index(struct index_state *istate)1709{1710returnread_index_from(istate,get_index_file(),get_git_dir());1711}17121713static struct cache_entry *cache_entry_from_ondisk(struct mem_pool *mem_pool,1714struct ondisk_cache_entry *ondisk,1715unsigned int flags,1716const char*name,1717size_t len)1718{1719struct cache_entry *ce =mem_pool__ce_alloc(mem_pool, len);17201721 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1722 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1723 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1724 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1725 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1726 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1727 ce->ce_mode =get_be32(&ondisk->mode);1728 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1729 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1730 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1731 ce->ce_flags = flags & ~CE_NAMEMASK;1732 ce->ce_namelen = len;1733 ce->index =0;1734hashcpy(ce->oid.hash, ondisk->sha1);1735memcpy(ce->name, name, len);1736 ce->name[len] ='\0';1737return ce;1738}17391740/*1741 * Adjacent cache entries tend to share the leading paths, so it makes1742 * sense to only store the differences in later entries. In the v41743 * on-disk format of the index, each on-disk cache entry stores the1744 * number of bytes to be stripped from the end of the previous name,1745 * and the bytes to append to the result, to come up with its name.1746 */1747static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1748{1749const unsigned char*ep, *cp = (const unsigned char*)cp_;1750size_t len =decode_varint(&cp);17511752if(name->len < len)1753die("malformed name field in the index");1754strbuf_remove(name, name->len - len, len);1755for(ep = cp; *ep; ep++)1756;/* find the end */1757strbuf_add(name, cp, ep - cp);1758return(const char*)ep +1- cp_;1759}17601761static struct cache_entry *create_from_disk(struct mem_pool *mem_pool,1762struct ondisk_cache_entry *ondisk,1763unsigned long*ent_size,1764struct strbuf *previous_name)1765{1766struct cache_entry *ce;1767size_t len;1768const char*name;1769unsigned int flags;17701771/* On-disk flags are just 16 bits */1772 flags =get_be16(&ondisk->flags);1773 len = flags & CE_NAMEMASK;17741775if(flags & CE_EXTENDED) {1776struct ondisk_cache_entry_extended *ondisk2;1777int extended_flags;1778 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1779 extended_flags =get_be16(&ondisk2->flags2) <<16;1780/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1781if(extended_flags & ~CE_EXTENDED_FLAGS)1782die("Unknown index entry format%08x", extended_flags);1783 flags |= extended_flags;1784 name = ondisk2->name;1785}1786else1787 name = ondisk->name;17881789if(!previous_name) {1790/* v3 and earlier */1791if(len == CE_NAMEMASK)1792 len =strlen(name);1793 ce =cache_entry_from_ondisk(mem_pool, ondisk, flags, name, len);17941795*ent_size =ondisk_ce_size(ce);1796}else{1797unsigned long consumed;1798 consumed =expand_name_field(previous_name, name);1799 ce =cache_entry_from_ondisk(mem_pool, ondisk, flags,1800 previous_name->buf,1801 previous_name->len);18021803*ent_size = (name - ((char*)ondisk)) + consumed;1804}1805return ce;1806}18071808static voidcheck_ce_order(struct index_state *istate)1809{1810unsigned int i;18111812if(!verify_ce_order)1813return;18141815for(i =1; i < istate->cache_nr; i++) {1816struct cache_entry *ce = istate->cache[i -1];1817struct cache_entry *next_ce = istate->cache[i];1818int name_compare =strcmp(ce->name, next_ce->name);18191820if(0< name_compare)1821die("unordered stage entries in index");1822if(!name_compare) {1823if(!ce_stage(ce))1824die("multiple stage entries for merged file '%s'",1825 ce->name);1826if(ce_stage(ce) >ce_stage(next_ce))1827die("unordered stage entries for '%s'",1828 ce->name);1829}1830}1831}18321833static voidtweak_untracked_cache(struct index_state *istate)1834{1835switch(git_config_get_untracked_cache()) {1836case-1:/* keep: do nothing */1837break;1838case0:/* false */1839remove_untracked_cache(istate);1840break;1841case1:/* true */1842add_untracked_cache(istate);1843break;1844default:/* unknown value: do nothing */1845break;1846}1847}18481849static voidtweak_split_index(struct index_state *istate)1850{1851switch(git_config_get_split_index()) {1852case-1:/* unset: do nothing */1853break;1854case0:/* false */1855remove_split_index(istate);1856break;1857case1:/* true */1858add_split_index(istate);1859break;1860default:/* unknown value: do nothing */1861break;1862}1863}18641865static voidpost_read_index_from(struct index_state *istate)1866{1867check_ce_order(istate);1868tweak_untracked_cache(istate);1869tweak_split_index(istate);1870tweak_fsmonitor(istate);1871}18721873static size_testimate_cache_size_from_compressed(unsigned int entries)1874{1875return entries * (sizeof(struct cache_entry) + CACHE_ENTRY_PATH_LENGTH);1876}18771878static size_testimate_cache_size(size_t ondisk_size,unsigned int entries)1879{1880long per_entry =sizeof(struct cache_entry) -sizeof(struct ondisk_cache_entry);18811882/*1883 * Account for potential alignment differences.1884 */1885 per_entry +=align_padding_size(sizeof(struct cache_entry), -sizeof(struct ondisk_cache_entry));1886return ondisk_size + entries * per_entry;1887}18881889/* remember to discard_cache() before reading a different cache! */1890intdo_read_index(struct index_state *istate,const char*path,int must_exist)1891{1892int fd, i;1893struct stat st;1894unsigned long src_offset;1895struct cache_header *hdr;1896void*mmap;1897size_t mmap_size;1898struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;18991900if(istate->initialized)1901return istate->cache_nr;19021903 istate->timestamp.sec =0;1904 istate->timestamp.nsec =0;1905 fd =open(path, O_RDONLY);1906if(fd <0) {1907if(!must_exist && errno == ENOENT)1908return0;1909die_errno("%s: index file open failed", path);1910}19111912if(fstat(fd, &st))1913die_errno("cannot stat the open index");19141915 mmap_size =xsize_t(st.st_size);1916if(mmap_size <sizeof(struct cache_header) + the_hash_algo->rawsz)1917die("index file smaller than expected");19181919 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);1920if(mmap == MAP_FAILED)1921die_errno("unable to map index file");1922close(fd);19231924 hdr = mmap;1925if(verify_hdr(hdr, mmap_size) <0)1926goto unmap;19271928hashcpy(istate->oid.hash, (const unsigned char*)hdr + mmap_size - the_hash_algo->rawsz);1929 istate->version =ntohl(hdr->hdr_version);1930 istate->cache_nr =ntohl(hdr->hdr_entries);1931 istate->cache_alloc =alloc_nr(istate->cache_nr);1932 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1933 istate->initialized =1;19341935if(istate->version ==4) {1936 previous_name = &previous_name_buf;1937mem_pool_init(&istate->ce_mem_pool,1938estimate_cache_size_from_compressed(istate->cache_nr));1939}else{1940 previous_name = NULL;1941mem_pool_init(&istate->ce_mem_pool,1942estimate_cache_size(mmap_size, istate->cache_nr));1943}19441945 src_offset =sizeof(*hdr);1946for(i =0; i < istate->cache_nr; i++) {1947struct ondisk_cache_entry *disk_ce;1948struct cache_entry *ce;1949unsigned long consumed;19501951 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1952 ce =create_from_disk(istate->ce_mem_pool, disk_ce, &consumed, previous_name);1953set_index_entry(istate, i, ce);19541955 src_offset += consumed;1956}1957strbuf_release(&previous_name_buf);1958 istate->timestamp.sec = st.st_mtime;1959 istate->timestamp.nsec =ST_MTIME_NSEC(st);19601961while(src_offset <= mmap_size - the_hash_algo->rawsz -8) {1962/* After an array of active_nr index entries,1963 * there can be arbitrary number of extended1964 * sections, each of which is prefixed with1965 * extension name (4-byte) and section length1966 * in 4-byte network byte order.1967 */1968uint32_t extsize;1969memcpy(&extsize, (char*)mmap + src_offset +4,4);1970 extsize =ntohl(extsize);1971if(read_index_extension(istate,1972(const char*) mmap + src_offset,1973(char*) mmap + src_offset +8,1974 extsize) <0)1975goto unmap;1976 src_offset +=8;1977 src_offset += extsize;1978}1979munmap(mmap, mmap_size);1980return istate->cache_nr;19811982unmap:1983munmap(mmap, mmap_size);1984die("index file corrupt");1985}19861987/*1988 * Signal that the shared index is used by updating its mtime.1989 *1990 * This way, shared index can be removed if they have not been used1991 * for some time.1992 */1993static voidfreshen_shared_index(const char*shared_index,int warn)1994{1995if(!check_and_freshen_file(shared_index,1) && warn)1996warning("could not freshen shared index '%s'", shared_index);1997}19981999intread_index_from(struct index_state *istate,const char*path,2000const char*gitdir)2001{2002uint64_t start =getnanotime();2003struct split_index *split_index;2004int ret;2005char*base_oid_hex;2006char*base_path;20072008/* istate->initialized covers both .git/index and .git/sharedindex.xxx */2009if(istate->initialized)2010return istate->cache_nr;20112012 ret =do_read_index(istate, path,0);2013trace_performance_since(start,"read cache%s", path);20142015 split_index = istate->split_index;2016if(!split_index ||is_null_oid(&split_index->base_oid)) {2017post_read_index_from(istate);2018return ret;2019}20202021if(split_index->base)2022discard_index(split_index->base);2023else2024 split_index->base =xcalloc(1,sizeof(*split_index->base));20252026 base_oid_hex =oid_to_hex(&split_index->base_oid);2027 base_path =xstrfmt("%s/sharedindex.%s", gitdir, base_oid_hex);2028 ret =do_read_index(split_index->base, base_path,1);2029if(oidcmp(&split_index->base_oid, &split_index->base->oid))2030die("broken index, expect%sin%s, got%s",2031 base_oid_hex, base_path,2032oid_to_hex(&split_index->base->oid));20332034freshen_shared_index(base_path,0);2035merge_base_index(istate);2036post_read_index_from(istate);2037trace_performance_since(start,"read cache%s", base_path);2038free(base_path);2039return ret;2040}20412042intis_index_unborn(struct index_state *istate)2043{2044return(!istate->cache_nr && !istate->timestamp.sec);2045}20462047intdiscard_index(struct index_state *istate)2048{2049/*2050 * Cache entries in istate->cache[] should have been allocated2051 * from the memory pool associated with this index, or from an2052 * associated split_index. There is no need to free individual2053 * cache entries.2054 */20552056resolve_undo_clear_index(istate);2057 istate->cache_nr =0;2058 istate->cache_changed =0;2059 istate->timestamp.sec =0;2060 istate->timestamp.nsec =0;2061free_name_hash(istate);2062cache_tree_free(&(istate->cache_tree));2063 istate->initialized =0;2064FREE_AND_NULL(istate->cache);2065 istate->cache_alloc =0;2066discard_split_index(istate);2067free_untracked_cache(istate->untracked);2068 istate->untracked = NULL;20692070if(istate->ce_mem_pool) {2071mem_pool_discard(istate->ce_mem_pool);2072 istate->ce_mem_pool = NULL;2073}20742075return0;2076}20772078intunmerged_index(const struct index_state *istate)2079{2080int i;2081for(i =0; i < istate->cache_nr; i++) {2082if(ce_stage(istate->cache[i]))2083return1;2084}2085return0;2086}20872088#define WRITE_BUFFER_SIZE 81922089static unsigned char write_buffer[WRITE_BUFFER_SIZE];2090static unsigned long write_buffer_len;20912092static intce_write_flush(git_hash_ctx *context,int fd)2093{2094unsigned int buffered = write_buffer_len;2095if(buffered) {2096 the_hash_algo->update_fn(context, write_buffer, buffered);2097if(write_in_full(fd, write_buffer, buffered) <0)2098return-1;2099 write_buffer_len =0;2100}2101return0;2102}21032104static intce_write(git_hash_ctx *context,int fd,void*data,unsigned int len)2105{2106while(len) {2107unsigned int buffered = write_buffer_len;2108unsigned int partial = WRITE_BUFFER_SIZE - buffered;2109if(partial > len)2110 partial = len;2111memcpy(write_buffer + buffered, data, partial);2112 buffered += partial;2113if(buffered == WRITE_BUFFER_SIZE) {2114 write_buffer_len = buffered;2115if(ce_write_flush(context, fd))2116return-1;2117 buffered =0;2118}2119 write_buffer_len = buffered;2120 len -= partial;2121 data = (char*) data + partial;2122}2123return0;2124}21252126static intwrite_index_ext_header(git_hash_ctx *context,int fd,2127unsigned int ext,unsigned int sz)2128{2129 ext =htonl(ext);2130 sz =htonl(sz);2131return((ce_write(context, fd, &ext,4) <0) ||2132(ce_write(context, fd, &sz,4) <0)) ? -1:0;2133}21342135static intce_flush(git_hash_ctx *context,int fd,unsigned char*hash)2136{2137unsigned int left = write_buffer_len;21382139if(left) {2140 write_buffer_len =0;2141 the_hash_algo->update_fn(context, write_buffer, left);2142}21432144/* Flush first if not enough space for hash signature */2145if(left + the_hash_algo->rawsz > WRITE_BUFFER_SIZE) {2146if(write_in_full(fd, write_buffer, left) <0)2147return-1;2148 left =0;2149}21502151/* Append the hash signature at the end */2152 the_hash_algo->final_fn(write_buffer + left, context);2153hashcpy(hash, write_buffer + left);2154 left += the_hash_algo->rawsz;2155return(write_in_full(fd, write_buffer, left) <0) ? -1:0;2156}21572158static voidce_smudge_racily_clean_entry(struct cache_entry *ce)2159{2160/*2161 * The only thing we care about in this function is to smudge the2162 * falsely clean entry due to touch-update-touch race, so we leave2163 * everything else as they are. We are called for entries whose2164 * ce_stat_data.sd_mtime match the index file mtime.2165 *2166 * Note that this actually does not do much for gitlinks, for2167 * which ce_match_stat_basic() always goes to the actual2168 * contents. The caller checks with is_racy_timestamp() which2169 * always says "no" for gitlinks, so we are not called for them ;-)2170 */2171struct stat st;21722173if(lstat(ce->name, &st) <0)2174return;2175if(ce_match_stat_basic(ce, &st))2176return;2177if(ce_modified_check_fs(ce, &st)) {2178/* This is "racily clean"; smudge it. Note that this2179 * is a tricky code. At first glance, it may appear2180 * that it can break with this sequence:2181 *2182 * $ echo xyzzy >frotz2183 * $ git-update-index --add frotz2184 * $ : >frotz2185 * $ sleep 32186 * $ echo filfre >nitfol2187 * $ git-update-index --add nitfol2188 *2189 * but it does not. When the second update-index runs,2190 * it notices that the entry "frotz" has the same timestamp2191 * as index, and if we were to smudge it by resetting its2192 * size to zero here, then the object name recorded2193 * in index is the 6-byte file but the cached stat information2194 * becomes zero --- which would then match what we would2195 * obtain from the filesystem next time we stat("frotz").2196 *2197 * However, the second update-index, before calling2198 * this function, notices that the cached size is 62199 * bytes and what is on the filesystem is an empty2200 * file, and never calls us, so the cached size information2201 * for "frotz" stays 6 which does not match the filesystem.2202 */2203 ce->ce_stat_data.sd_size =0;2204}2205}22062207/* Copy miscellaneous fields but not the name */2208static voidcopy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,2209struct cache_entry *ce)2210{2211short flags;22122213 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);2214 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);2215 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);2216 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);2217 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);2218 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);2219 ondisk->mode =htonl(ce->ce_mode);2220 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);2221 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);2222 ondisk->size =htonl(ce->ce_stat_data.sd_size);2223hashcpy(ondisk->sha1, ce->oid.hash);22242225 flags = ce->ce_flags & ~CE_NAMEMASK;2226 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));2227 ondisk->flags =htons(flags);2228if(ce->ce_flags & CE_EXTENDED) {2229struct ondisk_cache_entry_extended *ondisk2;2230 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;2231 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);2232}2233}22342235static intce_write_entry(git_hash_ctx *c,int fd,struct cache_entry *ce,2236struct strbuf *previous_name,struct ondisk_cache_entry *ondisk)2237{2238int size;2239int result;2240unsigned int saved_namelen;2241int stripped_name =0;2242static unsigned char padding[8] = {0x00};22432244if(ce->ce_flags & CE_STRIP_NAME) {2245 saved_namelen =ce_namelen(ce);2246 ce->ce_namelen =0;2247 stripped_name =1;2248}22492250if(ce->ce_flags & CE_EXTENDED)2251 size =offsetof(struct ondisk_cache_entry_extended, name);2252else2253 size =offsetof(struct ondisk_cache_entry, name);22542255if(!previous_name) {2256int len =ce_namelen(ce);2257copy_cache_entry_to_ondisk(ondisk, ce);2258 result =ce_write(c, fd, ondisk, size);2259if(!result)2260 result =ce_write(c, fd, ce->name, len);2261if(!result)2262 result =ce_write(c, fd, padding,align_padding_size(size, len));2263}else{2264int common, to_remove, prefix_size;2265unsigned char to_remove_vi[16];2266for(common =0;2267(ce->name[common] &&2268 common < previous_name->len &&2269 ce->name[common] == previous_name->buf[common]);2270 common++)2271;/* still matching */2272 to_remove = previous_name->len - common;2273 prefix_size =encode_varint(to_remove, to_remove_vi);22742275copy_cache_entry_to_ondisk(ondisk, ce);2276 result =ce_write(c, fd, ondisk, size);2277if(!result)2278 result =ce_write(c, fd, to_remove_vi, prefix_size);2279if(!result)2280 result =ce_write(c, fd, ce->name + common,ce_namelen(ce) - common);2281if(!result)2282 result =ce_write(c, fd, padding,1);22832284strbuf_splice(previous_name, common, to_remove,2285 ce->name + common,ce_namelen(ce) - common);2286}2287if(stripped_name) {2288 ce->ce_namelen = saved_namelen;2289 ce->ce_flags &= ~CE_STRIP_NAME;2290}22912292return result;2293}22942295/*2296 * This function verifies if index_state has the correct sha1 of the2297 * index file. Don't die if we have any other failure, just return 0.2298 */2299static intverify_index_from(const struct index_state *istate,const char*path)2300{2301int fd;2302 ssize_t n;2303struct stat st;2304unsigned char hash[GIT_MAX_RAWSZ];23052306if(!istate->initialized)2307return0;23082309 fd =open(path, O_RDONLY);2310if(fd <0)2311return0;23122313if(fstat(fd, &st))2314goto out;23152316if(st.st_size <sizeof(struct cache_header) + the_hash_algo->rawsz)2317goto out;23182319 n =pread_in_full(fd, hash, the_hash_algo->rawsz, st.st_size - the_hash_algo->rawsz);2320if(n != the_hash_algo->rawsz)2321goto out;23222323if(hashcmp(istate->oid.hash, hash))2324goto out;23252326close(fd);2327return1;23282329out:2330close(fd);2331return0;2332}23332334static intverify_index(const struct index_state *istate)2335{2336returnverify_index_from(istate,get_index_file());2337}23382339static inthas_racy_timestamp(struct index_state *istate)2340{2341int entries = istate->cache_nr;2342int i;23432344for(i =0; i < entries; i++) {2345struct cache_entry *ce = istate->cache[i];2346if(is_racy_timestamp(istate, ce))2347return1;2348}2349return0;2350}23512352voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2353{2354if((istate->cache_changed ||has_racy_timestamp(istate)) &&2355verify_index(istate))2356write_locked_index(istate, lockfile, COMMIT_LOCK);2357else2358rollback_lock_file(lockfile);2359}23602361/*2362 * On success, `tempfile` is closed. If it is the temporary file2363 * of a `struct lock_file`, we will therefore effectively perform2364 * a 'close_lock_file_gently()`. Since that is an implementation2365 * detail of lockfiles, callers of `do_write_index()` should not2366 * rely on it.2367 */2368static intdo_write_index(struct index_state *istate,struct tempfile *tempfile,2369int strip_extensions)2370{2371uint64_t start =getnanotime();2372int newfd = tempfile->fd;2373 git_hash_ctx c;2374struct cache_header hdr;2375int i, err =0, removed, extended, hdr_version;2376struct cache_entry **cache = istate->cache;2377int entries = istate->cache_nr;2378struct stat st;2379struct ondisk_cache_entry_extended ondisk;2380struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;2381int drop_cache_tree = istate->drop_cache_tree;23822383for(i = removed = extended =0; i < entries; i++) {2384if(cache[i]->ce_flags & CE_REMOVE)2385 removed++;23862387/* reduce extended entries if possible */2388 cache[i]->ce_flags &= ~CE_EXTENDED;2389if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2390 extended++;2391 cache[i]->ce_flags |= CE_EXTENDED;2392}2393}23942395if(!istate->version) {2396 istate->version =get_index_format_default();2397if(git_env_bool("GIT_TEST_SPLIT_INDEX",0))2398init_split_index(istate);2399}24002401/* demote version 3 to version 2 when the latter suffices */2402if(istate->version ==3|| istate->version ==2)2403 istate->version = extended ?3:2;24042405 hdr_version = istate->version;24062407 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2408 hdr.hdr_version =htonl(hdr_version);2409 hdr.hdr_entries =htonl(entries - removed);24102411 the_hash_algo->init_fn(&c);2412if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2413return-1;24142415 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;24162417for(i =0; i < entries; i++) {2418struct cache_entry *ce = cache[i];2419if(ce->ce_flags & CE_REMOVE)2420continue;2421if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2422ce_smudge_racily_clean_entry(ce);2423if(is_null_oid(&ce->oid)) {2424static const char msg[] ="cache entry has null sha1:%s";2425static int allow = -1;24262427if(allow <0)2428 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2429if(allow)2430warning(msg, ce->name);2431else2432 err =error(msg, ce->name);24332434 drop_cache_tree =1;2435}2436if(ce_write_entry(&c, newfd, ce, previous_name, (struct ondisk_cache_entry *)&ondisk) <0)2437 err = -1;24382439if(err)2440break;2441}2442strbuf_release(&previous_name_buf);24432444if(err)2445return err;24462447/* Write extension data here */2448if(!strip_extensions && istate->split_index) {2449struct strbuf sb = STRBUF_INIT;24502451 err =write_link_extension(&sb, istate) <0||2452write_index_ext_header(&c, newfd, CACHE_EXT_LINK,2453 sb.len) <0||2454ce_write(&c, newfd, sb.buf, sb.len) <0;2455strbuf_release(&sb);2456if(err)2457return-1;2458}2459if(!strip_extensions && !drop_cache_tree && istate->cache_tree) {2460struct strbuf sb = STRBUF_INIT;24612462cache_tree_write(&sb, istate->cache_tree);2463 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <02464||ce_write(&c, newfd, sb.buf, sb.len) <0;2465strbuf_release(&sb);2466if(err)2467return-1;2468}2469if(!strip_extensions && istate->resolve_undo) {2470struct strbuf sb = STRBUF_INIT;24712472resolve_undo_write(&sb, istate->resolve_undo);2473 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,2474 sb.len) <02475||ce_write(&c, newfd, sb.buf, sb.len) <0;2476strbuf_release(&sb);2477if(err)2478return-1;2479}2480if(!strip_extensions && istate->untracked) {2481struct strbuf sb = STRBUF_INIT;24822483write_untracked_extension(&sb, istate->untracked);2484 err =write_index_ext_header(&c, newfd, CACHE_EXT_UNTRACKED,2485 sb.len) <0||2486ce_write(&c, newfd, sb.buf, sb.len) <0;2487strbuf_release(&sb);2488if(err)2489return-1;2490}2491if(!strip_extensions && istate->fsmonitor_last_update) {2492struct strbuf sb = STRBUF_INIT;24932494write_fsmonitor_extension(&sb, istate);2495 err =write_index_ext_header(&c, newfd, CACHE_EXT_FSMONITOR, sb.len) <02496||ce_write(&c, newfd, sb.buf, sb.len) <0;2497strbuf_release(&sb);2498if(err)2499return-1;2500}25012502if(ce_flush(&c, newfd, istate->oid.hash))2503return-1;2504if(close_tempfile_gently(tempfile)) {2505error(_("could not close '%s'"), tempfile->filename.buf);2506return-1;2507}2508if(stat(tempfile->filename.buf, &st))2509return-1;2510 istate->timestamp.sec = (unsigned int)st.st_mtime;2511 istate->timestamp.nsec =ST_MTIME_NSEC(st);2512trace_performance_since(start,"write index, changed mask =%x", istate->cache_changed);2513return0;2514}25152516voidset_alternate_index_output(const char*name)2517{2518 alternate_index_output = name;2519}25202521static intcommit_locked_index(struct lock_file *lk)2522{2523if(alternate_index_output)2524returncommit_lock_file_to(lk, alternate_index_output);2525else2526returncommit_lock_file(lk);2527}25282529static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2530unsigned flags)2531{2532int ret =do_write_index(istate, lock->tempfile,0);2533if(ret)2534return ret;2535if(flags & COMMIT_LOCK)2536returncommit_locked_index(lock);2537returnclose_lock_file_gently(lock);2538}25392540static intwrite_split_index(struct index_state *istate,2541struct lock_file *lock,2542unsigned flags)2543{2544int ret;2545prepare_to_write_split_index(istate);2546 ret =do_write_locked_index(istate, lock, flags);2547finish_writing_split_index(istate);2548return ret;2549}25502551static const char*shared_index_expire ="2.weeks.ago";25522553static unsigned longget_shared_index_expire_date(void)2554{2555static unsigned long shared_index_expire_date;2556static int shared_index_expire_date_prepared;25572558if(!shared_index_expire_date_prepared) {2559git_config_get_expiry("splitindex.sharedindexexpire",2560&shared_index_expire);2561 shared_index_expire_date =approxidate(shared_index_expire);2562 shared_index_expire_date_prepared =1;2563}25642565return shared_index_expire_date;2566}25672568static intshould_delete_shared_index(const char*shared_index_path)2569{2570struct stat st;2571unsigned long expiration;25722573/* Check timestamp */2574 expiration =get_shared_index_expire_date();2575if(!expiration)2576return0;2577if(stat(shared_index_path, &st))2578returnerror_errno(_("could not stat '%s'"), shared_index_path);2579if(st.st_mtime > expiration)2580return0;25812582return1;2583}25842585static intclean_shared_index_files(const char*current_hex)2586{2587struct dirent *de;2588DIR*dir =opendir(get_git_dir());25892590if(!dir)2591returnerror_errno(_("unable to open git dir:%s"),get_git_dir());25922593while((de =readdir(dir)) != NULL) {2594const char*sha1_hex;2595const char*shared_index_path;2596if(!skip_prefix(de->d_name,"sharedindex.", &sha1_hex))2597continue;2598if(!strcmp(sha1_hex, current_hex))2599continue;2600 shared_index_path =git_path("%s", de->d_name);2601if(should_delete_shared_index(shared_index_path) >0&&2602unlink(shared_index_path))2603warning_errno(_("unable to unlink:%s"), shared_index_path);2604}2605closedir(dir);26062607return0;2608}26092610static intwrite_shared_index(struct index_state *istate,2611struct tempfile **temp)2612{2613struct split_index *si = istate->split_index;2614int ret;26152616move_cache_to_base_index(istate);2617 ret =do_write_index(si->base, *temp,1);2618if(ret)2619return ret;2620 ret =adjust_shared_perm(get_tempfile_path(*temp));2621if(ret) {2622error("cannot fix permission bits on%s",get_tempfile_path(*temp));2623return ret;2624}2625 ret =rename_tempfile(temp,2626git_path("sharedindex.%s",oid_to_hex(&si->base->oid)));2627if(!ret) {2628oidcpy(&si->base_oid, &si->base->oid);2629clean_shared_index_files(oid_to_hex(&si->base->oid));2630}26312632return ret;2633}26342635static const int default_max_percent_split_change =20;26362637static inttoo_many_not_shared_entries(struct index_state *istate)2638{2639int i, not_shared =0;2640int max_split =git_config_get_max_percent_split_change();26412642switch(max_split) {2643case-1:2644/* not or badly configured: use the default value */2645 max_split = default_max_percent_split_change;2646break;2647case0:2648return1;/* 0% means always write a new shared index */2649case100:2650return0;/* 100% means never write a new shared index */2651default:2652break;/* just use the configured value */2653}26542655/* Count not shared entries */2656for(i =0; i < istate->cache_nr; i++) {2657struct cache_entry *ce = istate->cache[i];2658if(!ce->index)2659 not_shared++;2660}26612662return(int64_t)istate->cache_nr * max_split < (int64_t)not_shared *100;2663}26642665intwrite_locked_index(struct index_state *istate,struct lock_file *lock,2666unsigned flags)2667{2668int new_shared_index, ret;2669struct split_index *si = istate->split_index;26702671if((flags & SKIP_IF_UNCHANGED) && !istate->cache_changed) {2672if(flags & COMMIT_LOCK)2673rollback_lock_file(lock);2674return0;2675}26762677if(istate->fsmonitor_last_update)2678fill_fsmonitor_bitmap(istate);26792680if(!si || alternate_index_output ||2681(istate->cache_changed & ~EXTMASK)) {2682if(si)2683oidclr(&si->base_oid);2684 ret =do_write_locked_index(istate, lock, flags);2685goto out;2686}26872688if(git_env_bool("GIT_TEST_SPLIT_INDEX",0)) {2689int v = si->base_oid.hash[0];2690if((v &15) <6)2691 istate->cache_changed |= SPLIT_INDEX_ORDERED;2692}2693if(too_many_not_shared_entries(istate))2694 istate->cache_changed |= SPLIT_INDEX_ORDERED;26952696 new_shared_index = istate->cache_changed & SPLIT_INDEX_ORDERED;26972698if(new_shared_index) {2699struct tempfile *temp;2700int saved_errno;27012702 temp =mks_tempfile(git_path("sharedindex_XXXXXX"));2703if(!temp) {2704oidclr(&si->base_oid);2705 ret =do_write_locked_index(istate, lock, flags);2706goto out;2707}2708 ret =write_shared_index(istate, &temp);27092710 saved_errno = errno;2711if(is_tempfile_active(temp))2712delete_tempfile(&temp);2713 errno = saved_errno;27142715if(ret)2716goto out;2717}27182719 ret =write_split_index(istate, lock, flags);27202721/* Freshen the shared index only if the split-index was written */2722if(!ret && !new_shared_index) {2723const char*shared_index =git_path("sharedindex.%s",2724oid_to_hex(&si->base_oid));2725freshen_shared_index(shared_index,1);2726}27272728out:2729if(flags & COMMIT_LOCK)2730rollback_lock_file(lock);2731return ret;2732}27332734/*2735 * Read the index file that is potentially unmerged into given2736 * index_state, dropping any unmerged entries. Returns true if2737 * the index is unmerged. Callers who want to refuse to work2738 * from an unmerged state can call this and check its return value,2739 * instead of calling read_cache().2740 */2741intread_index_unmerged(struct index_state *istate)2742{2743int i;2744int unmerged =0;27452746read_index(istate);2747for(i =0; i < istate->cache_nr; i++) {2748struct cache_entry *ce = istate->cache[i];2749struct cache_entry *new_ce;2750int len;27512752if(!ce_stage(ce))2753continue;2754 unmerged =1;2755 len =ce_namelen(ce);2756 new_ce =make_empty_cache_entry(istate, len);2757memcpy(new_ce->name, ce->name, len);2758 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;2759 new_ce->ce_namelen = len;2760 new_ce->ce_mode = ce->ce_mode;2761if(add_index_entry(istate, new_ce,0))2762returnerror("%s: cannot drop to stage #0",2763 new_ce->name);2764}2765return unmerged;2766}27672768/*2769 * Returns 1 if the path is an "other" path with respect to2770 * the index; that is, the path is not mentioned in the index at all,2771 * either as a file, a directory with some files in the index,2772 * or as an unmerged entry.2773 *2774 * We helpfully remove a trailing "/" from directories so that2775 * the output of read_directory can be used as-is.2776 */2777intindex_name_is_other(const struct index_state *istate,const char*name,2778int namelen)2779{2780int pos;2781if(namelen && name[namelen -1] =='/')2782 namelen--;2783 pos =index_name_pos(istate, name, namelen);2784if(0<= pos)2785return0;/* exact match */2786 pos = -pos -1;2787if(pos < istate->cache_nr) {2788struct cache_entry *ce = istate->cache[pos];2789if(ce_namelen(ce) == namelen &&2790!memcmp(ce->name, name, namelen))2791return0;/* Yup, this one exists unmerged */2792}2793return1;2794}27952796void*read_blob_data_from_index(const struct index_state *istate,2797const char*path,unsigned long*size)2798{2799int pos, len;2800unsigned long sz;2801enum object_type type;2802void*data;28032804 len =strlen(path);2805 pos =index_name_pos(istate, path, len);2806if(pos <0) {2807/*2808 * We might be in the middle of a merge, in which2809 * case we would read stage #2 (ours).2810 */2811int i;2812for(i = -pos -1;2813(pos <0&& i < istate->cache_nr &&2814!strcmp(istate->cache[i]->name, path));2815 i++)2816if(ce_stage(istate->cache[i]) ==2)2817 pos = i;2818}2819if(pos <0)2820return NULL;2821 data =read_object_file(&istate->cache[pos]->oid, &type, &sz);2822if(!data || type != OBJ_BLOB) {2823free(data);2824return NULL;2825}2826if(size)2827*size = sz;2828return data;2829}28302831voidstat_validity_clear(struct stat_validity *sv)2832{2833FREE_AND_NULL(sv->sd);2834}28352836intstat_validity_check(struct stat_validity *sv,const char*path)2837{2838struct stat st;28392840if(stat(path, &st) <0)2841return sv->sd == NULL;2842if(!sv->sd)2843return0;2844returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2845}28462847voidstat_validity_update(struct stat_validity *sv,int fd)2848{2849struct stat st;28502851if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2852stat_validity_clear(sv);2853else{2854if(!sv->sd)2855 sv->sd =xcalloc(1,sizeof(struct stat_data));2856fill_stat_data(sv->sd, &st);2857}2858}28592860voidmove_index_extensions(struct index_state *dst,struct index_state *src)2861{2862 dst->untracked = src->untracked;2863 src->untracked = NULL;2864}28652866struct cache_entry *dup_cache_entry(const struct cache_entry *ce,2867struct index_state *istate)2868{2869unsigned int size =ce_size(ce);2870int mem_pool_allocated;2871struct cache_entry *new_entry =make_empty_cache_entry(istate,ce_namelen(ce));2872 mem_pool_allocated = new_entry->mem_pool_allocated;28732874memcpy(new_entry, ce, size);2875 new_entry->mem_pool_allocated = mem_pool_allocated;2876return new_entry;2877}28782879voiddiscard_cache_entry(struct cache_entry *ce)2880{2881if(ce && ce->mem_pool_allocated)2882return;28832884free(ce);2885}