3 #include "refs-internal.h"
4 #include "../iterator.h"
5 #include "../dir-iterator.h"
6 #include "../lockfile.h"
13 struct object_id old_oid
;
19 * Information used (along with the information in ref_entry) to
20 * describe a single cached reference. This data structure only
21 * occurs embedded in a union in struct ref_entry, and only when
22 * (ref_entry->flag & REF_DIR) is zero.
26 * The name of the object to which this reference resolves
27 * (which may be a tag object). If REF_ISBROKEN, this is
28 * null. If REF_ISSYMREF, then this is the name of the object
29 * referred to by the last reference in the symlink chain.
34 * If REF_KNOWS_PEELED, then this field holds the peeled value
35 * of this reference, or null if the reference is known not to
36 * be peelable. See the documentation for peel_ref() for an
37 * exact definition of "peelable".
39 struct object_id peeled
;
42 struct files_ref_store
;
45 * Information used (along with the information in ref_entry) to
46 * describe a level in the hierarchy of references. This data
47 * structure only occurs embedded in a union in struct ref_entry, and
48 * only when (ref_entry.flag & REF_DIR) is set. In that case,
49 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references
50 * in the directory have already been read:
52 * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose
53 * or packed references, already read.
55 * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose
56 * references that hasn't been read yet (nor has any of its
59 * Entries within a directory are stored within a growable array of
60 * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i <
61 * sorted are sorted by their component name in strcmp() order and the
62 * remaining entries are unsorted.
64 * Loose references are read lazily, one directory at a time. When a
65 * directory of loose references is read, then all of the references
66 * in that directory are stored, and REF_INCOMPLETE stubs are created
67 * for any subdirectories, but the subdirectories themselves are not
68 * read. The reading is triggered by get_ref_dir().
74 * Entries with index 0 <= i < sorted are sorted by name. New
75 * entries are appended to the list unsorted, and are sorted
76 * only when required; thus we avoid the need to sort the list
77 * after the addition of every reference.
81 /* A pointer to the files_ref_store that contains this ref_dir. */
82 struct files_ref_store
*ref_store
;
84 struct ref_entry
**entries
;
88 * Bit values for ref_entry::flag. REF_ISSYMREF=0x01,
89 * REF_ISPACKED=0x02, REF_ISBROKEN=0x04 and REF_BAD_NAME=0x08 are
90 * public values; see refs.h.
94 * The field ref_entry->u.value.peeled of this value entry contains
95 * the correct peeled value for the reference, which might be
96 * null_sha1 if the reference is not a tag or if it is broken.
98 #define REF_KNOWS_PEELED 0x10
100 /* ref_entry represents a directory of references */
104 * Entry has not yet been read from disk (used only for REF_DIR
105 * entries representing loose references)
107 #define REF_INCOMPLETE 0x40
110 * A ref_entry represents either a reference or a "subdirectory" of
113 * Each directory in the reference namespace is represented by a
114 * ref_entry with (flags & REF_DIR) set and containing a subdir member
115 * that holds the entries in that directory that have been read so
116 * far. If (flags & REF_INCOMPLETE) is set, then the directory and
117 * its subdirectories haven't been read yet. REF_INCOMPLETE is only
118 * used for loose reference directories.
120 * References are represented by a ref_entry with (flags & REF_DIR)
121 * unset and a value member that describes the reference's value. The
122 * flag member is at the ref_entry level, but it is also needed to
123 * interpret the contents of the value field (in other words, a
124 * ref_value object is not very much use without the enclosing
127 * Reference names cannot end with slash and directories' names are
128 * always stored with a trailing slash (except for the top-level
129 * directory, which is always denoted by ""). This has two nice
130 * consequences: (1) when the entries in each subdir are sorted
131 * lexicographically by name (as they usually are), the references in
132 * a whole tree can be generated in lexicographic order by traversing
133 * the tree in left-to-right, depth-first order; (2) the names of
134 * references and subdirectories cannot conflict, and therefore the
135 * presence of an empty subdirectory does not block the creation of a
136 * similarly-named reference. (The fact that reference names with the
137 * same leading components can conflict *with each other* is a
138 * separate issue that is regulated by verify_refname_available().)
140 * Please note that the name field contains the fully-qualified
141 * reference (or subdirectory) name. Space could be saved by only
142 * storing the relative names. But that would require the full names
143 * to be generated on the fly when iterating in do_for_each_ref(), and
144 * would break callback functions, who have always been able to assume
145 * that the name strings that they are passed will not be freed during
149 unsigned char flag
; /* ISSYMREF? ISPACKED? */
151 struct ref_value value
; /* if not (flags&REF_DIR) */
152 struct ref_dir subdir
; /* if (flags&REF_DIR) */
155 * The full name of the reference (e.g., "refs/heads/master")
156 * or the full name of the directory with a trailing slash
157 * (e.g., "refs/heads/"):
159 char name
[FLEX_ARRAY
];
162 static void read_loose_refs(const char *dirname
, struct ref_dir
*dir
);
163 static int search_ref_dir(struct ref_dir
*dir
, const char *refname
, size_t len
);
164 static struct ref_entry
*create_dir_entry(struct files_ref_store
*ref_store
,
165 const char *dirname
, size_t len
,
167 static void add_entry_to_dir(struct ref_dir
*dir
, struct ref_entry
*entry
);
168 static int files_log_ref_write(struct files_ref_store
*refs
,
169 const char *refname
, const unsigned char *old_sha1
,
170 const unsigned char *new_sha1
, const char *msg
,
171 int flags
, struct strbuf
*err
);
173 static struct ref_dir
*get_ref_dir(struct ref_entry
*entry
)
176 assert(entry
->flag
& REF_DIR
);
177 dir
= &entry
->u
.subdir
;
178 if (entry
->flag
& REF_INCOMPLETE
) {
179 read_loose_refs(entry
->name
, dir
);
182 * Manually add refs/bisect, which, being
183 * per-worktree, might not appear in the directory
184 * listing for refs/ in the main repo.
186 if (!strcmp(entry
->name
, "refs/")) {
187 int pos
= search_ref_dir(dir
, "refs/bisect/", 12);
189 struct ref_entry
*child_entry
;
190 child_entry
= create_dir_entry(dir
->ref_store
,
193 add_entry_to_dir(dir
, child_entry
);
194 read_loose_refs("refs/bisect",
195 &child_entry
->u
.subdir
);
198 entry
->flag
&= ~REF_INCOMPLETE
;
203 static struct ref_entry
*create_ref_entry(const char *refname
,
204 const unsigned char *sha1
, int flag
,
207 struct ref_entry
*ref
;
210 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
))
211 die("Reference has invalid format: '%s'", refname
);
212 FLEX_ALLOC_STR(ref
, name
, refname
);
213 hashcpy(ref
->u
.value
.oid
.hash
, sha1
);
214 oidclr(&ref
->u
.value
.peeled
);
219 static void clear_ref_dir(struct ref_dir
*dir
);
221 static void free_ref_entry(struct ref_entry
*entry
)
223 if (entry
->flag
& REF_DIR
) {
225 * Do not use get_ref_dir() here, as that might
226 * trigger the reading of loose refs.
228 clear_ref_dir(&entry
->u
.subdir
);
234 * Add a ref_entry to the end of dir (unsorted). Entry is always
235 * stored directly in dir; no recursion into subdirectories is
238 static void add_entry_to_dir(struct ref_dir
*dir
, struct ref_entry
*entry
)
240 ALLOC_GROW(dir
->entries
, dir
->nr
+ 1, dir
->alloc
);
241 dir
->entries
[dir
->nr
++] = entry
;
242 /* optimize for the case that entries are added in order */
244 (dir
->nr
== dir
->sorted
+ 1 &&
245 strcmp(dir
->entries
[dir
->nr
- 2]->name
,
246 dir
->entries
[dir
->nr
- 1]->name
) < 0))
247 dir
->sorted
= dir
->nr
;
251 * Clear and free all entries in dir, recursively.
253 static void clear_ref_dir(struct ref_dir
*dir
)
256 for (i
= 0; i
< dir
->nr
; i
++)
257 free_ref_entry(dir
->entries
[i
]);
259 dir
->sorted
= dir
->nr
= dir
->alloc
= 0;
264 * Create a struct ref_entry object for the specified dirname.
265 * dirname is the name of the directory with a trailing slash (e.g.,
266 * "refs/heads/") or "" for the top-level directory.
268 static struct ref_entry
*create_dir_entry(struct files_ref_store
*ref_store
,
269 const char *dirname
, size_t len
,
272 struct ref_entry
*direntry
;
273 FLEX_ALLOC_MEM(direntry
, name
, dirname
, len
);
274 direntry
->u
.subdir
.ref_store
= ref_store
;
275 direntry
->flag
= REF_DIR
| (incomplete
? REF_INCOMPLETE
: 0);
279 static int ref_entry_cmp(const void *a
, const void *b
)
281 struct ref_entry
*one
= *(struct ref_entry
**)a
;
282 struct ref_entry
*two
= *(struct ref_entry
**)b
;
283 return strcmp(one
->name
, two
->name
);
286 static void sort_ref_dir(struct ref_dir
*dir
);
288 struct string_slice
{
293 static int ref_entry_cmp_sslice(const void *key_
, const void *ent_
)
295 const struct string_slice
*key
= key_
;
296 const struct ref_entry
*ent
= *(const struct ref_entry
* const *)ent_
;
297 int cmp
= strncmp(key
->str
, ent
->name
, key
->len
);
300 return '\0' - (unsigned char)ent
->name
[key
->len
];
304 * Return the index of the entry with the given refname from the
305 * ref_dir (non-recursively), sorting dir if necessary. Return -1 if
306 * no such entry is found. dir must already be complete.
308 static int search_ref_dir(struct ref_dir
*dir
, const char *refname
, size_t len
)
310 struct ref_entry
**r
;
311 struct string_slice key
;
313 if (refname
== NULL
|| !dir
->nr
)
319 r
= bsearch(&key
, dir
->entries
, dir
->nr
, sizeof(*dir
->entries
),
320 ref_entry_cmp_sslice
);
325 return r
- dir
->entries
;
329 * Search for a directory entry directly within dir (without
330 * recursing). Sort dir if necessary. subdirname must be a directory
331 * name (i.e., end in '/'). If mkdir is set, then create the
332 * directory if it is missing; otherwise, return NULL if the desired
333 * directory cannot be found. dir must already be complete.
335 static struct ref_dir
*search_for_subdir(struct ref_dir
*dir
,
336 const char *subdirname
, size_t len
,
339 int entry_index
= search_ref_dir(dir
, subdirname
, len
);
340 struct ref_entry
*entry
;
341 if (entry_index
== -1) {
345 * Since dir is complete, the absence of a subdir
346 * means that the subdir really doesn't exist;
347 * therefore, create an empty record for it but mark
348 * the record complete.
350 entry
= create_dir_entry(dir
->ref_store
, subdirname
, len
, 0);
351 add_entry_to_dir(dir
, entry
);
353 entry
= dir
->entries
[entry_index
];
355 return get_ref_dir(entry
);
359 * If refname is a reference name, find the ref_dir within the dir
360 * tree that should hold refname. If refname is a directory name
361 * (i.e., ends in '/'), then return that ref_dir itself. dir must
362 * represent the top-level directory and must already be complete.
363 * Sort ref_dirs and recurse into subdirectories as necessary. If
364 * mkdir is set, then create any missing directories; otherwise,
365 * return NULL if the desired directory cannot be found.
367 static struct ref_dir
*find_containing_dir(struct ref_dir
*dir
,
368 const char *refname
, int mkdir
)
371 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
372 size_t dirnamelen
= slash
- refname
+ 1;
373 struct ref_dir
*subdir
;
374 subdir
= search_for_subdir(dir
, refname
, dirnamelen
, mkdir
);
386 * Find the value entry with the given name in dir, sorting ref_dirs
387 * and recursing into subdirectories as necessary. If the name is not
388 * found or it corresponds to a directory entry, return NULL.
390 static struct ref_entry
*find_ref(struct ref_dir
*dir
, const char *refname
)
393 struct ref_entry
*entry
;
394 dir
= find_containing_dir(dir
, refname
, 0);
397 entry_index
= search_ref_dir(dir
, refname
, strlen(refname
));
398 if (entry_index
== -1)
400 entry
= dir
->entries
[entry_index
];
401 return (entry
->flag
& REF_DIR
) ? NULL
: entry
;
405 * Remove the entry with the given name from dir, recursing into
406 * subdirectories as necessary. If refname is the name of a directory
407 * (i.e., ends with '/'), then remove the directory and its contents.
408 * If the removal was successful, return the number of entries
409 * remaining in the directory entry that contained the deleted entry.
410 * If the name was not found, return -1. Please note that this
411 * function only deletes the entry from the cache; it does not delete
412 * it from the filesystem or ensure that other cache entries (which
413 * might be symbolic references to the removed entry) are updated.
414 * Nor does it remove any containing dir entries that might be made
415 * empty by the removal. dir must represent the top-level directory
416 * and must already be complete.
418 static int remove_entry(struct ref_dir
*dir
, const char *refname
)
420 int refname_len
= strlen(refname
);
422 struct ref_entry
*entry
;
423 int is_dir
= refname
[refname_len
- 1] == '/';
426 * refname represents a reference directory. Remove
427 * the trailing slash; otherwise we will get the
428 * directory *representing* refname rather than the
429 * one *containing* it.
431 char *dirname
= xmemdupz(refname
, refname_len
- 1);
432 dir
= find_containing_dir(dir
, dirname
, 0);
435 dir
= find_containing_dir(dir
, refname
, 0);
439 entry_index
= search_ref_dir(dir
, refname
, refname_len
);
440 if (entry_index
== -1)
442 entry
= dir
->entries
[entry_index
];
444 memmove(&dir
->entries
[entry_index
],
445 &dir
->entries
[entry_index
+ 1],
446 (dir
->nr
- entry_index
- 1) * sizeof(*dir
->entries
)
449 if (dir
->sorted
> entry_index
)
451 free_ref_entry(entry
);
456 * Add a ref_entry to the ref_dir (unsorted), recursing into
457 * subdirectories as necessary. dir must represent the top-level
458 * directory. Return 0 on success.
460 static int add_ref(struct ref_dir
*dir
, struct ref_entry
*ref
)
462 dir
= find_containing_dir(dir
, ref
->name
, 1);
465 add_entry_to_dir(dir
, ref
);
470 * Emit a warning and return true iff ref1 and ref2 have the same name
471 * and the same sha1. Die if they have the same name but different
474 static int is_dup_ref(const struct ref_entry
*ref1
, const struct ref_entry
*ref2
)
476 if (strcmp(ref1
->name
, ref2
->name
))
479 /* Duplicate name; make sure that they don't conflict: */
481 if ((ref1
->flag
& REF_DIR
) || (ref2
->flag
& REF_DIR
))
482 /* This is impossible by construction */
483 die("Reference directory conflict: %s", ref1
->name
);
485 if (oidcmp(&ref1
->u
.value
.oid
, &ref2
->u
.value
.oid
))
486 die("Duplicated ref, and SHA1s don't match: %s", ref1
->name
);
488 warning("Duplicated ref: %s", ref1
->name
);
493 * Sort the entries in dir non-recursively (if they are not already
494 * sorted) and remove any duplicate entries.
496 static void sort_ref_dir(struct ref_dir
*dir
)
499 struct ref_entry
*last
= NULL
;
502 * This check also prevents passing a zero-length array to qsort(),
503 * which is a problem on some platforms.
505 if (dir
->sorted
== dir
->nr
)
508 QSORT(dir
->entries
, dir
->nr
, ref_entry_cmp
);
510 /* Remove any duplicates: */
511 for (i
= 0, j
= 0; j
< dir
->nr
; j
++) {
512 struct ref_entry
*entry
= dir
->entries
[j
];
513 if (last
&& is_dup_ref(last
, entry
))
514 free_ref_entry(entry
);
516 last
= dir
->entries
[i
++] = entry
;
518 dir
->sorted
= dir
->nr
= i
;
522 * Return true if refname, which has the specified oid and flags, can
523 * be resolved to an object in the database. If the referred-to object
524 * does not exist, emit a warning and return false.
526 static int ref_resolves_to_object(const char *refname
,
527 const struct object_id
*oid
,
530 if (flags
& REF_ISBROKEN
)
532 if (!has_sha1_file(oid
->hash
)) {
533 error("%s does not point to a valid object!", refname
);
540 * Return true if the reference described by entry can be resolved to
541 * an object in the database; otherwise, emit a warning and return
544 static int entry_resolves_to_object(struct ref_entry
*entry
)
546 return ref_resolves_to_object(entry
->name
,
547 &entry
->u
.value
.oid
, entry
->flag
);
550 typedef int each_ref_entry_fn(struct ref_entry
*entry
, void *cb_data
);
553 * Call fn for each reference in dir that has index in the range
554 * offset <= index < dir->nr. Recurse into subdirectories that are in
555 * that index range, sorting them before iterating. This function
556 * does not sort dir itself; it should be sorted beforehand. fn is
557 * called for all references, including broken ones.
559 static int do_for_each_entry_in_dir(struct ref_dir
*dir
, int offset
,
560 each_ref_entry_fn fn
, void *cb_data
)
563 assert(dir
->sorted
== dir
->nr
);
564 for (i
= offset
; i
< dir
->nr
; i
++) {
565 struct ref_entry
*entry
= dir
->entries
[i
];
567 if (entry
->flag
& REF_DIR
) {
568 struct ref_dir
*subdir
= get_ref_dir(entry
);
569 sort_ref_dir(subdir
);
570 retval
= do_for_each_entry_in_dir(subdir
, 0, fn
, cb_data
);
572 retval
= fn(entry
, cb_data
);
581 * Load all of the refs from the dir into our in-memory cache. The hard work
582 * of loading loose refs is done by get_ref_dir(), so we just need to recurse
583 * through all of the sub-directories. We do not even need to care about
584 * sorting, as traversal order does not matter to us.
586 static void prime_ref_dir(struct ref_dir
*dir
)
589 for (i
= 0; i
< dir
->nr
; i
++) {
590 struct ref_entry
*entry
= dir
->entries
[i
];
591 if (entry
->flag
& REF_DIR
)
592 prime_ref_dir(get_ref_dir(entry
));
597 * A level in the reference hierarchy that is currently being iterated
600 struct cache_ref_iterator_level
{
602 * The ref_dir being iterated over at this level. The ref_dir
603 * is sorted before being stored here.
608 * The index of the current entry within dir (which might
609 * itself be a directory). If index == -1, then the iteration
610 * hasn't yet begun. If index == dir->nr, then the iteration
611 * through this level is over.
617 * Represent an iteration through a ref_dir in the memory cache. The
618 * iteration recurses through subdirectories.
620 struct cache_ref_iterator
{
621 struct ref_iterator base
;
624 * The number of levels currently on the stack. This is always
625 * at least 1, because when it becomes zero the iteration is
626 * ended and this struct is freed.
630 /* The number of levels that have been allocated on the stack */
634 * A stack of levels. levels[0] is the uppermost level that is
635 * being iterated over in this iteration. (This is not
636 * necessary the top level in the references hierarchy. If we
637 * are iterating through a subtree, then levels[0] will hold
638 * the ref_dir for that subtree, and subsequent levels will go
641 struct cache_ref_iterator_level
*levels
;
644 static int cache_ref_iterator_advance(struct ref_iterator
*ref_iterator
)
646 struct cache_ref_iterator
*iter
=
647 (struct cache_ref_iterator
*)ref_iterator
;
650 struct cache_ref_iterator_level
*level
=
651 &iter
->levels
[iter
->levels_nr
- 1];
652 struct ref_dir
*dir
= level
->dir
;
653 struct ref_entry
*entry
;
655 if (level
->index
== -1)
658 if (++level
->index
== level
->dir
->nr
) {
659 /* This level is exhausted; pop up a level */
660 if (--iter
->levels_nr
== 0)
661 return ref_iterator_abort(ref_iterator
);
666 entry
= dir
->entries
[level
->index
];
668 if (entry
->flag
& REF_DIR
) {
669 /* push down a level */
670 ALLOC_GROW(iter
->levels
, iter
->levels_nr
+ 1,
673 level
= &iter
->levels
[iter
->levels_nr
++];
674 level
->dir
= get_ref_dir(entry
);
677 iter
->base
.refname
= entry
->name
;
678 iter
->base
.oid
= &entry
->u
.value
.oid
;
679 iter
->base
.flags
= entry
->flag
;
685 static enum peel_status
peel_entry(struct ref_entry
*entry
, int repeel
);
687 static int cache_ref_iterator_peel(struct ref_iterator
*ref_iterator
,
688 struct object_id
*peeled
)
690 struct cache_ref_iterator
*iter
=
691 (struct cache_ref_iterator
*)ref_iterator
;
692 struct cache_ref_iterator_level
*level
;
693 struct ref_entry
*entry
;
695 level
= &iter
->levels
[iter
->levels_nr
- 1];
697 if (level
->index
== -1)
698 die("BUG: peel called before advance for cache iterator");
700 entry
= level
->dir
->entries
[level
->index
];
702 if (peel_entry(entry
, 0))
704 oidcpy(peeled
, &entry
->u
.value
.peeled
);
708 static int cache_ref_iterator_abort(struct ref_iterator
*ref_iterator
)
710 struct cache_ref_iterator
*iter
=
711 (struct cache_ref_iterator
*)ref_iterator
;
714 base_ref_iterator_free(ref_iterator
);
718 static struct ref_iterator_vtable cache_ref_iterator_vtable
= {
719 cache_ref_iterator_advance
,
720 cache_ref_iterator_peel
,
721 cache_ref_iterator_abort
724 static struct ref_iterator
*cache_ref_iterator_begin(struct ref_dir
*dir
)
726 struct cache_ref_iterator
*iter
;
727 struct ref_iterator
*ref_iterator
;
728 struct cache_ref_iterator_level
*level
;
730 iter
= xcalloc(1, sizeof(*iter
));
731 ref_iterator
= &iter
->base
;
732 base_ref_iterator_init(ref_iterator
, &cache_ref_iterator_vtable
);
733 ALLOC_GROW(iter
->levels
, 10, iter
->levels_alloc
);
736 level
= &iter
->levels
[0];
743 struct nonmatching_ref_data
{
744 const struct string_list
*skip
;
745 const char *conflicting_refname
;
748 static int nonmatching_ref_fn(struct ref_entry
*entry
, void *vdata
)
750 struct nonmatching_ref_data
*data
= vdata
;
752 if (data
->skip
&& string_list_has_string(data
->skip
, entry
->name
))
755 data
->conflicting_refname
= entry
->name
;
760 * Return 0 if a reference named refname could be created without
761 * conflicting with the name of an existing reference in dir.
762 * See verify_refname_available for more information.
764 static int verify_refname_available_dir(const char *refname
,
765 const struct string_list
*extras
,
766 const struct string_list
*skip
,
771 const char *extra_refname
;
773 struct strbuf dirname
= STRBUF_INIT
;
777 * For the sake of comments in this function, suppose that
778 * refname is "refs/foo/bar".
783 strbuf_grow(&dirname
, strlen(refname
) + 1);
784 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
785 /* Expand dirname to the new prefix, not including the trailing slash: */
786 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
789 * We are still at a leading dir of the refname (e.g.,
790 * "refs/foo"; if there is a reference with that name,
791 * it is a conflict, *unless* it is in skip.
794 pos
= search_ref_dir(dir
, dirname
.buf
, dirname
.len
);
796 (!skip
|| !string_list_has_string(skip
, dirname
.buf
))) {
798 * We found a reference whose name is
799 * a proper prefix of refname; e.g.,
800 * "refs/foo", and is not in skip.
802 strbuf_addf(err
, "'%s' exists; cannot create '%s'",
803 dirname
.buf
, refname
);
808 if (extras
&& string_list_has_string(extras
, dirname
.buf
) &&
809 (!skip
|| !string_list_has_string(skip
, dirname
.buf
))) {
810 strbuf_addf(err
, "cannot process '%s' and '%s' at the same time",
811 refname
, dirname
.buf
);
816 * Otherwise, we can try to continue our search with
817 * the next component. So try to look up the
818 * directory, e.g., "refs/foo/". If we come up empty,
819 * we know there is nothing under this whole prefix,
820 * but even in that case we still have to continue the
821 * search for conflicts with extras.
823 strbuf_addch(&dirname
, '/');
825 pos
= search_ref_dir(dir
, dirname
.buf
, dirname
.len
);
828 * There was no directory "refs/foo/",
829 * so there is nothing under this
830 * whole prefix. So there is no need
831 * to continue looking for conflicting
832 * references. But we need to continue
833 * looking for conflicting extras.
837 dir
= get_ref_dir(dir
->entries
[pos
]);
843 * We are at the leaf of our refname (e.g., "refs/foo/bar").
844 * There is no point in searching for a reference with that
845 * name, because a refname isn't considered to conflict with
846 * itself. But we still need to check for references whose
847 * names are in the "refs/foo/bar/" namespace, because they
850 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
851 strbuf_addch(&dirname
, '/');
854 pos
= search_ref_dir(dir
, dirname
.buf
, dirname
.len
);
858 * We found a directory named "$refname/"
859 * (e.g., "refs/foo/bar/"). It is a problem
860 * iff it contains any ref that is not in
863 struct nonmatching_ref_data data
;
866 data
.conflicting_refname
= NULL
;
867 dir
= get_ref_dir(dir
->entries
[pos
]);
869 if (do_for_each_entry_in_dir(dir
, 0, nonmatching_ref_fn
, &data
)) {
870 strbuf_addf(err
, "'%s' exists; cannot create '%s'",
871 data
.conflicting_refname
, refname
);
877 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
879 strbuf_addf(err
, "cannot process '%s' and '%s' at the same time",
880 refname
, extra_refname
);
885 strbuf_release(&dirname
);
889 struct packed_ref_cache
{
890 struct ref_entry
*root
;
893 * Count of references to the data structure in this instance,
894 * including the pointer from files_ref_store::packed if any.
895 * The data will not be freed as long as the reference count
898 unsigned int referrers
;
901 * Iff the packed-refs file associated with this instance is
902 * currently locked for writing, this points at the associated
903 * lock (which is owned by somebody else). The referrer count
904 * is also incremented when the file is locked and decremented
905 * when it is unlocked.
907 struct lock_file
*lock
;
909 /* The metadata from when this packed-refs cache was read */
910 struct stat_validity validity
;
914 * Future: need to be in "struct repository"
915 * when doing a full libification.
917 struct files_ref_store
{
918 struct ref_store base
;
919 unsigned int store_flags
;
923 char *packed_refs_path
;
925 struct ref_entry
*loose
;
926 struct packed_ref_cache
*packed
;
929 /* Lock used for the main packed-refs file: */
930 static struct lock_file packlock
;
933 * Increment the reference count of *packed_refs.
935 static void acquire_packed_ref_cache(struct packed_ref_cache
*packed_refs
)
937 packed_refs
->referrers
++;
941 * Decrease the reference count of *packed_refs. If it goes to zero,
942 * free *packed_refs and return true; otherwise return false.
944 static int release_packed_ref_cache(struct packed_ref_cache
*packed_refs
)
946 if (!--packed_refs
->referrers
) {
947 free_ref_entry(packed_refs
->root
);
948 stat_validity_clear(&packed_refs
->validity
);
956 static void clear_packed_ref_cache(struct files_ref_store
*refs
)
959 struct packed_ref_cache
*packed_refs
= refs
->packed
;
961 if (packed_refs
->lock
)
962 die("internal error: packed-ref cache cleared while locked");
964 release_packed_ref_cache(packed_refs
);
968 static void clear_loose_ref_cache(struct files_ref_store
*refs
)
971 free_ref_entry(refs
->loose
);
977 * Create a new submodule ref cache and add it to the internal
980 static struct ref_store
*files_ref_store_create(const char *gitdir
,
983 struct files_ref_store
*refs
= xcalloc(1, sizeof(*refs
));
984 struct ref_store
*ref_store
= (struct ref_store
*)refs
;
985 struct strbuf sb
= STRBUF_INIT
;
987 base_ref_store_init(ref_store
, &refs_be_files
);
988 refs
->store_flags
= flags
;
990 refs
->gitdir
= xstrdup(gitdir
);
991 get_common_dir_noenv(&sb
, gitdir
);
992 refs
->gitcommondir
= strbuf_detach(&sb
, NULL
);
993 strbuf_addf(&sb
, "%s/packed-refs", refs
->gitcommondir
);
994 refs
->packed_refs_path
= strbuf_detach(&sb
, NULL
);
1000 * Die if refs is not the main ref store. caller is used in any
1001 * necessary error messages.
1003 static void files_assert_main_repository(struct files_ref_store
*refs
,
1006 if (refs
->store_flags
& REF_STORE_MAIN
)
1009 die("BUG: operation %s only allowed for main ref store", caller
);
1013 * Downcast ref_store to files_ref_store. Die if ref_store is not a
1014 * files_ref_store. required_flags is compared with ref_store's
1015 * store_flags to ensure the ref_store has all required capabilities.
1016 * "caller" is used in any necessary error messages.
1018 static struct files_ref_store
*files_downcast(struct ref_store
*ref_store
,
1019 unsigned int required_flags
,
1022 struct files_ref_store
*refs
;
1024 if (ref_store
->be
!= &refs_be_files
)
1025 die("BUG: ref_store is type \"%s\" not \"files\" in %s",
1026 ref_store
->be
->name
, caller
);
1028 refs
= (struct files_ref_store
*)ref_store
;
1030 if ((refs
->store_flags
& required_flags
) != required_flags
)
1031 die("BUG: operation %s requires abilities 0x%x, but only have 0x%x",
1032 caller
, required_flags
, refs
->store_flags
);
1037 /* The length of a peeled reference line in packed-refs, including EOL: */
1038 #define PEELED_LINE_LENGTH 42
1041 * The packed-refs header line that we write out. Perhaps other
1042 * traits will be added later. The trailing space is required.
1044 static const char PACKED_REFS_HEADER
[] =
1045 "# pack-refs with: peeled fully-peeled \n";
1048 * Parse one line from a packed-refs file. Write the SHA1 to sha1.
1049 * Return a pointer to the refname within the line (null-terminated),
1050 * or NULL if there was a problem.
1052 static const char *parse_ref_line(struct strbuf
*line
, unsigned char *sha1
)
1057 * 42: the answer to everything.
1059 * In this case, it happens to be the answer to
1060 * 40 (length of sha1 hex representation)
1061 * +1 (space in between hex and name)
1062 * +1 (newline at the end of the line)
1064 if (line
->len
<= 42)
1067 if (get_sha1_hex(line
->buf
, sha1
) < 0)
1069 if (!isspace(line
->buf
[40]))
1072 ref
= line
->buf
+ 41;
1076 if (line
->buf
[line
->len
- 1] != '\n')
1078 line
->buf
[--line
->len
] = 0;
1084 * Read f, which is a packed-refs file, into dir.
1086 * A comment line of the form "# pack-refs with: " may contain zero or
1087 * more traits. We interpret the traits as follows:
1091 * Probably no references are peeled. But if the file contains a
1092 * peeled value for a reference, we will use it.
1096 * References under "refs/tags/", if they *can* be peeled, *are*
1097 * peeled in this file. References outside of "refs/tags/" are
1098 * probably not peeled even if they could have been, but if we find
1099 * a peeled value for such a reference we will use it.
1103 * All references in the file that can be peeled are peeled.
1104 * Inversely (and this is more important), any references in the
1105 * file for which no peeled value is recorded is not peelable. This
1106 * trait should typically be written alongside "peeled" for
1107 * compatibility with older clients, but we do not require it
1108 * (i.e., "peeled" is a no-op if "fully-peeled" is set).
1110 static void read_packed_refs(FILE *f
, struct ref_dir
*dir
)
1112 struct ref_entry
*last
= NULL
;
1113 struct strbuf line
= STRBUF_INIT
;
1114 enum { PEELED_NONE
, PEELED_TAGS
, PEELED_FULLY
} peeled
= PEELED_NONE
;
1116 while (strbuf_getwholeline(&line
, f
, '\n') != EOF
) {
1117 unsigned char sha1
[20];
1118 const char *refname
;
1121 if (skip_prefix(line
.buf
, "# pack-refs with:", &traits
)) {
1122 if (strstr(traits
, " fully-peeled "))
1123 peeled
= PEELED_FULLY
;
1124 else if (strstr(traits
, " peeled "))
1125 peeled
= PEELED_TAGS
;
1126 /* perhaps other traits later as well */
1130 refname
= parse_ref_line(&line
, sha1
);
1132 int flag
= REF_ISPACKED
;
1134 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1135 if (!refname_is_safe(refname
))
1136 die("packed refname is dangerous: %s", refname
);
1138 flag
|= REF_BAD_NAME
| REF_ISBROKEN
;
1140 last
= create_ref_entry(refname
, sha1
, flag
, 0);
1141 if (peeled
== PEELED_FULLY
||
1142 (peeled
== PEELED_TAGS
&& starts_with(refname
, "refs/tags/")))
1143 last
->flag
|= REF_KNOWS_PEELED
;
1148 line
.buf
[0] == '^' &&
1149 line
.len
== PEELED_LINE_LENGTH
&&
1150 line
.buf
[PEELED_LINE_LENGTH
- 1] == '\n' &&
1151 !get_sha1_hex(line
.buf
+ 1, sha1
)) {
1152 hashcpy(last
->u
.value
.peeled
.hash
, sha1
);
1154 * Regardless of what the file header said,
1155 * we definitely know the value of *this*
1158 last
->flag
|= REF_KNOWS_PEELED
;
1162 strbuf_release(&line
);
1165 static const char *files_packed_refs_path(struct files_ref_store
*refs
)
1167 return refs
->packed_refs_path
;
1170 static void files_reflog_path(struct files_ref_store
*refs
,
1172 const char *refname
)
1176 * FIXME: of course this is wrong in multi worktree
1177 * setting. To be fixed real soon.
1179 strbuf_addf(sb
, "%s/logs", refs
->gitcommondir
);
1183 switch (ref_type(refname
)) {
1184 case REF_TYPE_PER_WORKTREE
:
1185 case REF_TYPE_PSEUDOREF
:
1186 strbuf_addf(sb
, "%s/logs/%s", refs
->gitdir
, refname
);
1188 case REF_TYPE_NORMAL
:
1189 strbuf_addf(sb
, "%s/logs/%s", refs
->gitcommondir
, refname
);
1192 die("BUG: unknown ref type %d of ref %s",
1193 ref_type(refname
), refname
);
1197 static void files_ref_path(struct files_ref_store
*refs
,
1199 const char *refname
)
1201 switch (ref_type(refname
)) {
1202 case REF_TYPE_PER_WORKTREE
:
1203 case REF_TYPE_PSEUDOREF
:
1204 strbuf_addf(sb
, "%s/%s", refs
->gitdir
, refname
);
1206 case REF_TYPE_NORMAL
:
1207 strbuf_addf(sb
, "%s/%s", refs
->gitcommondir
, refname
);
1210 die("BUG: unknown ref type %d of ref %s",
1211 ref_type(refname
), refname
);
1216 * Get the packed_ref_cache for the specified files_ref_store,
1217 * creating it if necessary.
1219 static struct packed_ref_cache
*get_packed_ref_cache(struct files_ref_store
*refs
)
1221 const char *packed_refs_file
= files_packed_refs_path(refs
);
1224 !stat_validity_check(&refs
->packed
->validity
, packed_refs_file
))
1225 clear_packed_ref_cache(refs
);
1227 if (!refs
->packed
) {
1230 refs
->packed
= xcalloc(1, sizeof(*refs
->packed
));
1231 acquire_packed_ref_cache(refs
->packed
);
1232 refs
->packed
->root
= create_dir_entry(refs
, "", 0, 0);
1233 f
= fopen(packed_refs_file
, "r");
1235 stat_validity_update(&refs
->packed
->validity
, fileno(f
));
1236 read_packed_refs(f
, get_ref_dir(refs
->packed
->root
));
1240 return refs
->packed
;
1243 static struct ref_dir
*get_packed_ref_dir(struct packed_ref_cache
*packed_ref_cache
)
1245 return get_ref_dir(packed_ref_cache
->root
);
1248 static struct ref_dir
*get_packed_refs(struct files_ref_store
*refs
)
1250 return get_packed_ref_dir(get_packed_ref_cache(refs
));
1254 * Add a reference to the in-memory packed reference cache. This may
1255 * only be called while the packed-refs file is locked (see
1256 * lock_packed_refs()). To actually write the packed-refs file, call
1257 * commit_packed_refs().
1259 static void add_packed_ref(struct files_ref_store
*refs
,
1260 const char *refname
, const unsigned char *sha1
)
1262 struct packed_ref_cache
*packed_ref_cache
= get_packed_ref_cache(refs
);
1264 if (!packed_ref_cache
->lock
)
1265 die("internal error: packed refs not locked");
1266 add_ref(get_packed_ref_dir(packed_ref_cache
),
1267 create_ref_entry(refname
, sha1
, REF_ISPACKED
, 1));
1271 * Read the loose references from the namespace dirname into dir
1272 * (without recursing). dirname must end with '/'. dir must be the
1273 * directory entry corresponding to dirname.
1275 static void read_loose_refs(const char *dirname
, struct ref_dir
*dir
)
1277 struct files_ref_store
*refs
= dir
->ref_store
;
1280 int dirnamelen
= strlen(dirname
);
1281 struct strbuf refname
;
1282 struct strbuf path
= STRBUF_INIT
;
1283 size_t path_baselen
;
1285 files_ref_path(refs
, &path
, dirname
);
1286 path_baselen
= path
.len
;
1288 d
= opendir(path
.buf
);
1290 strbuf_release(&path
);
1294 strbuf_init(&refname
, dirnamelen
+ 257);
1295 strbuf_add(&refname
, dirname
, dirnamelen
);
1297 while ((de
= readdir(d
)) != NULL
) {
1298 unsigned char sha1
[20];
1302 if (de
->d_name
[0] == '.')
1304 if (ends_with(de
->d_name
, ".lock"))
1306 strbuf_addstr(&refname
, de
->d_name
);
1307 strbuf_addstr(&path
, de
->d_name
);
1308 if (stat(path
.buf
, &st
) < 0) {
1309 ; /* silently ignore */
1310 } else if (S_ISDIR(st
.st_mode
)) {
1311 strbuf_addch(&refname
, '/');
1312 add_entry_to_dir(dir
,
1313 create_dir_entry(refs
, refname
.buf
,
1316 if (!refs_resolve_ref_unsafe(&refs
->base
,
1318 RESOLVE_REF_READING
,
1321 flag
|= REF_ISBROKEN
;
1322 } else if (is_null_sha1(sha1
)) {
1324 * It is so astronomically unlikely
1325 * that NULL_SHA1 is the SHA-1 of an
1326 * actual object that we consider its
1327 * appearance in a loose reference
1328 * file to be repo corruption
1329 * (probably due to a software bug).
1331 flag
|= REF_ISBROKEN
;
1334 if (check_refname_format(refname
.buf
,
1335 REFNAME_ALLOW_ONELEVEL
)) {
1336 if (!refname_is_safe(refname
.buf
))
1337 die("loose refname is dangerous: %s", refname
.buf
);
1339 flag
|= REF_BAD_NAME
| REF_ISBROKEN
;
1341 add_entry_to_dir(dir
,
1342 create_ref_entry(refname
.buf
, sha1
, flag
, 0));
1344 strbuf_setlen(&refname
, dirnamelen
);
1345 strbuf_setlen(&path
, path_baselen
);
1347 strbuf_release(&refname
);
1348 strbuf_release(&path
);
1352 static struct ref_dir
*get_loose_refs(struct files_ref_store
*refs
)
1356 * Mark the top-level directory complete because we
1357 * are about to read the only subdirectory that can
1360 refs
->loose
= create_dir_entry(refs
, "", 0, 0);
1362 * Create an incomplete entry for "refs/":
1364 add_entry_to_dir(get_ref_dir(refs
->loose
),
1365 create_dir_entry(refs
, "refs/", 5, 1));
1367 return get_ref_dir(refs
->loose
);
1371 * Return the ref_entry for the given refname from the packed
1372 * references. If it does not exist, return NULL.
1374 static struct ref_entry
*get_packed_ref(struct files_ref_store
*refs
,
1375 const char *refname
)
1377 return find_ref(get_packed_refs(refs
), refname
);
1381 * A loose ref file doesn't exist; check for a packed ref.
1383 static int resolve_packed_ref(struct files_ref_store
*refs
,
1384 const char *refname
,
1385 unsigned char *sha1
, unsigned int *flags
)
1387 struct ref_entry
*entry
;
1390 * The loose reference file does not exist; check for a packed
1393 entry
= get_packed_ref(refs
, refname
);
1395 hashcpy(sha1
, entry
->u
.value
.oid
.hash
);
1396 *flags
|= REF_ISPACKED
;
1399 /* refname is not a packed reference. */
1403 static int files_read_raw_ref(struct ref_store
*ref_store
,
1404 const char *refname
, unsigned char *sha1
,
1405 struct strbuf
*referent
, unsigned int *type
)
1407 struct files_ref_store
*refs
=
1408 files_downcast(ref_store
, REF_STORE_READ
, "read_raw_ref");
1409 struct strbuf sb_contents
= STRBUF_INIT
;
1410 struct strbuf sb_path
= STRBUF_INIT
;
1417 int remaining_retries
= 3;
1420 strbuf_reset(&sb_path
);
1422 files_ref_path(refs
, &sb_path
, refname
);
1428 * We might have to loop back here to avoid a race
1429 * condition: first we lstat() the file, then we try
1430 * to read it as a link or as a file. But if somebody
1431 * changes the type of the file (file <-> directory
1432 * <-> symlink) between the lstat() and reading, then
1433 * we don't want to report that as an error but rather
1434 * try again starting with the lstat().
1436 * We'll keep a count of the retries, though, just to avoid
1437 * any confusing situation sending us into an infinite loop.
1440 if (remaining_retries
-- <= 0)
1443 if (lstat(path
, &st
) < 0) {
1444 if (errno
!= ENOENT
)
1446 if (resolve_packed_ref(refs
, refname
, sha1
, type
)) {
1454 /* Follow "normalized" - ie "refs/.." symlinks by hand */
1455 if (S_ISLNK(st
.st_mode
)) {
1456 strbuf_reset(&sb_contents
);
1457 if (strbuf_readlink(&sb_contents
, path
, 0) < 0) {
1458 if (errno
== ENOENT
|| errno
== EINVAL
)
1459 /* inconsistent with lstat; retry */
1464 if (starts_with(sb_contents
.buf
, "refs/") &&
1465 !check_refname_format(sb_contents
.buf
, 0)) {
1466 strbuf_swap(&sb_contents
, referent
);
1467 *type
|= REF_ISSYMREF
;
1472 * It doesn't look like a refname; fall through to just
1473 * treating it like a non-symlink, and reading whatever it
1478 /* Is it a directory? */
1479 if (S_ISDIR(st
.st_mode
)) {
1481 * Even though there is a directory where the loose
1482 * ref is supposed to be, there could still be a
1485 if (resolve_packed_ref(refs
, refname
, sha1
, type
)) {
1494 * Anything else, just open it and try to use it as
1497 fd
= open(path
, O_RDONLY
);
1499 if (errno
== ENOENT
&& !S_ISLNK(st
.st_mode
))
1500 /* inconsistent with lstat; retry */
1505 strbuf_reset(&sb_contents
);
1506 if (strbuf_read(&sb_contents
, fd
, 256) < 0) {
1507 int save_errno
= errno
;
1513 strbuf_rtrim(&sb_contents
);
1514 buf
= sb_contents
.buf
;
1515 if (starts_with(buf
, "ref:")) {
1517 while (isspace(*buf
))
1520 strbuf_reset(referent
);
1521 strbuf_addstr(referent
, buf
);
1522 *type
|= REF_ISSYMREF
;
1528 * Please note that FETCH_HEAD has additional
1529 * data after the sha.
1531 if (get_sha1_hex(buf
, sha1
) ||
1532 (buf
[40] != '\0' && !isspace(buf
[40]))) {
1533 *type
|= REF_ISBROKEN
;
1542 strbuf_release(&sb_path
);
1543 strbuf_release(&sb_contents
);
1548 static void unlock_ref(struct ref_lock
*lock
)
1550 /* Do not free lock->lk -- atexit() still looks at them */
1552 rollback_lock_file(lock
->lk
);
1553 free(lock
->ref_name
);
1558 * Lock refname, without following symrefs, and set *lock_p to point
1559 * at a newly-allocated lock object. Fill in lock->old_oid, referent,
1560 * and type similarly to read_raw_ref().
1562 * The caller must verify that refname is a "safe" reference name (in
1563 * the sense of refname_is_safe()) before calling this function.
1565 * If the reference doesn't already exist, verify that refname doesn't
1566 * have a D/F conflict with any existing references. extras and skip
1567 * are passed to verify_refname_available_dir() for this check.
1569 * If mustexist is not set and the reference is not found or is
1570 * broken, lock the reference anyway but clear sha1.
1572 * Return 0 on success. On failure, write an error message to err and
1573 * return TRANSACTION_NAME_CONFLICT or TRANSACTION_GENERIC_ERROR.
1575 * Implementation note: This function is basically
1580 * but it includes a lot more code to
1581 * - Deal with possible races with other processes
1582 * - Avoid calling verify_refname_available_dir() when it can be
1583 * avoided, namely if we were successfully able to read the ref
1584 * - Generate informative error messages in the case of failure
1586 static int lock_raw_ref(struct files_ref_store
*refs
,
1587 const char *refname
, int mustexist
,
1588 const struct string_list
*extras
,
1589 const struct string_list
*skip
,
1590 struct ref_lock
**lock_p
,
1591 struct strbuf
*referent
,
1595 struct ref_lock
*lock
;
1596 struct strbuf ref_file
= STRBUF_INIT
;
1597 int attempts_remaining
= 3;
1598 int ret
= TRANSACTION_GENERIC_ERROR
;
1601 files_assert_main_repository(refs
, "lock_raw_ref");
1605 /* First lock the file so it can't change out from under us. */
1607 *lock_p
= lock
= xcalloc(1, sizeof(*lock
));
1609 lock
->ref_name
= xstrdup(refname
);
1610 files_ref_path(refs
, &ref_file
, refname
);
1613 switch (safe_create_leading_directories(ref_file
.buf
)) {
1615 break; /* success */
1618 * Suppose refname is "refs/foo/bar". We just failed
1619 * to create the containing directory, "refs/foo",
1620 * because there was a non-directory in the way. This
1621 * indicates a D/F conflict, probably because of
1622 * another reference such as "refs/foo". There is no
1623 * reason to expect this error to be transitory.
1625 if (refs_verify_refname_available(&refs
->base
, refname
,
1626 extras
, skip
, err
)) {
1629 * To the user the relevant error is
1630 * that the "mustexist" reference is
1634 strbuf_addf(err
, "unable to resolve reference '%s'",
1638 * The error message set by
1639 * verify_refname_available_dir() is OK.
1641 ret
= TRANSACTION_NAME_CONFLICT
;
1645 * The file that is in the way isn't a loose
1646 * reference. Report it as a low-level
1649 strbuf_addf(err
, "unable to create lock file %s.lock; "
1650 "non-directory in the way",
1655 /* Maybe another process was tidying up. Try again. */
1656 if (--attempts_remaining
> 0)
1660 strbuf_addf(err
, "unable to create directory for %s",
1666 lock
->lk
= xcalloc(1, sizeof(struct lock_file
));
1668 if (hold_lock_file_for_update(lock
->lk
, ref_file
.buf
, LOCK_NO_DEREF
) < 0) {
1669 if (errno
== ENOENT
&& --attempts_remaining
> 0) {
1671 * Maybe somebody just deleted one of the
1672 * directories leading to ref_file. Try
1677 unable_to_lock_message(ref_file
.buf
, errno
, err
);
1683 * Now we hold the lock and can read the reference without
1684 * fear that its value will change.
1687 if (files_read_raw_ref(&refs
->base
, refname
,
1688 lock
->old_oid
.hash
, referent
, type
)) {
1689 if (errno
== ENOENT
) {
1691 /* Garden variety missing reference. */
1692 strbuf_addf(err
, "unable to resolve reference '%s'",
1697 * Reference is missing, but that's OK. We
1698 * know that there is not a conflict with
1699 * another loose reference because
1700 * (supposing that we are trying to lock
1701 * reference "refs/foo/bar"):
1703 * - We were successfully able to create
1704 * the lockfile refs/foo/bar.lock, so we
1705 * know there cannot be a loose reference
1708 * - We got ENOENT and not EISDIR, so we
1709 * know that there cannot be a loose
1710 * reference named "refs/foo/bar/baz".
1713 } else if (errno
== EISDIR
) {
1715 * There is a directory in the way. It might have
1716 * contained references that have been deleted. If
1717 * we don't require that the reference already
1718 * exists, try to remove the directory so that it
1719 * doesn't cause trouble when we want to rename the
1720 * lockfile into place later.
1723 /* Garden variety missing reference. */
1724 strbuf_addf(err
, "unable to resolve reference '%s'",
1727 } else if (remove_dir_recursively(&ref_file
,
1728 REMOVE_DIR_EMPTY_ONLY
)) {
1729 if (verify_refname_available_dir(
1730 refname
, extras
, skip
,
1731 get_loose_refs(refs
),
1734 * The error message set by
1735 * verify_refname_available() is OK.
1737 ret
= TRANSACTION_NAME_CONFLICT
;
1741 * We can't delete the directory,
1742 * but we also don't know of any
1743 * references that it should
1746 strbuf_addf(err
, "there is a non-empty directory '%s' "
1747 "blocking reference '%s'",
1748 ref_file
.buf
, refname
);
1752 } else if (errno
== EINVAL
&& (*type
& REF_ISBROKEN
)) {
1753 strbuf_addf(err
, "unable to resolve reference '%s': "
1754 "reference broken", refname
);
1757 strbuf_addf(err
, "unable to resolve reference '%s': %s",
1758 refname
, strerror(errno
));
1763 * If the ref did not exist and we are creating it,
1764 * make sure there is no existing packed ref whose
1765 * name begins with our refname, nor a packed ref
1766 * whose name is a proper prefix of our refname.
1768 if (verify_refname_available_dir(
1769 refname
, extras
, skip
,
1770 get_packed_refs(refs
),
1784 strbuf_release(&ref_file
);
1789 * Peel the entry (if possible) and return its new peel_status. If
1790 * repeel is true, re-peel the entry even if there is an old peeled
1791 * value that is already stored in it.
1793 * It is OK to call this function with a packed reference entry that
1794 * might be stale and might even refer to an object that has since
1795 * been garbage-collected. In such a case, if the entry has
1796 * REF_KNOWS_PEELED then leave the status unchanged and return
1797 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.
1799 static enum peel_status
peel_entry(struct ref_entry
*entry
, int repeel
)
1801 enum peel_status status
;
1803 if (entry
->flag
& REF_KNOWS_PEELED
) {
1805 entry
->flag
&= ~REF_KNOWS_PEELED
;
1806 oidclr(&entry
->u
.value
.peeled
);
1808 return is_null_oid(&entry
->u
.value
.peeled
) ?
1809 PEEL_NON_TAG
: PEEL_PEELED
;
1812 if (entry
->flag
& REF_ISBROKEN
)
1814 if (entry
->flag
& REF_ISSYMREF
)
1815 return PEEL_IS_SYMREF
;
1817 status
= peel_object(entry
->u
.value
.oid
.hash
, entry
->u
.value
.peeled
.hash
);
1818 if (status
== PEEL_PEELED
|| status
== PEEL_NON_TAG
)
1819 entry
->flag
|= REF_KNOWS_PEELED
;
1823 static int files_peel_ref(struct ref_store
*ref_store
,
1824 const char *refname
, unsigned char *sha1
)
1826 struct files_ref_store
*refs
=
1827 files_downcast(ref_store
, REF_STORE_READ
| REF_STORE_ODB
,
1830 unsigned char base
[20];
1832 if (current_ref_iter
&& current_ref_iter
->refname
== refname
) {
1833 struct object_id peeled
;
1835 if (ref_iterator_peel(current_ref_iter
, &peeled
))
1837 hashcpy(sha1
, peeled
.hash
);
1841 if (refs_read_ref_full(ref_store
, refname
,
1842 RESOLVE_REF_READING
, base
, &flag
))
1846 * If the reference is packed, read its ref_entry from the
1847 * cache in the hope that we already know its peeled value.
1848 * We only try this optimization on packed references because
1849 * (a) forcing the filling of the loose reference cache could
1850 * be expensive and (b) loose references anyway usually do not
1851 * have REF_KNOWS_PEELED.
1853 if (flag
& REF_ISPACKED
) {
1854 struct ref_entry
*r
= get_packed_ref(refs
, refname
);
1856 if (peel_entry(r
, 0))
1858 hashcpy(sha1
, r
->u
.value
.peeled
.hash
);
1863 return peel_object(base
, sha1
);
1866 struct files_ref_iterator
{
1867 struct ref_iterator base
;
1869 struct packed_ref_cache
*packed_ref_cache
;
1870 struct ref_iterator
*iter0
;
1874 static int files_ref_iterator_advance(struct ref_iterator
*ref_iterator
)
1876 struct files_ref_iterator
*iter
=
1877 (struct files_ref_iterator
*)ref_iterator
;
1880 while ((ok
= ref_iterator_advance(iter
->iter0
)) == ITER_OK
) {
1881 if (iter
->flags
& DO_FOR_EACH_PER_WORKTREE_ONLY
&&
1882 ref_type(iter
->iter0
->refname
) != REF_TYPE_PER_WORKTREE
)
1885 if (!(iter
->flags
& DO_FOR_EACH_INCLUDE_BROKEN
) &&
1886 !ref_resolves_to_object(iter
->iter0
->refname
,
1888 iter
->iter0
->flags
))
1891 iter
->base
.refname
= iter
->iter0
->refname
;
1892 iter
->base
.oid
= iter
->iter0
->oid
;
1893 iter
->base
.flags
= iter
->iter0
->flags
;
1898 if (ref_iterator_abort(ref_iterator
) != ITER_DONE
)
1904 static int files_ref_iterator_peel(struct ref_iterator
*ref_iterator
,
1905 struct object_id
*peeled
)
1907 struct files_ref_iterator
*iter
=
1908 (struct files_ref_iterator
*)ref_iterator
;
1910 return ref_iterator_peel(iter
->iter0
, peeled
);
1913 static int files_ref_iterator_abort(struct ref_iterator
*ref_iterator
)
1915 struct files_ref_iterator
*iter
=
1916 (struct files_ref_iterator
*)ref_iterator
;
1920 ok
= ref_iterator_abort(iter
->iter0
);
1922 release_packed_ref_cache(iter
->packed_ref_cache
);
1923 base_ref_iterator_free(ref_iterator
);
1927 static struct ref_iterator_vtable files_ref_iterator_vtable
= {
1928 files_ref_iterator_advance
,
1929 files_ref_iterator_peel
,
1930 files_ref_iterator_abort
1933 static struct ref_iterator
*files_ref_iterator_begin(
1934 struct ref_store
*ref_store
,
1935 const char *prefix
, unsigned int flags
)
1937 struct files_ref_store
*refs
;
1938 struct ref_dir
*loose_dir
, *packed_dir
;
1939 struct ref_iterator
*loose_iter
, *packed_iter
;
1940 struct files_ref_iterator
*iter
;
1941 struct ref_iterator
*ref_iterator
;
1943 if (ref_paranoia
< 0)
1944 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 0);
1946 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1948 refs
= files_downcast(ref_store
,
1949 REF_STORE_READ
| (ref_paranoia
? 0 : REF_STORE_ODB
),
1950 "ref_iterator_begin");
1952 iter
= xcalloc(1, sizeof(*iter
));
1953 ref_iterator
= &iter
->base
;
1954 base_ref_iterator_init(ref_iterator
, &files_ref_iterator_vtable
);
1957 * We must make sure that all loose refs are read before
1958 * accessing the packed-refs file; this avoids a race
1959 * condition if loose refs are migrated to the packed-refs
1960 * file by a simultaneous process, but our in-memory view is
1961 * from before the migration. We ensure this as follows:
1962 * First, we call prime_ref_dir(), which pre-reads the loose
1963 * references for the subtree into the cache. (If they've
1964 * already been read, that's OK; we only need to guarantee
1965 * that they're read before the packed refs, not *how much*
1966 * before.) After that, we call get_packed_ref_cache(), which
1967 * internally checks whether the packed-ref cache is up to
1968 * date with what is on disk, and re-reads it if not.
1971 loose_dir
= get_loose_refs(refs
);
1973 if (prefix
&& *prefix
)
1974 loose_dir
= find_containing_dir(loose_dir
, prefix
, 0);
1977 prime_ref_dir(loose_dir
);
1978 loose_iter
= cache_ref_iterator_begin(loose_dir
);
1980 /* There's nothing to iterate over. */
1981 loose_iter
= empty_ref_iterator_begin();
1984 iter
->packed_ref_cache
= get_packed_ref_cache(refs
);
1985 acquire_packed_ref_cache(iter
->packed_ref_cache
);
1986 packed_dir
= get_packed_ref_dir(iter
->packed_ref_cache
);
1988 if (prefix
&& *prefix
)
1989 packed_dir
= find_containing_dir(packed_dir
, prefix
, 0);
1992 packed_iter
= cache_ref_iterator_begin(packed_dir
);
1994 /* There's nothing to iterate over. */
1995 packed_iter
= empty_ref_iterator_begin();
1998 iter
->iter0
= overlay_ref_iterator_begin(loose_iter
, packed_iter
);
1999 iter
->flags
= flags
;
2001 return ref_iterator
;
2005 * Verify that the reference locked by lock has the value old_sha1.
2006 * Fail if the reference doesn't exist and mustexist is set. Return 0
2007 * on success. On error, write an error message to err, set errno, and
2008 * return a negative value.
2010 static int verify_lock(struct ref_store
*ref_store
, struct ref_lock
*lock
,
2011 const unsigned char *old_sha1
, int mustexist
,
2016 if (refs_read_ref_full(ref_store
, lock
->ref_name
,
2017 mustexist
? RESOLVE_REF_READING
: 0,
2018 lock
->old_oid
.hash
, NULL
)) {
2020 int save_errno
= errno
;
2021 strbuf_addf(err
, "can't verify ref '%s'", lock
->ref_name
);
2025 oidclr(&lock
->old_oid
);
2029 if (old_sha1
&& hashcmp(lock
->old_oid
.hash
, old_sha1
)) {
2030 strbuf_addf(err
, "ref '%s' is at %s but expected %s",
2032 oid_to_hex(&lock
->old_oid
),
2033 sha1_to_hex(old_sha1
));
2040 static int remove_empty_directories(struct strbuf
*path
)
2043 * we want to create a file but there is a directory there;
2044 * if that is an empty directory (or a directory that contains
2045 * only empty directories), remove them.
2047 return remove_dir_recursively(path
, REMOVE_DIR_EMPTY_ONLY
);
2050 static int create_reflock(const char *path
, void *cb
)
2052 struct lock_file
*lk
= cb
;
2054 return hold_lock_file_for_update(lk
, path
, LOCK_NO_DEREF
) < 0 ? -1 : 0;
2058 * Locks a ref returning the lock on success and NULL on failure.
2059 * On failure errno is set to something meaningful.
2061 static struct ref_lock
*lock_ref_sha1_basic(struct files_ref_store
*refs
,
2062 const char *refname
,
2063 const unsigned char *old_sha1
,
2064 const struct string_list
*extras
,
2065 const struct string_list
*skip
,
2066 unsigned int flags
, int *type
,
2069 struct strbuf ref_file
= STRBUF_INIT
;
2070 struct ref_lock
*lock
;
2072 int mustexist
= (old_sha1
&& !is_null_sha1(old_sha1
));
2073 int resolve_flags
= RESOLVE_REF_NO_RECURSE
;
2076 files_assert_main_repository(refs
, "lock_ref_sha1_basic");
2079 lock
= xcalloc(1, sizeof(struct ref_lock
));
2082 resolve_flags
|= RESOLVE_REF_READING
;
2083 if (flags
& REF_DELETING
)
2084 resolve_flags
|= RESOLVE_REF_ALLOW_BAD_NAME
;
2086 files_ref_path(refs
, &ref_file
, refname
);
2087 resolved
= !!refs_resolve_ref_unsafe(&refs
->base
,
2088 refname
, resolve_flags
,
2089 lock
->old_oid
.hash
, type
);
2090 if (!resolved
&& errno
== EISDIR
) {
2092 * we are trying to lock foo but we used to
2093 * have foo/bar which now does not exist;
2094 * it is normal for the empty directory 'foo'
2097 if (remove_empty_directories(&ref_file
)) {
2099 if (!verify_refname_available_dir(
2100 refname
, extras
, skip
,
2101 get_loose_refs(refs
), err
))
2102 strbuf_addf(err
, "there are still refs under '%s'",
2106 resolved
= !!refs_resolve_ref_unsafe(&refs
->base
,
2107 refname
, resolve_flags
,
2108 lock
->old_oid
.hash
, type
);
2112 if (last_errno
!= ENOTDIR
||
2113 !verify_refname_available_dir(
2114 refname
, extras
, skip
,
2115 get_loose_refs(refs
), err
))
2116 strbuf_addf(err
, "unable to resolve reference '%s': %s",
2117 refname
, strerror(last_errno
));
2123 * If the ref did not exist and we are creating it, make sure
2124 * there is no existing packed ref whose name begins with our
2125 * refname, nor a packed ref whose name is a proper prefix of
2128 if (is_null_oid(&lock
->old_oid
) &&
2129 verify_refname_available_dir(refname
, extras
, skip
,
2130 get_packed_refs(refs
),
2132 last_errno
= ENOTDIR
;
2136 lock
->lk
= xcalloc(1, sizeof(struct lock_file
));
2138 lock
->ref_name
= xstrdup(refname
);
2140 if (raceproof_create_file(ref_file
.buf
, create_reflock
, lock
->lk
)) {
2142 unable_to_lock_message(ref_file
.buf
, errno
, err
);
2146 if (verify_lock(&refs
->base
, lock
, old_sha1
, mustexist
, err
)) {
2157 strbuf_release(&ref_file
);
2163 * Write an entry to the packed-refs file for the specified refname.
2164 * If peeled is non-NULL, write it as the entry's peeled value.
2166 static void write_packed_entry(FILE *fh
, char *refname
, unsigned char *sha1
,
2167 unsigned char *peeled
)
2169 fprintf_or_die(fh
, "%s %s\n", sha1_to_hex(sha1
), refname
);
2171 fprintf_or_die(fh
, "^%s\n", sha1_to_hex(peeled
));
2175 * An each_ref_entry_fn that writes the entry to a packed-refs file.
2177 static int write_packed_entry_fn(struct ref_entry
*entry
, void *cb_data
)
2179 enum peel_status peel_status
= peel_entry(entry
, 0);
2181 if (peel_status
!= PEEL_PEELED
&& peel_status
!= PEEL_NON_TAG
)
2182 error("internal error: %s is not a valid packed reference!",
2184 write_packed_entry(cb_data
, entry
->name
, entry
->u
.value
.oid
.hash
,
2185 peel_status
== PEEL_PEELED
?
2186 entry
->u
.value
.peeled
.hash
: NULL
);
2191 * Lock the packed-refs file for writing. Flags is passed to
2192 * hold_lock_file_for_update(). Return 0 on success. On errors, set
2193 * errno appropriately and return a nonzero value.
2195 static int lock_packed_refs(struct files_ref_store
*refs
, int flags
)
2197 static int timeout_configured
= 0;
2198 static int timeout_value
= 1000;
2199 struct packed_ref_cache
*packed_ref_cache
;
2201 files_assert_main_repository(refs
, "lock_packed_refs");
2203 if (!timeout_configured
) {
2204 git_config_get_int("core.packedrefstimeout", &timeout_value
);
2205 timeout_configured
= 1;
2208 if (hold_lock_file_for_update_timeout(
2209 &packlock
, files_packed_refs_path(refs
),
2210 flags
, timeout_value
) < 0)
2213 * Get the current packed-refs while holding the lock. If the
2214 * packed-refs file has been modified since we last read it,
2215 * this will automatically invalidate the cache and re-read
2216 * the packed-refs file.
2218 packed_ref_cache
= get_packed_ref_cache(refs
);
2219 packed_ref_cache
->lock
= &packlock
;
2220 /* Increment the reference count to prevent it from being freed: */
2221 acquire_packed_ref_cache(packed_ref_cache
);
2226 * Write the current version of the packed refs cache from memory to
2227 * disk. The packed-refs file must already be locked for writing (see
2228 * lock_packed_refs()). Return zero on success. On errors, set errno
2229 * and return a nonzero value
2231 static int commit_packed_refs(struct files_ref_store
*refs
)
2233 struct packed_ref_cache
*packed_ref_cache
=
2234 get_packed_ref_cache(refs
);
2239 files_assert_main_repository(refs
, "commit_packed_refs");
2241 if (!packed_ref_cache
->lock
)
2242 die("internal error: packed-refs not locked");
2244 out
= fdopen_lock_file(packed_ref_cache
->lock
, "w");
2246 die_errno("unable to fdopen packed-refs descriptor");
2248 fprintf_or_die(out
, "%s", PACKED_REFS_HEADER
);
2249 do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache
),
2250 0, write_packed_entry_fn
, out
);
2252 if (commit_lock_file(packed_ref_cache
->lock
)) {
2256 packed_ref_cache
->lock
= NULL
;
2257 release_packed_ref_cache(packed_ref_cache
);
2263 * Rollback the lockfile for the packed-refs file, and discard the
2264 * in-memory packed reference cache. (The packed-refs file will be
2265 * read anew if it is needed again after this function is called.)
2267 static void rollback_packed_refs(struct files_ref_store
*refs
)
2269 struct packed_ref_cache
*packed_ref_cache
=
2270 get_packed_ref_cache(refs
);
2272 files_assert_main_repository(refs
, "rollback_packed_refs");
2274 if (!packed_ref_cache
->lock
)
2275 die("internal error: packed-refs not locked");
2276 rollback_lock_file(packed_ref_cache
->lock
);
2277 packed_ref_cache
->lock
= NULL
;
2278 release_packed_ref_cache(packed_ref_cache
);
2279 clear_packed_ref_cache(refs
);
2282 struct ref_to_prune
{
2283 struct ref_to_prune
*next
;
2284 unsigned char sha1
[20];
2285 char name
[FLEX_ARRAY
];
2288 struct pack_refs_cb_data
{
2290 struct ref_dir
*packed_refs
;
2291 struct ref_to_prune
*ref_to_prune
;
2295 * An each_ref_entry_fn that is run over loose references only. If
2296 * the loose reference can be packed, add an entry in the packed ref
2297 * cache. If the reference should be pruned, also add it to
2298 * ref_to_prune in the pack_refs_cb_data.
2300 static int pack_if_possible_fn(struct ref_entry
*entry
, void *cb_data
)
2302 struct pack_refs_cb_data
*cb
= cb_data
;
2303 enum peel_status peel_status
;
2304 struct ref_entry
*packed_entry
;
2305 int is_tag_ref
= starts_with(entry
->name
, "refs/tags/");
2307 /* Do not pack per-worktree refs: */
2308 if (ref_type(entry
->name
) != REF_TYPE_NORMAL
)
2311 /* ALWAYS pack tags */
2312 if (!(cb
->flags
& PACK_REFS_ALL
) && !is_tag_ref
)
2315 /* Do not pack symbolic or broken refs: */
2316 if ((entry
->flag
& REF_ISSYMREF
) || !entry_resolves_to_object(entry
))
2319 /* Add a packed ref cache entry equivalent to the loose entry. */
2320 peel_status
= peel_entry(entry
, 1);
2321 if (peel_status
!= PEEL_PEELED
&& peel_status
!= PEEL_NON_TAG
)
2322 die("internal error peeling reference %s (%s)",
2323 entry
->name
, oid_to_hex(&entry
->u
.value
.oid
));
2324 packed_entry
= find_ref(cb
->packed_refs
, entry
->name
);
2326 /* Overwrite existing packed entry with info from loose entry */
2327 packed_entry
->flag
= REF_ISPACKED
| REF_KNOWS_PEELED
;
2328 oidcpy(&packed_entry
->u
.value
.oid
, &entry
->u
.value
.oid
);
2330 packed_entry
= create_ref_entry(entry
->name
, entry
->u
.value
.oid
.hash
,
2331 REF_ISPACKED
| REF_KNOWS_PEELED
, 0);
2332 add_ref(cb
->packed_refs
, packed_entry
);
2334 oidcpy(&packed_entry
->u
.value
.peeled
, &entry
->u
.value
.peeled
);
2336 /* Schedule the loose reference for pruning if requested. */
2337 if ((cb
->flags
& PACK_REFS_PRUNE
)) {
2338 struct ref_to_prune
*n
;
2339 FLEX_ALLOC_STR(n
, name
, entry
->name
);
2340 hashcpy(n
->sha1
, entry
->u
.value
.oid
.hash
);
2341 n
->next
= cb
->ref_to_prune
;
2342 cb
->ref_to_prune
= n
;
2348 REMOVE_EMPTY_PARENTS_REF
= 0x01,
2349 REMOVE_EMPTY_PARENTS_REFLOG
= 0x02
2353 * Remove empty parent directories associated with the specified
2354 * reference and/or its reflog, but spare [logs/]refs/ and immediate
2355 * subdirs. flags is a combination of REMOVE_EMPTY_PARENTS_REF and/or
2356 * REMOVE_EMPTY_PARENTS_REFLOG.
2358 static void try_remove_empty_parents(struct files_ref_store
*refs
,
2359 const char *refname
,
2362 struct strbuf buf
= STRBUF_INIT
;
2363 struct strbuf sb
= STRBUF_INIT
;
2367 strbuf_addstr(&buf
, refname
);
2369 for (i
= 0; i
< 2; i
++) { /* refs/{heads,tags,...}/ */
2370 while (*p
&& *p
!= '/')
2372 /* tolerate duplicate slashes; see check_refname_format() */
2376 q
= buf
.buf
+ buf
.len
;
2377 while (flags
& (REMOVE_EMPTY_PARENTS_REF
| REMOVE_EMPTY_PARENTS_REFLOG
)) {
2378 while (q
> p
&& *q
!= '/')
2380 while (q
> p
&& *(q
-1) == '/')
2384 strbuf_setlen(&buf
, q
- buf
.buf
);
2387 files_ref_path(refs
, &sb
, buf
.buf
);
2388 if ((flags
& REMOVE_EMPTY_PARENTS_REF
) && rmdir(sb
.buf
))
2389 flags
&= ~REMOVE_EMPTY_PARENTS_REF
;
2392 files_reflog_path(refs
, &sb
, buf
.buf
);
2393 if ((flags
& REMOVE_EMPTY_PARENTS_REFLOG
) && rmdir(sb
.buf
))
2394 flags
&= ~REMOVE_EMPTY_PARENTS_REFLOG
;
2396 strbuf_release(&buf
);
2397 strbuf_release(&sb
);
2400 /* make sure nobody touched the ref, and unlink */
2401 static void prune_ref(struct files_ref_store
*refs
, struct ref_to_prune
*r
)
2403 struct ref_transaction
*transaction
;
2404 struct strbuf err
= STRBUF_INIT
;
2406 if (check_refname_format(r
->name
, 0))
2409 transaction
= ref_store_transaction_begin(&refs
->base
, &err
);
2411 ref_transaction_delete(transaction
, r
->name
, r
->sha1
,
2412 REF_ISPRUNING
| REF_NODEREF
, NULL
, &err
) ||
2413 ref_transaction_commit(transaction
, &err
)) {
2414 ref_transaction_free(transaction
);
2415 error("%s", err
.buf
);
2416 strbuf_release(&err
);
2419 ref_transaction_free(transaction
);
2420 strbuf_release(&err
);
2423 static void prune_refs(struct files_ref_store
*refs
, struct ref_to_prune
*r
)
2431 static int files_pack_refs(struct ref_store
*ref_store
, unsigned int flags
)
2433 struct files_ref_store
*refs
=
2434 files_downcast(ref_store
, REF_STORE_WRITE
| REF_STORE_ODB
,
2436 struct pack_refs_cb_data cbdata
;
2438 memset(&cbdata
, 0, sizeof(cbdata
));
2439 cbdata
.flags
= flags
;
2441 lock_packed_refs(refs
, LOCK_DIE_ON_ERROR
);
2442 cbdata
.packed_refs
= get_packed_refs(refs
);
2444 do_for_each_entry_in_dir(get_loose_refs(refs
), 0,
2445 pack_if_possible_fn
, &cbdata
);
2447 if (commit_packed_refs(refs
))
2448 die_errno("unable to overwrite old ref-pack file");
2450 prune_refs(refs
, cbdata
.ref_to_prune
);
2455 * Rewrite the packed-refs file, omitting any refs listed in
2456 * 'refnames'. On error, leave packed-refs unchanged, write an error
2457 * message to 'err', and return a nonzero value.
2459 * The refs in 'refnames' needn't be sorted. `err` must not be NULL.
2461 static int repack_without_refs(struct files_ref_store
*refs
,
2462 struct string_list
*refnames
, struct strbuf
*err
)
2464 struct ref_dir
*packed
;
2465 struct string_list_item
*refname
;
2466 int ret
, needs_repacking
= 0, removed
= 0;
2468 files_assert_main_repository(refs
, "repack_without_refs");
2471 /* Look for a packed ref */
2472 for_each_string_list_item(refname
, refnames
) {
2473 if (get_packed_ref(refs
, refname
->string
)) {
2474 needs_repacking
= 1;
2479 /* Avoid locking if we have nothing to do */
2480 if (!needs_repacking
)
2481 return 0; /* no refname exists in packed refs */
2483 if (lock_packed_refs(refs
, 0)) {
2484 unable_to_lock_message(files_packed_refs_path(refs
), errno
, err
);
2487 packed
= get_packed_refs(refs
);
2489 /* Remove refnames from the cache */
2490 for_each_string_list_item(refname
, refnames
)
2491 if (remove_entry(packed
, refname
->string
) != -1)
2495 * All packed entries disappeared while we were
2496 * acquiring the lock.
2498 rollback_packed_refs(refs
);
2502 /* Write what remains */
2503 ret
= commit_packed_refs(refs
);
2505 strbuf_addf(err
, "unable to overwrite old ref-pack file: %s",
2510 static int files_delete_refs(struct ref_store
*ref_store
,
2511 struct string_list
*refnames
, unsigned int flags
)
2513 struct files_ref_store
*refs
=
2514 files_downcast(ref_store
, REF_STORE_WRITE
, "delete_refs");
2515 struct strbuf err
= STRBUF_INIT
;
2521 result
= repack_without_refs(refs
, refnames
, &err
);
2524 * If we failed to rewrite the packed-refs file, then
2525 * it is unsafe to try to remove loose refs, because
2526 * doing so might expose an obsolete packed value for
2527 * a reference that might even point at an object that
2528 * has been garbage collected.
2530 if (refnames
->nr
== 1)
2531 error(_("could not delete reference %s: %s"),
2532 refnames
->items
[0].string
, err
.buf
);
2534 error(_("could not delete references: %s"), err
.buf
);
2539 for (i
= 0; i
< refnames
->nr
; i
++) {
2540 const char *refname
= refnames
->items
[i
].string
;
2542 if (refs_delete_ref(&refs
->base
, NULL
, refname
, NULL
, flags
))
2543 result
|= error(_("could not remove reference %s"), refname
);
2547 strbuf_release(&err
);
2552 * People using contrib's git-new-workdir have .git/logs/refs ->
2553 * /some/other/path/.git/logs/refs, and that may live on another device.
2555 * IOW, to avoid cross device rename errors, the temporary renamed log must
2556 * live into logs/refs.
2558 #define TMP_RENAMED_LOG "refs/.tmp-renamed-log"
2561 const char *tmp_renamed_log
;
2565 static int rename_tmp_log_callback(const char *path
, void *cb_data
)
2567 struct rename_cb
*cb
= cb_data
;
2569 if (rename(cb
->tmp_renamed_log
, path
)) {
2571 * rename(a, b) when b is an existing directory ought
2572 * to result in ISDIR, but Solaris 5.8 gives ENOTDIR.
2573 * Sheesh. Record the true errno for error reporting,
2574 * but report EISDIR to raceproof_create_file() so
2575 * that it knows to retry.
2577 cb
->true_errno
= errno
;
2578 if (errno
== ENOTDIR
)
2586 static int rename_tmp_log(struct files_ref_store
*refs
, const char *newrefname
)
2588 struct strbuf path
= STRBUF_INIT
;
2589 struct strbuf tmp
= STRBUF_INIT
;
2590 struct rename_cb cb
;
2593 files_reflog_path(refs
, &path
, newrefname
);
2594 files_reflog_path(refs
, &tmp
, TMP_RENAMED_LOG
);
2595 cb
.tmp_renamed_log
= tmp
.buf
;
2596 ret
= raceproof_create_file(path
.buf
, rename_tmp_log_callback
, &cb
);
2598 if (errno
== EISDIR
)
2599 error("directory not empty: %s", path
.buf
);
2601 error("unable to move logfile %s to %s: %s",
2603 strerror(cb
.true_errno
));
2606 strbuf_release(&path
);
2607 strbuf_release(&tmp
);
2611 static int files_verify_refname_available(struct ref_store
*ref_store
,
2612 const char *newname
,
2613 const struct string_list
*extras
,
2614 const struct string_list
*skip
,
2617 struct files_ref_store
*refs
=
2618 files_downcast(ref_store
, REF_STORE_READ
, "verify_refname_available");
2619 struct ref_dir
*packed_refs
= get_packed_refs(refs
);
2620 struct ref_dir
*loose_refs
= get_loose_refs(refs
);
2622 if (verify_refname_available_dir(newname
, extras
, skip
,
2623 packed_refs
, err
) ||
2624 verify_refname_available_dir(newname
, extras
, skip
,
2631 static int write_ref_to_lockfile(struct ref_lock
*lock
,
2632 const unsigned char *sha1
, struct strbuf
*err
);
2633 static int commit_ref_update(struct files_ref_store
*refs
,
2634 struct ref_lock
*lock
,
2635 const unsigned char *sha1
, const char *logmsg
,
2636 struct strbuf
*err
);
2638 static int files_rename_ref(struct ref_store
*ref_store
,
2639 const char *oldrefname
, const char *newrefname
,
2642 struct files_ref_store
*refs
=
2643 files_downcast(ref_store
, REF_STORE_WRITE
, "rename_ref");
2644 unsigned char sha1
[20], orig_sha1
[20];
2645 int flag
= 0, logmoved
= 0;
2646 struct ref_lock
*lock
;
2647 struct stat loginfo
;
2648 struct strbuf sb_oldref
= STRBUF_INIT
;
2649 struct strbuf sb_newref
= STRBUF_INIT
;
2650 struct strbuf tmp_renamed_log
= STRBUF_INIT
;
2652 struct strbuf err
= STRBUF_INIT
;
2654 files_reflog_path(refs
, &sb_oldref
, oldrefname
);
2655 files_reflog_path(refs
, &sb_newref
, newrefname
);
2656 files_reflog_path(refs
, &tmp_renamed_log
, TMP_RENAMED_LOG
);
2658 log
= !lstat(sb_oldref
.buf
, &loginfo
);
2659 if (log
&& S_ISLNK(loginfo
.st_mode
)) {
2660 ret
= error("reflog for %s is a symlink", oldrefname
);
2664 if (!refs_resolve_ref_unsafe(&refs
->base
, oldrefname
,
2665 RESOLVE_REF_READING
| RESOLVE_REF_NO_RECURSE
,
2666 orig_sha1
, &flag
)) {
2667 ret
= error("refname %s not found", oldrefname
);
2671 if (flag
& REF_ISSYMREF
) {
2672 ret
= error("refname %s is a symbolic ref, renaming it is not supported",
2676 if (!refs_rename_ref_available(&refs
->base
, oldrefname
, newrefname
)) {
2681 if (log
&& rename(sb_oldref
.buf
, tmp_renamed_log
.buf
)) {
2682 ret
= error("unable to move logfile logs/%s to logs/"TMP_RENAMED_LOG
": %s",
2683 oldrefname
, strerror(errno
));
2687 if (refs_delete_ref(&refs
->base
, logmsg
, oldrefname
,
2688 orig_sha1
, REF_NODEREF
)) {
2689 error("unable to delete old %s", oldrefname
);
2694 * Since we are doing a shallow lookup, sha1 is not the
2695 * correct value to pass to delete_ref as old_sha1. But that
2696 * doesn't matter, because an old_sha1 check wouldn't add to
2697 * the safety anyway; we want to delete the reference whatever
2698 * its current value.
2700 if (!refs_read_ref_full(&refs
->base
, newrefname
,
2701 RESOLVE_REF_READING
| RESOLVE_REF_NO_RECURSE
,
2703 refs_delete_ref(&refs
->base
, NULL
, newrefname
,
2704 NULL
, REF_NODEREF
)) {
2705 if (errno
== EISDIR
) {
2706 struct strbuf path
= STRBUF_INIT
;
2709 files_ref_path(refs
, &path
, newrefname
);
2710 result
= remove_empty_directories(&path
);
2711 strbuf_release(&path
);
2714 error("Directory not empty: %s", newrefname
);
2718 error("unable to delete existing %s", newrefname
);
2723 if (log
&& rename_tmp_log(refs
, newrefname
))
2728 lock
= lock_ref_sha1_basic(refs
, newrefname
, NULL
, NULL
, NULL
,
2729 REF_NODEREF
, NULL
, &err
);
2731 error("unable to rename '%s' to '%s': %s", oldrefname
, newrefname
, err
.buf
);
2732 strbuf_release(&err
);
2735 hashcpy(lock
->old_oid
.hash
, orig_sha1
);
2737 if (write_ref_to_lockfile(lock
, orig_sha1
, &err
) ||
2738 commit_ref_update(refs
, lock
, orig_sha1
, logmsg
, &err
)) {
2739 error("unable to write current sha1 into %s: %s", newrefname
, err
.buf
);
2740 strbuf_release(&err
);
2748 lock
= lock_ref_sha1_basic(refs
, oldrefname
, NULL
, NULL
, NULL
,
2749 REF_NODEREF
, NULL
, &err
);
2751 error("unable to lock %s for rollback: %s", oldrefname
, err
.buf
);
2752 strbuf_release(&err
);
2756 flag
= log_all_ref_updates
;
2757 log_all_ref_updates
= LOG_REFS_NONE
;
2758 if (write_ref_to_lockfile(lock
, orig_sha1
, &err
) ||
2759 commit_ref_update(refs
, lock
, orig_sha1
, NULL
, &err
)) {
2760 error("unable to write current sha1 into %s: %s", oldrefname
, err
.buf
);
2761 strbuf_release(&err
);
2763 log_all_ref_updates
= flag
;
2766 if (logmoved
&& rename(sb_newref
.buf
, sb_oldref
.buf
))
2767 error("unable to restore logfile %s from %s: %s",
2768 oldrefname
, newrefname
, strerror(errno
));
2769 if (!logmoved
&& log
&&
2770 rename(tmp_renamed_log
.buf
, sb_oldref
.buf
))
2771 error("unable to restore logfile %s from logs/"TMP_RENAMED_LOG
": %s",
2772 oldrefname
, strerror(errno
));
2775 strbuf_release(&sb_newref
);
2776 strbuf_release(&sb_oldref
);
2777 strbuf_release(&tmp_renamed_log
);
2782 static int close_ref(struct ref_lock
*lock
)
2784 if (close_lock_file(lock
->lk
))
2789 static int commit_ref(struct ref_lock
*lock
)
2791 char *path
= get_locked_file_path(lock
->lk
);
2794 if (!lstat(path
, &st
) && S_ISDIR(st
.st_mode
)) {
2796 * There is a directory at the path we want to rename
2797 * the lockfile to. Hopefully it is empty; try to
2800 size_t len
= strlen(path
);
2801 struct strbuf sb_path
= STRBUF_INIT
;
2803 strbuf_attach(&sb_path
, path
, len
, len
);
2806 * If this fails, commit_lock_file() will also fail
2807 * and will report the problem.
2809 remove_empty_directories(&sb_path
);
2810 strbuf_release(&sb_path
);
2815 if (commit_lock_file(lock
->lk
))
2820 static int open_or_create_logfile(const char *path
, void *cb
)
2824 *fd
= open(path
, O_APPEND
| O_WRONLY
| O_CREAT
, 0666);
2825 return (*fd
< 0) ? -1 : 0;
2829 * Create a reflog for a ref. If force_create = 0, only create the
2830 * reflog for certain refs (those for which should_autocreate_reflog
2831 * returns non-zero). Otherwise, create it regardless of the reference
2832 * name. If the logfile already existed or was created, return 0 and
2833 * set *logfd to the file descriptor opened for appending to the file.
2834 * If no logfile exists and we decided not to create one, return 0 and
2835 * set *logfd to -1. On failure, fill in *err, set *logfd to -1, and
2838 static int log_ref_setup(struct files_ref_store
*refs
,
2839 const char *refname
, int force_create
,
2840 int *logfd
, struct strbuf
*err
)
2842 struct strbuf logfile_sb
= STRBUF_INIT
;
2845 files_reflog_path(refs
, &logfile_sb
, refname
);
2846 logfile
= strbuf_detach(&logfile_sb
, NULL
);
2848 if (force_create
|| should_autocreate_reflog(refname
)) {
2849 if (raceproof_create_file(logfile
, open_or_create_logfile
, logfd
)) {
2850 if (errno
== ENOENT
)
2851 strbuf_addf(err
, "unable to create directory for '%s': "
2852 "%s", logfile
, strerror(errno
));
2853 else if (errno
== EISDIR
)
2854 strbuf_addf(err
, "there are still logs under '%s'",
2857 strbuf_addf(err
, "unable to append to '%s': %s",
2858 logfile
, strerror(errno
));
2863 *logfd
= open(logfile
, O_APPEND
| O_WRONLY
, 0666);
2865 if (errno
== ENOENT
|| errno
== EISDIR
) {
2867 * The logfile doesn't already exist,
2868 * but that is not an error; it only
2869 * means that we won't write log
2874 strbuf_addf(err
, "unable to append to '%s': %s",
2875 logfile
, strerror(errno
));
2882 adjust_shared_perm(logfile
);
2892 static int files_create_reflog(struct ref_store
*ref_store
,
2893 const char *refname
, int force_create
,
2896 struct files_ref_store
*refs
=
2897 files_downcast(ref_store
, REF_STORE_WRITE
, "create_reflog");
2900 if (log_ref_setup(refs
, refname
, force_create
, &fd
, err
))
2909 static int log_ref_write_fd(int fd
, const unsigned char *old_sha1
,
2910 const unsigned char *new_sha1
,
2911 const char *committer
, const char *msg
)
2913 int msglen
, written
;
2914 unsigned maxlen
, len
;
2917 msglen
= msg
? strlen(msg
) : 0;
2918 maxlen
= strlen(committer
) + msglen
+ 100;
2919 logrec
= xmalloc(maxlen
);
2920 len
= xsnprintf(logrec
, maxlen
, "%s %s %s\n",
2921 sha1_to_hex(old_sha1
),
2922 sha1_to_hex(new_sha1
),
2925 len
+= copy_reflog_msg(logrec
+ len
- 1, msg
) - 1;
2927 written
= len
<= maxlen
? write_in_full(fd
, logrec
, len
) : -1;
2935 static int files_log_ref_write(struct files_ref_store
*refs
,
2936 const char *refname
, const unsigned char *old_sha1
,
2937 const unsigned char *new_sha1
, const char *msg
,
2938 int flags
, struct strbuf
*err
)
2942 if (log_all_ref_updates
== LOG_REFS_UNSET
)
2943 log_all_ref_updates
= is_bare_repository() ? LOG_REFS_NONE
: LOG_REFS_NORMAL
;
2945 result
= log_ref_setup(refs
, refname
,
2946 flags
& REF_FORCE_CREATE_REFLOG
,
2954 result
= log_ref_write_fd(logfd
, old_sha1
, new_sha1
,
2955 git_committer_info(0), msg
);
2957 struct strbuf sb
= STRBUF_INIT
;
2958 int save_errno
= errno
;
2960 files_reflog_path(refs
, &sb
, refname
);
2961 strbuf_addf(err
, "unable to append to '%s': %s",
2962 sb
.buf
, strerror(save_errno
));
2963 strbuf_release(&sb
);
2968 struct strbuf sb
= STRBUF_INIT
;
2969 int save_errno
= errno
;
2971 files_reflog_path(refs
, &sb
, refname
);
2972 strbuf_addf(err
, "unable to append to '%s': %s",
2973 sb
.buf
, strerror(save_errno
));
2974 strbuf_release(&sb
);
2981 * Write sha1 into the open lockfile, then close the lockfile. On
2982 * errors, rollback the lockfile, fill in *err and
2985 static int write_ref_to_lockfile(struct ref_lock
*lock
,
2986 const unsigned char *sha1
, struct strbuf
*err
)
2988 static char term
= '\n';
2992 o
= parse_object(sha1
);
2995 "trying to write ref '%s' with nonexistent object %s",
2996 lock
->ref_name
, sha1_to_hex(sha1
));
3000 if (o
->type
!= OBJ_COMMIT
&& is_branch(lock
->ref_name
)) {
3002 "trying to write non-commit object %s to branch '%s'",
3003 sha1_to_hex(sha1
), lock
->ref_name
);
3007 fd
= get_lock_file_fd(lock
->lk
);
3008 if (write_in_full(fd
, sha1_to_hex(sha1
), 40) != 40 ||
3009 write_in_full(fd
, &term
, 1) != 1 ||
3010 close_ref(lock
) < 0) {
3012 "couldn't write '%s'", get_lock_file_path(lock
->lk
));
3020 * Commit a change to a loose reference that has already been written
3021 * to the loose reference lockfile. Also update the reflogs if
3022 * necessary, using the specified lockmsg (which can be NULL).
3024 static int commit_ref_update(struct files_ref_store
*refs
,
3025 struct ref_lock
*lock
,
3026 const unsigned char *sha1
, const char *logmsg
,
3029 files_assert_main_repository(refs
, "commit_ref_update");
3031 clear_loose_ref_cache(refs
);
3032 if (files_log_ref_write(refs
, lock
->ref_name
,
3033 lock
->old_oid
.hash
, sha1
,
3035 char *old_msg
= strbuf_detach(err
, NULL
);
3036 strbuf_addf(err
, "cannot update the ref '%s': %s",
3037 lock
->ref_name
, old_msg
);
3043 if (strcmp(lock
->ref_name
, "HEAD") != 0) {
3045 * Special hack: If a branch is updated directly and HEAD
3046 * points to it (may happen on the remote side of a push
3047 * for example) then logically the HEAD reflog should be
3049 * A generic solution implies reverse symref information,
3050 * but finding all symrefs pointing to the given branch
3051 * would be rather costly for this rare event (the direct
3052 * update of a branch) to be worth it. So let's cheat and
3053 * check with HEAD only which should cover 99% of all usage
3054 * scenarios (even 100% of the default ones).
3056 unsigned char head_sha1
[20];
3058 const char *head_ref
;
3060 head_ref
= refs_resolve_ref_unsafe(&refs
->base
, "HEAD",
3061 RESOLVE_REF_READING
,
3062 head_sha1
, &head_flag
);
3063 if (head_ref
&& (head_flag
& REF_ISSYMREF
) &&
3064 !strcmp(head_ref
, lock
->ref_name
)) {
3065 struct strbuf log_err
= STRBUF_INIT
;
3066 if (files_log_ref_write(refs
, "HEAD",
3067 lock
->old_oid
.hash
, sha1
,
3068 logmsg
, 0, &log_err
)) {
3069 error("%s", log_err
.buf
);
3070 strbuf_release(&log_err
);
3075 if (commit_ref(lock
)) {
3076 strbuf_addf(err
, "couldn't set '%s'", lock
->ref_name
);
3085 static int create_ref_symlink(struct ref_lock
*lock
, const char *target
)
3088 #ifndef NO_SYMLINK_HEAD
3089 char *ref_path
= get_locked_file_path(lock
->lk
);
3091 ret
= symlink(target
, ref_path
);
3095 fprintf(stderr
, "no symlink - falling back to symbolic ref\n");
3100 static void update_symref_reflog(struct files_ref_store
*refs
,
3101 struct ref_lock
*lock
, const char *refname
,
3102 const char *target
, const char *logmsg
)
3104 struct strbuf err
= STRBUF_INIT
;
3105 unsigned char new_sha1
[20];
3107 !refs_read_ref_full(&refs
->base
, target
,
3108 RESOLVE_REF_READING
, new_sha1
, NULL
) &&
3109 files_log_ref_write(refs
, refname
, lock
->old_oid
.hash
,
3110 new_sha1
, logmsg
, 0, &err
)) {
3111 error("%s", err
.buf
);
3112 strbuf_release(&err
);
3116 static int create_symref_locked(struct files_ref_store
*refs
,
3117 struct ref_lock
*lock
, const char *refname
,
3118 const char *target
, const char *logmsg
)
3120 if (prefer_symlink_refs
&& !create_ref_symlink(lock
, target
)) {
3121 update_symref_reflog(refs
, lock
, refname
, target
, logmsg
);
3125 if (!fdopen_lock_file(lock
->lk
, "w"))
3126 return error("unable to fdopen %s: %s",
3127 lock
->lk
->tempfile
.filename
.buf
, strerror(errno
));
3129 update_symref_reflog(refs
, lock
, refname
, target
, logmsg
);
3131 /* no error check; commit_ref will check ferror */
3132 fprintf(lock
->lk
->tempfile
.fp
, "ref: %s\n", target
);
3133 if (commit_ref(lock
) < 0)
3134 return error("unable to write symref for %s: %s", refname
,
3139 static int files_create_symref(struct ref_store
*ref_store
,
3140 const char *refname
, const char *target
,
3143 struct files_ref_store
*refs
=
3144 files_downcast(ref_store
, REF_STORE_WRITE
, "create_symref");
3145 struct strbuf err
= STRBUF_INIT
;
3146 struct ref_lock
*lock
;
3149 lock
= lock_ref_sha1_basic(refs
, refname
, NULL
,
3150 NULL
, NULL
, REF_NODEREF
, NULL
,
3153 error("%s", err
.buf
);
3154 strbuf_release(&err
);
3158 ret
= create_symref_locked(refs
, lock
, refname
, target
, logmsg
);
3163 int set_worktree_head_symref(const char *gitdir
, const char *target
, const char *logmsg
)
3166 * FIXME: this obviously will not work well for future refs
3167 * backends. This function needs to die.
3169 struct files_ref_store
*refs
=
3170 files_downcast(get_main_ref_store(),
3174 static struct lock_file head_lock
;
3175 struct ref_lock
*lock
;
3176 struct strbuf head_path
= STRBUF_INIT
;
3177 const char *head_rel
;
3180 strbuf_addf(&head_path
, "%s/HEAD", absolute_path(gitdir
));
3181 if (hold_lock_file_for_update(&head_lock
, head_path
.buf
,
3182 LOCK_NO_DEREF
) < 0) {
3183 struct strbuf err
= STRBUF_INIT
;
3184 unable_to_lock_message(head_path
.buf
, errno
, &err
);
3185 error("%s", err
.buf
);
3186 strbuf_release(&err
);
3187 strbuf_release(&head_path
);
3191 /* head_rel will be "HEAD" for the main tree, "worktrees/wt/HEAD" for
3193 head_rel
= remove_leading_path(head_path
.buf
,
3194 absolute_path(get_git_common_dir()));
3195 /* to make use of create_symref_locked(), initialize ref_lock */
3196 lock
= xcalloc(1, sizeof(struct ref_lock
));
3197 lock
->lk
= &head_lock
;
3198 lock
->ref_name
= xstrdup(head_rel
);
3200 ret
= create_symref_locked(refs
, lock
, head_rel
, target
, logmsg
);
3202 unlock_ref(lock
); /* will free lock */
3203 strbuf_release(&head_path
);
3207 static int files_reflog_exists(struct ref_store
*ref_store
,
3208 const char *refname
)
3210 struct files_ref_store
*refs
=
3211 files_downcast(ref_store
, REF_STORE_READ
, "reflog_exists");
3212 struct strbuf sb
= STRBUF_INIT
;
3216 files_reflog_path(refs
, &sb
, refname
);
3217 ret
= !lstat(sb
.buf
, &st
) && S_ISREG(st
.st_mode
);
3218 strbuf_release(&sb
);
3222 static int files_delete_reflog(struct ref_store
*ref_store
,
3223 const char *refname
)
3225 struct files_ref_store
*refs
=
3226 files_downcast(ref_store
, REF_STORE_WRITE
, "delete_reflog");
3227 struct strbuf sb
= STRBUF_INIT
;
3230 files_reflog_path(refs
, &sb
, refname
);
3231 ret
= remove_path(sb
.buf
);
3232 strbuf_release(&sb
);
3236 static int show_one_reflog_ent(struct strbuf
*sb
, each_reflog_ent_fn fn
, void *cb_data
)
3238 struct object_id ooid
, noid
;
3239 char *email_end
, *message
;
3240 unsigned long timestamp
;
3242 const char *p
= sb
->buf
;
3244 /* old SP new SP name <email> SP time TAB msg LF */
3245 if (!sb
->len
|| sb
->buf
[sb
->len
- 1] != '\n' ||
3246 parse_oid_hex(p
, &ooid
, &p
) || *p
++ != ' ' ||
3247 parse_oid_hex(p
, &noid
, &p
) || *p
++ != ' ' ||
3248 !(email_end
= strchr(p
, '>')) ||
3249 email_end
[1] != ' ' ||
3250 !(timestamp
= parse_timestamp(email_end
+ 2, &message
, 10)) ||
3251 !message
|| message
[0] != ' ' ||
3252 (message
[1] != '+' && message
[1] != '-') ||
3253 !isdigit(message
[2]) || !isdigit(message
[3]) ||
3254 !isdigit(message
[4]) || !isdigit(message
[5]))
3255 return 0; /* corrupt? */
3256 email_end
[1] = '\0';
3257 tz
= strtol(message
+ 1, NULL
, 10);
3258 if (message
[6] != '\t')
3262 return fn(&ooid
, &noid
, p
, timestamp
, tz
, message
, cb_data
);
3265 static char *find_beginning_of_line(char *bob
, char *scan
)
3267 while (bob
< scan
&& *(--scan
) != '\n')
3268 ; /* keep scanning backwards */
3270 * Return either beginning of the buffer, or LF at the end of
3271 * the previous line.
3276 static int files_for_each_reflog_ent_reverse(struct ref_store
*ref_store
,
3277 const char *refname
,
3278 each_reflog_ent_fn fn
,
3281 struct files_ref_store
*refs
=
3282 files_downcast(ref_store
, REF_STORE_READ
,
3283 "for_each_reflog_ent_reverse");
3284 struct strbuf sb
= STRBUF_INIT
;
3287 int ret
= 0, at_tail
= 1;
3289 files_reflog_path(refs
, &sb
, refname
);
3290 logfp
= fopen(sb
.buf
, "r");
3291 strbuf_release(&sb
);
3295 /* Jump to the end */
3296 if (fseek(logfp
, 0, SEEK_END
) < 0)
3297 return error("cannot seek back reflog for %s: %s",
3298 refname
, strerror(errno
));
3300 while (!ret
&& 0 < pos
) {
3306 /* Fill next block from the end */
3307 cnt
= (sizeof(buf
) < pos
) ? sizeof(buf
) : pos
;
3308 if (fseek(logfp
, pos
- cnt
, SEEK_SET
))
3309 return error("cannot seek back reflog for %s: %s",
3310 refname
, strerror(errno
));
3311 nread
= fread(buf
, cnt
, 1, logfp
);
3313 return error("cannot read %d bytes from reflog for %s: %s",
3314 cnt
, refname
, strerror(errno
));
3317 scanp
= endp
= buf
+ cnt
;
3318 if (at_tail
&& scanp
[-1] == '\n')
3319 /* Looking at the final LF at the end of the file */
3323 while (buf
< scanp
) {
3325 * terminating LF of the previous line, or the beginning
3330 bp
= find_beginning_of_line(buf
, scanp
);
3334 * The newline is the end of the previous line,
3335 * so we know we have complete line starting
3336 * at (bp + 1). Prefix it onto any prior data
3337 * we collected for the line and process it.
3339 strbuf_splice(&sb
, 0, 0, bp
+ 1, endp
- (bp
+ 1));
3342 ret
= show_one_reflog_ent(&sb
, fn
, cb_data
);
3348 * We are at the start of the buffer, and the
3349 * start of the file; there is no previous
3350 * line, and we have everything for this one.
3351 * Process it, and we can end the loop.
3353 strbuf_splice(&sb
, 0, 0, buf
, endp
- buf
);
3354 ret
= show_one_reflog_ent(&sb
, fn
, cb_data
);
3361 * We are at the start of the buffer, and there
3362 * is more file to read backwards. Which means
3363 * we are in the middle of a line. Note that we
3364 * may get here even if *bp was a newline; that
3365 * just means we are at the exact end of the
3366 * previous line, rather than some spot in the
3369 * Save away what we have to be combined with
3370 * the data from the next read.
3372 strbuf_splice(&sb
, 0, 0, buf
, endp
- buf
);
3379 die("BUG: reverse reflog parser had leftover data");
3382 strbuf_release(&sb
);
3386 static int files_for_each_reflog_ent(struct ref_store
*ref_store
,
3387 const char *refname
,
3388 each_reflog_ent_fn fn
, void *cb_data
)
3390 struct files_ref_store
*refs
=
3391 files_downcast(ref_store
, REF_STORE_READ
,
3392 "for_each_reflog_ent");
3394 struct strbuf sb
= STRBUF_INIT
;
3397 files_reflog_path(refs
, &sb
, refname
);
3398 logfp
= fopen(sb
.buf
, "r");
3399 strbuf_release(&sb
);
3403 while (!ret
&& !strbuf_getwholeline(&sb
, logfp
, '\n'))
3404 ret
= show_one_reflog_ent(&sb
, fn
, cb_data
);
3406 strbuf_release(&sb
);
3410 struct files_reflog_iterator
{
3411 struct ref_iterator base
;
3413 struct ref_store
*ref_store
;
3414 struct dir_iterator
*dir_iterator
;
3415 struct object_id oid
;
3418 static int files_reflog_iterator_advance(struct ref_iterator
*ref_iterator
)
3420 struct files_reflog_iterator
*iter
=
3421 (struct files_reflog_iterator
*)ref_iterator
;
3422 struct dir_iterator
*diter
= iter
->dir_iterator
;
3425 while ((ok
= dir_iterator_advance(diter
)) == ITER_OK
) {
3428 if (!S_ISREG(diter
->st
.st_mode
))
3430 if (diter
->basename
[0] == '.')
3432 if (ends_with(diter
->basename
, ".lock"))
3435 if (refs_read_ref_full(iter
->ref_store
,
3436 diter
->relative_path
, 0,
3437 iter
->oid
.hash
, &flags
)) {
3438 error("bad ref for %s", diter
->path
.buf
);
3442 iter
->base
.refname
= diter
->relative_path
;
3443 iter
->base
.oid
= &iter
->oid
;
3444 iter
->base
.flags
= flags
;
3448 iter
->dir_iterator
= NULL
;
3449 if (ref_iterator_abort(ref_iterator
) == ITER_ERROR
)
3454 static int files_reflog_iterator_peel(struct ref_iterator
*ref_iterator
,
3455 struct object_id
*peeled
)
3457 die("BUG: ref_iterator_peel() called for reflog_iterator");
3460 static int files_reflog_iterator_abort(struct ref_iterator
*ref_iterator
)
3462 struct files_reflog_iterator
*iter
=
3463 (struct files_reflog_iterator
*)ref_iterator
;
3466 if (iter
->dir_iterator
)
3467 ok
= dir_iterator_abort(iter
->dir_iterator
);
3469 base_ref_iterator_free(ref_iterator
);
3473 static struct ref_iterator_vtable files_reflog_iterator_vtable
= {
3474 files_reflog_iterator_advance
,
3475 files_reflog_iterator_peel
,
3476 files_reflog_iterator_abort
3479 static struct ref_iterator
*files_reflog_iterator_begin(struct ref_store
*ref_store
)
3481 struct files_ref_store
*refs
=
3482 files_downcast(ref_store
, REF_STORE_READ
,
3483 "reflog_iterator_begin");
3484 struct files_reflog_iterator
*iter
= xcalloc(1, sizeof(*iter
));
3485 struct ref_iterator
*ref_iterator
= &iter
->base
;
3486 struct strbuf sb
= STRBUF_INIT
;
3488 base_ref_iterator_init(ref_iterator
, &files_reflog_iterator_vtable
);
3489 files_reflog_path(refs
, &sb
, NULL
);
3490 iter
->dir_iterator
= dir_iterator_begin(sb
.buf
);
3491 iter
->ref_store
= ref_store
;
3492 strbuf_release(&sb
);
3493 return ref_iterator
;
3496 static int ref_update_reject_duplicates(struct string_list
*refnames
,
3499 int i
, n
= refnames
->nr
;
3503 for (i
= 1; i
< n
; i
++)
3504 if (!strcmp(refnames
->items
[i
- 1].string
, refnames
->items
[i
].string
)) {
3506 "multiple updates for ref '%s' not allowed.",
3507 refnames
->items
[i
].string
);
3514 * If update is a direct update of head_ref (the reference pointed to
3515 * by HEAD), then add an extra REF_LOG_ONLY update for HEAD.
3517 static int split_head_update(struct ref_update
*update
,
3518 struct ref_transaction
*transaction
,
3519 const char *head_ref
,
3520 struct string_list
*affected_refnames
,
3523 struct string_list_item
*item
;
3524 struct ref_update
*new_update
;
3526 if ((update
->flags
& REF_LOG_ONLY
) ||
3527 (update
->flags
& REF_ISPRUNING
) ||
3528 (update
->flags
& REF_UPDATE_VIA_HEAD
))
3531 if (strcmp(update
->refname
, head_ref
))
3535 * First make sure that HEAD is not already in the
3536 * transaction. This insertion is O(N) in the transaction
3537 * size, but it happens at most once per transaction.
3539 item
= string_list_insert(affected_refnames
, "HEAD");
3541 /* An entry already existed */
3543 "multiple updates for 'HEAD' (including one "
3544 "via its referent '%s') are not allowed",
3546 return TRANSACTION_NAME_CONFLICT
;
3549 new_update
= ref_transaction_add_update(
3550 transaction
, "HEAD",
3551 update
->flags
| REF_LOG_ONLY
| REF_NODEREF
,
3552 update
->new_sha1
, update
->old_sha1
,
3555 item
->util
= new_update
;
3561 * update is for a symref that points at referent and doesn't have
3562 * REF_NODEREF set. Split it into two updates:
3563 * - The original update, but with REF_LOG_ONLY and REF_NODEREF set
3564 * - A new, separate update for the referent reference
3565 * Note that the new update will itself be subject to splitting when
3566 * the iteration gets to it.
3568 static int split_symref_update(struct files_ref_store
*refs
,
3569 struct ref_update
*update
,
3570 const char *referent
,
3571 struct ref_transaction
*transaction
,
3572 struct string_list
*affected_refnames
,
3575 struct string_list_item
*item
;
3576 struct ref_update
*new_update
;
3577 unsigned int new_flags
;
3580 * First make sure that referent is not already in the
3581 * transaction. This insertion is O(N) in the transaction
3582 * size, but it happens at most once per symref in a
3585 item
= string_list_insert(affected_refnames
, referent
);
3587 /* An entry already existed */
3589 "multiple updates for '%s' (including one "
3590 "via symref '%s') are not allowed",
3591 referent
, update
->refname
);
3592 return TRANSACTION_NAME_CONFLICT
;
3595 new_flags
= update
->flags
;
3596 if (!strcmp(update
->refname
, "HEAD")) {
3598 * Record that the new update came via HEAD, so that
3599 * when we process it, split_head_update() doesn't try
3600 * to add another reflog update for HEAD. Note that
3601 * this bit will be propagated if the new_update
3602 * itself needs to be split.
3604 new_flags
|= REF_UPDATE_VIA_HEAD
;
3607 new_update
= ref_transaction_add_update(
3608 transaction
, referent
, new_flags
,
3609 update
->new_sha1
, update
->old_sha1
,
3612 new_update
->parent_update
= update
;
3615 * Change the symbolic ref update to log only. Also, it
3616 * doesn't need to check its old SHA-1 value, as that will be
3617 * done when new_update is processed.
3619 update
->flags
|= REF_LOG_ONLY
| REF_NODEREF
;
3620 update
->flags
&= ~REF_HAVE_OLD
;
3622 item
->util
= new_update
;
3628 * Return the refname under which update was originally requested.
3630 static const char *original_update_refname(struct ref_update
*update
)
3632 while (update
->parent_update
)
3633 update
= update
->parent_update
;
3635 return update
->refname
;
3639 * Check whether the REF_HAVE_OLD and old_oid values stored in update
3640 * are consistent with oid, which is the reference's current value. If
3641 * everything is OK, return 0; otherwise, write an error message to
3642 * err and return -1.
3644 static int check_old_oid(struct ref_update
*update
, struct object_id
*oid
,
3647 if (!(update
->flags
& REF_HAVE_OLD
) ||
3648 !hashcmp(oid
->hash
, update
->old_sha1
))
3651 if (is_null_sha1(update
->old_sha1
))
3652 strbuf_addf(err
, "cannot lock ref '%s': "
3653 "reference already exists",
3654 original_update_refname(update
));
3655 else if (is_null_oid(oid
))
3656 strbuf_addf(err
, "cannot lock ref '%s': "
3657 "reference is missing but expected %s",
3658 original_update_refname(update
),
3659 sha1_to_hex(update
->old_sha1
));
3661 strbuf_addf(err
, "cannot lock ref '%s': "
3662 "is at %s but expected %s",
3663 original_update_refname(update
),
3665 sha1_to_hex(update
->old_sha1
));
3671 * Prepare for carrying out update:
3672 * - Lock the reference referred to by update.
3673 * - Read the reference under lock.
3674 * - Check that its old SHA-1 value (if specified) is correct, and in
3675 * any case record it in update->lock->old_oid for later use when
3676 * writing the reflog.
3677 * - If it is a symref update without REF_NODEREF, split it up into a
3678 * REF_LOG_ONLY update of the symref and add a separate update for
3679 * the referent to transaction.
3680 * - If it is an update of head_ref, add a corresponding REF_LOG_ONLY
3683 static int lock_ref_for_update(struct files_ref_store
*refs
,
3684 struct ref_update
*update
,
3685 struct ref_transaction
*transaction
,
3686 const char *head_ref
,
3687 struct string_list
*affected_refnames
,
3690 struct strbuf referent
= STRBUF_INIT
;
3691 int mustexist
= (update
->flags
& REF_HAVE_OLD
) &&
3692 !is_null_sha1(update
->old_sha1
);
3694 struct ref_lock
*lock
;
3696 files_assert_main_repository(refs
, "lock_ref_for_update");
3698 if ((update
->flags
& REF_HAVE_NEW
) && is_null_sha1(update
->new_sha1
))
3699 update
->flags
|= REF_DELETING
;
3702 ret
= split_head_update(update
, transaction
, head_ref
,
3703 affected_refnames
, err
);
3708 ret
= lock_raw_ref(refs
, update
->refname
, mustexist
,
3709 affected_refnames
, NULL
,
3711 &update
->type
, err
);
3715 reason
= strbuf_detach(err
, NULL
);
3716 strbuf_addf(err
, "cannot lock ref '%s': %s",
3717 original_update_refname(update
), reason
);
3722 update
->backend_data
= lock
;
3724 if (update
->type
& REF_ISSYMREF
) {
3725 if (update
->flags
& REF_NODEREF
) {
3727 * We won't be reading the referent as part of
3728 * the transaction, so we have to read it here
3729 * to record and possibly check old_sha1:
3731 if (refs_read_ref_full(&refs
->base
,
3733 lock
->old_oid
.hash
, NULL
)) {
3734 if (update
->flags
& REF_HAVE_OLD
) {
3735 strbuf_addf(err
, "cannot lock ref '%s': "
3736 "error reading reference",
3737 original_update_refname(update
));
3740 } else if (check_old_oid(update
, &lock
->old_oid
, err
)) {
3741 return TRANSACTION_GENERIC_ERROR
;
3745 * Create a new update for the reference this
3746 * symref is pointing at. Also, we will record
3747 * and verify old_sha1 for this update as part
3748 * of processing the split-off update, so we
3749 * don't have to do it here.
3751 ret
= split_symref_update(refs
, update
,
3752 referent
.buf
, transaction
,
3753 affected_refnames
, err
);
3758 struct ref_update
*parent_update
;
3760 if (check_old_oid(update
, &lock
->old_oid
, err
))
3761 return TRANSACTION_GENERIC_ERROR
;
3764 * If this update is happening indirectly because of a
3765 * symref update, record the old SHA-1 in the parent
3768 for (parent_update
= update
->parent_update
;
3770 parent_update
= parent_update
->parent_update
) {
3771 struct ref_lock
*parent_lock
= parent_update
->backend_data
;
3772 oidcpy(&parent_lock
->old_oid
, &lock
->old_oid
);
3776 if ((update
->flags
& REF_HAVE_NEW
) &&
3777 !(update
->flags
& REF_DELETING
) &&
3778 !(update
->flags
& REF_LOG_ONLY
)) {
3779 if (!(update
->type
& REF_ISSYMREF
) &&
3780 !hashcmp(lock
->old_oid
.hash
, update
->new_sha1
)) {
3782 * The reference already has the desired
3783 * value, so we don't need to write it.
3785 } else if (write_ref_to_lockfile(lock
, update
->new_sha1
,
3787 char *write_err
= strbuf_detach(err
, NULL
);
3790 * The lock was freed upon failure of
3791 * write_ref_to_lockfile():
3793 update
->backend_data
= NULL
;
3795 "cannot update ref '%s': %s",
3796 update
->refname
, write_err
);
3798 return TRANSACTION_GENERIC_ERROR
;
3800 update
->flags
|= REF_NEEDS_COMMIT
;
3803 if (!(update
->flags
& REF_NEEDS_COMMIT
)) {
3805 * We didn't call write_ref_to_lockfile(), so
3806 * the lockfile is still open. Close it to
3807 * free up the file descriptor:
3809 if (close_ref(lock
)) {
3810 strbuf_addf(err
, "couldn't close '%s.lock'",
3812 return TRANSACTION_GENERIC_ERROR
;
3818 static int files_transaction_commit(struct ref_store
*ref_store
,
3819 struct ref_transaction
*transaction
,
3822 struct files_ref_store
*refs
=
3823 files_downcast(ref_store
, REF_STORE_WRITE
,
3824 "ref_transaction_commit");
3826 struct string_list refs_to_delete
= STRING_LIST_INIT_NODUP
;
3827 struct string_list_item
*ref_to_delete
;
3828 struct string_list affected_refnames
= STRING_LIST_INIT_NODUP
;
3829 char *head_ref
= NULL
;
3831 struct object_id head_oid
;
3832 struct strbuf sb
= STRBUF_INIT
;
3836 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
3837 die("BUG: commit called for transaction that is not open");
3839 if (!transaction
->nr
) {
3840 transaction
->state
= REF_TRANSACTION_CLOSED
;
3845 * Fail if a refname appears more than once in the
3846 * transaction. (If we end up splitting up any updates using
3847 * split_symref_update() or split_head_update(), those
3848 * functions will check that the new updates don't have the
3849 * same refname as any existing ones.)
3851 for (i
= 0; i
< transaction
->nr
; i
++) {
3852 struct ref_update
*update
= transaction
->updates
[i
];
3853 struct string_list_item
*item
=
3854 string_list_append(&affected_refnames
, update
->refname
);
3857 * We store a pointer to update in item->util, but at
3858 * the moment we never use the value of this field
3859 * except to check whether it is non-NULL.
3861 item
->util
= update
;
3863 string_list_sort(&affected_refnames
);
3864 if (ref_update_reject_duplicates(&affected_refnames
, err
)) {
3865 ret
= TRANSACTION_GENERIC_ERROR
;
3870 * Special hack: If a branch is updated directly and HEAD
3871 * points to it (may happen on the remote side of a push
3872 * for example) then logically the HEAD reflog should be
3875 * A generic solution would require reverse symref lookups,
3876 * but finding all symrefs pointing to a given branch would be
3877 * rather costly for this rare event (the direct update of a
3878 * branch) to be worth it. So let's cheat and check with HEAD
3879 * only, which should cover 99% of all usage scenarios (even
3880 * 100% of the default ones).
3882 * So if HEAD is a symbolic reference, then record the name of
3883 * the reference that it points to. If we see an update of
3884 * head_ref within the transaction, then split_head_update()
3885 * arranges for the reflog of HEAD to be updated, too.
3887 head_ref
= refs_resolve_refdup(ref_store
, "HEAD",
3888 RESOLVE_REF_NO_RECURSE
,
3889 head_oid
.hash
, &head_type
);
3891 if (head_ref
&& !(head_type
& REF_ISSYMREF
)) {
3897 * Acquire all locks, verify old values if provided, check
3898 * that new values are valid, and write new values to the
3899 * lockfiles, ready to be activated. Only keep one lockfile
3900 * open at a time to avoid running out of file descriptors.
3902 for (i
= 0; i
< transaction
->nr
; i
++) {
3903 struct ref_update
*update
= transaction
->updates
[i
];
3905 ret
= lock_ref_for_update(refs
, update
, transaction
,
3906 head_ref
, &affected_refnames
, err
);
3911 /* Perform updates first so live commits remain referenced */
3912 for (i
= 0; i
< transaction
->nr
; i
++) {
3913 struct ref_update
*update
= transaction
->updates
[i
];
3914 struct ref_lock
*lock
= update
->backend_data
;
3916 if (update
->flags
& REF_NEEDS_COMMIT
||
3917 update
->flags
& REF_LOG_ONLY
) {
3918 if (files_log_ref_write(refs
,
3922 update
->msg
, update
->flags
,
3924 char *old_msg
= strbuf_detach(err
, NULL
);
3926 strbuf_addf(err
, "cannot update the ref '%s': %s",
3927 lock
->ref_name
, old_msg
);
3930 update
->backend_data
= NULL
;
3931 ret
= TRANSACTION_GENERIC_ERROR
;
3935 if (update
->flags
& REF_NEEDS_COMMIT
) {
3936 clear_loose_ref_cache(refs
);
3937 if (commit_ref(lock
)) {
3938 strbuf_addf(err
, "couldn't set '%s'", lock
->ref_name
);
3940 update
->backend_data
= NULL
;
3941 ret
= TRANSACTION_GENERIC_ERROR
;
3946 /* Perform deletes now that updates are safely completed */
3947 for (i
= 0; i
< transaction
->nr
; i
++) {
3948 struct ref_update
*update
= transaction
->updates
[i
];
3949 struct ref_lock
*lock
= update
->backend_data
;
3951 if (update
->flags
& REF_DELETING
&&
3952 !(update
->flags
& REF_LOG_ONLY
)) {
3953 if (!(update
->type
& REF_ISPACKED
) ||
3954 update
->type
& REF_ISSYMREF
) {
3955 /* It is a loose reference. */
3957 files_ref_path(refs
, &sb
, lock
->ref_name
);
3958 if (unlink_or_msg(sb
.buf
, err
)) {
3959 ret
= TRANSACTION_GENERIC_ERROR
;
3962 update
->flags
|= REF_DELETED_LOOSE
;
3965 if (!(update
->flags
& REF_ISPRUNING
))
3966 string_list_append(&refs_to_delete
,
3971 if (repack_without_refs(refs
, &refs_to_delete
, err
)) {
3972 ret
= TRANSACTION_GENERIC_ERROR
;
3976 /* Delete the reflogs of any references that were deleted: */
3977 for_each_string_list_item(ref_to_delete
, &refs_to_delete
) {
3979 files_reflog_path(refs
, &sb
, ref_to_delete
->string
);
3980 if (!unlink_or_warn(sb
.buf
))
3981 try_remove_empty_parents(refs
, ref_to_delete
->string
,
3982 REMOVE_EMPTY_PARENTS_REFLOG
);
3985 clear_loose_ref_cache(refs
);
3988 strbuf_release(&sb
);
3989 transaction
->state
= REF_TRANSACTION_CLOSED
;
3991 for (i
= 0; i
< transaction
->nr
; i
++) {
3992 struct ref_update
*update
= transaction
->updates
[i
];
3993 struct ref_lock
*lock
= update
->backend_data
;
3998 if (update
->flags
& REF_DELETED_LOOSE
) {
4000 * The loose reference was deleted. Delete any
4001 * empty parent directories. (Note that this
4002 * can only work because we have already
4003 * removed the lockfile.)
4005 try_remove_empty_parents(refs
, update
->refname
,
4006 REMOVE_EMPTY_PARENTS_REF
);
4010 string_list_clear(&refs_to_delete
, 0);
4012 string_list_clear(&affected_refnames
, 0);
4017 static int ref_present(const char *refname
,
4018 const struct object_id
*oid
, int flags
, void *cb_data
)
4020 struct string_list
*affected_refnames
= cb_data
;
4022 return string_list_has_string(affected_refnames
, refname
);
4025 static int files_initial_transaction_commit(struct ref_store
*ref_store
,
4026 struct ref_transaction
*transaction
,
4029 struct files_ref_store
*refs
=
4030 files_downcast(ref_store
, REF_STORE_WRITE
,
4031 "initial_ref_transaction_commit");
4033 struct string_list affected_refnames
= STRING_LIST_INIT_NODUP
;
4037 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
4038 die("BUG: commit called for transaction that is not open");
4040 /* Fail if a refname appears more than once in the transaction: */
4041 for (i
= 0; i
< transaction
->nr
; i
++)
4042 string_list_append(&affected_refnames
,
4043 transaction
->updates
[i
]->refname
);
4044 string_list_sort(&affected_refnames
);
4045 if (ref_update_reject_duplicates(&affected_refnames
, err
)) {
4046 ret
= TRANSACTION_GENERIC_ERROR
;
4051 * It's really undefined to call this function in an active
4052 * repository or when there are existing references: we are
4053 * only locking and changing packed-refs, so (1) any
4054 * simultaneous processes might try to change a reference at
4055 * the same time we do, and (2) any existing loose versions of
4056 * the references that we are setting would have precedence
4057 * over our values. But some remote helpers create the remote
4058 * "HEAD" and "master" branches before calling this function,
4059 * so here we really only check that none of the references
4060 * that we are creating already exists.
4062 if (refs_for_each_rawref(&refs
->base
, ref_present
,
4063 &affected_refnames
))
4064 die("BUG: initial ref transaction called with existing refs");
4066 for (i
= 0; i
< transaction
->nr
; i
++) {
4067 struct ref_update
*update
= transaction
->updates
[i
];
4069 if ((update
->flags
& REF_HAVE_OLD
) &&
4070 !is_null_sha1(update
->old_sha1
))
4071 die("BUG: initial ref transaction with old_sha1 set");
4072 if (refs_verify_refname_available(&refs
->base
, update
->refname
,
4073 &affected_refnames
, NULL
,
4075 ret
= TRANSACTION_NAME_CONFLICT
;
4080 if (lock_packed_refs(refs
, 0)) {
4081 strbuf_addf(err
, "unable to lock packed-refs file: %s",
4083 ret
= TRANSACTION_GENERIC_ERROR
;
4087 for (i
= 0; i
< transaction
->nr
; i
++) {
4088 struct ref_update
*update
= transaction
->updates
[i
];
4090 if ((update
->flags
& REF_HAVE_NEW
) &&
4091 !is_null_sha1(update
->new_sha1
))
4092 add_packed_ref(refs
, update
->refname
, update
->new_sha1
);
4095 if (commit_packed_refs(refs
)) {
4096 strbuf_addf(err
, "unable to commit packed-refs file: %s",
4098 ret
= TRANSACTION_GENERIC_ERROR
;
4103 transaction
->state
= REF_TRANSACTION_CLOSED
;
4104 string_list_clear(&affected_refnames
, 0);
4108 struct expire_reflog_cb
{
4110 reflog_expiry_should_prune_fn
*should_prune_fn
;
4113 struct object_id last_kept_oid
;
4116 static int expire_reflog_ent(struct object_id
*ooid
, struct object_id
*noid
,
4117 const char *email
, unsigned long timestamp
, int tz
,
4118 const char *message
, void *cb_data
)
4120 struct expire_reflog_cb
*cb
= cb_data
;
4121 struct expire_reflog_policy_cb
*policy_cb
= cb
->policy_cb
;
4123 if (cb
->flags
& EXPIRE_REFLOGS_REWRITE
)
4124 ooid
= &cb
->last_kept_oid
;
4126 if ((*cb
->should_prune_fn
)(ooid
->hash
, noid
->hash
, email
, timestamp
, tz
,
4127 message
, policy_cb
)) {
4129 printf("would prune %s", message
);
4130 else if (cb
->flags
& EXPIRE_REFLOGS_VERBOSE
)
4131 printf("prune %s", message
);
4134 fprintf(cb
->newlog
, "%s %s %s %"PRItime
" %+05d\t%s",
4135 oid_to_hex(ooid
), oid_to_hex(noid
),
4136 email
, timestamp
, tz
, message
);
4137 oidcpy(&cb
->last_kept_oid
, noid
);
4139 if (cb
->flags
& EXPIRE_REFLOGS_VERBOSE
)
4140 printf("keep %s", message
);
4145 static int files_reflog_expire(struct ref_store
*ref_store
,
4146 const char *refname
, const unsigned char *sha1
,
4148 reflog_expiry_prepare_fn prepare_fn
,
4149 reflog_expiry_should_prune_fn should_prune_fn
,
4150 reflog_expiry_cleanup_fn cleanup_fn
,
4151 void *policy_cb_data
)
4153 struct files_ref_store
*refs
=
4154 files_downcast(ref_store
, REF_STORE_WRITE
, "reflog_expire");
4155 static struct lock_file reflog_lock
;
4156 struct expire_reflog_cb cb
;
4157 struct ref_lock
*lock
;
4158 struct strbuf log_file_sb
= STRBUF_INIT
;
4162 struct strbuf err
= STRBUF_INIT
;
4164 memset(&cb
, 0, sizeof(cb
));
4166 cb
.policy_cb
= policy_cb_data
;
4167 cb
.should_prune_fn
= should_prune_fn
;
4170 * The reflog file is locked by holding the lock on the
4171 * reference itself, plus we might need to update the
4172 * reference if --updateref was specified:
4174 lock
= lock_ref_sha1_basic(refs
, refname
, sha1
,
4175 NULL
, NULL
, REF_NODEREF
,
4178 error("cannot lock ref '%s': %s", refname
, err
.buf
);
4179 strbuf_release(&err
);
4182 if (!refs_reflog_exists(ref_store
, refname
)) {
4187 files_reflog_path(refs
, &log_file_sb
, refname
);
4188 log_file
= strbuf_detach(&log_file_sb
, NULL
);
4189 if (!(flags
& EXPIRE_REFLOGS_DRY_RUN
)) {
4191 * Even though holding $GIT_DIR/logs/$reflog.lock has
4192 * no locking implications, we use the lock_file
4193 * machinery here anyway because it does a lot of the
4194 * work we need, including cleaning up if the program
4195 * exits unexpectedly.
4197 if (hold_lock_file_for_update(&reflog_lock
, log_file
, 0) < 0) {
4198 struct strbuf err
= STRBUF_INIT
;
4199 unable_to_lock_message(log_file
, errno
, &err
);
4200 error("%s", err
.buf
);
4201 strbuf_release(&err
);
4204 cb
.newlog
= fdopen_lock_file(&reflog_lock
, "w");
4206 error("cannot fdopen %s (%s)",
4207 get_lock_file_path(&reflog_lock
), strerror(errno
));
4212 (*prepare_fn
)(refname
, sha1
, cb
.policy_cb
);
4213 refs_for_each_reflog_ent(ref_store
, refname
, expire_reflog_ent
, &cb
);
4214 (*cleanup_fn
)(cb
.policy_cb
);
4216 if (!(flags
& EXPIRE_REFLOGS_DRY_RUN
)) {
4218 * It doesn't make sense to adjust a reference pointed
4219 * to by a symbolic ref based on expiring entries in
4220 * the symbolic reference's reflog. Nor can we update
4221 * a reference if there are no remaining reflog
4224 int update
= (flags
& EXPIRE_REFLOGS_UPDATE_REF
) &&
4225 !(type
& REF_ISSYMREF
) &&
4226 !is_null_oid(&cb
.last_kept_oid
);
4228 if (close_lock_file(&reflog_lock
)) {
4229 status
|= error("couldn't write %s: %s", log_file
,
4231 } else if (update
&&
4232 (write_in_full(get_lock_file_fd(lock
->lk
),
4233 oid_to_hex(&cb
.last_kept_oid
), GIT_SHA1_HEXSZ
) != GIT_SHA1_HEXSZ
||
4234 write_str_in_full(get_lock_file_fd(lock
->lk
), "\n") != 1 ||
4235 close_ref(lock
) < 0)) {
4236 status
|= error("couldn't write %s",
4237 get_lock_file_path(lock
->lk
));
4238 rollback_lock_file(&reflog_lock
);
4239 } else if (commit_lock_file(&reflog_lock
)) {
4240 status
|= error("unable to write reflog '%s' (%s)",
4241 log_file
, strerror(errno
));
4242 } else if (update
&& commit_ref(lock
)) {
4243 status
|= error("couldn't set %s", lock
->ref_name
);
4251 rollback_lock_file(&reflog_lock
);
4257 static int files_init_db(struct ref_store
*ref_store
, struct strbuf
*err
)
4259 struct files_ref_store
*refs
=
4260 files_downcast(ref_store
, REF_STORE_WRITE
, "init_db");
4261 struct strbuf sb
= STRBUF_INIT
;
4264 * Create .git/refs/{heads,tags}
4266 files_ref_path(refs
, &sb
, "refs/heads");
4267 safe_create_dir(sb
.buf
, 1);
4270 files_ref_path(refs
, &sb
, "refs/tags");
4271 safe_create_dir(sb
.buf
, 1);
4273 strbuf_release(&sb
);
4277 struct ref_storage_be refs_be_files
= {
4280 files_ref_store_create
,
4282 files_transaction_commit
,
4283 files_initial_transaction_commit
,
4287 files_create_symref
,
4291 files_ref_iterator_begin
,
4293 files_verify_refname_available
,
4295 files_reflog_iterator_begin
,
4296 files_for_each_reflog_ent
,
4297 files_for_each_reflog_ent_reverse
,
4298 files_reflog_exists
,
4299 files_create_reflog
,
4300 files_delete_reflog
,