1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#define NO_THE_INDEX_COMPATIBILITY_MACROS 7#include"cache.h" 8#include"cache-tree.h" 9#include"refs.h" 10#include"dir.h" 11#include"tree.h" 12#include"commit.h" 13#include"blob.h" 14#include"resolve-undo.h" 15#include"strbuf.h" 16#include"varint.h" 17 18static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really); 19 20/* Mask for the name length in ce_flags in the on-disk index */ 21 22#define CE_NAMEMASK (0x0fff) 23 24/* Index extensions. 25 * 26 * The first letter should be 'A'..'Z' for extensions that are not 27 * necessary for a correct operation (i.e. optimization data). 28 * When new extensions are added that _needs_ to be understood in 29 * order to correctly interpret the index file, pick character that 30 * is outside the range, to cause the reader to abort. 31 */ 32 33#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 34#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 35#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 36 37struct index_state the_index; 38 39static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 40{ 41 istate->cache[nr] = ce; 42add_name_hash(istate, ce); 43} 44 45static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 46{ 47struct cache_entry *old = istate->cache[nr]; 48 49remove_name_hash(istate, old); 50set_index_entry(istate, nr, ce); 51 istate->cache_changed =1; 52} 53 54voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 55{ 56struct cache_entry *old = istate->cache[nr], *new; 57int namelen =strlen(new_name); 58 59new=xmalloc(cache_entry_size(namelen)); 60copy_cache_entry(new, old); 61new->ce_flags &= ~CE_STATE_MASK; 62new->ce_namelen = namelen; 63memcpy(new->name, new_name, namelen +1); 64 65cache_tree_invalidate_path(istate->cache_tree, old->name); 66remove_index_entry_at(istate, nr); 67add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 68} 69 70voidfill_stat_data(struct stat_data *sd,struct stat *st) 71{ 72 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 73 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 74 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 75 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 76 sd->sd_dev = st->st_dev; 77 sd->sd_ino = st->st_ino; 78 sd->sd_uid = st->st_uid; 79 sd->sd_gid = st->st_gid; 80 sd->sd_size = st->st_size; 81} 82 83intmatch_stat_data(const struct stat_data *sd,struct stat *st) 84{ 85int changed =0; 86 87if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 88 changed |= MTIME_CHANGED; 89if(trust_ctime && check_stat && 90 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 91 changed |= CTIME_CHANGED; 92 93#ifdef USE_NSEC 94if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 95 changed |= MTIME_CHANGED; 96if(trust_ctime && check_stat && 97 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 98 changed |= CTIME_CHANGED; 99#endif 100 101if(check_stat) { 102if(sd->sd_uid != (unsigned int) st->st_uid || 103 sd->sd_gid != (unsigned int) st->st_gid) 104 changed |= OWNER_CHANGED; 105if(sd->sd_ino != (unsigned int) st->st_ino) 106 changed |= INODE_CHANGED; 107} 108 109#ifdef USE_STDEV 110/* 111 * st_dev breaks on network filesystems where different 112 * clients will have different views of what "device" 113 * the filesystem is on 114 */ 115if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 116 changed |= INODE_CHANGED; 117#endif 118 119if(sd->sd_size != (unsigned int) st->st_size) 120 changed |= DATA_CHANGED; 121 122return changed; 123} 124 125/* 126 * This only updates the "non-critical" parts of the directory 127 * cache, ie the parts that aren't tracked by GIT, and only used 128 * to validate the cache. 129 */ 130voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 131{ 132fill_stat_data(&ce->ce_stat_data, st); 133 134if(assume_unchanged) 135 ce->ce_flags |= CE_VALID; 136 137if(S_ISREG(st->st_mode)) 138ce_mark_uptodate(ce); 139} 140 141static intce_compare_data(const struct cache_entry *ce,struct stat *st) 142{ 143int match = -1; 144int fd =open(ce->name, O_RDONLY); 145 146if(fd >=0) { 147unsigned char sha1[20]; 148if(!index_fd(sha1, fd, st, OBJ_BLOB, ce->name,0)) 149 match =hashcmp(sha1, ce->sha1); 150/* index_fd() closed the file descriptor already */ 151} 152return match; 153} 154 155static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 156{ 157int match = -1; 158void*buffer; 159unsigned long size; 160enum object_type type; 161struct strbuf sb = STRBUF_INIT; 162 163if(strbuf_readlink(&sb, ce->name, expected_size)) 164return-1; 165 166 buffer =read_sha1_file(ce->sha1, &type, &size); 167if(buffer) { 168if(size == sb.len) 169 match =memcmp(buffer, sb.buf, size); 170free(buffer); 171} 172strbuf_release(&sb); 173return match; 174} 175 176static intce_compare_gitlink(const struct cache_entry *ce) 177{ 178unsigned char sha1[20]; 179 180/* 181 * We don't actually require that the .git directory 182 * under GITLINK directory be a valid git directory. It 183 * might even be missing (in case nobody populated that 184 * sub-project). 185 * 186 * If so, we consider it always to match. 187 */ 188if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 189return0; 190returnhashcmp(sha1, ce->sha1); 191} 192 193static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 194{ 195switch(st->st_mode & S_IFMT) { 196case S_IFREG: 197if(ce_compare_data(ce, st)) 198return DATA_CHANGED; 199break; 200case S_IFLNK: 201if(ce_compare_link(ce,xsize_t(st->st_size))) 202return DATA_CHANGED; 203break; 204case S_IFDIR: 205if(S_ISGITLINK(ce->ce_mode)) 206returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 207default: 208return TYPE_CHANGED; 209} 210return0; 211} 212 213static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 214{ 215unsigned int changed =0; 216 217if(ce->ce_flags & CE_REMOVE) 218return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 219 220switch(ce->ce_mode & S_IFMT) { 221case S_IFREG: 222 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 223/* We consider only the owner x bit to be relevant for 224 * "mode changes" 225 */ 226if(trust_executable_bit && 227(0100& (ce->ce_mode ^ st->st_mode))) 228 changed |= MODE_CHANGED; 229break; 230case S_IFLNK: 231if(!S_ISLNK(st->st_mode) && 232(has_symlinks || !S_ISREG(st->st_mode))) 233 changed |= TYPE_CHANGED; 234break; 235case S_IFGITLINK: 236/* We ignore most of the st_xxx fields for gitlinks */ 237if(!S_ISDIR(st->st_mode)) 238 changed |= TYPE_CHANGED; 239else if(ce_compare_gitlink(ce)) 240 changed |= DATA_CHANGED; 241return changed; 242default: 243die("internal error: ce_mode is%o", ce->ce_mode); 244} 245 246 changed |=match_stat_data(&ce->ce_stat_data, st); 247 248/* Racily smudged entry? */ 249if(!ce->ce_stat_data.sd_size) { 250if(!is_empty_blob_sha1(ce->sha1)) 251 changed |= DATA_CHANGED; 252} 253 254return changed; 255} 256 257static intis_racy_timestamp(const struct index_state *istate, 258const struct cache_entry *ce) 259{ 260return(!S_ISGITLINK(ce->ce_mode) && 261 istate->timestamp.sec && 262#ifdef USE_NSEC 263/* nanosecond timestamped files can also be racy! */ 264(istate->timestamp.sec < ce->ce_stat_data.sd_mtime.sec || 265(istate->timestamp.sec == ce->ce_stat_data.sd_mtime.sec && 266 istate->timestamp.nsec <= ce->ce_stat_data.sd_mtime.nsec)) 267#else 268 istate->timestamp.sec <= ce->ce_stat_data.sd_mtime.sec 269#endif 270); 271} 272 273intie_match_stat(const struct index_state *istate, 274const struct cache_entry *ce,struct stat *st, 275unsigned int options) 276{ 277unsigned int changed; 278int ignore_valid = options & CE_MATCH_IGNORE_VALID; 279int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 280int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 281 282/* 283 * If it's marked as always valid in the index, it's 284 * valid whatever the checked-out copy says. 285 * 286 * skip-worktree has the same effect with higher precedence 287 */ 288if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 289return0; 290if(!ignore_valid && (ce->ce_flags & CE_VALID)) 291return0; 292 293/* 294 * Intent-to-add entries have not been added, so the index entry 295 * by definition never matches what is in the work tree until it 296 * actually gets added. 297 */ 298if(ce->ce_flags & CE_INTENT_TO_ADD) 299return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 300 301 changed =ce_match_stat_basic(ce, st); 302 303/* 304 * Within 1 second of this sequence: 305 * echo xyzzy >file && git-update-index --add file 306 * running this command: 307 * echo frotz >file 308 * would give a falsely clean cache entry. The mtime and 309 * length match the cache, and other stat fields do not change. 310 * 311 * We could detect this at update-index time (the cache entry 312 * being registered/updated records the same time as "now") 313 * and delay the return from git-update-index, but that would 314 * effectively mean we can make at most one commit per second, 315 * which is not acceptable. Instead, we check cache entries 316 * whose mtime are the same as the index file timestamp more 317 * carefully than others. 318 */ 319if(!changed &&is_racy_timestamp(istate, ce)) { 320if(assume_racy_is_modified) 321 changed |= DATA_CHANGED; 322else 323 changed |=ce_modified_check_fs(ce, st); 324} 325 326return changed; 327} 328 329intie_modified(const struct index_state *istate, 330const struct cache_entry *ce, 331struct stat *st,unsigned int options) 332{ 333int changed, changed_fs; 334 335 changed =ie_match_stat(istate, ce, st, options); 336if(!changed) 337return0; 338/* 339 * If the mode or type has changed, there's no point in trying 340 * to refresh the entry - it's not going to match 341 */ 342if(changed & (MODE_CHANGED | TYPE_CHANGED)) 343return changed; 344 345/* 346 * Immediately after read-tree or update-index --cacheinfo, 347 * the length field is zero, as we have never even read the 348 * lstat(2) information once, and we cannot trust DATA_CHANGED 349 * returned by ie_match_stat() which in turn was returned by 350 * ce_match_stat_basic() to signal that the filesize of the 351 * blob changed. We have to actually go to the filesystem to 352 * see if the contents match, and if so, should answer "unchanged". 353 * 354 * The logic does not apply to gitlinks, as ce_match_stat_basic() 355 * already has checked the actual HEAD from the filesystem in the 356 * subproject. If ie_match_stat() already said it is different, 357 * then we know it is. 358 */ 359if((changed & DATA_CHANGED) && 360(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 361return changed; 362 363 changed_fs =ce_modified_check_fs(ce, st); 364if(changed_fs) 365return changed | changed_fs; 366return0; 367} 368 369intbase_name_compare(const char*name1,int len1,int mode1, 370const char*name2,int len2,int mode2) 371{ 372unsigned char c1, c2; 373int len = len1 < len2 ? len1 : len2; 374int cmp; 375 376 cmp =memcmp(name1, name2, len); 377if(cmp) 378return cmp; 379 c1 = name1[len]; 380 c2 = name2[len]; 381if(!c1 &&S_ISDIR(mode1)) 382 c1 ='/'; 383if(!c2 &&S_ISDIR(mode2)) 384 c2 ='/'; 385return(c1 < c2) ? -1: (c1 > c2) ?1:0; 386} 387 388/* 389 * df_name_compare() is identical to base_name_compare(), except it 390 * compares conflicting directory/file entries as equal. Note that 391 * while a directory name compares as equal to a regular file, they 392 * then individually compare _differently_ to a filename that has 393 * a dot after the basename (because '\0' < '.' < '/'). 394 * 395 * This is used by routines that want to traverse the git namespace 396 * but then handle conflicting entries together when possible. 397 */ 398intdf_name_compare(const char*name1,int len1,int mode1, 399const char*name2,int len2,int mode2) 400{ 401int len = len1 < len2 ? len1 : len2, cmp; 402unsigned char c1, c2; 403 404 cmp =memcmp(name1, name2, len); 405if(cmp) 406return cmp; 407/* Directories and files compare equal (same length, same name) */ 408if(len1 == len2) 409return0; 410 c1 = name1[len]; 411if(!c1 &&S_ISDIR(mode1)) 412 c1 ='/'; 413 c2 = name2[len]; 414if(!c2 &&S_ISDIR(mode2)) 415 c2 ='/'; 416if(c1 =='/'&& !c2) 417return0; 418if(c2 =='/'&& !c1) 419return0; 420return c1 - c2; 421} 422 423intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 424{ 425int len = len1 < len2 ? len1 : len2; 426int cmp; 427 428 cmp =memcmp(name1, name2, len); 429if(cmp) 430return cmp; 431if(len1 < len2) 432return-1; 433if(len1 > len2) 434return1; 435 436if(stage1 < stage2) 437return-1; 438if(stage1 > stage2) 439return1; 440return0; 441} 442 443intcache_name_compare(const char*name1,int len1,const char*name2,int len2) 444{ 445returncache_name_stage_compare(name1, len1,0, name2, len2,0); 446} 447 448static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 449{ 450int first, last; 451 452 first =0; 453 last = istate->cache_nr; 454while(last > first) { 455int next = (last + first) >>1; 456struct cache_entry *ce = istate->cache[next]; 457int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 458if(!cmp) 459return next; 460if(cmp <0) { 461 last = next; 462continue; 463} 464 first = next+1; 465} 466return-first-1; 467} 468 469intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 470{ 471returnindex_name_stage_pos(istate, name, namelen,0); 472} 473 474/* Remove entry, return true if there are more entries to go.. */ 475intremove_index_entry_at(struct index_state *istate,int pos) 476{ 477struct cache_entry *ce = istate->cache[pos]; 478 479record_resolve_undo(istate, ce); 480remove_name_hash(istate, ce); 481 istate->cache_changed =1; 482 istate->cache_nr--; 483if(pos >= istate->cache_nr) 484return0; 485memmove(istate->cache + pos, 486 istate->cache + pos +1, 487(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 488return1; 489} 490 491/* 492 * Remove all cache ententries marked for removal, that is where 493 * CE_REMOVE is set in ce_flags. This is much more effective than 494 * calling remove_index_entry_at() for each entry to be removed. 495 */ 496voidremove_marked_cache_entries(struct index_state *istate) 497{ 498struct cache_entry **ce_array = istate->cache; 499unsigned int i, j; 500 501for(i = j =0; i < istate->cache_nr; i++) { 502if(ce_array[i]->ce_flags & CE_REMOVE) 503remove_name_hash(istate, ce_array[i]); 504else 505 ce_array[j++] = ce_array[i]; 506} 507 istate->cache_changed =1; 508 istate->cache_nr = j; 509} 510 511intremove_file_from_index(struct index_state *istate,const char*path) 512{ 513int pos =index_name_pos(istate, path,strlen(path)); 514if(pos <0) 515 pos = -pos-1; 516cache_tree_invalidate_path(istate->cache_tree, path); 517while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 518remove_index_entry_at(istate, pos); 519return0; 520} 521 522static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 523{ 524return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 525} 526 527static intindex_name_pos_also_unmerged(struct index_state *istate, 528const char*path,int namelen) 529{ 530int pos =index_name_pos(istate, path, namelen); 531struct cache_entry *ce; 532 533if(pos >=0) 534return pos; 535 536/* maybe unmerged? */ 537 pos = -1- pos; 538if(pos >= istate->cache_nr || 539compare_name((ce = istate->cache[pos]), path, namelen)) 540return-1; 541 542/* order of preference: stage 2, 1, 3 */ 543if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 544ce_stage((ce = istate->cache[pos +1])) ==2&& 545!compare_name(ce, path, namelen)) 546 pos++; 547return pos; 548} 549 550static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 551{ 552int len =ce_namelen(ce); 553returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 554} 555 556/* 557 * If we add a filename that aliases in the cache, we will use the 558 * name that we already have - but we don't want to update the same 559 * alias twice, because that implies that there were actually two 560 * different files with aliasing names! 561 * 562 * So we use the CE_ADDED flag to verify that the alias was an old 563 * one before we accept it as 564 */ 565static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 566{ 567int len; 568struct cache_entry *new; 569 570if(alias->ce_flags & CE_ADDED) 571die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 572 573/* Ok, create the new entry using the name of the existing alias */ 574 len =ce_namelen(alias); 575new=xcalloc(1,cache_entry_size(len)); 576memcpy(new->name, alias->name, len); 577copy_cache_entry(new, ce); 578free(ce); 579return new; 580} 581 582static voidrecord_intent_to_add(struct cache_entry *ce) 583{ 584unsigned char sha1[20]; 585if(write_sha1_file("",0, blob_type, sha1)) 586die("cannot create an empty blob in the object database"); 587hashcpy(ce->sha1, sha1); 588} 589 590intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 591{ 592int size, namelen, was_same; 593 mode_t st_mode = st->st_mode; 594struct cache_entry *ce, *alias; 595unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 596int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 597int pretend = flags & ADD_CACHE_PRETEND; 598int intent_only = flags & ADD_CACHE_INTENT; 599int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 600(intent_only ? ADD_CACHE_NEW_ONLY :0)); 601 602if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 603returnerror("%s: can only add regular files, symbolic links or git-directories", path); 604 605 namelen =strlen(path); 606if(S_ISDIR(st_mode)) { 607while(namelen && path[namelen-1] =='/') 608 namelen--; 609} 610 size =cache_entry_size(namelen); 611 ce =xcalloc(1, size); 612memcpy(ce->name, path, namelen); 613 ce->ce_namelen = namelen; 614if(!intent_only) 615fill_stat_cache_info(ce, st); 616else 617 ce->ce_flags |= CE_INTENT_TO_ADD; 618 619if(trust_executable_bit && has_symlinks) 620 ce->ce_mode =create_ce_mode(st_mode); 621else{ 622/* If there is an existing entry, pick the mode bits and type 623 * from it, otherwise assume unexecutable regular file. 624 */ 625struct cache_entry *ent; 626int pos =index_name_pos_also_unmerged(istate, path, namelen); 627 628 ent = (0<= pos) ? istate->cache[pos] : NULL; 629 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 630} 631 632/* When core.ignorecase=true, determine if a directory of the same name but differing 633 * case already exists within the Git repository. If it does, ensure the directory 634 * case of the file being added to the repository matches (is folded into) the existing 635 * entry's directory case. 636 */ 637if(ignore_case) { 638const char*startPtr = ce->name; 639const char*ptr = startPtr; 640while(*ptr) { 641while(*ptr && *ptr !='/') 642++ptr; 643if(*ptr =='/') { 644struct cache_entry *foundce; 645++ptr; 646 foundce =index_name_exists(istate, ce->name, ptr - ce->name, ignore_case); 647if(foundce) { 648memcpy((void*)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr); 649 startPtr = ptr; 650} 651} 652} 653} 654 655 alias =index_name_exists(istate, ce->name,ce_namelen(ce), ignore_case); 656if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 657/* Nothing changed, really */ 658free(ce); 659if(!S_ISGITLINK(alias->ce_mode)) 660ce_mark_uptodate(alias); 661 alias->ce_flags |= CE_ADDED; 662return0; 663} 664if(!intent_only) { 665if(index_path(ce->sha1, path, st, HASH_WRITE_OBJECT)) 666returnerror("unable to index file%s", path); 667}else 668record_intent_to_add(ce); 669 670if(ignore_case && alias &&different_name(ce, alias)) 671 ce =create_alias_ce(ce, alias); 672 ce->ce_flags |= CE_ADDED; 673 674/* It was suspected to be racily clean, but it turns out to be Ok */ 675 was_same = (alias && 676!ce_stage(alias) && 677!hashcmp(alias->sha1, ce->sha1) && 678 ce->ce_mode == alias->ce_mode); 679 680if(pretend) 681; 682else if(add_index_entry(istate, ce, add_option)) 683returnerror("unable to add%sto index",path); 684if(verbose && !was_same) 685printf("add '%s'\n", path); 686return0; 687} 688 689intadd_file_to_index(struct index_state *istate,const char*path,int flags) 690{ 691struct stat st; 692if(lstat(path, &st)) 693die_errno("unable to stat '%s'", path); 694returnadd_to_index(istate, path, &st, flags); 695} 696 697struct cache_entry *make_cache_entry(unsigned int mode, 698const unsigned char*sha1,const char*path,int stage, 699int refresh) 700{ 701int size, len; 702struct cache_entry *ce; 703 704if(!verify_path(path)) { 705error("Invalid path '%s'", path); 706return NULL; 707} 708 709 len =strlen(path); 710 size =cache_entry_size(len); 711 ce =xcalloc(1, size); 712 713hashcpy(ce->sha1, sha1); 714memcpy(ce->name, path, len); 715 ce->ce_flags =create_ce_flags(stage); 716 ce->ce_namelen = len; 717 ce->ce_mode =create_ce_mode(mode); 718 719if(refresh) 720returnrefresh_cache_entry(ce,0); 721 722return ce; 723} 724 725intce_same_name(struct cache_entry *a,struct cache_entry *b) 726{ 727int len =ce_namelen(a); 728returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 729} 730 731intce_path_match(const struct cache_entry *ce,const struct pathspec *pathspec) 732{ 733returnmatch_pathspec_depth(pathspec, ce->name,ce_namelen(ce),0, NULL); 734} 735 736/* 737 * We fundamentally don't like some paths: we don't want 738 * dot or dot-dot anywhere, and for obvious reasons don't 739 * want to recurse into ".git" either. 740 * 741 * Also, we don't want double slashes or slashes at the 742 * end that can make pathnames ambiguous. 743 */ 744static intverify_dotfile(const char*rest) 745{ 746/* 747 * The first character was '.', but that 748 * has already been discarded, we now test 749 * the rest. 750 */ 751 752/* "." is not allowed */ 753if(*rest =='\0'||is_dir_sep(*rest)) 754return0; 755 756switch(*rest) { 757/* 758 * ".git" followed by NUL or slash is bad. This 759 * shares the path end test with the ".." case. 760 */ 761case'g': 762if(rest[1] !='i') 763break; 764if(rest[2] !='t') 765break; 766 rest +=2; 767/* fallthrough */ 768case'.': 769if(rest[1] =='\0'||is_dir_sep(rest[1])) 770return0; 771} 772return1; 773} 774 775intverify_path(const char*path) 776{ 777char c; 778 779if(has_dos_drive_prefix(path)) 780return0; 781 782goto inside; 783for(;;) { 784if(!c) 785return1; 786if(is_dir_sep(c)) { 787inside: 788 c = *path++; 789if((c =='.'&& !verify_dotfile(path)) || 790is_dir_sep(c) || c =='\0') 791return0; 792} 793 c = *path++; 794} 795} 796 797/* 798 * Do we have another file that has the beginning components being a 799 * proper superset of the name we're trying to add? 800 */ 801static inthas_file_name(struct index_state *istate, 802const struct cache_entry *ce,int pos,int ok_to_replace) 803{ 804int retval =0; 805int len =ce_namelen(ce); 806int stage =ce_stage(ce); 807const char*name = ce->name; 808 809while(pos < istate->cache_nr) { 810struct cache_entry *p = istate->cache[pos++]; 811 812if(len >=ce_namelen(p)) 813break; 814if(memcmp(name, p->name, len)) 815break; 816if(ce_stage(p) != stage) 817continue; 818if(p->name[len] !='/') 819continue; 820if(p->ce_flags & CE_REMOVE) 821continue; 822 retval = -1; 823if(!ok_to_replace) 824break; 825remove_index_entry_at(istate, --pos); 826} 827return retval; 828} 829 830/* 831 * Do we have another file with a pathname that is a proper 832 * subset of the name we're trying to add? 833 */ 834static inthas_dir_name(struct index_state *istate, 835const struct cache_entry *ce,int pos,int ok_to_replace) 836{ 837int retval =0; 838int stage =ce_stage(ce); 839const char*name = ce->name; 840const char*slash = name +ce_namelen(ce); 841 842for(;;) { 843int len; 844 845for(;;) { 846if(*--slash =='/') 847break; 848if(slash <= ce->name) 849return retval; 850} 851 len = slash - name; 852 853 pos =index_name_stage_pos(istate, name, len, stage); 854if(pos >=0) { 855/* 856 * Found one, but not so fast. This could 857 * be a marker that says "I was here, but 858 * I am being removed". Such an entry is 859 * not a part of the resulting tree, and 860 * it is Ok to have a directory at the same 861 * path. 862 */ 863if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 864 retval = -1; 865if(!ok_to_replace) 866break; 867remove_index_entry_at(istate, pos); 868continue; 869} 870} 871else 872 pos = -pos-1; 873 874/* 875 * Trivial optimization: if we find an entry that 876 * already matches the sub-directory, then we know 877 * we're ok, and we can exit. 878 */ 879while(pos < istate->cache_nr) { 880struct cache_entry *p = istate->cache[pos]; 881if((ce_namelen(p) <= len) || 882(p->name[len] !='/') || 883memcmp(p->name, name, len)) 884break;/* not our subdirectory */ 885if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 886/* 887 * p is at the same stage as our entry, and 888 * is a subdirectory of what we are looking 889 * at, so we cannot have conflicts at our 890 * level or anything shorter. 891 */ 892return retval; 893 pos++; 894} 895} 896return retval; 897} 898 899/* We may be in a situation where we already have path/file and path 900 * is being added, or we already have path and path/file is being 901 * added. Either one would result in a nonsense tree that has path 902 * twice when git-write-tree tries to write it out. Prevent it. 903 * 904 * If ok-to-replace is specified, we remove the conflicting entries 905 * from the cache so the caller should recompute the insert position. 906 * When this happens, we return non-zero. 907 */ 908static intcheck_file_directory_conflict(struct index_state *istate, 909const struct cache_entry *ce, 910int pos,int ok_to_replace) 911{ 912int retval; 913 914/* 915 * When ce is an "I am going away" entry, we allow it to be added 916 */ 917if(ce->ce_flags & CE_REMOVE) 918return0; 919 920/* 921 * We check if the path is a sub-path of a subsequent pathname 922 * first, since removing those will not change the position 923 * in the array. 924 */ 925 retval =has_file_name(istate, ce, pos, ok_to_replace); 926 927/* 928 * Then check if the path might have a clashing sub-directory 929 * before it. 930 */ 931return retval +has_dir_name(istate, ce, pos, ok_to_replace); 932} 933 934static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 935{ 936int pos; 937int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 938int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 939int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 940int new_only = option & ADD_CACHE_NEW_ONLY; 941 942cache_tree_invalidate_path(istate->cache_tree, ce->name); 943 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 944 945/* existing match? Just replace it. */ 946if(pos >=0) { 947if(!new_only) 948replace_index_entry(istate, pos, ce); 949return0; 950} 951 pos = -pos-1; 952 953/* 954 * Inserting a merged entry ("stage 0") into the index 955 * will always replace all non-merged entries.. 956 */ 957if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 958while(ce_same_name(istate->cache[pos], ce)) { 959 ok_to_add =1; 960if(!remove_index_entry_at(istate, pos)) 961break; 962} 963} 964 965if(!ok_to_add) 966return-1; 967if(!verify_path(ce->name)) 968returnerror("Invalid path '%s'", ce->name); 969 970if(!skip_df_check && 971check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 972if(!ok_to_replace) 973returnerror("'%s' appears as both a file and as a directory", 974 ce->name); 975 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 976 pos = -pos-1; 977} 978return pos +1; 979} 980 981intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 982{ 983int pos; 984 985if(option & ADD_CACHE_JUST_APPEND) 986 pos = istate->cache_nr; 987else{ 988int ret; 989 ret =add_index_entry_with_check(istate, ce, option); 990if(ret <=0) 991return ret; 992 pos = ret -1; 993} 994 995/* Make sure the array is big enough .. */ 996if(istate->cache_nr == istate->cache_alloc) { 997 istate->cache_alloc =alloc_nr(istate->cache_alloc); 998 istate->cache =xrealloc(istate->cache, 999 istate->cache_alloc *sizeof(*istate->cache));1000}10011002/* Add it in.. */1003 istate->cache_nr++;1004if(istate->cache_nr > pos +1)1005memmove(istate->cache + pos +1,1006 istate->cache + pos,1007(istate->cache_nr - pos -1) *sizeof(ce));1008set_index_entry(istate, pos, ce);1009 istate->cache_changed =1;1010return0;1011}10121013/*1014 * "refresh" does not calculate a new sha1 file or bring the1015 * cache up-to-date for mode/content changes. But what it1016 * _does_ do is to "re-match" the stat information of a file1017 * with the cache, so that you can refresh the cache for a1018 * file that hasn't been changed but where the stat entry is1019 * out of date.1020 *1021 * For example, you'd want to do this after doing a "git-read-tree",1022 * to link up the stat cache details with the proper files.1023 */1024static struct cache_entry *refresh_cache_ent(struct index_state *istate,1025struct cache_entry *ce,1026unsigned int options,int*err,1027int*changed_ret)1028{1029struct stat st;1030struct cache_entry *updated;1031int changed, size;1032int ignore_valid = options & CE_MATCH_IGNORE_VALID;1033int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;10341035if(ce_uptodate(ce))1036return ce;10371038/*1039 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1040 * that the change to the work tree does not matter and told1041 * us not to worry.1042 */1043if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1044ce_mark_uptodate(ce);1045return ce;1046}1047if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1048ce_mark_uptodate(ce);1049return ce;1050}10511052if(lstat(ce->name, &st) <0) {1053if(err)1054*err = errno;1055return NULL;1056}10571058 changed =ie_match_stat(istate, ce, &st, options);1059if(changed_ret)1060*changed_ret = changed;1061if(!changed) {1062/*1063 * The path is unchanged. If we were told to ignore1064 * valid bit, then we did the actual stat check and1065 * found that the entry is unmodified. If the entry1066 * is not marked VALID, this is the place to mark it1067 * valid again, under "assume unchanged" mode.1068 */1069if(ignore_valid && assume_unchanged &&1070!(ce->ce_flags & CE_VALID))1071;/* mark this one VALID again */1072else{1073/*1074 * We do not mark the index itself "modified"1075 * because CE_UPTODATE flag is in-core only;1076 * we are not going to write this change out.1077 */1078if(!S_ISGITLINK(ce->ce_mode))1079ce_mark_uptodate(ce);1080return ce;1081}1082}10831084if(ie_modified(istate, ce, &st, options)) {1085if(err)1086*err = EINVAL;1087return NULL;1088}10891090 size =ce_size(ce);1091 updated =xmalloc(size);1092memcpy(updated, ce, size);1093fill_stat_cache_info(updated, &st);1094/*1095 * If ignore_valid is not set, we should leave CE_VALID bit1096 * alone. Otherwise, paths marked with --no-assume-unchanged1097 * (i.e. things to be edited) will reacquire CE_VALID bit1098 * automatically, which is not really what we want.1099 */1100if(!ignore_valid && assume_unchanged &&1101!(ce->ce_flags & CE_VALID))1102 updated->ce_flags &= ~CE_VALID;11031104return updated;1105}11061107static voidshow_file(const char* fmt,const char* name,int in_porcelain,1108int* first,const char*header_msg)1109{1110if(in_porcelain && *first && header_msg) {1111printf("%s\n", header_msg);1112*first =0;1113}1114printf(fmt, name);1115}11161117intrefresh_index(struct index_state *istate,unsigned int flags,const char**pathspec,1118char*seen,const char*header_msg)1119{1120int i;1121int has_errors =0;1122int really = (flags & REFRESH_REALLY) !=0;1123int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1124int quiet = (flags & REFRESH_QUIET) !=0;1125int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1126int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1127int first =1;1128int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1129unsigned int options = really ? CE_MATCH_IGNORE_VALID :0;1130const char*modified_fmt;1131const char*deleted_fmt;1132const char*typechange_fmt;1133const char*added_fmt;1134const char*unmerged_fmt;11351136 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1137 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1138 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1139 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1140 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1141for(i =0; i < istate->cache_nr; i++) {1142struct cache_entry *ce, *new;1143int cache_errno =0;1144int changed =0;1145int filtered =0;11461147 ce = istate->cache[i];1148if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1149continue;11501151if(pathspec &&1152!match_pathspec(pathspec, ce->name,ce_namelen(ce),0, seen))1153 filtered =1;11541155if(ce_stage(ce)) {1156while((i < istate->cache_nr) &&1157!strcmp(istate->cache[i]->name, ce->name))1158 i++;1159 i--;1160if(allow_unmerged)1161continue;1162if(!filtered)1163show_file(unmerged_fmt, ce->name, in_porcelain,1164&first, header_msg);1165 has_errors =1;1166continue;1167}11681169if(filtered)1170continue;11711172new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1173if(new== ce)1174continue;1175if(!new) {1176const char*fmt;11771178if(not_new && cache_errno == ENOENT)1179continue;1180if(really && cache_errno == EINVAL) {1181/* If we are doing --really-refresh that1182 * means the index is not valid anymore.1183 */1184 ce->ce_flags &= ~CE_VALID;1185 istate->cache_changed =1;1186}1187if(quiet)1188continue;11891190if(cache_errno == ENOENT)1191 fmt = deleted_fmt;1192else if(ce->ce_flags & CE_INTENT_TO_ADD)1193 fmt = added_fmt;/* must be before other checks */1194else if(changed & TYPE_CHANGED)1195 fmt = typechange_fmt;1196else1197 fmt = modified_fmt;1198show_file(fmt,1199 ce->name, in_porcelain, &first, header_msg);1200 has_errors =1;1201continue;1202}12031204replace_index_entry(istate, i,new);1205}1206return has_errors;1207}12081209static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really)1210{1211returnrefresh_cache_ent(&the_index, ce, really, NULL, NULL);1212}121312141215/*****************************************************************1216 * Index File I/O1217 *****************************************************************/12181219#define INDEX_FORMAT_DEFAULT 312201221/*1222 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1223 * Again - this is just a (very strong in practice) heuristic that1224 * the inode hasn't changed.1225 *1226 * We save the fields in big-endian order to allow using the1227 * index file over NFS transparently.1228 */1229struct ondisk_cache_entry {1230struct cache_time ctime;1231struct cache_time mtime;1232unsigned int dev;1233unsigned int ino;1234unsigned int mode;1235unsigned int uid;1236unsigned int gid;1237unsigned int size;1238unsigned char sha1[20];1239unsigned short flags;1240char name[FLEX_ARRAY];/* more */1241};12421243/*1244 * This struct is used when CE_EXTENDED bit is 11245 * The struct must match ondisk_cache_entry exactly from1246 * ctime till flags1247 */1248struct ondisk_cache_entry_extended {1249struct cache_time ctime;1250struct cache_time mtime;1251unsigned int dev;1252unsigned int ino;1253unsigned int mode;1254unsigned int uid;1255unsigned int gid;1256unsigned int size;1257unsigned char sha1[20];1258unsigned short flags;1259unsigned short flags2;1260char name[FLEX_ARRAY];/* more */1261};12621263/* These are only used for v3 or lower */1264#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1265#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1266#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1267#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1268 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1269 ondisk_cache_entry_size(ce_namelen(ce)))12701271static intverify_hdr(struct cache_header *hdr,unsigned long size)1272{1273 git_SHA_CTX c;1274unsigned char sha1[20];1275int hdr_version;12761277if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1278returnerror("bad signature");1279 hdr_version =ntohl(hdr->hdr_version);1280if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1281returnerror("bad index version%d", hdr_version);1282git_SHA1_Init(&c);1283git_SHA1_Update(&c, hdr, size -20);1284git_SHA1_Final(sha1, &c);1285if(hashcmp(sha1, (unsigned char*)hdr + size -20))1286returnerror("bad index file sha1 signature");1287return0;1288}12891290static intread_index_extension(struct index_state *istate,1291const char*ext,void*data,unsigned long sz)1292{1293switch(CACHE_EXT(ext)) {1294case CACHE_EXT_TREE:1295 istate->cache_tree =cache_tree_read(data, sz);1296break;1297case CACHE_EXT_RESOLVE_UNDO:1298 istate->resolve_undo =resolve_undo_read(data, sz);1299break;1300default:1301if(*ext <'A'||'Z'< *ext)1302returnerror("index uses %.4s extension, which we do not understand",1303 ext);1304fprintf(stderr,"ignoring %.4s extension\n", ext);1305break;1306}1307return0;1308}13091310intread_index(struct index_state *istate)1311{1312returnread_index_from(istate,get_index_file());1313}13141315#ifndef NEEDS_ALIGNED_ACCESS1316#define ntoh_s(var) ntohs(var)1317#define ntoh_l(var) ntohl(var)1318#else1319staticinlineuint16_tntoh_s_force_align(void*p)1320{1321uint16_t x;1322memcpy(&x, p,sizeof(x));1323returnntohs(x);1324}1325staticinlineuint32_tntoh_l_force_align(void*p)1326{1327uint32_t x;1328memcpy(&x, p,sizeof(x));1329returnntohl(x);1330}1331#define ntoh_s(var) ntoh_s_force_align(&(var))1332#define ntoh_l(var) ntoh_l_force_align(&(var))1333#endif13341335static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1336unsigned int flags,1337const char*name,1338size_t len)1339{1340struct cache_entry *ce =xmalloc(cache_entry_size(len));13411342 ce->ce_stat_data.sd_ctime.sec =ntoh_l(ondisk->ctime.sec);1343 ce->ce_stat_data.sd_mtime.sec =ntoh_l(ondisk->mtime.sec);1344 ce->ce_stat_data.sd_ctime.nsec =ntoh_l(ondisk->ctime.nsec);1345 ce->ce_stat_data.sd_mtime.nsec =ntoh_l(ondisk->mtime.nsec);1346 ce->ce_stat_data.sd_dev =ntoh_l(ondisk->dev);1347 ce->ce_stat_data.sd_ino =ntoh_l(ondisk->ino);1348 ce->ce_mode =ntoh_l(ondisk->mode);1349 ce->ce_stat_data.sd_uid =ntoh_l(ondisk->uid);1350 ce->ce_stat_data.sd_gid =ntoh_l(ondisk->gid);1351 ce->ce_stat_data.sd_size =ntoh_l(ondisk->size);1352 ce->ce_flags = flags & ~CE_NAMEMASK;1353 ce->ce_namelen = len;1354hashcpy(ce->sha1, ondisk->sha1);1355memcpy(ce->name, name, len);1356 ce->name[len] ='\0';1357return ce;1358}13591360/*1361 * Adjacent cache entries tend to share the leading paths, so it makes1362 * sense to only store the differences in later entries. In the v41363 * on-disk format of the index, each on-disk cache entry stores the1364 * number of bytes to be stripped from the end of the previous name,1365 * and the bytes to append to the result, to come up with its name.1366 */1367static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1368{1369const unsigned char*ep, *cp = (const unsigned char*)cp_;1370size_t len =decode_varint(&cp);13711372if(name->len < len)1373die("malformed name field in the index");1374strbuf_remove(name, name->len - len, len);1375for(ep = cp; *ep; ep++)1376;/* find the end */1377strbuf_add(name, cp, ep - cp);1378return(const char*)ep +1- cp_;1379}13801381static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1382unsigned long*ent_size,1383struct strbuf *previous_name)1384{1385struct cache_entry *ce;1386size_t len;1387const char*name;1388unsigned int flags;13891390/* On-disk flags are just 16 bits */1391 flags =ntoh_s(ondisk->flags);1392 len = flags & CE_NAMEMASK;13931394if(flags & CE_EXTENDED) {1395struct ondisk_cache_entry_extended *ondisk2;1396int extended_flags;1397 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1398 extended_flags =ntoh_s(ondisk2->flags2) <<16;1399/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1400if(extended_flags & ~CE_EXTENDED_FLAGS)1401die("Unknown index entry format%08x", extended_flags);1402 flags |= extended_flags;1403 name = ondisk2->name;1404}1405else1406 name = ondisk->name;14071408if(!previous_name) {1409/* v3 and earlier */1410if(len == CE_NAMEMASK)1411 len =strlen(name);1412 ce =cache_entry_from_ondisk(ondisk, flags, name, len);14131414*ent_size =ondisk_ce_size(ce);1415}else{1416unsigned long consumed;1417 consumed =expand_name_field(previous_name, name);1418 ce =cache_entry_from_ondisk(ondisk, flags,1419 previous_name->buf,1420 previous_name->len);14211422*ent_size = (name - ((char*)ondisk)) + consumed;1423}1424return ce;1425}14261427/* remember to discard_cache() before reading a different cache! */1428intread_index_from(struct index_state *istate,const char*path)1429{1430int fd, i;1431struct stat st;1432unsigned long src_offset;1433struct cache_header *hdr;1434void*mmap;1435size_t mmap_size;1436struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;14371438if(istate->initialized)1439return istate->cache_nr;14401441 istate->timestamp.sec =0;1442 istate->timestamp.nsec =0;1443 fd =open(path, O_RDONLY);1444if(fd <0) {1445if(errno == ENOENT)1446return0;1447die_errno("index file open failed");1448}14491450if(fstat(fd, &st))1451die_errno("cannot stat the open index");14521453 mmap_size =xsize_t(st.st_size);1454if(mmap_size <sizeof(struct cache_header) +20)1455die("index file smaller than expected");14561457 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1458if(mmap == MAP_FAILED)1459die_errno("unable to map index file");1460close(fd);14611462 hdr = mmap;1463if(verify_hdr(hdr, mmap_size) <0)1464goto unmap;14651466 istate->version =ntohl(hdr->hdr_version);1467 istate->cache_nr =ntohl(hdr->hdr_entries);1468 istate->cache_alloc =alloc_nr(istate->cache_nr);1469 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1470 istate->initialized =1;14711472if(istate->version ==4)1473 previous_name = &previous_name_buf;1474else1475 previous_name = NULL;14761477 src_offset =sizeof(*hdr);1478for(i =0; i < istate->cache_nr; i++) {1479struct ondisk_cache_entry *disk_ce;1480struct cache_entry *ce;1481unsigned long consumed;14821483 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1484 ce =create_from_disk(disk_ce, &consumed, previous_name);1485set_index_entry(istate, i, ce);14861487 src_offset += consumed;1488}1489strbuf_release(&previous_name_buf);1490 istate->timestamp.sec = st.st_mtime;1491 istate->timestamp.nsec =ST_MTIME_NSEC(st);14921493while(src_offset <= mmap_size -20-8) {1494/* After an array of active_nr index entries,1495 * there can be arbitrary number of extended1496 * sections, each of which is prefixed with1497 * extension name (4-byte) and section length1498 * in 4-byte network byte order.1499 */1500uint32_t extsize;1501memcpy(&extsize, (char*)mmap + src_offset +4,4);1502 extsize =ntohl(extsize);1503if(read_index_extension(istate,1504(const char*) mmap + src_offset,1505(char*) mmap + src_offset +8,1506 extsize) <0)1507goto unmap;1508 src_offset +=8;1509 src_offset += extsize;1510}1511munmap(mmap, mmap_size);1512return istate->cache_nr;15131514unmap:1515munmap(mmap, mmap_size);1516die("index file corrupt");1517}15181519intis_index_unborn(struct index_state *istate)1520{1521return(!istate->cache_nr && !istate->timestamp.sec);1522}15231524intdiscard_index(struct index_state *istate)1525{1526int i;15271528for(i =0; i < istate->cache_nr; i++)1529free(istate->cache[i]);1530resolve_undo_clear_index(istate);1531 istate->cache_nr =0;1532 istate->cache_changed =0;1533 istate->timestamp.sec =0;1534 istate->timestamp.nsec =0;1535free_name_hash(istate);1536cache_tree_free(&(istate->cache_tree));1537 istate->initialized =0;1538free(istate->cache);1539 istate->cache = NULL;1540 istate->cache_alloc =0;1541return0;1542}15431544intunmerged_index(const struct index_state *istate)1545{1546int i;1547for(i =0; i < istate->cache_nr; i++) {1548if(ce_stage(istate->cache[i]))1549return1;1550}1551return0;1552}15531554#define WRITE_BUFFER_SIZE 81921555static unsigned char write_buffer[WRITE_BUFFER_SIZE];1556static unsigned long write_buffer_len;15571558static intce_write_flush(git_SHA_CTX *context,int fd)1559{1560unsigned int buffered = write_buffer_len;1561if(buffered) {1562git_SHA1_Update(context, write_buffer, buffered);1563if(write_in_full(fd, write_buffer, buffered) != buffered)1564return-1;1565 write_buffer_len =0;1566}1567return0;1568}15691570static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1571{1572while(len) {1573unsigned int buffered = write_buffer_len;1574unsigned int partial = WRITE_BUFFER_SIZE - buffered;1575if(partial > len)1576 partial = len;1577memcpy(write_buffer + buffered, data, partial);1578 buffered += partial;1579if(buffered == WRITE_BUFFER_SIZE) {1580 write_buffer_len = buffered;1581if(ce_write_flush(context, fd))1582return-1;1583 buffered =0;1584}1585 write_buffer_len = buffered;1586 len -= partial;1587 data = (char*) data + partial;1588}1589return0;1590}15911592static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1593unsigned int ext,unsigned int sz)1594{1595 ext =htonl(ext);1596 sz =htonl(sz);1597return((ce_write(context, fd, &ext,4) <0) ||1598(ce_write(context, fd, &sz,4) <0)) ? -1:0;1599}16001601static intce_flush(git_SHA_CTX *context,int fd)1602{1603unsigned int left = write_buffer_len;16041605if(left) {1606 write_buffer_len =0;1607git_SHA1_Update(context, write_buffer, left);1608}16091610/* Flush first if not enough space for SHA1 signature */1611if(left +20> WRITE_BUFFER_SIZE) {1612if(write_in_full(fd, write_buffer, left) != left)1613return-1;1614 left =0;1615}16161617/* Append the SHA1 signature at the end */1618git_SHA1_Final(write_buffer + left, context);1619 left +=20;1620return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1621}16221623static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1624{1625/*1626 * The only thing we care about in this function is to smudge the1627 * falsely clean entry due to touch-update-touch race, so we leave1628 * everything else as they are. We are called for entries whose1629 * ce_stat_data.sd_mtime match the index file mtime.1630 *1631 * Note that this actually does not do much for gitlinks, for1632 * which ce_match_stat_basic() always goes to the actual1633 * contents. The caller checks with is_racy_timestamp() which1634 * always says "no" for gitlinks, so we are not called for them ;-)1635 */1636struct stat st;16371638if(lstat(ce->name, &st) <0)1639return;1640if(ce_match_stat_basic(ce, &st))1641return;1642if(ce_modified_check_fs(ce, &st)) {1643/* This is "racily clean"; smudge it. Note that this1644 * is a tricky code. At first glance, it may appear1645 * that it can break with this sequence:1646 *1647 * $ echo xyzzy >frotz1648 * $ git-update-index --add frotz1649 * $ : >frotz1650 * $ sleep 31651 * $ echo filfre >nitfol1652 * $ git-update-index --add nitfol1653 *1654 * but it does not. When the second update-index runs,1655 * it notices that the entry "frotz" has the same timestamp1656 * as index, and if we were to smudge it by resetting its1657 * size to zero here, then the object name recorded1658 * in index is the 6-byte file but the cached stat information1659 * becomes zero --- which would then match what we would1660 * obtain from the filesystem next time we stat("frotz").1661 *1662 * However, the second update-index, before calling1663 * this function, notices that the cached size is 61664 * bytes and what is on the filesystem is an empty1665 * file, and never calls us, so the cached size information1666 * for "frotz" stays 6 which does not match the filesystem.1667 */1668 ce->ce_stat_data.sd_size =0;1669}1670}16711672/* Copy miscellaneous fields but not the name */1673static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1674struct cache_entry *ce)1675{1676short flags;16771678 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);1679 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);1680 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);1681 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);1682 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);1683 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);1684 ondisk->mode =htonl(ce->ce_mode);1685 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);1686 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);1687 ondisk->size =htonl(ce->ce_stat_data.sd_size);1688hashcpy(ondisk->sha1, ce->sha1);16891690 flags = ce->ce_flags;1691 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1692 ondisk->flags =htons(flags);1693if(ce->ce_flags & CE_EXTENDED) {1694struct ondisk_cache_entry_extended *ondisk2;1695 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1696 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1697return ondisk2->name;1698}1699else{1700return ondisk->name;1701}1702}17031704static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1705struct strbuf *previous_name)1706{1707int size;1708struct ondisk_cache_entry *ondisk;1709char*name;1710int result;17111712if(!previous_name) {1713 size =ondisk_ce_size(ce);1714 ondisk =xcalloc(1, size);1715 name =copy_cache_entry_to_ondisk(ondisk, ce);1716memcpy(name, ce->name,ce_namelen(ce));1717}else{1718int common, to_remove, prefix_size;1719unsigned char to_remove_vi[16];1720for(common =0;1721(ce->name[common] &&1722 common < previous_name->len &&1723 ce->name[common] == previous_name->buf[common]);1724 common++)1725;/* still matching */1726 to_remove = previous_name->len - common;1727 prefix_size =encode_varint(to_remove, to_remove_vi);17281729if(ce->ce_flags & CE_EXTENDED)1730 size =offsetof(struct ondisk_cache_entry_extended, name);1731else1732 size =offsetof(struct ondisk_cache_entry, name);1733 size += prefix_size + (ce_namelen(ce) - common +1);17341735 ondisk =xcalloc(1, size);1736 name =copy_cache_entry_to_ondisk(ondisk, ce);1737memcpy(name, to_remove_vi, prefix_size);1738memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);17391740strbuf_splice(previous_name, common, to_remove,1741 ce->name + common,ce_namelen(ce) - common);1742}17431744 result =ce_write(c, fd, ondisk, size);1745free(ondisk);1746return result;1747}17481749static inthas_racy_timestamp(struct index_state *istate)1750{1751int entries = istate->cache_nr;1752int i;17531754for(i =0; i < entries; i++) {1755struct cache_entry *ce = istate->cache[i];1756if(is_racy_timestamp(istate, ce))1757return1;1758}1759return0;1760}17611762/*1763 * Opportunisticly update the index but do not complain if we can't1764 */1765voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)1766{1767if((istate->cache_changed ||has_racy_timestamp(istate)) &&1768!write_index(istate, lockfile->fd))1769commit_locked_index(lockfile);1770else1771rollback_lock_file(lockfile);1772}17731774intwrite_index(struct index_state *istate,int newfd)1775{1776 git_SHA_CTX c;1777struct cache_header hdr;1778int i, err, removed, extended, hdr_version;1779struct cache_entry **cache = istate->cache;1780int entries = istate->cache_nr;1781struct stat st;1782struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17831784for(i = removed = extended =0; i < entries; i++) {1785if(cache[i]->ce_flags & CE_REMOVE)1786 removed++;17871788/* reduce extended entries if possible */1789 cache[i]->ce_flags &= ~CE_EXTENDED;1790if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1791 extended++;1792 cache[i]->ce_flags |= CE_EXTENDED;1793}1794}17951796if(!istate->version)1797 istate->version = INDEX_FORMAT_DEFAULT;17981799/* demote version 3 to version 2 when the latter suffices */1800if(istate->version ==3|| istate->version ==2)1801 istate->version = extended ?3:2;18021803 hdr_version = istate->version;18041805 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1806 hdr.hdr_version =htonl(hdr_version);1807 hdr.hdr_entries =htonl(entries - removed);18081809git_SHA1_Init(&c);1810if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1811return-1;18121813 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;1814for(i =0; i < entries; i++) {1815struct cache_entry *ce = cache[i];1816if(ce->ce_flags & CE_REMOVE)1817continue;1818if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1819ce_smudge_racily_clean_entry(ce);1820if(is_null_sha1(ce->sha1))1821returnerror("cache entry has null sha1:%s", ce->name);1822if(ce_write_entry(&c, newfd, ce, previous_name) <0)1823return-1;1824}1825strbuf_release(&previous_name_buf);18261827/* Write extension data here */1828if(istate->cache_tree) {1829struct strbuf sb = STRBUF_INIT;18301831cache_tree_write(&sb, istate->cache_tree);1832 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01833||ce_write(&c, newfd, sb.buf, sb.len) <0;1834strbuf_release(&sb);1835if(err)1836return-1;1837}1838if(istate->resolve_undo) {1839struct strbuf sb = STRBUF_INIT;18401841resolve_undo_write(&sb, istate->resolve_undo);1842 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1843 sb.len) <01844||ce_write(&c, newfd, sb.buf, sb.len) <0;1845strbuf_release(&sb);1846if(err)1847return-1;1848}18491850if(ce_flush(&c, newfd) ||fstat(newfd, &st))1851return-1;1852 istate->timestamp.sec = (unsigned int)st.st_mtime;1853 istate->timestamp.nsec =ST_MTIME_NSEC(st);1854return0;1855}18561857/*1858 * Read the index file that is potentially unmerged into given1859 * index_state, dropping any unmerged entries. Returns true if1860 * the index is unmerged. Callers who want to refuse to work1861 * from an unmerged state can call this and check its return value,1862 * instead of calling read_cache().1863 */1864intread_index_unmerged(struct index_state *istate)1865{1866int i;1867int unmerged =0;18681869read_index(istate);1870for(i =0; i < istate->cache_nr; i++) {1871struct cache_entry *ce = istate->cache[i];1872struct cache_entry *new_ce;1873int size, len;18741875if(!ce_stage(ce))1876continue;1877 unmerged =1;1878 len =ce_namelen(ce);1879 size =cache_entry_size(len);1880 new_ce =xcalloc(1, size);1881memcpy(new_ce->name, ce->name, len);1882 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;1883 new_ce->ce_namelen = len;1884 new_ce->ce_mode = ce->ce_mode;1885if(add_index_entry(istate, new_ce,0))1886returnerror("%s: cannot drop to stage #0",1887 ce->name);1888 i =index_name_pos(istate, new_ce->name, len);1889}1890return unmerged;1891}18921893/*1894 * Returns 1 if the path is an "other" path with respect to1895 * the index; that is, the path is not mentioned in the index at all,1896 * either as a file, a directory with some files in the index,1897 * or as an unmerged entry.1898 *1899 * We helpfully remove a trailing "/" from directories so that1900 * the output of read_directory can be used as-is.1901 */1902intindex_name_is_other(const struct index_state *istate,const char*name,1903int namelen)1904{1905int pos;1906if(namelen && name[namelen -1] =='/')1907 namelen--;1908 pos =index_name_pos(istate, name, namelen);1909if(0<= pos)1910return0;/* exact match */1911 pos = -pos -1;1912if(pos < istate->cache_nr) {1913struct cache_entry *ce = istate->cache[pos];1914if(ce_namelen(ce) == namelen &&1915!memcmp(ce->name, name, namelen))1916return0;/* Yup, this one exists unmerged */1917}1918return1;1919}19201921void*read_blob_data_from_index(struct index_state *istate,const char*path,unsigned long*size)1922{1923int pos, len;1924unsigned long sz;1925enum object_type type;1926void*data;19271928 len =strlen(path);1929 pos =index_name_pos(istate, path, len);1930if(pos <0) {1931/*1932 * We might be in the middle of a merge, in which1933 * case we would read stage #2 (ours).1934 */1935int i;1936for(i = -pos -1;1937(pos <0&& i < istate->cache_nr &&1938!strcmp(istate->cache[i]->name, path));1939 i++)1940if(ce_stage(istate->cache[i]) ==2)1941 pos = i;1942}1943if(pos <0)1944return NULL;1945 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz);1946if(!data || type != OBJ_BLOB) {1947free(data);1948return NULL;1949}1950if(size)1951*size = sz;1952return data;1953}19541955voidstat_validity_clear(struct stat_validity *sv)1956{1957free(sv->sd);1958 sv->sd = NULL;1959}19601961intstat_validity_check(struct stat_validity *sv,const char*path)1962{1963struct stat st;19641965if(stat(path, &st) <0)1966return sv->sd == NULL;1967if(!sv->sd)1968return0;1969returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);1970}19711972voidstat_validity_update(struct stat_validity *sv,int fd)1973{1974struct stat st;19751976if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))1977stat_validity_clear(sv);1978else{1979if(!sv->sd)1980 sv->sd =xcalloc(1,sizeof(struct stat_data));1981fill_stat_data(sv->sd, &st);1982}1983}