1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#define NO_THE_INDEX_COMPATIBILITY_MACROS 7#include"cache.h" 8#include"cache-tree.h" 9#include"refs.h" 10#include"dir.h" 11#include"tree.h" 12#include"commit.h" 13#include"blob.h" 14#include"resolve-undo.h" 15#include"strbuf.h" 16#include"varint.h" 17 18static struct cache_entry *refresh_cache_entry(struct cache_entry *ce, 19unsigned int options); 20 21/* Mask for the name length in ce_flags in the on-disk index */ 22 23#define CE_NAMEMASK (0x0fff) 24 25/* Index extensions. 26 * 27 * The first letter should be 'A'..'Z' for extensions that are not 28 * necessary for a correct operation (i.e. optimization data). 29 * When new extensions are added that _needs_ to be understood in 30 * order to correctly interpret the index file, pick character that 31 * is outside the range, to cause the reader to abort. 32 */ 33 34#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 35#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 36#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 37 38struct index_state the_index; 39static const char*alternate_index_output; 40 41static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 42{ 43 istate->cache[nr] = ce; 44add_name_hash(istate, ce); 45} 46 47static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 48{ 49struct cache_entry *old = istate->cache[nr]; 50 51remove_name_hash(istate, old); 52free(old); 53set_index_entry(istate, nr, ce); 54 istate->cache_changed =1; 55} 56 57voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 58{ 59struct cache_entry *old = istate->cache[nr], *new; 60int namelen =strlen(new_name); 61 62new=xmalloc(cache_entry_size(namelen)); 63copy_cache_entry(new, old); 64new->ce_flags &= ~CE_HASHED; 65new->ce_namelen = namelen; 66memcpy(new->name, new_name, namelen +1); 67 68cache_tree_invalidate_path(istate->cache_tree, old->name); 69remove_index_entry_at(istate, nr); 70add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 71} 72 73voidfill_stat_data(struct stat_data *sd,struct stat *st) 74{ 75 sd->sd_ctime.sec = (unsigned int)st->st_ctime; 76 sd->sd_mtime.sec = (unsigned int)st->st_mtime; 77 sd->sd_ctime.nsec =ST_CTIME_NSEC(*st); 78 sd->sd_mtime.nsec =ST_MTIME_NSEC(*st); 79 sd->sd_dev = st->st_dev; 80 sd->sd_ino = st->st_ino; 81 sd->sd_uid = st->st_uid; 82 sd->sd_gid = st->st_gid; 83 sd->sd_size = st->st_size; 84} 85 86intmatch_stat_data(const struct stat_data *sd,struct stat *st) 87{ 88int changed =0; 89 90if(sd->sd_mtime.sec != (unsigned int)st->st_mtime) 91 changed |= MTIME_CHANGED; 92if(trust_ctime && check_stat && 93 sd->sd_ctime.sec != (unsigned int)st->st_ctime) 94 changed |= CTIME_CHANGED; 95 96#ifdef USE_NSEC 97if(check_stat && sd->sd_mtime.nsec !=ST_MTIME_NSEC(*st)) 98 changed |= MTIME_CHANGED; 99if(trust_ctime && check_stat && 100 sd->sd_ctime.nsec !=ST_CTIME_NSEC(*st)) 101 changed |= CTIME_CHANGED; 102#endif 103 104if(check_stat) { 105if(sd->sd_uid != (unsigned int) st->st_uid || 106 sd->sd_gid != (unsigned int) st->st_gid) 107 changed |= OWNER_CHANGED; 108if(sd->sd_ino != (unsigned int) st->st_ino) 109 changed |= INODE_CHANGED; 110} 111 112#ifdef USE_STDEV 113/* 114 * st_dev breaks on network filesystems where different 115 * clients will have different views of what "device" 116 * the filesystem is on 117 */ 118if(check_stat && sd->sd_dev != (unsigned int) st->st_dev) 119 changed |= INODE_CHANGED; 120#endif 121 122if(sd->sd_size != (unsigned int) st->st_size) 123 changed |= DATA_CHANGED; 124 125return changed; 126} 127 128/* 129 * This only updates the "non-critical" parts of the directory 130 * cache, ie the parts that aren't tracked by GIT, and only used 131 * to validate the cache. 132 */ 133voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 134{ 135fill_stat_data(&ce->ce_stat_data, st); 136 137if(assume_unchanged) 138 ce->ce_flags |= CE_VALID; 139 140if(S_ISREG(st->st_mode)) 141ce_mark_uptodate(ce); 142} 143 144static intce_compare_data(const struct cache_entry *ce,struct stat *st) 145{ 146int match = -1; 147int fd =open(ce->name, O_RDONLY); 148 149if(fd >=0) { 150unsigned char sha1[20]; 151if(!index_fd(sha1, fd, st, OBJ_BLOB, ce->name,0)) 152 match =hashcmp(sha1, ce->sha1); 153/* index_fd() closed the file descriptor already */ 154} 155return match; 156} 157 158static intce_compare_link(const struct cache_entry *ce,size_t expected_size) 159{ 160int match = -1; 161void*buffer; 162unsigned long size; 163enum object_type type; 164struct strbuf sb = STRBUF_INIT; 165 166if(strbuf_readlink(&sb, ce->name, expected_size)) 167return-1; 168 169 buffer =read_sha1_file(ce->sha1, &type, &size); 170if(buffer) { 171if(size == sb.len) 172 match =memcmp(buffer, sb.buf, size); 173free(buffer); 174} 175strbuf_release(&sb); 176return match; 177} 178 179static intce_compare_gitlink(const struct cache_entry *ce) 180{ 181unsigned char sha1[20]; 182 183/* 184 * We don't actually require that the .git directory 185 * under GITLINK directory be a valid git directory. It 186 * might even be missing (in case nobody populated that 187 * sub-project). 188 * 189 * If so, we consider it always to match. 190 */ 191if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 192return0; 193returnhashcmp(sha1, ce->sha1); 194} 195 196static intce_modified_check_fs(const struct cache_entry *ce,struct stat *st) 197{ 198switch(st->st_mode & S_IFMT) { 199case S_IFREG: 200if(ce_compare_data(ce, st)) 201return DATA_CHANGED; 202break; 203case S_IFLNK: 204if(ce_compare_link(ce,xsize_t(st->st_size))) 205return DATA_CHANGED; 206break; 207case S_IFDIR: 208if(S_ISGITLINK(ce->ce_mode)) 209returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 210default: 211return TYPE_CHANGED; 212} 213return0; 214} 215 216static intce_match_stat_basic(const struct cache_entry *ce,struct stat *st) 217{ 218unsigned int changed =0; 219 220if(ce->ce_flags & CE_REMOVE) 221return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 222 223switch(ce->ce_mode & S_IFMT) { 224case S_IFREG: 225 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 226/* We consider only the owner x bit to be relevant for 227 * "mode changes" 228 */ 229if(trust_executable_bit && 230(0100& (ce->ce_mode ^ st->st_mode))) 231 changed |= MODE_CHANGED; 232break; 233case S_IFLNK: 234if(!S_ISLNK(st->st_mode) && 235(has_symlinks || !S_ISREG(st->st_mode))) 236 changed |= TYPE_CHANGED; 237break; 238case S_IFGITLINK: 239/* We ignore most of the st_xxx fields for gitlinks */ 240if(!S_ISDIR(st->st_mode)) 241 changed |= TYPE_CHANGED; 242else if(ce_compare_gitlink(ce)) 243 changed |= DATA_CHANGED; 244return changed; 245default: 246die("internal error: ce_mode is%o", ce->ce_mode); 247} 248 249 changed |=match_stat_data(&ce->ce_stat_data, st); 250 251/* Racily smudged entry? */ 252if(!ce->ce_stat_data.sd_size) { 253if(!is_empty_blob_sha1(ce->sha1)) 254 changed |= DATA_CHANGED; 255} 256 257return changed; 258} 259 260static intis_racy_timestamp(const struct index_state *istate, 261const struct cache_entry *ce) 262{ 263return(!S_ISGITLINK(ce->ce_mode) && 264 istate->timestamp.sec && 265#ifdef USE_NSEC 266/* nanosecond timestamped files can also be racy! */ 267(istate->timestamp.sec < ce->ce_stat_data.sd_mtime.sec || 268(istate->timestamp.sec == ce->ce_stat_data.sd_mtime.sec && 269 istate->timestamp.nsec <= ce->ce_stat_data.sd_mtime.nsec)) 270#else 271 istate->timestamp.sec <= ce->ce_stat_data.sd_mtime.sec 272#endif 273); 274} 275 276intie_match_stat(const struct index_state *istate, 277const struct cache_entry *ce,struct stat *st, 278unsigned int options) 279{ 280unsigned int changed; 281int ignore_valid = options & CE_MATCH_IGNORE_VALID; 282int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 283int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 284 285/* 286 * If it's marked as always valid in the index, it's 287 * valid whatever the checked-out copy says. 288 * 289 * skip-worktree has the same effect with higher precedence 290 */ 291if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 292return0; 293if(!ignore_valid && (ce->ce_flags & CE_VALID)) 294return0; 295 296/* 297 * Intent-to-add entries have not been added, so the index entry 298 * by definition never matches what is in the work tree until it 299 * actually gets added. 300 */ 301if(ce->ce_flags & CE_INTENT_TO_ADD) 302return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 303 304 changed =ce_match_stat_basic(ce, st); 305 306/* 307 * Within 1 second of this sequence: 308 * echo xyzzy >file && git-update-index --add file 309 * running this command: 310 * echo frotz >file 311 * would give a falsely clean cache entry. The mtime and 312 * length match the cache, and other stat fields do not change. 313 * 314 * We could detect this at update-index time (the cache entry 315 * being registered/updated records the same time as "now") 316 * and delay the return from git-update-index, but that would 317 * effectively mean we can make at most one commit per second, 318 * which is not acceptable. Instead, we check cache entries 319 * whose mtime are the same as the index file timestamp more 320 * carefully than others. 321 */ 322if(!changed &&is_racy_timestamp(istate, ce)) { 323if(assume_racy_is_modified) 324 changed |= DATA_CHANGED; 325else 326 changed |=ce_modified_check_fs(ce, st); 327} 328 329return changed; 330} 331 332intie_modified(const struct index_state *istate, 333const struct cache_entry *ce, 334struct stat *st,unsigned int options) 335{ 336int changed, changed_fs; 337 338 changed =ie_match_stat(istate, ce, st, options); 339if(!changed) 340return0; 341/* 342 * If the mode or type has changed, there's no point in trying 343 * to refresh the entry - it's not going to match 344 */ 345if(changed & (MODE_CHANGED | TYPE_CHANGED)) 346return changed; 347 348/* 349 * Immediately after read-tree or update-index --cacheinfo, 350 * the length field is zero, as we have never even read the 351 * lstat(2) information once, and we cannot trust DATA_CHANGED 352 * returned by ie_match_stat() which in turn was returned by 353 * ce_match_stat_basic() to signal that the filesize of the 354 * blob changed. We have to actually go to the filesystem to 355 * see if the contents match, and if so, should answer "unchanged". 356 * 357 * The logic does not apply to gitlinks, as ce_match_stat_basic() 358 * already has checked the actual HEAD from the filesystem in the 359 * subproject. If ie_match_stat() already said it is different, 360 * then we know it is. 361 */ 362if((changed & DATA_CHANGED) && 363(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size !=0)) 364return changed; 365 366 changed_fs =ce_modified_check_fs(ce, st); 367if(changed_fs) 368return changed | changed_fs; 369return0; 370} 371 372intbase_name_compare(const char*name1,int len1,int mode1, 373const char*name2,int len2,int mode2) 374{ 375unsigned char c1, c2; 376int len = len1 < len2 ? len1 : len2; 377int cmp; 378 379 cmp =memcmp(name1, name2, len); 380if(cmp) 381return cmp; 382 c1 = name1[len]; 383 c2 = name2[len]; 384if(!c1 &&S_ISDIR(mode1)) 385 c1 ='/'; 386if(!c2 &&S_ISDIR(mode2)) 387 c2 ='/'; 388return(c1 < c2) ? -1: (c1 > c2) ?1:0; 389} 390 391/* 392 * df_name_compare() is identical to base_name_compare(), except it 393 * compares conflicting directory/file entries as equal. Note that 394 * while a directory name compares as equal to a regular file, they 395 * then individually compare _differently_ to a filename that has 396 * a dot after the basename (because '\0' < '.' < '/'). 397 * 398 * This is used by routines that want to traverse the git namespace 399 * but then handle conflicting entries together when possible. 400 */ 401intdf_name_compare(const char*name1,int len1,int mode1, 402const char*name2,int len2,int mode2) 403{ 404int len = len1 < len2 ? len1 : len2, cmp; 405unsigned char c1, c2; 406 407 cmp =memcmp(name1, name2, len); 408if(cmp) 409return cmp; 410/* Directories and files compare equal (same length, same name) */ 411if(len1 == len2) 412return0; 413 c1 = name1[len]; 414if(!c1 &&S_ISDIR(mode1)) 415 c1 ='/'; 416 c2 = name2[len]; 417if(!c2 &&S_ISDIR(mode2)) 418 c2 ='/'; 419if(c1 =='/'&& !c2) 420return0; 421if(c2 =='/'&& !c1) 422return0; 423return c1 - c2; 424} 425 426intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 427{ 428int len = len1 < len2 ? len1 : len2; 429int cmp; 430 431 cmp =memcmp(name1, name2, len); 432if(cmp) 433return cmp; 434if(len1 < len2) 435return-1; 436if(len1 > len2) 437return1; 438 439if(stage1 < stage2) 440return-1; 441if(stage1 > stage2) 442return1; 443return0; 444} 445 446intcache_name_compare(const char*name1,int len1,const char*name2,int len2) 447{ 448returncache_name_stage_compare(name1, len1,0, name2, len2,0); 449} 450 451static intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 452{ 453int first, last; 454 455 first =0; 456 last = istate->cache_nr; 457while(last > first) { 458int next = (last + first) >>1; 459struct cache_entry *ce = istate->cache[next]; 460int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 461if(!cmp) 462return next; 463if(cmp <0) { 464 last = next; 465continue; 466} 467 first = next+1; 468} 469return-first-1; 470} 471 472intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 473{ 474returnindex_name_stage_pos(istate, name, namelen,0); 475} 476 477/* Remove entry, return true if there are more entries to go.. */ 478intremove_index_entry_at(struct index_state *istate,int pos) 479{ 480struct cache_entry *ce = istate->cache[pos]; 481 482record_resolve_undo(istate, ce); 483remove_name_hash(istate, ce); 484free(ce); 485 istate->cache_changed =1; 486 istate->cache_nr--; 487if(pos >= istate->cache_nr) 488return0; 489memmove(istate->cache + pos, 490 istate->cache + pos +1, 491(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 492return1; 493} 494 495/* 496 * Remove all cache entries marked for removal, that is where 497 * CE_REMOVE is set in ce_flags. This is much more effective than 498 * calling remove_index_entry_at() for each entry to be removed. 499 */ 500voidremove_marked_cache_entries(struct index_state *istate) 501{ 502struct cache_entry **ce_array = istate->cache; 503unsigned int i, j; 504 505for(i = j =0; i < istate->cache_nr; i++) { 506if(ce_array[i]->ce_flags & CE_REMOVE) { 507remove_name_hash(istate, ce_array[i]); 508free(ce_array[i]); 509} 510else 511 ce_array[j++] = ce_array[i]; 512} 513 istate->cache_changed =1; 514 istate->cache_nr = j; 515} 516 517intremove_file_from_index(struct index_state *istate,const char*path) 518{ 519int pos =index_name_pos(istate, path,strlen(path)); 520if(pos <0) 521 pos = -pos-1; 522cache_tree_invalidate_path(istate->cache_tree, path); 523while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 524remove_index_entry_at(istate, pos); 525return0; 526} 527 528static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 529{ 530return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 531} 532 533static intindex_name_pos_also_unmerged(struct index_state *istate, 534const char*path,int namelen) 535{ 536int pos =index_name_pos(istate, path, namelen); 537struct cache_entry *ce; 538 539if(pos >=0) 540return pos; 541 542/* maybe unmerged? */ 543 pos = -1- pos; 544if(pos >= istate->cache_nr || 545compare_name((ce = istate->cache[pos]), path, namelen)) 546return-1; 547 548/* order of preference: stage 2, 1, 3 */ 549if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 550ce_stage((ce = istate->cache[pos +1])) ==2&& 551!compare_name(ce, path, namelen)) 552 pos++; 553return pos; 554} 555 556static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 557{ 558int len =ce_namelen(ce); 559returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 560} 561 562/* 563 * If we add a filename that aliases in the cache, we will use the 564 * name that we already have - but we don't want to update the same 565 * alias twice, because that implies that there were actually two 566 * different files with aliasing names! 567 * 568 * So we use the CE_ADDED flag to verify that the alias was an old 569 * one before we accept it as 570 */ 571static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 572{ 573int len; 574struct cache_entry *new; 575 576if(alias->ce_flags & CE_ADDED) 577die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 578 579/* Ok, create the new entry using the name of the existing alias */ 580 len =ce_namelen(alias); 581new=xcalloc(1,cache_entry_size(len)); 582memcpy(new->name, alias->name, len); 583copy_cache_entry(new, ce); 584free(ce); 585return new; 586} 587 588voidset_object_name_for_intent_to_add_entry(struct cache_entry *ce) 589{ 590unsigned char sha1[20]; 591if(write_sha1_file("",0, blob_type, sha1)) 592die("cannot create an empty blob in the object database"); 593hashcpy(ce->sha1, sha1); 594} 595 596intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 597{ 598int size, namelen, was_same; 599 mode_t st_mode = st->st_mode; 600struct cache_entry *ce, *alias; 601unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 602int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 603int pretend = flags & ADD_CACHE_PRETEND; 604int intent_only = flags & ADD_CACHE_INTENT; 605int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 606(intent_only ? ADD_CACHE_NEW_ONLY :0)); 607 608if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 609returnerror("%s: can only add regular files, symbolic links or git-directories", path); 610 611 namelen =strlen(path); 612if(S_ISDIR(st_mode)) { 613while(namelen && path[namelen-1] =='/') 614 namelen--; 615} 616 size =cache_entry_size(namelen); 617 ce =xcalloc(1, size); 618memcpy(ce->name, path, namelen); 619 ce->ce_namelen = namelen; 620if(!intent_only) 621fill_stat_cache_info(ce, st); 622else 623 ce->ce_flags |= CE_INTENT_TO_ADD; 624 625if(trust_executable_bit && has_symlinks) 626 ce->ce_mode =create_ce_mode(st_mode); 627else{ 628/* If there is an existing entry, pick the mode bits and type 629 * from it, otherwise assume unexecutable regular file. 630 */ 631struct cache_entry *ent; 632int pos =index_name_pos_also_unmerged(istate, path, namelen); 633 634 ent = (0<= pos) ? istate->cache[pos] : NULL; 635 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 636} 637 638/* When core.ignorecase=true, determine if a directory of the same name but differing 639 * case already exists within the Git repository. If it does, ensure the directory 640 * case of the file being added to the repository matches (is folded into) the existing 641 * entry's directory case. 642 */ 643if(ignore_case) { 644const char*startPtr = ce->name; 645const char*ptr = startPtr; 646while(*ptr) { 647while(*ptr && *ptr !='/') 648++ptr; 649if(*ptr =='/') { 650struct cache_entry *foundce; 651++ptr; 652 foundce =index_dir_exists(istate, ce->name, ptr - ce->name -1); 653if(foundce) { 654memcpy((void*)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr); 655 startPtr = ptr; 656} 657} 658} 659} 660 661 alias =index_file_exists(istate, ce->name,ce_namelen(ce), ignore_case); 662if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 663/* Nothing changed, really */ 664free(ce); 665if(!S_ISGITLINK(alias->ce_mode)) 666ce_mark_uptodate(alias); 667 alias->ce_flags |= CE_ADDED; 668return0; 669} 670if(!intent_only) { 671if(index_path(ce->sha1, path, st, HASH_WRITE_OBJECT)) 672returnerror("unable to index file%s", path); 673}else 674set_object_name_for_intent_to_add_entry(ce); 675 676if(ignore_case && alias &&different_name(ce, alias)) 677 ce =create_alias_ce(ce, alias); 678 ce->ce_flags |= CE_ADDED; 679 680/* It was suspected to be racily clean, but it turns out to be Ok */ 681 was_same = (alias && 682!ce_stage(alias) && 683!hashcmp(alias->sha1, ce->sha1) && 684 ce->ce_mode == alias->ce_mode); 685 686if(pretend) 687; 688else if(add_index_entry(istate, ce, add_option)) 689returnerror("unable to add%sto index",path); 690if(verbose && !was_same) 691printf("add '%s'\n", path); 692return0; 693} 694 695intadd_file_to_index(struct index_state *istate,const char*path,int flags) 696{ 697struct stat st; 698if(lstat(path, &st)) 699die_errno("unable to stat '%s'", path); 700returnadd_to_index(istate, path, &st, flags); 701} 702 703struct cache_entry *make_cache_entry(unsigned int mode, 704const unsigned char*sha1,const char*path,int stage, 705unsigned int refresh_options) 706{ 707int size, len; 708struct cache_entry *ce; 709 710if(!verify_path(path)) { 711error("Invalid path '%s'", path); 712return NULL; 713} 714 715 len =strlen(path); 716 size =cache_entry_size(len); 717 ce =xcalloc(1, size); 718 719hashcpy(ce->sha1, sha1); 720memcpy(ce->name, path, len); 721 ce->ce_flags =create_ce_flags(stage); 722 ce->ce_namelen = len; 723 ce->ce_mode =create_ce_mode(mode); 724 725returnrefresh_cache_entry(ce, refresh_options); 726} 727 728intce_same_name(const struct cache_entry *a,const struct cache_entry *b) 729{ 730int len =ce_namelen(a); 731returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 732} 733 734/* 735 * We fundamentally don't like some paths: we don't want 736 * dot or dot-dot anywhere, and for obvious reasons don't 737 * want to recurse into ".git" either. 738 * 739 * Also, we don't want double slashes or slashes at the 740 * end that can make pathnames ambiguous. 741 */ 742static intverify_dotfile(const char*rest) 743{ 744/* 745 * The first character was '.', but that 746 * has already been discarded, we now test 747 * the rest. 748 */ 749 750/* "." is not allowed */ 751if(*rest =='\0'||is_dir_sep(*rest)) 752return0; 753 754switch(*rest) { 755/* 756 * ".git" followed by NUL or slash is bad. This 757 * shares the path end test with the ".." case. 758 */ 759case'g': 760if(rest[1] !='i') 761break; 762if(rest[2] !='t') 763break; 764 rest +=2; 765/* fallthrough */ 766case'.': 767if(rest[1] =='\0'||is_dir_sep(rest[1])) 768return0; 769} 770return1; 771} 772 773intverify_path(const char*path) 774{ 775char c; 776 777if(has_dos_drive_prefix(path)) 778return0; 779 780goto inside; 781for(;;) { 782if(!c) 783return1; 784if(is_dir_sep(c)) { 785inside: 786 c = *path++; 787if((c =='.'&& !verify_dotfile(path)) || 788is_dir_sep(c) || c =='\0') 789return0; 790} 791 c = *path++; 792} 793} 794 795/* 796 * Do we have another file that has the beginning components being a 797 * proper superset of the name we're trying to add? 798 */ 799static inthas_file_name(struct index_state *istate, 800const struct cache_entry *ce,int pos,int ok_to_replace) 801{ 802int retval =0; 803int len =ce_namelen(ce); 804int stage =ce_stage(ce); 805const char*name = ce->name; 806 807while(pos < istate->cache_nr) { 808struct cache_entry *p = istate->cache[pos++]; 809 810if(len >=ce_namelen(p)) 811break; 812if(memcmp(name, p->name, len)) 813break; 814if(ce_stage(p) != stage) 815continue; 816if(p->name[len] !='/') 817continue; 818if(p->ce_flags & CE_REMOVE) 819continue; 820 retval = -1; 821if(!ok_to_replace) 822break; 823remove_index_entry_at(istate, --pos); 824} 825return retval; 826} 827 828/* 829 * Do we have another file with a pathname that is a proper 830 * subset of the name we're trying to add? 831 */ 832static inthas_dir_name(struct index_state *istate, 833const struct cache_entry *ce,int pos,int ok_to_replace) 834{ 835int retval =0; 836int stage =ce_stage(ce); 837const char*name = ce->name; 838const char*slash = name +ce_namelen(ce); 839 840for(;;) { 841int len; 842 843for(;;) { 844if(*--slash =='/') 845break; 846if(slash <= ce->name) 847return retval; 848} 849 len = slash - name; 850 851 pos =index_name_stage_pos(istate, name, len, stage); 852if(pos >=0) { 853/* 854 * Found one, but not so fast. This could 855 * be a marker that says "I was here, but 856 * I am being removed". Such an entry is 857 * not a part of the resulting tree, and 858 * it is Ok to have a directory at the same 859 * path. 860 */ 861if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 862 retval = -1; 863if(!ok_to_replace) 864break; 865remove_index_entry_at(istate, pos); 866continue; 867} 868} 869else 870 pos = -pos-1; 871 872/* 873 * Trivial optimization: if we find an entry that 874 * already matches the sub-directory, then we know 875 * we're ok, and we can exit. 876 */ 877while(pos < istate->cache_nr) { 878struct cache_entry *p = istate->cache[pos]; 879if((ce_namelen(p) <= len) || 880(p->name[len] !='/') || 881memcmp(p->name, name, len)) 882break;/* not our subdirectory */ 883if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 884/* 885 * p is at the same stage as our entry, and 886 * is a subdirectory of what we are looking 887 * at, so we cannot have conflicts at our 888 * level or anything shorter. 889 */ 890return retval; 891 pos++; 892} 893} 894return retval; 895} 896 897/* We may be in a situation where we already have path/file and path 898 * is being added, or we already have path and path/file is being 899 * added. Either one would result in a nonsense tree that has path 900 * twice when git-write-tree tries to write it out. Prevent it. 901 * 902 * If ok-to-replace is specified, we remove the conflicting entries 903 * from the cache so the caller should recompute the insert position. 904 * When this happens, we return non-zero. 905 */ 906static intcheck_file_directory_conflict(struct index_state *istate, 907const struct cache_entry *ce, 908int pos,int ok_to_replace) 909{ 910int retval; 911 912/* 913 * When ce is an "I am going away" entry, we allow it to be added 914 */ 915if(ce->ce_flags & CE_REMOVE) 916return0; 917 918/* 919 * We check if the path is a sub-path of a subsequent pathname 920 * first, since removing those will not change the position 921 * in the array. 922 */ 923 retval =has_file_name(istate, ce, pos, ok_to_replace); 924 925/* 926 * Then check if the path might have a clashing sub-directory 927 * before it. 928 */ 929return retval +has_dir_name(istate, ce, pos, ok_to_replace); 930} 931 932static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 933{ 934int pos; 935int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 936int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 937int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 938int new_only = option & ADD_CACHE_NEW_ONLY; 939 940cache_tree_invalidate_path(istate->cache_tree, ce->name); 941 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 942 943/* existing match? Just replace it. */ 944if(pos >=0) { 945if(!new_only) 946replace_index_entry(istate, pos, ce); 947return0; 948} 949 pos = -pos-1; 950 951/* 952 * Inserting a merged entry ("stage 0") into the index 953 * will always replace all non-merged entries.. 954 */ 955if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 956while(ce_same_name(istate->cache[pos], ce)) { 957 ok_to_add =1; 958if(!remove_index_entry_at(istate, pos)) 959break; 960} 961} 962 963if(!ok_to_add) 964return-1; 965if(!verify_path(ce->name)) 966returnerror("Invalid path '%s'", ce->name); 967 968if(!skip_df_check && 969check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 970if(!ok_to_replace) 971returnerror("'%s' appears as both a file and as a directory", 972 ce->name); 973 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 974 pos = -pos-1; 975} 976return pos +1; 977} 978 979intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 980{ 981int pos; 982 983if(option & ADD_CACHE_JUST_APPEND) 984 pos = istate->cache_nr; 985else{ 986int ret; 987 ret =add_index_entry_with_check(istate, ce, option); 988if(ret <=0) 989return ret; 990 pos = ret -1; 991} 992 993/* Make sure the array is big enough .. */ 994ALLOC_GROW(istate->cache, istate->cache_nr +1, istate->cache_alloc); 995 996/* Add it in.. */ 997 istate->cache_nr++; 998if(istate->cache_nr > pos +1) 999memmove(istate->cache + pos +1,1000 istate->cache + pos,1001(istate->cache_nr - pos -1) *sizeof(ce));1002set_index_entry(istate, pos, ce);1003 istate->cache_changed =1;1004return0;1005}10061007/*1008 * "refresh" does not calculate a new sha1 file or bring the1009 * cache up-to-date for mode/content changes. But what it1010 * _does_ do is to "re-match" the stat information of a file1011 * with the cache, so that you can refresh the cache for a1012 * file that hasn't been changed but where the stat entry is1013 * out of date.1014 *1015 * For example, you'd want to do this after doing a "git-read-tree",1016 * to link up the stat cache details with the proper files.1017 */1018static struct cache_entry *refresh_cache_ent(struct index_state *istate,1019struct cache_entry *ce,1020unsigned int options,int*err,1021int*changed_ret)1022{1023struct stat st;1024struct cache_entry *updated;1025int changed, size;1026int refresh = options & CE_MATCH_REFRESH;1027int ignore_valid = options & CE_MATCH_IGNORE_VALID;1028int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;1029int ignore_missing = options & CE_MATCH_IGNORE_MISSING;10301031if(!refresh ||ce_uptodate(ce))1032return ce;10331034/*1035 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1036 * that the change to the work tree does not matter and told1037 * us not to worry.1038 */1039if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1040ce_mark_uptodate(ce);1041return ce;1042}1043if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1044ce_mark_uptodate(ce);1045return ce;1046}10471048if(lstat(ce->name, &st) <0) {1049if(ignore_missing && errno == ENOENT)1050return ce;1051if(err)1052*err = errno;1053return NULL;1054}10551056 changed =ie_match_stat(istate, ce, &st, options);1057if(changed_ret)1058*changed_ret = changed;1059if(!changed) {1060/*1061 * The path is unchanged. If we were told to ignore1062 * valid bit, then we did the actual stat check and1063 * found that the entry is unmodified. If the entry1064 * is not marked VALID, this is the place to mark it1065 * valid again, under "assume unchanged" mode.1066 */1067if(ignore_valid && assume_unchanged &&1068!(ce->ce_flags & CE_VALID))1069;/* mark this one VALID again */1070else{1071/*1072 * We do not mark the index itself "modified"1073 * because CE_UPTODATE flag is in-core only;1074 * we are not going to write this change out.1075 */1076if(!S_ISGITLINK(ce->ce_mode))1077ce_mark_uptodate(ce);1078return ce;1079}1080}10811082if(ie_modified(istate, ce, &st, options)) {1083if(err)1084*err = EINVAL;1085return NULL;1086}10871088 size =ce_size(ce);1089 updated =xmalloc(size);1090memcpy(updated, ce, size);1091fill_stat_cache_info(updated, &st);1092/*1093 * If ignore_valid is not set, we should leave CE_VALID bit1094 * alone. Otherwise, paths marked with --no-assume-unchanged1095 * (i.e. things to be edited) will reacquire CE_VALID bit1096 * automatically, which is not really what we want.1097 */1098if(!ignore_valid && assume_unchanged &&1099!(ce->ce_flags & CE_VALID))1100 updated->ce_flags &= ~CE_VALID;11011102return updated;1103}11041105static voidshow_file(const char* fmt,const char* name,int in_porcelain,1106int* first,const char*header_msg)1107{1108if(in_porcelain && *first && header_msg) {1109printf("%s\n", header_msg);1110*first =0;1111}1112printf(fmt, name);1113}11141115intrefresh_index(struct index_state *istate,unsigned int flags,1116const struct pathspec *pathspec,1117char*seen,const char*header_msg)1118{1119int i;1120int has_errors =0;1121int really = (flags & REFRESH_REALLY) !=0;1122int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1123int quiet = (flags & REFRESH_QUIET) !=0;1124int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1125int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1126int first =1;1127int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1128unsigned int options = (CE_MATCH_REFRESH |1129(really ? CE_MATCH_IGNORE_VALID :0) |1130(not_new ? CE_MATCH_IGNORE_MISSING :0));1131const char*modified_fmt;1132const char*deleted_fmt;1133const char*typechange_fmt;1134const char*added_fmt;1135const char*unmerged_fmt;11361137 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1138 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1139 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1140 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1141 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1142for(i =0; i < istate->cache_nr; i++) {1143struct cache_entry *ce, *new;1144int cache_errno =0;1145int changed =0;1146int filtered =0;11471148 ce = istate->cache[i];1149if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1150continue;11511152if(pathspec && !ce_path_match(ce, pathspec, 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(really && cache_errno == EINVAL) {1179/* If we are doing --really-refresh that1180 * means the index is not valid anymore.1181 */1182 ce->ce_flags &= ~CE_VALID;1183 istate->cache_changed =1;1184}1185if(quiet)1186continue;11871188if(cache_errno == ENOENT)1189 fmt = deleted_fmt;1190else if(ce->ce_flags & CE_INTENT_TO_ADD)1191 fmt = added_fmt;/* must be before other checks */1192else if(changed & TYPE_CHANGED)1193 fmt = typechange_fmt;1194else1195 fmt = modified_fmt;1196show_file(fmt,1197 ce->name, in_porcelain, &first, header_msg);1198 has_errors =1;1199continue;1200}12011202replace_index_entry(istate, i,new);1203}1204return has_errors;1205}12061207static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,1208unsigned int options)1209{1210returnrefresh_cache_ent(&the_index, ce, options, NULL, NULL);1211}121212131214/*****************************************************************1215 * Index File I/O1216 *****************************************************************/12171218#define INDEX_FORMAT_DEFAULT 312191220static intindex_format_config(const char*var,const char*value,void*cb)1221{1222unsigned int*version = cb;1223if(!strcmp(var,"index.version")) {1224*version =git_config_int(var, value);1225return0;1226}1227return1;1228}12291230static unsigned intget_index_format_default(void)1231{1232char*envversion =getenv("GIT_INDEX_VERSION");1233char*endp;1234unsigned int version = INDEX_FORMAT_DEFAULT;12351236if(!envversion) {1237git_config(index_format_config, &version);1238if(version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1239warning(_("index.version set, but the value is invalid.\n"1240"Using version%i"), INDEX_FORMAT_DEFAULT);1241return INDEX_FORMAT_DEFAULT;1242}1243return version;1244}12451246 version =strtoul(envversion, &endp,10);1247if(*endp ||1248 version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {1249warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"1250"Using version%i"), INDEX_FORMAT_DEFAULT);1251 version = INDEX_FORMAT_DEFAULT;1252}1253return version;1254}12551256/*1257 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1258 * Again - this is just a (very strong in practice) heuristic that1259 * the inode hasn't changed.1260 *1261 * We save the fields in big-endian order to allow using the1262 * index file over NFS transparently.1263 */1264struct ondisk_cache_entry {1265struct cache_time ctime;1266struct cache_time mtime;1267uint32_t dev;1268uint32_t ino;1269uint32_t mode;1270uint32_t uid;1271uint32_t gid;1272uint32_t size;1273unsigned char sha1[20];1274uint16_t flags;1275char name[FLEX_ARRAY];/* more */1276};12771278/*1279 * This struct is used when CE_EXTENDED bit is 11280 * The struct must match ondisk_cache_entry exactly from1281 * ctime till flags1282 */1283struct ondisk_cache_entry_extended {1284struct cache_time ctime;1285struct cache_time mtime;1286uint32_t dev;1287uint32_t ino;1288uint32_t mode;1289uint32_t uid;1290uint32_t gid;1291uint32_t size;1292unsigned char sha1[20];1293uint16_t flags;1294uint16_t flags2;1295char name[FLEX_ARRAY];/* more */1296};12971298/* These are only used for v3 or lower */1299#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1300#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1301#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1302#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1303 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1304 ondisk_cache_entry_size(ce_namelen(ce)))13051306static intverify_hdr(struct cache_header *hdr,unsigned long size)1307{1308 git_SHA_CTX c;1309unsigned char sha1[20];1310int hdr_version;13111312if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1313returnerror("bad signature");1314 hdr_version =ntohl(hdr->hdr_version);1315if(hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)1316returnerror("bad index version%d", hdr_version);1317git_SHA1_Init(&c);1318git_SHA1_Update(&c, hdr, size -20);1319git_SHA1_Final(sha1, &c);1320if(hashcmp(sha1, (unsigned char*)hdr + size -20))1321returnerror("bad index file sha1 signature");1322return0;1323}13241325static intread_index_extension(struct index_state *istate,1326const char*ext,void*data,unsigned long sz)1327{1328switch(CACHE_EXT(ext)) {1329case CACHE_EXT_TREE:1330 istate->cache_tree =cache_tree_read(data, sz);1331break;1332case CACHE_EXT_RESOLVE_UNDO:1333 istate->resolve_undo =resolve_undo_read(data, sz);1334break;1335default:1336if(*ext <'A'||'Z'< *ext)1337returnerror("index uses %.4s extension, which we do not understand",1338 ext);1339fprintf(stderr,"ignoring %.4s extension\n", ext);1340break;1341}1342return0;1343}13441345intread_index(struct index_state *istate)1346{1347returnread_index_from(istate,get_index_file());1348}13491350static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1351unsigned int flags,1352const char*name,1353size_t len)1354{1355struct cache_entry *ce =xmalloc(cache_entry_size(len));13561357 ce->ce_stat_data.sd_ctime.sec =get_be32(&ondisk->ctime.sec);1358 ce->ce_stat_data.sd_mtime.sec =get_be32(&ondisk->mtime.sec);1359 ce->ce_stat_data.sd_ctime.nsec =get_be32(&ondisk->ctime.nsec);1360 ce->ce_stat_data.sd_mtime.nsec =get_be32(&ondisk->mtime.nsec);1361 ce->ce_stat_data.sd_dev =get_be32(&ondisk->dev);1362 ce->ce_stat_data.sd_ino =get_be32(&ondisk->ino);1363 ce->ce_mode =get_be32(&ondisk->mode);1364 ce->ce_stat_data.sd_uid =get_be32(&ondisk->uid);1365 ce->ce_stat_data.sd_gid =get_be32(&ondisk->gid);1366 ce->ce_stat_data.sd_size =get_be32(&ondisk->size);1367 ce->ce_flags = flags & ~CE_NAMEMASK;1368 ce->ce_namelen = len;1369hashcpy(ce->sha1, ondisk->sha1);1370memcpy(ce->name, name, len);1371 ce->name[len] ='\0';1372return ce;1373}13741375/*1376 * Adjacent cache entries tend to share the leading paths, so it makes1377 * sense to only store the differences in later entries. In the v41378 * on-disk format of the index, each on-disk cache entry stores the1379 * number of bytes to be stripped from the end of the previous name,1380 * and the bytes to append to the result, to come up with its name.1381 */1382static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1383{1384const unsigned char*ep, *cp = (const unsigned char*)cp_;1385size_t len =decode_varint(&cp);13861387if(name->len < len)1388die("malformed name field in the index");1389strbuf_remove(name, name->len - len, len);1390for(ep = cp; *ep; ep++)1391;/* find the end */1392strbuf_add(name, cp, ep - cp);1393return(const char*)ep +1- cp_;1394}13951396static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1397unsigned long*ent_size,1398struct strbuf *previous_name)1399{1400struct cache_entry *ce;1401size_t len;1402const char*name;1403unsigned int flags;14041405/* On-disk flags are just 16 bits */1406 flags =get_be16(&ondisk->flags);1407 len = flags & CE_NAMEMASK;14081409if(flags & CE_EXTENDED) {1410struct ondisk_cache_entry_extended *ondisk2;1411int extended_flags;1412 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1413 extended_flags =get_be16(&ondisk2->flags2) <<16;1414/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1415if(extended_flags & ~CE_EXTENDED_FLAGS)1416die("Unknown index entry format%08x", extended_flags);1417 flags |= extended_flags;1418 name = ondisk2->name;1419}1420else1421 name = ondisk->name;14221423if(!previous_name) {1424/* v3 and earlier */1425if(len == CE_NAMEMASK)1426 len =strlen(name);1427 ce =cache_entry_from_ondisk(ondisk, flags, name, len);14281429*ent_size =ondisk_ce_size(ce);1430}else{1431unsigned long consumed;1432 consumed =expand_name_field(previous_name, name);1433 ce =cache_entry_from_ondisk(ondisk, flags,1434 previous_name->buf,1435 previous_name->len);14361437*ent_size = (name - ((char*)ondisk)) + consumed;1438}1439return ce;1440}14411442/* remember to discard_cache() before reading a different cache! */1443intread_index_from(struct index_state *istate,const char*path)1444{1445int fd, i;1446struct stat st;1447unsigned long src_offset;1448struct cache_header *hdr;1449void*mmap;1450size_t mmap_size;1451struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;14521453if(istate->initialized)1454return istate->cache_nr;14551456 istate->timestamp.sec =0;1457 istate->timestamp.nsec =0;1458 fd =open(path, O_RDONLY);1459if(fd <0) {1460if(errno == ENOENT)1461return0;1462die_errno("index file open failed");1463}14641465if(fstat(fd, &st))1466die_errno("cannot stat the open index");14671468 mmap_size =xsize_t(st.st_size);1469if(mmap_size <sizeof(struct cache_header) +20)1470die("index file smaller than expected");14711472 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1473if(mmap == MAP_FAILED)1474die_errno("unable to map index file");1475close(fd);14761477 hdr = mmap;1478if(verify_hdr(hdr, mmap_size) <0)1479goto unmap;14801481 istate->version =ntohl(hdr->hdr_version);1482 istate->cache_nr =ntohl(hdr->hdr_entries);1483 istate->cache_alloc =alloc_nr(istate->cache_nr);1484 istate->cache =xcalloc(istate->cache_alloc,sizeof(*istate->cache));1485 istate->initialized =1;14861487if(istate->version ==4)1488 previous_name = &previous_name_buf;1489else1490 previous_name = NULL;14911492 src_offset =sizeof(*hdr);1493for(i =0; i < istate->cache_nr; i++) {1494struct ondisk_cache_entry *disk_ce;1495struct cache_entry *ce;1496unsigned long consumed;14971498 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1499 ce =create_from_disk(disk_ce, &consumed, previous_name);1500set_index_entry(istate, i, ce);15011502 src_offset += consumed;1503}1504strbuf_release(&previous_name_buf);1505 istate->timestamp.sec = st.st_mtime;1506 istate->timestamp.nsec =ST_MTIME_NSEC(st);15071508while(src_offset <= mmap_size -20-8) {1509/* After an array of active_nr index entries,1510 * there can be arbitrary number of extended1511 * sections, each of which is prefixed with1512 * extension name (4-byte) and section length1513 * in 4-byte network byte order.1514 */1515uint32_t extsize;1516memcpy(&extsize, (char*)mmap + src_offset +4,4);1517 extsize =ntohl(extsize);1518if(read_index_extension(istate,1519(const char*) mmap + src_offset,1520(char*) mmap + src_offset +8,1521 extsize) <0)1522goto unmap;1523 src_offset +=8;1524 src_offset += extsize;1525}1526munmap(mmap, mmap_size);1527return istate->cache_nr;15281529unmap:1530munmap(mmap, mmap_size);1531die("index file corrupt");1532}15331534intis_index_unborn(struct index_state *istate)1535{1536return(!istate->cache_nr && !istate->timestamp.sec);1537}15381539intdiscard_index(struct index_state *istate)1540{1541int i;15421543for(i =0; i < istate->cache_nr; i++)1544free(istate->cache[i]);1545resolve_undo_clear_index(istate);1546 istate->cache_nr =0;1547 istate->cache_changed =0;1548 istate->timestamp.sec =0;1549 istate->timestamp.nsec =0;1550free_name_hash(istate);1551cache_tree_free(&(istate->cache_tree));1552 istate->initialized =0;1553free(istate->cache);1554 istate->cache = NULL;1555 istate->cache_alloc =0;1556return0;1557}15581559intunmerged_index(const struct index_state *istate)1560{1561int i;1562for(i =0; i < istate->cache_nr; i++) {1563if(ce_stage(istate->cache[i]))1564return1;1565}1566return0;1567}15681569#define WRITE_BUFFER_SIZE 81921570static unsigned char write_buffer[WRITE_BUFFER_SIZE];1571static unsigned long write_buffer_len;15721573static intce_write_flush(git_SHA_CTX *context,int fd)1574{1575unsigned int buffered = write_buffer_len;1576if(buffered) {1577git_SHA1_Update(context, write_buffer, buffered);1578if(write_in_full(fd, write_buffer, buffered) != buffered)1579return-1;1580 write_buffer_len =0;1581}1582return0;1583}15841585static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1586{1587while(len) {1588unsigned int buffered = write_buffer_len;1589unsigned int partial = WRITE_BUFFER_SIZE - buffered;1590if(partial > len)1591 partial = len;1592memcpy(write_buffer + buffered, data, partial);1593 buffered += partial;1594if(buffered == WRITE_BUFFER_SIZE) {1595 write_buffer_len = buffered;1596if(ce_write_flush(context, fd))1597return-1;1598 buffered =0;1599}1600 write_buffer_len = buffered;1601 len -= partial;1602 data = (char*) data + partial;1603}1604return0;1605}16061607static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1608unsigned int ext,unsigned int sz)1609{1610 ext =htonl(ext);1611 sz =htonl(sz);1612return((ce_write(context, fd, &ext,4) <0) ||1613(ce_write(context, fd, &sz,4) <0)) ? -1:0;1614}16151616static intce_flush(git_SHA_CTX *context,int fd)1617{1618unsigned int left = write_buffer_len;16191620if(left) {1621 write_buffer_len =0;1622git_SHA1_Update(context, write_buffer, left);1623}16241625/* Flush first if not enough space for SHA1 signature */1626if(left +20> WRITE_BUFFER_SIZE) {1627if(write_in_full(fd, write_buffer, left) != left)1628return-1;1629 left =0;1630}16311632/* Append the SHA1 signature at the end */1633git_SHA1_Final(write_buffer + left, context);1634 left +=20;1635return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1636}16371638static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1639{1640/*1641 * The only thing we care about in this function is to smudge the1642 * falsely clean entry due to touch-update-touch race, so we leave1643 * everything else as they are. We are called for entries whose1644 * ce_stat_data.sd_mtime match the index file mtime.1645 *1646 * Note that this actually does not do much for gitlinks, for1647 * which ce_match_stat_basic() always goes to the actual1648 * contents. The caller checks with is_racy_timestamp() which1649 * always says "no" for gitlinks, so we are not called for them ;-)1650 */1651struct stat st;16521653if(lstat(ce->name, &st) <0)1654return;1655if(ce_match_stat_basic(ce, &st))1656return;1657if(ce_modified_check_fs(ce, &st)) {1658/* This is "racily clean"; smudge it. Note that this1659 * is a tricky code. At first glance, it may appear1660 * that it can break with this sequence:1661 *1662 * $ echo xyzzy >frotz1663 * $ git-update-index --add frotz1664 * $ : >frotz1665 * $ sleep 31666 * $ echo filfre >nitfol1667 * $ git-update-index --add nitfol1668 *1669 * but it does not. When the second update-index runs,1670 * it notices that the entry "frotz" has the same timestamp1671 * as index, and if we were to smudge it by resetting its1672 * size to zero here, then the object name recorded1673 * in index is the 6-byte file but the cached stat information1674 * becomes zero --- which would then match what we would1675 * obtain from the filesystem next time we stat("frotz").1676 *1677 * However, the second update-index, before calling1678 * this function, notices that the cached size is 61679 * bytes and what is on the filesystem is an empty1680 * file, and never calls us, so the cached size information1681 * for "frotz" stays 6 which does not match the filesystem.1682 */1683 ce->ce_stat_data.sd_size =0;1684}1685}16861687/* Copy miscellaneous fields but not the name */1688static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1689struct cache_entry *ce)1690{1691short flags;16921693 ondisk->ctime.sec =htonl(ce->ce_stat_data.sd_ctime.sec);1694 ondisk->mtime.sec =htonl(ce->ce_stat_data.sd_mtime.sec);1695 ondisk->ctime.nsec =htonl(ce->ce_stat_data.sd_ctime.nsec);1696 ondisk->mtime.nsec =htonl(ce->ce_stat_data.sd_mtime.nsec);1697 ondisk->dev =htonl(ce->ce_stat_data.sd_dev);1698 ondisk->ino =htonl(ce->ce_stat_data.sd_ino);1699 ondisk->mode =htonl(ce->ce_mode);1700 ondisk->uid =htonl(ce->ce_stat_data.sd_uid);1701 ondisk->gid =htonl(ce->ce_stat_data.sd_gid);1702 ondisk->size =htonl(ce->ce_stat_data.sd_size);1703hashcpy(ondisk->sha1, ce->sha1);17041705 flags = ce->ce_flags & ~CE_NAMEMASK;1706 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1707 ondisk->flags =htons(flags);1708if(ce->ce_flags & CE_EXTENDED) {1709struct ondisk_cache_entry_extended *ondisk2;1710 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1711 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1712return ondisk2->name;1713}1714else{1715return ondisk->name;1716}1717}17181719static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1720struct strbuf *previous_name)1721{1722int size;1723struct ondisk_cache_entry *ondisk;1724char*name;1725int result;17261727if(!previous_name) {1728 size =ondisk_ce_size(ce);1729 ondisk =xcalloc(1, size);1730 name =copy_cache_entry_to_ondisk(ondisk, ce);1731memcpy(name, ce->name,ce_namelen(ce));1732}else{1733int common, to_remove, prefix_size;1734unsigned char to_remove_vi[16];1735for(common =0;1736(ce->name[common] &&1737 common < previous_name->len &&1738 ce->name[common] == previous_name->buf[common]);1739 common++)1740;/* still matching */1741 to_remove = previous_name->len - common;1742 prefix_size =encode_varint(to_remove, to_remove_vi);17431744if(ce->ce_flags & CE_EXTENDED)1745 size =offsetof(struct ondisk_cache_entry_extended, name);1746else1747 size =offsetof(struct ondisk_cache_entry, name);1748 size += prefix_size + (ce_namelen(ce) - common +1);17491750 ondisk =xcalloc(1, size);1751 name =copy_cache_entry_to_ondisk(ondisk, ce);1752memcpy(name, to_remove_vi, prefix_size);1753memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);17541755strbuf_splice(previous_name, common, to_remove,1756 ce->name + common,ce_namelen(ce) - common);1757}17581759 result =ce_write(c, fd, ondisk, size);1760free(ondisk);1761return result;1762}17631764static inthas_racy_timestamp(struct index_state *istate)1765{1766int entries = istate->cache_nr;1767int i;17681769for(i =0; i < entries; i++) {1770struct cache_entry *ce = istate->cache[i];1771if(is_racy_timestamp(istate, ce))1772return1;1773}1774return0;1775}17761777/*1778 * Opportunistically update the index but do not complain if we can't1779 */1780voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)1781{1782if((istate->cache_changed ||has_racy_timestamp(istate)) &&1783write_locked_index(istate, lockfile, COMMIT_LOCK))1784rollback_lock_file(lockfile);1785}17861787static intdo_write_index(struct index_state *istate,int newfd)1788{1789 git_SHA_CTX c;1790struct cache_header hdr;1791int i, err, removed, extended, hdr_version;1792struct cache_entry **cache = istate->cache;1793int entries = istate->cache_nr;1794struct stat st;1795struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17961797for(i = removed = extended =0; i < entries; i++) {1798if(cache[i]->ce_flags & CE_REMOVE)1799 removed++;18001801/* reduce extended entries if possible */1802 cache[i]->ce_flags &= ~CE_EXTENDED;1803if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1804 extended++;1805 cache[i]->ce_flags |= CE_EXTENDED;1806}1807}18081809if(!istate->version)1810 istate->version =get_index_format_default();18111812/* demote version 3 to version 2 when the latter suffices */1813if(istate->version ==3|| istate->version ==2)1814 istate->version = extended ?3:2;18151816 hdr_version = istate->version;18171818 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1819 hdr.hdr_version =htonl(hdr_version);1820 hdr.hdr_entries =htonl(entries - removed);18211822git_SHA1_Init(&c);1823if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1824return-1;18251826 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;1827for(i =0; i < entries; i++) {1828struct cache_entry *ce = cache[i];1829if(ce->ce_flags & CE_REMOVE)1830continue;1831if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1832ce_smudge_racily_clean_entry(ce);1833if(is_null_sha1(ce->sha1)) {1834static const char msg[] ="cache entry has null sha1:%s";1835static int allow = -1;18361837if(allow <0)1838 allow =git_env_bool("GIT_ALLOW_NULL_SHA1",0);1839if(allow)1840warning(msg, ce->name);1841else1842returnerror(msg, ce->name);1843}1844if(ce_write_entry(&c, newfd, ce, previous_name) <0)1845return-1;1846}1847strbuf_release(&previous_name_buf);18481849/* Write extension data here */1850if(istate->cache_tree) {1851struct strbuf sb = STRBUF_INIT;18521853cache_tree_write(&sb, istate->cache_tree);1854 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01855||ce_write(&c, newfd, sb.buf, sb.len) <0;1856strbuf_release(&sb);1857if(err)1858return-1;1859}1860if(istate->resolve_undo) {1861struct strbuf sb = STRBUF_INIT;18621863resolve_undo_write(&sb, istate->resolve_undo);1864 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1865 sb.len) <01866||ce_write(&c, newfd, sb.buf, sb.len) <0;1867strbuf_release(&sb);1868if(err)1869return-1;1870}18711872if(ce_flush(&c, newfd) ||fstat(newfd, &st))1873return-1;1874 istate->timestamp.sec = (unsigned int)st.st_mtime;1875 istate->timestamp.nsec =ST_MTIME_NSEC(st);1876return0;1877}18781879voidset_alternate_index_output(const char*name)1880{1881 alternate_index_output = name;1882}18831884static intcommit_locked_index(struct lock_file *lk)1885{1886if(alternate_index_output) {1887if(lk->fd >=0&&close_lock_file(lk))1888return-1;1889if(rename(lk->filename, alternate_index_output))1890return-1;1891 lk->filename[0] =0;1892return0;1893}else{1894returncommit_lock_file(lk);1895}1896}18971898static intdo_write_locked_index(struct index_state *istate,struct lock_file *lock,1899unsigned flags)1900{1901int ret =do_write_index(istate, lock->fd);1902if(ret)1903return ret;1904assert((flags & (COMMIT_LOCK | CLOSE_LOCK)) !=1905(COMMIT_LOCK | CLOSE_LOCK));1906if(flags & COMMIT_LOCK)1907returncommit_locked_index(lock);1908else if(flags & CLOSE_LOCK)1909returnclose_lock_file(lock);1910else1911return ret;1912}19131914intwrite_locked_index(struct index_state *istate,struct lock_file *lock,1915unsigned flags)1916{1917returndo_write_locked_index(istate, lock, flags);1918}19191920/*1921 * Read the index file that is potentially unmerged into given1922 * index_state, dropping any unmerged entries. Returns true if1923 * the index is unmerged. Callers who want to refuse to work1924 * from an unmerged state can call this and check its return value,1925 * instead of calling read_cache().1926 */1927intread_index_unmerged(struct index_state *istate)1928{1929int i;1930int unmerged =0;19311932read_index(istate);1933for(i =0; i < istate->cache_nr; i++) {1934struct cache_entry *ce = istate->cache[i];1935struct cache_entry *new_ce;1936int size, len;19371938if(!ce_stage(ce))1939continue;1940 unmerged =1;1941 len =ce_namelen(ce);1942 size =cache_entry_size(len);1943 new_ce =xcalloc(1, size);1944memcpy(new_ce->name, ce->name, len);1945 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;1946 new_ce->ce_namelen = len;1947 new_ce->ce_mode = ce->ce_mode;1948if(add_index_entry(istate, new_ce,0))1949returnerror("%s: cannot drop to stage #0",1950 new_ce->name);1951 i =index_name_pos(istate, new_ce->name, len);1952}1953return unmerged;1954}19551956/*1957 * Returns 1 if the path is an "other" path with respect to1958 * the index; that is, the path is not mentioned in the index at all,1959 * either as a file, a directory with some files in the index,1960 * or as an unmerged entry.1961 *1962 * We helpfully remove a trailing "/" from directories so that1963 * the output of read_directory can be used as-is.1964 */1965intindex_name_is_other(const struct index_state *istate,const char*name,1966int namelen)1967{1968int pos;1969if(namelen && name[namelen -1] =='/')1970 namelen--;1971 pos =index_name_pos(istate, name, namelen);1972if(0<= pos)1973return0;/* exact match */1974 pos = -pos -1;1975if(pos < istate->cache_nr) {1976struct cache_entry *ce = istate->cache[pos];1977if(ce_namelen(ce) == namelen &&1978!memcmp(ce->name, name, namelen))1979return0;/* Yup, this one exists unmerged */1980}1981return1;1982}19831984void*read_blob_data_from_index(struct index_state *istate,const char*path,unsigned long*size)1985{1986int pos, len;1987unsigned long sz;1988enum object_type type;1989void*data;19901991 len =strlen(path);1992 pos =index_name_pos(istate, path, len);1993if(pos <0) {1994/*1995 * We might be in the middle of a merge, in which1996 * case we would read stage #2 (ours).1997 */1998int i;1999for(i = -pos -1;2000(pos <0&& i < istate->cache_nr &&2001!strcmp(istate->cache[i]->name, path));2002 i++)2003if(ce_stage(istate->cache[i]) ==2)2004 pos = i;2005}2006if(pos <0)2007return NULL;2008 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz);2009if(!data || type != OBJ_BLOB) {2010free(data);2011return NULL;2012}2013if(size)2014*size = sz;2015return data;2016}20172018voidstat_validity_clear(struct stat_validity *sv)2019{2020free(sv->sd);2021 sv->sd = NULL;2022}20232024intstat_validity_check(struct stat_validity *sv,const char*path)2025{2026struct stat st;20272028if(stat(path, &st) <0)2029return sv->sd == NULL;2030if(!sv->sd)2031return0;2032returnS_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);2033}20342035voidstat_validity_update(struct stat_validity *sv,int fd)2036{2037struct stat st;20382039if(fstat(fd, &st) <0|| !S_ISREG(st.st_mode))2040stat_validity_clear(sv);2041else{2042if(!sv->sd)2043 sv->sd =xcalloc(1,sizeof(struct stat_data));2044fill_stat_data(sv->sd, &st);2045}2046}