Merge branch 'dl/subtree-limit-to-one-rev'
[git/git.git] / builtin / fsck.c
1 #define USE_THE_INDEX_COMPATIBILITY_MACROS
2 #include "builtin.h"
3 #include "cache.h"
4 #include "repository.h"
5 #include "config.h"
6 #include "commit.h"
7 #include "tree.h"
8 #include "blob.h"
9 #include "tag.h"
10 #include "refs.h"
11 #include "pack.h"
12 #include "cache-tree.h"
13 #include "tree-walk.h"
14 #include "fsck.h"
15 #include "parse-options.h"
16 #include "dir.h"
17 #include "progress.h"
18 #include "streaming.h"
19 #include "decorate.h"
20 #include "packfile.h"
21 #include "object-store.h"
22 #include "run-command.h"
23 #include "worktree.h"
24
25 #define REACHABLE 0x0001
26 #define SEEN 0x0002
27 #define HAS_OBJ 0x0004
28 /* This flag is set if something points to this object. */
29 #define USED 0x0008
30
31 static int show_root;
32 static int show_tags;
33 static int show_unreachable;
34 static int include_reflogs = 1;
35 static int check_full = 1;
36 static int connectivity_only;
37 static int check_strict;
38 static int keep_cache_objects;
39 static struct fsck_options fsck_walk_options = FSCK_OPTIONS_DEFAULT;
40 static struct fsck_options fsck_obj_options = FSCK_OPTIONS_DEFAULT;
41 static int errors_found;
42 static int write_lost_and_found;
43 static int verbose;
44 static int show_progress = -1;
45 static int show_dangling = 1;
46 static int name_objects;
47 #define ERROR_OBJECT 01
48 #define ERROR_REACHABLE 02
49 #define ERROR_PACK 04
50 #define ERROR_REFS 010
51 #define ERROR_COMMIT_GRAPH 020
52
53 static const char *describe_object(struct object *obj)
54 {
55 static struct strbuf bufs[] = {
56 STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
57 };
58 static int b = 0;
59 struct strbuf *buf;
60 char *name = NULL;
61
62 if (name_objects)
63 name = lookup_decoration(fsck_walk_options.object_names, obj);
64
65 buf = bufs + b;
66 b = (b + 1) % ARRAY_SIZE(bufs);
67 strbuf_reset(buf);
68 strbuf_addstr(buf, oid_to_hex(&obj->oid));
69 if (name)
70 strbuf_addf(buf, " (%s)", name);
71
72 return buf->buf;
73 }
74
75 static const char *printable_type(struct object *obj)
76 {
77 const char *ret;
78
79 if (obj->type == OBJ_NONE) {
80 enum object_type type = oid_object_info(the_repository,
81 &obj->oid, NULL);
82 if (type > 0)
83 object_as_type(the_repository, obj, type, 0);
84 }
85
86 ret = type_name(obj->type);
87 if (!ret)
88 ret = _("unknown");
89
90 return ret;
91 }
92
93 static int fsck_config(const char *var, const char *value, void *cb)
94 {
95 if (strcmp(var, "fsck.skiplist") == 0) {
96 const char *path;
97 struct strbuf sb = STRBUF_INIT;
98
99 if (git_config_pathname(&path, var, value))
100 return 1;
101 strbuf_addf(&sb, "skiplist=%s", path);
102 free((char *)path);
103 fsck_set_msg_types(&fsck_obj_options, sb.buf);
104 strbuf_release(&sb);
105 return 0;
106 }
107
108 if (skip_prefix(var, "fsck.", &var)) {
109 fsck_set_msg_type(&fsck_obj_options, var, value);
110 return 0;
111 }
112
113 return git_default_config(var, value, cb);
114 }
115
116 static int objerror(struct object *obj, const char *err)
117 {
118 errors_found |= ERROR_OBJECT;
119 /* TRANSLATORS: e.g. error in tree 01bfda: <more explanation> */
120 fprintf_ln(stderr, _("error in %s %s: %s"),
121 printable_type(obj), describe_object(obj), err);
122 return -1;
123 }
124
125 static int fsck_error_func(struct fsck_options *o,
126 struct object *obj, int type, const char *message)
127 {
128 switch (type) {
129 case FSCK_WARN:
130 /* TRANSLATORS: e.g. warning in tree 01bfda: <more explanation> */
131 fprintf_ln(stderr, _("warning in %s %s: %s"),
132 printable_type(obj), describe_object(obj), message);
133 return 0;
134 case FSCK_ERROR:
135 /* TRANSLATORS: e.g. error in tree 01bfda: <more explanation> */
136 fprintf_ln(stderr, _("error in %s %s: %s"),
137 printable_type(obj), describe_object(obj), message);
138 return 1;
139 default:
140 BUG("%d (FSCK_IGNORE?) should never trigger this callback", type);
141 }
142 }
143
144 static struct object_array pending;
145
146 static int mark_object(struct object *obj, int type, void *data, struct fsck_options *options)
147 {
148 struct object *parent = data;
149
150 /*
151 * The only case data is NULL or type is OBJ_ANY is when
152 * mark_object_reachable() calls us. All the callers of
153 * that function has non-NULL obj hence ...
154 */
155 if (!obj) {
156 /* ... these references to parent->fld are safe here */
157 printf_ln(_("broken link from %7s %s"),
158 printable_type(parent), describe_object(parent));
159 printf_ln(_("broken link from %7s %s"),
160 (type == OBJ_ANY ? _("unknown") : type_name(type)),
161 _("unknown"));
162 errors_found |= ERROR_REACHABLE;
163 return 1;
164 }
165
166 if (type != OBJ_ANY && obj->type != type)
167 /* ... and the reference to parent is safe here */
168 objerror(parent, _("wrong object type in link"));
169
170 if (obj->flags & REACHABLE)
171 return 0;
172 obj->flags |= REACHABLE;
173
174 if (is_promisor_object(&obj->oid))
175 /*
176 * Further recursion does not need to be performed on this
177 * object since it is a promisor object (so it does not need to
178 * be added to "pending").
179 */
180 return 0;
181
182 if (!(obj->flags & HAS_OBJ)) {
183 if (parent && !has_object_file(&obj->oid)) {
184 printf_ln(_("broken link from %7s %s\n"
185 " to %7s %s"),
186 printable_type(parent),
187 describe_object(parent),
188 printable_type(obj),
189 describe_object(obj));
190 errors_found |= ERROR_REACHABLE;
191 }
192 return 1;
193 }
194
195 add_object_array(obj, NULL, &pending);
196 return 0;
197 }
198
199 static void mark_object_reachable(struct object *obj)
200 {
201 mark_object(obj, OBJ_ANY, NULL, NULL);
202 }
203
204 static int traverse_one_object(struct object *obj)
205 {
206 int result = fsck_walk(obj, obj, &fsck_walk_options);
207
208 if (obj->type == OBJ_TREE) {
209 struct tree *tree = (struct tree *)obj;
210 free_tree_buffer(tree);
211 }
212 return result;
213 }
214
215 static int traverse_reachable(void)
216 {
217 struct progress *progress = NULL;
218 unsigned int nr = 0;
219 int result = 0;
220 if (show_progress)
221 progress = start_delayed_progress(_("Checking connectivity"), 0);
222 while (pending.nr) {
223 result |= traverse_one_object(object_array_pop(&pending));
224 display_progress(progress, ++nr);
225 }
226 stop_progress(&progress);
227 return !!result;
228 }
229
230 static int mark_used(struct object *obj, int type, void *data, struct fsck_options *options)
231 {
232 if (!obj)
233 return 1;
234 obj->flags |= USED;
235 return 0;
236 }
237
238 static void mark_unreachable_referents(const struct object_id *oid)
239 {
240 struct fsck_options options = FSCK_OPTIONS_DEFAULT;
241 struct object *obj = lookup_object(the_repository, oid->hash);
242
243 if (!obj || !(obj->flags & HAS_OBJ))
244 return; /* not part of our original set */
245 if (obj->flags & REACHABLE)
246 return; /* reachable objects already traversed */
247
248 /*
249 * Avoid passing OBJ_NONE to fsck_walk, which will parse the object
250 * (and we want to avoid parsing blobs).
251 */
252 if (obj->type == OBJ_NONE) {
253 enum object_type type = oid_object_info(the_repository,
254 &obj->oid, NULL);
255 if (type > 0)
256 object_as_type(the_repository, obj, type, 0);
257 }
258
259 options.walk = mark_used;
260 fsck_walk(obj, NULL, &options);
261 }
262
263 static int mark_loose_unreachable_referents(const struct object_id *oid,
264 const char *path,
265 void *data)
266 {
267 mark_unreachable_referents(oid);
268 return 0;
269 }
270
271 static int mark_packed_unreachable_referents(const struct object_id *oid,
272 struct packed_git *pack,
273 uint32_t pos,
274 void *data)
275 {
276 mark_unreachable_referents(oid);
277 return 0;
278 }
279
280 /*
281 * Check a single reachable object
282 */
283 static void check_reachable_object(struct object *obj)
284 {
285 /*
286 * We obviously want the object to be parsed,
287 * except if it was in a pack-file and we didn't
288 * do a full fsck
289 */
290 if (!(obj->flags & HAS_OBJ)) {
291 if (is_promisor_object(&obj->oid))
292 return;
293 if (has_object_pack(&obj->oid))
294 return; /* it is in pack - forget about it */
295 printf_ln(_("missing %s %s"), printable_type(obj),
296 describe_object(obj));
297 errors_found |= ERROR_REACHABLE;
298 return;
299 }
300 }
301
302 /*
303 * Check a single unreachable object
304 */
305 static void check_unreachable_object(struct object *obj)
306 {
307 /*
308 * Missing unreachable object? Ignore it. It's not like
309 * we miss it (since it can't be reached), nor do we want
310 * to complain about it being unreachable (since it does
311 * not exist).
312 */
313 if (!(obj->flags & HAS_OBJ))
314 return;
315
316 /*
317 * Unreachable object that exists? Show it if asked to,
318 * since this is something that is prunable.
319 */
320 if (show_unreachable) {
321 printf_ln(_("unreachable %s %s"), printable_type(obj),
322 describe_object(obj));
323 return;
324 }
325
326 /*
327 * "!USED" means that nothing at all points to it, including
328 * other unreachable objects. In other words, it's the "tip"
329 * of some set of unreachable objects, usually a commit that
330 * got dropped.
331 *
332 * Such starting points are more interesting than some random
333 * set of unreachable objects, so we show them even if the user
334 * hasn't asked for _all_ unreachable objects. If you have
335 * deleted a branch by mistake, this is a prime candidate to
336 * start looking at, for example.
337 */
338 if (!(obj->flags & USED)) {
339 if (show_dangling)
340 printf_ln(_("dangling %s %s"), printable_type(obj),
341 describe_object(obj));
342 if (write_lost_and_found) {
343 char *filename = git_pathdup("lost-found/%s/%s",
344 obj->type == OBJ_COMMIT ? "commit" : "other",
345 describe_object(obj));
346 FILE *f;
347
348 if (safe_create_leading_directories_const(filename)) {
349 error(_("could not create lost-found"));
350 free(filename);
351 return;
352 }
353 f = xfopen(filename, "w");
354 if (obj->type == OBJ_BLOB) {
355 if (stream_blob_to_fd(fileno(f), &obj->oid, NULL, 1))
356 die_errno(_("could not write '%s'"), filename);
357 } else
358 fprintf(f, "%s\n", describe_object(obj));
359 if (fclose(f))
360 die_errno(_("could not finish '%s'"),
361 filename);
362 free(filename);
363 }
364 return;
365 }
366
367 /*
368 * Otherwise? It's there, it's unreachable, and some other unreachable
369 * object points to it. Ignore it - it's not interesting, and we showed
370 * all the interesting cases above.
371 */
372 }
373
374 static void check_object(struct object *obj)
375 {
376 if (verbose)
377 fprintf_ln(stderr, _("Checking %s"), describe_object(obj));
378
379 if (obj->flags & REACHABLE)
380 check_reachable_object(obj);
381 else
382 check_unreachable_object(obj);
383 }
384
385 static void check_connectivity(void)
386 {
387 int i, max;
388
389 /* Traverse the pending reachable objects */
390 traverse_reachable();
391
392 /*
393 * With --connectivity-only, we won't have actually opened and marked
394 * unreachable objects with USED. Do that now to make --dangling, etc
395 * accurate.
396 */
397 if (connectivity_only && (show_dangling || write_lost_and_found)) {
398 /*
399 * Even though we already have a "struct object" for each of
400 * these in memory, we must not iterate over the internal
401 * object hash as we do below. Our loop would potentially
402 * resize the hash, making our iteration invalid.
403 *
404 * Instead, we'll just go back to the source list of objects,
405 * and ignore any that weren't present in our earlier
406 * traversal.
407 */
408 for_each_loose_object(mark_loose_unreachable_referents, NULL, 0);
409 for_each_packed_object(mark_packed_unreachable_referents, NULL, 0);
410 }
411
412 /* Look up all the requirements, warn about missing objects.. */
413 max = get_max_object_index();
414 if (verbose)
415 fprintf_ln(stderr, _("Checking connectivity (%d objects)"), max);
416
417 for (i = 0; i < max; i++) {
418 struct object *obj = get_indexed_object(i);
419
420 if (obj)
421 check_object(obj);
422 }
423 }
424
425 static int fsck_obj(struct object *obj, void *buffer, unsigned long size)
426 {
427 int err;
428
429 if (obj->flags & SEEN)
430 return 0;
431 obj->flags |= SEEN;
432
433 if (verbose)
434 fprintf_ln(stderr, _("Checking %s %s"),
435 printable_type(obj), describe_object(obj));
436
437 if (fsck_walk(obj, NULL, &fsck_obj_options))
438 objerror(obj, _("broken links"));
439 err = fsck_object(obj, buffer, size, &fsck_obj_options);
440 if (err)
441 goto out;
442
443 if (obj->type == OBJ_COMMIT) {
444 struct commit *commit = (struct commit *) obj;
445
446 if (!commit->parents && show_root)
447 printf_ln(_("root %s"),
448 describe_object(&commit->object));
449 }
450
451 if (obj->type == OBJ_TAG) {
452 struct tag *tag = (struct tag *) obj;
453
454 if (show_tags && tag->tagged) {
455 printf_ln(_("tagged %s %s (%s) in %s"),
456 printable_type(tag->tagged),
457 describe_object(tag->tagged),
458 tag->tag,
459 describe_object(&tag->object));
460 }
461 }
462
463 out:
464 if (obj->type == OBJ_TREE)
465 free_tree_buffer((struct tree *)obj);
466 if (obj->type == OBJ_COMMIT)
467 free_commit_buffer(the_repository->parsed_objects,
468 (struct commit *)obj);
469 return err;
470 }
471
472 static int fsck_obj_buffer(const struct object_id *oid, enum object_type type,
473 unsigned long size, void *buffer, int *eaten)
474 {
475 /*
476 * Note, buffer may be NULL if type is OBJ_BLOB. See
477 * verify_packfile(), data_valid variable for details.
478 */
479 struct object *obj;
480 obj = parse_object_buffer(the_repository, oid, type, size, buffer,
481 eaten);
482 if (!obj) {
483 errors_found |= ERROR_OBJECT;
484 return error(_("%s: object corrupt or missing"),
485 oid_to_hex(oid));
486 }
487 obj->flags &= ~(REACHABLE | SEEN);
488 obj->flags |= HAS_OBJ;
489 return fsck_obj(obj, buffer, size);
490 }
491
492 static int default_refs;
493
494 static void fsck_handle_reflog_oid(const char *refname, struct object_id *oid,
495 timestamp_t timestamp)
496 {
497 struct object *obj;
498
499 if (!is_null_oid(oid)) {
500 obj = lookup_object(the_repository, oid->hash);
501 if (obj && (obj->flags & HAS_OBJ)) {
502 if (timestamp && name_objects)
503 add_decoration(fsck_walk_options.object_names,
504 obj,
505 xstrfmt("%s@{%"PRItime"}", refname, timestamp));
506 obj->flags |= USED;
507 mark_object_reachable(obj);
508 } else if (!is_promisor_object(oid)) {
509 error(_("%s: invalid reflog entry %s"),
510 refname, oid_to_hex(oid));
511 errors_found |= ERROR_REACHABLE;
512 }
513 }
514 }
515
516 static int fsck_handle_reflog_ent(struct object_id *ooid, struct object_id *noid,
517 const char *email, timestamp_t timestamp, int tz,
518 const char *message, void *cb_data)
519 {
520 const char *refname = cb_data;
521
522 if (verbose)
523 fprintf_ln(stderr, _("Checking reflog %s->%s"),
524 oid_to_hex(ooid), oid_to_hex(noid));
525
526 fsck_handle_reflog_oid(refname, ooid, 0);
527 fsck_handle_reflog_oid(refname, noid, timestamp);
528 return 0;
529 }
530
531 static int fsck_handle_reflog(const char *logname, const struct object_id *oid,
532 int flag, void *cb_data)
533 {
534 struct strbuf refname = STRBUF_INIT;
535
536 strbuf_worktree_ref(cb_data, &refname, logname);
537 for_each_reflog_ent(refname.buf, fsck_handle_reflog_ent, refname.buf);
538 strbuf_release(&refname);
539 return 0;
540 }
541
542 static int fsck_handle_ref(const char *refname, const struct object_id *oid,
543 int flag, void *cb_data)
544 {
545 struct object *obj;
546
547 obj = parse_object(the_repository, oid);
548 if (!obj) {
549 if (is_promisor_object(oid)) {
550 /*
551 * Increment default_refs anyway, because this is a
552 * valid ref.
553 */
554 default_refs++;
555 return 0;
556 }
557 error(_("%s: invalid sha1 pointer %s"),
558 refname, oid_to_hex(oid));
559 errors_found |= ERROR_REACHABLE;
560 /* We'll continue with the rest despite the error.. */
561 return 0;
562 }
563 if (obj->type != OBJ_COMMIT && is_branch(refname)) {
564 error(_("%s: not a commit"), refname);
565 errors_found |= ERROR_REFS;
566 }
567 default_refs++;
568 obj->flags |= USED;
569 if (name_objects)
570 add_decoration(fsck_walk_options.object_names,
571 obj, xstrdup(refname));
572 mark_object_reachable(obj);
573
574 return 0;
575 }
576
577 static int fsck_head_link(const char *head_ref_name,
578 const char **head_points_at,
579 struct object_id *head_oid);
580
581 static void get_default_heads(void)
582 {
583 struct worktree **worktrees, **p;
584 const char *head_points_at;
585 struct object_id head_oid;
586
587 for_each_rawref(fsck_handle_ref, NULL);
588
589 worktrees = get_worktrees(0);
590 for (p = worktrees; *p; p++) {
591 struct worktree *wt = *p;
592 struct strbuf ref = STRBUF_INIT;
593
594 strbuf_worktree_ref(wt, &ref, "HEAD");
595 fsck_head_link(ref.buf, &head_points_at, &head_oid);
596 if (head_points_at && !is_null_oid(&head_oid))
597 fsck_handle_ref(ref.buf, &head_oid, 0, NULL);
598 strbuf_release(&ref);
599
600 if (include_reflogs)
601 refs_for_each_reflog(get_worktree_ref_store(wt),
602 fsck_handle_reflog, wt);
603 }
604 free_worktrees(worktrees);
605
606 /*
607 * Not having any default heads isn't really fatal, but
608 * it does mean that "--unreachable" no longer makes any
609 * sense (since in this case everything will obviously
610 * be unreachable by definition.
611 *
612 * Showing dangling objects is valid, though (as those
613 * dangling objects are likely lost heads).
614 *
615 * So we just print a warning about it, and clear the
616 * "show_unreachable" flag.
617 */
618 if (!default_refs) {
619 fprintf_ln(stderr, _("notice: No default references"));
620 show_unreachable = 0;
621 }
622 }
623
624 static int fsck_loose(const struct object_id *oid, const char *path, void *data)
625 {
626 struct object *obj;
627 enum object_type type;
628 unsigned long size;
629 void *contents;
630 int eaten;
631
632 if (read_loose_object(path, oid, &type, &size, &contents) < 0) {
633 errors_found |= ERROR_OBJECT;
634 error(_("%s: object corrupt or missing: %s"),
635 oid_to_hex(oid), path);
636 return 0; /* keep checking other objects */
637 }
638
639 if (!contents && type != OBJ_BLOB)
640 BUG("read_loose_object streamed a non-blob");
641
642 obj = parse_object_buffer(the_repository, oid, type, size,
643 contents, &eaten);
644
645 if (!obj) {
646 errors_found |= ERROR_OBJECT;
647 error(_("%s: object could not be parsed: %s"),
648 oid_to_hex(oid), path);
649 if (!eaten)
650 free(contents);
651 return 0; /* keep checking other objects */
652 }
653
654 obj->flags &= ~(REACHABLE | SEEN);
655 obj->flags |= HAS_OBJ;
656 if (fsck_obj(obj, contents, size))
657 errors_found |= ERROR_OBJECT;
658
659 if (!eaten)
660 free(contents);
661 return 0; /* keep checking other objects, even if we saw an error */
662 }
663
664 static int fsck_cruft(const char *basename, const char *path, void *data)
665 {
666 if (!starts_with(basename, "tmp_obj_"))
667 fprintf_ln(stderr, _("bad sha1 file: %s"), path);
668 return 0;
669 }
670
671 static int fsck_subdir(unsigned int nr, const char *path, void *progress)
672 {
673 display_progress(progress, nr + 1);
674 return 0;
675 }
676
677 static void fsck_object_dir(const char *path)
678 {
679 struct progress *progress = NULL;
680
681 if (verbose)
682 fprintf_ln(stderr, _("Checking object directory"));
683
684 if (show_progress)
685 progress = start_progress(_("Checking object directories"), 256);
686
687 for_each_loose_file_in_objdir(path, fsck_loose, fsck_cruft, fsck_subdir,
688 progress);
689 display_progress(progress, 256);
690 stop_progress(&progress);
691 }
692
693 static int fsck_head_link(const char *head_ref_name,
694 const char **head_points_at,
695 struct object_id *head_oid)
696 {
697 int null_is_error = 0;
698
699 if (verbose)
700 fprintf_ln(stderr, _("Checking %s link"), head_ref_name);
701
702 *head_points_at = resolve_ref_unsafe(head_ref_name, 0, head_oid, NULL);
703 if (!*head_points_at) {
704 errors_found |= ERROR_REFS;
705 return error(_("invalid %s"), head_ref_name);
706 }
707 if (!strcmp(*head_points_at, head_ref_name))
708 /* detached HEAD */
709 null_is_error = 1;
710 else if (!starts_with(*head_points_at, "refs/heads/")) {
711 errors_found |= ERROR_REFS;
712 return error(_("%s points to something strange (%s)"),
713 head_ref_name, *head_points_at);
714 }
715 if (is_null_oid(head_oid)) {
716 if (null_is_error) {
717 errors_found |= ERROR_REFS;
718 return error(_("%s: detached HEAD points at nothing"),
719 head_ref_name);
720 }
721 fprintf_ln(stderr,
722 _("notice: %s points to an unborn branch (%s)"),
723 head_ref_name, *head_points_at + 11);
724 }
725 return 0;
726 }
727
728 static int fsck_cache_tree(struct cache_tree *it)
729 {
730 int i;
731 int err = 0;
732
733 if (verbose)
734 fprintf_ln(stderr, _("Checking cache tree"));
735
736 if (0 <= it->entry_count) {
737 struct object *obj = parse_object(the_repository, &it->oid);
738 if (!obj) {
739 error(_("%s: invalid sha1 pointer in cache-tree"),
740 oid_to_hex(&it->oid));
741 errors_found |= ERROR_REFS;
742 return 1;
743 }
744 obj->flags |= USED;
745 if (name_objects)
746 add_decoration(fsck_walk_options.object_names,
747 obj, xstrdup(":"));
748 mark_object_reachable(obj);
749 if (obj->type != OBJ_TREE)
750 err |= objerror(obj, _("non-tree in cache-tree"));
751 }
752 for (i = 0; i < it->subtree_nr; i++)
753 err |= fsck_cache_tree(it->down[i]->cache_tree);
754 return err;
755 }
756
757 static void mark_object_for_connectivity(const struct object_id *oid)
758 {
759 struct object *obj = lookup_unknown_object(oid->hash);
760 obj->flags |= HAS_OBJ;
761 }
762
763 static int mark_loose_for_connectivity(const struct object_id *oid,
764 const char *path,
765 void *data)
766 {
767 mark_object_for_connectivity(oid);
768 return 0;
769 }
770
771 static int mark_packed_for_connectivity(const struct object_id *oid,
772 struct packed_git *pack,
773 uint32_t pos,
774 void *data)
775 {
776 mark_object_for_connectivity(oid);
777 return 0;
778 }
779
780 static char const * const fsck_usage[] = {
781 N_("git fsck [<options>] [<object>...]"),
782 NULL
783 };
784
785 static struct option fsck_opts[] = {
786 OPT__VERBOSE(&verbose, N_("be verbose")),
787 OPT_BOOL(0, "unreachable", &show_unreachable, N_("show unreachable objects")),
788 OPT_BOOL(0, "dangling", &show_dangling, N_("show dangling objects")),
789 OPT_BOOL(0, "tags", &show_tags, N_("report tags")),
790 OPT_BOOL(0, "root", &show_root, N_("report root nodes")),
791 OPT_BOOL(0, "cache", &keep_cache_objects, N_("make index objects head nodes")),
792 OPT_BOOL(0, "reflogs", &include_reflogs, N_("make reflogs head nodes (default)")),
793 OPT_BOOL(0, "full", &check_full, N_("also consider packs and alternate objects")),
794 OPT_BOOL(0, "connectivity-only", &connectivity_only, N_("check only connectivity")),
795 OPT_BOOL(0, "strict", &check_strict, N_("enable more strict checking")),
796 OPT_BOOL(0, "lost-found", &write_lost_and_found,
797 N_("write dangling objects in .git/lost-found")),
798 OPT_BOOL(0, "progress", &show_progress, N_("show progress")),
799 OPT_BOOL(0, "name-objects", &name_objects, N_("show verbose names for reachable objects")),
800 OPT_END(),
801 };
802
803 int cmd_fsck(int argc, const char **argv, const char *prefix)
804 {
805 int i;
806 struct object_directory *odb;
807
808 /* fsck knows how to handle missing promisor objects */
809 fetch_if_missing = 0;
810
811 errors_found = 0;
812 read_replace_refs = 0;
813
814 argc = parse_options(argc, argv, prefix, fsck_opts, fsck_usage, 0);
815
816 fsck_walk_options.walk = mark_object;
817 fsck_obj_options.walk = mark_used;
818 fsck_obj_options.error_func = fsck_error_func;
819 if (check_strict)
820 fsck_obj_options.strict = 1;
821
822 if (show_progress == -1)
823 show_progress = isatty(2);
824 if (verbose)
825 show_progress = 0;
826
827 if (write_lost_and_found) {
828 check_full = 1;
829 include_reflogs = 0;
830 }
831
832 if (name_objects)
833 fsck_walk_options.object_names =
834 xcalloc(1, sizeof(struct decoration));
835
836 git_config(fsck_config, NULL);
837
838 if (connectivity_only) {
839 for_each_loose_object(mark_loose_for_connectivity, NULL, 0);
840 for_each_packed_object(mark_packed_for_connectivity, NULL, 0);
841 } else {
842 prepare_alt_odb(the_repository);
843 for (odb = the_repository->objects->odb; odb; odb = odb->next)
844 fsck_object_dir(odb->path);
845
846 if (check_full) {
847 struct packed_git *p;
848 uint32_t total = 0, count = 0;
849 struct progress *progress = NULL;
850
851 if (show_progress) {
852 for (p = get_all_packs(the_repository); p;
853 p = p->next) {
854 if (open_pack_index(p))
855 continue;
856 total += p->num_objects;
857 }
858
859 progress = start_progress(_("Checking objects"), total);
860 }
861 for (p = get_all_packs(the_repository); p;
862 p = p->next) {
863 /* verify gives error messages itself */
864 if (verify_pack(the_repository,
865 p, fsck_obj_buffer,
866 progress, count))
867 errors_found |= ERROR_PACK;
868 count += p->num_objects;
869 }
870 stop_progress(&progress);
871 }
872
873 if (fsck_finish(&fsck_obj_options))
874 errors_found |= ERROR_OBJECT;
875 }
876
877 for (i = 0; i < argc; i++) {
878 const char *arg = argv[i];
879 struct object_id oid;
880 if (!get_oid(arg, &oid)) {
881 struct object *obj = lookup_object(the_repository,
882 oid.hash);
883
884 if (!obj || !(obj->flags & HAS_OBJ)) {
885 if (is_promisor_object(&oid))
886 continue;
887 error(_("%s: object missing"), oid_to_hex(&oid));
888 errors_found |= ERROR_OBJECT;
889 continue;
890 }
891
892 obj->flags |= USED;
893 if (name_objects)
894 add_decoration(fsck_walk_options.object_names,
895 obj, xstrdup(arg));
896 mark_object_reachable(obj);
897 continue;
898 }
899 error(_("invalid parameter: expected sha1, got '%s'"), arg);
900 errors_found |= ERROR_OBJECT;
901 }
902
903 /*
904 * If we've not been given any explicit head information, do the
905 * default ones from .git/refs. We also consider the index file
906 * in this case (ie this implies --cache).
907 */
908 if (!argc) {
909 get_default_heads();
910 keep_cache_objects = 1;
911 }
912
913 if (keep_cache_objects) {
914 verify_index_checksum = 1;
915 verify_ce_order = 1;
916 read_cache();
917 for (i = 0; i < active_nr; i++) {
918 unsigned int mode;
919 struct blob *blob;
920 struct object *obj;
921
922 mode = active_cache[i]->ce_mode;
923 if (S_ISGITLINK(mode))
924 continue;
925 blob = lookup_blob(the_repository,
926 &active_cache[i]->oid);
927 if (!blob)
928 continue;
929 obj = &blob->object;
930 obj->flags |= USED;
931 if (name_objects)
932 add_decoration(fsck_walk_options.object_names,
933 obj,
934 xstrfmt(":%s", active_cache[i]->name));
935 mark_object_reachable(obj);
936 }
937 if (active_cache_tree)
938 fsck_cache_tree(active_cache_tree);
939 }
940
941 check_connectivity();
942
943 if (!git_config_get_bool("core.commitgraph", &i) && i) {
944 struct child_process commit_graph_verify = CHILD_PROCESS_INIT;
945 const char *verify_argv[] = { "commit-graph", "verify", NULL, NULL, NULL };
946
947 prepare_alt_odb(the_repository);
948 for (odb = the_repository->objects->odb; odb; odb = odb->next) {
949 child_process_init(&commit_graph_verify);
950 commit_graph_verify.argv = verify_argv;
951 commit_graph_verify.git_cmd = 1;
952 verify_argv[2] = "--object-dir";
953 verify_argv[3] = odb->path;
954 if (run_command(&commit_graph_verify))
955 errors_found |= ERROR_COMMIT_GRAPH;
956 }
957 }
958
959 if (!git_config_get_bool("core.multipackindex", &i) && i) {
960 struct child_process midx_verify = CHILD_PROCESS_INIT;
961 const char *midx_argv[] = { "multi-pack-index", "verify", NULL, NULL, NULL };
962
963 prepare_alt_odb(the_repository);
964 for (odb = the_repository->objects->odb; odb; odb = odb->next) {
965 child_process_init(&midx_verify);
966 midx_verify.argv = midx_argv;
967 midx_verify.git_cmd = 1;
968 midx_argv[2] = "--object-dir";
969 midx_argv[3] = odb->path;
970 if (run_command(&midx_verify))
971 errors_found |= ERROR_COMMIT_GRAPH;
972 }
973 }
974
975 return errors_found;
976 }