1#include "../cache.h" 2#include "../config.h" 3#include "../refs.h" 4#include "refs-internal.h" 5#include "ref-cache.h" 6#include "packed-backend.h" 7#include "../iterator.h" 8#include "../dir-iterator.h" 9#include "../lockfile.h" 10#include "../object.h" 11#include "../dir.h" 12 13/* 14 * This backend uses the following flags in `ref_update::flags` for 15 * internal bookkeeping purposes. Their numerical values must not 16 * conflict with REF_NO_DEREF, REF_FORCE_CREATE_REFLOG, REF_HAVE_NEW, 17 * REF_HAVE_OLD, or REF_IS_PRUNING, which are also stored in 18 * `ref_update::flags`. 19 */ 20 21/* 22 * Used as a flag in ref_update::flags when a loose ref is being 23 * pruned. This flag must only be used when REF_NO_DEREF is set. 24 */ 25#define REF_IS_PRUNING (1 << 4) 26 27/* 28 * Flag passed to lock_ref_sha1_basic() telling it to tolerate broken 29 * refs (i.e., because the reference is about to be deleted anyway). 30 */ 31#define REF_DELETING (1 << 5) 32 33/* 34 * Used as a flag in ref_update::flags when the lockfile needs to be 35 * committed. 36 */ 37#define REF_NEEDS_COMMIT (1 << 6) 38 39/* 40 * Used as a flag in ref_update::flags when we want to log a ref 41 * update but not actually perform it. This is used when a symbolic 42 * ref update is split up. 43 */ 44#define REF_LOG_ONLY (1 << 7) 45 46/* 47 * Used as a flag in ref_update::flags when the ref_update was via an 48 * update to HEAD. 49 */ 50#define REF_UPDATE_VIA_HEAD (1 << 8) 51 52/* 53 * Used as a flag in ref_update::flags when the loose reference has 54 * been deleted. 55 */ 56#define REF_DELETED_LOOSE (1 << 9) 57 58struct ref_lock { 59 char *ref_name; 60 struct lock_file lk; 61 struct object_id old_oid; 62}; 63 64/* 65 * Future: need to be in "struct repository" 66 * when doing a full libification. 67 */ 68struct files_ref_store { 69 struct ref_store base; 70 unsigned int store_flags; 71 72 char *gitdir; 73 char *gitcommondir; 74 75 struct ref_cache *loose; 76 77 struct ref_store *packed_ref_store; 78}; 79 80static void clear_loose_ref_cache(struct files_ref_store *refs) 81{ 82 if (refs->loose) { 83 free_ref_cache(refs->loose); 84 refs->loose = NULL; 85 } 86} 87 88/* 89 * Create a new submodule ref cache and add it to the internal 90 * set of caches. 91 */ 92static struct ref_store *files_ref_store_create(const char *gitdir, 93 unsigned int flags) 94{ 95 struct files_ref_store *refs = xcalloc(1, sizeof(*refs)); 96 struct ref_store *ref_store = (struct ref_store *)refs; 97 struct strbuf sb = STRBUF_INIT; 98 99 base_ref_store_init(ref_store, &refs_be_files); 100 refs->store_flags = flags; 101 102 refs->gitdir = xstrdup(gitdir); 103 get_common_dir_noenv(&sb, gitdir); 104 refs->gitcommondir = strbuf_detach(&sb, NULL); 105 strbuf_addf(&sb, "%s/packed-refs", refs->gitcommondir); 106 refs->packed_ref_store = packed_ref_store_create(sb.buf, flags); 107 strbuf_release(&sb); 108 109 return ref_store; 110} 111 112/* 113 * Die if refs is not the main ref store. caller is used in any 114 * necessary error messages. 115 */ 116static void files_assert_main_repository(struct files_ref_store *refs, 117 const char *caller) 118{ 119 if (refs->store_flags & REF_STORE_MAIN) 120 return; 121 122 die("BUG: operation %s only allowed for main ref store", caller); 123} 124 125/* 126 * Downcast ref_store to files_ref_store. Die if ref_store is not a 127 * files_ref_store. required_flags is compared with ref_store's 128 * store_flags to ensure the ref_store has all required capabilities. 129 * "caller" is used in any necessary error messages. 130 */ 131static struct files_ref_store *files_downcast(struct ref_store *ref_store, 132 unsigned int required_flags, 133 const char *caller) 134{ 135 struct files_ref_store *refs; 136 137 if (ref_store->be != &refs_be_files) 138 die("BUG: ref_store is type \"%s\" not \"files\" in %s", 139 ref_store->be->name, caller); 140 141 refs = (struct files_ref_store *)ref_store; 142 143 if ((refs->store_flags & required_flags) != required_flags) 144 die("BUG: operation %s requires abilities 0x%x, but only have 0x%x", 145 caller, required_flags, refs->store_flags); 146 147 return refs; 148} 149 150static void files_reflog_path(struct files_ref_store *refs, 151 struct strbuf *sb, 152 const char *refname) 153{ 154 switch (ref_type(refname)) { 155 case REF_TYPE_PER_WORKTREE: 156 case REF_TYPE_PSEUDOREF: 157 strbuf_addf(sb, "%s/logs/%s", refs->gitdir, refname); 158 break; 159 case REF_TYPE_NORMAL: 160 strbuf_addf(sb, "%s/logs/%s", refs->gitcommondir, refname); 161 break; 162 default: 163 die("BUG: unknown ref type %d of ref %s", 164 ref_type(refname), refname); 165 } 166} 167 168static void files_ref_path(struct files_ref_store *refs, 169 struct strbuf *sb, 170 const char *refname) 171{ 172 switch (ref_type(refname)) { 173 case REF_TYPE_PER_WORKTREE: 174 case REF_TYPE_PSEUDOREF: 175 strbuf_addf(sb, "%s/%s", refs->gitdir, refname); 176 break; 177 case REF_TYPE_NORMAL: 178 strbuf_addf(sb, "%s/%s", refs->gitcommondir, refname); 179 break; 180 default: 181 die("BUG: unknown ref type %d of ref %s", 182 ref_type(refname), refname); 183 } 184} 185 186/* 187 * Read the loose references from the namespace dirname into dir 188 * (without recursing). dirname must end with '/'. dir must be the 189 * directory entry corresponding to dirname. 190 */ 191static void loose_fill_ref_dir(struct ref_store *ref_store, 192 struct ref_dir *dir, const char *dirname) 193{ 194 struct files_ref_store *refs = 195 files_downcast(ref_store, REF_STORE_READ, "fill_ref_dir"); 196 DIR *d; 197 struct dirent *de; 198 int dirnamelen = strlen(dirname); 199 struct strbuf refname; 200 struct strbuf path = STRBUF_INIT; 201 size_t path_baselen; 202 203 files_ref_path(refs, &path, dirname); 204 path_baselen = path.len; 205 206 d = opendir(path.buf); 207 if (!d) { 208 strbuf_release(&path); 209 return; 210 } 211 212 strbuf_init(&refname, dirnamelen + 257); 213 strbuf_add(&refname, dirname, dirnamelen); 214 215 while ((de = readdir(d)) != NULL) { 216 struct object_id oid; 217 struct stat st; 218 int flag; 219 220 if (de->d_name[0] == '.') 221 continue; 222 if (ends_with(de->d_name, ".lock")) 223 continue; 224 strbuf_addstr(&refname, de->d_name); 225 strbuf_addstr(&path, de->d_name); 226 if (stat(path.buf, &st) < 0) { 227 ; /* silently ignore */ 228 } else if (S_ISDIR(st.st_mode)) { 229 strbuf_addch(&refname, '/'); 230 add_entry_to_dir(dir, 231 create_dir_entry(dir->cache, refname.buf, 232 refname.len, 1)); 233 } else { 234 if (!refs_resolve_ref_unsafe(&refs->base, 235 refname.buf, 236 RESOLVE_REF_READING, 237 &oid, &flag)) { 238 oidclr(&oid); 239 flag |= REF_ISBROKEN; 240 } else if (is_null_oid(&oid)) { 241 /* 242 * It is so astronomically unlikely 243 * that null_oid is the OID of an 244 * actual object that we consider its 245 * appearance in a loose reference 246 * file to be repo corruption 247 * (probably due to a software bug). 248 */ 249 flag |= REF_ISBROKEN; 250 } 251 252 if (check_refname_format(refname.buf, 253 REFNAME_ALLOW_ONELEVEL)) { 254 if (!refname_is_safe(refname.buf)) 255 die("loose refname is dangerous: %s", refname.buf); 256 oidclr(&oid); 257 flag |= REF_BAD_NAME | REF_ISBROKEN; 258 } 259 add_entry_to_dir(dir, 260 create_ref_entry(refname.buf, &oid, flag)); 261 } 262 strbuf_setlen(&refname, dirnamelen); 263 strbuf_setlen(&path, path_baselen); 264 } 265 strbuf_release(&refname); 266 strbuf_release(&path); 267 closedir(d); 268 269 /* 270 * Manually add refs/bisect, which, being per-worktree, might 271 * not appear in the directory listing for refs/ in the main 272 * repo. 273 */ 274 if (!strcmp(dirname, "refs/")) { 275 int pos = search_ref_dir(dir, "refs/bisect/", 12); 276 277 if (pos < 0) { 278 struct ref_entry *child_entry = create_dir_entry( 279 dir->cache, "refs/bisect/", 12, 1); 280 add_entry_to_dir(dir, child_entry); 281 } 282 } 283} 284 285static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs) 286{ 287 if (!refs->loose) { 288 /* 289 * Mark the top-level directory complete because we 290 * are about to read the only subdirectory that can 291 * hold references: 292 */ 293 refs->loose = create_ref_cache(&refs->base, loose_fill_ref_dir); 294 295 /* We're going to fill the top level ourselves: */ 296 refs->loose->root->flag &= ~REF_INCOMPLETE; 297 298 /* 299 * Add an incomplete entry for "refs/" (to be filled 300 * lazily): 301 */ 302 add_entry_to_dir(get_ref_dir(refs->loose->root), 303 create_dir_entry(refs->loose, "refs/", 5, 1)); 304 } 305 return refs->loose; 306} 307 308static int files_read_raw_ref(struct ref_store *ref_store, 309 const char *refname, struct object_id *oid, 310 struct strbuf *referent, unsigned int *type) 311{ 312 struct files_ref_store *refs = 313 files_downcast(ref_store, REF_STORE_READ, "read_raw_ref"); 314 struct strbuf sb_contents = STRBUF_INIT; 315 struct strbuf sb_path = STRBUF_INIT; 316 const char *path; 317 const char *buf; 318 const char *p; 319 struct stat st; 320 int fd; 321 int ret = -1; 322 int save_errno; 323 int remaining_retries = 3; 324 325 *type = 0; 326 strbuf_reset(&sb_path); 327 328 files_ref_path(refs, &sb_path, refname); 329 330 path = sb_path.buf; 331 332stat_ref: 333 /* 334 * We might have to loop back here to avoid a race 335 * condition: first we lstat() the file, then we try 336 * to read it as a link or as a file. But if somebody 337 * changes the type of the file (file <-> directory 338 * <-> symlink) between the lstat() and reading, then 339 * we don't want to report that as an error but rather 340 * try again starting with the lstat(). 341 * 342 * We'll keep a count of the retries, though, just to avoid 343 * any confusing situation sending us into an infinite loop. 344 */ 345 346 if (remaining_retries-- <= 0) 347 goto out; 348 349 if (lstat(path, &st) < 0) { 350 if (errno != ENOENT) 351 goto out; 352 if (refs_read_raw_ref(refs->packed_ref_store, refname, 353 oid, referent, type)) { 354 errno = ENOENT; 355 goto out; 356 } 357 ret = 0; 358 goto out; 359 } 360 361 /* Follow "normalized" - ie "refs/.." symlinks by hand */ 362 if (S_ISLNK(st.st_mode)) { 363 strbuf_reset(&sb_contents); 364 if (strbuf_readlink(&sb_contents, path, 0) < 0) { 365 if (errno == ENOENT || errno == EINVAL) 366 /* inconsistent with lstat; retry */ 367 goto stat_ref; 368 else 369 goto out; 370 } 371 if (starts_with(sb_contents.buf, "refs/") && 372 !check_refname_format(sb_contents.buf, 0)) { 373 strbuf_swap(&sb_contents, referent); 374 *type |= REF_ISSYMREF; 375 ret = 0; 376 goto out; 377 } 378 /* 379 * It doesn't look like a refname; fall through to just 380 * treating it like a non-symlink, and reading whatever it 381 * points to. 382 */ 383 } 384 385 /* Is it a directory? */ 386 if (S_ISDIR(st.st_mode)) { 387 /* 388 * Even though there is a directory where the loose 389 * ref is supposed to be, there could still be a 390 * packed ref: 391 */ 392 if (refs_read_raw_ref(refs->packed_ref_store, refname, 393 oid, referent, type)) { 394 errno = EISDIR; 395 goto out; 396 } 397 ret = 0; 398 goto out; 399 } 400 401 /* 402 * Anything else, just open it and try to use it as 403 * a ref 404 */ 405 fd = open(path, O_RDONLY); 406 if (fd < 0) { 407 if (errno == ENOENT && !S_ISLNK(st.st_mode)) 408 /* inconsistent with lstat; retry */ 409 goto stat_ref; 410 else 411 goto out; 412 } 413 strbuf_reset(&sb_contents); 414 if (strbuf_read(&sb_contents, fd, 256) < 0) { 415 int save_errno = errno; 416 close(fd); 417 errno = save_errno; 418 goto out; 419 } 420 close(fd); 421 strbuf_rtrim(&sb_contents); 422 buf = sb_contents.buf; 423 if (starts_with(buf, "ref:")) { 424 buf += 4; 425 while (isspace(*buf)) 426 buf++; 427 428 strbuf_reset(referent); 429 strbuf_addstr(referent, buf); 430 *type |= REF_ISSYMREF; 431 ret = 0; 432 goto out; 433 } 434 435 /* 436 * Please note that FETCH_HEAD has additional 437 * data after the sha. 438 */ 439 if (parse_oid_hex(buf, oid, &p) || 440 (*p != '\0' && !isspace(*p))) { 441 *type |= REF_ISBROKEN; 442 errno = EINVAL; 443 goto out; 444 } 445 446 ret = 0; 447 448out: 449 save_errno = errno; 450 strbuf_release(&sb_path); 451 strbuf_release(&sb_contents); 452 errno = save_errno; 453 return ret; 454} 455 456static void unlock_ref(struct ref_lock *lock) 457{ 458 rollback_lock_file(&lock->lk); 459 free(lock->ref_name); 460 free(lock); 461} 462 463/* 464 * Lock refname, without following symrefs, and set *lock_p to point 465 * at a newly-allocated lock object. Fill in lock->old_oid, referent, 466 * and type similarly to read_raw_ref(). 467 * 468 * The caller must verify that refname is a "safe" reference name (in 469 * the sense of refname_is_safe()) before calling this function. 470 * 471 * If the reference doesn't already exist, verify that refname doesn't 472 * have a D/F conflict with any existing references. extras and skip 473 * are passed to refs_verify_refname_available() for this check. 474 * 475 * If mustexist is not set and the reference is not found or is 476 * broken, lock the reference anyway but clear old_oid. 477 * 478 * Return 0 on success. On failure, write an error message to err and 479 * return TRANSACTION_NAME_CONFLICT or TRANSACTION_GENERIC_ERROR. 480 * 481 * Implementation note: This function is basically 482 * 483 * lock reference 484 * read_raw_ref() 485 * 486 * but it includes a lot more code to 487 * - Deal with possible races with other processes 488 * - Avoid calling refs_verify_refname_available() when it can be 489 * avoided, namely if we were successfully able to read the ref 490 * - Generate informative error messages in the case of failure 491 */ 492static int lock_raw_ref(struct files_ref_store *refs, 493 const char *refname, int mustexist, 494 const struct string_list *extras, 495 const struct string_list *skip, 496 struct ref_lock **lock_p, 497 struct strbuf *referent, 498 unsigned int *type, 499 struct strbuf *err) 500{ 501 struct ref_lock *lock; 502 struct strbuf ref_file = STRBUF_INIT; 503 int attempts_remaining = 3; 504 int ret = TRANSACTION_GENERIC_ERROR; 505 506 assert(err); 507 files_assert_main_repository(refs, "lock_raw_ref"); 508 509 *type = 0; 510 511 /* First lock the file so it can't change out from under us. */ 512 513 *lock_p = lock = xcalloc(1, sizeof(*lock)); 514 515 lock->ref_name = xstrdup(refname); 516 files_ref_path(refs, &ref_file, refname); 517 518retry: 519 switch (safe_create_leading_directories(ref_file.buf)) { 520 case SCLD_OK: 521 break; /* success */ 522 case SCLD_EXISTS: 523 /* 524 * Suppose refname is "refs/foo/bar". We just failed 525 * to create the containing directory, "refs/foo", 526 * because there was a non-directory in the way. This 527 * indicates a D/F conflict, probably because of 528 * another reference such as "refs/foo". There is no 529 * reason to expect this error to be transitory. 530 */ 531 if (refs_verify_refname_available(&refs->base, refname, 532 extras, skip, err)) { 533 if (mustexist) { 534 /* 535 * To the user the relevant error is 536 * that the "mustexist" reference is 537 * missing: 538 */ 539 strbuf_reset(err); 540 strbuf_addf(err, "unable to resolve reference '%s'", 541 refname); 542 } else { 543 /* 544 * The error message set by 545 * refs_verify_refname_available() is 546 * OK. 547 */ 548 ret = TRANSACTION_NAME_CONFLICT; 549 } 550 } else { 551 /* 552 * The file that is in the way isn't a loose 553 * reference. Report it as a low-level 554 * failure. 555 */ 556 strbuf_addf(err, "unable to create lock file %s.lock; " 557 "non-directory in the way", 558 ref_file.buf); 559 } 560 goto error_return; 561 case SCLD_VANISHED: 562 /* Maybe another process was tidying up. Try again. */ 563 if (--attempts_remaining > 0) 564 goto retry; 565 /* fall through */ 566 default: 567 strbuf_addf(err, "unable to create directory for %s", 568 ref_file.buf); 569 goto error_return; 570 } 571 572 if (hold_lock_file_for_update_timeout( 573 &lock->lk, ref_file.buf, LOCK_NO_DEREF, 574 get_files_ref_lock_timeout_ms()) < 0) { 575 if (errno == ENOENT && --attempts_remaining > 0) { 576 /* 577 * Maybe somebody just deleted one of the 578 * directories leading to ref_file. Try 579 * again: 580 */ 581 goto retry; 582 } else { 583 unable_to_lock_message(ref_file.buf, errno, err); 584 goto error_return; 585 } 586 } 587 588 /* 589 * Now we hold the lock and can read the reference without 590 * fear that its value will change. 591 */ 592 593 if (files_read_raw_ref(&refs->base, refname, 594 &lock->old_oid, referent, type)) { 595 if (errno == ENOENT) { 596 if (mustexist) { 597 /* Garden variety missing reference. */ 598 strbuf_addf(err, "unable to resolve reference '%s'", 599 refname); 600 goto error_return; 601 } else { 602 /* 603 * Reference is missing, but that's OK. We 604 * know that there is not a conflict with 605 * another loose reference because 606 * (supposing that we are trying to lock 607 * reference "refs/foo/bar"): 608 * 609 * - We were successfully able to create 610 * the lockfile refs/foo/bar.lock, so we 611 * know there cannot be a loose reference 612 * named "refs/foo". 613 * 614 * - We got ENOENT and not EISDIR, so we 615 * know that there cannot be a loose 616 * reference named "refs/foo/bar/baz". 617 */ 618 } 619 } else if (errno == EISDIR) { 620 /* 621 * There is a directory in the way. It might have 622 * contained references that have been deleted. If 623 * we don't require that the reference already 624 * exists, try to remove the directory so that it 625 * doesn't cause trouble when we want to rename the 626 * lockfile into place later. 627 */ 628 if (mustexist) { 629 /* Garden variety missing reference. */ 630 strbuf_addf(err, "unable to resolve reference '%s'", 631 refname); 632 goto error_return; 633 } else if (remove_dir_recursively(&ref_file, 634 REMOVE_DIR_EMPTY_ONLY)) { 635 if (refs_verify_refname_available( 636 &refs->base, refname, 637 extras, skip, err)) { 638 /* 639 * The error message set by 640 * verify_refname_available() is OK. 641 */ 642 ret = TRANSACTION_NAME_CONFLICT; 643 goto error_return; 644 } else { 645 /* 646 * We can't delete the directory, 647 * but we also don't know of any 648 * references that it should 649 * contain. 650 */ 651 strbuf_addf(err, "there is a non-empty directory '%s' " 652 "blocking reference '%s'", 653 ref_file.buf, refname); 654 goto error_return; 655 } 656 } 657 } else if (errno == EINVAL && (*type & REF_ISBROKEN)) { 658 strbuf_addf(err, "unable to resolve reference '%s': " 659 "reference broken", refname); 660 goto error_return; 661 } else { 662 strbuf_addf(err, "unable to resolve reference '%s': %s", 663 refname, strerror(errno)); 664 goto error_return; 665 } 666 667 /* 668 * If the ref did not exist and we are creating it, 669 * make sure there is no existing packed ref that 670 * conflicts with refname: 671 */ 672 if (refs_verify_refname_available( 673 refs->packed_ref_store, refname, 674 extras, skip, err)) 675 goto error_return; 676 } 677 678 ret = 0; 679 goto out; 680 681error_return: 682 unlock_ref(lock); 683 *lock_p = NULL; 684 685out: 686 strbuf_release(&ref_file); 687 return ret; 688} 689 690struct files_ref_iterator { 691 struct ref_iterator base; 692 693 struct ref_iterator *iter0; 694 unsigned int flags; 695}; 696 697static int files_ref_iterator_advance(struct ref_iterator *ref_iterator) 698{ 699 struct files_ref_iterator *iter = 700 (struct files_ref_iterator *)ref_iterator; 701 int ok; 702 703 while ((ok = ref_iterator_advance(iter->iter0)) == ITER_OK) { 704 if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY && 705 ref_type(iter->iter0->refname) != REF_TYPE_PER_WORKTREE) 706 continue; 707 708 if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 709 !ref_resolves_to_object(iter->iter0->refname, 710 iter->iter0->oid, 711 iter->iter0->flags)) 712 continue; 713 714 iter->base.refname = iter->iter0->refname; 715 iter->base.oid = iter->iter0->oid; 716 iter->base.flags = iter->iter0->flags; 717 return ITER_OK; 718 } 719 720 iter->iter0 = NULL; 721 if (ref_iterator_abort(ref_iterator) != ITER_DONE) 722 ok = ITER_ERROR; 723 724 return ok; 725} 726 727static int files_ref_iterator_peel(struct ref_iterator *ref_iterator, 728 struct object_id *peeled) 729{ 730 struct files_ref_iterator *iter = 731 (struct files_ref_iterator *)ref_iterator; 732 733 return ref_iterator_peel(iter->iter0, peeled); 734} 735 736static int files_ref_iterator_abort(struct ref_iterator *ref_iterator) 737{ 738 struct files_ref_iterator *iter = 739 (struct files_ref_iterator *)ref_iterator; 740 int ok = ITER_DONE; 741 742 if (iter->iter0) 743 ok = ref_iterator_abort(iter->iter0); 744 745 base_ref_iterator_free(ref_iterator); 746 return ok; 747} 748 749static struct ref_iterator_vtable files_ref_iterator_vtable = { 750 files_ref_iterator_advance, 751 files_ref_iterator_peel, 752 files_ref_iterator_abort 753}; 754 755static struct ref_iterator *files_ref_iterator_begin( 756 struct ref_store *ref_store, 757 const char *prefix, unsigned int flags) 758{ 759 struct files_ref_store *refs; 760 struct ref_iterator *loose_iter, *packed_iter, *overlay_iter; 761 struct files_ref_iterator *iter; 762 struct ref_iterator *ref_iterator; 763 unsigned int required_flags = REF_STORE_READ; 764 765 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) 766 required_flags |= REF_STORE_ODB; 767 768 refs = files_downcast(ref_store, required_flags, "ref_iterator_begin"); 769 770 /* 771 * We must make sure that all loose refs are read before 772 * accessing the packed-refs file; this avoids a race 773 * condition if loose refs are migrated to the packed-refs 774 * file by a simultaneous process, but our in-memory view is 775 * from before the migration. We ensure this as follows: 776 * First, we call start the loose refs iteration with its 777 * `prime_ref` argument set to true. This causes the loose 778 * references in the subtree to be pre-read into the cache. 779 * (If they've already been read, that's OK; we only need to 780 * guarantee that they're read before the packed refs, not 781 * *how much* before.) After that, we call 782 * packed_ref_iterator_begin(), which internally checks 783 * whether the packed-ref cache is up to date with what is on 784 * disk, and re-reads it if not. 785 */ 786 787 loose_iter = cache_ref_iterator_begin(get_loose_ref_cache(refs), 788 prefix, 1); 789 790 /* 791 * The packed-refs file might contain broken references, for 792 * example an old version of a reference that points at an 793 * object that has since been garbage-collected. This is OK as 794 * long as there is a corresponding loose reference that 795 * overrides it, and we don't want to emit an error message in 796 * this case. So ask the packed_ref_store for all of its 797 * references, and (if needed) do our own check for broken 798 * ones in files_ref_iterator_advance(), after we have merged 799 * the packed and loose references. 800 */ 801 packed_iter = refs_ref_iterator_begin( 802 refs->packed_ref_store, prefix, 0, 803 DO_FOR_EACH_INCLUDE_BROKEN); 804 805 overlay_iter = overlay_ref_iterator_begin(loose_iter, packed_iter); 806 807 iter = xcalloc(1, sizeof(*iter)); 808 ref_iterator = &iter->base; 809 base_ref_iterator_init(ref_iterator, &files_ref_iterator_vtable, 810 overlay_iter->ordered); 811 iter->iter0 = overlay_iter; 812 iter->flags = flags; 813 814 return ref_iterator; 815} 816 817/* 818 * Verify that the reference locked by lock has the value old_oid 819 * (unless it is NULL). Fail if the reference doesn't exist and 820 * mustexist is set. Return 0 on success. On error, write an error 821 * message to err, set errno, and return a negative value. 822 */ 823static int verify_lock(struct ref_store *ref_store, struct ref_lock *lock, 824 const struct object_id *old_oid, int mustexist, 825 struct strbuf *err) 826{ 827 assert(err); 828 829 if (refs_read_ref_full(ref_store, lock->ref_name, 830 mustexist ? RESOLVE_REF_READING : 0, 831 &lock->old_oid, NULL)) { 832 if (old_oid) { 833 int save_errno = errno; 834 strbuf_addf(err, "can't verify ref '%s'", lock->ref_name); 835 errno = save_errno; 836 return -1; 837 } else { 838 oidclr(&lock->old_oid); 839 return 0; 840 } 841 } 842 if (old_oid && oidcmp(&lock->old_oid, old_oid)) { 843 strbuf_addf(err, "ref '%s' is at %s but expected %s", 844 lock->ref_name, 845 oid_to_hex(&lock->old_oid), 846 oid_to_hex(old_oid)); 847 errno = EBUSY; 848 return -1; 849 } 850 return 0; 851} 852 853static int remove_empty_directories(struct strbuf *path) 854{ 855 /* 856 * we want to create a file but there is a directory there; 857 * if that is an empty directory (or a directory that contains 858 * only empty directories), remove them. 859 */ 860 return remove_dir_recursively(path, REMOVE_DIR_EMPTY_ONLY); 861} 862 863static int create_reflock(const char *path, void *cb) 864{ 865 struct lock_file *lk = cb; 866 867 return hold_lock_file_for_update_timeout( 868 lk, path, LOCK_NO_DEREF, 869 get_files_ref_lock_timeout_ms()) < 0 ? -1 : 0; 870} 871 872/* 873 * Locks a ref returning the lock on success and NULL on failure. 874 * On failure errno is set to something meaningful. 875 */ 876static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, 877 const char *refname, 878 const struct object_id *old_oid, 879 const struct string_list *extras, 880 const struct string_list *skip, 881 unsigned int flags, int *type, 882 struct strbuf *err) 883{ 884 struct strbuf ref_file = STRBUF_INIT; 885 struct ref_lock *lock; 886 int last_errno = 0; 887 int mustexist = (old_oid && !is_null_oid(old_oid)); 888 int resolve_flags = RESOLVE_REF_NO_RECURSE; 889 int resolved; 890 891 files_assert_main_repository(refs, "lock_ref_oid_basic"); 892 assert(err); 893 894 lock = xcalloc(1, sizeof(struct ref_lock)); 895 896 if (mustexist) 897 resolve_flags |= RESOLVE_REF_READING; 898 if (flags & REF_DELETING) 899 resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME; 900 901 files_ref_path(refs, &ref_file, refname); 902 resolved = !!refs_resolve_ref_unsafe(&refs->base, 903 refname, resolve_flags, 904 &lock->old_oid, type); 905 if (!resolved && errno == EISDIR) { 906 /* 907 * we are trying to lock foo but we used to 908 * have foo/bar which now does not exist; 909 * it is normal for the empty directory 'foo' 910 * to remain. 911 */ 912 if (remove_empty_directories(&ref_file)) { 913 last_errno = errno; 914 if (!refs_verify_refname_available( 915 &refs->base, 916 refname, extras, skip, err)) 917 strbuf_addf(err, "there are still refs under '%s'", 918 refname); 919 goto error_return; 920 } 921 resolved = !!refs_resolve_ref_unsafe(&refs->base, 922 refname, resolve_flags, 923 &lock->old_oid, type); 924 } 925 if (!resolved) { 926 last_errno = errno; 927 if (last_errno != ENOTDIR || 928 !refs_verify_refname_available(&refs->base, refname, 929 extras, skip, err)) 930 strbuf_addf(err, "unable to resolve reference '%s': %s", 931 refname, strerror(last_errno)); 932 933 goto error_return; 934 } 935 936 /* 937 * If the ref did not exist and we are creating it, make sure 938 * there is no existing packed ref whose name begins with our 939 * refname, nor a packed ref whose name is a proper prefix of 940 * our refname. 941 */ 942 if (is_null_oid(&lock->old_oid) && 943 refs_verify_refname_available(refs->packed_ref_store, refname, 944 extras, skip, err)) { 945 last_errno = ENOTDIR; 946 goto error_return; 947 } 948 949 lock->ref_name = xstrdup(refname); 950 951 if (raceproof_create_file(ref_file.buf, create_reflock, &lock->lk)) { 952 last_errno = errno; 953 unable_to_lock_message(ref_file.buf, errno, err); 954 goto error_return; 955 } 956 957 if (verify_lock(&refs->base, lock, old_oid, mustexist, err)) { 958 last_errno = errno; 959 goto error_return; 960 } 961 goto out; 962 963 error_return: 964 unlock_ref(lock); 965 lock = NULL; 966 967 out: 968 strbuf_release(&ref_file); 969 errno = last_errno; 970 return lock; 971} 972 973struct ref_to_prune { 974 struct ref_to_prune *next; 975 struct object_id oid; 976 char name[FLEX_ARRAY]; 977}; 978 979enum { 980 REMOVE_EMPTY_PARENTS_REF = 0x01, 981 REMOVE_EMPTY_PARENTS_REFLOG = 0x02 982}; 983 984/* 985 * Remove empty parent directories associated with the specified 986 * reference and/or its reflog, but spare [logs/]refs/ and immediate 987 * subdirs. flags is a combination of REMOVE_EMPTY_PARENTS_REF and/or 988 * REMOVE_EMPTY_PARENTS_REFLOG. 989 */ 990static void try_remove_empty_parents(struct files_ref_store *refs, 991 const char *refname, 992 unsigned int flags) 993{ 994 struct strbuf buf = STRBUF_INIT; 995 struct strbuf sb = STRBUF_INIT; 996 char *p, *q; 997 int i; 998 999 strbuf_addstr(&buf, refname);1000 p = buf.buf;1001 for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */1002 while (*p && *p != '/')1003 p++;1004 /* tolerate duplicate slashes; see check_refname_format() */1005 while (*p == '/')1006 p++;1007 }1008 q = buf.buf + buf.len;1009 while (flags & (REMOVE_EMPTY_PARENTS_REF | REMOVE_EMPTY_PARENTS_REFLOG)) {1010 while (q > p && *q != '/')1011 q--;1012 while (q > p && *(q-1) == '/')1013 q--;1014 if (q == p)1015 break;1016 strbuf_setlen(&buf, q - buf.buf);10171018 strbuf_reset(&sb);1019 files_ref_path(refs, &sb, buf.buf);1020 if ((flags & REMOVE_EMPTY_PARENTS_REF) && rmdir(sb.buf))1021 flags &= ~REMOVE_EMPTY_PARENTS_REF;10221023 strbuf_reset(&sb);1024 files_reflog_path(refs, &sb, buf.buf);1025 if ((flags & REMOVE_EMPTY_PARENTS_REFLOG) && rmdir(sb.buf))1026 flags &= ~REMOVE_EMPTY_PARENTS_REFLOG;1027 }1028 strbuf_release(&buf);1029 strbuf_release(&sb);1030}10311032/* make sure nobody touched the ref, and unlink */1033static void prune_ref(struct files_ref_store *refs, struct ref_to_prune *r)1034{1035 struct ref_transaction *transaction;1036 struct strbuf err = STRBUF_INIT;1037 int ret = -1;10381039 if (check_refname_format(r->name, 0))1040 return;10411042 transaction = ref_store_transaction_begin(&refs->base, &err);1043 if (!transaction)1044 goto cleanup;1045 ref_transaction_add_update(1046 transaction, r->name,1047 REF_NO_DEREF | REF_HAVE_NEW | REF_HAVE_OLD | REF_IS_PRUNING,1048 &null_oid, &r->oid, NULL);1049 if (ref_transaction_commit(transaction, &err))1050 goto cleanup;10511052 ret = 0;10531054cleanup:1055 if (ret)1056 error("%s", err.buf);1057 strbuf_release(&err);1058 ref_transaction_free(transaction);1059 return;1060}10611062/*1063 * Prune the loose versions of the references in the linked list1064 * `*refs_to_prune`, freeing the entries in the list as we go.1065 */1066static void prune_refs(struct files_ref_store *refs, struct ref_to_prune **refs_to_prune)1067{1068 while (*refs_to_prune) {1069 struct ref_to_prune *r = *refs_to_prune;1070 *refs_to_prune = r->next;1071 prune_ref(refs, r);1072 free(r);1073 }1074}10751076/*1077 * Return true if the specified reference should be packed.1078 */1079static int should_pack_ref(const char *refname,1080 const struct object_id *oid, unsigned int ref_flags,1081 unsigned int pack_flags)1082{1083 /* Do not pack per-worktree refs: */1084 if (ref_type(refname) != REF_TYPE_NORMAL)1085 return 0;10861087 /* Do not pack non-tags unless PACK_REFS_ALL is set: */1088 if (!(pack_flags & PACK_REFS_ALL) && !starts_with(refname, "refs/tags/"))1089 return 0;10901091 /* Do not pack symbolic refs: */1092 if (ref_flags & REF_ISSYMREF)1093 return 0;10941095 /* Do not pack broken refs: */1096 if (!ref_resolves_to_object(refname, oid, ref_flags))1097 return 0;10981099 return 1;1100}11011102static int files_pack_refs(struct ref_store *ref_store, unsigned int flags)1103{1104 struct files_ref_store *refs =1105 files_downcast(ref_store, REF_STORE_WRITE | REF_STORE_ODB,1106 "pack_refs");1107 struct ref_iterator *iter;1108 int ok;1109 struct ref_to_prune *refs_to_prune = NULL;1110 struct strbuf err = STRBUF_INIT;1111 struct ref_transaction *transaction;11121113 transaction = ref_store_transaction_begin(refs->packed_ref_store, &err);1114 if (!transaction)1115 return -1;11161117 packed_refs_lock(refs->packed_ref_store, LOCK_DIE_ON_ERROR, &err);11181119 iter = cache_ref_iterator_begin(get_loose_ref_cache(refs), NULL, 0);1120 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {1121 /*1122 * If the loose reference can be packed, add an entry1123 * in the packed ref cache. If the reference should be1124 * pruned, also add it to refs_to_prune.1125 */1126 if (!should_pack_ref(iter->refname, iter->oid, iter->flags,1127 flags))1128 continue;11291130 /*1131 * Add a reference creation for this reference to the1132 * packed-refs transaction:1133 */1134 if (ref_transaction_update(transaction, iter->refname,1135 iter->oid, NULL,1136 REF_NO_DEREF, NULL, &err))1137 die("failure preparing to create packed reference %s: %s",1138 iter->refname, err.buf);11391140 /* Schedule the loose reference for pruning if requested. */1141 if ((flags & PACK_REFS_PRUNE)) {1142 struct ref_to_prune *n;1143 FLEX_ALLOC_STR(n, name, iter->refname);1144 oidcpy(&n->oid, iter->oid);1145 n->next = refs_to_prune;1146 refs_to_prune = n;1147 }1148 }1149 if (ok != ITER_DONE)1150 die("error while iterating over references");11511152 if (ref_transaction_commit(transaction, &err))1153 die("unable to write new packed-refs: %s", err.buf);11541155 ref_transaction_free(transaction);11561157 packed_refs_unlock(refs->packed_ref_store);11581159 prune_refs(refs, &refs_to_prune);1160 strbuf_release(&err);1161 return 0;1162}11631164static int files_delete_refs(struct ref_store *ref_store, const char *msg,1165 struct string_list *refnames, unsigned int flags)1166{1167 struct files_ref_store *refs =1168 files_downcast(ref_store, REF_STORE_WRITE, "delete_refs");1169 struct strbuf err = STRBUF_INIT;1170 int i, result = 0;11711172 if (!refnames->nr)1173 return 0;11741175 if (packed_refs_lock(refs->packed_ref_store, 0, &err))1176 goto error;11771178 if (refs_delete_refs(refs->packed_ref_store, msg, refnames, flags)) {1179 packed_refs_unlock(refs->packed_ref_store);1180 goto error;1181 }11821183 packed_refs_unlock(refs->packed_ref_store);11841185 for (i = 0; i < refnames->nr; i++) {1186 const char *refname = refnames->items[i].string;11871188 if (refs_delete_ref(&refs->base, msg, refname, NULL, flags))1189 result |= error(_("could not remove reference %s"), refname);1190 }11911192 strbuf_release(&err);1193 return result;11941195error:1196 /*1197 * If we failed to rewrite the packed-refs file, then it is1198 * unsafe to try to remove loose refs, because doing so might1199 * expose an obsolete packed value for a reference that might1200 * even point at an object that has been garbage collected.1201 */1202 if (refnames->nr == 1)1203 error(_("could not delete reference %s: %s"),1204 refnames->items[0].string, err.buf);1205 else1206 error(_("could not delete references: %s"), err.buf);12071208 strbuf_release(&err);1209 return -1;1210}12111212/*1213 * People using contrib's git-new-workdir have .git/logs/refs ->1214 * /some/other/path/.git/logs/refs, and that may live on another device.1215 *1216 * IOW, to avoid cross device rename errors, the temporary renamed log must1217 * live into logs/refs.1218 */1219#define TMP_RENAMED_LOG "refs/.tmp-renamed-log"12201221struct rename_cb {1222 const char *tmp_renamed_log;1223 int true_errno;1224};12251226static int rename_tmp_log_callback(const char *path, void *cb_data)1227{1228 struct rename_cb *cb = cb_data;12291230 if (rename(cb->tmp_renamed_log, path)) {1231 /*1232 * rename(a, b) when b is an existing directory ought1233 * to result in ISDIR, but Solaris 5.8 gives ENOTDIR.1234 * Sheesh. Record the true errno for error reporting,1235 * but report EISDIR to raceproof_create_file() so1236 * that it knows to retry.1237 */1238 cb->true_errno = errno;1239 if (errno == ENOTDIR)1240 errno = EISDIR;1241 return -1;1242 } else {1243 return 0;1244 }1245}12461247static int rename_tmp_log(struct files_ref_store *refs, const char *newrefname)1248{1249 struct strbuf path = STRBUF_INIT;1250 struct strbuf tmp = STRBUF_INIT;1251 struct rename_cb cb;1252 int ret;12531254 files_reflog_path(refs, &path, newrefname);1255 files_reflog_path(refs, &tmp, TMP_RENAMED_LOG);1256 cb.tmp_renamed_log = tmp.buf;1257 ret = raceproof_create_file(path.buf, rename_tmp_log_callback, &cb);1258 if (ret) {1259 if (errno == EISDIR)1260 error("directory not empty: %s", path.buf);1261 else1262 error("unable to move logfile %s to %s: %s",1263 tmp.buf, path.buf,1264 strerror(cb.true_errno));1265 }12661267 strbuf_release(&path);1268 strbuf_release(&tmp);1269 return ret;1270}12711272static int write_ref_to_lockfile(struct ref_lock *lock,1273 const struct object_id *oid, struct strbuf *err);1274static int commit_ref_update(struct files_ref_store *refs,1275 struct ref_lock *lock,1276 const struct object_id *oid, const char *logmsg,1277 struct strbuf *err);12781279static int files_copy_or_rename_ref(struct ref_store *ref_store,1280 const char *oldrefname, const char *newrefname,1281 const char *logmsg, int copy)1282{1283 struct files_ref_store *refs =1284 files_downcast(ref_store, REF_STORE_WRITE, "rename_ref");1285 struct object_id oid, orig_oid;1286 int flag = 0, logmoved = 0;1287 struct ref_lock *lock;1288 struct stat loginfo;1289 struct strbuf sb_oldref = STRBUF_INIT;1290 struct strbuf sb_newref = STRBUF_INIT;1291 struct strbuf tmp_renamed_log = STRBUF_INIT;1292 int log, ret;1293 struct strbuf err = STRBUF_INIT;12941295 files_reflog_path(refs, &sb_oldref, oldrefname);1296 files_reflog_path(refs, &sb_newref, newrefname);1297 files_reflog_path(refs, &tmp_renamed_log, TMP_RENAMED_LOG);12981299 log = !lstat(sb_oldref.buf, &loginfo);1300 if (log && S_ISLNK(loginfo.st_mode)) {1301 ret = error("reflog for %s is a symlink", oldrefname);1302 goto out;1303 }13041305 if (!refs_resolve_ref_unsafe(&refs->base, oldrefname,1306 RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,1307 &orig_oid, &flag)) {1308 ret = error("refname %s not found", oldrefname);1309 goto out;1310 }13111312 if (flag & REF_ISSYMREF) {1313 if (copy)1314 ret = error("refname %s is a symbolic ref, copying it is not supported",1315 oldrefname);1316 else1317 ret = error("refname %s is a symbolic ref, renaming it is not supported",1318 oldrefname);1319 goto out;1320 }1321 if (!refs_rename_ref_available(&refs->base, oldrefname, newrefname)) {1322 ret = 1;1323 goto out;1324 }13251326 if (!copy && log && rename(sb_oldref.buf, tmp_renamed_log.buf)) {1327 ret = error("unable to move logfile logs/%s to logs/"TMP_RENAMED_LOG": %s",1328 oldrefname, strerror(errno));1329 goto out;1330 }13311332 if (copy && log && copy_file(tmp_renamed_log.buf, sb_oldref.buf, 0644)) {1333 ret = error("unable to copy logfile logs/%s to logs/"TMP_RENAMED_LOG": %s",1334 oldrefname, strerror(errno));1335 goto out;1336 }13371338 if (!copy && refs_delete_ref(&refs->base, logmsg, oldrefname,1339 &orig_oid, REF_NO_DEREF)) {1340 error("unable to delete old %s", oldrefname);1341 goto rollback;1342 }13431344 /*1345 * Since we are doing a shallow lookup, oid is not the1346 * correct value to pass to delete_ref as old_oid. But that1347 * doesn't matter, because an old_oid check wouldn't add to1348 * the safety anyway; we want to delete the reference whatever1349 * its current value.1350 */1351 if (!copy && !refs_read_ref_full(&refs->base, newrefname,1352 RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,1353 &oid, NULL) &&1354 refs_delete_ref(&refs->base, NULL, newrefname,1355 NULL, REF_NO_DEREF)) {1356 if (errno == EISDIR) {1357 struct strbuf path = STRBUF_INIT;1358 int result;13591360 files_ref_path(refs, &path, newrefname);1361 result = remove_empty_directories(&path);1362 strbuf_release(&path);13631364 if (result) {1365 error("Directory not empty: %s", newrefname);1366 goto rollback;1367 }1368 } else {1369 error("unable to delete existing %s", newrefname);1370 goto rollback;1371 }1372 }13731374 if (log && rename_tmp_log(refs, newrefname))1375 goto rollback;13761377 logmoved = log;13781379 lock = lock_ref_oid_basic(refs, newrefname, NULL, NULL, NULL,1380 REF_NO_DEREF, NULL, &err);1381 if (!lock) {1382 if (copy)1383 error("unable to copy '%s' to '%s': %s", oldrefname, newrefname, err.buf);1384 else1385 error("unable to rename '%s' to '%s': %s", oldrefname, newrefname, err.buf);1386 strbuf_release(&err);1387 goto rollback;1388 }1389 oidcpy(&lock->old_oid, &orig_oid);13901391 if (write_ref_to_lockfile(lock, &orig_oid, &err) ||1392 commit_ref_update(refs, lock, &orig_oid, logmsg, &err)) {1393 error("unable to write current sha1 into %s: %s", newrefname, err.buf);1394 strbuf_release(&err);1395 goto rollback;1396 }13971398 ret = 0;1399 goto out;14001401 rollback:1402 lock = lock_ref_oid_basic(refs, oldrefname, NULL, NULL, NULL,1403 REF_NO_DEREF, NULL, &err);1404 if (!lock) {1405 error("unable to lock %s for rollback: %s", oldrefname, err.buf);1406 strbuf_release(&err);1407 goto rollbacklog;1408 }14091410 flag = log_all_ref_updates;1411 log_all_ref_updates = LOG_REFS_NONE;1412 if (write_ref_to_lockfile(lock, &orig_oid, &err) ||1413 commit_ref_update(refs, lock, &orig_oid, NULL, &err)) {1414 error("unable to write current sha1 into %s: %s", oldrefname, err.buf);1415 strbuf_release(&err);1416 }1417 log_all_ref_updates = flag;14181419 rollbacklog:1420 if (logmoved && rename(sb_newref.buf, sb_oldref.buf))1421 error("unable to restore logfile %s from %s: %s",1422 oldrefname, newrefname, strerror(errno));1423 if (!logmoved && log &&1424 rename(tmp_renamed_log.buf, sb_oldref.buf))1425 error("unable to restore logfile %s from logs/"TMP_RENAMED_LOG": %s",1426 oldrefname, strerror(errno));1427 ret = 1;1428 out:1429 strbuf_release(&sb_newref);1430 strbuf_release(&sb_oldref);1431 strbuf_release(&tmp_renamed_log);14321433 return ret;1434}14351436static int files_rename_ref(struct ref_store *ref_store,1437 const char *oldrefname, const char *newrefname,1438 const char *logmsg)1439{1440 return files_copy_or_rename_ref(ref_store, oldrefname,1441 newrefname, logmsg, 0);1442}14431444static int files_copy_ref(struct ref_store *ref_store,1445 const char *oldrefname, const char *newrefname,1446 const char *logmsg)1447{1448 return files_copy_or_rename_ref(ref_store, oldrefname,1449 newrefname, logmsg, 1);1450}14511452static int close_ref_gently(struct ref_lock *lock)1453{1454 if (close_lock_file_gently(&lock->lk))1455 return -1;1456 return 0;1457}14581459static int commit_ref(struct ref_lock *lock)1460{1461 char *path = get_locked_file_path(&lock->lk);1462 struct stat st;14631464 if (!lstat(path, &st) && S_ISDIR(st.st_mode)) {1465 /*1466 * There is a directory at the path we want to rename1467 * the lockfile to. Hopefully it is empty; try to1468 * delete it.1469 */1470 size_t len = strlen(path);1471 struct strbuf sb_path = STRBUF_INIT;14721473 strbuf_attach(&sb_path, path, len, len);14741475 /*1476 * If this fails, commit_lock_file() will also fail1477 * and will report the problem.1478 */1479 remove_empty_directories(&sb_path);1480 strbuf_release(&sb_path);1481 } else {1482 free(path);1483 }14841485 if (commit_lock_file(&lock->lk))1486 return -1;1487 return 0;1488}14891490static int open_or_create_logfile(const char *path, void *cb)1491{1492 int *fd = cb;14931494 *fd = open(path, O_APPEND | O_WRONLY | O_CREAT, 0666);1495 return (*fd < 0) ? -1 : 0;1496}14971498/*1499 * Create a reflog for a ref. If force_create = 0, only create the1500 * reflog for certain refs (those for which should_autocreate_reflog1501 * returns non-zero). Otherwise, create it regardless of the reference1502 * name. If the logfile already existed or was created, return 0 and1503 * set *logfd to the file descriptor opened for appending to the file.1504 * If no logfile exists and we decided not to create one, return 0 and1505 * set *logfd to -1. On failure, fill in *err, set *logfd to -1, and1506 * return -1.1507 */1508static int log_ref_setup(struct files_ref_store *refs,1509 const char *refname, int force_create,1510 int *logfd, struct strbuf *err)1511{1512 struct strbuf logfile_sb = STRBUF_INIT;1513 char *logfile;15141515 files_reflog_path(refs, &logfile_sb, refname);1516 logfile = strbuf_detach(&logfile_sb, NULL);15171518 if (force_create || should_autocreate_reflog(refname)) {1519 if (raceproof_create_file(logfile, open_or_create_logfile, logfd)) {1520 if (errno == ENOENT)1521 strbuf_addf(err, "unable to create directory for '%s': "1522 "%s", logfile, strerror(errno));1523 else if (errno == EISDIR)1524 strbuf_addf(err, "there are still logs under '%s'",1525 logfile);1526 else1527 strbuf_addf(err, "unable to append to '%s': %s",1528 logfile, strerror(errno));15291530 goto error;1531 }1532 } else {1533 *logfd = open(logfile, O_APPEND | O_WRONLY, 0666);1534 if (*logfd < 0) {1535 if (errno == ENOENT || errno == EISDIR) {1536 /*1537 * The logfile doesn't already exist,1538 * but that is not an error; it only1539 * means that we won't write log1540 * entries to it.1541 */1542 ;1543 } else {1544 strbuf_addf(err, "unable to append to '%s': %s",1545 logfile, strerror(errno));1546 goto error;1547 }1548 }1549 }15501551 if (*logfd >= 0)1552 adjust_shared_perm(logfile);15531554 free(logfile);1555 return 0;15561557error:1558 free(logfile);1559 return -1;1560}15611562static int files_create_reflog(struct ref_store *ref_store,1563 const char *refname, int force_create,1564 struct strbuf *err)1565{1566 struct files_ref_store *refs =1567 files_downcast(ref_store, REF_STORE_WRITE, "create_reflog");1568 int fd;15691570 if (log_ref_setup(refs, refname, force_create, &fd, err))1571 return -1;15721573 if (fd >= 0)1574 close(fd);15751576 return 0;1577}15781579static int log_ref_write_fd(int fd, const struct object_id *old_oid,1580 const struct object_id *new_oid,1581 const char *committer, const char *msg)1582{1583 int msglen, written;1584 unsigned maxlen, len;1585 char *logrec;15861587 msglen = msg ? strlen(msg) : 0;1588 maxlen = strlen(committer) + msglen + 100;1589 logrec = xmalloc(maxlen);1590 len = xsnprintf(logrec, maxlen, "%s %s %s\n",1591 oid_to_hex(old_oid),1592 oid_to_hex(new_oid),1593 committer);1594 if (msglen)1595 len += copy_reflog_msg(logrec + len - 1, msg) - 1;15961597 written = len <= maxlen ? write_in_full(fd, logrec, len) : -1;1598 free(logrec);1599 if (written < 0)1600 return -1;16011602 return 0;1603}16041605static int files_log_ref_write(struct files_ref_store *refs,1606 const char *refname, const struct object_id *old_oid,1607 const struct object_id *new_oid, const char *msg,1608 int flags, struct strbuf *err)1609{1610 int logfd, result;16111612 if (log_all_ref_updates == LOG_REFS_UNSET)1613 log_all_ref_updates = is_bare_repository() ? LOG_REFS_NONE : LOG_REFS_NORMAL;16141615 result = log_ref_setup(refs, refname,1616 flags & REF_FORCE_CREATE_REFLOG,1617 &logfd, err);16181619 if (result)1620 return result;16211622 if (logfd < 0)1623 return 0;1624 result = log_ref_write_fd(logfd, old_oid, new_oid,1625 git_committer_info(0), msg);1626 if (result) {1627 struct strbuf sb = STRBUF_INIT;1628 int save_errno = errno;16291630 files_reflog_path(refs, &sb, refname);1631 strbuf_addf(err, "unable to append to '%s': %s",1632 sb.buf, strerror(save_errno));1633 strbuf_release(&sb);1634 close(logfd);1635 return -1;1636 }1637 if (close(logfd)) {1638 struct strbuf sb = STRBUF_INIT;1639 int save_errno = errno;16401641 files_reflog_path(refs, &sb, refname);1642 strbuf_addf(err, "unable to append to '%s': %s",1643 sb.buf, strerror(save_errno));1644 strbuf_release(&sb);1645 return -1;1646 }1647 return 0;1648}16491650/*1651 * Write oid into the open lockfile, then close the lockfile. On1652 * errors, rollback the lockfile, fill in *err and return -1.1653 */1654static int write_ref_to_lockfile(struct ref_lock *lock,1655 const struct object_id *oid, struct strbuf *err)1656{1657 static char term = '\n';1658 struct object *o;1659 int fd;16601661 o = parse_object(oid);1662 if (!o) {1663 strbuf_addf(err,1664 "trying to write ref '%s' with nonexistent object %s",1665 lock->ref_name, oid_to_hex(oid));1666 unlock_ref(lock);1667 return -1;1668 }1669 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {1670 strbuf_addf(err,1671 "trying to write non-commit object %s to branch '%s'",1672 oid_to_hex(oid), lock->ref_name);1673 unlock_ref(lock);1674 return -1;1675 }1676 fd = get_lock_file_fd(&lock->lk);1677 if (write_in_full(fd, oid_to_hex(oid), GIT_SHA1_HEXSZ) < 0 ||1678 write_in_full(fd, &term, 1) < 0 ||1679 close_ref_gently(lock) < 0) {1680 strbuf_addf(err,1681 "couldn't write '%s'", get_lock_file_path(&lock->lk));1682 unlock_ref(lock);1683 return -1;1684 }1685 return 0;1686}16871688/*1689 * Commit a change to a loose reference that has already been written1690 * to the loose reference lockfile. Also update the reflogs if1691 * necessary, using the specified lockmsg (which can be NULL).1692 */1693static int commit_ref_update(struct files_ref_store *refs,1694 struct ref_lock *lock,1695 const struct object_id *oid, const char *logmsg,1696 struct strbuf *err)1697{1698 files_assert_main_repository(refs, "commit_ref_update");16991700 clear_loose_ref_cache(refs);1701 if (files_log_ref_write(refs, lock->ref_name,1702 &lock->old_oid, oid,1703 logmsg, 0, err)) {1704 char *old_msg = strbuf_detach(err, NULL);1705 strbuf_addf(err, "cannot update the ref '%s': %s",1706 lock->ref_name, old_msg);1707 free(old_msg);1708 unlock_ref(lock);1709 return -1;1710 }17111712 if (strcmp(lock->ref_name, "HEAD") != 0) {1713 /*1714 * Special hack: If a branch is updated directly and HEAD1715 * points to it (may happen on the remote side of a push1716 * for example) then logically the HEAD reflog should be1717 * updated too.1718 * A generic solution implies reverse symref information,1719 * but finding all symrefs pointing to the given branch1720 * would be rather costly for this rare event (the direct1721 * update of a branch) to be worth it. So let's cheat and1722 * check with HEAD only which should cover 99% of all usage1723 * scenarios (even 100% of the default ones).1724 */1725 int head_flag;1726 const char *head_ref;17271728 head_ref = refs_resolve_ref_unsafe(&refs->base, "HEAD",1729 RESOLVE_REF_READING,1730 NULL, &head_flag);1731 if (head_ref && (head_flag & REF_ISSYMREF) &&1732 !strcmp(head_ref, lock->ref_name)) {1733 struct strbuf log_err = STRBUF_INIT;1734 if (files_log_ref_write(refs, "HEAD",1735 &lock->old_oid, oid,1736 logmsg, 0, &log_err)) {1737 error("%s", log_err.buf);1738 strbuf_release(&log_err);1739 }1740 }1741 }17421743 if (commit_ref(lock)) {1744 strbuf_addf(err, "couldn't set '%s'", lock->ref_name);1745 unlock_ref(lock);1746 return -1;1747 }17481749 unlock_ref(lock);1750 return 0;1751}17521753static int create_ref_symlink(struct ref_lock *lock, const char *target)1754{1755 int ret = -1;1756#ifndef NO_SYMLINK_HEAD1757 char *ref_path = get_locked_file_path(&lock->lk);1758 unlink(ref_path);1759 ret = symlink(target, ref_path);1760 free(ref_path);17611762 if (ret)1763 fprintf(stderr, "no symlink - falling back to symbolic ref\n");1764#endif1765 return ret;1766}17671768static void update_symref_reflog(struct files_ref_store *refs,1769 struct ref_lock *lock, const char *refname,1770 const char *target, const char *logmsg)1771{1772 struct strbuf err = STRBUF_INIT;1773 struct object_id new_oid;1774 if (logmsg &&1775 !refs_read_ref_full(&refs->base, target,1776 RESOLVE_REF_READING, &new_oid, NULL) &&1777 files_log_ref_write(refs, refname, &lock->old_oid,1778 &new_oid, logmsg, 0, &err)) {1779 error("%s", err.buf);1780 strbuf_release(&err);1781 }1782}17831784static int create_symref_locked(struct files_ref_store *refs,1785 struct ref_lock *lock, const char *refname,1786 const char *target, const char *logmsg)1787{1788 if (prefer_symlink_refs && !create_ref_symlink(lock, target)) {1789 update_symref_reflog(refs, lock, refname, target, logmsg);1790 return 0;1791 }17921793 if (!fdopen_lock_file(&lock->lk, "w"))1794 return error("unable to fdopen %s: %s",1795 lock->lk.tempfile->filename.buf, strerror(errno));17961797 update_symref_reflog(refs, lock, refname, target, logmsg);17981799 /* no error check; commit_ref will check ferror */1800 fprintf(lock->lk.tempfile->fp, "ref: %s\n", target);1801 if (commit_ref(lock) < 0)1802 return error("unable to write symref for %s: %s", refname,1803 strerror(errno));1804 return 0;1805}18061807static int files_create_symref(struct ref_store *ref_store,1808 const char *refname, const char *target,1809 const char *logmsg)1810{1811 struct files_ref_store *refs =1812 files_downcast(ref_store, REF_STORE_WRITE, "create_symref");1813 struct strbuf err = STRBUF_INIT;1814 struct ref_lock *lock;1815 int ret;18161817 lock = lock_ref_oid_basic(refs, refname, NULL,1818 NULL, NULL, REF_NO_DEREF, NULL,1819 &err);1820 if (!lock) {1821 error("%s", err.buf);1822 strbuf_release(&err);1823 return -1;1824 }18251826 ret = create_symref_locked(refs, lock, refname, target, logmsg);1827 unlock_ref(lock);1828 return ret;1829}18301831static int files_reflog_exists(struct ref_store *ref_store,1832 const char *refname)1833{1834 struct files_ref_store *refs =1835 files_downcast(ref_store, REF_STORE_READ, "reflog_exists");1836 struct strbuf sb = STRBUF_INIT;1837 struct stat st;1838 int ret;18391840 files_reflog_path(refs, &sb, refname);1841 ret = !lstat(sb.buf, &st) && S_ISREG(st.st_mode);1842 strbuf_release(&sb);1843 return ret;1844}18451846static int files_delete_reflog(struct ref_store *ref_store,1847 const char *refname)1848{1849 struct files_ref_store *refs =1850 files_downcast(ref_store, REF_STORE_WRITE, "delete_reflog");1851 struct strbuf sb = STRBUF_INIT;1852 int ret;18531854 files_reflog_path(refs, &sb, refname);1855 ret = remove_path(sb.buf);1856 strbuf_release(&sb);1857 return ret;1858}18591860static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)1861{1862 struct object_id ooid, noid;1863 char *email_end, *message;1864 timestamp_t timestamp;1865 int tz;1866 const char *p = sb->buf;18671868 /* old SP new SP name <email> SP time TAB msg LF */1869 if (!sb->len || sb->buf[sb->len - 1] != '\n' ||1870 parse_oid_hex(p, &ooid, &p) || *p++ != ' ' ||1871 parse_oid_hex(p, &noid, &p) || *p++ != ' ' ||1872 !(email_end = strchr(p, '>')) ||1873 email_end[1] != ' ' ||1874 !(timestamp = parse_timestamp(email_end + 2, &message, 10)) ||1875 !message || message[0] != ' ' ||1876 (message[1] != '+' && message[1] != '-') ||1877 !isdigit(message[2]) || !isdigit(message[3]) ||1878 !isdigit(message[4]) || !isdigit(message[5]))1879 return 0; /* corrupt? */1880 email_end[1] = '\0';1881 tz = strtol(message + 1, NULL, 10);1882 if (message[6] != '\t')1883 message += 6;1884 else1885 message += 7;1886 return fn(&ooid, &noid, p, timestamp, tz, message, cb_data);1887}18881889static char *find_beginning_of_line(char *bob, char *scan)1890{1891 while (bob < scan && *(--scan) != '\n')1892 ; /* keep scanning backwards */1893 /*1894 * Return either beginning of the buffer, or LF at the end of1895 * the previous line.1896 */1897 return scan;1898}18991900static int files_for_each_reflog_ent_reverse(struct ref_store *ref_store,1901 const char *refname,1902 each_reflog_ent_fn fn,1903 void *cb_data)1904{1905 struct files_ref_store *refs =1906 files_downcast(ref_store, REF_STORE_READ,1907 "for_each_reflog_ent_reverse");1908 struct strbuf sb = STRBUF_INIT;1909 FILE *logfp;1910 long pos;1911 int ret = 0, at_tail = 1;19121913 files_reflog_path(refs, &sb, refname);1914 logfp = fopen(sb.buf, "r");1915 strbuf_release(&sb);1916 if (!logfp)1917 return -1;19181919 /* Jump to the end */1920 if (fseek(logfp, 0, SEEK_END) < 0)1921 ret = error("cannot seek back reflog for %s: %s",1922 refname, strerror(errno));1923 pos = ftell(logfp);1924 while (!ret && 0 < pos) {1925 int cnt;1926 size_t nread;1927 char buf[BUFSIZ];1928 char *endp, *scanp;19291930 /* Fill next block from the end */1931 cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;1932 if (fseek(logfp, pos - cnt, SEEK_SET)) {1933 ret = error("cannot seek back reflog for %s: %s",1934 refname, strerror(errno));1935 break;1936 }1937 nread = fread(buf, cnt, 1, logfp);1938 if (nread != 1) {1939 ret = error("cannot read %d bytes from reflog for %s: %s",1940 cnt, refname, strerror(errno));1941 break;1942 }1943 pos -= cnt;19441945 scanp = endp = buf + cnt;1946 if (at_tail && scanp[-1] == '\n')1947 /* Looking at the final LF at the end of the file */1948 scanp--;1949 at_tail = 0;19501951 while (buf < scanp) {1952 /*1953 * terminating LF of the previous line, or the beginning1954 * of the buffer.1955 */1956 char *bp;19571958 bp = find_beginning_of_line(buf, scanp);19591960 if (*bp == '\n') {1961 /*1962 * The newline is the end of the previous line,1963 * so we know we have complete line starting1964 * at (bp + 1). Prefix it onto any prior data1965 * we collected for the line and process it.1966 */1967 strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));1968 scanp = bp;1969 endp = bp + 1;1970 ret = show_one_reflog_ent(&sb, fn, cb_data);1971 strbuf_reset(&sb);1972 if (ret)1973 break;1974 } else if (!pos) {1975 /*1976 * We are at the start of the buffer, and the1977 * start of the file; there is no previous1978 * line, and we have everything for this one.1979 * Process it, and we can end the loop.1980 */1981 strbuf_splice(&sb, 0, 0, buf, endp - buf);1982 ret = show_one_reflog_ent(&sb, fn, cb_data);1983 strbuf_reset(&sb);1984 break;1985 }19861987 if (bp == buf) {1988 /*1989 * We are at the start of the buffer, and there1990 * is more file to read backwards. Which means1991 * we are in the middle of a line. Note that we1992 * may get here even if *bp was a newline; that1993 * just means we are at the exact end of the1994 * previous line, rather than some spot in the1995 * middle.1996 *1997 * Save away what we have to be combined with1998 * the data from the next read.1999 */2000 strbuf_splice(&sb, 0, 0, buf, endp - buf);2001 break;2002 }2003 }20042005 }2006 if (!ret && sb.len)2007 die("BUG: reverse reflog parser had leftover data");20082009 fclose(logfp);2010 strbuf_release(&sb);2011 return ret;2012}20132014static int files_for_each_reflog_ent(struct ref_store *ref_store,2015 const char *refname,2016 each_reflog_ent_fn fn, void *cb_data)2017{2018 struct files_ref_store *refs =2019 files_downcast(ref_store, REF_STORE_READ,2020 "for_each_reflog_ent");2021 FILE *logfp;2022 struct strbuf sb = STRBUF_INIT;2023 int ret = 0;20242025 files_reflog_path(refs, &sb, refname);2026 logfp = fopen(sb.buf, "r");2027 strbuf_release(&sb);2028 if (!logfp)2029 return -1;20302031 while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))2032 ret = show_one_reflog_ent(&sb, fn, cb_data);2033 fclose(logfp);2034 strbuf_release(&sb);2035 return ret;2036}20372038struct files_reflog_iterator {2039 struct ref_iterator base;20402041 struct ref_store *ref_store;2042 struct dir_iterator *dir_iterator;2043 struct object_id oid;2044};20452046static int files_reflog_iterator_advance(struct ref_iterator *ref_iterator)2047{2048 struct files_reflog_iterator *iter =2049 (struct files_reflog_iterator *)ref_iterator;2050 struct dir_iterator *diter = iter->dir_iterator;2051 int ok;20522053 while ((ok = dir_iterator_advance(diter)) == ITER_OK) {2054 int flags;20552056 if (!S_ISREG(diter->st.st_mode))2057 continue;2058 if (diter->basename[0] == '.')2059 continue;2060 if (ends_with(diter->basename, ".lock"))2061 continue;20622063 if (refs_read_ref_full(iter->ref_store,2064 diter->relative_path, 0,2065 &iter->oid, &flags)) {2066 error("bad ref for %s", diter->path.buf);2067 continue;2068 }20692070 iter->base.refname = diter->relative_path;2071 iter->base.oid = &iter->oid;2072 iter->base.flags = flags;2073 return ITER_OK;2074 }20752076 iter->dir_iterator = NULL;2077 if (ref_iterator_abort(ref_iterator) == ITER_ERROR)2078 ok = ITER_ERROR;2079 return ok;2080}20812082static int files_reflog_iterator_peel(struct ref_iterator *ref_iterator,2083 struct object_id *peeled)2084{2085 die("BUG: ref_iterator_peel() called for reflog_iterator");2086}20872088static int files_reflog_iterator_abort(struct ref_iterator *ref_iterator)2089{2090 struct files_reflog_iterator *iter =2091 (struct files_reflog_iterator *)ref_iterator;2092 int ok = ITER_DONE;20932094 if (iter->dir_iterator)2095 ok = dir_iterator_abort(iter->dir_iterator);20962097 base_ref_iterator_free(ref_iterator);2098 return ok;2099}21002101static struct ref_iterator_vtable files_reflog_iterator_vtable = {2102 files_reflog_iterator_advance,2103 files_reflog_iterator_peel,2104 files_reflog_iterator_abort2105};21062107static struct ref_iterator *reflog_iterator_begin(struct ref_store *ref_store,2108 const char *gitdir)2109{2110 struct files_reflog_iterator *iter = xcalloc(1, sizeof(*iter));2111 struct ref_iterator *ref_iterator = &iter->base;2112 struct strbuf sb = STRBUF_INIT;21132114 base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable, 0);2115 strbuf_addf(&sb, "%s/logs", gitdir);2116 iter->dir_iterator = dir_iterator_begin(sb.buf);2117 iter->ref_store = ref_store;2118 strbuf_release(&sb);21192120 return ref_iterator;2121}21222123static enum iterator_selection reflog_iterator_select(2124 struct ref_iterator *iter_worktree,2125 struct ref_iterator *iter_common,2126 void *cb_data)2127{2128 if (iter_worktree) {2129 /*2130 * We're a bit loose here. We probably should ignore2131 * common refs if they are accidentally added as2132 * per-worktree refs.2133 */2134 return ITER_SELECT_0;2135 } else if (iter_common) {2136 if (ref_type(iter_common->refname) == REF_TYPE_NORMAL)2137 return ITER_SELECT_1;21382139 /*2140 * The main ref store may contain main worktree's2141 * per-worktree refs, which should be ignored2142 */2143 return ITER_SKIP_1;2144 } else2145 return ITER_DONE;2146}21472148static struct ref_iterator *files_reflog_iterator_begin(struct ref_store *ref_store)2149{2150 struct files_ref_store *refs =2151 files_downcast(ref_store, REF_STORE_READ,2152 "reflog_iterator_begin");21532154 if (!strcmp(refs->gitdir, refs->gitcommondir)) {2155 return reflog_iterator_begin(ref_store, refs->gitcommondir);2156 } else {2157 return merge_ref_iterator_begin(2158 0,2159 reflog_iterator_begin(ref_store, refs->gitdir),2160 reflog_iterator_begin(ref_store, refs->gitcommondir),2161 reflog_iterator_select, refs);2162 }2163}21642165/*2166 * If update is a direct update of head_ref (the reference pointed to2167 * by HEAD), then add an extra REF_LOG_ONLY update for HEAD.2168 */2169static int split_head_update(struct ref_update *update,2170 struct ref_transaction *transaction,2171 const char *head_ref,2172 struct string_list *affected_refnames,2173 struct strbuf *err)2174{2175 struct string_list_item *item;2176 struct ref_update *new_update;21772178 if ((update->flags & REF_LOG_ONLY) ||2179 (update->flags & REF_IS_PRUNING) ||2180 (update->flags & REF_UPDATE_VIA_HEAD))2181 return 0;21822183 if (strcmp(update->refname, head_ref))2184 return 0;21852186 /*2187 * First make sure that HEAD is not already in the2188 * transaction. This check is O(lg N) in the transaction2189 * size, but it happens at most once per transaction.2190 */2191 if (string_list_has_string(affected_refnames, "HEAD")) {2192 /* An entry already existed */2193 strbuf_addf(err,2194 "multiple updates for 'HEAD' (including one "2195 "via its referent '%s') are not allowed",2196 update->refname);2197 return TRANSACTION_NAME_CONFLICT;2198 }21992200 new_update = ref_transaction_add_update(2201 transaction, "HEAD",2202 update->flags | REF_LOG_ONLY | REF_NO_DEREF,2203 &update->new_oid, &update->old_oid,2204 update->msg);22052206 /*2207 * Add "HEAD". This insertion is O(N) in the transaction2208 * size, but it happens at most once per transaction.2209 * Add new_update->refname instead of a literal "HEAD".2210 */2211 if (strcmp(new_update->refname, "HEAD"))2212 BUG("%s unexpectedly not 'HEAD'", new_update->refname);2213 item = string_list_insert(affected_refnames, new_update->refname);2214 item->util = new_update;22152216 return 0;2217}22182219/*2220 * update is for a symref that points at referent and doesn't have2221 * REF_NO_DEREF set. Split it into two updates:2222 * - The original update, but with REF_LOG_ONLY and REF_NO_DEREF set2223 * - A new, separate update for the referent reference2224 * Note that the new update will itself be subject to splitting when2225 * the iteration gets to it.2226 */2227static int split_symref_update(struct files_ref_store *refs,2228 struct ref_update *update,2229 const char *referent,2230 struct ref_transaction *transaction,2231 struct string_list *affected_refnames,2232 struct strbuf *err)2233{2234 struct string_list_item *item;2235 struct ref_update *new_update;2236 unsigned int new_flags;22372238 /*2239 * First make sure that referent is not already in the2240 * transaction. This check is O(lg N) in the transaction2241 * size, but it happens at most once per symref in a2242 * transaction.2243 */2244 if (string_list_has_string(affected_refnames, referent)) {2245 /* An entry already exists */2246 strbuf_addf(err,2247 "multiple updates for '%s' (including one "2248 "via symref '%s') are not allowed",2249 referent, update->refname);2250 return TRANSACTION_NAME_CONFLICT;2251 }22522253 new_flags = update->flags;2254 if (!strcmp(update->refname, "HEAD")) {2255 /*2256 * Record that the new update came via HEAD, so that2257 * when we process it, split_head_update() doesn't try2258 * to add another reflog update for HEAD. Note that2259 * this bit will be propagated if the new_update2260 * itself needs to be split.2261 */2262 new_flags |= REF_UPDATE_VIA_HEAD;2263 }22642265 new_update = ref_transaction_add_update(2266 transaction, referent, new_flags,2267 &update->new_oid, &update->old_oid,2268 update->msg);22692270 new_update->parent_update = update;22712272 /*2273 * Change the symbolic ref update to log only. Also, it2274 * doesn't need to check its old OID value, as that will be2275 * done when new_update is processed.2276 */2277 update->flags |= REF_LOG_ONLY | REF_NO_DEREF;2278 update->flags &= ~REF_HAVE_OLD;22792280 /*2281 * Add the referent. This insertion is O(N) in the transaction2282 * size, but it happens at most once per symref in a2283 * transaction. Make sure to add new_update->refname, which will2284 * be valid as long as affected_refnames is in use, and NOT2285 * referent, which might soon be freed by our caller.2286 */2287 item = string_list_insert(affected_refnames, new_update->refname);2288 if (item->util)2289 BUG("%s unexpectedly found in affected_refnames",2290 new_update->refname);2291 item->util = new_update;22922293 return 0;2294}22952296/*2297 * Return the refname under which update was originally requested.2298 */2299static const char *original_update_refname(struct ref_update *update)2300{2301 while (update->parent_update)2302 update = update->parent_update;23032304 return update->refname;2305}23062307/*2308 * Check whether the REF_HAVE_OLD and old_oid values stored in update2309 * are consistent with oid, which is the reference's current value. If2310 * everything is OK, return 0; otherwise, write an error message to2311 * err and return -1.2312 */2313static int check_old_oid(struct ref_update *update, struct object_id *oid,2314 struct strbuf *err)2315{2316 if (!(update->flags & REF_HAVE_OLD) ||2317 !oidcmp(oid, &update->old_oid))2318 return 0;23192320 if (is_null_oid(&update->old_oid))2321 strbuf_addf(err, "cannot lock ref '%s': "2322 "reference already exists",2323 original_update_refname(update));2324 else if (is_null_oid(oid))2325 strbuf_addf(err, "cannot lock ref '%s': "2326 "reference is missing but expected %s",2327 original_update_refname(update),2328 oid_to_hex(&update->old_oid));2329 else2330 strbuf_addf(err, "cannot lock ref '%s': "2331 "is at %s but expected %s",2332 original_update_refname(update),2333 oid_to_hex(oid),2334 oid_to_hex(&update->old_oid));23352336 return -1;2337}23382339/*2340 * Prepare for carrying out update:2341 * - Lock the reference referred to by update.2342 * - Read the reference under lock.2343 * - Check that its old OID value (if specified) is correct, and in2344 * any case record it in update->lock->old_oid for later use when2345 * writing the reflog.2346 * - If it is a symref update without REF_NO_DEREF, split it up into a2347 * REF_LOG_ONLY update of the symref and add a separate update for2348 * the referent to transaction.2349 * - If it is an update of head_ref, add a corresponding REF_LOG_ONLY2350 * update of HEAD.2351 */2352static int lock_ref_for_update(struct files_ref_store *refs,2353 struct ref_update *update,2354 struct ref_transaction *transaction,2355 const char *head_ref,2356 struct string_list *affected_refnames,2357 struct strbuf *err)2358{2359 struct strbuf referent = STRBUF_INIT;2360 int mustexist = (update->flags & REF_HAVE_OLD) &&2361 !is_null_oid(&update->old_oid);2362 int ret = 0;2363 struct ref_lock *lock;23642365 files_assert_main_repository(refs, "lock_ref_for_update");23662367 if ((update->flags & REF_HAVE_NEW) && is_null_oid(&update->new_oid))2368 update->flags |= REF_DELETING;23692370 if (head_ref) {2371 ret = split_head_update(update, transaction, head_ref,2372 affected_refnames, err);2373 if (ret)2374 goto out;2375 }23762377 ret = lock_raw_ref(refs, update->refname, mustexist,2378 affected_refnames, NULL,2379 &lock, &referent,2380 &update->type, err);2381 if (ret) {2382 char *reason;23832384 reason = strbuf_detach(err, NULL);2385 strbuf_addf(err, "cannot lock ref '%s': %s",2386 original_update_refname(update), reason);2387 free(reason);2388 goto out;2389 }23902391 update->backend_data = lock;23922393 if (update->type & REF_ISSYMREF) {2394 if (update->flags & REF_NO_DEREF) {2395 /*2396 * We won't be reading the referent as part of2397 * the transaction, so we have to read it here2398 * to record and possibly check old_oid:2399 */2400 if (refs_read_ref_full(&refs->base,2401 referent.buf, 0,2402 &lock->old_oid, NULL)) {2403 if (update->flags & REF_HAVE_OLD) {2404 strbuf_addf(err, "cannot lock ref '%s': "2405 "error reading reference",2406 original_update_refname(update));2407 ret = TRANSACTION_GENERIC_ERROR;2408 goto out;2409 }2410 } else if (check_old_oid(update, &lock->old_oid, err)) {2411 ret = TRANSACTION_GENERIC_ERROR;2412 goto out;2413 }2414 } else {2415 /*2416 * Create a new update for the reference this2417 * symref is pointing at. Also, we will record2418 * and verify old_oid for this update as part2419 * of processing the split-off update, so we2420 * don't have to do it here.2421 */2422 ret = split_symref_update(refs, update,2423 referent.buf, transaction,2424 affected_refnames, err);2425 if (ret)2426 goto out;2427 }2428 } else {2429 struct ref_update *parent_update;24302431 if (check_old_oid(update, &lock->old_oid, err)) {2432 ret = TRANSACTION_GENERIC_ERROR;2433 goto out;2434 }24352436 /*2437 * If this update is happening indirectly because of a2438 * symref update, record the old OID in the parent2439 * update:2440 */2441 for (parent_update = update->parent_update;2442 parent_update;2443 parent_update = parent_update->parent_update) {2444 struct ref_lock *parent_lock = parent_update->backend_data;2445 oidcpy(&parent_lock->old_oid, &lock->old_oid);2446 }2447 }24482449 if ((update->flags & REF_HAVE_NEW) &&2450 !(update->flags & REF_DELETING) &&2451 !(update->flags & REF_LOG_ONLY)) {2452 if (!(update->type & REF_ISSYMREF) &&2453 !oidcmp(&lock->old_oid, &update->new_oid)) {2454 /*2455 * The reference already has the desired2456 * value, so we don't need to write it.2457 */2458 } else if (write_ref_to_lockfile(lock, &update->new_oid,2459 err)) {2460 char *write_err = strbuf_detach(err, NULL);24612462 /*2463 * The lock was freed upon failure of2464 * write_ref_to_lockfile():2465 */2466 update->backend_data = NULL;2467 strbuf_addf(err,2468 "cannot update ref '%s': %s",2469 update->refname, write_err);2470 free(write_err);2471 ret = TRANSACTION_GENERIC_ERROR;2472 goto out;2473 } else {2474 update->flags |= REF_NEEDS_COMMIT;2475 }2476 }2477 if (!(update->flags & REF_NEEDS_COMMIT)) {2478 /*2479 * We didn't call write_ref_to_lockfile(), so2480 * the lockfile is still open. Close it to2481 * free up the file descriptor:2482 */2483 if (close_ref_gently(lock)) {2484 strbuf_addf(err, "couldn't close '%s.lock'",2485 update->refname);2486 ret = TRANSACTION_GENERIC_ERROR;2487 goto out;2488 }2489 }24902491out:2492 strbuf_release(&referent);2493 return ret;2494}24952496struct files_transaction_backend_data {2497 struct ref_transaction *packed_transaction;2498 int packed_refs_locked;2499};25002501/*2502 * Unlock any references in `transaction` that are still locked, and2503 * mark the transaction closed.2504 */2505static void files_transaction_cleanup(struct files_ref_store *refs,2506 struct ref_transaction *transaction)2507{2508 size_t i;2509 struct files_transaction_backend_data *backend_data =2510 transaction->backend_data;2511 struct strbuf err = STRBUF_INIT;25122513 for (i = 0; i < transaction->nr; i++) {2514 struct ref_update *update = transaction->updates[i];2515 struct ref_lock *lock = update->backend_data;25162517 if (lock) {2518 unlock_ref(lock);2519 update->backend_data = NULL;2520 }2521 }25222523 if (backend_data->packed_transaction &&2524 ref_transaction_abort(backend_data->packed_transaction, &err)) {2525 error("error aborting transaction: %s", err.buf);2526 strbuf_release(&err);2527 }25282529 if (backend_data->packed_refs_locked)2530 packed_refs_unlock(refs->packed_ref_store);25312532 free(backend_data);25332534 transaction->state = REF_TRANSACTION_CLOSED;2535}25362537static int files_transaction_prepare(struct ref_store *ref_store,2538 struct ref_transaction *transaction,2539 struct strbuf *err)2540{2541 struct files_ref_store *refs =2542 files_downcast(ref_store, REF_STORE_WRITE,2543 "ref_transaction_prepare");2544 size_t i;2545 int ret = 0;2546 struct string_list affected_refnames = STRING_LIST_INIT_NODUP;2547 char *head_ref = NULL;2548 int head_type;2549 struct files_transaction_backend_data *backend_data;2550 struct ref_transaction *packed_transaction = NULL;25512552 assert(err);25532554 if (!transaction->nr)2555 goto cleanup;25562557 backend_data = xcalloc(1, sizeof(*backend_data));2558 transaction->backend_data = backend_data;25592560 /*2561 * Fail if a refname appears more than once in the2562 * transaction. (If we end up splitting up any updates using2563 * split_symref_update() or split_head_update(), those2564 * functions will check that the new updates don't have the2565 * same refname as any existing ones.) Also fail if any of the2566 * updates use REF_IS_PRUNING without REF_NO_DEREF.2567 */2568 for (i = 0; i < transaction->nr; i++) {2569 struct ref_update *update = transaction->updates[i];2570 struct string_list_item *item =2571 string_list_append(&affected_refnames, update->refname);25722573 if ((update->flags & REF_IS_PRUNING) &&2574 !(update->flags & REF_NO_DEREF))2575 BUG("REF_IS_PRUNING set without REF_NO_DEREF");25762577 /*2578 * We store a pointer to update in item->util, but at2579 * the moment we never use the value of this field2580 * except to check whether it is non-NULL.2581 */2582 item->util = update;2583 }2584 string_list_sort(&affected_refnames);2585 if (ref_update_reject_duplicates(&affected_refnames, err)) {2586 ret = TRANSACTION_GENERIC_ERROR;2587 goto cleanup;2588 }25892590 /*2591 * Special hack: If a branch is updated directly and HEAD2592 * points to it (may happen on the remote side of a push2593 * for example) then logically the HEAD reflog should be2594 * updated too.2595 *2596 * A generic solution would require reverse symref lookups,2597 * but finding all symrefs pointing to a given branch would be2598 * rather costly for this rare event (the direct update of a2599 * branch) to be worth it. So let's cheat and check with HEAD2600 * only, which should cover 99% of all usage scenarios (even2601 * 100% of the default ones).2602 *2603 * So if HEAD is a symbolic reference, then record the name of2604 * the reference that it points to. If we see an update of2605 * head_ref within the transaction, then split_head_update()2606 * arranges for the reflog of HEAD to be updated, too.2607 */2608 head_ref = refs_resolve_refdup(ref_store, "HEAD",2609 RESOLVE_REF_NO_RECURSE,2610 NULL, &head_type);26112612 if (head_ref && !(head_type & REF_ISSYMREF)) {2613 FREE_AND_NULL(head_ref);2614 }26152616 /*2617 * Acquire all locks, verify old values if provided, check2618 * that new values are valid, and write new values to the2619 * lockfiles, ready to be activated. Only keep one lockfile2620 * open at a time to avoid running out of file descriptors.2621 * Note that lock_ref_for_update() might append more updates2622 * to the transaction.2623 */2624 for (i = 0; i < transaction->nr; i++) {2625 struct ref_update *update = transaction->updates[i];26262627 ret = lock_ref_for_update(refs, update, transaction,2628 head_ref, &affected_refnames, err);2629 if (ret)2630 goto cleanup;26312632 if (update->flags & REF_DELETING &&2633 !(update->flags & REF_LOG_ONLY) &&2634 !(update->flags & REF_IS_PRUNING)) {2635 /*2636 * This reference has to be deleted from2637 * packed-refs if it exists there.2638 */2639 if (!packed_transaction) {2640 packed_transaction = ref_store_transaction_begin(2641 refs->packed_ref_store, err);2642 if (!packed_transaction) {2643 ret = TRANSACTION_GENERIC_ERROR;2644 goto cleanup;2645 }26462647 backend_data->packed_transaction =2648 packed_transaction;2649 }26502651 ref_transaction_add_update(2652 packed_transaction, update->refname,2653 REF_HAVE_NEW | REF_NO_DEREF,2654 &update->new_oid, NULL,2655 NULL);2656 }2657 }26582659 if (packed_transaction) {2660 if (packed_refs_lock(refs->packed_ref_store, 0, err)) {2661 ret = TRANSACTION_GENERIC_ERROR;2662 goto cleanup;2663 }2664 backend_data->packed_refs_locked = 1;26652666 if (is_packed_transaction_needed(refs->packed_ref_store,2667 packed_transaction)) {2668 ret = ref_transaction_prepare(packed_transaction, err);2669 } else {2670 /*2671 * We can skip rewriting the `packed-refs`2672 * file. But we do need to leave it locked, so2673 * that somebody else doesn't pack a reference2674 * that we are trying to delete.2675 */2676 if (ref_transaction_abort(packed_transaction, err)) {2677 ret = TRANSACTION_GENERIC_ERROR;2678 goto cleanup;2679 }2680 backend_data->packed_transaction = NULL;2681 }2682 }26832684cleanup:2685 free(head_ref);2686 string_list_clear(&affected_refnames, 0);26872688 if (ret)2689 files_transaction_cleanup(refs, transaction);2690 else2691 transaction->state = REF_TRANSACTION_PREPARED;26922693 return ret;2694}26952696static int files_transaction_finish(struct ref_store *ref_store,2697 struct ref_transaction *transaction,2698 struct strbuf *err)2699{2700 struct files_ref_store *refs =2701 files_downcast(ref_store, 0, "ref_transaction_finish");2702 size_t i;2703 int ret = 0;2704 struct strbuf sb = STRBUF_INIT;2705 struct files_transaction_backend_data *backend_data;2706 struct ref_transaction *packed_transaction;270727082709 assert(err);27102711 if (!transaction->nr) {2712 transaction->state = REF_TRANSACTION_CLOSED;2713 return 0;2714 }27152716 backend_data = transaction->backend_data;2717 packed_transaction = backend_data->packed_transaction;27182719 /* Perform updates first so live commits remain referenced */2720 for (i = 0; i < transaction->nr; i++) {2721 struct ref_update *update = transaction->updates[i];2722 struct ref_lock *lock = update->backend_data;27232724 if (update->flags & REF_NEEDS_COMMIT ||2725 update->flags & REF_LOG_ONLY) {2726 if (files_log_ref_write(refs,2727 lock->ref_name,2728 &lock->old_oid,2729 &update->new_oid,2730 update->msg, update->flags,2731 err)) {2732 char *old_msg = strbuf_detach(err, NULL);27332734 strbuf_addf(err, "cannot update the ref '%s': %s",2735 lock->ref_name, old_msg);2736 free(old_msg);2737 unlock_ref(lock);2738 update->backend_data = NULL;2739 ret = TRANSACTION_GENERIC_ERROR;2740 goto cleanup;2741 }2742 }2743 if (update->flags & REF_NEEDS_COMMIT) {2744 clear_loose_ref_cache(refs);2745 if (commit_ref(lock)) {2746 strbuf_addf(err, "couldn't set '%s'", lock->ref_name);2747 unlock_ref(lock);2748 update->backend_data = NULL;2749 ret = TRANSACTION_GENERIC_ERROR;2750 goto cleanup;2751 }2752 }2753 }27542755 /*2756 * Now that updates are safely completed, we can perform2757 * deletes. First delete the reflogs of any references that2758 * will be deleted, since (in the unexpected event of an2759 * error) leaving a reference without a reflog is less bad2760 * than leaving a reflog without a reference (the latter is a2761 * mildly invalid repository state):2762 */2763 for (i = 0; i < transaction->nr; i++) {2764 struct ref_update *update = transaction->updates[i];2765 if (update->flags & REF_DELETING &&2766 !(update->flags & REF_LOG_ONLY) &&2767 !(update->flags & REF_IS_PRUNING)) {2768 strbuf_reset(&sb);2769 files_reflog_path(refs, &sb, update->refname);2770 if (!unlink_or_warn(sb.buf))2771 try_remove_empty_parents(refs, update->refname,2772 REMOVE_EMPTY_PARENTS_REFLOG);2773 }2774 }27752776 /*2777 * Perform deletes now that updates are safely completed.2778 *2779 * First delete any packed versions of the references, while2780 * retaining the packed-refs lock:2781 */2782 if (packed_transaction) {2783 ret = ref_transaction_commit(packed_transaction, err);2784 ref_transaction_free(packed_transaction);2785 packed_transaction = NULL;2786 backend_data->packed_transaction = NULL;2787 if (ret)2788 goto cleanup;2789 }27902791 /* Now delete the loose versions of the references: */2792 for (i = 0; i < transaction->nr; i++) {2793 struct ref_update *update = transaction->updates[i];2794 struct ref_lock *lock = update->backend_data;27952796 if (update->flags & REF_DELETING &&2797 !(update->flags & REF_LOG_ONLY)) {2798 if (!(update->type & REF_ISPACKED) ||2799 update->type & REF_ISSYMREF) {2800 /* It is a loose reference. */2801 strbuf_reset(&sb);2802 files_ref_path(refs, &sb, lock->ref_name);2803 if (unlink_or_msg(sb.buf, err)) {2804 ret = TRANSACTION_GENERIC_ERROR;2805 goto cleanup;2806 }2807 update->flags |= REF_DELETED_LOOSE;2808 }2809 }2810 }28112812 clear_loose_ref_cache(refs);28132814cleanup:2815 files_transaction_cleanup(refs, transaction);28162817 for (i = 0; i < transaction->nr; i++) {2818 struct ref_update *update = transaction->updates[i];28192820 if (update->flags & REF_DELETED_LOOSE) {2821 /*2822 * The loose reference was deleted. Delete any2823 * empty parent directories. (Note that this2824 * can only work because we have already2825 * removed the lockfile.)2826 */2827 try_remove_empty_parents(refs, update->refname,2828 REMOVE_EMPTY_PARENTS_REF);2829 }2830 }28312832 strbuf_release(&sb);2833 return ret;2834}28352836static int files_transaction_abort(struct ref_store *ref_store,2837 struct ref_transaction *transaction,2838 struct strbuf *err)2839{2840 struct files_ref_store *refs =2841 files_downcast(ref_store, 0, "ref_transaction_abort");28422843 files_transaction_cleanup(refs, transaction);2844 return 0;2845}28462847static int ref_present(const char *refname,2848 const struct object_id *oid, int flags, void *cb_data)2849{2850 struct string_list *affected_refnames = cb_data;28512852 return string_list_has_string(affected_refnames, refname);2853}28542855static int files_initial_transaction_commit(struct ref_store *ref_store,2856 struct ref_transaction *transaction,2857 struct strbuf *err)2858{2859 struct files_ref_store *refs =2860 files_downcast(ref_store, REF_STORE_WRITE,2861 "initial_ref_transaction_commit");2862 size_t i;2863 int ret = 0;2864 struct string_list affected_refnames = STRING_LIST_INIT_NODUP;2865 struct ref_transaction *packed_transaction = NULL;28662867 assert(err);28682869 if (transaction->state != REF_TRANSACTION_OPEN)2870 die("BUG: commit called for transaction that is not open");28712872 /* Fail if a refname appears more than once in the transaction: */2873 for (i = 0; i < transaction->nr; i++)2874 string_list_append(&affected_refnames,2875 transaction->updates[i]->refname);2876 string_list_sort(&affected_refnames);2877 if (ref_update_reject_duplicates(&affected_refnames, err)) {2878 ret = TRANSACTION_GENERIC_ERROR;2879 goto cleanup;2880 }28812882 /*2883 * It's really undefined to call this function in an active2884 * repository or when there are existing references: we are2885 * only locking and changing packed-refs, so (1) any2886 * simultaneous processes might try to change a reference at2887 * the same time we do, and (2) any existing loose versions of2888 * the references that we are setting would have precedence2889 * over our values. But some remote helpers create the remote2890 * "HEAD" and "master" branches before calling this function,2891 * so here we really only check that none of the references2892 * that we are creating already exists.2893 */2894 if (refs_for_each_rawref(&refs->base, ref_present,2895 &affected_refnames))2896 die("BUG: initial ref transaction called with existing refs");28972898 packed_transaction = ref_store_transaction_begin(refs->packed_ref_store, err);2899 if (!packed_transaction) {2900 ret = TRANSACTION_GENERIC_ERROR;2901 goto cleanup;2902 }29032904 for (i = 0; i < transaction->nr; i++) {2905 struct ref_update *update = transaction->updates[i];29062907 if ((update->flags & REF_HAVE_OLD) &&2908 !is_null_oid(&update->old_oid))2909 die("BUG: initial ref transaction with old_sha1 set");2910 if (refs_verify_refname_available(&refs->base, update->refname,2911 &affected_refnames, NULL,2912 err)) {2913 ret = TRANSACTION_NAME_CONFLICT;2914 goto cleanup;2915 }29162917 /*2918 * Add a reference creation for this reference to the2919 * packed-refs transaction:2920 */2921 ref_transaction_add_update(packed_transaction, update->refname,2922 update->flags & ~REF_HAVE_OLD,2923 &update->new_oid, &update->old_oid,2924 NULL);2925 }29262927 if (packed_refs_lock(refs->packed_ref_store, 0, err)) {2928 ret = TRANSACTION_GENERIC_ERROR;2929 goto cleanup;2930 }29312932 if (initial_ref_transaction_commit(packed_transaction, err)) {2933 ret = TRANSACTION_GENERIC_ERROR;2934 }29352936 packed_refs_unlock(refs->packed_ref_store);2937cleanup:2938 if (packed_transaction)2939 ref_transaction_free(packed_transaction);2940 transaction->state = REF_TRANSACTION_CLOSED;2941 string_list_clear(&affected_refnames, 0);2942 return ret;2943}29442945struct expire_reflog_cb {2946 unsigned int flags;2947 reflog_expiry_should_prune_fn *should_prune_fn;2948 void *policy_cb;2949 FILE *newlog;2950 struct object_id last_kept_oid;2951};29522953static int expire_reflog_ent(struct object_id *ooid, struct object_id *noid,2954 const char *email, timestamp_t timestamp, int tz,2955 const char *message, void *cb_data)2956{2957 struct expire_reflog_cb *cb = cb_data;2958 struct expire_reflog_policy_cb *policy_cb = cb->policy_cb;29592960 if (cb->flags & EXPIRE_REFLOGS_REWRITE)2961 ooid = &cb->last_kept_oid;29622963 if ((*cb->should_prune_fn)(ooid, noid, email, timestamp, tz,2964 message, policy_cb)) {2965 if (!cb->newlog)2966 printf("would prune %s", message);2967 else if (cb->flags & EXPIRE_REFLOGS_VERBOSE)2968 printf("prune %s", message);2969 } else {2970 if (cb->newlog) {2971 fprintf(cb->newlog, "%s %s %s %"PRItime" %+05d\t%s",2972 oid_to_hex(ooid), oid_to_hex(noid),2973 email, timestamp, tz, message);2974 oidcpy(&cb->last_kept_oid, noid);2975 }2976 if (cb->flags & EXPIRE_REFLOGS_VERBOSE)2977 printf("keep %s", message);2978 }2979 return 0;2980}29812982static int files_reflog_expire(struct ref_store *ref_store,2983 const char *refname, const struct object_id *oid,2984 unsigned int flags,2985 reflog_expiry_prepare_fn prepare_fn,2986 reflog_expiry_should_prune_fn should_prune_fn,2987 reflog_expiry_cleanup_fn cleanup_fn,2988 void *policy_cb_data)2989{2990 struct files_ref_store *refs =2991 files_downcast(ref_store, REF_STORE_WRITE, "reflog_expire");2992 static struct lock_file reflog_lock;2993 struct expire_reflog_cb cb;2994 struct ref_lock *lock;2995 struct strbuf log_file_sb = STRBUF_INIT;2996 char *log_file;2997 int status = 0;2998 int type;2999 struct strbuf err = STRBUF_INIT;30003001 memset(&cb, 0, sizeof(cb));3002 cb.flags = flags;3003 cb.policy_cb = policy_cb_data;3004 cb.should_prune_fn = should_prune_fn;30053006 /*3007 * The reflog file is locked by holding the lock on the3008 * reference itself, plus we might need to update the3009 * reference if --updateref was specified:3010 */3011 lock = lock_ref_oid_basic(refs, refname, oid,3012 NULL, NULL, REF_NO_DEREF,3013 &type, &err);3014 if (!lock) {3015 error("cannot lock ref '%s': %s", refname, err.buf);3016 strbuf_release(&err);3017 return -1;3018 }3019 if (!refs_reflog_exists(ref_store, refname)) {3020 unlock_ref(lock);3021 return 0;3022 }30233024 files_reflog_path(refs, &log_file_sb, refname);3025 log_file = strbuf_detach(&log_file_sb, NULL);3026 if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {3027 /*3028 * Even though holding $GIT_DIR/logs/$reflog.lock has3029 * no locking implications, we use the lock_file3030 * machinery here anyway because it does a lot of the3031 * work we need, including cleaning up if the program3032 * exits unexpectedly.3033 */3034 if (hold_lock_file_for_update(&reflog_lock, log_file, 0) < 0) {3035 struct strbuf err = STRBUF_INIT;3036 unable_to_lock_message(log_file, errno, &err);3037 error("%s", err.buf);3038 strbuf_release(&err);3039 goto failure;3040 }3041 cb.newlog = fdopen_lock_file(&reflog_lock, "w");3042 if (!cb.newlog) {3043 error("cannot fdopen %s (%s)",3044 get_lock_file_path(&reflog_lock), strerror(errno));3045 goto failure;3046 }3047 }30483049 (*prepare_fn)(refname, oid, cb.policy_cb);3050 refs_for_each_reflog_ent(ref_store, refname, expire_reflog_ent, &cb);3051 (*cleanup_fn)(cb.policy_cb);30523053 if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {3054 /*3055 * It doesn't make sense to adjust a reference pointed3056 * to by a symbolic ref based on expiring entries in3057 * the symbolic reference's reflog. Nor can we update3058 * a reference if there are no remaining reflog3059 * entries.3060 */3061 int update = (flags & EXPIRE_REFLOGS_UPDATE_REF) &&3062 !(type & REF_ISSYMREF) &&3063 !is_null_oid(&cb.last_kept_oid);30643065 if (close_lock_file_gently(&reflog_lock)) {3066 status |= error("couldn't write %s: %s", log_file,3067 strerror(errno));3068 rollback_lock_file(&reflog_lock);3069 } else if (update &&3070 (write_in_full(get_lock_file_fd(&lock->lk),3071 oid_to_hex(&cb.last_kept_oid), GIT_SHA1_HEXSZ) < 0 ||3072 write_str_in_full(get_lock_file_fd(&lock->lk), "\n") < 0 ||3073 close_ref_gently(lock) < 0)) {3074 status |= error("couldn't write %s",3075 get_lock_file_path(&lock->lk));3076 rollback_lock_file(&reflog_lock);3077 } else if (commit_lock_file(&reflog_lock)) {3078 status |= error("unable to write reflog '%s' (%s)",3079 log_file, strerror(errno));3080 } else if (update && commit_ref(lock)) {3081 status |= error("couldn't set %s", lock->ref_name);3082 }3083 }3084 free(log_file);3085 unlock_ref(lock);3086 return status;30873088 failure:3089 rollback_lock_file(&reflog_lock);3090 free(log_file);3091 unlock_ref(lock);3092 return -1;3093}30943095static int files_init_db(struct ref_store *ref_store, struct strbuf *err)3096{3097 struct files_ref_store *refs =3098 files_downcast(ref_store, REF_STORE_WRITE, "init_db");3099 struct strbuf sb = STRBUF_INIT;31003101 /*3102 * Create .git/refs/{heads,tags}3103 */3104 files_ref_path(refs, &sb, "refs/heads");3105 safe_create_dir(sb.buf, 1);31063107 strbuf_reset(&sb);3108 files_ref_path(refs, &sb, "refs/tags");3109 safe_create_dir(sb.buf, 1);31103111 strbuf_release(&sb);3112 return 0;3113}31143115struct ref_storage_be refs_be_files = {3116 NULL,3117 "files",3118 files_ref_store_create,3119 files_init_db,3120 files_transaction_prepare,3121 files_transaction_finish,3122 files_transaction_abort,3123 files_initial_transaction_commit,31243125 files_pack_refs,3126 files_create_symref,3127 files_delete_refs,3128 files_rename_ref,3129 files_copy_ref,31303131 files_ref_iterator_begin,3132 files_read_raw_ref,31333134 files_reflog_iterator_begin,3135 files_for_each_reflog_ent,3136 files_for_each_reflog_ent_reverse,3137 files_reflog_exists,3138 files_create_reflog,3139 files_delete_reflog,3140 files_reflog_expire3141};