git

1
#include "builtin.h"
2
#include "abspath.h"
3
#include "advice.h"
4
#include "checkout.h"
5
#include "config.h"
6
#include "copy.h"
7
#include "dir.h"
8
#include "environment.h"
9
#include "gettext.h"
10
#include "hex.h"
11
#include "object-file.h"
12
#include "object-name.h"
13
#include "parse-options.h"
14
#include "path.h"
15
#include "strvec.h"
16
#include "branch.h"
17
#include "read-cache-ll.h"
18
#include "refs.h"
19
#include "remote.h"
20
#include "repository.h"
21
#include "run-command.h"
22
#include "hook.h"
23
#include "sigchain.h"
24
#include "submodule.h"
25
#include "utf8.h"
26
#include "worktree.h"
27
#include "quote.h"
28

29
#define BUILTIN_WORKTREE_ADD_USAGE \
30
	N_("git worktree add [-f] [--detach] [--checkout] [--lock [--reason <string>]]\n" \
31
	   "                 [--orphan] [(-b | -B) <new-branch>] <path> [<commit-ish>]")
32

33
#define BUILTIN_WORKTREE_LIST_USAGE \
34
	N_("git worktree list [-v | --porcelain [-z]]")
35
#define BUILTIN_WORKTREE_LOCK_USAGE \
36
	N_("git worktree lock [--reason <string>] <worktree>")
37
#define BUILTIN_WORKTREE_MOVE_USAGE \
38
	N_("git worktree move <worktree> <new-path>")
39
#define BUILTIN_WORKTREE_PRUNE_USAGE \
40
	N_("git worktree prune [-n] [-v] [--expire <expire>]")
41
#define BUILTIN_WORKTREE_REMOVE_USAGE \
42
	N_("git worktree remove [-f] <worktree>")
43
#define BUILTIN_WORKTREE_REPAIR_USAGE \
44
	N_("git worktree repair [<path>...]")
45
#define BUILTIN_WORKTREE_UNLOCK_USAGE \
46
	N_("git worktree unlock <worktree>")
47

48
#define WORKTREE_ADD_DWIM_ORPHAN_INFER_TEXT \
49
	_("No possible source branch, inferring '--orphan'")
50

51
#define WORKTREE_ADD_ORPHAN_WITH_DASH_B_HINT_TEXT \
52
	_("If you meant to create a worktree containing a new unborn branch\n" \
53
	"(branch with no commits) for this repository, you can do so\n" \
54
	"using the --orphan flag:\n" \
55
	"\n" \
56
	"    git worktree add --orphan -b %s %s\n")
57

58
#define WORKTREE_ADD_ORPHAN_NO_DASH_B_HINT_TEXT \
59
	_("If you meant to create a worktree containing a new unborn branch\n" \
60
	"(branch with no commits) for this repository, you can do so\n" \
61
	"using the --orphan flag:\n" \
62
	"\n" \
63
	"    git worktree add --orphan %s\n")
64

65
static const char * const git_worktree_usage[] = {
66
	BUILTIN_WORKTREE_ADD_USAGE,
67
	BUILTIN_WORKTREE_LIST_USAGE,
68
	BUILTIN_WORKTREE_LOCK_USAGE,
69
	BUILTIN_WORKTREE_MOVE_USAGE,
70
	BUILTIN_WORKTREE_PRUNE_USAGE,
71
	BUILTIN_WORKTREE_REMOVE_USAGE,
72
	BUILTIN_WORKTREE_REPAIR_USAGE,
73
	BUILTIN_WORKTREE_UNLOCK_USAGE,
74
	NULL
75
};
76

77
static const char * const git_worktree_add_usage[] = {
78
	BUILTIN_WORKTREE_ADD_USAGE,
79
	NULL,
80
};
81

82
static const char * const git_worktree_list_usage[] = {
83
	BUILTIN_WORKTREE_LIST_USAGE,
84
	NULL
85
};
86

87
static const char * const git_worktree_lock_usage[] = {
88
	BUILTIN_WORKTREE_LOCK_USAGE,
89
	NULL
90
};
91

92
static const char * const git_worktree_move_usage[] = {
93
	BUILTIN_WORKTREE_MOVE_USAGE,
94
	NULL
95
};
96

97
static const char * const git_worktree_prune_usage[] = {
98
	BUILTIN_WORKTREE_PRUNE_USAGE,
99
	NULL
100
};
101

102
static const char * const git_worktree_remove_usage[] = {
103
	BUILTIN_WORKTREE_REMOVE_USAGE,
104
	NULL
105
};
106

107
static const char * const git_worktree_repair_usage[] = {
108
	BUILTIN_WORKTREE_REPAIR_USAGE,
109
	NULL
110
};
111

112
static const char * const git_worktree_unlock_usage[] = {
113
	BUILTIN_WORKTREE_UNLOCK_USAGE,
114
	NULL
115
};
116

117
struct add_opts {
118
	int force;
119
	int detach;
120
	int quiet;
121
	int checkout;
122
	int orphan;
123
	const char *keep_locked;
124
};
125

126
static int show_only;
127
static int verbose;
128
static int guess_remote;
129
static timestamp_t expire;
130

131
static int git_worktree_config(const char *var, const char *value,
132
			       const struct config_context *ctx, void *cb)
133
{
134
	if (!strcmp(var, "worktree.guessremote")) {
135
		guess_remote = git_config_bool(var, value);
136
		return 0;
137
	}
138

139
	return git_default_config(var, value, ctx, cb);
140
}
141

142
static int delete_git_dir(const char *id)
143
{
144
	struct strbuf sb = STRBUF_INIT;
145
	int ret;
146

147
	strbuf_addstr(&sb, git_common_path("worktrees/%s", id));
148
	ret = remove_dir_recursively(&sb, 0);
149
	if (ret < 0 && errno == ENOTDIR)
150
		ret = unlink(sb.buf);
151
	if (ret)
152
		error_errno(_("failed to delete '%s'"), sb.buf);
153
	strbuf_release(&sb);
154
	return ret;
155
}
156

157
static void delete_worktrees_dir_if_empty(void)
158
{
159
	rmdir(git_path("worktrees")); /* ignore failed removal */
160
}
161

162
static void prune_worktree(const char *id, const char *reason)
163
{
164
	if (show_only || verbose)
165
		fprintf_ln(stderr, _("Removing %s/%s: %s"), "worktrees", id, reason);
166
	if (!show_only)
167
		delete_git_dir(id);
168
}
169

170
static int prune_cmp(const void *a, const void *b)
171
{
172
	const struct string_list_item *x = a;
173
	const struct string_list_item *y = b;
174
	int c;
175

176
	if ((c = fspathcmp(x->string, y->string)))
177
	    return c;
178
	/*
179
	 * paths same; prune_dupes() removes all but the first worktree entry
180
	 * having the same path, so sort main worktree ('util' is NULL) above
181
	 * linked worktrees ('util' not NULL) since main worktree can't be
182
	 * removed
183
	 */
184
	if (!x->util)
185
		return -1;
186
	if (!y->util)
187
		return 1;
188
	/* paths same; sort by .git/worktrees/<id> */
189
	return strcmp(x->util, y->util);
190
}
191

192
static void prune_dups(struct string_list *l)
193
{
194
	int i;
195

196
	QSORT(l->items, l->nr, prune_cmp);
197
	for (i = 1; i < l->nr; i++) {
198
		if (!fspathcmp(l->items[i].string, l->items[i - 1].string))
199
			prune_worktree(l->items[i].util, "duplicate entry");
200
	}
201
}
202

203
static void prune_worktrees(void)
204
{
205
	struct strbuf reason = STRBUF_INIT;
206
	struct strbuf main_path = STRBUF_INIT;
207
	struct string_list kept = STRING_LIST_INIT_DUP;
208
	DIR *dir = opendir(git_path("worktrees"));
209
	struct dirent *d;
210
	if (!dir)
211
		return;
212
	while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) {
213
		char *path;
214
		strbuf_reset(&reason);
215
		if (should_prune_worktree(d->d_name, &reason, &path, expire))
216
			prune_worktree(d->d_name, reason.buf);
217
		else if (path)
218
			string_list_append_nodup(&kept, path)->util = xstrdup(d->d_name);
219
	}
220
	closedir(dir);
221

222
	strbuf_add_absolute_path(&main_path, get_git_common_dir());
223
	/* massage main worktree absolute path to match 'gitdir' content */
224
	strbuf_strip_suffix(&main_path, "/.");
225
	string_list_append_nodup(&kept, strbuf_detach(&main_path, NULL));
226
	prune_dups(&kept);
227
	string_list_clear(&kept, 1);
228

229
	if (!show_only)
230
		delete_worktrees_dir_if_empty();
231
	strbuf_release(&reason);
232
}
233

234
static int prune(int ac, const char **av, const char *prefix)
235
{
236
	struct option options[] = {
237
		OPT__DRY_RUN(&show_only, N_("do not remove, show only")),
238
		OPT__VERBOSE(&verbose, N_("report pruned working trees")),
239
		OPT_EXPIRY_DATE(0, "expire", &expire,
240
				N_("expire working trees older than <time>")),
241
		OPT_END()
242
	};
243

244
	expire = TIME_MAX;
245
	ac = parse_options(ac, av, prefix, options, git_worktree_prune_usage,
246
			   0);
247
	if (ac)
248
		usage_with_options(git_worktree_prune_usage, options);
249
	prune_worktrees();
250
	return 0;
251
}
252

253
static char *junk_work_tree;
254
static char *junk_git_dir;
255
static int is_junk;
256
static pid_t junk_pid;
257

258
static void remove_junk(void)
259
{
260
	struct strbuf sb = STRBUF_INIT;
261
	if (!is_junk || getpid() != junk_pid)
262
		return;
263
	if (junk_git_dir) {
264
		strbuf_addstr(&sb, junk_git_dir);
265
		remove_dir_recursively(&sb, 0);
266
		strbuf_reset(&sb);
267
	}
268
	if (junk_work_tree) {
269
		strbuf_addstr(&sb, junk_work_tree);
270
		remove_dir_recursively(&sb, 0);
271
	}
272
	strbuf_release(&sb);
273
}
274

275
static void remove_junk_on_signal(int signo)
276
{
277
	remove_junk();
278
	sigchain_pop(signo);
279
	raise(signo);
280
}
281

282
static const char *worktree_basename(const char *path, int *olen)
283
{
284
	const char *name;
285
	int len;
286

287
	len = strlen(path);
288
	while (len && is_dir_sep(path[len - 1]))
289
		len--;
290

291
	for (name = path + len - 1; name > path; name--)
292
		if (is_dir_sep(*name)) {
293
			name++;
294
			break;
295
		}
296

297
	*olen = len;
298
	return name;
299
}
300

301
/* check that path is viable location for worktree */
302
static void check_candidate_path(const char *path,
303
				 int force,
304
				 struct worktree **worktrees,
305
				 const char *cmd)
306
{
307
	struct worktree *wt;
308
	int locked;
309

310
	if (file_exists(path) && !is_empty_dir(path))
311
		die(_("'%s' already exists"), path);
312

313
	wt = find_worktree_by_path(worktrees, path);
314
	if (!wt)
315
		return;
316

317
	locked = !!worktree_lock_reason(wt);
318
	if ((!locked && force) || (locked && force > 1)) {
319
		if (delete_git_dir(wt->id))
320
		    die(_("unusable worktree destination '%s'"), path);
321
		return;
322
	}
323

324
	if (locked)
325
		die(_("'%s' is a missing but locked worktree;\nuse '%s -f -f' to override, or 'unlock' and 'prune' or 'remove' to clear"), path, cmd);
326
	else
327
		die(_("'%s' is a missing but already registered worktree;\nuse '%s -f' to override, or 'prune' or 'remove' to clear"), path, cmd);
328
}
329

330
static void copy_sparse_checkout(const char *worktree_git_dir)
331
{
332
	char *from_file = git_pathdup("info/sparse-checkout");
333
	char *to_file = xstrfmt("%s/info/sparse-checkout", worktree_git_dir);
334

335
	if (file_exists(from_file)) {
336
		if (safe_create_leading_directories(to_file) ||
337
			copy_file(to_file, from_file, 0666))
338
			error(_("failed to copy '%s' to '%s'; sparse-checkout may not work correctly"),
339
				from_file, to_file);
340
	}
341

342
	free(from_file);
343
	free(to_file);
344
}
345

346
static void copy_filtered_worktree_config(const char *worktree_git_dir)
347
{
348
	char *from_file = git_pathdup("config.worktree");
349
	char *to_file = xstrfmt("%s/config.worktree", worktree_git_dir);
350

351
	if (file_exists(from_file)) {
352
		struct config_set cs = { { 0 } };
353
		int bare;
354

355
		if (safe_create_leading_directories(to_file) ||
356
			copy_file(to_file, from_file, 0666)) {
357
			error(_("failed to copy worktree config from '%s' to '%s'"),
358
				from_file, to_file);
359
			goto worktree_copy_cleanup;
360
		}
361

362
		git_configset_init(&cs);
363
		git_configset_add_file(&cs, from_file);
364

365
		if (!git_configset_get_bool(&cs, "core.bare", &bare) &&
366
			bare &&
367
			git_config_set_multivar_in_file_gently(
368
				to_file, "core.bare", NULL, "true", NULL, 0))
369
			error(_("failed to unset '%s' in '%s'"),
370
				"core.bare", to_file);
371
		if (!git_configset_get(&cs, "core.worktree") &&
372
			git_config_set_in_file_gently(to_file,
373
							"core.worktree", NULL, NULL))
374
			error(_("failed to unset '%s' in '%s'"),
375
				"core.worktree", to_file);
376

377
		git_configset_clear(&cs);
378
	}
379

380
worktree_copy_cleanup:
381
	free(from_file);
382
	free(to_file);
383
}
384

385
static int checkout_worktree(const struct add_opts *opts,
386
			     struct strvec *child_env)
387
{
388
	struct child_process cp = CHILD_PROCESS_INIT;
389
	cp.git_cmd = 1;
390
	strvec_pushl(&cp.args, "reset", "--hard", "--no-recurse-submodules", NULL);
391
	if (opts->quiet)
392
		strvec_push(&cp.args, "--quiet");
393
	strvec_pushv(&cp.env, child_env->v);
394
	return run_command(&cp);
395
}
396

397
static int make_worktree_orphan(const char * ref, const struct add_opts *opts,
398
				struct strvec *child_env)
399
{
400
	struct strbuf symref = STRBUF_INIT;
401
	struct child_process cp = CHILD_PROCESS_INIT;
402

403
	validate_new_branchname(ref, &symref, 0);
404
	strvec_pushl(&cp.args, "symbolic-ref", "HEAD", symref.buf, NULL);
405
	if (opts->quiet)
406
		strvec_push(&cp.args, "--quiet");
407
	strvec_pushv(&cp.env, child_env->v);
408
	strbuf_release(&symref);
409
	cp.git_cmd = 1;
410
	return run_command(&cp);
411
}
412

413
static int add_worktree(const char *path, const char *refname,
414
			const struct add_opts *opts)
415
{
416
	struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;
417
	struct strbuf sb = STRBUF_INIT, realpath = STRBUF_INIT;
418
	const char *name;
419
	struct strvec child_env = STRVEC_INIT;
420
	unsigned int counter = 0;
421
	int len, ret;
422
	struct strbuf symref = STRBUF_INIT;
423
	struct commit *commit = NULL;
424
	int is_branch = 0;
425
	struct strbuf sb_name = STRBUF_INIT;
426
	struct worktree **worktrees, *wt = NULL;
427
	struct ref_store *wt_refs;
428

429
	worktrees = get_worktrees();
430
	check_candidate_path(path, opts->force, worktrees, "add");
431
	free_worktrees(worktrees);
432
	worktrees = NULL;
433

434
	/* is 'refname' a branch or commit? */
435
	if (!opts->detach && !strbuf_check_branch_ref(&symref, refname) &&
436
	    refs_ref_exists(get_main_ref_store(the_repository), symref.buf)) {
437
		is_branch = 1;
438
		if (!opts->force)
439
			die_if_checked_out(symref.buf, 0);
440
	}
441
	commit = lookup_commit_reference_by_name(refname);
442
	if (!commit && !opts->orphan)
443
		die(_("invalid reference: %s"), refname);
444

445
	name = worktree_basename(path, &len);
446
	strbuf_add(&sb, name, path + len - name);
447
	sanitize_refname_component(sb.buf, &sb_name);
448
	if (!sb_name.len)
449
		BUG("How come '%s' becomes empty after sanitization?", sb.buf);
450
	strbuf_reset(&sb);
451
	name = sb_name.buf;
452
	git_path_buf(&sb_repo, "worktrees/%s", name);
453
	len = sb_repo.len;
454
	if (safe_create_leading_directories_const(sb_repo.buf))
455
		die_errno(_("could not create leading directories of '%s'"),
456
			  sb_repo.buf);
457

458
	while (mkdir(sb_repo.buf, 0777)) {
459
		counter++;
460
		if ((errno != EEXIST) || !counter /* overflow */)
461
			die_errno(_("could not create directory of '%s'"),
462
				  sb_repo.buf);
463
		strbuf_setlen(&sb_repo, len);
464
		strbuf_addf(&sb_repo, "%d", counter);
465
	}
466
	name = strrchr(sb_repo.buf, '/') + 1;
467

468
	junk_pid = getpid();
469
	atexit(remove_junk);
470
	sigchain_push_common(remove_junk_on_signal);
471

472
	junk_git_dir = xstrdup(sb_repo.buf);
473
	is_junk = 1;
474

475
	/*
476
	 * lock the incomplete repo so prune won't delete it, unlock
477
	 * after the preparation is over.
478
	 */
479
	strbuf_addf(&sb, "%s/locked", sb_repo.buf);
480
	if (opts->keep_locked)
481
		write_file(sb.buf, "%s", opts->keep_locked);
482
	else
483
		write_file(sb.buf, _("initializing"));
484

485
	strbuf_addf(&sb_git, "%s/.git", path);
486
	if (safe_create_leading_directories_const(sb_git.buf))
487
		die_errno(_("could not create leading directories of '%s'"),
488
			  sb_git.buf);
489
	junk_work_tree = xstrdup(path);
490

491
	strbuf_reset(&sb);
492
	strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);
493
	strbuf_realpath(&realpath, sb_git.buf, 1);
494
	write_file(sb.buf, "%s", realpath.buf);
495
	strbuf_realpath(&realpath, get_git_common_dir(), 1);
496
	write_file(sb_git.buf, "gitdir: %s/worktrees/%s",
497
		   realpath.buf, name);
498
	strbuf_reset(&sb);
499
	strbuf_addf(&sb, "%s/commondir", sb_repo.buf);
500
	write_file(sb.buf, "../..");
501

502
	/*
503
	 * Set up the ref store of the worktree and create the HEAD reference.
504
	 */
505
	wt = get_linked_worktree(name, 1);
506
	if (!wt) {
507
		ret = error(_("could not find created worktree '%s'"), name);
508
		goto done;
509
	}
510
	wt_refs = get_worktree_ref_store(wt);
511

512
	ret = ref_store_create_on_disk(wt_refs, REF_STORE_CREATE_ON_DISK_IS_WORKTREE, &sb);
513
	if (ret)
514
		goto done;
515

516
	if (!is_branch && commit)
517
		ret = refs_update_ref(wt_refs, NULL, "HEAD", &commit->object.oid,
518
				      NULL, 0, UPDATE_REFS_MSG_ON_ERR);
519
	else
520
		ret = refs_update_symref(wt_refs, "HEAD", symref.buf, NULL);
521
	if (ret)
522
		goto done;
523

524
	/*
525
	 * If the current worktree has sparse-checkout enabled, then copy
526
	 * the sparse-checkout patterns from the current worktree.
527
	 */
528
	if (core_apply_sparse_checkout)
529
		copy_sparse_checkout(sb_repo.buf);
530

531
	/*
532
	 * If we are using worktree config, then copy all current config
533
	 * values from the current worktree into the new one, that way the
534
	 * new worktree behaves the same as this one.
535
	 */
536
	if (the_repository->repository_format_worktree_config)
537
		copy_filtered_worktree_config(sb_repo.buf);
538

539
	strvec_pushf(&child_env, "%s=%s", GIT_DIR_ENVIRONMENT, sb_git.buf);
540
	strvec_pushf(&child_env, "%s=%s", GIT_WORK_TREE_ENVIRONMENT, path);
541

542
	if (opts->orphan &&
543
	    (ret = make_worktree_orphan(refname, opts, &child_env)))
544
		goto done;
545

546
	if (opts->checkout &&
547
	    (ret = checkout_worktree(opts, &child_env)))
548
		goto done;
549

550
	is_junk = 0;
551
	FREE_AND_NULL(junk_work_tree);
552
	FREE_AND_NULL(junk_git_dir);
553

554
done:
555
	if (ret || !opts->keep_locked) {
556
		strbuf_reset(&sb);
557
		strbuf_addf(&sb, "%s/locked", sb_repo.buf);
558
		unlink_or_warn(sb.buf);
559
	}
560

561
	/*
562
	 * Hook failure does not warrant worktree deletion, so run hook after
563
	 * is_junk is cleared, but do return appropriate code when hook fails.
564
	 */
565
	if (!ret && opts->checkout && !opts->orphan) {
566
		struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
567

568
		strvec_pushl(&opt.env, "GIT_DIR", "GIT_WORK_TREE", NULL);
569
		strvec_pushl(&opt.args,
570
			     oid_to_hex(null_oid()),
571
			     oid_to_hex(&commit->object.oid),
572
			     "1",
573
			     NULL);
574
		opt.dir = path;
575

576
		ret = run_hooks_opt(the_repository, "post-checkout", &opt);
577
	}
578

579
	strvec_clear(&child_env);
580
	strbuf_release(&sb);
581
	strbuf_release(&symref);
582
	strbuf_release(&sb_repo);
583
	strbuf_release(&sb_git);
584
	strbuf_release(&sb_name);
585
	strbuf_release(&realpath);
586
	free_worktree(wt);
587
	return ret;
588
}
589

590
static void print_preparing_worktree_line(int detach,
591
					  const char *branch,
592
					  const char *new_branch,
593
					  int force_new_branch)
594
{
595
	if (force_new_branch) {
596
		struct commit *commit = lookup_commit_reference_by_name(new_branch);
597
		if (!commit)
598
			fprintf_ln(stderr, _("Preparing worktree (new branch '%s')"), new_branch);
599
		else
600
			fprintf_ln(stderr, _("Preparing worktree (resetting branch '%s'; was at %s)"),
601
				  new_branch,
602
				  repo_find_unique_abbrev(the_repository, &commit->object.oid, DEFAULT_ABBREV));
603
	} else if (new_branch) {
604
		fprintf_ln(stderr, _("Preparing worktree (new branch '%s')"), new_branch);
605
	} else {
606
		struct strbuf s = STRBUF_INIT;
607
		if (!detach && !strbuf_check_branch_ref(&s, branch) &&
608
		    refs_ref_exists(get_main_ref_store(the_repository), s.buf))
609
			fprintf_ln(stderr, _("Preparing worktree (checking out '%s')"),
610
				  branch);
611
		else {
612
			struct commit *commit = lookup_commit_reference_by_name(branch);
613
			if (!commit)
614
				BUG(_("unreachable: invalid reference: %s"), branch);
615
			fprintf_ln(stderr, _("Preparing worktree (detached HEAD %s)"),
616
				  repo_find_unique_abbrev(the_repository, &commit->object.oid, DEFAULT_ABBREV));
617
		}
618
		strbuf_release(&s);
619
	}
620
}
621

622
/**
623
 * Callback to short circuit iteration over refs on the first reference
624
 * corresponding to a valid oid.
625
 *
626
 * Returns 0 on failure and non-zero on success.
627
 */
628
static int first_valid_ref(const char *refname UNUSED,
629
			   const char *referent UNUSED,
630
			   const struct object_id *oid UNUSED,
631
			   int flags UNUSED,
632
			   void *cb_data UNUSED)
633
{
634
	return 1;
635
}
636

637
/**
638
 * Verifies HEAD and determines whether there exist any valid local references.
639
 *
640
 * - Checks whether HEAD points to a valid reference.
641
 *
642
 * - Checks whether any valid local branches exist.
643
 *
644
 * - Emits a warning if there exist any valid branches but HEAD does not point
645
 *   to a valid reference.
646
 *
647
 * Returns 1 if any of the previous checks are true, otherwise returns 0.
648
 */
649
static int can_use_local_refs(const struct add_opts *opts)
650
{
651
	if (refs_head_ref(get_main_ref_store(the_repository), first_valid_ref, NULL)) {
652
		return 1;
653
	} else if (refs_for_each_branch_ref(get_main_ref_store(the_repository), first_valid_ref, NULL)) {
654
		if (!opts->quiet) {
655
			struct strbuf path = STRBUF_INIT;
656
			struct strbuf contents = STRBUF_INIT;
657

658
			strbuf_add_real_path(&path, get_worktree_git_dir(NULL));
659
			strbuf_addstr(&path, "/HEAD");
660
			strbuf_read_file(&contents, path.buf, 64);
661
			strbuf_stripspace(&contents, NULL);
662
			strbuf_strip_suffix(&contents, "\n");
663

664
			warning(_("HEAD points to an invalid (or orphaned) reference.\n"
665
				  "HEAD path: '%s'\n"
666
				  "HEAD contents: '%s'"),
667
				  path.buf, contents.buf);
668
			strbuf_release(&path);
669
			strbuf_release(&contents);
670
		}
671
		return 1;
672
	}
673
	return 0;
674
}
675

676
/**
677
 * Reports whether the necessary flags were set and whether the repository has
678
 * remote references to attempt DWIM tracking of upstream branches.
679
 *
680
 * 1. Checks that `--guess-remote` was used or `worktree.guessRemote = true`.
681
 *
682
 * 2. Checks whether any valid remote branches exist.
683
 *
684
 * 3. Checks that there exists at least one remote and emits a warning/error
685
 *    if both checks 1. and 2. are false (can be bypassed with `--force`).
686
 *
687
 * Returns 1 if checks 1. and 2. are true, otherwise 0.
688
 */
689
static int can_use_remote_refs(const struct add_opts *opts)
690
{
691
	if (!guess_remote) {
692
		return 0;
693
	} else if (refs_for_each_remote_ref(get_main_ref_store(the_repository), first_valid_ref, NULL)) {
694
		return 1;
695
	} else if (!opts->force && remote_get(NULL)) {
696
		die(_("No local or remote refs exist despite at least one remote\n"
697
		      "present, stopping; use 'add -f' to override or fetch a remote first"));
698
	}
699
	return 0;
700
}
701

702
/**
703
 * Determines whether `--orphan` should be inferred in the evaluation of
704
 * `worktree add path/` or `worktree add -b branch path/` and emits an error
705
 * if the supplied arguments would produce an illegal combination when the
706
 * `--orphan` flag is included.
707
 *
708
 * `opts` and `opt_track` contain the other options & flags supplied to the
709
 * command.
710
 *
711
 * remote determines whether to check `can_use_remote_refs()` or not. This
712
 * is primarily to differentiate between the basic `add` DWIM and `add -b`.
713
 *
714
 * Returns 1 when inferring `--orphan`, 0 otherwise, and emits an error when
715
 * `--orphan` is inferred but doing so produces an illegal combination of
716
 * options and flags. Additionally produces an error when remote refs are
717
 * checked and the repo is in a state that looks like the user added a remote
718
 * but forgot to fetch (and did not override the warning with -f).
719
 */
720
static int dwim_orphan(const struct add_opts *opts, int opt_track, int remote)
721
{
722
	if (can_use_local_refs(opts)) {
723
		return 0;
724
	} else if (remote && can_use_remote_refs(opts)) {
725
		return 0;
726
	} else if (!opts->quiet) {
727
		fprintf_ln(stderr, WORKTREE_ADD_DWIM_ORPHAN_INFER_TEXT);
728
	}
729

730
	if (opt_track) {
731
		die(_("options '%s' and '%s' cannot be used together"),
732
		    "--orphan", "--track");
733
	} else if (!opts->checkout) {
734
		die(_("options '%s' and '%s' cannot be used together"),
735
		    "--orphan", "--no-checkout");
736
	}
737
	return 1;
738
}
739

740
static char *dwim_branch(const char *path, char **new_branch)
741
{
742
	int n;
743
	int branch_exists;
744
	const char *s = worktree_basename(path, &n);
745
	char *branchname = xstrndup(s, n);
746
	struct strbuf ref = STRBUF_INIT;
747

748
	branch_exists = !strbuf_check_branch_ref(&ref, branchname) &&
749
			refs_ref_exists(get_main_ref_store(the_repository),
750
					ref.buf);
751
	strbuf_release(&ref);
752
	if (branch_exists)
753
		return branchname;
754

755
	*new_branch = branchname;
756
	if (guess_remote) {
757
		struct object_id oid;
758
		char *remote = unique_tracking_name(*new_branch, &oid, NULL);
759
		return remote;
760
	}
761
	return NULL;
762
}
763

764
static int add(int ac, const char **av, const char *prefix)
765
{
766
	struct add_opts opts;
767
	const char *new_branch_force = NULL;
768
	char *path;
769
	const char *branch;
770
	char *branch_to_free = NULL;
771
	char *new_branch_to_free = NULL;
772
	const char *new_branch = NULL;
773
	char *opt_track = NULL;
774
	const char *lock_reason = NULL;
775
	int keep_locked = 0;
776
	int used_new_branch_options;
777
	struct option options[] = {
778
		OPT__FORCE(&opts.force,
779
			   N_("checkout <branch> even if already checked out in other worktree"),
780
			   PARSE_OPT_NOCOMPLETE),
781
		OPT_STRING('b', NULL, &new_branch, N_("branch"),
782
			   N_("create a new branch")),
783
		OPT_STRING('B', NULL, &new_branch_force, N_("branch"),
784
			   N_("create or reset a branch")),
785
		OPT_BOOL(0, "orphan", &opts.orphan, N_("create unborn branch")),
786
		OPT_BOOL('d', "detach", &opts.detach, N_("detach HEAD at named commit")),
787
		OPT_BOOL(0, "checkout", &opts.checkout, N_("populate the new working tree")),
788
		OPT_BOOL(0, "lock", &keep_locked, N_("keep the new working tree locked")),
789
		OPT_STRING(0, "reason", &lock_reason, N_("string"),
790
			   N_("reason for locking")),
791
		OPT__QUIET(&opts.quiet, N_("suppress progress reporting")),
792
		OPT_PASSTHRU(0, "track", &opt_track, NULL,
793
			     N_("set up tracking mode (see git-branch(1))"),
794
			     PARSE_OPT_NOARG | PARSE_OPT_OPTARG),
795
		OPT_BOOL(0, "guess-remote", &guess_remote,
796
			 N_("try to match the new branch name with a remote-tracking branch")),
797
		OPT_END()
798
	};
799
	int ret;
800

801
	memset(&opts, 0, sizeof(opts));
802
	opts.checkout = 1;
803
	ac = parse_options(ac, av, prefix, options, git_worktree_add_usage, 0);
804
	if (!!opts.detach + !!new_branch + !!new_branch_force > 1)
805
		die(_("options '%s', '%s', and '%s' cannot be used together"), "-b", "-B", "--detach");
806
	if (opts.detach && opts.orphan)
807
		die(_("options '%s' and '%s' cannot be used together"),
808
		    "--orphan", "--detach");
809
	if (opts.orphan && opt_track)
810
		die(_("options '%s' and '%s' cannot be used together"),
811
		    "--orphan", "--track");
812
	if (opts.orphan && !opts.checkout)
813
		die(_("options '%s' and '%s' cannot be used together"),
814
		    "--orphan", "--no-checkout");
815
	if (opts.orphan && ac == 2)
816
		die(_("option '%s' and commit-ish cannot be used together"),
817
		    "--orphan");
818
	if (lock_reason && !keep_locked)
819
		die(_("the option '%s' requires '%s'"), "--reason", "--lock");
820
	if (lock_reason)
821
		opts.keep_locked = lock_reason;
822
	else if (keep_locked)
823
		opts.keep_locked = _("added with --lock");
824

825
	if (ac < 1 || ac > 2)
826
		usage_with_options(git_worktree_add_usage, options);
827

828
	path = prefix_filename(prefix, av[0]);
829
	branch = ac < 2 ? "HEAD" : av[1];
830
	used_new_branch_options = new_branch || new_branch_force;
831

832
	if (!strcmp(branch, "-"))
833
		branch = "@{-1}";
834

835
	if (new_branch_force) {
836
		struct strbuf symref = STRBUF_INIT;
837

838
		new_branch = new_branch_force;
839

840
		if (!opts.force &&
841
		    !strbuf_check_branch_ref(&symref, new_branch) &&
842
		    refs_ref_exists(get_main_ref_store(the_repository), symref.buf))
843
			die_if_checked_out(symref.buf, 0);
844
		strbuf_release(&symref);
845
	}
846

847
	if (opts.orphan && !new_branch) {
848
		int n;
849
		const char *s = worktree_basename(path, &n);
850
		new_branch = new_branch_to_free = xstrndup(s, n);
851
	} else if (opts.orphan) {
852
		; /* no-op */
853
	} else if (opts.detach) {
854
		/* Check HEAD */
855
		if (!strcmp(branch, "HEAD"))
856
			can_use_local_refs(&opts);
857
	} else if (ac < 2 && new_branch) {
858
		/* DWIM: Infer --orphan when repo has no refs. */
859
		opts.orphan = dwim_orphan(&opts, !!opt_track, 0);
860
	} else if (ac < 2) {
861
		/* DWIM: Guess branch name from path. */
862
		char *s = dwim_branch(path, &new_branch_to_free);
863
		if (s)
864
			branch = branch_to_free = s;
865
		new_branch = new_branch_to_free;
866

867
		/* DWIM: Infer --orphan when repo has no refs. */
868
		opts.orphan = (!s) && dwim_orphan(&opts, !!opt_track, 1);
869
	} else if (ac == 2) {
870
		struct object_id oid;
871
		struct commit *commit;
872
		char *remote;
873

874
		commit = lookup_commit_reference_by_name(branch);
875
		if (!commit) {
876
			remote = unique_tracking_name(branch, &oid, NULL);
877
			if (remote) {
878
				new_branch = branch;
879
				branch = new_branch_to_free = remote;
880
			}
881
		}
882

883
		if (!strcmp(branch, "HEAD"))
884
			can_use_local_refs(&opts);
885

886
	}
887

888
	if (!opts.orphan && !lookup_commit_reference_by_name(branch)) {
889
		int attempt_hint = !opts.quiet && (ac < 2);
890
		if (attempt_hint && used_new_branch_options) {
891
			advise_if_enabled(ADVICE_WORKTREE_ADD_ORPHAN,
892
				WORKTREE_ADD_ORPHAN_WITH_DASH_B_HINT_TEXT,
893
				new_branch, path);
894
		} else if (attempt_hint) {
895
			advise_if_enabled(ADVICE_WORKTREE_ADD_ORPHAN,
896
				WORKTREE_ADD_ORPHAN_NO_DASH_B_HINT_TEXT, path);
897
		}
898
		die(_("invalid reference: %s"), branch);
899
	}
900

901
	if (!opts.quiet)
902
		print_preparing_worktree_line(opts.detach, branch, new_branch, !!new_branch_force);
903

904
	if (opts.orphan) {
905
		branch = new_branch;
906
	} else if (new_branch) {
907
		struct child_process cp = CHILD_PROCESS_INIT;
908
		cp.git_cmd = 1;
909
		strvec_push(&cp.args, "branch");
910
		if (new_branch_force)
911
			strvec_push(&cp.args, "--force");
912
		if (opts.quiet)
913
			strvec_push(&cp.args, "--quiet");
914
		strvec_push(&cp.args, new_branch);
915
		strvec_push(&cp.args, branch);
916
		if (opt_track)
917
			strvec_push(&cp.args, opt_track);
918
		if (run_command(&cp))
919
			return -1;
920
		branch = new_branch;
921
	} else if (opt_track) {
922
		die(_("--[no-]track can only be used if a new branch is created"));
923
	}
924

925
	ret = add_worktree(path, branch, &opts);
926
	free(path);
927
	free(opt_track);
928
	free(branch_to_free);
929
	free(new_branch_to_free);
930
	return ret;
931
}
932

933
static void show_worktree_porcelain(struct worktree *wt, int line_terminator)
934
{
935
	const char *reason;
936

937
	printf("worktree %s%c", wt->path, line_terminator);
938
	if (wt->is_bare)
939
		printf("bare%c", line_terminator);
940
	else {
941
		printf("HEAD %s%c", oid_to_hex(&wt->head_oid), line_terminator);
942
		if (wt->is_detached)
943
			printf("detached%c", line_terminator);
944
		else if (wt->head_ref)
945
			printf("branch %s%c", wt->head_ref, line_terminator);
946
	}
947

948
	reason = worktree_lock_reason(wt);
949
	if (reason) {
950
		fputs("locked", stdout);
951
		if (*reason) {
952
			fputc(' ', stdout);
953
			write_name_quoted(reason, stdout, line_terminator);
954
		} else {
955
			fputc(line_terminator, stdout);
956
		}
957
	}
958

959
	reason = worktree_prune_reason(wt, expire);
960
	if (reason)
961
		printf("prunable %s%c", reason, line_terminator);
962

963
	fputc(line_terminator, stdout);
964
}
965

966
static void show_worktree(struct worktree *wt, int path_maxlen, int abbrev_len)
967
{
968
	struct strbuf sb = STRBUF_INIT;
969
	int cur_path_len = strlen(wt->path);
970
	int path_adj = cur_path_len - utf8_strwidth(wt->path);
971
	const char *reason;
972

973
	strbuf_addf(&sb, "%-*s ", 1 + path_maxlen + path_adj, wt->path);
974
	if (wt->is_bare)
975
		strbuf_addstr(&sb, "(bare)");
976
	else {
977
		strbuf_addf(&sb, "%-*s ", abbrev_len,
978
				repo_find_unique_abbrev(the_repository, &wt->head_oid, DEFAULT_ABBREV));
979
		if (wt->is_detached)
980
			strbuf_addstr(&sb, "(detached HEAD)");
981
		else if (wt->head_ref) {
982
			char *ref = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
983
								 wt->head_ref,
984
								 0);
985
			strbuf_addf(&sb, "[%s]", ref);
986
			free(ref);
987
		} else
988
			strbuf_addstr(&sb, "(error)");
989
	}
990

991
	reason = worktree_lock_reason(wt);
992
	if (verbose && reason && *reason)
993
		strbuf_addf(&sb, "\n\tlocked: %s", reason);
994
	else if (reason)
995
		strbuf_addstr(&sb, " locked");
996

997
	reason = worktree_prune_reason(wt, expire);
998
	if (verbose && reason)
999
		strbuf_addf(&sb, "\n\tprunable: %s", reason);
1000
	else if (reason)
1001
		strbuf_addstr(&sb, " prunable");
1002

1003
	printf("%s\n", sb.buf);
1004
	strbuf_release(&sb);
1005
}
1006

1007
static void measure_widths(struct worktree **wt, int *abbrev, int *maxlen)
1008
{
1009
	int i;
1010

1011
	for (i = 0; wt[i]; i++) {
1012
		int sha1_len;
1013
		int path_len = strlen(wt[i]->path);
1014

1015
		if (path_len > *maxlen)
1016
			*maxlen = path_len;
1017
		sha1_len = strlen(repo_find_unique_abbrev(the_repository, &wt[i]->head_oid, *abbrev));
1018
		if (sha1_len > *abbrev)
1019
			*abbrev = sha1_len;
1020
	}
1021
}
1022

1023
static int pathcmp(const void *a_, const void *b_)
1024
{
1025
	const struct worktree *const *a = a_;
1026
	const struct worktree *const *b = b_;
1027
	return fspathcmp((*a)->path, (*b)->path);
1028
}
1029

1030
static void pathsort(struct worktree **wt)
1031
{
1032
	int n = 0;
1033
	struct worktree **p = wt;
1034

1035
	while (*p++)
1036
		n++;
1037
	QSORT(wt, n, pathcmp);
1038
}
1039

1040
static int list(int ac, const char **av, const char *prefix)
1041
{
1042
	int porcelain = 0;
1043
	int line_terminator = '\n';
1044

1045
	struct option options[] = {
1046
		OPT_BOOL(0, "porcelain", &porcelain, N_("machine-readable output")),
1047
		OPT__VERBOSE(&verbose, N_("show extended annotations and reasons, if available")),
1048
		OPT_EXPIRY_DATE(0, "expire", &expire,
1049
				N_("add 'prunable' annotation to worktrees older than <time>")),
1050
		OPT_SET_INT('z', NULL, &line_terminator,
1051
			    N_("terminate records with a NUL character"), '\0'),
1052
		OPT_END()
1053
	};
1054

1055
	expire = TIME_MAX;
1056
	ac = parse_options(ac, av, prefix, options, git_worktree_list_usage, 0);
1057
	if (ac)
1058
		usage_with_options(git_worktree_list_usage, options);
1059
	else if (verbose && porcelain)
1060
		die(_("options '%s' and '%s' cannot be used together"), "--verbose", "--porcelain");
1061
	else if (!line_terminator && !porcelain)
1062
		die(_("the option '%s' requires '%s'"), "-z", "--porcelain");
1063
	else {
1064
		struct worktree **worktrees = get_worktrees();
1065
		int path_maxlen = 0, abbrev = DEFAULT_ABBREV, i;
1066

1067
		/* sort worktrees by path but keep main worktree at top */
1068
		pathsort(worktrees + 1);
1069

1070
		if (!porcelain)
1071
			measure_widths(worktrees, &abbrev, &path_maxlen);
1072

1073
		for (i = 0; worktrees[i]; i++) {
1074
			if (porcelain)
1075
				show_worktree_porcelain(worktrees[i],
1076
							line_terminator);
1077
			else
1078
				show_worktree(worktrees[i], path_maxlen, abbrev);
1079
		}
1080
		free_worktrees(worktrees);
1081
	}
1082
	return 0;
1083
}
1084

1085
static int lock_worktree(int ac, const char **av, const char *prefix)
1086
{
1087
	const char *reason = "", *old_reason;
1088
	struct option options[] = {
1089
		OPT_STRING(0, "reason", &reason, N_("string"),
1090
			   N_("reason for locking")),
1091
		OPT_END()
1092
	};
1093
	struct worktree **worktrees, *wt;
1094

1095
	ac = parse_options(ac, av, prefix, options, git_worktree_lock_usage, 0);
1096
	if (ac != 1)
1097
		usage_with_options(git_worktree_lock_usage, options);
1098

1099
	worktrees = get_worktrees();
1100
	wt = find_worktree(worktrees, prefix, av[0]);
1101
	if (!wt)
1102
		die(_("'%s' is not a working tree"), av[0]);
1103
	if (is_main_worktree(wt))
1104
		die(_("The main working tree cannot be locked or unlocked"));
1105

1106
	old_reason = worktree_lock_reason(wt);
1107
	if (old_reason) {
1108
		if (*old_reason)
1109
			die(_("'%s' is already locked, reason: %s"),
1110
			    av[0], old_reason);
1111
		die(_("'%s' is already locked"), av[0]);
1112
	}
1113

1114
	write_file(git_common_path("worktrees/%s/locked", wt->id),
1115
		   "%s", reason);
1116
	free_worktrees(worktrees);
1117
	return 0;
1118
}
1119

1120
static int unlock_worktree(int ac, const char **av, const char *prefix)
1121
{
1122
	struct option options[] = {
1123
		OPT_END()
1124
	};
1125
	struct worktree **worktrees, *wt;
1126
	int ret;
1127

1128
	ac = parse_options(ac, av, prefix, options, git_worktree_unlock_usage, 0);
1129
	if (ac != 1)
1130
		usage_with_options(git_worktree_unlock_usage, options);
1131

1132
	worktrees = get_worktrees();
1133
	wt = find_worktree(worktrees, prefix, av[0]);
1134
	if (!wt)
1135
		die(_("'%s' is not a working tree"), av[0]);
1136
	if (is_main_worktree(wt))
1137
		die(_("The main working tree cannot be locked or unlocked"));
1138
	if (!worktree_lock_reason(wt))
1139
		die(_("'%s' is not locked"), av[0]);
1140
	ret = unlink_or_warn(git_common_path("worktrees/%s/locked", wt->id));
1141
	free_worktrees(worktrees);
1142
	return ret;
1143
}
1144

1145
static void validate_no_submodules(const struct worktree *wt)
1146
{
1147
	struct index_state istate = INDEX_STATE_INIT(the_repository);
1148
	struct strbuf path = STRBUF_INIT;
1149
	int i, found_submodules = 0;
1150

1151
	if (is_directory(worktree_git_path(the_repository, wt, "modules"))) {
1152
		/*
1153
		 * There could be false positives, e.g. the "modules"
1154
		 * directory exists but is empty. But it's a rare case and
1155
		 * this simpler check is probably good enough for now.
1156
		 */
1157
		found_submodules = 1;
1158
	} else if (read_index_from(&istate, worktree_git_path(the_repository, wt, "index"),
1159
				   get_worktree_git_dir(wt)) > 0) {
1160
		for (i = 0; i < istate.cache_nr; i++) {
1161
			struct cache_entry *ce = istate.cache[i];
1162
			int err;
1163

1164
			if (!S_ISGITLINK(ce->ce_mode))
1165
				continue;
1166

1167
			strbuf_reset(&path);
1168
			strbuf_addf(&path, "%s/%s", wt->path, ce->name);
1169
			if (!is_submodule_populated_gently(path.buf, &err))
1170
				continue;
1171

1172
			found_submodules = 1;
1173
			break;
1174
		}
1175
	}
1176
	discard_index(&istate);
1177
	strbuf_release(&path);
1178

1179
	if (found_submodules)
1180
		die(_("working trees containing submodules cannot be moved or removed"));
1181
}
1182

1183
static int move_worktree(int ac, const char **av, const char *prefix)
1184
{
1185
	int force = 0;
1186
	struct option options[] = {
1187
		OPT__FORCE(&force,
1188
			 N_("force move even if worktree is dirty or locked"),
1189
			 PARSE_OPT_NOCOMPLETE),
1190
		OPT_END()
1191
	};
1192
	struct worktree **worktrees, *wt;
1193
	struct strbuf dst = STRBUF_INIT;
1194
	struct strbuf errmsg = STRBUF_INIT;
1195
	const char *reason = NULL;
1196
	char *path;
1197

1198
	ac = parse_options(ac, av, prefix, options, git_worktree_move_usage,
1199
			   0);
1200
	if (ac != 2)
1201
		usage_with_options(git_worktree_move_usage, options);
1202

1203
	path = prefix_filename(prefix, av[1]);
1204
	strbuf_addstr(&dst, path);
1205
	free(path);
1206

1207
	worktrees = get_worktrees();
1208
	wt = find_worktree(worktrees, prefix, av[0]);
1209
	if (!wt)
1210
		die(_("'%s' is not a working tree"), av[0]);
1211
	if (is_main_worktree(wt))
1212
		die(_("'%s' is a main working tree"), av[0]);
1213
	if (is_directory(dst.buf)) {
1214
		const char *sep = find_last_dir_sep(wt->path);
1215

1216
		if (!sep)
1217
			die(_("could not figure out destination name from '%s'"),
1218
			    wt->path);
1219
		strbuf_trim_trailing_dir_sep(&dst);
1220
		strbuf_addstr(&dst, sep);
1221
	}
1222
	check_candidate_path(dst.buf, force, worktrees, "move");
1223

1224
	validate_no_submodules(wt);
1225

1226
	if (force < 2)
1227
		reason = worktree_lock_reason(wt);
1228
	if (reason) {
1229
		if (*reason)
1230
			die(_("cannot move a locked working tree, lock reason: %s\nuse 'move -f -f' to override or unlock first"),
1231
			    reason);
1232
		die(_("cannot move a locked working tree;\nuse 'move -f -f' to override or unlock first"));
1233
	}
1234
	if (validate_worktree(wt, &errmsg, 0))
1235
		die(_("validation failed, cannot move working tree: %s"),
1236
		    errmsg.buf);
1237
	strbuf_release(&errmsg);
1238

1239
	if (rename(wt->path, dst.buf) == -1)
1240
		die_errno(_("failed to move '%s' to '%s'"), wt->path, dst.buf);
1241

1242
	update_worktree_location(wt, dst.buf);
1243

1244
	strbuf_release(&dst);
1245
	free_worktrees(worktrees);
1246
	return 0;
1247
}
1248

1249
/*
1250
 * Note, "git status --porcelain" is used to determine if it's safe to
1251
 * delete a whole worktree. "git status" does not ignore user
1252
 * configuration, so if a normal "git status" shows "clean" for the
1253
 * user, then it's ok to remove it.
1254
 *
1255
 * This assumption may be a bad one. We may want to ignore
1256
 * (potentially bad) user settings and only delete a worktree when
1257
 * it's absolutely safe to do so from _our_ point of view because we
1258
 * know better.
1259
 */
1260
static void check_clean_worktree(struct worktree *wt,
1261
				 const char *original_path)
1262
{
1263
	struct child_process cp;
1264
	char buf[1];
1265
	int ret;
1266

1267
	/*
1268
	 * Until we sort this out, all submodules are "dirty" and
1269
	 * will abort this function.
1270
	 */
1271
	validate_no_submodules(wt);
1272

1273
	child_process_init(&cp);
1274
	strvec_pushf(&cp.env, "%s=%s/.git",
1275
		     GIT_DIR_ENVIRONMENT, wt->path);
1276
	strvec_pushf(&cp.env, "%s=%s",
1277
		     GIT_WORK_TREE_ENVIRONMENT, wt->path);
1278
	strvec_pushl(&cp.args, "status",
1279
		     "--porcelain", "--ignore-submodules=none",
1280
		     NULL);
1281
	cp.git_cmd = 1;
1282
	cp.dir = wt->path;
1283
	cp.out = -1;
1284
	ret = start_command(&cp);
1285
	if (ret)
1286
		die_errno(_("failed to run 'git status' on '%s'"),
1287
			  original_path);
1288
	ret = xread(cp.out, buf, sizeof(buf));
1289
	if (ret)
1290
		die(_("'%s' contains modified or untracked files, use --force to delete it"),
1291
		    original_path);
1292
	close(cp.out);
1293
	ret = finish_command(&cp);
1294
	if (ret)
1295
		die_errno(_("failed to run 'git status' on '%s', code %d"),
1296
			  original_path, ret);
1297
}
1298

1299
static int delete_git_work_tree(struct worktree *wt)
1300
{
1301
	struct strbuf sb = STRBUF_INIT;
1302
	int ret = 0;
1303

1304
	strbuf_addstr(&sb, wt->path);
1305
	if (remove_dir_recursively(&sb, 0)) {
1306
		error_errno(_("failed to delete '%s'"), sb.buf);
1307
		ret = -1;
1308
	}
1309
	strbuf_release(&sb);
1310
	return ret;
1311
}
1312

1313
static int remove_worktree(int ac, const char **av, const char *prefix)
1314
{
1315
	int force = 0;
1316
	struct option options[] = {
1317
		OPT__FORCE(&force,
1318
			 N_("force removal even if worktree is dirty or locked"),
1319
			 PARSE_OPT_NOCOMPLETE),
1320
		OPT_END()
1321
	};
1322
	struct worktree **worktrees, *wt;
1323
	struct strbuf errmsg = STRBUF_INIT;
1324
	const char *reason = NULL;
1325
	int ret = 0;
1326

1327
	ac = parse_options(ac, av, prefix, options, git_worktree_remove_usage, 0);
1328
	if (ac != 1)
1329
		usage_with_options(git_worktree_remove_usage, options);
1330

1331
	worktrees = get_worktrees();
1332
	wt = find_worktree(worktrees, prefix, av[0]);
1333
	if (!wt)
1334
		die(_("'%s' is not a working tree"), av[0]);
1335
	if (is_main_worktree(wt))
1336
		die(_("'%s' is a main working tree"), av[0]);
1337
	if (force < 2)
1338
		reason = worktree_lock_reason(wt);
1339
	if (reason) {
1340
		if (*reason)
1341
			die(_("cannot remove a locked working tree, lock reason: %s\nuse 'remove -f -f' to override or unlock first"),
1342
			    reason);
1343
		die(_("cannot remove a locked working tree;\nuse 'remove -f -f' to override or unlock first"));
1344
	}
1345
	if (validate_worktree(wt, &errmsg, WT_VALIDATE_WORKTREE_MISSING_OK))
1346
		die(_("validation failed, cannot remove working tree: %s"),
1347
		    errmsg.buf);
1348
	strbuf_release(&errmsg);
1349

1350
	if (file_exists(wt->path)) {
1351
		if (!force)
1352
			check_clean_worktree(wt, av[0]);
1353

1354
		ret |= delete_git_work_tree(wt);
1355
	}
1356
	/*
1357
	 * continue on even if ret is non-zero, there's no going back
1358
	 * from here.
1359
	 */
1360
	ret |= delete_git_dir(wt->id);
1361
	delete_worktrees_dir_if_empty();
1362

1363
	free_worktrees(worktrees);
1364
	return ret;
1365
}
1366

1367
static void report_repair(int iserr, const char *path, const char *msg, void *cb_data)
1368
{
1369
	if (!iserr) {
1370
		fprintf_ln(stderr, _("repair: %s: %s"), msg, path);
1371
	} else {
1372
		int *exit_status = (int *)cb_data;
1373
		fprintf_ln(stderr, _("error: %s: %s"), msg, path);
1374
		*exit_status = 1;
1375
	}
1376
}
1377

1378
static int repair(int ac, const char **av, const char *prefix)
1379
{
1380
	const char **p;
1381
	const char *self[] = { ".", NULL };
1382
	struct option options[] = {
1383
		OPT_END()
1384
	};
1385
	int rc = 0;
1386

1387
	ac = parse_options(ac, av, prefix, options, git_worktree_repair_usage, 0);
1388
	p = ac > 0 ? av : self;
1389
	for (; *p; p++)
1390
		repair_worktree_at_path(*p, report_repair, &rc);
1391
	repair_worktrees(report_repair, &rc);
1392
	return rc;
1393
}
1394

1395
int cmd_worktree(int ac, const char **av, const char *prefix)
1396
{
1397
	parse_opt_subcommand_fn *fn = NULL;
1398
	struct option options[] = {
1399
		OPT_SUBCOMMAND("add", &fn, add),
1400
		OPT_SUBCOMMAND("prune", &fn, prune),
1401
		OPT_SUBCOMMAND("list", &fn, list),
1402
		OPT_SUBCOMMAND("lock", &fn, lock_worktree),
1403
		OPT_SUBCOMMAND("unlock", &fn, unlock_worktree),
1404
		OPT_SUBCOMMAND("move", &fn, move_worktree),
1405
		OPT_SUBCOMMAND("remove", &fn, remove_worktree),
1406
		OPT_SUBCOMMAND("repair", &fn, repair),
1407
		OPT_END()
1408
	};
1409

1410
	git_config(git_worktree_config, NULL);
1411

1412
	if (!prefix)
1413
		prefix = "";
1414

1415
	ac = parse_options(ac, av, prefix, options, git_worktree_usage, 0);
1416

1417
	prepare_repo_settings(the_repository);
1418
	the_repository->settings.command_requires_full_index = 0;
1419

1420
	return fn(ac, av, prefix);
1421
}
1422