1#include "builtin.h"
2#include "cache.h"
3#include "config.h"
4#include "commit.h"
5#include "tree.h"
6#include "blob.h"
7#include "tag.h"
8#include "refs.h"
9#include "pack.h"
10#include "cache-tree.h"
11#include "tree-walk.h"
12#include "fsck.h"
13#include "parse-options.h"
14#include "dir.h"
15#include "progress.h"
16#include "streaming.h"
17#include "decorate.h"
18
19#define REACHABLE 0x0001
20#define SEEN 0x0002
21#define HAS_OBJ 0x0004
22
23static int show_root;
24static int show_tags;
25static int show_unreachable;
26static int include_reflogs = 1;
27static int check_full = 1;
28static int connectivity_only;
29static int check_strict;
30static int keep_cache_objects;
31static struct fsck_options fsck_walk_options = FSCK_OPTIONS_DEFAULT;
32static struct fsck_options fsck_obj_options = FSCK_OPTIONS_DEFAULT;
33static struct object_id head_oid;
34static const char *head_points_at;
35static int errors_found;
36static int write_lost_and_found;
37static int verbose;
38static int show_progress = -1;
39static int show_dangling = 1;
40static int name_objects;
41#define ERROR_OBJECT 01
42#define ERROR_REACHABLE 02
43#define ERROR_PACK 04
44#define ERROR_REFS 010
45
46static const char *describe_object(struct object *obj)
47{
48 static struct strbuf buf = STRBUF_INIT;
49 char *name = name_objects ?
50 lookup_decoration(fsck_walk_options.object_names, obj) : NULL;
51
52 strbuf_reset(&buf);
53 strbuf_addstr(&buf, oid_to_hex(&obj->oid));
54 if (name)
55 strbuf_addf(&buf, " (%s)", name);
56
57 return buf.buf;
58}
59
60static const char *printable_type(struct object *obj)
61{
62 const char *ret;
63
64 if (obj->type == OBJ_NONE) {
65 enum object_type type = sha1_object_info(obj->oid.hash, NULL);
66 if (type > 0)
67 object_as_type(obj, type, 0);
68 }
69
70 ret = typename(obj->type);
71 if (!ret)
72 ret = "unknown";
73
74 return ret;
75}
76
77static int fsck_config(const char *var, const char *value, void *cb)
78{
79 if (strcmp(var, "fsck.skiplist") == 0) {
80 const char *path;
81 struct strbuf sb = STRBUF_INIT;
82
83 if (git_config_pathname(&path, var, value))
84 return 1;
85 strbuf_addf(&sb, "skiplist=%s", path);
86 free((char *)path);
87 fsck_set_msg_types(&fsck_obj_options, sb.buf);
88 strbuf_release(&sb);
89 return 0;
90 }
91
92 if (skip_prefix(var, "fsck.", &var)) {
93 fsck_set_msg_type(&fsck_obj_options, var, value);
94 return 0;
95 }
96
97 return git_default_config(var, value, cb);
98}
99
100static void objreport(struct object *obj, const char *msg_type,
101 const char *err)
102{
103 fprintf(stderr, "%s in %s %s: %s\n",
104 msg_type, printable_type(obj), describe_object(obj), err);
105}
106
107static int objerror(struct object *obj, const char *err)
108{
109 errors_found |= ERROR_OBJECT;
110 objreport(obj, "error", err);
111 return -1;
112}
113
114static int fsck_error_func(struct fsck_options *o,
115 struct object *obj, int type, const char *message)
116{
117 objreport(obj, (type == FSCK_WARN) ? "warning" : "error", message);
118 return (type == FSCK_WARN) ? 0 : 1;
119}
120
121static struct object_array pending;
122
123static int mark_object(struct object *obj, int type, void *data, struct fsck_options *options)
124{
125 struct object *parent = data;
126
127 /*
128 * The only case data is NULL or type is OBJ_ANY is when
129 * mark_object_reachable() calls us. All the callers of
130 * that function has non-NULL obj hence ...
131 */
132 if (!obj) {
133 /* ... these references to parent->fld are safe here */
134 printf("broken link from %7s %s\n",
135 printable_type(parent), describe_object(parent));
136 printf("broken link from %7s %s\n",
137 (type == OBJ_ANY ? "unknown" : typename(type)), "unknown");
138 errors_found |= ERROR_REACHABLE;
139 return 1;
140 }
141
142 if (type != OBJ_ANY && obj->type != type)
143 /* ... and the reference to parent is safe here */
144 objerror(parent, "wrong object type in link");
145
146 if (obj->flags & REACHABLE)
147 return 0;
148 obj->flags |= REACHABLE;
149 if (!(obj->flags & HAS_OBJ)) {
150 if (parent && !has_object_file(&obj->oid)) {
151 printf("broken link from %7s %s\n",
152 printable_type(parent), describe_object(parent));
153 printf(" to %7s %s\n",
154 printable_type(obj), describe_object(obj));
155 errors_found |= ERROR_REACHABLE;
156 }
157 return 1;
158 }
159
160 add_object_array(obj, NULL, &pending);
161 return 0;
162}
163
164static void mark_object_reachable(struct object *obj)
165{
166 mark_object(obj, OBJ_ANY, NULL, NULL);
167}
168
169static int traverse_one_object(struct object *obj)
170{
171 return fsck_walk(obj, obj, &fsck_walk_options);
172}
173
174static int traverse_reachable(void)
175{
176 struct progress *progress = NULL;
177 unsigned int nr = 0;
178 int result = 0;
179 if (show_progress)
180 progress = start_progress_delay(_("Checking connectivity"), 0, 0, 2);
181 while (pending.nr) {
182 struct object_array_entry *entry;
183 struct object *obj;
184
185 entry = pending.objects + --pending.nr;
186 obj = entry->item;
187 result |= traverse_one_object(obj);
188 display_progress(progress, ++nr);
189 }
190 stop_progress(&progress);
191 return !!result;
192}
193
194static int mark_used(struct object *obj, int type, void *data, struct fsck_options *options)
195{
196 if (!obj)
197 return 1;
198 obj->used = 1;
199 return 0;
200}
201
202/*
203 * Check a single reachable object
204 */
205static void check_reachable_object(struct object *obj)
206{
207 /*
208 * We obviously want the object to be parsed,
209 * except if it was in a pack-file and we didn't
210 * do a full fsck
211 */
212 if (!(obj->flags & HAS_OBJ)) {
213 if (has_sha1_pack(obj->oid.hash))
214 return; /* it is in pack - forget about it */
215 printf("missing %s %s\n", printable_type(obj),
216 describe_object(obj));
217 errors_found |= ERROR_REACHABLE;
218 return;
219 }
220}
221
222/*
223 * Check a single unreachable object
224 */
225static void check_unreachable_object(struct object *obj)
226{
227 /*
228 * Missing unreachable object? Ignore it. It's not like
229 * we miss it (since it can't be reached), nor do we want
230 * to complain about it being unreachable (since it does
231 * not exist).
232 */
233 if (!(obj->flags & HAS_OBJ))
234 return;
235
236 /*
237 * Unreachable object that exists? Show it if asked to,
238 * since this is something that is prunable.
239 */
240 if (show_unreachable) {
241 printf("unreachable %s %s\n", printable_type(obj),
242 describe_object(obj));
243 return;
244 }
245
246 /*
247 * "!used" means that nothing at all points to it, including
248 * other unreachable objects. In other words, it's the "tip"
249 * of some set of unreachable objects, usually a commit that
250 * got dropped.
251 *
252 * Such starting points are more interesting than some random
253 * set of unreachable objects, so we show them even if the user
254 * hasn't asked for _all_ unreachable objects. If you have
255 * deleted a branch by mistake, this is a prime candidate to
256 * start looking at, for example.
257 */
258 if (!obj->used) {
259 if (show_dangling)
260 printf("dangling %s %s\n", printable_type(obj),
261 describe_object(obj));
262 if (write_lost_and_found) {
263 char *filename = git_pathdup("lost-found/%s/%s",
264 obj->type == OBJ_COMMIT ? "commit" : "other",
265 describe_object(obj));
266 FILE *f;
267
268 if (safe_create_leading_directories_const(filename)) {
269 error("Could not create lost-found");
270 free(filename);
271 return;
272 }
273 f = xfopen(filename, "w");
274 if (obj->type == OBJ_BLOB) {
275 if (stream_blob_to_fd(fileno(f), &obj->oid, NULL, 1))
276 die_errno("Could not write '%s'", filename);
277 } else
278 fprintf(f, "%s\n", describe_object(obj));
279 if (fclose(f))
280 die_errno("Could not finish '%s'",
281 filename);
282 free(filename);
283 }
284 return;
285 }
286
287 /*
288 * Otherwise? It's there, it's unreachable, and some other unreachable
289 * object points to it. Ignore it - it's not interesting, and we showed
290 * all the interesting cases above.
291 */
292}
293
294static void check_object(struct object *obj)
295{
296 if (verbose)
297 fprintf(stderr, "Checking %s\n", describe_object(obj));
298
299 if (obj->flags & REACHABLE)
300 check_reachable_object(obj);
301 else
302 check_unreachable_object(obj);
303}
304
305static void check_connectivity(void)
306{
307 int i, max;
308
309 /* Traverse the pending reachable objects */
310 traverse_reachable();
311
312 /* Look up all the requirements, warn about missing objects.. */
313 max = get_max_object_index();
314 if (verbose)
315 fprintf(stderr, "Checking connectivity (%d objects)\n", max);
316
317 for (i = 0; i < max; i++) {
318 struct object *obj = get_indexed_object(i);
319
320 if (obj)
321 check_object(obj);
322 }
323}
324
325static int fsck_obj(struct object *obj)
326{
327 if (obj->flags & SEEN)
328 return 0;
329 obj->flags |= SEEN;
330
331 if (verbose)
332 fprintf(stderr, "Checking %s %s\n",
333 printable_type(obj), describe_object(obj));
334
335 if (fsck_walk(obj, NULL, &fsck_obj_options))
336 objerror(obj, "broken links");
337 if (fsck_object(obj, NULL, 0, &fsck_obj_options))
338 return -1;
339
340 if (obj->type == OBJ_TREE) {
341 struct tree *item = (struct tree *) obj;
342
343 free_tree_buffer(item);
344 }
345
346 if (obj->type == OBJ_COMMIT) {
347 struct commit *commit = (struct commit *) obj;
348
349 free_commit_buffer(commit);
350
351 if (!commit->parents && show_root)
352 printf("root %s\n", describe_object(&commit->object));
353 }
354
355 if (obj->type == OBJ_TAG) {
356 struct tag *tag = (struct tag *) obj;
357
358 if (show_tags && tag->tagged) {
359 printf("tagged %s %s", printable_type(tag->tagged),
360 describe_object(tag->tagged));
361 printf(" (%s) in %s\n", tag->tag,
362 describe_object(&tag->object));
363 }
364 }
365
366 return 0;
367}
368
369static int fsck_obj_buffer(const struct object_id *oid, enum object_type type,
370 unsigned long size, void *buffer, int *eaten)
371{
372 /*
373 * Note, buffer may be NULL if type is OBJ_BLOB. See
374 * verify_packfile(), data_valid variable for details.
375 */
376 struct object *obj;
377 obj = parse_object_buffer(oid, type, size, buffer, eaten);
378 if (!obj) {
379 errors_found |= ERROR_OBJECT;
380 return error("%s: object corrupt or missing", oid_to_hex(oid));
381 }
382 obj->flags = HAS_OBJ;
383 return fsck_obj(obj);
384}
385
386static int default_refs;
387
388static void fsck_handle_reflog_oid(const char *refname, struct object_id *oid,
389 timestamp_t timestamp)
390{
391 struct object *obj;
392
393 if (!is_null_oid(oid)) {
394 obj = lookup_object(oid->hash);
395 if (obj && (obj->flags & HAS_OBJ)) {
396 if (timestamp && name_objects)
397 add_decoration(fsck_walk_options.object_names,
398 obj,
399 xstrfmt("%s@{%"PRItime"}", refname, timestamp));
400 obj->used = 1;
401 mark_object_reachable(obj);
402 } else {
403 error("%s: invalid reflog entry %s", refname, oid_to_hex(oid));
404 errors_found |= ERROR_REACHABLE;
405 }
406 }
407}
408
409static int fsck_handle_reflog_ent(struct object_id *ooid, struct object_id *noid,
410 const char *email, timestamp_t timestamp, int tz,
411 const char *message, void *cb_data)
412{
413 const char *refname = cb_data;
414
415 if (verbose)
416 fprintf(stderr, "Checking reflog %s->%s\n",
417 oid_to_hex(ooid), oid_to_hex(noid));
418
419 fsck_handle_reflog_oid(refname, ooid, 0);
420 fsck_handle_reflog_oid(refname, noid, timestamp);
421 return 0;
422}
423
424static int fsck_handle_reflog(const char *logname, const struct object_id *oid,
425 int flag, void *cb_data)
426{
427 for_each_reflog_ent(logname, fsck_handle_reflog_ent, (void *)logname);
428 return 0;
429}
430
431static int fsck_handle_ref(const char *refname, const struct object_id *oid,
432 int flag, void *cb_data)
433{
434 struct object *obj;
435
436 obj = parse_object(oid);
437 if (!obj) {
438 error("%s: invalid sha1 pointer %s", refname, oid_to_hex(oid));
439 errors_found |= ERROR_REACHABLE;
440 /* We'll continue with the rest despite the error.. */
441 return 0;
442 }
443 if (obj->type != OBJ_COMMIT && is_branch(refname)) {
444 error("%s: not a commit", refname);
445 errors_found |= ERROR_REFS;
446 }
447 default_refs++;
448 obj->used = 1;
449 if (name_objects)
450 add_decoration(fsck_walk_options.object_names,
451 obj, xstrdup(refname));
452 mark_object_reachable(obj);
453
454 return 0;
455}
456
457static void get_default_heads(void)
458{
459 if (head_points_at && !is_null_oid(&head_oid))
460 fsck_handle_ref("HEAD", &head_oid, 0, NULL);
461 for_each_rawref(fsck_handle_ref, NULL);
462 if (include_reflogs)
463 for_each_reflog(fsck_handle_reflog, NULL);
464
465 /*
466 * Not having any default heads isn't really fatal, but
467 * it does mean that "--unreachable" no longer makes any
468 * sense (since in this case everything will obviously
469 * be unreachable by definition.
470 *
471 * Showing dangling objects is valid, though (as those
472 * dangling objects are likely lost heads).
473 *
474 * So we just print a warning about it, and clear the
475 * "show_unreachable" flag.
476 */
477 if (!default_refs) {
478 fprintf(stderr, "notice: No default references\n");
479 show_unreachable = 0;
480 }
481}
482
483static struct object *parse_loose_object(const struct object_id *oid,
484 const char *path)
485{
486 struct object *obj;
487 void *contents;
488 enum object_type type;
489 unsigned long size;
490 int eaten;
491
492 if (read_loose_object(path, oid->hash, &type, &size, &contents) < 0)
493 return NULL;
494
495 if (!contents && type != OBJ_BLOB)
496 die("BUG: read_loose_object streamed a non-blob");
497
498 obj = parse_object_buffer(oid, type, size, contents, &eaten);
499
500 if (!eaten)
501 free(contents);
502 return obj;
503}
504
505static int fsck_loose(const struct object_id *oid, const char *path, void *data)
506{
507 struct object *obj = parse_loose_object(oid, path);
508
509 if (!obj) {
510 errors_found |= ERROR_OBJECT;
511 error("%s: object corrupt or missing: %s",
512 oid_to_hex(oid), path);
513 return 0; /* keep checking other objects */
514 }
515
516 obj->flags = HAS_OBJ;
517 if (fsck_obj(obj))
518 errors_found |= ERROR_OBJECT;
519 return 0;
520}
521
522static int fsck_cruft(const char *basename, const char *path, void *data)
523{
524 if (!starts_with(basename, "tmp_obj_"))
525 fprintf(stderr, "bad sha1 file: %s\n", path);
526 return 0;
527}
528
529static int fsck_subdir(unsigned int nr, const char *path, void *progress)
530{
531 display_progress(progress, nr + 1);
532 return 0;
533}
534
535static void fsck_object_dir(const char *path)
536{
537 struct progress *progress = NULL;
538
539 if (verbose)
540 fprintf(stderr, "Checking object directory\n");
541
542 if (show_progress)
543 progress = start_progress(_("Checking object directories"), 256);
544
545 for_each_loose_file_in_objdir(path, fsck_loose, fsck_cruft, fsck_subdir,
546 progress);
547 display_progress(progress, 256);
548 stop_progress(&progress);
549}
550
551static int fsck_head_link(void)
552{
553 int null_is_error = 0;
554
555 if (verbose)
556 fprintf(stderr, "Checking HEAD link\n");
557
558 head_points_at = resolve_ref_unsafe("HEAD", 0, head_oid.hash, NULL);
559 if (!head_points_at) {
560 errors_found |= ERROR_REFS;
561 return error("Invalid HEAD");
562 }
563 if (!strcmp(head_points_at, "HEAD"))
564 /* detached HEAD */
565 null_is_error = 1;
566 else if (!starts_with(head_points_at, "refs/heads/")) {
567 errors_found |= ERROR_REFS;
568 return error("HEAD points to something strange (%s)",
569 head_points_at);
570 }
571 if (is_null_oid(&head_oid)) {
572 if (null_is_error) {
573 errors_found |= ERROR_REFS;
574 return error("HEAD: detached HEAD points at nothing");
575 }
576 fprintf(stderr, "notice: HEAD points to an unborn branch (%s)\n",
577 head_points_at + 11);
578 }
579 return 0;
580}
581
582static int fsck_cache_tree(struct cache_tree *it)
583{
584 int i;
585 int err = 0;
586
587 if (verbose)
588 fprintf(stderr, "Checking cache tree\n");
589
590 if (0 <= it->entry_count) {
591 struct object *obj = parse_object(&it->oid);
592 if (!obj) {
593 error("%s: invalid sha1 pointer in cache-tree",
594 oid_to_hex(&it->oid));
595 errors_found |= ERROR_REFS;
596 return 1;
597 }
598 obj->used = 1;
599 if (name_objects)
600 add_decoration(fsck_walk_options.object_names,
601 obj, xstrdup(":"));
602 mark_object_reachable(obj);
603 if (obj->type != OBJ_TREE)
604 err |= objerror(obj, "non-tree in cache-tree");
605 }
606 for (i = 0; i < it->subtree_nr; i++)
607 err |= fsck_cache_tree(it->down[i]->cache_tree);
608 return err;
609}
610
611static void mark_object_for_connectivity(const struct object_id *oid)
612{
613 struct object *obj = lookup_unknown_object(oid->hash);
614 obj->flags |= HAS_OBJ;
615}
616
617static int mark_loose_for_connectivity(const struct object_id *oid,
618 const char *path,
619 void *data)
620{
621 mark_object_for_connectivity(oid);
622 return 0;
623}
624
625static int mark_packed_for_connectivity(const struct object_id *oid,
626 struct packed_git *pack,
627 uint32_t pos,
628 void *data)
629{
630 mark_object_for_connectivity(oid);
631 return 0;
632}
633
634static char const * const fsck_usage[] = {
635 N_("git fsck [<options>] [<object>...]"),
636 NULL
637};
638
639static struct option fsck_opts[] = {
640 OPT__VERBOSE(&verbose, N_("be verbose")),
641 OPT_BOOL(0, "unreachable", &show_unreachable, N_("show unreachable objects")),
642 OPT_BOOL(0, "dangling", &show_dangling, N_("show dangling objects")),
643 OPT_BOOL(0, "tags", &show_tags, N_("report tags")),
644 OPT_BOOL(0, "root", &show_root, N_("report root nodes")),
645 OPT_BOOL(0, "cache", &keep_cache_objects, N_("make index objects head nodes")),
646 OPT_BOOL(0, "reflogs", &include_reflogs, N_("make reflogs head nodes (default)")),
647 OPT_BOOL(0, "full", &check_full, N_("also consider packs and alternate objects")),
648 OPT_BOOL(0, "connectivity-only", &connectivity_only, N_("check only connectivity")),
649 OPT_BOOL(0, "strict", &check_strict, N_("enable more strict checking")),
650 OPT_BOOL(0, "lost-found", &write_lost_and_found,
651 N_("write dangling objects in .git/lost-found")),
652 OPT_BOOL(0, "progress", &show_progress, N_("show progress")),
653 OPT_BOOL(0, "name-objects", &name_objects, N_("show verbose names for reachable objects")),
654 OPT_END(),
655};
656
657int cmd_fsck(int argc, const char **argv, const char *prefix)
658{
659 int i, heads;
660 struct alternate_object_database *alt;
661
662 errors_found = 0;
663 check_replace_refs = 0;
664
665 argc = parse_options(argc, argv, prefix, fsck_opts, fsck_usage, 0);
666
667 fsck_walk_options.walk = mark_object;
668 fsck_obj_options.walk = mark_used;
669 fsck_obj_options.error_func = fsck_error_func;
670 if (check_strict)
671 fsck_obj_options.strict = 1;
672
673 if (show_progress == -1)
674 show_progress = isatty(2);
675 if (verbose)
676 show_progress = 0;
677
678 if (write_lost_and_found) {
679 check_full = 1;
680 include_reflogs = 0;
681 }
682
683 if (name_objects)
684 fsck_walk_options.object_names =
685 xcalloc(1, sizeof(struct decoration));
686
687 git_config(fsck_config, NULL);
688
689 fsck_head_link();
690 if (connectivity_only) {
691 for_each_loose_object(mark_loose_for_connectivity, NULL, 0);
692 for_each_packed_object(mark_packed_for_connectivity, NULL, 0);
693 } else {
694 fsck_object_dir(get_object_directory());
695
696 prepare_alt_odb();
697 for (alt = alt_odb_list; alt; alt = alt->next)
698 fsck_object_dir(alt->path);
699
700 if (check_full) {
701 struct packed_git *p;
702 uint32_t total = 0, count = 0;
703 struct progress *progress = NULL;
704
705 prepare_packed_git();
706
707 if (show_progress) {
708 for (p = packed_git; p; p = p->next) {
709 if (open_pack_index(p))
710 continue;
711 total += p->num_objects;
712 }
713
714 progress = start_progress(_("Checking objects"), total);
715 }
716 for (p = packed_git; p; p = p->next) {
717 /* verify gives error messages itself */
718 if (verify_pack(p, fsck_obj_buffer,
719 progress, count))
720 errors_found |= ERROR_PACK;
721 count += p->num_objects;
722 }
723 stop_progress(&progress);
724 }
725 }
726
727 heads = 0;
728 for (i = 0; i < argc; i++) {
729 const char *arg = argv[i];
730 unsigned char sha1[20];
731 if (!get_sha1(arg, sha1)) {
732 struct object *obj = lookup_object(sha1);
733
734 if (!obj || !(obj->flags & HAS_OBJ)) {
735 error("%s: object missing", sha1_to_hex(sha1));
736 errors_found |= ERROR_OBJECT;
737 continue;
738 }
739
740 obj->used = 1;
741 if (name_objects)
742 add_decoration(fsck_walk_options.object_names,
743 obj, xstrdup(arg));
744 mark_object_reachable(obj);
745 heads++;
746 continue;
747 }
748 error("invalid parameter: expected sha1, got '%s'", arg);
749 errors_found |= ERROR_OBJECT;
750 }
751
752 /*
753 * If we've not been given any explicit head information, do the
754 * default ones from .git/refs. We also consider the index file
755 * in this case (ie this implies --cache).
756 */
757 if (!argc) {
758 get_default_heads();
759 keep_cache_objects = 1;
760 }
761
762 if (keep_cache_objects) {
763 verify_index_checksum = 1;
764 read_cache();
765 for (i = 0; i < active_nr; i++) {
766 unsigned int mode;
767 struct blob *blob;
768 struct object *obj;
769
770 mode = active_cache[i]->ce_mode;
771 if (S_ISGITLINK(mode))
772 continue;
773 blob = lookup_blob(&active_cache[i]->oid);
774 if (!blob)
775 continue;
776 obj = &blob->object;
777 obj->used = 1;
778 if (name_objects)
779 add_decoration(fsck_walk_options.object_names,
780 obj,
781 xstrfmt(":%s", active_cache[i]->name));
782 mark_object_reachable(obj);
783 }
784 if (active_cache_tree)
785 fsck_cache_tree(active_cache_tree);
786 }
787
788 check_connectivity();
789 return errors_found;
790}