1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#define NO_THE_INDEX_COMPATIBILITY_MACROS 7#include"cache.h" 8#include"config.h" 9#include"tempfile.h" 10#include"lockfile.h" 11#include"cache-tree.h" 12#include"refs.h" 13#include"dir.h" 14#include"tree.h" 15#include"commit.h" 16#include"blob.h" 17#include"resolve-undo.h" 18#include"strbuf.h" 19#include"varint.h" 20#include"split-index.h" 21#include"utf8.h" 22#include"fsmonitor.h" 23 24/* Mask for the name length in ce_flags in the on-disk index */ 25 26#define CE_NAMEMASK (0x0fff) 27 28/* Index extensions. 29 * 30 * The first letter should be 'A'..'Z' for extensions that are not 31 * necessary for a correct operation (i.e. optimization data). 32 * When new extensions are added that _needs_ to be understood in 33 * order to correctly interpret the index file, pick character that 34 * is outside the range, to cause the reader to abort. 35 */ 36 37#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 38#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 39#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 40#define CACHE_EXT_LINK 0x6c696e6b/* "link" */ 41#define CACHE_EXT_UNTRACKED 0x554E5452/* "UNTR" */ 42#define CACHE_EXT_FSMONITOR 0x46534D4E/* "FSMN" */ 43 44/* changes that can be kept in $GIT_DIR/index (basically all extensions) */ 45#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \ 46 CE_ENTRY_ADDED | CE_ENTRY_REMOVED | CE_ENTRY_CHANGED | \ 47 SPLIT_INDEX_ORDERED | UNTRACKED_CHANGED | FSMONITOR_CHANGED) 48 49struct index_state the_index; 50static const char*alternate_index_output; 51 52static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 53{ 54 istate->cache[nr] = ce; 55add_name_hash(istate, ce); 56} 57 58static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 59{ 60struct cache_entry *old = istate->cache[nr]; 61 62replace_index_entry_in_base(istate, old, ce); 63remove_name_hash(istate, old); 64free(old); 65 ce->ce_flags &= ~CE_HASHED; 66set_index_entry(istate, nr, ce); 67 ce->ce_flags |= CE_UPDATE_IN_BASE; 68mark_fsmonitor_invalid(istate, ce); 69 istate->cache_changed |= CE_ENTRY_CHANGED; 70} 71 72voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 73{ 74struct cache_entry *old = istate->cache[nr], *new; 75int namelen =strlen(new_name); 76 77new=xmalloc(cache_entry_size(namelen)); 78copy_cache_entry(new, old); 79new->ce_flags &= ~CE_HASHED; 80new->ce_namelen = namelen; 81new->index =0; 82memcpy(new->name, new_name, namelen +1); 83 84cache_tree_invalidate_path(istate, old->name); 85untracked_cache_remove_from_index(istate, old->name); 86remove_index_entry_at(istate, nr); 87add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 88} 89 90voidfill_stat_data(struct stat_data *sd,struct stat *st) 91{ 92 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 93 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 94 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 95 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 96 sd->sd_dev = st->st_dev; 97 sd->sd_ino = st->st_ino; 98 sd->sd_uid = st->st_uid; 99 sd->sd_gid = st->st_gid; 100 sd->sd_size = st->st_size; 101} 102 103intmatch_stat_data(const struct stat_data *sd,struct stat *st) 104{ 105int changed =0; 106 107if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 108 changed |= MTIME_CHANGED; 109if(trust_ctime && check_stat && 110 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 111 changed |= CTIME_CHANGED; 112 113#ifdef USE_NSEC 114if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 115 changed |= MTIME_CHANGED; 116if(trust_ctime && check_stat && 117 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 118 changed |= CTIME_CHANGED; 119#endif 120 121if(check_stat) { 122if(sd->sd_uid != (unsigned int) st->st_uid || 123 sd->sd_gid != (unsigned int) st->st_gid) 124 changed |= OWNER_CHANGED; 125if(sd->sd_ino != (unsigned int) st->st_ino) 126 changed |= INODE_CHANGED; 127} 128 129#ifdef USE_STDEV 130/* 131 * st_dev breaks on network filesystems where different 132 * clients will have different views of what "device" 133 * the filesystem is on 134 */ 135if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 136 changed |= INODE_CHANGED; 137#endif 138 139if(sd->sd_size != (unsigned int) st->st_size) 140 changed |= DATA_CHANGED; 141 142return changed; 143} 144 145/* 146 * This only updates the "non-critical" parts of the directory 147 * cache, ie the parts that aren't tracked by GIT, and only used 148 * to validate the cache. 149 */ 150voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 151{ 152fill_stat_data(&ce->ce_stat_data, st); 153 154if(assume_unchanged) 155 ce->ce_flags |= CE_VALID; 156 157if(S_ISREG(st->st_mode)) { 158ce_mark_uptodate(ce); 159mark_fsmonitor_valid(ce); 160} 161} 162 163static intce_compare_data(const struct cache_entry *ce,struct stat *st) 164{ 165int match = -1; 166int fd =git_open_cloexec(ce->name, O_RDONLY); 167 168if(fd >=0) { 169struct object_id oid; 170if(!index_fd(&oid, fd, st, OBJ_BLOB, ce->name,0)) 171 match =oidcmp(&oid, &ce->oid); 172/* index_fd() closed the file descriptor already */ 173} 174return match; 175} 176 177static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 178{ 179int match = -1; 180void*buffer; 181unsigned long size; 182enum object_type type; 183struct strbuf sb = STRBUF_INIT; 184 185if(strbuf_readlink(&sb, ce->name, expected_size)) 186return-1; 187 188 buffer =read_sha1_file(ce->oid.hash, &type, &size); 189if(buffer) { 190if(size == sb.len) 191 match =memcmp(buffer, sb.buf, size); 192free(buffer); 193} 194strbuf_release(&sb); 195return match; 196} 197 198static intce_compare_gitlink(const struct cache_entry *ce) 199{ 200struct object_id oid; 201 202/* 203 * We don't actually require that the .git directory 204 * under GITLINK directory be a valid git directory. It 205 * might even be missing (in case nobody populated that 206 * sub-project). 207 * 208 * If so, we consider it always to match. 209 */ 210if(resolve_gitlink_ref(ce->name,"HEAD", &oid) <0) 211return0; 212returnoidcmp(&oid, &ce->oid); 213} 214 215static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 216{ 217switch(st->st_mode & S_IFMT) { 218case S_IFREG: 219if(ce_compare_data(ce, st)) 220return DATA_CHANGED; 221break; 222case S_IFLNK: 223if(ce_compare_link(ce,xsize_t(st->st_size))) 224return DATA_CHANGED; 225break; 226case S_IFDIR: 227if(S_ISGITLINK(ce->ce_mode)) 228returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 229/* else fallthrough */ 230default: 231return TYPE_CHANGED; 232} 233return0; 234} 235 236static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 237{ 238unsigned int changed =0; 239 240if(ce->ce_flags & CE_REMOVE) 241return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 242 243switch(ce->ce_mode & S_IFMT) { 244case S_IFREG: 245 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 246/* We consider only the owner x bit to be relevant for 247 * "mode changes" 248 */ 249if(trust_executable_bit && 250(0100& (ce->ce_mode ^ st->st_mode))) 251 changed |= MODE_CHANGED; 252break; 253case S_IFLNK: 254if(!S_ISLNK(st->st_mode) && 255(has_symlinks || !S_ISREG(st->st_mode))) 256 changed |= TYPE_CHANGED; 257break; 258case S_IFGITLINK: 259/* We ignore most of the st_xxx fields for gitlinks */ 260if(!S_ISDIR(st->st_mode)) 261 changed |= TYPE_CHANGED; 262else if(ce_compare_gitlink(ce)) 263 changed |= DATA_CHANGED; 264return changed; 265default: 266die("internal error: ce_mode is%o", ce->ce_mode); 267} 268 269 changed |=match_stat_data(&ce->ce_stat_data, st); 270 271/* Racily smudged entry? */ 272if(!ce->ce_stat_data.sd_size) { 273if(!is_empty_blob_sha1(ce->oid.hash)) 274 changed |= DATA_CHANGED; 275} 276 277return changed; 278} 279 280static intis_racy_stat(const struct index_state *istate, 281const struct stat_data *sd) 282{ 283return(istate->timestamp.sec && 284#ifdef USE_NSEC 285/* nanosecond timestamped files can also be racy! */ 286(istate->timestamp.sec < sd->sd_mtime.sec || 287(istate->timestamp.sec == sd->sd_mtime.sec && 288 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 289#else 290 istate->timestamp.sec <= sd->sd_mtime.sec 291#endif 292); 293} 294 295static intis_racy_timestamp(const struct index_state *istate, 296const struct cache_entry *ce) 297{ 298return(!S_ISGITLINK(ce->ce_mode) && 299is_racy_stat(istate, &ce->ce_stat_data)); 300} 301 302intmatch_stat_data_racy(const struct index_state *istate, 303const struct stat_data *sd,struct stat *st) 304{ 305if(is_racy_stat(istate, sd)) 306return MTIME_CHANGED; 307returnmatch_stat_data(sd, st); 308} 309 310intie_match_stat(struct index_state *istate, 311const struct cache_entry *ce,struct stat *st, 312unsigned int options) 313{ 314unsigned int changed; 315int ignore_valid = options & CE_MATCH_IGNORE_VALID; 316int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 317int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 318int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR; 319 320if(!ignore_fsmonitor) 321refresh_fsmonitor(istate); 322/* 323 * If it's marked as always valid in the index, it's 324 * valid whatever the checked-out copy says. 325 * 326 * skip-worktree has the same effect with higher precedence 327 */ 328if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 329return0; 330if(!ignore_valid && (ce->ce_flags & CE_VALID)) 331return0; 332if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) 333return0; 334 335/* 336 * Intent-to-add entries have not been added, so the index entry 337 * by definition never matches what is in the work tree until it 338 * actually gets added. 339 */ 340if(ce_intent_to_add(ce)) 341return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 342 343 changed =ce_match_stat_basic(ce, st); 344 345/* 346 * Within 1 second of this sequence: 347 * echo xyzzy >file && git-update-index --add file 348 * running this command: 349 * echo frotz >file 350 * would give a falsely clean cache entry. The mtime and 351 * length match the cache, and other stat fields do not change. 352 * 353 * We could detect this at update-index time (the cache entry 354 * being registered/updated records the same time as "now") 355 * and delay the return from git-update-index, but that would 356 * effectively mean we can make at most one commit per second, 357 * which is not acceptable. Instead, we check cache entries 358 * whose mtime are the same as the index file timestamp more 359 * carefully than others. 360 */ 361if(!changed &&is_racy_timestamp(istate, ce)) { 362if(assume_racy_is_modified) 363 changed |= DATA_CHANGED; 364else 365 changed |=ce_modified_check_fs(ce, st); 366} 367 368return changed; 369} 370 371intie_modified(struct index_state *istate, 372const struct cache_entry *ce, 373struct stat *st,unsigned int options) 374{ 375int changed, changed_fs; 376 377 changed =ie_match_stat(istate, ce, st, options); 378if(!changed) 379return0; 380/* 381 * If the mode or type has changed, there's no point in trying 382 * to refresh the entry - it's not going to match 383 */ 384if(changed & (MODE_CHANGED | TYPE_CHANGED)) 385return changed; 386 387/* 388 * Immediately after read-tree or update-index --cacheinfo, 389 * the length field is zero, as we have never even read the 390 * lstat(2) information once, and we cannot trust DATA_CHANGED 391 * returned by ie_match_stat() which in turn was returned by 392 * ce_match_stat_basic() to signal that the filesize of the 393 * blob changed. We have to actually go to the filesystem to 394 * see if the contents match, and if so, should answer "unchanged". 395 * 396 * The logic does not apply to gitlinks, as ce_match_stat_basic() 397 * already has checked the actual HEAD from the filesystem in the 398 * subproject. If ie_match_stat() already said it is different, 399 * then we know it is. 400 */ 401if((changed & DATA_CHANGED) && 402(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 403return changed; 404 405 changed_fs =ce_modified_check_fs(ce, st); 406if(changed_fs) 407return changed | changed_fs; 408return0; 409} 410 411intbase_name_compare(const char*name1,int len1,int mode1, 412const char*name2,int len2,int mode2) 413{ 414unsigned char c1, c2; 415int len = len1 < len2 ? len1 : len2; 416int cmp; 417 418 cmp =memcmp(name1, name2, len); 419if(cmp) 420return cmp; 421 c1 = name1[len]; 422 c2 = name2[len]; 423if(!c1 &&S_ISDIR(mode1)) 424 c1 ='/'; 425if(!c2 &&S_ISDIR(mode2)) 426 c2 ='/'; 427return(c1 < c2) ? -1: (c1 > c2) ?1:0; 428} 429 430/* 431 * df_name_compare() is identical to base_name_compare(), except it 432 * compares conflicting directory/file entries as equal. Note that 433 * while a directory name compares as equal to a regular file, they 434 * then individually compare _differently_ to a filename that has 435 * a dot after the basename (because '\0' < '.' < '/'). 436 * 437 * This is used by routines that want to traverse the git namespace 438 * but then handle conflicting entries together when possible. 439 */ 440intdf_name_compare(const char*name1,int len1,int mode1, 441const char*name2,int len2,int mode2) 442{ 443int len = len1 < len2 ? len1 : len2, cmp; 444unsigned char c1, c2; 445 446 cmp =memcmp(name1, name2, len); 447if(cmp) 448return cmp; 449/* Directories and files compare equal (same length, same name) */ 450if(len1 == len2) 451return0; 452 c1 = name1[len]; 453if(!c1 &&S_ISDIR(mode1)) 454 c1 ='/'; 455 c2 = name2[len]; 456if(!c2 &&S_ISDIR(mode2)) 457 c2 ='/'; 458if(c1 =='/'&& !c2) 459return0; 460if(c2 =='/'&& !c1) 461return0; 462return c1 - c2; 463} 464 465intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 466{ 467size_t min_len = (len1 < len2) ? len1 : len2; 468int cmp =memcmp(name1, name2, min_len); 469if(cmp) 470return cmp; 471if(len1 < len2) 472return-1; 473if(len1 > len2) 474return1; 475return0; 476} 477 478intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 479{ 480int cmp; 481 482 cmp =name_compare(name1, len1, name2, len2); 483if(cmp) 484return cmp; 485 486if(stage1 < stage2) 487return-1; 488if(stage1 > stage2) 489return1; 490return0; 491} 492 493static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 494{ 495int first, last; 496 497 first =0; 498 last = istate->cache_nr; 499while(last > first) { 500int next = (last + first) >>1; 501struct cache_entry *ce = istate->cache[next]; 502int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 503if(!cmp) 504return next; 505if(cmp <0) { 506 last = next; 507continue; 508} 509 first = next+1; 510} 511return-first-1; 512} 513 514intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 515{ 516returnindex_name_stage_pos(istate, name, namelen,0); 517} 518 519intremove_index_entry_at(struct index_state *istate,int pos) 520{ 521struct cache_entry *ce = istate->cache[pos]; 522 523record_resolve_undo(istate, ce); 524remove_name_hash(istate, ce); 525save_or_free_index_entry(istate, ce); 526 istate->cache_changed |= CE_ENTRY_REMOVED; 527 istate->cache_nr--; 528if(pos >= istate->cache_nr) 529return0; 530MOVE_ARRAY(istate->cache + pos, istate->cache + pos +1, 531 istate->cache_nr - pos); 532return1; 533} 534 535/* 536 * Remove all cache entries marked for removal, that is where 537 * CE_REMOVE is set in ce_flags. This is much more effective than 538 * calling remove_index_entry_at() for each entry to be removed. 539 */ 540voidremove_marked_cache_entries(struct index_state *istate) 541{ 542struct cache_entry **ce_array = istate->cache; 543unsigned int i, j; 544 545for(i = j =0; i < istate->cache_nr; i++) { 546if(ce_array[i]->ce_flags & CE_REMOVE) { 547remove_name_hash(istate, ce_array[i]); 548save_or_free_index_entry(istate, ce_array[i]); 549} 550else 551 ce_array[j++] = ce_array[i]; 552} 553if(j == istate->cache_nr) 554return; 555 istate->cache_changed |= CE_ENTRY_REMOVED; 556 istate->cache_nr = j; 557} 558 559intremove_file_from_index(struct index_state *istate,const char*path) 560{ 561int pos =index_name_pos(istate, path,strlen(path)); 562if(pos <0) 563 pos = -pos-1; 564cache_tree_invalidate_path(istate, path); 565untracked_cache_remove_from_index(istate, path); 566while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 567remove_index_entry_at(istate, pos); 568return0; 569} 570 571static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 572{ 573return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 574} 575 576static intindex_name_pos_also_unmerged(struct index_state *istate, 577const char*path,int namelen) 578{ 579int pos =index_name_pos(istate, path, namelen); 580struct cache_entry *ce; 581 582if(pos >=0) 583return pos; 584 585/* maybe unmerged? */ 586 pos = -1- pos; 587if(pos >= istate->cache_nr || 588compare_name((ce = istate->cache[pos]), path, namelen)) 589return-1; 590 591/* order of preference: stage 2, 1, 3 */ 592if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 593ce_stage((ce = istate->cache[pos +1])) ==2&& 594!compare_name(ce, path, namelen)) 595 pos++; 596return pos; 597} 598 599static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 600{ 601int len =ce_namelen(ce); 602returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 603} 604 605/* 606 * If we add a filename that aliases in the cache, we will use the 607 * name that we already have - but we don't want to update the same 608 * alias twice, because that implies that there were actually two 609 * different files with aliasing names! 610 * 611 * So we use the CE_ADDED flag to verify that the alias was an old 612 * one before we accept it as 613 */ 614static struct cache_entry *create_alias_ce(struct index_state *istate, 615struct cache_entry *ce, 616struct cache_entry *alias) 617{ 618int len; 619struct cache_entry *new; 620 621if(alias->ce_flags & CE_ADDED) 622die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 623 624/* Ok, create the new entry using the name of the existing alias */ 625 len =ce_namelen(alias); 626new=xcalloc(1,cache_entry_size(len)); 627memcpy(new->name, alias->name, len); 628copy_cache_entry(new, ce); 629save_or_free_index_entry(istate, ce); 630return new; 631} 632 633voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 634{ 635unsigned char sha1[20]; 636if(write_sha1_file("",0, blob_type, sha1)) 637die("cannot create an empty blob in the object database"); 638hashcpy(ce->oid.hash, sha1); 639} 640 641intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 642{ 643int size, namelen, was_same; 644 mode_t st_mode = st->st_mode; 645struct cache_entry *ce, *alias = NULL; 646unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 647int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 648int pretend = flags & ADD_CACHE_PRETEND; 649int intent_only = flags & ADD_CACHE_INTENT; 650int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 651(intent_only ? ADD_CACHE_NEW_ONLY :0)); 652int newflags = HASH_WRITE_OBJECT; 653 654if(flags & HASH_RENORMALIZE) 655 newflags |= HASH_RENORMALIZE; 656 657if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 658returnerror("%s: can only add regular files, symbolic links or git-directories", path); 659 660 namelen =strlen(path); 661if(S_ISDIR(st_mode)) { 662while(namelen && path[namelen-1] =='/') 663 namelen--; 664} 665 size =cache_entry_size(namelen); 666 ce =xcalloc(1, size); 667memcpy(ce->name, path, namelen); 668 ce->ce_namelen = namelen; 669if(!intent_only) 670fill_stat_cache_info(ce, st); 671else 672 ce->ce_flags |= CE_INTENT_TO_ADD; 673 674 675if(trust_executable_bit && has_symlinks) { 676 ce->ce_mode =create_ce_mode(st_mode); 677}else{ 678/* If there is an existing entry, pick the mode bits and type 679 * from it, otherwise assume unexecutable regular file. 680 */ 681struct cache_entry *ent; 682int pos =index_name_pos_also_unmerged(istate, path, namelen); 683 684 ent = (0<= pos) ? istate->cache[pos] : NULL; 685 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 686} 687 688/* When core.ignorecase=true, determine if a directory of the same name but differing 689 * case already exists within the Git repository. If it does, ensure the directory 690 * case of the file being added to the repository matches (is folded into) the existing 691 * entry's directory case. 692 */ 693if(ignore_case) { 694adjust_dirname_case(istate, ce->name); 695} 696if(!(flags & HASH_RENORMALIZE)) { 697 alias =index_file_exists(istate, ce->name, 698ce_namelen(ce), ignore_case); 699if(alias && 700!ce_stage(alias) && 701!ie_match_stat(istate, alias, st, ce_option)) { 702/* Nothing changed, really */ 703if(!S_ISGITLINK(alias->ce_mode)) 704ce_mark_uptodate(alias); 705 alias->ce_flags |= CE_ADDED; 706 707free(ce); 708return0; 709} 710} 711if(!intent_only) { 712if(index_path(&ce->oid, path, st, newflags)) { 713free(ce); 714returnerror("unable to index file%s", path); 715} 716}else 717set_object_name_for_intent_to_add_entry(ce); 718 719if(ignore_case && alias &&different_name(ce, alias)) 720 ce =create_alias_ce(istate, ce, alias); 721 ce->ce_flags |= CE_ADDED; 722 723/* It was suspected to be racily clean, but it turns out to be Ok */ 724 was_same = (alias && 725!ce_stage(alias) && 726!oidcmp(&alias->oid, &ce->oid) && 727 ce->ce_mode == alias->ce_mode); 728 729if(pretend) 730free(ce); 731else if(add_index_entry(istate, ce, add_option)) { 732free(ce); 733returnerror("unable to add%sto index", path); 734} 735if(verbose && !was_same) 736printf("add '%s'\n", path); 737return0; 738} 739 740intadd_file_to_index(struct index_state *istate,const char*path,int flags) 741{ 742struct stat st; 743if(lstat(path, &st)) 744die_errno("unable to stat '%s'", path); 745returnadd_to_index(istate, path, &st, flags); 746} 747 748struct cache_entry *make_cache_entry(unsigned int mode, 749const unsigned char*sha1,const char*path,int stage, 750unsigned int refresh_options) 751{ 752int size, len; 753struct cache_entry *ce, *ret; 754 755if(!verify_path(path)) { 756error("Invalid path '%s'", path); 757return NULL; 758} 759 760 len =strlen(path); 761 size =cache_entry_size(len); 762 ce =xcalloc(1, size); 763 764hashcpy(ce->oid.hash, sha1); 765memcpy(ce->name, path, len); 766 ce->ce_flags =create_ce_flags(stage); 767 ce->ce_namelen = len; 768 ce->ce_mode =create_ce_mode(mode); 769 770 ret =refresh_cache_entry(ce, refresh_options); 771if(ret != ce) 772free(ce); 773return ret; 774} 775 776/* 777 * Chmod an index entry with either +x or -x. 778 * 779 * Returns -1 if the chmod for the particular cache entry failed (if it's 780 * not a regular file), -2 if an invalid flip argument is passed in, 0 781 * otherwise. 782 */ 783intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 784char flip) 785{ 786if(!S_ISREG(ce->ce_mode)) 787return-1; 788switch(flip) { 789case'+': 790 ce->ce_mode |=0111; 791break; 792case'-': 793 ce->ce_mode &= ~0111; 794break; 795default: 796return-2; 797} 798cache_tree_invalidate_path(istate, ce->name); 799 ce->ce_flags |= CE_UPDATE_IN_BASE; 800mark_fsmonitor_invalid(istate, ce); 801 istate->cache_changed |= CE_ENTRY_CHANGED; 802 803return0; 804} 805 806intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 807{ 808int len =ce_namelen(a); 809returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 810} 811 812/* 813 * We fundamentally don't like some paths: we don't want 814 * dot or dot-dot anywhere, and for obvious reasons don't 815 * want to recurse into ".git" either. 816 * 817 * Also, we don't want double slashes or slashes at the 818 * end that can make pathnames ambiguous. 819 */ 820static intverify_dotfile(const char*rest) 821{ 822/* 823 * The first character was '.', but that 824 * has already been discarded, we now test 825 * the rest. 826 */ 827 828/* "." is not allowed */ 829if(*rest =='\0'||is_dir_sep(*rest)) 830return0; 831 832switch(*rest) { 833/* 834 * ".git" followed by NUL or slash is bad. This 835 * shares the path end test with the ".." case. 836 */ 837case'g': 838case'G': 839if(rest[1] !='i'&& rest[1] !='I') 840break; 841if(rest[2] !='t'&& rest[2] !='T') 842break; 843 rest +=2; 844/* fallthrough */ 845case'.': 846if(rest[1] =='\0'||is_dir_sep(rest[1])) 847return0; 848} 849return1; 850} 851 852intverify_path(const char*path) 853{ 854char c; 855 856if(has_dos_drive_prefix(path)) 857return0; 858 859goto inside; 860for(;;) { 861if(!c) 862return1; 863if(is_dir_sep(c)) { 864inside: 865if(protect_hfs &&is_hfs_dotgit(path)) 866return0; 867if(protect_ntfs &&is_ntfs_dotgit(path)) 868return0; 869 c = *path++; 870if((c =='.'&& !verify_dotfile(path)) || 871is_dir_sep(c) || c =='\0') 872return0; 873} 874 c = *path++; 875} 876} 877 878/* 879 * Do we have another file that has the beginning components being a 880 * proper superset of the name we're trying to add? 881 */ 882static inthas_file_name(struct index_state *istate, 883const struct cache_entry *ce,int pos,int ok_to_replace) 884{ 885int retval =0; 886int len =ce_namelen(ce); 887int stage =ce_stage(ce); 888const char*name = ce->name; 889 890while(pos < istate->cache_nr) { 891struct cache_entry *p = istate->cache[pos++]; 892 893if(len >=ce_namelen(p)) 894break; 895if(memcmp(name, p->name, len)) 896break; 897if(ce_stage(p) != stage) 898continue; 899if(p->name[len] !='/') 900continue; 901if(p->ce_flags & CE_REMOVE) 902continue; 903 retval = -1; 904if(!ok_to_replace) 905break; 906remove_index_entry_at(istate, --pos); 907} 908return retval; 909} 910 911 912/* 913 * Like strcmp(), but also return the offset of the first change. 914 * If strings are equal, return the length. 915 */ 916intstrcmp_offset(const char*s1,const char*s2,size_t*first_change) 917{ 918size_t k; 919 920if(!first_change) 921returnstrcmp(s1, s2); 922 923for(k =0; s1[k] == s2[k]; k++) 924if(s1[k] =='\0') 925break; 926 927*first_change = k; 928return(unsigned char)s1[k] - (unsigned char)s2[k]; 929} 930 931/* 932 * Do we have another file with a pathname that is a proper 933 * subset of the name we're trying to add? 934 * 935 * That is, is there another file in the index with a path 936 * that matches a sub-directory in the given entry? 937 */ 938static inthas_dir_name(struct index_state *istate, 939const struct cache_entry *ce,int pos,int ok_to_replace) 940{ 941int retval =0; 942int stage =ce_stage(ce); 943const char*name = ce->name; 944const char*slash = name +ce_namelen(ce); 945size_t len_eq_last; 946int cmp_last =0; 947 948/* 949 * We are frequently called during an iteration on a sorted 950 * list of pathnames and while building a new index. Therefore, 951 * there is a high probability that this entry will eventually 952 * be appended to the index, rather than inserted in the middle. 953 * If we can confirm that, we can avoid binary searches on the 954 * components of the pathname. 955 * 956 * Compare the entry's full path with the last path in the index. 957 */ 958if(istate->cache_nr >0) { 959 cmp_last =strcmp_offset(name, 960 istate->cache[istate->cache_nr -1]->name, 961&len_eq_last); 962if(cmp_last >0) { 963if(len_eq_last ==0) { 964/* 965 * The entry sorts AFTER the last one in the 966 * index and their paths have no common prefix, 967 * so there cannot be a F/D conflict. 968 */ 969return retval; 970}else{ 971/* 972 * The entry sorts AFTER the last one in the 973 * index, but has a common prefix. Fall through 974 * to the loop below to disect the entry's path 975 * and see where the difference is. 976 */ 977} 978}else if(cmp_last ==0) { 979/* 980 * The entry exactly matches the last one in the 981 * index, but because of multiple stage and CE_REMOVE 982 * items, we fall through and let the regular search 983 * code handle it. 984 */ 985} 986} 987 988for(;;) { 989size_t len; 990 991for(;;) { 992if(*--slash =='/') 993break; 994if(slash <= ce->name) 995return retval; 996} 997 len = slash - name; 998 999if(cmp_last >0) {1000/*1001 * (len + 1) is a directory boundary (including1002 * the trailing slash). And since the loop is1003 * decrementing "slash", the first iteration is1004 * the longest directory prefix; subsequent1005 * iterations consider parent directories.1006 */10071008if(len +1<= len_eq_last) {1009/*1010 * The directory prefix (including the trailing1011 * slash) also appears as a prefix in the last1012 * entry, so the remainder cannot collide (because1013 * strcmp said the whole path was greater).1014 *1015 * EQ: last: xxx/A1016 * this: xxx/B1017 *1018 * LT: last: xxx/file_A1019 * this: xxx/file_B1020 */1021return retval;1022}10231024if(len > len_eq_last) {1025/*1026 * This part of the directory prefix (excluding1027 * the trailing slash) is longer than the known1028 * equal portions, so this sub-directory cannot1029 * collide with a file.1030 *1031 * GT: last: xxxA1032 * this: xxxB/file1033 */1034return retval;1035}10361037if(istate->cache_nr >0&&1038ce_namelen(istate->cache[istate->cache_nr -1]) > len) {1039/*1040 * The directory prefix lines up with part of1041 * a longer file or directory name, but sorts1042 * after it, so this sub-directory cannot1043 * collide with a file.1044 *1045 * last: xxx/yy-file (because '-' sorts before '/')1046 * this: xxx/yy/abc1047 */1048return retval;1049}10501051/*1052 * This is a possible collision. Fall through and1053 * let the regular search code handle it.1054 *1055 * last: xxx1056 * this: xxx/file1057 */1058}10591060 pos =index_name_stage_pos(istate, name, len, stage);1061if(pos >=0) {1062/*1063 * Found one, but not so fast. This could1064 * be a marker that says "I was here, but1065 * I am being removed". Such an entry is1066 * not a part of the resulting tree, and1067 * it is Ok to have a directory at the same1068 * path.1069 */1070if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) {1071 retval = -1;1072if(!ok_to_replace)1073break;1074remove_index_entry_at(istate, pos);1075continue;1076}1077}1078else1079 pos = -pos-1;10801081/*1082 * Trivial optimization: if we find an entry that1083 * already matches the sub-directory, then we know1084 * we're ok, and we can exit.1085 */1086while(pos < istate->cache_nr) {1087struct cache_entry *p = istate->cache[pos];1088if((ce_namelen(p) <= len) ||1089(p->name[len] !='/') ||1090memcmp(p->name, name, len))1091break;/* not our subdirectory */1092if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))1093/*1094 * p is at the same stage as our entry, and1095 * is a subdirectory of what we are looking1096 * at, so we cannot have conflicts at our1097 * level or anything shorter.1098 */1099return retval;1100 pos++;1101}1102}1103return retval;1104}11051106/* We may be in a situation where we already have path/file and path1107 * is being added, or we already have path and path/file is being1108 * added. Either one would result in a nonsense tree that has path1109 * twice when git-write-tree tries to write it out. Prevent it.1110 *1111 * If ok-to-replace is specified, we remove the conflicting entries1112 * from the cache so the caller should recompute the insert position.1113 * When this happens, we return non-zero.1114 */1115static intcheck_file_directory_conflict(struct index_state *istate,1116const struct cache_entry *ce,1117int pos,int ok_to_replace)1118{1119int retval;11201121/*1122 * When ce is an "I am going away" entry, we allow it to be added1123 */1124if(ce->ce_flags & CE_REMOVE)1125return0;11261127/*1128 * We check if the path is a sub-path of a subsequent pathname1129 * first, since removing those will not change the position1130 * in the array.1131 */1132 retval =has_file_name(istate, ce, pos, ok_to_replace);11331134/*1135 * Then check if the path might have a clashing sub-directory1136 * before it.1137 */1138return retval +has_dir_name(istate, ce, pos, ok_to_replace);1139}11401141static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1142{1143int pos;1144int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1145int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1146int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1147int new_only = option & ADD_CACHE_NEW_ONLY;11481149if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1150cache_tree_invalidate_path(istate, ce->name);11511152/*1153 * If this entry's path sorts after the last entry in the index,1154 * we can avoid searching for it.1155 */1156if(istate->cache_nr >0&&1157strcmp(ce->name, istate->cache[istate->cache_nr -1]->name) >0)1158 pos = -istate->cache_nr -1;1159else1160 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));11611162/* existing match? Just replace it. */1163if(pos >=0) {1164if(!new_only)1165replace_index_entry(istate, pos, ce);1166return0;1167}1168 pos = -pos-1;11691170if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1171untracked_cache_add_to_index(istate, ce->name);11721173/*1174 * Inserting a merged entry ("stage 0") into the index1175 * will always replace all non-merged entries..1176 */1177if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1178while(ce_same_name(istate->cache[pos], ce)) {1179 ok_to_add =1;1180if(!remove_index_entry_at(istate, pos))1181break;1182}1183}11841185if(!ok_to_add)1186return-1;1187if(!verify_path(ce->name))1188returnerror("Invalid path '%s'", ce->name);11891190if(!skip_df_check &&1191check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1192if(!ok_to_replace)1193returnerror("'%s' appears as both a file and as a directory",1194 ce->name);1195 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1196 pos = -pos-1;1197}1198return pos +1;1199}12001201intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1202{1203int pos;12041205if(option & ADD_CACHE_JUST_APPEND)1206 pos = istate->cache_nr;1207else{1208int ret;1209 ret =add_index_entry_with_check(istate, ce, option);1210if(ret <=0)1211return ret;1212 pos = ret -1;1213}12141215/* Make sure the array is big enough .. */1216ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);12171218/* Add it in.. */1219 istate->cache_nr++;1220if(istate->cache_nr > pos +1)1221memmove(istate->cache + pos +1,1222 istate->cache + pos,1223(istate->cache_nr - pos -1) *sizeof(ce));1224set_index_entry(istate, pos, ce);1225 istate->cache_changed |= CE_ENTRY_ADDED;1226return0;1227}12281229/*1230 * "refresh" does not calculate a new sha1 file or bring the1231 * cache up-to-date for mode/content changes. But what it1232 * _does_ do is to "re-match" the stat information of a file1233 * with the cache, so that you can refresh the cache for a1234 * file that hasn't been changed but where the stat entry is1235 * out of date.1236 *1237 * For example, you'd want to do this after doing a "git-read-tree",1238 * to link up the stat cache details with the proper files.1239 */1240static struct cache_entry *refresh_cache_ent(struct index_state *istate,1241struct cache_entry *ce,1242unsigned int options,int*err,1243int*changed_ret)1244{1245struct stat st;1246struct cache_entry *updated;1247int changed, size;1248int refresh = options & CE_MATCH_REFRESH;1249int ignore_valid = options & CE_MATCH_IGNORE_VALID;1250int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1251int ignore_missing = options & CE_MATCH_IGNORE_MISSING;1252int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR;12531254if(!refresh ||ce_uptodate(ce))1255return ce;12561257if(!ignore_fsmonitor)1258refresh_fsmonitor(istate);1259/*1260 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1261 * that the change to the work tree does not matter and told1262 * us not to worry.1263 */1264if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1265ce_mark_uptodate(ce);1266return ce;1267}1268if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1269ce_mark_uptodate(ce);1270return ce;1271}1272if(!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID)) {1273ce_mark_uptodate(ce);1274return ce;1275}12761277if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1278if(ignore_missing)1279return ce;1280if(err)1281*err = ENOENT;1282return NULL;1283}12841285if(lstat(ce->name, &st) <0) {1286if(ignore_missing && errno == ENOENT)1287return ce;1288if(err)1289*err = errno;1290return NULL;1291}12921293 changed =ie_match_stat(istate, ce, &st, options);1294if(changed_ret)1295*changed_ret = changed;1296if(!changed) {1297/*1298 * The path is unchanged. If we were told to ignore1299 * valid bit, then we did the actual stat check and1300 * found that the entry is unmodified. If the entry1301 * is not marked VALID, this is the place to mark it1302 * valid again, under "assume unchanged" mode.1303 */1304if(ignore_valid && assume_unchanged &&1305!(ce->ce_flags & CE_VALID))1306;/* mark this one VALID again */1307else{1308/*1309 * We do not mark the index itself "modified"1310 * because CE_UPTODATE flag is in-core only;1311 * we are not going to write this change out.1312 */1313if(!S_ISGITLINK(ce->ce_mode)) {1314ce_mark_uptodate(ce);1315mark_fsmonitor_valid(ce);1316}1317return ce;1318}1319}13201321if(ie_modified(istate, ce, &st, options)) {1322if(err)1323*err = EINVAL;1324return NULL;1325}13261327 size =ce_size(ce);1328 updated =xmalloc(size);1329copy_cache_entry(updated, ce);1330memcpy(updated->name, ce->name, ce->ce_namelen +1);1331fill_stat_cache_info(updated, &st);1332/*1333 * If ignore_valid is not set, we should leave CE_VALID bit1334 * alone. Otherwise, paths marked with --no-assume-unchanged1335 * (i.e. things to be edited) will reacquire CE_VALID bit1336 * automatically, which is not really what we want.1337 */1338if(!ignore_valid && assume_unchanged &&1339!(ce->ce_flags & CE_VALID))1340 updated->ce_flags &= ~CE_VALID;13411342/* istate->cache_changed is updated in the caller */1343return updated;1344}13451346static voidshow_file(const char* fmt,const char* name,int in_porcelain,1347int* first,const char*header_msg)1348{1349if(in_porcelain && *first && header_msg) {1350printf("%s\n", header_msg);1351*first =0;1352}1353printf(fmt, name);1354}13551356intrefresh_index(struct index_state *istate,unsigned int flags,1357const struct pathspec *pathspec,1358char*seen,const char*header_msg)1359{1360int i;1361int has_errors =0;1362int really = (flags & REFRESH_REALLY) !=0;1363int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1364int quiet = (flags & REFRESH_QUIET) !=0;1365int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1366int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1367int first =1;1368int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1369unsigned int options = (CE_MATCH_REFRESH |1370(really ? CE_MATCH_IGNORE_VALID :0) |1371(not_new ? CE_MATCH_IGNORE_MISSING :0));1372const char*modified_fmt;1373const char*deleted_fmt;1374const char*typechange_fmt;1375const char*added_fmt;1376const char*unmerged_fmt;13771378 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1379 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1380 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1381 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1382 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1383for(i =0; i < istate->cache_nr; i++) {1384struct cache_entry *ce, *new;1385int cache_errno =0;1386int changed =0;1387int filtered =0;13881389 ce = istate->cache[i];1390if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1391continue;13921393if(pathspec && !ce_path_match(ce, pathspec, seen))1394 filtered =1;13951396if(ce_stage(ce)) {1397while((i < istate->cache_nr) &&1398!strcmp(istate->cache[i]->name, ce->name))1399 i++;1400 i--;1401if(allow_unmerged)1402continue;1403if(!filtered)1404show_file(unmerged_fmt, ce->name, in_porcelain,1405&first, header_msg);1406 has_errors =1;1407continue;1408}14091410if(filtered)1411continue;14121413new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1414if(new== ce)1415continue;1416if(!new) {1417const char*fmt;14181419if(really && cache_errno == EINVAL) {1420/* If we are doing --really-refresh that1421 * means the index is not valid anymore.1422 */1423 ce->ce_flags &= ~CE_VALID;1424 ce->ce_flags |= CE_UPDATE_IN_BASE;1425mark_fsmonitor_invalid(istate, ce);1426 istate->cache_changed |= CE_ENTRY_CHANGED;1427}1428if(quiet)1429continue;14301431if(cache_errno == ENOENT)1432 fmt = deleted_fmt;1433else if(ce_intent_to_add(ce))1434 fmt = added_fmt;/* must be before other checks */1435else if(changed & TYPE_CHANGED)1436 fmt = typechange_fmt;1437else1438 fmt = modified_fmt;1439show_file(fmt,1440 ce->name, in_porcelain, &first, header_msg);1441 has_errors =1;1442continue;1443}14441445replace_index_entry(istate, i,new);1446}1447return has_errors;1448}14491450struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1451unsigned int options)1452{1453returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1454}145514561457/*****************************************************************1458 * Index File I/O1459 *****************************************************************/14601461#define INDEX_FORMAT_DEFAULT 314621463static unsigned intget_index_format_default(void)1464{1465char*envversion =getenv("GIT_INDEX_VERSION");1466char*endp;1467int value;1468unsigned int version = INDEX_FORMAT_DEFAULT;14691470if(!envversion) {1471if(!git_config_get_int("index.version", &value))1472 version = value;1473if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1474warning(_("index.version set, but the value is invalid.\n"1475"Using version%i"), INDEX_FORMAT_DEFAULT);1476return INDEX_FORMAT_DEFAULT;1477}1478return version;1479}14801481 version =strtoul(envversion, &endp,10);1482if(*endp ||1483 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1484warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1485"Using version%i"), INDEX_FORMAT_DEFAULT);1486 version = INDEX_FORMAT_DEFAULT;1487}1488return version;1489}14901491/*1492 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1493 * Again - this is just a (very strong in practice) heuristic that1494 * the inode hasn't changed.1495 *1496 * We save the fields in big-endian order to allow using the1497 * index file over NFS transparently.1498 */1499struct ondisk_cache_entry {1500struct cache_time ctime;1501struct cache_time mtime;1502uint32_t dev;1503uint32_t ino;1504uint32_t mode;1505uint32_t uid;1506uint32_t gid;1507uint32_t size;1508unsigned char sha1[20];1509uint16_t flags;1510char name[FLEX_ARRAY];/* more */1511};15121513/*1514 * This struct is used when CE_EXTENDED bit is 11515 * The struct must match ondisk_cache_entry exactly from1516 * ctime till flags1517 */1518struct ondisk_cache_entry_extended {1519struct cache_time ctime;1520struct cache_time mtime;1521uint32_t dev;1522uint32_t ino;1523uint32_t mode;1524uint32_t uid;1525uint32_t gid;1526uint32_t size;1527unsigned char sha1[20];1528uint16_t flags;1529uint16_t flags2;1530char name[FLEX_ARRAY];/* more */1531};15321533/* These are only used for v3 or lower */1534#define align_padding_size(size, len) ((size + (len) + 8) & ~7) - (size + len)1535#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1536#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1537#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1538#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1539 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1540 ondisk_cache_entry_size(ce_namelen(ce)))15411542/* Allow fsck to force verification of the index checksum. */1543int verify_index_checksum;15441545/* Allow fsck to force verification of the cache entry order. */1546int verify_ce_order;15471548static intverify_hdr(struct cache_header *hdr,unsigned long size)1549{1550 git_SHA_CTX c;1551unsigned char sha1[20];1552int hdr_version;15531554if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1555returnerror("bad signature");1556 hdr_version =ntohl(hdr->hdr_version);1557if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1558returnerror("bad index version%d", hdr_version);15591560if(!verify_index_checksum)1561return0;15621563git_SHA1_Init(&c);1564git_SHA1_Update(&c, hdr, size -20);1565git_SHA1_Final(sha1, &c);1566if(hashcmp(sha1, (unsigned char*)hdr + size -20))1567returnerror("bad index file sha1 signature");1568return0;1569}15701571static intread_index_extension(struct index_state *istate,1572const char*ext,void*data,unsigned long sz)1573{1574switch(CACHE_EXT(ext)) {1575case CACHE_EXT_TREE:1576 istate->cache_tree =cache_tree_read(data, sz);1577break;1578case CACHE_EXT_RESOLVE_UNDO:1579 istate->resolve_undo =resolve_undo_read(data, sz);1580break;1581case CACHE_EXT_LINK:1582if(read_link_extension(istate, data, sz))1583return-1;1584break;1585case CACHE_EXT_UNTRACKED:1586 istate->untracked =read_untracked_extension(data, sz);1587break;1588case CACHE_EXT_FSMONITOR:1589read_fsmonitor_extension(istate, data, sz);1590break;1591default:1592if(*ext <'A'||'Z'< *ext)1593returnerror("index uses %.4s extension, which we do not understand",1594 ext);1595fprintf(stderr,"ignoring %.4s extension\n", ext);1596break;1597}1598return0;1599}16001601inthold_locked_index(struct lock_file *lk,int lock_flags)1602{1603returnhold_lock_file_for_update(lk,get_index_file(), lock_flags);1604}16051606intread_index(struct index_state *istate)1607{1608returnread_index_from(istate,get_index_file());1609}16101611static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1612unsigned int flags,1613const char*name,1614size_t len)1615{1616struct cache_entry *ce =xmalloc(cache_entry_size(len));16171618 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1619 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1620 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1621 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1622 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1623 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1624 ce->ce_mode =get_be32(&ondisk->mode);1625 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1626 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1627 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1628 ce->ce_flags = flags & ~CE_NAMEMASK;1629 ce->ce_namelen = len;1630 ce->index =0;1631hashcpy(ce->oid.hash, ondisk->sha1);1632memcpy(ce->name, name, len);1633 ce->name[len] ='\0';1634return ce;1635}16361637/*1638 * Adjacent cache entries tend to share the leading paths, so it makes1639 * sense to only store the differences in later entries. In the v41640 * on-disk format of the index, each on-disk cache entry stores the1641 * number of bytes to be stripped from the end of the previous name,1642 * and the bytes to append to the result, to come up with its name.1643 */1644static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1645{1646const unsigned char*ep, *cp = (const unsigned char*)cp_;1647size_t len =decode_varint(&cp);16481649if(name->len < len)1650die("malformed name field in the index");1651strbuf_remove(name, name->len - len, len);1652for(ep = cp; *ep; ep++)1653;/* find the end */1654strbuf_add(name, cp, ep - cp);1655return(const char*)ep +1- cp_;1656}16571658static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1659unsigned long*ent_size,1660struct strbuf *previous_name)1661{1662struct cache_entry *ce;1663size_t len;1664const char*name;1665unsigned int flags;16661667/* On-disk flags are just 16 bits */1668 flags =get_be16(&ondisk->flags);1669 len = flags & CE_NAMEMASK;16701671if(flags & CE_EXTENDED) {1672struct ondisk_cache_entry_extended *ondisk2;1673int extended_flags;1674 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1675 extended_flags =get_be16(&ondisk2->flags2) <<16;1676/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1677if(extended_flags & ~CE_EXTENDED_FLAGS)1678die("Unknown index entry format%08x", extended_flags);1679 flags |= extended_flags;1680 name = ondisk2->name;1681}1682else1683 name = ondisk->name;16841685if(!previous_name) {1686/* v3 and earlier */1687if(len == CE_NAMEMASK)1688 len =strlen(name);1689 ce =cache_entry_from_ondisk(ondisk, flags, name, len);16901691*ent_size =ondisk_ce_size(ce);1692}else{1693unsigned long consumed;1694 consumed =expand_name_field(previous_name, name);1695 ce =cache_entry_from_ondisk(ondisk, flags,1696 previous_name->buf,1697 previous_name->len);16981699*ent_size = (name - ((char*)ondisk)) + consumed;1700}1701return ce;1702}17031704static voidcheck_ce_order(struct index_state *istate)1705{1706unsigned int i;17071708if(!verify_ce_order)1709return;17101711for(i =1; i < istate->cache_nr; i++) {1712struct cache_entry *ce = istate->cache[i -1];1713struct cache_entry *next_ce = istate->cache[i];1714int name_compare =strcmp(ce->name, next_ce->name);17151716if(0< name_compare)1717die("unordered stage entries in index");1718if(!name_compare) {1719if(!ce_stage(ce))1720die("multiple stage entries for merged file '%s'",1721 ce->name);1722if(ce_stage(ce) >ce_stage(next_ce))1723die("unordered stage entries for '%s'",1724 ce->name);1725}1726}1727}17281729static voidtweak_untracked_cache(struct index_state *istate)1730{1731switch(git_config_get_untracked_cache()) {1732case-1:/* keep: do nothing */1733break;1734case0:/* false */1735remove_untracked_cache(istate);1736break;1737case1:/* true */1738add_untracked_cache(istate);1739break;1740default:/* unknown value: do nothing */1741break;1742}1743}17441745static voidtweak_split_index(struct index_state *istate)1746{1747switch(git_config_get_split_index()) {1748case-1:/* unset: do nothing */1749break;1750case0:/* false */1751remove_split_index(istate);1752break;1753case1:/* true */1754add_split_index(istate);1755break;1756default:/* unknown value: do nothing */1757break;1758}1759}17601761static voidpost_read_index_from(struct index_state *istate)1762{1763check_ce_order(istate);1764tweak_untracked_cache(istate);1765tweak_split_index(istate);1766tweak_fsmonitor(istate);1767}17681769/* remember to discard_cache() before reading a different cache! */1770intdo_read_index(struct index_state *istate,const char*path,int must_exist)1771{1772int fd, i;1773struct stat st;1774unsigned long src_offset;1775struct cache_header *hdr;1776void*mmap;1777size_t mmap_size;1778struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17791780if(istate->initialized)1781return istate->cache_nr;17821783 istate->timestamp.sec =0;1784 istate->timestamp.nsec =0;1785 fd =open(path, O_RDONLY);1786if(fd <0) {1787if(!must_exist && errno == ENOENT)1788return0;1789die_errno("%s: index file open failed", path);1790}17911792if(fstat(fd, &st))1793die_errno("cannot stat the open index");17941795 mmap_size =xsize_t(st.st_size);1796if(mmap_size <sizeof(struct cache_header) +20)1797die("index file smaller than expected");17981799 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);1800if(mmap == MAP_FAILED)1801die_errno("unable to map index file");1802close(fd);18031804 hdr = mmap;1805if(verify_hdr(hdr, mmap_size) <0)1806goto unmap;18071808hashcpy(istate->sha1, (const unsigned char*)hdr + mmap_size -20);1809 istate->version =ntohl(hdr->hdr_version);1810 istate->cache_nr =ntohl(hdr->hdr_entries);1811 istate->cache_alloc =alloc_nr(istate->cache_nr);1812 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1813 istate->initialized =1;18141815if(istate->version ==4)1816 previous_name = &previous_name_buf;1817else1818 previous_name = NULL;18191820 src_offset =sizeof(*hdr);1821for(i =0; i < istate->cache_nr; i++) {1822struct ondisk_cache_entry *disk_ce;1823struct cache_entry *ce;1824unsigned long consumed;18251826 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1827 ce =create_from_disk(disk_ce, &consumed, previous_name);1828set_index_entry(istate, i, ce);18291830 src_offset += consumed;1831}1832strbuf_release(&previous_name_buf);1833 istate->timestamp.sec = st.st_mtime;1834 istate->timestamp.nsec =ST_MTIME_NSEC(st);18351836while(src_offset <= mmap_size -20-8) {1837/* After an array of active_nr index entries,1838 * there can be arbitrary number of extended1839 * sections, each of which is prefixed with1840 * extension name (4-byte) and section length1841 * in 4-byte network byte order.1842 */1843uint32_t extsize;1844memcpy(&extsize, (char*)mmap + src_offset +4,4);1845 extsize =ntohl(extsize);1846if(read_index_extension(istate,1847(const char*) mmap + src_offset,1848(char*) mmap + src_offset +8,1849 extsize) <0)1850goto unmap;1851 src_offset +=8;1852 src_offset += extsize;1853}1854munmap(mmap, mmap_size);1855return istate->cache_nr;18561857unmap:1858munmap(mmap, mmap_size);1859die("index file corrupt");1860}18611862/*1863 * Signal that the shared index is used by updating its mtime.1864 *1865 * This way, shared index can be removed if they have not been used1866 * for some time.1867 */1868static voidfreshen_shared_index(char*base_sha1_hex,int warn)1869{1870char*shared_index =git_pathdup("sharedindex.%s", base_sha1_hex);1871if(!check_and_freshen_file(shared_index,1) && warn)1872warning("could not freshen shared index '%s'", shared_index);1873free(shared_index);1874}18751876intread_index_from(struct index_state *istate,const char*path)1877{1878struct split_index *split_index;1879int ret;1880char*base_sha1_hex;1881const char*base_path;18821883/* istate->initialized covers both .git/index and .git/sharedindex.xxx */1884if(istate->initialized)1885return istate->cache_nr;18861887 ret =do_read_index(istate, path,0);18881889 split_index = istate->split_index;1890if(!split_index ||is_null_sha1(split_index->base_sha1)) {1891post_read_index_from(istate);1892return ret;1893}18941895if(split_index->base)1896discard_index(split_index->base);1897else1898 split_index->base =xcalloc(1,sizeof(*split_index->base));18991900 base_sha1_hex =sha1_to_hex(split_index->base_sha1);1901 base_path =git_path("sharedindex.%s", base_sha1_hex);1902 ret =do_read_index(split_index->base, base_path,1);1903if(hashcmp(split_index->base_sha1, split_index->base->sha1))1904die("broken index, expect%sin%s, got%s",1905 base_sha1_hex, base_path,1906sha1_to_hex(split_index->base->sha1));19071908freshen_shared_index(base_sha1_hex,0);1909merge_base_index(istate);1910post_read_index_from(istate);1911return ret;1912}19131914intis_index_unborn(struct index_state *istate)1915{1916return(!istate->cache_nr && !istate->timestamp.sec);1917}19181919intdiscard_index(struct index_state *istate)1920{1921int i;19221923for(i =0; i < istate->cache_nr; i++) {1924if(istate->cache[i]->index &&1925 istate->split_index &&1926 istate->split_index->base &&1927 istate->cache[i]->index <= istate->split_index->base->cache_nr &&1928 istate->cache[i] == istate->split_index->base->cache[istate->cache[i]->index -1])1929continue;1930free(istate->cache[i]);1931}1932resolve_undo_clear_index(istate);1933 istate->cache_nr =0;1934 istate->cache_changed =0;1935 istate->timestamp.sec =0;1936 istate->timestamp.nsec =0;1937free_name_hash(istate);1938cache_tree_free(&(istate->cache_tree));1939 istate->initialized =0;1940FREE_AND_NULL(istate->cache);1941 istate->cache_alloc =0;1942discard_split_index(istate);1943free_untracked_cache(istate->untracked);1944 istate->untracked = NULL;1945return0;1946}19471948intunmerged_index(const struct index_state *istate)1949{1950int i;1951for(i =0; i < istate->cache_nr; i++) {1952if(ce_stage(istate->cache[i]))1953return1;1954}1955return0;1956}19571958#define WRITE_BUFFER_SIZE 81921959static unsigned char write_buffer[WRITE_BUFFER_SIZE];1960static unsigned long write_buffer_len;19611962static intce_write_flush(git_SHA_CTX *context,int fd)1963{1964unsigned int buffered = write_buffer_len;1965if(buffered) {1966git_SHA1_Update(context, write_buffer, buffered);1967if(write_in_full(fd, write_buffer, buffered) <0)1968return-1;1969 write_buffer_len =0;1970}1971return0;1972}19731974static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1975{1976while(len) {1977unsigned int buffered = write_buffer_len;1978unsigned int partial = WRITE_BUFFER_SIZE - buffered;1979if(partial > len)1980 partial = len;1981memcpy(write_buffer + buffered, data, partial);1982 buffered += partial;1983if(buffered == WRITE_BUFFER_SIZE) {1984 write_buffer_len = buffered;1985if(ce_write_flush(context, fd))1986return-1;1987 buffered =0;1988}1989 write_buffer_len = buffered;1990 len -= partial;1991 data = (char*) data + partial;1992}1993return0;1994}19951996static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1997unsigned int ext,unsigned int sz)1998{1999 ext =htonl(ext);2000 sz =htonl(sz);2001return((ce_write(context, fd, &ext,4) <0) ||2002(ce_write(context, fd, &sz,4) <0)) ? -1:0;2003}20042005static intce_flush(git_SHA_CTX *context,int fd,unsigned char*sha1)2006{2007unsigned int left = write_buffer_len;20082009if(left) {2010 write_buffer_len =0;2011git_SHA1_Update(context, write_buffer, left);2012}20132014/* Flush first if not enough space for SHA1 signature */2015if(left +20> WRITE_BUFFER_SIZE) {2016if(write_in_full(fd, write_buffer, left) <0)2017return-1;2018 left =0;2019}20202021/* Append the SHA1 signature at the end */2022git_SHA1_Final(write_buffer + left, context);2023hashcpy(sha1, write_buffer + left);2024 left +=20;2025return(write_in_full(fd, write_buffer, left) <0) ? -1:0;2026}20272028static voidce_smudge_racily_clean_entry(struct cache_entry *ce)2029{2030/*2031 * The only thing we care about in this function is to smudge the2032 * falsely clean entry due to touch-update-touch race, so we leave2033 * everything else as they are. We are called for entries whose2034 * ce_stat_data.sd_mtime match the index file mtime.2035 *2036 * Note that this actually does not do much for gitlinks, for2037 * which ce_match_stat_basic() always goes to the actual2038 * contents. The caller checks with is_racy_timestamp() which2039 * always says "no" for gitlinks, so we are not called for them ;-)2040 */2041struct stat st;20422043if(lstat(ce->name, &st) <0)2044return;2045if(ce_match_stat_basic(ce, &st))2046return;2047if(ce_modified_check_fs(ce, &st)) {2048/* This is "racily clean"; smudge it. Note that this2049 * is a tricky code. At first glance, it may appear2050 * that it can break with this sequence:2051 *2052 * $ echo xyzzy >frotz2053 * $ git-update-index --add frotz2054 * $ : >frotz2055 * $ sleep 32056 * $ echo filfre >nitfol2057 * $ git-update-index --add nitfol2058 *2059 * but it does not. When the second update-index runs,2060 * it notices that the entry "frotz" has the same timestamp2061 * as index, and if we were to smudge it by resetting its2062 * size to zero here, then the object name recorded2063 * in index is the 6-byte file but the cached stat information2064 * becomes zero --- which would then match what we would2065 * obtain from the filesystem next time we stat("frotz").2066 *2067 * However, the second update-index, before calling2068 * this function, notices that the cached size is 62069 * bytes and what is on the filesystem is an empty2070 * file, and never calls us, so the cached size information2071 * for "frotz" stays 6 which does not match the filesystem.2072 */2073 ce->ce_stat_data.sd_size =0;2074}2075}20762077/* Copy miscellaneous fields but not the name */2078static voidcopy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,2079struct cache_entry *ce)2080{2081short flags;20822083 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);2084 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);2085 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);2086 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);2087 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);2088 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);2089 ondisk->mode =htonl(ce->ce_mode);2090 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);2091 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);2092 ondisk->size =htonl(ce->ce_stat_data.sd_size);2093hashcpy(ondisk->sha1, ce->oid.hash);20942095 flags = ce->ce_flags & ~CE_NAMEMASK;2096 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));2097 ondisk->flags =htons(flags);2098if(ce->ce_flags & CE_EXTENDED) {2099struct ondisk_cache_entry_extended *ondisk2;2100 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;2101 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);2102}2103}21042105static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,2106struct strbuf *previous_name,struct ondisk_cache_entry *ondisk)2107{2108int size;2109int saved_namelen = saved_namelen;/* compiler workaround */2110int result;2111static unsigned char padding[8] = {0x00};21122113if(ce->ce_flags & CE_STRIP_NAME) {2114 saved_namelen =ce_namelen(ce);2115 ce->ce_namelen =0;2116}21172118if(ce->ce_flags & CE_EXTENDED)2119 size =offsetof(struct ondisk_cache_entry_extended, name);2120else2121 size =offsetof(struct ondisk_cache_entry, name);21222123if(!previous_name) {2124int len =ce_namelen(ce);2125copy_cache_entry_to_ondisk(ondisk, ce);2126 result =ce_write(c, fd, ondisk, size);2127if(!result)2128 result =ce_write(c, fd, ce->name, len);2129if(!result)2130 result =ce_write(c, fd, padding,align_padding_size(size, len));2131}else{2132int common, to_remove, prefix_size;2133unsigned char to_remove_vi[16];2134for(common =0;2135(ce->name[common] &&2136 common < previous_name->len &&2137 ce->name[common] == previous_name->buf[common]);2138 common++)2139;/* still matching */2140 to_remove = previous_name->len - common;2141 prefix_size =encode_varint(to_remove, to_remove_vi);21422143copy_cache_entry_to_ondisk(ondisk, ce);2144 result =ce_write(c, fd, ondisk, size);2145if(!result)2146 result =ce_write(c, fd, to_remove_vi, prefix_size);2147if(!result)2148 result =ce_write(c, fd, ce->name + common,ce_namelen(ce) - common);2149if(!result)2150 result =ce_write(c, fd, padding,1);21512152strbuf_splice(previous_name, common, to_remove,2153 ce->name + common,ce_namelen(ce) - common);2154}2155if(ce->ce_flags & CE_STRIP_NAME) {2156 ce->ce_namelen = saved_namelen;2157 ce->ce_flags &= ~CE_STRIP_NAME;2158}21592160return result;2161}21622163/*2164 * This function verifies if index_state has the correct sha1 of the2165 * index file. Don't die if we have any other failure, just return 0.2166 */2167static intverify_index_from(const struct index_state *istate,const char*path)2168{2169int fd;2170 ssize_t n;2171struct stat st;2172unsigned char sha1[20];21732174if(!istate->initialized)2175return0;21762177 fd =open(path, O_RDONLY);2178if(fd <0)2179return0;21802181if(fstat(fd, &st))2182goto out;21832184if(st.st_size <sizeof(struct cache_header) +20)2185goto out;21862187 n =pread_in_full(fd, sha1,20, st.st_size -20);2188if(n !=20)2189goto out;21902191if(hashcmp(istate->sha1, sha1))2192goto out;21932194close(fd);2195return1;21962197out:2198close(fd);2199return0;2200}22012202static intverify_index(const struct index_state *istate)2203{2204returnverify_index_from(istate,get_index_file());2205}22062207static inthas_racy_timestamp(struct index_state *istate)2208{2209int entries = istate->cache_nr;2210int i;22112212for(i =0; i < entries; i++) {2213struct cache_entry *ce = istate->cache[i];2214if(is_racy_timestamp(istate, ce))2215return1;2216}2217return0;2218}22192220voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2221{2222if((istate->cache_changed ||has_racy_timestamp(istate)) &&2223verify_index(istate))2224write_locked_index(istate, lockfile, COMMIT_LOCK);2225else2226rollback_lock_file(lockfile);2227}22282229/*2230 * On success, `tempfile` is closed. If it is the temporary file2231 * of a `struct lock_file`, we will therefore effectively perform2232 * a 'close_lock_file_gently()`. Since that is an implementation2233 * detail of lockfiles, callers of `do_write_index()` should not2234 * rely on it.2235 */2236static intdo_write_index(struct index_state *istate,struct tempfile *tempfile,2237int strip_extensions)2238{2239int newfd = tempfile->fd;2240 git_SHA_CTX c;2241struct cache_header hdr;2242int i, err =0, removed, extended, hdr_version;2243struct cache_entry **cache = istate->cache;2244int entries = istate->cache_nr;2245struct stat st;2246struct ondisk_cache_entry_extended ondisk;2247struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;2248int drop_cache_tree =0;22492250for(i = removed = extended =0; i < entries; i++) {2251if(cache[i]->ce_flags & CE_REMOVE)2252 removed++;22532254/* reduce extended entries if possible */2255 cache[i]->ce_flags &= ~CE_EXTENDED;2256if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2257 extended++;2258 cache[i]->ce_flags |= CE_EXTENDED;2259}2260}22612262if(!istate->version) {2263 istate->version =get_index_format_default();2264if(getenv("GIT_TEST_SPLIT_INDEX"))2265init_split_index(istate);2266}22672268/* demote version 3 to version 2 when the latter suffices */2269if(istate->version ==3|| istate->version ==2)2270 istate->version = extended ?3:2;22712272 hdr_version = istate->version;22732274 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2275 hdr.hdr_version =htonl(hdr_version);2276 hdr.hdr_entries =htonl(entries - removed);22772278git_SHA1_Init(&c);2279if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2280return-1;22812282 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;22832284for(i =0; i < entries; i++) {2285struct cache_entry *ce = cache[i];2286if(ce->ce_flags & CE_REMOVE)2287continue;2288if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2289ce_smudge_racily_clean_entry(ce);2290if(is_null_oid(&ce->oid)) {2291static const char msg[] ="cache entry has null sha1:%s";2292static int allow = -1;22932294if(allow <0)2295 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2296if(allow)2297warning(msg, ce->name);2298else2299 err =error(msg, ce->name);23002301 drop_cache_tree =1;2302}2303if(ce_write_entry(&c, newfd, ce, previous_name, (struct ondisk_cache_entry *)&ondisk) <0)2304 err = -1;23052306if(err)2307break;2308}2309strbuf_release(&previous_name_buf);23102311if(err)2312return err;23132314/* Write extension data here */2315if(!strip_extensions && istate->split_index) {2316struct strbuf sb = STRBUF_INIT;23172318 err =write_link_extension(&sb, istate) <0||2319write_index_ext_header(&c, newfd, CACHE_EXT_LINK,2320 sb.len) <0||2321ce_write(&c, newfd, sb.buf, sb.len) <0;2322strbuf_release(&sb);2323if(err)2324return-1;2325}2326if(!strip_extensions && !drop_cache_tree && istate->cache_tree) {2327struct strbuf sb = STRBUF_INIT;23282329cache_tree_write(&sb, istate->cache_tree);2330 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <02331||ce_write(&c, newfd, sb.buf, sb.len) <0;2332strbuf_release(&sb);2333if(err)2334return-1;2335}2336if(!strip_extensions && istate->resolve_undo) {2337struct strbuf sb = STRBUF_INIT;23382339resolve_undo_write(&sb, istate->resolve_undo);2340 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,2341 sb.len) <02342||ce_write(&c, newfd, sb.buf, sb.len) <0;2343strbuf_release(&sb);2344if(err)2345return-1;2346}2347if(!strip_extensions && istate->untracked) {2348struct strbuf sb = STRBUF_INIT;23492350write_untracked_extension(&sb, istate->untracked);2351 err =write_index_ext_header(&c, newfd, CACHE_EXT_UNTRACKED,2352 sb.len) <0||2353ce_write(&c, newfd, sb.buf, sb.len) <0;2354strbuf_release(&sb);2355if(err)2356return-1;2357}2358if(!strip_extensions && istate->fsmonitor_last_update) {2359struct strbuf sb = STRBUF_INIT;23602361write_fsmonitor_extension(&sb, istate);2362 err =write_index_ext_header(&c, newfd, CACHE_EXT_FSMONITOR, sb.len) <02363||ce_write(&c, newfd, sb.buf, sb.len) <0;2364strbuf_release(&sb);2365if(err)2366return-1;2367}23682369if(ce_flush(&c, newfd, istate->sha1))2370return-1;2371if(close_tempfile_gently(tempfile)) {2372error(_("could not close '%s'"), tempfile->filename.buf);2373return-1;2374}2375if(stat(tempfile->filename.buf, &st))2376return-1;2377 istate->timestamp.sec = (unsigned int)st.st_mtime;2378 istate->timestamp.nsec =ST_MTIME_NSEC(st);2379return0;2380}23812382voidset_alternate_index_output(const char*name)2383{2384 alternate_index_output = name;2385}23862387static intcommit_locked_index(struct lock_file *lk)2388{2389if(alternate_index_output)2390returncommit_lock_file_to(lk, alternate_index_output);2391else2392returncommit_lock_file(lk);2393}23942395static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2396unsigned flags)2397{2398int ret =do_write_index(istate, lock->tempfile,0);2399if(ret)2400return ret;2401if(flags & COMMIT_LOCK)2402returncommit_locked_index(lock);2403returnclose_lock_file_gently(lock);2404}24052406static intwrite_split_index(struct index_state *istate,2407struct lock_file *lock,2408unsigned flags)2409{2410int ret;2411prepare_to_write_split_index(istate);2412 ret =do_write_locked_index(istate, lock, flags);2413finish_writing_split_index(istate);2414return ret;2415}24162417static const char*shared_index_expire ="2.weeks.ago";24182419static unsigned longget_shared_index_expire_date(void)2420{2421static unsigned long shared_index_expire_date;2422static int shared_index_expire_date_prepared;24232424if(!shared_index_expire_date_prepared) {2425git_config_get_expiry("splitindex.sharedindexexpire",2426&shared_index_expire);2427 shared_index_expire_date =approxidate(shared_index_expire);2428 shared_index_expire_date_prepared =1;2429}24302431return shared_index_expire_date;2432}24332434static intshould_delete_shared_index(const char*shared_index_path)2435{2436struct stat st;2437unsigned long expiration;24382439/* Check timestamp */2440 expiration =get_shared_index_expire_date();2441if(!expiration)2442return0;2443if(stat(shared_index_path, &st))2444returnerror_errno(_("could not stat '%s'"), shared_index_path);2445if(st.st_mtime > expiration)2446return0;24472448return1;2449}24502451static intclean_shared_index_files(const char*current_hex)2452{2453struct dirent *de;2454DIR*dir =opendir(get_git_dir());24552456if(!dir)2457returnerror_errno(_("unable to open git dir:%s"),get_git_dir());24582459while((de =readdir(dir)) != NULL) {2460const char*sha1_hex;2461const char*shared_index_path;2462if(!skip_prefix(de->d_name,"sharedindex.", &sha1_hex))2463continue;2464if(!strcmp(sha1_hex, current_hex))2465continue;2466 shared_index_path =git_path("%s", de->d_name);2467if(should_delete_shared_index(shared_index_path) >0&&2468unlink(shared_index_path))2469warning_errno(_("unable to unlink:%s"), shared_index_path);2470}2471closedir(dir);24722473return0;2474}24752476static intwrite_shared_index(struct index_state *istate,2477struct lock_file *lock,unsigned flags)2478{2479struct tempfile *temp;2480struct split_index *si = istate->split_index;2481int ret;24822483 temp =mks_tempfile(git_path("sharedindex_XXXXXX"));2484if(!temp) {2485hashclr(si->base_sha1);2486returndo_write_locked_index(istate, lock, flags);2487}2488move_cache_to_base_index(istate);2489 ret =do_write_index(si->base, temp,1);2490if(ret) {2491delete_tempfile(&temp);2492return ret;2493}2494 ret =adjust_shared_perm(get_tempfile_path(temp));2495if(ret) {2496int save_errno = errno;2497error("cannot fix permission bits on%s",get_tempfile_path(temp));2498delete_tempfile(&temp);2499 errno = save_errno;2500return ret;2501}2502 ret =rename_tempfile(&temp,2503git_path("sharedindex.%s",sha1_to_hex(si->base->sha1)));2504if(!ret) {2505hashcpy(si->base_sha1, si->base->sha1);2506clean_shared_index_files(sha1_to_hex(si->base->sha1));2507}25082509return ret;2510}25112512static const int default_max_percent_split_change =20;25132514static inttoo_many_not_shared_entries(struct index_state *istate)2515{2516int i, not_shared =0;2517int max_split =git_config_get_max_percent_split_change();25182519switch(max_split) {2520case-1:2521/* not or badly configured: use the default value */2522 max_split = default_max_percent_split_change;2523break;2524case0:2525return1;/* 0% means always write a new shared index */2526case100:2527return0;/* 100% means never write a new shared index */2528default:2529break;/* just use the configured value */2530}25312532/* Count not shared entries */2533for(i =0; i < istate->cache_nr; i++) {2534struct cache_entry *ce = istate->cache[i];2535if(!ce->index)2536 not_shared++;2537}25382539return(int64_t)istate->cache_nr * max_split < (int64_t)not_shared *100;2540}25412542intwrite_locked_index(struct index_state *istate,struct lock_file *lock,2543unsigned flags)2544{2545int new_shared_index, ret;2546struct split_index *si = istate->split_index;25472548if(istate->fsmonitor_last_update)2549fill_fsmonitor_bitmap(istate);25502551if(!si || alternate_index_output ||2552(istate->cache_changed & ~EXTMASK)) {2553if(si)2554hashclr(si->base_sha1);2555 ret =do_write_locked_index(istate, lock, flags);2556goto out;2557}25582559if(getenv("GIT_TEST_SPLIT_INDEX")) {2560int v = si->base_sha1[0];2561if((v &15) <6)2562 istate->cache_changed |= SPLIT_INDEX_ORDERED;2563}2564if(too_many_not_shared_entries(istate))2565 istate->cache_changed |= SPLIT_INDEX_ORDERED;25662567 new_shared_index = istate->cache_changed & SPLIT_INDEX_ORDERED;25682569if(new_shared_index) {2570 ret =write_shared_index(istate, lock, flags);2571if(ret)2572goto out;2573}25742575 ret =write_split_index(istate, lock, flags);25762577/* Freshen the shared index only if the split-index was written */2578if(!ret && !new_shared_index)2579freshen_shared_index(sha1_to_hex(si->base_sha1),1);25802581out:2582if(flags & COMMIT_LOCK)2583rollback_lock_file(lock);2584return ret;2585}25862587/*2588 * Read the index file that is potentially unmerged into given2589 * index_state, dropping any unmerged entries. Returns true if2590 * the index is unmerged. Callers who want to refuse to work2591 * from an unmerged state can call this and check its return value,2592 * instead of calling read_cache().2593 */2594intread_index_unmerged(struct index_state *istate)2595{2596int i;2597int unmerged =0;25982599read_index(istate);2600for(i =0; i < istate->cache_nr; i++) {2601struct cache_entry *ce = istate->cache[i];2602struct cache_entry *new_ce;2603int size, len;26042605if(!ce_stage(ce))2606continue;2607 unmerged =1;2608 len =ce_namelen(ce);2609 size =cache_entry_size(len);2610 new_ce =xcalloc(1, size);2611memcpy(new_ce->name, ce->name, len);2612 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;2613 new_ce->ce_namelen = len;2614 new_ce->ce_mode = ce->ce_mode;2615if(add_index_entry(istate, new_ce,0))2616returnerror("%s: cannot drop to stage #0",2617 new_ce->name);2618}2619return unmerged;2620}26212622/*2623 * Returns 1 if the path is an "other" path with respect to2624 * the index; that is, the path is not mentioned in the index at all,2625 * either as a file, a directory with some files in the index,2626 * or as an unmerged entry.2627 *2628 * We helpfully remove a trailing "/" from directories so that2629 * the output of read_directory can be used as-is.2630 */2631intindex_name_is_other(const struct index_state *istate,const char*name,2632int namelen)2633{2634int pos;2635if(namelen && name[namelen -1] =='/')2636 namelen--;2637 pos =index_name_pos(istate, name, namelen);2638if(0<= pos)2639return0;/* exact match */2640 pos = -pos -1;2641if(pos < istate->cache_nr) {2642struct cache_entry *ce = istate->cache[pos];2643if(ce_namelen(ce) == namelen &&2644!memcmp(ce->name, name, namelen))2645return0;/* Yup, this one exists unmerged */2646}2647return1;2648}26492650void*read_blob_data_from_index(const struct index_state *istate,2651const char*path,unsigned long*size)2652{2653int pos, len;2654unsigned long sz;2655enum object_type type;2656void*data;26572658 len =strlen(path);2659 pos =index_name_pos(istate, path, len);2660if(pos <0) {2661/*2662 * We might be in the middle of a merge, in which2663 * case we would read stage #2 (ours).2664 */2665int i;2666for(i = -pos -1;2667(pos <0&& i < istate->cache_nr &&2668!strcmp(istate->cache[i]->name, path));2669 i++)2670if(ce_stage(istate->cache[i]) ==2)2671 pos = i;2672}2673if(pos <0)2674return NULL;2675 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz);2676if(!data || type != OBJ_BLOB) {2677free(data);2678return NULL;2679}2680if(size)2681*size = sz;2682return data;2683}26842685voidstat_validity_clear(struct stat_validity *sv)2686{2687FREE_AND_NULL(sv->sd);2688}26892690intstat_validity_check(struct stat_validity *sv,const char*path)2691{2692struct stat st;26932694if(stat(path, &st) <0)2695return sv->sd == NULL;2696if(!sv->sd)2697return0;2698returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2699}27002701voidstat_validity_update(struct stat_validity *sv,int fd)2702{2703struct stat st;27042705if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2706stat_validity_clear(sv);2707else{2708if(!sv->sd)2709 sv->sd =xcalloc(1,sizeof(struct stat_data));2710fill_stat_data(sv->sd, &st);2711}2712}27132714voidmove_index_extensions(struct index_state *dst,struct index_state *src)2715{2716 dst->untracked = src->untracked;2717 src->untracked = NULL;2718}