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"tempfile.h" 9#include"lockfile.h" 10#include"cache-tree.h" 11#include"refs.h" 12#include"dir.h" 13#include"tree.h" 14#include"commit.h" 15#include"blob.h" 16#include"resolve-undo.h" 17#include"strbuf.h" 18#include"varint.h" 19#include"split-index.h" 20#include"utf8.h" 21 22static struct cache_entry *refresh_cache_entry(struct cache_entry *ce, 23unsigned int options); 24 25/* Mask for the name length in ce_flags in the on-disk index */ 26 27#define CE_NAMEMASK (0x0fff) 28 29/* Index extensions. 30 * 31 * The first letter should be 'A'..'Z' for extensions that are not 32 * necessary for a correct operation (i.e. optimization data). 33 * When new extensions are added that _needs_ to be understood in 34 * order to correctly interpret the index file, pick character that 35 * is outside the range, to cause the reader to abort. 36 */ 37 38#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 39#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 40#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 41#define CACHE_EXT_LINK 0x6c696e6b/* "link" */ 42#define CACHE_EXT_UNTRACKED 0x554E5452/* "UNTR" */ 43 44/* changes that can be kept in $GIT_DIR/index (basically all extensions) */ 45#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \ 46 CE_ENTRY_ADDED | CE_ENTRY_REMOVED | CE_ENTRY_CHANGED | \ 47 SPLIT_INDEX_ORDERED | UNTRACKED_CHANGED) 48 49struct index_state the_index; 50static const char*alternate_index_output; 51 52static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 53{ 54 istate->cache[nr] = ce; 55add_name_hash(istate, ce); 56} 57 58static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 59{ 60struct cache_entry *old = istate->cache[nr]; 61 62replace_index_entry_in_base(istate, old, ce); 63remove_name_hash(istate, old); 64free(old); 65set_index_entry(istate, nr, ce); 66 ce->ce_flags |= CE_UPDATE_IN_BASE; 67 istate->cache_changed |= CE_ENTRY_CHANGED; 68} 69 70voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 71{ 72struct cache_entry *old = istate->cache[nr], *new; 73int namelen =strlen(new_name); 74 75new=xmalloc(cache_entry_size(namelen)); 76copy_cache_entry(new, old); 77new->ce_flags &= ~CE_HASHED; 78new->ce_namelen = namelen; 79new->index =0; 80memcpy(new->name, new_name, namelen +1); 81 82cache_tree_invalidate_path(istate, old->name); 83untracked_cache_remove_from_index(istate, old->name); 84remove_index_entry_at(istate, nr); 85add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 86} 87 88voidfill_stat_data(struct stat_data *sd,struct stat *st) 89{ 90 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 91 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 92 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 93 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 94 sd->sd_dev = st->st_dev; 95 sd->sd_ino = st->st_ino; 96 sd->sd_uid = st->st_uid; 97 sd->sd_gid = st->st_gid; 98 sd->sd_size = st->st_size; 99} 100 101intmatch_stat_data(const struct stat_data *sd,struct stat *st) 102{ 103int changed =0; 104 105if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 106 changed |= MTIME_CHANGED; 107if(trust_ctime && check_stat && 108 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 109 changed |= CTIME_CHANGED; 110 111#ifdef USE_NSEC 112if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 113 changed |= MTIME_CHANGED; 114if(trust_ctime && check_stat && 115 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 116 changed |= CTIME_CHANGED; 117#endif 118 119if(check_stat) { 120if(sd->sd_uid != (unsigned int) st->st_uid || 121 sd->sd_gid != (unsigned int) st->st_gid) 122 changed |= OWNER_CHANGED; 123if(sd->sd_ino != (unsigned int) st->st_ino) 124 changed |= INODE_CHANGED; 125} 126 127#ifdef USE_STDEV 128/* 129 * st_dev breaks on network filesystems where different 130 * clients will have different views of what "device" 131 * the filesystem is on 132 */ 133if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 134 changed |= INODE_CHANGED; 135#endif 136 137if(sd->sd_size != (unsigned int) st->st_size) 138 changed |= DATA_CHANGED; 139 140return changed; 141} 142 143/* 144 * This only updates the "non-critical" parts of the directory 145 * cache, ie the parts that aren't tracked by GIT, and only used 146 * to validate the cache. 147 */ 148voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 149{ 150fill_stat_data(&ce->ce_stat_data, st); 151 152if(assume_unchanged) 153 ce->ce_flags |= CE_VALID; 154 155if(S_ISREG(st->st_mode)) 156ce_mark_uptodate(ce); 157} 158 159static intce_compare_data(const struct cache_entry *ce,struct stat *st) 160{ 161int match = -1; 162int fd =open(ce->name, O_RDONLY); 163 164if(fd >=0) { 165unsigned char sha1[20]; 166if(!index_fd(sha1, fd, st, OBJ_BLOB, ce->name,0)) 167 match =hashcmp(sha1, ce->sha1); 168/* index_fd() closed the file descriptor already */ 169} 170return match; 171} 172 173static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 174{ 175int match = -1; 176void*buffer; 177unsigned long size; 178enum object_type type; 179struct strbuf sb = STRBUF_INIT; 180 181if(strbuf_readlink(&sb, ce->name, expected_size)) 182return-1; 183 184 buffer =read_sha1_file(ce->sha1, &type, &size); 185if(buffer) { 186if(size == sb.len) 187 match =memcmp(buffer, sb.buf, size); 188free(buffer); 189} 190strbuf_release(&sb); 191return match; 192} 193 194static intce_compare_gitlink(const struct cache_entry *ce) 195{ 196unsigned char sha1[20]; 197 198/* 199 * We don't actually require that the .git directory 200 * under GITLINK directory be a valid git directory. It 201 * might even be missing (in case nobody populated that 202 * sub-project). 203 * 204 * If so, we consider it always to match. 205 */ 206if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 207return0; 208returnhashcmp(sha1, ce->sha1); 209} 210 211static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 212{ 213switch(st->st_mode & S_IFMT) { 214case S_IFREG: 215if(ce_compare_data(ce, st)) 216return DATA_CHANGED; 217break; 218case S_IFLNK: 219if(ce_compare_link(ce,xsize_t(st->st_size))) 220return DATA_CHANGED; 221break; 222case S_IFDIR: 223if(S_ISGITLINK(ce->ce_mode)) 224returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 225default: 226return TYPE_CHANGED; 227} 228return0; 229} 230 231static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 232{ 233unsigned int changed =0; 234 235if(ce->ce_flags & CE_REMOVE) 236return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 237 238switch(ce->ce_mode & S_IFMT) { 239case S_IFREG: 240 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 241/* We consider only the owner x bit to be relevant for 242 * "mode changes" 243 */ 244if(trust_executable_bit && 245(0100& (ce->ce_mode ^ st->st_mode))) 246 changed |= MODE_CHANGED; 247break; 248case S_IFLNK: 249if(!S_ISLNK(st->st_mode) && 250(has_symlinks || !S_ISREG(st->st_mode))) 251 changed |= TYPE_CHANGED; 252break; 253case S_IFGITLINK: 254/* We ignore most of the st_xxx fields for gitlinks */ 255if(!S_ISDIR(st->st_mode)) 256 changed |= TYPE_CHANGED; 257else if(ce_compare_gitlink(ce)) 258 changed |= DATA_CHANGED; 259return changed; 260default: 261die("internal error: ce_mode is%o", ce->ce_mode); 262} 263 264 changed |=match_stat_data(&ce->ce_stat_data, st); 265 266/* Racily smudged entry? */ 267if(!ce->ce_stat_data.sd_size) { 268if(!is_empty_blob_sha1(ce->sha1)) 269 changed |= DATA_CHANGED; 270} 271 272return changed; 273} 274 275static intis_racy_stat(const struct index_state *istate, 276const struct stat_data *sd) 277{ 278return(istate->timestamp.sec && 279#ifdef USE_NSEC 280/* nanosecond timestamped files can also be racy! */ 281(istate->timestamp.sec < sd->sd_mtime.sec || 282(istate->timestamp.sec == sd->sd_mtime.sec && 283 istate->timestamp.nsec <= sd->sd_mtime.nsec)) 284#else 285 istate->timestamp.sec <= sd->sd_mtime.sec 286#endif 287); 288} 289 290static intis_racy_timestamp(const struct index_state *istate, 291const struct cache_entry *ce) 292{ 293return(!S_ISGITLINK(ce->ce_mode) && 294is_racy_stat(istate, &ce->ce_stat_data)); 295} 296 297intmatch_stat_data_racy(const struct index_state *istate, 298const struct stat_data *sd,struct stat *st) 299{ 300if(is_racy_stat(istate, sd)) 301return MTIME_CHANGED; 302returnmatch_stat_data(sd, st); 303} 304 305intie_match_stat(const struct index_state *istate, 306const struct cache_entry *ce,struct stat *st, 307unsigned int options) 308{ 309unsigned int changed; 310int ignore_valid = options & CE_MATCH_IGNORE_VALID; 311int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 312int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 313 314/* 315 * If it's marked as always valid in the index, it's 316 * valid whatever the checked-out copy says. 317 * 318 * skip-worktree has the same effect with higher precedence 319 */ 320if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 321return0; 322if(!ignore_valid && (ce->ce_flags & CE_VALID)) 323return0; 324 325/* 326 * Intent-to-add entries have not been added, so the index entry 327 * by definition never matches what is in the work tree until it 328 * actually gets added. 329 */ 330if(ce_intent_to_add(ce)) 331return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 332 333 changed =ce_match_stat_basic(ce, st); 334 335/* 336 * Within 1 second of this sequence: 337 * echo xyzzy >file && git-update-index --add file 338 * running this command: 339 * echo frotz >file 340 * would give a falsely clean cache entry. The mtime and 341 * length match the cache, and other stat fields do not change. 342 * 343 * We could detect this at update-index time (the cache entry 344 * being registered/updated records the same time as "now") 345 * and delay the return from git-update-index, but that would 346 * effectively mean we can make at most one commit per second, 347 * which is not acceptable. Instead, we check cache entries 348 * whose mtime are the same as the index file timestamp more 349 * carefully than others. 350 */ 351if(!changed &&is_racy_timestamp(istate, ce)) { 352if(assume_racy_is_modified) 353 changed |= DATA_CHANGED; 354else 355 changed |=ce_modified_check_fs(ce, st); 356} 357 358return changed; 359} 360 361intie_modified(const struct index_state *istate, 362const struct cache_entry *ce, 363struct stat *st,unsigned int options) 364{ 365int changed, changed_fs; 366 367 changed =ie_match_stat(istate, ce, st, options); 368if(!changed) 369return0; 370/* 371 * If the mode or type has changed, there's no point in trying 372 * to refresh the entry - it's not going to match 373 */ 374if(changed & (MODE_CHANGED | TYPE_CHANGED)) 375return changed; 376 377/* 378 * Immediately after read-tree or update-index --cacheinfo, 379 * the length field is zero, as we have never even read the 380 * lstat(2) information once, and we cannot trust DATA_CHANGED 381 * returned by ie_match_stat() which in turn was returned by 382 * ce_match_stat_basic() to signal that the filesize of the 383 * blob changed. We have to actually go to the filesystem to 384 * see if the contents match, and if so, should answer "unchanged". 385 * 386 * The logic does not apply to gitlinks, as ce_match_stat_basic() 387 * already has checked the actual HEAD from the filesystem in the 388 * subproject. If ie_match_stat() already said it is different, 389 * then we know it is. 390 */ 391if((changed & DATA_CHANGED) && 392(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 393return changed; 394 395 changed_fs =ce_modified_check_fs(ce, st); 396if(changed_fs) 397return changed | changed_fs; 398return0; 399} 400 401intbase_name_compare(const char*name1,int len1,int mode1, 402const char*name2,int len2,int mode2) 403{ 404unsigned char c1, c2; 405int len = len1 < len2 ? len1 : len2; 406int cmp; 407 408 cmp =memcmp(name1, name2, len); 409if(cmp) 410return cmp; 411 c1 = name1[len]; 412 c2 = name2[len]; 413if(!c1 &&S_ISDIR(mode1)) 414 c1 ='/'; 415if(!c2 &&S_ISDIR(mode2)) 416 c2 ='/'; 417return(c1 < c2) ? -1: (c1 > c2) ?1:0; 418} 419 420/* 421 * df_name_compare() is identical to base_name_compare(), except it 422 * compares conflicting directory/file entries as equal. Note that 423 * while a directory name compares as equal to a regular file, they 424 * then individually compare _differently_ to a filename that has 425 * a dot after the basename (because '\0' < '.' < '/'). 426 * 427 * This is used by routines that want to traverse the git namespace 428 * but then handle conflicting entries together when possible. 429 */ 430intdf_name_compare(const char*name1,int len1,int mode1, 431const char*name2,int len2,int mode2) 432{ 433int len = len1 < len2 ? len1 : len2, cmp; 434unsigned char c1, c2; 435 436 cmp =memcmp(name1, name2, len); 437if(cmp) 438return cmp; 439/* Directories and files compare equal (same length, same name) */ 440if(len1 == len2) 441return0; 442 c1 = name1[len]; 443if(!c1 &&S_ISDIR(mode1)) 444 c1 ='/'; 445 c2 = name2[len]; 446if(!c2 &&S_ISDIR(mode2)) 447 c2 ='/'; 448if(c1 =='/'&& !c2) 449return0; 450if(c2 =='/'&& !c1) 451return0; 452return c1 - c2; 453} 454 455intname_compare(const char*name1,size_t len1,const char*name2,size_t len2) 456{ 457size_t min_len = (len1 < len2) ? len1 : len2; 458int cmp =memcmp(name1, name2, min_len); 459if(cmp) 460return cmp; 461if(len1 < len2) 462return-1; 463if(len1 > len2) 464return1; 465return0; 466} 467 468intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 469{ 470int cmp; 471 472 cmp =name_compare(name1, len1, name2, len2); 473if(cmp) 474return cmp; 475 476if(stage1 < stage2) 477return-1; 478if(stage1 > stage2) 479return1; 480return0; 481} 482 483static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 484{ 485int first, last; 486 487 first =0; 488 last = istate->cache_nr; 489while(last > first) { 490int next = (last + first) >>1; 491struct cache_entry *ce = istate->cache[next]; 492int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 493if(!cmp) 494return next; 495if(cmp <0) { 496 last = next; 497continue; 498} 499 first = next+1; 500} 501return-first-1; 502} 503 504intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 505{ 506returnindex_name_stage_pos(istate, name, namelen,0); 507} 508 509/* Remove entry, return true if there are more entries to go.. */ 510intremove_index_entry_at(struct index_state *istate,int pos) 511{ 512struct cache_entry *ce = istate->cache[pos]; 513 514record_resolve_undo(istate, ce); 515remove_name_hash(istate, ce); 516save_or_free_index_entry(istate, ce); 517 istate->cache_changed |= CE_ENTRY_REMOVED; 518 istate->cache_nr--; 519if(pos >= istate->cache_nr) 520return0; 521memmove(istate->cache + pos, 522 istate->cache + pos +1, 523(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 524return1; 525} 526 527/* 528 * Remove all cache entries marked for removal, that is where 529 * CE_REMOVE is set in ce_flags. This is much more effective than 530 * calling remove_index_entry_at() for each entry to be removed. 531 */ 532voidremove_marked_cache_entries(struct index_state *istate) 533{ 534struct cache_entry **ce_array = istate->cache; 535unsigned int i, j; 536 537for(i = j =0; i < istate->cache_nr; i++) { 538if(ce_array[i]->ce_flags & CE_REMOVE) { 539remove_name_hash(istate, ce_array[i]); 540save_or_free_index_entry(istate, ce_array[i]); 541} 542else 543 ce_array[j++] = ce_array[i]; 544} 545if(j == istate->cache_nr) 546return; 547 istate->cache_changed |= CE_ENTRY_REMOVED; 548 istate->cache_nr = j; 549} 550 551intremove_file_from_index(struct index_state *istate,const char*path) 552{ 553int pos =index_name_pos(istate, path,strlen(path)); 554if(pos <0) 555 pos = -pos-1; 556cache_tree_invalidate_path(istate, path); 557untracked_cache_remove_from_index(istate, path); 558while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 559remove_index_entry_at(istate, pos); 560return0; 561} 562 563static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 564{ 565return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 566} 567 568static intindex_name_pos_also_unmerged(struct index_state *istate, 569const char*path,int namelen) 570{ 571int pos =index_name_pos(istate, path, namelen); 572struct cache_entry *ce; 573 574if(pos >=0) 575return pos; 576 577/* maybe unmerged? */ 578 pos = -1- pos; 579if(pos >= istate->cache_nr || 580compare_name((ce = istate->cache[pos]), path, namelen)) 581return-1; 582 583/* order of preference: stage 2, 1, 3 */ 584if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 585ce_stage((ce = istate->cache[pos +1])) ==2&& 586!compare_name(ce, path, namelen)) 587 pos++; 588return pos; 589} 590 591static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 592{ 593int len =ce_namelen(ce); 594returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 595} 596 597/* 598 * If we add a filename that aliases in the cache, we will use the 599 * name that we already have - but we don't want to update the same 600 * alias twice, because that implies that there were actually two 601 * different files with aliasing names! 602 * 603 * So we use the CE_ADDED flag to verify that the alias was an old 604 * one before we accept it as 605 */ 606static struct cache_entry *create_alias_ce(struct index_state *istate, 607struct cache_entry *ce, 608struct cache_entry *alias) 609{ 610int len; 611struct cache_entry *new; 612 613if(alias->ce_flags & CE_ADDED) 614die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 615 616/* Ok, create the new entry using the name of the existing alias */ 617 len =ce_namelen(alias); 618new=xcalloc(1,cache_entry_size(len)); 619memcpy(new->name, alias->name, len); 620copy_cache_entry(new, ce); 621save_or_free_index_entry(istate, ce); 622return new; 623} 624 625voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 626{ 627unsigned char sha1[20]; 628if(write_sha1_file("",0, blob_type, sha1)) 629die("cannot create an empty blob in the object database"); 630hashcpy(ce->sha1, sha1); 631} 632 633intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags,int force_mode) 634{ 635int size, namelen, was_same; 636 mode_t st_mode = st->st_mode; 637struct cache_entry *ce, *alias; 638unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 639int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 640int pretend = flags & ADD_CACHE_PRETEND; 641int intent_only = flags & ADD_CACHE_INTENT; 642int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 643(intent_only ? ADD_CACHE_NEW_ONLY :0)); 644 645if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 646returnerror("%s: can only add regular files, symbolic links or git-directories", path); 647 648 namelen =strlen(path); 649if(S_ISDIR(st_mode)) { 650while(namelen && path[namelen-1] =='/') 651 namelen--; 652} 653 size =cache_entry_size(namelen); 654 ce =xcalloc(1, size); 655memcpy(ce->name, path, namelen); 656 ce->ce_namelen = namelen; 657if(!intent_only) 658fill_stat_cache_info(ce, st); 659else 660 ce->ce_flags |= CE_INTENT_TO_ADD; 661 662if(S_ISREG(st_mode) && force_mode) 663 ce->ce_mode =create_ce_mode(force_mode); 664else if(trust_executable_bit && has_symlinks) 665 ce->ce_mode =create_ce_mode(st_mode); 666else{ 667/* If there is an existing entry, pick the mode bits and type 668 * from it, otherwise assume unexecutable regular file. 669 */ 670struct cache_entry *ent; 671int pos =index_name_pos_also_unmerged(istate, path, namelen); 672 673 ent = (0<= pos) ? istate->cache[pos] : NULL; 674 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 675} 676 677/* When core.ignorecase=true, determine if a directory of the same name but differing 678 * case already exists within the Git repository. If it does, ensure the directory 679 * case of the file being added to the repository matches (is folded into) the existing 680 * entry's directory case. 681 */ 682if(ignore_case) { 683adjust_dirname_case(istate, ce->name); 684} 685 686 alias =index_file_exists(istate, ce->name,ce_namelen(ce), ignore_case); 687if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 688/* Nothing changed, really */ 689if(!S_ISGITLINK(alias->ce_mode)) 690ce_mark_uptodate(alias); 691 alias->ce_flags |= CE_ADDED; 692 693free(ce); 694return0; 695} 696if(!intent_only) { 697if(index_path(ce->sha1, path, st, HASH_WRITE_OBJECT)) { 698free(ce); 699returnerror("unable to index file%s", path); 700} 701}else 702set_object_name_for_intent_to_add_entry(ce); 703 704if(ignore_case && alias &&different_name(ce, alias)) 705 ce =create_alias_ce(istate, ce, alias); 706 ce->ce_flags |= CE_ADDED; 707 708/* It was suspected to be racily clean, but it turns out to be Ok */ 709 was_same = (alias && 710!ce_stage(alias) && 711!hashcmp(alias->sha1, ce->sha1) && 712 ce->ce_mode == alias->ce_mode); 713 714if(pretend) 715free(ce); 716else if(add_index_entry(istate, ce, add_option)) { 717free(ce); 718returnerror("unable to add%sto index", path); 719} 720if(verbose && !was_same) 721printf("add '%s'\n", path); 722return0; 723} 724 725intadd_file_to_index(struct index_state *istate,const char*path, 726int flags,int force_mode) 727{ 728struct stat st; 729if(lstat(path, &st)) 730die_errno("unable to stat '%s'", path); 731returnadd_to_index(istate, path, &st, flags, force_mode); 732} 733 734struct cache_entry *make_cache_entry(unsigned int mode, 735const unsigned char*sha1,const char*path,int stage, 736unsigned int refresh_options) 737{ 738int size, len; 739struct cache_entry *ce, *ret; 740 741if(!verify_path(path)) { 742error("Invalid path '%s'", path); 743return NULL; 744} 745 746 len =strlen(path); 747 size =cache_entry_size(len); 748 ce =xcalloc(1, size); 749 750hashcpy(ce->sha1, sha1); 751memcpy(ce->name, path, len); 752 ce->ce_flags =create_ce_flags(stage); 753 ce->ce_namelen = len; 754 ce->ce_mode =create_ce_mode(mode); 755 756 ret =refresh_cache_entry(ce, refresh_options); 757if(ret != ce) 758free(ce); 759return ret; 760} 761 762/* 763 * Chmod an index entry with either +x or -x. 764 * 765 * Returns -1 if the chmod for the particular cache entry failed (if it's 766 * not a regular file), -2 if an invalid flip argument is passed in, 0 767 * otherwise. 768 */ 769intchmod_index_entry(struct index_state *istate,struct cache_entry *ce, 770char flip) 771{ 772if(!S_ISREG(ce->ce_mode)) 773return-1; 774switch(flip) { 775case'+': 776 ce->ce_mode |=0111; 777break; 778case'-': 779 ce->ce_mode &= ~0111; 780break; 781default: 782return-2; 783} 784cache_tree_invalidate_path(istate, ce->name); 785 ce->ce_flags |= CE_UPDATE_IN_BASE; 786 istate->cache_changed |= CE_ENTRY_CHANGED; 787 788return0; 789} 790 791intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 792{ 793int len =ce_namelen(a); 794returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 795} 796 797/* 798 * We fundamentally don't like some paths: we don't want 799 * dot or dot-dot anywhere, and for obvious reasons don't 800 * want to recurse into ".git" either. 801 * 802 * Also, we don't want double slashes or slashes at the 803 * end that can make pathnames ambiguous. 804 */ 805static intverify_dotfile(const char*rest) 806{ 807/* 808 * The first character was '.', but that 809 * has already been discarded, we now test 810 * the rest. 811 */ 812 813/* "." is not allowed */ 814if(*rest =='\0'||is_dir_sep(*rest)) 815return0; 816 817switch(*rest) { 818/* 819 * ".git" followed by NUL or slash is bad. This 820 * shares the path end test with the ".." case. 821 */ 822case'g': 823case'G': 824if(rest[1] !='i'&& rest[1] !='I') 825break; 826if(rest[2] !='t'&& rest[2] !='T') 827break; 828 rest +=2; 829/* fallthrough */ 830case'.': 831if(rest[1] =='\0'||is_dir_sep(rest[1])) 832return0; 833} 834return1; 835} 836 837intverify_path(const char*path) 838{ 839char c; 840 841if(has_dos_drive_prefix(path)) 842return0; 843 844goto inside; 845for(;;) { 846if(!c) 847return1; 848if(is_dir_sep(c)) { 849inside: 850if(protect_hfs &&is_hfs_dotgit(path)) 851return0; 852if(protect_ntfs &&is_ntfs_dotgit(path)) 853return0; 854 c = *path++; 855if((c =='.'&& !verify_dotfile(path)) || 856is_dir_sep(c) || c =='\0') 857return0; 858} 859 c = *path++; 860} 861} 862 863/* 864 * Do we have another file that has the beginning components being a 865 * proper superset of the name we're trying to add? 866 */ 867static inthas_file_name(struct index_state *istate, 868const struct cache_entry *ce,int pos,int ok_to_replace) 869{ 870int retval =0; 871int len =ce_namelen(ce); 872int stage =ce_stage(ce); 873const char*name = ce->name; 874 875while(pos < istate->cache_nr) { 876struct cache_entry *p = istate->cache[pos++]; 877 878if(len >=ce_namelen(p)) 879break; 880if(memcmp(name, p->name, len)) 881break; 882if(ce_stage(p) != stage) 883continue; 884if(p->name[len] !='/') 885continue; 886if(p->ce_flags & CE_REMOVE) 887continue; 888 retval = -1; 889if(!ok_to_replace) 890break; 891remove_index_entry_at(istate, --pos); 892} 893return retval; 894} 895 896/* 897 * Do we have another file with a pathname that is a proper 898 * subset of the name we're trying to add? 899 */ 900static inthas_dir_name(struct index_state *istate, 901const struct cache_entry *ce,int pos,int ok_to_replace) 902{ 903int retval =0; 904int stage =ce_stage(ce); 905const char*name = ce->name; 906const char*slash = name +ce_namelen(ce); 907 908for(;;) { 909int len; 910 911for(;;) { 912if(*--slash =='/') 913break; 914if(slash <= ce->name) 915return retval; 916} 917 len = slash - name; 918 919 pos =index_name_stage_pos(istate, name, len, stage); 920if(pos >=0) { 921/* 922 * Found one, but not so fast. This could 923 * be a marker that says "I was here, but 924 * I am being removed". Such an entry is 925 * not a part of the resulting tree, and 926 * it is Ok to have a directory at the same 927 * path. 928 */ 929if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 930 retval = -1; 931if(!ok_to_replace) 932break; 933remove_index_entry_at(istate, pos); 934continue; 935} 936} 937else 938 pos = -pos-1; 939 940/* 941 * Trivial optimization: if we find an entry that 942 * already matches the sub-directory, then we know 943 * we're ok, and we can exit. 944 */ 945while(pos < istate->cache_nr) { 946struct cache_entry *p = istate->cache[pos]; 947if((ce_namelen(p) <= len) || 948(p->name[len] !='/') || 949memcmp(p->name, name, len)) 950break;/* not our subdirectory */ 951if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 952/* 953 * p is at the same stage as our entry, and 954 * is a subdirectory of what we are looking 955 * at, so we cannot have conflicts at our 956 * level or anything shorter. 957 */ 958return retval; 959 pos++; 960} 961} 962return retval; 963} 964 965/* We may be in a situation where we already have path/file and path 966 * is being added, or we already have path and path/file is being 967 * added. Either one would result in a nonsense tree that has path 968 * twice when git-write-tree tries to write it out. Prevent it. 969 * 970 * If ok-to-replace is specified, we remove the conflicting entries 971 * from the cache so the caller should recompute the insert position. 972 * When this happens, we return non-zero. 973 */ 974static intcheck_file_directory_conflict(struct index_state *istate, 975const struct cache_entry *ce, 976int pos,int ok_to_replace) 977{ 978int retval; 979 980/* 981 * When ce is an "I am going away" entry, we allow it to be added 982 */ 983if(ce->ce_flags & CE_REMOVE) 984return0; 985 986/* 987 * We check if the path is a sub-path of a subsequent pathname 988 * first, since removing those will not change the position 989 * in the array. 990 */ 991 retval =has_file_name(istate, ce, pos, ok_to_replace); 992 993/* 994 * Then check if the path might have a clashing sub-directory 995 * before it. 996 */ 997return retval +has_dir_name(istate, ce, pos, ok_to_replace); 998} 9991000static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option)1001{1002int pos;1003int ok_to_add = option & ADD_CACHE_OK_TO_ADD;1004int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;1005int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;1006int new_only = option & ADD_CACHE_NEW_ONLY;10071008if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1009cache_tree_invalidate_path(istate, ce->name);1010 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));10111012/* existing match? Just replace it. */1013if(pos >=0) {1014if(!new_only)1015replace_index_entry(istate, pos, ce);1016return0;1017}1018 pos = -pos-1;10191020if(!(option & ADD_CACHE_KEEP_CACHE_TREE))1021untracked_cache_add_to_index(istate, ce->name);10221023/*1024 * Inserting a merged entry ("stage 0") into the index1025 * will always replace all non-merged entries..1026 */1027if(pos < istate->cache_nr &&ce_stage(ce) ==0) {1028while(ce_same_name(istate->cache[pos], ce)) {1029 ok_to_add =1;1030if(!remove_index_entry_at(istate, pos))1031break;1032}1033}10341035if(!ok_to_add)1036return-1;1037if(!verify_path(ce->name))1038returnerror("Invalid path '%s'", ce->name);10391040if(!skip_df_check &&1041check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {1042if(!ok_to_replace)1043returnerror("'%s' appears as both a file and as a directory",1044 ce->name);1045 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce));1046 pos = -pos-1;1047}1048return pos +1;1049}10501051intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option)1052{1053int pos;10541055if(option & ADD_CACHE_JUST_APPEND)1056 pos = istate->cache_nr;1057else{1058int ret;1059 ret =add_index_entry_with_check(istate, ce, option);1060if(ret <=0)1061return ret;1062 pos = ret -1;1063}10641065/* Make sure the array is big enough .. */1066ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc);10671068/* Add it in.. */1069 istate->cache_nr++;1070if(istate->cache_nr > pos +1)1071memmove(istate->cache + pos +1,1072 istate->cache + pos,1073(istate->cache_nr - pos -1) *sizeof(ce));1074set_index_entry(istate, pos, ce);1075 istate->cache_changed |= CE_ENTRY_ADDED;1076return0;1077}10781079/*1080 * "refresh" does not calculate a new sha1 file or bring the1081 * cache up-to-date for mode/content changes. But what it1082 * _does_ do is to "re-match" the stat information of a file1083 * with the cache, so that you can refresh the cache for a1084 * file that hasn't been changed but where the stat entry is1085 * out of date.1086 *1087 * For example, you'd want to do this after doing a "git-read-tree",1088 * to link up the stat cache details with the proper files.1089 */1090static struct cache_entry *refresh_cache_ent(struct index_state *istate,1091struct cache_entry *ce,1092unsigned int options,int*err,1093int*changed_ret)1094{1095struct stat st;1096struct cache_entry *updated;1097int changed, size;1098int refresh = options & CE_MATCH_REFRESH;1099int ignore_valid = options & CE_MATCH_IGNORE_VALID;1100int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1101int ignore_missing = options & CE_MATCH_IGNORE_MISSING;11021103if(!refresh ||ce_uptodate(ce))1104return ce;11051106/*1107 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1108 * that the change to the work tree does not matter and told1109 * us not to worry.1110 */1111if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1112ce_mark_uptodate(ce);1113return ce;1114}1115if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1116ce_mark_uptodate(ce);1117return ce;1118}11191120if(has_symlink_leading_path(ce->name,ce_namelen(ce))) {1121if(ignore_missing)1122return ce;1123if(err)1124*err = ENOENT;1125return NULL;1126}11271128if(lstat(ce->name, &st) <0) {1129if(ignore_missing && errno == ENOENT)1130return ce;1131if(err)1132*err = errno;1133return NULL;1134}11351136 changed =ie_match_stat(istate, ce, &st, options);1137if(changed_ret)1138*changed_ret = changed;1139if(!changed) {1140/*1141 * The path is unchanged. If we were told to ignore1142 * valid bit, then we did the actual stat check and1143 * found that the entry is unmodified. If the entry1144 * is not marked VALID, this is the place to mark it1145 * valid again, under "assume unchanged" mode.1146 */1147if(ignore_valid && assume_unchanged &&1148!(ce->ce_flags & CE_VALID))1149;/* mark this one VALID again */1150else{1151/*1152 * We do not mark the index itself "modified"1153 * because CE_UPTODATE flag is in-core only;1154 * we are not going to write this change out.1155 */1156if(!S_ISGITLINK(ce->ce_mode))1157ce_mark_uptodate(ce);1158return ce;1159}1160}11611162if(ie_modified(istate, ce, &st, options)) {1163if(err)1164*err = EINVAL;1165return NULL;1166}11671168 size =ce_size(ce);1169 updated =xmalloc(size);1170memcpy(updated, ce, size);1171fill_stat_cache_info(updated, &st);1172/*1173 * If ignore_valid is not set, we should leave CE_VALID bit1174 * alone. Otherwise, paths marked with --no-assume-unchanged1175 * (i.e. things to be edited) will reacquire CE_VALID bit1176 * automatically, which is not really what we want.1177 */1178if(!ignore_valid && assume_unchanged &&1179!(ce->ce_flags & CE_VALID))1180 updated->ce_flags &= ~CE_VALID;11811182/* istate->cache_changed is updated in the caller */1183return updated;1184}11851186static voidshow_file(const char* fmt,const char* name,int in_porcelain,1187int* first,const char*header_msg)1188{1189if(in_porcelain && *first && header_msg) {1190printf("%s\n", header_msg);1191*first =0;1192}1193printf(fmt, name);1194}11951196intrefresh_index(struct index_state *istate,unsigned int flags,1197const struct pathspec *pathspec,1198char*seen,const char*header_msg)1199{1200int i;1201int has_errors =0;1202int really = (flags & REFRESH_REALLY) !=0;1203int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1204int quiet = (flags & REFRESH_QUIET) !=0;1205int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1206int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1207int first =1;1208int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1209unsigned int options = (CE_MATCH_REFRESH |1210(really ? CE_MATCH_IGNORE_VALID :0) |1211(not_new ? CE_MATCH_IGNORE_MISSING :0));1212const char*modified_fmt;1213const char*deleted_fmt;1214const char*typechange_fmt;1215const char*added_fmt;1216const char*unmerged_fmt;12171218 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1219 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1220 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1221 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1222 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1223for(i =0; i < istate->cache_nr; i++) {1224struct cache_entry *ce, *new;1225int cache_errno =0;1226int changed =0;1227int filtered =0;12281229 ce = istate->cache[i];1230if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1231continue;12321233if(pathspec && !ce_path_match(ce, pathspec, seen))1234 filtered =1;12351236if(ce_stage(ce)) {1237while((i < istate->cache_nr) &&1238!strcmp(istate->cache[i]->name, ce->name))1239 i++;1240 i--;1241if(allow_unmerged)1242continue;1243if(!filtered)1244show_file(unmerged_fmt, ce->name, in_porcelain,1245&first, header_msg);1246 has_errors =1;1247continue;1248}12491250if(filtered)1251continue;12521253new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1254if(new== ce)1255continue;1256if(!new) {1257const char*fmt;12581259if(really && cache_errno == EINVAL) {1260/* If we are doing --really-refresh that1261 * means the index is not valid anymore.1262 */1263 ce->ce_flags &= ~CE_VALID;1264 ce->ce_flags |= CE_UPDATE_IN_BASE;1265 istate->cache_changed |= CE_ENTRY_CHANGED;1266}1267if(quiet)1268continue;12691270if(cache_errno == ENOENT)1271 fmt = deleted_fmt;1272else if(ce_intent_to_add(ce))1273 fmt = added_fmt;/* must be before other checks */1274else if(changed & TYPE_CHANGED)1275 fmt = typechange_fmt;1276else1277 fmt = modified_fmt;1278show_file(fmt,1279 ce->name, in_porcelain, &first, header_msg);1280 has_errors =1;1281continue;1282}12831284replace_index_entry(istate, i,new);1285}1286return has_errors;1287}12881289static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1290unsigned int options)1291{1292returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1293}129412951296/*****************************************************************1297 * Index File I/O1298 *****************************************************************/12991300#define INDEX_FORMAT_DEFAULT 313011302static unsigned intget_index_format_default(void)1303{1304char*envversion =getenv("GIT_INDEX_VERSION");1305char*endp;1306int value;1307unsigned int version = INDEX_FORMAT_DEFAULT;13081309if(!envversion) {1310if(!git_config_get_int("index.version", &value))1311 version = value;1312if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1313warning(_("index.version set, but the value is invalid.\n"1314"Using version%i"), INDEX_FORMAT_DEFAULT);1315return INDEX_FORMAT_DEFAULT;1316}1317return version;1318}13191320 version =strtoul(envversion, &endp,10);1321if(*endp ||1322 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1323warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1324"Using version%i"), INDEX_FORMAT_DEFAULT);1325 version = INDEX_FORMAT_DEFAULT;1326}1327return version;1328}13291330/*1331 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1332 * Again - this is just a (very strong in practice) heuristic that1333 * the inode hasn't changed.1334 *1335 * We save the fields in big-endian order to allow using the1336 * index file over NFS transparently.1337 */1338struct ondisk_cache_entry {1339struct cache_time ctime;1340struct cache_time mtime;1341uint32_t dev;1342uint32_t ino;1343uint32_t mode;1344uint32_t uid;1345uint32_t gid;1346uint32_t size;1347unsigned char sha1[20];1348uint16_t flags;1349char name[FLEX_ARRAY];/* more */1350};13511352/*1353 * This struct is used when CE_EXTENDED bit is 11354 * The struct must match ondisk_cache_entry exactly from1355 * ctime till flags1356 */1357struct ondisk_cache_entry_extended {1358struct cache_time ctime;1359struct cache_time mtime;1360uint32_t dev;1361uint32_t ino;1362uint32_t mode;1363uint32_t uid;1364uint32_t gid;1365uint32_t size;1366unsigned char sha1[20];1367uint16_t flags;1368uint16_t flags2;1369char name[FLEX_ARRAY];/* more */1370};13711372/* These are only used for v3 or lower */1373#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1374#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1375#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1376#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1377 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1378 ondisk_cache_entry_size(ce_namelen(ce)))13791380static intverify_hdr(struct cache_header *hdr,unsigned long size)1381{1382 git_SHA_CTX c;1383unsigned char sha1[20];1384int hdr_version;13851386if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1387returnerror("bad signature");1388 hdr_version =ntohl(hdr->hdr_version);1389if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1390returnerror("bad index version%d", hdr_version);1391git_SHA1_Init(&c);1392git_SHA1_Update(&c, hdr, size -20);1393git_SHA1_Final(sha1, &c);1394if(hashcmp(sha1, (unsigned char*)hdr + size -20))1395returnerror("bad index file sha1 signature");1396return0;1397}13981399static intread_index_extension(struct index_state *istate,1400const char*ext,void*data,unsigned long sz)1401{1402switch(CACHE_EXT(ext)) {1403case CACHE_EXT_TREE:1404 istate->cache_tree =cache_tree_read(data, sz);1405break;1406case CACHE_EXT_RESOLVE_UNDO:1407 istate->resolve_undo =resolve_undo_read(data, sz);1408break;1409case CACHE_EXT_LINK:1410if(read_link_extension(istate, data, sz))1411return-1;1412break;1413case CACHE_EXT_UNTRACKED:1414 istate->untracked =read_untracked_extension(data, sz);1415break;1416default:1417if(*ext <'A'||'Z'< *ext)1418returnerror("index uses %.4s extension, which we do not understand",1419 ext);1420fprintf(stderr,"ignoring %.4s extension\n", ext);1421break;1422}1423return0;1424}14251426inthold_locked_index(struct lock_file *lk,int die_on_error)1427{1428returnhold_lock_file_for_update(lk,get_index_file(),1429 die_on_error1430? LOCK_DIE_ON_ERROR1431:0);1432}14331434intread_index(struct index_state *istate)1435{1436returnread_index_from(istate,get_index_file());1437}14381439static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1440unsigned int flags,1441const char*name,1442size_t len)1443{1444struct cache_entry *ce =xmalloc(cache_entry_size(len));14451446 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1447 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1448 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1449 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1450 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1451 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1452 ce->ce_mode =get_be32(&ondisk->mode);1453 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1454 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1455 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1456 ce->ce_flags = flags & ~CE_NAMEMASK;1457 ce->ce_namelen = len;1458 ce->index =0;1459hashcpy(ce->sha1, ondisk->sha1);1460memcpy(ce->name, name, len);1461 ce->name[len] ='\0';1462return ce;1463}14641465/*1466 * Adjacent cache entries tend to share the leading paths, so it makes1467 * sense to only store the differences in later entries. In the v41468 * on-disk format of the index, each on-disk cache entry stores the1469 * number of bytes to be stripped from the end of the previous name,1470 * and the bytes to append to the result, to come up with its name.1471 */1472static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1473{1474const unsigned char*ep, *cp = (const unsigned char*)cp_;1475size_t len =decode_varint(&cp);14761477if(name->len < len)1478die("malformed name field in the index");1479strbuf_remove(name, name->len - len, len);1480for(ep = cp; *ep; ep++)1481;/* find the end */1482strbuf_add(name, cp, ep - cp);1483return(const char*)ep +1- cp_;1484}14851486static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1487unsigned long*ent_size,1488struct strbuf *previous_name)1489{1490struct cache_entry *ce;1491size_t len;1492const char*name;1493unsigned int flags;14941495/* On-disk flags are just 16 bits */1496 flags =get_be16(&ondisk->flags);1497 len = flags & CE_NAMEMASK;14981499if(flags & CE_EXTENDED) {1500struct ondisk_cache_entry_extended *ondisk2;1501int extended_flags;1502 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1503 extended_flags =get_be16(&ondisk2->flags2) <<16;1504/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1505if(extended_flags & ~CE_EXTENDED_FLAGS)1506die("Unknown index entry format%08x", extended_flags);1507 flags |= extended_flags;1508 name = ondisk2->name;1509}1510else1511 name = ondisk->name;15121513if(!previous_name) {1514/* v3 and earlier */1515if(len == CE_NAMEMASK)1516 len =strlen(name);1517 ce =cache_entry_from_ondisk(ondisk, flags, name, len);15181519*ent_size =ondisk_ce_size(ce);1520}else{1521unsigned long consumed;1522 consumed =expand_name_field(previous_name, name);1523 ce =cache_entry_from_ondisk(ondisk, flags,1524 previous_name->buf,1525 previous_name->len);15261527*ent_size = (name - ((char*)ondisk)) + consumed;1528}1529return ce;1530}15311532static voidcheck_ce_order(struct index_state *istate)1533{1534unsigned int i;15351536for(i =1; i < istate->cache_nr; i++) {1537struct cache_entry *ce = istate->cache[i -1];1538struct cache_entry *next_ce = istate->cache[i];1539int name_compare =strcmp(ce->name, next_ce->name);15401541if(0< name_compare)1542die("unordered stage entries in index");1543if(!name_compare) {1544if(!ce_stage(ce))1545die("multiple stage entries for merged file '%s'",1546 ce->name);1547if(ce_stage(ce) >ce_stage(next_ce))1548die("unordered stage entries for '%s'",1549 ce->name);1550}1551}1552}15531554static voidtweak_untracked_cache(struct index_state *istate)1555{1556switch(git_config_get_untracked_cache()) {1557case-1:/* keep: do nothing */1558break;1559case0:/* false */1560remove_untracked_cache(istate);1561break;1562case1:/* true */1563add_untracked_cache(istate);1564break;1565default:/* unknown value: do nothing */1566break;1567}1568}15691570static voidpost_read_index_from(struct index_state *istate)1571{1572check_ce_order(istate);1573tweak_untracked_cache(istate);1574}15751576/* remember to discard_cache() before reading a different cache! */1577intdo_read_index(struct index_state *istate,const char*path,int must_exist)1578{1579int fd, i;1580struct stat st;1581unsigned long src_offset;1582struct cache_header *hdr;1583void*mmap;1584size_t mmap_size;1585struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;15861587if(istate->initialized)1588return istate->cache_nr;15891590 istate->timestamp.sec =0;1591 istate->timestamp.nsec =0;1592 fd =open(path, O_RDONLY);1593if(fd <0) {1594if(!must_exist && errno == ENOENT)1595return0;1596die_errno("%s: index file open failed", path);1597}15981599if(fstat(fd, &st))1600die_errno("cannot stat the open index");16011602 mmap_size =xsize_t(st.st_size);1603if(mmap_size <sizeof(struct cache_header) +20)1604die("index file smaller than expected");16051606 mmap =xmmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, fd,0);1607if(mmap == MAP_FAILED)1608die_errno("unable to map index file");1609close(fd);16101611 hdr = mmap;1612if(verify_hdr(hdr, mmap_size) <0)1613goto unmap;16141615hashcpy(istate->sha1, (const unsigned char*)hdr + mmap_size -20);1616 istate->version =ntohl(hdr->hdr_version);1617 istate->cache_nr =ntohl(hdr->hdr_entries);1618 istate->cache_alloc =alloc_nr(istate->cache_nr);1619 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1620 istate->initialized =1;16211622if(istate->version ==4)1623 previous_name = &previous_name_buf;1624else1625 previous_name = NULL;16261627 src_offset =sizeof(*hdr);1628for(i =0; i < istate->cache_nr; i++) {1629struct ondisk_cache_entry *disk_ce;1630struct cache_entry *ce;1631unsigned long consumed;16321633 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1634 ce =create_from_disk(disk_ce, &consumed, previous_name);1635set_index_entry(istate, i, ce);16361637 src_offset += consumed;1638}1639strbuf_release(&previous_name_buf);1640 istate->timestamp.sec = st.st_mtime;1641 istate->timestamp.nsec =ST_MTIME_NSEC(st);16421643while(src_offset <= mmap_size -20-8) {1644/* After an array of active_nr index entries,1645 * there can be arbitrary number of extended1646 * sections, each of which is prefixed with1647 * extension name (4-byte) and section length1648 * in 4-byte network byte order.1649 */1650uint32_t extsize;1651memcpy(&extsize, (char*)mmap + src_offset +4,4);1652 extsize =ntohl(extsize);1653if(read_index_extension(istate,1654(const char*) mmap + src_offset,1655(char*) mmap + src_offset +8,1656 extsize) <0)1657goto unmap;1658 src_offset +=8;1659 src_offset += extsize;1660}1661munmap(mmap, mmap_size);1662return istate->cache_nr;16631664unmap:1665munmap(mmap, mmap_size);1666die("index file corrupt");1667}16681669intread_index_from(struct index_state *istate,const char*path)1670{1671struct split_index *split_index;1672int ret;16731674/* istate->initialized covers both .git/index and .git/sharedindex.xxx */1675if(istate->initialized)1676return istate->cache_nr;16771678 ret =do_read_index(istate, path,0);16791680 split_index = istate->split_index;1681if(!split_index ||is_null_sha1(split_index->base_sha1)) {1682post_read_index_from(istate);1683return ret;1684}16851686if(split_index->base)1687discard_index(split_index->base);1688else1689 split_index->base =xcalloc(1,sizeof(*split_index->base));1690 ret =do_read_index(split_index->base,1691git_path("sharedindex.%s",1692sha1_to_hex(split_index->base_sha1)),1);1693if(hashcmp(split_index->base_sha1, split_index->base->sha1))1694die("broken index, expect%sin%s, got%s",1695sha1_to_hex(split_index->base_sha1),1696git_path("sharedindex.%s",1697sha1_to_hex(split_index->base_sha1)),1698sha1_to_hex(split_index->base->sha1));1699merge_base_index(istate);1700post_read_index_from(istate);1701return ret;1702}17031704intis_index_unborn(struct index_state *istate)1705{1706return(!istate->cache_nr && !istate->timestamp.sec);1707}17081709intdiscard_index(struct index_state *istate)1710{1711int i;17121713for(i =0; i < istate->cache_nr; i++) {1714if(istate->cache[i]->index &&1715 istate->split_index &&1716 istate->split_index->base &&1717 istate->cache[i]->index <= istate->split_index->base->cache_nr &&1718 istate->cache[i] == istate->split_index->base->cache[istate->cache[i]->index -1])1719continue;1720free(istate->cache[i]);1721}1722resolve_undo_clear_index(istate);1723 istate->cache_nr =0;1724 istate->cache_changed =0;1725 istate->timestamp.sec =0;1726 istate->timestamp.nsec =0;1727free_name_hash(istate);1728cache_tree_free(&(istate->cache_tree));1729 istate->initialized =0;1730free(istate->cache);1731 istate->cache = NULL;1732 istate->cache_alloc =0;1733discard_split_index(istate);1734free_untracked_cache(istate->untracked);1735 istate->untracked = NULL;1736return0;1737}17381739intunmerged_index(const struct index_state *istate)1740{1741int i;1742for(i =0; i < istate->cache_nr; i++) {1743if(ce_stage(istate->cache[i]))1744return1;1745}1746return0;1747}17481749#define WRITE_BUFFER_SIZE 81921750static unsigned char write_buffer[WRITE_BUFFER_SIZE];1751static unsigned long write_buffer_len;17521753static intce_write_flush(git_SHA_CTX *context,int fd)1754{1755unsigned int buffered = write_buffer_len;1756if(buffered) {1757git_SHA1_Update(context, write_buffer, buffered);1758if(write_in_full(fd, write_buffer, buffered) != buffered)1759return-1;1760 write_buffer_len =0;1761}1762return0;1763}17641765static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1766{1767while(len) {1768unsigned int buffered = write_buffer_len;1769unsigned int partial = WRITE_BUFFER_SIZE - buffered;1770if(partial > len)1771 partial = len;1772memcpy(write_buffer + buffered, data, partial);1773 buffered += partial;1774if(buffered == WRITE_BUFFER_SIZE) {1775 write_buffer_len = buffered;1776if(ce_write_flush(context, fd))1777return-1;1778 buffered =0;1779}1780 write_buffer_len = buffered;1781 len -= partial;1782 data = (char*) data + partial;1783}1784return0;1785}17861787static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1788unsigned int ext,unsigned int sz)1789{1790 ext =htonl(ext);1791 sz =htonl(sz);1792return((ce_write(context, fd, &ext,4) <0) ||1793(ce_write(context, fd, &sz,4) <0)) ? -1:0;1794}17951796static intce_flush(git_SHA_CTX *context,int fd,unsigned char*sha1)1797{1798unsigned int left = write_buffer_len;17991800if(left) {1801 write_buffer_len =0;1802git_SHA1_Update(context, write_buffer, left);1803}18041805/* Flush first if not enough space for SHA1 signature */1806if(left +20> WRITE_BUFFER_SIZE) {1807if(write_in_full(fd, write_buffer, left) != left)1808return-1;1809 left =0;1810}18111812/* Append the SHA1 signature at the end */1813git_SHA1_Final(write_buffer + left, context);1814hashcpy(sha1, write_buffer + left);1815 left +=20;1816return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1817}18181819static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1820{1821/*1822 * The only thing we care about in this function is to smudge the1823 * falsely clean entry due to touch-update-touch race, so we leave1824 * everything else as they are. We are called for entries whose1825 * ce_stat_data.sd_mtime match the index file mtime.1826 *1827 * Note that this actually does not do much for gitlinks, for1828 * which ce_match_stat_basic() always goes to the actual1829 * contents. The caller checks with is_racy_timestamp() which1830 * always says "no" for gitlinks, so we are not called for them ;-)1831 */1832struct stat st;18331834if(lstat(ce->name, &st) <0)1835return;1836if(ce_match_stat_basic(ce, &st))1837return;1838if(ce_modified_check_fs(ce, &st)) {1839/* This is "racily clean"; smudge it. Note that this1840 * is a tricky code. At first glance, it may appear1841 * that it can break with this sequence:1842 *1843 * $ echo xyzzy >frotz1844 * $ git-update-index --add frotz1845 * $ : >frotz1846 * $ sleep 31847 * $ echo filfre >nitfol1848 * $ git-update-index --add nitfol1849 *1850 * but it does not. When the second update-index runs,1851 * it notices that the entry "frotz" has the same timestamp1852 * as index, and if we were to smudge it by resetting its1853 * size to zero here, then the object name recorded1854 * in index is the 6-byte file but the cached stat information1855 * becomes zero --- which would then match what we would1856 * obtain from the filesystem next time we stat("frotz").1857 *1858 * However, the second update-index, before calling1859 * this function, notices that the cached size is 61860 * bytes and what is on the filesystem is an empty1861 * file, and never calls us, so the cached size information1862 * for "frotz" stays 6 which does not match the filesystem.1863 */1864 ce->ce_stat_data.sd_size =0;1865}1866}18671868/* Copy miscellaneous fields but not the name */1869static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1870struct cache_entry *ce)1871{1872short flags;18731874 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);1875 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);1876 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);1877 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);1878 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);1879 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);1880 ondisk->mode =htonl(ce->ce_mode);1881 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);1882 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);1883 ondisk->size =htonl(ce->ce_stat_data.sd_size);1884hashcpy(ondisk->sha1, ce->sha1);18851886 flags = ce->ce_flags & ~CE_NAMEMASK;1887 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1888 ondisk->flags =htons(flags);1889if(ce->ce_flags & CE_EXTENDED) {1890struct ondisk_cache_entry_extended *ondisk2;1891 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1892 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1893return ondisk2->name;1894}1895else{1896return ondisk->name;1897}1898}18991900static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1901struct strbuf *previous_name)1902{1903int size;1904struct ondisk_cache_entry *ondisk;1905int saved_namelen = saved_namelen;/* compiler workaround */1906char*name;1907int result;19081909if(ce->ce_flags & CE_STRIP_NAME) {1910 saved_namelen =ce_namelen(ce);1911 ce->ce_namelen =0;1912}19131914if(!previous_name) {1915 size =ondisk_ce_size(ce);1916 ondisk =xcalloc(1, size);1917 name =copy_cache_entry_to_ondisk(ondisk, ce);1918memcpy(name, ce->name,ce_namelen(ce));1919}else{1920int common, to_remove, prefix_size;1921unsigned char to_remove_vi[16];1922for(common =0;1923(ce->name[common] &&1924 common < previous_name->len &&1925 ce->name[common] == previous_name->buf[common]);1926 common++)1927;/* still matching */1928 to_remove = previous_name->len - common;1929 prefix_size =encode_varint(to_remove, to_remove_vi);19301931if(ce->ce_flags & CE_EXTENDED)1932 size =offsetof(struct ondisk_cache_entry_extended, name);1933else1934 size =offsetof(struct ondisk_cache_entry, name);1935 size += prefix_size + (ce_namelen(ce) - common +1);19361937 ondisk =xcalloc(1, size);1938 name =copy_cache_entry_to_ondisk(ondisk, ce);1939memcpy(name, to_remove_vi, prefix_size);1940memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);19411942strbuf_splice(previous_name, common, to_remove,1943 ce->name + common,ce_namelen(ce) - common);1944}1945if(ce->ce_flags & CE_STRIP_NAME) {1946 ce->ce_namelen = saved_namelen;1947 ce->ce_flags &= ~CE_STRIP_NAME;1948}19491950 result =ce_write(c, fd, ondisk, size);1951free(ondisk);1952return result;1953}19541955/*1956 * This function verifies if index_state has the correct sha1 of the1957 * index file. Don't die if we have any other failure, just return 0.1958 */1959static intverify_index_from(const struct index_state *istate,const char*path)1960{1961int fd;1962 ssize_t n;1963struct stat st;1964unsigned char sha1[20];19651966if(!istate->initialized)1967return0;19681969 fd =open(path, O_RDONLY);1970if(fd <0)1971return0;19721973if(fstat(fd, &st))1974goto out;19751976if(st.st_size <sizeof(struct cache_header) +20)1977goto out;19781979 n =pread_in_full(fd, sha1,20, st.st_size -20);1980if(n !=20)1981goto out;19821983if(hashcmp(istate->sha1, sha1))1984goto out;19851986close(fd);1987return1;19881989out:1990close(fd);1991return0;1992}19931994static intverify_index(const struct index_state *istate)1995{1996returnverify_index_from(istate,get_index_file());1997}19981999static inthas_racy_timestamp(struct index_state *istate)2000{2001int entries = istate->cache_nr;2002int i;20032004for(i =0; i < entries; i++) {2005struct cache_entry *ce = istate->cache[i];2006if(is_racy_timestamp(istate, ce))2007return1;2008}2009return0;2010}20112012/*2013 * Opportunistically update the index but do not complain if we can't2014 */2015voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)2016{2017if((istate->cache_changed ||has_racy_timestamp(istate)) &&2018verify_index(istate) &&2019write_locked_index(istate, lockfile, COMMIT_LOCK))2020rollback_lock_file(lockfile);2021}20222023static intdo_write_index(struct index_state *istate,int newfd,2024int strip_extensions)2025{2026 git_SHA_CTX c;2027struct cache_header hdr;2028int i, err, removed, extended, hdr_version;2029struct cache_entry **cache = istate->cache;2030int entries = istate->cache_nr;2031struct stat st;2032struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;20332034for(i = removed = extended =0; i < entries; i++) {2035if(cache[i]->ce_flags & CE_REMOVE)2036 removed++;20372038/* reduce extended entries if possible */2039 cache[i]->ce_flags &= ~CE_EXTENDED;2040if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {2041 extended++;2042 cache[i]->ce_flags |= CE_EXTENDED;2043}2044}20452046if(!istate->version) {2047 istate->version =get_index_format_default();2048if(getenv("GIT_TEST_SPLIT_INDEX"))2049init_split_index(istate);2050}20512052/* demote version 3 to version 2 when the latter suffices */2053if(istate->version ==3|| istate->version ==2)2054 istate->version = extended ?3:2;20552056 hdr_version = istate->version;20572058 hdr.hdr_signature =htonl(CACHE_SIGNATURE);2059 hdr.hdr_version =htonl(hdr_version);2060 hdr.hdr_entries =htonl(entries - removed);20612062git_SHA1_Init(&c);2063if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)2064return-1;20652066 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;2067for(i =0; i < entries; i++) {2068struct cache_entry *ce = cache[i];2069if(ce->ce_flags & CE_REMOVE)2070continue;2071if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))2072ce_smudge_racily_clean_entry(ce);2073if(is_null_sha1(ce->sha1)) {2074static const char msg[] ="cache entry has null sha1:%s";2075static int allow = -1;20762077if(allow <0)2078 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);2079if(allow)2080warning(msg, ce->name);2081else2082returnerror(msg, ce->name);2083}2084if(ce_write_entry(&c, newfd, ce, previous_name) <0)2085return-1;2086}2087strbuf_release(&previous_name_buf);20882089/* Write extension data here */2090if(!strip_extensions && istate->split_index) {2091struct strbuf sb = STRBUF_INIT;20922093 err =write_link_extension(&sb, istate) <0||2094write_index_ext_header(&c, newfd, CACHE_EXT_LINK,2095 sb.len) <0||2096ce_write(&c, newfd, sb.buf, sb.len) <0;2097strbuf_release(&sb);2098if(err)2099return-1;2100}2101if(!strip_extensions && istate->cache_tree) {2102struct strbuf sb = STRBUF_INIT;21032104cache_tree_write(&sb, istate->cache_tree);2105 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <02106||ce_write(&c, newfd, sb.buf, sb.len) <0;2107strbuf_release(&sb);2108if(err)2109return-1;2110}2111if(!strip_extensions && istate->resolve_undo) {2112struct strbuf sb = STRBUF_INIT;21132114resolve_undo_write(&sb, istate->resolve_undo);2115 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,2116 sb.len) <02117||ce_write(&c, newfd, sb.buf, sb.len) <0;2118strbuf_release(&sb);2119if(err)2120return-1;2121}2122if(!strip_extensions && istate->untracked) {2123struct strbuf sb = STRBUF_INIT;21242125write_untracked_extension(&sb, istate->untracked);2126 err =write_index_ext_header(&c, newfd, CACHE_EXT_UNTRACKED,2127 sb.len) <0||2128ce_write(&c, newfd, sb.buf, sb.len) <0;2129strbuf_release(&sb);2130if(err)2131return-1;2132}21332134if(ce_flush(&c, newfd, istate->sha1) ||fstat(newfd, &st))2135return-1;2136 istate->timestamp.sec = (unsigned int)st.st_mtime;2137 istate->timestamp.nsec =ST_MTIME_NSEC(st);2138return0;2139}21402141voidset_alternate_index_output(const char*name)2142{2143 alternate_index_output = name;2144}21452146static intcommit_locked_index(struct lock_file *lk)2147{2148if(alternate_index_output)2149returncommit_lock_file_to(lk, alternate_index_output);2150else2151returncommit_lock_file(lk);2152}21532154static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,2155unsigned flags)2156{2157int ret =do_write_index(istate,get_lock_file_fd(lock),0);2158if(ret)2159return ret;2160assert((flags & (COMMIT_LOCK | CLOSE_LOCK)) !=2161(COMMIT_LOCK | CLOSE_LOCK));2162if(flags & COMMIT_LOCK)2163returncommit_locked_index(lock);2164else if(flags & CLOSE_LOCK)2165returnclose_lock_file(lock);2166else2167return ret;2168}21692170static intwrite_split_index(struct index_state *istate,2171struct lock_file *lock,2172unsigned flags)2173{2174int ret;2175prepare_to_write_split_index(istate);2176 ret =do_write_locked_index(istate, lock, flags);2177finish_writing_split_index(istate);2178return ret;2179}21802181static struct tempfile temporary_sharedindex;21822183static intwrite_shared_index(struct index_state *istate,2184struct lock_file *lock,unsigned flags)2185{2186struct split_index *si = istate->split_index;2187int fd, ret;21882189 fd =mks_tempfile(&temporary_sharedindex,git_path("sharedindex_XXXXXX"));2190if(fd <0) {2191hashclr(si->base_sha1);2192returndo_write_locked_index(istate, lock, flags);2193}2194move_cache_to_base_index(istate);2195 ret =do_write_index(si->base, fd,1);2196if(ret) {2197delete_tempfile(&temporary_sharedindex);2198return ret;2199}2200 ret =rename_tempfile(&temporary_sharedindex,2201git_path("sharedindex.%s",sha1_to_hex(si->base->sha1)));2202if(!ret)2203hashcpy(si->base_sha1, si->base->sha1);2204return ret;2205}22062207intwrite_locked_index(struct index_state *istate,struct lock_file *lock,2208unsigned flags)2209{2210struct split_index *si = istate->split_index;22112212if(!si || alternate_index_output ||2213(istate->cache_changed & ~EXTMASK)) {2214if(si)2215hashclr(si->base_sha1);2216returndo_write_locked_index(istate, lock, flags);2217}22182219if(getenv("GIT_TEST_SPLIT_INDEX")) {2220int v = si->base_sha1[0];2221if((v &15) <6)2222 istate->cache_changed |= SPLIT_INDEX_ORDERED;2223}2224if(istate->cache_changed & SPLIT_INDEX_ORDERED) {2225int ret =write_shared_index(istate, lock, flags);2226if(ret)2227return ret;2228}22292230returnwrite_split_index(istate, lock, flags);2231}22322233/*2234 * Read the index file that is potentially unmerged into given2235 * index_state, dropping any unmerged entries. Returns true if2236 * the index is unmerged. Callers who want to refuse to work2237 * from an unmerged state can call this and check its return value,2238 * instead of calling read_cache().2239 */2240intread_index_unmerged(struct index_state *istate)2241{2242int i;2243int unmerged =0;22442245read_index(istate);2246for(i =0; i < istate->cache_nr; i++) {2247struct cache_entry *ce = istate->cache[i];2248struct cache_entry *new_ce;2249int size, len;22502251if(!ce_stage(ce))2252continue;2253 unmerged =1;2254 len =ce_namelen(ce);2255 size =cache_entry_size(len);2256 new_ce =xcalloc(1, size);2257memcpy(new_ce->name, ce->name, len);2258 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;2259 new_ce->ce_namelen = len;2260 new_ce->ce_mode = ce->ce_mode;2261if(add_index_entry(istate, new_ce,0))2262returnerror("%s: cannot drop to stage #0",2263 new_ce->name);2264}2265return unmerged;2266}22672268/*2269 * Returns 1 if the path is an "other" path with respect to2270 * the index; that is, the path is not mentioned in the index at all,2271 * either as a file, a directory with some files in the index,2272 * or as an unmerged entry.2273 *2274 * We helpfully remove a trailing "/" from directories so that2275 * the output of read_directory can be used as-is.2276 */2277intindex_name_is_other(const struct index_state *istate,const char*name,2278int namelen)2279{2280int pos;2281if(namelen && name[namelen -1] =='/')2282 namelen--;2283 pos =index_name_pos(istate, name, namelen);2284if(0<= pos)2285return0;/* exact match */2286 pos = -pos -1;2287if(pos < istate->cache_nr) {2288struct cache_entry *ce = istate->cache[pos];2289if(ce_namelen(ce) == namelen &&2290!memcmp(ce->name, name, namelen))2291return0;/* Yup, this one exists unmerged */2292}2293return1;2294}22952296void*read_blob_data_from_index(struct index_state *istate,const char*path,unsigned long*size)2297{2298int pos, len;2299unsigned long sz;2300enum object_type type;2301void*data;23022303 len =strlen(path);2304 pos =index_name_pos(istate, path, len);2305if(pos <0) {2306/*2307 * We might be in the middle of a merge, in which2308 * case we would read stage #2 (ours).2309 */2310int i;2311for(i = -pos -1;2312(pos <0&& i < istate->cache_nr &&2313!strcmp(istate->cache[i]->name, path));2314 i++)2315if(ce_stage(istate->cache[i]) ==2)2316 pos = i;2317}2318if(pos <0)2319return NULL;2320 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz);2321if(!data || type != OBJ_BLOB) {2322free(data);2323return NULL;2324}2325if(size)2326*size = sz;2327return data;2328}23292330voidstat_validity_clear(struct stat_validity *sv)2331{2332free(sv->sd);2333 sv->sd = NULL;2334}23352336intstat_validity_check(struct stat_validity *sv,const char*path)2337{2338struct stat st;23392340if(stat(path, &st) <0)2341return sv->sd == NULL;2342if(!sv->sd)2343return0;2344returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2345}23462347voidstat_validity_update(struct stat_validity *sv,int fd)2348{2349struct stat st;23502351if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2352stat_validity_clear(sv);2353else{2354if(!sv->sd)2355 sv->sd =xcalloc(1,sizeof(struct stat_data));2356fill_stat_data(sv->sd, &st);2357}2358}