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#include"utf8.h" 18 19static struct cache_entry *refresh_cache_entry(struct cache_entry *ce, 20unsigned int options); 21 22/* Mask for the name length in ce_flags in the on-disk index */ 23 24#define CE_NAMEMASK (0x0fff) 25 26/* Index extensions. 27 * 28 * The first letter should be 'A'..'Z' for extensions that are not 29 * necessary for a correct operation (i.e. optimization data). 30 * When new extensions are added that _needs_ to be understood in 31 * order to correctly interpret the index file, pick character that 32 * is outside the range, to cause the reader to abort. 33 */ 34 35#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 36#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 37#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 38 39struct index_state the_index; 40 41static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 42{ 43 istate->cache[nr] = ce; 44add_name_hash(istate, ce); 45} 46 47static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 48{ 49struct cache_entry *old = istate->cache[nr]; 50 51remove_name_hash(istate, 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_STATE_MASK; 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); 483 istate->cache_changed =1; 484 istate->cache_nr--; 485if(pos >= istate->cache_nr) 486return0; 487memmove(istate->cache + pos, 488 istate->cache + pos +1, 489(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 490return1; 491} 492 493/* 494 * Remove all cache entries marked for removal, that is where 495 * CE_REMOVE is set in ce_flags. This is much more effective than 496 * calling remove_index_entry_at() for each entry to be removed. 497 */ 498voidremove_marked_cache_entries(struct index_state *istate) 499{ 500struct cache_entry **ce_array = istate->cache; 501unsigned int i, j; 502 503for(i = j =0; i < istate->cache_nr; i++) { 504if(ce_array[i]->ce_flags & CE_REMOVE) 505remove_name_hash(istate, ce_array[i]); 506else 507 ce_array[j++] = ce_array[i]; 508} 509 istate->cache_changed =1; 510 istate->cache_nr = j; 511} 512 513intremove_file_from_index(struct index_state *istate,const char*path) 514{ 515int pos =index_name_pos(istate, path,strlen(path)); 516if(pos <0) 517 pos = -pos-1; 518cache_tree_invalidate_path(istate->cache_tree, path); 519while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 520remove_index_entry_at(istate, pos); 521return0; 522} 523 524static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 525{ 526return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 527} 528 529static intindex_name_pos_also_unmerged(struct index_state *istate, 530const char*path,int namelen) 531{ 532int pos =index_name_pos(istate, path, namelen); 533struct cache_entry *ce; 534 535if(pos >=0) 536return pos; 537 538/* maybe unmerged? */ 539 pos = -1- pos; 540if(pos >= istate->cache_nr || 541compare_name((ce = istate->cache[pos]), path, namelen)) 542return-1; 543 544/* order of preference: stage 2, 1, 3 */ 545if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 546ce_stage((ce = istate->cache[pos +1])) ==2&& 547!compare_name(ce, path, namelen)) 548 pos++; 549return pos; 550} 551 552static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 553{ 554int len =ce_namelen(ce); 555returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 556} 557 558/* 559 * If we add a filename that aliases in the cache, we will use the 560 * name that we already have - but we don't want to update the same 561 * alias twice, because that implies that there were actually two 562 * different files with aliasing names! 563 * 564 * So we use the CE_ADDED flag to verify that the alias was an old 565 * one before we accept it as 566 */ 567static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 568{ 569int len; 570struct cache_entry *new; 571 572if(alias->ce_flags & CE_ADDED) 573die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 574 575/* Ok, create the new entry using the name of the existing alias */ 576 len =ce_namelen(alias); 577new=xcalloc(1,cache_entry_size(len)); 578memcpy(new->name, alias->name, len); 579copy_cache_entry(new, ce); 580free(ce); 581return new; 582} 583 584static voidrecord_intent_to_add(struct cache_entry *ce) 585{ 586unsigned char sha1[20]; 587if(write_sha1_file("",0, blob_type, sha1)) 588die("cannot create an empty blob in the object database"); 589hashcpy(ce->sha1, sha1); 590} 591 592intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 593{ 594int size, namelen, was_same; 595 mode_t st_mode = st->st_mode; 596struct cache_entry *ce, *alias; 597unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 598int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 599int pretend = flags & ADD_CACHE_PRETEND; 600int intent_only = flags & ADD_CACHE_INTENT; 601int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 602(intent_only ? ADD_CACHE_NEW_ONLY :0)); 603 604if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 605returnerror("%s: can only add regular files, symbolic links or git-directories", path); 606 607 namelen =strlen(path); 608if(S_ISDIR(st_mode)) { 609while(namelen && path[namelen-1] =='/') 610 namelen--; 611} 612 size =cache_entry_size(namelen); 613 ce =xcalloc(1, size); 614memcpy(ce->name, path, namelen); 615 ce->ce_namelen = namelen; 616if(!intent_only) 617fill_stat_cache_info(ce, st); 618else 619 ce->ce_flags |= CE_INTENT_TO_ADD; 620 621if(trust_executable_bit && has_symlinks) 622 ce->ce_mode =create_ce_mode(st_mode); 623else{ 624/* If there is an existing entry, pick the mode bits and type 625 * from it, otherwise assume unexecutable regular file. 626 */ 627struct cache_entry *ent; 628int pos =index_name_pos_also_unmerged(istate, path, namelen); 629 630 ent = (0<= pos) ? istate->cache[pos] : NULL; 631 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 632} 633 634/* When core.ignorecase=true, determine if a directory of the same name but differing 635 * case already exists within the Git repository. If it does, ensure the directory 636 * case of the file being added to the repository matches (is folded into) the existing 637 * entry's directory case. 638 */ 639if(ignore_case) { 640const char*startPtr = ce->name; 641const char*ptr = startPtr; 642while(*ptr) { 643while(*ptr && *ptr !='/') 644++ptr; 645if(*ptr =='/') { 646struct cache_entry *foundce; 647++ptr; 648 foundce =index_dir_exists(istate, ce->name, ptr - ce->name -1); 649if(foundce) { 650memcpy((void*)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr); 651 startPtr = ptr; 652} 653} 654} 655} 656 657 alias =index_file_exists(istate, ce->name,ce_namelen(ce), ignore_case); 658if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 659/* Nothing changed, really */ 660free(ce); 661if(!S_ISGITLINK(alias->ce_mode)) 662ce_mark_uptodate(alias); 663 alias->ce_flags |= CE_ADDED; 664return0; 665} 666if(!intent_only) { 667if(index_path(ce->sha1, path, st, HASH_WRITE_OBJECT)) 668returnerror("unable to index file%s", path); 669}else 670record_intent_to_add(ce); 671 672if(ignore_case && alias &&different_name(ce, alias)) 673 ce =create_alias_ce(ce, alias); 674 ce->ce_flags |= CE_ADDED; 675 676/* It was suspected to be racily clean, but it turns out to be Ok */ 677 was_same = (alias && 678!ce_stage(alias) && 679!hashcmp(alias->sha1, ce->sha1) && 680 ce->ce_mode == alias->ce_mode); 681 682if(pretend) 683; 684else if(add_index_entry(istate, ce, add_option)) 685returnerror("unable to add%sto index",path); 686if(verbose && !was_same) 687printf("add '%s'\n", path); 688return0; 689} 690 691intadd_file_to_index(struct index_state *istate,const char*path,int flags) 692{ 693struct stat st; 694if(lstat(path, &st)) 695die_errno("unable to stat '%s'", path); 696returnadd_to_index(istate, path, &st, flags); 697} 698 699struct cache_entry *make_cache_entry(unsigned int mode, 700const unsigned char*sha1,const char*path,int stage, 701unsigned int refresh_options) 702{ 703int size, len; 704struct cache_entry *ce; 705 706if(!verify_path(path)) { 707error("Invalid path '%s'", path); 708return NULL; 709} 710 711 len =strlen(path); 712 size =cache_entry_size(len); 713 ce =xcalloc(1, size); 714 715hashcpy(ce->sha1, sha1); 716memcpy(ce->name, path, len); 717 ce->ce_flags =create_ce_flags(stage); 718 ce->ce_namelen = len; 719 ce->ce_mode =create_ce_mode(mode); 720 721returnrefresh_cache_entry(ce, refresh_options); 722} 723 724intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 725{ 726int len =ce_namelen(a); 727returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 728} 729 730/* 731 * We fundamentally don't like some paths: we don't want 732 * dot or dot-dot anywhere, and for obvious reasons don't 733 * want to recurse into ".git" either. 734 * 735 * Also, we don't want double slashes or slashes at the 736 * end that can make pathnames ambiguous. 737 */ 738static intverify_dotfile(const char*rest) 739{ 740/* 741 * The first character was '.', but that 742 * has already been discarded, we now test 743 * the rest. 744 */ 745 746/* "." is not allowed */ 747if(*rest =='\0'||is_dir_sep(*rest)) 748return0; 749 750switch(*rest) { 751/* 752 * ".git" followed by NUL or slash is bad. This 753 * shares the path end test with the ".." case. 754 */ 755case'g': 756case'G': 757if(rest[1] !='i'&& rest[1] !='I') 758break; 759if(rest[2] !='t'&& rest[2] !='T') 760break; 761 rest +=2; 762/* fallthrough */ 763case'.': 764if(rest[1] =='\0'||is_dir_sep(rest[1])) 765return0; 766} 767return1; 768} 769 770intverify_path(const char*path) 771{ 772char c; 773 774if(has_dos_drive_prefix(path)) 775return0; 776 777goto inside; 778for(;;) { 779if(!c) 780return1; 781if(is_dir_sep(c)) { 782inside: 783if(protect_hfs &&is_hfs_dotgit(path)) 784return0; 785if(protect_ntfs &&is_ntfs_dotgit(path)) 786return0; 787 c = *path++; 788if((c =='.'&& !verify_dotfile(path)) || 789is_dir_sep(c) || c =='\0') 790return0; 791} 792 c = *path++; 793} 794} 795 796/* 797 * Do we have another file that has the beginning components being a 798 * proper superset of the name we're trying to add? 799 */ 800static inthas_file_name(struct index_state *istate, 801const struct cache_entry *ce,int pos,int ok_to_replace) 802{ 803int retval =0; 804int len =ce_namelen(ce); 805int stage =ce_stage(ce); 806const char*name = ce->name; 807 808while(pos < istate->cache_nr) { 809struct cache_entry *p = istate->cache[pos++]; 810 811if(len >=ce_namelen(p)) 812break; 813if(memcmp(name, p->name, len)) 814break; 815if(ce_stage(p) != stage) 816continue; 817if(p->name[len] !='/') 818continue; 819if(p->ce_flags & CE_REMOVE) 820continue; 821 retval = -1; 822if(!ok_to_replace) 823break; 824remove_index_entry_at(istate, --pos); 825} 826return retval; 827} 828 829/* 830 * Do we have another file with a pathname that is a proper 831 * subset of the name we're trying to add? 832 */ 833static inthas_dir_name(struct index_state *istate, 834const struct cache_entry *ce,int pos,int ok_to_replace) 835{ 836int retval =0; 837int stage =ce_stage(ce); 838const char*name = ce->name; 839const char*slash = name +ce_namelen(ce); 840 841for(;;) { 842int len; 843 844for(;;) { 845if(*--slash =='/') 846break; 847if(slash <= ce->name) 848return retval; 849} 850 len = slash - name; 851 852 pos =index_name_stage_pos(istate, name, len, stage); 853if(pos >=0) { 854/* 855 * Found one, but not so fast. This could 856 * be a marker that says "I was here, but 857 * I am being removed". Such an entry is 858 * not a part of the resulting tree, and 859 * it is Ok to have a directory at the same 860 * path. 861 */ 862if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 863 retval = -1; 864if(!ok_to_replace) 865break; 866remove_index_entry_at(istate, pos); 867continue; 868} 869} 870else 871 pos = -pos-1; 872 873/* 874 * Trivial optimization: if we find an entry that 875 * already matches the sub-directory, then we know 876 * we're ok, and we can exit. 877 */ 878while(pos < istate->cache_nr) { 879struct cache_entry *p = istate->cache[pos]; 880if((ce_namelen(p) <= len) || 881(p->name[len] !='/') || 882memcmp(p->name, name, len)) 883break;/* not our subdirectory */ 884if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 885/* 886 * p is at the same stage as our entry, and 887 * is a subdirectory of what we are looking 888 * at, so we cannot have conflicts at our 889 * level or anything shorter. 890 */ 891return retval; 892 pos++; 893} 894} 895return retval; 896} 897 898/* We may be in a situation where we already have path/file and path 899 * is being added, or we already have path and path/file is being 900 * added. Either one would result in a nonsense tree that has path 901 * twice when git-write-tree tries to write it out. Prevent it. 902 * 903 * If ok-to-replace is specified, we remove the conflicting entries 904 * from the cache so the caller should recompute the insert position. 905 * When this happens, we return non-zero. 906 */ 907static intcheck_file_directory_conflict(struct index_state *istate, 908const struct cache_entry *ce, 909int pos,int ok_to_replace) 910{ 911int retval; 912 913/* 914 * When ce is an "I am going away" entry, we allow it to be added 915 */ 916if(ce->ce_flags & CE_REMOVE) 917return0; 918 919/* 920 * We check if the path is a sub-path of a subsequent pathname 921 * first, since removing those will not change the position 922 * in the array. 923 */ 924 retval =has_file_name(istate, ce, pos, ok_to_replace); 925 926/* 927 * Then check if the path might have a clashing sub-directory 928 * before it. 929 */ 930return retval +has_dir_name(istate, ce, pos, ok_to_replace); 931} 932 933static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 934{ 935int pos; 936int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 937int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 938int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 939int new_only = option & ADD_CACHE_NEW_ONLY; 940 941cache_tree_invalidate_path(istate->cache_tree, ce->name); 942 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 943 944/* existing match? Just replace it. */ 945if(pos >=0) { 946if(!new_only) 947replace_index_entry(istate, pos, ce); 948return0; 949} 950 pos = -pos-1; 951 952/* 953 * Inserting a merged entry ("stage 0") into the index 954 * will always replace all non-merged entries.. 955 */ 956if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 957while(ce_same_name(istate->cache[pos], ce)) { 958 ok_to_add =1; 959if(!remove_index_entry_at(istate, pos)) 960break; 961} 962} 963 964if(!ok_to_add) 965return-1; 966if(!verify_path(ce->name)) 967returnerror("Invalid path '%s'", ce->name); 968 969if(!skip_df_check && 970check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 971if(!ok_to_replace) 972returnerror("'%s' appears as both a file and as a directory", 973 ce->name); 974 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 975 pos = -pos-1; 976} 977return pos +1; 978} 979 980intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 981{ 982int pos; 983 984if(option & ADD_CACHE_JUST_APPEND) 985 pos = istate->cache_nr; 986else{ 987int ret; 988 ret =add_index_entry_with_check(istate, ce, option); 989if(ret <=0) 990return ret; 991 pos = ret -1; 992} 993 994/* Make sure the array is big enough .. */ 995if(istate->cache_nr == istate->cache_alloc) { 996 istate->cache_alloc =alloc_nr(istate->cache_alloc); 997 istate->cache =xrealloc(istate->cache, 998 istate->cache_alloc *sizeof(*istate->cache)); 999}10001001/* Add it in.. */1002 istate->cache_nr++;1003if(istate->cache_nr > pos +1)1004memmove(istate->cache + pos +1,1005 istate->cache + pos,1006(istate->cache_nr - pos -1) *sizeof(ce));1007set_index_entry(istate, pos, ce);1008 istate->cache_changed =1;1009return0;1010}10111012/*1013 * "refresh" does not calculate a new sha1 file or bring the1014 * cache up-to-date for mode/content changes. But what it1015 * _does_ do is to "re-match" the stat information of a file1016 * with the cache, so that you can refresh the cache for a1017 * file that hasn't been changed but where the stat entry is1018 * out of date.1019 *1020 * For example, you'd want to do this after doing a "git-read-tree",1021 * to link up the stat cache details with the proper files.1022 */1023static struct cache_entry *refresh_cache_ent(struct index_state *istate,1024struct cache_entry *ce,1025unsigned int options,int*err,1026int*changed_ret)1027{1028struct stat st;1029struct cache_entry *updated;1030int changed, size;1031int refresh = options & CE_MATCH_REFRESH;1032int ignore_valid = options & CE_MATCH_IGNORE_VALID;1033int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1034int ignore_missing = options & CE_MATCH_IGNORE_MISSING;10351036if(!refresh ||ce_uptodate(ce))1037return ce;10381039/*1040 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1041 * that the change to the work tree does not matter and told1042 * us not to worry.1043 */1044if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1045ce_mark_uptodate(ce);1046return ce;1047}1048if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1049ce_mark_uptodate(ce);1050return ce;1051}10521053if(lstat(ce->name, &st) <0) {1054if(ignore_missing && errno == ENOENT)1055return ce;1056if(err)1057*err = errno;1058return NULL;1059}10601061 changed =ie_match_stat(istate, ce, &st, options);1062if(changed_ret)1063*changed_ret = changed;1064if(!changed) {1065/*1066 * The path is unchanged. If we were told to ignore1067 * valid bit, then we did the actual stat check and1068 * found that the entry is unmodified. If the entry1069 * is not marked VALID, this is the place to mark it1070 * valid again, under "assume unchanged" mode.1071 */1072if(ignore_valid && assume_unchanged &&1073!(ce->ce_flags & CE_VALID))1074;/* mark this one VALID again */1075else{1076/*1077 * We do not mark the index itself "modified"1078 * because CE_UPTODATE flag is in-core only;1079 * we are not going to write this change out.1080 */1081if(!S_ISGITLINK(ce->ce_mode))1082ce_mark_uptodate(ce);1083return ce;1084}1085}10861087if(ie_modified(istate, ce, &st, options)) {1088if(err)1089*err = EINVAL;1090return NULL;1091}10921093 size =ce_size(ce);1094 updated =xmalloc(size);1095memcpy(updated, ce, size);1096fill_stat_cache_info(updated, &st);1097/*1098 * If ignore_valid is not set, we should leave CE_VALID bit1099 * alone. Otherwise, paths marked with --no-assume-unchanged1100 * (i.e. things to be edited) will reacquire CE_VALID bit1101 * automatically, which is not really what we want.1102 */1103if(!ignore_valid && assume_unchanged &&1104!(ce->ce_flags & CE_VALID))1105 updated->ce_flags &= ~CE_VALID;11061107return updated;1108}11091110static voidshow_file(const char* fmt,const char* name,int in_porcelain,1111int* first,const char*header_msg)1112{1113if(in_porcelain && *first && header_msg) {1114printf("%s\n", header_msg);1115*first =0;1116}1117printf(fmt, name);1118}11191120intrefresh_index(struct index_state *istate,unsigned int flags,1121const struct pathspec *pathspec,1122char*seen,const char*header_msg)1123{1124int i;1125int has_errors =0;1126int really = (flags & REFRESH_REALLY) !=0;1127int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1128int quiet = (flags & REFRESH_QUIET) !=0;1129int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1130int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1131int first =1;1132int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1133unsigned int options = (CE_MATCH_REFRESH |1134(really ? CE_MATCH_IGNORE_VALID :0) |1135(not_new ? CE_MATCH_IGNORE_MISSING :0));1136const char*modified_fmt;1137const char*deleted_fmt;1138const char*typechange_fmt;1139const char*added_fmt;1140const char*unmerged_fmt;11411142 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1143 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1144 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1145 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1146 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1147for(i =0; i < istate->cache_nr; i++) {1148struct cache_entry *ce, *new;1149int cache_errno =0;1150int changed =0;1151int filtered =0;11521153 ce = istate->cache[i];1154if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1155continue;11561157if(pathspec && !ce_path_match(ce, pathspec, seen))1158 filtered =1;11591160if(ce_stage(ce)) {1161while((i < istate->cache_nr) &&1162!strcmp(istate->cache[i]->name, ce->name))1163 i++;1164 i--;1165if(allow_unmerged)1166continue;1167if(!filtered)1168show_file(unmerged_fmt, ce->name, in_porcelain,1169&first, header_msg);1170 has_errors =1;1171continue;1172}11731174if(filtered)1175continue;11761177new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1178if(new== ce)1179continue;1180if(!new) {1181const char*fmt;11821183if(really && cache_errno == EINVAL) {1184/* If we are doing --really-refresh that1185 * means the index is not valid anymore.1186 */1187 ce->ce_flags &= ~CE_VALID;1188 istate->cache_changed =1;1189}1190if(quiet)1191continue;11921193if(cache_errno == ENOENT)1194 fmt = deleted_fmt;1195else if(ce->ce_flags & CE_INTENT_TO_ADD)1196 fmt = added_fmt;/* must be before other checks */1197else if(changed & TYPE_CHANGED)1198 fmt = typechange_fmt;1199else1200 fmt = modified_fmt;1201show_file(fmt,1202 ce->name, in_porcelain, &first, header_msg);1203 has_errors =1;1204continue;1205}12061207replace_index_entry(istate, i,new);1208}1209return has_errors;1210}12111212static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1213unsigned int options)1214{1215returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1216}121712181219/*****************************************************************1220 * Index File I/O1221 *****************************************************************/12221223#define INDEX_FORMAT_DEFAULT 312241225/*1226 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1227 * Again - this is just a (very strong in practice) heuristic that1228 * the inode hasn't changed.1229 *1230 * We save the fields in big-endian order to allow using the1231 * index file over NFS transparently.1232 */1233struct ondisk_cache_entry {1234struct cache_time ctime;1235struct cache_time mtime;1236uint32_t dev;1237uint32_t ino;1238uint32_t mode;1239uint32_t uid;1240uint32_t gid;1241uint32_t size;1242unsigned char sha1[20];1243uint16_t flags;1244char name[FLEX_ARRAY];/* more */1245};12461247/*1248 * This struct is used when CE_EXTENDED bit is 11249 * The struct must match ondisk_cache_entry exactly from1250 * ctime till flags1251 */1252struct ondisk_cache_entry_extended {1253struct cache_time ctime;1254struct cache_time mtime;1255uint32_t dev;1256uint32_t ino;1257uint32_t mode;1258uint32_t uid;1259uint32_t gid;1260uint32_t size;1261unsigned char sha1[20];1262uint16_t flags;1263uint16_t flags2;1264char name[FLEX_ARRAY];/* more */1265};12661267/* These are only used for v3 or lower */1268#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1269#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1270#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1271#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1272 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1273 ondisk_cache_entry_size(ce_namelen(ce)))12741275static intverify_hdr(struct cache_header *hdr,unsigned long size)1276{1277 git_SHA_CTX c;1278unsigned char sha1[20];1279int hdr_version;12801281if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1282returnerror("bad signature");1283 hdr_version =ntohl(hdr->hdr_version);1284if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1285returnerror("bad index version%d", hdr_version);1286git_SHA1_Init(&c);1287git_SHA1_Update(&c, hdr, size -20);1288git_SHA1_Final(sha1, &c);1289if(hashcmp(sha1, (unsigned char*)hdr + size -20))1290returnerror("bad index file sha1 signature");1291return0;1292}12931294static intread_index_extension(struct index_state *istate,1295const char*ext,void*data,unsigned long sz)1296{1297switch(CACHE_EXT(ext)) {1298case CACHE_EXT_TREE:1299 istate->cache_tree =cache_tree_read(data, sz);1300break;1301case CACHE_EXT_RESOLVE_UNDO:1302 istate->resolve_undo =resolve_undo_read(data, sz);1303break;1304default:1305if(*ext <'A'||'Z'< *ext)1306returnerror("index uses %.4s extension, which we do not understand",1307 ext);1308fprintf(stderr,"ignoring %.4s extension\n", ext);1309break;1310}1311return0;1312}13131314intread_index(struct index_state *istate)1315{1316returnread_index_from(istate,get_index_file());1317}13181319#ifndef NEEDS_ALIGNED_ACCESS1320#define ntoh_s(var) ntohs(var)1321#define ntoh_l(var) ntohl(var)1322#else1323staticinlineuint16_tntoh_s_force_align(void*p)1324{1325uint16_t x;1326memcpy(&x, p,sizeof(x));1327returnntohs(x);1328}1329staticinlineuint32_tntoh_l_force_align(void*p)1330{1331uint32_t x;1332memcpy(&x, p,sizeof(x));1333returnntohl(x);1334}1335#define ntoh_s(var) ntoh_s_force_align(&(var))1336#define ntoh_l(var) ntoh_l_force_align(&(var))1337#endif13381339static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1340unsigned int flags,1341const char*name,1342size_t len)1343{1344struct cache_entry *ce =xmalloc(cache_entry_size(len));13451346 ce->ce_stat_data.sd_ctime.sec =ntoh_l(ondisk->ctime.sec);1347 ce->ce_stat_data.sd_mtime.sec =ntoh_l(ondisk->mtime.sec);1348 ce->ce_stat_data.sd_ctime.nsec =ntoh_l(ondisk->ctime.nsec);1349 ce->ce_stat_data.sd_mtime.nsec =ntoh_l(ondisk->mtime.nsec);1350 ce->ce_stat_data.sd_dev =ntoh_l(ondisk->dev);1351 ce->ce_stat_data.sd_ino =ntoh_l(ondisk->ino);1352 ce->ce_mode =ntoh_l(ondisk->mode);1353 ce->ce_stat_data.sd_uid =ntoh_l(ondisk->uid);1354 ce->ce_stat_data.sd_gid =ntoh_l(ondisk->gid);1355 ce->ce_stat_data.sd_size =ntoh_l(ondisk->size);1356 ce->ce_flags = flags & ~CE_NAMEMASK;1357 ce->ce_namelen = len;1358hashcpy(ce->sha1, ondisk->sha1);1359memcpy(ce->name, name, len);1360 ce->name[len] ='\0';1361return ce;1362}13631364/*1365 * Adjacent cache entries tend to share the leading paths, so it makes1366 * sense to only store the differences in later entries. In the v41367 * on-disk format of the index, each on-disk cache entry stores the1368 * number of bytes to be stripped from the end of the previous name,1369 * and the bytes to append to the result, to come up with its name.1370 */1371static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1372{1373const unsigned char*ep, *cp = (const unsigned char*)cp_;1374size_t len =decode_varint(&cp);13751376if(name->len < len)1377die("malformed name field in the index");1378strbuf_remove(name, name->len - len, len);1379for(ep = cp; *ep; ep++)1380;/* find the end */1381strbuf_add(name, cp, ep - cp);1382return(const char*)ep +1- cp_;1383}13841385static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1386unsigned long*ent_size,1387struct strbuf *previous_name)1388{1389struct cache_entry *ce;1390size_t len;1391const char*name;1392unsigned int flags;13931394/* On-disk flags are just 16 bits */1395 flags =ntoh_s(ondisk->flags);1396 len = flags & CE_NAMEMASK;13971398if(flags & CE_EXTENDED) {1399struct ondisk_cache_entry_extended *ondisk2;1400int extended_flags;1401 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1402 extended_flags =ntoh_s(ondisk2->flags2) <<16;1403/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1404if(extended_flags & ~CE_EXTENDED_FLAGS)1405die("Unknown index entry format%08x", extended_flags);1406 flags |= extended_flags;1407 name = ondisk2->name;1408}1409else1410 name = ondisk->name;14111412if(!previous_name) {1413/* v3 and earlier */1414if(len == CE_NAMEMASK)1415 len =strlen(name);1416 ce =cache_entry_from_ondisk(ondisk, flags, name, len);14171418*ent_size =ondisk_ce_size(ce);1419}else{1420unsigned long consumed;1421 consumed =expand_name_field(previous_name, name);1422 ce =cache_entry_from_ondisk(ondisk, flags,1423 previous_name->buf,1424 previous_name->len);14251426*ent_size = (name - ((char*)ondisk)) + consumed;1427}1428return ce;1429}14301431/* remember to discard_cache() before reading a different cache! */1432intread_index_from(struct index_state *istate,const char*path)1433{1434int fd, i;1435struct stat st;1436unsigned long src_offset;1437struct cache_header *hdr;1438void*mmap;1439size_t mmap_size;1440struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;14411442if(istate->initialized)1443return istate->cache_nr;14441445 istate->timestamp.sec =0;1446 istate->timestamp.nsec =0;1447 fd =open(path, O_RDONLY);1448if(fd <0) {1449if(errno == ENOENT)1450return0;1451die_errno("index file open failed");1452}14531454if(fstat(fd, &st))1455die_errno("cannot stat the open index");14561457 mmap_size =xsize_t(st.st_size);1458if(mmap_size <sizeof(struct cache_header) +20)1459die("index file smaller than expected");14601461 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1462if(mmap == MAP_FAILED)1463die_errno("unable to map index file");1464close(fd);14651466 hdr = mmap;1467if(verify_hdr(hdr, mmap_size) <0)1468goto unmap;14691470 istate->version =ntohl(hdr->hdr_version);1471 istate->cache_nr =ntohl(hdr->hdr_entries);1472 istate->cache_alloc =alloc_nr(istate->cache_nr);1473 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1474 istate->initialized =1;14751476if(istate->version ==4)1477 previous_name = &previous_name_buf;1478else1479 previous_name = NULL;14801481 src_offset =sizeof(*hdr);1482for(i =0; i < istate->cache_nr; i++) {1483struct ondisk_cache_entry *disk_ce;1484struct cache_entry *ce;1485unsigned long consumed;14861487 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1488 ce =create_from_disk(disk_ce, &consumed, previous_name);1489set_index_entry(istate, i, ce);14901491 src_offset += consumed;1492}1493strbuf_release(&previous_name_buf);1494 istate->timestamp.sec = st.st_mtime;1495 istate->timestamp.nsec =ST_MTIME_NSEC(st);14961497while(src_offset <= mmap_size -20-8) {1498/* After an array of active_nr index entries,1499 * there can be arbitrary number of extended1500 * sections, each of which is prefixed with1501 * extension name (4-byte) and section length1502 * in 4-byte network byte order.1503 */1504uint32_t extsize;1505memcpy(&extsize, (char*)mmap + src_offset +4,4);1506 extsize =ntohl(extsize);1507if(read_index_extension(istate,1508(const char*) mmap + src_offset,1509(char*) mmap + src_offset +8,1510 extsize) <0)1511goto unmap;1512 src_offset +=8;1513 src_offset += extsize;1514}1515munmap(mmap, mmap_size);1516return istate->cache_nr;15171518unmap:1519munmap(mmap, mmap_size);1520die("index file corrupt");1521}15221523intis_index_unborn(struct index_state *istate)1524{1525return(!istate->cache_nr && !istate->timestamp.sec);1526}15271528intdiscard_index(struct index_state *istate)1529{1530int i;15311532for(i =0; i < istate->cache_nr; i++)1533free(istate->cache[i]);1534resolve_undo_clear_index(istate);1535 istate->cache_nr =0;1536 istate->cache_changed =0;1537 istate->timestamp.sec =0;1538 istate->timestamp.nsec =0;1539free_name_hash(istate);1540cache_tree_free(&(istate->cache_tree));1541 istate->initialized =0;1542free(istate->cache);1543 istate->cache = NULL;1544 istate->cache_alloc =0;1545return0;1546}15471548intunmerged_index(const struct index_state *istate)1549{1550int i;1551for(i =0; i < istate->cache_nr; i++) {1552if(ce_stage(istate->cache[i]))1553return1;1554}1555return0;1556}15571558#define WRITE_BUFFER_SIZE 81921559static unsigned char write_buffer[WRITE_BUFFER_SIZE];1560static unsigned long write_buffer_len;15611562static intce_write_flush(git_SHA_CTX *context,int fd)1563{1564unsigned int buffered = write_buffer_len;1565if(buffered) {1566git_SHA1_Update(context, write_buffer, buffered);1567if(write_in_full(fd, write_buffer, buffered) != buffered)1568return-1;1569 write_buffer_len =0;1570}1571return0;1572}15731574static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1575{1576while(len) {1577unsigned int buffered = write_buffer_len;1578unsigned int partial = WRITE_BUFFER_SIZE - buffered;1579if(partial > len)1580 partial = len;1581memcpy(write_buffer + buffered, data, partial);1582 buffered += partial;1583if(buffered == WRITE_BUFFER_SIZE) {1584 write_buffer_len = buffered;1585if(ce_write_flush(context, fd))1586return-1;1587 buffered =0;1588}1589 write_buffer_len = buffered;1590 len -= partial;1591 data = (char*) data + partial;1592}1593return0;1594}15951596static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1597unsigned int ext,unsigned int sz)1598{1599 ext =htonl(ext);1600 sz =htonl(sz);1601return((ce_write(context, fd, &ext,4) <0) ||1602(ce_write(context, fd, &sz,4) <0)) ? -1:0;1603}16041605static intce_flush(git_SHA_CTX *context,int fd)1606{1607unsigned int left = write_buffer_len;16081609if(left) {1610 write_buffer_len =0;1611git_SHA1_Update(context, write_buffer, left);1612}16131614/* Flush first if not enough space for SHA1 signature */1615if(left +20> WRITE_BUFFER_SIZE) {1616if(write_in_full(fd, write_buffer, left) != left)1617return-1;1618 left =0;1619}16201621/* Append the SHA1 signature at the end */1622git_SHA1_Final(write_buffer + left, context);1623 left +=20;1624return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1625}16261627static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1628{1629/*1630 * The only thing we care about in this function is to smudge the1631 * falsely clean entry due to touch-update-touch race, so we leave1632 * everything else as they are. We are called for entries whose1633 * ce_stat_data.sd_mtime match the index file mtime.1634 *1635 * Note that this actually does not do much for gitlinks, for1636 * which ce_match_stat_basic() always goes to the actual1637 * contents. The caller checks with is_racy_timestamp() which1638 * always says "no" for gitlinks, so we are not called for them ;-)1639 */1640struct stat st;16411642if(lstat(ce->name, &st) <0)1643return;1644if(ce_match_stat_basic(ce, &st))1645return;1646if(ce_modified_check_fs(ce, &st)) {1647/* This is "racily clean"; smudge it. Note that this1648 * is a tricky code. At first glance, it may appear1649 * that it can break with this sequence:1650 *1651 * $ echo xyzzy >frotz1652 * $ git-update-index --add frotz1653 * $ : >frotz1654 * $ sleep 31655 * $ echo filfre >nitfol1656 * $ git-update-index --add nitfol1657 *1658 * but it does not. When the second update-index runs,1659 * it notices that the entry "frotz" has the same timestamp1660 * as index, and if we were to smudge it by resetting its1661 * size to zero here, then the object name recorded1662 * in index is the 6-byte file but the cached stat information1663 * becomes zero --- which would then match what we would1664 * obtain from the filesystem next time we stat("frotz").1665 *1666 * However, the second update-index, before calling1667 * this function, notices that the cached size is 61668 * bytes and what is on the filesystem is an empty1669 * file, and never calls us, so the cached size information1670 * for "frotz" stays 6 which does not match the filesystem.1671 */1672 ce->ce_stat_data.sd_size =0;1673}1674}16751676/* Copy miscellaneous fields but not the name */1677static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1678struct cache_entry *ce)1679{1680short flags;16811682 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);1683 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);1684 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);1685 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);1686 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);1687 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);1688 ondisk->mode =htonl(ce->ce_mode);1689 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);1690 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);1691 ondisk->size =htonl(ce->ce_stat_data.sd_size);1692hashcpy(ondisk->sha1, ce->sha1);16931694 flags = ce->ce_flags;1695 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1696 ondisk->flags =htons(flags);1697if(ce->ce_flags & CE_EXTENDED) {1698struct ondisk_cache_entry_extended *ondisk2;1699 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1700 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1701return ondisk2->name;1702}1703else{1704return ondisk->name;1705}1706}17071708static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1709struct strbuf *previous_name)1710{1711int size;1712struct ondisk_cache_entry *ondisk;1713char*name;1714int result;17151716if(!previous_name) {1717 size =ondisk_ce_size(ce);1718 ondisk =xcalloc(1, size);1719 name =copy_cache_entry_to_ondisk(ondisk, ce);1720memcpy(name, ce->name,ce_namelen(ce));1721}else{1722int common, to_remove, prefix_size;1723unsigned char to_remove_vi[16];1724for(common =0;1725(ce->name[common] &&1726 common < previous_name->len &&1727 ce->name[common] == previous_name->buf[common]);1728 common++)1729;/* still matching */1730 to_remove = previous_name->len - common;1731 prefix_size =encode_varint(to_remove, to_remove_vi);17321733if(ce->ce_flags & CE_EXTENDED)1734 size =offsetof(struct ondisk_cache_entry_extended, name);1735else1736 size =offsetof(struct ondisk_cache_entry, name);1737 size += prefix_size + (ce_namelen(ce) - common +1);17381739 ondisk =xcalloc(1, size);1740 name =copy_cache_entry_to_ondisk(ondisk, ce);1741memcpy(name, to_remove_vi, prefix_size);1742memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);17431744strbuf_splice(previous_name, common, to_remove,1745 ce->name + common,ce_namelen(ce) - common);1746}17471748 result =ce_write(c, fd, ondisk, size);1749free(ondisk);1750return result;1751}17521753static inthas_racy_timestamp(struct index_state *istate)1754{1755int entries = istate->cache_nr;1756int i;17571758for(i =0; i < entries; i++) {1759struct cache_entry *ce = istate->cache[i];1760if(is_racy_timestamp(istate, ce))1761return1;1762}1763return0;1764}17651766/*1767 * Opportunistically update the index but do not complain if we can't1768 */1769voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)1770{1771if((istate->cache_changed ||has_racy_timestamp(istate)) &&1772!write_index(istate, lockfile->fd))1773commit_locked_index(lockfile);1774else1775rollback_lock_file(lockfile);1776}17771778intwrite_index(struct index_state *istate,int newfd)1779{1780 git_SHA_CTX c;1781struct cache_header hdr;1782int i, err, removed, extended, hdr_version;1783struct cache_entry **cache = istate->cache;1784int entries = istate->cache_nr;1785struct stat st;1786struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17871788for(i = removed = extended =0; i < entries; i++) {1789if(cache[i]->ce_flags & CE_REMOVE)1790 removed++;17911792/* reduce extended entries if possible */1793 cache[i]->ce_flags &= ~CE_EXTENDED;1794if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1795 extended++;1796 cache[i]->ce_flags |= CE_EXTENDED;1797}1798}17991800if(!istate->version)1801 istate->version = INDEX_FORMAT_DEFAULT;18021803/* demote version 3 to version 2 when the latter suffices */1804if(istate->version ==3|| istate->version ==2)1805 istate->version = extended ?3:2;18061807 hdr_version = istate->version;18081809 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1810 hdr.hdr_version =htonl(hdr_version);1811 hdr.hdr_entries =htonl(entries - removed);18121813git_SHA1_Init(&c);1814if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1815return-1;18161817 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;1818for(i =0; i < entries; i++) {1819struct cache_entry *ce = cache[i];1820if(ce->ce_flags & CE_REMOVE)1821continue;1822if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1823ce_smudge_racily_clean_entry(ce);1824if(is_null_sha1(ce->sha1)) {1825static const char msg[] ="cache entry has null sha1:%s";1826static int allow = -1;18271828if(allow <0)1829 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);1830if(allow)1831warning(msg, ce->name);1832else1833returnerror(msg, ce->name);1834}1835if(ce_write_entry(&c, newfd, ce, previous_name) <0)1836return-1;1837}1838strbuf_release(&previous_name_buf);18391840/* Write extension data here */1841if(istate->cache_tree) {1842struct strbuf sb = STRBUF_INIT;18431844cache_tree_write(&sb, istate->cache_tree);1845 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01846||ce_write(&c, newfd, sb.buf, sb.len) <0;1847strbuf_release(&sb);1848if(err)1849return-1;1850}1851if(istate->resolve_undo) {1852struct strbuf sb = STRBUF_INIT;18531854resolve_undo_write(&sb, istate->resolve_undo);1855 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1856 sb.len) <01857||ce_write(&c, newfd, sb.buf, sb.len) <0;1858strbuf_release(&sb);1859if(err)1860return-1;1861}18621863if(ce_flush(&c, newfd) ||fstat(newfd, &st))1864return-1;1865 istate->timestamp.sec = (unsigned int)st.st_mtime;1866 istate->timestamp.nsec =ST_MTIME_NSEC(st);1867return0;1868}18691870/*1871 * Read the index file that is potentially unmerged into given1872 * index_state, dropping any unmerged entries. Returns true if1873 * the index is unmerged. Callers who want to refuse to work1874 * from an unmerged state can call this and check its return value,1875 * instead of calling read_cache().1876 */1877intread_index_unmerged(struct index_state *istate)1878{1879int i;1880int unmerged =0;18811882read_index(istate);1883for(i =0; i < istate->cache_nr; i++) {1884struct cache_entry *ce = istate->cache[i];1885struct cache_entry *new_ce;1886int size, len;18871888if(!ce_stage(ce))1889continue;1890 unmerged =1;1891 len =ce_namelen(ce);1892 size =cache_entry_size(len);1893 new_ce =xcalloc(1, size);1894memcpy(new_ce->name, ce->name, len);1895 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;1896 new_ce->ce_namelen = len;1897 new_ce->ce_mode = ce->ce_mode;1898if(add_index_entry(istate, new_ce,0))1899returnerror("%s: cannot drop to stage #0",1900 ce->name);1901 i =index_name_pos(istate, new_ce->name, len);1902}1903return unmerged;1904}19051906/*1907 * Returns 1 if the path is an "other" path with respect to1908 * the index; that is, the path is not mentioned in the index at all,1909 * either as a file, a directory with some files in the index,1910 * or as an unmerged entry.1911 *1912 * We helpfully remove a trailing "/" from directories so that1913 * the output of read_directory can be used as-is.1914 */1915intindex_name_is_other(const struct index_state *istate,const char*name,1916int namelen)1917{1918int pos;1919if(namelen && name[namelen -1] =='/')1920 namelen--;1921 pos =index_name_pos(istate, name, namelen);1922if(0<= pos)1923return0;/* exact match */1924 pos = -pos -1;1925if(pos < istate->cache_nr) {1926struct cache_entry *ce = istate->cache[pos];1927if(ce_namelen(ce) == namelen &&1928!memcmp(ce->name, name, namelen))1929return0;/* Yup, this one exists unmerged */1930}1931return1;1932}19331934void*read_blob_data_from_index(struct index_state *istate,const char*path,unsigned long*size)1935{1936int pos, len;1937unsigned long sz;1938enum object_type type;1939void*data;19401941 len =strlen(path);1942 pos =index_name_pos(istate, path, len);1943if(pos <0) {1944/*1945 * We might be in the middle of a merge, in which1946 * case we would read stage #2 (ours).1947 */1948int i;1949for(i = -pos -1;1950(pos <0&& i < istate->cache_nr &&1951!strcmp(istate->cache[i]->name, path));1952 i++)1953if(ce_stage(istate->cache[i]) ==2)1954 pos = i;1955}1956if(pos <0)1957return NULL;1958 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz);1959if(!data || type != OBJ_BLOB) {1960free(data);1961return NULL;1962}1963if(size)1964*size = sz;1965return data;1966}19671968voidstat_validity_clear(struct stat_validity *sv)1969{1970free(sv->sd);1971 sv->sd = NULL;1972}19731974intstat_validity_check(struct stat_validity *sv,const char*path)1975{1976struct stat st;19771978if(stat(path, &st) <0)1979return sv->sd == NULL;1980if(!sv->sd)1981return0;1982returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);1983}19841985voidstat_validity_update(struct stat_validity *sv,int fd)1986{1987struct stat st;19881989if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))1990stat_validity_clear(sv);1991else{1992if(!sv->sd)1993 sv->sd =xcalloc(1,sizeof(struct stat_data));1994fill_stat_data(sv->sd, &st);1995}1996}