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"cache-tree.h" 9#include"refs.h" 10#include"dir.h" 11#include"tree.h" 12#include"commit.h" 13#include"blob.h" 14#include"resolve-undo.h" 15#include"strbuf.h" 16#include"varint.h" 17 18static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really); 19 20/* Mask for the name length in ce_flags in the on-disk index */ 21 22#define CE_NAMEMASK (0x0fff) 23 24/* Index extensions. 25 * 26 * The first letter should be 'A'..'Z' for extensions that are not 27 * necessary for a correct operation (i.e. optimization data). 28 * When new extensions are added that _needs_ to be understood in 29 * order to correctly interpret the index file, pick character that 30 * is outside the range, to cause the reader to abort. 31 */ 32 33#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 34#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 35#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 36 37struct index_state the_index; 38 39static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 40{ 41 istate->cache[nr] = ce; 42add_name_hash(istate, ce); 43} 44 45static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 46{ 47struct cache_entry *old = istate->cache[nr]; 48 49remove_name_hash(istate, old); 50free(old); 51set_index_entry(istate, nr, ce); 52 istate->cache_changed =1; 53} 54 55voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 56{ 57struct cache_entry *old = istate->cache[nr], *new; 58int namelen =strlen(new_name); 59 60new=xmalloc(cache_entry_size(namelen)); 61copy_cache_entry(new, old); 62new->ce_flags &= ~CE_HASHED; 63new->ce_namelen = namelen; 64memcpy(new->name, new_name, namelen +1); 65 66cache_tree_invalidate_path(istate->cache_tree, old->name); 67remove_index_entry_at(istate, nr); 68add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 69} 70 71voidfill_stat_data(struct stat_data *sd,struct stat *st) 72{ 73 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 74 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 75 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 76 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 77 sd->sd_dev = st->st_dev; 78 sd->sd_ino = st->st_ino; 79 sd->sd_uid = st->st_uid; 80 sd->sd_gid = st->st_gid; 81 sd->sd_size = st->st_size; 82} 83 84intmatch_stat_data(const struct stat_data *sd,struct stat *st) 85{ 86int changed =0; 87 88if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 89 changed |= MTIME_CHANGED; 90if(trust_ctime && check_stat && 91 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 92 changed |= CTIME_CHANGED; 93 94#ifdef USE_NSEC 95if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 96 changed |= MTIME_CHANGED; 97if(trust_ctime && check_stat && 98 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 99 changed |= CTIME_CHANGED; 100#endif 101 102if(check_stat) { 103if(sd->sd_uid != (unsigned int) st->st_uid || 104 sd->sd_gid != (unsigned int) st->st_gid) 105 changed |= OWNER_CHANGED; 106if(sd->sd_ino != (unsigned int) st->st_ino) 107 changed |= INODE_CHANGED; 108} 109 110#ifdef USE_STDEV 111/* 112 * st_dev breaks on network filesystems where different 113 * clients will have different views of what "device" 114 * the filesystem is on 115 */ 116if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 117 changed |= INODE_CHANGED; 118#endif 119 120if(sd->sd_size != (unsigned int) st->st_size) 121 changed |= DATA_CHANGED; 122 123return changed; 124} 125 126/* 127 * This only updates the "non-critical" parts of the directory 128 * cache, ie the parts that aren't tracked by GIT, and only used 129 * to validate the cache. 130 */ 131voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 132{ 133fill_stat_data(&ce->ce_stat_data, st); 134 135if(assume_unchanged) 136 ce->ce_flags |= CE_VALID; 137 138if(S_ISREG(st->st_mode)) 139ce_mark_uptodate(ce); 140} 141 142static intce_compare_data(const struct cache_entry *ce,struct stat *st) 143{ 144int match = -1; 145int fd =open(ce->name, O_RDONLY); 146 147if(fd >=0) { 148unsigned char sha1[20]; 149if(!index_fd(sha1, fd, st, OBJ_BLOB, ce->name,0)) 150 match =hashcmp(sha1, ce->sha1); 151/* index_fd() closed the file descriptor already */ 152} 153return match; 154} 155 156static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 157{ 158int match = -1; 159void*buffer; 160unsigned long size; 161enum object_type type; 162struct strbuf sb = STRBUF_INIT; 163 164if(strbuf_readlink(&sb, ce->name, expected_size)) 165return-1; 166 167 buffer =read_sha1_file(ce->sha1, &type, &size); 168if(buffer) { 169if(size == sb.len) 170 match =memcmp(buffer, sb.buf, size); 171free(buffer); 172} 173strbuf_release(&sb); 174return match; 175} 176 177static intce_compare_gitlink(const struct cache_entry *ce) 178{ 179unsigned char sha1[20]; 180 181/* 182 * We don't actually require that the .git directory 183 * under GITLINK directory be a valid git directory. It 184 * might even be missing (in case nobody populated that 185 * sub-project). 186 * 187 * If so, we consider it always to match. 188 */ 189if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 190return0; 191returnhashcmp(sha1, ce->sha1); 192} 193 194static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 195{ 196switch(st->st_mode & S_IFMT) { 197case S_IFREG: 198if(ce_compare_data(ce, st)) 199return DATA_CHANGED; 200break; 201case S_IFLNK: 202if(ce_compare_link(ce,xsize_t(st->st_size))) 203return DATA_CHANGED; 204break; 205case S_IFDIR: 206if(S_ISGITLINK(ce->ce_mode)) 207returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 208default: 209return TYPE_CHANGED; 210} 211return0; 212} 213 214static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 215{ 216unsigned int changed =0; 217 218if(ce->ce_flags & CE_REMOVE) 219return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 220 221switch(ce->ce_mode & S_IFMT) { 222case S_IFREG: 223 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 224/* We consider only the owner x bit to be relevant for 225 * "mode changes" 226 */ 227if(trust_executable_bit && 228(0100& (ce->ce_mode ^ st->st_mode))) 229 changed |= MODE_CHANGED; 230break; 231case S_IFLNK: 232if(!S_ISLNK(st->st_mode) && 233(has_symlinks || !S_ISREG(st->st_mode))) 234 changed |= TYPE_CHANGED; 235break; 236case S_IFGITLINK: 237/* We ignore most of the st_xxx fields for gitlinks */ 238if(!S_ISDIR(st->st_mode)) 239 changed |= TYPE_CHANGED; 240else if(ce_compare_gitlink(ce)) 241 changed |= DATA_CHANGED; 242return changed; 243default: 244die("internal error: ce_mode is%o", ce->ce_mode); 245} 246 247 changed |=match_stat_data(&ce->ce_stat_data, st); 248 249/* Racily smudged entry? */ 250if(!ce->ce_stat_data.sd_size) { 251if(!is_empty_blob_sha1(ce->sha1)) 252 changed |= DATA_CHANGED; 253} 254 255return changed; 256} 257 258static intis_racy_timestamp(const struct index_state *istate, 259const struct cache_entry *ce) 260{ 261return(!S_ISGITLINK(ce->ce_mode) && 262 istate->timestamp.sec && 263#ifdef USE_NSEC 264/* nanosecond timestamped files can also be racy! */ 265(istate->timestamp.sec < ce->ce_stat_data.sd_mtime.sec || 266(istate->timestamp.sec == ce->ce_stat_data.sd_mtime.sec && 267 istate->timestamp.nsec <= ce->ce_stat_data.sd_mtime.nsec)) 268#else 269 istate->timestamp.sec <= ce->ce_stat_data.sd_mtime.sec 270#endif 271); 272} 273 274intie_match_stat(const struct index_state *istate, 275const struct cache_entry *ce,struct stat *st, 276unsigned int options) 277{ 278unsigned int changed; 279int ignore_valid = options & CE_MATCH_IGNORE_VALID; 280int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 281int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 282 283/* 284 * If it's marked as always valid in the index, it's 285 * valid whatever the checked-out copy says. 286 * 287 * skip-worktree has the same effect with higher precedence 288 */ 289if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 290return0; 291if(!ignore_valid && (ce->ce_flags & CE_VALID)) 292return0; 293 294/* 295 * Intent-to-add entries have not been added, so the index entry 296 * by definition never matches what is in the work tree until it 297 * actually gets added. 298 */ 299if(ce->ce_flags & CE_INTENT_TO_ADD) 300return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 301 302 changed =ce_match_stat_basic(ce, st); 303 304/* 305 * Within 1 second of this sequence: 306 * echo xyzzy >file && git-update-index --add file 307 * running this command: 308 * echo frotz >file 309 * would give a falsely clean cache entry. The mtime and 310 * length match the cache, and other stat fields do not change. 311 * 312 * We could detect this at update-index time (the cache entry 313 * being registered/updated records the same time as "now") 314 * and delay the return from git-update-index, but that would 315 * effectively mean we can make at most one commit per second, 316 * which is not acceptable. Instead, we check cache entries 317 * whose mtime are the same as the index file timestamp more 318 * carefully than others. 319 */ 320if(!changed &&is_racy_timestamp(istate, ce)) { 321if(assume_racy_is_modified) 322 changed |= DATA_CHANGED; 323else 324 changed |=ce_modified_check_fs(ce, st); 325} 326 327return changed; 328} 329 330intie_modified(const struct index_state *istate, 331const struct cache_entry *ce, 332struct stat *st,unsigned int options) 333{ 334int changed, changed_fs; 335 336 changed =ie_match_stat(istate, ce, st, options); 337if(!changed) 338return0; 339/* 340 * If the mode or type has changed, there's no point in trying 341 * to refresh the entry - it's not going to match 342 */ 343if(changed & (MODE_CHANGED | TYPE_CHANGED)) 344return changed; 345 346/* 347 * Immediately after read-tree or update-index --cacheinfo, 348 * the length field is zero, as we have never even read the 349 * lstat(2) information once, and we cannot trust DATA_CHANGED 350 * returned by ie_match_stat() which in turn was returned by 351 * ce_match_stat_basic() to signal that the filesize of the 352 * blob changed. We have to actually go to the filesystem to 353 * see if the contents match, and if so, should answer "unchanged". 354 * 355 * The logic does not apply to gitlinks, as ce_match_stat_basic() 356 * already has checked the actual HEAD from the filesystem in the 357 * subproject. If ie_match_stat() already said it is different, 358 * then we know it is. 359 */ 360if((changed & DATA_CHANGED) && 361(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 362return changed; 363 364 changed_fs =ce_modified_check_fs(ce, st); 365if(changed_fs) 366return changed | changed_fs; 367return0; 368} 369 370intbase_name_compare(const char*name1,int len1,int mode1, 371const char*name2,int len2,int mode2) 372{ 373unsigned char c1, c2; 374int len = len1 < len2 ? len1 : len2; 375int cmp; 376 377 cmp =memcmp(name1, name2, len); 378if(cmp) 379return cmp; 380 c1 = name1[len]; 381 c2 = name2[len]; 382if(!c1 &&S_ISDIR(mode1)) 383 c1 ='/'; 384if(!c2 &&S_ISDIR(mode2)) 385 c2 ='/'; 386return(c1 < c2) ? -1: (c1 > c2) ?1:0; 387} 388 389/* 390 * df_name_compare() is identical to base_name_compare(), except it 391 * compares conflicting directory/file entries as equal. Note that 392 * while a directory name compares as equal to a regular file, they 393 * then individually compare _differently_ to a filename that has 394 * a dot after the basename (because '\0' < '.' < '/'). 395 * 396 * This is used by routines that want to traverse the git namespace 397 * but then handle conflicting entries together when possible. 398 */ 399intdf_name_compare(const char*name1,int len1,int mode1, 400const char*name2,int len2,int mode2) 401{ 402int len = len1 < len2 ? len1 : len2, cmp; 403unsigned char c1, c2; 404 405 cmp =memcmp(name1, name2, len); 406if(cmp) 407return cmp; 408/* Directories and files compare equal (same length, same name) */ 409if(len1 == len2) 410return0; 411 c1 = name1[len]; 412if(!c1 &&S_ISDIR(mode1)) 413 c1 ='/'; 414 c2 = name2[len]; 415if(!c2 &&S_ISDIR(mode2)) 416 c2 ='/'; 417if(c1 =='/'&& !c2) 418return0; 419if(c2 =='/'&& !c1) 420return0; 421return c1 - c2; 422} 423 424intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 425{ 426int len = len1 < len2 ? len1 : len2; 427int cmp; 428 429 cmp =memcmp(name1, name2, len); 430if(cmp) 431return cmp; 432if(len1 < len2) 433return-1; 434if(len1 > len2) 435return1; 436 437if(stage1 < stage2) 438return-1; 439if(stage1 > stage2) 440return1; 441return0; 442} 443 444intcache_name_compare(const char*name1,int len1,const char*name2,int len2) 445{ 446returncache_name_stage_compare(name1, len1,0, name2, len2,0); 447} 448 449static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 450{ 451int first, last; 452 453 first =0; 454 last = istate->cache_nr; 455while(last > first) { 456int next = (last + first) >>1; 457struct cache_entry *ce = istate->cache[next]; 458int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 459if(!cmp) 460return next; 461if(cmp <0) { 462 last = next; 463continue; 464} 465 first = next+1; 466} 467return-first-1; 468} 469 470intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 471{ 472returnindex_name_stage_pos(istate, name, namelen,0); 473} 474 475/* Remove entry, return true if there are more entries to go.. */ 476intremove_index_entry_at(struct index_state *istate,int pos) 477{ 478struct cache_entry *ce = istate->cache[pos]; 479 480record_resolve_undo(istate, ce); 481remove_name_hash(istate, ce); 482free(ce); 483 istate->cache_changed =1; 484 istate->cache_nr--; 485if(pos >= istate->cache_nr) 486return0; 487memmove(istate->cache + pos, 488 istate->cache + pos +1, 489(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 490return1; 491} 492 493/* 494 * Remove all cache entries marked for removal, that is where 495 * CE_REMOVE is set in ce_flags. This is much more effective than 496 * calling remove_index_entry_at() for each entry to be removed. 497 */ 498voidremove_marked_cache_entries(struct index_state *istate) 499{ 500struct cache_entry **ce_array = istate->cache; 501unsigned int i, j; 502 503for(i = j =0; i < istate->cache_nr; i++) { 504if(ce_array[i]->ce_flags & CE_REMOVE) { 505remove_name_hash(istate, ce_array[i]); 506free(ce_array[i]); 507} 508else 509 ce_array[j++] = ce_array[i]; 510} 511 istate->cache_changed =1; 512 istate->cache_nr = j; 513} 514 515intremove_file_from_index(struct index_state *istate,const char*path) 516{ 517int pos =index_name_pos(istate, path,strlen(path)); 518if(pos <0) 519 pos = -pos-1; 520cache_tree_invalidate_path(istate->cache_tree, path); 521while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 522remove_index_entry_at(istate, pos); 523return0; 524} 525 526static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 527{ 528return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 529} 530 531static intindex_name_pos_also_unmerged(struct index_state *istate, 532const char*path,int namelen) 533{ 534int pos =index_name_pos(istate, path, namelen); 535struct cache_entry *ce; 536 537if(pos >=0) 538return pos; 539 540/* maybe unmerged? */ 541 pos = -1- pos; 542if(pos >= istate->cache_nr || 543compare_name((ce = istate->cache[pos]), path, namelen)) 544return-1; 545 546/* order of preference: stage 2, 1, 3 */ 547if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 548ce_stage((ce = istate->cache[pos +1])) ==2&& 549!compare_name(ce, path, namelen)) 550 pos++; 551return pos; 552} 553 554static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 555{ 556int len =ce_namelen(ce); 557returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 558} 559 560/* 561 * If we add a filename that aliases in the cache, we will use the 562 * name that we already have - but we don't want to update the same 563 * alias twice, because that implies that there were actually two 564 * different files with aliasing names! 565 * 566 * So we use the CE_ADDED flag to verify that the alias was an old 567 * one before we accept it as 568 */ 569static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 570{ 571int len; 572struct cache_entry *new; 573 574if(alias->ce_flags & CE_ADDED) 575die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 576 577/* Ok, create the new entry using the name of the existing alias */ 578 len =ce_namelen(alias); 579new=xcalloc(1,cache_entry_size(len)); 580memcpy(new->name, alias->name, len); 581copy_cache_entry(new, ce); 582free(ce); 583return new; 584} 585 586static voidrecord_intent_to_add(struct cache_entry *ce) 587{ 588unsigned char sha1[20]; 589if(write_sha1_file("",0, blob_type, sha1)) 590die("cannot create an empty blob in the object database"); 591hashcpy(ce->sha1, sha1); 592} 593 594intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 595{ 596int size, namelen, was_same; 597 mode_t st_mode = st->st_mode; 598struct cache_entry *ce, *alias; 599unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 600int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 601int pretend = flags & ADD_CACHE_PRETEND; 602int intent_only = flags & ADD_CACHE_INTENT; 603int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 604(intent_only ? ADD_CACHE_NEW_ONLY :0)); 605 606if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 607returnerror("%s: can only add regular files, symbolic links or git-directories", path); 608 609 namelen =strlen(path); 610if(S_ISDIR(st_mode)) { 611while(namelen && path[namelen-1] =='/') 612 namelen--; 613} 614 size =cache_entry_size(namelen); 615 ce =xcalloc(1, size); 616memcpy(ce->name, path, namelen); 617 ce->ce_namelen = namelen; 618if(!intent_only) 619fill_stat_cache_info(ce, st); 620else 621 ce->ce_flags |= CE_INTENT_TO_ADD; 622 623if(trust_executable_bit && has_symlinks) 624 ce->ce_mode =create_ce_mode(st_mode); 625else{ 626/* If there is an existing entry, pick the mode bits and type 627 * from it, otherwise assume unexecutable regular file. 628 */ 629struct cache_entry *ent; 630int pos =index_name_pos_also_unmerged(istate, path, namelen); 631 632 ent = (0<= pos) ? istate->cache[pos] : NULL; 633 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 634} 635 636/* When core.ignorecase=true, determine if a directory of the same name but differing 637 * case already exists within the Git repository. If it does, ensure the directory 638 * case of the file being added to the repository matches (is folded into) the existing 639 * entry's directory case. 640 */ 641if(ignore_case) { 642const char*startPtr = ce->name; 643const char*ptr = startPtr; 644while(*ptr) { 645while(*ptr && *ptr !='/') 646++ptr; 647if(*ptr =='/') { 648struct cache_entry *foundce; 649++ptr; 650 foundce =index_dir_exists(istate, ce->name, ptr - ce->name -1); 651if(foundce) { 652memcpy((void*)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr); 653 startPtr = ptr; 654} 655} 656} 657} 658 659 alias =index_file_exists(istate, ce->name,ce_namelen(ce), ignore_case); 660if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 661/* Nothing changed, really */ 662free(ce); 663if(!S_ISGITLINK(alias->ce_mode)) 664ce_mark_uptodate(alias); 665 alias->ce_flags |= CE_ADDED; 666return0; 667} 668if(!intent_only) { 669if(index_path(ce->sha1, path, st, HASH_WRITE_OBJECT)) 670returnerror("unable to index file%s", path); 671}else 672record_intent_to_add(ce); 673 674if(ignore_case && alias &&different_name(ce, alias)) 675 ce =create_alias_ce(ce, alias); 676 ce->ce_flags |= CE_ADDED; 677 678/* It was suspected to be racily clean, but it turns out to be Ok */ 679 was_same = (alias && 680!ce_stage(alias) && 681!hashcmp(alias->sha1, ce->sha1) && 682 ce->ce_mode == alias->ce_mode); 683 684if(pretend) 685; 686else if(add_index_entry(istate, ce, add_option)) 687returnerror("unable to add%sto index",path); 688if(verbose && !was_same) 689printf("add '%s'\n", path); 690return0; 691} 692 693intadd_file_to_index(struct index_state *istate,const char*path,int flags) 694{ 695struct stat st; 696if(lstat(path, &st)) 697die_errno("unable to stat '%s'", path); 698returnadd_to_index(istate, path, &st, flags); 699} 700 701struct cache_entry *make_cache_entry(unsigned int mode, 702const unsigned char*sha1,const char*path,int stage, 703int refresh) 704{ 705int size, len; 706struct cache_entry *ce; 707 708if(!verify_path(path)) { 709error("Invalid path '%s'", path); 710return NULL; 711} 712 713 len =strlen(path); 714 size =cache_entry_size(len); 715 ce =xcalloc(1, size); 716 717hashcpy(ce->sha1, sha1); 718memcpy(ce->name, path, len); 719 ce->ce_flags =create_ce_flags(stage); 720 ce->ce_namelen = len; 721 ce->ce_mode =create_ce_mode(mode); 722 723if(refresh) 724returnrefresh_cache_entry(ce,0); 725 726return ce; 727} 728 729intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 730{ 731int len =ce_namelen(a); 732returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 733} 734 735intce_path_match(const struct cache_entry *ce,const struct pathspec *pathspec) 736{ 737returnmatch_pathspec_depth(pathspec, ce->name,ce_namelen(ce),0, NULL); 738} 739 740/* 741 * We fundamentally don't like some paths: we don't want 742 * dot or dot-dot anywhere, and for obvious reasons don't 743 * want to recurse into ".git" either. 744 * 745 * Also, we don't want double slashes or slashes at the 746 * end that can make pathnames ambiguous. 747 */ 748static intverify_dotfile(const char*rest) 749{ 750/* 751 * The first character was '.', but that 752 * has already been discarded, we now test 753 * the rest. 754 */ 755 756/* "." is not allowed */ 757if(*rest =='\0'||is_dir_sep(*rest)) 758return0; 759 760switch(*rest) { 761/* 762 * ".git" followed by NUL or slash is bad. This 763 * shares the path end test with the ".." case. 764 */ 765case'g': 766if(rest[1] !='i') 767break; 768if(rest[2] !='t') 769break; 770 rest +=2; 771/* fallthrough */ 772case'.': 773if(rest[1] =='\0'||is_dir_sep(rest[1])) 774return0; 775} 776return1; 777} 778 779intverify_path(const char*path) 780{ 781char c; 782 783if(has_dos_drive_prefix(path)) 784return0; 785 786goto inside; 787for(;;) { 788if(!c) 789return1; 790if(is_dir_sep(c)) { 791inside: 792 c = *path++; 793if((c =='.'&& !verify_dotfile(path)) || 794is_dir_sep(c) || c =='\0') 795return0; 796} 797 c = *path++; 798} 799} 800 801/* 802 * Do we have another file that has the beginning components being a 803 * proper superset of the name we're trying to add? 804 */ 805static inthas_file_name(struct index_state *istate, 806const struct cache_entry *ce,int pos,int ok_to_replace) 807{ 808int retval =0; 809int len =ce_namelen(ce); 810int stage =ce_stage(ce); 811const char*name = ce->name; 812 813while(pos < istate->cache_nr) { 814struct cache_entry *p = istate->cache[pos++]; 815 816if(len >=ce_namelen(p)) 817break; 818if(memcmp(name, p->name, len)) 819break; 820if(ce_stage(p) != stage) 821continue; 822if(p->name[len] !='/') 823continue; 824if(p->ce_flags & CE_REMOVE) 825continue; 826 retval = -1; 827if(!ok_to_replace) 828break; 829remove_index_entry_at(istate, --pos); 830} 831return retval; 832} 833 834/* 835 * Do we have another file with a pathname that is a proper 836 * subset of the name we're trying to add? 837 */ 838static inthas_dir_name(struct index_state *istate, 839const struct cache_entry *ce,int pos,int ok_to_replace) 840{ 841int retval =0; 842int stage =ce_stage(ce); 843const char*name = ce->name; 844const char*slash = name +ce_namelen(ce); 845 846for(;;) { 847int len; 848 849for(;;) { 850if(*--slash =='/') 851break; 852if(slash <= ce->name) 853return retval; 854} 855 len = slash - name; 856 857 pos =index_name_stage_pos(istate, name, len, stage); 858if(pos >=0) { 859/* 860 * Found one, but not so fast. This could 861 * be a marker that says "I was here, but 862 * I am being removed". Such an entry is 863 * not a part of the resulting tree, and 864 * it is Ok to have a directory at the same 865 * path. 866 */ 867if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 868 retval = -1; 869if(!ok_to_replace) 870break; 871remove_index_entry_at(istate, pos); 872continue; 873} 874} 875else 876 pos = -pos-1; 877 878/* 879 * Trivial optimization: if we find an entry that 880 * already matches the sub-directory, then we know 881 * we're ok, and we can exit. 882 */ 883while(pos < istate->cache_nr) { 884struct cache_entry *p = istate->cache[pos]; 885if((ce_namelen(p) <= len) || 886(p->name[len] !='/') || 887memcmp(p->name, name, len)) 888break;/* not our subdirectory */ 889if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 890/* 891 * p is at the same stage as our entry, and 892 * is a subdirectory of what we are looking 893 * at, so we cannot have conflicts at our 894 * level or anything shorter. 895 */ 896return retval; 897 pos++; 898} 899} 900return retval; 901} 902 903/* We may be in a situation where we already have path/file and path 904 * is being added, or we already have path and path/file is being 905 * added. Either one would result in a nonsense tree that has path 906 * twice when git-write-tree tries to write it out. Prevent it. 907 * 908 * If ok-to-replace is specified, we remove the conflicting entries 909 * from the cache so the caller should recompute the insert position. 910 * When this happens, we return non-zero. 911 */ 912static intcheck_file_directory_conflict(struct index_state *istate, 913const struct cache_entry *ce, 914int pos,int ok_to_replace) 915{ 916int retval; 917 918/* 919 * When ce is an "I am going away" entry, we allow it to be added 920 */ 921if(ce->ce_flags & CE_REMOVE) 922return0; 923 924/* 925 * We check if the path is a sub-path of a subsequent pathname 926 * first, since removing those will not change the position 927 * in the array. 928 */ 929 retval =has_file_name(istate, ce, pos, ok_to_replace); 930 931/* 932 * Then check if the path might have a clashing sub-directory 933 * before it. 934 */ 935return retval +has_dir_name(istate, ce, pos, ok_to_replace); 936} 937 938static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 939{ 940int pos; 941int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 942int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 943int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 944int new_only = option & ADD_CACHE_NEW_ONLY; 945 946cache_tree_invalidate_path(istate->cache_tree, ce->name); 947 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 948 949/* existing match? Just replace it. */ 950if(pos >=0) { 951if(!new_only) 952replace_index_entry(istate, pos, ce); 953return0; 954} 955 pos = -pos-1; 956 957/* 958 * Inserting a merged entry ("stage 0") into the index 959 * will always replace all non-merged entries.. 960 */ 961if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 962while(ce_same_name(istate->cache[pos], ce)) { 963 ok_to_add =1; 964if(!remove_index_entry_at(istate, pos)) 965break; 966} 967} 968 969if(!ok_to_add) 970return-1; 971if(!verify_path(ce->name)) 972returnerror("Invalid path '%s'", ce->name); 973 974if(!skip_df_check && 975check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 976if(!ok_to_replace) 977returnerror("'%s' appears as both a file and as a directory", 978 ce->name); 979 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 980 pos = -pos-1; 981} 982return pos +1; 983} 984 985intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 986{ 987int pos; 988 989if(option & ADD_CACHE_JUST_APPEND) 990 pos = istate->cache_nr; 991else{ 992int ret; 993 ret =add_index_entry_with_check(istate, ce, option); 994if(ret <=0) 995return ret; 996 pos = ret -1; 997} 998 999/* Make sure the array is big enough .. */1000if(istate->cache_nr == istate->cache_alloc) {1001 istate->cache_alloc =alloc_nr(istate->cache_alloc);1002 istate->cache =xrealloc(istate->cache,1003 istate->cache_alloc *sizeof(*istate->cache));1004}10051006/* Add it in.. */1007 istate->cache_nr++;1008if(istate->cache_nr > pos +1)1009memmove(istate->cache + pos +1,1010 istate->cache + pos,1011(istate->cache_nr - pos -1) *sizeof(ce));1012set_index_entry(istate, pos, ce);1013 istate->cache_changed =1;1014return0;1015}10161017/*1018 * "refresh" does not calculate a new sha1 file or bring the1019 * cache up-to-date for mode/content changes. But what it1020 * _does_ do is to "re-match" the stat information of a file1021 * with the cache, so that you can refresh the cache for a1022 * file that hasn't been changed but where the stat entry is1023 * out of date.1024 *1025 * For example, you'd want to do this after doing a "git-read-tree",1026 * to link up the stat cache details with the proper files.1027 */1028static struct cache_entry *refresh_cache_ent(struct index_state *istate,1029struct cache_entry *ce,1030unsigned int options,int*err,1031int*changed_ret)1032{1033struct stat st;1034struct cache_entry *updated;1035int changed, size;1036int ignore_valid = options & CE_MATCH_IGNORE_VALID;1037int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;10381039if(ce_uptodate(ce))1040return ce;10411042/*1043 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1044 * that the change to the work tree does not matter and told1045 * us not to worry.1046 */1047if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1048ce_mark_uptodate(ce);1049return ce;1050}1051if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1052ce_mark_uptodate(ce);1053return ce;1054}10551056if(lstat(ce->name, &st) <0) {1057if(err)1058*err = errno;1059return NULL;1060}10611062 changed =ie_match_stat(istate, ce, &st, options);1063if(changed_ret)1064*changed_ret = changed;1065if(!changed) {1066/*1067 * The path is unchanged. If we were told to ignore1068 * valid bit, then we did the actual stat check and1069 * found that the entry is unmodified. If the entry1070 * is not marked VALID, this is the place to mark it1071 * valid again, under "assume unchanged" mode.1072 */1073if(ignore_valid && assume_unchanged &&1074!(ce->ce_flags & CE_VALID))1075;/* mark this one VALID again */1076else{1077/*1078 * We do not mark the index itself "modified"1079 * because CE_UPTODATE flag is in-core only;1080 * we are not going to write this change out.1081 */1082if(!S_ISGITLINK(ce->ce_mode))1083ce_mark_uptodate(ce);1084return ce;1085}1086}10871088if(ie_modified(istate, ce, &st, options)) {1089if(err)1090*err = EINVAL;1091return NULL;1092}10931094 size =ce_size(ce);1095 updated =xmalloc(size);1096memcpy(updated, ce, size);1097fill_stat_cache_info(updated, &st);1098/*1099 * If ignore_valid is not set, we should leave CE_VALID bit1100 * alone. Otherwise, paths marked with --no-assume-unchanged1101 * (i.e. things to be edited) will reacquire CE_VALID bit1102 * automatically, which is not really what we want.1103 */1104if(!ignore_valid && assume_unchanged &&1105!(ce->ce_flags & CE_VALID))1106 updated->ce_flags &= ~CE_VALID;11071108return updated;1109}11101111static voidshow_file(const char* fmt,const char* name,int in_porcelain,1112int* first,const char*header_msg)1113{1114if(in_porcelain && *first && header_msg) {1115printf("%s\n", header_msg);1116*first =0;1117}1118printf(fmt, name);1119}11201121intrefresh_index(struct index_state *istate,unsigned int flags,1122const struct pathspec *pathspec,1123char*seen,const char*header_msg)1124{1125int i;1126int has_errors =0;1127int really = (flags & REFRESH_REALLY) !=0;1128int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1129int quiet = (flags & REFRESH_QUIET) !=0;1130int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1131int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1132int first =1;1133int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1134unsigned int options = really ? CE_MATCH_IGNORE_VALID :0;1135const char*modified_fmt;1136const char*deleted_fmt;1137const char*typechange_fmt;1138const char*added_fmt;1139const char*unmerged_fmt;11401141 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1142 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1143 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1144 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1145 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1146for(i =0; i < istate->cache_nr; i++) {1147struct cache_entry *ce, *new;1148int cache_errno =0;1149int changed =0;1150int filtered =0;11511152 ce = istate->cache[i];1153if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1154continue;11551156if(pathspec &&1157!match_pathspec_depth(pathspec, ce->name,ce_namelen(ce),0, seen))1158 filtered =1;11591160if(ce_stage(ce)) {1161while((i < istate->cache_nr) &&1162!strcmp(istate->cache[i]->name, ce->name))1163 i++;1164 i--;1165if(allow_unmerged)1166continue;1167if(!filtered)1168show_file(unmerged_fmt, ce->name, in_porcelain,1169&first, header_msg);1170 has_errors =1;1171continue;1172}11731174if(filtered)1175continue;11761177new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1178if(new== ce)1179continue;1180if(!new) {1181const char*fmt;11821183if(not_new && cache_errno == ENOENT)1184continue;1185if(really && cache_errno == EINVAL) {1186/* If we are doing --really-refresh that1187 * means the index is not valid anymore.1188 */1189 ce->ce_flags &= ~CE_VALID;1190 istate->cache_changed =1;1191}1192if(quiet)1193continue;11941195if(cache_errno == ENOENT)1196 fmt = deleted_fmt;1197else if(ce->ce_flags & CE_INTENT_TO_ADD)1198 fmt = added_fmt;/* must be before other checks */1199else if(changed & TYPE_CHANGED)1200 fmt = typechange_fmt;1201else1202 fmt = modified_fmt;1203show_file(fmt,1204 ce->name, in_porcelain, &first, header_msg);1205 has_errors =1;1206continue;1207}12081209replace_index_entry(istate, i,new);1210}1211return has_errors;1212}12131214static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really)1215{1216returnrefresh_cache_ent(&the_index, ce, really, NULL, NULL);1217}121812191220/*****************************************************************1221 * Index File I/O1222 *****************************************************************/12231224#define INDEX_FORMAT_DEFAULT 312251226/*1227 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1228 * Again - this is just a (very strong in practice) heuristic that1229 * the inode hasn't changed.1230 *1231 * We save the fields in big-endian order to allow using the1232 * index file over NFS transparently.1233 */1234struct ondisk_cache_entry {1235struct cache_time ctime;1236struct cache_time mtime;1237uint32_t dev;1238uint32_t ino;1239uint32_t mode;1240uint32_t uid;1241uint32_t gid;1242uint32_t size;1243unsigned char sha1[20];1244uint16_t flags;1245char name[FLEX_ARRAY];/* more */1246};12471248/*1249 * This struct is used when CE_EXTENDED bit is 11250 * The struct must match ondisk_cache_entry exactly from1251 * ctime till flags1252 */1253struct ondisk_cache_entry_extended {1254struct cache_time ctime;1255struct cache_time mtime;1256uint32_t dev;1257uint32_t ino;1258uint32_t mode;1259uint32_t uid;1260uint32_t gid;1261uint32_t size;1262unsigned char sha1[20];1263uint16_t flags;1264uint16_t flags2;1265char name[FLEX_ARRAY];/* more */1266};12671268/* These are only used for v3 or lower */1269#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1270#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1271#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1272#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1273 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1274 ondisk_cache_entry_size(ce_namelen(ce)))12751276static intverify_hdr(struct cache_header *hdr,unsigned long size)1277{1278 git_SHA_CTX c;1279unsigned char sha1[20];1280int hdr_version;12811282if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1283returnerror("bad signature");1284 hdr_version =ntohl(hdr->hdr_version);1285if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1286returnerror("bad index version%d", hdr_version);1287git_SHA1_Init(&c);1288git_SHA1_Update(&c, hdr, size -20);1289git_SHA1_Final(sha1, &c);1290if(hashcmp(sha1, (unsigned char*)hdr + size -20))1291returnerror("bad index file sha1 signature");1292return0;1293}12941295static intread_index_extension(struct index_state *istate,1296const char*ext,void*data,unsigned long sz)1297{1298switch(CACHE_EXT(ext)) {1299case CACHE_EXT_TREE:1300 istate->cache_tree =cache_tree_read(data, sz);1301break;1302case CACHE_EXT_RESOLVE_UNDO:1303 istate->resolve_undo =resolve_undo_read(data, sz);1304break;1305default:1306if(*ext <'A'||'Z'< *ext)1307returnerror("index uses %.4s extension, which we do not understand",1308 ext);1309fprintf(stderr,"ignoring %.4s extension\n", ext);1310break;1311}1312return0;1313}13141315intread_index(struct index_state *istate)1316{1317returnread_index_from(istate,get_index_file());1318}13191320#ifndef NEEDS_ALIGNED_ACCESS1321#define ntoh_s(var) ntohs(var)1322#define ntoh_l(var) ntohl(var)1323#else1324staticinlineuint16_tntoh_s_force_align(void*p)1325{1326uint16_t x;1327memcpy(&x, p,sizeof(x));1328returnntohs(x);1329}1330staticinlineuint32_tntoh_l_force_align(void*p)1331{1332uint32_t x;1333memcpy(&x, p,sizeof(x));1334returnntohl(x);1335}1336#define ntoh_s(var) ntoh_s_force_align(&(var))1337#define ntoh_l(var) ntoh_l_force_align(&(var))1338#endif13391340static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1341unsigned int flags,1342const char*name,1343size_t len)1344{1345struct cache_entry *ce =xmalloc(cache_entry_size(len));13461347 ce->ce_stat_data.sd_ctime.sec =ntoh_l(ondisk->ctime.sec);1348 ce->ce_stat_data.sd_mtime.sec =ntoh_l(ondisk->mtime.sec);1349 ce->ce_stat_data.sd_ctime.nsec =ntoh_l(ondisk->ctime.nsec);1350 ce->ce_stat_data.sd_mtime.nsec =ntoh_l(ondisk->mtime.nsec);1351 ce->ce_stat_data.sd_dev =ntoh_l(ondisk->dev);1352 ce->ce_stat_data.sd_ino =ntoh_l(ondisk->ino);1353 ce->ce_mode =ntoh_l(ondisk->mode);1354 ce->ce_stat_data.sd_uid =ntoh_l(ondisk->uid);1355 ce->ce_stat_data.sd_gid =ntoh_l(ondisk->gid);1356 ce->ce_stat_data.sd_size =ntoh_l(ondisk->size);1357 ce->ce_flags = flags & ~CE_NAMEMASK;1358 ce->ce_namelen = len;1359hashcpy(ce->sha1, ondisk->sha1);1360memcpy(ce->name, name, len);1361 ce->name[len] ='\0';1362return ce;1363}13641365/*1366 * Adjacent cache entries tend to share the leading paths, so it makes1367 * sense to only store the differences in later entries. In the v41368 * on-disk format of the index, each on-disk cache entry stores the1369 * number of bytes to be stripped from the end of the previous name,1370 * and the bytes to append to the result, to come up with its name.1371 */1372static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1373{1374const unsigned char*ep, *cp = (const unsigned char*)cp_;1375size_t len =decode_varint(&cp);13761377if(name->len < len)1378die("malformed name field in the index");1379strbuf_remove(name, name->len - len, len);1380for(ep = cp; *ep; ep++)1381;/* find the end */1382strbuf_add(name, cp, ep - cp);1383return(const char*)ep +1- cp_;1384}13851386static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1387unsigned long*ent_size,1388struct strbuf *previous_name)1389{1390struct cache_entry *ce;1391size_t len;1392const char*name;1393unsigned int flags;13941395/* On-disk flags are just 16 bits */1396 flags =ntoh_s(ondisk->flags);1397 len = flags & CE_NAMEMASK;13981399if(flags & CE_EXTENDED) {1400struct ondisk_cache_entry_extended *ondisk2;1401int extended_flags;1402 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1403 extended_flags =ntoh_s(ondisk2->flags2) <<16;1404/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1405if(extended_flags & ~CE_EXTENDED_FLAGS)1406die("Unknown index entry format%08x", extended_flags);1407 flags |= extended_flags;1408 name = ondisk2->name;1409}1410else1411 name = ondisk->name;14121413if(!previous_name) {1414/* v3 and earlier */1415if(len == CE_NAMEMASK)1416 len =strlen(name);1417 ce =cache_entry_from_ondisk(ondisk, flags, name, len);14181419*ent_size =ondisk_ce_size(ce);1420}else{1421unsigned long consumed;1422 consumed =expand_name_field(previous_name, name);1423 ce =cache_entry_from_ondisk(ondisk, flags,1424 previous_name->buf,1425 previous_name->len);14261427*ent_size = (name - ((char*)ondisk)) + consumed;1428}1429return ce;1430}14311432/* remember to discard_cache() before reading a different cache! */1433intread_index_from(struct index_state *istate,const char*path)1434{1435int fd, i;1436struct stat st;1437unsigned long src_offset;1438struct cache_header *hdr;1439void*mmap;1440size_t mmap_size;1441struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;14421443if(istate->initialized)1444return istate->cache_nr;14451446 istate->timestamp.sec =0;1447 istate->timestamp.nsec =0;1448 fd =open(path, O_RDONLY);1449if(fd <0) {1450if(errno == ENOENT)1451return0;1452die_errno("index file open failed");1453}14541455if(fstat(fd, &st))1456die_errno("cannot stat the open index");14571458 mmap_size =xsize_t(st.st_size);1459if(mmap_size <sizeof(struct cache_header) +20)1460die("index file smaller than expected");14611462 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1463if(mmap == MAP_FAILED)1464die_errno("unable to map index file");1465close(fd);14661467 hdr = mmap;1468if(verify_hdr(hdr, mmap_size) <0)1469goto unmap;14701471 istate->version =ntohl(hdr->hdr_version);1472 istate->cache_nr =ntohl(hdr->hdr_entries);1473 istate->cache_alloc =alloc_nr(istate->cache_nr);1474 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1475 istate->initialized =1;14761477if(istate->version ==4)1478 previous_name = &previous_name_buf;1479else1480 previous_name = NULL;14811482 src_offset =sizeof(*hdr);1483for(i =0; i < istate->cache_nr; i++) {1484struct ondisk_cache_entry *disk_ce;1485struct cache_entry *ce;1486unsigned long consumed;14871488 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1489 ce =create_from_disk(disk_ce, &consumed, previous_name);1490set_index_entry(istate, i, ce);14911492 src_offset += consumed;1493}1494strbuf_release(&previous_name_buf);1495 istate->timestamp.sec = st.st_mtime;1496 istate->timestamp.nsec =ST_MTIME_NSEC(st);14971498while(src_offset <= mmap_size -20-8) {1499/* After an array of active_nr index entries,1500 * there can be arbitrary number of extended1501 * sections, each of which is prefixed with1502 * extension name (4-byte) and section length1503 * in 4-byte network byte order.1504 */1505uint32_t extsize;1506memcpy(&extsize, (char*)mmap + src_offset +4,4);1507 extsize =ntohl(extsize);1508if(read_index_extension(istate,1509(const char*) mmap + src_offset,1510(char*) mmap + src_offset +8,1511 extsize) <0)1512goto unmap;1513 src_offset +=8;1514 src_offset += extsize;1515}1516munmap(mmap, mmap_size);1517return istate->cache_nr;15181519unmap:1520munmap(mmap, mmap_size);1521die("index file corrupt");1522}15231524intis_index_unborn(struct index_state *istate)1525{1526return(!istate->cache_nr && !istate->timestamp.sec);1527}15281529intdiscard_index(struct index_state *istate)1530{1531int i;15321533for(i =0; i < istate->cache_nr; i++)1534free(istate->cache[i]);1535resolve_undo_clear_index(istate);1536 istate->cache_nr =0;1537 istate->cache_changed =0;1538 istate->timestamp.sec =0;1539 istate->timestamp.nsec =0;1540free_name_hash(istate);1541cache_tree_free(&(istate->cache_tree));1542 istate->initialized =0;1543free(istate->cache);1544 istate->cache = NULL;1545 istate->cache_alloc =0;1546return0;1547}15481549intunmerged_index(const struct index_state *istate)1550{1551int i;1552for(i =0; i < istate->cache_nr; i++) {1553if(ce_stage(istate->cache[i]))1554return1;1555}1556return0;1557}15581559#define WRITE_BUFFER_SIZE 81921560static unsigned char write_buffer[WRITE_BUFFER_SIZE];1561static unsigned long write_buffer_len;15621563static intce_write_flush(git_SHA_CTX *context,int fd)1564{1565unsigned int buffered = write_buffer_len;1566if(buffered) {1567git_SHA1_Update(context, write_buffer, buffered);1568if(write_in_full(fd, write_buffer, buffered) != buffered)1569return-1;1570 write_buffer_len =0;1571}1572return0;1573}15741575static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1576{1577while(len) {1578unsigned int buffered = write_buffer_len;1579unsigned int partial = WRITE_BUFFER_SIZE - buffered;1580if(partial > len)1581 partial = len;1582memcpy(write_buffer + buffered, data, partial);1583 buffered += partial;1584if(buffered == WRITE_BUFFER_SIZE) {1585 write_buffer_len = buffered;1586if(ce_write_flush(context, fd))1587return-1;1588 buffered =0;1589}1590 write_buffer_len = buffered;1591 len -= partial;1592 data = (char*) data + partial;1593}1594return0;1595}15961597static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1598unsigned int ext,unsigned int sz)1599{1600 ext =htonl(ext);1601 sz =htonl(sz);1602return((ce_write(context, fd, &ext,4) <0) ||1603(ce_write(context, fd, &sz,4) <0)) ? -1:0;1604}16051606static intce_flush(git_SHA_CTX *context,int fd)1607{1608unsigned int left = write_buffer_len;16091610if(left) {1611 write_buffer_len =0;1612git_SHA1_Update(context, write_buffer, left);1613}16141615/* Flush first if not enough space for SHA1 signature */1616if(left +20> WRITE_BUFFER_SIZE) {1617if(write_in_full(fd, write_buffer, left) != left)1618return-1;1619 left =0;1620}16211622/* Append the SHA1 signature at the end */1623git_SHA1_Final(write_buffer + left, context);1624 left +=20;1625return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1626}16271628static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1629{1630/*1631 * The only thing we care about in this function is to smudge the1632 * falsely clean entry due to touch-update-touch race, so we leave1633 * everything else as they are. We are called for entries whose1634 * ce_stat_data.sd_mtime match the index file mtime.1635 *1636 * Note that this actually does not do much for gitlinks, for1637 * which ce_match_stat_basic() always goes to the actual1638 * contents. The caller checks with is_racy_timestamp() which1639 * always says "no" for gitlinks, so we are not called for them ;-)1640 */1641struct stat st;16421643if(lstat(ce->name, &st) <0)1644return;1645if(ce_match_stat_basic(ce, &st))1646return;1647if(ce_modified_check_fs(ce, &st)) {1648/* This is "racily clean"; smudge it. Note that this1649 * is a tricky code. At first glance, it may appear1650 * that it can break with this sequence:1651 *1652 * $ echo xyzzy >frotz1653 * $ git-update-index --add frotz1654 * $ : >frotz1655 * $ sleep 31656 * $ echo filfre >nitfol1657 * $ git-update-index --add nitfol1658 *1659 * but it does not. When the second update-index runs,1660 * it notices that the entry "frotz" has the same timestamp1661 * as index, and if we were to smudge it by resetting its1662 * size to zero here, then the object name recorded1663 * in index is the 6-byte file but the cached stat information1664 * becomes zero --- which would then match what we would1665 * obtain from the filesystem next time we stat("frotz").1666 *1667 * However, the second update-index, before calling1668 * this function, notices that the cached size is 61669 * bytes and what is on the filesystem is an empty1670 * file, and never calls us, so the cached size information1671 * for "frotz" stays 6 which does not match the filesystem.1672 */1673 ce->ce_stat_data.sd_size =0;1674}1675}16761677/* Copy miscellaneous fields but not the name */1678static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1679struct cache_entry *ce)1680{1681short flags;16821683 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);1684 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);1685 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);1686 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);1687 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);1688 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);1689 ondisk->mode =htonl(ce->ce_mode);1690 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);1691 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);1692 ondisk->size =htonl(ce->ce_stat_data.sd_size);1693hashcpy(ondisk->sha1, ce->sha1);16941695 flags = ce->ce_flags;1696 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1697 ondisk->flags =htons(flags);1698if(ce->ce_flags & CE_EXTENDED) {1699struct ondisk_cache_entry_extended *ondisk2;1700 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1701 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1702return ondisk2->name;1703}1704else{1705return ondisk->name;1706}1707}17081709static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1710struct strbuf *previous_name)1711{1712int size;1713struct ondisk_cache_entry *ondisk;1714char*name;1715int result;17161717if(!previous_name) {1718 size =ondisk_ce_size(ce);1719 ondisk =xcalloc(1, size);1720 name =copy_cache_entry_to_ondisk(ondisk, ce);1721memcpy(name, ce->name,ce_namelen(ce));1722}else{1723int common, to_remove, prefix_size;1724unsigned char to_remove_vi[16];1725for(common =0;1726(ce->name[common] &&1727 common < previous_name->len &&1728 ce->name[common] == previous_name->buf[common]);1729 common++)1730;/* still matching */1731 to_remove = previous_name->len - common;1732 prefix_size =encode_varint(to_remove, to_remove_vi);17331734if(ce->ce_flags & CE_EXTENDED)1735 size =offsetof(struct ondisk_cache_entry_extended, name);1736else1737 size =offsetof(struct ondisk_cache_entry, name);1738 size += prefix_size + (ce_namelen(ce) - common +1);17391740 ondisk =xcalloc(1, size);1741 name =copy_cache_entry_to_ondisk(ondisk, ce);1742memcpy(name, to_remove_vi, prefix_size);1743memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);17441745strbuf_splice(previous_name, common, to_remove,1746 ce->name + common,ce_namelen(ce) - common);1747}17481749 result =ce_write(c, fd, ondisk, size);1750free(ondisk);1751return result;1752}17531754static inthas_racy_timestamp(struct index_state *istate)1755{1756int entries = istate->cache_nr;1757int i;17581759for(i =0; i < entries; i++) {1760struct cache_entry *ce = istate->cache[i];1761if(is_racy_timestamp(istate, ce))1762return1;1763}1764return0;1765}17661767/*1768 * Opportunistically update the index but do not complain if we can't1769 */1770voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)1771{1772if((istate->cache_changed ||has_racy_timestamp(istate)) &&1773!write_index(istate, lockfile->fd))1774commit_locked_index(lockfile);1775else1776rollback_lock_file(lockfile);1777}17781779intwrite_index(struct index_state *istate,int newfd)1780{1781 git_SHA_CTX c;1782struct cache_header hdr;1783int i, err, removed, extended, hdr_version;1784struct cache_entry **cache = istate->cache;1785int entries = istate->cache_nr;1786struct stat st;1787struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17881789for(i = removed = extended =0; i < entries; i++) {1790if(cache[i]->ce_flags & CE_REMOVE)1791 removed++;17921793/* reduce extended entries if possible */1794 cache[i]->ce_flags &= ~CE_EXTENDED;1795if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1796 extended++;1797 cache[i]->ce_flags |= CE_EXTENDED;1798}1799}18001801if(!istate->version)1802 istate->version = INDEX_FORMAT_DEFAULT;18031804/* demote version 3 to version 2 when the latter suffices */1805if(istate->version ==3|| istate->version ==2)1806 istate->version = extended ?3:2;18071808 hdr_version = istate->version;18091810 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1811 hdr.hdr_version =htonl(hdr_version);1812 hdr.hdr_entries =htonl(entries - removed);18131814git_SHA1_Init(&c);1815if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1816return-1;18171818 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;1819for(i =0; i < entries; i++) {1820struct cache_entry *ce = cache[i];1821if(ce->ce_flags & CE_REMOVE)1822continue;1823if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1824ce_smudge_racily_clean_entry(ce);1825if(is_null_sha1(ce->sha1)) {1826static const char msg[] ="cache entry has null sha1:%s";1827static int allow = -1;18281829if(allow <0)1830 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);1831if(allow)1832warning(msg, ce->name);1833else1834returnerror(msg, ce->name);1835}1836if(ce_write_entry(&c, newfd, ce, previous_name) <0)1837return-1;1838}1839strbuf_release(&previous_name_buf);18401841/* Write extension data here */1842if(istate->cache_tree) {1843struct strbuf sb = STRBUF_INIT;18441845cache_tree_write(&sb, istate->cache_tree);1846 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01847||ce_write(&c, newfd, sb.buf, sb.len) <0;1848strbuf_release(&sb);1849if(err)1850return-1;1851}1852if(istate->resolve_undo) {1853struct strbuf sb = STRBUF_INIT;18541855resolve_undo_write(&sb, istate->resolve_undo);1856 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1857 sb.len) <01858||ce_write(&c, newfd, sb.buf, sb.len) <0;1859strbuf_release(&sb);1860if(err)1861return-1;1862}18631864if(ce_flush(&c, newfd) ||fstat(newfd, &st))1865return-1;1866 istate->timestamp.sec = (unsigned int)st.st_mtime;1867 istate->timestamp.nsec =ST_MTIME_NSEC(st);1868return0;1869}18701871/*1872 * Read the index file that is potentially unmerged into given1873 * index_state, dropping any unmerged entries. Returns true if1874 * the index is unmerged. Callers who want to refuse to work1875 * from an unmerged state can call this and check its return value,1876 * instead of calling read_cache().1877 */1878intread_index_unmerged(struct index_state *istate)1879{1880int i;1881int unmerged =0;18821883read_index(istate);1884for(i =0; i < istate->cache_nr; i++) {1885struct cache_entry *ce = istate->cache[i];1886struct cache_entry *new_ce;1887int size, len;18881889if(!ce_stage(ce))1890continue;1891 unmerged =1;1892 len =ce_namelen(ce);1893 size =cache_entry_size(len);1894 new_ce =xcalloc(1, size);1895memcpy(new_ce->name, ce->name, len);1896 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;1897 new_ce->ce_namelen = len;1898 new_ce->ce_mode = ce->ce_mode;1899if(add_index_entry(istate, new_ce,0))1900returnerror("%s: cannot drop to stage #0",1901 new_ce->name);1902 i =index_name_pos(istate, new_ce->name, len);1903}1904return unmerged;1905}19061907/*1908 * Returns 1 if the path is an "other" path with respect to1909 * the index; that is, the path is not mentioned in the index at all,1910 * either as a file, a directory with some files in the index,1911 * or as an unmerged entry.1912 *1913 * We helpfully remove a trailing "/" from directories so that1914 * the output of read_directory can be used as-is.1915 */1916intindex_name_is_other(const struct index_state *istate,const char*name,1917int namelen)1918{1919int pos;1920if(namelen && name[namelen -1] =='/')1921 namelen--;1922 pos =index_name_pos(istate, name, namelen);1923if(0<= pos)1924return0;/* exact match */1925 pos = -pos -1;1926if(pos < istate->cache_nr) {1927struct cache_entry *ce = istate->cache[pos];1928if(ce_namelen(ce) == namelen &&1929!memcmp(ce->name, name, namelen))1930return0;/* Yup, this one exists unmerged */1931}1932return1;1933}19341935void*read_blob_data_from_index(struct index_state *istate,const char*path,unsigned long*size)1936{1937int pos, len;1938unsigned long sz;1939enum object_type type;1940void*data;19411942 len =strlen(path);1943 pos =index_name_pos(istate, path, len);1944if(pos <0) {1945/*1946 * We might be in the middle of a merge, in which1947 * case we would read stage #2 (ours).1948 */1949int i;1950for(i = -pos -1;1951(pos <0&& i < istate->cache_nr &&1952!strcmp(istate->cache[i]->name, path));1953 i++)1954if(ce_stage(istate->cache[i]) ==2)1955 pos = i;1956}1957if(pos <0)1958return NULL;1959 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz);1960if(!data || type != OBJ_BLOB) {1961free(data);1962return NULL;1963}1964if(size)1965*size = sz;1966return data;1967}19681969voidstat_validity_clear(struct stat_validity *sv)1970{1971free(sv->sd);1972 sv->sd = NULL;1973}19741975intstat_validity_check(struct stat_validity *sv,const char*path)1976{1977struct stat st;19781979if(stat(path, &st) <0)1980return sv->sd == NULL;1981if(!sv->sd)1982return0;1983returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);1984}19851986voidstat_validity_update(struct stat_validity *sv,int fd)1987{1988struct stat st;19891990if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))1991stat_validity_clear(sv);1992else{1993if(!sv->sd)1994 sv->sd =xcalloc(1,sizeof(struct stat_data));1995fill_stat_data(sv->sd, &st);1996}1997}