X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=fsck-cache.c;h=916792417d55b16124f2c352bfc1efcb8461ebc0;hb=175011320690864d1483e7eec19da7f71d14dad7;hp=5db07e0f6dbac6b41f31d6ef308dfc7a31915136;hpb=ae7c0c92c0713307986bcd1fb54fa0694aae962a;p=git.git diff --git a/fsck-cache.c b/fsck-cache.c index 5db07e0f..91679241 100644 --- a/fsck-cache.c +++ b/fsck-cache.c @@ -25,7 +25,8 @@ static void check_connectivity(void) struct object_list *refs; if (!obj->parsed) { - printf("missing %s %s\n", obj->type, sha1_to_hex(obj->sha1)); + printf("missing %s %s\n", + obj->type, sha1_to_hex(obj->sha1)); continue; } @@ -38,12 +39,9 @@ static void check_connectivity(void) refs->item->type, sha1_to_hex(refs->item->sha1)); } - /* Don't bother with tag reachability. */ - if (obj->type == tag_type) - continue; - if (show_unreachable && !(obj->flags & REACHABLE)) { - printf("unreachable %s %s\n", obj->type, sha1_to_hex(obj->sha1)); + printf("unreachable %s %s\n", + obj->type, sha1_to_hex(obj->sha1)); continue; } @@ -62,6 +60,9 @@ static void check_connectivity(void) * So a directory called "a" is ordered _after_ a file * called "a.c", because "a/" sorts after "a.c". */ +#define TREE_UNORDERED (-1) +#define TREE_HAS_DUPS (-2) + static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b) { int len1 = strlen(a->name); @@ -74,7 +75,7 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b) if (cmp < 0) return 0; if (cmp > 0) - return -1; + return TREE_UNORDERED; /* * Ok, the first characters are the same. @@ -83,11 +84,18 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b) */ c1 = a->name[len]; c2 = b->name[len]; + if (!c1 && !c2) + /* + * git-write-tree used to write out a nonsense tree that has + * entries with the same name, one blob and one tree. Make + * sure we do not have duplicate entries. + */ + return TREE_HAS_DUPS; if (!c1 && a->directory) c1 = '/'; if (!c2 && b->directory) c2 = '/'; - return c1 < c2 ? 0 : -1; + return c1 < c2 ? 0 : TREE_UNORDERED; } static int fsck_tree(struct tree *item) @@ -100,11 +108,41 @@ static int fsck_tree(struct tree *item) if (strchr(entry->name, '/')) has_full_path = 1; + switch (entry->mode) { + /* + * Standard modes.. + */ + case S_IFREG | 0755: + case S_IFREG | 0644: + case S_IFLNK: + case S_IFDIR: + break; + /* + * This is nonstandard, but we had a few of these + * early on when we honored the full set of mode + * bits.. + */ + case S_IFREG | 0664: + break; + default: + printf("tree %s has entry %o %s\n", + sha1_to_hex(item->object.sha1), + entry->mode, entry->name); + } + if (last) { - if (verify_ordered(last, entry) < 0) { + switch (verify_ordered(last, entry)) { + case TREE_UNORDERED: fprintf(stderr, "tree %s not ordered\n", sha1_to_hex(item->object.sha1)); return -1; + case TREE_HAS_DUPS: + fprintf(stderr, "tree %s has duplicate entries for '%s'\n", + sha1_to_hex(item->object.sha1), + entry->name); + return -1; + default: + break; } } @@ -112,7 +150,7 @@ static int fsck_tree(struct tree *item) } if (has_full_path) { - fprintf(stderr, "warning: fsck-cache: tree %s " + fprintf(stderr, "warning: git-fsck-cache: tree %s " "has full pathnames in it\n", sha1_to_hex(item->object.sha1)); } @@ -122,6 +160,8 @@ static int fsck_tree(struct tree *item) static int fsck_commit(struct commit *commit) { + free(commit->buffer); + commit->buffer = NULL; if (!commit->tree) return -1; if (!commit->parents && show_root) @@ -256,6 +296,76 @@ static int fsck_dir(int i, char *path) return 0; } +static int read_sha1_reference(const char *path) +{ + char hexname[60]; + unsigned char sha1[20]; + int fd = open(path, O_RDONLY), len; + struct object *obj; + + if (fd < 0) + return -1; + + len = read(fd, hexname, sizeof(hexname)); + close(fd); + if (len < 40) + return -1; + + if (get_sha1_hex(hexname, sha1) < 0) + return -1; + + obj = lookup_object(sha1); + if (!obj) + return error("%s: invalid sha1 pointer %.40s", path, hexname); + + obj->used = 1; + mark_reachable(obj, REACHABLE); + return 0; +} + +static int find_file_objects(const char *base, const char *name) +{ + int baselen = strlen(base); + int namelen = strlen(name); + char *path = xmalloc(baselen + namelen + 2); + struct stat st; + + memcpy(path, base, baselen); + path[baselen] = '/'; + memcpy(path + baselen + 1, name, namelen+1); + if (stat(path, &st) < 0) + return 0; + + /* + * Recurse into directories + */ + if (S_ISDIR(st.st_mode)) { + int count = 0; + DIR *dir = opendir(path); + if (dir) { + struct dirent *de; + while ((de = readdir(dir)) != NULL) { + if (de->d_name[0] == '.') + continue; + count += find_file_objects(path, de->d_name); + } + closedir(dir); + } + return count; + } + if (S_ISREG(st.st_mode)) + return read_sha1_reference(path) == 0; + return 0; +} + +static void get_default_heads(void) +{ + char *git_dir = gitenv(GIT_DIR_ENVIRONMENT) ? : DEFAULT_GIT_DIR_ENVIRONMENT; + int count = find_file_objects(git_dir, "refs"); + if (!count) + die("No default references"); +} + int main(int argc, char **argv) { int i, heads; @@ -281,10 +391,10 @@ int main(int argc, char **argv) continue; } if (*arg == '-') - usage("fsck-cache [--tags] [[--unreachable] [--cache] *]"); + usage("git-fsck-cache [--tags] [[--unreachable] [--cache] *]"); } - sha1_dir = getenv(DB_ENVIRONMENT) ? : DEFAULT_DB_ENVIRONMENT; + sha1_dir = get_object_directory(); for (i = 0; i < 256; i++) { static char dir[4096]; sprintf(dir, "%s/%02x", sha1_dir, i); @@ -300,14 +410,12 @@ int main(int argc, char **argv) continue; if (!get_sha1(arg, head_sha1)) { - struct commit *commit = lookup_commit(head_sha1); - struct object *obj; + struct object *obj = lookup_object(head_sha1); - /* Error is printed by lookup_commit(). */ - if (!commit) + /* Error is printed by lookup_object(). */ + if (!obj) continue; - obj = &commit->object; obj->used = 1; mark_reachable(obj, REACHABLE); heads++; @@ -316,6 +424,16 @@ int main(int argc, char **argv) error("expected sha1, got %s", arg); } + /* + * If we've not been given any explicit head information, do the + * default ones from .git/refs. We also consider the index file + * in this case (ie this implies --cache). + */ + if (!heads) { + get_default_heads(); + keep_cache_objects = 1; + } + if (keep_cache_objects) { int i; read_cache(); @@ -330,15 +448,6 @@ int main(int argc, char **argv) } } - if (!heads && !keep_cache_objects) { - if (show_unreachable) { - fprintf(stderr, "unable to do reachability without a head nor --cache\n"); - show_unreachable = 0; - } - if (!heads) - fprintf(stderr, "expect dangling commits - potential heads - due to lack of head information\n"); - } - check_connectivity(); return 0; }