cache-tree.con commit Merge remote-tracking branch 'git-po/maint' (b82ef32)
   1#include "cache.h"
   2#include "lockfile.h"
   3#include "tree.h"
   4#include "tree-walk.h"
   5#include "cache-tree.h"
   6
   7#ifndef DEBUG
   8#define DEBUG 0
   9#endif
  10
  11struct cache_tree *cache_tree(void)
  12{
  13        struct cache_tree *it = xcalloc(1, sizeof(struct cache_tree));
  14        it->entry_count = -1;
  15        return it;
  16}
  17
  18void cache_tree_free(struct cache_tree **it_p)
  19{
  20        int i;
  21        struct cache_tree *it = *it_p;
  22
  23        if (!it)
  24                return;
  25        for (i = 0; i < it->subtree_nr; i++)
  26                if (it->down[i]) {
  27                        cache_tree_free(&it->down[i]->cache_tree);
  28                        free(it->down[i]);
  29                }
  30        free(it->down);
  31        free(it);
  32        *it_p = NULL;
  33}
  34
  35static int subtree_name_cmp(const char *one, int onelen,
  36                            const char *two, int twolen)
  37{
  38        if (onelen < twolen)
  39                return -1;
  40        if (twolen < onelen)
  41                return 1;
  42        return memcmp(one, two, onelen);
  43}
  44
  45static int subtree_pos(struct cache_tree *it, const char *path, int pathlen)
  46{
  47        struct cache_tree_sub **down = it->down;
  48        int lo, hi;
  49        lo = 0;
  50        hi = it->subtree_nr;
  51        while (lo < hi) {
  52                int mi = lo + (hi - lo) / 2;
  53                struct cache_tree_sub *mdl = down[mi];
  54                int cmp = subtree_name_cmp(path, pathlen,
  55                                           mdl->name, mdl->namelen);
  56                if (!cmp)
  57                        return mi;
  58                if (cmp < 0)
  59                        hi = mi;
  60                else
  61                        lo = mi + 1;
  62        }
  63        return -lo-1;
  64}
  65
  66static struct cache_tree_sub *find_subtree(struct cache_tree *it,
  67                                           const char *path,
  68                                           int pathlen,
  69                                           int create)
  70{
  71        struct cache_tree_sub *down;
  72        int pos = subtree_pos(it, path, pathlen);
  73        if (0 <= pos)
  74                return it->down[pos];
  75        if (!create)
  76                return NULL;
  77
  78        pos = -pos-1;
  79        ALLOC_GROW(it->down, it->subtree_nr + 1, it->subtree_alloc);
  80        it->subtree_nr++;
  81
  82        FLEX_ALLOC_MEM(down, name, path, pathlen);
  83        down->cache_tree = NULL;
  84        down->namelen = pathlen;
  85
  86        if (pos < it->subtree_nr)
  87                MOVE_ARRAY(it->down + pos + 1, it->down + pos,
  88                           it->subtree_nr - pos - 1);
  89        it->down[pos] = down;
  90        return down;
  91}
  92
  93struct cache_tree_sub *cache_tree_sub(struct cache_tree *it, const char *path)
  94{
  95        int pathlen = strlen(path);
  96        return find_subtree(it, path, pathlen, 1);
  97}
  98
  99static int do_invalidate_path(struct cache_tree *it, const char *path)
 100{
 101        /* a/b/c
 102         * ==> invalidate self
 103         * ==> find "a", have it invalidate "b/c"
 104         * a
 105         * ==> invalidate self
 106         * ==> if "a" exists as a subtree, remove it.
 107         */
 108        const char *slash;
 109        int namelen;
 110        struct cache_tree_sub *down;
 111
 112#if DEBUG
 113        fprintf(stderr, "cache-tree invalidate <%s>\n", path);
 114#endif
 115
 116        if (!it)
 117                return 0;
 118        slash = strchrnul(path, '/');
 119        namelen = slash - path;
 120        it->entry_count = -1;
 121        if (!*slash) {
 122                int pos;
 123                pos = subtree_pos(it, path, namelen);
 124                if (0 <= pos) {
 125                        cache_tree_free(&it->down[pos]->cache_tree);
 126                        free(it->down[pos]);
 127                        /* 0 1 2 3 4 5
 128                         *       ^     ^subtree_nr = 6
 129                         *       pos
 130                         * move 4 and 5 up one place (2 entries)
 131                         * 2 = 6 - 3 - 1 = subtree_nr - pos - 1
 132                         */
 133                        MOVE_ARRAY(it->down + pos, it->down + pos + 1,
 134                                   it->subtree_nr - pos - 1);
 135                        it->subtree_nr--;
 136                }
 137                return 1;
 138        }
 139        down = find_subtree(it, path, namelen, 0);
 140        if (down)
 141                do_invalidate_path(down->cache_tree, slash + 1);
 142        return 1;
 143}
 144
 145void cache_tree_invalidate_path(struct index_state *istate, const char *path)
 146{
 147        if (do_invalidate_path(istate->cache_tree, path))
 148                istate->cache_changed |= CACHE_TREE_CHANGED;
 149}
 150
 151static int verify_cache(struct cache_entry **cache,
 152                        int entries, int flags)
 153{
 154        int i, funny;
 155        int silent = flags & WRITE_TREE_SILENT;
 156
 157        /* Verify that the tree is merged */
 158        funny = 0;
 159        for (i = 0; i < entries; i++) {
 160                const struct cache_entry *ce = cache[i];
 161                if (ce_stage(ce)) {
 162                        if (silent)
 163                                return -1;
 164                        if (10 < ++funny) {
 165                                fprintf(stderr, "...\n");
 166                                break;
 167                        }
 168                        fprintf(stderr, "%s: unmerged (%s)\n",
 169                                ce->name, oid_to_hex(&ce->oid));
 170                }
 171        }
 172        if (funny)
 173                return -1;
 174
 175        /* Also verify that the cache does not have path and path/file
 176         * at the same time.  At this point we know the cache has only
 177         * stage 0 entries.
 178         */
 179        funny = 0;
 180        for (i = 0; i < entries - 1; i++) {
 181                /* path/file always comes after path because of the way
 182                 * the cache is sorted.  Also path can appear only once,
 183                 * which means conflicting one would immediately follow.
 184                 */
 185                const char *this_name = cache[i]->name;
 186                const char *next_name = cache[i+1]->name;
 187                int this_len = strlen(this_name);
 188                if (this_len < strlen(next_name) &&
 189                    strncmp(this_name, next_name, this_len) == 0 &&
 190                    next_name[this_len] == '/') {
 191                        if (10 < ++funny) {
 192                                fprintf(stderr, "...\n");
 193                                break;
 194                        }
 195                        fprintf(stderr, "You have both %s and %s\n",
 196                                this_name, next_name);
 197                }
 198        }
 199        if (funny)
 200                return -1;
 201        return 0;
 202}
 203
 204static void discard_unused_subtrees(struct cache_tree *it)
 205{
 206        struct cache_tree_sub **down = it->down;
 207        int nr = it->subtree_nr;
 208        int dst, src;
 209        for (dst = src = 0; src < nr; src++) {
 210                struct cache_tree_sub *s = down[src];
 211                if (s->used)
 212                        down[dst++] = s;
 213                else {
 214                        cache_tree_free(&s->cache_tree);
 215                        free(s);
 216                        it->subtree_nr--;
 217                }
 218        }
 219}
 220
 221int cache_tree_fully_valid(struct cache_tree *it)
 222{
 223        int i;
 224        if (!it)
 225                return 0;
 226        if (it->entry_count < 0 || !has_sha1_file(it->oid.hash))
 227                return 0;
 228        for (i = 0; i < it->subtree_nr; i++) {
 229                if (!cache_tree_fully_valid(it->down[i]->cache_tree))
 230                        return 0;
 231        }
 232        return 1;
 233}
 234
 235static int update_one(struct cache_tree *it,
 236                      struct cache_entry **cache,
 237                      int entries,
 238                      const char *base,
 239                      int baselen,
 240                      int *skip_count,
 241                      int flags)
 242{
 243        struct strbuf buffer;
 244        int missing_ok = flags & WRITE_TREE_MISSING_OK;
 245        int dryrun = flags & WRITE_TREE_DRY_RUN;
 246        int repair = flags & WRITE_TREE_REPAIR;
 247        int to_invalidate = 0;
 248        int i;
 249
 250        assert(!(dryrun && repair));
 251
 252        *skip_count = 0;
 253
 254        if (0 <= it->entry_count && has_sha1_file(it->oid.hash))
 255                return it->entry_count;
 256
 257        /*
 258         * We first scan for subtrees and update them; we start by
 259         * marking existing subtrees -- the ones that are unmarked
 260         * should not be in the result.
 261         */
 262        for (i = 0; i < it->subtree_nr; i++)
 263                it->down[i]->used = 0;
 264
 265        /*
 266         * Find the subtrees and update them.
 267         */
 268        i = 0;
 269        while (i < entries) {
 270                const struct cache_entry *ce = cache[i];
 271                struct cache_tree_sub *sub;
 272                const char *path, *slash;
 273                int pathlen, sublen, subcnt, subskip;
 274
 275                path = ce->name;
 276                pathlen = ce_namelen(ce);
 277                if (pathlen <= baselen || memcmp(base, path, baselen))
 278                        break; /* at the end of this level */
 279
 280                slash = strchr(path + baselen, '/');
 281                if (!slash) {
 282                        i++;
 283                        continue;
 284                }
 285                /*
 286                 * a/bbb/c (base = a/, slash = /c)
 287                 * ==>
 288                 * path+baselen = bbb/c, sublen = 3
 289                 */
 290                sublen = slash - (path + baselen);
 291                sub = find_subtree(it, path + baselen, sublen, 1);
 292                if (!sub->cache_tree)
 293                        sub->cache_tree = cache_tree();
 294                subcnt = update_one(sub->cache_tree,
 295                                    cache + i, entries - i,
 296                                    path,
 297                                    baselen + sublen + 1,
 298                                    &subskip,
 299                                    flags);
 300                if (subcnt < 0)
 301                        return subcnt;
 302                if (!subcnt)
 303                        die("index cache-tree records empty sub-tree");
 304                i += subcnt;
 305                sub->count = subcnt; /* to be used in the next loop */
 306                *skip_count += subskip;
 307                sub->used = 1;
 308        }
 309
 310        discard_unused_subtrees(it);
 311
 312        /*
 313         * Then write out the tree object for this level.
 314         */
 315        strbuf_init(&buffer, 8192);
 316
 317        i = 0;
 318        while (i < entries) {
 319                const struct cache_entry *ce = cache[i];
 320                struct cache_tree_sub *sub = NULL;
 321                const char *path, *slash;
 322                int pathlen, entlen;
 323                const unsigned char *sha1;
 324                unsigned mode;
 325                int expected_missing = 0;
 326                int contains_ita = 0;
 327
 328                path = ce->name;
 329                pathlen = ce_namelen(ce);
 330                if (pathlen <= baselen || memcmp(base, path, baselen))
 331                        break; /* at the end of this level */
 332
 333                slash = strchr(path + baselen, '/');
 334                if (slash) {
 335                        entlen = slash - (path + baselen);
 336                        sub = find_subtree(it, path + baselen, entlen, 0);
 337                        if (!sub)
 338                                die("cache-tree.c: '%.*s' in '%s' not found",
 339                                    entlen, path + baselen, path);
 340                        i += sub->count;
 341                        sha1 = sub->cache_tree->oid.hash;
 342                        mode = S_IFDIR;
 343                        contains_ita = sub->cache_tree->entry_count < 0;
 344                        if (contains_ita) {
 345                                to_invalidate = 1;
 346                                expected_missing = 1;
 347                        }
 348                }
 349                else {
 350                        sha1 = ce->oid.hash;
 351                        mode = ce->ce_mode;
 352                        entlen = pathlen - baselen;
 353                        i++;
 354                }
 355
 356                if (is_null_sha1(sha1) ||
 357                    (mode != S_IFGITLINK && !missing_ok && !has_sha1_file(sha1))) {
 358                        strbuf_release(&buffer);
 359                        if (expected_missing)
 360                                return -1;
 361                        return error("invalid object %06o %s for '%.*s'",
 362                                mode, sha1_to_hex(sha1), entlen+baselen, path);
 363                }
 364
 365                /*
 366                 * CE_REMOVE entries are removed before the index is
 367                 * written to disk. Skip them to remain consistent
 368                 * with the future on-disk index.
 369                 */
 370                if (ce->ce_flags & CE_REMOVE) {
 371                        *skip_count = *skip_count + 1;
 372                        continue;
 373                }
 374
 375                /*
 376                 * CE_INTENT_TO_ADD entries exist on on-disk index but
 377                 * they are not part of generated trees. Invalidate up
 378                 * to root to force cache-tree users to read elsewhere.
 379                 */
 380                if (!sub && ce_intent_to_add(ce)) {
 381                        to_invalidate = 1;
 382                        continue;
 383                }
 384
 385                /*
 386                 * "sub" can be an empty tree if all subentries are i-t-a.
 387                 */
 388                if (contains_ita && !hashcmp(sha1, EMPTY_TREE_SHA1_BIN))
 389                        continue;
 390
 391                strbuf_grow(&buffer, entlen + 100);
 392                strbuf_addf(&buffer, "%o %.*s%c", mode, entlen, path + baselen, '\0');
 393                strbuf_add(&buffer, sha1, 20);
 394
 395#if DEBUG
 396                fprintf(stderr, "cache-tree update-one %o %.*s\n",
 397                        mode, entlen, path + baselen);
 398#endif
 399        }
 400
 401        if (repair) {
 402                struct object_id oid;
 403                hash_object_file(buffer.buf, buffer.len, tree_type, &oid);
 404                if (has_sha1_file(oid.hash))
 405                        oidcpy(&it->oid, &oid);
 406                else
 407                        to_invalidate = 1;
 408        } else if (dryrun) {
 409                hash_object_file(buffer.buf, buffer.len, tree_type, &it->oid);
 410        } else if (write_object_file(buffer.buf, buffer.len, tree_type,
 411                                     &it->oid)) {
 412                strbuf_release(&buffer);
 413                return -1;
 414        }
 415
 416        strbuf_release(&buffer);
 417        it->entry_count = to_invalidate ? -1 : i - *skip_count;
 418#if DEBUG
 419        fprintf(stderr, "cache-tree update-one (%d ent, %d subtree) %s\n",
 420                it->entry_count, it->subtree_nr,
 421                oid_to_hex(&it->oid));
 422#endif
 423        return i;
 424}
 425
 426int cache_tree_update(struct index_state *istate, int flags)
 427{
 428        struct cache_tree *it = istate->cache_tree;
 429        struct cache_entry **cache = istate->cache;
 430        int entries = istate->cache_nr;
 431        int skip, i = verify_cache(cache, entries, flags);
 432
 433        if (i)
 434                return i;
 435        i = update_one(it, cache, entries, "", 0, &skip, flags);
 436        if (i < 0)
 437                return i;
 438        istate->cache_changed |= CACHE_TREE_CHANGED;
 439        return 0;
 440}
 441
 442static void write_one(struct strbuf *buffer, struct cache_tree *it,
 443                      const char *path, int pathlen)
 444{
 445        int i;
 446
 447        /* One "cache-tree" entry consists of the following:
 448         * path (NUL terminated)
 449         * entry_count, subtree_nr ("%d %d\n")
 450         * tree-sha1 (missing if invalid)
 451         * subtree_nr "cache-tree" entries for subtrees.
 452         */
 453        strbuf_grow(buffer, pathlen + 100);
 454        strbuf_add(buffer, path, pathlen);
 455        strbuf_addf(buffer, "%c%d %d\n", 0, it->entry_count, it->subtree_nr);
 456
 457#if DEBUG
 458        if (0 <= it->entry_count)
 459                fprintf(stderr, "cache-tree <%.*s> (%d ent, %d subtree) %s\n",
 460                        pathlen, path, it->entry_count, it->subtree_nr,
 461                        oid_to_hex(&it->oid));
 462        else
 463                fprintf(stderr, "cache-tree <%.*s> (%d subtree) invalid\n",
 464                        pathlen, path, it->subtree_nr);
 465#endif
 466
 467        if (0 <= it->entry_count) {
 468                strbuf_add(buffer, it->oid.hash, 20);
 469        }
 470        for (i = 0; i < it->subtree_nr; i++) {
 471                struct cache_tree_sub *down = it->down[i];
 472                if (i) {
 473                        struct cache_tree_sub *prev = it->down[i-1];
 474                        if (subtree_name_cmp(down->name, down->namelen,
 475                                             prev->name, prev->namelen) <= 0)
 476                                die("fatal - unsorted cache subtree");
 477                }
 478                write_one(buffer, down->cache_tree, down->name, down->namelen);
 479        }
 480}
 481
 482void cache_tree_write(struct strbuf *sb, struct cache_tree *root)
 483{
 484        write_one(sb, root, "", 0);
 485}
 486
 487static struct cache_tree *read_one(const char **buffer, unsigned long *size_p)
 488{
 489        const char *buf = *buffer;
 490        unsigned long size = *size_p;
 491        const char *cp;
 492        char *ep;
 493        struct cache_tree *it;
 494        int i, subtree_nr;
 495
 496        it = NULL;
 497        /* skip name, but make sure name exists */
 498        while (size && *buf) {
 499                size--;
 500                buf++;
 501        }
 502        if (!size)
 503                goto free_return;
 504        buf++; size--;
 505        it = cache_tree();
 506
 507        cp = buf;
 508        it->entry_count = strtol(cp, &ep, 10);
 509        if (cp == ep)
 510                goto free_return;
 511        cp = ep;
 512        subtree_nr = strtol(cp, &ep, 10);
 513        if (cp == ep)
 514                goto free_return;
 515        while (size && *buf && *buf != '\n') {
 516                size--;
 517                buf++;
 518        }
 519        if (!size)
 520                goto free_return;
 521        buf++; size--;
 522        if (0 <= it->entry_count) {
 523                if (size < 20)
 524                        goto free_return;
 525                hashcpy(it->oid.hash, (const unsigned char*)buf);
 526                buf += 20;
 527                size -= 20;
 528        }
 529
 530#if DEBUG
 531        if (0 <= it->entry_count)
 532                fprintf(stderr, "cache-tree <%s> (%d ent, %d subtree) %s\n",
 533                        *buffer, it->entry_count, subtree_nr,
 534                        oid_to_hex(&it->oid));
 535        else
 536                fprintf(stderr, "cache-tree <%s> (%d subtrees) invalid\n",
 537                        *buffer, subtree_nr);
 538#endif
 539
 540        /*
 541         * Just a heuristic -- we do not add directories that often but
 542         * we do not want to have to extend it immediately when we do,
 543         * hence +2.
 544         */
 545        it->subtree_alloc = subtree_nr + 2;
 546        it->down = xcalloc(it->subtree_alloc, sizeof(struct cache_tree_sub *));
 547        for (i = 0; i < subtree_nr; i++) {
 548                /* read each subtree */
 549                struct cache_tree *sub;
 550                struct cache_tree_sub *subtree;
 551                const char *name = buf;
 552
 553                sub = read_one(&buf, &size);
 554                if (!sub)
 555                        goto free_return;
 556                subtree = cache_tree_sub(it, name);
 557                subtree->cache_tree = sub;
 558        }
 559        if (subtree_nr != it->subtree_nr)
 560                die("cache-tree: internal error");
 561        *buffer = buf;
 562        *size_p = size;
 563        return it;
 564
 565 free_return:
 566        cache_tree_free(&it);
 567        return NULL;
 568}
 569
 570struct cache_tree *cache_tree_read(const char *buffer, unsigned long size)
 571{
 572        if (buffer[0])
 573                return NULL; /* not the whole tree */
 574        return read_one(&buffer, &size);
 575}
 576
 577static struct cache_tree *cache_tree_find(struct cache_tree *it, const char *path)
 578{
 579        if (!it)
 580                return NULL;
 581        while (*path) {
 582                const char *slash;
 583                struct cache_tree_sub *sub;
 584
 585                slash = strchrnul(path, '/');
 586                /*
 587                 * Between path and slash is the name of the subtree
 588                 * to look for.
 589                 */
 590                sub = find_subtree(it, path, slash - path, 0);
 591                if (!sub)
 592                        return NULL;
 593                it = sub->cache_tree;
 594
 595                path = slash;
 596                while (*path == '/')
 597                        path++;
 598        }
 599        return it;
 600}
 601
 602int write_index_as_tree(unsigned char *sha1, struct index_state *index_state, const char *index_path, int flags, const char *prefix)
 603{
 604        int entries, was_valid;
 605        struct lock_file lock_file = LOCK_INIT;
 606        int ret = 0;
 607
 608        hold_lock_file_for_update(&lock_file, index_path, LOCK_DIE_ON_ERROR);
 609
 610        entries = read_index_from(index_state, index_path, get_git_dir());
 611        if (entries < 0) {
 612                ret = WRITE_TREE_UNREADABLE_INDEX;
 613                goto out;
 614        }
 615        if (flags & WRITE_TREE_IGNORE_CACHE_TREE)
 616                cache_tree_free(&index_state->cache_tree);
 617
 618        if (!index_state->cache_tree)
 619                index_state->cache_tree = cache_tree();
 620
 621        was_valid = cache_tree_fully_valid(index_state->cache_tree);
 622        if (!was_valid) {
 623                if (cache_tree_update(index_state, flags) < 0) {
 624                        ret = WRITE_TREE_UNMERGED_INDEX;
 625                        goto out;
 626                }
 627                write_locked_index(index_state, &lock_file, COMMIT_LOCK);
 628                /* Not being able to write is fine -- we are only interested
 629                 * in updating the cache-tree part, and if the next caller
 630                 * ends up using the old index with unupdated cache-tree part
 631                 * it misses the work we did here, but that is just a
 632                 * performance penalty and not a big deal.
 633                 */
 634        }
 635
 636        if (prefix) {
 637                struct cache_tree *subtree;
 638                subtree = cache_tree_find(index_state->cache_tree, prefix);
 639                if (!subtree) {
 640                        ret = WRITE_TREE_PREFIX_ERROR;
 641                        goto out;
 642                }
 643                hashcpy(sha1, subtree->oid.hash);
 644        }
 645        else
 646                hashcpy(sha1, index_state->cache_tree->oid.hash);
 647
 648out:
 649        rollback_lock_file(&lock_file);
 650        return ret;
 651}
 652
 653int write_cache_as_tree(unsigned char *sha1, int flags, const char *prefix)
 654{
 655        return write_index_as_tree(sha1, &the_index, get_index_file(), flags, prefix);
 656}
 657
 658static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
 659{
 660        struct tree_desc desc;
 661        struct name_entry entry;
 662        int cnt;
 663
 664        oidcpy(&it->oid, &tree->object.oid);
 665        init_tree_desc(&desc, tree->buffer, tree->size);
 666        cnt = 0;
 667        while (tree_entry(&desc, &entry)) {
 668                if (!S_ISDIR(entry.mode))
 669                        cnt++;
 670                else {
 671                        struct cache_tree_sub *sub;
 672                        struct tree *subtree = lookup_tree(entry.oid);
 673                        if (!subtree->object.parsed)
 674                                parse_tree(subtree);
 675                        sub = cache_tree_sub(it, entry.path);
 676                        sub->cache_tree = cache_tree();
 677                        prime_cache_tree_rec(sub->cache_tree, subtree);
 678                        cnt += sub->cache_tree->entry_count;
 679                }
 680        }
 681        it->entry_count = cnt;
 682}
 683
 684void prime_cache_tree(struct index_state *istate, struct tree *tree)
 685{
 686        cache_tree_free(&istate->cache_tree);
 687        istate->cache_tree = cache_tree();
 688        prime_cache_tree_rec(istate->cache_tree, tree);
 689        istate->cache_changed |= CACHE_TREE_CHANGED;
 690}
 691
 692/*
 693 * find the cache_tree that corresponds to the current level without
 694 * exploding the full path into textual form.  The root of the
 695 * cache tree is given as "root", and our current level is "info".
 696 * (1) When at root level, info->prev is NULL, so it is "root" itself.
 697 * (2) Otherwise, find the cache_tree that corresponds to one level
 698 *     above us, and find ourselves in there.
 699 */
 700static struct cache_tree *find_cache_tree_from_traversal(struct cache_tree *root,
 701                                                         struct traverse_info *info)
 702{
 703        struct cache_tree *our_parent;
 704
 705        if (!info->prev)
 706                return root;
 707        our_parent = find_cache_tree_from_traversal(root, info->prev);
 708        return cache_tree_find(our_parent, info->name.path);
 709}
 710
 711int cache_tree_matches_traversal(struct cache_tree *root,
 712                                 struct name_entry *ent,
 713                                 struct traverse_info *info)
 714{
 715        struct cache_tree *it;
 716
 717        it = find_cache_tree_from_traversal(root, info);
 718        it = cache_tree_find(it, ent->path);
 719        if (it && it->entry_count > 0 && !oidcmp(ent->oid, &it->oid))
 720                return it->entry_count;
 721        return 0;
 722}
 723
 724int update_main_cache_tree(int flags)
 725{
 726        if (!the_index.cache_tree)
 727                the_index.cache_tree = cache_tree();
 728        return cache_tree_update(&the_index, flags);
 729}