1 #include "git-compat-util.h"
4 #include "environment.h"
7 #include "repository.h"
13 #include "wt-status.h"
17 void free_worktrees(struct worktree
**worktrees
)
21 for (i
= 0; worktrees
[i
]; i
++) {
22 free(worktrees
[i
]->path
);
23 free(worktrees
[i
]->id
);
24 free(worktrees
[i
]->head_ref
);
25 free(worktrees
[i
]->lock_reason
);
26 free(worktrees
[i
]->prune_reason
);
33 * Update head_oid, head_ref and is_detached of the given worktree
35 static void add_head_info(struct worktree
*wt
)
40 target
= refs_resolve_ref_unsafe(get_worktree_ref_store(wt
),
43 &wt
->head_oid
, &flags
);
47 if (flags
& REF_ISSYMREF
)
48 wt
->head_ref
= xstrdup(target
);
54 * get the main worktree
56 static struct worktree
*get_main_worktree(void)
58 struct worktree
*worktree
= NULL
;
59 struct strbuf worktree_path
= STRBUF_INIT
;
61 strbuf_add_real_path(&worktree_path
, get_git_common_dir());
62 strbuf_strip_suffix(&worktree_path
, "/.git");
64 CALLOC_ARRAY(worktree
, 1);
65 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
67 * NEEDSWORK: If this function is called from a secondary worktree and
68 * config.worktree is present, is_bare_repository_cfg will reflect the
69 * contents of config.worktree, not the contents of the main worktree.
70 * This means that worktree->is_bare may be set to 0 even if the main
71 * worktree is configured to be bare.
73 worktree
->is_bare
= (is_bare_repository_cfg
== 1) ||
75 add_head_info(worktree
);
79 static struct worktree
*get_linked_worktree(const char *id
)
81 struct worktree
*worktree
= NULL
;
82 struct strbuf path
= STRBUF_INIT
;
83 struct strbuf worktree_path
= STRBUF_INIT
;
86 die("Missing linked worktree name");
88 strbuf_git_common_path(&path
, the_repository
, "worktrees/%s/gitdir", id
);
89 if (strbuf_read_file(&worktree_path
, path
.buf
, 0) <= 0)
90 /* invalid gitdir file */
92 strbuf_rtrim(&worktree_path
);
93 strbuf_strip_suffix(&worktree_path
, "/.git");
95 CALLOC_ARRAY(worktree
, 1);
96 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
97 worktree
->id
= xstrdup(id
);
98 add_head_info(worktree
);
101 strbuf_release(&path
);
102 strbuf_release(&worktree_path
);
106 static void mark_current_worktree(struct worktree
**worktrees
)
108 char *git_dir
= absolute_pathdup(get_git_dir());
111 for (i
= 0; worktrees
[i
]; i
++) {
112 struct worktree
*wt
= worktrees
[i
];
113 const char *wt_git_dir
= get_worktree_git_dir(wt
);
115 if (!fspathcmp(git_dir
, absolute_path(wt_git_dir
))) {
123 struct worktree
**get_worktrees(void)
125 struct worktree
**list
= NULL
;
126 struct strbuf path
= STRBUF_INIT
;
129 int counter
= 0, alloc
= 2;
131 ALLOC_ARRAY(list
, alloc
);
133 list
[counter
++] = get_main_worktree();
135 strbuf_addf(&path
, "%s/worktrees", get_git_common_dir());
136 dir
= opendir(path
.buf
);
137 strbuf_release(&path
);
139 while ((d
= readdir_skip_dot_and_dotdot(dir
)) != NULL
) {
140 struct worktree
*linked
= NULL
;
142 if ((linked
= get_linked_worktree(d
->d_name
))) {
143 ALLOC_GROW(list
, counter
+ 1, alloc
);
144 list
[counter
++] = linked
;
149 ALLOC_GROW(list
, counter
+ 1, alloc
);
150 list
[counter
] = NULL
;
152 mark_current_worktree(list
);
156 const char *get_worktree_git_dir(const struct worktree
*wt
)
159 return get_git_dir();
161 return get_git_common_dir();
163 return git_common_path("worktrees/%s", wt
->id
);
166 static struct worktree
*find_worktree_by_suffix(struct worktree
**list
,
169 struct worktree
*found
= NULL
;
170 int nr_found
= 0, suffixlen
;
172 suffixlen
= strlen(suffix
);
176 for (; *list
&& nr_found
< 2; list
++) {
177 const char *path
= (*list
)->path
;
178 int pathlen
= strlen(path
);
179 int start
= pathlen
- suffixlen
;
181 /* suffix must start at directory boundary */
182 if ((!start
|| (start
> 0 && is_dir_sep(path
[start
- 1]))) &&
183 !fspathcmp(suffix
, path
+ start
)) {
188 return nr_found
== 1 ? found
: NULL
;
191 struct worktree
*find_worktree(struct worktree
**list
,
196 char *to_free
= NULL
;
198 if ((wt
= find_worktree_by_suffix(list
, arg
)))
202 arg
= to_free
= prefix_filename(prefix
, arg
);
203 wt
= find_worktree_by_path(list
, arg
);
208 struct worktree
*find_worktree_by_path(struct worktree
**list
, const char *p
)
210 struct strbuf wt_path
= STRBUF_INIT
;
211 char *path
= real_pathdup(p
, 0);
215 for (; *list
; list
++) {
216 if (!strbuf_realpath(&wt_path
, (*list
)->path
, 0))
219 if (!fspathcmp(path
, wt_path
.buf
))
223 strbuf_release(&wt_path
);
227 int is_main_worktree(const struct worktree
*wt
)
232 const char *worktree_lock_reason(struct worktree
*wt
)
234 if (is_main_worktree(wt
))
237 if (!wt
->lock_reason_valid
) {
238 struct strbuf path
= STRBUF_INIT
;
240 strbuf_addstr(&path
, worktree_git_path(wt
, "locked"));
241 if (file_exists(path
.buf
)) {
242 struct strbuf lock_reason
= STRBUF_INIT
;
243 if (strbuf_read_file(&lock_reason
, path
.buf
, 0) < 0)
244 die_errno(_("failed to read '%s'"), path
.buf
);
245 strbuf_trim(&lock_reason
);
246 wt
->lock_reason
= strbuf_detach(&lock_reason
, NULL
);
248 wt
->lock_reason
= NULL
;
249 wt
->lock_reason_valid
= 1;
250 strbuf_release(&path
);
253 return wt
->lock_reason
;
256 const char *worktree_prune_reason(struct worktree
*wt
, timestamp_t expire
)
258 struct strbuf reason
= STRBUF_INIT
;
261 if (is_main_worktree(wt
))
263 if (wt
->prune_reason_valid
)
264 return wt
->prune_reason
;
266 if (should_prune_worktree(wt
->id
, &reason
, &path
, expire
))
267 wt
->prune_reason
= strbuf_detach(&reason
, NULL
);
268 wt
->prune_reason_valid
= 1;
270 strbuf_release(&reason
);
272 return wt
->prune_reason
;
275 /* convenient wrapper to deal with NULL strbuf */
276 __attribute__((format (printf
, 2, 3)))
277 static void strbuf_addf_gently(struct strbuf
*buf
, const char *fmt
, ...)
284 va_start(params
, fmt
);
285 strbuf_vaddf(buf
, fmt
, params
);
289 int validate_worktree(const struct worktree
*wt
, struct strbuf
*errmsg
,
292 struct strbuf wt_path
= STRBUF_INIT
;
293 struct strbuf realpath
= STRBUF_INIT
;
297 strbuf_addf(&wt_path
, "%s/.git", wt
->path
);
299 if (is_main_worktree(wt
)) {
300 if (is_directory(wt_path
.buf
)) {
305 * Main worktree using .git file to point to the
306 * repository would make it impossible to know where
307 * the actual worktree is if this function is executed
308 * from another worktree. No .git file support for now.
310 strbuf_addf_gently(errmsg
,
311 _("'%s' at main working tree is not the repository directory"),
317 * Make sure "gitdir" file points to a real .git file and that
318 * file points back here.
320 if (!is_absolute_path(wt
->path
)) {
321 strbuf_addf_gently(errmsg
,
322 _("'%s' file does not contain absolute path to the working tree location"),
323 git_common_path("worktrees/%s/gitdir", wt
->id
));
327 if (flags
& WT_VALIDATE_WORKTREE_MISSING_OK
&&
328 !file_exists(wt
->path
)) {
333 if (!file_exists(wt_path
.buf
)) {
334 strbuf_addf_gently(errmsg
, _("'%s' does not exist"), wt_path
.buf
);
338 path
= xstrdup_or_null(read_gitfile_gently(wt_path
.buf
, &err
));
340 strbuf_addf_gently(errmsg
, _("'%s' is not a .git file, error code %d"),
345 strbuf_realpath(&realpath
, git_common_path("worktrees/%s", wt
->id
), 1);
346 ret
= fspathcmp(path
, realpath
.buf
);
349 strbuf_addf_gently(errmsg
, _("'%s' does not point back to '%s'"),
350 wt
->path
, git_common_path("worktrees/%s", wt
->id
));
353 strbuf_release(&wt_path
);
354 strbuf_release(&realpath
);
358 void update_worktree_location(struct worktree
*wt
, const char *path_
)
360 struct strbuf path
= STRBUF_INIT
;
362 if (is_main_worktree(wt
))
363 BUG("can't relocate main worktree");
365 strbuf_realpath(&path
, path_
, 1);
366 if (fspathcmp(wt
->path
, path
.buf
)) {
367 write_file(git_common_path("worktrees/%s/gitdir", wt
->id
),
368 "%s/.git", path
.buf
);
370 wt
->path
= strbuf_detach(&path
, NULL
);
372 strbuf_release(&path
);
375 int is_worktree_being_rebased(const struct worktree
*wt
,
378 struct wt_status_state state
;
381 memset(&state
, 0, sizeof(state
));
382 found_rebase
= wt_status_check_rebase(wt
, &state
) &&
383 (state
.rebase_in_progress
||
384 state
.rebase_interactive_in_progress
) &&
386 skip_prefix(target
, "refs/heads/", &target
) &&
387 !strcmp(state
.branch
, target
);
388 wt_status_state_free_buffers(&state
);
392 int is_worktree_being_bisected(const struct worktree
*wt
,
395 struct wt_status_state state
;
398 memset(&state
, 0, sizeof(state
));
399 found_bisect
= wt_status_check_bisect(wt
, &state
) &&
401 skip_prefix(target
, "refs/heads/", &target
) &&
402 !strcmp(state
.branch
, target
);
403 wt_status_state_free_buffers(&state
);
408 * note: this function should be able to detect shared symref even if
409 * HEAD is temporarily detached (e.g. in the middle of rebase or
410 * bisect). New commands that do similar things should update this
413 int is_shared_symref(const struct worktree
*wt
, const char *symref
,
416 const char *symref_target
;
417 struct ref_store
*refs
;
423 if (wt
->is_detached
&& !strcmp(symref
, "HEAD")) {
424 if (is_worktree_being_rebased(wt
, target
))
426 if (is_worktree_being_bisected(wt
, target
))
430 refs
= get_worktree_ref_store(wt
);
431 symref_target
= refs_resolve_ref_unsafe(refs
, symref
, 0,
433 if ((flags
& REF_ISSYMREF
) &&
434 symref_target
&& !strcmp(symref_target
, target
))
440 const struct worktree
*find_shared_symref(struct worktree
**worktrees
,
445 for (int i
= 0; worktrees
[i
]; i
++)
446 if (is_shared_symref(worktrees
[i
], symref
, target
))
452 int submodule_uses_worktrees(const char *path
)
454 char *submodule_gitdir
;
455 struct strbuf sb
= STRBUF_INIT
, err
= STRBUF_INIT
;
459 struct repository_format format
= REPOSITORY_FORMAT_INIT
;
461 submodule_gitdir
= git_pathdup_submodule(path
, "%s", "");
462 if (!submodule_gitdir
)
465 /* The env would be set for the superproject. */
466 get_common_dir_noenv(&sb
, submodule_gitdir
);
467 free(submodule_gitdir
);
469 strbuf_addstr(&sb
, "/config");
470 read_repository_format(&format
, sb
.buf
);
471 if (verify_repository_format(&format
, &err
)) {
472 strbuf_release(&err
);
474 clear_repository_format(&format
);
477 clear_repository_format(&format
);
478 strbuf_release(&err
);
480 /* Replace config by worktrees. */
481 strbuf_setlen(&sb
, sb
.len
- strlen("config"));
482 strbuf_addstr(&sb
, "worktrees");
484 /* See if there is any file inside the worktrees directory. */
485 dir
= opendir(sb
.buf
);
491 d
= readdir_skip_dot_and_dotdot(dir
);
498 void strbuf_worktree_ref(const struct worktree
*wt
,
502 if (parse_worktree_ref(refname
, NULL
, NULL
, NULL
) ==
503 REF_WORKTREE_CURRENT
&&
504 wt
&& !wt
->is_current
) {
505 if (is_main_worktree(wt
))
506 strbuf_addstr(sb
, "main-worktree/");
508 strbuf_addf(sb
, "worktrees/%s/", wt
->id
);
510 strbuf_addstr(sb
, refname
);
513 int other_head_refs(each_ref_fn fn
, void *cb_data
)
515 struct worktree
**worktrees
, **p
;
516 struct strbuf refname
= STRBUF_INIT
;
519 worktrees
= get_worktrees();
520 for (p
= worktrees
; *p
; p
++) {
521 struct worktree
*wt
= *p
;
522 struct object_id oid
;
528 strbuf_reset(&refname
);
529 strbuf_worktree_ref(wt
, &refname
, "HEAD");
530 if (refs_resolve_ref_unsafe(get_main_ref_store(the_repository
),
534 ret
= fn(refname
.buf
, &oid
, flag
, cb_data
);
538 free_worktrees(worktrees
);
539 strbuf_release(&refname
);
544 * Repair worktree's /path/to/worktree/.git file if missing, corrupt, or not
545 * pointing at <repo>/worktrees/<id>.
547 static void repair_gitfile(struct worktree
*wt
,
548 worktree_repair_fn fn
, void *cb_data
)
550 struct strbuf dotgit
= STRBUF_INIT
;
551 struct strbuf repo
= STRBUF_INIT
;
553 const char *repair
= NULL
;
556 /* missing worktree can't be repaired */
557 if (!file_exists(wt
->path
))
560 if (!is_directory(wt
->path
)) {
561 fn(1, wt
->path
, _("not a directory"), cb_data
);
565 strbuf_realpath(&repo
, git_common_path("worktrees/%s", wt
->id
), 1);
566 strbuf_addf(&dotgit
, "%s/.git", wt
->path
);
567 backlink
= xstrdup_or_null(read_gitfile_gently(dotgit
.buf
, &err
));
569 if (err
== READ_GITFILE_ERR_NOT_A_FILE
)
570 fn(1, wt
->path
, _(".git is not a file"), cb_data
);
572 repair
= _(".git file broken");
573 else if (fspathcmp(backlink
, repo
.buf
))
574 repair
= _(".git file incorrect");
577 fn(0, wt
->path
, repair
, cb_data
);
578 write_file(dotgit
.buf
, "gitdir: %s", repo
.buf
);
582 strbuf_release(&repo
);
583 strbuf_release(&dotgit
);
586 static void repair_noop(int iserr
, const char *path
, const char *msg
,
592 void repair_worktrees(worktree_repair_fn fn
, void *cb_data
)
594 struct worktree
**worktrees
= get_worktrees();
595 struct worktree
**wt
= worktrees
+ 1; /* +1 skips main worktree */
600 repair_gitfile(*wt
, fn
, cb_data
);
601 free_worktrees(worktrees
);
604 static int is_main_worktree_path(const char *path
)
606 struct strbuf target
= STRBUF_INIT
;
607 struct strbuf maindir
= STRBUF_INIT
;
610 strbuf_add_real_path(&target
, path
);
611 strbuf_strip_suffix(&target
, "/.git");
612 strbuf_add_real_path(&maindir
, get_git_common_dir());
613 strbuf_strip_suffix(&maindir
, "/.git");
614 cmp
= fspathcmp(maindir
.buf
, target
.buf
);
616 strbuf_release(&maindir
);
617 strbuf_release(&target
);
622 * If both the main worktree and linked worktree have been moved, then the
623 * gitfile /path/to/worktree/.git won't point into the repository, thus we
624 * won't know which <repo>/worktrees/<id>/gitdir to repair. However, we may
625 * be able to infer the gitdir by manually reading /path/to/worktree/.git,
626 * extracting the <id>, and checking if <repo>/worktrees/<id> exists.
628 static char *infer_backlink(const char *gitfile
)
630 struct strbuf actual
= STRBUF_INIT
;
631 struct strbuf inferred
= STRBUF_INIT
;
634 if (strbuf_read_file(&actual
, gitfile
, 0) < 0)
636 if (!starts_with(actual
.buf
, "gitdir:"))
638 if (!(id
= find_last_dir_sep(actual
.buf
)))
640 strbuf_trim(&actual
);
641 id
++; /* advance past '/' to point at <id> */
644 strbuf_git_common_path(&inferred
, the_repository
, "worktrees/%s", id
);
645 if (!is_directory(inferred
.buf
))
648 strbuf_release(&actual
);
649 return strbuf_detach(&inferred
, NULL
);
652 strbuf_release(&actual
);
653 strbuf_release(&inferred
);
658 * Repair <repo>/worktrees/<id>/gitdir if missing, corrupt, or not pointing at
659 * the worktree's path.
661 void repair_worktree_at_path(const char *path
,
662 worktree_repair_fn fn
, void *cb_data
)
664 struct strbuf dotgit
= STRBUF_INIT
;
665 struct strbuf realdotgit
= STRBUF_INIT
;
666 struct strbuf gitdir
= STRBUF_INIT
;
667 struct strbuf olddotgit
= STRBUF_INIT
;
668 char *backlink
= NULL
;
669 const char *repair
= NULL
;
675 if (is_main_worktree_path(path
))
678 strbuf_addf(&dotgit
, "%s/.git", path
);
679 if (!strbuf_realpath(&realdotgit
, dotgit
.buf
, 0)) {
680 fn(1, path
, _("not a valid path"), cb_data
);
684 backlink
= xstrdup_or_null(read_gitfile_gently(realdotgit
.buf
, &err
));
685 if (err
== READ_GITFILE_ERR_NOT_A_FILE
) {
686 fn(1, realdotgit
.buf
, _("unable to locate repository; .git is not a file"), cb_data
);
688 } else if (err
== READ_GITFILE_ERR_NOT_A_REPO
) {
689 if (!(backlink
= infer_backlink(realdotgit
.buf
))) {
690 fn(1, realdotgit
.buf
, _("unable to locate repository; .git file does not reference a repository"), cb_data
);
694 fn(1, realdotgit
.buf
, _("unable to locate repository; .git file broken"), cb_data
);
698 strbuf_addf(&gitdir
, "%s/gitdir", backlink
);
699 if (strbuf_read_file(&olddotgit
, gitdir
.buf
, 0) < 0)
700 repair
= _("gitdir unreadable");
702 strbuf_rtrim(&olddotgit
);
703 if (fspathcmp(olddotgit
.buf
, realdotgit
.buf
))
704 repair
= _("gitdir incorrect");
708 fn(0, gitdir
.buf
, repair
, cb_data
);
709 write_file(gitdir
.buf
, "%s", realdotgit
.buf
);
713 strbuf_release(&olddotgit
);
714 strbuf_release(&gitdir
);
715 strbuf_release(&realdotgit
);
716 strbuf_release(&dotgit
);
719 int should_prune_worktree(const char *id
, struct strbuf
*reason
, char **wtpath
, timestamp_t expire
)
728 if (!is_directory(git_path("worktrees/%s", id
))) {
729 strbuf_addstr(reason
, _("not a valid directory"));
732 if (file_exists(git_path("worktrees/%s/locked", id
)))
734 if (stat(git_path("worktrees/%s/gitdir", id
), &st
)) {
735 strbuf_addstr(reason
, _("gitdir file does not exist"));
738 fd
= open(git_path("worktrees/%s/gitdir", id
), O_RDONLY
);
740 strbuf_addf(reason
, _("unable to read gitdir file (%s)"),
744 len
= xsize_t(st
.st_size
);
745 path
= xmallocz(len
);
747 read_result
= read_in_full(fd
, path
, len
);
748 if (read_result
< 0) {
749 strbuf_addf(reason
, _("unable to read gitdir file (%s)"),
757 if (read_result
!= len
) {
759 _("short read (expected %"PRIuMAX
" bytes, read %"PRIuMAX
")"),
760 (uintmax_t)len
, (uintmax_t)read_result
);
764 while (len
&& (path
[len
- 1] == '\n' || path
[len
- 1] == '\r'))
767 strbuf_addstr(reason
, _("invalid gitdir file"));
772 if (!file_exists(path
)) {
773 if (stat(git_path("worktrees/%s/index", id
), &st
) ||
774 st
.st_mtime
<= expire
) {
775 strbuf_addstr(reason
, _("gitdir file points to non-existent location"));
787 static int move_config_setting(const char *key
, const char *value
,
788 const char *from_file
, const char *to_file
)
790 if (git_config_set_in_file_gently(to_file
, key
, value
))
791 return error(_("unable to set %s in '%s'"), key
, to_file
);
792 if (git_config_set_in_file_gently(from_file
, key
, NULL
))
793 return error(_("unable to unset %s in '%s'"), key
, from_file
);
797 int init_worktree_config(struct repository
*r
)
801 struct config_set cs
= { { 0 } };
802 const char *core_worktree
;
803 char *common_config_file
;
804 char *main_worktree_file
;
807 * If the extension is already enabled, then we can skip the
810 if (r
->repository_format_worktree_config
)
812 if ((res
= git_config_set_gently("extensions.worktreeConfig", "true")))
813 return error(_("failed to set extensions.worktreeConfig setting"));
815 common_config_file
= xstrfmt("%s/config", r
->commondir
);
816 main_worktree_file
= xstrfmt("%s/config.worktree", r
->commondir
);
818 git_configset_init(&cs
);
819 git_configset_add_file(&cs
, common_config_file
);
822 * If core.bare is true in the common config file, then we need to
823 * move it to the main worktree's config file or it will break all
824 * worktrees. If it is false, then leave it in place because it
825 * _could_ be negating a global core.bare=true.
827 if (!git_configset_get_bool(&cs
, "core.bare", &bare
) && bare
) {
828 if ((res
= move_config_setting("core.bare", "true",
830 main_worktree_file
)))
834 * If core.worktree is set, then the main worktree is located
835 * somewhere different than the parent of the common Git dir.
836 * Relocate that value to avoid breaking all worktrees with this
837 * upgrade to worktree config.
839 if (!git_configset_get_value(&cs
, "core.worktree", &core_worktree
, NULL
)) {
840 if ((res
= move_config_setting("core.worktree", core_worktree
,
842 main_worktree_file
)))
847 * Ensure that we use worktree config for the remaining lifetime
848 * of the current process.
850 r
->repository_format_worktree_config
= 1;
853 git_configset_clear(&cs
);
854 free(common_config_file
);
855 free(main_worktree_file
);