builtin-fsck.con commit Merge branch 'ep/cvstag' (0354539)
   1#include "cache.h"
   2#include "commit.h"
   3#include "tree.h"
   4#include "blob.h"
   5#include "tag.h"
   6#include "refs.h"
   7#include "pack.h"
   8#include "cache-tree.h"
   9#include "tree-walk.h"
  10
  11#define REACHABLE 0x0001
  12#define SEEN      0x0002
  13
  14static int show_root;
  15static int show_tags;
  16static int show_unreachable;
  17static int include_reflogs = 1;
  18static int check_full;
  19static int check_strict;
  20static int keep_cache_objects;
  21static unsigned char head_sha1[20];
  22static int errors_found;
  23static int verbose;
  24#define ERROR_OBJECT 01
  25#define ERROR_REACHABLE 02
  26
  27#ifdef NO_D_INO_IN_DIRENT
  28#define SORT_DIRENT 0
  29#define DIRENT_SORT_HINT(de) 0
  30#else
  31#define SORT_DIRENT 1
  32#define DIRENT_SORT_HINT(de) ((de)->d_ino)
  33#endif
  34
  35static void objreport(struct object *obj, const char *severity,
  36                      const char *err, va_list params)
  37{
  38        fprintf(stderr, "%s in %s %s: ",
  39                severity, typename(obj->type), sha1_to_hex(obj->sha1));
  40        vfprintf(stderr, err, params);
  41        fputs("\n", stderr);
  42}
  43
  44static int objerror(struct object *obj, const char *err, ...)
  45{
  46        va_list params;
  47        va_start(params, err);
  48        errors_found |= ERROR_OBJECT;
  49        objreport(obj, "error", err, params);
  50        va_end(params);
  51        return -1;
  52}
  53
  54static int objwarning(struct object *obj, const char *err, ...)
  55{
  56        va_list params;
  57        va_start(params, err);
  58        objreport(obj, "warning", err, params);
  59        va_end(params);
  60        return -1;
  61}
  62
  63/*
  64 * Check a single reachable object
  65 */
  66static void check_reachable_object(struct object *obj)
  67{
  68        const struct object_refs *refs;
  69
  70        /*
  71         * We obviously want the object to be parsed,
  72         * except if it was in a pack-file and we didn't
  73         * do a full fsck
  74         */
  75        if (!obj->parsed) {
  76                if (has_sha1_pack(obj->sha1, NULL))
  77                        return; /* it is in pack - forget about it */
  78                printf("missing %s %s\n", typename(obj->type), sha1_to_hex(obj->sha1));
  79                errors_found |= ERROR_REACHABLE;
  80                return;
  81        }
  82
  83        /*
  84         * Check that everything that we try to reference is also good.
  85         */
  86        refs = lookup_object_refs(obj);
  87        if (refs) {
  88                unsigned j;
  89                for (j = 0; j < refs->count; j++) {
  90                        struct object *ref = refs->ref[j];
  91                        if (ref->parsed ||
  92                            (has_sha1_file(ref->sha1)))
  93                                continue;
  94                        printf("broken link from %7s %s\n",
  95                               typename(obj->type), sha1_to_hex(obj->sha1));
  96                        printf("              to %7s %s\n",
  97                               typename(ref->type), sha1_to_hex(ref->sha1));
  98                        errors_found |= ERROR_REACHABLE;
  99                }
 100        }
 101}
 102
 103/*
 104 * Check a single unreachable object
 105 */
 106static void check_unreachable_object(struct object *obj)
 107{
 108        /*
 109         * Missing unreachable object? Ignore it. It's not like
 110         * we miss it (since it can't be reached), nor do we want
 111         * to complain about it being unreachable (since it does
 112         * not exist).
 113         */
 114        if (!obj->parsed)
 115                return;
 116
 117        /*
 118         * Unreachable object that exists? Show it if asked to,
 119         * since this is something that is prunable.
 120         */
 121        if (show_unreachable) {
 122                printf("unreachable %s %s\n", typename(obj->type), sha1_to_hex(obj->sha1));
 123                return;
 124        }
 125
 126        /*
 127         * "!used" means that nothing at all points to it, including
 128         * other unreachable objects. In other words, it's the "tip"
 129         * of some set of unreachable objects, usually a commit that
 130         * got dropped.
 131         *
 132         * Such starting points are more interesting than some random
 133         * set of unreachable objects, so we show them even if the user
 134         * hasn't asked for _all_ unreachable objects. If you have
 135         * deleted a branch by mistake, this is a prime candidate to
 136         * start looking at, for example.
 137         */
 138        if (!obj->used) {
 139                printf("dangling %s %s\n", typename(obj->type),
 140                       sha1_to_hex(obj->sha1));
 141                return;
 142        }
 143
 144        /*
 145         * Otherwise? It's there, it's unreachable, and some other unreachable
 146         * object points to it. Ignore it - it's not interesting, and we showed
 147         * all the interesting cases above.
 148         */
 149}
 150
 151static void check_object(struct object *obj)
 152{
 153        if (verbose)
 154                fprintf(stderr, "Checking %s\n", sha1_to_hex(obj->sha1));
 155
 156        if (obj->flags & REACHABLE)
 157                check_reachable_object(obj);
 158        else
 159                check_unreachable_object(obj);
 160}
 161
 162static void check_connectivity(void)
 163{
 164        int i, max;
 165
 166        /* Look up all the requirements, warn about missing objects.. */
 167        max = get_max_object_index();
 168        if (verbose)
 169                fprintf(stderr, "Checking connectivity (%d objects)\n", max);
 170
 171        for (i = 0; i < max; i++) {
 172                struct object *obj = get_indexed_object(i);
 173
 174                if (obj)
 175                        check_object(obj);
 176        }
 177}
 178
 179/*
 180 * The entries in a tree are ordered in the _path_ order,
 181 * which means that a directory entry is ordered by adding
 182 * a slash to the end of it.
 183 *
 184 * So a directory called "a" is ordered _after_ a file
 185 * called "a.c", because "a/" sorts after "a.c".
 186 */
 187#define TREE_UNORDERED (-1)
 188#define TREE_HAS_DUPS  (-2)
 189
 190static int verify_ordered(unsigned mode1, const char *name1, unsigned mode2, const char *name2)
 191{
 192        int len1 = strlen(name1);
 193        int len2 = strlen(name2);
 194        int len = len1 < len2 ? len1 : len2;
 195        unsigned char c1, c2;
 196        int cmp;
 197
 198        cmp = memcmp(name1, name2, len);
 199        if (cmp < 0)
 200                return 0;
 201        if (cmp > 0)
 202                return TREE_UNORDERED;
 203
 204        /*
 205         * Ok, the first <len> characters are the same.
 206         * Now we need to order the next one, but turn
 207         * a '\0' into a '/' for a directory entry.
 208         */
 209        c1 = name1[len];
 210        c2 = name2[len];
 211        if (!c1 && !c2)
 212                /*
 213                 * git-write-tree used to write out a nonsense tree that has
 214                 * entries with the same name, one blob and one tree.  Make
 215                 * sure we do not have duplicate entries.
 216                 */
 217                return TREE_HAS_DUPS;
 218        if (!c1 && S_ISDIR(mode1))
 219                c1 = '/';
 220        if (!c2 && S_ISDIR(mode2))
 221                c2 = '/';
 222        return c1 < c2 ? 0 : TREE_UNORDERED;
 223}
 224
 225static int fsck_tree(struct tree *item)
 226{
 227        int retval;
 228        int has_full_path = 0;
 229        int has_empty_name = 0;
 230        int has_zero_pad = 0;
 231        int has_bad_modes = 0;
 232        int has_dup_entries = 0;
 233        int not_properly_sorted = 0;
 234        struct tree_desc desc;
 235        unsigned o_mode;
 236        const char *o_name;
 237        const unsigned char *o_sha1;
 238
 239        if (verbose)
 240                fprintf(stderr, "Checking tree %s\n",
 241                                sha1_to_hex(item->object.sha1));
 242
 243        init_tree_desc(&desc, item->buffer, item->size);
 244
 245        o_mode = 0;
 246        o_name = NULL;
 247        o_sha1 = NULL;
 248        while (desc.size) {
 249                unsigned mode;
 250                const char *name;
 251                const unsigned char *sha1;
 252
 253                sha1 = tree_entry_extract(&desc, &name, &mode);
 254
 255                if (strchr(name, '/'))
 256                        has_full_path = 1;
 257                if (!*name)
 258                        has_empty_name = 1;
 259                has_zero_pad |= *(char *)desc.buffer == '0';
 260                update_tree_entry(&desc);
 261
 262                switch (mode) {
 263                /*
 264                 * Standard modes..
 265                 */
 266                case S_IFREG | 0755:
 267                case S_IFREG | 0644:
 268                case S_IFLNK:
 269                case S_IFDIR:
 270                case S_IFGITLINK:
 271                        break;
 272                /*
 273                 * This is nonstandard, but we had a few of these
 274                 * early on when we honored the full set of mode
 275                 * bits..
 276                 */
 277                case S_IFREG | 0664:
 278                        if (!check_strict)
 279                                break;
 280                default:
 281                        has_bad_modes = 1;
 282                }
 283
 284                if (o_name) {
 285                        switch (verify_ordered(o_mode, o_name, mode, name)) {
 286                        case TREE_UNORDERED:
 287                                not_properly_sorted = 1;
 288                                break;
 289                        case TREE_HAS_DUPS:
 290                                has_dup_entries = 1;
 291                                break;
 292                        default:
 293                                break;
 294                        }
 295                }
 296
 297                o_mode = mode;
 298                o_name = name;
 299                o_sha1 = sha1;
 300        }
 301        free(item->buffer);
 302        item->buffer = NULL;
 303
 304        retval = 0;
 305        if (has_full_path) {
 306                objwarning(&item->object, "contains full pathnames");
 307        }
 308        if (has_empty_name) {
 309                objwarning(&item->object, "contains empty pathname");
 310        }
 311        if (has_zero_pad) {
 312                objwarning(&item->object, "contains zero-padded file modes");
 313        }
 314        if (has_bad_modes) {
 315                objwarning(&item->object, "contains bad file modes");
 316        }
 317        if (has_dup_entries) {
 318                retval = objerror(&item->object, "contains duplicate file entries");
 319        }
 320        if (not_properly_sorted) {
 321                retval = objerror(&item->object, "not properly sorted");
 322        }
 323        return retval;
 324}
 325
 326static int fsck_commit(struct commit *commit)
 327{
 328        char *buffer = commit->buffer;
 329        unsigned char tree_sha1[20], sha1[20];
 330
 331        if (verbose)
 332                fprintf(stderr, "Checking commit %s\n",
 333                        sha1_to_hex(commit->object.sha1));
 334
 335        if (memcmp(buffer, "tree ", 5))
 336                return objerror(&commit->object, "invalid format - expected 'tree' line");
 337        if (get_sha1_hex(buffer+5, tree_sha1) || buffer[45] != '\n')
 338                return objerror(&commit->object, "invalid 'tree' line format - bad sha1");
 339        buffer += 46;
 340        while (!memcmp(buffer, "parent ", 7)) {
 341                if (get_sha1_hex(buffer+7, sha1) || buffer[47] != '\n')
 342                        return objerror(&commit->object, "invalid 'parent' line format - bad sha1");
 343                buffer += 48;
 344        }
 345        if (memcmp(buffer, "author ", 7))
 346                return objerror(&commit->object, "invalid format - expected 'author' line");
 347        free(commit->buffer);
 348        commit->buffer = NULL;
 349        if (!commit->tree)
 350                return objerror(&commit->object, "could not load commit's tree %s", tree_sha1);
 351        if (!commit->parents && show_root)
 352                printf("root %s\n", sha1_to_hex(commit->object.sha1));
 353        if (!commit->date)
 354                printf("bad commit date in %s\n",
 355                       sha1_to_hex(commit->object.sha1));
 356        return 0;
 357}
 358
 359static int fsck_tag(struct tag *tag)
 360{
 361        struct object *tagged = tag->tagged;
 362
 363        if (verbose)
 364                fprintf(stderr, "Checking tag %s\n",
 365                        sha1_to_hex(tag->object.sha1));
 366
 367        if (!tagged) {
 368                return objerror(&tag->object, "could not load tagged object");
 369        }
 370        if (!show_tags)
 371                return 0;
 372
 373        printf("tagged %s %s", typename(tagged->type), sha1_to_hex(tagged->sha1));
 374        printf(" (%s) in %s\n", tag->tag, sha1_to_hex(tag->object.sha1));
 375        return 0;
 376}
 377
 378static int fsck_sha1(const unsigned char *sha1)
 379{
 380        struct object *obj = parse_object(sha1);
 381        if (!obj) {
 382                errors_found |= ERROR_OBJECT;
 383                return error("%s: object corrupt or missing",
 384                             sha1_to_hex(sha1));
 385        }
 386        if (obj->flags & SEEN)
 387                return 0;
 388        obj->flags |= SEEN;
 389        if (obj->type == OBJ_BLOB)
 390                return 0;
 391        if (obj->type == OBJ_TREE)
 392                return fsck_tree((struct tree *) obj);
 393        if (obj->type == OBJ_COMMIT)
 394                return fsck_commit((struct commit *) obj);
 395        if (obj->type == OBJ_TAG)
 396                return fsck_tag((struct tag *) obj);
 397
 398        /* By now, parse_object() would've returned NULL instead. */
 399        return objerror(obj, "unknown type '%d' (internal fsck error)",
 400                        obj->type);
 401}
 402
 403/*
 404 * This is the sorting chunk size: make it reasonably
 405 * big so that we can sort well..
 406 */
 407#define MAX_SHA1_ENTRIES (1024)
 408
 409struct sha1_entry {
 410        unsigned long ino;
 411        unsigned char sha1[20];
 412};
 413
 414static struct {
 415        unsigned long nr;
 416        struct sha1_entry *entry[MAX_SHA1_ENTRIES];
 417} sha1_list;
 418
 419static int ino_compare(const void *_a, const void *_b)
 420{
 421        const struct sha1_entry *a = _a, *b = _b;
 422        unsigned long ino1 = a->ino, ino2 = b->ino;
 423        return ino1 < ino2 ? -1 : ino1 > ino2 ? 1 : 0;
 424}
 425
 426static void fsck_sha1_list(void)
 427{
 428        int i, nr = sha1_list.nr;
 429
 430        if (SORT_DIRENT)
 431                qsort(sha1_list.entry, nr,
 432                      sizeof(struct sha1_entry *), ino_compare);
 433        for (i = 0; i < nr; i++) {
 434                struct sha1_entry *entry = sha1_list.entry[i];
 435                unsigned char *sha1 = entry->sha1;
 436
 437                sha1_list.entry[i] = NULL;
 438                fsck_sha1(sha1);
 439                free(entry);
 440        }
 441        sha1_list.nr = 0;
 442}
 443
 444static void add_sha1_list(unsigned char *sha1, unsigned long ino)
 445{
 446        struct sha1_entry *entry = xmalloc(sizeof(*entry));
 447        int nr;
 448
 449        entry->ino = ino;
 450        hashcpy(entry->sha1, sha1);
 451        nr = sha1_list.nr;
 452        if (nr == MAX_SHA1_ENTRIES) {
 453                fsck_sha1_list();
 454                nr = 0;
 455        }
 456        sha1_list.entry[nr] = entry;
 457        sha1_list.nr = ++nr;
 458}
 459
 460static void fsck_dir(int i, char *path)
 461{
 462        DIR *dir = opendir(path);
 463        struct dirent *de;
 464
 465        if (!dir)
 466                return;
 467
 468        if (verbose)
 469                fprintf(stderr, "Checking directory %s\n", path);
 470
 471        while ((de = readdir(dir)) != NULL) {
 472                char name[100];
 473                unsigned char sha1[20];
 474                int len = strlen(de->d_name);
 475
 476                switch (len) {
 477                case 2:
 478                        if (de->d_name[1] != '.')
 479                                break;
 480                case 1:
 481                        if (de->d_name[0] != '.')
 482                                break;
 483                        continue;
 484                case 38:
 485                        sprintf(name, "%02x", i);
 486                        memcpy(name+2, de->d_name, len+1);
 487                        if (get_sha1_hex(name, sha1) < 0)
 488                                break;
 489                        add_sha1_list(sha1, DIRENT_SORT_HINT(de));
 490                        continue;
 491                }
 492                fprintf(stderr, "bad sha1 file: %s/%s\n", path, de->d_name);
 493        }
 494        closedir(dir);
 495}
 496
 497static int default_refs;
 498
 499static int fsck_handle_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
 500                const char *email, unsigned long timestamp, int tz,
 501                const char *message, void *cb_data)
 502{
 503        struct object *obj;
 504
 505        if (verbose)
 506                fprintf(stderr, "Checking reflog %s->%s\n",
 507                        sha1_to_hex(osha1), sha1_to_hex(nsha1));
 508
 509        if (!is_null_sha1(osha1)) {
 510                obj = lookup_object(osha1);
 511                if (obj) {
 512                        obj->used = 1;
 513                        mark_reachable(obj, REACHABLE);
 514                }
 515        }
 516        obj = lookup_object(nsha1);
 517        if (obj) {
 518                obj->used = 1;
 519                mark_reachable(obj, REACHABLE);
 520        }
 521        return 0;
 522}
 523
 524static int fsck_handle_reflog(const char *logname, const unsigned char *sha1, int flag, void *cb_data)
 525{
 526        for_each_reflog_ent(logname, fsck_handle_reflog_ent, NULL);
 527        return 0;
 528}
 529
 530static int fsck_handle_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 531{
 532        struct object *obj;
 533
 534        obj = lookup_object(sha1);
 535        if (!obj) {
 536                if (has_sha1_file(sha1)) {
 537                        default_refs++;
 538                        return 0; /* it is in a pack */
 539                }
 540                error("%s: invalid sha1 pointer %s", refname, sha1_to_hex(sha1));
 541                /* We'll continue with the rest despite the error.. */
 542                return 0;
 543        }
 544        default_refs++;
 545        obj->used = 1;
 546        mark_reachable(obj, REACHABLE);
 547
 548        return 0;
 549}
 550
 551static void get_default_heads(void)
 552{
 553        for_each_ref(fsck_handle_ref, NULL);
 554        if (include_reflogs)
 555                for_each_reflog(fsck_handle_reflog, NULL);
 556
 557        /*
 558         * Not having any default heads isn't really fatal, but
 559         * it does mean that "--unreachable" no longer makes any
 560         * sense (since in this case everything will obviously
 561         * be unreachable by definition.
 562         *
 563         * Showing dangling objects is valid, though (as those
 564         * dangling objects are likely lost heads).
 565         *
 566         * So we just print a warning about it, and clear the
 567         * "show_unreachable" flag.
 568         */
 569        if (!default_refs) {
 570                fprintf(stderr, "notice: No default references\n");
 571                show_unreachable = 0;
 572        }
 573}
 574
 575static void fsck_object_dir(const char *path)
 576{
 577        int i;
 578
 579        if (verbose)
 580                fprintf(stderr, "Checking object directory\n");
 581
 582        for (i = 0; i < 256; i++) {
 583                static char dir[4096];
 584                sprintf(dir, "%s/%02x", path, i);
 585                fsck_dir(i, dir);
 586        }
 587        fsck_sha1_list();
 588}
 589
 590static int fsck_head_link(void)
 591{
 592        unsigned char sha1[20];
 593        int flag;
 594        int null_is_error = 0;
 595        const char *head_points_at = resolve_ref("HEAD", sha1, 0, &flag);
 596
 597        if (verbose)
 598                fprintf(stderr, "Checking HEAD link\n");
 599
 600        if (!head_points_at)
 601                return error("Invalid HEAD");
 602        if (!strcmp(head_points_at, "HEAD"))
 603                /* detached HEAD */
 604                null_is_error = 1;
 605        else if (prefixcmp(head_points_at, "refs/heads/"))
 606                return error("HEAD points to something strange (%s)",
 607                             head_points_at);
 608        if (is_null_sha1(sha1)) {
 609                if (null_is_error)
 610                        return error("HEAD: detached HEAD points at nothing");
 611                fprintf(stderr, "notice: HEAD points to an unborn branch (%s)\n",
 612                        head_points_at + 11);
 613        }
 614        return 0;
 615}
 616
 617static int fsck_cache_tree(struct cache_tree *it)
 618{
 619        int i;
 620        int err = 0;
 621
 622        if (verbose)
 623                fprintf(stderr, "Checking cache tree\n");
 624
 625        if (0 <= it->entry_count) {
 626                struct object *obj = parse_object(it->sha1);
 627                if (!obj) {
 628                        error("%s: invalid sha1 pointer in cache-tree",
 629                              sha1_to_hex(it->sha1));
 630                        return 1;
 631                }
 632                mark_reachable(obj, REACHABLE);
 633                obj->used = 1;
 634                if (obj->type != OBJ_TREE)
 635                        err |= objerror(obj, "non-tree in cache-tree");
 636        }
 637        for (i = 0; i < it->subtree_nr; i++)
 638                err |= fsck_cache_tree(it->down[i]->cache_tree);
 639        return err;
 640}
 641
 642static const char fsck_usage[] =
 643"git-fsck [--tags] [--root] [[--unreachable] [--cache] [--full] "
 644"[--strict] [--verbose] <head-sha1>*]";
 645
 646int cmd_fsck(int argc, char **argv, const char *prefix)
 647{
 648        int i, heads;
 649
 650        track_object_refs = 1;
 651        errors_found = 0;
 652
 653        for (i = 1; i < argc; i++) {
 654                const char *arg = argv[i];
 655
 656                if (!strcmp(arg, "--unreachable")) {
 657                        show_unreachable = 1;
 658                        continue;
 659                }
 660                if (!strcmp(arg, "--tags")) {
 661                        show_tags = 1;
 662                        continue;
 663                }
 664                if (!strcmp(arg, "--root")) {
 665                        show_root = 1;
 666                        continue;
 667                }
 668                if (!strcmp(arg, "--cache")) {
 669                        keep_cache_objects = 1;
 670                        continue;
 671                }
 672                if (!strcmp(arg, "--no-reflogs")) {
 673                        include_reflogs = 0;
 674                        continue;
 675                }
 676                if (!strcmp(arg, "--full")) {
 677                        check_full = 1;
 678                        continue;
 679                }
 680                if (!strcmp(arg, "--strict")) {
 681                        check_strict = 1;
 682                        continue;
 683                }
 684                if (!strcmp(arg, "--verbose")) {
 685                        verbose = 1;
 686                        continue;
 687                }
 688                if (*arg == '-')
 689                        usage(fsck_usage);
 690        }
 691
 692        fsck_head_link();
 693        fsck_object_dir(get_object_directory());
 694        if (check_full) {
 695                struct alternate_object_database *alt;
 696                struct packed_git *p;
 697                prepare_alt_odb();
 698                for (alt = alt_odb_list; alt; alt = alt->next) {
 699                        char namebuf[PATH_MAX];
 700                        int namelen = alt->name - alt->base;
 701                        memcpy(namebuf, alt->base, namelen);
 702                        namebuf[namelen - 1] = 0;
 703                        fsck_object_dir(namebuf);
 704                }
 705                prepare_packed_git();
 706                for (p = packed_git; p; p = p->next)
 707                        /* verify gives error messages itself */
 708                        verify_pack(p, 0);
 709
 710                for (p = packed_git; p; p = p->next) {
 711                        uint32_t i, num;
 712                        if (open_pack_index(p))
 713                                continue;
 714                        num = p->num_objects;
 715                        for (i = 0; i < num; i++)
 716                                fsck_sha1(nth_packed_object_sha1(p, i));
 717                }
 718        }
 719
 720        heads = 0;
 721        for (i = 1; i < argc; i++) {
 722                const char *arg = argv[i];
 723
 724                if (*arg == '-')
 725                        continue;
 726
 727                if (!get_sha1(arg, head_sha1)) {
 728                        struct object *obj = lookup_object(head_sha1);
 729
 730                        /* Error is printed by lookup_object(). */
 731                        if (!obj)
 732                                continue;
 733
 734                        obj->used = 1;
 735                        mark_reachable(obj, REACHABLE);
 736                        heads++;
 737                        continue;
 738                }
 739                error("invalid parameter: expected sha1, got '%s'", arg);
 740        }
 741
 742        /*
 743         * If we've not been given any explicit head information, do the
 744         * default ones from .git/refs. We also consider the index file
 745         * in this case (ie this implies --cache).
 746         */
 747        if (!heads) {
 748                get_default_heads();
 749                keep_cache_objects = 1;
 750        }
 751
 752        if (keep_cache_objects) {
 753                int i;
 754                read_cache();
 755                for (i = 0; i < active_nr; i++) {
 756                        unsigned int mode;
 757                        struct blob *blob;
 758                        struct object *obj;
 759
 760                        mode = ntohl(active_cache[i]->ce_mode);
 761                        if (S_ISGITLINK(mode))
 762                                continue;
 763                        blob = lookup_blob(active_cache[i]->sha1);
 764                        if (!blob)
 765                                continue;
 766                        obj = &blob->object;
 767                        obj->used = 1;
 768                        mark_reachable(obj, REACHABLE);
 769                }
 770                if (active_cache_tree)
 771                        fsck_cache_tree(active_cache_tree);
 772        }
 773
 774        check_connectivity();
 775        return errors_found;
 776}