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, 19unsigned int options); 20 21/* Mask for the name length in ce_flags in the on-disk index */ 22 23#define CE_NAMEMASK (0x0fff) 24 25/* Index extensions. 26 * 27 * The first letter should be 'A'..'Z' for extensions that are not 28 * necessary for a correct operation (i.e. optimization data). 29 * When new extensions are added that _needs_ to be understood in 30 * order to correctly interpret the index file, pick character that 31 * is outside the range, to cause the reader to abort. 32 */ 33 34#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 35#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 36#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 37 38struct index_state the_index; 39 40static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 41{ 42 istate->cache[nr] = ce; 43add_name_hash(istate, ce); 44} 45 46static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 47{ 48struct cache_entry *old = istate->cache[nr]; 49 50remove_name_hash(istate, old); 51free(old); 52set_index_entry(istate, nr, ce); 53 istate->cache_changed =1; 54} 55 56voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 57{ 58struct cache_entry *old = istate->cache[nr], *new; 59int namelen =strlen(new_name); 60 61new=xmalloc(cache_entry_size(namelen)); 62copy_cache_entry(new, old); 63new->ce_flags &= ~CE_HASHED; 64new->ce_namelen = namelen; 65memcpy(new->name, new_name, namelen +1); 66 67cache_tree_invalidate_path(istate->cache_tree, old->name); 68remove_index_entry_at(istate, nr); 69add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 70} 71 72voidfill_stat_data(struct stat_data *sd,struct stat *st) 73{ 74 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 75 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 76 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 77 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 78 sd->sd_dev = st->st_dev; 79 sd->sd_ino = st->st_ino; 80 sd->sd_uid = st->st_uid; 81 sd->sd_gid = st->st_gid; 82 sd->sd_size = st->st_size; 83} 84 85intmatch_stat_data(const struct stat_data *sd,struct stat *st) 86{ 87int changed =0; 88 89if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 90 changed |= MTIME_CHANGED; 91if(trust_ctime && check_stat && 92 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 93 changed |= CTIME_CHANGED; 94 95#ifdef USE_NSEC 96if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 97 changed |= MTIME_CHANGED; 98if(trust_ctime && check_stat && 99 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 100 changed |= CTIME_CHANGED; 101#endif 102 103if(check_stat) { 104if(sd->sd_uid != (unsigned int) st->st_uid || 105 sd->sd_gid != (unsigned int) st->st_gid) 106 changed |= OWNER_CHANGED; 107if(sd->sd_ino != (unsigned int) st->st_ino) 108 changed |= INODE_CHANGED; 109} 110 111#ifdef USE_STDEV 112/* 113 * st_dev breaks on network filesystems where different 114 * clients will have different views of what "device" 115 * the filesystem is on 116 */ 117if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 118 changed |= INODE_CHANGED; 119#endif 120 121if(sd->sd_size != (unsigned int) st->st_size) 122 changed |= DATA_CHANGED; 123 124return changed; 125} 126 127/* 128 * This only updates the "non-critical" parts of the directory 129 * cache, ie the parts that aren't tracked by GIT, and only used 130 * to validate the cache. 131 */ 132voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 133{ 134fill_stat_data(&ce->ce_stat_data, st); 135 136if(assume_unchanged) 137 ce->ce_flags |= CE_VALID; 138 139if(S_ISREG(st->st_mode)) 140ce_mark_uptodate(ce); 141} 142 143static intce_compare_data(const struct cache_entry *ce,struct stat *st) 144{ 145int match = -1; 146int fd =open(ce->name, O_RDONLY); 147 148if(fd >=0) { 149unsigned char sha1[20]; 150if(!index_fd(sha1, fd, st, OBJ_BLOB, ce->name,0)) 151 match =hashcmp(sha1, ce->sha1); 152/* index_fd() closed the file descriptor already */ 153} 154return match; 155} 156 157static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 158{ 159int match = -1; 160void*buffer; 161unsigned long size; 162enum object_type type; 163struct strbuf sb = STRBUF_INIT; 164 165if(strbuf_readlink(&sb, ce->name, expected_size)) 166return-1; 167 168 buffer =read_sha1_file(ce->sha1, &type, &size); 169if(buffer) { 170if(size == sb.len) 171 match =memcmp(buffer, sb.buf, size); 172free(buffer); 173} 174strbuf_release(&sb); 175return match; 176} 177 178static intce_compare_gitlink(const struct cache_entry *ce) 179{ 180unsigned char sha1[20]; 181 182/* 183 * We don't actually require that the .git directory 184 * under GITLINK directory be a valid git directory. It 185 * might even be missing (in case nobody populated that 186 * sub-project). 187 * 188 * If so, we consider it always to match. 189 */ 190if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 191return0; 192returnhashcmp(sha1, ce->sha1); 193} 194 195static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 196{ 197switch(st->st_mode & S_IFMT) { 198case S_IFREG: 199if(ce_compare_data(ce, st)) 200return DATA_CHANGED; 201break; 202case S_IFLNK: 203if(ce_compare_link(ce,xsize_t(st->st_size))) 204return DATA_CHANGED; 205break; 206case S_IFDIR: 207if(S_ISGITLINK(ce->ce_mode)) 208returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 209default: 210return TYPE_CHANGED; 211} 212return0; 213} 214 215static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 216{ 217unsigned int changed =0; 218 219if(ce->ce_flags & CE_REMOVE) 220return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 221 222switch(ce->ce_mode & S_IFMT) { 223case S_IFREG: 224 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 225/* We consider only the owner x bit to be relevant for 226 * "mode changes" 227 */ 228if(trust_executable_bit && 229(0100& (ce->ce_mode ^ st->st_mode))) 230 changed |= MODE_CHANGED; 231break; 232case S_IFLNK: 233if(!S_ISLNK(st->st_mode) && 234(has_symlinks || !S_ISREG(st->st_mode))) 235 changed |= TYPE_CHANGED; 236break; 237case S_IFGITLINK: 238/* We ignore most of the st_xxx fields for gitlinks */ 239if(!S_ISDIR(st->st_mode)) 240 changed |= TYPE_CHANGED; 241else if(ce_compare_gitlink(ce)) 242 changed |= DATA_CHANGED; 243return changed; 244default: 245die("internal error: ce_mode is%o", ce->ce_mode); 246} 247 248 changed |=match_stat_data(&ce->ce_stat_data, st); 249 250/* Racily smudged entry? */ 251if(!ce->ce_stat_data.sd_size) { 252if(!is_empty_blob_sha1(ce->sha1)) 253 changed |= DATA_CHANGED; 254} 255 256return changed; 257} 258 259static intis_racy_timestamp(const struct index_state *istate, 260const struct cache_entry *ce) 261{ 262return(!S_ISGITLINK(ce->ce_mode) && 263 istate->timestamp.sec && 264#ifdef USE_NSEC 265/* nanosecond timestamped files can also be racy! */ 266(istate->timestamp.sec < ce->ce_stat_data.sd_mtime.sec || 267(istate->timestamp.sec == ce->ce_stat_data.sd_mtime.sec && 268 istate->timestamp.nsec <= ce->ce_stat_data.sd_mtime.nsec)) 269#else 270 istate->timestamp.sec <= ce->ce_stat_data.sd_mtime.sec 271#endif 272); 273} 274 275intie_match_stat(const struct index_state *istate, 276const struct cache_entry *ce,struct stat *st, 277unsigned int options) 278{ 279unsigned int changed; 280int ignore_valid = options & CE_MATCH_IGNORE_VALID; 281int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 282int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 283 284/* 285 * If it's marked as always valid in the index, it's 286 * valid whatever the checked-out copy says. 287 * 288 * skip-worktree has the same effect with higher precedence 289 */ 290if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 291return0; 292if(!ignore_valid && (ce->ce_flags & CE_VALID)) 293return0; 294 295/* 296 * Intent-to-add entries have not been added, so the index entry 297 * by definition never matches what is in the work tree until it 298 * actually gets added. 299 */ 300if(ce->ce_flags & CE_INTENT_TO_ADD) 301return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 302 303 changed =ce_match_stat_basic(ce, st); 304 305/* 306 * Within 1 second of this sequence: 307 * echo xyzzy >file && git-update-index --add file 308 * running this command: 309 * echo frotz >file 310 * would give a falsely clean cache entry. The mtime and 311 * length match the cache, and other stat fields do not change. 312 * 313 * We could detect this at update-index time (the cache entry 314 * being registered/updated records the same time as "now") 315 * and delay the return from git-update-index, but that would 316 * effectively mean we can make at most one commit per second, 317 * which is not acceptable. Instead, we check cache entries 318 * whose mtime are the same as the index file timestamp more 319 * carefully than others. 320 */ 321if(!changed &&is_racy_timestamp(istate, ce)) { 322if(assume_racy_is_modified) 323 changed |= DATA_CHANGED; 324else 325 changed |=ce_modified_check_fs(ce, st); 326} 327 328return changed; 329} 330 331intie_modified(const struct index_state *istate, 332const struct cache_entry *ce, 333struct stat *st,unsigned int options) 334{ 335int changed, changed_fs; 336 337 changed =ie_match_stat(istate, ce, st, options); 338if(!changed) 339return0; 340/* 341 * If the mode or type has changed, there's no point in trying 342 * to refresh the entry - it's not going to match 343 */ 344if(changed & (MODE_CHANGED | TYPE_CHANGED)) 345return changed; 346 347/* 348 * Immediately after read-tree or update-index --cacheinfo, 349 * the length field is zero, as we have never even read the 350 * lstat(2) information once, and we cannot trust DATA_CHANGED 351 * returned by ie_match_stat() which in turn was returned by 352 * ce_match_stat_basic() to signal that the filesize of the 353 * blob changed. We have to actually go to the filesystem to 354 * see if the contents match, and if so, should answer "unchanged". 355 * 356 * The logic does not apply to gitlinks, as ce_match_stat_basic() 357 * already has checked the actual HEAD from the filesystem in the 358 * subproject. If ie_match_stat() already said it is different, 359 * then we know it is. 360 */ 361if((changed & DATA_CHANGED) && 362(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 363return changed; 364 365 changed_fs =ce_modified_check_fs(ce, st); 366if(changed_fs) 367return changed | changed_fs; 368return0; 369} 370 371intbase_name_compare(const char*name1,int len1,int mode1, 372const char*name2,int len2,int mode2) 373{ 374unsigned char c1, c2; 375int len = len1 < len2 ? len1 : len2; 376int cmp; 377 378 cmp =memcmp(name1, name2, len); 379if(cmp) 380return cmp; 381 c1 = name1[len]; 382 c2 = name2[len]; 383if(!c1 &&S_ISDIR(mode1)) 384 c1 ='/'; 385if(!c2 &&S_ISDIR(mode2)) 386 c2 ='/'; 387return(c1 < c2) ? -1: (c1 > c2) ?1:0; 388} 389 390/* 391 * df_name_compare() is identical to base_name_compare(), except it 392 * compares conflicting directory/file entries as equal. Note that 393 * while a directory name compares as equal to a regular file, they 394 * then individually compare _differently_ to a filename that has 395 * a dot after the basename (because '\0' < '.' < '/'). 396 * 397 * This is used by routines that want to traverse the git namespace 398 * but then handle conflicting entries together when possible. 399 */ 400intdf_name_compare(const char*name1,int len1,int mode1, 401const char*name2,int len2,int mode2) 402{ 403int len = len1 < len2 ? len1 : len2, cmp; 404unsigned char c1, c2; 405 406 cmp =memcmp(name1, name2, len); 407if(cmp) 408return cmp; 409/* Directories and files compare equal (same length, same name) */ 410if(len1 == len2) 411return0; 412 c1 = name1[len]; 413if(!c1 &&S_ISDIR(mode1)) 414 c1 ='/'; 415 c2 = name2[len]; 416if(!c2 &&S_ISDIR(mode2)) 417 c2 ='/'; 418if(c1 =='/'&& !c2) 419return0; 420if(c2 =='/'&& !c1) 421return0; 422return c1 - c2; 423} 424 425intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 426{ 427int len = len1 < len2 ? len1 : len2; 428int cmp; 429 430 cmp =memcmp(name1, name2, len); 431if(cmp) 432return cmp; 433if(len1 < len2) 434return-1; 435if(len1 > len2) 436return1; 437 438if(stage1 < stage2) 439return-1; 440if(stage1 > stage2) 441return1; 442return0; 443} 444 445intcache_name_compare(const char*name1,int len1,const char*name2,int len2) 446{ 447returncache_name_stage_compare(name1, len1,0, name2, len2,0); 448} 449 450static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 451{ 452int first, last; 453 454 first =0; 455 last = istate->cache_nr; 456while(last > first) { 457int next = (last + first) >>1; 458struct cache_entry *ce = istate->cache[next]; 459int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 460if(!cmp) 461return next; 462if(cmp <0) { 463 last = next; 464continue; 465} 466 first = next+1; 467} 468return-first-1; 469} 470 471intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 472{ 473returnindex_name_stage_pos(istate, name, namelen,0); 474} 475 476/* Remove entry, return true if there are more entries to go.. */ 477intremove_index_entry_at(struct index_state *istate,int pos) 478{ 479struct cache_entry *ce = istate->cache[pos]; 480 481record_resolve_undo(istate, ce); 482remove_name_hash(istate, ce); 483free(ce); 484 istate->cache_changed =1; 485 istate->cache_nr--; 486if(pos >= istate->cache_nr) 487return0; 488memmove(istate->cache + pos, 489 istate->cache + pos +1, 490(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 491return1; 492} 493 494/* 495 * Remove all cache entries marked for removal, that is where 496 * CE_REMOVE is set in ce_flags. This is much more effective than 497 * calling remove_index_entry_at() for each entry to be removed. 498 */ 499voidremove_marked_cache_entries(struct index_state *istate) 500{ 501struct cache_entry **ce_array = istate->cache; 502unsigned int i, j; 503 504for(i = j =0; i < istate->cache_nr; i++) { 505if(ce_array[i]->ce_flags & CE_REMOVE) { 506remove_name_hash(istate, ce_array[i]); 507free(ce_array[i]); 508} 509else 510 ce_array[j++] = ce_array[i]; 511} 512 istate->cache_changed =1; 513 istate->cache_nr = j; 514} 515 516intremove_file_from_index(struct index_state *istate,const char*path) 517{ 518int pos =index_name_pos(istate, path,strlen(path)); 519if(pos <0) 520 pos = -pos-1; 521cache_tree_invalidate_path(istate->cache_tree, path); 522while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 523remove_index_entry_at(istate, pos); 524return0; 525} 526 527static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 528{ 529return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 530} 531 532static intindex_name_pos_also_unmerged(struct index_state *istate, 533const char*path,int namelen) 534{ 535int pos =index_name_pos(istate, path, namelen); 536struct cache_entry *ce; 537 538if(pos >=0) 539return pos; 540 541/* maybe unmerged? */ 542 pos = -1- pos; 543if(pos >= istate->cache_nr || 544compare_name((ce = istate->cache[pos]), path, namelen)) 545return-1; 546 547/* order of preference: stage 2, 1, 3 */ 548if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 549ce_stage((ce = istate->cache[pos +1])) ==2&& 550!compare_name(ce, path, namelen)) 551 pos++; 552return pos; 553} 554 555static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 556{ 557int len =ce_namelen(ce); 558returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 559} 560 561/* 562 * If we add a filename that aliases in the cache, we will use the 563 * name that we already have - but we don't want to update the same 564 * alias twice, because that implies that there were actually two 565 * different files with aliasing names! 566 * 567 * So we use the CE_ADDED flag to verify that the alias was an old 568 * one before we accept it as 569 */ 570static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 571{ 572int len; 573struct cache_entry *new; 574 575if(alias->ce_flags & CE_ADDED) 576die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 577 578/* Ok, create the new entry using the name of the existing alias */ 579 len =ce_namelen(alias); 580new=xcalloc(1,cache_entry_size(len)); 581memcpy(new->name, alias->name, len); 582copy_cache_entry(new, ce); 583free(ce); 584return new; 585} 586 587voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 588{ 589unsigned char sha1[20]; 590if(write_sha1_file("",0, blob_type, sha1)) 591die("cannot create an empty blob in the object database"); 592hashcpy(ce->sha1, sha1); 593} 594 595intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 596{ 597int size, namelen, was_same; 598 mode_t st_mode = st->st_mode; 599struct cache_entry *ce, *alias; 600unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 601int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 602int pretend = flags & ADD_CACHE_PRETEND; 603int intent_only = flags & ADD_CACHE_INTENT; 604int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 605(intent_only ? ADD_CACHE_NEW_ONLY :0)); 606 607if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 608returnerror("%s: can only add regular files, symbolic links or git-directories", path); 609 610 namelen =strlen(path); 611if(S_ISDIR(st_mode)) { 612while(namelen && path[namelen-1] =='/') 613 namelen--; 614} 615 size =cache_entry_size(namelen); 616 ce =xcalloc(1, size); 617memcpy(ce->name, path, namelen); 618 ce->ce_namelen = namelen; 619if(!intent_only) 620fill_stat_cache_info(ce, st); 621else 622 ce->ce_flags |= CE_INTENT_TO_ADD; 623 624if(trust_executable_bit && has_symlinks) 625 ce->ce_mode =create_ce_mode(st_mode); 626else{ 627/* If there is an existing entry, pick the mode bits and type 628 * from it, otherwise assume unexecutable regular file. 629 */ 630struct cache_entry *ent; 631int pos =index_name_pos_also_unmerged(istate, path, namelen); 632 633 ent = (0<= pos) ? istate->cache[pos] : NULL; 634 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 635} 636 637/* When core.ignorecase=true, determine if a directory of the same name but differing 638 * case already exists within the Git repository. If it does, ensure the directory 639 * case of the file being added to the repository matches (is folded into) the existing 640 * entry's directory case. 641 */ 642if(ignore_case) { 643const char*startPtr = ce->name; 644const char*ptr = startPtr; 645while(*ptr) { 646while(*ptr && *ptr !='/') 647++ptr; 648if(*ptr =='/') { 649struct cache_entry *foundce; 650++ptr; 651 foundce =index_dir_exists(istate, ce->name, ptr - ce->name -1); 652if(foundce) { 653memcpy((void*)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr); 654 startPtr = ptr; 655} 656} 657} 658} 659 660 alias =index_file_exists(istate, ce->name,ce_namelen(ce), ignore_case); 661if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 662/* Nothing changed, really */ 663free(ce); 664if(!S_ISGITLINK(alias->ce_mode)) 665ce_mark_uptodate(alias); 666 alias->ce_flags |= CE_ADDED; 667return0; 668} 669if(!intent_only) { 670if(index_path(ce->sha1, path, st, HASH_WRITE_OBJECT)) 671returnerror("unable to index file%s", path); 672}else 673set_object_name_for_intent_to_add_entry(ce); 674 675if(ignore_case && alias &&different_name(ce, alias)) 676 ce =create_alias_ce(ce, alias); 677 ce->ce_flags |= CE_ADDED; 678 679/* It was suspected to be racily clean, but it turns out to be Ok */ 680 was_same = (alias && 681!ce_stage(alias) && 682!hashcmp(alias->sha1, ce->sha1) && 683 ce->ce_mode == alias->ce_mode); 684 685if(pretend) 686; 687else if(add_index_entry(istate, ce, add_option)) 688returnerror("unable to add%sto index",path); 689if(verbose && !was_same) 690printf("add '%s'\n", path); 691return0; 692} 693 694intadd_file_to_index(struct index_state *istate,const char*path,int flags) 695{ 696struct stat st; 697if(lstat(path, &st)) 698die_errno("unable to stat '%s'", path); 699returnadd_to_index(istate, path, &st, flags); 700} 701 702struct cache_entry *make_cache_entry(unsigned int mode, 703const unsigned char*sha1,const char*path,int stage, 704unsigned int refresh_options) 705{ 706int size, len; 707struct cache_entry *ce; 708 709if(!verify_path(path)) { 710error("Invalid path '%s'", path); 711return NULL; 712} 713 714 len =strlen(path); 715 size =cache_entry_size(len); 716 ce =xcalloc(1, size); 717 718hashcpy(ce->sha1, sha1); 719memcpy(ce->name, path, len); 720 ce->ce_flags =create_ce_flags(stage); 721 ce->ce_namelen = len; 722 ce->ce_mode =create_ce_mode(mode); 723 724returnrefresh_cache_entry(ce, refresh_options); 725} 726 727intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 728{ 729int len =ce_namelen(a); 730returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 731} 732 733/* 734 * We fundamentally don't like some paths: we don't want 735 * dot or dot-dot anywhere, and for obvious reasons don't 736 * want to recurse into ".git" either. 737 * 738 * Also, we don't want double slashes or slashes at the 739 * end that can make pathnames ambiguous. 740 */ 741static intverify_dotfile(const char*rest) 742{ 743/* 744 * The first character was '.', but that 745 * has already been discarded, we now test 746 * the rest. 747 */ 748 749/* "." is not allowed */ 750if(*rest =='\0'||is_dir_sep(*rest)) 751return0; 752 753switch(*rest) { 754/* 755 * ".git" followed by NUL or slash is bad. This 756 * shares the path end test with the ".." case. 757 */ 758case'g': 759if(rest[1] !='i') 760break; 761if(rest[2] !='t') 762break; 763 rest +=2; 764/* fallthrough */ 765case'.': 766if(rest[1] =='\0'||is_dir_sep(rest[1])) 767return0; 768} 769return1; 770} 771 772intverify_path(const char*path) 773{ 774char c; 775 776if(has_dos_drive_prefix(path)) 777return0; 778 779goto inside; 780for(;;) { 781if(!c) 782return1; 783if(is_dir_sep(c)) { 784inside: 785 c = *path++; 786if((c =='.'&& !verify_dotfile(path)) || 787is_dir_sep(c) || c =='\0') 788return0; 789} 790 c = *path++; 791} 792} 793 794/* 795 * Do we have another file that has the beginning components being a 796 * proper superset of the name we're trying to add? 797 */ 798static inthas_file_name(struct index_state *istate, 799const struct cache_entry *ce,int pos,int ok_to_replace) 800{ 801int retval =0; 802int len =ce_namelen(ce); 803int stage =ce_stage(ce); 804const char*name = ce->name; 805 806while(pos < istate->cache_nr) { 807struct cache_entry *p = istate->cache[pos++]; 808 809if(len >=ce_namelen(p)) 810break; 811if(memcmp(name, p->name, len)) 812break; 813if(ce_stage(p) != stage) 814continue; 815if(p->name[len] !='/') 816continue; 817if(p->ce_flags & CE_REMOVE) 818continue; 819 retval = -1; 820if(!ok_to_replace) 821break; 822remove_index_entry_at(istate, --pos); 823} 824return retval; 825} 826 827/* 828 * Do we have another file with a pathname that is a proper 829 * subset of the name we're trying to add? 830 */ 831static inthas_dir_name(struct index_state *istate, 832const struct cache_entry *ce,int pos,int ok_to_replace) 833{ 834int retval =0; 835int stage =ce_stage(ce); 836const char*name = ce->name; 837const char*slash = name +ce_namelen(ce); 838 839for(;;) { 840int len; 841 842for(;;) { 843if(*--slash =='/') 844break; 845if(slash <= ce->name) 846return retval; 847} 848 len = slash - name; 849 850 pos =index_name_stage_pos(istate, name, len, stage); 851if(pos >=0) { 852/* 853 * Found one, but not so fast. This could 854 * be a marker that says "I was here, but 855 * I am being removed". Such an entry is 856 * not a part of the resulting tree, and 857 * it is Ok to have a directory at the same 858 * path. 859 */ 860if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 861 retval = -1; 862if(!ok_to_replace) 863break; 864remove_index_entry_at(istate, pos); 865continue; 866} 867} 868else 869 pos = -pos-1; 870 871/* 872 * Trivial optimization: if we find an entry that 873 * already matches the sub-directory, then we know 874 * we're ok, and we can exit. 875 */ 876while(pos < istate->cache_nr) { 877struct cache_entry *p = istate->cache[pos]; 878if((ce_namelen(p) <= len) || 879(p->name[len] !='/') || 880memcmp(p->name, name, len)) 881break;/* not our subdirectory */ 882if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 883/* 884 * p is at the same stage as our entry, and 885 * is a subdirectory of what we are looking 886 * at, so we cannot have conflicts at our 887 * level or anything shorter. 888 */ 889return retval; 890 pos++; 891} 892} 893return retval; 894} 895 896/* We may be in a situation where we already have path/file and path 897 * is being added, or we already have path and path/file is being 898 * added. Either one would result in a nonsense tree that has path 899 * twice when git-write-tree tries to write it out. Prevent it. 900 * 901 * If ok-to-replace is specified, we remove the conflicting entries 902 * from the cache so the caller should recompute the insert position. 903 * When this happens, we return non-zero. 904 */ 905static intcheck_file_directory_conflict(struct index_state *istate, 906const struct cache_entry *ce, 907int pos,int ok_to_replace) 908{ 909int retval; 910 911/* 912 * When ce is an "I am going away" entry, we allow it to be added 913 */ 914if(ce->ce_flags & CE_REMOVE) 915return0; 916 917/* 918 * We check if the path is a sub-path of a subsequent pathname 919 * first, since removing those will not change the position 920 * in the array. 921 */ 922 retval =has_file_name(istate, ce, pos, ok_to_replace); 923 924/* 925 * Then check if the path might have a clashing sub-directory 926 * before it. 927 */ 928return retval +has_dir_name(istate, ce, pos, ok_to_replace); 929} 930 931static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 932{ 933int pos; 934int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 935int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 936int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 937int new_only = option & ADD_CACHE_NEW_ONLY; 938 939cache_tree_invalidate_path(istate->cache_tree, ce->name); 940 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 941 942/* existing match? Just replace it. */ 943if(pos >=0) { 944if(!new_only) 945replace_index_entry(istate, pos, ce); 946return0; 947} 948 pos = -pos-1; 949 950/* 951 * Inserting a merged entry ("stage 0") into the index 952 * will always replace all non-merged entries.. 953 */ 954if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 955while(ce_same_name(istate->cache[pos], ce)) { 956 ok_to_add =1; 957if(!remove_index_entry_at(istate, pos)) 958break; 959} 960} 961 962if(!ok_to_add) 963return-1; 964if(!verify_path(ce->name)) 965returnerror("Invalid path '%s'", ce->name); 966 967if(!skip_df_check && 968check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 969if(!ok_to_replace) 970returnerror("'%s' appears as both a file and as a directory", 971 ce->name); 972 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 973 pos = -pos-1; 974} 975return pos +1; 976} 977 978intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 979{ 980int pos; 981 982if(option & ADD_CACHE_JUST_APPEND) 983 pos = istate->cache_nr; 984else{ 985int ret; 986 ret =add_index_entry_with_check(istate, ce, option); 987if(ret <=0) 988return ret; 989 pos = ret -1; 990} 991 992/* Make sure the array is big enough .. */ 993if(istate->cache_nr == istate->cache_alloc) { 994 istate->cache_alloc =alloc_nr(istate->cache_alloc); 995 istate->cache =xrealloc(istate->cache, 996 istate->cache_alloc *sizeof(*istate->cache)); 997} 998 999/* Add it in.. */1000 istate->cache_nr++;1001if(istate->cache_nr > pos +1)1002memmove(istate->cache + pos +1,1003 istate->cache + pos,1004(istate->cache_nr - pos -1) *sizeof(ce));1005set_index_entry(istate, pos, ce);1006 istate->cache_changed =1;1007return0;1008}10091010/*1011 * "refresh" does not calculate a new sha1 file or bring the1012 * cache up-to-date for mode/content changes. But what it1013 * _does_ do is to "re-match" the stat information of a file1014 * with the cache, so that you can refresh the cache for a1015 * file that hasn't been changed but where the stat entry is1016 * out of date.1017 *1018 * For example, you'd want to do this after doing a "git-read-tree",1019 * to link up the stat cache details with the proper files.1020 */1021static struct cache_entry *refresh_cache_ent(struct index_state *istate,1022struct cache_entry *ce,1023unsigned int options,int*err,1024int*changed_ret)1025{1026struct stat st;1027struct cache_entry *updated;1028int changed, size;1029int refresh = options & CE_MATCH_REFRESH;1030int ignore_valid = options & CE_MATCH_IGNORE_VALID;1031int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1032int ignore_missing = options & CE_MATCH_IGNORE_MISSING;10331034if(!refresh ||ce_uptodate(ce))1035return ce;10361037/*1038 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1039 * that the change to the work tree does not matter and told1040 * us not to worry.1041 */1042if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1043ce_mark_uptodate(ce);1044return ce;1045}1046if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1047ce_mark_uptodate(ce);1048return ce;1049}10501051if(lstat(ce->name, &st) <0) {1052if(ignore_missing && errno == ENOENT)1053return ce;1054if(err)1055*err = errno;1056return NULL;1057}10581059 changed =ie_match_stat(istate, ce, &st, options);1060if(changed_ret)1061*changed_ret = changed;1062if(!changed) {1063/*1064 * The path is unchanged. If we were told to ignore1065 * valid bit, then we did the actual stat check and1066 * found that the entry is unmodified. If the entry1067 * is not marked VALID, this is the place to mark it1068 * valid again, under "assume unchanged" mode.1069 */1070if(ignore_valid && assume_unchanged &&1071!(ce->ce_flags & CE_VALID))1072;/* mark this one VALID again */1073else{1074/*1075 * We do not mark the index itself "modified"1076 * because CE_UPTODATE flag is in-core only;1077 * we are not going to write this change out.1078 */1079if(!S_ISGITLINK(ce->ce_mode))1080ce_mark_uptodate(ce);1081return ce;1082}1083}10841085if(ie_modified(istate, ce, &st, options)) {1086if(err)1087*err = EINVAL;1088return NULL;1089}10901091 size =ce_size(ce);1092 updated =xmalloc(size);1093memcpy(updated, ce, size);1094fill_stat_cache_info(updated, &st);1095/*1096 * If ignore_valid is not set, we should leave CE_VALID bit1097 * alone. Otherwise, paths marked with --no-assume-unchanged1098 * (i.e. things to be edited) will reacquire CE_VALID bit1099 * automatically, which is not really what we want.1100 */1101if(!ignore_valid && assume_unchanged &&1102!(ce->ce_flags & CE_VALID))1103 updated->ce_flags &= ~CE_VALID;11041105return updated;1106}11071108static voidshow_file(const char* fmt,const char* name,int in_porcelain,1109int* first,const char*header_msg)1110{1111if(in_porcelain && *first && header_msg) {1112printf("%s\n", header_msg);1113*first =0;1114}1115printf(fmt, name);1116}11171118intrefresh_index(struct index_state *istate,unsigned int flags,1119const struct pathspec *pathspec,1120char*seen,const char*header_msg)1121{1122int i;1123int has_errors =0;1124int really = (flags & REFRESH_REALLY) !=0;1125int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1126int quiet = (flags & REFRESH_QUIET) !=0;1127int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1128int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1129int first =1;1130int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1131unsigned int options = (CE_MATCH_REFRESH |1132(really ? CE_MATCH_IGNORE_VALID :0) |1133(not_new ? CE_MATCH_IGNORE_MISSING :0));1134const char*modified_fmt;1135const char*deleted_fmt;1136const char*typechange_fmt;1137const char*added_fmt;1138const char*unmerged_fmt;11391140 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1141 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1142 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1143 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1144 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1145for(i =0; i < istate->cache_nr; i++) {1146struct cache_entry *ce, *new;1147int cache_errno =0;1148int changed =0;1149int filtered =0;11501151 ce = istate->cache[i];1152if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1153continue;11541155if(pathspec && !ce_path_match(ce, pathspec, seen))1156 filtered =1;11571158if(ce_stage(ce)) {1159while((i < istate->cache_nr) &&1160!strcmp(istate->cache[i]->name, ce->name))1161 i++;1162 i--;1163if(allow_unmerged)1164continue;1165if(!filtered)1166show_file(unmerged_fmt, ce->name, in_porcelain,1167&first, header_msg);1168 has_errors =1;1169continue;1170}11711172if(filtered)1173continue;11741175new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1176if(new== ce)1177continue;1178if(!new) {1179const char*fmt;11801181if(really && cache_errno == EINVAL) {1182/* If we are doing --really-refresh that1183 * means the index is not valid anymore.1184 */1185 ce->ce_flags &= ~CE_VALID;1186 istate->cache_changed =1;1187}1188if(quiet)1189continue;11901191if(cache_errno == ENOENT)1192 fmt = deleted_fmt;1193else if(ce->ce_flags & CE_INTENT_TO_ADD)1194 fmt = added_fmt;/* must be before other checks */1195else if(changed & TYPE_CHANGED)1196 fmt = typechange_fmt;1197else1198 fmt = modified_fmt;1199show_file(fmt,1200 ce->name, in_porcelain, &first, header_msg);1201 has_errors =1;1202continue;1203}12041205replace_index_entry(istate, i,new);1206}1207return has_errors;1208}12091210static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1211unsigned int options)1212{1213returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1214}121512161217/*****************************************************************1218 * Index File I/O1219 *****************************************************************/12201221#define INDEX_FORMAT_DEFAULT 312221223/*1224 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1225 * Again - this is just a (very strong in practice) heuristic that1226 * the inode hasn't changed.1227 *1228 * We save the fields in big-endian order to allow using the1229 * index file over NFS transparently.1230 */1231struct ondisk_cache_entry {1232struct cache_time ctime;1233struct cache_time mtime;1234uint32_t dev;1235uint32_t ino;1236uint32_t mode;1237uint32_t uid;1238uint32_t gid;1239uint32_t size;1240unsigned char sha1[20];1241uint16_t flags;1242char name[FLEX_ARRAY];/* more */1243};12441245/*1246 * This struct is used when CE_EXTENDED bit is 11247 * The struct must match ondisk_cache_entry exactly from1248 * ctime till flags1249 */1250struct ondisk_cache_entry_extended {1251struct cache_time ctime;1252struct cache_time mtime;1253uint32_t dev;1254uint32_t ino;1255uint32_t mode;1256uint32_t uid;1257uint32_t gid;1258uint32_t size;1259unsigned char sha1[20];1260uint16_t flags;1261uint16_t flags2;1262char name[FLEX_ARRAY];/* more */1263};12641265/* These are only used for v3 or lower */1266#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1267#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1268#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1269#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1270 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1271 ondisk_cache_entry_size(ce_namelen(ce)))12721273static intverify_hdr(struct cache_header *hdr,unsigned long size)1274{1275 git_SHA_CTX c;1276unsigned char sha1[20];1277int hdr_version;12781279if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1280returnerror("bad signature");1281 hdr_version =ntohl(hdr->hdr_version);1282if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1283returnerror("bad index version%d", hdr_version);1284git_SHA1_Init(&c);1285git_SHA1_Update(&c, hdr, size -20);1286git_SHA1_Final(sha1, &c);1287if(hashcmp(sha1, (unsigned char*)hdr + size -20))1288returnerror("bad index file sha1 signature");1289return0;1290}12911292static intread_index_extension(struct index_state *istate,1293const char*ext,void*data,unsigned long sz)1294{1295switch(CACHE_EXT(ext)) {1296case CACHE_EXT_TREE:1297 istate->cache_tree =cache_tree_read(data, sz);1298break;1299case CACHE_EXT_RESOLVE_UNDO:1300 istate->resolve_undo =resolve_undo_read(data, sz);1301break;1302default:1303if(*ext <'A'||'Z'< *ext)1304returnerror("index uses %.4s extension, which we do not understand",1305 ext);1306fprintf(stderr,"ignoring %.4s extension\n", ext);1307break;1308}1309return0;1310}13111312intread_index(struct index_state *istate)1313{1314returnread_index_from(istate,get_index_file());1315}13161317#ifndef NEEDS_ALIGNED_ACCESS1318#define ntoh_s(var) ntohs(var)1319#define ntoh_l(var) ntohl(var)1320#else1321staticinlineuint16_tntoh_s_force_align(void*p)1322{1323uint16_t x;1324memcpy(&x, p,sizeof(x));1325returnntohs(x);1326}1327staticinlineuint32_tntoh_l_force_align(void*p)1328{1329uint32_t x;1330memcpy(&x, p,sizeof(x));1331returnntohl(x);1332}1333#define ntoh_s(var) ntoh_s_force_align(&(var))1334#define ntoh_l(var) ntoh_l_force_align(&(var))1335#endif13361337static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1338unsigned int flags,1339const char*name,1340size_t len)1341{1342struct cache_entry *ce =xmalloc(cache_entry_size(len));13431344 ce->ce_stat_data.sd_ctime.sec =ntoh_l(ondisk->ctime.sec);1345 ce->ce_stat_data.sd_mtime.sec =ntoh_l(ondisk->mtime.sec);1346 ce->ce_stat_data.sd_ctime.nsec =ntoh_l(ondisk->ctime.nsec);1347 ce->ce_stat_data.sd_mtime.nsec =ntoh_l(ondisk->mtime.nsec);1348 ce->ce_stat_data.sd_dev =ntoh_l(ondisk->dev);1349 ce->ce_stat_data.sd_ino =ntoh_l(ondisk->ino);1350 ce->ce_mode =ntoh_l(ondisk->mode);1351 ce->ce_stat_data.sd_uid =ntoh_l(ondisk->uid);1352 ce->ce_stat_data.sd_gid =ntoh_l(ondisk->gid);1353 ce->ce_stat_data.sd_size =ntoh_l(ondisk->size);1354 ce->ce_flags = flags & ~CE_NAMEMASK;1355 ce->ce_namelen = len;1356hashcpy(ce->sha1, ondisk->sha1);1357memcpy(ce->name, name, len);1358 ce->name[len] ='\0';1359return ce;1360}13611362/*1363 * Adjacent cache entries tend to share the leading paths, so it makes1364 * sense to only store the differences in later entries. In the v41365 * on-disk format of the index, each on-disk cache entry stores the1366 * number of bytes to be stripped from the end of the previous name,1367 * and the bytes to append to the result, to come up with its name.1368 */1369static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1370{1371const unsigned char*ep, *cp = (const unsigned char*)cp_;1372size_t len =decode_varint(&cp);13731374if(name->len < len)1375die("malformed name field in the index");1376strbuf_remove(name, name->len - len, len);1377for(ep = cp; *ep; ep++)1378;/* find the end */1379strbuf_add(name, cp, ep - cp);1380return(const char*)ep +1- cp_;1381}13821383static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1384unsigned long*ent_size,1385struct strbuf *previous_name)1386{1387struct cache_entry *ce;1388size_t len;1389const char*name;1390unsigned int flags;13911392/* On-disk flags are just 16 bits */1393 flags =ntoh_s(ondisk->flags);1394 len = flags & CE_NAMEMASK;13951396if(flags & CE_EXTENDED) {1397struct ondisk_cache_entry_extended *ondisk2;1398int extended_flags;1399 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1400 extended_flags =ntoh_s(ondisk2->flags2) <<16;1401/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1402if(extended_flags & ~CE_EXTENDED_FLAGS)1403die("Unknown index entry format%08x", extended_flags);1404 flags |= extended_flags;1405 name = ondisk2->name;1406}1407else1408 name = ondisk->name;14091410if(!previous_name) {1411/* v3 and earlier */1412if(len == CE_NAMEMASK)1413 len =strlen(name);1414 ce =cache_entry_from_ondisk(ondisk, flags, name, len);14151416*ent_size =ondisk_ce_size(ce);1417}else{1418unsigned long consumed;1419 consumed =expand_name_field(previous_name, name);1420 ce =cache_entry_from_ondisk(ondisk, flags,1421 previous_name->buf,1422 previous_name->len);14231424*ent_size = (name - ((char*)ondisk)) + consumed;1425}1426return ce;1427}14281429/* remember to discard_cache() before reading a different cache! */1430intread_index_from(struct index_state *istate,const char*path)1431{1432int fd, i;1433struct stat st;1434unsigned long src_offset;1435struct cache_header *hdr;1436void*mmap;1437size_t mmap_size;1438struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;14391440if(istate->initialized)1441return istate->cache_nr;14421443 istate->timestamp.sec =0;1444 istate->timestamp.nsec =0;1445 fd =open(path, O_RDONLY);1446if(fd <0) {1447if(errno == ENOENT)1448return0;1449die_errno("index file open failed");1450}14511452if(fstat(fd, &st))1453die_errno("cannot stat the open index");14541455 mmap_size =xsize_t(st.st_size);1456if(mmap_size <sizeof(struct cache_header) +20)1457die("index file smaller than expected");14581459 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1460if(mmap == MAP_FAILED)1461die_errno("unable to map index file");1462close(fd);14631464 hdr = mmap;1465if(verify_hdr(hdr, mmap_size) <0)1466goto unmap;14671468 istate->version =ntohl(hdr->hdr_version);1469 istate->cache_nr =ntohl(hdr->hdr_entries);1470 istate->cache_alloc =alloc_nr(istate->cache_nr);1471 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1472 istate->initialized =1;14731474if(istate->version ==4)1475 previous_name = &previous_name_buf;1476else1477 previous_name = NULL;14781479 src_offset =sizeof(*hdr);1480for(i =0; i < istate->cache_nr; i++) {1481struct ondisk_cache_entry *disk_ce;1482struct cache_entry *ce;1483unsigned long consumed;14841485 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1486 ce =create_from_disk(disk_ce, &consumed, previous_name);1487set_index_entry(istate, i, ce);14881489 src_offset += consumed;1490}1491strbuf_release(&previous_name_buf);1492 istate->timestamp.sec = st.st_mtime;1493 istate->timestamp.nsec =ST_MTIME_NSEC(st);14941495while(src_offset <= mmap_size -20-8) {1496/* After an array of active_nr index entries,1497 * there can be arbitrary number of extended1498 * sections, each of which is prefixed with1499 * extension name (4-byte) and section length1500 * in 4-byte network byte order.1501 */1502uint32_t extsize;1503memcpy(&extsize, (char*)mmap + src_offset +4,4);1504 extsize =ntohl(extsize);1505if(read_index_extension(istate,1506(const char*) mmap + src_offset,1507(char*) mmap + src_offset +8,1508 extsize) <0)1509goto unmap;1510 src_offset +=8;1511 src_offset += extsize;1512}1513munmap(mmap, mmap_size);1514return istate->cache_nr;15151516unmap:1517munmap(mmap, mmap_size);1518die("index file corrupt");1519}15201521intis_index_unborn(struct index_state *istate)1522{1523return(!istate->cache_nr && !istate->timestamp.sec);1524}15251526intdiscard_index(struct index_state *istate)1527{1528int i;15291530for(i =0; i < istate->cache_nr; i++)1531free(istate->cache[i]);1532resolve_undo_clear_index(istate);1533 istate->cache_nr =0;1534 istate->cache_changed =0;1535 istate->timestamp.sec =0;1536 istate->timestamp.nsec =0;1537free_name_hash(istate);1538cache_tree_free(&(istate->cache_tree));1539 istate->initialized =0;1540free(istate->cache);1541 istate->cache = NULL;1542 istate->cache_alloc =0;1543return0;1544}15451546intunmerged_index(const struct index_state *istate)1547{1548int i;1549for(i =0; i < istate->cache_nr; i++) {1550if(ce_stage(istate->cache[i]))1551return1;1552}1553return0;1554}15551556#define WRITE_BUFFER_SIZE 81921557static unsigned char write_buffer[WRITE_BUFFER_SIZE];1558static unsigned long write_buffer_len;15591560static intce_write_flush(git_SHA_CTX *context,int fd)1561{1562unsigned int buffered = write_buffer_len;1563if(buffered) {1564git_SHA1_Update(context, write_buffer, buffered);1565if(write_in_full(fd, write_buffer, buffered) != buffered)1566return-1;1567 write_buffer_len =0;1568}1569return0;1570}15711572static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1573{1574while(len) {1575unsigned int buffered = write_buffer_len;1576unsigned int partial = WRITE_BUFFER_SIZE - buffered;1577if(partial > len)1578 partial = len;1579memcpy(write_buffer + buffered, data, partial);1580 buffered += partial;1581if(buffered == WRITE_BUFFER_SIZE) {1582 write_buffer_len = buffered;1583if(ce_write_flush(context, fd))1584return-1;1585 buffered =0;1586}1587 write_buffer_len = buffered;1588 len -= partial;1589 data = (char*) data + partial;1590}1591return0;1592}15931594static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1595unsigned int ext,unsigned int sz)1596{1597 ext =htonl(ext);1598 sz =htonl(sz);1599return((ce_write(context, fd, &ext,4) <0) ||1600(ce_write(context, fd, &sz,4) <0)) ? -1:0;1601}16021603static intce_flush(git_SHA_CTX *context,int fd)1604{1605unsigned int left = write_buffer_len;16061607if(left) {1608 write_buffer_len =0;1609git_SHA1_Update(context, write_buffer, left);1610}16111612/* Flush first if not enough space for SHA1 signature */1613if(left +20> WRITE_BUFFER_SIZE) {1614if(write_in_full(fd, write_buffer, left) != left)1615return-1;1616 left =0;1617}16181619/* Append the SHA1 signature at the end */1620git_SHA1_Final(write_buffer + left, context);1621 left +=20;1622return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1623}16241625static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1626{1627/*1628 * The only thing we care about in this function is to smudge the1629 * falsely clean entry due to touch-update-touch race, so we leave1630 * everything else as they are. We are called for entries whose1631 * ce_stat_data.sd_mtime match the index file mtime.1632 *1633 * Note that this actually does not do much for gitlinks, for1634 * which ce_match_stat_basic() always goes to the actual1635 * contents. The caller checks with is_racy_timestamp() which1636 * always says "no" for gitlinks, so we are not called for them ;-)1637 */1638struct stat st;16391640if(lstat(ce->name, &st) <0)1641return;1642if(ce_match_stat_basic(ce, &st))1643return;1644if(ce_modified_check_fs(ce, &st)) {1645/* This is "racily clean"; smudge it. Note that this1646 * is a tricky code. At first glance, it may appear1647 * that it can break with this sequence:1648 *1649 * $ echo xyzzy >frotz1650 * $ git-update-index --add frotz1651 * $ : >frotz1652 * $ sleep 31653 * $ echo filfre >nitfol1654 * $ git-update-index --add nitfol1655 *1656 * but it does not. When the second update-index runs,1657 * it notices that the entry "frotz" has the same timestamp1658 * as index, and if we were to smudge it by resetting its1659 * size to zero here, then the object name recorded1660 * in index is the 6-byte file but the cached stat information1661 * becomes zero --- which would then match what we would1662 * obtain from the filesystem next time we stat("frotz").1663 *1664 * However, the second update-index, before calling1665 * this function, notices that the cached size is 61666 * bytes and what is on the filesystem is an empty1667 * file, and never calls us, so the cached size information1668 * for "frotz" stays 6 which does not match the filesystem.1669 */1670 ce->ce_stat_data.sd_size =0;1671}1672}16731674/* Copy miscellaneous fields but not the name */1675static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1676struct cache_entry *ce)1677{1678short flags;16791680 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);1681 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);1682 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);1683 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);1684 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);1685 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);1686 ondisk->mode =htonl(ce->ce_mode);1687 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);1688 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);1689 ondisk->size =htonl(ce->ce_stat_data.sd_size);1690hashcpy(ondisk->sha1, ce->sha1);16911692 flags = ce->ce_flags;1693 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1694 ondisk->flags =htons(flags);1695if(ce->ce_flags & CE_EXTENDED) {1696struct ondisk_cache_entry_extended *ondisk2;1697 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1698 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1699return ondisk2->name;1700}1701else{1702return ondisk->name;1703}1704}17051706static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1707struct strbuf *previous_name)1708{1709int size;1710struct ondisk_cache_entry *ondisk;1711char*name;1712int result;17131714if(!previous_name) {1715 size =ondisk_ce_size(ce);1716 ondisk =xcalloc(1, size);1717 name =copy_cache_entry_to_ondisk(ondisk, ce);1718memcpy(name, ce->name,ce_namelen(ce));1719}else{1720int common, to_remove, prefix_size;1721unsigned char to_remove_vi[16];1722for(common =0;1723(ce->name[common] &&1724 common < previous_name->len &&1725 ce->name[common] == previous_name->buf[common]);1726 common++)1727;/* still matching */1728 to_remove = previous_name->len - common;1729 prefix_size =encode_varint(to_remove, to_remove_vi);17301731if(ce->ce_flags & CE_EXTENDED)1732 size =offsetof(struct ondisk_cache_entry_extended, name);1733else1734 size =offsetof(struct ondisk_cache_entry, name);1735 size += prefix_size + (ce_namelen(ce) - common +1);17361737 ondisk =xcalloc(1, size);1738 name =copy_cache_entry_to_ondisk(ondisk, ce);1739memcpy(name, to_remove_vi, prefix_size);1740memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);17411742strbuf_splice(previous_name, common, to_remove,1743 ce->name + common,ce_namelen(ce) - common);1744}17451746 result =ce_write(c, fd, ondisk, size);1747free(ondisk);1748return result;1749}17501751static inthas_racy_timestamp(struct index_state *istate)1752{1753int entries = istate->cache_nr;1754int i;17551756for(i =0; i < entries; i++) {1757struct cache_entry *ce = istate->cache[i];1758if(is_racy_timestamp(istate, ce))1759return1;1760}1761return0;1762}17631764/*1765 * Opportunistically update the index but do not complain if we can't1766 */1767voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)1768{1769if((istate->cache_changed ||has_racy_timestamp(istate)) &&1770!write_index(istate, lockfile->fd))1771commit_locked_index(lockfile);1772else1773rollback_lock_file(lockfile);1774}17751776intwrite_index(struct index_state *istate,int newfd)1777{1778 git_SHA_CTX c;1779struct cache_header hdr;1780int i, err, removed, extended, hdr_version;1781struct cache_entry **cache = istate->cache;1782int entries = istate->cache_nr;1783struct stat st;1784struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17851786for(i = removed = extended =0; i < entries; i++) {1787if(cache[i]->ce_flags & CE_REMOVE)1788 removed++;17891790/* reduce extended entries if possible */1791 cache[i]->ce_flags &= ~CE_EXTENDED;1792if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1793 extended++;1794 cache[i]->ce_flags |= CE_EXTENDED;1795}1796}17971798if(!istate->version)1799 istate->version = INDEX_FORMAT_DEFAULT;18001801/* demote version 3 to version 2 when the latter suffices */1802if(istate->version ==3|| istate->version ==2)1803 istate->version = extended ?3:2;18041805 hdr_version = istate->version;18061807 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1808 hdr.hdr_version =htonl(hdr_version);1809 hdr.hdr_entries =htonl(entries - removed);18101811git_SHA1_Init(&c);1812if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1813return-1;18141815 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;1816for(i =0; i < entries; i++) {1817struct cache_entry *ce = cache[i];1818if(ce->ce_flags & CE_REMOVE)1819continue;1820if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1821ce_smudge_racily_clean_entry(ce);1822if(is_null_sha1(ce->sha1)) {1823static const char msg[] ="cache entry has null sha1:%s";1824static int allow = -1;18251826if(allow <0)1827 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);1828if(allow)1829warning(msg, ce->name);1830else1831returnerror(msg, ce->name);1832}1833if(ce_write_entry(&c, newfd, ce, previous_name) <0)1834return-1;1835}1836strbuf_release(&previous_name_buf);18371838/* Write extension data here */1839if(istate->cache_tree) {1840struct strbuf sb = STRBUF_INIT;18411842cache_tree_write(&sb, istate->cache_tree);1843 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01844||ce_write(&c, newfd, sb.buf, sb.len) <0;1845strbuf_release(&sb);1846if(err)1847return-1;1848}1849if(istate->resolve_undo) {1850struct strbuf sb = STRBUF_INIT;18511852resolve_undo_write(&sb, istate->resolve_undo);1853 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1854 sb.len) <01855||ce_write(&c, newfd, sb.buf, sb.len) <0;1856strbuf_release(&sb);1857if(err)1858return-1;1859}18601861if(ce_flush(&c, newfd) ||fstat(newfd, &st))1862return-1;1863 istate->timestamp.sec = (unsigned int)st.st_mtime;1864 istate->timestamp.nsec =ST_MTIME_NSEC(st);1865return0;1866}18671868/*1869 * Read the index file that is potentially unmerged into given1870 * index_state, dropping any unmerged entries. Returns true if1871 * the index is unmerged. Callers who want to refuse to work1872 * from an unmerged state can call this and check its return value,1873 * instead of calling read_cache().1874 */1875intread_index_unmerged(struct index_state *istate)1876{1877int i;1878int unmerged =0;18791880read_index(istate);1881for(i =0; i < istate->cache_nr; i++) {1882struct cache_entry *ce = istate->cache[i];1883struct cache_entry *new_ce;1884int size, len;18851886if(!ce_stage(ce))1887continue;1888 unmerged =1;1889 len =ce_namelen(ce);1890 size =cache_entry_size(len);1891 new_ce =xcalloc(1, size);1892memcpy(new_ce->name, ce->name, len);1893 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;1894 new_ce->ce_namelen = len;1895 new_ce->ce_mode = ce->ce_mode;1896if(add_index_entry(istate, new_ce,0))1897returnerror("%s: cannot drop to stage #0",1898 new_ce->name);1899 i =index_name_pos(istate, new_ce->name, len);1900}1901return unmerged;1902}19031904/*1905 * Returns 1 if the path is an "other" path with respect to1906 * the index; that is, the path is not mentioned in the index at all,1907 * either as a file, a directory with some files in the index,1908 * or as an unmerged entry.1909 *1910 * We helpfully remove a trailing "/" from directories so that1911 * the output of read_directory can be used as-is.1912 */1913intindex_name_is_other(const struct index_state *istate,const char*name,1914int namelen)1915{1916int pos;1917if(namelen && name[namelen -1] =='/')1918 namelen--;1919 pos =index_name_pos(istate, name, namelen);1920if(0<= pos)1921return0;/* exact match */1922 pos = -pos -1;1923if(pos < istate->cache_nr) {1924struct cache_entry *ce = istate->cache[pos];1925if(ce_namelen(ce) == namelen &&1926!memcmp(ce->name, name, namelen))1927return0;/* Yup, this one exists unmerged */1928}1929return1;1930}19311932void*read_blob_data_from_index(struct index_state *istate,const char*path,unsigned long*size)1933{1934int pos, len;1935unsigned long sz;1936enum object_type type;1937void*data;19381939 len =strlen(path);1940 pos =index_name_pos(istate, path, len);1941if(pos <0) {1942/*1943 * We might be in the middle of a merge, in which1944 * case we would read stage #2 (ours).1945 */1946int i;1947for(i = -pos -1;1948(pos <0&& i < istate->cache_nr &&1949!strcmp(istate->cache[i]->name, path));1950 i++)1951if(ce_stage(istate->cache[i]) ==2)1952 pos = i;1953}1954if(pos <0)1955return NULL;1956 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz);1957if(!data || type != OBJ_BLOB) {1958free(data);1959return NULL;1960}1961if(size)1962*size = sz;1963return data;1964}19651966voidstat_validity_clear(struct stat_validity *sv)1967{1968free(sv->sd);1969 sv->sd = NULL;1970}19711972intstat_validity_check(struct stat_validity *sv,const char*path)1973{1974struct stat st;19751976if(stat(path, &st) <0)1977return sv->sd == NULL;1978if(!sv->sd)1979return0;1980returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);1981}19821983voidstat_validity_update(struct stat_validity *sv,int fd)1984{1985struct stat st;19861987if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))1988stat_validity_clear(sv);1989else{1990if(!sv->sd)1991 sv->sd =xcalloc(1,sizeof(struct stat_data));1992fill_stat_data(sv->sd, &st);1993}1994}