read-cache.c 16.9 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 7 8
#include "cache.h"

struct cache_entry **active_cache = NULL;
Junio C Hamano's avatar
Junio C Hamano committed
9
static time_t index_file_timestamp;
10
unsigned int active_nr = 0, active_alloc = 0, active_cache_changed = 0;
11

12 13 14 15 16 17 18 19 20
/*
 * 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);
21
#ifdef USE_NSEC
22 23 24 25 26 27 28 29
	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
30 31 32

	if (assume_unchanged)
		ce->ce_flags |= htons(CE_VALID);
33 34
}

Junio C Hamano's avatar
Junio C Hamano committed
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
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];
		if (!index_fd(sha1, fd, st, 0, NULL))
			match = memcmp(sha1, ce->sha1, 20);
		close(fd);
	}
	return match;
}

static int ce_compare_link(struct cache_entry *ce, unsigned long expected_size)
{
	int match = -1;
	char *target;
	void *buffer;
	unsigned long size;
	char type[10];
	int len;

	target = xmalloc(expected_size);
	len = readlink(ce->name, target, expected_size);
	if (len != expected_size) {
		free(target);
		return -1;
	}
	buffer = read_sha1_file(ce->sha1, type, &size);
	if (!buffer) {
		free(target);
		return -1;
	}
	if (size == expected_size)
		match = memcmp(buffer, target, size);
	free(buffer);
	free(target);
	return match;
}

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:
		if (ce_compare_link(ce, st->st_size))
			return DATA_CHANGED;
		break;
	default:
		return TYPE_CHANGED;
	}
	return 0;
}

Junio C Hamano's avatar
Junio C Hamano committed
93
static int ce_match_stat_basic(struct cache_entry *ce, struct stat *st)
94 95 96
{
	unsigned int changed = 0;

97 98 99
	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
100 101 102 103 104
		/* 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)))
105
			changed |= MODE_CHANGED;
106 107 108 109 110 111 112
		break;
	case S_IFLNK:
		changed |= !S_ISLNK(st->st_mode) ? TYPE_CHANGED : 0;
		break;
	default:
		die("internal error: ce_mode is %o", ntohl(ce->ce_mode));
	}
113
	if (ce->ce_mtime.sec != htonl(st->st_mtime))
114
		changed |= MTIME_CHANGED;
115 116 117
	if (ce->ce_ctime.sec != htonl(st->st_ctime))
		changed |= CTIME_CHANGED;

118
#ifdef USE_NSEC
119 120 121 122 123
	/*
	 * 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.
	 */
124
	if (ce->ce_mtime.nsec != htonl(st->st_mtim.tv_nsec))
125
		changed |= MTIME_CHANGED;
126
	if (ce->ce_ctime.nsec != htonl(st->st_ctim.tv_nsec))
127
		changed |= CTIME_CHANGED;
128 129 130 131
#endif	

	if (ce->ce_uid != htonl(st->st_uid) ||
	    ce->ce_gid != htonl(st->st_gid))
132
		changed |= OWNER_CHANGED;
133
	if (ce->ce_ino != htonl(st->st_ino))
134
		changed |= INODE_CHANGED;
135 136 137 138 139 140 141 142 143 144 145

#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

146
	if (ce->ce_size != htonl(st->st_size))
147
		changed |= DATA_CHANGED;
148

Junio C Hamano's avatar
Junio C Hamano committed
149 150 151
	return changed;
}

Junio C Hamano's avatar
Junio C Hamano committed
152
int ce_match_stat(struct cache_entry *ce, struct stat *st, int ignore_valid)
Junio C Hamano's avatar
Junio C Hamano committed
153
{
Junio C Hamano's avatar
Junio C Hamano committed
154 155 156 157 158 159 160 161 162 163
	unsigned int changed;

	/*
	 * 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
164

Junio C Hamano's avatar
Junio C Hamano committed
165 166 167 168 169 170 171 172 173 174 175 176 177 178
	/*
	 * 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
179
	 * carefully than others.
Junio C Hamano's avatar
Junio C Hamano committed
180 181 182 183 184
	 */
	if (!changed &&
	    index_file_timestamp &&
	    index_file_timestamp <= ntohl(ce->ce_mtime.sec))
		changed |= ce_modified_check_fs(ce, st);
185

Junio C Hamano's avatar
Junio C Hamano committed
186
	return changed;
187 188
}

Junio C Hamano's avatar
Junio C Hamano committed
189
int ce_modified(struct cache_entry *ce, struct stat *st, int really)
190
{
Junio C Hamano's avatar
Junio C Hamano committed
191
	int changed, changed_fs;
Junio C Hamano's avatar
Junio C Hamano committed
192
	changed = ce_match_stat(ce, st, really);
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
	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
209 210 211
	changed_fs = ce_modified_check_fs(ce, st);
	if (changed_fs)
		return changed | changed_fs;
212 213 214
	return 0;
}

215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
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];
	if (!c1 && S_ISDIR(mode1))
		c1 = '/';
	if (!c2 && S_ISDIR(mode2))
		c2 = '/';
	return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
}

234
int cache_name_compare(const char *name1, int flags1, const char *name2, int flags2)
235
{
236 237
	int len1 = flags1 & CE_NAMEMASK;
	int len2 = flags2 & CE_NAMEMASK;
238 239 240 241 242 243 244 245 246 247
	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
248

249 250 251
	/* Compare stages  */
	flags1 &= CE_STAGEMASK;
	flags2 &= CE_STAGEMASK;
Junio C Hamano's avatar
Junio C Hamano committed
252

253 254 255 256
	if (flags1 < flags2)
		return -1;
	if (flags1 > flags2)
		return 1;
257 258 259 260 261 262 263 264 265 266 267 268
	return 0;
}

int cache_name_pos(const char *name, int namelen)
{
	int first, last;

	first = 0;
	last = active_nr;
	while (last > first) {
		int next = (last + first) >> 1;
		struct cache_entry *ce = active_cache[next];
269
		int cmp = cache_name_compare(name, namelen, ce->name, ntohs(ce->ce_flags));
270
		if (!cmp)
271
			return next;
272 273 274 275 276 277
		if (cmp < 0) {
			last = next;
			continue;
		}
		first = next+1;
	}
278
	return -first-1;
279 280
}

281
/* Remove entry, return true if there are more entries to go.. */
282
int remove_cache_entry_at(int pos)
283
{
284
	active_cache_changed = 1;
285 286 287 288 289 290 291
	active_nr--;
	if (pos >= active_nr)
		return 0;
	memmove(active_cache + pos, active_cache + pos + 1, (active_nr - pos) * sizeof(struct cache_entry *));
	return 1;
}

Junio C Hamano's avatar
Junio C Hamano committed
292
int remove_file_from_cache(const char *path)
293 294
{
	int pos = cache_name_pos(path, strlen(path));
295 296 297
	if (pos < 0)
		pos = -pos-1;
	while (pos < active_nr && !strcmp(active_cache[pos]->name, path))
298
		remove_cache_entry_at(pos);
299 300 301
	return 0;
}

302
int ce_same_name(struct cache_entry *a, struct cache_entry *b)
303 304 305 306 307
{
	int len = ce_namelen(a);
	return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
}

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
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;
328 329
		if (!matchlen)
			return 1;
330 331 332 333
	}
	return 0;
}

334 335 336
/*
 * Do we have another file that has the beginning components being a
 * proper superset of the name we're trying to add?
337
 */
338
static int has_file_name(const struct cache_entry *ce, int pos, int ok_to_replace)
339
{
340 341
	int retval = 0;
	int len = ce_namelen(ce);
342
	int stage = ce_stage(ce);
343
	const char *name = ce->name;
344

345 346
	while (pos < active_nr) {
		struct cache_entry *p = active_cache[pos++];
347

348
		if (len >= ce_namelen(p))
349
			break;
350 351
		if (memcmp(name, p->name, len))
			break;
352 353
		if (ce_stage(p) != stage)
			continue;
354 355 356 357 358 359
		if (p->name[len] != '/')
			continue;
		retval = -1;
		if (!ok_to_replace)
			break;
		remove_cache_entry_at(--pos);
360
	}
361 362
	return retval;
}
363

364 365 366 367 368 369 370
/*
 * Do we have another file with a pathname that is a proper
 * subset of the name we're trying to add?
 */
static int has_dir_name(const struct cache_entry *ce, int pos, int ok_to_replace)
{
	int retval = 0;
371
	int stage = ce_stage(ce);
372 373
	const char *name = ce->name;
	const char *slash = name + ce_namelen(ce);
374

375 376
	for (;;) {
		int len;
377

378 379 380 381 382 383 384
		for (;;) {
			if (*--slash == '/')
				break;
			if (slash <= ce->name)
				return retval;
		}
		len = slash - name;
385

386
		pos = cache_name_pos(name, ntohs(create_ce_flags(len, stage)));
387 388 389 390
		if (pos >= 0) {
			retval = -1;
			if (ok_to_replace)
				break;
391
			remove_cache_entry_at(pos);
392 393 394 395 396 397
			continue;
		}

		/*
		 * Trivial optimization: if we find an entry that
		 * already matches the sub-directory, then we know
398
		 * we're ok, and we can exit.
399 400
		 */
		pos = -pos-1;
401
		while (pos < active_nr) {
402
			struct cache_entry *p = active_cache[pos];
403 404 405 406 407 408 409 410 411 412 413 414
			if ((ce_namelen(p) <= len) ||
			    (p->name[len] != '/') ||
			    memcmp(p->name, name, len))
				break; /* not our subdirectory */
			if (ce_stage(p) == stage)
				/* 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++;
415
		}
416
	}
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
	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.
 * 
 * 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.
 */
static int check_file_directory_conflict(const struct cache_entry *ce, int pos, int ok_to_replace)
{
	/*
	 * We check if the path is a sub-path of a subsequent pathname
	 * first, since removing those will not change the position
	 * in the array
	 */
	int retval = has_file_name(ce, pos, ok_to_replace);
	/*
	 * Then check if the path might have a clashing sub-directory
	 * before it.
	 */
	return retval + has_dir_name(ce, pos, ok_to_replace);
442 443
}

444
int add_cache_entry(struct cache_entry *ce, int option)
445 446
{
	int pos;
447 448
	int ok_to_add = option & ADD_CACHE_OK_TO_ADD;
	int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;
449
	int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;
Junio C Hamano's avatar
Junio C Hamano committed
450

451
	pos = cache_name_pos(ce->name, ntohs(ce->ce_flags));
452

Junio C Hamano's avatar
Junio C Hamano committed
453
	/* existing match? Just replace it. */
454
	if (pos >= 0) {
455
		active_cache_changed = 1;
456
		active_cache[pos] = ce;
457 458
		return 0;
	}
459
	pos = -pos-1;
460

461 462 463 464 465
	/*
	 * Inserting a merged entry ("stage 0") into the index
	 * will always replace all non-merged entries..
	 */
	if (pos < active_nr && ce_stage(ce) == 0) {
466
		while (ce_same_name(active_cache[pos], ce)) {
467
			ok_to_add = 1;
468
			if (!remove_cache_entry_at(pos))
469 470 471 472
				break;
		}
	}

473 474 475
	if (!ok_to_add)
		return -1;

Junio C Hamano's avatar
Junio C Hamano committed
476 477
	if (!skip_df_check &&
	    check_file_directory_conflict(ce, pos, ok_to_replace)) {
478 479
		if (!ok_to_replace)
			return -1;
480
		pos = cache_name_pos(ce->name, ntohs(ce->ce_flags));
481 482
		pos = -pos-1;
	}
483

484 485 486
	/* Make sure the array is big enough .. */
	if (active_nr == active_alloc) {
		active_alloc = alloc_nr(active_alloc);
487
		active_cache = xrealloc(active_cache, active_alloc * sizeof(struct cache_entry *));
488 489 490 491 492 493 494
	}

	/* Add it in.. */
	active_nr++;
	if (active_nr > pos)
		memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce));
	active_cache[pos] = ce;
495
	active_cache_changed = 1;
496 497 498
	return 0;
}

499 500 501 502 503
static int verify_hdr(struct cache_header *hdr, unsigned long size)
{
	SHA_CTX c;
	unsigned char sha1[20];

504
	if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
505
		return error("bad signature");
506 507
	if (hdr->hdr_version != htonl(2))
		return error("bad index version");
508
	SHA1_Init(&c);
509
	SHA1_Update(&c, hdr, size - 20);
510
	SHA1_Final(sha1, &c);
511 512
	if (memcmp(sha1, (void *)hdr + size - 20, 20))
		return error("bad index file sha1 signature");
513 514 515 516 517 518 519 520 521 522 523 524 525
	return 0;
}

int read_cache(void)
{
	int fd, i;
	struct stat st;
	unsigned long size, offset;
	void *map;
	struct cache_header *hdr;

	errno = EBUSY;
	if (active_cache)
526 527
		return active_nr;

528
	errno = ENOENT;
Junio C Hamano's avatar
Junio C Hamano committed
529
	index_file_timestamp = 0;
530
	fd = open(get_index_file(), O_RDONLY);
531 532 533 534 535
	if (fd < 0) {
		if (errno == ENOENT)
			return 0;
		die("index file open failed (%s)", strerror(errno));
	}
536

537
	size = 0; // avoid gcc warning
Pavel Roskin's avatar
Pavel Roskin committed
538
	map = MAP_FAILED;
539 540 541
	if (!fstat(fd, &st)) {
		size = st.st_size;
		errno = EINVAL;
542
		if (size >= sizeof(struct cache_header) + 20)
543
			map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
544 545
	}
	close(fd);
Pavel Roskin's avatar
Pavel Roskin committed
546
	if (map == MAP_FAILED)
547
		die("index file mmap failed (%s)", strerror(errno));
548 549 550 551 552

	hdr = map;
	if (verify_hdr(hdr, size) < 0)
		goto unmap;

553
	active_nr = ntohl(hdr->hdr_entries);
554
	active_alloc = alloc_nr(active_nr);
555
	active_cache = xcalloc(active_alloc, sizeof(struct cache_entry *));
556 557

	offset = sizeof(*hdr);
558
	for (i = 0; i < active_nr; i++) {
559 560 561 562
		struct cache_entry *ce = map + offset;
		offset = offset + ce_size(ce);
		active_cache[i] = ce;
	}
Junio C Hamano's avatar
Junio C Hamano committed
563
	index_file_timestamp = st.st_mtime;
564 565 566 567 568
	return active_nr;

unmap:
	munmap(map, size);
	errno = EINVAL;
569
	die("index file corrupt");
570 571
}

572
#define WRITE_BUFFER_SIZE 8192
573
static unsigned char write_buffer[WRITE_BUFFER_SIZE];
574 575
static unsigned long write_buffer_len;

576
static int ce_write(SHA_CTX *context, int fd, void *data, unsigned int len)
577 578 579 580 581 582 583 584 585
{
	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) {
586
			SHA1_Update(context, write_buffer, WRITE_BUFFER_SIZE);
587 588 589 590 591 592 593 594 595 596 597
			if (write(fd, write_buffer, WRITE_BUFFER_SIZE) != WRITE_BUFFER_SIZE)
				return -1;
			buffered = 0;
		}
		write_buffer_len = buffered;
		len -= partial;
		data += partial;
 	}
 	return 0;
}

598
static int ce_flush(SHA_CTX *context, int fd)
599 600
{
	unsigned int left = write_buffer_len;
601

602 603
	if (left) {
		write_buffer_len = 0;
604
		SHA1_Update(context, write_buffer, left);
605
	}
606

607 608 609 610 611 612 613
	/* Flush first if not enough space for SHA1 signature */
	if (left + 20 > WRITE_BUFFER_SIZE) {
		if (write(fd, write_buffer, left) != left)
			return -1;
		left = 0;
	}

614 615 616 617 618
	/* Append the SHA1 signature at the end */
	SHA1_Final(write_buffer + left, context);
	left += 20;
	if (write(fd, write_buffer, left) != left)
		return -1;
619 620 621
	return 0;
}

Junio C Hamano's avatar
Junio C Hamano committed
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
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)) {
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
		/* 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
		 *
		 * but it does not.  Whe the second update-index runs,
		 * 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
		 * obtain from the filesystem next time we stat("frotz"). 
		 *
		 * 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
662 663 664 665
		ce->ce_size = htonl(0);
	}
}

666 667 668 669
int write_cache(int newfd, struct cache_entry **cache, int entries)
{
	SHA_CTX c;
	struct cache_header hdr;
670 671 672 673 674
	int i, removed;

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

676
	hdr.hdr_signature = htonl(CACHE_SIGNATURE);
677
	hdr.hdr_version = htonl(2);
678
	hdr.hdr_entries = htonl(entries - removed);
679 680

	SHA1_Init(&c);
681
	if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0)
682 683 684 685
		return -1;

	for (i = 0; i < entries; i++) {
		struct cache_entry *ce = cache[i];
686 687
		if (!ce->ce_mode)
			continue;
Junio C Hamano's avatar
Junio C Hamano committed
688 689 690
		if (index_file_timestamp &&
		    index_file_timestamp <= ntohl(ce->ce_mtime.sec))
			ce_smudge_racily_clean_entry(ce);
691
		if (ce_write(&c, newfd, ce, ce_size(ce)) < 0)
692 693
			return -1;
	}
694
	return ce_flush(&c, newfd);
695
}