Merge branch 'jk/leak-checkers'
[git] / 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 };