git.oblomov.eu Git - git/blob - refs/packed-backend.c

   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 "../lockfile.h"
   9
  10 struct packed_ref_cache {
  11         struct ref_cache *cache;
  12
  13         /*
  14          * Count of references to the data structure in this instance,
  15          * including the pointer from files_ref_store::packed if any.
  16          * The data will not be freed as long as the reference count
  17          * is nonzero.
  18          */
  19         unsigned int referrers;
  20
  21         /* The metadata from when this packed-refs cache was read */
  22         struct stat_validity validity;
  23 };
  24
  25 /*
  26  * Increment the reference count of *packed_refs.
  27  */
  28 static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs)
  29 {
  30         packed_refs->referrers++;
  31 }
  32
  33 /*
  34  * Decrease the reference count of *packed_refs.  If it goes to zero,
  35  * free *packed_refs and return true; otherwise return false.
  36  */
  37 static int release_packed_ref_cache(struct packed_ref_cache *packed_refs)
  38 {
  39         if (!--packed_refs->referrers) {
  40                 free_ref_cache(packed_refs->cache);
  41                 stat_validity_clear(&packed_refs->validity);
  42                 free(packed_refs);
  43                 return 1;
  44         } else {
  45                 return 0;
  46         }
  47 }
  48
  49 /*
  50  * A container for `packed-refs`-related data. It is not (yet) a
  51  * `ref_store`.
  52  */
  53 struct packed_ref_store {
  54         struct ref_store base;
  55
  56         unsigned int store_flags;
  57
  58         /* The path of the "packed-refs" file: */
  59         char *path;
  60
  61         /*
  62          * A cache of the values read from the `packed-refs` file, if
  63          * it might still be current; otherwise, NULL.
  64          */
  65         struct packed_ref_cache *cache;
  66
  67         /*
  68          * Lock used for the "packed-refs" file. Note that this (and
  69          * thus the enclosing `packed_ref_store`) must not be freed.
  70          */
  71         struct lock_file lock;
  72
  73         /*
  74          * Temporary file used when rewriting new contents to the
  75          * "packed-refs" file. Note that this (and thus the enclosing
  76          * `packed_ref_store`) must not be freed.
  77          */
  78         struct tempfile *tempfile;
  79 };
  80
  81 struct ref_store *packed_ref_store_create(const char *path,
  82                                           unsigned int store_flags)
  83 {
  84         struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));
  85         struct ref_store *ref_store = (struct ref_store *)refs;
  86
  87         base_ref_store_init(ref_store, &refs_be_packed);
  88         refs->store_flags = store_flags;
  89
  90         refs->path = xstrdup(path);
  91         return ref_store;
  92 }
  93
  94 /*
  95  * Die if refs is not the main ref store. caller is used in any
  96  * necessary error messages.
  97  */
  98 static void packed_assert_main_repository(struct packed_ref_store *refs,
  99                                           const char *caller)
 100 {
 101         if (refs->store_flags & REF_STORE_MAIN)
 102                 return;
 103
 104         die("BUG: operation %s only allowed for main ref store", caller);
 105 }
 106
 107 /*
 108  * Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is
 109  * not a `packed_ref_store`. Also die if `packed_ref_store` doesn't
 110  * support at least the flags specified in `required_flags`. `caller`
 111  * is used in any necessary error messages.
 112  */
 113 static struct packed_ref_store *packed_downcast(struct ref_store *ref_store,
 114                                                 unsigned int required_flags,
 115                                                 const char *caller)
 116 {
 117         struct packed_ref_store *refs;
 118
 119         if (ref_store->be != &refs_be_packed)
 120                 die("BUG: ref_store is type \"%s\" not \"packed\" in %s",
 121                     ref_store->be->name, caller);
 122
 123         refs = (struct packed_ref_store *)ref_store;
 124
 125         if ((refs->store_flags & required_flags) != required_flags)
 126                 die("BUG: unallowed operation (%s), requires %x, has %x\n",
 127                     caller, required_flags, refs->store_flags);
 128
 129         return refs;
 130 }
 131
 132 static void clear_packed_ref_cache(struct packed_ref_store *refs)
 133 {
 134         if (refs->cache) {
 135                 struct packed_ref_cache *cache = refs->cache;
 136
 137                 refs->cache = NULL;
 138                 release_packed_ref_cache(cache);
 139         }
 140 }
 141
 142 /* The length of a peeled reference line in packed-refs, including EOL: */
 143 #define PEELED_LINE_LENGTH 42
 144
 145 /*
 146  * Parse one line from a packed-refs file.  Write the SHA1 to sha1.
 147  * Return a pointer to the refname within the line (null-terminated),
 148  * or NULL if there was a problem.
 149  */
 150 static const char *parse_ref_line(struct strbuf *line, struct object_id *oid)
 151 {
 152         const char *ref;
 153
 154         if (parse_oid_hex(line->buf, oid, &ref) < 0)
 155                 return NULL;
 156         if (!isspace(*ref++))
 157                 return NULL;
 158
 159         if (isspace(*ref))
 160                 return NULL;
 161
 162         if (line->buf[line->len - 1] != '\n')
 163                 return NULL;
 164         line->buf[--line->len] = 0;
 165
 166         return ref;
 167 }
 168
 169 /*
 170  * Read from `packed_refs_file` into a newly-allocated
 171  * `packed_ref_cache` and return it. The return value will already
 172  * have its reference count incremented.
 173  *
 174  * A comment line of the form "# pack-refs with: " may contain zero or
 175  * more traits. We interpret the traits as follows:
 176  *
 177  *   No traits:
 178  *
 179  *      Probably no references are peeled. But if the file contains a
 180  *      peeled value for a reference, we will use it.
 181  *
 182  *   peeled:
 183  *
 184  *      References under "refs/tags/", if they *can* be peeled, *are*
 185  *      peeled in this file. References outside of "refs/tags/" are
 186  *      probably not peeled even if they could have been, but if we find
 187  *      a peeled value for such a reference we will use it.
 188  *
 189  *   fully-peeled:
 190  *
 191  *      All references in the file that can be peeled are peeled.
 192  *      Inversely (and this is more important), any references in the
 193  *      file for which no peeled value is recorded is not peelable. This
 194  *      trait should typically be written alongside "peeled" for
 195  *      compatibility with older clients, but we do not require it
 196  *      (i.e., "peeled" is a no-op if "fully-peeled" is set).
 197  */
 198 static struct packed_ref_cache *read_packed_refs(const char *packed_refs_file)
 199 {
 200         FILE *f;
 201         struct packed_ref_cache *packed_refs = xcalloc(1, sizeof(*packed_refs));
 202         struct ref_entry *last = NULL;
 203         struct strbuf line = STRBUF_INIT;
 204         enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
 205         struct ref_dir *dir;
 206
 207         acquire_packed_ref_cache(packed_refs);
 208         packed_refs->cache = create_ref_cache(NULL, NULL);
 209         packed_refs->cache->root->flag &= ~REF_INCOMPLETE;
 210
 211         f = fopen(packed_refs_file, "r");
 212         if (!f) {
 213                 if (errno == ENOENT) {
 214                         /*
 215                          * This is OK; it just means that no
 216                          * "packed-refs" file has been written yet,
 217                          * which is equivalent to it being empty.
 218                          */
 219                         return packed_refs;
 220                 } else {
 221                         die_errno("couldn't read %s", packed_refs_file);
 222                 }
 223         }
 224
 225         stat_validity_update(&packed_refs->validity, fileno(f));
 226
 227         dir = get_ref_dir(packed_refs->cache->root);
 228         while (strbuf_getwholeline(&line, f, '\n') != EOF) {
 229                 struct object_id oid;
 230                 const char *refname;
 231                 const char *traits;
 232
 233                 if (!line.len || line.buf[line.len - 1] != '\n')
 234                         die("unterminated line in %s: %s", packed_refs_file, line.buf);
 235
 236                 if (skip_prefix(line.buf, "# pack-refs with:", &traits)) {
 237                         if (strstr(traits, " fully-peeled "))
 238                                 peeled = PEELED_FULLY;
 239                         else if (strstr(traits, " peeled "))
 240                                 peeled = PEELED_TAGS;
 241                         /* perhaps other traits later as well */
 242                         continue;
 243                 }
 244
 245                 refname = parse_ref_line(&line, &oid);
 246                 if (refname) {
 247                         int flag = REF_ISPACKED;
 248
 249                         if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
 250                                 if (!refname_is_safe(refname))
 251                                         die("packed refname is dangerous: %s", refname);
 252                                 oidclr(&oid);
 253                                 flag |= REF_BAD_NAME | REF_ISBROKEN;
 254                         }
 255                         last = create_ref_entry(refname, &oid, flag);
 256                         if (peeled == PEELED_FULLY ||
 257                             (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))
 258                                 last->flag |= REF_KNOWS_PEELED;
 259                         add_ref_entry(dir, last);
 260                 } else if (last &&
 261                     line.buf[0] == '^' &&
 262                     line.len == PEELED_LINE_LENGTH &&
 263                     line.buf[PEELED_LINE_LENGTH - 1] == '\n' &&
 264                     !get_oid_hex(line.buf + 1, &oid)) {
 265                         oidcpy(&last->u.value.peeled, &oid);
 266                         /*
 267                          * Regardless of what the file header said,
 268                          * we definitely know the value of *this*
 269                          * reference:
 270                          */
 271                         last->flag |= REF_KNOWS_PEELED;
 272                 } else {
 273                         strbuf_setlen(&line, line.len - 1);
 274                         die("unexpected line in %s: %s", packed_refs_file, line.buf);
 275                 }
 276         }
 277
 278         fclose(f);
 279         strbuf_release(&line);
 280
 281         return packed_refs;
 282 }
 283
 284 /*
 285  * Check that the packed refs cache (if any) still reflects the
 286  * contents of the file. If not, clear the cache.
 287  */
 288 static void validate_packed_ref_cache(struct packed_ref_store *refs)
 289 {
 290         if (refs->cache &&
 291             !stat_validity_check(&refs->cache->validity, refs->path))
 292                 clear_packed_ref_cache(refs);
 293 }
 294
 295 /*
 296  * Get the packed_ref_cache for the specified packed_ref_store,
 297  * creating and populating it if it hasn't been read before or if the
 298  * file has been changed (according to its `validity` field) since it
 299  * was last read. On the other hand, if we hold the lock, then assume
 300  * that the file hasn't been changed out from under us, so skip the
 301  * extra `stat()` call in `stat_validity_check()`.
 302  */
 303 static struct packed_ref_cache *get_packed_ref_cache(struct packed_ref_store *refs)
 304 {
 305         if (!is_lock_file_locked(&refs->lock))
 306                 validate_packed_ref_cache(refs);
 307
 308         if (!refs->cache)
 309                 refs->cache = read_packed_refs(refs->path);
 310
 311         return refs->cache;
 312 }
 313
 314 static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)
 315 {
 316         return get_ref_dir(packed_ref_cache->cache->root);
 317 }
 318
 319 static struct ref_dir *get_packed_refs(struct packed_ref_store *refs)
 320 {
 321         return get_packed_ref_dir(get_packed_ref_cache(refs));
 322 }
 323
 324 /*
 325  * Add or overwrite a reference in the in-memory packed reference
 326  * cache. This may only be called while the packed-refs file is locked
 327  * (see packed_refs_lock()). To actually write the packed-refs file,
 328  * call commit_packed_refs().
 329  */
 330 void add_packed_ref(struct ref_store *ref_store,
 331                     const char *refname, const struct object_id *oid)
 332 {
 333         struct packed_ref_store *refs =
 334                 packed_downcast(ref_store, REF_STORE_WRITE,
 335                                 "add_packed_ref");
 336         struct ref_dir *packed_refs;
 337         struct ref_entry *packed_entry;
 338
 339         if (!is_lock_file_locked(&refs->lock))
 340                 die("BUG: packed refs not locked");
 341
 342         if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
 343                 die("Reference has invalid format: '%s'", refname);
 344
 345         packed_refs = get_packed_refs(refs);
 346         packed_entry = find_ref_entry(packed_refs, refname);
 347         if (packed_entry) {
 348                 /* Overwrite the existing entry: */
 349                 oidcpy(&packed_entry->u.value.oid, oid);
 350                 packed_entry->flag = REF_ISPACKED;
 351                 oidclr(&packed_entry->u.value.peeled);
 352         } else {
 353                 packed_entry = create_ref_entry(refname, oid, REF_ISPACKED);
 354                 add_ref_entry(packed_refs, packed_entry);
 355         }
 356 }
 357
 358 /*
 359  * Return the ref_entry for the given refname from the packed
 360  * references.  If it does not exist, return NULL.
 361  */
 362 static struct ref_entry *get_packed_ref(struct packed_ref_store *refs,
 363                                         const char *refname)
 364 {
 365         return find_ref_entry(get_packed_refs(refs), refname);
 366 }
 367
 368 static int packed_read_raw_ref(struct ref_store *ref_store,
 369                                const char *refname, unsigned char *sha1,
 370                                struct strbuf *referent, unsigned int *type)
 371 {
 372         struct packed_ref_store *refs =
 373                 packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref");
 374
 375         struct ref_entry *entry;
 376
 377         *type = 0;
 378
 379         entry = get_packed_ref(refs, refname);
 380         if (!entry) {
 381                 errno = ENOENT;
 382                 return -1;
 383         }
 384
 385         hashcpy(sha1, entry->u.value.oid.hash);
 386         *type = REF_ISPACKED;
 387         return 0;
 388 }
 389
 390 static int packed_peel_ref(struct ref_store *ref_store,
 391                            const char *refname, unsigned char *sha1)
 392 {
 393         struct packed_ref_store *refs =
 394                 packed_downcast(ref_store, REF_STORE_READ | REF_STORE_ODB,
 395                                 "peel_ref");
 396         struct ref_entry *r = get_packed_ref(refs, refname);
 397
 398         if (!r || peel_entry(r, 0))
 399                 return -1;
 400
 401         hashcpy(sha1, r->u.value.peeled.hash);
 402         return 0;
 403 }
 404
 405 struct packed_ref_iterator {
 406         struct ref_iterator base;
 407
 408         struct packed_ref_cache *cache;
 409         struct ref_iterator *iter0;
 410         unsigned int flags;
 411 };
 412
 413 static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator)
 414 {
 415         struct packed_ref_iterator *iter =
 416                 (struct packed_ref_iterator *)ref_iterator;
 417         int ok;
 418
 419         while ((ok = ref_iterator_advance(iter->iter0)) == ITER_OK) {
 420                 if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY &&
 421                     ref_type(iter->iter0->refname) != REF_TYPE_PER_WORKTREE)
 422                         continue;
 423
 424                 if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&
 425                     !ref_resolves_to_object(iter->iter0->refname,
 426                                             iter->iter0->oid,
 427                                             iter->iter0->flags))
 428                         continue;
 429
 430                 iter->base.refname = iter->iter0->refname;
 431                 iter->base.oid = iter->iter0->oid;
 432                 iter->base.flags = iter->iter0->flags;
 433                 return ITER_OK;
 434         }
 435
 436         iter->iter0 = NULL;
 437         if (ref_iterator_abort(ref_iterator) != ITER_DONE)
 438                 ok = ITER_ERROR;
 439
 440         return ok;
 441 }
 442
 443 static int packed_ref_iterator_peel(struct ref_iterator *ref_iterator,
 444                                    struct object_id *peeled)
 445 {
 446         struct packed_ref_iterator *iter =
 447                 (struct packed_ref_iterator *)ref_iterator;
 448
 449         return ref_iterator_peel(iter->iter0, peeled);
 450 }
 451
 452 static int packed_ref_iterator_abort(struct ref_iterator *ref_iterator)
 453 {
 454         struct packed_ref_iterator *iter =
 455                 (struct packed_ref_iterator *)ref_iterator;
 456         int ok = ITER_DONE;
 457
 458         if (iter->iter0)
 459                 ok = ref_iterator_abort(iter->iter0);
 460
 461         release_packed_ref_cache(iter->cache);
 462         base_ref_iterator_free(ref_iterator);
 463         return ok;
 464 }
 465
 466 static struct ref_iterator_vtable packed_ref_iterator_vtable = {
 467         packed_ref_iterator_advance,
 468         packed_ref_iterator_peel,
 469         packed_ref_iterator_abort
 470 };
 471
 472 static struct ref_iterator *packed_ref_iterator_begin(
 473                 struct ref_store *ref_store,
 474                 const char *prefix, unsigned int flags)
 475 {
 476         struct packed_ref_store *refs;
 477         struct packed_ref_iterator *iter;
 478         struct ref_iterator *ref_iterator;
 479         unsigned int required_flags = REF_STORE_READ;
 480
 481         if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN))
 482                 required_flags |= REF_STORE_ODB;
 483         refs = packed_downcast(ref_store, required_flags, "ref_iterator_begin");
 484
 485         iter = xcalloc(1, sizeof(*iter));
 486         ref_iterator = &iter->base;
 487         base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable);
 488
 489         /*
 490          * Note that get_packed_ref_cache() internally checks whether
 491          * the packed-ref cache is up to date with what is on disk,
 492          * and re-reads it if not.
 493          */
 494
 495         iter->cache = get_packed_ref_cache(refs);
 496         acquire_packed_ref_cache(iter->cache);
 497         iter->iter0 = cache_ref_iterator_begin(iter->cache->cache, prefix, 0);
 498
 499         iter->flags = flags;
 500
 501         return ref_iterator;
 502 }
 503
 504 /*
 505  * Write an entry to the packed-refs file for the specified refname.
 506  * If peeled is non-NULL, write it as the entry's peeled value. On
 507  * error, return a nonzero value and leave errno set at the value left
 508  * by the failing call to `fprintf()`.
 509  */
 510 static int write_packed_entry(FILE *fh, const char *refname,
 511                               const unsigned char *sha1,
 512                               const unsigned char *peeled)
 513 {
 514         if (fprintf(fh, "%s %s\n", sha1_to_hex(sha1), refname) < 0 ||
 515             (peeled && fprintf(fh, "^%s\n", sha1_to_hex(peeled)) < 0))
 516                 return -1;
 517
 518         return 0;
 519 }
 520
 521 int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)
 522 {
 523         struct packed_ref_store *refs =
 524                 packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
 525                                 "packed_refs_lock");
 526         static int timeout_configured = 0;
 527         static int timeout_value = 1000;
 528         struct packed_ref_cache *packed_ref_cache;
 529
 530         if (!timeout_configured) {
 531                 git_config_get_int("core.packedrefstimeout", &timeout_value);
 532                 timeout_configured = 1;
 533         }
 534
 535         /*
 536          * Note that we close the lockfile immediately because we
 537          * don't write new content to it, but rather to a separate
 538          * tempfile.
 539          */
 540         if (hold_lock_file_for_update_timeout(
 541                             &refs->lock,
 542                             refs->path,
 543                             flags, timeout_value) < 0) {
 544                 unable_to_lock_message(refs->path, errno, err);
 545                 return -1;
 546         }
 547
 548         if (close_lock_file_gently(&refs->lock)) {
 549                 strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno));
 550                 rollback_lock_file(&refs->lock);
 551                 return -1;
 552         }
 553
 554         /*
 555          * Now that we hold the `packed-refs` lock, make sure that our
 556          * cache matches the current version of the file. Normally
 557          * `get_packed_ref_cache()` does that for us, but that
 558          * function assumes that when the file is locked, any existing
 559          * cache is still valid. We've just locked the file, but it
 560          * might have changed the moment *before* we locked it.
 561          */
 562         validate_packed_ref_cache(refs);
 563
 564         packed_ref_cache = get_packed_ref_cache(refs);
 565         /* Increment the reference count to prevent it from being freed: */
 566         acquire_packed_ref_cache(packed_ref_cache);
 567         return 0;
 568 }
 569
 570 void packed_refs_unlock(struct ref_store *ref_store)
 571 {
 572         struct packed_ref_store *refs = packed_downcast(
 573                         ref_store,
 574                         REF_STORE_READ | REF_STORE_WRITE,
 575                         "packed_refs_unlock");
 576
 577         if (!is_lock_file_locked(&refs->lock))
 578                 die("BUG: packed_refs_unlock() called when not locked");
 579         rollback_lock_file(&refs->lock);
 580         release_packed_ref_cache(refs->cache);
 581 }
 582
 583 int packed_refs_is_locked(struct ref_store *ref_store)
 584 {
 585         struct packed_ref_store *refs = packed_downcast(
 586                         ref_store,
 587                         REF_STORE_READ | REF_STORE_WRITE,
 588                         "packed_refs_is_locked");
 589
 590         return is_lock_file_locked(&refs->lock);
 591 }
 592
 593 /*
 594  * The packed-refs header line that we write out.  Perhaps other
 595  * traits will be added later.  The trailing space is required.
 596  */
 597 static const char PACKED_REFS_HEADER[] =
 598         "# pack-refs with: peeled fully-peeled \n";
 599
 600 /*
 601  * Write the current version of the packed refs cache from memory to
 602  * disk. The packed-refs file must already be locked for writing (see
 603  * packed_refs_lock()). Return zero on success. On errors, rollback
 604  * the lockfile, write an error message to `err`, and return a nonzero
 605  * value.
 606  */
 607 int commit_packed_refs(struct ref_store *ref_store, struct strbuf *err)
 608 {
 609         struct packed_ref_store *refs =
 610                 packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
 611                                 "commit_packed_refs");
 612         struct packed_ref_cache *packed_ref_cache =
 613                 get_packed_ref_cache(refs);
 614         int ok;
 615         int ret = -1;
 616         struct strbuf sb = STRBUF_INIT;
 617         FILE *out;
 618         struct ref_iterator *iter;
 619         char *packed_refs_path;
 620
 621         if (!is_lock_file_locked(&refs->lock))
 622                 die("BUG: commit_packed_refs() called when unlocked");
 623
 624         /*
 625          * If packed-refs is a symlink, we want to overwrite the
 626          * symlinked-to file, not the symlink itself. Also, put the
 627          * staging file next to it:
 628          */
 629         packed_refs_path = get_locked_file_path(&refs->lock);
 630         strbuf_addf(&sb, "%s.new", packed_refs_path);
 631         refs->tempfile = create_tempfile(sb.buf);
 632         if (!refs->tempfile) {
 633                 strbuf_addf(err, "unable to create file %s: %s",
 634                             sb.buf, strerror(errno));
 635                 strbuf_release(&sb);
 636                 goto out;
 637         }
 638         strbuf_release(&sb);
 639
 640         out = fdopen_tempfile(refs->tempfile, "w");
 641         if (!out) {
 642                 strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s",
 643                             strerror(errno));
 644                 goto error;
 645         }
 646
 647         if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0) {
 648                 strbuf_addf(err, "error writing to %s: %s",
 649                             get_tempfile_path(refs->tempfile), strerror(errno));
 650                 goto error;
 651         }
 652
 653         iter = cache_ref_iterator_begin(packed_ref_cache->cache, NULL, 0);
 654         while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
 655                 struct object_id peeled;
 656                 int peel_error = ref_iterator_peel(iter, &peeled);
 657
 658                 if (write_packed_entry(out, iter->refname, iter->oid->hash,
 659                                        peel_error ? NULL : peeled.hash)) {
 660                         strbuf_addf(err, "error writing to %s: %s",
 661                                     get_tempfile_path(refs->tempfile),
 662                                     strerror(errno));
 663                         ref_iterator_abort(iter);
 664                         goto error;
 665                 }
 666         }
 667
 668         if (ok != ITER_DONE) {
 669                 strbuf_addf(err, "unable to rewrite packed-refs file: "
 670                             "error iterating over old contents");
 671                 goto error;
 672         }
 673
 674         if (rename_tempfile(&refs->tempfile, packed_refs_path)) {
 675                 strbuf_addf(err, "error replacing %s: %s",
 676                             refs->path, strerror(errno));
 677                 goto out;
 678         }
 679
 680         ret = 0;
 681         goto out;
 682
 683 error:
 684         delete_tempfile(&refs->tempfile);
 685
 686 out:
 687         free(packed_refs_path);
 688         return ret;
 689 }
 690
 691 /*
 692  * Rewrite the packed-refs file, omitting any refs listed in
 693  * 'refnames'. On error, leave packed-refs unchanged, write an error
 694  * message to 'err', and return a nonzero value. The packed refs lock
 695  * must be held when calling this function; it will still be held when
 696  * the function returns.
 697  *
 698  * The refs in 'refnames' needn't be sorted. `err` must not be NULL.
 699  */
 700 int repack_without_refs(struct ref_store *ref_store,
 701                         struct string_list *refnames, struct strbuf *err)
 702 {
 703         struct packed_ref_store *refs =
 704                 packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
 705                                 "repack_without_refs");
 706         struct ref_dir *packed;
 707         struct string_list_item *refname;
 708         int needs_repacking = 0, removed = 0;
 709
 710         packed_assert_main_repository(refs, "repack_without_refs");
 711         assert(err);
 712
 713         if (!is_lock_file_locked(&refs->lock))
 714                 die("BUG: repack_without_refs called without holding lock");
 715
 716         /* Look for a packed ref */
 717         for_each_string_list_item(refname, refnames) {
 718                 if (get_packed_ref(refs, refname->string)) {
 719                         needs_repacking = 1;
 720                         break;
 721                 }
 722         }
 723
 724         /* Avoid locking if we have nothing to do */
 725         if (!needs_repacking)
 726                 return 0; /* no refname exists in packed refs */
 727
 728         packed = get_packed_refs(refs);
 729
 730         /* Remove refnames from the cache */
 731         for_each_string_list_item(refname, refnames)
 732                 if (remove_entry_from_dir(packed, refname->string) != -1)
 733                         removed = 1;
 734         if (!removed) {
 735                 /*
 736                  * All packed entries disappeared while we were
 737                  * acquiring the lock.
 738                  */
 739                 clear_packed_ref_cache(refs);
 740                 return 0;
 741         }
 742
 743         /* Write what remains */
 744         return commit_packed_refs(&refs->base, err);
 745 }
 746
 747 static int packed_init_db(struct ref_store *ref_store, struct strbuf *err)
 748 {
 749         /* Nothing to do. */
 750         return 0;
 751 }
 752
 753 static int packed_transaction_prepare(struct ref_store *ref_store,
 754                                       struct ref_transaction *transaction,
 755                                       struct strbuf *err)
 756 {
 757         die("BUG: not implemented yet");
 758 }
 759
 760 static int packed_transaction_abort(struct ref_store *ref_store,
 761                                     struct ref_transaction *transaction,
 762                                     struct strbuf *err)
 763 {
 764         die("BUG: not implemented yet");
 765 }
 766
 767 static int packed_transaction_finish(struct ref_store *ref_store,
 768                                      struct ref_transaction *transaction,
 769                                      struct strbuf *err)
 770 {
 771         die("BUG: not implemented yet");
 772 }
 773
 774 static int packed_initial_transaction_commit(struct ref_store *ref_store,
 775                                             struct ref_transaction *transaction,
 776                                             struct strbuf *err)
 777 {
 778         return ref_transaction_commit(transaction, err);
 779 }
 780
 781 static int packed_delete_refs(struct ref_store *ref_store, const char *msg,
 782                              struct string_list *refnames, unsigned int flags)
 783 {
 784         die("BUG: not implemented yet");
 785 }
 786
 787 static int packed_pack_refs(struct ref_store *ref_store, unsigned int flags)
 788 {
 789         /*
 790          * Packed refs are already packed. It might be that loose refs
 791          * are packed *into* a packed refs store, but that is done by
 792          * updating the packed references via a transaction.
 793          */
 794         return 0;
 795 }
 796
 797 static int packed_create_symref(struct ref_store *ref_store,
 798                                const char *refname, const char *target,
 799                                const char *logmsg)
 800 {
 801         die("BUG: packed reference store does not support symrefs");
 802 }
 803
 804 static int packed_rename_ref(struct ref_store *ref_store,
 805                             const char *oldrefname, const char *newrefname,
 806                             const char *logmsg)
 807 {
 808         die("BUG: packed reference store does not support renaming references");
 809 }
 810
 811 static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_store)
 812 {
 813         return empty_ref_iterator_begin();
 814 }
 815
 816 static int packed_for_each_reflog_ent(struct ref_store *ref_store,
 817                                       const char *refname,
 818                                       each_reflog_ent_fn fn, void *cb_data)
 819 {
 820         return 0;
 821 }
 822
 823 static int packed_for_each_reflog_ent_reverse(struct ref_store *ref_store,
 824                                               const char *refname,
 825                                               each_reflog_ent_fn fn,
 826                                               void *cb_data)
 827 {
 828         return 0;
 829 }
 830
 831 static int packed_reflog_exists(struct ref_store *ref_store,
 832                                const char *refname)
 833 {
 834         return 0;
 835 }
 836
 837 static int packed_create_reflog(struct ref_store *ref_store,
 838                                const char *refname, int force_create,
 839                                struct strbuf *err)
 840 {
 841         die("BUG: packed reference store does not support reflogs");
 842 }
 843
 844 static int packed_delete_reflog(struct ref_store *ref_store,
 845                                const char *refname)
 846 {
 847         return 0;
 848 }
 849
 850 static int packed_reflog_expire(struct ref_store *ref_store,
 851                                 const char *refname, const unsigned char *sha1,
 852                                 unsigned int flags,
 853                                 reflog_expiry_prepare_fn prepare_fn,
 854                                 reflog_expiry_should_prune_fn should_prune_fn,
 855                                 reflog_expiry_cleanup_fn cleanup_fn,
 856                                 void *policy_cb_data)
 857 {
 858         return 0;
 859 }
 860
 861 struct ref_storage_be refs_be_packed = {
 862         NULL,
 863         "packed",
 864         packed_ref_store_create,
 865         packed_init_db,
 866         packed_transaction_prepare,
 867         packed_transaction_finish,
 868         packed_transaction_abort,
 869         packed_initial_transaction_commit,
 870
 871         packed_pack_refs,
 872         packed_peel_ref,
 873         packed_create_symref,
 874         packed_delete_refs,
 875         packed_rename_ref,
 876
 877         packed_ref_iterator_begin,
 878         packed_read_raw_ref,
 879
 880         packed_reflog_iterator_begin,
 881         packed_for_each_reflog_ent,
 882         packed_for_each_reflog_ent_reverse,
 883         packed_reflog_exists,
 884         packed_create_reflog,
 885         packed_delete_reflog,
 886         packed_reflog_expire
 887 };