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 13struct ref_lock { 14char*ref_name; 15struct lock_file *lk; 16struct object_id old_oid; 17}; 18 19/* 20 * Future: need to be in "struct repository" 21 * when doing a full libification. 22 */ 23struct files_ref_store { 24struct ref_store base; 25unsigned int store_flags; 26 27char*gitdir; 28char*gitcommondir; 29 30struct ref_cache *loose; 31 32struct ref_store *packed_ref_store; 33}; 34 35static voidclear_loose_ref_cache(struct files_ref_store *refs) 36{ 37if(refs->loose) { 38free_ref_cache(refs->loose); 39 refs->loose = NULL; 40} 41} 42 43/* 44 * Create a new submodule ref cache and add it to the internal 45 * set of caches. 46 */ 47static struct ref_store *files_ref_store_create(const char*gitdir, 48unsigned int flags) 49{ 50struct files_ref_store *refs =xcalloc(1,sizeof(*refs)); 51struct ref_store *ref_store = (struct ref_store *)refs; 52struct strbuf sb = STRBUF_INIT; 53 54base_ref_store_init(ref_store, &refs_be_files); 55 refs->store_flags = flags; 56 57 refs->gitdir =xstrdup(gitdir); 58get_common_dir_noenv(&sb, gitdir); 59 refs->gitcommondir =strbuf_detach(&sb, NULL); 60strbuf_addf(&sb,"%s/packed-refs", refs->gitcommondir); 61 refs->packed_ref_store =packed_ref_store_create(sb.buf, flags); 62strbuf_release(&sb); 63 64return ref_store; 65} 66 67/* 68 * Die if refs is not the main ref store. caller is used in any 69 * necessary error messages. 70 */ 71static voidfiles_assert_main_repository(struct files_ref_store *refs, 72const char*caller) 73{ 74if(refs->store_flags & REF_STORE_MAIN) 75return; 76 77die("BUG: operation%sonly allowed for main ref store", caller); 78} 79 80/* 81 * Downcast ref_store to files_ref_store. Die if ref_store is not a 82 * files_ref_store. required_flags is compared with ref_store's 83 * store_flags to ensure the ref_store has all required capabilities. 84 * "caller" is used in any necessary error messages. 85 */ 86static struct files_ref_store *files_downcast(struct ref_store *ref_store, 87unsigned int required_flags, 88const char*caller) 89{ 90struct files_ref_store *refs; 91 92if(ref_store->be != &refs_be_files) 93die("BUG: ref_store is type\"%s\"not\"files\"in%s", 94 ref_store->be->name, caller); 95 96 refs = (struct files_ref_store *)ref_store; 97 98if((refs->store_flags & required_flags) != required_flags) 99die("BUG: operation%srequires abilities 0x%x, but only have 0x%x", 100 caller, required_flags, refs->store_flags); 101 102return refs; 103} 104 105static voidfiles_reflog_path(struct files_ref_store *refs, 106struct strbuf *sb, 107const char*refname) 108{ 109if(!refname) { 110/* 111 * FIXME: of course this is wrong in multi worktree 112 * setting. To be fixed real soon. 113 */ 114strbuf_addf(sb,"%s/logs", refs->gitcommondir); 115return; 116} 117 118switch(ref_type(refname)) { 119case REF_TYPE_PER_WORKTREE: 120case REF_TYPE_PSEUDOREF: 121strbuf_addf(sb,"%s/logs/%s", refs->gitdir, refname); 122break; 123case REF_TYPE_NORMAL: 124strbuf_addf(sb,"%s/logs/%s", refs->gitcommondir, refname); 125break; 126default: 127die("BUG: unknown ref type%dof ref%s", 128ref_type(refname), refname); 129} 130} 131 132static voidfiles_ref_path(struct files_ref_store *refs, 133struct strbuf *sb, 134const char*refname) 135{ 136switch(ref_type(refname)) { 137case REF_TYPE_PER_WORKTREE: 138case REF_TYPE_PSEUDOREF: 139strbuf_addf(sb,"%s/%s", refs->gitdir, refname); 140break; 141case REF_TYPE_NORMAL: 142strbuf_addf(sb,"%s/%s", refs->gitcommondir, refname); 143break; 144default: 145die("BUG: unknown ref type%dof ref%s", 146ref_type(refname), refname); 147} 148} 149 150/* 151 * Read the loose references from the namespace dirname into dir 152 * (without recursing). dirname must end with '/'. dir must be the 153 * directory entry corresponding to dirname. 154 */ 155static voidloose_fill_ref_dir(struct ref_store *ref_store, 156struct ref_dir *dir,const char*dirname) 157{ 158struct files_ref_store *refs = 159files_downcast(ref_store, REF_STORE_READ,"fill_ref_dir"); 160DIR*d; 161struct dirent *de; 162int dirnamelen =strlen(dirname); 163struct strbuf refname; 164struct strbuf path = STRBUF_INIT; 165size_t path_baselen; 166 167files_ref_path(refs, &path, dirname); 168 path_baselen = path.len; 169 170 d =opendir(path.buf); 171if(!d) { 172strbuf_release(&path); 173return; 174} 175 176strbuf_init(&refname, dirnamelen +257); 177strbuf_add(&refname, dirname, dirnamelen); 178 179while((de =readdir(d)) != NULL) { 180struct object_id oid; 181struct stat st; 182int flag; 183 184if(de->d_name[0] =='.') 185continue; 186if(ends_with(de->d_name,".lock")) 187continue; 188strbuf_addstr(&refname, de->d_name); 189strbuf_addstr(&path, de->d_name); 190if(stat(path.buf, &st) <0) { 191;/* silently ignore */ 192}else if(S_ISDIR(st.st_mode)) { 193strbuf_addch(&refname,'/'); 194add_entry_to_dir(dir, 195create_dir_entry(dir->cache, refname.buf, 196 refname.len,1)); 197}else{ 198if(!refs_resolve_ref_unsafe(&refs->base, 199 refname.buf, 200 RESOLVE_REF_READING, 201 oid.hash, &flag)) { 202oidclr(&oid); 203 flag |= REF_ISBROKEN; 204}else if(is_null_oid(&oid)) { 205/* 206 * It is so astronomically unlikely 207 * that NULL_SHA1 is the SHA-1 of an 208 * actual object that we consider its 209 * appearance in a loose reference 210 * file to be repo corruption 211 * (probably due to a software bug). 212 */ 213 flag |= REF_ISBROKEN; 214} 215 216if(check_refname_format(refname.buf, 217 REFNAME_ALLOW_ONELEVEL)) { 218if(!refname_is_safe(refname.buf)) 219die("loose refname is dangerous:%s", refname.buf); 220oidclr(&oid); 221 flag |= REF_BAD_NAME | REF_ISBROKEN; 222} 223add_entry_to_dir(dir, 224create_ref_entry(refname.buf, &oid, flag)); 225} 226strbuf_setlen(&refname, dirnamelen); 227strbuf_setlen(&path, path_baselen); 228} 229strbuf_release(&refname); 230strbuf_release(&path); 231closedir(d); 232 233/* 234 * Manually add refs/bisect, which, being per-worktree, might 235 * not appear in the directory listing for refs/ in the main 236 * repo. 237 */ 238if(!strcmp(dirname,"refs/")) { 239int pos =search_ref_dir(dir,"refs/bisect/",12); 240 241if(pos <0) { 242struct ref_entry *child_entry =create_dir_entry( 243 dir->cache,"refs/bisect/",12,1); 244add_entry_to_dir(dir, child_entry); 245} 246} 247} 248 249static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs) 250{ 251if(!refs->loose) { 252/* 253 * Mark the top-level directory complete because we 254 * are about to read the only subdirectory that can 255 * hold references: 256 */ 257 refs->loose =create_ref_cache(&refs->base, loose_fill_ref_dir); 258 259/* We're going to fill the top level ourselves: */ 260 refs->loose->root->flag &= ~REF_INCOMPLETE; 261 262/* 263 * Add an incomplete entry for "refs/" (to be filled 264 * lazily): 265 */ 266add_entry_to_dir(get_ref_dir(refs->loose->root), 267create_dir_entry(refs->loose,"refs/",5,1)); 268} 269return refs->loose; 270} 271 272static intfiles_read_raw_ref(struct ref_store *ref_store, 273const char*refname,unsigned char*sha1, 274struct strbuf *referent,unsigned int*type) 275{ 276struct files_ref_store *refs = 277files_downcast(ref_store, REF_STORE_READ,"read_raw_ref"); 278struct strbuf sb_contents = STRBUF_INIT; 279struct strbuf sb_path = STRBUF_INIT; 280const char*path; 281const char*buf; 282struct stat st; 283int fd; 284int ret = -1; 285int save_errno; 286int remaining_retries =3; 287 288*type =0; 289strbuf_reset(&sb_path); 290 291files_ref_path(refs, &sb_path, refname); 292 293 path = sb_path.buf; 294 295stat_ref: 296/* 297 * We might have to loop back here to avoid a race 298 * condition: first we lstat() the file, then we try 299 * to read it as a link or as a file. But if somebody 300 * changes the type of the file (file <-> directory 301 * <-> symlink) between the lstat() and reading, then 302 * we don't want to report that as an error but rather 303 * try again starting with the lstat(). 304 * 305 * We'll keep a count of the retries, though, just to avoid 306 * any confusing situation sending us into an infinite loop. 307 */ 308 309if(remaining_retries-- <=0) 310goto out; 311 312if(lstat(path, &st) <0) { 313if(errno != ENOENT) 314goto out; 315if(refs_read_raw_ref(refs->packed_ref_store, refname, 316 sha1, referent, type)) { 317 errno = ENOENT; 318goto out; 319} 320 ret =0; 321goto out; 322} 323 324/* Follow "normalized" - ie "refs/.." symlinks by hand */ 325if(S_ISLNK(st.st_mode)) { 326strbuf_reset(&sb_contents); 327if(strbuf_readlink(&sb_contents, path,0) <0) { 328if(errno == ENOENT || errno == EINVAL) 329/* inconsistent with lstat; retry */ 330goto stat_ref; 331else 332goto out; 333} 334if(starts_with(sb_contents.buf,"refs/") && 335!check_refname_format(sb_contents.buf,0)) { 336strbuf_swap(&sb_contents, referent); 337*type |= REF_ISSYMREF; 338 ret =0; 339goto out; 340} 341/* 342 * It doesn't look like a refname; fall through to just 343 * treating it like a non-symlink, and reading whatever it 344 * points to. 345 */ 346} 347 348/* Is it a directory? */ 349if(S_ISDIR(st.st_mode)) { 350/* 351 * Even though there is a directory where the loose 352 * ref is supposed to be, there could still be a 353 * packed ref: 354 */ 355if(refs_read_raw_ref(refs->packed_ref_store, refname, 356 sha1, referent, type)) { 357 errno = EISDIR; 358goto out; 359} 360 ret =0; 361goto out; 362} 363 364/* 365 * Anything else, just open it and try to use it as 366 * a ref 367 */ 368 fd =open(path, O_RDONLY); 369if(fd <0) { 370if(errno == ENOENT && !S_ISLNK(st.st_mode)) 371/* inconsistent with lstat; retry */ 372goto stat_ref; 373else 374goto out; 375} 376strbuf_reset(&sb_contents); 377if(strbuf_read(&sb_contents, fd,256) <0) { 378int save_errno = errno; 379close(fd); 380 errno = save_errno; 381goto out; 382} 383close(fd); 384strbuf_rtrim(&sb_contents); 385 buf = sb_contents.buf; 386if(starts_with(buf,"ref:")) { 387 buf +=4; 388while(isspace(*buf)) 389 buf++; 390 391strbuf_reset(referent); 392strbuf_addstr(referent, buf); 393*type |= REF_ISSYMREF; 394 ret =0; 395goto out; 396} 397 398/* 399 * Please note that FETCH_HEAD has additional 400 * data after the sha. 401 */ 402if(get_sha1_hex(buf, sha1) || 403(buf[40] !='\0'&& !isspace(buf[40]))) { 404*type |= REF_ISBROKEN; 405 errno = EINVAL; 406goto out; 407} 408 409 ret =0; 410 411out: 412 save_errno = errno; 413strbuf_release(&sb_path); 414strbuf_release(&sb_contents); 415 errno = save_errno; 416return ret; 417} 418 419static voidunlock_ref(struct ref_lock *lock) 420{ 421/* Do not free lock->lk -- atexit() still looks at them */ 422if(lock->lk) 423rollback_lock_file(lock->lk); 424free(lock->ref_name); 425free(lock); 426} 427 428/* 429 * Lock refname, without following symrefs, and set *lock_p to point 430 * at a newly-allocated lock object. Fill in lock->old_oid, referent, 431 * and type similarly to read_raw_ref(). 432 * 433 * The caller must verify that refname is a "safe" reference name (in 434 * the sense of refname_is_safe()) before calling this function. 435 * 436 * If the reference doesn't already exist, verify that refname doesn't 437 * have a D/F conflict with any existing references. extras and skip 438 * are passed to refs_verify_refname_available() for this check. 439 * 440 * If mustexist is not set and the reference is not found or is 441 * broken, lock the reference anyway but clear sha1. 442 * 443 * Return 0 on success. On failure, write an error message to err and 444 * return TRANSACTION_NAME_CONFLICT or TRANSACTION_GENERIC_ERROR. 445 * 446 * Implementation note: This function is basically 447 * 448 * lock reference 449 * read_raw_ref() 450 * 451 * but it includes a lot more code to 452 * - Deal with possible races with other processes 453 * - Avoid calling refs_verify_refname_available() when it can be 454 * avoided, namely if we were successfully able to read the ref 455 * - Generate informative error messages in the case of failure 456 */ 457static intlock_raw_ref(struct files_ref_store *refs, 458const char*refname,int mustexist, 459const struct string_list *extras, 460const struct string_list *skip, 461struct ref_lock **lock_p, 462struct strbuf *referent, 463unsigned int*type, 464struct strbuf *err) 465{ 466struct ref_lock *lock; 467struct strbuf ref_file = STRBUF_INIT; 468int attempts_remaining =3; 469int ret = TRANSACTION_GENERIC_ERROR; 470 471assert(err); 472files_assert_main_repository(refs,"lock_raw_ref"); 473 474*type =0; 475 476/* First lock the file so it can't change out from under us. */ 477 478*lock_p = lock =xcalloc(1,sizeof(*lock)); 479 480 lock->ref_name =xstrdup(refname); 481files_ref_path(refs, &ref_file, refname); 482 483retry: 484switch(safe_create_leading_directories(ref_file.buf)) { 485case SCLD_OK: 486break;/* success */ 487case SCLD_EXISTS: 488/* 489 * Suppose refname is "refs/foo/bar". We just failed 490 * to create the containing directory, "refs/foo", 491 * because there was a non-directory in the way. This 492 * indicates a D/F conflict, probably because of 493 * another reference such as "refs/foo". There is no 494 * reason to expect this error to be transitory. 495 */ 496if(refs_verify_refname_available(&refs->base, refname, 497 extras, skip, err)) { 498if(mustexist) { 499/* 500 * To the user the relevant error is 501 * that the "mustexist" reference is 502 * missing: 503 */ 504strbuf_reset(err); 505strbuf_addf(err,"unable to resolve reference '%s'", 506 refname); 507}else{ 508/* 509 * The error message set by 510 * refs_verify_refname_available() is 511 * OK. 512 */ 513 ret = TRANSACTION_NAME_CONFLICT; 514} 515}else{ 516/* 517 * The file that is in the way isn't a loose 518 * reference. Report it as a low-level 519 * failure. 520 */ 521strbuf_addf(err,"unable to create lock file%s.lock; " 522"non-directory in the way", 523 ref_file.buf); 524} 525goto error_return; 526case SCLD_VANISHED: 527/* Maybe another process was tidying up. Try again. */ 528if(--attempts_remaining >0) 529goto retry; 530/* fall through */ 531default: 532strbuf_addf(err,"unable to create directory for%s", 533 ref_file.buf); 534goto error_return; 535} 536 537if(!lock->lk) 538 lock->lk =xcalloc(1,sizeof(struct lock_file)); 539 540if(hold_lock_file_for_update_timeout( 541 lock->lk, ref_file.buf, LOCK_NO_DEREF, 542get_files_ref_lock_timeout_ms()) <0) { 543if(errno == ENOENT && --attempts_remaining >0) { 544/* 545 * Maybe somebody just deleted one of the 546 * directories leading to ref_file. Try 547 * again: 548 */ 549goto retry; 550}else{ 551unable_to_lock_message(ref_file.buf, errno, err); 552goto error_return; 553} 554} 555 556/* 557 * Now we hold the lock and can read the reference without 558 * fear that its value will change. 559 */ 560 561if(files_read_raw_ref(&refs->base, refname, 562 lock->old_oid.hash, referent, type)) { 563if(errno == ENOENT) { 564if(mustexist) { 565/* Garden variety missing reference. */ 566strbuf_addf(err,"unable to resolve reference '%s'", 567 refname); 568goto error_return; 569}else{ 570/* 571 * Reference is missing, but that's OK. We 572 * know that there is not a conflict with 573 * another loose reference because 574 * (supposing that we are trying to lock 575 * reference "refs/foo/bar"): 576 * 577 * - We were successfully able to create 578 * the lockfile refs/foo/bar.lock, so we 579 * know there cannot be a loose reference 580 * named "refs/foo". 581 * 582 * - We got ENOENT and not EISDIR, so we 583 * know that there cannot be a loose 584 * reference named "refs/foo/bar/baz". 585 */ 586} 587}else if(errno == EISDIR) { 588/* 589 * There is a directory in the way. It might have 590 * contained references that have been deleted. If 591 * we don't require that the reference already 592 * exists, try to remove the directory so that it 593 * doesn't cause trouble when we want to rename the 594 * lockfile into place later. 595 */ 596if(mustexist) { 597/* Garden variety missing reference. */ 598strbuf_addf(err,"unable to resolve reference '%s'", 599 refname); 600goto error_return; 601}else if(remove_dir_recursively(&ref_file, 602 REMOVE_DIR_EMPTY_ONLY)) { 603if(refs_verify_refname_available( 604&refs->base, refname, 605 extras, skip, err)) { 606/* 607 * The error message set by 608 * verify_refname_available() is OK. 609 */ 610 ret = TRANSACTION_NAME_CONFLICT; 611goto error_return; 612}else{ 613/* 614 * We can't delete the directory, 615 * but we also don't know of any 616 * references that it should 617 * contain. 618 */ 619strbuf_addf(err,"there is a non-empty directory '%s' " 620"blocking reference '%s'", 621 ref_file.buf, refname); 622goto error_return; 623} 624} 625}else if(errno == EINVAL && (*type & REF_ISBROKEN)) { 626strbuf_addf(err,"unable to resolve reference '%s': " 627"reference broken", refname); 628goto error_return; 629}else{ 630strbuf_addf(err,"unable to resolve reference '%s':%s", 631 refname,strerror(errno)); 632goto error_return; 633} 634 635/* 636 * If the ref did not exist and we are creating it, 637 * make sure there is no existing packed ref that 638 * conflicts with refname: 639 */ 640if(refs_verify_refname_available( 641 refs->packed_ref_store, refname, 642 extras, skip, err)) 643goto error_return; 644} 645 646 ret =0; 647goto out; 648 649error_return: 650unlock_ref(lock); 651*lock_p = NULL; 652 653out: 654strbuf_release(&ref_file); 655return ret; 656} 657 658static intfiles_peel_ref(struct ref_store *ref_store, 659const char*refname,unsigned char*sha1) 660{ 661struct files_ref_store *refs = 662files_downcast(ref_store, REF_STORE_READ | REF_STORE_ODB, 663"peel_ref"); 664int flag; 665unsigned char base[20]; 666 667if(current_ref_iter && current_ref_iter->refname == refname) { 668struct object_id peeled; 669 670if(ref_iterator_peel(current_ref_iter, &peeled)) 671return-1; 672hashcpy(sha1, peeled.hash); 673return0; 674} 675 676if(refs_read_ref_full(ref_store, refname, 677 RESOLVE_REF_READING, base, &flag)) 678return-1; 679 680/* 681 * If the reference is packed, read its ref_entry from the 682 * cache in the hope that we already know its peeled value. 683 * We only try this optimization on packed references because 684 * (a) forcing the filling of the loose reference cache could 685 * be expensive and (b) loose references anyway usually do not 686 * have REF_KNOWS_PEELED. 687 */ 688if(flag & REF_ISPACKED && 689!refs_peel_ref(refs->packed_ref_store, refname, sha1)) 690return0; 691 692returnpeel_object(base, sha1); 693} 694 695struct files_ref_iterator { 696struct ref_iterator base; 697 698struct ref_iterator *iter0; 699unsigned int flags; 700}; 701 702static intfiles_ref_iterator_advance(struct ref_iterator *ref_iterator) 703{ 704struct files_ref_iterator *iter = 705(struct files_ref_iterator *)ref_iterator; 706int ok; 707 708while((ok =ref_iterator_advance(iter->iter0)) == ITER_OK) { 709if(iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY && 710ref_type(iter->iter0->refname) != REF_TYPE_PER_WORKTREE) 711continue; 712 713if(!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 714!ref_resolves_to_object(iter->iter0->refname, 715 iter->iter0->oid, 716 iter->iter0->flags)) 717continue; 718 719 iter->base.refname = iter->iter0->refname; 720 iter->base.oid = iter->iter0->oid; 721 iter->base.flags = iter->iter0->flags; 722return ITER_OK; 723} 724 725 iter->iter0 = NULL; 726if(ref_iterator_abort(ref_iterator) != ITER_DONE) 727 ok = ITER_ERROR; 728 729return ok; 730} 731 732static intfiles_ref_iterator_peel(struct ref_iterator *ref_iterator, 733struct object_id *peeled) 734{ 735struct files_ref_iterator *iter = 736(struct files_ref_iterator *)ref_iterator; 737 738returnref_iterator_peel(iter->iter0, peeled); 739} 740 741static intfiles_ref_iterator_abort(struct ref_iterator *ref_iterator) 742{ 743struct files_ref_iterator *iter = 744(struct files_ref_iterator *)ref_iterator; 745int ok = ITER_DONE; 746 747if(iter->iter0) 748 ok =ref_iterator_abort(iter->iter0); 749 750base_ref_iterator_free(ref_iterator); 751return ok; 752} 753 754static struct ref_iterator_vtable files_ref_iterator_vtable = { 755 files_ref_iterator_advance, 756 files_ref_iterator_peel, 757 files_ref_iterator_abort 758}; 759 760static struct ref_iterator *files_ref_iterator_begin( 761struct ref_store *ref_store, 762const char*prefix,unsigned int flags) 763{ 764struct files_ref_store *refs; 765struct ref_iterator *loose_iter, *packed_iter; 766struct files_ref_iterator *iter; 767struct ref_iterator *ref_iterator; 768unsigned int required_flags = REF_STORE_READ; 769 770if(!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) 771 required_flags |= REF_STORE_ODB; 772 773 refs =files_downcast(ref_store, required_flags,"ref_iterator_begin"); 774 775 iter =xcalloc(1,sizeof(*iter)); 776 ref_iterator = &iter->base; 777base_ref_iterator_init(ref_iterator, &files_ref_iterator_vtable); 778 779/* 780 * We must make sure that all loose refs are read before 781 * accessing the packed-refs file; this avoids a race 782 * condition if loose refs are migrated to the packed-refs 783 * file by a simultaneous process, but our in-memory view is 784 * from before the migration. We ensure this as follows: 785 * First, we call start the loose refs iteration with its 786 * `prime_ref` argument set to true. This causes the loose 787 * references in the subtree to be pre-read into the cache. 788 * (If they've already been read, that's OK; we only need to 789 * guarantee that they're read before the packed refs, not 790 * *how much* before.) After that, we call 791 * packed_ref_iterator_begin(), which internally checks 792 * whether the packed-ref cache is up to date with what is on 793 * disk, and re-reads it if not. 794 */ 795 796 loose_iter =cache_ref_iterator_begin(get_loose_ref_cache(refs), 797 prefix,1); 798 799/* 800 * The packed-refs file might contain broken references, for 801 * example an old version of a reference that points at an 802 * object that has since been garbage-collected. This is OK as 803 * long as there is a corresponding loose reference that 804 * overrides it, and we don't want to emit an error message in 805 * this case. So ask the packed_ref_store for all of its 806 * references, and (if needed) do our own check for broken 807 * ones in files_ref_iterator_advance(), after we have merged 808 * the packed and loose references. 809 */ 810 packed_iter =refs_ref_iterator_begin( 811 refs->packed_ref_store, prefix,0, 812 DO_FOR_EACH_INCLUDE_BROKEN); 813 814 iter->iter0 =overlay_ref_iterator_begin(loose_iter, packed_iter); 815 iter->flags = flags; 816 817return ref_iterator; 818} 819 820/* 821 * Verify that the reference locked by lock has the value old_sha1. 822 * Fail if the reference doesn't exist and mustexist is set. Return 0 823 * on success. On error, write an error message to err, set errno, and 824 * return a negative value. 825 */ 826static intverify_lock(struct ref_store *ref_store,struct ref_lock *lock, 827const unsigned char*old_sha1,int mustexist, 828struct strbuf *err) 829{ 830assert(err); 831 832if(refs_read_ref_full(ref_store, lock->ref_name, 833 mustexist ? RESOLVE_REF_READING :0, 834 lock->old_oid.hash, NULL)) { 835if(old_sha1) { 836int save_errno = errno; 837strbuf_addf(err,"can't verify ref '%s'", lock->ref_name); 838 errno = save_errno; 839return-1; 840}else{ 841oidclr(&lock->old_oid); 842return0; 843} 844} 845if(old_sha1 &&hashcmp(lock->old_oid.hash, old_sha1)) { 846strbuf_addf(err,"ref '%s' is at%sbut expected%s", 847 lock->ref_name, 848oid_to_hex(&lock->old_oid), 849sha1_to_hex(old_sha1)); 850 errno = EBUSY; 851return-1; 852} 853return0; 854} 855 856static intremove_empty_directories(struct strbuf *path) 857{ 858/* 859 * we want to create a file but there is a directory there; 860 * if that is an empty directory (or a directory that contains 861 * only empty directories), remove them. 862 */ 863returnremove_dir_recursively(path, REMOVE_DIR_EMPTY_ONLY); 864} 865 866static intcreate_reflock(const char*path,void*cb) 867{ 868struct lock_file *lk = cb; 869 870returnhold_lock_file_for_update_timeout( 871 lk, path, LOCK_NO_DEREF, 872get_files_ref_lock_timeout_ms()) <0? -1:0; 873} 874 875/* 876 * Locks a ref returning the lock on success and NULL on failure. 877 * On failure errno is set to something meaningful. 878 */ 879static struct ref_lock *lock_ref_sha1_basic(struct files_ref_store *refs, 880const char*refname, 881const unsigned char*old_sha1, 882const struct string_list *extras, 883const struct string_list *skip, 884unsigned int flags,int*type, 885struct strbuf *err) 886{ 887struct strbuf ref_file = STRBUF_INIT; 888struct ref_lock *lock; 889int last_errno =0; 890int mustexist = (old_sha1 && !is_null_sha1(old_sha1)); 891int resolve_flags = RESOLVE_REF_NO_RECURSE; 892int resolved; 893 894files_assert_main_repository(refs,"lock_ref_sha1_basic"); 895assert(err); 896 897 lock =xcalloc(1,sizeof(struct ref_lock)); 898 899if(mustexist) 900 resolve_flags |= RESOLVE_REF_READING; 901if(flags & REF_DELETING) 902 resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME; 903 904files_ref_path(refs, &ref_file, refname); 905 resolved = !!refs_resolve_ref_unsafe(&refs->base, 906 refname, resolve_flags, 907 lock->old_oid.hash, type); 908if(!resolved && errno == EISDIR) { 909/* 910 * we are trying to lock foo but we used to 911 * have foo/bar which now does not exist; 912 * it is normal for the empty directory 'foo' 913 * to remain. 914 */ 915if(remove_empty_directories(&ref_file)) { 916 last_errno = errno; 917if(!refs_verify_refname_available( 918&refs->base, 919 refname, extras, skip, err)) 920strbuf_addf(err,"there are still refs under '%s'", 921 refname); 922goto error_return; 923} 924 resolved = !!refs_resolve_ref_unsafe(&refs->base, 925 refname, resolve_flags, 926 lock->old_oid.hash, type); 927} 928if(!resolved) { 929 last_errno = errno; 930if(last_errno != ENOTDIR || 931!refs_verify_refname_available(&refs->base, refname, 932 extras, skip, err)) 933strbuf_addf(err,"unable to resolve reference '%s':%s", 934 refname,strerror(last_errno)); 935 936goto error_return; 937} 938 939/* 940 * If the ref did not exist and we are creating it, make sure 941 * there is no existing packed ref whose name begins with our 942 * refname, nor a packed ref whose name is a proper prefix of 943 * our refname. 944 */ 945if(is_null_oid(&lock->old_oid) && 946refs_verify_refname_available(refs->packed_ref_store, refname, 947 extras, skip, err)) { 948 last_errno = ENOTDIR; 949goto error_return; 950} 951 952 lock->lk =xcalloc(1,sizeof(struct lock_file)); 953 954 lock->ref_name =xstrdup(refname); 955 956if(raceproof_create_file(ref_file.buf, create_reflock, lock->lk)) { 957 last_errno = errno; 958unable_to_lock_message(ref_file.buf, errno, err); 959goto error_return; 960} 961 962if(verify_lock(&refs->base, lock, old_sha1, mustexist, err)) { 963 last_errno = errno; 964goto error_return; 965} 966goto out; 967 968 error_return: 969unlock_ref(lock); 970 lock = NULL; 971 972 out: 973strbuf_release(&ref_file); 974 errno = last_errno; 975return lock; 976} 977 978struct ref_to_prune { 979struct ref_to_prune *next; 980unsigned char sha1[20]; 981char name[FLEX_ARRAY]; 982}; 983 984enum{ 985 REMOVE_EMPTY_PARENTS_REF =0x01, 986 REMOVE_EMPTY_PARENTS_REFLOG =0x02 987}; 988 989/* 990 * Remove empty parent directories associated with the specified 991 * reference and/or its reflog, but spare [logs/]refs/ and immediate 992 * subdirs. flags is a combination of REMOVE_EMPTY_PARENTS_REF and/or 993 * REMOVE_EMPTY_PARENTS_REFLOG. 994 */ 995static voidtry_remove_empty_parents(struct files_ref_store *refs, 996const char*refname, 997unsigned int flags) 998{ 999struct strbuf buf = STRBUF_INIT;1000struct strbuf sb = STRBUF_INIT;1001char*p, *q;1002int i;10031004strbuf_addstr(&buf, refname);1005 p = buf.buf;1006for(i =0; i <2; i++) {/* refs/{heads,tags,...}/ */1007while(*p && *p !='/')1008 p++;1009/* tolerate duplicate slashes; see check_refname_format() */1010while(*p =='/')1011 p++;1012}1013 q = buf.buf + buf.len;1014while(flags & (REMOVE_EMPTY_PARENTS_REF | REMOVE_EMPTY_PARENTS_REFLOG)) {1015while(q > p && *q !='/')1016 q--;1017while(q > p && *(q-1) =='/')1018 q--;1019if(q == p)1020break;1021strbuf_setlen(&buf, q - buf.buf);10221023strbuf_reset(&sb);1024files_ref_path(refs, &sb, buf.buf);1025if((flags & REMOVE_EMPTY_PARENTS_REF) &&rmdir(sb.buf))1026 flags &= ~REMOVE_EMPTY_PARENTS_REF;10271028strbuf_reset(&sb);1029files_reflog_path(refs, &sb, buf.buf);1030if((flags & REMOVE_EMPTY_PARENTS_REFLOG) &&rmdir(sb.buf))1031 flags &= ~REMOVE_EMPTY_PARENTS_REFLOG;1032}1033strbuf_release(&buf);1034strbuf_release(&sb);1035}10361037/* make sure nobody touched the ref, and unlink */1038static voidprune_ref(struct files_ref_store *refs,struct ref_to_prune *r)1039{1040struct ref_transaction *transaction;1041struct strbuf err = STRBUF_INIT;10421043if(check_refname_format(r->name,0))1044return;10451046 transaction =ref_store_transaction_begin(&refs->base, &err);1047if(!transaction ||1048ref_transaction_delete(transaction, r->name, r->sha1,1049 REF_ISPRUNING | REF_NODEREF, NULL, &err) ||1050ref_transaction_commit(transaction, &err)) {1051ref_transaction_free(transaction);1052error("%s", err.buf);1053strbuf_release(&err);1054return;1055}1056ref_transaction_free(transaction);1057strbuf_release(&err);1058}10591060/*1061 * Prune the loose versions of the references in the linked list1062 * `*refs_to_prune`, freeing the entries in the list as we go.1063 */1064static voidprune_refs(struct files_ref_store *refs,struct ref_to_prune **refs_to_prune)1065{1066while(*refs_to_prune) {1067struct ref_to_prune *r = *refs_to_prune;1068*refs_to_prune = r->next;1069prune_ref(refs, r);1070free(r);1071}1072}10731074/*1075 * Return true if the specified reference should be packed.1076 */1077static intshould_pack_ref(const char*refname,1078const struct object_id *oid,unsigned int ref_flags,1079unsigned int pack_flags)1080{1081/* Do not pack per-worktree refs: */1082if(ref_type(refname) != REF_TYPE_NORMAL)1083return0;10841085/* Do not pack non-tags unless PACK_REFS_ALL is set: */1086if(!(pack_flags & PACK_REFS_ALL) && !starts_with(refname,"refs/tags/"))1087return0;10881089/* Do not pack symbolic refs: */1090if(ref_flags & REF_ISSYMREF)1091return0;10921093/* Do not pack broken refs: */1094if(!ref_resolves_to_object(refname, oid, ref_flags))1095return0;10961097return1;1098}10991100static intfiles_pack_refs(struct ref_store *ref_store,unsigned int flags)1101{1102struct files_ref_store *refs =1103files_downcast(ref_store, REF_STORE_WRITE | REF_STORE_ODB,1104"pack_refs");1105struct ref_iterator *iter;1106int ok;1107struct ref_to_prune *refs_to_prune = NULL;1108struct strbuf err = STRBUF_INIT;1109struct ref_transaction *transaction;11101111 transaction =ref_store_transaction_begin(refs->packed_ref_store, &err);1112if(!transaction)1113return-1;11141115packed_refs_lock(refs->packed_ref_store, LOCK_DIE_ON_ERROR, &err);11161117 iter =cache_ref_iterator_begin(get_loose_ref_cache(refs), NULL,0);1118while((ok =ref_iterator_advance(iter)) == ITER_OK) {1119/*1120 * If the loose reference can be packed, add an entry1121 * in the packed ref cache. If the reference should be1122 * pruned, also add it to refs_to_prune.1123 */1124if(!should_pack_ref(iter->refname, iter->oid, iter->flags,1125 flags))1126continue;11271128/*1129 * Add a reference creation for this reference to the1130 * packed-refs transaction:1131 */1132if(ref_transaction_update(transaction, iter->refname,1133 iter->oid->hash, NULL,1134 REF_NODEREF, NULL, &err))1135die("failure preparing to create packed reference%s:%s",1136 iter->refname, err.buf);11371138/* Schedule the loose reference for pruning if requested. */1139if((flags & PACK_REFS_PRUNE)) {1140struct ref_to_prune *n;1141FLEX_ALLOC_STR(n, name, iter->refname);1142hashcpy(n->sha1, iter->oid->hash);1143 n->next = refs_to_prune;1144 refs_to_prune = n;1145}1146}1147if(ok != ITER_DONE)1148die("error while iterating over references");11491150if(ref_transaction_commit(transaction, &err))1151die("unable to write new packed-refs:%s", err.buf);11521153ref_transaction_free(transaction);11541155packed_refs_unlock(refs->packed_ref_store);11561157prune_refs(refs, &refs_to_prune);1158strbuf_release(&err);1159return0;1160}11611162static intfiles_delete_refs(struct ref_store *ref_store,const char*msg,1163struct string_list *refnames,unsigned int flags)1164{1165struct files_ref_store *refs =1166files_downcast(ref_store, REF_STORE_WRITE,"delete_refs");1167struct strbuf err = STRBUF_INIT;1168int i, result =0;11691170if(!refnames->nr)1171return0;11721173if(packed_refs_lock(refs->packed_ref_store,0, &err))1174goto error;11751176if(refs_delete_refs(refs->packed_ref_store, msg, refnames, flags)) {1177packed_refs_unlock(refs->packed_ref_store);1178goto error;1179}11801181packed_refs_unlock(refs->packed_ref_store);11821183for(i =0; i < refnames->nr; i++) {1184const char*refname = refnames->items[i].string;11851186if(refs_delete_ref(&refs->base, msg, refname, NULL, flags))1187 result |=error(_("could not remove reference%s"), refname);1188}11891190strbuf_release(&err);1191return result;11921193error:1194/*1195 * If we failed to rewrite the packed-refs file, then it is1196 * unsafe to try to remove loose refs, because doing so might1197 * expose an obsolete packed value for a reference that might1198 * even point at an object that has been garbage collected.1199 */1200if(refnames->nr ==1)1201error(_("could not delete reference%s:%s"),1202 refnames->items[0].string, err.buf);1203else1204error(_("could not delete references:%s"), err.buf);12051206strbuf_release(&err);1207return-1;1208}12091210/*1211 * People using contrib's git-new-workdir have .git/logs/refs ->1212 * /some/other/path/.git/logs/refs, and that may live on another device.1213 *1214 * IOW, to avoid cross device rename errors, the temporary renamed log must1215 * live into logs/refs.1216 */1217#define TMP_RENAMED_LOG"refs/.tmp-renamed-log"12181219struct rename_cb {1220const char*tmp_renamed_log;1221int true_errno;1222};12231224static intrename_tmp_log_callback(const char*path,void*cb_data)1225{1226struct rename_cb *cb = cb_data;12271228if(rename(cb->tmp_renamed_log, path)) {1229/*1230 * rename(a, b) when b is an existing directory ought1231 * to result in ISDIR, but Solaris 5.8 gives ENOTDIR.1232 * Sheesh. Record the true errno for error reporting,1233 * but report EISDIR to raceproof_create_file() so1234 * that it knows to retry.1235 */1236 cb->true_errno = errno;1237if(errno == ENOTDIR)1238 errno = EISDIR;1239return-1;1240}else{1241return0;1242}1243}12441245static intrename_tmp_log(struct files_ref_store *refs,const char*newrefname)1246{1247struct strbuf path = STRBUF_INIT;1248struct strbuf tmp = STRBUF_INIT;1249struct rename_cb cb;1250int ret;12511252files_reflog_path(refs, &path, newrefname);1253files_reflog_path(refs, &tmp, TMP_RENAMED_LOG);1254 cb.tmp_renamed_log = tmp.buf;1255 ret =raceproof_create_file(path.buf, rename_tmp_log_callback, &cb);1256if(ret) {1257if(errno == EISDIR)1258error("directory not empty:%s", path.buf);1259else1260error("unable to move logfile%sto%s:%s",1261 tmp.buf, path.buf,1262strerror(cb.true_errno));1263}12641265strbuf_release(&path);1266strbuf_release(&tmp);1267return ret;1268}12691270static intwrite_ref_to_lockfile(struct ref_lock *lock,1271const struct object_id *oid,struct strbuf *err);1272static intcommit_ref_update(struct files_ref_store *refs,1273struct ref_lock *lock,1274const struct object_id *oid,const char*logmsg,1275struct strbuf *err);12761277static intfiles_rename_ref(struct ref_store *ref_store,1278const char*oldrefname,const char*newrefname,1279const char*logmsg)1280{1281struct files_ref_store *refs =1282files_downcast(ref_store, REF_STORE_WRITE,"rename_ref");1283struct object_id oid, orig_oid;1284int flag =0, logmoved =0;1285struct ref_lock *lock;1286struct stat loginfo;1287struct strbuf sb_oldref = STRBUF_INIT;1288struct strbuf sb_newref = STRBUF_INIT;1289struct strbuf tmp_renamed_log = STRBUF_INIT;1290int log, ret;1291struct strbuf err = STRBUF_INIT;12921293files_reflog_path(refs, &sb_oldref, oldrefname);1294files_reflog_path(refs, &sb_newref, newrefname);1295files_reflog_path(refs, &tmp_renamed_log, TMP_RENAMED_LOG);12961297 log = !lstat(sb_oldref.buf, &loginfo);1298if(log &&S_ISLNK(loginfo.st_mode)) {1299 ret =error("reflog for%sis a symlink", oldrefname);1300goto out;1301}13021303if(!refs_resolve_ref_unsafe(&refs->base, oldrefname,1304 RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,1305 orig_oid.hash, &flag)) {1306 ret =error("refname%snot found", oldrefname);1307goto out;1308}13091310if(flag & REF_ISSYMREF) {1311 ret =error("refname%sis a symbolic ref, renaming it is not supported",1312 oldrefname);1313goto out;1314}1315if(!refs_rename_ref_available(&refs->base, oldrefname, newrefname)) {1316 ret =1;1317goto out;1318}13191320if(log &&rename(sb_oldref.buf, tmp_renamed_log.buf)) {1321 ret =error("unable to move logfile logs/%sto logs/"TMP_RENAMED_LOG":%s",1322 oldrefname,strerror(errno));1323goto out;1324}13251326if(refs_delete_ref(&refs->base, logmsg, oldrefname,1327 orig_oid.hash, REF_NODEREF)) {1328error("unable to delete old%s", oldrefname);1329goto rollback;1330}13311332/*1333 * Since we are doing a shallow lookup, oid is not the1334 * correct value to pass to delete_ref as old_oid. But that1335 * doesn't matter, because an old_oid check wouldn't add to1336 * the safety anyway; we want to delete the reference whatever1337 * its current value.1338 */1339if(!refs_read_ref_full(&refs->base, newrefname,1340 RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,1341 oid.hash, NULL) &&1342refs_delete_ref(&refs->base, NULL, newrefname,1343 NULL, REF_NODEREF)) {1344if(errno == EISDIR) {1345struct strbuf path = STRBUF_INIT;1346int result;13471348files_ref_path(refs, &path, newrefname);1349 result =remove_empty_directories(&path);1350strbuf_release(&path);13511352if(result) {1353error("Directory not empty:%s", newrefname);1354goto rollback;1355}1356}else{1357error("unable to delete existing%s", newrefname);1358goto rollback;1359}1360}13611362if(log &&rename_tmp_log(refs, newrefname))1363goto rollback;13641365 logmoved = log;13661367 lock =lock_ref_sha1_basic(refs, newrefname, NULL, NULL, NULL,1368 REF_NODEREF, NULL, &err);1369if(!lock) {1370error("unable to rename '%s' to '%s':%s", oldrefname, newrefname, err.buf);1371strbuf_release(&err);1372goto rollback;1373}1374oidcpy(&lock->old_oid, &orig_oid);13751376if(write_ref_to_lockfile(lock, &orig_oid, &err) ||1377commit_ref_update(refs, lock, &orig_oid, logmsg, &err)) {1378error("unable to write current sha1 into%s:%s", newrefname, err.buf);1379strbuf_release(&err);1380goto rollback;1381}13821383 ret =0;1384goto out;13851386 rollback:1387 lock =lock_ref_sha1_basic(refs, oldrefname, NULL, NULL, NULL,1388 REF_NODEREF, NULL, &err);1389if(!lock) {1390error("unable to lock%sfor rollback:%s", oldrefname, err.buf);1391strbuf_release(&err);1392goto rollbacklog;1393}13941395 flag = log_all_ref_updates;1396 log_all_ref_updates = LOG_REFS_NONE;1397if(write_ref_to_lockfile(lock, &orig_oid, &err) ||1398commit_ref_update(refs, lock, &orig_oid, NULL, &err)) {1399error("unable to write current sha1 into%s:%s", oldrefname, err.buf);1400strbuf_release(&err);1401}1402 log_all_ref_updates = flag;14031404 rollbacklog:1405if(logmoved &&rename(sb_newref.buf, sb_oldref.buf))1406error("unable to restore logfile%sfrom%s:%s",1407 oldrefname, newrefname,strerror(errno));1408if(!logmoved && log &&1409rename(tmp_renamed_log.buf, sb_oldref.buf))1410error("unable to restore logfile%sfrom logs/"TMP_RENAMED_LOG":%s",1411 oldrefname,strerror(errno));1412 ret =1;1413 out:1414strbuf_release(&sb_newref);1415strbuf_release(&sb_oldref);1416strbuf_release(&tmp_renamed_log);14171418return ret;1419}14201421static intclose_ref(struct ref_lock *lock)1422{1423if(close_lock_file(lock->lk))1424return-1;1425return0;1426}14271428static intcommit_ref(struct ref_lock *lock)1429{1430char*path =get_locked_file_path(lock->lk);1431struct stat st;14321433if(!lstat(path, &st) &&S_ISDIR(st.st_mode)) {1434/*1435 * There is a directory at the path we want to rename1436 * the lockfile to. Hopefully it is empty; try to1437 * delete it.1438 */1439size_t len =strlen(path);1440struct strbuf sb_path = STRBUF_INIT;14411442strbuf_attach(&sb_path, path, len, len);14431444/*1445 * If this fails, commit_lock_file() will also fail1446 * and will report the problem.1447 */1448remove_empty_directories(&sb_path);1449strbuf_release(&sb_path);1450}else{1451free(path);1452}14531454if(commit_lock_file(lock->lk))1455return-1;1456return0;1457}14581459static intopen_or_create_logfile(const char*path,void*cb)1460{1461int*fd = cb;14621463*fd =open(path, O_APPEND | O_WRONLY | O_CREAT,0666);1464return(*fd <0) ? -1:0;1465}14661467/*1468 * Create a reflog for a ref. If force_create = 0, only create the1469 * reflog for certain refs (those for which should_autocreate_reflog1470 * returns non-zero). Otherwise, create it regardless of the reference1471 * name. If the logfile already existed or was created, return 0 and1472 * set *logfd to the file descriptor opened for appending to the file.1473 * If no logfile exists and we decided not to create one, return 0 and1474 * set *logfd to -1. On failure, fill in *err, set *logfd to -1, and1475 * return -1.1476 */1477static intlog_ref_setup(struct files_ref_store *refs,1478const char*refname,int force_create,1479int*logfd,struct strbuf *err)1480{1481struct strbuf logfile_sb = STRBUF_INIT;1482char*logfile;14831484files_reflog_path(refs, &logfile_sb, refname);1485 logfile =strbuf_detach(&logfile_sb, NULL);14861487if(force_create ||should_autocreate_reflog(refname)) {1488if(raceproof_create_file(logfile, open_or_create_logfile, logfd)) {1489if(errno == ENOENT)1490strbuf_addf(err,"unable to create directory for '%s': "1491"%s", logfile,strerror(errno));1492else if(errno == EISDIR)1493strbuf_addf(err,"there are still logs under '%s'",1494 logfile);1495else1496strbuf_addf(err,"unable to append to '%s':%s",1497 logfile,strerror(errno));14981499goto error;1500}1501}else{1502*logfd =open(logfile, O_APPEND | O_WRONLY,0666);1503if(*logfd <0) {1504if(errno == ENOENT || errno == EISDIR) {1505/*1506 * The logfile doesn't already exist,1507 * but that is not an error; it only1508 * means that we won't write log1509 * entries to it.1510 */1511;1512}else{1513strbuf_addf(err,"unable to append to '%s':%s",1514 logfile,strerror(errno));1515goto error;1516}1517}1518}15191520if(*logfd >=0)1521adjust_shared_perm(logfile);15221523free(logfile);1524return0;15251526error:1527free(logfile);1528return-1;1529}15301531static intfiles_create_reflog(struct ref_store *ref_store,1532const char*refname,int force_create,1533struct strbuf *err)1534{1535struct files_ref_store *refs =1536files_downcast(ref_store, REF_STORE_WRITE,"create_reflog");1537int fd;15381539if(log_ref_setup(refs, refname, force_create, &fd, err))1540return-1;15411542if(fd >=0)1543close(fd);15441545return0;1546}15471548static intlog_ref_write_fd(int fd,const struct object_id *old_oid,1549const struct object_id *new_oid,1550const char*committer,const char*msg)1551{1552int msglen, written;1553unsigned maxlen, len;1554char*logrec;15551556 msglen = msg ?strlen(msg) :0;1557 maxlen =strlen(committer) + msglen +100;1558 logrec =xmalloc(maxlen);1559 len =xsnprintf(logrec, maxlen,"%s %s %s\n",1560oid_to_hex(old_oid),1561oid_to_hex(new_oid),1562 committer);1563if(msglen)1564 len +=copy_reflog_msg(logrec + len -1, msg) -1;15651566 written = len <= maxlen ?write_in_full(fd, logrec, len) : -1;1567free(logrec);1568if(written != len)1569return-1;15701571return0;1572}15731574static intfiles_log_ref_write(struct files_ref_store *refs,1575const char*refname,const struct object_id *old_oid,1576const struct object_id *new_oid,const char*msg,1577int flags,struct strbuf *err)1578{1579int logfd, result;15801581if(log_all_ref_updates == LOG_REFS_UNSET)1582 log_all_ref_updates =is_bare_repository() ? LOG_REFS_NONE : LOG_REFS_NORMAL;15831584 result =log_ref_setup(refs, refname,1585 flags & REF_FORCE_CREATE_REFLOG,1586&logfd, err);15871588if(result)1589return result;15901591if(logfd <0)1592return0;1593 result =log_ref_write_fd(logfd, old_oid, new_oid,1594git_committer_info(0), msg);1595if(result) {1596struct strbuf sb = STRBUF_INIT;1597int save_errno = errno;15981599files_reflog_path(refs, &sb, refname);1600strbuf_addf(err,"unable to append to '%s':%s",1601 sb.buf,strerror(save_errno));1602strbuf_release(&sb);1603close(logfd);1604return-1;1605}1606if(close(logfd)) {1607struct strbuf sb = STRBUF_INIT;1608int save_errno = errno;16091610files_reflog_path(refs, &sb, refname);1611strbuf_addf(err,"unable to append to '%s':%s",1612 sb.buf,strerror(save_errno));1613strbuf_release(&sb);1614return-1;1615}1616return0;1617}16181619/*1620 * Write sha1 into the open lockfile, then close the lockfile. On1621 * errors, rollback the lockfile, fill in *err and1622 * return -1.1623 */1624static intwrite_ref_to_lockfile(struct ref_lock *lock,1625const struct object_id *oid,struct strbuf *err)1626{1627static char term ='\n';1628struct object *o;1629int fd;16301631 o =parse_object(oid);1632if(!o) {1633strbuf_addf(err,1634"trying to write ref '%s' with nonexistent object%s",1635 lock->ref_name,oid_to_hex(oid));1636unlock_ref(lock);1637return-1;1638}1639if(o->type != OBJ_COMMIT &&is_branch(lock->ref_name)) {1640strbuf_addf(err,1641"trying to write non-commit object%sto branch '%s'",1642oid_to_hex(oid), lock->ref_name);1643unlock_ref(lock);1644return-1;1645}1646 fd =get_lock_file_fd(lock->lk);1647if(write_in_full(fd,oid_to_hex(oid), GIT_SHA1_HEXSZ) != GIT_SHA1_HEXSZ ||1648write_in_full(fd, &term,1) !=1||1649close_ref(lock) <0) {1650strbuf_addf(err,1651"couldn't write '%s'",get_lock_file_path(lock->lk));1652unlock_ref(lock);1653return-1;1654}1655return0;1656}16571658/*1659 * Commit a change to a loose reference that has already been written1660 * to the loose reference lockfile. Also update the reflogs if1661 * necessary, using the specified lockmsg (which can be NULL).1662 */1663static intcommit_ref_update(struct files_ref_store *refs,1664struct ref_lock *lock,1665const struct object_id *oid,const char*logmsg,1666struct strbuf *err)1667{1668files_assert_main_repository(refs,"commit_ref_update");16691670clear_loose_ref_cache(refs);1671if(files_log_ref_write(refs, lock->ref_name,1672&lock->old_oid, oid,1673 logmsg,0, err)) {1674char*old_msg =strbuf_detach(err, NULL);1675strbuf_addf(err,"cannot update the ref '%s':%s",1676 lock->ref_name, old_msg);1677free(old_msg);1678unlock_ref(lock);1679return-1;1680}16811682if(strcmp(lock->ref_name,"HEAD") !=0) {1683/*1684 * Special hack: If a branch is updated directly and HEAD1685 * points to it (may happen on the remote side of a push1686 * for example) then logically the HEAD reflog should be1687 * updated too.1688 * A generic solution implies reverse symref information,1689 * but finding all symrefs pointing to the given branch1690 * would be rather costly for this rare event (the direct1691 * update of a branch) to be worth it. So let's cheat and1692 * check with HEAD only which should cover 99% of all usage1693 * scenarios (even 100% of the default ones).1694 */1695struct object_id head_oid;1696int head_flag;1697const char*head_ref;16981699 head_ref =refs_resolve_ref_unsafe(&refs->base,"HEAD",1700 RESOLVE_REF_READING,1701 head_oid.hash, &head_flag);1702if(head_ref && (head_flag & REF_ISSYMREF) &&1703!strcmp(head_ref, lock->ref_name)) {1704struct strbuf log_err = STRBUF_INIT;1705if(files_log_ref_write(refs,"HEAD",1706&lock->old_oid, oid,1707 logmsg,0, &log_err)) {1708error("%s", log_err.buf);1709strbuf_release(&log_err);1710}1711}1712}17131714if(commit_ref(lock)) {1715strbuf_addf(err,"couldn't set '%s'", lock->ref_name);1716unlock_ref(lock);1717return-1;1718}17191720unlock_ref(lock);1721return0;1722}17231724static intcreate_ref_symlink(struct ref_lock *lock,const char*target)1725{1726int ret = -1;1727#ifndef NO_SYMLINK_HEAD1728char*ref_path =get_locked_file_path(lock->lk);1729unlink(ref_path);1730 ret =symlink(target, ref_path);1731free(ref_path);17321733if(ret)1734fprintf(stderr,"no symlink - falling back to symbolic ref\n");1735#endif1736return ret;1737}17381739static voidupdate_symref_reflog(struct files_ref_store *refs,1740struct ref_lock *lock,const char*refname,1741const char*target,const char*logmsg)1742{1743struct strbuf err = STRBUF_INIT;1744struct object_id new_oid;1745if(logmsg &&1746!refs_read_ref_full(&refs->base, target,1747 RESOLVE_REF_READING, new_oid.hash, NULL) &&1748files_log_ref_write(refs, refname, &lock->old_oid,1749&new_oid, logmsg,0, &err)) {1750error("%s", err.buf);1751strbuf_release(&err);1752}1753}17541755static intcreate_symref_locked(struct files_ref_store *refs,1756struct ref_lock *lock,const char*refname,1757const char*target,const char*logmsg)1758{1759if(prefer_symlink_refs && !create_ref_symlink(lock, target)) {1760update_symref_reflog(refs, lock, refname, target, logmsg);1761return0;1762}17631764if(!fdopen_lock_file(lock->lk,"w"))1765returnerror("unable to fdopen%s:%s",1766 lock->lk->tempfile.filename.buf,strerror(errno));17671768update_symref_reflog(refs, lock, refname, target, logmsg);17691770/* no error check; commit_ref will check ferror */1771fprintf(lock->lk->tempfile.fp,"ref:%s\n", target);1772if(commit_ref(lock) <0)1773returnerror("unable to write symref for%s:%s", refname,1774strerror(errno));1775return0;1776}17771778static intfiles_create_symref(struct ref_store *ref_store,1779const char*refname,const char*target,1780const char*logmsg)1781{1782struct files_ref_store *refs =1783files_downcast(ref_store, REF_STORE_WRITE,"create_symref");1784struct strbuf err = STRBUF_INIT;1785struct ref_lock *lock;1786int ret;17871788 lock =lock_ref_sha1_basic(refs, refname, NULL,1789 NULL, NULL, REF_NODEREF, NULL,1790&err);1791if(!lock) {1792error("%s", err.buf);1793strbuf_release(&err);1794return-1;1795}17961797 ret =create_symref_locked(refs, lock, refname, target, logmsg);1798unlock_ref(lock);1799return ret;1800}18011802static intfiles_reflog_exists(struct ref_store *ref_store,1803const char*refname)1804{1805struct files_ref_store *refs =1806files_downcast(ref_store, REF_STORE_READ,"reflog_exists");1807struct strbuf sb = STRBUF_INIT;1808struct stat st;1809int ret;18101811files_reflog_path(refs, &sb, refname);1812 ret = !lstat(sb.buf, &st) &&S_ISREG(st.st_mode);1813strbuf_release(&sb);1814return ret;1815}18161817static intfiles_delete_reflog(struct ref_store *ref_store,1818const char*refname)1819{1820struct files_ref_store *refs =1821files_downcast(ref_store, REF_STORE_WRITE,"delete_reflog");1822struct strbuf sb = STRBUF_INIT;1823int ret;18241825files_reflog_path(refs, &sb, refname);1826 ret =remove_path(sb.buf);1827strbuf_release(&sb);1828return ret;1829}18301831static intshow_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn,void*cb_data)1832{1833struct object_id ooid, noid;1834char*email_end, *message;1835 timestamp_t timestamp;1836int tz;1837const char*p = sb->buf;18381839/* old SP new SP name <email> SP time TAB msg LF */1840if(!sb->len || sb->buf[sb->len -1] !='\n'||1841parse_oid_hex(p, &ooid, &p) || *p++ !=' '||1842parse_oid_hex(p, &noid, &p) || *p++ !=' '||1843!(email_end =strchr(p,'>')) ||1844 email_end[1] !=' '||1845!(timestamp =parse_timestamp(email_end +2, &message,10)) ||1846!message || message[0] !=' '||1847(message[1] !='+'&& message[1] !='-') ||1848!isdigit(message[2]) || !isdigit(message[3]) ||1849!isdigit(message[4]) || !isdigit(message[5]))1850return0;/* corrupt? */1851 email_end[1] ='\0';1852 tz =strtol(message +1, NULL,10);1853if(message[6] !='\t')1854 message +=6;1855else1856 message +=7;1857returnfn(&ooid, &noid, p, timestamp, tz, message, cb_data);1858}18591860static char*find_beginning_of_line(char*bob,char*scan)1861{1862while(bob < scan && *(--scan) !='\n')1863;/* keep scanning backwards */1864/*1865 * Return either beginning of the buffer, or LF at the end of1866 * the previous line.1867 */1868return scan;1869}18701871static intfiles_for_each_reflog_ent_reverse(struct ref_store *ref_store,1872const char*refname,1873 each_reflog_ent_fn fn,1874void*cb_data)1875{1876struct files_ref_store *refs =1877files_downcast(ref_store, REF_STORE_READ,1878"for_each_reflog_ent_reverse");1879struct strbuf sb = STRBUF_INIT;1880FILE*logfp;1881long pos;1882int ret =0, at_tail =1;18831884files_reflog_path(refs, &sb, refname);1885 logfp =fopen(sb.buf,"r");1886strbuf_release(&sb);1887if(!logfp)1888return-1;18891890/* Jump to the end */1891if(fseek(logfp,0, SEEK_END) <0)1892 ret =error("cannot seek back reflog for%s:%s",1893 refname,strerror(errno));1894 pos =ftell(logfp);1895while(!ret &&0< pos) {1896int cnt;1897size_t nread;1898char buf[BUFSIZ];1899char*endp, *scanp;19001901/* Fill next block from the end */1902 cnt = (sizeof(buf) < pos) ?sizeof(buf) : pos;1903if(fseek(logfp, pos - cnt, SEEK_SET)) {1904 ret =error("cannot seek back reflog for%s:%s",1905 refname,strerror(errno));1906break;1907}1908 nread =fread(buf, cnt,1, logfp);1909if(nread !=1) {1910 ret =error("cannot read%dbytes from reflog for%s:%s",1911 cnt, refname,strerror(errno));1912break;1913}1914 pos -= cnt;19151916 scanp = endp = buf + cnt;1917if(at_tail && scanp[-1] =='\n')1918/* Looking at the final LF at the end of the file */1919 scanp--;1920 at_tail =0;19211922while(buf < scanp) {1923/*1924 * terminating LF of the previous line, or the beginning1925 * of the buffer.1926 */1927char*bp;19281929 bp =find_beginning_of_line(buf, scanp);19301931if(*bp =='\n') {1932/*1933 * The newline is the end of the previous line,1934 * so we know we have complete line starting1935 * at (bp + 1). Prefix it onto any prior data1936 * we collected for the line and process it.1937 */1938strbuf_splice(&sb,0,0, bp +1, endp - (bp +1));1939 scanp = bp;1940 endp = bp +1;1941 ret =show_one_reflog_ent(&sb, fn, cb_data);1942strbuf_reset(&sb);1943if(ret)1944break;1945}else if(!pos) {1946/*1947 * We are at the start of the buffer, and the1948 * start of the file; there is no previous1949 * line, and we have everything for this one.1950 * Process it, and we can end the loop.1951 */1952strbuf_splice(&sb,0,0, buf, endp - buf);1953 ret =show_one_reflog_ent(&sb, fn, cb_data);1954strbuf_reset(&sb);1955break;1956}19571958if(bp == buf) {1959/*1960 * We are at the start of the buffer, and there1961 * is more file to read backwards. Which means1962 * we are in the middle of a line. Note that we1963 * may get here even if *bp was a newline; that1964 * just means we are at the exact end of the1965 * previous line, rather than some spot in the1966 * middle.1967 *1968 * Save away what we have to be combined with1969 * the data from the next read.1970 */1971strbuf_splice(&sb,0,0, buf, endp - buf);1972break;1973}1974}19751976}1977if(!ret && sb.len)1978die("BUG: reverse reflog parser had leftover data");19791980fclose(logfp);1981strbuf_release(&sb);1982return ret;1983}19841985static intfiles_for_each_reflog_ent(struct ref_store *ref_store,1986const char*refname,1987 each_reflog_ent_fn fn,void*cb_data)1988{1989struct files_ref_store *refs =1990files_downcast(ref_store, REF_STORE_READ,1991"for_each_reflog_ent");1992FILE*logfp;1993struct strbuf sb = STRBUF_INIT;1994int ret =0;19951996files_reflog_path(refs, &sb, refname);1997 logfp =fopen(sb.buf,"r");1998strbuf_release(&sb);1999if(!logfp)2000return-1;20012002while(!ret && !strbuf_getwholeline(&sb, logfp,'\n'))2003 ret =show_one_reflog_ent(&sb, fn, cb_data);2004fclose(logfp);2005strbuf_release(&sb);2006return ret;2007}20082009struct files_reflog_iterator {2010struct ref_iterator base;20112012struct ref_store *ref_store;2013struct dir_iterator *dir_iterator;2014struct object_id oid;2015};20162017static intfiles_reflog_iterator_advance(struct ref_iterator *ref_iterator)2018{2019struct files_reflog_iterator *iter =2020(struct files_reflog_iterator *)ref_iterator;2021struct dir_iterator *diter = iter->dir_iterator;2022int ok;20232024while((ok =dir_iterator_advance(diter)) == ITER_OK) {2025int flags;20262027if(!S_ISREG(diter->st.st_mode))2028continue;2029if(diter->basename[0] =='.')2030continue;2031if(ends_with(diter->basename,".lock"))2032continue;20332034if(refs_read_ref_full(iter->ref_store,2035 diter->relative_path,0,2036 iter->oid.hash, &flags)) {2037error("bad ref for%s", diter->path.buf);2038continue;2039}20402041 iter->base.refname = diter->relative_path;2042 iter->base.oid = &iter->oid;2043 iter->base.flags = flags;2044return ITER_OK;2045}20462047 iter->dir_iterator = NULL;2048if(ref_iterator_abort(ref_iterator) == ITER_ERROR)2049 ok = ITER_ERROR;2050return ok;2051}20522053static intfiles_reflog_iterator_peel(struct ref_iterator *ref_iterator,2054struct object_id *peeled)2055{2056die("BUG: ref_iterator_peel() called for reflog_iterator");2057}20582059static intfiles_reflog_iterator_abort(struct ref_iterator *ref_iterator)2060{2061struct files_reflog_iterator *iter =2062(struct files_reflog_iterator *)ref_iterator;2063int ok = ITER_DONE;20642065if(iter->dir_iterator)2066 ok =dir_iterator_abort(iter->dir_iterator);20672068base_ref_iterator_free(ref_iterator);2069return ok;2070}20712072static struct ref_iterator_vtable files_reflog_iterator_vtable = {2073 files_reflog_iterator_advance,2074 files_reflog_iterator_peel,2075 files_reflog_iterator_abort2076};20772078static struct ref_iterator *files_reflog_iterator_begin(struct ref_store *ref_store)2079{2080struct files_ref_store *refs =2081files_downcast(ref_store, REF_STORE_READ,2082"reflog_iterator_begin");2083struct files_reflog_iterator *iter =xcalloc(1,sizeof(*iter));2084struct ref_iterator *ref_iterator = &iter->base;2085struct strbuf sb = STRBUF_INIT;20862087base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable);2088files_reflog_path(refs, &sb, NULL);2089 iter->dir_iterator =dir_iterator_begin(sb.buf);2090 iter->ref_store = ref_store;2091strbuf_release(&sb);2092return ref_iterator;2093}20942095/*2096 * If update is a direct update of head_ref (the reference pointed to2097 * by HEAD), then add an extra REF_LOG_ONLY update for HEAD.2098 */2099static intsplit_head_update(struct ref_update *update,2100struct ref_transaction *transaction,2101const char*head_ref,2102struct string_list *affected_refnames,2103struct strbuf *err)2104{2105struct string_list_item *item;2106struct ref_update *new_update;21072108if((update->flags & REF_LOG_ONLY) ||2109(update->flags & REF_ISPRUNING) ||2110(update->flags & REF_UPDATE_VIA_HEAD))2111return0;21122113if(strcmp(update->refname, head_ref))2114return0;21152116/*2117 * First make sure that HEAD is not already in the2118 * transaction. This insertion is O(N) in the transaction2119 * size, but it happens at most once per transaction.2120 */2121 item =string_list_insert(affected_refnames,"HEAD");2122if(item->util) {2123/* An entry already existed */2124strbuf_addf(err,2125"multiple updates for 'HEAD' (including one "2126"via its referent '%s') are not allowed",2127 update->refname);2128return TRANSACTION_NAME_CONFLICT;2129}21302131 new_update =ref_transaction_add_update(2132 transaction,"HEAD",2133 update->flags | REF_LOG_ONLY | REF_NODEREF,2134 update->new_oid.hash, update->old_oid.hash,2135 update->msg);21362137 item->util = new_update;21382139return0;2140}21412142/*2143 * update is for a symref that points at referent and doesn't have2144 * REF_NODEREF set. Split it into two updates:2145 * - The original update, but with REF_LOG_ONLY and REF_NODEREF set2146 * - A new, separate update for the referent reference2147 * Note that the new update will itself be subject to splitting when2148 * the iteration gets to it.2149 */2150static intsplit_symref_update(struct files_ref_store *refs,2151struct ref_update *update,2152const char*referent,2153struct ref_transaction *transaction,2154struct string_list *affected_refnames,2155struct strbuf *err)2156{2157struct string_list_item *item;2158struct ref_update *new_update;2159unsigned int new_flags;21602161/*2162 * First make sure that referent is not already in the2163 * transaction. This insertion is O(N) in the transaction2164 * size, but it happens at most once per symref in a2165 * transaction.2166 */2167 item =string_list_insert(affected_refnames, referent);2168if(item->util) {2169/* An entry already existed */2170strbuf_addf(err,2171"multiple updates for '%s' (including one "2172"via symref '%s') are not allowed",2173 referent, update->refname);2174return TRANSACTION_NAME_CONFLICT;2175}21762177 new_flags = update->flags;2178if(!strcmp(update->refname,"HEAD")) {2179/*2180 * Record that the new update came via HEAD, so that2181 * when we process it, split_head_update() doesn't try2182 * to add another reflog update for HEAD. Note that2183 * this bit will be propagated if the new_update2184 * itself needs to be split.2185 */2186 new_flags |= REF_UPDATE_VIA_HEAD;2187}21882189 new_update =ref_transaction_add_update(2190 transaction, referent, new_flags,2191 update->new_oid.hash, update->old_oid.hash,2192 update->msg);21932194 new_update->parent_update = update;21952196/*2197 * Change the symbolic ref update to log only. Also, it2198 * doesn't need to check its old SHA-1 value, as that will be2199 * done when new_update is processed.2200 */2201 update->flags |= REF_LOG_ONLY | REF_NODEREF;2202 update->flags &= ~REF_HAVE_OLD;22032204 item->util = new_update;22052206return0;2207}22082209/*2210 * Return the refname under which update was originally requested.2211 */2212static const char*original_update_refname(struct ref_update *update)2213{2214while(update->parent_update)2215 update = update->parent_update;22162217return update->refname;2218}22192220/*2221 * Check whether the REF_HAVE_OLD and old_oid values stored in update2222 * are consistent with oid, which is the reference's current value. If2223 * everything is OK, return 0; otherwise, write an error message to2224 * err and return -1.2225 */2226static intcheck_old_oid(struct ref_update *update,struct object_id *oid,2227struct strbuf *err)2228{2229if(!(update->flags & REF_HAVE_OLD) ||2230!oidcmp(oid, &update->old_oid))2231return0;22322233if(is_null_oid(&update->old_oid))2234strbuf_addf(err,"cannot lock ref '%s': "2235"reference already exists",2236original_update_refname(update));2237else if(is_null_oid(oid))2238strbuf_addf(err,"cannot lock ref '%s': "2239"reference is missing but expected%s",2240original_update_refname(update),2241oid_to_hex(&update->old_oid));2242else2243strbuf_addf(err,"cannot lock ref '%s': "2244"is at%sbut expected%s",2245original_update_refname(update),2246oid_to_hex(oid),2247oid_to_hex(&update->old_oid));22482249return-1;2250}22512252/*2253 * Prepare for carrying out update:2254 * - Lock the reference referred to by update.2255 * - Read the reference under lock.2256 * - Check that its old SHA-1 value (if specified) is correct, and in2257 * any case record it in update->lock->old_oid for later use when2258 * writing the reflog.2259 * - If it is a symref update without REF_NODEREF, split it up into a2260 * REF_LOG_ONLY update of the symref and add a separate update for2261 * the referent to transaction.2262 * - If it is an update of head_ref, add a corresponding REF_LOG_ONLY2263 * update of HEAD.2264 */2265static intlock_ref_for_update(struct files_ref_store *refs,2266struct ref_update *update,2267struct ref_transaction *transaction,2268const char*head_ref,2269struct string_list *affected_refnames,2270struct strbuf *err)2271{2272struct strbuf referent = STRBUF_INIT;2273int mustexist = (update->flags & REF_HAVE_OLD) &&2274!is_null_oid(&update->old_oid);2275int ret;2276struct ref_lock *lock;22772278files_assert_main_repository(refs,"lock_ref_for_update");22792280if((update->flags & REF_HAVE_NEW) &&is_null_oid(&update->new_oid))2281 update->flags |= REF_DELETING;22822283if(head_ref) {2284 ret =split_head_update(update, transaction, head_ref,2285 affected_refnames, err);2286if(ret)2287return ret;2288}22892290 ret =lock_raw_ref(refs, update->refname, mustexist,2291 affected_refnames, NULL,2292&lock, &referent,2293&update->type, err);2294if(ret) {2295char*reason;22962297 reason =strbuf_detach(err, NULL);2298strbuf_addf(err,"cannot lock ref '%s':%s",2299original_update_refname(update), reason);2300free(reason);2301return ret;2302}23032304 update->backend_data = lock;23052306if(update->type & REF_ISSYMREF) {2307if(update->flags & REF_NODEREF) {2308/*2309 * We won't be reading the referent as part of2310 * the transaction, so we have to read it here2311 * to record and possibly check old_sha1:2312 */2313if(refs_read_ref_full(&refs->base,2314 referent.buf,0,2315 lock->old_oid.hash, NULL)) {2316if(update->flags & REF_HAVE_OLD) {2317strbuf_addf(err,"cannot lock ref '%s': "2318"error reading reference",2319original_update_refname(update));2320return-1;2321}2322}else if(check_old_oid(update, &lock->old_oid, err)) {2323return TRANSACTION_GENERIC_ERROR;2324}2325}else{2326/*2327 * Create a new update for the reference this2328 * symref is pointing at. Also, we will record2329 * and verify old_sha1 for this update as part2330 * of processing the split-off update, so we2331 * don't have to do it here.2332 */2333 ret =split_symref_update(refs, update,2334 referent.buf, transaction,2335 affected_refnames, err);2336if(ret)2337return ret;2338}2339}else{2340struct ref_update *parent_update;23412342if(check_old_oid(update, &lock->old_oid, err))2343return TRANSACTION_GENERIC_ERROR;23442345/*2346 * If this update is happening indirectly because of a2347 * symref update, record the old SHA-1 in the parent2348 * update:2349 */2350for(parent_update = update->parent_update;2351 parent_update;2352 parent_update = parent_update->parent_update) {2353struct ref_lock *parent_lock = parent_update->backend_data;2354oidcpy(&parent_lock->old_oid, &lock->old_oid);2355}2356}23572358if((update->flags & REF_HAVE_NEW) &&2359!(update->flags & REF_DELETING) &&2360!(update->flags & REF_LOG_ONLY)) {2361if(!(update->type & REF_ISSYMREF) &&2362!oidcmp(&lock->old_oid, &update->new_oid)) {2363/*2364 * The reference already has the desired2365 * value, so we don't need to write it.2366 */2367}else if(write_ref_to_lockfile(lock, &update->new_oid,2368 err)) {2369char*write_err =strbuf_detach(err, NULL);23702371/*2372 * The lock was freed upon failure of2373 * write_ref_to_lockfile():2374 */2375 update->backend_data = NULL;2376strbuf_addf(err,2377"cannot update ref '%s':%s",2378 update->refname, write_err);2379free(write_err);2380return TRANSACTION_GENERIC_ERROR;2381}else{2382 update->flags |= REF_NEEDS_COMMIT;2383}2384}2385if(!(update->flags & REF_NEEDS_COMMIT)) {2386/*2387 * We didn't call write_ref_to_lockfile(), so2388 * the lockfile is still open. Close it to2389 * free up the file descriptor:2390 */2391if(close_ref(lock)) {2392strbuf_addf(err,"couldn't close '%s.lock'",2393 update->refname);2394return TRANSACTION_GENERIC_ERROR;2395}2396}2397return0;2398}23992400struct files_transaction_backend_data {2401struct ref_transaction *packed_transaction;2402int packed_refs_locked;2403};24042405/*2406 * Unlock any references in `transaction` that are still locked, and2407 * mark the transaction closed.2408 */2409static voidfiles_transaction_cleanup(struct files_ref_store *refs,2410struct ref_transaction *transaction)2411{2412size_t i;2413struct files_transaction_backend_data *backend_data =2414 transaction->backend_data;2415struct strbuf err = STRBUF_INIT;24162417for(i =0; i < transaction->nr; i++) {2418struct ref_update *update = transaction->updates[i];2419struct ref_lock *lock = update->backend_data;24202421if(lock) {2422unlock_ref(lock);2423 update->backend_data = NULL;2424}2425}24262427if(backend_data->packed_transaction &&2428ref_transaction_abort(backend_data->packed_transaction, &err)) {2429error("error aborting transaction:%s", err.buf);2430strbuf_release(&err);2431}24322433if(backend_data->packed_refs_locked)2434packed_refs_unlock(refs->packed_ref_store);24352436free(backend_data);24372438 transaction->state = REF_TRANSACTION_CLOSED;2439}24402441static intfiles_transaction_prepare(struct ref_store *ref_store,2442struct ref_transaction *transaction,2443struct strbuf *err)2444{2445struct files_ref_store *refs =2446files_downcast(ref_store, REF_STORE_WRITE,2447"ref_transaction_prepare");2448size_t i;2449int ret =0;2450struct string_list affected_refnames = STRING_LIST_INIT_NODUP;2451char*head_ref = NULL;2452int head_type;2453struct object_id head_oid;2454struct files_transaction_backend_data *backend_data;2455struct ref_transaction *packed_transaction = NULL;24562457assert(err);24582459if(!transaction->nr)2460goto cleanup;24612462 backend_data =xcalloc(1,sizeof(*backend_data));2463 transaction->backend_data = backend_data;24642465/*2466 * Fail if a refname appears more than once in the2467 * transaction. (If we end up splitting up any updates using2468 * split_symref_update() or split_head_update(), those2469 * functions will check that the new updates don't have the2470 * same refname as any existing ones.)2471 */2472for(i =0; i < transaction->nr; i++) {2473struct ref_update *update = transaction->updates[i];2474struct string_list_item *item =2475string_list_append(&affected_refnames, update->refname);24762477/*2478 * We store a pointer to update in item->util, but at2479 * the moment we never use the value of this field2480 * except to check whether it is non-NULL.2481 */2482 item->util = update;2483}2484string_list_sort(&affected_refnames);2485if(ref_update_reject_duplicates(&affected_refnames, err)) {2486 ret = TRANSACTION_GENERIC_ERROR;2487goto cleanup;2488}24892490/*2491 * Special hack: If a branch is updated directly and HEAD2492 * points to it (may happen on the remote side of a push2493 * for example) then logically the HEAD reflog should be2494 * updated too.2495 *2496 * A generic solution would require reverse symref lookups,2497 * but finding all symrefs pointing to a given branch would be2498 * rather costly for this rare event (the direct update of a2499 * branch) to be worth it. So let's cheat and check with HEAD2500 * only, which should cover 99% of all usage scenarios (even2501 * 100% of the default ones).2502 *2503 * So if HEAD is a symbolic reference, then record the name of2504 * the reference that it points to. If we see an update of2505 * head_ref within the transaction, then split_head_update()2506 * arranges for the reflog of HEAD to be updated, too.2507 */2508 head_ref =refs_resolve_refdup(ref_store,"HEAD",2509 RESOLVE_REF_NO_RECURSE,2510 head_oid.hash, &head_type);25112512if(head_ref && !(head_type & REF_ISSYMREF)) {2513FREE_AND_NULL(head_ref);2514}25152516/*2517 * Acquire all locks, verify old values if provided, check2518 * that new values are valid, and write new values to the2519 * lockfiles, ready to be activated. Only keep one lockfile2520 * open at a time to avoid running out of file descriptors.2521 * Note that lock_ref_for_update() might append more updates2522 * to the transaction.2523 */2524for(i =0; i < transaction->nr; i++) {2525struct ref_update *update = transaction->updates[i];25262527 ret =lock_ref_for_update(refs, update, transaction,2528 head_ref, &affected_refnames, err);2529if(ret)2530goto cleanup;25312532if(update->flags & REF_DELETING &&2533!(update->flags & REF_LOG_ONLY) &&2534!(update->flags & REF_ISPRUNING)) {2535/*2536 * This reference has to be deleted from2537 * packed-refs if it exists there.2538 */2539if(!packed_transaction) {2540 packed_transaction =ref_store_transaction_begin(2541 refs->packed_ref_store, err);2542if(!packed_transaction) {2543 ret = TRANSACTION_GENERIC_ERROR;2544goto cleanup;2545}25462547 backend_data->packed_transaction =2548 packed_transaction;2549}25502551ref_transaction_add_update(2552 packed_transaction, update->refname,2553 update->flags & ~REF_HAVE_OLD,2554 update->new_oid.hash, update->old_oid.hash,2555 NULL);2556}2557}25582559if(packed_transaction) {2560if(packed_refs_lock(refs->packed_ref_store,0, err)) {2561 ret = TRANSACTION_GENERIC_ERROR;2562goto cleanup;2563}2564 backend_data->packed_refs_locked =1;2565 ret =ref_transaction_prepare(packed_transaction, err);2566}25672568cleanup:2569free(head_ref);2570string_list_clear(&affected_refnames,0);25712572if(ret)2573files_transaction_cleanup(refs, transaction);2574else2575 transaction->state = REF_TRANSACTION_PREPARED;25762577return ret;2578}25792580static intfiles_transaction_finish(struct ref_store *ref_store,2581struct ref_transaction *transaction,2582struct strbuf *err)2583{2584struct files_ref_store *refs =2585files_downcast(ref_store,0,"ref_transaction_finish");2586size_t i;2587int ret =0;2588struct strbuf sb = STRBUF_INIT;2589struct files_transaction_backend_data *backend_data;2590struct ref_transaction *packed_transaction;259125922593assert(err);25942595if(!transaction->nr) {2596 transaction->state = REF_TRANSACTION_CLOSED;2597return0;2598}25992600 backend_data = transaction->backend_data;2601 packed_transaction = backend_data->packed_transaction;26022603/* Perform updates first so live commits remain referenced */2604for(i =0; i < transaction->nr; i++) {2605struct ref_update *update = transaction->updates[i];2606struct ref_lock *lock = update->backend_data;26072608if(update->flags & REF_NEEDS_COMMIT ||2609 update->flags & REF_LOG_ONLY) {2610if(files_log_ref_write(refs,2611 lock->ref_name,2612&lock->old_oid,2613&update->new_oid,2614 update->msg, update->flags,2615 err)) {2616char*old_msg =strbuf_detach(err, NULL);26172618strbuf_addf(err,"cannot update the ref '%s':%s",2619 lock->ref_name, old_msg);2620free(old_msg);2621unlock_ref(lock);2622 update->backend_data = NULL;2623 ret = TRANSACTION_GENERIC_ERROR;2624goto cleanup;2625}2626}2627if(update->flags & REF_NEEDS_COMMIT) {2628clear_loose_ref_cache(refs);2629if(commit_ref(lock)) {2630strbuf_addf(err,"couldn't set '%s'", lock->ref_name);2631unlock_ref(lock);2632 update->backend_data = NULL;2633 ret = TRANSACTION_GENERIC_ERROR;2634goto cleanup;2635}2636}2637}26382639/*2640 * Now that updates are safely completed, we can perform2641 * deletes. First delete the reflogs of any references that2642 * will be deleted, since (in the unexpected event of an2643 * error) leaving a reference without a reflog is less bad2644 * than leaving a reflog without a reference (the latter is a2645 * mildly invalid repository state):2646 */2647for(i =0; i < transaction->nr; i++) {2648struct ref_update *update = transaction->updates[i];2649if(update->flags & REF_DELETING &&2650!(update->flags & REF_LOG_ONLY) &&2651!(update->flags & REF_ISPRUNING)) {2652strbuf_reset(&sb);2653files_reflog_path(refs, &sb, update->refname);2654if(!unlink_or_warn(sb.buf))2655try_remove_empty_parents(refs, update->refname,2656 REMOVE_EMPTY_PARENTS_REFLOG);2657}2658}26592660/*2661 * Perform deletes now that updates are safely completed.2662 *2663 * First delete any packed versions of the references, while2664 * retaining the packed-refs lock:2665 */2666if(packed_transaction) {2667 ret =ref_transaction_commit(packed_transaction, err);2668ref_transaction_free(packed_transaction);2669 packed_transaction = NULL;2670 backend_data->packed_transaction = NULL;2671if(ret)2672goto cleanup;2673}26742675/* Now delete the loose versions of the references: */2676for(i =0; i < transaction->nr; i++) {2677struct ref_update *update = transaction->updates[i];2678struct ref_lock *lock = update->backend_data;26792680if(update->flags & REF_DELETING &&2681!(update->flags & REF_LOG_ONLY)) {2682if(!(update->type & REF_ISPACKED) ||2683 update->type & REF_ISSYMREF) {2684/* It is a loose reference. */2685strbuf_reset(&sb);2686files_ref_path(refs, &sb, lock->ref_name);2687if(unlink_or_msg(sb.buf, err)) {2688 ret = TRANSACTION_GENERIC_ERROR;2689goto cleanup;2690}2691 update->flags |= REF_DELETED_LOOSE;2692}2693}2694}26952696clear_loose_ref_cache(refs);26972698cleanup:2699files_transaction_cleanup(refs, transaction);27002701for(i =0; i < transaction->nr; i++) {2702struct ref_update *update = transaction->updates[i];27032704if(update->flags & REF_DELETED_LOOSE) {2705/*2706 * The loose reference was deleted. Delete any2707 * empty parent directories. (Note that this2708 * can only work because we have already2709 * removed the lockfile.)2710 */2711try_remove_empty_parents(refs, update->refname,2712 REMOVE_EMPTY_PARENTS_REF);2713}2714}27152716strbuf_release(&sb);2717return ret;2718}27192720static intfiles_transaction_abort(struct ref_store *ref_store,2721struct ref_transaction *transaction,2722struct strbuf *err)2723{2724struct files_ref_store *refs =2725files_downcast(ref_store,0,"ref_transaction_abort");27262727files_transaction_cleanup(refs, transaction);2728return0;2729}27302731static intref_present(const char*refname,2732const struct object_id *oid,int flags,void*cb_data)2733{2734struct string_list *affected_refnames = cb_data;27352736returnstring_list_has_string(affected_refnames, refname);2737}27382739static intfiles_initial_transaction_commit(struct ref_store *ref_store,2740struct ref_transaction *transaction,2741struct strbuf *err)2742{2743struct files_ref_store *refs =2744files_downcast(ref_store, REF_STORE_WRITE,2745"initial_ref_transaction_commit");2746size_t i;2747int ret =0;2748struct string_list affected_refnames = STRING_LIST_INIT_NODUP;2749struct ref_transaction *packed_transaction = NULL;27502751assert(err);27522753if(transaction->state != REF_TRANSACTION_OPEN)2754die("BUG: commit called for transaction that is not open");27552756/* Fail if a refname appears more than once in the transaction: */2757for(i =0; i < transaction->nr; i++)2758string_list_append(&affected_refnames,2759 transaction->updates[i]->refname);2760string_list_sort(&affected_refnames);2761if(ref_update_reject_duplicates(&affected_refnames, err)) {2762 ret = TRANSACTION_GENERIC_ERROR;2763goto cleanup;2764}27652766/*2767 * It's really undefined to call this function in an active2768 * repository or when there are existing references: we are2769 * only locking and changing packed-refs, so (1) any2770 * simultaneous processes might try to change a reference at2771 * the same time we do, and (2) any existing loose versions of2772 * the references that we are setting would have precedence2773 * over our values. But some remote helpers create the remote2774 * "HEAD" and "master" branches before calling this function,2775 * so here we really only check that none of the references2776 * that we are creating already exists.2777 */2778if(refs_for_each_rawref(&refs->base, ref_present,2779&affected_refnames))2780die("BUG: initial ref transaction called with existing refs");27812782 packed_transaction =ref_store_transaction_begin(refs->packed_ref_store, err);2783if(!packed_transaction) {2784 ret = TRANSACTION_GENERIC_ERROR;2785goto cleanup;2786}27872788for(i =0; i < transaction->nr; i++) {2789struct ref_update *update = transaction->updates[i];27902791if((update->flags & REF_HAVE_OLD) &&2792!is_null_oid(&update->old_oid))2793die("BUG: initial ref transaction with old_sha1 set");2794if(refs_verify_refname_available(&refs->base, update->refname,2795&affected_refnames, NULL,2796 err)) {2797 ret = TRANSACTION_NAME_CONFLICT;2798goto cleanup;2799}28002801/*2802 * Add a reference creation for this reference to the2803 * packed-refs transaction:2804 */2805ref_transaction_add_update(packed_transaction, update->refname,2806 update->flags & ~REF_HAVE_OLD,2807 update->new_oid.hash, update->old_oid.hash,2808 NULL);2809}28102811if(packed_refs_lock(refs->packed_ref_store,0, err)) {2812 ret = TRANSACTION_GENERIC_ERROR;2813goto cleanup;2814}28152816if(initial_ref_transaction_commit(packed_transaction, err)) {2817 ret = TRANSACTION_GENERIC_ERROR;2818goto cleanup;2819}28202821cleanup:2822if(packed_transaction)2823ref_transaction_free(packed_transaction);2824packed_refs_unlock(refs->packed_ref_store);2825 transaction->state = REF_TRANSACTION_CLOSED;2826string_list_clear(&affected_refnames,0);2827return ret;2828}28292830struct expire_reflog_cb {2831unsigned int flags;2832 reflog_expiry_should_prune_fn *should_prune_fn;2833void*policy_cb;2834FILE*newlog;2835struct object_id last_kept_oid;2836};28372838static intexpire_reflog_ent(struct object_id *ooid,struct object_id *noid,2839const char*email, timestamp_t timestamp,int tz,2840const char*message,void*cb_data)2841{2842struct expire_reflog_cb *cb = cb_data;2843struct expire_reflog_policy_cb *policy_cb = cb->policy_cb;28442845if(cb->flags & EXPIRE_REFLOGS_REWRITE)2846 ooid = &cb->last_kept_oid;28472848if((*cb->should_prune_fn)(ooid, noid, email, timestamp, tz,2849 message, policy_cb)) {2850if(!cb->newlog)2851printf("would prune%s", message);2852else if(cb->flags & EXPIRE_REFLOGS_VERBOSE)2853printf("prune%s", message);2854}else{2855if(cb->newlog) {2856fprintf(cb->newlog,"%s %s %s%"PRItime" %+05d\t%s",2857oid_to_hex(ooid),oid_to_hex(noid),2858 email, timestamp, tz, message);2859oidcpy(&cb->last_kept_oid, noid);2860}2861if(cb->flags & EXPIRE_REFLOGS_VERBOSE)2862printf("keep%s", message);2863}2864return0;2865}28662867static intfiles_reflog_expire(struct ref_store *ref_store,2868const char*refname,const unsigned char*sha1,2869unsigned int flags,2870 reflog_expiry_prepare_fn prepare_fn,2871 reflog_expiry_should_prune_fn should_prune_fn,2872 reflog_expiry_cleanup_fn cleanup_fn,2873void*policy_cb_data)2874{2875struct files_ref_store *refs =2876files_downcast(ref_store, REF_STORE_WRITE,"reflog_expire");2877static struct lock_file reflog_lock;2878struct expire_reflog_cb cb;2879struct ref_lock *lock;2880struct strbuf log_file_sb = STRBUF_INIT;2881char*log_file;2882int status =0;2883int type;2884struct strbuf err = STRBUF_INIT;2885struct object_id oid;28862887memset(&cb,0,sizeof(cb));2888 cb.flags = flags;2889 cb.policy_cb = policy_cb_data;2890 cb.should_prune_fn = should_prune_fn;28912892/*2893 * The reflog file is locked by holding the lock on the2894 * reference itself, plus we might need to update the2895 * reference if --updateref was specified:2896 */2897 lock =lock_ref_sha1_basic(refs, refname, sha1,2898 NULL, NULL, REF_NODEREF,2899&type, &err);2900if(!lock) {2901error("cannot lock ref '%s':%s", refname, err.buf);2902strbuf_release(&err);2903return-1;2904}2905if(!refs_reflog_exists(ref_store, refname)) {2906unlock_ref(lock);2907return0;2908}29092910files_reflog_path(refs, &log_file_sb, refname);2911 log_file =strbuf_detach(&log_file_sb, NULL);2912if(!(flags & EXPIRE_REFLOGS_DRY_RUN)) {2913/*2914 * Even though holding $GIT_DIR/logs/$reflog.lock has2915 * no locking implications, we use the lock_file2916 * machinery here anyway because it does a lot of the2917 * work we need, including cleaning up if the program2918 * exits unexpectedly.2919 */2920if(hold_lock_file_for_update(&reflog_lock, log_file,0) <0) {2921struct strbuf err = STRBUF_INIT;2922unable_to_lock_message(log_file, errno, &err);2923error("%s", err.buf);2924strbuf_release(&err);2925goto failure;2926}2927 cb.newlog =fdopen_lock_file(&reflog_lock,"w");2928if(!cb.newlog) {2929error("cannot fdopen%s(%s)",2930get_lock_file_path(&reflog_lock),strerror(errno));2931goto failure;2932}2933}29342935hashcpy(oid.hash, sha1);29362937(*prepare_fn)(refname, &oid, cb.policy_cb);2938refs_for_each_reflog_ent(ref_store, refname, expire_reflog_ent, &cb);2939(*cleanup_fn)(cb.policy_cb);29402941if(!(flags & EXPIRE_REFLOGS_DRY_RUN)) {2942/*2943 * It doesn't make sense to adjust a reference pointed2944 * to by a symbolic ref based on expiring entries in2945 * the symbolic reference's reflog. Nor can we update2946 * a reference if there are no remaining reflog2947 * entries.2948 */2949int update = (flags & EXPIRE_REFLOGS_UPDATE_REF) &&2950!(type & REF_ISSYMREF) &&2951!is_null_oid(&cb.last_kept_oid);29522953if(close_lock_file(&reflog_lock)) {2954 status |=error("couldn't write%s:%s", log_file,2955strerror(errno));2956}else if(update &&2957(write_in_full(get_lock_file_fd(lock->lk),2958oid_to_hex(&cb.last_kept_oid), GIT_SHA1_HEXSZ) != GIT_SHA1_HEXSZ ||2959write_str_in_full(get_lock_file_fd(lock->lk),"\n") !=1||2960close_ref(lock) <0)) {2961 status |=error("couldn't write%s",2962get_lock_file_path(lock->lk));2963rollback_lock_file(&reflog_lock);2964}else if(commit_lock_file(&reflog_lock)) {2965 status |=error("unable to write reflog '%s' (%s)",2966 log_file,strerror(errno));2967}else if(update &&commit_ref(lock)) {2968 status |=error("couldn't set%s", lock->ref_name);2969}2970}2971free(log_file);2972unlock_ref(lock);2973return status;29742975 failure:2976rollback_lock_file(&reflog_lock);2977free(log_file);2978unlock_ref(lock);2979return-1;2980}29812982static intfiles_init_db(struct ref_store *ref_store,struct strbuf *err)2983{2984struct files_ref_store *refs =2985files_downcast(ref_store, REF_STORE_WRITE,"init_db");2986struct strbuf sb = STRBUF_INIT;29872988/*2989 * Create .git/refs/{heads,tags}2990 */2991files_ref_path(refs, &sb,"refs/heads");2992safe_create_dir(sb.buf,1);29932994strbuf_reset(&sb);2995files_ref_path(refs, &sb,"refs/tags");2996safe_create_dir(sb.buf,1);29972998strbuf_release(&sb);2999return0;3000}30013002struct ref_storage_be refs_be_files = {3003 NULL,3004"files",3005 files_ref_store_create,3006 files_init_db,3007 files_transaction_prepare,3008 files_transaction_finish,3009 files_transaction_abort,3010 files_initial_transaction_commit,30113012 files_pack_refs,3013 files_peel_ref,3014 files_create_symref,3015 files_delete_refs,3016 files_rename_ref,30173018 files_ref_iterator_begin,3019 files_read_raw_ref,30203021 files_reflog_iterator_begin,3022 files_for_each_reflog_ent,3023 files_for_each_reflog_ent_reverse,3024 files_reflog_exists,3025 files_create_reflog,3026 files_delete_reflog,3027 files_reflog_expire3028};