2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
8 struct cache_entry
**active_cache
= NULL
;
9 static time_t index_file_timestamp
;
10 unsigned int active_nr
= 0, active_alloc
= 0, active_cache_changed
= 0;
13 * This only updates the "non-critical" parts of the directory
14 * cache, ie the parts that aren't tracked by GIT, and only used
15 * to validate the cache.
17 void fill_stat_cache_info(struct cache_entry
*ce
, struct stat
*st
)
19 ce
->ce_ctime
.sec
= htonl(st
->st_ctime
);
20 ce
->ce_mtime
.sec
= htonl(st
->st_mtime
);
22 ce
->ce_ctime
.nsec
= htonl(st
->st_ctim
.tv_nsec
);
23 ce
->ce_mtime
.nsec
= htonl(st
->st_mtim
.tv_nsec
);
25 ce
->ce_dev
= htonl(st
->st_dev
);
26 ce
->ce_ino
= htonl(st
->st_ino
);
27 ce
->ce_uid
= htonl(st
->st_uid
);
28 ce
->ce_gid
= htonl(st
->st_gid
);
29 ce
->ce_size
= htonl(st
->st_size
);
32 ce
->ce_flags
|= htons(CE_VALID
);
35 static int ce_compare_data(struct cache_entry
*ce
, struct stat
*st
)
38 int fd
= open(ce
->name
, O_RDONLY
);
41 unsigned char sha1
[20];
42 if (!index_fd(sha1
, fd
, st
, 0, NULL
))
43 match
= memcmp(sha1
, ce
->sha1
, 20);
49 static int ce_compare_link(struct cache_entry
*ce
, unsigned long expected_size
)
58 target
= xmalloc(expected_size
);
59 len
= readlink(ce
->name
, target
, expected_size
);
60 if (len
!= expected_size
) {
64 buffer
= read_sha1_file(ce
->sha1
, type
, &size
);
69 if (size
== expected_size
)
70 match
= memcmp(buffer
, target
, size
);
76 static int ce_modified_check_fs(struct cache_entry
*ce
, struct stat
*st
)
78 switch (st
->st_mode
& S_IFMT
) {
80 if (ce_compare_data(ce
, st
))
84 if (ce_compare_link(ce
, st
->st_size
))
93 static int ce_match_stat_basic(struct cache_entry
*ce
, struct stat
*st
)
95 unsigned int changed
= 0;
97 switch (ntohl(ce
->ce_mode
) & S_IFMT
) {
99 changed
|= !S_ISREG(st
->st_mode
) ? TYPE_CHANGED
: 0;
100 /* We consider only the owner x bit to be relevant for
103 if (trust_executable_bit
&&
104 (0100 & (ntohl(ce
->ce_mode
) ^ st
->st_mode
)))
105 changed
|= MODE_CHANGED
;
108 changed
|= !S_ISLNK(st
->st_mode
) ? TYPE_CHANGED
: 0;
111 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 if (ce
->ce_ctime
.sec
!= htonl(st
->st_ctime
))
116 changed
|= CTIME_CHANGED
;
120 * nsec seems unreliable - not all filesystems support it, so
121 * as long as it is in the inode cache you get right nsec
122 * 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
;
130 if (ce
->ce_uid
!= htonl(st
->st_uid
) ||
131 ce
->ce_gid
!= htonl(st
->st_gid
))
132 changed
|= OWNER_CHANGED
;
133 if (ce
->ce_ino
!= htonl(st
->st_ino
))
134 changed
|= INODE_CHANGED
;
138 * st_dev breaks on network filesystems where different
139 * clients will have different views of what "device"
140 * the filesystem is on
142 if (ce
->ce_dev
!= htonl(st
->st_dev
))
143 changed
|= INODE_CHANGED
;
146 if (ce
->ce_size
!= htonl(st
->st_size
))
147 changed
|= DATA_CHANGED
;
152 int ce_match_stat(struct cache_entry
*ce
, struct stat
*st
, int ignore_valid
)
154 unsigned int changed
;
157 * If it's marked as always valid in the index, it's
158 * valid whatever the checked-out copy says.
160 if (!ignore_valid
&& (ce
->ce_flags
& htons(CE_VALID
)))
163 changed
= ce_match_stat_basic(ce
, st
);
166 * Within 1 second of this sequence:
167 * echo xyzzy >file && git-update-index --add file
168 * running this command:
170 * would give a falsely clean cache entry. The mtime and
171 * length match the cache, and other stat fields do not change.
173 * We could detect this at update-index time (the cache entry
174 * being registered/updated records the same time as "now")
175 * and delay the return from git-update-index, but that would
176 * effectively mean we can make at most one commit per second,
177 * which is not acceptable. Instead, we check cache entries
178 * whose mtime are the same as the index file timestamp more
179 * carefully than others.
182 index_file_timestamp
&&
183 index_file_timestamp
<= ntohl(ce
->ce_mtime
.sec
))
184 changed
|= ce_modified_check_fs(ce
, st
);
189 int ce_modified(struct cache_entry
*ce
, struct stat
*st
, int really
)
191 int changed
, changed_fs
;
192 changed
= ce_match_stat(ce
, st
, really
);
196 * If the mode or type has changed, there's no point in trying
197 * to refresh the entry - it's not going to match
199 if (changed
& (MODE_CHANGED
| TYPE_CHANGED
))
202 /* Immediately after read-tree or update-index --cacheinfo,
203 * the length field is zero. For other cases the ce_size
204 * should match the SHA1 recorded in the index entry.
206 if ((changed
& DATA_CHANGED
) && ce
->ce_size
!= htonl(0))
209 changed_fs
= ce_modified_check_fs(ce
, st
);
211 return changed
| changed_fs
;
215 int base_name_compare(const char *name1
, int len1
, int mode1
,
216 const char *name2
, int len2
, int mode2
)
218 unsigned char c1
, c2
;
219 int len
= len1
< len2
? len1
: len2
;
222 cmp
= memcmp(name1
, name2
, len
);
227 if (!c1
&& S_ISDIR(mode1
))
229 if (!c2
&& S_ISDIR(mode2
))
231 return (c1
< c2
) ? -1 : (c1
> c2
) ? 1 : 0;
234 int cache_name_compare(const char *name1
, int flags1
, const char *name2
, int flags2
)
236 int len1
= flags1
& CE_NAMEMASK
;
237 int len2
= flags2
& CE_NAMEMASK
;
238 int len
= len1
< len2
? len1
: len2
;
241 cmp
= memcmp(name1
, name2
, len
);
250 flags1
&= CE_STAGEMASK
;
251 flags2
&= CE_STAGEMASK
;
260 int cache_name_pos(const char *name
, int namelen
)
266 while (last
> first
) {
267 int next
= (last
+ first
) >> 1;
268 struct cache_entry
*ce
= active_cache
[next
];
269 int cmp
= cache_name_compare(name
, namelen
, ce
->name
, ntohs(ce
->ce_flags
));
281 /* Remove entry, return true if there are more entries to go.. */
282 int remove_cache_entry_at(int pos
)
284 active_cache_changed
= 1;
286 if (pos
>= active_nr
)
288 memmove(active_cache
+ pos
, active_cache
+ pos
+ 1, (active_nr
- pos
) * sizeof(struct cache_entry
*));
292 int remove_file_from_cache(const char *path
)
294 int pos
= cache_name_pos(path
, strlen(path
));
297 while (pos
< active_nr
&& !strcmp(active_cache
[pos
]->name
, path
))
298 remove_cache_entry_at(pos
);
302 int ce_same_name(struct cache_entry
*a
, struct cache_entry
*b
)
304 int len
= ce_namelen(a
);
305 return ce_namelen(b
) == len
&& !memcmp(a
->name
, b
->name
, len
);
308 int ce_path_match(const struct cache_entry
*ce
, const char **pathspec
)
310 const char *match
, *name
;
316 len
= ce_namelen(ce
);
318 while ((match
= *pathspec
++) != NULL
) {
319 int matchlen
= strlen(match
);
322 if (memcmp(name
, match
, matchlen
))
324 if (matchlen
&& name
[matchlen
-1] == '/')
326 if (name
[matchlen
] == '/' || !name
[matchlen
])
335 * Do we have another file that has the beginning components being a
336 * proper superset of the name we're trying to add?
338 static int has_file_name(const struct cache_entry
*ce
, int pos
, int ok_to_replace
)
341 int len
= ce_namelen(ce
);
342 int stage
= ce_stage(ce
);
343 const char *name
= ce
->name
;
345 while (pos
< active_nr
) {
346 struct cache_entry
*p
= active_cache
[pos
++];
348 if (len
>= ce_namelen(p
))
350 if (memcmp(name
, p
->name
, len
))
352 if (ce_stage(p
) != stage
)
354 if (p
->name
[len
] != '/')
359 remove_cache_entry_at(--pos
);
365 * Do we have another file with a pathname that is a proper
366 * subset of the name we're trying to add?
368 static int has_dir_name(const struct cache_entry
*ce
, int pos
, int ok_to_replace
)
371 int stage
= ce_stage(ce
);
372 const char *name
= ce
->name
;
373 const char *slash
= name
+ ce_namelen(ce
);
381 if (slash
<= ce
->name
)
386 pos
= cache_name_pos(name
, ntohs(create_ce_flags(len
, stage
)));
391 remove_cache_entry_at(pos
);
396 * Trivial optimization: if we find an entry that
397 * already matches the sub-directory, then we know
398 * we're ok, and we can exit.
401 while (pos
< active_nr
) {
402 struct cache_entry
*p
= active_cache
[pos
];
403 if ((ce_namelen(p
) <= len
) ||
404 (p
->name
[len
] != '/') ||
405 memcmp(p
->name
, name
, len
))
406 break; /* not our subdirectory */
407 if (ce_stage(p
) == stage
)
408 /* p is at the same stage as our entry, and
409 * is a subdirectory of what we are looking
410 * at, so we cannot have conflicts at our
411 * level or anything shorter.
420 /* We may be in a situation where we already have path/file and path
421 * is being added, or we already have path and path/file is being
422 * added. Either one would result in a nonsense tree that has path
423 * twice when git-write-tree tries to write it out. Prevent it.
425 * If ok-to-replace is specified, we remove the conflicting entries
426 * from the cache so the caller should recompute the insert position.
427 * When this happens, we return non-zero.
429 static int check_file_directory_conflict(const struct cache_entry
*ce
, int pos
, int ok_to_replace
)
432 * We check if the path is a sub-path of a subsequent pathname
433 * first, since removing those will not change the position
436 int retval
= has_file_name(ce
, pos
, ok_to_replace
);
438 * Then check if the path might have a clashing sub-directory
441 return retval
+ has_dir_name(ce
, pos
, ok_to_replace
);
444 int add_cache_entry(struct cache_entry
*ce
, int option
)
447 int ok_to_add
= option
& ADD_CACHE_OK_TO_ADD
;
448 int ok_to_replace
= option
& ADD_CACHE_OK_TO_REPLACE
;
449 int skip_df_check
= option
& ADD_CACHE_SKIP_DFCHECK
;
451 pos
= cache_name_pos(ce
->name
, ntohs(ce
->ce_flags
));
453 /* existing match? Just replace it. */
455 active_cache_changed
= 1;
456 active_cache
[pos
] = ce
;
462 * Inserting a merged entry ("stage 0") into the index
463 * will always replace all non-merged entries..
465 if (pos
< active_nr
&& ce_stage(ce
) == 0) {
466 while (ce_same_name(active_cache
[pos
], ce
)) {
468 if (!remove_cache_entry_at(pos
))
476 if (!skip_df_check
&&
477 check_file_directory_conflict(ce
, pos
, ok_to_replace
)) {
480 pos
= cache_name_pos(ce
->name
, ntohs(ce
->ce_flags
));
484 /* Make sure the array is big enough .. */
485 if (active_nr
== active_alloc
) {
486 active_alloc
= alloc_nr(active_alloc
);
487 active_cache
= xrealloc(active_cache
, active_alloc
* sizeof(struct cache_entry
*));
493 memmove(active_cache
+ pos
+ 1, active_cache
+ pos
, (active_nr
- pos
- 1) * sizeof(ce
));
494 active_cache
[pos
] = ce
;
495 active_cache_changed
= 1;
499 static int verify_hdr(struct cache_header
*hdr
, unsigned long size
)
502 unsigned char sha1
[20];
504 if (hdr
->hdr_signature
!= htonl(CACHE_SIGNATURE
))
505 return error("bad signature");
506 if (hdr
->hdr_version
!= htonl(2))
507 return error("bad index version");
509 SHA1_Update(&c
, hdr
, size
- 20);
510 SHA1_Final(sha1
, &c
);
511 if (memcmp(sha1
, (void *)hdr
+ size
- 20, 20))
512 return error("bad index file sha1 signature");
520 unsigned long size
, offset
;
522 struct cache_header
*hdr
;
529 index_file_timestamp
= 0;
530 fd
= open(get_index_file(), O_RDONLY
);
534 die("index file open failed (%s)", strerror(errno
));
537 size
= 0; // avoid gcc warning
539 if (!fstat(fd
, &st
)) {
542 if (size
>= sizeof(struct cache_header
) + 20)
543 map
= mmap(NULL
, size
, PROT_READ
| PROT_WRITE
, MAP_PRIVATE
, fd
, 0);
546 if (map
== MAP_FAILED
)
547 die("index file mmap failed (%s)", strerror(errno
));
550 if (verify_hdr(hdr
, size
) < 0)
553 active_nr
= ntohl(hdr
->hdr_entries
);
554 active_alloc
= alloc_nr(active_nr
);
555 active_cache
= calloc(active_alloc
, sizeof(struct cache_entry
*));
557 offset
= sizeof(*hdr
);
558 for (i
= 0; i
< active_nr
; i
++) {
559 struct cache_entry
*ce
= map
+ offset
;
560 offset
= offset
+ ce_size(ce
);
561 active_cache
[i
] = ce
;
563 index_file_timestamp
= st
.st_mtime
;
569 die("index file corrupt");
572 #define WRITE_BUFFER_SIZE 8192
573 static unsigned char write_buffer
[WRITE_BUFFER_SIZE
];
574 static unsigned long write_buffer_len
;
576 static int ce_write(SHA_CTX
*context
, int fd
, void *data
, unsigned int len
)
579 unsigned int buffered
= write_buffer_len
;
580 unsigned int partial
= WRITE_BUFFER_SIZE
- buffered
;
583 memcpy(write_buffer
+ buffered
, data
, partial
);
585 if (buffered
== WRITE_BUFFER_SIZE
) {
586 SHA1_Update(context
, write_buffer
, WRITE_BUFFER_SIZE
);
587 if (write(fd
, write_buffer
, WRITE_BUFFER_SIZE
) != WRITE_BUFFER_SIZE
)
591 write_buffer_len
= buffered
;
598 static int ce_flush(SHA_CTX
*context
, int fd
)
600 unsigned int left
= write_buffer_len
;
603 write_buffer_len
= 0;
604 SHA1_Update(context
, write_buffer
, left
);
607 /* Flush first if not enough space for SHA1 signature */
608 if (left
+ 20 > WRITE_BUFFER_SIZE
) {
609 if (write(fd
, write_buffer
, left
) != left
)
614 /* Append the SHA1 signature at the end */
615 SHA1_Final(write_buffer
+ left
, context
);
617 if (write(fd
, write_buffer
, left
) != left
)
622 static void ce_smudge_racily_clean_entry(struct cache_entry
*ce
)
625 * The only thing we care about in this function is to smudge the
626 * falsely clean entry due to touch-update-touch race, so we leave
627 * everything else as they are. We are called for entries whose
628 * ce_mtime match the index file mtime.
632 if (lstat(ce
->name
, &st
) < 0)
634 if (ce_match_stat_basic(ce
, &st
))
636 if (ce_modified_check_fs(ce
, &st
)) {
637 /* This is "racily clean"; smudge it. Note that this
638 * is a tricky code. At first glance, it may appear
639 * that it can break with this sequence:
641 * $ echo xyzzy >frotz
642 * $ git-update-index --add frotz
645 * $ echo filfre >nitfol
646 * $ git-update-index --add nitfol
648 * but it does not. Whe the second update-index runs,
649 * it notices that the entry "frotz" has the same timestamp
650 * as index, and if we were to smudge it by resetting its
651 * size to zero here, then the object name recorded
652 * in index is the 6-byte file but the cached stat information
653 * becomes zero --- which would then match what we would
654 * obtain from the filesystem next time we stat("frotz").
656 * However, the second update-index, before calling
657 * this function, notices that the cached size is 6
658 * bytes and what is on the filesystem is an empty
659 * file, and never calls us, so the cached size information
660 * for "frotz" stays 6 which does not match the filesystem.
662 ce
->ce_size
= htonl(0);
666 int write_cache(int newfd
, struct cache_entry
**cache
, int entries
)
669 struct cache_header hdr
;
672 for (i
= removed
= 0; i
< entries
; i
++)
673 if (!cache
[i
]->ce_mode
)
676 hdr
.hdr_signature
= htonl(CACHE_SIGNATURE
);
677 hdr
.hdr_version
= htonl(2);
678 hdr
.hdr_entries
= htonl(entries
- removed
);
681 if (ce_write(&c
, newfd
, &hdr
, sizeof(hdr
)) < 0)
684 for (i
= 0; i
< entries
; i
++) {
685 struct cache_entry
*ce
= cache
[i
];
688 if (index_file_timestamp
&&
689 index_file_timestamp
<= ntohl(ce
->ce_mtime
.sec
))
690 ce_smudge_racily_clean_entry(ce
);
691 if (ce_write(&c
, newfd
, ce
, ce_size(ce
)) < 0)
694 return ce_flush(&c
, newfd
);