12 #define REACHABLE 0x0001
14 static int show_root
= 0;
15 static int show_tags
= 0;
16 static int show_unreachable
= 0;
17 static int standalone
= 0;
18 static int check_full
= 0;
19 static int check_strict
= 0;
20 static int keep_cache_objects
= 0;
21 static unsigned char head_sha1
[20];
23 static void check_connectivity(void)
27 /* Look up all the requirements, warn about missing objects.. */
28 for (i
= 0; i
< nr_objs
; i
++) {
29 struct object
*obj
= objs
[i
];
30 struct object_list
*refs
;
33 if (!standalone
&& has_sha1_file(obj
->sha1
))
36 printf("missing %s %s\n",
37 obj
->type
, sha1_to_hex(obj
->sha1
));
41 for (refs
= obj
->refs
; refs
; refs
= refs
->next
) {
42 if (refs
->item
->parsed
||
43 (!standalone
&& has_sha1_file(refs
->item
->sha1
)))
45 printf("broken link from %7s %s\n",
46 obj
->type
, sha1_to_hex(obj
->sha1
));
47 printf(" to %7s %s\n",
48 refs
->item
->type
, sha1_to_hex(refs
->item
->sha1
));
51 if (show_unreachable
&& !(obj
->flags
& REACHABLE
)) {
52 printf("unreachable %s %s\n",
53 obj
->type
, sha1_to_hex(obj
->sha1
));
58 printf("dangling %s %s\n", obj
->type
,
59 sha1_to_hex(obj
->sha1
));
65 * The entries in a tree are ordered in the _path_ order,
66 * which means that a directory entry is ordered by adding
67 * a slash to the end of it.
69 * So a directory called "a" is ordered _after_ a file
70 * called "a.c", because "a/" sorts after "a.c".
72 #define TREE_UNORDERED (-1)
73 #define TREE_HAS_DUPS (-2)
75 static int verify_ordered(struct tree_entry_list
*a
, struct tree_entry_list
*b
)
77 int len1
= strlen(a
->name
);
78 int len2
= strlen(b
->name
);
79 int len
= len1
< len2
? len1
: len2
;
83 cmp
= memcmp(a
->name
, b
->name
, len
);
87 return TREE_UNORDERED
;
90 * Ok, the first <len> characters are the same.
91 * Now we need to order the next one, but turn
92 * a '\0' into a '/' for a directory entry.
98 * git-write-tree used to write out a nonsense tree that has
99 * entries with the same name, one blob and one tree. Make
100 * sure we do not have duplicate entries.
102 return TREE_HAS_DUPS
;
103 if (!c1
&& a
->directory
)
105 if (!c2
&& b
->directory
)
107 return c1
< c2
? 0 : TREE_UNORDERED
;
110 static int fsck_tree(struct tree
*item
)
113 int has_full_path
= 0;
114 int has_zero_pad
= 0;
115 int has_bad_modes
= 0;
116 int has_dup_entries
= 0;
117 int not_properly_sorted
= 0;
118 struct tree_entry_list
*entry
, *last
;
121 for (entry
= item
->entries
; entry
; entry
= entry
->next
) {
122 if (strchr(entry
->name
, '/'))
124 has_zero_pad
|= entry
->zeropad
;
126 switch (entry
->mode
) {
136 * This is nonstandard, but we had a few of these
137 * early on when we honored the full set of mode
148 switch (verify_ordered(last
, entry
)) {
150 not_properly_sorted
= 1;
165 fprintf(stderr
, "warning: git-fsck-cache: tree %s "
166 "has full pathnames in it\n",
167 sha1_to_hex(item
->object
.sha1
));
170 fprintf(stderr
, "warning: git-fsck-cache: tree %s "
171 "has zero-padded file modes in it\n",
172 sha1_to_hex(item
->object
.sha1
));
175 fprintf(stderr
, "warning: git-fsck-cache: tree %s "
176 "has bad file modes in it\n",
177 sha1_to_hex(item
->object
.sha1
));
179 if (has_dup_entries
) {
180 fprintf(stderr
, "error: git-fsck-cache: tree %s "
181 "has duplicate file entries\n",
182 sha1_to_hex(item
->object
.sha1
));
185 if (not_properly_sorted
) {
186 fprintf(stderr
, "error: git-fsck-cache: tree %s "
187 "is not properly sorted\n",
188 sha1_to_hex(item
->object
.sha1
));
194 static int fsck_commit(struct commit
*commit
)
196 char *buffer
= commit
->buffer
;
197 unsigned char sha1
[20];
199 if (memcmp(buffer
, "tree ", 5))
201 if (get_sha1_hex(buffer
+5, sha1
) || buffer
[45] != '\n')
204 while (!memcmp(buffer
, "parent ", 7)) {
205 if (get_sha1_hex(buffer
+7, sha1
) || buffer
[47] != '\n')
209 if (memcmp(buffer
, "author ", 7))
211 free(commit
->buffer
);
212 commit
->buffer
= NULL
;
215 if (!commit
->parents
&& show_root
)
216 printf("root %s\n", sha1_to_hex(commit
->object
.sha1
));
218 printf("bad commit date in %s\n",
219 sha1_to_hex(commit
->object
.sha1
));
223 static int fsck_tag(struct tag
*tag
)
225 struct object
*tagged
= tag
->tagged
;
228 printf("bad object in tag %s\n", sha1_to_hex(tag
->object
.sha1
));
234 printf("tagged %s %s", tagged
->type
, sha1_to_hex(tagged
->sha1
));
235 printf(" (%s) in %s\n", tag
->tag
, sha1_to_hex(tag
->object
.sha1
));
239 static int fsck_sha1(unsigned char *sha1
)
241 struct object
*obj
= parse_object(sha1
);
244 if (obj
->type
== blob_type
)
246 if (obj
->type
== tree_type
)
247 return fsck_tree((struct tree
*) obj
);
248 if (obj
->type
== commit_type
)
249 return fsck_commit((struct commit
*) obj
);
250 if (obj
->type
== tag_type
)
251 return fsck_tag((struct tag
*) obj
);
256 * This is the sorting chunk size: make it reasonably
257 * big so that we can sort well..
259 #define MAX_SHA1_ENTRIES (1024)
263 unsigned char sha1
[20];
268 struct sha1_entry
*entry
[MAX_SHA1_ENTRIES
];
271 static int ino_compare(const void *_a
, const void *_b
)
273 const struct sha1_entry
*a
= _a
, *b
= _b
;
274 unsigned long ino1
= a
->ino
, ino2
= b
->ino
;
275 return ino1
< ino2
? -1 : ino1
> ino2
? 1 : 0;
278 static void fsck_sha1_list(void)
280 int i
, nr
= sha1_list
.nr
;
282 qsort(sha1_list
.entry
, nr
, sizeof(struct sha1_entry
*), ino_compare
);
283 for (i
= 0; i
< nr
; i
++) {
284 struct sha1_entry
*entry
= sha1_list
.entry
[i
];
285 unsigned char *sha1
= entry
->sha1
;
287 sha1_list
.entry
[i
] = NULL
;
288 if (fsck_sha1(sha1
) < 0)
289 fprintf(stderr
, "bad sha1 entry '%s'\n", sha1_to_hex(sha1
));
295 static void add_sha1_list(unsigned char *sha1
, unsigned long ino
)
297 struct sha1_entry
*entry
= xmalloc(sizeof(*entry
));
301 memcpy(entry
->sha1
, sha1
, 20);
303 if (nr
== MAX_SHA1_ENTRIES
) {
307 sha1_list
.entry
[nr
] = entry
;
311 static int fsck_dir(int i
, char *path
)
313 DIR *dir
= opendir(path
);
317 return error("missing sha1 directory '%s'", path
);
320 while ((de
= readdir(dir
)) != NULL
) {
322 unsigned char sha1
[20];
323 int len
= strlen(de
->d_name
);
327 if (de
->d_name
[1] != '.')
330 if (de
->d_name
[0] != '.')
334 sprintf(name
, "%02x", i
);
335 memcpy(name
+2, de
->d_name
, len
+1);
336 if (get_sha1_hex(name
, sha1
) < 0)
338 add_sha1_list(sha1
, de
->d_ino
);
341 fprintf(stderr
, "bad sha1 file: %s/%s\n", path
, de
->d_name
);
347 static int default_refs
= 0;
349 static int fsck_handle_ref(const char *refname
, const unsigned char *sha1
)
353 obj
= lookup_object(sha1
);
355 if (!standalone
&& has_sha1_file(sha1
)) {
357 return 0; /* it is in a pack */
359 error("%s: invalid sha1 pointer %s", refname
, sha1_to_hex(sha1
));
360 /* We'll continue with the rest despite the error.. */
365 mark_reachable(obj
, REACHABLE
);
369 static void get_default_heads(void)
371 for_each_ref(fsck_handle_ref
);
373 die("No default references");
376 static void fsck_object_dir(const char *path
)
379 for (i
= 0; i
< 256; i
++) {
380 static char dir
[4096];
381 sprintf(dir
, "%s/%02x", path
, i
);
387 static int fsck_head_link(void)
391 unsigned char sha1
[20];
392 static char path
[PATH_MAX
], link
[PATH_MAX
];
393 const char *git_dir
= gitenv(GIT_DIR_ENVIRONMENT
) ? : DEFAULT_GIT_DIR_ENVIRONMENT
;
395 snprintf(path
, sizeof(path
), "%s/HEAD", git_dir
);
396 if (readlink(path
, link
, sizeof(link
)) < 0)
397 return error("HEAD is not a symlink");
398 if (strncmp("refs/heads/", link
, 11))
399 return error("HEAD points to something strange (%s)", link
);
400 fd
= open(path
, O_RDONLY
);
402 return error("HEAD: %s", strerror(errno
));
403 count
= read(fd
, hex
, sizeof(hex
));
406 return error("HEAD: %s", strerror(errno
));
407 if (count
< 40 || get_sha1_hex(hex
, sha1
))
408 return error("HEAD: not a valid git pointer");
412 int main(int argc
, char **argv
)
416 for (i
= 1; i
< argc
; i
++) {
417 const char *arg
= argv
[i
];
419 if (!strcmp(arg
, "--unreachable")) {
420 show_unreachable
= 1;
423 if (!strcmp(arg
, "--tags")) {
427 if (!strcmp(arg
, "--root")) {
431 if (!strcmp(arg
, "--cache")) {
432 keep_cache_objects
= 1;
435 if (!strcmp(arg
, "--standalone")) {
439 if (!strcmp(arg
, "--full")) {
443 if (!strcmp(arg
, "--strict")) {
448 usage("git-fsck-cache [--tags] [[--unreachable] [--cache] [--standalone | --full] <head-sha1>*]");
451 if (standalone
&& check_full
)
452 die("Only one of --standalone or --full can be used.");
454 unsetenv("GIT_ALTERNATE_OBJECT_DIRECTORIES");
457 fsck_object_dir(get_object_directory());
460 struct packed_git
*p
;
462 for (j
= 0; alt_odb
[j
].base
; j
++) {
463 char namebuf
[PATH_MAX
];
464 int namelen
= alt_odb
[j
].name
- alt_odb
[j
].base
;
465 memcpy(namebuf
, alt_odb
[j
].base
, namelen
);
466 namebuf
[namelen
- 1] = 0;
467 fsck_object_dir(namebuf
);
469 prepare_packed_git();
470 for (p
= packed_git
; p
; p
= p
->next
)
471 /* verify gives error messages itself */
474 for (p
= packed_git
; p
; p
= p
->next
) {
475 int num
= num_packed_objects(p
);
476 for (i
= 0; i
< num
; i
++) {
477 unsigned char sha1
[20];
478 nth_packed_object_sha1(p
, i
, sha1
);
479 if (fsck_sha1(sha1
) < 0)
480 fprintf(stderr
, "bad sha1 entry '%s'\n", sha1_to_hex(sha1
));
487 for (i
= 1; i
< argc
; i
++) {
488 const char *arg
= argv
[i
];
493 if (!get_sha1(arg
, head_sha1
)) {
494 struct object
*obj
= lookup_object(head_sha1
);
496 /* Error is printed by lookup_object(). */
501 mark_reachable(obj
, REACHABLE
);
505 error("expected sha1, got %s", arg
);
509 * If we've not been given any explicit head information, do the
510 * default ones from .git/refs. We also consider the index file
511 * in this case (ie this implies --cache).
515 keep_cache_objects
= 1;
518 if (keep_cache_objects
) {
521 for (i
= 0; i
< active_nr
; i
++) {
522 struct blob
*blob
= lookup_blob(active_cache
[i
]->sha1
);
528 mark_reachable(obj
, REACHABLE
);
532 check_connectivity();