kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'ps/refs-wo-the-repository' 

The ref subsystem and the worktree API have been refactored to pass a
repository pointer down the call chain, allowing them to drop
references to the global 'the_repository' variable.  As part of this,
the handling of the 'core.packedRefsTimeout' configuration has been
moved into the per-repository ref store structure.

* ps/refs-wo-the-repository:
  refs: remove remaining uses of `the_repository`
  worktree: pass repository to public functions
  worktree: pass repository to file-local functions
  worktree: refactor code to use available repositories
  refs/files: drop `USE_THE_REPOSITORY_VARIABLE`
  refs/packed: de-globalize handling of "core.packedRefsTimeout"
main
Junio C Hamano 2026-07-27 09:08:59 -07:00
parent f931547dff b1296cb1aa
commit 0c20b08631
25 changed files with 208 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
branch.c
View File

@ -372,7 +372,7 @@ int read_branch_desc(struct strbuf *buf, const char *branch_name)
*/ */
int validate_branchname(const char *name, struct strbuf *ref) int validate_branchname(const char *name, struct strbuf *ref)
{ {
if (check_branch_ref(ref, name)) { if (check_branch_ref(the_repository, ref, name)) {
int code = die_message(_("'%s' is not a valid branch name"), name); int code = die_message(_("'%s' is not a valid branch name"), name);
advise_if_enabled(ADVICE_REF_SYNTAX, advise_if_enabled(ADVICE_REF_SYNTAX,
_("See 'git help check-ref-format'")); _("See 'git help check-ref-format'"));
@ -394,7 +394,7 @@ static void prepare_checked_out_branches(void)
return; return;
initialized_checked_out_branches = 1; initialized_checked_out_branches = 1;


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);


while (worktrees[i]) { while (worktrees[i]) {
char *old, *wt_gitdir; char *old, *wt_gitdir;
@ -846,7 +846,7 @@ void remove_branch_state(struct repository *r, int verbose)


void die_if_checked_out(const char *branch, int ignore_current_worktree) void die_if_checked_out(const char *branch, int ignore_current_worktree)
{ {
struct worktree **worktrees = get_worktrees(); struct worktree **worktrees = get_worktrees(the_repository);


for (int i = 0; worktrees[i]; i++) { for (int i = 0; worktrees[i]; i++) {
if (worktrees[i]->is_current && ignore_current_worktree) if (worktrees[i]->is_current && ignore_current_worktree)

16
builtin/branch.c
View File

@ -259,7 +259,8 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
char *target = NULL; char *target = NULL;
int flags = 0; int flags = 0;


copy_branchname(&bname, argv[i], allowed_interpret); copy_branchname(the_repository, &bname,
argv[i], allowed_interpret);
free(name); free(name);
name = mkpathdup(fmt, bname.buf); name = mkpathdup(fmt, bname.buf);


@ -579,9 +580,9 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
const char *interpreted_oldname = NULL; const char *interpreted_oldname = NULL;
const char *interpreted_newname = NULL; const char *interpreted_newname = NULL;
int recovery = 0, oldref_usage = 0; int recovery = 0, oldref_usage = 0;
struct worktree **worktrees = get_worktrees(); struct worktree **worktrees = get_worktrees(the_repository);


if (check_branch_ref(&oldref, oldname)) { if (check_branch_ref(the_repository, &oldref, oldname)) {
/* /*
* Bad name --- this could be an attempt to rename a * Bad name --- this could be an attempt to rename a
* ref that we used to allow to be created by accident. * ref that we used to allow to be created by accident.
@ -921,7 +922,8 @@ int cmd_branch(int argc,
die(_("cannot give description to detached HEAD")); die(_("cannot give description to detached HEAD"));
branch_name = head; branch_name = head;
} else if (argc == 1) { } else if (argc == 1) {
copy_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL); copy_branchname(the_repository, &buf, argv[0],
INTERPRET_BRANCH_LOCAL);
branch_name = buf.buf; branch_name = buf.buf;
} else { } else {
die(_("cannot edit description of more than one branch")); die(_("cannot edit description of more than one branch"));
@ -964,7 +966,8 @@ int cmd_branch(int argc,
if (!argc) if (!argc)
branch = branch_get(NULL); branch = branch_get(NULL);
else if (argc == 1) { else if (argc == 1) {
copy_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL); copy_branchname(the_repository, &buf, argv[0],
INTERPRET_BRANCH_LOCAL);
branch = branch_get(buf.buf); branch = branch_get(buf.buf);
} else } else
die(_("too many arguments to set new upstream")); die(_("too many arguments to set new upstream"));
@ -1003,7 +1006,8 @@ int cmd_branch(int argc,
if (!argc) if (!argc)
branch = branch_get(NULL); branch = branch_get(NULL);
else if (argc == 1) { else if (argc == 1) {
copy_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL); copy_branchname(the_repository, &buf, argv[0],
INTERPRET_BRANCH_LOCAL);
branch = branch_get(buf.buf); branch = branch_get(buf.buf);
} else } else
die(_("too many arguments to unset upstream")); die(_("too many arguments to unset upstream"));

2
builtin/check-ref-format.c
View File

@ -45,7 +45,7 @@ static int check_ref_format_branch(const char *arg)
int nongit; int nongit;


setup_git_directory_gently(the_repository, &nongit); setup_git_directory_gently(the_repository, &nongit);
if (check_branch_ref(&sb, arg) || if (check_branch_ref(the_repository, &sb, arg) ||
!skip_prefix(sb.buf, "refs/heads/", &name)) !skip_prefix(sb.buf, "refs/heads/", &name))
die("'%s' is not a valid branch name", arg); die("'%s' is not a valid branch name", arg);
printf("%s\n", name); printf("%s\n", name);

2
builtin/checkout.c
View File

@ -805,7 +805,7 @@ static void setup_branch_path(struct branch_info *branch)
&branch->oid, &branch->refname, 0)) &branch->oid, &branch->refname, 0))
repo_get_oid_committish(the_repository, branch->name, &branch->oid); repo_get_oid_committish(the_repository, branch->name, &branch->oid);


copy_branchname(&buf, branch->name, INTERPRET_BRANCH_LOCAL); copy_branchname(the_repository, &buf, branch->name, INTERPRET_BRANCH_LOCAL);
if (strcmp(buf.buf, branch->name)) { if (strcmp(buf.buf, branch->name)) {
free(branch->name); free(branch->name);
branch->name = xstrdup(buf.buf); branch->name = xstrdup(buf.buf);

2
builtin/config.c
View File

@ -974,7 +974,7 @@ static void location_options_init(struct config_location_options *opts,
opts->source.file = opts->file_to_free = repo_git_path(the_repository, "config"); opts->source.file = opts->file_to_free = repo_git_path(the_repository, "config");
opts->source.scope = CONFIG_SCOPE_LOCAL; opts->source.scope = CONFIG_SCOPE_LOCAL;
} else if (opts->use_worktree_config) { } else if (opts->use_worktree_config) {
struct worktree **worktrees = get_worktrees(); struct worktree **worktrees = get_worktrees(the_repository);
if (the_repository->repository_format_worktree_config) if (the_repository->repository_format_worktree_config)
opts->source.file = opts->file_to_free = opts->source.file = opts->file_to_free =
repo_git_path(the_repository, "config.worktree"); repo_git_path(the_repository, "config.worktree");

6
builtin/fsck.c
View File

@ -632,7 +632,7 @@ static void snapshot_refs(struct repository *repo,
refs_for_each_ref_ext(get_main_ref_store(repo), refs_for_each_ref_ext(get_main_ref_store(repo),
snapshot_ref, &data, &opts); snapshot_ref, &data, &opts);


worktrees = get_worktrees(); worktrees = get_worktrees(repo);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
struct worktree *wt = *p; struct worktree *wt = *p;
struct strbuf refname = STRBUF_INIT; struct strbuf refname = STRBUF_INIT;
@ -685,7 +685,7 @@ static void process_refs(struct repository *repo, struct snapshot *snap)
} }


if (include_reflogs) { if (include_reflogs) {
worktrees = get_worktrees(); worktrees = get_worktrees(repo);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
struct worktree *wt = *p; struct worktree *wt = *p;


@ -1121,7 +1121,7 @@ int cmd_fsck(int argc,
verify_index_checksum = 1; verify_index_checksum = 1;
verify_ce_order = 1; verify_ce_order = 1;


worktrees = get_worktrees(); worktrees = get_worktrees(repo);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
struct worktree *wt = *p; struct worktree *wt = *p;
struct index_state istate = struct index_state istate =

2
builtin/gc.c
View File

@ -412,7 +412,7 @@ static int worktree_prune_condition(struct gc_config *cfg)
while (limit && (d = readdir_skip_dot_and_dotdot(dir))) { while (limit && (d = readdir_skip_dot_and_dotdot(dir))) {
char *wtpath; char *wtpath;
strbuf_reset(&buf); strbuf_reset(&buf);
if (should_prune_worktree(d->d_name, &buf, &wtpath, expiry_date)) if (should_prune_worktree(the_repository, d->d_name, &buf, &wtpath, expiry_date))
limit--; limit--;
free(wtpath); free(wtpath);
} }

2
builtin/merge.c
View File

@ -553,7 +553,7 @@ static void merge_name(const char *remote, struct strbuf *msg)
char *found_ref = NULL; char *found_ref = NULL;
int len, early; int len, early;


copy_branchname(&bname, remote, 0); copy_branchname(the_repository, &bname, remote, 0);
remote = bname.buf; remote = bname.buf;


oidclr(&branch_head, the_repository->hash_algo); oidclr(&branch_head, the_repository->hash_algo);

2
builtin/notes.c
View File

@ -989,7 +989,7 @@ static int merge(int argc, const char **argv, const char *prefix,
"NOTES_MERGE_PARTIAL", &result_oid, NULL, "NOTES_MERGE_PARTIAL", &result_oid, NULL,
0, UPDATE_REFS_DIE_ON_ERR); 0, UPDATE_REFS_DIE_ON_ERR);
/* Store ref-to-be-updated into .git/NOTES_MERGE_REF */ /* Store ref-to-be-updated into .git/NOTES_MERGE_REF */
worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
wt = find_shared_symref(worktrees, "NOTES_MERGE_REF", wt = find_shared_symref(worktrees, "NOTES_MERGE_REF",
notes_ref); notes_ref);
if (wt) if (wt)

2
builtin/receive-pack.c
View File

@ -1500,7 +1500,7 @@ static const char *update(struct command *cmd, struct shallow_info *si)
struct object_id *old_oid = &cmd->old_oid; struct object_id *old_oid = &cmd->old_oid;
struct object_id *new_oid = &cmd->new_oid; struct object_id *new_oid = &cmd->new_oid;
int do_update_worktree = 0; int do_update_worktree = 0;
struct worktree **worktrees = get_worktrees(); struct worktree **worktrees = get_worktrees(the_repository);
const struct worktree *worktree = const struct worktree *worktree =
find_shared_symref(worktrees, "HEAD", name); find_shared_symref(worktrees, "HEAD", name);



4
builtin/reflog.c
View File

@ -250,7 +250,7 @@ static int cmd_reflog_expire(int argc, const char **argv, const char *prefix,
struct string_list_item *item; struct string_list_item *item;
struct worktree **worktrees, **p; struct worktree **worktrees, **p;


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
if (single_worktree && !(*p)->is_current) if (single_worktree && !(*p)->is_current)
continue; continue;
@ -374,7 +374,7 @@ static int cmd_reflog_drop(int argc, const char **argv, const char *prefix,
struct string_list_item *item; struct string_list_item *item;
struct worktree **worktrees, **p; struct worktree **worktrees, **p;


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
if (single_worktree && !(*p)->is_current) if (single_worktree && !(*p)->is_current)
continue; continue;

2
builtin/refs.c
View File

@ -113,7 +113,7 @@ static int cmd_refs_verify(int argc, const char **argv, const char *prefix,
repo_config(repo, git_fsck_config, &fsck_refs_options); repo_config(repo, git_fsck_config, &fsck_refs_options);
prepare_repo_settings(repo); prepare_repo_settings(repo);


worktrees = get_worktrees_without_reading_head(); worktrees = get_worktrees_without_reading_head(repo);
for (size_t i = 0; worktrees[i]; i++) for (size_t i = 0; worktrees[i]; i++)
ret |= refs_fsck(get_worktree_ref_store(worktrees[i]), ret |= refs_fsck(get_worktree_ref_store(worktrees[i]),
&fsck_refs_options, worktrees[i]); &fsck_refs_options, worktrees[i]);

32
builtin/worktree.c
View File

@ -226,7 +226,7 @@ static void prune_worktrees(void)
while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) { while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) {
char *path; char *path;
strbuf_reset(&reason); strbuf_reset(&reason);
if (should_prune_worktree(d->d_name, &reason, &path, expire)) if (should_prune_worktree(the_repository, d->d_name, &reason, &path, expire))
prune_worktree(d->d_name, reason.buf); prune_worktree(d->d_name, reason.buf);
else if (path) else if (path)
string_list_append_nodup(&kept, path)->util = xstrdup(d->d_name); string_list_append_nodup(&kept, path)->util = xstrdup(d->d_name);
@ -475,13 +475,13 @@ static int add_worktree(const char *path, const char *refname,
struct ref_store *wt_refs; struct ref_store *wt_refs;
struct repo_config_values *cfg = repo_config_values(the_repository); struct repo_config_values *cfg = repo_config_values(the_repository);


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
check_candidate_path(path, opts->force, worktrees, "add"); check_candidate_path(path, opts->force, worktrees, "add");
free_worktrees(worktrees); free_worktrees(worktrees);
worktrees = NULL; worktrees = NULL;


/* is 'refname' a branch or commit? */ /* is 'refname' a branch or commit? */
if (!opts->detach && !check_branch_ref(&symref, refname) && if (!opts->detach && !check_branch_ref(the_repository, &symref, refname) &&
refs_ref_exists(get_main_ref_store(the_repository), symref.buf)) { refs_ref_exists(get_main_ref_store(the_repository), symref.buf)) {
is_branch = 1; is_branch = 1;
if (!opts->force) if (!opts->force)
@ -539,7 +539,8 @@ static int add_worktree(const char *path, const char *refname,


strbuf_reset(&sb); strbuf_reset(&sb);
strbuf_addf(&sb, "%s/gitdir", sb_repo.buf); strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);
write_worktree_linking_files(sb_git.buf, sb.buf, opts->relative_paths); write_worktree_linking_files(the_repository, sb_git.buf,
sb.buf, opts->relative_paths);
strbuf_reset(&sb); strbuf_reset(&sb);
strbuf_addf(&sb, "%s/commondir", sb_repo.buf); strbuf_addf(&sb, "%s/commondir", sb_repo.buf);
write_file(sb.buf, "../.."); write_file(sb.buf, "../..");
@ -547,7 +548,7 @@ static int add_worktree(const char *path, const char *refname,
/* /*
* Set up the ref store of the worktree and create the HEAD reference. * Set up the ref store of the worktree and create the HEAD reference.
*/ */
wt = get_linked_worktree(name, 1); wt = get_linked_worktree(the_repository, name, 1);
if (!wt) { if (!wt) {
ret = error(_("could not find created worktree '%s'"), name); ret = error(_("could not find created worktree '%s'"), name);
goto done; goto done;
@ -649,7 +650,7 @@ static void print_preparing_worktree_line(int detach,
fprintf_ln(stderr, _("Preparing worktree (new branch '%s')"), new_branch); fprintf_ln(stderr, _("Preparing worktree (new branch '%s')"), new_branch);
} else { } else {
struct strbuf s = STRBUF_INIT; struct strbuf s = STRBUF_INIT;
if (!detach && !check_branch_ref(&s, branch) && if (!detach && !check_branch_ref(the_repository, &s, branch) &&
refs_ref_exists(get_main_ref_store(the_repository), s.buf)) refs_ref_exists(get_main_ref_store(the_repository), s.buf))
fprintf_ln(stderr, _("Preparing worktree (checking out '%s')"), fprintf_ln(stderr, _("Preparing worktree (checking out '%s')"),
branch); branch);
@ -771,7 +772,7 @@ static char *dwim_branch(const char *path, char **new_branch)
char *branchname = xstrndup(s, n); char *branchname = xstrndup(s, n);
struct strbuf ref = STRBUF_INIT; struct strbuf ref = STRBUF_INIT;


branch_exists = !check_branch_ref(&ref, branchname) && branch_exists = !check_branch_ref(the_repository, &ref, branchname) &&
refs_ref_exists(get_main_ref_store(the_repository), refs_ref_exists(get_main_ref_store(the_repository),
ref.buf); ref.buf);
strbuf_release(&ref); strbuf_release(&ref);
@ -868,7 +869,7 @@ static int add(int ac, const char **av, const char *prefix,
new_branch = new_branch_force; new_branch = new_branch_force;


if (!opts.force && if (!opts.force &&
!check_branch_ref(&symref, new_branch) && !check_branch_ref(the_repository, &symref, new_branch) &&
refs_ref_exists(get_main_ref_store(the_repository), symref.buf)) refs_ref_exists(get_main_ref_store(the_repository), symref.buf))
die_if_checked_out(symref.buf, 0); die_if_checked_out(symref.buf, 0);
strbuf_release(&symref); strbuf_release(&symref);
@ -1106,7 +1107,7 @@ static int list(int ac, const char **av, const char *prefix,
else if (!line_terminator && !porcelain) else if (!line_terminator && !porcelain)
die(_("the option '%s' requires '%s'"), "-z", "--porcelain"); die(_("the option '%s' requires '%s'"), "-z", "--porcelain");
else { else {
struct worktree **worktrees = get_worktrees(); struct worktree **worktrees = get_worktrees(the_repository);
int path_maxwidth = 0, abbrev = DEFAULT_ABBREV, i; int path_maxwidth = 0, abbrev = DEFAULT_ABBREV, i;
struct worktree_display *display = NULL; struct worktree_display *display = NULL;


@ -1149,7 +1150,7 @@ static int lock_worktree(int ac, const char **av, const char *prefix,
if (ac != 1) if (ac != 1)
usage_with_options(git_worktree_lock_usage, options); usage_with_options(git_worktree_lock_usage, options);


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
wt = find_worktree(worktrees, prefix, av[0]); wt = find_worktree(worktrees, prefix, av[0]);
if (!wt) if (!wt)
die(_("'%s' is not a working tree"), av[0]); die(_("'%s' is not a working tree"), av[0]);
@ -1186,7 +1187,7 @@ static int unlock_worktree(int ac, const char **av, const char *prefix,
if (ac != 1) if (ac != 1)
usage_with_options(git_worktree_unlock_usage, options); usage_with_options(git_worktree_unlock_usage, options);


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
wt = find_worktree(worktrees, prefix, av[0]); wt = find_worktree(worktrees, prefix, av[0]);
if (!wt) if (!wt)
die(_("'%s' is not a working tree"), av[0]); die(_("'%s' is not a working tree"), av[0]);
@ -1272,7 +1273,7 @@ static int move_worktree(int ac, const char **av, const char *prefix,
strbuf_addstr(&dst, path); strbuf_addstr(&dst, path);
free(path); free(path);


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
wt = find_worktree(worktrees, prefix, av[0]); wt = find_worktree(worktrees, prefix, av[0]);
if (!wt) if (!wt)
die(_("'%s' is not a working tree"), av[0]); die(_("'%s' is not a working tree"), av[0]);
@ -1397,7 +1398,7 @@ static int remove_worktree(int ac, const char **av, const char *prefix,
if (ac != 1) if (ac != 1)
usage_with_options(git_worktree_remove_usage, options); usage_with_options(git_worktree_remove_usage, options);


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
wt = find_worktree(worktrees, prefix, av[0]); wt = find_worktree(worktrees, prefix, av[0]);
if (!wt) if (!wt)
die(_("'%s' is not a working tree"), av[0]); die(_("'%s' is not a working tree"), av[0]);
@ -1459,8 +1460,9 @@ static int repair(int ac, const char **av, const char *prefix,
ac = parse_options(ac, av, prefix, options, git_worktree_repair_usage, 0); ac = parse_options(ac, av, prefix, options, git_worktree_repair_usage, 0);
p = ac > 0 ? av : self; p = ac > 0 ? av : self;
for (; *p; p++) for (; *p; p++)
repair_worktree_at_path(*p, report_repair, &rc, use_relative_paths); repair_worktree_at_path(the_repository, *p, report_repair,
repair_worktrees(report_repair, &rc, use_relative_paths); &rc, use_relative_paths);
repair_worktrees(the_repository, report_repair, &rc, use_relative_paths);
return rc; return rc;
} }



4
reachable.c
View File

@ -62,7 +62,7 @@ static void add_rebase_files(struct rev_info *revs)
"rebase-merge/autostash", "rebase-merge/autostash",
"rebase-merge/orig-head", "rebase-merge/orig-head",
}; };
struct worktree **worktrees = get_worktrees(); struct worktree **worktrees = get_worktrees(the_repository);


for (struct worktree **wt = worktrees; *wt; wt++) { for (struct worktree **wt = worktrees; *wt; wt++) {
char *wt_gitdir = get_worktree_git_dir(*wt); char *wt_gitdir = get_worktree_git_dir(*wt);
@ -322,7 +322,7 @@ void mark_reachable_objects(struct rev_info *revs, int mark_reflog,


/* detached HEAD is not included in the list above */ /* detached HEAD is not included in the list above */
refs_head_ref(get_main_ref_store(the_repository), add_one_ref, revs); refs_head_ref(get_main_ref_store(the_repository), add_one_ref, revs);
other_head_refs(add_one_ref, revs); other_head_refs(the_repository, add_one_ref, revs);


/* rebase autostash and orig-head */ /* rebase autostash and orig-head */
add_rebase_files(revs); add_rebase_files(revs);

2
ref-filter.c
View File

@ -2402,7 +2402,7 @@ static void lazy_init_worktree_map(void)
if (ref_to_worktree_map.worktrees) if (ref_to_worktree_map.worktrees)
return; return;


ref_to_worktree_map.worktrees = get_worktrees(); ref_to_worktree_map.worktrees = get_worktrees(the_repository);
hashmap_init(&(ref_to_worktree_map.map), ref_to_worktree_map_cmpfnc, NULL, 0); hashmap_init(&(ref_to_worktree_map.map), ref_to_worktree_map_cmpfnc, NULL, 0);
populate_worktree_map(&(ref_to_worktree_map.map), ref_to_worktree_map.worktrees); populate_worktree_map(&(ref_to_worktree_map.map), ref_to_worktree_map.worktrees);
} }

23
refs.c
View File

@ -2,8 +2,6 @@
* The backend-independent part of the reference module. * The backend-independent part of the reference module.
*/ */


#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h" #include "git-compat-util.h"
#include "abspath.h" #include "abspath.h"
#include "advice.h" #include "advice.h"
@ -744,14 +742,15 @@ static char *substitute_branch_name(struct repository *r,
return NULL; return NULL;
} }


void copy_branchname(struct strbuf *sb, const char *name, void copy_branchname(struct repository *repo,
struct strbuf *sb, const char *name,
enum interpret_branch_kind allowed) enum interpret_branch_kind allowed)
{ {
int len = strlen(name); int len = strlen(name);
struct interpret_branch_name_options options = { struct interpret_branch_name_options options = {
.allowed = allowed .allowed = allowed
}; };
int used = repo_interpret_branch_name(the_repository, name, len, sb, int used = repo_interpret_branch_name(repo, name, len, sb,
&options); &options);


if (used < 0) if (used < 0)
@ -759,10 +758,10 @@ void copy_branchname(struct strbuf *sb, const char *name,
strbuf_add(sb, name + used, len - used); strbuf_add(sb, name + used, len - used);
} }


int check_branch_ref(struct strbuf *sb, const char *name) int check_branch_ref(struct repository *repo, struct strbuf *sb, const char *name)
{ {
if (startup_info->have_repository) if (startup_info->have_repository)
copy_branchname(sb, name, INTERPRET_BRANCH_LOCAL); copy_branchname(repo, sb, name, INTERPRET_BRANCH_LOCAL);
else else
strbuf_addstr(sb, name); strbuf_addstr(sb, name);


@ -3326,9 +3325,9 @@ done:
return ret; return ret;
} }


static int has_worktrees(void) static int has_worktrees(struct repository *repo)
{ {
struct worktree **worktrees = get_worktrees(); struct worktree **worktrees = get_worktrees(repo);
int ret = 0; int ret = 0;
size_t i; size_t i;


@ -3373,12 +3372,8 @@ int repo_migrate_ref_storage_format(struct repository *repo,
* Worktrees complicate the migration because every worktree has a * Worktrees complicate the migration because every worktree has a
* separate ref storage. While it should be feasible to implement, this * separate ref storage. While it should be feasible to implement, this
* is pushed out to a future iteration. * is pushed out to a future iteration.
*
* TODO: we should really be passing the caller-provided repository to
* `has_worktrees()`, but our worktree subsystem doesn't yet support
* that.
*/ */
if (has_worktrees()) { if (has_worktrees(repo)) {
strbuf_addstr(errbuf, "migrating repositories with worktrees is not supported yet"); strbuf_addstr(errbuf, "migrating repositories with worktrees is not supported yet");
ret = -1; ret = -1;
goto done; goto done;
@ -3503,7 +3498,7 @@ int repo_migrate_ref_storage_format(struct repository *repo,
* repository format so that clients will use the new ref store. * repository format so that clients will use the new ref store.
* We also need to swap out the repository's main ref store. * We also need to swap out the repository's main ref store.
*/ */
initialize_repository_version(the_repository, hash_algo_by_ptr(repo->hash_algo), format, 1); initialize_repository_version(repo, hash_algo_by_ptr(repo->hash_algo), format, 1);


/* /*
* Unset the old ref store and release it. `get_main_ref_store()` will * Unset the old ref store and release it. `get_main_ref_store()` will

5
refs.h
View File

@ -234,7 +234,8 @@ char *repo_default_branch_name(struct repository *r, int quiet);
* If "allowed" is non-zero, restrict the set of allowed expansions. See * If "allowed" is non-zero, restrict the set of allowed expansions. See
* repo_interpret_branch_name() for details. * repo_interpret_branch_name() for details.
*/ */
void copy_branchname(struct strbuf *sb, const char *name, void copy_branchname(struct repository *repo,
struct strbuf *sb, const char *name,
enum interpret_branch_kind allowed); enum interpret_branch_kind allowed);


/* /*
@ -243,7 +244,7 @@ void copy_branchname(struct strbuf *sb, const char *name,
* *
* The return value is "0" if the result is valid, and "-1" otherwise. * The return value is "0" if the result is valid, and "-1" otherwise.
*/ */
int check_branch_ref(struct strbuf *sb, const char *name); int check_branch_ref(struct repository *repo, struct strbuf *sb, const char *name);


/* /*
* Similar for a tag name in refs/tags/. * Similar for a tag name in refs/tags/.

35
refs/files-backend.c
View File

@ -1,4 +1,3 @@
#define USE_THE_REPOSITORY_VARIABLE
#define DISABLE_SIGN_COMPARE_WARNINGS #define DISABLE_SIGN_COMPARE_WARNINGS


#include "../git-compat-util.h" #include "../git-compat-util.h"
@ -29,6 +28,9 @@
#include "../revision.h" #include "../revision.h"
#include <wildmatch.h> #include <wildmatch.h>


/* So that we can drop `USE_THE_REPOSITORY_VARIABLE`. */
extern int ignore_case;

/* /*
* This backend uses the following flags in `ref_update::flags` for * This backend uses the following flags in `ref_update::flags` for
* internal bookkeeping purposes. Their numerical values must not * internal bookkeeping purposes. Their numerical values must not
@ -788,7 +790,7 @@ static enum ref_transaction_error lock_raw_ref(struct files_ref_store *refs,
files_ref_path(refs, &ref_file, refname); files_ref_path(refs, &ref_file, refname);


retry: retry:
switch (safe_create_leading_directories(the_repository, ref_file.buf)) { switch (safe_create_leading_directories(refs->base.repo, ref_file.buf)) {
case SCLD_OK: case SCLD_OK:
break; /* success */ break; /* success */
case SCLD_EXISTS: case SCLD_EXISTS:
@ -857,7 +859,7 @@ retry:
} else { } else {
unable_to_lock_message(ref_file.buf, myerr, err); unable_to_lock_message(ref_file.buf, myerr, err);
if (myerr == EEXIST) { if (myerr == EEXIST) {
if (repo_ignore_case(the_repository) && if (repo_ignore_case(refs->base.repo) &&
transaction_has_case_conflicting_update(transaction, update)) { transaction_has_case_conflicting_update(transaction, update)) {
/* /*
* In case-insensitive filesystems, ensure that conflicts within a * In case-insensitive filesystems, ensure that conflicts within a
@ -971,7 +973,7 @@ retry:
* conflicts between 'foo' and 'Foo/bar'. So let's lowercase * conflicts between 'foo' and 'Foo/bar'. So let's lowercase
* the refname. * the refname.
*/ */
if (repo_ignore_case(the_repository)) { if (repo_ignore_case(refs->base.repo)) {
struct strbuf lower = STRBUF_INIT; struct strbuf lower = STRBUF_INIT;


strbuf_addstr(&lower, refname); strbuf_addstr(&lower, refname);
@ -1164,7 +1166,8 @@ typedef int create_file_fn(const char *path, void *cb);
* recent call of fn. fn is always called at least once, and will be * recent call of fn. fn is always called at least once, and will be
* called more than once if it returns ENOENT or EISDIR. * called more than once if it returns ENOENT or EISDIR.
*/ */
static int raceproof_create_file(const char *path, create_file_fn fn, void *cb) static int raceproof_create_file(struct files_ref_store *refs,
const char *path, create_file_fn fn, void *cb)
{ {
/* /*
* The number of times we will try to remove empty directories * The number of times we will try to remove empty directories
@ -1220,7 +1223,7 @@ retry_fn:
strbuf_addstr(&path_copy, path); strbuf_addstr(&path_copy, path);


do { do {
scld_result = safe_create_leading_directories(the_repository, path_copy.buf); scld_result = safe_create_leading_directories(refs->base.repo, path_copy.buf);
if (scld_result == SCLD_OK) if (scld_result == SCLD_OK)
goto retry_fn; goto retry_fn;
} while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0); } while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0);
@ -1289,7 +1292,7 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs,
cb_data.lk = &lock->lk; cb_data.lk = &lock->lk;
cb_data.repo = refs->base.repo; cb_data.repo = refs->base.repo;


if (raceproof_create_file(ref_file.buf, create_reflock, &cb_data)) { if (raceproof_create_file(refs, ref_file.buf, create_reflock, &cb_data)) {
unable_to_lock_message(ref_file.buf, errno, err); unable_to_lock_message(ref_file.buf, errno, err);
goto error_return; goto error_return;
} }
@ -1383,7 +1386,7 @@ static void prune_ref(struct files_ref_store *refs, struct ref_to_prune *r)
ref_transaction_add_update( ref_transaction_add_update(
transaction, r->name, transaction, r->name,
REF_NO_DEREF | REF_HAVE_NEW | REF_HAVE_OLD | REF_IS_PRUNING, REF_NO_DEREF | REF_HAVE_NEW | REF_HAVE_OLD | REF_IS_PRUNING,
null_oid(the_hash_algo), &r->oid, NULL, NULL, NULL, null_oid(refs->base.repo->hash_algo), &r->oid, NULL, NULL, NULL,
NULL, NULL); NULL, NULL);
if (ref_transaction_commit(transaction, &err)) if (ref_transaction_commit(transaction, &err))
goto cleanup; goto cleanup;
@ -1629,7 +1632,7 @@ static int rename_tmp_log(struct files_ref_store *refs, const char *newrefname)
files_reflog_path(refs, &path, newrefname); files_reflog_path(refs, &path, newrefname);
files_reflog_path(refs, &tmp, TMP_RENAMED_LOG); files_reflog_path(refs, &tmp, TMP_RENAMED_LOG);
cb.tmp_renamed_log = tmp.buf; cb.tmp_renamed_log = tmp.buf;
ret = raceproof_create_file(path.buf, rename_tmp_log_callback, &cb); ret = raceproof_create_file(refs, path.buf, rename_tmp_log_callback, &cb);
if (ret) { if (ret) {
if (errno == EISDIR) if (errno == EISDIR)
error("directory not empty: %s", path.buf); error("directory not empty: %s", path.buf);
@ -1916,13 +1919,13 @@ static int log_ref_setup(struct files_ref_store *refs,
char *logfile; char *logfile;


if (log_refs_cfg == LOG_REFS_UNSET) if (log_refs_cfg == LOG_REFS_UNSET)
log_refs_cfg = is_bare_repository(the_repository) ? LOG_REFS_NONE : LOG_REFS_NORMAL; log_refs_cfg = is_bare_repository(refs->base.repo) ? LOG_REFS_NONE : LOG_REFS_NORMAL;


files_reflog_path(refs, &logfile_sb, refname); files_reflog_path(refs, &logfile_sb, refname);
logfile = strbuf_detach(&logfile_sb, NULL); logfile = strbuf_detach(&logfile_sb, NULL);


if (force_create || should_autocreate_reflog(log_refs_cfg, refname)) { if (force_create || should_autocreate_reflog(log_refs_cfg, refname)) {
if (raceproof_create_file(logfile, open_or_create_logfile, logfd)) { if (raceproof_create_file(refs, logfile, open_or_create_logfile, logfd)) {
if (errno == ENOENT) if (errno == ENOENT)
strbuf_addf(err, "unable to create directory for '%s': " strbuf_addf(err, "unable to create directory for '%s': "
"%s", logfile, strerror(errno)); "%s", logfile, strerror(errno));
@ -1955,7 +1958,7 @@ static int log_ref_setup(struct files_ref_store *refs,
} }


if (*logfd >= 0) if (*logfd >= 0)
adjust_shared_perm(the_repository, logfile); adjust_shared_perm(refs->base.repo, logfile);


free(logfile); free(logfile);
return 0; return 0;
@ -3672,8 +3675,8 @@ static int files_ref_store_create_on_disk(struct ref_store *ref_store,
* they do not understand the reference format extension. * they do not understand the reference format extension.
*/ */
strbuf_addf(&sb, "%s/refs", ref_store->gitdir); strbuf_addf(&sb, "%s/refs", ref_store->gitdir);
safe_create_dir(the_repository, sb.buf, 1); safe_create_dir(refs->base.repo, sb.buf, 1);
adjust_shared_perm(the_repository, sb.buf); adjust_shared_perm(refs->base.repo, sb.buf);


/* /*
* There is no need to create directories for common refs when creating * There is no need to create directories for common refs when creating
@ -3685,11 +3688,11 @@ static int files_ref_store_create_on_disk(struct ref_store *ref_store,
*/ */
strbuf_reset(&sb); strbuf_reset(&sb);
files_ref_path(refs, &sb, "refs/heads"); files_ref_path(refs, &sb, "refs/heads");
safe_create_dir(the_repository, sb.buf, 1); safe_create_dir(refs->base.repo, sb.buf, 1);


strbuf_reset(&sb); strbuf_reset(&sb);
files_ref_path(refs, &sb, "refs/tags"); files_ref_path(refs, &sb, "refs/tags");
safe_create_dir(the_repository, sb.buf, 1); safe_create_dir(refs->base.repo, sb.buf, 1);
} }


strbuf_release(&sb); strbuf_release(&sb);

20
refs/packed-backend.c
View File

@ -1,4 +1,3 @@
#define USE_THE_REPOSITORY_VARIABLE
#define DISABLE_SIGN_COMPARE_WARNINGS #define DISABLE_SIGN_COMPARE_WARNINGS


#include "../git-compat-util.h" #include "../git-compat-util.h"
@ -162,6 +161,13 @@ struct packed_ref_store {
* `packed_ref_store`) must not be freed. * `packed_ref_store`) must not be freed.
*/ */
struct tempfile *tempfile; struct tempfile *tempfile;

/*
* Timeout when taking the "packed-refs.lock" file. configurable via
* "core.packedRefsTimeout".
*/
bool timeout_configured;
int timeout_value;
}; };


/* /*
@ -1233,12 +1239,12 @@ int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)
struct packed_ref_store *refs = struct packed_ref_store *refs =
packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN, packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
"packed_refs_lock"); "packed_refs_lock");
static int timeout_configured = 0;
static int timeout_value = 1000;


if (!timeout_configured) { if (!refs->timeout_configured) {
repo_config_get_int(the_repository, "core.packedrefstimeout", &timeout_value); if (repo_config_get_int(ref_store->repo, "core.packedrefstimeout",
timeout_configured = 1; &refs->timeout_value))
refs->timeout_value = 1000;
refs->timeout_configured = true;
} }


/* /*
@ -1249,7 +1255,7 @@ int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)
if (hold_lock_file_for_update_timeout( if (hold_lock_file_for_update_timeout(
&refs->lock, &refs->lock,
refs->path, refs->path,
flags, timeout_value) < 0) { flags, refs->timeout_value) < 0) {
unable_to_lock_message(refs->path, errno, err); unable_to_lock_message(refs->path, errno, err);
return -1; return -1;
} }

6
revision.c
View File

@ -1711,7 +1711,7 @@ static void add_other_reflogs_to_pending(struct all_refs_cb *cb)
{ {
struct worktree **worktrees, **p; struct worktree **worktrees, **p;


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
struct worktree *wt = *p; struct worktree *wt = *p;


@ -1837,7 +1837,7 @@ void add_index_objects_to_pending(struct rev_info *revs, unsigned int flags)
if (revs->single_worktree) if (revs->single_worktree)
return; return;


worktrees = get_worktrees(); worktrees = get_worktrees(the_repository);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
struct worktree *wt = *p; struct worktree *wt = *p;
struct index_state istate = INDEX_STATE_INIT(revs->repo); struct index_state istate = INDEX_STATE_INIT(revs->repo);
@ -2824,7 +2824,7 @@ static int handle_revision_pseudo_opt(struct rev_info *revs,
struct all_refs_cb cb; struct all_refs_cb cb;


init_all_refs_cb(&cb, revs, *flags); init_all_refs_cb(&cb, revs, *flags);
other_head_refs(handle_one_ref, &cb); other_head_refs(the_repository, handle_one_ref, &cb);
} }
clear_ref_exclusions(&revs->ref_excludes); clear_ref_exclusions(&revs->ref_excludes);
} else if (!strcmp(arg, "--branches")) { } else if (!strcmp(arg, "--branches")) {

7
setup.c
View File

@ -2674,7 +2674,8 @@ static void create_object_directory(struct repository *repo)
strbuf_release(&path); strbuf_release(&path);
} }


static void separate_git_dir(const char *git_dir, const char *git_link) static void separate_git_dir(struct repository *repo,
const char *git_dir, const char *git_link)
{ {
struct stat st; struct stat st;


@ -2690,7 +2691,7 @@ static void separate_git_dir(const char *git_dir, const char *git_link)


if (rename(src, git_dir)) if (rename(src, git_dir))
die_errno(_("unable to move %s to %s"), src, git_dir); die_errno(_("unable to move %s to %s"), src, git_dir);
repair_worktrees_after_gitdir_move(src); repair_worktrees_after_gitdir_move(repo, src);
} }


write_file(git_link, "gitdir: %s", git_dir); write_file(git_link, "gitdir: %s", git_dir);
@ -2849,7 +2850,7 @@ int init_db(struct repository *repo,


apply_and_export_relative_gitdir(repo, real_git_dir, 1); apply_and_export_relative_gitdir(repo, real_git_dir, 1);
git_dir = repo_get_git_dir(repo); git_dir = repo_get_git_dir(repo);
separate_git_dir(git_dir, original_git_dir); separate_git_dir(repo, git_dir, original_git_dir);
} else { } else {
apply_and_export_relative_gitdir(repo, git_dir, 1); apply_and_export_relative_gitdir(repo, git_dir, 1);
git_dir = repo_get_git_dir(repo); git_dir = repo_get_git_dir(repo);

2
submodule.c
View File

@ -2494,7 +2494,7 @@ static void relocate_single_git_dir_into_superproject(const char *path,
if (validate_submodule_path(path) < 0) if (validate_submodule_path(path) < 0)
exit(128); exit(128);


if (submodule_uses_worktrees(path)) if (submodule_uses_worktrees(the_repository, path))
die(_("relocate_gitdir for submodule '%s' with " die(_("relocate_gitdir for submodule '%s' with "
"more than one worktree not supported"), path); "more than one worktree not supported"), path);



2
t/helper/test-ref-store.c
View File

@ -84,7 +84,7 @@ static const char **get_store(const char **argv, struct ref_store **refs)


*refs = repo_get_submodule_ref_store(the_repository, gitdir); *refs = repo_get_submodule_ref_store(the_repository, gitdir);
} else if (skip_prefix(argv[0], "worktree:", &gitdir)) { } else if (skip_prefix(argv[0], "worktree:", &gitdir)) {
struct worktree **p, **worktrees = get_worktrees(); struct worktree **p, **worktrees = get_worktrees(the_repository);


for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
struct worktree *wt = *p; struct worktree *wt = *p;

166
worktree.c
View File

@ -1,4 +1,3 @@
#define USE_THE_REPOSITORY_VARIABLE
#define DISABLE_SIGN_COMPARE_WARNINGS #define DISABLE_SIGN_COMPARE_WARNINGS


#include "git-compat-util.h" #include "git-compat-util.h"
@ -111,34 +110,36 @@ static int is_main_worktree_bare(struct repository *repo)
/** /**
* get the main worktree * get the main worktree
*/ */
static struct worktree *get_main_worktree(int skip_reading_head) static struct worktree *get_main_worktree(struct repository *repo,
int skip_reading_head)
{ {
struct worktree *worktree = NULL; struct worktree *worktree = NULL;
struct strbuf worktree_path = STRBUF_INIT; struct strbuf worktree_path = STRBUF_INIT;


strbuf_add_real_path(&worktree_path, repo_get_common_dir(the_repository)); strbuf_add_real_path(&worktree_path, repo_get_common_dir(repo));
strbuf_strip_suffix(&worktree_path, "/.git"); strbuf_strip_suffix(&worktree_path, "/.git");


CALLOC_ARRAY(worktree, 1); CALLOC_ARRAY(worktree, 1);
worktree->repo = the_repository; worktree->repo = repo;
worktree->path = strbuf_detach(&worktree_path, NULL); worktree->path = strbuf_detach(&worktree_path, NULL);
worktree->is_current = is_current_worktree(worktree); worktree->is_current = is_current_worktree(worktree);
worktree->is_bare = (the_repository->bare_cfg == 1) || worktree->is_bare = (repo->bare_cfg == 1) ||
is_bare_repository(the_repository) || is_bare_repository(repo) ||
/* /*
* When in a secondary worktree we have to also verify if the main * When in a secondary worktree we have to also verify if the main
* worktree is bare in $commondir/config.worktree. * worktree is bare in $commondir/config.worktree.
* This check is unnecessary if we're currently in the main worktree, * This check is unnecessary if we're currently in the main worktree,
* as prior checks already consulted all configs of the current worktree. * as prior checks already consulted all configs of the current worktree.
*/ */
(!worktree->is_current && is_main_worktree_bare(the_repository)); (!worktree->is_current && is_main_worktree_bare(repo));


if (!skip_reading_head) if (!skip_reading_head)
add_head_info(worktree); add_head_info(worktree);
return worktree; return worktree;
} }


struct worktree *get_linked_worktree(const char *id, struct worktree *get_linked_worktree(struct repository *repo,
const char *id,
int skip_reading_head) int skip_reading_head)
{ {
struct worktree *worktree = NULL; struct worktree *worktree = NULL;
@ -148,7 +149,7 @@ struct worktree *get_linked_worktree(const char *id,
if (!id) if (!id)
die("Missing linked worktree name"); die("Missing linked worktree name");


repo_common_path_append(the_repository, &path, "worktrees/%s/gitdir", id); repo_common_path_append(repo, &path, "worktrees/%s/gitdir", id);
if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0) if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0)
/* invalid gitdir file */ /* invalid gitdir file */
goto done; goto done;
@ -162,7 +163,7 @@ struct worktree *get_linked_worktree(const char *id,
} }


CALLOC_ARRAY(worktree, 1); CALLOC_ARRAY(worktree, 1);
worktree->repo = the_repository; worktree->repo = repo;
worktree->path = strbuf_detach(&worktree_path, NULL); worktree->path = strbuf_detach(&worktree_path, NULL);
worktree->id = xstrdup(id); worktree->id = xstrdup(id);
worktree->is_current = is_current_worktree(worktree); worktree->is_current = is_current_worktree(worktree);
@ -182,7 +183,8 @@ done:
* retrieving worktree metadata that could be used when the worktree is known * retrieving worktree metadata that could be used when the worktree is known
* to not be in a healthy state, e.g. when creating or repairing it. * to not be in a healthy state, e.g. when creating or repairing it.
*/ */
static struct worktree **get_worktrees_internal(int skip_reading_head) static struct worktree **get_worktrees_internal(struct repository *repo,
int skip_reading_head)
{ {
struct worktree **list = NULL; struct worktree **list = NULL;
struct strbuf path = STRBUF_INIT; struct strbuf path = STRBUF_INIT;
@ -192,16 +194,16 @@ static struct worktree **get_worktrees_internal(int skip_reading_head)


ALLOC_ARRAY(list, alloc); ALLOC_ARRAY(list, alloc);


list[counter++] = get_main_worktree(skip_reading_head); list[counter++] = get_main_worktree(repo, skip_reading_head);


strbuf_addf(&path, "%s/worktrees", repo_get_common_dir(the_repository)); strbuf_addf(&path, "%s/worktrees", repo_get_common_dir(repo));
dir = opendir(path.buf); dir = opendir(path.buf);
strbuf_release(&path); strbuf_release(&path);
if (dir) { if (dir) {
while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) { while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) {
struct worktree *linked = NULL; struct worktree *linked = NULL;


if ((linked = get_linked_worktree(d->d_name, skip_reading_head))) { if ((linked = get_linked_worktree(repo, d->d_name, skip_reading_head))) {
ALLOC_GROW(list, counter + 1, alloc); ALLOC_GROW(list, counter + 1, alloc);
list[counter++] = linked; list[counter++] = linked;
} }
@ -214,14 +216,14 @@ static struct worktree **get_worktrees_internal(int skip_reading_head)
return list; return list;
} }


struct worktree **get_worktrees(void) struct worktree **get_worktrees(struct repository *repo)
{ {
return get_worktrees_internal(0); return get_worktrees_internal(repo, 0);
} }


struct worktree **get_worktrees_without_reading_head(void) struct worktree **get_worktrees_without_reading_head(struct repository *repo)
{ {
return get_worktrees_internal(1); return get_worktrees_internal(repo, 1);
} }


char *get_worktree_git_dir(const struct worktree *wt) char *get_worktree_git_dir(const struct worktree *wt)
@ -334,7 +336,7 @@ const char *worktree_prune_reason(struct worktree *wt, timestamp_t expire)
if (wt->prune_reason_valid) if (wt->prune_reason_valid)
return wt->prune_reason; return wt->prune_reason;


if (should_prune_worktree(wt->id, &reason, &path, expire)) if (should_prune_worktree(wt->repo, wt->id, &reason, &path, expire))
wt->prune_reason = strbuf_detach(&reason, NULL); wt->prune_reason = strbuf_detach(&reason, NULL);
wt->prune_reason_valid = 1; wt->prune_reason_valid = 1;


@ -392,7 +394,7 @@ int validate_worktree(const struct worktree *wt, struct strbuf *errmsg,
if (!is_absolute_path(wt->path)) { if (!is_absolute_path(wt->path)) {
strbuf_addf_gently(errmsg, strbuf_addf_gently(errmsg,
_("'%s' file does not contain absolute path to the working tree location"), _("'%s' file does not contain absolute path to the working tree location"),
repo_common_path_replace(the_repository, &buf, "worktrees/%s/gitdir", wt->id)); repo_common_path_replace(wt->repo, &buf, "worktrees/%s/gitdir", wt->id));
goto done; goto done;
} }


@ -414,12 +416,12 @@ int validate_worktree(const struct worktree *wt, struct strbuf *errmsg,
goto done; goto done;
} }


strbuf_realpath(&realpath, repo_common_path_replace(the_repository, &buf, "worktrees/%s", wt->id), 1); strbuf_realpath(&realpath, repo_common_path_replace(wt->repo, &buf, "worktrees/%s", wt->id), 1);
ret = fspathcmp(path, realpath.buf); ret = fspathcmp(path, realpath.buf);


if (ret) if (ret)
strbuf_addf_gently(errmsg, _("'%s' does not point back to '%s'"), strbuf_addf_gently(errmsg, _("'%s' does not point back to '%s'"),
wt->path, repo_common_path_replace(the_repository, &buf, wt->path, repo_common_path_replace(wt->repo, &buf,
"worktrees/%s", wt->id)); "worktrees/%s", wt->id));
done: done:
free(path); free(path);
@ -440,12 +442,13 @@ void update_worktree_location(struct worktree *wt, const char *path_,
if (is_main_worktree(wt)) if (is_main_worktree(wt))
BUG("can't relocate main worktree"); BUG("can't relocate main worktree");


wt_gitdir = repo_common_path(the_repository, "worktrees/%s/gitdir", wt->id); wt_gitdir = repo_common_path(wt->repo, "worktrees/%s/gitdir", wt->id);
strbuf_realpath(&gitdir, wt_gitdir, 1); strbuf_realpath(&gitdir, wt_gitdir, 1);
strbuf_realpath(&path, path_, 1); strbuf_realpath(&path, path_, 1);
strbuf_addf(&dotgit, "%s/.git", path.buf); strbuf_addf(&dotgit, "%s/.git", path.buf);
if (fspathcmp(wt->path, path.buf)) { if (fspathcmp(wt->path, path.buf)) {
write_worktree_linking_files(dotgit.buf, gitdir.buf, use_relative_paths); write_worktree_linking_files(wt->repo, dotgit.buf,
gitdir.buf, use_relative_paths);


free(wt->path); free(wt->path);
wt->path = strbuf_detach(&path, NULL); wt->path = strbuf_detach(&path, NULL);
@ -533,7 +536,8 @@ const struct worktree *find_shared_symref(struct worktree **worktrees,
return NULL; return NULL;
} }


int submodule_uses_worktrees(const char *path) int submodule_uses_worktrees(struct repository *repo,
const char *path)
{ {
char *submodule_gitdir; char *submodule_gitdir;
struct strbuf sb = STRBUF_INIT, err = STRBUF_INIT; struct strbuf sb = STRBUF_INIT, err = STRBUF_INIT;
@ -542,7 +546,7 @@ int submodule_uses_worktrees(const char *path)
int ret = 0; int ret = 0;
struct repository_format format = REPOSITORY_FORMAT_INIT; struct repository_format format = REPOSITORY_FORMAT_INIT;


submodule_gitdir = repo_submodule_path(the_repository, submodule_gitdir = repo_submodule_path(repo,
path, "%s", ""); path, "%s", "");
if (!submodule_gitdir) if (!submodule_gitdir)
return 0; return 0;
@ -595,13 +599,14 @@ void strbuf_worktree_ref(const struct worktree *wt,
strbuf_addstr(sb, refname); strbuf_addstr(sb, refname);
} }


int other_head_refs(refs_for_each_cb fn, void *cb_data) int other_head_refs(struct repository *repo,
refs_for_each_cb fn, void *cb_data)
{ {
struct worktree **worktrees, **p; struct worktree **worktrees, **p;
struct strbuf refname = STRBUF_INIT; struct strbuf refname = STRBUF_INIT;
int ret = 0; int ret = 0;


worktrees = get_worktrees(); worktrees = get_worktrees(repo);
for (p = worktrees; *p; p++) { for (p = worktrees; *p; p++) {
struct worktree *wt = *p; struct worktree *wt = *p;
struct object_id oid; struct object_id oid;
@ -612,7 +617,7 @@ int other_head_refs(refs_for_each_cb fn, void *cb_data)


strbuf_reset(&refname); strbuf_reset(&refname);
strbuf_worktree_ref(wt, &refname, "HEAD"); strbuf_worktree_ref(wt, &refname, "HEAD");
if (refs_resolve_ref_unsafe(get_main_ref_store(the_repository), if (refs_resolve_ref_unsafe(get_main_ref_store(repo),
refname.buf, refname.buf,
RESOLVE_REF_READING, RESOLVE_REF_READING,
&oid, &flag)) { &oid, &flag)) {
@ -658,7 +663,7 @@ static void repair_gitfile(struct worktree *wt,
goto done; goto done;
} }


path = repo_common_path(the_repository, "worktrees/%s", wt->id); path = repo_common_path(wt->repo, "worktrees/%s", wt->id);
strbuf_realpath(&repo, path, 1); strbuf_realpath(&repo, path, 1);
strbuf_addf(&dotgit, "%s/.git", wt->path); strbuf_addf(&dotgit, "%s/.git", wt->path);
strbuf_addf(&gitdir, "%s/gitdir", repo.buf); strbuf_addf(&gitdir, "%s/gitdir", repo.buf);
@ -685,7 +690,8 @@ static void repair_gitfile(struct worktree *wt,


if (repair) { if (repair) {
fn(0, wt->path, repair, cb_data); fn(0, wt->path, repair, cb_data);
write_worktree_linking_files(dotgit.buf, gitdir.buf, use_relative_paths); write_worktree_linking_files(wt->repo, dotgit.buf,
gitdir.buf, use_relative_paths);
} }


done: done:
@ -705,9 +711,10 @@ static void repair_noop(int iserr UNUSED,
/* nothing */ /* nothing */
} }


void repair_worktrees(worktree_repair_fn fn, void *cb_data, int use_relative_paths) void repair_worktrees(struct repository *repo, worktree_repair_fn fn,
void *cb_data, int use_relative_paths)
{ {
struct worktree **worktrees = get_worktrees_internal(1); struct worktree **worktrees = get_worktrees_internal(repo, 1);
struct worktree **wt = worktrees + 1; /* +1 skips main worktree */ struct worktree **wt = worktrees + 1; /* +1 skips main worktree */


if (!fn) if (!fn)
@ -727,7 +734,7 @@ void repair_worktree_after_gitdir_move(struct worktree *wt, const char *old_path
if (is_main_worktree(wt)) if (is_main_worktree(wt))
goto done; goto done;


path = repo_common_path(the_repository, "worktrees/%s/gitdir", wt->id); path = repo_common_path(wt->repo, "worktrees/%s/gitdir", wt->id);
strbuf_realpath(&gitdir, path, 1); strbuf_realpath(&gitdir, path, 1);


if (strbuf_read_file(&dotgit, gitdir.buf, 0) < 0) if (strbuf_read_file(&dotgit, gitdir.buf, 0) < 0)
@ -743,16 +750,17 @@ void repair_worktree_after_gitdir_move(struct worktree *wt, const char *old_path
if (!file_exists(dotgit.buf)) if (!file_exists(dotgit.buf))
goto done; goto done;


write_worktree_linking_files(dotgit.buf, gitdir.buf, is_relative_path); write_worktree_linking_files(wt->repo, dotgit.buf,
gitdir.buf, is_relative_path);
done: done:
strbuf_release(&gitdir); strbuf_release(&gitdir);
strbuf_release(&dotgit); strbuf_release(&dotgit);
free(path); free(path);
} }


void repair_worktrees_after_gitdir_move(const char *old_path) void repair_worktrees_after_gitdir_move(struct repository *repo, const char *old_path)
{ {
struct worktree **worktrees = get_worktrees_internal(1); struct worktree **worktrees = get_worktrees_internal(repo, 1);
struct worktree **wt = worktrees + 1; /* +1 skips main worktree */ struct worktree **wt = worktrees + 1; /* +1 skips main worktree */


for (; *wt; wt++) for (; *wt; wt++)
@ -760,7 +768,7 @@ void repair_worktrees_after_gitdir_move(const char *old_path)
free_worktrees(worktrees); free_worktrees(worktrees);
} }


static int is_main_worktree_path(const char *path) static int is_main_worktree_path(struct repository *repo, const char *path)
{ {
struct strbuf target = STRBUF_INIT; struct strbuf target = STRBUF_INIT;
struct strbuf maindir = STRBUF_INIT; struct strbuf maindir = STRBUF_INIT;
@ -768,7 +776,7 @@ static int is_main_worktree_path(const char *path)


strbuf_add_real_path(&target, path); strbuf_add_real_path(&target, path);
strbuf_strip_suffix(&target, "/.git"); strbuf_strip_suffix(&target, "/.git");
strbuf_add_real_path(&maindir, repo_get_common_dir(the_repository)); strbuf_add_real_path(&maindir, repo_get_common_dir(repo));
strbuf_strip_suffix(&maindir, "/.git"); strbuf_strip_suffix(&maindir, "/.git");
cmp = fspathcmp(maindir.buf, target.buf); cmp = fspathcmp(maindir.buf, target.buf);


@ -786,7 +794,9 @@ static int is_main_worktree_path(const char *path)
* *
* Returns -1 on failure and strbuf.len on success. * Returns -1 on failure and strbuf.len on success.
*/ */
static ssize_t infer_backlink(const char *gitfile, struct strbuf *inferred) static ssize_t infer_backlink(struct repository *repo,
const char *gitfile,
struct strbuf *inferred)
{ {
struct strbuf actual = STRBUF_INIT; struct strbuf actual = STRBUF_INIT;
const char *id; const char *id;
@ -801,7 +811,7 @@ static ssize_t infer_backlink(const char *gitfile, struct strbuf *inferred)
id++; /* advance past '/' to point at <id> */ id++; /* advance past '/' to point at <id> */
if (!*id) if (!*id)
goto error; goto error;
repo_common_path_replace(the_repository, inferred, "worktrees/%s", id); repo_common_path_replace(repo, inferred, "worktrees/%s", id);
if (!is_directory(inferred->buf)) if (!is_directory(inferred->buf))
goto error; goto error;


@ -817,7 +827,8 @@ error:
* Repair <repo>/worktrees/<id>/gitdir if missing, corrupt, or not pointing at * Repair <repo>/worktrees/<id>/gitdir if missing, corrupt, or not pointing at
* the worktree's path. * the worktree's path.
*/ */
void repair_worktree_at_path(const char *path, void repair_worktree_at_path(struct repository *repo,
const char *path,
worktree_repair_fn fn, void *cb_data, worktree_repair_fn fn, void *cb_data,
int use_relative_paths) int use_relative_paths)
{ {
@ -833,7 +844,7 @@ void repair_worktree_at_path(const char *path,
if (!fn) if (!fn)
fn = repair_noop; fn = repair_noop;


if (is_main_worktree_path(path)) if (is_main_worktree_path(repo, path))
goto done; goto done;


strbuf_addf(&dotgit, "%s/.git", path); strbuf_addf(&dotgit, "%s/.git", path);
@ -842,7 +853,7 @@ void repair_worktree_at_path(const char *path,
goto done; goto done;
} }


infer_backlink(dotgit.buf, &inferred_backlink); infer_backlink(repo, dotgit.buf, &inferred_backlink);
strbuf_realpath_forgiving(&inferred_backlink, inferred_backlink.buf, 0); strbuf_realpath_forgiving(&inferred_backlink, inferred_backlink.buf, 0);
dotgit_contents = xstrdup_or_null(read_gitfile_gently(dotgit.buf, &err)); dotgit_contents = xstrdup_or_null(read_gitfile_gently(dotgit.buf, &err));
if (dotgit_contents) { if (dotgit_contents) {
@ -915,7 +926,8 @@ void repair_worktree_at_path(const char *path,


if (repair) { if (repair) {
fn(0, gitdir.buf, repair, cb_data); fn(0, gitdir.buf, repair, cb_data);
write_worktree_linking_files(dotgit.buf, gitdir.buf, use_relative_paths); write_worktree_linking_files(repo, dotgit.buf,
gitdir.buf, use_relative_paths);
} }
done: done:
free(dotgit_contents); free(dotgit_contents);
@ -926,12 +938,16 @@ done:
strbuf_release(&dotgit); strbuf_release(&dotgit);
} }


int should_prune_worktree(const char *id, struct strbuf *reason, char **wtpath, timestamp_t expire) int should_prune_worktree(struct repository *repo,
const char *id,
struct strbuf *reason,
char **wtpath,
timestamp_t expire)
{ {
struct stat st; struct stat st;
struct strbuf dotgit = STRBUF_INIT; struct strbuf dotgit = STRBUF_INIT;
struct strbuf gitdir = STRBUF_INIT; struct strbuf gitdir = STRBUF_INIT;
struct strbuf repo = STRBUF_INIT; struct strbuf repo_path = STRBUF_INIT;
struct strbuf file = STRBUF_INIT; struct strbuf file = STRBUF_INIT;
char *path = NULL; char *path = NULL;
int rc = 0; int rc = 0;
@ -941,17 +957,17 @@ int should_prune_worktree(const char *id, struct strbuf *reason, char **wtpath,


*wtpath = NULL; *wtpath = NULL;


path = repo_common_path(the_repository, "worktrees/%s", id); path = repo_common_path(repo, "worktrees/%s", id);
strbuf_realpath(&repo, path, 1); strbuf_realpath(&repo_path, path, 1);
FREE_AND_NULL(path); FREE_AND_NULL(path);


strbuf_addf(&gitdir, "%s/gitdir", repo.buf); strbuf_addf(&gitdir, "%s/gitdir", repo_path.buf);
if (!is_directory(repo.buf)) { if (!is_directory(repo_path.buf)) {
strbuf_addstr(reason, _("not a valid directory")); strbuf_addstr(reason, _("not a valid directory"));
rc = 1; rc = 1;
goto done; goto done;
} }
strbuf_addf(&file, "%s/locked", repo.buf); strbuf_addf(&file, "%s/locked", repo_path.buf);
if (file_exists(file.buf)) { if (file_exists(file.buf)) {
goto done; goto done;
} }
@ -995,12 +1011,12 @@ int should_prune_worktree(const char *id, struct strbuf *reason, char **wtpath,
if (is_absolute_path(path)) { if (is_absolute_path(path)) {
strbuf_addstr(&dotgit, path); strbuf_addstr(&dotgit, path);
} else { } else {
strbuf_addf(&dotgit, "%s/%s", repo.buf, path); strbuf_addf(&dotgit, "%s/%s", repo_path.buf, path);
strbuf_realpath_forgiving(&dotgit, dotgit.buf, 0); strbuf_realpath_forgiving(&dotgit, dotgit.buf, 0);
} }
if (!file_exists(dotgit.buf)) { if (!file_exists(dotgit.buf)) {
strbuf_reset(&file); strbuf_reset(&file);
strbuf_addf(&file, "%s/index", repo.buf); strbuf_addf(&file, "%s/index", repo_path.buf);
if (stat(file.buf, &st) || st.st_mtime <= expire) { if (stat(file.buf, &st) || st.st_mtime <= expire) {
strbuf_addstr(reason, _("gitdir file points to non-existent location")); strbuf_addstr(reason, _("gitdir file points to non-existent location"));
rc = 1; rc = 1;
@ -1012,17 +1028,18 @@ done:
free(path); free(path);
strbuf_release(&dotgit); strbuf_release(&dotgit);
strbuf_release(&gitdir); strbuf_release(&gitdir);
strbuf_release(&repo); strbuf_release(&repo_path);
strbuf_release(&file); strbuf_release(&file);
return rc; return rc;
} }


static int move_config_setting(const char *key, const char *value, static int move_config_setting(struct repository *repo,
const char *key, const char *value,
const char *from_file, const char *to_file) const char *from_file, const char *to_file)
{ {
if (repo_config_set_in_file_gently(the_repository, to_file, key, NULL, value)) if (repo_config_set_in_file_gently(repo, to_file, key, NULL, value))
return error(_("unable to set %s in '%s'"), key, to_file); return error(_("unable to set %s in '%s'"), key, to_file);
if (repo_config_set_in_file_gently(the_repository, from_file, key, NULL, NULL)) if (repo_config_set_in_file_gently(repo, from_file, key, NULL, NULL))
return error(_("unable to unset %s in '%s'"), key, from_file); return error(_("unable to unset %s in '%s'"), key, from_file);
return 0; return 0;
} }
@ -1042,7 +1059,7 @@ int init_worktree_config(struct repository *r)
*/ */
if (r->repository_format_worktree_config) if (r->repository_format_worktree_config)
return 0; return 0;
if ((res = repo_config_set_gently(the_repository, "extensions.worktreeConfig", "true"))) if ((res = repo_config_set_gently(r, "extensions.worktreeConfig", "true")))
return error(_("failed to set extensions.worktreeConfig setting")); return error(_("failed to set extensions.worktreeConfig setting"));


common_config_file = xstrfmt("%s/config", r->commondir); common_config_file = xstrfmt("%s/config", r->commondir);
@ -1058,7 +1075,7 @@ int init_worktree_config(struct repository *r)
* _could_ be negating a global core.bare=true. * _could_ be negating a global core.bare=true.
*/ */
if (!git_configset_get_bool(&cs, "core.bare", &bare) && bare) { if (!git_configset_get_bool(&cs, "core.bare", &bare) && bare) {
if ((res = move_config_setting("core.bare", "true", if ((res = move_config_setting(r, "core.bare", "true",
common_config_file, common_config_file,
main_worktree_file))) main_worktree_file)))
goto cleanup; goto cleanup;
@ -1070,7 +1087,7 @@ int init_worktree_config(struct repository *r)
* upgrade to worktree config. * upgrade to worktree config.
*/ */
if (!git_configset_get_value(&cs, "core.worktree", &core_worktree, NULL)) { if (!git_configset_get_value(&cs, "core.worktree", &core_worktree, NULL)) {
if ((res = move_config_setting("core.worktree", core_worktree, if ((res = move_config_setting(r, "core.worktree", core_worktree,
common_config_file, common_config_file,
main_worktree_file))) main_worktree_file)))
goto cleanup; goto cleanup;
@ -1089,37 +1106,38 @@ cleanup:
return res; return res;
} }


void write_worktree_linking_files(const char *dotgit, const char *gitdir, void write_worktree_linking_files(struct repository *repo,
const char *dotgit, const char *gitdir,
int use_relative_paths) int use_relative_paths)
{ {
struct strbuf path = STRBUF_INIT; struct strbuf path = STRBUF_INIT;
struct strbuf repo = STRBUF_INIT; struct strbuf repo_path = STRBUF_INIT;
struct strbuf tmp = STRBUF_INIT; struct strbuf tmp = STRBUF_INIT;


strbuf_addstr(&path, dotgit); strbuf_addstr(&path, dotgit);
strbuf_strip_suffix(&path, "/.git"); strbuf_strip_suffix(&path, "/.git");
strbuf_realpath(&path, path.buf, 1); strbuf_realpath(&path, path.buf, 1);
strbuf_addstr(&repo, gitdir); strbuf_addstr(&repo_path, gitdir);
strbuf_strip_suffix(&repo, "/gitdir"); strbuf_strip_suffix(&repo_path, "/gitdir");
strbuf_realpath(&repo, repo.buf, 1); strbuf_realpath(&repo_path, repo_path.buf, 1);


if (use_relative_paths && !the_repository->repository_format_relative_worktrees) { if (use_relative_paths && !repo->repository_format_relative_worktrees) {
if (upgrade_repository_format(the_repository, 1) < 0) if (upgrade_repository_format(repo, 1) < 0)
die(_("unable to upgrade repository format to support relative worktrees")); die(_("unable to upgrade repository format to support relative worktrees"));
if (repo_config_set_gently(the_repository, "extensions.relativeWorktrees", "true")) if (repo_config_set_gently(repo, "extensions.relativeWorktrees", "true"))
die(_("unable to set extensions.relativeWorktrees setting")); die(_("unable to set extensions.relativeWorktrees setting"));
the_repository->repository_format_relative_worktrees = 1; repo->repository_format_relative_worktrees = 1;
} }


if (use_relative_paths) { if (use_relative_paths) {
write_file(gitdir, "%s/.git", relative_path(path.buf, repo.buf, &tmp)); write_file(gitdir, "%s/.git", relative_path(path.buf, repo_path.buf, &tmp));
write_file(dotgit, "gitdir: %s", relative_path(repo.buf, path.buf, &tmp)); write_file(dotgit, "gitdir: %s", relative_path(repo_path.buf, path.buf, &tmp));
} else { } else {
write_file(gitdir, "%s/.git", path.buf); write_file(gitdir, "%s/.git", path.buf);
write_file(dotgit, "gitdir: %s", repo.buf); write_file(dotgit, "gitdir: %s", repo_path.buf);
} }


strbuf_release(&path); strbuf_release(&path);
strbuf_release(&repo); strbuf_release(&repo_path);
strbuf_release(&tmp); strbuf_release(&tmp);
} }

27
worktree.h
View File

@ -28,7 +28,7 @@ struct worktree {
* The caller is responsible for freeing the memory from the returned * The caller is responsible for freeing the memory from the returned
* worktrees by calling free_worktrees(). * worktrees by calling free_worktrees().
*/ */
struct worktree **get_worktrees(void); struct worktree **get_worktrees(struct repository *repo);


/* /*
* Like `get_worktrees`, but does not read HEAD. Skip reading HEAD allows to * Like `get_worktrees`, but does not read HEAD. Skip reading HEAD allows to
@ -36,7 +36,7 @@ struct worktree **get_worktrees(void);
* the HEAD ref. This is useful in contexts where it is assumed that the * the HEAD ref. This is useful in contexts where it is assumed that the
* refdb may not be in a consistent state. * refdb may not be in a consistent state.
*/ */
struct worktree **get_worktrees_without_reading_head(void); struct worktree **get_worktrees_without_reading_head(struct repository *repo);


/* /*
* Construct a struct worktree corresponding to repo->gitdir and * Construct a struct worktree corresponding to repo->gitdir and
@ -47,7 +47,7 @@ struct worktree *get_current_worktree(struct repository *repo);
/* /*
* Returns 1 if linked worktrees exist, 0 otherwise. * Returns 1 if linked worktrees exist, 0 otherwise.
*/ */
int submodule_uses_worktrees(const char *path); int submodule_uses_worktrees(struct repository *repo, const char *path);


/* /*
* Return git dir of the worktree. Note that the path may be relative. * Return git dir of the worktree. Note that the path may be relative.
@ -76,7 +76,8 @@ struct worktree *find_worktree(struct worktree **list,
* Look up the worktree corresponding to `id`, or NULL of no such worktree * Look up the worktree corresponding to `id`, or NULL of no such worktree
* exists. * exists.
*/ */
struct worktree *get_linked_worktree(const char *id, struct worktree *get_linked_worktree(struct repository *repo,
const char *id,
int skip_reading_head); int skip_reading_head);


/* /*
@ -112,7 +113,8 @@ const char *worktree_prune_reason(struct worktree *wt, timestamp_t expire);
* `expire` defines a grace period to prune the worktree when its path * `expire` defines a grace period to prune the worktree when its path
* does not exist. * does not exist.
*/ */
int should_prune_worktree(const char *id, int should_prune_worktree(struct repository *repo,
const char *id,
struct strbuf *reason, struct strbuf *reason,
char **wtpath, char **wtpath,
timestamp_t expire); timestamp_t expire);
@ -142,12 +144,14 @@ typedef void (* worktree_repair_fn)(int iserr, const char *path,
* function, if non-NULL, is called with the path of the worktree and a * function, if non-NULL, is called with the path of the worktree and a
* description of the repair or error, along with the callback user-data. * description of the repair or error, along with the callback user-data.
*/ */
void repair_worktrees(worktree_repair_fn, void *cb_data, int use_relative_paths); void repair_worktrees(struct repository *repo, worktree_repair_fn,
void *cb_data, int use_relative_paths);


/* /*
* Repair the linked worktrees after the gitdir has been moved. * Repair the linked worktrees after the gitdir has been moved.
*/ */
void repair_worktrees_after_gitdir_move(const char *old_path); void repair_worktrees_after_gitdir_move(struct repository *repo,
const char *old_path);


/* /*
* Repair the linked worktree after the gitdir has been moved. * Repair the linked worktree after the gitdir has been moved.
@ -164,7 +168,9 @@ void repair_worktree_after_gitdir_move(struct worktree *wt, const char *old_path
* worktree and a description of the repair or error, along with the callback * worktree and a description of the repair or error, along with the callback
* user-data. * user-data.
*/ */
void repair_worktree_at_path(const char *, worktree_repair_fn, void repair_worktree_at_path(struct repository *repo,
const char *path,
worktree_repair_fn fn,
void *cb_data, int use_relative_paths); void *cb_data, int use_relative_paths);


/* /*
@ -196,7 +202,7 @@ int is_shared_symref(const struct worktree *wt,
* Similar to head_ref() for all HEADs _except_ one from the current * Similar to head_ref() for all HEADs _except_ one from the current
* worktree, which is covered by head_ref(). * worktree, which is covered by head_ref().
*/ */
int other_head_refs(refs_for_each_cb fn, void *cb_data); int other_head_refs(struct repository *repo, refs_for_each_cb fn, void *cb_data);


int is_worktree_being_rebased(const struct worktree *wt, const char *target); int is_worktree_being_rebased(const struct worktree *wt, const char *target);
int is_worktree_being_bisected(const struct worktree *wt, const char *target); int is_worktree_being_bisected(const struct worktree *wt, const char *target);
@ -239,7 +245,8 @@ int init_worktree_config(struct repository *r);
* dotgit: "/path/to/foo/.git" * dotgit: "/path/to/foo/.git"
* gitdir: "/path/to/repo/worktrees/foo/gitdir" * gitdir: "/path/to/repo/worktrees/foo/gitdir"
*/ */
void write_worktree_linking_files(const char *dotgit, const char *gitdir, void write_worktree_linking_files(struct repository *repo,
const char *dotgit, const char *gitdir,
int use_relative_paths); int use_relative_paths);


#endif #endif