1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#define NO_THE_INDEX_COMPATIBILITY_MACROS 7#include"cache.h" 8#include"config.h" 9#include"diff.h" 10#include"diffcore.h" 11#include"tempfile.h" 12#include"lockfile.h" 13#include"cache-tree.h" 14#include"refs.h" 15#include"dir.h" 16#include"tree.h" 17#include"commit.h" 18#include"blob.h" 19#include"resolve-undo.h" 20#include"strbuf.h" 21#include"varint.h" 22#include"split-index.h" 23#include"utf8.h" 24#include"fsmonitor.h" 25 26/* Mask for the name length in ce_flags in the on-disk index */ 27 28#define CE_NAMEMASK (0x0fff) 29 30/* Index extensions. 31 * 32 * The first letter should be 'A'..'Z' for extensions that are not 33 * necessary for a correct operation (i.e. optimization data). 34 * When new extensions are added that _needs_ to be understood in 35 * order to correctly interpret the index file, pick character that 36 * is outside the range, to cause the reader to abort. 37 */ 38 39#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 40#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 41#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 42#define CACHE_EXT_LINK 0x6c696e6b/* "link" */ 43#define CACHE_EXT_UNTRACKED 0x554E5452/* "UNTR" */ 44#define CACHE_EXT_FSMONITOR 0x46534D4E/* "FSMN" */ 45 46/* changes that can be kept in $GIT_DIR/index (basically all extensions) */ 47#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \ 48 CE_ENTRY_ADDED | CE_ENTRY_REMOVED | CE_ENTRY_CHANGED | \ 49 SPLIT_INDEX_ORDERED | UNTRACKED_CHANGED | FSMONITOR_CHANGED) 50 51struct index_state the_index; 52static const char*alternate_index_output; 53 54static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 55{ 56 istate->cache[nr] = ce; 57add_name_hash(istate, ce); 58} 59 60static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 61{ 62struct cache_entry *old = istate->cache[nr]; 63 64replace_index_entry_in_base(istate, old, ce); 65remove_name_hash(istate, old); 66free(old); 67 ce->ce_flags &= ~CE_HASHED; 68set_index_entry(istate, nr, ce); 69 ce->ce_flags |= CE_UPDATE_IN_BASE; 70mark_fsmonitor_invalid(istate, ce); 71 istate->cache_changed |= CE_ENTRY_CHANGED; 72} 73 74voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 75{ 76struct cache_entry *old_entry = istate->cache[nr], *new_entry; 77int namelen =strlen(new_name); 78 79 new_entry =xmalloc(cache_entry_size(namelen)); 80copy_cache_entry(new_entry, old_entry); 81 new_entry->ce_flags &= ~CE_HASHED; 82 new_entry->ce_namelen = namelen; 83 new_entry->index =0; 84memcpy(new_entry->name, new_name, namelen +1); 85 86cache_tree_invalidate_path(istate, old_entry->name); 87untracked_cache_remove_from_index(istate, old_entry->name); 88remove_index_entry_at(istate, nr); 89add_index_entry(istate, new_entry, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 90} 91 92voidfill_stat_data(struct stat_data *sd,struct stat *st) 93{ 94 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 95 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 96 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 97 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 98 sd->sd_dev = st->st_dev; 99 sd->sd_ino = st->st_ino; 100 sd->sd_uid = st->st_uid; 101 sd->sd_gid = st->st_gid; 102 sd->sd_size = st->st_size; 103} 104 105intmatch_stat_data(const struct stat_data *sd,struct stat *st) 106{ 107int changed =0; 108 109if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 110 changed |= MTIME_CHANGED; 111if(trust_ctime && check_stat && 112 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 113 changed |= CTIME_CHANGED; 114 115#ifdef USE_NSEC 116if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 117 changed |= MTIME_CHANGED; 118if(trust_ctime && check_stat && 119 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 120 changed |= CTIME_CHANGED; 121#endif 122 123if(check_stat) { 124if(sd->sd_uid != (unsigned int) st->st_uid || 125 sd->sd_gid != (unsigned int) st->st_gid) 126 changed |= OWNER_CHANGED; 127if(sd->sd_ino != (unsigned int) st->st_ino) 128 changed |= INODE_CHANGED; 129} 130 131#ifdef USE_STDEV 132/* 133 * st_dev breaks on network filesystems where different 134 * clients will have different views of what "device" 135 * the filesystem is on 136 */ 137if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 138 changed |= INODE_CHANGED; 139#endif 140 141if(sd->sd_size != (unsigned int) st->st_size) 142 changed |= DATA_CHANGED; 143 144return changed; 145} 146 147/* 148 * This only updates the "non-critical" parts of the directory 149 * cache, ie the parts that aren't tracked by GIT, and only used 150 * to validate the cache. 151 */ 152voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 153{ 154fill_stat_data(&ce->ce_stat_data, st); 155 156if(assume_unchanged) 157 ce->ce_flags |= CE_VALID; 158 159if(S_ISREG(st->st_mode)) { 160ce_mark_uptodate(ce); 161mark_fsmonitor_valid(ce); 162} 163} 164 165static intce_compare_data(const struct cache_entry *ce,struct stat *st) 166{ 167int match = -1; 168int fd =git_open_cloexec(ce->name, O_RDONLY); 169 170if(fd >=0) { 171struct object_id oid; 172if(!index_fd(&oid, fd, st, OBJ_BLOB, ce->name,0)) 173 match =oidcmp(&oid, &ce->oid); 174/* index_fd() closed the file descriptor already */ 175} 176return match; 177} 178 179static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 180{ 181int match = -1; 182void*buffer; 183unsigned long size; 184enum object_type type; 185struct strbuf sb = STRBUF_INIT; 186 187if(strbuf_readlink(&sb, ce->name, expected_size)) 188return-1; 189 190 buffer =read_sha1_file(ce->oid.hash, &type, &size); 191if(buffer) { 192if(size == sb.len) 193 match =memcmp(buffer, sb.buf, size); 194free(buffer); 195} 196strbuf_release(&sb); 197return match; 198} 199 200static intce_compare_gitlink(const struct cache_entry *ce) 201{ 202struct object_id oid; 203 204/* 205 * We don't actually require that the .git directory 206 * under GITLINK directory be a valid git directory. It 207 * might even be missing (in case nobody populated that 208 * sub-project). 209 * 210 * If so, we consider it always to match. 211 */ 212if(resolve_gitlink_ref(ce->name,"HEAD", &oid) <0) 213return0; 214returnoidcmp(&oid, &ce->oid); 215} 216 217static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 218{ 219switch(st->st_mode & S_IFMT) { 220case S_IFREG: 221if(ce_compare_data(ce, st)) 222return DATA_CHANGED; 223break; 224case S_IFLNK: 225if(ce_compare_link(ce,xsize_t(st->st_size))) 226return DATA_CHANGED; 227break; 228case S_IFDIR: 229if(S_ISGITLINK(ce->ce_mode)) 230returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 231/* else fallthrough */ 232default: 233return TYPE_CHANGED; 234} 235return0; 236} 237 238static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 239{ 240unsigned int changed =0; 241 242if(ce->ce_flags & CE_REMOVE) 243return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 244 245switch(ce->ce_mode & S_IFMT) { 246case S_IFREG: 247 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 248/* We consider only the owner x bit to be relevant for 249 * "mode changes" 250 */ 251if(trust_executable_bit && 252(0100& (ce->ce_mode ^ st->st_mode))) 253 changed |= MODE_CHANGED; 254break; 255case S_IFLNK: 256if(!S_ISLNK(st->st_mode) && 257(has_symlinks || !S_ISREG(st->st_mode))) 258 changed |= TYPE_CHANGED; 259break; 260case S_IFGITLINK: 261/* We ignore most of the st_xxx fields for gitlinks */ 262if(!S_ISDIR(st->st_mode)) 263 changed |= TYPE_CHANGED; 264else if(ce_compare_gitlink(ce)) 265 changed |= DATA_CHANGED; 266return changed; 267default: 268die("internal error: ce_mode is%o", ce->ce_mode); 269} 270 271 changed |=match_stat_data(&ce->ce_stat_data, st); 272 273/* Racily smudged entry? */ 274if(!ce->ce_stat_data.sd_size) { 275if(!is_empty_blob_sha1(ce->oid.hash)) 276 changed |= DATA_CHANGED; 277} 278 279return changed; 280} 281 282static intis_racy_stat(const struct index_state *istate, 283const struct stat_data *sd) 284{ 285return(istate->timestamp.sec && 286#ifdef USE_NSEC 287/* nanosecond timestamped files can also be racy! */ 288(istate->timestamp.sec < sd->sd_mtime.sec || 289(istate->timestamp.sec == sd->sd_mtime.sec && 290 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 291#else 292 istate->timestamp.sec <= sd->sd_mtime.sec 293#endif 294); 295} 296 297static intis_racy_timestamp(const struct index_state *istate, 298const struct cache_entry *ce) 299{ 300return(!S_ISGITLINK(ce->ce_mode) && 301is_racy_stat(istate, &ce->ce_stat_data)); 302} 303 304intmatch_stat_data_racy(const struct index_state *istate, 305const struct stat_data *sd,struct stat *st) 306{ 307if(is_racy_stat(istate, sd)) 308return MTIME_CHANGED; 309returnmatch_stat_data(sd, st); 310} 311 312intie_match_stat(struct index_state *istate, 313const struct cache_entry *ce,struct stat *st, 314unsigned int options) 315{ 316unsigned int changed; 317int ignore_valid = options & CE_MATCH_IGNORE_VALID; 318int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 319int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 320int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR; 321 322if(!ignore_fsmonitor) 323refresh_fsmonitor(istate); 324/* 325 * If it's marked as always valid in the index, it's 326 * valid whatever the checked-out copy says. 327 * 328 * skip-worktree has the same effect with higher precedence 329 */ 330if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 331return0; 332if(!ignore_valid && (ce->ce_flags & CE_VALID)) 333return0; 334if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) 335return0; 336 337/* 338 * Intent-to-add entries have not been added, so the index entry 339 * by definition never matches what is in the work tree until it 340 * actually gets added. 341 */ 342if(ce_intent_to_add(ce)) 343return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 344 345 changed =ce_match_stat_basic(ce, st); 346 347/* 348 * Within 1 second of this sequence: 349 * echo xyzzy >file && git-update-index --add file 350 * running this command: 351 * echo frotz >file 352 * would give a falsely clean cache entry. The mtime and 353 * length match the cache, and other stat fields do not change. 354 * 355 * We could detect this at update-index time (the cache entry 356 * being registered/updated records the same time as "now") 357 * and delay the return from git-update-index, but that would 358 * effectively mean we can make at most one commit per second, 359 * which is not acceptable. Instead, we check cache entries 360 * whose mtime are the same as the index file timestamp more 361 * carefully than others. 362 */ 363if(!changed &&is_racy_timestamp(istate, ce)) { 364if(assume_racy_is_modified) 365 changed |= DATA_CHANGED; 366else 367 changed |=ce_modified_check_fs(ce, st); 368} 369 370return changed; 371} 372 373intie_modified(struct index_state *istate, 374const struct cache_entry *ce, 375struct stat *st,unsigned int options) 376{ 377int changed, changed_fs; 378 379 changed =ie_match_stat(istate, ce, st, options); 380if(!changed) 381return0; 382/* 383 * If the mode or type has changed, there's no point in trying 384 * to refresh the entry - it's not going to match 385 */ 386if(changed & (MODE_CHANGED | TYPE_CHANGED)) 387return changed; 388 389/* 390 * Immediately after read-tree or update-index --cacheinfo, 391 * the length field is zero, as we have never even read the 392 * lstat(2) information once, and we cannot trust DATA_CHANGED 393 * returned by ie_match_stat() which in turn was returned by 394 * ce_match_stat_basic() to signal that the filesize of the 395 * blob changed. We have to actually go to the filesystem to 396 * see if the contents match, and if so, should answer "unchanged". 397 * 398 * The logic does not apply to gitlinks, as ce_match_stat_basic() 399 * already has checked the actual HEAD from the filesystem in the 400 * subproject. If ie_match_stat() already said it is different, 401 * then we know it is. 402 */ 403if((changed & DATA_CHANGED) && 404(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 405return changed; 406 407 changed_fs =ce_modified_check_fs(ce, st); 408if(changed_fs) 409return changed | changed_fs; 410return0; 411} 412 413intbase_name_compare(const char*name1,int len1,int mode1, 414const char*name2,int len2,int mode2) 415{ 416unsigned char c1, c2; 417int len = len1 < len2 ? len1 : len2; 418int cmp; 419 420 cmp =memcmp(name1, name2, len); 421if(cmp) 422return cmp; 423 c1 = name1[len]; 424 c2 = name2[len]; 425if(!c1 &&S_ISDIR(mode1)) 426 c1 ='/'; 427if(!c2 &&S_ISDIR(mode2)) 428 c2 ='/'; 429return(c1 < c2) ? -1: (c1 > c2) ?1:0; 430} 431 432/* 433 * df_name_compare() is identical to base_name_compare(), except it 434 * compares conflicting directory/file entries as equal. Note that 435 * while a directory name compares as equal to a regular file, they 436 * then individually compare _differently_ to a filename that has 437 * a dot after the basename (because '\0' < '.' < '/'). 438 * 439 * This is used by routines that want to traverse the git namespace 440 * but then handle conflicting entries together when possible. 441 */ 442intdf_name_compare(const char*name1,int len1,int mode1, 443const char*name2,int len2,int mode2) 444{ 445int len = len1 < len2 ? len1 : len2, cmp; 446unsigned char c1, c2; 447 448 cmp =memcmp(name1, name2, len); 449if(cmp) 450return cmp; 451/* Directories and files compare equal (same length, same name) */ 452if(len1 == len2) 453return0; 454 c1 = name1[len]; 455if(!c1 &&S_ISDIR(mode1)) 456 c1 ='/'; 457 c2 = name2[len]; 458if(!c2 &&S_ISDIR(mode2)) 459 c2 ='/'; 460if(c1 =='/'&& !c2) 461return0; 462if(c2 =='/'&& !c1) 463return0; 464return c1 - c2; 465} 466 467intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 468{ 469size_t min_len = (len1 < len2) ? len1 : len2; 470int cmp =memcmp(name1, name2, min_len); 471if(cmp) 472return cmp; 473if(len1 < len2) 474return-1; 475if(len1 > len2) 476return1; 477return0; 478} 479 480intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 481{ 482int cmp; 483 484 cmp =name_compare(name1, len1, name2, len2); 485if(cmp) 486return cmp; 487 488if(stage1 < stage2) 489return-1; 490if(stage1 > stage2) 491return1; 492return0; 493} 494 495static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 496{ 497int first, last; 498 499 first =0; 500 last = istate->cache_nr; 501while(last > first) { 502int next = (last + first) >>1; 503struct cache_entry *ce = istate->cache[next]; 504int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 505if(!cmp) 506return next; 507if(cmp <0) { 508 last = next; 509continue; 510} 511 first = next+1; 512} 513return-first-1; 514} 515 516intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 517{ 518returnindex_name_stage_pos(istate, name, namelen,0); 519} 520 521intremove_index_entry_at(struct index_state *istate,int pos) 522{ 523struct cache_entry *ce = istate->cache[pos]; 524 525record_resolve_undo(istate, ce); 526remove_name_hash(istate, ce); 527save_or_free_index_entry(istate, ce); 528 istate->cache_changed |= CE_ENTRY_REMOVED; 529 istate->cache_nr--; 530if(pos >= istate->cache_nr) 531return0; 532MOVE_ARRAY(istate->cache + pos, istate->cache + pos +1, 533 istate->cache_nr - pos); 534return1; 535} 536 537/* 538 * Remove all cache entries marked for removal, that is where 539 * CE_REMOVE is set in ce_flags. This is much more effective than 540 * calling remove_index_entry_at() for each entry to be removed. 541 */ 542voidremove_marked_cache_entries(struct index_state *istate) 543{ 544struct cache_entry **ce_array = istate->cache; 545unsigned int i, j; 546 547for(i = j =0; i < istate->cache_nr; i++) { 548if(ce_array[i]->ce_flags & CE_REMOVE) { 549remove_name_hash(istate, ce_array[i]); 550save_or_free_index_entry(istate, ce_array[i]); 551} 552else 553 ce_array[j++] = ce_array[i]; 554} 555if(j == istate->cache_nr) 556return; 557 istate->cache_changed |= CE_ENTRY_REMOVED; 558 istate->cache_nr = j; 559} 560 561intremove_file_from_index(struct index_state *istate,const char*path) 562{ 563int pos =index_name_pos(istate, path,strlen(path)); 564if(pos <0) 565 pos = -pos-1; 566cache_tree_invalidate_path(istate, path); 567untracked_cache_remove_from_index(istate, path); 568while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 569remove_index_entry_at(istate, pos); 570return0; 571} 572 573static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 574{ 575return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 576} 577 578static intindex_name_pos_also_unmerged(struct index_state *istate, 579const char*path,int namelen) 580{ 581int pos =index_name_pos(istate, path, namelen); 582struct cache_entry *ce; 583 584if(pos >=0) 585return pos; 586 587/* maybe unmerged? */ 588 pos = -1- pos; 589if(pos >= istate->cache_nr || 590compare_name((ce = istate->cache[pos]), path, namelen)) 591return-1; 592 593/* order of preference: stage 2, 1, 3 */ 594if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 595ce_stage((ce = istate->cache[pos +1])) ==2&& 596!compare_name(ce, path, namelen)) 597 pos++; 598return pos; 599} 600 601static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 602{ 603int len =ce_namelen(ce); 604returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 605} 606 607/* 608 * If we add a filename that aliases in the cache, we will use the 609 * name that we already have - but we don't want to update the same 610 * alias twice, because that implies that there were actually two 611 * different files with aliasing names! 612 * 613 * So we use the CE_ADDED flag to verify that the alias was an old 614 * one before we accept it as 615 */ 616static struct cache_entry *create_alias_ce(struct index_state *istate, 617struct cache_entry *ce, 618struct cache_entry *alias) 619{ 620int len; 621struct cache_entry *new_entry; 622 623if(alias->ce_flags & CE_ADDED) 624die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 625 626/* Ok, create the new entry using the name of the existing alias */ 627 len =ce_namelen(alias); 628 new_entry =xcalloc(1,cache_entry_size(len)); 629memcpy(new_entry->name, alias->name, len); 630copy_cache_entry(new_entry, ce); 631save_or_free_index_entry(istate, ce); 632return new_entry; 633} 634 635voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 636{ 637struct object_id oid; 638if(write_object_file("",0, blob_type, &oid)) 639die("cannot create an empty blob in the object database"); 640oidcpy(&ce->oid, &oid); 641} 642 643intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 644{ 645int size, namelen, was_same; 646 mode_t st_mode = st->st_mode; 647struct cache_entry *ce, *alias = NULL; 648unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 649int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 650int pretend = flags & ADD_CACHE_PRETEND; 651int intent_only = flags & ADD_CACHE_INTENT; 652int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 653(intent_only ? ADD_CACHE_NEW_ONLY :0)); 654int newflags = HASH_WRITE_OBJECT; 655 656if(flags & HASH_RENORMALIZE) 657 newflags |= HASH_RENORMALIZE; 658 659if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 660returnerror("%s: can only add regular files, symbolic links or git-directories", path); 661 662 namelen =strlen(path); 663if(S_ISDIR(st_mode)) { 664while(namelen && path[namelen-1] =='/') 665 namelen--; 666} 667 size =cache_entry_size(namelen); 668 ce =xcalloc(1, size); 669memcpy(ce->name, path, namelen); 670 ce->ce_namelen = namelen; 671if(!intent_only) 672fill_stat_cache_info(ce, st); 673else 674 ce->ce_flags |= CE_INTENT_TO_ADD; 675 676 677if(trust_executable_bit && has_symlinks) { 678 ce->ce_mode =create_ce_mode(st_mode); 679}else{ 680/* If there is an existing entry, pick the mode bits and type 681 * from it, otherwise assume unexecutable regular file. 682 */ 683struct cache_entry *ent; 684int pos =index_name_pos_also_unmerged(istate, path, namelen); 685 686 ent = (0<= pos) ? istate->cache[pos] : NULL; 687 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 688} 689 690/* When core.ignorecase=true, determine if a directory of the same name but differing 691 * case already exists within the Git repository. If it does, ensure the directory 692 * case of the file being added to the repository matches (is folded into) the existing 693 * entry's directory case. 694 */ 695if(ignore_case) { 696adjust_dirname_case(istate, ce->name); 697} 698if(!(flags & HASH_RENORMALIZE)) { 699 alias =index_file_exists(istate, ce->name, 700ce_namelen(ce), ignore_case); 701if(alias && 702!ce_stage(alias) && 703!ie_match_stat(istate, alias, st, ce_option)) { 704/* Nothing changed, really */ 705if(!S_ISGITLINK(alias->ce_mode)) 706ce_mark_uptodate(alias); 707 alias->ce_flags |= CE_ADDED; 708 709free(ce); 710return0; 711} 712} 713if(!intent_only) { 714if(index_path(&ce->oid, path, st, newflags)) { 715free(ce); 716returnerror("unable to index file%s", path); 717} 718}else 719set_object_name_for_intent_to_add_entry(ce); 720 721if(ignore_case && alias &&different_name(ce, alias)) 722 ce =create_alias_ce(istate, ce, alias); 723 ce->ce_flags |= CE_ADDED; 724 725/* It was suspected to be racily clean, but it turns out to be Ok */ 726 was_same = (alias && 727!ce_stage(alias) && 728!oidcmp(&alias->oid, &ce->oid) && 729 ce->ce_mode == alias->ce_mode); 730 731if(pretend) 732free(ce); 733else if(add_index_entry(istate, ce, add_option)) { 734free(ce); 735returnerror("unable to add%sto index", path); 736} 737if(verbose && !was_same) 738printf("add '%s'\n", path); 739return0; 740} 741 742intadd_file_to_index(struct index_state *istate,const char*path,int flags) 743{ 744struct stat st; 745if(lstat(path, &st)) 746die_errno("unable to stat '%s'", path); 747returnadd_to_index(istate, path, &st, flags); 748} 749 750struct cache_entry *make_cache_entry(unsigned int mode, 751const unsigned char*sha1,const char*path,int stage, 752unsigned int refresh_options) 753{ 754int size, len; 755struct cache_entry *ce, *ret; 756 757if(!verify_path(path, mode)) { 758error("Invalid path '%s'", path); 759return NULL; 760} 761 762 len =strlen(path); 763 size =cache_entry_size(len); 764 ce =xcalloc(1, size); 765 766hashcpy(ce->oid.hash, sha1); 767memcpy(ce->name, path, len); 768 ce->ce_flags =create_ce_flags(stage); 769 ce->ce_namelen = len; 770 ce->ce_mode =create_ce_mode(mode); 771 772 ret =refresh_cache_entry(ce, refresh_options); 773if(ret != ce) 774free(ce); 775return ret; 776} 777 778/* 779 * Chmod an index entry with either +x or -x. 780 * 781 * Returns -1 if the chmod for the particular cache entry failed (if it's 782 * not a regular file), -2 if an invalid flip argument is passed in, 0 783 * otherwise. 784 */ 785intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 786char flip) 787{ 788if(!S_ISREG(ce->ce_mode)) 789return-1; 790switch(flip) { 791case'+': 792 ce->ce_mode |=0111; 793break; 794case'-': 795 ce->ce_mode &= ~0111; 796break; 797default: 798return-2; 799} 800cache_tree_invalidate_path(istate, ce->name); 801 ce->ce_flags |= CE_UPDATE_IN_BASE; 802mark_fsmonitor_invalid(istate, ce); 803 istate->cache_changed |= CE_ENTRY_CHANGED; 804 805return0; 806} 807 808intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 809{ 810int len =ce_namelen(a); 811returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 812} 813 814/* 815 * We fundamentally don't like some paths: we don't want 816 * dot or dot-dot anywhere, and for obvious reasons don't 817 * want to recurse into ".git" either. 818 * 819 * Also, we don't want double slashes or slashes at the 820 * end that can make pathnames ambiguous. 821 */ 822static intverify_dotfile(const char*rest,unsigned mode) 823{ 824/* 825 * The first character was '.', but that 826 * has already been discarded, we now test 827 * the rest. 828 */ 829 830/* "." is not allowed */ 831if(*rest =='\0'||is_dir_sep(*rest)) 832return0; 833 834switch(*rest) { 835/* 836 * ".git" followed by NUL or slash is bad. Note that we match 837 * case-insensitively here, even if ignore_case is not set. 838 * This outlaws ".GIT" everywhere out of an abundance of caution, 839 * since there's really no good reason to allow it. 840 * 841 * Once we've seen ".git", we can also find ".gitmodules", etc (also 842 * case-insensitively). 843 */ 844case'g': 845case'G': 846if(rest[1] !='i'&& rest[1] !='I') 847break; 848if(rest[2] !='t'&& rest[2] !='T') 849break; 850if(rest[3] =='\0'||is_dir_sep(rest[3])) 851return0; 852if(S_ISLNK(mode)) { 853 rest +=3; 854if(skip_iprefix(rest,"modules", &rest) && 855(*rest =='\0'||is_dir_sep(*rest))) 856return0; 857} 858break; 859case'.': 860if(rest[1] =='\0'||is_dir_sep(rest[1])) 861return0; 862} 863return1; 864} 865 866intverify_path(const char*path,unsigned mode) 867{ 868char c; 869 870if(has_dos_drive_prefix(path)) 871return0; 872 873goto inside; 874for(;;) { 875if(!c) 876return1; 877if(is_dir_sep(c)) { 878inside: 879if(protect_hfs) { 880if(is_hfs_dotgit(path)) 881return0; 882if(S_ISLNK(mode)) { 883if(is_hfs_dotgitmodules(path)) 884return0; 885} 886} 887if(protect_ntfs) { 888if(is_ntfs_dotgit(path)) 889return0; 890if(S_ISLNK(mode)) { 891if(is_ntfs_dotgitmodules(path)) 892return0; 893} 894} 895 896 c = *path++; 897if((c =='.'&& !verify_dotfile(path, mode)) || 898is_dir_sep(c) || c =='\0') 899return0; 900} 901 c = *path++; 902} 903} 904 905/* 906 * Do we have another file that has the beginning components being a 907 * proper superset of the name we're trying to add? 908 */ 909static inthas_file_name(struct index_state *istate, 910const struct cache_entry *ce,int pos,int ok_to_replace) 911{ 912int retval =0; 913int len =ce_namelen(ce); 914int stage =ce_stage(ce); 915const char*name = ce->name; 916 917while(pos < istate->cache_nr) { 918struct cache_entry *p = istate->cache[pos++]; 919 920if(len >=ce_namelen(p)) 921break; 922if(memcmp(name, p->name, len)) 923break; 924if(ce_stage(p) != stage) 925continue; 926if(p->name[len] !='/') 927continue; 928if(p->ce_flags & CE_REMOVE) 929continue; 930 retval = -1; 931if(!ok_to_replace) 932break; 933remove_index_entry_at(istate, --pos); 934} 935return retval; 936} 937 938 939/* 940 * Like strcmp(), but also return the offset of the first change. 941 * If strings are equal, return the length. 942 */ 943intstrcmp_offset(const char*s1,const char*s2,size_t*first_change) 944{ 945size_t k; 946 947if(!first_change) 948returnstrcmp(s1, s2); 949 950for(k =0; s1[k] == s2[k]; k++) 951if(s1[k] =='\0') 952break; 953 954*first_change = k; 955return(unsigned char)s1[k] - (unsigned char)s2[k]; 956} 957 958/* 959 * Do we have another file with a pathname that is a proper 960 * subset of the name we're trying to add? 961 * 962 * That is, is there another file in the index with a path 963 * that matches a sub-directory in the given entry? 964 */ 965static inthas_dir_name(struct index_state *istate, 966const struct cache_entry *ce,int pos,int ok_to_replace) 967{ 968int retval =0; 969int stage =ce_stage(ce); 970const char*name = ce->name; 971const char*slash = name +ce_namelen(ce); 972size_t len_eq_last; 973int cmp_last =0; 974 975/* 976 * We are frequently called during an iteration on a sorted 977 * list of pathnames and while building a new index. Therefore, 978 * there is a high probability that this entry will eventually 979 * be appended to the index, rather than inserted in the middle. 980 * If we can confirm that, we can avoid binary searches on the 981 * components of the pathname. 982 * 983 * Compare the entry's full path with the last path in the index. 984 */ 985if(istate->cache_nr >0) { 986 cmp_last =strcmp_offset(name, 987 istate->cache[istate->cache_nr -1]->name, 988&len_eq_last); 989if(cmp_last >0) { 990if(len_eq_last ==0) { 991/* 992 * The entry sorts AFTER the last one in the 993 * index and their paths have no common prefix, 994 * so there cannot be a F/D conflict. 995 */ 996return retval; 997}else{ 998/* 999 * The entry sorts AFTER the last one in the1000 * index, but has a common prefix. Fall through1001 * to the loop below to disect the entry's path1002 * and see where the difference is.1003 */1004}1005}else if(cmp_last ==0) {1006/*1007 * The entry exactly matches the last one in the1008 * index, but because of multiple stage and CE_REMOVE1009 * items, we fall through and let the regular search1010 * code handle it.1011 */1012}1013}10141015for(;;) {1016size_t len;10171018for(;;) {1019if(*--slash =='/')1020break;1021if(slash <= ce->name)1022return retval;1023}1024 len = slash - name;10251026if(cmp_last >0) {1027/*1028 * (len + 1) is a directory boundary (including1029 * the trailing slash). And since the loop is1030 * decrementing "slash", the first iteration is1031 * the longest directory prefix; subsequent1032 * iterations consider parent directories.1033 */10341035if(len +1<= len_eq_last) {1036/*1037 * The directory prefix (including the trailing1038 * slash) also appears as a prefix in the last1039 * entry, so the remainder cannot collide (because1040 * strcmp said the whole path was greater).1041 *1042 * EQ: last: xxx/A1043 * this: xxx/B1044 *1045 * LT: last: xxx/file_A1046 * this: xxx/file_B1047 */1048return retval;1049}10501051if(len > len_eq_last) {1052/*1053 * This part of the directory prefix (excluding1054 * the trailing slash) is longer than the known1055 * equal portions, so this sub-directory cannot1056 * collide with a file.1057 *1058 * GT: last: xxxA1059 * this: xxxB/file1060 */1061return retval;1062}10631064if(istate->cache_nr >0&&1065ce_namelen(istate->cache[istate->cache_nr -1]) > len) {1066/*1067 * The directory prefix lines up with part of1068 * a longer file or directory name, but sorts1069 * after it, so this sub-directory cannot1070 * collide with a file.1071 *1072 * last: xxx/yy-file (because '-' sorts before '/')1073 * this: xxx/yy/abc1074 */1075return retval;1076}10771078/*1079 * This is a possible collision. Fall through and1080 * let the regular search code handle it.1081 *1082 * last: xxx1083 * this: xxx/file1084 */1085}10861087 pos =index_name_stage_pos(istate, name, len, stage);1088if(pos >=0) {1089/*1090 * Found one, but not so fast. This could1091 * be a marker that says "I was here, but1092 * I am being removed". Such an entry is1093 * not a part of the resulting tree, and1094 * it is Ok to have a directory at the same1095 * path.1096 */1097if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) {1098 retval = -1;1099if(!ok_to_replace)1100break;1101remove_index_entry_at(istate, pos);1102continue;1103}1104}1105else1106 pos = -pos-1;11071108/*1109 * Trivial optimization: if we find an entry that1110 * already matches the sub-directory, then we know1111 * we're ok, and we can exit.1112 */1113while(pos < istate->cache_nr) {1114struct cache_entry *p = istate->cache[pos];1115if((ce_namelen(p) <= len) ||1116(p->name[len] !='/') ||1117memcmp(p->name, name, len))1118break;/* not our subdirectory */1119if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))1120/*1121 * p is at the same stage as our entry, and1122 * is a subdirectory of what we are looking1123 * at, so we cannot have conflicts at our1124 * level or anything shorter.1125 */1126return retval;1127 pos++;1128}1129}1130return retval;1131}11321133/* We may be in a situation where we already have path/file and path1134 * is being added, or we already have path and path/file is being1135 * added. Either one would result in a nonsense tree that has path1136 * twice when git-write-tree tries to write it out. Prevent it.1137 *1138 * If ok-to-replace is specified, we remove the conflicting entries1139 * from the cache so the caller should recompute the insert position.1140 * When this happens, we return non-zero.1141 */1142static intcheck_file_directory_conflict(struct index_state *istate,1143const struct cache_entry *ce,1144int pos,int ok_to_replace)1145{1146int retval;11471148/*1149 * When ce is an "I am going away" entry, we allow it to be added1150 */1151if(ce->ce_flags & CE_REMOVE)1152return0;11531154/*1155 * We check if the path is a sub-path of a subsequent pathname1156 * first, since removing those will not change the position1157 * in the array.1158 */1159 retval =has_file_name(istate, ce, pos, ok_to_replace);11601161/*1162 * Then check if the path might have a clashing sub-directory1163 * before it.1164 */1165return retval +has_dir_name(istate, ce, pos, ok_to_replace);1166}11671168static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1169{1170int pos;1171int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1172int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1173int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1174int new_only = option & ADD_CACHE_NEW_ONLY;11751176if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1177cache_tree_invalidate_path(istate, ce->name);11781179/*1180 * If this entry's path sorts after the last entry in the index,1181 * we can avoid searching for it.1182 */1183if(istate->cache_nr >0&&1184strcmp(ce->name, istate->cache[istate->cache_nr -1]->name) >0)1185 pos = -istate->cache_nr -1;1186else1187 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));11881189/* existing match? Just replace it. */1190if(pos >=0) {1191if(!new_only)1192replace_index_entry(istate, pos, ce);1193return0;1194}1195 pos = -pos-1;11961197if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1198untracked_cache_add_to_index(istate, ce->name);11991200/*1201 * Inserting a merged entry ("stage 0") into the index1202 * will always replace all non-merged entries..1203 */1204if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1205while(ce_same_name(istate->cache[pos], ce)) {1206 ok_to_add =1;1207if(!remove_index_entry_at(istate, pos))1208break;1209}1210}12111212if(!ok_to_add)1213return-1;1214if(!verify_path(ce->name, ce->ce_mode))1215returnerror("Invalid path '%s'", ce->name);12161217if(!skip_df_check &&1218check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1219if(!ok_to_replace)1220returnerror("'%s' appears as both a file and as a directory",1221 ce->name);1222 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1223 pos = -pos-1;1224}1225return pos +1;1226}12271228intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1229{1230int pos;12311232if(option & ADD_CACHE_JUST_APPEND)1233 pos = istate->cache_nr;1234else{1235int ret;1236 ret =add_index_entry_with_check(istate, ce, option);1237if(ret <=0)1238return ret;1239 pos = ret -1;1240}12411242/* Make sure the array is big enough .. */1243ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);12441245/* Add it in.. */1246 istate->cache_nr++;1247if(istate->cache_nr > pos +1)1248MOVE_ARRAY(istate->cache + pos +1, istate->cache + pos,1249 istate->cache_nr - pos -1);1250set_index_entry(istate, pos, ce);1251 istate->cache_changed |= CE_ENTRY_ADDED;1252return0;1253}12541255/*1256 * "refresh" does not calculate a new sha1 file or bring the1257 * cache up-to-date for mode/content changes. But what it1258 * _does_ do is to "re-match" the stat information of a file1259 * with the cache, so that you can refresh the cache for a1260 * file that hasn't been changed but where the stat entry is1261 * out of date.1262 *1263 * For example, you'd want to do this after doing a "git-read-tree",1264 * to link up the stat cache details with the proper files.1265 */1266static struct cache_entry *refresh_cache_ent(struct index_state *istate,1267struct cache_entry *ce,1268unsigned int options,int*err,1269int*changed_ret)1270{1271struct stat st;1272struct cache_entry *updated;1273int changed, size;1274int refresh = options & CE_MATCH_REFRESH;1275int ignore_valid = options & CE_MATCH_IGNORE_VALID;1276int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1277int ignore_missing = options & CE_MATCH_IGNORE_MISSING;1278int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR;12791280if(!refresh ||ce_uptodate(ce))1281return ce;12821283if(!ignore_fsmonitor)1284refresh_fsmonitor(istate);1285/*1286 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1287 * that the change to the work tree does not matter and told1288 * us not to worry.1289 */1290if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1291ce_mark_uptodate(ce);1292return ce;1293}1294if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1295ce_mark_uptodate(ce);1296return ce;1297}1298if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) {1299ce_mark_uptodate(ce);1300return ce;1301}13021303if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1304if(ignore_missing)1305return ce;1306if(err)1307*err = ENOENT;1308return NULL;1309}13101311if(lstat(ce->name, &st) <0) {1312if(ignore_missing && errno == ENOENT)1313return ce;1314if(err)1315*err = errno;1316return NULL;1317}13181319 changed =ie_match_stat(istate, ce, &st, options);1320if(changed_ret)1321*changed_ret = changed;1322if(!changed) {1323/*1324 * The path is unchanged. If we were told to ignore1325 * valid bit, then we did the actual stat check and1326 * found that the entry is unmodified. If the entry1327 * is not marked VALID, this is the place to mark it1328 * valid again, under "assume unchanged" mode.1329 */1330if(ignore_valid && assume_unchanged &&1331!(ce->ce_flags & CE_VALID))1332;/* mark this one VALID again */1333else{1334/*1335 * We do not mark the index itself "modified"1336 * because CE_UPTODATE flag is in-core only;1337 * we are not going to write this change out.1338 */1339if(!S_ISGITLINK(ce->ce_mode)) {1340ce_mark_uptodate(ce);1341mark_fsmonitor_valid(ce);1342}1343return ce;1344}1345}13461347if(ie_modified(istate, ce, &st, options)) {1348if(err)1349*err = EINVAL;1350return NULL;1351}13521353 size =ce_size(ce);1354 updated =xmalloc(size);1355copy_cache_entry(updated, ce);1356memcpy(updated->name, ce->name, ce->ce_namelen +1);1357fill_stat_cache_info(updated, &st);1358/*1359 * If ignore_valid is not set, we should leave CE_VALID bit1360 * alone. Otherwise, paths marked with --no-assume-unchanged1361 * (i.e. things to be edited) will reacquire CE_VALID bit1362 * automatically, which is not really what we want.1363 */1364if(!ignore_valid && assume_unchanged &&1365!(ce->ce_flags & CE_VALID))1366 updated->ce_flags &= ~CE_VALID;13671368/* istate->cache_changed is updated in the caller */1369return updated;1370}13711372static voidshow_file(const char* fmt,const char* name,int in_porcelain,1373int* first,const char*header_msg)1374{1375if(in_porcelain && *first && header_msg) {1376printf("%s\n", header_msg);1377*first =0;1378}1379printf(fmt, name);1380}13811382intrefresh_index(struct index_state *istate,unsigned int flags,1383const struct pathspec *pathspec,1384char*seen,const char*header_msg)1385{1386int i;1387int has_errors =0;1388int really = (flags & REFRESH_REALLY) !=0;1389int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1390int quiet = (flags & REFRESH_QUIET) !=0;1391int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1392int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1393int first =1;1394int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1395unsigned int options = (CE_MATCH_REFRESH |1396(really ? CE_MATCH_IGNORE_VALID :0) |1397(not_new ? CE_MATCH_IGNORE_MISSING :0));1398const char*modified_fmt;1399const char*deleted_fmt;1400const char*typechange_fmt;1401const char*added_fmt;1402const char*unmerged_fmt;1403uint64_t start =getnanotime();14041405 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1406 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1407 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1408 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1409 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1410for(i =0; i < istate->cache_nr; i++) {1411struct cache_entry *ce, *new_entry;1412int cache_errno =0;1413int changed =0;1414int filtered =0;14151416 ce = istate->cache[i];1417if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1418continue;14191420if(pathspec && !ce_path_match(ce, pathspec, seen))1421 filtered =1;14221423if(ce_stage(ce)) {1424while((i < istate->cache_nr) &&1425!strcmp(istate->cache[i]->name, ce->name))1426 i++;1427 i--;1428if(allow_unmerged)1429continue;1430if(!filtered)1431show_file(unmerged_fmt, ce->name, in_porcelain,1432&first, header_msg);1433 has_errors =1;1434continue;1435}14361437if(filtered)1438continue;14391440 new_entry =refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1441if(new_entry == ce)1442continue;1443if(!new_entry) {1444const char*fmt;14451446if(really && cache_errno == EINVAL) {1447/* If we are doing --really-refresh that1448 * means the index is not valid anymore.1449 */1450 ce->ce_flags &= ~CE_VALID;1451 ce->ce_flags |= CE_UPDATE_IN_BASE;1452mark_fsmonitor_invalid(istate, ce);1453 istate->cache_changed |= CE_ENTRY_CHANGED;1454}1455if(quiet)1456continue;14571458if(cache_errno == ENOENT)1459 fmt = deleted_fmt;1460else if(ce_intent_to_add(ce))1461 fmt = added_fmt;/* must be before other checks */1462else if(changed & TYPE_CHANGED)1463 fmt = typechange_fmt;1464else1465 fmt = modified_fmt;1466show_file(fmt,1467 ce->name, in_porcelain, &first, header_msg);1468 has_errors =1;1469continue;1470}14711472replace_index_entry(istate, i, new_entry);1473}1474trace_performance_since(start,"refresh index");1475return has_errors;1476}14771478struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1479unsigned int options)1480{1481returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1482}148314841485/*****************************************************************1486 * Index File I/O1487 *****************************************************************/14881489#define INDEX_FORMAT_DEFAULT 314901491static unsigned intget_index_format_default(void)1492{1493char*envversion =getenv("GIT_INDEX_VERSION");1494char*endp;1495int value;1496unsigned int version = INDEX_FORMAT_DEFAULT;14971498if(!envversion) {1499if(!git_config_get_int("index.version", &value))1500 version = value;1501if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1502warning(_("index.version set, but the value is invalid.\n"1503"Using version%i"), INDEX_FORMAT_DEFAULT);1504return INDEX_FORMAT_DEFAULT;1505}1506return version;1507}15081509 version =strtoul(envversion, &endp,10);1510if(*endp ||1511 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1512warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1513"Using version%i"), INDEX_FORMAT_DEFAULT);1514 version = INDEX_FORMAT_DEFAULT;1515}1516return version;1517}15181519/*1520 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1521 * Again - this is just a (very strong in practice) heuristic that1522 * the inode hasn't changed.1523 *1524 * We save the fields in big-endian order to allow using the1525 * index file over NFS transparently.1526 */1527struct ondisk_cache_entry {1528struct cache_time ctime;1529struct cache_time mtime;1530uint32_t dev;1531uint32_t ino;1532uint32_t mode;1533uint32_t uid;1534uint32_t gid;1535uint32_t size;1536unsigned char sha1[20];1537uint16_t flags;1538char name[FLEX_ARRAY];/* more */1539};15401541/*1542 * This struct is used when CE_EXTENDED bit is 11543 * The struct must match ondisk_cache_entry exactly from1544 * ctime till flags1545 */1546struct ondisk_cache_entry_extended {1547struct cache_time ctime;1548struct cache_time mtime;1549uint32_t dev;1550uint32_t ino;1551uint32_t mode;1552uint32_t uid;1553uint32_t gid;1554uint32_t size;1555unsigned char sha1[20];1556uint16_t flags;1557uint16_t flags2;1558char name[FLEX_ARRAY];/* more */1559};15601561/* These are only used for v3 or lower */1562#define align_padding_size(size, len) ((size + (len) + 8) & ~7) - (size + len)1563#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1564#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1565#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1566#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1567 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1568 ondisk_cache_entry_size(ce_namelen(ce)))15691570/* Allow fsck to force verification of the index checksum. */1571int verify_index_checksum;15721573/* Allow fsck to force verification of the cache entry order. */1574int verify_ce_order;15751576static intverify_hdr(struct cache_header *hdr,unsigned long size)1577{1578 git_hash_ctx c;1579unsigned char hash[GIT_MAX_RAWSZ];1580int hdr_version;15811582if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1583returnerror("bad signature");1584 hdr_version =ntohl(hdr->hdr_version);1585if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1586returnerror("bad index version%d", hdr_version);15871588if(!verify_index_checksum)1589return0;15901591 the_hash_algo->init_fn(&c);1592 the_hash_algo->update_fn(&c, hdr, size - the_hash_algo->rawsz);1593 the_hash_algo->final_fn(hash, &c);1594if(hashcmp(hash, (unsigned char*)hdr + size - the_hash_algo->rawsz))1595returnerror("bad index file sha1 signature");1596return0;1597}15981599static intread_index_extension(struct index_state *istate,1600const char*ext,void*data,unsigned long sz)1601{1602switch(CACHE_EXT(ext)) {1603case CACHE_EXT_TREE:1604 istate->cache_tree =cache_tree_read(data, sz);1605break;1606case CACHE_EXT_RESOLVE_UNDO:1607 istate->resolve_undo =resolve_undo_read(data, sz);1608break;1609case CACHE_EXT_LINK:1610if(read_link_extension(istate, data, sz))1611return-1;1612break;1613case CACHE_EXT_UNTRACKED:1614 istate->untracked =read_untracked_extension(data, sz);1615break;1616case CACHE_EXT_FSMONITOR:1617read_fsmonitor_extension(istate, data, sz);1618break;1619default:1620if(*ext <'A'||'Z'< *ext)1621returnerror("index uses %.4s extension, which we do not understand",1622 ext);1623fprintf(stderr,"ignoring %.4s extension\n", ext);1624break;1625}1626return0;1627}16281629inthold_locked_index(struct lock_file *lk,int lock_flags)1630{1631returnhold_lock_file_for_update(lk,get_index_file(), lock_flags);1632}16331634intread_index(struct index_state *istate)1635{1636returnread_index_from(istate,get_index_file(),get_git_dir());1637}16381639static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1640unsigned int flags,1641const char*name,1642size_t len)1643{1644struct cache_entry *ce =xmalloc(cache_entry_size(len));16451646 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1647 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1648 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1649 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1650 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1651 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1652 ce->ce_mode =get_be32(&ondisk->mode);1653 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1654 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1655 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1656 ce->ce_flags = flags & ~CE_NAMEMASK;1657 ce->ce_namelen = len;1658 ce->index =0;1659hashcpy(ce->oid.hash, ondisk->sha1);1660memcpy(ce->name, name, len);1661 ce->name[len] ='\0';1662return ce;1663}16641665/*1666 * Adjacent cache entries tend to share the leading paths, so it makes1667 * sense to only store the differences in later entries. In the v41668 * on-disk format of the index, each on-disk cache entry stores the1669 * number of bytes to be stripped from the end of the previous name,1670 * and the bytes to append to the result, to come up with its name.1671 */1672static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1673{1674const unsigned char*ep, *cp = (const unsigned char*)cp_;1675size_t len =decode_varint(&cp);16761677if(name->len < len)1678die("malformed name field in the index");1679strbuf_remove(name, name->len - len, len);1680for(ep = cp; *ep; ep++)1681;/* find the end */1682strbuf_add(name, cp, ep - cp);1683return(const char*)ep +1- cp_;1684}16851686static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1687unsigned long*ent_size,1688struct strbuf *previous_name)1689{1690struct cache_entry *ce;1691size_t len;1692const char*name;1693unsigned int flags;16941695/* On-disk flags are just 16 bits */1696 flags =get_be16(&ondisk->flags);1697 len = flags & CE_NAMEMASK;16981699if(flags & CE_EXTENDED) {1700struct ondisk_cache_entry_extended *ondisk2;1701int extended_flags;1702 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1703 extended_flags =get_be16(&ondisk2->flags2) <<16;1704/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1705if(extended_flags & ~CE_EXTENDED_FLAGS)1706die("Unknown index entry format%08x", extended_flags);1707 flags |= extended_flags;1708 name = ondisk2->name;1709}1710else1711 name = ondisk->name;17121713if(!previous_name) {1714/* v3 and earlier */1715if(len == CE_NAMEMASK)1716 len =strlen(name);1717 ce =cache_entry_from_ondisk(ondisk, flags, name, len);17181719*ent_size =ondisk_ce_size(ce);1720}else{1721unsigned long consumed;1722 consumed =expand_name_field(previous_name, name);1723 ce =cache_entry_from_ondisk(ondisk, flags,1724 previous_name->buf,1725 previous_name->len);17261727*ent_size = (name - ((char*)ondisk)) + consumed;1728}1729return ce;1730}17311732static voidcheck_ce_order(struct index_state *istate)1733{1734unsigned int i;17351736if(!verify_ce_order)1737return;17381739for(i =1; i < istate->cache_nr; i++) {1740struct cache_entry *ce = istate->cache[i -1];1741struct cache_entry *next_ce = istate->cache[i];1742int name_compare =strcmp(ce->name, next_ce->name);17431744if(0< name_compare)1745die("unordered stage entries in index");1746if(!name_compare) {1747if(!ce_stage(ce))1748die("multiple stage entries for merged file '%s'",1749 ce->name);1750if(ce_stage(ce) >ce_stage(next_ce))1751die("unordered stage entries for '%s'",1752 ce->name);1753}1754}1755}17561757static voidtweak_untracked_cache(struct index_state *istate)1758{1759switch(git_config_get_untracked_cache()) {1760case-1:/* keep: do nothing */1761break;1762case0:/* false */1763remove_untracked_cache(istate);1764break;1765case1:/* true */1766add_untracked_cache(istate);1767break;1768default:/* unknown value: do nothing */1769break;1770}1771}17721773static voidtweak_split_index(struct index_state *istate)1774{1775switch(git_config_get_split_index()) {1776case-1:/* unset: do nothing */1777break;1778case0:/* false */1779remove_split_index(istate);1780break;1781case1:/* true */1782add_split_index(istate);1783break;1784default:/* unknown value: do nothing */1785break;1786}1787}17881789static voidpost_read_index_from(struct index_state *istate)1790{1791check_ce_order(istate);1792tweak_untracked_cache(istate);1793tweak_split_index(istate);1794tweak_fsmonitor(istate);1795}17961797/* remember to discard_cache() before reading a different cache! */1798intdo_read_index(struct index_state *istate,const char*path,int must_exist)1799{1800int fd, i;1801struct stat st;1802unsigned long src_offset;1803struct cache_header *hdr;1804void*mmap;1805size_t mmap_size;1806struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;18071808if(istate->initialized)1809return istate->cache_nr;18101811 istate->timestamp.sec =0;1812 istate->timestamp.nsec =0;1813 fd =open(path, O_RDONLY);1814if(fd <0) {1815if(!must_exist && errno == ENOENT)1816return0;1817die_errno("%s: index file open failed", path);1818}18191820if(fstat(fd, &st))1821die_errno("cannot stat the open index");18221823 mmap_size =xsize_t(st.st_size);1824if(mmap_size <sizeof(struct cache_header) + the_hash_algo->rawsz)1825die("index file smaller than expected");18261827 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);1828if(mmap == MAP_FAILED)1829die_errno("unable to map index file");1830close(fd);18311832 hdr = mmap;1833if(verify_hdr(hdr, mmap_size) <0)1834goto unmap;18351836hashcpy(istate->sha1, (const unsigned char*)hdr + mmap_size - the_hash_algo->rawsz);1837 istate->version =ntohl(hdr->hdr_version);1838 istate->cache_nr =ntohl(hdr->hdr_entries);1839 istate->cache_alloc =alloc_nr(istate->cache_nr);1840 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1841 istate->initialized =1;18421843if(istate->version ==4)1844 previous_name = &previous_name_buf;1845else1846 previous_name = NULL;18471848 src_offset =sizeof(*hdr);1849for(i =0; i < istate->cache_nr; i++) {1850struct ondisk_cache_entry *disk_ce;1851struct cache_entry *ce;1852unsigned long consumed;18531854 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1855 ce =create_from_disk(disk_ce, &consumed, previous_name);1856set_index_entry(istate, i, ce);18571858 src_offset += consumed;1859}1860strbuf_release(&previous_name_buf);1861 istate->timestamp.sec = st.st_mtime;1862 istate->timestamp.nsec =ST_MTIME_NSEC(st);18631864while(src_offset <= mmap_size - the_hash_algo->rawsz -8) {1865/* After an array of active_nr index entries,1866 * there can be arbitrary number of extended1867 * sections, each of which is prefixed with1868 * extension name (4-byte) and section length1869 * in 4-byte network byte order.1870 */1871uint32_t extsize;1872memcpy(&extsize, (char*)mmap + src_offset +4,4);1873 extsize =ntohl(extsize);1874if(read_index_extension(istate,1875(const char*) mmap + src_offset,1876(char*) mmap + src_offset +8,1877 extsize) <0)1878goto unmap;1879 src_offset +=8;1880 src_offset += extsize;1881}1882munmap(mmap, mmap_size);1883return istate->cache_nr;18841885unmap:1886munmap(mmap, mmap_size);1887die("index file corrupt");1888}18891890/*1891 * Signal that the shared index is used by updating its mtime.1892 *1893 * This way, shared index can be removed if they have not been used1894 * for some time.1895 */1896static voidfreshen_shared_index(const char*shared_index,int warn)1897{1898if(!check_and_freshen_file(shared_index,1) && warn)1899warning("could not freshen shared index '%s'", shared_index);1900}19011902intread_index_from(struct index_state *istate,const char*path,1903const char*gitdir)1904{1905uint64_t start =getnanotime();1906struct split_index *split_index;1907int ret;1908char*base_sha1_hex;1909char*base_path;19101911/* istate->initialized covers both .git/index and .git/sharedindex.xxx */1912if(istate->initialized)1913return istate->cache_nr;19141915 ret =do_read_index(istate, path,0);1916trace_performance_since(start,"read cache%s", path);19171918 split_index = istate->split_index;1919if(!split_index ||is_null_sha1(split_index->base_sha1)) {1920post_read_index_from(istate);1921return ret;1922}19231924if(split_index->base)1925discard_index(split_index->base);1926else1927 split_index->base =xcalloc(1,sizeof(*split_index->base));19281929 base_sha1_hex =sha1_to_hex(split_index->base_sha1);1930 base_path =xstrfmt("%s/sharedindex.%s", gitdir, base_sha1_hex);1931 ret =do_read_index(split_index->base, base_path,1);1932if(hashcmp(split_index->base_sha1, split_index->base->sha1))1933die("broken index, expect%sin%s, got%s",1934 base_sha1_hex, base_path,1935sha1_to_hex(split_index->base->sha1));19361937freshen_shared_index(base_path,0);1938merge_base_index(istate);1939post_read_index_from(istate);1940trace_performance_since(start,"read cache%s", base_path);1941free(base_path);1942return ret;1943}19441945intis_index_unborn(struct index_state *istate)1946{1947return(!istate->cache_nr && !istate->timestamp.sec);1948}19491950intdiscard_index(struct index_state *istate)1951{1952int i;19531954for(i =0; i < istate->cache_nr; i++) {1955if(istate->cache[i]->index &&1956 istate->split_index &&1957 istate->split_index->base &&1958 istate->cache[i]->index <= istate->split_index->base->cache_nr &&1959 istate->cache[i] == istate->split_index->base->cache[istate->cache[i]->index -1])1960continue;1961free(istate->cache[i]);1962}1963resolve_undo_clear_index(istate);1964 istate->cache_nr =0;1965 istate->cache_changed =0;1966 istate->timestamp.sec =0;1967 istate->timestamp.nsec =0;1968free_name_hash(istate);1969cache_tree_free(&(istate->cache_tree));1970 istate->initialized =0;1971FREE_AND_NULL(istate->cache);1972 istate->cache_alloc =0;1973discard_split_index(istate);1974free_untracked_cache(istate->untracked);1975 istate->untracked = NULL;1976return0;1977}19781979intunmerged_index(const struct index_state *istate)1980{1981int i;1982for(i =0; i < istate->cache_nr; i++) {1983if(ce_stage(istate->cache[i]))1984return1;1985}1986return0;1987}19881989intindex_has_changes(const struct index_state *istate,struct strbuf *sb)1990{1991struct object_id head;1992int i;19931994if(istate != &the_index) {1995BUG("index_has_changes cannot yet accept istate != &the_index; do_diff_cache needs updating first.");1996}1997if(!get_oid_tree("HEAD", &head)) {1998struct diff_options opt;19992000diff_setup(&opt);2001 opt.flags.exit_with_status =1;2002if(!sb)2003 opt.flags.quick =1;2004do_diff_cache(&head, &opt);2005diffcore_std(&opt);2006for(i =0; sb && i < diff_queued_diff.nr; i++) {2007if(i)2008strbuf_addch(sb,' ');2009strbuf_addstr(sb, diff_queued_diff.queue[i]->two->path);2010}2011diff_flush(&opt);2012return opt.flags.has_changes !=0;2013}else{2014for(i =0; sb && i < istate->cache_nr; i++) {2015if(i)2016strbuf_addch(sb,' ');2017strbuf_addstr(sb, istate->cache[i]->name);2018}2019return!!istate->cache_nr;2020}2021}20222023#define WRITE_BUFFER_SIZE 81922024static unsigned char write_buffer[WRITE_BUFFER_SIZE];2025static unsigned long write_buffer_len;20262027static intce_write_flush(git_hash_ctx *context,int fd)2028{2029unsigned int buffered = write_buffer_len;2030if(buffered) {2031 the_hash_algo->update_fn(context, write_buffer, buffered);2032if(write_in_full(fd, write_buffer, buffered) <0)2033return-1;2034 write_buffer_len =0;2035}2036return0;2037}20382039static intce_write(git_hash_ctx *context,int fd,void*data,unsigned int len)2040{2041while(len) {2042unsigned int buffered = write_buffer_len;2043unsigned int partial = WRITE_BUFFER_SIZE - buffered;2044if(partial > len)2045 partial = len;2046memcpy(write_buffer + buffered, data, partial);2047 buffered += partial;2048if(buffered == WRITE_BUFFER_SIZE) {2049 write_buffer_len = buffered;2050if(ce_write_flush(context, fd))2051return-1;2052 buffered =0;2053}2054 write_buffer_len = buffered;2055 len -= partial;2056 data = (char*) data + partial;2057}2058return0;2059}20602061static intwrite_index_ext_header(git_hash_ctx *context,int fd,2062unsigned int ext,unsigned int sz)2063{2064 ext =htonl(ext);2065 sz =htonl(sz);2066return((ce_write(context, fd, &ext,4) <0) ||2067(ce_write(context, fd, &sz,4) <0)) ? -1:0;2068}20692070static intce_flush(git_hash_ctx *context,int fd,unsigned char*hash)2071{2072unsigned int left = write_buffer_len;20732074if(left) {2075 write_buffer_len =0;2076 the_hash_algo->update_fn(context, write_buffer, left);2077}20782079/* Flush first if not enough space for hash signature */2080if(left + the_hash_algo->rawsz > WRITE_BUFFER_SIZE) {2081if(write_in_full(fd, write_buffer, left) <0)2082return-1;2083 left =0;2084}20852086/* Append the hash signature at the end */2087 the_hash_algo->final_fn(write_buffer + left, context);2088hashcpy(hash, write_buffer + left);2089 left += the_hash_algo->rawsz;2090return(write_in_full(fd, write_buffer, left) <0) ? -1:0;2091}20922093static voidce_smudge_racily_clean_entry(struct cache_entry *ce)2094{2095/*2096 * The only thing we care about in this function is to smudge the2097 * falsely clean entry due to touch-update-touch race, so we leave2098 * everything else as they are. We are called for entries whose2099 * ce_stat_data.sd_mtime match the index file mtime.2100 *2101 * Note that this actually does not do much for gitlinks, for2102 * which ce_match_stat_basic() always goes to the actual2103 * contents. The caller checks with is_racy_timestamp() which2104 * always says "no" for gitlinks, so we are not called for them ;-)2105 */2106struct stat st;21072108if(lstat(ce->name, &st) <0)2109return;2110if(ce_match_stat_basic(ce, &st))2111return;2112if(ce_modified_check_fs(ce, &st)) {2113/* This is "racily clean"; smudge it. Note that this2114 * is a tricky code. At first glance, it may appear2115 * that it can break with this sequence:2116 *2117 * $ echo xyzzy >frotz2118 * $ git-update-index --add frotz2119 * $ : >frotz2120 * $ sleep 32121 * $ echo filfre >nitfol2122 * $ git-update-index --add nitfol2123 *2124 * but it does not. When the second update-index runs,2125 * it notices that the entry "frotz" has the same timestamp2126 * as index, and if we were to smudge it by resetting its2127 * size to zero here, then the object name recorded2128 * in index is the 6-byte file but the cached stat information2129 * becomes zero --- which would then match what we would2130 * obtain from the filesystem next time we stat("frotz").2131 *2132 * However, the second update-index, before calling2133 * this function, notices that the cached size is 62134 * bytes and what is on the filesystem is an empty2135 * file, and never calls us, so the cached size information2136 * for "frotz" stays 6 which does not match the filesystem.2137 */2138 ce->ce_stat_data.sd_size =0;2139}2140}21412142/* Copy miscellaneous fields but not the name */2143static voidcopy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,2144struct cache_entry *ce)2145{2146short flags;21472148 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);2149 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);2150 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);2151 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);2152 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);2153 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);2154 ondisk->mode =htonl(ce->ce_mode);2155 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);2156 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);2157 ondisk->size =htonl(ce->ce_stat_data.sd_size);2158hashcpy(ondisk->sha1, ce->oid.hash);21592160 flags = ce->ce_flags & ~CE_NAMEMASK;2161 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));2162 ondisk->flags =htons(flags);2163if(ce->ce_flags & CE_EXTENDED) {2164struct ondisk_cache_entry_extended *ondisk2;2165 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;2166 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);2167}2168}21692170static intce_write_entry(git_hash_ctx *c,int fd,struct cache_entry *ce,2171struct strbuf *previous_name,struct ondisk_cache_entry *ondisk)2172{2173int size;2174int result;2175unsigned int saved_namelen;2176int stripped_name =0;2177static unsigned char padding[8] = {0x00};21782179if(ce->ce_flags & CE_STRIP_NAME) {2180 saved_namelen =ce_namelen(ce);2181 ce->ce_namelen =0;2182 stripped_name =1;2183}21842185if(ce->ce_flags & CE_EXTENDED)2186 size =offsetof(struct ondisk_cache_entry_extended, name);2187else2188 size =offsetof(struct ondisk_cache_entry, name);21892190if(!previous_name) {2191int len =ce_namelen(ce);2192copy_cache_entry_to_ondisk(ondisk, ce);2193 result =ce_write(c, fd, ondisk, size);2194if(!result)2195 result =ce_write(c, fd, ce->name, len);2196if(!result)2197 result =ce_write(c, fd, padding,align_padding_size(size, len));2198}else{2199int common, to_remove, prefix_size;2200unsigned char to_remove_vi[16];2201for(common =0;2202(ce->name[common] &&2203 common < previous_name->len &&2204 ce->name[common] == previous_name->buf[common]);2205 common++)2206;/* still matching */2207 to_remove = previous_name->len - common;2208 prefix_size =encode_varint(to_remove, to_remove_vi);22092210copy_cache_entry_to_ondisk(ondisk, ce);2211 result =ce_write(c, fd, ondisk, size);2212if(!result)2213 result =ce_write(c, fd, to_remove_vi, prefix_size);2214if(!result)2215 result =ce_write(c, fd, ce->name + common,ce_namelen(ce) - common);2216if(!result)2217 result =ce_write(c, fd, padding,1);22182219strbuf_splice(previous_name, common, to_remove,2220 ce->name + common,ce_namelen(ce) - common);2221}2222if(stripped_name) {2223 ce->ce_namelen = saved_namelen;2224 ce->ce_flags &= ~CE_STRIP_NAME;2225}22262227return result;2228}22292230/*2231 * This function verifies if index_state has the correct sha1 of the2232 * index file. Don't die if we have any other failure, just return 0.2233 */2234static intverify_index_from(const struct index_state *istate,const char*path)2235{2236int fd;2237 ssize_t n;2238struct stat st;2239unsigned char hash[GIT_MAX_RAWSZ];22402241if(!istate->initialized)2242return0;22432244 fd =open(path, O_RDONLY);2245if(fd <0)2246return0;22472248if(fstat(fd, &st))2249goto out;22502251if(st.st_size <sizeof(struct cache_header) + the_hash_algo->rawsz)2252goto out;22532254 n =pread_in_full(fd, hash, the_hash_algo->rawsz, st.st_size - the_hash_algo->rawsz);2255if(n != the_hash_algo->rawsz)2256goto out;22572258if(hashcmp(istate->sha1, hash))2259goto out;22602261close(fd);2262return1;22632264out:2265close(fd);2266return0;2267}22682269static intverify_index(const struct index_state *istate)2270{2271returnverify_index_from(istate,get_index_file());2272}22732274static inthas_racy_timestamp(struct index_state *istate)2275{2276int entries = istate->cache_nr;2277int i;22782279for(i =0; i < entries; i++) {2280struct cache_entry *ce = istate->cache[i];2281if(is_racy_timestamp(istate, ce))2282return1;2283}2284return0;2285}22862287voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2288{2289if((istate->cache_changed ||has_racy_timestamp(istate)) &&2290verify_index(istate))2291write_locked_index(istate, lockfile, COMMIT_LOCK);2292else2293rollback_lock_file(lockfile);2294}22952296/*2297 * On success, `tempfile` is closed. If it is the temporary file2298 * of a `struct lock_file`, we will therefore effectively perform2299 * a 'close_lock_file_gently()`. Since that is an implementation2300 * detail of lockfiles, callers of `do_write_index()` should not2301 * rely on it.2302 */2303static intdo_write_index(struct index_state *istate,struct tempfile *tempfile,2304int strip_extensions)2305{2306uint64_t start =getnanotime();2307int newfd = tempfile->fd;2308 git_hash_ctx c;2309struct cache_header hdr;2310int i, err =0, removed, extended, hdr_version;2311struct cache_entry **cache = istate->cache;2312int entries = istate->cache_nr;2313struct stat st;2314struct ondisk_cache_entry_extended ondisk;2315struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;2316int drop_cache_tree = istate->drop_cache_tree;23172318for(i = removed = extended =0; i < entries; i++) {2319if(cache[i]->ce_flags & CE_REMOVE)2320 removed++;23212322/* reduce extended entries if possible */2323 cache[i]->ce_flags &= ~CE_EXTENDED;2324if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2325 extended++;2326 cache[i]->ce_flags |= CE_EXTENDED;2327}2328}23292330if(!istate->version) {2331 istate->version =get_index_format_default();2332if(getenv("GIT_TEST_SPLIT_INDEX"))2333init_split_index(istate);2334}23352336/* demote version 3 to version 2 when the latter suffices */2337if(istate->version ==3|| istate->version ==2)2338 istate->version = extended ?3:2;23392340 hdr_version = istate->version;23412342 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2343 hdr.hdr_version =htonl(hdr_version);2344 hdr.hdr_entries =htonl(entries - removed);23452346 the_hash_algo->init_fn(&c);2347if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2348return-1;23492350 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;23512352for(i =0; i < entries; i++) {2353struct cache_entry *ce = cache[i];2354if(ce->ce_flags & CE_REMOVE)2355continue;2356if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2357ce_smudge_racily_clean_entry(ce);2358if(is_null_oid(&ce->oid)) {2359static const char msg[] ="cache entry has null sha1:%s";2360static int allow = -1;23612362if(allow <0)2363 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2364if(allow)2365warning(msg, ce->name);2366else2367 err =error(msg, ce->name);23682369 drop_cache_tree =1;2370}2371if(ce_write_entry(&c, newfd, ce, previous_name, (struct ondisk_cache_entry *)&ondisk) <0)2372 err = -1;23732374if(err)2375break;2376}2377strbuf_release(&previous_name_buf);23782379if(err)2380return err;23812382/* Write extension data here */2383if(!strip_extensions && istate->split_index) {2384struct strbuf sb = STRBUF_INIT;23852386 err =write_link_extension(&sb, istate) <0||2387write_index_ext_header(&c, newfd, CACHE_EXT_LINK,2388 sb.len) <0||2389ce_write(&c, newfd, sb.buf, sb.len) <0;2390strbuf_release(&sb);2391if(err)2392return-1;2393}2394if(!strip_extensions && !drop_cache_tree && istate->cache_tree) {2395struct strbuf sb = STRBUF_INIT;23962397cache_tree_write(&sb, istate->cache_tree);2398 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <02399||ce_write(&c, newfd, sb.buf, sb.len) <0;2400strbuf_release(&sb);2401if(err)2402return-1;2403}2404if(!strip_extensions && istate->resolve_undo) {2405struct strbuf sb = STRBUF_INIT;24062407resolve_undo_write(&sb, istate->resolve_undo);2408 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,2409 sb.len) <02410||ce_write(&c, newfd, sb.buf, sb.len) <0;2411strbuf_release(&sb);2412if(err)2413return-1;2414}2415if(!strip_extensions && istate->untracked) {2416struct strbuf sb = STRBUF_INIT;24172418write_untracked_extension(&sb, istate->untracked);2419 err =write_index_ext_header(&c, newfd, CACHE_EXT_UNTRACKED,2420 sb.len) <0||2421ce_write(&c, newfd, sb.buf, sb.len) <0;2422strbuf_release(&sb);2423if(err)2424return-1;2425}2426if(!strip_extensions && istate->fsmonitor_last_update) {2427struct strbuf sb = STRBUF_INIT;24282429write_fsmonitor_extension(&sb, istate);2430 err =write_index_ext_header(&c, newfd, CACHE_EXT_FSMONITOR, sb.len) <02431||ce_write(&c, newfd, sb.buf, sb.len) <0;2432strbuf_release(&sb);2433if(err)2434return-1;2435}24362437if(ce_flush(&c, newfd, istate->sha1))2438return-1;2439if(close_tempfile_gently(tempfile)) {2440error(_("could not close '%s'"), tempfile->filename.buf);2441return-1;2442}2443if(stat(tempfile->filename.buf, &st))2444return-1;2445 istate->timestamp.sec = (unsigned int)st.st_mtime;2446 istate->timestamp.nsec =ST_MTIME_NSEC(st);2447trace_performance_since(start,"write index, changed mask =%x", istate->cache_changed);2448return0;2449}24502451voidset_alternate_index_output(const char*name)2452{2453 alternate_index_output = name;2454}24552456static intcommit_locked_index(struct lock_file *lk)2457{2458if(alternate_index_output)2459returncommit_lock_file_to(lk, alternate_index_output);2460else2461returncommit_lock_file(lk);2462}24632464static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2465unsigned flags)2466{2467int ret =do_write_index(istate, lock->tempfile,0);2468if(ret)2469return ret;2470if(flags & COMMIT_LOCK)2471returncommit_locked_index(lock);2472returnclose_lock_file_gently(lock);2473}24742475static intwrite_split_index(struct index_state *istate,2476struct lock_file *lock,2477unsigned flags)2478{2479int ret;2480prepare_to_write_split_index(istate);2481 ret =do_write_locked_index(istate, lock, flags);2482finish_writing_split_index(istate);2483return ret;2484}24852486static const char*shared_index_expire ="2.weeks.ago";24872488static unsigned longget_shared_index_expire_date(void)2489{2490static unsigned long shared_index_expire_date;2491static int shared_index_expire_date_prepared;24922493if(!shared_index_expire_date_prepared) {2494git_config_get_expiry("splitindex.sharedindexexpire",2495&shared_index_expire);2496 shared_index_expire_date =approxidate(shared_index_expire);2497 shared_index_expire_date_prepared =1;2498}24992500return shared_index_expire_date;2501}25022503static intshould_delete_shared_index(const char*shared_index_path)2504{2505struct stat st;2506unsigned long expiration;25072508/* Check timestamp */2509 expiration =get_shared_index_expire_date();2510if(!expiration)2511return0;2512if(stat(shared_index_path, &st))2513returnerror_errno(_("could not stat '%s'"), shared_index_path);2514if(st.st_mtime > expiration)2515return0;25162517return1;2518}25192520static intclean_shared_index_files(const char*current_hex)2521{2522struct dirent *de;2523DIR*dir =opendir(get_git_dir());25242525if(!dir)2526returnerror_errno(_("unable to open git dir:%s"),get_git_dir());25272528while((de =readdir(dir)) != NULL) {2529const char*sha1_hex;2530const char*shared_index_path;2531if(!skip_prefix(de->d_name,"sharedindex.", &sha1_hex))2532continue;2533if(!strcmp(sha1_hex, current_hex))2534continue;2535 shared_index_path =git_path("%s", de->d_name);2536if(should_delete_shared_index(shared_index_path) >0&&2537unlink(shared_index_path))2538warning_errno(_("unable to unlink:%s"), shared_index_path);2539}2540closedir(dir);25412542return0;2543}25442545static intwrite_shared_index(struct index_state *istate,2546struct tempfile **temp)2547{2548struct split_index *si = istate->split_index;2549int ret;25502551move_cache_to_base_index(istate);2552 ret =do_write_index(si->base, *temp,1);2553if(ret)2554return ret;2555 ret =adjust_shared_perm(get_tempfile_path(*temp));2556if(ret) {2557error("cannot fix permission bits on%s",get_tempfile_path(*temp));2558return ret;2559}2560 ret =rename_tempfile(temp,2561git_path("sharedindex.%s",sha1_to_hex(si->base->sha1)));2562if(!ret) {2563hashcpy(si->base_sha1, si->base->sha1);2564clean_shared_index_files(sha1_to_hex(si->base->sha1));2565}25662567return ret;2568}25692570static const int default_max_percent_split_change =20;25712572static inttoo_many_not_shared_entries(struct index_state *istate)2573{2574int i, not_shared =0;2575int max_split =git_config_get_max_percent_split_change();25762577switch(max_split) {2578case-1:2579/* not or badly configured: use the default value */2580 max_split = default_max_percent_split_change;2581break;2582case0:2583return1;/* 0% means always write a new shared index */2584case100:2585return0;/* 100% means never write a new shared index */2586default:2587break;/* just use the configured value */2588}25892590/* Count not shared entries */2591for(i =0; i < istate->cache_nr; i++) {2592struct cache_entry *ce = istate->cache[i];2593if(!ce->index)2594 not_shared++;2595}25962597return(int64_t)istate->cache_nr * max_split < (int64_t)not_shared *100;2598}25992600intwrite_locked_index(struct index_state *istate,struct lock_file *lock,2601unsigned flags)2602{2603int new_shared_index, ret;2604struct split_index *si = istate->split_index;26052606if((flags & SKIP_IF_UNCHANGED) && !istate->cache_changed) {2607if(flags & COMMIT_LOCK)2608rollback_lock_file(lock);2609return0;2610}26112612if(istate->fsmonitor_last_update)2613fill_fsmonitor_bitmap(istate);26142615if(!si || alternate_index_output ||2616(istate->cache_changed & ~EXTMASK)) {2617if(si)2618hashclr(si->base_sha1);2619 ret =do_write_locked_index(istate, lock, flags);2620goto out;2621}26222623if(getenv("GIT_TEST_SPLIT_INDEX")) {2624int v = si->base_sha1[0];2625if((v &15) <6)2626 istate->cache_changed |= SPLIT_INDEX_ORDERED;2627}2628if(too_many_not_shared_entries(istate))2629 istate->cache_changed |= SPLIT_INDEX_ORDERED;26302631 new_shared_index = istate->cache_changed & SPLIT_INDEX_ORDERED;26322633if(new_shared_index) {2634struct tempfile *temp;2635int saved_errno;26362637 temp =mks_tempfile(git_path("sharedindex_XXXXXX"));2638if(!temp) {2639hashclr(si->base_sha1);2640 ret =do_write_locked_index(istate, lock, flags);2641goto out;2642}2643 ret =write_shared_index(istate, &temp);26442645 saved_errno = errno;2646if(is_tempfile_active(temp))2647delete_tempfile(&temp);2648 errno = saved_errno;26492650if(ret)2651goto out;2652}26532654 ret =write_split_index(istate, lock, flags);26552656/* Freshen the shared index only if the split-index was written */2657if(!ret && !new_shared_index) {2658const char*shared_index =git_path("sharedindex.%s",2659sha1_to_hex(si->base_sha1));2660freshen_shared_index(shared_index,1);2661}26622663out:2664if(flags & COMMIT_LOCK)2665rollback_lock_file(lock);2666return ret;2667}26682669/*2670 * Read the index file that is potentially unmerged into given2671 * index_state, dropping any unmerged entries. Returns true if2672 * the index is unmerged. Callers who want to refuse to work2673 * from an unmerged state can call this and check its return value,2674 * instead of calling read_cache().2675 */2676intread_index_unmerged(struct index_state *istate)2677{2678int i;2679int unmerged =0;26802681read_index(istate);2682for(i =0; i < istate->cache_nr; i++) {2683struct cache_entry *ce = istate->cache[i];2684struct cache_entry *new_ce;2685int size, len;26862687if(!ce_stage(ce))2688continue;2689 unmerged =1;2690 len =ce_namelen(ce);2691 size =cache_entry_size(len);2692 new_ce =xcalloc(1, size);2693memcpy(new_ce->name, ce->name, len);2694 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;2695 new_ce->ce_namelen = len;2696 new_ce->ce_mode = ce->ce_mode;2697if(add_index_entry(istate, new_ce,0))2698returnerror("%s: cannot drop to stage #0",2699 new_ce->name);2700}2701return unmerged;2702}27032704/*2705 * Returns 1 if the path is an "other" path with respect to2706 * the index; that is, the path is not mentioned in the index at all,2707 * either as a file, a directory with some files in the index,2708 * or as an unmerged entry.2709 *2710 * We helpfully remove a trailing "/" from directories so that2711 * the output of read_directory can be used as-is.2712 */2713intindex_name_is_other(const struct index_state *istate,const char*name,2714int namelen)2715{2716int pos;2717if(namelen && name[namelen -1] =='/')2718 namelen--;2719 pos =index_name_pos(istate, name, namelen);2720if(0<= pos)2721return0;/* exact match */2722 pos = -pos -1;2723if(pos < istate->cache_nr) {2724struct cache_entry *ce = istate->cache[pos];2725if(ce_namelen(ce) == namelen &&2726!memcmp(ce->name, name, namelen))2727return0;/* Yup, this one exists unmerged */2728}2729return1;2730}27312732void*read_blob_data_from_index(const struct index_state *istate,2733const char*path,unsigned long*size)2734{2735int pos, len;2736unsigned long sz;2737enum object_type type;2738void*data;27392740 len =strlen(path);2741 pos =index_name_pos(istate, path, len);2742if(pos <0) {2743/*2744 * We might be in the middle of a merge, in which2745 * case we would read stage #2 (ours).2746 */2747int i;2748for(i = -pos -1;2749(pos <0&& i < istate->cache_nr &&2750!strcmp(istate->cache[i]->name, path));2751 i++)2752if(ce_stage(istate->cache[i]) ==2)2753 pos = i;2754}2755if(pos <0)2756return NULL;2757 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz);2758if(!data || type != OBJ_BLOB) {2759free(data);2760return NULL;2761}2762if(size)2763*size = sz;2764return data;2765}27662767voidstat_validity_clear(struct stat_validity *sv)2768{2769FREE_AND_NULL(sv->sd);2770}27712772intstat_validity_check(struct stat_validity *sv,const char*path)2773{2774struct stat st;27752776if(stat(path, &st) <0)2777return sv->sd == NULL;2778if(!sv->sd)2779return0;2780returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2781}27822783voidstat_validity_update(struct stat_validity *sv,int fd)2784{2785struct stat st;27862787if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2788stat_validity_clear(sv);2789else{2790if(!sv->sd)2791 sv->sd =xcalloc(1,sizeof(struct stat_data));2792fill_stat_data(sv->sd, &st);2793}2794}27952796voidmove_index_extensions(struct index_state *dst,struct index_state *src)2797{2798 dst->untracked = src->untracked;2799 src->untracked = NULL;2800}