X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=read-cache.c;h=da2adf4612c3a1cb39fbb76e303302e9b7e1356b;hb=14242464811bff9e8d1af8eb33367a01480a18d0;hp=042b0c2107330c35731a4d42c9907e0b34ad5257;hpb=e8871e88adca0637eb0299a41d85400beac928bd;p=git.git diff --git a/read-cache.c b/read-cache.c index 042b0c21..da2adf46 100644 --- a/read-cache.c +++ b/read-cache.c @@ -6,283 +6,26 @@ #include #include "cache.h" -const char *sha1_file_directory = NULL; struct cache_entry **active_cache = NULL; -unsigned int active_nr = 0, active_alloc = 0; - -void usage(const char *err) -{ - fprintf(stderr, "usage: %s\n", err); - exit(1); -} - -static void report(const char *prefix, const char *err, va_list params) -{ - fputs(prefix, stderr); - vfprintf(stderr, err, params); - fputs("\n", stderr); -} - -void die(const char *err, ...) -{ - va_list params; - - va_start(params, err); - report("fatal: ", err, params); - va_end(params); - exit(1); -} - -int error(const char *err, ...) -{ - va_list params; - - va_start(params, err); - report("error: ", err, params); - va_end(params); - return -1; -} - - -static unsigned hexval(char c) -{ - if (c >= '0' && c <= '9') - return c - '0'; - if (c >= 'a' && c <= 'f') - return c - 'a' + 10; - if (c >= 'A' && c <= 'F') - return c - 'A' + 10; - return ~0; -} - -int get_sha1_hex(const char *hex, unsigned char *sha1) -{ - int i; - for (i = 0; i < 20; i++) { - unsigned int val = (hexval(hex[0]) << 4) | hexval(hex[1]); - if (val & ~0xff) - return -1; - *sha1++ = val; - hex += 2; - } - return 0; -} - -char * sha1_to_hex(const unsigned char *sha1) -{ - static char buffer[50]; - static const char hex[] = "0123456789abcdef"; - char *buf = buffer; - int i; - - for (i = 0; i < 20; i++) { - unsigned int val = *sha1++; - *buf++ = hex[val >> 4]; - *buf++ = hex[val & 0xf]; - } - return buffer; -} - -/* - * NOTE! This returns a statically allocated buffer, so you have to be - * careful about using it. Do a "strdup()" if you need to save the - * filename. - */ -char *sha1_file_name(const unsigned char *sha1) -{ - int i; - static char *name, *base; - - if (!base) { - char *sha1_file_directory = getenv(DB_ENVIRONMENT) ? : DEFAULT_DB_ENVIRONMENT; - int len = strlen(sha1_file_directory); - base = malloc(len + 60); - memcpy(base, sha1_file_directory, len); - memset(base+len, 0, 60); - base[len] = '/'; - base[len+3] = '/'; - name = base + len + 1; - } - for (i = 0; i < 20; i++) { - static char hex[] = "0123456789abcdef"; - unsigned int val = sha1[i]; - char *pos = name + i*2 + (i > 0); - *pos++ = hex[val >> 4]; - *pos = hex[val & 0xf]; - } - return base; -} - -int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size) -{ - unsigned char real_sha1[20]; - SHA_CTX c; - - SHA1_Init(&c); - SHA1_Update(&c, map, size); - SHA1_Final(real_sha1, &c); - return memcmp(sha1, real_sha1, 20) ? -1 : 0; -} - -void *map_sha1_file(const unsigned char *sha1, unsigned long *size) -{ - char *filename = sha1_file_name(sha1); - int fd = open(filename, O_RDONLY); - struct stat st; - void *map; - - if (fd < 0) { - perror(filename); - return NULL; - } - if (fstat(fd, &st) < 0) { - close(fd); - return NULL; - } - map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); - close(fd); - if (-1 == (int)(long)map) - return NULL; - *size = st.st_size; - return map; -} - -void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size) -{ - int ret, bytes; - z_stream stream; - char buffer[8192]; - char *buf; - - /* Get the data stream */ - memset(&stream, 0, sizeof(stream)); - stream.next_in = map; - stream.avail_in = mapsize; - stream.next_out = buffer; - stream.avail_out = sizeof(buffer); - - inflateInit(&stream); - ret = inflate(&stream, 0); - if (sscanf(buffer, "%10s %lu", type, size) != 2) - return NULL; - - bytes = strlen(buffer) + 1; - buf = malloc(*size); - if (!buf) - return NULL; - - memcpy(buf, buffer + bytes, stream.total_out - bytes); - bytes = stream.total_out - bytes; - if (bytes < *size && ret == Z_OK) { - stream.next_out = buf + bytes; - stream.avail_out = *size - bytes; - while (inflate(&stream, Z_FINISH) == Z_OK) - /* nothing */; - } - inflateEnd(&stream); - return buf; -} - -void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size) -{ - unsigned long mapsize; - void *map, *buf; - - map = map_sha1_file(sha1, &mapsize); - if (map) { - buf = unpack_sha1_file(map, mapsize, type, size); - munmap(map, mapsize); - return buf; - } - return NULL; -} - -int write_sha1_file(char *buf, unsigned len, unsigned char *returnsha1) -{ - int size; - char *compressed; - z_stream stream; - unsigned char sha1[20]; - SHA_CTX c; - - /* Set it up */ - memset(&stream, 0, sizeof(stream)); - deflateInit(&stream, Z_BEST_COMPRESSION); - size = deflateBound(&stream, len); - compressed = malloc(size); - - /* Compress it */ - stream.next_in = buf; - stream.avail_in = len; - stream.next_out = compressed; - stream.avail_out = size; - while (deflate(&stream, Z_FINISH) == Z_OK) - /* nothing */; - deflateEnd(&stream); - size = stream.total_out; - - /* Sha1.. */ - SHA1_Init(&c); - SHA1_Update(&c, compressed, size); - SHA1_Final(sha1, &c); - - if (write_sha1_buffer(sha1, compressed, size) < 0) - return -1; - if (returnsha1) - memcpy(returnsha1, sha1, 20); - return 0; -} - -static inline int collision_check(char *filename, void *buf, unsigned int size) -{ -#ifdef COLLISION_CHECK - void *map; - int fd = open(filename, O_RDONLY); - struct stat st; - int cmp; - - /* Unreadable object, or object went away? Strange. */ - if (fd < 0) - return -1; - - if (fstat(fd, &st) < 0 || size != st.st_size) - return -1; - - map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); - close(fd); - if (map == MAP_FAILED) - return -1; - cmp = memcmp(buf, map, size); - munmap(map, size); - if (cmp) - return -1; -#endif - return 0; -} - -int write_sha1_buffer(const unsigned char *sha1, void *buf, unsigned int size) -{ - char *filename = sha1_file_name(sha1); - int fd; - - fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666); - if (fd < 0) { - if (errno != EEXIST) - return -1; - if (collision_check(filename, buf, size)) - return error("SHA1 collision detected!" - " This is bad, bad, BAD!\a\n"); - return 0; - } - write(fd, buf, size); - close(fd); - return 0; -} +unsigned int active_nr = 0, active_alloc = 0, active_cache_changed = 0; int cache_match_stat(struct cache_entry *ce, struct stat *st) { unsigned int changed = 0; + switch (ntohl(ce->ce_mode) & S_IFMT) { + case S_IFREG: + changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0; + /* We consider only the owner x bit to be relevant for "mode changes" */ + if (0100 & (ntohl(ce->ce_mode) ^ st->st_mode)) + changed |= MODE_CHANGED; + 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)); + } if (ce->ce_mtime.sec != htonl(st->st_mtime)) changed |= MTIME_CHANGED; if (ce->ce_ctime.sec != htonl(st->st_ctime)) @@ -294,18 +37,15 @@ int cache_match_stat(struct cache_entry *ce, struct stat *st) * as long as it is in the inode cache you get right nsec * but after it gets flushed, you get zero nsec. */ - if (ce->ce_mtime.nsec != htonl(st->st_mtim.tv_nsec) + if (ce->ce_mtime.nsec != htonl(st->st_mtim.tv_nsec)) changed |= MTIME_CHANGED; - if (ce->ce_ctime.nsec != htonl(st->st_ctim.tv_nsec) + if (ce->ce_ctime.nsec != htonl(st->st_ctim.tv_nsec)) changed |= CTIME_CHANGED; #endif if (ce->ce_uid != htonl(st->st_uid) || ce->ce_gid != htonl(st->st_gid)) changed |= OWNER_CHANGED; - /* We consider only the owner x bit to be relevant for "mode changes" */ - if (0100 & (ntohl(ce->ce_mode) ^ st->st_mode)) - changed |= MODE_CHANGED; if (ce->ce_dev != htonl(st->st_dev) || ce->ce_ino != htonl(st->st_ino)) changed |= INODE_CHANGED; @@ -357,8 +97,9 @@ int cache_name_pos(const char *name, int namelen) } /* Remove entry, return true if there are more entries to go.. */ -static int remove_entry_at(int pos) +int remove_entry_at(int pos) { + active_cache_changed = 1; active_nr--; if (pos >= active_nr) return 0; @@ -376,20 +117,123 @@ int remove_file_from_cache(char *path) return 0; } -static int same_name(struct cache_entry *a, struct cache_entry *b) +int same_name(struct cache_entry *a, struct cache_entry *b) { int len = ce_namelen(a); return ce_namelen(b) == len && !memcmp(a->name, b->name, len); } -int add_cache_entry(struct cache_entry *ce, int ok_to_add) +/* 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 ok_to_replace) { - int pos; + int pos, replaced = 0; + const char *path = ce->name; + int namelen = strlen(path); + int stage = ce_stage(ce); + char *pathbuf = xmalloc(namelen + 1); + char *cp; + + memcpy(pathbuf, path, namelen + 1); + + /* + * We are inserting path/file. Do they have path registered at + * the same stage? We need to do this for all the levels of our + * subpath. + */ + cp = pathbuf; + while (1) { + char *ep = strchr(cp, '/'); + if (!ep) + break; + *ep = 0; /* first cut it at slash */ + pos = cache_name_pos(pathbuf, + htons(create_ce_flags(ep-cp, stage))); + if (0 <= pos) { + /* Our leading path component is registered as a file, + * and we are trying to make it a directory. This is + * bad. + */ + if (!ok_to_replace) { + free(pathbuf); + return -1; + } + fprintf(stderr, "removing file '%s' to replace it with a directory to create '%s'.\n", pathbuf, path); + remove_entry_at(pos); + replaced = 1; + } + *ep = '/'; /* then restore it and go downwards */ + cp = ep + 1; + } + free(pathbuf); + + /* Do we have an entry in the cache that makes our path a prefix + * of it? That is, are we creating a file where they already expect + * a directory there? + */ + pos = cache_name_pos(path, + htons(create_ce_flags(namelen, stage))); + + /* (0 <= pos) cannot happen because add_cache_entry() + * should have taken care of that case. + */ + pos = -pos-1; + + /* pos would point at an existing entry that would come immediately + * after our path. It could be the same as our path in higher stage, + * or different path but in a lower stage. + * + * E.g. when we are inserting path at stage 2, + * + * 1 path + * pos-> 3 path + * 2 path/file1 + * 3 path/file1 + * 2 path/file2 + * 2 patho + * + * We need to examine pos, ignore it because it is at different + * stage, examine next to find the path/file at stage 2, and + * complain. We need to do this until we are not the leading + * path of an existing entry anymore. + */ + + while (pos < active_nr) { + struct cache_entry *other = active_cache[pos]; + if (strncmp(other->name, path, namelen)) + break; /* it is not our "subdirectory" anymore */ + if ((ce_stage(other) == stage) && + other->name[namelen] == '/') { + if (!ok_to_replace) + return -1; + fprintf(stderr, "removing file '%s' under '%s' to be replaced with a file\n", other->name, path); + remove_entry_at(pos); + replaced = 1; + continue; /* cycle without updating pos */ + } + pos++; + } + return replaced; +} +int add_cache_entry(struct cache_entry *ce, int option) +{ + int pos; + int ok_to_add = option & ADD_CACHE_OK_TO_ADD; + int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; pos = cache_name_pos(ce->name, htons(ce->ce_flags)); /* existing match? Just replace it */ if (pos >= 0) { + active_cache_changed = 1; active_cache[pos] = ce; return 0; } @@ -402,7 +246,6 @@ int add_cache_entry(struct cache_entry *ce, int ok_to_add) if (pos < active_nr && ce_stage(ce) == 0) { while (same_name(active_cache[pos], ce)) { ok_to_add = 1; - active_nr--; if (!remove_entry_at(pos)) break; } @@ -411,10 +254,17 @@ int add_cache_entry(struct cache_entry *ce, int ok_to_add) if (!ok_to_add) return -1; + if (check_file_directory_conflict(ce, ok_to_replace)) { + if (!ok_to_replace) + return -1; + pos = cache_name_pos(ce->name, htons(ce->ce_flags)); + pos = -pos-1; + } + /* Make sure the array is big enough .. */ if (active_nr == active_alloc) { active_alloc = alloc_nr(active_alloc); - active_cache = realloc(active_cache, active_alloc * sizeof(struct cache_entry *)); + active_cache = xrealloc(active_cache, active_alloc * sizeof(struct cache_entry *)); } /* Add it in.. */ @@ -422,6 +272,7 @@ int add_cache_entry(struct cache_entry *ce, int ok_to_add) if (active_nr > pos) memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce)); active_cache[pos] = ce; + active_cache_changed = 1; return 0; } @@ -432,14 +283,13 @@ static int verify_hdr(struct cache_header *hdr, unsigned long size) if (hdr->hdr_signature != htonl(CACHE_SIGNATURE)) return error("bad signature"); - if (hdr->hdr_version != htonl(1)) - return error("bad version"); + if (hdr->hdr_version != htonl(2)) + return error("bad index version"); SHA1_Init(&c); - SHA1_Update(&c, hdr, offsetof(struct cache_header, sha1)); - SHA1_Update(&c, hdr+1, size - sizeof(*hdr)); + SHA1_Update(&c, hdr, size - 20); SHA1_Final(sha1, &c); - if (memcmp(sha1, hdr->sha1, 20)) - return error("bad header sha1"); + if (memcmp(sha1, (void *)hdr + size - 20, 20)) + return error("bad index file sha1 signature"); return 0; } @@ -455,12 +305,7 @@ int read_cache(void) if (active_cache) return error("more than one cachefile"); errno = ENOENT; - sha1_file_directory = getenv(DB_ENVIRONMENT); - if (!sha1_file_directory) - sha1_file_directory = DEFAULT_DB_ENVIRONMENT; - if (access(sha1_file_directory, X_OK) < 0) - return error("no access to SHA1 file directory"); - fd = open(".git/index", O_RDONLY); + fd = open(get_index_file(), O_RDONLY); if (fd < 0) return (errno == ENOENT) ? 0 : error("open failed"); @@ -469,8 +314,8 @@ int read_cache(void) if (!fstat(fd, &st)) { size = st.st_size; errno = EINVAL; - if (size >= sizeof(struct cache_header)) - map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); + if (size >= sizeof(struct cache_header) + 20) + map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); } close(fd); if (-1 == (int)(long)map) @@ -498,6 +343,49 @@ unmap: return error("verify header failed"); } +#define WRITE_BUFFER_SIZE 8192 +static char write_buffer[WRITE_BUFFER_SIZE]; +static unsigned long write_buffer_len; + +static int ce_write(SHA_CTX *context, int fd, void *data, unsigned int len) +{ + 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) { + SHA1_Update(context, write_buffer, WRITE_BUFFER_SIZE); + 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; +} + +static int ce_flush(SHA_CTX *context, int fd) +{ + unsigned int left = write_buffer_len; + + if (left) { + write_buffer_len = 0; + SHA1_Update(context, write_buffer, left); + } + + /* Append the SHA1 signature at the end */ + SHA1_Final(write_buffer + left, context); + left += 20; + if (write(fd, write_buffer, left) != left) + return -1; + return 0; +} + int write_cache(int newfd, struct cache_entry **cache, int entries) { SHA_CTX c; @@ -505,26 +393,17 @@ int write_cache(int newfd, struct cache_entry **cache, int entries) int i; hdr.hdr_signature = htonl(CACHE_SIGNATURE); - hdr.hdr_version = htonl(1); + hdr.hdr_version = htonl(2); hdr.hdr_entries = htonl(entries); SHA1_Init(&c); - SHA1_Update(&c, &hdr, offsetof(struct cache_header, sha1)); - for (i = 0; i < entries; i++) { - struct cache_entry *ce = cache[i]; - int size = ce_size(ce); - SHA1_Update(&c, ce, size); - } - SHA1_Final(hdr.sha1, &c); - - if (write(newfd, &hdr, sizeof(hdr)) != sizeof(hdr)) + if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0) return -1; for (i = 0; i < entries; i++) { struct cache_entry *ce = cache[i]; - int size = ce_size(ce); - if (write(newfd, ce, size) != size) + if (ce_write(&c, newfd, ce, ce_size(ce)) < 0) return -1; } - return 0; + return ce_flush(&c, newfd); }