find_reference_location(): make function safe for empty snapshots
[git/git.git] / refs / packed-backend.c
CommitLineData
67be7c5a 1#include "../cache.h"
44c2339e 2#include "../config.h"
67be7c5a
MH
3#include "../refs.h"
4#include "refs-internal.h"
67be7c5a
MH
5#include "packed-backend.h"
6#include "../iterator.h"
7#include "../lockfile.h"
8
5b633610
MH
9enum mmap_strategy {
10 /*
11 * Don't use mmap() at all for reading `packed-refs`.
12 */
13 MMAP_NONE,
67be7c5a
MH
14
15 /*
5b633610
MH
16 * Can use mmap() for reading `packed-refs`, but the file must
17 * not remain mmapped. This is the usual option on Windows,
18 * where you cannot rename a new version of a file onto a file
19 * that is currently mmapped.
67be7c5a 20 */
5b633610 21 MMAP_TEMPORARY,
67be7c5a 22
5b633610
MH
23 /*
24 * It is OK to leave the `packed-refs` file mmapped while
25 * arbitrary other code is running.
26 */
27 MMAP_OK
67be7c5a
MH
28};
29
5b633610
MH
30#if defined(NO_MMAP)
31static enum mmap_strategy mmap_strategy = MMAP_NONE;
32#elif defined(MMAP_PREVENTS_DELETE)
33static enum mmap_strategy mmap_strategy = MMAP_TEMPORARY;
34#else
35static enum mmap_strategy mmap_strategy = MMAP_OK;
36#endif
37
f0a7dc86 38struct packed_ref_store;
67be7c5a
MH
39
40/*
cff28ca9
MH
41 * A `snapshot` represents one snapshot of a `packed-refs` file.
42 *
43 * Normally, this will be a mmapped view of the contents of the
44 * `packed-refs` file at the time the snapshot was created. However,
45 * if the `packed-refs` file was not sorted, this might point at heap
46 * memory holding the contents of the `packed-refs` file with its
47 * records sorted by refname.
48 *
49 * `snapshot` instances are reference counted (via
50 * `acquire_snapshot()` and `release_snapshot()`). This is to prevent
51 * an instance from disappearing while an iterator is still iterating
52 * over it. Instances are garbage collected when their `referrers`
53 * count goes to zero.
54 *
55 * The most recent `snapshot`, if available, is referenced by the
56 * `packed_ref_store`. Its freshness is checked whenever
57 * `get_snapshot()` is called; if the existing snapshot is obsolete, a
58 * new snapshot is taken.
67be7c5a 59 */
cff28ca9 60struct snapshot {
f0a7dc86
MH
61 /*
62 * A back-pointer to the packed_ref_store with which this
cff28ca9 63 * snapshot is associated:
f0a7dc86
MH
64 */
65 struct packed_ref_store *refs;
66
5b633610
MH
67 /* Is the `packed-refs` file currently mmapped? */
68 int mmapped;
69
70 /*
4a2854f7
MH
71 * The contents of the `packed-refs` file:
72 *
73 * - buf -- a pointer to the start of the memory
74 * - start -- a pointer to the first byte of actual references
75 * (i.e., after the header line, if one is present)
76 * - eof -- a pointer just past the end of the reference
77 * contents
78 *
79 * If the `packed-refs` file was already sorted, `buf` points
80 * at the mmapped contents of the file. If not, it points at
81 * heap-allocated memory containing the contents, sorted. If
82 * there were no contents (e.g., because the file didn't
83 * exist), `buf`, `start`, and `eof` are all NULL.
5b633610 84 */
4a2854f7 85 char *buf, *start, *eof;
5b633610 86
daa45408 87 /*
cff28ca9
MH
88 * What is the peeled state of the `packed-refs` file that
89 * this snapshot represents? (This is usually determined from
90 * the file's header.)
daa45408
MH
91 */
92 enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled;
93
67be7c5a 94 /*
cff28ca9
MH
95 * Count of references to this instance, including the pointer
96 * from `packed_ref_store::snapshot`, if any. The instance
97 * will not be freed as long as the reference count is
98 * nonzero.
67be7c5a
MH
99 */
100 unsigned int referrers;
101
cff28ca9
MH
102 /*
103 * The metadata of the `packed-refs` file from which this
104 * snapshot was created, used to tell if the file has been
105 * replaced since we read it.
106 */
67be7c5a
MH
107 struct stat_validity validity;
108};
67be7c5a
MH
109
110/*
cff28ca9
MH
111 * A `ref_store` representing references stored in a `packed-refs`
112 * file. It implements the `ref_store` interface, though it has some
113 * limitations:
114 *
115 * - It cannot store symbolic references.
116 *
117 * - It cannot store reflogs.
118 *
119 * - It does not support reference renaming (though it could).
120 *
121 * On the other hand, it can be locked outside of a reference
122 * transaction. In that case, it remains locked even after the
123 * transaction is done and the new `packed-refs` file is activated.
67be7c5a
MH
124 */
125struct packed_ref_store {
e0cc8ac8
MH
126 struct ref_store base;
127
67be7c5a
MH
128 unsigned int store_flags;
129
130 /* The path of the "packed-refs" file: */
131 char *path;
132
133 /*
cff28ca9
MH
134 * A snapshot of the values read from the `packed-refs` file,
135 * if it might still be current; otherwise, NULL.
67be7c5a 136 */
cff28ca9 137 struct snapshot *snapshot;
67be7c5a
MH
138
139 /*
140 * Lock used for the "packed-refs" file. Note that this (and
141 * thus the enclosing `packed_ref_store`) must not be freed.
142 */
143 struct lock_file lock;
42dfa7ec
MH
144
145 /*
146 * Temporary file used when rewriting new contents to the
147 * "packed-refs" file. Note that this (and thus the enclosing
148 * `packed_ref_store`) must not be freed.
149 */
076aa2cb 150 struct tempfile *tempfile;
67be7c5a
MH
151};
152
14b3c344 153/*
cff28ca9 154 * Increment the reference count of `*snapshot`.
14b3c344 155 */
cff28ca9 156static void acquire_snapshot(struct snapshot *snapshot)
14b3c344 157{
cff28ca9 158 snapshot->referrers++;
14b3c344
MH
159}
160
5b633610 161/*
cff28ca9 162 * If the buffer in `snapshot` is active, then either munmap the
5b633610
MH
163 * memory and close the file, or free the memory. Then set the buffer
164 * pointers to NULL.
165 */
cff28ca9 166static void clear_snapshot_buffer(struct snapshot *snapshot)
5b633610 167{
cff28ca9
MH
168 if (snapshot->mmapped) {
169 if (munmap(snapshot->buf, snapshot->eof - snapshot->buf))
5b633610 170 die_errno("error ummapping packed-refs file %s",
cff28ca9
MH
171 snapshot->refs->path);
172 snapshot->mmapped = 0;
5b633610 173 } else {
cff28ca9 174 free(snapshot->buf);
5b633610 175 }
4a2854f7 176 snapshot->buf = snapshot->start = snapshot->eof = NULL;
5b633610
MH
177}
178
14b3c344 179/*
cff28ca9
MH
180 * Decrease the reference count of `*snapshot`. If it goes to zero,
181 * free `*snapshot` and return true; otherwise return false.
14b3c344 182 */
cff28ca9 183static int release_snapshot(struct snapshot *snapshot)
14b3c344 184{
cff28ca9
MH
185 if (!--snapshot->referrers) {
186 stat_validity_clear(&snapshot->validity);
187 clear_snapshot_buffer(snapshot);
188 free(snapshot);
14b3c344
MH
189 return 1;
190 } else {
191 return 0;
192 }
193}
194
e0cc8ac8
MH
195struct ref_store *packed_ref_store_create(const char *path,
196 unsigned int store_flags)
67be7c5a
MH
197{
198 struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));
e0cc8ac8 199 struct ref_store *ref_store = (struct ref_store *)refs;
67be7c5a 200
e0cc8ac8 201 base_ref_store_init(ref_store, &refs_be_packed);
67be7c5a 202 refs->store_flags = store_flags;
e0cc8ac8 203
67be7c5a 204 refs->path = xstrdup(path);
e0cc8ac8 205 return ref_store;
67be7c5a
MH
206}
207
e0cc8ac8
MH
208/*
209 * Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is
210 * not a `packed_ref_store`. Also die if `packed_ref_store` doesn't
211 * support at least the flags specified in `required_flags`. `caller`
212 * is used in any necessary error messages.
213 */
214static struct packed_ref_store *packed_downcast(struct ref_store *ref_store,
215 unsigned int required_flags,
216 const char *caller)
217{
218 struct packed_ref_store *refs;
219
220 if (ref_store->be != &refs_be_packed)
221 die("BUG: ref_store is type \"%s\" not \"packed\" in %s",
222 ref_store->be->name, caller);
223
224 refs = (struct packed_ref_store *)ref_store;
225
226 if ((refs->store_flags & required_flags) != required_flags)
227 die("BUG: unallowed operation (%s), requires %x, has %x\n",
228 caller, required_flags, refs->store_flags);
229
230 return refs;
231}
232
cff28ca9 233static void clear_snapshot(struct packed_ref_store *refs)
67be7c5a 234{
cff28ca9
MH
235 if (refs->snapshot) {
236 struct snapshot *snapshot = refs->snapshot;
67be7c5a 237
cff28ca9
MH
238 refs->snapshot = NULL;
239 release_snapshot(snapshot);
67be7c5a
MH
240 }
241}
242
735267aa
MH
243static NORETURN void die_unterminated_line(const char *path,
244 const char *p, size_t len)
67be7c5a 245{
735267aa
MH
246 if (len < 80)
247 die("unterminated line in %s: %.*s", path, (int)len, p);
248 else
249 die("unterminated line in %s: %.75s...", path, p);
250}
67be7c5a 251
735267aa
MH
252static NORETURN void die_invalid_line(const char *path,
253 const char *p, size_t len)
254{
255 const char *eol = memchr(p, '\n', len);
256
257 if (!eol)
258 die_unterminated_line(path, p, len);
259 else if (eol - p < 80)
260 die("unexpected line in %s: %.*s", path, (int)(eol - p), p);
261 else
262 die("unexpected line in %s: %.75s...", path, p);
263
264}
265
cff28ca9 266struct snapshot_record {
02b920f3
MH
267 const char *start;
268 size_t len;
269};
270
cff28ca9 271static int cmp_packed_ref_records(const void *v1, const void *v2)
02b920f3 272{
cff28ca9 273 const struct snapshot_record *e1 = v1, *e2 = v2;
02b920f3
MH
274 const char *r1 = e1->start + GIT_SHA1_HEXSZ + 1;
275 const char *r2 = e2->start + GIT_SHA1_HEXSZ + 1;
276
277 while (1) {
278 if (*r1 == '\n')
279 return *r2 == '\n' ? 0 : -1;
280 if (*r1 != *r2) {
281 if (*r2 == '\n')
282 return 1;
283 else
284 return (unsigned char)*r1 < (unsigned char)*r2 ? -1 : +1;
285 }
286 r1++;
287 r2++;
67be7c5a
MH
288 }
289}
290
d1cf1551 291/*
cff28ca9
MH
292 * Compare a snapshot record at `rec` to the specified NUL-terminated
293 * refname.
d1cf1551 294 */
cff28ca9 295static int cmp_record_to_refname(const char *rec, const char *refname)
d1cf1551
MH
296{
297 const char *r1 = rec + GIT_SHA1_HEXSZ + 1;
298 const char *r2 = refname;
299
300 while (1) {
301 if (*r1 == '\n')
302 return *r2 ? -1 : 0;
303 if (!*r2)
304 return 1;
305 if (*r1 != *r2)
306 return (unsigned char)*r1 < (unsigned char)*r2 ? -1 : +1;
307 r1++;
308 r2++;
309 }
310}
67be7c5a
MH
311
312/*
cff28ca9
MH
313 * `snapshot->buf` is not known to be sorted. Check whether it is, and
314 * if not, sort it into new memory and munmap/free the old storage.
67be7c5a 315 */
cff28ca9 316static void sort_snapshot(struct snapshot *snapshot)
67be7c5a 317{
cff28ca9 318 struct snapshot_record *records = NULL;
02b920f3
MH
319 size_t alloc = 0, nr = 0;
320 int sorted = 1;
321 const char *pos, *eof, *eol;
322 size_t len, i;
323 char *new_buffer, *dst;
67be7c5a 324
4a2854f7 325 pos = snapshot->start;
cff28ca9 326 eof = snapshot->eof;
67be7c5a 327
4a2854f7 328 if (pos == eof)
02b920f3 329 return;
67be7c5a 330
4a2854f7
MH
331 len = eof - pos;
332
02b920f3 333 /*
cff28ca9 334 * Initialize records based on a crude estimate of the number
02b920f3
MH
335 * of references in the file (we'll grow it below if needed):
336 */
cff28ca9 337 ALLOC_GROW(records, len / 80 + 20, alloc);
02b920f3
MH
338
339 while (pos < eof) {
340 eol = memchr(pos, '\n', eof - pos);
341 if (!eol)
342 /* The safety check should prevent this. */
343 BUG("unterminated line found in packed-refs");
344 if (eol - pos < GIT_SHA1_HEXSZ + 2)
cff28ca9 345 die_invalid_line(snapshot->refs->path,
02b920f3
MH
346 pos, eof - pos);
347 eol++;
348 if (eol < eof && *eol == '^') {
349 /*
350 * Keep any peeled line together with its
351 * reference:
352 */
353 const char *peeled_start = eol;
354
355 eol = memchr(peeled_start, '\n', eof - peeled_start);
356 if (!eol)
357 /* The safety check should prevent this. */
358 BUG("unterminated peeled line found in packed-refs");
359 eol++;
360 }
361
cff28ca9
MH
362 ALLOC_GROW(records, nr + 1, alloc);
363 records[nr].start = pos;
364 records[nr].len = eol - pos;
02b920f3
MH
365 nr++;
366
367 if (sorted &&
368 nr > 1 &&
cff28ca9
MH
369 cmp_packed_ref_records(&records[nr - 2],
370 &records[nr - 1]) >= 0)
02b920f3 371 sorted = 0;
67be7c5a 372
02b920f3
MH
373 pos = eol;
374 }
375
376 if (sorted)
377 goto cleanup;
378
cff28ca9
MH
379 /* We need to sort the memory. First we sort the records array: */
380 QSORT(records, nr, cmp_packed_ref_records);
02b920f3
MH
381
382 /*
383 * Allocate a new chunk of memory, and copy the old memory to
cff28ca9 384 * the new in the order indicated by `records` (not bothering
02b920f3
MH
385 * with the header line):
386 */
387 new_buffer = xmalloc(len);
388 for (dst = new_buffer, i = 0; i < nr; i++) {
cff28ca9
MH
389 memcpy(dst, records[i].start, records[i].len);
390 dst += records[i].len;
02b920f3
MH
391 }
392
393 /*
394 * Now munmap the old buffer and use the sorted buffer in its
395 * place:
396 */
cff28ca9 397 clear_snapshot_buffer(snapshot);
4a2854f7 398 snapshot->buf = snapshot->start = new_buffer;
cff28ca9 399 snapshot->eof = new_buffer + len;
02b920f3
MH
400
401cleanup:
cff28ca9 402 free(records);
67be7c5a
MH
403}
404
405/*
02b920f3
MH
406 * Return a pointer to the start of the record that contains the
407 * character `*p` (which must be within the buffer). If no other
408 * record start is found, return `buf`.
409 */
410static const char *find_start_of_record(const char *buf, const char *p)
411{
412 while (p > buf && (p[-1] != '\n' || p[0] == '^'))
413 p--;
414 return p;
415}
416
d1cf1551
MH
417/*
418 * Return a pointer to the start of the record following the record
419 * that contains `*p`. If none is found before `end`, return `end`.
420 */
421static const char *find_end_of_record(const char *p, const char *end)
422{
423 while (++p < end && (p[-1] != '\n' || p[0] == '^'))
424 ;
425 return p;
426}
427
02b920f3
MH
428/*
429 * We want to be able to compare mmapped reference records quickly,
430 * without totally parsing them. We can do so because the records are
431 * LF-terminated, and the refname should start exactly (GIT_SHA1_HEXSZ
432 * + 1) bytes past the beginning of the record.
433 *
434 * But what if the `packed-refs` file contains garbage? We're willing
435 * to tolerate not detecting the problem, as long as we don't produce
436 * totally garbled output (we can't afford to check the integrity of
437 * the whole file during every Git invocation). But we do want to be
438 * sure that we never read past the end of the buffer in memory and
439 * perform an illegal memory access.
440 *
441 * Guarantee that minimum level of safety by verifying that the last
442 * record in the file is LF-terminated, and that it has at least
443 * (GIT_SHA1_HEXSZ + 1) characters before the LF. Die if either of
444 * these checks fails.
445 */
cff28ca9 446static void verify_buffer_safe(struct snapshot *snapshot)
02b920f3 447{
4a2854f7 448 const char *start = snapshot->start;
cff28ca9 449 const char *eof = snapshot->eof;
02b920f3
MH
450 const char *last_line;
451
4a2854f7 452 if (start == eof)
02b920f3
MH
453 return;
454
4a2854f7 455 last_line = find_start_of_record(start, eof - 1);
02b920f3 456 if (*(eof - 1) != '\n' || eof - last_line < GIT_SHA1_HEXSZ + 2)
cff28ca9 457 die_invalid_line(snapshot->refs->path,
02b920f3
MH
458 last_line, eof - last_line);
459}
460
5b633610
MH
461/*
462 * Depending on `mmap_strategy`, either mmap or read the contents of
cff28ca9
MH
463 * the `packed-refs` file into the snapshot. Return 1 if the file
464 * existed and was read, or 0 if the file was absent. Die on errors.
5b633610 465 */
cff28ca9 466static int load_contents(struct snapshot *snapshot)
5b633610
MH
467{
468 int fd;
469 struct stat st;
470 size_t size;
471 ssize_t bytes_read;
472
cff28ca9 473 fd = open(snapshot->refs->path, O_RDONLY);
5b633610
MH
474 if (fd < 0) {
475 if (errno == ENOENT) {
476 /*
477 * This is OK; it just means that no
478 * "packed-refs" file has been written yet,
479 * which is equivalent to it being empty,
480 * which is its state when initialized with
481 * zeros.
482 */
483 return 0;
484 } else {
cff28ca9 485 die_errno("couldn't read %s", snapshot->refs->path);
5b633610
MH
486 }
487 }
488
cff28ca9 489 stat_validity_update(&snapshot->validity, fd);
5b633610
MH
490
491 if (fstat(fd, &st) < 0)
cff28ca9 492 die_errno("couldn't stat %s", snapshot->refs->path);
5b633610
MH
493 size = xsize_t(st.st_size);
494
495 switch (mmap_strategy) {
496 case MMAP_NONE:
cff28ca9
MH
497 snapshot->buf = xmalloc(size);
498 bytes_read = read_in_full(fd, snapshot->buf, size);
5b633610 499 if (bytes_read < 0 || bytes_read != size)
cff28ca9 500 die_errno("couldn't read %s", snapshot->refs->path);
cff28ca9 501 snapshot->mmapped = 0;
5b633610 502 break;
02b920f3 503 case MMAP_TEMPORARY:
5b633610 504 case MMAP_OK:
cff28ca9 505 snapshot->buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
cff28ca9 506 snapshot->mmapped = 1;
5b633610
MH
507 break;
508 }
509 close(fd);
510
4a2854f7
MH
511 snapshot->start = snapshot->buf;
512 snapshot->eof = snapshot->buf + size;
513
5b633610
MH
514 return 1;
515}
516
d1cf1551 517/*
cff28ca9 518 * Find the place in `snapshot->buf` where the start of the record for
d1cf1551
MH
519 * `refname` starts. If `mustexist` is true and the reference doesn't
520 * exist, then return NULL. If `mustexist` is false and the reference
521 * doesn't exist, then return the point where that reference would be
4a14f8d0
MH
522 * inserted, or `snapshot->eof` (which might be NULL) if it would be
523 * inserted at the end of the file. In the latter mode, `refname`
524 * doesn't have to be a proper reference name; for example, one could
525 * search for "refs/replace/" to find the start of any replace
526 * references.
d1cf1551 527 *
cff28ca9
MH
528 * The record is sought using a binary search, so `snapshot->buf` must
529 * be sorted.
d1cf1551 530 */
cff28ca9 531static const char *find_reference_location(struct snapshot *snapshot,
d1cf1551
MH
532 const char *refname, int mustexist)
533{
534 /*
535 * This is not *quite* a garden-variety binary search, because
536 * the data we're searching is made up of records, and we
537 * always need to find the beginning of a record to do a
538 * comparison. A "record" here is one line for the reference
539 * itself and zero or one peel lines that start with '^'. Our
540 * loop invariant is described in the next two comments.
541 */
542
543 /*
544 * A pointer to the character at the start of a record whose
545 * preceding records all have reference names that come
546 * *before* `refname`.
547 */
4a2854f7 548 const char *lo = snapshot->start;
d1cf1551
MH
549
550 /*
551 * A pointer to a the first character of a record whose
552 * reference name comes *after* `refname`.
553 */
cff28ca9 554 const char *hi = snapshot->eof;
d1cf1551 555
4a14f8d0 556 while (lo != hi) {
d1cf1551
MH
557 const char *mid, *rec;
558 int cmp;
559
560 mid = lo + (hi - lo) / 2;
561 rec = find_start_of_record(lo, mid);
cff28ca9 562 cmp = cmp_record_to_refname(rec, refname);
d1cf1551
MH
563 if (cmp < 0) {
564 lo = find_end_of_record(mid, hi);
565 } else if (cmp > 0) {
566 hi = rec;
567 } else {
568 return rec;
569 }
570 }
571
572 if (mustexist)
573 return NULL;
574 else
575 return lo;
576}
577
67be7c5a 578/*
cff28ca9
MH
579 * Create a newly-allocated `snapshot` of the `packed-refs` file in
580 * its current state and return it. The return value will already have
581 * its reference count incremented.
67be7c5a
MH
582 *
583 * A comment line of the form "# pack-refs with: " may contain zero or
584 * more traits. We interpret the traits as follows:
585 *
02b920f3 586 * Neither `peeled` nor `fully-peeled`:
67be7c5a
MH
587 *
588 * Probably no references are peeled. But if the file contains a
589 * peeled value for a reference, we will use it.
590 *
02b920f3 591 * `peeled`:
67be7c5a
MH
592 *
593 * References under "refs/tags/", if they *can* be peeled, *are*
594 * peeled in this file. References outside of "refs/tags/" are
595 * probably not peeled even if they could have been, but if we find
596 * a peeled value for such a reference we will use it.
597 *
02b920f3 598 * `fully-peeled`:
67be7c5a
MH
599 *
600 * All references in the file that can be peeled are peeled.
601 * Inversely (and this is more important), any references in the
602 * file for which no peeled value is recorded is not peelable. This
603 * trait should typically be written alongside "peeled" for
604 * compatibility with older clients, but we do not require it
605 * (i.e., "peeled" is a no-op if "fully-peeled" is set).
02b920f3
MH
606 *
607 * `sorted`:
608 *
609 * The references in this file are known to be sorted by refname.
67be7c5a 610 */
cff28ca9 611static struct snapshot *create_snapshot(struct packed_ref_store *refs)
67be7c5a 612{
cff28ca9 613 struct snapshot *snapshot = xcalloc(1, sizeof(*snapshot));
02b920f3 614 int sorted = 0;
67be7c5a 615
cff28ca9
MH
616 snapshot->refs = refs;
617 acquire_snapshot(snapshot);
618 snapshot->peeled = PEELED_NONE;
67be7c5a 619
cff28ca9
MH
620 if (!load_contents(snapshot))
621 return snapshot;
67be7c5a 622
36f23534 623 /* If the file has a header line, process it: */
cff28ca9 624 if (snapshot->buf < snapshot->eof && *snapshot->buf == '#') {
27a41841 625 char *tmp, *p, *eol;
a8811695 626 struct string_list traits = STRING_LIST_INIT_NODUP;
9308b7f3 627
cff28ca9
MH
628 eol = memchr(snapshot->buf, '\n',
629 snapshot->eof - snapshot->buf);
36f23534 630 if (!eol)
5b633610 631 die_unterminated_line(refs->path,
cff28ca9
MH
632 snapshot->buf,
633 snapshot->eof - snapshot->buf);
67be7c5a 634
27a41841 635 tmp = xmemdupz(snapshot->buf, eol - snapshot->buf);
67be7c5a 636
27a41841 637 if (!skip_prefix(tmp, "# pack-refs with:", (const char **)&p))
5b633610 638 die_invalid_line(refs->path,
cff28ca9
MH
639 snapshot->buf,
640 snapshot->eof - snapshot->buf);
36f23534 641
a8811695
MH
642 string_list_split_in_place(&traits, p, ' ', -1);
643
644 if (unsorted_string_list_has_string(&traits, "fully-peeled"))
cff28ca9 645 snapshot->peeled = PEELED_FULLY;
a8811695 646 else if (unsorted_string_list_has_string(&traits, "peeled"))
cff28ca9 647 snapshot->peeled = PEELED_TAGS;
02b920f3
MH
648
649 sorted = unsorted_string_list_has_string(&traits, "sorted");
650
36f23534
MH
651 /* perhaps other traits later as well */
652
653 /* The "+ 1" is for the LF character. */
4a2854f7 654 snapshot->start = eol + 1;
a8811695
MH
655
656 string_list_clear(&traits, 0);
27a41841 657 free(tmp);
67be7c5a
MH
658 }
659
cff28ca9 660 verify_buffer_safe(snapshot);
67be7c5a 661
02b920f3 662 if (!sorted) {
cff28ca9 663 sort_snapshot(snapshot);
02b920f3
MH
664
665 /*
666 * Reordering the records might have moved a short one
667 * to the end of the buffer, so verify the buffer's
668 * safety again:
669 */
cff28ca9 670 verify_buffer_safe(snapshot);
02b920f3
MH
671 }
672
cff28ca9 673 if (mmap_strategy != MMAP_OK && snapshot->mmapped) {
02b920f3
MH
674 /*
675 * We don't want to leave the file mmapped, so we are
676 * forced to make a copy now:
677 */
4a2854f7 678 size_t size = snapshot->eof - snapshot->start;
02b920f3
MH
679 char *buf_copy = xmalloc(size);
680
4a2854f7 681 memcpy(buf_copy, snapshot->start, size);
cff28ca9 682 clear_snapshot_buffer(snapshot);
4a2854f7 683 snapshot->buf = snapshot->start = buf_copy;
cff28ca9 684 snapshot->eof = buf_copy + size;
02b920f3
MH
685 }
686
cff28ca9 687 return snapshot;
67be7c5a
MH
688}
689
690/*
cff28ca9
MH
691 * Check that `refs->snapshot` (if present) still reflects the
692 * contents of the `packed-refs` file. If not, clear the snapshot.
67be7c5a 693 */
cff28ca9 694static void validate_snapshot(struct packed_ref_store *refs)
67be7c5a 695{
cff28ca9
MH
696 if (refs->snapshot &&
697 !stat_validity_check(&refs->snapshot->validity, refs->path))
698 clear_snapshot(refs);
67be7c5a
MH
699}
700
701/*
cff28ca9
MH
702 * Get the `snapshot` for the specified packed_ref_store, creating and
703 * populating it if it hasn't been read before or if the file has been
704 * changed (according to its `validity` field) since it was last read.
705 * On the other hand, if we hold the lock, then assume that the file
706 * hasn't been changed out from under us, so skip the extra `stat()`
707 * call in `stat_validity_check()`. This function does *not* increase
708 * the snapshot's reference count on behalf of the caller.
67be7c5a 709 */
cff28ca9 710static struct snapshot *get_snapshot(struct packed_ref_store *refs)
67be7c5a
MH
711{
712 if (!is_lock_file_locked(&refs->lock))
cff28ca9 713 validate_snapshot(refs);
67be7c5a 714
cff28ca9
MH
715 if (!refs->snapshot)
716 refs->snapshot = create_snapshot(refs);
67be7c5a 717
cff28ca9 718 return refs->snapshot;
67be7c5a
MH
719}
720
e0cc8ac8
MH
721static int packed_read_raw_ref(struct ref_store *ref_store,
722 const char *refname, unsigned char *sha1,
723 struct strbuf *referent, unsigned int *type)
67be7c5a 724{
e0cc8ac8
MH
725 struct packed_ref_store *refs =
726 packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref");
cff28ca9 727 struct snapshot *snapshot = get_snapshot(refs);
f3987ab3 728 const char *rec;
67be7c5a
MH
729
730 *type = 0;
731
cff28ca9 732 rec = find_reference_location(snapshot, refname, 1);
f3987ab3
MH
733
734 if (!rec) {
735 /* refname is not a packed reference. */
67be7c5a
MH
736 errno = ENOENT;
737 return -1;
738 }
739
f3987ab3 740 if (get_sha1_hex(rec, sha1))
cff28ca9 741 die_invalid_line(refs->path, rec, snapshot->eof - rec);
f3987ab3 742
67be7c5a
MH
743 *type = REF_ISPACKED;
744 return 0;
745}
746
523ee2d7
MH
747/*
748 * This value is set in `base.flags` if the peeled value of the
749 * current reference is known. In that case, `peeled` contains the
750 * correct peeled value for the reference, which might be `null_sha1`
751 * if the reference is not a tag or if it is broken.
752 */
753#define REF_KNOWS_PEELED 0x40
67be7c5a 754
523ee2d7 755/*
cff28ca9 756 * An iterator over a snapshot of a `packed-refs` file.
523ee2d7 757 */
67be7c5a
MH
758struct packed_ref_iterator {
759 struct ref_iterator base;
760
cff28ca9 761 struct snapshot *snapshot;
523ee2d7 762
cff28ca9 763 /* The current position in the snapshot's buffer: */
523ee2d7
MH
764 const char *pos;
765
cff28ca9 766 /* The end of the part of the buffer that will be iterated over: */
523ee2d7
MH
767 const char *eof;
768
cff28ca9 769 /* Scratch space for current values: */
523ee2d7 770 struct object_id oid, peeled;
523ee2d7
MH
771 struct strbuf refname_buf;
772
67be7c5a
MH
773 unsigned int flags;
774};
775
cff28ca9
MH
776/*
777 * Move the iterator to the next record in the snapshot, without
778 * respect for whether the record is actually required by the current
779 * iteration. Adjust the fields in `iter` and return `ITER_OK` or
780 * `ITER_DONE`. This function does not free the iterator in the case
781 * of `ITER_DONE`.
782 */
523ee2d7
MH
783static int next_record(struct packed_ref_iterator *iter)
784{
785 const char *p = iter->pos, *eol;
786
787 strbuf_reset(&iter->refname_buf);
788
789 if (iter->pos == iter->eof)
790 return ITER_DONE;
791
792 iter->base.flags = REF_ISPACKED;
793
794 if (iter->eof - p < GIT_SHA1_HEXSZ + 2 ||
795 parse_oid_hex(p, &iter->oid, &p) ||
796 !isspace(*p++))
cff28ca9 797 die_invalid_line(iter->snapshot->refs->path,
523ee2d7
MH
798 iter->pos, iter->eof - iter->pos);
799
800 eol = memchr(p, '\n', iter->eof - p);
801 if (!eol)
cff28ca9 802 die_unterminated_line(iter->snapshot->refs->path,
523ee2d7
MH
803 iter->pos, iter->eof - iter->pos);
804
805 strbuf_add(&iter->refname_buf, p, eol - p);
806 iter->base.refname = iter->refname_buf.buf;
807
808 if (check_refname_format(iter->base.refname, REFNAME_ALLOW_ONELEVEL)) {
809 if (!refname_is_safe(iter->base.refname))
810 die("packed refname is dangerous: %s",
811 iter->base.refname);
812 oidclr(&iter->oid);
813 iter->base.flags |= REF_BAD_NAME | REF_ISBROKEN;
814 }
cff28ca9
MH
815 if (iter->snapshot->peeled == PEELED_FULLY ||
816 (iter->snapshot->peeled == PEELED_TAGS &&
523ee2d7
MH
817 starts_with(iter->base.refname, "refs/tags/")))
818 iter->base.flags |= REF_KNOWS_PEELED;
819
820 iter->pos = eol + 1;
821
822 if (iter->pos < iter->eof && *iter->pos == '^') {
823 p = iter->pos + 1;
824 if (iter->eof - p < GIT_SHA1_HEXSZ + 1 ||
825 parse_oid_hex(p, &iter->peeled, &p) ||
826 *p++ != '\n')
cff28ca9 827 die_invalid_line(iter->snapshot->refs->path,
523ee2d7
MH
828 iter->pos, iter->eof - iter->pos);
829 iter->pos = p;
830
831 /*
832 * Regardless of what the file header said, we
833 * definitely know the value of *this* reference. But
834 * we suppress it if the reference is broken:
835 */
836 if ((iter->base.flags & REF_ISBROKEN)) {
837 oidclr(&iter->peeled);
838 iter->base.flags &= ~REF_KNOWS_PEELED;
839 } else {
840 iter->base.flags |= REF_KNOWS_PEELED;
841 }
842 } else {
843 oidclr(&iter->peeled);
844 }
845
846 return ITER_OK;
847}
848
67be7c5a
MH
849static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator)
850{
851 struct packed_ref_iterator *iter =
852 (struct packed_ref_iterator *)ref_iterator;
853 int ok;
854
523ee2d7 855 while ((ok = next_record(iter)) == ITER_OK) {
67be7c5a 856 if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY &&
523ee2d7 857 ref_type(iter->base.refname) != REF_TYPE_PER_WORKTREE)
67be7c5a
MH
858 continue;
859
860 if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&
523ee2d7
MH
861 !ref_resolves_to_object(iter->base.refname, &iter->oid,
862 iter->flags))
67be7c5a
MH
863 continue;
864
67be7c5a
MH
865 return ITER_OK;
866 }
867
67be7c5a
MH
868 if (ref_iterator_abort(ref_iterator) != ITER_DONE)
869 ok = ITER_ERROR;
870
871 return ok;
872}
873
874static int packed_ref_iterator_peel(struct ref_iterator *ref_iterator,
875 struct object_id *peeled)
876{
877 struct packed_ref_iterator *iter =
878 (struct packed_ref_iterator *)ref_iterator;
879
523ee2d7
MH
880 if ((iter->base.flags & REF_KNOWS_PEELED)) {
881 oidcpy(peeled, &iter->peeled);
882 return is_null_oid(&iter->peeled) ? -1 : 0;
883 } else if ((iter->base.flags & (REF_ISBROKEN | REF_ISSYMREF))) {
884 return -1;
885 } else {
886 return !!peel_object(iter->oid.hash, peeled->hash);
887 }
67be7c5a
MH
888}
889
890static int packed_ref_iterator_abort(struct ref_iterator *ref_iterator)
891{
892 struct packed_ref_iterator *iter =
893 (struct packed_ref_iterator *)ref_iterator;
894 int ok = ITER_DONE;
895
523ee2d7 896 strbuf_release(&iter->refname_buf);
cff28ca9 897 release_snapshot(iter->snapshot);
67be7c5a
MH
898 base_ref_iterator_free(ref_iterator);
899 return ok;
900}
901
902static struct ref_iterator_vtable packed_ref_iterator_vtable = {
903 packed_ref_iterator_advance,
904 packed_ref_iterator_peel,
905 packed_ref_iterator_abort
906};
907
e0cc8ac8
MH
908static struct ref_iterator *packed_ref_iterator_begin(
909 struct ref_store *ref_store,
67be7c5a
MH
910 const char *prefix, unsigned int flags)
911{
e0cc8ac8 912 struct packed_ref_store *refs;
cff28ca9 913 struct snapshot *snapshot;
d1cf1551 914 const char *start;
67be7c5a
MH
915 struct packed_ref_iterator *iter;
916 struct ref_iterator *ref_iterator;
e0cc8ac8
MH
917 unsigned int required_flags = REF_STORE_READ;
918
919 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN))
920 required_flags |= REF_STORE_ODB;
921 refs = packed_downcast(ref_store, required_flags, "ref_iterator_begin");
67be7c5a 922
cff28ca9
MH
923 /*
924 * Note that `get_snapshot()` internally checks whether the
925 * snapshot is up to date with what is on disk, and re-reads
926 * it if not.
927 */
928 snapshot = get_snapshot(refs);
523ee2d7 929
cff28ca9 930 if (!snapshot->buf)
523ee2d7
MH
931 return empty_ref_iterator_begin();
932
67be7c5a
MH
933 iter = xcalloc(1, sizeof(*iter));
934 ref_iterator = &iter->base;
8738a8a4 935 base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable, 1);
67be7c5a 936
cff28ca9
MH
937 iter->snapshot = snapshot;
938 acquire_snapshot(snapshot);
67be7c5a 939
d1cf1551 940 if (prefix && *prefix)
cff28ca9 941 start = find_reference_location(snapshot, prefix, 0);
d1cf1551 942 else
4a2854f7 943 start = snapshot->start;
67be7c5a 944
523ee2d7 945 iter->pos = start;
cff28ca9 946 iter->eof = snapshot->eof;
523ee2d7
MH
947 strbuf_init(&iter->refname_buf, 0);
948
949 iter->base.oid = &iter->oid;
67be7c5a
MH
950
951 iter->flags = flags;
952
d1cf1551
MH
953 if (prefix && *prefix)
954 /* Stop iteration after we've gone *past* prefix: */
955 ref_iterator = prefix_ref_iterator_begin(ref_iterator, prefix, 0);
956
67be7c5a
MH
957 return ref_iterator;
958}
959
960/*
961 * Write an entry to the packed-refs file for the specified refname.
3478983b
MH
962 * If peeled is non-NULL, write it as the entry's peeled value. On
963 * error, return a nonzero value and leave errno set at the value left
964 * by the failing call to `fprintf()`.
67be7c5a 965 */
3478983b
MH
966static int write_packed_entry(FILE *fh, const char *refname,
967 const unsigned char *sha1,
968 const unsigned char *peeled)
67be7c5a 969{
3478983b
MH
970 if (fprintf(fh, "%s %s\n", sha1_to_hex(sha1), refname) < 0 ||
971 (peeled && fprintf(fh, "^%s\n", sha1_to_hex(peeled)) < 0))
972 return -1;
973
974 return 0;
67be7c5a
MH
975}
976
c8bed835 977int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)
67be7c5a 978{
e0cc8ac8
MH
979 struct packed_ref_store *refs =
980 packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
b7de57d8 981 "packed_refs_lock");
67be7c5a
MH
982 static int timeout_configured = 0;
983 static int timeout_value = 1000;
67be7c5a 984
67be7c5a
MH
985 if (!timeout_configured) {
986 git_config_get_int("core.packedrefstimeout", &timeout_value);
987 timeout_configured = 1;
988 }
989
42dfa7ec
MH
990 /*
991 * Note that we close the lockfile immediately because we
992 * don't write new content to it, but rather to a separate
993 * tempfile.
994 */
67be7c5a
MH
995 if (hold_lock_file_for_update_timeout(
996 &refs->lock,
997 refs->path,
c8bed835
MH
998 flags, timeout_value) < 0) {
999 unable_to_lock_message(refs->path, errno, err);
1000 return -1;
1001 }
1002
83a3069a 1003 if (close_lock_file_gently(&refs->lock)) {
c8bed835 1004 strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno));
83a3069a 1005 rollback_lock_file(&refs->lock);
67be7c5a 1006 return -1;
c8bed835 1007 }
67be7c5a
MH
1008
1009 /*
1010 * Now that we hold the `packed-refs` lock, make sure that our
cff28ca9
MH
1011 * snapshot matches the current version of the file. Normally
1012 * `get_snapshot()` does that for us, but that function
1013 * assumes that when the file is locked, any existing snapshot
1014 * is still valid. We've just locked the file, but it might
1015 * have changed the moment *before* we locked it.
67be7c5a 1016 */
cff28ca9 1017 validate_snapshot(refs);
67be7c5a 1018
39c8df0c
MH
1019 /*
1020 * Now make sure that the packed-refs file as it exists in the
cff28ca9 1021 * locked state is loaded into the snapshot:
39c8df0c 1022 */
cff28ca9 1023 get_snapshot(refs);
67be7c5a
MH
1024 return 0;
1025}
1026
49aebcf4
MH
1027void packed_refs_unlock(struct ref_store *ref_store)
1028{
1029 struct packed_ref_store *refs = packed_downcast(
1030 ref_store,
1031 REF_STORE_READ | REF_STORE_WRITE,
1032 "packed_refs_unlock");
1033
1034 if (!is_lock_file_locked(&refs->lock))
1035 die("BUG: packed_refs_unlock() called when not locked");
1036 rollback_lock_file(&refs->lock);
49aebcf4
MH
1037}
1038
1039int packed_refs_is_locked(struct ref_store *ref_store)
1040{
1041 struct packed_ref_store *refs = packed_downcast(
1042 ref_store,
1043 REF_STORE_READ | REF_STORE_WRITE,
1044 "packed_refs_is_locked");
1045
1046 return is_lock_file_locked(&refs->lock);
1047}
1048
67be7c5a 1049/*
cff28ca9
MH
1050 * The packed-refs header line that we write out. Perhaps other traits
1051 * will be added later.
a8811695
MH
1052 *
1053 * Note that earlier versions of Git used to parse these traits by
1054 * looking for " trait " in the line. For this reason, the space after
1055 * the colon and the trailing space are required.
67be7c5a
MH
1056 */
1057static const char PACKED_REFS_HEADER[] =
02b920f3 1058 "# pack-refs with: peeled fully-peeled sorted \n";
67be7c5a 1059
e0cc8ac8
MH
1060static int packed_init_db(struct ref_store *ref_store, struct strbuf *err)
1061{
1062 /* Nothing to do. */
1063 return 0;
1064}
1065
67be7c5a 1066/*
cff28ca9
MH
1067 * Write the packed refs from the current snapshot to the packed-refs
1068 * tempfile, incorporating any changes from `updates`. `updates` must
1069 * be a sorted string list whose keys are the refnames and whose util
2775d872
MH
1070 * values are `struct ref_update *`. On error, rollback the tempfile,
1071 * write an error message to `err`, and return a nonzero value.
1072 *
1073 * The packfile must be locked before calling this function and will
1074 * remain locked when it is done.
67be7c5a 1075 */
2775d872
MH
1076static int write_with_updates(struct packed_ref_store *refs,
1077 struct string_list *updates,
1078 struct strbuf *err)
67be7c5a 1079{
2775d872
MH
1080 struct ref_iterator *iter = NULL;
1081 size_t i;
3478983b 1082 int ok;
67be7c5a 1083 FILE *out;
2775d872 1084 struct strbuf sb = STRBUF_INIT;
198b808e 1085 char *packed_refs_path;
67be7c5a 1086
67be7c5a 1087 if (!is_lock_file_locked(&refs->lock))
2775d872 1088 die("BUG: write_with_updates() called while unlocked");
67be7c5a 1089
198b808e
MH
1090 /*
1091 * If packed-refs is a symlink, we want to overwrite the
1092 * symlinked-to file, not the symlink itself. Also, put the
1093 * staging file next to it:
1094 */
1095 packed_refs_path = get_locked_file_path(&refs->lock);
1096 strbuf_addf(&sb, "%s.new", packed_refs_path);
2775d872 1097 free(packed_refs_path);
076aa2cb
JK
1098 refs->tempfile = create_tempfile(sb.buf);
1099 if (!refs->tempfile) {
42dfa7ec
MH
1100 strbuf_addf(err, "unable to create file %s: %s",
1101 sb.buf, strerror(errno));
1102 strbuf_release(&sb);
2775d872 1103 return -1;
42dfa7ec
MH
1104 }
1105 strbuf_release(&sb);
1106
076aa2cb 1107 out = fdopen_tempfile(refs->tempfile, "w");
3478983b
MH
1108 if (!out) {
1109 strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s",
1110 strerror(errno));
1111 goto error;
1112 }
67be7c5a 1113
2775d872
MH
1114 if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0)
1115 goto write_error;
1116
1117 /*
1118 * We iterate in parallel through the current list of refs and
1119 * the list of updates, processing an entry from at least one
1120 * of the lists each time through the loop. When the current
1121 * list of refs is exhausted, set iter to NULL. When the list
1122 * of updates is exhausted, leave i set to updates->nr.
1123 */
1124 iter = packed_ref_iterator_begin(&refs->base, "",
1125 DO_FOR_EACH_INCLUDE_BROKEN);
1126 if ((ok = ref_iterator_advance(iter)) != ITER_OK)
1127 iter = NULL;
1128
1129 i = 0;
67be7c5a 1130
2775d872
MH
1131 while (iter || i < updates->nr) {
1132 struct ref_update *update = NULL;
1133 int cmp;
1134
1135 if (i >= updates->nr) {
1136 cmp = -1;
1137 } else {
1138 update = updates->items[i].util;
1139
1140 if (!iter)
1141 cmp = +1;
1142 else
1143 cmp = strcmp(iter->refname, update->refname);
1144 }
1145
1146 if (!cmp) {
1147 /*
1148 * There is both an old value and an update
1149 * for this reference. Check the old value if
1150 * necessary:
1151 */
1152 if ((update->flags & REF_HAVE_OLD)) {
1153 if (is_null_oid(&update->old_oid)) {
1154 strbuf_addf(err, "cannot update ref '%s': "
1155 "reference already exists",
1156 update->refname);
1157 goto error;
1158 } else if (oidcmp(&update->old_oid, iter->oid)) {
1159 strbuf_addf(err, "cannot update ref '%s': "
1160 "is at %s but expected %s",
1161 update->refname,
1162 oid_to_hex(iter->oid),
1163 oid_to_hex(&update->old_oid));
1164 goto error;
1165 }
1166 }
1167
1168 /* Now figure out what to use for the new value: */
1169 if ((update->flags & REF_HAVE_NEW)) {
1170 /*
1171 * The update takes precedence. Skip
1172 * the iterator over the unneeded
1173 * value.
1174 */
1175 if ((ok = ref_iterator_advance(iter)) != ITER_OK)
1176 iter = NULL;
1177 cmp = +1;
1178 } else {
1179 /*
1180 * The update doesn't actually want to
1181 * change anything. We're done with it.
1182 */
1183 i++;
1184 cmp = -1;
1185 }
1186 } else if (cmp > 0) {
1187 /*
1188 * There is no old value but there is an
1189 * update for this reference. Make sure that
1190 * the update didn't expect an existing value:
1191 */
1192 if ((update->flags & REF_HAVE_OLD) &&
1193 !is_null_oid(&update->old_oid)) {
1194 strbuf_addf(err, "cannot update ref '%s': "
1195 "reference is missing but expected %s",
1196 update->refname,
1197 oid_to_hex(&update->old_oid));
1198 goto error;
1199 }
1200 }
1201
1202 if (cmp < 0) {
1203 /* Pass the old reference through. */
1204
1205 struct object_id peeled;
1206 int peel_error = ref_iterator_peel(iter, &peeled);
1207
1208 if (write_packed_entry(out, iter->refname,
1209 iter->oid->hash,
1210 peel_error ? NULL : peeled.hash))
1211 goto write_error;
1212
1213 if ((ok = ref_iterator_advance(iter)) != ITER_OK)
1214 iter = NULL;
1215 } else if (is_null_oid(&update->new_oid)) {
1216 /*
1217 * The update wants to delete the reference,
1218 * and the reference either didn't exist or we
1219 * have already skipped it. So we're done with
1220 * the update (and don't have to write
1221 * anything).
1222 */
1223 i++;
1224 } else {
1225 struct object_id peeled;
1226 int peel_error = peel_object(update->new_oid.hash,
1227 peeled.hash);
1228
1229 if (write_packed_entry(out, update->refname,
1230 update->new_oid.hash,
1231 peel_error ? NULL : peeled.hash))
1232 goto write_error;
1233
1234 i++;
3478983b 1235 }
67be7c5a
MH
1236 }
1237
3478983b 1238 if (ok != ITER_DONE) {
72d4a9a7
RS
1239 strbuf_addstr(err, "unable to write packed-refs file: "
1240 "error iterating over old contents");
3478983b
MH
1241 goto error;
1242 }
67be7c5a 1243
07f0542d 1244 if (close_tempfile_gently(refs->tempfile)) {
2775d872 1245 strbuf_addf(err, "error closing file %s: %s",
07f0542d 1246 get_tempfile_path(refs->tempfile),
2775d872
MH
1247 strerror(errno));
1248 strbuf_release(&sb);
07f0542d 1249 delete_tempfile(&refs->tempfile);
2775d872 1250 return -1;
67be7c5a 1251 }
3478983b 1252
2775d872
MH
1253 return 0;
1254
1255write_error:
1256 strbuf_addf(err, "error writing to %s: %s",
07f0542d 1257 get_tempfile_path(refs->tempfile), strerror(errno));
3478983b
MH
1258
1259error:
2775d872
MH
1260 if (iter)
1261 ref_iterator_abort(iter);
198b808e 1262
2775d872
MH
1263 delete_tempfile(&refs->tempfile);
1264 return -1;
67be7c5a
MH
1265}
1266
7c6bd25c
MH
1267int is_packed_transaction_needed(struct ref_store *ref_store,
1268 struct ref_transaction *transaction)
1269{
1270 struct packed_ref_store *refs = packed_downcast(
1271 ref_store,
1272 REF_STORE_READ,
1273 "is_packed_transaction_needed");
1274 struct strbuf referent = STRBUF_INIT;
1275 size_t i;
1276 int ret;
1277
1278 if (!is_lock_file_locked(&refs->lock))
1279 BUG("is_packed_transaction_needed() called while unlocked");
1280
1281 /*
1282 * We're only going to bother returning false for the common,
1283 * trivial case that references are only being deleted, their
1284 * old values are not being checked, and the old `packed-refs`
1285 * file doesn't contain any of those reference(s). This gives
1286 * false positives for some other cases that could
1287 * theoretically be optimized away:
1288 *
1289 * 1. It could be that the old value is being verified without
1290 * setting a new value. In this case, we could verify the
1291 * old value here and skip the update if it agrees. If it
1292 * disagrees, we could either let the update go through
1293 * (the actual commit would re-detect and report the
1294 * problem), or come up with a way of reporting such an
1295 * error to *our* caller.
1296 *
1297 * 2. It could be that a new value is being set, but that it
1298 * is identical to the current packed value of the
1299 * reference.
1300 *
1301 * Neither of these cases will come up in the current code,
1302 * because the only caller of this function passes to it a
1303 * transaction that only includes `delete` updates with no
1304 * `old_id`. Even if that ever changes, false positives only
1305 * cause an optimization to be missed; they do not affect
1306 * correctness.
1307 */
1308
1309 /*
1310 * Start with the cheap checks that don't require old
1311 * reference values to be read:
1312 */
1313 for (i = 0; i < transaction->nr; i++) {
1314 struct ref_update *update = transaction->updates[i];
1315
1316 if (update->flags & REF_HAVE_OLD)
1317 /* Have to check the old value -> needed. */
1318 return 1;
1319
1320 if ((update->flags & REF_HAVE_NEW) && !is_null_oid(&update->new_oid))
1321 /* Have to set a new value -> needed. */
1322 return 1;
1323 }
1324
1325 /*
1326 * The transaction isn't checking any old values nor is it
1327 * setting any nonzero new values, so it still might be able
1328 * to be skipped. Now do the more expensive check: the update
1329 * is needed if any of the updates is a delete, and the old
1330 * `packed-refs` file contains a value for that reference.
1331 */
1332 ret = 0;
1333 for (i = 0; i < transaction->nr; i++) {
1334 struct ref_update *update = transaction->updates[i];
1335 unsigned int type;
1336 struct object_id oid;
1337
1338 if (!(update->flags & REF_HAVE_NEW))
1339 /*
1340 * This reference isn't being deleted -> not
1341 * needed.
1342 */
1343 continue;
1344
1345 if (!refs_read_raw_ref(ref_store, update->refname,
1346 oid.hash, &referent, &type) ||
1347 errno != ENOENT) {
1348 /*
1349 * We have to actually delete that reference
1350 * -> this transaction is needed.
1351 */
1352 ret = 1;
1353 break;
1354 }
1355 }
1356
1357 strbuf_release(&referent);
1358 return ret;
1359}
1360
2775d872
MH
1361struct packed_transaction_backend_data {
1362 /* True iff the transaction owns the packed-refs lock. */
1363 int own_lock;
1364
1365 struct string_list updates;
1366};
1367
1368static void packed_transaction_cleanup(struct packed_ref_store *refs,
1369 struct ref_transaction *transaction)
67be7c5a 1370{
2775d872 1371 struct packed_transaction_backend_data *data = transaction->backend_data;
67be7c5a 1372
2775d872
MH
1373 if (data) {
1374 string_list_clear(&data->updates, 0);
67be7c5a 1375
07f0542d 1376 if (is_tempfile_active(refs->tempfile))
2775d872 1377 delete_tempfile(&refs->tempfile);
e5cc7d7d 1378
2775d872
MH
1379 if (data->own_lock && is_lock_file_locked(&refs->lock)) {
1380 packed_refs_unlock(&refs->base);
1381 data->own_lock = 0;
67be7c5a 1382 }
67be7c5a 1383
2775d872
MH
1384 free(data);
1385 transaction->backend_data = NULL;
67be7c5a
MH
1386 }
1387
2775d872 1388 transaction->state = REF_TRANSACTION_CLOSED;
e0cc8ac8
MH
1389}
1390
1391static int packed_transaction_prepare(struct ref_store *ref_store,
1392 struct ref_transaction *transaction,
1393 struct strbuf *err)
1394{
2775d872
MH
1395 struct packed_ref_store *refs = packed_downcast(
1396 ref_store,
1397 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
1398 "ref_transaction_prepare");
1399 struct packed_transaction_backend_data *data;
1400 size_t i;
1401 int ret = TRANSACTION_GENERIC_ERROR;
1402
1403 /*
1404 * Note that we *don't* skip transactions with zero updates,
1405 * because such a transaction might be executed for the side
cff28ca9
MH
1406 * effect of ensuring that all of the references are peeled or
1407 * ensuring that the `packed-refs` file is sorted. If the
1408 * caller wants to optimize away empty transactions, it should
1409 * do so itself.
2775d872
MH
1410 */
1411
1412 data = xcalloc(1, sizeof(*data));
1413 string_list_init(&data->updates, 0);
1414
1415 transaction->backend_data = data;
1416
1417 /*
1418 * Stick the updates in a string list by refname so that we
1419 * can sort them:
1420 */
1421 for (i = 0; i < transaction->nr; i++) {
1422 struct ref_update *update = transaction->updates[i];
1423 struct string_list_item *item =
1424 string_list_append(&data->updates, update->refname);
1425
1426 /* Store a pointer to update in item->util: */
1427 item->util = update;
1428 }
1429 string_list_sort(&data->updates);
1430
1431 if (ref_update_reject_duplicates(&data->updates, err))
1432 goto failure;
1433
1434 if (!is_lock_file_locked(&refs->lock)) {
1435 if (packed_refs_lock(ref_store, 0, err))
1436 goto failure;
1437 data->own_lock = 1;
1438 }
1439
1440 if (write_with_updates(refs, &data->updates, err))
1441 goto failure;
1442
1443 transaction->state = REF_TRANSACTION_PREPARED;
1444 return 0;
1445
1446failure:
1447 packed_transaction_cleanup(refs, transaction);
1448 return ret;
e0cc8ac8
MH
1449}
1450
1451static int packed_transaction_abort(struct ref_store *ref_store,
1452 struct ref_transaction *transaction,
1453 struct strbuf *err)
1454{
2775d872
MH
1455 struct packed_ref_store *refs = packed_downcast(
1456 ref_store,
1457 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
1458 "ref_transaction_abort");
1459
1460 packed_transaction_cleanup(refs, transaction);
1461 return 0;
e0cc8ac8
MH
1462}
1463
1464static int packed_transaction_finish(struct ref_store *ref_store,
1465 struct ref_transaction *transaction,
1466 struct strbuf *err)
1467{
2775d872
MH
1468 struct packed_ref_store *refs = packed_downcast(
1469 ref_store,
1470 REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
1471 "ref_transaction_finish");
1472 int ret = TRANSACTION_GENERIC_ERROR;
1473 char *packed_refs_path;
1474
cff28ca9 1475 clear_snapshot(refs);
5b633610 1476
2775d872
MH
1477 packed_refs_path = get_locked_file_path(&refs->lock);
1478 if (rename_tempfile(&refs->tempfile, packed_refs_path)) {
1479 strbuf_addf(err, "error replacing %s: %s",
1480 refs->path, strerror(errno));
1481 goto cleanup;
1482 }
1483
2775d872
MH
1484 ret = 0;
1485
1486cleanup:
1487 free(packed_refs_path);
1488 packed_transaction_cleanup(refs, transaction);
1489 return ret;
e0cc8ac8
MH
1490}
1491
1492static int packed_initial_transaction_commit(struct ref_store *ref_store,
1493 struct ref_transaction *transaction,
1494 struct strbuf *err)
1495{
1496 return ref_transaction_commit(transaction, err);
1497}
1498
1499static int packed_delete_refs(struct ref_store *ref_store, const char *msg,
1500 struct string_list *refnames, unsigned int flags)
1501{
2fb330ca
MH
1502 struct packed_ref_store *refs =
1503 packed_downcast(ref_store, REF_STORE_WRITE, "delete_refs");
1504 struct strbuf err = STRBUF_INIT;
1505 struct ref_transaction *transaction;
1506 struct string_list_item *item;
1507 int ret;
1508
1509 (void)refs; /* We need the check above, but don't use the variable */
1510
1511 if (!refnames->nr)
1512 return 0;
1513
1514 /*
1515 * Since we don't check the references' old_oids, the
1516 * individual updates can't fail, so we can pack all of the
1517 * updates into a single transaction.
1518 */
1519
1520 transaction = ref_store_transaction_begin(ref_store, &err);
1521 if (!transaction)
1522 return -1;
1523
1524 for_each_string_list_item(item, refnames) {
1525 if (ref_transaction_delete(transaction, item->string, NULL,
1526 flags, msg, &err)) {
1527 warning(_("could not delete reference %s: %s"),
1528 item->string, err.buf);
1529 strbuf_reset(&err);
1530 }
1531 }
1532
1533 ret = ref_transaction_commit(transaction, &err);
1534
1535 if (ret) {
1536 if (refnames->nr == 1)
1537 error(_("could not delete reference %s: %s"),
1538 refnames->items[0].string, err.buf);
1539 else
1540 error(_("could not delete references: %s"), err.buf);
1541 }
1542
1543 ref_transaction_free(transaction);
1544 strbuf_release(&err);
1545 return ret;
e0cc8ac8
MH
1546}
1547
1548static int packed_pack_refs(struct ref_store *ref_store, unsigned int flags)
1549{
1550 /*
1551 * Packed refs are already packed. It might be that loose refs
1552 * are packed *into* a packed refs store, but that is done by
1553 * updating the packed references via a transaction.
1554 */
1555 return 0;
1556}
1557
1558static int packed_create_symref(struct ref_store *ref_store,
1559 const char *refname, const char *target,
1560 const char *logmsg)
1561{
1562 die("BUG: packed reference store does not support symrefs");
1563}
1564
1565static int packed_rename_ref(struct ref_store *ref_store,
1566 const char *oldrefname, const char *newrefname,
1567 const char *logmsg)
1568{
1569 die("BUG: packed reference store does not support renaming references");
1570}
1571
3b48045c
JH
1572static int packed_copy_ref(struct ref_store *ref_store,
1573 const char *oldrefname, const char *newrefname,
1574 const char *logmsg)
1575{
1576 die("BUG: packed reference store does not support copying references");
1577}
1578
e0cc8ac8
MH
1579static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_store)
1580{
1581 return empty_ref_iterator_begin();
1582}
1583
1584static int packed_for_each_reflog_ent(struct ref_store *ref_store,
1585 const char *refname,
1586 each_reflog_ent_fn fn, void *cb_data)
1587{
1588 return 0;
1589}
1590
1591static int packed_for_each_reflog_ent_reverse(struct ref_store *ref_store,
1592 const char *refname,
1593 each_reflog_ent_fn fn,
1594 void *cb_data)
1595{
1596 return 0;
1597}
1598
1599static int packed_reflog_exists(struct ref_store *ref_store,
1600 const char *refname)
1601{
1602 return 0;
1603}
1604
1605static int packed_create_reflog(struct ref_store *ref_store,
1606 const char *refname, int force_create,
1607 struct strbuf *err)
1608{
1609 die("BUG: packed reference store does not support reflogs");
1610}
1611
1612static int packed_delete_reflog(struct ref_store *ref_store,
1613 const char *refname)
1614{
1615 return 0;
1616}
1617
1618static int packed_reflog_expire(struct ref_store *ref_store,
1619 const char *refname, const unsigned char *sha1,
1620 unsigned int flags,
1621 reflog_expiry_prepare_fn prepare_fn,
1622 reflog_expiry_should_prune_fn should_prune_fn,
1623 reflog_expiry_cleanup_fn cleanup_fn,
1624 void *policy_cb_data)
1625{
1626 return 0;
1627}
1628
1629struct ref_storage_be refs_be_packed = {
1630 NULL,
1631 "packed",
1632 packed_ref_store_create,
1633 packed_init_db,
1634 packed_transaction_prepare,
1635 packed_transaction_finish,
1636 packed_transaction_abort,
1637 packed_initial_transaction_commit,
1638
1639 packed_pack_refs,
e0cc8ac8
MH
1640 packed_create_symref,
1641 packed_delete_refs,
1642 packed_rename_ref,
3b48045c 1643 packed_copy_ref,
e0cc8ac8
MH
1644
1645 packed_ref_iterator_begin,
1646 packed_read_raw_ref,
1647
1648 packed_reflog_iterator_begin,
1649 packed_for_each_reflog_ent,
1650 packed_for_each_reflog_ent_reverse,
1651 packed_reflog_exists,
1652 packed_create_reflog,
1653 packed_delete_reflog,
1654 packed_reflog_expire
1655};