[thirdparty/git.git] / worktree.c

#include "cache.h"
#include "refs.h"
#include "strbuf.h"
#include "worktree.h"
#include "dir.h"
#include "wt-status.h"

void free_worktrees(struct worktree **worktrees)
{
	int i = 0;

	for (i = 0; worktrees[i]; i++) {
		free(worktrees[i]->path);
		free(worktrees[i]->id);
		free(worktrees[i]->head_ref);
		free(worktrees[i]->lock_reason);
		free(worktrees[i]);
	}
	free (worktrees);
}

/**
 * Update head_sha1, head_ref and is_detached of the given worktree
 */
static void add_head_info(struct worktree *wt)
{
	int flags;
	const char *target;

	target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt),
					 "HEAD",
					 RESOLVE_REF_READING,
					 wt->head_sha1, &flags);
	if (!target)
		return;

	if (flags & REF_ISSYMREF)
		wt->head_ref = xstrdup(target);
	else
		wt->is_detached = 1;
}

/**
 * get the main worktree
 */
static struct worktree *get_main_worktree(void)
{
	struct worktree *worktree = NULL;
	struct strbuf path = STRBUF_INIT;
	struct strbuf worktree_path = STRBUF_INIT;
	int is_bare = 0;

	strbuf_add_absolute_path(&worktree_path, get_git_common_dir());
	is_bare = !strbuf_strip_suffix(&worktree_path, "/.git");
	if (is_bare)
		strbuf_strip_suffix(&worktree_path, "/.");

	strbuf_addf(&path, "%s/HEAD", get_git_common_dir());

	worktree = xcalloc(1, sizeof(*worktree));
	worktree->path = strbuf_detach(&worktree_path, NULL);
	worktree->is_bare = is_bare;
	add_head_info(worktree);

	strbuf_release(&path);
	strbuf_release(&worktree_path);
	return worktree;
}

static struct worktree *get_linked_worktree(const char *id)
{
	struct worktree *worktree = NULL;
	struct strbuf path = STRBUF_INIT;
	struct strbuf worktree_path = STRBUF_INIT;

	if (!id)
		die("Missing linked worktree name");

	strbuf_git_common_path(&path, "worktrees/%s/gitdir", id);
	if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0)
		/* invalid gitdir file */
		goto done;

	strbuf_rtrim(&worktree_path);
	if (!strbuf_strip_suffix(&worktree_path, "/.git")) {
		strbuf_reset(&worktree_path);
		strbuf_add_absolute_path(&worktree_path, ".");
		strbuf_strip_suffix(&worktree_path, "/.");
	}

	strbuf_reset(&path);
	strbuf_addf(&path, "%s/worktrees/%s/HEAD", get_git_common_dir(), id);

	worktree = xcalloc(1, sizeof(*worktree));
	worktree->path = strbuf_detach(&worktree_path, NULL);
	worktree->id = xstrdup(id);
	add_head_info(worktree);

done:
	strbuf_release(&path);
	strbuf_release(&worktree_path);
	return worktree;
}

static void mark_current_worktree(struct worktree **worktrees)
{
	char *git_dir = absolute_pathdup(get_git_dir());
	int i;

	for (i = 0; worktrees[i]; i++) {
		struct worktree *wt = worktrees[i];
		const char *wt_git_dir = get_worktree_git_dir(wt);

		if (!fspathcmp(git_dir, absolute_path(wt_git_dir))) {
			wt->is_current = 1;
			break;
		}
	}
	free(git_dir);
}

static int compare_worktree(const void *a_, const void *b_)
{
	const struct worktree *const *a = a_;
	const struct worktree *const *b = b_;
	return fspathcmp((*a)->path, (*b)->path);
}

struct worktree **get_worktrees(unsigned flags)
{
	struct worktree **list = NULL;
	struct strbuf path = STRBUF_INIT;
	DIR *dir;
	struct dirent *d;
	int counter = 0, alloc = 2;

	ALLOC_ARRAY(list, alloc);

	list[counter++] = get_main_worktree();

	strbuf_addf(&path, "%s/worktrees", get_git_common_dir());
	dir = opendir(path.buf);
	strbuf_release(&path);
	if (dir) {
		while ((d = readdir(dir)) != NULL) {
			struct worktree *linked = NULL;
			if (is_dot_or_dotdot(d->d_name))
				continue;

			if ((linked = get_linked_worktree(d->d_name))) {
				ALLOC_GROW(list, counter + 1, alloc);
				list[counter++] = linked;
			}
		}
		closedir(dir);
	}
	ALLOC_GROW(list, counter + 1, alloc);
	list[counter] = NULL;

	if (flags & GWT_SORT_LINKED)
		/*
		 * don't sort the first item (main worktree), which will
		 * always be the first
		 */
		QSORT(list + 1, counter - 1, compare_worktree);

	mark_current_worktree(list);
	return list;
}

const char *get_worktree_git_dir(const struct worktree *wt)
{
	if (!wt)
		return get_git_dir();
	else if (!wt->id)
		return get_git_common_dir();
	else
		return git_common_path("worktrees/%s", wt->id);
}

static struct worktree *find_worktree_by_suffix(struct worktree **list,
						const char *suffix)
{
	struct worktree *found = NULL;
	int nr_found = 0, suffixlen;

	suffixlen = strlen(suffix);
	if (!suffixlen)
		return NULL;

	for (; *list && nr_found < 2; list++) {
		const char	*path	 = (*list)->path;
		int		 pathlen = strlen(path);
		int		 start	 = pathlen - suffixlen;

		/* suffix must start at directory boundary */
		if ((!start || (start > 0 && is_dir_sep(path[start - 1]))) &&
		    !fspathcmp(suffix, path + start)) {
			found = *list;
			nr_found++;
		}
	}
	return nr_found == 1 ? found : NULL;
}

struct worktree *find_worktree(struct worktree **list,
			       const char *prefix,
			       const char *arg)
{
	struct worktree *wt;
	char *path;

	if ((wt = find_worktree_by_suffix(list, arg)))
		return wt;

	arg = prefix_filename(prefix, strlen(prefix), arg);
	path = real_pathdup(arg, 1);
	for (; *list; list++)
		if (!fspathcmp(path, real_path((*list)->path)))
			break;
	free(path);
	return *list;
}

int is_main_worktree(const struct worktree *wt)
{
	return !wt->id;
}

const char *is_worktree_locked(struct worktree *wt)
{
	assert(!is_main_worktree(wt));

	if (!wt->lock_reason_valid) {
		struct strbuf path = STRBUF_INIT;

		strbuf_addstr(&path, worktree_git_path(wt, "locked"));
		if (file_exists(path.buf)) {
			struct strbuf lock_reason = STRBUF_INIT;
			if (strbuf_read_file(&lock_reason, path.buf, 0) < 0)
				die_errno(_("failed to read '%s'"), path.buf);
			strbuf_trim(&lock_reason);
			wt->lock_reason = strbuf_detach(&lock_reason, NULL);
		} else
			wt->lock_reason = NULL;
		wt->lock_reason_valid = 1;
		strbuf_release(&path);
	}

	return wt->lock_reason;
}

int is_worktree_being_rebased(const struct worktree *wt,
			      const char *target)
{
	struct wt_status_state state;
	int found_rebase;

	memset(&state, 0, sizeof(state));
	found_rebase = wt_status_check_rebase(wt, &state) &&
		((state.rebase_in_progress ||
		  state.rebase_interactive_in_progress) &&
		 state.branch &&
		 starts_with(target, "refs/heads/") &&
		 !strcmp(state.branch, target + strlen("refs/heads/")));
	free(state.branch);
	free(state.onto);
	return found_rebase;
}

int is_worktree_being_bisected(const struct worktree *wt,
			       const char *target)
{
	struct wt_status_state state;
	int found_rebase;

	memset(&state, 0, sizeof(state));
	found_rebase = wt_status_check_bisect(wt, &state) &&
		state.branch &&
		starts_with(target, "refs/heads/") &&
		!strcmp(state.branch, target + strlen("refs/heads/"));
	free(state.branch);
	return found_rebase;
}

/*
 * note: this function should be able to detect shared symref even if
 * HEAD is temporarily detached (e.g. in the middle of rebase or
 * bisect). New commands that do similar things should update this
 * function as well.
 */
const struct worktree *find_shared_symref(const char *symref,
					  const char *target)
{
	const struct worktree *existing = NULL;
	static struct worktree **worktrees;
	int i = 0;

	if (worktrees)
		free_worktrees(worktrees);
	worktrees = get_worktrees(0);

	for (i = 0; worktrees[i]; i++) {
		struct worktree *wt = worktrees[i];
		const char *symref_target;
		unsigned char sha1[20];
		struct ref_store *refs;
		int flags;

		if (wt->is_bare)
			continue;

		if (wt->is_detached && !strcmp(symref, "HEAD")) {
			if (is_worktree_being_rebased(wt, target)) {
				existing = wt;
				break;
			}
			if (is_worktree_being_bisected(wt, target)) {
				existing = wt;
				break;
			}
		}

		refs = get_worktree_ref_store(wt);
		symref_target = refs_resolve_ref_unsafe(refs, symref, 0,
							sha1, &flags);
		if ((flags & REF_ISSYMREF) && !strcmp(symref_target, target)) {
			existing = wt;
			break;
		}
	}

	return existing;
}

int submodule_uses_worktrees(const char *path)
{
	char *submodule_gitdir;
	struct strbuf sb = STRBUF_INIT;
	DIR *dir;
	struct dirent *d;
	int ret = 0;
	struct repository_format format;

	submodule_gitdir = git_pathdup_submodule(path, "%s", "");
	if (!submodule_gitdir)
		return 0;

	/* The env would be set for the superproject. */
	get_common_dir_noenv(&sb, submodule_gitdir);

	/*
	 * The check below is only known to be good for repository format
	 * version 0 at the time of writing this code.
	 */
	strbuf_addstr(&sb, "/config");
	read_repository_format(&format, sb.buf);
	if (format.version != 0) {
		strbuf_release(&sb);
		return 1;
	}

	/* Replace config by worktrees. */
	strbuf_setlen(&sb, sb.len - strlen("config"));
	strbuf_addstr(&sb, "worktrees");

	/* See if there is any file inside the worktrees directory. */
	dir = opendir(sb.buf);
	strbuf_release(&sb);
	free(submodule_gitdir);

	if (!dir)
		return 0;

	while ((d = readdir(dir)) != NULL) {
		if (is_dot_or_dotdot(d->d_name))
			continue;

		ret = 1;
		break;
	}
	closedir(dir);
	return ret;
}
Commit	Line	Data
ac6c561b MR	1	#include "cache.h"
	2	#include "refs.h"
	3	#include "strbuf.h"
	4	#include "worktree.h"
750e8a60	5	#include "dir.h"
8d9fdd70	6	#include "wt-status.h"
ac6c561b	7
51934904 MR	8	void free_worktrees(struct worktree **worktrees)
	9	{
	10	int i = 0;
	11
	12	for (i = 0; worktrees[i]; i++) {
	13	free(worktrees[i]->path);
69dfe3b9	14	free(worktrees[i]->id);
92718b74	15	free(worktrees[i]->head_ref);
346ef530	16	free(worktrees[i]->lock_reason);
51934904 MR	17	free(worktrees[i]);
	18	}
	19	free (worktrees);
	20	}
	21
92718b74	22	/**
fa099d23	23	* Update head_sha1, head_ref and is_detached of the given worktree
92718b74	24	*/
fa099d23	25	static void add_head_info(struct worktree *wt)
92718b74	26	{
fa099d23 NTND	27	int flags;
	28	const char *target;
	29
	30	target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt),
	31	"HEAD",
	32	RESOLVE_REF_READING,
	33	wt->head_sha1, &flags);
	34	if (!target)
	35	return;
	36
	37	if (flags & REF_ISSYMREF)
	38	wt->head_ref = xstrdup(target);
	39	else
	40	wt->is_detached = 1;
92718b74 MR	41	}
92718b74 MR	42
51934904 MR	43	/**
	44	* get the main worktree
	45	*/
	46	static struct worktree *get_main_worktree(void)
1ceb7f90	47	{
51934904	48	struct worktree *worktree = NULL;
1ceb7f90	49	struct strbuf path = STRBUF_INIT;
51934904	50	struct strbuf worktree_path = STRBUF_INIT;
92718b74	51	int is_bare = 0;
1ceb7f90	52
fd2e7daf	53	strbuf_add_absolute_path(&worktree_path, get_git_common_dir());
92718b74 MR	54	is_bare = !strbuf_strip_suffix(&worktree_path, "/.git");
92718b74 MR	55	if (is_bare)
51934904 MR	56	strbuf_strip_suffix(&worktree_path, "/.");
	57
	58	strbuf_addf(&path, "%s/HEAD", get_git_common_dir());
	59
f054996d	60	worktree = xcalloc(1, sizeof(*worktree));
92718b74	61	worktree->path = strbuf_detach(&worktree_path, NULL);
92718b74	62	worktree->is_bare = is_bare;
fa099d23	63	add_head_info(worktree);
92718b74	64
1ceb7f90	65	strbuf_release(&path);
51934904	66	strbuf_release(&worktree_path);
51934904	67	return worktree;
1ceb7f90 MR	68	}
1ceb7f90 MR	69
51934904	70	static struct worktree get_linked_worktree(const char id)
ac6c561b	71	{
51934904	72	struct worktree *worktree = NULL;
ac6c561b	73	struct strbuf path = STRBUF_INIT;
51934904	74	struct strbuf worktree_path = STRBUF_INIT;
ac6c561b	75
1ceb7f90 MR	76	if (!id)
1ceb7f90 MR	77	die("Missing linked worktree name");
ac6c561b	78
69dfe3b9	79	strbuf_git_common_path(&path, "worktrees/%s/gitdir", id);
51934904 MR	80	if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0)
51934904 MR	81	/* invalid gitdir file */
ac6c561b	82	goto done;
51934904 MR	83
	84	strbuf_rtrim(&worktree_path);
	85	if (!strbuf_strip_suffix(&worktree_path, "/.git")) {
	86	strbuf_reset(&worktree_path);
fd2e7daf	87	strbuf_add_absolute_path(&worktree_path, ".");
51934904 MR	88	strbuf_strip_suffix(&worktree_path, "/.");
	89	}
	90
1ceb7f90	91	strbuf_reset(&path);
51934904 MR	92	strbuf_addf(&path, "%s/worktrees/%s/HEAD", get_git_common_dir(), id);
51934904 MR	93
f054996d	94	worktree = xcalloc(1, sizeof(*worktree));
92718b74	95	worktree->path = strbuf_detach(&worktree_path, NULL);
69dfe3b9	96	worktree->id = xstrdup(id);
fa099d23	97	add_head_info(worktree);
ac6c561b	98
ac6c561b MR	99	done:
ac6c561b MR	100	strbuf_release(&path);
51934904	101	strbuf_release(&worktree_path);
51934904	102	return worktree;
ac6c561b MR	103	}
ac6c561b MR	104
750e8a60 NTND	105	static void mark_current_worktree(struct worktree **worktrees)
750e8a60 NTND	106	{
0aaad415	107	char *git_dir = absolute_pathdup(get_git_dir());
750e8a60 NTND	108	int i;
750e8a60 NTND	109
750e8a60 NTND	110	for (i = 0; worktrees[i]; i++) {
750e8a60 NTND	111	struct worktree *wt = worktrees[i];
360af2da NTND	112	const char *wt_git_dir = get_worktree_git_dir(wt);
	113
	114	if (!fspathcmp(git_dir, absolute_path(wt_git_dir))) {
	115	wt->is_current = 1;
750e8a60	116	break;
360af2da	117	}
750e8a60	118	}
360af2da	119	free(git_dir);
750e8a60 NTND	120	}
750e8a60 NTND	121
4df1d4d4 NTND	122	static int compare_worktree(const void a_, const void b_)
	123	{
	124	const struct worktree const a = a_;
	125	const struct worktree const b = b_;
	126	return fspathcmp((a)->path, (b)->path);
	127	}
	128
4fff1ef7	129	struct worktree **get_worktrees(unsigned flags)
ac6c561b	130	{
51934904	131	struct worktree **list = NULL;
ac6c561b MR	132	struct strbuf path = STRBUF_INIT;
	133	DIR *dir;
	134	struct dirent *d;
51934904 MR	135	int counter = 0, alloc = 2;
51934904 MR	136
3f64699f	137	ALLOC_ARRAY(list, alloc);
ac6c561b	138
a234563a	139	list[counter++] = get_main_worktree();
ac6c561b MR	140
	141	strbuf_addf(&path, "%s/worktrees", get_git_common_dir());
	142	dir = opendir(path.buf);
	143	strbuf_release(&path);
51934904 MR	144	if (dir) {
	145	while ((d = readdir(dir)) != NULL) {
	146	struct worktree *linked = NULL;
afb9e30b	147	if (is_dot_or_dotdot(d->d_name))
51934904	148	continue;
ac6c561b	149
d4cddd66 NTND	150	if ((linked = get_linked_worktree(d->d_name))) {
	151	ALLOC_GROW(list, counter + 1, alloc);
	152	list[counter++] = linked;
	153	}
51934904 MR	154	}
	155	closedir(dir);
	156	}
	157	ALLOC_GROW(list, counter + 1, alloc);
	158	list[counter] = NULL;
750e8a60	159
4df1d4d4 NTND	160	if (flags & GWT_SORT_LINKED)
	161	/*
	162	* don't sort the first item (main worktree), which will
	163	* always be the first
	164	*/
	165	QSORT(list + 1, counter - 1, compare_worktree);
	166
750e8a60	167	mark_current_worktree(list);
51934904 MR	168	return list;
	169	}
	170
69dfe3b9 NTND	171	const char get_worktree_git_dir(const struct worktree wt)
	172	{
	173	if (!wt)
	174	return get_git_dir();
	175	else if (!wt->id)
	176	return get_git_common_dir();
	177	else
	178	return git_common_path("worktrees/%s", wt->id);
	179	}
	180
080739ba NTND	181	static struct worktree find_worktree_by_suffix(struct worktree *list,
	182	const char *suffix)
	183	{
	184	struct worktree *found = NULL;
	185	int nr_found = 0, suffixlen;
	186
	187	suffixlen = strlen(suffix);
	188	if (!suffixlen)
	189	return NULL;
	190
	191	for (; *list && nr_found < 2; list++) {
	192	const char path = (list)->path;
	193	int pathlen = strlen(path);
	194	int start = pathlen - suffixlen;
	195
	196	/* suffix must start at directory boundary */
	197	if ((!start \|\| (start > 0 && is_dir_sep(path[start - 1]))) &&
	198	!fspathcmp(suffix, path + start)) {
	199	found = *list;
	200	nr_found++;
	201	}
	202	}
	203	return nr_found == 1 ? found : NULL;
	204	}
	205
68353144 NTND	206	struct worktree find_worktree(struct worktree *list,
	207	const char *prefix,
	208	const char *arg)
	209	{
080739ba	210	struct worktree *wt;
68353144 NTND	211	char *path;
68353144 NTND	212
080739ba NTND	213	if ((wt = find_worktree_by_suffix(list, arg)))
	214	return wt;
	215
68353144	216	arg = prefix_filename(prefix, strlen(prefix), arg);
ce83eadd	217	path = real_pathdup(arg, 1);
68353144 NTND	218	for (; *list; list++)
	219	if (!fspathcmp(path, real_path((*list)->path)))
	220	break;
	221	free(path);
	222	return *list;
	223	}
	224
984ad9e5 NTND	225	int is_main_worktree(const struct worktree *wt)
	226	{
	227	return !wt->id;
	228	}
	229
346ef530 NTND	230	const char is_worktree_locked(struct worktree wt)
	231	{
	232	assert(!is_main_worktree(wt));
	233
	234	if (!wt->lock_reason_valid) {
	235	struct strbuf path = STRBUF_INIT;
	236
	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);
	244	} else
	245	wt->lock_reason = NULL;
	246	wt->lock_reason_valid = 1;
	247	strbuf_release(&path);
	248	}
	249
	250	return wt->lock_reason;
	251	}
	252
14ace5b7 NTND	253	int is_worktree_being_rebased(const struct worktree *wt,
14ace5b7 NTND	254	const char *target)
8d9fdd70 NTND	255	{
	256	struct wt_status_state state;
	257	int found_rebase;
	258
	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) &&
	263	state.branch &&
	264	starts_with(target, "refs/heads/") &&
	265	!strcmp(state.branch, target + strlen("refs/heads/")));
	266	free(state.branch);
	267	free(state.onto);
	268	return found_rebase;
	269	}
	270
14ace5b7 NTND	271	int is_worktree_being_bisected(const struct worktree *wt,
14ace5b7 NTND	272	const char *target)
51934904	273	{
04a3dfb8 NTND	274	struct wt_status_state state;
	275	int found_rebase;
	276
	277	memset(&state, 0, sizeof(state));
	278	found_rebase = wt_status_check_bisect(wt, &state) &&
	279	state.branch &&
	280	starts_with(target, "refs/heads/") &&
	281	!strcmp(state.branch, target + strlen("refs/heads/"));
	282	free(state.branch);
	283	return found_rebase;
	284	}
	285
8d9fdd70 NTND	286	/*
	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
	290	* function as well.
	291	*/
d3b9ac07 NTND	292	const struct worktree find_shared_symref(const char symref,
d3b9ac07 NTND	293	const char *target)
51934904	294	{
d3b9ac07	295	const struct worktree *existing = NULL;
d3b9ac07	296	static struct worktree **worktrees;
51934904 MR	297	int i = 0;
51934904 MR	298
d3b9ac07 NTND	299	if (worktrees)
d3b9ac07 NTND	300	free_worktrees(worktrees);
4fff1ef7	301	worktrees = get_worktrees(0);
d3b9ac07	302
51934904	303	for (i = 0; worktrees[i]; i++) {
c8717148	304	struct worktree *wt = worktrees[i];
fa099d23 NTND	305	const char *symref_target;
	306	unsigned char sha1[20];
	307	struct ref_store *refs;
	308	int flags;
	309
171c646f DK	310	if (wt->is_bare)
171c646f DK	311	continue;
c8717148	312
8d9fdd70 NTND	313	if (wt->is_detached && !strcmp(symref, "HEAD")) {
	314	if (is_worktree_being_rebased(wt, target)) {
	315	existing = wt;
	316	break;
	317	}
04a3dfb8 NTND	318	if (is_worktree_being_bisected(wt, target)) {
	319	existing = wt;
	320	break;
	321	}
8d9fdd70 NTND	322	}
8d9fdd70 NTND	323
fa099d23 NTND	324	refs = get_worktree_ref_store(wt);
	325	symref_target = refs_resolve_ref_unsafe(refs, symref, 0,
	326	sha1, &flags);
	327	if ((flags & REF_ISSYMREF) && !strcmp(symref_target, target)) {
c8717148	328	existing = wt;
51934904 MR	329	break;
51934904 MR	330	}
ac6c561b	331	}
51934904	332
ac6c561b MR	333	return existing;
ac6c561b MR	334	}
1a248cf2 SB	335
	336	int submodule_uses_worktrees(const char *path)
	337	{
	338	char *submodule_gitdir;
	339	struct strbuf sb = STRBUF_INIT;
	340	DIR *dir;
	341	struct dirent *d;
7c4be458	342	int ret = 0;
1a248cf2 SB	343	struct repository_format format;
	344
	345	submodule_gitdir = git_pathdup_submodule(path, "%s", "");
	346	if (!submodule_gitdir)
	347	return 0;
	348
	349	/* The env would be set for the superproject. */
	350	get_common_dir_noenv(&sb, submodule_gitdir);
	351
	352	/*
	353	* The check below is only known to be good for repository format
	354	* version 0 at the time of writing this code.
	355	*/
	356	strbuf_addstr(&sb, "/config");
	357	read_repository_format(&format, sb.buf);
	358	if (format.version != 0) {
	359	strbuf_release(&sb);
	360	return 1;
	361	}
	362
	363	/* Replace config by worktrees. */
	364	strbuf_setlen(&sb, sb.len - strlen("config"));
	365	strbuf_addstr(&sb, "worktrees");
	366
	367	/* See if there is any file inside the worktrees directory. */
	368	dir = opendir(sb.buf);
	369	strbuf_release(&sb);
	370	free(submodule_gitdir);
	371
	372	if (!dir)
	373	return 0;
	374
	375	while ((d = readdir(dir)) != NULL) {
	376	if (is_dot_or_dotdot(d->d_name))
	377	continue;
	378
	379	ret = 1;
	380	break;
	381	}
	382	closedir(dir);
	383	return ret;
	384	}