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 312221223static intindex_format_config(const char*var,const char*value,void*cb)1224{1225unsigned int*version = cb;1226if(!strcmp(var,"index.version")) {1227*version =git_config_int(var, value);1228return0;1229}1230return1;1231}12321233static unsigned intget_index_format_default(void)1234{1235char*envversion =getenv("GIT_INDEX_VERSION");1236char*endp;1237unsigned int version = INDEX_FORMAT_DEFAULT;12381239if(!envversion) {1240git_config(index_format_config, &version);1241if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1242warning(_("index.version set, but the value is invalid.\n"1243"Using version%i"), INDEX_FORMAT_DEFAULT);1244return INDEX_FORMAT_DEFAULT;1245}1246return version;1247}12481249 version =strtoul(envversion, &endp,10);1250if(*endp ||1251 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1252warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1253"Using version%i"), INDEX_FORMAT_DEFAULT);1254 version = INDEX_FORMAT_DEFAULT;1255}1256return version;1257}12581259/*1260 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1261 * Again - this is just a (very strong in practice) heuristic that1262 * the inode hasn't changed.1263 *1264 * We save the fields in big-endian order to allow using the1265 * index file over NFS transparently.1266 */1267struct ondisk_cache_entry {1268struct cache_time ctime;1269struct cache_time mtime;1270uint32_t dev;1271uint32_t ino;1272uint32_t mode;1273uint32_t uid;1274uint32_t gid;1275uint32_t size;1276unsigned char sha1[20];1277uint16_t flags;1278char name[FLEX_ARRAY];/* more */1279};12801281/*1282 * This struct is used when CE_EXTENDED bit is 11283 * The struct must match ondisk_cache_entry exactly from1284 * ctime till flags1285 */1286struct ondisk_cache_entry_extended {1287struct cache_time ctime;1288struct cache_time mtime;1289uint32_t dev;1290uint32_t ino;1291uint32_t mode;1292uint32_t uid;1293uint32_t gid;1294uint32_t size;1295unsigned char sha1[20];1296uint16_t flags;1297uint16_t flags2;1298char name[FLEX_ARRAY];/* more */1299};13001301/* These are only used for v3 or lower */1302#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1303#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1304#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1305#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1306 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1307 ondisk_cache_entry_size(ce_namelen(ce)))13081309static intverify_hdr(struct cache_header *hdr,unsigned long size)1310{1311 git_SHA_CTX c;1312unsigned char sha1[20];1313int hdr_version;13141315if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1316returnerror("bad signature");1317 hdr_version =ntohl(hdr->hdr_version);1318if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1319returnerror("bad index version%d", hdr_version);1320git_SHA1_Init(&c);1321git_SHA1_Update(&c, hdr, size -20);1322git_SHA1_Final(sha1, &c);1323if(hashcmp(sha1, (unsigned char*)hdr + size -20))1324returnerror("bad index file sha1 signature");1325return0;1326}13271328static intread_index_extension(struct index_state *istate,1329const char*ext,void*data,unsigned long sz)1330{1331switch(CACHE_EXT(ext)) {1332case CACHE_EXT_TREE:1333 istate->cache_tree =cache_tree_read(data, sz);1334break;1335case CACHE_EXT_RESOLVE_UNDO:1336 istate->resolve_undo =resolve_undo_read(data, sz);1337break;1338default:1339if(*ext <'A'||'Z'< *ext)1340returnerror("index uses %.4s extension, which we do not understand",1341 ext);1342fprintf(stderr,"ignoring %.4s extension\n", ext);1343break;1344}1345return0;1346}13471348intread_index(struct index_state *istate)1349{1350returnread_index_from(istate,get_index_file());1351}13521353static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1354unsigned int flags,1355const char*name,1356size_t len)1357{1358struct cache_entry *ce =xmalloc(cache_entry_size(len));13591360 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1361 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1362 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1363 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1364 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1365 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1366 ce->ce_mode =get_be32(&ondisk->mode);1367 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1368 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1369 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1370 ce->ce_flags = flags & ~CE_NAMEMASK;1371 ce->ce_namelen = len;1372hashcpy(ce->sha1, ondisk->sha1);1373memcpy(ce->name, name, len);1374 ce->name[len] ='\0';1375return ce;1376}13771378/*1379 * Adjacent cache entries tend to share the leading paths, so it makes1380 * sense to only store the differences in later entries. In the v41381 * on-disk format of the index, each on-disk cache entry stores the1382 * number of bytes to be stripped from the end of the previous name,1383 * and the bytes to append to the result, to come up with its name.1384 */1385static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1386{1387const unsigned char*ep, *cp = (const unsigned char*)cp_;1388size_t len =decode_varint(&cp);13891390if(name->len < len)1391die("malformed name field in the index");1392strbuf_remove(name, name->len - len, len);1393for(ep = cp; *ep; ep++)1394;/* find the end */1395strbuf_add(name, cp, ep - cp);1396return(const char*)ep +1- cp_;1397}13981399static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1400unsigned long*ent_size,1401struct strbuf *previous_name)1402{1403struct cache_entry *ce;1404size_t len;1405const char*name;1406unsigned int flags;14071408/* On-disk flags are just 16 bits */1409 flags =get_be16(&ondisk->flags);1410 len = flags & CE_NAMEMASK;14111412if(flags & CE_EXTENDED) {1413struct ondisk_cache_entry_extended *ondisk2;1414int extended_flags;1415 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1416 extended_flags =get_be16(&ondisk2->flags2) <<16;1417/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1418if(extended_flags & ~CE_EXTENDED_FLAGS)1419die("Unknown index entry format%08x", extended_flags);1420 flags |= extended_flags;1421 name = ondisk2->name;1422}1423else1424 name = ondisk->name;14251426if(!previous_name) {1427/* v3 and earlier */1428if(len == CE_NAMEMASK)1429 len =strlen(name);1430 ce =cache_entry_from_ondisk(ondisk, flags, name, len);14311432*ent_size =ondisk_ce_size(ce);1433}else{1434unsigned long consumed;1435 consumed =expand_name_field(previous_name, name);1436 ce =cache_entry_from_ondisk(ondisk, flags,1437 previous_name->buf,1438 previous_name->len);14391440*ent_size = (name - ((char*)ondisk)) + consumed;1441}1442return ce;1443}14441445/* remember to discard_cache() before reading a different cache! */1446intread_index_from(struct index_state *istate,const char*path)1447{1448int fd, i;1449struct stat st;1450unsigned long src_offset;1451struct cache_header *hdr;1452void*mmap;1453size_t mmap_size;1454struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;14551456if(istate->initialized)1457return istate->cache_nr;14581459 istate->timestamp.sec =0;1460 istate->timestamp.nsec =0;1461 fd =open(path, O_RDONLY);1462if(fd <0) {1463if(errno == ENOENT)1464return0;1465die_errno("index file open failed");1466}14671468if(fstat(fd, &st))1469die_errno("cannot stat the open index");14701471 mmap_size =xsize_t(st.st_size);1472if(mmap_size <sizeof(struct cache_header) +20)1473die("index file smaller than expected");14741475 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1476if(mmap == MAP_FAILED)1477die_errno("unable to map index file");1478close(fd);14791480 hdr = mmap;1481if(verify_hdr(hdr, mmap_size) <0)1482goto unmap;14831484 istate->version =ntohl(hdr->hdr_version);1485 istate->cache_nr =ntohl(hdr->hdr_entries);1486 istate->cache_alloc =alloc_nr(istate->cache_nr);1487 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1488 istate->initialized =1;14891490if(istate->version ==4)1491 previous_name = &previous_name_buf;1492else1493 previous_name = NULL;14941495 src_offset =sizeof(*hdr);1496for(i =0; i < istate->cache_nr; i++) {1497struct ondisk_cache_entry *disk_ce;1498struct cache_entry *ce;1499unsigned long consumed;15001501 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1502 ce =create_from_disk(disk_ce, &consumed, previous_name);1503set_index_entry(istate, i, ce);15041505 src_offset += consumed;1506}1507strbuf_release(&previous_name_buf);1508 istate->timestamp.sec = st.st_mtime;1509 istate->timestamp.nsec =ST_MTIME_NSEC(st);15101511while(src_offset <= mmap_size -20-8) {1512/* After an array of active_nr index entries,1513 * there can be arbitrary number of extended1514 * sections, each of which is prefixed with1515 * extension name (4-byte) and section length1516 * in 4-byte network byte order.1517 */1518uint32_t extsize;1519memcpy(&extsize, (char*)mmap + src_offset +4,4);1520 extsize =ntohl(extsize);1521if(read_index_extension(istate,1522(const char*) mmap + src_offset,1523(char*) mmap + src_offset +8,1524 extsize) <0)1525goto unmap;1526 src_offset +=8;1527 src_offset += extsize;1528}1529munmap(mmap, mmap_size);1530return istate->cache_nr;15311532unmap:1533munmap(mmap, mmap_size);1534die("index file corrupt");1535}15361537intis_index_unborn(struct index_state *istate)1538{1539return(!istate->cache_nr && !istate->timestamp.sec);1540}15411542intdiscard_index(struct index_state *istate)1543{1544int i;15451546for(i =0; i < istate->cache_nr; i++)1547free(istate->cache[i]);1548resolve_undo_clear_index(istate);1549 istate->cache_nr =0;1550 istate->cache_changed =0;1551 istate->timestamp.sec =0;1552 istate->timestamp.nsec =0;1553free_name_hash(istate);1554cache_tree_free(&(istate->cache_tree));1555 istate->initialized =0;1556free(istate->cache);1557 istate->cache = NULL;1558 istate->cache_alloc =0;1559return0;1560}15611562intunmerged_index(const struct index_state *istate)1563{1564int i;1565for(i =0; i < istate->cache_nr; i++) {1566if(ce_stage(istate->cache[i]))1567return1;1568}1569return0;1570}15711572#define WRITE_BUFFER_SIZE 81921573static unsigned char write_buffer[WRITE_BUFFER_SIZE];1574static unsigned long write_buffer_len;15751576static intce_write_flush(git_SHA_CTX *context,int fd)1577{1578unsigned int buffered = write_buffer_len;1579if(buffered) {1580git_SHA1_Update(context, write_buffer, buffered);1581if(write_in_full(fd, write_buffer, buffered) != buffered)1582return-1;1583 write_buffer_len =0;1584}1585return0;1586}15871588static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1589{1590while(len) {1591unsigned int buffered = write_buffer_len;1592unsigned int partial = WRITE_BUFFER_SIZE - buffered;1593if(partial > len)1594 partial = len;1595memcpy(write_buffer + buffered, data, partial);1596 buffered += partial;1597if(buffered == WRITE_BUFFER_SIZE) {1598 write_buffer_len = buffered;1599if(ce_write_flush(context, fd))1600return-1;1601 buffered =0;1602}1603 write_buffer_len = buffered;1604 len -= partial;1605 data = (char*) data + partial;1606}1607return0;1608}16091610static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1611unsigned int ext,unsigned int sz)1612{1613 ext =htonl(ext);1614 sz =htonl(sz);1615return((ce_write(context, fd, &ext,4) <0) ||1616(ce_write(context, fd, &sz,4) <0)) ? -1:0;1617}16181619static intce_flush(git_SHA_CTX *context,int fd)1620{1621unsigned int left = write_buffer_len;16221623if(left) {1624 write_buffer_len =0;1625git_SHA1_Update(context, write_buffer, left);1626}16271628/* Flush first if not enough space for SHA1 signature */1629if(left +20> WRITE_BUFFER_SIZE) {1630if(write_in_full(fd, write_buffer, left) != left)1631return-1;1632 left =0;1633}16341635/* Append the SHA1 signature at the end */1636git_SHA1_Final(write_buffer + left, context);1637 left +=20;1638return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1639}16401641static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1642{1643/*1644 * The only thing we care about in this function is to smudge the1645 * falsely clean entry due to touch-update-touch race, so we leave1646 * everything else as they are. We are called for entries whose1647 * ce_stat_data.sd_mtime match the index file mtime.1648 *1649 * Note that this actually does not do much for gitlinks, for1650 * which ce_match_stat_basic() always goes to the actual1651 * contents. The caller checks with is_racy_timestamp() which1652 * always says "no" for gitlinks, so we are not called for them ;-)1653 */1654struct stat st;16551656if(lstat(ce->name, &st) <0)1657return;1658if(ce_match_stat_basic(ce, &st))1659return;1660if(ce_modified_check_fs(ce, &st)) {1661/* This is "racily clean"; smudge it. Note that this1662 * is a tricky code. At first glance, it may appear1663 * that it can break with this sequence:1664 *1665 * $ echo xyzzy >frotz1666 * $ git-update-index --add frotz1667 * $ : >frotz1668 * $ sleep 31669 * $ echo filfre >nitfol1670 * $ git-update-index --add nitfol1671 *1672 * but it does not. When the second update-index runs,1673 * it notices that the entry "frotz" has the same timestamp1674 * as index, and if we were to smudge it by resetting its1675 * size to zero here, then the object name recorded1676 * in index is the 6-byte file but the cached stat information1677 * becomes zero --- which would then match what we would1678 * obtain from the filesystem next time we stat("frotz").1679 *1680 * However, the second update-index, before calling1681 * this function, notices that the cached size is 61682 * bytes and what is on the filesystem is an empty1683 * file, and never calls us, so the cached size information1684 * for "frotz" stays 6 which does not match the filesystem.1685 */1686 ce->ce_stat_data.sd_size =0;1687}1688}16891690/* Copy miscellaneous fields but not the name */1691static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1692struct cache_entry *ce)1693{1694short flags;16951696 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);1697 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);1698 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);1699 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);1700 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);1701 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);1702 ondisk->mode =htonl(ce->ce_mode);1703 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);1704 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);1705 ondisk->size =htonl(ce->ce_stat_data.sd_size);1706hashcpy(ondisk->sha1, ce->sha1);17071708 flags = ce->ce_flags;1709 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1710 ondisk->flags =htons(flags);1711if(ce->ce_flags & CE_EXTENDED) {1712struct ondisk_cache_entry_extended *ondisk2;1713 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1714 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1715return ondisk2->name;1716}1717else{1718return ondisk->name;1719}1720}17211722static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1723struct strbuf *previous_name)1724{1725int size;1726struct ondisk_cache_entry *ondisk;1727char*name;1728int result;17291730if(!previous_name) {1731 size =ondisk_ce_size(ce);1732 ondisk =xcalloc(1, size);1733 name =copy_cache_entry_to_ondisk(ondisk, ce);1734memcpy(name, ce->name,ce_namelen(ce));1735}else{1736int common, to_remove, prefix_size;1737unsigned char to_remove_vi[16];1738for(common =0;1739(ce->name[common] &&1740 common < previous_name->len &&1741 ce->name[common] == previous_name->buf[common]);1742 common++)1743;/* still matching */1744 to_remove = previous_name->len - common;1745 prefix_size =encode_varint(to_remove, to_remove_vi);17461747if(ce->ce_flags & CE_EXTENDED)1748 size =offsetof(struct ondisk_cache_entry_extended, name);1749else1750 size =offsetof(struct ondisk_cache_entry, name);1751 size += prefix_size + (ce_namelen(ce) - common +1);17521753 ondisk =xcalloc(1, size);1754 name =copy_cache_entry_to_ondisk(ondisk, ce);1755memcpy(name, to_remove_vi, prefix_size);1756memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);17571758strbuf_splice(previous_name, common, to_remove,1759 ce->name + common,ce_namelen(ce) - common);1760}17611762 result =ce_write(c, fd, ondisk, size);1763free(ondisk);1764return result;1765}17661767static inthas_racy_timestamp(struct index_state *istate)1768{1769int entries = istate->cache_nr;1770int i;17711772for(i =0; i < entries; i++) {1773struct cache_entry *ce = istate->cache[i];1774if(is_racy_timestamp(istate, ce))1775return1;1776}1777return0;1778}17791780/*1781 * Opportunistically update the index but do not complain if we can't1782 */1783voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)1784{1785if((istate->cache_changed ||has_racy_timestamp(istate)) &&1786!write_index(istate, lockfile->fd))1787commit_locked_index(lockfile);1788else1789rollback_lock_file(lockfile);1790}17911792intwrite_index(struct index_state *istate,int newfd)1793{1794 git_SHA_CTX c;1795struct cache_header hdr;1796int i, err, removed, extended, hdr_version;1797struct cache_entry **cache = istate->cache;1798int entries = istate->cache_nr;1799struct stat st;1800struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;18011802for(i = removed = extended =0; i < entries; i++) {1803if(cache[i]->ce_flags & CE_REMOVE)1804 removed++;18051806/* reduce extended entries if possible */1807 cache[i]->ce_flags &= ~CE_EXTENDED;1808if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1809 extended++;1810 cache[i]->ce_flags |= CE_EXTENDED;1811}1812}18131814if(!istate->version)1815 istate->version =get_index_format_default();18161817/* demote version 3 to version 2 when the latter suffices */1818if(istate->version ==3|| istate->version ==2)1819 istate->version = extended ?3:2;18201821 hdr_version = istate->version;18221823 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1824 hdr.hdr_version =htonl(hdr_version);1825 hdr.hdr_entries =htonl(entries - removed);18261827git_SHA1_Init(&c);1828if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1829return-1;18301831 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;1832for(i =0; i < entries; i++) {1833struct cache_entry *ce = cache[i];1834if(ce->ce_flags & CE_REMOVE)1835continue;1836if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1837ce_smudge_racily_clean_entry(ce);1838if(is_null_sha1(ce->sha1)) {1839static const char msg[] ="cache entry has null sha1:%s";1840static int allow = -1;18411842if(allow <0)1843 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);1844if(allow)1845warning(msg, ce->name);1846else1847returnerror(msg, ce->name);1848}1849if(ce_write_entry(&c, newfd, ce, previous_name) <0)1850return-1;1851}1852strbuf_release(&previous_name_buf);18531854/* Write extension data here */1855if(istate->cache_tree) {1856struct strbuf sb = STRBUF_INIT;18571858cache_tree_write(&sb, istate->cache_tree);1859 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01860||ce_write(&c, newfd, sb.buf, sb.len) <0;1861strbuf_release(&sb);1862if(err)1863return-1;1864}1865if(istate->resolve_undo) {1866struct strbuf sb = STRBUF_INIT;18671868resolve_undo_write(&sb, istate->resolve_undo);1869 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1870 sb.len) <01871||ce_write(&c, newfd, sb.buf, sb.len) <0;1872strbuf_release(&sb);1873if(err)1874return-1;1875}18761877if(ce_flush(&c, newfd) ||fstat(newfd, &st))1878return-1;1879 istate->timestamp.sec = (unsigned int)st.st_mtime;1880 istate->timestamp.nsec =ST_MTIME_NSEC(st);1881return0;1882}18831884/*1885 * Read the index file that is potentially unmerged into given1886 * index_state, dropping any unmerged entries. Returns true if1887 * the index is unmerged. Callers who want to refuse to work1888 * from an unmerged state can call this and check its return value,1889 * instead of calling read_cache().1890 */1891intread_index_unmerged(struct index_state *istate)1892{1893int i;1894int unmerged =0;18951896read_index(istate);1897for(i =0; i < istate->cache_nr; i++) {1898struct cache_entry *ce = istate->cache[i];1899struct cache_entry *new_ce;1900int size, len;19011902if(!ce_stage(ce))1903continue;1904 unmerged =1;1905 len =ce_namelen(ce);1906 size =cache_entry_size(len);1907 new_ce =xcalloc(1, size);1908memcpy(new_ce->name, ce->name, len);1909 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;1910 new_ce->ce_namelen = len;1911 new_ce->ce_mode = ce->ce_mode;1912if(add_index_entry(istate, new_ce,0))1913returnerror("%s: cannot drop to stage #0",1914 new_ce->name);1915 i =index_name_pos(istate, new_ce->name, len);1916}1917return unmerged;1918}19191920/*1921 * Returns 1 if the path is an "other" path with respect to1922 * the index; that is, the path is not mentioned in the index at all,1923 * either as a file, a directory with some files in the index,1924 * or as an unmerged entry.1925 *1926 * We helpfully remove a trailing "/" from directories so that1927 * the output of read_directory can be used as-is.1928 */1929intindex_name_is_other(const struct index_state *istate,const char*name,1930int namelen)1931{1932int pos;1933if(namelen && name[namelen -1] =='/')1934 namelen--;1935 pos =index_name_pos(istate, name, namelen);1936if(0<= pos)1937return0;/* exact match */1938 pos = -pos -1;1939if(pos < istate->cache_nr) {1940struct cache_entry *ce = istate->cache[pos];1941if(ce_namelen(ce) == namelen &&1942!memcmp(ce->name, name, namelen))1943return0;/* Yup, this one exists unmerged */1944}1945return1;1946}19471948void*read_blob_data_from_index(struct index_state *istate,const char*path,unsigned long*size)1949{1950int pos, len;1951unsigned long sz;1952enum object_type type;1953void*data;19541955 len =strlen(path);1956 pos =index_name_pos(istate, path, len);1957if(pos <0) {1958/*1959 * We might be in the middle of a merge, in which1960 * case we would read stage #2 (ours).1961 */1962int i;1963for(i = -pos -1;1964(pos <0&& i < istate->cache_nr &&1965!strcmp(istate->cache[i]->name, path));1966 i++)1967if(ce_stage(istate->cache[i]) ==2)1968 pos = i;1969}1970if(pos <0)1971return NULL;1972 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz);1973if(!data || type != OBJ_BLOB) {1974free(data);1975return NULL;1976}1977if(size)1978*size = sz;1979return data;1980}19811982voidstat_validity_clear(struct stat_validity *sv)1983{1984free(sv->sd);1985 sv->sd = NULL;1986}19871988intstat_validity_check(struct stat_validity *sv,const char*path)1989{1990struct stat st;19911992if(stat(path, &st) <0)1993return sv->sd == NULL;1994if(!sv->sd)1995return0;1996returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);1997}19981999voidstat_validity_update(struct stat_validity *sv,int fd)2000{2001struct stat st;20022003if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2004stat_validity_clear(sv);2005else{2006if(!sv->sd)2007 sv->sd =xcalloc(1,sizeof(struct stat_data));2008fill_stat_data(sv->sd, &st);2009}2010}