1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#include"cache.h" 7#include"cache-tree.h" 8#include"refs.h" 9 10/* Index extensions. 11 * 12 * The first letter should be 'A'..'Z' for extensions that are not 13 * necessary for a correct operation (i.e. optimization data). 14 * When new extensions are added that _needs_ to be understood in 15 * order to correctly interpret the index file, pick character that 16 * is outside the range, to cause the reader to abort. 17 */ 18 19#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 20#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 21 22struct cache_entry **active_cache; 23static time_t index_file_timestamp; 24unsigned int active_nr, active_alloc, active_cache_changed; 25 26struct cache_tree *active_cache_tree; 27 28static void*cache_mmap; 29static size_t cache_mmap_size; 30 31/* 32 * This only updates the "non-critical" parts of the directory 33 * cache, ie the parts that aren't tracked by GIT, and only used 34 * to validate the cache. 35 */ 36voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 37{ 38 ce->ce_ctime.sec =htonl(st->st_ctime); 39 ce->ce_mtime.sec =htonl(st->st_mtime); 40#ifdef USE_NSEC 41 ce->ce_ctime.nsec =htonl(st->st_ctim.tv_nsec); 42 ce->ce_mtime.nsec =htonl(st->st_mtim.tv_nsec); 43#endif 44 ce->ce_dev =htonl(st->st_dev); 45 ce->ce_ino =htonl(st->st_ino); 46 ce->ce_uid =htonl(st->st_uid); 47 ce->ce_gid =htonl(st->st_gid); 48 ce->ce_size =htonl(st->st_size); 49 50if(assume_unchanged) 51 ce->ce_flags |=htons(CE_VALID); 52} 53 54static intce_compare_data(struct cache_entry *ce,struct stat *st) 55{ 56int match = -1; 57int fd =open(ce->name, O_RDONLY); 58 59if(fd >=0) { 60unsigned char sha1[20]; 61if(!index_fd(sha1, fd, st,0, OBJ_BLOB, ce->name)) 62 match =hashcmp(sha1, ce->sha1); 63/* index_fd() closed the file descriptor already */ 64} 65return match; 66} 67 68static intce_compare_link(struct cache_entry *ce,size_t expected_size) 69{ 70int match = -1; 71char*target; 72void*buffer; 73unsigned long size; 74enum object_type type; 75int len; 76 77 target =xmalloc(expected_size); 78 len =readlink(ce->name, target, expected_size); 79if(len != expected_size) { 80free(target); 81return-1; 82} 83 buffer =read_sha1_file(ce->sha1, &type, &size); 84if(!buffer) { 85free(target); 86return-1; 87} 88if(size == expected_size) 89 match =memcmp(buffer, target, size); 90free(buffer); 91free(target); 92return match; 93} 94 95static intce_compare_gitlink(struct cache_entry *ce) 96{ 97unsigned char sha1[20]; 98 99/* 100 * We don't actually require that the .git directory 101 * under DIRLNK directory be a valid git directory. It 102 * might even be missing (in case nobody populated that 103 * sub-project). 104 * 105 * If so, we consider it always to match. 106 */ 107if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 108return0; 109returnhashcmp(sha1, ce->sha1); 110} 111 112static intce_modified_check_fs(struct cache_entry *ce,struct stat *st) 113{ 114switch(st->st_mode & S_IFMT) { 115case S_IFREG: 116if(ce_compare_data(ce, st)) 117return DATA_CHANGED; 118break; 119case S_IFLNK: 120if(ce_compare_link(ce,xsize_t(st->st_size))) 121return DATA_CHANGED; 122break; 123case S_IFDIRLNK: 124/* No need to do anything, we did the exact compare in "match_stat_basic" */ 125break; 126default: 127return TYPE_CHANGED; 128} 129return0; 130} 131 132static intce_match_stat_basic(struct cache_entry *ce,struct stat *st) 133{ 134unsigned int changed =0; 135 136switch(ntohl(ce->ce_mode) & S_IFMT) { 137case S_IFREG: 138 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 139/* We consider only the owner x bit to be relevant for 140 * "mode changes" 141 */ 142if(trust_executable_bit && 143(0100& (ntohl(ce->ce_mode) ^ st->st_mode))) 144 changed |= MODE_CHANGED; 145break; 146case S_IFLNK: 147if(!S_ISLNK(st->st_mode) && 148(has_symlinks || !S_ISREG(st->st_mode))) 149 changed |= TYPE_CHANGED; 150break; 151case S_IFDIRLNK: 152if(!S_ISDIR(st->st_mode)) 153 changed |= TYPE_CHANGED; 154else if(ce_compare_gitlink(ce)) 155 changed |= DATA_CHANGED; 156break; 157default: 158die("internal error: ce_mode is%o",ntohl(ce->ce_mode)); 159} 160if(ce->ce_mtime.sec !=htonl(st->st_mtime)) 161 changed |= MTIME_CHANGED; 162if(ce->ce_ctime.sec !=htonl(st->st_ctime)) 163 changed |= CTIME_CHANGED; 164 165#ifdef USE_NSEC 166/* 167 * nsec seems unreliable - not all filesystems support it, so 168 * as long as it is in the inode cache you get right nsec 169 * but after it gets flushed, you get zero nsec. 170 */ 171if(ce->ce_mtime.nsec !=htonl(st->st_mtim.tv_nsec)) 172 changed |= MTIME_CHANGED; 173if(ce->ce_ctime.nsec !=htonl(st->st_ctim.tv_nsec)) 174 changed |= CTIME_CHANGED; 175#endif 176 177if(ce->ce_uid !=htonl(st->st_uid) || 178 ce->ce_gid !=htonl(st->st_gid)) 179 changed |= OWNER_CHANGED; 180if(ce->ce_ino !=htonl(st->st_ino)) 181 changed |= INODE_CHANGED; 182 183#ifdef USE_STDEV 184/* 185 * st_dev breaks on network filesystems where different 186 * clients will have different views of what "device" 187 * the filesystem is on 188 */ 189if(ce->ce_dev !=htonl(st->st_dev)) 190 changed |= INODE_CHANGED; 191#endif 192 193if(ce->ce_size !=htonl(st->st_size)) 194 changed |= DATA_CHANGED; 195 196return changed; 197} 198 199intce_match_stat(struct cache_entry *ce,struct stat *st,int options) 200{ 201unsigned int changed; 202int ignore_valid = options &01; 203int assume_racy_is_modified = options &02; 204 205/* 206 * If it's marked as always valid in the index, it's 207 * valid whatever the checked-out copy says. 208 */ 209if(!ignore_valid && (ce->ce_flags &htons(CE_VALID))) 210return0; 211 212 changed =ce_match_stat_basic(ce, st); 213 214/* 215 * Within 1 second of this sequence: 216 * echo xyzzy >file && git-update-index --add file 217 * running this command: 218 * echo frotz >file 219 * would give a falsely clean cache entry. The mtime and 220 * length match the cache, and other stat fields do not change. 221 * 222 * We could detect this at update-index time (the cache entry 223 * being registered/updated records the same time as "now") 224 * and delay the return from git-update-index, but that would 225 * effectively mean we can make at most one commit per second, 226 * which is not acceptable. Instead, we check cache entries 227 * whose mtime are the same as the index file timestamp more 228 * carefully than others. 229 */ 230if(!changed && 231 index_file_timestamp && 232 index_file_timestamp <=ntohl(ce->ce_mtime.sec)) { 233if(assume_racy_is_modified) 234 changed |= DATA_CHANGED; 235else 236 changed |=ce_modified_check_fs(ce, st); 237} 238 239return changed; 240} 241 242intce_modified(struct cache_entry *ce,struct stat *st,int really) 243{ 244int changed, changed_fs; 245 changed =ce_match_stat(ce, st, really); 246if(!changed) 247return0; 248/* 249 * If the mode or type has changed, there's no point in trying 250 * to refresh the entry - it's not going to match 251 */ 252if(changed & (MODE_CHANGED | TYPE_CHANGED)) 253return changed; 254 255/* Immediately after read-tree or update-index --cacheinfo, 256 * the length field is zero. For other cases the ce_size 257 * should match the SHA1 recorded in the index entry. 258 */ 259if((changed & DATA_CHANGED) && ce->ce_size !=htonl(0)) 260return changed; 261 262 changed_fs =ce_modified_check_fs(ce, st); 263if(changed_fs) 264return changed | changed_fs; 265return0; 266} 267 268intbase_name_compare(const char*name1,int len1,int mode1, 269const char*name2,int len2,int mode2) 270{ 271unsigned char c1, c2; 272int len = len1 < len2 ? len1 : len2; 273int cmp; 274 275 cmp =memcmp(name1, name2, len); 276if(cmp) 277return cmp; 278 c1 = name1[len]; 279 c2 = name2[len]; 280if(!c1 &&S_ISDIR(mode1)) 281 c1 ='/'; 282if(!c2 &&S_ISDIR(mode2)) 283 c2 ='/'; 284return(c1 < c2) ? -1: (c1 > c2) ?1:0; 285} 286 287intcache_name_compare(const char*name1,int flags1,const char*name2,int flags2) 288{ 289int len1 = flags1 & CE_NAMEMASK; 290int len2 = flags2 & CE_NAMEMASK; 291int len = len1 < len2 ? len1 : len2; 292int cmp; 293 294 cmp =memcmp(name1, name2, len); 295if(cmp) 296return cmp; 297if(len1 < len2) 298return-1; 299if(len1 > len2) 300return1; 301 302/* Compare stages */ 303 flags1 &= CE_STAGEMASK; 304 flags2 &= CE_STAGEMASK; 305 306if(flags1 < flags2) 307return-1; 308if(flags1 > flags2) 309return1; 310return0; 311} 312 313intcache_name_pos(const char*name,int namelen) 314{ 315int first, last; 316 317 first =0; 318 last = active_nr; 319while(last > first) { 320int next = (last + first) >>1; 321struct cache_entry *ce = active_cache[next]; 322int cmp =cache_name_compare(name, namelen, ce->name,ntohs(ce->ce_flags)); 323if(!cmp) 324return next; 325if(cmp <0) { 326 last = next; 327continue; 328} 329 first = next+1; 330} 331return-first-1; 332} 333 334/* Remove entry, return true if there are more entries to go.. */ 335intremove_cache_entry_at(int pos) 336{ 337 active_cache_changed =1; 338 active_nr--; 339if(pos >= active_nr) 340return0; 341memmove(active_cache + pos, active_cache + pos +1, (active_nr - pos) *sizeof(struct cache_entry *)); 342return1; 343} 344 345intremove_file_from_cache(const char*path) 346{ 347int pos =cache_name_pos(path,strlen(path)); 348if(pos <0) 349 pos = -pos-1; 350while(pos < active_nr && !strcmp(active_cache[pos]->name, path)) 351remove_cache_entry_at(pos); 352return0; 353} 354 355intadd_file_to_cache(const char*path,int verbose) 356{ 357int size, namelen; 358struct stat st; 359struct cache_entry *ce; 360 361if(lstat(path, &st)) 362die("%s: unable to stat (%s)", path,strerror(errno)); 363 364if(!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode) && !S_ISDIR(st.st_mode)) 365die("%s: can only add regular files, symbolic links or git-directories", path); 366 367 namelen =strlen(path); 368 size =cache_entry_size(namelen); 369 ce =xcalloc(1, size); 370memcpy(ce->name, path, namelen); 371 ce->ce_flags =htons(namelen); 372fill_stat_cache_info(ce, &st); 373 374if(trust_executable_bit && has_symlinks) 375 ce->ce_mode =create_ce_mode(st.st_mode); 376else{ 377/* If there is an existing entry, pick the mode bits and type 378 * from it, otherwise assume unexecutable regular file. 379 */ 380struct cache_entry *ent; 381int pos =cache_name_pos(path, namelen); 382 383 ent = (0<= pos) ? active_cache[pos] : NULL; 384 ce->ce_mode =ce_mode_from_stat(ent, st.st_mode); 385} 386 387if(index_path(ce->sha1, path, &st,1)) 388die("unable to index file%s", path); 389if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE)) 390die("unable to add%sto index",path); 391if(verbose) 392printf("add '%s'\n", path); 393cache_tree_invalidate_path(active_cache_tree, path); 394return0; 395} 396 397intce_same_name(struct cache_entry *a,struct cache_entry *b) 398{ 399int len =ce_namelen(a); 400returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 401} 402 403intce_path_match(const struct cache_entry *ce,const char**pathspec) 404{ 405const char*match, *name; 406int len; 407 408if(!pathspec) 409return1; 410 411 len =ce_namelen(ce); 412 name = ce->name; 413while((match = *pathspec++) != NULL) { 414int matchlen =strlen(match); 415if(matchlen > len) 416continue; 417if(memcmp(name, match, matchlen)) 418continue; 419if(matchlen && name[matchlen-1] =='/') 420return1; 421if(name[matchlen] =='/'|| !name[matchlen]) 422return1; 423if(!matchlen) 424return1; 425} 426return0; 427} 428 429/* 430 * We fundamentally don't like some paths: we don't want 431 * dot or dot-dot anywhere, and for obvious reasons don't 432 * want to recurse into ".git" either. 433 * 434 * Also, we don't want double slashes or slashes at the 435 * end that can make pathnames ambiguous. 436 */ 437static intverify_dotfile(const char*rest) 438{ 439/* 440 * The first character was '.', but that 441 * has already been discarded, we now test 442 * the rest. 443 */ 444switch(*rest) { 445/* "." is not allowed */ 446case'\0':case'/': 447return0; 448 449/* 450 * ".git" followed by NUL or slash is bad. This 451 * shares the path end test with the ".." case. 452 */ 453case'g': 454if(rest[1] !='i') 455break; 456if(rest[2] !='t') 457break; 458 rest +=2; 459/* fallthrough */ 460case'.': 461if(rest[1] =='\0'|| rest[1] =='/') 462return0; 463} 464return1; 465} 466 467intverify_path(const char*path) 468{ 469char c; 470 471goto inside; 472for(;;) { 473if(!c) 474return1; 475if(c =='/') { 476inside: 477 c = *path++; 478switch(c) { 479default: 480continue; 481case'/':case'\0': 482break; 483case'.': 484if(verify_dotfile(path)) 485continue; 486} 487return0; 488} 489 c = *path++; 490} 491} 492 493/* 494 * Do we have another file that has the beginning components being a 495 * proper superset of the name we're trying to add? 496 */ 497static inthas_file_name(const struct cache_entry *ce,int pos,int ok_to_replace) 498{ 499int retval =0; 500int len =ce_namelen(ce); 501int stage =ce_stage(ce); 502const char*name = ce->name; 503 504while(pos < active_nr) { 505struct cache_entry *p = active_cache[pos++]; 506 507if(len >=ce_namelen(p)) 508break; 509if(memcmp(name, p->name, len)) 510break; 511if(ce_stage(p) != stage) 512continue; 513if(p->name[len] !='/') 514continue; 515if(!ce_stage(p) && !p->ce_mode) 516continue; 517 retval = -1; 518if(!ok_to_replace) 519break; 520remove_cache_entry_at(--pos); 521} 522return retval; 523} 524 525/* 526 * Do we have another file with a pathname that is a proper 527 * subset of the name we're trying to add? 528 */ 529static inthas_dir_name(const struct cache_entry *ce,int pos,int ok_to_replace) 530{ 531int retval =0; 532int stage =ce_stage(ce); 533const char*name = ce->name; 534const char*slash = name +ce_namelen(ce); 535 536for(;;) { 537int len; 538 539for(;;) { 540if(*--slash =='/') 541break; 542if(slash <= ce->name) 543return retval; 544} 545 len = slash - name; 546 547 pos =cache_name_pos(name,ntohs(create_ce_flags(len, stage))); 548if(pos >=0) { 549/* 550 * Found one, but not so fast. This could 551 * be a marker that says "I was here, but 552 * I am being removed". Such an entry is 553 * not a part of the resulting tree, and 554 * it is Ok to have a directory at the same 555 * path. 556 */ 557if(stage || active_cache[pos]->ce_mode) { 558 retval = -1; 559if(!ok_to_replace) 560break; 561remove_cache_entry_at(pos); 562continue; 563} 564} 565else 566 pos = -pos-1; 567 568/* 569 * Trivial optimization: if we find an entry that 570 * already matches the sub-directory, then we know 571 * we're ok, and we can exit. 572 */ 573while(pos < active_nr) { 574struct cache_entry *p = active_cache[pos]; 575if((ce_namelen(p) <= len) || 576(p->name[len] !='/') || 577memcmp(p->name, name, len)) 578break;/* not our subdirectory */ 579if(ce_stage(p) == stage && (stage || p->ce_mode)) 580/* p is at the same stage as our entry, and 581 * is a subdirectory of what we are looking 582 * at, so we cannot have conflicts at our 583 * level or anything shorter. 584 */ 585return retval; 586 pos++; 587} 588} 589return retval; 590} 591 592/* We may be in a situation where we already have path/file and path 593 * is being added, or we already have path and path/file is being 594 * added. Either one would result in a nonsense tree that has path 595 * twice when git-write-tree tries to write it out. Prevent it. 596 * 597 * If ok-to-replace is specified, we remove the conflicting entries 598 * from the cache so the caller should recompute the insert position. 599 * When this happens, we return non-zero. 600 */ 601static intcheck_file_directory_conflict(const struct cache_entry *ce,int pos,int ok_to_replace) 602{ 603int retval; 604 605/* 606 * When ce is an "I am going away" entry, we allow it to be added 607 */ 608if(!ce_stage(ce) && !ce->ce_mode) 609return0; 610 611/* 612 * We check if the path is a sub-path of a subsequent pathname 613 * first, since removing those will not change the position 614 * in the array. 615 */ 616 retval =has_file_name(ce, pos, ok_to_replace); 617 618/* 619 * Then check if the path might have a clashing sub-directory 620 * before it. 621 */ 622return retval +has_dir_name(ce, pos, ok_to_replace); 623} 624 625intadd_cache_entry(struct cache_entry *ce,int option) 626{ 627int pos; 628int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 629int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 630int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 631 632 pos =cache_name_pos(ce->name,ntohs(ce->ce_flags)); 633 634/* existing match? Just replace it. */ 635if(pos >=0) { 636 active_cache_changed =1; 637 active_cache[pos] = ce; 638return0; 639} 640 pos = -pos-1; 641 642/* 643 * Inserting a merged entry ("stage 0") into the index 644 * will always replace all non-merged entries.. 645 */ 646if(pos < active_nr &&ce_stage(ce) ==0) { 647while(ce_same_name(active_cache[pos], ce)) { 648 ok_to_add =1; 649if(!remove_cache_entry_at(pos)) 650break; 651} 652} 653 654if(!ok_to_add) 655return-1; 656if(!verify_path(ce->name)) 657return-1; 658 659if(!skip_df_check && 660check_file_directory_conflict(ce, pos, ok_to_replace)) { 661if(!ok_to_replace) 662returnerror("'%s' appears as both a file and as a directory", ce->name); 663 pos =cache_name_pos(ce->name,ntohs(ce->ce_flags)); 664 pos = -pos-1; 665} 666 667/* Make sure the array is big enough .. */ 668if(active_nr == active_alloc) { 669 active_alloc =alloc_nr(active_alloc); 670 active_cache =xrealloc(active_cache, active_alloc *sizeof(struct cache_entry *)); 671} 672 673/* Add it in.. */ 674 active_nr++; 675if(active_nr > pos) 676memmove(active_cache + pos +1, active_cache + pos, (active_nr - pos -1) *sizeof(ce)); 677 active_cache[pos] = ce; 678 active_cache_changed =1; 679return0; 680} 681 682/* 683 * "refresh" does not calculate a new sha1 file or bring the 684 * cache up-to-date for mode/content changes. But what it 685 * _does_ do is to "re-match" the stat information of a file 686 * with the cache, so that you can refresh the cache for a 687 * file that hasn't been changed but where the stat entry is 688 * out of date. 689 * 690 * For example, you'd want to do this after doing a "git-read-tree", 691 * to link up the stat cache details with the proper files. 692 */ 693static struct cache_entry *refresh_cache_ent(struct cache_entry *ce,int really,int*err) 694{ 695struct stat st; 696struct cache_entry *updated; 697int changed, size; 698 699if(lstat(ce->name, &st) <0) { 700if(err) 701*err = errno; 702return NULL; 703} 704 705 changed =ce_match_stat(ce, &st, really); 706if(!changed) { 707if(really && assume_unchanged && 708!(ce->ce_flags &htons(CE_VALID))) 709;/* mark this one VALID again */ 710else 711return ce; 712} 713 714if(ce_modified(ce, &st, really)) { 715if(err) 716*err = EINVAL; 717return NULL; 718} 719 720 size =ce_size(ce); 721 updated =xmalloc(size); 722memcpy(updated, ce, size); 723fill_stat_cache_info(updated, &st); 724 725/* In this case, if really is not set, we should leave 726 * CE_VALID bit alone. Otherwise, paths marked with 727 * --no-assume-unchanged (i.e. things to be edited) will 728 * reacquire CE_VALID bit automatically, which is not 729 * really what we want. 730 */ 731if(!really && assume_unchanged && !(ce->ce_flags &htons(CE_VALID))) 732 updated->ce_flags &= ~htons(CE_VALID); 733 734return updated; 735} 736 737intrefresh_cache(unsigned int flags) 738{ 739int i; 740int has_errors =0; 741int really = (flags & REFRESH_REALLY) !=0; 742int allow_unmerged = (flags & REFRESH_UNMERGED) !=0; 743int quiet = (flags & REFRESH_QUIET) !=0; 744int not_new = (flags & REFRESH_IGNORE_MISSING) !=0; 745 746for(i =0; i < active_nr; i++) { 747struct cache_entry *ce, *new; 748int cache_errno =0; 749 750 ce = active_cache[i]; 751if(ce_stage(ce)) { 752while((i < active_nr) && 753!strcmp(active_cache[i]->name, ce->name)) 754 i++; 755 i--; 756if(allow_unmerged) 757continue; 758printf("%s: needs merge\n", ce->name); 759 has_errors =1; 760continue; 761} 762 763new=refresh_cache_ent(ce, really, &cache_errno); 764if(new== ce) 765continue; 766if(!new) { 767if(not_new && cache_errno == ENOENT) 768continue; 769if(really && cache_errno == EINVAL) { 770/* If we are doing --really-refresh that 771 * means the index is not valid anymore. 772 */ 773 ce->ce_flags &= ~htons(CE_VALID); 774 active_cache_changed =1; 775} 776if(quiet) 777continue; 778printf("%s: needs update\n", ce->name); 779 has_errors =1; 780continue; 781} 782 active_cache_changed =1; 783/* You can NOT just free active_cache[i] here, since it 784 * might not be necessarily malloc()ed but can also come 785 * from mmap(). */ 786 active_cache[i] =new; 787} 788return has_errors; 789} 790 791struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really) 792{ 793returnrefresh_cache_ent(ce, really, NULL); 794} 795 796static intverify_hdr(struct cache_header *hdr,unsigned long size) 797{ 798 SHA_CTX c; 799unsigned char sha1[20]; 800 801if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE)) 802returnerror("bad signature"); 803if(hdr->hdr_version !=htonl(2)) 804returnerror("bad index version"); 805SHA1_Init(&c); 806SHA1_Update(&c, hdr, size -20); 807SHA1_Final(sha1, &c); 808if(hashcmp(sha1, (unsigned char*)hdr + size -20)) 809returnerror("bad index file sha1 signature"); 810return0; 811} 812 813static intread_index_extension(const char*ext,void*data,unsigned long sz) 814{ 815switch(CACHE_EXT(ext)) { 816case CACHE_EXT_TREE: 817 active_cache_tree =cache_tree_read(data, sz); 818break; 819default: 820if(*ext <'A'||'Z'< *ext) 821returnerror("index uses %.4s extension, which we do not understand", 822 ext); 823fprintf(stderr,"ignoring %.4s extension\n", ext); 824break; 825} 826return0; 827} 828 829intread_cache(void) 830{ 831returnread_cache_from(get_index_file()); 832} 833 834/* remember to discard_cache() before reading a different cache! */ 835intread_cache_from(const char*path) 836{ 837int fd, i; 838struct stat st; 839unsigned long offset; 840struct cache_header *hdr; 841 842 errno = EBUSY; 843if(cache_mmap) 844return active_nr; 845 846 errno = ENOENT; 847 index_file_timestamp =0; 848 fd =open(path, O_RDONLY); 849if(fd <0) { 850if(errno == ENOENT) 851return0; 852die("index file open failed (%s)",strerror(errno)); 853} 854 855if(!fstat(fd, &st)) { 856 cache_mmap_size =xsize_t(st.st_size); 857 errno = EINVAL; 858if(cache_mmap_size >=sizeof(struct cache_header) +20) 859 cache_mmap =xmmap(NULL, cache_mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0); 860else 861die("index file smaller than expected"); 862}else 863die("cannot stat the open index (%s)",strerror(errno)); 864close(fd); 865 866 hdr = cache_mmap; 867if(verify_hdr(hdr, cache_mmap_size) <0) 868goto unmap; 869 870 active_nr =ntohl(hdr->hdr_entries); 871 active_alloc =alloc_nr(active_nr); 872 active_cache =xcalloc(active_alloc,sizeof(struct cache_entry *)); 873 874 offset =sizeof(*hdr); 875for(i =0; i < active_nr; i++) { 876struct cache_entry *ce = (struct cache_entry *) ((char*) cache_mmap + offset); 877 offset = offset +ce_size(ce); 878 active_cache[i] = ce; 879} 880 index_file_timestamp = st.st_mtime; 881while(offset <= cache_mmap_size -20-8) { 882/* After an array of active_nr index entries, 883 * there can be arbitrary number of extended 884 * sections, each of which is prefixed with 885 * extension name (4-byte) and section length 886 * in 4-byte network byte order. 887 */ 888unsigned long extsize; 889memcpy(&extsize, (char*) cache_mmap + offset +4,4); 890 extsize =ntohl(extsize); 891if(read_index_extension(((const char*) cache_mmap) + offset, 892(char*) cache_mmap + offset +8, 893 extsize) <0) 894goto unmap; 895 offset +=8; 896 offset += extsize; 897} 898return active_nr; 899 900unmap: 901munmap(cache_mmap, cache_mmap_size); 902 errno = EINVAL; 903die("index file corrupt"); 904} 905 906intdiscard_cache(void) 907{ 908int ret; 909 910 active_nr = active_cache_changed =0; 911 index_file_timestamp =0; 912cache_tree_free(&active_cache_tree); 913if(cache_mmap == NULL) 914return0; 915 ret =munmap(cache_mmap, cache_mmap_size); 916 cache_mmap = NULL; 917 cache_mmap_size =0; 918 919/* no need to throw away allocated active_cache */ 920return ret; 921} 922 923#define WRITE_BUFFER_SIZE 8192 924static unsigned char write_buffer[WRITE_BUFFER_SIZE]; 925static unsigned long write_buffer_len; 926 927static intce_write_flush(SHA_CTX *context,int fd) 928{ 929unsigned int buffered = write_buffer_len; 930if(buffered) { 931SHA1_Update(context, write_buffer, buffered); 932if(write_in_full(fd, write_buffer, buffered) != buffered) 933return-1; 934 write_buffer_len =0; 935} 936return0; 937} 938 939static intce_write(SHA_CTX *context,int fd,void*data,unsigned int len) 940{ 941while(len) { 942unsigned int buffered = write_buffer_len; 943unsigned int partial = WRITE_BUFFER_SIZE - buffered; 944if(partial > len) 945 partial = len; 946memcpy(write_buffer + buffered, data, partial); 947 buffered += partial; 948if(buffered == WRITE_BUFFER_SIZE) { 949 write_buffer_len = buffered; 950if(ce_write_flush(context, fd)) 951return-1; 952 buffered =0; 953} 954 write_buffer_len = buffered; 955 len -= partial; 956 data = (char*) data + partial; 957} 958return0; 959} 960 961static intwrite_index_ext_header(SHA_CTX *context,int fd, 962unsigned int ext,unsigned int sz) 963{ 964 ext =htonl(ext); 965 sz =htonl(sz); 966return((ce_write(context, fd, &ext,4) <0) || 967(ce_write(context, fd, &sz,4) <0)) ? -1:0; 968} 969 970static intce_flush(SHA_CTX *context,int fd) 971{ 972unsigned int left = write_buffer_len; 973 974if(left) { 975 write_buffer_len =0; 976SHA1_Update(context, write_buffer, left); 977} 978 979/* Flush first if not enough space for SHA1 signature */ 980if(left +20> WRITE_BUFFER_SIZE) { 981if(write_in_full(fd, write_buffer, left) != left) 982return-1; 983 left =0; 984} 985 986/* Append the SHA1 signature at the end */ 987SHA1_Final(write_buffer + left, context); 988 left +=20; 989return(write_in_full(fd, write_buffer, left) != left) ? -1:0; 990} 991 992static voidce_smudge_racily_clean_entry(struct cache_entry *ce) 993{ 994/* 995 * The only thing we care about in this function is to smudge the 996 * falsely clean entry due to touch-update-touch race, so we leave 997 * everything else as they are. We are called for entries whose 998 * ce_mtime match the index file mtime. 999 */1000struct stat st;10011002if(lstat(ce->name, &st) <0)1003return;1004if(ce_match_stat_basic(ce, &st))1005return;1006if(ce_modified_check_fs(ce, &st)) {1007/* This is "racily clean"; smudge it. Note that this1008 * is a tricky code. At first glance, it may appear1009 * that it can break with this sequence:1010 *1011 * $ echo xyzzy >frotz1012 * $ git-update-index --add frotz1013 * $ : >frotz1014 * $ sleep 31015 * $ echo filfre >nitfol1016 * $ git-update-index --add nitfol1017 *1018 * but it does not. When the second update-index runs,1019 * it notices that the entry "frotz" has the same timestamp1020 * as index, and if we were to smudge it by resetting its1021 * size to zero here, then the object name recorded1022 * in index is the 6-byte file but the cached stat information1023 * becomes zero --- which would then match what we would1024 * obtain from the filesystem next time we stat("frotz"). 1025 *1026 * However, the second update-index, before calling1027 * this function, notices that the cached size is 61028 * bytes and what is on the filesystem is an empty1029 * file, and never calls us, so the cached size information1030 * for "frotz" stays 6 which does not match the filesystem.1031 */1032 ce->ce_size =htonl(0);1033}1034}10351036intwrite_cache(int newfd,struct cache_entry **cache,int entries)1037{1038 SHA_CTX c;1039struct cache_header hdr;1040int i, removed;10411042for(i = removed =0; i < entries; i++)1043if(!cache[i]->ce_mode)1044 removed++;10451046 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1047 hdr.hdr_version =htonl(2);1048 hdr.hdr_entries =htonl(entries - removed);10491050SHA1_Init(&c);1051if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1052return-1;10531054for(i =0; i < entries; i++) {1055struct cache_entry *ce = cache[i];1056if(!ce->ce_mode)1057continue;1058if(index_file_timestamp &&1059 index_file_timestamp <=ntohl(ce->ce_mtime.sec))1060ce_smudge_racily_clean_entry(ce);1061if(ce_write(&c, newfd, ce,ce_size(ce)) <0)1062return-1;1063}10641065/* Write extension data here */1066if(active_cache_tree) {1067unsigned long sz;1068void*data =cache_tree_write(active_cache_tree, &sz);1069if(data &&1070!write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sz) &&1071!ce_write(&c, newfd, data, sz))1072free(data);1073else{1074free(data);1075return-1;1076}1077}1078returnce_flush(&c, newfd);1079}