2 * The backend-independent part of the reference module.
5 #include "git-compat-util.h"
8 #include "environment.h"
15 #include "refs/refs-internal.h"
16 #include "run-command.h"
18 #include "object-name.h"
19 #include "object-store-ll.h"
22 #include "submodule.h"
25 #include "repository.h"
30 #include "wildmatch.h"
33 * List of all available backends
35 static const struct ref_storage_be
*refs_backends
[] = {
36 [REF_STORAGE_FORMAT_FILES
] = &refs_be_files
,
37 [REF_STORAGE_FORMAT_REFTABLE
] = &refs_be_reftable
,
40 static const struct ref_storage_be
*find_ref_storage_backend(
41 enum ref_storage_format ref_storage_format
)
43 if (ref_storage_format
< ARRAY_SIZE(refs_backends
))
44 return refs_backends
[ref_storage_format
];
48 enum ref_storage_format
ref_storage_format_by_name(const char *name
)
50 for (unsigned int i
= 0; i
< ARRAY_SIZE(refs_backends
); i
++)
51 if (refs_backends
[i
] && !strcmp(refs_backends
[i
]->name
, name
))
53 return REF_STORAGE_FORMAT_UNKNOWN
;
56 const char *ref_storage_format_to_name(enum ref_storage_format ref_storage_format
)
58 const struct ref_storage_be
*be
= find_ref_storage_backend(ref_storage_format
);
65 * How to handle various characters in refnames:
66 * 0: An acceptable character for refs
68 * 2: ., look for a preceding . to reject .. in refs
69 * 3: {, look for a preceding @ to reject @{ in refs
70 * 4: A bad character: ASCII control characters, and
71 * ":", "?", "[", "\", "^", "~", SP, or TAB
72 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
74 static unsigned char refname_disposition
[256] = {
75 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
85 struct ref_namespace_info ref_namespace
[] = {
88 .decoration
= DECORATION_REF_HEAD
,
91 [NAMESPACE_BRANCHES
] = {
93 .decoration
= DECORATION_REF_LOCAL
,
97 .decoration
= DECORATION_REF_TAG
,
99 [NAMESPACE_REMOTE_REFS
] = {
101 * The default refspec for new remotes copies refs from
102 * refs/heads/ on the remote into refs/remotes/<remote>/.
103 * As such, "refs/remotes/" has special handling.
105 .ref
= "refs/remotes/",
106 .decoration
= DECORATION_REF_REMOTE
,
108 [NAMESPACE_STASH
] = {
110 * The single ref "refs/stash" stores the latest stash.
111 * Older stashes can be found in the reflog.
115 .decoration
= DECORATION_REF_STASH
,
117 [NAMESPACE_REPLACE
] = {
119 * This namespace allows Git to act as if one object ID
120 * points to the content of another. Unlike the other
121 * ref namespaces, this one can be changed by the
122 * GIT_REPLACE_REF_BASE environment variable. This
123 * .namespace value will be overwritten in setup_git_env().
125 .ref
= "refs/replace/",
126 .decoration
= DECORATION_GRAFTED
,
128 [NAMESPACE_NOTES
] = {
130 * The refs/notes/commit ref points to the tip of a
131 * parallel commit history that adds metadata to commits
132 * in the normal history. This ref can be overwritten
133 * by the core.notesRef config variable or the
134 * GIT_NOTES_REFS environment variable.
136 .ref
= "refs/notes/commit",
139 [NAMESPACE_PREFETCH
] = {
141 * Prefetch refs are written by the background 'fetch'
142 * maintenance task. It allows faster foreground fetches
143 * by advertising these previously-downloaded tips without
144 * updating refs/remotes/ without user intervention.
146 .ref
= "refs/prefetch/",
148 [NAMESPACE_REWRITTEN
] = {
150 * Rewritten refs are used by the 'label' command in the
151 * sequencer. These are particularly useful during an
152 * interactive rebase that uses the 'merge' command.
154 .ref
= "refs/rewritten/",
158 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
160 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
161 if (info
->ref_updated
)
162 free((char *)info
->ref
);
164 info
->ref_updated
= 1;
168 * Try to read one refname component from the front of refname.
169 * Return the length of the component found, or -1 if the component is
170 * not legal. It is legal if it is something reasonable to have under
171 * ".git/refs/"; We do not like it if:
173 * - it begins with ".", or
174 * - it has double dots "..", or
175 * - it has ASCII control characters, or
176 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
177 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
178 * - it ends with a "/", or
179 * - it ends with ".lock", or
180 * - it contains a "@{" portion
182 * When sanitized is not NULL, instead of rejecting the input refname
183 * as an error, try to come up with a usable replacement for the input
186 static int check_refname_component(const char *refname
, int *flags
,
187 struct strbuf
*sanitized
)
191 size_t component_start
= 0; /* garbage - not a reasonable initial value */
194 component_start
= sanitized
->len
;
196 for (cp
= refname
; ; cp
++) {
198 unsigned char disp
= refname_disposition
[ch
];
200 if (sanitized
&& disp
!= 1)
201 strbuf_addch(sanitized
, ch
);
207 if (last
== '.') { /* Refname contains "..". */
209 /* collapse ".." to single "." */
210 strbuf_setlen(sanitized
, sanitized
->len
- 1);
216 if (last
== '@') { /* Refname contains "@{". */
218 sanitized
->buf
[sanitized
->len
-1] = '-';
226 sanitized
->buf
[sanitized
->len
-1] = '-';
231 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
232 /* refspec can't be a pattern */
234 sanitized
->buf
[sanitized
->len
-1] = '-';
240 * Unset the pattern flag so that we only accept
241 * a single asterisk for one side of refspec.
243 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
250 return 0; /* Component has zero length. */
252 if (refname
[0] == '.') { /* Component starts with '.'. */
254 sanitized
->buf
[component_start
] = '-';
258 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
259 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
262 /* Refname ends with ".lock". */
263 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
264 /* try again in case we have .lock.lock */
270 static int check_or_sanitize_refname(const char *refname
, int flags
,
271 struct strbuf
*sanitized
)
273 int component_len
, component_count
= 0;
275 if (!strcmp(refname
, "@")) {
276 /* Refname is a single character '@'. */
278 strbuf_addch(sanitized
, '-');
284 if (sanitized
&& sanitized
->len
)
285 strbuf_complete(sanitized
, '/');
287 /* We are at the start of a path component. */
288 component_len
= check_refname_component(refname
, &flags
,
290 if (sanitized
&& component_len
== 0)
291 ; /* OK, omit empty component */
292 else if (component_len
<= 0)
296 if (refname
[component_len
] == '\0')
298 /* Skip to next component. */
299 refname
+= component_len
+ 1;
302 if (refname
[component_len
- 1] == '.') {
303 /* Refname ends with '.'. */
305 ; /* omit ending dot */
309 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
310 return -1; /* Refname has only one component. */
314 int check_refname_format(const char *refname
, int flags
)
316 return check_or_sanitize_refname(refname
, flags
, NULL
);
319 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
321 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
322 BUG("sanitizing refname '%s' check returned error", refname
);
325 int refname_is_safe(const char *refname
)
329 if (skip_prefix(refname
, "refs/", &rest
)) {
332 size_t restlen
= strlen(rest
);
334 /* rest must not be empty, or start or end with "/" */
335 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
339 * Does the refname try to escape refs/?
340 * For example: refs/foo/../bar is safe but refs/foo/../../bar
343 buf
= xmallocz(restlen
);
344 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
350 if (!isupper(*refname
) && *refname
!= '_')
358 * Return true if refname, which has the specified oid and flags, can
359 * be resolved to an object in the database. If the referred-to object
360 * does not exist, emit a warning and return false.
362 int ref_resolves_to_object(const char *refname
,
363 struct repository
*repo
,
364 const struct object_id
*oid
,
367 if (flags
& REF_ISBROKEN
)
369 if (!repo_has_object_file(repo
, oid
)) {
370 error(_("%s does not point to a valid object!"), refname
);
376 char *refs_resolve_refdup(struct ref_store
*refs
,
377 const char *refname
, int resolve_flags
,
378 struct object_id
*oid
, int *flags
)
382 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
384 return xstrdup_or_null(result
);
387 /* The argument to for_each_filter_refs */
388 struct for_each_ref_filter
{
395 int refs_read_ref_full(struct ref_store
*refs
, const char *refname
,
396 int resolve_flags
, struct object_id
*oid
, int *flags
)
398 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
404 int refs_read_ref(struct ref_store
*refs
, const char *refname
, struct object_id
*oid
)
406 return refs_read_ref_full(refs
, refname
, RESOLVE_REF_READING
, oid
, NULL
);
409 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
411 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
415 static int for_each_filter_refs(const char *refname
,
416 const struct object_id
*oid
,
417 int flags
, void *data
)
419 struct for_each_ref_filter
*filter
= data
;
421 if (wildmatch(filter
->pattern
, refname
, 0))
424 skip_prefix(refname
, filter
->prefix
, &refname
);
425 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
428 struct warn_if_dangling_data
{
429 struct ref_store
*refs
;
432 const struct string_list
*refnames
;
436 static int warn_if_dangling_symref(const char *refname
,
437 const struct object_id
*oid UNUSED
,
438 int flags
, void *cb_data
)
440 struct warn_if_dangling_data
*d
= cb_data
;
441 const char *resolves_to
;
443 if (!(flags
& REF_ISSYMREF
))
446 resolves_to
= refs_resolve_ref_unsafe(d
->refs
, refname
, 0, NULL
, NULL
);
449 ? strcmp(resolves_to
, d
->refname
)
450 : !string_list_has_string(d
->refnames
, resolves_to
))) {
454 fprintf(d
->fp
, d
->msg_fmt
, refname
);
459 void refs_warn_dangling_symref(struct ref_store
*refs
, FILE *fp
,
460 const char *msg_fmt
, const char *refname
)
462 struct warn_if_dangling_data data
= {
468 refs_for_each_rawref(refs
, warn_if_dangling_symref
, &data
);
471 void refs_warn_dangling_symrefs(struct ref_store
*refs
, FILE *fp
,
472 const char *msg_fmt
, const struct string_list
*refnames
)
474 struct warn_if_dangling_data data
= {
477 .refnames
= refnames
,
480 refs_for_each_rawref(refs
, warn_if_dangling_symref
, &data
);
483 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
485 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
488 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
490 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
493 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
495 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
498 int refs_head_ref_namespaced(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
500 struct strbuf buf
= STRBUF_INIT
;
502 struct object_id oid
;
505 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
506 if (!refs_read_ref_full(refs
, buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
507 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
508 strbuf_release(&buf
);
513 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
516 struct strbuf normalized_pattern
= STRBUF_INIT
;
519 BUG("pattern must not start with '/'");
522 strbuf_addstr(&normalized_pattern
, prefix
);
523 else if (!starts_with(pattern
, "refs/") &&
524 strcmp(pattern
, "HEAD"))
525 strbuf_addstr(&normalized_pattern
, "refs/");
527 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
531 strbuf_addstr(&normalized_pattern
, pattern
);
532 strbuf_strip_suffix(&normalized_pattern
, "/");
534 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
535 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
536 strbuf_release(&normalized_pattern
);
539 int refs_for_each_glob_ref_in(struct ref_store
*refs
, each_ref_fn fn
,
540 const char *pattern
, const char *prefix
, void *cb_data
)
542 struct strbuf real_pattern
= STRBUF_INIT
;
543 struct for_each_ref_filter filter
;
546 if (!prefix
&& !starts_with(pattern
, "refs/"))
547 strbuf_addstr(&real_pattern
, "refs/");
549 strbuf_addstr(&real_pattern
, prefix
);
550 strbuf_addstr(&real_pattern
, pattern
);
552 if (!has_glob_specials(pattern
)) {
553 /* Append implied '/' '*' if not present. */
554 strbuf_complete(&real_pattern
, '/');
555 /* No need to check for '*', there is none. */
556 strbuf_addch(&real_pattern
, '*');
559 filter
.pattern
= real_pattern
.buf
;
560 filter
.prefix
= prefix
;
562 filter
.cb_data
= cb_data
;
563 ret
= refs_for_each_ref(refs
, for_each_filter_refs
, &filter
);
565 strbuf_release(&real_pattern
);
569 int refs_for_each_glob_ref(struct ref_store
*refs
, each_ref_fn fn
,
570 const char *pattern
, void *cb_data
)
572 return refs_for_each_glob_ref_in(refs
, fn
, pattern
, NULL
, cb_data
);
575 const char *prettify_refname(const char *name
)
577 if (skip_prefix(name
, "refs/heads/", &name
) ||
578 skip_prefix(name
, "refs/tags/", &name
) ||
579 skip_prefix(name
, "refs/remotes/", &name
))
584 static const char *ref_rev_parse_rules
[] = {
590 "refs/remotes/%.*s/HEAD",
594 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
597 * Is it possible that the caller meant full_name with abbrev_name?
598 * If so return a non-zero value to signal "yes"; the magnitude of
599 * the returned value gives the precedence used for disambiguation.
601 * If abbrev_name cannot mean full_name, return 0.
603 int refname_match(const char *abbrev_name
, const char *full_name
)
606 const int abbrev_name_len
= strlen(abbrev_name
);
607 const int num_rules
= NUM_REV_PARSE_RULES
;
609 for (p
= ref_rev_parse_rules
; *p
; p
++)
610 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
611 return &ref_rev_parse_rules
[num_rules
] - p
;
617 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
618 * the results to 'prefixes'
620 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
623 int len
= strlen(prefix
);
625 for (p
= ref_rev_parse_rules
; *p
; p
++)
626 strvec_pushf(prefixes
, *p
, len
, prefix
);
629 static const char default_branch_name_advice
[] = N_(
630 "Using '%s' as the name for the initial branch. This default branch name\n"
631 "is subject to change. To configure the initial branch name to use in all\n"
632 "of your new repositories, which will suppress this warning, call:\n"
634 "\tgit config --global init.defaultBranch <name>\n"
636 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
637 "'development'. The just-created branch can be renamed via this command:\n"
639 "\tgit branch -m <name>\n"
642 char *repo_default_branch_name(struct repository
*r
, int quiet
)
644 const char *config_key
= "init.defaultbranch";
645 const char *config_display_key
= "init.defaultBranch";
646 char *ret
= NULL
, *full_ref
;
647 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
651 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
652 die(_("could not retrieve `%s`"), config_display_key
);
655 ret
= xstrdup("master");
657 advise(_(default_branch_name_advice
), ret
);
660 full_ref
= xstrfmt("refs/heads/%s", ret
);
661 if (check_refname_format(full_ref
, 0))
662 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
669 * *string and *len will only be substituted, and *string returned (for
670 * later free()ing) if the string passed in is a magic short-hand form
673 static char *substitute_branch_name(struct repository
*r
,
674 const char **string
, int *len
,
675 int nonfatal_dangling_mark
)
677 struct strbuf buf
= STRBUF_INIT
;
678 struct interpret_branch_name_options options
= {
679 .nonfatal_dangling_mark
= nonfatal_dangling_mark
681 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
685 *string
= strbuf_detach(&buf
, &size
);
687 return (char *)*string
;
693 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
694 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
696 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
697 nonfatal_dangling_mark
);
698 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
703 int expand_ref(struct repository
*repo
, const char *str
, int len
,
704 struct object_id
*oid
, char **ref
)
708 struct strbuf fullref
= STRBUF_INIT
;
711 for (p
= ref_rev_parse_rules
; *p
; p
++) {
712 struct object_id oid_from_ref
;
713 struct object_id
*this_result
;
715 struct ref_store
*refs
= get_main_ref_store(repo
);
717 this_result
= refs_found
? &oid_from_ref
: oid
;
718 strbuf_reset(&fullref
);
719 strbuf_addf(&fullref
, *p
, len
, str
);
720 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
726 if (!warn_ambiguous_refs
)
728 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
729 warning(_("ignoring dangling symref %s"), fullref
.buf
);
730 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
731 warning(_("ignoring broken ref %s"), fullref
.buf
);
734 strbuf_release(&fullref
);
738 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
739 struct object_id
*oid
, char **log
)
741 struct ref_store
*refs
= get_main_ref_store(r
);
742 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
745 struct strbuf path
= STRBUF_INIT
;
748 for (p
= ref_rev_parse_rules
; *p
; p
++) {
749 struct object_id hash
;
750 const char *ref
, *it
;
753 strbuf_addf(&path
, *p
, len
, str
);
754 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
756 oid
? &hash
: NULL
, NULL
);
759 if (refs_reflog_exists(refs
, path
.buf
))
761 else if (strcmp(ref
, path
.buf
) &&
762 refs_reflog_exists(refs
, ref
))
771 if (!warn_ambiguous_refs
)
774 strbuf_release(&path
);
779 int is_per_worktree_ref(const char *refname
)
781 return starts_with(refname
, "refs/worktree/") ||
782 starts_with(refname
, "refs/bisect/") ||
783 starts_with(refname
, "refs/rewritten/");
786 int is_pseudo_ref(const char *refname
)
788 static const char * const pseudo_refs
[] = {
794 for (i
= 0; i
< ARRAY_SIZE(pseudo_refs
); i
++)
795 if (!strcmp(refname
, pseudo_refs
[i
]))
801 static int is_root_ref_syntax(const char *refname
)
805 for (c
= refname
; *c
; c
++) {
806 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
813 int is_root_ref(const char *refname
)
815 static const char *const irregular_root_refs
[] = {
818 "BISECT_EXPECTED_REV",
819 "NOTES_MERGE_PARTIAL",
825 if (!is_root_ref_syntax(refname
) ||
826 is_pseudo_ref(refname
))
829 if (ends_with(refname
, "_HEAD"))
832 for (i
= 0; i
< ARRAY_SIZE(irregular_root_refs
); i
++)
833 if (!strcmp(refname
, irregular_root_refs
[i
]))
839 static int is_current_worktree_ref(const char *ref
) {
840 return is_root_ref_syntax(ref
) || is_per_worktree_ref(ref
);
843 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
844 const char **worktree_name
, int *worktree_name_length
,
845 const char **bare_refname
)
847 const char *name_dummy
;
848 int name_length_dummy
;
849 const char *ref_dummy
;
852 worktree_name
= &name_dummy
;
853 if (!worktree_name_length
)
854 worktree_name_length
= &name_length_dummy
;
856 bare_refname
= &ref_dummy
;
858 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
859 const char *slash
= strchr(*bare_refname
, '/');
861 *worktree_name
= *bare_refname
;
863 *worktree_name_length
= strlen(*worktree_name
);
865 /* This is an error condition, and the caller tell because the bare_refname is "" */
866 *bare_refname
= *worktree_name
+ *worktree_name_length
;
867 return REF_WORKTREE_OTHER
;
870 *worktree_name_length
= slash
- *bare_refname
;
871 *bare_refname
= slash
+ 1;
873 if (is_current_worktree_ref(*bare_refname
))
874 return REF_WORKTREE_OTHER
;
877 *worktree_name
= NULL
;
878 *worktree_name_length
= 0;
880 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
881 && is_current_worktree_ref(*bare_refname
))
882 return REF_WORKTREE_MAIN
;
884 *bare_refname
= maybe_worktree_ref
;
885 if (is_current_worktree_ref(maybe_worktree_ref
))
886 return REF_WORKTREE_CURRENT
;
888 return REF_WORKTREE_SHARED
;
891 long get_files_ref_lock_timeout_ms(void)
893 static int configured
= 0;
895 /* The default timeout is 100 ms: */
896 static int timeout_ms
= 100;
899 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
906 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
908 const struct object_id
*old_oid
,
911 struct ref_transaction
*transaction
;
912 struct strbuf err
= STRBUF_INIT
;
914 transaction
= ref_store_transaction_begin(refs
, &err
);
916 ref_transaction_delete(transaction
, refname
, old_oid
,
918 ref_transaction_commit(transaction
, &err
)) {
919 error("%s", err
.buf
);
920 ref_transaction_free(transaction
);
921 strbuf_release(&err
);
924 ref_transaction_free(transaction
);
925 strbuf_release(&err
);
929 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
934 while ((c
= *msg
++)) {
935 if (wasspace
&& isspace(c
))
937 wasspace
= isspace(c
);
945 static char *normalize_reflog_message(const char *msg
)
947 struct strbuf sb
= STRBUF_INIT
;
950 copy_reflog_msg(&sb
, msg
);
951 return strbuf_detach(&sb
, NULL
);
954 int should_autocreate_reflog(const char *refname
)
956 switch (log_all_ref_updates
) {
957 case LOG_REFS_ALWAYS
:
959 case LOG_REFS_NORMAL
:
960 return starts_with(refname
, "refs/heads/") ||
961 starts_with(refname
, "refs/remotes/") ||
962 starts_with(refname
, "refs/notes/") ||
963 !strcmp(refname
, "HEAD");
969 int is_branch(const char *refname
)
971 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
974 struct read_ref_at_cb
{
979 struct object_id
*oid
;
982 struct object_id ooid
;
983 struct object_id noid
;
987 timestamp_t
*cutoff_time
;
992 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
993 timestamp_t timestamp
, int tz
, const char *message
)
996 *cb
->msg
= xstrdup(message
);
998 *cb
->cutoff_time
= timestamp
;
1000 *cb
->cutoff_tz
= tz
;
1002 *cb
->cutoff_cnt
= cb
->reccnt
;
1005 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1006 const char *email UNUSED
,
1007 timestamp_t timestamp
, int tz
,
1008 const char *message
, void *cb_data
)
1010 struct read_ref_at_cb
*cb
= cb_data
;
1013 cb
->date
= timestamp
;
1015 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
1016 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1018 * we have not yet updated cb->[n|o]oid so they still
1019 * hold the values for the previous record.
1021 if (!is_null_oid(&cb
->ooid
)) {
1022 oidcpy(cb
->oid
, noid
);
1023 if (!oideq(&cb
->ooid
, noid
))
1024 warning(_("log for ref %s has gap after %s"),
1025 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1027 else if (cb
->date
== cb
->at_time
)
1028 oidcpy(cb
->oid
, noid
);
1029 else if (!oideq(noid
, cb
->oid
))
1030 warning(_("log for ref %s unexpectedly ended on %s"),
1031 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1032 DATE_MODE(RFC2822
)));
1034 oidcpy(&cb
->ooid
, ooid
);
1035 oidcpy(&cb
->noid
, noid
);
1040 oidcpy(&cb
->ooid
, ooid
);
1041 oidcpy(&cb
->noid
, noid
);
1047 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1048 const char *email UNUSED
,
1049 timestamp_t timestamp
, int tz
,
1050 const char *message
, void *cb_data
)
1052 struct read_ref_at_cb
*cb
= cb_data
;
1054 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1055 oidcpy(cb
->oid
, ooid
);
1056 if (cb
->at_time
&& is_null_oid(cb
->oid
))
1057 oidcpy(cb
->oid
, noid
);
1058 /* We just want the first entry */
1062 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1063 unsigned int flags
, timestamp_t at_time
, int cnt
,
1064 struct object_id
*oid
, char **msg
,
1065 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1067 struct read_ref_at_cb cb
;
1069 memset(&cb
, 0, sizeof(cb
));
1070 cb
.refname
= refname
;
1071 cb
.at_time
= at_time
;
1074 cb
.cutoff_time
= cutoff_time
;
1075 cb
.cutoff_tz
= cutoff_tz
;
1076 cb
.cutoff_cnt
= cutoff_cnt
;
1079 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1084 * The caller asked for ref@{0}, and we had no entries.
1085 * It's a bit subtle, but in practice all callers have
1086 * prepped the "oid" field with the current value of
1087 * the ref, which is the most reasonable fallback.
1089 * We'll put dummy values into the out-parameters (so
1090 * they're not just uninitialized garbage), and the
1091 * caller can take our return value as a hint that
1092 * we did not find any such reflog.
1094 set_read_ref_cutoffs(&cb
, 0, 0, "empty reflog");
1097 if (flags
& GET_OID_QUIETLY
)
1100 die(_("log for %s is empty"), refname
);
1105 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1110 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1113 struct ref_transaction
*tr
;
1116 CALLOC_ARRAY(tr
, 1);
1117 tr
->ref_store
= refs
;
1121 void ref_transaction_free(struct ref_transaction
*transaction
)
1128 switch (transaction
->state
) {
1129 case REF_TRANSACTION_OPEN
:
1130 case REF_TRANSACTION_CLOSED
:
1133 case REF_TRANSACTION_PREPARED
:
1134 BUG("free called on a prepared reference transaction");
1137 BUG("unexpected reference transaction state");
1141 for (i
= 0; i
< transaction
->nr
; i
++) {
1142 free(transaction
->updates
[i
]->msg
);
1143 free((char *)transaction
->updates
[i
]->new_target
);
1144 free((char *)transaction
->updates
[i
]->old_target
);
1145 free(transaction
->updates
[i
]);
1147 free(transaction
->updates
);
1151 struct ref_update
*ref_transaction_add_update(
1152 struct ref_transaction
*transaction
,
1153 const char *refname
, unsigned int flags
,
1154 const struct object_id
*new_oid
,
1155 const struct object_id
*old_oid
,
1156 const char *new_target
, const char *old_target
,
1159 struct ref_update
*update
;
1161 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1162 BUG("update called for transaction that is not open");
1164 if (old_oid
&& old_target
)
1165 BUG("only one of old_oid and old_target should be non NULL");
1166 if (new_oid
&& new_target
)
1167 BUG("only one of new_oid and new_target should be non NULL");
1169 FLEX_ALLOC_STR(update
, refname
, refname
);
1170 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1171 transaction
->updates
[transaction
->nr
++] = update
;
1173 update
->flags
= flags
;
1175 update
->new_target
= xstrdup_or_null(new_target
);
1176 update
->old_target
= xstrdup_or_null(old_target
);
1177 if ((flags
& REF_HAVE_NEW
) && new_oid
)
1178 oidcpy(&update
->new_oid
, new_oid
);
1179 if ((flags
& REF_HAVE_OLD
) && old_oid
)
1180 oidcpy(&update
->old_oid
, old_oid
);
1182 update
->msg
= normalize_reflog_message(msg
);
1186 int ref_transaction_update(struct ref_transaction
*transaction
,
1187 const char *refname
,
1188 const struct object_id
*new_oid
,
1189 const struct object_id
*old_oid
,
1190 const char *new_target
,
1191 const char *old_target
,
1192 unsigned int flags
, const char *msg
,
1197 if ((flags
& REF_FORCE_CREATE_REFLOG
) &&
1198 (flags
& REF_SKIP_CREATE_REFLOG
)) {
1199 strbuf_addstr(err
, _("refusing to force and skip creation of reflog"));
1203 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1204 ((new_oid
&& !is_null_oid(new_oid
)) ?
1205 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1206 !refname_is_safe(refname
))) {
1207 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1212 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1213 is_pseudo_ref(refname
)) {
1214 strbuf_addf(err
, _("refusing to update pseudoref '%s'"),
1219 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1220 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1223 * Clear flags outside the allowed set; this should be a noop because
1224 * of the BUG() check above, but it works around a -Wnonnull warning
1225 * with some versions of "gcc -O3".
1227 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1229 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1230 flags
|= (new_target
? REF_HAVE_NEW
: 0) | (old_target
? REF_HAVE_OLD
: 0);
1232 ref_transaction_add_update(transaction
, refname
, flags
,
1233 new_oid
, old_oid
, new_target
,
1238 int ref_transaction_create(struct ref_transaction
*transaction
,
1239 const char *refname
,
1240 const struct object_id
*new_oid
,
1241 unsigned int flags
, const char *msg
,
1244 if (!new_oid
|| is_null_oid(new_oid
)) {
1245 strbuf_addf(err
, "'%s' has a null OID", refname
);
1248 return ref_transaction_update(transaction
, refname
, new_oid
,
1249 null_oid(), NULL
, NULL
, flags
,
1253 int ref_transaction_delete(struct ref_transaction
*transaction
,
1254 const char *refname
,
1255 const struct object_id
*old_oid
,
1256 unsigned int flags
, const char *msg
,
1259 if (old_oid
&& is_null_oid(old_oid
))
1260 BUG("delete called with old_oid set to zeros");
1261 return ref_transaction_update(transaction
, refname
,
1262 null_oid(), old_oid
,
1267 int ref_transaction_verify(struct ref_transaction
*transaction
,
1268 const char *refname
,
1269 const struct object_id
*old_oid
,
1274 BUG("verify called with old_oid set to NULL");
1275 return ref_transaction_update(transaction
, refname
,
1281 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1282 const char *refname
, const struct object_id
*new_oid
,
1283 const struct object_id
*old_oid
, unsigned int flags
,
1284 enum action_on_err onerr
)
1286 struct ref_transaction
*t
= NULL
;
1287 struct strbuf err
= STRBUF_INIT
;
1290 t
= ref_store_transaction_begin(refs
, &err
);
1292 ref_transaction_update(t
, refname
, new_oid
, old_oid
, NULL
, NULL
,
1293 flags
, msg
, &err
) ||
1294 ref_transaction_commit(t
, &err
)) {
1296 ref_transaction_free(t
);
1299 const char *str
= _("update_ref failed for ref '%s': %s");
1302 case UPDATE_REFS_MSG_ON_ERR
:
1303 error(str
, refname
, err
.buf
);
1305 case UPDATE_REFS_DIE_ON_ERR
:
1306 die(str
, refname
, err
.buf
);
1308 case UPDATE_REFS_QUIET_ON_ERR
:
1311 strbuf_release(&err
);
1314 strbuf_release(&err
);
1316 ref_transaction_free(t
);
1321 * Check that the string refname matches a rule of the form
1322 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1323 * "foo/%.*s/baz", and return the string "bar".
1325 static const char *match_parse_rule(const char *refname
, const char *rule
,
1329 * Check that rule matches refname up to the first percent in the rule.
1330 * We can bail immediately if not, but otherwise we leave "rule" at the
1331 * %-placeholder, and "refname" at the start of the potential matched
1334 while (*rule
!= '%') {
1336 BUG("rev-parse rule did not have percent");
1337 if (*refname
++ != *rule
++)
1342 * Check that our "%" is the expected placeholder. This assumes there
1343 * are no other percents (placeholder or quoted) in the string, but
1344 * that is sufficient for our rev-parse rules.
1346 if (!skip_prefix(rule
, "%.*s", &rule
))
1350 * And now check that our suffix (if any) matches.
1352 if (!strip_suffix(refname
, rule
, len
))
1355 return refname
; /* len set by strip_suffix() */
1358 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1359 const char *refname
, int strict
)
1362 struct strbuf resolved_buf
= STRBUF_INIT
;
1364 /* skip first rule, it will always match */
1365 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1367 int rules_to_fail
= i
;
1368 const char *short_name
;
1369 size_t short_name_len
;
1371 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1377 * in strict mode, all (except the matched one) rules
1378 * must fail to resolve to a valid non-ambiguous ref
1381 rules_to_fail
= NUM_REV_PARSE_RULES
;
1384 * check if the short name resolves to a valid ref,
1385 * but use only rules prior to the matched one
1387 for (j
= 0; j
< rules_to_fail
; j
++) {
1388 const char *rule
= ref_rev_parse_rules
[j
];
1390 /* skip matched rule */
1395 * the short name is ambiguous, if it resolves
1396 * (with this previous rule) to a valid ref
1397 * read_ref() returns 0 on success
1399 strbuf_reset(&resolved_buf
);
1400 strbuf_addf(&resolved_buf
, rule
,
1401 cast_size_t_to_int(short_name_len
),
1403 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1408 * short name is non-ambiguous if all previous rules
1409 * haven't resolved to a valid ref
1411 if (j
== rules_to_fail
) {
1412 strbuf_release(&resolved_buf
);
1413 return xmemdupz(short_name
, short_name_len
);
1417 strbuf_release(&resolved_buf
);
1418 return xstrdup(refname
);
1421 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1422 struct strvec
*hide_refs
)
1425 if (!strcmp("transfer.hiderefs", var
) ||
1426 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1427 !strcmp(key
, "hiderefs"))) {
1432 return config_error_nonbool(var
);
1434 /* drop const to remove trailing '/' characters */
1435 ref
= (char *)strvec_push(hide_refs
, value
);
1437 while (len
&& ref
[len
- 1] == '/')
1443 int ref_is_hidden(const char *refname
, const char *refname_full
,
1444 const struct strvec
*hide_refs
)
1448 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1449 const char *match
= hide_refs
->v
[i
];
1450 const char *subject
;
1454 if (*match
== '!') {
1459 if (*match
== '^') {
1460 subject
= refname_full
;
1466 /* refname can be NULL when namespaces are used. */
1468 skip_prefix(subject
, match
, &p
) &&
1475 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1477 const char **pattern
;
1478 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1480 * We can't feed any excludes from hidden refs config
1481 * sections, since later rules may override previous
1482 * ones. For example, with rules "refs/foo" and
1483 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1484 * everything underneath it), but the earlier exclusion
1485 * would cause us to skip all of "refs/foo". We
1486 * likewise don't implement the namespace stripping
1487 * required for '^' rules.
1489 * Both are possible to do, but complicated, so avoid
1490 * populating the jump list at all if we see either of
1493 if (**pattern
== '!' || **pattern
== '^')
1496 return hide_refs
->v
;
1499 const char *find_descendant_ref(const char *dirname
,
1500 const struct string_list
*extras
,
1501 const struct string_list
*skip
)
1509 * Look at the place where dirname would be inserted into
1510 * extras. If there is an entry at that position that starts
1511 * with dirname (remember, dirname includes the trailing
1512 * slash) and is not in skip, then we have a conflict.
1514 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1515 pos
< extras
->nr
; pos
++) {
1516 const char *extra_refname
= extras
->items
[pos
].string
;
1518 if (!starts_with(extra_refname
, dirname
))
1521 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1522 return extra_refname
;
1527 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1529 struct object_id oid
;
1532 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1534 return fn("HEAD", &oid
, flag
, cb_data
);
1539 struct ref_iterator
*refs_ref_iterator_begin(
1540 struct ref_store
*refs
,
1542 const char **exclude_patterns
,
1544 enum do_for_each_ref_flags flags
)
1546 struct ref_iterator
*iter
;
1548 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1549 static int ref_paranoia
= -1;
1551 if (ref_paranoia
< 0)
1552 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1554 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1555 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1559 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1561 * `iterator_begin()` already takes care of prefix, but we
1562 * might need to do some trimming:
1565 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1570 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1571 const char **exclude_patterns
,
1572 each_ref_fn fn
, int trim
,
1573 enum do_for_each_ref_flags flags
, void *cb_data
)
1575 struct ref_iterator
*iter
;
1580 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1583 return do_for_each_ref_iterator(iter
, fn
, cb_data
);
1586 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1588 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1591 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1592 each_ref_fn fn
, void *cb_data
)
1594 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1597 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1598 const char **exclude_patterns
,
1599 each_ref_fn fn
, void *cb_data
)
1601 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1604 int refs_for_each_replace_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1606 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1607 return do_for_each_ref(refs
, git_replace_ref_base
, NULL
, fn
,
1608 strlen(git_replace_ref_base
),
1609 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1612 int refs_for_each_namespaced_ref(struct ref_store
*refs
,
1613 const char **exclude_patterns
,
1614 each_ref_fn fn
, void *cb_data
)
1616 struct strbuf buf
= STRBUF_INIT
;
1618 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1619 ret
= do_for_each_ref(refs
, buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1620 strbuf_release(&buf
);
1624 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1626 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1627 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1630 int refs_for_each_include_root_refs(struct ref_store
*refs
, each_ref_fn fn
,
1633 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1634 DO_FOR_EACH_INCLUDE_ROOT_REFS
, cb_data
);
1637 static int qsort_strcmp(const void *va
, const void *vb
)
1639 const char *a
= *(const char **)va
;
1640 const char *b
= *(const char **)vb
;
1642 return strcmp(a
, b
);
1645 static void find_longest_prefixes_1(struct string_list
*out
,
1646 struct strbuf
*prefix
,
1647 const char **patterns
, size_t nr
)
1651 for (i
= 0; i
< nr
; i
++) {
1652 char c
= patterns
[i
][prefix
->len
];
1653 if (!c
|| is_glob_special(c
)) {
1654 string_list_append(out
, prefix
->buf
);
1664 * Set "end" to the index of the element _after_ the last one
1667 for (end
= i
+ 1; end
< nr
; end
++) {
1668 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1672 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1673 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1674 strbuf_setlen(prefix
, prefix
->len
- 1);
1680 static void find_longest_prefixes(struct string_list
*out
,
1681 const char **patterns
)
1683 struct strvec sorted
= STRVEC_INIT
;
1684 struct strbuf prefix
= STRBUF_INIT
;
1686 strvec_pushv(&sorted
, patterns
);
1687 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1689 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1691 strvec_clear(&sorted
);
1692 strbuf_release(&prefix
);
1695 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1696 const char *namespace,
1697 const char **patterns
,
1698 const char **exclude_patterns
,
1699 each_ref_fn fn
, void *cb_data
)
1701 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1702 struct string_list_item
*prefix
;
1703 struct strbuf buf
= STRBUF_INIT
;
1704 int ret
= 0, namespace_len
;
1706 find_longest_prefixes(&prefixes
, patterns
);
1709 strbuf_addstr(&buf
, namespace);
1710 namespace_len
= buf
.len
;
1712 for_each_string_list_item(prefix
, &prefixes
) {
1713 strbuf_addstr(&buf
, prefix
->string
);
1714 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1715 exclude_patterns
, fn
, cb_data
);
1718 strbuf_setlen(&buf
, namespace_len
);
1721 string_list_clear(&prefixes
, 0);
1722 strbuf_release(&buf
);
1726 static int refs_read_special_head(struct ref_store
*ref_store
,
1727 const char *refname
, struct object_id
*oid
,
1728 struct strbuf
*referent
, unsigned int *type
,
1731 struct strbuf full_path
= STRBUF_INIT
;
1732 struct strbuf content
= STRBUF_INIT
;
1734 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1736 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1737 *failure_errno
= errno
;
1741 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1745 strbuf_release(&full_path
);
1746 strbuf_release(&content
);
1750 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1751 struct object_id
*oid
, struct strbuf
*referent
,
1752 unsigned int *type
, int *failure_errno
)
1754 assert(failure_errno
);
1755 if (is_pseudo_ref(refname
))
1756 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1757 type
, failure_errno
);
1759 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1760 type
, failure_errno
);
1763 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1764 struct strbuf
*referent
)
1766 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1769 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1770 const char *refname
,
1772 struct object_id
*oid
,
1775 static struct strbuf sb_refname
= STRBUF_INIT
;
1776 struct object_id unused_oid
;
1783 flags
= &unused_flags
;
1787 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1788 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1789 !refname_is_safe(refname
))
1793 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1794 * missing refs and refs that were present but invalid,
1795 * to complain about the latter to stderr.
1797 * We don't know whether the ref exists, so don't set
1800 *flags
|= REF_BAD_NAME
;
1803 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1804 unsigned int read_flags
= 0;
1807 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1808 &read_flags
, &failure_errno
)) {
1809 *flags
|= read_flags
;
1811 /* In reading mode, refs must eventually resolve */
1812 if (resolve_flags
& RESOLVE_REF_READING
)
1816 * Otherwise a missing ref is OK. But the files backend
1817 * may show errors besides ENOENT if there are
1818 * similarly-named refs.
1820 if (failure_errno
!= ENOENT
&&
1821 failure_errno
!= EISDIR
&&
1822 failure_errno
!= ENOTDIR
)
1826 if (*flags
& REF_BAD_NAME
)
1827 *flags
|= REF_ISBROKEN
;
1831 *flags
|= read_flags
;
1833 if (!(read_flags
& REF_ISSYMREF
)) {
1834 if (*flags
& REF_BAD_NAME
) {
1836 *flags
|= REF_ISBROKEN
;
1841 refname
= sb_refname
.buf
;
1842 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1846 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1847 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1848 !refname_is_safe(refname
))
1851 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1858 /* backend functions */
1859 int ref_store_create_on_disk(struct ref_store
*refs
, int flags
, struct strbuf
*err
)
1861 return refs
->be
->create_on_disk(refs
, flags
, err
);
1864 int ref_store_remove_on_disk(struct ref_store
*refs
, struct strbuf
*err
)
1866 return refs
->be
->remove_on_disk(refs
, err
);
1869 int repo_resolve_gitlink_ref(struct repository
*r
,
1870 const char *submodule
, const char *refname
,
1871 struct object_id
*oid
)
1873 struct ref_store
*refs
;
1876 refs
= repo_get_submodule_ref_store(r
, submodule
);
1880 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1887 * Look up a ref store by name. If that ref_store hasn't been
1888 * registered yet, return NULL.
1890 static struct ref_store
*lookup_ref_store_map(struct strmap
*map
,
1893 struct strmap_entry
*entry
;
1895 if (!map
->map
.tablesize
)
1896 /* It's initialized on demand in register_ref_store(). */
1899 entry
= strmap_get_entry(map
, name
);
1900 return entry
? entry
->value
: NULL
;
1904 * Create, record, and return a ref_store instance for the specified
1905 * gitdir using the given ref storage format.
1907 static struct ref_store
*ref_store_init(struct repository
*repo
,
1908 enum ref_storage_format format
,
1912 const struct ref_storage_be
*be
;
1913 struct ref_store
*refs
;
1915 be
= find_ref_storage_backend(format
);
1917 BUG("reference backend is unknown");
1919 refs
= be
->init(repo
, gitdir
, flags
);
1923 void ref_store_release(struct ref_store
*ref_store
)
1925 ref_store
->be
->release(ref_store
);
1926 free(ref_store
->gitdir
);
1929 struct ref_store
*get_main_ref_store(struct repository
*r
)
1931 if (r
->refs_private
)
1932 return r
->refs_private
;
1935 BUG("attempting to get main_ref_store outside of repository");
1937 r
->refs_private
= ref_store_init(r
, r
->ref_storage_format
,
1938 r
->gitdir
, REF_STORE_ALL_CAPS
);
1939 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1940 return r
->refs_private
;
1944 * Associate a ref store with a name. It is a fatal error to call this
1945 * function twice for the same name.
1947 static void register_ref_store_map(struct strmap
*map
,
1949 struct ref_store
*refs
,
1952 if (!map
->map
.tablesize
)
1954 if (strmap_put(map
, name
, refs
))
1955 BUG("%s ref_store '%s' initialized twice", type
, name
);
1958 struct ref_store
*repo_get_submodule_ref_store(struct repository
*repo
,
1959 const char *submodule
)
1961 struct strbuf submodule_sb
= STRBUF_INIT
;
1962 struct ref_store
*refs
;
1963 char *to_free
= NULL
;
1965 struct repository
*subrepo
;
1970 len
= strlen(submodule
);
1971 while (len
&& is_dir_sep(submodule
[len
- 1]))
1977 /* We need to strip off one or more trailing slashes */
1978 submodule
= to_free
= xmemdupz(submodule
, len
);
1980 refs
= lookup_ref_store_map(&repo
->submodule_ref_stores
, submodule
);
1984 strbuf_addstr(&submodule_sb
, submodule
);
1985 if (!is_nonbare_repository_dir(&submodule_sb
))
1988 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1991 subrepo
= xmalloc(sizeof(*subrepo
));
1993 if (repo_submodule_init(subrepo
, repo
, submodule
,
1998 refs
= ref_store_init(subrepo
, the_repository
->ref_storage_format
,
2000 REF_STORE_READ
| REF_STORE_ODB
);
2001 register_ref_store_map(&repo
->submodule_ref_stores
, "submodule",
2005 strbuf_release(&submodule_sb
);
2011 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2013 struct ref_store
*refs
;
2017 return get_main_ref_store(wt
->repo
);
2019 id
= wt
->id
? wt
->id
: "/";
2020 refs
= lookup_ref_store_map(&wt
->repo
->worktree_ref_stores
, id
);
2025 struct strbuf common_path
= STRBUF_INIT
;
2026 strbuf_git_common_path(&common_path
, wt
->repo
,
2027 "worktrees/%s", wt
->id
);
2028 refs
= ref_store_init(wt
->repo
, wt
->repo
->ref_storage_format
,
2029 common_path
.buf
, REF_STORE_ALL_CAPS
);
2030 strbuf_release(&common_path
);
2032 refs
= ref_store_init(wt
->repo
, the_repository
->ref_storage_format
,
2033 wt
->repo
->commondir
, REF_STORE_ALL_CAPS
);
2037 register_ref_store_map(&wt
->repo
->worktree_ref_stores
,
2038 "worktree", refs
, id
);
2043 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2044 const char *path
, const struct ref_storage_be
*be
)
2048 refs
->gitdir
= xstrdup(path
);
2051 /* backend functions */
2052 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2054 return refs
->be
->pack_refs(refs
, opts
);
2057 int peel_iterated_oid(struct repository
*r
, const struct object_id
*base
, struct object_id
*peeled
)
2059 if (current_ref_iter
&&
2060 (current_ref_iter
->oid
== base
||
2061 oideq(current_ref_iter
->oid
, base
)))
2062 return ref_iterator_peel(current_ref_iter
, peeled
);
2064 return peel_object(r
, base
, peeled
) ? -1 : 0;
2067 int refs_update_symref(struct ref_store
*refs
, const char *ref
,
2068 const char *target
, const char *logmsg
)
2070 struct ref_transaction
*transaction
;
2071 struct strbuf err
= STRBUF_INIT
;
2074 transaction
= ref_store_transaction_begin(refs
, &err
);
2076 ref_transaction_update(transaction
, ref
, NULL
, NULL
,
2077 target
, NULL
, REF_NO_DEREF
,
2079 ref_transaction_commit(transaction
, &err
)) {
2080 ret
= error("%s", err
.buf
);
2083 strbuf_release(&err
);
2085 ref_transaction_free(transaction
);
2090 int ref_update_reject_duplicates(struct string_list
*refnames
,
2093 size_t i
, n
= refnames
->nr
;
2097 for (i
= 1; i
< n
; i
++) {
2098 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2099 refnames
->items
[i
].string
);
2103 _("multiple updates for ref '%s' not allowed"),
2104 refnames
->items
[i
].string
);
2106 } else if (cmp
> 0) {
2107 BUG("ref_update_reject_duplicates() received unsorted list");
2113 static int run_transaction_hook(struct ref_transaction
*transaction
,
2116 struct child_process proc
= CHILD_PROCESS_INIT
;
2117 struct strbuf buf
= STRBUF_INIT
;
2121 hook
= find_hook("reference-transaction");
2125 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2127 proc
.stdout_to_stderr
= 1;
2128 proc
.trace2_hook_name
= "reference-transaction";
2130 ret
= start_command(&proc
);
2134 sigchain_push(SIGPIPE
, SIG_IGN
);
2136 for (i
= 0; i
< transaction
->nr
; i
++) {
2137 struct ref_update
*update
= transaction
->updates
[i
];
2141 if (!(update
->flags
& REF_HAVE_OLD
))
2142 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2143 else if (update
->old_target
)
2144 strbuf_addf(&buf
, "ref:%s ", update
->old_target
);
2146 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->old_oid
));
2148 if (!(update
->flags
& REF_HAVE_NEW
))
2149 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2150 else if (update
->new_target
)
2151 strbuf_addf(&buf
, "ref:%s ", update
->new_target
);
2153 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->new_oid
));
2155 strbuf_addf(&buf
, "%s\n", update
->refname
);
2157 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2158 if (errno
!= EPIPE
) {
2159 /* Don't leak errno outside this API */
2168 sigchain_pop(SIGPIPE
);
2169 strbuf_release(&buf
);
2171 ret
|= finish_command(&proc
);
2175 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2178 struct ref_store
*refs
= transaction
->ref_store
;
2181 switch (transaction
->state
) {
2182 case REF_TRANSACTION_OPEN
:
2185 case REF_TRANSACTION_PREPARED
:
2186 BUG("prepare called twice on reference transaction");
2188 case REF_TRANSACTION_CLOSED
:
2189 BUG("prepare called on a closed reference transaction");
2192 BUG("unexpected reference transaction state");
2196 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2198 _("ref updates forbidden inside quarantine environment"));
2202 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2206 ret
= run_transaction_hook(transaction
, "prepared");
2208 ref_transaction_abort(transaction
, err
);
2209 die(_("ref updates aborted by hook"));
2215 int ref_transaction_abort(struct ref_transaction
*transaction
,
2218 struct ref_store
*refs
= transaction
->ref_store
;
2221 switch (transaction
->state
) {
2222 case REF_TRANSACTION_OPEN
:
2223 /* No need to abort explicitly. */
2225 case REF_TRANSACTION_PREPARED
:
2226 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2228 case REF_TRANSACTION_CLOSED
:
2229 BUG("abort called on a closed reference transaction");
2232 BUG("unexpected reference transaction state");
2236 run_transaction_hook(transaction
, "aborted");
2238 ref_transaction_free(transaction
);
2242 int ref_transaction_commit(struct ref_transaction
*transaction
,
2245 struct ref_store
*refs
= transaction
->ref_store
;
2248 switch (transaction
->state
) {
2249 case REF_TRANSACTION_OPEN
:
2250 /* Need to prepare first. */
2251 ret
= ref_transaction_prepare(transaction
, err
);
2255 case REF_TRANSACTION_PREPARED
:
2256 /* Fall through to finish. */
2258 case REF_TRANSACTION_CLOSED
:
2259 BUG("commit called on a closed reference transaction");
2262 BUG("unexpected reference transaction state");
2266 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2268 run_transaction_hook(transaction
, "committed");
2272 int refs_verify_refname_available(struct ref_store
*refs
,
2273 const char *refname
,
2274 const struct string_list
*extras
,
2275 const struct string_list
*skip
,
2279 const char *extra_refname
;
2280 struct strbuf dirname
= STRBUF_INIT
;
2281 struct strbuf referent
= STRBUF_INIT
;
2282 struct object_id oid
;
2284 struct ref_iterator
*iter
;
2289 * For the sake of comments in this function, suppose that
2290 * refname is "refs/foo/bar".
2295 strbuf_grow(&dirname
, strlen(refname
) + 1);
2296 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2298 * Just saying "Is a directory" when we e.g. can't
2299 * lock some multi-level ref isn't very informative,
2300 * the user won't be told *what* is a directory, so
2301 * let's not use strerror() below.
2304 /* Expand dirname to the new prefix, not including the trailing slash: */
2305 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2308 * We are still at a leading dir of the refname (e.g.,
2309 * "refs/foo"; if there is a reference with that name,
2310 * it is a conflict, *unless* it is in skip.
2312 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2315 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2316 &type
, &ignore_errno
)) {
2317 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2318 dirname
.buf
, refname
);
2322 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2323 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2324 refname
, dirname
.buf
);
2330 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2331 * There is no point in searching for a reference with that
2332 * name, because a refname isn't considered to conflict with
2333 * itself. But we still need to check for references whose
2334 * names are in the "refs/foo/bar/" namespace, because they
2337 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2338 strbuf_addch(&dirname
, '/');
2340 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2341 DO_FOR_EACH_INCLUDE_BROKEN
);
2342 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2344 string_list_has_string(skip
, iter
->refname
))
2347 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2348 iter
->refname
, refname
);
2349 ref_iterator_abort(iter
);
2353 if (ok
!= ITER_DONE
)
2354 BUG("error while iterating over references");
2356 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2358 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2359 refname
, extra_refname
);
2364 strbuf_release(&referent
);
2365 strbuf_release(&dirname
);
2369 struct do_for_each_reflog_help
{
2374 static int do_for_each_reflog_helper(const char *refname
,
2375 const struct object_id
*oid UNUSED
,
2379 struct do_for_each_reflog_help
*hp
= cb_data
;
2380 return hp
->fn(refname
, hp
->cb_data
);
2383 int refs_for_each_reflog(struct ref_store
*refs
, each_reflog_fn fn
, void *cb_data
)
2385 struct ref_iterator
*iter
;
2386 struct do_for_each_reflog_help hp
= { fn
, cb_data
};
2388 iter
= refs
->be
->reflog_iterator_begin(refs
);
2390 return do_for_each_ref_iterator(iter
, do_for_each_reflog_helper
, &hp
);
2393 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2394 const char *refname
,
2395 each_reflog_ent_fn fn
,
2398 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2402 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2403 each_reflog_ent_fn fn
, void *cb_data
)
2405 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2408 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2410 return refs
->be
->reflog_exists(refs
, refname
);
2413 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2416 return refs
->be
->create_reflog(refs
, refname
, err
);
2419 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2421 return refs
->be
->delete_reflog(refs
, refname
);
2424 int refs_reflog_expire(struct ref_store
*refs
,
2425 const char *refname
,
2427 reflog_expiry_prepare_fn prepare_fn
,
2428 reflog_expiry_should_prune_fn should_prune_fn
,
2429 reflog_expiry_cleanup_fn cleanup_fn
,
2430 void *policy_cb_data
)
2432 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2433 prepare_fn
, should_prune_fn
,
2434 cleanup_fn
, policy_cb_data
);
2437 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2440 struct ref_store
*refs
= transaction
->ref_store
;
2442 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2445 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2446 ref_transaction_for_each_queued_update_fn cb
,
2451 for (i
= 0; i
< transaction
->nr
; i
++) {
2452 struct ref_update
*update
= transaction
->updates
[i
];
2455 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2456 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2461 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2462 struct string_list
*refnames
, unsigned int flags
)
2464 struct ref_transaction
*transaction
;
2465 struct strbuf err
= STRBUF_INIT
;
2466 struct string_list_item
*item
;
2467 int ret
= 0, failures
= 0;
2473 msg
= normalize_reflog_message(logmsg
);
2476 * Since we don't check the references' old_oids, the
2477 * individual updates can't fail, so we can pack all of the
2478 * updates into a single transaction.
2480 transaction
= ref_store_transaction_begin(refs
, &err
);
2482 ret
= error("%s", err
.buf
);
2486 for_each_string_list_item(item
, refnames
) {
2487 ret
= ref_transaction_delete(transaction
, item
->string
,
2488 NULL
, flags
, msg
, &err
);
2490 warning(_("could not delete reference %s: %s"),
2491 item
->string
, err
.buf
);
2497 ret
= ref_transaction_commit(transaction
, &err
);
2499 if (refnames
->nr
== 1)
2500 error(_("could not delete reference %s: %s"),
2501 refnames
->items
[0].string
, err
.buf
);
2503 error(_("could not delete references: %s"), err
.buf
);
2507 if (!ret
&& failures
)
2509 ref_transaction_free(transaction
);
2510 strbuf_release(&err
);
2515 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2516 const char *newref
, const char *logmsg
)
2521 msg
= normalize_reflog_message(logmsg
);
2522 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2527 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2528 const char *newref
, const char *logmsg
)
2533 msg
= normalize_reflog_message(logmsg
);
2534 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2539 const char *ref_update_original_update_refname(struct ref_update
*update
)
2541 while (update
->parent_update
)
2542 update
= update
->parent_update
;
2544 return update
->refname
;
2547 int ref_update_has_null_new_value(struct ref_update
*update
)
2549 return !update
->new_target
&& is_null_oid(&update
->new_oid
);
2552 int ref_update_check_old_target(const char *referent
, struct ref_update
*update
,
2555 if (!update
->old_target
)
2556 BUG("called without old_target set");
2558 if (!strcmp(referent
, update
->old_target
))
2561 if (!strcmp(referent
, ""))
2562 strbuf_addf(err
, "verifying symref target: '%s': "
2563 "reference is missing but expected %s",
2564 ref_update_original_update_refname(update
),
2565 update
->old_target
);
2567 strbuf_addf(err
, "verifying symref target: '%s': "
2568 "is at %s but expected %s",
2569 ref_update_original_update_refname(update
),
2570 referent
, update
->old_target
);
2574 struct migration_data
{
2575 struct ref_store
*old_refs
;
2576 struct ref_transaction
*transaction
;
2577 struct strbuf
*errbuf
;
2580 static int migrate_one_ref(const char *refname
, const struct object_id
*oid
,
2581 int flags
, void *cb_data
)
2583 struct migration_data
*data
= cb_data
;
2584 struct strbuf symref_target
= STRBUF_INIT
;
2587 if (flags
& REF_ISSYMREF
) {
2588 ret
= refs_read_symbolic_ref(data
->old_refs
, refname
, &symref_target
);
2592 ret
= ref_transaction_update(data
->transaction
, refname
, NULL
, null_oid(),
2593 symref_target
.buf
, NULL
,
2594 REF_SKIP_CREATE_REFLOG
| REF_NO_DEREF
, NULL
, data
->errbuf
);
2598 ret
= ref_transaction_create(data
->transaction
, refname
, oid
,
2599 REF_SKIP_CREATE_REFLOG
| REF_SKIP_OID_VERIFICATION
,
2600 NULL
, data
->errbuf
);
2606 strbuf_release(&symref_target
);
2610 static int move_files(const char *from_path
, const char *to_path
, struct strbuf
*errbuf
)
2612 struct strbuf from_buf
= STRBUF_INIT
, to_buf
= STRBUF_INIT
;
2613 size_t from_len
, to_len
;
2617 from_dir
= opendir(from_path
);
2619 strbuf_addf(errbuf
, "could not open source directory '%s': %s",
2620 from_path
, strerror(errno
));
2625 strbuf_addstr(&from_buf
, from_path
);
2626 strbuf_complete(&from_buf
, '/');
2627 from_len
= from_buf
.len
;
2629 strbuf_addstr(&to_buf
, to_path
);
2630 strbuf_complete(&to_buf
, '/');
2631 to_len
= to_buf
.len
;
2637 ent
= readdir(from_dir
);
2641 if (!strcmp(ent
->d_name
, ".") ||
2642 !strcmp(ent
->d_name
, ".."))
2645 strbuf_setlen(&from_buf
, from_len
);
2646 strbuf_addstr(&from_buf
, ent
->d_name
);
2648 strbuf_setlen(&to_buf
, to_len
);
2649 strbuf_addstr(&to_buf
, ent
->d_name
);
2651 ret
= rename(from_buf
.buf
, to_buf
.buf
);
2653 strbuf_addf(errbuf
, "could not link file '%s' to '%s': %s",
2654 from_buf
.buf
, to_buf
.buf
, strerror(errno
));
2660 strbuf_addf(errbuf
, "could not read entry from directory '%s': %s",
2661 from_path
, strerror(errno
));
2669 strbuf_release(&from_buf
);
2670 strbuf_release(&to_buf
);
2676 static int count_reflogs(const char *reflog UNUSED
, void *payload
)
2678 size_t *reflog_count
= payload
;
2683 static int has_worktrees(void)
2685 struct worktree
**worktrees
= get_worktrees();
2689 for (i
= 0; worktrees
[i
]; i
++) {
2690 if (is_main_worktree(worktrees
[i
]))
2695 free_worktrees(worktrees
);
2699 int repo_migrate_ref_storage_format(struct repository
*repo
,
2700 enum ref_storage_format format
,
2702 struct strbuf
*errbuf
)
2704 struct ref_store
*old_refs
= NULL
, *new_refs
= NULL
;
2705 struct ref_transaction
*transaction
= NULL
;
2706 struct strbuf new_gitdir
= STRBUF_INIT
;
2707 struct migration_data data
;
2708 size_t reflog_count
= 0;
2709 int did_migrate_refs
= 0;
2712 if (repo
->ref_storage_format
== format
) {
2713 strbuf_addstr(errbuf
, "current and new ref storage format are equal");
2718 old_refs
= get_main_ref_store(repo
);
2721 * We do not have any interfaces that would allow us to write many
2722 * reflog entries. Once we have them we can remove this restriction.
2724 if (refs_for_each_reflog(old_refs
, count_reflogs
, &reflog_count
) < 0) {
2725 strbuf_addstr(errbuf
, "cannot count reflogs");
2730 strbuf_addstr(errbuf
, "migrating reflogs is not supported yet");
2736 * Worktrees complicate the migration because every worktree has a
2737 * separate ref storage. While it should be feasible to implement, this
2738 * is pushed out to a future iteration.
2740 * TODO: we should really be passing the caller-provided repository to
2741 * `has_worktrees()`, but our worktree subsystem doesn't yet support
2744 if (has_worktrees()) {
2745 strbuf_addstr(errbuf
, "migrating repositories with worktrees is not supported yet");
2751 * The overall logic looks like this:
2753 * 1. Set up a new temporary directory and initialize it with the new
2754 * format. This is where all refs will be migrated into.
2756 * 2. Enumerate all refs and write them into the new ref storage.
2757 * This operation is safe as we do not yet modify the main
2760 * 3. If we're in dry-run mode then we are done and can hand over the
2761 * directory to the caller for inspection. If not, we now start
2762 * with the destructive part.
2764 * 4. Delete the old ref storage from disk. As we have a copy of refs
2765 * in the new ref storage it's okay(ish) if we now get interrupted
2766 * as there is an equivalent copy of all refs available.
2768 * 5. Move the new ref storage files into place.
2770 * 6. Change the repository format to the new ref format.
2772 strbuf_addf(&new_gitdir
, "%s/%s", old_refs
->gitdir
, "ref_migration.XXXXXX");
2773 if (!mkdtemp(new_gitdir
.buf
)) {
2774 strbuf_addf(errbuf
, "cannot create migration directory: %s",
2780 new_refs
= ref_store_init(repo
, format
, new_gitdir
.buf
,
2781 REF_STORE_ALL_CAPS
);
2782 ret
= ref_store_create_on_disk(new_refs
, 0, errbuf
);
2786 transaction
= ref_store_transaction_begin(new_refs
, errbuf
);
2790 data
.old_refs
= old_refs
;
2791 data
.transaction
= transaction
;
2792 data
.errbuf
= errbuf
;
2795 * We need to use the internal `do_for_each_ref()` here so that we can
2796 * also include broken refs and symrefs. These would otherwise be
2799 * Ideally, we would do this call while locking the old ref storage
2800 * such that there cannot be any concurrent modifications. We do not
2801 * have the infra for that though, and the "files" backend does not
2802 * allow for a central lock due to its design. It's thus on the user to
2803 * ensure that there are no concurrent writes.
2805 ret
= do_for_each_ref(old_refs
, "", NULL
, migrate_one_ref
, 0,
2806 DO_FOR_EACH_INCLUDE_ROOT_REFS
| DO_FOR_EACH_INCLUDE_BROKEN
,
2812 * TODO: we might want to migrate to `initial_ref_transaction_commit()`
2813 * here, which is more efficient for the files backend because it would
2814 * write new refs into the packed-refs file directly. At this point,
2815 * the files backend doesn't handle pseudo-refs and symrefs correctly
2816 * though, so this requires some more work.
2818 ret
= ref_transaction_commit(transaction
, errbuf
);
2821 did_migrate_refs
= 1;
2823 if (flags
& REPO_MIGRATE_REF_STORAGE_FORMAT_DRYRUN
) {
2824 printf(_("Finished dry-run migration of refs, "
2825 "the result can be found at '%s'\n"), new_gitdir
.buf
);
2831 * Until now we were in the non-destructive phase, where we only
2832 * populated the new ref store. From hereon though we are about
2833 * to get hands by deleting the old ref store and then moving
2834 * the new one into place.
2836 * Assuming that there were no concurrent writes, the new ref
2837 * store should have all information. So if we fail from hereon
2838 * we may be in an in-between state, but it would still be able
2839 * to recover by manually moving remaining files from the
2840 * temporary migration directory into place.
2842 ret
= ref_store_remove_on_disk(old_refs
, errbuf
);
2846 ret
= move_files(new_gitdir
.buf
, old_refs
->gitdir
, errbuf
);
2850 if (rmdir(new_gitdir
.buf
) < 0)
2851 warning_errno(_("could not remove temporary migration directory '%s'"),
2855 * We have migrated the repository, so we now need to adjust the
2856 * repository format so that clients will use the new ref store.
2857 * We also need to swap out the repository's main ref store.
2859 initialize_repository_version(hash_algo_by_ptr(repo
->hash_algo
), format
, 1);
2861 free(new_refs
->gitdir
);
2862 new_refs
->gitdir
= xstrdup(old_refs
->gitdir
);
2863 repo
->refs_private
= new_refs
;
2864 ref_store_release(old_refs
);
2869 if (ret
&& did_migrate_refs
) {
2870 strbuf_complete(errbuf
, '\n');
2871 strbuf_addf(errbuf
, _("migrated refs can be found at '%s'"),
2875 if (ret
&& new_refs
)
2876 ref_store_release(new_refs
);
2877 ref_transaction_free(transaction
);
2878 strbuf_release(&new_gitdir
);