1#include"../cache.h" 2#include"../config.h" 3#include"../refs.h" 4#include"refs-internal.h" 5#include"packed-backend.h" 6#include"../iterator.h" 7#include"../lockfile.h" 8 9enum mmap_strategy { 10/* 11 * Don't use mmap() at all for reading `packed-refs`. 12 */ 13 MMAP_NONE, 14 15/* 16 * Can use mmap() for reading `packed-refs`, but the file must 17 * not remain mmapped. This is the usual option on Windows, 18 * where you cannot rename a new version of a file onto a file 19 * that is currently mmapped. 20 */ 21 MMAP_TEMPORARY, 22 23/* 24 * It is OK to leave the `packed-refs` file mmapped while 25 * arbitrary other code is running. 26 */ 27 MMAP_OK 28}; 29 30#if defined(NO_MMAP) 31static enum mmap_strategy mmap_strategy = MMAP_NONE; 32#elif defined(MMAP_PREVENTS_DELETE) 33static enum mmap_strategy mmap_strategy = MMAP_TEMPORARY; 34#else 35static enum mmap_strategy mmap_strategy = MMAP_OK; 36#endif 37 38struct packed_ref_store; 39 40/* 41 * A `snapshot` represents one snapshot of a `packed-refs` file. 42 * 43 * Normally, this will be a mmapped view of the contents of the 44 * `packed-refs` file at the time the snapshot was created. However, 45 * if the `packed-refs` file was not sorted, this might point at heap 46 * memory holding the contents of the `packed-refs` file with its 47 * records sorted by refname. 48 * 49 * `snapshot` instances are reference counted (via 50 * `acquire_snapshot()` and `release_snapshot()`). This is to prevent 51 * an instance from disappearing while an iterator is still iterating 52 * over it. Instances are garbage collected when their `referrers` 53 * count goes to zero. 54 * 55 * The most recent `snapshot`, if available, is referenced by the 56 * `packed_ref_store`. Its freshness is checked whenever 57 * `get_snapshot()` is called; if the existing snapshot is obsolete, a 58 * new snapshot is taken. 59 */ 60struct snapshot { 61/* 62 * A back-pointer to the packed_ref_store with which this 63 * snapshot is associated: 64 */ 65struct packed_ref_store *refs; 66 67/* Is the `packed-refs` file currently mmapped? */ 68int mmapped; 69 70/* 71 * The contents of the `packed-refs` file: 72 * 73 * - buf -- a pointer to the start of the memory 74 * - start -- a pointer to the first byte of actual references 75 * (i.e., after the header line, if one is present) 76 * - eof -- a pointer just past the end of the reference 77 * contents 78 * 79 * If the `packed-refs` file was already sorted, `buf` points 80 * at the mmapped contents of the file. If not, it points at 81 * heap-allocated memory containing the contents, sorted. If 82 * there were no contents (e.g., because the file didn't 83 * exist), `buf`, `start`, and `eof` are all NULL. 84 */ 85char*buf, *start, *eof; 86 87/* 88 * What is the peeled state of the `packed-refs` file that 89 * this snapshot represents? (This is usually determined from 90 * the file's header.) 91 */ 92enum{ PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled; 93 94/* 95 * Count of references to this instance, including the pointer 96 * from `packed_ref_store::snapshot`, if any. The instance 97 * will not be freed as long as the reference count is 98 * nonzero. 99 */ 100unsigned int referrers; 101 102/* 103 * The metadata of the `packed-refs` file from which this 104 * snapshot was created, used to tell if the file has been 105 * replaced since we read it. 106 */ 107struct stat_validity validity; 108}; 109 110/* 111 * A `ref_store` representing references stored in a `packed-refs` 112 * file. It implements the `ref_store` interface, though it has some 113 * limitations: 114 * 115 * - It cannot store symbolic references. 116 * 117 * - It cannot store reflogs. 118 * 119 * - It does not support reference renaming (though it could). 120 * 121 * On the other hand, it can be locked outside of a reference 122 * transaction. In that case, it remains locked even after the 123 * transaction is done and the new `packed-refs` file is activated. 124 */ 125struct packed_ref_store { 126struct ref_store base; 127 128unsigned int store_flags; 129 130/* The path of the "packed-refs" file: */ 131char*path; 132 133/* 134 * A snapshot of the values read from the `packed-refs` file, 135 * if it might still be current; otherwise, NULL. 136 */ 137struct snapshot *snapshot; 138 139/* 140 * Lock used for the "packed-refs" file. Note that this (and 141 * thus the enclosing `packed_ref_store`) must not be freed. 142 */ 143struct lock_file lock; 144 145/* 146 * Temporary file used when rewriting new contents to the 147 * "packed-refs" file. Note that this (and thus the enclosing 148 * `packed_ref_store`) must not be freed. 149 */ 150struct tempfile *tempfile; 151}; 152 153/* 154 * Increment the reference count of `*snapshot`. 155 */ 156static voidacquire_snapshot(struct snapshot *snapshot) 157{ 158 snapshot->referrers++; 159} 160 161/* 162 * If the buffer in `snapshot` is active, then either munmap the 163 * memory and close the file, or free the memory. Then set the buffer 164 * pointers to NULL. 165 */ 166static voidclear_snapshot_buffer(struct snapshot *snapshot) 167{ 168if(snapshot->mmapped) { 169if(munmap(snapshot->buf, snapshot->eof - snapshot->buf)) 170die_errno("error ummapping packed-refs file%s", 171 snapshot->refs->path); 172 snapshot->mmapped =0; 173}else{ 174free(snapshot->buf); 175} 176 snapshot->buf = snapshot->start = snapshot->eof = NULL; 177} 178 179/* 180 * Decrease the reference count of `*snapshot`. If it goes to zero, 181 * free `*snapshot` and return true; otherwise return false. 182 */ 183static intrelease_snapshot(struct snapshot *snapshot) 184{ 185if(!--snapshot->referrers) { 186stat_validity_clear(&snapshot->validity); 187clear_snapshot_buffer(snapshot); 188free(snapshot); 189return1; 190}else{ 191return0; 192} 193} 194 195struct ref_store *packed_ref_store_create(const char*path, 196unsigned int store_flags) 197{ 198struct packed_ref_store *refs =xcalloc(1,sizeof(*refs)); 199struct ref_store *ref_store = (struct ref_store *)refs; 200 201base_ref_store_init(ref_store, &refs_be_packed); 202 refs->store_flags = store_flags; 203 204 refs->path =xstrdup(path); 205return ref_store; 206} 207 208/* 209 * Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is 210 * not a `packed_ref_store`. Also die if `packed_ref_store` doesn't 211 * support at least the flags specified in `required_flags`. `caller` 212 * is used in any necessary error messages. 213 */ 214static struct packed_ref_store *packed_downcast(struct ref_store *ref_store, 215unsigned int required_flags, 216const char*caller) 217{ 218struct packed_ref_store *refs; 219 220if(ref_store->be != &refs_be_packed) 221die("BUG: ref_store is type\"%s\"not\"packed\"in%s", 222 ref_store->be->name, caller); 223 224 refs = (struct packed_ref_store *)ref_store; 225 226if((refs->store_flags & required_flags) != required_flags) 227die("BUG: unallowed operation (%s), requires%x, has%x\n", 228 caller, required_flags, refs->store_flags); 229 230return refs; 231} 232 233static voidclear_snapshot(struct packed_ref_store *refs) 234{ 235if(refs->snapshot) { 236struct snapshot *snapshot = refs->snapshot; 237 238 refs->snapshot = NULL; 239release_snapshot(snapshot); 240} 241} 242 243static NORETURN voiddie_unterminated_line(const char*path, 244const char*p,size_t len) 245{ 246if(len <80) 247die("unterminated line in%s: %.*s", path, (int)len, p); 248else 249die("unterminated line in%s: %.75s...", path, p); 250} 251 252static NORETURN voiddie_invalid_line(const char*path, 253const char*p,size_t len) 254{ 255const char*eol =memchr(p,'\n', len); 256 257if(!eol) 258die_unterminated_line(path, p, len); 259else if(eol - p <80) 260die("unexpected line in%s: %.*s", path, (int)(eol - p), p); 261else 262die("unexpected line in%s: %.75s...", path, p); 263 264} 265 266struct snapshot_record { 267const char*start; 268size_t len; 269}; 270 271static intcmp_packed_ref_records(const void*v1,const void*v2) 272{ 273const struct snapshot_record *e1 = v1, *e2 = v2; 274const char*r1 = e1->start + GIT_SHA1_HEXSZ +1; 275const char*r2 = e2->start + GIT_SHA1_HEXSZ +1; 276 277while(1) { 278if(*r1 =='\n') 279return*r2 =='\n'?0: -1; 280if(*r1 != *r2) { 281if(*r2 =='\n') 282return1; 283else 284return(unsigned char)*r1 < (unsigned char)*r2 ? -1: +1; 285} 286 r1++; 287 r2++; 288} 289} 290 291/* 292 * Compare a snapshot record at `rec` to the specified NUL-terminated 293 * refname. 294 */ 295static intcmp_record_to_refname(const char*rec,const char*refname) 296{ 297const char*r1 = rec + GIT_SHA1_HEXSZ +1; 298const char*r2 = refname; 299 300while(1) { 301if(*r1 =='\n') 302return*r2 ? -1:0; 303if(!*r2) 304return1; 305if(*r1 != *r2) 306return(unsigned char)*r1 < (unsigned char)*r2 ? -1: +1; 307 r1++; 308 r2++; 309} 310} 311 312/* 313 * `snapshot->buf` is not known to be sorted. Check whether it is, and 314 * if not, sort it into new memory and munmap/free the old storage. 315 */ 316static voidsort_snapshot(struct snapshot *snapshot) 317{ 318struct snapshot_record *records = NULL; 319size_t alloc =0, nr =0; 320int sorted =1; 321const char*pos, *eof, *eol; 322size_t len, i; 323char*new_buffer, *dst; 324 325 pos = snapshot->start; 326 eof = snapshot->eof; 327 328if(pos == eof) 329return; 330 331 len = eof - pos; 332 333/* 334 * Initialize records based on a crude estimate of the number 335 * of references in the file (we'll grow it below if needed): 336 */ 337ALLOC_GROW(records, len /80+20, alloc); 338 339while(pos < eof) { 340 eol =memchr(pos,'\n', eof - pos); 341if(!eol) 342/* The safety check should prevent this. */ 343BUG("unterminated line found in packed-refs"); 344if(eol - pos < GIT_SHA1_HEXSZ +2) 345die_invalid_line(snapshot->refs->path, 346 pos, eof - pos); 347 eol++; 348if(eol < eof && *eol =='^') { 349/* 350 * Keep any peeled line together with its 351 * reference: 352 */ 353const char*peeled_start = eol; 354 355 eol =memchr(peeled_start,'\n', eof - peeled_start); 356if(!eol) 357/* The safety check should prevent this. */ 358BUG("unterminated peeled line found in packed-refs"); 359 eol++; 360} 361 362ALLOC_GROW(records, nr +1, alloc); 363 records[nr].start = pos; 364 records[nr].len = eol - pos; 365 nr++; 366 367if(sorted && 368 nr >1&& 369cmp_packed_ref_records(&records[nr -2], 370&records[nr -1]) >=0) 371 sorted =0; 372 373 pos = eol; 374} 375 376if(sorted) 377goto cleanup; 378 379/* We need to sort the memory. First we sort the records array: */ 380QSORT(records, nr, cmp_packed_ref_records); 381 382/* 383 * Allocate a new chunk of memory, and copy the old memory to 384 * the new in the order indicated by `records` (not bothering 385 * with the header line): 386 */ 387 new_buffer =xmalloc(len); 388for(dst = new_buffer, i =0; i < nr; i++) { 389memcpy(dst, records[i].start, records[i].len); 390 dst += records[i].len; 391} 392 393/* 394 * Now munmap the old buffer and use the sorted buffer in its 395 * place: 396 */ 397clear_snapshot_buffer(snapshot); 398 snapshot->buf = snapshot->start = new_buffer; 399 snapshot->eof = new_buffer + len; 400 401cleanup: 402free(records); 403} 404 405/* 406 * Return a pointer to the start of the record that contains the 407 * character `*p` (which must be within the buffer). If no other 408 * record start is found, return `buf`. 409 */ 410static const char*find_start_of_record(const char*buf,const char*p) 411{ 412while(p > buf && (p[-1] !='\n'|| p[0] =='^')) 413 p--; 414return p; 415} 416 417/* 418 * Return a pointer to the start of the record following the record 419 * that contains `*p`. If none is found before `end`, return `end`. 420 */ 421static const char*find_end_of_record(const char*p,const char*end) 422{ 423while(++p < end && (p[-1] !='\n'|| p[0] =='^')) 424; 425return p; 426} 427 428/* 429 * We want to be able to compare mmapped reference records quickly, 430 * without totally parsing them. We can do so because the records are 431 * LF-terminated, and the refname should start exactly (GIT_SHA1_HEXSZ 432 * + 1) bytes past the beginning of the record. 433 * 434 * But what if the `packed-refs` file contains garbage? We're willing 435 * to tolerate not detecting the problem, as long as we don't produce 436 * totally garbled output (we can't afford to check the integrity of 437 * the whole file during every Git invocation). But we do want to be 438 * sure that we never read past the end of the buffer in memory and 439 * perform an illegal memory access. 440 * 441 * Guarantee that minimum level of safety by verifying that the last 442 * record in the file is LF-terminated, and that it has at least 443 * (GIT_SHA1_HEXSZ + 1) characters before the LF. Die if either of 444 * these checks fails. 445 */ 446static voidverify_buffer_safe(struct snapshot *snapshot) 447{ 448const char*start = snapshot->start; 449const char*eof = snapshot->eof; 450const char*last_line; 451 452if(start == eof) 453return; 454 455 last_line =find_start_of_record(start, eof -1); 456if(*(eof -1) !='\n'|| eof - last_line < GIT_SHA1_HEXSZ +2) 457die_invalid_line(snapshot->refs->path, 458 last_line, eof - last_line); 459} 460 461/* 462 * Depending on `mmap_strategy`, either mmap or read the contents of 463 * the `packed-refs` file into the snapshot. Return 1 if the file 464 * existed and was read, or 0 if the file was absent. Die on errors. 465 */ 466static intload_contents(struct snapshot *snapshot) 467{ 468int fd; 469struct stat st; 470size_t size; 471 ssize_t bytes_read; 472 473 fd =open(snapshot->refs->path, O_RDONLY); 474if(fd <0) { 475if(errno == ENOENT) { 476/* 477 * This is OK; it just means that no 478 * "packed-refs" file has been written yet, 479 * which is equivalent to it being empty, 480 * which is its state when initialized with 481 * zeros. 482 */ 483return0; 484}else{ 485die_errno("couldn't read%s", snapshot->refs->path); 486} 487} 488 489stat_validity_update(&snapshot->validity, fd); 490 491if(fstat(fd, &st) <0) 492die_errno("couldn't stat%s", snapshot->refs->path); 493 size =xsize_t(st.st_size); 494 495switch(mmap_strategy) { 496case MMAP_NONE: 497 snapshot->buf =xmalloc(size); 498 bytes_read =read_in_full(fd, snapshot->buf, size); 499if(bytes_read <0|| bytes_read != size) 500die_errno("couldn't read%s", snapshot->refs->path); 501 snapshot->mmapped =0; 502break; 503case MMAP_TEMPORARY: 504case MMAP_OK: 505 snapshot->buf =xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd,0); 506 snapshot->mmapped =1; 507break; 508} 509close(fd); 510 511 snapshot->start = snapshot->buf; 512 snapshot->eof = snapshot->buf + size; 513 514return1; 515} 516 517/* 518 * Find the place in `snapshot->buf` where the start of the record for 519 * `refname` starts. If `mustexist` is true and the reference doesn't 520 * exist, then return NULL. If `mustexist` is false and the reference 521 * doesn't exist, then return the point where that reference would be 522 * inserted, or `snapshot->eof` (which might be NULL) if it would be 523 * inserted at the end of the file. In the latter mode, `refname` 524 * doesn't have to be a proper reference name; for example, one could 525 * search for "refs/replace/" to find the start of any replace 526 * references. 527 * 528 * The record is sought using a binary search, so `snapshot->buf` must 529 * be sorted. 530 */ 531static const char*find_reference_location(struct snapshot *snapshot, 532const char*refname,int mustexist) 533{ 534/* 535 * This is not *quite* a garden-variety binary search, because 536 * the data we're searching is made up of records, and we 537 * always need to find the beginning of a record to do a 538 * comparison. A "record" here is one line for the reference 539 * itself and zero or one peel lines that start with '^'. Our 540 * loop invariant is described in the next two comments. 541 */ 542 543/* 544 * A pointer to the character at the start of a record whose 545 * preceding records all have reference names that come 546 * *before* `refname`. 547 */ 548const char*lo = snapshot->start; 549 550/* 551 * A pointer to a the first character of a record whose 552 * reference name comes *after* `refname`. 553 */ 554const char*hi = snapshot->eof; 555 556while(lo != hi) { 557const char*mid, *rec; 558int cmp; 559 560 mid = lo + (hi - lo) /2; 561 rec =find_start_of_record(lo, mid); 562 cmp =cmp_record_to_refname(rec, refname); 563if(cmp <0) { 564 lo =find_end_of_record(mid, hi); 565}else if(cmp >0) { 566 hi = rec; 567}else{ 568return rec; 569} 570} 571 572if(mustexist) 573return NULL; 574else 575return lo; 576} 577 578/* 579 * Create a newly-allocated `snapshot` of the `packed-refs` file in 580 * its current state and return it. The return value will already have 581 * its reference count incremented. 582 * 583 * A comment line of the form "# pack-refs with: " may contain zero or 584 * more traits. We interpret the traits as follows: 585 * 586 * Neither `peeled` nor `fully-peeled`: 587 * 588 * Probably no references are peeled. But if the file contains a 589 * peeled value for a reference, we will use it. 590 * 591 * `peeled`: 592 * 593 * References under "refs/tags/", if they *can* be peeled, *are* 594 * peeled in this file. References outside of "refs/tags/" are 595 * probably not peeled even if they could have been, but if we find 596 * a peeled value for such a reference we will use it. 597 * 598 * `fully-peeled`: 599 * 600 * All references in the file that can be peeled are peeled. 601 * Inversely (and this is more important), any references in the 602 * file for which no peeled value is recorded is not peelable. This 603 * trait should typically be written alongside "peeled" for 604 * compatibility with older clients, but we do not require it 605 * (i.e., "peeled" is a no-op if "fully-peeled" is set). 606 * 607 * `sorted`: 608 * 609 * The references in this file are known to be sorted by refname. 610 */ 611static struct snapshot *create_snapshot(struct packed_ref_store *refs) 612{ 613struct snapshot *snapshot =xcalloc(1,sizeof(*snapshot)); 614int sorted =0; 615 616 snapshot->refs = refs; 617acquire_snapshot(snapshot); 618 snapshot->peeled = PEELED_NONE; 619 620if(!load_contents(snapshot)) 621return snapshot; 622 623/* If the file has a header line, process it: */ 624if(snapshot->buf < snapshot->eof && *snapshot->buf =='#') { 625char*tmp, *p, *eol; 626struct string_list traits = STRING_LIST_INIT_NODUP; 627 628 eol =memchr(snapshot->buf,'\n', 629 snapshot->eof - snapshot->buf); 630if(!eol) 631die_unterminated_line(refs->path, 632 snapshot->buf, 633 snapshot->eof - snapshot->buf); 634 635 tmp =xmemdupz(snapshot->buf, eol - snapshot->buf); 636 637if(!skip_prefix(tmp,"# pack-refs with:", (const char**)&p)) 638die_invalid_line(refs->path, 639 snapshot->buf, 640 snapshot->eof - snapshot->buf); 641 642string_list_split_in_place(&traits, p,' ', -1); 643 644if(unsorted_string_list_has_string(&traits,"fully-peeled")) 645 snapshot->peeled = PEELED_FULLY; 646else if(unsorted_string_list_has_string(&traits,"peeled")) 647 snapshot->peeled = PEELED_TAGS; 648 649 sorted =unsorted_string_list_has_string(&traits,"sorted"); 650 651/* perhaps other traits later as well */ 652 653/* The "+ 1" is for the LF character. */ 654 snapshot->start = eol +1; 655 656string_list_clear(&traits,0); 657free(tmp); 658} 659 660verify_buffer_safe(snapshot); 661 662if(!sorted) { 663sort_snapshot(snapshot); 664 665/* 666 * Reordering the records might have moved a short one 667 * to the end of the buffer, so verify the buffer's 668 * safety again: 669 */ 670verify_buffer_safe(snapshot); 671} 672 673if(mmap_strategy != MMAP_OK && snapshot->mmapped) { 674/* 675 * We don't want to leave the file mmapped, so we are 676 * forced to make a copy now: 677 */ 678size_t size = snapshot->eof - snapshot->start; 679char*buf_copy =xmalloc(size); 680 681memcpy(buf_copy, snapshot->start, size); 682clear_snapshot_buffer(snapshot); 683 snapshot->buf = snapshot->start = buf_copy; 684 snapshot->eof = buf_copy + size; 685} 686 687return snapshot; 688} 689 690/* 691 * Check that `refs->snapshot` (if present) still reflects the 692 * contents of the `packed-refs` file. If not, clear the snapshot. 693 */ 694static voidvalidate_snapshot(struct packed_ref_store *refs) 695{ 696if(refs->snapshot && 697!stat_validity_check(&refs->snapshot->validity, refs->path)) 698clear_snapshot(refs); 699} 700 701/* 702 * Get the `snapshot` for the specified packed_ref_store, creating and 703 * populating it if it hasn't been read before or if the file has been 704 * changed (according to its `validity` field) since it was last read. 705 * On the other hand, if we hold the lock, then assume that the file 706 * hasn't been changed out from under us, so skip the extra `stat()` 707 * call in `stat_validity_check()`. This function does *not* increase 708 * the snapshot's reference count on behalf of the caller. 709 */ 710static struct snapshot *get_snapshot(struct packed_ref_store *refs) 711{ 712if(!is_lock_file_locked(&refs->lock)) 713validate_snapshot(refs); 714 715if(!refs->snapshot) 716 refs->snapshot =create_snapshot(refs); 717 718return refs->snapshot; 719} 720 721static intpacked_read_raw_ref(struct ref_store *ref_store, 722const char*refname,unsigned char*sha1, 723struct strbuf *referent,unsigned int*type) 724{ 725struct packed_ref_store *refs = 726packed_downcast(ref_store, REF_STORE_READ,"read_raw_ref"); 727struct snapshot *snapshot =get_snapshot(refs); 728const char*rec; 729 730*type =0; 731 732 rec =find_reference_location(snapshot, refname,1); 733 734if(!rec) { 735/* refname is not a packed reference. */ 736 errno = ENOENT; 737return-1; 738} 739 740if(get_sha1_hex(rec, sha1)) 741die_invalid_line(refs->path, rec, snapshot->eof - rec); 742 743*type = REF_ISPACKED; 744return0; 745} 746 747/* 748 * This value is set in `base.flags` if the peeled value of the 749 * current reference is known. In that case, `peeled` contains the 750 * correct peeled value for the reference, which might be `null_sha1` 751 * if the reference is not a tag or if it is broken. 752 */ 753#define REF_KNOWS_PEELED 0x40 754 755/* 756 * An iterator over a snapshot of a `packed-refs` file. 757 */ 758struct packed_ref_iterator { 759struct ref_iterator base; 760 761struct snapshot *snapshot; 762 763/* The current position in the snapshot's buffer: */ 764const char*pos; 765 766/* The end of the part of the buffer that will be iterated over: */ 767const char*eof; 768 769/* Scratch space for current values: */ 770struct object_id oid, peeled; 771struct strbuf refname_buf; 772 773unsigned int flags; 774}; 775 776/* 777 * Move the iterator to the next record in the snapshot, without 778 * respect for whether the record is actually required by the current 779 * iteration. Adjust the fields in `iter` and return `ITER_OK` or 780 * `ITER_DONE`. This function does not free the iterator in the case 781 * of `ITER_DONE`. 782 */ 783static intnext_record(struct packed_ref_iterator *iter) 784{ 785const char*p = iter->pos, *eol; 786 787strbuf_reset(&iter->refname_buf); 788 789if(iter->pos == iter->eof) 790return ITER_DONE; 791 792 iter->base.flags = REF_ISPACKED; 793 794if(iter->eof - p < GIT_SHA1_HEXSZ +2|| 795parse_oid_hex(p, &iter->oid, &p) || 796!isspace(*p++)) 797die_invalid_line(iter->snapshot->refs->path, 798 iter->pos, iter->eof - iter->pos); 799 800 eol =memchr(p,'\n', iter->eof - p); 801if(!eol) 802die_unterminated_line(iter->snapshot->refs->path, 803 iter->pos, iter->eof - iter->pos); 804 805strbuf_add(&iter->refname_buf, p, eol - p); 806 iter->base.refname = iter->refname_buf.buf; 807 808if(check_refname_format(iter->base.refname, REFNAME_ALLOW_ONELEVEL)) { 809if(!refname_is_safe(iter->base.refname)) 810die("packed refname is dangerous:%s", 811 iter->base.refname); 812oidclr(&iter->oid); 813 iter->base.flags |= REF_BAD_NAME | REF_ISBROKEN; 814} 815if(iter->snapshot->peeled == PEELED_FULLY || 816(iter->snapshot->peeled == PEELED_TAGS && 817starts_with(iter->base.refname,"refs/tags/"))) 818 iter->base.flags |= REF_KNOWS_PEELED; 819 820 iter->pos = eol +1; 821 822if(iter->pos < iter->eof && *iter->pos =='^') { 823 p = iter->pos +1; 824if(iter->eof - p < GIT_SHA1_HEXSZ +1|| 825parse_oid_hex(p, &iter->peeled, &p) || 826*p++ !='\n') 827die_invalid_line(iter->snapshot->refs->path, 828 iter->pos, iter->eof - iter->pos); 829 iter->pos = p; 830 831/* 832 * Regardless of what the file header said, we 833 * definitely know the value of *this* reference. But 834 * we suppress it if the reference is broken: 835 */ 836if((iter->base.flags & REF_ISBROKEN)) { 837oidclr(&iter->peeled); 838 iter->base.flags &= ~REF_KNOWS_PEELED; 839}else{ 840 iter->base.flags |= REF_KNOWS_PEELED; 841} 842}else{ 843oidclr(&iter->peeled); 844} 845 846return ITER_OK; 847} 848 849static intpacked_ref_iterator_advance(struct ref_iterator *ref_iterator) 850{ 851struct packed_ref_iterator *iter = 852(struct packed_ref_iterator *)ref_iterator; 853int ok; 854 855while((ok =next_record(iter)) == ITER_OK) { 856if(iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY && 857ref_type(iter->base.refname) != REF_TYPE_PER_WORKTREE) 858continue; 859 860if(!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 861!ref_resolves_to_object(iter->base.refname, &iter->oid, 862 iter->flags)) 863continue; 864 865return ITER_OK; 866} 867 868if(ref_iterator_abort(ref_iterator) != ITER_DONE) 869 ok = ITER_ERROR; 870 871return ok; 872} 873 874static intpacked_ref_iterator_peel(struct ref_iterator *ref_iterator, 875struct object_id *peeled) 876{ 877struct packed_ref_iterator *iter = 878(struct packed_ref_iterator *)ref_iterator; 879 880if((iter->base.flags & REF_KNOWS_PEELED)) { 881oidcpy(peeled, &iter->peeled); 882returnis_null_oid(&iter->peeled) ? -1:0; 883}else if((iter->base.flags & (REF_ISBROKEN | REF_ISSYMREF))) { 884return-1; 885}else{ 886return!!peel_object(iter->oid.hash, peeled->hash); 887} 888} 889 890static intpacked_ref_iterator_abort(struct ref_iterator *ref_iterator) 891{ 892struct packed_ref_iterator *iter = 893(struct packed_ref_iterator *)ref_iterator; 894int ok = ITER_DONE; 895 896strbuf_release(&iter->refname_buf); 897release_snapshot(iter->snapshot); 898base_ref_iterator_free(ref_iterator); 899return ok; 900} 901 902static struct ref_iterator_vtable packed_ref_iterator_vtable = { 903 packed_ref_iterator_advance, 904 packed_ref_iterator_peel, 905 packed_ref_iterator_abort 906}; 907 908static struct ref_iterator *packed_ref_iterator_begin( 909struct ref_store *ref_store, 910const char*prefix,unsigned int flags) 911{ 912struct packed_ref_store *refs; 913struct snapshot *snapshot; 914const char*start; 915struct packed_ref_iterator *iter; 916struct ref_iterator *ref_iterator; 917unsigned int required_flags = REF_STORE_READ; 918 919if(!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) 920 required_flags |= REF_STORE_ODB; 921 refs =packed_downcast(ref_store, required_flags,"ref_iterator_begin"); 922 923/* 924 * Note that `get_snapshot()` internally checks whether the 925 * snapshot is up to date with what is on disk, and re-reads 926 * it if not. 927 */ 928 snapshot =get_snapshot(refs); 929 930if(!snapshot->buf) 931returnempty_ref_iterator_begin(); 932 933 iter =xcalloc(1,sizeof(*iter)); 934 ref_iterator = &iter->base; 935base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable,1); 936 937 iter->snapshot = snapshot; 938acquire_snapshot(snapshot); 939 940if(prefix && *prefix) 941 start =find_reference_location(snapshot, prefix,0); 942else 943 start = snapshot->start; 944 945 iter->pos = start; 946 iter->eof = snapshot->eof; 947strbuf_init(&iter->refname_buf,0); 948 949 iter->base.oid = &iter->oid; 950 951 iter->flags = flags; 952 953if(prefix && *prefix) 954/* Stop iteration after we've gone *past* prefix: */ 955 ref_iterator =prefix_ref_iterator_begin(ref_iterator, prefix,0); 956 957return ref_iterator; 958} 959 960/* 961 * Write an entry to the packed-refs file for the specified refname. 962 * If peeled is non-NULL, write it as the entry's peeled value. On 963 * error, return a nonzero value and leave errno set at the value left 964 * by the failing call to `fprintf()`. 965 */ 966static intwrite_packed_entry(FILE*fh,const char*refname, 967const unsigned char*sha1, 968const unsigned char*peeled) 969{ 970if(fprintf(fh,"%s %s\n",sha1_to_hex(sha1), refname) <0|| 971(peeled &&fprintf(fh,"^%s\n",sha1_to_hex(peeled)) <0)) 972return-1; 973 974return0; 975} 976 977intpacked_refs_lock(struct ref_store *ref_store,int flags,struct strbuf *err) 978{ 979struct packed_ref_store *refs = 980packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN, 981"packed_refs_lock"); 982static int timeout_configured =0; 983static int timeout_value =1000; 984 985if(!timeout_configured) { 986git_config_get_int("core.packedrefstimeout", &timeout_value); 987 timeout_configured =1; 988} 989 990/* 991 * Note that we close the lockfile immediately because we 992 * don't write new content to it, but rather to a separate 993 * tempfile. 994 */ 995if(hold_lock_file_for_update_timeout( 996&refs->lock, 997 refs->path, 998 flags, timeout_value) <0) { 999unable_to_lock_message(refs->path, errno, err);1000return-1;1001}10021003if(close_lock_file_gently(&refs->lock)) {1004strbuf_addf(err,"unable to close%s:%s", refs->path,strerror(errno));1005rollback_lock_file(&refs->lock);1006return-1;1007}10081009/*1010 * Now that we hold the `packed-refs` lock, make sure that our1011 * snapshot matches the current version of the file. Normally1012 * `get_snapshot()` does that for us, but that function1013 * assumes that when the file is locked, any existing snapshot1014 * is still valid. We've just locked the file, but it might1015 * have changed the moment *before* we locked it.1016 */1017validate_snapshot(refs);10181019/*1020 * Now make sure that the packed-refs file as it exists in the1021 * locked state is loaded into the snapshot:1022 */1023get_snapshot(refs);1024return0;1025}10261027voidpacked_refs_unlock(struct ref_store *ref_store)1028{1029struct packed_ref_store *refs =packed_downcast(1030 ref_store,1031 REF_STORE_READ | REF_STORE_WRITE,1032"packed_refs_unlock");10331034if(!is_lock_file_locked(&refs->lock))1035die("BUG: packed_refs_unlock() called when not locked");1036rollback_lock_file(&refs->lock);1037}10381039intpacked_refs_is_locked(struct ref_store *ref_store)1040{1041struct packed_ref_store *refs =packed_downcast(1042 ref_store,1043 REF_STORE_READ | REF_STORE_WRITE,1044"packed_refs_is_locked");10451046returnis_lock_file_locked(&refs->lock);1047}10481049/*1050 * The packed-refs header line that we write out. Perhaps other traits1051 * will be added later.1052 *1053 * Note that earlier versions of Git used to parse these traits by1054 * looking for " trait " in the line. For this reason, the space after1055 * the colon and the trailing space are required.1056 */1057static const char PACKED_REFS_HEADER[] =1058"# pack-refs with: peeled fully-peeled sorted\n";10591060static intpacked_init_db(struct ref_store *ref_store,struct strbuf *err)1061{1062/* Nothing to do. */1063return0;1064}10651066/*1067 * Write the packed refs from the current snapshot to the packed-refs1068 * tempfile, incorporating any changes from `updates`. `updates` must1069 * be a sorted string list whose keys are the refnames and whose util1070 * values are `struct ref_update *`. On error, rollback the tempfile,1071 * write an error message to `err`, and return a nonzero value.1072 *1073 * The packfile must be locked before calling this function and will1074 * remain locked when it is done.1075 */1076static intwrite_with_updates(struct packed_ref_store *refs,1077struct string_list *updates,1078struct strbuf *err)1079{1080struct ref_iterator *iter = NULL;1081size_t i;1082int ok;1083FILE*out;1084struct strbuf sb = STRBUF_INIT;1085char*packed_refs_path;10861087if(!is_lock_file_locked(&refs->lock))1088die("BUG: write_with_updates() called while unlocked");10891090/*1091 * If packed-refs is a symlink, we want to overwrite the1092 * symlinked-to file, not the symlink itself. Also, put the1093 * staging file next to it:1094 */1095 packed_refs_path =get_locked_file_path(&refs->lock);1096strbuf_addf(&sb,"%s.new", packed_refs_path);1097free(packed_refs_path);1098 refs->tempfile =create_tempfile(sb.buf);1099if(!refs->tempfile) {1100strbuf_addf(err,"unable to create file%s:%s",1101 sb.buf,strerror(errno));1102strbuf_release(&sb);1103return-1;1104}1105strbuf_release(&sb);11061107 out =fdopen_tempfile(refs->tempfile,"w");1108if(!out) {1109strbuf_addf(err,"unable to fdopen packed-refs tempfile:%s",1110strerror(errno));1111goto error;1112}11131114if(fprintf(out,"%s", PACKED_REFS_HEADER) <0)1115goto write_error;11161117/*1118 * We iterate in parallel through the current list of refs and1119 * the list of updates, processing an entry from at least one1120 * of the lists each time through the loop. When the current1121 * list of refs is exhausted, set iter to NULL. When the list1122 * of updates is exhausted, leave i set to updates->nr.1123 */1124 iter =packed_ref_iterator_begin(&refs->base,"",1125 DO_FOR_EACH_INCLUDE_BROKEN);1126if((ok =ref_iterator_advance(iter)) != ITER_OK)1127 iter = NULL;11281129 i =0;11301131while(iter || i < updates->nr) {1132struct ref_update *update = NULL;1133int cmp;11341135if(i >= updates->nr) {1136 cmp = -1;1137}else{1138 update = updates->items[i].util;11391140if(!iter)1141 cmp = +1;1142else1143 cmp =strcmp(iter->refname, update->refname);1144}11451146if(!cmp) {1147/*1148 * There is both an old value and an update1149 * for this reference. Check the old value if1150 * necessary:1151 */1152if((update->flags & REF_HAVE_OLD)) {1153if(is_null_oid(&update->old_oid)) {1154strbuf_addf(err,"cannot update ref '%s': "1155"reference already exists",1156 update->refname);1157goto error;1158}else if(oidcmp(&update->old_oid, iter->oid)) {1159strbuf_addf(err,"cannot update ref '%s': "1160"is at%sbut expected%s",1161 update->refname,1162oid_to_hex(iter->oid),1163oid_to_hex(&update->old_oid));1164goto error;1165}1166}11671168/* Now figure out what to use for the new value: */1169if((update->flags & REF_HAVE_NEW)) {1170/*1171 * The update takes precedence. Skip1172 * the iterator over the unneeded1173 * value.1174 */1175if((ok =ref_iterator_advance(iter)) != ITER_OK)1176 iter = NULL;1177 cmp = +1;1178}else{1179/*1180 * The update doesn't actually want to1181 * change anything. We're done with it.1182 */1183 i++;1184 cmp = -1;1185}1186}else if(cmp >0) {1187/*1188 * There is no old value but there is an1189 * update for this reference. Make sure that1190 * the update didn't expect an existing value:1191 */1192if((update->flags & REF_HAVE_OLD) &&1193!is_null_oid(&update->old_oid)) {1194strbuf_addf(err,"cannot update ref '%s': "1195"reference is missing but expected%s",1196 update->refname,1197oid_to_hex(&update->old_oid));1198goto error;1199}1200}12011202if(cmp <0) {1203/* Pass the old reference through. */12041205struct object_id peeled;1206int peel_error =ref_iterator_peel(iter, &peeled);12071208if(write_packed_entry(out, iter->refname,1209 iter->oid->hash,1210 peel_error ? NULL : peeled.hash))1211goto write_error;12121213if((ok =ref_iterator_advance(iter)) != ITER_OK)1214 iter = NULL;1215}else if(is_null_oid(&update->new_oid)) {1216/*1217 * The update wants to delete the reference,1218 * and the reference either didn't exist or we1219 * have already skipped it. So we're done with1220 * the update (and don't have to write1221 * anything).1222 */1223 i++;1224}else{1225struct object_id peeled;1226int peel_error =peel_object(update->new_oid.hash,1227 peeled.hash);12281229if(write_packed_entry(out, update->refname,1230 update->new_oid.hash,1231 peel_error ? NULL : peeled.hash))1232goto write_error;12331234 i++;1235}1236}12371238if(ok != ITER_DONE) {1239strbuf_addstr(err,"unable to write packed-refs file: "1240"error iterating over old contents");1241goto error;1242}12431244if(close_tempfile_gently(refs->tempfile)) {1245strbuf_addf(err,"error closing file%s:%s",1246get_tempfile_path(refs->tempfile),1247strerror(errno));1248strbuf_release(&sb);1249delete_tempfile(&refs->tempfile);1250return-1;1251}12521253return0;12541255write_error:1256strbuf_addf(err,"error writing to%s:%s",1257get_tempfile_path(refs->tempfile),strerror(errno));12581259error:1260if(iter)1261ref_iterator_abort(iter);12621263delete_tempfile(&refs->tempfile);1264return-1;1265}12661267intis_packed_transaction_needed(struct ref_store *ref_store,1268struct ref_transaction *transaction)1269{1270struct packed_ref_store *refs =packed_downcast(1271 ref_store,1272 REF_STORE_READ,1273"is_packed_transaction_needed");1274struct strbuf referent = STRBUF_INIT;1275size_t i;1276int ret;12771278if(!is_lock_file_locked(&refs->lock))1279BUG("is_packed_transaction_needed() called while unlocked");12801281/*1282 * We're only going to bother returning false for the common,1283 * trivial case that references are only being deleted, their1284 * old values are not being checked, and the old `packed-refs`1285 * file doesn't contain any of those reference(s). This gives1286 * false positives for some other cases that could1287 * theoretically be optimized away:1288 *1289 * 1. It could be that the old value is being verified without1290 * setting a new value. In this case, we could verify the1291 * old value here and skip the update if it agrees. If it1292 * disagrees, we could either let the update go through1293 * (the actual commit would re-detect and report the1294 * problem), or come up with a way of reporting such an1295 * error to *our* caller.1296 *1297 * 2. It could be that a new value is being set, but that it1298 * is identical to the current packed value of the1299 * reference.1300 *1301 * Neither of these cases will come up in the current code,1302 * because the only caller of this function passes to it a1303 * transaction that only includes `delete` updates with no1304 * `old_id`. Even if that ever changes, false positives only1305 * cause an optimization to be missed; they do not affect1306 * correctness.1307 */13081309/*1310 * Start with the cheap checks that don't require old1311 * reference values to be read:1312 */1313for(i =0; i < transaction->nr; i++) {1314struct ref_update *update = transaction->updates[i];13151316if(update->flags & REF_HAVE_OLD)1317/* Have to check the old value -> needed. */1318return1;13191320if((update->flags & REF_HAVE_NEW) && !is_null_oid(&update->new_oid))1321/* Have to set a new value -> needed. */1322return1;1323}13241325/*1326 * The transaction isn't checking any old values nor is it1327 * setting any nonzero new values, so it still might be able1328 * to be skipped. Now do the more expensive check: the update1329 * is needed if any of the updates is a delete, and the old1330 * `packed-refs` file contains a value for that reference.1331 */1332 ret =0;1333for(i =0; i < transaction->nr; i++) {1334struct ref_update *update = transaction->updates[i];1335unsigned int type;1336struct object_id oid;13371338if(!(update->flags & REF_HAVE_NEW))1339/*1340 * This reference isn't being deleted -> not1341 * needed.1342 */1343continue;13441345if(!refs_read_raw_ref(ref_store, update->refname,1346 oid.hash, &referent, &type) ||1347 errno != ENOENT) {1348/*1349 * We have to actually delete that reference1350 * -> this transaction is needed.1351 */1352 ret =1;1353break;1354}1355}13561357strbuf_release(&referent);1358return ret;1359}13601361struct packed_transaction_backend_data {1362/* True iff the transaction owns the packed-refs lock. */1363int own_lock;13641365struct string_list updates;1366};13671368static voidpacked_transaction_cleanup(struct packed_ref_store *refs,1369struct ref_transaction *transaction)1370{1371struct packed_transaction_backend_data *data = transaction->backend_data;13721373if(data) {1374string_list_clear(&data->updates,0);13751376if(is_tempfile_active(refs->tempfile))1377delete_tempfile(&refs->tempfile);13781379if(data->own_lock &&is_lock_file_locked(&refs->lock)) {1380packed_refs_unlock(&refs->base);1381 data->own_lock =0;1382}13831384free(data);1385 transaction->backend_data = NULL;1386}13871388 transaction->state = REF_TRANSACTION_CLOSED;1389}13901391static intpacked_transaction_prepare(struct ref_store *ref_store,1392struct ref_transaction *transaction,1393struct strbuf *err)1394{1395struct packed_ref_store *refs =packed_downcast(1396 ref_store,1397 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1398"ref_transaction_prepare");1399struct packed_transaction_backend_data *data;1400size_t i;1401int ret = TRANSACTION_GENERIC_ERROR;14021403/*1404 * Note that we *don't* skip transactions with zero updates,1405 * because such a transaction might be executed for the side1406 * effect of ensuring that all of the references are peeled or1407 * ensuring that the `packed-refs` file is sorted. If the1408 * caller wants to optimize away empty transactions, it should1409 * do so itself.1410 */14111412 data =xcalloc(1,sizeof(*data));1413string_list_init(&data->updates,0);14141415 transaction->backend_data = data;14161417/*1418 * Stick the updates in a string list by refname so that we1419 * can sort them:1420 */1421for(i =0; i < transaction->nr; i++) {1422struct ref_update *update = transaction->updates[i];1423struct string_list_item *item =1424string_list_append(&data->updates, update->refname);14251426/* Store a pointer to update in item->util: */1427 item->util = update;1428}1429string_list_sort(&data->updates);14301431if(ref_update_reject_duplicates(&data->updates, err))1432goto failure;14331434if(!is_lock_file_locked(&refs->lock)) {1435if(packed_refs_lock(ref_store,0, err))1436goto failure;1437 data->own_lock =1;1438}14391440if(write_with_updates(refs, &data->updates, err))1441goto failure;14421443 transaction->state = REF_TRANSACTION_PREPARED;1444return0;14451446failure:1447packed_transaction_cleanup(refs, transaction);1448return ret;1449}14501451static intpacked_transaction_abort(struct ref_store *ref_store,1452struct ref_transaction *transaction,1453struct strbuf *err)1454{1455struct packed_ref_store *refs =packed_downcast(1456 ref_store,1457 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1458"ref_transaction_abort");14591460packed_transaction_cleanup(refs, transaction);1461return0;1462}14631464static intpacked_transaction_finish(struct ref_store *ref_store,1465struct ref_transaction *transaction,1466struct strbuf *err)1467{1468struct packed_ref_store *refs =packed_downcast(1469 ref_store,1470 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1471"ref_transaction_finish");1472int ret = TRANSACTION_GENERIC_ERROR;1473char*packed_refs_path;14741475clear_snapshot(refs);14761477 packed_refs_path =get_locked_file_path(&refs->lock);1478if(rename_tempfile(&refs->tempfile, packed_refs_path)) {1479strbuf_addf(err,"error replacing%s:%s",1480 refs->path,strerror(errno));1481goto cleanup;1482}14831484 ret =0;14851486cleanup:1487free(packed_refs_path);1488packed_transaction_cleanup(refs, transaction);1489return ret;1490}14911492static intpacked_initial_transaction_commit(struct ref_store *ref_store,1493struct ref_transaction *transaction,1494struct strbuf *err)1495{1496returnref_transaction_commit(transaction, err);1497}14981499static intpacked_delete_refs(struct ref_store *ref_store,const char*msg,1500struct string_list *refnames,unsigned int flags)1501{1502struct packed_ref_store *refs =1503packed_downcast(ref_store, REF_STORE_WRITE,"delete_refs");1504struct strbuf err = STRBUF_INIT;1505struct ref_transaction *transaction;1506struct string_list_item *item;1507int ret;15081509(void)refs;/* We need the check above, but don't use the variable */15101511if(!refnames->nr)1512return0;15131514/*1515 * Since we don't check the references' old_oids, the1516 * individual updates can't fail, so we can pack all of the1517 * updates into a single transaction.1518 */15191520 transaction =ref_store_transaction_begin(ref_store, &err);1521if(!transaction)1522return-1;15231524for_each_string_list_item(item, refnames) {1525if(ref_transaction_delete(transaction, item->string, NULL,1526 flags, msg, &err)) {1527warning(_("could not delete reference%s:%s"),1528 item->string, err.buf);1529strbuf_reset(&err);1530}1531}15321533 ret =ref_transaction_commit(transaction, &err);15341535if(ret) {1536if(refnames->nr ==1)1537error(_("could not delete reference%s:%s"),1538 refnames->items[0].string, err.buf);1539else1540error(_("could not delete references:%s"), err.buf);1541}15421543ref_transaction_free(transaction);1544strbuf_release(&err);1545return ret;1546}15471548static intpacked_pack_refs(struct ref_store *ref_store,unsigned int flags)1549{1550/*1551 * Packed refs are already packed. It might be that loose refs1552 * are packed *into* a packed refs store, but that is done by1553 * updating the packed references via a transaction.1554 */1555return0;1556}15571558static intpacked_create_symref(struct ref_store *ref_store,1559const char*refname,const char*target,1560const char*logmsg)1561{1562die("BUG: packed reference store does not support symrefs");1563}15641565static intpacked_rename_ref(struct ref_store *ref_store,1566const char*oldrefname,const char*newrefname,1567const char*logmsg)1568{1569die("BUG: packed reference store does not support renaming references");1570}15711572static intpacked_copy_ref(struct ref_store *ref_store,1573const char*oldrefname,const char*newrefname,1574const char*logmsg)1575{1576die("BUG: packed reference store does not support copying references");1577}15781579static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_store)1580{1581returnempty_ref_iterator_begin();1582}15831584static intpacked_for_each_reflog_ent(struct ref_store *ref_store,1585const char*refname,1586 each_reflog_ent_fn fn,void*cb_data)1587{1588return0;1589}15901591static intpacked_for_each_reflog_ent_reverse(struct ref_store *ref_store,1592const char*refname,1593 each_reflog_ent_fn fn,1594void*cb_data)1595{1596return0;1597}15981599static intpacked_reflog_exists(struct ref_store *ref_store,1600const char*refname)1601{1602return0;1603}16041605static intpacked_create_reflog(struct ref_store *ref_store,1606const char*refname,int force_create,1607struct strbuf *err)1608{1609die("BUG: packed reference store does not support reflogs");1610}16111612static intpacked_delete_reflog(struct ref_store *ref_store,1613const char*refname)1614{1615return0;1616}16171618static intpacked_reflog_expire(struct ref_store *ref_store,1619const char*refname,const unsigned char*sha1,1620unsigned int flags,1621 reflog_expiry_prepare_fn prepare_fn,1622 reflog_expiry_should_prune_fn should_prune_fn,1623 reflog_expiry_cleanup_fn cleanup_fn,1624void*policy_cb_data)1625{1626return0;1627}16281629struct ref_storage_be refs_be_packed = {1630 NULL,1631"packed",1632 packed_ref_store_create,1633 packed_init_db,1634 packed_transaction_prepare,1635 packed_transaction_finish,1636 packed_transaction_abort,1637 packed_initial_transaction_commit,16381639 packed_pack_refs,1640 packed_create_symref,1641 packed_delete_refs,1642 packed_rename_ref,1643 packed_copy_ref,16441645 packed_ref_iterator_begin,1646 packed_read_raw_ref,16471648 packed_reflog_iterator_begin,1649 packed_for_each_reflog_ent,1650 packed_for_each_reflog_ent_reverse,1651 packed_reflog_exists,1652 packed_create_reflog,1653 packed_delete_reflog,1654 packed_reflog_expire1655};