Add write_or_die(), a helper function

diff --git a/read-cache.c b/read-cache.c
index ec4dd5ae6c96c8114b75fdec415b2af816518e21..b6982eac416fe765e1a570cdb25298e83264c81e 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -18,16 +18,16 @@
 #define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) )
 #define CACHE_EXT_TREE 0x54524545      /* "TREE" */
 
-struct cache_entry **active_cache = NULL;
+struct cache_entry **active_cache;
 static time_t index_file_timestamp;
-unsigned int active_nr = 0, active_alloc = 0, active_cache_changed = 0;
+unsigned int active_nr, active_alloc, active_cache_changed;
 
-struct cache_tree *active_cache_tree = NULL;
+struct cache_tree *active_cache_tree;
 
-int cache_errno = 0;
+int cache_errno;
 
-static void *cache_mmap = NULL;
-static size_t cache_mmap_size = 0;
+static void *cache_mmap;
+static size_t cache_mmap_size;
 
 /*
  * This only updates the "non-critical" parts of the directory
@@ -60,7 +60,7 @@ static int ce_compare_data(struct cache_entry *ce, struct stat *st)
        if (fd >= 0) {
                unsigned char sha1[20];
                if (!index_fd(sha1, fd, st, 0, NULL))
-                       match = memcmp(sha1, ce->sha1, 20);
+                       match = hashcmp(sha1, ce->sha1);
                /* index_fd() closed the file descriptor already */
        }
        return match;
@@ -169,9 +169,11 @@ static int ce_match_stat_basic(struct cache_entry *ce, struct stat *st)
        return changed;
 }
 
-int ce_match_stat(struct cache_entry *ce, struct stat *st, int ignore_valid)
+int ce_match_stat(struct cache_entry *ce, struct stat *st, int options)
 {
        unsigned int changed;
+       int ignore_valid = options & 01;
+       int assume_racy_is_modified = options & 02;
 
        /*
         * If it's marked as always valid in the index, it's
@@ -200,8 +202,12 @@ int ce_match_stat(struct cache_entry *ce, struct stat *st, int ignore_valid)
         */
        if (!changed &&
            index_file_timestamp &&
-           index_file_timestamp <= ntohl(ce->ce_mtime.sec))
-               changed |= ce_modified_check_fs(ce, st);
+           index_file_timestamp <= ntohl(ce->ce_mtime.sec)) {
+               if (assume_racy_is_modified)
+                       changed |= DATA_CHANGED;
+               else
+                       changed |= ce_modified_check_fs(ce, st);
+       }
 
        return changed;
 }
@@ -738,7 +744,7 @@ static int verify_hdr(struct cache_header *hdr, unsigned long size)
        SHA1_Init(&c);
        SHA1_Update(&c, hdr, size - 20);
        SHA1_Final(sha1, &c);
-       if (memcmp(sha1, (char *) hdr + size - 20, 20))
+       if (hashcmp(sha1, (unsigned char *)hdr + size - 20))
                return error("bad index file sha1 signature");
        return 0;
 }
@@ -953,9 +959,7 @@ int write_cache(int newfd, struct cache_entry **cache, int entries)
 {
        SHA_CTX c;
        struct cache_header hdr;
-       int i, removed, recent;
-       struct stat st;
-       time_t now;
+       int i, removed;
 
        for (i = removed = 0; i < entries; i++)
                if (!cache[i]->ce_mode)
@@ -993,54 +997,5 @@ int write_cache(int newfd, struct cache_entry **cache, int entries)
                        return -1;
                }
        }
-
-       /*
-        * To prevent later ce_match_stat() from always falling into
-        * check_fs(), if we have too many entries that can trigger
-        * racily clean check, we are better off delaying the return.
-        * We arbitrarily say if more than 20 paths or 25% of total
-        * paths are very new, we delay the return until the index
-        * file gets a new timestamp.
-        *
-        * NOTE! NOTE! NOTE!
-        *
-        * This assumes that nobody is touching the working tree while
-        * we are updating the index.
-        */
-
-       /* Make sure that the new index file has st_mtime
-        * that is current enough -- ce_write() batches the data
-        * so it might not have written anything yet.
-        */
-       ce_write_flush(&c, newfd);
-
-       now = fstat(newfd, &st) ? 0 : st.st_mtime;
-       if (now) {
-               recent = 0;
-               for (i = 0; i < entries; i++) {
-                       struct cache_entry *ce = cache[i];
-                       time_t entry_time = (time_t) ntohl(ce->ce_mtime.sec);
-                       if (!ce->ce_mode)
-                               continue;
-                       if (now && now <= entry_time)
-                               recent++;
-               }
-               if (20 < recent && entries <= recent * 4) {
-#if 0
-                       fprintf(stderr, "entries    %d\n", entries);
-                       fprintf(stderr, "recent     %d\n", recent);
-                       fprintf(stderr, "now        %lu\n", now);
-#endif
-                       while (!fstat(newfd, &st) && st.st_mtime <= now) {
-                               off_t where = lseek(newfd, 0, SEEK_CUR);
-                               sleep(1);
-                               if ((where == (off_t) -1) ||
-                                   (write(newfd, "", 1) != 1) ||
-                                   (lseek(newfd, -1, SEEK_CUR) != where) ||
-                                   ftruncate(newfd, where))
-                                       break;
-                       }
-               }
-       }
        return ce_flush(&c, newfd);
 }