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 */ 65 struct packed_ref_store *refs; 66 67 /* Is the `packed-refs` file currently mmapped? */ 68 int 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 */ 85 char *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 */ 92 enum { 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 */ 100 unsigned 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 */ 107 struct 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 { 126 struct ref_store base; 127 128 unsigned int store_flags; 129 130 /* The path of the "packed-refs" file: */ 131 char *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 */ 137 struct 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 */ 143 struct 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 */ 150 struct tempfile *tempfile; 151}; 152 153/* 154 * Increment the reference count of `*snapshot`. 155 */ 156static void acquire_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 void clear_snapshot_buffer(struct snapshot *snapshot) 167{ 168 if (snapshot->mmapped) { 169 if (munmap(snapshot->buf, snapshot->eof - snapshot->buf)) 170 die_errno("error ummapping packed-refs file %s", 171 snapshot->refs->path); 172 snapshot->mmapped = 0; 173 } else { 174 free(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 int release_snapshot(struct snapshot *snapshot) 184{ 185 if (!--snapshot->referrers) { 186 stat_validity_clear(&snapshot->validity); 187 clear_snapshot_buffer(snapshot); 188 free(snapshot); 189 return 1; 190 } else { 191 return 0; 192 } 193} 194 195struct ref_store *packed_ref_store_create(const char *path, 196 unsigned int store_flags) 197{ 198 struct packed_ref_store *refs = xcalloc(1, sizeof(*refs)); 199 struct ref_store *ref_store = (struct ref_store *)refs; 200 201 base_ref_store_init(ref_store, &refs_be_packed); 202 refs->store_flags = store_flags; 203 204 refs->path = xstrdup(path); 205 return 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, 215 unsigned int required_flags, 216 const char *caller) 217{ 218 struct packed_ref_store *refs; 219 220 if (ref_store->be != &refs_be_packed) 221 die("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 226 if ((refs->store_flags & required_flags) != required_flags) 227 die("BUG: unallowed operation (%s), requires %x, has %x\n", 228 caller, required_flags, refs->store_flags); 229 230 return refs; 231} 232 233static void clear_snapshot(struct packed_ref_store *refs) 234{ 235 if (refs->snapshot) { 236 struct snapshot *snapshot = refs->snapshot; 237 238 refs->snapshot = NULL; 239 release_snapshot(snapshot); 240 } 241} 242 243static NORETURN void die_unterminated_line(const char *path, 244 const char *p, size_t len) 245{ 246 if (len < 80) 247 die("unterminated line in %s: %.*s", path, (int)len, p); 248 else 249 die("unterminated line in %s: %.75s...", path, p); 250} 251 252static NORETURN void die_invalid_line(const char *path, 253 const char *p, size_t len) 254{ 255 const char *eol = memchr(p, '\n', len); 256 257 if (!eol) 258 die_unterminated_line(path, p, len); 259 else if (eol - p < 80) 260 die("unexpected line in %s: %.*s", path, (int)(eol - p), p); 261 else 262 die("unexpected line in %s: %.75s...", path, p); 263 264} 265 266struct snapshot_record { 267 const char *start; 268 size_t len; 269}; 270 271static int cmp_packed_ref_records(const void *v1, const void *v2) 272{ 273 const struct snapshot_record *e1 = v1, *e2 = v2; 274 const char *r1 = e1->start + GIT_SHA1_HEXSZ + 1; 275 const char *r2 = e2->start + GIT_SHA1_HEXSZ + 1; 276 277 while (1) { 278 if (*r1 == '\n') 279 return *r2 == '\n' ? 0 : -1; 280 if (*r1 != *r2) { 281 if (*r2 == '\n') 282 return 1; 283 else 284 return (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 int cmp_record_to_refname(const char *rec, const char *refname) 296{ 297 const char *r1 = rec + GIT_SHA1_HEXSZ + 1; 298 const char *r2 = refname; 299 300 while (1) { 301 if (*r1 == '\n') 302 return *r2 ? -1 : 0; 303 if (!*r2) 304 return 1; 305 if (*r1 != *r2) 306 return (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 void sort_snapshot(struct snapshot *snapshot) 317{ 318 struct snapshot_record *records = NULL; 319 size_t alloc = 0, nr = 0; 320 int sorted = 1; 321 const char *pos, *eof, *eol; 322 size_t len, i; 323 char *new_buffer, *dst; 324 325 pos = snapshot->start; 326 eof = snapshot->eof; 327 328 if (pos == eof) 329 return; 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 */ 337 ALLOC_GROW(records, len / 80 + 20, alloc); 338 339 while (pos < eof) { 340 eol = memchr(pos, '\n', eof - pos); 341 if (!eol) 342 /* The safety check should prevent this. */ 343 BUG("unterminated line found in packed-refs"); 344 if (eol - pos < GIT_SHA1_HEXSZ + 2) 345 die_invalid_line(snapshot->refs->path, 346 pos, eof - pos); 347 eol++; 348 if (eol < eof && *eol == '^') { 349 /* 350 * Keep any peeled line together with its 351 * reference: 352 */ 353 const char *peeled_start = eol; 354 355 eol = memchr(peeled_start, '\n', eof - peeled_start); 356 if (!eol) 357 /* The safety check should prevent this. */ 358 BUG("unterminated peeled line found in packed-refs"); 359 eol++; 360 } 361 362 ALLOC_GROW(records, nr + 1, alloc); 363 records[nr].start = pos; 364 records[nr].len = eol - pos; 365 nr++; 366 367 if (sorted && 368 nr > 1 && 369 cmp_packed_ref_records(&records[nr - 2], 370 &records[nr - 1]) >= 0) 371 sorted = 0; 372 373 pos = eol; 374 } 375 376 if (sorted) 377 goto cleanup; 378 379 /* We need to sort the memory. First we sort the records array: */ 380 QSORT(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); 388 for (dst = new_buffer, i = 0; i < nr; i++) { 389 memcpy(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 */ 397 clear_snapshot_buffer(snapshot); 398 snapshot->buf = snapshot->start = new_buffer; 399 snapshot->eof = new_buffer + len; 400 401cleanup: 402 free(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{ 412 while (p > buf && (p[-1] != '\n' || p[0] == '^')) 413 p--; 414 return 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{ 423 while (++p < end && (p[-1] != '\n' || p[0] == '^')) 424 ; 425 return 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 void verify_buffer_safe(struct snapshot *snapshot) 447{ 448 const char *start = snapshot->start; 449 const char *eof = snapshot->eof; 450 const char *last_line; 451 452 if (start == eof) 453 return; 454 455 last_line = find_start_of_record(start, eof - 1); 456 if (*(eof - 1) != '\n' || eof - last_line < GIT_SHA1_HEXSZ + 2) 457 die_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 int load_contents(struct snapshot *snapshot) 467{ 468 int fd; 469 struct stat st; 470 size_t size; 471 ssize_t bytes_read; 472 473 fd = open(snapshot->refs->path, O_RDONLY); 474 if (fd < 0) { 475 if (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 */ 483 return 0; 484 } else { 485 die_errno("couldn't read %s", snapshot->refs->path); 486 } 487 } 488 489 stat_validity_update(&snapshot->validity, fd); 490 491 if (fstat(fd, &st) < 0) 492 die_errno("couldn't stat %s", snapshot->refs->path); 493 size = xsize_t(st.st_size); 494 495 switch (mmap_strategy) { 496 case MMAP_NONE: 497 snapshot->buf = xmalloc(size); 498 bytes_read = read_in_full(fd, snapshot->buf, size); 499 if (bytes_read < 0 || bytes_read != size) 500 die_errno("couldn't read %s", snapshot->refs->path); 501 snapshot->mmapped = 0; 502 break; 503 case MMAP_TEMPORARY: 504 case MMAP_OK: 505 snapshot->buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); 506 snapshot->mmapped = 1; 507 break; 508 } 509 close(fd); 510 511 snapshot->start = snapshot->buf; 512 snapshot->eof = snapshot->buf + size; 513 514 return 1; 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, 532 const 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 */ 548 const 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 */ 554 const char *hi = snapshot->eof; 555 556 while (lo != hi) { 557 const char *mid, *rec; 558 int cmp; 559 560 mid = lo + (hi - lo) / 2; 561 rec = find_start_of_record(lo, mid); 562 cmp = cmp_record_to_refname(rec, refname); 563 if (cmp < 0) { 564 lo = find_end_of_record(mid, hi); 565 } else if (cmp > 0) { 566 hi = rec; 567 } else { 568 return rec; 569 } 570 } 571 572 if (mustexist) 573 return NULL; 574 else 575 return 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{ 613 struct snapshot *snapshot = xcalloc(1, sizeof(*snapshot)); 614 int sorted = 0; 615 616 snapshot->refs = refs; 617 acquire_snapshot(snapshot); 618 snapshot->peeled = PEELED_NONE; 619 620 if (!load_contents(snapshot)) 621 return snapshot; 622 623 /* If the file has a header line, process it: */ 624 if (snapshot->buf < snapshot->eof && *snapshot->buf == '#') { 625 char *tmp, *p, *eol; 626 struct string_list traits = STRING_LIST_INIT_NODUP; 627 628 eol = memchr(snapshot->buf, '\n', 629 snapshot->eof - snapshot->buf); 630 if (!eol) 631 die_unterminated_line(refs->path, 632 snapshot->buf, 633 snapshot->eof - snapshot->buf); 634 635 tmp = xmemdupz(snapshot->buf, eol - snapshot->buf); 636 637 if (!skip_prefix(tmp, "# pack-refs with:", (const char **)&p)) 638 die_invalid_line(refs->path, 639 snapshot->buf, 640 snapshot->eof - snapshot->buf); 641 642 string_list_split_in_place(&traits, p, ' ', -1); 643 644 if (unsorted_string_list_has_string(&traits, "fully-peeled")) 645 snapshot->peeled = PEELED_FULLY; 646 else 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 656 string_list_clear(&traits, 0); 657 free(tmp); 658 } 659 660 verify_buffer_safe(snapshot); 661 662 if (!sorted) { 663 sort_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 */ 670 verify_buffer_safe(snapshot); 671 } 672 673 if (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 */ 678 size_t size = snapshot->eof - snapshot->start; 679 char *buf_copy = xmalloc(size); 680 681 memcpy(buf_copy, snapshot->start, size); 682 clear_snapshot_buffer(snapshot); 683 snapshot->buf = snapshot->start = buf_copy; 684 snapshot->eof = buf_copy + size; 685 } 686 687 return 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 void validate_snapshot(struct packed_ref_store *refs) 695{ 696 if (refs->snapshot && 697 !stat_validity_check(&refs->snapshot->validity, refs->path)) 698 clear_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{ 712 if (!is_lock_file_locked(&refs->lock)) 713 validate_snapshot(refs); 714 715 if (!refs->snapshot) 716 refs->snapshot = create_snapshot(refs); 717 718 return refs->snapshot; 719} 720 721static int packed_read_raw_ref(struct ref_store *ref_store, 722 const char *refname, unsigned char *sha1, 723 struct strbuf *referent, unsigned int *type) 724{ 725 struct packed_ref_store *refs = 726 packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref"); 727 struct snapshot *snapshot = get_snapshot(refs); 728 const char *rec; 729 730 *type = 0; 731 732 rec = find_reference_location(snapshot, refname, 1); 733 734 if (!rec) { 735 /* refname is not a packed reference. */ 736 errno = ENOENT; 737 return -1; 738 } 739 740 if (get_sha1_hex(rec, sha1)) 741 die_invalid_line(refs->path, rec, snapshot->eof - rec); 742 743 *type = REF_ISPACKED; 744 return 0; 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 { 759 struct ref_iterator base; 760 761 struct snapshot *snapshot; 762 763 /* The current position in the snapshot's buffer: */ 764 const char *pos; 765 766 /* The end of the part of the buffer that will be iterated over: */ 767 const char *eof; 768 769 /* Scratch space for current values: */ 770 struct object_id oid, peeled; 771 struct strbuf refname_buf; 772 773 unsigned 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 int next_record(struct packed_ref_iterator *iter) 784{ 785 const char *p = iter->pos, *eol; 786 787 strbuf_reset(&iter->refname_buf); 788 789 if (iter->pos == iter->eof) 790 return ITER_DONE; 791 792 iter->base.flags = REF_ISPACKED; 793 794 if (iter->eof - p < GIT_SHA1_HEXSZ + 2 || 795 parse_oid_hex(p, &iter->oid, &p) || 796 !isspace(*p++)) 797 die_invalid_line(iter->snapshot->refs->path, 798 iter->pos, iter->eof - iter->pos); 799 800 eol = memchr(p, '\n', iter->eof - p); 801 if (!eol) 802 die_unterminated_line(iter->snapshot->refs->path, 803 iter->pos, iter->eof - iter->pos); 804 805 strbuf_add(&iter->refname_buf, p, eol - p); 806 iter->base.refname = iter->refname_buf.buf; 807 808 if (check_refname_format(iter->base.refname, REFNAME_ALLOW_ONELEVEL)) { 809 if (!refname_is_safe(iter->base.refname)) 810 die("packed refname is dangerous: %s", 811 iter->base.refname); 812 oidclr(&iter->oid); 813 iter->base.flags |= REF_BAD_NAME | REF_ISBROKEN; 814 } 815 if (iter->snapshot->peeled == PEELED_FULLY || 816 (iter->snapshot->peeled == PEELED_TAGS && 817 starts_with(iter->base.refname, "refs/tags/"))) 818 iter->base.flags |= REF_KNOWS_PEELED; 819 820 iter->pos = eol + 1; 821 822 if (iter->pos < iter->eof && *iter->pos == '^') { 823 p = iter->pos + 1; 824 if (iter->eof - p < GIT_SHA1_HEXSZ + 1 || 825 parse_oid_hex(p, &iter->peeled, &p) || 826 *p++ != '\n') 827 die_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 */ 836 if ((iter->base.flags & REF_ISBROKEN)) { 837 oidclr(&iter->peeled); 838 iter->base.flags &= ~REF_KNOWS_PEELED; 839 } else { 840 iter->base.flags |= REF_KNOWS_PEELED; 841 } 842 } else { 843 oidclr(&iter->peeled); 844 } 845 846 return ITER_OK; 847} 848 849static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator) 850{ 851 struct packed_ref_iterator *iter = 852 (struct packed_ref_iterator *)ref_iterator; 853 int ok; 854 855 while ((ok = next_record(iter)) == ITER_OK) { 856 if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY && 857 ref_type(iter->base.refname) != REF_TYPE_PER_WORKTREE) 858 continue; 859 860 if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 861 !ref_resolves_to_object(iter->base.refname, &iter->oid, 862 iter->flags)) 863 continue; 864 865 return ITER_OK; 866 } 867 868 if (ref_iterator_abort(ref_iterator) != ITER_DONE) 869 ok = ITER_ERROR; 870 871 return ok; 872} 873 874static int packed_ref_iterator_peel(struct ref_iterator *ref_iterator, 875 struct object_id *peeled) 876{ 877 struct packed_ref_iterator *iter = 878 (struct packed_ref_iterator *)ref_iterator; 879 880 if ((iter->base.flags & REF_KNOWS_PEELED)) { 881 oidcpy(peeled, &iter->peeled); 882 return is_null_oid(&iter->peeled) ? -1 : 0; 883 } else if ((iter->base.flags & (REF_ISBROKEN | REF_ISSYMREF))) { 884 return -1; 885 } else { 886 return !!peel_object(iter->oid.hash, peeled->hash); 887 } 888} 889 890static int packed_ref_iterator_abort(struct ref_iterator *ref_iterator) 891{ 892 struct packed_ref_iterator *iter = 893 (struct packed_ref_iterator *)ref_iterator; 894 int ok = ITER_DONE; 895 896 strbuf_release(&iter->refname_buf); 897 release_snapshot(iter->snapshot); 898 base_ref_iterator_free(ref_iterator); 899 return 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( 909 struct ref_store *ref_store, 910 const char *prefix, unsigned int flags) 911{ 912 struct packed_ref_store *refs; 913 struct snapshot *snapshot; 914 const char *start; 915 struct packed_ref_iterator *iter; 916 struct ref_iterator *ref_iterator; 917 unsigned int required_flags = REF_STORE_READ; 918 919 if (!(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 930 if (!snapshot->buf) 931 return empty_ref_iterator_begin(); 932 933 iter = xcalloc(1, sizeof(*iter)); 934 ref_iterator = &iter->base; 935 base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable, 1); 936 937 iter->snapshot = snapshot; 938 acquire_snapshot(snapshot); 939 940 if (prefix && *prefix) 941 start = find_reference_location(snapshot, prefix, 0); 942 else 943 start = snapshot->start; 944 945 iter->pos = start; 946 iter->eof = snapshot->eof; 947 strbuf_init(&iter->refname_buf, 0); 948 949 iter->base.oid = &iter->oid; 950 951 iter->flags = flags; 952 953 if (prefix && *prefix) 954 /* Stop iteration after we've gone *past* prefix: */ 955 ref_iterator = prefix_ref_iterator_begin(ref_iterator, prefix, 0); 956 957 return 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 int write_packed_entry(FILE *fh, const char *refname, 967 const unsigned char *sha1, 968 const unsigned char *peeled) 969{ 970 if (fprintf(fh, "%s %s\n", sha1_to_hex(sha1), refname) < 0 || 971 (peeled && fprintf(fh, "^%s\n", sha1_to_hex(peeled)) < 0)) 972 return -1; 973 974 return 0; 975} 976 977int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err) 978{ 979 struct packed_ref_store *refs = 980 packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN, 981 "packed_refs_lock"); 982 static int timeout_configured = 0; 983 static int timeout_value = 1000; 984 985 if (!timeout_configured) { 986 git_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 */ 995 if (hold_lock_file_for_update_timeout( 996 &refs->lock, 997 refs->path, 998 flags, timeout_value) < 0) { 999 unable_to_lock_message(refs->path, errno, err);1000 return -1;1001 }10021003 if (close_lock_file_gently(&refs->lock)) {1004 strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno));1005 rollback_lock_file(&refs->lock);1006 return -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 */1017 validate_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 */1023 get_snapshot(refs);1024 return 0;1025}10261027void packed_refs_unlock(struct ref_store *ref_store)1028{1029 struct packed_ref_store *refs = packed_downcast(1030 ref_store,1031 REF_STORE_READ | REF_STORE_WRITE,1032 "packed_refs_unlock");10331034 if (!is_lock_file_locked(&refs->lock))1035 die("BUG: packed_refs_unlock() called when not locked");1036 rollback_lock_file(&refs->lock);1037}10381039int packed_refs_is_locked(struct ref_store *ref_store)1040{1041 struct packed_ref_store *refs = packed_downcast(1042 ref_store,1043 REF_STORE_READ | REF_STORE_WRITE,1044 "packed_refs_is_locked");10451046 return is_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 int packed_init_db(struct ref_store *ref_store, struct strbuf *err)1061{1062 /* Nothing to do. */1063 return 0;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 int write_with_updates(struct packed_ref_store *refs,1077 struct string_list *updates,1078 struct strbuf *err)1079{1080 struct ref_iterator *iter = NULL;1081 size_t i;1082 int ok;1083 FILE *out;1084 struct strbuf sb = STRBUF_INIT;1085 char *packed_refs_path;10861087 if (!is_lock_file_locked(&refs->lock))1088 die("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);1096 strbuf_addf(&sb, "%s.new", packed_refs_path);1097 free(packed_refs_path);1098 refs->tempfile = create_tempfile(sb.buf);1099 if (!refs->tempfile) {1100 strbuf_addf(err, "unable to create file %s: %s",1101 sb.buf, strerror(errno));1102 strbuf_release(&sb);1103 return -1;1104 }1105 strbuf_release(&sb);11061107 out = fdopen_tempfile(refs->tempfile, "w");1108 if (!out) {1109 strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s",1110 strerror(errno));1111 goto error;1112 }11131114 if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0)1115 goto 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);1126 if ((ok = ref_iterator_advance(iter)) != ITER_OK)1127 iter = NULL;11281129 i = 0;11301131 while (iter || i < updates->nr) {1132 struct ref_update *update = NULL;1133 int cmp;11341135 if (i >= updates->nr) {1136 cmp = -1;1137 } else {1138 update = updates->items[i].util;11391140 if (!iter)1141 cmp = +1;1142 else1143 cmp = strcmp(iter->refname, update->refname);1144 }11451146 if (!cmp) {1147 /*1148 * There is both an old value and an update1149 * for this reference. Check the old value if1150 * necessary:1151 */1152 if ((update->flags & REF_HAVE_OLD)) {1153 if (is_null_oid(&update->old_oid)) {1154 strbuf_addf(err, "cannot update ref '%s': "1155 "reference already exists",1156 update->refname);1157 goto error;1158 } else if (oidcmp(&update->old_oid, iter->oid)) {1159 strbuf_addf(err, "cannot update ref '%s': "1160 "is at %s but expected %s",1161 update->refname,1162 oid_to_hex(iter->oid),1163 oid_to_hex(&update->old_oid));1164 goto error;1165 }1166 }11671168 /* Now figure out what to use for the new value: */1169 if ((update->flags & REF_HAVE_NEW)) {1170 /*1171 * The update takes precedence. Skip1172 * the iterator over the unneeded1173 * value.1174 */1175 if ((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 */1192 if ((update->flags & REF_HAVE_OLD) &&1193 !is_null_oid(&update->old_oid)) {1194 strbuf_addf(err, "cannot update ref '%s': "1195 "reference is missing but expected %s",1196 update->refname,1197 oid_to_hex(&update->old_oid));1198 goto error;1199 }1200 }12011202 if (cmp < 0) {1203 /* Pass the old reference through. */12041205 struct object_id peeled;1206 int peel_error = ref_iterator_peel(iter, &peeled);12071208 if (write_packed_entry(out, iter->refname,1209 iter->oid->hash,1210 peel_error ? NULL : peeled.hash))1211 goto write_error;12121213 if ((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 {1225 struct object_id peeled;1226 int peel_error = peel_object(update->new_oid.hash,1227 peeled.hash);12281229 if (write_packed_entry(out, update->refname,1230 update->new_oid.hash,1231 peel_error ? NULL : peeled.hash))1232 goto write_error;12331234 i++;1235 }1236 }12371238 if (ok != ITER_DONE) {1239 strbuf_addstr(err, "unable to write packed-refs file: "1240 "error iterating over old contents");1241 goto error;1242 }12431244 if (close_tempfile_gently(refs->tempfile)) {1245 strbuf_addf(err, "error closing file %s: %s",1246 get_tempfile_path(refs->tempfile),1247 strerror(errno));1248 strbuf_release(&sb);1249 delete_tempfile(&refs->tempfile);1250 return -1;1251 }12521253 return 0;12541255write_error:1256 strbuf_addf(err, "error writing to %s: %s",1257 get_tempfile_path(refs->tempfile), strerror(errno));12581259error:1260 if (iter)1261 ref_iterator_abort(iter);12621263 delete_tempfile(&refs->tempfile);1264 return -1;1265}12661267int is_packed_transaction_needed(struct ref_store *ref_store,1268 struct ref_transaction *transaction)1269{1270 struct packed_ref_store *refs = packed_downcast(1271 ref_store,1272 REF_STORE_READ,1273 "is_packed_transaction_needed");1274 struct strbuf referent = STRBUF_INIT;1275 size_t i;1276 int ret;12771278 if (!is_lock_file_locked(&refs->lock))1279 BUG("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 */1313 for (i = 0; i < transaction->nr; i++) {1314 struct ref_update *update = transaction->updates[i];13151316 if (update->flags & REF_HAVE_OLD)1317 /* Have to check the old value -> needed. */1318 return 1;13191320 if ((update->flags & REF_HAVE_NEW) && !is_null_oid(&update->new_oid))1321 /* Have to set a new value -> needed. */1322 return 1;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;1333 for (i = 0; i < transaction->nr; i++) {1334 struct ref_update *update = transaction->updates[i];1335 unsigned int type;1336 struct object_id oid;13371338 if (!(update->flags & REF_HAVE_NEW))1339 /*1340 * This reference isn't being deleted -> not1341 * needed.1342 */1343 continue;13441345 if (!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;1353 break;1354 }1355 }13561357 strbuf_release(&referent);1358 return ret;1359}13601361struct packed_transaction_backend_data {1362 /* True iff the transaction owns the packed-refs lock. */1363 int own_lock;13641365 struct string_list updates;1366};13671368static void packed_transaction_cleanup(struct packed_ref_store *refs,1369 struct ref_transaction *transaction)1370{1371 struct packed_transaction_backend_data *data = transaction->backend_data;13721373 if (data) {1374 string_list_clear(&data->updates, 0);13751376 if (is_tempfile_active(refs->tempfile))1377 delete_tempfile(&refs->tempfile);13781379 if (data->own_lock && is_lock_file_locked(&refs->lock)) {1380 packed_refs_unlock(&refs->base);1381 data->own_lock = 0;1382 }13831384 free(data);1385 transaction->backend_data = NULL;1386 }13871388 transaction->state = REF_TRANSACTION_CLOSED;1389}13901391static int packed_transaction_prepare(struct ref_store *ref_store,1392 struct ref_transaction *transaction,1393 struct strbuf *err)1394{1395 struct packed_ref_store *refs = packed_downcast(1396 ref_store,1397 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1398 "ref_transaction_prepare");1399 struct packed_transaction_backend_data *data;1400 size_t i;1401 int 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));1413 string_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 */1421 for (i = 0; i < transaction->nr; i++) {1422 struct ref_update *update = transaction->updates[i];1423 struct string_list_item *item =1424 string_list_append(&data->updates, update->refname);14251426 /* Store a pointer to update in item->util: */1427 item->util = update;1428 }1429 string_list_sort(&data->updates);14301431 if (ref_update_reject_duplicates(&data->updates, err))1432 goto failure;14331434 if (!is_lock_file_locked(&refs->lock)) {1435 if (packed_refs_lock(ref_store, 0, err))1436 goto failure;1437 data->own_lock = 1;1438 }14391440 if (write_with_updates(refs, &data->updates, err))1441 goto failure;14421443 transaction->state = REF_TRANSACTION_PREPARED;1444 return 0;14451446failure:1447 packed_transaction_cleanup(refs, transaction);1448 return ret;1449}14501451static int packed_transaction_abort(struct ref_store *ref_store,1452 struct ref_transaction *transaction,1453 struct strbuf *err)1454{1455 struct packed_ref_store *refs = packed_downcast(1456 ref_store,1457 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1458 "ref_transaction_abort");14591460 packed_transaction_cleanup(refs, transaction);1461 return 0;1462}14631464static int packed_transaction_finish(struct ref_store *ref_store,1465 struct ref_transaction *transaction,1466 struct strbuf *err)1467{1468 struct packed_ref_store *refs = packed_downcast(1469 ref_store,1470 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1471 "ref_transaction_finish");1472 int ret = TRANSACTION_GENERIC_ERROR;1473 char *packed_refs_path;14741475 clear_snapshot(refs);14761477 packed_refs_path = get_locked_file_path(&refs->lock);1478 if (rename_tempfile(&refs->tempfile, packed_refs_path)) {1479 strbuf_addf(err, "error replacing %s: %s",1480 refs->path, strerror(errno));1481 goto cleanup;1482 }14831484 ret = 0;14851486cleanup:1487 free(packed_refs_path);1488 packed_transaction_cleanup(refs, transaction);1489 return ret;1490}14911492static int packed_initial_transaction_commit(struct ref_store *ref_store,1493 struct ref_transaction *transaction,1494 struct strbuf *err)1495{1496 return ref_transaction_commit(transaction, err);1497}14981499static int packed_delete_refs(struct ref_store *ref_store, const char *msg,1500 struct string_list *refnames, unsigned int flags)1501{1502 struct packed_ref_store *refs =1503 packed_downcast(ref_store, REF_STORE_WRITE, "delete_refs");1504 struct strbuf err = STRBUF_INIT;1505 struct ref_transaction *transaction;1506 struct string_list_item *item;1507 int ret;15081509 (void)refs; /* We need the check above, but don't use the variable */15101511 if (!refnames->nr)1512 return 0;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);1521 if (!transaction)1522 return -1;15231524 for_each_string_list_item(item, refnames) {1525 if (ref_transaction_delete(transaction, item->string, NULL,1526 flags, msg, &err)) {1527 warning(_("could not delete reference %s: %s"),1528 item->string, err.buf);1529 strbuf_reset(&err);1530 }1531 }15321533 ret = ref_transaction_commit(transaction, &err);15341535 if (ret) {1536 if (refnames->nr == 1)1537 error(_("could not delete reference %s: %s"),1538 refnames->items[0].string, err.buf);1539 else1540 error(_("could not delete references: %s"), err.buf);1541 }15421543 ref_transaction_free(transaction);1544 strbuf_release(&err);1545 return ret;1546}15471548static int packed_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 */1555 return 0;1556}15571558static int packed_create_symref(struct ref_store *ref_store,1559 const char *refname, const char *target,1560 const char *logmsg)1561{1562 die("BUG: packed reference store does not support symrefs");1563}15641565static int packed_rename_ref(struct ref_store *ref_store,1566 const char *oldrefname, const char *newrefname,1567 const char *logmsg)1568{1569 die("BUG: packed reference store does not support renaming references");1570}15711572static int packed_copy_ref(struct ref_store *ref_store,1573 const char *oldrefname, const char *newrefname,1574 const char *logmsg)1575{1576 die("BUG: packed reference store does not support copying references");1577}15781579static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_store)1580{1581 return empty_ref_iterator_begin();1582}15831584static int packed_for_each_reflog_ent(struct ref_store *ref_store,1585 const char *refname,1586 each_reflog_ent_fn fn, void *cb_data)1587{1588 return 0;1589}15901591static int packed_for_each_reflog_ent_reverse(struct ref_store *ref_store,1592 const char *refname,1593 each_reflog_ent_fn fn,1594 void *cb_data)1595{1596 return 0;1597}15981599static int packed_reflog_exists(struct ref_store *ref_store,1600 const char *refname)1601{1602 return 0;1603}16041605static int packed_create_reflog(struct ref_store *ref_store,1606 const char *refname, int force_create,1607 struct strbuf *err)1608{1609 die("BUG: packed reference store does not support reflogs");1610}16111612static int packed_delete_reflog(struct ref_store *ref_store,1613 const char *refname)1614{1615 return 0;1616}16171618static int packed_reflog_expire(struct ref_store *ref_store,1619 const char *refname, const unsigned char *sha1,1620 unsigned 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,1624 void *policy_cb_data)1625{1626 return 0;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};