builtin/fsck.c

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