2 #include "repository.h"
9 void free_worktrees(struct worktree
**worktrees
)
13 for (i
= 0; worktrees
[i
]; i
++) {
14 free(worktrees
[i
]->path
);
15 free(worktrees
[i
]->id
);
16 free(worktrees
[i
]->head_ref
);
17 free(worktrees
[i
]->lock_reason
);
24 * Update head_sha1, head_ref and is_detached of the given worktree
26 static void add_head_info(struct worktree
*wt
)
31 target
= refs_resolve_ref_unsafe(get_worktree_ref_store(wt
),
34 &wt
->head_oid
, &flags
);
38 if (flags
& REF_ISSYMREF
)
39 wt
->head_ref
= xstrdup(target
);
45 * get the main worktree
47 static struct worktree
*get_main_worktree(void)
49 struct worktree
*worktree
= NULL
;
50 struct strbuf worktree_path
= STRBUF_INIT
;
52 strbuf_add_absolute_path(&worktree_path
, get_git_common_dir());
53 if (!strbuf_strip_suffix(&worktree_path
, "/.git/.") && /* in .git */
54 !strbuf_strip_suffix(&worktree_path
, "/.git")) /* in worktree */
55 strbuf_strip_suffix(&worktree_path
, "/."); /* in bare repo */
57 worktree
= xcalloc(1, sizeof(*worktree
));
58 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
60 * NEEDSWORK: If this function is called from a secondary worktree and
61 * config.worktree is present, is_bare_repository_cfg will reflect the
62 * contents of config.worktree, not the contents of the main worktree.
63 * This means that worktree->is_bare may be set to 0 even if the main
64 * worktree is configured to be bare.
66 worktree
->is_bare
= (is_bare_repository_cfg
== 1) ||
68 add_head_info(worktree
);
72 static struct worktree
*get_linked_worktree(const char *id
)
74 struct worktree
*worktree
= NULL
;
75 struct strbuf path
= STRBUF_INIT
;
76 struct strbuf worktree_path
= STRBUF_INIT
;
79 die("Missing linked worktree name");
81 strbuf_git_common_path(&path
, the_repository
, "worktrees/%s/gitdir", id
);
82 if (strbuf_read_file(&worktree_path
, path
.buf
, 0) <= 0)
83 /* invalid gitdir file */
86 strbuf_rtrim(&worktree_path
);
87 if (!strbuf_strip_suffix(&worktree_path
, "/.git")) {
88 strbuf_reset(&worktree_path
);
89 strbuf_add_absolute_path(&worktree_path
, ".");
90 strbuf_strip_suffix(&worktree_path
, "/.");
94 strbuf_addf(&path
, "%s/worktrees/%s/HEAD", get_git_common_dir(), id
);
96 worktree
= xcalloc(1, sizeof(*worktree
));
97 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
98 worktree
->id
= xstrdup(id
);
99 add_head_info(worktree
);
102 strbuf_release(&path
);
103 strbuf_release(&worktree_path
);
107 static void mark_current_worktree(struct worktree
**worktrees
)
109 char *git_dir
= absolute_pathdup(get_git_dir());
112 for (i
= 0; worktrees
[i
]; i
++) {
113 struct worktree
*wt
= worktrees
[i
];
114 const char *wt_git_dir
= get_worktree_git_dir(wt
);
116 if (!fspathcmp(git_dir
, absolute_path(wt_git_dir
))) {
124 struct worktree
**get_worktrees(void)
126 struct worktree
**list
= NULL
;
127 struct strbuf path
= STRBUF_INIT
;
130 int counter
= 0, alloc
= 2;
132 ALLOC_ARRAY(list
, alloc
);
134 list
[counter
++] = get_main_worktree();
136 strbuf_addf(&path
, "%s/worktrees", get_git_common_dir());
137 dir
= opendir(path
.buf
);
138 strbuf_release(&path
);
140 while ((d
= readdir(dir
)) != NULL
) {
141 struct worktree
*linked
= NULL
;
142 if (is_dot_or_dotdot(d
->d_name
))
145 if ((linked
= get_linked_worktree(d
->d_name
))) {
146 ALLOC_GROW(list
, counter
+ 1, alloc
);
147 list
[counter
++] = linked
;
152 ALLOC_GROW(list
, counter
+ 1, alloc
);
153 list
[counter
] = NULL
;
155 mark_current_worktree(list
);
159 const char *get_worktree_git_dir(const struct worktree
*wt
)
162 return get_git_dir();
164 return get_git_common_dir();
166 return git_common_path("worktrees/%s", wt
->id
);
169 static struct worktree
*find_worktree_by_suffix(struct worktree
**list
,
172 struct worktree
*found
= NULL
;
173 int nr_found
= 0, suffixlen
;
175 suffixlen
= strlen(suffix
);
179 for (; *list
&& nr_found
< 2; list
++) {
180 const char *path
= (*list
)->path
;
181 int pathlen
= strlen(path
);
182 int start
= pathlen
- suffixlen
;
184 /* suffix must start at directory boundary */
185 if ((!start
|| (start
> 0 && is_dir_sep(path
[start
- 1]))) &&
186 !fspathcmp(suffix
, path
+ start
)) {
191 return nr_found
== 1 ? found
: NULL
;
194 struct worktree
*find_worktree(struct worktree
**list
,
199 char *to_free
= NULL
;
201 if ((wt
= find_worktree_by_suffix(list
, arg
)))
205 arg
= to_free
= prefix_filename(prefix
, arg
);
206 wt
= find_worktree_by_path(list
, arg
);
211 struct worktree
*find_worktree_by_path(struct worktree
**list
, const char *p
)
213 struct strbuf wt_path
= STRBUF_INIT
;
214 char *path
= real_pathdup(p
, 0);
218 for (; *list
; list
++) {
219 if (!strbuf_realpath(&wt_path
, (*list
)->path
, 0))
222 if (!fspathcmp(path
, wt_path
.buf
))
226 strbuf_release(&wt_path
);
230 int is_main_worktree(const struct worktree
*wt
)
235 const char *worktree_lock_reason(struct worktree
*wt
)
237 assert(!is_main_worktree(wt
));
239 if (!wt
->lock_reason_valid
) {
240 struct strbuf path
= STRBUF_INIT
;
242 strbuf_addstr(&path
, worktree_git_path(wt
, "locked"));
243 if (file_exists(path
.buf
)) {
244 struct strbuf lock_reason
= STRBUF_INIT
;
245 if (strbuf_read_file(&lock_reason
, path
.buf
, 0) < 0)
246 die_errno(_("failed to read '%s'"), path
.buf
);
247 strbuf_trim(&lock_reason
);
248 wt
->lock_reason
= strbuf_detach(&lock_reason
, NULL
);
250 wt
->lock_reason
= NULL
;
251 wt
->lock_reason_valid
= 1;
252 strbuf_release(&path
);
255 return wt
->lock_reason
;
258 /* convenient wrapper to deal with NULL strbuf */
259 static void strbuf_addf_gently(struct strbuf
*buf
, const char *fmt
, ...)
266 va_start(params
, fmt
);
267 strbuf_vaddf(buf
, fmt
, params
);
271 int validate_worktree(const struct worktree
*wt
, struct strbuf
*errmsg
,
274 struct strbuf wt_path
= STRBUF_INIT
;
275 struct strbuf realpath
= STRBUF_INIT
;
279 strbuf_addf(&wt_path
, "%s/.git", wt
->path
);
281 if (is_main_worktree(wt
)) {
282 if (is_directory(wt_path
.buf
)) {
287 * Main worktree using .git file to point to the
288 * repository would make it impossible to know where
289 * the actual worktree is if this function is executed
290 * from another worktree. No .git file support for now.
292 strbuf_addf_gently(errmsg
,
293 _("'%s' at main working tree is not the repository directory"),
299 * Make sure "gitdir" file points to a real .git file and that
300 * file points back here.
302 if (!is_absolute_path(wt
->path
)) {
303 strbuf_addf_gently(errmsg
,
304 _("'%s' file does not contain absolute path to the working tree location"),
305 git_common_path("worktrees/%s/gitdir", wt
->id
));
309 if (flags
& WT_VALIDATE_WORKTREE_MISSING_OK
&&
310 !file_exists(wt
->path
)) {
315 if (!file_exists(wt_path
.buf
)) {
316 strbuf_addf_gently(errmsg
, _("'%s' does not exist"), wt_path
.buf
);
320 path
= xstrdup_or_null(read_gitfile_gently(wt_path
.buf
, &err
));
322 strbuf_addf_gently(errmsg
, _("'%s' is not a .git file, error code %d"),
327 strbuf_realpath(&realpath
, git_common_path("worktrees/%s", wt
->id
), 1);
328 ret
= fspathcmp(path
, realpath
.buf
);
331 strbuf_addf_gently(errmsg
, _("'%s' does not point back to '%s'"),
332 wt
->path
, git_common_path("worktrees/%s", wt
->id
));
335 strbuf_release(&wt_path
);
336 strbuf_release(&realpath
);
340 void update_worktree_location(struct worktree
*wt
, const char *path_
)
342 struct strbuf path
= STRBUF_INIT
;
344 if (is_main_worktree(wt
))
345 BUG("can't relocate main worktree");
347 strbuf_realpath(&path
, path_
, 1);
348 if (fspathcmp(wt
->path
, path
.buf
)) {
349 write_file(git_common_path("worktrees/%s/gitdir", wt
->id
),
350 "%s/.git", path
.buf
);
352 wt
->path
= strbuf_detach(&path
, NULL
);
354 strbuf_release(&path
);
357 int is_worktree_being_rebased(const struct worktree
*wt
,
360 struct wt_status_state state
;
363 memset(&state
, 0, sizeof(state
));
364 found_rebase
= wt_status_check_rebase(wt
, &state
) &&
365 ((state
.rebase_in_progress
||
366 state
.rebase_interactive_in_progress
) &&
368 starts_with(target
, "refs/heads/") &&
369 !strcmp(state
.branch
, target
+ strlen("refs/heads/")));
375 int is_worktree_being_bisected(const struct worktree
*wt
,
378 struct wt_status_state state
;
381 memset(&state
, 0, sizeof(state
));
382 found_rebase
= wt_status_check_bisect(wt
, &state
) &&
384 starts_with(target
, "refs/heads/") &&
385 !strcmp(state
.branch
, target
+ strlen("refs/heads/"));
391 * note: this function should be able to detect shared symref even if
392 * HEAD is temporarily detached (e.g. in the middle of rebase or
393 * bisect). New commands that do similar things should update this
396 const struct worktree
*find_shared_symref(const char *symref
,
399 const struct worktree
*existing
= NULL
;
400 static struct worktree
**worktrees
;
404 free_worktrees(worktrees
);
405 worktrees
= get_worktrees();
407 for (i
= 0; worktrees
[i
]; i
++) {
408 struct worktree
*wt
= worktrees
[i
];
409 const char *symref_target
;
410 struct ref_store
*refs
;
416 if (wt
->is_detached
&& !strcmp(symref
, "HEAD")) {
417 if (is_worktree_being_rebased(wt
, target
)) {
421 if (is_worktree_being_bisected(wt
, target
)) {
427 refs
= get_worktree_ref_store(wt
);
428 symref_target
= refs_resolve_ref_unsafe(refs
, symref
, 0,
430 if ((flags
& REF_ISSYMREF
) &&
431 symref_target
&& !strcmp(symref_target
, target
)) {
440 int submodule_uses_worktrees(const char *path
)
442 char *submodule_gitdir
;
443 struct strbuf sb
= STRBUF_INIT
, err
= STRBUF_INIT
;
447 struct repository_format format
= REPOSITORY_FORMAT_INIT
;
449 submodule_gitdir
= git_pathdup_submodule(path
, "%s", "");
450 if (!submodule_gitdir
)
453 /* The env would be set for the superproject. */
454 get_common_dir_noenv(&sb
, submodule_gitdir
);
455 free(submodule_gitdir
);
457 strbuf_addstr(&sb
, "/config");
458 read_repository_format(&format
, sb
.buf
);
459 if (verify_repository_format(&format
, &err
)) {
460 strbuf_release(&err
);
462 clear_repository_format(&format
);
465 clear_repository_format(&format
);
466 strbuf_release(&err
);
468 /* Replace config by worktrees. */
469 strbuf_setlen(&sb
, sb
.len
- strlen("config"));
470 strbuf_addstr(&sb
, "worktrees");
472 /* See if there is any file inside the worktrees directory. */
473 dir
= opendir(sb
.buf
);
479 while ((d
= readdir(dir
)) != NULL
) {
480 if (is_dot_or_dotdot(d
->d_name
))
490 int parse_worktree_ref(const char *worktree_ref
, const char **name
,
491 int *name_length
, const char **ref
)
493 if (skip_prefix(worktree_ref
, "main-worktree/", &worktree_ref
)) {
504 if (skip_prefix(worktree_ref
, "worktrees/", &worktree_ref
)) {
505 const char *slash
= strchr(worktree_ref
, '/');
507 if (!slash
|| slash
== worktree_ref
|| !slash
[1])
510 *name
= worktree_ref
;
512 *name_length
= slash
- worktree_ref
;
520 void strbuf_worktree_ref(const struct worktree
*wt
,
524 switch (ref_type(refname
)) {
525 case REF_TYPE_PSEUDOREF
:
526 case REF_TYPE_PER_WORKTREE
:
527 if (wt
&& !wt
->is_current
) {
528 if (is_main_worktree(wt
))
529 strbuf_addstr(sb
, "main-worktree/");
531 strbuf_addf(sb
, "worktrees/%s/", wt
->id
);
535 case REF_TYPE_MAIN_PSEUDOREF
:
536 case REF_TYPE_OTHER_PSEUDOREF
:
539 case REF_TYPE_NORMAL
:
541 * For shared refs, don't prefix worktrees/ or
542 * main-worktree/. It's not necessary and
543 * files-backend.c can't handle it anyway.
547 strbuf_addstr(sb
, refname
);
550 const char *worktree_ref(const struct worktree
*wt
, const char *refname
)
552 static struct strbuf sb
= STRBUF_INIT
;
555 strbuf_worktree_ref(wt
, &sb
, refname
);
559 int other_head_refs(each_ref_fn fn
, void *cb_data
)
561 struct worktree
**worktrees
, **p
;
564 worktrees
= get_worktrees();
565 for (p
= worktrees
; *p
; p
++) {
566 struct worktree
*wt
= *p
;
567 struct object_id oid
;
573 if (!refs_read_ref_full(get_main_ref_store(the_repository
),
574 worktree_ref(wt
, "HEAD"),
577 ret
= fn(worktree_ref(wt
, "HEAD"), &oid
, flag
, cb_data
);
581 free_worktrees(worktrees
);