read-cache.c 28.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5
/*
 * GIT - The information manager from hell
 *
 * Copyright (C) Linus Torvalds, 2005
 */
6
#define NO_THE_INDEX_COMPATIBILITY_MACROS
7
#include "cache.h"
8
#include "cache-tree.h"
9
#include "refs.h"
10
#include "dir.h"
11 12 13 14 15 16 17 18 19 20 21 22

/* Index extensions.
 *
 * The first letter should be 'A'..'Z' for extensions that are not
 * necessary for a correct operation (i.e. optimization data).
 * When new extensions are added that _needs_ to be understood in
 * order to correctly interpret the index file, pick character that
 * is outside the range, to cause the reader to abort.
 */

#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) )
#define CACHE_EXT_TREE 0x54524545	/* "TREE" */
23

24
struct index_state the_index;
25

26 27 28 29 30 31 32 33 34
/*
 * This only updates the "non-critical" parts of the directory
 * cache, ie the parts that aren't tracked by GIT, and only used
 * to validate the cache.
 */
void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
{
	ce->ce_ctime.sec = htonl(st->st_ctime);
	ce->ce_mtime.sec = htonl(st->st_mtime);
35
#ifdef USE_NSEC
36 37 38 39 40 41 42 43
	ce->ce_ctime.nsec = htonl(st->st_ctim.tv_nsec);
	ce->ce_mtime.nsec = htonl(st->st_mtim.tv_nsec);
#endif
	ce->ce_dev = htonl(st->st_dev);
	ce->ce_ino = htonl(st->st_ino);
	ce->ce_uid = htonl(st->st_uid);
	ce->ce_gid = htonl(st->st_gid);
	ce->ce_size = htonl(st->st_size);
Junio C Hamano's avatar
Junio C Hamano committed
44 45 46

	if (assume_unchanged)
		ce->ce_flags |= htons(CE_VALID);
47 48
}

Junio C Hamano's avatar
Junio C Hamano committed
49 50 51 52 53 54 55
static int ce_compare_data(struct cache_entry *ce, struct stat *st)
{
	int match = -1;
	int fd = open(ce->name, O_RDONLY);

	if (fd >= 0) {
		unsigned char sha1[20];
56
		if (!index_fd(sha1, fd, st, 0, OBJ_BLOB, ce->name))
57
			match = hashcmp(sha1, ce->sha1);
58
		/* index_fd() closed the file descriptor already */
Junio C Hamano's avatar
Junio C Hamano committed
59 60 61 62
	}
	return match;
}

63
static int ce_compare_link(struct cache_entry *ce, size_t expected_size)
Junio C Hamano's avatar
Junio C Hamano committed
64 65 66 67 68
{
	int match = -1;
	char *target;
	void *buffer;
	unsigned long size;
69
	enum object_type type;
Junio C Hamano's avatar
Junio C Hamano committed
70 71 72 73 74 75 76 77
	int len;

	target = xmalloc(expected_size);
	len = readlink(ce->name, target, expected_size);
	if (len != expected_size) {
		free(target);
		return -1;
	}
78
	buffer = read_sha1_file(ce->sha1, &type, &size);
Junio C Hamano's avatar
Junio C Hamano committed
79 80 81 82 83 84 85 86 87 88 89
	if (!buffer) {
		free(target);
		return -1;
	}
	if (size == expected_size)
		match = memcmp(buffer, target, size);
	free(buffer);
	free(target);
	return match;
}

90 91 92 93 94 95
static int ce_compare_gitlink(struct cache_entry *ce)
{
	unsigned char sha1[20];

	/*
	 * We don't actually require that the .git directory
Martin Waitz's avatar
Martin Waitz committed
96
	 * under GITLINK directory be a valid git directory. It
97 98 99 100 101 102 103 104 105 106
	 * might even be missing (in case nobody populated that
	 * sub-project).
	 *
	 * If so, we consider it always to match.
	 */
	if (resolve_gitlink_ref(ce->name, "HEAD", sha1) < 0)
		return 0;
	return hashcmp(sha1, ce->sha1);
}

Junio C Hamano's avatar
Junio C Hamano committed
107 108 109 110 111 112 113 114
static int ce_modified_check_fs(struct cache_entry *ce, struct stat *st)
{
	switch (st->st_mode & S_IFMT) {
	case S_IFREG:
		if (ce_compare_data(ce, st))
			return DATA_CHANGED;
		break;
	case S_IFLNK:
115
		if (ce_compare_link(ce, xsize_t(st->st_size)))
Junio C Hamano's avatar
Junio C Hamano committed
116 117
			return DATA_CHANGED;
		break;
118
	case S_IFDIR:
Martin Waitz's avatar
Martin Waitz committed
119
		if (S_ISGITLINK(ntohl(ce->ce_mode)))
120
			return 0;
Junio C Hamano's avatar
Junio C Hamano committed
121 122 123 124 125 126
	default:
		return TYPE_CHANGED;
	}
	return 0;
}

Junio C Hamano's avatar
Junio C Hamano committed
127
static int ce_match_stat_basic(struct cache_entry *ce, struct stat *st)
128 129 130
{
	unsigned int changed = 0;

131 132 133
	switch (ntohl(ce->ce_mode) & S_IFMT) {
	case S_IFREG:
		changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0;
Junio C Hamano's avatar
Junio C Hamano committed
134 135 136 137 138
		/* We consider only the owner x bit to be relevant for
		 * "mode changes"
		 */
		if (trust_executable_bit &&
		    (0100 & (ntohl(ce->ce_mode) ^ st->st_mode)))
139
			changed |= MODE_CHANGED;
140 141
		break;
	case S_IFLNK:
142 143 144
		if (!S_ISLNK(st->st_mode) &&
		    (has_symlinks || !S_ISREG(st->st_mode)))
			changed |= TYPE_CHANGED;
145
		break;
Martin Waitz's avatar
Martin Waitz committed
146
	case S_IFGITLINK:
147 148 149 150
		if (!S_ISDIR(st->st_mode))
			changed |= TYPE_CHANGED;
		else if (ce_compare_gitlink(ce))
			changed |= DATA_CHANGED;
151
		return changed;
152 153 154
	default:
		die("internal error: ce_mode is %o", ntohl(ce->ce_mode));
	}
155
	if (ce->ce_mtime.sec != htonl(st->st_mtime))
156
		changed |= MTIME_CHANGED;
157 158 159
	if (ce->ce_ctime.sec != htonl(st->st_ctime))
		changed |= CTIME_CHANGED;

160
#ifdef USE_NSEC
161 162 163 164 165
	/*
	 * nsec seems unreliable - not all filesystems support it, so
	 * as long as it is in the inode cache you get right nsec
	 * but after it gets flushed, you get zero nsec.
	 */
166
	if (ce->ce_mtime.nsec != htonl(st->st_mtim.tv_nsec))
167
		changed |= MTIME_CHANGED;
168
	if (ce->ce_ctime.nsec != htonl(st->st_ctim.tv_nsec))
169
		changed |= CTIME_CHANGED;
Junio C Hamano's avatar
Junio C Hamano committed
170
#endif
171 172 173

	if (ce->ce_uid != htonl(st->st_uid) ||
	    ce->ce_gid != htonl(st->st_gid))
174
		changed |= OWNER_CHANGED;
175
	if (ce->ce_ino != htonl(st->st_ino))
176
		changed |= INODE_CHANGED;
177 178 179 180 181 182 183 184 185 186 187

#ifdef USE_STDEV
	/*
	 * st_dev breaks on network filesystems where different
	 * clients will have different views of what "device"
	 * the filesystem is on
	 */
	if (ce->ce_dev != htonl(st->st_dev))
		changed |= INODE_CHANGED;
#endif

188
	if (ce->ce_size != htonl(st->st_size))
189
		changed |= DATA_CHANGED;
190

Junio C Hamano's avatar
Junio C Hamano committed
191 192 193
	return changed;
}

194 195
int ie_match_stat(struct index_state *istate,
		  struct cache_entry *ce, struct stat *st, int options)
Junio C Hamano's avatar
Junio C Hamano committed
196
{
Junio C Hamano's avatar
Junio C Hamano committed
197
	unsigned int changed;
198 199
	int ignore_valid = options & 01;
	int assume_racy_is_modified = options & 02;
Junio C Hamano's avatar
Junio C Hamano committed
200 201 202 203 204 205 206 207 208

	/*
	 * If it's marked as always valid in the index, it's
	 * valid whatever the checked-out copy says.
	 */
	if (!ignore_valid && (ce->ce_flags & htons(CE_VALID)))
		return 0;

	changed = ce_match_stat_basic(ce, st);
Junio C Hamano's avatar
Junio C Hamano committed
209

Junio C Hamano's avatar
Junio C Hamano committed
210 211 212 213 214 215 216 217 218 219 220 221 222 223
	/*
	 * Within 1 second of this sequence:
	 * 	echo xyzzy >file && git-update-index --add file
	 * running this command:
	 * 	echo frotz >file
	 * would give a falsely clean cache entry.  The mtime and
	 * length match the cache, and other stat fields do not change.
	 *
	 * We could detect this at update-index time (the cache entry
	 * being registered/updated records the same time as "now")
	 * and delay the return from git-update-index, but that would
	 * effectively mean we can make at most one commit per second,
	 * which is not acceptable.  Instead, we check cache entries
	 * whose mtime are the same as the index file timestamp more
Junio C Hamano's avatar
Junio C Hamano committed
224
	 * carefully than others.
Junio C Hamano's avatar
Junio C Hamano committed
225 226
	 */
	if (!changed &&
227 228
	    istate->timestamp &&
	    istate->timestamp <= ntohl(ce->ce_mtime.sec)) {
229 230 231 232 233
		if (assume_racy_is_modified)
			changed |= DATA_CHANGED;
		else
			changed |= ce_modified_check_fs(ce, st);
	}
234

Junio C Hamano's avatar
Junio C Hamano committed
235
	return changed;
236 237
}

238 239
int ie_modified(struct index_state *istate,
		struct cache_entry *ce, struct stat *st, int really)
240
{
Junio C Hamano's avatar
Junio C Hamano committed
241
	int changed, changed_fs;
242
	changed = ie_match_stat(istate, ce, st, really);
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
	if (!changed)
		return 0;
	/*
	 * If the mode or type has changed, there's no point in trying
	 * to refresh the entry - it's not going to match
	 */
	if (changed & (MODE_CHANGED | TYPE_CHANGED))
		return changed;

	/* Immediately after read-tree or update-index --cacheinfo,
	 * the length field is zero.  For other cases the ce_size
	 * should match the SHA1 recorded in the index entry.
	 */
	if ((changed & DATA_CHANGED) && ce->ce_size != htonl(0))
		return changed;

Junio C Hamano's avatar
Junio C Hamano committed
259 260 261
	changed_fs = ce_modified_check_fs(ce, st);
	if (changed_fs)
		return changed | changed_fs;
262 263 264
	return 0;
}

265 266 267 268 269 270 271 272 273 274 275 276
int base_name_compare(const char *name1, int len1, int mode1,
		      const char *name2, int len2, int mode2)
{
	unsigned char c1, c2;
	int len = len1 < len2 ? len1 : len2;
	int cmp;

	cmp = memcmp(name1, name2, len);
	if (cmp)
		return cmp;
	c1 = name1[len];
	c2 = name2[len];
277
	if (!c1 && S_ISDIR(mode1))
278
		c1 = '/';
279
	if (!c2 && S_ISDIR(mode2))
280 281 282 283
		c2 = '/';
	return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
}

284
int cache_name_compare(const char *name1, int flags1, const char *name2, int flags2)
285
{
286 287
	int len1 = flags1 & CE_NAMEMASK;
	int len2 = flags2 & CE_NAMEMASK;
288 289 290 291 292 293 294 295 296 297
	int len = len1 < len2 ? len1 : len2;
	int cmp;

	cmp = memcmp(name1, name2, len);
	if (cmp)
		return cmp;
	if (len1 < len2)
		return -1;
	if (len1 > len2)
		return 1;
Junio C Hamano's avatar
Junio C Hamano committed
298

299 300 301
	/* Compare stages  */
	flags1 &= CE_STAGEMASK;
	flags2 &= CE_STAGEMASK;
Junio C Hamano's avatar
Junio C Hamano committed
302

303 304 305 306
	if (flags1 < flags2)
		return -1;
	if (flags1 > flags2)
		return 1;
307 308 309
	return 0;
}

310
int index_name_pos(struct index_state *istate, const char *name, int namelen)
311 312 313 314
{
	int first, last;

	first = 0;
315
	last = istate->cache_nr;
316 317
	while (last > first) {
		int next = (last + first) >> 1;
318
		struct cache_entry *ce = istate->cache[next];
319
		int cmp = cache_name_compare(name, namelen, ce->name, ntohs(ce->ce_flags));
320
		if (!cmp)
321
			return next;
322 323 324 325 326 327
		if (cmp < 0) {
			last = next;
			continue;
		}
		first = next+1;
	}
328
	return -first-1;
329 330
}

331
/* Remove entry, return true if there are more entries to go.. */
332
int remove_index_entry_at(struct index_state *istate, int pos)
333
{
334 335 336
	istate->cache_changed = 1;
	istate->cache_nr--;
	if (pos >= istate->cache_nr)
337
		return 0;
338 339 340
	memmove(istate->cache + pos,
		istate->cache + pos + 1,
		(istate->cache_nr - pos) * sizeof(struct cache_entry *));
341 342 343
	return 1;
}

344
int remove_file_from_index(struct index_state *istate, const char *path)
345
{
346
	int pos = index_name_pos(istate, path, strlen(path));
347 348
	if (pos < 0)
		pos = -pos-1;
349 350
	while (pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path))
		remove_index_entry_at(istate, pos);
351 352 353
	return 0;
}

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
static int compare_name(struct cache_entry *ce, const char *path, int namelen)
{
	return namelen != ce_namelen(ce) || memcmp(path, ce->name, namelen);
}

static int index_name_pos_also_unmerged(struct index_state *istate,
	const char *path, int namelen)
{
	int pos = index_name_pos(istate, path, namelen);
	struct cache_entry *ce;

	if (pos >= 0)
		return pos;

	/* maybe unmerged? */
	pos = -1 - pos;
	if (pos >= istate->cache_nr ||
			compare_name((ce = istate->cache[pos]), path, namelen))
		return -1;

	/* order of preference: stage 2, 1, 3 */
	if (ce_stage(ce) == 1 && pos + 1 < istate->cache_nr &&
			ce_stage((ce = istate->cache[pos + 1])) == 2 &&
			!compare_name(ce, path, namelen))
		pos++;
	return pos;
}

382
int add_file_to_index(struct index_state *istate, const char *path, int verbose)
Johannes Schindelin's avatar
Johannes Schindelin committed
383
{
384
	int size, namelen, pos;
Johannes Schindelin's avatar
Johannes Schindelin committed
385 386 387 388 389 390
	struct stat st;
	struct cache_entry *ce;

	if (lstat(path, &st))
		die("%s: unable to stat (%s)", path, strerror(errno));

391 392
	if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode) && !S_ISDIR(st.st_mode))
		die("%s: can only add regular files, symbolic links or git-directories", path);
Johannes Schindelin's avatar
Johannes Schindelin committed
393 394

	namelen = strlen(path);
395 396 397 398
	if (S_ISDIR(st.st_mode)) {
		while (namelen && path[namelen-1] == '/')
			namelen--;
	}
Johannes Schindelin's avatar
Johannes Schindelin committed
399 400 401 402 403 404
	size = cache_entry_size(namelen);
	ce = xcalloc(1, size);
	memcpy(ce->name, path, namelen);
	ce->ce_flags = htons(namelen);
	fill_stat_cache_info(ce, &st);

405
	if (trust_executable_bit && has_symlinks)
406 407
		ce->ce_mode = create_ce_mode(st.st_mode);
	else {
408 409
		/* If there is an existing entry, pick the mode bits and type
		 * from it, otherwise assume unexecutable regular file.
Johannes Schindelin's avatar
Johannes Schindelin committed
410
		 */
411
		struct cache_entry *ent;
412
		int pos = index_name_pos_also_unmerged(istate, path, namelen);
413

414
		ent = (0 <= pos) ? istate->cache[pos] : NULL;
415
		ce->ce_mode = ce_mode_from_stat(ent, st.st_mode);
Johannes Schindelin's avatar
Johannes Schindelin committed
416 417
	}

418 419 420 421 422 423 424 425 426
	pos = index_name_pos(istate, ce->name, namelen);
	if (0 <= pos &&
	    !ce_stage(istate->cache[pos]) &&
	    !ie_modified(istate, istate->cache[pos], &st, 1)) {
		/* Nothing changed, really */
		free(ce);
		return 0;
	}

Johannes Schindelin's avatar
Johannes Schindelin committed
427 428
	if (index_path(ce->sha1, path, &st, 1))
		die("unable to index file %s", path);
429
	if (add_index_entry(istate, ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE))
Johannes Schindelin's avatar
Johannes Schindelin committed
430 431 432
		die("unable to add %s to index",path);
	if (verbose)
		printf("add '%s'\n", path);
433
	cache_tree_invalidate_path(istate->cache_tree, path);
Johannes Schindelin's avatar
Johannes Schindelin committed
434 435 436
	return 0;
}

437
int ce_same_name(struct cache_entry *a, struct cache_entry *b)
438 439 440 441 442
{
	int len = ce_namelen(a);
	return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
}

443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
int ce_path_match(const struct cache_entry *ce, const char **pathspec)
{
	const char *match, *name;
	int len;

	if (!pathspec)
		return 1;

	len = ce_namelen(ce);
	name = ce->name;
	while ((match = *pathspec++) != NULL) {
		int matchlen = strlen(match);
		if (matchlen > len)
			continue;
		if (memcmp(name, match, matchlen))
			continue;
		if (matchlen && name[matchlen-1] == '/')
			return 1;
		if (name[matchlen] == '/' || !name[matchlen])
			return 1;
463 464
		if (!matchlen)
			return 1;
465 466 467 468
	}
	return 0;
}

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
/*
 * We fundamentally don't like some paths: we don't want
 * dot or dot-dot anywhere, and for obvious reasons don't
 * want to recurse into ".git" either.
 *
 * Also, we don't want double slashes or slashes at the
 * end that can make pathnames ambiguous.
 */
static int verify_dotfile(const char *rest)
{
	/*
	 * The first character was '.', but that
	 * has already been discarded, we now test
	 * the rest.
	 */
	switch (*rest) {
	/* "." is not allowed */
	case '\0': case '/':
		return 0;

	/*
	 * ".git" followed by  NUL or slash is bad. This
	 * shares the path end test with the ".." case.
	 */
	case 'g':
		if (rest[1] != 'i')
			break;
		if (rest[2] != 't')
			break;
		rest += 2;
	/* fallthrough */
	case '.':
		if (rest[1] == '\0' || rest[1] == '/')
			return 0;
	}
	return 1;
}

int verify_path(const char *path)
{
	char c;

	goto inside;
	for (;;) {
		if (!c)
			return 1;
		if (c == '/') {
inside:
			c = *path++;
			switch (c) {
			default:
				continue;
			case '/': case '\0':
				break;
			case '.':
				if (verify_dotfile(path))
					continue;
			}
			return 0;
		}
		c = *path++;
	}
}

533 534 535
/*
 * Do we have another file that has the beginning components being a
 * proper superset of the name we're trying to add?
536
 */
537 538
static int has_file_name(struct index_state *istate,
			 const struct cache_entry *ce, int pos, int ok_to_replace)
539
{
540 541
	int retval = 0;
	int len = ce_namelen(ce);
542
	int stage = ce_stage(ce);
543
	const char *name = ce->name;
544

545 546
	while (pos < istate->cache_nr) {
		struct cache_entry *p = istate->cache[pos++];
547

548
		if (len >= ce_namelen(p))
549
			break;
550 551
		if (memcmp(name, p->name, len))
			break;
552 553
		if (ce_stage(p) != stage)
			continue;
554 555
		if (p->name[len] != '/')
			continue;
556 557
		if (!ce_stage(p) && !p->ce_mode)
			continue;
558 559 560
		retval = -1;
		if (!ok_to_replace)
			break;
561
		remove_index_entry_at(istate, --pos);
562
	}
563 564
	return retval;
}
565

566 567 568 569
/*
 * Do we have another file with a pathname that is a proper
 * subset of the name we're trying to add?
 */
570 571
static int has_dir_name(struct index_state *istate,
			const struct cache_entry *ce, int pos, int ok_to_replace)
572 573
{
	int retval = 0;
574
	int stage = ce_stage(ce);
575 576
	const char *name = ce->name;
	const char *slash = name + ce_namelen(ce);
577

578 579
	for (;;) {
		int len;
580

581 582 583 584 585 586 587
		for (;;) {
			if (*--slash == '/')
				break;
			if (slash <= ce->name)
				return retval;
		}
		len = slash - name;
588

589
		pos = index_name_pos(istate, name, ntohs(create_ce_flags(len, stage)));
590
		if (pos >= 0) {
591 592 593 594 595 596 597 598
			/*
			 * Found one, but not so fast.  This could
			 * be a marker that says "I was here, but
			 * I am being removed".  Such an entry is
			 * not a part of the resulting tree, and
			 * it is Ok to have a directory at the same
			 * path.
			 */
599
			if (stage || istate->cache[pos]->ce_mode) {
600 601 602
				retval = -1;
				if (!ok_to_replace)
					break;
603
				remove_index_entry_at(istate, pos);
604 605
				continue;
			}
606
		}
607 608
		else
			pos = -pos-1;
609 610 611 612

		/*
		 * Trivial optimization: if we find an entry that
		 * already matches the sub-directory, then we know
613
		 * we're ok, and we can exit.
614
		 */
615 616
		while (pos < istate->cache_nr) {
			struct cache_entry *p = istate->cache[pos];
617 618 619 620
			if ((ce_namelen(p) <= len) ||
			    (p->name[len] != '/') ||
			    memcmp(p->name, name, len))
				break; /* not our subdirectory */
621
			if (ce_stage(p) == stage && (stage || p->ce_mode))
622 623 624 625 626 627 628
				/* p is at the same stage as our entry, and
				 * is a subdirectory of what we are looking
				 * at, so we cannot have conflicts at our
				 * level or anything shorter.
				 */
				return retval;
			pos++;
629
		}
630
	}
631 632 633 634 635 636 637
	return retval;
}

/* We may be in a situation where we already have path/file and path
 * is being added, or we already have path and path/file is being
 * added.  Either one would result in a nonsense tree that has path
 * twice when git-write-tree tries to write it out.  Prevent it.
Junio C Hamano's avatar
Junio C Hamano committed
638
 *
639 640 641 642
 * If ok-to-replace is specified, we remove the conflicting entries
 * from the cache so the caller should recompute the insert position.
 * When this happens, we return non-zero.
 */
643 644 645
static int check_file_directory_conflict(struct index_state *istate,
					 const struct cache_entry *ce,
					 int pos, int ok_to_replace)
646
{
647 648 649 650 651 652 653 654
	int retval;

	/*
	 * When ce is an "I am going away" entry, we allow it to be added
	 */
	if (!ce_stage(ce) && !ce->ce_mode)
		return 0;

655 656 657
	/*
	 * We check if the path is a sub-path of a subsequent pathname
	 * first, since removing those will not change the position
658
	 * in the array.
659
	 */
660
	retval = has_file_name(istate, ce, pos, ok_to_replace);
661

662 663 664 665
	/*
	 * Then check if the path might have a clashing sub-directory
	 * before it.
	 */
666
	return retval + has_dir_name(istate, ce, pos, ok_to_replace);
667 668
}

669
static int add_index_entry_with_check(struct index_state *istate, struct cache_entry *ce, int option)
670 671
{
	int pos;
672 673
	int ok_to_add = option & ADD_CACHE_OK_TO_ADD;
	int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;
674
	int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;
Junio C Hamano's avatar
Junio C Hamano committed
675

676
	pos = index_name_pos(istate, ce->name, ntohs(ce->ce_flags));
677

Junio C Hamano's avatar
Junio C Hamano committed
678
	/* existing match? Just replace it. */
679
	if (pos >= 0) {
680 681
		istate->cache_changed = 1;
		istate->cache[pos] = ce;
682 683
		return 0;
	}
684
	pos = -pos-1;
685

686 687 688 689
	/*
	 * Inserting a merged entry ("stage 0") into the index
	 * will always replace all non-merged entries..
	 */
690 691
	if (pos < istate->cache_nr && ce_stage(ce) == 0) {
		while (ce_same_name(istate->cache[pos], ce)) {
692
			ok_to_add = 1;
693
			if (!remove_index_entry_at(istate, pos))
694 695 696 697
				break;
		}
	}

698 699
	if (!ok_to_add)
		return -1;
700 701
	if (!verify_path(ce->name))
		return -1;
702

Junio C Hamano's avatar
Junio C Hamano committed
703
	if (!skip_df_check &&
704
	    check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {
705
		if (!ok_to_replace)
706 707 708
			return error("'%s' appears as both a file and as a directory",
				     ce->name);
		pos = index_name_pos(istate, ce->name, ntohs(ce->ce_flags));
709 710
		pos = -pos-1;
	}
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
	return pos + 1;
}

int add_index_entry(struct index_state *istate, struct cache_entry *ce, int option)
{
	int pos;

	if (option & ADD_CACHE_JUST_APPEND)
		pos = istate->cache_nr;
	else {
		int ret;
		ret = add_index_entry_with_check(istate, ce, option);
		if (ret <= 0)
			return ret;
		pos = ret - 1;
	}
727

728
	/* Make sure the array is big enough .. */
729 730 731 732
	if (istate->cache_nr == istate->cache_alloc) {
		istate->cache_alloc = alloc_nr(istate->cache_alloc);
		istate->cache = xrealloc(istate->cache,
					istate->cache_alloc * sizeof(struct cache_entry *));
733 734 735
	}

	/* Add it in.. */
736
	istate->cache_nr++;
737
	if (istate->cache_nr > pos + 1)
738 739 740 741 742
		memmove(istate->cache + pos + 1,
			istate->cache + pos,
			(istate->cache_nr - pos - 1) * sizeof(ce));
	istate->cache[pos] = ce;
	istate->cache_changed = 1;
743 744 745
	return 0;
}

746 747 748 749 750 751 752 753 754 755 756
/*
 * "refresh" does not calculate a new sha1 file or bring the
 * cache up-to-date for mode/content changes. But what it
 * _does_ do is to "re-match" the stat information of a file
 * with the cache, so that you can refresh the cache for a
 * file that hasn't been changed but where the stat entry is
 * out of date.
 *
 * For example, you'd want to do this after doing a "git-read-tree",
 * to link up the stat cache details with the proper files.
 */
757 758
static struct cache_entry *refresh_cache_ent(struct index_state *istate,
					     struct cache_entry *ce, int really, int *err)
759 760 761 762 763
{
	struct stat st;
	struct cache_entry *updated;
	int changed, size;

764
	if (lstat(ce->name, &st) < 0) {
765 766
		if (err)
			*err = errno;
767 768
		return NULL;
	}
769

770
	changed = ie_match_stat(istate, ce, &st, really);
771 772 773 774 775
	if (!changed) {
		if (really && assume_unchanged &&
		    !(ce->ce_flags & htons(CE_VALID)))
			; /* mark this one VALID again */
		else
776
			return ce;
777 778
	}

779
	if (ie_modified(istate, ce, &st, really)) {
780 781
		if (err)
			*err = EINVAL;
782 783
		return NULL;
	}
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801

	size = ce_size(ce);
	updated = xmalloc(size);
	memcpy(updated, ce, size);
	fill_stat_cache_info(updated, &st);

	/* In this case, if really is not set, we should leave
	 * CE_VALID bit alone.  Otherwise, paths marked with
	 * --no-assume-unchanged (i.e. things to be edited) will
	 * reacquire CE_VALID bit automatically, which is not
	 * really what we want.
	 */
	if (!really && assume_unchanged && !(ce->ce_flags & htons(CE_VALID)))
		updated->ce_flags &= ~htons(CE_VALID);

	return updated;
}

802
int refresh_index(struct index_state *istate, unsigned int flags, const char **pathspec, char *seen)
803 804 805 806 807 808 809 810
{
	int i;
	int has_errors = 0;
	int really = (flags & REFRESH_REALLY) != 0;
	int allow_unmerged = (flags & REFRESH_UNMERGED) != 0;
	int quiet = (flags & REFRESH_QUIET) != 0;
	int not_new = (flags & REFRESH_IGNORE_MISSING) != 0;

811
	for (i = 0; i < istate->cache_nr; i++) {
812
		struct cache_entry *ce, *new;
813 814
		int cache_errno = 0;

815
		ce = istate->cache[i];
816
		if (ce_stage(ce)) {
817 818
			while ((i < istate->cache_nr) &&
			       ! strcmp(istate->cache[i]->name, ce->name))
819 820 821 822 823 824 825 826 827
				i++;
			i--;
			if (allow_unmerged)
				continue;
			printf("%s: needs merge\n", ce->name);
			has_errors = 1;
			continue;
		}

828 829 830
		if (pathspec && !match_pathspec(pathspec, ce->name, strlen(ce->name), 0, seen))
			continue;

831
		new = refresh_cache_ent(istate, ce, really, &cache_errno);
832
		if (new == ce)
833
			continue;
834 835
		if (!new) {
			if (not_new && cache_errno == ENOENT)
836
				continue;
837
			if (really && cache_errno == EINVAL) {
838 839 840 841
				/* If we are doing --really-refresh that
				 * means the index is not valid anymore.
				 */
				ce->ce_flags &= ~htons(CE_VALID);
842
				istate->cache_changed = 1;
843 844 845 846 847 848 849
			}
			if (quiet)
				continue;
			printf("%s: needs update\n", ce->name);
			has_errors = 1;
			continue;
		}
850 851
		istate->cache_changed = 1;
		/* You can NOT just free istate->cache[i] here, since it
852 853
		 * might not be necessarily malloc()ed but can also come
		 * from mmap(). */
854
		istate->cache[i] = new;
855 856 857 858
	}
	return has_errors;
}

859 860
struct cache_entry *refresh_cache_entry(struct cache_entry *ce, int really)
{
861
	return refresh_cache_ent(&the_index, ce, really, NULL);
862 863
}

864
static int verify_hdr(struct cache_header *hdr, unsigned long size)
865 866
{
	SHA_CTX c;
867
	unsigned char sha1[20];
868

869
	if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
870
		return error("bad signature");
871 872
	if (hdr->hdr_version != htonl(2))
		return error("bad index version");
873
	SHA1_Init(&c);
874
	SHA1_Update(&c, hdr, size - 20);
875
	SHA1_Final(sha1, &c);
876
	if (hashcmp(sha1, (unsigned char *)hdr + size - 20))
877
		return error("bad index file sha1 signature");
878 879 880
	return 0;
}

881 882
static int read_index_extension(struct index_state *istate,
				const char *ext, void *data, unsigned long sz)
883 884 885
{
	switch (CACHE_EXT(ext)) {
	case CACHE_EXT_TREE:
886
		istate->cache_tree = cache_tree_read(data, sz);
887 888 889 890 891 892 893 894 895 896 897
		break;
	default:
		if (*ext < 'A' || 'Z' < *ext)
			return error("index uses %.4s extension, which we do not understand",
				     ext);
		fprintf(stderr, "ignoring %.4s extension\n", ext);
		break;
	}
	return 0;
}

898
int read_index(struct index_state *istate)
899
{
900
	return read_index_from(istate, get_index_file());
901 902 903
}

/* remember to discard_cache() before reading a different cache! */
904
int read_index_from(struct index_state *istate, const char *path)
905 906 907
{
	int fd, i;
	struct stat st;
908
	unsigned long offset;
909 910 911
	struct cache_header *hdr;

	errno = EBUSY;
912 913
	if (istate->mmap)
		return istate->cache_nr;
914

915
	errno = ENOENT;
916
	istate->timestamp = 0;
917
	fd = open(path, O_RDONLY);
918 919 920 921 922
	if (fd < 0) {
		if (errno == ENOENT)
			return 0;
		die("index file open failed (%s)", strerror(errno));
	}
923

924
	if (fstat(fd, &st))
925
		die("cannot stat the open index (%s)", strerror(errno));
926 927 928 929 930 931 932

	errno = EINVAL;
	istate->mmap_size = xsize_t(st.st_size);
	if (istate->mmap_size < sizeof(struct cache_header) + 20)
		die("index file smaller than expected");

	istate->mmap = xmmap(NULL, istate->mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
933 934
	close(fd);

935 936
	hdr = istate->mmap;
	if (verify_hdr(hdr, istate->mmap_size) < 0)
937 938
		goto unmap;

939 940 941
	istate->cache_nr = ntohl(hdr->hdr_entries);
	istate->cache_alloc = alloc_nr(istate->cache_nr);
	istate->cache = xcalloc(istate->cache_alloc, sizeof(struct cache_entry *));
942 943

	offset = sizeof(*hdr);
944 945 946 947
	for (i = 0; i < istate->cache_nr; i++) {
		struct cache_entry *ce;

		ce = (struct cache_entry *)((char *)(istate->mmap) + offset);
948
		offset = offset + ce_size(ce);
949
		istate->cache[i] = ce;
950
	}
951 952
	istate->timestamp = st.st_mtime;
	while (offset <= istate->mmap_size - 20 - 8) {
953 954 955 956 957 958 959
		/* After an array of active_nr index entries,
		 * there can be arbitrary number of extended
		 * sections, each of which is prefixed with
		 * extension name (4-byte) and section length
		 * in 4-byte network byte order.
		 */
		unsigned long extsize;
960
		memcpy(&extsize, (char *)(istate->mmap) + offset + 4, 4);
961
		extsize = ntohl(extsize);
962 963 964
		if (read_index_extension(istate,
					 ((const char *) (istate->mmap)) + offset,
					 (char *) (istate->mmap) + offset + 8,
965
					 extsize) < 0)
966 967 968 969
			goto unmap;
		offset += 8;
		offset += extsize;
	}
970
	return istate->cache_nr;
971 972

unmap:
973
	munmap(istate->mmap, istate->mmap_size);
974
	errno = EINVAL;
975
	die("index file corrupt");
976 977
}

978
int discard_index(struct index_state *istate)
979 980 981
{
	int ret;

982 983 984 985 986
	istate->cache_nr = 0;
	istate->cache_changed = 0;
	istate->timestamp = 0;
	cache_tree_free(&(istate->cache_tree));
	if (istate->mmap == NULL)
987
		return 0;
988 989 990
	ret = munmap(istate->mmap, istate->mmap_size);
	istate->mmap = NULL;
	istate->mmap_size = 0;
991 992 993 994 995

	/* no need to throw away allocated active_cache */
	return ret;
}

996
#define WRITE_BUFFER_SIZE 8192
997
static unsigned char write_buffer[WRITE_BUFFER_SIZE];
998 999
static unsigned long write_buffer_len;

1000 1001 1002 1003 1004
static int ce_write_flush(SHA_CTX *context, int fd)
{
	unsigned int buffered = write_buffer_len;
	if (buffered) {
		SHA1_Update(context, write_buffer, buffered);
1005
		if (write_in_full(fd, write_buffer, buffered) != buffered)
1006 1007 1008 1009 1010 1011
			return -1;
		write_buffer_len = 0;
	}
	return 0;
}

1012
static int ce_write(SHA_CTX *context, int fd, void *data, unsigned int len)
1013 1014 1015 1016 1017 1018 1019 1020 1021
{
	while (len) {
		unsigned int buffered = write_buffer_len;
		unsigned int partial = WRITE_BUFFER_SIZE - buffered;
		if (partial > len)
			partial = len;
		memcpy(write_buffer + buffered, data, partial);
		buffered += partial;
		if (buffered == WRITE_BUFFER_SIZE) {
1022 1023
			write_buffer_len = buffered;
			if (ce_write_flush(context, fd))
1024 1025 1026 1027 1028
				return -1;
			buffered = 0;
		}
		write_buffer_len = buffered;
		len -= partial;
1029
		data = (char *) data + partial;
Junio C Hamano's avatar
Junio C Hamano committed
1030 1031
	}
	return 0;
1032 1033
}

1034
static int write_index_ext_header(SHA_CTX *context, int fd,
1035
				  unsigned int ext, unsigned int sz)
1036 1037 1038
{
	ext = htonl(ext);
	sz = htonl(sz);
David Rientjes's avatar
David Rientjes committed
1039 1040
	return ((ce_write(context, fd, &ext, 4) < 0) ||
		(ce_write(context, fd, &sz, 4) < 0)) ? -1 : 0;
1041 1042 1043
}

static int ce_flush(SHA_CTX *context, int fd)
1044 1045
{
	unsigned int left = write_buffer_len;
1046

1047 1048
	if (left) {
		write_buffer_len = 0;
1049
		SHA1_Update(context, write_buffer, left);
1050
	}
1051

1052 1053
	/* Flush first if not enough space for SHA1 signature */
	if (left + 20 > WRITE_BUFFER_SIZE) {
1054
		if (write_in_full(fd, write_buffer, left) != left)
1055 1056 1057 1058
			return -1;
		left = 0;
	}

1059
	/* Append the SHA1 signature at the end */
1060
	SHA1_Final(write_buffer + left, context);
1061
	left += 20;
1062
	return (write_in_full(fd, write_buffer, left) != left) ? -1 : 0;
1063 1064
}

Junio C Hamano's avatar
Junio C Hamano committed
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
static void ce_smudge_racily_clean_entry(struct cache_entry *ce)
{
	/*
	 * The only thing we care about in this function is to smudge the
	 * falsely clean entry due to touch-update-touch race, so we leave
	 * everything else as they are.  We are called for entries whose
	 * ce_mtime match the index file mtime.
	 */
	struct stat st;

	if (lstat(ce->name, &st) < 0)
		return;
	if (ce_match_stat_basic(ce, &st))
		return;
	if (ce_modified_check_fs(ce, &st)) {
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
		/* This is "racily clean"; smudge it.  Note that this
		 * is a tricky code.  At first glance, it may appear
		 * that it can break with this sequence:
		 *
		 * $ echo xyzzy >frotz
		 * $ git-update-index --add frotz
		 * $ : >frotz
		 * $ sleep 3
		 * $ echo filfre >nitfol
		 * $ git-update-index --add nitfol
		 *
1091
		 * but it does not.  When the second update-index runs,
1092 1093 1094 1095 1096
		 * it notices that the entry "frotz" has the same timestamp
		 * as index, and if we were to smudge it by resetting its
		 * size to zero here, then the object name recorded
		 * in index is the 6-byte file but the cached stat information
		 * becomes zero --- which would then match what we would
Junio C Hamano's avatar
Junio C Hamano committed
1097
		 * obtain from the filesystem next time we stat("frotz").
1098 1099 1100 1101 1102 1103 1104
		 *
		 * However, the second update-index, before calling
		 * this function, notices that the cached size is 6
		 * bytes and what is on the filesystem is an empty
		 * file, and never calls us, so the cached size information
		 * for "frotz" stays 6 which does not match the filesystem.
		 */
Junio C Hamano's avatar
Junio C Hamano committed
1105 1106 1107 1108
		ce->ce_size = htonl(0);
	}
}

1109
int write_index(struct index_state *istate, int newfd)
1110 1111 1112
{
	SHA_CTX c;
	struct cache_header hdr;
1113
	int i, removed;
1114 1115
	struct cache_entry **cache = istate->cache;
	int entries = istate->cache_nr;
1116 1117 1118 1119

	for (i = removed = 0; i < entries; i++)
		if (!cache[i]->ce_mode)
			removed++;
1120

1121
	hdr.hdr_signature = htonl(CACHE_SIGNATURE);
1122
	hdr.hdr_version = htonl(2);
1123
	hdr.hdr_entries = htonl(entries - removed);
1124 1125

	SHA1_Init(&c);
1126
	if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0)
1127 1128 1129 1130
		return -1;

	for (i = 0; i < entries; i++) {
		struct cache_entry *ce = cache[i];
1131 1132
		if (!ce->ce_mode)
			continue;
1133 1134
		if (istate->timestamp &&
		    istate->timestamp <= ntohl(ce->ce_mtime.sec))
Junio C Hamano's avatar
Junio C Hamano committed
1135
			ce_smudge_racily_clean_entry(ce);
1136
		if (ce_write(&c, newfd, ce, ce_size(ce)) < 0)
1137 1138
			return -1;
	}
1139

1140
	/* Write extension data here */
1141
	if (istate->cache_tree) {
1142
		unsigned long sz;
1143
		void *data = cache_tree_write(istate->cache_tree, &sz);
1144 1145 1146
		if (data &&
		    !write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sz) &&
		    !ce_write(&c, newfd, data, sz))
1147
			free(data);
1148 1149 1150 1151 1152 1153
		else {
			free(data);
			return -1;
		}
	}
	return ce_flush(&c, newfd);
1154
}