git

1
/*
2
 * GIT - The information manager from hell
3
 *
4
 * Copyright (C) Linus Torvalds, 2005
5
 */
6

7
#include "builtin.h"
8
#include "bulk-checkin.h"
9
#include "config.h"
10
#include "environment.h"
11
#include "gettext.h"
12
#include "hash.h"
13
#include "hex.h"
14
#include "lockfile.h"
15
#include "quote.h"
16
#include "cache-tree.h"
17
#include "tree-walk.h"
18
#include "object-file.h"
19
#include "refs.h"
20
#include "resolve-undo.h"
21
#include "parse-options.h"
22
#include "pathspec.h"
23
#include "dir.h"
24
#include "read-cache.h"
25
#include "repository.h"
26
#include "setup.h"
27
#include "sparse-index.h"
28
#include "split-index.h"
29
#include "symlinks.h"
30
#include "fsmonitor.h"
31
#include "write-or-die.h"
32

33
/*
34
 * Default to not allowing changes to the list of files. The
35
 * tool doesn't actually care, but this makes it harder to add
36
 * files to the revision control by mistake by doing something
37
 * like "git update-index *" and suddenly having all the object
38
 * files be revision controlled.
39
 */
40
static int allow_add;
41
static int allow_remove;
42
static int allow_replace;
43
static int info_only;
44
static int force_remove;
45
static int verbose;
46
static int mark_valid_only;
47
static int mark_skip_worktree_only;
48
static int mark_fsmonitor_only;
49
static int ignore_skip_worktree_entries;
50
#define MARK_FLAG 1
51
#define UNMARK_FLAG 2
52
static struct strbuf mtime_dir = STRBUF_INIT;
53

54
/* Untracked cache mode */
55
enum uc_mode {
56
	UC_UNSPECIFIED = -1,
57
	UC_DISABLE = 0,
58
	UC_ENABLE,
59
	UC_TEST,
60
	UC_FORCE
61
};
62

63
__attribute__((format (printf, 1, 2)))
64
static void report(const char *fmt, ...)
65
{
66
	va_list vp;
67

68
	if (!verbose)
69
		return;
70

71
	/*
72
	 * It is possible, though unlikely, that a caller could use the verbose
73
	 * output to synchronize with addition of objects to the object
74
	 * database. The current implementation of ODB transactions leaves
75
	 * objects invisible while a transaction is active, so flush the
76
	 * transaction here before reporting a change made by update-index.
77
	 */
78
	flush_odb_transaction();
79
	va_start(vp, fmt);
80
	vprintf(fmt, vp);
81
	putchar('\n');
82
	va_end(vp);
83
}
84

85
static void remove_test_directory(void)
86
{
87
	if (mtime_dir.len)
88
		remove_dir_recursively(&mtime_dir, 0);
89
}
90

91
static const char *get_mtime_path(const char *path)
92
{
93
	static struct strbuf sb = STRBUF_INIT;
94
	strbuf_reset(&sb);
95
	strbuf_addf(&sb, "%s/%s", mtime_dir.buf, path);
96
	return sb.buf;
97
}
98

99
static void xmkdir(const char *path)
100
{
101
	path = get_mtime_path(path);
102
	if (mkdir(path, 0700))
103
		die_errno(_("failed to create directory %s"), path);
104
}
105

106
static int xstat_mtime_dir(struct stat *st)
107
{
108
	if (stat(mtime_dir.buf, st))
109
		die_errno(_("failed to stat %s"), mtime_dir.buf);
110
	return 0;
111
}
112

113
static int create_file(const char *path)
114
{
115
	int fd;
116
	path = get_mtime_path(path);
117
	fd = xopen(path, O_CREAT | O_RDWR, 0644);
118
	return fd;
119
}
120

121
static void xunlink(const char *path)
122
{
123
	path = get_mtime_path(path);
124
	if (unlink(path))
125
		die_errno(_("failed to delete file %s"), path);
126
}
127

128
static void xrmdir(const char *path)
129
{
130
	path = get_mtime_path(path);
131
	if (rmdir(path))
132
		die_errno(_("failed to delete directory %s"), path);
133
}
134

135
static void avoid_racy(void)
136
{
137
	/*
138
	 * not use if we could usleep(10) if USE_NSEC is defined. The
139
	 * field nsec could be there, but the OS could choose to
140
	 * ignore it?
141
	 */
142
	sleep(1);
143
}
144

145
static int test_if_untracked_cache_is_supported(void)
146
{
147
	struct stat st;
148
	struct stat_data base;
149
	int fd, ret = 0;
150
	char *cwd;
151

152
	strbuf_addstr(&mtime_dir, "mtime-test-XXXXXX");
153
	if (!mkdtemp(mtime_dir.buf))
154
		die_errno("Could not make temporary directory");
155

156
	cwd = xgetcwd();
157
	fprintf(stderr, _("Testing mtime in '%s' "), cwd);
158
	free(cwd);
159

160
	atexit(remove_test_directory);
161
	xstat_mtime_dir(&st);
162
	fill_stat_data(&base, &st);
163
	fputc('.', stderr);
164

165
	avoid_racy();
166
	fd = create_file("newfile");
167
	xstat_mtime_dir(&st);
168
	if (!match_stat_data(&base, &st)) {
169
		close(fd);
170
		fputc('\n', stderr);
171
		fprintf_ln(stderr,_("directory stat info does not "
172
				    "change after adding a new file"));
173
		goto done;
174
	}
175
	fill_stat_data(&base, &st);
176
	fputc('.', stderr);
177

178
	avoid_racy();
179
	xmkdir("new-dir");
180
	xstat_mtime_dir(&st);
181
	if (!match_stat_data(&base, &st)) {
182
		close(fd);
183
		fputc('\n', stderr);
184
		fprintf_ln(stderr, _("directory stat info does not change "
185
				     "after adding a new directory"));
186
		goto done;
187
	}
188
	fill_stat_data(&base, &st);
189
	fputc('.', stderr);
190

191
	avoid_racy();
192
	write_or_die(fd, "data", 4);
193
	close(fd);
194
	xstat_mtime_dir(&st);
195
	if (match_stat_data(&base, &st)) {
196
		fputc('\n', stderr);
197
		fprintf_ln(stderr, _("directory stat info changes "
198
				     "after updating a file"));
199
		goto done;
200
	}
201
	fputc('.', stderr);
202

203
	avoid_racy();
204
	close(create_file("new-dir/new"));
205
	xstat_mtime_dir(&st);
206
	if (match_stat_data(&base, &st)) {
207
		fputc('\n', stderr);
208
		fprintf_ln(stderr, _("directory stat info changes after "
209
				     "adding a file inside subdirectory"));
210
		goto done;
211
	}
212
	fputc('.', stderr);
213

214
	avoid_racy();
215
	xunlink("newfile");
216
	xstat_mtime_dir(&st);
217
	if (!match_stat_data(&base, &st)) {
218
		fputc('\n', stderr);
219
		fprintf_ln(stderr, _("directory stat info does not "
220
				     "change after deleting a file"));
221
		goto done;
222
	}
223
	fill_stat_data(&base, &st);
224
	fputc('.', stderr);
225

226
	avoid_racy();
227
	xunlink("new-dir/new");
228
	xrmdir("new-dir");
229
	xstat_mtime_dir(&st);
230
	if (!match_stat_data(&base, &st)) {
231
		fputc('\n', stderr);
232
		fprintf_ln(stderr, _("directory stat info does not "
233
				     "change after deleting a directory"));
234
		goto done;
235
	}
236

237
	if (rmdir(mtime_dir.buf))
238
		die_errno(_("failed to delete directory %s"), mtime_dir.buf);
239
	fprintf_ln(stderr, _(" OK"));
240
	ret = 1;
241

242
done:
243
	strbuf_release(&mtime_dir);
244
	return ret;
245
}
246

247
static int mark_ce_flags(const char *path, int flag, int mark)
248
{
249
	int namelen = strlen(path);
250
	int pos = index_name_pos(the_repository->index, path, namelen);
251
	if (0 <= pos) {
252
		mark_fsmonitor_invalid(the_repository->index, the_repository->index->cache[pos]);
253
		if (mark)
254
			the_repository->index->cache[pos]->ce_flags |= flag;
255
		else
256
			the_repository->index->cache[pos]->ce_flags &= ~flag;
257
		the_repository->index->cache[pos]->ce_flags |= CE_UPDATE_IN_BASE;
258
		cache_tree_invalidate_path(the_repository->index, path);
259
		the_repository->index->cache_changed |= CE_ENTRY_CHANGED;
260
		return 0;
261
	}
262
	return -1;
263
}
264

265
static int remove_one_path(const char *path)
266
{
267
	if (!allow_remove)
268
		return error("%s: does not exist and --remove not passed", path);
269
	if (remove_file_from_index(the_repository->index, path))
270
		return error("%s: cannot remove from the index", path);
271
	return 0;
272
}
273

274
/*
275
 * Handle a path that couldn't be lstat'ed. It's either:
276
 *  - missing file (ENOENT or ENOTDIR). That's ok if we're
277
 *    supposed to be removing it and the removal actually
278
 *    succeeds.
279
 *  - permission error. That's never ok.
280
 */
281
static int process_lstat_error(const char *path, int err)
282
{
283
	if (is_missing_file_error(err))
284
		return remove_one_path(path);
285
	return error("lstat(\"%s\"): %s", path, strerror(err));
286
}
287

288
static int add_one_path(const struct cache_entry *old, const char *path, int len, struct stat *st)
289
{
290
	int option;
291
	struct cache_entry *ce;
292

293
	/* Was the old index entry already up-to-date? */
294
	if (old && !ce_stage(old) && !ie_match_stat(the_repository->index, old, st, 0))
295
		return 0;
296

297
	ce = make_empty_cache_entry(the_repository->index, len);
298
	memcpy(ce->name, path, len);
299
	ce->ce_flags = create_ce_flags(0);
300
	ce->ce_namelen = len;
301
	fill_stat_cache_info(the_repository->index, ce, st);
302
	ce->ce_mode = ce_mode_from_stat(old, st->st_mode);
303

304
	if (index_path(the_repository->index, &ce->oid, path, st,
305
		       info_only ? 0 : HASH_WRITE_OBJECT)) {
306
		discard_cache_entry(ce);
307
		return -1;
308
	}
309
	option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
310
	option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
311
	if (add_index_entry(the_repository->index, ce, option)) {
312
		discard_cache_entry(ce);
313
		return error("%s: cannot add to the index - missing --add option?", path);
314
	}
315
	return 0;
316
}
317

318
/*
319
 * Handle a path that was a directory. Four cases:
320
 *
321
 *  - it's already a gitlink in the index, and we keep it that
322
 *    way, and update it if we can (if we cannot find the HEAD,
323
 *    we're going to keep it unchanged in the index!)
324
 *
325
 *  - it's a *file* in the index, in which case it should be
326
 *    removed as a file if removal is allowed, since it doesn't
327
 *    exist as such any more. If removal isn't allowed, it's
328
 *    an error.
329
 *
330
 *    (NOTE! This is old and arguably fairly strange behaviour.
331
 *    We might want to make this an error unconditionally, and
332
 *    use "--force-remove" if you actually want to force removal).
333
 *
334
 *  - it used to exist as a subdirectory (ie multiple files with
335
 *    this particular prefix) in the index, in which case it's wrong
336
 *    to try to update it as a directory.
337
 *
338
 *  - it doesn't exist at all in the index, but it is a valid
339
 *    git directory, and it should be *added* as a gitlink.
340
 */
341
static int process_directory(const char *path, int len, struct stat *st)
342
{
343
	struct object_id oid;
344
	int pos = index_name_pos(the_repository->index, path, len);
345

346
	/* Exact match: file or existing gitlink */
347
	if (pos >= 0) {
348
		const struct cache_entry *ce = the_repository->index->cache[pos];
349
		if (S_ISGITLINK(ce->ce_mode)) {
350

351
			/* Do nothing to the index if there is no HEAD! */
352
			if (repo_resolve_gitlink_ref(the_repository, path,
353
						     "HEAD", &oid) < 0)
354
				return 0;
355

356
			return add_one_path(ce, path, len, st);
357
		}
358
		/* Should this be an unconditional error? */
359
		return remove_one_path(path);
360
	}
361

362
	/* Inexact match: is there perhaps a subdirectory match? */
363
	pos = -pos-1;
364
	while (pos < the_repository->index->cache_nr) {
365
		const struct cache_entry *ce = the_repository->index->cache[pos++];
366

367
		if (strncmp(ce->name, path, len))
368
			break;
369
		if (ce->name[len] > '/')
370
			break;
371
		if (ce->name[len] < '/')
372
			continue;
373

374
		/* Subdirectory match - error out */
375
		return error("%s: is a directory - add individual files instead", path);
376
	}
377

378
	/* No match - should we add it as a gitlink? */
379
	if (!repo_resolve_gitlink_ref(the_repository, path, "HEAD", &oid))
380
		return add_one_path(NULL, path, len, st);
381

382
	/* Error out. */
383
	return error("%s: is a directory - add files inside instead", path);
384
}
385

386
static int process_path(const char *path, struct stat *st, int stat_errno)
387
{
388
	int pos, len;
389
	const struct cache_entry *ce;
390

391
	len = strlen(path);
392
	if (has_symlink_leading_path(path, len))
393
		return error("'%s' is beyond a symbolic link", path);
394

395
	pos = index_name_pos(the_repository->index, path, len);
396
	ce = pos < 0 ? NULL : the_repository->index->cache[pos];
397
	if (ce && ce_skip_worktree(ce)) {
398
		/*
399
		 * working directory version is assumed "good"
400
		 * so updating it does not make sense.
401
		 * On the other hand, removing it from index should work
402
		 */
403
		if (!ignore_skip_worktree_entries && allow_remove &&
404
		    remove_file_from_index(the_repository->index, path))
405
			return error("%s: cannot remove from the index", path);
406
		return 0;
407
	}
408

409
	/*
410
	 * First things first: get the stat information, to decide
411
	 * what to do about the pathname!
412
	 */
413
	if (stat_errno)
414
		return process_lstat_error(path, stat_errno);
415

416
	if (S_ISDIR(st->st_mode))
417
		return process_directory(path, len, st);
418

419
	return add_one_path(ce, path, len, st);
420
}
421

422
static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
423
			 const char *path, int stage)
424
{
425
	int len, option;
426
	struct cache_entry *ce;
427

428
	if (!verify_path(path, mode))
429
		return error("Invalid path '%s'", path);
430

431
	len = strlen(path);
432
	ce = make_empty_cache_entry(the_repository->index, len);
433

434
	oidcpy(&ce->oid, oid);
435
	memcpy(ce->name, path, len);
436
	ce->ce_flags = create_ce_flags(stage);
437
	ce->ce_namelen = len;
438
	ce->ce_mode = create_ce_mode(mode);
439
	if (assume_unchanged)
440
		ce->ce_flags |= CE_VALID;
441
	option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
442
	option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
443
	if (add_index_entry(the_repository->index, ce, option))
444
		return error("%s: cannot add to the index - missing --add option?",
445
			     path);
446
	report("add '%s'", path);
447
	return 0;
448
}
449

450
static void chmod_path(char flip, const char *path)
451
{
452
	int pos;
453
	struct cache_entry *ce;
454

455
	pos = index_name_pos(the_repository->index, path, strlen(path));
456
	if (pos < 0)
457
		goto fail;
458
	ce = the_repository->index->cache[pos];
459
	if (chmod_index_entry(the_repository->index, ce, flip) < 0)
460
		goto fail;
461

462
	report("chmod %cx '%s'", flip, path);
463
	return;
464
 fail:
465
	die("git update-index: cannot chmod %cx '%s'", flip, path);
466
}
467

468
static void update_one(const char *path)
469
{
470
	int stat_errno = 0;
471
	struct stat st;
472

473
	if (mark_valid_only || mark_skip_worktree_only || force_remove ||
474
	    mark_fsmonitor_only)
475
		st.st_mode = 0;
476
	else if (lstat(path, &st) < 0) {
477
		st.st_mode = 0;
478
		stat_errno = errno;
479
	} /* else stat is valid */
480

481
	if (!verify_path(path, st.st_mode)) {
482
		fprintf(stderr, "Ignoring path %s\n", path);
483
		return;
484
	}
485
	if (mark_valid_only) {
486
		if (mark_ce_flags(path, CE_VALID, mark_valid_only == MARK_FLAG))
487
			die("Unable to mark file %s", path);
488
		return;
489
	}
490
	if (mark_skip_worktree_only) {
491
		if (mark_ce_flags(path, CE_SKIP_WORKTREE, mark_skip_worktree_only == MARK_FLAG))
492
			die("Unable to mark file %s", path);
493
		return;
494
	}
495
	if (mark_fsmonitor_only) {
496
		if (mark_ce_flags(path, CE_FSMONITOR_VALID, mark_fsmonitor_only == MARK_FLAG))
497
			die("Unable to mark file %s", path);
498
		return;
499
	}
500

501
	if (force_remove) {
502
		if (remove_file_from_index(the_repository->index, path))
503
			die("git update-index: unable to remove %s", path);
504
		report("remove '%s'", path);
505
		return;
506
	}
507
	if (process_path(path, &st, stat_errno))
508
		die("Unable to process path %s", path);
509
	report("add '%s'", path);
510
}
511

512
static void read_index_info(int nul_term_line)
513
{
514
	const int hexsz = the_hash_algo->hexsz;
515
	struct strbuf buf = STRBUF_INIT;
516
	struct strbuf uq = STRBUF_INIT;
517
	strbuf_getline_fn getline_fn;
518

519
	getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
520
	while (getline_fn(&buf, stdin) != EOF) {
521
		char *ptr, *tab;
522
		char *path_name;
523
		struct object_id oid;
524
		unsigned int mode;
525
		unsigned long ul;
526
		int stage;
527

528
		/* This reads lines formatted in one of three formats:
529
		 *
530
		 * (1) mode         SP sha1          TAB path
531
		 * The first format is what "git apply --index-info"
532
		 * reports, and used to reconstruct a partial tree
533
		 * that is used for phony merge base tree when falling
534
		 * back on 3-way merge.
535
		 *
536
		 * (2) mode SP type SP sha1          TAB path
537
		 * The second format is to stuff "git ls-tree" output
538
		 * into the index file.
539
		 *
540
		 * (3) mode         SP sha1 SP stage TAB path
541
		 * This format is to put higher order stages into the
542
		 * index file and matches "git ls-files --stage" output.
543
		 */
544
		errno = 0;
545
		ul = strtoul(buf.buf, &ptr, 8);
546
		if (ptr == buf.buf || *ptr != ' '
547
		    || errno || (unsigned int) ul != ul)
548
			goto bad_line;
549
		mode = ul;
550

551
		tab = strchr(ptr, '\t');
552
		if (!tab || tab - ptr < hexsz + 1)
553
			goto bad_line;
554

555
		if (tab[-2] == ' ' && '0' <= tab[-1] && tab[-1] <= '3') {
556
			stage = tab[-1] - '0';
557
			ptr = tab + 1; /* point at the head of path */
558
			tab = tab - 2; /* point at tail of sha1 */
559
		}
560
		else {
561
			stage = 0;
562
			ptr = tab + 1; /* point at the head of path */
563
		}
564

565
		if (get_oid_hex(tab - hexsz, &oid) ||
566
			tab[-(hexsz + 1)] != ' ')
567
			goto bad_line;
568

569
		path_name = ptr;
570
		if (!nul_term_line && path_name[0] == '"') {
571
			strbuf_reset(&uq);
572
			if (unquote_c_style(&uq, path_name, NULL)) {
573
				die("git update-index: bad quoting of path name");
574
			}
575
			path_name = uq.buf;
576
		}
577

578
		if (!verify_path(path_name, mode)) {
579
			fprintf(stderr, "Ignoring path %s\n", path_name);
580
			continue;
581
		}
582

583
		if (!mode) {
584
			/* mode == 0 means there is no such path -- remove */
585
			if (remove_file_from_index(the_repository->index, path_name))
586
				die("git update-index: unable to remove %s",
587
				    ptr);
588
		}
589
		else {
590
			/* mode ' ' sha1 '\t' name
591
			 * ptr[-1] points at tab,
592
			 * ptr[-41] is at the beginning of sha1
593
			 */
594
			ptr[-(hexsz + 2)] = ptr[-1] = 0;
595
			if (add_cacheinfo(mode, &oid, path_name, stage))
596
				die("git update-index: unable to update %s",
597
				    path_name);
598
		}
599
		continue;
600

601
	bad_line:
602
		die("malformed index info %s", buf.buf);
603
	}
604
	strbuf_release(&buf);
605
	strbuf_release(&uq);
606
}
607

608
static const char * const update_index_usage[] = {
609
	N_("git update-index [<options>] [--] [<file>...]"),
610
	NULL
611
};
612

613
static struct cache_entry *read_one_ent(const char *which,
614
					struct object_id *ent, const char *path,
615
					int namelen, int stage)
616
{
617
	unsigned short mode;
618
	struct object_id oid;
619
	struct cache_entry *ce;
620

621
	if (get_tree_entry(the_repository, ent, path, &oid, &mode)) {
622
		if (which)
623
			error("%s: not in %s branch.", path, which);
624
		return NULL;
625
	}
626
	if (!the_repository->index->sparse_index && mode == S_IFDIR) {
627
		if (which)
628
			error("%s: not a blob in %s branch.", path, which);
629
		return NULL;
630
	}
631
	ce = make_empty_cache_entry(the_repository->index, namelen);
632

633
	oidcpy(&ce->oid, &oid);
634
	memcpy(ce->name, path, namelen);
635
	ce->ce_flags = create_ce_flags(stage);
636
	ce->ce_namelen = namelen;
637
	ce->ce_mode = create_ce_mode(mode);
638
	return ce;
639
}
640

641
static int unresolve_one(const char *path)
642
{
643
	struct string_list_item *item;
644
	int res = 0;
645

646
	if (!the_repository->index->resolve_undo)
647
		return res;
648
	item = string_list_lookup(the_repository->index->resolve_undo, path);
649
	if (!item)
650
		return res; /* no resolve-undo record for the path */
651
	res = unmerge_index_entry(the_repository->index, path, item->util, 0);
652
	FREE_AND_NULL(item->util);
653
	return res;
654
}
655

656
static int do_unresolve(int ac, const char **av,
657
			const char *prefix, int prefix_length)
658
{
659
	int i;
660
	int err = 0;
661

662
	for (i = 1; i < ac; i++) {
663
		const char *arg = av[i];
664
		char *p = prefix_path(prefix, prefix_length, arg);
665
		err |= unresolve_one(p);
666
		free(p);
667
	}
668
	return err;
669
}
670

671
static int do_reupdate(const char **paths,
672
		       const char *prefix)
673
{
674
	/* Read HEAD and run update-index on paths that are
675
	 * merged and already different between index and HEAD.
676
	 */
677
	int pos;
678
	int has_head = 1;
679
	struct pathspec pathspec;
680
	struct object_id head_oid;
681

682
	parse_pathspec(&pathspec, 0,
683
		       PATHSPEC_PREFER_CWD,
684
		       prefix, paths);
685

686
	if (refs_read_ref(get_main_ref_store(the_repository), "HEAD", &head_oid))
687
		/* If there is no HEAD, that means it is an initial
688
		 * commit.  Update everything in the index.
689
		 */
690
		has_head = 0;
691
 redo:
692
	for (pos = 0; pos < the_repository->index->cache_nr; pos++) {
693
		const struct cache_entry *ce = the_repository->index->cache[pos];
694
		struct cache_entry *old = NULL;
695
		int save_nr;
696
		char *path;
697

698
		if (ce_stage(ce) || !ce_path_match(the_repository->index, ce, &pathspec, NULL))
699
			continue;
700
		if (has_head)
701
			old = read_one_ent(NULL, &head_oid,
702
					   ce->name, ce_namelen(ce), 0);
703
		if (old && ce->ce_mode == old->ce_mode &&
704
		    oideq(&ce->oid, &old->oid)) {
705
			discard_cache_entry(old);
706
			continue; /* unchanged */
707
		}
708

709
		/* At this point, we know the contents of the sparse directory are
710
		 * modified with respect to HEAD, so we expand the index and restart
711
		 * to process each path individually
712
		 */
713
		if (S_ISSPARSEDIR(ce->ce_mode)) {
714
			ensure_full_index(the_repository->index);
715
			goto redo;
716
		}
717

718
		/* Be careful.  The working tree may not have the
719
		 * path anymore, in which case, under 'allow_remove',
720
		 * or worse yet 'allow_replace', active_nr may decrease.
721
		 */
722
		save_nr = the_repository->index->cache_nr;
723
		path = xstrdup(ce->name);
724
		update_one(path);
725
		free(path);
726
		discard_cache_entry(old);
727
		if (save_nr != the_repository->index->cache_nr)
728
			goto redo;
729
	}
730
	clear_pathspec(&pathspec);
731
	return 0;
732
}
733

734
struct refresh_params {
735
	unsigned int flags;
736
	int *has_errors;
737
};
738

739
static int refresh(struct refresh_params *o, unsigned int flag)
740
{
741
	setup_work_tree();
742
	repo_read_index(the_repository);
743
	*o->has_errors |= refresh_index(the_repository->index, o->flags | flag, NULL,
744
					NULL, NULL);
745
	if (has_racy_timestamp(the_repository->index)) {
746
		/*
747
		 * Even if nothing else has changed, updating the file
748
		 * increases the chance that racy timestamps become
749
		 * non-racy, helping future run-time performance.
750
		 * We do that even in case of "errors" returned by
751
		 * refresh_index() as these are no actual errors.
752
		 * cmd_status() does the same.
753
		 */
754
		the_repository->index->cache_changed |= SOMETHING_CHANGED;
755
	}
756
	return 0;
757
}
758

759
static int refresh_callback(const struct option *opt,
760
				const char *arg, int unset)
761
{
762
	BUG_ON_OPT_NEG(unset);
763
	BUG_ON_OPT_ARG(arg);
764
	return refresh(opt->value, 0);
765
}
766

767
static int really_refresh_callback(const struct option *opt,
768
				const char *arg, int unset)
769
{
770
	BUG_ON_OPT_NEG(unset);
771
	BUG_ON_OPT_ARG(arg);
772
	return refresh(opt->value, REFRESH_REALLY);
773
}
774

775
static int chmod_callback(const struct option *opt,
776
				const char *arg, int unset)
777
{
778
	char *flip = opt->value;
779
	BUG_ON_OPT_NEG(unset);
780
	if ((arg[0] != '-' && arg[0] != '+') || arg[1] != 'x' || arg[2])
781
		return error("option 'chmod' expects \"+x\" or \"-x\"");
782
	*flip = arg[0];
783
	return 0;
784
}
785

786
static int resolve_undo_clear_callback(const struct option *opt UNUSED,
787
				const char *arg, int unset)
788
{
789
	BUG_ON_OPT_NEG(unset);
790
	BUG_ON_OPT_ARG(arg);
791
	resolve_undo_clear_index(the_repository->index);
792
	return 0;
793
}
794

795
static int parse_new_style_cacheinfo(const char *arg,
796
				     unsigned int *mode,
797
				     struct object_id *oid,
798
				     const char **path)
799
{
800
	unsigned long ul;
801
	char *endp;
802
	const char *p;
803

804
	if (!arg)
805
		return -1;
806

807
	errno = 0;
808
	ul = strtoul(arg, &endp, 8);
809
	if (errno || endp == arg || *endp != ',' || (unsigned int) ul != ul)
810
		return -1; /* not a new-style cacheinfo */
811
	*mode = ul;
812
	endp++;
813
	if (parse_oid_hex(endp, oid, &p) || *p != ',')
814
		return -1;
815
	*path = p + 1;
816
	return 0;
817
}
818

819
static enum parse_opt_result cacheinfo_callback(
820
	struct parse_opt_ctx_t *ctx, const struct option *opt UNUSED,
821
	const char *arg, int unset)
822
{
823
	struct object_id oid;
824
	unsigned int mode;
825
	const char *path;
826

827
	BUG_ON_OPT_NEG(unset);
828
	BUG_ON_OPT_ARG(arg);
829

830
	if (!parse_new_style_cacheinfo(ctx->argv[1], &mode, &oid, &path)) {
831
		if (add_cacheinfo(mode, &oid, path, 0))
832
			die("git update-index: --cacheinfo cannot add %s", path);
833
		ctx->argv++;
834
		ctx->argc--;
835
		return 0;
836
	}
837
	if (ctx->argc <= 3)
838
		return error("option 'cacheinfo' expects <mode>,<sha1>,<path>");
839
	if (strtoul_ui(*++ctx->argv, 8, &mode) ||
840
	    get_oid_hex(*++ctx->argv, &oid) ||
841
	    add_cacheinfo(mode, &oid, *++ctx->argv, 0))
842
		die("git update-index: --cacheinfo cannot add %s", *ctx->argv);
843
	ctx->argc -= 3;
844
	return 0;
845
}
846

847
static enum parse_opt_result stdin_cacheinfo_callback(
848
	struct parse_opt_ctx_t *ctx, const struct option *opt,
849
	const char *arg, int unset)
850
{
851
	int *nul_term_line = opt->value;
852

853
	BUG_ON_OPT_NEG(unset);
854
	BUG_ON_OPT_ARG(arg);
855

856
	if (ctx->argc != 1)
857
		return error("option '%s' must be the last argument", opt->long_name);
858
	allow_add = allow_replace = allow_remove = 1;
859
	read_index_info(*nul_term_line);
860
	return 0;
861
}
862

863
static enum parse_opt_result stdin_callback(
864
	struct parse_opt_ctx_t *ctx, const struct option *opt,
865
	const char *arg, int unset)
866
{
867
	int *read_from_stdin = opt->value;
868

869
	BUG_ON_OPT_NEG(unset);
870
	BUG_ON_OPT_ARG(arg);
871

872
	if (ctx->argc != 1)
873
		return error("option '%s' must be the last argument", opt->long_name);
874
	*read_from_stdin = 1;
875
	return 0;
876
}
877

878
static enum parse_opt_result unresolve_callback(
879
	struct parse_opt_ctx_t *ctx, const struct option *opt,
880
	const char *arg, int unset)
881
{
882
	int *has_errors = opt->value;
883
	const char *prefix = startup_info->prefix;
884

885
	BUG_ON_OPT_NEG(unset);
886
	BUG_ON_OPT_ARG(arg);
887

888
	/* consume remaining arguments. */
889
	*has_errors = do_unresolve(ctx->argc, ctx->argv,
890
				prefix, prefix ? strlen(prefix) : 0);
891
	if (*has_errors)
892
		the_repository->index->cache_changed = 0;
893

894
	ctx->argv += ctx->argc - 1;
895
	ctx->argc = 1;
896
	return 0;
897
}
898

899
static enum parse_opt_result reupdate_callback(
900
	struct parse_opt_ctx_t *ctx, const struct option *opt,
901
	const char *arg, int unset)
902
{
903
	int *has_errors = opt->value;
904
	const char *prefix = startup_info->prefix;
905

906
	BUG_ON_OPT_NEG(unset);
907
	BUG_ON_OPT_ARG(arg);
908

909
	/* consume remaining arguments. */
910
	setup_work_tree();
911
	*has_errors = do_reupdate(ctx->argv + 1, prefix);
912
	if (*has_errors)
913
		the_repository->index->cache_changed = 0;
914

915
	ctx->argv += ctx->argc - 1;
916
	ctx->argc = 1;
917
	return 0;
918
}
919

920
int cmd_update_index(int argc, const char **argv, const char *prefix)
921
{
922
	int newfd, entries, has_errors = 0, nul_term_line = 0;
923
	enum uc_mode untracked_cache = UC_UNSPECIFIED;
924
	int read_from_stdin = 0;
925
	int prefix_length = prefix ? strlen(prefix) : 0;
926
	int preferred_index_format = 0;
927
	char set_executable_bit = 0;
928
	struct refresh_params refresh_args = {0, &has_errors};
929
	int lock_error = 0;
930
	int split_index = -1;
931
	int force_write = 0;
932
	int fsmonitor = -1;
933
	struct lock_file lock_file = LOCK_INIT;
934
	struct parse_opt_ctx_t ctx;
935
	strbuf_getline_fn getline_fn;
936
	int parseopt_state = PARSE_OPT_UNKNOWN;
937
	struct repository *r = the_repository;
938
	struct option options[] = {
939
		OPT_BIT('q', NULL, &refresh_args.flags,
940
			N_("continue refresh even when index needs update"),
941
			REFRESH_QUIET),
942
		OPT_BIT(0, "ignore-submodules", &refresh_args.flags,
943
			N_("refresh: ignore submodules"),
944
			REFRESH_IGNORE_SUBMODULES),
945
		OPT_SET_INT(0, "add", &allow_add,
946
			N_("do not ignore new files"), 1),
947
		OPT_SET_INT(0, "replace", &allow_replace,
948
			N_("let files replace directories and vice-versa"), 1),
949
		OPT_SET_INT(0, "remove", &allow_remove,
950
			N_("notice files missing from worktree"), 1),
951
		OPT_BIT(0, "unmerged", &refresh_args.flags,
952
			N_("refresh even if index contains unmerged entries"),
953
			REFRESH_UNMERGED),
954
		OPT_CALLBACK_F(0, "refresh", &refresh_args, NULL,
955
			N_("refresh stat information"),
956
			PARSE_OPT_NOARG | PARSE_OPT_NONEG,
957
			refresh_callback),
958
		OPT_CALLBACK_F(0, "really-refresh", &refresh_args, NULL,
959
			N_("like --refresh, but ignore assume-unchanged setting"),
960
			PARSE_OPT_NOARG | PARSE_OPT_NONEG,
961
			really_refresh_callback),
962
		{OPTION_LOWLEVEL_CALLBACK, 0, "cacheinfo", NULL,
963
			N_("<mode>,<object>,<path>"),
964
			N_("add the specified entry to the index"),
965
			PARSE_OPT_NOARG | /* disallow --cacheinfo=<mode> form */
966
			PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
967
			NULL, 0,
968
			cacheinfo_callback},
969
		OPT_CALLBACK_F(0, "chmod", &set_executable_bit, "(+|-)x",
970
			N_("override the executable bit of the listed files"),
971
			PARSE_OPT_NONEG,
972
			chmod_callback),
973
		{OPTION_SET_INT, 0, "assume-unchanged", &mark_valid_only, NULL,
974
			N_("mark files as \"not changing\""),
975
			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
976
		{OPTION_SET_INT, 0, "no-assume-unchanged", &mark_valid_only, NULL,
977
			N_("clear assumed-unchanged bit"),
978
			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
979
		{OPTION_SET_INT, 0, "skip-worktree", &mark_skip_worktree_only, NULL,
980
			N_("mark files as \"index-only\""),
981
			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
982
		{OPTION_SET_INT, 0, "no-skip-worktree", &mark_skip_worktree_only, NULL,
983
			N_("clear skip-worktree bit"),
984
			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
985
		OPT_BOOL(0, "ignore-skip-worktree-entries", &ignore_skip_worktree_entries,
986
			 N_("do not touch index-only entries")),
987
		OPT_SET_INT(0, "info-only", &info_only,
988
			N_("add to index only; do not add content to object database"), 1),
989
		OPT_SET_INT(0, "force-remove", &force_remove,
990
			N_("remove named paths even if present in worktree"), 1),
991
		OPT_BOOL('z', NULL, &nul_term_line,
992
			 N_("with --stdin: input lines are terminated by null bytes")),
993
		{OPTION_LOWLEVEL_CALLBACK, 0, "stdin", &read_from_stdin, NULL,
994
			N_("read list of paths to be updated from standard input"),
995
			PARSE_OPT_NONEG | PARSE_OPT_NOARG,
996
			NULL, 0, stdin_callback},
997
		{OPTION_LOWLEVEL_CALLBACK, 0, "index-info", &nul_term_line, NULL,
998
			N_("add entries from standard input to the index"),
999
			PARSE_OPT_NONEG | PARSE_OPT_NOARG,
1000
			NULL, 0, stdin_cacheinfo_callback},
1001
		{OPTION_LOWLEVEL_CALLBACK, 0, "unresolve", &has_errors, NULL,
1002
			N_("repopulate stages #2 and #3 for the listed paths"),
1003
			PARSE_OPT_NONEG | PARSE_OPT_NOARG,
1004
			NULL, 0, unresolve_callback},
1005
		{OPTION_LOWLEVEL_CALLBACK, 'g', "again", &has_errors, NULL,
1006
			N_("only update entries that differ from HEAD"),
1007
			PARSE_OPT_NONEG | PARSE_OPT_NOARG,
1008
			NULL, 0, reupdate_callback},
1009
		OPT_BIT(0, "ignore-missing", &refresh_args.flags,
1010
			N_("ignore files missing from worktree"),
1011
			REFRESH_IGNORE_MISSING),
1012
		OPT_SET_INT(0, "verbose", &verbose,
1013
			N_("report actions to standard output"), 1),
1014
		OPT_CALLBACK_F(0, "clear-resolve-undo", NULL, NULL,
1015
			N_("(for porcelains) forget saved unresolved conflicts"),
1016
			PARSE_OPT_NOARG | PARSE_OPT_NONEG,
1017
			resolve_undo_clear_callback),
1018
		OPT_INTEGER(0, "index-version", &preferred_index_format,
1019
			N_("write index in this format")),
1020
		OPT_SET_INT(0, "show-index-version", &preferred_index_format,
1021
			    N_("report on-disk index format version"), -1),
1022
		OPT_BOOL(0, "split-index", &split_index,
1023
			N_("enable or disable split index")),
1024
		OPT_BOOL(0, "untracked-cache", &untracked_cache,
1025
			N_("enable/disable untracked cache")),
1026
		OPT_SET_INT(0, "test-untracked-cache", &untracked_cache,
1027
			    N_("test if the filesystem supports untracked cache"), UC_TEST),
1028
		OPT_SET_INT(0, "force-untracked-cache", &untracked_cache,
1029
			    N_("enable untracked cache without testing the filesystem"), UC_FORCE),
1030
		OPT_SET_INT(0, "force-write-index", &force_write,
1031
			N_("write out the index even if is not flagged as changed"), 1),
1032
		OPT_BOOL(0, "fsmonitor", &fsmonitor,
1033
			N_("enable or disable file system monitor")),
1034
		{OPTION_SET_INT, 0, "fsmonitor-valid", &mark_fsmonitor_only, NULL,
1035
			N_("mark files as fsmonitor valid"),
1036
			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
1037
		{OPTION_SET_INT, 0, "no-fsmonitor-valid", &mark_fsmonitor_only, NULL,
1038
			N_("clear fsmonitor valid bit"),
1039
			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
1040
		OPT_END()
1041
	};
1042

1043
	if (argc == 2 && !strcmp(argv[1], "-h"))
1044
		usage_with_options(update_index_usage, options);
1045

1046
	git_config(git_default_config, NULL);
1047

1048
	prepare_repo_settings(r);
1049
	the_repository->settings.command_requires_full_index = 0;
1050

1051
	/* we will diagnose later if it turns out that we need to update it */
1052
	newfd = repo_hold_locked_index(the_repository, &lock_file, 0);
1053
	if (newfd < 0)
1054
		lock_error = errno;
1055

1056
	entries = repo_read_index(the_repository);
1057
	if (entries < 0)
1058
		die("cache corrupted");
1059

1060
	the_repository->index->updated_skipworktree = 1;
1061

1062
	/*
1063
	 * Custom copy of parse_options() because we want to handle
1064
	 * filename arguments as they come.
1065
	 */
1066
	parse_options_start(&ctx, argc, argv, prefix,
1067
			    options, PARSE_OPT_STOP_AT_NON_OPTION);
1068

1069
	/*
1070
	 * Allow the object layer to optimize adding multiple objects in
1071
	 * a batch.
1072
	 */
1073
	begin_odb_transaction();
1074
	while (ctx.argc) {
1075
		if (parseopt_state != PARSE_OPT_DONE)
1076
			parseopt_state = parse_options_step(&ctx, options,
1077
							    update_index_usage);
1078
		if (!ctx.argc)
1079
			break;
1080
		switch (parseopt_state) {
1081
		case PARSE_OPT_HELP:
1082
		case PARSE_OPT_ERROR:
1083
			exit(129);
1084
		case PARSE_OPT_COMPLETE:
1085
			exit(0);
1086
		case PARSE_OPT_NON_OPTION:
1087
		case PARSE_OPT_DONE:
1088
		{
1089
			const char *path = ctx.argv[0];
1090
			char *p;
1091

1092
			setup_work_tree();
1093
			p = prefix_path(prefix, prefix_length, path);
1094
			update_one(p);
1095
			if (set_executable_bit)
1096
				chmod_path(set_executable_bit, p);
1097
			free(p);
1098
			ctx.argc--;
1099
			ctx.argv++;
1100
			break;
1101
		}
1102
		case PARSE_OPT_UNKNOWN:
1103
			if (ctx.argv[0][1] == '-')
1104
				error("unknown option '%s'", ctx.argv[0] + 2);
1105
			else
1106
				error("unknown switch '%c'", *ctx.opt);
1107
			usage_with_options(update_index_usage, options);
1108
		}
1109
	}
1110
	argc = parse_options_end(&ctx);
1111

1112
	getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
1113
	if (preferred_index_format) {
1114
		if (preferred_index_format < 0) {
1115
			printf(_("%d\n"), the_repository->index->version);
1116
		} else if (preferred_index_format < INDEX_FORMAT_LB ||
1117
			   INDEX_FORMAT_UB < preferred_index_format) {
1118
			die("index-version %d not in range: %d..%d",
1119
			    preferred_index_format,
1120
			    INDEX_FORMAT_LB, INDEX_FORMAT_UB);
1121
		} else {
1122
			if (the_repository->index->version != preferred_index_format)
1123
				the_repository->index->cache_changed |= SOMETHING_CHANGED;
1124
			report(_("index-version: was %d, set to %d"),
1125
			       the_repository->index->version, preferred_index_format);
1126
			the_repository->index->version = preferred_index_format;
1127
		}
1128
	}
1129

1130
	if (read_from_stdin) {
1131
		struct strbuf buf = STRBUF_INIT;
1132
		struct strbuf unquoted = STRBUF_INIT;
1133

1134
		setup_work_tree();
1135
		while (getline_fn(&buf, stdin) != EOF) {
1136
			char *p;
1137
			if (!nul_term_line && buf.buf[0] == '"') {
1138
				strbuf_reset(&unquoted);
1139
				if (unquote_c_style(&unquoted, buf.buf, NULL))
1140
					die("line is badly quoted");
1141
				strbuf_swap(&buf, &unquoted);
1142
			}
1143
			p = prefix_path(prefix, prefix_length, buf.buf);
1144
			update_one(p);
1145
			if (set_executable_bit)
1146
				chmod_path(set_executable_bit, p);
1147
			free(p);
1148
		}
1149
		strbuf_release(&unquoted);
1150
		strbuf_release(&buf);
1151
	}
1152

1153
	/*
1154
	 * By now we have added all of the new objects
1155
	 */
1156
	end_odb_transaction();
1157

1158
	if (split_index > 0) {
1159
		if (repo_config_get_split_index(the_repository) == 0)
1160
			warning(_("core.splitIndex is set to false; "
1161
				  "remove or change it, if you really want to "
1162
				  "enable split index"));
1163
		if (the_repository->index->split_index)
1164
			the_repository->index->cache_changed |= SPLIT_INDEX_ORDERED;
1165
		else
1166
			add_split_index(the_repository->index);
1167
	} else if (!split_index) {
1168
		if (repo_config_get_split_index(the_repository) == 1)
1169
			warning(_("core.splitIndex is set to true; "
1170
				  "remove or change it, if you really want to "
1171
				  "disable split index"));
1172
		remove_split_index(the_repository->index);
1173
	}
1174

1175
	prepare_repo_settings(r);
1176
	switch (untracked_cache) {
1177
	case UC_UNSPECIFIED:
1178
		break;
1179
	case UC_DISABLE:
1180
		if (r->settings.core_untracked_cache == UNTRACKED_CACHE_WRITE)
1181
			warning(_("core.untrackedCache is set to true; "
1182
				  "remove or change it, if you really want to "
1183
				  "disable the untracked cache"));
1184
		remove_untracked_cache(the_repository->index);
1185
		report(_("Untracked cache disabled"));
1186
		break;
1187
	case UC_TEST:
1188
		setup_work_tree();
1189
		return !test_if_untracked_cache_is_supported();
1190
	case UC_ENABLE:
1191
	case UC_FORCE:
1192
		if (r->settings.core_untracked_cache == UNTRACKED_CACHE_REMOVE)
1193
			warning(_("core.untrackedCache is set to false; "
1194
				  "remove or change it, if you really want to "
1195
				  "enable the untracked cache"));
1196
		add_untracked_cache(the_repository->index);
1197
		report(_("Untracked cache enabled for '%s'"), get_git_work_tree());
1198
		break;
1199
	default:
1200
		BUG("bad untracked_cache value: %d", untracked_cache);
1201
	}
1202

1203
	if (fsmonitor > 0) {
1204
		enum fsmonitor_mode fsm_mode = fsm_settings__get_mode(r);
1205
		enum fsmonitor_reason reason = fsm_settings__get_reason(r);
1206

1207
		/*
1208
		 * The user wants to turn on FSMonitor using the command
1209
		 * line argument.  (We don't know (or care) whether that
1210
		 * is the IPC or HOOK version.)
1211
		 *
1212
		 * Use one of the __get routines to force load the FSMonitor
1213
		 * config settings into the repo-settings.  That will detect
1214
		 * whether the file system is compatible so that we can stop
1215
		 * here with a nice error message.
1216
		 */
1217
		if (reason > FSMONITOR_REASON_OK)
1218
			die("%s",
1219
			    fsm_settings__get_incompatible_msg(r, reason));
1220

1221
		if (fsm_mode == FSMONITOR_MODE_DISABLED) {
1222
			warning(_("core.fsmonitor is unset; "
1223
				"set it if you really want to "
1224
				"enable fsmonitor"));
1225
		}
1226
		add_fsmonitor(the_repository->index);
1227
		report(_("fsmonitor enabled"));
1228
	} else if (!fsmonitor) {
1229
		enum fsmonitor_mode fsm_mode = fsm_settings__get_mode(r);
1230
		if (fsm_mode > FSMONITOR_MODE_DISABLED)
1231
			warning(_("core.fsmonitor is set; "
1232
				"remove it if you really want to "
1233
				"disable fsmonitor"));
1234
		remove_fsmonitor(the_repository->index);
1235
		report(_("fsmonitor disabled"));
1236
	}
1237

1238
	if (the_repository->index->cache_changed || force_write) {
1239
		if (newfd < 0) {
1240
			if (refresh_args.flags & REFRESH_QUIET)
1241
				exit(128);
1242
			unable_to_lock_die(get_index_file(), lock_error);
1243
		}
1244
		if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
1245
			die("Unable to write new index file");
1246
	}
1247

1248
	rollback_lock_file(&lock_file);
1249

1250
	return has_errors ? 1 : 0;
1251
}
1252