8 void free_worktrees(struct worktree
**worktrees
)
12 for (i
= 0; worktrees
[i
]; i
++) {
13 free(worktrees
[i
]->path
);
14 free(worktrees
[i
]->id
);
15 free(worktrees
[i
]->head_ref
);
16 free(worktrees
[i
]->lock_reason
);
23 * Update head_sha1, head_ref and is_detached of the given worktree
25 static void add_head_info(struct worktree
*wt
)
30 target
= refs_resolve_ref_unsafe(get_worktree_ref_store(wt
),
33 wt
->head_sha1
, &flags
);
37 if (flags
& REF_ISSYMREF
)
38 wt
->head_ref
= xstrdup(target
);
44 * get the main worktree
46 static struct worktree
*get_main_worktree(void)
48 struct worktree
*worktree
= NULL
;
49 struct strbuf path
= STRBUF_INIT
;
50 struct strbuf worktree_path
= STRBUF_INIT
;
53 strbuf_add_absolute_path(&worktree_path
, get_git_common_dir());
54 is_bare
= !strbuf_strip_suffix(&worktree_path
, "/.git");
56 strbuf_strip_suffix(&worktree_path
, "/.");
58 strbuf_addf(&path
, "%s/HEAD", get_git_common_dir());
60 worktree
= xcalloc(1, sizeof(*worktree
));
61 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
62 worktree
->is_bare
= is_bare
;
63 add_head_info(worktree
);
65 strbuf_release(&path
);
66 strbuf_release(&worktree_path
);
70 static struct worktree
*get_linked_worktree(const char *id
)
72 struct worktree
*worktree
= NULL
;
73 struct strbuf path
= STRBUF_INIT
;
74 struct strbuf worktree_path
= STRBUF_INIT
;
77 die("Missing linked worktree name");
79 strbuf_git_common_path(&path
, "worktrees/%s/gitdir", id
);
80 if (strbuf_read_file(&worktree_path
, path
.buf
, 0) <= 0)
81 /* invalid gitdir file */
84 strbuf_rtrim(&worktree_path
);
85 if (!strbuf_strip_suffix(&worktree_path
, "/.git")) {
86 strbuf_reset(&worktree_path
);
87 strbuf_add_absolute_path(&worktree_path
, ".");
88 strbuf_strip_suffix(&worktree_path
, "/.");
92 strbuf_addf(&path
, "%s/worktrees/%s/HEAD", get_git_common_dir(), id
);
94 worktree
= xcalloc(1, sizeof(*worktree
));
95 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
96 worktree
->id
= xstrdup(id
);
97 add_head_info(worktree
);
100 strbuf_release(&path
);
101 strbuf_release(&worktree_path
);
105 static void mark_current_worktree(struct worktree
**worktrees
)
107 char *git_dir
= absolute_pathdup(get_git_dir());
110 for (i
= 0; worktrees
[i
]; i
++) {
111 struct worktree
*wt
= worktrees
[i
];
112 const char *wt_git_dir
= get_worktree_git_dir(wt
);
114 if (!fspathcmp(git_dir
, absolute_path(wt_git_dir
))) {
122 static int compare_worktree(const void *a_
, const void *b_
)
124 const struct worktree
*const *a
= a_
;
125 const struct worktree
*const *b
= b_
;
126 return fspathcmp((*a
)->path
, (*b
)->path
);
129 struct worktree
**get_worktrees(unsigned flags
)
131 struct worktree
**list
= NULL
;
132 struct strbuf path
= STRBUF_INIT
;
135 int counter
= 0, alloc
= 2;
137 ALLOC_ARRAY(list
, alloc
);
139 list
[counter
++] = get_main_worktree();
141 strbuf_addf(&path
, "%s/worktrees", get_git_common_dir());
142 dir
= opendir(path
.buf
);
143 strbuf_release(&path
);
145 while ((d
= readdir(dir
)) != NULL
) {
146 struct worktree
*linked
= NULL
;
147 if (is_dot_or_dotdot(d
->d_name
))
150 if ((linked
= get_linked_worktree(d
->d_name
))) {
151 ALLOC_GROW(list
, counter
+ 1, alloc
);
152 list
[counter
++] = linked
;
157 ALLOC_GROW(list
, counter
+ 1, alloc
);
158 list
[counter
] = NULL
;
160 if (flags
& GWT_SORT_LINKED
)
162 * don't sort the first item (main worktree), which will
163 * always be the first
165 QSORT(list
+ 1, counter
- 1, compare_worktree
);
167 mark_current_worktree(list
);
171 const char *get_worktree_git_dir(const struct worktree
*wt
)
174 return get_git_dir();
176 return get_git_common_dir();
178 return git_common_path("worktrees/%s", wt
->id
);
181 static struct worktree
*find_worktree_by_suffix(struct worktree
**list
,
184 struct worktree
*found
= NULL
;
185 int nr_found
= 0, suffixlen
;
187 suffixlen
= strlen(suffix
);
191 for (; *list
&& nr_found
< 2; list
++) {
192 const char *path
= (*list
)->path
;
193 int pathlen
= strlen(path
);
194 int start
= pathlen
- suffixlen
;
196 /* suffix must start at directory boundary */
197 if ((!start
|| (start
> 0 && is_dir_sep(path
[start
- 1]))) &&
198 !fspathcmp(suffix
, path
+ start
)) {
203 return nr_found
== 1 ? found
: NULL
;
206 struct worktree
*find_worktree(struct worktree
**list
,
213 if ((wt
= find_worktree_by_suffix(list
, arg
)))
216 arg
= prefix_filename(prefix
, strlen(prefix
), arg
);
217 path
= real_pathdup(arg
, 1);
218 for (; *list
; list
++)
219 if (!fspathcmp(path
, real_path((*list
)->path
)))
225 int is_main_worktree(const struct worktree
*wt
)
230 const char *is_worktree_locked(struct worktree
*wt
)
232 assert(!is_main_worktree(wt
));
234 if (!wt
->lock_reason_valid
) {
235 struct strbuf path
= STRBUF_INIT
;
237 strbuf_addstr(&path
, worktree_git_path(wt
, "locked"));
238 if (file_exists(path
.buf
)) {
239 struct strbuf lock_reason
= STRBUF_INIT
;
240 if (strbuf_read_file(&lock_reason
, path
.buf
, 0) < 0)
241 die_errno(_("failed to read '%s'"), path
.buf
);
242 strbuf_trim(&lock_reason
);
243 wt
->lock_reason
= strbuf_detach(&lock_reason
, NULL
);
245 wt
->lock_reason
= NULL
;
246 wt
->lock_reason_valid
= 1;
247 strbuf_release(&path
);
250 return wt
->lock_reason
;
253 int is_worktree_being_rebased(const struct worktree
*wt
,
256 struct wt_status_state state
;
259 memset(&state
, 0, sizeof(state
));
260 found_rebase
= wt_status_check_rebase(wt
, &state
) &&
261 ((state
.rebase_in_progress
||
262 state
.rebase_interactive_in_progress
) &&
264 starts_with(target
, "refs/heads/") &&
265 !strcmp(state
.branch
, target
+ strlen("refs/heads/")));
271 int is_worktree_being_bisected(const struct worktree
*wt
,
274 struct wt_status_state state
;
277 memset(&state
, 0, sizeof(state
));
278 found_rebase
= wt_status_check_bisect(wt
, &state
) &&
280 starts_with(target
, "refs/heads/") &&
281 !strcmp(state
.branch
, target
+ strlen("refs/heads/"));
287 * note: this function should be able to detect shared symref even if
288 * HEAD is temporarily detached (e.g. in the middle of rebase or
289 * bisect). New commands that do similar things should update this
292 const struct worktree
*find_shared_symref(const char *symref
,
295 const struct worktree
*existing
= NULL
;
296 static struct worktree
**worktrees
;
300 free_worktrees(worktrees
);
301 worktrees
= get_worktrees(0);
303 for (i
= 0; worktrees
[i
]; i
++) {
304 struct worktree
*wt
= worktrees
[i
];
305 const char *symref_target
;
306 unsigned char sha1
[20];
307 struct ref_store
*refs
;
313 if (wt
->is_detached
&& !strcmp(symref
, "HEAD")) {
314 if (is_worktree_being_rebased(wt
, target
)) {
318 if (is_worktree_being_bisected(wt
, target
)) {
324 refs
= get_worktree_ref_store(wt
);
325 symref_target
= refs_resolve_ref_unsafe(refs
, symref
, 0,
327 if ((flags
& REF_ISSYMREF
) && !strcmp(symref_target
, target
)) {
336 int submodule_uses_worktrees(const char *path
)
338 char *submodule_gitdir
;
339 struct strbuf sb
= STRBUF_INIT
;
343 struct repository_format format
;
345 submodule_gitdir
= git_pathdup_submodule(path
, "%s", "");
346 if (!submodule_gitdir
)
349 /* The env would be set for the superproject. */
350 get_common_dir_noenv(&sb
, submodule_gitdir
);
353 * The check below is only known to be good for repository format
354 * version 0 at the time of writing this code.
356 strbuf_addstr(&sb
, "/config");
357 read_repository_format(&format
, sb
.buf
);
358 if (format
.version
!= 0) {
363 /* Replace config by worktrees. */
364 strbuf_setlen(&sb
, sb
.len
- strlen("config"));
365 strbuf_addstr(&sb
, "worktrees");
367 /* See if there is any file inside the worktrees directory. */
368 dir
= opendir(sb
.buf
);
370 free(submodule_gitdir
);
375 while ((d
= readdir(dir
)) != NULL
) {
376 if (is_dot_or_dotdot(d
->d_name
))